Find the Safest Path in a Grid - BFS & Binary Search, BFS & Dijkstra's [JS]

By on

Description 

Solution 1: BFS & Binary Search

  1. Use multi-source BFS to find each cell's minimum distance to a thief. We start the BFS at the thief cells and expand outwards.
  2. Binary search for the maximum possible minSafeness factor.
    To check whether a minSafeness is possible, use BFS to check whether there exists a valid path from (0, 0) to (n-1, n-1) using only cells with safeness >= minSafeness.

Time Complexity: O(n^2 log(n^2)) 512ms
Space Complexity: O(n^2) 91.4MB

var maximumSafenessFactor = function(grid) {
  let safeness = getSafeness(grid), n = grid.length;
  let low = 0, high = n * n;
  while (low < high) {
    let mid = Math.ceil((low + high) / 2);
    if (isEnough(safeness, mid)) low = mid;
    else high = mid - 1;
  }
  return low;
};

function isEnough(safeness, minSafeness) { // use bfs to check whether a valid path exists using only cells with safeness >= minSafeness
  let n = safeness.length, directions = [[-1, 0], [0, 1], [1, 0], [0, -1]];
  if (safeness[0][0] < minSafeness || safeness[n - 1][n - 1] < minSafeness) return false;
  let seen = Array(n).fill(0).map(() => Array(n).fill(false));
  let queue = [[0, 0]];
  seen[0][0] = true;
  while (queue.length) {
    let [row, col] = queue.shift();
    if (row === n - 1 && col === n - 1) return true;
    for (let [x, y] of directions) {
      let newRow = row + x, newCol = col + y;
      if (newRow < 0 || newRow >= n || newCol < 0 || newCol >= n) continue; // out of bounds
      if (seen[newRow][newCol] || safeness[newRow][newCol] < minSafeness) continue; // already visited or safeness is lower than the minimum safeness
      seen[newRow][newCol] = true;
      queue.push([newRow, newCol]);
    }
  }
  return false;
}

function getSafeness(grid) { // use multi-source level-by-level BFS to compute each cell's minimum distance to a thief
  const directions = [[-1, 0], [0, 1], [1, 0], [0, -1]];
  let n = grid.length, queue = [];
  let safeness = Array(n).fill(0).map(() => Array(n).fill(Infinity));
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < n; j++) {
      if (grid[i][j] === 1) { 
        safeness[i][j] = 0;
        queue.push([i, j]);
      }
    }
  }
  let steps = 1;
  while (queue.length) {
    let next = [];
    while (queue.length) {
      let [row, col] = queue.pop();
      for (let [x, y] of directions) {
        let newRow = row + x, newCol = col + y;
        if (newRow < 0 || newRow >= n || newCol < 0 || newCol >= n) continue;
        if (safeness[newRow][newCol] !== Infinity) continue; // visited already
        safeness[newRow][newCol] = steps;
        next.push([newRow, newCol]);
      }
    }
    queue = next;
    steps++;
  }
  return safeness;
}

Solution 2: BFS & Dijkstra's Algorithm

  1. Use multi-source BFS to find each cell's minimum distance to a thief. We start the BFS at the thief cells and expand outwards.
  2. Use dijkstra's algorithm to find the maximum minimum safeness factor.
  • Use a max heap to keep track of the cell's and their current safeness.
  • maxSafeness[row][col] = maximum minimum safeness from (0, 0) to (row, col).

Time Complexity: O(n^2 log(n^2)) 408ms
Space Complexity: O(n^2) 90.2MB

var maximumSafenessFactor = function(grid) {
  const directions = [[-1, 0], [0, 1], [1, 0], [0, -1]];
  let safeness = getSafeness(grid), n = grid.length;
  let heap = new Heap((a, b) => b[2] - a[2]); // sort by safeness in desc order
  let maxSafeness = Array(n).fill(0).map(() => Array(n).fill(-1));
  heap.add([0, 0, safeness[0][0]]);
  maxSafeness[0][0] = safeness[0][0];
  while (!heap.isEmpty()) {
    let [row, col, minSafeness] = heap.remove();
    if (maxSafeness[row][col] > minSafeness) continue;
    if (row === n - 1 && col === n - 1) return minSafeness;
    
    for (let [x, y] of directions) {
      let newRow = row + x, newCol = col + y;
      if (newRow < 0 || newRow >= n || newCol < 0 || newCol >= n) continue; // out of bounds
      let newMinSafeness = Math.min(minSafeness, safeness[newRow][newCol]);
      if (maxSafeness[newRow][newCol] < newMinSafeness) {
        maxSafeness[newRow][newCol] = newMinSafeness;
        heap.add([newRow, newCol, newMinSafeness]);
      }
    }
  }
};

