Sum Problem

2018-04-22 19:59:52

Sum系列的问题是Leetcode上的一个很经典的系列题，这里做一个简单的总结。

• 167. Two Sum II - Input array is sorted

问题描述：

问题求解：

对于已排序的问题，可以使用双指针在O(n)的时间复杂度内完成求解。

    // 已排序数组，返回indices
    public int[] twoSum(int[] numbers, int target) {
        int i = 0;
        int j = numbers.length - 1;
        while (i < j) {
            if (target > numbers[i] + numbers[j]) i++;
            else if (target < numbers[i] + numbers[j]) j--;
            else break;
        }
        return new int[]{i + 1, j + 1};
    }

• 1. Two Sum

问题描述：

问题求解：

可以使用数据结构中的hash来很高效的解决，具体来说，我们可以建立一个hashmap，用来保存数值和其index，遍历数组，如果说hashmap中存在target - nums[i]，由于题目中明确了只有唯一的解，因此就可以直接确定结果，将这两个数的index返回即可。

    public int[] twoSum3(int[] numbers, int target) {
        int[] result = new int[2];
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < numbers.length; i++) {
            if (map.containsKey(target - numbers[i])) {
                result[1] = i + 1;
                result[0] = map.get(target - numbers[i]);
                break;
            }
            map.put(numbers[i], i + 1);
        }
        return result;
    }

• 653. Two Sum IV - Input is a BST

问题描述：

Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such that their sum is equal to the given target.

问题求解：

方法一、很容易想到的是二叉搜索树的中序遍历是一个有序数列，如果我们采用中序遍历一次并保存下来，那么问题就变成了上述的已排序数组求two sum的问题。

代码时间复杂度为O(n)。

    ArrayList<Integer> ls = new ArrayList<>();
    public boolean findTarget(TreeNode root, int k) {
        inOrder(root);
        boolean res = false;
        int i = 0;
        int j = ls.size() - 1;
        while (i < j) {
            if (ls.get(i) + ls.get(j) > k) j--;
            else if (ls.get(i) + ls.get(j) < k) i++;
            else {
                res = true;
                break;
            }
        }
        return res;
    }

    void inOrder(TreeNode root) {
        if (root != null) {
            inOrder(root.left);
            ls.add(root.val);
            inOrder(root.right);
        }
    }

方法二、递归遍历，每次递归到某个数就对target - nums[i]进行查找，值得注意的是，在查找过程中要特别注意不能是当前的数，因为同一个数只能出现一次，因此在传参的时候要把当前的结点信息传进去。

代码时间复杂度从理论上来说应该是O(nlogn)。但由于剪枝效应的存在，所以在实际的运行上还是比较高效的。

    public boolean findTarget(TreeNode root, int k) {
        return dfs(root, root, k);
    }

    private boolean dfs(TreeNode root, TreeNode cur, int k) {
        if(cur == null) return false;
        return search(root, cur, k-cur.val) || dfs(root, cur.left, k) || dfs(root, cur.right, k);
    }

    private boolean search(TreeNode root, TreeNode cur, int target) {
        if(root == null) return false;
        if(target == root.val) return root != cur;
        else if (target > root.val) return search(root.right, cur, target);
        else return search(root.left, cur, target);
    }

• 15. 3Sum

问题描述：

问题求解：

主要的思想就是转化成Two Sum的问题，其中由于结果不能重复，所以我们需要提前对nums进行排序，在排序后，对先后相等的数就可以进行忽略处理了，这样就避免了重复的问题。另外，由于本题中的target = 0，那么在排序后的数组中如果其值大于0，那么也是可以直接排除可能性的，因为其值大于0，其后面的值也必然大于0，因此是不可能存在说三个正数的和为0的。

本题其实也是可以使用dfs + 回溯解决的，但是时间复杂度上会高不少。这里就不多讲解了。

    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 2; i++) {
            if (i == 0 || (nums[i] <= 0 && nums[i] != nums[i - 1])) {
                int sum = 0 - nums[i];
                int l = i + 1;
                int r = nums.length - 1;
                while (l < r) {
                    if (nums[l] + nums[r] == sum) {
                        res.add(Arrays.asList(nums[i], nums[l], nums[r]));
                        while (l < r && nums[l] == nums[l + 1]) l++;
                        while (l < r && nums[r] == nums[r - 1]) r--;
                        l++;
                        r--;
                    }
                    else if (nums[l] + nums[r] < sum) {
                        while(l < r && nums[l] == nums[l + 1]) l++;
                        l++;
                    }
                    else {
                        while(l < r && nums[r - 1] == nums[r]) r--;
                        r--;
                    }
                }
            }
        }
        return res;
    }

