蓝桥杯java历年真题及答案整理(共129道题目及答案)

35.圆周率与级数

我国古代数学家对圆周率方面的研究工作，成绩是突出的。三国时期的刘徽、南北朝时期的祖冲之都在这个领域取

得过辉煌战绩。

有了计算机，圆周率的计算变得十分容易了。如今，人们创造了上百种方法求π的值。其中比较常用且易于编程的

是无穷级数法。

π/4 = 1 – 1/3 + 1/5 – 1/7 + 1/9 - …

是初学者特别喜欢的一个级数形式，但其缺点是收敛太慢。

π/2 = 1 + 1/3 +1/3*2/5 + 1/3*2/5*3/7 + 1/3*2/5*3/7*4/9 + …

是收敛很快的一个级数方法。下面的代码演示了用这种方法计算π值。请填写缺失的代码部分。

把填空的答案（仅填空处的答案，不包括题面）存入考生文件夹下对应题号的“解答.txt”中即可。

publicclassDemo01 {

}

publicstaticvoid main(String[] args){

}

double x = 1;

double y = 1;

int a = 1;

int b = 3;

while(y>1e-15){

}

n(x*2);

y = y*a/b; // 填空

x += y;

a++;

b += 2;

36.最大5个数（测量到的工程数据）

[12,127,85,66,27,34,15,344,156,344,29,47,....]

这是某设备测量到的工程数据。

因工程要求，需要找出最大的5个值。

一般的想法是对它排序，输出前5个。但当数据较多时，这样做很浪费时间。

因为对输出数据以外的数据进行排序并非工程要求，即便是要输出的5个数字，

也并不要求按大小顺序，只要找到5个就可以。

以下的代码采用了另外的思路。考虑如果手里已经抓着5个最大数，再来一个数据怎么办呢？

让它和手里的数据比，如果比哪个大，就抢占它的座位，让那个被挤出来的再自己找位子,....

请分析代码逻辑，并推测划线处的代码。

答案写在“解答.txt”文件中

注意：只写划线处应该填的内容，划线前后的内容不要抄写。

import .*;

publicclassDemo11_B23 {

publicstatic List max5(List lst) {

if (() <= 5)

100

}

}

return lst;

int a = (() - 1); // 填空

List b = max5(lst);

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

}

return b;

int t = (i);

if (a > t) {

}

(i, a); // 填空

a = t;

publicstaticvoid main(String[] args) {

}

List lst = new Vector();

((12, 127, 85, 66, 27, 34, 15, 344, 156, 344,

29, 47));

n(max5(lst));

运行结果：

[344, 344, 156, 127, 85]

37.祖冲之割圆法

南北朝时，我国数学家祖冲之首先把圆周率值计算到小数点后六位，比欧洲早了1100年！

他采用的是称为“割圆法”的算法，实际上已经蕴含着现代微积分的思想。

如图【】所示，圆的内接正六边形周长与圆的周长近似。

多边形的边越多，接近的越好！我们从正六边形开始割圆吧。

如图【】所示，从圆心做弦的垂线，可把6边形分割为12边形。

101

该12边形的边长a'的计算方法很容易利用勾股定理给出。

之后，再分割为正24边形，....如此循环会越来越接近圆周。

之所以从正六边开始，是因为此时边长与半径相等，便于计算。取半径值为1，开始割圆吧！

以下代码描述了割圆过程。

程序先输出了标准圆周率值，紧接着输出了不断分割过程中多边形边数和所对应的圆周率逼近值。

publicclassDemo10_B21

{

}

publicstaticvoid main(String[] args)

{

}

n("标准 " + );

double a = 1;

int n = 6;

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

{

double b = (1-(a/2)*(a/2));

a = ((1-b)*(1-b) + (a/2)*(a/2));

n = n*2; //填空

n(n + " " + n*a/2 ); // 填空

}

运行结果：

标准 3.9793

12 3.149

24 3.12378

48 3.13935

96 3.141

192 3.54624

384 3.1858

768 3.83186

1536 3.14159

3072 3.92717

102

6144 3.21577

38.奇怪的比赛（低碳生活大奖赛）

某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：

每位选手需要回答10个问题（其编号为1到10），越后面越有难度。

答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。

每位选手都有一个起步的分数为10分。

某获胜选手最终得分刚好是100分，如果不让你看比赛过程，

