Posts tagged as “shortest path”

花花酱 LeetCode 1334. Find the City With the Smallest Number of Neighbors at a Threshold Distance

By zxi on January 26, 2020

There are n cities numbered from 0 to n-1. Given the array edges where edges[i] = [from_i, to_i, weight_i] represents a bidirectional and weighted edge between cities from_i and to_i, 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 <= from_i < to_i < n
1 <= weight_i, distanceThreshold <= 10^4
All pairs (from_i, to_i) are distinct.

Solution1: Floyd-Warshall

All pair shortest path

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

C++

// 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)

C++

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

}

};

花花酱 LeetCode 1293. Shortest Path in a Grid with Obstacles Elimination

By zxi on December 14, 2019

iven a m * n grid, where each cell is either 0 (empty) or 1 (obstacle). In one step, you can move up, down, left or right from and to an empty cell.

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)

C++

// 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)

Bottom-Up

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

}

};

Top-Down

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;

}

};

花花酱 LeetCode 1138. Alphabet Board Path

By zxi on July 27, 2019

On an alphabet board, we start at position (0, 0), corresponding to character board[0][0].

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)

C++

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

}

};

花花酱 LeetCode 934. Shortest Bridge

By zxi on November 4, 2018

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 <= A.length = A[0].length <= 100
A[i][j] == 0 or A[i][j] == 1

Solution: DFS + BFS

Use DFS to find one island and color all the nodes as 2 (BLUE).
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)

C++

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

}

};

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:

0 <= edges.length <= 10000
0 <= edges[i][0] < edges[i][1] < N
There does not exist any i != j for which edges[i][0] == edges[j][0] and edges[i][1] == edges[j][1].
The original graph has no parallel edges.
0 <= edges[i][2] <= 10000
0 <= M <= 10^9
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;

}

};

Posts tagged as “shortest path”

花花酱 LeetCode 1334. Find the City With the Smallest Number of Neighbors at a Threshold Distance

Solution1: Floyd-Warshall

C++

C++

花花酱 LeetCode 1293. Shortest Path in a Grid with Obstacles Elimination

Solution: BFS

C++

Solution 2: DP

Bottom-Up

Top-Down

花花酱 LeetCode 1138. Alphabet Board Path

Solution: Manhattan walk

C++

花花酱 LeetCode 934. Shortest Bridge

Problem

Solution: DFS + BFS

C++

Related Problems

花花酱 LeetCode 882. Reachable Nodes In Subdivided Graph

Problem

Solution: Dijkstra Shortest Path