一、数论算法

（一）求最大公约数

思路：辗转相除法(欧几里德算法)

int Gcd(int a,int b)
{
    if(a<b)
    {
        int tmp=a;
        a=b;
        b=tmp;
}
    while(a%b)
    {
        int tmp=a%b;
        a=b;
        b=tmp;
}
    return b;
}

（二）求最小公倍数

思路：对于整数a,b,lcm(a,b)=a*b/gcd(a,b)

int Lcm(int a,int b)
{
    int gcdnum=Gcd(a,b);
    return a*b/gcdnum;
}

 (三)求能整除n!的m的最大次幂

思路：

先将M质数分解，然后对M的每个素数因子求N！的最高次幂。

例如M = 45 N = 67，其中45 = 3 ^ 2 * 5 ^ 1，即45的素数因子为3 和 5，而67！中3的最高次幂为31，5的最高次幂为15.这样就可以确定67！中45的最高幂为15，因为67！中每2个3，1个5就包含                 一个45，换句话说也就是求67！中包含了多少（3^2*5^1）这样的组合，也就是求min （ 31 / 2， 15 / 1 ）。

#include <iostream>
#include <cstring> 
using namespace std;
int getsum(int n,int x)
{//计算1~n之间包含一个因子x的个数
    int ans=0;
    while(n)
    {
        ans+=n/x; n/=x;
    }
    return ans;
}
int main(int argc, char *argv[])
{
    int n,m,i,j,t,c=1,temp,ans,a;
    cin>>t;
    while(t--)
    {
        cin>>m>>n;
        i=2; ans=1000000;
        while(m>1)
        {    
a=0;
            while(m%i==0)
            {
                a++; m/=i;
            }
            if(a)
            {
                temp=getsum(n,i)/a;
                if(ans>temp) ans=temp;
            }
            i++;
        }
        cout<<"Case "<<c++<<":"<<endl; 
        if(ans) cout<<ans<<endl;
        else cout<<"Impossible to divide"<<endl; 
    } 
    return 0;
}

（四）全排列

1、递归实现全排列（所有元素视为不同元素）

template<class T>
void Swap(T & a, T & b)
{
    T temp = a;
    a = b;
    b = temp;
}
template<class T>
void permutations(T list[], int k, int m)
{
    if (k == m)
    {
        //copy(list,list+m+1,ostream_iterator<T>(cout,""));
        for (int i = 0; i <= m; i++)
            cout << list[i] << ' ';
        cout << endl;
    }
    else
    {
        for (int i = k; i <= m; i++)
        {
            Swap(list[k], list[i]);
            permutations(list, k + 1, m);
            Swap(list[k], list[i]);
        }
    }
}

2、STL实现全排列（所有元素视为不同元素）

void permutation(char* str, int length)
{
    sort(str, str + length);
    do
    {
        for (int i = 0; i<length; i++)
            cout << str[i];
        cout << endl;
    } while (next_permutation(str, str + length));
}

3、递归实现全排列（重复元素视为相同元素）

template<class T>
void permutation(T a[], int t, int n)
{
    if (t == n)
    {
        for (int i = 0; i<n; i++)
        {
            cout << a[i] << " ";
        }
        cout << endl;
        return;
    }
    for (int j = t; j<n; j++)
    {
        int flag = 1;
        for (int r = t; r<j; r++)
        {
            if (a[r] == a[j])
            {
                flag = 0;
                break;
            }
        }
        if (flag == 0)
        {  //不符合条件跳入下一循环
            continue;
        }
        swap(a[j], a[t]);
        permutation(a, t + 1, n);
        swap(a[j], a[t]);
    }
}

（五）组合

1、对无重复的n个元素，求取m个元素的组合，并输出这些组合

void dfs(int st, int cur)
{//求n个不同的数中取m个元素的组合，调用：dfs(n-1,0);ininum为排好序的且无相同元素的数组，num为临时数组
    if (cur>=m)
        return;
    for (int i = st; i >= 0; --i)
    {
        int v = ininum[i];
        vis[v] = 1;
        num[cur] = v;
        if (cur == m - 1)
        {
            for (int j = 0; j < m; j++)
            {
                cout << num[j] << ' ';
            }
            cout << endl;
        }
        dfs(i - 1, cur + 1);
    }
}

2、对含有重复元素的n个元素（重复元素视为相同元素），求取m个不同元素的组合，并输出这些组合