你能推断出他（她）哪个题目答对了，哪个题目答错了吗？

如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和0的串来表示。

例如： 就是可能的情况。

你的任务是算出所有可能情况。每个答案占一行。

package Question40_49;

publicclass Question41 {

publicstaticvoid exeForward(int question[],int index,int sum,int needSum) {

}

publicstaticvoid main(String[] args) {

intneedSum=100;

int question[]=newint[12];

exeForward(question, 1, 10, 100);

103

if(index<=10){

}

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

}

if(sum==needSum){

}

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

}

n();

return;

return;

(question[i]);

question[index]=i;

int t=sum;

if(i==0){

}

exeForward(question, index+1, sum, needSum);

question[index]=(i==1?0:1);

sum=t;

sum-=index;

sum*=2;

}else {

}else {

}else {

}

}

运行结果：

1011010000

1011010000

方法二：

/*

某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：

每位选手需要回答10个问题（其编号为1到10），越后面越有难度。

答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。

每位选手都有一个起步的分数为10分。

某获胜选手最终得分刚好是100分，如果不让你看比赛过程，

你能推断出他（她）哪个题目答对了，哪个题目答错了吗？

如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和0的串来表示。

例如： 就是可能的情况。

你的任务是算出所有可能情况。每个答案占一行。

*/

public class Demo08_a {

// 判断是否符合条件

public static void show(int[] x){

int s = 10;

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

if(x[i]==0){

s = s-(i+1); // 扣掉与题号相同的分数

}else{

s = s*2; // 当前分数翻倍

}

}

if(s==100){

for(int i:x){

(i);

}

n();

}

}

// 递归遍历每种情况

public static void f(int[] x,int n){

if(n>=){

show(x); // 判断

return;

}

104

x[n] = 0;

f(x,n+1);

x[n] = 1;

f(x,n+1);

}

public static void main(String[] args){

int[] x = new int[10];

f(x,0);

}

}

39.益智玩具(汉诺塔)

汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。

大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上(可以借助第三根柱子做缓冲)。

并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

如图【】是现代“山寨”版的该玩具。64个圆盘太多了，所以减为7个，

金刚石和黄金都以木头代替了......但道理是相同的。

据说完成大梵天的命令需要太多的移动次数，以至被认为完成之时就是世界末日！

你的任务是精确计算出到底需要移动多少次。

很明显，如果只有2个圆盘，需要移动3次。

圆盘数为3，则需要移动7次。

那么64个呢？

答案写在“解答.txt”中，不要写在这里！

package Question40_49;

import eger;

import r;

public class Question42MustRemember {

public static BigInteger count=f(0);

public static void move(int from,int to) {

// n(from+"--->"+to);

}

public static void hanoi(int n,int from,int to,int assist) {

}

public static void main(String[] args) {

Scanner scanner=new Scanner();

105

count=(f(1));

if(n>0){

}

hanoi(n-1, from, assist, to);

move(from, to);

hanoi(n-1, assist, to, from);

// int n=t();

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

long startTime = tTimeMillis(); // 程序开始时间

hanoi(i, 1, 2, 3);

long endTime = tTimeMillis(); // 程序结束时间

n("n="+("%4d", i)+" 时,耗时"+("%f",

(endTime-startTime)/1000f)+"秒, 移动了"+count+" 次 ");

count=f(0);

}

方法二：

import eger;

/*

* 汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。

大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上(可以借助第三根柱子做缓冲)。

并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

如图【】是现代“山寨”版的该玩具。64个圆盘太多了，所以减为7个，

金刚石和黄金都以木头代替了......但道理是相同的。

据说完成大梵天的命令需要太多的移动次数，以至被认为完成之时就是世界末日！

你的任务是精确计算出到底需要移动多少次。

很明显，如果只有2个圆盘，需要移动3次。

圆盘数为3，则需要移动7次。

那么64个呢？

答案写在“解答.txt”中，不要写在这里！

*/

class Demo07_hanoi {

public static void hanoi(int n,char a,char b,char c){

if(n>0){

hanoi(n-1,a,c,b);

//n(a+"->"+b);

hanoi(n-1,c,b,a);

s++;

}

}

static long s = 0;

public static void main(String[] args){

int n = 10;

n("圆盘个数t移动次数");

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

s = 0;

hanoi(i,'a','b','c');

n(i+" ->t"+s);

106

}

}

}

