《趣学算法》第四章 动态规划代码实现（Java）

最新推荐文章于 2022-01-17 15:05:59 发布
最新推荐文章于 2022-01-17 15:05:59 发布
阅读量497 收藏 7
点赞数 2
分类专栏： 《趣学算法》 文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zd454909951/article/details/79131447
版权
本文深入探讨动态规划，通过Java代码详细解释了最长公共子序列、编辑距离、游艇租赁、矩阵连乘及0-1背包问题的解决方法，展示了动态规划在算法中的应用。
摘要由CSDN通过智能技术生成

4.3 最长的公共子序列

import java.util.Scanner;

public class Test4_3 {
    static String s1;
    static String s2;

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入字符串s1：");
        s1=scanner.next();
        System.out.println("输入字符串s2：");
        s2=scanner.next();
        int len1=s1.length();                          //计算两个字符串的长度
        int len2=s2.length();     

        int[][] c=new int[len1+1][len2+1];             //存放公共子序列的最大长度
        int[][] b=new int[len1+1][len2+1];             //记录来源

        for(int i=0;i<=len1;i++)
            c[i][0]=0;                                 //初始化第一列为0
        for(int j=0;j<=len2;j++)
            c[0][j]=0;                                 //初始化第一行为0

        LCSL(c,b);                                     //求解最长公共子序列
        System.out.println("s1和s2的最长公共子序列长度是："+c[len1][len2]);
        System.out.print("s1和s2的最长公共子序列是：");
        print(len1,len2,b);                            //递归构造最长公共子序列最优解
    }

    /*求解最长公共子序列*/
    public static void LCSL(int[][] c,int[][] b) {
        int i,j;
        for(i=1;i<=c.length-1;i++) {                   //控制s1的序列，即遍历s1的每个字符
            for(j=1;j<=c[i].length-1;j++) {            //控制s2的序列，即用s1的字符与s2的所有字符进行比较

                if(s1.charAt(i-1)==s2.charAt(j-1)) {   //字符下标从0开始
                    //如果当前字符相同，则公共子序列的长度为该字符前的最长公共序列+1
                    c[i][j]=c[i-1][j-1]+1;
                    b[i][j]=1;
                }
                else {
                    if(c[i][j-1]>=c[i-1][j]) {         //找出两者最大值，若相等默认取左侧
                        c[i][j]=c[i][j-1];             //取左侧值
                        b[i][j]=2;
                    }
                    else {
                        c[i][j]=c[i-1][j];             //取上面值
                        b[i][j]=3;
                    }
                }
            }
        }
    }

    /*递归构造最长公共子序列最优解*/
    public static void print(int i,int j,int[][] b) {
        if(i==0||j==0)
            return;                                    //递归结束条件
        if(b[i][j]==1) {                               //来源左上角
            print(i-1,j-1,b);
            System.out.print(s1.charAt(i-1));
        }
        else if(b[i][j]==2) 
            print(i,j-1,b);                            //来源左侧
        else
            print(i-1,j,b);                            //来源上面               
    }
}

程序运行结果如下：
这里写图片描述

4.4 编辑距离

import java.util.Scanner;

public class Test4_4 {

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入字符串str1：");
        String str1=scanner.next();
        System.out.println("输入字符串str2：");
        String str2=scanner.next();
        int answer=editDistance(str1,str2);                  //求编辑距离
        System.out.println(str1+"和"+str2+"的编辑距离是："+answer);
    }

    public static int editDistance(String str1,String str2) {
        int len1=str1.length();                              //计算字符串的长度
        int len2=str2.length();
        int[][] d=new int[len1+1][len2+1];                   //d[i][j]表示str1前i个字符和str2前j个字符的编辑距离

        for(int i=0;i<=len1;i++)                             //当第二个字符串长度为0时，编辑距离初始化为i
            d[i][0]=i;
        for(int j=0;j<=len2;j++)                             //当第一个字符串长度为0时，编辑距离初始化为j
            d[0][j]=j;

        for(int i=1;i<d.length;i++) {                        //遍历str1的每个字符
            for(int j=1;j<d[i].length;j++) {                 //与第二个字符串的每个字符进行比较
                int diff;                                    //判断str1[i]是否等于str2[j]，相等为0
                if(str1.charAt(i-1)==str2.charAt(j-1)) {     //字符串小标从0开始
                    diff=0;
                }
                else
                    diff=1;

                int temp=Math.min(d[i-1][j]+1, d[i][j-1]+1);  //去三者中最小值
                d[i][j]=Math.min(temp,d[i-1][j-1]+diff);
            }
        }
        return d[len1][len2];
    }

}

