dp递推 口胡记录

[SHOI2013] 超级跳马

$tag$：矩阵乘法，前缀和

暴力$dp$很显然，设$f_{i,j}$为从$(1,1)$跳到$(i,j)$的方案数，那么有$f_{i,j}= \sum \limits _{j-(2k+1)>0}f _{i/i+1/i-1,j-(2k+1)}$

发现这个东西其实是一直由前面奇偶性相同的一段转移过来的，因此考虑前缀和优化

设$s_{i,j}=\sum \limits _{j-2k>0} f_{i,j-2k}$，那么由定义有$s_{i,j}=s_{i,j-2}+f_{i,j}$，然后我们再考虑$f$怎么由$s$转移而来，不难发现$f_{i,j}=s_{i-1,j-1}+s_{i,j-1}+s_{i+1,j-1}$，联立两式有$s_{i,j}=s_{i,j-2}+s_{i,j-1}+s_{i-1,j}+s_{i+1,j-1}$。

然后这个前缀和显然可以矩乘转移。

[JLOI2015] 有意义的字符串

不看题解连矩乘都想不到，/kk

发现$\frac{b+ \sqrt{d}}{2}$的形式和一元二次方程求根公式很像，进过构造可以发现它是方程$x^2-bx+\frac{b^2-d}{4}=0$的一个解。

移项后两边同时乘$x^{n-2}$有$x^n=bx^{n-1}-\frac{b^2-d}{4}x^{n-2}$。

发现这个已经形成了矩乘形式的递推关系，但是初始$\frac{b+ \sqrt{d}}{2}$是小数，不方便进行取模。

所以考虑构造$f(x)=(\frac{b+ \sqrt{d}}{2})^x+(\frac{b- \sqrt{d}}{2})^x$,将两个根$x1,x2$带入后两式相加发现有$f(i)=bf(i-1)-\frac{b^2-d}{4}f(i-2)$，并且有$f(0),f(1),b,\frac{b^2-d}{4}$都为整数。

因此可以直接矩乘计算出$f(n)$，再考虑减去$(\frac{b- \sqrt{d}}{2})^n$的贡献，发现这东西 $\in \left\{-1,1 \right\}$分类讨论$n$的奇偶性判断答案是否减一即可。

注意用__int128或者龟速乘。

[ABC219H] Candles

首先有经典的关灯模型，显然每次关灯都是在已选的区间向左或向右拓展一格。那么设$dp_{l,r,t,0/1}$为已选区间为$[l,r]$ ,时间为 $t$ ,在 $[l,r]$ 的左/右端点的蜡烛长度最大值。

但是时间这一维很大，考虑优化，一种比较套路的想法是先将所有蜡烛熄灭，然后时间倒流点燃，对于每个时刻，答案会损失点燃的长度非负蜡烛数。

因此每个蜡烛的贡献为$\max(0, a_i - t)$，这个式子不好维护。因为存在某些蜡烛最终贡献为0，考虑只记录有效的点。具体来说，设$dp_{l,r,k,0/1}$，其中$l,r,0/1$与前文的定义相同，$k$表示$[l,r]$区间外有$k$个点有效，会对答案造成贡献。然后就很好做了。

时间复杂度$O(n^3)$。

点击查看代码

#include <bits/stdc++.h>
 
#define ll long long
const int MAXN = 305;
ll dp[MAXN][MAXN][MAXN][2];
 
