剪绳子

题目描述

给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[1],...,k[m]。请问k[1]x...xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

输入描述:

输入一个数n，意义见题面。（2 <= n <= 60）

输出描述:

输出答案。

示例1

输入

复制

8

输出

复制

18

法1：暴力递归破解法：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class test {
    private static int back_track(int target){
        if(target<=4) return target;

        int ret=0;
        for(int i=1;i<=target;i++){
            int t = back_track(target - i);
            ret = i*t>ret?i*t:ret;
        }
        return ret;
    }

    private static int cutRope(int target){
        if(target==2) return 1;
        else if(target==3) return 2;
        return back_track(target);
    }
    public static void main(String[] args) throws IOException {
        System.out.println("请输入绳子的长度：");
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(br.readLine());
        System.out.println(cutRope(n));
    }
}

时间复杂度为O(n!),空间复杂度为O(n);相当于根结点为back_track(n)的一棵树，叶子结点都是back_track(1)，树的深度是n，第二层从左到右的子树复杂度分别为O((n-1)!),O((n-2)!),...,最外面还有一层循环，所以是O(n!);

法2：记忆递归法：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class test {
    private static int back_track(int target,int[] mark){
        if(target<=4) return target;
        if(mark[target]!=0) {
            return mark[target];
        }
        int ret=0;
        for(int i=1;i<=target;i++){
            int t = back_track(target - i,mark);
            ret = i*t>ret?i*t:ret;
        }
        return mark[target]=ret;
    }

    private static int cutRope(int target){
        if(target==2) return 1;
        else if(target==3) return 2;
        int[] mark=new int[target+1];
        return back_track(target,mark);
    }
    public static void main(String[] args) throws IOException {
        System.out.println("请输入绳子的长度：");
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(br.readLine());
        System.out.println(cutRope(n));
    }
}

时间复杂度是O(n^2),空间复杂度是O(n);最外面循环一遍，然后每个mark[i]计算一次,共计算n次，所以O(n^2);

法3：动态规划求解：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class pass {
    private static int cutRope(int target){
        if(target==2) return 1;
        else if(target==3) return 2;
        int[] f=new int[target+1];
        for(int i=1;i<=4;i++){
            f[i]=i;
        }
        for(int i=5;i<=target;i++){
            for(int j=1;j<i;j++){
                f[i]=f[i]>j*f[i-j]?f[i]:j*f[i-j];
            }
        }
        return f[target];
    }
    public static void main(String[] args) throws IOException {
        System.out.println("请输入绳子的长度：");
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(br.readLine());
        System.out.println(cutRope(n));
    }
}

时间复杂度是O(n^2),空间复杂度是O(n);