0
点赞
收藏
分享

微信扫一扫

《剑指offer》-day 24 -数学(中等)

剑指 Offer 14- I. 剪绳子

在这里插入图片描述
提示:

  • 2 < = n < = 58 2 <= n <= 58 2<=n<=58

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() O()
  • 空间复杂度: O ( ) O() O()

在这里插入图片描述

动态规划 ⭐️

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^2) O(n2)
  • 空间复杂度: O ( n ) O(n) O(n)

在这里插入图片描述

贪心 ⭐️

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

在这里插入图片描述

限制:

  • 1 < = t a r g e t < = 1 0 5 1 <= target <= 10^5 1<=target<=105

暴力

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(n^2) O(n2)
  • 空间复杂度: O ( 1 ) O(1) O(1)
    在这里插入图片描述

滑动窗口 ⭐️

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(n) O(n)
  • 空间复杂度: O ( 1 ) O(1) O(1)
    滑动窗口

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

在这里插入图片描述
限制:

  • 1 < = n < = 1 0 5 1 <= n <= 10^5 1<=n<=105
  • 1 < = m < = 1 0 6 1 <= m <= 10^6 1<=m<=106

链表模拟(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 ( n m ) O(nm) O(nm) (数据范围太大 1 0 11 10^{11} 1011, 所以超时了)
  • 空间复杂度: O ( n ) O(n) O(n)
    在这里插入图片描述

动态规划 ⭐️⭐️⭐️

思路 🤔

  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) O(n)
  • 空间复杂度: O ( n ) O(n) O(n)
    在这里插入图片描述
// 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;
    }
}

在这里插入图片描述

举报

相关推荐

0 条评论