【JZOF】14剪绳子

最新推荐文章于 2022-08-26 21:45:48 发布

叹了口丶气

最新推荐文章于 2022-08-26 21:45:48 发布

阅读量220

点赞数

分类专栏： LeetCode 文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/yexiguafu/article/details/125942950

版权

LeetCode 专栏收录该内容

68 篇文章 1 订阅

订阅专栏

本文探讨了如何使用暴力递归、记忆化递归和动态规划三种方法解决绳子最大乘积切割问题。时间复杂度从O(n!)到O(n^2)，空间复杂度从O(n)到O(n)。通过这些算法，可以找到将绳子切成若干段以获得最大乘积的最佳策略。

摘要由CSDN通过智能技术生成

暴力递归：

    // 方法1, 暴力递归， 时间复杂度为O(n!)，空间复杂度为O(n)，最多分n段，每段长度为1，递归深度为n
    public static int cutRope(int target) {
        if (target == 2) {
            return 1;
        } else if (target == 3) {
            return 2;
        } else {
            return backTrack(target);
        }
    }

    private static int backTrack(int n) {
        // n<=4，表明不分割的时候，长度是最长的。
        if (n <= 4) {
            return n;
        }
        int res = 0;
        for (int i = 1; i < n; i++) {
            res += Math.max(res, i * backTrack(n - i));
        }
        return res;
    }

记忆化递归：

    // 记忆化递归，时间复杂度为O(n^2)，空间复杂度为O(n)
    static int[] mark = null;
    public static int cutRope2(int target) {
        if (target == 2) {
            return 1;
        } else if (target == 3) {
            return 2;
        }
        // 创建一个数组,初始值为0
        mark = new int[target+1];
        return backTrack2(target);
    }

    private static int backTrack2(int target) {
        if (target <= 4) {
            return target;
        }
        if (mark[target] != 0) {
            return mark[target];
        }
        int ret = 0;
        for (int i = 1; i < target; i++) {
            ret = Math.max(ret, i * backTrack2(target - i));
        }
        return mark[target] = ret;
    }

动态规划：

    // 动态规划, 时间复杂度为O(n^2)，空间复杂度为O(n)
    public static int cutRope3(int target) {
        if (target == 2) {
            return 1;
        } else if (target == 3) {
            return 2;
        }
        int[] mark = new int[target + 1];
        for (int i = 1; i <= 4; i++) {
            mark[i] = i;
        }
        for (int i = 5; i <= target; i++) {
            for (int j = 1; j < i; j++) {
                mark[i] = Math.max(mark[i], j * mark[i - j]);
            }
        }
        return mark[target];
    }