程序运行结果如下：
这里写图片描述

4.5 游艇租赁

import java.util.Scanner;

public class Test4_5 {
    static int n;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入站点的个数n：");
        n=scanner.nextInt();
        System.out.println("请依次输入各站点之间的租金：");
        int[][] r=new int[n+1][n+1];                            //存放各站点之间的租金
        int[][] m=new int[n+1][n+1];                            //各个子问题的最优值
        int[][] s=new int[n+1][n+1];                            //各个子问题的最优决策
        for(int i=1;i<=n;i++) {
            for(int j=i+1;j<=n;j++) {
                r[i][j]=scanner.nextInt();
                m[i][j]=r[i][j];                                //初始化m数组
            }   
        }
        rent(m,s);                                              //求最少租金
        System.out.println("花费最少的租金为："+m[1][n]);
        System.out.print("最少租金经过的站点：1");
        print(1,n,s);
        System.out.println();
        scanner.close();
    }

    /*最少租金求解函数*/
    public static void rent(int[][] m,int[][] s) {
        int i,j,k,d;
        for(d=3;d<=n;d++) {                                     //将问题划分为小规模d，3个站点、4个站点...n个站点
            for(i=1;i<=n-d+1;i++) {                             //子问题的初始站点
                j=i+d-1;                                        //子问题的终点站点
                for(k=i+1;k<j;k++) {                            //可停靠站点
                    int temp=m[i][k]+m[k][j];                   //在站点k停留
                    if(temp<m[i][j]) {                          //停留后的租金和比直达的租金便宜
                        m[i][j]=temp;
                        s[i][j]=k;                              //记录停靠点
                    }
                }
            }       
        }
    }

    /*求得停靠点，当s[i][j]=0时说明中间没有停靠点，输出站点j，否则划分为两个子问题*/
    public static void print(int i,int j,int[][] s) {
        if(s[i][j]==0) {
            System.out.print("——"+j);
            return;
        }
        print(i,s[i][j],s);
        print(s[i][j],j,s);
    }
}

程序运行结果如下：
这里写图片描述

4.6 矩阵连乘

import java.util.Scanner;

public class Test4_6 {
    static int n;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入矩阵的个数n：");
        n=scanner.nextInt();
        int[] p=new int[n+1];                          //记录矩阵行列
        int[][] m=new int[n+1][n+1];                   //最优值数组
        int[][] s=new int[n+1][n+1];                   //最优决策数组

        System.out.println("请依次输入每个矩阵的行数和最后一个矩阵的列数：");
        for(int i=0;i<=n;i++)
            p[i]=scanner.nextInt();
        matrixChain(p,m,s);                            //矩阵连乘求解函数
        print(1,n,s);
        System.out.println();
        System.out.println("最小计算量的值为："+m[1][n]);
    }

    /*矩阵连乘求解函数*/
    public static void matrixChain(int[] p,int[][] m,int[][] s) {
        int i,j,r,k;
        for(r=2;r<=n;r++) {                            //2个矩阵连乘、3个矩阵连乘...n个矩阵连乘
            for(i=1;i<=n-r+1;i++) {                    //r个矩阵开始矩阵的下标
                j=i+r-1;                               //结束矩阵
                m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];    //k=i时的乘法次数
                s[i][j]=i;                             //子问题的最优策略是i

                for(k=i+1;k<j;k++) {                   //对从i到j的所有策略求最优值
                    int temp=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
                    if(temp<m[i][j]) {
                        m[i][j]=temp;
                        s[i][j]=k;
                    }
                }
            }
        }
    }

    /*最优解输出函数*/
    public static void print(int i,int j,int[][] s) {
        if(i==j) {
            System.out.print("A"+i);
            return;
        }
        System.out.print("(");
        print(i,s[i][j],s);
        print(s[i][j]+1,j,s);
        System.out.print(")");
    }
}

程序运行结果如下：
这里写图片描述

4.9 0-1背包问题

import java.util.Scanner;

public class Test4_9 {

