acm算法经典例题

一、数论

1: Wolf and Rabbit

描述

There is a hill with n holes around. The holes are signed from 0 to n-1.

A rabbit must hide in one of the holes. A wolf searches the rabbit in anticlockwise order. The first hole he get into is the one signed with 0. Then he will get into the hole every m holes. For example, m=2 and n=6, the wolf will get into the holes which are signed 0,2,4,0. If the rabbit hides in the hole which signed 1,3 or 5, she will survive. So we call these holes the safe holes.

输入

The input starts with a positive integer P which indicates the number of test cases. Then on the following P lines,each line consists 2 positive integer m and n(0

输出

For each input m n, if safe holes exist, you should output "YES", else output "NO" in a single line.

样例输入

2

1 2

2 2

样例输出

NO

YES

翻译：

描述

一座山有n个洞，洞被标记为从0到n-1。兔子必须藏在一个洞中。狼会逆时针方向搜索兔子。狼一开始在洞0，然后他会每m个洞进去一次。例如：m=2，n=6，狼就会依次进入洞0 2 4 0。如果兔子藏在1 3 5就安全。

输入

第一行一个数字p，表示下面有p组测试数据，每组测试数据2个数m n(0

输出

每组数据输出一行，如果存在安全洞穴，输出"YES"，否则输出"NO"

思路/方法：你是不是觉得总是无法通过，看看下面的解析

假设有n=6个洞 0 1 2 3 4 5

当m=4时，狼进的洞是0 4 2 0，也就是形成了一个循环，永远也到不了其他洞穴

当m=5时，狼进的洞是0 5 4 3 2 1 0，这时所有的洞都遍历了一遍。

思考：当m=4和m=5时，到底有什么区别？

当n和m有公约数(非1)时，就会形成一个数字个数小于n的循环

当n和m无公约数时，就会形成一个数字个数为n的循环，此时没有安全洞穴。

解题关键：这题就转化成了判断两个数是否有公约数。

代码：

#include

using namespace std;

long long greatestCommonDivisor(long long a, long long b)//最大公约数

{

long long t;

while(b)

{

return a;

}

int main()

{

int i, p;

long long m, n;

cin >> p;

for(i = 0; i < p; i++)

{

cin >> m >> n;

if(greatestCommonDivisor(m, n) == 1)//公约数为1说明互斥，没有安全洞穴

cout << "NO\n";

else

cout << "YES\n";

}

return 0;

}

2: a^b

描述

给定a和b，输出a^b的最后一个数字。

输入

输入数据有多组，每组数据占一行，每行为a和b的值（0

输出

对每组输入数据，输出a^b的最后一位数字，每组数据占一行。

样例输入

2 2

3 4

样例输出

4

1

思路/方法：如果你模拟a^b次肯定会超时，而且数字还会超出Int范围

题目说只要最后一个数字，回想一下小学时学的乘法过程，貌似乘数最后一位和前面的无关

我们大胆的尝试一下用a的个位代替a，然后我们发现循环b次还是会超时，这是我们要想办法减少循环的次数，试一下是不是有周期规律

这时我们来列举一下2的n次方的个位：2 4 8 6 2 4 8 6

我们发现周期为4，我们在试试1-9的n次方，发现周期都是4，所以，我们可以用b%4代替b，需要注意的是，当b%4==0时，我们需要给他加上4，不然就不循环了。

代码：

#include

int main()

{

int a, b, i, t;

while(scanf("%d %d", &a, &b) != EOF)

{

b = b % 4;

for(i = 0; i < b; i++)

{

t = t * a;

t = t % 10;

}

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

}

return 0;

}

3: 筛选法求素数

描述

请使用筛选法输出[a, b]之间的所有素数。

输入

输入数据有多组，每组数据占一行，每行2个正整数a和b，其中2<=a<=b<=1000000。

输出

每组数据按从小到大的顺序输出[a, b]中所有的素数，每行最多输出10个素数。每组数据之后空一行。

样例输入

2 3

2 50

样例输出

2 3

2 3 5 7 11 13 17 19 23 29

31 37 41 43 47

思路/方法：这题测试的数据量很大，所以尽量少循环，尽量少判断，要非常精简才能通过。

1.定义一个全局变量short s[1000001];//全局变量默认为0

2.把数组中下标为奇数的值改为1，偶数不用改，因为除了2，其他偶数都不是素数

s[2] = 1;//2也是素数

for(i = 3; i < 1000001; i = i + 2)//把奇数全部假设为素数

s[i] = 1;

3.把素数的倍数挖掉，改为0。(从2开始到根号1000000之间的素数的倍数挖掉)

for(i = 2; i < 1000; i++)//小于根号1000000

if(s[i])//判断是否为素数，只有素数的倍数才挖掉

for(j = i * 2; j < 1000001; j = j + i)//把i的倍数的值改成0

s[j] = 0;

4.最后一点是输出格式，每组之间一个空行，另外一行最多10个。定义一个变量来记录输出了多少个，达到十个就输出换行。具体看代码。

代码：

#include

short s[1000001];//全局变量默认为0

int main()

{

int t, a, b, i, j;

s[2] = 1;//2也是素数

for(i = 3; i < 1000001; i = i + 2)//把奇数全部假设为素数

s[j] = 0;

while(scanf("%d %d", &a, &b) != EOF)

{

t = 0;

for(i = a; i <= b; i++)

{

if(s[i])//素数就输出

{

if(t)

if(t == 10)

{

printf("\n");

t = 0;

}

else

printf(" ");

t++;

printf("%d", i);

}

}

printf("\n\n");

}

return 0;

}

4: The ones to remain

描述

There are N soldiers standing in one line. They are marked from 1 to N, from right to left. And they are given a number m. Then the soldiers numbered off, straight from the right-hand man. The one who reported a number that is the multiple of m was kept in the line. Others have to leave the line. They continue doing this till the number of people in the line is less than m. For example, if there are 10 soldiers, and m = 3. For the first time the soldiers who are marked 3, 6, 9 remain in the line. For the second time the soldier who is marked 9 remains in the line. Because the number of soldiers in the line is less than m, so the soldier marked 9 was the only one to remain in the line.

Now we want to know who will be the ones to remain, can you tell us ?

输入

There are several test cases in the input. Each test cases is only one line, contains two integers n and m.(3 <= n <= 109, 2 <= m <= n). The input ends when n = 0 and m = 0.

输出

For each test case, output two lines. The first line contains one integer x, the number of soldiers to remain. The second line contains x integers, the numbers marked on the soldiers who remain in the line. You should output them in increasing order.

样例输入

10 3

8 3

0 0

样例输出

1

9

有N个士兵站在一行。他们被从右到左标记为1到N。他们被给与了一个数字m。然后士兵直接从右面报数。报的数是m的倍数的留下来，其他人离开。然后继续上述操作，直到人数少于m。例如，有10个士兵，m=3。第一次士兵报数为3 6 9的留下，第二次士兵报数为9的留下。

输入

有多组测试数据。每组一行两个数n m(3 <= n <= 109, 2 <= m <= n)，以0 0结束

输出

每组输出两行，第一行输出一个x表示留下来的士兵数量，第二行输出x个留下来的士兵的编号。

思路/方法：

这题用数组来存储士兵状态就会超时，所以我们需要更精简的算法，很明显可以看出这是道数学题，所以我们多举几个例子，看看是否有规律。

m=2时

1 2

2

1 2 3

2

1 2 3 4

2 4

4

1 2 3 4 5 6

2 4 6

4

1 2 3 4 5 6 7 8

2 4 6 8

4 8

8

m=3时

1 2 3

3

1 2 3 4

3

1 2 3 4 5 6

3 6

1 2 3 4 5 6 7 8 9

3 6 9

9

由上面的几个例子可以看出关键是找到一个不大于n的最大的m^x。比如m=2的时候，依次是2^1 2^1 2^2 2^2 2^3，当x一样时，他们的结果值一样，并且就是m^x。

如上，当m=4时，只有m^1不大于n，所以结果第一个数为4，然后后面有8 12为4的倍数，且不大于n，所以得到3个结果，和例子的结果一致。

这样就成功推出了解题方法，虽然不严谨，但作为一般人，能做出来就行了。

代码：

#include

using namespace std;

int main()

{

long long m, n, remain, id, j;//id表示下标，j表示当前第几个报数

while(cin >> n >> m, !(n == 0 && m == 0))

{

//得到不大于n的 m^x 的值

j = 1;

for(id = 1;; id++)

{

j = j * m;

if(j * m > n)

break;

}

remain = 0;

for(id = 1;;id++)

{

if(j * id <= n)//得到不大于n的 m的倍数的个数

remain++;

else

break;

}

cout << remain << endl;

for(id = 1; id < remain; id++)

cout << id * j << " ";

cout << id * j << endl;

}

return 0;

}

5: 小数化分数

描述

Ray 在数学课上听老师说，任何小数都能表示成分数的形式，他开始了化了起来，很快他就完成了，但他又想到一个问题，如何把一个循环小数化成分数呢?

请你写一个程序不但可以将普通小数化成最简分数，也可以把循环小数化成最简分数。

输入

第一行是一个整数N，表示有多少组数据。

每组数据只有一个纯小数，也就是整数部分为0。小数的位数不超过9位，循环部分用()括起来。

输出

0.32(692307)

样例输出

4/9

1/2

17/52

思路/方法：这题需要有个数学转化方法，小编看了别人的纯循环小数转分数的方法，然后又花了点时间推出了非纯循环小数转分数方法，下面分享一下。

1.有限小数：

分子分母乘以10的次方，使得没有小数位，然后分子分母分别除以最大公约数就化简完成。比如0.4，就是0.4*10/10，最大公约数为2，化简后就是2/5

2.纯循环小数

乘以10的次方使得循环部分没有小数位，然后用该数-原数=整数部分。

所以分数形式=循环节/9...9(9的个数等于循环节数字个数)

例如：0.44..，0.444..*10-0.444..=4。所以(10-1)*0.44..=4。0.44..=4/9。

3.非纯循环小数

乘以10的次方使得循环部分没有小数位记为a*10^x，乘以10的次方使得非循环部分没有小数记为a*10^y，则a*10^x-a*10^y就消去了后面的小数。比如：0.2433..*1000-0.243..*100=243-24，所以0.243..=(243-23)/(1000-100)，然后总结之后得出下面的结论。不循环部分和循环节构成的的数减去不循环部分的差,再除以循环节位数个9，添上不循环部分的位数个0。比如：

0.24333333…………=(243-24)/900=73/300

0.9545454…………=(954-9)/990=945/990=21/22

方法有了，代码也容易写，但小编做的时候犯了一个错误，把循环部分和非循环部分全都当成整数来接受，导致丢失了位数，使得分母不准确了。比如0.001(02)这样的，当成整数接受，非循环部分是1，算长度的时候直接算就是1，循环部分接受后变成2，算长度是1，导致分母变成了90，而实际上是99000。所以必须用字符串来存储，具体看代码了。

代码：

#include

#include

long long greatestCommonDivisor(long long a, long long b)

{

long long t;

while(b)

{

t = a % b;

a = b;

b = t;

}

return a;

}

int main()

{

int i, n, j, k;

long long denominator, numerator, divisor, cyclical, nonCyclical;//分母分子,非循环部分和循环部分

char a[20], nonCyclicalString[20], cyclicalString[20];//必须用文本，否则会丢失位数，比如0.001010这样的会把0丢了 scanf("%d ", &n);

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

{

if(a[0] == '(')//如果是纯循环小数

{

sscanf(a, "(%s", cyclicalString);//只能这样读取，把括号补充完整也一样的结果

cyclicalString[strlen(cyclicalString) - 1] = '\0';//手动删除后面的括号。读取到了循环部分 sscanf(cyclicalString ,"%I64d", &cyclical);

nonCyclicalString[0] = '\0';

numerator = cyclical;//分子就等于循环节

}

else

{

for(j = 0; a[j] != '('; j++)//读取到(就停止。读取非循环部分

nonCyclicalString[j] = a[j];

nonCyclicalString[j] = '\0';

for(k = 0, j = j + 1; a[j] != ')'; j++, k++)//从(右边一个开始读取到)就停止。读取循环部分 cyclicalString[k] = a[j];

cyclicalString[k] = '\0';

sscanf(nonCyclicalString, "%I64d", &nonCyclical);//把非循环部分的值放入到变量中

sscanf(cyclicalString, "%I64d", &cyclical);//把循环部分的值放入到变量中

numerator = nonCyclical;//把分子的值先变成非循环部分

for(j = 0; cyclicalString[j] != '\0'; j++)//往分子尾部加入循环节部分

{

numerator = numerator * 10 + (cyclicalString[j] - '0');

}

numerator = numerator - nonCyclical;//非循环部分和循环部分的组合 - 非循环部分

}

//计算分母

denominator = 0;

for(j = 0; cyclicalString[j] != '\0'; j++)//加上循环节个数个9

denominator = denominator * 10 + 9;

for(j = 0; nonCyclicalString[j] != '\0'; j++)//加上非循环部分个0

denominator = denominator * 10;

divisor = greatestCommonDivisor(numerator, denominator);

printf("%I64d/%I64d\n", numerator / divisor, denominator / divisor);

}

else//非循环小数

{

sscanf(a, "%I64d", &numerator);//把小数部分存到变量中

denominator = 1;

for(j = 0; a[j] != '\0'; j++)//计算分母

denominator = denominator * 10;

divisor = greatestCommonDivisor(numerator, denominator);

printf("%I64d/%I64d\n", numerator / divisor, denominator / divisor);

}

}

return 0;

}

输入

测试数据有多组，第一行是整数t（0

输出

按递增的顺序输出序列的全排列。每个测试数据后面输出一个空行。

样例输入

1

3

1 3 5

样例输出

1 3 5

1 5 3

3 1 5

3 5 1

5 1 3

5 3 1

思路/方法：全排列有递归和非递归算法，具体网上有，这里我们为了代码简洁，采用STL里面的函数来实现，容易理解，而且好写。首先引用algorithm这个库，然后里面有sort排序函数和next_permutation下一个排列函数。

sort升序排序，参数分别是首地址和末地址

next_permutation是判断是否有下一个排列，有返回true，并且改变数组状态，否则返回false。参数分别是首地址和末地址

代码：

#include

#include

using namespace std;

void display(int a[], int n)

{

int i;

for(i = 0; i < n - 1; i++)

cout << a[i] << " ";

cout << a[i] << endl;

}

void fullPermutation(int a[], int n)//全排列，STL实现

{

sort(a, a + n);//升序排序

do

{

display(a, n);//显示出来

}while(next_permutation(a, a + n));

}

int main()

{

int i, n, t, j;

cin >> t;

for(i = 0; i < t; i++)

{

cin >> n;

cout << endl;

}

return 0;

}

7: (1+x)^n

描述

Please calculate the coefficient modulo 2 of x^i in (1+x)^n.

输入

For each case, there are two integers n, i (0<=i<=n<=2^31-1)

输出

For each case, print the coefficient modulo 2 of x^i in (1+x)^n on a single line. 样例输入

3 1

4 2

样例输出

1

翻译：

描述

请计算(1+x)^n中x^i的系数对2取模的值

输入

每组测试数据有两个整数n i (0<=i<=n<=2^31-1)

输出

每组输出一行，即对2取模的值

思路/方法：(1 + x)^n展开后x^i项的系数的对2取余

即求 c(n, i)x^i中的c(n, i) % 2的值

如果我们计算组合数在对2取余，就会超时，所以我们需要更简便的算法

既然是对2取模，就是奇偶性咯，所以我们需要一个组合数的奇偶性判断的算法

对于组合数C(n, m) 如果(n&m) == m，那么该组合数是奇数，否则为偶数

代码：

#include

int main ()

{

long long n, i;

while(scanf("%I64d %I64d", &n, &i) != EOF)

if((n&i) == i)//奇数，输出1

printf("1\n");

else

printf("0\n");

return 0;

}

8: Summing divisors

描述

divisors of 4 are 1, 2 and 4 and the positive divisors of 3 are 1 and 3, so S(4/3) = 1/1 + 2/1 + 4/1 + 1/3 + 2/3 + 4/3 = 28/3.

输入

Each line of input will be of the form a/b (with no white space) where a and b are integers in the range from 1 to 16000. 输出

Each line of output is of the form a/b where a and b are integers, and the fraction is in simplest terms (so 1/2 will be output instead of 2/4 for example).

样例输入

6/1

2/3

100/49

样例输出

12/1

4/1

1767/7

翻译：

描述

在18世纪，L. Euler发明了一个功能去研究数字的特性，他称之为sigma。他对比较整数的正因子的和感兴趣。在这个问题我们扩展Euler的功能到分数。

给一个正分数最简形式a/b，我们定义 S(a/b) 是所有整数x/y的和，x/y是正因子组成，x来自a的因子，y来自b的因子。例如，4的正因子是1 2 4；3的正因子是1 3。所以S(4/3) = 1/1 + 2/1 + 4/1 + 1/3 + 2/3 + 4/3 = 28/3。

输入

每行输入a/b，a b范围1到16000.

输出

每行输出S(a/b)的值，分数最简形式。

思路/方法：

1.定义数组a和b分别存储输入的两个数的因子。

2.定义一个结构体用来表示分数

3.定义一个函数用来计算分数相加

4.把a和b因子组合起来的分数累加起来，然后约分为最简。

不太好说，具体看下面代码，不难。

代码：

#include

typedef struct Fraction//分数

{

int numerator;//分子

int denominator;//分母

}fraction;

int greatestCommonDivisor(int a, int b)

{

int t;

while(b)

{

t = a % b;

a = b;

fraction addFraction(fraction * f1, fraction * f2)

{

fraction s;

int divisor;

if(f1->denominator == f2->denominator || f1->numerator == 0)//两数分母相同

{

s.numerator = f1->numerator + f2->numerator;//分子相加

s.denominator = f2->denominator;

}

else

{

s.denominator = f1->denominator * f2->denominator;//分母通分

s.numerator = f1->numerator * f2->denominator + f2->numerator * f1->denominator;//分子通分后相加 divisor = greatestCommonDivisor(s.numerator, s.denominator);//求最大公约数

//约分

s.numerator /= divisor;

s.denominator /= divisor;

}

return s;

}

int main()

{

int a[16001], b[16001], i, j, ca, cb;

fraction s, t;

while(scanf("%d/%d", a, b) != EOF)//把a和b存到a0 b0

{

ca = cb = 1;

for(i = 1; i <= a[0]; i++)//a的所有因子

{

if(a[0] % i == 0)

{

a[ca] = i;

ca++;

}

}

for(i = 1; i <= b[0]; i++)//b的所有因子

{

if(b[0] % i == 0)

{

b[cb] = i;

cb++;

}

}

s.denominator = s.numerator = 0;

for(i = 1; i < cb; i++)//计算因子组合的和

{

for(j = 1; j < ca; j++)

{

int divisor = greatestCommonDivisor(s.numerator, s.denominator);//求最大公约数

//约分

s.numerator /= divisor;

s.denominator /= divisor;

printf("%d/%d\n", s.numerator, s.denominator);

}

return 0;

}

9: 简单组合问题

描述

对于有m个元素的集合，在元素能重复取的情况下，我们可以得到有r组合的集合；例如，当m=2，r=4时，集合{a,b}可以划分为5个不同的r组合的集合:

{a,a,a,a};

{a,a,a,b};

{a,a,b,b};

{a,b,b,b};

{b,b,b,b};

输入

输入数据有多组，每行输入2个整型数据m,r，(0

输出

输出可以划分的集合个数

样例输入

2 4

样例输出

5

思路/方法：题目指明了是组合问题，就是不考虑顺序。

这题输入的数据范围小，说明不是有公式就能得出答案的，需要经过推算。

我们不妨来举个例子来看一下是否有规律。

当m=1是，结果都是1

当m=3，r=4时，假设有a,b,c三种数，a就有5(即r+1)种情况，集合中a的个数可以为0 1 2 3 4。a=0时，就剩下b,c来充满4个位置，这种情况的值与m=2，r=4时的值一样；a=1时，就剩下b,c来充满3个位置，这种情况的值与m=2，r=3时的值一样；a=2时，就剩下b,c来充满2个位置，这种情况的值与m=2，r=2时的值一样；a=3时，就剩下b,c来充满1个位置，这种情况的值与m=2，r=1时的值一样；a=4时，位置充满了，值为1。

通过上面例子我们发现s(m=3,r=4)可以转化成s(m=2,r=4) + s(m=2,r=3) + s(m=2,r=2) + s(m=2,r=1) +1。

同样的，我们推广出来就是s(m,r)=s(m-1,r)+s(m-1,r-1)+s(m-1,r-2)+.....+s(m-1,1)+1。

也就是s(m,r)可以转化成前一行的前r列的和+1。

有了这个规律，我们只要知道第一行，就能退出后面的。

这题用递归会超时，所以我们用递推，具体代码如下。

代码：

#include

long long a[21][21];

int main()

{

int m, r, i;

for(i = 0; i < r; i++)//循环r次

a[m][r] = a[m][r] + a[m - 1][r - i];

a[m][r] = a[m][r] + 1;

}

while(scanf("%d %d", &m, &r) != EOF)

printf("%I64d\n", a[m][r]);

return 0;

}

10: GCD & LCM

描述

Given x and y (2 <= x <= 100,000, 2 <= y <= 1,000,000), you are to count the number of p and q such that:

1) p and q are positive integers;

2) GCD(p, q) = x;

3) LCM(p, q) = y.

输入

There are multiple test cases, each case contains two integers x and y, one line for each test case.

输出

Number of pairs of p and q.

样例输入

3 60

样例输出

4

翻译：

描述

给定x,y(2 <= x <= 100,000, 2 <= y <= 1,000,000)，你要像下面那样计算出p和q：

1) p,q是正整数;

2) GCD(p, q) = x;即p,q的最大公约数是x

3) LCM(p, q) = y.即p,q的最小公倍数是y

