Codeforces Round #504：D. Array Restoration

D. Array Restoration

题目链接：https://codeforces.com/contest/1023/problem/D

题意：

给出一个序列，现在要求对一个全为0的序列执行q次操作，每次操作都要选定一段区间然后将区间上面的值变为i（i为操作的次数）。最终使得0序列变为之前给出的序列。

原序列中如果存在0，那么说明这个值是任意的。

最后要求输出经过q次操作之后的序列。

题解：

我们首先可以想到不可行的情况：在原序列中若存在一个数a，假设其出现次数大于1，那么两端为a的中间区间部分，是没有值比a小的。

还有一种情况也不可行，就是原序列中没有0且最大值小于q。

当把这两种情况排除过后，就是可行的情况了，之后输出方案就好了。

输出方案的时候还要解决0的问题，我的解决方案是让0等于其右边或左边的数，我是将一段连续的0缩点后进行处理的。

代码如下：

#include <bits/stdc++.h>
#define pii pair<int,int>
#define INF 99999999
using namespace std;
 
const int N = 2e5+;
int n,q;
int a[N],cnt[N];
struct node{
    int l,r;
}z[N],All[N];
int f[N][];
vector <int> vec[N];
int main(){
    cin>>n>>q;
    int num = ,mx=;
    a[]=-;a[n+]=-;
    for(int i=;i<=n;i++){
        scanf("%d",&a[i]);
        mx=max(mx,a[i]);
        if(a[i]==&&a[i-]!=){
            num++;
        }
        if(a[i]==){
            cnt[i]=num;
            if(a[i-]!=) z[num].l=i-;
        }else if(a[i-]==) z[num].r=i;
        vec[a[i]].push_back(i);
    }
    if(a[n]==) z[num].r=n+;
    int flag = ;
    for(int i=;i<=n;i++){
        if(a[i]== || vec[a[i]].size()<=) continue ;
        int len = vec[a[i]].size()-;
        All[a[i]].l=vec[a[i]][];
        All[a[i]].r=vec[a[i]][len];
    }
    for(int i=;i<=n;i++) for(int j=;j<=;j++) f[i][j]=INF;
    for(int i=;i<=n;i++) f[i][]=(a[i]== ? INF : a[i]);
    for(int i=;i<=n;i++)
        for(int j=;j<=;j++)
            f[i][j]=min(f[i][j-],f[i+(1ll<<(j-))][j-]);
    for(int i=;i<=n;i++){
        if(vec[a[i]].size()<=) continue ;
        int l = All[a[i]].l,r = All[a[i]].r;
        l++;r--;
        int K = log((r-l+));
        int mn = min(f[l][K],f[r-(<<K)+][K]);
        if(mn<a[i]){
            flag=;
            break ;
        }
    }
    int ok=;
    if(q>mx) ok=;
    if(ok) for(int i=;i<=n;i++){
        if(a[i]==){
            a[i]=q;
            ok=;
            break ;
        }
    }
    if(flag||ok==) cout<<"NO";
    else{
        cout<<"YES"<<endl;
        for(int i=;i<=n;i++){
            if(a[i]!=){
                cout<<a[i]<<" ";
            }
            else{
                int l = z[cnt[i]].l,r = z[cnt[i]].r;
                if(l< && r>n) cout<<q<<" ";
                else if(l<) cout<<a[r]<<" ";
                else cout<<a[l]<<" ";
            }
        }
    }
    return ;
}

之后看了下标程，用的是并查集orz...

标程的想法就比较巧妙了，首先把之前说的第二种不可行情况判断一下，然后开始骚操作。

其基本思想为：值从大到小进行区间修改的操作，对于当前位置的数而言，用并查集来维护i之后小于或等于它的第一个位置。

因为我们是从大到小开始涂色，对于第一次涂色，肯定能找到第一个小于或等于它的位置；对于第i次涂色，假设当前位置为pos，如果pos+1的值比pos的值大，那么它之前已经操作过了，说明已经用并查集处理过了，那么f(pos+1)就是比pos+1的值小的第一个位置；如果此时找到的值还比pos的值大，那么就继续寻找；如果比pos的值小，那么就不可行。

注意上面查找值时要满足值的存在区间范围，并且为了输出方案，我们还要对区间进行修改，这时只用对0进行修改就好了~比它大的都不用管。

具体代码如下：

#include <bits/stdc++.h>
using namespace std;
 
const int N =2e5+;
int n,q;
int f[N],l[N],r[N];
int a[N];
 
int find(int x){
    return f[x]==x ? f[x] : f[x]=find(f[x]);
}
 
int main(){
    cin>>n>>q;
    for(int i=;i<=q;i++) l[i]=n+,r[i]=;
    for(int i=;i<=n+;i++) f[i]=i;
    for(int i=;i<=n;i++){
        scanf("%d",&a[i]);
        l[a[i]]=min(l[a[i]],i);
        r[a[i]]=max(r[a[i]],i);
    }
    if(l[q]>r[q]){
        if(l[]>r[]){
            cout<<"NO";
            return ;
        }
        a[l[]]=q;
        f[l[]]=l[]+;
    }
    for(int i=q;i>=;i--){
        for(int j=find(l[i]);j<=r[i];j=find(j)){
            if(a[j] && a[j]<i){
                cout<<"NO";
                return ;
            }
            a[j]=i;
            f[j]=find(j+);
        }
    }
    puts("YES");
    for(int i=;i<=n;i++) printf("%d ",a[i]?a[i]:);
    return ;
}