You start with the string source. In one operation, you can pick a character x from the string and change it to the character y at a cost of z if there exists any index j such that cost[j] == z, original[j] == x, and changed[j] == y.

Return the minimum cost to convert the string source to the string target using any number of operations. If it is impossible to convert source to target, return -1.

Note that there may exist indices i, j such that original[j] == original[i] and changed[j] == changed[i].

Example 1:

Input: source = "abcd", target = "acbe", original = ["a","b","c","c","e","d"], changed = ["b","c","b","e","b","e"], cost = [2,5,5,1,2,20]
Output: 28
Explanation: To convert the string "abcd" to string "acbe":
- Change value at index 1 from 'b' to 'c' at a cost of 5.
- Change value at index 2 from 'c' to 'e' at a cost of 1.
- Change value at index 2 from 'e' to 'b' at a cost of 2.
- Change value at index 3 from 'd' to 'e' at a cost of 20.
The total cost incurred is 5 + 1 + 2 + 20 = 28.
It can be shown that this is the minimum possible cost.

Example 2:

Input: source = "aaaa", target = "bbbb", original = ["a","c"], changed = ["c","b"], cost = [1,2]
Output: 12
Explanation: To change the character 'a' to 'b' change the character 'a' to 'c' at a cost of 1, followed by changing the character 'c' to 'b' at a cost of 2, for a total cost of 1 + 2 = 3. To change all occurrences of 'a' to 'b', a total cost of 3 * 4 = 12 is incurred.

Example 3:

Input: source = "abcd", target = "abce", original = ["a"], changed = ["e"], cost = [10000]
Output: -1
Explanation: It is impossible to convert source to target because the value at index 3 cannot be changed from 'd' to 'e'.

Constraints:

• 1 <= source.length == target.length <= 105
• source, target consist of lowercase English letters.
• 1 <= cost.length == original.length == changed.length <= 2000
• original[i], changed[i] are lowercase English letters.
• 1 <= cost[i] <= 106
• original[i] != changed[i]

Solution: All pairs shortest path

Compute the shortest path (min cost) for any given letter pairs.

Time complexity: O(26^3 + m + n)
Space complexity: O(26^2)

class Solution {
public:
    long long minimumCost(string s, string t, vector<char>& o, vector<char>& c, vector<int>& cost) {
    const int n = c.size();
    vector<vector<int>> d(26, vector<int>(26, 1e9));
    for (int i = 0; i < 26; ++i)
      d[i][i] = 0;
    for (int i = 0; i < n; ++i)
      d[o[i] - 'a'][c[i] - 'a'] = min(d[o[i] - 'a'][c[i] - 'a'], cost[i]);
    for (int k = 0; k < 26; ++k)
      for (int i = 0; i < 26;++i)
        for (int j = 0; j < 26; ++j)
          if (d[i][k] + d[k][j] < d[i][j])
            d[i][j] = d[i][k] + d[k][j];
    long ans = 0;
    for (int i = 0; i < s.size(); ++i) {
      if (d[s[i] - 'a'][t[i] - 'a'] >= 1e9) return -1; 
      ans += d[s[i] - 'a'][t[i] - 'a'];
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2976. Minimum Cost to Convert String I appeared first on Huahua's Tech Road.

You are given an array start where start = [startX, startY] represents your initial position (startX, startY) in a 2D space. You are also given the array target where target = [targetX, targetY] represents your target position (targetX, targetY).

The cost of going from a position (x1, y1) to any other position in the space (x2, y2) is |x2 - x1| + |y2 - y1|.

There are also some special roads. You are given a 2D array specialRoads where specialRoads[i] = [x1i, y1i, x2i, y2i, costi] indicates that the ith special road can take you from (x1i, y1i) to (x2i, y2i) with a cost equal to costi. You can use each special road any number of times.

Return the minimum cost required to go from (startX, startY) to (targetX, targetY).

Example 1:

Input: start = [1,1], target = [4,5], specialRoads = [[1,2,3,3,2],[3,4,4,5,1]]
Output: 5
Explanation: The optimal path from (1,1) to (4,5) is the following:
- (1,1) -> (1,2). This move has a cost of |1 - 1| + |2 - 1| = 1.
- (1,2) -> (3,3). This move uses the first special edge, the cost is 2.
- (3,3) -> (3,4). This move has a cost of |3 - 3| + |4 - 3| = 1.
- (3,4) -> (4,5). This move uses the second special edge, the cost is 1.
So the total cost is 1 + 2 + 1 + 1 = 5.
It can be shown that we cannot achieve a smaller total cost than 5.

Example 2:

Input: start = [3,2], target = [5,7], specialRoads = [[3,2,3,4,4],[3,3,5,5,5],[3,4,5,6,6]]
Output: 7
Explanation: It is optimal to not use any special edges and go directly from the starting to the ending position with a cost |5 - 3| + |7 - 2| = 7.

Constraints:

• start.length == target.length == 2
• 1 <= startX <= targetX <= 105
• 1 <= startY <= targetY <= 105
• 1 <= specialRoads.length <= 200
• specialRoads[i].length == 5
• startX <= x1i, x2i <= targetX
• startY <= y1i, y2i <= targetY
• 1 <= costi <= 105

Solution: Dijkstra

1. Create a node for each point in special edges as well as start and target.
2. Add edges for special roads (note it’s directional)
3. Add edges for each pair of node with default cost, i.e. |x1-x2| + |y1-y2|
4. Run Dijkstra’s algorithm

Time complexity: O(n²logn)
Space complexity: O(n²)

// Author: Huahua
class Solution {
public:
  int minimumCost(vector<int>& start, vector<int>& target, vector<vector<int>>& specialRoads) {
    unordered_map<long, int> ids;
    vector<pair<int, int>> pos;
    
    auto getId = [&](int x, int y) {
      const auto key = ((unsigned long)x << 32) | y;
      if (ids.count(key)) return ids[key];
      const int id = ids.size();      
      ids[key] = id;
      pos.emplace_back(x, y);
      return id;
    };
    const int s = getId(start[0], start[1]);
    const int t = getId(target[0], target[1]);
    vector<vector<pair<int, int>>> g;
    auto addEdge = [&](int x1, int y1, int x2, int y2, int c = INT_MAX) {      
      int n1 = getId(x1, y1);
      int n2 = getId(x2, y2);
      if (n1 == n2) return;
      while (g.size() <= max(n1, n2)) g.push_back({});      
      int cost = min(c, abs(x1 - x2) + abs(y1 - y2));
      g[n1].emplace_back(cost, n2);
      // directional for special edge
      if (c == INT_MAX) g[n2].emplace_back(cost, n1);
    };
    for (const auto& r : specialRoads)
      addEdge(r[0], r[1], r[2], r[3], r[4]);    
    for (int i = 0; i < pos.size(); ++i)
      for (int j = i + 1; j < pos.size(); ++j)
        addEdge(pos[i].first, pos[i].second, 
                pos[j].first, pos[j].second);
    vector<int> dist(ids.size(), INT_MAX);
    dist[s] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> q;
    q.emplace(0, s);    
    while (!q.empty()) {
      auto [d, u] = q.top(); q.pop();
      if (d > dist[u]) continue;
      if (u == t) return d;
      for (auto [c, v] : g[u])
        if (d + c < dist[v])
          q.emplace(dist[v] = d + c, v);
    }
    return -1;
  }
};

The post 花花酱 LeetCode 2662. Minimum Cost of a Path With Special Roads appeared first on Huahua's Tech Road.

Implement the Graph class:

• Graph(int n, int[][] edges) initializes the object with n nodes and the given edges.
• addEdge(int[] edge) adds an edge to the list of edges where edge = [from, to, edgeCost]. It is guaranteed that there is no edge between the two nodes before adding this one.
• int shortestPath(int node1, int node2) returns the minimum cost of a path from node1 to node2. If no path exists, return -1. The cost of a path is the sum of the costs of the edges in the path.

Example 1:

Input
["Graph", "shortestPath", "shortestPath", "addEdge", "shortestPath"]
[[4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]], [3, 2], [0, 3], [[1, 3, 4]], [0, 3]]
Output
[null, 6, -1, null, 6]

Explanation

Graph g = new Graph(4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]); g.shortestPath(3, 2); // return 6. The shortest path from 3 to 2 in the first diagram above is 3 -> 0 -> 1 -> 2 with a total cost of 3 + 2 + 1 = 6.
g.shortestPath(0, 3); // return -1. There is no path from 0 to 3. 
g.addEdge([1, 3, 4]); // We add an edge from node 1 to node 3, and we get the second diagram above. 
g.shortestPath(0, 3); // return 6. The shortest path from 0 to 3 now is 0 -> 1 -> 3 with a total cost of 2 + 4 = 6.

Constraints:

• 1 <= n <= 100
• 0 <= edges.length <= n * (n - 1)
• edges[i].length == edge.length == 3
• 0 <= fromi, toi, from, to, node1, node2 <= n - 1
• 1 <= edgeCosti, edgeCost <= 106
• There are no repeated edges and no self-loops in the graph at any point.
• At most 100 calls will be made for addEdge.
• At most 100 calls will be made for shortestPath.

Solution 1: Floyd-Washall

Time complexity:
Init O(n³)
addEdge O(n²)
shortestPath O(1)

Space complexity: O(1)

// Author: Huahua
class Graph {
public:
  Graph(int n, vector<vector<int>>& edges):
  n_(n),
  d_(n, vector<long>(n, 1e18)) {
    for (int i = 0; i < n; ++i)
      d_[i][i] = 0;
    for (const vector<int>& e : edges)
      d_[e[0]][e[1]] = e[2];    
    for (int k = 0; k < n; ++k)
      for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
          d_[i][j] = min(d_[i][j], d_[i][k] + d_[k][j]);
  }
  
