NOIP模拟测试12

I boom boom boom

Problem A:斐波那契(fibonacci)

题目名字就叫fibonacci，肯定要往这个方向想。

手玩那棵树，可以发现儿子与父亲的差是小于儿子的最大的fib数列的项。

开个set，一边用x减它能减的最大的fib的项来找爸爸一边往set里塞，然后一边减y一边在set里查，查见了输出就完事了。

不必担心时间复杂度问题，fib增长飞快，fib[60]就已经超过1e13了。

gmk手写hashtable太勇了（

#include <bits/stdc++.h>

long long fib[65], x, y;
int m;

signed main() {
    fib[1] = fib[2] = 1;
    for (int i = 3; i <= 60; i++)
        fib[i] = fib[i - 1] + fib[i - 2];
    scanf("%d", &m);
    for (int i = 1; i <= m; i++) {
        scanf("%lld%lld", &x, &y);
        std::set<long long> s;
        s.insert(x);
        for (int j = 60; j >= 1; j--) {
            if (x > fib[j])
                x -= fib[j], s.insert(x);
            if (x == 1) {
                s.insert(1);
                break;
            }
        }
        if (s.count(y)) {
            printf("%lld\n", y);
            continue;
        }
        for (int j = 60; j >= 1; j--) {
            if (y > fib[j]) {
                y -= fib[j];
                if (s.count(y)) {
                    printf("%lld\n", y);
                    break;
                }
            }
        }    
    }
    return 0;
}

Problem B:数颜色

看到这题就想到了Luogu P1903 数颜色，满脑子都是莫队，我的脑子再也容不下其他的想法（

光速码一个带修莫队，然而由于太久没写，出了很大的偏差。。。。先想了大约半小时，然后调调调，对了个拍感觉没啥问题，不过耗时太多了，已经9:50了。。。期望得分60

然而T成40？？？？

GMK怒斥，块长开了$ \sqrt N $，必死无疑

猛然惊醒，带修莫队最优块长是$ N ^ {\frac{2}{3}}$。。。

带修莫队最优块长是$ N ^ {\frac{2}{3}}$!!

带修莫队最优块长是$ N ^ {\frac{2}{3}}$ !!!

写这种带根号的东西的时候多试试块长。。。20分白丢了。。。。。

 

#include <bits/stdc++.h>

const int N = 3e5 + 233;
int n, m, a[N], cnt[N], blk, pos[N], ans[N], ncnt, ccnt, ch[N];
struct Node {
    int l, r, t, c, id;
    friend bool operator <(Node a, Node b) {
        if (pos[a.l] != pos[b.l]) return pos[a.l] < pos[b.l];
        if (pos[a.r] != pos[b.r]) return pos[a.r] < pos[b.r];
        else return a.t < b.t;
    }
} nd[N];

inline int R() {
    int a = 0; char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
    return a;
}

void Change(int t, int l, int r) {
    if (ch[t] + 1 == l)
        ++cnt[a[l - 1]], --cnt[a[l]]; 
    if (ch[t] == r) 
        ++cnt[a[r + 1]], --cnt[a[r]];
    std::swap(a[ch[t]], a[ch[t] + 1]);
}

inline void Add(int x) {cnt[x]++;}

inline void Del(int x) {cnt[x]--;}

signed main() {
    n = R(), m = R();
    for (int i = 1; i <= n; i++) a[i] = R();
    for (int i = 1, op; i <= m; i++) {
        op = R();
        if (op == 1) {
            int l = R(), r = R(), c = R();
            nd[++ncnt] = {l, r, ccnt, c, ncnt};
        } else {
            ch[++ccnt] = R();
        }
    }
    blk = pow(n, 0.666666);
    for (int i = 1; i <= n; i++)
        pos[i] = (i - 1) / blk + 1;
    std::sort(nd + 1, nd + 1 + ncnt);
    for (int i = 1, l = 1, r = 0, tim = 0; i <= ncnt; i++) {
        while (tim < nd[i].t) Change(++tim, l, r);
        while (tim > nd[i].t) Change(tim--, l, r);
        while (l < nd[i].l) Del(a[l++]);
        while (l > nd[i].l) Add(a[--l]);
        while (r < nd[i].r) Add(a[++r]);
        while (r > nd[i].r) Del(a[r--]);
        ans[nd[i].id] = cnt[nd[i].c];
    }
    for (int i = 1; i <= ncnt; i++)
        printf("%d\n", ans[i]);
    return 0;
}

正解有两种，数据结构学傻了的动态开点线段树和二分我选择二分

动态开点线段树好像空间有点问题，TKJ开了迫真内存池其实只是内存回收，我还是写二分了

开个vector存每种颜色存在的位置，修改直接二分查见修改位置暴力改，查询仍旧二分查位置，不多谈了。不过要注意查询的时候一个lower_bound一个upper_bound。

谨防数据结构学傻。。。。别让你的思维被那几个sqrt/log锢住。。。。

 

#include <bits/stdc++.h>

