南阳理工学院软件、计科16级新生联合月赛（10月）

最新推荐文章于 2019-01-24 14:36:40 发布

黑色的夢

最新推荐文章于 2019-01-24 14:36:40 发布

阅读量2.7k

点赞数 2

分类专栏：题解文章标签： ACM

本文链接：https://blog.csdn.net/AcmLzq/article/details/52971957

版权

题解专栏收录该内容

1 篇文章 0 订阅

订阅专栏

感谢软件学院提供oj支持，以及机房援助~
//如果发现错误，请联系QQ：528859519，转载请注明出处。
A：矩阵相乘。
签到题，题目很容易理解，多组数据，两个n*n的矩阵的相乘，相乘的定义是：a[i][j]*b[i][j]=c[i][j]。
即两层for循环遍历i,j,使得c[i][j]=a[i][j]*b[i][j]，不过需要留意一下，输出矩阵的每一个数字后面都有空格。

#include<stdio.h>
int a[11][11],b[11][11],c[11][11];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int i,j;
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                scanf("%d",&a[i][j]);
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                scanf("%d",&b[i][j]),c[i][j]=a[i][j]*b[i][j];  //得到题中所求的矩阵
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
            {
                printf("%d ",c[i][j]);
                if(j==n)
                    printf("\n");  //每一行行末都有一个换行
            }
    }
    return 0;
}

B：lzq的大风车
中等题，打印一个风车，每个n对应一个长度和宽度均为2*n-1的风车，除了第一个风车前面没有换行，其他风车前面都有换行。
假设风车用一个二维字符数组来表示（行，列下标为i,j，1<=i,j<=2* n-1）可以以（n,n）为中心将这个风车分解为四部分：左上（1<=i<=n,1<=j<=n），右下（n<=i<=2 * n-1,n<=j<=2*n-1），左下（n<=i<=2 * n-1,1<=j<=n），右上（1<=i<=n,n<=j<=2 * n-1）。观察图案可知左上为满足j>=i时
为’ ’ ，右下满足j<=i时为’*‘，左下满足j<=2*n-i时为’ * ‘,右上满足j>=2 * n-i为j<=2*n-i时为’*‘，其他均为空格。联合上面的i,j取值范围可知左上‘*’的范围为（1<=i<=n，j>=i）,右下为‘*’的范围为（n<=i<=2*n-1，j<=i）,左下为’*’的范围为（n<=i<=2*n-1,j<=2*n-i）,右上为’*‘的范围为（1<=i<=n，j>=2*n-i）。

#include<stdio.h>
void print(int n)
{
    int i,j;
    for(i=1; i<2*n; i++)
    {
        for(j=1; j<2*n; j++)
            if((j>=i&&j<=n)||(j<=i&&j>=n)||(i<=n&&j>=2*n-i)||(i>=n&&j<=2*n-i))  //分别对应左上，右下，左下，右上是'*'的范围
                printf("*");
            else
                printf(" ");
        printf("\n");   //每一行行末要换行
    }
}
int main()
{
    int n,f=0;
    while(scanf("%d",&n)!=EOF)
    {
        if(f==1)   
            printf("\n"); //除了第一个风车外其他风车前面都有换行
        print(n);
        f=1;
    }
    return 0;
}

C：TC_荣耀之路
中等题，先查询n，m之间素数个数，若个数为素数，则输出n，m的最小公倍数，否则输出n，m的最大公约数。
数据范围不大，从min(n,m)到max(n,m)一路遍历，统计素数个数，再判断素数的个数是否为素数，若是，输出(n,m)最小公倍数，否则输出(n,m)的最大公约数。

#include<stdio.h>
#include<string.h>
#include<math.h>
int gcd(int a,int b)  //求最大公约数的调用函数
{
    int t;
    while(b!=0)
        t=a,a=b,b=t%a;  //辗转相除法
    return a;
}
int lcm(int a,int b)  //求最小公倍数的调用函数
{
    return a*b/gcd(a,b);  //两个相乘再除以最大公约数
}
int judge(int a)   //判断一个数是否为素数的调用函数
{
    int i;
    for(i=2; i<=sqrt(a); i++)
        if(a%i==0)
            return 0;    //若能被这些数整除，肯定不是素数
    if(a==0||a==1)
        return 0;      //0,1,不是素数
    return 1;   //若以上都不是，说明肯定是素数
}
int main()
{
    int nn;
    scanf("%d",&nn);
    while(nn--)
    {
        int n,m,i,prime=0,temp;
        scanf("%d%d",&n,&m);
        if(n>m)     //可能n>m
            temp=n,n=m,m=temp;
        for(i=n; i<=m; i++)
            if(judge(i))
                prime++;  //统计n到m之间素数个数
        if(judge(prime))
            printf("%d\n",lcm(n,m));  //若素数个数是素数，输出最小公倍数
        else
            printf("%d\n",gcd(n,m));  //不是素数，输出最大公约数
    }
    return 0;
}

