LeetCode Hot 100：回溯

已于 2024-10-25 22:43:13 修改
阅读量283 收藏
点赞数 2
分类专栏： Every day a LeetCode 文章标签： C++ LeetCode 数据结构与算法
于 2024-10-25 12:13:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ProgramNovice/article/details/143221979
版权

LeetCode Hot 100：回溯

46. 全排列

class Solution {
private:
    vector<vector<int>> ans;

public:
    vector<vector<int>> permute(vector<int>& nums) {
        if (nums.empty())
            return {};

        backtrace(nums, 0, (int)nums.size());
        return ans;
    }
    void backtrace(vector<int>& path, int level, int n) {
        if (level == n) {
            ans.push_back(path);
            return;
        }

        for (int i = level; i < n; i++) {
            swap(path[i], path[level]);
            backtrace(path, level + 1, n);
            swap(path[i], path[level]);
        }
    }
};

78. 子集

class Solution {
private:
    vector<vector<int>> ans;

public:
    vector<vector<int>> subsets(vector<int>& nums) {
        if (nums.empty())
            return {};

        vector<int> path;
        backtrace(nums, 0, (int)nums.size(), path);

        return ans;
    }
    void backtrace(vector<int>& nums, int level, int n, vector<int> path) {
        if (level == n) {
            ans.push_back(path);
            return;
        }

        path.push_back(nums[level]);
        backtrace(nums, level + 1, n, path);
        path.pop_back();
        backtrace(nums, level + 1, n, path);
    }
};

17. 电话号码的字母组合

class Solution {
private:
    unordered_map<char, string> dict{
        {'2', "abc"}, {'3', "def"},  {'4', "ghi"}, {'5', "jkl"},
        {'6', "mno"}, {'7', "pqrs"}, {'8', "tuv"}, {'9', "wxyz"}};

    vector<string> ans;

public:
    vector<string> letterCombinations(string digits) {
        if (digits.empty())
            return {};

        int n = digits.length();
        string path;
        backtrace(digits, 0, n, path);

        return ans;
    }
    void backtrace(string& digits, int level, int n, string path) {
        if (level == n) {
            ans.push_back(path);
            return;
        }

        char digit = digits[level];
        string s = dict[digit];

        for (char& c : s) {
            path.push_back(c);
            backtrace(digits, level + 1, n, path);
            path.pop_back();
        }
    }
};

39. 组合总和

class Solution {
private:
    vector<vector<int>> ans;

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if (candidates.empty())
            return {};

        int n = candidates.size();
        vector<int> path;
        backtrace(candidates, 0, n, target, path);

        return ans;
    }
    void backtrace(vector<int>& nums, int level, int n, int target,
                   vector<int> path) {
        if (level == n)
            return;
        if (accumulate(path.begin(), path.end(), 0) == target) {
            ans.push_back(path);
            return;
        }

        // 选 nums[level]
        if (accumulate(path.begin(), path.end(), 0) + nums[level] <= target) {
            path.push_back(nums[level]);
            backtrace(nums, level, n, target, path);
            path.pop_back();
        }
        // 不选 nums[level]
        backtrace(nums, level + 1, n, target, path);
    }
};

22. 括号生成

思路 1：回溯

class Solution {
private:
    vector<string> ans;

public:
    vector<string> generateParenthesis(int n) {
        if (n == 0)
            return {};

        string path;
        backtrace(0, 2 * n, path);

        return ans;
    }
    void backtrace(int level, int n, string path) {
        if (level == n) {
            if (isValid(path))
                ans.push_back(path);
            return;
        }

        path.push_back('(');
        backtrace(level + 1, n, path);
        path.pop_back();

        path.push_back(')');
        backtrace(level + 1, n, path);
        path.pop_back();
    }
    // 辅函数 - 判断字符串 s 是否有效
    bool isValid(const string& s) {
        int balance = 0;
        for (const char& c : s) {
            if (c == '(')
                balance++;
            else
                balance--;
            if (balance < 0)
                return false;
        }
        return balance == 0;
    }
};

思路 2：深度优先搜索

class Solution {
private:
    vector<string> ans;

public:
    vector<string> generateParenthesis(int n) {
        if (n == 0)
            return {};

        function<void(int, int, string)> dfs = [&](int left, int right, string str) {
            if (left < 0 || right < 0 || left > right)
                return;
            if (left == 0 && right == 0) {
                ans.push_back(str);
                return;
            }

            dfs(left - 1, right, str + '(');
            dfs(left, right - 1, str + ')');
        };

        dfs(n, n, "");

        return ans;
    }
};

