German Collegiate Programming Contest 2018

最新推荐文章于 2021-02-06 17:58:27 发布

原创最新推荐文章于 2021-02-06 17:58:27 发布 · 622 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

ACM-ICPC 专栏收录该内容

30 篇文章

订阅专栏

本文精选了多项算法竞赛题目并提供了详细的解决方案，包括绕过圆形障碍的最短路径、有向图中的最长路径、构建金字塔数字模式、寻找满足特定条件的素数对等问题，涵盖了从几何到图论再到数论的广泛算法知识。

题目链接

B. Battle Royale

从一个点绕过一个圆形区域到达另一个点，求最短的距离。

这个距离分为三段，两个点到圆周的切线和一段圆弧。L1和L2在直角三角形中可以直接求出来，根据余弦定理可以求出大角和两边的较小的角，相减得到圆弧对应的圆心角，求出L3。

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

struct node
{
    double x,y;
}s,e,p,q;
double r;
double len(node a,node b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}

int main()
{
    scanf("%lf%lf",&s.x,&s.y);
    scanf("%lf%lf",&e.x,&e.y);
    scanf("%lf%lf%lf",&q.x,&q.y,&r);
    scanf("%lf%lf%lf",&p.x,&p.y,&r);
    double rs=len(s,p),re=len(e,p),se=len(s,e);
    double ang=acos((re*re+rs*rs-se*se)/(2*re*rs));
    double ang1=acos(r/re),ang2=acos(r/rs);
    double ans=sqrt(re*re-r*r)+sqrt(rs*rs-r*r);
    ans+=(r*(ang-ang1-ang2));
    printf("%.10lf\n",ans);
    return 0;
}

C. Coolest Ski Route

在有向图里求出一个最长路。题目规定不存在负权边，那么根据反证法可以得到，这条路的起点必然是入度为0的点。这样只需要枚举所有入度为0的点用spfa求最长路就行了。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<iostream>
#include<algorithm>
#define maxn 1050
#define maxm 5050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,m,a,b,x,no;
int head[maxn],dis[maxn];
bool flag[maxn],vis[maxn];
struct node
{
    int to;
    int w;
    int nxt;
}e[maxm];
void add(int a,int b,int x)
{
    e[no].to=b;
    e[no].w=x;
    e[no].nxt=head[a];
    head[a]=no++;
}

int spfa(int s)
{
    for(int i=1;i<=n;i++)
        dis[i]=INF;
    memset(vis,0,sizeof(vis));
    vis[s]=1;
    dis[s]=0;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=e[i].nxt)
        {
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].w)
            {
                dis[v]=dis[u]+e[i].w;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    int res=0;
    for(int i=1;i<=n;i++)
        res=min(res,dis[i]);
    return res;
}

int main()
{
    scanf("%d%d",&n,&m);
    no=0;
    memset(head,-1,sizeof(head));
    memset(flag,0,sizeof(flag));
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&a,&b,&x);
        add(a,b,-x);
        flag[b]=1;
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        if(!flag[i])
            ans=max(ans,-1*spfa(i));
    }
    printf("%d\n",ans);
    return 0;
}

D. Down the Pyramid

两层数，上面的每一个数都是下层相邻两个数的和，给出上面一层，问下面一层有多少种合法的方案。

设上面一层是b[]，下面一层是a[]，可以写出相关的n+1个方程。消元之后可以将a1到an用a0和b[]表示出来。由于a1到an每个数与a0都是一一对应，因此只需要求出a0有多少种合法的取值。对于a[]的每一项都要大于等于0，解这n+1个不等式就可以得到a0的范围。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<iostream>
#include<algorithm>
#define maxn 1000050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n;
int a[maxn];

int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    ll sum=0;
    ll maxx=-1LL*INF,minn=1LL*INF;
    for(int i=0;i<n;i++)
    {
        if(i%2==0)sum+=a[i];
        else sum-=a[i];
        if(i%2==1)maxx=max(maxx,sum);
        else minn=min(minn,sum);
    }
    maxx=max(maxx,1LL*0);
    if(minn<0||minn<maxx)
        printf("0\n");
    else if(n==1)printf("%d\n",a[0]+1);
    else printf("%d\n",minn-maxx+1);
    return 0;
}

E. Expired License

给出两个实数a和b，求是否存在两个素数p,q满足a/b=p/q。

输入最多有5位小数，就将a和b都乘上1e5，然后除以它们的最大公因数，判断两个结果是不是都为素数。

有一种特殊情况是a和b相等，这时候上面的结果是1 1，这时候直接输出2 2。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<iostream>
#include<algorithm>
#define maxn 10000050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,num;
double a,b;
int pri[maxn];
bool flag[maxn];

void init()
{
    memset(flag,0,sizeof(flag));
    for(int i=2;i<=10000000;i++)
    {
        for(int j=i*2;j<=10000000;j+=i)
            flag[j]=1;
    }
    flag[1]=1;
    num=0;
    for(int i=2;i<=10000000;i++)
        if(!flag[i])pri[num++]=i;
}

int gcd(int a,int b)
{
    if(b==0)return a;
    return gcd(b,a%b);
}

int main()
{
    scanf("%d",&n);
    init();
    for(int i=0;i<n;i++)
    {
        scanf("%lf%lf",&a,&b);
        int x=round(a*100000),y=round(b*100000);
        int tmp=gcd(x,y);
        x/=tmp,y/=tmp;
        if(x==1&&y==1)
        {
            printf("2 2\n");
            continue;
        }
        if(!flag[x]&&!flag[y])
            printf("%d %d\n",x,y);
        else printf("impossible\n");
    }
    return 0;
}

