【学习动态规划】两个基本的小问题_刻画最优子结构-优快云博客

本文深入讲解动态规划的核心概念，包括最优子结构与子问题重叠，并通过钢条分割与矩阵链乘法两个经典案例，展示如何运用动态规划解决实际问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

动态规划的两个标识：

（1）最优子结构

用动态规划的方法求解最优化问题的第一步就是刻画最优解的结构。如果一个问题的最优解包含其子问题的最优解，我们就称此问题具有最优子结构性质。

而最优子结构的一个最基本的额特性就是子问题无关特性。比如求图中两点之间最长简单路径，可以分为两点分别到一个间接点的最长简单路径之和，但是该子问题直接是相关的（因为两个子路径会有重叠）。故我们确定该问题不具有最优子结构性质，故不能用动态规划方法。相对应的，求两点之间最短路径就具有最优子结构性质。

（2）子问题重叠

存在以上两个标识的就可以使用动态规划来解决。

1、钢条分割问题

钢条的切割长度不同，价格不同。如下的价格表：

长度：	1	2	3	4	5	6	7	8	9	10
价格：	1	5	8	9	10	17	17	20	24	30

问：一个长度为n的钢条，怎么分割才能最大利益化？

思路：将长度为n的钢条切为长度为i单独一段和可分的长度为（n-i）的段。

r[n]=max(p[i]+r[n-i])；

对于长度为n的钢条来说，最优的解是最优的长度为i单独一段和可分的长度为（n-i）的段。

r[0]=0;//初始条件

for i = 1 to n:

q=-∞;

for j = 1 to i:

if(q<pj+r[i-j]):

q=pj+r[i-j];

s[i]=j;

r[i]=q;

return r and s;

pj是长度为j的段的价格。

使用最经典的自底向上的动态规划方法：

根据最小的子问题，逐步构建大问题。

public class 钢条分割 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int n=7;
		int[] r = new int[n+1];//最有利益
		int[] s = new int[n+1];//备份方案
		int[] p = {0,1,5,8,9,10,17,17,20,24,30};
		bottom_Up_cut(p,n,r,s);
		System.out.println(r[n]);
		int i=n;
		while(i!=0){
			System.out.print(s[i]+" ");
			i -= s[i];
		}		
	}
	
	public static void bottom_Up_cut(int[] p, int n, int[] r, int[] s){
		r[0] = 0;
		for(int j=1;j<=n;j++){
			int q = Integer.MIN_VALUE;
			for(int i=1;i<=j;i++){
				if(q<p[i]+r[j-i]){
					q = p[i]+r[j-i];
					r[j] = q;
					s[j] = i;
				}
			}	
		}
	}

}

2、矩阵链乘法

这一个例子是求解矩阵链乘问题的动态规划算法。

给定一个n个矩阵的序列（矩阵链）<A1,A2,...An>，我们希望计算它的乘积。

为了计算乘积，可以适当的在该矩阵链上加入括号，因为乘法顺序的不同，会严重影响该乘法的据算量。

递归公式：

m[i,j]表示矩阵i连乘到矩阵j所用的最小代价。

知道p的这个计算是两个已知矩阵乘积的运算量。因为该矩阵分为了两段，两段之间的乘法依然会需要计算量，就是这个p。。。了

从长度为2的乘法开始计算，求得其最大值。依次由j-1的最优值求得j的最优值，最终求得长度n的最优值。欧耶！

package 动态规划;

import java.util.ArrayList;
import java.util.List;

class Mymatrix{
	int rownum;
	int colnum;
	public Mymatrix(int rownum, int colnum) {
		super();
		this.rownum = rownum;
		this.colnum = colnum;
	}
}

public class 矩阵链乘法 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		List<Mymatrix> ms = new ArrayList<Mymatrix>();
		ms.add(new Mymatrix(30, 35));
		ms.add(new Mymatrix(35, 15));
		ms.add(new Mymatrix(15, 5));
		ms.add(new Mymatrix(5, 10));
		ms.add(new Mymatrix(10, 20));
		ms.add(new Mymatrix(20, 25));
		int len = ms.size();
		long[][] m = new long[len][len];
		int[][] s = new int[len][len];
		matrix_chain_order(ms, m, s);
		System.out.println(m[0][5]);
	}

	private static void matrix_chain_order(List<Mymatrix> ms, long[][] m,
			int[][] s) {
		int len = ms.size();
		int[] p = new int[len+1];
		for(int i=0;i<len;i++){
			p[i] = ms.get(i).rownum;
		}
		p[len] = ms.get(len-1).colnum;
			
		for(int i=0;i<len;i++){
			m[i][i]=0;
		}
		int j=0,y;
		for(int l=2;l<=len;l++){
			if(l==len)
				 y=0;
			for(int i=0;i<=len-l;i++){
				j=i+l-1;
				m[i][j]=Long.MAX_VALUE;
				for(int k=i;k<=j-1;k++){
					if(m[i][j]>m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1]){//p[i]是前一个矩阵的行数，p[k+1]是前一个矩阵的列数，p[j+1]是后一个矩阵的列数
						m[i][j]=m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1];
						s[i][j] = k;
					}
				}
			}
		}
		
	}
	

}

再看一个自顶向下的递归来解决该问题。一个很重要的点就是记得要使用m矩阵进行备份。因为一般的递归方法是直接返的每个步骤的最优值，假如不备份的话，会连续出现很多子问题的重复计算。影响效率。

（从算法直观上看，使用有备份的递归比动态规划更加可读性好，而且逻辑性强。

但是从效率上看，因为递归额外占用一些资源，so动态规划效率更高。）

我建议在参加一些时间比较紧张的上机考试中，还是直接用递归较好些，不容易出错。

package 动态规划;

import java.util.ArrayList;
import java.util.List;

public class 矩阵链乘法_备忘机制 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		List<Mymatrix> ms = new ArrayList<Mymatrix>();
		ms.add(new Mymatrix(30, 35));
		ms.add(new Mymatrix(35, 15));
		ms.add(new Mymatrix(15, 5));
		ms.add(new Mymatrix(5, 10));
		ms.add(new Mymatrix(10, 20));
		ms.add(new Mymatrix(20, 25));
		int len = ms.size();
		long[][] m = new long[len][len];
		for(int i=0;i<len;i++)
			for(int j=0;j<len;j++)
				m[i][j] = Long.MAX_VALUE;
		int[][] s = new int[len][len];
		int[] p = new int[len+1];
		for(int i=0;i<len;i++){
			p[i] = ms.get(i).rownum;
		}
		p[len] = ms.get(len-1).colnum;
		long r = memo_matrix_chain_order(p,0,len-1,m,s);
		System.out.println(r);
		矩阵链乘法_动态规划.print(s,0,5);
	}

	private static long memo_matrix_chain_order(int[] p, int i,
			int j, long[][] m, int[][] s) {
		// TODO Auto-generated method stub
		long min = Long.MAX_VALUE;
		if(m[i][j]<Long.MAX_VALUE)
			return m[i][j];
		if(i==j)
			m[i][j]=0;
		else{
			for(int k=i;k<j;k++){
				if((memo_matrix_chain_order(p, i, k, m, s)+memo_matrix_chain_order(p, k+1, j, m, s)+p[i]*p[k+1]*p[j+1])<min){
					min = memo_matrix_chain_order(p, i, k, m, s)+memo_matrix_chain_order(p, k+1, j, m, s)+p[i]*p[k+1]*p[j+1];
					s[i][j] = k;
					m[i][j] = min;
				}
			}
		}
		
		return m[i][j];
		
	}

}