  void addEdge(vector<int> edge) {    
    for (int i = 0; i < n_; ++i)
      for (int j = 0; j < n_; ++j)
        d_[i][j] = min(d_[i][j], d_[i][edge[0]] + edge[2] + d_[edge[1]][j]);
  }
  
  int shortestPath(int node1, int node2) {
    return d_[node1][node2] >= 1e18 ? -1 : d_[node1][node2];
  }
private:
  int n_;
  vector<vector<long>> d_;
};

Solution 2: Dijkstra

Time complexity:
Init: O(|E|) ~ O(n²)
AddEdge: O(1)
ShortestPath: O(|V|*log(|E|)) ~ O(n*logn)

Space complexity: O(E|) ~ O(n²)

// Author: Huahua
class Graph {
public:
    Graph(int n, vector<vector<int>>& edges): n_(n), g_(n) {
      for (const auto& e : edges)
        g_[e[0]].emplace_back(e[1], e[2]);
    }
    
    void addEdge(vector<int> edge) {
      g_[edge[0]].emplace_back(edge[1], edge[2]);
    }
    
    int shortestPath(int node1, int node2) {
      vector<int> dist(n_, INT_MAX);
      dist[node1] = 0;
      priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> q;
      q.emplace(0, node1);
      while (!q.empty()) {
        const auto [d, u] = q.top(); q.pop();        
        if (u == node2) return d;
        for (const auto& [v, c] : g_[u])
          if (dist[u] + c < dist[v]) {
            dist[v] = dist[u] + c;
            q.emplace(dist[v], v);
          }
      }
      return -1;
    }
private:
  int n_;
  vector<vector<pair<int, int>>> g_;
};

The post 花花酱 LeetCode 2642. Design Graph With Shortest Path Calculator appeared first on Huahua's Tech Road.

• 0 represents a wall that you cannot pass through.
• 1 represents an empty cell that you can freely move to and from.
• All other positive integers represent the price of an item in that cell. You may also freely move to and from these item cells.

It takes 1 step to travel between adjacent grid cells.

You are also given integer arrays pricing and start where pricing = [low, high] and start = [row, col] indicates that you start at the position (row, col) and are interested only in items with a price in the range of [low, high] (inclusive). You are further given an integer k.

You are interested in the positions of the k highest-ranked items whose prices are within the given price range. The rank is determined by the first of these criteria that is different:

1. Distance, defined as the length of the shortest path from the start (shorter distance has a higher rank).
2. Price (lower price has a higher rank, but it must be in the price range).
3. The row number (smaller row number has a higher rank).
4. The column number (smaller column number has a higher rank).

Return the k highest-ranked items within the price range sorted by their rank (highest to lowest). If there are fewer than k reachable items within the price range, return all of them.

Example 1:

Input: grid = [[1,2,0,1],[1,3,0,1],[0,2,5,1]], pricing = [2,5], start = [0,0], k = 3
Output: [[0,1],[1,1],[2,1]]
Explanation: You start at (0,0).
With a price range of [2,5], we can take items from (0,1), (1,1), (2,1) and (2,2).
The ranks of these items are:
- (0,1) with distance 1
- (1,1) with distance 2
- (2,1) with distance 3
- (2,2) with distance 4
Thus, the 3 highest ranked items in the price range are (0,1), (1,1), and (2,1).

Example 2:

Input: grid = [[1,2,0,1],[1,3,3,1],[0,2,5,1]], pricing = [2,3], start = [2,3], k = 2
Output: [[2,1],[1,2]]
Explanation: You start at (2,3).
With a price range of [2,3], we can take items from (0,1), (1,1), (1,2) and (2,1).
The ranks of these items are:
- (2,1) with distance 2, price 2
- (1,2) with distance 2, price 3
- (1,1) with distance 3
- (0,1) with distance 4
Thus, the 2 highest ranked items in the price range are (2,1) and (1,2).

Example 3:

Input: grid = [[1,1,1],[0,0,1],[2,3,4]], pricing = [2,3], start = [0,0], k = 3
Output: [[2,1],[2,0]]
Explanation: You start at (0,0).
With a price range of [2,3], we can take items from (2,0) and (2,1). 
The ranks of these items are: 
- (2,1) with distance 5
- (2,0) with distance 6
Thus, the 2 highest ranked items in the price range are (2,1) and (2,0). 
Note that k = 3 but there are only 2 reachable items within the price range.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 105
• 1 <= m * n <= 105
• 0 <= grid[i][j] <= 105
• pricing.length == 2
• 2 <= low <= high <= 105
• start.length == 2
• 0 <= row <= m - 1
• 0 <= col <= n - 1
• grid[row][col] > 0
• 1 <= k <= m * n

Solution: BFS + Sorting

Use BFS to collect reachable cells and sort afterwards.

Time complexity: O(mn + KlogK) where K = # of reachable cells.

Space complexity: O(mn)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> highestRankedKItems(vector<vector<int>>& grid, vector<int>& pricing, vector<int>& start, int k) {
    const int m = grid.size();
    const int n = grid[0].size();    
    const vector<int> dirs{1, 0, -1, 0, 1};    
    vector<vector<int>> seen(m, vector<int>(n));
    seen[start[0]][start[1]] = 1;
    vector<vector<int>> cells;
    queue<array<int, 3>> q;
    q.push({start[0], start[1], 0});
    while (!q.empty()) {
      auto [y, x, d] = q.front(); q.pop();
      if (grid[y][x] >= pricing[0] && grid[y][x] <= pricing[1])
          cells.push_back({d, grid[y][x], y, x});
      for (int i = 0; i < 4; ++i) {
        const int tx = x + dirs[i];
        const int ty = y + dirs[i + 1];
        if (tx < 0 || tx >= n || ty < 0 || ty >= m 
            || !grid[ty][tx] || seen[ty][tx]++) continue;
        q.push({ty, tx, d + 1});
      }
    }
    sort(begin(cells), end(cells), less<vector<int>>());
    vector<vector<int>> ans;
    for (int i = 0; i < min(k, (int)(cells.size())); ++i)
      ans.push_back({cells[i][2], cells[i][3]});
    return ans;
  }
};

