hdu ACM Steps 3.2

这节完全是基础的DP，就直接贴代码了

 

3.2.1 Max Sum

#include<stdio.h>
#include<memory.h>
using namespace std;
int main()
{
    int t,n,max,res;
    int a[100001],dp[100001],f[100001];
    scanf("%d",&t);
    for (int tt=1;tt<=t;tt++)
    {
        if (tt!=1) printf("\n");
        scanf("%d",&n);
        for (int i=0;i<n;i++)
        scanf("%d",&a[i]);
        memset(dp,0,sizeof(dp));
        max=a[n-1]; res=n; dp[n-1]=a[n-1]; f[n-1]=n;
        for (int i=n-1;i>0;i--)
        {
            if (dp[i]>0) {dp[i-1]=dp[i]+a[i-1]; f[i-1]=f[i];}
                    else {dp[i-1]=a[i-1]; f[i-1]=i;}
            if (dp[i-1]>=max) {max=dp[i-1]; res=i;}
        }
        printf("Case %d:\n%d %d %d\n",tt,max,res,f[res-1]);
    }
    return 0;
}

3.2.2 Common Subsequence

#include<iostream>
#include<memory.h>
#include<string>
using namespace std;
int dp[1001][1001];
int ans;
int MAX(int a,int b)
{
    if (a>=b) return a;
        else  return b;
}
int main()
{
    string x,y;
    while (cin>>x>>y)
    {
        memset(dp,0,sizeof(dp));
        ans=0;
        for (int i=1;i<=x.length();i++)
        for (int j=1;j<=y.length();j++)
        {
            if (x[i-1]==y[j-1]) dp[i][j]=dp[i-1][j-1]+1;
                           else dp[i][j]=MAX(dp[i-1][j],dp[i][j-1]);
            if (dp[i][j]>ans) ans=dp[i][j];
        }
        cout<<ans<<endl;
    }
    return 0;
}

3.2.3 Super Jumping! Jumping! Jumping!

#include<stdio.h>
#include<memory.h>
using namespace std;
int n;
int a[10001];
int dp[10001];
int main()
{
    scanf("%d",&n);
    while (n!=0)
    {
        int ans=0;
        memset(dp,0,sizeof(dp));
        for (int i=0;i<n;i++)
        scanf("%d",&a[i]);
        dp[0]=a[0]; ans=dp[0];
        for (int i=1;i<n;i++)
        {
            dp[i]=a[i];
            for (int j=0;j<i;j++)
            if (dp[j]+a[i]>dp[i]&&a[j]<a[i]) dp[i]=dp[j]+a[i];
            if (dp[i]>ans) ans=dp[i];
        }
        printf("%d\n",ans);
        scanf("%d",&n);
    }
    return 0;
}

3.2.4 FatMouse's Speed

#include<iostream>
using namespace std;
typedef struct p
{
 int weight;
 int speed;
 int num;
 int pre;
}Mouse;
void sort(Mouse m[],int n)
{
   int i,j,k;
   Mouse temp;
   for(i=1;i<=n;i++)
   {
     k=i;
     for(j=i+1;j<=n;j++)
	 {
         if(m[j].weight<m[k].weight)
              k=j;
         else if(m[j].weight==m[k].weight&&m[j].speed>m[k].speed)
              k=j;
	 }
     if(k!=i)
	 {
         temp=m[k];
         m[k]=m[i];
         m[i]=temp;
	 }
   }
}

int main()
{
 int i=1,j,n=1,data[1001],a,b;
 int f[1001];
 Mouse m[1001];
 while(cin>>a>>b)
    {
        m[n].num = n;
		m[n].weight = a;
        m[n].speed = b;
        n++;
    }
 sort(m,n-1);
   f[1]=1; a=1; b=1; m[1].pre=1;
    for(i = 2; i < n; i++)
    {
        f[i]=1; m[i].pre=i;
        for(j=1; j<i;j++)
            if(m[i].weight>m[j].weight&&m[i].speed<m[j].speed&&f[j] + 1 >f[i])
                {
                    f[i]=f[j]+1;
                    m[i].pre=j;
                }
        if(f[i]>a)
        {
            a=f[i];
            b=i;
        }
    }
    cout<<a<<endl;
    i=0;
    while(f[b]+1)
    {
        data[i]=m[b].num;
        b=m[b].pre;
        i++;
        f[b]--;
    }
    for(i=a-1;i>=0;i--)
        cout<<data[i]<<endl;

 return 0;
}

