方法1: BFS

把问题看成求无权重图中的最短路径，BFS可以找到最优解。

我们的节点有两个状态，当前的长度，剪贴板（上次复制后）的长度。
长度超过n一定无解，所以我们的状态最多只有n²种，每个状态最多拓展2个新的节点。

时间复杂度：O(n²)
空间复杂度：O(n²)

class Solution {
public:
  int minSteps(int n) {
    vector<vector<bool>> seen(n + 1, vector<bool>(n + 1));
    queue<pair<int, int>> q;

    auto expand = [&](int len, int clip) {
      if (len > n || len > n || seen[len][clip]) return;
      q.emplace(len, clip);
      seen[len][clip] = true;
    };

    int steps = 0;
    expand(1, 0); // init state.
    while (!q.empty()) {
      int size = q.size();
      while (size--) {
        auto [len, clip] = q.front(); q.pop();
        if (len == n) return steps;
        expand(len, len); // copy.
        expand(len + clip, clip); // paste.
      }
      ++steps;
    }
    return -1;
  }
};

• 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;
  }
};

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 bombs are represented by a 0-indexed 2D integer array bombs where bombs[i] = [xi, yi, ri]. xi and yi denote the X-coordinate and Y-coordinate of the location of the ith bomb, whereas ri denotes the radius of its range.

You may choose to detonate a single bomb. When a bomb is detonated, it will detonate all bombs that lie in its range. These bombs will further detonate the bombs that lie in their ranges.

Given the list of bombs, return the maximum number of bombs that can be detonated if you are allowed to detonate only one bomb.

Example 1:

Input: bombs = [[2,1,3],[6,1,4]]
Output: 2
Explanation:
The above figure shows the positions and ranges of the 2 bombs.
If we detonate the left bomb, the right bomb will not be affected.
But if we detonate the right bomb, both bombs will be detonated.
So the maximum bombs that can be detonated is max(1, 2) = 2.

Example 2:

Input: bombs = [[1,1,5],[10,10,5]]
Output: 1
Explanation:
Detonating either bomb will not detonate the other bomb, so the maximum number of bombs that can be detonated is 1.

Example 3:

Input: bombs = [[1,2,3],[2,3,1],[3,4,2],[4,5,3],[5,6,4]]
Output: 5
Explanation:
The best bomb to detonate is bomb 0 because:
- Bomb 0 detonates bombs 1 and 2. The red circle denotes the range of bomb 0.
- Bomb 2 detonates bomb 3. The blue circle denotes the range of bomb 2.
- Bomb 3 detonates bomb 4. The green circle denotes the range of bomb 3.
Thus all 5 bombs are detonated.

Constraints:

• 1 <= bombs.length <= 100
• bombs[i].length == 3
• 1 <= xi, yi, ri <= 105

Solution: Simulation w/ BFS

Enumerate the bomb to detonate, and simulate the process using BFS.

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

// Author: Huahua
class Solution {
public:
  int maximumDetonation(vector<vector<int>>& bombs) {
    const int n = bombs.size();    
    auto check = [&](int i, int j) -> bool {
      long x1 = bombs[i][0], y1 = bombs[i][1], r1 = bombs[i][2];
      long x2 = bombs[j][0], y2 = bombs[j][1], r2 = bombs[j][2];
      return ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) <= r1 * r1);          
    };
    int ans = 0;
    for (int s = 0; s < n; ++s) {
      int count = 0;
      queue<int> q{{s}};
      vector<int> seen(n);
      seen[s] = 1;
      while (!q.empty()) {
        ++count;
        int i = q.front(); q.pop();
        for (int j = 0; j < n; ++j)
          if (check(i, j) && !seen[j]++)
            q.push(j);
      }
      ans = max(ans, count);
    }
    return ans;
  }
};

If 0 <= x <= 1000, then for any index i in the array (0 <= i < nums.length), you can set x to any of the following:

• x + nums[i]
• x - nums[i]
• x ^ nums[i] (bitwise-XOR)

Note that you can use each nums[i] any number of times in any order. Operations that set x to be out of the range 0 <= x <= 1000 are valid, but no more operations can be done afterward.

Return the minimum number of operations needed to convert x = start into goal, and -1 if it is not possible.

