Codeforces Round #446

Greed

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
    return (*((long long *)(x))) > (*((long long *)(y))) ?  : -;
}
long long a[], b[];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n;
    scanf("%d", &n);
    for (int i = ; i < n; i++)scanf("%lld", &a[i]);
    for (int i = ; i < n; i++)scanf("%lld", &b[i]);
    //qsort(b, n, sizeof(long long), cmp);
    sort(b, b + n);
    long long sum = ;
    for (int i = ; i < n; i++) sum += a[i];
    if (sum > b[n - ] + b[n - ]) printf("NO\n");
    else printf("YES\n");
    return ;
}

Wrath

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
    return (*((long long *)(x))) > (*((long long *)(y))) ?  : -;
}
int stack[], top = ;
long long l;
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n;
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
        scanf("%lld", &l);
        while (top >  && i - stack[top - ] <= l) top--;
        stack[top++] = i;
    }
    printf("%d\n", top);
    return ;
}

Pride

把一个不是1的数变成1肯定至少要1次操作，所以全变成1的最少操作次数肯定不会比a中不是1的数字个数还少。假定最初a中已经有了几个1，则直接输出n-1的个数。如果最初a中没有1，则首先用最少的操作次数弄出来一个1，然后再用n-1次操作把其他数字变成1。求弄出1的最少操作次数的方法是这样的：首先把a中相邻的数字两两求最大公约数，再对得到的数组再对相邻数字两两求最大公约数，直到出现1：则最少操作次数为迭代次数；全相同且不为1：说明不可能出现1。至于为啥，我也不知道，直觉是这样的，试了试居然过了。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
    return (*((long long *)(x))) > (*((long long *)(y))) ?  : -;
}
long long gcd(long long a, long long b) {
    long long k;
    while (b != ) {
        k = b;
        b = a % b;
        a = k;
    }
    return a;
}
long long a[][];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n, cnt = ;
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
        scanf("%lld", &a[][i]);
        if (a[][i] == ) cnt++;
    }
    if (cnt) {
        printf("%d\n", n - cnt);
        return ;
    }
    int last = ;
    for (int i = ; i < n; i++) {
        for (int j = ; j < n - i; j++) {
            a[ - last][j] = gcd(a[last][j], a[last][j + ]);
        }
        bool same = true, find1 = false;
        for (int j = ; j < n - i; j++) {
            if (a[ - last][j] == ) find1 = true;
            if (j +  < n - i && a[ - last][j] != a[ - last][j + ]) same = false;
        }
        if (find1) {
            printf("%d\n", n -  + i);
            return ;
        }
        if (same) {
            printf("-1\n");
            return ;
        }
        last =  - last;
    }
    printf("-1\n");
    return ;
}

Gluttony

把每个数字用大于它的最小的数字代替，最大的数字用最小的数字代替，没有-1的情况。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using std::vector;
using std::sort;
int cmp(const void * x, const void * y) {
    //x < y
    return (*((long long *)(x))) > (*((long long *)(y))) ?  : -;
}
int n;
long long a[], b[], c[];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    scanf("%d", &n);
    for (int i = ; i < n; i++) {
        scanf("%lld", &a[i]);
        b[i] = a[i];
    }
    qsort(a, n, sizeof(long long), cmp);
    for (int i = ; i < n; i++) {
        for (int j = ; j < n; j++) {
            if (b[i] == a[j]) {
                c[i] = j;
                break;
            }
        }
    }
    for (int i = ; i < n; i++) c[i] = (c[i] + ) % n;
    for (int i = ; i < n; i++) printf("%lld ", a[c[i]]);
    return ;
}

Envy

按边长从小到大处理（kruskal），各个询问中涉及的边也按从小到大处理。

当处理长度为i的边时，先不在整体的边集里处理，依次判断各个询问中涉及相同长度的边集全部加入会不会产生环，然后把长度为i的边全部加入最小生成树中（这个过程中产生环也无所谓，不加就行了）。

这个题标签里有个dsu，不过我用普通合并和启发式合并分别提交反而是普通合并比较快。他们都说启发式合并比较优，但是我觉得挺反直觉的，因为合并过程是一样的，得到的结果本质上也是一样的，所以我觉得启不启发没什么区别。强行要说的话，就是启发式能减少一点之后在路径压缩上花的时间。

Solution

Sloth

Last