ACM各种有用的模板

最长回文串manacher：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#define INF 99999999
using namespace std;
const int MAX=110000+10;
char s[MAX*2];
int p[MAX*2];

int main(){
    while(scanf("%s",s)!=EOF)
    {
        memset(p,0,sizeof(p));
        int len = strlen(s);
        for(int i = len-1;i >= 0;i--)
        {
            s[i*2+2] = s[i];
            s[i*2+1] = '#';
        }
        int id = 0,mx = 0;
        int ans = 0;
        s[0] = '$',s[len*2+2] = '\0';
        s[len*2+1] = '#';
        for(int i = 2;i < 2*len+2;i++)
        {
            if(mx > i)
                p[i] = min(p[2*id-i],mx-i);
            else
                p[i] = 1;
            while(s[i+p[i]] == s[i-p[i]])
            {
                ++p[i];
            }
            if(mx < i+p[i])
            {
                mx = p[i]+i;
                id = i;
            }
            ans = max(ans,p[i]);
        }
        cout<<ans-1<<endl;
    }
    return 0;
}

最短路：

//dijkstra
#define INF 0x3f3f3f3f
const int MAX_N = 200;
int Edge[MAX_N][MAX_N];         //邻接矩阵
int n;
int vis[MAX_N];        //标记已被加入集合的点
int d[MAX_N];              //源点到其他点的最短路径
void dijkstra(int s)
{
    fill(d,d+N,INF);
    fill(vis,vis+N,0);
    d[s] = 0;
    vis[s] = 1;
    int Mi,u = s;
    for(int i = 0;i < n-1;i++)
    {
        Mi = INF;
        for(int v = 1;v <= n;v++)
        {
            if(!vis[v]&&d[v] < Mi)
            {
                u = v;
                Mi = d[v];
            }
        }
        vis[u] = 1;
        for(int k = 1;k <= n;k++)
            d[k] = min(d[k],d[u]+Edge[u][k]);
    }
}
//dijkstra堆优化
void Dijkstra()
{
    priority_queue<int,vector<int>,cmp> Q;
    memset(dis,-1,sizeof(dis));
    memset(vis,0,sizeof(vis));
    int i,u,v;
    Q.push(st);
    dis[st]=0;
    while(!Q.empty())
    {
        u=Q.top();
        Q.pop();
        vis[u]=0;
        if(u==ed)
            break;
        for(i=0;i<edge[u].size();i++)
        {
            v=edge[u][i].v;
            if(dis[v]==-1 || dis[v]>dis[u]+edge[u][i].w)
            {
                dis[v]=dis[u]+edge[u][i].w;
                if(!vis[v])
                {
                    vis[v]=1;
                    Q.push(v);
                }
            }
        }
    }
}
//Floyd

int d[1000][1000];  //表示两点之间边的权值，不存在就设置为INF
void Floyd()
{
    for(int k = 0;k < N;k++)
        for(int i = 0;i < N;i++)
            for(int j = 0;j < N;j++)
                d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
}


//SPFA
int spfa_bfs(int s)
{
    queue <int> q;
    memset(d,0x3f,sizeof(d));
    d[s]=0;
    memset(c,0,sizeof(c));
    memset(vis,0,sizeof(vis));

    q.push(s);  vis[s]=1; c[s]=1;
    //顶点入队vis要做标记，另外要统计顶点的入队次数
    int OK=1;
    while(!q.empty())
    {
        int x;
        x=q.front(); q.pop();  vis[x]=0;
        //队头元素出队，并且消除标记
        for(int k = f[x]; k!=0; k = next[k]) //遍历顶点x的邻接表
        {
            int y=v[k];
            if( d[x]+w[k] < d[y])
            {
                d[y]=d[x]+w[k];  //松弛
                if(!vis[y])  //顶点y不在队内
                {
                    vis[y]=1;    //标记
                    c[y]++;      //统计次数
                    q.push(y);   //入队
                    if(c[y] > N)  //超过入队次数上限，说明有负环
                        return OK=0;
                }
            }
        }
    }
    return OK;
}

