AIM Tech Round 3 (Div. 2)

链接：戳这儿

A: 按照题意模拟

#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

int main() {
    int n, b, d;
    scanf("%d%d%d", &n, &b, &d);
    int now = 0;
    int res = 0;
    for(int i=0; i<n; i++) {
        int t; scanf("%d", &t);
        if(t <= b) now += t;
        if(now > d) now = 0, res++;
    }
    printf("%d\n", res);
    return 0;
}

B：

/*
    题意:给你n个点的坐标以及一个人的起点， 这个人需要从起点开始以任意的顺序遍历n-1个点， 问你最少走的距离是多少?
    分析:我们只需要排序之后枚举这个人走的n个点， 然后让这个人分别从两端走取个最小值即可。。注意n=1的时候要特判。
*/
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>

using namespace std;
const int maxn = 100000 + 100;
int pospos[maxn];
int n, pos;

int main() {
    scanf("%d%d", &n, &pos);

    for(int i=1; i<=n; i++)
        scanf("%d", &pospos[i]);
    if(n == 1) {
        printf("0\n");
        return 0;
    }
    sort(pospos+1, pospos+1+n);
    int res = 0x3f3f3f3f;
    for(int i=1; i+n-1-1<=n; i++) {
        int ans = pospos[i+n-1-1] - pospos[i];
        ans += min(abs(pos-pospos[i]), abs(pos-pospos[i+n-1-1]));
        res = min(res, ans);
    }
    printf("%d\n", res);
    return 0;
}

C:

/*
    题意:给你一个字符串， 从这个字符串中选择一个非空的子串，可以将这些子串中的每个字符变到他前一个字符， a变到z,
    让你输出字典序最小的字符串。
    分析:首先对于开头的a是不需要变为z的， 让后让接下来非a的字符变为他前面一个字符即可， 知道处理到下一个a结束
*/
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;
const int maxn = 100000 + 100;
char str[maxn];

int main() {
    scanf("%s", str);
    int len = strlen(str);
    int i;
    for(i=0; str[i]=='a'&&i<len; i++);
    bool flog = false;
    for(int j=i; str[j]!='a'&&j<len; j++){
        str[j] -= 1;
        flog = true;
    }
    if(!flog) str[len-1] = 'z';
    printf("%s\n", str);
    return 0;
}

D:

/*
    题意：给你一个序列中00，01， 10， 11的个数， 让你构造一个序列满足这些要求。。
    分析:首先我们可以根据00 11的个数知道序列中0 和 1的个数， 然后我们注意到01 和 10对的个数的和 = 0的个数 * 1个个数
    所以我们只需构造10即可。

*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>

using namespace std;
typedef long long LL;
LL a, b, c, d;

LL getnum(LL a) {
    LL x = (1+sqrt(1+8*a)) / 2;
    if(x*(x-1)/2 == a) return x;
    else return -1;
}

int main() {
    cin>>a>>b>>c>>d;
    if(a+b+c+d==0) {
        printf("1\n");
    }else if(b+c+d == 0) {    //全是0
        LL zero = getnum(a);
        if(zero == -1) printf("Impossible\n");
        else while(zero) printf("0"), zero--;
        printf("\n");
    }else if(a+b+c == 0) {    //全是1
        LL zero = getnum(d);
        if(zero == -1) printf("Impossible\n");
        else while(zero) printf("1"), zero--;
        printf("\n");
    }else {
        LL zero = getnum(a), one = getnum(d);
        if(zero==-1 || one==-1) {
            printf("Impossible\n");
            return 0;
        }
        if(zero*one != b + c) {
            printf("Impossible\n");
            return 0;
        }
        LL usedone = 0;
        while(c >= zero) {
            printf("1");
            c -= zero;
            usedone++;
        }
        for(int i=0; i<zero-c; i++) printf("0");
        if(usedone < one) printf("1"),  usedone++;
        for(int i=0; i<c; i++) printf("0");
        while(usedone < one) printf("1"), usedone++;
        printf("\n");
    }
    return 0;
}

/*
    题意：给你一棵树，判断能否将树的一个节点通过一种操作变为重心, 这种操作是将一颗子树剪下来然后接到其他地方。
    tag：dp  dfs
    分析:首先我们可以将这棵树的重心作为树根， 然后考虑其他子节点， 对于一个子节点，超过n/2的子树肯定是树根所在的子树
    因此我们考虑将树根剪下来或者将树根的一个子树剪下来， 如果能让这个节点变为重心那么就可行， 否则不可行.

*/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;
const int maxn = 400000 + 100;
int n;
vector<int> G[maxn];
int sze[maxn];

int maxsubtree, centroid;
int dfs(int fa, int u, int N) {    //总的顶点数
    int sz = 1, m = 0;  //以u为根结点的子树大小    最大子树的大小
    for(int i=0; i<G[u].size(); i++) {
        int v = G[u][i];
        if(v == fa) continue;
        int tp = dfs(u, v, N);
        m = max(m, tp);
        sz += tp;
    }
    m = max(m, N-sz);
    if(m < maxsubtree) maxsubtree = m, centroid = u;
    return sz;
}

int dfs2(int fa, int u) {
    int sz = 1;
    for(int i=0; i<G[u].size(); i++) {
        int v = G[u][i]; if(v == fa) continue;
        sz += dfs2(u, v);
    }
    sze[u] = sz;
    return sz;
}
int ans[maxn];
void dfs3(int fa, int u, int maxnum) {
    if(n-sze[u]-maxnum <= (n/2)) ans[u] = 1;
    else ans[u] = 0;
    for(int i=0; i<G[u].size(); i++) {
        int v = G[u][i];
        if(v == fa || v==centroid) continue;
        dfs3(u, v, maxnum);
    }
}
int f[maxn];

bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
    return a.first > b.first;
}

int main() {
    scanf("%d", &n);
    for(int i=0; i<n-1; i++) {
        int u, v; scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    maxsubtree = 0x3f3f3f3f;
    dfs(-1, 1, n);
//    printf("centroid = %d\n", centroid);
    dfs2(-1, centroid);
    ans[centroid] = 1;
    int sumnode = 0;
    vector<pair<int, int> > tp;
    for(int i=0; i<G[centroid].size(); i++) {
        int v = G[centroid][i];
        sumnode += sze[v];
        tp.push_back(make_pair(sze[v], i));
    }
    sort(tp.begin(), tp.end(), cmp);
    for(int i=1; i<tp.size(); i++) {
        pair<int, int> tpii = tp[i];
        f[tpii.second] = tp[0].first;
    }
    f[tp[0].second] = tp[1].first;
    for(int i=0; i<G[centroid].size(); i++) {
        int maxnum = f[i], resnum = sumnode - sze[G[centroid][i]];
        if(resnum+1 <= (n/2)) maxnum = resnum;
        dfs3(-1, G[centroid][i], maxnum);
     }
     for(int i=1; i<=n; i++) {
        printf("%d%c", ans[i], i==n?'\n':' ');
     }
    return 0;
}