初入数论(1)--水仙花数-Gcd && LCM 问题-判断是否为素数

1.水仙花数

问题描述

水仙花数是指水仙花数是指一个N位正整数（ $3\le N\le 7$），它的每个位上的数字的N次幂之和等于它本身，例如：13+53+3^3=153。

输入格式:
输入在一行中给出一个正整数N（3≤N≤7）。

输出格式:
按递增顺序输出所有N位水仙花数，每个数字占一行

对N=3进行分析

#include <iostream>
using namespace std;
int main() {
	for(int i=100; i<1000 ; i++) {
		int a=i%10;
		int b=i/10%10;
		int c=i/100;
		if(a*a*a+b*b*b+c*c*c == i)
			cout<<i<<endl;
	}
  return 0;
}

分析：当N=3时，由于数值不大，且知道位数，在循环内部可直接求出其每个位上的数，可不用循环和math函数，这样只执行1000次。

对N( $3\le N\le 7$)未知分析

分析：由于N未知，且$3\le N\le 7$，继续采取上面的方法很繁杂，这时我想当然的再利用一个循环将其各个位数的值求出来，对其相加（由于N未知，就立马想到用pow()函数）代码如下(运行超时)：

#include<iostream>
#include<cmath>
using namespace std;
int main() {
    int n;
    scanf("%d",&n);
	for(int i=pow(10,n-1) ;i<pow(10,n) ; i++) {
        int b,t=0;
        b=i;
        while(b) {
        t+=pow(b%10,n);
            b/=10;
        }
        if(i == t)
        	printf("%d\n",i);
    }
    return 0;
}

分析：
这时问题就来了，N=7这个测试点显示运行超时，网上给的答案是频繁调用pow()函数。
解决方案：自定义一个power()函数(*只进行整数的次方运算*)来代替Pow()函数的功能。

原因： pow()函数原型double pow(double x,double y);
故它要处理的不只是关于整数次的次方也有可能是0.5等小数次的次方，所以它在运算时会考虑很多的情况，从而运算超时。并且当N=7时，需要调用pow函数的次数 $T>7\times 10^6+2$，运算量比N=3大多了。

故优化后的AC代码如下：

#include<iostream>
#include<cmath>
using namespace std;
int power(int a,int b) {
	int s=1;
	for(int i=1 ;i<=b ; i++)
		s*=a;
	return s;
}
int main() {
    int n;
    scanf("%d",&n);
	for(int i=pow(10,n-1) ;i<pow(10,n) ; i++) {
        int  b,t=0;
        b=i;
        while(b) {
        t+=pow(b%10,n);
            b/=10;
        }
        if(i == t)
        	printf("%d\n",i);
    }
    return 0;
}

分析：这种方法虽然能够AC，但时间能达到500ms，效率不高，在网上又看到一种解法：利用数组来优化

终极解法(数组下标法)

核心代码如下：

for(int i=0 ; i<10 ; i++)
			num[i]=power(i,n);

分析：由于要将整数分解成单个的个位数，其范围是$0\le N\le 9$，故不管怎么分解，都是这十个数之一。可以先将这是个数先进行次方运算，然后在进行循环遍历。

代码如下：

#include<iostream>
using namespace std;
int main()
{
	int power(int a,int n);
	int n;
	scanf("%d",&n);
	int num[10]={0};
	for(int i=0 ; i<10 ; i++)
			num[i]=power(i,n);
	for(int i=power(10,n-1) ; i<power(10,n) ;i++) {
		int b=i,sum=0;
		while(b) {
			sum+=num[b%10];  //将分解的数放至数组的下标，直接在数组中找出其对应的次方运算后的数
			b/=10;
		}
		if(i==sum)
			printf("%d\n",i);
	}
	return 0;
}

int power(int a,int n) {
	int s=1;
	for(int i=0 ; i<n ;i++)
		s*=a;
	return s;
}

N=7时的运算最大次数 T $=7\times 10^6$,但调用power函数的次数为$10+2$次， 效率又进一步的提升了，但测试时间仍要一百多毫秒。

将N=7单独分析的巧解

代码如下：

#include<iostream>
using namespace std;
int power(int a,int b) {
	int s=1;
	for(int i=1 ;i<=b ; i++)
		s*=a;
	return s;
}
int main() {
    int n;
    scanf("%d",&n);
    if(n == 7) {    //单独处理，时间更少
        printf("1741725\n");    
        printf("4210818\n");    
        printf("9800817\n");    
        printf("9926315\n");  
    }
    else{
        int num[10]={0};
		for(int i=0 ; i<10 ; i++)
			num[i]=power(i,n);
		for(int i=power(10,n-1) ; i<power(10,n) ;i++) {
			int b=i,sum=0;
			while(b) {
				sum+=num[b%10];
				b/=10;
			}
			if(i==sum)
				printf("%d\n",i);
		}  
    }
    return 0;
}

