模板收集

<pre class="cpp" name="code">ll exmod[100005],rmod[100005];

ll multimod(ll a,ll b,ll mod)
{
    ll ans = 0;
    for ( ; b; b >>= 1, a = (a<<1)%mod)
        if (b&1)
        {
            ans = (ans + a)%mod;
        }
    return ans;
}

ll quickpow(ll a,ll b,ll mod)
{
    ll res=1;
    a%=mod;
    while(b)
    {
        if(b&1)res=(res*a)%mod;
        a=(a*a)%mod;
        b>>=1;
    }
    return res;
}
void Init()
{
    memset(exmod,0,sizeof(exmod));
    exmod[0]=1;
    for(int i=1; i<100005; i++)
        exmod[i]=(exmod[i-1]*i)%INF;
    for(int i=1; i<100005; i++)
        rmod[i]=quickpow(exmod[i],INF-2,INF);
}
///计算结合公式 C(N,K)%INF
ll C(ll N,ll K)
{
    if(K>N)return 0;
    if(K==N)return 1;
    if(K==0)return 1;
    return (((exmod[N]*rmod[K])%INF)*rmod[N-K])%INF;
}

///kmp

#define M 1000010
char s[M],t[M];
int next[M],sum;
void getNext()//求next数组
{
int i,j;
next[0]=-1;
for(i=1,j=-1;s[i];i++){
	while(j!=-1&&s[i]!=s[j+1])j=next[j];//从s[j+1]开始找与s[i]相同的字母
		if(s[j+1]==s[i])j++;
			next[i]=j;//如果找到相同字母，next[i]记录此位置,否则next[i]=next[i-1]
		}
}
void kmp()
{
int i,j;
sum=0;
getNext();
for(i=0,j=-1;t[i];i++){
	while(j!=-1&&s[j+1]!=t[i])j=next[j];//按next[j]后退找出与t[i]相同的s[j+1]
		if(s[j+1]==t[i])j++;//如果找到则向后前进
		if(!s[j+1]){//如果在t中找到完整的s
			sum++;//计数增1
			j=next[j];//按next后退
				}
		}
}

///rmp 预处理 比线段树快
void rmq_init()
{
    int i,j,k,m;
    m=(int)(log(n)/log(2.0));
    for(i=1; i<=n; i++)
    {
        mx[i][0]=mm[i][0]=A[i];
    }
    for(j=1; j<=m; j++)
    {
        for(i=1; i<=n; i++)
        {
            mx[i][j]=mx[i][j-1];
            k=1<<(j-1);
            if(i+k<=n)
                mx[i][j]=max(mx[i][j],mx[i+k][j-1]);
        }
    }
    for(j=1; j<=m; j++)
    {
        for(i=1; i<=n; i++)
        {
            mm[i][j]=mm[i][j-1];
            k=1<<(j-1);
            if(i+k<=n)
                mm[i][j]=min(mm[i][j],mm[i+k][j-1]);
        }
    }
}
int rmq_query(int l,int r)
{
    int i,j,m;
    m=(int)(log(r-l+1)/log(2.0));
    i=max(mx[l][m],mx[r-(1<<m)+1][m]);
    j=min(mm[l][m],mm[r-(1<<m)+1][m]);
    return i-j;
}

///输出串中最对称最长的对称长度
int f(char *gg){
        int maxlen = 1;//最大长度
        int len=strlen(gg);
        int record[len];//存包含该位及前个元素最长对称子串
        record[0]=1;
        int i=1;
        for(;i<len;i++){
                int max =1;
                if((i-record[i-1]-1)>=0 && gg[i] == gg[i-record[i-1]-1]){
                        max = max>(record[i-1] + 2)? max:(record[i-1] +2);
                }
                int k = 1;
                while(gg[i] == gg[i-k]){
                        k++;
                }
                max = max>k? max:k;
                record[i] = max;
                if(record[i]>maxlen) maxlen=record[i];
        }
        return maxlen;
}

