2018 BIT 迎新赛

啊这......总之就是先摸一摸以前的迎新赛，找找手感。

网址http://codeforces.com/gym/102426

A，忘了线性相关是啥，百度一波，然后根据以前的经验，大概高斯消元一波就行了吧。

先消成倒三角，然后找一找有没有全0向量。有全零就代表线性相关。

第一次交的时候莫名其妙的WA了...然后微调了几个地方莫名其妙就A了，太怪了。

#include <bits/stdc++.h>

typedef long long LL;

const int N = 15;
const double eps = 1e-10;

int n, m;
double a[N][N];

inline double fabs(double x) {
    return (x < 0) ? (-x) : x;
}

inline bool work() {
    for(int i = 1; i < n; i++) {
        for(int j = i; j <= n; j++) {
            if(fabs(a[j][i]) > eps) {
                // [j][i] != 0
                std::swap(a[j], a[i]);
                break;
            }
        }
        if(fabs(a[i][i]) < eps) {
            continue;
        }
        for(int j = i + 1; j <= n; j++) {
            if(fabs(a[j][i]) < eps) {
                continue;
            }
            double x = a[j][i] / a[i][i];
            for(int k = i; k <= m; k++) {
                a[j][k] -= a[i][k] * x;
            }
        }
    }
    for(int i = 1; i <= n; i++) {
        bool flag = false;
        for(int j = 1; j <= m; j++) {
            if(fabs(a[i][j]) > eps) {
                flag = true;
                break;
            }
        }
        if(!flag) {
            return true;
        }
    }
    return false;
}

