算法导论 动态规划

动态规划:dynamic programming

dp:

最优子结构

重叠子问题

独立子问题

步骤：

1.描述一个最优子结构

2.递归定义最优解

3.自底向上求出最优解的值

4.按要求求出一个最优解

 

其时间效率为：  有多少子问题＊这些子问题分别有多少选择

总结：还挺好玩，感觉和高中的推理差不多，只是要深植于   找到特征＋找到最优子结构＋描述最优子结构＋递归定义＋求解＋加上路径数组来构造最优解。

从前几项的关系得出推理：

从本问题可以被分为几个问题来得出推理

从要求的最后一项往前推

 

 

装配线调度：

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    int e1,e2,x1,x2,a1[7],a2[7];
    int f[2][7],fe,le,l[2][7],t1[7],t2[7];
    scanf("%d%d",&e1,&e2);
    scanf("%d%d",&x1,&x2);
    for(int i=1;i<=6;i++)
        scanf("%d",&a1[i]);
    for(int i=1;i<=6;i++)
        scanf("%d",&a2[i]);
    for(int i=1;i<=5;i++)
        scanf("%d",&t1[i]);
    for(int i=1;i<=5;i++)
        scanf("%d",&t2[i]);
    f[1][1]=e1+a1[1];
    f[2][1]=e2+a2[1];
    
    for(int j=2;j<=6;j++)
    {
        if(f[1][j-1]+a1[j]<=f[2][j-1]+t2[j-1]+a1[j])
        {
            f[1][j]=f[1][j-1]+a1[j];
            l[1][j]=1;
        }
        else
        {
            f[1][j]=f[2][j-1]+t2[j-1]+a1[j];
            l[1][j]=2;
        }
        
        if(f[2][j-1]+a2[j]<=f[1][j-1]+t1[j-1]+a2[j])
        {
            f[2][j]=f[2][j-1]+a2[j];
            l[2][j]=2;
        }
        else
        {
            f[2][j]=f[1][j-1]+t1[j-1]+a2[j];
            l[2][j]=1;
        }
    }
    if(f[1][6]+x1<=f[2][6]+x2)
    {
        fe=f[1][6]+x1;
        le=1;
    }
    else
    {
        fe=f[2][6]+x2;
        le=2;
    }
    
    printf("%d\n",fe);
    
    int i=le;
    printf("print line %d,station %d\n",i,6);
    for(int j=6;j>=2;j--)
    {
        i=l[i][j];
        printf("print line %d,station %d\n",i,j-1);
    }
    return 0;
}

矩阵链乘法

节省了常数递归时间，还可以根据存取模式进行求解。

#include <iostream>
#include <cstdio>
#define inf 1e9
using namespace std;
int s[7][7];
void print_optimal_parens(int i,int j)
{
    if(i==j)
        printf("A%d",i);
    else
    {
        printf("(");
        print_optimal_parens(i,s[i][j]);
        print_optimal_parens(s[i][j]+1,j);
        printf(")");
    }
        
}

int main()
{
    int p[7];
    for(int i=0;i<=6;i++)
        scanf("%d",&p[i]);
    
    int m[7][7];
    for(int i=1;i<=6;i++)
        m[i][i]=0;
    for(int l=2;l<=6;l++)
    {
        for(int i=1;i<=6-l+1;i++)
        {
            int j=i+l-1;
            m[i][j]=inf;
            for(int k=i;k<=j-1;k++)
            {
                int q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
                if(q<m[i][j])
                {
                    m[i][j]=q;
                    s[i][j]=k;
                }
            }
        }
    }
    printf("%d\n",m[1][6]);
    
    print_optimal_parens(1,6);
    return 0;
}

 做备忘录的自顶向下的递归法时间效率O(n^3)

可以对一些子问题根本不需要求解的问题避免求解。