F. Fighting Monsters

两个怪物打架的规则是攻击对方的时候就将对方的能力值减去自己的能力值。定义一对好的怪物是当一方失败的时候另一方的能力值恰好为1。

尝试模拟以后可以发现，一队怪物是好的的充要条件是，他俩的能力值是斐波那契数列的相邻两项。于是就对于数列的每一项，存储下能力值为这一项的怪物的下标。然后在每相邻的两项里取下标最小的解。还要注意两个怪物能力值都为1也是合法情况。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<iostream>
#include<algorithm>
#define maxn 55
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n;
int a[100050];
vector<int>v[maxn];
int w[maxn];

void init()
{
    w[0]=w[1]=1;
    for(int i=2;i<=32;i++)
        w[i]=w[i-1]+w[i-2];
}

int main()
{
    scanf("%d",&n);
    init();
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        int tmp=lower_bound(w+1,w+33,a[i])-w;
        if(w[tmp]==a[i])
            v[tmp].push_back(i);
    }
    int ansx=INF,ansy=INF;
    for(int i=1;i<32;i++)
    {
        if(v[i].size()==0)continue;
        if(v[i+1].size()==0)continue;
        if(ansx>v[i][0])
            ansx=v[i][0],ansy=v[i+1][0];
    }
    if(v[1].size()>1)
    {
        if(ansx>v[1][0])
            ansx=v[1][0],ansy=v[1][1];
    }
    if(ansx==INF)printf("impossible\n");
    else printf("%d %d\n",ansx,ansy);
    return 0;
}

H. Hyper Illuminati

给定m，求两个数n和s满足 $\sum_{i=0}^{s}i^{n-1}=m$ 。

可以直接枚举n从3到2^(n-1)>m为止，s从1到s^(n-1)>m为止。虽然m达到了1e16，但是long long还是可以解决，而且这个地方用double会产生谜之精度问题。。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<queue>
#include<algorithm>
#define maxn 100050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

ll m;

int main()
{
    scanf("%lld",&m);
    if(m==1)
    {
        printf("3 1\n");
        return 0;
    }
    for(int i=3;(1LL<<(i-1))<=m;i++)
    {
        ll tmp=m;
        int s=1;
        while(tmp>0)
        {
            ll res=1;
            for(int j=0;j<i-1;j++)
                res*=s;
            tmp-=res;
            s++;
        }
        if(tmp==0){printf("%d %d\n",i,s-1);return 0;}
    }
    printf("impossible\n");
    return 0;
}

I. It's Time for a Montage

一队英雄和一队怪物按照优先级排队打架，看优先级最高的英雄能否获胜。规定如果英雄和怪物的能力值相同，那么就看优先级较低的下一对的结果。每训练一天可以使所有英雄的能力值都提高1，问要使英雄获胜最少训练多少天。

考虑第一个英雄不能直接取胜的情况。这时候有一个怪物和英雄的能力值之差a。向后遍历每一对，如果这一对的能力值之差小于a，就只需要让第一个英雄训练到和第一个怪物相等，这样在后面的这一对中，训练之后英雄的能力值必然比怪物高，可以取胜，直接输出a。如果这一对的能力值之差大于a，那么直接让第一个英雄训练到直接战胜怪物，所花的时间反而更少，直接输出a+1。如果等于a，就无法在这一对分出胜负，继续向下遍历。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<iostream>
#include<algorithm>
#define maxn 1050
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n;
int a[maxn];
int b[maxn];

int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    for(int i=0;i<n;i++)scanf("%d",&b[i]);
    if(a[0]>b[0])
    {
        printf("0\n");
        return 0;
    }
    else
    {
        for(int i=1;i<n;i++)
        {
            if(b[i]-a[i]>b[0]-a[0])
            {
                printf("%d\n",b[0]-a[0]+1);
                return 0;
            }
            else if(b[i]-a[i]<b[0]-a[0])
            {
                printf("%d\n",b[0]-a[0]);
                return 0;
            }
        }
        printf("%d\n",b[0]-a[0]);
    }
    return 0;
}

L. Logic Puzzle

扫雷游戏，给出周围雷的数目，还原出雷区的分布。

不同的是这题中自己位置上的雷也会计算在内。一行一行地解决，从雷区的第一个位置开始，看左上角的位置的雷的数目，如果不为0，就把这个点标记上雷，并将自己和周围的位置全部减去1。

最后如果全部位置在处理完毕之后都为0，就代表存在合法的解。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<queue>
#include<algorithm>
#define maxn 115
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
typedef long long ll;

int n,m;
int s[maxn][maxn];
bool flag[maxn][maxn];
int pos[9][2]={1,0,0,1,-1,0,0,-1,1,1,1,-1,-1,1,-1,-1,0,0};

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<=n+1;i++)
    {
        for(int j=0;j<=m+1;j++)
            scanf("%d",&s[i][j]);
    }
    memset(flag,0,sizeof(flag));
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(s[i-1][j-1]>0)
            {
                flag[i][j]=1;
                for(int k=0;k<9;k++)
                {
                    int dx=i+pos[k][0];
                    int dy=j+pos[k][1];
                    s[dx][dy]--;
                }
            }
        }
    }
    for(int i=0;i<=n+1;i++)
    {
        for(int j=1;j<=m+1;j++)
        {
            if(s[i][j]!=0)
            {
                printf("impossible\n");
                return 0;
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(flag[i][j])
                printf("X");
            else printf(".");
        }
        printf("\n");
    }
    return 0;
}