const int N = 3e5 + 5;
int n, m, a[N];
std::vector<int> v[N];

inline int R() {
    int a = 0; char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
    return a;
}

signed main() {
    n = R(), m = R();
    for (int i = 1; i <= n; i++) {
        a[i] = R();
        v[a[i]].push_back(i);
    }
    for (int i = 1, op; i <= m; i++) {
        op = R();
        if (op == 1) {
            int l = R(), r = R(), c = R();
            int p = std::lower_bound(v[c].begin(), v[c].end(), l) - v[c].begin();
            int q = std::upper_bound(v[c].begin(), v[c].end(), r) - v[c].begin();
            printf("%d\n", q - p);
        } else {
            int x = R();
            if (a[x] != a[x + 1]) {
                int p = std::lower_bound(v[a[x]].begin(),
                        v[a[x]].end(), x) - v[a[x]].begin();
                int q = std::lower_bound(v[a[x + 1]].begin(),
                        v[a[x + 1]].end(), x + 1) - v[a[x + 1]].begin();
                v[a[x]][p]++, v[a[x + 1]][q]--;
                std::swap(a[x], a[x + 1]);
            }
        }
    }
    return 0;
}

 

Problem C:分组

考试的时候时间不够了，而且读题读错了。。。。可见置顶计数器。

首先T2时间拖太久，心态有点爆炸了，这次考试的时间安排是有问题的。。。。

然后是读了题后我就开始想，这个团体该咋分啊，然后我就想。。。想了20min左右时间不够了，只能printf("1\n\n")了。。。

考完听讲题才看见K只能等于1或2。。。。。

少星际，多读题。。。多看看数据范围没坏处。。。。

K=1时显然，只能是把1-n分成几个连续的区间，直接单调地扫一遍就完事了。但有一个点，就是关于如何维护冲突。一看这数据范围，枚举平方的话撑死不到512²。我们维护一个是否出现过的数组vis[]，每有一个新的数就枚举幂k，看$k^2 - a_i$是否出现过。这样就把判断的复杂度降下来了。

注意，为了得到字典序最小的答案，我们从后往前枚举，这样能使分的位置尽量考前。

namespace Subtask1 {
    signed QAQ() {
        for (int i = n, j = n; i;) {
            for (bool gg = 0; j; j--) {
                for (int k = 1; k * k - a[j] < N; k++) {
                    if (k * k - a[j] <= 0) continue;
                    if (vis[k * k - a[j]]) {gg = 1; break;}
                }
                if (gg) break;
                vis[a[j]] = 1;
            }
            if (!j) break;
            brk[++m] = j;
            for (; i > j; i--) vis[a[i]] = 0;
        }
        printf("%d\n", m + 1);
        for (int i = m; i >= 1; i--)
            printf("%d ", brk[i]);
        puts("");
        return 0;
    }
}

K=2时我们可以在每个区间放冲突兔子了。如果把冲突兔子互相连边，区间实际上形成了二分图。

你暴力染色check肯定不行，$N^2$复杂度爆炸 然而数据太水，HZ有人这么A了

我反正看到这玩意就想起的不是关押罪犯，而是Luogu P2024 食物链。这是一个拓展域冰茶姬的板子。

我最开始是很懵的，gmk画图给我解了惑。我们把每只兔子拆开，冲突兔子相连，当达到什么的时候会冲突呢？就是兔子的两个点属于同一集合的时候。这个自己画图多膜膜你%你出来。

于是我们就在Subtask1的基础上，把这玩意加进去。

namespace Subtask2 {
    int fa[N << 1], mx;
    bool sp[N << 1], vis[N << 1];

    int get(int x) {
        return fa[x] == x ? x : fa[x] = get(fa[x]);
    }

    void merge(int x, int y) {
        x = get(x), y = get(y);
        fa[x] = y;
    }

    void QAQ() {
        for (int i = 1; i <= n; i++) mx = std::max(mx, a[i]);
        for (int i = 1; i <= 2 * mx; i++) fa[i] = i;
        for (int i = n; i >= 1; i--) {
            for (int j = 2; j <= 512; j++) {
                if (j * j - a[i] <= 0) continue;
                if (vis[j * j - a[i]]) {
                    merge(a[i], j * j - a[i] + mx);
                    merge(a[i] + mx, j * j - a[i]);
                }
            }
            if (get(a[i]) == get(a[i] + mx)) {
                brk[++m] = i;
                for (int j = i; j <= (m == 1 ? n : brk[m - 1]); j++)
                    fa[a[j]] = a[j], fa[a[j] + mx] = a[j] + mx, vis[a[j]] = 0;
            }
            vis[a[i]] = 1;
        }
    }
}

然而有一个问题，有重复兔子啊。。。当然不是所有重复兔子都要背锅，如果2倍是完全平方数就要背锅了。我们必须把她们放在两组。

大力特判，一个背锅兔子出现两次就不能插入敌对兔子了，放不下。

调试n年。。。。。。。。。

详情请见计数器。

namespace Subtask2 {
    int get(int x) {
        return fa[x] == x ? x : fa[x] = get(fa[x]);
    }