inline void solve() {

    memset(a, 0, sizeof(a));
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            int x;
            scanf("%d", &x);
            a[i][j] = x;
        }
    }

    if(work()) {
        printf("YES
");
    }
    else {
        printf("NO
");
    }

    return;
}

int main() {

    int T;
    scanf("%d", &T);
    while(T--) {
        solve();
    }

    return 0;
}

B，仔细一看，傻逼打表题，1s不到就跑出来答案了。

答案是93389411

C，有点复杂，没啥技术含量，不想写先放着。

D，cnm傻逼才会去写啊！

E，啊这，一开始看到的时候，觉得蓝书上面应该见过类似的，结果不会做。想了半天，最后还是回到了二分上，想到我有没有办法先二分到哪个位置开头，再二分那一个串，结果就想到了从外部二分答案，啊这！秒切了。log²能过。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 100010;

LL a[N];
int n;

template <typename T>
inline T max(const T &a, const T &b) {
    return a > b ? a : b;
}
template <typename T>
inline T min(const T &a, const T &b) {
    return a > b ? b : a;
}

inline LL cnt(LL x) {
    LL ans = 0;
    for(int i = 1; i <= n; i++) {
        int l = i, r = n, mid;
        while(l < r) {
            mid = (l + r + 1) >> 1;
            if(a[mid] - a[i - 1] < x) {
                l = mid;
            }
            else {
                r = mid - 1;
            }
        }
        ans += r - i + 1;
    }
    return ans;
}

int main() {
    LL l = 0x7fffffffffffffffll, r, mid, k;
    scanf("%d%lld", &n, &k);
    for(int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
        l = min(l, a[i]);
        a[i] += a[i - 1];
    }
    r = a[n];
    while(l < r) {
        mid = (l + r + 1) >> 1;
        if(cnt(mid) >= k) {
            r = mid - 1;
        }
        else {
            l = mid;
        }
    }
    printf("%lld
", r);
    return 0;
}

写了半天，二分写法快忘了...

F，好！见到一个水题，爽！

直接把n * m个数排序，就是个阶梯状的东西，然后随便做做就行了。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 1e6 + 10;

int n, m, t, v, a[N], b[N];

int main() {
    scanf("%d%d%d", &n, &m, &v);
    t = n * m;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            scanf("%d", &a[(i - 1) * m + j]);
        }
    }
    std::sort(a + 1, a + t + 1);
    int h = a[t];
    for(int i = 1; i <= t; i++) {
        b[i] = a[i] - a[i - 1];
    }
    for(int i = t; i >= 1 && v; i--) {
        if(v >= b[i] * (t - i + 1)) {
            v -= b[i] * (t - i + 1);
            h -= b[i];
        }
        else {
            h -= v / (t - i + 1);
        }
    }
    printf("%d
", h);
    return 0;
}

G，好！位运算水题，秒了。

#include <bits/stdc++.h>

const int N = 20;

int a[N], n = 11;
char str[N];

inline void out() {
    for(int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    puts("");
    return;
}

inline void add(int x) {
    for(int i = 0; i < n; i++) {
        if(x & (1 << i)) {
            a[i]++;
        }
    }
    out();
    return;
}

inline void del(int x) {
    int i = 0;
    while((1 << i) < x) {
        ++i;
    }
    while(!a[i] && i < n) {
        ++i;
    }
    if(i == n) {
        printf("ERROR!
");
    }
    else {
        int y = 1 << i;
        a[i]--;
        add(y - x);
    }
    return;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        int x;
        scanf("%s%d", str, &x);
        if(str[0] == 'f') {
            add(x);
        }
        else {
            del(x);
        }
    }
    return 0;
}

H

先想到，如果子区间白学那么父区间也白学。然后考虑预处理出对于左端点 i ，到ans[i]是最小的白学区间。

考虑到ans[i] ≤ ans[i + 1]，可以从右向左加数字，同时用一个ans[i]指针从右向左单调移动。又考虑到ans[i]一定是三角形的一边，于是把那个指针从右向左移动，用一个值域数据结构来维护......挂了。到这里，不会做了。

第二天，发现非白学串长度不会超过64，因为从最小往大加入，每次加入一个新数，如果想要不形成白学串，就要大于最大的两个之和。（感觉不是很严谨...）有了这个性质之后，直接从每个位置开始找log个，就是个log²了(还是用值域数据结构来维护有哪些数)，为了速度我们选择树状数组，抱着试一试的心态写出来，结果切了。

更具体的说，我们枚举左端点再枚举右端点，且这两个数一定是三角形的两边。于是第三条边就是（abs(a - b), a + b）这个范围内的了。

#include <bits/stdc++.h>

const int N = 100010;

int a[N], n, ans[N], X[N], top, ta[N * 2];

inline int abs(int x) {
    return (x < 0) ? (-x) : x;
}

inline void add(int i, int x) {
    for(; i <= top; i += i & (-i)) {
        ta[i] += x;
    }
}
inline int ask(int i) {
    int ans = 0;
    for(; i; i -= i & (-i)) {
        ans += ta[i];
    }
    return ans;
}
inline int ask(int l, int r) {
    if(l > r) return 0;
    return ask(r) - ask(l - 1);
}

inline void Main() {
    int m;
    scanf("%d%d", &n, &m);
    ans[n + 1] = n + 1;
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        X[i] = a[i];
    }
    std::sort(X + 1, X + n + 1);
    top = std::unique(X + 1, X + n + 1) - X - 1;
    for(int i = 1; i <= n; i++) {
        a[i] = std::lower_bound(X + 1, X + top + 1, a[i]) - X;
    }
    // solve
    for(int i = n; i >= 1; i--) {
        ans[i] = n + 1;
        for(int j = i + 1; j <= n; j++) {
            int l = abs(X[a[i]] - X[a[j]]), r = X[a[i]] + X[a[j]];
            l = std::upper_bound(X + 1, X + top + 1, l) - X;
            r = std::lower_bound(X + 1, X + top + 1, r) - X - 1;
            if(ask(l, r)) {
                ans[i] = j;
                break;
            }
            if(j == ans[i + 1]) {
                ans[i] = j;
                break;
            }
            add(a[j], 1);
        }
        for(int j = i + 1; j < ans[i]; j++) {
            add(a[j], -1);
        }
    }

    int l, r;
    for(int i = 1; i <= m; i++) {
        scanf("%d%d", &l, &r);
        if(r >= ans[l]) {
            printf("yes
");
        }
        else {
            printf("no
");
        }
    }
    return;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        Main();
    }
    return 0;
}

I，搞不倒

J，通过人数是最多的，然而...被long long坑了一次。

仔细一研究，发现是个树形结构，一个树形DP就搞定了。

#include <bits/stdc++.h>

typedef long long LL;
const int N = 200010;

struct Edge {
    int nex, v;
}edge[N]; int tp;

int e[N], fa[N], n;
LL f[N][2];

inline void adde(int x, int y) {
    edge[++tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
}

void dfs(int x) {
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        dfs(y);
        f[x][0] += std::max(f[y][0], f[y][1]);
        f[x][1] += f[y][0];
    }
    f[x][1] += x;
    return;
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        if(i & 1) {
            adde(n + 1, i);
        }
        else {
            adde(i / 2, i);
        }
    }
    dfs(n + 1);
    f[n + 1][1] -= n + 1;
    printf("%lld
", std::max(f[n + 1][0], f[n + 1][1]));
    return 0;
}

K，10个窗口，10次点击，瞧不起谁呢……