Example 1:

Input: nums = [1,3], start = 6, goal = 4
Output: 2
Explanation:
We can go from 6 → 7 → 4 with the following 2 operations.
- 6 ^ 1 = 7
- 7 ^ 3 = 4

Example 2:

Input: nums = [2,4,12], start = 2, goal = 12
Output: 2
Explanation:
We can go from 2 → 14 → 12 with the following 2 operations.
- 2 + 12 = 14
- 14 - 2 = 12

Example 3:

Input: nums = [3,5,7], start = 0, goal = -4
Output: 2
Explanation:
We can go from 0 → 3 → -4 with the following 2 operations. 
- 0 + 3 = 3
- 3 - 7 = -4
Note that the last operation sets x out of the range 0 <= x <= 1000, which is valid.

Example 4:

Input: nums = [2,8,16], start = 0, goal = 1
Output: -1
Explanation:
There is no way to convert 0 into 1.

Example 5:

<strong>Input:</strong> nums = [1], start = 0, goal = 3
<strong>Output:</strong> 3
<strong>Explanation:</strong> 
We can go from 0 → 1 → 2 → 3 with the following 3 operations. 
- 0 + 1 = 1 
- 1 + 1 = 2
- 2 + 1 = 3

Constraints:

• 1 <= nums.length <= 1000
• -109 <= nums[i], goal <= 109
• 0 <= start <= 1000
• start != goal
• All the integers in nums are distinct.

Solution: BFS

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

// Author: Huahua
class Solution {
public:
  int minimumOperations(vector<int>& nums, int start, int goal) {
    vector<int> seen(1001);
    queue<int> q{{start}};  
    for (int ans = 1, s = 1; !q.empty(); ++ans, s = q.size()) {
      while (s--) {
        int x = q.front(); q.pop();
        for (int n : nums)
          for (int t : {x + n, x - n, x ^ n})
            if (t == goal) 
              return ans;
            else if (t < 0 || t > 1000 || seen[t]++)
              continue;
            else
              q.push(t);
      }
    }
    return -1;
  }
};

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;
  }
};

Each vertex has a traffic signal which changes its color from green to red and vice versa every change minutes. All signals change at the same time. You can enter a vertex at any time, but can leave a vertex only when the signal is green. You cannot wait at a vertex if the signal is green.

The second minimum value is defined as the smallest value strictly larger than the minimum value.

• For example the second minimum value of [2, 3, 4] is 3, and the second minimum value of [2, 2, 4] is 4.

Given n, edges, time, and change, return the second minimum time it will take to go from vertex 1 to vertex n.

Notes:

• You can go through any vertex any number of times, including 1 and n.
• You can assume that when the journey starts, all signals have just turned green.

Example 1:

Input: n = 5, edges = [[1,2],[1,3],[1,4],[3,4],[4,5]], time = 3, change = 5
Output: 13
Explanation:
The figure on the left shows the given graph.
The blue path in the figure on the right is the minimum time path.
The time taken is:
- Start at 1, time elapsed=0
- 1 -> 4: 3 minutes, time elapsed=3
- 4 -> 5: 3 minutes, time elapsed=6
Hence the minimum time needed is 6 minutes.

The red path shows the path to get the second minimum time.
- Start at 1, time elapsed=0
- 1 -> 3: 3 minutes, time elapsed=3
- 3 -> 4: 3 minutes, time elapsed=6
- Wait at 4 for 4 minutes, time elapsed=10
- 4 -> 5: 3 minutes, time elapsed=13
Hence the second minimum time is 13 minutes.      

Example 2:

Input: n = 2, edges = [[1,2]], time = 3, change = 2
Output: 11
Explanation:
The minimum time path is 1 -> 2 with time = 3 minutes.
The second minimum time path is 1 -> 2 -> 1 -> 2 with time = 11 minutes.

Constraints:

• 2 <= n <= 104
• n - 1 <= edges.length <= min(2 * 104, n * (n - 1) / 2)
• edges[i].length == 2
• 1 <= ui, vi <= n
• ui != vi
• There are no duplicate edges.
• Each vertex can be reached directly or indirectly from every other vertex.
• 1 <= time, change <= 103

