算法记录|Day07

Leecode

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。

思路

• 用一个长度为26的数组记录两个字符串中字符出现的次数
• magazine 中的每个字符只能在 ransomNote 中使用一次，所以对于出现在ransomenote中的字母$rans[i]!=0$，在rans…中出现的次数$<=$在maginzine中出现的次数

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
    int[] rans = getKeys(ransomNote);
    int[] mag = getKeys(magazine);

    for(int i=0;i<rans.length;i++){
      if(rans[i]!=0&&rans[i]> mag[i]){
          return false;
      }
    }
    return true;
    }

    public  int[] getKeys(String str){
        int[] keys = new int[26];
        char[] chars = str.toCharArray();
        for(char c:chars){
            keys[c-97]++;
        }
        return keys;
    }

代码随想录中的方法：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        // shortcut
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        // 定义一个哈希映射数组
        int[] record = new int[26];

        // 遍历
        for(char c : magazine.toCharArray()){
            record[c - 'a'] += 1;
        }

        for(char c : ransomNote.toCharArray()){
            record[c - 'a'] -= 1;
        }
        
        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
        for(int i : record){
            if(i < 0){
                return false;
            }
        }

        return true;
    }
}

相同点：都是构建对应的数组
不同点：

//我的方法：
  if(rans[i]!=0&&rans[i]> mag[i]){
          return false;
      }
  //代码随想录：如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
       for(int i : record){
            if(i < 0){
                return false;
            }
        }
/*
mag[i]-rans[i]>0;
如果有小于0的元素就是false;
/*

总结

对于类似的字符，用哈希映射数组的思路

    public  int[] getKeys(String str){
        int[] keys = new int[26];
        char[] chars = str.toCharArray();
        for(char c:chars){
            keys[c-97]++;
            // 或者写成 keys[c-'a']++;
        }
        return keys;
    }

15. 三数之和

这个视频讲的很好

思路

• 基于两数之和，将第一个元素的负数看作后面两数之和的tagert
• 两数据之和使用双指针
  两数之和的思路

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;}
        //答案中不可以包含重复的三元组,所以相同的直接跳过
        //对被当作为target的元素去重
        if(i>0&&nums[i]==nums[i-1]){continue;}

        //开始类似两数相加
        int left = i+1;
        int right = nums.length-1;

        while(right>left){
            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]));
                 // 在移动两个指针之前也要去重
                //我们也需要对left和right对应的元素去重
                while(right>left&&nums[left]==nums[left+1]){left++;}
                while(right>left&&nums[right]==nums[right-1]){right--;}
             //
                left++;
                right--;
            }
        }
    }
return res;
    }
}

总结：

需要记住的函数：
数组转换成集合：Arrays.asList(x,x,x,x);

这道题的关键在于：

• 对数组进行排序，以及对三个元素都要进行去重
• 双指针的思想：对于两层for循环，都可以转换为头尾双指针

for(int i =0;i<nums.length-1;i++){
for(int j =i+1;i<nums.length;i++){
}
}

//转换为双指针：一个在头一个在尾部
int left =0；
int right = nums.length-1;
while(left<right){ // 这里是小于等于还是小于依据题目判断
}

18. 四数之和

思考

• 先把后面三个数想成两个数，对于第一个数还是利用for循环再去重
  需要注意的是：
  在上一题目中，只有$nums[i]>0$是因为target=0

  if(nums[i]>0&&nums[i]>target){break;}

• 然后寻找第二个数，就可以把第一个数和target的和看成一个整体，后三个数就组成了一个新的三数之和。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
    Arrays.sort(nums);
    List<List<Integer>> res = new ArrayList<>();

    for(int i=0;i<nums.length;i++){
        if(nums[i]>0&&nums[i]>target){break;}

        if(i>0&&nums[i]==nums[i-1]){continue;}

    
         //从这里开始理解成三数之和
        
        for(int j = i+1;j<nums.length;j++){
             long sum =(long)nums[j]+nums[i]-target; 

             if(nums[j]>0&&sum>0){break;}

             if(j>i+1&&nums[j] == nums[j-1]){continue;}
             int left = j+1;
             int right = nums.length-1;
             while(left<right){
                 long all = (long)nums[left] + nums[right]+sum;
                 if(all>0){
                     right--;
                 }else if(all<0){
                     left++;
                 }else{

                     res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                     while(right>left&&nums[left]==nums[left+1]){left++;}
                     while(right>left&&nums[right]==nums[right-1]){right--;}
                     left++;
                     right--;
                 }
             }
    }
    }
return res;
}
}

总结

454四数相加
454.四数相加II (opens new window)是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，

• 不用考虑有重复的四个元素相加等于0的情况
• 不需要记录对应的元素值，只需要记录次数