Codeforces Round #603 (Div. 2)
A - Sweet Problem
题意：有3种糖果（什么蜡烛？分不清candy和candle的一定不止我一个中国人），每天要吃两种不同的各1颗。给出3种的数量，求可以吃多少天。
题解：假如数据小的话直接每次去最高的两个--，然后sort就行了。可惜搞不得。但是每次取最高这个思路是没错的。假如三种数量很平均，那么肯定是加起来除以2的下整，不对的情况在于最多的糖不能充分利用，临界情况是恰好相等，所以：
void test_case() {
int a[4];
for(int i = 1; i <= 3; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + 1 + 3);
a[3] = min(a[3], a[1] + a[2]);
printf("%d\n", (a[1] + a[2] + a[3]) / 2);
}
B - PIN Codes
题意：有n(<=10)种PIN码，PIN码就是4位可前导零的数字，每次可以改动一位数字，求使得所有PIN码两两不同的最小改法。
题解：因为一共就10种码，刚好有10种数字，所以无论如何都最多改1位就够了。每次取重复的两个出来，然后遍历其中的数字，枚举把它改成谁会和大家都不一样。注意最后还要输出前后对应的关系。
map<string, int> m;
string a[15];
void test_case() {
m.clear();
int n;
cin >> n;
for(int i = 1; i <= n; ++i) {
cin >> a[i];
m[a[i]]++;
}
int ans = 0;
while(m.size() < n) {
string id;
for(auto i : m) {
if(i.second >= 2) {
id = i.first;
break;
}
}
++ans;
for(int j = 0; j <= 9; ++j) {
if(id[0] == ('0' + j))
continue;
string tmp = id;
tmp[0] = char('0' + j);
if(m.count(tmp))
continue;
else {
m[tmp]++;
m[id]--;
for(int k = 1; k <= n; ++k) {
if(a[k] == id) {
a[k] = tmp;
break;
}
}
break;
}
}
}
cout << ans << endl;
for(int i = 1; i <= n; ++i)
cout << a[i] << endl;
}
C - Everyone is a Winner!
题意：数论分块
注意：数论分块的复杂度是 \(\lceil2\sqrt{n}\rceil\) ，搞不清楚就弄个vec或者开大很多或者输出出来看一下。还有就是1e9的根号是3.2e4。
int a[64005];
void test_case() {
int n, atop = 0;
scanf("%d", &n);
for(int l = 1, r; l <= n; l = r + 1) {
r = n / (n / l);
a[++atop] = n / l;
}
a[++atop] = 0;
reverse(a + 1, a + 1 + atop);
printf("%d\n", atop);
for(int i = 1; i <= atop; ++i)
printf("%d%c", a[i], " \n"[i == atop]);
}
D - Secret Passwords
题意：两个字符串等价，当其中含有至少一个相同的字母时，并且可以传递。例如"ab"和"bc"等价，"bc"和"cd"等价，那么在本题中"ab"="bc"="cd"。求有多少种不等价的字符串。
题解：传递性，并查集，开26个节点表示26种字母，字符串就是无向边，全部等价连在一起，数有多少个连通块，记得去掉题目中没有出现的字母。
struct DisjointSetUnion {
static const int MAXN = 30;
int n, fa[MAXN + 5], rnk[MAXN + 5];
int cnt;
void Init(int _n) {
n = _n;
for(int i = 1; i <= n; i++) {
fa[i] = i;
rnk[i] = 1;
}
cnt = n;
}
int Find(int u) {
int r = fa[u];
while(fa[r] != r)
r = fa[r];
int t;
while(fa[u] != r) {
t = fa[u];
fa[u] = r;
u = t;
}
return r;
}
bool Merge(int u, int v) {
u = Find(u), v = Find(v);
if(u == v)
return false;
else {
if(rnk[u] < rnk[v])
swap(u, v);
fa[v] = u;
rnk[u] += rnk[v];
--cnt;
return true;
}
}
} dsu;
char s[1000005];
bool vis[30 + 5];
bool vis2[30 + 5];
void test_case() {
int n;
scanf("%d", &n);
memset(vis2, 0, sizeof(vis2));
dsu.Init(26);
for(int i = 1; i <= n; ++i) {
scanf("%s", s);
int len = strlen(s);
memset(vis, 0, sizeof(vis));
for(int j = 0; j < len; ++j) {
vis[s[j] - 'a' + 1] = 1;
vis2[s[j] - 'a' + 1] = 1;
}
int first = -1;
for(int j = 1; j <= 26; ++j) {
if(vis[j]) {
if(first == -1)
first = j;
dsu.Merge(first, j);
}
}
}
int sum = 0;
for(int i = 1; i <= 26; ++i)
sum += 1 - vis2[i];
printf("%d\n", dsu.cnt - sum);
}
E - Editor
题意：一个文本编辑器，有一段文本和一个光标，LR左右移动光标，其他字母修改文本。编辑器要给嵌套的括号染色，求最少的用色。
题解：一开始还在往FHQTreap那里想。其实合法的括号序列只需要：最终左右平衡且任何情况非负。嵌套最多时显然是最大值。用线段树就可以，树状数组感觉很不自然。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct SegmentTree {
#define ls (o<<1)
#define rs (o<<1|1)
static const int MAXN = 1000000;
static const int INF = 0x3f3f3f3f;
int mi[(MAXN << 2) + 5];
int ma[(MAXN << 2) + 5];
int lz[(MAXN << 2) + 5];
void PushUp(int o) {
mi[o] = min(mi[ls], mi[rs]);
ma[o] = max(ma[ls], ma[rs]);
}
void PushDown(int o, int l, int r) {
if(lz[o]) {
lz[ls] += lz[o];
lz[rs] += lz[o];
//int m = l + r >> 1;
mi[ls] += lz[o];
mi[rs] += lz[o];
ma[ls] += lz[o];
ma[rs] += lz[o];
lz[o] = 0;
}
}
void Build(int o, int l, int r) {
if(l == r) {
mi[o] = 0;
ma[o] = 0;
} else {
int m = l + r >> 1;
Build(ls, l, m);
Build(rs, m + 1, r);
PushUp(o);
}
lz[o] = 0;
}
void Update(int o, int l, int r, int ql, int qr, int v) {
if(ql <= l && r <= qr) {
lz[o] += v;
mi[o] += v;
ma[o] += v;
} else {
PushDown(o, l, r);
int m = l + r >> 1;
if(ql <= m)
Update(ls, l, m, ql, qr, v);
if(qr >= m + 1)
Update(rs, m + 1, r, ql, qr, v);
PushUp(o);
}
}
int QueryMin(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return mi[o];
} else {
PushDown(o, l, r);
int m = l + r >> 1;
int res = INF;
if(ql <= m)
res = QueryMin(ls, l, m, ql, qr);
if(qr >= m + 1)
res = min(res, QueryMin(rs, m + 1, r, ql, qr));
return res;
}
}
int QueryMax(int o, int l, int r, int ql, int qr) {
if(ql <= l && r <= qr) {
return ma[o];
} else {
PushDown(o, l, r);
int m = l + r >> 1;
int res = -INF;
if(ql <= m)
res = QueryMax(ls, l, m, ql, qr);
if(qr >= m + 1)
res = max(res, QueryMax(rs, m + 1, r, ql, qr));
return res;
}
}
#undef ls
#undef rs
} st;
int n, a[1000005];
char op[1000005];
void test_case() {
scanf("%d%s", &n, op + 1);
//st.Build(1, 1, n);
//memset(a, 0, sizeof(a));
int cur = 1, sum = 0;
for(int i = 1; i <= n; ++i) {
if(op[i] == 'L') {
--cur;
if(cur == 0)
cur = 1;
} else if(op[i] == 'R') {
++cur;
} else {
int tmp = 0;
if(op[i] == '(')
tmp = 1;
else if(op[i] == ')')
tmp = -1;
int d = tmp - a[cur];
if(d != 0) {
a[cur] = tmp;
sum += d;
st.Update(1, 1, n, cur, n, d);
}
}
int ans = -1;
if(sum == 0 && st.QueryMin(1, 1, n, 1, n) >= 0)
ans = st.QueryMax(1, 1, n, 1, n);
printf("%d%c", ans, " \n"[i == n]);
}
}
int main() {
#ifdef KisekiPurin
freopen("KisekiPurin.in", "r", stdin);
#endif // KisekiPurin
int t = 1;
//scanf("%d", &t);
for(int ti = 1; ti <= t; ++ti) {
//printf("Case #%d: ", ti);
test_case();
}
}
/*
1. 小数据问题退化：
输入为0或1会不会有特殊情况？其他的比如最小环要有三个点，强连通分量缩到最后一个点等等。
2. 内存：
内存的空间有没有开够？有时有反向边，有时有额外新加的边。线段树开了4倍了吗？
可持久化数据结构会不会内存溢出？多组数据时vector会不会翻车？字符大小写有考虑吗？
多组数据有进行初始化吗？memset会不会翻车？
3. 算术溢出：
乘法上溢出了？忘记取模了？输入输出用了%d？让无符号数越到负数了？
4. 习惯：
函数都有指定返回值吗？返回值非void函数的每一个分支都有显式的返回值吗？确定不会进入的分支可以assert一把。
Yes和No有没有反，大小写有没有错？有没有搞错n和m？离散化之后的cn有没有错？换行和空格要怎么整？priority要把符号反过来。
5. 其他bug：
基环树是树加环，不是链加环。
*/
注：这道题还有 \(O(n)\) 的做法，维护两个对顶栈，光标右移时把右边栈的元素吸到左边，光标左移时反过来。众所周知栈可以维护前缀最大值以及前缀最小值。但是实际操作起来速度还不如线段树，因为线段树并不是每次都Update，只有真正Update的时候才是log时间的，移动光标的速度飞快，无效改值的速度飞快，平均意义下来也很快。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct Stack {
static const int MAXN = 1000000;
static const int INF = 0x3f3f3f3f;
int s[MAXN + 5];
int mi[MAXN + 5];
int ma[MAXN + 5];
int top, sum;
void Clear() {
top = 0;
s[top] = 0;
mi[top] = INF;
ma[top] = -INF;
}
void Push(int v) {
++top;
s[top] = v;
sum += s[top];
mi[top] = min(mi[top - 1], sum);
ma[top] = max(ma[top - 1], sum);
}
void Pop() {
if(top) {
sum -= s[top];
--top;
}
}
int Top() {
return s[top];
}
int Min() {
return mi[top];
}
int Max() {
return ma[top];
}
} ;
struct Editor {
Stack LStack, RStack;
int cur, sum;
void LeftShift() {
if(cur == 1)
return;
RStack.Push(-LStack.Top());
LStack.Pop();
--cur;
}
void RightShift() {
LStack.Push(-RStack.Top());
RStack.Pop();
++cur;
}
void Clear() {
LStack.Clear();
RStack.Clear();
sum = 0;
RightShift();
}
void Update(int v) {
int pv = LStack.Top();
if(pv == v)
return;
LStack.Pop();
sum -= pv;
LStack.Push(v);
sum += v;
}
int Min() {
return min(LStack.Min(), RStack.Min());
}
int Max() {
return max(LStack.Max(), RStack.Max());
}
void Show() {
for(int i = 1; i <= LStack.top; ++i)
printf(" %d", LStack.s[i]);
printf(" |");
for(int i = RStack.top; i >= 1; --i)
printf(" %d", RStack.s[i]);
printf("\n");
}
} editor;
char op[1000005];
void test_case() {
int n;
scanf("%d%s", &n, op + 1);
editor.Clear();
for(int i = 1; i <= n; ++i) {
if(op[i] == 'L') {
editor.LeftShift();
} else if(op[i] == 'R') {
editor.RightShift();
} else {
int tmp = 0;
if(op[i] == '(')
tmp = 1;
else if(op[i] == ')')
tmp = -1;
editor.Update(tmp);
}
//editor.Show();
int ans = -1;
if(editor.sum == 0 && editor.Min() >= 0)
ans = editor.Max();
printf("%d%c", ans, " \n"[i == n]);
}
}
int main() {
#ifdef KisekiPurin
freopen("KisekiPurin.in", "r", stdin);
#endif // KisekiPurin
int t = 1;
//scanf("%d", &t);
for(int ti = 1; ti <= t; ++ti) {
//printf("Case #%d: ", ti);
test_case();
}
}
/*
1. 小数据问题退化：
输入为0或1会不会有特殊情况？其他的比如最小环要有三个点，强连通分量缩到最后一个点等等。
2. 内存：
内存的空间有没有开够？有时有反向边，有时有额外新加的边。线段树开了4倍了吗？
可持久化数据结构会不会内存溢出？多组数据时vector会不会翻车？字符大小写有考虑吗？
多组数据有进行初始化吗？memset会不会翻车？
3. 算术溢出：
乘法上溢出了？忘记取模了？输入输出用了%d？让无符号数越到负数了？
4. 习惯：
函数都有指定返回值吗？返回值非void函数的每一个分支都有显式的返回值吗？确定不会进入的分支可以assert一把。
Yes和No有没有反，大小写有没有错？有没有搞错n和m？离散化之后的cn有没有错？换行和空格要怎么整？priority要把符号反过来。
5. 其他bug：
基环树是树加环，不是链加环。
*/
注意：这道题的左移操作要特判左边是不是没有元素了。每个栈的最底部存放这个操作的幺元，这样就不用判空了。
这道题貌似也可以用平衡树来维护，只不过这样子使用的平衡树就和线段树一样了，常数还大。
