LeetCode Online Judge 题目C# 练习 - Permutations

Given a collection of numbers, return all possible permutations.
For example,
[1,2,3] have the following permutations:
[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

        public static List<List<int>> Permutation(List<int> num)
        {
            List<List<int>> ret = new List<List<int>>();
            PermutationHelper(ret, num, 0);
            return ret;
        }

        public static void PermutationHelper(List<List<int>> ret, List<int> num, int index)
        {
            if (index == num.Count - 1)
                ret.Add(new List<int>(num));
            else
            {
                for (int i = index; i < num.Count; i++)
                {
                    PermutationSwap(num, index, i);
                    PermutationHelper(ret, num, index + 1);
                    PermutationSwap(num, index, i); //remember this!!!
                }
            }
        }

        public static void PermutationSwap(List<int> num, int i, int j)
        {
            int temp = num[i];
            num[i] = num[j];
            num[j] = temp;
        }

代码分析：

　　这也应该是必须复习的题目了，求所有的排列组合。

　　这个是递归的做法，思想是把每一个元素都放到第一个位置（做法是第一个元素与所有后面的元素都交换一次，当然第一次是跟自己交换），然后递归下去求从第二个位置开始的所以排列组合。

　　例如：

　　

　　记住要递归玩之后swap back，不然就乱了套，结果会出现重复。

　　复习的时候想应该有DP的做法。

　　

        public static List<List<int>> PermutationDP(List<int> num)
        {
            if (num.Count == 0)
                return null;

            List<List<int>> curr = new List<List<int>>();
            List<List<int>> next = new List<List<int>>();

            curr.Add(new List<int> { num[0] });
            for (int i = 1; i < num.Count; i++)
            {
                for (int p = 0; p < curr.Count; p++)
                {
                    List<int> temp = new List<int>(curr[p]);
                    int temp_count = temp.Count;
                    for (int k = 0; k <= temp_count; k++)
                    {
                        temp.Insert(k, num[i]);
                        next.Add(new List<int>(temp));
                        temp.RemoveAt(k);
                    }
                }
                PermutationDPSwap(ref curr, ref next);
                next.Clear();
            }

            return curr;
        }

        public static void PermutationDPSwap(ref List<List<int>> curr, ref List<List<int>> next)
        {
            List<List<int>> temp;
            temp = curr;
            curr = next;
            next = temp;
        }

代码分析：

　　DP的做法

　　例如：

　　1，2，3

　　1 的 所有排列组合 ： 1

　　1， 2 的所有排列组合 = （2，1）， （1，2) 。 就是用2加到之前所有排列组合的前面， 插入到每个元素之间 (这里没有），加到后面。

　　1，2， 3 的所有排列组合 = （3，2，1）前面， （2，3，1）之间， （2，1，3）后面， （3，1，2）前面， （1，3，2）之间， (1，2，3) 后面

　　......

　　感觉嘛。DP好像好懂，可能是我脑子对递归的抗拒，老觉得自己写不出来递归。在这个CASE， 递归的performance比DP好，可能是因为List的Insert 和 RemoveAt都比较耗性能的，虽然到了11个元素大家都out of memory了。

　　这里学习到一个东西。C#里面虽然List<List<int>>之类的reference type 传参的时候是pass by reference， 但是其实是一个reference 的copy，

　　analogous passing a pointer to the object, the pointer get copied, 所以这一调换 curr 和 next 的位置的时候，要用ref 关键字。