本周总结（8.17-8.23）（动态规划）

本周主要复习背包问题，线性DP，区间DP，计数类DP，数位统计DP，状态压缩DP，树形DP，记忆化搜索等内容。

算法总结

背包问题

01背包

二维

for (int i = 1; i <= n; i ++ )
        for (int j = 0; j <= m; j ++ )
	    {
	        f[i][j] = f[i - 1][j];
	        if (j >= v[i]) f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
	    }

一维

for (int i = 1; i <= n; i ++ )
        for (int j = m; j >= v[i]; j -- ) //逆序
            f[j] = max(f[j], f[j - v[i]] + w[i]);

完全背包

for (int i = 1; i <= n; i ++ )
        for (int j = v[i]; j <= m; j ++ ) //正序
            f[j] = max(f[j], f[j - v[i]] + w[i]);

多重背包

二进制优化，优化后变为01背包问题

for (int k = 1; k <= s; k *= 2) //s是限制数量
{
    s -= k;
    t.push_back({v * k, w * k});
}
if (s > 0) t.push_back({v * s, w * s});

线性DP

最长上升子序列

f[1] = 1; //f[i]表示以第i位结尾的最长长度
for (int i = 2; i <= n; i ++ )
{
    f[i] = 1;
    for (int j = 1; j < i; j ++ )
        if (a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
}

int res = 0;
for (int i = 1; i <= n; i ++ )
    res = max(res, f[i]);

最长公共子序列

//f[i][j]表示所有从a[1 ~ i],b[1 ~ j]且以b[j]结尾的公共子序列的最大长度
for (int i = 1; i <= n; i ++ )
{
    for (int j = 1; j <= m; j ++ )
    {
        f[i][j] = f[i - 1][j];
        if (a[i] == b[j])
        {
            int maxv = 1;
            for (int k = 1; k < j; k ++ )
            {
                maxv = max(maxv, f[i - 1][k] + 1);
            }
            f[i][j] = max(f[i][j], maxv);
        }
    }
}

int res = 0;
for (int i = 1; i <= m; i ++ ) res = max(res, f[n][i]);

区间DP

一般外层循环从小到大枚举区间长度，内层循环枚举左端点的位置。
f[i][j]表示区间（i, j）上的某种性质。

计数类DP

特点：不能重叠，不能遗漏。
可能与组合数学相关联。
也可能转换成其他类型的动态规划问题。

数位统计DP

主要思路：分类讨论。
依次枚举每个数位可能出现的情况。
一般问题是求区间（a, b）内满足某条件的数的个数，可转换为f(b) - f(a - 1)，其中f(n)表示从0 ~ n区间内满足条件的个数。（类似前缀和的思想）

状态压缩DP

一般n的范围较小，可以用二进制数枚举出所有可能出现的情况。

树形DP

向下搜索（类似题目：大臣的旅费）

//d1、d2数组分别是向下的最远距离和次远距离，p数组记录最远距离的路径
void dfs_d(int u, int fa) //通过子节点更新父节点
{
    for (int i = 0; i < g[u].size(); i ++ )
    {
        auto j = g[u][i];
        if (j.first != fa)
        {
            dfs_d(j.first, u);
            int d = d1[j.first] + j.second;
            if (d > d1[u])
            {
                d2[u] = d1[u];
                d1[u] = d;
                p[u] = j.first;
            }
            else if (d > d2[u]) d2[u] = d;
        }
    }
}

向上搜索（类似题目：树的中心）

//up数组是向上的最远距离（反方向），p数组记录最远距离的路径
void dfs_u(int u, int fa) //通过父节点更新子节点
{
    for (int i = 0; i < g[u].size(); i ++ )
    {
        auto j = g[u][i];
        if (j.first != fa)
        {
            if (p[u] == j.first) up[j.first] = max(up[u], d2[u]) + j.second;
            else up[j.first] = max(up[u], d1[u]) + j.second;
            dfs_u(j.first, u);
        }
    }
}

其他总结

1. 快速幂函数的返回类型和参数类型最好统一，否则在计算过程中要进行类型转换。
2. 其他问题转换为背包问题时，有几个限制就要用几维的数组，再对空间进行优化。
3. 迭代器遍历vector：for (auto i = v.begin(); i != v.end(); i ++ ) // 若为int型vector，迭代器类型为vector<int>::iterator
4. 使用迭代器删除元素：v.erase(i); // i为迭代器
5. 使用迭代器访问元素：auto t = (*i); // i为迭代器

本周拓展题

以下题目均来源于acwing网站
背包1：1022. 宠物小精灵之收服
背包2：7. 混合背包问题
线性DP：272. 最长公共上升子序列
区间DP：479. 加分二叉树
计数类DP：306. 杰拉尔德和巨型象棋
数位统计DP：1081. 度的数量
状态压缩DP：1064. 小国王
树形DP：1073. 树的中心
记忆化搜索：898. 数字三角形