alpha = 0
dt = 1
Man: 2  Bug: 0.1
Man: 3  Bug: 0.25
Man: 4  Bug: 0.433333
Caught at manx = 33617, bugx = 33617.1 after 33616 secs
dt = 0.1
Man: 1.1        Bug: 0.01
Man: 1.2        Bug: 0.0209091
Man: 1.3        Bug: 0.0326515
Caught at manx = 23136.5, bugx = 23136.5 after 23135.5 secs
dt = 0.01
Man: 1.01       Bug: 0.001
Man: 1.02       Bug: 0.0020099
Man: 1.03       Bug: 0.00302961
Caught at manx = 22136.7, bugx = 22136.7 after 22135.7 secs
dt = 0.001
Man: 1.001      Bug: 0.0001
Man: 1.002      Bug: 0.0002001
Man: 1.003      Bug: 0.0003003
Caught at manx = 22037.5, bugx = 22037.5 after 22036.5 secs
alpha = 1
dt = 1
Man: 2  Bug: 0.2
Man: 3  Bug: 0.45
Man: 4  Bug: 0.733333
Caught at manx = 12368, bugx = 12368.1 after 12367 secs
dt = 0.1
Man: 1.1        Bug: 0.011
Man: 1.2        Bug: 0.0229091
Man: 1.3        Bug: 0.0356515
Caught at manx = 20934.9, bugx = 20934.9 after 20933.9 secs
dt = 0.01
Man: 1.01       Bug: 0.00101
Man: 1.02       Bug: 0.0020299
Man: 1.03       Bug: 0.00305961
Caught at manx = 21916.4, bugx = 21916.4 after 21915.4 secs
dt = 0.001
Man: 1.001      Bug: 0.0001001
Man: 1.002      Bug: 0.0002003
Man: 1.003      Bug: 0.0003006
Caught at manx = 22015.5, bugx = 22015.5 after 22014.5 secs

#include <iostream>
using namespace std;

// The state of the World!
struct CState {
    double rubberlen;
    double bugx;

    double manspeed;
    double bugspeed;

    double rubberlen0;

    CState(): rubberlen(1.), bugx(0.), manspeed(1.), bugspeed(.1), rubberlen0(rubberlen) { }
    Reset() { rubberlen = rubberlen0; bugx = 0.; }
};

// calculates a new state of the world based on the current state cur,
// alpha, which is the coefficient of the influence of rubber stretching,
// and dt -- small time period,

// alpha=0 -- take into account bug's speed only + the movement of the initial position
// alpha=1 -- take into account the movement of the final position as well

// Returns 1 if the man was caught, o/w returns 0

// Before: bugx=1., rubberlen = 2., dt = .01
// After: new rubber length = 2. + 1. * .01 = 2.01, stretch coefficient = 2.01/2. = 1.005,
//        the distance the bug made: ds = .1 * .01 = .001,
//        the movement of the start position (due to stretch): from bugx=1. to 1. * 1.005 = 1.005,
//        the movement of the final position (due to stretch): from bugx+ds=1.001 to 1.001 * 1.005 = 1.006005,
//        if alpha = 0., then new position = start position + ds = 1.005 + .001 = 1.006,
//        if alpha = 1., then new position = final position = 1.006005
//        if alpha between 0 and 1, then new position is calculated as an weighted sum of those two above
int move(CState & cur, double alpha, double dt) {
    double ds = cur.bugspeed * dt;
    double coef = 1 + cur.manspeed * dt / cur.rubberlen;
    double startx = cur.bugx * coef; // where is the start due to stretching
    double finishx = (cur.bugx + ds) * coef; // where is the finish due to stretching
    double x0 = startx + ds; // if the stretch of the distance is not taken into account
    double x1 = finishx; // otherwise, i.e. if it is taken
    cur.bugx = x0 + alpha * (x1 - x0);
    cur.rubberlen += cur.manspeed * dt;
    return (cur.bugx >= cur.rubberlen);
}

