LeetCode46.全排列Golang版

最新推荐文章于 2024-06-21 19:27:23 发布

皮卡猴

最新推荐文章于 2024-06-21 19:27:23 发布

阅读量474

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode刷题文章标签： leetcode

本文链接：https://blog.youkuaiyun.com/flying_monkey_1/article/details/114597807

leetcode刷题专栏收录该内容

252 篇文章

订阅专栏

本文介绍LeetCode46全排列问题的Golang解决方案，采用回溯法实现，详细解析了全排列问题的解决思路，并给出了两种实现代码模板。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LeetCode46.全排列Golang版

1. 问题描述

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

示例:

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

2. 思路

全排列问题是典型的回溯法问题
回溯法模板：

void dfs ( int x ) {
	if ( 到达目的地 ) {
		输出解
		return
	}
	
	for （ i = 1; i <= 方案数; i++ ）{
		if ( 方案可行 ) {
			保存路径
			dfs( x + 1 )
			保存回复前的状态
		}
	}
}

注意
简单来说，整体的思路就是有规律的穷举。把所有流程平铺到一棵树上，就是一个深度遍历的过程。

从数组中选取数
从剩下的元素中继续选取作为子节点
直到深度和数组长度相同，则生成了一条路径
返回的时候将当前路径中最后一个节点拿走，从未被当作下一个节点的剩余元素中再取一个，继续以上的步骤
整个流程中用到了几个数组
res：二维数组，用来保存已经生成的完整路径。这里要注意的是，ret在传递的时候使用了指针。保证函数内部对这个数组做改变的时候，外部也可以获取到相同的内容。容易引起问题的就是append操作，如果切片底层数组进行了扩容，那么这一次append对外部的这个切片是无效的。而我们一开始是不确定最后ret中会有多少路径的。
path：用来保存当前进度下的所有节点。注意这里函数返回的时候要将当前的元素去掉
visit：用来保存nums中每一个元素是否已经在路径中被使用。如果被使用了直接跳过。
————————————————
版权声明：本文为优快云博主「RRRagnaros」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/weixin_42609341/article/details/104435919

3. 代码

func permute(nums []int) [][]int {
    res := make([][]int,0)
    if len(nums) == 0 {
        return res
    }

    visit := make([]bool,len(nums))
    path := make([]int,0)
    
    dfs(nums,len(nums),0,visit,path,&res)
    return res
}

func dfs(nums []int, length int, depth int, visit []bool, path []int, res *[][]int) {
    if depth == length {
        tmp := make([]int, len(path))
        copy(tmp, path)
        *res = append(*res,tmp)
        return
    }

    for i := 0; i < length; i++ {
        if visit[i] == false {
            visit[i] = true
            path = append(path,nums[i])
            dfs(nums,length,depth+1,visit,path,res)
            visit[i] = false
            path = path[0:len(path)-1]
        }
    }
}

3.2. 二刷模板

func permute(nums []int) [][]int {
    var res [][]int
    var path []int
    used := make([]bool, len(nums))
    backtracking(nums, used, path, &res)
    return res
}


func backtracking(nums []int, used []bool, path []int, res *[][]int) {
    if len(path) == len(nums) {
        temp := make([]int, len(path))
        copy(temp, path)
        *res = append(*res, temp)
        return
    }
    for i := 0; i < len(nums); i++ {
        if used[i] == true {
            continue
        }
        used[i] = true
        path = append(path, nums[i])
        backtracking(nums, used, path, res)
        path = path[:len(path) - 1]
        used[i] = false
    }  
}