day13回溯3

已于 2023-10-04 17:05:33 修改
阅读量22 收藏
点赞数
文章标签： 算法 数据结构 leetcode
于 2023-10-03 17:06:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bian100816/article/details/133522980
版权

90.子集II

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used){
        result.push_back(path);// 收集子集，要放在终止添加的上面，否则会漏掉自己
       // if(startIndex >= nums.size()) return;
        for(int i=startIndex; i<nums.size(); i++){
            if(i>0 && nums[i]==nums[i-1] && used[i-1]==false) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums, 0, used);
        return result;
    }
};

491.递增子序列

class Solution {
public:
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> uset;
        for(int i=startIndex; i<nums.size(); i++){
            if((!path.empty() && nums[i]<path.back()) || uset.find(nums[i]) != uset.end() ) 
                continue;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            
            backtracking(nums,i+1);
            path.pop_back();
            
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        //vector<bool> used(nums.size(),false);
        backtracking(nums, 0);
        return result;
    }
};

此种解答 有问题，
前面的几题，自己不强调顺序，因此可以对原数组排序后采用used数组，而递增子序列需要保证原数组顺序，不可对原数组进行排序，因此nums[i]==nums[i-1]这个条件不适用，像4 7 6 7，nums[i]==nums[i-1] 对 7 和 6 不适用。
遗失的美好:
nums[i] 需要 不等于 前面所有的num[0]~nums[i-1]

class Solution {
public:
vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used){
        if(path.size()>1)
            result.push_back(path);
        for(int i=startIndex; i<nums.size(); i++){
            if((!path.empty() && nums[i]<path.back()) || (i>0 && nums[i]==nums[i-1] && used[i-1]==false)) 
                continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,i+1,used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(),false);
        backtracking(nums, 0, used);
        return result;
    }
};

可以写一个 for循环 然后判断一下？不行，1个continue 不能连跳 两个循环

if((!path.empty() && nums[i]<path.back()) || (i>0 && nums[i]==nums[i-1] && used[i-1]==false)) 
                continue;

改为：

 if(!path.empty() && nums[i]<path.back()) continue;
 for(int j=0;j<i;j++){
 	if(i>0 && nums[i]==nums[j] && used[j]==false)
         continue;
    }

还是不行，只能用set

46.全排列

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(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] == true) continue;
            used[i]=true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(),false);
        backtracking(nums, used);
        return result;
    }
};

47.全排列 II

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(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] == true) continue;
            if(i>0 && nums[i]==nums[i-1] && used[i-1]==false) continue;
            used[i]=true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
         result.clear();
        path.clear();
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums, used);
        return result;
    }
};

332. 重新安排行程

还是有一点问题，没找到 问题在哪，超时了，有一个用例通过不了。

class Solution {
private:
    vector<string> path={"JFK"};
    vector<string> res;
    void backtracking(vector<vector<string>>& tickets,string from,vector<int>& used){
        if(used.back()==tickets.size()){
            res=path;
            return;
        }
        for(int i=0;i<tickets.size();i++){
            if(tickets[i][0]==from&&used[i]==0){
                used[i]=1;
                used[tickets.size()]+=1;
                path.push_back(tickets[i][1]);
                backtracking(tickets,tickets[i][1],used);
                path.pop_back();
                used[i]=0;
                used[tickets.size()]-=1;
            }
            if(res.size()){
                return;
            }
        }
    }
    
public:
    static bool combine(const vector<string>& a,const vector<string>& b){
        return a[1]<b[1];
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        sort(tickets.begin(),tickets.end(),combine);
        vector<int> used(tickets.size()+1,0);
        backtracking(tickets,"JFK",used);
        return res;
    }
};

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

class Solution {
public:
vector<string> findItinerary(vector<vector<string>>& tickets) {
  sort(tickets.begin(), tickets.end(), [](const vector<string>& a, const vector<string>& b) {
  return a[1] < b[1];
});
path.emplace_back("JFK");
vector<bool> used(tickets.size(), false);
backTracking(tickets, used);
return result;
}
bool backTracking(vector<vector<string>>& tickets, vector<bool>& used) {
  if (path.size() == tickets.size() + 1) {
  result = path;
  return true;
  }
  for (int i = 0; i < tickets.size(); i++) {
  if (!used[i] && tickets[i].front() == path.back()) {
  path.push_back(tickets[i][1]);
  used[i] = true;
  if (backTracking(tickets, used)) {
  return true;
}
used[i] = false;
path.pop_back();
}
}
return false;
}

private:
vector<string> result;
vector<string> path;
};

// int main() {
// Solution solution;
// vector<vector<string>> tickets = {{"MUC", "LHR"}, {"JFK", "MUC"}, {"SFO", "SJC"}, {"LHR", "SFO"}};
// vector<string> itinerary = solution.findItinerary(tickets);
// for (const string& city : itinerary) {
// cout << city << " ";
// }
// cout << endl;
// return 0;
// }

51. N皇后