int spfa_dfs(int u)
{
    vis[u]=1;
    for(int k=f[u]; k!=0; k=e[k].next)
    {
        int v=e[k].v,w=e[k].w;
        if( d[u]+w < d[v] )
        {
            d[v]=d[u]+w;
            if(!vis[v])
            {
                if(spfa_dfs(v))
                    return 1;
            }
            else
                return 1;
        }
    }
    vis[u]=0;
    return 0;
}

字符串进制转换（62进制内的数转换）：

const int MAXN = 1000;
int  t[MAXN], A[MAXN];
char OldData[MAXN], NewData[MAXN];  // 转换前、后的数据
int olds, news;                     // 转换前、后的进制

// 调用方式：输入olds、news、OldData，然后调用trans(),输出NewData
void trans()
{
    int i, len, k;
    len = strlen(OldData);
    for(i=len; i>=0; --i)
        t[len-1-i] = OldData[i] - (OldData[i]<58 ? 48 : OldData[i]<97 ? 55 : 61);
    for(k=0; len;)
    {
        for(i=len; i>=1; --i)
        {
            t[i-1] += t[i]%news*olds;
            t[i] /= news;
        }
        A[k++] = t[0] % news;
        t[0] /= news;
        while(len>0 && !t[len-1]) --len;
    }
    NewData[k] = NULL;
    for(i=0; i<k; ++i)
        NewData[k-1-i] = A[i] + (A[i]<10 ? 48 : A[i]<36 ? 55 : 61);
}

计算矩阵行列式：

LL getans()
{
    LL sum = 1;
    for(int i = 1;i < n;i++)
    {
        for(int j = i+1;j < n;j++)
        {
            while(a[j][i])
            {
                LL t = a[i][i]/a[j][i];

                for(int k = i;k < n;k++)
                    a[i][k] = a[i][k]-a[j][k]*t;

                for(int k = i;k < n;k++)
                    swap(a[i][k],a[j][k]);
                sum = -sum;
            }
        }
        if(a[i][i] == 0)
            return 0;
        sum = sum*a[i][i];
    }
    if(sum < 0)
        sum = -sum;
    return sum;
}

LIS最长递增子序列：

int stk[10010];
int LIS(int a[],int n)
{
    int i,top,mid,low,high;
    top = 0;
    stk[0] = -1;
    for(i = 0;i < n;i++)
    {
        if(a[i] > stk[top])
            stk[++top] = a[i];
        else
        {
            low = 1;
            high = top;
            while(low <= high)
            {
                mid = (low+high)/2;
                if(a[i] > stk[mid])
                    low = mid+1;
                else
                    high = mid-1;
            }
            stk[low] = a[i];
        }
    }
    return top;
}

KMP模板：

const int MAX_N = 1e5+10;
const double eps = 1e-8;
const LL mod = 1000000007;
using namespace std;
int next[MAX_N],a[MAX_N];
int n,m;
void getnext(int s[])
{
    mem(next);
    int k = -1,j = 0;
    next[0] = -1;
    while(j < n)
    {
        if(k == -1||s[k] == s[j])
        {
            next[j+1] = k+1;
            j++;
            k++;
        }
        else
            k = next[k];
    }
}
int KMP(int s[],int t[])
{
    getnext(t);
    int i = 0,j = 0;
    while(i < n&&j < m)
    {
        if(j == -1||s[i] == t[j])
        {
            i++,j++;
        }
        else
            j = next[j];
        if(j == m)
            return i-j+1;
    }
    return -1;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i = 0;i < n;i++)
            scanf("%d",&a[i]);
        for(int j = 0;j < m;j++)
            scanf("%d",&s[j]);
        printf("%d\n",KMP(a,s));
    }
    return 0;
}

LCS模板：

