动态规划优化 习题总结 1

动态规划优化 习题总结

《算法竞赛进阶指南》中的例题与练习题。

排名 - L5-2022-A2-动态规划优化 - 码创未来

*A. P1081 [NOIP2012 提高组] 开车旅行（倍增优化 DP）

洛谷 P1081 | AcWing 293 | 码创未来

题意

小 A 和小 B 开车去东西排列的连续 $n$ 座城市旅行，城市自西向东编号依次为 $1$ 到 $n$，已知各个城市的海拔高度互不相同，记城市 $i$ 的海拔高度为 $h_i$，则城市 $i$ 和城市 $j$ 之间的距离 $d_{i,j}=|h_i-h_j|$。

旅行过程中，小 A 和小 B 轮流开车，第一天小 A 开车，之后每天轮换一次。他们计划选择一个城市 $s$ 作为起点，一直向东行驶，并且最多行驶 $x$ 公里就结束旅行。

小 A 和小 B 的驾驶风格不同，小 B 总是沿着前进方向选择一个最近的城市作为目的地，而小 A 总是沿着前进方向选择第二近的城市作为目的地（注意：本题中如果当前城市到两个城市的距离相同，则认为离海拔低的那个城市更近）。如果其中任何一人无法按照自己的原则选择目的城市，或者到达目的地会使行驶的总距离超出 $x$ 公里，他们就会结束旅行。

在启程之前，小 A 想知道两个问题：

1. 对于一个给定的 $x=x_0$，从哪一个城市出发，小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值最小（如果小 B 的行驶路程为 $0$，此时的比值可视为无穷大，且两个无穷大视为相等）。如果从多个城市出发，小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值都最小，则输出海拔最高的那个城市。

2. 对任意给定的 $x=x_i$ 和出发城市 $s_i$，小 A 开车行驶的路程总数以及小 B 行驶的路程总数。

对于 $100\mathrm{\%}$ 的数据：$1\le n,m\le {10}^5$，$-{10}^9\le h_i\le {10}^9$，$1\le s_i\le n$，$0\le x_i\le {10}^9$ 。

数据保证 $h_i$ 互不相同。

思路

本题有三个关键信息：所在城市、行驶天数、A 和 B 行驶的总距离。

由出发城市和天数我们可以知道现在所在的城市，以及当前谁在开车，并且可以算出两人分别和总共行驶的距离。

天数是一个连续的阶段，我们可以用倍增来优化。还需要设一维状态表示谁先开车，因为中间过程中不一定是 A 先开车。

