Codeforces 1096F Inversion Expectation（数学+树状数组）

题目链接：Inversion Expectation

题意：给定一个长为n数组，数组中包含[1,n]中每个元素，但部分位置被-1代替，每个位置可以被[1,n]中任意数代替，但需要满足最终数组中包含[1,n]中每个元素且每个元素只出现一次,问期望的逆序对数量

题解：一直以为是DP，参考了题解后恍然大悟，我们可以把问题分成三个部分分开考虑

1.已知数和已知数直接形成的逆序对，可以用树状数组维护即可

2.未知数和未知数之间形成逆序对，我们可以发现两个未知数，二者大于对方的概率都为1/2，所以记录下有多少个未知数m，那么就一共有m(m-1)/2对，所以期望为m(m-1)/4

3.已知数和未知数，考虑两个位置上分别为已知数和未知数，设有tmp个数小于当前已知数并且未出现（即可代替未知数且小于当前已知数到的个数），那么已知数大于未知数的期望即为tmp/m，已知数小于未知数的概率即为(m-tmp)/m（即1-tmp/m）,发现具有累加性，故可以分左右贡献枚举两次，用前缀和优化，

细节和不懂见代码注释（很详细）：

#include<iostream>
#include<stack>
#include<list>
#include<set>
#include<vector>
#include<algorithm>
#include<math.h>
#include<numeric>
#include<map>
#include<cstring>
#include<queue>
#include<iomanip>
#include<cmath>
#include<queue>
#include <bitset>
#include<unordered_map>
	#ifndef local
	#define endl '\n'
#endif */
#define mkp make_pair
using namespace std;
using std::bitset;
typedef long long ll;
typedef long double ld;
const int inf=0x3f3f3f3f;
const ll MAXN=2e6+10;
const ll N=1e5+100;
const ll mod=998244353;
const ll hash_p1=1610612741;
const ll hash_p2=805306457;
const ll hash_p3=402653189;
//-----------------------------------------------------------------------------------------------------------------*/
// ll head[MAXN],net[MAXN],to[MAXN],edge[MAXN]/*流量*/,cost[MAXN]//费用;
/* 
void add(ll u,ll v,ll w,ll s){
	to[++cnt]=v;net[cnt]=head[u];edge[cnt]=w;cost[cnt]=s;head[u]=cnt;
	to[++cnt]=u;net[cnt]=head[v];edge[cnt]=0;cost[cnt]=-s;head[v]=cnt;
}
struct elemt{
	int p,v;
};
struct comp{
	public:
		bool operator()(elemt v1,elemt v2){
			return v1.v<v2.v;
		}
};
-----------------------------------
求[1,MAXN]组合式和逆元 
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}	
		a=a*a%mod;
	}
	return res;
}
ll fac[MAXN],inv[MAXN]
fac[0]=1;inv[0]=1;
for(int i=1;i<=MAXN;i){
	fac[i]=(fac[i-1]*i)%mod;
	inv[i]=mi(fac[i],mod-2);
}
ll C(int m,int n){//组合式C(m,n); 
	if(!n){
		return 1;
	}
	return fac[m]*(inv[n]*inv[m*-n]%mod)%mod;
}
---------------------------------
 unordered_map<int,int>mp;
//优先队列默认小顶堆 ， greater<int> --小顶堆  less<int> --大顶堆  
priority_queue<elemt,vector<elemt>,comp>q;
	set<int>::iterator it=st.begin();
*/
// vector<vector<int>>edge; 二维虚拟储存坐标 
//-----------------------------------------------------------------------------------------------------------------*/
  //map<int,bool>mp[N]; 
int b[2*N];
int n;
void update(int x){
	while (x<=n){
		b[x]++;
		x+=x&-x;
	}
}
ll query(int x){
	int res=0;
	while(x){
		res+=b[x];
		x-=x&-x;
	}
	return res;
}
int a[2*N];
int vis[2*N];
ll num[2*N];//记录有多少个已知数小于等于自己
ll mi(ll a,ll b){
	ll res=1;
	while(b){
		if(b%2){
			res=res*a%mod;
		}
		a=a*a%mod;
		b/=2;
	}
	return res;
}
int main(){
/*cout<<setiosflags(ios::fixed)<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（不含整数部分）*/
/*cout<<setprecision(8)<<ans<<endl;//输出ans（float）格式控制为8位小数（含整数部分）*/
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//同步流
	cin>>n;
	ll m=0;//记录未知数个数
	for(int i=1;i<=n;i++){
		cin>>a[i];
		if(a[i]==-1){
			m++;
		}
		else{
			vis[a[i]]++;
		}
	}
	//分三个部分计算
	//第一部分：未知数和未知数之间;相互之间比对方大的概率维0.5，所以总和为：m*(m-1)/4
	ll ans=m*(m-1)%mod*mi(4,mod-2)%mod;
	//第二部分：已知数和已知数，直接树状数组求
	for(int i=1;i<=n;i++){//求有多少个已知数小于等于自己
		num[i]=num[i-1];
		if(vis[i]){
			num[i]++;
		}
	}
	for(int i=1;i<=n;i++){//树状数组求第二部分
		if(a[i]==-1){
			continue;
		}
		update(a[i]);
		ans+=num[a[i]]-query(a[i]);//这些数比a[i]小但又在a[i]后面
		ans%=mod;
	}
	//第三部分，已知数和未知数
	ll pre=0;//累加贡献
	for(int i=1;i<=n;i++){//先算每个未知数对左边数的贡献
		if(a[i]!=-1){
			ll tmp=a[i]-num[a[i]];//有多少个小于a[i]但没出现
			pre+=tmp*mi(m,mod-2)%mod;
			pre%=mod;
		}
		else{
			ans+=pre;
			ans%=mod;
		}
	}
	pre=0;
	for(int i=n;i>=1;i--){
		if(a[i]!=-1){
			ll tmp=a[i]-num[a[i]];
			tmp=m-tmp;//有多少个大于a[i]但没出现
			pre+=tmp*mi(m,mod-2)%mod;
			pre%=mod;
		}
		else{
			ans+=pre;
			ans%=mod;
		}
	}
	cout<<ans<<endl;
	return 0;
}