#include <iostream>
#include <cstdio>
#define inf 1e9
using namespace std;
int s[7][7];
int p[7];
int m[7][7];
void print_optimal_parens(int i,int j)
{
    if(i==j)
        printf("A%d",i);
    else
    {
        printf("(");
        print_optimal_parens(i,s[i][j]);
        print_optimal_parens(s[i][j]+1,j);
        printf(")");
    }
        
}

int lookup_chain(int i,int j)
{
   if(m[i][j]<inf)
       return m[i][j];
    if(i==j)
        m[i][j]=0;
    for(int k=i;k<=j-1;k++)
    {
        int q=lookup_chain(i,k)+lookup_chain(k+1,j)+p[i-1]*p[k]*p[j];
        if(q<m[i][j])
        {
            m[i][j]=q;
            s[i][j]=k;
        }
    }
    return m[i][j];
}

void memorzed_matrix_chain()
{
    for(int i=1;i<=6;i++)
        for(int j=i;j<=6;j++)
            m[i][j]=inf;
    lookup_chain(1,6);
}




int main()
{
    for(int i=0;i<=6;i++)
        scanf("%d",&p[i]);
    memorzed_matrix_chain();
    printf("%d\n",m[1][6]);
    
    print_optimal_parens(1,6);
    return 0;
}

 

 

最长公共子序列的实现算法：加打印最优解

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>

using namespace std;

void print_lcs(int b[][5],char x[],int i,int j)
{
    if(i==-1 || j==-1)
        return;
    if(b[i][j]==1)
    {
        printf("%c",x[i]);
        print_lcs(b,x,i-1,j-1);
    }
    else if(b[i][j]==2)
        print_lcs(b,x,i-1,j);
    else if(b[i][j]==3)
        print_lcs(b,x,i,j-1);
    
}
int lcs(char x[],char y[])
{
    int m=strlen(x);
    int n=strlen(y);
    int c[m+1][n+1];
    int b[8][5];
    for(int i=0;i<=m;i++)
        c[i][0]=0;
    for(int i=0;i<=n;i++)
        c[0][i]=0;
    
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(x[i]==y[j])
            {
                c[i+1][j+1]=c[i][j]+1;
                b[i][j]=1;
            }
            
            else if(c[i][j+1]>=c[i+1][j])
            {
                c[i+1][j+1]=c[i][j+1];
                b[i][j]=2;
            }
            else if(c[i][j+1]<c[i+1][j])
            {
                c[i+1][j+1]=c[i+1][j];
                b[i][j]=3;
            }
        }
    }
    print_lcs(b,x,m-1,n-1);
    puts("");
    return c[m][n];
}
int main()
{
    char x[]="ABCBDAB";
    char y[]="ABCB";
    int LCS=lcs(x,y);
    printf("%d\n",LCS);
    return 0;
}

 

最优二叉搜索树

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#define inf 0x3f3f3f3f
using namespace std;


float optimal_bst(float p[],float q[],int n)
{
    float e[n+2][n+2],w[n+2][n+2];
    int root[7][7];
    
    for(int i=1;i<=n+1;i++)
    {
        e[i][i-1]=q[i-1];
        w[i][i-1]=q[i-1];
    }
    
    for(int l=1;l<=n;l++)
    {
        for(int i=1;i<=n-l+1;i++)
        {
            int j=i+l-1;
            e[i][j]=inf;
            w[i][j]=w[i][j-1]+p[j]+q[j];
            for(int r=i;r<=j;r++)
            {
                float t=e[i][r-1]+e[r+1][j]+w[i][j];
                if(t<e[i][j])
                {
                    e[i][j]=t;
                    root[i][j]=r;
                }
            }
        }
    }
    return e[1][n];
}


int main()
{
    float q[7],p[7];
    for(int i=1;i<=5;i++)
        scanf("%f",&p[i]);
    for(int i=0;i<=5;i++)
        scanf("%f",&q[i]);
    printf("%f\n",optimal_bst(p,q,5));
    return 0;
}