逻辑题目！都来讨论哈

[expter]

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

不好算

[expter]

同事问，做了几分钟，做错了

来讨论下 很有意思哦

[K行天下]

用计算机编程序 还是考自己逻辑

[K行天下]

感觉计算机做就没什么意思了
粗算是：
100分钟40秒

[xkyx_cn]

我也觉得应该是100'40"
400 / (52 - 46) = 66 + 2/3
[(66 + 2/3) * 52 / 100] = 34 []表示取整
66 + 2/3 + 34 = 100 + 2/3 = 100'40"

但总觉有些不妥，暂时没想出来

[expter]

不对哦。

[langhua0001]

假设甲用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 

[rhq12345]

假设用时t，甲跑路径长度 x
则：甲跑步时间t1=t-(x/100取整)
方程一：t1*52=x

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

[expter]

[t1-4,t-3] 什么意思？

[langhua0001]

[Quote=引用 11 楼 rhq12345 的回复:]
假设用时t，甲跑路径长度 x
则：甲跑步时间t1=t-(x/100取整)
方程一：t1*52=x

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

注意: 乙跑的长度为x-400

[fallening]

：）

[fallening]

写了一个模拟的程序，不过貌似有点问题
大家看看

/*
 *环行跑道周长为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;
}

[caimps]

[Quote=引用 8 楼 langhua0001 的回复:]
。。。

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

。。。。。

[/Quote]

挺复杂，如果甲休息时乙跑过来休息，这时甲起跑算不算超过？

[K行天下]

[Quote=引用 16 楼 caimps 的回复:]
引用 8 楼 langhua0001 的回复:
。。。

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

。。。。。



挺复杂，如果甲休息时乙跑过来休息，这时甲起跑算不算超过？
[/Quote]
还是只是超过n个四百米就算可以了！

[langhua0001]

[Quote=引用 16 楼 caimps 的回复:]
引用 8 楼 langhua0001 的回复:
。。。

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

。。。。。



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

你觉得这是甲追上乙吗?

[langhua0001]

[Quote=引用 16 楼 caimps 的回复:]
引用 8 楼 langhua0001 的回复:
。。。

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

。。。。。



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

即使存在这样的时刻,那么在此之前肯定有某个时刻是甲追上乙的,因为甲快

[expter]

恩


LS的有道理

[langhua0001]

[Quote=引用 7 楼 expter 的回复:]
恩


LS的有道理
[/Quote]

感觉思路应该没问题

你自己再验证一下吧

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

但是由于 52, 46 的最小公倍数比较大,肯定比这个结果大,所以那种情况肯定不是第一次追上的

[expter]

你的解法是甲只超过乙一圈?

会不会好是多圈呢?

[langhua0001]

每超一圈两人都会有一个相遇的时候,这是实际问题

题意显然求的是第一次...

[Ijiuweiyaohul]

假设中间不休息
t为时间 52*t-400 = 46*t
t = 66.7（分钟）
期间甲跑的总路程为 t*52
休息的时间为 t*52/100
所以 甲用 304/3分钟追上乙