输入

输入多组测试数据，每组包含两个整数x y

输出

每组输出满足条件的p和q的组数。

思路/方法：

我们要求p，q可能的组数，先来推一下x y p q之间的关系

最小公倍数=两数之积/最大公约数。也就是y=p*q/x;

所以得到xy=pq (范围：x <= p,q <= y)

因为p和q可以用最大公约数的倍数来表示，即设p=x*n1，q=x*n2。

我们可以得到p*q=x*x*n1*n2=x*y。即n1*n2=y/x。

还可以得到gcd(p,q)=gcd(x*n1,x*n2)=x

因此gcd(n1,n2)=1也就是n1,n2是互质的数 (范围：1 <=n1,n2 <= y/x)

所以，确定n1,n2就确定了p,q，我们只需要知道这样的n1,n2有多少组，就知道有多少组p,q

代码：

#include

int gcd(int a, int b)//最大公约数

t = a % b;

a = b;

b = t;

}

return a;

}

int main()

{

int x, y, i, c, s;

while(scanf("%d %d", &x, &y) != EOF)

{

if(y % x != 0)//如果发现最小公倍数不是最大公约数的倍数，就说明组数为0

{

printf("0\n");

continue;

}

c = 0;

s = y / x;

for(i = 1; i <= s; i++)

if(s % i == 0)//能除尽,因为 n1*n2=y/x=s。这里是用i表示n1，s/i表示n2

if(gcd(i, s / i) == 1)//判断n1和n2是否互质

c++;

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

}

return 0;

}

