蓝桥杯算法训练习题与官方答案

输出格式

输出两行，每行两个整数，表示A^b%m的值。

样例输入

2 2

1 1

0 1

样例输出

1 0

0 1

参考代码：

import edReader;

import ption;

import treamReader;

public class Main{

static int m;

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader());

String[] str = ne().split(" ");

int b = nt(str[0]);

m = nt(str[1]);

int[][] arr = new int[2][2];

for (int i = 0; i < ; i++) {

String[] tag = ne().split(" ");

for (int j = 0; j < arr[i].length; j++) {

arr[i][j] = nt(tag[j]);

}

}

int[][] tak = new int[2][2];

tak = mulpow(arr, b);

for (int i = 0; i < 2; i++) {

for (int j = 0; j < 2; j++) {

(tak[i][j] % m + " ");

}

n();

}

}

public static int[][] mul(int[][] x, int[][] y) {

int[][] temp = new int[2][2];

for (int a = 0; a < 2; a++) {

for (int b = 0; b < 2; b++) {

temp[a][b] = 0;

for (int c = 0; c < 2; c++) {

temp[a][b] += x[a][c] * y[c][b];

temp[a][b] %= m;

}

}

}

return temp;

}

public static int[][] mulpow(int[][] arr, int b) {

if (b == 0) {

int[][] temp = new int[2][2];

for (int x = 0; x < 2; x++) {

for (int y = 0; y < 2; y++) {

if (x == y)

temp[x][y] = 1;

}

}

return temp;

}

if (b == 1)

return arr;

int[][] rep = mulpow(arr, b / 2);

if (b % 2 == 0)

return mul(rep, rep);

else

return mul(mul(rep, rep), arr);

}

}

编号：ALGO-61

题目：奇偶判断

关键字：

类型：vip试题

问题描述

能被2整除的数称为偶数，不能被2整除的数称为奇数。给一个整数x，判断x是奇数

还是偶数。

输入格式

输入包括一个整数x，0<=x<=100000000。

输出格式

如果x是奇数，则输出“odd”，如果是偶数，则输出“even”。

样例输入

10

样例输出

even

样例输入

2009

样例输出

odd

参考代码：

import r;

public class Main {

public static void main(String[] args) {

@SuppressWarnings("resource")

Scanner scan = new Scanner();

int a = t();

if (a % 2 == 0)

n("even");

else

n("odd");

}

}

编号：ALGO-62

题目：平方计算

关键字：

类型：vip试题

问题描述

输入正整数a, m，输出a^2%m，其中^表示乘方，即a^2表示a的平方，%表示取余。

输入格式

输入包含两个整数a, m，a不超过10000。

输出格式

输出一个整数，即a^2%m的值。

样例输入

5 6

样例输出

1

参考代码：

import .*;

public class Main {

}

public static void main(String[] args) throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader());

String str [] = ne().split(" ");

int a = nt(str[0]);

int m = nt(str[1]);

int Mi = (int)(a, 2);

(Mi%m);

}

编号：ALGO-63

题目：乘法表

关键字：

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

问题描述

输出九九乘法表。

输出格式

输出格式见下面的样例。乘号用“*”表示。

样例输出

下面给出输出的前几行：

1*1=1

2*1=2 2*2=4

3*1=3 3*2=6 3*3=9

4*1=4 4*2=8 4*3=12 4*4=16

……

参考代码：public class Main {

public static void main(String[] args) {

for(int i=1;i<=9;i++){

for(int j=1;j

(i+"*"+j+"="+(i*j)+" ");

}

n(i+"*"+i+"="+(i*i));

}

}

}

编号：ALGO-64

题目：大小写判断

关键字：

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

问题描述

给定一个英文字母判断这个字母是大写还是小写。

输入格式

输入只包含一个英文字母c。

输出格式

如果c是大写字母，输出“upper”，否则输出“lower”。

样例输入

x

样例输出

lower

样例输入

B

样例输出

upper

参考代码：

import ption;

import r;

public class Main {

public static void main(String[] args) throws IOException {

char c=(char)();

if((int)c>=65&&(int)c<=90)

n("upper");

if((int)c>=97&&(int)c<=122)

n("lower");

}

}

编号：ALGO-65

题目：比赛安排

关键字：

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

问题描述

设有有2 n（n<=6）个球队进行单循环比赛，计划在2 n – 1天内完成，每个队每天进

行一场比赛。设计一个比赛的安排，使在2 n – 1天内每个队都与不同的对手比赛。

输入格式

输入文件共一行，输入n的数值。

输出格式

输出文件共（2 n – 1）行，第i行输出第i天的比赛安排。

格式为： A-B，C-D，……。其中i是天数，A，B分别为比赛双方的编号，每行共2 n-1

个比赛场次。

样例输入

2

样例输出

<1>1-2,3-4

<2>1-3,2-4

<3>1-4,2-3

参考代码：

import ist;

import ;

import r;

public class Main {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc=new Scanner();

int n=t();

List list=new ArrayList();

int sum=(int) (2, n);

for(int i=1;i<=sum;i+=2){

String s=i+"-"+(i+1);

(s);

}

for(int i=1;i<=sum-2;i++){

int[] arr=new int[sum+1];

for(int j=1;j<=sum;j++)

arr[j]=j;

(new String(1+"-"+(i+2)));

arr[1]=0;arr[i+2]=0;

for(int k=2;k<=sum;k++){

for(int p=2;p<=sum;p++){

if(k!=p&&arr[p]!=0&&arr[k]!=0){

String sp=k+"-"+p;

if(ns(sp))

}

}

continue;

else{

(sp);

arr[p]=0;arr[k]=0;

}

}

}

}

}

int num=2;

("<1>");

for(int i=1,j=();i<=j;i++){

((i-1)+" ");

if(i%(sum/2)==0&&i

n();

("<"+num+">");

num++;

}

}

编号：ALGO-66

题目：字符串编辑

关键字：

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

从键盘输入一个字符串（长度<=40个字符），并以字符 ’.’ 结束。编辑功能有：1 D：删

除一个字符，命令的方式为： D a 其中a为被删除的字符，例如：D s 表示删除字符 ’s’ ，

若字符串中有多个 ‘s’，则删除第一次出现的。

2 I：插入一个字符，命令的格式为：I a1 a2 其中a1表示插入到指定字符前面，a2表示

将要插入的字符。例如：I s d 表示在指定字符 ’s’ 的前面插入字符 ‘d’ ，若原串中有

多个 ‘s’ ，则插入在最后一个字符的前面。

3 R：替换一个字符，命令格式为：R a1 a2 其中a1为被替换的字符，a2为替换的字符，

若在原串中有多个a1则应全部替换。

在编辑过程中，若出现被改的字符不存在时，则给出提示信息。

输入格式

输入文件共两行，第一行为原串(以’.’结束)，第二行为命令（输入方式

参见“问题描述” 。

输出格式

输出文件共一行，为修改后的字符串或输出指定字符不存在的提示信息。

样例输入

This is a book.

D s

样例输出

Thi is a book.

D s

输入输出样例解释

命令为删去s，第一个在字符中出现的s在This中，即得到结果。

参考代码：

import r;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner();

StringBuffer sb = new StringBuffer(ne());

String s = ();

if (IgnoreCase("D")) {

String a = ();

int l = f(a);

n(CharAt(l));

} else if (IgnoreCase("I")) {

String a1 = ();

String a2 = ();

int l = dexOf(a1);

n((l, a2));

} else if (IgnoreCase("R")) {

String a1 = ();

String a2 = ();

if (f(a1) == -1)

n("u6307u5b9au5b57u7b26u4e0du5b58u5728");

else

n(ng().replace(a1, a2));

}

}

}

编号：ALGO-67

题目：最大值与最小值的计算

关键字：数组，逻辑表达式

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

输入11个整数，计算它们的最大值和最小值。

样例输入

0 1 2 3 4 5 6 7 8 9 10

样例输出

10 0

参考代码：

import .*;

public class Main{

public static void main(String args[]){

Scanner sc=new Scanner();

int a[]=new int[11];

a[0]=1000000;

for(int i=0;i<11;i++){

String s=();

if((0)>='0'&&(0)<='9')

a[i]=nt(s);

}

(a);

if(a[10]==1000000)

n(1+" "+1);

else

n(a[10]+" "+a[0]);

}

}

编号：ALGO-68

题目：判定数字

关键字：if-else结构，数据有效性检查

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

编写函数，判断某个给定字符是否为数字。

样例输入

9

样例输出

yes

参考代码：

import .*;

public class Main {

public static void main(String[] args) throws Exception {

Scanner scanner=new Scanner();

String str=ne();

boolean flag=isNumber(str);

if(flag){

n("yes");

}

} else {

n("no");

}

}

private static boolean isNumber(String str){

for(int i=0;i<();i++){

if((i)<'0' || (i)>'9'){

return false;

}

}

return true;

}

编号：ALGO-69

题目：字符串逆序

关键字：字符串

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

输入一个字符串，长度在100以内，按相反次序输出其中的所有字符。

样例输入

tsinghua

样例输出

auhgnist

参考代码：

import .*;

public class Main {

/**

* @param args

*/

public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub

exe();

/*

BufferedReader br = new BufferedReader(new InputStreamReader());

String str = ne();

String [] strs = ("s+");

//n();

if(strs[0].equals(strs[1])){

n(0);

}else{

int len1 = strs[0].length();

int len2 = strs[1].length();

int len = 0;

len = len2;

if(len1

len = len1;

}

for(int i=0;i

if(strs[0].charAt(i)==strs[1].charAt(i)){

continue;

}else{

n(strs[0].charAt(i)-strs[1].charAt(i));

break;

}

}

}*/

}

