Merge branch 'master' into n-queens

Author: ignacio-chiazzo

FloodFill.js

@@ -0,0 +1,59 @@
+/*
+https://leetcode.com/problems/flood-fill/description/
+
+An image is represented by a 2-D array of integers, each integer representing the pixel value of the image (from 0 to 65535).
+
+Given a coordinate (sr, sc) representing the starting pixel (row and column) of the flood fill, and a pixel value newColor, "flood fill" the image.
+
+To perform a "flood fill", consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), and so on. Replace the color of all of the aforementioned pixels with the newColor.
+
+At the end, return the modified image.
+
+Example 1:
+Input: 
+image = [[1,1,1],[1,1,0],[1,0,1]]
+sr = 1, sc = 1, newColor = 2
+Output: [[2,2,2],[2,2,0],[2,0,1]]
+Explanation: 
+From the center of the image (with position (sr, sc) = (1, 1)), all pixels connected 
+by a path of the same color as the starting pixel are colored with the new color.
+Note the bottom corner is not colored 2, because it is not 4-directionally connected
+to the starting pixel.
+Note:
+
+The length of image and image[0] will be in the range [1, 50].
+The given starting pixel will satisfy 0 <= sr < image.length and 0 <= sc < image[0].length.
+The value of each color in image[i][j] and newColor will be an integer in [0, 65535].
+
+*/
+
+var floodFill = function(image, sr, sc, newColor) {
+  var oldColor = image[sr][sc];
+  
+  if(newColor == oldColor) {
+      return image;
+  }
+  
+  image[sr][sc] = newColor;
+  
+  if(sr > 0 && image[sr - 1][sc] == oldColor) {
+      floodFill(image, sr - 1, sc, newColor);    //Left
+  }
+  if(sc > 0 && image[sr][sc - 1] == oldColor) {
+      floodFill(image, sr, sc - 1, newColor);   //Up
+  }
+  if(sr < image.length - 1 && image[sr + 1][sc] == oldColor) {
+      floodFill(image, sr + 1, sc, newColor);    //Down
+  }
+  if(sc < image[0].length - 1 && image[sr][sc + 1] == oldColor) {
+      floodFill(image, sr, sc + 1, newColor);    // Right
+  }
+  return image;
+};
+
+
+function main() {
+  console.log(floodFill([[1,1,1],[1,1,0],[1,0,1]], 1, 1, 2))
+}
+
+module.exports.main = main;

Main.js

@@ -3,10 +3,14 @@ var permutationWithoutDuplicates = require("./PermutationsWithoutDuplicates.js")
 var permutationWithDuplicates = require("./PermutationsWithDuplicates.js");
 var subsets = require("./Subsets.js");
 var nQueens = require("./NQueens.js");
+var uniquePaths = require("./UniquePaths.js");
+var floodFill = require("./FloodFill.js")
 
 // Invocation
 
 // permutationWithoutDuplicates.main();
 // permutationWithDuplicates.main();
 // subsets.main();
 // nQueens.main();
+// uniquePaths.main();
+// floodFill.main();

UniquePaths.js

@@ -0,0 +1,105 @@
+/*
+
+62. Unique Paths 
+https://leetcode.com/problems/unique-paths/description/
+
+A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+How many possible unique paths are there?
+
+Example 1:
+
+Input: m = 3, n = 2
+Output: 3
+Explanation:
+From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+1. Right -> Right -> Down
+2. Right -> Down -> Right
+3. Down -> Right -> Right
+Example 2:
+
+Input: m = 7, n = 3
+Output: 28
+
+*/
+
+// Solution 1
+// This solution is a naive solution implementing a binary tree and visiting each node.
+
+var uniquePaths1 = function(m, n) {
+  return uniquePathsAux(0, 0, m, n)
+};
+
+var uniquePathsAux = function(row, col, rowLength, colLength) {
+  if(row >= rowLength || col >= colLength) {
+    return 0;
+  }
+  if(row == rowLength - 1 && col == colLength - 1) {
+    return 1;
+  }
+  
+  return uniquePathsAux(row + 1, col, rowLength, colLength) + 
+    uniquePathsAux(row, col + 1, rowLength, colLength)
+};
+
+// Solution 2
+// This solution is solution 1 but memoized.
+var uniquePaths2 = function(m, n) {
+  var memo = {};
+  return uniquePathsAux2(0, 0, m, n, memo)
+};
+
+var uniquePathsAux2 = function(row, col, rowLength, colLength, memo) {
+  if(memo[memoKey(row, col)]) {
+    return memo[row + "-" + col];
+  }
+  if(row >= rowLength || col >= colLength) {
+    return 0;
+  }
+  if(row == rowLength - 1 && col == colLength - 1) {
+    return 1;
+  }
+  
+  var result = uniquePathsAux(row + 1, col, rowLength, colLength, memo) + 
+    uniquePathsAux(row, col + 1, rowLength, colLength, memo);
+  memo[memoKey(row, col)] = result;
+  return result;
+};
+
+var memoKey = function(row, col) {
+  return row + "-" + col;
+}
+
+// Solution 3
+// This solution uses Dinamic Programming
+var uniquePaths3 = function(m, n) {
+  var matrix = [];
+  for(var i = 0; i < m; i++) {
+    matrix[i] = [];
+    for(var j = 0; j < n; j++) {
+      if(i == 0 || j == 0) {
+        matrix[i][j] = 1;
+      } else{
+        matrix[i][j] = 0;   
+      }
+    }
+  }
+  
+  for(var row = 1; row < m; row++) {
+    for(var col = 1; col < n; col++) {
+      matrix[row][col] = matrix[row - 1][col] + matrix[row][col - 1]
+    }
+  }
+
+  return matrix[m - 1][n - 1];
+};
+
+var main = function() {
+  console.log(uniquePaths1(10,4));
+  console.log(uniquePaths2(10,4));
+  console.log(uniquePaths3(10,4));
+}
+
+module.exports.main = main;