n("由上结果可找到规律为：n移动次数 = 2的n次方-1（n为圆盘个数）");

n("64个圆盘的移动次数为：");

BigInteger bi = new BigInteger("2");

bi = (64).subtract();

n(bi);

}

}

运行结果：

圆盘个数 移动次数

1 -> 1

2 -> 3

3 -> 7

4 -> 15

5 -> 31

6 -> 63

7 -> 127

8 -> 255

9 -> 511

10 -> 1023

由上结果可找到规律为：

移动次数 = 2的n次方-1（n为圆盘个数）

64个圆盘的移动次数为：

18446744

40.拼酒量

有一群海盗（不多于20人），在船上比拼酒量。过程如下：打开一瓶酒，

所有在场的人平分喝下，有几个人倒下了。再打开一瓶酒平分，又有倒下的，

再次重复...... 直到开了第4瓶酒，坐着的已经所剩无几，海盗船长也在其中。

当第4瓶酒平分喝下后，大家都倒下了。等船长醒来，发现海盗船搁浅了。

他在航海日志中写到：“......昨天，我正好喝了一瓶.......奉劝大家，开船不喝酒，喝酒别开船......”

请你根据这些信息，推断开始有多少人，每一轮喝下来还剩多少人。

如果有多个可能的答案，请列出所有答案，每个答案占一行。

格式是：人数,人数,...

例如,有一种可能是：20,5,4,2,0

答案写在“解答.txt”中，不要写在这里！

package Question40_49;

publicclass Question43 {

publicstaticvoid main(String[] args) {

int person[]=newint[5];

for (person[1] = 1; person[1]<=20 ; person[1]++) {

107

}

}

}

for (person[2] = 1; person[2]

}

for (person[3] = 1; person[3]

}

for (person[4] = 1; person[4]

}

if ((1.0)/person[1]+(1.0)/person[2]+(1.0)/person[3]+(1.0)/person[4]==1) {

}

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

}

(person[i]);

if(i==4){

}

n(",0");

(",");

}else {

运行结果：

20,5,4,2,0

18,9,3,2,0

15,10,3,2,0

12,6,4,2,0

方法二：

/*

有一群海盗（不多于20人），在船上比拼酒量。过程如下：打开一瓶酒，

所有在场的人平分喝下，有几个人倒下了。再打开一瓶酒平分，又有倒下的，

再次重复...... 直到开了第4瓶酒，坐着的已经所剩无几，海盗船长也在其中。

当第4瓶酒平分喝下后，大家都倒下了。 等船长醒来，发现海盗船搁浅了。

他在航海日志中写到：“......昨天，我正好喝了一瓶.......奉劝大家，开船不喝酒，喝酒别开船......”

请你根据这些信息，推断开始有多少人，每一轮喝下来还剩多少人。

如果有多个可能的答案，请列出所有答案，每个答案占一行。

格式是：人数,人数,...

例如,有一种可能是：20,5,4,2,0

答案写在“解答.txt”中，不要写在这里！

*/

public class Demo06_alcohol {

public static void main(String[] args){

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

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

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

for(int m=k-1;m>0;m--){ // 符点数比较,这里误差定为小于0.0000001为成立

if((((1.0/i+1.0/j+1.0/k+1.0/m)-1))<0.0000001)

108

n(i+","+j+","+k+","+m+",0");

}

}

}

}

}

}

运行结果：

20,5,4,2,0

18,9,3,2,0

15,10,3,2,0

12,6,4,2,0

41.矩形运算

在编写图形界面软件的时候，经常会遇到处理两个矩形的关系。

如图【】所示，矩形的交集指的是：两个矩形重叠区的矩形，当然也可能不存在（参看【】）。

【】

109

【】

两个矩形的并集指的是：能包含这两个矩形的最小矩形，它一定是存在的。

本题目的要求就是：由用户输入两个矩形的坐标，程序输出它们的交集和并集矩形。

矩形坐标的输入格式是输入两个对角点坐标，注意，不保证是哪个对角，

也不保证顺序（你可以体会一下，在桌面上拖动鼠标拉矩形，4个方向都可以的）。

输入数据格式：

x1,y1,x2,y2

x1,y1,x2,y2

数据共两行，每行表示一个矩形。每行是两个点的坐标。x坐标在左，y坐标在右。

坐标系统是：屏幕左上角为(0,0)，x坐标水平向右增大；y坐标垂直向下增大。

