Leetcode刷题总结--回溯法

最新推荐文章于 2022-02-09 00:51:14 发布

Q都Q歪来

最新推荐文章于 2022-02-09 00:51:14 发布

阅读量266

点赞数

分类专栏： Leetcode刷题总结文章标签：算法字符串数据结构 c++

本文链接：https://blog.csdn.net/qq_41283672/article/details/106846585

版权

Leetcode刷题总结专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Leetcode刷题总结

回溯法

回溯法的本质就是在递归过程中将生成和检查过程有机结合起来，从而减少不必要的枚举，是一种系统性的搜索算法。只要可以把问题分解为不太多的步骤，每个步骤含有不太多的选择，均可以使用回溯法（有超时的风险）。

回溯法从根节点出发，以深度优先搜索方式搜索整个解空间。回溯法以这种工作方式递归地在解空间中搜索，直到找到所要求的解或解空间所有解都被遍历过为止。
伪代码：

void dfs(int curr_state)
{
	if(到达基例) return;
    // 1. 进行尝试操作,当前状态转为next_state
    opeartion(curr_state);
    // 2. 进入下一层深搜6
    dfs(next_state);
    // 3. 子过程返回后将状态还原为curr_state
    rev_opeartion(next_state);
}

Leetcode46 全排列

题目描述：

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

示例：

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

算法思想：

数字的全排列，意味着我们需要遍历所有的解空间。数学知识告诉我们 $N$ 个数字的全排列有 $N!$ 种情况。

假设当前已经确定好排列的字符串为 $S (i, j)$ ，那么只需要在 $j + 1$ 位置枚举出现的所有的可能的情况。所以这个题目也是一个树型问题，我们只需要按顺序枚举每一位可能出现的情况，已经选择的数字在接下来要确定的数字中不能出现。按照这种策略选取就能够做到不重不漏，把可能的全排列都枚举出来。

枚举每一位可能出现的情况，其实就是一个回溯过程，假设当前位置为K，将这个状态传递下去，得到这个状态下所有的字符串。然后再将当前位置改为K'，继续传递下去。

算法步骤：

定义start为当前遍历到的位置，从start至结尾枚举下一位置i
将下一位置start与i交换位置，进入下一位置，重复步骤1
如果当前位置为字符串结尾，则输出字符串，然后返回

代码：

vector<vector<int>> permute(vector<int>& nums)
{
    if(nums.size() == 0) return vc;
    int len = nums.size();
    permutehelp(nums,0,len);
    return vc;

}

void permutehelp(vector<int>& nums,int start,int end)
{
    if(start == end)
    {
        vc.push_back(nums);
        return;
    }
    for(int i=start;i<end;i++)
    {
        swap(nums,start,i);
        permutehelp(nums,start+1,end);
        swap(nums,start,i);
    }
}

Leetcode47 无重复全排列

题目描述：

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

示例：

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

算法思想：

此题思想与上一题一样，唯一多加一点的地方就是去除重复。如何去除重复？

如果当前交换的位置元素与之前位置元素值相同（前面出现过），则直接丢弃这一次的枚举结果。

这样一来，就不会存在重复排列了

算法步骤：

定义start为当前遍历到的位置，从start至结尾枚举下一位置i
若i位置与之前位置元素不同，将位置start与i交换位置，进入下一位置，重复步骤1
如果当前位置为字符串结尾，则输出字符串，然后返回

（这里没遍历一个字符，就加入set中，后续有相同字符，就会被检测出来）

代码：

vector<vector<int>> permuteUnique(vector<int>& nums)
{
    if(nums.size() == 0) return vc;
    int len = nums.size();
    permutehelp(nums,0,len);
    return vc;
}
void permutehelp(vector<int>& nums,int start,int end)
{
    if(start == end)
   	{
        vc.push_back(nums);
        return;
    }
    unordered_set<int> uniq;
    for(int i=start;i<end;i++)
    {
        if(uniq.count(nums[i]))
        {
            continue;
        }
        swap(nums,start,i);
        permutehelp(nums,start+1,end);
        swap(nums,start,i);  
        uniq.insert(nums[i]);
    }
}

Leetcode679 24点

题目描述：

你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 *，/，+，-，(，) 的运算得到 24。

示例：

输入: [4, 1, 8, 7]
输出: True
解释: (8-4) * (7-1) = 24

算法思想：

需要枚举四个数以及对应的操作，从四个数选择两个数进行操作，然后放回。然后从三个数选择两个进行操作，放回。最后将剩下两个数进行运算，判断答案是否出现24点。

上述过程中，需要不断改变的就是两个数之间的操作，这就是需要回溯的点。只需要从序列中枚举两个点，然后试探每一种操作，寻找到是否有满足条件的情况即可。

算法步骤：

从列表中选择两个数，将这两个数从列表中删除。如果列表元素只有一个，去往步骤三
对这两个数尝试所有运算操作，每尝试一次，都将结果送回列表，重复步骤1
如果寻找到符合条件的结果，返回True

代码：

bool judgePoint24(vector<int>& nums) 
{
    bool res = false;
    double eps = 0.001;
    vector<double> arr(nums.begin(), nums.end());
    helper(arr, eps, res);
    return res;
}

