Feng2012
diff --git a/‎src/0046.Permutations/README.md
Lines changed: 6 additions & 3 deletions b/‎src/0046.Permutations/README.md
Lines changed: 6 additions & 3 deletions
diff --git a/‎src/0046.Permutations/Solution.go
Lines changed: 30 additions & 2 deletions b/‎src/0046.Permutations/Solution.go
Lines changed: 30 additions & 2 deletions
diff --git a/‎src/0046.Permutations/Solution_test.go
Lines changed: 16 additions & 10 deletions b/‎src/0046.Permutations/Solution_test.go
Lines changed: 16 additions & 10 deletions
@@ -23,13 +23,16 @@ Output: "10101"
 **Tags:** Math, String
 
 ## 题意
->给你两个二进制串，求其和的二进制串。
+>给出一列互不相同的整数，返回其全排列
 
 ## 题解
 
 ### 思路1
-> 按照小学算数那么来做，用 `carry` 表示进位，从后往前算，依次往前，每算出一位就插入到最前面即可，直到把两个二进制串都遍历完即可。
-
+> 我们从前往后，一位一位枚举，每次选择一个没有被使用过的数。
+  选好之后，将该数的状态改成“已被使用”，同时将该数记录在相应位置上，然后递归。
+  递归返回时，不要忘记将该数的状态改成“未被使用”，并将该数从相应位置上删除。
+  
+  时间复杂度分析：搜索树中最后一层共 n!n! 个节点，前面所有层加一块的节点数量相比于最后一层节点数是无穷小量，可以忽略。且最后一层节点记录方案的计算量是 O(n)O(n)，所以总时间复杂度是 O(n×n!)O(n×n!)。
 ```go
 
 ```
 
@@ -1,5 +1,33 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+var ans [][]int
+var visit []bool
+
+func permute(nums []int) [][]int {
+
+	ans = [][]int{}
+	visit = make([]bool, len(nums))
+	dfs(nums, []int{})
+	return ans
+}
+
+func dfs(nums []int, curr []int) {
+	if len(curr) == len(nums) {
+		temp := make([]int, len(curr))
+		copy(temp, curr)
+		ans = append(ans, temp)
+		return
+	}
+
+	for idx, num := range nums {
+		if !visit[idx] {
+			curr = append(curr, num)
+			visit[idx] = true
+
+			dfs(nums, curr)
+
+			visit[idx] = false
+			curr = curr[:len(curr)-1]
+		}
+	}
 }
@@ -2,28 +2,34 @@ package Solution
 
 import (
 	"reflect"
+	"strconv"
 	"testing"
 )
 
 func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs []int
+		expect [][]int
 	}{
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", false, false},
+		{"TestCase", []int{1, 1, 2}, [][]int{
+			{1, 1, 2},
+			{1, 2, 1},
+			{1, 1, 2},
+			{1, 2, 1},
+			{2, 1, 1},
+			{2, 1, 1},
+		}},
 	}
 
 	//	开始测试
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			ret := Solution(c.inputs)
-			if !reflect.DeepEqual(ret, c.expect) {
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := permute(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
 				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, ret, c.inputs)
+					c.expect, got, c.inputs)
 			}
 		})
 	}