    public static void main(String[] args) {
        int n,W;                                                    //n表示n个物品，W表示购物车容量      
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入物品的个数n：");
        n=scanner.nextInt();
        System.out.println("请输入购物车的容量W：");
        W=scanner.nextInt();

        int[] w=new int[n+1];                                       //存放所有物品的重量
        int[] v=new int[n+1];                                       //存放所有物品的价值
        int[][] c=new int[n+1][W+1];                                //表示前i个物品放入容量为j的购物车获得的最大价值

        System.out.println("请依次输入每个物品的重量w和价值v，用空格分开：");
        for(int i=1;i<=n;i++) {
            w[i]=scanner.nextInt();
            v[i]=scanner.nextInt();
        }

        //计算c[i][j]
        for(int i=1;i<=n;i++) {                                     //控制物品个数
            for(int j=1;j<=W;j++) {                                 //控制容量大小
                if(w[i]>j)                                          //物品重量大于购物车容量，则不放入第i个物品
                    c[i][j]=c[i-1][j];
                else 
                    c[i][j]=Math.max(c[i-1][j],c[i-1][j-w[i]]+v[i]);//比较放入此物品与不放入此物品哪个价值更大
            }
        }
        System.out.println("装入购物车的最大价值为："+c[n][W]);

        //逆向构造最优解
        int[] x=new int[n+1];                                       //表示第i个物品是否放入购物车
        int j=W;
        for(int i=n;i>0;i--) {                                      //从最后一个物品开始判断
            if(c[i][j]>c[i-1][j]) {                                 //说明第i个物品放入购物车
                x[i]=1;
                j-=w[i];
            }
            else
                x[i]=0;                                             //说明第i个物品没有放入购物车
        }
        System.out.println("装入购物车的物品为：");
        for(int i=1;i<=n;i++) {
            if(x[i]==1)
                System.out.print(i+"  ");
        }
    }
}

程序运行结果如下：
这里写图片描述

