Day 07

最新推荐文章于 2024-09-16 06:54:08 发布

TFMJ

最新推荐文章于 2024-09-16 06:54:08 发布

阅读量89

点赞数

分类专栏： Leetcode 文章标签： leetcode 哈希算法算法

本文链接：https://blog.csdn.net/qq_45669065/article/details/128351116

版权

Leetcode 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

454.四数相加II

map不去重，注意在放入的时候判断之前是否已经放入相应的东西。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

     int temp=0;    
     int res=0;
 
     Map<Integer,Integer> map= new HashMap<>();
     
     for(int i:nums1)
     {
         for(int j:nums2)
         {  temp=i+j;
             if(map.containsKey(temp))
             {
             map.put(temp,map.get(temp)+1);
             }else
            {
                map.put(temp,1);
            }
         }
     }


    for(int i:nums3)
    {
        for(int j:nums4)
        {
            temp=i+j;
            if(map.containsKey(0-temp))
            {
                res+=map.get(0-temp);
            }
        }
    }

    return res;


    }
}

383. 赎金信

str.toCharArray()

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
      int[] record = new int[26];
      
      for(char c:magazine.toCharArray())
      {
          record[c-'a']++;      
      } 

      for(char c: ransomNote.toCharArray())
      {
          record[c-'a']--;    
      }

      for(int i:record)
      {
          if(i<0)
          return false;
      }
    
    return true;

    }
}

15. 三数之和

Arrays.sort()和Arrays.asList()

List<List<Integer>> result = new ArrayList<>();

步骤：1. 创建结果，数组排序

2. for循环遍历每个数。

在循环里首先剪枝，如果i都大于零，不可能和为零，结束；

去重a，判断i>0并且和前一个比，如果相等continue；

开始遍历，设定left和right初始值，当有结果时先去重b c 然后加入result，移动left和right

class Solution {
    public List<List<Integer>> threeSum(int[] nums) 
    {
      List<List<Integer>> result = new ArrayList<>();

      Arrays.sort(nums);

      for(int i=0;i<nums.length;i++)
      {
          if(nums[i]>0)
          {
              return result;
          }
          
          //去重
          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 
            {
                result.add(Arrays.asList(nums[i],nums[left],nums[right]));

                //去重
                while(left<right&&nums[right]==nums[right-1]) right--;
                while(left<right&&nums[left]==nums[left+1]) left++;

                right--;
                left++;
            }     
          }
      }

      return result;
    }
}

18. 四数之和

和三数之和很类似，最外层是遍历循环，然后去重，最后左右指针（注意右指针从最后开始），去重c d如果左右指针一样，减去某个指针再移动左右指针。

（两个剪枝有些许不同）

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) 
    {
       List<List<Integer>> result = new ArrayList<>();
       Arrays.sort(nums);
       
       for(int i=0;i<nums.length;i++)
       {   
       
       //剪枝，注意值本身要大于零
       if(nums[i]>0&&nums[i]>target)
       {
           return result;
       }
       
       //去重a
       if(i>0&&nums[i-1]==nums[i])
       {
           continue;
       }

       for(int j=i+1;j<nums.length;j++)
       {
     
            if(j>i+1&&nums[j-1]==nums[j])
            {
                continue;
            }

            int left = j+1;
            int right = nums.length -1; //从最后开始
            while(right>left)
            {
                long sum=(long) nums[i]+nums[j]+nums[left]+nums[right];
                if(sum>target)
                {
                    right--;
                }
                else if(sum<target)
                {
                    left++;
                }

                else
                {   
                    result.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));

                    while(right>left&&nums[right]==nums[right-1]) right--;
                    while(right>left&&nums[left]==nums[left+1]) left++;

                    left++;
                    right--;
                }
            }
       }

       }
       return result;
    }
}