[CF1523C] Compression and Expansion （DP/贪心）

C. Compression and Expansion

题面

一个合法的表单由横向 $N$ 行数字链，纵向一层或多层数字链组成，第 $k$ 层的数字链（可以想象为前面打了 $k$ 个制表符 ）由 $k$ 个数字组成，如 $k=3:1.1.1,1.1.2,1.2.1,\cdots$，$k=1:1,2,3,\cdots$。每个形如 $a_1.a_2.a_3.\cdots .a_k.x$ 的数字链都会在数字链 $a_1.a_2.a_3.\cdots .a_k$ 的后面，以及数字链 $a_1.a_2.a_3.\cdots .(a_k+1)$（如果有的话） 的前面，并且相互之间 $x$ 按照从小到大的顺序（它们不一定相邻）。上图中的最左边就是一个合法例子，右边的不合法。

现在告诉你每一行的数字链的最后一个数字，要还原出任意一个合法的表单。

$1\le N\le 1000$.

题解

Dynamic Programming

先分析一下最后一个数字给我们的信息：

• 如果此行是 1（最后数字），那么层数一定是上一行+1 。
• 如果此行非 1 ，设其为 $i$，那么和之前的某个末尾为 $i-1$ 的同层。

这种方向不好分析，我们换一换：

• 如果此行的下一行是 1，那么此行层数一定为下一行-1 ，且设此行的（末尾）数字为 $i$ ，后面可能有某数字为 $i+1$ 的行与此行最近同层。
• 如果此行的下一行非 1，设此行数字为 $i$ ，那么此行后面一定不能直接接层数+1的行了，且后面与此行最近同层的行数字一定不为 $i+1$。

这样好像更复杂了，但是我们可以依此想出一个 $\mathrm{D}\mathrm{P}$ 的方法：

• 维护两个值 $dp[i],next[i]$ ，依次表示 （$dp[i]$:） 第 $i$ 个位置向后延伸的最远距离，满足 $[i,i+dp[i]-1]$ 之间的行层数都不小于 $i$ 的层数，以及 （$next[i]$:） 满足 $dp[i]$ 最大的情况下，后面与 $i$ 最近同层的 $a_i+1$ 的位置，方便输出方案（没有就为 $N+1$）。
• 从后往前计算，如果此行 $i$ 的下一行数字是 1，就令 dp[i]=dp[i+1]+1 ，然后枚举后面的所有 $a$ 值为 $a_i+1$ 的行 $j$（实为枚举 $next[i]$ 的可能值），若 dp[j]+(j-i) > dp[i] ，说明更优，此时更新 dp[i]=dp[j]+(j-i) , next[i]=j 。
• 如果此行 $i$ 的下一行数字非 1，为 $a_i+1$，那么只好接着它：dp[i]=dp[i+1]+1 , next[i]=i+1 。
• 如果此行 $i$ 的下一行数字非 1 且非 $a_i+1$，那么没法向后延伸了，dp[i]=1 , next[i]=N+1 。
• 既然我们直到了每一行的 $next[i]$ ，那么就好输出方案了。

这样虽然有点大材小用，但是复杂度还是最优的 $O(n^2)$ 。

CODE

#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 1005
#define ENDL putchar('\n')
#define LL long long
#define DB double
#define lowbit(x) ((-x) & (x))
#define SI set<int>::iterator
LL read() {
	LL f = 1,x = 0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f * x;
}
int n,m,i,j,s,o,k;
int a[MAXN];
int dp[MAXN],nx[MAXN];
vector<int> bu[MAXN];
void print(int l,int r,string ss) {
	if(l > r) return ;
	int p = l;
	while(p > 0 && p <= r) {
		cout<<ss<<a[p]<<endl;
		char s0[15]; sprintf(s0,"%d.",a[p]);
		int nn = nx[p];
		string s2 = ss + s0;
		print(p+1,min(r,nn-1),s2);
		p = nn;
	}
	return ;
}
int main() {
	int T = read();
	while(T --) {
		n = read();
		for(int i = 1;i <= n;i ++) a[i] = read(),bu[i].clear();
		dp[n] = 1;nx[n] = n+1;
		bu[a[n]].push_back(n);
		for(int i = n-1;i > 0;i --) {
			dp[i] = 1;nx[i] = n+1;
			if(a[i+1] == 1) {
				int le = dp[i+1],nm = a[i]+1;
				dp[i] = le+1;
				for(int jj = 0;jj < (int)bu[nm].size();jj ++) {
					int j = bu[nm][jj];
					if(j <= i+le+1 && dp[j]+(j-i) > dp[i]) {
						dp[i] = dp[j]+(j-i); nx[i] = j;
					}
				}
			}
			else if(a[i+1] == a[i]+1) {
				dp[i] = dp[i+1]+1; nx[i] = i+1;
			}
			bu[a[i]].push_back(i);
		}
		print(1,n,"");
	}
	return 0;
}

---

Greedy

要是先祭出贪心方法，估计没人会看动规了吧

我们维护一个栈，若上一行的层数为 $k$ ，那么从栈顶到栈底依次是当前层数为 $k$ 的最后一行、层数为 $k-1$ 的最后一行、层数为 $k-2$ 的最后一行……

从前往后加行，每加一行 $i$ 就分类：

• $a_i>1$：在栈中依次弹出栈顶，直到找到数字等于 $a_i-1$ 的那行 $j$，然后成为它的后继，令 next[j]=i ，然后用 $i$ 替换 $j$。
• $a_i=1$：加入栈顶。

这样为什么是正确的呢？

$a_i=1$ 的情况就不用说了吧，只能加入栈顶。$a_i>1$ 时，没法增加层数了，那么一定得令栈中的某个数字等于 $a_i-1$ 的行替换为 $a_i$，并且让该数上面的都弹出栈。那么为什么不最小化弹出栈的元素个数呢？这样后面能匹配到的机会就更多，一定是最优的。

$\mathrm{z}\mathrm{x}\mathrm{y}:这样不就\mathrm{O}(\mathrm{n})了吗？$
$对曰:输出是\mathrm{O}({\mathrm{n}}^2)的，你没法降维。$

CODE

Perfect Solution by jiangly

#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t;
    std::cin >> t;
    while (t--) {
        int n;
        std::cin >> n;
        std::vector<int> a(n);
        for (int i = 0; i < n; i++) {
            std::cin >> a[i];
        }
        std::vector<std::vector<int>> ans(n);
        ans[0] = {1};
        std::vector<int> stk{0};
        for (int i = 1; i < n; i++) {
            if (a[i] == 1) {
                ans[i] = ans[stk.back()];
                ans[i].push_back(1);
                stk.push_back(i);
            } else {
                while (ans[stk.back()].back() != a[i] - 1) {
                    stk.pop_back();
                }
                ans[i] = ans[stk.back()];
                ans[i].back()++;
                stk.back() = i;
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < int(ans[i].size()); j++) {
                std::cout << ans[i][j] << ".\n"[j == int(ans[i].size()) - 1];
            }
        }
    }
    return 0;
}