Solution: Best first search

Since we’re only looking for second best, to avoid TLE, for each vertex, keep two best time to arrival is sufficient.

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

// Author: Huahua
class Solution {
public:
  int secondMinimum(int n, vector<vector<int>>& edges, int time, int change) {
    vector<vector<int>> g(n + 1);
    for (const auto& e : edges) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }
    priority_queue<pair<int, int>> q; // {-t, node}
    q.emplace(0, 1);
    int min_time = -1;
    vector<vector<int>> ts(n + 1);
    ts[1].push_back(0);
    while (true) {
      const int t = -q.top().first;
      const int u = q.top().second;
      if (u == n) {
        if (min_time == -1 || t == min_time) { 
          min_time = t;
        } else {
          return t;
        }
      }
      q.pop();
      for (const auto& v : g[u]) {
        const int tt = (((t / change) & 1) ? (t + change - t % change) : t) + time;
        if ((ts[v].size() > 0 && tt == ts[v].back()) || ts[v].size() >= 2) continue;
        ts[v].push_back(tt);        
        q.emplace(-tt, v);        
      }
    }
    return -1;
  }
};

• 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 bug jumps according to the following rules:

• It can jump exactly a positions forward (to the right).
• It can jump exactly b positions backward (to the left).
• It cannot jump backward twice in a row.
• It cannot jump to any forbidden positions.

The bug may jump forward beyond its home, but it cannot jump to positions numbered with negative integers.

Given an array of integers forbidden, where forbidden[i] means that the bug cannot jump to the position forbidden[i], and integers a, b, and x, return the minimum number of jumps needed for the bug to reach its home. If there is no possible sequence of jumps that lands the bug on position x, return -1.

Example 1:

Input: forbidden = [14,4,18,1,15], a = 3, b = 15, x = 9
Output: 3
Explanation: 3 jumps forward (0 -> 3 -> 6 -> 9) will get the bug home.

Example 2:

Input: forbidden = [8,3,16,6,12,20], a = 15, b = 13, x = 11
Output: -1

Example 3:

Input: forbidden = [1,6,2,14,5,17,4], a = 16, b = 9, x = 7
Output: 2
Explanation: One jump forward (0 -> 16) then one jump backward (16 -> 7) will get the bug home.

Constraints:

• 1 <= forbidden.length <= 1000
• 1 <= a, b, forbidden[i] <= 2000
• 0 <= x <= 2000
• All the elements in forbidden are distinct.
• Position x is not forbidden.

Solution: BFS

Normal BFS with two tricks:
1. For each position, we need to track whether it’s reached via a forward jump or backward jump
2. How far should we go? If we don’t limit, it can go forever which leads to TLE/MLE. We can limit the distance to 2*max_jump, e.g. 4000, that’s maximum distance we can jump back to home in one shot.

Time complexity: O(max_distance * 2)
Space complexity: O(max_distance * 2)

// Author: Huahua
class Solution {
public:
  int minimumJumps(vector<int>& forbidden, int a, int b, int x) {
    constexpr int kMaxPosition = 4000;
    if (x == 0) return 0;
    queue<pair<int, bool>> q{{{0, true}}};
    unordered_set<int> seen1, seen2;
    for (int f : forbidden) seen1.insert(f), seen2.insert(f);
    seen1.insert(0);
    int steps = 0;
    while (!q.empty()) {      
      int size = q.size();
      while (size--) {
        auto [cur, forward] = q.front(); q.pop();        
        if (cur == x) return steps;
        if (cur > kMaxPosition) continue; // no way to go back
        if (seen1.insert(cur + a).second)      
          q.emplace(cur + a, true);
        if (cur - b >= 0 && forward && seen2.insert(cur - b).second)
          q.emplace(cur - b, false);
      }
      ++steps;
    }
    return -1;
  }
};

You are a hiker preparing for an upcoming hike. You are given heights, a 2D array of size rows x columns, where heights[row][col] represents the height of cell (row, col). You are situated in the top-left cell, (0, 0), and you hope to travel to the bottom-right cell, (rows-1, columns-1) (i.e., 0-indexed). You can move up, down, left, or right, and you wish to find a route that requires the minimum effort.

