Huahua's Tech Road

花花酱 LeetCode 1584. Min Cost to Connect All Points

By zxi on September 13, 2020

You are given an array points representing integer coordinates of some points on a 2D-plane, where points[i] = [x_i, y_i].

Return the minimum cost to make all points connected. All points are connected if there is exactly one simple path between any two points.

Example 1:

Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
Output: 20
Explanation:

We can connect the points as shown above to get the minimum cost of 20.
Notice that there is a unique path between every pair of points.

Example 2:

Input: points = [[3,12],[-2,5],[-4,1]]
Output: 18

Example 3:

Input: points = [[0,0],[1,1],[1,0],[-1,1]]
Output: 4

Example 4:

Input: points = [[-1000000,-1000000],[1000000,1000000]]
Output: 4000000

Example 5:

Input: points = [[0,0]]
Output: 0

Constraints:

1 <= points.length <= 1000
-10⁶ <= x_i, y_i <= 10⁶
All pairs (x_i, y_i) are distinct.

Solution: Minimum Spanning Tree

Kruskal’s algorithm
Time complexity: O(n^2logn)
Space complexity: O(n^2)
using vector of vector, array, pair of pair, or tuple might lead to TLE…

C++

struct Edge {

int cost;

int x;

int y;

bool operator<(const Edge& e) const { return cost < e.cost; }

};

class Solution {

public:

int minCostConnectPoints(vector<vector<int>>& points) {

const int n = points.size();

vector<Edge> edges(n * (n - 1) / 2); // {cost, i, j}

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

for (int j = i + 1; j < n; ++j)

edges[idx++] = {abs(points[i][0] - points[j][0]) +

abs(points[i][1] - points[j][1]), i, j};

std::sort(begin(edges), end(edges));

vector<int> p(n);

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

vector<int> rank(n, 0);

int ans = 0;

int count = 0;

for (const auto& e : edges) {

int rx = find(p, e.x);

int ry = find(p, e.y);

if (rx == ry) continue;

ans += e.cost;

if (rank[rx] < rank[ry]) swap(rx, ry);

p[rx] = ry;

rank[ry] += rank[rx] == rank[ry];

if (++count == n - 1) break;

}

return ans;

}

private:

int find(vector<int>& p, int x) const {

while (p[x] != x) {

int tp = p[x];

p[x] = p[p[x]];

x = tp;

}

return x;

}

};

Prim’s Algorithm
ds[i] := min distance from i to ANY nodes in the tree.

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

C++

class Solution {

public:

int minCostConnectPoints(vector<vector<int>>& points) {

const int n = points.size();

auto dist = [](const vector<int>& pi, const vector<int>& pj) {

return abs(pi[0] - pj[0]) + abs(pi[1] - pj[1]);

};

vector<int> ds(n, INT_MAX);

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

ds[i] = dist(points[0], points[i]);

int ans = 0;

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

auto it = min_element(begin(ds), end(ds));

const int v = distance(begin(ds), it);

ans += ds[v];

ds[v] = INT_MAX; // done

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

if (ds[i] == INT_MAX) continue;

ds[i] = min(ds[i], dist(points[i], points[v]));

}

return ans;

}

};

花花酱 LeetCode 1583. Count Unhappy Friends

By zxi on September 12, 2020

You are given a list of preferences for n friends, where n is always even.

For each person i, preferences[i] contains a list of friends sorted in the order of preference. In other words, a friend earlier in the list is more preferred than a friend later in the list. Friends in each list are denoted by integers from 0 to n-1.

All the friends are divided into pairs. The pairings are given in a list pairs, where pairs[i] = [x_i, y_i] denotes x_i is paired with y_i and y_i is paired with x_i.

However, this pairing may cause some of the friends to be unhappy. A friend x is unhappy if x is paired with y and there exists a friend u who is paired with v but:

x prefers u over y, and
u prefers x over v.

Return the number of unhappy friends.

Example 1:

Input: n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]]
Output: 2
Explanation:
Friend 1 is unhappy because:
- 1 is paired with 0 but prefers 3 over 0, and
- 3 prefers 1 over 2.
Friend 3 is unhappy because:
- 3 is paired with 2 but prefers 1 over 2, and
- 1 prefers 3 over 0.
Friends 0 and 2 are happy.

Example 2:

Input: n = 2, preferences = [[1], [0]], pairs = [[1, 0]]
Output: 0
Explanation: Both friends 0 and 1 are happy.

Example 3:

Input: n = 4, preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], pairs = [[1, 3], [0, 2]]
Output: 4

