update some solutions

Author: chihungyu1116

26 Remove Duplicates from Sorted Array.js

@@ -1,21 +1,41 @@
+// Given a sorted array, remove the duplicates in place such that each element appear only once and return the new length.
+
+// Do not allocate extra space for another array, you must do this in place with constant memory.
+
+// For example,
+// Given input array nums = [1,1,2],
+
+// Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the new length.
+
+
 /**
- * @param {number[]} A
+ * @param {number[]} nums
  * @return {number}
  */
-var removeDuplicates = function(A) {
-    if(A === null){
+var removeDuplicates = function(nums) {
+    if(!nums || nums.length === 0) {
         return 0;
     }
+  
+    var end = 0;
 
-    var index = 1;
+    // index: 012345678
+    // vals:  111222333
+    // first swap happen when end = 0; i points at index 3 with val 2
+    // end++ becomes end points at index 1 and swap with index 3
+    // after that vals become:
+    // vals:  121122333
+    // i at at index 4 and end is at index 2
 
-    while(index < A.length){
-        if(A[index] === A[index - 1]){
-            A.splice(index, 1);
-        } else{
-            index++;    
+    for(var i = 1; i < nums.length; i++) {
+        if(nums[i] !== nums[end]) {
+            end++;
+            
+            if(i !== end) {
+                nums[end] = nums[i];
+            }
         }
     }
 
-    return A.length;
+    return end+1;
 };

286 Walls and Gates.js

@@ -1,73 +1,60 @@
-// https://segmentfault.com/a/1190000003906674
-
 // You are given a m x n 2D grid initialized with these three possible values.
 
 // -1 - A wall or an obstacle.
 // 0 - A gate.
-// INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647. Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.
-// For example, given the 2D grid:
+// INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647.
+// Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.
 
+// For example, given the 2D grid:
 // INF  -1  0  INF
 // INF INF INF  -1
 // INF  -1 INF  -1
-//   0  -1 INF INF 
+//   0  -1 INF INF
 // After running your function, the 2D grid should be:
-
 //   3  -1   0   1
 //   2   2   1  -1
 //   1  -1   2  -1
 //   0  -1   3   4
+// Hide Company Tags Google Facebook
+// Show Tags
+// Show Similar Problems
+
 
 
-public class Solution {
-    public void wallsAndGates(int[][] rooms) {
-        if(rooms.length == 0) return;
-        for(int i = 0; i < rooms.length; i++){
-            for(int j = 0; j < rooms[0].length; j++){
-                // 如果遇到一个门，从门开始广度优先搜索，标记连通的节点到自己的距离
-                if(rooms[i][j] == 0) bfs(rooms, i, j);
+var wallsAndGates = function(rooms) {
+    var gates = [];
+    
+    if(!rooms || rooms.length === 0) {
+        return;
+    }
+    
+    var rows = rooms.length;
+    var cols = rooms[0].length;
+    
+    // find all gates
+    for(var i = 0; i < rows; i++) {
+        for(var j = 0; j < cols; j++) {
+            if(rooms[i][j] === 0) {
+                gates.push([i, j]);
             }
         }
     }
 
-    public void bfs(int[][] rooms, int i, int j){
-        Queue<Integer> queue = new LinkedList<Integer>();
-        queue.offer(i * rooms[0].length + j);
-        int dist = 0;
-        // 用一个集合记录已经访问过的点
-        Set<Integer> visited = new HashSet<Integer>();
-        visited.add(i * rooms[0].length + j);
-        while(!queue.isEmpty()){
-            int size = queue.size();
-            // 记录深度的搜索
-            for(int k = 0; k < size; k++){
-                Integer curr = queue.poll();
-                int row = curr / rooms[0].length;
-                int col = curr % rooms[0].length;
-                // 选取之前标记的值和当前的距离的较小值
-                rooms[row][col] = Math.min(rooms[row][col], dist);
-                int up = (row - 1) * rooms[0].length + col;
-                int down = (row + 1) * rooms[0].length + col;
-                int left = row * rooms[0].length + col - 1;
-                int right = row * rooms[0].length + col + 1;
-                if(row > 0 && rooms[row - 1][col] > 0 && !visited.contains(up)){
-                    queue.offer(up);
-                    visited.add(up);
-                }
-                if(col > 0 && rooms[row][col - 1] > 0 && !visited.contains(left)){
-                    queue.offer(left);
-                    visited.add(left);
-                }
-                if(row < rooms.length - 1 && rooms[row + 1][col] > 0 && !visited.contains(down)){
-                    queue.offer(down);
-                    visited.add(down);
-                }
-                if(col < rooms[0].length - 1 && rooms[row][col + 1] > 0 && !visited.contains(right)){
-                    queue.offer(right);
-                    visited.add(right);
-                }
-            }
-            dist++;
+    // starting from all gates and traverse
+    for(i = 0; i < gates.length; i++) {
+        var gate = gates[i];
+        traverse(rooms, gate[0], gate[1], rows, cols, 0);
+    }
+};
+
+function traverse(rooms, i, j, rows, cols, dist) {
+    if(i >= 0 && i < rows && j >= 0 && j < cols) {
+        if(rooms[i][j] !== -1 && rooms[i][j] >= dist) {
+            rooms[i][j] = dist;
+            traverse(rooms, i + 1, j, rows, cols, dist + 1);
+            traverse(rooms, i, j + 1, rows, cols, dist + 1);
+            traverse(rooms, i - 1, j, rows, cols, dist + 1);
+            traverse(rooms, i, j - 1, rows, cols, dist + 1);
         }
     }
 }