public static void exe() throws IOException{

BufferedReader br = new BufferedReader(new InputStreamReader());

String str = ne();

int len = ();

for(int i=len-1;i>=0;i--){

((i));

}

}

}

编号：ALGO-70

题目：最长字符串

关键字：字符串、循环

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

求出5个字符串中最长的字符串。每个字符串长度在100以内，且全为小写字母。

样例输入

one two three four five

样例输出

three

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

String[] s = ne().split(" ");

String out = "";

int length = 0;

for (int i = 0; i < ; i++) {

if (s[i].length() > length) {

length = s[i].length();

out = s[i];

}

}

n(out);

}

}

编号：ALGO-71

题目：比较字符串

关键字：字符串

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

编程实现两个字符串s1和s2的字典序比较。（保证每一个字符串不是另一个的前缀，且

长度在100以内）。若s1和s2相等，输出0；若它们不相等，则指出其第一个不同字符的

ASCII码的差值：如果s1>s2，则差值为正；如果s1

样例输入

java basic

样例输出

8

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args)throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

String[] strs = ne().split(" +");

int length, def = 0;

}

}

if(strs[1].length()

else length=strs[0].length();

for(int i=0; i

if((def=strs[0].charAt(i)-strs[1].charAt(i)) != 0)

break;

}

n(def);

编号：ALGO-72

题目：成绩的等级输出

关键字：分支结构

类型：vip试题

问题描述：

时间限制：1.0s ? 内存限制：512.0MB

输入一个百分制的成绩t后

输入一个百分制的成绩t后，按下式输出它的等级。等级为：90~100为A，80~89为B，70~79

为C，60~69为D，0~59为E。

样例输入

98

样例输出

A

参考代码：import lFormat;

import r;

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner();

double n=uble();

if(n>=90)

n("A");

else if (n>=80) {

n("B");

}

else if (n>=70) {

n("C");

}

else if (n>=60) {

n("D");

}

else {

n("E");

}

}

}

编号：ALGO-73

题目：统计字符次数

关键字：字符串 循环

类型：vip试题

问题描述：输入一个字符串(长度在100以内)，统计其中数字字符出现的次数。

样例输入

Ab100cd200

样例输出

6

参考代码：

import .*;

public class Main {

public static void main(String [] args) throws IOException{

/* int count = 0;

char c = (char) ();

while(!(c=='n')){

//n(c);

if(c>='0'&&c<='9'){

count++;

}

c = (char) ();

}

n(count);*/

BufferedReader br = new BufferedReader(new InputStreamReader());

StringBuilder sb = new StringBuilder(ne());

int count=0;

int len = ();

for(int i=0;i

char c = (i);

if(c>='0'&&c<='9'){

}

}

count++;

}

}

n(count);

编号：ALGO-74

题目：连接字符串

关键字：算法、字符串基本操作

类型：vip试题

问题描述：编程将两个字符串连接起来。例如country与side相连接成为countryside。

输入两行，每行一个字符串（只包含小写字母，长度不超过100）；输出一行一个字符

串。

样例输入

country

side

样例输出

Countryside

参考代码：

import iter;

import ption;

import ;

import r;

public class Main

{

public static void main(String args[]) throws Exception

{

Scanner sc = new Scanner();

String str1 = ();

String str2 = ();

n(str1+str2);

}

}

编号：ALGO-75

题目：筛选号码

关键字：算法、枚举、标记数组

类型：vip试题

问题描述

有n个人围成一圈，顺序排号（编号为1到n）。从第1个人开始报数(从1到3报数)，

凡报到3的人退出圈子。从下一个人开始继续报数，直到剩下最后一个人，游戏结束。

问最后留下的是原来第几号的那位。

举个例子，8个人围成一圈：

1 2 3 4 5 6 7 8

第1次报数之后，3退出，剩下：

1 2 4 5 6 7 8 （现在从4开始报数）

第2次报数之后，6退出，剩下：

1 2 4 5 7 8 （现在从7开始报数）

第3次报数之后，1退出，剩下：

2 4 5 7 8 （现在从2开始报数）

第4次报数之后，5退出，剩下：

2 4 7 8 （现在从7开始报数）

第5次报数之后，2退出，剩下：

4 7 8 （现在从4开始报数）

第6次报数之后，8退出，剩下：

4 7 （现在从4开始报数）

最后一次报数之后，4退出，剩下：

7.

所以，最后留下来的人编号是7。

输入格式

一个正整数n，(1

输出格式

一个正整数，最后留下来的那个人的编号。

样例输入

8

样例输出

7

数据规模和约定

对于100%的数据，1

参考代码：

import edReader;

import treamReader;

import ist;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int length = nt(ne());

ArrayList arr = new ArrayList();

}

}

for (int i = 1; i <= length; i++) {

(i);

}

int control = 0;

int index = 0;

while (() != 1) {

if (control == 2) {

(index);

index--;

}

control = (control + 1) % 3;

index = (index + 1) % ();

}

n((0));

编号：ALGO-76

题目：十进制数转八进制数

关键字：进制转换

类型：vip试题

问题描述：编写函数把一个十进制数输出其对应的八进制数。

样例输入

9274

样例输出

22072

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args)throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int x = nt(ne().replace(" ", ""));

n(lString(x));

}

}

编号：ALGO-77

题目：斜率计算

关键字：

类型：vip试题

问题描述：输入两个点的坐标，即p1 = (x1, y1)和p2=(x2, y2)，求过这两个点的直线的斜率。

如果斜率为无穷大输出“INF”。

样例输入

1 2

2 4

样例输出

2

样例输入

1 2

1 4

样例输出

INF

样例输入

1 2

3 2

样例输出

0

参考代码：

import r;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner();

int x1 = t(), y1 = t();

int x2 = t(), y2 = t();

();

if (x2 - x1 == 0)

n("INF");

else

n((y2 - y1) / (x2 - x1));

}

}

编号：ALGO-78

题目：确定元音字母位置

关键字：

类型：vip试题

问题描述：输入一个字符串，编写程序输出该字符串中元音字母的首次出现位置，如果没有

元音字母输出0。英语元音字母只有‘a’、‘e’、‘i’、‘o’、‘u’五个。

样例输入:

hello

样例输出:

2

样例输入:

apple

样例输出:

1

样例输入:

pmp

样例输出:

0

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args)throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

String str = ne();

String yy = "aeiouAEIOU";

char[] cs = Array();

for(int i=0; i<; i++){

if(f(cs[i]) != -1){

n(i+1);

return;

}

}

n(0);

}

}

编号：ALGO-80

题目：整数平均值

关键字：

类型：vip试题

问题描述：编写函数，求包含n个元素的整数数组中元素的平均值。要求在函数内部使用指

针操纵数组元素，其中n个整数从键盘输入，输出为其平均值。

样例输入: （输入格式说明：5为输入数据的个数，3 4 0 0 2 是以空格隔开的5个整数）

5

3 4 0 0 2

样例输出:

1

样例输入:

7

3 2 7 5 2 9 1

样例输出:

4

参考代码：

import edReader;

import ption;

import treamReader;

public class Main{

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader());

int n = nt(ne().trim());

int sum = 0;

String[] str = ne().split(" ");

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

sum += nt(str[i]);

}

n(sum / n);

}

}

编号：ALGO-82

题目：输出米字形

关键字：无

类型：vip试题

问题描述：

根据输入的正整数n (1 米字形由一个(2n-1)*(2n-1)的矩阵组成，矩阵包含从大写A开

始的n个字母

例如:n=3时，包含A,B,C；n=4时，包含A,B,C,D。

矩阵的正中间为n个字母中字典序最大的那个，从这个字母开始，沿着西北、正北、东

北、正西、正东、西南、正南、东南八个方向各有一条由大写字母组成的直线。并且直线上

的字母按字典序依次减小，直到大写字母A。

矩阵的其它位置用英文句号．填充。

样例输入一

3

样例输出一

Ａ．Ａ．Ａ

．ＢＢＢ．

ＡＢＣＢＡ

．ＢＢＢ．

Ａ．Ａ．Ａ

样例输入二

4

样例输出二

Ａ．．Ａ．．Ａ

．Ｂ．Ｂ．Ｂ．

．．ＣＣＣ．．

ＡＢＣＤＣＢＡ

．．ＣＣＣ．．

．Ｂ．Ｂ．Ｂ．

Ａ．．Ａ．．Ａ

参考代码：

import edReader;

import ption;

import treamReader;

public class Main{

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader());

int n = nt(ne());

String str = "";

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

str += (char) (i + 65);

for (int i = n - 2; i > -1; i--)

str += (char) (i + 65);

int len = n * 2 - 1;

char[][] chs = new char[len][len];

int y = len - 1;

for (int i = 0; i < ; i++) {

chs[i][i] = (i);

chs[i][y--] = (i);

chs[len / 2][i] = (i);

chs[i][len / 2] = (i);

}

for (int i = 0; i < ; i++) {

for (int j = 0; j < chs[i].length; j++) {

if(!(chs[i][j]>='A' && chs[i][j]<='Z'))

chs[i][j] = '.';

}

}

for (int i = 0; i < ; i++) {

for (int j = 0; j < chs[i].length; j++) {

(chs[i][j]);

}

n();

}

}

}

编号：ALGO-83

题目：阶乘

关键字：循环语句 数学知识

类型：vip试题

问题描述：

问题描述

一个整数n的阶乘可以写成n!，它表示从1到n这n个整数的乘积。阶乘的增长速