要求程序输出格式：

x1,y1,长度,高度

x1,y1,长度,高度

也是两行数据，分别表示交集和并集。如果交集不存在，则输出“不存在”

前边两项是左上角的坐标。后边是矩形的长度和高度。

例如，用户输入：

100,220,300,100

150,150,300,300

则程序输出：

150,150,150,70

100,100,200,200

例如，用户输入：

10,10,20,20

30,30,40,40

则程序输出：

不存在

10,10,30,30

import gle;

import r;

publicclassDemo13_Rectang {

110

}

publicstatic Rectangle getRec(Rectangle[] rec){

}

publicstaticvoid op(Rectangle[] rec){

}

publicstaticvoid main(String[] args){

Rectangle rec[] = new Rectangle[2];

rec[0] = getRec(rec);

rec[1] = getRec(rec);

// 第一个矩形

// 第二个矩形

Rectangle r,rr;

if(rec[0].intersects(rec[1])){

r = rec[0].intersection(rec[1]); // 交集

n(r.x+","+r.y+","++","+);

Scanner scan = new Scanner();

String s = ne();

String[] ss = (",");

int x1 = nt(ss[0]);

int y1 = nt(ss[1]);

int x2 = nt(ss[2]);

int y2 = nt(ss[3]);

// 如果（x1,y1）（x2,y2）分别在（左上，右下，右上，左下）时

returnnew Rectangle((x1, x2),(y1, y2),

(x2-x1),(y2-y1));

}else{

n("不存在");

}

rr = rec[0].union(rec[1]); // 并集

n(rr.x+","+rr.y+","++","+);

op(rec); // 输出交集和并集

}

运行结果1：

100,220,300,100

150,150,300,300

150,150,150,70

100,100,200,200

运行结果2：

10,10,20,20

30,30,40,40

不存在

10,10,30,30

42.警察智力训练

匪警请拨110,即使手机欠费也可拨通！

为了保障社会秩序，保护人民群众生命财产安全，警察叔叔需要与罪犯斗智斗勇，因而需要经常性地进行体力训练

和智力训练！

某批警察叔叔正在进行智力训练：

111

1 2 3 4 5 6 7 8 9 = 110;

请看上边的算式，为了使等式成立，需要在数字间填入加号或者减号（可以不填，但不能填入其它符号）。之间没

有填入符号的数字组合成一个数，

例如：12+34+56+7-8+9 就是一种合格的填法；123+4+5+67-89 是另一个可能的答案。

请你利用计算机的优势，帮助警察叔叔快速找到所有答案。

每个答案占一行。形如：12+34+56+7-8+9123+4+

已知的两个答案可以输出，但不计分。

各个答案的前后顺序不重要。

public class C2 {

public static void main(String[] args) {

// TODO Auto-generated method stub

//String string = "123+4+5+67-89";

char a[] = {' ','+','-'};

char num[] = {'1','2','3','4','5','6','7','8','9'};

for(char x1:a)

for(char x2:a)

for(char x3:a)

for(char x4:a)

for(char x5:a)

for(char x6:a)

for(char x7:a)

for(char x8:a)

{

int result = 0;

char s[] = {x1,x2,x3,x4,x5,x6,x7,x8};

String string = "";

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

{

string = string+num[i]+s[i];

}

string = string+num[8];

string= eAll(" ","");

String jianString[] = ("-");

int addResult[] = new int[];

addResult[0] = 0;

String addString[] = jianString[0].split("[+]");

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

{

addResult[0]

nt(f(addString[j]));

}

result = addResult[0];

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

{

112

+=

}

}

String num1[] = jianString[i].split("[+]");

result = result - nt(f(num1[0]));

for(int p = 1;p<;p++)

result += nt(f(num1[p]));

}

if(result == 110)

n(string)

}

其他解法：

/*

匪警请拨110,即使手机欠费也可拨通！

为了保障社会秩序，保护人民群众生命财产安全，警察叔叔需要与罪犯斗智斗勇，

因而需要经常性地进行体力训练和智力训练！

某批警察叔叔正在进行智力训练：

1 2 3 4 5 6 7 8 9 = 110;

请看上边的算式，为了使等式成立，需要在数字间填入加号或者减号（可以不填，但不能填入其它符号）。

之间没有填入符号的数字组合成一个数，

例如：12+34+56+7-8+9 就是一种合格的填法；123+4+5+67-89 是另一个可能的答案。

请你利用计算机的优势，帮助警察叔叔快速找到所有答案。

每个答案占一行。形如：

12+34+56+7-8+9

123+4+5+67-89

......

已知的两个答案可以输出，但不计分。

各个答案的前后顺序不重要。

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

请不要使用package语句。

源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

*/

