动态规划专题 - 解题报告 - C_input9 6 114518 114520 114514 114520 114515 114521-优快云博客

本文探讨了一道涉及动态规划的问题，主要分为两部分：手办的抽取和插入。在抽取部分，通过01背包思路解决，利用状态压缩表示当前状态。动态转移方程的关键在于考虑当前高度与上一次高度的关系。在插入部分，通过预处理统计手办高度种类，判断插入是否增加混乱值。滚动数组优化空间使用，避免空间爆炸。最后，提供了完整的AC代码。

依旧是先写博客打草稿再写码，听过题解后来整理一下思路，我们把抽出插入分为两个部分，①抽出k个手办，②将k个手办插入剩余（n-k）的手办堆中。
问题二很好解决，只要插入的堆中有一样高度的手办，就不会改变混乱值，尽量把这个手办安排在队列最后就不会影响到前面的排列，总体来说就是个贪心的思路。
问题一是难点，前n个手办抽出k个每个手办的状态只有取（1）或者不取（0）两种状态，这听起来就很01背包了，对于第i个手办，抽出时是否影响到整体混乱度取决于末位（前一位）的高度(last)（我们从前往后取），这是需要记录的，然后因为要限制只抽出k个，所以我们可以记录一下现在已经取了几个手办(j)了，一如平时我们解01背包那样。但是仅仅如此只会让第二问显得更麻烦，如果我能知道剩余有哪些手办了就好了，我们因为总共只有八种状态，所以可以状态压缩来表示当前状态(status)，用一串二进制的1和0表示当前位是否存在。

我们让dp[i][j][status][last]来表示取了当前第i位，这是第j次取，它的上一位是last，此时剩余元素中存在的状态是status时的最小混乱值。

之前提到的抽出时是否影响到整体混乱度取决于末位，就是说有这样的关系，设我们当前输入的手办高度为x，那么
if(last == x) dp[i][j][status][last] = min (dp[i][j][status][last], dp[i - 1][j][status][last]);
当前高度与上一次高度一致的话，肯定是不取最好嘛。
如果不一致呢？就要讨论是取还是不取了。
不取，就意味着要合并状态：

dp[i][j][status|(1<<x)][x] = 								//当前不取了，j维持不变，status合并，更新末位
			min (dp[i][j][status|(1<<x)][x], 				//在本身和i-1位时就已经取了j个，那时status和last的状态比较，
						dp[i-1][j][status][last] + 1);		//因为last!=x，所以混乱度必+1

那么取的话是什么情况呢？

dp[i][j+1][status][last] = min (dp[i][j+1][status][last], dp[i-1][j][status][last]); 
//单纯取最小值，因为statu和last啥都没改变

那么核心动态转移方程就出来了

if(last == x)
	 dp[i][j][status][last] = min (dp[i][j][status][last], dp[i - 1][j][status][last]);
else
{
	dp[i][j][status|(1<<x)][x] = min (dp[i][j][status|(1<<x)][x], dp[i-1][j][status][last] + 1);
	dp[i][j+1][status][last] = min (dp[i][j+1][status][last], dp[i-1][j][status][last]); 
}

做到这里我已经大呼大佬们的神乎其技了，这个转移方程出来之后基本上就能做了，不过为了保险起见怕空间炸还需要用滚动数组优化一下。我不知道为啥一开始交的没有优化的代码没有mle而是wa了，其他的改动也不多，大概是写挂了。
滚动数组：因为转移方程中我们发现dp[i][][][]的状态只与dp[i - 1][][][]的状态有关，所以我们只需要开一个大小为2的数组作第一维，每一次循环开始时先把不用的那轮初始化，然后用其记录本轮的状态，每次用0和1表示这一轮和下一轮的关系即可，具体操作见代码。说起来一直以来用的#define inf 2147483647的inf来初始化代码在这里竟然炸了，就很奇怪，后来退而求其次拿了平时经常模的#define hrdg 1000000007就过了，果然模hrdg能过代码。

