Posts tagged as “graph”

花花酱 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;

}

};

花花酱 Minimum Spanning Tree (MST) 最小生成树 SP18

By zxi on January 24, 2020

Prim’s Algorithm

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

C++

// Author: Huahua

#include <iostream>

#include <queue>

#include <vector>

using namespace std;

int main(int argc, char** argv) {

const int n = 4;

vector<vector<int>> edges{{0,1,1},{0,3,3},{0,2,6},{2,3,2},{1,2,4},{1,3,5}};

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

}

priority_queue<pair<int, int>> q; // (-w, v)

vector<int> seen(n);

q.emplace(0, 0); // (-w, v)

int cost = 0;

for (int i = 0; i < n; ++i) {

while (true) {

const int w = -q.top().first;

const int v = q.top().second;

q.pop();

if (seen[v]++) continue;

cost += w;

for (const auto& p : g[v]) {

if (seen[p.first]) continue;

q.emplace(-p.second, p.first);

}

break;

}

cout << cost << endl;

return 0;

}

Python

# Author: Huahua

from collections import defaultdict

from heapq import *

n = 4

edges = [[0,1,1],[0,3,3],[0,2,6],[2,3,2],[1,2,4],[1,3,5]]

g = defaultdict(list)

for e in edges:

g[e[0]].append((e[1], e[2]))

g[e[1]].append((e[0], e[2]))

q = []

cost = 0

seen = set()

heappush(q, (0, 0))

for _ in range(n):

while True:

w, u = heappop(q)

if u in seen: continue

cost += w

seen.add(u)

for v, w in g[u]:

if v in seen: continue

heappush(q, (w, v))

break

print(cost)

Kruskal’s Algorithm

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

C++

// Author: Huahua

#include <iostream>

#include <queue>

#include <vector>

#include <functional>

#include <numeric>

using namespace std;

int main(int argc, char** argv) {

const int n = 4;

vector<vector<int>> edges{{0,1,1},{0,3,3},{0,2,6},{2,3,2},{1,2,4},{1,3,5}};

vector<vector<int>> q; // (w, u, v)

for (const auto& e : edges)

q.push_back({e[2], e[0], e[1]});

sort(begin(q), end(q));

vector<int> p(n);

iota(begin(p), end(p), 0);

function<int(int)> find = [&](int x) {

return x == p[x] ? x : p[x] = find(p[p[x]]);

};

int cost = 0;

for (const auto& t : q) {

int w = t[0], u = t[1], v = t[2];

int ru = find(u), rv = find(v);

if (ru == rv) continue;

p[ru] = rv; // merge (u, v)

cost += w;

}

cout << cost << endl;

return 0;

}

Python

from collections import defaultdict

from heapq import *

n = 4

edges = [[0,1,1],[0,3,3],[0,2,6],[2,3,2],[1,2,4],[1,3,5]]

p = list(range(n))

def find(x):

if x != p[x]: p[x] = find(p[p[x]])

return p[x]

cost = 0

for u, v, w in sorted(edges, key=lambda x: x[2]):

ru, rv = find(u), find(v)

if ru == rv: continue

p[ru] = rv

cost += w

print(cost)

花花酱 LeetCode 1319. Number of Operations to Make Network Connected

By zxi on January 11, 2020

There are n computers numbered from 0 to n-1 connected by ethernet cables connections forming a network where connections[i] = [a, b] represents a connection between computers a and b. Any computer can reach any other computer directly or indirectly through the network.

Given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected. Return the minimum number of times you need to do this in order to make all the computers connected. If it’s not possible, return -1.

Example 1:

Input: n = 4, connections = [[0,1],[0,2],[1,2]]
Output: 1
Explanation: Remove cable between computer 1 and 2 and place between computers 1 and 3.

Example 2:

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

Example 3:

Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
Output: -1
Explanation: There are not enough cables.

Example 4:

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

Constraints:

1 <= n <= 10^5
1 <= connections.length <= min(n*(n-1)/2, 10^5)
connections[i].length == 2
0 <= connections[i][0], connections[i][1] < n
connections[i][0] != connections[i][1]
There are no repeated connections.
No two computers are connected by more than one cable.

