AIM Tech Round 3 (Div. 2)

#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;
}

/*
题意:给你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;
}

/*
题意:给你一个字符串， 从这个字符串中选择一个非空的子串，可以将这些子串中的每个字符变到他前一个字符， 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;
}

/*
题意：给你一个序列中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--;

4000
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;
}