class Solution {
public:
/*验证棋盘是否合法
按照如下标准去重：

不能同行
不能同列
不能同斜线 （45度和135度角）*/
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列   保证 同一列没有  同一行 是自己加上去的，一定没有皇后
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}
    vector<vector<string>> result;
    // n 为输入的棋盘大小
    // row 是当前递归到棋盘的第几行了
    void backtracking(int n,int row,vector<string>& chessboard){
        if(row==n){
            result.push_back(chessboard);
            return;
        }
        for(int i=0;i<n;i++){
            if(isValid(row,i,chessboard,n)){
                chessboard[row][i]='Q';
                backtracking(n,row+1,chessboard);
                chessboard[row][i]='.';
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        /*创建一个n*n的棋盘，vector表示一个动态数组，
        string表示一个字符串，string初始化为一个由n个‘.’组成的字符串，
        然后这个字符串复制n次，，得到了n行n列的棋盘。*/
        backtracking(n, 0, chessboard);
        return result;
    }
};

37. 解数独

class Solution {
public:
bool isValid(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++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}
     bool backtracking(vector<vector<char>>& board){
        for(int i = 0; i < board.size(); i++){// 遍历行
            for (int j = 0; j < board[0].size(); j++) { // 遍历列
                if(board[i][j] == '.'){
                    for(char k='1';k<='9';k++){// (i, j) 这个位置放k是否合适
                        if(isValid(i,j,k,board)){
                            board[i][j]=k;   // 放置k
                            if(backtracking(board))
                                return true;// 如果找到合适一组立刻返回
                            board[i][j]='.';   // 回溯，撤销k
                        }
                    }
                    return false; // 9个数都试完了，都不行，那么就返回false
                    
                }
            
            }
        }
        return true;// 遍历完没有返回false，说明找到了合适棋盘位置了
    }
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};
遗失的美好886
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
day3ssm.rar
07-01
这个名为"day3ssm.rar"的压缩包文件包含了一个使用IDEA集成开发环境和Maven构建工具实现的简单SSM项目，提供了完整的源代码以及前端JSP页面，方便学习和理解SSM的整合过程。 首先，Spring框架作为整个应用的基础，...
python刷题day3.rar
04-23
"Python刷题day3"这个压缩包文件包含了多个关于算法和数据结构的视频教程，主要针对常见的面试问题进行讲解，涉及了二叉树、股票交易、搜索算法等多个核心知识点。下面我们将逐一深入探讨这些主题。 1. **二叉树的...
Day 30 回溯总结
qq_46025584的博客
04-19 589
​ 回溯和递归往往是相辅相成的；void backtracking(参数) {if (终止条件) {存放结果;return;for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {处理节点;backtracking(路径，选择列表);// 递归回溯，撤销处理结果。
回溯算法练习day.3
u011381222的博客
04-20 1183
题目描述：给你一个的整数数组candidates和一个目标整数target，找出candidates中可以使数字和为目标数target的 所有，并以列表形式返回。你可以按返回这些组合。candidates中的数字可以。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为target的不同组合数少于150个。[2,3,6,7],target =72 和 3 可以形成一组候选，2 + 2 + 3 = 7。注意 2 可以使用多次。7 也是一个候选， 7 = 7。仅有这两种组合。
Day24 回溯算法
qq_44072579的博客
03-18 424
【代码】Day24 回溯算法。
Day30 回溯06
xiaoantu的博客
12-07 363
回溯总结。
Day28 回溯04
xiaoantu的博客
12-05 394
这题注意，需要数层去重。
Day29 回溯05
xiaoantu的博客
12-06 383
Day29 回溯05
day24 回溯 77组合
m0_58298553的博客
01-21 393
Day21 回溯专项
DuanDuan0820的博客
05-12 66
组合
Day24 回溯开篇
m0_57236377的博客
02-03 67
day24，开篇
day 24 回溯算法
gzy865408的博客
11-21 105
1
chessgame-java.zip_May Day
09-24
同时，可能需要使用栈或队列来处理回溯和搜索算法。 4. **算法**：游戏的核心在于其决策逻辑，如**最小-最大搜索算法(minimax)** 或 **阿尔法-贝塔剪枝(α-β pruning)**，用于模拟对手的可能走法，以找到最佳移动...
春节7天练丨Day7：贪心、分治、回溯和动态规划1
08-03
3. 零钱兑换：动态规划问题，寻找最少的硬币数量组合，使得总和等于给定的目标金额。 4. 买卖股票的最佳时机：动态规划或贪心算法，寻找在给定价格数组中买入和卖出股票的最大利润。 5. 最大乘积子序列：动态规划...
Day02
03-10
例如，栈常用于处理回溯问题，而队列则在处理先进先出（FIFO）的任务时很有用。 算法是解决问题的步骤或过程，它与数据结构紧密相关。排序算法（如冒泡排序、插入排序、快速排序和归并排序）和搜索算法（如线性搜索...
P1145 约瑟夫
zty20120913的博客
08-06 424
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 940
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 249
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 574
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值