The post 花花酱 LeetCode 2146. K Highest Ranked Items Within a Price Range appeared first on Huahua's Tech Road.

In one step, you can move one cell up, down, left, or right. You cannot step into a cell with a wall, and you cannot step outside the maze. Your goal is to find the nearest exit from the entrance. An exit is defined as an empty cell that is at the border of the maze. The entrance does not count as an exit.

Return the number of steps in the shortest path from the entrance to the nearest exit, or -1 if no such path exists.

Example 1:

Input: maze = [["+","+",".","+"],[".",".",".","+"],["+","+","+","."]], entrance = [1,2]
Output: 1
Explanation: There are 3 exits in this maze at [1,0], [0,2], and [2,3].
Initially, you are at the entrance cell [1,2].
- You can reach [1,0] by moving 2 steps left.
- You can reach [0,2] by moving 1 step up.
It is impossible to reach [2,3] from the entrance.
Thus, the nearest exit is [0,2], which is 1 step away.

Example 2:

Input: maze = [["+","+","+"],[".",".","."],["+","+","+"]], entrance = [1,0]
Output: 2
Explanation: There is 1 exit in this maze at [1,2].
[1,0] does not count as an exit since it is the entrance cell.
Initially, you are at the entrance cell [1,0].
- You can reach [1,2] by moving 2 steps right.
Thus, the nearest exit is [1,2], which is 2 steps away.

Example 3:

Input: maze = [[".","+"]], entrance = [0,0]
Output: -1
Explanation: There are no exits in this maze.

Constraints:

• maze.length == m
• maze[i].length == n
• 1 <= m, n <= 100
• maze[i][j] is either '.' or '+'.
• entrance.length == 2
• 0 <= entrancerow < m
• 0 <= entrancecol < n
• entrance will always be an empty cell.

Solution: BFS

Use BFS to find the shortest path. We can re-use the board for visited array.

Time complexity: O(m*n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) {    
    const int m = maze.size();
    const int n = maze[0].size();
    const vector<int> dirs{0, -1, 0, 1, 0};
    queue<pair<int, int>> q;
    q.emplace(entrance[1], entrance[0]);    
    for (int steps = 0; !q.empty(); ++steps) {      
      for (int s = q.size(); s; --s) {      
        const auto [x, y] = q.front(); q.pop();        
        if (x == 0 || x == n - 1 || y == 0 || y == m - 1)
          if (x != entrance[1] || y != entrance[0])
            return steps;
        for (int i = 0; i < 4; ++i) {
          const int tx = x + dirs[i];
          const int ty = y + dirs[i + 1];
          if (tx < 0 || tx >= n || ty < 0 || ty >= m || maze[ty][tx] != '.') continue;
          maze[ty][tx] = '*';
          q.emplace(tx, ty);
        }
      }      
    }
    return -1;
  }
};

The post 花花酱 LeetCode 1926. Nearest Exit from Entrance in Maze appeared first on Huahua's Tech Road.

Find the shortest path starting from node s and ending at node t. Generate step-by-step directions of such path as a string consisting of only the uppercase letters 'L', 'R', and 'U'. Each letter indicates a specific direction:

• 'L' means to go from a node to its left child node.
• 'R' means to go from a node to its right child node.
• 'U' means to go from a node to its parent node.

Return the step-by-step directions of the shortest path from node s to node t.

Example 1:

Input: root = [5,1,2,3,null,6,4], startValue = 3, destValue = 6
Output: "UURL"
Explanation: The shortest path is: 3 → 1 → 5 → 2 → 6.

Example 2:

Input: root = [2,1], startValue = 2, destValue = 1
Output: "L"
Explanation: The shortest path is: 2 → 1.

Constraints:

• The number of nodes in the tree is n.
• 2 <= n <= 105
• 1 <= Node.val <= n
• All the values in the tree are unique.
• 1 <= startValue, destValue <= n
• startValue != destValue

Solution: Lowest common ancestor

It’s no hard to see that the shortest path is from the start node to the lowest common ancestor (LCA) of (start, end), then to the end node. The key is to find the LCA while finding paths from root to two nodes.

We can use recursion to find/build a path from root to a target node.
The common prefix of these two paths is the path from root to the LCA that we need to remove from the shortest path.
e.g.
root to start “LLRLR”
root to dest “LLLR”
common prefix is “LL”, after removing, it becomes:
LCA to start “RLR”
LCA to dest “LR”
Final path becomes “UUU” + “LR” = “UUULR”

The final step is to replace the L/R with U for the start path since we are moving up and then concatenate with the target path.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  string getDirections(TreeNode* root, int startValue, int destValue) {
    string startPath;
    string destPath;
    buildPath(root, startValue, startPath);
    buildPath(root, destValue, destPath);    
    // Remove common suffix (shared path from root to LCA)
    while (!startPath.empty() && !destPath.empty() 
           && startPath.back() == destPath.back()) {
      startPath.pop_back();
      destPath.pop_back();
    }
    reverse(begin(destPath), end(destPath));
    return string(startPath.size(), 'U') + destPath;
  }
private:
  bool buildPath(TreeNode* root, int t, string& path) {
    if (!root) return false;
    if (root->val == t) return true;
    if (buildPath(root->left, t, path)) {
      path.push_back('L');
      return true;
    } else if (buildPath(root->right, t, path)) {
      path.push_back('R');
      return true;
    }
    return false;
  }
};

The post 花花酱 LeetCode 2096. Step-By-Step Directions From a Binary Tree Node to Another appeared first on Huahua's Tech Road.

All servers are connected, i.e., a message can be passed from one server to any other server(s) directly or indirectly through the message channels.