分析：不管是用数组下标法，还是用pow()函数，或是用自定义函数，将N=7的结果都打印出来后，最终都能AC，且效率大大提升。

但用数组下标法用的是它的思想(重要)

2.Gcd && LCM 问题stien算法和辗转相除法

题目描述及问题分析

		已知两位整数m,n,求其最大公约数和最小公倍数

*(解决这类问题的方法有很多,在这里重点总结效率最高的辗转相除法)

  				以m = 12 , n = 16为例
   						m 	 n 
   						12 	16
  第一步:   ---------------------------gcd(12,16);
  	 t = 12%16 == 12;
  	 m = 16;
     n = 12;	
     
  第二步:  --------------------------gcd(16,12)  ---->gcd(16,12%16);
  	t = 16%12 == 4; 			
  	m = 12;
    n = 4;

  第三步: -------------------------gcd(12,4) ------->gcd(12,16%12);
  	t = 12%4 == 0; 
  	m = 4; 
  	n = 0;

这里演示了辗转相除法的原理,给了几个重要信息:
1.出循环的条件: n == 0;-------------取余分母为0无意义
2.最终的gcd == m;
这个也是递归调用的出递归的条件,即递归出口

循环

int gcd( int m , int n) {
	while(n) { //为分母
		int t = m%n;
		m = n;
		n = t;
	}
	return m;  //为分子
}

递归

基于辗转相除的特性,我们可以用递归来解决该问题,简单明了 每一步的处理形式都形同,通过规律可知下一步为:gcd(n,m%n)

int gcd( int m , int n ) {
	return n == 0 ? m : gcd( n , m%n );
	//当n == 0 时,递归结束

主函数:

int main() {
	int m,n;
	cin>>m>>n;
	cout<<"最大公约数: "<<gcd(m,n)<<endl;
	cout<<"最小公倍数: "<<(m*n)/gcd(m,n);
	//最大公约数 * 最小公倍数 == m*n;
	return 0;
}

c++中STL中的__gcd(x,y)函数

#include <bits/stdc++.h>
#include <algorithm>//其函数在这个库里面
using namespace std;
int main() {
	int m,n;
	cin>>m>>n;
	cout<<"最大公约数: "<<__gcd(m,n)<<endl;  //两者的数据类型要相同
	cout<<"最小公倍数: "<<(m*n)/__gcd(m,n);
	return 0;
}

stein算法(处理超过64位的整数)

代码:

int SteinGcd ( int m, int n ) {
	if(!min(n,n))//最小为0输出最大,递归出口,两种方法都是这个条件
		return max(m,n);//多种情况,这个单独写,用三目运算符反而麻烦
	if(!(m%2) && !(n%2))//m和n都为偶数
		return 2*SteinGcd (m/2,n/2);
	if(!(m%2))//m为偶数
		return SteinGcd (m/2,n);
	if(!(n%2))//n为偶数
		return SteinGcd (m,n/2);
	return SteinGcd ((m+n)/2,abs(m-n)/2);//m和n都为奇数
}

①递归出口: 最小为0输出最大
分析m,n均不为0的情况
②$m_n,n_n$为偶数
$m_{n+1}=m_n/2$
$n_{n+1}=n_n/2$
SteinGcd是返回的数据 $SteinGc{d}_{n+1}=SteinGc{d}_n\ast 2$
③$m_n,$为偶数
$m_{n+1}=m_n/2$
$n_{n+1}=n_n$
SteinGcd是返回的数据 $SteinGc{d}_{n+1}=SteinGc{d}_n$
④$n_n,$为偶数
$m_{n+1}=m_n$
$n_{n+1}=n_n/2$
SteinGcd是返回的数据 $SteinGc{d}_{n+1}=SteinGc{d}_n$
⑤②$m_n,n_n$为奇数
$m_{n+1}=|n_n-m_n|$
$n_{n+1}=min(n_n,m_n)$
SteinGcd是返回的数据 $SteinGc{d}_{n+1}=SteinGc{d}_n$

3. 判断是否为素数

代码:

int isprime(int n) {
	int j = 0;
	if(n < 2 )
		return 0;
	else
		for( int i = 2 ; i*i <= n ; i++ )//效率较高
			if(n%i == 0)
				j++;
	if(j)
		return 0;
	else
		return 1;
}

分析:

由于素数有很多,我们只能根据定义来判断是否为素数
(1)$0和1$既不是素数也不是合数
(2)$2$是素数
(3)$i\ast i\le n$中的等号不能省,因为这样$4$开根号后为$2$,该数不进入循环,会被默认为是素数