刷算法题（C++）

文章目录

• 堆栈
• • 压栈出栈序列
• 深度优先搜索
• • 括号生成
  • 无重复项的全排列
  • 有重复项的全排列
• 动态规划
• • 跳台阶
  • 打家劫舍
  • 删除并获得点数
  • [0/1 背包问题](#0/1 背包问题)
  • 完全背包问题
  • 小红取数
• 贪心算法
• • 单源最短路

堆栈

压栈出栈序列

• 问题：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。
• 解法：采用模拟方法，为序列 pushV 构造一个栈，为序列 popV 构造一个队列。不断压栈，直到遇到当前需要出栈的元素；然后不断出栈，直到需要继续压栈。

#include <vector>
class Solution {
  public:

    bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
        int fst = 0;
        int len = pushV.size();
        vector<int> stack;

        int i = 0;
        while (i != len) {
            if (pushV[i] != popV[fst]) {	// （压栈后的）栈顶不是预期的出栈队首
                stack.push_back(pushV[i]);	// 那么实际压栈
            } else {
                fst++;	// 否则将它压栈并出栈（stack 不变，出栈队列移除队首）
                while (!stack.empty() && stack.back() == popV[fst]) {
                    stack.pop_back();	// 然后不断出栈
                    fst++;
                }
            }

            i++;	// 继续压栈
        }

        return stack.empty();	// 为空，那么模拟顺利
    }
};

深度优先搜索

括号生成

• 问题：给出 n n n 对括号，请编写一个函数来生成所有的由n对括号组成的合法组合，要求空间复杂度为 O ( n ) O(n) O(n)。

• 解法：这里不能使用动态规划，如果构造并记录所有含有 d < n d < n d<n 对括号的串，然后再用不同长度的它们组合，将消耗指数级的内存。这里构建一棵树，其深度为 d < n d < n d<n 的中间节点存储了长度为 d d d 的合理加括号（从左向右书写 ，确保左括号的数量严格大于右括号的数量，根节点是空串 ）；左孩子是继续添加 "("，右孩子是继续添加 ")"，记得记录已使用的左右括号数量；只有深度为 n n n 的节点是叶子，其存储了最终的加括号结果。

#include <functional>
using namespace std;

class Solution {
  public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        
        // Lambda 表达式，设置 [&] 以引用方式捕获所有的外部变量
        function<void(string, int, int)> dfs = [&](string s, int l, int r) -> void {
            if (l == n && r == n) {
                res.push_back(s);	// 书写完毕
            }
            if (l < n) {
                dfs(s + "(", l + 1, r); // 在右端书写：(
            }
            if (r < l) {
                dfs(s + ")", l, r + 1); // 在右端书写：)
            }
        };
        
        dfs(string(""), 0, 0);	// 从左向右书写，根节点是空串
        return res;
    }
};

无重复项的全排列

• 问题：给出一组互不相同的数字，返回该组数字的所有排列。以数字在数组中的位置靠前 为优先级，按字典序排列输出。
• 解法：使用多叉树（深度 d d d 的节点具有 n − d n-d n−d 个孩子），深度优先 + 回溯 （入栈/出栈），借助数组 visited[i] 记录当前已使用的数字（以确定有哪些孩子）。这里的深度优先搜索，保证了访问到的叶子是按照数字位置的字典序。

#include <vector>
class Solution {
  public:

    void dfs(vector<vector<int>>& res, const vector<int>& num, vector<int>& visited, vector<int>& str) {
        int size = num.size();
        if (str.size() == size) {
            res.push_back(str);	// 叶子，获得一个全排列
            return;
        }

        // 已有的部分排列 str，作为子树根，搜索它的孩子节点
        for (int i = 0; i < size; i++) {
            if (visited[i] == 1)
                continue;	// 找出孩子
            
            visited[i] = 1;
            str.push_back(num[i]);	// 入栈
            
            dfs(res, num, visited, str);
            
            str.pop_back();	// 出栈
            visited[i] = 0;
        }
    }

    vector<vector<int>> permute(vector<int>& num) {
        int size = num.size();
        vector<int> str;
        vector<vector<int>> res;
        vector<int> visited(size, 0);

        dfs(res, num, visited, str); // 深度优先搜索
        return res;
    }
};

有重复项的全排列

• 问题：给出一组可能包含重复项的数字，返回该组数字的所有排列，结果以字典序升序排列。
• 解法：首先排序，将数字大小 的字典序，转化为数字位置 的字典序。如果有多个数字的值都是 v v v，那么简单做 DFS 将会得到一些重复项，它们的特征是这些具有相同数值的不同数字，分别作为同一个中间节点的孩子。因此，需要记录已有的孩子使用了哪些数值，对于重复数值的子树做剪枝。