瞌睡虫zZ
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《趣学算法》第二章 贪心算法代码实现（Java）
zd454909951的博客
01-04 1446
2.2最优装载问题 import java.util.Scanner; import java.util.Arrays; public class Test2_2 { public static void main(String[] args) { Scanner scanner=new Scanner(System.in);
【趣学算法】动态规划
AI小白的学习记录，欢迎交流~
10-29 837
动态规划把原问题分解为若干子问题，然后自底向上，先求解最小的子问题，把结果存储在表格中，再求解大的子问题时，直接从表格中查询小的子问题的解，避免重复计算，从而提高算法效率。
《趣学算法》的java实践(1)贪心算法
yakumosumi的博客
02-05 156
最优装载问题 问题描述 海盗船载重量为c，每件古董载重量为wiw_iwi​，海盗要怎样才能把尽可能多的宝物装上船？ Java实现 import java.util.Arrays; import java.util.Scanner; public class BestLoadingProblem { public static void main(String[] args) { double[] w; double c; int n;
趣学算法系列-动态规划
那远远的云端
11-21 1597
趣学算法系列-动态规划声明：本系列为趣学算法一书学习总结内容，在此推荐大家看这本算法书籍作为算法入门， 原作者博客链接,本书暂无免费电子版资源，请大家支持正版，更多实例分析请查看原书内容第四章 动态规划 动态规划解决复杂问题的思路也是对问题进行分解，通过求解小规模的子问题再反推出原问题的结果。动态规划也是把原问题分解为若干子问题，然后自底向上，先求解最小的子问题，把结果存储在表格中，再求解大的
动态规划-算法学习之路
brightlee`s blog
03-16 3302
这是我开始写博客的第一篇。以此纪念一下。概述动态规划（dynamic programming），首先不是一个特定的算法。它是一种思想，大部分的优化问题，都可以使用动态规划来解决。优化问题是我们经常碰到的一类问题，很多情况我们都不知道如何下手解决，首先我们应该做的，是分解问题，看看能不能将这个问题分解成多个子问题。谈到问题分解，很多人都会联想到分治算法。分治算法是学会分解问题的第一步。而动态规划比分治
Java学习之动态规划-背包问题代码
最新发布
05-16
本文将深入探讨Java中的动态规划实现，特别是在解决背包问题时的应用。背包问题是一个经典的优化问题，它通常涉及在一个容量有限的背包中选择最有价值的物品，以最大化总价值。 首先，我们要理解动态规划的基本思想...
实验4_动态规划（代码查重）_代码查重_动态规划—代码查重问题_
10-02
1、给定两个代码行长度分别为m与n的代码源文件“A.cpp”与“B.cpp”，其中“A.cpp”为模板代码文件，“B.cpp”为测试...如果文件“A.cpp”在第i 行代码与文件“B.cpp”在第j行代码相似程度超过事先给定的重复比率阈值r
java实现页面置换算法
08-18
Java 实现页面置换算法 Java 实现页面置换算法是计算机操作系统中的一种常见算法，用于管理内存中的页面替换。页面置换算法的主要目的是在内存中分配一定的空间来存储当前使用的页面，以提高系统的性能和效率。 ...
算法（Java）——动态规划
小朱小朱绝不认输的博客
03-16 4908
动态规划是经典算法的一种。在算法中动态规划算法的重要性不容置疑，本博客主要是记载自己在刷题和学习过程中对动态规划的一个理解和总结。 动态规划 定义 动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。 动态规划算法的基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决
游艇最小租金问题（Java实现）
04-15
给定游艇出租站i到出租站J之间的租金为R(I,J),计算出从出租站到游艇站n所需要的最小租金。
游艇租用问题 java 语言程序
05-27
长江游艇俱乐部在长江上设置了n个游艇出租站1，2，……，n。游客可在这些游艇出租站租用游艇，并在下游的任何一个游艇出租站归还游艇。游艇出租站i到游艇出租站j之间的租金为r(i,j)，1≤i＜j≤n。试设计一个算法，计算从游艇出租站1到游艇出租站n所需的最少租金。 2、 输入 游艇出租站的个数n，以及游艇从任意两个站租和还的费用。 3、 输出 从游艇出租站1到游艇出租站n所需的最少租金。
长江游艇问题c代码
03-24
C代码的长江游艇问题，是动态规划的一个典型问题
java：实现遗传算法
04-03
遗传算法的步骤： （1）染色体的编码与解码 对于区间[a,b]上的值x进行解码表示；对于某一个个体的编码为b1,b2,...,bn,解码后对应的参数x值为： x=a+(b-a)/(2^n-1)sum(bk*2^(k-1)).....k=1,2,...n; (2)个体适应...
《趣学算法》C++源码/java源码下载和QQ交流群
rainchxy的博客
06-19 2991
瞌睡虫zZ的博客，对《趣学算法》中的算法提供了java源码实现，在此致谢：https://blog.csdn.net/zd454909951/article/category/7381444
leetcode983.最低票价(java)：动态规划
yinianxx的博客
05-06 160
题目 示例 思路 从前往后进行动态规划 dp[i]表示从days[i]开始到days[days.length-1]的最小花费 dp[i] = min(dp[i+1]+cost[0],dp[i+7]+cost[1],dp[i+30]+cost[2]); 限制条件 如果days[j] < days[i]+durations[k]，j++，一直遍历到这次花费不能旅行的那一天，因为dur...
java实现爬楼梯的最小费用（动态规划）
Erictr的博客
01-17 548
解题思路 我们爬上第n级台阶所花费的最小费用即为从第n-1级台阶所花的费用加上cost[n-1],或者从第n-2级台阶所花费的最小费用加上cost[n-2],因此我们只需要一个长度为3的数组即可完成计算，有一点需要注意的地方是爬上最后一级台阶之后还要再爬一次才能到顶部，因此，在遍历cost数组时，最后一级台阶的费用也要使用，刚开始用了一个dp[n]的数组，后来经过优化，使用长度为3的数组即可解决问题，代码如下： 代码 class Solution { public int minCostClimbi
课程设计/动态规划/JAVA/最小购物费用
Fann
06-29 1856
采用java语言,使用了集合(数组+链表+哈希表)来进行存储.动态规划.(XATU) 问题陈述: 一朵花的价格是2元。一个花瓶的价格是5 元。为了吸引顾客，商店提供了一组优惠商品价 商品有2种,依次分别为编号,需要购买的数量,单价 优惠方案有2种,三朵花的价格是5元而不是6元.购买1个花和两个花瓶只需要十元. 存储思路 数组ArrayList里面存储的都是LinkedList 数组存放对应的...
清华大学 最小花费(java)(动态规划)
weixin_43306331的博客
02-04 445
题目描述 在某条线路上有N个火车站，有三种距离的路程，L1，L2，L3,对应的价格为C1,C2,C3.其对应关系如下: 距离s 票价 0<S<=L1 C1 L1<S<=L2 C2 L2<S<=L3 C3 输入保证0<L1<L2<L3<10^9,0<C1<C2&lt...
算法第四版：JAVA实现与深入解析
这本由Robert Sedgewick和Kevin Wayne合著的《算法》第四版是一本广泛认可的算法书籍，以Java语言作为实现基础。本书涵盖了算法设计、分析和实现的核心概念，适合计算机科学和软件工程领域的学生及专业人士阅读。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值