public class Demo14 {

// 遍历所有情况

public static void fun(String s) {

char[] c = Array();

StringBuffer sb = new StringBuffer(); // 记录 组成的式子

int len = ()-1; // 字符串长度 - 1

int[] sign = new int[len]; // sign用来标记符号, 最多有（s的长度-1）个符号

// 从后身前添加符号

while(sign[0]<3){ // 最前面的判定符号的值若 >=3 则结束循环

(c[0]); // 添加首元素

for(int i=0;i

113

}

}

}

if(sign[i]==1){ // 值为1添加"+"号

("+");

}else if(sign[i]==2){// 值为2添加"-"号

("-");

}

(c[i+1]); // 不管添加不添加+-号，都添加后一个元素

}

check(ng()); // 验证并输出

gth(0); // 清空sb

sign[len-1]++; // 每循环一次，最后一个符号值加1

for(int i=len-1;i>0;i--){ //当值等于3时，实现逢3进位

if(sign[i]==3){

sign[i] = 0; // sign[i] 归零

sign[i-1]++; // sign[i-1]进位

}

}

// 验证并输出

public static void check(String str){

String[] s = ("[+]|[-]"); // 得到全部数字

String sign = eAll("d*", ""); // 得到全部符号（+-）

int sum = nt(s[0]); // 把第一个数字给sum

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

switch((i)){

case '+':

sum += nt(s[i+1]);

break;

case '-':

sum -= nt(s[i+1]);

break;

}

}

if(sum==110){ // 符合条件输出

n(str);

}

}

// 主函数

public static void main(String[] args){

String s = "123456789";

fun(s);

}

运行结果：

114

123+4+5+67-89

123+4-5-6-7-8+9

123-4+5-6-7+8-9

123-4-5+6+7-8-9

12+34+56+7-8+9

12+3+45+67-8-9

12-3+4-5+6+7+89

1+234-56-78+9

1+2+34+5+67-8+9

1-2+3+45-6+78-9

123+4+5+67-89

123+4-5-6-7-8+9

123-4+5-6-7+8-9

123-4-5+6+7-8-9

12+34+56+7-8+9

12+3+45+67-8-9

12-3+4-5+6+7+89

1+234-56-78+9

1+2+34+5+67-8+9

1-2+3+45-6+78-9

方法二：

递归算法：

public class Demo15 {

// 遍历所有情况

public static void fun(String v, int n) {

}

if(n==9){ // 修改到最后一位符号时输出

check(v);

}else{ // 递归向后修改，数字 变为 数字加符号

fun(e(n+"", n+"+"),n+1);

fun(e(n+"", n+"-"),n+1);

fun(v,n+1);

}

// 验证 并 输出

public static void check(String str){

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

int sum = 0;

for(String t:s){

String[] sub = ("[-]");

int num = nt(sub[0]);

// 计算负数

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

num -= nt(sub[i]);

115

}

sum += num; // 正数或负数结果 加到 总和上

}

if(sum == 110){

n(str);

}

}

public static void main(String[] args){

String str = "123456789";

fun(str,1);

}

}

运行结果：

1+2+34+5+67-8+9

1+234-56-78+9

1-2+3+45-6+78-9

12+3+45+67-8-9

12+34+56+7-8+9

12-3+4-5+6+7+89

123+4+5+67-89

123+4-5-6-7-8+9

123-4+5-6-7+8-9

123-4-5+6+7-8-9

// 调用函数，从1开始修改

43.泊松分酒

泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。

有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。

有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。

在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。

有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。

要求你只用3个容器操作，最后使得某个容器中正好有6升油。

下面的列表是可能的操作状态记录：

12,0,0

4,8,0

4,3,5

9,3,0

9,0,3

1,8,3

1,6,5

每行3个数据，分别表示12，8，6升容器中的油量

第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，...

当然，同一个题目可能有多种不同的正确操作步骤。

本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，

和要求的目标油量，程序则通过计算输出一种实现的步骤（不需要找到所有可能的方法）。

