update

Author: CongLinDev

0045-跳跃游戏 II.md

@@ -39,4 +39,4 @@ class Solution {
         return step;
     }
 }
-```
+```

0046-全排列.md

@@ -30,14 +30,13 @@ public class Solution {
         dfs(nums, 0, results);
         return results;
     }
-    
+
     private void swap(int[] nums, int i, int j) {
         int temp = nums[i];
         nums[i] = nums[j];
         nums[j]  = temp;
     }
-    
-    
+
     private void dfs(int[] nums, int l, List<List<Integer>> results) {
         if (l == nums.length) {
             List<Integer> result = new ArrayList<Integer>();
@@ -46,12 +45,12 @@ public class Solution {
             }
             results.add(result);
         }
-        
+
         for (int i = l; i < nums.length; i++) {
             swap(nums, l, i);
             dfs(nums, l+1, results);
             swap(nums, l, i);
         }
     }
 }
-```
+```

0047-全排列 II.md

@@ -0,0 +1,55 @@
+# 全排列 II
+
+## 题目描述
+
+给定一个可包含重复数字的序列，返回所有不重复的全排列。
+
+```
+输入: [1,1,2]
+输出:
+[
+  [1,1,2],
+  [1,2,1],
+  [2,1,1]
+]
+```
+
+## 分析
+
+1. 在开始回溯算法之前，对数组进行一次排序操作，这是上面多次提到的；
+2. 在进入一个新的分支之前，看一看这个数是不是和之前的数一样，如果这个数和之前的数一样，并且之前的数还未使用过，那接下来如果走这个分支，就会使用到之前那个和当前一样的数，就会发生重复，此时分支和之前的分支一模一样。
+
+## 算法
+
+```java
+class Solution {
+    private List<List<Integer>> lists = new ArrayList<>();
+
+    public List<List<Integer>> permuteUnique(int[] nums) {
+        if(nums == null || nums.length == 0) return lists;
+        Arrays.sort(nums);
+        dfs(new LinkedList<Integer>(), nums, new boolean[nums.length]);
+        return lists;
+    }
+
+    private void dfs(LinkedList<Integer> list, int[] nums, boolean[] used){
+        if(nums.length == list.length()){
+            lists.add(new ArrayList<Integer>(list));
+            return;
+        }
+
+        for(int i = 0; i < nums.length; i++){
+            if(!used[i]){
+                if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
+                    continue;
+                }
+                used[i] = true;
+                list.addLast(nums[i]);
+                dfs(list, nums, used);
+                list.removeLast();
+                used[i] = false;
+            }
+        }
+    }
+}
+```

0239-滑动窗口最大值.md

@@ -0,0 +1,53 @@
+# 滑动窗口最大值
+
+## 题目描述
+
+给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
+
+返回滑动窗口中的最大值。
+
+## 分析
+
+使用一个双端链表保存数组的索引值。每次向链表中添加元素时保证以下操作即可在链表首端得到当前窗口的最大值的**索引**：
+
+* 观察链表尾端的索引对应的值是否大于欲入链表索引对应的值，若是则加入链表尾端。若不是将尾端的索引移除，继续比较，直到满足大于条件，然后将欲入链表索引加入链表尾端。
+* 计算出链表尾端的索引和链表首端的索引差值是否大于等于窗口大小，若是则将首端元素移除，反之不做任何操作。
+
+此时链表的首端元素即为该窗口下最大的元素的索引。
+
+## 算法
+
+```java
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        if(k == 0 || nums == null || nums.length == 0) return new int[0];
+        if(k == 1) return nums;
+
+        LinkedList<Integer> list = new LinkedList<>();
+        int []result = new int[nums.length - k + 1];
+
+        for(int i = 0; i < k; i++){
+            add(list, nums, i, k);
+        }
+
+        for(int i = 0; i < result.length; i++){
+            result[i] = add(list, nums, k + i - 1, k);
+        }
+        return result;
+    }
+
+    private int add(LinkedList<Integer> list, int[] nums, int index, int k){
+        Integer i;
+
+        while((i = list.peekLast()) != null && nums[i] < nums[index]){
+            list.pollLast();
+        }
+
+        list.offerLast(index);
+
+        if(index - list.getFirst() >= k) list.pollFirst();
+
+        return nums[list.peekFirst()];
+    }
+}
+```

0283-移动零.md

@@ -0,0 +1,28 @@
+# 移动零
+
+## 题目描述
+
+给定一个数组 `nums`，编写一个函数将所有 `0` 移动到数组的末尾，同时保持非零元素的相对顺序。
+
+## 分析
+
+如果一个数为零，则利用后面一位非零的值代替0的位置，最后循环补零就行了。
+
+## 算法
+
+```java
+class Solution {
+    public void moveZeroes(int[] nums) {
+        int index = 0;
+
+        for(int i = 0; i < nums.length; i++){
+            if(nums[i] != 0)
+                nums[index++] = nums[i];
+        }
+
+        for(int i = index; i < nums.length; i++){
+            nums[i] = 0;
+        }
+    }
+}
+```

0292-Nim 游戏.md

@@ -0,0 +1,28 @@
+# Nim 游戏
+
+## 题目描述
+
+你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。
+
+你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。
+
+```
+输入: 4
+输出: false
+解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；
+     因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。
+```
+
+## 分析
+
+巴什博奕，`n%(m+1)!=0` 时，先手总是会赢的。
+
+## 算法
+
+```java
+class Solution {
+    public boolean canWinNim(int n) {
+        return (n & 3) != 0;
+    }
+}
+```