标签:
-------------------------------------------
dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems. (通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法)
咦,这不就是分而治之法吗?不,虽然它们的目的是一样的,但它们分解的子问题属性不同。
the fastest way through station S1,j-1 and then directly through stationS1,j, or
the fastest way through station S2,j-1, a transfer from line 2 to line 1, and then through stationS1,j.
the fastest way through station S2,j-1 and then directly through stationS2,j, or
the fastest way through station S1,j-1, a transfer from line 1 to line 2, and then through stationS2,j.
FASTEST-WAY(a, t, e, x, n)
1 f1[1] ← e1 + a1,1
2 f2[1] ←e2 + a2,1
3 for j ← 2 to n
4 do if f1[j - 1] + a1,j ≤ f2[j - 1] + t2,j-1 + a1,j
5 then f1[j] ← f1[j - 1] + a1, j
6 l1[j] ← 1
7 else f1[j] ← f2[j - 1] + t2,j-1 + a1,j
8 l1[j] ← 2
9 if f2[j - 1] + a2,j ≤ f1[j - 1] + t1,j-1 + a2,j
10 then f2[j] ← f2[j - 1] + a2,j
11 l2[j] ← 2
12 else f2[j] ∞ f1[j - 1] + t1,j-1 + a2,j
13 l2[j] ← 1
14 if f1[n] + x1 ≤ f2[n] + x2
15 then f* = f1[n] + x1
16 l* = 1
17 else f* = f2[n] + x2
18 l* = 2
PRINT-STATIONS(l, n)
1 i ← l*
2 print "line " i ", station " n
3 for j ← n downto 2
4 do i ← li[j]
5 print "line " i ", station " j - 1
line 1, station 6
line 2, station 5
line 2, station 4
line 1, station 3
line 2, station 2
line 1, station 1
MATRIX-MULTIPLY(A, B) 1 if columns[A] ≠ rows[B] 2 then error "incompatible dimensions" 3 else for i ← 1 to rows[A] // rows[A] 4 do for j ← 1 to columns[B] // col[B] 5 do C[i, j] ← 0 6 for k ← 1 to columns[A] // col[A] 7 do C[i, j] ← C[i, j] + A[i, k] · B[k, j] 8 return C从上面的代码中,我们可以看出两个矩阵AB相乘,他们的操作次数为rows[A]*col[B]*col[A].知道这一点之后,我们看下面:
MATRIX-CHAIN-ORDER(p)
1 n ← length[p] - 1
2 for i ← 1 to n
3 do m[i, i] ← 0
4 for l ← 2 to n ?l is the chain length.
5 do for i ← 1 to n - l + 1
6 do j ← i + l - 1
7 m[i, j] ← ∞
8 for k ← i to j - 1
9 do q ← m[i, k] + m[k + 1, j] + pi-1 pkpj
10 if q < m[i, j]
11 then m[i, j] ← q
12 s[i, j] ← k
13 return m and s
解释一下:1 // Matrix Ai has dimension p[i-1] x p[i] for i = 1..n 2 MatrixChainOrder(int p[]) 3 { 4 // length[p] = n + 1 5 n = p.length - 1; 6 // m[i,j] = Minimum number of scalar multiplications (i.e., cost) 7 // needed to compute the matrix A[i]A[i+1]...A[j] = A[i..j] 8 // cost is zero when multiplying one matrix 9 for (i = 1; i <= n; i++) 10 m[i,i] = 0; 11 12 for (L=2; L<=n; L++) { // L is chain length 13 for (i=1; i<=n-L+1; i++) { 14 j = i+L-1; 15 m[i,j] = MAXINT; 16 for (k=i; k<=j-1; k++) { 17 // q = cost/scalar multiplications 18 q = m[i,k] + m[k+1,j] + p[i-1]*p[k]*p[j]; 19 if (q < m[i,j]) { 20 m[i,j] = q; 21 s[i,j]=k// s[i,j] = Second auxiliary table that stores k 22 // k = Index that achieved optimal cost 23 24 } 25 } 26 } 27 } 28 }
matrix |
dimension |
---|---|
A1 |
30 × 35 |
A2 |
35 × 15 |
A3 |
15 × 5 |
A4 |
5 × 10 |
A5 |
10 × 20 |
A6 |
20 × 25 |
1 public class MatrixOrderOptimization { 2 protected int[][]m; 3 protected int[][]s; 4 public void matrixChainOrder(int[] p) { 5 int n = p.length - 1; 6 m = new int[n][n]; 7 s = new int[n][n]; 8 for (int i = 0; i < n; i++) { 9 m[i] = new int[n]; 10 m[i][i] = 0; 11 s[i] = new int[n]; 12 } 13 for (int ii = 1; ii < n; ii++) { 14 for (int i = 0; i < n - ii; i++) { 15 int j = i + ii; 16 m[i][j] = Integer.MAX_VALUE; 17 for (int k = i; k < j; k++) { 18 int q = m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]; 19 if (q < m[i][j]) { 20 m[i][j] = q; 21 s[i][j] = k; 22 } 23 } 24 } 25 } 26 } 27 public void printOptimalParenthesizations() { 28 boolean[] inAResult = new boolean[s.length]; 29 printOptimalParenthesizations(s, 0, s.length - 1, inAResult); 30 } 31 void printOptimalParenthesizations(int[][]s, int i, int j, /* for pretty printing: */ boolean[] inAResult) { 32 if (i != j) { 33 printOptimalParenthesizations(s, i, s[i][j], inAResult); 34 printOptimalParenthesizations(s, s[i][j] + 1, j, inAResult); 35 String istr = inAResult[i] ? "_result " : " "; 36 String jstr = inAResult[j] ? "_result " : " "; 37 System.out.println(" A_" + i + istr + "* A_" + j + jstr); 38 inAResult[i] = true; 39 inAResult[j] = true; 40 } 41 } 42 }
【例题1】余数最少的路径。
如图所示,有4个点,分别是A、B、C、D,相邻两点用两条连线C2k,C2k-1(1≤k≤3)表示两条通行的道路。连线上的数字表示道路的长度。定义从A到D的所有路径中,长度除以4所得余数最小的路径为最优路径。
求一条最优路径。
【分析】在这个问题中,如果A的最优取值可以由B的最优取值来确定,而B的最优取值为(1+3) mod 4 = 0,所以A的最优值应为2,而实际上,路径C1-C3-C5可得最优值为(2+1+1) mod 4 = 0,所以,B的最优路径并不是A的最优路径的子路径,也就是说,A的最优取值不是由B的最优取值决定的,即其不满足最优化原理,问题不具有最优子结构的性质。
由此可见,并不是所有的“决策问题”都可以用“动态规划”来解决,运用“动态规划”来处理问题必须满足最优化原理。
4.2 重叠子问题
问题利用递归方法会反复地求解相同的子问题,而不是一直生成新的子问题,我们就成该问题是重叠子问题。
在分治方法中通常就每一步都生成全新的子问题,动态规划就是利用重叠子问题性质:对每个子问题球结一次,将解存入一个表中,当再次需要这个子问题时直接查表,每次查表的代价为常数时间。
4.3 无后效性
它是这样一种性质:某阶段的状态一旦确定,则此后过程的演变不再受此前各种状态及决策的影响,简单的说,就是“未来与过去无关”,当前的状态是此前历史的一个完整总结,此前的历史只能通过当前的状态去影响过程未来的演变。具体地说,如果一个问题被划分各个阶段之后,阶段I中的状态只能由阶段I-1中的状态通过状态转移方程得来,与其它状态没有关系,特别是与未发生的状态没有关系。从图论的角度去考虑,如果把这个问题中的状态定义成图中的顶点,两个状态之间的转移定义为边,转移过程中的权值增量定义为边的权值,则构成一个有向无环加权图,因此,这个图可以进行“拓扑排序”,至少可以按它们拓扑排序的顺序去划分阶段。
简单来说就是在状态i求解时用到状态j而状态j求解时用到状态k…..状态N。
而如果求状态N时有用到了状态i这样求解状态的过程形成了环就没法用动态规划解答了,这也是上面用图论理解动态规划中形成的图无环的原因。
也就是说当前状态是前面状态的完美总结,现在与过去无关。
当然,要是换一个划分状态或阶段的方法就满足无后效性了,这样的问题仍然可以用动态规划解。
动态规划问题还有还多,这里就不一一举例子了,如最长公子序列,背包问题,最有二叉搜索树。之后再添加上去,先把上面两个例子理解了。
不得不说动态规划问题好难啊,我ri。
看下这篇博客吧:最大子数组和
标签:
原文地址:http://www.cnblogs.com/fu11211129/p/4197391.html