BZOJ2064 分裂

最新推荐文章于 2019-07-28 20:12:00 发布

Log_x

最新推荐文章于 2019-07-28 20:12:00 发布

阅读量309

点赞数 1

分类专栏： BZOJ 文章标签：状态压缩动态规划

本文链接：https://blog.csdn.net/bzjr_Log_x/article/details/81149240

版权

BZOJ 专栏收录该内容

58 篇文章 0 订阅

订阅专栏

Address

BZOJ2064

Solution

只可意会不可言传？不存在的。
但感觉这题解法很神，代码也很神。
可以知道操作次数的上界是 $n + m - 2$ 次（ $n - 1$ 次合并成一块后再分裂 $m - 1$ 次）。
考虑如果能把初始状态和目标状态分成和对应相等的两组，那么操作次数就变为 $n + m - 2 \times 2$ 次。
同样，如果能分为 $k$ 组，操作次数就变为 $n + m - 2k$ 次。
于是问题就转化为求 $k$ 的最大值。
注意到 $n_1, n_2$ 的范围很小，把初始状态和目标状态中的所有块压缩成一个 $20$ 位的二进制串，来表示它们选取的状态。
把目标状态中块的面积取反，则问题就被转化为选取尽量多面积和为 $0$ 的子集。
记状态 $i$ 的面积和为 $sum[i]$ ，则转移为 $sum[i] = sum[lowbit(i)] + sum[i - lowbit(i)]$ （其实任选两个 $i$ 的子集相加即可，这样写只是方便）。
记状态 $i$ 最多能选取的子集个数为 $f[i]$ ，则转移为 $f[i] = \max \limits ^ {n_1 + n_2}_{j = 1}\{f[i - 2^{j - 1}]\} + (sum[i] == 0)$ （这里并不需要枚举子集转移，因为 $i$ 的子集肯定被 $i - 2 ^ {j - 1}$ 的子集包含，之前已经转移过了）。
时间复杂度 $O(2 ^ {n_1 + n_2} \times (n_1 + n_2))$ 。

Code

#include <iostream>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <cstring>
#include <cstdlib>

using namespace std;

inline int get()
{
    char ch; int res = 0; bool flag = false;
    while (ch = getchar(), !isdigit(ch) && ch != '-');
    (ch == '-' ? flag = true : res = ch ^ 48);
    while (ch = getchar(), isdigit(ch))
        res = res * 10 + ch - 48;
    return flag ? -res : res;
}

inline void CkMax(int &x, int y)
{
    if (x < y) x = y;
}

const int N = 11e5 + 5;
int n, m, sum[N], f[N];

int main()
{
    n = get();
    for (int i = 0; i < n; ++i) sum[1 << i] = get();
    m = get();
    for (int i = 0; i < m; ++i) sum[1 << n + i - 1] = -get();

    n += m;
    const int C = 1 << n;
    for (int i = 1; i < C; ++i)
    {
        int tmp = i & -i;
        sum[i] = sum[tmp] + sum[i ^ tmp];
        for (int j = 0; j < n; ++j)
            if (1 << j & i) CkMax(f[i], f[1 << j ^ i]);
        if (!sum[i]) ++f[i];
    }
    printf("%d\n", n - (f[C - 1] << 1));
}