度非常快，例如，13!就已经比较大了，已经无法存放在一个整型变量中；而35!就更大

了，它已经无法存放在一个浮点型变量中。因此，当n比较大时，去计算n!是非常困难

的。幸运的是，在本题中，我们的任务不是去计算n!，而是去计算n!最右边的那个非0

的数字是多少。例如，5! = 1*2*3*4*5 = 120，因此5!最右边的那个非0的数字是2。

再如：7! = 5040，因此7!最右边的那个非0的数字是4。请编写一个程序，输入一个整

数n(n<=100)，然后输出n! 最右边的那个非0的数字是多少。

输入格式：输入只有一个整数n。

输出格式：输出只有一个整数，即n! 最右边的那个非0的数字。

输入输出样例

样例输入

6

样例输出

2

参考代码：

import edReader;

import treamReader;

import imal;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int number = nt(ne());

BigDecimal bd = new BigDecimal(1);

for (long i = 1; i <= number; i++) {

bd = ly(new BigDecimal(i));

}

String out = ng();

for (int i = () - 1; i >= 0; i--) {

if ((i) != '0') {

n((i));

return;

}

}

}

}

编号：ALGO-85

题目：进制转换

关键字：字符操作 数学知识

类型：vip试题

问题描述：

问题描述

编写一个程序，输入一个二进制的字符串（长度不超过32），然后计算出相应的十

进制整数，并把它打印出来。

输入格式：输入为一个字符串，每个字符都是’0’或’1’，字符串的长度不超过

32。

输出格式：输出一个整数。

输入输出样例

样例输入

1101

样例输出

13

参考代码：

import edReader;

import treamReader;

import ption;

public class Main{

/**

* @param args

*/

public static void fun(String n){

char[] arr=Array();

int j=0,sum=0;

for(int i=-1;i>=0;i--){

//((int)(arr[i]));

if(arr[j]==(char)(49)){

sum+=(2, i);

}

j++;

}

(sum);

}

public static void main(String[] args)throws IOException {

// TODO Auto-generated method stub

BufferedReader br=new BufferedReader(new InputStreamReader());

String n=ne();

fun(n);

}

}

编号：ALGO-88

题目：字串统计

关键字：无

类型：vip试题

问题描述

给定一个长度为n的字符串S，还有一个数字L，统计长度大于等于L的出现次数最

多的子串（不同的出现可以相交），如果有多个，输出最长的，如果仍然有多个，输出

第一次出现最早的。

输入格式

第一行一个数字L。

第二行是字符串S。

L大于0，且不超过S的长度。

输出格式

一行，题目要求的字符串。

输入样例1：

4

bbaabbaaaaa

输出样例1：

bbaa

输入样例2：

2

bbaabbaaaaa

输出样例2：

aa

数据规模和约定

n<=60

S中所有字符都是小写英文字母。

提示

枚举所有可能的子串，统计出现次数，找出符合条件的那个

参考代码：

import r;

public class Main

{

public static void main(String[] args)

{

Scanner sc=new Scanner();

int L=t();

String s=();

Main a=new Main();

(L,s);

}

public void childs(int L,String s)

{

String s1[][]=new String[60][60];

int in[][]=new int[60][60];

int max=0;

int td=0;

int tj=0;

for(int i=L;i<();i++)

for(int j=0;j<=()-i;j++)

{

s1[i][j]=ing(j,j+i);

}

for(int i=L;i<();i++)

for(int j=0;j<=()-i;j++)

for(int k=j;k<=()-i;k++)

if(s1[i][k].equals(s1[i][j]))

{

in[i][j]=in[i][j]+1;

}

for(int i=L;i<=();i++)

for(int j=0;j<=()-i;j++)

{

if(in[i][j]>=max && td!=i)

{

max=in[i][j];

td=i;

tj=j;

}else if(in[i][j]>max)

{

max=in[i][j];

td=i;

tj=j;

}

}

n(s1[td][tj]);

}

}

编号：ALGO-89

题目：字串删除

关键字：数组运算

类型：vip试题

问题描述

编写一个程序，先输入一个字符串str（长度不超过20），再输入单独的一个字符

ch，然后程序会把字符串str当中出现的所有的ch字符都删掉，从而得到一个新的字符

串str2，然后把这个字符串打印出来。

输入格式：输入有两行，第一行是一个字符串（内部没有空格），第二行是一个字

符。

输出格式：经过处理以后的字符串。

输入输出样例

样例输入

123-45-678

-

样例输出

12345678

参考代码：

import edReader;

import treamReader;

import ar;

import p;

import or;

import ;

import r;

public class Main

{

public static void main(String args[]) throws Exception

{

//Scanner sc = new Scanner();

BufferedReader br = new BufferedReader(new InputStreamReader());

String str = ne();

char ch = (char) ();

n(e(f(ch), ""));

}

}

编号：ALGO-91

题目：Anagrams问题

关键字：数组运算 字符操作

类型：普通试题

问题描述

Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不

区分大小写）所出现的次数都是相同的。例如，“Unclear”和“Nuclear”、“Rimon”和“MinOR”

都是Anagrams。编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。

每一个单词的长度不会超过80个字符，而且是大小写无关的。

输入格式：输入有两行，分别为两个单词。

输出格式：输出只有一个字母Y或N，分别表示Yes和No。

输入输出样例

样例输入

Unclear

Nuclear

样例输出

Y

参考代码：

import edReader;

import treamReader;

import ption;

import ;

public class Main{

/**

* @param args

*/

public static void main(String[] args)throws IOException {

// TODO Auto-generated method stub

BufferedReader br=new BufferedReader(new InputStreamReader());

String s1=ne();

String s2=ne();

String st1=rCase();

String st2=rCase();

char[] str1=Array();

char[] str2=Array();

int[] arr1=new int[];

int[] arr2=new int[];

if(==){

for(int i=0;i<;i++){

arr1[i]=(int)(str1[i]);

arr2[i]=(int)(str2[i]);

if(arr1[i]>96){

arr1[i]=arr1[i]-32;

}

if(arr2[i]>96){

arr2[i]=arr2[i]-32;

}

}

(arr1);

(arr2);

int count1=0,count2=0;

for(int i=0;i<;i++){

if(arr1[i]==arr2[i]){

count1++;

}

count2++;

//(arr1[i]+" "+arr2[i]+" ");

}

//(count1+" "+count2);

if(count1==count2){

("Y");

}

else{

("N");

}

}

else{

("N");

}

}

}

编号：ALGO-92

题目：前缀表达式

关键字：字符操作 数学知识

类型：普通试题

问题描述

编写一个程序，以字符串方式输入一个前缀表达式，然后计算它的值。输入格式为：“运

算符 对象1 对象2”，其中，运算符为“+”（加法）、“-”（减法）、“*”（乘法）或“/”（除

法），运算对象为不超过10的整数，它们之间用一个空格隔开。要求：对于加、减、乘、除

这四种运算，分别设计相应的函数来实现。

输入格式：输入只有一行，即一个前缀表达式字符串。

输出格式：输出相应的计算结果（如果是除法，直接采用c语言的“/”运算符，结果

为整数）。

输入输出样例

样例输入

+ 5 2

样例输出

7

参考代码：

import edReader;

import ption;

import treamReader;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader bf = new BufferedReader(new InputStreamReader());

String s=ne();

String [] str = (" ");

int a=nt(str[1]);

int b=nt(str[2]);

if("+".equals(str[0])){

add(a,b);

}else if("-".equals(str[0])){

subtract(a, b);

}else if("*".equals(str[0])){

multiply(a, b);

}else{

divide(a, b);

}

}

public static void add(int a, int b){

n(a + b);

}

public static void subtract(int a, int b){

n(a - b);

}

public static void multiply(int a, int b){

n(a * b);

}

public static void divide(int a, int b){

if(b != 0){

n(a / b);

}else {

n("by zero");

}

}

}

编号：ALGO-93

题目：反置数

关键字：函数设计 字符操作

类型：VIP试题

问题描述

一个整数的“反置数”指的是把该整数的每一位数字的顺序颠倒过来所得到的另一个整

数。如果一个整数的末尾是以0结尾，那么在它的反置数当中，这些0就被省略掉了。比如

说，1245的反置数是5421，而1200的反置数是21。请编写一个程序，输入两个整数，然

后计算这两个整数的反置数之和sum，然后再把sum的反置数打印出来。要求：由于在本

题中需要多次去计算一个整数的反置数，因此必须把这部分代码抽象为一个函数的形式。

输入格式：输入只有一行，包括两个整数，中间用空格隔开。

输出格式：输出只有一行，即相应的结果。

输入输出样例

样例输入

435 754

样例输出

199

参考代码：

import edReader;

import ption;

import treamReader;

public class Main {

static int sum;

private static int rpNum(String str1) {

// TODO Auto-generated method stub

StringBuffer sb=new StringBuffer(str1);

sb=e();

StringBuffer tem=new StringBuffer();

boolean ch=false;

for(int i=0;i<();i++){

if((i)!='0'){

ch=true;

}

if(ch){

((i));

}

}

return nt(ng());

}

public static void main(String[] args) throws IOException {

BufferedReader br=new BufferedReader(new InputStreamReader());

String[] strNum=ne().split(" ");

for(int i=0;i<2;i++){

sum+=rpNum(strNum[i]);

}

}

}

n(rpNum(new Integer(sum).toString()));

编号：ALGO-94

题目：新生舞会

关键字：

类型：VIP试题

问题描述

新生舞会开始了。n名新生每人有三个属性：姓名、学号、性别。其中，姓名用长度不