The server labeled 0 is the master server. The rest are data servers. Each data server needs to send its message to the master server for processing and wait for a reply. Messages move between servers optimally, so every message takes the least amount of time to arrive at the master server. The master server will process all newly arrived messages instantly and send a reply to the originating server via the reversed path the message had gone through.

At the beginning of second 0, each data server sends its message to be processed. Starting from second 1, at the beginning of every second, each data server will check if it has received a reply to the message it sent (including any newly arrived replies) from the master server:

• If it has not, it will resend the message periodically. The data server i will resend the message every patience[i] second(s), i.e., the data server i will resend the message if patience[i] second(s) have elapsed since the last time the message was sent from this server.
• Otherwise, no more resending will occur from this server.

The network becomes idle when there are no messages passing between servers or arriving at servers.

Return the earliest second starting from which the network becomes idle.

Example 1:

Input: edges = [[0,1],[1,2]], patience = [0,2,1]
Output: 8
Explanation:
At (the beginning of) second 0,
- Data server 1 sends its message (denoted 1A) to the master server.
- Data server 2 sends its message (denoted 2A) to the master server.

At second 1,
- Message 1A arrives at the master server. Master server processes message 1A instantly and sends a reply 1A back.
- Server 1 has not received any reply. 1 second (1 < patience[1] = 2) elapsed since this server has sent the message, therefore it does not resend the message.
- Server 2 has not received any reply. 1 second (1 == patience[2] = 1) elapsed since this server has sent the message, therefore it resends the message (denoted 2B).

At second 2,
- The reply 1A arrives at server 1. No more resending will occur from server 1.
- Message 2A arrives at the master server. Master server processes message 2A instantly and sends a reply 2A back.
- Server 2 resends the message (denoted 2C).
...
At second 4,
- The reply 2A arrives at server 2. No more resending will occur from server 2.
...
At second 7, reply 2D arrives at server 2.

Starting from the beginning of the second 8, there are no messages passing between servers or arriving at servers.
This is the time when the network becomes idle.

Example 2:

Input: edges = [[0,1],[0,2],[1,2]], patience = [0,10,10]
Output: 3
Explanation: Data servers 1 and 2 receive a reply back at the beginning of second 2.
From the beginning of the second 3, the network becomes idle.

Constraints:

• n == patience.length
• 2 <= n <= 105
• patience[0] == 0
• 1 <= patience[i] <= 105 for 1 <= i < n
• 1 <= edges.length <= min(105, n * (n - 1) / 2)
• edges[i].length == 2
• 0 <= ui, vi < n
• ui != vi
• There are no duplicate edges.
• Each server can directly or indirectly reach another server.

Solution: Shortest Path

Compute the shortest path from node 0 to rest of the nodes using BFS.

Idle time for node i = (dist[i] * 2 – 1) / patince[i] * patience[i] + dist[i] * 2 + 1

Time complexity: O(E + V)
Space complexity: O(E + V)

// Author: Huahua
class Solution {
public:
  int networkBecomesIdle(vector<vector<int>>& edges, vector<int>& patience) {
    const int n = patience.size();
    vector<vector<int>> g(n);
    for (const auto& e : edges) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }
    vector<int> ts(n, -1);
    ts[0] = 0;
    queue<int> q{{0}};    
    while (!q.empty()) {      
      int u = q.front(); q.pop();        
      for (int v : g[u]) {
        if (ts[v] != -1) continue;
        ts[v] = ts[u] + 1;
        q.push(v);
      }
    }
    int ans = 0;
    for (int i = 1; i < n; ++i) {      
      int t = (ts[i] * 2 - 1) / patience[i] * patience[i] + ts[i] * 2 + 1;
      ans = max(ans, t);
    }    
    return ans;
  }
};

The post 花花酱 LeetCode 2039. The Time When the Network Becomes Idle appeared first on Huahua's Tech Road.

There is an undirected weighted connected graph. You are given a positive integer n which denotes that the graph has n nodes labeled from 1 to n, and an array edges where each edges[i] = [ui, vi, weighti] denotes that there is an edge between nodes ui and vi with weight equal to weighti.

A path from node start to node end is a sequence of nodes [z0, z1,z2, ..., zk] such that z0 = start and zk = end and there is an edge between zi and zi+1 where 0 <= i <= k-1.

The distance of a path is the sum of the weights on the edges of the path. Let distanceToLastNode(x) denote the shortest distance of a path between node n and node x. A restricted path is a path that also satisfies that distanceToLastNode(zi) > distanceToLastNode(zi+1) where 0 <= i <= k-1.

Return the number of restricted paths from node 1 to node n. Since that number may be too large, return it modulo 109 + 7.

Example 1:

Input: n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]
Output: 3
Explanation: Each circle contains the node number in black and its distanceToLastNode value in blue. The three restricted paths are:
1) 1 --> 2 --> 5
2) 1 --> 2 --> 3 --> 5
3) 1 --> 3 --> 5

Example 2:

Input: n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]
Output: 1
Explanation: Each circle contains the node number in black and its distanceToLastNode value in blue. The only restricted path is 1 --> 3 --> 7.

Constraints:

• 1 <= n <= 2 * 104
• n - 1 <= edges.length <= 4 * 104
• edges[i].length == 3
• 1 <= ui, vi <= n
• ui != vi
• 1 <= weighti <= 105
• There is at most one edge between any two nodes.
• There is at least one path between any two nodes.

Solution: Dijkstra + DFS w/ memoization

Find shortest path from n to all the nodes.
paths(u) = sum(paths(v)) if dist[u] > dist[v] and (u, v) has an edge
return paths(1)

Time complexity: O(ElogV + V + E)
Space complexity: O(V + E)

// Author: Huahua
class Solution {
public:
  int countRestrictedPaths(int n, vector<vector<int>>& edges) {
    constexpr int kMod = 1e9 + 7;
    using PII = pair<int, int>;    
    vector<vector<PII>> g(n + 1);
    for (const auto& e : edges) {
      g[e[0]].emplace_back(e[1], e[2]);
      g[e[1]].emplace_back(e[0], e[2]);
    }    
    
    // Shortest distance from n to x.
    vector<int> dist(n + 1, INT_MAX / 2);
    dist[n] = 0;
    priority_queue<PII, vector<PII>, std::greater<PII>> q;
    q.emplace(0, n);
    while (!q.empty()) {
      const auto [d, u] = q.top(); q.pop();
      if (dist[u] < d) continue;
      for (auto [v, w]: g[u]) {
        if (dist[u] + w >= dist[v]) continue;
        dist[v] = dist[u] + w;
        q.emplace(dist[v], v);
      }
    }

    vector<int> dp(n + 1, INT_MAX);
    function<int(int)> dfs = [&](int u) {      
      if (u == n) return 1;
      if (dp[u] != INT_MAX) return dp[u];
      int ans = 0;
      for (auto [v, w]: g[u])
        if (dist[u] > dist[v])
          ans = (ans + dfs(v)) % kMod;      
      return dp[u] = ans;
    };
    
    return dfs(1);
  }
};

Combined

