leetcode 剑指 Offer 57

剑指 Offer 57 - II. 和为s的连续正数序列

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]

示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

限制：

1 <= target <= 10^5

解法一：dfs深度优先搜索

思路：

dfs深度优先搜索，每次添加之前先判断temp是否为空或者 temp 是是否包含 i - 1, 

class Solution {
    public int[][] findContinuousSequence(int target) {
        ArrayList<LinkedList<Integer>> res = new ArrayList<LinkedList<Integer>>();
        LinkedList<Integer> temp = new LinkedList<Integer>();
        // 使用dfs将所有的组合都找到并存在res列表中
        dfs(0, target, 0, res, temp);
        //System.out.println(res);
        // 将res中的内容拷贝到一个二维数组中
        int[][] ret = new int[res.size()][];
        for(int i= 0; i < res.size(); i++){
            ret[i] = new int[res.get(i).size()];
            for(int j = 0; j < res.get(i).size(); j++){
                ret[i][j] = res.get(i).get(j);
            }
        }
        return ret;        
    }

    // dfs递归
    public void dfs(int nowSum, int target, int nowNum, ArrayList<LinkedList<Integer>> res, LinkedList<Integer> temp){
        if(nowSum == target){
            res.add(new LinkedList<Integer>(temp));
            return;
        }
        if(nowSum > target){
            return;
        }
        // 尝试添加每个大于当前数字的元素
        for(int i = nowNum + 1; i < target; i++){
            //System.out.println(i);
            // 只能是连续的数字组合
            if((temp.isEmpty() || temp.contains(i-1)) && nowSum + i <= target){
                temp.addLast(i);
                dfs(nowSum + i, target, i, res, temp);
                temp.removeLast();  // 回溯之后消除上次添加元素的影响
            }
        }

    }
}

这个方法当target比较大的时候会超时，只通过了22个测试用例

 解法二：迭代

思路：

迭代, 以1-target/2的所有元素为起点，寻找满足条件的组合

class Solution {
    public int[][] findContinuousSequence(int target) {
        ArrayList<int[]> res = new ArrayList<>();
        
        int sum = 0, limit = target / 2;    // 因为最少两个数，所以上界为target / 2
        for(int i = 1; i <= limit; i++){
            for(int j = i; ; j++){
                sum += j;
                if(sum > target){
                    sum = 0;
                    break;
                }else if(sum == target){
                    int[] arr = new int[j - i + 1];
                    for(int k = i; k <= j; k++){
                        arr[k-i] = k;
                    }
                    res.add(arr);
                }
            }
        }

        return res.toArray(new int[res.size()][]);        
    }
}

leetcode运行时间为8ms, 空间为36.6MB

复杂度分析：

 空间复杂度：除了存储结果的数组只需要常数个变量，所以空间复杂度为O(1)

解法三：滑动窗口

思路：

滑动窗口，这个解法其实是对上个解法的改进，当我们判断到[i,j+1]的元素之和已经大于 target了，解法二是直接从( i + 1)开始，加上(i + 2), 一直到 下次sum 大于 target, 假设区间为 [i+1, k], 但是其实这个区间的[i+1,j]的和在上一次迭代的时候就已经求出来了，所以我们只需要在上一次迭代的sum减去 i, 然后从j开始累加，一直累加到k, 这样可以避免很多重复计算

class Solution {
    public int[][] findContinuousSequence(int target) {
        ArrayList<int[]> res = new ArrayList<>();
        
        int sum = 0, limit = target / 2;    // 因为最少两个数，所以上界为target / 2
        int i = 1, j = 1;
        while(i <= limit){
            if(sum < target){
                sum += j;
                j++;        // 右指针后移
            }else if(sum > target){
                sum -= i;
                i++;        // 左指针右移
            }else{
                int[] arr = new int[j-i];       // j还没被添加到sum中，所以区间大小为j - i
                for(int k = i; k < j; k++){
                    arr[k-i] = k;
                }
                res.add(arr);
                sum -= i;
                i++;
            }
               
        }

        return res.toArray(new int[res.size()][]);        
    }
}

leetcode运行时间为：2ms, 空间为36.9MB

复杂度分析：

时间复杂度：右指针没有回溯，所以相当于两个指针都从 1增大到了 target/2, 所以时间复杂度为O(target)

空间复杂度：除了存储结果的数组只需要常数个变量，所以空间复杂度为O(1)