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)。