<防无聊>题解

简单题目解析与思路分享

最新推荐文章于 2024-03-03 18:15:29 发布

最新推荐文章于 2024-03-03 18:15:29 发布 · 340 阅读

训练题解专栏收录该内容

1 篇文章

订阅专栏

这篇博客分享了多个算法题目的解题思路，包括简单的判重、最大商选择、覆盖城市、K周期数组、图论基础、滑雪问题、扩展欧几里得应用以及素数交换等。鼓励读者多思考，互相讨论，提升编程能力。

这些题目许多都比较简单，希望大家能够多敲多想，实在不清楚再看题解，也可以相互讨论或者问学长学姐们

A - DZY Loves Hash
A题就是一个简单的判重，所有输入的数对p取模，输出所得结果中第一个重复的位置。

#include<bits/stdc++.h>
using namespace std;
int vis[305];
int main()
{
    int n,p,num;
    cin>>p>>n;
    memset(vis,0,sizeof(vis));
    int ans=-1,flag=0;
    for(int i=1;i<=n;i++)
    {
        cin>>num;
        if(flag==1) continue;
        num%=p;
        if(vis[num]) ans=i,flag=1;
        vis[num]=1;
    }
    printf("%d\n",ans);
    return 0;
}

B - DZY Loves Physics
B题其实很简单，题目要你选择一些点，使得Σ（选择点的点权）/Σ（所选点之间边的边权）最大，其实我们直接找到两个点使得两点和与相连边的商最大即可，因为在这种情况下再选择点进入只会减小这个值。

#include<bits/stdc++.h>
using namespace std;
double num[505];
int main()
{
    int n,m,a,b;
    double x;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%lf",num+i);
    double ans=0.0;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%lf",&a,&b,&x);
        ans=max(ans,(num[a]+num[b])/x);
    }
    printf("%.15lf\n",ans);
    return 0;
}

C - Megacity
C题就是说以原点为中心，以最小的半径圈住一些城市，使得人口总数满足>=1000000，用结构体排序即可完成。

#include<bits/stdc++.h>
using namespace std;
const int Max=1000000;
struct node
{
    int p;
    double dis;
}city[1005];
bool cmp(node a,node b)
{
    return a.dis<b.dis;
}
int main()
{
    int n,s;
    double x,y;
    scanf("%d%d",&n,&s);
    for(int i=1;i<=n;i++)
    {
        scanf("%lf%lf%d",&x,&y,&city[i].p);
        city[i].dis=sqrt(x*x+y*y);
    }
    sort(city+1,city+1+n,cmp);
    int vis=0;
    double ans=0.0;
    for(int i=1;i<=n;i++)
    {
        s+=city[i].p;
        ans=city[i].dis;
        if(s>=Max)
        {
            vis=1;
            break;
        }
    }
    vis?printf("%.7f\n",ans):printf("-1\n");
    return 0;
}

D - K-Periodic Array
D题就是找使得序列每K个为一循环的改动最少的次数，有种比较简单的方法，因为序列中不是1就是2，所以，我们只需要记录在循环中的每个位置上1和2的个数，取小的改变，这样就能得到最少的改动次数。

#include<bits/stdc++.h>
using namespace std;
int a[105][3];
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    int cnt=0;
    while(n--)
    {
        int x;
        scanf("%d",&x);
        a[cnt++][x]++;
        cnt%=k;
    }
    int ans=0;
    for(int i=0;i<k;i++)
        ans+=min(a[i][1],a[i][2]);
    printf("%d\n",ans);
    return 0;
}

E - 一个人的旅行
E题其实是个裸的图论，关于图论你们下个礼拜就会学习，我在这里就不详细讲解，有兴趣的可以先去了解一下，在这里我就贴两份代码。

#include<stdio.h>
#include<queue>
#define maxn 0x7ffffff
using namespace std;
int dis[1010],vis[1010],st[1010],fi[1010],mp[1010][1010],n;
void spaf(int s,int d)
{
    int i;
    for(i=1;i<=n;i++)
    {
        vis[i]=0;
        dis[i]=maxn;
    }
    queue<int>q;
    for(i=1;i<=s;i++)
    {
        vis[st[i]]=1;
        dis[st[i]]=0;
        q.push(st[i]);
    }
    while(!q.empty())
    {
        int m=q.front();
        q.pop();
        vis[m]=0;
        for(i=1;i<=n;i++)
        {
            if(dis[i]>dis[m]+mp[i][m])
            {
                dis[i]=dis[m]+mp[m][i];
                if(!vis[i])
                {
                    vis[i]=0;
                    q.push(i);
                }
            }
        }
    }
    int ans=maxn;
    for(i=1;i<=d;i++)
        ans=min(ans,dis[fi[i]]);
    printf("%d\n",ans);
}
int main()
{
    int T,S,D,i,j,a,b,c;
    while(scanf("%d%d%d",&T,&S,&D)!=EOF)
    {
        for(i=1;i<=1010;i++)
            for(j=1;j<=1010;j++)
                mp[i][j]=maxn;
        n=0;
        while(T--)
        {
            scanf("%d%d%d",&a,&b,&c);
            n=max(n,max(a,b));
            if(mp[a][b]>c)
                mp[a][b]=mp[b][a]=c;
        }
        for(i=1;i<=S;i++)
            scanf("%d",&st[i]);
        for(i=1;i<=D;i++)
            scanf("%d",&fi[i]);
        spaf(S,D);
    }
    return 0;
}

