A. Adjoin the Networks
给出若干棵树,将它们连成一整棵树,求新树直径的最小值。
对于一棵直径为d的树,它对新树直径的贡献最多为(d+1)>>1。于是求出所有子树的直径并对贡献排序。
注意连接的时候是在两棵树的某点之间连边,而不是把两个点直接合成一个。
如果只有一棵子树,新树的直径就是它的直径。
如果最大的两个贡献和第三大的不等,为了保证直径最小,直径至少就是这两个最大的通过一条边连接起来,就是最大的两个之和加1。
如果最大的三个贡献都相等,为了保证直径最小,直径至少就是这之中的两个通过两条边连接,就是最大的两个之和加2。
此外,最小的直径还可能是子树中最大的直径(不是贡献)。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<queue>
#include<cmath>
#include<set>
#include<iostream>
#include<algorithm>
#define maxn 100050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;
int n,m,a,b,cnt,res,x;
vector<int>maze[maxn];
int num[maxn];
bool vis[maxn],flag[maxn];
void dfs(int u,int num)
{
vis[u]=1;
flag[u]=1;
if(res<num){res=num,x=u;}
int len=maze[u].size();
for(int i=0;i<len;i++)
{
int v=maze[u][i];
if(!flag[v])
dfs(v,num+1);
}
}
int main()
{
cnt=0;
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
maze[a].push_back(b);
maze[b].push_back(a);
}
memset(vis,0,sizeof(vis));
int ans=0;
for(int i=0;i<n;i++)
{
if(!vis[i])
{
memset(flag,0,sizeof(flag));
x=i,res=0;dfs(i,0);
memset(flag,0,sizeof(flag));
res=0;dfs(x,0);
num[cnt++]=(res+1)/2;
ans=max(ans,res);
}
}
sort(num,num+cnt);
if(n==1||n==2)ans=max(ans,n-1);
else if(cnt==1)ans=max(ans,num[0]);
else if(cnt>=3&&num[cnt-1]==num[cnt-2]&&num[cnt-2]==num[cnt-3])
ans=max(ans,num[cnt-1]+num[cnt-2]+2);
else ans=max(ans,num[cnt-1]+num[cnt-2]+1);
printf("%d\n",ans);
return 0;
}
B. Belling Ringing
求1-n的所有全排列的一个排列,使得相邻两个排列中,每个数字的位置差异至多为1。(n<=8)
n的答案可以从n-1的答案递推而来。例如n=2的答案是1 2/2 1,于是在n=3的时候就在n=2的每个答案的每个位置上添加一个3,添加的方法如下:
1 2 3
1 3 2
3 1 2
3 2 1
2 3 1
2 1 3 可以看到每个数的位置都是不断的在1-n之间往复移动的。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<queue>
#include<cmath>
#include<set>
#include<iostream>
#include<algorithm>
#define maxn 100050
#define maxm 10050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;
int n;
vector<int>ans[maxn],tmp,res;
int main()
{
scanf("%d",&n);
ans[0].push_back(1);
if(n==1){printf("1\n");return 0;}
int no=1;
for(int i=2;i<=n;i++)
{
queue< vector<int> >q;
for(int j=0;j<no;j++)
q.push(ans[j]);
no=0;
int num=0;
while(!q.empty())
{
res=q.front();
q.pop();
int len=res.size();
if(num%2==1)
{
for(int j=0;j<=len;j++)
{
tmp=res;
tmp.insert(tmp.begin()+j,i);
ans[no++]=tmp;
}
}
else
{
for(int j=len;j>=0;j--)
{
tmp=res;
tmp.insert(tmp.begin()+j,i);
ans[no++]=tmp;
}
}
num++;
}
}
for(int i=0;i<no;i++)
{
for(int j=0;j<n;j++)
printf(j==n-1?"%d\n":"%d ",ans[i][j]);
}
return 0;
}
C. Cryptographer's Conundrum
直接看有多少个字符和PER循环的串不同即可。
D. Disastrous Downtime
n个任务依次进入处理器,处理器最多可以同时处理k个任务,处理每个任务都需要1000ms的时间,问要处理完所有的任务最少需要多少台处理器。
用一个队列模拟,让所有的任务依次进入,在每一个任务进入之前,将所有已经在队列中待了1000ms及以上的任务弹出队列,然后再将新任务压入队列。
维护这个过程中队列中元素的最大数量sum,显然最多需要台处理器。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<queue>
#include<iostream>
#include<algorithm>
#define maxn 100050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;
int n,k;
int a[maxn];
int main()
{
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
queue<int>q;
for(int i=1;i<=k;i++)
q.push(a[i]);
int maxx=k;
int num=k;
for(int i=k+1;i<=n;i++)
{
while(q.front()<=a[i]-1000&&!q.empty())
q.pop(),num--;
q.push(a[i]);
num++;
maxx=max(maxx,num);
}
int ans=maxx/k;
if(maxx%k!=0)ans++;
printf("%d\n",ans);
return 0;
}
E. Entertainment Box
有n个任务,第i个任务需要占用处理器li-ri的时间,现在只有一台处理器,每次最多可以处理k个任务,求最多可以处理这n个任务中的多少个。
将所有任务按照终止时间排序,前k个先加进去。后面每一个任务想要加入的时候,都贪心地去找终止时间距离新任务的起始时间最近的那个任务,通俗的讲就是让这个位置空闲浪费的时间尽可能少。如果能找到这样的一个位置,就把原先的任务去掉, 在这个位置加入新任务的终止时间。
这个过程的维护可以使用multiset,也可以用vector去模拟。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<queue>
#include<set>
#include<iostream>
#include<algorithm>
#define maxn 100050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;
int n,k;
vector<int>s;
struct node
{
int l,r;
}e[maxn];
bool cmp(node a,node b)
{
return a.r<b.r;
}
int main()
{
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++)
scanf("%d%d",&e[i].l,&e[i].r);
sort(e,e+n,cmp);
int ans=0,cnt;
for(int i=0;i<k;i++)
s.push_back(0);
for(int i=0;i<n;i++)
{
cnt = upper_bound(s.begin(),s.end(),e[i].l) - s.begin();
if(cnt!=0)
{
s.erase(s.begin()+cnt-1);
s.push_back(e[i].r);
ans++;
}
}
printf("%d\n",ans);
return 0;
}
F. Floppy Music
题意是给出一个数列a,给每项都乘上1或者-1,使得前缀和的最大值与最小值之差不超过t。
可以用暴力的去记录某个数是否会出现在前缀和里。dp[i][j]表示i项前缀和为j是否会出现。在每个a[i],枚举出现过的j,尝试向j+a[i]和j-a[i]扩展。
最后看dp[i][]中是否有数被标记即可。
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<iostream>
#include<algorithm>
#define maxn 100050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;
int t,n,m,x,y;
int flag[105][maxn];
int main()
{
scanf("%d",&t);
bool vis=0;
while(t--)
{
scanf("%d%d",&n,&m);
memset(flag,0,sizeof(flag));
for(int i=0;i<=n;i++)flag[0][i]=1;
for(int i=1;i<=m;i++)
{
scanf("%d%d",&x,&y);
int num=y-x;
for(int j=0;j<=n;j++)
{
if(j+num<=n)flag[i][j] |= flag[i-1][j+num];
if(j-num>=0)flag[i][j] |= flag[i-1][j-num];
}
}
int fflag=0;
for(int i=0;i<=n;i++)
fflag |= flag[m][i];
if(fflag==0)
vis=1;
}
if(vis)printf("impossible\n");
else printf("possible\n");
return 0;
}
G. Goblin Garden Guards
坐标的范围只有1e4*1e4,直接在每个喷泉暴力地标记能覆盖的点,然后对每个怪物判断是否被覆盖了即可。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<queue>
#include<cmath>
#include<set>
#include<iostream>
#include<algorithm>
#define maxn 100050
#define maxm 10050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;
int n,m,x,y;
int u,v,r;
bool flag[maxm][maxm];
struct node
{
int x,y;
}e[maxn];
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d%d",&e[i].x,&e[i].y);
}
memset(flag,0,sizeof(flag));
scanf("%d",&m);
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&r);
int l1=max(u-r,0),l2=max(v-r,0);
int r1=min(u+r,10000),r2=min(v+r,10000);
for(int j=l1;j<=r1;j++)
{
for(int k=l2;k<=r2;k++)
if((j-u)*(j-u)+(v-k)*(v-k)<=r*r)
flag[j][k]=1;
}
}
int ans=0;
for(int i=0;i<n;i++)
if(!flag[e[i].x][e[i].y])ans++;
printf("%d\n",ans);
return 0;
}