// prints the state
void print(CState cur) {
    cout << "Man: " << cur.rubberlen << "\tBug: " << cur.bugx << '\n';
}

int main() {
    CState state;

    for (double alpha = 0.0; alpha <= 1.0; alpha += 1.0) {
        cout << "alpha = " << alpha << '\n';
        for (double dt = 1; dt >= 0.001; dt /= 10.) {
            cout << "dt = " << dt << '\n';
            int cou = 0;
            while(!move(state, alpha, dt)) {
                if (++cou <= 3) print(state);
            }
            cout << "Caught at manx = " << state.rubberlen << ", bugx = " << state.bugx
                    << " after " << (state.rubberlen - state.rubberlen0) / state.manspeed << " secs\n";
            state.Reset();
        }
    }
}

#include <iostream>
#include <math.h>
using namespace std;
double absolute( double x ) {
     return (( x >= 0.0 ) ? x : x*(-1) );
    }
double get_cof( double time ) {
     if( time ==1 ) return 1;
     double rettime = ( time + 1 ) / time;
     return rettime;
    }
double get_disnow( double time, double speed ) {
      double disnow = get_cof( time ) * speed;
      return disnow;
     }
double get_distance( double time, double speed ) {
     if( time ==1 ) return 20;
     double distance =  get_disnow( time, speed );
     return distance;
    }
using namespace std;
int main( int argc, char **argv ) {
     double x = 0.0;
     for( double t = 1.0; t < 10000 ;t+=1 )
         {
           x += get_distance( t, 10.0 );
           x *= get_cof( t );
           if( (absolute( x - (t * 100 ) ) < 5) || t == 6480 )
            {
                cout << " hallelua  time = " << t << endl;
                cout << "  Moskitos  =     " << x << " cm;   ";
                cout << ",  Man       =     " << t * 100 << " cm;   " << endl;
            }
         }
     return 0;
    }

#include <iostream>
#include <math.h>
using namespace std;
double absolute( double x ) {
     return (( x >= 0.0 ) ? x : x*(-1) );
    }
double get_cof( double time ) {
     if( time ==1 ) return 1;
     double rettime = ( time + 1 ) / time;
     return rettime;
    }
double get_disnow( double time, double speed ) {
      double disnow = get_cof( time ) * speed;
      return disnow;
     }
double get_distance( double time, double speed ) {
     if( time ==1 ) return 20;
     double distance =  get_disnow( time, speed );
     return distance;
    }
using namespace std;
int main( int argc, char **argv ) {
     double x = 20.0;
     for( double t = 2.0; t < 20000 ;t+=1 )
         {
           x *= get_cof( t );
           x += get_distance( t, 10.0 );
           if( (absolute( x - (t * 100 ) ) < 10)  )
            {
                cout << " hallelua  time = " << t << endl;
                cout << "  Moskitos  =     " << x << " cm;   ";
                cout << ",  Man       =     " << t * 100 << " cm;   " << endl;
            }
         }
     return 0;
    }

S>>красиво, ничего не скажешь

S>>if( time ==1 ) return 20; — это что?

  double Lp = 0.0;
  double Lr = 1.0;
  double Vp = 0.1;
  double Vm = 1.0;

  double dt = 0.01;
  int t = 1;
  while (Lp < Lr)
  {
    Lp = (Lr + Vm * dt) * (Lp / Lr);
    Lp += Vp * dt;
    Lr += Vm * dt;
    printf("T=%d  Lp=%f  Lf=%f\n", t, Lp, Lr);
    t++;
  }
  printf("T=%d\n", int(t * dt));

C>можете попробовать проверить эмпирически

class Program
{
  public static void Main()
  {
    const double dt = 1e-5;

    double t = 0;
    for (double x = 0, X = 1; X - x > 1e-8; t += dt)
    {
      if (t > 1e+10) throw new System.OverflowException();

      const double V = 1.0;
      double v = 0.1 + V*x/X;

      X += V*dt;
      x += v*dt;
    }
    System.Console.WriteLine("T={0}", t);
  }
}

