DP水题练习——HDOJ 2391 HDOJ1069 HDOJ 2512

HDOJ 2391

http://acm.hdu.edu.cn/showproblem.php?pid=2391

简单的DP dp[i][j] = max { dp[i-1][j], dp[i][j-1],dp[i-1][j-1] } + val[i][j];

#include<iostream>
 using namespace std;
 int dp[1001][1001];
#include<algorithm>//max()函数返回较大值
 int main(){
    int t;cin>>t;
    int m,n;
    for(int i=1;i<=t;i++){
        cin>>m>>n;
        //初始化边界
         for(int j=0;j<=1000;j++)
            dp[j][0]=dp[0][j]=0;
        for(int j=1;j<=m;j++)
            for(int k=1;k<=n;k++)
                //cin>>map[j][k];
                //改变输入后，时间由1700ms变为300ms...
                 scanf("%d",&dp[j][k]);
        int tempMax,map;
        for(int j=1;j<=m;j++)
            for(int k=1;k<=n;k++){
                map=dp[j][k];
                //找三者间最大值
                dp[j][k]=max(map+dp[j][k-1]
                            ,map+dp[j-1][k]);
                dp[j][k]=max(map+dp[j-1][k-1],dp[j][k]);
            }
        cout<<"Scenario #"<<i<<":"<<endl<<dp[m][n]<<endl<<endl;
    }
    return 0;
}

HDOJ 1069

题目大意，给定n中木块，分别给长宽高，问最高能垒多高，要求上面的木块长宽都要比下面的小。

ＤＰ：由于每一种木块数量无限，但实际上，每一种木块最多使用三次，所以每一种木块都当三个木块存储。

   　　再按底面积大小从大到小排一下序。

　　　最优子状态设定：box[i].max为以第i个木块为顶所能达到的最大高度。

则DP公式为：box[i].max = MAX{box[j].max}+box[i].height;    (0<=j<i , 并且MAX{}木块要容得下box[i])

第一次提交有错误，原因在多了第38句，break;实际上，排序只是按照底面积排的序，所以box[j].max并不是按照从自底向上

从小到大排的，比如，特殊化一下，一个面积特别小的细长型棍子，虽然排在了最后面，比如box[j(=i-1)],但是它并不一定能磊

到最上面，太长了，下面的容不下他，所以单独一个的话，box[j(=i-1)].max就很小了，所以得全部搜索一遍

#include<iostream>
#include<algorithm>
using namespace std;
struct Box{
    int length;
    int width;
    int height;
    int max;
};
bool comp(Box a,Box b){
    return a.length*a.width>b.length*b.width;
}
bool isSuit(Box a,Box b){
    return a.length<b.length&&a.width<b.width
        || a.length<b.width&&a.width<b.length;
}

Box box[100];
int main(){
    int n,l,w,h,t=1;
    while(cin>>n&&n!=0){
        for(int i=0;i<3*n;i++){
            cin>>l>>w>>h;
            box[i].height=l;box[i].width=w;box[i].length=h;i++;
            box[i].height=w;box[i].width=l;box[i].length=h;i++;
            box[i].height=h;box[i].width=l;box[i].length=w;
        }
        sort(box,box+3*n,comp);
        
        box[0].max=box[0].height;
        int tempmax=box[0].max;
        for(int i=1;i<3*n;i++){
            box[i].max=box[i].height;
            for(int j=i-1;j>=0;j--){
                if(!isSuit(box[i],box[j]))continue;
                else if(box[i].max<box[j].max+box[i].height)
                    box[i].max=box[j].max+box[i].height;
                //break;
            }
            if(box[i].max>tempmax)tempmax=box[i].max;
        }
        cout<<"Case "<<t++<<": maximum height = "<<tempmax<<endl;
    }
    return 0;
}

HDOJ 2512

http://acm.hdu.edu.cn/showproblem.php?pid=2512

题目大意：给定n张不同的卡，放到相同的书中，问多少种方法。如果，三张卡的话有五种如：

{{A},{B},{C}} , {{A,B},{C}}, {{B,C},{A}}, {{A,C},{B}} ,{{A,B,C}}

两张卡的话，两种：{{A}{B}}  {{A，B}}

状态设定：dp[i][j]为i张卡放到j本书的种类数。那么dp[i][j]=dp[i-1][j-1]*1+dp[i-1][j]*j

公式的前半部分：dp[i-1][j-1]*1表示第i张卡单独放到一本书中；

后半部分表示：dp[i-1][j]第j本书放到j堆中的其中一堆

状态临界值：当i=j时，dp[i][j]=1;

     　　　　当j=1时，dp[i][j]=1;

i 张卡的方法则为dp[i][1]+dp[i][2]+dp[i][3]...dp[i][i]

由此可以总结：应用dp时，矛头不一定指向问题的直接解，可以巧设状态变量，求的最终的解！

#include<iostream>
using namespace std;
int dp[2010][2010], res[2010], T, N;
void DP () {
     dp[1][1] = 1, res[1] = 1;
     for ( int i = 2; i <= 2000; ++ i ) {
         dp[i][1] = dp[i][i] = 1, res[i] = 2;
         for ( int j = 2; j < i; ++ j ) {
             res[i] += dp[i][j] = ( dp[i-1][j-1] + dp[i-1][j] * j ) % 1000;    
         }  
         res[i] %= 1000;  
     }     
}
 
int main ()
{
    DP ();
    scanf ( "%d", &T );
    while ( T -- ) {
          scanf ( "%d", &N );
          printf ( "%d\n", res[N] );      
    }
    return 0;
}