力扣周赛代码分享
80 场双周
第一题
class Solution {
public:
bool strongPasswordCheckerII(string pd) {
string t = "!@#$%^&*()-+";
unordered_set<char> st;
for (char& c : t) st.insert(c);
int lf = 0, gf = 0, nf = 0, tf = 0, f = 1;
for (int i = 0; i < pd.size(); ++ i) {
char c = pd[i];
if (c >= 'a' && c <= 'z') lf = 1;
if (c >= 'A' && c <= 'Z') gf = 1;
if (c >= '0' && c <= '9') nf = 1;
if (st.count(c)) tf = 1;
if (i && pd[i] == pd[i - 1]) {
f = 0;
break;
}
}
if (lf && gf && nf && tf && f && pd.size() >= 8) return true;
return false;
}
};
第二题
class Solution {
public:
vector<int> successfulPairs(vector<int>& sl, vector<int>& ps, long long ss) {
sort(ps.begin(), ps.end());
vector<int> ret;
for (int& i : sl) {
int x = lower_bound(ps.begin(), ps.end(), (ss + i - 1) / i) - ps.begin();
ret.push_back(ps.size() - x);
}
return ret;
}
};
第三题
class Solution {
public:
bool matchReplacement(string s, string sb, vector<vector<char>>& ms) {
unordered_map<char, multiset<char>> mp;
for (auto& it : ms) {
mp[it[0]].insert(it[1]);
}
for (int i = 0; i <= s.size() - sb.size(); ++ i) {
int f = 1;
for (int k = i; k < s.size() && k - i < sb.size(); ++ k) {
if (s[k] != sb[k - i]) {
if (mp.count(sb[k - i]) && mp[sb[k - i]].count(s[k])) {
}else {
f = 0;
break;
}
}
}
if (f) return true;
}
return false;
}
};
第四题
#define ll long long
class Solution {
public:
long long countSubarrays(vector<int>& nums, long long k) {
int n = nums.size();
ll ret = 0;
int i = 0;
ll sum = 0;
for (int j = 0; j < n; j++) {
sum += nums[j];
while (i <= j && sum * (j - i + 1) >= k) {
sum -= nums[i];
i ++;
}
ret += j - i + 1;
}
return ret;
}
};
296 场单周
第一题
class Solution {
public:
int minMaxGame(vector<int>& nums) {
while (nums.size() > 1) {
vector<int> tt;
int f = 1;
for (int i = 0; i < nums.size(); i += 2) {
int t;
if (f) {
t = min(nums[i], nums[i + 1]);
f = 0;
}else {
t = max(nums[i], nums[i + 1]);
f = 1;
}
tt.push_back(t);
}
nums = tt;
}
return nums[0];
}
};
第二题
class Solution {
public:
int partitionArray(vector<int>& nums, int k) {
sort(nums.begin(), nums.end());
int ret = 0;
for (int i = 0; i < nums.size(); ++ i) {
int j = i;
while (j < nums.size() && nums[j] - nums[i] <= k) ++ j;
i = j - 1;
++ ret;
}
return ret;
}
};
第三题
class Solution {
public:
static const int N = 1e6 + 5;
int h[N], e[N], ne[N], idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
unordered_map<int, int> mp;
vector<int> arrayChange(vector<int>& nums, vector<vector<int>>& os) {
memset(h, -1, sizeof h);
for (int i = 0; i < nums.size(); ++ i) {
add(nums[i], i);
}
for (auto& it : os) {
int a = it[0], b = it[1];
int j = h[a];
while (ne[j] != -1) {
j = ne[j];
}
ne[j] = h[b];
h[b] = h[a];
h[a] = -1;
}
vector<int> ret(nums.size());
for (int i = 1; i <= 1e6; ++ i) {
for (int j = h[i]; j != -1; j = ne[j]) {
ret[e[j]] = i;
}
}
return ret;
}
};
第四题
class TextEditor {
vector<char> left, right;
public:
TextEditor() {
}
void addText(string text) {
left.insert(left.end(), text.begin(), text.end());
}
int deleteText(int k) {
int t = k;
while (k && left.size()) {
left.pop_back();
-- k;
}
return t - k;
}
string to_text() {
return string(next(left.begin(), max((int)left.size() - 10, 0)), left.end());
}
string cursorLeft(int k) {
while (k && left.size()) {
-- k;
right.push_back(left.back());
left.pop_back();
}
return to_text();
}
string cursorRight(int k) {
while (k && right.size()) {
left.push_back(right.back());
right.pop_back();
-- k;
}
return to_text();
}
};
/**
* Your TextEditor object will be instantiated and called as such:
* TextEditor* obj = new TextEditor();
* obj->addText(text);
* int param_2 = obj->deleteText(k);
* string param_3 = obj->cursorLeft(k);
* string param_4 = obj->cursorRight(k);
*/
295 场单周
第一题
class Solution {
public:
int rearrangeCharacters(string s, string t) {
int cnt[26];
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < s.size(); ++ i) {
cnt[s[i] - 'a'] ++;
}
int cnt2[26];
memset(cnt2, 0, sizeof cnt2);
for (char c : t) {
cnt2[c - 'a'] ++;
}
int ret = 1e5;
for (char c : t) {
ret = min(ret, cnt[c - 'a'] / cnt2[c - 'a']);
}
return ret;
}
};
第二题
class Solution {
public:
string ToString(double val)//doule转string
{
stringstream ss;
ss << setiosflags(ios::fixed) << setprecision(2) << val;//保留两位小数
string str = ss.str();
return str;
}
string discountPrices(string s, int d) {
stringstream ss;
ss << s;
string ret;
while (ss) {
string t;
ss >> t;
if (ret.size() && t.size()) ret += " ";
if (t[0] == '$' && t.size() > 1) {
double x = 0;
int j = 1;
int f = 0;
while (j < t.size()) {
if (t[j] < '0' || t[j] > '9') {
f = 1;
break;
}
x *= 10;
x += (t[j] - '0');
++ j;
}
if (f) {
ret += t;
}else {
x = x * (100 - d) / 100;
string tt;
// tt = to_string(x);
// for (int j = 0; j < tt.size(); ++ j) {
// if (tt[j] == '.') {
// if (tt[j + 3] >= '5') {
// tt[j + 2] ++
// }
// tt = tt.substr(0, j + 3);
// }
// }
ret += "$" + ToString(x);
}
}else {
ret += t;
}
}
return ret;
}
};
第三题
class Solution {
public:
int totalSteps(vector<int>& nums) {
int ret = 0;
stack<pair<int, int> > st;
for (int num : nums) {
int mx = 0;
while (st.size() && st.top().first <= num) {
mx = max(st.top().second, mx);
st.pop();
}
if (st.size()) ++ mx;
ret = max(ret, mx);
st.push({num, mx});
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 1e6 + 5;
int dist[N];
int dx[4] = {0, 1, -1, 0};
int dy[4] = {1, 0, 0, -1};
int minimumObstacles(vector<vector<int>>& g) {
int n = g.size();
int m = g[0].size();
queue<int> q;
memset(dist, 0x3f, sizeof dist);
q.push(0);
dist[0] = 0;
while (q.size()) {
int sz = q.size();
for (int i = 0; i < sz; ++ i) {
int t = q.front();
q.pop();
int x = t / m;
int y = t % m;
for (int k = 0; k < 4; ++ k) {
int tx = x + dx[k];
int ty = y + dy[k];
if (tx < 0 || tx >= n || ty < 0 || ty >= m) continue;
int tot = tx * m + ty;
// cout << tot << endl;
if (dist[tot] > dist[t] + g[tx][ty]) {
q.push(tot);
dist[tot] = dist[t] + g[tx][ty];
}
}
}
}
return dist[(n - 1) * m + (m - 1)];
}
};
79 场双周
第一题
class Solution {
public:
bool digitCount(string num) {
int cnt[10];
memset(cnt, 0, sizeof cnt);
for (char& c : num) {
cnt[c - '0'] ++;
}
for (int i = 0; i < num.size(); ++ i) {
if ((num[i] - '0') != cnt[i]) return false;
}
return true;
}
};
第二题
class Solution {
public:
string largestWordCount(vector<string>& ms, vector<string>& ss) {
vector<pair<string, int>> ret;
map<string, int> mp;
for (int i = 0; i < ss.size(); ++ i) {
stringstream st;
st << ms[i];
int cnt = 0;
while (st) {
string t;
st >> t;
if (t.size()) ++ cnt;
}
// ret.push_back({ss[i], cnt});
mp[ss[i]] += cnt;
}
for (auto& [c, v] : mp) {
ret.push_back({c, v});
}
sort(ret.begin(), ret.end(), [](pair<string, int>& a, pair<string, int>& b) {
if (a.second != b.second) return a.second > b.second;
else {
return a.first > b.first;
}
});
return ret[0].first;
}
};
第三题
class Solution {
public:
long long maximumImportance(int n, vector<vector<int>>& rs) {
long long ret = 0;
unordered_map<int, int> mp;
for (auto it : rs) {
mp[it[0]] ++;
mp[it[1]] ++;
}
vector<int> tt;
for (auto& [c, v] : mp) {
tt.push_back(v);
}
sort(tt.begin(), tt.end());
// for (int i = n; i >)
int i = n;
for (int j = tt.size() - 1; j >= 0; -- j) {
// cout << tt[j] << " " << i << endl;
ret += (long long )tt[j] * i;
-- i;
}
return ret;
}
};
第四题
class BookMyShow {
static const int N = 1E5 + 5;
struct node{
int l, r;
long long sum = 0, val = 0;
}tr[N * 4];
void push_up(int u) {
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
tr[u].val = min(tr[u << 1].val, tr[u << 1 | 1].val);
}
void built(int u, int l, int r) {
tr[u] = {l, r};
if (l == r) return;
int mid = l + r >> 1;
built(u << 1, l, mid);
built(u << 1 | 1, mid + 1, r);
}
void add(int u, int idx, int val) {
if (tr[u].l == idx && tr[u].r == idx) {
tr[u].sum += val;
tr[u].val += val;
return;
}
int mid = tr[u].l + tr[u].r >> 1;
if (idx <= mid) {
add(u << 1, idx, val);
}else {
add(u << 1 | 1, idx, val);
}
push_up(u);
}
pair<int, int> look_for(int u, int val, int R) {
if (tr[u].val > val) return {-1, -1};
if (tr[u].l == tr[u].r) {
if (tr[u].l > R) {
return {-1, -1};
}
return {tr[u].l, tr[u].sum};
}
if (tr[u << 1].val <= val) {
return look_for(u << 1, val, R);
}else if (tr[u << 1 | 1].val <= val) {
return look_for(u << 1 | 1, val, R);
}
return {-1, -1};
}
long long query_sum(int u, int l, int r) {
if (l <= tr[u].l && tr[u].r <= r) return tr[u].sum;
int mid = l + r >> 1;
long long ret = 0;
if (l <= mid) ret += query_sum(u << 1, l, r);
if (r > mid) ret += query_sum(u << 1 | 1, l, r);
return ret;
}
public:
int n, m;
BookMyShow(int n, int m) {
this->n = n, this->m = m;
built(1, 0, n - 1);
}
vector<int> gather(int k, int maxRow) {
pair<int, int> idx = look_for(1, m - k, maxRow);
if (idx.first == -1) return {};
add(1, idx.first, k);
return {idx.first, idx.second};
}
bool scatter(int k, int maxRow) {
long long ret = query_sum(1, 0, maxRow);
// if (maxRow == 0)
// cout << ret << endl;
if ((long long)m * (maxRow + 1) - ret < k) return false;
while (k) {
// if (maxRow == 0)
// cout << k << endl;
auto it = look_for(1, m - 1, maxRow);
long long res = (m - it.second);
if (k <= res) {
add(1, it.first, k);
k -= k;
}else {
add(1, it.first, res);
k -= res;
}
}
return true;
}
};
/**
* Your BookMyShow object will be instantiated and called as such:
* BookMyShow* obj = new BookMyShow(n, m);
* vector<int> param_1 = obj->gather(k,maxRow);
* bool param_2 = obj->scatter(k,maxRow);
*/
293 场单周
第一题
class Solution {
public:
vector<string> removeAnagrams(vector<string>& words) {
vector<string> ret;
ret.push_back(words[0]);
for (int i = 1; i < words.size(); ++ i) {
string s = ret.back();
sort(s.begin(), s.end());
string t = words[i];
sort(t.begin(), t.end());
if (t == s) continue;
else ret.push_back(words[i]);
}
return ret;
}
};
第二题
class Solution {
public:
int maxConsecutive(int bm, int top, vector<int>& sl) {
int ret = 0;
sort(sl.begin(), sl.end());
for (int i = 1; i < sl.size(); ++ i) {
ret = max(sl[i] - sl[i - 1] - 1, ret);
}
ret = max(ret, sl[0] - bm);
ret = max(ret, top - sl[sl.size() - 1]);
return ret;
}
};
第三题
class Solution {
public:
int largestCombination(vector<int>& c) {
int cnt[28];
memset(cnt, 0, sizeof cnt);
int ret = 0;
for (int& x : c) {
for (int i = 0; i < 28; ++ i) {
if (x >> i & 1) {
++ cnt[i];
ret = max(ret, cnt[i]);
}
}
}
return ret;
}
};
第四题
#define ls(x) tr[x].L
#define rs(x) tr[x].R
class CountIntervals {
static const int N = 8e5 + 5;
struct node{
int l, r, cnt = 0;
int L = -1, R = -1;
}tr[N];
int idx = 1;
void push_up(int u) {
tr[u].cnt = 0;
if (ls(u) != -1) {
tr[u].cnt += tr[ls(u)].cnt;
}
if (rs(u) != -1) {
tr[u].cnt += tr[rs(u)].cnt;
}
}
void add2(int u, int l, int r) {
if (tr[u].l == tr[u].r) {
tr[u].cnt = 1;
return;
}
if (l <= tr[u].l && r >= tr[u].r) {
tr[u].cnt = tr[u].r - tr[u].l + 1;
return;
}
if (tr[u].cnt == tr[u].r - tr[u].l + 1) return;
int mid = (tr[u].l + tr[u].r) >> 1;
if (l <= mid) {
int& L = ls(u);
if (L == -1) {
L = idx ++;
tr[L] = {tr[u].l, mid};
}
add2(L, l, r);
}
if (r > mid) {
int& R = rs(u);
if (R == -1) {
R = idx ++;
tr[R] = {mid + 1, tr[u].r};
}
add2(R, l, r);
}
push_up(u);
}
public:
CountIntervals() {
tr[idx ++] = {1, 1000000005, 0};
}
void add(int left, int right) {
add2(1, left, right);
// cout << idx << endl;
}
int count() {
// cout << idx << endl;
return tr[1].cnt;
}
};
/**
* Your CountIntervals object will be instantiated and called as such:
* CountIntervals* obj = new CountIntervals();
* obj->add(left,right);
* int param_2 = obj->count();
*/
78 场双周
第一题
class Solution {
public:
int divisorSubstrings(int num, int k) {
string s = to_string(num);
int n = s.size();
for (int len = k; len <= k; ++ len) {
int cnt = 0;
for (int i = 0; i + len - 1 < n; ++ i) {
int t = 0;
for (int j = i; j < i + len; ++ j) {
t *= 10;
t += s[j] - '0';
}
if (t && num % t == 0) ++ cnt;
}
return cnt;
}
return 0;
}
};
第二题
class Solution {
public:
int waysToSplitArray(vector<int>& nums) {
long long sum = 0;
for (int& x : nums) sum += x;
long long cur = 0;
int ret = 0;
for (int i = 0; i < nums.size() - 1; ++ i) {
cur += nums[i];
if (cur >= sum - cur) ++ ret;
}
return ret;
}
};
第三题
class Solution {
public:
int maximumWhiteTiles(vector<vector<int>>& ts, int cn) {
-- cn;
sort(ts.begin(), ts.end(), [](vector<int>& a, vector<int>& b) {
return a[0] < b[0];
});
// long long sum = 0;
for (int i = 0; i < ts.size(); ++ i) {
ts[i].push_back(ts[i][1] - ts[i][0] + 1);
// sum += ts[i][2];
}
int ret = 0;
// cout << ts[0][0] << " " << ts[ts.size() - 1][1] << endl;
// cout << sum << " " << ts[0][2] << " " << ts[10][2] << endl;
// sum = 0;
// for (int i = 1; i < ts.size() - 1; ++ i) {
// sum += ts[i][2];
// }
// cout << sum << endl;
for (int i = 0; i < ts.size(); ++ i) {
int t = ts[i][0] + cn;
int l = i, r = ts.size();
while (l < r) {
int mid = l + r >> 1;
if (ts[mid][0] <= t) {
l = mid + 1;
}else {
r = mid;
}
}
-- l;
// cout << i << " " << l << " " << ts.size() << endl;
int cnt = 0;
for (int j = i + 1; j < l; ++ j) {
cnt += ts[j][2];
}
// cout << cnt << endl;
cnt += min((int)ts[i][2], t - ts[i][0] + 1);
// cout << ts[i][1] << " " << ts[i][0] << " " << ts[i].size() << endl;
// cout << cnt << endl;
if (l > i)
cnt += min((int)ts[l][2], t - ts[l][0] + 1);
// cout << t << " " << l << " " << cnt << endl;
// cout << cnt << endl;
ret = max(ret, cnt);
if (t >= ts[ts.size() - 1][1]) return ret;
}
for (int i = ts.size() - 1; i >= 0; -- i) {
int t = ts[i][1] - cn;
int l = i, r = -1;
while (l > r) {
int mid = (l + r + 1) >> 1;
if (ts[mid][1] > t) {
l = mid - 1;
}else {
r = mid;
}
}
++ l;
int cnt = 0;
for (int j = i - 1; j > l; -- j) {
cnt += ts[j][2];
}
cnt += min((int)ts[i][2], ts[i][1] - t + 1);
// cout << cnt << endl;
// ut << ts[i][1] << " " << ts[i][0] << " " << ts[i].size() << endl;
if (l < i)
cnt += min((int)ts[l][2], ts[l][1]- t + 1);
// cout << t << " " << l << " " << cnt << endl;
ret = max(ret, cnt);
}
return ret;
}
};
第四题
class Solution {
public:
int largestVariance(string s) {
int ret = 0;
int n = s.size();
for (int i = 'a'; i <= 'z'; ++ i) {
for (int j = 'a'; j <= 'z'; ++ j) {
if (i == j) continue;
for (int k = 0, dp0 = -1e8, dp1 = -1e8; k < n; ++ k) {
int v = 0;
if (s[k] == i) v = 1;
else if (s[k] == j) v = -1;
if (v == -1) {
dp1 = max(dp0 + v, v);
}else {
dp1 = dp1 + v;
}
dp0 = max(dp0 + v, v);
ret = max(ret, dp1);
}
}
}
return ret;
}
};
56 场双周
第一题
class Solution {
public:
int countTriples(int n) {
int ret = 0;
for (int i = 1; i <= n; ++ i) {
for (int j = 1; j <= n; ++ j) {
if (j == i) continue;
for (int k = 1; k <= n; ++ k) {
if (k == i || k == j) continue;
if (i * i + j * j == k * k) ++ ret;
}
}
}
return ret;
}
};
第二题
#define x first
#define y second
class Solution {
public:
int dx[4] = {0, 1, -1, 0};
int dy[4] = {-1, 0, 0, 1};
pair<int, int> q[100005];
int nearestExit(vector<vector<char>>& me, vector<int>& e) {
// queue<pair<int, int> > q;
// q.push({e[0], e[1]});
q[0] = {e[0], e[1]};
int cnt = 0;
int n = me.size();
int m = me[0].size();
me[e[0]][e[1]] = '+';
int hh = 0, tt = 0;
while (hh <= tt) {
// int sz = q.size();
int sz = tt - hh + 1;
for (int i = 0; i < sz; ++ i) {
// auto& t = q.front();
// q.pop();
auto& t = q[hh ++];
// cout << t.x << " " << t.y << " " << endl;
for (int k = 0; k < 4; ++ k) {
int xt = t.x + dx[k];
int yt = t.y + dy[k];
if (xt < 0 || xt >= n || yt < 0 || yt >= m) {
if (cnt) return cnt;
continue;
}
if (me[xt][yt] == '+') continue;
me[xt][yt] = '+';
// q.push({xt, yt});
q[++ tt] = {xt, yt};
}
}
if (tt - hh + 1 > 0)
++ cnt;
}
return -1;
}
};
第三题
class Solution {
public:
bool sumGame(string num) {
int lq = 0, lcnt = 0, rq = 0, rcnt = 0;
for (int i = 0; i < num.size(); ++ i) {
if (i < num.size() / 2) {
if (num[i] == '?') {
++ lq;
}else {
lcnt += num[i] - '0';
}
}else {
if (num[i] == '?') {
++ rq;
}else {
rcnt += num[i] - '0';
}
}
}
if (lcnt == rcnt) {
return lq != rq;
}
else if (lcnt < rcnt) {
swap(lcnt, rcnt);
swap(lq, rq);
}
if (lq >= rq) return true;
lcnt -= rcnt;
rq -= lq;
// cout << lcnt << " " << rq<< endl;
int b = rq / 2;
int a = rq - b;
if (lcnt >= a * 9 && lcnt <= b * 9) return false;
return true;
}
};
第四题
class Solution {
public:
static const int N = 1E3 + 5;
int dist[N][N];
int minCost(int me, vector<vector<int>>& es, vector<int>& ps) {
memset(dist, 0x3f, sizeof dist);
dist[0][0] = ps[0];
for (int i = 1; i <= me; ++ i) {
for (auto& it : es) {
int a = it[0], b = it[1], c = it[2];
if (i - c >= 0) {
dist[i][a] = min(dist[i][a], dist[i - c][b] + ps[a]);
dist[i][b] = min(dist[i][b], dist[i - c][a] + ps[b]);
}
}
}
int ret = 1e6 + 5;
for (int i = 0; i <= me; ++ i) {
ret = min(ret, dist[i][ps.size() - 1]);
}
return ret == 1e6 + 5 ? -1 : ret;
}
};
292 场周赛
第一题
class Solution {
public:
string largestGoodInteger(string num) {
string ret = "";
for (int i = 0; i < num.size(); ++ i) {
string t = num.substr(i, 3);
if (t[0] == t[1] && t[0] == t[2] && t > ret) {
ret = t;
}
}
return ret;
}
};
第二题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int ret = 0;
pair<int, int> dfs(TreeNode* root) {
pair<int, int> l = {0, 0}, r = {0, 0};
if (root->left) {
l = dfs(root->left);
}
if (root->right) {
r = dfs(root->right);
}
int v = root->val;
if (v == (l.first + r.first + v) / (l.second + r.second + 1) ) ++ ret;
return {v + l.first + r.first, l.second + r.second + 1};
}
int averageOfSubtree(TreeNode* root) {
dfs(root);
return ret;
}
};
第三题
class Solution {
public:
static const int N = 1E5 + 5;
int f[N], g[N];
int countTexts(string ps) {
f[0] = 1;
g[0] = 1;
int p = 1e9 + 7;
for (int i = 1; i < N; ++ i) {
for (int j = 1; j <= 3; ++ j) {
if (i >= j) f[i] = (f[i] + f[i - j]) % p;
}
for (int j = 1; j <= 4; ++ j) {
if (i >= j) g[i] = (g[i] + g[i - j]) % p;
}
}
long long ret = 1;
for (int i = 0; i < ps.size(); ++ i) {
int j = i;
while (j < ps.size() && ps[j] == ps[i]) {
++ j;
}
if (ps[i] == '7' || ps[i] == '9') ret *= g[j - i];
else ret *= f[j - i];
ret %= p;
i = j - 1;
}
return ret;
}
};
第四题
** 动态规划的本质就是有剪枝的暴力枚举**
一般学习方法：写出暴力枚举 --> 剪枝暴力枚举 --> 写成循环的方式
剪枝推荐题解
循环推荐题解
// 超时
class Solution {
public:
vector<vector<char> > g;
bool dfs(int x, int y, int cnt) {
if (x >= g.size() || y >= g[0].size()) return false;
if (g[x][y] == '(') {
++ cnt;
}else -- cnt;
if (cnt < 0) return false;
if (x == g.size() - 1 && y == g[0].size() - 1) {
return cnt == 0;
}
return dfs(x + 1, y, cnt) || dfs(x, y + 1, cnt);
}
bool hasValidPath(vector<vector<char>>& grid) {
this->g = grid;
return dfs(0, 0, 0);
}
};
// 剪枝
class Solution {
public:
vector<vector<char> > g;
unordered_map<int, int> mp;
bool dfs(int x, int y, int cnt) {
int n = g.size(), m = g[0].size();
if (x >= g.size() || y >= g[0].size()) return false;
int k = (x * m + y) * m + cnt;
if (mp[(x * m + y) * m + cnt]) return mp[k] == 1;
if (g[x][y] == '(') {
++ cnt;
}else -- cnt;
if (cnt < 0) return false;
if (x == g.size() - 1 && y == g[0].size() - 1) {
return cnt == 0;
}
bool t = dfs(x + 1, y, cnt) || dfs(x, y + 1, cnt);
if (t) {
mp[k] = 1;
}else mp[k] = 2;
return mp[k] == 1;
}
bool hasValidPath(vector<vector<char>>& grid) {
this->g = grid;
return dfs(0, 0, 0);
}
};
// 循环
class Solution {
public:
static const int N = 2e2 + 5;
int dp[N][N][N];
bool hasValidPath(vector<vector<char>>& grid) {
if (grid[0][0] == ')') return false;
int n = grid.size(), m = grid[0].size();
dp[0][0][1] = 1;
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (i || j) {
int t = grid[i][j] == '('? 1 : -1;
for (int k = 0; k < n + m; ++ k) {
if (k - t < 0) continue;
if (i)
dp[i][j][k] |= dp[i - 1][j][k - t];
if (j)
dp[i][j][k] |= dp[i][j - 1][k - t];
}
}
}
}
return dp[n - 1][m - 1][0];
}
};
132 场周赛
第一题
class Solution {
public:
bool divisorGame(int n) {
return n % 2 == 0;
}
};
第二题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int ret = 0;
vector<int> dfs(TreeNode* root) {
int lmin = 1e5 + 5, rmin = 1e5 + 5;
int lmax = -1, rmax = -1;
if (root->left) {
auto it = dfs(root->left);
lmin = it[0];
lmax = it[1];
}
if (root->right) {
auto it = dfs(root->right);
rmin = it[0];
rmax = it[1];
}
int xmin = min(lmin, rmin);
int xmax = max(lmax, rmax);
int v = root->val;
if (xmin != 1e5 + 5)
ret = max(ret, abs(v - xmin));
if (xmax != -1) {
ret = max(ret, abs(v - xmax));
}
return {min(v, xmin), max(v, xmax)};
}
int maxAncestorDiff(TreeNode* root) {
dfs(root);
return ret;
}
};
第三题
补题中...
第四题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* recoverFromPreorder(string t) {
stack<TreeNode*> stk;
int num = 0;
int i = 0;
while (i < t.size() && t[i] != '-') {
num *= 10;
num += t[i] - '0';
++ i;
}
TreeNode* node = new TreeNode(num);
if (i == t.size()) return node;
stk.push(node);
for (i; i < t.size();) {
int cnt = 0;
while (t[i] == '-'){
++ cnt;
++ i;
}
int num = 0;
while (i < t.size() && t[i] != '-') {
num *= 10;
num += t[i] - '0';
++ i;
}
TreeNode* n = new TreeNode((int)(num));
while (cnt < stk.size()) {
stk.pop();
}
if (stk.top()->left != NULL) {
stk.top()->right = n;
}else {
stk.top()->left = n;
}
stk.push(n);
}
return node;
}
};
215 场周赛
第一题
class OrderedStream {
public:
vector<string> st;
OrderedStream(int n) {
st.assign(n + 5, "");
}
int p = 0;
vector<string> insert(int id, string v) {
st[id - 1] = v;
vector<string> ret;
//for (int i = 0; i < st.size(); ++ i) cout << st[i] << endl;
// cout << st[0] << endl;
while (st[p] != "") {
ret.push_back(st[p]);
++ p;
}
return ret;
}
};
/**
* Your OrderedStream object will be instantiated and called as such:
* OrderedStream* obj = new OrderedStream(n);
* vector<string> param_1 = obj->insert(idKey,value);
*/
第二题
class Solution {
public:
bool closeStrings(string w1, string w2) {
unordered_set<char> st;
int cnt[26];
memset(cnt, 0, sizeof cnt);
vector<int> ww1;
for (char& c : w1) {
st.insert(c);
cnt[c - 'a'] ++;
}
for (int i = 0; i < 26; ++ i) {
ww1.push_back(cnt[i]);
}
memset(cnt, 0, sizeof cnt);
vector<int> ww2;
for (char& c : w2) {
cnt[c - 'a'] ++;
if (st.count(c) == 0) return false;
}
for (int i = 0; i < 26; ++ i) {
ww2.push_back(cnt[i]);
}
sort(ww1.begin(), ww1.end());
sort(ww2.begin(), ww2.end());
if (ww1.size() != ww2.size()) return false;
for (int i = 0; i < ww1.size(); ++ i) {
if (ww1[i] != ww2[i]) return false;
}
return true;
}
};
第三题
class Solution {
public:
int minOperations(vector<int>& nums, int x) {
int ret = 1e5 + 5;
int i = 0, j = nums.size() - 1;
while (i < nums.size() && x > 0) {
x -= nums[i ++];
}
if (x == 0)
ret = i;
if (x > 0 && i > j) return -1;
-- i;
while (j >= 0) {
x -= nums[j];
while (i >= 0 && x < 0) {
x += nums[i --];
}
if (x == 0) {
ret = min(ret, i + 1 + (int)nums.size() - j);
}
-- j;
}
return ret == 1e5 + 5 ? -1 : ret;
}
};
第四题
class Solution {
public:
int dp[26][7][7][250];
int offset[3][3] = {0, 0, 0, 0, -60, -10, 0, -10, 40};
int cases, cases1, m, n;
int dfs(int cur, int a, int b, int status) {
if (cur == m * n) return 0;
if (dp[cur][a][b][status] != -1) return dp[cur][a][b][status];
int x = cur / n, y = cur % n;
//first是当前位置（x, y）的上面位置(x - 1, y)的状态，
//last是指当前位置前一个位置放人的状态(当y == 0时则没有前一个位置)
int first = status / cases1, last = status % 3;
int nexs = (status * 3) % cases; //(左移并去掉status的首位)
//当前位置不放人
int ans = dfs(cur + 1, a, b, nexs);
//当前位置放内向的人。
int dif = 0;
if (a > 0) {
dif = 120 + offset[1][first] + (y > 0) * offset[1][last];
ans = max(ans, dif + dfs(cur + 1, a - 1, b, nexs + 1));
}
//当前位置放外向的人。
if (b > 0) {
dif = 40 + offset[2][first] + (y > 0) * offset[2][last];
ans = max(ans, dif + dfs(cur + 1, a, b - 1, nexs + 2));
}
return dp[cur][a][b][status] = ans;
}
int getMaxGridHappiness(int m, int n, int a, int b) {
// 0- 不放人 1-放内向 2-放外向 3^n
cases = pow(3, n);
cases1 = pow(3, n-1);
memset(dp, -1, sizeof(dp));
this->m = m;
this->n = n;
return dfs(0, a, b, 0);
}
};
46 场双周
第一题
class Solution {
public:
string longestNiceSubstring(string s) {
if (s.size() < 2) return "";
for (int len = s.size(); len >= 2; -- len) {
for (int i = 0; i + len - 1 < s.size(); ++ i) {
int cnt1[26], cnt2[26];
for (int i = 0; i < 26; ++ i) {
cnt1[i] = 1;
cnt2[i] = 1;
}
int cnt3[26];
memset(cnt3, 0, sizeof cnt3);
for (int j = i; j < i + len; ++ j) {
char c = s[j];
if (s[j] >= 'a' && s[j] <= 'z') {
if (cnt1[c - 'a']) {
cnt3[c - 'a'] += cnt1[c - 'a'];
cnt1[c - 'a'] = 0;
}
}
else {
if (cnt2[c - 'A']) {
cnt3[c - 'A'] += cnt2[c - 'A'];
cnt2[c - 'A'] = 0;
}
}
}
int f = 1;
for (int i = 0; i < 26; ++ i) {
if (cnt3[i] % 2) {
f = 0;
break;
}
}
if (f) return s.substr(i, len);
}
}
return "";
}
};
第二题
class Solution {
public:
bool canChoose(vector<vector<int>>& gs, vector<int>& nums) {
int j = 0;
for (int i = 0; i < nums.size(); ++ i) {
int k = i;
while (k < nums.size() && k - i < gs[j].size() && nums[k] == gs[j][k - i]) {
++ k;
}
if (k - i == gs[j].size()) {
++ j;
// cout << "j " << j << endl;
i = k - 1;
}
if (j == gs.size()) return true;
if (k == nums.size()) return false;
// cout << i << endl;
}
return false;
}
};
第三题
#define pii pair<int, int>
#define x first
#define y second
class Solution {
public:
static const int N = 1E6 + 5;
pii q[N];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
vector<vector<int>> highestPeak(vector<vector<int>>& ir) {
int n = ir.size();
int m = ir[0].size();
int hh = 0, tt = -1;
unordered_set<int> st;
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (ir[i][j]) {
q[++ tt] = {i, j};
st.insert(i * m + j);
}
}
}
vector<vector<int>> ret(n, vector<int>(m));
int cnt = 0;
while (hh <= tt) {
int sz = tt - hh + 1;
++ cnt;
for (int i = 0; i < sz; ++ i) {
pii t = q[hh ++];
for (int k = 0; k < 4; ++ k) {
int xt = t.x + dx[k];
int yt = t.y + dy[k];
if (xt < 0 || xt >= n || yt < 0 || yt >= m || st.count(xt * m + yt)) continue;
// cout << xt << " " << yt << endl;
st.insert(xt * m + yt);
q[++ tt] = {xt, yt};
ret[xt][yt] = cnt;
// cout << "ok" << endl;
}
}
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 2e5 + 5;
int h[N], e[N], ne[N], idx;
vector<stack<pair<int, int> > > stk;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
vector<int> ret;
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
vector<int> nums;
void dfs(int u, int f, int cnt) {
int ans = -1, lv = 0;
for (int i = 1; i <= 50; ++ i) {
if (stk[i].size() && stk[i].top().first > lv && gcd(i, nums[u]) == 1) {
lv = stk[i].top().first;
ans = stk[i].top().second;
}
}
// cout << u << " " << ans << " " << lv << endl;
ret[u] = ans;
stk[nums[u]].push({cnt, u});
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
dfs(j, u, cnt + 1);
}
stk[nums[u]].pop();
}
vector<int> getCoprimes(vector<int>& nums, vector<vector<int>>& edges) {
this->nums = nums;
stk.assign(55, stack<pair<int, int>>());
memset(h, -1, sizeof h);
ret.assign(nums.size(), -1);
for (auto& it : edges) {
add(it[0], it[1]);
add(it[1], it[0]);
}
dfs(0, -1, 1);
return ret;
}
};
161 场周赛
第一题
class Solution {
public:
int minimumSwap(string s1, string s2) {
int a1 = 0;//x -> y
int a2 = 0;//y -> x
for (int i = 0;i < s1.size();i++) {
if (s1[i] == 'x' && s2[i] == 'y') {
a1++;
}
if (s1[i] == 'y' && s2[i] == 'x') {
a2++;
}
}
if (a1 % 2 + a2 % 2 == 1) {
return -1;
}
int ret = a1 / 2 + a2 / 2;
if (a1 % 2 == 1) {
ret += 2;
}
return ret;
}
};
第二题
class Solution {
public:
int numberOfSubarrays(vector<int>& nums, int k) {
int i = 0, j = 0;
int cnt = 0;
int ret = 0;
while (j < nums.size()) {
while (j < nums.size() && cnt < k) {
if (nums[j] & 1) ++ cnt;
++ j;
}
if (j == nums.size() && cnt < k) break;
while (i < nums.size() && cnt == k) {
if (nums[i] & 1) -- cnt;
++ i;
}
int l = i - 2, r = j;
while (l >= 0 && nums[l] % 2 == 0) {
-- l;
}
while (r < nums.size() && nums[r] % 2 == 0) {
++ r;
}
ret += (i - l - 1) * (r - j + 1);
}
return ret;
}
};
第三题
class Solution {
public:
string minRemoveToMakeValid(string s) {
string ret;
int cnt = 0;
for (char& c : s) {
if (c == '(') ++ cnt;
else if (c == ')') -- cnt;
if (cnt >= 0) {
ret += c;
}else {
cnt = 0;
}
}
s = ret;
cnt = 0;
ret = "";
for (int i = s.size() - 1; i >= 0; -- i) {
char c = s[i];
if (c == ')') ++ cnt;
else if (c == '(') -- cnt;
if (cnt >= 0) {
ret += c;
}else {
cnt = 0;
}
}
reverse(ret.begin(), ret.end());
return ret;
}
};
第四题
class Solution {
public:
int gcd(int a, int b) {
return b? gcd(b, a % b) : a;
}
bool isGoodArray(vector<int>& nums) {
int d = nums[0];
for (int& i : nums) {
d = gcd(i, d);
}
return d == 1;
}
};
291 场周赛
第一题
class Solution {
public:
string removeDigit(string number, char digit) {
string ret;
for (int i = 0; i < number.size(); ++ i) {
if (number[i] == digit) {
string t = number.substr(0, i) + number.substr(i + 1, number.size() - i - 1);
ret = max(ret, t);
}
}
return ret;
}
};
第二题
class Solution {
public:
static const int N = 1e6 + 5;
int mp[N];
int minimumCardPickup(vector<int>& c) {
int ret = 1e5 + 2;
memset(mp, -1, sizeof mp);
for (int i = 0; i < c.size(); ++ i) {
if (mp[c[i]] != -1) {
ret = min(ret, i - mp[c[i]] + 1);
}
mp[c[i]] = i;
}
return ret == 1e5 + 2 ? -1 : ret;
}
};
第三题
class Solution {
public:
int countDistinct(vector<int>& nums, int k, int p) {
unordered_set<string> st;
for (int len = 1; len <= nums.size(); ++ len) {
int i = 0, j = 0;
string t;
int cnt = 0;
while (j < nums.size()) {
while (j - i < len) {
t += to_string(nums[j]);
t += "_";
if (nums[j] % p == 0) ++ cnt;
++ j;
}
if (cnt <= k) {
st.insert(t);
}
int u = 0;
while (u < t.size() && t[u] != '_') ++ u;
if (u < t.size() - 1) {
t = t.substr(u + 1, t.size() - u - 1);
}else {
t = "";
}
if (nums[i] % p == 0) -- cnt;
++ i;
}
}
return st.size();
}
};
第四题
class Solution {
public:
int mp[26];
long long appealSum(string s) {
long long ret = 0;
memset(mp, -1, sizeof mp);
for (int i = 0; i < s.size(); ++ i) {
mp[s[i] - 'a'] = max(i, mp[s[i] - 'a']);
// priority_queue<int, vector<int>, greater<int> > q;
vector<int> d;
for (int j = 0; j < 26; ++ j) {
if (mp[j] != -1) {
// q.push(mp[j]);
d.push_back(mp[j]);
}
}
sort(d.begin(), d.end(), [](int& a, int& b){
return a > b;
});
int last = -1;
// while (q.size()) {
// ret += (q.top() - last) * q.size();
// last = q.top();
// q.pop();
// }
while (d.size()) {
ret += (d.back() - last) * d.size();
last = d.back();
d.pop_back();
}
}
return ret;
}
};
77 场双周
第一题
class Solution {
public:
int countPrefixes(vector<string>& words, string s) {
unordered_set<string> st;
for (int i = 1; i <= s.size(); ++ i) {
st.insert(s.substr(0, i));
}
int ret = 0;
for (string& t : words) {
if (st.count(t)) ++ ret;
}
return ret;
}
};
第二题
class Solution {
public:
int minimumAverageDifference(vector<int>& nums) {
int n = nums.size();
vector<long long> pre(nums.size() + 1);
for (int i = nums.size() - 1; i >= 0; -- i) {
pre[i] = pre[i + 1] + nums[i];
}
long long tot = 0;
long long mx = 1e10;
int ret = 0;
for (int i = 0; i < nums.size(); ++ i) {
tot += nums[i];
long long t = abs(tot / (i + 1) - (pre[i] - nums[i]) / max(1, (n - i - 1)) );
if (t < mx) {
mx = t;
ret = i;
}
}
return ret;
}
};
第三题
class Solution {
public:
int countUnguarded(int m, int n, vector<vector<int>>& gs, vector<vector<int>>& ws) {
vector<vector<int> > g(m, vector<int>(n));
for (auto& it : ws) {
g[it[0]][it[1]] = 1;
}
for (auto& it : gs) {
g[it[0]][it[1]] = 1;
}
for (auto& it : gs) {
int x = it[0], y = it[1];
for (int i = x - 1; i >= 0; -- i) {
if (g[i][y] == 1) break;
g[i][y] = 2;
}
for (int i = x + 1; i < m; ++ i) {
if (g[i][y] == 1) break;
g[i][y] = 2;
}
for (int j = y - 1; j >= 0; -- j) {
if (g[x][j] == 1) break;
g[x][j] = 2;
}
for (int j = y + 1; j < n; ++ j) {
if (g[x][j] == 1) break;
g[x][j] = 2;
}
g[x][y] = 1;
}
int ret = 0;
for (int i = 0; i < m; ++ i) {
for (int j = 0; j < n; ++ j) {
if (g[i][j] == 0) ++ ret;
}
}
return ret;
}
};
第四题
class Solution {
public:
vector<vector<int> > f;
int dx[4] = {0, 1, -1, 0};
int dy[4] = {-1, 0, 0, 1};
bool check(int x, vector<vector<int> > g) {
queue<vector<int>> q;
vector<vector<int> > ft = f;
for (auto& it : f) {
q.push(it);
}
if (x)
while (q.size()) {
int sz = q.size();
for (int i = 0; i < sz; ++ i) {
auto t = q.front();
q.pop();
for (int k = 0; k < 4; ++ k) {
int tx = t[0] + dx[k];
int ty = t[1] + dy[k];
if (tx < 0 || tx >= g.size() || ty < 0 || ty >= g[0].size() || g[tx][ty]) continue;
g[tx][ty] = 1;
q.push({tx, ty});
}
}
if (-- x == 0) break;
}
// for (int i = 0; i < g.size(); ++ i) {
// for (int j = 0; j < g[0].size(); ++ j) {
// cout << g[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
queue<vector<int> > q2;
q2.push({0, 0});
g[0][0] = 3;
while (q2.size()) {
int f = 0;
int sz = q.size();
for (int i = 0; i < sz; ++ i) {
auto t = q.front();
q.pop();
for (int k = 0; k < 4; ++ k) {
int tx = t[0] + dx[k];
int ty = t[1] + dy[k];
if (tx < 0 || tx >= g.size() || ty < 0 || ty >= g[0].size() || g[tx][ty] == 1 || g[tx][ty] == 2) continue;
if (tx == g.size() - 1 && ty == g[0].size() - 1) {
f = 1;
}
else
g[tx][ty] = 1;
q.push({tx, ty});
}
}
sz = q2.size();
// cout << sz << endl;
for (int i = 0; i < sz; ++ i) {
auto t = q2.front();
q2.pop();
for (int k = 0; k < 4; ++ k) {
int tx = t[0] + dx[k];
int ty = t[1] + dy[k];
if (tx < 0 || tx >= g.size() || ty < 0 || ty >= g[0].size() || g[tx][ty]) continue;
g[tx][ty] = 3;
// cout << "-> "<< " " << tx << " " << ty << " " << g[tx][ty] << endl;
if (tx == g.size() - 1 && ty == g[0].size() - 1) return true;
q2.push({tx, ty});
}
}
if (f) return false;
// for (int i = 0; i < g.size(); ++ i) {
// for (int j = 0; j < g[0].size(); ++ j) {
// cout << g[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
}
return false;
}
int maximumMinutes(vector<vector<int>>& grid) {
int n = grid.size();
int m = grid[0].size();
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (grid[i][j] == 1) {
f.push_back({i, j});
// cout << i << " " << j << " " << grid[i][j] << endl;
}
}
}
// if (check(0, grid)) {
// cout << "yes" << endl;
// }else {
// cout << "NO" << endl;
// }
int l = 0, r = 2e4 + 5;
while (l < r) {
int mid = l + r >> 1;
if (check(mid, grid)) {
l = mid + 1;
}else {
r = mid;
}
}
if (l == 2e4 + 5) return 1e9;
return -- l;
}
};
55 场双周
第一题
class Solution {
public:
static const int N = 1005;
int dp[N];
bool canBeIncreasing(vector<int>& nums) {
int mx = 0;
for (int i = 0; i < nums.size(); ++ i) {
dp[i] = 1;
for (int j = 0; j < i; ++ j) {
if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
}
mx = max(dp[i], mx);
}
return mx == nums.size() || mx == nums.size() - 1;
}
};
第二题
class Solution {
public:
string removeOccurrences(string s, string p) {
string ret;
for (int i = 0; i < s.size(); ++ i) {
ret += s[i];
// if (ret.size() >= p.size()) {
// cout << ret.substr(ret.size() - p.size(), p.size()) << endl;
// }
while(ret.size() >= p.size() && ret.substr(ret.size() - p.size(), p.size()) == p) {
ret = ret.substr(0, ret.size() - p.size());
}
}
return ret;
}
};
第三题
class Solution {
public:
long long maxAlternatingSum(vector<int>& nums) {
if (nums.size() == 1) return nums[0];
vector<int> ret;
for (int i = 0, j = 1; j < nums.size(); ) {
if (nums[j] >= nums[j - 1]) {
while (j < nums.size() && nums[j] >= nums[j - 1]) {
++ j;
}
ret.push_back(nums[j - 1]);
i = j - 1;
}
else {
if (i == 0) {
ret.push_back(nums[i]);
}
while (j < nums.size() && nums[j] < nums[j - 1]) {
++ j;
}
ret.push_back(nums[j - 1]);
i = j - 1;
}
}
long long tt = 0;
for (int i = 0; i < ret.size(); ++ i) {
// cout << ret[i] << endl;
if (i & 1) {
tt -= ret[i];
}else tt += ret[i];
}
if (ret.size() % 2 == 0) {
tt += ret.back();
}
return tt;
}
};
第四题
补题中...
107 场单周
第一题
#define ull unsigned long long
class Solution {
public:
static const int N = 3E5 + 5;
const int sp = 131;
ull h[N], p[N];
ull get(int l, int r) {
return h[r] - h[l - 1] * p[r - l + 1];
}
vector<int> threeEqualParts(vector<int>& arr) {
p[0] = 1;
for (int i = 1; i <= n; ++ i) {
h[i] = h[i - 1] * sp + s[i - 1];
p[i] = p[i - 1] * sp;
}
}
};
第二题
class Solution {
public:
int minFlipsMonoIncr(string s) {
vector<int> stk;
for (char& c : s) {
int x = c - '0';
int l = 0, r = stk.size();
while (l < r) {
int mid = l + r >> 1;
if (stk[mid] <= x) {
l = mid + 1;
}else r = mid;
}
if (l == stk.size()) {
stk.push_back(x);
}else {
stk[l] = x;
}
}
return s.size() - stk.size();
}
};
第三题
class Solution {
public:
vector<int> threeEqualParts(vector<int>& arr) {
int cnt = 0;
for (int& i : arr)
if (i) ++ cnt;
if (cnt % 3 != 0) return {-1, -1};
if (cnt == 0) return {0, (int)arr.size() - 1};
cnt /= 3;
int b1, b2, b3;
int cur = 0;
for (int i = 0; i < arr.size(); ++ i) {
if (cur == 0) b1 = i;
else if (cur == cnt) b2 = i;
else if (cur == cnt * 2) b3 = i;
else if (cur > cnt * 2) break;
if (arr[i]) ++ cur;
}
int len = arr.size() - b3;
for (int i = 0; i < len; ++ i) {
if (arr[b1 + i] != arr[b2 + i] || arr[b1 + i] != arr[b3 + i]) {
return {-1, -1};
}
}
return {b1 + len - 1, b2 + len};
}
};
第四题
class Solution {
public:
static const int N = 305;
int fa[N], sz[N];
int find(int x) {
return fa[x] == -1 ? x : fa[x] = find(fa[x]);
}
void merge(int a, int b) {
a = find(a), b = find(b);
if (a != b) {
fa[b] = a;
sz[a] += sz[b];
}
}
int minMalwareSpread(vector<vector<int>>& g, vector<int>& it) {
memset(fa, -1, sizeof fa);
for (int i = 0; i < N; ++ i) {
sz[i] = 1;
}
for (int i = 0; i < g.size(); ++ i) {
for (int j = 0; j < g[0].size(); ++ j) {
if (g[i][j] && !count(it.begin(), it.end(), i) && !count(it.begin(), it.end(), j)) {
merge(i, j);
}
}
}
// cout << sz[1] << endl;
int ret= 0;
int mx = 10000;
for (int i = 0; i < it.size(); ++ i) {
unordered_set<int> st;
int cnt = 0;
for (int j = 0; j < it.size(); ++ j) {
if (j == i) continue;
cnt ++;
for (int k = 0; k < g.size(); ++ k) {
if (count(it.begin(), it.end(), k) || g[it[j]][k] == 0) continue;
int f = find(k);
if (st.count(f)) continue;
st.insert(f);
cnt += sz[f];
}
}
// cout << cnt << endl;
if (cnt <= mx) {
if (cnt < mx)
ret = it[i];
else ret = min(ret, it[i]);
mx = cnt;
}
}
return ret;
}
};
39 场双周
第一题
class Solution {
public:
vector<int> decrypt(vector<int>& c, int k) {
vector<int> code = c;
int n = code.size();
for (int i : c) {
code.push_back(i);
}
vector<int> ret;
for (int i : c) {
code.push_back(i);
}
vector<int> pre(n * 3 + 1);
// cout << code.size() << " " << pre.size() << endl;
for (int i = 1; i <= code.size(); ++ i) {
pre[i] = pre[i - 1] + code[i - 1];
}
for (int i = n; i < 2 * n; ++ i) {
if (k == 0)
ret.push_back(0);
else if (k > 0) {
ret.push_back(pre[i + k + 1] - pre[i + 1]);
}else {
ret.push_back(pre[i] - pre[i + k]);
}
}
return ret;
}
};
第二题
class Solution {
public:
static const int N = 1E5 + 5;
int minimumDeletions(string s) {
vector<int> c;
c.push_back(s[0]);
for (int i = 1; i < s.size(); ++ i) {
int l = 0, r = c.size();
while (l < r) {
int mid = l + r >> 1;
if (c[mid] <= s[i]) l = mid + 1;
else r = mid;
}
if (l == c.size()) {
c.push_back(s[i]);
}else {
c[l] = s[i];
}
}
// cout << c.size() << endl;
return s.size() - c.size();
}
};
第三题
class Solution {
public:
int minimumJumps(vector<int>& forbidden, int a, int b, int x) {
unordered_set<int> st;
for (int i : forbidden) st.insert(i);
queue<pair<int, int>> q;
q.push({0, 0});
st.insert(0);
int ret = 0;
unordered_set<int> f;
unordered_set<int> bk;
while (q.size()) {
int sz = q.size();
for (int i = 0; i < sz; ++ i) {
auto t = q.front();
// cout << t.first << endl;
if (t.first == x) return ret;
q.pop();
if (t.first + a < 8000 && !f.count(t.first + a) && !st.count(t.first + a)) {
f.insert(t.first + a);
q.push({t.first + a, 0});
}
if (t.second == 0) {
if (t.first - b >= 0 && !bk.count(t.first - b) && !st.count(t.first - b)) {
bk.insert(t.first - b);
q.push({t.first - b, 1});
}
}
}
++ ret;
}
return -1;
}
};
第四题
class Solution {
public:
bool canDistribute(vector<int>& ns, vector<int>& qy) {
unordered_map<int, int> mp;
for (int& i : ns) {
mp[i] ++;
}
vector<int> cnt;
for (auto& [c, v] : mp)
cnt.push_back(v);
int n = cnt.size();
int m = qy.size();
vector<int> sum(1 << m, 0);
for (int i = 0; i < 1 << m; ++ i) {
for (int j = 0; j < m; ++ j) {
if (i >> j & 1) {
sum[i] += qy[j];
}
}
}
vector<vector<bool> > dp(n + 1, vector<bool>(1 << m, false));
dp[0][0] = true;
for (int i = 1; i <= n; ++ i) {
for (int j = 0; j < 1 << m; ++ j) {
dp[i][j] = dp[i - 1][j];
if (dp[i][j]) continue;
for (int m = j; m; m = (m - 1) & j) {
if (dp[i - 1][j - m] && sum[m] <= cnt[i - 1]) {
dp[i][j] = true;
break;
}
}
}
}
return dp[n][(1 << m) - 1];
}
};
290 场周赛
第一题
class Solution {
public:
vector<int> intersection(vector<vector<int>>& nums) {
vector<int> ret;
unordered_map<int, int> mp;
for (auto& it : nums) {
for (int& i : it) {
mp[i] ++;
}
}
for (auto& [c, v] : mp) {
if (v == nums.size()) {
ret.push_back(c);
}
}
sort(ret.begin(), ret.end());
return ret;
}
};
第二题
class Solution {
public:
double get(int x1, int y2, int x, int y) {
double dx = x1 - x;
double dy = y2 - y;
return sqrt(dx * dx + dy * dy);
}
int countLatticePoints(vector<vector<int>>& cs) {
int ret = 0;
for (int i = 0; i <= 205; ++ i) {
for (int j = 0; j <= 206; ++ j) {
for (auto& it : cs) {
if (get(i, j, it[0], it[1]) <= it[2]) {
++ ret;
// cout << i << " " << j << endl;
break;
}
}
}
}
return ret;
}
};
第三题
class Solution {
public:
static const int N = 1E5 + 100;
unordered_map<int, int> mp;
int pre[N][105];
vector<int> arr;
void add(int x1, int y1, int x2, int y2) {
pre[x1][y1] ++;
pre[x2 + 1][y1] --;
pre[x1][y2 + 1] --;
pre[x2 + 1][y2 + 1] ++;
}
vector<int> ret;
vector<int> countRectangles(vector<vector<int>>& rs, vector<vector<int>>& ps) {
for (auto& it : rs) {
arr.push_back(it[0]);
}
for (auto& it : ps) {
arr.push_back(it[0]);
}
sort(arr.begin(), arr.end());
arr.erase(unique(arr.begin(), arr.end()), arr.end());
for (int i = 0; i < arr.size(); ++ i) {
mp[arr[i]] = i + 1;
}
for (auto& it : rs) {
int x = mp[it[0]];
int y = it[1];
add(1, 1, x, y);
}
for (int i = 1; i < arr.size() + 1; ++ i) {
for (int j = 1; j < 105; ++ j) {
pre[i][j] = pre[i][j] + pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1];
}
}
ret.assign(ps.size(), 0);
for (int i = 0; i < ps.size(); ++ i) {
int x = mp[ps[i][0]];
int y = ps[i][1];
ret[i] = pre[x][y];
}
return ret;
}
};
第四题
#define LL long long
class Solution {
public:
static const int N = 2e5 + 5;
int d[N], pre[N];
vector<int> ret;
vector<int> arr;
unordered_map<int, int> mp;
vector<int> fullBloomFlowers(vector<vector<int>>& fs, vector<int>& ps) {
ret.assign(ps.size(), 0);
for (auto& it : fs) {
arr.push_back(it[0]);
arr.push_back(it[1]);
}
for (auto& it : ps) {
arr.push_back(it);
}
sort(arr.begin(), arr.end());
arr.erase(unique(arr.begin(), arr.end()), arr.end());
// for (int i : arr) cout << i << " ";
// cout << endl;
for (int i = 0; i < arr.size(); ++ i) {
mp[arr[i]] = i;
}
for (auto& it : fs) {
// int x1 = find(arr.begin(), arr.end(), it[0]) - arr.begin();
// int x2 = find(arr.begin(), arr.end(), it[1]) - arr.begin();
// cout << x1 << " " << x2 << endl;
int x1 = mp[it[0]];
int x2 = mp[it[1]];
d[x1] += 1;
d[x2 + 1] -= 1;
}
pre[0] = d[0];
for (int i = 1; i < N; ++ i) {
pre[i] += pre[i - 1] + d[i];
}
// for (int i : pre) {
// cout << i << " ";
// }
// cout << endl;
for (int i = 0; i < ps.size(); ++ i) {
// int x = find(arr.begin(), arr.end(), ps[i]) - arr.begin();
int x = mp[ps[i]];
// cout << x << endl;
ret[i] = pre[x];
}
return ret;
}
};
252 场周赛
第一题
class Solution {
public:
bool isThree(int n) {
int c = 0;
for (int i = 1; i <= n; ++i) {
if (n % i == 0) ++ c;
}
return c == 3;
}
};
第二题
class Solution {
public:
long long numberOfWeeks(vector<int>& milestones) {
// 耗时最长工作所需周数
long long longest = *max_element(milestones.begin(), milestones.end());
// 其余工作共计所需周数
long long rest = accumulate(milestones.begin(), milestones.end(), 0LL) - longest;
if (longest > rest + 1){
// 此时无法完成所耗时最长的工作
return rest * 2 + 1;
}
else {
// 此时可以完成所有工作
return longest + rest;
}
}
};
第三题
#define ll long long
class Solution {
public:
long long minimumPerimeter(long long ns) {
int n = 1;
while (ns > (ll)n * n * 12) {
ns -= (ll)n * n * 12;
++ n;
}
return n * 8;
}
};
第四题
class Solution {
public:
int countSpecialSubsequences(vector<int>& nums) {
long long f0 = 0, f1 = 0, f2 = 0;
int mod = 1e9 + 7;
for (int& i : nums) {
if (i == 0) {
f0 += f0 + 1;
f0 %= mod;
}else if (i == 1) {
f1 += f1 + f0;
f1 %= mod;
}
else if (i == 2) {
f2 += f1 + f2;
f2 %= mod;
}
}
return f2;
}
};
136 场周赛
第一题
class Solution {
public:
int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};
bool isRobotBounded(string is) {
int x = 0, y = 0;
int dic = 0;
for (int k = 0; k < 4; ++ k) {
for (int i = 0; i < is.size(); ++ i) {
if (is[i] == 'L') {
++ dic;
if (dic == 4) {
dic = 0;
}
}else if (is[i] == 'R') {
if (dic == 0) {
dic = 3;
}
else -- dic;
}
else {
x += dx[dic];
y += dy[dic];
}
}
}
// cout << x << endl;
return x == 0 && y == 0;
}
};
第二题
class Solution {
public:
static const int N = 1E5 + 5;
int h[N], e[N], ne[N], idx;
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
unordered_set<int> st;
vector<int> ret;
vector<vector<int> > near;
void dfs(int u) {
int t = 1;
while (count(near[u].begin(), near[u].end(), t)) ++ t;
ret[u - 1] = t;
st.insert(u);
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
near[j].push_back(t);
}
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (!st.count(j)) {
dfs(j);
}
}
}
vector<int> gardenNoAdj(int n, vector<vector<int>>& ps) {
ret.assign(n, 0);
near.assign(n + 1, vector<int>());
memset(h, - 1, sizeof h);
for (auto& it : ps) {
add(it[0], it[1]);
add(it[1], it[0]);
}
for (int i = 1; i <= n; ++ i) {
if (!st.count(i)) {
dfs(i);
}
}
return ret;
}
};
第三题
class Solution {
public:
int maxSumAfterPartitioning(vector<int>& arr, int k) {
int n = arr.size();
vector<int> dp(n);
for (int i = 0; i < n; ++ i) {
dp[i] = arr[i];
if (i) {
dp[i] += dp[i - 1];
}
int cur = arr[i];
for (int j = 1; j < k && j <= i; ++ j) {
cur = max(cur, arr[i - j]);
if (i == j)
dp[i] = max(dp[i], cur * (j + 1));
else dp[i] = max(dp[i], cur * (j + 1) + dp[i - j - 1]);
}
}
return dp[n - 1];
}
};
第四题
#define ULL unsigned long long
class Solution {
public:
static const int N = 1E5 + 10;
const int sp = 131;
ULL h[N], p[N];
ULL get(int l, int r) {
return h[r] - h[l - 1] * p[r - l + 1];
}
bool check(int len, string& ret, string& s) {
unordered_map<ULL, int> mp;
for (int i = 0; i + len - 1 < s.size(); ++ i) {
ULL x = get(i + 1, i + len);
mp[x] ++;
if (mp[x] >= 2) {
if (len > ret.size())
ret = s.substr(i, len);
return true;
}
}
return false;
}
string longestDupSubstring(string s) {
int n = s.size();
p[0] = 1;
for (int i = 1; i <= n; ++ i) {
h[i] = h[i - 1] * sp + s[i - 1];
p[i] = p[i - 1] * sp;
}
string ret;
int l = 1, r = s.size();
while (l < r) {
int mid = l + r >> 1;
if (check(mid, ret, s)) {
l = mid + 1;
}else {
r = mid;
}
}
return ret;
}
};
164 场周赛
第一题
class Solution {
public:
int minTimeToVisitAllPoints(vector<vector<int>>& ps) {
int ret = 0;
for (int i = 1; i < ps.size(); ++ i) {
int a = ps[i - 1][0], b = ps[i - 1][1];
int c = ps[i][0], d = ps[i][1];
int x = min(abs(c - a), abs(d - b));
ret += x;
if (c < a) c += x;
else a += x;
if (b < d) b += x;
else d += x;
ret += abs(c - a) + abs(d - b);
}
return ret;
}
};
第二题
class Solution {
public:
int countServers(vector<vector<int>>& grid) {
int n = grid.size();
int m = grid[0].size();
vector<int> row(n);
vector<int> col(m);
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (grid[i][j]) ++ row[i];
}
}
for (int j = 0; j < m; ++ j) {
for (int i = 0; i < n; ++ i) {
if (grid[i][j]) ++ col[j];
}
}
int ret = 0;
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (grid[i][j])
if (row[i] >= 2 || col[j] >= 2) ++ ret;
}
}
return ret;
}
};
第三题
class Solution {
public:
static const int N = 1e5 + 10;
int son[N][26], idx = 0;
int cnt[N];
void insert(string s) {
int p = 0;
for (int i = 0; i < s.size(); ++ i) {
int u = s[i] - 'a';
if (!son[p][u] ) son[p][u] = ++ idx;
p = son[p][u];
}
cnt[p] ++;
}
void dfs(vector<string>& ret, int p, string& t) {
for (int j = 0; j < cnt[p]; ++ j) {
if (ret.size() >= 3) return;
ret.push_back(t);
}
for (int i = 0; i < 26; ++ i) {
if (son[p][i]) {
char a = 'a' + i;
t += a;
dfs(ret, son[p][i], t);
t.pop_back();
}
if (ret.size() >= 3) return;
}
}
vector<vector<string>> suggestedProducts(vector<string>& ps, string sd) {
for (string s : ps) {
insert(s);
}
vector<vector<string>> ret(sd.size());
string t;
int p = 0;
for (int i = 0; i < sd.size(); ++ i) {
int u = sd[i] - 'a';
if (!son[p][u]) {
break;
}
t += sd[i];
p = son[p][u];
dfs(ret[i], p, t);
}
return ret;
}
};
第四题
class Solution {
public:
const int p = 1e9 + 7;
int f[1000005];
int numWays(int st, int an) {
f[0] = 1;
for (int i = 1; i <= st; ++ i) {
int last;
for (int j = 0; j < an; ++ j) {
if (j == 0) {
last = f[j];
f[j] = ((long long)f[j] + f[j + 1]) % p;
continue;
}
else if (j == an - 1) {
f[j] = ((long long)last + f[j]) % p;
continue;
}
int t = f[j];
f[j] = ((long long)f[j] + last + f[j + 1]) % p;
last = t;
if (f[j] == 0) break;
}
}
return f[0];
}
};
210 场周赛
第一题
class Solution {
public:
int maxDepth(string s) {
int ret = 0;
int cnt = 0;
for (int i = 0; i < s.size(); ++ i) {
if (s[i] == '(') {
++ cnt;
ret = max(ret, cnt);
}else if (s[i] == ')') -- cnt;
}
return ret;
}
};
第二题
class Solution {
public:
int maximalNetworkRank(int n, vector<vector<int>>& roads) {
vector<unordered_set<int>> g(n);
for (auto& it : roads) {
g[it[0]].insert(it[1]);
g[it[1]].insert(it[0]);
}
int ret = 0;
for (int i = 0; i < n; ++ i) {
for (int j = i + 1; j < n; ++ j) {
int t = g[i].size() + g[j].size();
if (g[i].count(j)) -- t;
ret = max(ret, t);
}
}
return ret;
}
};
第三题
class Solution {
public:
bool is_hui(string s) {
for (int i = 0, j = s.size() - 1; i < j; ++ i, -- j) {
if (s[i] != s[j]) return false;
}
return true;
}
bool check(string s, string t) {
int l, r;
if (s.size() % 2) {
l = s.size() / 2 - 1;
r = s.size() / 2 + 1;
}else {
l = s.size() / 2 - 1;
r = s.size() / 2;
}
while (l >= 0 && r < s.size() && s[l] == s[r]) --l, ++ r;
if (l == 0) return true;
return is_hui(s.substr(0, l + 1) + t.substr(r, t.size() - r)) || is_hui(t.substr(0, l + 1) + s.substr(r, s.size() - r));
}
bool checkPalindromeFormation(string a, string b) {
if (a.size() == 1 || b.size() == 1) return true;
return check(a, b) || check(b, a);
}
};
第四题
class Solution {
public:
vector<int> countSubgraphsForEachDiameter(int n, vector<vector<int>>& edges) {
vector<int> dp(1 << n);
vector<vector<int> > dist(n, vector<int>(n, 1e8));
for (auto& it : edges) {
dist[it[0] - 1][it[1] - 1] = 1;
dist[it[1] - 1][it[0] - 1] = 1;
dp[(1 << (it[0] - 1) ) + (1 << (it[1] - 1))] = 1;
}
for (int i = 0; i < n; ++ i) {
dist[i][i] = 0;
}
for (int k = 0; k < n; ++ k) {
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < n; ++ j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
for (int j = 1; j < dp.size(); ++ j) {
if (dp[j] == 0) continue;
for (int i = 0; i < n; ++ i) {
if ((j >> i & 1) || dp[j + (1 << i)]) continue;
for (int k = 0; k < n; ++ k) {
if ((j >> k & 1) && dist[i][k] == 1) {
// dp[j + (1 << i)] = 1;
dp[j + (1 << i)] = dp[j];
break;
}
}
if (!dp[j + (1 << i)]) continue;
for (int k = 0; k < n; ++ k) {
if (j >> k & 1) {
dp[j + (1 << i)] = max(dp[j + (1 << i)], dist[i][k]);
}
}
// int t = j + (1 << i);
// for (int k = 0; k < n; ++ k) {
// for (int u = 0; u < n; ++ u) {
// if ((t >> k & 1) && (t >> u & 1) )
// dp[j + (1 << i)] = max(dp[j + (1 << i)], dist[k][u]);
// }
// }
}
}
vector<int> ret(n - 1);
for (int j = 0; j < dp.size(); ++ j) {
if (dp[j])
{
ret[dp[j] - 1] ++;
}
}
return ret;
}
};
289 场周赛
第一题
class Solution {
public:
string digitSum(string s, int k) {
int cnt = 10;
while (s.size() > k) {
string t;
for (int i = 0; i < s.size(); i += k) {
string tt = s.substr(i, min(k, (int)s.size() - i));
int x = 0;
for (char& c : tt) {
x += c - '0';
}
t += to_string(x);
}
s = t;
}
return s;
}
};
第二题
class Solution {
public:
unordered_map<int, int> mp;
int minimumRounds(vector<int>& tasks) {
for (int& i : tasks) mp[i] ++;
int ret = 0;
for (auto& [c, v] : mp) {
if (v == 1) return -1;
ret += (v + 2) / 3;
}
return ret;
}
};
第三题
class Solution {
public:
int maxTrailingZeros(vector<vector<int>>& grid) {
int ret = 0;
int n = grid.size();
int m = grid[0].size();
vector<vector<pair<int, int> > > row(n + 1, vector<pair<int, int>>(m + 1));
vector<vector<pair<int, int>>> col(n + 1, vector<pair<int, int>> (m + 1));
for (int i = 1; i <= n; ++ i) {
int cnt2 = 0, cnt5 = 0;
for (int j = 1; j <= m; ++ j) {
int x = grid[i - 1][j - 1];
while (x % 2 == 0) {
++ cnt2;
x /= 2;
}
while (x % 5 == 0) {
++ cnt5;
x /= 5;
}
row[i][j] = {cnt2, cnt5};
// cout << i << " " << j << " " << row[i][j].first << " " << row[i][j].second << endl;
}
}
for (int j = 1; j <= m; ++ j) {
int cnt2 = 0, cnt5 = 0;
for (int i = 1; i <= n; ++ i) {
int x = grid[i - 1][j - 1];
while (x % 2 == 0) {
++ cnt2;
x /= 2;
}
while (x % 5 == 0) {
++ cnt5;
x /= 5;
}
col[i][j] = {cnt2, cnt5};
}
}
for (int i = 1; i <= n; ++ i) {
for (int j = 1; j <= m; ++ j) {
ret = max(ret, min(row[i][j].first + col[i - 1][j].first,
row[i][j].second + col[i - 1][j].second));
ret = max(ret, min(row[i][m].first - row[i][j - 1].first + col[i - 1][j].first,
row[i][m].second - row[i][j - 1].second + col[i - 1][j].second));
ret = max(ret, min(row[i][j].first + col[n][j].first - col[i][j].first,
row[i][j].second + col[n][j].second - col[i][j].second));
ret = max(ret, min(row[i][m].first - row[i][j - 1].first + col[n][j].first - col[i][j].first,
row[i][m].second - row[i][j - 1].second + col[n][j].second - col[i][j].second));
}
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 1E5 + 5;
int h[N], e[N], ne[N], idx;
string s;
int ret = 0;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
int dfs(int u) {
int cnt = 1;
int t1 = 0, t2 = 0;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
int x = dfs(j);
if (s[j] != s[u]) {
if (x > t1) {
t2 = t1;
t1 = x;
}else if (x > t2) {
t2 = x;
}
}
}
cnt += t1;
ret = max(ret, max(cnt, cnt + t2));
return cnt;
}
int longestPath(vector<int>& pt, string s) {
this->s = s;
memset(h, -1, sizeof h);
for (int i = 1; i < pt.size(); ++ i) {
add(pt[i], i);
}
dfs(0);
return ret;
}
};
76 场双周
第一题
class Solution {
public:
int findClosestNumber(vector<int>& nums) {
int mx = 1e5;
int ret = -1e5;
for (int i : nums) {
int t = abs(i - 0);
if (t <= mx) {
if (t == mx)
ret = max(ret, i);
else ret = i;
mx = t;
}
}
return ret;
}
};
第二题
class Solution {
public:
long long waysToBuyPensPencils(int tl, int c1, int c2) {
long long ret = 0;
for (int i = 0; ; ++ i) {
long long t = tl - c1 * i;
if (t < 0) break;
int l = 0, r = 1e6 + 1;
while (l < r) {
int mid = l + r >> 1;
if ((long long)mid * c2 < t) {
l = mid + 1;
}else r = mid;
}
if ((long long) l * c2 > t) -- l;
ret += l + 1;
// cout << l << endl;
}
return ret;
}
};
第三题
class ATM {
public:
long long cnt[5];
int mp[5] = {20, 50, 100, 200, 500};
ATM() {
memset(cnt, 0, sizeof cnt);
}
void deposit(vector<int> bt) {
int j = 0;
for (int i : bt) {
cnt[j ++] += i;
}
}
vector<int> withdraw(int at) {
int i = 4;
vector<int> ret(5);
while (at > 0 && i >= 0) {
if (at >= mp[i]) {
long long l = 0, r = cnt[i];
while (l <= r) {
long long mid = l + r >> 1;
if (at - (long long) mid * mp[i] < 0) {
r = mid - 1;
}else l = mid + 1;
}
-- l;
// cout << mp[i] << " " << l << " " << at << " " << cnt[i] << endl;
at -= min(l, cnt[i]) * mp[i];
ret[i] = min(l, cnt[i]);
}
-- i;
}
if (at == 0) {
for (int j = 0; j < ret.size(); ++ j) {
cnt[j] -= ret[j];
}
return ret;
}else return {-1};
}
};
/**
* Your ATM object will be instantiated and called as such:
* ATM* obj = new ATM();
* obj->deposit(banknotesCount);
* vector<int> param_2 = obj->withdraw(amount);
*/
第四题
class Solution {
public:
int maximumScore(vector<int>& scores, vector<vector<int>>& edges) {
int n = scores.size();
vector<vector<pair<int, int> > > g(n);
for (auto& it : edges) {
int a = it[0], b = it[1];
g[a].push_back({scores[b], b});
g[b].push_back({scores[a], a});
}
for (int i = 0; i < n; ++ i) {
sort(g[i].begin(), g[i].end(), [](pair<int, int>& a, pair<int, int>& b) {
return a.first > b.first;
});
}
int ret = -1;
for (auto& it : edges) {
int a = it[0], b = it[1];
for (int i = 0; i < min(3, (int)g[a].size()); ++ i) {
for (int j = 0; j < min(3, (int)g[b].size()); ++ j) {
if (g[a][i].second != b && g[a][i].second != g[b][j].second && g[b][j].second != a) {
ret = max(ret, g[a][i].first + scores[a] + scores[b] + g[b][j].first);
}
}
}
}
return ret;
}
};
127 场单周
第一题
class Solution {
public:
int largestSumAfterKNegations(vector<int>& nums, int k) {
sort(nums.begin(), nums.end());
int i = 0;
int ret = 0;
while (i < nums.size() && nums[i] < 0 && k > 0) {
-- k;
nums[i] = abs(nums[i]);
++ i;
}
k %= 2;
sort(nums.begin(), nums.end());
i = 0;
while (i < nums.size()) {
if (k > 0) {
-- k;
ret -= nums[i];
}else ret += nums[i];
++ i;
}
return ret;
}
};
第二题
class Solution {
public:
int clumsy(int n) {
int k = 0;
string opp = "*/+-";
stack<char> op;
stack<int> num;
num.push(n);
while (-- n) {
int t = n;
char c = opp[k ++];
k %= 4;
if (c == '*') {
num.top() *= t;
}else if (c == '/') {
num.top() /= t;
}else if (c == '+' || c == '-') {
num.push(t);
op.push(c);
}
}
int t1 = 0, t2 = 0;
while (op.size()) {
int t = num.top();
num.pop();
char c = op.top();
op.pop();
if (c == '+') {
t1 += t;
}else {
t2 -= t;
}
}
return num.top() + t1 + t2;
}
};
第三题
class Solution {
public:
int minDominoRotations(vector<int>& tops, vector<int>& bottoms) {
pair<int, int> mx = {0, 0};
for (int i = 1; i <= 6; ++ i) {
int k = 0;
for (int j = 0; j < tops.size(); ++ j) {
if (tops[j] == i || bottoms[j] == i) {
++ k;
}
}
if (k > mx.first) {
mx = {k, i};
}
}
if (mx.first != tops.size()) return -1;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < tops.size(); ++ i) {
if (tops[i] == mx.second) ++ cnt1;
if (bottoms[i] == mx.second) ++ cnt2;
}
return mx.first - max(cnt1, cnt2);
}
};
第四题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> p;
TreeNode* dfs(int& u, int mx) {
TreeNode* head = new TreeNode(p[u]);
int x = p[u];
if (u + 1 < p.size() && p[u + 1] < x) {
head->left = dfs(++ u, x);
}
// if (x == 8) cout << u << endl;
if (u + 1 < p.size() && p[u + 1] > x && p[u + 1] < mx) {
head->right = dfs(++ u, mx);
}
return head;
}
TreeNode* bstFromPreorder(vector<int>& preorder) {
this->p = preorder;
int u = 0;
return dfs(u, 1e8);
}
};
37 场双周
第一题
class Solution {
public:
double trimMean(vector<int>& arr) {
sort(arr.begin(), arr.end());
int idx = arr.size() * 5 / 100;
double sum = 0;
for (int i = idx; i < arr.size() - idx; ++ i) {
sum += arr[i];
}
return sum / (arr.size() - 2 * idx);
}
};
第二题
class Solution {
public:
double get(pair<int, int> a, pair<int, int> b) {
double dx = a.first - b.first;
double dy = a.second - b.second;
return sqrt(dx * dx + dy * dy);
}
vector<int> bestCoordinate(vector<vector<int>>& ts, int rs) {
vector<int> ret = {0, 0, 0};
for (int i = 0; i <= 100; ++ i) {
for (int j = 0; j <= 100; ++ j) {
int mx = 0;
for (auto& it : ts) {
double dist = get({i, j}, {it[0], it[1]});
if (dist <= rs) {
mx += (it[2] / (1 + dist));
}
}
// if (i == 0 && j == 1) cout << mx << endl;
// if (i == 1 && j == 1) cout << mx << endl;
if (mx >= ret[2]) {
if (i < ret[0] || (i == ret[0] && j < ret[1]) || mx > ret[2]) {
ret = {i, j, mx};
}
}
}
}
return {ret[0], ret[1]};
}
};
第三题
class Solution {
static const int p = 1e9 + 7;
long long f[1001][1001][2];
public:
int numberOfSets(int n, int k) {
memset(f, 0, sizeof f);
f[0][0][0] = 1;
for (int i = 1; i < n; ++ i) {
f[i][0][0] = 1;
for (int j = 1; j <= k; ++ j) {
f[i][j][0] = f[i - 1][j][1] + f[i - 1][j][0];
f[i][j][0] %= p;
f[i][j][1] = f[i - 1][j - 1][0] + f[i - 1][j - 1][1] + f[i - 1][j][1];
f[i][j][1] %= p;
}
}
return (f[n - 1][k][0] + f[n - 1][k][1]) % p;
}
};
第四题
#define p 1000000007;
#define LL long long
class Fancy {
public:
static const int N = 1E5 + 5;
struct node {
int l, r;
int sum, add, mul;
}tr[N * 8];
int tot = 0;
int w[N];
void pushup(int u) {
tr[u].sum = (tr[u << 1].sum + tr[u << 1 | 1].sum) % p;
}
void pushup(node& u, node& l, node& r) {
u.sum = ((LL)l.sum + r.sum) % p;
}
void pushdown(int u, int add, int mul) {
tr[u].sum = ((LL)tr[u].sum * mul + (LL)(tr[u].r - tr[u].l + 1) * add) % p;
tr[u].add = ((LL)tr[u].add * mul + add) % p;
tr[u].mul = ((LL)tr[u].mul * mul) % p;
}
void pushdown(int u) {
pushdown(u << 1, tr[u].add, tr[u].mul);
pushdown(u << 1 | 1, tr[u].add, tr[u].mul);
tr[u].add = 0;
tr[u].mul = 1;
}
void modify(int u, int l, int r, int add, int mul) {
if (tr[u].l >= l && tr[u].r <= r) {
// tr[u].sum = (long long) (tr[u].sum * mul) % p;
// tr[u].sum = (long long)(tr[u].sum + (tr[u].r - tr[u].l + 1) * add) & p;
tr[u].sum = ((LL)tr[u].sum * mul + (LL)(tr[u].r - tr[u].l + 1) * add) % p;
// cout << "->" << mul << endl;
tr[u].add = ((LL)tr[u].add * mul + add) % p;
tr[u].mul = ((LL) tr[u].mul * mul ) % p;
}
else {
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, add, mul);
if (r > mid) modify(u << 1 | 1, l, r, add, mul);
pushup(u);
}
}
node query(int u, int l, int r) {
if (tr[u].l >= l && tr[u].r <= r) {
return tr[u];
}
else {
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (r <= mid) return query(u << 1, l, r);
else if (l > mid) return query(u << 1 | 1, l, r);
node left = query(u << 1, l, r);
node right = query(u << 1 | 1, l, r);
node ret;
pushup(ret, left, right);
return ret;
}
}
void built(int u, int l, int r) {
if (l == r) {
tr[u] = {l, r, w[l], 0, 1};
}
else {
tr[u] = {l, r, 0, 0, 1};
int mid = l + r >> 1;
built(u << 1, l, mid);
built(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
Fancy() {
built(1, 1, N - 3);
}
void append(int val) {
++ tot;
modify(1, tot, tot, val, 1);
}
void addAll(int inc) {
modify(1, 1, tot, inc, 1);
}
void multAll(int m) {
modify(1, 1, tot, 0, m);
}
int getIndex(int idx) {
int x = query(1, idx + 1, idx + 1).sum;
return x == 0 ? -1 : x;
}
};
/**
* Your Fancy object will be instantiated and called as such:
* Fancy* obj = new Fancy();
* obj->append(val);
* obj->addAll(inc);
* obj->multAll(m);
* int param_4 = obj->getIndex(idx);
*/
招商银行专场
第一题
class Solution {
public:
string deleteText(string a, int index) {
string ret;
for (int i = 0; i < a.size(); ++ i) {
int j = i;
string t;
while (j < a.size() && a[j] != ' ') t += a[j ++];
if (index > j) {
ret += t;
ret += " ";
}
else {
if (index == j) {
ret += t;
ret += " ";
}
index = a.size() + 1;
}
i = j;
}
if (ret.size())
ret.pop_back();
return ret;
}
};
第二题
class Solution {
public:
static const int N = 2E5 + 5;
int h[N], e[N], ne[N], idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
int ret = 1;
vector<vector<int> > near;
void dfs(int u, int f) {
int t = 1;
while (count(near[u].begin(), near[u].end(), t) || (f != -1 && count(near[f].begin(), near[f].end(), t)) ) ++ t;
ret = max(ret, t);
if (f != -1) near[f].push_back(t);
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
near[j].push_back(t);
dfs(j, u);
}
}
int numFlowers(vector<vector<int>>& rs) {
near.assign(N, vector<int>());
memset(h, -1, sizeof h);
for (auto& it : rs) {
add(it[0], it[1]);
add(it[1], it[0]);
}
dfs(0, -1);
// for (int i = 0; i <= 3; ++ i) {
// for (int j : near[i]) cout << j << " ";
// cout << endl;
// }
return ret;
}
};
第三题
class Solution {
public:
static const int N = 1E4 + 5;
int h[N], e[N], ne[N], idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
unordered_set<int> dian;
vector<int> lightSticks(int ht, int w, vector<int>& is) {
sort(is.begin(), is.end());
int k = -1;
memset(h, -1, sizeof h);
for (int i = 0; i < ht; ++ i) {
for (int j = 0; j < w; ++ j) {
int a = i * (w + 1) + j;
int b = a + 1;
++ k;
if (count(is.begin(), is.end(), k)) {
continue;
}
// cout << a << " " << b << endl;
add(a, b);
add(b, a);
dian.insert(a);
dian.insert(b);
}
for (int j = 0; j <= w; ++ j) {
int a = i * (w + 1) + j;
int b = a + (w + 1);
++ k;
if (count(is.begin(), is.end(), k)){
continue;
}
add(a, b);
add(b, a);
// cout << a << " " << b << endl;
dian.insert(a);
dian.insert(b);
}
}
for (int j = 0; j < w; ++ j) {
int a = ht * (w + 1) + j;
int b = a + 1;
++ k;
if (count(is.begin(), is.end(), k)) {
continue;
}
add(a, b);
add(b, a);
// cout << a << " " << b << endl;
dian.insert(a);
dian.insert(b);
}
vector<int> ret;
int tmax = 1e8;
for (int i : dian) {
unordered_set<int> st;
queue<int> q;
q.push(i);
int tm = 0;
st.insert(i);
while (q.size()) {
++ tm;
int sz = q.size();
for (int i = 0; i < sz; ++ i) {
int t = q.front();
q.pop();
for (int i = h[t]; i != -1; i = ne[i]) {
int j = e[i];
if (st.count(j)) continue;
st.insert(j);
q.push(j);
}
}
}
if (st.size() == dian.size() && tm < tmax) {
tmax = tm;
ret = {i};
}
else if (st.size() == dian.size() && tm == tmax) {
ret.push_back(i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
};
第四题
补题中...
288 场单周
第一题
class Solution {
public:
int largestInteger(int num) {
vector<int> ji, ou;
vector<int> d;
while (num) {
int x = num % 10;
num /= 10;
if (x % 2) ji.push_back(x);
else ou.push_back(x);
if (x % 2) {
d.push_back(1);
}else d.push_back(2);
}
sort(ji.begin(), ji.end());
sort(ou.begin(), ou.end());
// for (int i : ji) cout << i << " ";
// for (int i : ou) cout << i << " ";
int ret = 0;
for (int i = d.size() - 1; i >= 0; -- i) {
ret *= 10;
if (d[i] == 1) {
ret += ji.back();
ji.pop_back();
}else {
ret += ou.back();
ou.pop_back();
}
}
return ret;
}
};
第二题
class Solution {
public:
string minimizeResult(string en) {
int ix;
for (int i = 0; i < en.size(); ++ i) {
if (en[i] == '+') {
ix = i;
break;
}
}
int ret = 1e9 + 5;
int idxl, idxr;
for (int i = ix - 1; i >= 0; -- i) {
for (int j = ix + 1; j < en.size(); ++ j) {
int pre = 0, midl = 0, midr = 0, bk = 0;
for (int k = i; k < ix; ++ k) {
midl *= 10;
midl += (en[k] - '0');
}
for (int k = 0; k < i; ++ k) {
pre *= 10;
pre += (en[k] - '0');
}
for (int k = ix + 1; k <= j; ++ k) {
midr *= 10;
midr += (en[k] - '0');
}
for (int k = j + 1; k < en.size(); ++ k) {
bk *= 10;
bk += (en[k] - '0');
}
int t = midl + midr;
if (pre) t *= pre;
if (bk) t *= bk;
// cout << i << " " << j << " " << pre << " " << midl << " " << midr << " " << bk << " " << t << endl;
if (t < ret) {
ret = t;
idxl = i, idxr = j;
}
}
}
string tt;
for (int i = 0; i < en.size(); ++ i) {
if (i == idxl) {
tt += "(";
}
tt += en[i];
if (i == idxr) {
tt += ")";
}
}
return tt;
}
第三题
class Solution {
public:
int maximumProduct(vector<int>& nums, int k) {
long long ret = 1;
priority_queue<int, vector<int>, greater<int> > q;
for (int i : nums) {
q.push(i);
}
while (k) {
int t = q.top();
q.pop();
t += 1;
-- k;
q.push(t);
}
int mod = 1e9 + 7;
while (q.size()) {
ret *= q.top();
ret %= mod;
q.pop();
}
return ret;
}
};
第四题
class Solution {
public:
long long maximumBeauty(vector<int>& flowers, long long newFlowers, int target, int full, int partial) {
int n = flowers.size();
vector<int> a(n + 1);
sort(flowers.begin(), flowers.end());
vector<long long> f(n + 1);
for (int i = 1; i <= n; ++ i) {
a[i] = flowers[i - 1];
}
for (int i = 1; i <= n; ++ i) {
f[i] = f[i - 1] + a[i];
}
int st = 0;
for (; st < n; ++ st) {
if (a[n - st] < target) break;
}
long long ans = 0, sm = 0;
for (int i = st; i <= n && sm <= newFlowers; ++ i) {
int l = 0, r = n - i + 1;
while (l < r) {
int mid = l + r >> 1;
long long t = 1ll * mid * a[mid] - f[mid];
if (t + sm > newFlowers) r = mid;
else l = mid + 1;
}
-- l;
long long x = newFlowers - sm - (1ll * l * a[l] - f[l]);
long long y = min(l ? a[l] + x / l : 0, target - 1ll);
ans = max(ans, 1ll * i * full + y * partial);
sm += target - a[n - i];
}
return ans;
}
};
143 场单周
第一题
class Solution {
public:
vector<int> distributeCandies(int cs, int num) {
int tot = 0;
for (int i = 1; i <= num; ++ i) tot += i;
int l = 0, r = 1e9 + 1;
int d = num * num;
while (l < r) {
int mid = l + r >> 1;
long long k = (unsigned long long) mid * (tot + tot + (long long)(mid - 1) * d) / 2;
if (cs > k) {
l = mid + 1;
}
else r = mid;
}
-- l;
// cout << l << endl;
vector<int> ret(num);
for (int i = 0; i < num; ++ i) {
ret[i] = l * (i + 1 + i + 1 + (l - 1) * num) / 2;
// cout << ret[i] << " ";
cs -= ret[i];
}
// cout << endl;
int st = 1 + l * num;
// cout << st << endl;
for (int i = 0; i < num; ++ i) {
ret[i] += min(st, cs);
cs -= st;
++ st;
if (cs <= 0) break;
}
return ret;
}
};
第二题
class Solution {
public:
vector<int> pathInZigZagTree(int label) {
vector<int> ret;
int i = 1;
while (label >= i * 2) {
i *= 2;
}
i /= 2;
while (label >= 1) {
ret.push_back(label);
label /= 2;
label = i + (i * 2 - 1 - label);
i /= 2;
}
reverse(ret.begin(), ret.end());
return ret;
}
};
第三题
class Solution {
public:
int minHeightShelves(vector<vector<int>>& books, int shelfWidth) {
int n = books.size();
vector<int> dp(n + 1, 1e8);
dp[0] = 0;
for (int i = 1; i <= n; ++ i) {
int hm = 0, res = shelfWidth;
for (int j = i; j >= 1 && res >= books[j - 1][0]; -- j) {
hm = max(hm, books[j - 1][1]);
dp[i] = min(dp[i], dp[j - 1] + hm);
res -= books[j - 1][0];
}
}
return dp[n];
}
};
第四题
class Solution {
public:
char op(char a, char b, char c) {
char ret;
if (c == '&') {
if (a == 't' && b == 't') {
ret = 't';
}
else ret = 'f';
}else {
if (a == 't' || b == 't') {
ret = 't';
}else ret = 'f';
}
return ret;
}
bool parseBoolExpr(string en) {
stack<char> top;
stack<char> vl;
for (int i = 0; i < en.size(); ++ i) {
if (en[i] == ',') continue;
else if (en[i] == '|' || en[i] == '&' || en[i] == '!') {
top.push(en[i]);
}
else if (en[i] == '(') {
vl.push(en[i]);
}
else if (en[i] == ')') {
char c = vl.top();
vl.pop();
vl.pop();
if (top.top() == '!') {
if (c == 't') c = 'f';
else c = 't';
}
top.pop();
if (vl.size() && vl.top() != '(' && top.top() != '!') {
char c2 = vl.top();
vl.pop();
c = op(c, c2, top.top());
}
vl.push(c);
}
else {
if (top.top() != '!' && vl.top() != '(') {
char c1 = vl.top();
vl.pop();
char rt = op(c1, en[i], top.top());
vl.push(rt);
}
else vl.push(en[i]);
}
}
return vl.top() == 't';
}
};
25 场双周
第一题
class Solution {
public:
vector<bool> kidsWithCandies(vector<int>& cs, int es) {
vector<bool> ret;
int mx = 0;
for (int i : cs) {
mx = max(i, mx);
}
for (int i = 0; i < cs.size(); ++ i) {
if (cs[i] + es >= mx) ret.push_back(true);
else ret.push_back(false);
}
return ret;
}
};
第二题
class Solution {
public:
int maxDiff(int num) {
vector<int> d;
while (num) {
d.push_back(num % 10);
num /= 10;
}
if (d.size() == 1) return 8;
int dx = d.size() - 1;
while (d[dx] == 9) -- dx;
int tmax = 0;
for (int i = d.size() - 1; i >= 0; -- i) {
tmax *= 10;
if (d[i] == d[dx]) tmax += 9;
else tmax += d[i];
}
int tmin = 0;
dx = d.size() - 1;
if (d.back() == 1) {
-- dx;
while (dx > 0 && d[dx] <= 1) -- dx;
}
for (int i = d.size() - 1; i >= 0; -- i) {
tmin *= 10;
if (d[i] == d[dx] ) {
if (d[d.size() - 1] == d[dx]) tmin += 1;
else tmin += 0;
}
else tmin += d[i];
}
return tmax - tmin;
}
};
第三题
class Solution {
public:
bool checkIfCanBreak(string s1, string s2) {
sort(s1.begin(), s1.end());
sort(s2.begin(), s2.end());
int f1 = 1;
int f2 = 1;
for (int i = 0; i < s1.size(); ++ i) {
if (s1[i] > s2[i]) f1 = 0;
if (s2[i] > s1[i]) f2 = 0;
}
return f1 == 1 || f2 == 1;
}
};
第四题
class Solution {
public:
static const int N = 500;
static const int mod = 1e9 + 7;
int st[N];
int n;
int h[N], e[N], ne[N], idx;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
long long ret = 0;
vector<vector<long long> > mp;
int dfs(int u, int cnt, int state) {
if (cnt == n) {
return 1;
}
if (mp[u][state]) return mp[u][state];
if (u > 40) return 0;
int k = state;
mp[u][k] += dfs(u + 1, cnt, state);
mp[u][k] %= mod;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (state >> j & 1) continue;
state |= (1 << j);
mp[u][k] += dfs(u + 1, cnt + 1, state);
mp[u][k] %= mod;
state -= (1 << j);
}
return mp[u][k];
}
int numberWays(vector<vector<int>>& hats) {
n = hats.size();
mp.assign(42, vector<long long>(1 << n));
memset(h, -1, sizeof h);
for (int i = 0; i < hats.size(); ++ i) {
for (int j = 0; j < hats[i].size(); ++ j) {
add(hats[i][j], i);
}
}
mp[0][0] = 1;
for (int i = 1; i <= 40; ++ i) {
mp[i][0] = mp[i - 1][0];
for (int state = 1; state < (1 << n); ++ state) {
mp[i][state] = mp[i - 1][state];
for (int j = h[i]; j != -1; j = ne[j]) {
int k = e[j];
if (state >> k & 1)
mp[i][state] += mp[i - 1][state - (1 << k)];
mp[i][state] %= mod;
}
}
}
return mp[40][(1 << n) - 1];
// return dfs(1, 0, 0);
}
};
264 场单周
第一题
class Solution {
public:
int countValidWords(string se) {
stringstream ss;
ss << se;
int ret = 0;
while (ss) {
string t;
ss >> t;
// cout << t << endl;
if (!t.size()) break;
int cnt = 0;
int f = 0;
for (int i = 0; i < t.size(); ++ i) {
if (t[i] == '-') {
if (i == 0) f = 1;
if (i + 1 < t.size()) {
if (t[i + 1] < 'a' || t[i] > 'z') f = 1;
}
++ cnt;
}
if (t[i] >= '0' && t[i] <= '9') f = 1;
if (i != t.size() - 1 && ((t[i] < 'a' || t[i] > 'z') && t[i] != '-')) f = 1;
}
// if (t == "pencil-sharpener.") cout << f << endl;
if (f) continue;
if (t.back() == '-' || cnt > 1 ) continue;
// cout << t << endl;
++ ret;
}
return ret;
}
};
第二题
class Solution {
public:
int nextBeautifulNumber(int n) {
for(int i = n + 1;; ++i) {
if(isBalanced(i)) return i;
}
return -1;
}
bool isBalanced(int num) {
int cnt[10] = {0}; // 用于计算0-9每个数字出现的次数
while(num) {
cnt[num % 10]++;
num /= 10;
}
for(int i = 0; i < 10; ++i) {// 当数字 i 出现且cnt[i] != i 不是平衡数
if(cnt[i] != 0 && cnt[i] != i) return false;
}
return true;
}
};
第三题
class Solution {
public:
static const int N = 1E5 + 5;
int h[N], e[N], ne[N], idx;
int sz[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
int cnt = 0;
long long ret = 0;
void dfs(int u) {
sz[u] = 1;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
dfs(j);
sz[u] += sz[j];
}
}
void dfs2(int u) {
long long t = 1;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
t *= sz[j];
dfs2(j);
}
if (u != 0)
t *= sz[0] - sz[u];
if (t > ret) {
ret = t;
cnt = 0;
}
if (t == ret) {
++ cnt;
}
}
int countHighestScoreNodes(vector<int>& ps) {
memset(h, -1, sizeof h);
for (int i = 1; i < ps.size(); ++ i) {
add(ps[i], i);
}
dfs(0);
dfs2(0);
return cnt;
}
};
第四题
class Solution {
public:
static const int N = 1E5 + 5;
int h[N], e[N], ne[N], idx;
int d[N], backup[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
pair<int, int> q[N];
int minimumTime(int n, vector<vector<int>>& rs, vector<int>& te) {
memset(h, -1, sizeof h);
for (auto& it : rs) {
add(it[0], it[1]);
d[it[1]] ++;
}
int l = 1, r = 1e9;
unordered_map<int, int> mp;
while (l < r) {
int mid = l + r >> 1;
int hh = 0, tt = -1;
memcpy(backup, d, sizeof d);
for (int i = 1; i <= n; ++ i) {
if (d[i] == 0) {
q[++ tt] = {0, i};
}
}
int f = 1;
while (hh <= tt) {
pair<int, int> t = q[hh ++];
int x = t.second;
int tm = t.first + te[x - 1];
if (tm > mid) {
f = 0;
break;
}
for (int i = h[x]; i != -1; i = ne[i]) {
int j = e[i];
mp[j] = max(mp[j], tm);
if (-- d[j] == 0) {
q[++ tt] = {mp[j], j};
}
}
}
if (f) r = mid;
else l = mid + 1;
memcpy(d, backup, sizeof backup);
}
// cout << mp[3] << endl;
return l;
}
};
179 场单周
第一题
class Solution {
public:
string generateTheString(int n) {
string ret;
if (n % 2) {
for (int i = 0; i < n; ++ i) {
ret += 'a';
}
}
else {
for (int i = 0; i < n - 1; ++ i) {
ret += 'a';
}
ret += 'b';
}
return ret;
}
};
第二题
class Solution {
public:
int numTimesAllBlue(vector<int>& fs) {
int r = 0;
int tot = 0;
int ret = 0;
for (int i = 0; i < fs.size(); ++ i) {
++ tot;
r = max(fs[i], r);
if (r == tot) ++ ret;
}
return ret;
}
};
第三题
class Solution {
public:
static const int N = 1E5 + 5;
int h[N], e[N], ne[N], idx;
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
vector<int> it;
int hd;
bool dfs(int u, int tm, int tg) {
if (tm > tg) return false;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (!dfs(j, tm + it[u], tg)) return false;
}
return true;
}
bool check(int x) {
return dfs(hd, 0, x);
}
int numOfMinutes(int n, int hd, vector<int>& mr, vector<int>& it) {
memset(h, -1, sizeof h);
this->it = it;
this->hd = hd;
for (int i = 0; i < mr.size(); ++ i) {
if (i != hd) {
add(mr[i], i);
}
}
int l = 0, r = 1e9 + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(mid)) r = mid;
else l = mid + 1;
}
return l;
}
};
第四题
class Solution {
public:
static const int N = 1E3;
int h[N], e[N], ne[N], idx;
int t, tg;
double sz[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
bool dfs(int u, int f, vector<int>& track) {
track.push_back(u);
if (u == tg) {
return true;
}
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
if ( dfs(j, u, track) ) return true;
}
track.pop_back();
return false;
}
void dfs2(int u, int f) {
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
dfs2(j, u);
sz[u] ++;
}
}
double frogPosition(int n, vector<vector<int>>& edges, int t, int tg) {
this->t = t;
this->tg = tg;
memset(sz, 0, sizeof sz);
memset(h, -1, sizeof h);
for (auto& it : edges) {
add(it[0], it[1]);
add(it[1], it[0]);
}
vector<int> track;
dfs(1, -1, track);
dfs2(1, -1);
if (track.size() != t + 1) {
if (track.size() > t + 1) return 0;
else if (sz[tg] != 0) return 0;
}
double ret = 1;
for (int& i : track) {
// cout << i << " ";
if (i != tg) {
ret *= (double) 1 / sz[i];
}
}
// cout << endl;
return ret;
}
};
51 场双周
第一题
class Solution {
public:
string replaceDigits(string s) {
string ret;
for (int i = 0; i < s.size(); ++ i) {
if (i % 2) {
ret += char(ret.back() + (s[i] - '0'));
}
else ret += s[i];
}
return ret;
}
};
第二题
class SeatManager {
public:
priority_queue<int, vector<int>, greater<int>> q;
SeatManager(int n) {
for (int i = 1; i <= n; ++ i) q.push(i);
}
int reserve() {
int x = q.top();
q.pop();
return x;
}
void unreserve(int seatNumber) {
q.push(seatNumber);
}
};
/**
* Your SeatManager object will be instantiated and called as such:
* SeatManager* obj = new SeatManager(n);
* int param_1 = obj->reserve();
* obj->unreserve(seatNumber);
*/
第三题
class Solution {
public:
int maximumElementAfterDecrementingAndRearranging(vector<int>& arr) {
sort(arr.begin(), arr.end());
if (arr[0] != 1) {
arr[0] = 1;
}
for (int i = 1; i < arr.size(); ++ i) {
if (arr[i] - 1 > arr[i - 1]) {
arr[i] = arr[i - 1] + 1;
}
}
return arr[arr.size() - 1];
}
};
第四题
class Solution {
public:
static const int N = 1E7 + 5;
int tr[N];
int lowbit(int x) {
return x & -x;
}
void add(int x) {
for (int i = x; i < N; i += lowbit(i)) {
tr[i] += 1;
}
}
int query(int x) {
if (x < 0) return 0;
int ret = 0;
for (int i = x; i; i -= lowbit(i)) {
ret += tr[i];
}
return ret;
}
int query(int l, int r) {
return query(r) - query(l - 1);
}
vector<int> closestRoom(vector<vector<int>>& rs, vector<vector<int>>& qs) {
sort(rs.begin(), rs.end(), [](vector<int>& a, vector<int>& b){
return a[1] > b[1];
});
for (int i = 0; i < qs.size(); ++ i) {
qs[i].push_back(i);
}
sort(qs.begin(), qs.end(), [](vector<int>& a, vector<int>& b){
return a[1] > b[1];
});
int i = 0;
vector<int> ret(qs.size());
for (auto& it : qs) {
while (i < rs.size() && rs[i][1] >= it[1]) {
add(rs[i][0]);
++ i;
}
int f = 0;
int x = it[0];
int l = 0, r = x;
while (l < r) {
int mid = l + r >> 1;
if (query(x - mid, x)) r = mid;
else l = mid + 1;
}
int len = r == x ? N : l;
l = 0, r = N - x;
while (l < r) {
int mid = l + r >> 1;
if (query(x, x + mid)) r = mid;
else l = mid + 1;
}
if (r != N - x) {
if (l < len) {
len = l;
f = 1;
}
}
if (len == N) ret[it[2]] = -1;
else {
if (f) ret[it[2]] = x + len;
else ret[it[2]] = x - len;
}
}
return ret;
}
};
117 场单周
第一题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int x;
bool dfs(TreeNode* root) {
if (root->left && !dfs(root->left) ) return false;
if (root->right && !dfs(root->right)) return false;
return root->val == x;
}
bool isUnivalTree(TreeNode* root) {
x = root->val;
return dfs(root);
}
};
第二题
class Solution {
public:
vector<int> ret;
int n;
void dfs(int u, int last, int& k, int track) {
if (u == n) {
ret.push_back(track);
return;
}
if (last + k <= 9) {
int t = track;
track *= 10;
track += last + k;
dfs(u + 1, last + k, k, track);
track = t;
}
if (k != 0 && last - k >= 0) {
track *= 10;
track += last - k;
dfs(u + 1, last - k, k, track);
}
}
vector<int> numsSameConsecDiff(int n, int k) {
this->n = n;
for (int i = 1; i <= 9; ++ i) {
dfs(1, i, k, i);
}
return ret;
}
};
第三题
class Solution {
public:
unordered_map<string, vector<string> > mp;
vector<string> spellchecker(vector<string>& wt, vector<string>& qs) {
for (string& s : wt) {
string t = s;
transform(t.begin(), t.end(), t.begin(), ::tolower);
for (int i = 0; i < t.size(); ++ i) {
if (t[i] == 'a' || t[i] == 'e' || t[i] == 'i' || t[i] == 'o' || t[i] == 'u') {
t[i] = '?';
}
}
// cout << t << " " << s << endl;
mp[t].push_back(s);
}
// cout << endl;
vector<string> ret;
for (int i = 0; i < qs.size(); ++ i) {
string t = qs[i];
transform(t.begin(), t.end(), t.begin(), ::tolower);
for (int i = 0; i < t.size(); ++ i) {
if (t[i] == 'a' || t[i] == 'e' || t[i] == 'i' || t[i] == 'o' || t[i] == 'u') {
t[i] = '?';
}
}
string et = "";
string ult = "";
string yt = "";
// cout << t << " : ";
for (string& s : mp[t]) {
// if (qs[i] == "HARE")
// cout << s << " ";
int bs = 0;
int yuan = 0;
// if (qs[i] == "HARE") cout << endl;
for (int j = 0; j < (int)s.size(); ++ j) {
if (s[j] != qs[i][j]) {
char c = tolower(s[j]);
// ut << c << " " << s[j] << endl;
if (c == tolower(qs[i][j])) {
++ bs;
}else ++ yuan;
}
}
// if (qs[i] == "EkO") {
// cout << bs << " " << yuan << " " << endl;
// }
if (bs == 0 && yuan == 0) {
et = s;
break;
}
if (yuan) {
if (yt == "")
yt = s;
}
else if ( bs && ult == "") {
ult = s;
}
}
// if (qs[i] == "EkO"){
// cout << et << endl;
// cout << ult << endl;
// cout << yt << endl;
// }
if (et != "") {
ret.push_back(et);
}else if (ult != "") {
ret.push_back(ult);
}else ret.push_back(yt);
}
return ret;
}
};
第四题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int ret = 0;
int dfs(TreeNode* root) {
if (!root) {
return 2;
}
int l = dfs(root->left);
int r = dfs(root->right);
if (l == 0 || r == 0) {
++ ret;
return 1;
}
if (l == 1 || r == 1) return 2;
return 0;
}
int minCameraCover(TreeNode* root) {
int x = dfs(root);
if (x == 0) ++ ret;
return ret;
}
};
93 场单周
第一题
class Solution {
public:
int binaryGap(int n) {
int ret = 0;
int last = -1;
for (int i = 0; i < 32; ++ i) {
if (n & (1 << i)) {
if (last != - 1) {
ret = max(ret, i - last);
}
last = i;
}
}
return ret;
}
};
第二题
class Solution {
public:
int cnt[10];
bool reorderedPowerOf2(int n) {
int t = 0;
while (n) {
cnt[n % 10] ++;
n /= 10;
++ t;
}
for (int i = 0; i < 32; ++ i) {
int tt = pow(2, i);
int tc = 0;
int tcnt[10];
memset(tcnt, 0, sizeof tcnt);
while (tt) {
tcnt[tt % 10] ++;
tt /= 10;
++ tc;
}
if (tc < t) continue;
else if (tc > t) break;
int f = 1;
for (int i = 0; i < 10; ++ i) {
if (cnt[i] != tcnt[i] ){
f = 0;
break;
}
}
if (f) return true;
}
return false;
}
};
第三题
class Solution {
public:
unordered_map<int, vector<int> > mp;
int st[100005];
vector<int> advantageCount(vector<int>& nums1, vector<int>& nums2) {
sort(nums1.begin(), nums1.end());
vector<int> tt = nums2;
vector<int> ret;
sort(nums2.begin(), nums2.end());
// cout << nums1[0] << " " << nums2[0] << endl;
int i = 0, j = 0;
for (i = 0, j = 0; i < nums2.size(); ++ i) {
while (j < nums1.size() && nums1[j] <= nums2[i]) ++ j;
if (j >= nums1.size()) break;
mp[nums2[i]].push_back(nums1[j]);
st[j ++] = 1;
}
j = 0;
while (i < nums2.size()) {
while (st[j]) ++ j;
mp[nums2[i]].push_back(nums1[j ++]);
++ i;
}
// cout << mp[11][0] << endl;
for (int& x : tt) {
ret.push_back(mp[x][0]);
mp[x].erase(mp[x].begin());
}
return ret;
}
};
第四题
class Solution {
public:
int minRefuelStops(int tg, int sl, vector<vector<int>>& ss) {
priority_queue<int, vector<int>, less<int>> q;
int ret = 0;
int r = sl;
for (auto& it : ss) {
while (r < it[0] && q.size()) {
r += q.top();
q.pop();
++ ret;
}
if (r >= it[0]) {
q.push(it[1]);
}else break;
if (r >= tg) break;
}
while (r < tg && q.size()) {
r += q.top();
q.pop();
++ ret;
}
return r >= tg ? ret : -1;
}
};
287 场单周
第一题
class Solution {
public:
int convertTime(string ct, string cot) {
int t1 = 0, t2 = 0;
t1 = ((ct[0] - '0') * 10 + (ct[1] - '0') ) * 60 + ((ct[3] - '0') * 10 + ct[4] - '0');
t2 = ((cot[0] - '0') * 10 + (cot[1] - '0') ) * 60 + ((cot[3] - '0') * 10 + cot[4] - '0');
t2 -= t1;
if (t2 < 0) t2 += 1440;
// cout << t1 << " " << t2 << endl;
int ret = 0;
while (t2) {
while (t2 >= 60) {
t2 -= 60;
++ ret;
}
while (t2 >= 15) {
t2 -= 15;
++ ret;
}
while (t2 >= 5) {
t2 -= 5;
++ ret;
}
while (t2 >= 1) {
t2 -= 1;
++ ret;
}
}
return ret;
}
};
第二题
class Solution {
public:
int cnt[100005];
vector<vector<int>> findWinners(vector<vector<int>>& ms) {
vector<int> st;
for (auto& it : ms) {
cnt[it[1]] ++;
st.push_back(it[0]);
st.push_back(it[1]);
}
vector<int> ret1, ret2;
for (int& i : st) {
if (cnt[i] == 0) {
ret1.push_back(i);
}
else if (cnt[i] == 1) {
ret2.push_back(i);
}
}
sort(ret1.begin(), ret1.end());
sort(ret2.begin(), ret2.end());
ret1.erase(unique(ret1.begin(), ret1.end()), ret1.end());
ret2.erase(unique(ret2.begin(), ret2.end()), ret2.end());
return {ret1, ret2};
}
};
第三题
class Solution {
public:
bool check(vector<int>& cs, int mid, long long k) {
long long cnt = 0;
for (int& i : cs) {
cnt += i / mid;
}
return cnt >= k;
}
int maximumCandies(vector<int>& cs, long long k) {
int l = 1, r = 1e7 + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(cs, mid, k)) {
l = mid + 1;
}else {
r = mid;
}
}
return l - 1;
}
};
第四题
class Encrypter {
public:
vector<char> keys;
vector<string> vs;
vector<string> dy;
Encrypter(vector<char>& keys, vector<string>& vs, vector<string>& dy) {
this->keys = keys;
this->vs = vs;
this->dy = dy;
}
string encrypt(string word1) {
string ret;
for (int i = 0; i < word1.size(); ++ i) {
for (int j = 0; j < keys.size(); ++ j) {
if (word1[i] == keys[j]) {
ret += vs[j];
break;
}
}
}
return ret;
}
int decrypt(string word2) {
vector<vector<char> > tot(word2.size() / 2);
for (int i = 0; i < word2.size(); i += 2) {
string t = word2.substr(i, 2);
for (int j = 0; j < vs.size(); ++ j ) {
if (t == vs[j]) {
tot[i / 2].push_back(keys[j]);
}
}
sort(tot[i / 2].begin(), tot[i / 2].end());
tot[i / 2].erase(unique(tot[i / 2].begin(), tot[i / 2].end()), tot[i / 2].end());
}
int ret = 0;
for (string& s : dy) {
if (tot.size() != s.size()) continue;
int f = 1;
for (int i = 0; i < s.size(); ++ i) {
if (count(tot[i].begin(), tot[i].end(), s[i]) == 0) {
f = 0;
break;
}
}
if (f) ++ ret;
}
return ret;
}
};
/**
* Your Encrypter object will be instantiated and called as such:
* Encrypter* obj = new Encrypter(keys, values, dictionary);
* string param_1 = obj->encrypt(word1);
* int param_2 = obj->decrypt(word2);
*/
75 场双周
第一题
class Solution {
public:
int minBitFlips(int st, int gl) {
int ret = 0;
for (int i = 0; i < 32; ++ i) {
if ((st & (1 << i)) != (gl & (1 << i))) ++ ret;
}
return ret;
}
};
第二题
class Solution {
public:
int triangularSum(vector<int>& nums) {
vector<int> t;
while ((int)nums.size() > 1) {
for (int i = 1; i < nums.size(); ++ i) {
t.push_back((nums[i] + nums[i - 1]) % 10 );
}
nums = t;
t.clear();
}
return nums[0];
}
};
第三题
class Solution {
public:
long long numberOfWays(string s) {
long long ret = 0, n0 = 0, n1 = 0, n01 = 0, n10 = 0;
for (char& c : s) {
if (c == '1') {
n01 += n0;
++ n1;
ret += n10;
}
else {
n10 += n1;
++ n0;
ret += n01;
}
}
return ret;
}
};
第四题
Z数组
class Solution {
public:
long long sumScores(string s) {
int n = s.size();
vector<int> z(n);
int l = 0, r = 0;
long long ret = 0;
for (int i = 1; i < n; ++ i) {
z[i] = min(z[i - l], r - i + 1);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
l = i;
r = i + z[i];
++ z[i];
}
r = max(i, r);
ret += z[i];
}
return ret + n;
}
};
后缀数组
class Solution {
public:
static const int N = 1E5 + 5;
int n, m;
char s[N];
int sa[N], x[N], y[N], c[N], rk[N], height[N];
void get_sa()
{
for (int i = 1; i <= n; i ++ ) c[x[i] = s[i]] ++ ;
for (int i = 2; i <= m; i ++ ) c[i] += c[i - 1];
for (int i = n; i; i -- ) sa[c[x[i]] -- ] = i;
for (int k = 1; k <= n; k <<= 1)
{
int num = 0;
for (int i = n - k + 1; i <= n; i ++ ) y[ ++ num] = i;
for (int i = 1; i <= n; i ++ )
if (sa[i] > k)
y[ ++ num] = sa[i] - k;
for (int i = 1; i <= m; i ++ ) c[i] = 0;
for (int i = 1; i <= n; i ++ ) c[x[i]] ++ ;
for (int i = 2; i <= m; i ++ ) c[i] += c[i - 1];
for (int i = n; i; i -- ) sa[c[x[y[i]]] -- ] = y[i], y[i] = 0;
swap(x, y);
x[sa[1]] = 1, num = 1;
for (int i = 2; i <= n; i ++ )
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]) ? num : ++ num;
if (num == n) break;
m = num;
}
}
void get_height()
{
for (int i = 1; i <= n; i ++ ) rk[sa[i]] = i;
for (int i = 1, k = 0; i <= n; i ++ )
{
if (rk[i] == 1) continue;
if (k) k -- ;
int j = sa[rk[i] - 1];
while (i + k <= n && j + k <= n && s[i + k] == s[j + k]) k ++ ;
height[rk[i]] = k;
}
}
long long sumScores(string st) {
for (int i = 1; i <= st.size(); ++ i) {
s[i] = st[i - 1];
}
n = strlen(s + 1);
m = 'z';
get_sa();
get_height();
long long ret = 0;
int idx = rk[1];
int len = n;
for (int i = idx; i >= 1; -- i) {
ret += len;
len = min(len, height[i]);
}
len = n;
for (int i = idx + 1; i <= n; ++ i) {
len = min(len, height[i]);
ret += len;
}
return ret;
}
};
二分哈希
class Solution {
public:
static const int mod = 1e9 + 7;
long long sumScores(string s) {
int n = s.size();
vector<int> f(n + 1), g(n + 1);
for (int i = 1; i <= n; ++ i) {
f[i] = ((long long)f[i - 1] * 171 + s[i - 1]) % mod;
}
g[0] = 1;
for (int i = 1; i <= n; ++ i) {
g[i] = ((long long)g[i - 1] * 171) % mod;
}
long long ret = 0;
for (int i = 1; i <= n; ++ i) {
int l = 0, r = n - i + 1 + 1;
while (l < r) {
int mid = l + r >> 1;
int h = ((long long)f[i + mid - 1] - (long long)f[i - 1] * g[mid] % mod + mod) % mod;
if (f[mid] == h) l = mid + 1;
else r = mid;
}
ret += l - 1;
}
return ret;
}
};
139 场单周
第一题
class Solution {
public:
string gcdOfStrings(string str1, string str2) {
string ret;
for (int i = 1; i <= min((int)str1.size(), (int)str2.size()); ++ i) {
string t = str1.substr(0, i);
if (str1.size() % i || str2.size() % i) continue;
int f = 1;
for (int j = 0; j < str1.size(); ++ j) {
if (str1[j] != t[j % i]) {
f = 0;
break;
}
}
if (f == 0) continue;
for (int j = 0; j < str2.size(); ++ j) {
if (str2[j] != t[j % i]) {
f = 0;
break;
}
}
if (f) ret = t;
}
return ret;
}
};
第二题
class Solution {
public:
unordered_map<string, int> cnt;
int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {
int ret = 0;
for (auto& it : matrix) {
if (it[0] == 1) {
string t;
for (int& i : it) {
if (i == 1) t += '1';
else t += '0';
}
cnt[t] ++;
continue;
}
}
for (auto& it : matrix) {
if (it[0] == 1) continue;
string t;
for (int& i : it) {
if (i == 0) {
t += '1';
}else t += '0';
}
cnt[t] ++;
}
for (auto& [c, v] : cnt) {
ret = max(ret, v);
}
return ret;
}
};
第三题
补题中...
第四题
class Solution {
public:
int numSubmatrixSumTarget(vector<vector<int>>& mx, int target) {
int n = mx.size();
int m = mx[0].size();
vector<vector<int> > pre(n, vector<int>(m));
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (i == 0 && j == 0) {
pre[i][j] = mx[i][j];
}
else if (i == 0) {
pre[i][j] = mx[i][j] + pre[i][j - 1];
}else if (j == 0) {
pre[i][j] = mx[i][j] + pre[i - 1][j];
}else {
pre[i][j] = mx[i][j] + pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1];
}
}
}
// for (auto& it : pre) {
// for (int x : it) {
// cout << x << " ";
// }
// cout << endl;
// }
// cout << endl;
int ret = 0;
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (mx[i][j] == target) ++ ret;
for (int u = i; u < n; ++ u) {
for (int k = j; k < m; ++ k) {
if (u == i && k == j) continue;
int t = pre[u][k];
if (i != 0) {
t -= pre[i - 1][k];
}
if (j != 0) {
t -= pre[u][j - 1];
}
if (i != 0 && j != 0) {
t += pre[i - 1][j - 1];
}
if (t == target) ++ ret;
}
}
}
}
return ret;
}
};
135 场单周
第一题
class Solution {
public:
int gcd(int a, int b) {
return b == 0? a : gcd(b, a % b);
}
bool isBoomerang(vector<vector<int>>& ps) {
int a1 = ps[1][0] - ps[0][0];
int b1 = ps[1][1] - ps[0][1];
if (a1 == 0 && b1 == 0) return false;
int t1 = gcd(a1, b1);
a1 /= t1;
b1 /= t1;
int a2 = ps[2][0] - ps[0][0];
int b2 = ps[2][1] - ps[0][1];
int t2 = gcd(a2, b2);
if (a2 == 0 && b2 == 0) return false;
a2 /= t2;
b2 /= t2;
// cout << a1 << " " << b1 << " " << a2 << " " << b2 << endl;
return !(a1 == a2 && b1 == b2);
}
};
第二题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int t = 0;
void dfs3(TreeNode* root) {
if (root->right) {
dfs3(root->right);
}
t += root->val;
root->val = t;
if (root->left) {
dfs3(root->left);
}
}
TreeNode* bstToGst(TreeNode* root) {
dfs3(root);
return root;
}
};
第三题
class Solution {
public:
int minScoreTriangulation(vector<int>& vs) {
int n = vs.size();
vector<vector<int> > dp(n, vector<int>(n));
for (int len = 3; len <= n; ++ len) {
for (int i = 0; i + len - 1 < n; ++ i) {
int j = i + len - 1;
for (int k = i + 1; k < j; ++ k) {
if (dp[i][j] == 0) {
dp[i][j] = vs[i] * vs[j] * vs[k] + dp[i][k] + dp[k][j];
}else {
dp[i][j] = min(dp[i][j], vs[i] * vs[j] * vs[k] + dp[i][k] + dp[k][j]);
}
}
}
}
return dp[0][n - 1];
}
};
第四题
class Solution {
public:
vector<int> numMovesStonesII(vector<int>& st) {
sort(st.begin(), st.end());
int n = st.size();
int mx = st[n - 1] - st[0] + 1 - n;
mx -= min(st[n - 1] - st[n - 2] - 1, st[1] - st[0] - 1);
int mi = mx;
int i = 0, j = 0;
for (int i = 0; i < n; ++ i) {
while (j + 1 < n && st[j + 1] <= st[i] + n - 1) ++ j;
int t = n - (j - i + 1);
if (j - i + 1 == n - 1 && st[j] == st[i] + n - 2) t = 2;
mi = min(mi, t);
}
return {mi, mx};
}
};
198 场周赛
第一题
class Solution {
public:
int numWaterBottles(int num, int e) {
int ret = num;
while (num) {
ret += num / e;
num = num / e + num % e;
if (num < e) break;
}
return ret;
}
};
第二题
class Solution {
public:
static const int N = 2E5 + 5;
int h[N], e[N], ne[N], idx;
string ls;
vector<int> ret;
int cnt[26];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void dfs(int u, int f) {
ret[u] -= cnt[ls[u] - 'a'];
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
dfs(j, u);
}
ret[u] += ++ cnt[ls[u] - 'a'];
}
vector<int> countSubTrees(int n, vector<vector<int>>& es, string ls) {
this->ls = ls;
memset(h, -1, sizeof h);
for (auto& it : es) {
add(it[0], it[1]);
add(it[1], it[0]);
}
ret.assign(n, 0);
dfs(0, - 1);
return ret;
}
};
class Solution {
public:
static const int N = 2E5 + 5;
int h[N], e[N], ne[N], idx;
int sz[N], son[N];
int cnt[26];
string ls;
vector<int> ret;
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void dfs1(int u, int f) {
sz[u] = 1;
son[u] = -1;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
dfs1(j, u);
if (son[u] == - 1 || sz[son[u]] < sz[j]) son[u] = j;
sz[u] += sz[j];
}
}
void update(int u, int sign, int pson, int f) {
cnt[ls[u] - 'a'] += sign;
for (int i = h[u]; i != - 1; i = ne[i]) {
int j = e[i];
if (j == pson || j == f) continue;
update(j, sign, pson, u);
}
}
void dfs2(int u, int p, int f) {
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == son[u] || j == f) continue;
dfs2(j, 0, u);
}
if (son[u] != -1)
dfs2(son[u], 1, u);
update(u, 1, son[u], f);
ret[u] = cnt[ls[u] - 'a'];
if (p == 0) update(u, -1, -1, f);
}
vector<int> countSubTrees(int n, vector<vector<int>>& es, string ls) {
this->ls = ls;
// memset(son, -1, sizeof son);
ret.assign(n, 0);
memset(h, -1, sizeof h);
for (auto& it : es) {
add(it[0], it[1]);
add(it[1], it[0]);
}
dfs1(0, -1);
dfs2(0, 1, -1);
return ret;
}
};
第三题
补题中...
第四题
class Solution {
public:
int closestToTarget(vector<int>& arr, int target) {
unordered_set<int> st;
int ret = abs(arr[0] - target);
st.insert(arr[0]);
for (int& x : arr) {
unordered_set<int> nst;
nst.insert(x);
ret = min(ret, abs(x - target));
for (int v : st) {
ret = min(ret, abs((v & x) - target));
nst.insert(v & x);
}
st = nst;
}
return ret;
}
};
247 场周赛
第一题
class Solution {
public:
int maxProductDifference(vector<int>& nums) {
sort(nums.begin(), nums.end());
return (nums[nums.size() - 1] * nums[nums.size() - 2] ) - (nums[0] * nums[1]);
}
};
第二题
class Solution {
public:
vector<vector<int>> rotateGrid(vector<vector<int>>& grid, int k) {
int n = grid.size();
int m = grid[0].size();
for (int i = 0; i < (min((int)grid[0].size(), (int)grid.size())) / 2; ++ i) {
int tot = (grid[i].size() - i * 2 + grid.size() - i * 2) * 2 - 4;
int t = k % tot;
for (int j = 0; j < t; ++ j) {
int x = grid[i][i];
int u = i, o = i;
while (o < m - 1 - i) grid[u][o] = grid[u][o + 1], ++ o;
while (u < n - 1 - i) grid[u][o] = grid[u + 1][o], ++ u;
while (o > 0 + i) grid[u][o] = grid[u][o - 1], -- o;
while (u > 1 + i) grid[u][o] = grid[u - 1][o], -- u;
grid[u][o] = x;
}
}
return grid;
}
};
第三题
class Solution {
public:
long long wonderfulSubstrings(string word) {
int cnt[1025];
memset(cnt, 0, sizeof cnt);
cnt[0] = 1;
long long ret = 0;
int pre = 0;
for (char c : word) {
pre ^= (1 << (c - 'a'));
ret += cnt[pre];
for (int i = 0; i < 10; ++ i) {
ret += cnt[pre ^ (1 << i)];
}
cnt[pre] ++;
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 1e5 + 5;
int p = 1e9 + 7;
typedef long long LL;
int fact[100005], infact[100005];
int qmi(int a, int k, int p) // 快速幂模板
{
int res = 1;
while (k)
{
if (k & 1) res = (LL)res * a % p;
a = (LL)a * a % p;
k >>= 1;
}
return res;
}
int h[N], e[N], ne[N], idx;
int sz[N];
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
void dfs1(int u) {
sz[u] = 1;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
dfs1(j);
sz[u] += sz[j];
}
}
void dfs2(int u, int s, long long& ret) {
-- s;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
// cout << j << " " << s << " " << ret << endl;
ret = ret * fact[s] % p * infact[s - sz[j]] % p * infact[sz[j]] % p;
s -= sz[j];
dfs2(j, sz[j], ret);
}
}
int waysToBuildRooms(vector<int>& pm) {
// 预处理阶乘的余数和阶乘逆元的余数
fact[0] = infact[0] = 1;
for (int i = 1; i < N; i ++ )
{
fact[i] = (LL)fact[i - 1] * i % p;
infact[i] = (LL)infact[i - 1] * qmi(i, p - 2, p) % p;
}
memset(h, -1, sizeof h);
for (int i = 1; i < pm.size(); ++ i) {
add(pm[i], i);
}
dfs1(0);
long long ret = 1;
dfs2(0, sz[0], ret);
return ret;
}
};
114 场周赛
第一题
class Solution {
public:
bool isAlienSorted(vector<string>& ws, string odr) {
unordered_map<char, int> mp;
for (int i = 0; i < odr.size(); ++ i) {
mp[odr[i]] = i;
}
for (int i = 1; i < ws.size(); ++ i) {
int f = 2;
for (int j = 0; j < min((int)ws[i].size(), (int)ws[i - 1].size()); ++ j) {
if (mp[ws[i][j]] > mp[ws[i - 1][j]]) {
f = 1;
break;
}else if (mp[ws[i][j]] < mp[ws[i - 1][j]]) {
f = 0;
break;
}
}
if (f == 0 || (f == 2 && ws[i].size() < ws[i - 1].size())) return false;
}
return true;
}
};
第二题
class Solution {
public:
bool canReorderDoubled(vector<int>& arr) {
unordered_map<int, int> mp;
sort(arr.begin(), arr.end());
int k = 0;
for (int i = 0; i < arr.size(); ++ i) {
if (arr[i] < 0) {
if (mp[arr[i] * 2] > 0) {
-- mp[arr[i] * 2];
-- k;
}else {
mp[arr[i]] ++;
++ k;
}
}else {
if (arr[i] % 2 == 0 && mp[arr[i] / 2] > 0) {
-- mp[arr[i] / 2];
-- k;
}else {
mp[arr[i]] ++;
++ k;
}
}
}
return k == 0;
}
};
第三题
class Solution {
public:
int minDeletionSize(vector<string>& strs) {
int ret = 0;
vector<string> st(strs.size() + 1);
// if (st[0] <= st[1]) {
// cout << "ok" << endl;
// }
for (int i = 0; i < strs[0].size(); ++ i) {
int f = 1;
for (int j = 1; j < strs.size(); ++ j) {
if (strs[j][i] < strs[j - 1][i] && st[j - 1] == st[j]) {
f = 0;
break;
}
}
if (f) {
for (int j = 0; j < strs.size(); ++ j) {
st[j] += strs[j][i];
}
}
}
// cout << st[0] << endl;
return strs[0].size() - st[0].size();
}
};
第四题
class Solution {
public:
int tallestBillboard(vector<int>& rods) {
unordered_map<int, int> dp;
dp[0] = 0;
for (int& x : rods) {
unordered_map<int, int> tmp(dp);
for (auto& it : tmp) {
int key = it.first;
dp[key + x] = max(dp[key + x], tmp[key] + x);
dp[key - x] = max(dp[key - x], tmp[key]);
}
}
return dp[0];
}
};
168 场周赛
第一题
class Solution {
public:
int get(int x) {
int cnt = 0;
while (x) {
++ cnt;
x /= 10;
}
return cnt;
}
int findNumbers(vector<int>& nums) {
int ret = 0;
for (int& x : nums) {
if (get(x) % 2 == 0) ++ ret;
}
return ret;
}
};
第二题
class Solution {
public:
unordered_map<int, int> mp;
bool isPossibleDivide(vector<int>& nums, int k) {
if (nums.size() % k != 0) return false;
sort(nums.begin(), nums.end());
for (int& i : nums) mp[i] ++;
nums.erase(unique(nums.begin(), nums.end()), nums.end());
int j = 0;
while (j < nums.size()) {
if (mp[nums[j]] == 0) {
++ j;
continue;
}
-- mp[nums[j]];
// cout << nums[j] << " ";
for (int i = j + 1; i < j + k; ++ i) {
// cout << nums[i] << " ";
if (nums[i] != nums[i - 1] + 1 || mp[nums[i]] <= 0 ) {
return false;
}
else -- mp[nums[i]];
}
// cout << endl;
}
return true;
}
};
第三题
class Solution {
public:
string wd;
int df = 0;
int cnt[26];
unordered_map<string, int> mp;
void add(char c) {
wd += c;
if (cnt[c - 'a'] == 0) ++ df;
cnt[c - 'a'] ++;
}
void del(char c) {
cnt[c - 'a'] --;
if (cnt[c - 'a'] == 0) -- df;
wd = wd.substr(1, wd.size());
}
int maxFreq(string s, int ms, int mie, int mae) {
int ret = 0;
for (int len = mie; len <= mae; ++ len) {
memset(cnt, 0, sizeof cnt);
int l = 0, r = 0;
df = 0;
wd = "";
while (r < s.size()) {
add(s[r ++]);
if (r - l < len) {
continue;
}
if (df <= ms) {
// cout << df << " " << wd << endl;
mp[wd] ++;
ret = max(mp[wd], ret);
}
del(s[l ++]);
}
}
return ret;
}
};
第四题
class Solution {
public:
int maxCandies(vector<int>& ss, vector<int>& cs, vector<vector<int>>& ks, vector<vector<int>>& cons, vector<int>& is) {
unordered_set<int> st;
for (int i : is) st.insert(i);
int ret = 0;
for (int i = 0; i < 1005; ++ i) {
vector<int> del;
vector<int> add;
for (int x : st) {
// cout << x << endl;
if (ss[x]) {
for (int& j : cons[x]) add.push_back(j);
for (int& j : ks[x]) {
ss[j] = 1;
}
del.push_back(x);
ret += cs[x];
}
}
for (int& x : del) {
st.erase(st.find(x));
}
for (int& x : add) {
st.insert(x);
}
}
return ret;
}
};
245 场单周
第一题
class Solution {
public:
bool makeEqual(vector<string>& words) {
int cnt[26];
memset(cnt, 0, sizeof cnt);
for (auto& s : words) {
for (char c : s) {
cnt[c - 'a'] ++;
}
}
for (int i = 0; i < 26; ++ i) {
if (cnt[i] % words.size() != 0) return false;
}
return true;
}
};
第二题
class Solution {
public:
int maximumRemovals(string s, string p, vector<int>& re) {
unordered_set<int> st;
int l = 0, r = re.size();
int k = -1;
while (l < r) {
int mid = l + r >> 1;
while (k < mid) {
st.insert(re[++ k]);
}
while (k > mid) {
st.erase(st.find(re[k --]));
}
int j = 0;
for (int i = 0; i < s.size(); ++ i) {
if (st.count(i)) continue;
if (s[i] == p[j]) ++ j;
if (j == p.size()) break;
}
// cout << j << endl;
if (j != p.size()) r = mid;
else l = mid + 1;
}
return l;
}
};
第三题
class Solution {
public:
bool mergeTriplets(vector<vector<int>>& ts, vector<int>& tt) {
int cnt[3];
memset(cnt, 0, sizeof cnt);
for (auto& it : ts) {
int a = it[0], b = it[1], c = it[2];
if (a == tt[0] && b <= tt[1] && c <= tt[2]) cnt[0] = 1;
if (b == tt[1] && a <= tt[0] && c <= tt[2]) cnt[1] = 1;
if (c == tt[2] && a <= tt[0] && b <= tt[1]) cnt[2] = 1;
if (cnt[0] && cnt[1] && cnt[2]) return true;
}
return false;
}
};
第四题
class Solution {
private:
int F[30][30][30], G[30][30][30];
public:
pair<int, int> dp(int n, int f, int s) {
if (F[n][f][s]) {
return {F[n][f][s], G[n][f][s]};
}
if (f + s == n + 1) {
return {1, 1};
}
// F(n,f,s) = F(n,n+1-s,n+1-f)
if (f + s > n + 1) {
tie(F[n][f][s], G[n][f][s]) = dp(n, n + 1 - s, n + 1 - f);
return {F[n][f][s], G[n][f][s]};
}
int earlist = INT_MAX, latest = INT_MIN;
int n_half = (n + 1) / 2;
if (s <= n_half) {
// 在左侧或者中间
for (int i = 0; i < f; ++ i) {
for (int j = 0; j < s - f; ++ j) {
auto [x, y] = dp(n_half, i + 1, i + j + 2);
earlist = min(earlist, x);
latest = max(latest, y);
}
}
}
else {
// s 在右侧
// s'
int s_prime = n + 1 - s;
int mid = (n - 2 * s_prime + 1) / 2;
for (int i = 0; i < f; ++i) {
for (int j = 0; j < s_prime - f; ++j) {
auto [x, y] = dp(n_half, i + 1, i + j + mid + 2);
earlist = min(earlist, x);
latest = max(latest, y);
}
}
}
return {F[n][f][s] = earlist + 1, G[n][f][s] = latest + 1};
}
vector<int> earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
memset(F, 0, sizeof(F));
memset(G, 0, sizeof(G));
// F(n,f,s) = F(n,s,f)
if (firstPlayer > secondPlayer) {
swap(firstPlayer, secondPlayer);
}
auto [earlist, latest] = dp(n, firstPlayer, secondPlayer);
return {earlist, latest};
}
};
286 场单周
第一题
class Solution {
public:
vector<vector<int>> findDifference(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> st1, st2;
for (int i : nums1) {
st1.insert(i);
}
for (int i : nums2) {
st2.insert(i);
}
unordered_set<int> st3;
vector<vector<int> > ret(2);
for (int i : nums1) {
if (!st3.count(i) && !st2.count(i)) {
st3.insert(i);
ret[0].push_back(i);
}
}
unordered_set<int> st4;
for (int i : nums2) {
if (!st4.count(i) && !st1.count(i)) {
st4.insert(i);
ret[1].push_back(i);
}
}
return ret;
}
};
第二题
class Solution {
public:
int minDeletion(vector<int>& nums) {
if (nums.size() == 1) return 1;
int ret = 0;
int k = 0;
for (int i = 0; i < nums.size(); ++ i) {
// cout << k << " " << nums[i] << endl;
if (k % 2 == 0 && i + 1 < nums.size() && nums[i] == nums[i + 1]) {
++ ret;
}else ++ k;
}
if ((nums.size() - ret) % 2) ++ ret;
return ret;
}
};
第三题
class Solution {
public:
vector<long long> kthPalindrome(vector<int>& qs, int ih) {
vector<long long> ret;
for (int& x : qs) {
int k = (ih + 1) / 2;
long long p = 1;
for (int i = 0; i < k - 1; ++ i) {
p *= 10;
}
if (x > 9 * p) {
ret.push_back(-1);
}else {
long long res = p + x - 1;
string t = to_string(res);
t.resize(ih - k);
reverse(t.begin(), t.end());
for (char c : t) {
res = res * 10 + (c - '0');
}
ret.push_back(res);
}
}
return ret;
}
};
第四题
class Solution {
public:
int f[1005][2005];
int sum[1005][2005];
int maxValueOfCoins(vector<vector<int>>& ps, int k) {
memset(f, 0, sizeof f);
memset(sum, 0, sizeof sum);
for (int i = 1; i <= ps.size(); ++ i) {
for (int j = 1; j <= ps[i - 1].size(); ++ j) {
sum[i][j] = sum[i][j - 1] + ps[i - 1][j - 1];
}
}
for (int i = 1; i <= ps.size(); ++ i) {
for (int j = 0; j <= k; ++ j) {
for (int u = 0; u <= min(j, (int)ps[i - 1].size()); ++ u) {
f[i][j] = max(f[i][j], f[i - 1][j - u] + sum[i][u]);
}
}
}
return f[ps.size()][k];
}
};
152 场单周
第一题
class Solution {
public:
bool is_prim(int x) {
for (int i = 2; i <= x / i; ++ i) {
if (x % i == 0) return false;
}
return true;
}
int numPrimeArrangements(int n) {
int cnt = 0;
for (int i = 2; i <= n; ++ i) {
if (is_prim(i)) ++ cnt;
}
long long ret = 1;
int mod = 1e9 + 7;
for (int i = cnt; i >= 1; -- i) {
ret *= i;
ret %= mod;
}
for (int i = n - cnt; i >= 1; -- i) {
ret *= i;
ret %= mod;
}
return ret;
}
};
第三题
int len;
int get(int x) {
return x / len;
}
class Solution {
public:
int cnt[26];
struct node{
int l, r, k, id;
bool operator< (const node& n) {
if (get(l) != get(n.l)) {
return get(l) < get(n.l);
}
return r < n.r;
}
}qm[100005];
void add(char c) {
cnt[c - 'a'] ++;
}
void del(char c) {
cnt[c - 'a'] --;
}
vector<bool> canMakePaliQueries(string s, vector<vector<int>>& qs) {
len = sqrt(qs.size());
for (int i = 0; i < qs.size(); ++ i) {
qm[i] = {qs[i][0], qs[i][1], qs[i][2], i};
}
sort(qm, qm + (int)qs.size());
vector<bool> ret(qs.size(), false);
memset(cnt, 0, sizeof cnt);
for (int i = 0, j = -1, u = 0; u < qs.size(); ++ u) {
int l = qm[u].l, r = qm[u].r, k = qm[u].k, id = qm[u].id;
// cout << i << " " << l << " " << r << " " << k << " " << id << endl;
while (i < l) del(s[i ++]);
while (i > l) add(s[-- i]);
while (j > r) del(s[j --]);
while (j < r) add(s[++ j]);
k *= 2;
// cout << k << endl;
int tot = 0;
for (int i = 0; i < 26; ++ i) {
if (cnt[i] % 2) -- k;
tot += cnt[i];
}
if (tot % 2) ++ k;
if (k >= 0) ret[id] = true;
else ret[id] = false;
}
return ret;
}
};
第四题
class Solution {
public:
unordered_map<char, unordered_map<int, int> > mp;
vector<int> findNumOfValidWords(vector<string>& ws, vector<string>& ps) {
for (string& s : ws) {
int k = 0;
for (int i = 0; i < s.size(); ++ i) {
char c = s[i];
k |= (1 << (c - 'a'));
}
// cout << k << endl;
unordered_set<char> st;
for (int i = 0; i < s.size(); ++ i) {
if (st.count(s[i])) continue;
mp[s[i]][k] ++;
st.insert(s[i]);
}
}
vector<int> ret(ps.size());
for (int i = 0; i < ps.size(); ++ i) {
// cout << ps[i] << endl;
for (int j = 1; j < 1 << ps[i].size(); ++ j) {
int t = 0;
for (int k = 0; k < ps[i].size(); ++ k) {
char c = ps[i][k];
if ((j >> k) & 1) {
t |= (1 << (c -'a'));
}
}
// cout << "t " << t << endl;
ret[i] += mp[ps[i][0]][t];
}
}
return ret;
}
};
84 场单周
第一题
class Solution {
public:
vector<vector<int>> flipAndInvertImage(vector<vector<int>>& image) {
vector<vector<int> > ret(image.size());
for (int i = 0; i < image.size(); ++ i) {
reverse(image[i].begin(), image[i].end());
for (int j = 0; j < image[i].size(); ++ j) {
if (image[i][j]) ret[i].push_back(0);
else ret[i].push_back(1);
}
}
return ret;
}
};
第二题
class Solution {
public:
unordered_map<int, vector<string>> mp;
string findReplaceString(string s, vector<int>& is, vector<string>& ss, vector<string>& ts) {
string ret;
for (int i = 0; i < is.size(); ++ i) {
mp[is[i]].push_back(ss[i]);
mp[is[i]].push_back(ts[i]);
}
sort(is.begin(), is.end());
for (int i = 0; i < s.size(); ++ i) {
if (count(is.begin(), is.end(), i) != 0) {
string t = mp[i][0];
int sz = t.size();
string tt = mp[i][1];
int f = 1;
string ttt;
if (i + sz > s.size()) f = 0;
for (int j = i; j < min((int)s.size(), i + sz); ++ j) {
if (t[j - i] != s[j]) {
f = 0;
}
ttt += s[j];
}
if (f) {
ret += tt;
}else {
ret += ttt;
}
i += sz - 1;
continue;
}
ret += s[i];
}
return ret;
}
};
第三题
class Solution {
public:
int largestOverlap(vector<vector<int>>& img1, vector<vector<int>>& img2) {
int ret = 0;
int n = img1.size();
int m = img2[0].size();
vector<vector<int> > img3(3 * n, vector<int>(3 * m, 0));
for (int i = n; i < 2 * n; ++ i) {
for (int j = m; j < 2 * m; ++ j) {
img3[i][j] = img2[i - n][j - m];
}
}
for (int i = 0; i < 3 * n; ++ i) {
for (int j = 0; j < 3 * m; ++ j) {
// cout << img3[i][j] << " ";
int t = 0;
for (int u = i; u < min(3 * n, i + n); ++ u) {
for (int k = j; k < min(3 * m, j + m); ++ k) {
if (img1[u - i][k - j] && img1[u - i][k - j] == img3[u][k]) ++ t;
}
}
ret = max(ret, t);
}
// cout << endl;
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 1e5;
int h[N], e[N], ne[N], sz[N], idx;
vector<int> ret;
void add(int a, int b) {
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
void dfs1(int u, int f) {
sz[u] = 1;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
dfs1(j, u);
sz[u] += sz[j];
ret[u] += ret[j] + sz[j];
}
}
void dfs2(int u, int f) {
if (f != -1) {
// if (u == 3) {
// cout << ret[f] << " " << sz[f] << " " << sz[u] << endl;
// }
ret[u] = ret[f] - sz[u] + sz[f] - sz[u];
sz[u] = sz[f];
}
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == f) continue;
dfs2(j, u);
}
}
vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& es) {
if (n == 1) return {0};
ret.assign(n, 0);
memset(h, -1, sizeof h);
idx = 0;
for (auto& it : es) {
add(it[0], it[1]);
add(it[1], it[0]);
}
dfs1(0, -1);
dfs2(0, -1);
return ret;
}
};
170 场单周
第一题
class Solution {
public:
string freqAlphabets(string s) {
string ret;
for (int i = 0; i < s.size(); ++ i) {
string t;
while (i < s.size() && s[i] >= '0' && s[i] <= '9') {
t += s[i];
++ i;
}
if (i < s.size()) {
reverse(t.begin(), t.end());
while ((int)t.size() > 2) {
char c = t.back();
t.pop_back();
ret += (char) ('a' + c - '1');
}
int k = t[1] - '0';
k *= 10;
k += t[0] - '0';
ret += (char) ('j' + k - 10);
}
else if (i == s.size() && t.size() ) {
reverse(t.begin(), t.end());
while ((int)t.size()) {
char c = t.back();
t.pop_back();
ret += (char) ('a' + c - '1');
}
}
}
return ret;
}
};
第二题
int len;
int get(int x) {
return x / len;
}
class Solution {
public:
int tt = 0;
void add(int x) {
tt ^= x;
}
struct node{
int l, r, id;
bool operator< (const node& a) const {
if (get(l) != get(a.l)) return get(l) < get(a.l);
else return r < a.r;
}
}qm[100005];
vector<int> xorQueries(vector<int>& ar, vector<vector<int>>& qs) {
len = sqrt(ar.size());
vector<int> ret(qs.size());
for (int i = 0; i < qs.size(); ++ i) {
qm[i] = {qs[i][0], qs[i][1], i};
}
sort(qm, qm + (int)qs.size());
for (int i = 0, j = -1, k = 0; k < qs.size(); ++ k) {
int id = qm[k].id, l = qm[k].l, r = qm[k].r;
while (i > l) add(ar[-- i]);
while (i < l) add(ar[i ++]);
while (j < r) add(ar[++ j]);
while (j > r) add(ar[j --]);
ret[id] = tt;
}
return ret;
}
};
第三题
class Solution {
public:
int q[105];
vector<string> watchedVideosByFriends(vector<vector<string>>& ws, vector<vector<int>>& fs, int id, int lv) {
unordered_set<int> st;
unordered_map<string, int> cnt;
int hh = 0, tt = -1;
q[++ tt] = id;
st.insert(id);
while (hh <= tt) {
int sz = tt - hh + 1;
for (int i = 0; i < sz; ++ i) {
int t = q[hh ++];
for (int& x : fs[t]) {
if (!st.count(x)) {
st.insert(x);
q[++ tt] = x;
}
}
}
if (-- lv == 0) break;
}
while (hh <= tt) {
int t = q[hh ++];
// cout << t << endl;
for (string& s : ws[t]) {
cnt[s] ++;
}
}
vector<pair<string, int> > pt;
for (auto& [s, ct] : cnt) {
pt.push_back({s, ct});
}
sort(pt.begin(), pt.end(), [](pair<string, int>& a, pair<string, int>& b) {
if (a.second != b.second) return a.second < b.second;
else return a.first < b.first;
});
vector<string> ret;
for (auto& [s, _] : pt) ret.push_back(s);
return ret;
}
};
第四题
class Solution {
public:
int f[505][505];
int minInsertions(string s) {
memset(f, 0x3f, sizeof 0x3f);
int n = s.size();
for (int len = 1; len <= n; ++ len) {
for (int i = 0; i + len - 1 < n; ++ i) {
int j = i + len - 1;
if (i == j) {
f[i][i] = 0;
}
else {
if (s[i] == s[j]) {
f[i][j] = f[i + 1][j - 1];
}else {
f[i][j] = min(f[i + 1][j], f[i][j - 1]) + 1;
}
}
}
}
return f[0][n - 1];
}
};
145 场单周
第一题
class Solution {
public:
vector<int> relativeSortArray(vector<int>& a1, vector<int>& a2) {
vector<int> ret;
map<int, int> mp;
for (int& i : a1) {
mp[i] ++;
}
for (int i = 0; i < a2.size(); ++ i) {
for (int j = 0; j < mp[a2[i]]; ++ j) {
ret.push_back(a2[i]);
}
mp.erase(a2[i]);
}
for (auto& [v, c] : mp) {
for (int i = 0; i < c; ++ i) {
ret.push_back(v);
}
}
return ret;
}
};
第二题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int f[1005][13];
TreeNode* q[1005];
int d[1005];
vector<int> ye;
int len = 1;
unordered_map<int, TreeNode*> mp;
void bfs(TreeNode* root) {
int hh = 0, tt = -1;
q[++ tt] = root;
int dep = 1;
while (hh <= tt) {
int sz = tt - hh + 1;
for (int i = 0; i < sz; ++ i) {
TreeNode* t = q[hh ++];
d[t->val] = dep;
mp[t->val] = t;
if ( t && t-> left) {
q[++ tt] = t->left;
int val = t->left->val;
f[val][0] = t->val;
for (int i = 1; i < 12; ++ i) {
f[val][i] = f[f[val][i - 1]][i - 1];
}
}
if ( t && t-> right) {
q[++ tt] = t->right;
int val = t->right->val;
f[val][0] = t->val;
for (int i = 1; i < 12; ++ i) {
f[val][i] = f[f[val][i - 1]][i - 1];
}
}
if (t && !t->left && !t->right) {
if (d[t->val] == len)
ye.push_back(t->val);
else if (d[t->val] > len) {
ye.clear();
len = d[t->val];
ye.push_back(t->val);
}
}
}
++ dep;
}
}
void dfs(TreeNode* root) {
root->val += 1;
if (root->left) dfs(root->left);
if (root->right) dfs(root->right);
}
void dfs2(TreeNode* root) {
cout << root->val << endl;
if (root->left) dfs2(root->left);
if (root->right) dfs2(root->right);
}
void dfs3(TreeNode* root) {
root->val -= 1;
if (root->left) dfs3(root->left);
if (root->right) dfs3(root->right);
}
TreeNode* lcaDeepestLeaves(TreeNode* root) {
dfs(root);
// dfs2(root);
ye.clear();
bfs(root);
// for (int i : ye) cout << i << " ";
// cout << endl;
if (ye.size() == 1) {
dfs3(mp[ye[0]]);
return mp[ye[0]];
}
TreeNode* ret = NULL;
for (int i = 0; i < ye.size(); ++ i) {
for (int j = i + 1; j < ye.size(); ++ j) {
int a = ye[i], b = ye[j];
if (d[a] < d[b]) swap(a, b);
for (int i = 0; i < 12; ++ i) {
if (d[f[a][i]] >= d[b]) a = f[a][i];
}
if (a == b) {
if ( ret == NULL || d[a] < d[ret->val]) {
ret = mp[a];
}
break;
}
for (int i = 11; i >= 0; -- i) {
if (f[a][i] != f[b][i]) {
a = f[a][i];
b = f[b][i];
}
}
a = f[a][0];
if (ret == NULL || d[a] < d[ret->val]) {
ret = mp[a];
}
}
}
dfs3(ret);
return ret;
}
};
第三题
class Solution {
public:
int pre[10005];
int longestWPI(vector<int>& hs) {
int n = hs.size();
for (int i = 1; i <= n; ++ i) {
pre[i] = pre[i - 1];
if (hs[i - 1] > 8) pre[i] += 1;
else pre[i] -= 1;
}
for (int len = n; len >= 1; -- len) {
for (int i = 1; i + len - 1 <= n; ++ i) {
int j = i + len - 1;
if (pre[j] - pre[i - 1] > 0) return len;
}
}
return 0;
}
};
第四题
class Solution {
public:
unordered_map<string, int> mp;
vector<int> smallestSufficientTeam(vector<string>& rs, vector<vector<string>>& pe) {
for (int i = 0; i < rs.size(); ++ i) {
mp[rs[i]] = i;
}
vector<int> skill(pe.size());
for (int i = 0; i < pe.size(); ++ i) {
for (auto& s : pe[i]) {
skill[i] |= 1 << mp[s];
}
}
vector<vector<int> > dp(1 << rs.size());
for (int i = 0; i < 1 << rs.size(); ++ i) {
if (i && dp[i].size() == 0) continue;
for (int j = 0; j < pe.size(); ++ j) {
if (skill[j] == 0) continue;
int ns = i | skill[j];
if (dp[ns].size() == 0 || dp[i].size() + 1 < dp[ns].size()) {
dp[ns] = dp[i];
dp[ns].push_back(j);
}
}
}
return dp[(1 << rs.size()) - 1];
}
};
259 场单周
第一题
class Solution {
public:
int finalValueAfterOperations(vector<string>& os) {
int ret = 0;
for (string& s : os) {
if (s[1] == '+') ++ ret;
else -- ret;
}
return ret;
}
};
第二题
class Solution {
public:
int sumOfBeauties(vector<int>& nums) {
int ret = 0;
vector<int> pre(nums.size() + 1);
pre[nums.size()] = 100005;
for (int i = nums.size() - 1; i >= 0; -- i) {
pre[i] = min(nums[i], pre[i + 1]);
}
int k = nums[0];
for (int i = 1; i < nums.size() - 1; ++ i) {
if (k < nums[i] && nums[i] < pre[i + 1]) {
ret += 2;
}else if (nums[i - 1] < nums[i] && nums[i] < nums[i + 1]) {
ret += 1;
}
k = max(k, nums[i]);
}
return ret;
}
};
第三题
class DetectSquares {
public:
static const int N = 1005;
int st[1005][1005];
int dx[4] = {1, 1, -1, -1};
int dy[4] = {-1, 1, 1, -1};
DetectSquares() {
memset(st, 0, sizeof st);
}
void add(vector<int> point) {
st[point[0]][point[1]] ++;
}
int count(vector<int> point) {
int ret = 0;
int x = point[0], y = point[1];
for (int i = 1; i < N; ++ i) {
for (int k = 0; k < 4; ++ k) {
int xt = x + dx[k] * i;
int yt = y + dy[k] * i;
if (xt < 0 || xt >= N || yt < 0 || yt >= N) continue;
ret += 1 * st[x][yt] * st[xt][y] * st[xt][yt];
}
}
return ret;
}
};
/**
* Your DetectSquares object will be instantiated and called as such:
* DetectSquares* obj = new DetectSquares();
* obj->add(point);
* int param_2 = obj->count(point);
*/
第四题
class Solution {
public:
unordered_map<int, int> cnt;
string s, track, ret;
int k;
void dfs() {
unordered_map<int, int> cnt2(cnt);
for (auto& [ch, ct] : cnt2) {
track += ch;
if (track.size() > ret.size() || (track.size() == ret.size() && track > ret)) {
int time = 0, pos = 0;
for (char& c : s) {
if (c == track[pos]) {
++ pos;
if (pos == track.size()) {
++ time, pos = 0;
}
}
}
if (time >= k) ret = track;
}
cnt[ch] -= k;
if (cnt[ch] < k) {
cnt.erase(ch);
}
dfs();
track.pop_back();
cnt[ch] = ct;
}
}
string longestSubsequenceRepeatedK(string s, int k) {
this->k = k;
for (char c : s) {
cnt[c] ++;
}
string to_del;
for (auto [ch, ct] : cnt) {
if (ct < k) to_del += ch;
}
for (char& c : to_del) {
cnt.erase(c);
}
for (char& c : s) {
if (cnt.count(c)) this->s += c;
}
dfs();
return ret;
}
};
112 场单周
第一题
class Solution {
public:
int minIncrementForUnique(vector<int>& nums) {
sort(nums.begin(), nums.end());
int bk = -1;
int ret = 0;
for (int i = 0; i < nums.size(); ++ i) {
if (nums[i] <= bk) {
ret += bk - nums[i] + 1;
}
bk = max(bk + 1, nums[i]);
}
return ret;
}
};
第二题
class Solution {
public:
bool validateStackSequences(vector<int>& psh, vector<int>& pop) {
stack<int> stk;
for (int i = 0, j = 0; j < pop.size() && i < psh.size(); ) {
while (i < psh.size() && pop[j] != psh[i]) {
stk.push(psh[i]);
++ i;
}
if (i == psh.size()) return false;
stk.push(psh[i ++]);
while (j < pop.size() && stk.size() && stk.top() == pop[j]) {
++ j;
stk.pop();
}
}
// cout << stk.size() << endl;
if (stk.size() == 0) return true;
return false;
}
};
第三题
class Solution {
public:
int fa[1005];
int idx;
int find(int x) {
return fa[x] == -1 ? x : fa[x] = find(fa[x]);
}
void un(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
fa[a] = b;
-- idx;
}
}
int removeStones(vector<vector<int>>& s) {
memset(fa, -1, sizeof fa);
vector<vector<int> > row(10005);
vector<vector<int> > col(10005);
idx = 0;
for (auto& it : s) {
row[it[0]].push_back(idx);
col[it[1]].push_back(idx ++);
}
int k = 0;
for (auto& it : s) {
for (int& i : row[it[0]]) {
un(k, i);
}
for (int& i : col[it[1]]) {
un(k, i);
}
++ k;
}
return s.size() - idx;
}
};
第四题
class Solution {
public:
int bagOfTokensScore(vector<int>& ts, int pr) {
sort(ts.begin(), ts.end());
int ret = 0, k = 0;
for (int i = 0, j = ts.size() - 1; i <= j; ) {
while (i <= j && pr >= ts[i]) {
pr -= ts[i];
++ k;
++ i;
}
ret = max(ret, k);
if (!k) break;
if (i <= j) {
-- k;
pr += ts[j --];
}
}
return ret;
}
};
41 场双周
第一题
class Solution {
public:
int countConsistentStrings(string ad, vector<string>& ws) {
int ret = 0;
unordered_set<char> st;
for (char c : ad) {
st.insert(c);
}
for (string s : ws) {
int f = 1;
for (char c : s) {
if (!st.count(c)) {
f = 0;
break;
}
}
if (f) ++ ret;
}
return ret;
}
};
第二题
class Solution {
public:
vector<int> getSumAbsoluteDifferences(vector<int>& nums) {
vector<int> pre(nums.size() + 1);
for (int i = nums.size() - 1; i >= 0; -- i) {
pre[i] = nums[i] + pre[i + 1];
}
vector<int> ret(nums.size());
int sum = 0;
for (int i = 0; i < nums.size(); ++ i) {
int bx = nums.size() - i - 1;
ret[i] = pre[i + 1] - bx * nums[i];
if (i != 0) {
ret[i] += i * nums[i] - sum;
}
sum += nums[i];
}
return ret;
}
};
第三题
class Solution {
public:
int stoneGameVI(vector<int>& as, vector<int>& bs) {
vector<vector<int> > ret;
for (int i = 0; i < as.size(); ++ i) {
ret.push_back({as[i] + bs[i], as[i], bs[i]});
}
sort(ret.begin(), ret.end(), [](vector<int>& a, vector<int>& b) {
return a[0] > b[0];
});
int suma = 0, sumb = 0;
int f = 1;
for (int i = 0; i < ret.size(); ++ i) {
if (f) {
suma += ret[i][1];
f = 0;
}else {
sumb += ret[i][2];
f = 1;
}
}
if (suma > sumb) return 1;
else if (suma == sumb) return 0;
else return -1;
}
};
第四题
class Solution {
public:
int q[100005];
int boxDelivering(vector<vector<int>>& bs, int pt, int ms, int mt) {
int n = bs.size();
vector<long long> w(n + 1);
vector<int> g(n + 1), f(n + 1), neg(n + 1);
for (int i = 1; i <= n; ++ i) {
w[i] = w[i - 1] + bs[i - 1][1];
}
for (int i = 2; i <= n; ++ i) {
neg[i] = neg[i - 1] + (bs[i - 1][0] != bs[i - 2][0]);
int hh = 0, tt = -1;
q[++ tt] = 0;
for (int i = 1; i <= n; ++ i) {
while (hh <= tt && (q[hh] < i - ms || w[i] - w[q[hh]] > mt)) ++ hh;
f[i] = g[q[hh]] + neg[i] + 2;
if (i != n) {
g[i] = f[i] - neg[i + 1];
}
while (hh <= tt && g[i] <= g[q[tt]]) -- tt;
q[++ tt] = i;
}
return f[n];
}
};
206 场单周
第一题
class Solution {
public:
int numSpecial(vector<vector<int>>& mat) {
int n = mat.size();
int m = mat[0].size();
vector<int> row(n);
vector<int> col(m);
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
row[i] += mat[i][j];
}
}
for (int j = 0; j < m; ++ j) {
for (int i = 0; i < n; ++ i) {
col[j] += mat[i][j];
}
}
int ret = 0;
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (mat[i][j] && row[i] == 1 && col[j] == 1) ++ ret;
}
}
return ret;
}
};
第二题
class Solution {
public:
int unhappyFriends(int n, vector<vector<int>>& ps, vector<vector<int>>& pairs) {
unordered_map<int, int> mp;
for (auto& it : pairs) {
mp[it[0]] = it[1];
mp[it[1]] = it[0];
}
int ret = 0;
for (int i = 0; i < n; ++ i) {
int x = mp[i];
for (int j = 0; j < (int)ps[i].size(); ++ j) {
if (ps[i][j] == x) break;
int t = ps[i][j];
int tm = mp[t];
int f = 0;
for (int k = 0; k < (int)ps[t].size(); ++ k) {
if (ps[t][k] == tm) break;
if (ps[t][k] == i) {
// cout << i << " ";
f = 1;
++ ret;
}
}
if (f) break;
}
}
// cout << endl;
return ret;
}
};
第三题
class Solution {
public:
int fa[1005];
struct edge{
int a, b, c;
const bool operator<(const edge& e) {
return c < e.c;
}
}edges[1000006];
int get(vector<int>& a, vector<int>& b) {
int dx = abs(a[0] - b[0]);
int dy = abs(a[1] - b[1]);
return dx + dy;
}
int find(int x) {
return fa[x] == -1 ? x : fa[x] = find(fa[x]);
}
int minCostConnectPoints(vector<vector<int>>& points) {
int idx = 0;
memset(fa, -1, sizeof fa);
for (int i = 0; i < points.size(); ++ i) {
for (int j = i + 1; j < points.size(); ++ j) {
edges[idx ++] = {i, j, get(points[i], points[j])};
}
}
sort(edges, edges + idx);
int ret = 0;
for (int i = 0; i < idx; ++ i) {
int a = edges[i].a, b = edges[i].b, c = edges[i].c;
a = find(a);
b = find(b);
if (a != b) {
ret += c;
fa[a] = b;
}
}
return ret;
}
};
第四题
class Solution {
public:
bool isTransformable(string s, string t) {
vector<queue<int> > pos(10);
for (int i = 0; i < s.size(); ++ i) {
pos[s[i] - '0'].push(i);
}
for (int i = 0; i < t.size(); ++ i) {
int j = t[i] - '0';
if (pos[j].empty()) return false;
for (int k = 0; k < j; ++ k) {
if (!pos[k].empty() && pos[k].front() < pos[j].front()) return false;
}
pos[j].pop();
}
return true;
}
};
113 场单周
第一题
class Solution {
public:
string largestTimeFromDigits(vector<int>& A) {
sort(A.begin(), A.end());
string ans = "00:00";
bool flag = false;
do {
string t = "00:00";
t[0] = A[0] + '0';
t[1] = A[1] + '0';
t[3] = A[2] + '0';
t[4] = A[3] + '0';
if (t[0] > '2' || t[3] > '5') continue;
if (t[0] == '2' && t[1] > '3') continue;
if (t >= ans) {
ans = t;
flag = true;
}
} while (next_permutation(A.begin(), A.end()));
return flag ? ans : "";
}
};
第二题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
bool flipEquiv(TreeNode* root1, TreeNode* root2) {
if (!root1 && !root2) return true;
if ((root1 && root2 && root1 ->val != root2->val) || (root1 && !root2) || (!root1 && root2)) return false;
return (flipEquiv(root1->left, root2->right) && flipEquiv(root1->right, root2->left)) ||
(flipEquiv(root1->left, root2->left) && flipEquiv(root1->right, root2->right)) ;
}
};
第三题
class Solution {
public:
vector<int> deckRevealedIncreasing(vector<int>& deck) {
if (deck.size() <= 2) return deck;
sort(deck.begin(), deck.end());
deque<int> q;
q.push_back(deck.back());
q.push_front(deck[deck.size() - 2]);
for (int i = deck.size() - 3; i >= 0; -- i) {
q.push_front(q.back());
q.pop_back();
q.push_front(deck[i]);
}
vector<int> ret;
while (q.size()) {
ret.push_back(q.front());
q.pop_front();
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 1e5 + 5;
int primes[100005];
void init() {
for (int i = 2; i < N; ++ i) {
if (!primes[i]) primes[++ primes[0]] = i;
for (int j = 0; primes[j] <= N / i; ++ j) {
primes[primes[j] * i] = 1;
if (i % primes[j] == 0) break;
}
}
}
int fa[N], sz[N];
int ret = 1;
int find(int x ) {
return fa[x] == 0 ? x : fa[x] = find(fa[x]);
}
void un(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
fa[b] = a;
sz[a] += sz[b];
ret = max(ret, sz[a]);
}
}
int largestComponentSize(vector<int>& nums) {
init();
unordered_set<int> st;
for (int i : nums) st.insert(i);
for (int i = 0; i < N; ++ i) {
sz[i] = 1;
}
for (int i = 1; i <= primes[0]; ++ i) {
long long x = primes[i];
if (!st.count(x)) sz[x] --;
for (long long j = 1; j <= N / x; ++ j) {
long long t = (long long)j * x;
if (st.count(t)) {
un(x, t);
}
}
}
return ret;
}
};
285 场单周
第一题
class Solution {
public:
int countHillValley(vector<int>& nums) {
int ret = 0;
for (int i = 1; i < nums.size() - 1; ++ i) {
int j = i - 1, k = i + 1;
// while (j > 0 && nums[j] == nums[i]) -- j;
while (k < nums.size() - 1 && nums[i] == nums[k]) ++ k;
if (nums[j] < nums[i] && nums[k] < nums[i]) {
++ ret;
// cout << i << " f" << endl;
}
else if (nums[j] > nums[i] && nums[k] > nums[i]) {
// cout << i << " g" << endl;
++ ret;
}
}
return ret;
}
};
第二题
class Solution {
public:
int countCollisions(string ds) {
stack<char> st;
int f = 0;
int ret = 0;
for (int i = 0; i < ds.size(); ++ i) {
if (ds[i] == 'R') st.push('R');
else if (ds[i] == 'L') {
if (st.size()) ret += st.size();
else ret += f;
if (st.size() && st.top() == 'R') ++ ret;
while (st.size()) st.pop();
if (ret) f = 1;
}
else if (ds[i] == 'S') {
ret += st.size();
while (st.size()) st.pop();
f = 1;
}
// cout << "i " << i << " " << ret << endl;
}
return ret;
}
};
第三题
class Solution {
public:
vector<int> maximumBobPoints(int ns, vector<int>& as) {
int mask = 0, f = 0;
int ret = 0, rm = 0;
for (mask = 0; mask < (1 << 12); ++ mask) {
int tot = 0, se = 0;
for (int j = 0; j < 12; ++ j) {
if (mask >> j & 1) {
tot += as[j] + 1;
se += j;
}
if (tot <= ns) {
if (se > ret) {
ret = se;
rm = mask;
}
}
else break;
}
}
vector<int> rt(12, 0);
int tot = 0;
for (int j = 0; j < 12; ++ j) {
if (rm >> j & 1) {
rt[j] = as[j] + 1;
tot += rt[j];
}
}
if (ns > tot) rt[0] = ns - tot;
return rt;
}
};
第四题
补题中...
74 场双周
第一题
class Solution {
public:
bool divideArray(vector<int>& nums) {
int cnt[505];
memset(cnt, 0, sizeof cnt);
for (int& i : nums) cnt[i] ++;
for (int i = 1; i < 505; ++ i) {
if (cnt[i] % 2) return false;
}
return true;
}
};
第二题
class Solution {
public:
long long maximumSubsequenceCount(string tx, string p) {
int cnta = 0, cntc = 0;
for (char c : tx) {
if (c == p[0]) ++ cnta;
else if (c == p[1]) ++ cntc;
}
if (cnta > cntc) tx += p[1];
else {
string tt;
tt += p[0];
tt += tx;
tx = tt;
}
int cnt[100005];
memset(cnt, 0, sizeof cnt);
for (int i = tx.size() - 1; i >= 0; -- i) {
cnt[i] = cnt[i + 1];
if (tx[i] == p[1]) cnt[i] ++;
}
long long ret = 0;
for (int i = 0; i < tx.size(); ++ i) {
if (tx[i] == p[0]) {
ret += cnt[i + 1];
}
}
return ret;
}
};
第三题
class Solution {
public:
int halveArray(vector<int>& nums) {
int ret = 0;
priority_queue<double, vector<double>, less<double> > q;
for (int& i : nums) q.push(i);
double sum = 0;
for (int i = 0; i < nums.size(); ++ i) sum += (double)nums[i] / 2;
double t = 0;
int cnt = 0;
while (t < sum) {
t += q.top() / 2;
double tt = q.top();
q.pop();
q.push(tt / 2);
++ cnt;
}
return cnt;
}
};
第四题
class Solution {
public:
int minimumWhiteTiles(string f, int n, int c) {
vector<vector<int> > dp(f.size() + 1, vector<int>(n + 1, 1e8));
for (int i = 0; i <= n; ++ i) dp[0][i] = 0;
for (int i = 1; i <= f.size(); ++ i) {
for (int j = 0; j <= n; ++ j) {
dp[i][j] = dp[i - 1][j] + (f[i - 1] == '1');
if (j) dp[i][j] = min(dp[i][j], dp[max(i - c, 0)][j - 1]);
}
}
return dp[f.size()][n];
}
};
153 场
第一题
class Solution {
public:
int distanceBetweenBusStops(vector<int>& dt, int st, int dn) {
if (st > dn) swap(st, dn);
int k = dn - st;
int n = dt.size();
for (int i = 0; i < n; ++ i) dt.push_back(dt[i]);
int t = 0;
int ret;
for (int i = st; i < dn; ++ i) {
t += dt[i];
}
ret = t;
t = 0;
for (int i = dn; i < st + n; ++ i) {
t += dt[i];
}
// cout << ret << " " << t << endl;
ret = min(ret, t);
return ret;
}
};
第二题
class Solution {
public:
string dayOfTheWeek(int day, int month, int year) {
vector<string> week = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
vector<int> monthDays = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30};
/* 输入年份之前的年份的天数贡献 */
int days = 365 * (year - 1971) + (year - 1969) / 4;
/* 输入年份中，输入月份之前的月份的天数贡献 */
for (int i = 0; i < month - 1; ++i) {
days += monthDays[i];
}
if ((year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) && month >= 3) {
days += 1;
}
/* 输入月份中的天数贡献 */
days += day;
return week[(days + 3) % 7];
}
};
第三题
class Solution {
public:
int maximumSum(vector<int>& arr) {
vector<vector<int> > dp(arr.size() + 1, vector<int>(2));
dp[0][0] = -1e8;
for (int i = 1; i <= arr.size(); ++ i) {
dp[i][0] = max(dp[i - 1][0] + arr[i - 1], arr[i - 1]);
dp[i][1] = max(dp[i - 1][0], dp[i - 1][1] + arr[i - 1]);
}
int ret = -1e8;
for (int i = 1; i <= arr.size(); ++ i) {
ret = max(ret, max(dp[i][0], dp[i][1]));
}
return ret;
}
};
第四题
补题中...
249 场
第一题
class Solution {
public:
vector<int> getConcatenation(vector<int>& nums) {
vector<int> ans;
for (int i = 0; i < nums.size(); ++ i) ans.push_back(nums[i]);
for (int i = 0; i < nums.size(); ++ i) ans.push_back(nums[i]);
return ans;
}
};
第二题
class Solution {
public:
int countPalindromicSubsequence(string s) {
int ret = 0;
for (int i = 0; i < 26; ++ i) {
char c = 'a' + i;
int mx = 0;
unordered_set<char> ct;
int j;
for (j = 0; j < s.size(); ++ j) {
if (s[j] == c) break;
}
if (j + 1 < s.size()) ct.insert(s[++ j]);
++ j;
while (j < s.size() ) {
if (s[j] == c) {
mx = ct.size();
}
ct.insert(s[j]);
++ j;
}
ret += mx;
}
return ret;
}
};
第三题
补题中...
第四题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int d[200005];
TreeNode* q[200005];
void dfs(TreeNode* head, vector<int>& vt) {
if (head->left) dfs(head->left, vt);
vt.push_back(head->val);
if (head->right) dfs(head->right, vt);
}
TreeNode* canMerge(vector<TreeNode*>& trees) {
memset(d, 0, sizeof d);
unordered_map<int, TreeNode* > mp;
for (TreeNode* it : trees) {
mp[it->val] = it;
if (it->left)
{
++ d[it->left->val];
if (d[it->left->val] >= 2) return NULL;
}
if (it->right) {
++ d[it->right->val];
if (d[it->right->val] >= 2) return NULL;
}
}
int hh = 0, tt = -1;
TreeNode* head;
for (TreeNode* it : trees) {
if (d[it->val] == 0) {
q[++ tt] = it;
head = it;
break;
}
}
int cnt = 1;
unordered_set<TreeNode*> st;
while (hh <= tt) {
TreeNode* t = q[hh ++];
if (t->left) {
if (mp[t->left->val]) {
t->left = mp[t->left->val];
q[++ tt] = t->left;
++ cnt;
if (st.count(t->left)) return NULL;
st.insert(t->left);
}
}
if (t->right) {
if (mp[t->right->val]) {
t->right = mp[t->right->val];
q[++ tt] = t->right;
++ cnt;
if (st.count(t->right)) return NULL;
st.insert(t->right);
}
}
}
if (cnt != trees.size()) return NULL;
vector<int> vt;
dfs(head, vt);
if (is_sorted(vt.begin(), vt.end())) return head;
return NULL;
}
};
208 场
第一题
class Solution {
public:
int minOperations(vector<string>& logs) {
int cnt = 0;
for (string& s : logs) {
if (s[0] == '.' && s[1] == '.') {
if (cnt) -- cnt;
}
else if (s[0] == '.' && s[1] == '/');
else ++ cnt;
}
return cnt;
}
};
第二题
class Solution {
public:
int minOperationsMaxProfit(vector<int>& cs, int bt, int rt) {
long long ret = 0, rcnt = -1;
long long cnt = 0, res = 4, sum = 0;
for (int i = 0; i < cs.size(); ++ i) {
int f = 0;
int t = cs[i];
while (cnt < i) {
f = 1;
++ cnt;
res = 4;
}
while (t >= res) {
t -= res;
sum += res;
res = 4;
++ cnt;
f = 1;
}
if (f && (long long)sum * bt - (long long)cnt * rt > ret) {
ret = sum * bt - cnt * rt;
rcnt = cnt;
}
res -= t;
sum += t;
}
++ cnt;
if ((long long)sum * bt - (long long)cnt * rt > ret) {
ret = sum * bt - cnt * rt;
rcnt = cnt;
}
return rcnt;
}
};
第三题
class ThroneInheritance {
public:
unordered_map<string, vector<string> > mp;
unordered_set<string> dth;
string king;
ThroneInheritance(string kingName) {
king = kingName;
}
void birth(string parentName, string childName) {
mp[parentName].push_back(childName);
}
void death(string name) {
dth.insert(name);
}
void dfs(vector<string>&ret, string u) {
for (string& s : mp[u]) {
if (!dth.count(s)) ret.push_back(s);
dfs(ret, s);
}
}
vector<string> getInheritanceOrder() {
vector<string> ret;
if (!dth.count(king)) ret.push_back(king);
dfs(ret, king);
return ret;
}
};
/**
* Your ThroneInheritance object will be instantiated and called as such:
* ThroneInheritance* obj = new ThroneInheritance(kingName);
* obj->birth(parentName,childName);
* obj->death(name);
* vector<string> param_3 = obj->getInheritanceOrder();
*/
第四题
#define INF 1e8
class Solution {
public:
static const int N = 50, M = 60;
int h[N], e[M], f[M], w[M], ne[M], idx;
int q[N], d[N], pre[N], incf[N]; // d 记录权值， pre 记录来边， incf 记录到某地最大流量
int S, T;
bool st[N];
void add(int a, int b, int c, int ct) {
e[idx] = b, w[idx] = ct, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
e[idx] = a, w[idx] = -ct, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}
bool spfa()
{
int hh = 0, tt = 1;
memset(d, 0x3f, sizeof d);
memset(incf, 0, sizeof incf);
q[0] = S, d[S] = 0, incf[S] = INF;
while (hh != tt)
{
int t = q[hh ++ ];
if (hh == N) hh = 0;
st[t] = false;
for (int i = h[t]; ~i; i = ne[i])
{
int ver = e[i];
if (f[i] && d[ver] > d[t] + w[i])
{
d[ver] = d[t] + w[i];
pre[ver] = i;
incf[ver] = min(f[i], incf[t]);
if (!st[ver])
{
q[tt ++ ] = ver;
if (tt == N) tt = 0;
st[ver] = true;
}
}
}
}
return incf[T] > 0;
}
void EK(int& flow, int& cost)
{
flow = cost = 0;
while (spfa())
{
int t = incf[T];
flow += t, cost += t * d[T];
for (int i = T; i != S; i = e[pre[i] ^ 1])
{
f[pre[i]] -= t;
f[pre[i] ^ 1] += t;
}
}
}
int maximumRequests(int n, vector<vector<int>>& requests) {
vector<int> deg(n);
memset(h, -1, sizeof h);
for (auto& it : requests) {
add(it[0] + 1, it[1] + 1, 1, 1);
deg[it[0]] --;
deg[it[1]] ++;
}
S = N - 1, T = N - 2;
for (int i = 0; i < n; ++ i) {
if (deg[i] > 0) {
add(i + 1, T, deg[i], 0);
}else if (deg[i] < 0) {
add(S, i + 1, -deg[i], 0);
}
}
int flow, ret;
EK(flow, ret);
return requests.size() - ret;
}
};
141 场
第一题
class Solution {
public:
void duplicateZeros(vector<int>& arr) {
vector<int> ret;
for (int i = 0; i < arr.size(); ++ i) {
if (ret.size() >= arr.size()) break;
ret.push_back(arr[i]);
if (ret.size() >= arr.size()) break;
if (arr[i] == 0) ret.push_back(0);
}
arr = ret;
}
};
第二题
class Solution {
public:
int largestValsFromLabels(vector<int>& vs, vector<int>& ls, int nd, int ut) {
vector<pair<int, int> > tt;
for (int i = 0; i < vs.size(); ++ i) {
tt.push_back({vs[i], ls[i]});
}
sort(tt.begin(), tt.end(), [](pair<int, int>& a, pair<int, int>&b){
return a.first > b.first;
});
unordered_map<int, int> mp;
int ret = 0, cnt = 0;
for (auto& it : tt) {
if (cnt < nd) {
if (mp[it.second] < ut) {
++ mp[it.second];
++ cnt;
ret += it.first;
}
}else break;
}
return ret;
}
};
第三题
class Solution {
public:
int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
pair<int, int> q[10005];
int shortestPathBinaryMatrix(vector<vector<int>>& gd) {
int hh = 0, tt = -1;
if (gd[0][0] != 0) return -1;
if (gd.size() == 1 && gd[0].size() == 1) return 1;
q[++ tt] = {0, 0};
int ret = 1;
while (hh <= tt) {
int sz = tt - hh + 1;
++ ret;
for (int i = 0; i < sz; ++ i) {
int x = q[hh].first;
int y = q[hh ++].second;
for (int k = 0; k < 8; ++ k) {
int xt = x + dx[k];
int yt = y + dy[k];
if (xt < 0 || xt >= gd.size() || yt < 0 || yt >= gd[0].size() || gd[xt][yt]) continue;
gd[xt][yt] = 1;
q[++ tt] = {xt, yt};
if (xt == gd.size() - 1 && yt == gd[0].size() - 1) return ret;
}
}
}
return -1;
}
};
第四题
class Solution {
public:
string shortestCommonSupersequence(string s1, string s2) {
int n = s1.size();
int m = s2.size();
vector<vector<string> > dp(n + 1, vector<string>(m + 1));
for (int i = 1; i <= n; ++ i) {
for (int j = 1; j <= m; ++ j) {
if (s1[i - 1] == s2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + s1[i - 1];
}
else {
int t = 0, d = dp[i - 1][j - 1].size();
if (dp[i][j - 1].size() > d) {
t = 1;
d =dp[i][j - 1].size();
}
if (dp[i - 1][j].size() > d) {
t = 2;
d = dp[i - 1][j].size();
}
if (t == 0) dp[i][j] = dp[i - 1][j - 1];
else if (t == 1) dp[i][j] = dp[i][j - 1];
else if (t == 2) dp[i][j] = dp[i - 1][j];
}
}
}
string ret;
string t = dp[n][m];
int i, j, k;
for (i = 0, j = 0, k = 0; k < t.size(); ++ i, ++ j, ++ k) {
while (i < n && s1[i] != t[k]) {
ret += s1[i];
++ i;
}
while (j < m && s2[j] != t[k]) {
ret += s2[j];
++ j;
}
ret += t[k];
}
while (i < n) {
ret += s1[i ++];
}
while (j < m) {
ret += s2[j ++];
}
return ret;
}
};
238 场
第一题
class Solution {
public:
int sumBase(int n, int k) {
int ret = 0;
while (n) {
ret += n % k;
n /= k;
}
return ret;
}
};
第二题
class Solution {
public:
int maxFrequency(vector<int>& nums, int k) {
sort(nums.begin(), nums.end());
int ret = 0;
long long sum = 0;
for (int i = 0, j = 0; j < nums.size(); ++ j) {
sum += nums[j];
int t = j - i + 1;
while (i < j && (long long)sum + k < (long long)t * nums[j]) {
sum -= nums[i];
++ i;
-- t;
}
ret = max(ret, t);
}
return ret;
}
};
第三题
class Solution {
public:
string t = "aeiou";
int longestBeautifulSubstring(string word) {
int ret = 0;
stack<char> stk;
unordered_map<char, int> mp;
for (int i = 0; i < t.size(); ++ i) {
mp[t[i]] = i;
}
// int f = 0;
for (int i = 0; i < word.size(); ++ i) {
if (stk.size() && (mp[word[i]] < mp[stk.top()] || mp[word[i]] > mp[stk.top()] + 1)) {
while (stk.size()) stk.pop();
if (word[i] == 'a') stk.push(word[i]);
}
else if (stk.size()) stk.push(word[i]);
else if (word[i] == 'a') stk.push(word[i]);
if (stk.size() && stk.top() == 'u') ret = max(ret, (int)stk.size());
}
return ret;
}
};
第四题
补题中...
217 场
第一题
class Solution {
public:
int maximumWealth(vector<vector<int>>& as) {
int ret = 0;
for (auto& it : as) {
int t = 0;
for (int& x : it) {
t += x;
}
ret = max(ret, t);
}
return ret;
}
};
第二题
class Solution {
public:
vector<int> mostCompetitive(vector<int>& nums, int k) {
int n = nums.size();
vector<int> ret;
for (int i = 0; i < nums.size(); ++ i) {
for (int j = ret.size() - 1; j >= 0; -- j) {
if (ret[j] > nums[i] && i + k - j - 1 < n) {
ret.pop_back();
}else break;
}
if (ret.size() < k)
ret.push_back(nums[i]);
}
return ret;
}
};
第三题
class Solution {
public:
int minMoves(vector<int>& nums, int limit) {
// 差分数组, diff[0...x] 的和表示最终互补的数字和为 x，需要的操作数
// 因为差分数组的计算需要更新 r + 1，所以数组的总大小在 limit * 2 + 1 的基础上再 + 1
vector<int> diff(limit * 2 + 2, 0);
int n = nums.size();
for(int i = 0; i < n / 2; i ++){
int A = nums[i], B = nums[n - 1 - i];
// [2, 2 * limit] 范围 + 2
int l = 2, r = 2 * limit;
diff[l] += 2, diff[r + 1] -= 2;
// [1 + min(A, B), limit + max(A, B)] 范围 -1
l = 1 + min(A, B), r = limit + max(A, B);
diff[l] += -1, diff[r + 1] -= -1;
// [A + B] 再 -1
l = A + B, r = A + B;
diff[l] += -1, diff[r + 1] -= -1;
}
// 依次求和，得到 最终互补的数字和 i 的时候，需要的操作数 sum
// 取最小值
int res = n, sum = 0;
for(int i = 2; i <= 2 * limit; i ++){
sum += diff[i];
if(sum < res) res = sum;
}
return res;
}
};
作者：liuyubobobo
[链接：](https://leetcode-cn.com/problems/minimum-moves-to-make-array-complementary/solution/jie-zhe-ge-wen-ti-xue-xi-yi-xia-chai-fen-shu-zu-on/)
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
第四题
class Solution {
public:
int minimumDeviation(vector<int>& nums) {
int p_max = 1;
for(int a : nums) p_max = max(p_max, a >> (__builtin_ctz(a)));
vector<int> upper;
int min = p_max;
for(int a : nums){
if(a & 1) a <<= 1;
if(a >= p_max){
a >>= __builtin_clz(p_max) - __builtin_clz(a);
if(a < p_max) a <<= 1;
upper.push_back(a);
}
min = std::min(min, a);
}
sort(upper.begin(), upper.end());
int ans = upper.back() - min;
for(int i = upper.size() - 1; upper[i] > p_max; i -= 1){
min = std::min(min, upper[i] >> 1);
ans = std::min(ans, upper[i - 1] - min);
}
return ans;
}
};
244 场
第一题
class Solution {
public:
bool findRotation(vector<vector<int>>& mt, vector<vector<int>>& target) {
int n = mt.size();
int m = mt[0].size();
vector<vector<int> > ret(n, vector<int>(m));
for (int i = 0; i < 4; ++ i) {
for (int j = 0; j < n; ++ j) {
for (int k = 0, tk = n - 1; k < m; ++ k, -- tk) {
ret[j][k] = mt[tk][j];
}
}
if (ret == target) return true;
mt = ret;
}
return false;
}
};
第二题
class Solution {
public:
int reductionOperations(vector<int>& nums) {
sort(nums.begin(), nums.end());
int t = 0;
int ret = 0;
for (int i = 1; i < nums.size(); ++ i) {
if (nums[i] == nums[i - 1]) ret += t;
else ret += ++ t;
}
return ret;
}
};
第三题
class Solution {
public:
int minFlips(string s) {
int n = s.size();
vector<vector<int> > l(2, vector<int>(n));
vector<vector<int> > r(2, vector<int>(n));
for (int i = 0; i < 2; ++ i) {
for (int j = 0, c = 0, k = i; j < n; ++ j, k ^= 1) {
if (k != s[j] - '0') ++ c;
l[i][j] = c;
}
}
for (int i = 0; i < 2; ++ i) {
for (int j = n - 1, c = 0, k = i; j >= 0; -- j, k ^= 1) {
if (k != s[j] - '0') ++ c;
r[i][j] = c;
}
}
if (n % 2 == 0) {
return min(l[0][n - 1], l[1][n - 1]);
}else {
int ret = min(l[0][n - 1], l[1][n - 1]);
for (int i = 0; i + 1 < n; ++ i) {
ret = min(ret, l[0][i] + r[1][i + 1]);
ret = min(ret, l[1][i] + r[0][i + 1]);
}
return ret;
}
}
};
第四题
class Solution {
public:
int minWastedSpace(vector<int>& ps, vector<vector<int>>& bs) {
sort(ps.begin(), ps.end());
long long sum = 0;
for (int& x : ps) sum += x;
long long ret = 1e18;
for (auto& it : bs) {
sort(it.begin(), it.end());
if (ps.back() > it.back()) continue;
long long t = -sum, last = -1;
for (auto& x : it) {
int l = last, r = ps.size() - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (ps[mid] > x) r = mid - 1;
else l = mid;
}
if (r == last) continue;
t += (r - last) * x;
last = r;
}
ret = min(ret, t);
}
if (ret == 1e18) return -1;
int mod = 1e9 + 7;
return ret % mod;
}
};
146 场
第一题
class Solution {
public:
static const int N = 4E4 + 5;
int get(int v) {
return v * (1 + v) / 2;
}
int numEquivDominoPairs(vector<vector<int>>& ds) {
unordered_map<int, int> mp;
for (auto& it : ds) {
if (it[0] < it[1]) swap(it[0], it[1]);
mp[it[0] * N + it[1]] ++;
}
int ret = 0;
for (auto [c, v] : mp) {
if (v > 1)
ret += get(v - 1);
}
return ret;
}
};
第二题
补题ing...
第三题
class Solution {
public:
int mctFromLeafValues(vector<int>& arr) {
int n = arr.size();
vector<vector<int> > dp(arr.size(), vector<int>(arr.size(), 1e9));
vector<vector<int> > mx(n, vector<int>(n));
for (int i = 0; i < n; ++ i) {
int x = 0;
for (int j = i; j < n; ++ j) {
x = max(arr[j], x);
mx[i][j] = x;
}
}
for (int len = 1; len <= n; ++ len) {
for (int i = 0; i + len - 1 < n; ++ i) {
int j = i + len - 1;
if (i == j) {
dp[i][i] = 0;
}else {
for (int k = i; k < j; ++ k) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + mx[i][k] * mx[k + 1][j]);
}
}
}
}
return dp[0][n - 1];
}
};
第四题
补题ing...
194 场
第一题
class Solution {
public:
int xorOperation(int n, int start) {
int ret = 0;
while (n --) {
ret ^= start;
start += 2;
}
return ret;
}
};
第二题
class Solution {
public:
vector<string> getFolderNames(vector<string>& names) {
unordered_map<string, int> mp;
unordered_set<string> st;
vector<string> ret;
for (string s : names) {
if (st.count(s)) {
string t = s;
while (st.count(t)) {
t = s;
int& k = mp[s];
t += "(" + to_string(k + 1) + ")";
++ k;
}
s = t;
}
ret.push_back(s);
st.insert(s);
}
return ret;
}
};
第三题
vector<int> avoidFlood(vector<int>& rains) {
vector<int> ans(rains.size(), 1);
unordered_map<int, int> water;
set<int> zero;
for (int i = 0; i < rains.size(); i++) {
int r = rains[i];
if (r == 0) {
zero.insert(i);
continue;
}
if (water.count(r) != 0) {
auto it = zero.lower_bound(water[r]);
if (it == zero.end()) return {};
ans[*it] = r;
zero.erase(it);
}
water[r] = i;
ans[i] = -1;
}
return ans;
}
第四题
class Solution {
public:
static const int N = 105;
int fa[N];
int find(int x) {
return fa[x] == -1 ? x : find(fa[x]);
}
vector<vector<int>> findCriticalAndPseudoCriticalEdges(int n, vector<vector<int>>& es) {
vector<vector<int> > ret(2);
for (int i = 0; i < es.size(); ++ i) {
es[i].push_back(i);
}
sort(es.begin(), es.end(), [](vector<int>& a, vector<int>& b) {
return a[2] < b[2];
});
memset(fa, -1, sizeof fa);
int k = 0;
for (int i = 0; i < es.size(); ++ i) {
int a = es[i][0], b = es[i][1], c = es[i][2];
a = find(a);
b = find(b);
if (a != b) {
fa[a] = b;
k += c;
}
}
// cout << k << endl;
for (int j = 0; j < es.size(); ++ j) {
memset(fa, -1, sizeof fa);
int t = 0;
int at, bt, ct;
for (int i = 0; i < es.size(); ++ i) {
int a = es[i][0], b = es[i][1], c = es[i][2], id = es[i][3];
if (id == j) {
at = a, bt = b, ct = c;
continue;
}
a = find(a);
b = find(b);
if (a != b) {
fa[a] = b;
t += c;
}
}
int f = 1;
for (int i = 1; i < n; ++ i) {
if (find(i - 1) != find(i)) {
f = 0;
break;
}
}
if (f == 0 || t > k) {
ret[0].push_back(j);
continue;
}
memset(fa, -1, sizeof fa);
t = 0;
fa[find(at)] = find(bt);
t += ct;
for (int i = 0; i < es.size(); ++ i) {
int a = es[i][0], b = es[i][1], c = es[i][2], id = es[i][3];
if (id == j) {
continue;
}
a = find(a);
b = find(b);
if (a != b) {
fa[a] = b;
t += c;
}
}
if (t == k) ret[1].push_back(j);
}
return ret;
}
};
284 场
第一题
class Solution {
public:
vector<int> findKDistantIndices(vector<int>& nums, int key, int k) {
vector<int> ret;
vector<int> j;
for (int i = 0; i < nums.size(); ++ i) {
if (nums[i] == key) {
j.push_back(i);
}
}
for (int& x : j) {
for (int i = max(0, x - k); i < min((int)nums.size(), x + k + 1); ++ i) {
ret.push_back(i);
}
}
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
};
第二题
class Solution {
public:
int t;
int get(int x, int y) {
return x * t + y;
}
int digArtifacts(int n, vector<vector<int>>& as, vector<vector<int>>& dig) {
t = n;
unordered_set<int> st;
for (auto& it : dig) {
st.insert(get(it[0], it[1]));
}
int ret = 0;
for (auto& it : as) {
int f = 1;
for (int i = it[0]; i <= it[2]; ++ i) {
for (int j = it[1]; j <= it[3]; ++ j) {
if (!st.count(get(i, j))) {
f = 0;
break;
}
}
}
if (f) ++ ret;
}
return ret;
}
};
第三题
class Solution {
public:
int maximumTop(vector<int>& nums, int k) {
if (nums.size() == 1 && k % 2 == 1) return -1;
int ret = 0;
for (int i = 0; i < min((int)nums.size(), k + 1); ++ i) {
if (i != k - 1)
ret = max(ret, nums[i]);
}
return ret;
}
};
第四题
class Solution {
public:
static const int N = 2e5 + 5;
typedef pair<long long, int> PLI;
int n; // 点的数量
int h1[N], h2[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
long long d1[N], d2[N], d3[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定
// 求1号点到n号点的最短距离，如果不存在，则返回-1
void dijkstra(long long dist[N], int a, int h[N])
{
memset(st, false, sizeof st);
for (int i = 0; i < N; ++ i) dist[i] = 1e18;
dist[a] = 0;
priority_queue<PLI, vector<PLI>, greater<PLI>> heap;
heap.push({0, a}); // first存储距离，second存储节点编号
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second;
long long distance = t.first;
if (st[ver]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j], j});
}
}
}
}
void add(int h[N], int a, int b, int c) {
e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}
long long minimumWeight(int n, vector<vector<int>>& es, int s1, int s2, int dt) {
this->n = n;
memset(h1, -1, sizeof h1);
memset(h2, -1, sizeof h2);
for (auto& it : es) {
add(h1, it[0], it[1], it[2]);
add(h2, it[1], it[0], it[2]);
}
dijkstra(d1, s1, h1);
dijkstra(d2, s2, h1);
dijkstra(d3, dt, h2);
long long ans = 1e18;
for (int i = 0; i < n; i++) if (d1[i] >= 0 && d2[i] >= 0 && d3[i] >= 0) ans = min(ans, d1[i] + d2[i] + d3[i]);
return ans < 1e18 ? ans : -1;
}
};
225 场
第一题
class Solution {
public:
string maximumTime(string time) {
string ret;
string h, m;
if (time[0] == '?' && ((time[1] <= '3' && time[1] >= '0') || time[1] == '?')) ret += '2';
else if (time[0] == '?') {
ret += '1';
}else ret += time[0];
if (time[1] == '?' ) {
if (ret[0] != '2') ret += '9';
else ret += '3';
}else ret += time[1];
ret += ':';
if (time[3] == '?') ret += '5';
else ret += time[3];
if (time[4] == '?') ret += '9';
else ret += time[4];
return ret;
}
};
第二题
class Solution {
public:
int minCharacters(string a, string b) {
vector<int> acnt(26, 0);
vector<int> bcnt(26, 0);
int an = a.size(), bn = b.size();
for (char c : a) acnt[c-'a']++;
for (char c : b) bcnt[c-'a']++;
int ans = INT_MAX, asum = 0, bsum = 0;
for (int i = 0; i < 25; i++) {
asum += acnt[i];
bsum += bcnt[i];
ans = min(min(ans, an-acnt[i]+bn-bcnt[i]), min(an-asum+bsum, bn-bsum+asum));
}
ans = min(ans, an-acnt[25]+bn-bcnt[25]);
return ans;
}
};
第三题
class Solution {
public:
int kthLargestValue(vector<vector<int>>& mx, int k) {
int n = mx.size();
int m = mx[0].size();
vector<int> ret;
vector<vector<int> > pre(n + 1, vector<int>(m + 1));
for (int j = 0; j <= m; ++ j) {
pre[0].push_back(0);
}
for (int i = 0; i <= n; ++ i) {
pre[i][0] = 0;
}
for (int i = 1; i <= n; ++ i) {
for (int j = 1; j <= m; ++ j) {
pre[i][j] = mx[i - 1][j - 1] ^ pre[i - 1][j] ^ pre[i][j - 1] ^ pre[i - 1][j - 1];
ret.push_back(pre[i][j]);
}
}
sort(ret.begin(), ret.end());
// for (int i = 1; i <= n; ++ i) {
// for (int j = 1; j <= m; ++ j) {
// cout << pre[i][j] << " ";
// }
// cout << endl;
// }
// for (int& i : ret) cout << i << endl;
return ret[ret.size() - k];
}
};
第四题
class Solution {
public:
long long get(int x) {
return (long long)(1 + x) * x / 2;
}
bool check(int mid, int n) {
long long tot = 0;
for (int i = 1; i <= mid; ++ i) {
tot += get(i);
if (tot >= n) return true;
}
return false;
}
int minimumBoxes(int n) {
int l = 1, r = 2000;
while (l < r) {
int mid = l + r >> 1;
if (check(mid, n)) r = mid;
else l = mid + 1;
}
// for (int i = 1; i < l; ++ i) {
// n -= get(i);
// }
n -= l == 1? (long long)l * (l + 1) / 6 : (long long)(l - 1) * l * (l + 1) / 6;
int ret = get(l - 1);
for (int i = 0; ; ++ i) {
++ ret;
-- n;
n -= i;
if (n <= 0) break;
}
return ret;
}
};
261 场
第一题
class Solution {
public:
int minimumMoves(string s) {
int ret = 0;
for (int i = 0; i < s.size(); ++ i) {
if (s[i] == 'X') {
++ ret;
for (int k = 0; k < 3 && i + k < s.size(); ++ k) {
s[i + k] = 'O';
}
}
}
return ret;
}
};
第二题
class Solution {
public:
vector<int> missingRolls(vector<int>& rolls, int mean, int n) {
int m = rolls.size();
int tot = (n + m) * mean;
for (int& i : rolls) {
tot -= i;
}
if (tot > n * 6 || tot < n) return {};
vector<int> ret(n, 1);
tot -= n;
for (int i = 0; i < ret.size(); ++ i) {
if (tot >= 5) {
ret[i] += 5;
tot -= 5;
}
else {
if (tot == 0) break;
ret[i] += tot;
tot = 0;
}
}
return ret;
}
};
第三题
class Solution {
public:
bool stoneGameIX(vector<int>& stones) {
int cnt0 = 0, cnt1 = 0, cnt2 = 0;
for (int val: stones) {
if (int type = val % 3; type == 0) {
++cnt0;
}
else if (type == 1) {
++cnt1;
}
else {
++cnt2;
}
}
if (cnt0 % 2 == 0) {
return cnt1 >= 1 && cnt2 >= 1;
}
return cnt1 - cnt2 > 2 || cnt2 - cnt1 > 2;
}
};
第四题
补题ing...
118 场
第一题
class Solution {
public:
vector<int> powerfulIntegers(int x, int y, int bd) {
vector<int> ret;
for (int i = 0; ; ++ i) {
int n1 = pow(x, i);
if (n1 > bd) break;
for (int j = 0; ; ++ j) {
int n2 = pow(y, j);
long long z = (long long) n1 + n2;
if (z > bd) break;
ret.push_back(z);
if (y == 1) break;
}
if (x == 1) break;
}
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
};
第二题
class Solution {
public:
vector<int> pancakeSort(vector<int>& arr) {
int rt = 0;
vector<int> ret;
while (rt < arr.size()) {
int last = 0;
for (int i = 0; i < arr.size() - rt; ++ i) {
if (arr[i] >= arr[last]) {
last = i;
}
}
ret.push_back(last + 1);
ret.push_back(arr.size() - rt);
reverse(arr.begin(), arr.begin() + last + 1);
reverse(arr.begin(), arr.end() - rt);
++ rt;
}
return ret;
}
};
第三题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int fa[105];
int son[105][1];
void dfs(TreeNode* u, int f) {
int val = u->val;
fa[val] = f;
if (u->left) dfs(u->left, val);
if (u->right) {
dfs(u->right, val);
son[val][0] = u->right->val;
}
}
vector<int> flipMatchVoyage(TreeNode* root, vector<int>& ve) {
dfs(root, 0);
stack<pair<int, int> > stk;
stk.push({0, 0});
vector<int> ret;
for (int i = 0; i < ve.size(); ++ i ) {
while (stk.size() && fa[ve[i]] != stk.top().first) {
stk.pop();
}
if (stk.size() == 0) return {-1};
stk.top().second ++;
if (stk.top().second == 2 && son[stk.top().first][0] != ve[i] && stk.top().first != 0) {
ret.push_back(stk.top().first);
}
stk.push({ve[i], 0});
}
return ret;
}
};
第四题
class Solution {
public:
bool isRationalEqual(string s, string t) {
string t1, t2;
string s1, s2;
int s1h = 0, s2h = 0;
for (int i = 0; i < s.size(); ++ i) {
if (s[i] == '(') {
++ i;
while (s[i] != ')') {
t1 += s[i ++];
}
++ i;
break;
}
if (s[i] == '.') s1h = 1;
s1 += s[i];
}
for (int i = 0; i < t.size(); ++ i) {
if (t[i] == '(') {
++ i;
while (t[i] != ')') {
t2 += t[i ++];
}
++ i;
break;
}
if (t[i] == '.') s2h = 1;
s2 += t[i];
}
// cout << "s1: " << s1 << " " << "t1: " << t1 << endl;
// cout << "s2: " << s2 << " " << "t2: " << t2 << endl;
int f1 = 1, f2 = 1;
for (int i = 0; i < t1.size(); ++ i) {
if (t1[i] != '9') {
f1 = 0;
break;
}
}
if (t1.size() == 0) f1 = 0;
for (int i = 0; i < t2.size(); ++ i) {
if (t2[i] != '9') {
f2 = 0;
break;
}
}
if (t2.size() == 0) f2 = 0;
if (f2 == 0 && t2.size() > t1.size()) {
s2 += t2 + t2 + t2;
while (t1 != "" && f1 == 0 && !(t1.size() == 1 && t1[0] == '0') &&s1.size() < s2.size()) {
s1 += t1;
}
}else if (f1 == 0) {
s1 += t1 + t1 + t1;
while (t2 != "" && f2 == 0 && !(t2.size() == 1 && t2[0] == '0' )&& s2.size() < s1.size()) {
s2 += t2;
}
}
// cout << "s1: " << s1 << " " << "t1: " << t1 << endl;
// cout << "s2: " << s2 << " " << "t2: " << t2 << endl;
if (f1) {
int k = 1;
for (int i = s1.size() - 1; i >= 0; -- i) {
if (s1[i] == '.') continue;
int x = s1[i] - '0';
x += k;
k = 0;
if (x >= 10) {
k = 1;
x %= 10;
}
s1[i] = (char) '0' + x;
}
if (k) {
reverse(s1.begin(), s1.end());
s1 += "1";
reverse(s1.begin(), s1.end());
}
}
if (f2) {
int k = 1;
for (int i = s2.size() - 1; i >= 0; -- i) {
if (s2[i] == '.') continue;
int x = s2[i] - '0';
x += k;
k = 0;
if (x >= 10) {
k = 1;
x %= 10;
}
s2[i] = (char)'0' + x;
}
if (k) {
reverse(s2.begin(), s2.end());
s2 += "1";
reverse(s2.begin(), s2.end());
}
}
// cout << "s1: " << s1 << " " << "t1: " << t1 << endl;
// cout << "s2: " << s2 << " " << "t2: " << t2 << endl;
while (s1h && (s1.back() == '0' || s1.back() == '.')) {
if (s1.back() == '.') {
s1.pop_back();
break;
}
s1.pop_back();
}
while (s2h && (s2.back() == '.' || s2.back() == '0')) {
if (s2.back() == '.') {
s2.pop_back();
break;
}
s2.pop_back();
}
// cout << "s1: " << s1 << " " << "t1: " << t1 << endl;
// cout << "s2: " << s2 << " " << "t2: " << t2 << endl;
if ((t1.size() == 0 || t2.size() == 0 || (f1 && f2)) && s1.size() != s2.size()) return false;
for (int i = 0; i < min((int)s1.size(), (int)s2.size()); ++ i) {
if (s1[i] != s2[i]) return false;
}
return true;
}
};
180 场
第一题
class Solution {
public:
vector<int> luckyNumbers (vector<vector<int>>& mx) {
vector<int> ret;
int xi = 1e5 + 5;
vector<int> d(mx[0].size());
for (int i = 0; i < mx[0].size(); ++ i) {
for (int j = 0; j < mx.size(); ++ j) {
d[i] = max(d[i], mx[j][i]);
}
}
for (int i = 0; i < mx.size(); ++ i) {
int t = 0;
for (int j = 0; j < mx[0].size(); ++ j) {
if (mx[i][j] < mx[i][t])
t = j;
}
if (mx[i][t] == d[t]) ret.push_back(d[t]);
}
return ret;
}
};
第二题
class CustomStack {
public:
vector<int> stk;
int tot;
CustomStack(int maxSize) {
tot = maxSize;
}
void push(int x) {
if (stk.size() < tot) {
stk.push_back(x);
}
}
int pop() {
if (stk.size() == 0) return -1;
int x = stk.back();
stk.pop_back();
return x;
}
void increment(int k, int val) {
for (int i = 0; i < min((int)stk.size(), k); ++ i) stk[i] += val;
}
};
/**
* Your CustomStack object will be instantiated and called as such:
* CustomStack* obj = new CustomStack(maxSize);
* obj->push(x);
* int param_2 = obj->pop();
* obj->increment(k,val);
*/
第三题
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> nums;
void dfs(TreeNode* root) {
if (root->left) {
dfs(root->left);
}
nums.push_back(root->val);
if (root->right) {
dfs(root->right);
}
}
TreeNode* ct(vector<int>& nums, int l, int r) {
if (l == r) {
TreeNode* nw = new TreeNode(nums[l]);
return nw;
}
if (l + 1 == r) {
TreeNode* nw = new TreeNode(nums[l]);
nw->right = new TreeNode(nums[r]);
return nw;
}
int mid = l + r >> 1;
TreeNode* nw = new TreeNode(nums[mid]);
nw->left = ct(nums, l, mid - 1);
nw->right = ct(nums, mid + 1, r);
return nw;
}
TreeNode* balanceBST(TreeNode* root) {
dfs(root);
return ct(nums, 0, nums.size() - 1);
}
};
第四题
将所有的工程师按效率降序排序
遍历到第 i 个工程师，即将这个工程师加入到团队，并在前 i 个工程师中选速度最大的前 k - 1 个工程师（这里用 小顶堆 优化）
#define pii pair<int, int>
class Solution {
public:
vector<pii> team;
int mod = 1e9 + 7;
int maxPerformance(int n, vector<int>& sd, vector<int>& ey, int k) {
for (int i = 0; i < n; ++ i) {
team.push_back({sd[i], ey[i]});
}
sort(team.begin(), team.end(), [](pii& a, pii& b) {
return a.second > b.second;
});
long long sum = 0;
long long ret = 0;
priority_queue<int, vector<int>, greater<int> > q;
for (int i = 0; i < k; ++ i) {
q.push(team[i].first);
sum += team[i].first;
ret = max(ret, sum * team[i].second);
}
for (int i = k; i < n; ++ i) {
sum -= q.top();
q.pop();
sum += team[i].first;
q.push(team[i].first);
ret = max(ret, sum * team[i].second);
}
return ret % mod;
}
};
175 场
第一题
class Solution {
public:
bool checkIfExist(vector<int>& arr) {
unordered_set<int> st;
for (int i = 0; i < arr.size(); ++ i) {
if (st.count(arr[i] * 2)) return true;
if (arr[i] % 2 == 0 && st.count(arr[i] / 2)) return true;
st.insert(arr[i]);
}
return false;
}
};
第二题
class Solution {
public:
int minSteps(string s, string t) {
int cnt[26];
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < s.size(); ++ i) {
cnt[s[i] - 'a'] --;
cnt[t[i] - 'a'] ++;
}
int tot = 0;
for (int i = 0; i < 26; ++ i) {
tot += abs(cnt[i]);
}
return tot / 2;
}
};
第三题
class TweetCounts {
unordered_map<string, vector<int>> mp;
public:
TweetCounts() {
}
void recordTweet(string tweetName, int time) {
mp[tweetName].push_back(time);
}
vector<int> getTweetCountsPerFrequency(string fq, string te, int se, int ee) {
int len;
if (fq == "minute") len = 60;
else if (fq == "hour") len = 60 * 60;
else len = 60 * 60 * 24;
vector<int> ret((ee - se) / len + 1);
for (int t : mp[te])
if (t >= se && t <= ee)
++ ret[(t - se) / len];
return ret;
}
};
第四题
可放的数量 = 总点数 - 最小权点覆盖集
建图参考
#define INF 0x3f3f3f3f
class Solution {
public:
static const int N = 1000;
int h[N], e[N], ne[N], f[N], idx;
int dx[4] = {0, 0, -1, -1};
int dy[4] = {-1, 1, -1, 1};
int q[N], cur[N], d[N];
int S, T, n, m;
void add(int a, int b, int c) {
e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx ++;
e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}
bool bfs() {
for (int i = 0; i < N; ++ i) d[i] = -1;
int hh = 0, tt = 0;
q[tt ++] = S, d[S] = 0, cur[S] = h[S];
while (hh < tt) {
int t = q[hh ++];
for (int i = h[t]; i != -1; i = ne[i]) {
int ver = e[i];
if (d[ver] == -1 && f[i]) {
d[ver] = d[t] + 1;
cur[ver] = h[ver];
if (ver == T) return true;
q[tt ++] = ver;
}
}
}
return false;
}
int find(int u, int limit) {
if (u == T) return limit;
int flow = 0;
for(int i = cur[u]; i != -1 && flow < limit; i = ne[i]) {
int ver = e[i];
cur[u] = i;
if (d[ver] == d[u] + 1 && f[i]) {
int t = find(ver, min(limit - flow, f[i]));
if (!t) d[ver] = -1;
f[i] -= t, f[i ^ 1] += t, flow += t;
}
}
return flow;
}
int dinic() {
int ret = 0, flow = 0;
while (bfs()) while (flow = find(S, INF)) ret += flow;
return ret;
}
int get(int x, int y) {
return x * m + y + 1;
}
int maxStudents(vector<vector<char>>& ss) {
n = ss.size();
m = ss[0].size();
int tot = 0;
S = N - 1, T = N - 2;
memset(h, -1, sizeof h);
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < m; ++ j) {
if (ss[i][j] == '.') {
++ tot;
int x = i * m + j + 1;
if (j & 1) add(S, x, 1);
else add(x, T, 1);
if (j - 1 >= 0 && ss[i][j-1] == '.')
{
if (j & 1) add(x, get(i, j - 1), 1);
else add(get(i, j - 1), x, 1);
}
if (j + 1 < m && ss[i][j+1] == '.')
{
if (j & 1) add(x, get(i, j + 1), 1);
else add(get(i, j + 1), x, 1);
}
if (i && j + 1 < m && ss[i - 1][j + 1] == '.')
{
if (j & 1) add(x, get(i - 1, j + 1), 1);
else add(get(i - 1, j + 1), x, 1);
}
if (i && j && ss[i - 1][j - 1] == '.')
{
if (j & 1) add(x, get(i - 1, j - 1), 1);
else add(get(i - 1, j - 1), x, 1);
}
}
}
}
return tot - dinic();
}
};
浙公网安备 33010602011771号