我的模板（持续更新ing）[早就不更新了]

头文件

短的：

#include<bits/stdc++.h>
#define cl(a,b) memset(a,b,sizeof(a))
#define debug(a) cerr<<#a<<"=="<<a<<endl
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

const int maxn=1e5+10;

int main()
{

    return 0;
}/*



*/

长的：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string>
#include<ctime>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<cstdlib>
#include<cassert>
#include<sstream>
#include<stack>
#include<list>
#include<bitset>
#define cl(a,b) memset(a,b,sizeof(a))
#define debug(x) cerr<<#x<<"=="<<(x)<<endl
using namespace std;
typedef long long ll;
typedef long double ldb;
typedef pair<int,int> pii;

const int inf=0x3f3f3f3f;
const int maxn=1e9+10;
const int mod=1e7+7;
const double eps=1e-8;
const double pi=acos(-1);

int dx[8]= {0,0,1,-1,1,-1,1,-1};
int dy[8]= {1,-1,0,0,-1,1,1,-1};

ll gcd(ll a,ll b){return a?gcd(b%a,a):b;}
ll powmod(ll a,ll x,ll mod){ll t=1;while(x){if(x&1)t=t*a%mod;a=a*a%mod;x>>=1;}return t;}
//---------------------------------------ヽ(^。^)丿
int main()
{

    return 0;
}
/*



*/

超神读入挂

#define JUDGE

#ifdef DEBUG
inline bool read(int &ret)
{
    if(scanf("%d",&ret)==EOF) return false;
    return true;
}
#endif  DEBUG

