算法笔记（二）：动态规划

最新推荐文章于 2024-04-22 13:10:13 发布
最新推荐文章于 2024-04-22 13:10:13 发布
阅读量513 收藏 1
点赞数
分类专栏： 数据结构与算法（Java） 文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hoshizola/article/details/109301586
版权

一、基本思想

动态规划与分治法由相似之处，动态规划在求解子问题时也需要将原问题分解为子问题，首先求子问题的解，然后在此基础上求解原问题的解。然而，分治法中子问题与与原问题的性质相同并且相互独立，而动态规划产生的子问题是相互重叠的并非相互独立。因此，如果使用分治法求解子问题就需要重复计算很多子问题导致运算效率降低。而动态规划采取了一种策略，即在求解子问题时一旦得到这个子问题就记录到一个表格中而不是丢弃，未来一旦需要用到这个子问题的解只需回到表格中以常数时间获取这个子问题的解即可，是一种自底向上的求解方式，具有较高的效率。例如，计算斐波那契数列时，采用递归算法算f第5项元素f(5)，则需要计算出第四项f(4)和第三项f(3)，而算f(4)时又需要算出f(3)和f(2)，算完后递归返回继续算f(3)，由于f(3)结果没有保存就被重复计算了，这就是子问题重叠问题。如图所示：
在这里插入图片描述

二、基本要素

能用动态规划求解的问题具备的两个基本性质：最优子结构和子问题重叠性质。这两个性质也是判断一个问题是否可以用动态求解的标准。其基本步骤是：
1、分析问题的最优解性质，刻画最优解的结构特征；
2、建立最优值的递归定义；
3、以自底向上的方式计算出最优值；
4、构造问题的最优解。

三、经典案例

矩阵连乘

假设A是一个p × \times ×q的矩阵，B是一个q × \times ×r的矩阵，两个矩阵相乘共用了p × \times ×q × \times ×r次乘法。由于矩阵乘法满足结合律，因此计算矩阵连乘积的计算次序有多种。此处用动态规划求解使得乘法次数最少(计算机中的乘法操作较为复杂)的矩阵连乘计算次序。

步骤

1、找出最优解的性质并刻画其结构特征
1）将矩阵连乘积AiAi+1…Aj简记为A[i:j]，i<=j，Ai的维数为pi-1pi。
2）考察A[i:j]的最优计算次序。设在Ak和Ak+1之间将连乘矩阵断开,i<=k<j，相应的矩阵加括号的方式为(AiAi+1…Ak)(Ak+1Ak+2…Aj)。
3）计算量：A[i:k]的计算量加上A[k+1:j]的计算量再加上A[i:k]和A[k+1:j]相乘的计算量。
2、建立递归关系