D：小明和排列
简单题，有一次机会交换1~n的随机排列中的两个元素，求交换后的1和n的对应的距离。
用数组来存这个排列，将1和n分别和排列中的第一个，最后一个数字交换位置，并分别求出交换之后，1和n对应的下标绝对值之差。

#include<stdio.h>
#include<string.h>
int a[110];
int max(int a,int b)  //一个求两个数最大值的调用函数
{
    if(a>b) return a;
    return b;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int i,j,mini,maxi,s=0;  //s为所求值
        for(i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
            if(a[i]==1) mini=i;   
            if(a[i]==n) maxi=i;  //先求出1,n的下标,mini为数值为1的下标，maxi为数值为n的下标
        }
        for(i=1; i<=n; i++)
        {
            if(a[i]==1)
                s=max(maxi-1,s),s=max(n-maxi,s);  //若此下标为1，假设其与a[1]，a[n]交换了位置，求出其与maxi的下表之差，同时取最大值
            if(a[i]==n)
                s=max(mini-1,s),s=max(s,n-mini); //若此下标为1，假设其与a[1]，a[n]交换了位置，求出其与maxi的下表之差，同时取最大值
        }
        printf("%d\n",s);
    }
    return 0;
}

E：zlh取宝藏
难题，给一个d*d的矩阵，可以从d*d的矩阵中取一个以x,y为左上角的n*m的矩阵，现在要求选取的n*m的矩阵的所有值的和最大，输出选取点x,y的位置，以及最大值的值，若n*m的矩阵超出了d*d矩阵的右边界或下边界，则可从d*d矩阵的左边界或上边界补。如若从3*3矩阵中选取3,3为左上角的2*2矩阵，所选取的2*2矩阵所有元素为位置为(3,3),(1,1),(1,3),(3,1)，若最大值有多个解，先取行最小的，若行相等，取列最小的。
可暴力遍历a[1~d][1~d]的每个点，不断求d*d的矩阵值并更新最大的矩阵值即行列下标，因为涉及到超过边界问题，可将d*d的矩阵扩展到2d*2d，即a[1~d][d+1~2d]，a[d+1~2*d][1~d]，a[d+1~2*d][d+1~2d]分别等于a[1~d][1~d]。
同时n,m可能大于d，因此n应该取min(n,d),m取min(m,d)。

#include<stdio.h>
#include<string.h>
int a[110][110];
int main()
{
    int n,x,y;
    while(scanf("%d%d%d",&n,&x,&y)!=EOF)
    {
        if(x==0&&y==0&&n==0)
            break;
        x=(x>n)?n:x,y=(y>n)?n:y;  //为防止x，y大于n出现多加的情况，x，y的值不能超过n，若超过n则取n
        int ans=0,s=0,maxi,maxj,i,j,v,u;
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
                scanf("%d",&a[i][j]);
        for(i=n+1; i<=n+n; i++)
            for(j=1; j<=n; j++)
                a[i][j]=a[i-n][j];   //复制得到a[1~2n][1~n]
        for(i=1; i<=n+n; i++)
            for(j=n+1; j<=n+n; j++)
                a[i][j]=a[i][j-n];   //复制得到a[1~2n][1~2n]
        for(i=1; i<=n; i++)
            for(j=1; j<=n; j++)
            {
                s=0;
                for(v=i; v<i+x; v++)
                    for(u=j; u<j+y; u++)
                        s+=a[v][u];   //以i,j为落脚点，遍历这个x*y的矩阵
                if(ans<s)   //因取行最小的，如果行相同，取列最小的，所以不能用'<='
                    ans=s,maxi=i,maxj=j;   //若ans小于s，更新落脚点以及最大收获。
            }
        printf("%d %d %d\n",maxi,maxj,ans);
    }
    return 0;
}

F - GM的函数求值
思路题，已知函数f(x)有唯一值且
1.函数的定义域是正整数域，值域为整数域
2.f(1)=0
3.f(2*x)=2*f(x)+1
4.函数f(x)是单调递增函数,即如果x1>x2,则f(x1)>f(x2)。
给定一个x，求f(x)。
f(1)=0,f(2)=1,f(4)=3,f(8)=7,f(16)=15….因为f(x)为单调递增函数，所以可推出f(x)=x-1;

#include<stdio.h>
int main()
{
    int n;
    while(scanf("%d",&n)&&n>=1)   //当n<1时程序结束，所以while满足n>=1时执行循环
    {
        printf("%d\n",n-1);
    }
    return 0;
}

G - 这是一道简单题！
坑题，给定一个字符串，字符串里面包含的有小括号，不会出现括号的里面存在括号的情况，求括号里面小写字母个数（可能括号不匹配，只有左括号，没有右括号）。