#include <algorithm>
#include <set>
#include <vector>
class Solution {
  public:

    void dfs(vector<vector<int>>& res, const vector<int>& num, vector<int>& visited,
             vector<int>& str) {
        int size = num.size();
        if (str.size() == size) {
            res.push_back(str); // 叶子，获得一个全排列
            return;
        }
        set<int> S;	// 记录已有孩子的数值，用于剪枝

        // 已有的部分排列 str，作为子树根，搜索它的孩子节点
        for (int i = 0; i < size; i++) {
            if (visited[i] == 1)
                continue;   // 找出孩子
            if (S.find(num[i]) != S.end())
                continue;   // 剪枝

            visited[i] = 1;
            str.push_back(num[i]);  // 入栈
            S.insert(num[i]);

            dfs(res, num, visited, str);

            str.pop_back(); // 出栈
            visited[i] = 0;
        }
    }

    vector<vector<int>> permuteUnique(vector<int>& num) {
        int size = num.size();
        vector<int> str;
        vector<vector<int>> res;
        vector<int> visited(size, 0);

        sort(num.begin(), num.end()); // 以数字大小为字典序
        dfs(res, num, visited, str); // 深度优先搜索
        return res;
    }
};

动态规划

跳台阶

• 问题：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

• 解法：跳到第 n n n 阶时，要么从 n − 1 n-1 n−1 跳上来，要么从 n − 2 n-2 n−2 跳上来，这是互斥的 事件。使用一维表格 T [ k ] T[k] T[k] 记录跳到第 k k k 阶的跳法数量。

#include <vector>
using namespace std;

class Solution {
public:
    int jumpFloor(int number) {

        vector<int> T(number+1, 0);
        T[0] = 1;
        T[1] = 1;
        
        for(int k=2;k<=number;k++)
            T[k] = T[k-1] + T[k-2]; // 互斥的两种事件

        return T[number];
    }
};

打家劫舍

• 问题：你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
• 解法：使用一维表格 记录中间数据，其中 T [ i ] T[i] T[i] 表示在前 i + 1 i+1 i+1 个房间中 打劫，并且打劫了第 i i i 个房间 。如果 n ≤ 2 n \le 2 n≤2，那么简单打劫最有钱的房间；否则，赋值 T [ i ] T[i] T[i] 为打劫了第 i i i 个房间，同时在前 i − 1 i-1 i−1 个房间（索引 0 0 0 到 i − 2 i-2 i−2）中打劫以获得最大收益。

#include <algorithm>
using namespace std;

class Solution {
public:
    int rob(vector<int>& nums) {
        int size = nums.size();
        vector<int> T(size);

        if(size == 1){
            return T[0];
        }
        else{
            T[0] = nums[0];	// 打劫第 0 家，则不能打劫第 1 家
            T[1] = nums[1];	// 同理
        }

        // 打劫第 i 家，那么第 i-1 家不能打劫，因此搜索在 0 - (i-2) 中打劫的最优解
        for(int i=2;i<size;i++){
            auto it = max_element(T.begin(), T.begin()+(i-1));	
            T[i] = nums[i] + *it;
        }

        return *max_element(T.begin(), T.end()); // 最后搜索全局最优解
    }
};

删除并获得点数

• 问题：给你一个整数数组 nums ，你可以对它进行一些操作。每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除所有等于 nums[i] - 1 和 nums[i] + 1 的元素。开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
• 解法：数组中可能会出现重复的值 ，因此贪心的选取最大值并不正确。因此需要区分 "数值" 和 "点数"。首先，将数组中的相同数值 x i x_i xi，计算出它们的总体点数 ，并存储到一维数组中 V [ x ] = ∑ x i V[x] = \sum x_i V[x]=∑xi（没有出现的 x x x 位置赋值 V [ x ] = 0 V[x]=0 V[x]=0），然后使用 "打家劫舍" 算法。

#include <map>
#include <algorithm>
using namespace std;

class Solution {

    int rob(vector<int>& nums) {
        // 上一节的代码 ....
    }

public:
    int deleteAndEarn(vector<int>& nums) {
        map<int,int> T;
        for(auto v: nums){
            if(T.find(v) != T.end()){
                T[v] += v;	// 更新数值 v 的点数
            }
            else{
                T.insert({v,v}); // 新的数值
            }
        }

        int maxval = *max_element(nums.begin(), nums.end()); // 确定房子数量
        vector<int> V(maxval+1, 0);	// 初始化各个房子的价值为 0
        for(auto &p: T){
            V[p.first] = p.second;	// 数值 v 对应的点数
        }

        return rob(V);
    }
};

