Codeforces_1187D 居然是线段树

Codeforces 1187D

——居然是线段树

---

题目大意

给n个数的序列a和b，对序列a可以选择子序列排序，问a能否变成b。

思路

对a序列的每个出现的数字，用队列来存储每次出现的位置。对于b序列中每个数字，对应的那个数字到当前位进行操作，且影响最小，就是两两排序，将那个位置的数交换过来，前提是，当前位置到应该在该位置的数的位置间的数字都不小于当前所需数字。即，我们需要知道，区间（当前位置，到，队列里该数字位置）最小值是否是当前所需数字。

这样，问题就转化成了线段树，记录区间最小值即可。居然是线段树。

每次查询后，将所需数字a序列位置，置inf，线段树单点修改。这样就不会影响到后面再进行区间最小值的求解了，每次查询最开始到当前所需数字位置即可，因为如果当前位置仍是转换成功仍是有可能的话，当前位置前已经填好了数字，即排序/交换过了。为了避免麻烦而不现实的排序操作，我们通过这种方式就可以做到。

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int maxn = 3e5+10;

int t,n;
int a[maxn],b[maxn];
queue <int> pos[maxn];
bool flag;

struct node{
    int l,r;
    int mins,tag;
}tree[maxn<<2];

void build(int k,int l,int r)
{
    tree[k].l=l;tree[k].r=r;
    tree[k].tag=0;
    if(l==r){
        tree[k].mins=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    tree[k].mins=min(tree[k<<1].mins,tree[k<<1|1].mins);
}

int query(int k,int l,int r)
{
    if(tree[k].l==l&&tree[k].r==r){
        return tree[k].mins;
    }
    int mid=(tree[k].l+tree[k].r)>>1;
    if(r<=mid) return query(k<<1,l,r);
    else if(l>=mid+1) return query(k<<1|1,l,r);
    else return min(query(k<<1,l,mid),query(k<<1|1,mid+1,r));
}

void update(int k,int pos,int val)
{
    if(tree[k].l==tree[k].r){
        tree[k].mins=val;
        return;
    }
    int mid=(tree[k].l+tree[k].r)>>1;
    if(pos<=mid) update(k<<1,pos,val);
    else if(pos>=mid+1) update(k<<1|1,pos,val);
    tree[k].mins=min(tree[k<<1].mins,tree[k<<1|1].mins);
}

int main()
{
    scanf("%d",&t);
    while(t--){
        flag=true;
        scanf("%d",&n);
        for(int i=1;i<=n;++i){
            while(!pos[i].empty()) pos[i].pop();    //clear!
        }
        for(int i=1;i<=n;++i){
            scanf("%d",&a[i]);
            pos[a[i]].push(i);
        }
        build(1,1,n);
        for(int i=1;i<=n;++i) scanf("%d",&b[i]);
        for(int i=1;i<=n;++i){
            if(pos[b[i]].empty()){
                flag=false;break;
            }
            int j=pos[b[i]].front();pos[b[i]].pop();
            int m=query(1,1,j); //前面所有的
            if(m<b[i]){
                flag=false;break;
            }
            update(1,j,maxn);
            //更新时即排序并不是说区间排序，这样并不是最优，而且也不这样因为要改动的太多了，
            //而是类似一个冒泡的过程则可改动最小，贪心地更可能YES，
            //故而将原来所在位的最小值置为最大即可
        }
        if(flag) printf("YES\n");
        else printf("NO\n");
    }

    return 0;
}