#include<stdio.h>
#include<algorithm>
#define maxn 0x3f3f3f3f
using namespace std;
int mp[1010][1010],ed[1010];
int main()
{
    int t,s,d,i,j,k,a,b,c,st;
    while(scanf("%d%d%d",&t,&s,&d)!=EOF)
    {
        for(i=0;i<1010;i++)
            for(j=0;j<=1010;j++)
                mp[i][j]=maxn;
        for(i=0;i<=1010;i++)
            mp[i][i]=0;
        int n=0;
        while(t--)
        {
            scanf("%d%d%d",&a,&b,&c);
            n=max(n,max(a,b));
            if(c<mp[a][b])
                mp[a][b]=mp[b][a]=c;
        }
        for(i=1;i<=s;i++)
        {
            scanf("%d",&st);
            mp[0][st]=0;
            mp[st][0]=0;
        }
        for(i=1;i<=d;i++)
            scanf("%d",&ed[i]);
        for(i=0;i<=n;i++)
            for(j=0;j<=n;j++)
                if(mp[i][j]!=maxn)
                {
                    for(k=0;k<=n;k++)
                        mp[j][k]=min(mp[j][k],mp[j][i]+mp[i][k]);
                }
        int ans=maxn;
        for(i=1;i<=d;i++)
            ans=min(ans,mp[0][ed[i]]);
        printf("%d\n",ans);
    }
    return 0;
}

F - 滑雪
F题就是一个搜索，我们可以使用记忆化搜索来缩减其复杂度，就是每次搜索时将已经搜索过的点的值保存下来，下次再搜到这个点时直接使用即可。

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
int r,c;
int dp[105][105],num[105][105],vis[105][105];
int X[4]= {0,0,1,-1};
int Y[4]= {1,-1,0,0};
int dfs(int x,int y)
{
    if(vis[x][y]) return dp[x][y];
    dp[x][y]=1;
    for(int i=0; i<4; i++)
    {
        int xx=x+X[i];
        int yy=y+Y[i];
        if(xx>r||yy>c||xx<=0||yy<=0)
            continue;
        if(num[xx][yy]<num[x][y])
            dp[x][y]=max(dfs(xx,yy)+1,dp[x][y]);
    }
    vis[x][y]=1;
    return dp[x][y];
}
int main()
{
    while(~scanf("%d%d",&r,&c))
    {
        memset(dp,0,sizeof(dp));
        memset(vis,0,sizeof(vis));
        for(int i=1; i<=r; i++)
            for(int j=1; j<=c; j++)
                scanf("%d",&num[i][j]);
        int ans=0;
        for(int i=1; i<=r; i++)  
            for(int j=1; j<=c; j++)
                ans=max(ans,dfs(i,j));  //暴力搜索，但每次搜完之后都不清空dp和vis
        printf("%d\n",ans);
    }
    return 0;
}

G - 青蛙的约会
G题其实是一个裸的扩展欧几里得应用，这里就推荐两篇比较好的博客。
http://www.cnblogs.com/ka200812/archive/2011/09/02/2164404.html
http://blog.youkuaiyun.com/zhjchengfeng5/article/details/7786595

#include<cstdio>
#include<iostream>
using namespace std;
typedef long long LL;
LL t,k,c;  //青蛙跳跃的次数t,gcd(a,b)=c,k见下面解析
void solve(LL a,LL b)
{
    if(b==0)
    {
        t=1;
        k=0;
        c=a;
    }
    else
    {
        solve(b,a%b);
        LL f=t;
        t=k;
        k=f-a/b*k;
    }
}
int main()
{
    LL x,y,m,n,l;
    cin>>x>>y>>m>>n>>l;
    int vis=0;
    LL a,b,d;
    if(m==n)
        vis=1;
    else
    {
        a=n-m;   //公式 (x+m*t)-(y+n*t)=k*l 转换而来
        b=l;
        d=x-y;   //转换完之后变成 a*t+k*b=d (可以使用扩展欧几里得)
        solve(a,b);
        if(d%c!=0)
            vis=1;
    }
    if(vis)
        printf("Impossible\n");
    else
    {
        LL t0=t*d/c;
        LL f=t0*c/b;
        t=t0-(b/c)*f;
        if(t<0)
            t+=b/c;
        cout<<t<<endl;
    }
    return 0;
}