0/1 背包问题

• 问题：有一个箱子容量为 V V V，同时有 n n n 个物品，每个物品 有一个体积。要求 n n n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。

• 解法：这里的物品只有一份，要么选取，要么不选取。构建二维表， T [ i ] [ v ] T[i][v] T[i][v] 表示在前 i + 1 i+1 i+1 个物品中挑选，填充体积是 v ≤ V v \le V v≤V 的小背包，所能达到的最大体积。那么状态公式为： T [ i ] [ v ] T[i][v] T[i][v] 要么是 T [ i − 1 ] [ v ] T[i-1][v] T[i−1][v]（注意这个值的复制），要么是 T [ i − 1 ] [ v − b ] + b T[i-1][v-b] + b T[i−1][v−b]+b（选取了某个体积为 b b b 的物品）中的最大值。在节省空间的代码中，注意 T [ v ] T[v] T[v] 依赖于 T [ v − b ] T[v-b] T[v−b]，但是 T [ v − b ] T[v-b] T[v−b] 不应该使用体积为 b b b 的物品 ，因此必须从后向前更新。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int V, n;
    cin >> V >> n;

    vector<int> a(n);
    for (int i = 0; i < n; i++)
        cin >> a[i];

    vector<int> T(V + 1, 0);
    for (int i = 0; i < n; i++) {
        int b = a[i];
        
        // 容量 v 的背包，只考虑前 i+1 个物品，是否选中了第 i 个物品
        for (int v = V; v >= b; v--) {	// 从后向前
            T[v] = max(T[v], T[v - b] + b);	
        }
    }

    cout << V - T[V];
}

完全背包问题

• 问题：给定数组 arr，其中的所有值都为正整数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张 ，再给定一个 aim，代表要找的钱数，求组成 aim 的最少货币数。如果无解，请返回 − 1 -1 −1

• 解法：这也是背包问题，但是不再限制物品的份数。使用二维表 T [ k ] [ i ] T[k][i] T[k][i] 记录使用前 k + 1 k+1 k+1 种面值，去找零 i i i 元，所需的货币数量。初始时，设置 T [ 0 ] [ 0 ] = 0 T[0][0]=0 T[0][0]=0，其他的状态都使用 INT_MAX 表示无解。状态方程为：设置 T [ k ] [ i ] T[k][i] T[k][i] 要么是 T [ k − 1 ] [ i ] T[k-1][i] T[k−1][i]（注意这个值的复制），要么是 T [ k ] [ i − k v ] + k T[k][i-kv]+k T[k][i−kv]+k（使用了 k k k 张面值为 v v v 的货币）中最小的。在节省空间的代码中，注意 T [ i ] T[i] T[i] 依赖于 T [ i − v ] T[i-v] T[i−v]，并且 T [ i − v ] T[i-v] T[i−v] 本身也可以使用面值为 v v v 的货币 ，因此必须从前向后更新。

#include <climits>
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, aim;
    cin >> n >> aim;

    vector<int> arr(n, 0);
    for (int i = 0; i < n; i++)
        cin >> arr[i];

    vector<int> T(aim + 1, INT_MAX); // 初值为 "无穷大"
    T[0] = 0;

    for (int i = 0; i <= aim; i++) {	// 从前向后
        for (auto v : arr) {
            if (i >= v && T[i - v] != INT_MAX)
                T[i] = min(T[i], T[i - v] + 1);	// 在找零 i-v 元的策略中，再使用一张面值 v 的货币
        }
    }

    if (T[aim] == INT_MAX)	// 无解
        cout << -1;
    else
        cout << T[aim];
}

小红取数

• 问题：小红拿到了一个正整数的数组，她想取一些数使得取的数之和尽可能大，但要求这个和必须是 k k k 的倍数。你能帮帮她吗？