11: Raising Modulo Numbers(快速取模)

描述

People are different. Some secretly read magazines full of interesting girls' pictures, others create an A-bomb in their cellar, others like using Windows, and some like difficult mathematical games. Latest marketing research shows, that this market segment was so far underestimated and that there is lack of such games. This kind of game was thus included into the KOKODDáKH. The rules follow:

Each player chooses two numbers Ai and Bi and writes them on a slip of paper. Others cannot see the numbers. In a given moment all players show their numbers to the others. The goal is to determine the sum of all expressions AiBi from all players including oneself and determine the remainder after division by a given number M. The winner is the one who first determines the correct result. According to the players' experience it is possible to increase the difficulty by choosing higher numbers.

You should write a program that calculates the result and is able to find out who won the game.

输入

The input consists of Z assignments. The number of them is given by the single positive integer Z appearing on the first line of input. Then the assignements follow. Each assignement begins with line containing an integer M (1 <= M <= 45000). The sum will be divided by this number. Next line contains number of players H (1 <= H <= 45000). Next exactly H lines follow. On each line, there are exactly two numbers Ai and Bi separated by space. Both numbers cannot be equal zero at the same time.

输出

For each assingnement there is the only one line of output. On this line, there is a number, the result of expression (A1B1 + A2B2 + ... + AHBH) mod M.

