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 <unordered_map>
       
 
       
unsigned char numVisited[5] = { 0,0,0,0,0 };
       
unsigned char maxPerArc = 0;
       
 
       
#define FAST
       
#ifdef  FAST
       
const auto Unknown = 0xFFFFFFFFFFFFFFFFull;
       
std::vector<unsigned long long> cache;
       
#else
       
std::unordered_map<unsigned int, unsigned long long> cache;
       
#endif
       
 
       
// count number of valid arcs

       
unsigned long long search(unsigned char arcsLeft = 70, unsigned char currentArc = 0)
       
{
       
  // all arcs were used
       
  if (arcsLeft == 0)
       
  {
       
    // did not return to initial arc ?
       
    if (currentArc != 0)
       
      return 0;
       
 
       
    // expect that all arcs were visited equally often
       
    if (numVisited[0] != numVisited[1] ||
       
        numVisited[2] != numVisited[3] ||
       
        numVisited[0] != numVisited[2]) // no need to check visited[4]
       
      return 0;
       
 
       
    return 1;
       
  }
       
 
       
  // create a unique key
       
  const auto IdFactor = maxPerArc + 1;
       
  unsigned int id = currentArc;
       
  id *= IdFactor;
       
  id += numVisited[0];
       
  id *= IdFactor;
       
  id += numVisited[1];
       
  id *= IdFactor;
       
  id += numVisited[2];
       
  id *= IdFactor;
       
  id += numVisited[3];
       
  id *= IdFactor;
       
  id += numVisited[4];
       
  // memoize
       
#ifdef FAST
       
  if (cache.empty())
       
    cache.resize(5 * IdFactor * IdFactor * IdFactor * IdFactor * IdFactor, Unknown);
       
  if (cache[id] != Unknown)
       
    return cache[id];
       
#else
       
  auto lookup = cache.find(id);
       
  if (lookup != cache.end())
       
    return lookup->second;
       
#endif
       
 
       
  unsigned long long result = 0;
       
 
       
  // turn left  if possible
       
  auto turnLeft = (currentArc + 1) % 5;
       
  if (numVisited[turnLeft]  < maxPerArc)
       
  {
       
    numVisited[turnLeft]++;
       
    result += search(arcsLeft - 1, turnLeft);
       
    numVisited[turnLeft]--;
       
  }
       
 
       
  // turn right if possible
       
  auto turnRight = (currentArc + 4) % 5; // -1 mod 5 => 5-1 mod 5
       
  if (numVisited[turnRight] < maxPerArc)
       
  {
       
    numVisited[turnRight]++;
       
    result += search(arcsLeft - 1, turnRight);
       
    numVisited[turnRight]--;
       
  }
       
 
       
  // save result
       
  cache[id] = result;
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int numArcs = 70;
       
  std::cin >> numArcs;
       
 
       
  // let's go !
       
  maxPerArc = numArcs / 5;
       
  std::cout << search(numArcs) << std::endl;
       
  return 0;
       
}

This solution contains 12 empty lines, 10 comments and 10 preprocessor commands.