电路布线问题的几种动态规划算法是（电路布线问题的几种动态规划算法）

一、什么是动态规划算法？动态规划算法是将问题进行划分，定义问题状态之间的关系，使问题以递归(或分而治之)的方式求解。

动态规划算法的基本思想类似于分治法。它还把要解决的问题分解成几个子问题(阶段)，依次解决子阶段。前一个子问题的解决为后一个子问题的解决提供了有用的信息。在解决任何子问题时，列出所有可能的局部解，通过决策保留那些可能达到最佳的局部解，而丢弃其他局部解。依次求解每个子问题，最后一个子问题就是初始问题的解。

二、动态规划算法的实现动态规划的主要难点在于理论设计，即上述四个步骤的确定。一旦设计完成，实现部分就会非常简单。使用动态规划解决问题时，最重要的是确定动态规划的三个要素：

(1)问题的阶段

(2)每个阶段的状态

(3)从上一阶段到下一阶段的转化之间的递归关系。

递归关系必然是从下一个最小问题到更大问题的转换。从这个角度来看，动态编程往往可以通过递归程序来实现。但由于递归可以充分利用之前保存的子问题的解来减少重复计算，因此对于大规模问题具有不可比拟的优势，这也是动态规划算法的核心。

当动态规划的这三个要素确定后，整个求解过程就可以用一个最优决策表来描述，这个最优决策表是一个二维表，其中行代表决策阶段，列代表问题状态。表格中要填写的数据一般对应最优值(如最短路径、最长公共子序列、最大值等。)这个问题在某个阶段、某个状态下。填充表的过程基于递归关系，从一行一列开始，行或列按优先级顺序排列。f(n，m)=max{f(n-1，m)，f(n-1，m-w[n]) P(n，m)}

三。动态规划算法和策略编辑的基本思想。动态规划算法的基本思想类似于分治法。它还把要解决的问题分解成几个子问题(阶段)，依次解决子问题。前一个子问题的解决为后一个子问题的解决提供了有用的信息。在解决任何子问题时，列出所有可能的局部解，通过决策保留那些可能达到最佳的局部解，而丢弃其他局部解。依次求解每个子问题，最后一个子问题就是初始问题的解。

由于动态规划求解的问题大多具有子问题重叠的特点，为了减少重复计算，每个子问题只求解一次，其不同阶段的不同状态存储在一个二维数组中。

