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>
       
 
       
int main()
       
{
       
  unsigned int limit;
       
  std::cin >> limit;
       
 
       
  // the usual prime sieve
       
  std::vector<unsigned int> primes;
       
  primes.push_back(2);
       
  for (unsigned int i = 3; i <= limit; i += 2)
       
  {
       
    bool isPrime = true;
       
 
       
    // test against all prime numbers we have so far (in ascending order)
       
    for (auto p : primes)
       
    {
       
      // next prime is too large to be a divisor ?
       
      if (p*p > i)
       
        break;
       
 
       
      // divisible ? => not prime
       
      if (i % p == 0)
       
      {
       
        isPrime = false;
       
        break;
       
      }
       
    }
       
 
       
    // yes, we have a prime number
       
    if (isPrime)
       
      primes.push_back(i);
       
  }
       
 
       
  // initial mapping of each number to its proper divisor's sum
       
  std::vector<unsigned int> divsum(limit + 1, 0);
       
  for (unsigned int i = 2; i <= limit; i++)
       
  {
       
    unsigned int sum = 1;
       
    unsigned int reduce = i;
       
    for (auto p : primes)
       
    {
       
      // note: reduce itself might be prime in the end
       
      if (p*p > reduce)
       
        break;
       
 
       
      // divide by all primes
       
      unsigned int factor = 1;
       
      while (reduce % p == 0)
       
      {
       
        reduce /= p;
       
 
       
        // add 1 to each exponent, e.g. p^0 + p^1 becomes p^1 + p^2
       
        factor *= p;
       
        // add a new term p^0
       
        factor++;
       
      }
       
      sum *= factor;
       
    }
       
 
       
    // if a large prime was left over
       
    if (reduce > 1 && reduce < i)
       
      sum *= reduce + 1;
       
 
       
    // subtract number itself if it isn't a prime
       
    if (sum > 1)
       
      sum -= i;
       
 
       
    divsum[i] = sum;
       
  }
       
 
       
  // loop until numbers are mapped to themselves (or get stuck in a loop)
       
  unsigned int longestChain = 0;
       
  unsigned int smallestMember = limit;
       
  for (unsigned int i = 1; i <= limit; i++)
       
  {
       
    // re-use the same vector over and over again to avoid memory re-allocations
       
    static std::vector<unsigned int> chain;
       
    chain.clear();
       
    chain.push_back(i);
       
 
       
    // until we:
       
    // 1. return to i or
       
    // 2. exceed the limit or
       
    // 3. get stuck in a loop
       
    while (true)
       
    {
       
      unsigned int add = divsum[chain.back()];
       
      chain.push_back(add);
       
 
       
      // yes, we found an amicable chain
       
      if (add == i)
       
        break;
       
 
       
      // can't be a new shorter loop:
       
      // we have already seen this number in an earlier iteration
       
      if (add < i)
       
        break;
       
 
       
      // abort if limit exceeded
       
      if (add > limit)
       
        break;
       
 
       
      // stuck in a loop ?
       
      bool isLoop = false;
       
      for (size_t j = 1; j < chain.size() - 1; j++) // except last element
       
        if (add == chain[j])
       
        {
       
          isLoop = true;
       
          break;
       
        }
       
      if (isLoop)
       
        break;
       
    }
       
 
       
    // did we return to i ?
       
    if (chain.back() != i)
       
      continue;
       
 
       
    // too short ?
       
    if (chain.size() < longestChain)
       
      continue;
       
 
       
    // shorter chain ?
       
    if (longestChain < chain.size())
       
    {
       
      longestChain = chain.size();
       
      smallestMember = chain.front();
       
    }
       
  }
       
 
       
  std::cout << smallestMember << std::endl;
       
  return 0;
       
}

This solution contains 21 empty lines, 26 comments and 2 preprocessor commands.