假设计算A[i:j]的最少数乘次数为 m[i][j]。
1）当i=j时，矩阵为单一矩阵，无需计算，m[i][i]=0。
2）当i<j时，可以利用最优子结构性质来计算m[i][j]。假设计算A[i:j]的最优计算次序在Ak和Ak+1之间断开，则m[i][j]可以递归定义为
T ( n ) = { 0 , i = j m i n [ m [ i ] [ k ] + m [ k + 1 ] [ j ] + p i − 1 p k p j ] i < j T(n)=\left\{ \begin{array}{lcl} 0, & & {i = j}\\ min[m[i][k]+m[k+1][j]+p_{i-1}p_{k}p_{j}] & & {i <j} \end{array} \right. T(n)={0,min[m[i][k]+m[k+1][j]+pi−1​pk​pj​]​​i=ji<j​
3）在计算过程中并不知道k的确定位置，但k的位置只有j-i种可能。
3、应用举例。设有6个矩阵连乘A1A2A3A4A5A6。找出最优计算次序使得矩阵连乘所需的计算量最少。
在这里插入图片描述在这里插入图片描述

第1步，长度r=1时，单一矩阵是完全加括号的（一个矩阵连乘积的计算次序完全确定该矩阵就是完全加括号）。矩阵s用来记录加括号的位置：m[1][1]=0，m[2][2]=0，m[3][3]=0，m[4][4]=0，m[5][5]=0，m[6][6]=0；s[1][1]=0，s[2][2]=0，s[3][3]=0，s[4][4]=0，s[5][5]=0，s[6][6]=0。结果如图 ：
在这里插入图片描述第2步，r=2时计算两个矩阵连乘的最优值。
i=1,j=2时，计算A1A2：
m[1][2]=m[1][1]+m[2][2]+p[0]p[1]p[2]=15750；s[1][2]=1
i=2,j=3时，计算A2A3：
m[2][3]=m[2][2]+m[3][3]+p[1]p[2]p[3]=2625；s[2][3]=2
i=3,j=4时，计算A3A4：
m[3][4]=m[3][3]+m[4][4]+p[2]p[3]p[4]=750；s[3][4]=3
i=4,j=5时，计算A4A5：
m[4][5]=m[4][4]+m[5][5]+p[3]p[4]p[5]=1000；s[4][5]=4
i=5,j=6时，计算A5A6：
m[5][6]=m[5][5]+m[6][6]+p[4]p[5]p[6]=5000；s[5][6]=5
在这里插入图片描述第3步，r=3时计算三个矩阵连乘的最优值。
i=1，j=3时，计算A1A2A3：
k=1时，m[1][3]=m[1][1]+m[2][3]+p[0]p[1]p[3]=7875；
k=2时，m[1][3]=m[1][2]+m[3][3]+p[0]p[2]p[3]=18000；
m[1][3]=7875；s[1][3]=1
i=2，j=4时，计算A2A3A4：
k=2时，m[2][4]=m[2][2]+m[3][4]+p[1]p[2]p[4]=6000；
k=3时，m[2][4]=m[2][3]+m[4][4]+p[1]p[3]p[4]=4375；
m[2][4]=4375；s[2][4]=3
i=3，j=5时，计算A3A4A5：
k=3时，m[3][5]=m[3][3]+m[4][5]+p[2]p[3]p[5]=2500；
k=4时，m[3][5]=m[3][4]+m[5][5]+p[2]p[4]p[5]=3750；
m[3][5]=2500；s[3][5]=3
i=4，j=6时，计算A4A5A6：
k=4时，m[4][6]=m[4][4]+m[5][6]+p[3]p[4]p[6]=6250；
k=5时，m[4][6]=m[4][5]+m[6][6]+p[3]p[5]p[6]=3500；
m[4][6]=3500；s[4][6]=5
在这里插入图片描述第4步，r=4时计算四个矩阵连乘的最优值。
i=1，j=4时计算A1A2A3A4：
k=1，m[1][4]=m[1][1]+m[2][4]+p[0]p[1]p[4]=14875；
k=2，m[1][4]=m[1][2]+m[3][4]+p[0]p[2]p[4]=21000；
k=3，m[1][4]=m[1][3]+m[4][4]+p[0]p[3]p[4]=9375；
m[1][4]=9375，s[1][4]=3
i=2，j=5时计算A2A3A4A5：
k=2，m[2][5]=m[2][2]+m[3][5]+p[1]p[2]p[5]=13000；
k=3，m[2][5]=m[2][3]+m[4][5]+p[1]p[3]p[5]=7125；
k=4，m[1][4]=m[2][4]+m[5][5]+p[1]p[4]p[5]=11375；
m[2][5]=7125，s[1][4]=3
i=3，j=6时计算A3A4A5A6：
k=3，m[3][6]=m[3][3]+m[4][6]+p[2]p[3]p[6]=5375；
k=4，m[3][6]=m[3][4]+m[5][6]+p[2]p[4]p[6]=9500；
k=5，m[3][6]=m[3][5]+m[6][6]+p[2]p[5]p[6]=10000；
m[3][6]=5375，s[1][4]=3
在这里插入图片描述第5步，r=5时计算五个矩阵连乘的最优值。
i=1,j=5时，计算A1A2A3A4A5：
k=1,m[1][5]=m[1][1]+m[2][5]+p[0][1][5]=28125;
k=2,m[1][5]=m[1][2]+m[3][5]+p[0][2][5]=27250;
k=3,m[1][5]=m[1][3]+m[4][5]+p[0][3][5]=11875;
k=4,m[1][5]=m[1][4]+m[5][5]+p[0][4][5]=15375;
m[1][5]=11875，s[1][5]=3
i=2,j=6时，计算A2A3A4A5A6：
k=2,m[2][6]=m[2][2]+m[3][6]+p[1][2][6]=13125;
k=3,m[2][6]=m[2][3]+m[4][6]+p[1][3][6]=10500;
k=4,m[2][6]=m[2][4]+m[5][6]+p[1][4][6]=18075;
k=5,m[2][6]=m[2][5]+m[6][6]+p[1][5][6]=24625;
m[2][6]=10500，s[2][6]=3
在这里插入图片描述第6步，r=6时计算六个矩阵连乘的最优值。
i=1，j=6时计算A1A2A3A4A5A6：
k=1,m[1][6]=m[1][1]+m[2][6]+p[0][1][6]=36750;
k=2,m[1][6]=m[1][2]+m[3][6]+p[0][2][6]=32375;
k=3,m[1][6]=m[1][3]+m[4][6]+p[0][3][6]=15125;
k=4,m[1][6]=m[1][4]+m[5][6]+p[0][4][6]=21875;
k=5,m[1][6]=m[1][5]+m[6][6]+p[0][5][6]=26875;
m[1][6]=15125，a[1][6]=3
在这里插入图片描述至此，算法结束，六个矩阵连乘最优值是15125。
Java代码实现：

public class MatricChain {
	static int n = 6;
	public static void main(String[] args) {
		int[] p = {30,35,15,5,10,20,25};
		int[][] m = new int[n+1][n+1];
		int[][] s = new int[n+1][n+1];
		matrixChain(p,m,s);
		traceback(s,1,6);
		System.out.println("最优计算次数："+m[1][n]);
	}

	public static void matrixChain (int []p, int [][]m, int [][]s){    
		for (int i = 1; i <= n; i++) {
			m[i][i] = 0;
		}
		for (int r = 2; r <= n; r++) {
			for (int i = 1; i <= n - r+1; i++) {
				int j=i+r-1;
				//System.out.println(i+":"+j);
				m[i][j] = m[i][i] +m[i+1][j]+ p[i-1]*p[i]*p[j];
				s[i][j] = i;
				for (int k = i+1; k < j; k++) {
					int t = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
					if (t < m[i][j]) { 
						m[i][j] = t;
						s[i][j] = k;
					}
				}
			} 
		}
	}
	
	public static void traceback(int [][]s,int i,int j)
	  {
	    if(i==j)return;
	      traceback(s,i,s[i][j]);
	      traceback(s,s[i][j]+1,j);
	      System.out.println("Multiply A["+i+":"+s[i][j]+"] and A["+(s[i][j]+1)+":"+j+"]");
	  }
}

四、相关题目

01背包

/*
 * 有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过W的物品，求所有挑选方案中总价值最大的值
 * 输入
 * 	n = 4
 * 	(w, v) = {(2,3), (1,2), (3,4), (2,2)}
 * 	W = 5
 * 
 * 输出
 * 	7（选择第0,1,3号物品）
 * 
 * 因为对于每个物品只有选和不选两种情况，所以这个问题也叫01背包
 */
public class _01背包 {
	static int[] w = {2, 1, 3, 2};
	static int[] v = {3, 2, 4, 2};
	static int n = 4;
	static int W = 5;
	static int[][] rec;//记录已经求解过的子问题
	public static void main(String[] args) {
		int ww = W;//创建总重量W的副本，保留W的值不变
		int ans = dfs(0, ww);
		System.out.println(ans);
		
		rec = new int[n][W + 1];
		for(int i = 0; i < n; i++) {//将记录数组元素初始化为-1
			Arrays.fill(rec[i], -1);
		}
		ww = W;
		ans = m(0, ww);
		System.out.println(ans);
		
		ww = W;
		ans = dp(0, ww);
		System.out.println(ans);
	}
	/*
	 * 2^n的复杂度
	 */
	public static int dfs(int i, int ww) { //返回总价值
		if(ww <= 0) //如果剩余的重量小于等于0，装不下，返回总价值0
			return 0;
		if(i == n) //如果没有物品了，返回总价值0
			return 0;
		int v2 = dfs(i+1, ww);//不选择当前物品
		if(w[i] <= ww) {
			int v1 = v[i] + dfs(i+1, ww-w[i]); //选择当前物品
			return Math.max(v1, v2);
		}else {
			return v2;
		}
	}
	/*
	 * 记忆型递归
	 */
	public static int m(int i, int ww) {
		if(ww <= 0) 
			return 0;
		if(i == n)
			return 0;
		
		if(rec[i][ww] >= 0)
			return rec[i][ww];
		
		int v2 = m(i+1, ww);//不选当前物品
		int ans;
		if(w[i] <= ww) {
			int v1 = v[i] + dfs(i+1, ww-w[i]); //选择当前物品
			ans = Math.max(v1, v2);
		}else {
			ans = v2;
		}
		rec[i][ww] = ans;
		return ans;
	}
	
	//dp(动态规划)解法，需要先建立一个dp表，表的最后一行最后一列的那个数就是答案
	//思想与前面记忆型递归类似
	public static int dp(int i, int ww) {
		int[][] dp = new int[n][W+1];
		//初始化dp表的第一行，列的下标也代表剩余的容量
		for(int k = 0; k < W+1; k++) {
			if(w[0] > k) {
				dp[0][k] = 0;
			}else {
				dp[0][k] = v[0];
			}
		}
		//其他行
		for(int k = 1; k < n; k++) {
			for(int j = 0; j < W+1; j++) {
				if(w[k] <= j) {
					int v1 = v[k] + dp[k-1][j-w[k]];
					int v2 = dp[k-1][j];
					dp[k][j] = Math.max(v1, v2);
				}else {
					dp[k][j] = dp[k-1][j];
				}
			}
		}
		return dp[n-1][W];
	}
}

背包问题一

/*
 * 给出n个物体，第i个物体重量为wi，选择尽量多的物体使得总量不超过c
 * 思路：
 * 	将物体重量按从小到大排序后把较小的一个个装入背包，知道不超过重量c
 */
public class _背包问题一 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] w = new int[n];
		for(int i = 0; i<n; i++) {
			w[i] = sc.nextInt();
		}
		int c = sc.nextInt();
		Arrays.sort(w);
		int ans = f(n, w, c);
		System.out.println(ans);
	}

	private static int f(int n, int[] w, int c) {
		int sum = c;
		int cnt = 0;
		for(int i = 0; i < n; i++) {
			if(w[i] <= sum) {
				sum -= w[i];
				cnt++;
			}
		}
		return cnt;
	}
}