// Author: Huahua
class Solution {
public:
  int countRestrictedPaths(int n, vector<vector<int>>& edges) {
    constexpr int kMod = 1e9 + 7;
    using PII = pair<int, int>;    
    vector<vector<PII>> g(n + 1);
    for (const auto& e : edges) {
      g[e[0]].emplace_back(e[1], e[2]);
      g[e[1]].emplace_back(e[0], e[2]);
    }    
    
    // Shortest distance from n to x.
    vector<int> dist(n + 1, INT_MAX);
    vector<int> dp(n + 1);
    dist[n] = 0;
    dp[n] = 1;
    priority_queue<PII, vector<PII>, std::greater<PII>> q;
    q.emplace(0, n);
    while (!q.empty()) {
      const auto [d, u] = q.top(); q.pop();
      if (d > dist[u]) continue;
      if (u == 1) break;
      for (auto [v, w]: g[u]) {
        if (dist[v] > dist[u] + w)
          q.emplace(dist[v] = dist[u] + w, v);
        if (dist[v] > dist[u])
          dp[v] = (dp[v] + dp[u]) % kMod;
      }
    }    
    return dp[1];
  }
};

The post 花花酱 LeetCode 1786. Number of Restricted Paths From First to Last Node appeared first on Huahua's Tech Road.

• If isWater[i][j] == 0, cell (i, j) is a land cell.
• If isWater[i][j] == 1, cell (i, j) is a water cell.

You must assign each cell a height in a way that follows these rules:

• The height of each cell must be non-negative.
• If the cell is a water cell, its height must be 0.
• Any two adjacent cells must have an absolute height difference of at most 1. A cell is adjacent to another cell if the former is directly north, east, south, or west of the latter (i.e., their sides are touching).

Find an assignment of heights such that the maximum height in the matrix is maximized.

Return an integer matrix height of size m x n where height[i][j] is cell (i, j)‘s height. If there are multiple solutions, return any of them.

Example 1:

Input: isWater = [[0,1],[0,0]]
Output: [[1,0],[2,1]]
Explanation: The image shows the assigned heights of each cell.
The blue cell is the water cell, and the green cells are the land cells.

Example 2:

Input: isWater = [[0,0,1],[1,0,0],[0,0,0]]
Output: [[1,1,0],[0,1,1],[1,2,2]]
Explanation: A height of 2 is the maximum possible height of any assignment.
Any height assignment that has a maximum height of 2 while still meeting the rules will also be accepted.

Constraints:

• m == isWater.length
• n == isWater[i].length
• 1 <= m, n <= 1000
• isWater[i][j] is 0 or 1.
• There is at least one water cell.

Solution: BFS

h[y][x] = min distance of (x, y) to any water cell.