function getSafeness(grid) { // use multi-source level-by-level BFS to compute each cell's minimum distance to a thief
  const directions = [[-1, 0], [0, 1], [1, 0], [0, -1]];
  let n = grid.length, queue = [];
  let safeness = Array(n).fill(0).map(() => Array(n).fill(Infinity));
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < n; j++) {
      if (grid[i][j] === 1) { 
        safeness[i][j] = 0;
        queue.push([i, j]);
      }
    }
  }
  let steps = 1;
  while (queue.length) {
    let next = [];
    while (queue.length) {
      let [row, col] = queue.pop();
      for (let [x, y] of directions) {
        let newRow = row + x, newCol = col + y;
        if (newRow < 0 || newRow >= n || newCol < 0 || newCol >= n) continue;
        if (safeness[newRow][newCol] !== Infinity) continue; // visited already
        safeness[newRow][newCol] = steps;
        next.push([newRow, newCol]);
      }
    }
    queue = next;
    steps++;
  }
  return safeness;
}

class Heap {
  constructor(comparator = ((a, b) => a - b)) {
    this.values = [];
    this.comparator = comparator;
    this.size = 0;
  }
  add(val) {
    this.size++;
    this.values.push(val);
    let idx = this.size - 1, parentIdx = Math.floor((idx - 1) / 2);
    while (parentIdx >= 0 && this.comparator(this.values[parentIdx], this.values[idx]) > 0) {
      [this.values[parentIdx], this.values[idx]] = [this.values[idx], this.values[parentIdx]];
      idx = parentIdx;
      parentIdx = Math.floor((idx - 1) / 2);
    }
  }
  remove() {
    if (this.size === 0) return -1;
    this.size--;
    if (this.size === 0) return this.values.pop();
    let removedVal = this.values[0];
    this.values[0] = this.values.pop();
    let idx = 0;
    while (idx < this.size && idx < Math.floor(this.size / 2)) {
      let leftIdx = idx * 2 + 1, rightIdx = idx * 2 + 2;
      if (rightIdx === this.size) {
        if (this.comparator(this.values[leftIdx], this.values[idx]) > 0) break;
        [this.values[leftIdx], this.values[idx]] = [this.values[idx], this.values[leftIdx]];
        idx = leftIdx;
      } else if (this.comparator(this.values[leftIdx], this.values[idx]) < 0 || this.comparator(this.values[rightIdx], this.values[idx]) < 0) {
        if (this.comparator(this.values[leftIdx], this.values[rightIdx]) <= 0) {
          [this.values[leftIdx], this.values[idx]] = [this.values[idx], this.values[leftIdx]];
          idx = leftIdx;
        } else {
          [this.values[rightIdx], this.values[idx]] = [this.values[idx], this.values[rightIdx]];
          idx = rightIdx;
        }
      } else {
        break;
      }
    }
    return removedVal;
  }
  top() {
    return this.values[0];
  }
  isEmpty() {
    return this.size === 0;
  }
}
Location: Auckland, New Zealand

Comments

Post a Comment

Popular posts from this blog

Maximum Value of an Ordered Triplet II - Two Solutions [JS]

