Merge branch 'master' of https://github.com/doocs/leetcode

Author: EndaLin

solution/0063.Unique Paths II/Solution2.java

@@ -0,0 +1,42 @@
+class Solution {
+    public int uniquePathsWithObstacles(int[][] dp) {
+        if (dp[0][0] == 1 || dp[dp.length - 1][dp[0].length - 1] == 1) return 0;
+        for (int i = 1; i < dp.length; i ++) {
+            if (dp[i][0] == 1) {
+                dp[i][0] = -1;
+                continue;
+            }
+            if (dp[i - 1][0] == -1) {
+                dp[i][0] = -1;
+            } else dp[i][0] = 1;
+        }
+        for (int i = 1; i < dp[0].length; i ++) {
+            if (dp[0][i] == 1) {
+                dp[0][i] = -1;
+                continue;
+            }
+            if (dp[0][i - 1] == -1) {
+                dp[0][i] = -1;
+            } else dp[0][i] = 1;
+        }
+        for (int i = 1; i < dp.length; i ++) {
+            for (int j = 1; j < dp[0].length; j ++) {
+                if (dp[i][j] == 1) {
+                    dp[i][j] = -1;
+                } else if (dp[i][j - 1] == -1 && dp[i - 1][j] == -1) {
+                    dp[i][j] = -1;
+                } else if (dp[i][j - 1] == -1) {
+                    dp[i][j] = dp[i - 1][j];
+                } else if (dp[i - 1][j] == -1) {
+                    dp[i][j] = dp[i][j - 1];
+                } else {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        int res = dp[dp.length - 1][dp[0].length - 1];
+        if (res == 0) return 1;
+        if (res == -1) return 0;
+        return res;
+    }
+}

solution/1346. Check If N and Its Double Exist/README_EN.md

@@ -0,0 +1,37 @@
+# Check If N and Its Double Exist
+
+Given an array arr of integers, check if there exists two integers N and M such that N is the double of M ( i.e. N = 2 * M).
+
+More formally check if there exists two indices i and j such that :
+* i != j
+* 0 <= i, j < arr.length
+* arr[i] == 2 * arr[j]
+
+## Example 1:
+```
+    Input: arr = [10,2,5,3]
+    Output: true
+    Explanation: N = 10 is the double of M = 5,that is, 10 = 2 * 5.
+ 
+```
+
+## Example 2:
+```
+    Input: arr = [7,1,14,11]
+    Output: true
+    Explanation: N = 14 is the double of M = 7,that is, 14 = 2 * 7.
+
+```
+
+## Example 3:
+```
+    Input: arr = [3,1,7,11]
+    Output: false
+    Explanation: In this case does not exist N and M, such that N = 2 * M.
+    
+```
+
+
+## Constraints:
+   * 2 <= arr.length <= 500
+   * -10^3 <= arr[i] <= 10^3

solution/1346. Check If N and Its Double Exist/Solution.java

@@ -0,0 +1,15 @@
+import java.util.*;
+
+class Solution {
+    public boolean checkIfExist(int[] arr) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < arr.length; i++) {
+            map.put(arr[i], i);
+        }
+        for (int i = 0; i < arr.length; i++) {
+            if (map.containsKey(arr[i] * 2) && i != map.get(arr[i] * 2))
+                return true;
+        }
+        return false;
+    }
+}

solution/1347. Minimum Number of Steps to Make Two Strings Anagram/README_EN.md

@@ -0,0 +1,37 @@
+# Minimum Number of Steps to Make Two Strings Anagram
+
+Given two equal-size strings s and t. In one step you can choose any character of t and replace it with another character.
+
+Return the minimum number of steps to make t an anagram of s.
+
+An Anagram of a string is a string that contains the same characters with a different (or the same) ordering.
+
+## Example 1:
+```
+    Input: s = "bab", t = "aba"
+    Output: 1
+    Explanation: Replace the first 'a' in t with b, t = "bba" which is anagram of s.
+ 
+```
+
+## Example 2:
+```
+    Input: s = "leetcode", t = "practice"
+    Output: 5
+    Explanation: Replace 'p', 'r', 'a', 'i' and 'c' from t with proper characters to make t anagram of s.
+
+```
+
+## Example 3:
+```
+    Input: s = "anagram", t = "mangaar"
+    Output: 0
+    Explanation: "anagram" and "mangaar" are anagrams. 
+    
+```
+
+
+## Constraints:
+   * 1 <= s.length <= 50000
+   * s.length == t.length
+   * s and t contain lower-case English letters only.

solution/1347. Minimum Number of Steps to Make Two Strings Anagram/Solution.java

@@ -0,0 +1,19 @@
+import java.util.*;
+
+class Solution {
+    public int minSteps(String s, String t) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            if (map.containsKey(c)) {
+                map.put(c, map.get(c) + 1);
+            } else map.put(c, 1);
+        }
+        int res = 0;
+        for (char c : s.toCharArray()) {
+            if (map.containsKey(c) && map.get(c) > 0) {
+                map.put(c, map.get(c) - 1);
+            } else res ++;
+        }
+        return res;
+    }
+}