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 <map>
       
#include <algorithm>
       
 
       
// ---------- standard prime sieve from my toolbox ----------

       
 
       
// odd prime numbers are marked as "true" in a bitvector

       
std::vector<bool> sieve;
       
 
       
// return true, if x is a prime number

       
bool isPrime(unsigned int x)
       
{
       
  // handle even numbers
       
  if ((x & 1) == 0)
       
    return x == 2;
       
 
       
  // lookup for odd numbers
       
  return sieve[x >> 1];
       
}
       
 
       
// find all prime numbers from 2 to size

       
void fillSieve(unsigned int size)
       
{
       
  // store only odd numbers
       
  const unsigned int half = size >> 1;
       
 
       
  // allocate memory
       
  sieve.resize(half, true);
       
  // 1 is not a prime number
       
  sieve[0] = false;
       
 
       
  // process all relevant prime factors
       
  for (unsigned int i = 1; 2 * i*i < half; i++)
       
    // do we have a prime factor ?
       
    if (sieve[i])
       
    {
       
      // mark all its multiples as false
       
      unsigned int current = 3 * i + 1;
       
      while (current < half)
       
      {
       
        sieve[current] = false;
       
        current += 2 * i + 1;
       
      }
       
    }
       
}
       
 
       
// ---------- problem specific code ----------

       
 
       
// compute antichain of exponents, "from" and "to" are iterators like "begin" and "end"

       
template <typename T>
       
unsigned int antichain(T from, T to, unsigned int half)
       
{
       
  // compute sum of exponents
       
  unsigned int sum = 0;
       
  unsigned int numExponents = 0;
       
  for (auto x = from; x != to; x++)
       
  {
       
    sum += *x;
       
    numExponents++;
       
  }
       
  // too few ? => empty antichain
       
  if (sum < half || numExponents == 0)
       
    return 0;
       
 
       
  // reduced to a trivial case ? => antichain has one element
       
  if (half == 0  || numExponents == 1)
       
    return 1;
       
 
       
  // iterate over all combinations of the first exponent and the remaining exponents
       
  unsigned int result = 0;
       
  for (unsigned int i = 0; i <= *from; i++)
       
    result += antichain(std::next(from), to, half - i);
       
  return result;
       
}
       
 
       
// "compress" list of prime factors with exponent   = 1, e.g. 2,2, 3,   5
       
// to a       list of prime factors with exponents >= 1   =>  2^2, 3^1, 5^1 => 2,1,1
       
// and then compute max. antichain

       
unsigned int evaluate(const std::vector<unsigned int>& factors)
       
{
       
  // all factors are sorted, let's count them to get the exponents
       
  // e.g. { 2,2,2,3,5,5 } becomes { 3,1,2 } because it's 2^3 * 3^1 * 5^2
       
  static std::vector<unsigned int> exponents; // static => avoid frequent memory allocations
       
  exponents = { 1 };
       
  for (size_t i = 1; i < factors.size(); i++)
       
    if (factors[i] == factors[i - 1])
       
      exponents.back()++;     // same factor as before, increment the last exponent
       
    else
       
      exponents.push_back(1); // new prime factor, add a new exponent 1
       
 
       
  // actually the bases don't matter at all, hence I can sort the exponents
       
  // => reduces the number of distinct "exponents" containers considerably
       
  std::sort(exponents.begin(), exponents.end());
       
 
       
  // memoize
       
  static std::map<std::vector<unsigned int>, unsigned int> cache;
       
  auto lookup = cache.find(exponents);
       
  if (lookup != cache.end())
       
    return lookup->second;
       
 
       
  // compute maximum antichain
       
  auto result = antichain(exponents.begin(), exponents.end(), factors.size() / 2);
       
  cache[exponents] = result;
       
  return result;
       
}
       
 
       
// generate all numbers and their prime factorization recursively and then compute their max. antichain length

       
unsigned int search(unsigned int limit, unsigned int current = 1, unsigned int largestFactor = 1)
       
{
       
  unsigned int result = 0;
       
 
       
  // 1 cannot be factored into prime factors, so manually add its antichain size
       
  static std::vector<unsigned int> factors;
       
  if (factors.empty())
       
    result = 1;
       
 
       
  // allocate memory for one more prime factor (value doesn't matter, 0 is just a placeholder)
       
  factors.push_back(0);
       
  // each new prime factor must not be smaller then the previously largest
       
  for (auto prime = largestFactor; prime <= limit; prime++)
       
  {
       
    if (!isPrime(prime))
       
      continue;
       
 
       
    // found a new number
       
    auto next = (unsigned long long)current * prime;
       
    if (next > limit)
       
      break;
       
 
       
    // process number: find length of its longest antichain
       
    factors.back() = prime;
       
    result += evaluate(factors);
       
 
       
    // can I multiply it by some larger-or-equal prime ? (and still stay within the limit)
       
    if (next * prime <= limit)
       
      result += search(limit, next, prime); // search numbers with one more prime factor
       
  }
       
  factors.pop_back();
       
  return result;
       
}
       
 
       
int main()
       
{
       
  unsigned int limit = 100000000;
       
  std::cin >> limit;
       
 
       
  // run prime sieve
       
  fillSieve(limit);
       
 
       
  std::cout << search(limit) << std::endl;
       
  return 0;
       
}

This solution contains 24 empty lines, 35 comments and 4 preprocessor commands.