By on
Description   Solution 1: Prefix Max Summary: Anchor at  nums[j] . We want  nums[i]  and  nums[k]  to be as larger as possible, and  nums[j]  to be as small as possible to ensure the maximum value. Calculate the maximum value on the right of each index  i :  maxRight[i]  = maximum value from index  i  to  n - 1 Go through  nums  from left to right and take each element as  nums[j] . Keep track of the maximum value on the left. Get the maximum value on the left and right of  nums[j] . Record the maximum value. Time Complexity:  O(n) Space Complexity:  O(n) var maximumTripletValue = function ( nums ) { let n = nums.length, maxRight = [...nums]; for ( let i = n - 2 ; i >= 0 ; i--) { maxRight[i] = Math .max(nums[i], maxRight[i + 1 ]); } let maxLeft = 0 , ans = 0 ; for ( let j = 0 ; j < n; j++) { if (j > 0 && j < n - 1 ) { ans = Math .max(an...
Read more

Maximum Sum of Distinct Subarrays With Length K - Sliding Window w/ Two Pointers & Set [JS]

By on
Description  Solution: Sliding Window w/ Two Pointers & Set Maintain a sliding window of unique numbers with maximum size of  k . We can store the numbers in the window in a hashset. When we move the right pointer up, move the left pointer up until: all numbers in the window are unique the window size  <= k Time Complexity:  O(n)  246ms Space Complexity:  O(k)  71.5MB var maximumSubarraySum = function ( nums, k ) { let set = new Set (), sum = 0 ; let ans = 0 , n = nums.length; for ( let j = 0 , i = 0 ; j < n; j++) { sum += nums[j]; while (set.has(nums[j]) || j - i >= k) { sum -= nums[i]; set.delete(nums[i]); i++; } set.add(nums[j]); if (j - i + 1 === k) ans = Math .max(ans, sum); } return ans; };
Read more

Sum of Prefix Scores of Strings - Trie [JS]

By on
Description   Solution: Trie Store each word in a trie. For every node in the trie, keep track of the number of words it is part of. Since we stored the count of words on every node, we can calculate the count of every prefix for every word on the fly. n = number of words ,  m = max(words[i].length) Time Complexity:  O(nm) Space Complexity:  O(26^m)  at worst var sumPrefixScores = function ( words ) { let trie = new Trie(); for ( let word of words) { trie.add(word); } let n = words.length, res = Array (n); for ( let i = 0 ; i < words.length; i++) { res[i] = trie.getScore(words[i]); } return res; }; class TrieNode { constructor ( ) { this .children = {}; this .count = 0 ; } } class Trie { constructor ( ) { this .root = new TrieNode(); } add ( word ) { let node = this .root; for ( let i = 0 ; i < word.length; i++) { node = node.children; let char = word[i]; if (...
Read more

Maximum Count of Positive Integer and Negative Integer - Binary Search [JS]

By on
Description  Solution: Binary Search Since  nums  is sorted, we can use binary search: Binary search for the index of the rightmost negative number. Binary search for the index of the leftmost positive number. Based on the indexes we can find the amount of negative and positive numbers. Time Complexity:  O(log(n))  64ms Space Complexity:  O(1)  43.7MB var maximumCount = function ( nums ) { return Math .max(upper_bound(nums), lower_bound(nums)); }; // binary search for the rightmost negative number function upper_bound ( nums ) { let low = 0 , high = nums.length - 1 ; while (low < high) { let mid = Math .ceil((low + high) / 2 ); if (nums[mid] < 0 ) low = mid; else high = mid - 1 ; } return nums[ 0 ] >= 0 ? 0 : low + 1 ; } // binary search for the leftmost positive number function lower_bound ( nums ) { let low = 0 , high = nums.length - 1 ; while (low < high) { let mid = Math .floor((low + hi...
Read more

Count Subarrays With Median K - Count Left & Right Balance [JS]

By on
Description   Solution: Count Left & Right Balance For a subarray to have median of  k : The subarray must contain  k . k  must be the middle element (if odd) or lower mid element (if even). Create subarrays revolving around  nums[i] = k . How do we find whether  k  is the mid/lower mid element? Starting from  k , count the "balance" on the left and right of  k . If  nums[i] < k , add  -1  to the balance. If  nums[i] > k , add  1  to the balance. If  k  is the mid element, the left balance + right balance =  0 . If  k  is the lower mid element, left balance + right balance =  1 . Store the count of left balances in a hashmap. Go through each right balance, Balance = 0 : Count the number of left balances that are equal to ( -right balance ) Balance = 1 : Count the number of left balances that are equal to ( -right balance + 1 ) Time Complexity:  O(n) Space Complexity:...
Read more