A route’s effort is the maximum absolute differencein heights between two consecutive cells of the route.

Return the minimum effort required to travel from the top-left cell to the bottom-right cell.

Example 1:

Input: heights = [[1,2,2],[3,8,2],[5,3,5]]
Output: 2
Explanation: The route of [1,3,5,3,5] has a maximum absolute difference of 2 in consecutive cells.
This is better than the route of [1,2,2,2,5], where the maximum absolute difference is 3.

Example 2:

Input: heights = [[1,2,3],[3,8,4],[5,3,5]]
Output: 1
Explanation: The route of [1,2,3,4,5] has a maximum absolute difference of 1 in consecutive cells, which is better than route [1,3,5,3,5].

Example 3:

Input: heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]
Output: 0
Explanation: This route does not require any effort.

Constraints:

• rows == heights.length
• columns == heights[i].length
• 1 <= rows, columns <= 100
• 1 <= heights[i][j] <= 106

Solution: “Lazy BFS / DP”

dp[y][x] = min(max(dp[ty][tx], abs(h[ty][tx] – h[y][x]))) (x, y) and (tx, ty) are neighbors
repeat this process for at most rows * cols times.
if dp does not change after one round which means we found the optimal solution and can break earlier.

Time complexity: O(n^2*m^2))
Space complexity: O(nm)

// Author: Huahua, 824 ms
class Solution {
public:
  int minimumEffortPath(vector<vector<int>>& heights) {
    const int r = heights.size();
    const int c = heights[0].size();
    int dp[100][100];
    memset(dp, 0x7f, sizeof(dp));
    dp[0][0] = 0;
    vector<int> dirs{0, -1, 0, 1, 0};
    for (int k = 0; k < r * c; ++k) {
      bool stable = true;
      for (int y = 0; y < r; ++y)
        for (int x = 0; x < c; ++x)
          for (int d = 0; d < 4; ++d) {
            int tx = x + dirs[d];
            int ty = y + dirs[d + 1];
            if (tx < 0 || tx == c || ty < 0 || ty == r) continue;
            int t = max(dp[ty][tx], abs(heights[ty][tx] - heights[y][x]));
            if (t < dp[y][x]) {
              stable = false;
              dp[y][x] = t;
            }
          }    
      if (stable) break;
    }
    return dp[r - 1][c - 1];
  }
};

Solution 2: Binary Search + BFS

Use binary search to guess a cost and then check whether there is path that is under the cost.

Time complexity: O(mn*log(max(h) – min(h)))
Space complexity: O(mn)

// Author: Huahua, 620 ms
class Solution {
public:
  int minimumEffortPath(vector<vector<int>>& heights) {
    const int rows = heights.size();
    const int cols = heights[0].size();    
    vector<int> dirs{0, -1, 0, 1, 0};
    auto bfs = [&](int cost) -> bool {
      queue<pair<int, int>> q;
      vector<int> seen(cols * rows);
      q.emplace(0, 0);
      seen[0] = 1;
      while (!q.empty()) {
        auto [cx, cy] = q.front(); q.pop();
        if (cx == cols - 1 && cy == rows - 1) return true;
        for (int i = 0; i < 4; ++i) {
          int x = cx + dirs[i];
          int y = cy + dirs[i + 1];
          if (x < 0 || x == cols || y < 0 || y == rows) continue;
          if (abs(heights[cy][cx] - heights[y][x]) > cost) continue;
          if (seen[y * cols + x]++) continue;
          q.emplace(x, y);
        }          
      }
      return false;
    };
    int l = 0, r = 1e6 + 1;
    while (l < r) {
      const int m = l + (r - l) / 2;
      if (bfs(m)) {
        r = m;
      } else {
        l = m + 1;
      }
    }
    return l;
  }
};

Solution 3: Dijkstra

Time complexity: O(mnlog(mn))
Space complexity: O(mn)

