《剑指offer》-day 24 -数学（中等）

剑指 Offer 14- I. 剪绳子

提示：

• $2<=n<=58$

注意：本题与 343. 整数拆分 题相同

DFS （TLE）

class Solution {
    int n;
    int res = 0;

    public int cuttingRope(int n) {
        this.n = n;
        dfs(0, 1, new ArrayList<>());
        return res;
    }

    void dfs(int sum, int mul, List<Integer> cnt) {
        if (sum == n) {
            // System.out.println(cnt);
            res = Math.max(mul, res);
            return;
        }
        // 剪枝
        if (sum > n) {
            return;
        }
        for (int i = 1; i < n; i++) {
            cnt.add(i);
            dfs(sum + i, mul * i, cnt);
            cnt.remove(cnt.size() - 1); // 回溯
        }
    }
}

• 时间复杂度：$O()$
• 空间复杂度：$O()$

动态规划 ⭐️

本题与 343. 整数拆分 题相同

class Solution {
    public int cuttingRope(int n) {
        // 1、dp[i]表示将i拆分后能得到的最大乘积
        int[] dp = new int[n + 1];
        // 3、初始化
        dp[0] = 0;
        dp[1] = 0;
        // 4、顺序
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                // 2、递推公式
                dp[i] = Math.max(dp[i], Math.max((i - j) * j, dp[i - j] * j));
            }
        }
        // 5、打印dp
        System.out.println(Arrays.toString(dp));
        return dp[n];
    }
}

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(n)$

贪心 ⭐️

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

限制：

• $1<=target<=10^5$

暴力

class Solution {
    public int[][] findContinuousSequence(int target) {
        List<int[]> res = new ArrayList<>();
        for (int i = 1; i <= (target + 1) / 2; i++) {
            int sum = 0;
            int j = i;
            for ( ; sum < target; j++) {
                sum += j;
            }
            if (sum == target) {
                int[] cnt = new int[j - i];
                for (int k = i; k < j; k++) {
                    cnt[k - i] = k;
                }
                res.add(cnt);
            }
        }
        // list to int[][]
        return res.toArray(new int[0][0]);
    }
}

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$
  

滑动窗口 ⭐️

上面暴力枚举每次起始位置都要从 i 重新开始，对此可以使用 “滑动窗口” 进行优化

class Solution {
    public int[][] findContinuousSequence(int target) {
        List<int[]> res = new ArrayList<>();
        int sum = 0;
        int slow = 1;
        int fast = 1;
        // 保证至少含有两个数
        while (fast <= (target + 1) / 2) {
            sum += fast;
            // 维护窗口
            while (sum > target) {
                sum -= slow;
                slow++; // 被动右移
            }
            // 收集结果
            if (sum == target) {
                int[] cnt = new int[fast - slow + 1];
                for (int i = slow; i <= fast; i++) {
                    cnt[i - slow] = i;
                }
                res.add(cnt);
            }
            fast++; // 主动右移
        }
        return res.toArray(new int[0][0]);
    }
}

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$
  

剑指 Offer 62. 圆圈中最后剩下的数字

限制：

• $1<=n<=10^5$
• $1<=m<=10^6$

链表模拟（TLE）

本题其实是 约瑟夫环问题，但数据范围较大。直接同 约瑟夫环问题- leetcode 1823. 找出游戏的获胜者 使用链表进行模拟时，会超时。

// tle
class Solution {
    public int lastRemaining(int n, int m) {
        LinkedList<Integer> circle = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            circle.add(i);
        }
        // 出队 --> 直到只剩下一个人
        int start = 0;
        while (circle.size() > 1) {
            int delete = (start + (m - 1)) % circle.size();
            circle.remove(delete);
            start = delete;
        }
        return circle.get(0);
    }
}

• 时间复杂度：$O(nm)$ （数据范围太大 $10^{11}$， 所以超时了）
• 空间复杂度：$O(n)$
  

动态规划 ⭐️⭐️⭐️

学废了 😭，约瑟夫环还能用 DP 求解，参考 K佬题解

思路 🤔

1. dp[i] 表示从 i 个数组中每次删除第 m 个数字，最后剩下的数字为 dp[i]；

2. 递推公式：dp[i] = (dp[i - 1] + m) % i;
   

3. 初始化：dp[1] = 0（只有一个数字时，无论m为多少，留下的都是0）

class Solution {
    public int lastRemaining(int n, int m) {
        // 1、dp[i]表示从 i 个数组中每次删除第 m 个数字，最后剩下的数字为 dp[i]
        int[] dp = new int[n + 1];
        // 3、初始化
        dp[1] = 0; // 只有一个数字时，无论m为多少，留下的都是0
        for (int i = 1; i <= n; i++) {
            // 2、递推公式
            dp[i] = (dp[i - 1] + m) % i;
        } 
        return dp[n];
    }
}

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$
  

以上 DP 版本中，由状态转移方程可知，当前状态 dp[i] 仅仅依赖于其前面一个状态 dp[i - 1]。
所以，只用使用一个变量 pre 来保存“前一个状态” 即可，而不必使用 dp 数组。

// dp优化空间
class Solution {
    public int lastRemaining(int n, int m) {
        int pre = 0; // dp[0]
        int cnt = -1;
        for (int i = 1; i <= n; i++) {
            // 递推公式
            cnt = (pre + m) % i;
            pre = cnt; // 更新
        } 
        return cnt;
    }
}