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 <vector>
       
#include <cmath>
       
 
       
unsigned int minRadius = 30;
       
unsigned int maxRadius = 50;
       
unsigned int numBalls  = maxRadius - minRadius + 1;
       
unsigned int pipeRadius = 50;
       
 
       
// double has 64 bits => memoized cache would be twice as large

       
typedef float Number;
       
 
       
// an arbitrarily high number (more than sum of all radii)

       
const Number WorstCase = 999999999;
       
 
       
// get distance between centre of two balls along the y axis

       
Number getDistanceY(unsigned int radiusA, unsigned int radiusB)
       
{
       
  auto sum = radiusA + radiusB;
       
  return sqrt(sum*sum - (2*pipeRadius - sum)*(2*pipeRadius - sum));
       
}
       
 
       
// mask - bitmask of all available spheres

       
Number search(unsigned int mask, unsigned int lastRadius)
       
{
       
  // are all balls in the pipe (except for the largest) ?
       
  if (mask == 0)
       
    return getDistanceY(lastRadius, maxRadius) + maxRadius;
       
 
       
  // memoize
       
  const unsigned int Shift = numBalls - 2; // ignore the two largest balls
       
  const Number Invalid = -1;
       
  static std::vector<Number> cache((1 << Shift) * (maxRadius - minRadius + 1), Invalid);
       
  // already computed ?
       
  auto id = mask + ((lastRadius - minRadius) << Shift);
       
  if (cache[id] != Invalid)
       
    return cache[id];
       
 
       
  Number best = WorstCase;
       
  for (unsigned int radius = minRadius; radius <= maxRadius; radius++) // could stop at maxRadius - 2, too
       
  {
       
    // already used ?
       
    auto bit = 1 << (radius - minRadius);
       
    if ((mask & bit) == 0)
       
      continue;
       
 
       
    // process recursively
       
    auto newHeight = getDistanceY(radius, lastRadius) + search(mask & ~bit, radius);
       
    // improvement ?
       
    if (best > newHeight)
       
      best = newHeight;
       
  }
       
 
       
  cache[id] = best;
       
  return best;
       
}
       
 
       
int main()
       
{
       
  std::cin >> pipeRadius >> minRadius >> maxRadius;
       
  // avoid invalid input (for live test only)
       
  if (minRadius >= maxRadius)
       
    return 1;
       
  if (pipeRadius < maxRadius)
       
    return 2;
       
 
       
  numBalls  = maxRadius - minRadius + 1;
       
 
       
  // all bits set => all balls still available
       
  unsigned int mask = (1 << (maxRadius - minRadius + 1)) - 1;
       
 
       
  // the two largest balls must be at the ends of the pipe, remove those bits
       
  for (unsigned int radius = maxRadius - 1; radius <= maxRadius; radius++)
       
    mask &= ~(1 << (radius - minRadius));
       
 
       
  // start with the second largest ball
       
  auto first = maxRadius - 1;
       
  // half of the first ball (from its border to its centre) plus everything else
       
  auto best  = first + search(mask, first);
       
 
       
  // convert to micrometre and round to nearest integer
       
  std::cout << (unsigned int)round(1000 * best) << std::endl;
       
  return 0;
       
}

This solution contains 15 empty lines, 16 comments and 3 preprocessor commands.