超过20的仅由大小写字母构成的字符串表示，学号用长度不超过10的仅由数字构成的字符

串表示，性别用一个大写字符‘F’或‘M’表示。任意两人的姓名、学号均互不相同。换

言之，每个人可被其姓名或学号唯一确定。给出m对两人的信息（姓名或学号），判断他们

是否能共舞。两人能共舞的充要条件为两人性别相异。

输入

第一行一个整数n（2<=n<=1000），表示学生人数。接下来的n行每行依次包含一名新

生的姓名、学号、性别，分别用一个空格隔开。

之后的一行是一个整数m(1<=m<=1000)，表示询问的数目。接着的m行每行包含两个

信息（姓名或学号），保证两个信息不属于同一人，中间用一个空格隔开。

输出

对于每个询问输出一行，如果两人可以共舞，输出一个大写字母‘Y’，否则输出一个大

写字母‘N’。

样例输入

4

John 10 M

Jack 11 M

Kate 20 F

Jim 21 M

3

John 11

20 Jack

Jim Jack

样例输出

N

Y

N

提示

可以把名字和学号都当成字符串处理。可以按以下流程实现。

#include

#include

using namespace std;

struct tstudent

{

char name[21];

char num[21];

char sex;

};

void readdata(tstudent student[], int n)

{

输入N个学生的信息

}

int findstudent(tstudent student[], int n, char* data)

{

if (data == NULL) return -1;

判断是否有某个学生的学号或名字等于data，如果有，函数返回该学生在student数组中的

序号，否则返回-1

}

void solve(tstudent student[], int n, int m)

{

char x[21], y[21];

for (int i=0; i

输入两个人的信息X、Y。通过调用findstudent函数判断这两个人能否成为舞伴

}

}

int main()

{

int n, m;

tstudent student[1010];

cin>>n;

readdata(student, n);

cin>>m;

solve(student, n, m);

}

参考代码：

import edReader;

import ption;

import treamReader;

public class Main {

static Stu[] stu ;

public static void main(String[] args) throws IOException {

BufferedReader br=new BufferedReader(new InputStreamReader());

int n=nt(ne());

stu=new Stu[n];

for(int i=0;i

String []str=ne().split(" ");

Stu tem=new Stu(str[0],str[1],str[2]);

stu[i]=tem;

}

int m=nt(ne());

String[][] str=new String[m][2];

for(int i=0;i

String []tem=ne().split(" ");

str[i][0]=tem[0];

str[i][1]=tem[1];

}

String[][] arr=new String[m][2];

for(int i=0;i

String tem1=str[i][0];

String tem2=str[i][1];

for(int p=0;p

if(stu[p].getStuID().equals(tem1)||stu[p].getStuName().equals(tem1)){

arr[i][0]=stu[p].getStuSex();

}

if(stu[p].getStuID().equals(tem2)||stu[p].getStuName().equals(tem2)){

arr[i][1]=stu[p].getStuSex();

}

}

}

for(int i=0;i

if(!arr[i][0].equals(arr[i][1])){

n("Y");

}else{

n("N");

}

}

}

}

class Stu{

String StuID;

String StuName;

String StuSex;

public Stu(String stuID, String stuName, String stuSex) {

super();

StuID = stuID;

StuName = stuName;

StuSex = stuSex;

}

public String getStuID() {

return StuID;

}

public String getStuName() {

return StuName;

}

public String getStuSex() {

return StuSex;

}

}

编号：ALGO-95

题目：2的次幂表示

关键字：

类型：普通试题

问题描述

任何一个正整数都可以用2进制表示，例如：137的2进制表示为10001001。

将这种2进制表示写成2的次幂的和的形式，令次幂高的排在前面，可得到如下表达式：

137=2^7+2^3+2^0

现在约定幂次用括号来表示，即a^b表示为a（b）

此时，137可表示为：2（7）+2（3）+2（0）

进一步：7=2^2+2+2^0 （2^1用2表示）

3=2+2^0

所以最后137可表示为：2（2（2）+2+2（0））+2（2+2（0））+2（0）

又如：1315=2^10+2^8+2^5+2+1

所以1315最后可表示为：

2（2（2+2（0））+2）+2（2（2+2（0）））+2（2（2）+2（0））+2+2（0）

输入格式

正整数（1<=n<=20000）

输出格式

符合约定的n的0，2表示（在表示中不能有空格）

样例输入

137

样例输出

2(2(2)+2+2(0))+2(2+2(0))+2(0)

样例输入

1315

样例输出

2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)

提示

用递归实现会比较简单，可以一边递归一边输出

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int number = f(ne());

toString(ryString(number));

}

private static void toString(String binary) {

char[] temp = Array();

boolean control = false;

for (int i = 0; i < ; i++) {

if (temp[i] == '1') {

if (control)

("+");

else

control = true;

("2");

int mi = - i - 1;

if (mi == 0)

("(0)");

else if (mi > 1) {

("(");

toString(ryString(mi));

(")");

}

}

}

}

}

编号：ALGO-96

题目：Hello World!

关键字：输出格式

类型：VIP试题

描述

本题定义本学期作业题的输出格式，请认真阅读。

如无特殊说明，开头无空格，间隔符为1个空格，答案最后必须输出换行符("n")。

输入格式

无

输出格式

Hello World!

参考代码：

public class Main{

public static void main(String[] args) {

n("Hello World!");

}

}

编号：ALGO-97

题目：排序

关键字：循环语句

类型：普通试题

问题描述

编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。

输入格式：输入只有一行，即三个整数，中间用空格隔开。

输出格式：输出只有一行，即排序后的结果。

输入输出样例

样例输入

9 2 30

样例输出

30 9 2

参考代码：

import .*;

import ;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader str=new BufferedReader(new InputStreamReader());

String s=ne();

String[] s1=(" ");

int n=;

int[] arr=new int[n];

for(int i=0;i

arr[i]=nt(s1[i]);

}

(arr);

for(int j=n-1;j>=0;j--){

(arr[j]+" ");

}

}

}

编号：ALGO-98

题目：数位分离

关键字：字符操作 循环语句

类型：VIP试题

问题描述

编写一个程序，输入一个1000 以内的正整数，然后把这个整数的每一位数字都分离出

来，并逐一地显示。

输入格式：输入只有一行，即一个1000以内的正整数。

输出格式：输出只有一行，即该整数的每一位数字，之间用空格隔开。

输入输出样例

样例输入

769

样例输出

7 6 9

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

char[] out = ne().toCharArray();

for (int i = 0; i < ; i++) {

if (i != - 1)

(out[i] + " ");

else

(out[i]);

}

}

}

编号：ALGO-99

题目：薪水计算

关键字：逻辑判断 数学知识

类型：VIP试题

问题描述

编写一个程序，计算员工的周薪。薪水的计算是以小时为单位，如果在一周的时间内，

员工工作的时间不超过40 个小时，那么他/她的总收入等于工作时间乘以每小时的薪水。

如果员工工作的时间在40 到50 个小时之间，那么对于前40 个小时，仍按常规方法计算；

而对于剩余的超额部分，每小时的薪水按1.5 倍计算。如果员工工作的时间超过了50 个小

时，那么对于前40 个小时，仍按常规方法计算；对于40～50 个小时之间的部分，每小时

的薪水按1.5 倍计算；而对于超出50 个小时的部分，每小时的薪水按2 倍计算。请编写一

个程序，输入员工的工作时间和每小时的薪水，然后计算并显示他/她应该得到的周薪。

输入格式：输入只有一行，包括一个整数和一个实数，分别表示工作时间和每小时薪水。

输出格式：输出只有一个实数，表示周薪，保留小数点后2位。

输入输出样例

样例输入

40 50

样例输出

2000.00

参考代码：

import imal;

import r;

public class Main {

public static void main(String[] args) {

Scanner sc=new Scanner();

String a=();

String b=();

double t= ouble(a);

double m= ouble(b);

double sum=0;

if(t==0||m==0)

n("0.00");

else

if(0

{

sum=t*m;

BigDecimal bd = new BigDecimal(sum);

bd = le(2,_HALF_UP);

n(bd);

}

else

if(t<=50)

{ sum=40*m+(t-40)*m*1.5;

BigDecimal bd = new BigDecimal(sum);

bd = le(2,_HALF_UP);

n(bd);

}

else

{

sum=40*m+10*1.5*m+(t-50)*m*2;

BigDecimal bd = new BigDecimal(sum);

bd = le(2,_HALF_UP);

n(bd);

}

}

}

编号：ALGO-100

题目：整除问题

关键字：循环语句 数学知识

类型：VIP试题

问题描述

编写一个程序，输入三个正整数min、max和factor，然后对于min到max之间的每一

个整数（包括min和max），如果它能被factor整除，就把它打印出来。

输入格式：输入只有一行，包括三个整数min、max和factor。

输出格式：输出只有一行，包括若干个整数。

输入输出样例

样例输入

1 10 3

样例输出

3 6 9

参考代码:

import edReader;

import treamReader;

public class Main {

public static void main(String args[])throws Exception{

BufferedReader br = new BufferedReader(new InputStreamReader());

String[] temp = ne().split(" ");

int min = nt(temp[0]), max = nt(temp[1]),

divi = nt(temp[2]);

for(int i=min; i<=max; i++)

if(i%divi==0)

(i+" ");

}

}

编号：ALGO-101

题目：图形显示

关键字：循环语句

类型：普通试题

问题描述：

编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示

行数）：

* * * * *

* * * *

* * *

* *

*

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int number = f(ne());

for (int i = 0; i < number; i++) {

for (int j = i; j < number; j++) {

if (i != number - 1)

("* ");

else

("*");

}

n();

}

}

}

