自动搬运

查看原文

来自洛谷，原作者为

	ღꦿ࿐ 一直游到海水变蓝

搬运于2025-08-24 22:47:28，当前版本为作者最后更新于2023-06-14 17:13:42，作者可能在搬运后再次修改，您可在原文处查看最新版

自动搬运只会搬运当前题目点赞数最高的题解，您可前往洛谷题解查看更多

以下是正文

upd:2023/9/20 补充了基于霍尔婚配定理的证明。

首先观察前面两档部分分，很显然——第一档直接背包，第二档给我们一个思想就是基于桶去找饼干，直接贪心地选数量尽可能多的饼干种类就行，正确性显然。

也就是说我们找到一组确定的尽可能少的桶后直接贪心地选择饼干就行了。

接下来问题是 如何找到一组合法的桶。

最大的桶 $C_1$ 需要被所有不同的饼干装满，需要 至少有 $C_1$ 种不同的饼干。

次大的桶 $C_2$ 需要被所有不同的饼干装满，需要在装满 $C_1$ 后至少有 $C_2$ 种不同的饼干，而有两块或更多的饼干可以同时用于装两个桶。

再次大的桶 $C_3$ 需要被所有不同的饼干装满，需要在装满 $C_1,C_2$ 后至少有 $C_3$ 种不同的饼干，而有两块的饼干可以同时用于装两个桶，有三块或更多的饼干可以拿来同时装三个桶。

……

这个条件显然是必要的。其充分性可以归纳证明，也可以使用霍尔定理证明：

构造一个二分图，每个左部点是桶，右边是饼干，每个左部点向右边连一条容量为 $1$ 的边，使用霍尔定理，对于集合 $S$ 能匹配 $f(S)=\sum \min\{a_i,j\}$，右侧的 $a_i$ 每个就可以匹配不超过 $k$ 个，所以 $f(S)$ 的大小只和 $|S|$ 相关，所以对于每个 $k$，选择前 $k$ 大的 $C_i$ 作为 $S$ 中的左部点，那么就有了上面的式子。

取上界 $\sum_{i=1}^j C_i=cir_i$。

现在就变成了，从大到小选 尽可能少的桶，使得前 $i$ 大的和不超过 $cir_i$，且和为 $n$。

首先有 $n^3$ 的 dp，让 $f_{i,j,k}$ 表示前 $i$ 大的桶，目前选了 $j$ 个，和为 $k$ 是否可行。

转移就枚举这个桶是否选，个数从小到大做完全背包即可。

考虑优化，因为是前 $j$ 大的桶，所以 $siz_i \times j \leq \sum_{x_\leq j} C_x \leq m$，故有 $siz_i \times j \leq m$，所以第二维只用开到 $\frac m {siz_i}$，复杂度是调和级数 $O(n^2\log n)$。

注意到 dp 值是 boolean 的，所以可以压位，时空均为 $O(\frac {n^2\log n}w)$，空间约 400M 可以通过。

代码

/*
君は瞬きと共に過ぎてく時間も
遠くから見てると微笑んで
 */
/*author::ღꦿ࿐(DeepSea.) */
const int N = 15002 ;
int n , a[N + 10] , b[N + 10] , m;
int cir[N + 10] ;
int val[N + 10] ;
int cnt[N + 10] , sum[N + 10] ; 
using state = bitset<N + 2>;
vector < state > dp[N + 2] ;
bitset<N + 2> px[N + 2];
vi C;
void go(int i,int j,int s) {
    if(i == 1) {
        C.emplace_back(j) ;
        return ;
    }
    for(int pre = 1 ; pre <= m && b[pre] * (i - 1) <= N ; ++ pre) {
        if(b[pre] >= j && dp[i - 1][b[pre]][s - j]) {go(i - 1,b[pre],s - j) ; C.emplace_back(j); return ;}   
    }
}
signed main()
{
    read(n) ;
    rep(i,1,n) read(a[i]) , cnt[a[i] + 1] ++ , sum[a[i] + 1] += a[i]; 
    read(m);
    rep(i,1,m) read(b[i]);
    int c = n , s = 0;
    rep(i,1,N) {
        c -= cnt[i] ;
        s += sum[i] ;
        cir[i] = c * i + s ;
    }
    rep(i,1,N) dp[i].resize(N / i + 2);
    rep(i,1,m) {
        if(b[i] <= cir[1]) dp[1][b[i]][b[i]] = 1 ;
    }
    px[0][0] = 1;
    rep(i,1,N) px[i] = px[i - 1] << 1 , px[i][0] = 1 ;
    int ptr = m ;
    rep(i,1,N - 1) {
        state s ;
        while(i * b[ptr] > N) ptr -- ;
        for(int j = ptr ; j >= 1 ; -- j) {
            s |= dp[i][b[j]] ; 
            if((i + 1) * b[j] <= N) {
                dp[i + 1][b[j]] |= s << b[j] ;
                dp[i + 1][b[j]] &= px[cir[i + 1]];
            } 
        }
    }

    rep(i,1,N) {
        for(int j = 1 ; j <= m && b[j] * i <= N ; ++ j) {
            if(dp[i][b[j]][s]) {
                go(i,b[j],s); 
                goto Construct;
            }
        }
    }       

    puts("-1") ;
    exit(0) ;

    Construct:{
        priority_queue< pi > h ;
        vector<vi> ans;
        rep(i,1,n) h.emplace(a[i] , i);
        for(int p:C) {
            vector< pi > tmp ;
            vi ths;
            while(p -- ) {
                auto [c,num] = h.top( ) ;h.pop( );
                if(c > 1) tmp.emplace_back(c - 1 , num);
                ths.emplace_back(num) ;
            }
            ans.emplace_back(ths);
            for(auto x:tmp) h.push(x);
        }
        wrt( C.size( ) , '\n');
        for(auto vec:ans) {
            wrt(vec.size( ) , ' ');
            wrt(vec, ' ') ;
            nxtl;
        }
        exit(0) ; 
    }

    return 0;   
}