H - 呵呵?线形代数?
H题就是你们写的PM3，题已经讲过了，就不再写思路了。

//暴力解法
#include<stdio.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
int a[maxn][maxn],b[maxn][maxn],c[maxn][maxn];
int main()
{
    int n,p,m;
    scanf("%d%d%d",&n,&p,&m);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=p; j++)
            scanf("%d",&a[i][j]);
    for(int i=1; i<=p; i++)
        for(int j=1; j<=m; j++)
            scanf("%d",&b[i][j]);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            scanf("%d",&c[i][j]);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
        {
            int num=0;
            for(int k=1; k<=p; k++)
                num+=a[i][k]*b[k][j];
            if(num!=c[i][j])
            {
                printf("No\n%d %d\n%d\n",i,j,num);
                return 0;
            }
        }
    printf("Yes\n");
    return 0;
}

//优化解法
#include<stdio.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
int a[maxn][maxn],b[maxn][maxn],c[maxn][maxn],sumb[maxn],sumc[maxn];
int main()
{
    int n,p,m;
    scanf("%d%d%d",&n,&p,&m);
    for(int i=1; i<=n; i++) for(int j=1; j<=p; j++) scanf("%d",&a[i][j]);
    for(int i=1; i<=p; i++) for(int j=1; j<=m; j++) scanf("%d",&b[i][j]),sumb[i]+=b[i][j];
    for(int i=1; i<=n; i++) for(int j=1; j<=m; j++) scanf("%d",&c[i][j]),sumc[i]+=c[i][j];
    int vis=0;
    for(int i=1; i<=n; i++)
    {
        int k=0;
        for(int j=1; j<=p; j++)
            k+=a[i][j]*sumb[j];
        if(k!=sumc[i])
        {
            vis=i;
            break;
        }
    }
    if(!vis) printf("Yes\n");
    else
    {
        printf("No\n");
        for(int i=1;i<=m;i++)
        {
            int k=0;
            for(int j=1;j<=p;j++)
                k+=a[vis][j]*b[j][i];
            if(k!=c[vis][i])
                printf("%d %d\n%d\n",vis,i,k);
        }
    }
    return 0;
}

I - Prime Swaps
I题是一个素筛+贪心，要将序列改成1~n排列的序列，交换a[i]和a[j]，要保证j-i+1是素数，且要在5n步之内完成，这符合哥德巴赫猜想，至于为什么，我也不太清楚。总之，我们可以知道，可以在5n步之内完成交换。
【思路】
1、首先设定一个数组pos[i]，表示数字i现在的位子。显然，如果pos[i]！=i，我们希望将这个数字i放到第i位。那么我们从第1个数处理第n个数。那么我们处理每一个数的时候，将这个数尽量向前交换，直到将这个数交换到位子i为止。
2、上述过程的实现：
①选择元素从1-N记做i，考虑将这个数交换到第i个位子。
②然后我们找一个位子j，使得这个位子j尽可能的小同时保证pos[i]-j+1是一个素数，然后将数字i现在所在位子和位子j进行交换。
③重复过程②直到数字i换到了位子i为止。
④记录这个交换过程输出即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=100005;
int a[maxn],pri[maxn],pos[maxn];
int ans[maxn*5][2],num;
int n;
void isprime()  //素数筛选
{
    memset(pri,0,sizeof(pri));
    for(int i=2;i<maxn;i++)
        if(!pri[i])
            for(int j=2*i;j<maxn;j+=i)
                pri[j]=1;
}
void solve()
{
    for(int i=1;i<=n;i++)
        while(pos[i]!=i)
            for(int j=i;j<pos[i];j++)
                if(!pri[pos[i]-j+1])  //注意此处记得交换pos[i]和j处的值，并更新pos[i]和j处的位置
                {
                    ans[++num][0]=j;
                    ans[num][1]=pos[i];
                    int k=pos[i];
                    pos[i]=j;
                    pos[a[j]]=k;
                    swap(a[k],a[j]);
                    break;
                }
}
int main()
{
    isprime();
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",a+i);
        pos[a[i]]=i;
    }
    solve();
    printf("%d\n",num);
    for(int i=1;i<=num;i++)
        printf("%d %d\n",ans[i][0],ans[i][1]);
    return 0;
}