蓝桥杯第十五讲--复杂dp【习题】

前言

蓝桥杯官网：蓝桥杯大赛——全国大学生TMT行业赛事
✨本博客讲解 蓝桥杯C/C++ 备赛所涉及算法知识，此博客为第十五讲：复杂dp【习题】

本篇博客所包含习题有：
👊包子凑数
👊括号配对
👊旅游规划

复杂dp【例题】见博客：蓝桥杯第十五讲–复杂dp【例题】

如果你觉得本章节有些难度，建议先修如下两篇博客：
蓝桥杯第六讲–简单dp【例题】
蓝桥杯第六讲–简单dp【习题】

博客内容以题代讲，通过讲解题目的做法来帮助读者快速理解算法内容，需要注意：学习算法不能光过脑，更要实践，请读者务必自己敲写一遍本博客相关代码！！！

---

包子凑数

来源： 第八届蓝桥杯省赛C++A/B组,第八届蓝桥杯省赛JAVAA/B组

题目要求

题目描述：

小明几乎每天早晨都会在一家包子铺吃早餐。

他发现这家包子铺有 $N$ 种蒸笼，其中第 $i$ 种蒸笼恰好能放 $A_i$ 个包子。

每种蒸笼都有非常多笼，可以认为是无限笼。

每当有顾客想买 $X$ 个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有 $X$ 个包子。

比如一共有 $3$ 种蒸笼，分别能放 $3$、$4$ 和 $5$ 个包子。

当顾客想买 $11$ 个包子时，大叔就会选 $2$ 笼 $3$ 个的再加 $1$ 笼 $5$ 个的（也可能选出 $1$ 笼 $3$ 个的再加 $2$ 笼 $4$ 个的）。

当然有时包子大叔无论如何也凑不出顾客想买的数量。

比如一共有 $3$ 种蒸笼，分别能放 $4$、$5$ 和 $6$ 个包子。

而顾客想买 $7$ 个包子时，大叔就凑不出来了。

小明想知道一共有多少种数目是包子大叔凑不出来的。

输入格式：

第一行包含一个整数 $N$。

接下来 $N$ 行，每行包含一个整数 $A_i$。

输出格式：

输出一个整数代表答案。

如果凑不出的数目有无限多个，输出 $INF$。

数据范围：

$1\le N\le 100,$
$1\le A_i\le 100$

输入样例1：

2
4
5

输出样例1：

6

输入样例2：

2
4
6

输出样例2：

INF

样例解释：
对于样例 $1$，凑不出的数目包括：$1$, $2$, $3$, $6$, $7$, $11$。
对于样例 $2$，所有奇数都凑不出来，所以有无限多个。

思路分析

1.判断给定的所有数最大公约数是否是 $1$，若不是则返回 $INF$

2.若是，则有：
状态表示
$f[i][j]$ 表示：是否能从前i个物品中选,且能恰好能凑出体积是j

状态计算
$f[i][j]=f[i-1][j]||f[i-1][j-v]||f[i-1][j-2v]...$

二维空间的写法（朴素写法）

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 10010;

int a[110];
bool f[110][N];

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    int n;
    scanf("%d", &n);
    int d = 0;
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d", &a[i]);
        d = gcd(d, a[i]);
    }

    if (d != 1) puts("INF");
    else
    {
        f[0][0] = true;
        for (int i = 1; i <= n; i ++ )
            for (int j = 0; j < N; j ++ )
            {
                f[i][j] = f[i - 1][j];
                if (j >= a[i]) f[i][j] |= f[i][j - a[i]];
            }

        int res = 0;
        for (int i = 0; i < N; i ++ )
            if (!f[n][i])
                res ++ ;

        printf("%d\n", res);
    }

    return 0;
}

优化完空间后的写法

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 10010;

int a[110];
bool f[N];

int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    int n;
    scanf("%d", &n);
    int d = 0;
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d", &a[i]);
        d = gcd(d, a[i]);
    }

    if (d != 1) puts("INF");
    else
    {
        f[0] = true;
        for (int i = 1; i <= n; i ++ )
            for (int j = a[i]; j < N; j ++ )
                f[j] |= f[j - a[i]];

        int res = 0;
        for (int i = 0; i < N; i ++ )
            if (!f[i])
                res ++ ;

        printf("%d\n", res);
    }

    return 0;
}

括号配对

题目要求

题目描述：

$Hecy$ 又接了个新任务：$BE$ 处理。

$BE$ 中有一类被称为 $GBE$。

以下是 $GBE$ 的定义：

• 空表达式是 $GBE$
• 如果表达式 $A$ 是 $GBE$，则 $[A]$ 与 $(A)$ 都是 $GBE$
• 如果 $A$ 与 $B$ 都是 $GBE$，那么 $AB$ 是 $GBE$