部分背包

/*
 * 有n个物体，第i个物体的重量为wi，价值为vi，在总重量不超过c的情况下让总价值尽量高
 * 每一个物体都可以只取走一部分，价值和重量按比例计算
 */
public class _部分背包 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//n个物体
		int n = sc.nextInt();
		//重量数组
		double[] w = new double[n];
		//价格数组
		double[] v = new double[n];
		//总重量
		int c = sc.nextInt();
		for(int i = 0; i < n; i++) {
			w[i] = sc.nextDouble();
		}
		for(int i = 0; i < n; i++) {
			v[i] = sc.nextDouble();
		}
		
		double[] price = new double[n];
		for(int i = 0; i < n; i++) {
			price[i] = v[i]/w[i]; 
		}
		sort(w, v, price);//按单价从高到底排序
		int weight = c;
		double maxValue = 0;
		for(int i = 0; i < n; i++) {
			if(weight > 0) {
				if(w[i] <= weight) {
					weight -= w[i];
					maxValue += v[i];
				}else {
					maxValue += weight*price[i];
					weight = 0;
				}
				//System.out.println(weight+"-->"+maxValue);
			}else {
				break;
			}
		}
		System.out.println(maxValue);
	}

	private static void sort(double[] w, double[] v, double[] price) {
		for(int i = 0; i < price.length - 1; i++) {
			for(int j = i + 1; j < price.length; j++) {
				if(price[i] < price[j]) {
					swap(w, v, price, i, j);
				}
			}
		}
		System.out.print("重量：");
		for(double i : w) {
			System.out.print(i+" ");
		}
		System.out.println();
		
		System.out.print("价格：");
		for(double i : v) {
			System.out.print(i+" ");
		}
		System.out.println();
		
		System.out.print("单价：");
		for(double i : price) {
			System.out.print(i+" ");
		}
		System.out.println();
	}

	private static void swap(double[] w, double[] v, double[] price, int i, int j) {
		double temp;
		temp = w[i];
		w[i] = w[j];
		w[j] = temp;
		
		temp = v[i];
		v[i] = v[j];
		v[j] = temp;
		
		temp = price[i];
		price[i] = price[j];
		price[j] = temp;
	}
}

