2015 年 JXNU_ACS 算法组寒假第一次周赛 作答总结

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/KevinWu93/article/details/43115979

<span style="font-family: 'Times New Roman', Times, serif; background-color: rgb(255, 255, 255);">2015 年 JXNU_ACS 算法组寒假第一次周赛</span>

也把它当蓝桥之路第一次训练赛了，做了4道题，两道Wrong Answer，一道Stack Overflow，一道Runtime Error，真是累觉不爱，把写的都贴在这里吧，以后说不定哪天就发现哪里有问题了。

1001 A+B

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 48   Accepted Submission(s) : 0

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

整数版的A+B做多了，难免会对其产生厌倦心理，今天我们来尝试下更有趣的分数A+B吧。令A=a/b,B=c/d;求A+B，并以最简分数形式输出结果,最简分数就是分子和分母不能有大于1的公因数的分数。例如给定2/4不是最简分数，因为它们有公因子2，而1/2就是最简分数了，因为它们没有大于1的公因子。

Input

第一行有一个正整数t，表示有t组测试数据。
每组测试数据有四个正整数,a,b,c,d，它们分别用空格隔开。这四个正整数每个的取值范围都是[1,10^50]。

Output

以最简分数的形式输出A+B的结果，每个结果占一行。

Sample Input

3
1 1 1 1
1 2 1 3
2 4 3 6

Sample Output

2/1
5/6
1/1

我写的答案：

#include <stdio.h>
int main()
{
    int t,a,b,c,d,suma,sumb,yue1,yue2,temp;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d%d",&a,&b,&c,&d);
        if(a>=1&&b>=1&&c>=1&&d>=1)
        {
            suma=a*d+b*c;
            sumb=b*d;
            yue1=suma>sumb?suma:sumb;
            yue2=suma<=sumb?suma:sumb;
            while(yue1%yue2)
            {
                temp=yue2;
                yue2=yue1%yue2;
                yue1=temp;
            }
            printf("%d/%d\n",suma/yue2,sumb/yue2);
        }
    }
    return 0;
}

1002 稳定的排序

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 91   Accepted Submission(s) : 15

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

我们知道，排序算法有很多种，不仅每种排序算法的复杂度不一样，而且每种排序算法的稳定性也不一定。稳定排序是指：待排序的记录序列中可能存在两个或两个以上关键字相等的记录。排序前的序列中Ri领先于Rj（即i<j）.若在排序后的序列中Ri仍然领先于Rj，则称所用的方法是稳定的。否则是不稳定的。现给出一些字符串和其对应的权值。现要求依据权值升序排序，请你写一个程序输出稳定的排序结果。
例如：给定字符串和其对应的权值是：
abc 2
kdwycz 2
MummyDing 1
这里的权值即为关键字，由于abc和kdwycz对应的权值是相等的，但是排序前，abc排在kdwycz前面，那么排序后的abc也应该排在kdwycz的前面。
故稳定的排序结果为：
MummyDing 1
abc 2
kdwycz 2
而结果：
MummyDing 1
kdwycz 2
abc 2
虽然满足按权值升序排序的要求，但是其排序结果是不稳定的。

Input

第一行是一个整数t表示有t组测试数据。
每组测试数据的第一行是一个整数n(n<=10^5)。
接下来有n行排序前的数据。
每行包含一个字符串s和一个权值w，以空格隔开。s的长度小于等于10,w的范围是[1,2^31-1]。

Output

输出稳定排序后的结果。
每组测试数据对应的输出结果包括n行。
每行输出一个字符串和其对应的权值，它们之间以一个空格隔开。

Sample Input

1
3
abc 2
kdwycz 2
MummyDing 1

Sample Output

MummyDing 1
abc 2
kdwycz 2

我写的代码：

#include <stdio.h>
#define MAXSIZE 100000
typedef struct
{
    char data[10];
    int quan;
} b;
int main()
{
    b a[100];
    int t,n,i,j;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        if(n<=MAXSIZE)
        {
            for(i=0; i<n; i++){
                scanf("%s %d",&a[i].data,&a[i].quan);
            }
            for(i=0; i<n-1; i++){
            		for(j=i+1;j<=n-1;j++)
                if(a[i].quan>a[j].quan)
                {
                    a[n]=a[i];
                    a[i]=a[j];
                    a[j]=a[n];
                }
				printf("%s %d\n",a[i].data,a[i].quan);
            }
            printf("%s %d\n",a[i].data,a[i].quan);
        }
    }
    return 0;
}

1006 惩奸除恶

Time Limit : 4000/2000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 58   Accepted Submission(s) : 3

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

有一个皇帝准备处决一批奸臣和小人，但是一起处决太没劲了，有一个大臣建议边玩游戏，边处决。这个游戏是：将这N个人坏人围成一圈顺序编号，从1号开始按1、2、3......顺序报数，报p者退出则立即处决，其余的人从被处决的下一个开始再从1、2、3开始报数，报p的人也立即处决，以此类推。请按处决顺序输出每个被处决的人的原序号。

Input

第一行是正整数t代表有t组测试数据。
每组测试数据包括一个整数N(1<=N<=1000)及一个整数p(1<=p<=1000)。

Output

对于每一组数据，
按处决顺序输出每个被处决的人的原序号，每两个序号之间以一个空格隔开。

Sample Input

1
7 3

Sample Output

3 6 2 7 5 1 4

我写的代码：

#include <stdio.h>
#include<stdlib.h>

typedef struct node
{
    int a;
    struct node *next;
} L;
int main()
{
    L *l,*head,*tail,*pt;
    int T,n,p,i,j;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&p);
        if(n<=1000)
        {
            for(i=1; i<=n; i++)
            {
                if(i==1)
                {
                    tail=(L*)malloc(sizeof(L));
                    tail->a=i;
                    tail->next=head;
                    head=tail;
                }
                else
                {
                    l=(L*)malloc(sizeof(L));
                    l->a=i;
                    l->next=head;
                    tail->next=l;
                    tail=l;
                }
            }
            pt=head;
            i=1;
            while(pt->next!=pt)
            {
                i++;
                tail=pt->next;
                if(i==p)
                {
                    printf("%d ",tail->a);
                    pt->next=tail->next;
                    free(tail);
                    i=1;
                }
                pt=pt->next;
            }
            printf("%d ",pt->a);
        }
    }
    return 0;
}

汉诺塔问题

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 90   Accepted Submission(s) : 16

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
不过现在有2*n个圆盘，柱子还是三根，圆盘有n种不同的尺寸，每一种尺寸的圆盘有两个，如通常那样，在第一根柱子上从下往上按照大小顺序摞着2*n个圆盘。要求每次只能移动一个圆盘，且不能把较大的圆盘放在较小的上面，显然，圆盘可以放在同样大的圆盘上面。如果相同尺寸的圆盘是相互不可区分的，要把一个双重塔从第一根桩柱移动到第三根桩柱最少需要移动多少次？如下图，为n=3时，即第一根柱子上有2*3个圆盘的初始状态。本图片由小KD友情提供！

Input

第一行是一个整数T，表示有T组测试数据
每组测试数据有一个正整数n(1<=n<=60)，表示有2*n个圆盘。

Output

对于每组输入数据，输出最少要移动的次数。

Sample Input

2
1
2

Sample Output

2
6

我写的代码：

#include<stdio.h>

int main()
{
    double j;
    int n,i,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        if(n>=1&&n<=60)
                for(i=1,j=1; i<n; i++)
                    j=j*2+1;
        printf("%0.0lf\n",2*j);
    }
    return 0;
}