// Author: Huahua, 216 ms
class Solution {
public:
  int minimumEffortPath(vector<vector<int>>& heights) {
    const vector<int> dirs{0, -1, 0, 1, 0}; 
    const int rows = heights.size();
    const int cols = heights[0].size();
    using Node = pair<int, int>;
    priority_queue<Node, vector<Node>, greater<Node>> q;
    vector<int> dist(rows * cols, INT_MAX / 2);    
    q.emplace(0, 0);
    dist[0] = 0;
    while (!q.empty()) {
      auto [t, u] = q.top(); q.pop();
      if (u == rows * cols - 1) return t;
      if (t > dist[u]) continue;
      const int ux = u % cols;
      const int uy = u / cols;
      for (int i = 0; i < 4; ++i) {
        const int x = ux + dirs[i];
        const int y = uy + dirs[i + 1];
        if (x < 0 || x == cols || y < 0 || y == rows) continue;
        const int v = y * cols + x;
        const int c = abs(heights[uy][ux] - heights[y][x]);
        if (max(t, c) >= dist[v]) continue;
        q.emplace(dist[v] = max(t, c), v);
      }
    }
    return -1;
  }
};

Roads are represented by connections where connections[i] = [a, b] represents a road from city a to b.

This year, there will be a big event in the capital (city 0), and many people want to travel to this city.

Your task consists of reorienting some roads such that each city can visit the city 0. Return the minimum number of edges changed.

It’s guaranteed that each city can reach the city 0 after reorder.

Example 1:

Input: n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
Output: 3
Explanation: Change the direction of edges show in red such that each node can reach the node 0 (capital).

Example 2:

Input: n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]
Output: 2
Explanation: Change the direction of edges show in red such that each node can reach the node 0 (capital).

Example 3:

Input: n = 3, connections = [[1,0],[2,0]]
Output: 0

Constraints:

• 2 <= n <= 5 * 10^4
• connections.length == n-1
• connections[i].length == 2
• 0 <= connections[i][0], connections[i][1] <= n-1
• connections[i][0] != connections[i][1]

Solution: BFS

Augment the graph
g[u][v] = 1, g[v][u] = 0, u->v is an edge in the original graph.

BFS from 0, sum up all the edge costs to visit all the nodes.

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

// Author: Huahua
class Solution {
public:
  int minReorder(int n, vector<vector<int>>& connections) {
    vector<vector<pair<int, int>>> g(n); // u -> {v, cost}
    for (const auto& e : connections) {
      g[e[0]].emplace_back(e[1], 1); // u -> v, needs flip
      g[e[1]].emplace_back(e[0], 0); // v -> u, no cost
    }
    int ans = 0;
    queue<int> q{{0}};
    vector<int> seen(n);
    while (!q.empty()) {
      int cur = q.front(); q.pop();
      seen[cur] = 1;
      for (const auto& [nxt, cost] : g[cur]) {
        if (seen[nxt]) continue;
        ans += cost;
        q.push(nxt);
      }
    }
    return ans;
  }
};

• 1 which means a street connecting the left cell and the right cell.
• 2 which means a street connecting the upper cell and the lower cell.
• 3 which means a street connecting the left cell and the lower cell.
• 4 which means a street connecting the right cell and the lower cell.
• 5 which means a street connecting the left cell and the upper cell.
• 6 which means a street connecting the right cell and the upper cell.

You will initially start at the street of the upper-left cell (0,0). A valid path in the grid is a path which starts from the upper left cell (0,0) and ends at the bottom-right cell (m - 1, n - 1). The path should only follow the streets.

Notice that you are not allowed to change any street.

Return true if there is a valid path in the grid or false otherwise.

Example 1:

Input: grid = [[2,4,3],[6,5,2]]
Output: true
Explanation: As shown you can start at cell (0, 0) and visit all the cells of the grid to reach (m - 1, n - 1).

Example 2:

Input: grid = [[1,2,1],[1,2,1]]
Output: false
Explanation: As shown you the street at cell (0, 0) is not connected with any street of any other cell and you will get stuck at cell (0, 0)

Example 3:

Input: grid = [[1,1,2]]
Output: false
Explanation: You will get stuck at cell (0, 1) and you cannot reach cell (0, 2).

Example 4:

Input: grid = [[1,1,1,1,1,1,3]]
Output: true

Example 5:

Input: grid = [[2],[2],[2],[2],[2],[2],[6]]
Output: true

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• 1 <= grid[i][j] <= 6