#include <stdio.h>
#include <stdlib.h>
#define MAX_NUM 26
int comb[MAX_NUM];
int c1,c2;
void combination(int m,int n) {
    int i,j;

    for (i=m;i>=n;i--) {
        comb[n]=i; /* 选择当前的“头”元素 */
        if (n>1) {
            combination(i-1,n-1); /* 进入下一次更小的组合问题 */
        } else { /* 满了需要的组合数，输出 */
            for (j=comb[0];j>0;j--) printf("%c",'A'+c1-comb[j]);
            printf("
");
        }
    }
    return;
}
int main(int argc,char **argv) {
    if (argc<3) {
        printf("%s 组合下标 组合上标
",argv[0]);
        return 1;
    }
    c1=atoi(argv[1]);
    if (c1<1 || MAX_NUM<c1) {
        printf("1<=组合下标<=%d
",MAX_NUM);
        return 2;
    }
    c2=atoi(argv[2]);
    if (c2<1 || c1<c2) {
        printf("1<=组合上标<=组合下标
");
        return 3;
    }
    comb[0]=c2;
    combination(c1,c2);
    return 0;
}

(六)容斥原理

原理：

（1）|A∪B∪C|=|A|+|B|+|C|-|A∩B|-|A∩C|-|B∩C|+|A∩B∩C|

（2）|A∪B∪C∪D|=|A|+|B|+|C|+|D|-|A∩B|-|A∩C|-|A∩D|-|B∩C|-|B∩D|-|C∩D|+|B∩C∩D|+|A∩C∩D|+|A∩B∩D|+|A∩B∩C|-|A∩B∩C∩D|

（3）

容斥原理可与二进制位运算枚举方案数相结合。

（七）快速幂

1、快速幂取模

以下以求a的b次方来介绍

把b转换成二进制数。

该二进制数第i位的权为 2^(i-1)

例如

11的二进制是1011

11 = 2³×1 + 2²×0 + 2¹×1 + 2º×1

因此，我们将a¹¹转化为算a^(2^0)*a^(2^1)*a^(2^3)

long long  quickpow(long long   m , long long   n , long long   k){ 
    long long   ans = 1; 
    while(n){ 
        if(n&1) //取b二进制的最低位，判断和1是否相同，相同返回1，否则返回0，可用于判断奇偶 
            ans = (ans * m) % k; 
        n = n >> 1; //把b的二进制右移一位，即去掉其二进制位的最低位
        m = (m * m) % k; 
    } 
    return ans; 
} 

2、矩阵快速幂

//定义一个矩阵类，例如求（A^n）%mod 
class Matrix { 
public: 
     long long m[MAXN][MAXN]; //二维数组存放矩阵 
    Matrix(){} //对数组的初始化 
    void init(long long  num[MAXN][MAXN])//重载矩阵的乘法运算
    {
        for(int i = 0 ; i < MAXN ; i++)
        { 
            for(int j = 0 ; j < MAXN ; j++)
            { 
                m[i][j] = num[i][j]; 
            } 
       } 
    } 
    friend Matrix operator*(Matrix &m1 ,Matrix &m2) //矩阵的快速幂
    { 
        int i, j, k; 
        Matrix temp; 
        for (i = 0; i < MAXN; i++) 
        { 
            for (j = 0; j < MAXN; j++) 
            { 
                temp.m[i][j] = 0; 
                for(k = 0 ; k < MAXN ; k++) //注意每一步都进行取模 
                   temp.m[i][j] += (m1.m[i][k] * m2.m[k][j])%mod 
                temp.m[i][j] %= mod; 
           } 
        } 
        return temp; 
    } 
    friend Matrix quickpow(Matrix &M , long long n)//初始化为单位矩阵 
    { 
        Matrix tempans; 
        //初始化 
        for(int i = 0 ; i < MAXN ; i++)
        { 
            for(int j = 0 ; j < MAXN ; j++)
            { 
                if(i == j) 
                    tempans.m[i][j] = 1; 
                else 
                    tempans.m[i][j] = 0; 
            } 
        } 
        //快速幂（类似整数） 
        while(n)
        { 
            if(n & 1)    www.2cto.com
                tempans = tempans * M; //已经重载了* 
            n = n >> 1; 
            M = M * M; 
        } 
       return tempans; 
    } 
}; 
 
int main() 
{ 
    Matrix A , ans; 
    long long T , n , k , sum; //数据类型为long long 
    long long num[MAXN][MAXN]; //输入的数据存入数组 
    scanf("%lld" , &T); 
    while(T--)
    { 
        scanf("%lld%lld
", &n , &k); 
        memset(num , 0 , sizeof(num)); 
        for(int i = 0 ; i < n ; i++)
        { 
            for(int j = 0 ; j < n ; j++) 
                scanf("%lld" , &num[i][j]); 
        } 
        A.init(num);//初始化A矩阵 
        ans = quickpow(A , k);//求出矩阵的快速幂 
    } 
}