3.2.5 Humble Numbers

#include<iostream>
using namespace std;
int F[10000];
int fp=2;
int main()
{
   int a=1,b=1,c=1,d=1;
   F[1]=1;
   int v[5]={0,1,1,1,1};
   int st[5]={0,2,3,5,7};
   for(fp=2;fp<=5842;fp++)
   {
      int mins=2000001000,mp=-1;
      for(int i=1;i<=4;i++)
      {
         int mul=F[v[i]]*st[i];
         if(mul<mins)
         {
            mins=mul;
            mp=i;
         }
      }
      for(int i=1;i<=4;i++)
      {
         int mul=F[v[i]]*st[i];
         if(mul==mins)
         v[i]++;
      }
      F[fp]=mins;
   }
   int n;
   while(cin>>n,n)
   {
      if(n%10==1&&n%100!=11)
      cout<<"The "<<n<<"st humble number is "<<F[n]<<"."<<endl;
      else if(n%10==2&&n%100!=12)
      cout<<"The "<<n<<"nd humble number is "<<F[n]<<"."<<endl;
      else if(n%10==3&&n%100!=13)
      cout<<"The "<<n<<"rd humble number is "<<F[n]<<"."<<endl;
      else
      cout<<"The "<<n<<"th humble number is "<<F[n]<<"."<<endl;
   }
   return 0;
}

3.2.6 数塔

#include<stdio.h>
#include<memory.h>
using namespace std;
int main()
{
    int c,n,x;
    scanf("%d",&c);
    while (c--)
    {
        scanf("%d",&n);
        int a[1000],b[1000];
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        for (int i=1;i<=n;i++)
        {
            for (int j=1;j<=i;j++)
            {
                scanf("%d",&x);
                if (a[j-1]>=a[j]) b[j]=a[j-1]+x;
                            else  b[j]=a[j]+x;
            }
            for (int j=1;j<=i;j++) a[j]=b[j];
        }
        int ans=0;
        for (int i=1;i<=n;i++)
        if (a[i]>ans) ans=a[i];
        printf("%d\n",ans);
    }
    return 0;
}

3.2.7 免费馅饼

#include<stdio.h>
#include<cmath>
#include<memory.h>
#include<algorithm>
using namespace std;
int dp[100005][12];
int main()
{
    int n,i,j,maxt;
    int x,t;
    while(scanf("%d",&n),n)
    {
        maxt=0;
        memset(dp,0,sizeof(dp));
        for(i=0;i<n;i++)
        {
            scanf("%d%d",&x,&t);
            dp[t][x]++;
            if(maxt<t)  maxt=t;
        }
        for(i=maxt-1;i>=0;i--)
        {
            dp[i][0]+=max(dp[i+1][1],dp[i+1][0]);
            for(j=1;j<11;j++)
            {
                dp[i][j]+=max(max(dp[i+1][j-1],dp[i+1][j]),dp[i+1][j+1]);
            }
        }
        printf("%d\n",dp[0][5]);
    }
    return 0;
}

3.2.8 命运

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

int main()
{
    int c,n,m,a[21][1010],f[21][1010],max;
    cin>>c;
    while(c--)
    {
        cin>>n>>m;
        memset(f,0,sizeof(f));
        for(int i = 1 ; i <= n ; i++)
        {
            for(int j = 1 ; j <= m ; j++)
            {
               scanf("%d",&a[i][j]);
                f[i][j] = a[i][j];
                if(i == 1) max = -101;
                else max = f[i-1][j];
                for(int k = 1 ; k <= j/2;k++)
                {
                    if(j%k==0)
                    if(max<f[i][k])
                    max = f[i][k];
                }
                if(max < f[i][j-1])
                max = f[i][j-1];
                f[i][j] += max;
            }
        }
        cout<<f[n][m]<<endl;
    }
    return 0;
}