char a[110][40],b[110][40];
char ans[110][40];
int dp[110][110],vis[110][110],la,lb,cnt;
void LCS()
{
    mem(dp,0); mem(vis,0);
    for(int i = 0;i <= la;i++)
        vis[i][0] = 1;
    for(int i = 0;i <= lb;i++)
        vis[0][i] = -1;
    for(int i = 1;i <= la;i++)
    {
        for(int j = 1;j <= lb;j++)
        {
            if(!strcmp(a[i-1],b[j-1]))
            {
                dp[i][j] = dp[i-1][j-1]+1;
                vis[i][j] = 0;
            }
            else if(dp[i-1][j] >= dp[i][j-1])
            {
                dp[i][j] = dp[i-1][j];
                vis[i][j] = 1;
            }
            else
            {
                dp[i][j] = dp[i][j-1];
                vis[i][j] = -1;
            }
        }
    }
}
void PrintLCS(int i,int j)
{
    if(i == 0&&j == 0)
        return ;
    if(vis[i][j] == 0)
    {
        PrintLCS(i-1,j-1);
        strcpy(ans[cnt++],a[i-1]);
    }
    else if(vis[i][j] == 1)
        PrintLCS(i-1,j);
    else
        PrintLCS(i,j-1);
}

字符串最小表示法：

int getmin(string s)
{
    int n=s.size();
    int i=0,j=1,k=0,t;
    while(i<n && j<n && k<n)
    {
        t=s[(i+k)%n]-s[(j+k)%n];
        if (!t) k++;
        else{
            if (t>0) i+=k+1;
            else j+=k+1;
            if (i==j) j++;
            k=0;
        }
    }
    return i<j?i:j;
}

最小树形图（poj3164）：

#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <string.h>
#include <string>
#include <algorithm>
#include <queue>
#include <set>
#include <iostream>
#define PI 3.1415926535898
#define LL long long
#define MAX 0x3fffffff
#define INF 0x3f3f3f3f
#define mem(a,v) memset(a,v,sizeof(a))
const int MAX_N = 1e2+10;
const double eps = 1e-7;
const int mod = 10007;
const LL inf = 1LL<<60;
using namespace std;
int n,m;
struct Point
{
    double x,y;
}a[MAX_N];
struct edge
{
    int u,v;
    double val;
}es[MAX_N*MAX_N*5];
double in[MAX_N];
int col[MAX_N],pre[MAX_N],ID[MAX_N];
double getdist(Point e1,Point e2)
{
    return sqrt((e1.x-e2.x)*(e1.x-e2.x)+(e1.y-e2.y)*(e1.y-e2.y));
}
double ZL_Mst(int root)
{
    double sum = 0;
    while(1)
    {
        for(int i = 0;i < n;i++) in[i] = INF;
        for(int i = 0;i < m;i++)
        {
            int u = es[i].u;
            int v = es[i].v;
            if(u!=v&&es[i].val < in[v])
            {
                in[v] = es[i].val;
                pre[v] = u;
            }
        }
        for(int i = 0;i < n;i++)
        {
            if(i!=root&&in[i] == INF)
                return -1;
        }
        memset(col,-1,sizeof(col));
        memset(ID,-1,sizeof(ID));
        in[root] = 0;
        int tn = 0;
        for(int i = 0;i < n;i++)
        {
            sum+=in[i];
            int v = i;
            while(v!=root&&col[v] != i&&ID[v] == -1)
            {
                col[v] = i;
                v = pre[v];
            }
            if(v!=root&&ID[v] == -1)
            {
                for(int u = pre[v];u!=v;u = pre[u])
                    ID[u] = tn;
                ID[v] = tn++;
            }
        }
        if(!tn) break;
        for(int i = 0;i < n;i++)
            if(ID[i] == -1)
                ID[i] = tn++;
        for(int i = 0;i < m;i++)
        {
            int u = es[i].u;
            int v = es[i].v;
            es[i].u = ID[u];
            es[i].v = ID[v];
            if(ID[u]!=ID[v]) es[i].val -=in[v];
        }
        n = tn;
        root = ID[root];
    }
    return sum;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {

        for(int i = 0;i < n;i++)
            scanf("%lf%lf",&a[i].x,&a[i].y);
        int u,v;
        for(int i = 0;i < m;i++)
        {
            scanf("%d%d",&u,&v);
            es[i].u = u-1;
            es[i].v = v-1;
            if(u!=v)
                es[i].val = getdist(a[u-1],a[v-1]);
            else
                es[i].val = INF;
        }
        double ans = ZL_Mst(0);
        if(ans == -1)
            printf("poor snoopy\n");
        else
            printf("%.2f\n",ans);
    }
    return 0;
}

