【训练题47：概率dp | 动态规划 | 优化】Increasing Subsequence | 2021牛客暑期多校训练营1 I题

题意

• Increasing Subsequence | 2021牛客暑期多校训练营1
  长度为 $n$ 的数组，第 $i$ 个数为 $a_i$ , 且这个数组是一个 $[1,n]$ 的全排列
  $Alice$ 先等概率随机选择一个位置 $x$ ， 然后 $Bob$ 也等概率随机选择一个位置 $y$ ，但要求 $a_y>a_x$
  然后 $Alice$ 先，轮流两人操作：
• 假设 ta 上一步选择的下标为 $x$ ，对方上一步选择的下标为 $y$
  那么 ta 必须选择一个位置 $k$ ， 满足 $k>x$ 且 $a_k>a_y$
  多有多个满足的位置，那么 ta 会等概率随机选择一个
  若没有满足的位置，那么结束
  问你从开始到结束，轮次的期望值
• $1\le n\le 5000$

思路

• 看到期望，还有数据范围，肯定会去想一个 期望的 $dp$
  设 $dp[i][j]$ 表示 $Alice$ 拿了下标 $i$ ，$Bob$ 拿了下标 $j$ ，到结束的轮次的期望
  我们根据 $a_i、a_j$ 的大小关系可以自己判断下一步是谁拿数字
  假设 $a_i>a_j$ ，那么就是 $Bob$ 拿，我们自己可以写出转移：
  $$dp[i][j]=\frac{1}{c}\sum _{\underset{a_k>a_i}{k>j}}dp[i][k]+1$$
  假设 $a_i<a_j$，那么就是 $Alice$ 拿：
  $$dp[i][j]=\frac{1}{c}\sum _{\underset{a_k>a_j}{k>i}}dp[k][j]+1$$
  这里 $c$ 就是有多少个 $k$ 满足以上要求
  但是这样直接去做当然是 $O(N^3)$ 的，直接 $TLE$
  当时我用开 $4n$ 个树状数组去做，但是 $O(N^2\log N\times c)$ 也 $TLE$
  实际上，我们可以优化到 $O(N^2)$
• 两个状态维度都是必须要的，也就是说我们只能去 $O(1)$ 获得后面的那个求和
  因为我们写代码肯定是这样：

	for(int i = n;i >= 1;--i)
	for(int j = n;j >= 1;--j){
		dp[i][j] = Something
	}

• 对于 $Bob$ 拿的情况，我们需要快速求出 ${\sum }_{\underset{a_k>a_i}{k>j}}dp[i][k]$
  因为我们就是 $j$ 从 $n$ 倒序枚举到现在的，所以我们只要对当前的 $i$ ，记录有多少个数满足 $a_k>a_i$，并且把他们的 $dp[i][k]$ 的和记录下来，就可以 $O(1)$ 拿到了
  大概就是这样，很好理解：

	for(int i = n;i >= 1;--i){
        ll c = 0;
        ll sum1 = 0;
        for(int j = n;j >= 1;--j){
            if(i == j)continue;
            if(aa[i] > aa[j]){
                dp[i][j] = (1 + iv[c] * sum1) % MOD;		// iv[c] = 1 / c
            }else{
                c++;
                sum1 = (sum1 + dp[i][j]) % MOD;
            }
        }
    }

• 对于 $Alice$ 拿的情况，我们需要快速求出 ${\sum }_{\underset{a_k>a_j}{k>i}}dp[k][j]$
  因为我们的 $i$ 也是从 $n$ 倒序枚举到现在的，就默认满足了 $k>i$
  对于所有 $a_k>a_j$ 的情况，我们需要记录有多少次满足，以及 $dp[k][j]$ 的和
  这里 $j$ 有很多种值，那么我们干脆开一个数字 $cnt[j]、sum[j]$ 存对应满足的内容

    for(int i = n;i >= 1;--i){
        ll c = 0;
        ll sum1 = 0;
        for(int j = n;j >= 1;--j){
            if(i == j)continue;
            if(aa[i] > aa[j]){
                dp[i][j] = (1 + iv[c] * sum1) % MOD;
                cnt[j]++;
                sum[j] = (sum[j] + dp[i][j]) % MOD;
            }else{
                dp[i][j] = (1 + iv[cnt[j]] * sum[j]) % MOD;
                c++;
                sum1 = (sum1 + dp[i][j]) % MOD;
            }
        }
    }

• 稍微再修改一下，因为一开始开局不是两个人一下子选好的，是先 $Alice$ 选再 $Bob$ 选
  那我们 $Bob$ 的下标选到 $0$ 则表示 $Bob$ 还没开始选

    for(int i = n;i >= 1;--i){
        ll c = 0;
        ll sum1 = 0;
        for(int j = n;j >= 0;--j){
            if(i == j)continue;
            if(aa[i] > aa[j]){
                dp[i][j] = (1 + iv[c] * sum1) % MOD;
                cnt[j]++;
                sum[j] = (sum[j] + dp[i][j]) % MOD;
            }else{
                dp[i][j] = (1 + iv[cnt[j]] * sum[j]) % MOD;
                c++;
                sum1 = (sum1 + dp[i][j]) % MOD;
            }
        }
    }

• 最后答案是什么？就是所有开局情况的期望 除以 开局的情况数

	for(int i = 1;i <= n;++i){
        ans = (ans + dp[i][0]) % MOD;
    }
    ans = ans * iv[n] % MOD;

代码

• 时间复杂度：$O(N^2)$

#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
typedef long long ll;
void show(){std::cerr << endl;}template<typename T,typename... Args>void show(T x,Args... args){std::cerr << "[ " << x <<  " ] , ";show(args...);}

const int MAX = 5e3+50;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-5;


ll qpow(ll a,ll n){/* */ll res = 1LL;while(n){if(n&1)res=res*a%MOD;a=a*a%MOD;n>>=1;}return res;}
ll qpow(ll a,ll n,ll p){a%=p;ll res = 1LL;while(n){if(n&1)res=res*a%p;a=a*a%p;n>>=1;}return res;}
ll npow(ll a,ll n){/* */ll res = 1LL;while(n){if(n&1)res=res*a;a=a*a;n>>=1;if(res<0||a<0)return 0;}return res;}
ll inv(ll a){/* */return qpow(a,MOD-2);}
ll inv(ll a,ll p){return qpow(a,p-2,p);}

int aa[MAX];
ll dp[MAX][MAX];
ll iv[MAX];
ll sum[MAX],cnt[MAX];
int main()
{
    IOS;
    int n;cin >> n;
    for(int i = 1;i <= n;++i)cin >> aa[i],iv[i] = inv(i);
    iv[0] = 1;
    for(int i = n;i >= 1;--i){
        ll c = 0;
        ll sum1 = 0;
        for(int j = n;j >= 0;--j){
            if(i == j)continue;
            if(aa[i] > aa[j]){
                dp[i][j] = (1 + iv[c] * sum1) % MOD;
                cnt[j]++;
                sum[j] = (sum[j] + dp[i][j]) % MOD;
            }else{
                dp[i][j] = (1 + iv[cnt[j]] * sum[j]) % MOD;
                c++;
                sum1 = (sum1 + dp[i][j]) % MOD;
            }
        }
    }
    ll ans = 0;
    for(int i = 1;i <= n;++i){
        ans = (ans + dp[i][0]) % MOD;
    }
    ans = ans * iv[n] % MOD;
    cout << ans;
    return 0;
}
/**

*/