Constraints:

2 <= n <= 500
n is even.
preferences.length == n
preferences[i].length == n - 1
0 <= preferences[i][j] <= n - 1
preferences[i] does not contain i.
All values in preferences[i] are unique.
pairs.length == n/2
pairs[i].length == 2
x_i != y_i
0 <= x_i, y_i <= n - 1
Each person is contained in exactly one pair.

Solution: HashTable

Put the order in a map {x -> {y, order}}, since this is dense, we use can 2D array instead of hasthable which is much faster.

Then for each pair, we just need to check every other pair and compare their orders.

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

C++

class Solution {

public:

int unhappyFriends(int n, vector<vector<int>>& preferences, vector<vector<int>>& pairs) {

vector<int> p(n);

for (const auto& pair : pairs) {

p[pair[0]] = pair[1];

p[pair[1]] = pair[0];

}

vector<vector<int>> orders(n, vector<int>(n));

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

for (int i = 0; i < preferences[x].size(); ++i)

orders[x][preferences[x][i]] = i;

int ans = 0;

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

const int y = p[x];

bool found = false;

for (int u = 0; u < n && !found; ++u) {

if (u == x || u == y) continue;

const int v = p[u];

found |= orders[x][u] < orders[x][y] && orders[u][x] < orders[u][v];

}

if (found) ++ans;

}

return ans;

}

};

花花酱 LeetCode 1582. Special Positions in a Binary Matrix

By zxi on September 12, 2020

Given a rows x cols matrix mat, where mat[i][j] is either 0 or 1, return the number of special positions in mat.

A position (i,j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed).

Example 1:

Input: mat = [[1,0,0],
              [0,0,1],
              [1,0,0]]
Output: 1
Explanation: (1,2) is a special position because mat[1][2] == 1 and all other elements in row 1 and column 2 are 0.

Example 2:

Input: mat = [[1,0,0],
              [0,1,0],
              [0,0,1]]
Output: 3
Explanation: (0,0), (1,1) and (2,2) are special positions.

Example 3:

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

Example 4:

Input: mat = [[0,0,0,0,0],
              [1,0,0,0,0],
              [0,1,0,0,0],
              [0,0,1,0,0],
              [0,0,0,1,1]]
Output: 3

Constraints:

rows == mat.length
cols == mat[i].length
1 <= rows, cols <= 100
mat[i][j] is 0 or 1.

Solution: Sum for each row and column

Brute force:
Time complexity: O(R*C*(R+C))
Space complexity: O(1)

We can pre-compute the sums for each row and each column, ans = sum(mat[r][c] == 1 and rsum[r] == 1 and csum[c] == 1)

Time complexity: O(R*C)
Space complexity: O(R+C)

C++

class Solution {

public:

int numSpecial(vector<vector<int>>& mat) {

const int rows = mat.size();

const int cols = mat[0].size();

vector<int> rs(rows);

vector<int> cs(cols);

for (int r = 0; r < rows; ++r)

for (int c = 0; c < cols; ++c) {

rs[r] += mat[r][c];

cs[c] += mat[r][c];

}

int ans = 0;

for (int r = 0; r < rows; ++r)

for (int c = 0; c < cols; ++c)

ans += mat[r][c] && rs[r] == 1 && cs[c] == 1;

return ans;

}

};

花花酱 LeetCode 1579. Remove Max Number of Edges to Keep Graph Fully Traversable

By zxi on September 6, 2020

Alice and Bob have an undirected graph of n nodes and 3 types of edges:

Type 1: Can be traversed by Alice only.
Type 2: Can be traversed by Bob only.
Type 3: Can by traversed by both Alice and Bob.

Given an array edges where edges[i] = [type_i, u_i, v_i] represents a bidirectional edge of type type_i between nodes u_i and v_i, find the maximum number of edges you can remove so that after removing the edges, the graph can still be fully traversed by both Alice and Bob. The graph is fully traversed by Alice and Bob if starting from any node, they can reach all other nodes.

Return the maximum number of edges you can remove, or return -1 if it’s impossible for the graph to be fully traversed by Alice and Bob.

Example 1:

Input: n = 4, edges = [[3,1,2],[3,2,3],[1,1,3],[1,2,4],[1,1,2],[2,3,4]]
Output: 2
Explanation: If we remove the 2 edges [1,1,2] and [1,1,3]. The graph will still be fully traversable by Alice and Bob. Removing any additional edge will not make it so. So the maximum number of edges we can remove is 2.

Example 2:

