南京理工大学第八届程序设计大赛(校外镜像)

（A） 偷吃糖果

Time Limit: 1000Ms

Memory Limit: 65536KB

Description

小鱼喜欢吃糖果。他有两盒糖果，两盒糖果分别仅由小写字母组成的字符串s和字符串t构成。其中’a’到’z’表示具体的某种糖果类别。

他原本打算送给他喜欢的女生，但是要送给女孩子的话两盒糖果不能有差别(即字符串s和t完全相同)。所以，他决定偷吃几块，他吃糖果的策略是每次选出一盒糖果中两个连续的同种类别的糖果，然后吃掉其中一块。该策略可以使用多次。

例如一盒糖果是’rrrjj’，他可以把这盒糖果变成’rrjj’或者’rrrj’。现在你要告诉小鱼，经过他多次偷吃糖果之后，两盒糖果能否送给他喜欢的女孩子。如果可以输出’Yes’，如果不行输出’No’。

Input

第一行一个T，表示T组测试数据。每组测试数据格式如下。

第一行表示字符串s，第二行表示字符串t。

1 ≤ T ≤ 100

Each character of s, t will be between ‘a’ and ‘z’.

1 ≤ length of string s ≤ 1000

1 ≤ length of string t ≤ 1000

Output

对于每组测试数据，输出Yes，或者No。

Sample Input

2

rrrjj

rrrj

rj

jr

Sample Output

Yes

No

Hint

题目中的第一个样例：第一盒糖果：rrrjj -> rrjj -> rjj -> rj第二盒糖果：rrrj -> rrj -> rjA

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

typedef long long LL;
const int MAXN = 1000 + 10;
int t, n;
char str1[MAXN], str2[MAXN];

bool Is() {
int len1 = strlen(str1);
int len2 = strlen(str2);
int i = 0, j = 1;
while (j < len1) {
if (str1[i] == str1[j]) {
++j;
} else {
str1[++i] = str1[j++];
}
}
str1[i + 1] = 0;
i = 0; j = 1;
while (j < len2) {
if (str2[i] == str2[j]) {
++j;
} else {
str2[++i] = str2[j++];
}
}
str2[i + 1] = 0;
return strcmp(str1, str2) == 0 ? true : false;
}

int main() {
scanf("%d%*c", &t);
while (t--) {
scanf("%s%*c%s%*c", str1, str2);
printf("%s\n", Is() ? "Yes" : "No");
}
return 0;
}

（C） count_prime

Time Limit: 1000ms

Memory Limit: 65536KB

Description

给定你一个数n，请你统计出在[a,b]这个区间中和n互质的数的个数。

两个数互质当且仅当他们除了1之外没有其他的公共因子或者他们最大的公共因子是1。1和任何数是互素的。

Input

第一行输入一个整数T（1 <= T <= 100），表示T组测试数据。

接下来T行，每行3个整数a，b，n（1 <= a <=b <=10^15, 1<= n <= 10^9），用空格隔开。

Output

输出一个整数表示和n互质的数的个数。

Sample Input

2

1 10 2

3 10 5

Sample Output

5

6

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long LL;
int t;
LL a, b, n, prime[1000];

int GetPrime(LL num) {
int cnt = 0;
for (LL i = 2; i*i <= num; ++i) {
if (num && num%i == 0) {
prime[cnt++] = i;
while (num && num%i == 0) num /= i;
}
}
if (num > 1) prime[cnt++] = num;
return cnt;
}

LL Multiple(int  cnt, LL arg) {
LL ans = 0;
for (LL i = 1; i < (LL)1 << cnt; ++i) {
LL flag = 0, temp = 1;
for (LL j = 0; j < cnt; ++j) {
if (i & (LL)1<<j) { ++flag; temp *= prime[j]; }
}
if (flag & 1) ans += arg / temp;
else ans -= arg / temp;
}
return ans;
}

int main() {
scanf("%d", &t);
while (t--) {
scanf("%lld%lld%lld", &a, &b, &n);
int cnt = GetPrime(n);
printf("%lld\n", b - Multiple(cnt, b) - (a - 1 - Multiple(cnt, a - 1)));
}
return 0;
}

（F） sequence

Time Limit: 1000MS

Memory Limit: 65536KB

Description

将一个给定的数列，拆分成K个不降序列，每个数出现且只出现一次，且在各序列中各个数相对于原数列的相对顺序不变。

如7 6 9 8 10可以拆成 7 9 10和6 8。求最小的K值。

Input

第一行输入一个整数T（1 <= T <= 100），表示接下来T组测试数据，

每组两行，第一行为n，代表数列长度（1<=n<=10000）

接下来一行有n个数，空格分隔（每个数<=50000）。

Output

对每组数据输出一个最小的K值。

Sample Input

2

5

7 6 9 8 10

5

5 4 3 2 1

Sample Output

2