Solution: BFS

Need to check both sides (x, y) -> (tx, ty) and (tx, ty) -> (x, y) to make sure a path exist.

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

// Author: Huahua
class Solution {
public:
  bool hasValidPath(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<int> dirs{0, -1, 0, 1, 0}; // [up, left, down, right]    
    vector<set<int>> rules{
      {1, 3}, {0, 2}, {1, 2}, 
      {2, 3}, {0, 1}, {0, 3}};
    queue<int> q{{0}};
    vector<int> seen(m * n);
    seen[0] = 1;
    while (!q.empty()) {
      int cx = q.front() % n;
      int cy = q.front() / n;      
      q.pop();
      if (cx == n - 1 && cy == m - 1) return true;      
      for (int d : rules[grid[cy][cx] - 1]) {
        int x = cx + dirs[d];
        int y = cy + dirs[d + 1];
        int key = y * n + x;
        if (x < 0 || x >= n || y < 0 || y >= m || seen[key] 
           || !rules[grid[y][x] - 1].count((d + 2) % 4)) continue;
        seen[key] = 1;
        q.push(key);
      }
    }
    return false;
  }
};

Given an undirected tree consisting of n vertices numbered from 1 to n. A frog starts jumping from the vertex 1. In one second, the frog jumps from its current vertex to another unvisited vertex if they are directly connected. The frog can not jump back to a visited vertex. In case the frog can jump to several vertices it jumps randomly to one of them with the same probability, otherwise, when the frog can not jump to any unvisited vertex it jumps forever on the same vertex. 

The edges of the undirected tree are given in the array edges, where edges[i] = [fromi, toi] means that exists an edge connecting directly the vertices fromi and toi.

Return the probability that after t seconds the frog is on the vertex target.

Example 1:

Input: n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 2, target = 4
Output: 0.16666666666666666 
Explanation: The figure above shows the given graph. The frog starts at vertex 1, jumping with 1/3 probability to the vertex 2 after second 1 and then jumping with 1/2 probability to vertex 4 after second 2. Thus the probability for the frog is on the vertex 4 after 2 seconds is 1/3 * 1/2 = 1/6 = 0.16666666666666666. 

Example 2:

Input: n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 1, target = 7
Output: 0.3333333333333333
Explanation: The figure above shows the given graph. The frog starts at vertex 1, jumping with 1/3 = 0.3333333333333333 probability to the vertex 7 after second 1. 

Example 3:

Input: n = 7, edges = [[1,2],[1,3],[1,7],[2,4],[2,6],[3,5]], t = 20, target = 6
Output: 0.16666666666666666

Constraints:

• 1 <= n <= 100
• edges.length == n-1
• edges[i].length == 2
• 1 <= edges[i][0], edges[i][1] <= n
• 1 <= t <= 50
• 1 <= target <= n
• Answers within 10^-5 of the actual value will be accepted as correct.

Solution: BFS

key: if a node has children, the fog jumps to to children so the probability at current node will become 0.

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

// Author: Huahua
class Solution {
public:
  double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
    vector<double> p(n + 1);
    p[1] = 1.0;
    vector<vector<int>> g(n + 1);
    for (const auto& e : edges) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }
    vector<int> seen(n + 1);
    seen[1] = 1;
    queue<int> q{{1}};
    while (t--) {
      int size = q.size();      
      while (size--) {
        int cur = q.front(); q.pop();
        int children = 0;
        for (int nxt : g[cur])
          if (!seen[nxt]) ++children;
        for (int nxt : g[cur])
          if (!seen[nxt]++) {
            q.push(nxt);
            p[nxt] += p[cur] / children;
          }
        // key: fog jumps this node has children
        if (children > 0) p[cur] = 0.0;
      }
    }
    return p[target];
  }
};

class Solution:
  def frogPosition(self, n: int, edges: List[List[int]],
                   t: int, target: int) -> float:
    p = [0] + [1] + [0] * (n - 1)
    seen = [False] + [True] + [False] * (n - 1)    
    q = [1]
    g = [[] for _ in range(n + 1)]
    for i, j in edges:
      g[i].append(j)
      g[j].append(i)
    for _ in range(t):
      q2 = []
      for cur in q:
        children = sum([not seen[nxt] for nxt in g[cur]])
        for nxt in g[cur]:
          if seen[nxt]: continue
          seen[nxt] = True
          q2.append(nxt)
          p[nxt] = p[cur] / children
        if children > 0: p[cur] = 0
      q = q2
    return p[target]

