Merge branch 'master' into parent

Author: ignacio-chiazzo

CoinChange.js

@@ -0,0 +1,161 @@
+/*
+
+https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/description/
+
+862. Shortest Subarray with Sum at Least K
+Return the length of the shortest, non-empty, contiguous subarray of A with sum at least K.
+
+If there is no non-empty subarray with sum at least K, return -1.
+
+ 
+
+Example 1:
+
+Input: A = [1], K = 1
+Output: 1
+Example 2:
+
+Input: A = [1,2], K = 4
+Output: -1
+Example 3:
+
+Input: A = [2,-1,2], K = 3
+Output: 3
+ 
+
+Note:
+
+1 <= A.length <= 50000
+-10 ^ 5 <= A[i] <= 10 ^ 5
+1 <= K <= 10 ^ 9
+*/
+
+
+/*
+Tree for solution
+
+
+                                           [pos, countOfNumbers, K]
+[pos + 1, countOfNumbers, K]   [pos + 1, countOfNumbers + 1, K - nums[pos]]   [pos, countOfNumbers + 1, K - nums[pos]]
+...
+
+                                                [0, 0, 11]  // [pos, countOfNumbers, K]
+                                /                   |                 \
+            [1, 0, 11]                          [1, 1, 10]                         [0, 1, 10]
+        /       |       \                     /     |     \                       /    |    \
+[2, 0, 11]  [2, 1, 9]  [1, 1, 9]     [2, 0, 10] [2, 2, 8] [1, 2, 8]     [1, 1, 10] [1, 2, 9] [0, 2, 9]
+...
+*/
+
+// Solution 3 
+var coinChange3 = function(coins, amount) {
+  var memo = [];
+
+  for(var i = 0; i <= amount; i++) {
+    memo[i] = Number.POSITIVE_INFINITY;
+  }
+  memo[0] = 0;
+
+  for(var i = 0; i < coins.length; i++) {
+    const coin = coins[i];
+    for(var j = coin; j < memo.length; j++) {
+      memo[j] = min2(memo[j], memo[j - coin] + 1);
+    }
+  }
+
+  return (memo[amount] == Number.POSITIVE_INFINITY) ? -1 : memo[amount];
+};
+
+var min2 = function(a, b) {
+  return (a < b) ? a : b;
+}
+
+
+// Solution 2
+var buildMemoKey = function(position, amount) {
+  return position + "-" + amount;
+}
+
+var coinChange2 = function(coins, amount) {
+  var memo = {};
+  var solution = coinChangeAux2(coins, amount, 0, memo, Number.POSITIVE_INFINITY);
+  return solution == Number.POSITIVE_INFINITY ? -1 : solution;
+};
+
+var coinChangeAux2 = function(coins, amount, pos, memo) {
+  var key = buildMemoKey(pos, amount);
+  if(memo[key]) {
+    return memo[key];
+  }
+  if(amount < 0) {
+    return Number.POSITIVE_INFINITY; 
+  } else if(amount == 0) {
+    return 0;
+  } else if(pos >= coins.length) {
+    return Number.POSITIVE_INFINITY;
+  }
+  
+  var left = coinChangeAux2(coins, amount, pos + 1, memo);
+  var middle = 1 + coinChangeAux2(coins, amount - coins[pos], pos + 1, memo);
+  var right = 1 + coinChangeAux2(coins, amount - coins[pos], pos, memo);
+  
+  var solution = min(left, middle, right);
+  memo[key] = solution;
+  return solution;
+}
+
+// Solution 1 naive
+var coinChange1 = function(coins, amount) {
+  var solution = coinChangeAux1(coins, amount, 0);
+  return solution == Number.POSITIVE_INFINITY ? -1 : solution;
+};
+
+var coinChangeAux1 = function(coins, amount, pos) {
+  if(amount < 0) {
+    return Number.POSITIVE_INFINITY; 
+  } else if(amount == 0) {
+    return 0;
+  } else if(pos >= coins.length) {
+    return Number.POSITIVE_INFINITY;
+  }
+  
+  var left = coinChangeAux1(coins, amount, pos + 1);
+  var middle = 1 + coinChangeAux1(coins, amount - coins[pos], pos + 1);
+  var right = 1 + coinChangeAux1(coins, amount - coins[pos], pos);
+  
+  var partialSol = min(left, middle, right);
+  return partialSol;
+}
+
+var min = function(a, b, c) {
+  if(a < b) { return (a < c) ? a : c };
+  return (b < c) ? b : c;
+}
+
+
+function main() {
+  console.log("-------------");
+  console.log("Approach 1")
+  console.log(coinChange1([], 3));
+  console.log(coinChange1([2], 3));
+  console.log(coinChange1([1, 2, 5], 11));
+  console.log(coinChange1([3,7,405,436], 8839));
+  // console.log(coinChange1([370,417,408,156,143,434,168,83,177,280,117], 9953)); takes forever
+
+  console.log("-------------");
+  console.log("Approach 2")
+  console.log(coinChange2([], 3));
+  console.log(coinChange2([2], 3));
+  console.log(coinChange2([1, 2, 5], 11));
+  console.log(coinChange2([3,7,405,436], 8839));
+  console.log(coinChange2([370,417,408,156,143,434,168,83,177,280,117], 9953));
+
+  console.log("-------------");
+  console.log("Approach 3")
+  console.log(coinChange3([], 3));
+  console.log(coinChange3([2], 3));
+  console.log(coinChange3([1, 2, 5], 11));
+  console.log(coinChange3([3,7,405,436], 8839));
+  console.log(coinChange3([370,417,408,156,143,434,168,83,177,280,117], 9953));
+}
+main();

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,20 @@ var permutationWithoutDuplicates = require("./PermutationsWithoutDuplicates.js")
 var permutationWithDuplicates = require("./PermutationsWithDuplicates.js");
 var subsets = require("./Subsets.js");
 var generateParentheses = require("./GenerateParentheses.js")