再来讲讲第二个问题，我们得到了所有的dp[n%2][][][]时的最小混乱值，插回去的话，我们需要先统计一遍原本有多少种高度，如果当前status（剩余手办高度的状态）的高度种类比总共高度少，那么插回去就会增加混乱值。可以用预处理，计算出从0到(1<<8)-1所有手办的情况时有多少种类存在num[ ]数组里，然后每一次读入循环的答案统计一次tot表示全部种类数

		ans = hrdg;
        for (int j = 0; j <= k; j++)
        {
            for (int status = 0; status <= all; status++)
            {
                for (int last = 0; last <= 8; last++)
                {
                    if(dp[n%2][j][status][last] != hrdg)
                        ans = min(ans, dp[n%2][j][status][last]+tot-num[status]);
                }
            }
        }

完整AC代码如下：

#include<bits/stdc++.h>
#define FOR(a, b, c) for(int a=b; a<=c; a++)
#define maxn 105
#define maxm 55
#define hrdg 1000000007
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
#define pi acos(-1.0)
#define ls p<<1
#define rs p<<1|1
using namespace std;

int n, k, x, dp[2][maxn+5][1<<8+1][10], ans, cnt;
int all, tot, num[1<<9+1], now;
bool vis[9];
inline int read(){
    char c=getchar();long long x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

int gkd(int x){
    int ret = 0;
    while(x)
    {
        if(x&1)
            ret++;
        x >>= 1;
    }
    return ret;
}

int main()
{
    for (int i = 0; i <= 1<<8; i++)
        num[i] = gkd(i);						//预处理num[]数组
    while (~scanf("%d %d", &n, &k))
    {
        cnt++;
        if(n == 0 && k == 0)
            break;
        memset(vis, 0, sizeof(vis));
        memset(dp[0], hrdg, sizeof(dp[0]));         //为什么我用2147483647初始化会爆掉啊？？
        dp[0][0][0][8] = 0;
        all = 0; tot = 0;				//循环初始化
        for (int i = 1; i <= n; i++)
        {
            x = read();
            x -= 114514;
            all |= 1 << x;
            now = i % 2;
            if(vis[x] == 0)
            {
                vis[x] = 1;
                tot++;
            }
            memset(dp[now], hrdg, sizeof(dp[now]));			//初始化上上次的状态，因为这没什么用
            for (int j = 0; j <= min(k, i); j++)
            {
                for (int status = 0; status <= all; status++)
                {
                    for (int last = 0; last <= 8; last++)
                    {
                        if(dp[!now][j][status][last] != hrdg)			//核心转移方程如下
                        {
                            if(last == x)
                                 dp[now][j][status][last] = min (dp[now][j][status][last], dp[!now][j][status][last]);
                            else
                            {
                                dp[now][j][status|(1<<x)][x] = min (dp[now][j][status|(1<<x)][x], dp[!now][j][status][last] + 1);
                                dp[now][j+1][status][last] = min (dp[now][j+1][status][last], dp[!now][j][status][last]);
                            }
                        }
                    }
                }
                //puts("");
            }
        }
        //printf("%d\n", all);
        ans = hrdg;
        for (int j = 0; j <= k; j++)
        {
            for (int status = 0; status <= all; status++)
            {
                for (int last = 0; last <= 8; last++)
                {
                    if(dp[n%2][j][status][last] != hrdg)
                        ans = min(ans, dp[n%2][j][status][last]+tot-num[status]);			//更新答案
                }
            }
        }
        printf("Case %d: %d\n", cnt, ans);
    }
    return 0;
}

/*
9 6
114518 114520 114514 114520 114515 114521 114515 114519 114516
3 1
114516 114514 114518
2 2
114521 114521
6 3
114515 114520 114521 114518 114521 114515
0 0
*/