如果没有可能实现，则输出：“不可能”。

116

例如，用户输入：

12,8,5,12,0,0,6

用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，

最后一个数是要求得到的油量（放在哪个容器里得到都可以）

则程序可以输出（答案不唯一，只验证操作可行性）：

12,0,0

4,8,0

4,3,5

9,3,0

9,0,3

1,8,3

1,6,5

每一行表示一个操作过程中的油量状态。

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

请不要使用package语句。

源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

package Question30_39;

import ist;

import or;

import HashSet;

import ;

import r;

import ;

import ;

public class Question36TooDifficultMustRemember {

public static List distribute(List capacityList,List

}

117

oilSizeList,int where,int to) {

ListtList =new ArrayList();

(oilSizeList);

if((where)==0){

}

return null;

return null;

(to, (to));

(where,

return tList;

(to, (to)+(where));

(where, 0);

return tList;

}else if ((where)>=(to)-(to)) {

(where)-((to)-(to)));

}else if((where)<=(to)-(to)){

public static boolean exeForward(Set>set,List

for (List list : set) {

}

n();

for (Integer integer : oilSizeList) {

}

Vector>vector=new Vector>();

(distribute(capacityList, oilSizeList, 0, 1));

(distribute(capacityList, oilSizeList, 0, 2));

(distribute(capacityList, oilSizeList, 1, 0));

(distribute(capacityList, oilSizeList, 1, 2));

(distribute(capacityList, oilSizeList, 2, 0));

(distribute(capacityList, oilSizeList, 2, 1));

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

if((i)!=null){

if(((i))){

}

118

capacityList,List oilSizeList,int NeedOilSize) {

//

//

//

//

(list+" ");

if(integer==NeedOilSize){

}

for (List list : set) {

// (list+" ");

// (()+" ");

}

return true;

for (Iterator iterator = or(); iterator

}

.hasNext();) {

Integer integer2 = (Integer) ();

(integer2);

if(t()){

}

(",");

("n");

}else {

if(exeForward(set, capacityList, (i), NeedOilSize)==true){

}

((i));

return true;

}

}

}

}

return false;

public static void main(String[] args){

}

Scanner scanner=new Scanner();

Set>set=new LinkedHashSet>();

ListtList=new ArrayList();

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

}

List capacityList=new ArrayList<>(tList);

List oilSizeList=new ArrayList<>(tList);

int NeedOilSize;

String ts=ne();

String tss[]=(",");

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

}

int totalOil=0;

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

}

NeedOilSize=nt(tss[6]);

if(NeedOilSize>totalOil){

}

boolean posible=false;

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

}

if(posible==false){

}

exeForward(set, capacityList, oilSizeList, NeedOilSize);

n("不可能");

return;

if((i)>NeedOilSize){

}

posible=true;

break;

n("不可能");

return;

(i, nt(tss[i+3]));

totalOil+=nt(tss[i+3]);

(i, nt(tss[i]));

(0);

运行结果：

119

输入数据（格式为7个数字用","号隔开,例：)12,8,5,12,0,0,6

12,8,5,12,0,0,6

12 0 0

4 8 0

4 3 5

9 3 0

9 0 3

1 8 3

1 6 5

记录数:(7)

方法二：

import r;