• 16. 3Sum Closest

问题描述：

问题求解：

本质上和Three Sum是一样的。

    public int threeSumClosest(int[] nums, int target) {
        int min = Integer.MAX_VALUE;
        int res = Integer.MAX_VALUE;
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 2; i++) {
            if (i == 0 || nums[i] != nums[i - 1]) {
                int sum = target - nums[i];
                int l = i + 1;
                int r = nums.length - 1;
                while (l < r) {
                    if (nums[l] + nums[r] == sum) {
                        return target;
                    }
                    else if (nums[l] + nums[r] < sum) {
                        if (min > sum - (nums[l] + nums[r])) {
                            min = sum - (nums[l] + nums[r]);
                            res = nums[i] + nums[l] + nums[r];
                        };
                        while (l < r && nums[l + 1] == nums[l]) l++;
                        l++;
                    }
                    else {
                        if (min > nums[l] + nums[r] - sum) {
                            min = nums[l] + nums[r] - sum;
                            res = nums[i] + nums[l] + nums[r];
                        };
                        while (l < r && nums[r - 1] == nums[r]) r--;
                        r--;
                    }
                }
            }
        }
        return res;
    }

• 18. 4Sum

问题描述：

问题求解：

转化成Three Sum就好了。

    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 3; i++) {
            if (i == 0 || nums[i] != nums[i - 1]) {
                for (int j = i + 1; j < nums.length - 2; j++) {
                    if (j == i + 1 || nums[j] != nums[j - 1]) {
                        int sum = target - nums[i] - nums[j];
                        int l = j + 1;
                        int r = nums.length - 1;
                        while (l < r) {
                            if (nums[l] + nums[r] == sum) {
                                res.add(Arrays.asList(nums[i], nums[j], nums[l], nums[r]));
                                while (l < r && nums[l + 1] == nums[l]) l++;
                                while (l < r && nums[r - 1] == nums[r]) r--;
                                l++;
                                r--;
                            }
                            else if (nums[l] + nums[r] < sum) {
                                while (l < r && nums[l + 1] == nums[l]) l++;
                                l++;
                            }
                            else {
                                while (l < r && nums[r - 1] == nums[r]) r--;
                                r--;
                            }
                        }
                    }
                }
            }
        }
        return res;
    }

• 416. Partition Equal Subset Sum

问题描述：

问题求解：

其实就是一个背包问题，这里就是在看能不能挑其中n个物品，使其和为sum/2。当然，首先sum应该是偶数，如果sum奇数，那么就可以直接返回结果。

    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i : nums) sum += i;
        if (sum % 2 != 0) return false;
        sum /= 2;
        boolean dp[] = new boolean[sum + 1];
        dp[0] = true;
        for (int num : nums) {
            for (int i = sum; i >= num; i--) {
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[sum];
    }

• 494. Target Sum

问题描述：

问题求解：

方法一、第一个方法就是暴力搜索，回溯枚举。时间复杂度为指数级。

    public int findTargetSumWays(int[] nums, int S) {
        if (nums.length == 0) return 0;
        return helper(nums, 0, S);
    }

    private int helper(int[] nums, int idx, int S) {
        if (idx == nums.length) {
            if (S == 0) return 1;
            else return 0;
        }
        int res = 0;
        res += helper(nums, idx + 1, S + nums[idx]);
        res += helper(nums, idx + 1, S - nums[idx]);
        return res;
    }

方法二、这个方法很有技巧性，实际上是把原问题转化成了求部分和的问题。不妨设＋部分和为Ｐ，－部分和为Ｑ，则P - Q = S，又P + Q = sum，所以得到2P = S + sum。也就是说求解nums中部分和为(S + sum）/ 2的总个数。由于原问题中指出了数字非负性，所以这种方法是可行的。算法的时间复杂度为伪多项式时间复杂度。

必须要多sum 和 S 的大小进行判断，因为S的大小可能远超sum，这个时候如果不加判断会MLE。

    public int findTargetSumWays(int[] nums, int S) {
        int sum = 0;
        for (int i : nums) sum += i;
        if (sum < S || sum + S < 0 || (sum + S) % 2 != 0) return 0;
        return helper(nums, (sum + S) / 2);
    }

    private int helper(int[] nums, int S) {
        int[] dp = new int[S + 1];
        dp[0] = 1;
        for (int num : nums) {
            for (int i = S; i >= num; i--) {
                dp[i] += dp[i - num];
            }
        }
        return dp[S];
    }