BZOJ4069 [APIO2015]巴厘岛的雕塑

Address

• 洛谷P3646 BZOJ4069

Solution

• 按照题意去做发现很不可做。
• 于是转化一下问题：
• 我们希望二进制的答案高位尽可能为0，这显然满足最小的性质。
• 因此贪心地按从高位到低位尽可能填0，判断我们用一个DP来处理。
• 假设我们现在处理第 $st$ 位，最多有 $ed$ 位，第 $st + 1$ ~ $ed$ 位的最优填取方案（已经处理完的）为 $ans$ ，定义bool数组 $f[i][j]$ 表示到第 $i$ 座雕塑为止，分成 $j$ 组能否使第 $st$ 位为0（能为 $true$）。
• $f[i][j]$ 的转移要满足：
  
  • 存在 $f[k][j - 1] = true(k < i)$。
  • 将第 $k + 1$ ~ $i$ 座雕塑的年龄和或入后，$ans$ 不改变（如果已经确定的几位改变了那么接下来无论怎么填显然都是不优的），并且第 $st$ 位为0。
• 那么只要存在 $f[n][j] = true(a \le j \le b)$，第 $st$ 位就能够为0，更新 $ans$。
• 这里要枚举 $st, i,j,k$，时间复杂度 $O(n^3\log \sum \limits_{i = 1}^n y_i)$ 。
• 然后发现最后一个子任务被卡……这时 $n \le 2000$。
• 注意到 $a = 1$，我们特判这种情况，把DP的 $j$ 这一维去掉，改为转移选取组数的最小值（选取组数尽量少在这里不会影响结果）。
• 这里只要枚举 $st, i, k$，时间复杂度 $O(n ^ 2 \log \sum \limits_{i = 1}^n y_i)$。

Code

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

using namespace std;

namespace INOUT
{
    const int S = 1 << 20;
    char frd[S], *hed = frd + S;
    const char *tal = hed;

    inline char nxtChar()
    {
        if (hed == tal)
            fread(frd, 1, S, stdin), hed = frd;
        return *hed++; 
    }

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

typedef long long ll;
const int M = 2005;
int n, a, b, ed; 
ll sum[M], Ans;

inline int Min(int x, int y) {return x < y ? x : y;}

namespace solve1
{
    const int N = 105;
    bool f[N][N];

    inline void work()
    {
        for (int st = ed; st; --st)
        {
            memset(f, false, sizeof(f));
            f[0][0] = true;

            for (int i = 1; i <= n; ++i)
                for (int j = 1, jm = Min(i, b); j <= jm; ++j)
                    for (int k = j - 1; k < i; ++k)
                        if (f[k][j - 1])
                        {
                            ll tmp = sum[i] - sum[k];
                            if ((tmp >> st | Ans) == Ans && !(1ll << st - 1 & tmp))
                            {
                                f[i][j] = true;
                                break;
                            }
                        }

            Ans <<= 1; bool flag = false;
            for (int j = a; j <= b; ++j)
                if (f[n][j]) 
                {
                    flag = true;
                    break;
                } 
            if (!flag) Ans |= 1;
        }

        cout << Ans;
    } 
};

namespace solve2
{
    const int Maxn = 0x3f3f3f3f;
    int g[M];

    inline void work()
    {
        for (int st = ed; st; --st)
        {
            memset(g, Maxn, sizeof(g));
            g[0] = 0;

            for (int i = 1; i <= n; ++i)
                for (int j = 0; j < i; ++j)
                    if (g[j] != Maxn)
                    {
                        ll tmp = sum[i] - sum[j];
                        if ((tmp >> st | Ans) == Ans && !(1ll << st - 1 & tmp))
                            g[i] = Min(g[i], g[j] + 1);
                    }

            Ans <<= 1;
            if (g[n] > b) Ans |= 1;
        }

        cout << Ans;
    }
};

int main()
{
    freopen("sculpture.in", "r", stdin);
    freopen("sculpture.out", "w", stdout);

    n = get(); a = get(); b = get();
    for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + get();
    for (ll i = sum[n]; i; i >>= 1) ++ed;

    if (a == 1) 
        solve2::work();
    else 
        solve1::work();

    fclose(stdin); fclose(stdout);
    return 0;
}