【人民币问题】
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<iostream>
#include<math.h>
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<<i<<"+"<<n-i<<endl;
z+=1;
}
}
}
cout<<z;
cout<<endl;
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<stdio.h>
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<stdio.h>
#include<math.h>
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<iostream>
#include<string>
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<iostream>
using namespace std;
int main ()
{int n,temp;
cin>>n;
int i,j,k;
int *p=new(int[n]);
for(i=0;i<n;i++)
scanf("%d",&p[i]);
for(i=0;i<n-1;i++)
for(j=0;j<n-1-i;j++)
if(p[j]>p[j+1])
{temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
for(k=0;k<n;k++)
printf("%d ",p[k]);
cout<<endl;
delete []p;
return 0;
}
输入一个整数，求出各位上的数字的乘积
方法一：
#include<iostream>
using namespace std;
int main()
{ int n,s=1;
cin>>n;
while(n)
{s*=n%10;n/=10;
}
cout<<s;
}
- 基本思想：冒泡排序（BubbleSort）（稳定排序）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第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 - 鸡尾酒排序法（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]上进行。
- 插入排序法（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]. - 希尔排序（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时，对整个序列进行依次直接插入排序即可。
主要参考了这个关于数据结构的网站：不错的数据结构网站
2647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
