[atAGC055E]Set Merging

当$S_{i}=S_{i+1}$时对$i$操作显然无意义，不妨强制不允许此类操作

构造排列$P_{i}$，初始等于$\{1,2,...,n\}$，当对$i$操作后交换$P_{i}$和$P_{i+1}$

结论：$S_{i}=[\min_{i\le j\le n}P_{j},\max_{1\le j\le i}P_{j}]$

考虑归纳，初始显然成立，考虑某次对$i$操作——

简单分析，也即求证$P_{i+1}\ne \min_{i\le j\le n}P_{j}$且$P_{i}\ne \max_{1\le j\le i+1}P_{j}$（这里的$P_{i}$仍是交换前的排列）

两者不成立的必要条件均为$P_{i}>P_{i+1}$，而此时显然$S_{i}=S_{i+1}$，与假设矛盾

换言之，问题即构造$P_{i}$，使得$L_{i}=\min_{i\le j\le n}P_{j}$且$R_{i}=\max_{1\le j\le i}P_{j}$，并最小化逆序对数

首先，可以确定确定$P_{i}=\begin{cases}L_{i}&(i=n\or L_{i}\ne L_{i+1})\\R_{i}&(i=1 \or R_{i}\ne R_{i-1})\end{cases}$

同时，简单判定合法性：无重复元素且不存在最小值过小/最大值过大（后者也保证了$L_{i}$和$R_{i}$单调不降）

然后，每一个$L_{i}$和$R_{i}$均已经存在$P_{j}$取到该值，即每一个位置仅还有$\in [L_{i},R_{i}]$的限制，根据两者的单调性，直接将剩余元素从小到大依次填入即可（填入时判定该限制，且这样也最小化逆序对数）

最终，简单统计逆序对数即可

时间复杂度为$o(n\log n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 500005
int n,L[N],R[N],P[N],vis[N],f[N];
long long ans;
int lowbit(int k){
    return (k&(-k));
}
void update(int k){
    while (k<=n){
        f[k]++;
        k+=lowbit(k);
    }
}
int query(int k){
    int ans=0;
    while (k){
        ans+=f[k];
        k-=lowbit(k);
    }
    return ans;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&L[i],&R[i]);
    for(int i=1;i<=n;i++){
        if ((i==n)||(L[i]!=L[i+1]))P[i]=L[i];
        if ((i==1)||(R[i]!=R[i-1])){
            if ((P[i])&&(P[i]!=R[i])){
                printf("-1\n");
                return 0;
            }
            P[i]=R[i];
        }
    }
    for(int i=n,s=n+1;i;i--){
        if (P[i])s=min(s,P[i]);
        if (s<L[i]){
            printf("-1\n");
            return 0;
        }
    }
    for(int i=1,s=0;i<=n;i++){
        if (P[i])s=max(s,P[i]);
        if (s>R[i]){
            printf("-1\n");
            return 0;
        }
    }
    for(int i=1;i<=n;i++){
        if ((P[i])&&(vis[P[i]])){
            printf("-1\n");
            return 0;
        }
        vis[P[i]]=1;
    }
    for(int i=1,j=1;i<=n;i++)
        if (!P[i]){
            while ((j<=n)&&(vis[j]))j++;
            if ((j<L[i])||(j>R[i])){
                printf("-1\n");
                return 0;
            }
            vis[j]=1,P[i]=j;
        }
    for(int i=1;i<=n;i++){
        ans+=query(n)-query(P[i]);
        update(P[i]);
    }
    printf("%lld\n",ans);
    return 0;
}