LeetCode有一系列做法套路相同的題目，N數之和就可以算一個
兩數之和
給定一個整數陣列 nums 和一個目標值 target，請你在該陣列中找出和為目標值的那 兩個 整數，並返回他們的陣列下標。
你可以假設每種輸入只會對應一個答案。但是，你不能重複利用這個陣列中同樣的元素。
示例:
給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
第一個解決辦法，簡單暴力，堆for迴圈就是，但是，既然在做LeetCode，肯定不能這樣做啊
第二個就是開闢額外的空間來儲存之前出現過的元素，如果之前當前遍歷到的數字和儲存的數字其中一個能夠相加等於target，那麼返回兩個數的下標。
public int[] twoSum(int[] nums, int target) { HashMap<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < nums.length; i++) { if(map.containsKey(target-nums[i])) return new int[] {map.get(target-nums[i]),i}; map.put(nums[i], i); } return new int[] {0,0}; }
三數之和
給定一個包含 n 個整數的陣列 nums，判斷 nums 中是否存在三個元素 a，b，c ，使得 a + b + c = 0 ？找出所有滿足條件且不重複的三元組。 注意：答案中不可以包含重複的三元組。 例如, 給定陣列 nums = [-1, 0, 1, 2, -1, -4]， 滿足要求的三元組集合為： [ [-1, 0, 1], [-1, -1, 2] ]
第一暴力就不多說了。
第二，這道題有一個很需要考慮的地方，就是要去重，我剛開始就是卡在這裡，因為我習慣性的思維就是想把所有的答案找出來，然後再從結果集裡面去重，後來才發現這樣想著簡單但是實現起來也不容易，因為答案有三個數，判斷三個數重複又是很麻煩的事情，直到看到評論區大佬的程式碼，茅塞頓開，採用三指標，判斷後面兩個指標與第一個指標所指的元素的和是否等於target就行，但是這樣帶來一個問題，因為資料是大小分佈不均的，那麼根據什麼條件判斷指標的移動呢，這裡就得多出一個排序的時間，先將nums排序然後再根據後面兩個指標的和跟target的大小關係來移動指標，同時，需要判斷指標前後的元素是否相同，是則跳過。從而達到去重的目的。
class Solution { public List<List<Integer>> threeSum(int[] nums) { Arrays.sort(nums); List<List<Integer>> ans = new ArrayList<>(); if(nums.length<3) return ans; for(int i = 0;i < nums.length-2;i++){ if(nums[i]>0) return ans; if(i>0&&nums[i-1]==nums[i]) continue; for(int j = i+1,k = nums.length-1;j<k;){ if(j>i+1&&nums[j-1]==nums[j]){ j++; continue; } if(k<nums.length-1&&nums[k+1]==nums[k]){ k--; continue; } int t = nums[i]+nums[j]+nums[k]; //stem.out.println(t); if(t<0) j++; else if(t>0) k--; else if(t==0){ List<Integer> l = new ArrayList<>(); l.add(nums[i]); l.add(nums[j++]); l.add(nums[k--]); ans.add(l); } } } return ans; } }
最接近的三數之和
給定一個包括 n 個整數的陣列 nums 和 一個目標值 target。找出 nums 中的三個整數，使得它們的和與 target 最接近。返回這三個數的和。假定每組輸入只存在唯一答案。 例如，給定陣列 nums = [-1，2，1，-4], 和 target = 1. 與 target 最接近的三個數的和為 2. (-1 + 2 + 1 = 2).
跟三數之和差不多的原理，相當於求三數之和和target之差的絕對值的最小值
public class Solution16 { public static int threeSumClosest(int[] nums, int target) { Arrays.sort(nums); int ans = nums[0]+nums[1]+nums[2]; for (int i = 0; i < nums.length-2; i++) { if(i>0&&nums[i-1]==nums[i])//重複就跳過 continue; //雙指標 int l = i+1; int r = nums.length-1; while(l<r) { int t = nums[i]+nums[l]+nums[r]; if(Math.abs(t-target)<Math.abs(ans-target)) ans = t; if(t>target) r--; else if(t<target) l++; else return target;//等於直接返回 if(l>i+1&&nums[l-1]==nums[l]) l++; if(r<nums.length-1&&nums[r+1]==nums[r]) r--; } } return ans; } public static void main(String[] args) { int[] nums = {1,1,-1,-1,3}; System.out.println(threeSumClosest(nums, 3));; } }
四數之和
給定一個包含 n 個整數的陣列 nums 和一個目標值 target，判斷 nums 中是否存在四個元素 a，b，c 和 d ，使得 a + b + c + d 的值與 target 相等？找出所有滿足條件且不重複的四元組。 注意： 答案中不可以包含重複的四元組。 示例： 給定陣列 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 滿足要求的四元組集合為： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
我的辦法就是由三數之和改進的做法，將第一個數固定，然後判斷這個數後面是否有三數之和。。去重策略也一樣。
先挖個坑在這，回去研究研究，有別的辦法再補上
package com.mine.leetcode; import java.util.*; public class Solution18 { public List<List<Integer>> fourSum(int[] nums, int target) { Arrays.sort(nums);//先排序 List<List<Integer>> ans = new ArrayList<>(); if(nums==null||nums.length==0) return ans; for(int i = 0;i < nums.length-3;i++) { if(i>0&&nums[i-1]==nums[i])//去重 continue; ans.addAll(exitThreeSum(nums,i,target-nums[i]));//找尋此數後面有沒有等於target-自己的陣列 } return ans; } public List<List<Integer>> exitThreeSum(int[] nums,int start,int target) { //三數之和的改進 List<List<Integer>> ans = new ArrayList<>(); for(int i = start+1;i < nums.length-2;i++){ if(i>start+1&&nums[i-1]==nums[i])//去重 continue; for(int j = i+1,k = nums.length-1;j<k;){ if(j>i+1&&nums[j-1]==nums[j]){//去重 j++; continue; } if(k<nums.length-1&&nums[k+1]==nums[k]){//去重 k--; continue; } int t = nums[i]+nums[j]+nums[k]; if(t<target) j++; else if(t>target) k--; else if(t==target){ List<Integer> l = new ArrayList<>(); l.add(nums[start]); l.add(nums[i]); l.add(nums[j++]); l.add(nums[k--]); ans.add(l); } } } return ans; } }
最後，我的LeetCode做題記錄：https://github.com/Yintianhao/AlgorithmPractice