哈希表
- HashMap
我自己的思路：
1、先把magazine里的字符和出现次数存到map
2、遍历ransomNote的字符，如果没有在map里出现或者出现了次数用完了就返回false，否则返回true
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
Map<Character,Integer> map=new HashMap<>();
for(char ch : magazine.toCharArray()){//把magazine里的字符和出现次数存到map
map.put(ch,map.getOrDefault(ch,0)+1);
}
for(char ch : ransomNote.toCharArray()){
if(map.containsKey(ch)){//存在，则把对应次数-1
map.compute(ch, (key, value) -> value - 1);
if(map.get(ch)<0){//次数用完了就返回false
return false;
}
}else{//不存在直接返回false
return false;
}
}
return true;
}
}
- 方法一：纯哈希
思路挺容易想的，但是去重特别特别复杂，去重想了快一个小时。。。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
for(int i=0; i<nums.length; i++){
if(i > 0 && nums[i] == nums[i -1]){
continue;
}
Set<Integer> set=new HashSet<>();
for(int j=i+1;j<nums.length;j++){
if (j > i + 2
&& nums[j] == nums[j-1]
&& nums[j-1] == nums[j-2]) {
continue;
}
if(!set.contains(nums[j])){
set.add(-nums[i]-nums[j]);
}else{
res.add(Arrays.asList(nums[i],-nums[i]-nums[j],nums[j]));
set.remove(nums[j]);
}
}
}
return res;
}
}
- 方法二：双指针
- 首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
- 依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。
- 接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
- 如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。
去重逻辑的思考
a的去重：当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到 第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到 结果集里。
b和c的去重逻辑和a相似。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
for(int i=0; i<nums.length; i++){
// 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
if (nums[i] > 0) {
break;
}
if(i > 0 && nums[i] == nums[i -1]){//三元组元素a去重
continue;
}
int left=i+1;
int right=nums.length-1;
while(left<right){
int sum=nums[i]+nums[left]+nums[right];
if(sum>0){
right--;
}else if(sum<0){
left++;
}else{
res.add(Arrays.asList(nums[i],nums[left],nums[right]));
//三元组元素b和c去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
}
}
return res;
}
}
- 双指针
- 这题可以直接拿三数之和解法改
四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^2)，四数之和的时间复杂度是O(n^3) 。
要注意的是，不要判断
nums[k] > target就返回了，三数之和 可以通过nums[i] > 0就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
for(int i=0; i<nums.length; i++){
// 排序之后如果第一个元素已经大于target，那么不可能凑成四元组
if (nums[i] > 0 &&nums[i] > target) {//这里要考虑负数的情况
break;
}
if(i > 0 && nums[i] == nums[i -1]){//对nums[i]去重
continue;
}
for(int j=i+1;j<nums.length;j++){
if (j > i + 1 && nums[j - 1] == nums[j]) { // 对nums[j]去重
continue;
}
int left=j+1;
int right=nums.length-1;
while(left<right){
int sum=nums[i]+nums[j]+nums[left]+nums[right];
if(sum>target){
right--;
}else if(sum<target){
left++;
}else{
res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
// 对nums[left]和nums[right]去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
}
}
}
return res;
}
}
