钢条切割-递归,记忆性递归,dp

钢条切割

在这里插入图片描述
方法1:递归

import java.util.Scanner;

public class Cutting {
    public static int n = 10 ;
    public static int [] p = {1,5,8,16,10,17,17,20,24,30} ;
    public static int cut(int x){
        int res = 0 ;
        if(x == 0){
            return 0 ;
        }
        for(int i=1; i<=x; i++){
            int temp = p[i-1] + cut(x-i) ; //每一段的价格+剩余的最佳方案的价格
            res = Math.max(temp, res) ; //找出所有temp的最大值,即是切割后的最大价值
        }
        return res ;
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in) ;
        int x = input.nextInt() ;
        System.out.println(cut(x)) ;
    }
}

方法2:记忆性递归–提高效率

import java.util.Arrays;
import java.util.Scanner;

public class Cutting {
    public static int n = 10 ;
    public static int [] p = {1,5,8,16,10,17,17,20,24,30} ;
    static int [] remember = new int [n] ;
    public static int cut(int x){
        int res = 0 ;
        if(x == 0){
            return 0 ;
        }

        for(int i=1; i<=x; i++){
            if(remember[x-i] == -1){
                remember[x-i] = cut(x-i) ; //提前找到,存储,不用每次都寻找
            }
            int temp = p[i-1] + remember[x-i] ; //每一段的价格+剩余的最佳方案的价格
            res = Math.max(temp, res) ; //找出所有temp的最大值,即是切割后的最大价值
        }
        return res ;
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in) ;
        Arrays.fill(remember,-1) ;
        int x = input.nextInt() ;
        System.out.println(cut(x)) ;
    }
}

方法3:动态规划


import java.util.Arrays;
import java.util.Scanner;

public class Cutting {
    public static int n = 10 ;
    public static int [] p = {1,5,8,16,10,17,17,20,24,30} ;
    static int [] vs = new int [n+1] ;
    public static int dp(int x){
        for(int i=1; i<=x; i++){ //拥有钢条的长度
            for(int j=1; j<=i; j++){ //所有可能组合成i的数字范围为1~i
                int temp = vs[i-j] + p[j-1] ; //p[j-1]为长度为j的价值,vs[i-j]为其余长度的最大价值
                vs[i] = Math.max(vs[i], temp) ; //长度为i的钢条如果出现更大价值,就更新
            }
        }
        return vs[x];
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in) ;
        Arrays.fill(vs, 0) ;
        int x = input.nextInt() ;
        System.out.println(dp(x)) ;
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
钢条切割问题是经典的动态规划问题,可以使用递归来解决。 假设钢条长度为 n,价格表为 p[],我们需要求出钢条切割后的最大收益。 可以使用以下的递归式来解决这个问题: r[n] = max(p[i] + r[n-i]),其中 1 <= i <= n。 其中,r[n] 表示长度为 n 的钢条的最大收益。 这个递归式的意思是:将钢条切割成长度为 i 和 n-i 的两段,最大收益为钢条长度为 i 的最大收益加上钢条长度为 n-i 的最大收益。 递归式的边界条件为:当钢条长度为 0 时,最大收益为 0。 下面是使用递归来解决钢条切割问题的代码: ```c #include <stdio.h> // 计算长度为 n 的钢条的最大收益 int cut_rod(int p[], int n) { if (n == 0) { return 0; } int max_profit = -1; for (int i = 1; i <= n; i++) { int profit = p[i] + cut_rod(p, n-i); if (profit > max_profit) { max_profit = profit; } } return max_profit; } int main() { int p[] = {0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30}; int n = 4; int max_profit = cut_rod(p, n); printf("钢条长度为 %d 时的最大收益为 %d\n", n, max_profit); return 0; } ``` 在这个代码中,p[] 数组表示价格表,n 表示钢条长度,cut_rod() 函数返回钢条长度为 n 时的最大收益。函数使用了递归,依次计算每一种切割方案的最大收益,并返回最大值。 需要注意的是,使用递归来解决钢条切割问题的时间复杂度为指数级别,因此当 n 较大时,递归效率较低,需要使用其他算来解决。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nuist__NJUPT

给个鼓励吧,谢谢你

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值