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[][N];
 int S[SIZE];

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

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

 int main()
 {
     #ifndef ONLINE_JUDGE
         freopen("3982.in", "r", stdin);
         freopen("3982.out", "w", stdout);
     #endif

     while (scanf("%d", &n) == )
     {
         Init();
         Solve();
     }

     #ifndef ONLINE_JUDGE
         fclose(stdin);
         fclose(stdout);
     #endif
     return ;
 }