算法设计(动态规划实验报告) 基于动态规划的背包问题、Warshall算法和Floyd算法
一、名称
动态规划法应用
二、目的
1.掌握动态规划法的基本思想;
2.学会运用动态规划法解决实际设计应用中碰到的问题。
三、要求
1.基于动态规划法思想解决背包问题(递归或自底向上的实现均可);
2.实现基于动态规划法思想的Warshall算法和Floyd算法。
四、仿真内容
1.基于动态规划法思想解决背包问题
1.1、解决背包问题的伪代码描述
算法 MFKnapsack(i,j)
//对背包问题实现记忆功能方法
//输入:一个非负整数i表示先考虑的物品数量,一个非负整数j表示背包的承受重量
//输出:前i个物品的最最优可行子集的价值
If F[I,j]<0
If j<MFKnapsack(i-1,j)
Value←MFKnapsack(i-1,j)
Else
value←max(MFKnapsack(i-1,j),
Values[i]+MFKnapsack(i-1,j-Weights[i]))
F[I,j] ←value
Return F[I,j]
2.2、解决背包问题的源代码实现
package com.zyz.back;
import java.util.Random;
public class BackQuestion {
public static int knaspace(int[] weight, int[] value, int maxweight) {
// 参数 i为放入前i个物体,j为背包的最大承重量。
int n = weight.length;// 放入商品的质量
int[][] maxvalue = new int[n + 1][maxweight + 1];// 背包最大的价值。放入第i个在当前背包的最大价值
int[][] help = new int[n][2];//用来记录商品的价值和质量
for (int i = 0; i < maxweight + 1; i++) { // 第0个商品放入背包,最大价值为0
maxvalue[0][i] = 0;
}
for (int i = 0; i < n + 1; i++) {
maxvalue[i][0] = 0;// 第i个商品放入背包为0的书包,最大价值为0
}
// //参数 i为放入前i个物体,j为背包的最大承重量。
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= maxweight; j++) {// 背包容量逐渐增加
maxvalue[i][j] = maxvalue[i - 1][j];// 将较小的数赋值
if (weight[i - 1] <= j) {// 待放入的物品质量小于背包的容量
// 放入第i个商品的价值maxvalue[i-1][j-weight[i-1]+value[i-1]
if (maxvalue[i - 1][j - weight[i - 1]] + value[i - 1] > maxvalue[i][j]) {
maxvalue[i][j] = maxvalue[i - 1][j - weight[i - 1]] + value[i - 1];
}
}
}
}
return maxvalue[n][maxweight];
}
public static void main(String[] args) {
int maxweight = 14;// 书包的容量
// 随机生成数组
int W = 15;
int V = 25;
Random random = new Random();
int[] weight = new int[20];
int[] value = new int[20];
// 随机给商品附加质量
for (int i = 0; i < weight.length; i++) {
weight[i] = random.nextInt(W);
if(weight[i]==0){
weight[i]=2;
}
}
System.out.println("商品的质量:");
for (int i = 0; i < weight.length; i++) {
System.out.print(weight[i] + " ");
}
System.out.println();
// 随机给商品附加值
System.out.println("商品的价值:");
for (int i = 0; i < value.length; i++) {
value[i] = random.nextInt(V);
if(value[i]==0){
value[i]=3;
}
}
for (int i = 0; i < value.length; i++) {
System.out.print(value[i] + " ");
}
long startTime=System.currentTimeMillis();
int result = knaspace(weight, value, maxweight);
long endTime=System.currentTimeMillis();
long time=endTime-startTime;
System.out.println("\n背包最大的价值:" + result);
System.out.println("数据大小:"+value.length+" 耗时:"+time+"毫秒");
}
}
2.3、时间效率分析
动态法实现背包问题,动态的增加背包的容量,保证放入的商品价值始终是最大的。判断每次新放入的商品和之前放入的商品价值之间的价值比较。比之前的价值大则放入背包。小则不放入。时间效率为Tn=(n).
2.实现基于动态规划法思想的warshall
2.1、warshall算法的伪代码描述
算法 Warshall(A[1…n,1…n])
//实现计算传递闭包的Warshall算法
//输入:包括n个顶点有向图的邻接矩阵A
//输出:该有向图的传递闭包
R(0)←A
For k←1 to n do
For i←1 to n do
For j←1 to n do
R(k)[I,j] ←R(I,j) or R(k-1)[I,k] and R(k-1)[k,j]
Return R(n)
2.2、warshall算法的源代码实现
package com.zyz.comlate;
import java.util.Scanner;
public class Warshall {
public void warshall(int a[][]) {
for (int k = 0; k < a.length; k++) {//求取最终的封闭包通过R0求R1,通过R1求R2。。。。直到最后
for (int j = 0; j < a.length; j++) {//用来判断a[j][i]是否连通
if (a[k][j] == 1) {
for (int i = 0; i < a.length; i++) {
if (a[i][k] == 1) {
a[j][i] = 1;
}
}
}
}
}
}
//打印
public void print(int[][] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}
public static void main(String[] args) {
System.out.println("请输入阶数:");
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[][] a = new int[n][n];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if (i == j) {
a[i][j] = 0;
} else {
a[i][j] = (Math.random() > 0.6 ? 1 : 0);
}
}
}
Warshall warshall = new Warshall();
System.out.println("原始数据:");
warshall.print(a);
System.out.println("处理后的数据:");
long startTime=System.currentTimeMillis();
warshall.warshall(a);
long endTime=System.currentTimeMillis();
long time=endTime-startTime;
warshall.print(a);
System.out.println("耗时:"+time+"毫秒");
}
}
2.3、时间效率分析
T=O(nnn)
3.实现基于动态规划法思想的Floyd算法
3.1、Floyd算法的伪代码描述
算法:Floyd(W[1..n],[1..n]
//实现计算完全最短路径的Floyd算法
//输入:不包含长度为负的回路的图的权重矩阵W
//输出:包含最短路径长度的距离矩阵
D←W
For k←1 to n do
For i←1 to n do
For j←1 to n do
D[I,j] ←min{D[I,j],D[I,j]+D[k,j]}
Return D
3.2、Floyd算法的源代码实现
package com.zyz.comlate;
import java.util.Scanner;
public class Floyd {
public void floyd(int a[][]) {
for (int k = 0; k < a.length; k++) {//求第Rk次的封闭包
for (int j = 0; j < a.length; j++) {//判断第Rk次的位置的最短路径。每次增加一个新的顶点。
for (int i = 0; i < a.length; i++) {
if (a[j][i] > (a[j][k] + a[k][i])) {//新的路径比原先的路径更加短,则将最短路径写入
a[j][i] = a[j][k] + a[k][i];
}
}
}
}
}
// 打印
public void print(int[][] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if (a[i][j] == 3 || a[i][j] == 7 || a[i][j] == 6 || a[i][j] == 5 || a[i][j] == 9) {
System.out.print("∞" + " ");
} else {
System.out.print(a[i][j] + " ");
}
}
System.out.println();
}
}
public static void main(String[] args) {
System.out.println("请输入矩阵阶数:");
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[][] a = new int[n][n];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if (i == j) {
a[i][j] = 0;
} else {
a[i][j] = (int) (Math.random() * 10);
}
}
}
Floyd floyd = new Floyd();
System.out.println("原始数据:");
floyd.print(a);
System.out.println("处理后的数据:");
long startTime = System.currentTimeMillis();
floyd.floyd(a);
long endTime = System.currentTimeMillis();
long time = endTime - startTime;
floyd.print(a);
System.out.println("耗时:" + time + "毫秒");
}
}
3.3、Floyd算法的时间效率分析
T=O(nnn)
4、运行结果
4.1、基于动态规划法思想解决背包问题
1)背包问题测试结果
4.2、Warshall算法的测试用例结果截图
4.3、Floyd算法的测试用例结果截图
5、小结
通过本次实验我了解到动态化和基于动态规划法思想的Warshall算法和Floyd算法使用。我对动态规划法有了更加深入的了解,通过把一个大的问题分级减少为若干个子问题,通过对子问题的求解最终达到求解问题的结果。
算法设计(动态规划实验报告) 基于动态规划的背包问题、Warshall算法和Floyd算法的更多相关文章
- Warshall算法和Floyd算法
不用说这两位都是冷门算法……毕竟O(n^3)的时间复杂度算法在算法竞赛里基本算是被淘汰了……而且也没有在这个算法上继续衍生出其他的算法… 有兴趣的话:click here.. 话说学离散的时候曾经有个 ...
- 【转】最短路径——Dijkstra算法和Floyd算法
[转]最短路径--Dijkstra算法和Floyd算法 标签(空格分隔): 算法 本文是转载,原文在:最短路径-Dijkstra算法和Floyd算法 注意:以下代码 只是描述思路,没有测试过!! Di ...
- 最短路径——Dijkstra算法和Floyd算法
Dijkstra算法概述 Dijkstra算法是由荷兰计算机科学家狄克斯特拉(Dijkstra)于1959 年提出的,因此又叫狄克斯特拉算法.是从一个顶点到其余各顶点的最短路径算法,解决的是有向图(无 ...
- 最短路径Dijkstra算法和Floyd算法整理、
转载自:http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html 最短路径—Dijkstra算法和Floyd算法 Dijks ...
- 【转载】Dijkstra算法和Floyd算法的正确性证明
说明: 本文仅提供关于两个算法的正确性的证明,不涉及对算法的过程描述和实现细节 本人算法菜鸟一枚,提供的证明仅是自己的思路,不保证正确,仅供参考,若有错误,欢迎拍砖指正 ----------- ...
- Dijkstra算法和Floyd算法的正确性证明
说明: 本文仅提供关于两个算法的正确性的证明,不涉及对算法的过程描述和实现细节 本人算法菜鸟一枚,提供的证明仅是自己的思路,不保证正确,仅供参考,若有错误,欢迎拍砖指正 ------------- ...
- 最短路径—Dijkstra算法和Floyd算法
原文链接:http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html 最后边附有我根据文中Dijkstra算法的描述使用jav ...
- 最短路径—大话Dijkstra算法和Floyd算法
Dijkstra算法 算法描述 1)算法思想:设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,第一组为已求出最短路径的顶点集合(用S表示,初始时S中只有一个源点,以后每求得一条最短路径 , ...
- 最短路径—Dijkstra算法和Floyd算法【转】
本文来自博客园的文章:http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html Dijkstra算法 1.定义概览 Dijk ...
随机推荐
- ABP 6.0.0-rc.1的新特性
2022-07-26官方发布ABP 6.0.0-rc.1版本,本文挑选了几个新特性进行了介绍,主要包括LeptonX Lite默认主题.OpenIddict模块,以及如何将Identity Ser ...
- CF280D k-Maximum Subsequence Sum(线段树)
在做这题时我一开始把\(tag\)写入了结构体 #include <iostream> #include <cstdio> #include <cstring> # ...
- 元数据治理利器 - Apache Atlas
一.功能简介 Atlas 是一组可扩展的核心基础治理服务,使企业能够高效地满足其在 Hadoop 中的合规性要求,并允许与整个企业数据生态系统集成.Apache Atlas 为组织提供开放的元数据管理 ...
- Java SE 9 模块化示例
Java SE 9 模块化示例 作者:Grey 原文地址:Java SE 9 模块化示例 说明 Java SE 9引入了模块系统,模块就是代码和数据的封装体.模块的代码被组织成多个包,每个包中包含Ja ...
- java学习第一天.day05
jvm的内存 栈:类方法使用后自动销毁,销毁的好处是释放内存 java方法执行时,在栈区执行 堆: 线程共享的一块内存区域 所有的对象实例以及 数组 都要在堆上分配 每次使用new ...
- 744. 寻找比目标字母大的最小字母--LeetCode
来源:力扣(LeetCode) 链接:https://leetcode.cn/problems/find-smallest-letter-greater-than-target 著作权归领扣网络所有. ...
- 你言我语 By Twikoo
主要做了两件事: 一是前端魔改 二是首页调用(替代原 bber) 注明:以下样式.功能代码基于 Twikoo v1.6.4 前端魔改 "管理面板"按钮同步隐藏输入框.先到twiko ...
- Batch Norm 与 Layer Norm 比较
一.结论 Batch Norm一般用于CV领域,而Layer Norm一般用于NLP领域 Batch Norm需要计算全局平均,而Layer Norm不需要计算全局平均 二.Batch Norm Ba ...
- 跟羽夏学 Ghidra ——窗口
写在前面 此系列是本人一个字一个字码出来的,包括示例和实验截图.本人非计算机专业,可能对本教程涉及的事物没有了解的足够深入,如有错误,欢迎批评指正. 如有好的建议,欢迎反馈.码字不易,如果本篇文章 ...
- WinForm完美实现Cefsharp-v49控件C#与JS交互,并且可加载运行flash
https://blog.csdn.net/zhao331863874/article/details/117328415