算法:动态规划总结

动态规划和分治的区别:动态规划的子问题不相互独立，分治的子问题相互独立

因为动态规划的子问题相互影响，所以为了避免大量的重复计算，我们可以用一个表来记录所有已经解决的问题。

设计动态规划算法的步骤:

（1）找出最优解的性质，并刻画其结构特征。

（2）递归地定义最优值

（3）以自底向上的方式计算出最优值

（4）根据计算最优值时得到的信息，构造一个最优解

关于矩阵连乘问题的求索:

（1）矩阵连乘，连乘顺序不同，计算次数不同

（2）可以采取分治看法，比如三个连乘，可以分为1 23或者12 3然后取其小，当剩一个矩阵返回0

（3）若是A[1]--A[N],区分为A[1-k]--A[k+1-n],那么计算量就是A[1-k]的矩阵连乘的计算量，加后一个矩阵连乘的计算量再加上连乘后两矩阵的计算量

（4）要知道的是要保证原本矩阵的计算量是最优解，那么他新分的两个矩阵集合加上中间乘积的值也应当是最优解

（5）这样一来就采取递归方式，A[i-j]，使k从[i,j)左闭右开，然后遍历查找使得计算结果最小的就是

递归算法，s记录每次需要分割的地方，m记录每次的最小值

int MatrixChain(int *p,int i,int j,int **m,int **s)
{
num +=1;
if(i == j) return 0;
if(m[i][j] > 0) return m[i][j];
else if(i < j)
{
m[i][j] = 0 + MatrixChain(p,i+1,j,m,s) + p[i-1]*p[i]*p[j];//ii
s[i][j] = i;
for(int k = i+1;k<j;++k)
{
int t = MatrixChain(p,i,k,m,s)+MatrixChain(p,k+1,j,m,s)+p[i-1]*p[k]*p[j];
if(m[i][j] > t)
{
m[i][j]= t;
s[i][j]= k;
}
}
return m[i][j];
}
}

非递归算法:

int MatrixChain2(int *p,int n,int **m,int **s)
{
int i,j;
for(i =1;i<=n;++i) m[i][i] = 0;
for(int len=2;len <=n; ++len)
{
for(i = 1;i <= n-len+1;++i)
{
j = i+len-1;
m[i][j] = 0+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(m[i][j] > t)
{
m[i][j] = t;
s[i][j] = k;
}
}
}
Print_2Array(m,n+1,n+1);
}
return m[1][n];
}

两序列X，Y求解他们最长公共子序列

int Find1(int **c,int i,int j,int* local1)
{
int max = 0;
for(int k = 1;k < i;k++)//0的话那全是0没有查找的必要
{
for(int l = 1;l < j;l++)
{
int tmp = 0;
int tmp1 = k;
int tmp2 = l;
while(( (tmp1<=i) && (tmp2<=j ) )&& c[tmp1][tmp2]==1)
{
tmp1++;
tmp2++;
tmp++;
}
if(max<tmp)
{
*local1 = tmp1;
max = tmp;
}
}
}
return max;
}


void Print_Same(int** c,int max,int a,char *X)
{
int t = a-max;
for(int i = max;i > 0;--i)
{
cout<<X[t]<<" ";
++t;
}
cout<<endl;
}

求解一个序列最长连续对称序列//X2是X1逆序以后的序列

void Print_sym(char* X,char* X2,int M,int**d,int **d2)
{
LCSLength(X,X2,M,M,d2,d);//d相当于c
int local1;
int max = Find1(d,M,M,&local1);
Print_Same(d, max,local1,X);
}

通过如下函数得到c：

int num = 0;
int LCSLength(char *X,char *Y,int m, int n,int **s,int **c)
{
int i,j;
for(i = 0;i<=n;++i) s[0][i] = 0;
for(i = 0;i<=m;++i) s[i][0] = 0;


for(i = 1;i<=m;++i)
{
for(j = 1; j<=n;++j)
{
if(X[i] == Y[j])
{
s[i][j] = s[i-1][j-1]+1;
c[i][j] = 1;
}else if(s[i][j-1] > s[i-1][j])
{
s[i][j] = s[i][j-1];
c[i][j] = 3;
}else
{
s[i][j] = s[i-1][j];
c[i][j] = 2;
}
}
// Print_2Array(s,m+1,n+1);
}
return s[m][n];
}