79. 单词搜索

/*
 * @lc app=leetcode.cn id=79 lang=cpp
 *
 * [79] 单词搜索
 */

// @lc code=start
class Solution {
private:
    const int dx[4] = {0, 0, 1, -1};
    const int dy[4] = {1, -1, 0, 0};

public:
    // 主函数
    bool exist(vector<vector<char>>& board, string word) {
        if (board.empty())
            return false;

        int m = board.size(), n = m ? board[0].size() : 0;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        bool find = false;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                backtrack(i, j, 0, board, word, find, visited);

        return find;
    }
    // 辅函数（注意传引用，否则TLE）
    void backtrack(int i, int j, int level, vector<vector<char>>& board,
                   string& word, bool& find, vector<vector<bool>>& visited) {
        if (i < 0 || i >= board.size() || j < 0 || j >= board[0].size())
            return;
        if (visited[i][j] || find || board[i][j] != word[level])
            return;
        if (level == word.size() - 1) {
            find = true;
            return;
        }

        visited[i][j] = true; // 修改当前节点状态
        // 递归子节点
        for (int k = 0; k < 4; k++) {
            int r = i + dx[k];
            int c = j + dy[k];
            backtrack(r, c, level + 1, board, word, find, visited);
        }
        visited[i][j] = false; // 回改当前节点状态
    }
};
// @lc code=end

131. 分割回文串

/*
 * @lc app=leetcode.cn id=131 lang=cpp
 *
 * [131] 分割回文串
 */

// @lc code=start

// 回溯

class Solution {
private:
    vector<vector<string>> ans;

public:
    vector<vector<string>> partition(string s) {
        int n = s.length();

        vector<string> path;
        backtrack(s, 0, n, 0, path);

        return ans;
    }
    void backtrack(string s, int level, int n, int start, vector<string> path) {
        if (level == n) {
            ans.push_back(path);
            return;
        }

        if (level < n - 1) {
            // 跳过当前字符 s[level]
            backtrack(s, level + 1, n, start, path);
        }

        if (isPalindrome(s, start, level)) {
            // s[start, level] 是一个回文串
            string tmp = s.substr(start, level - start + 1);
            path.push_back(tmp);
            // 下一个回文串从 level+1 开始
            backtrack(s, level + 1, n, level + 1, path);
            // 回溯
            path.pop_back();
        }
    }
    // 辅函数 - 判断字符串 s 的 [left, right] 部分是否回文
    bool isPalindrome(const string& s, int left, int right) {
        while (left < right) {
            if (s[left] != s[right])
                return false;
            left++;
            right--;
        }
        return true;
    }
};
// @lc code=end

51. N 皇后

