My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <iomanip>
       
#include <vector>
       
#include <cmath>
       
 
       
// crossing between two marches

       
struct Point
       
{
       
  double x;
       
  double y;
       
 
       
  // create a new 2D point
       
  Point(double x_, double y_)
       
  : x(x_), y(y_)
       
  {}
       
 
       
  // distance between two points
       
  double distance(const Point& other) const
       
  {
       
    auto diffX = x - other.x;
       
    auto diffY = y - other.y;
       
    return sqrt(diffX * diffX + diffY * diffY);
       
  }
       
};
       
 
       
// how many days does it take to walk from the first to the last point, considering "speed" of the surfaces

       
double duration(const std::vector<Point>& points)
       
{
       
  // leagues travelled per day between point[i] and point[i+1]
       
  static const std::vector<double> speed = { 10, 9, 8, 7, 6, 5, 10 };
       
 
       
  double result = 0;
       
  // for each surface: determine length and divide by speed
       
  for (size_t i = 0; i < speed.size(); i++)
       
  {
       
    auto way = points[i].distance(points[i+1]);
       
    result += way / speed[i];
       
  }
       
  return result;
       
}
       
 
       
// a simple pseudo-random number generator
       
// (produces the same result no matter what compiler you have - unlike rand() from math.h)

       
unsigned int myrand()
       
{
       
  static unsigned long long seed = 0;
       
  seed = 6364136223846793005ULL * seed + 1;
       
  return (unsigned int)(seed >> 30);
       
}
       
 
       
// try to move a single point's y-value by delta
       
// if the mutation is better, then keep the result
       
// if the mutation is worse,  then undo the change

       
void mutate(std::vector<Point>& points, double delta)
       
{
       
  auto oldDuration = duration(points);
       
 
       
  // decide at random whether to add or subtract
       
  if (myrand() & 1)
       
    delta = -delta;
       
 
       
  // change one random y-coordinate (must not be the first or last)
       
  auto id = myrand() % 6 + 1;
       
  points[id].y += delta;
       
 
       
  // not faster ? => undo change
       
  if (duration(points) >= oldDuration)
       
    points[id].y -= delta;
       
}
       
 
       
int main()
       
{
       
  // A
       
  std::vector<Point> points;
       
  points.push_back({ 0, 0 });
       
 
       
  // rotate the coordinate system by 45 degrees,
       
  // so that travelling one league is equivalent to moving 1/scaling units along x-axis and 1/scaling units along y-axis
       
  double scaling = sqrt(2);
       
 
       
  // when travelling the shortest distance between A and B, how wide is the marsh ?
       
  auto direct = 50 * scaling; // c^2 = a^2 + b^2 where a=b=50
       
 
       
  // entering the marsh
       
  auto current = ((100 - direct) / 2) / scaling; // same as 25*(sqrt(2)-1)
       
  points.push_back({ current, current });
       
 
       
  // all 5 zones of the marsh
       
  for (auto i = 1; i <= 5; i++)
       
    points.push_back({ current + i * 10, current + i * 10 });
       
 
       
  // B
       
  points.push_back({ 100 / scaling, 100 / scaling });
       
 
       
  // randomly mutate the crossing
       
  const auto NumIterations = 10000;
       
  for (auto delta = 0.01; delta >= 0.00001; delta /= 10)
       
    for (auto i = 0; i < NumIterations; i++)
       
      mutate(points, delta);
       
 
       
  // display result with 10 digits after the decimal point
       
  std::cout << std::fixed << std::setprecision(10)
       
            << duration(points) << std::endl;
       
  return 0;
       
}

This solution contains 18 empty lines, 23 comments and 4 preprocessor commands.