Nordic Collegiate Programming Contest 2015

最新推荐文章于 2021-08-05 12:46:51 发布

ArkBagpipe

最新推荐文章于 2021-08-05 12:46:51 发布

阅读量244

点赞数 1

分类专栏： ACM-ICPC

本文链接：https://blog.csdn.net/NPU_SXY/article/details/81231322

版权

ACM-ICPC 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

题目链接

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，显然最多需要 $\left \lceil \frac{sum}{k} \right \rceil$ 台处理器。

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