C++博客-DjvuLee-随笔分类-动态规划

最大序列和[1077@Jobdo]

DjvuLee — Wed, 07 Mar 2012 08:34:00 GMT

//@Jobdo 清华06 典型的DY问题
//本题的时间复杂度为O(n).空间复杂度为O(1).
#include
#include
using namespace std;

typedef long long int T;
T s[2];

int main()
{
    int n;
    while(~scanf("%d",&n)){
        bool first=true;
        T    myMax, tp;
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&tp);
            if(first){
                myMax=s[1]=tp;
                first=false;
            }
            else
            {
                s[1]= s[0]>0 ? s[0]+tp : tp;
                if(myMax                    myMax=max(s[1],s[0]);
            }
            s[0]=s[1];
        }
        printf("%lld\n",myMax);
    }//end while

    return 0;
}

DjvuLee 2012-03-07 16:34 发表评论

Zipper[2192@pku]

DjvuLee — Fri, 02 Mar 2012 01:42:00 GMT

//@pku DY问题
//自底向上的迭代通过了
#include
#include<string>
#include
using namespace std;

#define N 210
#define fin cin
bool flag[N][N];
string s1,s2,s;
int main()
{
    //ifstream fin("input.txt");
    int num;
    while(fin>>num){
        for(int t=1;t<=num;t++)
        {
            fin>>s1>>s2>>s;
            for(int j=1;j<=s2.size();j++)
            {
                string sub=s2.substr(0,j);//s2的前j个字符
                string subs=s.substr(0,j);
                flag[0][j]= sub==subs ? true : false ;
            }
            for(int i=1;i<=s1.size();i++)
            {
                string sub=s1.substr(0,i);//s1的前i个字符
                string subs=s.substr(0,i);
                flag[i][0]= sub==subs ? true : false;
            }

            //i,j表示个数
            for(int i=1;i<=s1.size();i++)
                for(int j=1;j<=s2.size();j++)
                    if( (flag[i-1][j] && s[i+j-1]==s1[i-1]) || (flag[i][j-1] && s[i+j-1]==s2[j-1]) )
                        flag[i][j]=true;
                    else
                        flag[i][j]=false;

            if(flag[s1.size()][s2.size()])
                cout<<"Data set "<            else
                cout<<"Data set "<        }
    }//end while

    return 0;
}

同一个题目，用备忘录却TLE了。看来递归调用的速度慢了很多。

//@pku DY
//备忘录方式
//程序理论上没有错误，但是TLE
#include
#include
#include<string>
using namespace std;