+var maximunSubarray = require("./MaximunSubarray.js");
+var coinChange = require("./CoinChange.js");
+var nQueens = require("./NQueens.js");
+var uniquePaths = require("./UniquePaths.js");
+var floodFill = require("./FloodFill.js")
 
 // Invocation
 
 // permutationWithoutDuplicates.main();
 // permutationWithDuplicates.main();
 // subsets.main();
-// generateParentheses.main();
+// generateParentheses.main();
+// maximunSubarray.main();
+// coinChange.main();
+// nQueens.main();
+// uniquePaths.main();
+// floodFill.main();

MaximunSubarray.js

@@ -0,0 +1,39 @@
+/*
+https://leetcode.com/problems/maximum-subarray/submissions/1
+
+. Maximum Subarray
+Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
+
+Example:
+
+Input: [-2,1,-3,4,-1,2,1,-5,4],
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+Follow up:
+
+*/
+
+var maxSubArray = function(nums) {
+  if(nums.length == 0) { return 0 };
+  var maxSub = nums[0];
+  var currentMax = nums[0];
+  
+  for(var i = 1; i < nums.length; i++) {
+    currentMax = max(nums[i], currentMax + nums[i]);
+    if(currentMax > maxSub) {
+      maxSub = currentMax;
+    }
+  }
+
+  return maxSub;
+};
+
+var max = function(i, j) {
+  return (i > j) ? i : j;
+}
+
+var main = function() {
+  console.log(maxSubArray([4,1,-1,4,5,6,7,-200]));
+}
+
+module.exports.main = main;

NQueens.js

@@ -0,0 +1,92 @@
+/* https://leetcode.com/problems/n-queens/description/
+
+Example:
+
+Input: 4
+Output: [
+ [".Q..",  // Solution 1
+  "...Q",
+  "Q...",
+  "..Q."],
+
+ ["..Q.",  // Solution 2
+  "Q...",
+  "...Q",
+  ".Q.."]
+]
+Explanation: There exist two distinct solutions to the 4-queens puzzle as shown above.
+*/
+
+/**
+ * @param {number} n
+ * @return {string[][]}
+ */
+var solveNQueens = function(n) {
+  var sol = [];
+  solveNQueensAux(n, 0, new Set(), new Set(), new Set(), [], sol);
+  return parseSolutions(sol, n);
+};
+
+var solveNQueensAux = function(n, row, diagonalDiffs, diagonalSums, cols, currentSol, sol) {
+  if(row == n) { 
+    sol.push(currentSol);  
+    return; 
+  }
+  
+  for(var i = 0; i < n; i++) {
+    const diagonalDiff = i - row;
+    const diagonalSum = i + row;
+    if(!diagonalDiffs.has(diagonalDiff) && !cols.has(i) && !diagonalSums.has(diagonalSum)) {
+      diagonalDiffs.add(diagonalDiff);
+      diagonalSums.add(diagonalSum);
+      cols.add(i);
+      solveNQueensAux(n, row + 1, diagonalDiffs, diagonalSums, cols, [...currentSol, ...[[row, i]]], sol);
+      cols.delete(i);
+      diagonalDiffs.delete(diagonalDiff);
+      diagonalSums.delete(diagonalSum);
+    }
+  }
+  return;
+}
+
+var parseSolutions = function(sols, n) {
+  var matrixes = [];
+  for(var i = 0; i < sols.length; i++) {
+    var sol = sols[i];
+    var matrix = [];
+    for(var row = 0; row < n; row++) {
+      matrix[row] = []
+      const queenPos = sol[row];
+      for(var col = 0; col < n; col++) {
+        matrix[row] += (queenPos[1] == col) ? "Q" : ".";
+      }
+    }
+
+    matrixes.push(matrix);
+  }
+
+  return matrixes;
+}
+
+var printMatrixes = function(matrixes, n) {
+  console.log("Start solution of n: " + n);
+  for(var i = 0; i < matrixes.length; i++) {
+    printMatrix(matrixes[i]);
+  }
+  console.log("End solution of n: " + n);
+}
+
+var printMatrix = function(matrix) {
+  console.log("------------");
+  for(var i = 0; i < matrix.length; i++) {
+    console.log(matrix[i]);
+  }
+  console.log("------------");
+}
+
+var main = function(n) {
+  printMatrixes(solveNQueens(4), 4);
+  printMatrixes(solveNQueens(5), 5);
+  printMatrixes(solveNQueens(6), 6);
+}
+main();