以下内容整理自《算法笔记》—胡凡
引子—数学黑洞问题
题目大意：给定四个0~9的数字，按照升序排列得到一个正整数MIN，按照降序排列得到一个正整数MAX，n=MAX-MIN，那么对n的四位也做同样的操作，发现到了最后会循环得到一个数：6174，请证明这个过程
使用函数实现功能是一个好习惯，比如这个题如果不使用函数的话，直接在主函数中用MAX和MIN去充当to_number中的sum参数，是非常危险的，如果不在循环的开头将它们置零的话。但是使用函数实现这个功能的话就从根本上消除了这个问题
#include <iostream>
#include <algorithm>
using namespace std;
bool cmp(int a,int b)
{
return a>b;
}
void to_array(int n,int num[])//将数字的各个位存入数组
{
for(int i=0;i<4;i++)
{
num[i]=n%10;
n=n/10;
}
}
int to_number(int num[])//将数组转换成数字
{
int sum=0;
for(int i=0;i<4;i++)
{
sum=sum*10+num[i];
}
return sum;
}
int main()
{
int n,MIN,MAX;
cin>>n;
int num[5];
while(1)
{
to_array(n,num);
sort(num,num+4);
MIN=to_number(num);
sort(num,num+4,cmp);
MAX=to_number(num);
n=MAX-MIN;
cout<<MAX<<"-"<<MIN<<"="<<n<<endl;
if(n==0||n==6174) break;
}
}
最大公约数和最小公倍数
最大公约数可以使用辗转相除法：
int gcd(int a,int b)
{
if(b==0) return a;
else
{
return gcd(b,a%b);
}
}
假设两个数分别是a和b，最大的公约数是d，那么，最小的公倍数是ab/d
分数的简化以及四则运算
没有啥需要注意的，对了，减法不能用minus，貌似会冲突，随便定义为minu
其余的需要注意的点在以下注释中已经注明
#include <iostream>
#include <algorithm>
using namespace std;
struct fraction
{
int up;
int down;
fraction(int x,int y):up(x),down(y){}
fraction(){}//如果只使用上面的初始化方法，那么无法不通过参数传递，必须要通过参数传递
};
int gcd(int a,int b)//求最大公因数
{
if(b==0) return a;
else
{
return gcd(b,a%b);
}
}
fraction reduction(fraction result)//约分
{
if(result.down<0)//将负号统一放到分子
{
result.up=-result.up;
result.down=-result.down;
}
if(result.up==0)//分子为零，就让分母为一
{
result.down=1;
}
else//只要分子不为零就可以进行约分
{
int d=gcd(abs(result.up),abs(result.down));
result.up/=d;
result.down/=d;
}
return result;
}
//以下为四则运算
fraction add(fraction f1,fraction f2)
{
fraction result;
result.up=f1.up*f2.down+f2.up*f1.down;
result.down=f1.down*f2.down;
return reduction(result);
}
fraction minu(fraction f1,fraction f2)
{
fraction result;
result.up=f1.up*f2.down-f2.up*f1.down;
result.down=f1.down*f2.down;
return reduction(result);
}
fraction multi(fraction f1,fraction f2)
{
fraction result;
result.up=f1.up*f2.up;
result.down=f1.down*f2.down;
return reduction(result);
}
fraction divide(fraction f1,fraction f2)
{
fraction result;
result.up=f1.up*f2.down;
result.down=f1.down*f2.up;
return reduction(result);
}
void showFraction(fraction r)
{
r=reduction(r);
if(r.down==1) cout<<r.up<<endl;
else if(abs(r.up)>r.down)
cout<<r.up/r.down<<" "<<r.up%r.down<<"/"<<r.down<<endl;
else cout<<r.up<<"/"<<r.down<<endl;
}
int main()
{
fraction test=fraction(1,2);
fraction test2=fraction(2,3);
fraction Test=add(test,test2);
showFraction(Test);
fraction Test2=minu(test,test2);
showFraction(Test2);
fraction Test3=multi(test,test2);
showFraction(Test3);
fraction Test4=divide(test,test2);
showFraction(Test4);
}
素数
（1）构建素数表的两种方法（第二种略快）MAX代表素数表的上限
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int MAX=101;
int prime[MAX],pNum =0;//pNum作为指向prime的指针，也可以表示当前数组储存的素数的数目大小
bool p[MAX]={0};
bool isPrime(int n)//这样判断部分的时间复杂度就是根号n
{
if(n<=1) return false;
int sqr=(int)sqrt(1.0*n);
for(int i=2;i<=sqr;i++)
{
if(n%i==0) return false;
}
return true;
}
void findPrime()
{
for(int i=1;i<MAX;i++)
{
if(isPrime(i)==true)
{
prime[pNum++]=i;
p[i]=true;
}
}
}
int main()
{
findPrime();
for(int i=0;i<pNum;i++)
{
cout<<prime[i]<<" ";
}
}
//时间复杂度是O(nlogn)
#include <iostream>
#include <cmath>
using namespace std;
//简单来说就是因为素数的倍数一定不是素数这个原理进行消除
const int MAX=101;
int prime[MAX],pNum=0;//储存数组
bool p[MAX]={0};//判断是否是素数的数组
void findPrime()
{
for(int i=2;i<MAX;i++)
{
if(p[i]==false)//这个数是素数
{
prime[pNum++]=i;
for(int j=i+i;j<MAX;j+=i)
p[j]=true;//它的倍数不是素数
}
}
}
int main()
{
//时间复杂度是O(nloglogn)
findPrime();
for(int i=0;i<pNum;i++)
cout<<prime[i]<<" ";
}
//注：假设输出格式是每十个数字占一行，以空格分隔，但是行末不得有多余的空格
//for(int i=m;i<=n;i++)
//{
// cout<<prime[i-1];
// count++//初始值为0
// if(count%10!=0&&i<n) cout<<" ";
// else
// cout<<endl;
//}
应用：分解质因数
概论：先用上述的方法制作好质数表，然后对于在0~sqrt(目的数）之间的每个质数进行尝试，对于某个质数可以整除就整除到不能整除为止，最后要么剩下1，要么就剩下一个大于sqrt(目的数）的数（绝对是质数）。在这个过程中记得保存和输出即可（这里采用第一种方法打表）
#include <iostream>
#include <cmath>
using namespace std;
const int MAX=100010;
bool is_Prime(int n)
{
if(n==1) return false;
int sqr=(int)sqrt(1.0*n);
for(int i=2;i<=sqr;i++)
{
if(n%i==0) return false;
}
return true;
}
int prime[MAX],pNum=0;
void findPrime()
{
for(int i=1;i<MAX;i++)
{
if(is_Prime(i)==true)
{
prime[pNum++]=i;
}
}
}//制作质数表以便应用打表法
struct factor
{
int x,cnt;
}fac[10];//一般不会超过10个不同的因数（都是质数），毕竟需要在int的范围内
int main()
{
findPrime();
int n,num=0;
cin>>n;
if(n==1) cout<<"1=1";
else
{
cout<<n<<"=";
int sqr=(int)sqrt(1.0*n);
for(int i=0;i<pNum&&prime[i]<=sqr;i++)//条件保证 用来尝试的质因数在表中 且没有过根号n
{
if(n%prime[i]==0)
{
fac[num].x=prime[i];
fac[num].cnt=0;
while(n%prime[i]==0)
{
fac[num].cnt++;
n/=prime[i];
}
num++;
}
if(n==1) break;
}
if(n!=1)
{
fac[num].x=n;
fac[num].cnt=1;
num++;
}
for(int i=0;i<num;i++)
{
if(i>0) cout<<"*";
cout<<fac[i].x;
if(fac[i].cnt>1)
cout<<"^"<<fac[i].cnt;
}
}
}
高精度
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
struct bigNumber
{
int d[1000];
int len;
bigNumber()
{
memset(d,0,sizeof(d));
len=0;
}
};
bigNumber Transform(string a)
{
bigNumber m;
m.len=a.size();
for(int i=0;i<m.len;i++)
{
m.d[i]=a[m.len-i-1]-'0';//保证数组是从低到高来储存
}
return m;
}
//高精度加法（对于两个非负数而言），如果是其中一个为负数，那么使用高精度减法，都是负数，先去掉负号进行相加，最后加上
bigNumber add(bigNumber a,bigNumber b)
{
bigNumber c;
int carry=0;
for(int i=0;i<a.len||i<b.len;i++)
{
int temp=(a.d[i]+b.d[i]+carry);//使用临时值是一个好习惯，这里可以不用
c.d[i]=temp%10;
c.len++;
carry=temp/10;
}
if(carry!=0)
c.d[c.len++]=carry;
return c;//一定不要忘记返回值
}
bigNumber minu(bigNumber a,bigNumber b)
{
bigNumber c;
for(int i=0;i<a.len||i<b.len;i++)
{
if(a.d[i]<b.d[i])
{
a.d[i+1]--;
c.d[i]=a.d[i]+10-b.d[i];
c.len++;
}
else
{
c.d[i]=a.d[i]-b.d[i];
c.len++;
}
}
//为了防止两个数相同的情况下，会输出0000这样的数，所以我们需要对其进行去零处理
while(c.len>1&&c.d[c.len-1]==0)//输出长度不能为零，所以长度必须至少有1
{
c.len--;
}
return c;
}
//对于乘法而言，每次都是a的一位去乘以b，所得到的结果的个位数作为结果，其余的高位作为进位
//所以这里将 与每一个位相乘 单独拿出来作为一个函数
bigNumber multi(bigNumber a,int b)
{
bigNumber c;
int carry=0;
for(int i=0;i<a.len;i++)
{
int temp=a.d[i]*b+carry;
c.d[c.len++]=temp%10;
carry=temp/10;
}
while(carry!=0)
{
c.d[c.len++]=carry%10;
carry/=10;//不要忘记等号。。。。。。
}
return c;
}
bigNumber Multi(bigNumber a,bigNumber b)
{
bigNumber D;
for(int i=0;i<b.len;i++)
{
D.len=i;
bigNumber c=multi(a,b.d[i]);
for(int i=0;i<c.len;i++)
{
int temp=D.d[D.len]+c.d[i];
D.d[D.len]=temp%10;
D.d[D.len+1]+=temp/10;
D.len++;
}
}
return D;
}
//两个大数的除法有点复杂，这里暂且只讨论大数除以某个int整数
//其实思路大同小异，两个大数的除法就是手算的过程，尝试商的过程可以用高精度减法实现，对齐，求减法减为负数的次数，再对齐
bigNumber divide(bigNumber m,int b,int& r)//b为除数，a为被除数
{
bigNumber c;
c.len=m.len;
for(int i=m.len-1;i>=0;i--)
{
r=r*10+m.d[i];
if(r<b) c.d[i]=0;//不够除
else//够除
{
c.d[i]=r/b;
r=r%b;
}
}
//去0
while(c.len>1&&c.d[c.len-1]==0)//删除到只剩一位或者没有0
{
c.len--;
}
return c;
}
int main()
{
int x=2;
int r=0;
string a="88888888";
string b="88888888";
bigNumber test=Transform(a);
bigNumber test1=Transform(b);
bigNumber Test=add(test,test1);
for(int i=Test.len-1;i>=0;i--)
{
cout<<Test.d[i];
}
cout<<endl;
bigNumber Test2=minu(test,test1);
for(int i=Test2.len-1;i>=0;i--)
{
cout<<Test2.d[i];
}
cout<<endl;
bigNumber Test3=Multi(test,test1);
for(int i=Test3.len-1;i>=0;i--)
{
cout<<Test3.d[i];
}
cout<<endl;
bigNumber Test4=divide(test,2,r);
for(int i=Test4.len-1;i>=0;i--)
{
cout<<Test4.d[i];
}
}
math的常见函数
1.fabs(double x)：对double型的变量取绝对值（记得和algorithm中的abs区分开）
2.floor(double x)和ceil(double x): 对double型变量向下取整和向上取整，返回值为double类型
3.pow(double r, double p): 返回值是rp, 要求r和p都是double类型的
4.sqrt(double x): 返回double型变量的算数平方根
5.log(double x): 返回某double型变量的以自然对数为底的对数
注：以任意为底的对数的计算都应该转换成以e为底的对数的计算
6.sin(double x) cos(double x) tan(double x): double变量的正弦余弦正切值
注：弧度制（所以x可以含有π）
7.asin(double x) acos(double x) atan(double x): double型变量的反正弦反余弦反正切值（都是弧度）
8.round(double x): 四舍五入，返回的类型也是double类型，如果取整，那么应该强制类型转换
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