5

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 1e5 + 10;
int t, n, arr[MAXN], lis[MAXN], dp[MAXN];

int Lis() {
lis[1] = arr[1];
int len = 1;
for (int i = 1; i <= n; ++i) {
int j = lower_bound(lis + 1, lis + 1 + len, arr[i]) - lis;
if (len < j) { len = j; }
lis[j] = arr[i];
}
return len;
}

int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int ans = 0;
memset(dp, 0, sizeof(dp));
memset(lis, 0, sizeof(lis));
for (int i = n ; i > 0; --i) {
scanf("%d", &arr[i]);
}
printf("%d\n", Lis());
}
return 0;
}

（H） 谁才是最强战舰！

Time Limit: 1000MS

Memory Limit: 65536KB

Description

依阿华来到镇守府的第一件事情，就是找大和solo！

然而这并不是什么好消息，说不定，镇守府，甚至佐伯湾就这么消失了。。。

于是，提督君想了一个简单的游戏，来分出她们的胜负。游戏规则如下：这里有N堆石子，每堆石子有a[i]（1<=i<=N）个，每人轮流从其中的某一堆石子中拿出任意个石子（只能在其中一堆拿，不能不拿），大和先手，谁拿出了最后一个石子，谁输。若大和必胜，输出“Yamato_Saikou!”，若依阿华必胜，输出“Meidikeji_Shijiediyi!”，若两边都无法必胜，输出“Sayonara_Konosekai!”.

Input

第一行输入一个正整数T(1 <= T <= 1000)，表示有T组测试数据。

对于每组测试数据：

第一行一个正整数，N（N<=1000），表示有N堆石子。

第二行N个整数a[i]（1<=a[i]<=1000），表示每堆石子的数量。

Output

若大和必胜，输出“Yamato_Saikou!”，若依阿华必胜，输出“Meidikeji_Shijiediyi!”，若两边都无法必胜，输出“Sayonara_Konosekai!”.

Sample Input

3

1

5

2

1 2

3

1 1 1

Sample Output

Yamato_Saikou!

Yamato_Saikou!

Meidikeji_Shijiediyi!

#include <iostream>
using namespace std;

typedef long long LL;
int t, n;

int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int ans = 0, num1 = 0, num2 = 0, num;
for (int i = 0; i < n; ++i) {
scanf("%d", &num);
num > 1 ? ++num1 : ++num2;
ans ^= num;
}
if (n == 0) printf("Sayonara_Konosekai!");
else if ((ans != 0 && num1 != 0) || (ans == 0 && num1 == 0)) {
printf("Yamato_Saikou!\n");
} else {
printf("Meidikeji_Shijiediyi!\n");
}
}
return 0;
}

（J） water1

Time Limit: 1000MS

Memory Limit: 65536KB

Description

听说全球气候变暖，冰川融化，海水淹大地。着实好奇要融化多少冰川会淹没我的宿舍，哦不，淹没南京，反正NJUST应该总会是第一批被淹的。

现将问题简化成一个二维坐标系的模型。有N个矩形块区域，每个区域有海拔（H）和宽度（W），区域按照顺序给出，比如有3个区域，第一个区域宽度为1，海拔为2，第二个区域宽度为5，海拔为6，第三个区域宽度为3，海拔为4，从图像上看就是像这样：（Y轴是海拔）

8

7

6 +++++

5 +++++

4 ++++++++

3 ++++++++

2 +++++++++

1 +++++++++

123456789

假设最左边和最右边都是无限高的墙。

为了简化问题，假设水流下来的速度是每秒一个单位的水，并且总是往区域一降水（某沿海地区）。

现在请问要淹没所有的区域至少要多少时间（秒）？淹没的定义是，所有的区域表面至少覆盖一层水。如果没有区域则至少要放一滴水。

上图例子中，淹没完如下：

8

7 wwwwwwwww

6 w+++++www

5 w+++++www

4 w++++++++

3 w++++++++

2 +++++++++

1 +++++++++

123456789

所以需要19秒。

Input

多CASE，测试数据以EOF结尾，对于每个CASE：

第一行一个整数N（0 <= N <= 10^5）。

接下去N行每行对应两个整数H（1 <= H <= 10^5）,W（1 <= W <= 10^5）分别对应第N个区域的海拔和宽度。

Output

一个整数，表示所需要的时间。

Sample Input

3

2 1

6 5

4 3

Sample Output

19

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

typedef long long LL;
const int MAXN = 1e5 + 10;
int n, h[MAXN], w[MAXN];

int main() {
while (scanf("%d", &n) != EOF) {
LL maxh = 0, sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &h[i], &w[i]);
if (maxh < (LL)h[i]) maxh = (LL)h[i];
}
maxh++;
for (int i = 0; i < n; ++i) {
sum += (maxh - h[i]) * (LL)w[i];
}
printf("%lld\n", sum == 0 ? 1 : sum);
}
return 0;
}