传送门
题意：\(a_i\)在\([l_i,r_i]\)等概率取，问\(a_{1\cdots n}\)不递增的概率，对\(998244353\)取模。（\(1 \leqslant n \leqslant 50, 1 \leqslant l_i \leqslant r_i < 998244353\)）
可以先求方案数，然后除以\(\prod\limits_{i=1}^n (r_i-l_i+1)\).如果直接令\(dp[i][j]\)表示第\(i\)个数选\(j\)时的方案数，显然会超时。因为\(n\)个区间最多会划分出\(2n-1\)个不相交的区间，考虑到\(n\)很小，可以从这方面入手。
先把所有区间右端点+1，处理成\(2n-1\)个左闭右开的区间。令\(dp[i][j]\)表示第\(i\)个数选择第\(j\)个区间中的某个数时合法序列的方案数。那么只要枚举他和前面多少个数选择同一个区间\(j\)即可。那么从区间\(I\)中选择\(a\)个数，使其构成不递增序列的方案数，实际上就是隔板法，而隔板法的含义就是从\(I\)中随便选出\(a\)个数的方案数，即\(\binom{|I|+a-1}{a}\)，那么就有dp转移方程：
\[dp[i][j] = \sum\limits_{k < i, t > j} dp[k][t] * \binom{|I_j|+i-k-1}{i - k}
\]
关于组合数，虽然\(|I_j|\)会很大，单次需要\(O(n)\)算，但是从\(k\)转移到\(k-1\)是有规律的，可以动态求。所以这样转移时间复杂度是\(O(n^4 \log n)\)的（有个快速幂的\(\log n\)，应该也可以优化），再用后缀和可以优化到\(O(n^3\log n)\).
#include<bits/stdc++.h>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 55;
const ll mod = 998244353;
In ll read()
{
ll ans = 0;
char ch = getchar(), las = ' ';
while(!isdigit(ch)) las = ch, ch = getchar();
while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
if(las == '-') ans = -ans;
return ans;
}
In void write(ll x)
{
if(x < 0) x = -x, putchar('-');
if(x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
In ll ADD(ll a, ll b) {return a + b < mod ? a + b : a + b - mod;}
In ll quickpow(ll a, ll b)
{
ll ret = 1;
for(; b; b >>= 1, a = a * a % mod)
if(b & 1) ret = ret * a % mod;
return ret;
}
int n;
struct Node {int L, R;}t[maxn];
int li[maxn << 1], _n = 0;
ll dp[maxn][maxn << 1], sum[maxn][maxn << 1];
int main()
{
n = read();
for(int i = 1; i <= n; ++i)
{
int L = read(), R = read() + 1;
li[++_n] = L, li[++_n] = R;
t[i] = (Node){L, R};
}
sort(li + 1, li + _n + 1);
_n = unique(li + 1, li + _n + 1) - li - 1;
fill_n(sum[0], _n + 1, 1);
t[0].L = 0, t[0].R = _n;
for(int i = 1; i <= n; ++i)
{
t[i].L = lower_bound(li + 1, li + _n + 1, t[i].L) - li;
t[i].R = lower_bound(li + 1, li + _n + 1, t[i].R) - li;
for(int j = t[i].L; j < t[i].R; ++j)
{
ll c = li[j + 1] - li[j]; ll len = c;
for(int k = i - 1; k >= 0; --k)
{
if(t[k + 1].L > j || t[k + 1].R <= j) break; //第k+1个区间可能不包含当前枚举的区间
dp[i][j] = ADD(dp[i][j], sum[k][j + 1] * c % mod);
c = c * (len + i - k) % mod * quickpow(i - k + 1, mod - 2) % mod;
}
}
for(int j = _n; j; --j) sum[i][j] = ADD(sum[i][j + 1], dp[i][j]);
}
ll ans = sum[n][1];
for(int i = 1; i <= n; ++i) ans = ans * quickpow(li[t[i].R] - li[t[i].L], mod - 2) % mod;
write(ans), enter;
return 0;
}