2 3

3 4

4 5

5 6

36123

1

2374859 3029382

17

1

3 18132

样例输出

2

13195

13

翻译：

描述

人们都不同。有些人私下的看满是令人感兴趣的美女图片的杂志，一些人在他们地下室造炸弹，一些人喜欢使用窗户，一些人喜欢复杂的数学游戏。最新的市场调查表明，市场部分太过低估，缺乏这样的游戏。这种游戏是这样的包含在KOKODDáKH。规则如下：

每个玩家选择两个数字Ai 和 Bi，在光滑的纸上写下他们。其他人不能看见这些数字，在给定的时间所有的玩家展示他们的数字给别人看。目标是决定所有的表达式AiBi的和对M取模。第一个得出答案的是胜利者。根据玩家的表达式，很有可能通过选择大的数来增加难度。

你应该写一个程序来计算结果，并且能够造出是谁赢家。

输入

第一行输入一个整数z表示有z组测试数据。每组数据第一行是一个整数M(1 <= M <= 45000)。所有表达式的和对M取模。下一行是玩家个数H(1<=H<=45000)。下面H行是每个玩家的两个数字Ai Bi，两个数不会同时为0

输出

每组数据输出一行表达式(A1B1 + A2B2 + ... + AHBH) mod M.的结果。

