UVA 12235 Help Bubu

状态压缩DP

题意： 书架上有n本书，给出一个书的高度的序列，我们把相邻的高度相同的书看成一个片段，并且定义该书架的混乱程度为片段的个数。为整理书架，你最多可以从中拿出k本书，然后再把他们插回书架(其他书的相对顺序保持不变)，使书架的混乱程度降至最低。1<=k<=n<=100，书高25<=h<=32。

解法： 书高只有8种，入手点。

设状态dp[i][j][s][k]为在第i本书，取了j本，留下的书的集合为s，留下的书的最后一本为k时的留下的书的混乱最小值，设第i本书高为a，有如下转移：

当k == a 时，dp[i][j][s][a] = min(dp[i][j][s][a], dp[i-1][j][s][k])

当k != a 时，

考虑不取走a： dp[i][j][s|(1<<a)][a] = min(dp[i][j][s|(1<<a)][a], dp[i-1][j][s][k] + 1)

考虑取走a： dp[i][j+1][s][k] = min(dp[i][j+1][s][k], dp[i-1][j][s][k])

最后的答案，还要考虑把取出来的书放回去会增加的混乱程度。

好一道4维状态的DP，初时见到高度只有8种，有想过压缩成集合，但是着实没敢想到开4维。

个人觉得从i推到i+1比较好写，注意初始化的问题。

UVA空间上不限制时间上超级宽，基本只要状态对了就不卡你，但是在hdu上，空间稍微不注意，不是MLE就是TLE，留意细节。

/* **********************************************
Author      : Nero
Created Time: 2013-8-31 21:55:28
Problem id  : UVA 12235
Problem Name: Help Bubu
*********************************************** */

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define REP(i,a,b) for(int i=(a); i<(int)(b); i++)
#define clr(a,b) memset(a,b,sizeof(a))

const int INF = 0x3f3f3f3f;
int dp[2][102][(1<<8)][8]; // 前i本书,取走j本,留下的书的集合为s,留下的书最后一本为k的最小混乱度
int n, K;
int all;

int main() {
    int ca = 0;
    while(~scanf("%d%d", &n, &K), n || K) {
        all = 0;
        int a;
        clr(dp[0], INF);
        for(int i = 0; i < n; i ++) {
            scanf("%d", &a);
            a -= 25;
            int now = i & 1;
            int nes = ! now;
            clr(dp[nes], INF);
            dp[nes][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(dp[now][j][s][k] != INF) {
                        if(k == a) dp[nes][j][s][a] = min(dp[nes][j][s][a], dp[now][j][s][k]);
                        else {
                            dp[nes][j][s|(1<<a)][a] = min(dp[nes][j][s|(1<<a)][a], dp[now][j][s][k] + 1);
                            dp[nes][j+1][s][k] = min(dp[nes][j+1][s][k], dp[now][j][s][k]);
                        }
                    }
                }
            }
            all |= (1<<a);
        }

        int minx = 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(dp[n&1][j][s][k] != INF) {
                    int cnt = 0;
                    for(int ss = s ^ all; ss; ss >>= 1) if(ss & 1) cnt ++;
                    minx = min(minx, cnt + dp[n&1][j][s][k]);
                }
            }
        }
        printf("Case %d: %d\n\n", ++ca, minx);
    }
    return 0;
}