修炼dp（1）

从最简单的开始：

POJ:The Triangle

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int dp[][];
int a[][];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=;i<=n;i++)
    {
        for(int j=;j<=i;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    memset(dp,,sizeof(dp));
    for(int i=;i<=n;i++) dp[n][i] = a[n][i];
    for(int i=n-;i>=;i--)
    {
        for(int j=;j<=i;j++)
        {
            dp[i][j] = max(dp[i+][j],dp[i+][j+])+a[i][j];
        }
    }
    printf("%d\n",dp[][]);
}

卷珠帘

HDU:1159最长公共子序列

一维的转来转去，卡死了，结果换成二维的，轻松解决。清晰的体现了转移的特性。

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = ;
int dp[maxn][maxn];
char s1[maxn];
char s2[maxn];
int main()
{
    while(scanf("%s %s",s1+,s2+)!=EOF)
    {
        int n = strlen(s1+);
        int m = strlen(s2+);
        int maxx = ;
        memset(dp,,sizeof(dp));
        for(int i=;i<=n;i++)
        {
            for(int j=;j<=m;j++)
            {
                if(s1[i]==s2[j])
                {
                    dp[i][j] = dp[i-][j-]+;
                }
                else
                {
                    dp[i][j] = max(dp[i-][j],dp[i][j-]); //两方程突出了转移
                }
            }
        }
        printf("%d\n",dp[n][m]);
    }
}
/*
127486 214786
*/

卷珠帘

HDU:1069最长上升子序列

思路清晰^_^

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = ;
int dp[maxn];
struct edge
{
    int l,r,h;
};
edge e[maxn];
bool cmp(edge A,edge B)
{
    if(A.l!=B.l) return A.l>B.l;
    if(A.r!=B.r) return A.r>B.r;
    if(A.h!=B.h) return A.h>B.h;
}
int main()
{
    int n,kase = ;
    while(scanf("%d",&n)!=EOF&&n)
    {
        int x,y,z;
        for(int i=;i<=*n;i+=)
        {
            scanf("%d %d %d",&x,&y,&z);
            e[i].l = e[i+].r = e[i+].h = x;
            e[i].r = e[i+].h = e[i+].l = y;
            e[i].h = e[i+].l = e[i+].r = z;
            if(e[i].l<e[i].r) swap(e[i].l,e[i].r);
            if(e[i+].l<e[i+].r) swap(e[i+].l,e[i+].r);
            if(e[i+].l<e[i+].r) swap(e[i+].l,e[i+].r);
        }
        sort(e+,e+*n+,cmp);
        memset(dp,,sizeof(dp));
        int maxx = ;
        for(int i=;i<=*n;i++)
        {
            dp[i] = e[i].h;
            for(int j=;j<i;j++)
            {
                if(e[i].l<e[j].l&&e[i].r<e[j].r)
                {
                    dp[i] = max(dp[i],dp[j]+e[i].h);
                }
            }
            maxx = max(maxx,dp[i]);
        }
        printf("Case %d: maximum height = %d\n",++kase,maxx);
    }
}
/*
127486 214786
*/

卷珠帘

UVa:103 Stacking Box

n维的的最长上升子序列，不过需要打印路径，一个pre记录下。

在每一个box内部排序时，我差点写10个变量，不过最后学的姿势。

每次最愁做UVa题，网速慢死了。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
const int maxn = ;
int n,m;
int pre[maxn];
int dp[maxn];
vector<int> cnt;
struct node
{
    int sq,edge[];
};
node box[maxn];
bool cmp(node A,node B)
{
    for(int i=;i<=m;i++)
        if(A.edge[i]!=B.edge[i]) return A.edge[i]>B.edge[i];
    return A.edge[m]>B.edge[m];//以防全相等
}
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        for(int i=;i<=n;i++)
        {
            box[i].sq = i;
            for(int j=;j<=m;j++)
            {
                scanf("%d",&box[i].edge[j]);
            }
            sort(box[i].edge+,box[i].edge+m+);
        }

        sort(box+,box+n+,cmp);
        memset(dp,,sizeof(dp));
        memset(pre,,sizeof(pre));
        int maxn = ;
        int ans = ;
        int flag = ;
        for(int i=;i<=n;i++)
        {
            dp[i] = ;
            for(int j=;j<i;j++)
            {
                flag = ;
                for(int k=;k<=m;k++)
                {
                    if(box[i].edge[k]>=box[j].edge[k])
                    {
                        flag = ;
                        break;
                    }
                }
                if(!flag)
                {
                    if(dp[i]<dp[j]+)
                    {
                        dp[i] = dp[j]+;
                        pre[box[i].sq] = box[j].sq;
                    }
                }
            }
            if(dp[i]>maxn)
            {
                maxn = dp[i];
                ans = box[i].sq;
            }
        }
        printf("%d\n",maxn);
        cnt.clear();
        while(pre[ans]!=)
        {
            cnt.push_back(ans);
            ans = pre[ans];
        }
        cnt.push_back(ans);
        for(int i=;i<cnt.size()-;i++)
        {
            printf("%d ",cnt[i]);
        }
        printf("%d\n",cnt[cnt.size()-]);
    }
    return ;
}
/*
5 1
2
1
4
2
4
*/

卷珠帘