Given a m x ngrid. Each cell of the grid has a sign pointing to the next cell you should visit if you are currently in this cell. The sign of grid[i][j] can be:

• 1 which means go to the cell to the right. (i.e go from grid[i][j] to grid[i][j + 1])
• 2 which means go to the cell to the left. (i.e go from grid[i][j] to grid[i][j - 1])
• 3 which means go to the lower cell. (i.e go from grid[i][j] to grid[i + 1][j])
• 4 which means go to the upper cell. (i.e go from grid[i][j] to grid[i - 1][j])

Notice that there could be some invalid signs on the cells of the grid which points outside the grid.

You will initially start at the upper left cell (0,0). A valid path in the grid is a path which starts from the upper left cell (0,0) and ends at the bottom-right cell (m - 1, n - 1) following the signs on the grid. The valid path doesn’t have to be the shortest.

You can modify the sign on a cell with cost = 1. You can modify the sign on a cell one time only.

Return the minimum cost to make the grid have at least one valid path.

Example 1:

Input: grid = [[1,1,1,1],[2,2,2,2],[1,1,1,1],[2,2,2,2]]
Output: 3
Explanation: You will start at point (0, 0).
The path to (3, 3) is as follows. (0, 0) --> (0, 1) --> (0, 2) --> (0, 3) change the arrow to down with cost = 1 --> (1, 3) --> (1, 2) --> (1, 1) --> (1, 0) change the arrow to down with cost = 1 --> (2, 0) --> (2, 1) --> (2, 2) --> (2, 3) change the arrow to down with cost = 1 --> (3, 3)
The total cost = 3.

Example 2:

Input: grid = [[1,1,3],[3,2,2],[1,1,4]]
Output: 0
Explanation: You can follow the path from (0, 0) to (2, 2).

Example 3:

Input: grid = [[1,2],[4,3]]
Output: 1

Example 4:

Input: grid = [[2,2,2],[2,2,2]]
Output: 3

Example 5:

Input: grid = [[4]]
Output: 0

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100

Solution 1: Lazy BFS (fake DP)

dp[i][j] := min steps to reach (i, j)

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

// Author: Huahua
class Solution {
public:
  int minCost(vector<vector<int>>& grid) {
    int m = grid.size();
    int n = grid[0].size();
    vector<vector<int>> dp(m, vector<int>(n, INT_MAX / 2));    
        
    dp[0][0] = 0;
    auto solve = [&](int x, int y) {
      int& v = dp[y][x];
      if (x > 0) v = min(v, dp[y][x - 1] + (grid[y][x - 1] != 1));
      if (y > 0) v = min(v, dp[y - 1][x] + (grid[y - 1][x] != 3));
      if (x < n - 1) v = min(v, dp[y][x + 1] + (grid[y][x + 1] != 2));
      if (y < m - 1) v = min(v, dp[y + 1][x] + (grid[y + 1][x] != 4));
    };
    
    // At most m + n steps to propagate the results to (m - 1, n -1).
    for (int k = 0; k <= (m + n); ++k) {
      for (int y = 0; y < m; ++y)
        for (int x = 0; x < n; ++x)
          solve(x, y);
      for (int y = m - 1; y >= 0; --y)
        for (int x = n - 1; x >= 0; --x)
          solve(x, y);
    }
    return dp[m - 1][n - 1];
  }
};

