C语言穷举法最长公共子序列,最长公共子序列问题

Biological applications often need to compare the DNA of two (or more) different organisms. A strand of DNA consists of a string of molecules called bases, where the possible bases are adenine, guanine, cytosine, and thymine. Representing each of these bases by its initial letter, we can express a strand of DNA as a string over the finite set {A,C,G,T}.

这是生物学应用中最为常见的“最长公共子序列问题”。

动态规划原理

能够用动态规划解决的问题，通常具有两种属性：第一，存在最优子结构，即可以用“剪切，粘帖”的方法来证明；第二，具有重叠子问题。

递归和穷举算法分析

在矩阵链乘法的问题中，可以使用递归和穷举两种方法来解决最优的括号化方案。其中，对每一种方案计算乘法运算次数。

用穷举法的时候，表中的每一个节点都必须访问，记访问一个节点的时间为$b_k$

则有递推式：

$b_n= sum_{k=0}^{n-1}b_kb_{n-1-k}$

该递推式符合卡特兰数，可以推出通项公式为：

$b(n)=frac{4^n}{sqrt{pi}n^{3/2}}(1+O(1/n))$

阶是关于n的指数函数。

用Recursive-Matrix-Chain递归求解，递推式符合

$T(n)geq1+sum_{k=1}^{n-1}(T(k)+T(n-k)+1) qquad n>1$

可以求得递推公式为：

$T(n)geq2^{n-1}$

可见朴素递归算法比穷举好一些。

动态规划问题和分治法区别

在merge-sort过程中，可以发现，问题不具有重叠字问题的性质，如下图所示，所有的子问题均不重叠。

最大化矩阵括号方案

最大化矩阵括号化方案，问题仍然具有最优子结构性质。因为“剪切，粘帖”的处理方式没有变。

假设最大括号化方案能够使结果最优，则其中的划分为：

$A_1A_2dots dots A_kA_{k+1}dots A_j$

如果该方案不是最优的，总可以找到另外一种方案如下：

$A_1A_2dots A_iA_{i+1}dots dots A_j$

来替代该方案，使得结果最优。

贪心和动态规划的区别

贪心算法的原理是：我们不必计算原问题的最优解，总是可以在求解子问题的时候划分出$A_iA_{i+1}dots A_j$，选定的k使得$p_{i-1}p_{k}p_{j}$最小。这样的贪心算法并不能够得到最优解。原因如下：

虽然我们求出来的最优解如红色的图，但很有可能

$p_{u-1}p_wp_v

原因如下：最优解的函数表达式与贪心中的$p_k$函数表达式不同，所以贪心算法并不能够用于最优解问题。

编程验证：

贪心策略如下：

//下面这是用错误的贪心算法求解的问题：

Matrix_Chain Matrix_Chain_Order_greedy(int p[])

{

int N=n-1;

Matrix_Chain T_greedy;

for(int i=0;i

T_greedy.m[i][i]=0;

for(int l=2;l<=N;l++)

{

for(int i=1;i<=N-l+1;i++)

{

int j=i+l-1;

T_greedy.m[i-1][j-1]=INFINITY;

int q_min=INFINITY;

for(int k=i;k<=j-1;k++)

{

int q=T_greedy.m[i-1][k-1]+T_greedy.m[k][j-1]+p[i-1]*p[k]*p[j];

if(q_min>p[i-1]*p[k]*p[j])

{

q_min=p[i-1]*p[k]*p[j];

T_greedy.m[i-1][j-1]=q;

T_greedy.s[i-1][j-1]=k-1;

}

}

}

}

return T_greedy;

}

结果如图：

很显然地看出，greedy_result得到了不同的括号化结果。

钢条切割问题的限制

如果我们限制，在r=4的时候，只能够切割成两段长度为1的钢条，则r=4的时候，最优切割方案1+1+1+1无法成立。

外币兑换问题

该问题可以看成是一种矩阵链乘法的变形，当佣金$C_k$为任意值的时候，并不符合最优子结构的性质。

具体的描述见下图：

合并问题的代价，可以描述为$C_k$

解决每个问题所需要的代价为$R_k$

总代价的递推式为：

$R_k+C_k$

$R_{k2}+C_{k_2}$

如果$C_k$不为常数，假设它可以用一个$f(k)$描述，则问题的代价可以描述为：

$R_k+f(k)$

动态规划算法只能保证$R_k$的最优解，并不能保证$f(k)$的最优解。

最长公共子序列

最长公共子序列的求解，如下图所示：

可以看到，最长公共子序列的依赖关系如上图所示，[i,j]的值取决于{[i-1,j-1],[i,j-1],[i-1,j]}

实现方法如下：

LCS_len.h

#include

#include

#include

#define M 6

#define N 7

wchar_t b[N+1][M+1]={'S'}; //表示起点start

int c[N+1][M+1]={0};

wchar_t northwest=L'\\', up=L'|', leftway=L'-';

void LCS_length(char *x,char *y)

{

for(int i1=0;i1<=N;i1++)

b[i1][0]='S';

for(int j1=0;j1<=M;j1++)

b[0][j1]='S';

for(int i=1;i<=N;i++)

{

for(int j=1;j<=M;j++)

{

if(x[i]==y[j])

{

c[i][j]=c[i-1][j-1]+1;

b[i][j]=northwest; //Northwest往左上

}

else

{

if(c[i-1][j]>=c[i][j-1])

//c[i-1][j-1] 过渡到 c[i][j]，需要将c[i-1][j]和c[i][j-1]比较大小

//取较大的那一个值

{

c[i][j]=c[i-1][j];

b[i][j]=up; //Up往上