• 解法：构建二维表 T [ i ] [ j ] T[i][j] T[i][j] 表示使用前 i i i 个数，所能获得的同余 j ( m o d k ) j\pmod{k} j(modk) 的最大加和。状态公式为：要么是 T [ i − 1 ] [ j ] T[i-1][j] T[i−1][j]，要么是 T [ i − 1 ] [ j − a i ] + a i T[i-1][j-a_i] + a_i T[i−1][j−ai]+ai（循环的索引 ）。使用 INT64_MIN 代表无解，仅初始化 T [ 0 ] [ a 0 ] = a 0 T[0][a_0]=a_0 T[0][a0]=a0 是不行的，这隐含了 a 0 a_0 a0 必定被选取。需要首先设置 T [ 0 ] [ 0 ] = 0 T[0][0]=0 T[0][0]=0，表示不选取 a 0 a_0 a0 时（也是一种无解）的最大加和。然后再设置 T [ 0 ] [ a 0 ] = a 0 T[0][a_0]=a_0 T[0][a0]=a0（这可能会覆写 T [ 0 ] [ 0 ] T[0][0] T[0][0]），并且将 T [ n − 1 ] [ 0 ] = 0 T[n-1][0] = 0 T[n−1][0]=0 作为无解的判定。

#include <climits>
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int64_t n, k;
    cin >> n >> k;

    vector<int64_t> a(n);
    for (int i = 0; i < n; i++)
        cin >> a[i];

    vector<vector<int64_t>> T(n, vector<int64_t>(k, INT64_MIN));	// 使用 "负无穷" 表示无解
    T[0][0] = 0;	// 不使用第 1 个数（特殊的无解）
    T[0][a[0] % k] = a[0];	// 使用第 1 个数（可能覆写 T[1][0]）

    for (int i = 1; i < n; i++) {
        int64_t val = a[i];
        for (int j = 0; j < k; j++) {
            int mod = (j + k - (val % k)) % k;
            if (T[i - 1][mod] == INT64_MIN)	// 注意这里 T[0][0] == 0 并不被认为是无解
                T[i][j] = T[i - 1][j];	// 若使用第 i-1 个数则无解，那么简单复制上一列（不使用它）
            else
                T[i][j] = max(T[i - 1][j], T[i - 1][mod]  + val);	// 是否更新
        }
    }

    if (T[n-1][0] == 0)	// 一直没被更新，无解
        cout << -1;
    else
        cout << T[n-1][0];
}

贪心算法

单源最短路

• 问题：给你一个无向图，图中包含 5000 个点 m m m 个边，任意两个点之间的距离是 w w w，无重边或自环。请求出 1 1 1 号点到 n n n 号点的最短距离。图中可能存在孤立点，即存在点与任意点都没有边相连。如果 1 1 1 号点不能到达 n n n 号点，输出 -1。
• 解法：注意 n ≠ N = 5000 n \neq N=5000 n=N=5000（不然访存越界，弄了好久）。采用 Dijkstra 算法：初始化单源点到其他所有点的距离为其邻接表的源点所在行，并将该源点收集到 V V V 中；贪心的收集还不在 V V V 内的最短路径 （从源点经过 V V V 所能到达的最近点，它不会更短了）到集合 V V V 内，并用这个新的最短路径更新不在 V V V 内的其他路径；迭代 N − 1 N-1 N−1 轮，直到所有点都被收集到 V V V 中，便获得了单源点到其他所有点的最短路。

#include <climits>
#include <iostream>
#include <vector>
#include <map>
using namespace std;

int dijkstra(int N, vector<map<int, int>>& Adj, int s, int t) {
    vector<int> dist(N + 1, INT_MAX); // 冗余一项，更自然
    vector<int> mask(N + 1, 0);
    dist[s] = 0;
    mask[s] = 1;

    for (auto& p : Adj[s]) {
        dist[p.first] = p.second; // 初始化邻居到 s 的距离
    }

    for (int i = 1; i < N; i++) { // 迭代 N-1 轮
        int min_dist = INT_MAX;
        int min_u = 0;

        for (int u = 1; u <= N; u++) {
            if (mask[u] == 0 && dist[u] < min_dist) {   // 找出当前 mask=0 的最短路
                min_u = u;
                min_dist = dist[u];
            }
        }

        mask[min_u] = 1;
        if (min_u == t) // 提前终止
            break;

        for (int v = 1; v <= N; v++) {  // 用这个新的最短路，更新其他路径
            if (mask[v] == 1)
                continue;

            if (Adj[min_u].find(v) != Adj[min_u].end()) // 这个函数太慢了
                dist[v] = min(dist[v], dist[min_u] + Adj[min_u][v]); // 从 s 到 u 再到 v
        }
    }

    if (dist[t] == INT_MAX)
        return -1;
    else
        return dist[t];
}

int main() {
    int N = 5000;
    int n, m;
    cin >> n >> m;
    vector<map<int, int>> Adj(N + 1);  // 节省空间

    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        Adj[u][v] = w;
        Adj[v][u] = w;
    }

    cout << dijkstra(N, Adj, 1, n);
}