思路/方法：如果找常规方法算即使是64位整数也不够存储，所以我们需要快速取模的算法。这算法推起来不简单，这里就不讲为什么，记住这么做就行，下面代码也有注释，至少能保证你看得懂代码，至于为什么这么写，可以百度“快速取模”。

代码：

#include

long long quickMod(long long a, long long b, int m)//a的b次方对 m取模

{

long long s = 1;

while(b)//b次方就循环b次

{

if(b&1)//等价于b%2，如果b是奇数

{

s = s * a % m;//乘以a后对m取模

b--;

}

a = a * a % m;

b >>= 1;//等价于b/= 2

}

return s;

long long s, a, b;

scanf("%d", &z);

for(i = 0; i < z; i++)

{

s = 0;

scanf("%d", &m);

scanf("%d", &h);

for(j = 0; j < h; j++)

{

scanf("%I64d %I64d", &a, &b);

s = s + quickMod(a, b, m);

s = s % m;

}

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

}

return 0;

}

12: Euclid's Game(简单博弈论)

描述

Two players, Stan and Ollie, play, starting with two natural numbers. Stan, the first player, subtracts any positive multiple of the lesser of the two numbers from the greater of the two numbers, provided that the resulting number must be nonnegative. Then Ollie, the second player, does the same with the two resulting numbers, then Stan, etc., alternately, until one player is able to subtract a multiple of the lesser number from the greater to reach 0, and thereby wins. For example, the players may start with (25,7):