Solution 1: Union-Find

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

C++

// Author: Huahua

class Solution {

public:

int makeConnected(int n, vector<vector<int>>& connections) {

if (connections.size() < n - 1) return -1;

vector<int> p(n);

iota(begin(p), end(p), 0);

function<int(int)> find = [&](int x) {

return p[x] == x ? x : p[x] = find(p[x]);

};

for (const auto& c : connections)

p[find(c[0])] = find(c[1]);

unordered_set<int> s;

for (int i = 0; i < n; ++i)

s.insert(find(i));

return s.size() - 1;

}

};

Solution 2: DFS

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

C++

// Author: Huahua

class Solution {

public:

int makeConnected(int n, vector<vector<int>>& connections) {

if (connections.size() < n - 1) return -1;

vector<vector<int>> g(n);

for (const auto& c : connections) {

g[c[0]].push_back(c[1]);

g[c[1]].push_back(c[0]);

}

vector<int> seen(n);

int count = 0;

function<void(int)> dfs = [&](int cur) {

for (int nxt : g[cur])

if (!seen[nxt]++) dfs(nxt);

};

for (int i = 0; i < n; ++i)

if (!seen[i]++ && ++count)

dfs(i);

return count - 1;

}

};

花花酱 LeetCode 1298. Maximum Candies You Can Get from Boxes

By zxi on December 28, 2019

Given n boxes, each box is given in the format [status, candies, keys, containedBoxes] where:

status[i]: an integer which is 1 if box[i] is open and 0 if box[i] is closed.
candies[i]: an integer representing the number of candies in box[i].
keys[i]: an array contains the indices of the boxes you can open with the key in box[i].
containedBoxes[i]: an array contains the indices of the boxes found in box[i].

You will start with some boxes given in initialBoxes array. You can take all the candies in any open box and you can use the keys in it to open new boxes and you also can use the boxes you find in it.

Return the maximum number of candies you can get following the rules above.

Example 1:

Input: status = [1,0,1,0], candies = [7,5,4,100], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]
Output: 16
Explanation: You will be initially given box 0. You will find 7 candies in it and boxes 1 and 2. Box 1 is closed and you don't have a key for it so you will open box 2. You will find 4 candies and a key to box 1 in box 2.
In box 1, you will find 5 candies and box 3 but you will not find a key to box 3 so box 3 will remain closed.
Total number of candies collected = 7 + 4 + 5 = 16 candy.

Example 2:

Input: status = [1,0,0,0,0,0], candies = [1,1,1,1,1,1], keys = [[1,2,3,4,5],[],[],[],[],[]], containedBoxes = [[1,2,3,4,5],[],[],[],[],[]], initialBoxes = [0]
Output: 6
Explanation: You have initially box 0. Opening it you can find boxes 1,2,3,4 and 5 and their keys. The total number of candies will be 6.

Example 3:

Input: status = [1,1,1], candies = [100,1,100], keys = [[],[0,2],[]], containedBoxes = [[],[],[]], initialBoxes = [1]
Output: 1

Example 4:

Input: status = [1], candies = [100], keys = [[]], containedBoxes = [[]], initialBoxes = []
Output: 0

Example 5:

Input: status = [1,1,1], candies = [2,3,2], keys = [[],[],[]], containedBoxes = [[],[],[]], initialBoxes = [2,1,0]
Output: 7

Constraints:

1 <= status.length <= 1000
status.length == candies.length == keys.length == containedBoxes.length == n
status[i] is 0 or 1.
1 <= candies[i] <= 1000
0 <= keys[i].length <= status.length
0 <= keys[i][j] < status.length
All values in keys[i] are unique.
0 <= containedBoxes[i].length <= status.length
0 <= containedBoxes[i][j] < status.length
All values in containedBoxes[i] are unique.
Each box is contained in one box at most.
0 <= initialBoxes.length <= status.length
0 <= initialBoxes[i] < status.length

Solution: BFS

Only push boxes that we can open into the queue.

When can we open the box?
1. When we find it and have the key in hand.
2. When we find the key and have the box in hand.

Time complexity: O(B + K)
Space complexity: O(B)

C++

// Author: Huahua