#ifdef JUDGE
namespace fastIO {
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if(p1 == pend) {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pend == p1) {
                IOerror = 1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) {
        return ch == ' ' || ch == '
' || ch == '
' || ch == '	';
    }
    inline bool read(int &x) {
        char ch;
        while(blank(ch = nc()));
        if(IOerror)
            return false;
        for(x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
        return true;
    }
    #undef BUF_SIZE
};
using namespace fastIO;
#endif JUDGE

矩阵快速幂

struct matrix
{
    ll a[maxn][maxn];
    int row,col;
    matrix():row(maxn),col(maxn){cl(a,0);}
    matrix(int x,int y):row(x),col(y){cl(a,0);}
    void show()
    {
        for(int i=0; i<row; i++)
        {
            for(int j=0; j<col; j++)
            {
                printf("%d%c",a[i][j],j==col-1?'
':' ');
            }
        }
    }
    inline ll* operator [] (int x)
    {
        return a[x];
    }
    inline matrix operator * (matrix x)
    {
        matrix tmp(row,col);
        for (int i=0; i<row; i++)
            for (int j=0; j<col; j++)
                for (int k=0; k<row; k++)
                    tmp[i][j]=(tmp[i][j]+a[i][k]*x[k][j])%mod;
        return tmp;
    }
    inline void operator *= (matrix x)
    {
        *this = *this * x;
    }
    matrix operator ^ (ll x)
    {
        matrix result(row,col),now=*this;
        for(int i=0; i<row; i++)
        {
            result[i][i]=1;
        }
        while(x)
        {
            if(x%2) result*=now;
            now*=now;
            x/=2;
        }
        return result;
    }
};

降维线段树（区间更新+单点更新）

#define ls getid(l,l+r>>1)
#define rs getid((l+r>>1)+1,r)
#define lson l,m,ls
#define rson m+1,r,rs

typedef long long ll;

const int maxn = 1e5+10;

inline int getid(int x,int y)
{
    return x+y|y!=x;
}

ll rm[maxn<<1],col[maxn<<1];

void pushup(int l,int r,int rt)
{
    rm[rt]=rm[ls]+rm[rs];
}

void pushdown(int l,int r,int rt,int k)
{
    if (col[rt])
    {
        col[ls] += col[rt];
        col[rs] += col[rt];
        rm[ls] += col[rt]*(k-(k>>1));
        rm[rs] += col[rt]*(k>>1);
        col[rt] = 0;
    }
}

void build(int l,int r,int rt)
{
    if(l == r)
    {
        scanf("%I64d",&rm[rt]);
        return ;
    }
    int m=l+r>>1;
    build(lson);
    build(rson);
    pushup(l,r,rt);
}

void update(int L,int R,int c,int l,int r,int rt)
{//区间更新
    if(L<=l && r<=R)
    {
        col[rt]+=c;
        rm[rt]+=c*(r-l+1);
        return ;
    }
    pushdown(l,r,rt,r-l+1);
    int m=l+r>>1;
    if( L <= m ) update(L,R,c,lson);
    if (R > m) update(L,R,c,rson);
    pushup(l,r,rt);
}

void update(int p,int c,int l,int r,int rt)
{//单点更新
    if(l==r)
    {
        rm[rt]+=c;
        return ;
    }
    int m=l+r>>1;
    if( p <= m ) update(p,c,lson);
    else update(p,c,rson);
    pushup(l,r,rt);
}

ll query(int L,int R,int l,int r,int rt)
{
    if( L<=l && r<=R )
    {
        return rm[rt];
    }
    pushdown(l,r,rt, r-l+1);
    int m=l+r>>1;
    ll ret = 0;
    if( L<=m ) ret += query(L,R,lson);
    if( m<R ) ret += query(L,R,rson);
    return ret;
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    char str[2];
    build(1,n,1);
    while(m--)
    {
        int l,r,x;
        scanf("%s",str);
        if(str[0]=='Q')
        {
            scanf("%d%d",&l,&r);
            printf("%I64d
",query(l,r,1,n,1));
        }
        else
        {
            scanf("%d %d %d", &l, &r, &x);
            update(l, r, x, 1, n, 1);
        }
    }
    return 0;
}

字典树求异或值

typedef long long ll;

const int maxn=1e5+10;

struct t
{
    ll tree[32*maxn][3];//字典树的树部分
    ll val[32*maxn];//字典树的终止节点
    ll cnt;//字典树的大小
    void init() //初始化字典树
    {
        cl(tree,0);
        cl(val,0);
        cnt=1;
    }
    void add(ll a)
    {
        int x=0,now;
        for(int i=32; i>=0; i--)
        {
            now=((a>>i)&1); //当前位数
            if(tree[x][now]==0) //没有的这个节点的话 加入这个节点
            {
                cl(tree[cnt],0);
                val[cnt]=0;
                tree[x][now]=cnt++;
            }
            x=tree[x][now];
        }
        val[x]=a; //结尾标记
    }
    ll Search(ll a) //查找字典树中和a异或起来最大的值
    {
        int x=0,now;
        for(int i=32; i>=0; i--)
        {
            now=!((a>>i)&1);
            if(tree[x][now]) //如果和当前位相反的这个节点存在
            {
                x=tree[x][now]; //那么继续找这个节点下的子树
            }
            else
            {
                x=tree[x][!now]; //不存在就找自己这个节点下的子树
            }
        }
        return val[x]; //结尾标记就是这个数字
    }
} Trie;

马拉车算法求最长回文串

string longestPalindrome(string ss)
{
    string s="#";
    for(auto i:ss)
    {
        s+=i;
        s+="#";
    }
    int c=0,r=0;
    vector<int>p(s.size(),0);
    for(int i=0;i<s.size();i++)
    {
        if(r>i) p[i]=min(r-i,p[2*c-i]);
        while((i-1-p[i])>=0
            &&(i+1+p[i])<s.size()
            &&s[i+1+p[i]]==s[i-1-p[i]]) 
                p[i]++;
        if(i+p[i]>r)
        {
            r=i+p[i];
            c=i;
        }
    }
    int ans=0,mid=0;
    for(int i=0;i<s.size();i++)
    {
        if(p[i]>ans)
        {
            ans=p[i];
            mid=i;
        }
    }
    return ss.substr((mid-ans)/2,ans);
}

lucas定理

ll fac[maxn];

ll quick_pow(ll a,ll n)
{
    ll ans=1;
    while(n)
    {
        if(n%2) ans=1ll*ans*a%mod;
        a=1ll*a*a%mod;
        n>>=1;
    }
    return ans;
}

ll inv(ll a)
{
    return quick_pow(a,mod-2);
}

void init()
{
    fac[0]=1;
    for(int i=1;i<maxn;i++)
    {
        fac[i]=1ll*fac[i-1]*i%mod;
    }
}

ll C(ll a,ll b)
{
    ll ans=1;
    if(a<b || b<0) return 0;
    while(a&&b)
    {
        ll aa=a%mod,bb=b%mod;
        if(aa<bb) return 0;;
        ans = 1ll*ans*fac[aa]%mod * inv(1ll*fac[bb]*fac[aa-bb]%mod)%mod;
        a/=mod,b/=mod;
    }
    return ans;
}

O(n)预处理Cm n

const int maxn=1e6+10;
const int mod=1e9+7;
ll fac[maxn],f[maxn],inv[maxn];

void init()
{
    fac[0]=fac[1]=f[0]=f[1]=inv[0]=inv[1]=1;
    for(int i=2;i<maxn;i++)
    {
        fac[i]=fac[i-1]*i%mod;   // n！
        ll t=mod/i,k=mod%i;
        f[i]=(mod-t)*f[k]%mod;  // n的逆元
        inv[i]=inv[i-1]*f[i]%mod; // n！的逆元
    }
}

ll C(ll n,ll m)
{
    if(n<m) return 0;
    return fac[n]*inv[m]%mod*inv[n-m]%mod;
}

自适应simpson积分

double simpson(double a,double b)
{
    double c=a+(b-a)/2;
    return (f(a)+4*f(c)+f(b))*(b-a)/6;
}

double asr(double a,double b,double eps,double A)
{
    double c=a+(b-a)/2;
    double L=simpson(a,c);
    double R=simpson(c,b);
    if(fabs(L+R-A)<=15*eps) return L+R+(L+R-A)/15.0;
    return asr(a,c,eps/2,L)+asr(c,b,eps/2,R);
}

double asr(double a,double b,double eps)
{
    return asr(a,b,eps,simpson(a,b));
}

日期公式

int zeller(int y,int m,int d)
{//计算星期几
    if(m<=2) y--,m+=12;
    int c=y/100;y%=100;
    int w=((c>>2)-(c<<1)+y+(y>>2)+(13*(m+1)/5)+d-1)%7;
    if(w<0) w+=7; return (w);
}

int getid(int y,int m,int d)
{//计算每个日期的id 可以计算两个日期之间的天数
    if(m<3) {y--;m+=12;}
    return 365*y+y/4-y/100+y/400+(153*m+2)/5+d;
}

费用流（uva11248）

// UVa11248 Frequency Hopping：使用Dinic算法
// Rujia Liu
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn = 100 + 10;
const int INF = 1000000000;

struct Edge
{
    int from, to, cap, flow;
    bool operator < (const Edge& b)
    {
        return from < b.from || (from == b.from && to < b.to);
    }
};

struct Dinic
{
    int n, m, s, t;         //点的编号从0开始
    vector<Edge> edges;    // 边数的两倍
    vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
    bool vis[maxn];         // BFS使用
    int d[maxn];           // 从起点到i的距离
    int cur[maxn];        // 当前弧指针

    void ClearAll(int n)
    {
        for(int i = 0; i < n; i++) G[i].clear();
        edges.clear();
    }

    void ClearFlow()
    {
        for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;
    }

    void AddEdge(int from, int to, int cap)
    {
        edges.push_back((Edge){from, to, cap, 0});
        edges.push_back((Edge){to, from, 0, 0});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        while(!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for(int i = 0; i < G[x].size(); i++)
            {
                Edge& e = edges[G[x][i]];
                if(!vis[e.to] && e.cap > e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x, int a)
    {
        if(x == t || a == 0) return a;
        int flow = 0, f;
        for(int& i = cur[x]; i < G[x].size(); i++)
        {
            Edge& e = edges[G[x][i]];
            if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0)
            {
                e.flow += f;
                edges[G[x][i]^1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
        return flow;
    }

    int Maxflow(int s, int t)
    {
        this->s = s;
        this->t = t;
        int flow = 0;
        while(BFS())
        {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }

    vector<int> Mincut()   // call this after maxflow
    {
        vector<int> ans;
        for(int i = 0; i < edges.size(); i++)
        {
            Edge& e = edges[i];
            if(vis[e.from] && !vis[e.to] && e.cap > 0) ans.push_back(i);
        }
        return ans;
    }

    void Reduce()
    {
        for(int i = 0; i < edges.size(); i++) edges[i].cap -= edges[i].flow;
    }
};

Dinic g;

int main()
{
    int n, e, c, kase = 0;
    while(scanf("%d%d%d", &n, &e, &c) == 3 && n)
    {
        g.ClearAll(n);
        while(e--)
        {
            int b1, b2, fp;
            scanf("%d%d%d", &b1, &b2, &fp);
            g.AddEdge(b1-1, b2-1, fp);
        }
        int flow = g.Maxflow(0, n-1);
        printf("Case %d: ", ++kase);
        if(flow >= c) printf("possible
");
        else
        {
            vector<int> cut = g.Mincut();
            g.Reduce();
            vector<Edge> ans;
            for(int i = 0; i < cut.size(); i++)
            {
                Edge& e = g.edges[cut[i]];
                e.cap = c;
                g.ClearFlow();
                if(flow + g.Maxflow(0, n-1) >= c) ans.push_back(e);
                e.cap = 0;
            }
            if(ans.empty()) printf("not possible
");
            else
            {
                sort(ans.begin(), ans.end());
                printf("possible option:(%d,%d)", ans[0].from+1, ans[0].to+1);
                for(int i = 1; i < ans.size(); i++)
                    printf(",(%d,%d)", ans[i].from+1, ans[i].to+1);
                printf("
");
            }
        }
    }
    return 0;
}

数论小模板

void div_fac(int m)
{
    Len = 0;
    for(int i=2; i*i<=m; i++) if(m%i==0)
    {
        p[Len] = i;
        xc[Len] = 1;
        while(m%i==0) xc[Len] *= i , m /= i;
        Len++;
    }
    if(m>1) p[Len] = xc[Len++] = m;
}

int getcount(int x,int p)
{
    int ret = 0;
    while(x)
    {
        x /= p;
        ret += x;
    }
    return ret;
}

int pow_mod(int a,int n,int mod)
{//快速幂
    a%=mod;
    int r = 1;
    while(n)
    {
        if(n&1) r=(ll)r*a%mod;
        a=(ll)a*a%mod;
        n>>=1;
    }
    return r;
}

int gcd(int a,int b,int &x,int &y)
{//最大公因数
    if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    int d = gcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}

int inv(int a,int mod)
{//求逆元
    int x,y;
    while( gcd(a,mod,x,y) != 1 );
    return (x+mod)%mod;
}

int crt(int a[],int m[],int n)
{//中国剩余定理
    int M = 1;
    for(int i=0; i<n; i++) M*=m[i];
    int ret = 0;
    for(int i=0; i<n; i++)
    {
        int x,y,tm=M/m[i];
        gcd(tm,m[i],x,y);
        ret=(ret+(ll)tm*x%M*a[i])%M;
    }
    return (ret+M)%M;
}

点hash

const int maxn=500+10;
const int prime = 100007;

pii pt[maxn];

struct point_hash
{
    int _hash[prime+5];
    int _next[prime+5];
    void clr()
    {//清空hash表
        cl(_next,0),cl(_hash,0);
    }
    void insert(pii pt,int index)
    {//向hash表中插入标号是index的点pt
        int x=pt.first,y=pt.second;
        int h = (x*x+y*y) % prime;
        int u = _hash[h];
        while(u)
        {
            u=_next[u];
        }
        _next[index]=_hash[h];
        _hash[h]=index;
    }
    bool ok(pii p)
    {//查询hash表中点p是否存在
        int x=p.first,y=p.second;
        int h = (x*x+y*y) % prime;
        int u = _hash[h];
        while(u)
        {
            if(pt[u].first==x && pt[u].second==y)return true;
            u=_next[u];
        }
        return false;
    }
}pthash;

威尔逊定理

p为素数时 

从ACdream那里扒下来的

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <math.h>

using namespace std;
typedef long long LL;

int Work(LL n)
{
    while(n % 4 == 0) n >>= 2;
    if(n % 8 == 7) return 4;
    LL i = 8, t = 9;
    while(t <= n)
    {
        while(n % t == 0) n /= t;
        i += 8;
        t += i;
    }
    if(n == 1) return 1;
    if(n % 2 == 0) n >>= 1;
    if(n % 4 == 3) return 3;
    LL k = 3;
    while(k * k <= n)
    {
        if(n % k == 0) return 3;
        k += 4;
    }
    return 2;
}

int main()
{
    LL n;
    while(cin>>n)
        cout<<Work(n)<<endl;
    return 0;
}