25 7

11 7

4 7

4 3

1 3

1 0

an Stan wins.

输入

The input consists of a number of lines. Each line contains two positive integers giving the starting two numbers of the game. Stan always starts.

输出

For each line of input, output one line saying either Stan wins or Ollie wins assuming that both of them play perfectly. The last line of input contains two zeroes and should not be processed.

样例输入

34 12

15 24

0 0

样例输出

Stan wins

Ollie wins

翻译：

描述

11 7

4 7

4 3

1 3

1 0

Stan赢了。

输入

输入多组测试数据，每组一行两个正整数，Stan总是第一个开始。

输出

每组数据输出一行，谁赢了比赛。输入两个0 0就不处理结束运行。

思路/方法：这题还是需要找规律。

我们假设a<=b，如果a>b就交换a b。

1.很明显，如果a或者b为1，则Stan必胜。如果a==b则Stan也必胜。

2.如果b==2*a,显然Stan必胜。如果b>2*a,我们可以假设b%a=c,(c

如果(c,a)是必败态,则Stan肯定会将b减成c，这时是O面临此种情况，可使得O必败。如果(c,a)是必胜态，则S可减b，使得b（要知道b>2*a啊，那就是说b=n*a+c,其中n>=2）成为a+c,局面成为(a,a+c)，这是O只有一种选择，那就是将a+c减一个a（仔细想想，按照游戏规则，他真的没别的办法了），局面变成了Stan面临的(c,a)是一种必胜态，也就是说，当b>2*a的时候，无论(c,a)是必胜态还是必败态，S都必胜。

3.如果a< b < 2 * a。这时只有一种选择，但我们仍然不知道是否能赢，所以我们用递归就行了，注意递归(b-a, a)时下一个状态，即对手的状态，所以我们要取反才是自己的状态。

上面就包含了所有的情况，同样的当a > b时，也是一样的，选手是从中选择一个大的数减去小的，所以谁大无所谓。

代码：

#include

void swap(long long * a, long long * b)

{

long long t;

t = *a;

*a = *b;

*b = t;

}

int game(long long a, long long b)

{

if(a > b)//保证b较大

swap(&a, &b);

if(a == b || b >= 2 * a)

return 1;

else

return !game(b - a, a);//下一个状态是对手状态，对手赢了自己就输了，所以需要加一个!才是自己的状态

}

int main()

{

long long a, b;

while(scanf("%I64d %I64d", &a, &b), !(a == 0 && b == 0))

if(game(a, b))

printf("Stan wins\n");

else

二．几何基础

1: 求两直线的夹角

描述

有两条直线，AB和CD，A、B、C、D的坐标已知，求这两条直线的所成夹角中较小的一个。

输入

输入包括多组数据，第一行为测试数据的组数n，接下来后面有n行，每一行有8个整数，依次代表A点的x坐标、A点的y坐标，B 点的x坐标、B点的y坐标，C点的x坐标、C点的y坐标，D点的x坐标、D点的y坐标。

输出

输出夹角的近似值（角度值而非弧度值，保留1位小数）。

样例输入

2

0 0 0 1 0 0 1 0

0 0 1 1 1 1 1 0

样例输出

90.0

45.0

思路/方法：两直线夹角等价于求两直线的向量的夹角。即cos=n1*n2/(|n1|*|n2|)，两向量点积 / 两向量模 = 角的余弦值然后把余弦值转化成弧度再转化成角度。acos函数就是arccos。

代码：

#include

#include

int main()

{

int a[8], n, i, j, x1, x2, y1, y2;//两个向量(x1,y1)(x2,y2)

double angle;//角度

scanf("%d", &n);

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

{

for(j = 0; j < 8; j++)

scanf("%d", a + j);//输入到数组中

x1 = a[2] - a[0];

y1 = a[3] - a[1];

x2 = a[6] - a[4];

y2 = a[7] - a[5];

angle = fabs((x1 * x2 + y1 * y2) / (sqrt(x1 * x1 + y1 * y1) * sqrt(x2 * x2 + y2 * y2)));//cos=n1*n2/(|n1|*|n2|) angle = acos(angle) / 3.1415926 * 180;//arccos反三角求弧度，转成度数先除以π，在乘以180

printf("%.1lf\n", angle);

}

return 0;

}

2: 计算几何练习题——线段相交

描述

线段相交测试在计算几何中是经常用到的，给定线段P1P2（P1和P2是线段的两端点，且不重合）、P3P4（P3和P4是线段的两端点，且不重合），判断P1P2和P3P4是否相交。P1P2和P3P4不重合，即指只存在一个点P，它既落在P1P2上又落在P3P4上（含线段的端

1

0 0 1 1

2 2

3 3

表示P1、P2、P3、P4的坐标分别为：P1（0,0），P2（1,1），P3（2,2），P4（3,3）

输出

判断每组数据中的线段P1P2和P3P4是否相交，如果相交输出YES，否则输出NO。每组数据输出占一行。

样例输入

1

0 0 1 1

2 2

3 3

样例输出

NO

思路/方法：判断线段相交，我这里介绍一种常见的方法。

快速排斥(两个由线段做对角线的矩形是否有交集) + 跨立(一个线段的两个端点在另一线段的两端)

判断是否有交集就是把所有不相交的情况取反，也就是

!( max(p1.x, p2.x) < min(p3.x, p4.x) || max(p3.x, p4.x) < min(p1.x, p2.x) || max(p1.y, p2.y) < min(p3.y, p4.y) || max(p3.y, p4.y) < min(p1.y, p2.y) )

判断跨立就是(AC X AB) * (AD X AB) <= 0 && (CA X CD) * (CB X CD) <= 0

叉乘X的公式是p1 X p2 = p1.x * p2.y - p1.y * p2.x

所以代码就好写了。

代码：

#include

#include

using namespace std;

class point

{

public:

double x, y;

point(double x1, double y1)

{

x = x1;

y = y1;

}

};

class line

{

public:

point n;

line(point & p1, point &p2): n(p2.x - p1.x, p2.y - p1.y){}

friend double X(line & l1, line & l2);//叉乘

};

double X(line & l1, line & l2)//叉乘

{

return l1.n.x * l2.n.y - l1.n.y * l2.n.x;

}

inline double min(double a, double b)