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 <queue>
       
#include <string>
       
 
       
// represent a number where "value = square^2 + cube^3"

       
struct SquareCube
       
{
       
  // create a new object made of a square and a cube
       
  SquareCube(unsigned int square_, unsigned int cube_)
       
  : square(square_), cube(cube_),
       
    value(cube_*(unsigned long long)cube_*cube_ + square_*(unsigned long long)square_)
       
  { }
       
 
       
  // compare two objects (for std::priority_queue)
       
  bool operator<(const SquareCube& other) const
       
  {
       
    if (value != other.value)
       
      return value > other.value; // deliberately switched the sign => min-heap
       
 
       
    return cube > other.cube;
       
  }
       
  bool operator==(const SquareCube& other) const
       
  {
       
    return value == other.value && cube == other.cube;
       
  }
       
 
       
  unsigned int square;
       
  unsigned int cube;
       
  // equal to square^2 + cube^3
       
  unsigned int value;
       
};
       
 
       
int main()
       
{
       
  // find the first 5 numbers
       
  unsigned int maxFound = 5;
       
  std::cin >> maxFound;
       
 
       
  // all cubes and squares must be greater than 1
       
  std::priority_queue<SquareCube> todo;
       
  todo.push(SquareCube(2, 2));
       
 
       
  // find first 5
       
  unsigned int numFound = 0;
       
  // and their sum
       
  unsigned int sum = 0;
       
 
       
  while (numFound < maxFound)
       
  {
       
    // start a new value
       
    auto current = todo.top();
       
    // add its "successors"
       
    todo.emplace(current.square + 1, current.cube);
       
    todo.emplace(current.square, current.cube + 1);
       
 
       
    while (todo.top() == current)
       
      todo.pop();
       
 
       
    // count all combinations of squares and cube with the same value
       
    unsigned int numSame = 1;
       
    while (todo.top().value == current.value)
       
    {
       
      numSame++;
       
      auto same = todo.top();
       
 
       
      // same value, remove it and add its successors
       
      while (todo.top() == same)
       
        todo.pop();
       
      todo.emplace(same.square + 1, same.cube);
       
      todo.emplace(same.square, same.cube + 1);
       
    }
       
 
       
    // exactly four combinations ?
       
    if (numSame == 4)
       
    {
       
      // palindrome ?
       
      unsigned int reverse = 0;
       
      auto reduce = current.value;
       
      while (reduce > 0)
       
      {
       
        reverse *= 10;
       
        reverse += reduce % 10;
       
        reduce  /= 10;
       
      }
       
 
       
      // yes, a match
       
      if (current.value == reverse)
       
      {
       
        numFound++;
       
        sum += current.value;
       
      }
       
    }
       
  }
       
 
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 14 empty lines, 15 comments and 4 preprocessor commands.