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 <string>
       
#include <map>
       
#include <vector>
       
#include <cmath>
       
 
       
const unsigned int NumLetters = 7;
       
const char Letters[] = { 'M', 'D', 'C', 'L', 'X', 'V', 'I' };
       
 
       
// 2% chance to find the terminal symbol

       
const double Terminal  = 0.02;
       
// each letter has the same probability of 14% (7*14% + 2% = 100%)

       
const double AnyLetter = 0.14;
       
 
       
// ---------- roman2number and number2roman were copied from problem 89 ----------

       
 
       
// convert valid roman numbers to binary numbers

       
unsigned int roman2number(const std::string& roman)
       
{
       
  unsigned int result = 0;
       
 
       
  // remember the value of the previous Roman letter
       
  unsigned int last = 0;
       
  // true, if the current letter is subtracted (and the next identical letters)
       
  bool subtract = false;
       
 
       
  // walk through the whole string from the end to the beginning ...
       
  for (auto i = roman.rbegin(); i != roman.rend(); i++)
       
  {
       
    unsigned int current = 0;
       
    switch (*i)
       
    {
       
    case 'M': current = 1000; break;
       
    case 'D': current =  500; break;
       
    case 'C': current =  100; break;
       
    case 'L': current =   50; break;
       
    case 'X': current =   10; break;
       
    case 'V': current =    5; break;
       
    case 'I': current =    1; break;
       
    }
       
 
       
    // smaller than its right neighbor ? => we must subtract
       
    if (current < last)
       
    {
       
      subtract = true;
       
      last = current;
       
    }
       
    // bigger than its right neighbor ? => we must add
       
    else if (current > last)
       
    {
       
      subtract = false;
       
      last = current;
       
    }
       
 
       
    // note: if current == last then we keep the variables "subtract" and "last" in their current state
       
 
       
    // add/subtract accordingly
       
    if (subtract)
       
      result -= current;
       
    else
       
      result += current;
       
  }
       
 
       
  return result;
       
}
       
 
       
std::string number2roman(unsigned int number)
       
{
       
  // apply these rules in the presented order:
       
  // - as long as number >= steps[i] add roman[i] to result
       
  const unsigned int NumRules = 13;
       
  const unsigned int rules[NumRules] =
       
    { 1000,  900, 500,  400, 100,  90,   50,   40,  10,    9,   5,    4,  1  };
       
  const char* action[NumRules] =
       
    {  "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" };
       
 
       
  // apply all rules ...
       
  std::string result;
       
  for (unsigned int i = 0; i < NumRules; i++)
       
    // ... as often as needed
       
    while (number >= rules[i])
       
    {
       
      // reduce integer
       
      number -= rules[i];
       
      // add letter(s)
       
      result += action[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);
       
}
       
 
       
// ---------- problem-specific code ----------

       
 
       
// store possible continuations for each Roman representation

       
std::vector<std::vector<unsigned int>> next(1000);
       
 
       
// run randomized simulation

       
double monteCarlo(unsigned int iterations)
       
{
       
  double result = 0;
       
  for (unsigned int i = 0; i < iterations; i++)
       
  {
       
    std::string current;
       
    while (true)
       
    {
       
      // choose a random letter
       
      auto choice = myrand() % 1000;
       
      // is it the terminal sign ?
       
      if (choice < Terminal * 1000)
       
      {
       
        result += roman2number(current);
       
        break;
       
      }
       
 
       
      // append letter
       
      current += Letters[choice % NumLetters];
       
      // still valid ?
       
      auto number = roman2number(current);
       
      auto verify = number2roman(number);
       
      // not valid or not optimal, remove last letter
       
      if (current != verify)
       
        current.pop_back();
       
    }
       
  }
       
 
       
  return result / iterations;
       
}
       
 
       
// return expected value of current number and all its potential continuations

       
double search(unsigned int current)
       
{
       
  // impossible to add any letter and get another valid, optimal number ? => terminal state
       
  if (next[current].empty())
       
    return current;
       
 
       
  // there's a 2% chance that the current number is the final number
       
  auto result      = Terminal * current;
       
  auto percentages = Terminal;
       
 
       
  // and a 14% chance for each letter 'I', 'V', ...
       
  for (auto x : next[current])
       
  {
       
    result      += AnyLetter * search(x);
       
    percentages += AnyLetter;
       
  }
       
 
       
  // in almost all cases, only a few letters actually yield a valid continuation
       
  // so that those percentages don't add to 100%, need to adjust for that deficit
       
  result /= percentages;
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // store each number's Roman representation (0..999)
       
  std::vector<std::string>               n2r(1000);
       
  // map each Roman representation to a number (0..999)
       
  std::map<std::string, unsigned int>    r2n;
       
 
       
  // generate all Roman numbers from 0 to 999
       
  const unsigned int Thousand = 1000;
       
  for (unsigned int i = 0; i < Thousand; i++)
       
  {
       
    auto roman = number2roman(i);
       
    n2r[i]     = roman;
       
    r2n[roman] = i;
       
  }
       
 
       
  // for each Roman number between 0 and 999:
       
  // analyze which numbers they can transition into by adding a single letter (e.g. 50 + 'X' => 60)
       
  for (unsigned int i = 0; i < Thousand; i++)
       
  {
       
    auto current = n2r[i];
       
 
       
    // add a dummy letter (will be replaced in the next loop)
       
    current += ' ';
       
 
       
    // try to append every possible letter
       
    for (auto add : Letters)
       
    {
       
      current.back() = add;
       
      // is it a valid number (and optimal) ?
       
      if (r2n.count(current) == 1)
       
        next[i].push_back(r2n[current]);
       
    }
       
  }
       
 
       
  // process all Roman numbers that DON'T start with an M (it's 0..999)
       
  auto upTo1000 = 0.0;
       
  upTo1000 += AnyLetter * search(  1); // I
       
  upTo1000 += AnyLetter * search(  5); // V
       
  upTo1000 += AnyLetter * search( 10); // X
       
  upTo1000 += AnyLetter * search( 50); // L
       
  upTo1000 += AnyLetter * search(100); // C
       
  upTo1000 += AnyLetter * search(500); // D
       
 
       
  // stop if adding one more M's doesn't significantly affect the result anymore
       
  auto Precision = 0.000000001; // 10^-9
       
  // count M's => the "thousands"
       
  auto numM   = 1;
       
 
       
  auto result = upTo1000;
       
  while (true)
       
  {
       
    // "weight" of the M's
       
    auto manyM     = numM * 1000 * (1 - AnyLetter);
       
    // add the following letters
       
    auto increment = manyM + upTo1000;
       
    // and the whole thing because less likely the more M's we have ...
       
    result        += increment * pow(AnyLetter, numM);
       
 
       
    // enough precision ?
       
    if (increment < Precision)
       
      break;
       
 
       
    // next iteration
       
    numM++;
       
  }
       
 
       
  std::cout << std::fixed << std::setprecision(8)
       
            << result << std::endl;
       
 
       
  // Monte-Carlo simulation
       
  //while (true)
       
    //std::cout << monteCarlo(100000) << std::endl;
       
 
       
  return 0;
       
}

This solution contains 37 empty lines, 52 comments and 6 preprocessor commands.