#define N 210
#define fin cin
bool flag[N][N];
string s1,s2,s;
bool dp(int pos1, int pos2, int pos);
int main()
{
//ifstream fin("input.txt");
    int num;
    while(fin>>num){
        for(int t=1;t<=num;t++)
        {
            fin>>s1>>s2>>s;
            for(int i=0;i//s1,s2的下标都从0开始
                for(int j=0;j                        flag[i][j]=false;

            bool res=dp(s1.size()-1,s2.size()-1,s.size()-1);
            if(res)
                cout<<"Data set "<            else
                cout<<"Data set "<        }
    }//end while

    return 0;
}

bool dp(int pos1, int pos2, int pos)
{
    if(pos2==-1)//边界值
    {
        string sub1=s1.substr(0,pos1+1);
        string sub=s.substr(0,pos+1);
        return flag[pos1+1][0]=(sub1==sub);
    }
    if(pos1==-1)//边界值
    {
        string sub2=s2.substr(0,pos2+1);
        string sub=s.substr(0,pos+1);
        return flag[0][pos2+1]=(sub2==sub);
    }
    else
    {
        if( flag[pos1+1][pos2+1])//已经计算了返回计算值
            return true;
        else
        {
            flag[pos1][pos2+1]=dp(pos1-1,pos2,pos-1);
            flag[pos1+1][pos2]=dp(pos1,pos2-1,pos-1);

            if( (flag[pos1][pos2+1] && s1[pos1]==s[pos]) ||
                (flag[pos1+1][pos2] && s2[pos2]==s[pos])  )
                return flag[pos1+1][pos2+1]=true;
            else
                return flag[pos1+1][pos2+1]=false;
        }
    }
}

DjvuLee 2012-03-02 09:42 发表评论

Human Gene Functions[1080@pku]

DjvuLee — Thu, 01 Mar 2012 02:04:00 GMT

//@pku DY问题，最重要的是要找到最优子结构
//最优子结构为TAG标记处
//本题反映的就是子结构的最终边界返回出来不是很自然
#include
#include<string>
#include
using namespace std;

#define N 120
#define MAX 10000//考虑到串最长不会超过100，全部匹配也只有500
int flag[N][N];

int dp(int pos1,int pos2);
int getVal(char ch1, char ch2);
int M[5][5]={{5,-1,-2,-1,-3},
             {-1,5,-3,-2,-4},
             {-2,-3,5,-2,-2},
             {-1,-2,-2,5,-1},
             {-3,-4,-2,-1,-10000}};
string s1,s2;
int main()
{
    int n;
    while(cin>>n){
        for(int i=0;i        {
            int len1,len2;
            cin>>len1>>s1;
            cin>>len2>>s2;

            int cn=0;
            for(int i=0;i                for(int j=0;j                    flag[i][j]=MAX;
            cn=dp(s1.size()-1,s2.size()-1);
            cout<        }
    }//end while
}

int dp(int pos1,int pos2)
{
    if(pos1==-1 && pos2 ==-1)
        return 0;
    if(pos1==-1)
    {
        return getVal('-',s2[pos2])+dp(-1,pos2-1);
    }
    if(pos2==-1)
    {
        return getVal(s1[pos1],'-')+dp(pos1-1,-1);
    }
    else
    {
        if(flag[pos1+1][pos2+1]!=MAX)
            return flag[pos1+1][pos2+1];
        else
        {
            int val1=getVal(s1[pos1],s2[pos2])+dp(pos1-1,pos2-1);
            int val2=getVal(s1[pos1],'-')+dp(pos1-1,pos2);
            int val3=getVal('-',s2[pos2])+dp(pos1,pos2-1);

            return flag[pos1+1][pos2+1]=max(val1,max(val2,val3));//TAG
        }
    }
}

int getVal(char ch1, char ch2)
{
    if(ch1==ch2)
        return 5;
    int pos1,pos2;
    switch(ch1){
        case 'A':{pos1=0;break;}
        case 'C':{pos1=1;break;}
        case 'G':{pos1=2;break;}
        case 'T':{pos1=3;break;}
        case '-':{pos1=4;break;}
    }//end switch
    switch(ch2){
        case 'A':{pos2=0;break;}
        case 'C':{pos2=1;break;}
        case 'G':{pos2=2;break;}
        case 'T':{pos2=3;break;}
        case '-':{pos2=4;break;}
    }//end switch

    return M[pos1][pos2];
}

DjvuLee 2012-03-01 10:04 发表评论

Common Subsequence[1458@pku]

DjvuLee — Wed, 29 Feb 2012 04:18:00 GMT

//@pku 1458 经典的DY问题LCS
//采用备忘录的方法
#include
#include
#include<string>
using namespace std;

#define N 1500
int flag[N][N];

int getlen(string &s1,int i, string &s2, int j);
int main()
{
    string s1,s2;
    int max=0;
    while(cin>>s1>>s2){
        memset(flag,-1,sizeof(flag));
        max=getlen(s1,s1.size()-1,s2,s2.size()-1);
        cout<    }//end while

    return 0;
}

int getlen(string &s1,int i, string &s2, int j)
{
    if(i==-1 || j==-1)
        return 0;
    else
    {
        if(flag[i][j]!=-1)
            return flag[i][j];
        if(s1[i]==s2[j])
        {
            if(i>0 && j>0)
            {
                flag[i-1][j-1]=getlen(s1,i-1,s2,j-1);
                return 1+flag[i-1][j-1];
            }
            else
            {
                return 1+getlen(s1,i-1,s2,j-1);
            }
        }
        else
        {
            if(i>0 && j>0)
            {
                flag[i][j-1]=getlen(s1,i,s2,j-1);
                flag[i-1][j]=getlen(s1,i-1,s2,j);
                return max(flag[i][j-1],flag[i-1][j]);
            }
            else
            {
                return max(getlen(s1,i,s2,j-1),getlen(s1,i-1,s2,j));
            }
        }
    }
}

DjvuLee 2012-02-29 12:18 发表评论

Compromise[2250@pku]

DjvuLee — Wed, 29 Feb 2012 04:17:00 GMT

//@pku DY问题完整的LCS问题
//采用迭代的方法
//标志数组的初始化很重要,让s1,s2的下标从1开始很方便设置边界检测
#include
#include<string>
#include
#include
using namespace std;

#define N 120
#define Left -1
#define Up 1
#define NW    0
#define fin cin
int flag[N][N];
int dir[N][N];

vector<string> s1,s2,res;
void len();
void Output(int i,int j);
int main()
{
    //ifstream fin("input.txt");
    string s;
    while(1){
        s1.clear();
        s2.clear();
        res.clear();
        while(1)
        {
            fin>>s;
            if(s=="#")
                break;
            s1.push_back(s);
        }
        while(fin>>s){
            if(s=="#")
                break;
            s2.push_back(s);
        }
        len();
        Output(s1.size(), s2.size());
        bool first=true;
        for(int i=0;i        {
            if(first){
                first=false;
            }
            else
                cout<<" ";
            cout<        }
        cout<        if(fin.eof())
            break;
    }//end while
    return 0;

}

void len()
{
    for(int i=0;i<=s1.size();i++)
        flag[i][0]=0;
    for(int j=0;j<=s2.size();j++)
        flag[0][j]=0;

    for(int i=1;i<=s1.size();i++)
    {
        for(int j=1;j<=s2.size();j++)
        {
            if(s1[i-1]==s2[j-1])
            {
                flag[i][j]=1+flag[i-1][j-1];
                dir[i][j]=NW;
            }
            else
            {
                flag[i][j]=max(flag[i-1][j],flag[i][j-1]);
                if(flag[i-1][j]                    dir[i][j]=Left;
                else
                    dir[i][j]=Up;
            }
        }
    }
}

void Output(int i,int j)
{
    if(i==0 || j==0)
        return ;
    if(dir[i][j]==NW)
    {
        Output(i-1,j-1);
        res.push_back(s1[i-1]);
    }
    else
    {
        if(dir[i][j]==Up)
            Output(i-1,j);
        else
            Output(i,j-1);
    }
}

DjvuLee 2012-02-29 12:17 发表评论

Palindrome[1159@pku]

DjvuLee — Wed, 29 Feb 2012 04:15:00 GMT

//@pku DY问题
//最重要的是要找到重叠子问题，本题用LCS的方法是错误的
//本题最大的问题是flag数组太大，用int会MLE，改用short可以勉强通过
//感觉每次用备忘录的方法时内存的开销都是一个很大的问题
#include
#include
#include<string>
#include
using namespace std;

#define N 5010
short flag[N][N];
string s;
int dp(int low,int high);
int main()
{
    int n;
    while(cin>>n){
        int cn=0;
        cin>>s;
        memset(flag,-1,sizeof(flag));

        cn=dp(0,n-1);
        cout<    }//end while
    return 0;
}

int dp(int low,int high)
{
    if(low>=high)
        return 0;
    else
    {
        if(flag[low][high]!=-1)
            return flag[low][high];

        else
        {
            if(s[low]==s[high])
                return flag[low+1][high-1]=dp(low+1,high-1);
            else
            {
                flag[low+1][high]=dp(low+1, high);
                flag[low][high-1]=dp(low, high-1);
                return flag[low][high]=1+min(flag[low+1][high],flag[low][high-1]);
            }
        }
    }
}

DjvuLee 2012-02-29 12:15 发表评论

The Triangle[1163@pku]

DjvuLee — Mon, 27 Feb 2012 02:15:00 GMT

第一种方式：备忘录

//@pku 1163 DY问题
//最基础的DY问题,采用的是备忘录方式
//在max(dp(r+1,c),dp(r+1,c+1))处错写成了max(s[r+1][c],s[r+1][c+1]),导致了调试时间。
#include
#include
#include
using namespace std;

#define N 120
#define fin cin

int v[N][N];
int s[N][N];
int n;
int dp(int r, int c);//adopt the memoization method
int main()
{
    //ifstream fin("input.txt");
    while(fin>>n){
        for(int i=1;i<=n;i++)//read the data
            for(int j=1;j<=i;j++)
                fin>>v[i][j];
        memset(s,-1,sizeof(s));//intialize the sum
        cout<    }//end while
    return 0;
}

int dp(int r, int c)//adopt the memoization method
{
    if(r==n)//is the lastest line
        return s[r][c]=v[r][c];
    if(s[r][c]!=-1)//has been caluated
        return s[r][c];
    else
        return s[r][c]=v[r][c]+max(dp(r+1,c),dp(r+1,c+1));
}

第二种方式：迭代

//pku 1163 DY 问题
//采用的是迭代的方式
#include
#include
#include
using namespace std;

#define N 120
#define fin cin
int v[N][N];
int s[N];

int main()
{
    //ifstream fin("input.txt");
    int n;
    while(fin>>n){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=i;j++)
                fin>>v[i][j];

        for(int i=1;i<=n;i++)
            s[i]=v[n][i];

        //每个数的最大值只和它的下一行的数算出的最大值有关。
        for(int i=n-1;i>=1;i--)
            for(int j=1;j<=i;j++)//j只能是从1开始，而不能是从i开始，因为这样数据会被覆盖
                s[j]=v[i][j]+max(s[j],s[j+1]);
        cout<    }//end while

    return 0;
}

DjvuLee 2012-02-27 10:15 发表评论

Function Run Fun[1579@pku]

DjvuLee — Mon, 27 Feb 2012 02:10:00 GMT

//@pku 1579 DY问题
//采用的是备忘录方式
//主要的问题是在dp()前，先检查一下下标
#include
#include
using namespace std;

#define N 24
#define fin cin
int v[N][N][N];
int dp(int a,int b,int c);

int main()
{
    //ifstream fin("input.txt");
    int a,b,c;
    memset(v,-1,sizeof(v));//只需要初始化一次
    while(fin>>a>>b>>c){
        if(a==-1 && b==-1 && c==-1)
            break;
        int sum;
        if(a<=0 || b<=0 || c<=0)
            sum=1;
        else if(a> 20 || b>20 || c>20)
            sum=dp(20,20,20);
        else
            sum=dp(a,b,c);
        cout<<"w("<    }//end while
    return 0;
}

int dp(int a,int b,int c)
{
    if(a<=0 || b<=0 || c<=0)
        return 1;
    if(v[a][b][c]!=-1)
        return v[a][b][c];
    else
    {
        if(a            return v[a][b][c]=dp(a,b,c-1)+dp(a,b-1,c-1)-dp(a,b-1,c);
        else
            return v[a][b][c]=dp(a-1, b, c) + dp(a-1, b-1, c) + dp(a-1, b, c-1) - dp(a-1, b-1, c-1);
    }
}

DjvuLee 2012-02-27 10:10 发表评论

滑雪[pku oj]

DjvuLee — Sat, 25 Feb 2012 13:08:00 GMT

//@PEK DY问题
//最重要的是找到最优子结构，以及构造合理的结束函数。
//自己现在最大的问题是在利用备忘录的递归还是迭代上找不准。本题采用的是备忘录递归，但是在处理上还有很多重复的。
//本题应该是可以向贪心算法上改进的。
//在构造最优子结构问题上也欠缺经验，本题主要花费在了这上面。
//本题因为freopen()提交的时候没注释掉,dp()中right的坐标写错了。导致了2次WA。
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;

#define N 102
#define INF 12000
int data[N][N];
int len[N][N];
int rt,ct;
int dp(int r, int c);
int GetMax(int a,int b,int c,int d);

int main()
{
    freopen("input.txt","r",stdin);
    while(~scanf("%d %d",&rt,&ct)){
        for(int i=1;i<=rt;i++)
            for(int j=1;j<=ct;j++)
                scanf("%d",&data[i][j]);
        for(int j=0;j<=ct+1;j++)
        {
            data[0][j]=INF;
            data[rt+1][j]=INF;
        }
        for(int j=0;j<=rt+1;j++)
        {
            data[j][0]=INF;
            data[j][ct+1]=INF;
        }

        for(int i=1;i<=rt;i++)
            for(int j=1;j<=ct;j++)
                len[i][j]=-1;

        for(int i=1;i<=rt;i++)
            for(int j=1;j<=rt;j++)
                dp(i,j);

        int max=len[1][1];
        for(int i=1;i<=rt;i++)
            for(int j=1;j<=ct;j++)
                if(max<len[i][j])
                    max=len[i][j];
        printf("%d\n",max);
    }//end while
    return 0;
}

int dp(int r, int c)
{
    bool left=data[r][c]<=data[r][c+1];
    bool right=data[r][c]<=data[r][c-1];
    bool down=data[r][c]<=data[r+1][c];
    bool up=data[r][c]<=data[r-1][c];

    if(left && right && down && up)
        return len[r][c]=1;
    else
    {
        int dipl=1,dipr=1,dipd=1,dipu=1;
        if(!left)
        {
            dipl+=(len[r][c+1]!=-1) ? len[r][c+1] : dp(r,c+1);
        }
        if(!down)
        {
            dipd+=(len[r+1][c]!=-1) ? len[r+1][c] : dp(r+1,c);
        }
        if(!right)
        {
            dipr+=(len[r][c-1]!=-1) ? len[r][c-1] : dp(r,c-1);
        }
        if(!up)
        {
            dipu+=(len[r-1][c]!=-1) ? len[r-1][c] : dp(r-1,c);
        }
        return len[r][c]=GetMax(dipl,dipr,dipd,dipu);
    }
}

int GetMax(int a,int b,int c,int d)
{
    return max(a,max(b,max(c,d)));
}

DjvuLee 2012-02-25 21:08 发表评论

动态规划的两种手法

DjvuLee — Fri, 24 Feb 2012 13:00:00 GMT

一、在用动态规划思想解题的过程中常用的两种手法：
①递推计算：
②记忆化搜索（也就是备忘录）方法：直接的自底向上进行。
memset(v,-1,sizeof(v0);当不是-1的时候，返回已经计算的值，否则用递归的形式进行计算。
二、动态规划能够应用的两个特征：
①存在递归解形式；②存在重叠子问题；反映在实际中就是最优化问题，然后问题的解是一个和问题规模无关的问题。
能够用动态规划进行求解的问题，常常都能够转换为DAG模型进行处理。尤其对于很烦复杂的问题，这一点很重要。
三、动态规划和贪心算法的区别区别支持：
贪心算法是自顶向下的，动态规划是自底向上的。
贪心算法是通过首先有序化，由局部最优选择得到最终的全局最优问题。
动态规划是通过全局最优问题是有局部最优问题组成的来得到最终的解。
在实际的程序中，往往可以通过排序来将动态规划问题转换为贪心算法求解。
贪心算法的时间复杂度多半为：O(N)。而动态规划多半为O(N*N);

DjvuLee 2012-02-24 21:00 发表评论