// Author: Huahua, 88 ms / 22.9 MB
class Solution {
public:
  int minCost(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<int>> dp(m, vector<int>(n, INT_MAX / 2));
    dp[0][0] = 0;
    while (true) {
      auto prev(dp);
      for (int i = 0; i < m; ++i)
        for (int j = 0; j < n; ++j) {
          if (i > 0) dp[i][j] = min(dp[i][j], dp[i - 1][j] + (grid[i - 1][j] != 3));
          if (j > 0) dp[i][j] = min(dp[i][j], dp[i][j - 1] + (grid[i][j - 1] != 1));
        }            
      for (int i = m - 1; i >= 0; --i)
        for (int j = n - 1; j >= 0; --j) {
          if (i != m - 1) dp[i][j] = min(dp[i][j], dp[i + 1][j] + (grid[i + 1][j] != 4));
          if (j != n - 1) dp[i][j] = min(dp[i][j], dp[i][j + 1] + (grid[i][j + 1] != 2));
        }
      if (prev == dp) break; // optimal solution obtained.
    }
    return dp[m - 1][n - 1];
  }
};

Solution 2: 0-1 BFS

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

// Author: Huahua
class Solution {
public:
  int minCost(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    deque<pair<int, int>> q{{0, 0}};
    vector<char> seen(m * n);
    vector<vector<int>> dirs{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    while (!q.empty()) {
      auto [p, cost] = q.front(); q.pop_front();
      int x = p % n, y = p / n;
      if (x == n - 1 && y == m - 1) return cost;
      if (seen[p]++) continue;
      for (int i = 0; i < 4; ++i) {
        int tx = x + dirs[i][0], ty = y + dirs[i][1];
        int tp = ty * n + tx;
        if (tx < 0 || ty < 0 || tx >= n || ty >= m || seen[tp]) continue;
        if (grid[y][x] == i + 1)
          q.emplace_front(tp, cost);
        else
          q.emplace_back(tp, cost + 1);
      }
    }    
    return -1;
  }
};

In one step you can jump from index i to index:

• i + 1 where: i + 1 < arr.length.
• i - 1 where: i - 1 >= 0.
• j where: arr[i] == arr[j] and i != j.

Return the minimum number of steps to reach the last index of the array.

Notice that you can not jump outside of the array at any time.

Example 1:

Input: arr = [100,-23,-23,404,100,23,23,23,3,404]
Output: 3
Explanation: You need three jumps from index 0 --> 4 --> 3 --> 9. Note that index 9 is the last index of the array.

Example 2:

Input: arr = [7]
Output: 0
Explanation: Start index is the last index. You don't need to jump.

Example 3:

Input: arr = [7,6,9,6,9,6,9,7]
Output: 1
Explanation: You can jump directly from index 0 to index 7 which is last index of the array.

Example 4:

Input: arr = [6,1,9]
Output: 2

Example 5:

Input: arr = [11,22,7,7,7,7,7,7,7,22,13]
Output: 3

Constraints:

• 1 <= arr.length <= 5 * 10^4
• -10^8 <= arr[i] <= 10^8

Solution: HashTable + BFS

Use a hashtable to store the indices of each unique number.

each index i has neighbors (i-1, i + 1, hashtable[arr[i]])

Use BFS to find the shortest path in this unweighted graph.

Key optimization, clear hashtable[arr[i]] after the first use, since all nodes are already on queue, no longer needed.

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

// Author: Huahua, 124 ms, 30.5 MB
class Solution {
public:
  int minJumps(vector<int>& arr) {
    const int n = arr.size();
    unordered_map<int, vector<int>> m;
    for (int i = 0; i < n; ++i)
      m[arr[i]].push_back(i);
    vector<int> seen(n);
    queue<int> q({0});    
    seen[0] = 1;
    int steps = 0;
    while (!q.empty()) {
      int size = q.size();
      while (size--) {
        int i = q.front(); q.pop();        
        if (i == n - 1) return steps;
        if (i - 1 >= 0 && !seen[i - 1]++) q.push(i - 1);
        if (i + 1 < n && !seen[i + 1]++) q.push(i + 1);
        auto it = m.find(arr[i]);
        if (it == m.end()) continue;
        for (int nxt : it->second)
          if (!seen[nxt]++) q.push(nxt);
        m.erase(it); // no longer needed.
      }
      ++steps;
    }
    return -1;
  }
};

Related Problems

• https://zxi.mytechroad.com/blog/greedy/leetcode-55-jump-game/
• https://zxi.mytechroad.com/blog/greedy/leetcode-45-jump-game-ii/
• https://zxi.mytechroad.com/blog/searching/leetcode-1306-jump-game-iii/
• https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-1344-jump-game-v/