我们一起学习排列问题!你会吗?

开发 前端
当收集元素的数组path的大小达到和nums数组一样大的时候,说明找到了一个全排列,也表示到达了叶子节点。

[[428071]]

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

示例:

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

思路

此时我们已经学习了组合问题、 分割回文串和子集问题,接下来看一看排列问题。

相信这个排列问题就算是让你用for循环暴力把结果搜索出来,这个暴力也不是很好写。

所以正如我们在关于回溯算法,你该了解这些!所讲的为什么回溯法是暴力搜索,效率这么低,还要用它?

因为一些问题能暴力搜出来就已经很不错了!

我以[1,2,3]为例,抽象成树形结构如下:

全排列

回溯三部曲

  • 递归函数参数

首先排列是有序的,也就是说[1,2] 和[2,1] 是两个集合,这和之前分析的子集以及组合所不同的地方。

可以看出元素1在[1,2]中已经使用过了,但是在[2,1]中还要在使用一次1,所以处理排列问题就不用使用startIndex了。

但排列问题需要一个used数组,标记已经选择的元素,如图橘黄色部分所示:

全排列

代码如下:

  1. vector<vector<int>> result; 
  2. vector<int> path; 
  3. void backtracking (vector<int>& nums, vector<bool>& used) 
  • 递归终止条件

全排列

可以看出叶子节点,就是收割结果的地方。

那么什么时候,算是到达叶子节点呢?

当收集元素的数组path的大小达到和nums数组一样大的时候,说明找到了一个全排列,也表示到达了叶子节点。

代码如下:

  1. // 此时说明找到了一组 
  2. if (path.size() == nums.size()) { 
  3.     result.push_back(path); 
  4.     return
  • 单层搜索的逻辑

这里和组合问题、切割问题和子集问题最大的不同就是for循环里不用startIndex了。

因为排列问题,每次都要从头开始搜索,例如元素1在[1,2]中已经使用过了,但是在[2,1]中还要再使用一次1。

而used数组,其实就是记录此时path里都有哪些元素使用了,一个排列里一个元素只能使用一次。

代码如下:

  1. for (int i = 0; i < nums.size(); i++) { 
  2.     if (used[i] == truecontinue; // path里已经收录的元素,直接跳过 
  3.     used[i] = true
  4.     path.push_back(nums[i]); 
  5.     backtracking(nums, used); 
  6.     path.pop_back(); 
  7.     used[i] = false

整体C++代码如下:

  1. class Solution { 
  2. public
  3.     vector<vector<int>> result; 
  4.     vector<int> path; 
  5.     void backtracking (vector<int>& nums, vector<bool>& used) { 
  6.         // 此时说明找到了一组 
  7.         if (path.size() == nums.size()) { 
  8.             result.push_back(path); 
  9.             return
  10.         } 
  11.         for (int i = 0; i < nums.size(); i++) { 
  12.             if (used[i] == truecontinue; // path里已经收录的元素,直接跳过 
  13.             used[i] = true
  14.             path.push_back(nums[i]); 
  15.             backtracking(nums, used); 
  16.             path.pop_back(); 
  17.             used[i] = false
  18.         } 
  19.     } 
  20.     vector<vector<int>> permute(vector<int>& nums) { 
  21.         result.clear(); 
  22.         path.clear(); 
  23.         vector<bool> used(nums.size(), false); 
  24.         backtracking(nums, used); 
  25.         return result; 
  26.     } 
  27. }; 

总结

大家此时可以感受出排列问题的不同:

  • 每层都是从0开始搜索而不是startIndex
  • 需要used数组记录path里都放了哪些元素了

排列问题是回溯算法解决的经典题目,大家可以好好体会体会。

本文转载自微信公众号「代码随想录」,可以通过以下二维码关注。转载本文请联系代码随想录生公众号。

 

责任编辑:武晓燕 来源: 代码随想录
相关推荐

2021-05-31 09:23:04

管道模式责任链

2022-02-14 10:16:22

Axios接口HTTP

2021-05-19 10:37:16

WebFlux 前置工具

2010-07-16 10:14:29

信博会国际信息技术博览会

2023-03-28 07:32:37

2023-03-26 12:45:52

Linux内核头文件

2024-02-28 08:41:51

Maven冲突版本

2022-06-15 08:00:50

磁盘RedisRocketMQ

2021-11-26 09:44:42

链表节点定位

2022-12-01 09:59:57

内核观测性方法

2021-05-20 07:15:34

RSA-PSS算法签名

2023-05-29 09:07:10

SQLpageSize主键

2021-03-18 00:04:13

C# 类型数据

2023-10-26 08:38:43

SQL排名平分分区

2023-10-31 14:04:17

Rust类型编译器

2023-04-26 22:52:19

视觉人脸检测人脸对齐

2024-02-20 21:34:16

循环GolangGo

2021-12-29 08:27:05

ByteBuffer磁盘服务器

2022-01-17 06:59:40

Grep指令linux

2021-08-27 07:06:10

IOJava抽象
点赞
收藏

51CTO技术栈公众号