945. Minimum Increment to Make Array Unique
Given an array of integers A, a move consists of choosing any A[i], and incrementing it by 1.
Return the least number of moves to make every value in A unique.
Example 1:
Input: [1,2,2]
Output: 1
Explanation: After 1 move, the array could be [1, 2, 3].
Example 2:
Input: [3,2,1,2,1,7]
Output: 6
Explanation: After 6 moves, the array could be [3, 4, 1, 2, 5, 7].
It can be shown with 5 or less moves that it is impossible for the array to have all unique values.
Note:
0 <= A.length <= 400000 <= A[i] < 40000
Approach #1:
class Solution {
public:
int minIncrementForUnique(vector<int>& A) {
sort(A.begin(), A.end());
int move = 0;
for (int i = 1; i < A.size(); ++i) {
if (A[i] <= A[i-1]) {
int step= A[i] == A[i-1] ? 1 : A[i-1]+1-A[i];
A[i] += step;
move += step;
}
}
return move;
}
};
946. Validate Stack Sequences
Given two sequences pushed and popped with distinct values, return true if and only if this could have been the result of a sequence of push and pop operations on an initially empty stack.
Example 1:
Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
Output: true
Explanation: We might do the following sequence:
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
Example 2:
Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
Output: false
Explanation: 1 cannot be popped before 2.
Note:
0 <= pushed.length == popped.length <= 10000 <= pushed[i], popped[i] < 1000pushedis a permutation ofpopped.pushedandpoppedhave distinct values.
Approach #1:
class Solution {
public:
bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
stack<int> ipush;
queue<int> ipop;
for (int i = 0; i < popped.size(); ++i)
ipop.push(popped[i]);
for (int i = 0; i < pushed.size(); ++i) {
ipush.push(pushed[i]);
while (!ipush.empty() && ipush.top() == ipop.front()) {
ipush.pop();
ipop.pop();
}
}
return ipush.empty();
}
};
948. Bag of Tokens
You have an initial power P, an initial score of 0 points, and a bag of tokens.
Each token can be used at most once, has a value token[i], and has potentially two ways to use it.
- If we have at least
token[i]power, we may play the token face up, losingtoken[i]power, and gaining1point. - If we have at least
1point, we may play the token face down, gainingtoken[i]power, and losing1point.
Return the largest number of points we can have after playing any number of tokens.
Example 1:
Input: tokens = [100], P = 50
Output: 0
Example 2:
Input: tokens = [100,200], P = 150
Output: 1
Example 3:
Input: tokens = [100,200,300,400], P = 200
Output: 2
Note:
tokens.length <= 10000 <= tokens[i] < 100000 <= P < 10000
Approach #1:
class Solution {
public:
int bagOfTokensScore(vector<int>& tokens, int P) {
if (tokens.size() == 0) return 0;
sort(tokens.begin(), tokens.end());
if (P < tokens[0]) return 0;
int temp = 0, ans = 0;
int start = 0, end = tokens.size()-1;
while (start <= end && (temp > 0 || P >= tokens[ans])) {
if (P >= tokens[start]) {
P -= tokens[start];
temp++;
start++;
ans = max(ans, temp);
} else {
temp--;
P += tokens[end];
end--;
}
}
return ans;
}
};
947. Most Stones Removed with Same Row or Column
On a 2D plane, we place stones at some integer coordinate points. Each coordinate point may have at most one stone.
Now, a move consists of removing a stone that shares a column or row with another stone on the grid.
What is the largest possible number of moves we can make?
Example 1:
Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
Output: 5
Example 2:
Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
Output: 3
Example 3:
Input: stones = [[0,0]]
Output: 0
Note:
1 <= stones.length <= 10000 <= stones[i][j] < 10000
class Solution {
void color(vector<vector<int>> &G, vector<int> &C, int i, int c) {
C[i] = c;
for (int j : G[i]) {
if (C[j] == -1) color(G, C, j, c);
}
}
public:
int removeStones(vector<vector<int>> & stones) {
int N = stones.size();
vector<vector<int>> G(N);
for (int i = 0; i < N-1; i++) {
int x = stones[i][0];
int y = stones[i][1];
for (int j = i + 1; j < N; j++) {
if ((stones[j][0] == stones[i][0])||(stones[j][1] == stones[i][1])) {
G[i].push_back(j);
G[j].push_back(i);
}
}
}
vector<int> C(N, -1);
int c = 0;
for (int i = 0; i < N; i++) {
if (C[i] == -1) color(G, C, i, c++);
}
return N - c;
}
};
Approach #2: C++ [UnionFind]
class Solution {
public:
int removeStones(vector<vector<int>>& stones) {
for (int i = 0; i < stones.size(); ++i)
uni(stones[i][0], ~stones[i][1]);
return stones.size() - islands;
}
unordered_map<int, int> f;
int islands = 0;
int find(int x) {
if (!f.count(x)) f[x] = x, islands++;
if (x != f[x]) f[x] = find(f[x]);
return f[x];
}
void uni(int x, int y) {
x = find(x), y = find(y);
if (x != y) f[x] = y, islands--;
}
};
Approach #3: Python [DFS]
class Solution(object):
def removeStones(self, stones):
"""
:type stones: List[List[int]]
:rtype: int
"""
index = collections.defaultdict(set)
for i, j in stones:
index[i].add(j + 10000)
index[j+10000].add(i)
def dfs(i):
seen.add(i)
for j in index[i]:
if j not in seen:
dfs(j)
seen = set()
islands = 0
for i, j in stones:
if i not in seen:
islands += 1
dfs(i)
dfs(j + 10000)
return len(stones) - islands
come from:
https://www.jianshu.com/p/30d2058db7f7
https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/discuss/197659/C%2B%2B-solution-using-graph-coloring