leetcode46

public class Solution {
    public IList<IList<int>> Permute(int[] nums)
        {
            IList<IList<int>> result = new List<IList<int>>();
            permute(result, nums, );
            return result;
        }

        private void permute(IList<IList<int>> result, int[] array, int start)
        {
            if (start >= array.Length)
            {
                List<int> current = new List<int>();
                foreach (int a in array)
                {
                    current.Add(a);
                }
                result.Add(current);
            }
            else
            {
                for (int i = start; i < array.Length; i++)
                {
                    swap(array, start, i);
                    permute(result, array, start + );
                    swap(array, start, i);
                }
            }
        }

        private void swap(int[] array, int i, int j)
        {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
}

https://leetcode.com/problems/permutations/#/solutions

经过学习和思考，采用另一种写法实现。更容易理解

public class Solution
    {
        List<IList<int>> list = new List<IList<int>>();
        int N;
        private void BackTrack(List<int> records, List<int> save, int t)
        {
            if (t >= N)
            {
                var temp = new int[N];
                save.CopyTo(temp);
                list.Add(temp.ToList());
                return;
            }

            for (int i = ; i < records.Count; i++)
            {
                var current = records[i];
                save.Add(current);
                var notsave = records.Where(x => x != current).ToList();
                BackTrack(notsave, save, t + );
                save.Remove(current);
            }
        }

        public IList<IList<int>> Permute(int[] nums)
        {
            N = nums.Length;//初始化最大范围
            var records = nums.ToList();
            var save = new List<int>();
            BackTrack(records, save, );
            return list;
        }
    }

补充一个python的实现：

 class Solution:
     def dfs(self,nums,n,path,l,visited):
         if len(path) == n:
             l.append(path[:])
         else:
             if nums != None:
                 for i in range(len(nums)):
                     if visited[i] == :
                         continue
                     path.append(nums[i])
                     visited[i] =
                     self.dfs(nums,n,path,l,visited)
                     visited[i] =
                     path.pop(-)

     def permute(self, nums: 'List[int]') -> 'List[List[int]]':
         n = len(nums)
         path = list()
         l = list()
         visited = [] * n
         self.dfs(nums,n,path,l,visited)
         return l