LCA（最近公共祖先）：

struct node
{
    int to,cost,next;
}es[MAX_N*2];
int e,head[MAX_N],vis[MAX_N],ver[MAX_N];
int tot,first[MAX_N],dis[MAX_N],R[MAX_N],dp[MAX_N][40];
void add(int u,int v,int w)
{
    es[e].to = v;
    es[e].cost = w;
    es[e].next = head[u];
    head[u] = e++;
}
void dfs(int u,int dep)
{
    vis[u] = 1;
    ver[++tot] = u;
    first[u] = tot;
    R[tot] = dep;
    for(int i = head[u];i!=-1;i = es[i].next)
    {
        int v = es[i].to;
        if(!vis[v])
        {
            dis[v] = dis[u]+es[i].cost;
            dfs(v,dep+1);
            ver[++tot] = u;
            R[tot] = dep;
        }
    }
}
void ST(int len)
{
    for(int i = 0;i <= len;i++)
        dp[i][0] = i;
    for(int j = 1;(1<<j) <= len;j++)
    {
        for(int i = 1;i +(1<<j)-1 <= len;i++)
        {
            int a = dp[i][j-1];
            int b = dp[i+(1<<(j-1))][j-1];
            dp[i][j] = R[a] < R[b]?a:b;
        }
    }
}
int RMQ(int l,int r)
{
    int k = 0;
    while((1<<(k+1)) <= r-l+1) k++;
    int a = dp[l][k],b = dp[r-(1<<k)+1][k];
    return R[a] < R[b]?a:b;
}
int LCA(int u,int v)
{
    int x = first[u],y = first[v];
    if(x > y) swap(x,y);
    int f = ver[RMQ(x,y)];
    return f;
}

字典树（hdu1251）：

#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <string.h>
#include <string>
#include <algorithm>
#include <map>
#include <queue>
#include <vector>
#include <iostream>
#define LL long long
#define INF 0x3f3f3f3f
const int MAX_N = 5e5+10;
const LL mod = 1e9+7;
const double eps = 1e-6;
using namespace std;
struct Trie
{
    int ch[MAX_N][26];
    int num[MAX_N];
    int sz;
    void clr()
    {
        sz = 0;
        memset(num,0,sizeof(num));
        memset(ch[0],0,sizeof(ch[0]));
    }
    void Insert(char *s)
    {
        int len = strlen(s);
        int u = 0;
        for(int i = 0;i < len;i++)
        {
            int z = s[i]-'a';
            if(!ch[u][z])
            {
                memset(ch[sz],0,sizeof(ch[sz]));
                ch[u][z] = ++sz;
                num[sz] = 0;
            }
            u = ch[u][z];
            num[u]++;
        }
    }
    int Find(char *s)
    {
        int len = strlen(s);
        int u = 0;
        if(len > 20) return 0;
        for(int i = 0;i < len;i++)
        {
            int id = s[i]-'a';
            u = ch[u][id];
            if(u == 0)
                return 0;
        }
        return num[u];
    }
};
Trie t;
int main()
{
    char s[105];
    t.clr();
    while(gets(s))
    {
        if(!strcmp(s,"")) break;
        t.Insert(s);
    }
    while(scanf("%s",s)!=EOF)
    {
        printf("%d\n",t.Find(s));
    }
    return 0;
}