编号：ALGO-102

题目：数对

关键字：循环语句 数学知识

类型：普通试题

问题描述：

编写一个程序，该程序从用户读入一个整数，然后列出所有的数对，每个数对的乘积即

为该数。

输入格式：输入只有一行，即一个整数。

输出格式：输出有若干行，每一行是一个乘法式子。（注意：运算符号与数字之间有一

个空格）

输入输出样例

样例输入

32

样例输出

1 * 32 = 32

2 * 16 = 32

4 * 8 = 32

8 * 4 = 32

16 * 2 = 32

32 * 1 = 32

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int number = nt(ne());

for (int i = 1; i <= number; i++) {

if(number%i==0)

n(i+" * "+number/i +" = "+number);

}

}

}

编号：ALGO-103

题目：完数

关键字：循环语句 数学知识

类型：普通试题

问题描述：

一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如，6的因子为1、2、

3，而6＝1＋2＋3，因此6就是“完数”。又如，28的因子为1、2、4、7、14，而28＝1＋

2＋4＋7＋14，因此28也是“完数”。编写一个程序，判断用户输入的一个数是否为“完数”。

输入格式：输入只有一行，即一个整数。

输出格式：输出只有一行，如果该数为完数，输出yes，否则输出no。

输入输出样例

样例输入

6

样例输出

yes

参考代码：

import edReader;

import treamReader;

public class Main {

public static Integer total=1;

public static void main(String[] args)throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

int x = nt(ne());

add(x);

if(x == total)n("yes");

else n("no");

}

public static void add(Integer x){

if(x == 1)total = 0;

int sqrt = (int)(x);

for(int i=2; i<=sqrt; i++){

if(x % i == 0){

total += i;

total += x/i;

}

}

}

}

编号：ALGO-104

题目：阿尔法乘积

关键字：字符操作 数学知识

类型：普通试题

问题描述：

计算一个整数的阿尔法乘积。对于一个整数x来说，它的阿尔法乘积是这样来计算的：

如果x是一个个位数，那么它的阿尔法乘积就是它本身；否则的话，x的阿尔法乘积就等于

它的各位非0的数字相乘所得到的那个整数的阿尔法乘积。例如：4018224312的阿尔法乘

积等于8，它是按照以下的步骤来计算的：

4018224312 → 4*1*8*2*2*4*3*1*2 → 3072 → 3*7*2 → 42 → 4*2 → 8

编写一个程序，输入一个正整数（该整数不会超过6,000,000），输出它的阿尔法乘积。

输入格式：输入只有一行，即一个正整数。

输出格式：输出相应的阿尔法乘积。

输入输出样例

样例输入

4018224312

样例输出

8

参考代码：

import edReader;

import treamReader;

public class Main{

public static void main(String[] args) throws Exception {

BufferedReader br = new BufferedReader(new InputStreamReader());

String number = ne();

if (("0"))

n(number);

else {

while (() > 1) {

int sum = 1;

char[] temp = Array();

for (int i = 0; i < ; i++) {

if (temp[i] == '0')

continue;

sum *= temp[i] - 48;

}

number = sum + "";

}

n(number);

}

}

}

编号：ALGO-105

题目：黑色星期五

关键字：逻辑判断 取余运算 循环语句

类型：普通试题

问题描述：

有些西方人比较迷信，如果某个月的13号正好是星期五，他们就会觉得不太吉利，用

古人的说法，就是“诸事不宜”。请你编写一个程序，统计出在某个特定的年份中，出现了

多少次既是13号又是星期五的情形，以帮助你的迷信朋友解决难题。

说明：（1）一年有365天，闰年有366天，所谓闰年，即能被4整除且不能被100整

除的年份，或是既能被100整除也能被400整除的年份；（2）已知1998年1月1日是星期

四，用户输入的年份肯定大于或等于1998年。

输入格式：输入只有一行，即某个特定的年份（大于或等于1998年）。

输出格式：输出只有一行，即在这一年中，出现了多少次既是13号又是星期五的情形。

输入输出样例

样例输入

1998

样例输出

3

参考代码：

import r;

public class Main {

public static boolean runnian(int year)

{

if((year%4==0&&year%100!=0)||(year%400==0))

return true;

else return false;

}

public static int total(int year)

{

int total=0;

int years=0;

int count=0;

if(year<2000)

years=(year-1998)*365;

else

years=(((year-2000)/4)+1)*366+(year-1998-(((year-2000)/4)+1))*365;

if(runnian(year))

years=((year-2000)/4)*366+(year-1998-((year-2000)/4))*365;

int mouth []=new int []{0,31,0,31,30,31,30,31,31,30,31,30,31};

if(runnian(year))

mouth[2]=29;

else mouth[2]=28;

for(int i=1;i<=12;i++)

{

if((years+mouth[i-1]+13-4)%7==5)

{

count++;

}

years=years+mouth[i-1];

}

return count;

}

public static void main(String[] args) {

Scanner in=new Scanner();

int year=t();

int i=total(year);

n(i);

}

}

编号：ALGO-106

题目：6-3判定字符位置

关键字：字符串操作

类型：普通试题

问题描述：

返回给定字符串s中元音字母的首次出现位置。英语元音字母只有‘a’、‘e’、‘i’、‘o’、

‘u’五个。

若字符串中没有元音字母，则返回0。

只考虑小写的情况。

样例输入

and

样例输出

1

参考代码：

import edReader;

import treamReader;

import ption;

public class Main{

/**

* @param args

*/

public static void main(String[] args)throws IOException {

// TODO Auto-generated method stub

BufferedReader br=new BufferedReader(new InputStreamReader());

String s=ne();

int n=();

char[] arr=new char[n];

}

}

String st="aeiou";

char[] brr=new char[5];

for(int i=0;i

arr[i]=(i);

}

for(int i=0;i<5;i++){

brr[i]=(i);

}

int count=0;

for(int i=0;i

for(int j=0;j<5;j++){

if(arr[i]==brr[j]){

count=i+1;

break;

}

}

if(count!=0){

(count);

break;

}

}

if(count==0){

(0);

}

编号：ALGO-107

题目：9-7链表数据求和操作

关键字：

类型：普通试题

问题描述：

读入10个复数，建立对应链表，然后求所有复数的和。

样例输入

1 2

1 3

4 5

2 3

3 1

2 1

4 2

2 2

3 3

1 1

样例输出

23+23i

参考代码：

import edReader;

import treamReader;

public class Main {

public static void main(String args[])throws Exception{

BufferedReader br = new BufferedReader(new InputStreamReader());

int shibu=0, xubu=0;

String[] temp;

for(int i=0; i<10; i++){

temp = ne().split(" ");

shibu += nt(temp[0]);

xubu += nt(temp[1]);

}

if(xubu==0)

n(shibu);

else if(shibu==0)

n(xubu);

else

n(shibu+"+"+xubu+"i");

}

}

编号：ALGO-108

题目：最大体积

关键字：g背包

类型：普通试题

问题描述：

每个物品有一定的体积（废话），不同的物品组合，装入背包会战用一定的总体积。假

如每个物品有无限件可用，那么有些体积是永远也装不出来的。为了尽量装满背包，附中的

OIER想要研究一下物品不能装出的最大体积。题目保证有解，如果是有限解，保证不超过2，

000，000，000

如果是无限解，则输出0

输入格式

第一行一个整数n（n<=10），表示物品的件数

第2行到N+1行: 每件物品的体积(1<= <=500)

输出格式

一个整数ans，表示不能用这些物品得到的最大体积。

样例输入

3

3

6

10

样例输出

17

参考代码：

import r;