钢条切割

/*
 * Serling公司购买长钢条，将其切割为短钢条出售，切割工序本身没有成本支出，公司管理层希望知道最佳的切割方案
 * 假定知道公司出售一段长为i英寸的钢条的价格为pi(i=1,2,...,单位为美元)
 * 长度： 1 | 2 | 3 | 4  | 5  | 6  | 7  | 8  | 9  | 10 
 * 价格： 1 | 5 | 8 | 16 | 10 | 17 | 17 | 20 | 24 | 30
 * 钢条切割问题：给定一段长度为n英寸的钢条和一个价格表pi，求切割钢条方案，使得销售收益rn最大 
 */
public class _钢条切割 {
	
	static int n = 10;
	static int[] p = {1, 5, 8, 16, 10, 17, 17, 20, 24, 30};
	static int[] vs = new int[n+1];
	//记忆型递归
	static int r(int x) {
		if(x == 0)
			return 0;
		int ans = 0;
		for(int i = 1; i <= x; i++) {
			if(vs[x - i] == -1)
				vs[x - i] = r(x - i);
			int v = p[i - 1] + vs[x - i];
			ans = Math.max(v, ans);
		}
		vs[x] = ans;
		return ans;
	}
	//dp解法
	static int dp(int x) {
		vs[0] = 0;
		for(int i = 1; i <= x; i++) { //拥有的钢条的长度
			for(int j = 1; j <= i; j++) {//可切割的钢条长度
				vs[i] = Math.max((p[j - 1] + vs[i - j]), vs[i]);
			}
		}
		return vs[n];
	}
	public static void main(String[] args) {
		Arrays.fill(vs, -1);
		int ans = r(n);
		System.out.println(ans);
		
		Arrays.fill(vs, -1);
		ans = dp(n);
		System.out.println(ans);
	}
}

