Educational Codeforces Round 57 (Rated for Div. 2)F. Inversion Expectation【期望逆序对】

F. Inversion Expectation

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

A permutation of size nn is an array of size nn such that each integer from 11 to nn occurs exactly once in this array. An inversion in a permutation pp is a pair of indices (i,j)(i,j) such that i>ji>j and ai<ajai<aj. For example, a permutation [4,1,3,2][4,1,3,2] contains 44 inversions: (2,1)(2,1), (3,1)(3,1), (4,1)(4,1), (4,3)(4,3).

You are given a permutation pp of size nn. However, the numbers on some positions are replaced by −1−1. Let the valid permutation be such a replacement of −1−1 in this sequence back to numbers from 11 to nn in such a way that the resulting sequence is a permutation of size nn.

The given sequence was turned into a valid permutation randomly with the equal probability of getting each valid permutation.

Calculate the expected total number of inversions in the resulting valid permutation.

It can be shown that it is in the form of PQPQ where PP and QQ are non-negative integers and Q≠0Q≠0. Report the value of P⋅Q−1(mod998244353)P⋅Q−1(mod998244353).

Input

The first line contains a single integer nn (1≤n≤2⋅1051≤n≤2⋅105) — the length of the sequence.

The second line contains nn integers p1,p2,…,pnp1,p2,…,pn (−1≤pi≤n−1≤pi≤n, pi≠0pi≠0) — the initial sequence.

It is guaranteed that all elements not equal to −1−1 are pairwise distinct.

Output

Print a single integer — the expected total number of inversions in the resulting valid permutation.

It can be shown that it is in the form of PQPQ where PP and QQ are non-negative integers and Q≠0Q≠0. Report the value of P⋅Q−1(mod998244353)P⋅Q−1(mod998244353).

Examples

input

Copy

3
3 -1 -1

output

Copy

499122179

input

Copy

2
1 2

output

Copy

0

input

Copy

2
-1 -1

output

Copy

499122177

Note

In the first example two resulting valid permutations are possible:

• [3,1,2][3,1,2] — 22 inversions;
• [3,2,1][3,2,1] — 33 inversions.

The expected value is 2⋅1+3⋅12=2.52⋅1+3⋅12=2.5.

In the second example no −1−1 are present, thus the only valid permutation is possible — the given one. It has 00 inversions.

In the third example there are two resulting valid permutations — one with 00 inversions and one with 11 inversion.

 

题意：给一个n的排列，其中有一些数缺失，现在等可能的将缺失的数放进去，求逆序对的期望值。

分析：首先可以把ans细分为3类

（1）已确定的数相互之间的逆序对

（2）未确定的数相互之间的逆序对

（3）确定与未确定的数之间的逆序对

对于（1）直接BIT求解即可

对于（2）相当于求解N个数任意排列的逆序对的期望，现在考虑将第N个数加入，那么这个数产生的贡献是（N-1）/2（易证明，其实就是（N-1）*N/2/N，等差数列求和即可：（N-1）*N/4。

对于（3）的情况，维护一个缺失的数的集合，对于每个缺失的为止，选取集合中的数是等可能的，那么这个缺失的数前面的每个数a[i]的贡献 = 集合中小于a[i]的数的个数/集合的SIZE，后面同理，动态维护一个sum即可。

#include<bits/stdc++.h>

using namespace std;
long long a[300004];
const int mod = 998244353;
long long qk(long long a,long long n){
    long long ans = 1;
    while(n){if(n&1)ans = ans * a % mod;n>>=1;a=a*a%mod;}
    return ans;
}
struct BIT {
    int n;vector<int> v;
    BIT(int n) : n(n) { v.resize(n + 1); }
    void update(long long x, long long d) { while (x <= n) { v[x] += d;if (v[x] >= mod)v[x] -= mod;x += (x & -x); }}
    long long que(long long x) { long long res = 0;while (x > 0) { res += v[x];if (res >= mod)res -= mod;x -= (x & -x); }return res; }
};
BIT l(200000),r(200000);
bool have[200004];
int main() {
    int n;
    cin>>n;
    memset(have,0, sizeof(have));
    for (int i = 1; i <= n; ++i) {
        scanf("%lld",&a[i]);if(a[i]!=-1)have[a[i]]=1;
    }
    vector<int>v;
    for (int i = 1; i <= n; ++i) {
        if(!have[i])v.push_back(i);
    }
    long long invn = qk(v.size(),mod-2);
    long long ans = 0;
    long long base = 0;
    for (int i = 1; i <= n; ++i) {
        if(a[i]!=-1){
            ans = (ans + l.que(n) - l.que(a[i]));
            l.update(a[i],1);
            base += upper_bound(v.begin(),v.end(),a[i]) - v.begin() ;
            base %= mod;
        }
        else {
            ans = (ans + base * invn % mod) % mod;
        }
    }
    base = 0;
    long long len = v.size();
    for (int i = n; i >= 1; --i) {
        if(a[i]!=-1){
            base += len - (upper_bound(v.begin(),v.end(),a[i]) - v.begin());
        }
        else {
            ans = (ans + base * invn % mod) % mod;
        }
    }
    ans = (ans + (len - 1) * len % mod * qk(4,mod - 2) % mod) % mod;
    cout<<ans<<endl;
}