public class C33 {

public static void main(String[] args){

}

static int[] getNum()

{

}

static void fenjiu(int num1,int num2,int num3,int num[])

{

//C2*X - C3*Y = 1

int b1 = num[1],c1 = num[2];

int a = num1,b = num2,c = num3,result = num[6];

if(b == result||c == result||a == result)

("");

120

int num[] = getNum();

int d = gcd(num[1], num[2]);//中瓶和小瓶容量的最大公约数

if(num[0]/2 <= num[1] + num[2] && (num[0]/2)%d == 0)

{

}

else

{

n("不可能");

}

n(num[3] + " " + num[4] + " " + num[5]);

fenjiu(num[3], num[4], num[5],num);

Scanner readerScanner = new Scanner();

String string[] = ne().split(",");

int i = 0;

int num[] = new int[7];

while(i < 7)

{

}

return num;

num[i] = nt(string[i]);

i++;

else {

//12,8,5,12,0,0,6

1. 大瓶子只能倒入中瓶子

2. 中瓶子只能倒入小瓶子

3. 小瓶子只能倒入大瓶子

4. 小瓶子只有在已经装满的情况下才能倒入大瓶

5. 若小瓶子被倒空，则无论中瓶子是否满，应马上从中瓶子倒入小瓶子

if(c == c1)

{// 4. 小瓶子只有在已经装满的情况下才能倒入大瓶子

a = a + c;

}

else {

if(c == 0 && b > 0)

5. 若小瓶子被倒空，则无论中瓶子是否满，应马上从中瓶子倒入小瓶子

if(b > c1)

{

}

else {

}

c = b;

b = 0;

n(a + " " + b + " " + c);

fenjiu(a, b, c, num);

c = c1;

b = b - c1;

n(a + " " + b + " " + c);

fenjiu(a, b, c, num);

{//

}

else {

}

121

//

//

//

//

//

c = 0;

n(a + " " + b + " " + c);

fenjiu(a, b, c, num);

if(b != b1)

{

}

else {

}

b = b - c1 + c;

c = c1;

n(a + " " + b + " " + c);

fenjiu(a, b, c, num);

a = a - b1 + b;

b = b1;

n(a + " " + b + " " + c);

fenjiu(a, b, c, num);

}

}

}

}

public static int gcd(int m, int n)

{

}

int a = n, b = m;

while (true)

{

}

if ((a = a % b) == 0)

return b;

return a;

if ((b = b % a) == 0)

方法三：

/*

泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。

有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。

有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。

在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。

有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。

要求你只用3个容器操作，最后使得某个容器中正好有6升油。

下面的列表是可能的操作状态记录：

12,0,0

4,8,0

4,3,5

9,3,0

9,0,3

1,8,3

1,6,5

每行3个数据，分别表示12，8，6升容器中的油量

第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，...

当然，同一个题目可能有多种不同的正确操作步骤。

本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，

和要求的目标油量，程序则通过计算输出一种实现的步骤（不需要找到所有可能的方法）。

如果没有可能实现，则输出：“不可能”。

例如，用户输入：

12,8,5,12,0,0,6

用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，

最后一个数是要求得到的油量（放在哪个容器里得到都可以）

则程序可以输出（答案不唯一，只验证操作可行性）：

12,0,0

4,8,0

4,3,5

122

9,3,0

9,0,3

1,8,3

1,6,5

每一行表示一个操作过程中的油量状态。

注意：

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

请不要使用package语句。

源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

*/

import r;

public class Demo16 {

// 有6种倒酒方法,x[0]->y[0]即（"0"->"1"）代表第一个瓶子向第二个瓶子倒酒,后即同理

static int[] x = {0,1, 2}; // 0 为第一个瓶子，1为第二个瓶子 ，2为第三个瓶子

static int[] y = {1,2, 0};

static int[][] rr = new int[1000][3]; // 记录倒酒后每一行结果

static int index = 0;

static int count = 0;

static int[] tt= {0,0,0};

// 输入数据

public static int[] input(){

Scanner scan = new Scanner();

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

int[] temp = new int[];

for(int i=0;i<;i++){ // 字符转为数字

temp[i] = nt(s[i]);

}

return temp;

}

// 输出

public static void print(int[][] rr){

for(int i=0;i

for(int j:rr[i])

(j+"t");

n();

}

n("记录数:("+index+")");

}

// 记录步骤

public static void record(int[] cur){

rr[index][0] = cur[0];

rr[index][1] = cur[1];

rr[index][2] = cur[2];

index++;

}

123

// 判断当前的记录 是否 在以前的记录里 存在

public static boolean curExist(int[] cur){

for(int i=0;i

if(rr[i][0]==cur[0] && rr[i][1]==cur[1]

&& rr[i][2]==cur[2]){

return true;

}

}

return false;

}

// 倒酒

public static void pour(int[] v,int[] cur,int i){

count++; // 统计倒酒的次数, 若倒酒次数超过1000次,则识为"不可能"

int r = v[y[i]] - cur[y[i]]; // 计算 y瓶中还可以装入多少酒，拿y瓶的总容量-y瓶当前

的酒

if(cur[x[i]] > r){ // x > y 时

cur[y[i]] = v[y[i]]; // y = 满

cur[x[i]] -= r; // x = x - r

}else{ // x <= y

cur[y[i]] += cur[x[i]]; // y = y + x

cur[x[i]] = 0; // x = x - r

}

}

// 求解

public static void f(int[] v,int[] cur,int m){

if(m>v[0]){

n("要求得到的油量"+m+"大于最大容器"+v[0]+",所以n不可能");

return;

}

boolean flag = true;

record(cur);

while(flag){

if(count>1000){

n("倒酒次数超过1000次,所以n不可能");

return;

}

for(int i=0; i<3; i++){ // 6种倒酒方法

// 找到解，退出

if(cur[0]==m || cur[1]==m || cur[2]==m){

print(rr); // 找到解,输出记录

flag = false;

break;

}

// 如果 x 瓶中为空，则跳过， 执行下一轮倒酒

if(cur[x[i]] == 0){

continue;

}

124

pour(v,cur,i);// 倒酒

// 记录步骤

if(curExist(cur)){

cur[0] = rr[index-1][0]; // 还原为上次倒酒的值

cur[1] = rr[index-1][1];

cur[2] = rr[index-1][2];

//--index;

continue;

}else{

record(cur);

}

}

}

}

// 主函数

public static void main(String[] args){

n("输入数据（格式为7个数字用","号隔开,例：)12,8,5,12,0,0,6");

int[] t = input(); // 输入数据

int[] v = {t[0],t[1],t[2]}; // 每个容器的最大容量 v

int[] cur = {t[3],t[4],t[5]}; // 容器的开始的状态 init

int m = t[6]; // 要求得到的油量 r

f(v,cur,m);

}

}