Time complexity: O(m*n)
Space complexity: O(m*n)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> highestPeak(vector<vector<int>>& isWater) {
    const int m = isWater.size();
    const int n = isWater[0].size();
    vector<vector<int>> ans(m, vector<int>(n, INT_MIN));
    queue<pair<int, int>> q;
    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        if (isWater[y][x]) {
          q.emplace(x, y);
          ans[y][x] = 0;
        }
    const vector<int> dirs{0, -1, 0, 1, 0};    
    while (!q.empty()) {
      const auto [cx, cy] = q.front();
      q.pop();
      for (int i = 0; i < 4; ++i) {
        const int x = cx + dirs[i];
        const int y = cy + dirs[i + 1];
        if (x < 0 || x >= n || y < 0 || y >= m) continue;
        if (ans[y][x] != INT_MIN) continue;
        ans[y][x] = ans[cy][cx] + 1;
        q.emplace(x, y);
      }      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1765. Map of Highest Peak appeared first on Huahua's Tech Road.

Given two nodes start and end, find the path with the maximum probability of success to go from start to end and return its success probability.

If there is no path from start to end, return 0. Your answer will be accepted if it differs from the correct answer by at most 1e-5.

Example 1:

Input: n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
Output: 0.25000
Explanation: There are two paths from start to end, one having a probability of success = 0.2 and the other has 0.5 * 0.5 = 0.25.

Example 2:

Input: n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
Output: 0.30000

Example 3:

Input: n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
Output: 0.00000
Explanation: There is no path between 0 and 2.

Constraints:

• 2 <= n <= 10^4
• 0 <= start, end < n
• start != end
• 0 <= a, b < n
• a != b
• 0 <= succProb.length == edges.length <= 2*10^4
• 0 <= succProb[i] <= 1
• There is at most one edge between every two nodes.

Solution: Dijkstra’s Algorithm

max(P1*P2*…*Pn) => max(log(P1*P2…*Pn)) => max(log(P1) + log(P2) + … + log(Pn) => min(-(log(P1) + log(P2) … + log(Pn)).

Thus we can convert this problem to the classic single source shortest path problem that can be solved with Dijkstra’s algorithm.

Time complexity: O(ElogV)
Space complexity: O(E+V)

// Author: Huahua
// Author: Huahua
class Solution {
public:
  double maxProbability(int n, vector<vector<int>>& edges, 
                        vector<double>& succProb, int start, int end) {
    vector<vector<pair<int, double>>> g(n); // u -> {v, -log(w)}
    for (int i = 0; i < edges.size(); ++i) {
      const double w = -log(succProb[i]);
      g[edges[i][0]].emplace_back(edges[i][1], w);
      g[edges[i][1]].emplace_back(edges[i][0], w);
    }

    vector<double> dist(n, FLT_MAX);
    priority_queue<pair<double, int>> q;
    q.emplace(-0.0, start);
    vector<int> seen(n);
    while (!q.empty()) {
      const double d = -q.top().first;
      const int u = q.top().second;        
      q.pop();
      seen[u] = 1;
      if (u == end) return exp(-d);
      for (const auto& [v, w] : g[u]) {
        if (seen[v] || d + w > dist[v]) continue;
        q.emplace(-(dist[v] = d + w), v);
      }
    }
    return 0;
  }
};

// Author: Huahua
import java.util.AbstractMap;

class Solution {
  public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
    var g = new ArrayList<List<Map.Entry<Integer, Double>>>();
    for (int i = 0; i < n; ++i) g.add(new ArrayList<Map.Entry<Integer, Double>>());
    for (int i = 0; i < edges.length; ++i) {
      g.get(edges[i][0]).add(new AbstractMap.SimpleEntry<>(edges[i][1], -Math.log(succProb[i])));
      g.get(edges[i][1]).add(new AbstractMap.SimpleEntry<>(edges[i][0], -Math.log(succProb[i])));
    }    
    var seen = new boolean[n];
    var dist = new double[n];
    Arrays.fill(dist, Double.MAX_VALUE);
    seen[start] = true;
    dist[start] = 0.0;
    // {u, dist[u]}
    var q = new PriorityQueue<Map.Entry<Integer, Double>>(Map.Entry.comparingByValue());    
    q.offer(new AbstractMap.SimpleEntry<>(start, 0.0));
    while (!q.isEmpty()) {
      var node = q.poll();
      final int u = node.getKey();
      if (u == end) return Math.exp(-dist[end]);
      seen[u] = true;
      for (var e : g.get(u)) {
        final int v = e.getKey();
        final double w = e.getValue();
        if (seen[v] || dist[u] + w > dist[v]) continue;
        dist[v] = dist[u] + w;
        q.offer(new AbstractMap.SimpleEntry<>(v, dist[v]));
      }
    }
    return 0;
  }
}

# Author: Huahua
class Solution:
  def maxProbability(self, n: int, edges: List[List[int]], 
                     succProb: List[float], start: int, end: int) -> float:
    g = [[] for _ in range(n)]
    for i, e in enumerate(edges):
      g[e[0]].append((e[1], -math.log(succProb[i])))
      g[e[1]].append((e[0], -math.log(succProb[i])))
    seen = [False] * n
    dist = [float('inf')] * n
    dist[start] = 0.0
    q = [(dist[start], start)]
    while q:
      _, u = heapq.heappop(q)
      if seen[u]: continue
      seen[u] = True
      if u == end: return math.exp(-dist[u])
      for v, w in g[u]:
        if seen[v] or dist[u] + w > dist[v]: continue
        dist[v] = dist[u] + w        
        heapq.heappush(q, (dist[v], v))
    return 0

The post 花花酱 LeetCode 1514. Path with Maximum Probability appeared first on Huahua's Tech Road.

There are n cities numbered from 0 to n-1. Given the array edges where edges[i] = [fromi, toi, weighti] represents a bidirectional and weighted edge between cities fromi and toi, and given the integer distanceThreshold.

Return the city with the smallest numberof cities that are reachable through some path and whose distance is at most distanceThreshold, If there are multiple such cities, return the city with the greatest number.

Notice that the distance of a path connecting cities i and j is equal to the sum of the edges’ weights along that path.

Example 1:

Input: n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4
Output: 3
Explanation: The figure above describes the graph. 
The neighboring cities at a distanceThreshold = 4 for each city are:
City 0 -> [City 1, City 2] 
City 1 -> [City 0, City 2, City 3] 
City 2 -> [City 0, City 1, City 3] 
City 3 -> [City 1, City 2] 
Cities 0 and 3 have 2 neighboring cities at a distanceThreshold = 4, but we have to return city 3 since it has the greatest number.

Example 2:

Input: n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2
Output: 0
Explanation: The figure above describes the graph. 
The neighboring cities at a distanceThreshold = 2 for each city are:
City 0 -> [City 1] 
City 1 -> [City 0, City 4] 
City 2 -> [City 3, City 4] 
City 3 -> [City 2, City 4]
City 4 -> [City 1, City 2, City 3] 
The city 0 has 1 neighboring city at a distanceThreshold = 2.

Constraints:

• 2 <= n <= 100
• 1 <= edges.length <= n * (n - 1) / 2
• edges[i].length == 3
• 0 <= fromi < toi < n
• 1 <= weighti, distanceThreshold <= 10^4
• All pairs (fromi, toi) are distinct.

Solution1: Floyd-Warshall

All pair shortest path

Time complexity: O(n^3)
Space complexity: O(n^2)

// Author: Huahua
class Solution {
public:
  int findTheCity(int n, vector<vector<int>>& edges, int distanceThreshold) {
    vector<vector<int>> dp(n, vector<int>(n, INT_MAX / 2));
    for (const auto& e : edges)      
      dp[e[0]][e[1]] = dp[e[1]][e[0]] = e[2];    
    
    for (int k = 0; k < n; ++k)
      for (int u = 0; u < n; ++u)
        for (int v = 0; v < n; ++v)
          dp[u][v] = min(dp[u][v], dp[u][k] + dp[k][v]);
    
    int ans = -1;
    int min_nb = INT_MAX;
    for (int u = 0; u < n; ++u) {
      int nb = 0;
      for (int v = 0; v < n; ++v)
        if (v != u && dp[u][v] <= distanceThreshold)
          ++nb;
      if (nb <= min_nb) {
        min_nb = nb;
        ans = u;
      }
    }
    
    return ans;
  }
};

Solution 2: Dijkstra’s Algorithm

Time complexity: O(V * ElogV) / worst O(n^3*logn), best O(n^2*logn)
Space complexity: O(V + E)

// Author: Huahua
// Author: Huahua
class Solution {
public:
  int findTheCity(int n, vector<vector<int>>& edges, int t) {
    vector<vector<pair<int, int>>> g(n);
    for (const auto& e : edges) {
      g[e[0]].emplace_back(e[1], e[2]);
      g[e[1]].emplace_back(e[0], e[2]);
    }
    
    // Returns the number of nodes within t from s.
    auto dijkstra = [&](int s) {
      vector<int> dist(n, INT_MAX / 2);
      set<pair<int, int>> q; // <dist, node>
      vector<set<pair<int, int>>::const_iterator> its(n);
      dist[s] = 0;
      for (int i = 0; i < n; ++i)
        its[i] = q.emplace(dist[i], i).first;
      while (!q.empty()) {
        auto it = cbegin(q);
        int d = it->first;
        int u = it->second;
        q.erase(it);        
        if (d > t) break; // pruning
        for (const auto& p : g[u]) {
          int v = p.first;
          int w = p.second;
          if (dist[v] <= d + w) continue;
          // Decrease key
          q.erase(its[v]);
          its[v] = q.emplace(dist[v] = d + w, v).first;
        }
      }
      return count_if(begin(dist), end(dist), [t](int d) { return d <= t; });
    };
    
    int ans = -1;
    int min_nb = INT_MAX;
    for (int i = 0; i < n; ++i) {
      int nb = dijkstra(i);
      if (nb <= min_nb) {
        min_nb = nb;
        ans = i;
      }
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 1334. Find the City With the Smallest Number of Neighbors at a Threshold Distance appeared first on Huahua's Tech Road.

Return the minimum number of steps to walk from the upper left corner (0, 0) to the lower right corner (m-1, n-1) given that you can eliminate at most k obstacles. If it is not possible to find such walk return -1.

Example 1:

Input: 
grid = 
[[0,0,0],
 [1,1,0],
 [0,0,0],
 [0,1,1],
 [0,0,0]], 
k = 1
Output: 6
Explanation: 
The shortest path without eliminating any obstacle is 10. 
The shortest path with one obstacle elimination at position (3,2) is 6. Such path is (0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (3,2) -> (4,2).

Example 2:

Input: 
grid = 
[[0,1,1],
 [1,1,1],
 [1,0,0]], 
k = 1
Output: -1
Explanation: 
We need to eliminate at least two obstacles to find such a walk.

Constraints:

• grid.length == m
• grid[0].length == n
• 1 <= m, n <= 40
• 1 <= k <= m*n
• grid[i][j] == 0 or 1
• grid[0][0] == grid[m-1][n-1] == 0

Solution: BFS

State: (x, y, k) where k is the number of obstacles along the path.

Time complexity: O(m*n*k)
Space complexity: O(m*n*k)

// Author: Huahua, 8 ms, 10.5 MB
class Solution {
public:
  int shortestPath(vector<vector<int>>& grid, int k) {
    const vector<int> dirs{0, 1, 0, -1, 0};
    const int n = grid.size();
    const int m = grid[0].size();
    vector<vector<int>> seen(n, vector<int>(m, INT_MAX));
    queue<tuple<int, int, int>> q; 
    int steps = 0;
    q.emplace(0, 0, 0);
    seen[0][0] = 0;
    while (!q.empty()) {
      int size = q.size();
      while (size--) {
        int cx, cy, co;
        tie(cx, cy, co) = q.front(); q.pop();         
        if (cx == m - 1 && cy == n - 1) return steps;
        for (int i = 0; i < 4; ++i) {
          int x = cx + dirs[i];
          int y = cy + dirs[i + 1];
          if (x < 0 || y < 0 || x >= m || y >= n) continue;
          int o = co + grid[y][x];
          if (o >= seen[y][x] || o > k) continue;            
          seen[y][x] = o;
          q.emplace(x, y, o);
        }
      }
      ++steps;
    }
    return -1;
  }
};

Solution 2: DP

Time complexity: O(mnk)
Space complexity: O(mnk)

// AC 236 ms
class Solution {
public:
  int shortestPath(vector<vector<int>>& grid, int k) {
    constexpr int kInf = 1e9;
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<vector<int>>> dp(m + 2, vector<vector<int>>(n + 2, vector<int>(k + 1, kInf)));
    dp[1][1][0] = 0;
    for (int s = 0; s < 3; ++s)
      for (int i = 1; i <= m; ++i)
        for (int j = 1; j <= n; ++j) {
          const int o = grid[i - 1][j - 1];
          for (int z = 0; z + o <= k; ++z)
            dp[i][j][z + o] = min(dp[i][j][z + o],
                                  min({dp[i - 1][j][z],
                                       dp[i][j - 1][z],
                                       dp[i + 1][j][z],
                                       dp[i][j + 1][z]}) + 1);
        }
    int ans = *min_element(begin(dp[m][n]), end(dp[m][n]));
    return ans >= kInf ? -1 : ans;
  }
};

class Solution {
public:
  int shortestPath(vector<vector<int>>& grid, int K) {
    constexpr int kInf = 1e9;
    const vector<int> dirs{0, 1, 0, -1, 0};
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<vector<int>>> mem(m + 2, vector<vector<int>>(n + 2, vector<int>(K + 1, -1)));
    vector<vector<int>> seen(m + 2, vector<int>(n + 2));    
    function<int(int, int, int)> dp = [&](int x, int y, int k) {      
      if (x < 1 || x > n || y < 1 || y > m || k < 0 || seen[y][x]) return kInf;
      if (x == 1 && y == 1) return 0;
      if (mem[y][x][k] != -1) return mem[y][x][k];
      seen[y][x] = 1;
      int ans = kInf;
      for (int i = 0; i < 4; ++i)
        ans = min(ans, 1 + dp(x + dirs[i], y + dirs[i + 1], k - grid[y - 1][x - 1]));
      seen[y][x] = 0;      
      return mem[y][x][k] = ans;
    };        
    const int ans = dp(n, m, K);
    return ans >= kInf ? -1 : ans;
  }
};

The post 花花酱 LeetCode 1293. Shortest Path in a Grid with Obstacles Elimination appeared first on Huahua's Tech Road.

Here, board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"].

We may make the following moves:

• 'U' moves our position up one row, if the square exists;
• 'D' moves our position down one row, if the square exists;
• 'L' moves our position left one column, if the square exists;
• 'R' moves our position right one column, if the square exists;
• '!' adds the character board[r][c] at our current position (r, c) to the answer.

Return a sequence of moves that makes our answer equal to target in the minimum number of moves.  You may return any path that does so.

Example 1:

Input: target = "leet"
Output: "DDR!UURRR!!DDD!"

Example 2:

Input: target = "code"
Output: "RR!DDRR!UUL!R!"

Constraints:

• 1 <= target.length <= 100
• target consists only of English lowercase letters.

Solution: Manhattan walk

Compute the coordinates of each char, walk from (x1, y1) to (x2, y2) in Manhattan way.
Be aware of the last row, we can only walk on ‘z’, so go left and up first if needed.

Time complexity: O(26*26 + n)
Space complexity: O(26*26)

// Author: Huahua
class Solution {
public:
  string alphabetBoardPath(string target) {    
    vector<vector<string>> paths(26, vector<string>(26));
    for (int s = 0; s < 26; ++s)
      for (int t = 0; t < 26; ++t) {
        int dx = t % 5 - s % 5;
        int dy = t / 5 - s / 5; 
        string path;
        while (dx < 0) { path.push_back('L'); dx++; }
        while (dy < 0) { path.push_back('U'); dy++; }
        while (dx > 0) { path.push_back('R'); dx--; }
        while (dy > 0) { path.push_back('D'); dy--; }
        paths[s][t] = path;
      }
    
    char l = 'a';
    string ans;
    for (char c : target) {
      ans += paths[l - 'a'][c - 'a'] + "!";
      l = c;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1138. Alphabet Board Path appeared first on Huahua's Tech Road.

Problem

https://leetcode.com/problems/shortest-bridge/description/

In a given 2D binary array A, there are two islands.  (An island is a 4-directionally connected group of 1s not connected to any other 1s.)

Now, we may change 0s to 1s so as to connect the two islands together to form 1 island.

Return the smallest number of 0s that must be flipped.  (It is guaranteed that the answer is at least 1.)

Example 1:

Input: [[0,1],[1,0]]
Output: 1

Example 2:

Input: [[0,1,0],[0,0,0],[0,0,1]]
Output: 2

Example 3:

Input: [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
Output: 1

Note:

1. 1 <= A.length = A[0].length <= 100
2. A[i][j] == 0 or A[i][j] == 1

Solution: DFS + BFS

1. Use DFS to find one island and color all the nodes as 2 (BLUE).
2. Use BFS to find the shortest path from any nodes with color 2 (BLUE) to any nodes with color 1 (RED).

Time complexity: O(mn)

Space complexity: O(mn)

class Solution {
public:
  int shortestBridge(vector<vector<int>>& A) {
    queue<pair<int, int>> q;
    bool found = false;
    for (int i = 0; i < A.size() && !found; ++i)
      for (int j = 0; j < A[0].size() && !found; ++j)
        if (A[i][j]) {
          dfs(A, j, i, q);
          found = true;
        }
    
    int steps = 0;
    vector<int> dirs{0, 1, 0, -1, 0};
    while (!q.empty()) {      
      size_t size = q.size();
      while (size--) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        for (int i = 0; i < 4; ++i) {
          int tx = x + dirs[i];
          int ty = y + dirs[i + 1];
          if (tx < 0 || ty < 0 || tx >= A[0].size() || ty >= A.size() || A[ty][tx] == 2) continue;          
          if (A[ty][tx] == 1) return steps;
          A[ty][tx] = 2;
          q.emplace(tx, ty);
        }
      }
      ++steps;
    }
    return -1;
  }
private:  
  void dfs(vector<vector<int>>& A, int x, int y, queue<pair<int, int>>& q) {
    if (x < 0 || y < 0 || x >= A[0].size() || y >= A.size() || A[y][x] != 1) return;
    A[y][x] = 2;
    q.emplace(x, y);
    dfs(A, x - 1, y, q);
    dfs(A, x, y - 1, q);
    dfs(A, x + 1, y, q);
    dfs(A, x, y + 1, q);
  }
};

Related Problems

• 花花酱 LeetCode 827. Making A Large Island
• 花花酱 LeetCode 695. Max Area of Island
• 花花酱 LeetCode 882. Reachable Nodes In Subdivided Graph
• 花花酱 LeetCode 743. Network Delay Time

The post 花花酱 LeetCode 934. Shortest Bridge appeared first on Huahua's Tech Road.

Problem

Starting with an undirected graph (the “original graph”) with nodes from 0 to N-1, subdivisions are made to some of the edges.

The graph is given as follows: edges[k] is a list of integer pairs (i, j, n) such that (i, j) is an edge of the original graph,

and n is the total number of new nodes on that edge.

Then, the edge (i, j) is deleted from the original graph, n new nodes (x_1, x_2, ..., x_n) are added to the original graph,

and n+1 new edges (i, x_1), (x_1, x_2), (x_2, x_3), ..., (x_{n-1}, x_n), (x_n, j) are added to the original graph.

Now, you start at node 0 from the original graph, and in each move, you travel along one edge.

Return how many nodes you can reach in at most M moves.

Example 1:

Input: edge = [[0,1,10],[0,2,1],[1,2,2]], M = 6, N = 3 
Output: 13 
Explanation:  The nodes that are reachable in the final graph after M = 6 moves are indicated below. 

Example 2:

Input: edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], M = 10, N = 4 
Output: 23

Note:

1. 0 <= edges.length <= 10000
2. 0 <= edges[i][0] < edges[i][1] < N
3. There does not exist any i != j for which edges[i][0] == edges[j][0] and edges[i][1] == edges[j][1].
4. The original graph has no parallel edges.
5. 0 <= edges[i][2] <= 10000
6. 0 <= M <= 10^9
7. 1 <= N <= 3000

Solution: Dijkstra Shortest Path

Compute the shortest from 0 to rest of the nodes. Use HP to mark the maximum moves left to reach each node.

HP[u] = a, HP[v] = b, new_nodes[u][v] = c

nodes covered between a<->b = min(c, a + b)

Time complexity: O(ElogE)

Space complexity: O(E)

C++

// Author: Huahua
// Running time: 88 ms
class Solution {
public:
  int reachableNodes(vector<vector<int>>& edges, int M, int N) {
    unordered_map<int, unordered_map<int, int>> g;
    for (const auto& e : edges)
      g[e[0]][e[1]] = g[e[1]][e[0]] = e[2];
    
    priority_queue<pair<int, int>> q;   // {hp, node}, sort by HP desc
    unordered_map<int, int> HP;         // node -> max HP left
    q.push({M, 0});
    while (!q.empty()) {
      int hp = q.top().first;
      int cur = q.top().second;
      q.pop();
      if (HP.count(cur)) continue;
      HP[cur] = hp;
      for (const auto& pair : g[cur]) {
        int nxt = pair.first;
        int nxt_hp = hp - pair.second - 1;
        if (HP.count(nxt) || nxt_hp < 0) continue;
        q.push({nxt_hp, nxt});
      }
    }
    
    int ans = HP.size(); // Original nodes covered.
    for (const auto& e : edges) {
      int uv = HP.count(e[0]) ? HP[e[0]] : 0;
      int vu = HP.count(e[1]) ? HP[e[1]] : 0;
      ans += min(e[2], uv + vu);
    }
    return ans;
  }
};

Optimized Dijkstra (replace hashmap with vector)

// Author: Huahua
// Running time: 56 ms (beats 88%)
class Solution {
public:
  int reachableNodes(vector<vector<int>>& edges, int M, int N) {
    vector<vector<pair<int, int>>> g(N);
    for (const auto& e : edges) {
      g[e[0]].emplace_back(e[1], e[2]);
      g[e[1]].emplace_back(e[0], e[2]);
    }
    
    set<pair<int, int>> q;           // {hp, node}, sort by HP asc
    vector<int> HP(N, INT_MIN);      // node -> HP left
    q.insert({M, 0});
    int ans = 0;
    while (!q.empty()) {
      auto last_it = prev(end(q));
      int hp = last_it->first;
      int cur = last_it->second;
      q.erase(last_it);
      if (HP[cur] != INT_MIN) continue;
      HP[cur] = hp;
      ++ans;
      for (const auto& pair : g[cur]) {
        int nxt = pair.first;
        int nxt_hp = hp - pair.second - 1;
        if (nxt_hp < 0 || HP[nxt] != INT_MIN) continue;
        q.insert({nxt_hp, nxt});
      }
    }
        
    for (const auto& e : edges) {
      const int uv = HP[e[0]] == INT_MIN ?  0 : HP[e[0]];
      const int vu = HP[e[1]] == INT_MIN ?  0 : HP[e[1]];
      ans += min(e[2], uv + vu);
    }
    return ans;
  }
};

Using SPFA

// Author: Huahua
// Running time: 56 ms (beats 88%)
class Solution {
public:
  int reachableNodes(vector<vector<int>>& edges, int M, int N) {
    vector<vector<pair<int, int>>> g(N);
    for (const auto& e : edges) {
      g[e[0]].emplace_back(e[1], e[2]);
      g[e[1]].emplace_back(e[0], e[2]);
    }
    
    queue<int> q;               
    vector<int> HP(N, INT_MIN);
    vector<bool> in_q(N);
    HP[0] = M;
    q.push(0);
    in_q[0] = true;
    
    // SPFA (Shortest Path Faster Algorithm).
    while (!q.empty()) {      
      int u = q.front(); q.pop();
      in_q[u] = false;
      for (const auto& pair : g[u]) {
        int v = pair.first;
        int new_hp = HP[u] - pair.second - 1;        
        if (new_hp < 0 || new_hp <= HP[v]) continue;
        HP[v] = new_hp;
        if (in_q[v]) continue;
        q.push(v);
        in_q[v] = true;
      }
    }
    
    int ans = 0;
    for (int i = 0; i < N; ++i) ans += HP[i] >= 0;
    for (const auto& e : edges) {
      const int uv = HP[e[0]] == INT_MIN ?  0 : HP[e[0]];
      const int vu = HP[e[1]] == INT_MIN ?  0 : HP[e[1]];
      ans += min(e[2], uv + vu);
    }
    return ans;
  }
};

BFS

// Author: Huahua
// Running time: 108 ms
class Solution {
public:
  int reachableNodes(vector<vector<int>>& edges, int M, int N) {
    unordered_map<int, unordered_map<int, int>> g;
    for (const auto& e : edges)
      g[e[0]][e[1]] = g[e[1]][e[0]] = e[2];
    
    queue<pair<int, int>> q;            // {hp, node}
    unordered_map<int, int> HP;         // node -> max HP left
    q.push({M, 0});
    while (!q.empty()) {
      int hp = q.front().first;
      int cur = q.front().second;
      q.pop();
      if (HP.count(cur) && HP[cur] > hp) continue;
      HP[cur] = hp;
      for (const auto& pair : g[cur]) {
        int nxt = pair.first;
        int nxt_hp = hp - pair.second - 1;
        if (nxt_hp < 0 || (HP.count(nxt) && HP[nxt] > nxt_hp)) continue;
        q.push({nxt_hp, nxt});
      }
    }
    
    int ans = HP.size(); // Original nodes covered.
    for (const auto& e : edges) {
      int uv = HP.count(e[0]) ? HP[e[0]] : 0;
      int vu = HP.count(e[1]) ? HP[e[1]] : 0;
      ans += min(e[2], uv + vu);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 882. Reachable Nodes In Subdivided Graph appeared first on Huahua's Tech Road.