S>>>красиво, ничего не скажешь

S>>>if( time ==1 ) return 20; — это что?

S>  double Lp = 0.0;
S>  double Lr = 1.0;
S>  double Vp = 0.1;
S>  double Vm = 1.0;

S>  double dt = 0.01;
S>  int t = 1;
S>  while (Lp < Lr)
S>  {
S>    Lp = (Lr + Vm * dt) * (Lp / Lr);
S>    Lp += Vp * dt;
S>    Lr += Vm * dt;
S>    printf("T=%d  Lp=%f  Lf=%f\n", t, Lp, Lr);
S>    t++;
S>  }
S>  printf("T=%d\n", int(t * dt));
S>

#include <iostream>
#include <math.h>
using namespace std;
double absolute( double x ) {
     return (( x >= 0.0 ) ? x : x*(-1) );
    }
double get_cof( double time ) {
     return ( ( time <=1 ) ? 1.0 : ( time + 1 ) / time );
    }
double get_disnow( double time, double speed ) {
      return (get_cof( time ) * speed);
     }
using namespace std;
int main( int argc, char **argv ) {
     double x = 10.0;
     for( double t = 1.0; t < 100000 ;t+=1 )
         {
           x *= get_cof( t );
           x += get_disnow( t, 10.0 );
           cout <<" Moskitos = " << x << " cm,  " << "Man = " << t*100 << "cm   " << endl;
           if( (absolute( x - (t * 100 ) ) < 10)  )
            {   cout.width( 20 );
                cout <<"___________________________________________" << endl;
                cout << "TIME WAS = " << t << endl;
                cout << "MOSKITOS  =     " << x << " cm;   ";
                cout << ", MAN       =     " << t * 100 << " cm;   " << endl;
                cout <<"___________________________________________" << endl;
                break;
            }
         }
     return 0;
    }

#include <iostream>
#include <math.h>
using namespace std;
double absolute( double x ) {
     return (( x >= 0.0 ) ? x : x*(-1) );
    }
double get_cof( double time ) {
     return ( ( time <=1 ) ? 1.0 : ( time + 1 ) / time );
    }
double get_disnow( double time, double speed ) {
      return (get_cof( time ) * speed);
     }
using namespace std;
int main( int argc, char **argv ) {
     double x = 10.0;
     for( double t = 1.0; t < 100000 ; )
         {
           x *= get_cof( t );
           x += get_disnow( t, 10.0 );
           cout <<" Moskitos = " << x << " cm,  " << "Man = " <<++t*100 << "cm   " << endl;
           if( (absolute( x - (t * 100 ) ) < 10)  )            {   cout.width( 20 );
                cout <<"___________________________________________" << endl;
                cout << "TIME WAS = " << t << endl;
                cout << "MOSKITOS  =     " << x << " cm;   ";
                cout << ", MAN       =     " << t * 100 << " cm;   " << endl;
                cout <<"___________________________________________" << endl;
                break;
            }
         }
     return 0;
    }

Moskitos = 20 cm, Man = 200cm
Moskitos = 45 cm, Man = 300cm
Moskitos = 73.3333 cm, Man = 400cm
Moskitos = 104.167 cm, Man = 500cm
Moskitos = 137 cm, Man = 600cm
Moskitos = 171.5 cm, Man = 700cm
Moskitos = 207.429 cm, Man = 800cm
Moskitos = 244.607 cm, Man = 900cm
Moskitos = 282.897 cm, Man = 1000cm
Moskitos = 322.187 cm, Man = 1100cm
Moskitos = 362.385 cm, Man = 1200cm
Moskitos = 403.417 cm, Man = 1300cm
Moskitos = 445.219 cm, Man = 1400cm
Moskitos = 487.734 cm, Man = 1500cm
Moskitos = 530.917 cm, Man = 1600cm
Moskitos = 574.724 cm, Man = 1700cm
Moskitos = 619.119 cm, Man = 1800cm
Moskitos = 664.071 cm, Man = 1900cm
Moskitos = 709.548 cm, Man = 2000cm
Moskitos = 755.525 cm, Man = 2100cm
Moskitos = 801.979 cm, Man = 2200cm
Moskitos = 848.887 cm, Man = 2300cm

