[bzoj4889] [Tjoi2017]不勤劳的图书管理员

Description

加里敦大学有个帝国图书馆，小豆是图书馆阅览室的一个书籍管理员。他的任务是把书排成有序的，所以无序的书让他产生厌烦，两本乱序的书会让小豆产生这两本书页数的和的厌烦度。现在有n本被打乱顺序的书，在接下来m天中每天都会因为读者的阅览导致书籍顺序改变位置。因为小豆被要求在接下来的m天中至少要整理一次图书。小豆想知道，如果他前i天不去整理，第i天他的厌烦度是多少，这样他好选择厌烦度最小的那天去整理。

Input

第一行会有两个数，n，m分别表示有n本书，m天

接下来n行，每行两个数，ai和vi，分别表示第i本书本来应该放在ai的位置，这本书有vi页，保证不会有放置同一个位置的书

接下来m行，每行两个数，xj和yj，表示在第j天的第xj本书会和第yj本书会因为读者阅读交换位置

Output

一共m行，每行一个数，第i行表示前i天不去整理，第i天小豆的厌烦度，因为这个数可能很大，所以将结果模10^9 +7后输出

Sample Input

Sample Output

HINT

对于20%的数据，1 ≤ ai; xj; yj ≤ n ≤ 5000, m ≤ 5000, vi ≤ 10^5

对于100%的数据，1 ≤ ai; xj; yj ≤ n ≤ 50000, m ≤ 50000, vi ≤ 10^5

solution

话说$bzoj$没有题面是什么操作啊。。

题目其实就是让你维护动态的逆序对。

注意到每次$swap(l,r)$，只会改变$\forall \, i \in \, [l+1,r-1]$，$(l,i)\&(i,r)$ 这些二元组的贡献，

所以可以维护一个全局变量$ans$统计答案，然后用树状数组套动态开点的权值线段树来维护就行了。

具体的，对于每个线段树维护$x$到$y$的权值，记录一个$sum$表示$b_i$的和，$num$表示有多少个。

然后对于$l$的贡献就是$[l+1,r-1]$当中$b_i$范围在 $(0,a_l-1]$内的 $sum$ 加上 $num \cdot b_l $，然后 $ans$减去这个再加上 $swap$后的贡献。

对于$r$也类似，然后就做完了。

注意少模几次，少开点$long\,long$啥的就能过了。

%: pragma GCC optimize(3)  // 人傻常数大QAQ

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define void inline void

#define il inline

void read(int &x) {

	x=0;int f=1;char ch=getchar();

	for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;

	for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;

}

void print(ll x) {

	if(x<0) putchar('-'),x=-x;

	if(!x) return ;print(x/10),putchar(x%10+48);

}

void write(ll x) {if(!x) putchar('0');else print(x);putchar('\n');}

const int maxn = 1e5+10;

const int N = 1e5;

const int mod = 1e9+7;

int ls[maxn*120],rs[maxn*120],sum[maxn*120],tot,num[maxn*120];

int a[maxn],b[maxn],n,m;

#define mid ((l+r)>>1)

struct Segment_Tree {

	void modify(int &p,int l,int r,int x,int v,int val) {

		if(!p) p=++tot;sum[p]+=val;num[p]+=v;

		if(l==r) return ;

		if(x<=mid) modify(ls[p],l,mid,x,v,val);

		else modify(rs[p],mid+1,r,x,v,val);

	}

	il int query(int p,int l,int r,int x,int y) {

		if(!p) return 0;

		if(x<=l&&r<=y) return sum[p];

		int ans=0;

		if(x<=mid) ans+=query(ls[p],l,mid,x,y);

		if(y>mid) ans+=query(rs[p],mid+1,r,x,y);

		return ans;

	}

	il int query_num(int p,int l,int r,int x,int y) {

		if(!p) return 0;

		if(x<=l&&r<=y) return num[p];

		int ans=0;

		if(x<=mid) ans+=query_num(ls[p],l,mid,x,y);

		if(y>mid) ans+=query_num(rs[p],mid+1,r,x,y);

		return ans;

	}

};

il ll dec(ll x,ll y) {if(x<y) x+=mod;return x-y;}

struct Binary_Indexed_Tree {

	int rt[maxn];

	Segment_Tree SGT[maxn];

	void modify(int i,int x,int v,int val) {

		for(;i<=n;i+=i&-i) SGT[i].modify(rt[i],0,N,x,v,val);

	}

	il ll query(int l,int r,int L,int R) {

		if(l>r||L>R) return 0;ll ans=0;

		for(;r;r-=r&-r) ans+=SGT[r].query(rt[r],0,N,L,R);l--;

		for(;l;l-=l&-l) ans-=SGT[l].query(rt[l],0,N,L,R);

		return ans;

	}

	il ll query_num(int l,int r,int L,int R) {

		if(l>r||L>R) return 0;ll ans=0;

		for(;r;r-=r&-r) ans+=SGT[r].query_num(rt[r],0,N,L,R);l--;

		for(;l;l-=l&-l) ans-=SGT[l].query_num(rt[l],0,N,L,R);

		return ans;

	}

}BIT;

int main() {

	read(n),read(m);ll ans=0;

	for(int i=1;i<=n;i++) read(a[i]),read(b[i]),BIT.modify(i,a[i],1,b[i]);

	for(int i=1;i<=n;i++)

		ans+=BIT.query(1,i-1,a[i]+1,N)+BIT.query_num(1,i-1,a[i]+1,N)*b[i];

	for(int x,y,i=1;i<=m;i++) {

		read(x),read(y);if(x>y) swap(x,y);

		if(x==y) {write(ans);continue;}

		ans=dec(ans,BIT.query(x+1,y-1,1,a[x]-1));

		ans=dec(ans,1ll*BIT.query_num(x+1,y-1,1,a[x]-1)*b[x]);

		ans=dec(ans,BIT.query(x+1,y-1,a[y]+1,N));

		ans=dec(ans,1ll*BIT.query_num(x+1,y-1,a[y]+1,N)*b[y]);

		ans=(ans+BIT.query(x+1,y-1,1,a[y]-1));

		ans=(ans+1ll*BIT.query_num(x+1,y-1,1,a[y]-1)*b[y]);

		ans=(ans+BIT.query(x+1,y-1,a[x]+1,N));

		ans=(ans+1ll*BIT.query_num(x+1,y-1,a[x]+1,N)*b[x])%mod;

		if(a[x]>a[y]) ans=(ans-b[x]-b[y])%mod;

		else ans=(ans+b[x]+b[y])%mod;

		BIT.modify(x,a[x],-1,-b[x]),BIT.modify(x,a[y],1,b[y]);

		BIT.modify(y,a[y],-1,-b[y]),BIT.modify(y,a[x],1,b[x]);

		swap(a[x],a[y]),swap(b[x],b[y]);

		write(ans=(ans+mod)%mod);

	}

	return 0;

}