public class Main {

public static void main(String[] args) {

Scanner sc=new Scanner();

int n=t();

int s[]=new int[n];

for(int i=0;i

s[i]=t();

int t=s[0];

for(int i=0;i

t=func(t,s[i]);

t=func(t,s[n-1]);

if(t!=1){

n(0);

return;

}

int dp[]=new int[_VALUE/1000];

for(int i=0;i

dp[s[i]]=1;

for(int i=0;i<;i++){

if(dp[i]==i)

continue;

for(int j=0;j

if(s[j]>i)

continue;

dp[i]=(dp[i-s[j]],dp[i]);

if(dp[i]==1)

break;

}

}

for(int i=-1;i>=0;i--){

if(dp[i]==0){

n(i);

return;

}

}

}

n(0);

}

public static int func(int a,int b){

if(a

int temp=a;

a=b;

b=temp;

}

while(b!=0){

int temp=a%b;

a=b;

b=temp;

}

return a;

}

编号：ALGO-109

题目：貌似化学

关键字：g背包

类型：普通试题

问题描述：

现在有a,b,c三种原料，如果他们按x:y:z混合，就能产生一种神奇的物品d。

当然不一定只产生一份d，但a,b,c的最简比一定是x:y:z

现在给你3种可供选择的物品:

每个物品都是由a,b,c以一定比例组合成的，求出最少的物品数，使得他们能凑出整数

个d物品（这里的最少是指三者个数的总和最少）

输入格式

第一行三个整数，表示d的配比（x,y,z）

接下来三行，表示三种物品的配比，每行三个整数（<=10000）。

输出格式

四个整数，分别表示在最少物品总数的前提下a,b,c,d的个数（d是由a,b,c配得的）

目标答案<=10000

如果不存在满足条件的方案，输出NONE

样例输入

3 4 5

1 2 3

3 7 1

2 1 2

样例输出

8 1 5 7

参考代码：

该题暂时没有人完全正确，暂时没有该语言的参考程序。

编号：ALGO-110

题目：字符串的展开

关键字：字符串的处理 模拟

类型：普通试题

问题描述：

人类终于登上了火星的土地并且见到了神秘的火星人。人类和火星人都无法理解对方的

语言，但是我们的科学家发明了一种用数字交流的方法。这种交流方法是这样 的，首先，

火星人把一个非常大的数字告诉人类科学家，科学家破解这个数字的含义后，再把一个很小

的数字加到这个大数上面，把结果告诉火星人，作为人类的回 答。

在初赛普及组的“阅读程序写结果”的问题中，我们曾给出一个字符串展开的例子：如

果在输入的字符串中，含有类似于“d-h”或者“4-8”的字串，我们就把它当作一种简写，

输出时，用连续递增的字母获数字串替代其中的减号，即，将上面两个子串分别输出为“defgh”

和“45678”。在本题中，我们通过增加一些参数的设置，使字符串的展开更为灵活。具体约

定如下：

(1) 遇到下面的情况需要做字符串的展开：在输入的字符串中，出现了减号“-”，减号

两侧同为小写字母或同为数字，且按照ASCII码的顺序，减号右边的字符严格大于左边的字

符。

(2) 参数p1：展开方式。p1=1时，对于字母子串，填充小写字母；p1=2时，对于字母

子串，填充大写字母。这两种情况下数字子串的填充方式相同。p1=3时，不论是字母子串

还是数字字串，都用与要填充的字母个数相同的星号“*”来填充。

(3) 参数p2：填充字符的重复个数。p2=k表示同一个字符要连续填充k个。例如，当

p2=3时，子串“d-h”应扩展为“deeefffgggh”。减号两边的字符不变。

(4) 参数p3：是否改为逆序：p3=1表示维持原来顺序，p3=2表示采用逆序输出，注意

这时候仍然不包括减号两端的字符。例如当p1=1、p2=2、p3=2时，子串“d-h”应扩展为

“dggffeeh”。

(5) 如果减号右边的字符恰好是左边字符的后继，只删除中间的减号，例如：“d-e”应

输出为“de”，“3-4”应输出为“34”。如果减号右边的字符按照ASCII码的顺序小于或等于

左边字符，输出时，要保留中间的减号，例如：“d-d”应输出为“d-d”，“3-1”应输出为“3-1”。

输入格式

输入包括两行：

第1行为用空格隔开的3个正整数，一次表示参数p1，p2，p3。

第2行为一行字符串，仅由数字、小写字母和减号“-”组成。行首和行末均无空格。

输出格式

输出只有一行，为展开后的字符串。

输入输出样例1

输入

输出

1 2 1

abcs-w1234-9s-4zz

abcsttuuvvw89s-4zz

输入输出样例2

输入

输出

2 3 2

a-d-d

aCCCBBBd-d

输入输出样例3

输入

输出

3 4 2

di-jkstra2-6

dijkstra2************6

数据规模和约定

40%的数据满足：字符串长度不超过5

100%的数据满足：1<=p1<=3，1<=p2<=8，1<=p3<=2。字符串长度不超过100

参考代码：

import edReader;

import ption;

import treamReader;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader br=new BufferedReader(new InputStreamReader());

String [] str1=ne().split(" ");

char [] chr=ne().toCharArray();

int p1=nt(str1[0]);

int p2=nt(str1[1]);

int p3=nt(str1[2]);

StringBuffer sb=new StringBuffer();

for(int i=0;i<;i++){

if(chr[i]=='-'&&i>0&&i<-1&&chr[i+1]!='-'&&chr[i-1]!='-'){

int tem1=(int)chr[i-1];

int tem2=(int) chr[i+1];

if(((tem1-tem2))>32){

(chr[i]);

continue;

}

if(tem1>=tem2){

(chr[i]);

i++;

}else if(tem2-tem1==1){

(chr[i+1]);

i++;

continue;

}else{

StringBuffer sbTem=new StringBuffer();

if(p1==1){

for(int j=tem1+1;j

char chrTem=(char)j;

for(int x=0;x

(chrTem);

}

}

}else if(p1==2){

for(int j=tem1+1;j

if(j>=97){

char chrTem=(char)(j-32);

for(int x=0;x

(chrTem);

}

}else if(j>=48&&j<=57){

int tem=j-48;

for(int x=0;x

(tem);

}

}

}

}

}

}else if(p1==3){

for(int j=tem1+1;j

char chrTem='*';

for(int x=0;x

(chrTem);

}

}

}

if(p3==2){

(e());

}else{

(sbTem);

}

i++;

}

}

(chr[i]);

}

n(ng());

111、明明的随机数

问题描述

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生

成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其

余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照

排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。

输入格式

输入有2行，第1行为1个正整数，表示所生成的随机数的个数：

N

第2行有N个用空格隔开的正整数，为所产生的随机数。

输出格式

输出也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个

用空格隔开的正整数，为从小到大排好序的不相同的随机数。

样例输入

10

20 40 32 67 40 20 89 300 400 15

样例输出

8

15 20 32 40 67 89 300 400

题目来源

计13李震摘编自NOIP06PJ01

Java参考代码如下：

import edReader;

import ption;

import treamReader;

import ist;

import ;

public class Main {

public static void main(String[] args) throws NumberFormatException, IOException {

// TODO Auto-generated method stub

BufferedReader br =new BufferedReader(new InputStreamReader());

int n=nt(ne());

int[] arr =new int[n];

String[] strTem=ne().split(" ");

for(int i=0;i

arr[i]=nt(strTem[i]);

}

ArrayList arrList=new ArrayList();

(arr[0]);

for(int i=1;i

for(int j=0;j<();j++){

if(arr[i]==(j))

break;

if(arr[i]!=(j)&&j==()-1){

(arr[i]);

}

}

}

int num=();

n(num);

int[] tem=new int[num];

for(int i=0;i

tem[i]=(i);

}

(tem);

for(int i=0;i

(tem[i]+" ");

}

}

}

112、暗恋

问题描述

同在一个高中，他却不敢去找她，虽然在别人看来，那是再简单不过的事。暗恋，是他

唯一能做的事。他只能在每天课间操的时候，望望她的位置，看看她倾心的动作，就够了。

操场上的彩砖啊，你们的位置，就是他们能够站立的地方，他俩的关系就像砖与砖之间一样

固定，无法动摇。还记得当初铺砖的工人，将整个操场按正方形铺砖（整个操场可视为R

行C列的矩阵，矩阵的每个元素为一块正方形砖块），正方形砖块有两种，一种为蓝色，另

一种为红色。我们定义他和她之间的“爱情指标”为最大纯色正方形的面积，请你写一个程

序求出“爱情指标”。

输入格式

第一行两个正整数R和C。

接下来R行C列描述整个操场，红色砖块用1来表示，蓝色砖块用0来表示。

输出格式

一个数，表示他和她之间的“爱情指标”。

样例输入

5 8

0 0 0 1 1 1 0 1

1 1 0 1 1 1 1 1

0 1 1 1 1 1 0 1

1 0 1 1 1 1 1 0

1 1 1 0 1 1 0 1

样例输出

9

数据规模和约定

40%的数据R,C<=10;

70%的数据R,C<=50;

100%的数据R,C<=200;

Java参考代码如下：

import edReader;

import ption;

import treamReader;

import Tokenizer;

public class Main {

private static int x, y;

private static int arr[][] = new int[205][205];

private static int max = 0, p, q;

public static void main(String[] args) throws IOException {

StreamTokenizer st = new StreamTokenizer(new

InputStreamReader()));

ken();

x = (int) ;

ken();

y = (int) ;

for (int i = 1; i <= x; i++) {

for (int j = 1; j <= y; j++) {

ken();

arr[i][j] = (int) ;

}

}

for (int i = 1; i <= x; i++) {

for (int j = 1; j <= y; j++) {

baosou(i, j, arr[1][i], 1);

}

}

boolean is = false;

q = q - max;

for (int i = p; i > p - max; i--) {

if (arr[p][q] != arr[p - 1][q]) {

is = true;

break;

}

}

if (is)

max -= 1;

n(max * max);

}

private static void baosou(int a, int b, int c, int d) {

if (a >= x || b >= y) {

if (max < d) {

p = a;

q = b;

max = d;

}

return;

BufferedReader(new

}

}

}

if (arr[a + 1][b] == c && arr[a][b + 1] == c && arr[a + 1][b + 1] == c) {

baosou(a + 1, b + 1, c, d + 1);

} else {

if (max < d) {

max = d;

p = a;

q = b;

}

return;

}

113、数的统计

问题描述

在一个有限的正整数序列中，有些数会多次重复出现在这个序列中。

如序列：3，1，2，1，5，1，2。其中1就出现3次，2出现2次，3出现1 次，5出

现1次。

你的任务是对于给定的正整数序列，从小到大依次输出序列中出现的数及出现的次数。

输入格式

第一行正整数n，表示给定序列中正整数的个数。

第二行是n 个用空格隔开的正整数x，代表给定的序列。

输出格式

若干行，每行两个用一个空格隔开的数，第一个是数列中出现的数，第二个是该数在序

列中出现的次数。

样例输入

12

8 2 8 2 2 11 1 1 8 1 13 13

样例输出

1 3

2 3

8 3

11 1

13 2

数据规模和约定

数据：n<=1000；0

Java参考代码如下：

import edReader;

import ption;

import treamReader;

import Tokenizer;

import ist;

import tions;

import HashMap;

import ;

public class Main {

public static void main(String[] args) throws IOException {

StreamTokenizer st = new StreamTokenizer(new BufferedReader(

new InputStreamReader()));

ken();

int n = (int) ;

Map map = new LinkedHashMap();

int m;

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

ken();

m = (int) ;

if (nsKey(m))

(m, (m) + 1);

else

(m, 1);

}

ArrayList list = new ArrayList();

(());

(list);

int key;

for (int i = 0; i < (); i++) {

key = (i);

n(key + " " + (key));

}

}

}