TIME WAS = 12367 сек

#include <iostream>
#include <math.h>
using namespace std;
double absolute( double x ) {
     return (( x >= 0.0 ) ? x : x*(-1) );
    }
double get_cof( double time, double dt ) {
     return ( ( time <=1.0 ) ? 1.0 : ( time + dt ) / time );
    }
double get_disnow( double time, double speed, double dt ) {
      return ( get_cof( time, dt ) * speed * dt );
     }
using namespace std;
int main( int argc, char **argv ) {
     double x = 10.0;
     double dt = 0.001;// Приращение времени
     for( double t = 1.0; t < 100000.0 ; )
         {
           x *= get_cof( t, dt );
           x += get_disnow( t, 10.0, dt );
           t += dt;
           if( x > t * 100.0 ) { cout << " Length  = " << x << ",    " << " Time = " << t << endl; break; }
         }
     return 0;
    }

 ( time + 1 ) / time

 ( time + 2 ) / (time+1)

#include <iostream>
#include <math.h>
using namespace std;
using namespace std;

int main( int argc, char **argv )
{
     double dt = 1e-3;

     double x = 0;

     for( double t = dt; t < 100000 ; )
         {
           double coef = (1+t+dt)/(1+t);//there was an error: (t+dt)/t;

           x = (x + 10.0*dt) * coef;

           t += dt;

           double X = 100.0 + t * 100.0;
           //cout <<" Moskitos = " << x << " cm,  " << "Man = " << X << "cm   " << endl;
           if ( X < x )
           { 
              cout.width( 20 );
              cout <<"___________________________________________" << endl;
              cout << "TIME WAS = "        << t <<                    endl;
              cout << "MOSKITOS  =     "   << x << " cm;   ";
              cout << ", MAN       =     " << X << " cm;   "       << endl;
              cout <<"___________________________________________" << endl;
              break;
            }
         }
     return 0;
}

Через время t резинка станет длиной 1+t. Паучок ползет с постоянной скоростью 0.1 м/с относительной резинки.
Давайте резинку не растягивать, а скажем, что просто паучок ползет со скоростью .1/(1+t) относительно значальной резинки.

Резинку держат двое. Один стоит на месте, а второй (вместе со стенкой) начинает отходить.
...
Пусть он разделяет резинку x+y на части: x до первого и y до второго, в пропорции r=y:x
x' = v*x/(x+y) — s
y' = v*y/(x+y) + s

Через время t резинка станет длиной 1+int[0,t]f(t). Паучок ползет с постоянной скоростью 0.1 м/с относительной резинки.
Давайте резинку не растягивать, а скажем, что просто паучок ползет со скоростью .1/(1+int[0,t]f(t)) относительно значальной резинки.

Резинку держат двое. Один стоит на месте, а второй (вместе со стенкой) начинает отходить.
...
Пусть он разделяет резинку x+y на части: x до первого и y до второго, в пропорции r=y:x
x' = f(t)*x/(x+y) — s
y' = f(t)*y/(x+y) + s

Через время t резинка станет длиной 1+???. Паучок ползет с постоянной скоростью 0.1 м/с относительной резинки.
Давайте резинку не растягивать, а скажем, что просто паучок ползет со скоростью .1/(1+???) относительно значальной резинки.

Резинку держат двое. Один стоит на месте, а второй (вместе со стенкой) начинает отходить.
...
Пусть он разделяет резинку x+y на части: x до первого и y до второго, в пропорции r=y:x
x' = f(t,x)*x/(x+y) — s
y' = f(t,x)*y/(x+y) + s