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]);
}

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：
        基环树是树加环，不是链加环。
*/