杭电60道DP问题总结（三）

接着前两篇，还是5道一贴吧。

题目链接地址：http://acm.hdu.edu.cn/problemclass.php?id=516

ProID 1159  Common Subsequence

题目意思很简单，是个最基本的DP，任何一本算法书都会讲这个题目，最长公共子序列。

状态转移方程，dp[i][j]=dp[i-1][j-1]+1(when str[i]==str[j])  max(dp[i-1][j],dp[i][j-1])(when str[i]!=str[j])

就不解释了，直接上代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char s1[2000],s2[2000];
int dp[2000][2000];
int main()
{
    while(scanf("%s %s",&s1,&s2)!=EOF)
    {
        int L1=strlen(s1);
        int L2=strlen(s2);

        memset(dp,0,sizeof(dp));
        for(int i=1;i<=L1;i++)
            for(int j=1;j<=L2;j++)
                if(s1[i-1]==s2[j-1])
                    dp[i][j]=dp[i-1][j-1]+1;
                else
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        printf("%d\n",dp[L1][L2]);
    }
    return 0;
}

ProID 1160   FatMouse's Speed

题目大意是，让你证明一下肥的老鼠跑的慢（直接翻译），其实就是求一个最长上升子序列问题，要找的就是在重量从小到大的一个序列中，找一个最长的序列，其中这个序列中的元素速度是递减的。这也算是一个比较经典的问题了，就不再多说了，最早的那篇中对最长上升子序列有详细解释。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include<vector>
using namespace std;

struct Data
{
    int weight;
    int speed;
    int index;
};
Data data[1001];

bool com(Data d1,Data d2)
{
    if(d1.weight==d2.weight)
        return d1.speed>d2.speed;
    return d1.weight<d2.weight;
}
int dp[1001];
int memory[1001];
int main()
{
    int num=1;
    while(scanf("%d %d",&data[num].weight,&data[num].speed)!=EOF)
    {
        data[num].index=num++;
    }
    sort(data+1,data+num,com);//按重量递减排序
    memset(dp,0,sizeof(dp));
    memset(memory,0,sizeof(memory));
    dp[1]=1;
    int res=data[1].speed;//最长上升子序列
    for(int i=2;i<num;i++)
    {
        int len=0;
        memory[i]=i;
        for(int j=1;j<i;j++)
            if(data[i].speed<data[j].speed)
            {
                if(len<dp[j])
                {
                    len=dp[j];
                    memory[i]=j;
                }
            }
			dp[i]=len==0?1:len+1;
    }//由于需要对结果输出，所以需要记录
    int ind=1;
    int tmp=dp[1];
    for(int i=2;i<num;i++)
    {
        if(dp[i]>tmp)
        {
            tmp=dp[i];
            ind=i;
        }
    }
    printf("%d\n",tmp);
    vector<int>vec;
    while(memory[ind]!=ind)
    {
        vec.push_back(data[ind].index);
        ind=memory[ind];
    }
    vec.push_back(data[ind].index);
    for(int i=vec.size()-1;i>=0;i--)
        printf("%d\n",vec[i]);
    return 0;
}

ProID  1165    Eddy's research II

看题目应该是有个同样的题目吧，不然为什么会有个II呢。题目意思很简单，就是求解一个递归式，其实算不上是一个DP问题，题目放到这里或许有点问题吧，那就强制性的用用DP呗，其实就是一个方程式化简问题。化简过程就不写出来了，在纸上画画就明显能看出来，

这段代码是摘录题目后边的Discuss中一个同学的，因为看起来比较像DP，参考下吧。

#include<stdio.h>
int dp[4][1000005];
int main ()
{
    int i,j;
    for(i=0;i<=1000005;i++)
    dp[1][i]=i+2;
    for(i=0;i<=1000005;i++)
    dp[2][i]=i*2+3;
    dp[3][0]=5;
    for(i=1;i<=24;i++)
    dp[3][i]=2*dp[3][i-1]+3;
    while(~scanf("%d%d",&i,&j))
    {
       printf("%d\n",dp[i][j]);
    }
    return 0;
}

ProID 1176  免费馅饼

   题目意思是，你站在一条路上的中间位置，这条路有11个点组成的，在某一秒种会有馅饼掉落，你可以在一秒内移动到两边的某一个位置上， 在当前位置上可以接到包括当前位置以及两边位置的馅饼。简单来说比如我站在5点，那么可以在1s内接到4,5,6其中的某一个点落下的馅饼。因为每次只能向左右移动，其实就是一个数塔的变形。普通的数塔是向左下或右下走。

状态转移方程：

dp[i][j]=max(dp[i+1][j-1],dp[i+1][j],dp[i+1][j+1])+data[i][j] 

解释一下，dp[i][j]表示从第i秒到第Max秒在位置j上所收获的最多的馅饼，就是由第i+1秒到第Max秒所获得的最多的馅饼，注意了，一定是从下往上算，一开始我也弄错了，算了半天总是结果不对，普通数塔是从上往下算（当然从下往上算也可以），是因为要求的最终结果在最下边一层，而且需要多一次最终的遍历，以找到最大值，本题目需要从下往上算是因为需要的最后最终结果在最顶层。

【不过个人觉得应该从上往下算也可以，但是实际做的时候却总是得不到正确的结果，哪位大神知道怎么做的话可否给点提示】

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define N 100005 
int dp[N][11];

int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        memset(dp,0,sizeof(dp));
        int x,t;
        int Max_t=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d %d",&x,&t);
            dp[t][x]++;
            Max_t=max(Max_t,t);
        }
        for(int i=Max_t;i>=0;i--)
        {
            dp[i][0]+=max(dp[i+1][0],dp[i+1][1]);
            for(int j=1;j<=9;j++)
                dp[i][j]+=max(max(dp[i+1][j-1],dp[i+1][j]),dp[i+1][j+1]);
            dp[i][10]+=max(dp[i+1][9],dp[i+1][10]);
        }
        printf("%d\n",dp[0][5]);
    }
    return 0;
}

ProID 1176 I NEED A OFFER

题目大意是，某个人有n快钱，向m个学校申请offer，告诉申请每个学校的资金和概率，求出至少拿到一份offer的概率。说白了就是个01背包问题，m个物品，总的背包重量是n，每装一个物品，所占用的背包重量是资金，收获的价值是获得offer的概率。对应起来直接套公式就可以了。

注意了，是求得至少获得一个offer的概率，因此需要使用全概率公式，保存的时候保存都不能获得offer的概率。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int a[10005];
double b[10005],dp[10005];
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)!=EOF && (n||m))
    {
        for(int i=0;i<m;i++)
        {
            scanf("%d %lf",&a[i],&b[i]);
            b[i]=1.0-b[i];
        }
        for(int i=0;i<=n;i++)
            dp[i]=1;
        for(int i=0;i<m;i++)
            for(int j=n;j>=a[i];j--)
                dp[j]=min(dp[j],dp[j-a[i]]*b[i]);
        printf("%.1f%%\n",(1-dp[n])*100);
    }
    return 0;
}