遍历字符串数组，若字符为’(’，则向右遍历寻找到’)’，若找到，则从 ‘(’ 遍历到 ‘)’ ，统计小写字母的个数，统计完则继续重新从’)’的右边的字符开始继续遍历。

#include<stdio.h>
#include<string.h>
int main()
{
    int nn;
    char a[1010];
    scanf("%d",&nn);
    while(nn--)
    {
        scanf("%s",a);
        int s=0,i,j,k;
        for(i=0; a[i]!='\0'; i++)
            if(a[i]=='(')   //找到左括号
                for(j=i+1; a[j]!='\0'; j++)
                {
                    if(a[j]==')')  //找到右括号
                    {
                        for(k=i+1; k<j; k++)  //在左括号到右括号这段区间查找小写字母个数
                        {
                            if(a[k]>='a'&&a[k]<='z')
                                s++;
                        }
                        i=j;  //i的位置变成j的位置，因为i~j这段区间已经查找一遍了，
                        break;
                    }
                }
        printf("%d\n",s);
    }
    return 0;
}

H - WY的数根
中等偏下题，将一个数字每一位加起来得到一个新的数字，若新数字位数为1，输出，否则重复操作（题目有错，N的范围大于1000）。
可用九余数法，或者手动模拟。
九余数法：将所有位数字加起来，对九取余，若大于0，直接输出，否则输出9（因为n>0）。
手动模拟：将所有位加起来，若大于9，则重新将得到值的所有位加起来，重复操作，直到得到的值<=9。

#include<stdio.h>
#include<string.h>
int main()
{
    int nn;
    scanf("%d",&nn);
    while(nn--)
    {
        int n,m;
        scanf("%d",&n);
        while(n>=10)  //当n大于等于10，执行这个循环
        {
            m=0;   
            while(n!=0)
                m+=n%10,n/=10;  //求出n的各位数字和
            n=m;  //令n=m，
        }
        printf("%d\n",n);
    }
    return 0;
}

I - 今年双11不AC
难题，给定n行数据，每行两个数字为第i个节目的开始，结束时间，输出能完整看到的最多的节目。
和算法竞赛入门经典（小白书）P152 8.4.4选择不相交区间类似。

#include<stdio.h>
#include<string.h>
struct stu
{
    int x,y;
} a[110],tempstu;
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int i,j,maxi;
        for(i=1; i<=n; i++)
            scanf("%d%d",&a[i].x,&a[i].y);
        for(i=1; i<n; i++)
            for(j=1; j<n-i+1; j++)
                if(a[j].y>a[j+1].y)
                    tempstu=a[j],a[j]=a[j+1],a[j+1]=tempstu;   //冒泡对结束时间排序，注意交换的是结构体
        int ans=1,temp=a[1].y;
        for(i=2; i<=n; i++)
        {
            if(a[i].x>=temp)
                temp=a[i].y,ans++;  //小白书P152  8.4.4
        }
        printf("%d\n",ans);
    }
    return 0;
}

J - 赤裸裸的签到题

输入一个<=1000位的数字，输出这个数字。
标准的签到题，因为数字过大，超过了19位，不能用int,以及long long，所以可以当成字符串输入输出即可。

#include<stdio.h>
char a[1010];
int main()
{
    int nn;
    scanf("%d",&nn);
    while(nn--)
    {
        scanf("%s",a);   //输入输出字符串
        printf("%s\n",a);
    }
    return 0;
}

K - 上善若水

坑题，输入一个不超过18446744073709551615的正整数a，输出a+2。

18446744073709551615是unsigned long long 可取的最大值，因此可以特判一下，定义一个unsigned long long类型的a,若输入的a==18446744073709551614 输出18446744073709551616，否则如果a==18446744073709551615，输出18446744073709551617，否则以%llu形式输出a+2;

#include<stdio.h>
int main()
{
    unsigned long long n;
    scanf("%llu",&n);   //无符号长整型 输入格式 %llu 
    if(n==18446744073709551615)
        printf("18446744073709551617\n");
    else if(n==18446744073709551614)
        printf("18446744073709551616\n");
    else
        printf("%llu\n",n+2);
    return 0;
}

黑色的夢

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
南阳理工学院软件、计科16级新生联合月赛（10月）

//如果发现错误，请联系QQ：528859519。 A：矩阵相乘。签到题，题目很容易理解，多组数据，两个n*n的矩阵的相乘，相乘的定义是：a[i][j]*b[i][j]=c[i][j]。即两层for循环遍历i,j,使得c[i][j]=a[i][j]*b[i][j]，不过需要留意一下，输出矩阵的每一个数字后面都有空格。#include<stdio.h>int a[11][11],b[11]
复制链接

扫一扫