Huahua’s Tech Road

花花酱 LeetCode 1585. Check If String Is Transformable With Substring Sort Operations

By zxi on September 13, 2020

Given two strings s and t, you want to transform string s into string t using the following operation any number of times:

Choose a non-empty substring in s and sort it in-place so the characters are in ascending order.

For example, applying the operation on the underlined substring in "14234" results in "12344".

Return true if it is possible to transform string s into string t. Otherwise, return false.

A substring is a contiguous sequence of characters within a string.

Example 1:

Input: s = "84532", t = "34852"
Output: true
Explanation: You can transform s into t using the following sort operations:
"84532" (from index 2 to 3) -> "84352"
"84352" (from index 0 to 2) -> "34852"

Example 2:

Input: s = "34521", t = "23415"
Output: true
Explanation: You can transform s into t using the following sort operations:
"34521" -> "23451"
"23451" -> "23415"

Example 3:

Input: s = "12345", t = "12435"
Output: false

Example 4:

Input: s = "1", t = "2"
Output: false

Constraints:

s.length == t.length
1 <= s.length <= 10⁵
s and t only contain digits from '0' to '9'.

Solution: Queue

We can move a smaller digit from right to left by sorting two adjacent digits.
e.g. 18572 -> 18527 -> 18257 -> 12857, but we can not move a larger to the left of a smaller one.

Thus, for each digit in the target string, we find the first occurrence of it in s, and try to move it to the front by checking if there is any smaller one in front of it.

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

C++

class Solution {

public:

bool isTransformable(string s, string t) {

vector<deque<int>> idx(10);

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

idx[s[i] - '0'].push_back(i);

for (char c : t) {

const int d = c - '0';

if (idx[d].empty()) return false;

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

if (!idx[i].empty() && idx[i].front() < idx[d].front())

return false;

idx[d].pop_front();

}

return true;

}

};

Python3

class Solution:

def isTransformable(self, s: str, t: str) -> bool:

idx = defaultdict(deque)

for i, c in enumerate(s):

idx[int(c)].append(i)

for c in t:

d = int(c)

if not idx[d]: return False

for i in range(d):

if idx[i] and idx[i][0] < idx[d][0]: return False

idx[d].popleft()

return True

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

Huahua's Tech Road

花花酱 LeetCode 1585. Check If String Is Transformable With Substring Sort Operations

C++

Python3

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

Solution: Minimum Spanning Tree

C++

C++

花花酱 LeetCode 1583. Count Unhappy Friends

Solution: HashTable

C++

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

Solution: Sum for each row and column

C++

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

Solution: Greedy + Spanning Tree / Union Find

C++

python3