114、黑白无常 问题描述

某寝室的同学们在学术完之后准备玩一个游戏：游戏是这样的，每个人头上都被贴了一

张白色或者黑色的纸，现在每个人都会说一句话“我看到x张白色纸条和y张黑色的纸条”，

又已知每个头上贴着白色纸的人说的是真话、每个头上贴着黑色纸的人说的是谎话，现在要

求你判断哪些人头上贴着的是白色的纸条，如果无解输出“NoSolution.”；如果有多组解，

则把每个答案中贴白条的人的编号按照大小排列后组成一个数（比如第一个人和第三个人头

上贴着的是白纸条，那么这个数就是13；如果第6、7、8个人都贴的是白纸条，那么这个

数就是678）输出最小的那个数（如果全部都是黑纸条也满足情况的话，那么输出0）

输入格式

第一行为一个整数n，接下来n行中的第i行有两个整数x和y，分别表示第i个人说“我

看到x张白色纸条和y张黑色的纸条”。

输出格式

一行。如果无解输出“NoSolution.”。否则输出答案中数值（具体见问题描述）最小的

那个，如果全部都是黑纸条也满足情况的话，那么输出0

样例输入

2

1 0

1 0

样例输出

0

样例输入

5

3 1

0 4

1 3

4 0

1 3

样例输出

35

数据规模和约定

n<=8

Java参考代码如下：

import r;

public class Main{

public static void main(String args[]) {

Scanner scanner = new Scanner();

int[][] xy;

int n, x, y;

n = t();

xy = new int[n + 1][2];

for (int i = 1; i < n + 1; i++) {

xy[i][0] = t();

xy[i][1] = t();

}

String[] result = new String[n + 1];

int flag = 1;

for (int i = 1; i < n + 1; i++) {

// 是否为全黑标志位

if (xy[i][0] == 0 && xy[i][1] == n - 1)

flag = 0;

result[i] = "" + i;

for (int a = 1; a < n + 1; a++) {

if(a == i)continue ;

if (xy[i][0] == xy[a][0] && xy[i][1] == xy[a][1]) {

if(xy[i][0] == 0){

result[0] = a

}

if (result[i].length() < (xy[i][0]+1))

result[i] = result[i] + a;

}

}

}

if (flag == 1) {

n(0);

} else {

int temp = 100000000;

for (int i = 1; i <= n; i++) {

if (result[i].length() > 1) {

if(temp != 100000000 && f(temp).length() <

result[i].length()){

temp = nt(result[i]) ;

}else{

temp = temp > nt(result[i]) ? Integer

.parseInt(result[i]) : temp;

}

}

}

if (temp != 100000000) {

n(temp);

} else if(result[0] != null){

n(result[0]) ;

}else{

n("NoSolution.") ;

}

}

}

}

115、和为T

问题描述

从一个大小为n的整数集中选取一些元素，使得它们的和等于给定的值T。每个元素限

选一次，不能一个都不选。

输入格式

第一行一个正整数n，表示整数集内元素的个数。

第二行n个整数，用空格隔开。

第三行一个整数T，表示要达到的和。

输出格式

输出有若干行，每行输出一组解，即所选取的数字，按照输入中的顺序排列。

若有多组解，优先输出不包含第n个整数的；若都包含或都不包含，优先输出不包含第

n-1个整数的，依次类推。

最后一行输出总方案数。

样例输入

5

-7 -3 -2 5 9

0

样例输出

-3 -2 5

-7 -2 9

2

数据规模和约定

1<=n<=22

T<=maxlongint

集合中任意元素的和都不超过long的范围

Java参考代码如下：

import r;

