zoukankan      html  css  js  c++  java
  • 状压dp

    状压dp可以理解为最暴力的dp,因为他需要遍历每个状态,所以将会出现2^n的情况数量,所以明显的标志就是数据不能太多(好像是<=15?),然后遍历所有状态的姿势就是用二进制来表示,01串,1表示使用,0表示未使用,就把所有的状态投射到很多二进制的数上(类似于hash?)然后对每个状态找上一"些"状态的方法如下代码,即状压dp的精髓!!!

    就是暴力每一个状态( 0--(1<<n)  ):

    例:传送门

    给出战神吕布的初始攻击力ATI、防御力DEF、生命值HP、每升一级增加的攻击力In_ATI,增加的防御力In_DEF和增加的生命值In_HP。然后给出n个敌人的攻击力、防御力、生命值和杀死该单位能获得的经验值EXP。  吕布的初始经验值EXP是0,初始等级level是1,每当EXP>=level*100时就会升级。
      在吕布LvBu和敌人A之间的战斗有3条规则
      1.吕布攻击A,A失去 Max(1,LvBu's ATI- A's DEF). HP;
      2.A攻击吕布,吕布失去Max(1,A'ATI- LvBu'DEF).HP;
      3.战斗持续到任意一方死亡
    如果吕布能够将全部敌人杀死,并且自己不死,那么输出能够余下的最大HP,否则输出"Poor LvBu,his period was gone."

    Input
    输入吕布的攻击值,防御值,生命值,攻击成长值,防御成长值,生命成长值。
    输入n
    输入敌人名称,攻击值,防御值,生命值,经验值。
    多组输入Output如果吕布死了,输出 "Poor LvBu,his period was gone." 
    或者输出最大生命值。Sample Input

    100  80  100  5  5  5
    2
    ZhangFei 95  75  100  100 
    XuChu 90  90  100  90
    
    100 75 100 5 5 5
    1
    GuanYu 95 85 100 100

    Sample Output

    30
    Poor LvBu,his period was gone.

     这个就是关键:最后111都更新完了

    #include<iostream>
    #include<algorithm>
    using namespace std;
    /*
    https://vjudge.net/contest/425658#problem/D
    */
    struct State{//吕布的每一个状态
        int ati,def,hp,lev,exp;//攻击值,防御值,生命值,经验值,初始等级 
    }dp[(1<<20)+2];
    struct Node{
        int ati,def,hp,exp;//攻击值,防御值,生命值,经验值
    }node[100];
    char str[100];
    int n;
    int In_ati,In_def,In_hp;//攻击成长值,防御成长值,生命成长值
    int main(){
        while(~scanf("%d%d%d%d%d%d",&dp[0].ati,&dp[0].def,&dp[0].hp,&In_ati,&In_def,&In_hp)){
            cin>>n;
            for(int i=0;i<n;i++){
                scanf("%s%d%d%d%d",str,&node[i].ati,&node[i].def,&node[i].hp,&node[i].exp);
            }    
            for(int i=1;i<(1<<20)+2;i++){
                dp[i].hp=0;
            }
            dp[0].exp=0;
            dp[0].lev=1;
            for(int state=0;state<(1<<n);state++){
                if(dp[state].hp<=0) continue; 
                for(int i=0;i<n;i++){
                    if(state&(1<<i)) continue;
                    State S=dp[state];
                    int tmp1=max(1,S.ati-node[i].def);//吕布打别人 
                    int tmp2=max(1,node[i].ati-S.def);//别人打吕布
                    int t=(node[i].hp/tmp1)+(node[i].hp%tmp1==0?-1:0);//由于是吕布先打别人 
                    S.hp-=t*tmp2;
                    if(S.hp<=0){
                        continue;
                    } 
                    S.exp+=node[i].exp;
                    if(S.exp>=S.lev*100){
                        S.lev++;
                        S.ati+=In_ati;
                        S.def+=In_def;
                        S.hp+=In_hp;
                    }
                    if(S.hp>dp[state|(1<<i)].hp){
                        dp[state|(1<<i)]=S;
                    }
                }
            }
            if(dp[(1<<n)-1].hp<=0){
                cout<<"Poor LvBu,his period was gone."<<endl;
            }
            else{
                cout<<dp[(1<<n)-1].hp<<endl;
            }
            
        }
    }

    例二:传送门

    两辆车n个物品,每个物品有体积,两辆车也有体积, 要求把物品全部运走最少需要多少次 每次每辆车运送的物体总体积不得大于车的体积

    第一行包含场景的数量。每个场景由一行组成,其中包含三个数字n、C1和C2。C1和C2分别为汽车的容量(1≤Ci≤100),n为家具件数(1≤n≤10)。下一行包含n个整数w1,…,wn,家具的权重(1≤wi≤100)。保证每一件家具都能被两辆车中的至少一辆装载。

    输出
    每个场景的输出都以包含“场景#i:”的一行开始,其中i是场景的编号,从1开始。然后打印一行,显示他们为了搬动所有家具到新房子的次数。用空行结束每个场景。

    这个题就是judge函数是关键:judge函数就是判断这一个状态看看能不能装入(c1和c2)中

    bool judge(int x){//judge函数来judge这个状态x能否用一次c1+c2来装完 
        memset(vis,0,sizeof(vis));
        int sum=0;
        for(int i=0;i<n;i++){
            sum+=a[i];
            for(int j=c1;j>=a[i];j--){//就是把c1能弄完的都弄的都标记了
                if(vis[j-a[i]]){
                    vis[j]=1;
                }
            }
        }
        if(sum>(c1+c2)){
            return false;
        }
        for(int i=0;i<c1;i++){//c2
            if(vis[i]&&sum-i<=c2){//sum-i
                return true;
            } 
        }
        return false;
    }

    举个例子把:2 3 5

    c1=3,c2=10;就是第一个vis[2],vis[3],第二个循环就是vis[i]就是满足第一个,sum-i 就是这个状态中除了i,之后剩下的能不能完全装入c2中

    for(int i=1;i<=cnt;i++){
               for(int j=0;j<(1<<n);j++){//用j转移i 
                    if(dp[j]==INF){
                        continue;
                    }
                    if(!(j&state[i])){// 
                        dp[i|state[i]]=min(dp[i|state[i]],dp[j]+1);
                    }
                }
            }

    上面的就是用j来更新i,i是一个状态就是一次,然后你的dp[j]在前面已经要更新了

    #include<iostream>
    #include<algorithm>
    #include<cstring>
    using namespace std;
    typedef long long ll;
    int n,c1,c2;
    const int maxn=1e4+100;
    const int INF=0x3f3f3f3f;
    int cnt=0;
    int state[maxn];
    int dp[maxn];
    int vis[maxn];
    int a[maxn];
    bool judge(int x){//judge函数来judge这个状态x能否用一次c1+c2来装完 
        memset(vis,0,sizeof(vis));
        int sum=0;
        for(int i=0;i<n;i++){
            sum+=a[i];
            for(int j=c1;j>=a[i];j--){
                if(vis[j-a[i]]){
                    vis[j]=1;
                }
            }
        }
        if(sum>(c1+c2)){
            return false;
        }
        for(int i=0;i<c1;i++){
            if(vis[i]&&sum-i<=c2){
                return true;
            } 
        }
        return false;
    }
    int main(){
        int t;
        cin>>t;
        int kase=0;
        while(t--){
            scanf("%d%d%d",&n,&c1,&c2);
            for(int i=0;i<n;i++){
                scanf("%d",&a[i]); 
            }
            for(int i=0;i<(1<<n);i++){
                dp[i]=INF;
            }
            cnt=0;
            for(int i=1;i<(1<<n);i++){
                if(judge(i)){
                    state[++cnt]=i;//能一次装完的状态 
                } 
            }
            for(int i=1;i<=cnt;i++){
                for(int j=0;j<(1<<n);j++){//用j转移i 
                    if(dp[j]==INF){
                        continue;
                    }
                    if(!(j&state[i])){// 
                        dp[i|state[i]]=min(dp[i|state[i]],dp[j]+1);
                    }
                }
            }
            printf("Scenario #%d:
    %d
    
    ",++kase,dp[(1<<n)-1]);
        }
        return 0;
    }

    例三:

    司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成,地图的每一格可能是山地(用"H" 表示),也可能是平原(用"P"表示),如下图。在每一格平原地形上最多可以布置一支炮兵部队(山地上不能够部署炮兵部队);一支炮兵部队在地图上的攻击范围如图中黑色区域所示: 

    如果在地图中的灰色所标识的平原上部署一支炮兵部队,则图中的黑色的网格表示它能够攻击到的区域:沿横向左右各两格,沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。 
    现在,将军们规划如何部署炮兵部队,在防止误伤的前提下(保证任何两支炮兵部队之间不能互相攻击,即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内),在整个地图区域内最多能够摆放多少我军的炮兵部队。 

    Input

    第一行包含两个由空格分割开的正整数,分别表示N和M; 
    接下来的N行,每一行含有连续的M个字符('P'或者'H'),中间没有空格。按顺序表示地图中每一行的数据。N <= 100;M <= 10。

    Output

    仅一行,包含一个整数K,表示最多能摆放的炮兵部队的数量。

    Sample Input

    5 4
    PHPP
    PPHH
    PPPP
    PHPP
    PHHP

    Sample Output

    6

    这个题就是先从(0->(1<<n))中处理出来满足不会相互攻击的状态,然后三层暴力判断状态i和状态i-1和状态i-2
    //dp[i][j][k] 表示第i行状态为state[j],第i-1行状态为state[k]时的最优解
    #include<iostream>
    #include<algorithm>
    using namespace std;
    int dp[115][70][70],maze[105],status[70],num[70],m,n,len;
    //dp[i][j][k] 表示第i行状态为state[j],第i-1行状态为state[k]时的最优解
    char str[111];
    int cnt=0;
    int main(){
        cin>>n>>m;
        for(int i=1;i<=n;i++){
            scanf("%s",str);
            for(int j=0;j<m;j++){
                if(str[j]=='H'){//H代表的是山地 
                    maze[i]+=(1<<j);
                }
            } 
        }
        for(int i=0;i<(1<<m);i++){
            if(!(i&(i<<1))&&!(i&(i<<2))){
                int k=i,sum=0;
                while(k){
                    if(k&1){
                        sum++;
                    } 
                    k>>=1;
                }
                cnt++;
                num[cnt]=sum;
                status[cnt]=i;//符合不是自己炸自己的数 
            }
        } //1010
          //0101
        for(int i=1;i<=cnt;i++){
            if(!(maze[1]&status[i])){//士兵不能摆在山地上 
                dp[1][i][1]=num[i];//第0行的状态是1 
            }
        }
        //i-2
        //i-1
        //i
        for(int i=2;i<=n;i++){
            for(int j=1;j<=cnt;j++){//枚举第i行的状态
                if(status[j]&maze[i]) continue;
                for(int k=1;k<=cnt;k++){//枚举第i-1行的状态
                    if(status[j]&status[k]) continue;
                    if(status[k]&maze[i-1]) continue;
                    for(int t=1;t<=cnt;t++){//枚举第i-2行的状态
                        if(status[t]&status[j]) continue;
                        if(status[t]&status[k]) continue;
                        if(status[t]&maze[i-2]) continue;
                        dp[i][j][k]=max(dp[i][j][k],dp[i-1][k][t]+num[j]);
                    }
                }
            }
        }
        int ans=0;
        for(int i=1;i<=cnt;i++){
            for(int j=1;j<=cnt;j++){
                ans=max(ans,dp[n][i][j]);
            }
        }
        cout<<ans<<endl;
    } 

    例四:传送门

    农场主John新买新牧场,这块牧场被划分成M行N列(1 ≤ M ≤ 12; 1 ≤ N ≤ 12),每一格都是一块正方形的土地。John打算在牧场上的某几格里种上美味的草,供他的奶牛们享用。

    遗憾的是,有些土地相当贫瘠,不能用来种草。并且,奶牛们喜欢独占一块草地的感觉,于是John不会选择两块相邻的土地,也就是说,没有哪两块草地有公共边。

    John想知道,如果不考虑草地的总块数,那么,一共有多少种种植方案可供他选择?(当然,把新牧场完全荒废也是一种方案)

    Input

    第一行:两个整数M和N,用空格隔开。

    第2到第M+1行:每行包含N个用空格隔开的整数,描述了每块土地的状态。第i+1行描述了第i行的土地,所有整数均为0或1,是1的话,表示这块土地足够肥沃,0则表示这块土地不适合种草。

    Output一个整数,即牧场分配总方案数除以100,000,000的余数。Sample Input

    2 3
    1 1 1
    0 1 0

    Sample Output

    9

    HintNumber the squares as follows: 

    	1 2 3
      4  


    There are four ways to plant only on one squares (1, 2, 3, or 4), three ways to plant on two squares (13, 14, or 34), 1 way to plant on three squares (134), and one way to plant on no squares. 4+3+1+1=9.

    
    
    #include<iostream>
    #include<algorithm>
    #include<cstring> 
    using namespace std;
    const int maxn=1e2+10;
    int a[maxn][maxn];
    int dp[13][1<<13]; 
    const int mod=100000000;
    int n,m;
    int judge(int i,int j){//第i行状态是j 
        for(int k=0;k<m;k++){
            if((a[i][k]==0)&&((j>>k)&1)) return false;
        }
        return true;
    } 
    int main(){    
        cin>>n>>m;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                cin>>a[i][j];
            }
        } 
        memset(dp,0,sizeof(dp));
        int r=(1<<m);
        for(int i=0;i<r;i++){
            if(judge(0,i)&&!(i&i<<1)){
                dp[0][i]=1;
            }
        }
        for(int i=1;i<n;i++){
            for(int j=0;j<r;j++){
                if(!(j&j<<1)&&judge(i,j)){
                    for(int k=0;k<r;k++){
                        if(!(k&j)){
                            dp[i][j]=(dp[i][j]+dp[i-1][k])%mod;
                        }
                    } 
                }
            }
        }
        int ans=0;
        for(int i=0;i<r;i++){
            ans=(ans+dp[n-1][i])%mod;
        }
        cout<<ans<<endl;
    }

    额,这个题忘了。。。。尴尬



  • 相关阅读:
    Swift之类型安全和类型推断
    Swift之浮点数
    Swift之整数
    泛互联网产品技术支持划分
    WPF WebBrowser 不可见问题的解析[转]
    form WebBrowser自动点击弹出提示框alert、弹出对话框confirm、屏蔽弹出框、屏蔽弹出脚本错误的解决办法
    Mvvm绑定datagrid或listview的selectItems的方法[转]
    [C#]获取最近在Windows上所使用的文件
    拷贝构造函数和赋值运算符重载的区别
    Why Doesn’t Drag-and-Drop work when my Application is Running Elevated? – A: Mandatory Integrity Control and UIPI(转载)
  • 原文地址:https://www.cnblogs.com/lipu123/p/14488982.html
Copyright © 2011-2022 走看看