///编辑距离
首先定义这样一个函数——edit(i, j)，它表示第一个字符串的长度为i的子串到第二个字符串的长度为j的子串的编辑距离。
显然可以有如下动态规划公式：
if i == 0 且 j == 0，edit(i, j) = 0
if i == 0 且 j > 0，edit(i, j) = j
if i > 0 且j == 0，edit(i, j) = i
if i ≥ 1  且 j ≥ 1 ，edit(i, j) == min{ edit(i-1, j) + 1, edit(i, j-1) + 1, edit(i-1, j-1) + f(i, j) }，当第一个字符串的第i个字符不等于第二个字符串的第j个字符时，f(i, j) = 1；否则，f(i, j) = 0。
for(i=0;i<len1;i++){
		dp[i][0] = i ;
	}
	for(j=0;j<len2;j++){
		dp[0][j] = j ;
	}
	for(i=1;i<=len1;i++){
		for(j=1;j<=len2;j++){
			if(str1[i-1] == str2[j-1]){
				dp[i][j] = dp[i-1][j-1];	//对应字母相等，dp值不增加
			}
			else{//三个形参分别对应str2在str1的基础上增加，减少和修改的情况
				dp[i][j] = min( dp[i][j-1]+1 , dp[i-1][j]+1 , dp[i-1][j-1]+1 );
			}
		}
	}
	return dp[len1][len2];

单元最短路径 
Bellman-Ford 算法
记从起点S出发到顶点i的最短距离为d[i]
d[i]=min {d[i],d[j]+e(j,i)}
记当前到顶点i的最短路长度为d[i]
并设初值d[s]=0,d[i]=INF
再不断使用 上面的公式更新d的值
从顶点from指向顶点to的cost值

const int MAX_E=1000;
const int MAX_V=1000;
struct edge
{
    int from;
    int to;
    int cost;
};
edge es[MAX_E];//边
int d[MAX_E];//最短距离
int V;//顶点数
int E;//边数
//求解从顶点S出发到所有点的最短距离
void shortest_path(int s)
{
    for(int i=0; i<V; i++)
        d[i]=INF;
    d[s]=0;
    while(true)
    {
        bool update=false;
        for(int i=0; i<E; i++)
        {
            edge e=es[i];
            if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost) //精华
            {
                d[e.to]=d[e.from]+e.cost;
                update=true;
            }
        }
        if(!update)
            break;
    }
}

