uva12235 状压dp

关键词：分阶段动态规划、状压dp、主后继法设计转移方程、滚动数组

题意：定义一列书的混乱度：相同高度的序列区间混乱度为1。如1 1 2 2 3 的混乱度为3。从n本书中抽出k本书，再将这k本书插入到书架上去，求这种操作后的最小混乱度。

特殊条件：书的高度在28-35之间，取整数。

做法：将取书和插入分成两个过程考虑。

dp[i][j][s][k]：从前i本书中取出j本书剩余书的种类集合为s，最后一本书高度编号为k（设高度为28-35的书高度编号为0-7），剩余书籍的最小混乱度

ans：取出j本书再插入后的最小混乱度

考虑取出两者的关系。若抽出的书中含有剩余书中未含有的书籍种类，则ans则比dp值大，确切地说：ans=dp[i][j][s][k]+cnt,cnt是抽出中含有而剩余书中不含有的书籍种类。这也是在dp求解中加入s维的目的。

因此问题简化为仅考虑取书过程的dp值。由于加入了原本求解此过程不需要而下一个求解过程需要的s维，转移过程相对麻烦些。

由于状态后继的s维与前继的s维的关系具有不可逆性！（可由状态前继的s维和选择得到状态后继，但是不能由状态后继的s维和先前选择得到状态前继！）因此必须先确定状态前继的s，才能表示后继的s维。所以在设计状态转移方程时，要以状态前继为主进行划分，而不是状态后继！

思路一：

如果取走第i个元素，前i和前i-1的s维相同：dp[i][j+1][s][k]=min{dp[i][j][s][k],dp[i-1][j][s][k]}  (注意：此时k!=a[i])

如果不取走第i个元素，前i和前i-1的s维不同：dp[i][j][s|(1<<a)][a]=min{dp[i][j+1][s|(1<<a)][a],dp[i-1][j][s][k]+(k!=a[i])}

粗体字中的s是前i-1个元素所含高度编号子集的遍历，k为s所含高度编号的遍历

思路二：

对dp[i-1][j][s][k]的k进行分类讨论

1.k==a[i]：dp[i][j][s][k]=min{dp[i][j][s][k],dp[i-1][j][s][k]}

2.k!=a[i]：

取走a[i]，那么前i个共取走j+1个，s相同：

dp[i][j+1][s][k]=min{dp[i][j+1][s][k],dp[i-1][j][s][k]}

不取走a[i]，那么前i个共取走j个，i的s要并上a[i]，前i个取走j个后剩余的最后一个元素为a[i]：

dp[i][j][s|(1<<a)][a]=min{dp[i][j][s|(1<<a)][a],dp[i-1][j][s][k]+1}

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#define dp f
#define INF 0x3f3f3f3f
#define ll long long

const int maxn = 100+5;
const int maxh=8;

int cas,n,K;
int all;//前i个=本书所含数的种类
int a;
int dp[2][maxn][(1<<maxh)+5][maxh];
int ans;

int Min(int a,int b){
    if(a<b) return a;
    return b;
}

int main(){
    //freopen("a.txt","r",stdin);
    cas=0;
    while(scanf("%d%d",&n,&K)!=EOF,n||K){
        all=0;
        memset(dp[1],INF,sizeof(f[1]));
        for(int i=0;i<n;i++){
            scanf("%d",&a);
            a-=25;
            int now=i&1;
            int old=!now;
            memset(dp[now],INF,sizeof(dp[now]));
            dp[now][i][(1<<a)][a]=1;
            for(int j=0;j<=Min(i,K);j++){
                for(int s=all;s;s=(s-1)&all){
                    for(int k=0;(1<<k)<=s;k++){
                        if(((1<<k)&s)!=0){
                            //法一：（参考）
                            /*if(k==a) dp[now][j][s][k]=Min(dp[now][j][s][k],dp[old][j][s][k]);
                            else{
                                dp[now][j][s|(1<<a)][a]=Min(dp[now][j][s|(1<<a)][a],dp[old][j][s][k]+1);
                                dp[now][j+1][s][k]=Min(dp[now][j+1][s][k],dp[old][j][s][k]);
                            }*/
                            //法二：（自创）
                            if(k!=a) dp[now][j+1][s][k]=Min(dp[now][j][s][k],dp[old][j][s][k]);//取a[i]
                            dp[now][j][s|(1<<a)][a]=Min(dp[now][j][s|(1<<a)][a],dp[old][j][s][k]+(k!=a));//不取a[i]
                        }
                    }
                }
            }
            all|=(1<<a);
        }
        ans=INF;
        for(int j=0;j<=K;j++){
            for(int s=all;s;s=(s-1)&all){
                for(int k=0;(1<<k)<=s;k++){
                    if(((1<<k)&s)!=0){
                        int cnt=0;
                        for(int ss=s^all;ss;ss>>=1) if(ss&1) cnt++;//计算还需要添加的混乱度
                        ans=Min(ans,dp[(n-1)&1][j][s][k]+cnt);
                    }
                }
            }
        }
        printf("Case %d: %d\n\n", ++cas, ans);
    }
    return 0;
}