C. Compression and Expansion
题面
一个合法的表单由横向
N
N
N 行数字链,纵向一层或多层数字链组成,第
k
k
k 层的数字链(可以想象为前面打了
k
k
k 个制表符 )由
k
k
k 个数字组成,如
k
=
3
:
1.1.1
,
1.1.2
,
1.2.1
,
⋯
k=3:1.1.1,1.1.2,1.2.1,\cdots
k=3:1.1.1,1.1.2,1.2.1,⋯,
k
=
1
:
1
,
2
,
3
,
⋯
k=1:1,2,3,\cdots
k=1:1,2,3,⋯。每个形如
a
1
.
a
2
.
a
3
.
⋯
.
a
k
.
x
a_1.a_2.a_3.\cdots.a_k.x
a1.a2.a3.⋯.ak.x 的数字链都会在数字链
a
1
.
a
2
.
a
3
.
⋯
.
a
k
a_1.a_2.a_3.\cdots.a_k
a1.a2.a3.⋯.ak 的后面,以及数字链
a
1
.
a
2
.
a
3
.
⋯
.
(
a
k
+
1
)
a_1.a_2.a_3.\cdots.(a_k+1)
a1.a2.a3.⋯.(ak+1)(如果有的话) 的前面,并且相互之间
x
x
x 按照从小到大的顺序(它们不一定相邻)。上图中的最左边就是一个合法例子,右边的不合法。
现在告诉你每一行的数字链的最后一个数字,要还原出任意一个合法的表单。
1 ≤ N ≤ 1000 1\leq N\leq 1000 1≤N≤1000.
题解
Dynamic Programming
先分析一下最后一个数字给我们的信息:
- 如果此行是 1(最后数字),那么层数一定是上一行+1 。
- 如果此行非 1 ,设其为 i i i,那么和之前的某个末尾为 i − 1 i-1 i−1 的同层。
这种方向不好分析,我们换一换:
- 如果此行的下一行是 1,那么此行层数一定为下一行-1 ,且设此行的(末尾)数字为 i i i ,后面可能有某数字为 i + 1 i+1 i+1 的行与此行最近同层。
- 如果此行的下一行非 1,设此行数字为 i i i ,那么此行后面一定不能直接接层数+1的行了,且后面与此行最近同层的行数字一定不为 i + 1 i+1 i+1。
这样好像更复杂了,但是我们可以依此想出一个 D P \rm DP DP 的方法:
- 维护两个值 d p [ i ] , n e x t [ i ] dp[i],next[i] dp[i],next[i] ,依次表示 ( d p [ i ] dp[i] dp[i]:) 第 i i i 个位置向后延伸的最远距离,满足 [ i , i + d p [ i ] − 1 ] [i,i+dp[i]-1] [i,i+dp[i]−1] 之间的行层数都不小于 i i i 的层数,以及 ( n e x t [ i ] next[i] next[i]:) 满足 d p [ i ] dp[i] dp[i] 最大的情况下,后面与 i i i 最近同层的 a i + 1 a_i+1 ai+1 的位置,方便输出方案(没有就为 N + 1 N+1 N+1)。
- 从后往前计算,如果此行
i
i
i 的下一行数字是 1,就令
dp[i]=dp[i+1]+1
,然后枚举后面的所有 a a a 值为 a i + 1 a_i+1 ai+1 的行 j j j(实为枚举 n e x t [ i ] next[i] next[i] 的可能值),若dp[j]+(j-i) > dp[i]
,说明更优,此时更新dp[i]=dp[j]+(j-i) , next[i]=j
。 - 如果此行
i
i
i 的下一行数字非 1,为
a
i
+
1
a_i+1
ai+1,那么只好接着它:
dp[i]=dp[i+1]+1 , next[i]=i+1
。 - 如果此行
i
i
i 的下一行数字非 1 且非
a
i
+
1
a_i+1
ai+1,那么没法向后延伸了,
dp[i]=1 , next[i]=N+1
。 - 既然我们直到了每一行的 n e x t [ i ] next[i] next[i] ,那么就好输出方案了。
这样虽然有点大材小用,但是复杂度还是最优的 O ( n 2 ) O(n^2) O(n2) 。
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 ,那么从栈顶到栈底依次是当前层数为 k k k 的最后一行、层数为 k − 1 k-1 k−1 的最后一行、层数为 k − 2 k-2 k−2 的最后一行……
从前往后加行,每加一行 i i i 就分类:
-
a
i
>
1
a_i>1
ai>1:在栈中依次弹出栈顶,直到找到数字等于
a
i
−
1
a_i-1
ai−1 的那行
j
j
j,然后成为它的后继,令
next[j]=i
,然后用 i i i 替换 j j j。 - a i = 1 a_i=1 ai=1:加入栈顶。
这样为什么是正确的呢?
a i = 1 a_i=1 ai=1 的情况就不用说了吧,只能加入栈顶。 a i > 1 a_i>1 ai>1 时,没法增加层数了,那么一定得令栈中的某个数字等于 a i − 1 a_i-1 ai−1 的行替换为 a i a_i ai,并且让该数上面的都弹出栈。那么为什么不最小化弹出栈的元素个数呢?这样后面能匹配到的机会就更多,一定是最优的。
z x y : 这 样 不 就 O ( n ) 了 吗 ? \rm zxy:这样不就~O(n)~了吗? zxy:这样不就 O(n) 了吗?
对 曰 : 输 出 是 O ( n 2 ) 的 , 你 没 法 降 维 。 \rm 对曰:输出是~O(n^2)~的,你没法降维。 对曰:输出是 O(n2) 的,你没法降维。
CODE
#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;
}