四、动态规划算法的基本框架为(j=1；j"=m；J=j 1) //第一阶段

Xn [j]=初始值；

for(I=n-1；I》=1；I=i-1)//其他n-1级

for(j=1；j"=f(I)；J=j 1)//f(i)与I相关的表达式

Xi [j]=j=max(或min) {g (Xi-1 [J1: J2])，g(Xi-1[JK:JK 1])}；

t=g(x1[J1:J2])；//用子问题的最优解来求解整个问题的最优解的方案

print(x1[J1])；

for(I=2；I"=n-1；i=i 1)

{

t=t-Xi-1[Ji]；

for(j=1；j"=f(I)；j=j ^ 1)

if(t=Xi[冀])

打破；

}

动词（verb的缩写）电路布线问题的几种动态规划算法

#包括《iostream》

#包括《string》

使用命名空间std

int MNS(int i，int j)；//自上而下备忘录算法

int MNS _ 2(int n)；//自底向上动态编程算法

void trace back _ 1(int n)；//输出符合条件的导线。

void trace back _ 2(int n)；//输出符合条件的导线。

void trace back _ 3(int n)；//输出符合条件的导线。

int MNS _ 3(int n)；//优化的动态规划算法

int MNS _ 4(int n)；//动态规划算法的另一个想法

int MNS _ 5(int n)；//算法4的改进：分阶段讨论，避免不必要的计算

int MNS _ 6(int n)；//将问题转化为最长序列，不降。

const int N=10

int c[N 1]={0，8，7，4，2，5，1，9，3，10，6 }；

int s[N 1][N 1]；

int a[N 1][N 1]；

int b[N 1][N 1]；

int pre[N 1]；//上一条记录

int cur[N 1]；//当前行记录

int S[N 1]；//记录最长的升序子序列的长度，直到元素I。

int main()

{

cout《MNS(N，N)《endl；

cout《MNS _ 2(N)》endl；

cout《MNS 3(N)》endl；

cout《MNS _ 4(N)》endl；

cout《MNS 5(N)》endl；

cout《MNS 6(N)》endl；

回溯_ 1(N)；

traceback _ 2(N)；

traceback _ 3(N)；

返回0；

}

Int MNS(int i，int j)//自上而下备忘录算法

{

if (s[i][j]》 0)

return s[I][j]；

If (i==1) //处理第一根线

{

s[i][j]=(j 《c[i])？0 : 1;

}

其他

{

s[i][j]=MNS(i-1，j)；

if(j)"=c[I]MNS(I-1，c[I]-1)1"s[I][j])

s[I][j]=s[I-1][c[I]-1]1；//S [I-1] [C [I]-1]已经记录在if语句中

}

return s[I][j]；

}

Int MNS_2(int n)//自底向上的动态规划算法

{

//首先处理第一条线

for(int j=1；j《c[1]；j)

s[1][j]=0；

for(int j=c[1]；j"=n；j)

s[1][j]=1；

//然后处理中间的线

for(int I=2；我《n；我)

{

for(int j=1；j《c[I]；j)

{

s[I][j]=s[I-1][j]；

}

for(int j=c[I]；j"=n；j)

{

s[I][j]=(s[I-1][c[I]-1]1]s[I-1][j])？s[I-1][c[I]-1]1:s[I-1][j]；

}

}

//重新处理最后一根焊线

s[n][n]=(s[n-1][c[n]-1]1]s[n-1][n])？s[n-1][c[n]-1]1:s[n-1][n]；

return s[n][n]；

}

Void Traceback_1(int n) //输出满足条件的连线

{

int j=n；

for(int I=n；我》1；我-)

{

if(s[I][j]”s[I-1][j])

{

cout《我》《c[I]》endl；

j=c[I]-1；

}

}

if(j"=c[1])

{

cout《1》-《c[1]》endl；

}

}

Void Traceback_2(int n) //导体的输出满足条件。

{

int j=n；

for(int I=n；我》1；我-)

{

if (a[i][j]》 a[i-1][j])

{

cout《我》《c[I]》endl；

j=c[I]-1；

}

}

if(j"=c[1])

{

cout《1》-《c[1]》endl；

}

}

Void Traceback_3(int n) //导体的输出满足条件。

{

int j=n；

for(int I=n；我》1；我-)

{

if (b[i][j]》 b[i-1][j])

{

cout《我》《c[I]》endl；

j=c[I]-1；

}

}

if(j"=c[1])

{

cout《1》-《c[1]》endl；

}

}

Int MNS_3(int n)//优化的动态规划算法

{

//首先处理第一条线

for(int j=1；j《c[1]；j)

pre[j]=0；

for(int j=c[1]；j"=n；j)

pre[j]=1；

//然后处理中间的线

for(int I=2；我《n；我)

{//处理当前行cur

for(int j=1；j《c[I]；j)

{

cur[j]=pre[j]；

}

for(int j=c[I]；j"=n；j)

{

cur[j]=(pre[c[I]-1]1"pre[j])？pre[c[I]-1]1:pre[j]；

}

//将当前行信息cur复制到pre

for(int j=1；j"=n；j)

{

pre[j]=cur[j]；

}

}

//重新处理最后一根焊线

cur[n]=(pre[n-1]1"pre[n])？pre[n-1]1:pre[n]；

返回cur[n]；

}

MNS _ 4(int n)//另一种思想的动态规划算法，非常类似于最长公共子序列。

{

for(int I=1；I \u=n；我)

{

for(int j=1；j"=n；j)

{

if (j==c[i])

a[I][j]=a[I-1][j-1]1；

其他

a[i][j]=max(a[i-1][j]，a[I][j-1])；

}

}

返回a[n][n]；

}

int _ 5(int n)//算法4的改进：分阶段讨论，避免不必要的计算

{

for(int I=1；I \u=n；我)

{

for(int j=1；j《c[I]；J )//在终端C [I]的左侧区域，最优解与没有终端I时一致。

{

b[I][j]=b[I-1][j]；

}

b[I][c[I]]=b[I-1][c[I]-1]1；

for(int j=c[I]1；j"=n；J )//在终端C [I]的右边区域，最优解可能包含也可能不包含终端I。

{

b[i][j]=max(b[i-1][j]，b[I][j-1])；

}

}

返回a[n][n]；

}

Int MNS_6(int n)//把问题转化成最长的序列，不降。

{

s[1]=1；//默认情况下，直到元素I的最长升序子序列的长度为1

for(int I=2；I \u=n；我)

{

int m=0；

for(int j=I-1；j》0；j-)//求逆序不大于A [I]的最长元素。

{

if(c[I]”c[j]S[j]”m)

{

m=S[j]；

}

}

s[I]=m ^ 1；

}

int len=S[n]；

for(int I=n-1；我》0;我-)

{

if (S[i]》 len)

{

len=S[I]；

}

}

返回低输入联网（low-entry networking的缩写）

}