void solve() {
    int n;
    std::cin >> n;
    std::vector <std::pair<int, int> > a(n + 1);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i].first >> a[i].second;
    }
    a[n] = std::make_pair(0, 0);
 
    std::sort(a.begin(), a.end());
    int beg = -1;
    for (int i = 0; i < a.size(); i++) {
        if (a[i].second == 0) {
            beg = i;
            break;
        }
    } 
    
    const ll INF = 1e15;
    for (int i = 0 ; i <= n; i++) {
        for (int j = 0; j <= n; j++) {
            for (int k = 0; k <= n; k++) {
                dp[i][j][k][0] = dp[i][j][k][1] = -INF;
            }
        }
    }
 
    for (int i = 0; i <= n; i++) {
        dp[beg][beg][i][0] = dp[beg][beg][i][1] = 0;
    }
    for (int len = 2; len <= n + 1; len++) {
        for (int l = 0; l <= n; l++) {
            int r = l + len - 1;
            if (r > n) break;
            for (int k = 0; k <= n; k++) {
                ll x1 = -INF, x2 = -INF;
                x1 = std::max(dp[l + 1][r][k][0] - 1ll * (a[l + 1].first - a[l].first) * k, dp[l + 1][r][k][1] - 1ll * (a[r].first - a[l].first) * k);
                if (k != n) x2 = std::max(dp[l + 1][r][k + 1][0] - 1ll * (a[l + 1].first - a[l].first) * (k + 1) + a[l].second, dp[l + 1][r][k + 1][1] - 1ll * (a[r].first - a[l].first) * (k + 1) + a[l].second);
                dp[l][r][k][0] = std::max(x1, x2); 
 
                x1 = std::max(dp[l][r - 1][k][0] - 1ll * (a[r].first - a[l].first) * k, dp[l][r - 1][k][1] - 1ll * (a[r].first - a[r - 1].first) * k);
                if (k != n) x2 = std::max(dp[l][r - 1][k + 1][0] - 1ll * (a[r].first - a[l].first) * (k + 1) + a[r].second, dp[l][r - 1][k + 1][1] - 1ll * (a[r].first - a[r - 1].first) * (k + 1) + a[r].second);
                dp[l][r][k][1] = std::max(x1, x2);                 
            }
        }
    }
 
    ll ans = -INF;
    for (int l = 0; l <= n; l++) {
        for (int r = l; r <= n; r++) {
            for (int k = 0; k <= n; k++) {
                ans = std::max(ans, std::max(dp[l][r][k][0], dp[l][r][k][1]));
            }
        }
    }
 
    std::cout << ans << "\n";
}
 
int main() {
    std::ios::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
 
    int t = 1;
    while (t--) {
        solve();
    }
 
    return 0;
}

[AGC012E] Camel and Oases

首先由于每次跳跃时$v$的值都会除以2,所以只有$O(\log n)$个$v$值,不难想到固定一个$v$的值，可以算出每个点能向左/右拓展到的最远点，分别记为$l_i, r_i$。

然后发现如果我们将每个固定的$v$形成的若干个区间的集合看成一层，那么原问题等价于对于每个$i$在除了$v'=v$这一层中之后的每一层都选恰好一个区间，能否使得它们的并集为$[1,n]$，简称能为可达

那么显然如果$i$可达$[1,n]$,就有从$1$开始的前缀和从$n$开始的后缀能够覆盖$i$所在区间。考虑设$dpl_{mask}$为在状态为$mask$的层中选择了点能覆盖前缀的最大值,$dpr_{mask}$同理，很好转移。

对于每个$i$, 若$dpl_{mask}$ 与 $dpr_{mask2}$ 的交覆盖了$i$所在的区间 $(mask1 | mask2 = all)$,则这个区间是可行的。

复杂度$O(n \log v)$

扩张

一类形如 $dp_{mask} = (|mask| - |sub|) \times w(mask)$的转移方程的优化，$O(3 ^ n) -> O(2 ^ n \times n ^2)$

[ARC101E] Ribbons on Tree

三个月前做过，现在不会了，不像某位神仙两年前做过现在一眼秒了😅

比较navie的想法是设$dp{u,x}$为$u$的子树中有$x$个点未被覆盖，需要子树外一个点向内某个点相连的方案数，直接类似树背包转移有 $dp_{u,x + y - 2k} = \sum \limits_{v \in son(u), x +y > 0,k \leq min(x, y)} dp_{u, x} \times dp_{v,y} \times \binom{x}{k} \times \binom{y}{k} \times k!$。

系数过于复杂，不便于优化。看到每条边至少被覆盖一次考虑容斥。

考虑边集$S$中的边一次都没被覆盖过，这等价于删去这些边。此时整张图被分成了若干个联通块，显然每个联通块内部匹配的方案数是 $g(n) = \prod \limits _{2k \leq n, k \in N^*}{2k - 1}$，注意$n$为奇数时$g(n) = 0$。

数据范围无法枚举子集，考虑$dp$，重定义$dp_{u,x}$为以$u$为根的子树联通块大小为$x$的方案数（考虑容斥系数）。那么有这条边断掉 $dp_{u,x} \times dp_{v,y} \times{g(y)} \times -1 \rightarrow dp_{u,x}$ (断边集合大小加一)，保留这条边 $dp_{u,x} \times dp_{v,y} \rightarrow dp_{u, x +y}$。