单元最短路径
priority_queue优化的Dijkstra
const int MAX_E=1000;
const int MAX_V=1000;
struct edge
{
    int to;
    int cost;
};
typedef pair<int ,int> P;//first是最短距离，second是顶点编号
int V;
Vector<edge> G[MAX_V];
int d[MAX_V];
void Dijkstra(int s)
{
//通过指定greater<P>的参数，堆按照从小到达的顺序取出值
    priority_queue<P, vector<P> , greater<P> > que;
    fill(d,d+V,INF);
    d[s]=0;
    que.push(P(0,s));
    while(!que.empty())
    {
        P p = que.top();
        que.pop();
        int v=p.second;
        if(d[v]<p.first)
            continue;
        for(int i=0; i<G[v].size(),i++)
        {
            edge e=G[v][i];
            if(d[e.to]>d[v]+e.cost)
            {
                d[e.to]=d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}

最小生成树 Spanning tree
Prim 算法
首先，我们假设有一颗只包含一个顶点V的树T
然后，贪心地选取T和其他顶点之间项链的最小权值的边
并把它加入到T中
不断的进行这个操作，就可以得到一个Spanning tree 了
const int MAX_E=1000;
const int MAX_V=1000;
int cost[MAX_V][MAX_V];
int mincost[MAX_V];//从顶点X出发的边到每个顶点的最小权值
bool used[MAX_V];//顶点i是否包含在集合X中
int V;//顶点数
int Prim()
{
    for(int i=0; i<V; i++)
    {
        mincost[i]=INF;
        used[i]=false;
    }
    mincost[0]=0;
    int res=0;
    while(true)
    {
        int v=-1;//从不属于X的顶点集合中选择X到其权值最小的顶点
        for(int u=0; u<V; u++)
        {
            if(!used[u]&&(v==-1||mincost[u]<mincost[v]))
                v=u;
        }
        if(v==-1)
            break;
        used[v]=true;//把顶点v加入到X
        res+=mincost[v];//把边的长度加入到结果里
        for(int u=0; u<V; u++)
        {
            mincost[u]=min(mincost[u],cost[v][u]);
        }
    }
    return res;
}

Kruskal 算法
按照边的权值的顺序从小到大查看一遍
如果不产生圈（重边也算在内）
就把当前这条边加入到生成树中
如何判断是否产生圈
假设现在要把连接顶点u和v的边e加入到生成树中。
如果加入之前u和v不在同一个连通分量里，
那么加入e也不会产生圈
反之，如果u和v在同一个连通分量里
那么一定会产生圈
可以使用并查集高效地判断是否属于同一个连通分量
const int MAX_E=1000;
const int MAX_V=1000;
struct edge
{
    int u;
    int v;
    int cost;
};
bool cmp(edge e1,edge e2)
{
    return e1.cost<e2.cost;
}
edge es[MAX_E];
int V,E;//顶点数和边数
int set[MAX_V];//并查集
void init_union_find(int n)
{
    for(int i=0; i<n; i++)
        set[i]=i;
}
void find(int x)
{
    if(set[x]==x)
        return x;
    else
        return set[x]=find(set[x]);
}
void unite(int x,int y)
{
    x=find(x);
    y=find(y);
    if(x==y)
        return ;
    if(y<x)
        set[x]=y;
    else if(y>x)
        set[y]=x;
}
bool same(int x,int y)
{
    return find(x)==find(y);
}
int kruskal()
{
    sort(es,es+E,cmp);//从小到大排序
    init_union_find(V);//并查集初始化
    int res=0;
    for(int i=0; i<E; i++)
    {
        edge e=es[i];
        if(same(e.u,e.v))
        {
            unite(e.u,e.v);
            res+=e.cost;
        }
    }
    return res;
}

 http://blog.csdn.net/theprinceofelf/article/details/7225206 博弈

http://www.myexception.cn/arithmetic/2034601.html   可能用得上 

//定义结构，使用运算符重载,自定义优先级1  
struct cmp1{  
    bool operator ()(int &a,int &b){  
        return a>b;//最小值优先  
    }  
};  
struct cmp2{  
    bool operator ()(int &a,int &b){  
        return a<b;//最大值优先  
    }  
};  
//定义结构，使用运算符重载,自定义优先级2  
struct number1{  
    int x;  
    bool operator < (const number1 &a) const {  
        return x>a.x;//最小值优先  
    }  
};  
struct number2{  
    int x;  
    bool operator < (const number2 &a) const {  
        return x<a.x;//最大值优先  
    }  
};  
priority_queue<int>que;//采用默认优先级构造队列  
  
    priority_queue<int,vector<int>,cmp1>que1;//最小值优先  
    priority_queue<int,vector<int>,cmp2>que2;//最大值优先  
  
    priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为错误，  
                                                      //这是右移运算符，所以这里用空格号隔开  
    priority_queue<int,vector<int>,less<int> >que4;最大值优先  
  
    priority_queue<number1>que5;  
    priority_queue<number2>que6;  

匈牙利算法 求最大匹配
bool find(int x)  
{    
    int i,j;    
    for (j=1;j<=m;j++)  
    {    //扫描每个妹子    
        if (line[x][j]==true && used[j]==false)          
        //如果有暧昧并且还没有标记过(这里标记的意思是这次查找曾试图改变过该妹子的归属问题，但是没有成功，所以就不用瞎费工夫了）    
        {    
            used[j]=1;    
            if (girl[j]==0 || find(girl[j]))   
            {     
                //名花无主或者能腾出个位置来，这里使用递归    
                girl[j]=x;    
                return true;    
            }    
        }    
    }    
    return false;    
}    
  
for (i=1;i<=n;i++)    
{    
    memset(used,0,sizeof(used));    //这个在每一步中清空    
    if find(i) all+=1;    
}