输入数据（格式为7个数字用","号隔开,例：)12,8,5,12,0,0,6

12,8,5,12,0,0,6

12 0 0

4 8 0

4 3 5

9 3 0

9 0 3

1 8 3

1 6 5

记录数:(7)

44.黄金分割数

黄金分割数0.618与美学有重要的关系。舞台上报幕员所站的位置大约就是舞台宽度的0.618处，

墙上的画像一般也挂在房间高度的0.618处，甚至股票的波动据说也能找到0.618的影子....

黄金分割数是个无理数，也就是无法表示为两个整数的比值。

0.618只是它的近似值，其真值可以通过对5开方减去1再除以2来获得，

我们取它的一个较精确的近似值：0.618034

有趣的是，一些简单的数列中也会包含这个无理数，这很令数学家震惊！

1 3 4 7 11 18 29 47 .... 称为“鲁卡斯队列”。它后面的每一个项都是前边两项的和。

如果观察前后两项的比值，即：1/3,3/4,4/7,7/11,11/18 ... 会发现它越来越接近于黄金分割数！

125

你的任务就是计算出从哪一项开始，这个比值四舍五入后已经达到了与0.618034一致的精度。

请写出该比值。格式是：分子/分母。比如：29/47

package Question40_49;

import

imal;

publicclass Question44 {

}

publicstaticvoid main(String[] args) {

}

int a=1,b=3,t;

while(true){

}

if(((double)a/b-0.618034)<0.000001){

}

t=a;

a=b;

b+=t;

n(a+"/"+b+" = "+(double)a/b);

break;

运行结果：

1364/2207

方法二：

import imal;

/*

* 黄金分割数0.618与美学有重要的关系。舞台上报幕员所站的位置大约就是舞台宽度的0.618处，

墙上的画像一般也挂在房间高度的0.618处，甚至股票的波动据说也能找到0.618的影子....

黄金分割数是个无理数，也就是无法表示为两个整数的比值。

0.618只是它的近似值，其真值可以通过对5开方减去1再除以2来获得，

我们取它的一个较精确的近似值：0.618034

有趣的是，一些简单的数列中也会包含这个无理数，这很令数学家震惊！

1 3 4 7 11 18 29 47 .... 称为“鲁卡斯队列”。它后面的每一个项都是前边两项的和。

如果观察前后两项的比值，即：1/3,3/4,4/7,7/11,11/18 ... 会发现它越来越接近于黄金分割数！

你的任务就是计算出从哪一项开始，这个比值四舍五入后已经达到了与0.618034一致的精度。

请写出该比值。格式是：分子/分母。比如：29/47

*/

public class Demo05_Fibonacci {

public static double format(double d){

BigDecimal bd = new BigDecimal(d).setScale(6,_HALF_UP);

double dd = Value();

return dd;

}

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

double d = format((double)a/b);

if(d==0.618034){

n(a+"/"+b+"="+d);

return;

126