最后答案即为 $\sum \limits_{i = 1} ^n dp_{1, i} \times g(i)$。复杂度为树形背包的 $O(n ^2)$。

点击查看代码

#include <bits/stdc++.h>
 
void solve() {
    int n;
    std::cin >> n;
    std::vector <std::vector<int> > adj(n + 1);
    for (int i = 1; i < n; i++) {
        int u, v;
        std::cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
 
    const int MOD = 1e9 + 7;
    std::vector <int> g(n + 1);
    g[0] = 1;
    for (int i = 2; i <= n; i += 2) g[i] = 1ll * g[i - 2] * (i - 1) % MOD; 
 
    std::vector <std::vector<int> > dp(n + 1);
    std::vector <int> siz(n + 1);
    for (int i = 0; i <= n; i++) dp[i].resize(n + 1);
    auto dfs = [&](auto self, int u, int fa) -> void {
        siz[u] = 1;
        dp[u][1] = 1;
        for (const auto &v : adj[u]) {
            if (v == fa) continue;
            self(self, v, u);
            std::vector <int> tmp(siz[u] + siz[v] + 1);
            for (int j = 1; j <= siz[u]; j++) {
                for (int k = 1; k <= siz[v]; k++) {
                    tmp[j] += -1ll * dp[u][j] * dp[v][k] % MOD * g[k] % MOD;
                    tmp[j] %= MOD; tmp[j] += MOD; tmp[j] %= MOD;
                    tmp[j + k] += 1ll * dp[u][j] * dp[v][k] % MOD;
                    tmp[j + k] %= MOD;
                }
            }
            siz[u] += siz[v];
            for (int i = 1; i <= siz[u]; i++) dp[u][i] = tmp[i];
        }
    };
    dfs(dfs, 1, 0);
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        ans += 1ll * dp[1][i] * g[i] % MOD;
        ans %= MOD;
    }
 
    std::cout << ans << "\n";
}
 
int main() {
    std::ios::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
 
    int t = 1;
    while (t--) {
        solve();
    }
 
    return 0;
}

「GLR-R3」惊蛰

tag:$dp$优化，线段树

暴力$dp$很显然，状态为设$dp_{i,j}$前$i$个$b$，其中最后一个数为$j$的最小答案，可以暴力 $O(nV^2)$转移。

发现可以前缀最小值优化，并且第二维的取值只可能是$a_i$，于是可以离散化优化到$O(n ^ 2)$。

设离散化后数组为$a'$，离散化数组为$lsh$，考虑变换$dp$状态，重定义$dp_{i,j}$为$lsh_j \leq b_i$时最小值（即原dp的后缀和）,那么$dp$转移过程为

发现这种形式可以用线段树维护。

具体来说，第一种转移直接区间加。第二种主要是区间加$lsh_j$打标记即可。主要难在保持$dp_i$的单调性。

但是又发现$lsh$与$dp_i$两个数组都是单调的，加完后$dp_{i,1} \rightarrow dp_{i,k}$，$dp_{i,k+1} \rightarrow dp_{i,n}$都是单调的。为了维护整个$dp_i$单调性，用第一部分的最小值，在线段树上二分出取$min$的影响区间，然后区间覆盖即可。

复杂度$O(n \log n)$。

点击查看代码

#include <bits/stdc++.h>
 
const int MAXN = 1e6 + 5;
 
template <class T>
void read(T &x) {
    x = 0; char c = getchar(); bool f = 0;
    while (!isdigit(c)) f = c == '-', c = getchar();
    while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
    x = f ? (-x) : x;
}
 
#define ll long long
 
