2021暑期牛客多校训练营第二场 K-Stack

K-Stack

题目链接

题目描述

思路

题意：

让数组a的元素按顺序，进入单调栈。给出数组a中部分 第 pi 个数进入栈后的栈的大小，让你求出满足以上关系的数组 a 的排列组合，如果不存在输出 - 1

分析：
题目中所给代码维护了一个单调栈。所以我们也可以根据单调栈的特点，和给出的pi、xi、 和p(i - 1) 、x（i - 1) 的关系来构造出a[i] (i : 1-n) 这些数，这些数没必要一定 要 1-n，重要的是他们之间的大小关系，只要把他们的大小关系转换为排列组合即可。所以只要离散化下a[i]从小到大在整个序列中的序号，就是对应 1 - n的排列组合。

如何构造？很简单 ！ 分类讨论即可，解释下 pi xi (pi:数组a下标为pi的数入栈后，栈的大小xi，默认这里 pi 已经按从小到大排序过了）只要能够让数组a中p(i-1) + 1 到pi 的数进栈后体积变为 xi 即可

分类讨论

①pi - p(i - 1) + x(i - 1) < xi
无解 输出 - 1

②pi - (pi - 1) + x(i - 1) == xi
说明数组a下标 p(i - 1) + 1到pi的数都保存到了 栈中，说明栈顶 和 数组a下标从 p(i - 1) + 1 到 pi 的数是单调不递减的，所以从小到大构造即可

③pi - (pi - 1) + x(i - 1) > xi
说明栈的体积再加入这些数后，体积还小了，但不用管他内部顺序，只要满足从让数组a中p(i-1) + 1 到pi 的数进栈后体积变为 xi 即可。可以让p(i-1) + 1 到 pi - 1 个数直接按单调不减顺序进栈即可，然后再利用单调栈特点，构造出第 pi 个数使得pi进栈前，使得栈出栈了 pi - p(i - 1) + x(i-1) - xi - 1 个数即可

①为了避免构造出已经有的数，可以使用map。
②为了避免乱序，将数递增入栈时保证相邻两个数之间保证差值足够大，防止找比栈顶小的元素时，找成比栈顶的下一个数还小，从而导致错乱序。
③注意优化输入输出，and 使用模拟栈

code

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
typedef long long ll;
struct ty{
    ll p,x;// pi, xi
};

ty a[N];   //pi, xi
ll st[N];  //模拟栈
vector<ll>b;//存构造的 ai
vector<ll>c;//复制 vector<ll> b 并且离散化
unordered_map<ll,int> mp;

int main(){
    ll w = 1e8;
    ll now = 0;//栈顶下标
    ll cnt = 1;
    int n,k;    cin >> n >> k;
    for(int i = 1; i <= k; ++i)
        scanf("%lld %lld",&a[i].p, &a[i].x);
    
    sort(a + 1, a + 1 + k,[](ty a, ty b){return a.p < b.p;}); //按pi 从小到大排序
    
    a[0].p = 0,a[0].x = 0;//人为的加上左边界 方便操作
    if(a[k].p != n){      //人为加上右边界
        a[k + 1].p = n; a[k + 1].x = a[k].x + n - a[k].p;
        ++k;
    }
    
    for(int i = 1; i <= k; ++i){//判断是否有解
        if(a[i].p < a[i].x || a[i].x == 0){
          
            cout << -1 << "\n";
            return 0;
        }
        if(a[i].x > a[i-1].x && a[i].x - a[i-1].x > a[i].p - a[i - 1].p){
            cout << -1 << "\n";
            return 0;
        }
    }
    
  
    for(int i = 1; i <= k; ++i){//从 1 到 k 遍历 状态构造出 a 的全排列
       
        int p = a[i].p - a[i-1].p;
        int d = a[i].x - a[i-1].x;
        int sz = now;
     
        if(p < d){//无解
            cout << -1 << "\n";
            return 0;
        }else if(p == d){
            int in = p;//入栈个数
            while(in--){
                if(!now)
                {
                    st[++now] = 1;
                    b.push_back(1);
                    ++mp[1];
                }
                else{
                    ll z = st[now] + 1 + w;
                    while(mp.find(z) != mp.end()){
                        z += ++cnt;
                       
                    }
                    mp[z]++;
                    b.push_back(z);
                    st[++now] = b.back();
                }
            }
        }else{//p >= d
            
            int in = p - 1;//进栈 p - 1个数
           
            while(in--){
                if(!now)
                {
                    st[++now] = 1;
                    b.push_back(1);
                    ++mp[1];
                }
                else{
                    ll z = st[now] + 1 + w;
                    while(mp.find(z) != mp.end()){
                        z += ++cnt;
                       
                    }
                    mp[z]++;
                    b.push_back(z);
                    st[++now] = b.back();
                }
            }
            
            int out = p - 1 - d  ;//需要出栈几个数
            now -= out;           //模拟出栈
            
            ll z = st[now] - 1 ;    //找到替换栈顶的数
            
            while(mp.find(z) != mp.end()){//防止出现重复数字影响离散化
               z -= ++cnt;
            }
            
            mp[z]++;
            b.push_back(z);//保存构造的数a[i]
            
            st[now] = b.back();
        }
        
    }
    
    c = b;//复制
    sort(c.begin(),c.end(),[](ll a,ll b){return a < b;});//离散化排序
  
    for(int i = 0;i < n;++i){                            //转换成排列组合
        b[i] = lower_bound(c.begin(),c.end(), b[i])  - c.begin() + 1 ;
    }
    
    for(int i = 0 ;i < n; ++i)
        printf("%lld ",b[i]);
  
    return 0;
}