区间调度

/*
 * 贪心问题
 * 区间调度（不相交区间）
 * 有n项工作，每项工作分别在s时间开始，t时间结束
 * 对于每项工作，你都可以选择参加或不参加，如果选择了参与，那么自始至终都要参加
 * 此外，参与工作的时间段不能重复（即后一项工作的时间和前一项工作的时间不能重叠）
 * 那么最多能参与多少项工作？
 * 
 * 输入：
 * 第一行:n
 * 第二行:n个整数空格隔开，代表n个工作的开始时间
 * 第三行:n个整数空格隔开，代表n个工作的结束时间
 * 
 * 样例
 * 输入：
 * 5
 * 1 2 4 6 8
 * 3 5 7 9 10
 * 
 * 输出：
 * 3
 */
public class _区间调度 {
	static int n;//有n项工作
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		int[] s = new int[n]; //开始时间数组
		int[] t = new int[n];//结束时间数组
		for(int i = 0; i < n; i++) {
			s[i] = sc.nextInt();
		}
		for(int i = 0; i < n; i++) {
			t[i] = sc.nextInt();
		}
		sort(s, t);//将结束时间从小到大排序，对应的开始时间也要变换顺序
		int res = f(n, s, t);
		System.out.println(res); 
	}
	
	private static void sort(int[] s, int[] t) {
		for(int i = 0; i < t.length - 1; i++) {
			for(int j = i + 1; j < t.length; j++) {
				if(t[i] > t[j]) {
					int temp = t[i];
					swap(s, t, i, j);
				}
			}
		}
		for(int i : s) {
			System.out.print(i+" ");
		}
		System.out.println();
		for(int i : t) {
			System.out.print(i+" ");
		}
		System.out.println();
	}

	private static void swap(int[] s, int[] t, int i, int j) {
		int temp;
		temp = t[i];
		t[i] = t[j];
		t[j] = temp;
		
		temp = s[i];
		s[i] = s[j];
		s[j] = temp;
	}

	public static int f(int n, int[] s, int[] t) {
		int cnt = 1;
		int y = t[0];//结束时间最早的工作
		for(int i = 1; i < n; i++) {
			if(s[i] > y) { //如果下一项工作的开始时间比上一项工作的结束时间晚
				cnt++;
				y = t[i];
			}
		}
		return cnt;
	}
}

