一些简单的acm题

 

【人民币问题】

 

Time Limit:1000MS  Memory Limit:10000K

Total Submit:574 Accepted:278

 

Description

 

给出任意的人民币(>10元)的整币兑换成5元、2元和1元币值（要求三种币值均有）的方法有多少种。

 

Input

 

输入任意的人民币(>10元)的整币100,50,20,10

 

Output

 

计算出兑换成5元、2元和1元币值（要求三种币值均有）的方法有多少种

 

Sample Input

 

 

50

Sample Output

 

 

106

Source

 

 

 

 

 

【哥德巴赫曾猜测】

 

Time Limit:10000MS  Memory Limit:65536K

Total Submit:592 Accepted:194

 

Description

 

德国数学家哥德巴赫曾猜测：任何大于6的偶数都可以分解成两个素数（素数对）的和。但有些偶数可以分解成多种素数对的和，如： 10=3+7，10=5+5，即10可以分解成两种不同的素数对。

 

Input

输入任意的>6的正偶数(<32767)

 

Output

 

试求给出的偶数可以分解成多少种不同的素数对（注：A+B与B+A认为是相同素数对）

 

Sample Input

 

 

1234

Sample Output

 

 

25

Source

Code:

#include

#include

using namespace std;

int main()

{int n;int z=0;

int f(int);

cin>>n;

for(int i=2;i<=n/2;i++)

{

if(f(i)) {if(f(n-i))

{// cout<

z+=1;

}

}

}

cout<

cout<

return 0;

}

int f(int y)

{int j;

for( j=2;j<=sqrt(y);j++)

if(y%j==0) break;

if(j<=sqrt(y))

return 0;

else

return y;

}

 

 

 

【数列问题】

 

Time Limit:10000MS  Memory Limit:65536K

Total Submit:647 Accepted:312

 

Description

 

已知一个数列的前3个数为3，4，5，以后每个数为前3个数的和，编程序求此数列的第N项

 

Input

 

输入N(N<=35)

 

Output

 

求出第N项的值

 

Sample Input

 

 

28

Sample Output

 

 

25527448

Source

 

代码 ：

#include

void main()