• 设 $f(i,j,k)$ 表示从城市 $j$ 出发，一共行驶了 $2^i$ 天，出发时 $k$ 先开车，最终能到达的城市，其中 $k\in \{0,1\}$，$k=0$ 表示 A 先开车，$k=1$ 表示 B 先开车。

  对于初值 $f(0,j,k)$，我们可以暴力处理出来。

  设 $ga(j)$ 和 $gb(j)$ 分别表示 A 和 B 从 $j$ 出发到达的下一个城市，$i\in [j+1,n]$，那么 $gb(j)$ 即是令 $d_{i,j}$ 取得最小值的 $i$，$ga(j)$ 即是令 $d_{i,j}$ 取得次小值的的 $i$。（注意 A 对应次小值，B 对应最小值。。。）

  我们从后往前遍历城市 $j$，将 $h_j$ 插入一个 std::multiset 即平衡树，这样已经在平衡树中的城市范围为 $[j,n]$，那么从当前城市 $j$ 向前遍历两个、向后遍历两个城市并比较距离即可得出最近城市和第二近城市。具体实现可以参考代码。

  于是 $f(0,j,0)=ga(j),f(0,j,1)=gb(j)$。根据倍增的思想，并且特殊考虑 $i=1$ 的情况（一共 $2$ 天，第一天 $k$ 开车，第二天 $k\mathrm{xor}1$ 开车），得出状态转移方程。

  $$f(i,j,k)=\{\begin{array}{ll}f(i-1,f(i-1,j,k),k\mathrm{xor}1)& k=1\\ f(i-1,f(i-1,j,k),k)& k\ne 1\end{array}i\ge 1,1\le j\le n,k\in \{0,1\}.$$

• 接下来处理 A 和 B 行驶的距离。我们设 $da(i,j,k)$ 和 $db(i,j,k)$ 分别表示从城市 $j$ 出发，一共行驶了 $2^i$ 天，出发时 $k$ 先开车，A 和 B 行驶的总距离。

  初值 $da(0,j,0)=d_{j,ga(j)},da(0,j,1)=0$；$db(0,j,0)=0,db(0,j,1)=d_{j,gb(j)}$。

  同样根据倍增思想，利用之前处理出的 $f$ 数组，写出状态转移方程。

  $$\begin{gathered} da(i,j,k)=\{\begin{array}{ll}da(i-1,j,k)+da(i-1,f(i-1,j,k),k\mathrm{xor}1)& k=1\\ da(i-1,j,k)+da(i-1,f(i-1,j,k),k)& k\ne 1\end{array} \\ db(i,j,k)=\{\begin{array}{ll}db(i-1,j,k)+db(i-1,f(i-1,j,k),k\mathrm{xor}1)& k=1\\ db(i-1,j,k)+db(i-1,f(i-1,j,k),k)& k\ne 1\end{array} \\ i\ge 1,1\le j\le n,k\in \{0,1\}. \end{gathered}$$

• 预处理出天数的二进制每一位的状态之后，我们来考虑一般性的问题。

  设 $calc(s,x)$ 表示从城市 $s$ 出发，最多行驶 $x$ 公里，A 和 B 行驶的路程。显然这个函数是一个二元组。

  根据二进制拆分的思想，我们递减枚举 $2$ 的 $i$ 次幂，累加到行驶的天数里。

  具体来说，我们设所在城市为 $p$，A 和 B 行驶的路程分别为 $la$ 和 $lb$。开始时 $p=s,la=lb=0$。然后倒序循环枚举 $2$ 的幂次 $i$，${\log }_2(n)\ge i\ge 0$。如果 $la+lb+da(i,p,0)+db(i,p,0)\le x$，说明可以继续行驶 $2^i$ 天，于是我们更新数值，令 $la\leftarrow la+da(i,p,0),lb\leftarrow lb+db(i,p,0),p\leftarrow f(i,p,0)$。

  循环结束后，所得的 $la,lb$ 即为答案。

• 有了 $calc(s,x)$ 函数，我们就可以解决题目中提出的问题了。

  1. 枚举 $s$，打擂台求出 $\arg min\{calc(s,x_0)\}$；
  2. 多次询问 $calc(s_i,x_i)$。

代码

点击查看代码

#include <iostream>
#include <cstdio>
#include <cmath>
#include <set>
#include <algorithm>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
#define g(x, y, z) for (int x = (y); (x) >= (z); --(x))
#define int long long
using namespace std;
typedef pair<int, int> pii;
const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f3f3f3f3f;
int n, m, l, ga, gb, f[20][N][2], da[20][N][2], db[20][N][2];

struct City {
    int id, h;
    City() {}
    City(int _id, int _h): id(_id), h(_h) {}
    bool operator<(City const &o) const {
        return h < o.h;
    }
} a[N], tmp[4];
multiset<City> myset;

inline bool cmp(City const &p, City const &q) {
    return p.h == q.h ? a[p.id].h < a[q.id].h : p.h < q.h;
}

pii calc(int s, int x) {
    int p = s;
    int la = 0, lb = 0;
    g(i, l, 0) {
        if (f[i][p][0] && la + lb + da[i][p][0] + db[i][p][0] <= x) {
            la += da[i][p][0];
            lb += db[i][p][0];
            p = f[i][p][0];
        }
    }
    return (pii){la, lb};
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    cin >> n;
    l = log2(n);
    f(i, 1, n) cin >> a[i].h, a[i].id = i;
    myset.insert(City(0, INF)), myset.insert(City(0, INF));
    myset.insert(City(n + 1, -INF)), myset.insert(City(n + 1, -INF));
    g(i, n, 1) {
        auto it = myset.insert(a[i]); //insert()函数返回值正是刚刚插入的值的迭代器(这样就不用find()函数了)
        auto it1 = ++it, it2 = ++it, it3 = --(--(--it)), it4 = --it; //移动std::multiset<>::iterator只能用++和--
        tmp[0] = City((*it1).id, (*it1).h - a[i].h), tmp[1] = City((*it2).id, (*it2).h - a[i].h); //*iterator表示引用迭代器所
        tmp[2] = City((*it3).id, a[i].h - (*it3).h), tmp[3] = City((*it4).id, a[i].h - (*it4).h); //指向的元素, 也可以用it->h
        sort(tmp, tmp + 4, cmp);
        gb = tmp[0].id, ga = tmp[1].id;
        f[0][i][0] = ga, f[0][i][1] = gb;
        da[0][i][0] = abs(a[i].h - a[ga].h), db[0][i][1] = abs(a[i].h - a[gb].h);
    }
    f(j, 1, n) f(k, 0, 1) { //i=1
        f[1][j][k] = f[0][f[0][j][k]][k^1];
        da[1][j][k] = da[0][j][k] + da[0][f[0][j][k]][k^1];
        db[1][j][k] = db[0][j][k] + db[0][f[0][j][k]][k^1];
    }
    f(i, 2, l) f(j, 1, n) f(k, 0, 1) { //i>1
        f[i][j][k] = f[i-1][f[i-1][j][k]][k];
        da[i][j][k] = da[i-1][j][k] + da[i-1][f[i-1][j][k]][k];
        db[i][j][k] = db[i-1][j][k] + db[i-1][f[i-1][j][k]][k];
    }
    int s = 0, x;
    cin >> x;
    double minn = INF;
    f(i, 1, n) {
        pii tmp = calc(i, x);
        double sum = tmp.second == 0 ? INF : ((double)tmp.first / (double)tmp.second);
        if (sum < minn) minn = sum, s = i;
        else if (sum == minn && a[i].h > a[s].h) s = i;
    }
    cout << s << '\n';
    cin >> m;
    f(i, 1, m) {
        cin >> s >> x;
        pii tmp = calc(s, x);
        cout << tmp.first << ' ' << tmp.second << '\n';
    }
    
    return 0;
}

*B. Count The Repetitions（倍增优化 DP）

AcWing 294 | 码创未来

题意

定义 $conn(s,n)$ 为 $n$ 个字符串 $s$ 首尾相接形成的字符串，例如 $conn(\mathtt{\text{abc}},2)=\mathtt{\text{abcabc}}$。

称字符串 $a$ 能由字符串 $b$ 生成，当且仅当从字符串 $b$ 中删除某些字符后可以得到字符串 $a$。

例如 $\mathtt{\text{abdbec}}$ 可以生成 $\mathtt{\text{abc}}$，但是 $\mathtt{\text{acbbe}}$ 不能生成 $\mathtt{\text{abc}}$。

给定两个字符串 $s_1$ 和 $s_2$，以及两个整数 $n_1$ 和 $n_2$，求一个最大的整数 $m$，满足 $conn(conn(s_2,n_2),m)$ 能由 $conn(s_1,n_1)$ 生成。

$|s_1|,|s_2|\le 100$，$n_1,n_2\le {10}^6$。其中 $|str|$ 表示字符串 $str$ 的长度。

（注意先输入 $s_2,n_2$ 再输入 $s_1,n_1$。。。）

思路

首先发现 $conn(conn(s_2,n_2),m)=conn(s_2,n_2\times m)$。

所以我们求的其实是最大的 $m^{\prime }=n_2\times m$，满足 $conn(s_2,m^{\prime })$ 是 $conn(s_1,n_1)$ 的一个子序列（不一定连续）。

注意到 $m^{\prime }$ 的上界很大，为 ${\displaystyle \frac{|s_1|\times n_1}{|s_2|}}$，于是我们考虑二进制拆分的思想。设 $l={\log }_2\left({\displaystyle \frac{|s_1|\times n_1}{|s_2|}}\right)$，表示 $m^{\prime }$ 的二进制最多有多少位。

令 $m^{\prime }=2^{p_1}+2^{p_2}+\cdots +2^{p_k}$，把 $conn(s_2,m^{\prime })$ 看做由 $conn(s_2,2^{p_1}),conn(s_2,2^{p_2}),\dots ,conn(s_2,2^{p_k})$ 拼接而成，其中 $p_i\le l$。

最后统计答案的时候，用尽量大的 $2^{p_i}$ 在所用若干个 $s_1$ 总长度不超过 $|s_1|\times n_1$ 的情况下拼成 $m^{\prime }$。

考虑每一个 $conn(s_2,2^j)$。由于 $conn(s_1,n_1)$ 是由很多个 $s_1$ 重复拼接而成的，我们不妨设想一个字符串 $s_1^{\prime }=conn(s_1,+\mathrm{\infty })$，即令 $s_1$ 重复无数次。

由于所用的 $s_1^{\prime }$ 长度与开始匹配的起点 $i$ 和 $s_2$ 的重复次数 $j$ 有关，我们设 $f(i,j)$ 表示从 $s_1^{\prime }[i]$ 开始，要想生成 $conn(s_2,2^j)$，需要用 $s_1^{\prime }$ 的最小连续长度。

即用 $s_1^{\prime }[i..i+f(i,j)-1]$ 能够生成 $conn(s_2,2^j)$ 的最小 $f(i,j)$。

在 $s_1^{\prime }$ 中，从第 $i$ 位开始和从第 $i+k|s_1|$ 位开始是等效的，所以 $f(i,j)$ 中 $i\in [0,|s_1|)$。

考虑倍增的思想，我们先用尽量短的 $s_1^{\prime }$ 生成 $conn(s_2,2^{j-1})$，再从当前位置开始用尽量短的 $s_1^{\prime }$ 生成另一个 $conn(s_2,2^{j-1})$。

$$f(i,j)=f(i,j-1)+f[(i+f(i,j-1))mod|s_1|,j-1].$$

初值 $f(i,0)$ 可以暴力匹配 $s_1^{\prime }$ 和 $s_2$ 处理。

接下来对 DP 的阶段 $j$ 进行拼接。

第一步，枚举起始位置 $i\in [0,|s_1|)$；

第二步，用 $p$ 记录当前位置，开始时 $p=i$，从 $l$ 到 $0$ 倒序循环枚举 $j$，如果当前的 $conn(s_1,n_1)$ 足够生成 $conn(s_2,2^j)$，即 $p+f(pmod|s_1|,j)\le |s_1|\times n_1$，那么累加答案，并且改变当前位置，即令 $p\leftarrow p+f(pmod|s_1|,j)$，直到无法再生成；

第三步，打擂台更新答案，枚举下一个 $i$。

最后别忘了将答案除以 $n_2$ 以得到真正的 $m$。

代码

点击查看代码

#include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
const int N = 110;
int n1, n2, l1, l2, l;
long long f[N][33], ans, tmp, x;
string s1, s2;

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    while (cin >> s2 >> n2 >> s1 >> n1) {
        l1 = s1.length(), l2 = s2.length();
        l = log2(l1 * n1 / l2);
        for (int i = 0; i < l1; ++i) {
            int p = i;
            f[i][0] = 0;
            for (int j = 0; j < l2; ++j) { //匹配s2的每一位
                int cnt = 0;
                while (s1[p] != s2[j]) {
                    if (++p == l1) p = 0;
                    if (++cnt >= l1) { //s1中匹配不上这一位
                        cout << 0 << '\n';
                        goto label; //goto语句, 直接跳到循环最后的continue
                    }
                }
                if (++p == l1) p = 0;
                f[i][0] += cnt + 1;
            }
        }
        for (int j = 1; j <= l; ++j)
            for (int i = 0; i < l1; ++i)
                f[i][j] = f[i][j - 1] + f[(i + f[i][j - 1]) % l1][j - 1];
        x = tmp = 0;
        for (int j = l; j >= 0; --j)
            if (x + f[x % l1][j] <= l1 * n1)
                x += f[x % l1][j], tmp += (1 << j);
        cout << tmp / n2 << '\n';
        label:
            continue;
    }
    
    return 0;
}

C. [USACO04DEC]Cleaning Shifts S（线段树优化 DP，离散化）

POJ 2376 | AcWing 295 | 码创未来

题意

给定 $n$ 个区间，用 $l_i,r_i(1\le i\le n)$ 表示，有一排 $T$ 个格子，用区间（可以重叠）覆盖所有格子，求最小区间数。

$1\le n\le 25000,1\le T\le {10}^6$。

思路

设 $f(i)$ 表示覆盖 $[1,i]$ 最少需要多少个区间。初值 $f(0)=0,f(i)=+\mathrm{\infty }(i\ne 0)$。

将区间按 $r$ 从小到大排序，枚举区间。

对于当前区间 $i$，它能覆盖的范围为 $[l_i,r_i]$，所以需要之前覆盖的范围最少为 $[1,l_i-1]$，最多为 $[1,r_i-1]$，于是可以得出状态转移方程。

$$f(r_i)=\underset{l_i-1\le j\le r_i-1}{min}\{f(j)\}+1.$$

对于取 min 的操作，我们用线段树来维护。数据范围较大，需要离散化（或许也可以不离散化）。

代码

点击查看代码

#include <iostream>
#include <cstring>
#include <algorithm>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
using namespace std;
const int N = 2.5e4 + 10;
const int INF = 0x3f3f3f3f;
int n, m, f[N << 2], ans = INF, raw[N << 2], cnt;

struct Node {
    int l, r;
    friend bool operator<(Node const &p, Node const &q) {
        return p.r < q.r;
    }
} a[N];

struct SegTree {
    #define lson (u << 1)
    #define rson (u << 1 | 1)
    struct Node {
        int l, r, minn;
    } tr[N << 4];
    inline void pushup(int u) { tr[u].minn = min(tr[lson].minn, tr[rson].minn); }
    void build(int u, int l, int r) {
        tr[u].l = l, tr[u].r = r;
        tr[u].minn = l ? INF : 0;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(lson, l, mid);
        build(rson, mid + 1, r);
        // pushup(u);
    }
    void modify(int u, int x, int v) {
        if (tr[u].l == x && tr[u].r == x) {
            tr[u].minn = v;
            return;
        }
        int mid = (tr[u].l + tr[u].r) >> 1;
        if (x <= mid) modify(lson, x, v);
        else modify(rson, x, v);
        pushup(u);
        return;
    }
    int query(int u, int l, int r) {
        if (l <= tr[u].l && tr[u].r <= r) return tr[u].minn;
        int res = INF;
        int mid = (tr[u].l + tr[u].r) >> 1;
        if (l <= mid) res = min(res, query(lson, l, r));
        if (r > mid) res = min(res, query(rson, l, r));
        return res;
    }
} t;

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    cin >> n >> m;
    raw[++cnt] = 1, raw[++cnt] = m;
    f(i, 1, n) {
        cin >> a[i].l >> a[i].r;
        raw[++cnt] = a[i].l, raw[++cnt] = a[i].r;
        raw[++cnt] = a[i].l + 1, raw[++cnt] = a[i].r + 1;
    }
    sort(a + 1, a + n + 1);
    sort(raw + 1, raw + cnt + 1);
    cnt = unique(raw + 1, raw + cnt + 1) - raw - 1;
    while (raw[cnt] > m) --cnt;
    memset(f, 0x3f, sizeof f);
    f[0] = 0;
    t.build(1, 0, cnt);
    f(i, 1, n) {
        a[i].l = lower_bound(raw + 1, raw + cnt + 1, a[i].l) - raw;
        a[i].r = lower_bound(raw + 1, raw + cnt + 1, a[i].r) - raw;
        int tmp = t.query(1, a[i].l - 1, a[i].r - 1) + 1;
        if (f[a[i].r] > tmp) {
            f[a[i].r] = tmp;
            t.modify(1, a[i].r, f[a[i].r]);
        }
    }
    if (f[cnt] == INF) cout << "-1\n";
    else cout << f[cnt] << '\n';
    
    return 0;
}

D. [USACO05DEC]Cleaning Shifts S（线段树优化 DP）

洛谷 P4644 | POJ 3171 | AcWing 296 | 码创未来

题意

给定 $n$ 个区间，用 $l_i,r_i(1\le i\le n)$ 表示，第 $i$ 个区间有一个代价 $c_i$，有一排 $T$ 个格子，用这些区间（可以重叠）覆盖 $[L,R]$ 内的所有格子，求所需的最小代价。

$1\le n\le 10000,0\le L,R\le 86399,L\le l_i\le r_i\le R,0\le c_i\le 500000$。

思路

与上一题不同之处在于不需要离散化；每个区间有一定的代价；覆盖的范围为 $[L,R]$。

令 $f(i)$ 表示覆盖 $[L,i]$ 所需的最小代价。初值 $f(L-1)=0,f(i)=+\mathrm{\infty }(L\le i\le R)$。

$$f(r_i)=\underset{l_i-1\le j\le r_i-1}{min}\{f(j)\}+c_i.$$

用线段树维护区间最小值。答案为 $f(R)$。

代码

点击查看代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
#define il inline
using namespace std;
const int N = 1e4 + 10, M = 1e5 + 10;
int n, L, R;
long long f[M];

struct Cow {
	int a, b, c;
	bool operator<(Cow const &o) const {
		return b < o.b;
	}
} a[N];

namespace SegTree {
	#define lson (u << 1)
	#define rson (u << 1 | 1)
	struct Node {
		int l, r;
		long long x;
	} tr[M << 2];
	il void pushup(int u) { tr[u].x = min(tr[lson].x, tr[rson].x); }
	void build(int u, int l, int r) {
		tr[u].l = l, tr[u].r = r;
		if (l == r) return tr[u].x = f[l], void();
		int mid = (l + r) >> 1;
		build(lson, l, mid);
		build(rson, mid + 1, r);
		pushup(u);
		return;
	}
	void modify(int u, int x, long long y) {
		if (tr[u].l == x && tr[u].r == x) {
			tr[u].x = y;
			return;
		}
		// pushdown(u);
		int mid = (tr[u].l + tr[u].r) >> 1;
		if (x <= mid) modify(lson, x, y);
		else modify(rson, x, y);
		pushup(u);
		return;
	}
	long long query(int u, int l, int r) {
		if (l <= tr[u].l && tr[u].r <= r) {
			return tr[u].x;
		}
		long long res = 4557430888798830399LL; //0x3f3f3f3f3f3f3f3f
		int mid = (tr[u].l + tr[u].r) >> 1;
		if (l <= mid) res = min(res, query(lson, l, r));
		if (r > mid) res = min(res, query(rson, l, r));
		return res;
	}
}
using SegTree::build;
using SegTree::modify;
using SegTree::query;

signed main() {
	
	scanf("%d%d%d", &n, &L, &R);
	++L, ++R;
	memset(f, 0x3f, sizeof f);
	f[L - 1] = 0;
	f(i, 1, n) {
		scanf("%lld%lld%lld", &a[i].a, &a[i].b, &a[i].c);
		a[i].a = max(++a[i].a, L);
		a[i].b = min(++a[i].b, R);
	}
	sort(a + 1, a + n + 1);
	build(1, L - 1, R);
	f(i, 1, n) {
		f[a[i].b] = min(f[a[i].b], query(1, a[i].a - 1, a[i].b - 1) + a[i].c);
		modify(1, a[i].b, f[a[i].b]);
	}
	if (f[R] >= 4557430888798830399LL) puts("-1");
	else printf("%lld\n", f[R]);
	
	return 0;
}

*E. The Battle of Chibi（树状数组优化 DP，离散化）

洛谷 UVA12983 | AcWing 297 | 码创未来

题意

给定长度为 $n$ 的数列 $A$，求 $A$ 有多少个长度为 $m$ 的严格递增子序列。$T$ 组测试数据。

对于每组测试数据，$1\le m\le n\le 1000,|A_i|\le {10}^9(1\le i\le n)$。

对于每个测试点，数据满足 $1\le T\le 100,\sum _{i=1}^T{n}_i\times m_i\le {10}^7$。

思路

设 $f(i,j)$ 表示在前 $j$ 个数中，有多少个长度为 $i$ 且以 $A_j$ 为结尾的严格递增子序列。显然若 $i>j$ 则 $f(i,j)=0$。初值 $f(0,0)=1$。

可以写出状态转移方程：

$$f(i,j)=\sum _{k<j\wedge a_k<a_j}f(i-1,k).$$

如果每次都要重新扫一遍 $k$，那么代价是 $O(n^3)$ 的（$m,n$ 视为同阶），显然会喜提一个大大的 TLE。如何优化呢？

我们先把外层循环的 $i$ 看做定值。对于每一个 $j$，我们想知道的是满足 $a_k<a_j$ 的 $f(i-1,k)$ 的和。

由于 $j$ 从小到大枚举，所以 $k<j$ 的条件自然就满足了。我们把 $a_k$ 当做比较大小的关键码，将 $f(i-1,k)$ 加入树状数组，每次询问所有小于 $a_j$ 的 $a_k$ 的和。

由于 $a_i$ 很大，所以需要进行离散化。我们把数组映射到区间 $[2,n+1]$ 上，把 $-\mathrm{\infty }$ 映射到 $1$ 上。

当枚举到每一个 $i$ 时，我们清空树状数组，然后向树状数组的位置 $1$（对应 $-\mathrm{\infty }$）上插入 $f(i-1,0)$ 即 $1(i=1)$ 或 $0(i\ne 1)$。

然后枚举 $j$，需要进行两个操作（顺序任意）：

• 查询小于 $a_j$ 的所有 $a_k$ 的 $f(i-1,k)$ 的和，修改 $f(i,j)$ 的值；
• 向树状数组中 $j$ 对应的位置 $va{l}_j$ 上插入 $f(i-1,j)$。

答案为 $\sum _{i=m}^{n}f(m,i)$。

代码

点击查看代码

#include <iostream>
#include <cstring>
#include <unordered_map>
#include <algorithm>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
#define il inline
using namespace std;
const int N = 1e3 + 10;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int tt, n, m, a[N], f[N][N], raw[N], c[N], cnt, ans;
unordered_map<int, int> val;

il int lowbit(int x) { return x & (-x); }

void add(int x, int y) {
    while (x <= cnt) {
        c[x] += y;
        c[x] %= MOD;
        x += lowbit(x);
    }
    return;
}

int query(int x) {
    int res = 0;
    while (x >= 1) {
        res += c[x];
        res %= MOD;
        x -= lowbit(x);
    }
    return res;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    cin >> tt;
    f(x, 1, tt) {
        val.clear();
        ans = 0;
        cin >> n >> m;
        f(i, 1, n) cin >> a[i], raw[i] = a[i];
        raw[0] = -INF;
        sort(raw, raw + n + 1);
        cnt = unique(raw, raw + n + 1) - raw;
        f(i, 0, cnt - 1) val[raw[i]] = i + 1;
        // f[0][0] = 1;
        f(i, 1, m) {
            memset(c, 0, sizeof c);
            add(1, (bool)(i == 1));
            f(j, 1, n) {
                f[i][j] = query(val[a[j]] - 1);
                add(val[a[j]], f[i - 1][j]);
            }
        }
        f(i, m, n) ans += f[m][i], ans %= MOD;
        cout << "Case #" << x << ": " << ans << '\n';
    }
    
    return 0;
}

*F. Cut The Sequence（单调队列优化 DP）

POJ 3017 | AcWing 299 | 码创未来

TO DO...

G. Bribing FIPA（树上背包 DP）

洛谷 UVA1222 | AcWing 324 | 码创未来

题意

给定一个 $n$ 个节点的森林和非负整数 $m(0\le m\le n)$，节点 $i$ 有费用 $a_i$。每个节点的价值即为以它为根的子树大小。

要求选定若干节点，使得价值总和 $\ge m$。并且如果选定了一个子树，则这个子树中的点不能再被选定。

求选定节点的费用和的最小值。

$1\le n\le 200,0\le m\le n$。

思路

选定一个节点，就相当于选定了它下面的所有点。

设 $f(u,i)$ 表示在以 $u$ 为根的子树中，选定若干节点使价值总和 $\ge i$ 的最小费用和。

令 $v$ 是 $u$ 的儿子，那么状态转移方程为：

$$f(u,i)=\underset{0\le j\le i}{min}\{f(u,j)+f(v,i-j)\}.$$

初值 $f(u,i)=+\mathrm{\infty },f(u,0)=0$。

由于一个 $f(u,i)$ 只能由一个 $v$ 更新，所以要倒序枚举 $i$。这一点与背包问题很相似。

为了把森林变成一棵树，我们建立一个超级根节点 $0$。令 $a_0=+\mathrm{\infty }$。答案为 $\underset{m\le i\le n}{min}\{f(0,i)\}$。

代码

点击查看代码

#include <cstdio>
#include <sstream>
#include <cstring>
#include <unordered_map>
#include <string>
#include <vector>
#include <bitset>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
#define g(x, y, z) for (int x = (y); (x) >= (z); --(x))
using namespace std;
const int N = 210;
const int INF = 0x3f3f3f3f;
int n, m, c, a[N], siz[N], f[N][N], ans;
char s[22000];
unordered_map<string, int> mp;
vector<int> e[N];
bitset<N> isRoot;

int dfs(int u) {
    memset(f[u], 0x3f, sizeof f[u]);
    f[u][0] = 0;
    int siz = 1;
    for (auto v: e[u]) {
        siz += dfs(v);
        g(i, n, 0) f(j, 0, i)
            f[u][i] = min(f[u][i], f[u][j] + f[v][i - j]);
    }
    f[u][siz] = min(f[u][siz], a[u]);
    return siz;
}

signed main() {
    
    while (true) {
        fgets(s, sizeof s, stdin); //读入整行存到字符串中
        if (s[0] == '#') break;
        sscanf(s, "%d%d", &n, &m); //从字符串中读入数据
        c = 0;
        mp.clear();
        f(i, 0, n) e[i].clear();
        isRoot.set(); //全部设为1
        f(i, 1, n) {
            int x, y, tmp;
            scanf("%s %d", s, &tmp);
            if (mp.find(s) == mp.end()) mp[s] = ++c;
            x = mp[s];
            a[x] = tmp;
            fgets(s, sizeof s, stdin); //读入整行
            stringstream ss(s); //字符串流
            string str;
            while (ss >> str) { //在字符串流中读入字符串
                if (mp.find(str) == mp.end()) mp[str] = ++c;
                y = mp[str];
                isRoot[y] = 0;
                e[x].push_back(y); //建边(指向儿子)
            }
        }
        f(i, 1, n) if (isRoot[i]) e[0].push_back(i); //超级根节点
        a[0] = INF;
        dfs(0);
        ans = INF;
        f(i, m, n) ans = min(ans, f[0][i]);
        printf("%d\n", ans);
    }
    
    return 0;
}

H. Computer（换根树上 DP）

AcWing 325 | 码创未来

题意

给定一棵 $n$ 个节点的树，边有权值 $l$，求每个节点到其他节点的最远距离。

$2\le n\le 100000,\sum l\le {10}^9$。

思路

（简单题，说得挺多，实际上没什么。。）

对于一个节点，这条最长的路径可能是向下到子树中的，也可能是向上经过父亲的。

我们设节点 $i$ 向下到某一个叶子的最长路径为 $dl{f}_i$（distance to leaf），向上的最长路径为 $du{p}_i$。

那么节点 $i$ 的答案即为 $max\{dl{f}_i,du{p}_i\}$。

对于 $dlf$，我们用一次 DFS 容易求得。具体来说，如果 $v$ 是 $u$ 的儿子，它们之间的边权为 $w_{u,v}$，那么在 DFS 回溯之后更新 $dl{f}_u$：

$$dl{f}_u=max\{dl{f}_v+w_{u,v}\}.$$

对于 $dup$，我们再用一次 DFS 也可以求得。如果 $v$ 是 $u$ 的儿子，它们之间的边权为 $w_{u,v}$，那么由 $u$ 更新 $v$，讨论从 $u$ 向上还是向下：

$$du{p}_v=max\{du{p}_u,dl{f}_u\}+w_{u,v}.$$

但是！！！我们发现一个重要的 bug：如果长度为 $dl{f}_u$ 的这条路径经过 $v$ 怎么办？这时由 $dl{f}_u$ 更新 $du{p}_v$ 不是重复经过 $v$ 了吗？？

所以我们再保存一个由节点向下到叶子的所有路径的次大值，并且保存最大值是从哪个儿子更新来的。

设 $dl{f}_{i,0}$ 表示由 $i$ 向下到叶子的所有路径的最大值，$dl{f}_{i,1}$ 表示由 $i$ 向下到叶子的所有路径的次大值，$so{n}_i$ 表示更新 $dl{f}_{i,0}$ 的 $i$ 的那个儿子。

处理 $dlf$ 的过程与上面类似，分别与当前的 $dl{f}_{u,0}$ 和当前的 $dl{f}_{u,1}$ 比较即可，过程中保存 $so{n}_u$。$du{p}_v$ 的状态转移要考虑 $v$ 是否等于 $so{n}_u$。

答案为 $max\{dl{f}_{i,0},du{p}_i\}$。

代码

点击查看代码

#include <iostream>
#include <cstring>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
using namespace std;
const int N = 1e5 + 10;
int n, dlf[N][2], son[N], dup[N];

struct Edge {
    int to, nxt, val;
} e[N << 1];
int head[N], cnt;
inline void add(int from, int to, int val) {
    e[++cnt].to = to, e[cnt].nxt = head[from], e[cnt].val = val, head[from] = cnt;
    return;
}

void dfs1(int u, int fa) {
    for (int i = head[u]; i; i = e[i].nxt) {
        int v = e[i].to, w = e[i].val;
        if (v == fa) continue;
        dfs1(v, u);
        if (dlf[v][0] + w > dlf[u][0]) {
            dlf[u][1] = dlf[u][0];
            dlf[u][0] = dlf[v][0] + w, son[u] = v;
        } else if (dlf[v][0] + w > dlf[u][1]) {
            dlf[u][1] = dlf[v][0] + w;
        }
    }
}

void dfs2(int u, int fa) {
    for (int i = head[u]; i; i = e[i].nxt) {
        int v = e[i].to, w = e[i].val;
        if (v == fa) continue;
        dup[v] = max(dup[u], (son[u] == v) ? dlf[u][1] : dlf[u][0]) + w;
        dfs2(v, u);
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    while (cin >> n) {
        memset(dlf, 0, sizeof dlf);
        memset(dup, 0, sizeof dup);
        memset(head, 0, sizeof head);
        cnt = 0;
        f(i, 2, n) {
            int y, l;
            cin >> y >> l;
            add(i, y, l), add(y, i, l);
        }
        dfs1(1, 1);
        dfs2(1, -1);
        f(i, 1, n) cout << max(dlf[i][0], dup[i]) << '\n';
    }
    
    return 0;
}

*I. [HNOI2011]XOR和路径（有后效性 DP，高斯消元，期望）

洛谷 P3211 | AcWing 326 | 码创未来

TO DO...

J. Fence Obstacle Course（线段树优化 DP）

POJ 2374 | AcWing 329 | 码创未来

题意

农夫约翰为他的奶牛们建造了一个围栏障碍训练场，以供奶牛们玩耍。

训练场由 $n$ 个不同长度的围栏组成，每个围栏都与 $x$ 轴平行，并且第 $i$ 个围栏的 $y$ 坐标为 $i$，$x$ 坐标覆盖 $[a_i,b_i]$。

训练场的出口位于原点 $(0,0)$，起点位于 $(S,n)$。

这些牛会从起点处开始向下走，当它们碰到围栏时会选择沿着围栏向左或向右走，走到围栏端点时继续往下走，按照此种走法一直走到出口为止。

求出这些牛从开始到结束，行走的水平距离的最小值。

$1\le n\le 30000,-{10}^5\le S\le {10}^5,-{10}^5\le a_i,b_i\le {10}^5$。

思路

为了方便转移，我们将从上往下走改为从下往上走，从 $(0,0)$ 最终走到 $(S,n)$。如图所示。

设 $f(i,j)$ 表示到第 $i$ 层栅栏的左/右端点时的答案，其中 $1\le i<n,j\in \{0,1\}$。

初值：$f(0,0)=f(0,1)=0$。令 $a_0=b_0=0$。

设 $lst(i)$ 表示上一个覆盖直线 $x=i$ 的栅栏编号。

那么状态转移方程为：

$$\begin{array}{rl}& f(i,0)=min\{f(lst(a_i),0)+|a_i-a_{lst(a_i)}|,f(lst(a_i),1)+|a_i-b_{lst(a_i)}|\},\\ & f(i,1)=min\{f(lst(b_i),0)+|b_i-a_{lst(b_i)}|,f(lst(b_i),1)+|b_i-b_{lst(b_i)}|\}.\end{array}$$

答案为 $min\{f(n-1,0)+|a_{n-1}-S|,f(n-1,1)+|b_{n-1}-S|\}$。

还有一个问题：如何快速求出 $ls{t}_i$？

我们需要一个支持区间覆盖、单点查询的数据结构，线段树标记下传可以很好地解决。

代码

点击查看代码

#include <iostream>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
using namespace std;
const int N = 5e4 + 10, M = 3e5 + 10;
int n, s, f[N][2], a[N], b[N];

inline int abs(int x) { return __builtin_abs(x); }

struct SegTree { //区间覆盖, 单点查询
    #define lson (u << 1)
    #define rson (u << 1 | 1)
    struct Node {
        int l, r, x;
    } tr[M << 2];
    inline void pushdown(int u) {
        if (~tr[u].x) tr[lson].x = tr[rson].x = tr[u].x, tr[u].x = -1;
        return;
    }
    void build(int u, int l, int r) {
        tr[u].l = l, tr[u].r = r;
        if (l == r) return;
        else tr[u].x = -1;
        int mid = (l + r) >> 1;
        build(lson, l, mid);
        build(rson, mid + 1, r);
        return;
    }
    void modify(int u, int l, int r, int x) {
        if (l <= tr[u].l && tr[u].r <= r) return tr[u].x = x, void();
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1;
        if (l <= mid) modify(lson, l, r, x);
        if (r > mid) modify(rson, l, r, x);
        return;
    }
    int query(int u, int x) {
        if (tr[u].l == x && tr[u].r == x) return tr[u].x;
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1;
        if (x <= mid) return query(lson, x);
        else return query(rson, x);
    }
} t;

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    cin >> n >> s;
    s += 1e5;
    t.build(1, 0, 2e5);
    // t.modify(1, 0, 2e5, 0);
    a[0] = 1e5, b[0] = 1e5;
    // f[0][0] = f[0][1] = 0;
    f(i, 1, n) {
        cin >> a[i] >> b[i];
        a[i] += 1e5, b[i] += 1e5;
        int j = t.query(1, a[i]);
        f[i][0] = min(f[j][0] + abs(a[i] - a[j]), f[j][1] + abs(a[i] - b[j]));
        j = t.query(1, b[i]);
        f[i][1] = min(f[j][0] + abs(b[i] - a[j]), f[j][1] + abs(b[i] - b[j]));
        t.modify(1, a[i], b[i], i);
    }
    cout << min(f[n][0] + abs(a[n] - s), f[n][1] + abs(b[n] - s)) << '\n';
    
    return 0;
}

*K. [USACO09OPEN]Tower of Hay G（单调队列优化 DP）

洛谷 P4954 | AcWing 331 | 码创未来

题意

一共有 $n$ 大包的干草（从 $1$ 到 $n$ 编号），第 $i$ 包干草有一个宽度 $w_i$。所有的干草包的厚度和高度都为 $1$。

Bessie 必须利用所有 $n$ 包干草来建立起干草堆。具体来说，她可以在一层中放若干包干草，但是这些干草只能紧挨着放在一起，并且总宽度不超过下面一层（最下面一层的宽度无限制）。她持续像这样堆放干草，直到所有的草包都被安置完成。

她必须按照从 $1$ 到 $n$ 的顺序堆放干草包。

Bessie 的目标是建立起最高的干草堆。求出最高的干草堆的高度。

$1\le N\le 100000,1\le w_i\le 10000$。

思路

由于从下到上搭干草堆不好维护，我们考虑从上到下搭干草堆。那么应依次读入 $n$ 到 $1$ 号的干草包。

猜想：如果使底层宽度最小，那么一定可以构造出一种层数最高的方案。

证明：对于当前的所有干草，任取一个能使层数最高的方案，设有 $C_A$ 层，把其中从下往上每一层最大的块编号记为 $A_i$；任取一个能使底边最短的方案，设有 $C_B$ 层，把其中从下往上每一层最大的块编号记为 $B_i$。显然 $A_1\ge B_1,A_{C_B}\le B_{C_B}$，这说明至少存在一个 $k\in (1,C_B)$，满足 $A_{k-1}\ge B_{k-1}$ 且 $A_k\le B_k$。也就是说，方案 $A$ 第 $k$ 层完全被方案 $B$ 第 $k$ 层包含。构造一个新方案，第 $k$ 层往上按方案 $A$，往下按方案 $B$，两边都不要的块放中间当第 $k$ 层。新方案的层数与 $A$ 相同，而底边长度与 $B$ 相同。证毕。（proof by zkw）（引自 USACO 2009 Open 干草塔Tower of Hay 解题报告 - Lazycal - 博客园）

设 $f(i)$ 表示用第 $1$ 到 $i$ 包干草最多能搭多少层。初值 $f(0)=0$，答案为 $f(n)$。

设 $g(i)$ 表示从上到下第 $i$ 层的最小宽度。

状态转移方程：

$$f(i)=\underset{\begin{array}{c}1\le j<i\\ w_{j+1}+\cdots +w_i>g(j)\end{array}}{max}\{f(j)\}+1$$

含义是：枚举 $j$，把 $j+1$ 到 $i$ 的这些干草放到当前这一层（如果能放的话）。只是暴力枚举 $j$ 的话，复杂度是 $O(n^2)$ 的，所以我们要进一步优化。

设 $w$ 的前缀和数组为 $s$。条件可以表示为：$s_i-s_j>g(j)$。注意到如果移项变为 $g(j)+s_j<s_i$，那么要维护的多项式只与 $j$ 有关，并且随着 $j$ 递增， $g(j)$ 和 $s_j$ 都单调递增。所以为了找到最大的（因为要更新 $g(j)$）满足上述不等式的 $j$，我们维护一个 $g(j)+s_j$ 单调递增，下标单调递增的单调队列。那么每次弹出队首直至不满足条件，最后一个满足条件的队首就是满足条件的最大的 $j$。用 $f(j)+1$ 更新 $f(i)$，并且用 $s_i-s_j$ 更新 $g(j)$。

总之这道题的特殊之处在于不是直接取队首，而是取最后一个满足条件的队首。

代码

点击查看代码

#include <iostream>
#define f(x, y, z) for (int x = (y); (x) <= (z); ++(x))
#define g(x, y, z) for (int x = (y); (x) >= (z); --(x))
using namespace std;
const int N = 1e5 + 10;
int n, w[N], s[N], q[N], h, t, f[N], g[N], ans;

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    
    cin >> n;
    g(i, n, 1) cin >> w[i];
    h = t = 1;
    f[0] = 0;
    f(i, 1, n) {
        s[i] = s[i - 1] + w[i];
        while (h <= t && g[q[h]] + s[q[h]] <= s[i]) ++h;
        int j = q[h - 1];
        f[i] = f[j] + 1;
        ans = max(ans, f[i]);
        g[i] = s[i] - s[j];
        while (h <= t && g[q[t]] + s[q[t]] >= g[i] + s[i]) --t;
        q[++t] = i;
    }
    cout << ans << '\n';
    
    return 0;
}