区间覆盖

/*
 * 在给定的N个区间中，求解覆盖某个区间的最少区间数
 * 样例输入：
 * 3 10（3表示需要输入3个区间，10表示1-10这个区间）
 * 1 7
 * 3 6
 * 6 10
 * 输出：
 * 2
 */
public class _区间覆盖 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int T = sc.nextInt();
		int[] s = new int[N];
		int[] t = new int[N];
		for(int i = 0; i < N; i++) {
			s[i] = sc.nextInt();
			t[i] = sc.nextInt();
		}
		sort(s, t);
		int start = 1;
		int end = 1;
		int ans = 0;
		for(int i = 0; i < N; i++) {
			int ss = s[i];
			int tt = t[i];
			if(i == 0 && ss > 1)//不符合
				break;
			if(ss <= start) {
				end = Math.max(tt, end);
			}else {
				ans++;
				start = end + 1;
				if(ss <= start) {
					end = Math.max(tt, end);
				}else {
					break;
				}
			}
		}
		if(end < T)
			System.out.println(-1);
		else
			System.out.println(++ans);
	}

	private static void sort(int[] s, int[] t) {
		for(int i = 0; i < t.length - 1; i++) {
			for(int j = i + 1; j < t.length; j++) {
				if(s[i] > s[j]) {
					int temp = s[i];
					swap(s, t, i, j);
				}
			}
		}
		for(int i : s) {
			System.out.print(i+" ");
		}
		System.out.println();
		for(int i : t) {
			System.out.print(i+" ");
		}
		System.out.println();
	}
	private static void swap(int[] s, int[] t, int i, int j) {
		int temp;
		temp = t[i];
		t[i] = t[j];
		t[j] = temp;
		
		temp = s[i];
		s[i] = s[j];
		s[j] = temp;
	}
}

数字三角形

/*
 * 在数字三角形中国寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大
 * 路径上的每一步都只能往左下或右下走，只需要求出这个最大和即可，不必给出具体路径
 * 输入格式：
 * 5  （表示行数）
 * 7
 * 3 8
 * 8 1 0
 * 2 7 4 4
 * 4 5 2 6 5
 * 思路：确定下一行的最大值，从下往上递推
 */
public class _数字三角形 {
	static int N;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		int[][] triangle = new int[N][N];
		for(int i = 0; i < N; i++) {
			for(int j = 0; j <= i; j++) {
				triangle[i][j] = sc.nextInt();
			}
		}
		int ans = f1(triangle);
		System.out.println(ans);
	}

	private static int f1(int[][] triangle) {
		for(int i = N-1; i >= 0; i--) {
			for(int j = 0; j <= i; j++) {
				if(i == N - 1) { }
				else {
					triangle[i][j] = triangle[i][j]+Math.max(triangle[i+1][j], triangle[i+1][j+1]);
				}
			}
		}
		return triangle[0][0];
	}
}

硬币支付

/*贪心问题一
 * 有1元，5元，10元，50元，100元，500元的硬币各有C1,C5,C10,C50,C100,C500枚
 * 现在要用这些硬币来支付A元，最少需要多少枚硬币？
 * 
 * 输入第一行6个数字分别代表每种面值，第二行是需要支付的总金额
 * 例如输入 
 * 3 2 1 3 0 2  
 * 620
 * 输出
 * 6
 * (6=1(*500)+2(*50)+1(*10)+2(*5))
 */
public class _硬币支付 {
	static int[] cnts = new int[6];
	static int[] coins = {1,5,10,50,100,500};
	static int A;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		for(int i = 0; i < 6; i++) {
			cnts[i] = sc.nextInt();
		}
		A = sc.nextInt();
		int res = f(A, 5);
		System.out.println(res);
	}
	private static int f(int A, int cur) {
		if(A <= 0)
			return 0;
		if(cur == 0)
			return A;
		int coinValue = coins[cur];
		int x = A/coinValue;
		int cnt = cnts[cur];
		int t = Math.min(x, cnt);
		
		return t+f(A-t*coinValue, cur-1);
	}
}

字典序最小