void helper(vector<double>& nums, double eps, bool &res)
{
    // 因为传递的是引用，如果有一个例子找到了，那么剩下的过程都会直接返回，提前结束
    if (res) return;
    if (nums.size() == 1) 
    {
        if (abs(nums[0] - 24) < eps) 
        {
            res = true; 
        }
        return;
    }        
    // 枚举两个数
    for (int i = 0; i < nums.size(); ++i) 
    {
        for (int j = 0; j < i; ++j) 
        {
            double p = nums[i], q = nums[j];
            // 枚举这两个数所有可能的操作
            vector<double> t{p + q, p - q, q - p, p * q};
            //除数不为0
            if (p > eps) 
            {
                t.push_back(q / p);
            }
            if (q > eps) 
            {
                t.push_back(p / q);    
            }
            
            // 下面是回溯部分代码
            nums.erase(nums.begin() + i);
            nums.erase(nums.begin() + j);
            
            for (double k : t) 
            {
                nums.push_back(k);
                helper(nums, eps, res);
                nums.pop_back();
            }
            
            nums.insert(nums.begin() + j, q);
            nums.insert(nums.begin() + i, p);
            }
        }
	}
}

Leetcode126 单词接龙II

题目描述：

给定两个单词（beginWord 和 endWord）和一个字典 wordList，找出所有从 beginWord 到 endWord 的最短转换序列。

转换需遵循如下规则：

每次转换只能改变一个字母。
转换后得到的单词必须是字典中的单词。
说明:

如果不存在这样的转换序列，返回一个空列表。
所有单词具有相同的长度。
所有单词只由小写字母组成。
字典中不存在重复的单词。
你可以假设 beginWord 和 endWord 是非空的，且二者不相同。

示例：

输入:
beginWord = “hit”,
endWord = “cog”,
wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]

输出:
[
[“hit”,“hot”,“dot”,“dog”,“cog”],
[“hit”,“hot”,“lot”,“log”,“cog”]
]

算法思想：

一次转化可以改变一个字母，从一个单词找到另一个单词。把单词看成图的节点，单词转化就变成了图的节点之间存在一条边。题目就变成了从源节点到目标节点的单元最短路径。

从源节点开始，尝试一次改变可以到达的节点，然后依次递推，直到到达目标节点。虽然这样可以找到路径，但是无法确定最短路径。有一种做法就是将路径长度也作为参数传递下去，到达基例时比较长短，更新结果。这样虽然不失为一种解决方法，但是会遍历所有的路径，所以很不幸的超时了！

那么如何改进呢？说到最短，我们就可以想到BFS算法，而且这个图里边的权值可以当成1来处理。因此对于这个图，首先使用BFS确定图中的每个节点所在的层次（距离根节点的距离）。同时通过BFS就可以判断从源点是否存在去往根节点的路径。

然后，就可以寻找路径了。可以从源节点开始，按照层次递增的规矩向下遍历。也可以从目的节点开始，按照层次递减的规矩向上遍历。但是无论是那种方式，都要尝试可能的路径，这样一来就无法避免的要使用回溯。

算法步骤：

对输入信息进行处理，构造出无向图
对图进行BFS遍历，确定所有节点的层次信息，确定最短路径的长度
根据层次信息，使用DFS遍历输出所有可能的路径

代码:

class Solution {
public:
    // 判断两个单词是否一步转化
    bool sim(const string& s1, const string& s2) {
        int diff = 0;
        for (int i = 0; i < s1.size(); ++i) {
            diff += s1[i] != s2[i];
        }
        return diff <= 1;
    }
    
    // 从目的节点开始 反向深搜 找到路径
    void dfs(const vector<vector<int> >& g, const vector<int>& dfn, const vector<string>& wordList,
            int i, vector<string>& path, vector<vector<string> >& paths) {
        if (dfn[i] == 0) {
            vector<string> v(path);
            reverse(v.begin(), v.end());
            paths.push_back(v);
            return;
        }
        for (auto j : g[i]) {
            if (dfn[j] == dfn[i] - 1) {
                // 回溯过程 找到上一层的一个路径
                path.push_back(wordList[j]);
                dfs(g, dfn, wordList, j, path, paths);
                path.pop_back();
            }
        }
    }
    
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        wordList.push_back(beginWord);
        int N = wordList.size();
        vector<vector<int> > g(N);
        int endi = -1;
        // 构图
        for (int i = 0; i < N; ++i) {
            if (wordList[i] == endWord) endi = i;
            for (int j = i + 1; j < N; ++j) {
                if (sim(wordList[i], wordList[j])) {
                    g[i].push_back(j);
                    g[j].push_back(i);
                }
            }
        }
        if (endi == -1) return {};
        // 层级编号
        vector<int> dfn(N, -1);
        queue<int> q;
        q.push(N - 1);
        dfn[N - 1] = 0;
        while (!q.empty()) {
            auto i = q.front();
            q.pop();
            for (auto j : g[i]) {
                if (dfn[j] == -1) {
                    dfn[j] = dfn[i] + 1;
                    q.push(j);
                }
            }
        }
        if (dfn[endi] == -1) return {};
        // 回溯路径
        vector<string> path{endWord};
        vector<vector<string> > paths;
        dfs(g, dfn, wordList, endi, path, paths);
        return paths;
    }
};

Q都Q歪来

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Leetcode刷题总结--回溯法

Leetcode刷题总结回溯法回溯法的本质就是在递归过程中将生成和检查过程有机结合起来，从而减少不必要的枚举，是一种系统性的搜索算法。只要可以把问题分解为不太多的步骤，每个步骤含有不太多的选择，均可以使用回溯法（有超时的风险）。回溯法从根节点出发，以深度优先搜索方式搜索整个解空间。回溯法以这种工作方式递归地在解空间中搜索，直到找到所要求的解或解空间所有解都被遍历过为止。伪代码：void dfs(int curr_state){ if(到达基例) return; // 1. 进行尝试操作
复制链接

扫一扫