数据结构/K Sum求解方法

K sum的求和问题一般是这样子描述的：给你一组N个数字(比如 vector<int> num), 然后给你一个常数(比如 int target) ，我们的goal是在这一堆数里面找到K个数字，使得这K个数字的和等于target。

注意事项(constraints):
注意这一组数字可能有重复项：比如 1 1 2 3 , 求3sum, 然后 target  = 6, 你搜的时候可能会得到 两组1 2 3, 1 2 3，1 来自第一个1或者第二个1, 但是结果其实只有一组，所以最后结果要去重。

K Sum求解方法, 适用leetcode 2Sum, 3Sum, 4Sum：

（1）2sum
方法一： 暴力，就是枚举所有的K-subset, 那么这样的复杂度就是 从N选出K个，复杂度是O(N^K)

方法二： 排序，这个算法可以考虑最简单的case, 2sum，这是个经典问题，方法就是先排序，然后利用头尾指针找到两个数使得他们的和等于target，算法复杂度O(N log N)。2sum的算法复杂度是O(N log N)， 因为排序用了N log N以及头尾指针的搜索是线性的。

/**
 * 在排序的基础上用头尾指针的方法
 */
import java.util.Arrays;
        import java.util.LinkedList;
        import java.util.List;

class Pair{
    int x;
    int y;
    Pair(int xParam, int yParam){
        x = xParam;
        y = yParam;
    }
}

public class TwoSum {

    public static List<Pair> sum(int[] nums, int sum){
        Arrays.sort(nums);
        List<Pair> result = new LinkedList<Pair>();
        // 使用头尾指针
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int num1 = nums[left];
            int num2 = nums[right];
            if(num1 + num2 == sum){
                Pair pair = new Pair(num1, num2);
                result.add(pair);
                //左边有相等的元素
                while(left<right && nums[left] == nums[left+1]){
                    // 左指针右移
                    left ++;
                }
                left ++;
                //右边有相等的元素
                while(right > 0 && nums[right]==nums[right-1]){
                    // 右指针左移
                    right --;
                }
                right --;
            } else if(num1 + num2 > sum){
                while(right > 0 && nums[right]==nums[right-1]){
                    // 右指针左移
                    right --;
                }
                right --;
            } else{
                while(left<right && nums[left] == nums[left+1]){
                    // 左指针右移
                    left ++;
                }
                left ++;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {0,0,0,1,1,12,1,6,4,8,32,86,66,2,3,2,5};
        List<Pair> list = TwoSum.sum(nums, 5);
        for(Pair p: list){
            System.out.println(p.x + " " + p.y);
        }
    }
}https://blog.csdn.net/sloanqin/article/details/51933411

（2）3sum       O(N^2 )

3sum, 有了2sum其实3sum就不难了，这样想：先取出一个数，那么我只要在剩下的数字里面找到两个数字使得他们的和等于(target – 那个取出的数)就可以了吧。所以3sum就退化成了2sum, 取出一个数字，这样的数字有N个，所以3sum的算法复杂度就是O(N^2 ), 注意这里复杂度是N平方，因为你排序只需要排一次，后面的工作都是取出一个数字，然后找剩下的两个数字，找两个数字是2sum用头尾指针线性扫，这里很容易错误的将复杂度算成O(N^2 log N)，这个是不对的。

一次排序O(nlogn),排序之后把target – 那个取出的数作为2sum的新target，所以使用头尾指针的方法O(N^2)，所以3sum最终是O(n^2)。