public class _字典序最小 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		StringBuilder sb = new StringBuilder();
		sb.append(sc.nextLine());
		
		f(sb.toString());
	}

	public static void f(String str) {
		//将原来的字符串翻转，为了方便比较首尾字典序
		String reverse_str = new StringBuilder(str).reverse().toString();
		int len = str.length();
		StringBuilder new_str = new StringBuilder();
		int cnt = 0;
		while(new_str.length() < len) {
			if(str.compareTo(reverse_str) <= 0) {
				new_str.append(str.charAt(0));
				str = str.substring(1);
			}else {
				new_str.append(reverse_str.charAt(0));
				reverse_str = reverse_str.substring(1);
			}
			
		}
		print(new_str.toString());
	}
	
	public static void print(String new_str) {
		int len = new_str.length();
		int cnt = len/80;
		if(cnt <= 1)
			System.out.println(new_str);
		else {
			int i;
			for(i = 0; i < cnt; i++) {
				System.out.println(new_str.substring(i*80, (i+1)*80)); 
			}
			if(len%80!=0)
				System.out.println(new_str.substring(i*80));   
		}
	}
}
Hoshizola
关注
专栏目录
矩阵连乘问题实现(最佳加括号方式－动态规划算法)
11-15
矩阵连乘问题分析和实现用于动态规划 最佳加括号方式－动态规划算法
算法设计——矩阵连乘（动态规划）
Doro_的博客
04-13 2082
问题 给定定n个矩阵 {A1,A2,A3…An}， 其中 Ai与Ai+1 是可乘的， 求矩阵连乘的最少计算乘法次数的顺序。 分析 为什么会有不同次数的乘法？ 由于矩阵A(mn)B(nr)乘法次数为mnr 不同矩阵计算顺序会导致不同的计算次数 ...
动态规划的应用
梦码城博客中心
04-03 824
1. 硬币支付问题 有1元,5元,10元,50元,100元,500元的硬币各c1,c5,c10,c50,c100,c500枚. 现在要用这些硬币来支付A元,最少需要多少枚硬币? 假定本题至少存在一种支付方案. 0≤ci≤10^9 0≤A≤10^9 输入: 第一行有六个数字,分别代表从小到大6种面值的硬币的个数 第二行为A,代表需支付的A元 样例: 输入 3 2 1 3 0 2 620 输出 6 package 动态规划; import java.util.Arrays; import java.util.
矩阵连乘问题(递归与动态规划实现)
qyh的博客
07-04 3958
问题描述 给定n个矩阵{A1A2…An}，其中Ai和Ai+1是可乘的，考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律，故计算矩阵的连乘积有许多不同的计算次序，而不同的计算次序，所需要计算的连乘次数也是不同的，求解连乘次数最少的矩阵连乘最优次序。 ** 递归实现： **#include “stdafx.h” int p[100],s[100][100],n; //计算最优值 int LookupChain(int i, int j,) { if (i == j) return 0; int u
矩阵连乘——动态规划算法
热门推荐
weixin_45416043的博客
07-25 1万+
矩阵连乘——动态规划算法 目录 矩阵连乘——动态规划算法 预备知识 前言 问题 应用动态规划方法的步骤 按照步骤分析问题 步骤1：最有括号化方案的结构特征 步骤2：一个递归求解方案 步骤3：计算最优代价 步骤4：构造最优解 算法的核心代码 举例验证算法 算法复杂度分析 算法的基本要素 1、最优子结构 2、重叠子问题 3、备忘录方法 闲聊时刻 预备知识 了解...
动态规划算法笔记总结ZIP分享
12-01
动态规划是一种重要的算法思想，广泛应用于解决复杂优化问题。它通过将大问题分解为相互关联的小问题，并存储每个小问题的解，避免了重复计算，从而达到高效求解的目的。在计算机科学，尤其是算法设计中，动态规划是...
算法基础课 模板题笔记：动态规划
最新发布
www.h y p e r p l a s m a.top
04-22 1787
AcWing算法基础课 动态规划模板题笔记
算法笔记：动态规划（1）
我叫李铁柱
03-28 276
何时能够使用动态规划        动态规划（Dynamic Programming, DP）与其说是一种算法，更准确地说是一种解决问题的思维方式，因为其并没有对所有相关问题抽象出一种通用的算法程序，而是要在解题时根据具体的问题运用动态规划的思想进行问题的建模并编码求解。因此在理解动态规划解题之前，首先要了解什么样的问题能够用动态规划的思想解决。 &nbsp...
《算法笔记》pdf版，欢迎下载学习~
10-10
3. **动态规划**：解决最优化问题的利器，例如背包问题、最长公共子序列、斐波那契数列等，动态规划能找出全局最优解。 4. **贪心算法**：在每一步选择局部最优解，以期达到整体最优，适用于资源分配、任务调度等...
算法基础：动态规划
清水河C罗——Leonardo-Liu
03-05 798
本博客所有内容均整理自《算法图解》，欢迎讨论交流~ 动态规划是一种很优雅的算法，它可以认为是使用了分治法的思想，即将大问题划分成小问题，逐一击破这些小问题，从而总体上解决大问题。 对于动态规划的定义，百度百科是这样给出的：动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E....
动态规划矩阵连乘代码实现
05-06
动态规划算法中矩阵连乘的实现代码，主要是用C语言编写；
矩阵连乘问题---算法分析之动态规划
04-20
动态规划方法解决矩阵连乘问题，即寻求多个矩阵连乘时的最好的加括号方式使得总的乘法两最小； 可以设定矩阵个数，手动输入矩阵的阶，显示动态规划算法的表格，即乘法量和括号信息； 多文档，C++6.0
矩阵连乘动态规划 算法分析
10-25
对矩阵连乘问题的详细介绍并且附有源代码的实现
【算法分析与设计】动态规划算法解决矩阵链乘法最优顺序问题
付费专栏已不再维护，请勿购买
02-25 1431
基于动态规划解决矩阵链乘法最优顺序问题，Java编程实现
算法设计与分析——动态规划
sdjcwangwei的博客
05-04 319
一、动态规划的基本思想 动态规划算法通常用于求解具有某种最优性质的问题。 在这类问题中，可能会有许多可行解。 每一个解都对应于一个值，我们希望找到具有最优值的解。 基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 ...
矩阵连乘--动态规划算法
hello_bravo_的博客
10-29 6408
动态规划(之前的背包问题也是动态规划的一种) 动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 与分治法不同的是：适用于动态规划法求解的问题，经分解得到的子问题往往不是互相独立的。 目的：保存已解决的子文题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，从而得到多项式时间的算法。 基本思路：用一个
动态规划法解决矩阵连乘问题
weixin_44755413的博客
04-14 4933
问题描述 矩阵连乘问题就是让我们找一个加括号的位置，使得加完括号之后矩阵的计算次数最小。这是一道典型的动态规划问题，而且和我们昨天讨论的题目动态规划解决多边形最优三角剖分很相似，大家可以参考一下。 题目分析 学过线性代数的朋友一定都知道矩阵相乘是有条件的，即AxB的条件是A矩阵的列数应该等于B矩阵的行数，这样两个矩阵才能相乘。 现在考虑三个矩阵的连乘运算，加括号方式会对整个计算量产生影响。现有矩...
关于动态规划解决矩阵连乘问题
qq_43396172的博客
10-16 1237
关于动态规划解决矩阵连乘问题 以《计算机算法设计与分析 第5版》教材中的例子为例。 动态规划解决具体问题分为4步： 分析最优解结构。 最优子结构是：问题的最优解包含着子问题的最优解。 建立递归关系。 递归的定义最优值。 计算最优值。 根据递归式，写出递归算法。 构造最优解。 根据算法获取到的信息构造最优解。 空谈比较空泛，现在利用动态规划寻找矩阵连乘的最优顺序： 例...
动态规划算法之矩阵连乘
ScriptFlying的博客
10-31 2288
1、动态规划算法基本思想： 与分治法类似，也是将待求解问题分解成若干个子问题，但是经分解得到的子问题往往不是互相独立的。不同子问题的数目常常只有多项式量级。在用分治法求解时，有些子问题被重复计算了许多次。 2、基本步骤： 1）找出最优解的性质，并刻划其结构特征。 2）递归地定义最优值。 3）以自底向上的方式计算出最优值。 4）根据计算最优值时得到的信息，构造最优解。 3、矩阵连乘问题： 由于矩阵乘...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值