solve problem Permutations II

Author: P-ppc

README.md

@@ -225,6 +225,7 @@ All solutions will be accepted!
 |40|[Combination Sum II](https://leetcode-cn.com/problems/combination-sum-ii/description/)|[java/py/js](./algorithms/CombinationSumII)|Medium|
 |216|[Combination Sum III](https://leetcode-cn.com/problems/combination-sum-iii/description/)|[java/py/js](./algorithms/CombinationSumIII)|Medium|
 |46|[Permutations](https://leetcode-cn.com/problems/permutations/description/)|[java/py/js](./algorithms/Permutations)|Medium|
+|47|[Permutations II](https://leetcode-cn.com/problems/permutations-ii/description/)|[java/py/js](./algorithms/PermutationsII)|Medium|
 |77|[Combinations](https://leetcode-cn.com/problems/combinations/description/)|[java/py/js](./algorithms/Combinations)|Medium|
 
 # Database

algorithms/PermutationsII/README.md

@@ -0,0 +1,2 @@
+# Permutations II
+We can solve this proble by Backtracking Algorithm like [Combination Sum II](./CombinationSumII)

algorithms/PermutationsII/Solution.java

@@ -0,0 +1,31 @@
+class Solution {
+    public List<List<Integer>> permuteUnique(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        Arrays.sort(nums);
+        backTrack(nums, new ArrayList<Integer>(), res);
+        return res;
+    }
+    
+    public void backTrack(int[] nums, List<Integer> temp, List<List<Integer>> res) {
+        int length = nums.length;
+        if (length == 0) {
+            res.add(temp);
+        } else {
+            int i = 0;
+            while (i < length) {
+                int num = nums[i];
+                int[] tempNums = new int[length - 1];
+                System.arraycopy(nums, 0, tempNums, 0, i);
+                System.arraycopy(nums, i + 1, tempNums, i, length - 1 - i);
+                List<Integer> t = new ArrayList<Integer>(temp);
+                t.add(num);
+                
+                backTrack(tempNums, t, res);
+                while (i + 1 < length && nums[i + 1] == num) {
+                    i++;
+                }
+                i++;
+            }
+        }
+    }
+}

algorithms/PermutationsII/solution.js

@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permuteUnique = function(nums) {
+    let res = []
+    nums.sort()
+    backTrack(nums, [], res)
+    return res
+};
+
+var backTrack = function(nums, temp, res) {
+    if (nums.length === 0) {
+        res.push(temp)
+    } else {
+        let i = 0
+        while (i < nums.length) {
+            let num = nums[i],
+                tempNums = nums.slice(),
+                t = temp.slice()
+            
+            tempNums.splice(i, 1)
+            t.push(num)
+            backTrack(tempNums, t, res)
+            
+            while (i + 1 < nums.length && nums[i + 1] === num) {
+                i++
+            }
+            i++
+        }
+    }
+}

algorithms/PermutationsII/solution.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def permuteUnique(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        res = []
+        nums.sort()
+        self.backtrack(nums, [], res)
+        return res
+    
+    def backtrack(self, nums, temp, res):
+        if len(nums) == 0:
+            res.append(temp)
+        else:
+            i = 0
+            while i < len(nums):
+                num = nums[i]
+                temp_nums = nums[:]
+                temp_nums.remove(num)
+                t = temp[:]
+                t.append(num)
+                self.backtrack(temp_nums, t, res)
+                
+                while i + 1 < len(nums) and nums[i + 1] == num:
+                    i += 1
+                i += 1