public class Main {

int[] A;

int n; long sum;

int count=0;

boolean[] Mark;

void Search(int k, long S)

{

if(k>0) Search(k-1,S);

if(S-A[k]==0)

{

(A[k]+" ");

for(int i=k+1;i

if(Mark[i]==true) (A[i]+" ");

n();

count++;

//return;

}

Mark[k]=true;

if(k>0) Search(k-1,S-A[k]);

Mark[k]=false;

}

public Main() {

Scanner sc=new Scanner();

n=t();

A=new int[n]; Mark=new boolean[n];

for(int i=0;i

sum=ng();

Search(n-1,sum);

n(count);

}

public static void main(String[] args) {

Main st=new Main();

}

}

116、最大的算式

问题描述

题目很简单，给出N个数字，不改变它们的相对位置，在中间加入K个乘号和N-K-1

个加号，（括号随便加）使最终结果尽量大。因为乘号和加号一共就是N-1个了，所以恰好

每两个相邻数字之间都有一个符号。例如：

N=5，K=2，5个数字分别为1、2、3、4、5，可以加成：

1*2*(3+4+5)=24

1*(2+3)*(4+5)=45

(1*2+3)*(4+5)=45

……

输入格式

输入文件共有二行，第一行为两个有空格隔开的整数，表示N和K，其中（2<=N<=15,

0<=K<=N-1）。第二行为 N个用空格隔开的数字（每个数字在0到9之间）。

输出格式

输出文件仅一行包含一个整数，表示要求的最大的结果

样例输入

5 2

1 2 3 4 5

样例输出

120

样例说明

(1+2+3)*4*5=120

Java参考代码如下：

import r;

public class Main {

public static void main(String[] args) {

Scanner sc = new Scanner();

int n = t(), k = t();

long temp;

long[][] arr = new long[n][k + 1];

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

arr[i][0] = t() + (i > 0 ? arr[i - 1][0] : 0);

}

();

for(int a = 1; a < n; a++) {

for(int b = 1; b <= k; b++) {

for(int c = 0; c < a; c++) {

temp = arr[a][0] - arr[c][0];

arr[a][b] = (arr[c][b - 1] * temp, arr[a][b]);

}

}

}

n(arr[n - 1][k]);

}

}

117、友好数

问题描述

有两个整数，如果每个整数的约数和（除了它本身以外）等于对方，我们就称这对数是

友好的。例如：

9的约数和有：1+3=4

4的约数和有：1+2=3

所以9和4不是友好的。

220的约数和有：1 2 4 5 10 11 20 22 44 55 110=284

284的约数和有：1 2 4 71 142=220

所以220和284是友好的。

编写程序，判断两个数是否是友好数。

输入格式

一行，两个整数，由空格分隔

输出格式

如果是友好数，输出"yes"，否则输出"no"，注意不包含引号。

样例输入

220 284

样例输出

yes

数据规模和约定

两个整数都小于10000

Java参考代码如下

import r;

public class Main {

static int Get(int n)

{

int sum=1;

for(int i=2;i

if(n%i==0) sum+=i;

return sum;

}

public static void main(String[] args) {

Scanner sc=new Scanner();

int m=t(),n=t();

if(Get(m)==n && Get(n)==m)

n("yes");

else n("no");

}

}

118、连续正整数的和

问题描述

78这个数可以表示为连续正整数的和，1+2+3，18+19+20+21，25+26+27。

输入一个正整数 n(<=10000)

输出 m 行(n有m种表示法)，每行是两个正整数a，b，表示a+(a+1)+...+b=n。

对于多种表示法，a小的方案先输出。

样例输入

78

样例输出

1 12

18 21

25 27

Java参考代码如下：

import r;

public class Main {

public static void main(String[] args){

Scanner sn = new Scanner();

int n = t();

for(int x = 1;x<=n;x++){

int sum = x;

for(int y = x+1;y<=n;y++){

sum = sum+y;

if(sum==n){

n(x+" "+y);

}else if(sum>n){

break;

}

}

}

}

}

119、寂寞的数

问题描述

道德经曰：一生二，二生三，三生万物。

对于任意正整数n，我们定义d(n)的值为为n加上组成n的各个数字的和。例如，

d(23)=23+2+3=28, d(1481)=1481+1+4+8+1=1495。

因此，给定了任意一个n作为起点，你可以构造如下一个递增序列：

n,d(n),d(d(n)),d(d(d(n)))....例如，从33开始的递增序列为：

33, 39, 51, 57, 69, 84, 96, 111, 114, 120, 123, 129, 141, ...

我们把n叫做d(n)的生成元，在上面的数列中，33是39的生成元，39是51的生成元，

等等。有一些数字甚至可以有两个生成元，比如101，可以由91和100生成。但也有一些

数字没有任何生成元，如42。我们把这样的数字称为寂寞的数字。

输入格式

一行，一个正整数n。

输出格式

按照升序输出小于n的所有寂寞的数字，每行一个。

样例输入

40

样例输出

1

3

5

7

9

20

31

数据规模和约定

n<=10000

Java参考代码如下：

import r;

public class Main {

public static void main(String[] args) {

boolean[] a = new boolean[10001];

for(int i=1; i<10000; i++){

int temp = i;

int result = temp;

while(temp>0){

result += temp%10;

temp /= 10;

}

if(result<10001 && !a[result]){

a[result] = true;

}

}

Scanner sc = new Scanner();

int n = t();

for(int i=1; i

if(!a[i]){

n(i);

}

}

}

}

120、学做菜

问题描述

涛涛立志要做新好青年，他最近在学做菜。由于技术还很生疏，他只会用鸡蛋，西红柿，

鸡丁，辣酱这四种原料来做菜，我们给这四种原料标上字母A,B,C,D。

涛涛现在会做的菜有五种：

1、 西红柿炒鸡蛋 原料：AABDD

2、 酸辣鸡丁 原料：ABCD

3、 宫保鸡丁 原料：CCD

4、 水煮西红柿 原料：BBB

5、 怪味蛋 原料：AD

这天早上，开开去早市给涛涛买了一些原料回来。由于事先没有什么计划，涛涛决定，

对于现存的原料，每次尽量做菜单上靠前（即编号小）的菜。

现在请你写一个程序，判断一下开开和涛涛中午能吃到哪些菜。

输入格式

共4个整数a,b,c,d。分别表示开开买的A,B,C,D这4种原料的数量。每种原料不会超过

30份。

输出格式

输出5行。其中第i行表示涛涛做的第i种菜的数目。

样例输入

3

1

2

4

样例输出

1

0

1

0

1

Java参考代码如下：

import r;

public class Main {

Scanner sc;

int a,b,c,d;

public static void main(String[] args) {

// TODO Auto-generated method stub

new Main();

}

public Main(){

sc=new Scanner();

a=t();

b=t();

c=t();

d=t();

dish(a,b,c,d);

}

public void dish(int a,int b,int c,int d){

int i;

for(i=1;(a>=2)&&(b>=1)&&(d>=2);i++){

a=a-2;--b;d=d-2;

}

n(i-1);

for(i=1;(a>=1)&&(b>=1)&&(c>=1)&&(d>=1);i++){

--a;--b;--c;--d;

}

n(i-1);

for(i=1;(d>=1)&&(c>=2);i++){

c=c-2;--d;

}

n(i-1);

for(i=1;b>=3;i++){

b=b-3;

}

}

}

n(i-1);

for(i=1;(a>=1)&&(d>=1);i++){

--a;--d;

}

n(i-1);

编号：ALGO-121

题目：猴子分苹果

关键字：递推

类型：VIP试题

问题描述

秋天到了，n只猴子采摘了一大堆苹果放到山洞里，约定第二天平分。这些猴子很崇拜

猴王孙悟空，所以都想给他留一些苹果。第一只猴子悄悄来到山洞，把苹果平均分成n份，

把剩下的m个苹果吃了,然后藏起来一份，最后把剩下的苹果重新合在一起。这些猴子依次

悄悄来到山洞，都做同样的操作，恰好每次都剩下了m个苹果。第二天，这些猴子来到山

洞，把剩下的苹果分成n分，巧了，还是剩下了m个。问，原来这些猴子至少采了多少个

苹果。

输入格式

两个整数，n m

输出格式

一个整数，表示原来苹果的数目

样例输入

5 1

样例输出

15621

数据规模和约定

0

参考代码

import r;

public class Main{

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner in = new Scanner();

int n = t() , m = t() ;

for(int i = 0 ; ; i++){

int s = i * n + m , j = 0;

for( ; j < n; j ++){

if(s % (n - 1) != 0 ){

break;

}

s = s * n / (n -1 ) + m;

}

if(j == n){

n(s);

break;

}

}

}

}

编号：ALGO-122

题目：未名湖边的烦恼

关键字：递归 递推

类型：VIP试题

问题描述

每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多

了，每天下午收工后，常常一双冰鞋都不剩。

每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的

问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样

需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）

输入格式

两个整数，表示m和n

输出格式

一个整数，表示队伍的排法的方案数。

样例输入

3 2

样例输出

5

数据规模和约定

m,n∈［0,18］

问题分析

参考代码

import r;

public class Main {

public static long f(long m, long n){

if(m

return 0;

else if(n==0)

return 1;

else

return f(m-1, n) + f(m, n-1);

}

public static void main(String[] args) {

Scanner sc = new Scanner();

int m = t();

int n = t();

n(f(m, n));

}

}

编号：ALGO-123

题目：A+B problem

类型：VIP试题

问题描述

Given two integers A and B, your task is to output their sum, A+B.

输入格式

The input contains of only one line, consisting of two integers A and B. (0 ≤ A,B ≤ 1 000)

输出格式

The output should contain only one number that is A+B.

样例输入

1 1

样例输出

2

参考代码

import .*;

public class Main{

public static void main(String[] args) throws Exception{

BufferedReader reader=new BufferedReader(new InputStreamReader());

String string =null;

string=ne();

String string2[]=(" ");

int a=nt(string2[0]);

int b=nt(string2[1]);

();

n(a+b);

}

}

编号：ALGO-124

题目：数字三角形

类型：VIP试题

问题描述

（图３.１－１）示出了一个数字三角形。 请编一个程序计算从顶至底的某处的一条路

径，使该路径所经过的数字的总和最大。

●每一步可沿左斜线向下或右斜线向下走；

●1＜三角形行数≤100；

●三角形中的数字为整数0，1，…99；

.

（图３.１－１）

输入格式

文件中首先读到的是三角形的行数。

接下来描述整个三角形

输出格式

最大总和（整数）

样例输入

5

7

3 8

8 1 0

2 7 4 4

4 5 2 6 5

样例输出

30

参考代码

import r;

public class Main {

public static void main(String[] args) {

int n;

Scanner s = new Scanner();

n = t();

int[][] a = new int[n][n];

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

for (int j = 0; j <= i; j++) {

a[i][j] = t();

}

}

for(int i = n - 1; i >= 0; i--)

for(int j = 0; j <= i; j++)

getBest(a, i, j);

n(a[0][0]);

}

static void getBest(int[][] arr, int i, int j) {

if (i == - 1) //if it's the last line

return;

else{

arr[i][j] = getMax(arr[i][j] + arr[i + 1][j], arr[i][j] + arr[i + 1][j + 1]);

}

}

static int getMax(int n1, int n2) {

if (n1 > n2)

return n1;

else

return n2;

}

}

编号：ALGO-125

题目：王、后传说

关键字：回溯 递归

类型：VIP试题

问题描述

地球人都知道，在国际象棋中，后如同太阳，光芒四射，威风八面，它能控制横、坚、

斜线位置。

看过清宫戏的中国人都知道，后宫乃步步惊心的险恶之地。各皇后都有自己的势力范围，

但也总能找到相安无事的办法。

所有中国人都知道，皇权神圣，伴君如伴虎，触龙颜者死......

现在有一个n*n的皇宫，国王占据他所在位置及周围的共9个格子，这些格子皇后不

能使用（如果国王在王宫的边上，占用的格子可能不到9个）。当然，皇后也不会攻击国王。

现在知道了国王的位置（x,y）（国王位于第x行第y列，x,y的起始行和列为1），请问，

有多少种方案放置n个皇后，使她们不能互相攻击。

输入格式

一行，三个整数，皇宫的规模及表示国王的位置

输出格式

一个整数，表示放置n个皇后的方案数

样例输入

8 2 2

样例输出

10

数据规模和约定

n<=12

参考代码

import r;

public class Main {

static int count=0;

public static boolean king(int k ,int x,int y,int a[]){

if((k-x)<=1&&(a[k]-y)<=1)

return false;

return true;

}

public static boolean position_ok(int k,int a[],int x,int y){

for(int i=0;i

if(a[i]==a[k]||(a[i]-a[k])==(i-k))

return false;

if(king(k,x,y,a)==false)

return false;

return true;

}

public static void set(int k,int a[],int x,int y){

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

{

a[k]=i;

if(position_ok(k,a,x,y))

{if(k==-1)

{

count++;

}

else

set(k+1,a,x,y);

}

}

}

public static void main(String[] args) {

Scanner sc=new Scanner();

}

}

int n=t();

int x=t();

int y=t();

int a[]=new int [n];

();

set(0,a,x-1,y-1);

n(count);

编号：ALGO-126

题目：水仙花

关键字：判断 分支

类型：VIP试题

问题描述

判断给定的三位数是否 水仙花 数。所谓 水仙花 数是指其值等于它本身 每位数字立

方和的数。例 153 就是一个 水仙花 数。 153=13+53+33

输入格式

一个整数。

输出格式

是水仙花数,输出"YES",否则输出"NO"(不包括引号)

样例输入

123

样例输出

NO

数据规模和约定

一个三位的整数,否则输出"NO"

参考代码

import r;

public class Main{

public static void main(String[] args) {

Scanner in = new Scanner();

int n = t();

String s = method(n);

n(s);

}

private static String method(int n) {

int a = n % 10;

int m = n / 10;

int b = m % 10;

int c = m / 10;

if (n == a * a * a + b * b * b + c * c * c) {

}

}

return "YES";

}

return "NO";

编号：ALGO-127

题目：C*++ Calculations

关键字：字符串处理 贪心

类型：VIP试题

问题描述

C*++语言和C++语言非常相似，然而C*++的程序有时会出现意想不到的结果。比如像

这样的算术表达式：

表达式=基本式 / 表达式+基本式 / 表达式-基本式

基本式=增量 / 系数*增量

增量=a++ / ++a

系数=0/1/2/……/1000

如“5*a++-3*++a+a++”是合法的C*++表达式。

计算这样的表达式的值的方法：首先是每个基本式进行计算，然后按照正常的算术运算

法则计算。如果一个基本式包含“a++”，则先进行乘法运算再使变量a权值+1；如果一个基

本式包含“++a”，则先使变量a权值+1再进行乘法运算。

然而基本式可以按任意顺序计算，这就是为什么计算结果是完全无法预料的。

你的任务就是去找到最大的可能结果。

第一行，一个整数n，表示变量a的初始值。

第二行，一个合法的C*++表达式。