csps-s模拟测试62,63Graph,Permutation,Tree,Game题解

题面：https://www.cnblogs.com/Juve/articles/11631298.html

permutation:

参考：https://www.cnblogs.com/clno1/p/10832579.html

因为原来的数组不好做于是我们想反过来数组，根据交换条件：值相邻且位置差大于等于k，那么在变换后的数组就变成了位置相邻且差值大于等于k。这样的话变换操作变成了，相邻的大于等于k的值临近交换，于是我们注意到因为现在只能临近交换的原因，两个差值小于k的数他们的相对位置不可能发生改变。那么问题就变成了，在只有一些相对位置限制条件下，无限制的可以随意交换位置，求这个数组的最小字典序（原数组字典序最小也是现在数组字典序最小）。那么我们容易想到拓扑排序。

但是如果每个点都想后面差值小于k的点连边的话，这个图会变得十分巨大，时间无法承受。于是我们必循得考虑优化建图：我们注意到像a->b,b->c,a->c这种建图，a->c这条边是不必要的。于是我们想办法避免掉这种无意义的边，所以对于某个点，我们让它向后面的所有限制(即差值小于k)中只向最小的那一个点连边，那么用线段树维护这样的信息，这样就达到优化建图的目的。

这样只向最小的连边为什么是对的呢？借用上面大佬的一句话：倒着加入，显然 p_i 连向 (p_i-k, p_i)∪(p_i, p_i+k)。我们只需要分别连向两个区间中下标最小的那一个即可。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<queue>
 using namespace std;
 const int MAXN=5e5+;
 int n,k,a[MAXN],pos[MAXN],du[MAXN],ans[MAXN],num=;
 vector<int>m[MAXN];
 priority_queue<int>q;
 int tr[MAXN<<];
 void update(int k,int l,int r,int opt,int val){
     if(l==r){
         tr[k]=min(tr[k],val);
         return ;
     }
     int mid=(l+r)>>;
     if(opt<=mid) update(k<<,l,mid,opt,val);
     else update(k<<|,mid+,r,opt,val);
     tr[k]=min(tr[k<<],tr[k<<|]);
 }
 int query(int k,int l,int r,int opl,int opr){
     if(opl>opr) return 0x3f3f3f3f;
     if(opl<=l&&r<=opr) return tr[k];
     int mid=(l+r)>>,res=0x3f3f3f3f;
     if(opl<=mid) res=min(res,query(k<<,l,mid,opl,opr));
     if(opr>mid) res=min(res,query(k<<|,mid+,r,opl,opr));
     return res;
 }
 int main(){
     scanf("%d%d",&n,&k);
     for(int i=;i<=n;++i){
         scanf("%d",&a[i]);
         pos[a[i]]=i;
     }
     memset(tr,0x3f,sizeof(tr));
     for(int i=n;i>=;--i){
         int p=query(,,n,max(,pos[i]-k+),pos[i]);
         if(p<=n) m[pos[i]].push_back(pos[p]),++du[pos[p]];
         p=query(,,n,pos[i],min(n,pos[i]+k-));
         if(p<=n) m[pos[i]].push_back(pos[p]),++du[pos[p]];
         update(,,n,pos[i],i);
     }
     for(int i=;i<=n;++i){
         if(!du[i]) q.push(-i);
     }
     while(!q.empty()){
         int x=-q.top();
         q.pop();
         ans[x]=++num;
         int N=m[x].size();
         for(int i=;i<N;++i){
             int y=m[x][i];
             --du[y];
             if(!du[y]) q.push(-y);
         }
     }
     for(int i=;i<=n;++i){
         printf("%d\n",ans[i]);
     }
     return ;
 }

tree：

好像是个结论：边权之和就是答案

#include<cstdio>
#define int long long
int n,ans=;
signed main(){
    scanf("%lld",&n);
    for(int i=,u,v,w;i<n;++i){
        scanf("%lld%lld%lld",&u,&v,&w);
        ans+=w;
    }
    printf("%lld\n",ans);
    return ;
}

game：

模拟用堆可以有50分

考虑如何优化

我们对于前p个数找出最大值，并开桶统计所有数出现的次数

然后对于一个新加入的点，如果它大于当前的最大值，那么下一个人一定选择新加如的这个点，所以最大值没有变

否则更新新加入的数的次数并更新最大值

考虑到最大值一定不上升，所以复杂度较有保障

但是还是会T，所以我们离散化一下

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<unordered_map>
#define re register
using namespace std;
const int MAXN=;
int n,k,a[MAXN],p,tim[MAXN],cnt,b[MAXN];
signed main(){
    scanf("%d%d",&n,&k);
    for(re int i=;i<=n;++i) scanf("%d",&a[i]),b[i]=a[i];
    sort(b+,b+n+);
    cnt=unique(b+,b+n+)-b-;
    for(int i=;i<=n;++i) a[i]=lower_bound(b+,b+cnt+,a[i])-b;
    while(k--){
        scanf("%d",&p);
        re long long ans1=,ans2=;
        re int maxp=;
        for(re int i=;i<=p;++i){
            ++tim[a[i]];
            maxp=max(maxp,a[i]);
        }
        ans1+=b[maxp];
        --tim[maxp];
        while(maxp>&&tim[maxp]==) --maxp;
        for(re int i=;i<=n;++i){
            if(i&){
                if(p+<=n){
                    ++p;
                    if(a[p]>=maxp) ans1+=b[a[p]];
                    else{
                        ans1+=b[maxp];
                        --tim[maxp];
                        ++tim[a[p]];
                        while(maxp>&&tim[maxp]==) --maxp;
                    }
                }else{
                    ans1+=b[maxp];
                    --tim[maxp];
                    while(maxp>&&tim[maxp]==) --maxp;
                }
            }else{
                if(p+<=n){
                    ++p;
                    if(a[p]>=maxp) ans2+=b[a[p]];
                    else{
                        ans2+=b[maxp];
                        --tim[maxp];
                        ++tim[a[p]];
                        while(maxp>&&tim[maxp]==) --maxp;
                    }
                }else{
                    ans2+=b[maxp];
                    --tim[maxp];
                    while(maxp>&&tim[maxp]==) --maxp;
                }
            }
        }
        printf("%lld\n",ans1-ans2);
    }
    return ;
}