Codeforces Gym 101623E English Restaurant

题目传送门

　　传送门

题目大意

　　餐厅有$n$张桌子，第$i$张桌子可以容纳$c_i$个人，有$t$组客人，每组客人的人数等概率是$[1, g]$中的整数。

　　每来一组人数为$x$客人，餐厅如果能找到最小的$c_j$使得$c_j geqslant x$，那么就会把这张桌子分配给这些客人，并得到$x$的收益。

　　问期望的收益。

　　好像可以枚举每一种人数，然后算一下，但时间复杂度很爆炸。

　　先添加若干个容量为$infty$的桌子。这样每组人一定能够分配到一张桌子，只是可能没有收益。

　　考虑最后答案一定是将桌子排序后，若干段连续的桌子被占用。

　　用$f_{l, r}$表示恰好$[l, r]$这段桌子被占用的所有方案的收益总和和方案数。每次转移考虑枚举最后一组人来的时候占用的桌子，假如它是$mid$，那么最后一组人可行的人数是$(c_{l - 1}, c_{mid}]$。

　　然后做一个背包，$h_{i, j}$表示考虑到在时刻$i$及其之后来的人，被占用的最靠左的左端点是$j$，所有方案的收益总和和方案数。转移的时候枚举这一段的长度，以及前一段的区间的左端点，注意两个区间不能相交。后者用一个后缀和优化掉。

　　注意每组人是带标号的，所以合并两个方案的时候还需要分配标号。

Code

/**
 * Codeforces
 * Gym#101623E
 * Accepted
 * Time: 46ms
 * Memory: 2600k
 */
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
using namespace std;
typedef bool boolean;

typedef long double ld;
typedef pair<ld, ld> pdd;

pdd operator + (const pdd& a, const pdd& b) {
    return pdd(a.first + b.first, a.second + b.second);
}

pdd operator * (const pdd& a, const pdd& b) {
    return pdd(a.first * b.second + a.second * b.first, a.second * b.second);
}

pdd operator * (const pdd& a, ld x) {
    return pdd(a.first * x, a.second * x);
}

ld nature_sum(int x) {
    return x * (x + 1) >> 1;
}

const int N = 105;

int n, g, t;
vector<int> c;
ld C[N << 1][N << 1];
pdd f[N << 1][N << 1], h[N][N << 1], s[N][N << 1];

inline void init() {
    scanf("%d%d%d", &n, &g, &t);
    c.resize(n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &c[i]);
        c[i] = min(c[i], g);
    }
    for (int i = 0; i < t; i++)
        c.push_back(g + 1);
    sort(c.begin(), c.end());
    n = c.size();
}

inline void solve() {
    C[0][0] = 1;
    for (int i = 1; i <= n; i++) {
        C[i][0] = C[i][i] = 1;
        for (int j = 1; j < i; j++)
            C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
    }

    for (int r = 0; r < n; r++)
        for (int l = r; ~l; l--) {
            for (int mid = l; mid <= r; mid++) {
                pdd val; //(0, 1);//C[r - l][r - mid]);
                if (c[mid] > g)
                    val = pdd(0, g - ((l) ? (min(c[l - 1], g)) : (0)));
                else
                    val = pdd(nature_sum(c[mid]) - ((l) ? (nature_sum(c[l - 1])) : (0)), c[mid] - ((l) ? (c[l - 1]) : (0)));
                pdd vall = (mid > l) ? (f[l][mid - 1] * C[r - l][r - mid]) : (pdd(0, 1));
                pdd valr = (mid < r) ? (f[mid + 1][r]) : (pdd(0, 1));
                f[l][r] = f[l][r] + (vall * val * valr);
            }
//            cerr << l << " " << r << " " << f[l][r].first << " " << f[l][r].second << '
';
        }

    for (int i = 0; i < t; i++)
        for (int j = 0; j < n - t + i + 1; j++)
            h[i][j] = f[j][j + t - i - 1];
    for (int i = t; i--; ) {
        int all = t - i;
        for (int j = 0; j + all < n; j++) {
            for (int k = i + 1; k < t; k++) {
                int put = k - i;
//                cerr << i << " " << j << " " << k << " " << all << " " << put << '
';
                ld comb = C[all][put];
                h[i][j] = h[i][j] + (f[j][j + put - 1] * comb * s[k][j + put + 1]);
            }
//            cerr << i << " " << j << " " << h[i][j].first << " " << h[i][j].second << '
';
        }
        s[i][n - 1] = h[i][n - 1];
        for (int j = n - 2; j >= 0; j--)
            s[i][j] = s[i][j + 1] + h[i][j];
    }
    pdd ans(0, 0);
    for (int i = 0; i < n; i++)
        ans = ans + h[0][i];
//    cout << (ans.first / ans.second) << '
';
    double E = ans.first / ans.second;
    printf("%.9lf", E);
}

int main() {
    init();
    solve();
    return 0;
}