 |
| 百度面试题(算法) |
|
bleakoasis 原创 更新：2006-11-13 17:11:43 版本: 1.0
|
|
题目：有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。木杆很细，不能同时通过一只蚂蚁。开始时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间。
模拟每秒钟5只蚂蚁的情况。在生成Ant对象时确定蚂蚁的运行方向和名字。代码如下：
public class Ant {
//蚂蚁的位置
private int position;
//爬行方向
private boolean front_flg;
//是否到达终点
private boolean isOver = false;
//蚂蚁的名字
private String antName;
public boolean isOver() {
if((position == 0)||(position == 27)){
isOver = true;
} else {
isOver = false;
}
return isOver;
}
public void setOver(boolean isOver) {
this.isOver = isOver;
}
public String getAntName() {
return antName;
}
public void setAntName(String antName) {
this.antName = antName;
}
public boolean isFront_flg() {
return front_flg;
}
public void setFront_flg(boolean front_flg) {
this.front_flg = front_flg;
}
public void setPosition(int position) {
this.position = position;
}
//构造方法
public Ant (int position,boolean flg,String antName){
this.position = position;
this.front_flg = flg;
this.antName = antName;
}
public void crawl(boolean front_flg){
//根据爬行方向判断position的加减
if(!(isOver())){
if (front_flg){
position = position + 1;
} else {
position = position - 1;
}
}
System.out.println(antName + " has arrived position : " + position);
}
public int getPosition() {
return position;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Ant ant3 = new Ant (3,true,"ant3");
Ant ant7 = new Ant (7,true,"ant7");
Ant ant11 = new Ant (11,true,"ant11");
Ant ant17 = new Ant (17,false,"ant17");
Ant ant23 = new Ant (23,false,"ant23");
//记录爬行时间
int useTime = 1;
while(!(ant3.isOver()
&&ant7.isOver()
&&ant11.isOver()
&&ant17.isOver()
&&ant23.isOver())){
//如果两只蚂蚁相遇则调转爬行方向
if (ant3.getPosition()==ant7.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant7.isFront_flg());
ant7.setFront_flg(temp);
}
if (ant3.getPosition()==ant11.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant11.isFront_flg());
ant11.setFront_flg(temp);
}
if (ant3.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant3.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
if (ant7.getPosition()==ant11.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant11.isFront_flg());
ant11.setFront_flg(temp);
}
if (ant7.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant7.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
if (ant11.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant11.isFront_flg();
ant11.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant11.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant11.isFront_flg();
ant11.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
if (ant17.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant17.isFront_flg();
ant17.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
//蚂蚁爬行
ant3.crawl(ant3.isFront_flg());
ant7.crawl(ant7.isFront_flg());
ant11.crawl(ant11.isFront_flg());
ant17.crawl(ant17.isFront_flg());
ant23.crawl(ant23.isFront_flg());
System.out.println("Use time is :" + useTime++);
System.out.println("================================");
}
}
}
希望喜欢研究java的朋友一起交流
MSN：dl_lgj@hotmail.com
QQ: 77860880
|
|
|
评论人：lifeizhou714
|
发表时间: Mon Nov 13 20:02:43 CST 2006
|
朋友,我觉得这段代码有点逻辑错误.
//如果两只蚂蚁相遇则调转爬行方向
if (ant3.getPosition()==ant7.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant7.isFront_flg());
ant7.setFront_flg(temp);
}
if (ant3.getPosition()==ant11.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant11.isFront_flg());
ant11.setFront_flg(temp);
}
if (ant3.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant3.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
if (ant7.getPosition()==ant11.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant11.isFront_flg());
ant11.setFront_flg(temp);
}
if (ant7.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant7.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
if (ant11.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant11.isFront_flg();
ant11.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant11.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant11.isFront_flg();
ant11.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
if (ant17.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant17.isFront_flg();
ant17.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
|
|
|
评论人：java2benice
|
发表时间: Tue Nov 14 06:24:13 CST 2006
|
//code below
import java.util.*;
class Ant {
boolean left;
int pos;
Ant(int pos) {
this.pos = pos;
}
boolean isOut() {
return pos < 0 || pos > 27;
}
}
class Test {
Ant[] ants;
Test(Ant[] ants) {
this.ants = ants;
}
boolean isCollision(Ant antLeft, Ant antRight) {
return antRight.left&&!antLeft.left&&antRight.pos-antLeft.pos<=1;
}
void turnAround(Ant antLeft, Ant antRight) {
antLeft.left=true;
antRight.left=false;
}
void tryCrawl(int begin,int end) {
for (int i=begin;i<end;i++)
if(!ants[i].isOut()&&isCollision(ants[i],ants[i+1])) {
turnAround(ants[i],ants[i+1]);
tryCrawl(begin,i-1);
tryCrawl(i+1,end);
}
}
void crawl() {
for(Ant ant:ants)
if(ant.left)
--ant.pos;
else
++ant.pos;
}
boolean isOver() {
boolean over = true;
for(Ant ant:ants) over = over && ant.isOut();
return over;
}
public static void main(String[] args) {
Ant[] ants = new Ant[5];
Test t = new Test(ants);
List<Integer> list = new ArrayList<Integer>();
int time;
boolean[] bb0 = {true,false};
boolean[] bb1 = {true,false};
boolean[] bb2 = {true,false};
boolean[] bb3 = {true,false};
boolean[] bb4 = {true,false};
for (int i0=0;i0<2;i0++)
for (int i1=0;i1<2;i1++)
for (int i2=0;i2<2;i2++)
for (int i3=0;i3<2;i3++)
for (int i4=0;i4<2;i4++) {
ants[0] = new Ant(3);
ants[1] = new Ant(7);
ants[2] = new Ant(11);
ants[3] = new Ant(17);
ants[4] = new Ant(23);
ants[0].left = bb0[i0];
ants[1].left = bb1[i1];
ants[2].left = bb2[i2];
ants[3].left = bb3[i3];
ants[4].left = bb4[i4];
time = 0;
while (!t.isOver()) {
t.tryCrawl(0,3);
t.crawl();
++ time;
}
System.out.println("time " + time);
list.add(time);
}
Collections.sort(list);
System.out.println("minTime " + list.get(0));
System.out.println("maxTime " + list.get(list.size()-1));
}
}
//output below
/*
time 24
time 18
time 24
time 12
time 24
time 18
time 24
time 17
time 24
time 21
time 24
time 21
time 24
time 21
time 24
time 21
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
time 25
minTime 12
maxTime 25
*/
|
|
|
评论人：sntuuje
|
发表时间: Tue Nov 14 08:58:04 CST 2006
|
作者思路清晰，非常好，值得我们学习。
不过有一些代码可以省略，不相邻的蚂蚁不会相遇的，所以我们可以把不相邻的蚂蚁相遇的这些情况的代码删除掉。这样节省了一些运行开支。
/* if (ant3.getPosition()==ant11.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant11.isFront_flg());
ant11.setFront_flg(temp);
}
if (ant3.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant3.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant3.isFront_flg();
ant3.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}*/
/* if (ant7.getPosition()==ant17.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant17.isFront_flg());
ant17.setFront_flg(temp);
}
if (ant7.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant7.isFront_flg();
ant7.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
*/
/* if (ant11.getPosition()==ant23.getPosition()){
boolean temp;
temp = ant11.isFront_flg();
ant11.setFront_flg(ant23.isFront_flg());
ant23.setFront_flg(temp);
}
*/
|
|
|
评论人：bleakoasis
|
发表时间: Tue Nov 14 09:32:53 CST 2006
|
|
多谢sntuuje指点，急于求成居然疏忽了这么重要的一点。
|
|
|
评论人：joy_here
|
发表时间: Wed Nov 15 09:08:05 CST 2006
|
You've specified all directions of all ants. Then how do you plan to get the minimum and maximum cost of time?
|
|
|
评论人：linkehong
|
发表时间: Wed Nov 15 11:22:57 CST 2006
|
|
最小时间只用11秒，最大时间24秒。
|
|
|
评论人：linkehong
|
发表时间: Wed Nov 15 11:25:37 CST 2006
|
|
我一朋友研究出了快速算法，很简单明了，可以直接得出答案。详情稍后附上
|
|
|
评论人：简单
|
发表时间: Wed Nov 15 15:23:04 CST 2006
|
//蚂蚁的位置
private int position;
不要定义成int[w]
|
|
|
评论人：简单
|
发表时间: Wed Nov 15 15:24:12 CST 2006
|
//蚂蚁的位置
private int position;
不要用int[w]
|
|
|
评论人：简单
|
发表时间: Wed Nov 15 15:25:39 CST 2006
|
//蚂蚁的位置
private int position;
不要用int
|
|
|
评论人：简单
|
发表时间: Wed Nov 15 17:32:47 CST 2006
|
好像只需要求出蚂蚁之间0碰撞，和最大碰撞的场合，遍历六个值就可以
0碰撞4个场合
最大碰撞2个场合
|
|
|
评论人：简单
|
发表时间: Wed Nov 15 17:35:58 CST 2006
|
好像只需要遍历0碰撞和最大碰撞就可以了
用6个值就可以得出2个结果了
|
|
|
评论人：为爱走西川
|
发表时间: Wed Nov 15 18:29:52 CST 2006
|
|
上面写的实现还可以，其实除了这些之外，我认为有点更重要的东西才是他们考察的项目，如何推出min和max的公式，其实可以推出通用公式的，考虑一下蚂蚁碰头的最小次数和最大次数，就不难推出了，就像1+2+3....+100的面试题一样，在于通用公式
|
|
|
评论人：geyiaffh
|
发表时间: Wed Nov 15 20:12:08 CST 2006
|
|
作者的怎么不能得出时间？time错了
|
|
|
评论人：linkehong
|
发表时间: Thu Nov 16 13:07:33 CST 2006
|
|
考虑到要所有的蚂蚁都爬出木竿，当两只蚂蚁相撞可以等效为两只蚂蚁互相穿透了，这个是关键点。 所以最大的就是在3厘米位置的蚂蚁爬到27，时间为24秒。
|
|
|
评论人：suifeng
|
发表时间: Thu Nov 16 18:35:51 CST 2006
|
public class Call {
public static void main(String[] args) {
call();
}
static int[] AXIS = new int[] {3,7,11,17,23};
//计算最大最小值
public static void call() {
int[] axis = new int[5]; // 蚂蚁坐标
int[] speed = new int[5]; // 速度 (感觉速度比方向更好理解,就命名为速度)
boolean[] isOut = new boolean[5];//是否出去
int maxTime = 0;
int minTime = Integer.MAX_VALUE;
//给出蚂蚁最初的方向 一共2^5=32种 (这些组合是通过二进制表达出来)
for (int i=32; i<64; i++) {
reset(axis,speed,isOut);
String speedStr = Integer.toString(i,2); //组合
for (int j=1; j<speedStr.length(); j++) {
speed[j-1] = speedStr.charAt(j) == '0' ? -1 : 1;
}
int time = getTime(axis,speed,isOut); // 当给出一种初始速度时，计算时间
maxTime = time > maxTime ? time : maxTime;
minTime = time < minTime ? time : minTime;
System.out.println("time : " + time);
}
System.out.println("max time : " + maxTime);
System.out.println("min time : " + minTime);
}
public static void reset(int[] axis, int[] speed, boolean[] isOut) {
for (int i=0; i<axis.length; i++) {
speed[i] = 0;
axis[i] = AXIS[i];
isOut[i] = false;
}
}
// 当给出一种初始速度时，计算时间
public static int getTime(int[] axis, int[] speed, boolean[] isOut) {
int time = 0;
while(!isAllOut(isOut)) {
move(axis,speed);//蚂蚁移动
doWhenTouch(axis,speed,isOut);//蚂蚁出去
doWhenOut(axis,isOut); //蚂蚁相碰
time ++; //时间流动
}
return time;
}
//判断是否蚂蚁都出去了
public static boolean isAllOut(boolean[] isOut) {
boolean isAllOut = true;
for (int i=0; i<isOut.length; i++) {
isAllOut = isAllOut && isOut[i];
}
return isAllOut;
}
//蚂蚁移动
public static void move(int[] axis, int[] speed) {
for (int i=0; i<axis.length; i++) {
axis[i] += speed[i];
}
}
//蚂蚁相碰
public static void doWhenTouch(int[] axis, int[] speed, boolean[] isOut) {
for (int i=0; i<axis.length-1; i++) {
if (isOut[i] || isOut[i+1]) {
continue;
}
if (axis[i] == axis[i+1]) {
speed[i] *= -1;
speed[i+1] *= -1;
}
}
}
//蚂蚁出去
public static void doWhenOut(int[] axis, boolean[] isOut) {
for (int i=0; i<axis.length; i++) {
if (axis[i] == 27 || axis[i] == 0) {
isOut[i] = true;
}
}
}
}
time : 23
time : 17
time : 23
time : 11
time : 23
time : 17
time : 23
time : 16
time : 23
time : 20
time : 23
time : 20
time : 23
time : 20
time : 23
time : 20
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
max time : 24
min time : 11
|
|
|
评论人：suifeng
|
发表时间: Thu Nov 16 18:43:25 CST 2006
|
public class Call {
public static void main(String[] args) {
call();
}
static int[] AXIS = new int[] {3,7,11,17,23};
//计算最大最小值
public static void call() {
int[] axis = new int[5];// 蚂蚁坐标
int[] speed = new int[5]; // 速度 (感觉速度比方向更好理解,就命名为速度)
boolean[] isOut = new boolean[5];//是否出去
int maxTime = 0;
int minTime = Integer.MAX_VALUE;
//给出蚂蚁最初的方向 一共2^5=32种 (这些组合是通过二进制表达出来)
for (int i=32; i<64; i++) {
reset(axis,speed,isOut);
String speedStr = Integer.toString(i,2); //组合
for (int j=1; j<speedStr.length(); j++) {
speed[j-1] = speedStr.charAt(j) == '0' ? -1 : 1;
}
int time = getTime(axis,speed,isOut);
maxTime = time > maxTime ? time : maxTime;
minTime = time < minTime ? time : minTime;
System.out.println("time : " + time);
}
System.out.println("max time : " + maxTime);
System.out.println("min time : " + minTime);
}
public static void reset(int[] axis, int[] speed, boolean[] isOut) {
for (int i=0; i<axis.length; i++) {
speed[i] = 0;
axis[i] = AXIS[i];
isOut[i] = false;
}
}
// 当给出一种初始速度时，计算时间
public static int getTime(int[] axis, int[] speed, boolean[] isOut) {
int time = 0;
while(!isAllOut(isOut)) {
move(axis,speed);//蚂蚁移动
doWhenTouch(axis,speed,isOut);//蚂蚁出去
doWhenOut(axis,isOut); //蚂蚁相碰
time ++; //时间流动
}
return time;
}
//判断是否蚂蚁都出去了
public static boolean isAllOut(boolean[] isOut) {
boolean isAllOut = true;
for (int i=0; i<isOut.length; i++) {
isAllOut = isAllOut && isOut[i];
}
return isAllOut;
}
//蚂蚁移动
public static void move(int[] axis, int[] speed) {
for (int i=0; i<axis.length; i++) {
axis[i] += speed[i];
}
}
//蚂蚁相碰
public static void doWhenTouch(int[] axis, int[] speed, boolean[] isOut) {
for (int i=0; i<axis.length-1; i++) {
if (isOut[i] || isOut[i+1]) {
continue;
}
if (axis[i] == axis[i+1]) {
speed[i] *= -1;
speed[i+1] *= -1;
}
}
}
//蚂蚁出去
public static void doWhenOut(int[] axis, boolean[] isOut) {
for (int i=0; i<axis.length; i++) {
if (axis[i] == 27 || axis[i] == 0) {
isOut[i] = true;
}
}
}
}
time : 23
time : 17
time : 23
time : 11
time : 23
time : 17
time : 23
time : 16
time : 23
time : 20
time : 23
time : 20
time : 23
time : 20
time : 23
time : 20
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
time : 24
max time : 24
min time : 11
|
|
|
评论人：oboaix
|
发表时间: Fri Nov 17 17:04:07 CST 2006
|
|
最小时间明显11秒，工作继续...
|
|
|
评论人：forscan
|
发表时间: Sat Nov 18 11:16:26 CST 2006
|
自己也写了一个,结果最小是11,最大是24.请多指教:
package puzzle;
import puzzle.Ant;
//import java.math
/*
* 有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。
* 木杆很细，不能同时通过一只蚂蚁。
* 开始时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，但不会后退。
* 当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。
* 假设蚂蚁们每秒钟可以走一厘米的距离。编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间。
*/
public class AntOnStick {
static int time = 0;
static int maxtime = 0;
static int mintime = 27;
/*
* 判断两只蚂蚁是否碰头
*/
public static void meet(Ant a,Ant b){
if(a.getPosition() == b.getPosition()){
String temp = a.getDirection();
a.setDirection(b.getDirection());
b.setDirection(temp);
}
}
/*
* 产生蚂蚁的随机方向
*/
public static String dir(int d){
if(d == 0){
return "left";
}else if(d == 1){
return "right";
}else{
return "no dir";
}
}
/*
* 计算最小时间和最大时间
*/
public static void comput(int t){
if(t>maxtime){
maxtime = t;
System.out.println("maxtime is "+maxtime);
}else if(t<mintime){
mintime = t;
System.out.println("mintime is "+mintime);
}else{
System.out.println("current is "+t);
}
}
public static void main(String[] args) {
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
for(int z=0;z<2;z++){
for(int x=0;x<2;x++){
for(int y=0;y<2;y++){
time = 0;
Ant ant3 = new Ant("ant3", 3, dir(i));
Ant ant7 = new Ant("ant7", 7, dir(j));
Ant ant11 = new Ant("ant11", 11, dir(z));
Ant ant17 = new Ant("ant17", 17, dir(x));
Ant ant23 = new Ant("ant23", 23, dir(y));
//判断是否所有的蚂蚁都离开木杆
while (!ant3.isOut() || !ant7.isOut() || !ant11.isOut() || !ant17.isOut()
|| !ant23.isOut()) {
ant3.move();
ant7.move();
ant11.move();
ant17.move();
ant23.move();
time++;
meet(ant3,ant7);
meet(ant7,ant11);
meet(ant11,ant17);
meet(ant17,ant23);
}
comput(time);
}
}
}
}
}
System.out.println("maxtime ="+maxtime);
System.out.println("mintime ="+mintime);
}
}
package puzzle;
/*
* 蚂蚁类
*/
public class Ant {
private String name = null;
private int position = 0;
private String direction = null; // left or right
private boolean out = false; // 是否已离开要木杆
public Ant(String n, int p, String d) {
this.name = n;
this.position = p;
this.direction = d;
}
/*
* 判断蚂蚁是否离开木杆
*/
public boolean isOut() {
if (position == 0 || position == 27) {
out = true;
} else {
out = false;
}
return out;
}
/*
* 蚂蚁的移动.向右则位置加1,向左则位置减1 如果蚂蚁已离开木杆则不会移动
*/
public void move() {
if (!isOut()) {
if (direction.equals("left")) {
position--;
} else if (direction.equals("right")) {
position++;
} else {
System.out.println("no diection found");
}
System.out.println("[" + name + "] at: " + position + "move to "
+ direction);
}else{
System.out.println("["+name+"] is out");
}
}
public String getDirection() {
return direction;
}
public void setDirection(String direction) {
this.direction = direction;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPosition() {
return position;
}
public void setPosition(int position) {
this.position = position;
}
}
|
|
|
评论人：forscan
|
发表时间: Sat Nov 18 11:23:39 CST 2006
|
有个问题:如果蚂蚁的初始位置有奇数和偶数那么用两只蚂蚁的位置是否相同来判断是否
碰头好象就有问题.如一只在5处向右,一只有6处向左,那么向右的加1变6,向左的减1变5,位置就也不同???????????,望指教?
|
|
|
评论人：gentleman
|
发表时间: Tue Nov 21 00:24:43 CST 2006
|
其实最大的距离看两边的数那个离两端的端点最远.那个就是最大的距离了
比如说 ant1,ant2,ant3,ant4,ant5
对于ant1来说它的最远距离就是s(也就27)-ant1(3)
对于ant2来说它的最远距离就是s+(ant2 - ant1+ant2/2)+ant1+ant2/2 合并一下就是s-ant2
因为ant2在大于ant1所以
ant1就是距离最远的.
当然因为是可以两个方向的,所以就要比较两个端点的的大小了.
|
|
|
评论人：简单
|
发表时间: Fri Dec 01 15:46:17 CST 2006
|
评论人：linkehong 发表时间: Thu Nov 16 13:07:33 CST 2006
考虑到要所有的蚂蚁都爬出木竿，当两只蚂蚁相撞可以等效为两只蚂蚁互相穿透了，这个是关键点。 所以最大的就是在3厘米位置的蚂蚁爬到27，时间为24秒。
[w]强，好想法！
|
|
|
评论人：mrou2001
|
发表时间: Wed Dec 06 22:15:01 CST 2006
|
|
不错的文章[java]
|
|
|
|
|
|
9 
0