class Solution {

public:

int maxCandies(vector<int>& status, vector<int>& candies, vector<vector<int>>& keys, vector<vector<int>>& containedBoxes, vector<int>& initialBoxes) {

vector<int> found(status.size());

vector<int> hasKeys(status);

queue<int> q;

for (int b : initialBoxes) {

found[b] = 1;

if (hasKeys[b]) q.push(b);

}

int ans = 0;

while (!q.empty()) {

int b = q.front();

q.pop();

ans += candies[b];

for (int t : containedBoxes[b]) {

found[t] = 1;

if (hasKeys[t]) q.push(t);

}

for (int t : keys[b]) {

if (!hasKeys[t] && found[t]) q.push(t);

hasKeys[t] = 1;

}

return ans;

}

};

花花酱 LeetCode 1202. Smallest String With Swaps

By zxi on September 22, 2019

You are given a string s, and an array of pairs of indices in the string pairs where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.

You can swap the characters at any pair of indices in the given pairs any number of times.

Return the lexicographically smallest string that s can be changed to after using the swaps.

Example 1:

Input: s = "dcab", pairs = [[0,3],[1,2]]
Output: "bacd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[1] and s[2], s = "bacd"

Example 2:

Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
Output: "abcd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[0] and s[2], s = "acbd"
Swap s[1] and s[2], s = "abcd"

Example 3:

Input: s = "cba", pairs = [[0,1],[1,2]]
Output: "abc"
Explaination: 
Swap s[0] and s[1], s = "bca"
Swap s[1] and s[2], s = "bac"
Swap s[0] and s[1], s = "abc"

Constraints:

1 <= s.length <= 10^5
0 <= pairs.length <= 10^5
0 <= pairs[i][0], pairs[i][1] < s.length
s only contains lower case English letters.

Solution: Connected Components

Use DFS / Union-Find to find all the connected components of swapable indices. For each connected components (index group), extract the subsequence of corresponding chars as a string, sort it and put it back to the original string in the same location.

e.g. s = “dcab”, pairs = [[0,3],[1,2]]
There are two connected components: {0,3}, {1,2}
subsequences:
1. 0,3 “db”, sorted: “bd”
2. 1,2 “ca”, sorted: “ac”
0 => b
1 => a
2 => c
3 => d
final = “bacd”

Time complexity: DFS: O(nlogn + k*(V+E)), Union-Find: O(nlogn + V+E)
Space complexity: O(n)

C++/DFS

// Author: Huahua, 268 ms, 89 MB

class Solution {

public:

string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {

vector<vector<int>> g(s.length());

for (const auto& e : pairs) {

g[e[0]].push_back(e[1]);

g[e[1]].push_back(e[0]);

}

unordered_set<int> seen;

vector<int> idx;

string tmp;

function<void(int)> dfs = [&](int cur) {

if (seen.count(cur)) return;

seen.insert(cur);

idx.push_back(cur);

tmp += s[cur];

for (int nxt : g[cur]) dfs(nxt);

};

for (int i = 0; i < s.length(); ++i) {

if (seen.count(i)) continue;

idx.clear();

tmp.clear();

dfs(i);

sort(begin(tmp), end(tmp));

sort(begin(idx), end(idx));

for (int k = 0; k < idx.size(); ++k)

s[idx[k]] = tmp[k];

}

return s;

}

};

C++/Union-Find

// Author: Huahua, 152 ms, 48.2 MB

class Solution {

public:

string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {

int n = s.length();

vector<int> p(n);

iota(begin(p), end(p), 0); // p = {0, 1, 2, ... n - 1}

function<int(int)> find = [&](int x) {

return p[x] == x ? x : p[x] = find(p[x]);

};

for (const auto& e : pairs)

p[find(e[0])] = find(e[1]); // union

vector<vector<int>> idx(n);

vector<string> ss(n);

for (int i = 0; i < s.length(); ++i) {

int id = find(i);

idx[id].push_back(i); // already sorted

ss[id].push_back(s[i]);

}

for (int i = 0; i < n; ++i) {

sort(begin(ss[i]), end(ss[i]));

for (int k = 0; k < idx[i].size(); ++k)

s[idx[i][k]] = ss[i][k];

}

return s;

}

};