训练营第二十七天 | 491.递增子序列46.全排列47.全排列 II332.重新安排行程51. N皇后

已于 2024-06-05 14:14:41 修改
阅读量936 收藏 24
点赞数 10
文章标签： 算法 数据结构
于 2024-06-05 10:45:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44824156/article/details/139383869
版权

491.递增子序列

力扣题目链接(opens new window)

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

  • 输入: [4, 6, 7, 7]
  • 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

  • 给定数组的长度不会超过15。
  • 数组中的整数范围是 [-100,100]。
  • 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

思路：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startindex) {
        if (path.size() > 1) result.push_back(path);
        for (int i = startindex; i < nums.size(); i++) {
            if (i > startindex && nums[i] == nums[i - 1]) continue;  
            // 跳过重复元素
            if (path.empty() || nums[i] >= path.back()) {  
                // 确保递增顺序
                path.push_back(nums[i]);
                backtracking(nums, i + 1);
                path.pop_back();
            }
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

初始代码：

没有正确处理重复元素的情况。如果输入数组中有重复元素，直接跳过重复的元素，这样会遗漏一些合法的递增子序列。

为了正确处理重复元素，需要在每一层递归中使用一个集合（如 unordered_set）来记录当前层中已经使用过的元素，以确保每个元素在每一层递归中只使用一次，但在不同的递归路径中可以使用相同的元素。

unordered_set<int> used;  // 使用集合来记录当前层使用过的元素

if (used.find(nums[i]) != used.end()) continue;  // 当前层已经使用过的元素跳过

if (path.empty() || nums[i] >= path.back()) {  // 确保递增顺序

改正后的代码：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startindex) {
        if (path.size() > 1) result.push_back(path);
        unordered_set<int> used;  // 使用集合来记录当前层使用过的元素
        for (int i = startindex; i < nums.size(); i++) {
            if (used.find(nums[i]) != used.end()) continue;  // 当前层已经使用过的元素跳过
            if (path.empty() || nums[i] >= path.back()) {  // 确保递增顺序
                used.insert(nums[i]);  // 记录当前元素
                path.push_back(nums[i]);
                backtracking(nums, i + 1);
                path.pop_back();
            }
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

46.全排列

力扣题目链接(opens new window)

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

  • 输入: [1,2,3]
  • 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

思路：

该题在回溯法的基础上加了一个used数组，存储数组对应元素是否使用过，以此作为条件判断是否将该数加入path。

            if (used[i]) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtrack(nums, used);
            path.pop_back();
            used[i] = false;

同时，该题不需要startindex，因为每次循环都是将未加入path的所有元素依次遍历加入path。而是用used代替了，作为参数值传入backtrack函数。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path; // 全局变量

    void backtrack(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i]) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtrack(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtrack(nums, used);
        return result;
    }
};

47.全排列 II

力扣题目链接(opens new window)

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

  • 输入：nums = [1,1,2]
  • 输出： [[1,1,2], [1,2,1], [2,1,1]]

示例 2：

  • 输入：nums = [1,2,3]
  • 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

思路：

该题就多了一个去重操作。先给数组排序，然后还是使用used的方式递归。

其中特别注意：if (i > 0 && nums[i] == nums[i - 1]&& !used[i - 1]) continue;中不要忘记“!used[i - 1]”。!used[i - 1]：确保在当前层级中，前一个相同元素没有被使用。如果前一个相同元素没有被使用，则跳过当前元素。这一步的目的是避免在同一层级中选择相同的元素，从而防止生成重复的排列。如果used[i - 1] == true。则同一树枝重复，是被允许的。

class Solution {
    private:
    vector<vector<int>> result;
    vector<int> path;
    void backtrack(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++){
            if (used[i]) continue;           
            if (i > 0 && nums[i] == nums[i - 1]&& !used[i - 1]) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtrack(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtrack(nums, used);
        return result;
    }
};

332.重新安排行程

力扣题目链接(opens new window)

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

提示：

  • 如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前
  • 所有的机场都用三个大写字母表示（机场代码）。
  • 假定所有机票至少存在一种合理的行程。
  • 所有的机票必须都用一次 且 只能用一次。

示例 1：

  • 输入：[["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
  • 输出：["JFK", "MUC", "LHR", "SFO", "SJC"]

示例 2：

  • 输入：[["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
  • 输出：["JFK","ATL","JFK","SFO","ATL","SFO"]
  • 解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"]。但是它自然排序更大更靠后。

思路： 

使用unordered_map<string, map<string, int>> targets; 来记录航班的映射关系，定义为全局变量。参数里还需要ticketNum，表示有多少个航班（终止条件会用上）。

代码如下：

// unordered_map<出发机场, map<到达机场, 航班次数>> targets
unordered_map<string, map<string, int>> targets;
bool backtracking(int ticketNum, vector<string>& result) {

返回值用bool！

因为只需要找到一个行程，就是在树形结构中唯一的一条通向叶子节点的路线，所以找到了这个叶子节点了直接返回。

  • 递归终止条件

拿题目中的示例为例，输入: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]] ，这是有4个航班，那么只要找出一种行程，行程里的机场个数是5就可以了。

所以终止条件是：回溯遍历的过程中，遇到的机场个数，如果达到了（航班数量+1），那么我们就找到了一个行程，把所有航班串在一起了。

  • 单层搜索的逻辑

在选择映射函数的时候，不能选择unordered_map<string, multiset<string>> targets， 因为一旦有元素增删multiset的迭代器就会失效。

可以说本题既要找到一个对数据进行排序的容器，而且还要容易增删元素，迭代器还不能失效。

所以我选择了unordered_map<string, map<string, int>> targets 来做机场之间的映射。

class Solution {
private:
// unordered_map<出发机场, map<到达机场, 航班次数>> targets
unordered_map<string, map<string, int>> targets;
bool backtracking(int ticketNum, vector<string>& result) {
    if (result.size() == ticketNum + 1) {
        return true;
    }
    for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
        if (target.second > 0 ) { // 记录到达机场是否飞过了
            result.push_back(target.first);
            target.second--;
            if (backtracking(ticketNum, result)) return true;
            result.pop_back();
            target.second++;
        }
    }
    return false;
}
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> result;
        for (const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++; // 记录映射关系
        }
        result.push_back("JFK"); // 起始机场
        backtracking(tickets.size(), result);
        return result;
    }
};

51. N皇后

力扣题目链接(opens new window)

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：

  • 输入：n = 4
  • 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
  • 解释：如上图所示，4 皇后问题存在两个不同的解法。

示例 2：

  • 输入：n = 1
  • 输出：[["Q"]]

class Solution {
private:
    vector<vector<string>> result;
    
    void backtrack(int n, int i, vector<vector<char>>& chessboard, vector<bool>& used) {
        if (i == n) {
            vector<string> board;
            for (const auto& row : chessboard) {
                board.push_back(string(row.begin(), row.end()));
            }
            result.push_back(board);
            return;
        }
        for (int j = 0; j < n; j++) {
            if (used[j] || !valid(i, j, chessboard, n)) continue;
            chessboard[i][j] = 'Q'; // 放置皇后
            used[j] = true;
            backtrack(n, i + 1, chessboard, used);
            chessboard[i][j] = '.'; // 回溯，撤销皇后
            used[j] = false;
        }
    }

    bool valid(int i, int j, vector<vector<char>>& chessboard, int n) {
        // 检查左上对角线
        for (int k = i - 1, h = j - 1; k >= 0 && h >= 0; k--, h--) {
            if (chessboard[k][h] == 'Q') return false;
        }
        // 检查右上对角线
        for (int k = i - 1, h = j + 1; k >= 0 && h < n; k--, h++) {
            if (chessboard[k][h] == 'Q') return false;
        }
        return true;
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<char>> chessboard(n, vector<char>(n, '.'));
        vector<bool> used(n, false);
        backtrack(n, 0, chessboard, used);
        return result;
    }
};

37. 解数独

力扣题目链接(opens new window)

编写一个程序，通过填充空格来解决数独问题。

一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 '.' 表示。

解数独

一个数独。

解数独

答案被标成红色。

提示：

  • 给定的数独序列只包含数字 1-9 和字符 '.' 。
  • 你可以假设给定的数独只有唯一解。
  • 给定数独永远是 9x9 形式的。

思路：

树枝是board的每一个空格，用双层for循环（行、列）遍历，如果等于‘.‘ ， 则填入数字。树层是每个空格可以填入的数字，可以设置一个辅助函数判断该数字是否符合要求， 若符合则继续填入下一个空格。其中特别注意，这个回溯函数是一个bool函数，因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。

找九宫格的时候，可以通过int startRow = (row / 3) * 3;找到特定位置。

class Solution {
private:
    bool backtrack(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') {
                    for (char n = '1'; n <= '9'; n++) {
                        if (valid(i, j, n, board)) {
                            board[i][j] = n;
                            if (backtrack(board)) {
                                return true;
                            }
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }

    bool valid(int row, int col, char val, vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == val) {
                return false;
            }
        }
        for (int j = 0; j < 9; j++) {
            if (board[j][col] == val) {
                return false;
            }
        }
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++) {
            for (int j = startCol; j < startCol + 3; j++) {
                if (board[i][j] == val) {
                    return false;
                }
            }
        }
        return true;
    }

public:
    void solveSudoku(vector<vector<char>>& board) {
        backtrack(board);
    }
};

weixin_44824156
关注
  • 10
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CC++全排列..1--n的全排列以及字符串的全排列
05-12
CC++全排列算法详解 在计算机科学中，全排列是一个非常重要的概念，它指的是将一个集合中的元素按照一定的顺序排列出来的所有可能的排列方式。在这个文件中，我们将讨论CC++中生成从1到n的全排列算法，以及字符串的...
最长递增子序列 动态规划法.cpp.rar
10-14
C++的课程作业，一个简单的程序，用dev就能直接运行，老师应该不会太仔细检查，糊弄一下肯定没事的，不过最好能自己看懂就是了
代码随想录算法训练营第二十六天|332.重新安排行程，51. N皇后，37. 解数独，总结
weixin_47748259的博客
02-15 909
组合问题：N个数里面按一定规则找出k个数的集合排列问题：N个数按一定规则全排列，有几种排列方式切割问题：一个字符串按一定规则有几种切割方式子集问题：一个N个数的集合里有多少符合条件的子集棋盘问题：N皇后，解数独等等。
代码随想录算法训练营第三十二天|738.单调递增的数字，968.监控二叉树，总结
weixin_47748259的博客
02-21 928
贪心无套路，也没有框架之类的，需要多看多练培养感觉才能想到贪心的思路；贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
代码随想录算法训练营第四十七天|392.判断子序列，115.不同的子序列
weixin_47748259的博客
03-08 827
确定dp数组（dp table）以及下标的含义：dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]确定dp数组（dp table）以及下标的含义：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。dp数组如何初始化：dp[i][0] = 1，dp[0][j] = 0，其中dp[0][0]=1。
代码随想录算法训练营第四十五天|300.最长递增子序列，674. 最长连续递增序列，718. 最长重复子数组
weixin_47748259的博客
03-07 860
连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …确定递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1。确定递推公式：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1)确定遍历顺序：A和B先遍历哪一个都可以。
代码随想录算法训练营第四十六天|1143.最长公共子序列，1035.不相交的线，53. 最大子序和
weixin_47748259的博客
03-08 935
现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：nums1[i] == nums2[j]，且绘制的直线不与任何其他连线（非水平线）相交。确定dp数组（dp table）以及下标的含义：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]确定递推公式：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])确定遍历顺序：从左到右遍历，从上到下遍历。
代码随想录算法训练营第五十一天|503.下一个更大元素II，42. 接雨水
weixin_47748259的博客
03-13 847
给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素。数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
代码随想录算法训练营第四十九天|647. 回文子串，516.最长回文子序列，动态规划总结篇
weixin_47748259的博客
03-11 923
确定dp数组（dp table）以及下标的含义确定递推公式dp数组如何初始化确定遍历顺序举例推导dp数组背包问题系列打家劫舍系列股票系列子序列系列。
代码随想录算法训练营第四十二天|121. 买卖股票的最佳时机，122.买卖股票的最佳时机II
weixin_47748259的博客
03-04 852
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。这是因为本题的股票可以买卖多次，所以买入股票的时候，可能会有之前买卖的利润即：dp[i - 1][1]，所以dp[i - 1][1] - prices[i]。确定dp数组（dp table）以及下标的含义：dp[i][0] 表示第i天持有股票所得最多现金，dp[i][1] 表示第i天不持有股票所得最多现金。
代码随想录算法训练营第三十四天|62.不同路径，63. 不同路径 II
weixin_47748259的博客
02-27 1460
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。确定dp数组（dp table）以及下标的含义：dp[i][j]表示从(0,0)出发，到(i, j) 有dp[i][j]条不同的路径。确定递推公式：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
最长单调递增子序列（O（n2））.rar_company7ne_最长单调递增子序列（动态规划法）
09-20
最长单调递增子序列，使用动态规划算法，时间复杂度O（n2）
超级列表框递增显示.zip易语言项目例子源码下载
03-21
超级列表框递增显示.zip易语言项目例子源码下载超级列表框递增显示.zip易语言项目例子源码下载 1.合个人学习技术做项目参考 2.适合学生做毕业设计参考 3.适合小团队开发项目参考
51单片机模拟串口的三种方法.pdf
02-27
在51单片机应用中，常常需要模拟串口来扩展通信接口，因为标准的51系列单片机通常只有一个内置串口。模拟串口的基本思路是利用单片机的I/O引脚模拟串行通信的信号变化，实现数据的发送和接收。以下是三种模拟51...
排序（3）【归并排序】【计数排序】【排序算法度及其稳定性分析】
2301_81699364的博客
06-19 553
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
*算法训练（leetcode）第十四天 | 513. 找树左下角的值、112. 路径总和、106. 从中序与后序遍历序列构造二叉树、D
最新发布
weixin_43872997的博客
06-21 1127
LeetCode刷题日记
算法训练营day62
stmfresher的博客
06-17 194
在上一题的基础上加了一个，map确定 数组num1里元素最右边的值。真 暴力解法，但会超时。
C语言期末习题（结构体开始）
Mr_Xuhhh的博客
06-18 853
包含内容：结构体，枚举，联合体，动态内存管理，宏定义，编译，链接，预处理等相关知识，以题目的方式带着复习知识点，加油，相信一定对你有很大收获
求数组A的一个最长的单调递增子序列.
04-28
可以使用动态规划的方法来解决这个问题。首先定义一个数组dp，其中dp[i]表示以A[i]结尾的最长单调递增子序列的长度。初始化时，将dp[i]都赋值为1，因为每个元素本身都可以构成一个长度为1的单调递增子序列。 然后从左往右遍历数组A，对于每个位置i，再从0到i-1遍历一次，如果A[j]小于A[i]，则更新dp[i]为dp[j]+1和当前dp[i]的较大值。最后再遍历一次dp数组，找到最大值即可。 代码实现如下： ```python def longest_increasing_subsequence(A): n = len(A) dp = [1] * n for i in range(1, n): for j in range(i): if A[j] < A[i]: dp[i] = max(dp[i], dp[j] + 1) return max(dp) ``` 例如，对于数组A=[1, 3, 5, 2, 4, 6, 7]，最长的单调递增子序列为[1, 3, 5, 6, 7]，其长度为5。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值