dijkstra Archives - Huahua's Tech Road

花花酱 LeetCode 2662. Minimum Cost of a Path With Special Roads

zxi — Sun, 30 Apr 2023 18:03:03 +0000

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] = [x1_i, y1_i, x2_i, y2_i, cost_i] indicates that the i^th special road can take you from (x1_i, y1_i) to (x2_i, y2_i) with a cost equal to cost_i. 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 <= 10⁵
1 <= startY <= targetY <= 10⁵
1 <= specialRoads.length <= 200
specialRoads[i].length == 5
startX <= x1_i, x2_i <= targetX
startY <= y1_i, y2_i <= targetY
1 <= cost_i <= 10⁵

Solution: Dijkstra

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

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

C++

// Author: Huahua
class Solution {
public:
  int minimumCost(vector& start, vector& target, vector>& specialRoads) {
    unordered_map ids;
    vector> 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>> 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 dist(ids.size(), INT_MAX);
    dist[s] = 0;
    priority_queue, vector>, 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.

花花酱 LeetCode 2642. Design Graph With Shortest Path Calculator

zxi — Sat, 29 Apr 2023 19:16:35 +0000

There is a directed weighted graph that consists of n nodes numbered from 0 to n - 1. The edges of the graph are initially represented by the given array edges where edges[i] = [from_i, to_i, edgeCost_i] meaning that there is an edge from from_i to to_i with the cost edgeCost_i.

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 <= from_i, to_i, from, to, node1, node2 <= n - 1
1 <= edgeCost_i, edgeCost <= 10⁶
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)

C++

// Author: Huahua
class Graph {
public:
  Graph(int n, vector>& edges):
  n_(n),
  d_(n, vector(n, 1e18)) {
    for (int i = 0; i < n; ++i)
      d_[i][i] = 0;
    for (const vector& 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 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> 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²)

C++

// Author: Huahua
class Graph {
public:
    Graph(int n, vector>& edges): n_(n), g_(n) {
      for (const auto& e : edges)
        g_[e[0]].emplace_back(e[1], e[2]);
    }
    
    void addEdge(vector edge) {
      g_[edge[0]].emplace_back(edge[1], edge[2]);
    }
    
    int shortestPath(int node1, int node2) {
      vector dist(n_, INT_MAX);
      dist[node1] = 0;
      priority_queue, vector>, 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>> g_;
};

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

花花酱 LeetCode 1786. Number of Restricted Paths From First to Last Node

zxi — Sun, 07 Mar 2021 07:30:38 +0000

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] = [u_i, v_i, weight_i] denotes that there is an edge between nodes u_i and v_i with weight equal to weight_i.

A path from node start to node end is a sequence of nodes [z₀, z₁,z₂, ..., z_k] such that z₀= start and z_k = end and there is an edge between z_i and z_i+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(z_i) > distanceToLastNode(z_i+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 10⁹ + 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 * 10⁴
n - 1 <= edges.length <= 4 * 10⁴
edges[i].length == 3
1 <= u_i, v_i <= n
u_i!= v_i
1 <= weight_i <= 10⁵
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)

C++

// Author: Huahua
class Solution {
public:
  int countRestrictedPaths(int n, vector>& edges) {
    constexpr int kMod = 1e9 + 7;
    using PII = pair;    
    vector> 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 dist(n + 1, INT_MAX / 2);
    dist[n] = 0;
    priority_queue, std::greater> 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 dp(n + 1, INT_MAX);
    function 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

C++

// Author: Huahua
class Solution {
public:
  int countRestrictedPaths(int n, vector>& edges) {
    constexpr int kMod = 1e9 + 7;
    using PII = pair;    
    vector> 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 dist(n + 1, INT_MAX);
    vector dp(n + 1);
    dist[n] = 0;
    dp[n] = 1;
    priority_queue, std::greater> 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.

花花酱 LeetCode 1514. Path with Maximum Probability

zxi — Sun, 12 Jul 2020 05:44:28 +0000

You are given an undirected weighted graph of n nodes (0-indexed), represented by an edge list where edges[i] = [a, b] is an undirected edge connecting the nodes a and b with a probability of success of traversing that edge succProb[i].

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)

C++

// Author: Huahua
// Author: Huahua
class Solution {
public:
  double maxProbability(int n, vector>& edges, 
                        vector& succProb, int start, int end) {
    vector>> 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 dist(n, FLT_MAX);
    priority_queue> q;
    q.emplace(-0.0, start);
    vector 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;
  }
};

Java

// 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>>();
    for (int i = 0; i < n; ++i) g.add(new ArrayList>());
    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.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;
  }
}

Python3

# 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.

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

zxi — Mon, 27 Jan 2020 06:58:54 +0000

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>& edges, int distanceThreshold) {
    vector> dp(n, vector(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
// Author: Huahua
class Solution {
public:
  int findTheCity(int n, vector>& edges, int t) {
    vector>> 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 dist(n, INT_MAX / 2);
      set> q; // 
      vector>::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.