CF1716E（分治，最大子段和，dp）

CF1716E（分治，最大子段和，dp）

题意

给一个序列 $a$ ，长 $2^n$。

现在有 $q$ 次询问，每次给出一个 $k$ 。之后要将 $a$ 中 $a_i$ 和 $a_{i+2^{k}}$ 交换，每个元素最大进行一次交换，$i+2^k>n$ 时不进行交换。

输出操作后 $a$ 的最大子段和。

每次操作 不独立。

思路

首先，得有一个前置知识，分治法求最大子段和。

通过维护一段子区间的 $ls,s,rs,sum$ （分别是前缀最大和，最大子段和，后缀最大和，区间和）。可以 $pushup$ 合并出区间答案。

---

1. 两次操作会相互抵消，并且与操作顺序无关。

因此，所有的答案可能一共就 $2^n$ 种可能。我们用一串 $n$ 位01串表示操作。

最暴力的解法就是对每种状态dfs一遍搜出答案，单次复杂度 $O(2^n)$ ，会T。

2. 该序列可以建立一棵完全二叉树，某一位的操作相当于交换这棵树某层的左右子树，而不会影响上层。

可以发现，这保证了 无后效性，考虑dp处理答案。

定义 $f[i][j]$ 表示以 $i$ 为根，$i$ 位于第 $m$ 层，考虑操作序列低 $m$ 位为 $j$ 的答案。于是 $f[1][j]$ 就是答案。

考虑转移，设 $i$ 的左右儿子为 $lc,rc$ 。

如果第 $m+1$ 层不换

$$f[i][j]=f[lc][j]\oplus f[rc][j]$$

如果交换

$$f[i][j]=f[rc][j] \oplus f[lc][j]$$

其中 $\oplus$ 是结点合并:

struct Node {
        int ls, s, rs, sum;
        Node operator+(const Node& rv) const {
            return {max(ls,sum + rv.ls),
            max({s,rv.s,rs + rv.ls}),
            max(rv.rs,rs + rv.sum),
            sum + rv.sum};
        }
    };

于是，我们做一个树dp就可以预处理出答案。时间复杂度 $O(n*2^n)$

最后一问题是空间开销太大，将 $f[i][j]$ 的第一维压掉用一个滚动数组即可。在递归上的实现方式是递归返回vector，具体看代码。

#include<bits/stdc++.h>
#define yes puts("yes");
#define inf 0x3f3f3f3f
#define ll long long
#define linf 0x3f3f3f3f3f3f3f3fll
#define ull unsigned long long
#define endl '\n'
#define int long long
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
using namespace std;
mt19937 mrand(random_device{}());
int rnd(int x) { return mrand() % x;}
using PII = array<int,2>;
const int MAXN =10 + 2e5 ,mod=1e9 + 7;

void solve()
{    
    int n; cin >> n;
    n = 1 << n;
    vector<int>a(n + 1);
    for(int i = 1;i <= n;i += 1)
        cin >> a[i];
    
    struct Node {
        int ls, s, rs, sum;
        Node operator+(const Node& rv) const {
            return {max(ls,sum + rv.ls),
            max({s,rv.s,rs + rv.ls}),
            max(rv.rs,rs + rv.sum),
            sum + rv.sum};
        }
    };

    function<vector<Node>(int,int)> dfs = [&](int l,int r) {
        if(l == r) {
            return vector<Node>{{a[l],a[l],a[l],a[l]}};
        }
        int mid = l + r >> 1;
        auto resL = dfs(l,mid);
        auto resR = dfs(mid + 1,r);

        int k = 2 * resL.size();
        vector<Node> res(k);
        for(int i = 0;i < resL.size();i += 1) {
            res[i] = resL[i] + resR[i];
            res[i + k / 2] = resR[i] + resL[i];
        }
        return res;
    };

    auto ans = dfs(1,n);

    int q, idx = 0; cin >> q;
    while(q --) {
        int t; cin >> t;
        idx ^= (1 << t);
        cout << max(0ll, ans[idx].s) << endl;
    }

}
signed main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

    //int T;cin>>T;
    //while(T--)
        solve();

    return 0;
}