{int a[35]={3,4,5};

int n,i;

scanf(“%d”,&n);

for(i=3;i<=n;i++)

a[i]=a[i-1]+a[i-2]+a[i-3];

printf(“%d\n”,a[n-1]);

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

【敲七】

 

Time Limit:10000MS  Memory Limit:65536K

Total Submit:502 Accepted:170

 

Description

 

输出7和7的倍数，还有包含7的数字例如（17，27，37...70，71，72，73...）

 

 

Input

 

一个整数N。(N不大于30000)

 

 

Output

 

统计出不大于N的与7有关的数字的个数。如20以内与7有关的数为7、14、17共3个。

 

 

Sample Input

 

 

20

 

Sample Output

 

 

3

 

Source

 

 

 

 

 

 

 

/*验证哥德巴赫猜想：任一充分大的偶数，可以用两个素数之和表示，例如：

4 = 2 + 2      6 = 3 + 3      ……      98 = 19 + 79。

程序要求：键盘输入一个偶数x>4，找到两个素数a、b，满足 x=a+b。最后输出此等式

提示

我们先不考虑怎样判断一个数是否为素数，而从整体上对这个问题进行考虑，可以这样做：读入一个偶数n ，将它分成p 和q ，使n = p + q 。怎样分呢？可以令p 从2 开始，每次加1 ，而令q = n -p ，如果p 、q 均为素数，则正为所求，否则令p = p + 1 再试。

其基本算法如下：

1）读入大于3的偶数n。

2）P=1

3）do{

4）p=p+1；q=n-p;

5）p是素数吗？

6）q是素数吗？

7）}while(p、q有一个不是素数)

8）输出n=p+q。

为了判明p、q是否是素数，我们设置两个标志量flagp和flagq，初始值为0，若p是素数，令flagp=1，若q是素数，令flagq=1，于是第7步变成：

7）}while(flagp*flagq==0);

再来分析第5、第6步，怎样判断一个数是不是素数呢？

素数就是除了1和它自身外，不能被任何数整除的整数，由定义可知：

2、3、5、7、11、13、17、19等是素数；

1、4、6、8、9、10、12、14等不是素数。

要判断i是否是素数，最简单的办法是用2、3、4、……i-1这些数依次去除i，看能否除尽，若能被其中之一除尽，则i不是素数，反之，i是素数。其实，没必要用那么多的数去除，实际上，用反证法很容易证明，如果不大于i的平方根的数都不能整除，则i必是素数。于是，上述算法中的第5步、第6步可以细化为：第5）步p是素数吗？

flagp=1;

for(j=2;j<=[sqrt(p)];j++)

if  p除以j的余数==0

{flagp=0;

break;}

第6）步q是素数吗？

flagq=1;

for(j=2;j<=[sqrt(q)];j++)

if  q除以j的余数==0

{flagq=0;

break;} */

 

#include

#include

void main()

{int s=0,n,i;

int f(int);

scanf("%d",&n);

for(i=1;i<=n/2;i++)

if(f(i)+f(n-i)==2)

s+=1;

printf("%d\n",s);

}

 

int f(int b)

{ int a,c;

for(a=2;a<=sqrt(b);a++)

if(b%a==0)break;

if(a>sqrt(b))

c=1;

else  c=0;

return c;

}

 

 

 

【倒杨辉三角形】

Time Limit:1000MSMemory Limit:65536K
Total Submit:178 Accepted:13

Description

Fans喜欢图形，而且喜欢把图形倒过来欣赏。有一次，他看见杨辉三角形了，觉得很新鲜，于是就把它们大大小小地摆布出来。输入一些整数n（1≤n≤10），读入其每个整数，以该整数为行数，其画出来的倒杨辉三角形（每个数据占三个字符）就是fans所喜欢欣赏的。Fans是手工做的，你却可以用编程更快捷地做出来，多爽啊!

Input

 

Output

 

Sample Input

5

3

Sample Output

  1    4     6     4    1

     1    3     3     1

        1    2     1

           1    1

              1

 

  1    2     1

     1    1

        1

Source

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

【大小写转换】

TimeLimit:10000MS Memory Limit:65536K
Total Submit:341 Accepted:154

Description

读入一些字符串，将其中的小写字母转成大写字母（其他字符不变）。

Input

输入为多行，每行为一个字符串，字符串只由字母和数字组成，长度不超过80。输入以“End of file”结束。

Output

对于每行输入，输出转换后的字符串。

Sample Input

Hello

ICPC2004

12345abcde

Sample Output

HELLO

ICPC2004

12345ABCDE

 

 

Source

 

Codes:

#include

#include

using namespace std;

int main()

{

char a;

while((a=getchar())!=EOF)

{if(a>='a'&&a<='z')printf("%c",a-('a'-'A'));

 

else printf("%c",a);

   

}

return 0;

 

}

 

 

 

 

 

 

 

 

 

 

 

最大子矩阵

Time Limit:1000MSMemory Limit:65536K
Total Submit:7 Accepted:7

Description

已知矩阵的大小定义为矩阵中所有元素的和。给定一个矩阵，你的任务是找到最大的非空(大小至少是1 * 1)子矩阵。

 比如，如下4 * 4的矩阵

 0 -2 -7 0
 9 2 -6 2
 -4 1 -4 1
 -1 8 0 -2

 的最大子矩阵是

 9 2
 -4 1
 -1 8

 这个子矩阵的大小是15。

Input

输入部分第一行是一个正整数N,说明矩阵的大小。下一行后面跟着n*n个整数。留意这些整数的输入格式可能比较混乱。矩阵是以行优先存储的。
 N可能等于100，矩阵中每个数字的范围为[-127, 127].

Output

输出最大子矩阵的大小。

Sample Input

4

0 -2-7 0 9 2 -6 2

-4 1-4  1 -1

 

8  0 -2

Sample Output

15

Hint

翻译自 Greater New York 2001 的试题

Source

xinyue

 

 

 

 

【练习试题】:全排列

Time Limit:1000MSMemory Limit:65536K
Total Submit:27 Accepted:10

Description

编程列举出1、2、…、n的全排列，要求产生的任一个数字序列中不允许出现重复的数字

Input

输入n(1<=n<=9)

Output

有1到n组成的所有不重复数字的序列，每行一个序列

Sample Input

3

Sample Output

1 23

1 32

2 13

2 31

3 12

3 21

Source

xinyue

 

 

 

 

 

【母牛生小牛】

Time Limit:10000MS Memory Limit:65536K
Total Submit:525 Accepted:196

Description

设有一头小母牛，从出生第四年起每年生一头小母牛，按此规律，第N年时有几头母牛？

Input

输入一个整数N。(1≤N≤50)

Output

第N年时母牛的数量

SampleInput

5

SampleOutput

3

 

 

 

 

对n个数的排序：(从小到大)

#include

using namespace std;

int main ()

{int n,temp;

cin>>n;

int  i,j,k;

int *p=new(int[n]);

for(i=0;i

scanf("%d",&p[i]);

for(i=0;i

for(j=0;j

if(p[j]>p[j+1])

{temp=p[j];

p[j]=p[j+1];

p[j+1]=temp;

}

for(k=0;k

printf("%d ",p[k]);

cout<

delete []p;

return 0;

}

 

 

 

输入一个整数，求出各位上的数字的乘积

方法一：

#include

using namespace std;

int main()

{ int n,s=1;

cin>>n;

while(n)

{s*=n%10;n/=10;

}

cout<

}

 

 

1. 基本思想：冒泡排序（BubbleSort）（稳定排序）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
2. 选择排序（Selection Sort）（不稳定排序）
   　　初始关键字 [49 38 65 97 76 13 27 49]
   49与38比较，49>38；38与65比，38<65；38继续跟97比，38<97；38跟76比，3813；13跟27比，13<27；13跟49比，13<49；至此得到13最小。所以将13与第一个数字交换位置。即可得到第一躺排序后的序列。
   　　第一趟排序后 13 ［38 65 97 76 49 27 49]
   　　第二趟排序后 13 27 ［65 97 76 49 38 49]
   　　第三趟排序后 13 27 38 [97 76 49 65 49]
   　　第四趟排序后 13 27 38 49 [76 97 65 49 ]
   　　第五趟排序后 13 27 38 49 49 [97 65 76]
   　　第六趟排序后 13 27 38 49 49 65 [97 76]
   　　第七趟排序后 13 27 38 49 49 65 76 [97]
   　　最后排序结果 13 27 38 49 49 65 76 97
3. 鸡尾酒排序法（shaker sort）（稳定排序）：假设有待排序数组[20, 37, 50, 35, 10, 1]，可知整个排序过程共分3个阶段。首先进行第一阶段的从左向右遍历，整数对(20,37)被比较，不进行交换操作。接下来比较整数对(37,50)，它们也不进行交换。然后比较整数对(50, 35)，由于它们处于非正常顺序，因此产生交换，得到新数组[20, 37, 35, 50, 10, 1]。当50和10被比较时，通过一个交换得到新数组[20, 37, 35, 10, 50, 1]。最后比较整数对(50,1)，在一个交换之后，第一阶段的自左向右遍历结束，并得到新数组[20, 37, 35, 10, 1, 50]。现在进行第一阶段的自右向左遍历。首先比较整数对(10,1)，并做一次交换，得到新数组[20, 37, 35, 1, 10, 50]。然后比较整数对(35,1)，进行一次交换后得到新数组[20, 37, 1, 35, 10, 50]。如此继续下去最终在第一阶段的自右向左遍历结束后得到新数组[1, 20, 37, 35, 10, 50]。第一阶段完毕后，最大和最小的元素已经分别得到，排除掉它们得到数组[20, 37, 35, 10]，在这个数组上进行第二阶段操作。在完成自左向右遍历后，得到[20, 35, 10, 37]。接下来再进行自右向左遍历得到[10, 20, 35, 37]。同样排除掉两头的元素，因此第三阶段的操作将在[20, 35]上进行。
4. 插入排序法（Insertion sort）（稳定排序）：直接插入排序（Straight Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。
   把a[i]插入到a[0]，a[1]，…,a[i-1]之中的具体实施过程为:先把a[i]赋值给变量t,然后将t依次与a[i-1],a[i-2],…进行比较,将比t大的元素右移一个位置,直到发现某个j(0<=j<=i-1),使得a[j]<=t或j为(-1),把t赋值给a[j+1].
5. 希尔排序（shell sort）（不稳定排序）：希尔排序（Shell Sort）又称为“缩小增量排序”。是1959年由D.L.Shell提出来的。该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。
   举例说明：
   初始:
   503,17,512,908,170,897,275,653,426,154,509,612,677,765,703,94
   第1趟d1=8）426,17,509,612,170,765,275,94,503,154,512,908,677,897,703,653
   第一趟步长是8,一共有十六个数，所以将这十六个数分成8组，即第一个和第九个一组，第二个和第十个一组，以此类推。每组两个元素进行直接插入排序。即可得第一次排序结果。
   第2趟d2=4)170,17,275,94,426,154,509,612,503,765,512,653,677,897,703,908
   第二趟排序步长是4,也就是第一个和第五个、第九个、第十三个一组，第二个和第六个、第十个、第十四个一组，以此类推。每组在做直接插入排序即可得第二趟排序结果。
   第3趟d3=2):170,17,275,94,426,154,503,612,509,653,512,765,677,897,703,908
   第三趟重复第二趟的步骤。
   第4趟d1=1):17,94,154,170,275,426,503,509,512,612,653,677,703,765,897,908
   当最后步长为1时，对整个序列进行依次直接插入排序即可。

主要参考了这个关于数据结构的网站：不错的数据结构网站