Input: n = 4, edges = [[3,1,2],[3,2,3],[1,1,4],[2,1,4]]
Output: 0
Explanation: Notice that removing any edge will not make the graph fully traversable by Alice and Bob.

Example 3:

Input: n = 4, edges = [[3,2,3],[1,1,2],[2,3,4]]
Output: -1
Explanation: In the current graph, Alice cannot reach node 4 from the other nodes. Likewise, Bob cannot reach 1. Therefore it's impossible to make the graph fully traversable.

Constraints:

1 <= n <= 10^5
1 <= edges.length <= min(10^5, 3 * n * (n-1) / 2)
edges[i].length == 3
1 <= edges[i][0] <= 3
1 <= edges[i][1] < edges[i][2] <= n
All tuples (type_i, u_i, v_i) are distinct.

Solution: Greedy + Spanning Tree / Union Find

Use type 3 (both) edges first.

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

C++

class DSU {

public:

DSU(int n): p_(n + 1), e_(0) {

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

}

int find(int x) {

if (p_[x] == x) return x;

return p_[x] = find(p_[x]);

}

int merge(int x, int y) {

int rx = find(x);

int ry = find(y);

if (rx == ry) return 1;

p_[rx] = ry;

++e_;

return 0;

}

int edges() const { return e_; }

private:

vector<int> p_;

int e_;

};

class Solution {

public:

int maxNumEdgesToRemove(int n, vector<vector<int>>& edges) {

int ans = 0;

DSU A(n), B(n);

for (const auto& e: edges) {

if (e[0] != 3) continue;

ans += A.merge(e[1], e[2]);

B.merge(e[1], e[2]);

}

for (const auto& e: edges) {

if (e[0] == 3) continue;

DSU& d = e[0] == 1 ? A : B;

ans += d.merge(e[1], e[2]);

}

return (A.edges() == n - 1 && B.edges() == n - 1) ? ans : -1;

}

};

python3

class DSU:

def __init__(self, n: int):

self.p = list(range(n))

self.e = 0

def find(self, x: int) -> int:

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

return self.p[x]

def merge(self, x: int, y: int) -> int:

rx, ry = self.find(x), self.find(y)

if rx == ry: return 1

self.p[rx] = ry

self.e += 1

return 0

class Solution:

def maxNumEdgesToRemove(self, n: int, edges: List[List[int]]) -> int:

A, B = DSU(n + 1), DSU(n + 1)

ans = 0

for t, x, y in edges:

if t != 3: continue

ans += A.merge(x, y)

B.merge(x, y)

for t, x, y in edges:

if t == 3: continue

d = A if t == 1 else B

ans += d.merge(x, y)

return ans if A.e == B.e == n - 1 else -1

花花酱 LeetCode 1578. Minimum Deletion Cost to Avoid Repeating Letters

By zxi on September 5, 2020

Given a string s and an array of integers cost where cost[i] is the cost of deleting the character i in s.

Return the minimum cost of deletions such that there are no two identical letters next to each other.

Notice that you will delete the chosen characters at the same time, in other words, after deleting a character, the costs of deleting other characters will not change.

Example 1:

Input: s = "abaac", cost = [1,2,3,4,5]
Output: 3
Explanation: Delete the letter "a" with cost 3 to get "abac" (String without two identical letters next to each other).

Example 2:

Input: s = "abc", cost = [1,2,3]
Output: 0
Explanation: You don't need to delete any character because there are no identical letters next to each other.

Example 3:

Input: s = "aabaa", cost = [1,2,3,4,1]
Output: 2
Explanation: Delete the first and the last character, getting the string ("aba").

Constraints:

s.length == cost.length
1 <= s.length, cost.length <= 10^5
1 <= cost[i] <= 10^4
s contains only lowercase English letters.

Solution: Group by group

For a group of same letters, delete all expect the one with the highest cost.

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

C++

class Solution {

public:

int minCost(string s, vector<int>& cost) {

int t = cost[0];

int m = cost[0];

int ans = 0;

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

if (s[i] != s[i - 1]) {

ans += t - m;

t = m = 0;

}

t += cost[i];

m = max(m, cost[i]);

}

return ans + (t - m);

}

};

python3

class Solution:

def minCost(self, s: str, cost: List[int]) -> int:

s = '*' + s + '*'

cost = [0] + cost + [0]

ans = t = m = 0

for i in range(1, len(s)):

if s[i] != s[i - 1]:

ans += t - m

t = m = 0

t += cost[i]

m = max(m, cost[i])

return ans