BZOJ 3982 Stacking Plates 解题报告

我们首先可以得到：如果有一堆盘子里有一些相邻的盘子的直径相等，那么自然这些盘子可以统一处理，就可以缩成一个了。

然后我们接着考虑给每一堆盘子都染上一种颜色，那么操作的次数 step = diff * 2 - n + 1

其中 diff 表示最终的盘子堆中相邻的盘子的颜色不同的对数。

接着我们可以将盘子的直径离散化。

那么我们可以考虑Dp，设 Dp[s][i] 为处理完所有盘子直径小于等于 s 的盘子，并且最底下的盘子的颜色是 i 的 diff 的最小值。

至于转移的话呢，记直径为 s 的盘子个数为 tot[s]，然后找到所有直径为 s 的盘子及其颜色 i ，那么就有：

• res1 = min(Dp[s - 1][j] + tot[s]) (j = 1 ~ n)
• res2 = min(Dp[s - 1][k] + tot[s] - 1) (存在一个直径为 s，颜色为 k 的盘子)
• Dp[s][i] = min(res1, res2)

初始化 Dp[0][i] = 0 (i = 1 ~ n)

答案 ans = min(Dp[Max_s][i]) * 2 - n + 1 

于是就做完啦~

毕竟 Gromah 太弱，只会做水题。

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define N 50 + 5
#define M 2500 + 5
#define SIZE 10000 + 5
#define INF 593119681

int _, n;
int A[N][N];
int Size[N], Point[N], T[N];
int Dp[2][N];
int S[SIZE];

inline void Init()
{
    memset(S, 0, sizeof(S));
    for (int i = 1; i <= n; i ++)
    {
        scanf("%d", Size + i);
        for (int j = 1; j <= Size[i]; j ++)
        {
            scanf("%d", A[i] + j);
            S[A[i][j]] = 1;
        }
        Size[i] = unique(A[i] + 1, A[i] + Size[i] + 1) - A[i] - 1;
        Point[i] = 1;
    }
    for (int i = 1; i < SIZE; i ++)
        S[i] += S[i - 1];
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= Size[i]; j ++)
            A[i][j] = S[A[i][j]];
}

inline void Solve()
{
    printf("Case %d: ", ++ _);
    for (int i = 0; i <= n; i ++)
        Dp[0][i] = 0;
    for (int i = 1; i <= S[SIZE - 1]; i ++)
    {
        T[0] = 0;
        Dp[1][0] = INF;
        for (int j = 1; j <= n; j ++)
        {
            if (A[j][Point[j]] == i)
                T[++ T[0]] = j, Point[j] ++;
            Dp[1][j] = INF;
        }
        for (int j = 1; j <= T[0]; j ++)
        {
            for (int k = 1; k <= T[0]; k ++)
            {
                if (j == k && T[0] > 1) continue ;
                Dp[1][T[k]] = min(Dp[1][T[k]], Dp[0][T[j]] + T[0] - 1);
            }
            for (int k = 0; k <= n; k ++)
                Dp[1][T[j]] = min(Dp[1][T[j]], Dp[0][k] + T[0]);
        }
        for (int j = 0; j <= n; j ++)
            Dp[0][j] = Dp[1][j];
    }
    int Min = INF;
    for (int i = 0; i <= n; i ++)
        Min = min(Min, Dp[0][i]);
    printf("%d\n", Min * 2 - n + 1);
}

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("3982.in", "r", stdin);
        freopen("3982.out", "w", stdout);
    #endif
    
    while (scanf("%d", &n) == 1)
    {
        Init();
        Solve();
    }
    
    #ifndef ONLINE_JUDGE
        fclose(stdin);
        fclose(stdout);
    #endif
    return 0;
}