下面给出一个 $BE$，求至少添加多少字符能使这个 $BE$ 成为 $GBE$。

注意： $BE$ 是一个仅由(、)、[、]四种字符中的若干种构成的字符串。

输入格式：

输入仅一行，为字符串 $BE$。

输出格式：

输出仅一个整数，表示增加的最少字符数。

数据范围：

对于所有输入字符串，其长度小于 $100$。

输入样例：

[])

输出样例：

1

思路分析

代码

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, INF = 100000000;

int n;
int f[N][N];

bool is_match(char l, char r)
{
    if (l == '(' && r == ')') return true;
    if (l == '[' && r == ']') return true;
    return false;
}

int main()
{
    string s;
    cin >> s;
    n = s.size();

    for (int len = 1; len <= n; len ++ )
        for (int i = 0; i + len - 1 < n; i ++ )
        {
            int j = i + len - 1;
            f[i][j] = INF;
            if (is_match(s[i], s[j])) f[i][j] = f[i + 1][j - 1];
            if (j >= 1) f[i][j] = min(f[i][j], min(f[i][j - 1], f[i + 1][j]) + 1);

            for (int k = i; k < j; k ++ )
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j]);
        }

    cout << f[0][n - 1] << endl;

    return 0;
}

旅游规划

题目要求

题目描述：

$W$ 市的交通规划出现了重大问题，市政府下定决心在全市各大交通路口安排疏导员来疏导密集的车流。

但由于人员不足，$W$ 市市长决定只在最需要安排人员的路口安排人员。

具体来说，$W$ 市的交通网络十分简单，由 $n$ 个交叉路口和 $n-1$ 条街道构成，交叉路口路口编号依次为 $0,1,\dots ,n-1$ 。

任意一条街道连接两个交叉路口，且任意两个交叉路口间都存在一条路径互相连接。

经过长期调查，结果显示，如果一个交叉路口位于 $W$ 市交通网最长路径上，那么这个路口必定拥挤不堪。

所谓最长路径，定义为某条路径 $p=(v_1,v_2,\dots ,v_k)$，路径经过的路口各不相同，且城市中不存在长度大于 $k$ 的路径（因此最长路径可能不唯一）。

因此 $W$ 市市长想知道哪些路口位于城市交通网的最长路径上。

输入格式：

第一行包含一个整数 $n$。

之后 $n-1$ 行每行两个整数 $u,v$，表示编号为 $u$ 和 $v$ 的路口间存在着一条街道。

输出格式：

输出包括若干行，每行包括一个整数——某个位于最长路径上的路口编号。

为了确保解唯一，请将所有最长路径上的路口编号按编号顺序由小到大依次输出。

数据范围：

$1\le n\le 2\times 10^5$

输入样例：

10
0 1
0 2
0 4
0 6
0 7
1 3
2 5
4 8
6 9

输出样例：

0
1
2
3
4
5
6
8
9

思路分析

1.先通过 $树形dp$ 求出每个点往下走的最大长度和次大长度，并且更新整棵树的最大路径 $ans$

2.枚举每一个结点 $i$，设该点的最大长度是 $d_1[i]$，次大长度是 $d_2[i]$，若 d1[i] + d2[i] == ans，表示最大路径是从该点得出的，通过 $dfs2$ 找到最大长度的路径，$dfs3$ 找到次大长度的路径，并对路径的点进行标记

代码

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

using namespace std;

const int N = 200010, M = N * 2;

int n;
int h[N], e[M], ne[M], idx;
int d1[N], d2[N], p1[N], up[N];
int maxd;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs_d(int u, int father)
{
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != father)
        {
            dfs_d(j, u);
            int distance = d1[j] + 1;
            if (distance > d1[u])
            {
                d2[u] = d1[u], d1[u] = distance;
                p1[u] = j;
            }
            else if (distance > d2[u]) d2[u] = distance;
        }
    }

    maxd = max(maxd, d1[u] + d2[u]);
}

void dfs_u(int u, int father)
{
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != father)
        {
            up[j] = up[u] + 1;
            if (p1[u] == j) up[j] = max(up[j], d2[u] + 1);
            else up[j] = max(up[j], d1[u] + 1);
            dfs_u(j, u);
        }
    }
}

int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }

    dfs_d(0, -1);
    dfs_u(0, -1);

    for (int i = 0; i < n; i ++ )
    {
        int d[3] = {d1[i], d2[i], up[i]};
        sort(d, d + 3);
        if (d[1] + d[2] == maxd) printf("%d\n", i);
    }

    return 0;
}

---