    void merge(int x, int y) {
        x = get(x), y = get(y);
        if (x != y) fa[x] = y;
    }

    signed QAQ() {
        for (int i = 2; i <= 512; i++) 
            if (!((i * i) & 1)) sp[(i * i) / 2] = 1;
        for (int i = 1; i <= n; i++) mx = std::max(mx, a[i]);
        for (int i = 1; i <= 2 * mx; i++) fa[i] = i;
        for (int i = n; i >= 1; i--) {
            for (int j = 2; j <= 512; j++) {
                if (j * j - a[i] <= 0) continue;
                if (j * j == 2 * a[i]) continue;
                if (vis[j * j - a[i]]) {
                    if (sp[j * j - a[i]] && vis[j * j - a[i]] >= 2) {
                        merge(a[i], a[i] + mx);
                        break;
                    }
                    merge(a[i], j * j - a[i] + mx);
                    merge(a[i] + mx, j * j - a[i]);
                }
            }
            if (sp[a[i]] && vis[a[i]]) {
                if (vis[a[i]] >= 2) merge(a[i], a[i] + mx);
                else for (int j = 2; j <= 512; j++) {
                    if (j * j - a[i] <= 0) continue;
                    if (j * j == 2 * a[i]) continue;
                    if (vis[j * j - a[i]]) {
                        merge(a[i], a[i] + mx);
                        break;
                    }
                }
            }
            if (get(a[i]) == get(a[i] + mx)) {
                brk[++m] = i;
                for (int j = i; j <= (m == 1 ? n : brk[m - 1]); j++)
                    fa[a[j]] = a[j], fa[a[j] + mx] = a[j] + mx, vis[a[j]] = 0;
            }
            vis[a[i]]++;
        }
        printf("%d\n", m + 1);
        for (int i = m; i >= 1; i--)
            printf("%d ", brk[i]);
        printf("\n");
        return 0;
    }
}

完全代码：

#include <bits/stdc++.h>

const int N = 131072 * 2 + 233;
int n, k, a[N], m, brk[N], fa[N << 1], mx, vis[N << 1];
bool sp[N << 1];

namespace Subtask1 {
    signed QAQ() {
        for (int i = n, j = n; i;) {
            for (bool gg = 0; j; j--) {
                for (int k = 1; k * k - a[j] < N; k++) {
                    if (k * k - a[j] <= 0) continue;
                    if (vis[k * k - a[j]]) {gg = 1; break;}
                }
                if (gg) break;
                vis[a[j]] = 1;
            }
            if (!j) break;
            brk[++m] = j;
            for (; i > j; i--) vis[a[i]] = 0;
        }
        printf("%d\n", m + 1);
        for (int i = m; i >= 1; i--)
            printf("%d ", brk[i]);
        puts("");
        return 0;
    }
}

namespace Subtask2 {
    int get(int x) {
        return fa[x] == x ? x : fa[x] = get(fa[x]);
    }

    void merge(int x, int y) {
        x = get(x), y = get(y);
        if (x != y) fa[x] = y;
    }

    signed QAQ() {
        for (int i = 2; i <= 512; i++) 
            if (!((i * i) & 1)) sp[(i * i) / 2] = 1;
        for (int i = 1; i <= n; i++) mx = std::max(mx, a[i]);
        for (int i = 1; i <= 2 * mx; i++) fa[i] = i;
        for (int i = n; i >= 1; i--) {
            for (int j = 2; j <= 512; j++) {
                if (j * j - a[i] <= 0) continue;
                if (j * j == 2 * a[i]) continue;
                if (vis[j * j - a[i]]) {
                    if (sp[j * j - a[i]] && vis[j * j - a[i]] >= 2) {
                        merge(a[i], a[i] + mx);
                        break;
                    }
                    merge(a[i], j * j - a[i] + mx);
                    merge(a[i] + mx, j * j - a[i]);
                }
            }
            if (sp[a[i]] && vis[a[i]]) {
                if (vis[a[i]] >= 2) merge(a[i], a[i] + mx);
                else for (int j = 2; j <= 512; j++) {
                    if (j * j - a[i] <= 0) continue;
                    if (j * j == 2 * a[i]) continue;
                    if (vis[j * j - a[i]]) {
                        merge(a[i], a[i] + mx);
                        break;
                    }
                }
            }
            if (get(a[i]) == get(a[i] + mx)) {
                brk[++m] = i;
                for (int j = i; j <= (m == 1 ? n : brk[m - 1]); j++)
                    fa[a[j]] = a[j], fa[a[j] + mx] = a[j] + mx, vis[a[j]] = 0;
            }
            vis[a[i]]++;
        }
        printf("%d\n", m + 1);
        for (int i = m; i >= 1; i--)
            printf("%d ", brk[i]);
        printf("\n");
        return 0;
    }
}

signed main() {
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++) scanf("%d", a + i);
    if (k == 1) return Subtask1::QAQ();
    else return Subtask2::QAQ();
}