数论（未完待续）

数论

素数：

素数筛法
埃氏筛法
欧拉筛法：
尽管Eratosthenes 筛法已经比较快了，但是它任然做了很多冗余的运算，比如说6就会重复被2和3剔除两次。而欧拉筛法则避免了这个问题，它保证了每一个合数只会被它最小的那个因子剔除。
欧拉筛法是从2开始，不断往下处理，并且记录下当前找到的所有素数。然后每处理到一个数，将当前找到的素数与这个数的乘积剔除。直到这个数被某个素数整除为止。
代码：

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int prime[100001];
bool is_prime[100001];
int main()
{
    memset(is_prime,1,sizeof(is_prime));
    int n;
    scanf("%d",&n);
    int cnt=0;
    for(int i=2;i<n;i++)
    {
        if(is_prime[i])
            prime[cnt++]=i;
        for(int j=0;j<cnt&&i*prime[j]<n;j++)
        {
            is_prime[i*prime[j]]=false;
            if(i%prime[j]==0)
                break;
        }
    }
    cout<<endl;
    for(int i=0;i<cnt;i++)
        cout<<prime[i]<<" ";
    cout<<endl;
    return 0;
}

质因数分解：

暴力分解：

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int num[100010];
int main()
{
    int k=0;
    int n;
    scanf("%d",&n);
    while(n%2==0)
    {
        num[k++]=2;
        n/=2;
    }
    for(int i=3;i*i<=n;i++)
    {
        while(n%i==0)
        {
            num[k++]=i;
            n/=i;
        }
    }
    if(n>2)
       num[k++]=n;
    for(int i=0;i<k;i++)
       cout<<num[i]<<" ";
    return 0;
}

欧拉函数：
欧拉函数φ(n)表示1,2,…,n中有多少个数与n互质。
设n=∏_(i=1)^m▒p_i(q_i ) ，则
φ(n)=∏_(i=1)^m▒〖(p_i-1) p_i^(q_i-1) 〗=n∏_(i=1)^m▒(1-1/p_i )
φ(1)=1, φ(2)=1, φ(3)=2, φ(4)=2, φ(5)=4, φ(6)=2, …

原根的个数为φ(φ(n))，n为奇质数时，为φ(n-1)

整除与剩余

快速幂运算：

typedef long long ll;
ll Quick_Pow(ll x,ll n)
{
    ll res=1;
    while(n>0)
    {
        if(n&1)
            res*=x;
        x*=x;
        n>>=1;
    }
    return res;
}
ll Quick_Pow2(ll x,ll n)
{
    ll res=1;
    if(n==0)
        return 1;
    if(n&1)
        res*=x;
    res=Quick_Pow(x*x,n/2);
    return res;
}

欧几里得算法：

裴蜀定理：

若a和b是整数，方程ax+by=c有整数解当且仅当gcd⁡(a,b)|c。
例如，方程3x+6y=2就不存在整数解，方程3x+6y=3存在（无数多个）整数解，其中一个是x=1，y=0。
这个定理给我们了一个判定形如ax+by=c的方程是否有整数解的方法，但是它并没有告诉我们如何求解。求解这样的方程是扩展欧几里得算法的内容。

扩展欧几里得算法：

typedef long long ll;
int extgcd(int a,int b,int &x,int &y)
{
    int d=a;
    if(b!=0)
    {
        d=extgcd(b,a%b,y,x);
        y-=(a/b)*x;
    }
    else{
        x=1;
        y=0;
    }
    return d;
}

中国剩余定理：
有 n个方程, 第 i个方程为 x≡a_i (mod m_i)，求最小的 x。
类似插值的方法: 设M=∏_(i=1)^n▒m_i ，M_i=M/m_i ，t_i M_i≡1(mod m_i )，则在 (mod M) 的意义下, 该方程组只有一个解：x=∑_(i=1)^n▒〖a_i t_i M_i 〗。
若m_i不互质，则要用扩展欧几里得合并方程组。
x=m_1 p+a_1=m_2 q+a_2，即m_i p-m_2 q=a_2-a_1 。

若a_1 !≡a_2 (mod t)，则线性同余方程组无解。
将方程两边同时除以t，记新方程为ap+bq=c。
用扩展欧几里得得到该方程的一组特解(p_0,q_0 )，通解为p=p_0+k×b，k为整数。
则合并后的方程为m_1 (p_0+k×b)+a_1=x。
即x mod (m_1×b)=m_1 x_0+a_1。

例题POJ 2981
代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll extgcd(ll a,ll b,ll& x,ll& y)
{
    ll d=a;
    if(b!=0)
    {
        d=extgcd(b,a%b,y,x);
        y-=(a/b)*x;
    }
    else
    {
        x=1;
        y=0;
    }
    return d;
}
ll k;
int main()
{
    while(~scanf("%lld",&k))
    {

    ll a1,r1;
    ll a2,r2;
    //cout<<k<<endl;
    for(int i=0;i<k;i++)
    {
        scanf("%lld%lld",&a1,&r1);
        bool flag=true;                       //标记是否有解
        for(ll i=1;i<k;i++)
        {
            scanf("%lld%lld",&a2,&r2);
            ll k1,k2;
            ll d=extgcd(a1,a2,k1,k2);        //得特解k1，注意此时的特解并非最小的
            //cout<<d<<endl;
            ll r=r2-r1;
            if(r%d!=0)            //r1,r2的差不是gcd(a1,a2)的倍数，拓展欧几里得无解
            {
                flag=false;
                continue;
            }
            ll t=a2/d;                     //通解k0=k1+t*m   （m属于整数）
            k1=(k1*(r/d)%t+t)%t;           //特解根据通解公式求最小正特解k1
            ll P=a1*k1+r1;                 //P为最小正特解，所以通解P0=P+lcm(a1,a2)*t，所以p0%lcm=P+
            ll lcm=a1*a2/d;                //a1,a2的最小公倍数
            a1=lcm;                        //a1 r1是两个式子合并后的新式子
            r1=P%lcm;
        }
        printf("%lld\n",flag?r1:-1);
    }
    }
    return 0;
}