int lsh[MAXN];
struct Sgt {
    struct Node {
        int l, r;
        ll mx;
        ll add, tag, addb;
    }t[MAXN * 8];
    void pushup(int p) {
        t[p].mx = std::max(t[p << 1].mx, t[p << 1 | 1].mx);
    }
    void pushadd(int p, ll tg) {
        t[p].mx += tg; t[p].add += tg;
    }
    void pushaddb(int p, ll tg) {
        t[p].mx += 1ll * lsh[t[p].l] * tg; t[p].addb += tg;
    }
    void pushtag(int p, ll tg) {
        t[p].mx = t[p].tag = tg;
        t[p].add = t[p].addb = 0;
    }
    void pushdown(int p) {
        if (t[p].tag != -1) {
            pushtag(p << 1, t[p].tag); pushtag(p << 1 | 1, t[p].tag);
            t[p].tag = -1;
        }
        if (t[p].add) {
            pushadd(p << 1, t[p].add); pushadd(p << 1 | 1, t[p].add);
            t[p].add = 0;
        }
        if (t[p].addb) {
            pushaddb(p << 1, t[p].addb); pushaddb(p << 1 | 1, t[p].addb);
            t[p].addb = 0;
        }
    }
    void build(int p, int l, int r) {
        t[p].l = l; t[p].r = r;
        t[p].tag = -1;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(p << 1, l, mid); build(p << 1 | 1, mid + 1, r);
    }
    void add(int p, int l, int r, ll delta) {
        if (l <= t[p].l && t[p].r <= r) {
            pushadd(p, delta);
            return;
        }
        if (t[p].l != t[p].r) pushdown(p);
        int mid = (t[p].l + t[p].r) >> 1;
        if (l <= mid) add(p << 1, l, r, delta);
        if (r > mid) add(p << 1 | 1, l, r, delta);
        pushup(p);
    }
    void addb(int p, int l, int r, ll delta) {
        if (l <= t[p].l && t[p].r <= r) {
            pushaddb(p, delta);
            return;
        }
        if (t[p].l != t[p].r) pushdown(p);
        int mid = (t[p].l + t[p].r) >> 1;
        if (l <= mid) addb(p << 1, l, r, delta);
        if (r > mid) addb(p << 1 | 1, l, r, delta);
        pushup(p);        
    }
    void assign(int p, int l, int r, ll v) {
        if (l <= t[p].l && t[p].r <= r) {
            pushtag(p, v);
            return;
        }
        if (t[p].l != t[p].r) pushdown(p);
        int mid = (t[p].l + t[p].r) >> 1;
        if (l <= mid) assign(p << 1, l, r, v);
        if (r > mid) assign(p << 1 | 1, l, r, v);
        pushup(p); 
    }
    ll query(int p, int pos) {
        if (t[p].l == t[p].r) {
            return t[p].mx;
        }
        if (t[p].l != t[p].r) pushdown(p);
        int mid = (t[p].l + t[p].r) >> 1;
        if (pos <= mid) return query(p << 1, pos);
        return query(p << 1 | 1, pos);
    }
    int binary(int p, ll x) {
        if (t[p].l != t[p].r) pushdown(p);
        if (t[p].mx < x) return -1;
        else if (t[p].l == t[p].r) return t[p].l;
        int mid = (t[p].l + t[p].r) >> 1;
        int ret = binary(p << 1 | 1, x);
        if (ret != -1) return ret;
        return binary(p << 1, x);
    }
    //last position i where dp[i] >= x
};
 
void solve() {
    int n, c;
    std::cin >> n >> c;
    std::vector <int> a(n + 1);
    for (int i = 1; i <= n; i++) {
        read(a[i]);
        lsh[i] = a[i];
    }
    std::sort(lsh + 1, lsh + 1 + n);
    int tot = std::unique(lsh + 1, lsh + 1 + n) - lsh - 1;
    for (int i = 1; i <= n; i++) {
        a[i] = std::lower_bound(lsh + 1, lsh + 1 + tot, a[i]) - lsh;
        a[i] = tot - a[i] + 1;
        // std::cerr << a[i] << " ";
    }
    // std::cerr << "\n";
    std::reverse(lsh + 1, lsh + 1 + tot);
 
    static Sgt t;
    t.build(1, 1, tot);
    for (int i = 1; i <= n; i++) {
        if (a[i] + 1 <= tot) t.add(1, a[i] + 1, tot, c);
        t.add(1, 1, a[i], -lsh[a[i]]);
        t.addb(1, 1, a[i], 1);
        ll val = t.query(1, a[i]);
        // std::cerr << "qwq" << "\n";
        int pos = t.binary(1, val);
        // int pos = tot;
        // std::cerr << "qaq" << "\n";
        if (pos != -1 && a[i] + 1 <= pos) t.assign(1, a[i] + 1, pos, val);
    }
 
    ll ans = 1e18;
    for (int i = 1; i <= tot; i++) ans = std::min(ans, t.query(1, i));
    std::cout << ans << "\n";
}
 
int main() {
    // freopen("wave.in", "r", stdin);
    // freopen("wave.out", "w", stdout);
    // std::ios::sync_with_stdio(0);
    // std::cin.tie(0);
    // std::cout.tie(0);
 
    int t = 1;
    while (t--) {
        solve();
    }
 
    return 0;
}