class Solution {
private:
    vector<vector<string>> ans;

public:
    vector<vector<string>> solveNQueens(int n) {
        if (n == 0)
            return {};

        // 初始化棋局
        vector<string> board(n, string(n, '.'));
        // 每行每行放置皇后
        backtrack(board, 0, n);

        return ans;
    }
    void backtrack(vector<string> board, int row, int n) {
        if (row == n) {
            ans.push_back(board);
            return;
        }

        for (int col = 0; col < n; col++) {
            if (check(board, row, col, n) == false)
                continue;
            board[row][col] = 'Q';
            backtrack(board, row + 1, n);
            board[row][col] = '.';
        }
    }
    bool check(const vector<string>& board, int row, int col, int n) {
        // 同一列
        for (int i = 0; i < row; i++)
            if (board[i][col] == 'Q')
                return false;

        // 斜上方
        for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
            if (board[i][j] == 'Q')
                return false;

        for (int i = row, j = col; i >= 0 && j <= n; i--, j++)
            if (board[i][j] == 'Q')
                return false;

        return true;
    }
};
【2024】LeetCode HOT 100——回溯
⚡
06-29 586
时我们便得到了一个答案。个右括号组成的所有括号序列中，合法的括号序列有。因为共有卡塔兰数个方案，且构造每个方案需要。是否是回文串，这样就可以在回溯的过程中以。一个括号序列是合法的当且仅当它满足以下条件。而所有的括号序列共有。数组（布尔数组），它代表。为所有可行解的长度之和。是三个字母的数字个数，是四个字母的数字个数。的时间，故时间复杂度为。我们可以预处理出来一个。
Leetcode HOT 100 (Java 版)
dwtianwen的博客
07-14 1291
一刷 Leetcode HOT 100 记录
LeetCode Hot 100：二叉树
ProgramNovice的博客
10-23 440
LeetCode Hot 100：二叉树
LeetCode 热题 HOT 100：回溯专题
秀岩的博客
10-01 445
题目包含：号码的字母组合、括号生成、组合总和、全排列、全排列 II （待优化)、子集、单词搜索、二叉树中的最大路径和、岛屿数量、路径总和 III
Python题解Leetcode Hot100之回溯
BigerBang的博客
07-22 752
leetcode hot100回溯问题python解答
leetcode hot 100搜索回溯
chenziang1的博客
12-27 438
需要注意的是，candidates需要每次只能搜索到后面的dfs(target,current,current_list,candidates[index:])# 当成一棵树来遍历回溯条件是大于target。如果至少一个数字的被选数量不同，则两种组合是不同的。，并以列表形式返回。中可以使数字和为目标数。对于给定的输入，保证和为。
leetcode hot100：十一、解题思路大全：回溯（全排列、子集、电话号码的字母组合、组合总和、括号生成、单词搜索、分割回文串、N皇后）
shanshan的博客
05-23 1188
我太爱这种回溯了，多做几次就熟了的感觉，别管，已膨胀（
【LeetCode Hot100】回溯篇
_Djhhh` blog
05-01 564
本文用于整理LeetCode Hot100中题目解答，因题目比较简单且更多是为了面试快速写出正确思路，只做简单题意解读和一句话题解方便记忆。但代码会全部给出，方便大家整理代码思路。
LeetCode Hot100题解
2301_82023822的博客
05-03 971
链表的多数问题可以通过双指针（快慢指针、前后指针）高效解决。
leetcode答案-leetcode-hot:leetcode-热门
06-30
如果是穷举答案相关的题（如八皇后、二叉树等），基本上来说，需要使用深度优先、广度优先或是回溯等递归的思路。 动态规划要重点准备一下，这样的题很多，如最大和子数组、买卖股票、背包问题、爬楼梯、改字符……...
leetcode530-leetcode-googtech::hot_beverage:数据结构、算法和leetcode问题的学习笔记，基于java、python、go
06-30
LeetCode涵盖的算法包括排序（快速排序、归并排序、插入排序等）、查找（二分查找、哈希查找等）、动态规划、贪心策略、回溯、递归等。通过解决这些题目，开发者可以深入理解各种算法的工作原理，并学会如何选择合适...
算法题（166）：占卜DIY
2301_79954395的博客
06-10 325
本题其实就是一个模拟题，但是如果我们按照题意对扑克堆进行操作，就相当于对数组进行数据头插与尾删了，而我们需要进行的次数是较多的，这样会导致效率低下，且模拟也不是很好进行。这里我们第一行的扑克牌中四张都没有翻出来过，所以我们需要移动第四张牌，此时我们直接定位到下标为四的牌就是下一个需要移动的牌。3.最终cnt中若没有未翻转的牌，说明该牌堆含有一对，即cnt[i]值为0时说明第i行含有一对，answer++我们发现每次的操作都是一样的，且在抽取到K之前都是逐层进行的，所以我们可以用递归模拟抽牌和放牌的过程。
LeetCode - 199. 二叉树的右视图
2402_83315537的博客
06-09 1001
DFS访问顺序（先右后左）是：1 -> 3 -> 6 -> 2 -> 5 -> 4。右视图是指从树的右侧看，对于每一层，只能看到该层最右边的节点。最终result=[1,3,6]，正好是树的右视图。如果当前节为空，直接返回检查当前深度是否等于结果数组的长度如果是，说明这是当前深度第一个被访问的节点，将其值加入结果数组如果不是，说明该深度已经有节点被加入结果，不做操作先递归访问右子树（深度+1），再递归访问左子树（深度+1）
每日leetcode
XiaoyaoCarter的博客
06-10 638
(student, class)是该表的主键（不同值的列的组合）。该表的每一行表示学生的名字和他们注册的班级。-计算机课有 1 个学生，所以我们不包括它。-英语课有 1 名学生，所以我们不包括它。-生物课有 1 名学生，所以我们不包括它。-数学课有 6 个学生，所以我们包括它。
算法刷题-回溯
2301_81754159的博客
06-09 902
今天给大家分享的还是一道关于dfs回溯的问题，对于这类问题大家还是要多刷和总结，总体难度还是偏大。对于回溯问题有几个关键点：1.首先对于这类回溯可以节点可以随机选择的问题，要做mian函数中循环调用dfs（i，obj），同时在dfs中要对后面的节点再次进行调用，还是使用dfs。2.对于使用过的节点用vis进行记录，而递归出口则是flag。3.注意在dfs选择后，要对这一次的递归选择进行回溯，下面这道题在dfs内的调用以及main函数中的调用都有显示。
可视化图解算法50：最小的K个数
weixin_42117918的博客
06-10 692
对于数据结构与算法，我们总结了一套【可视化+图解】方法，依据此方法来解决相关问题，算法变得易于理解，写出来的代码可读性高也不容易出错。
C++哈希碰撞精解：从原理到多策略冲突解决实战
C语言实战大全
06-12 689
​不同输入数据（Key）经哈希函数计算后得到相同的哈希值（即索引位置），即：
数据结构与算法：贪心（一）
最新发布
2402_89326161的博客
06-13 758
贪心
贪心算法之分发饼干（一）
2301_79314767的博客
06-12 338
【代码】贪心算法之分发饼干（一）
leetcode hot100答案python
03-20
### LeetCode Hot 100 Problems Python Solutions 以下是针对LeetCode热门100题中的部分经典题目提供Python实现方案： #### 两数之和 (Two Sum) 通过暴力解法可以遍历数组两次来找到目标值对应的索引位置[^1]。 ```python class Solution(object): def twoSum(self, nums, target): for i in range(len(nums)): for j in range(i + 1, len(nums)): if nums[i] + nums[j] == target: return [i, j] return [] ``` 另一种更高效的解决方案是利用哈希表减少时间复杂度至O(n)[^4]: ```python class Solution(object): def twoSum(self, nums, target): hash_map = {} for index, value in enumerate(nums): complement = target - value if complement in hash_map: return [hash_map[complement], index] hash_map[value] = index return [] ``` --- #### 组合总和 (Combination Sum) 此问题可以通过回溯算法解决，递归构建满足条件的结果集[^2]。 ```python class Solution: def combinationSum(self, candidates, target): result = [] def backtrack(remain, comb, start): if remain == 0: result.append(list(comb)) return elif remain < 0: return for i in range(start, len(candidates)): comb.append(candidates[i]) backtrack(remain - candidates[i], comb, i) comb.pop() backtrack(target, [], 0) return result ``` --- #### 全排列 (Permutations) 对于全排列问题，同样采用回溯方法生成所有可能的排列组合。 ```python class Solution: def permute(self, nums): res = [] def backtrack(path, options): if not options: res.append(path[:]) return for i in range(len(options)): path.append(options[i]) backtrack(path, options[:i] + options[i+1:]) path.pop() backtrack([], nums) return res ``` --- #### 最长连续序列 (Longest Consecutive Sequence) 该问题的核心在于使用集合数据结构优化查找效率，从而降低整体的时间复杂度[^3]。 ```python class Solution: def longestConsecutive(self, nums): longest_streak = 0 num_set = set(nums) for num in num_set: if num - 1 not in num_set: current_num = num current_streak = 1 while current_num + 1 in num_set: current_num += 1 current_streak += 1 longest_streak = max(longest_streak, current_streak) return longest_streak ``` --- #### 字符串中所有字母异位词 (Find All Anagrams in a String) 滑动窗口配合字符计数器能够高效解决问题。 ```python from collections import defaultdict class Solution: def findAnagrams(self, s, p): need = defaultdict(int) window = defaultdict(int) valid = 0 for c in p: need[c] += 1 left, right = 0, 0 res = [] while right < len(s): c = s[right] right += 1 if c in need: window[c] += 1 if window[c] == need[c]: valid += 1 while right - left >= len(p): if valid == len(need): res.append(left) d = s[left] left += 1 if d in need: if window[d] == need[d]: valid -= 1 window[d] -= 1 return res ``` --- #### 两数相加 (Add Two Numbers) 链表操作的经典案例之一，需注意进位处理逻辑。 ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next class Solution: def addTwoNumbers(self, l1, l2): dummy_head = ListNode(0) curr = dummy_head carry = 0 while l1 or l2 or carry: x = l1.val if l1 else 0 y = l2.val if l2 else 0 total = x + y + carry carry = total // 10 curr.next = ListNode(total % 10) curr = curr.next if l1: l1 = l1.next if l2: l2 = l2.next return dummy_head.next ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值