-
Notifications
You must be signed in to change notification settings - Fork 33
/
euler-0095.cpp
180 lines (158 loc) · 5.32 KB
/
euler-0095.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
// ////////////////////////////////////////////////////////
// # Title
// Amicable chains
//
// # URL
// https://projecteuler.net/problem=95
// http://euler.stephan-brumme.com/95/
//
// # Problem
// The proper divisors of a number are all the divisors excluding the number itself.
// For example, the proper divisors of 28 are 1, 2, 4, 7, and 14. As the sum of these divisors is equal to 28, we call it a perfect number.
//
// Interestingly the sum of the proper divisors of 220 is 284 and the sum of the proper divisors of 284 is 220, forming a chain of two numbers.
// For this reason, 220 and 284 are called an amicable pair.
//
// Perhaps less well known are longer chains. For example, starting with 12496, we form a chain of five numbers:
//
// 12496 ==> 14288 ==> 15472 ==> 14536 ==> 14264 (==> 12496 ==> ...)
//
// Since this chain returns to its starting point, it is called an amicable chain.
//
// Find the smallest member of the longest amicable chain with no element exceeding one million.
//
// # Solved by
// Stephan Brumme
// March 2017
//
// # Algorithm
// A pre-computation step creates a container ''divsum'' such that ''divsum[x]'' is the sum of all proper divisors of ''x''.
// My function ''getSum()'' from problem 21 produces the correct sum of all proper divisors but turns out to be too slow,
// therefore I searched the web for faster algorithms and found this one:
// 1. split a number into its prime factors `x = p_1^{e_1} * p_2^{e_2} * ...`
// where `p_1`, `p_2`, ... are the primes and `e_1`, `e_2`, ... how often they appear in `x` (=exponents), for example `96 = 2^5 * 3^1`
// 2. then the sum of all divisors is `(2^0 + 2^1 + 2^2 + 2^3 + 2^4 + 2^5) * (3^0 + 3^1) = 252`
// 3. but since we need only the proper divisors instead of all divisors (which include the number itself): `252 - 96 = 156`
// ==> ''divsum[96] = 156''
//
// The chain algorithm appends ''chain[i] = divsum[chain[i - 1]]'' until:
// 1. it's the initial number, then an amicable chain was found or
// 2. it's a number lower than the initial number ==> abort because we should have seen this loop before, when we processed that lower number or
// 3. it's a number above the limit ==> abort according to problem description ("no element exceeding one million") or
// 4. it's a number that is already part of the chain ==> a loop
//
// If the chain is longer than anything before than its first element is stored in ''smallestMember'' (it must be the first element of the chain).
#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;
}