逻辑题目!都来讨论哈

expter 2008-07-08 04:42:23
环行跑道周长为400米.甲乙两人同时同地顺时针沿环行跑道跑步.甲52米/分钟.乙46米/分钟.假设甲乙两人每跑100米停下休息一分钟.问甲多长时间追上乙?

不好算

...全文
322 点赞 收藏 21
写回复
21 条回复
Ijiuweiyaohul 2008年07月15日
假设中间不休息
t为时间 52*t-400 = 46*t
t = 66.7(分钟)
期间甲跑的总路程为 t*52
休息的时间为 t*52/100
所以 甲用 304/3分钟追上乙
回复 点赞
langhua0001 2008年07月09日
每超一圈两人都会有一个相遇的时候,这是实际问题

题意显然求的是第一次...
回复 点赞
expter 2008年07月09日
你的解法是甲只超过乙一圈?

会不会好是多圈呢?
回复 点赞
langhua0001 2008年07月09日
[Quote=引用 7 楼 expter 的回复:]



LS的有道理
[/Quote]

感觉思路应该没问题

你自己再验证一下吧

这里我对正好在乙休息的时候甲追上的情况没考虑

但是由于 52, 46 的最小公倍数比较大,肯定比这个结果大,所以那种情况肯定不是第一次追上的
回复 点赞
expter 2008年07月09日



LS的有道理
回复 点赞
langhua0001 2008年07月09日
[Quote=引用 16 楼 caimps 的回复:]
引用 8 楼 langhua0001 的回复:
。。。

这里我对正好在乙休息的时候甲追上的情况没考虑

。。。。。



挺复杂,如果甲休息时乙跑过来休息,这时甲起跑算不算超过?
[/Quote]

即使存在这样的时刻,那么在此之前肯定有某个时刻是甲追上乙的,因为甲快
回复 点赞
langhua0001 2008年07月09日
[Quote=引用 16 楼 caimps 的回复:]
引用 8 楼 langhua0001 的回复:
。。。

这里我对正好在乙休息的时候甲追上的情况没考虑

。。。。。



挺复杂,如果甲休息时乙跑过来休息,这时甲起跑算不算超过?
[/Quote]

你觉得这是甲追上乙吗?
回复 点赞
k2eats 2008年07月09日
[Quote=引用 16 楼 caimps 的回复:]
引用 8 楼 langhua0001 的回复:
。。。

这里我对正好在乙休息的时候甲追上的情况没考虑

。。。。。



挺复杂,如果甲休息时乙跑过来休息,这时甲起跑算不算超过?
[/Quote]
还是只是超过n个四百米就算可以了!
回复 点赞
caimps 2008年07月09日
[Quote=引用 8 楼 langhua0001 的回复:]
。。。

这里我对正好在乙休息的时候甲追上的情况没考虑

。。。。。

[/Quote]

挺复杂,如果甲休息时乙跑过来休息,这时甲起跑算不算超过?
回复 点赞
fallening 2008年07月09日
写了一个模拟的程序,不过貌似有点问题
大家看看
/*
*环行跑道周长为400米.甲乙两人同时同地顺时针沿环行跑道跑步.甲52米/分钟.
*乙46米/分钟.假设甲乙两人每跑100米停下休息一分钟.问甲多长时间追上乙?
*/

struct Accuracy_Control
{
static const long double time_acc = 1E-2;
static const long double position_acc = 5.0E-3;
};

struct Racetrack
{
static const long double circumference = 400.0L;
};

struct Runner
{
bool is_running;
long double speed;
long double position;
long double status_remain_time;
long double time;

Runner():
is_running(false),
speed(0.0L),
position(0.0L),
status_remain_time(0.0L),
time(0.0L)
{}

friend bool operator > ( const Runner& lhs, const Runner& rhs )
{
return lhs.position > rhs.position;
}×/
};

bool need_change_tactic( const Runner& runner, const Accuracy_Control& ac )
{
return runner.status_remain_time < ac.time_acc;
}

template< typename Run_Tactic, typename Rest_Tactic >
void change_tactic( Runner& runner, const Run_Tactic& run_tactic,
const Rest_Tactic& rest_tactic, const Accuracy_Control& ac )
{
if ( runner.is_running )
rest_tactic( runner);
else
run_tactic( runner, ac );
}

void time_flying( Runner& runner, const Accuracy_Control& ac )
{
runner.position += runner.speed;
runner.status_remain_time -= ac.time_acc;
runner.time += ac.time_acc;
}

void correct_position( Runner& runner, const Racetrack& racetrack )
{
if ( runner.position > racetrack.circumference )
{
runner.position -= racetrack.circumference;
//last_relation = !last_relation;
}
}

