[leetcode]_K Sum 问题

问题：K Sum问题是一个问题系列，在一个数组中找K个数的和能够满足题目中要求。从2 Sum 到 3 Sum , 3 Sum Clozet , 4 Sum。。解法虽一开始不容易想到，但get到解题技能后，该系列的题目其实解法较为单一。

一、核心解题思路。Two Sum。

题目：一个数组a中，找寻两个数，使其和等于target。返回两个数的下标。

思路：最白目的思路是O(n²)解法，无需多言。精彩的解法能够O(n)完成算法。

　　　将该数组进行排序。设置两个指针start,end指向数组的头尾。如果a[start] + a[end] < target，那么将start指针往后移，因为当前的和值比目标值小；反之，将end指针向前移，因为当前的和值比目标值大。直到两个指针相遇，结束查找。

代码：由于要返回两个数的下标，因此在对数组进行排序之前，需要记录数据的原始下标。

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        
        if(numbers.length <= 1) return null;
        
        Pair[] pairs = new Pair[numbers.length];
        for(int i = 0 ; i < numbers.length ; i++){
            pairs[i] = new Pair(numbers[i] , i+1);
        }
        
        Comparator<Pair> comparator = new Comparator<Pair>(){
            public int compare(Pair o1 , Pair o2){
                return o1.val > o2.val ? 1 : -1 ;
            }
        };
        
        Arrays.sort(pairs , comparator);
        
        int index1 = 0 , index2 = numbers.length - 1;
        
        while(index1 < index2){
            int temp = pairs[index1].val + pairs[index2].val;
            if(temp == target) break;
            else if(temp < target) index1++;
            else index2--;
        }
        if(pairs[index1].index < pairs[index2].index)  return new int[]{pairs[index1].index , pairs[index2].index};
        else return new int[]{pairs[index2].index , pairs[index1].index};
    }
}

class Pair{
        int val;
        int index;
        Pair(int x , int y){
            val = x;
            index = y;
        }
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

二、举一反三。3 Sum。

问题：一个数组a，判断其中是否存在三个数a , b , c 使其和为target。返回这些三元组集合。

思路：该问题可退化为 2 Sum问题来解答。先选择任意一个数a ，然后判断剩余数组中是否存在另外两个数的和等于target - a。<----这里就完全是2 Sum问题的方法了。

代码：

public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
        
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        
        Arrays.sort(num);
        
        for(int i = 0 ; i < num.length ; i++){
            int target = 0 - num[i];
            //由于结果要求三元组的值要非递减顺序，因此将数组排序后，从头开始定第一个数据，后两个数据从该数据的后部选取。
            for(int j = i + 1 , k = num.length - 1 ; j < num.length && k >= 0 && j < k ;){
                int temp = num[j] + num[k];
                if(temp == target){
                    
                    boolean ifAdd = true;
        
                    //judge duplicate
                    for(int index = 0 ; index < result.size() ; index++){
                        if(result.get(index).get(0) == num[i] 
                        && result.get(index).get(1) == num[j] 
                        && result.get(index).get(2) == num[k]){
                            ifAdd = false;
                            break;
                        }
                    }
                    if(ifAdd){
                        ArrayList<Integer> one = new ArrayList<Integer>();
                        one.add(num[i]);
                        one.add(num[j]);
                        one.add(num[k]);
                        result.add(one);
                    }
                    j++;
                    
                }else if(temp < target) j++;
                 else k--;
            }
        }
        return result;
    }

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

三、练习熟悉。3 Sum Closest。

题目：给顶一个数组a，求最接近target的三元组的和。输出该和。

思路：完全与3 Sum问题相同。唯一不同的地方在于，因为它是判断与target最接近，因此利用绝对值来判断当前和是否与target最接近。

代码：

public int threeSumClosest(int[] num, int target) {
        
        Arrays.sort(num);
        int min = Integer.MAX_VALUE; 
        
        for(int i = 0 ; i < num.length ; i++){
            
            for(int j = i + 1 , k = num.length - 1 ; j < num.length && k >= 0 && j < k ;){
                int threeSum = num[j] + num[k] + num[i];
                if(threeSum == target) {
                    min = 0;
                    break;
                }else{
                    
                    int dis = target - threeSum;
                    //利用绝对值来判断是否与traget最接近。
                    if(Math.abs(dis) < Math.abs(min)) {
                        min = dis;
                    }
                    
                    if(dis > 0) j++;
                    else k--;
                }
            }
            if(min == 0){
                break;
            }
        }
        return target - min;
    }

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

四、还是练习。4 Sum。

问题：一个数组a,寻找是否存在四个数a + b + c + d = target。返回四元组集合。

思路：先固定住一个数a ， 然后寻找剩余数组中是否存在三个数和 等于 target - a(退化为3Sum)，然后计算三个数和时，再先固定一个数b，然后寻找剩余数组中是否存在两个数和等于target-a -b(退化为2Sum)。

代码：

public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        
        if(num.length <= 3) return result;
        
        Arrays.sort(num);
        
        for(int i = 0 ; i <= num.length - 4 ; i++){
            for(int j = i + 1 ; j <= num.length - 3 ; j++){
                int start = j + 1;
                int end = num.length - 1;
                while(start < end){
                    int temp = num[i] + num[j] + num[start] + num[end];
                    if(temp == target){
                        boolean ifAdd = true;
                        for(int k = 0 ; k < result.size() ; k++){
                            if(result.get(k).get(0) == num[i] && result.get(k).get(1) == num[j]
                            && result.get(k).get(2) == num[start] && result.get(k).get(3) == num[end]){
                                ifAdd = false;
                                break;
                            }
                        }
                        
                        if(ifAdd){
                            ArrayList<Integer> each = new ArrayList<Integer>();
                            each.add(num[i]);
                            each.add(num[j]);
                            each.add(num[start]);
                            each.add(num[end]);
                            result.add(each);
                        }
                        
                        start++;
                        
                    }else if(temp < target) start++;
                     else end--;
                }
            }
        }
        
        return result;
    }

因此，总结K Sum的问题，其核心思路就是2Sum问题，任何K > 2时，都可通过逐层退化，到2Sum。而2Sum问题，在将数据进行排序后，就可通过两个指针来达到要求。