那天的题挺简单的
下面来看下
No1
If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.
//project euler num1
#include <stdio.h>
#include <stdlib.h>
#include <string.h> int main()
{
int sum = 0;
int i;
for(i = 0; i < 1000; i++)
{
if(i % 3 == 0 || i % 5 == 0)
sum += i;
} printf("The sum is %d\n", sum);
}
第一题很简单，不解释~
No 2
Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms
第二题是求斐波那契数列小于 4e6 的那些偶数项的和，很简单的想到了递归算法
//project euler pro02
#include <iostream>
#include <string>
#include <vector>
using namespace std; int fib_temp[10000];//避免重复运算，算好的项存入数组 int fib(int n)
{
if(n == 1)
{
fib_temp[0] = 1;
return fib_temp[0];
}
else if( n == 0)
{
fib_temp[1] = 2;
return fib_temp[1];
}
else
{
if(fib_temp[n - 1] != 0)
{
if(fib_temp[n - 2] != 0)
return fib_temp[n - 1] + fib_temp[n - 2];//如果已经预存，直接返回
else
fib_temp[n - 2] = fib( n - 2);
return fib_temp[n - 1] + fib_temp[n - 2];
}
else
{
fib_temp[n - 1] = fib(n - 1);
fib_temp[n - 2] = fib(n - 2);
return fib_temp[n - 1] + fib_temp[n - 2];
}
}
} int sum_even_fib(int top_num)
{ int i = 0;
int sum = 0;
int temp = 0;
while(1)
{
if(i % 2 == 0)
{
if((temp = fib(i)) < top_num)
sum += temp;
else
break;
}
i++;
}
return sum;
} int main()
{ int sum = sum_even_fib(400000000);
cout << sum << endl;
return 0;
}
就是这样，没有选用最基本的递归方法是因为效率过低，不如把算好的想先存入数组，避免重复计算。
但是这让我想起了之前的动态规划算法：
递归算法是很简单的自顶向下，从上可以看出是从n一步步的计算到第一项；
但是动态规划恰恰相反，它是先从第一项开始计算，然后把算好的结果存入数组以备后用。
//project euler pro02
#include <iostream>
#include <string>
#include <vector>
using namespace std; int fib_temp[10000];
//設立預存數組
int fib(int n)
{
if( n == 0 || n == 1)
{
if(fib_temp[0] == 0)
fib_temp[0] = 1;
if(fib_temp[1] == 0)
fib_temp[1] = 2;
//對前兩項初始化
}
else
{
for(int i = 2; i <= n; i++)
{
if(fib_temp[i] == 0)
fib_temp[i] = fib_temp[i - 1] + fib_temp[i - 2];
//用循環計算後面的項
}
}
return fib_temp[n];
//直接返回數組中的項
} int sum_even_fib(int top_num)
{
int i = 0;
int sum = 0;
int temp = 0;
while(1)
{
if((temp = fib(i)) % 2 == 0)
{
if(temp < top_num)
sum += temp;
else
break;
}
cout << fib(i) << endl;
i++;
}
return sum;
}
int main()
{
int sum = sum_even_fib(4e6);
cout << sum << endl;
return 0;
}
No3
The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?
我会说就是这个我没有看清楚题么，我看做是求小于这个数的所有素数~
但是题目是求小于这个数的最大素因子。
悲伤~~
好吧，两个都做完了，先看计算最大素因子。
#include <iostream>
#include <string>
#include <vector>
#include <math.h> using namespace std; bool is_prime(long long int i)
{
long long int j;
for(j = 2; j <= sqrt(i); j ++)
{
if(i % j == 0)
return false;
}
if(j > sqrt(i))
return true;
}
//这是判断素数的 void max_prime_facter(long long int n)
{
if(is_prime(n))
{
cout << n << endl;
return;
//如果n本身就是素数，直接输出
}
for(long long int i = 2; i < (n / 2); ++i)
{
if(n % i == 0)
{
n = n / i;
//如果找到一个小的因子，替换n为n/i
cout << "factor is " << i << endl;
i = 2;
//重置循环变量
if(is_prime(n))
{
cout << n << endl;
//如果在过程中发现n变为了素数，说明
得到了最大的素因子
break;
}
}
}
} int main(int argc, const char *argv[])
{
long long int n = 600851475143;
max_prime_facter(n);
return 0;
}
看~不难吧。
那么问题就来了， 挖掘机到底那家强！！
小扯一下，那么如果我想输出小于这个数的所有素数呢？
先说一下这个程序的基本思想：
传统的输出小于这个数的所有素数就是，
一个循环，依次判断，但是判断素数是一个很繁琐的事情。
所以我们就想可不可以把一些数省掉呢？
首先所有偶数都是合数。
那么自然而然的就想到了算数基本定理：所有合数都可以表示为素因子的乘积。
#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
using namespace std; bool is_prime(long long int i)
{
for(long long int j = 2; j <= sqrt(i); j ++)
{
if(i % j == 0)
return false;
}
if(i > sqrt(i))
return true;
}
//判断素数的函数
vector<int> vec_prime;
//一个存放素数的数组
void prime_number(long long int n)
{
long long int max;
for (int i = 2; i < n; i++)
{
if(vec_prime.size() != 0)
//一开始数组内是没有元素的
{
vector<int>::iterator it ;
for( it = vec_prime.begin(); it != vec_ prime.end(); ++it)
{
if(i % (*it) == 0)
break;
//依次判断数组内有没有其的因子
}
if(it != vec_prime.end())
continue;
//这表示有他的素因子
}
if(is_prime(i) == true)
//到这里说明数组中没有这个数的因子
//因为我们知道一切正整数都可以表示成素数的乘积
//反之，如果这个数不能表示成素数的乘积
//那么这个数本身很可能就是素数
//所以判断他是否是素数，是的话就加入数组
{
vec_prime.push_back(i);
cout << i << endl;
//依次输出素数
}
}
return ;
} int main()
{ long long int n = 600851475143;
prime_number(n);
return 0;
}
可以看到这个算法其实是非常快速的~
补充：
今早起来突然想到上面的程序是不是还不够快呢~
可不可以把判断素数的函数省掉呢？
事实上，判断素数就是多余的。
因为所有正整数都可以表示为它一组素因子的乘积或者是它本身与 1 的乘积。
#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
using namespace std; bool is_prime(long long int i)
{
for(long long int j = ; j <= sqrt(i); j ++)
{
if(i % j == )
return false;
}
if(i > sqrt(i))
return true;
}
//判断素数的函数
vector<int> vec_prime;
//存入第一个素数
//一个存放素数的数组
void prime_number(long long int n)
{ if(vec_prime.size() == )
vec_prime.push_back(); long long int max;
for (int i = 3; i < n; i += 2)
{
//一开始数组内是没有元素的
vector<int>::iterator it ;
for( it = vec_prime.begin(); it != vec_prime.end(); ++it)
{
if(i % (*it) == )
break;
//依次判断数组内有没有其的因子
}
if(it != vec_prime.end())
continue;
else if(it == vec_prime.end())
{
vec_prime.push_back(i);
cout << i << endl;
}
//这表示有他的素因子
//到这里说明数组中没有这个数的因子
//因为我们知道一切正整数都可以表示成素数的乘积
//反之，如果这个数不能表示成素数的乘积
//那么这个数本身很可能就是素数
//所以判断他是否是素数，是的话就加入数组
//依次输出素数
}
return ;
} int main()
{ long long int n = ;
prime_number(n);
return ;
}
实验一下发现这个程序还是非常快速的。
那么我们就得到了这样的程序：
最后再说一下：
今天学习了c++中的两个新的数据类型long long int 和 _int64.
参考文章:
http://www.cnblogs.com/jiai/articles/2613900.html
http://www.cnblogs.com/felove2013/articles/3880590.html