bool do_they_meet( const Runner& runner_a, const Runner& runner_b, const Accuracy_Control& ac )
//bool do_they_meet( const Runner& runner_a, const Runner& runner_b, const Accuracy_Control& )
{
/*
static bool last_relation = true;
bool ans = false;

if ( ( runner_a > runner_b ) != last_relation )
ans = true;

last_relation = runner_a > runner_b;

return ans;
*/

bool ans = false;

long double difference = runner_a.position - runner_b.position;
if ( difference < 0 )
difference = -difference;
if ( difference < ac.position_acc )
ans = true;

return ans;

}

struct Run_Tactic_A
{
void operator()( Runner& runner, const Accuracy_Control& ac ) const
{
runner.is_running = true;
runner.speed = 52.0L / 60.0L * ac.time_acc;
runner.status_remain_time = 100.0L / 52.0L;
}
};

struct Run_Tactic_B
{
void operator()( Runner& runner, const Accuracy_Control& ac ) const
{
runner.is_running = true;
runner.speed = 46.0L / 60.0L * ac.time_acc;
runner.status_remain_time = 100.0L/ 46.0L;
}
};

struct Rest_Tactic
{
void operator()( Runner& runner ) const
{
runner.is_running = false;
runner.speed = 0.0L;
runner.status_remain_time = 60.0L;
}
};


#include <iostream>
using namespace std;

int main()
{
Accuracy_Control ac;
Racetrack racetrack;
Runner runner_a, runner_b;

for ( long long l = 0; l < 99999999; ++l )
{
if ( need_change_tactic( runner_a, ac ) )
{
change_tactic( runner_a, Run_Tactic_A(), Rest_Tactic(), ac );
}
if ( need_change_tactic( runner_b, ac ) )
{
change_tactic( runner_b, Run_Tactic_B(), Rest_Tactic(), ac );
}

time_flying( runner_a, ac );
time_flying( runner_b, ac );

correct_position( runner_a, racetrack );
correct_position( runner_b, racetrack );

if ( do_they_meet( runner_a, runner_b, ac ) )
{
cout << "\nA. Find a meet at the time " << runner_a.time
<< " at the position " << runner_a.position;
cout << "\nB. Find a meet at the time " << runner_b.time
<< " at the position " << runner_b.position;
}
}

return 0;
}






回复 点赞
fallening 2008年07月09日
:)
回复 点赞
langhua0001 2008年07月09日
[Quote=引用 11 楼 rhq12345 的回复:]
假设用时t,甲跑路径长度 x
则:甲跑步时间t1=t-(x/100取整)
方程一:t1*52=x

同理:乙跑步时间t2=[t1-4,t-3]
方程二:t2*46=x
[/Quote]

注意: 乙跑的长度为x-400
回复 点赞
expter 2008年07月09日
[t1-4,t-3] 什么意思?
回复 点赞
rhq12345 2008年07月09日
假设用时t,甲跑路径长度 x
则:甲跑步时间t1=t-(x/100取整)
方程一:t1*52=x

同理:乙跑步时间t2=[t1-4,t-3]
方程二:t2*46=x

回复 点赞
langhua0001 2008年07月08日

假设甲用t分钟追上乙 此时甲行驶了(x百米+y米) 其中y<100
则甲实际跑了 (t-x) 分钟 总路程为 100*x+y
乙实际跑了 [t-(x-4)] 分钟 总路程为 100*(x-4)+ y

从而可以列出下面两个等式 :

100*x+y = 52*(t-x)

100*(x-4)+y = 46*[t-(x-4)]

从中可以求得 t-x = 292/3 (甲实际跑的时间)

甲实际跑的路程为 292/3 * 52 = 15184/3 (整数部分为5061)

所以甲中途休息了 50分钟

总的时间为 292/3 + 50 = 147+ 1/3

回复 点赞
expter 2008年07月08日
不对哦。

回复 点赞
xkyx_cn 2008年07月08日
我也觉得应该是100'40"
400 / (52 - 46) = 66 + 2/3
[(66 + 2/3) * 52 / 100] = 34 []表示取整
66 + 2/3 + 34 = 100 + 2/3 = 100'40"

但总觉有些不妥,暂时没想出来
回复 点赞
k2eats 2008年07月08日
感觉计算机做就没什么意思了
粗算是:
100分钟40秒
回复 点赞
k2eats 2008年07月08日
用计算机编程序 还是考自己逻辑
回复 点赞
expter 2008年07月08日
同事问,做了几分钟,做错了

来讨论下 很有意思哦
回复 点赞
发动态
发帖子
非技术区
创建于2007-09-28

4415

社区成员

5.8w+

社区内容

C/C++ 非技术区
社区公告
暂无公告