OI算法复习

搜集一些算法，赛前背一背有好处的

转自各大网站

 

前排感谢：hzwer、风了咕凉

前辈。。。Orz

 

快速读入：

int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

 

经典快排：虽说C++直接sort就好了。。。

#include <iostream>
 
using namespace std;
 
void Qsort(int a[], int low, int high)
{
    if(low >= high)
        return;
    int first = low;
    int last = high;
    int key = a[first];
    while(first < last)
    {
        while(first < last && a[last] >= key)
            --last;
        a[first] = a[last];
        while(first < last && a[first] <= key)
            ++first;
         a[last] = a[first];
    }
    a[first] = key;
    Qsort(a, low, first-1);
    Qsort(a, first+1, high);
}

 

归并排序：

template <typename T>
void MergeSort (T data[], int size)
{
    if ( size>1 )
    {
        //预处理
        int mid=size/2;
        int numOfleft=mid;
        int numOfright=size-mid;
        T* left=new T[numOfleft];
        T* right=new T[numOfright];
        //分
        std::copy(data, data+numOfleft, left);
        std::copy(data+numOfleft, data+size, right);
        MergeSort(left, numOfleft);
        MergeSort(right, numOfright);
        //合
        std::merge(left, left+numOfleft, right, right+numOfright, data);
        //清理
        delete[] left;
        delete[] right;
    }
}

堆排：

template <typename T>
void heap_down (T data[], int i, const int& size)
{
    int p=i*2+1;
    while ( p<size )
    {
        if ( p+1<size )
        {
            if ( data[p]<data[p+1] )
                ++p;
        }
        if ( data[i]<data[p] )
        {
            std::swap(data[p], data[i]);
            i=p;
            p=i*2+1;
        }
        else
            break;
    }
}

template <typename T>
void HeapSort (T data[], int size)
{
    int i;
    for (i=(size-1)/2; i>=0; --i)
        heap_down(data, i, size);
    for (i=size-1; i>0; --i)
    {
        std::swap(data[0], data[i]);
        heap_down(data, 0, i);
    }
}

拓扑排序：

#include<iostream>
#include<cstdio>
using namespace std;

struct Edge
{
    int to,next;
}E[100001];
int head[100001],r[100001],s[100001];
int node=0;

int n;

void insert(int u,int v)
{
    E[++node]=(Edge){v,head[u]};
    head[u]=node;
    r[v]++;
}

void topsort()
{
    int t=1,top=0;
    for(int i=1;i<=n;i++)
        if(!r[i])
        {
            s[++top]=i;
        }
    while(t<=top)
    {
        int x=s[t++];
        for(int i=head[x];i;i=E[i].next)
        {
            r[E[i].to]--;
            if(!r[E[i].to])
            {
                s[++top]=E[i].to;
            }
        }
    }
}

 

kahn算法（NOIP2013车站分级为例子）纯过程形式：

#include<iostream>
#include<cstring>
using namespace std;

const int MAXN=1000+10;
int n,m,ans=0;
int B[MAXN]={0},R[MAXN]={0},SK[MAXN]={0};//R储存入度  SK储存入度为0的点
bool A[MAXN]={0},F[MAXN]={0},E[MAXN][MAXN]={0};//F判断点是否已被访问  E判断两点是否存在边

int main()
{
    /*cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int s;
        memset(A,0,sizeof(A));
        cin>>s;
        for(int j=1;j<=s;j++)
        {
            cin>>B[j];
            A[B[j]]=1;
        }
        for(int j=B[1];j<=B[s];j++)
            if(!A[j])
                for(int k=1;k<=s;k++)
                    if(!E[j][B[k]])
                    {
                        E[j][B[k]]=1;
                        R[B[k]]++;
                    }
    }*///初始化
    int top;
    while(1)
    {
        top=0;
        for(int i=1;i<=n;i++)//遍历n个点
            if(!R[i]&&!F[i])//如果入度为0且没有被访问过，则加入SK数组
            {
                SK[++top]=i;//加入SK数组
                F[i]=1;//i点已被访问
            }
        if(top==0)break;//如果所有的点都被访问则跳出
        for(int i=1;i<=top;i++)
            for(int j=1;j<=n;j++)
                if(E[SK[i]][j])//判断是否有边
                {
                    E[SK[i]][j]=0;//将边移除
                    R[j]--;//入度-1
                }
        ans++;
    }
    cout<<ans<<endl;
    return 0;
}

 

并查集：

int find(int x)
{
    while(f[x]!=0) x=f[x];
    return x;
}

快速幂：

int modexp(int a,int b,int n)   
{   
    int ret=1;   
    int tmp=a;   
    while(b)   
    {
       if(b&0x1) ret=ret*tmp%n;   
       tmp=tmp*tmp%n;   
       b>>=1;   
    }   
    return ret;   
}   

欧几里得算法：

int gcd(int a,int b)
{
    return b?gcd(b,a%b):a;
}

拓展欧几里德算法：

int gcd(int a,int b,int &x,int &y){
    if (b==0){
        x=1,y=0;
        return a;
    }
    int q=gcd(b,a%b,y,x);
    y-=a/b*x;
    return q;
}

spfa：

struct Edge
{
    int to,w,next;
}E[1000];
int node=0,head[50];

void insert(int u,int v,int w)
{
    node++;
    E[node]=Edge{v,w,head[u]};
    head[u]=node;
}

int spfa(int s,int t)
{
    int dist[21];
    bool vis[21];
    memset(dist,0x7f,sizeof(dist));
    memset(vis,0,sizeof(vis));
    dist[s]=0;vis[s]=1;
    queue<int> Q;
    Q.push(s);
    while(!Q.empty())
    {
        int q=Q.front();Q.pop();
        for(int i=head[q];i;i=E[i].next)
            if(dist[E[i].to]>dist[q]+E[i].w)
            {
                dist[E[i].to]=dist[q]+E[i].w;
                if(!vis[E[i].to])
                {
                    Q.push(E[i].to);
                    vis[E[i].to]=1;
                }
            }
        vis[q]=0;
    }
    return dist[t];
}

 

spfa_dfs判负环：

#include<iostream>
#include<cstring>
using namespace std;

struct Edge
{
    int to,w,next;
}E[10000001];
int node=0,head[10001],dist[10001];
bool vis[10001];

int n,m;
bool flag;

void insert(int u,int v,int w)
{
    E[++node]=(Edge){v,w,head[u]};
    head[u]=node;
}

void spfa_dfs(int s)
{
    vis[s]=1;
    for(int i=head[s];i;i=E[i].next)
    {
        if(dist[E[i].to]>dist[s]+E[i].w)
        {
            if(vis[E[i].to]){flag=1;return;}
            else
            {
                dist[E[i].to]=dist[s]+E[i].w;
                spfa_dfs(E[i].to);
            }
        }
    }
    vis[s]=0;
}

bool check()
{
    flag=0;
    memset(dist,0x7f,sizeof(dist));
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
    {
        dist[i]=0;
        spfa_dfs(i);
        if(flag) return 1;
    }
    return 0;
}

 

floyd:

const int maxn=105,
          INF=10000000;
int n,Dist[maxn][maxn],Graph[maxn][maxn];
int minn=INF;
void floyd()
{
    //memcpy(Graph,Dist,sizeof(Dist));
    for(int k=1;k<=n;k++)
    {/*拓展求最小环
        for(int i=1;i<k;i++)
            for(int j=i+1;j<k;j++)
                minn=min(minn,Dist[i][j]+Graph[j][k]+Graph[k][i]);*/
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                int temp=Dist[i][k]+Dist[k][j];
                if(temp<Dist[i][j])
                    Dist[i][j]=Dist[j][i]=temp;
            }
    }
}

 

Dijkstra:

#include <iostream>
#include <cstring>
using namespace std;

#define MAXN 10000000

int n,e;
int matrix[100][100];
int dist[100];

void Dijkstra(int s)
{
    int u,minn;
    bool vis[100];
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++)
        if(matrix[s][i]>0)
            dist[i]=matrix[s][i];
        else dist[i]=MAXN;
    vis[s]=1;dist[s]=0;
    for(int i=1;i<n;i++)
    {
        minn=MAXN;
        for(int j=0;j<n;j++)
            if(!vis[j]&&dist[j]<minn)
            {
                u=j;
                minn=dist[j];
            }
        vis[u]=1;
        for(int j=0;j<n;j++)
            if(!vis[j]&&matrix[u][j]>0&&minn+matrix[u][j]<dist[j])
                dist[j]=minn+matrix[u][j];
    }
}

int main()
{
    int v;
    cin>>n;
    cin>>e;
    memset(matrix,0,sizeof(matrix));
    for(int i=0;i<e;i++)
    {
        int x,y,w;
        cin>>x>>y>>w;
        matrix[x][y]=w;
    }
    Dijkstra(0);
    cin>>v;
    cout<<dist[v];
    return 0;
}

线段树：详见Codevs1082线段树练习3

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

struct node
{
    int left,right,flag;
    long long sum;
}tree[600000];

int n,q;
int a[200001];

void build(int node,int left,int right)
{
    tree[node].left=left;tree[node].right=right;
    if(left==right)
    {
        tree[node].sum=a[left];
        return;
    }
    int mid=(left+right)>>1;
    build(node<<1,left,mid);
    build(node<<1|1,mid+1,right);
    tree[node].sum=tree[node<<1].sum+tree[node<<1|1].sum;
}

void pushdown(int node)
{
    int x=tree[node].right-tree[node].left+1;
    tree[node<<1].flag+=tree[node].flag;
    tree[node<<1|1].flag+=tree[node].flag;
    tree[node<<1].sum+=(x-(x>>1))*tree[node].flag;
    tree[node<<1|1].sum+=(x>>1)*tree[node].flag;
    tree[node].flag=0;
}

void update(int node,int left,int right,int x)
{
    int mid=(tree[node].left+tree[node].right)>>1;
    tree[node].sum+=(right-left+1)*x;
    if(tree[node].left==left&&tree[node].right==right)
    {
        tree[node].flag+=x;
        return;
    }
    if(tree[node].left==tree[node].right) return;
    if(tree[node].flag>0) pushdown(node);
    if(right<=mid) update(node<<1,left,right,x);
    else if(left>mid) update(node<<1|1,left,right,x);
    else
    {
        update(node<<1,left,mid,x);
        update(node<<1|1,mid+1,right,x);
    }
    tree[node].sum=tree[node<<1].sum+tree[node<<1|1].sum;
}

long long query(int node,int left,int right)
{
    int mid=(tree[node].left+tree[node].right)>>1;
    if(tree[node].left==left&&tree[node].right==right)
        return tree[node].sum;
    if(tree[node].flag>0) pushdown(node);
    if(right<=mid)
        return     query(node<<1,left,right);
    else if(left>mid)
        return query(node<<1|1,left,right);
    else
        return query(node<<1,left,mid)+query(node<<1|1,mid+1,right);
}

 

树状数组：

详见

Codevs1080 线段树练习

Codevs1081 线段树练习 2

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

int n,m;
int f[100001];

int lowbit(int x)
{
    return x&(-x);
}

void update(int x,int num)
{
    while(x<=n)
    {
        f[x]+=num;
        x+=lowbit(x);
    }
}

int sum(int x)
{
    int sum=0;
    while(x>0)
    {
        sum+=f[x];
        x-=lowbit(x);
    }
    return sum;
}

int main()
{
    n=read();
    for(int i=1;i<=n;i++)
        update(i,read());
    m=read();
    for(int i=1;i<=m;i++)
    {
        int a=read(),x=read(),y=read();
        if(a==1)update(x,y);
        if(a==2)printf("%d
",sum(y)-sum(x-1));
    }
    return 0;
}

 

分块法：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;

int n,m,q,block;
int a[1000001],b[1000001],pos[1000001],add[1000001];

void reset(int x)
{
    int l=(x-1)*block+1,r=min(x*block,n);
    for(int i=l;i<=r;i++)
        b[i]=a[i];
    sort(b+l,b+r+1);//对单个块内进行排序
}

int find(int x,int z)//单个块内二分查找
{
    int l=(x-1)*block+1,r=min(x*block,n);
    int last=r;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(b[mid]<z) l=mid+1;
        else r=mid-1;
    }
    return last-l+1;
}

void update(int x,int y,int z)
{
    if(pos[x]==pos[y])//同个块则暴力修改
        for(int i=x;i<=y;i++) a[i]=a[i]+z;
    else//不同块修改左右两边的块
    {
        for(int i=x;i<=pos[x]*block;i++) a[i]=a[i]+z;
        for(int i=(pos[y]-1)*block+1;i<=y;i++) a[i]=a[i]+z;
    }
    reset(pos[x]);reset(pos[y]);
    for(int i=pos[x]+1;i<pos[y];i++)//其余块用add标记，表示增加了z
        add[i]+=z;
}

int query(int x,int y,int z)
{
    int sum=0;
    if(pos[x]==pos[y])//单个块暴力查找
    {
        for(int i=x;i<=y;i++)
            if(a[i]+add[pos[i]]>=z) sum++;
    }
    else//多个块左右两边的块暴力查找
    {
        for(int i=x;i<=pos[x]*block;i++)
            if(a[i]+add[pos[i]]>=z) sum++;
        for(int i=(pos[y]-1)*block+1;i<=y;i++)
            if(a[i]+add[pos[i]]>=z) sum++;
    }
    for(int i=pos[x]+1;i<pos[y];i++)//其余块每个二分查找
        sum+=find(i,z-add[i]);
    return sum;
}

int main()
{
    scanf("%d %d",&n,&q);
    block=(int)sqrt(n);//每个块的大小
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        pos[i]=(i-1)/block+1;
        b[i]=a[i];
    }
    if(n%block) m=n/block+1;//计算块的个数，如有多余则+1
    else m=n/block;
    for(int i=1;i<=m;i++) reset(i);//对每个块进行块内排序
    for(int i=1;i<=q;i++)
    {
        char ch;int x,y,z;
        scanf("
%c %d %d %d",&ch,&x,&y,&z);
        if(ch=='M') update(x,y,z);
        else printf("%d
",query(x,y,z));
    }
    return 0;
}

 

倍增算法：

RMQ：这里借鉴了一下黄学长的模板。。。Orz膜拜前辈

#include<iostream>
#include<cmath>
#include<iostream>
using namespace std;
int A[200001];
int MX[200001][18];
int n,q;
void RMP_INIT()
{
    for(int i=1;i<=n;i++)
        MX[i][0]=A[i];
    int m=log(n)/log(2);
    for(int i=1;i<=m;i++)
        for(int j=n;j>0;j--)
        {
             MX[j][i]=MX[j][i-1];
            if(j+(1<<(i-1))<=n)MX[j][i]=max(MX[j][i],MX[j+(1<<(i-1))][i-1]); 
        }
 }
int RMP(int l,int r)
{
    int m=log(r-l+1)/log(2);
    return max(MX[l][m],MX[r-(1<<m)+1][m]);
}

 KMP算法：

#include<iostream>
#include<cstring>
using namespace std;

char S[255],T[255];
int ls,lt;
int next[255];

void initnext(char *t,int *next)
{
    int j=0;
    int len=strlen(t);
    memset(next,0,sizeof(next));
    for(int i=1;i<len;i++)
    {
        while(j&&t[i]!=t[j]) j=next[j];
        if(t[i]==t[j]) j++;
        next[i+1]=j;
    }
}

int KMP(char *s,char *t)
{
    int j=0,ans=0;
    int ls=strlen(s),lt=strlen(t);
    for(int i=0;i<ls;i++)
    {
        while(j&&s[i]!=t[j]) j=next[j];
        if(s[i]==t[j]) j++;
        if(j==lt)
        {
            ans++;
            j=next[j];
        }
    }
    return ans;
}

 

 

 高斯消元：感谢浙大学长。。。Orz

#include<iostream>
#include<cmath>
using namespace std;

#define eps 1e-9
const int MAXN=220;
double a[MAXN][MAXN],x[MAXN]; //方程的左边的矩阵和等式右边的值，求解之后 x存的就是结果  
int equ,var;//方程数和未知数个数
 /* *返回0表示无解，1表示有解*/ 
int Gauss()
{
    int i,j,k,col,max_r;
    for(k=0,col=0;k<equ&&col<var;k++,col++)
    {
        max_r=k;
        for(i=k+1;i<equ;i++)
            if(fabs(a[i][col])>fabs(a[max_r][col])) max_r=i;
        if(fabs(a[max_r][col])<eps) return 0;
        if(k!=max_r)
        {
            for(j=col;j<var;j++) swap(a[k][j],a[max_r][j]);
            swap(x[k],x[max_r]);
        }
        x[k]/=a[k][col];
        for(j=col+1;j<var;j++) a[k][j]/=a[k][col];
        a[k][col]=1;
        for(i=0;i<equ;i++)
            if(i!=k)
            {
                x[i]-=x[k]*a[i][k];
                for(j=col+1;j<var;j++) a[i][j]-=a[k][j]*a[i][col];
                a[i][col]=0;
            }
    }
    return 1;
}

分解质因数：感谢浙大学长。。。Orz

long long fac[100],fac_num;
void getfactor(int num)
{
    fac_num=0; 
    for(int i=2;i*i<=num;i++)
    {
        if(num%i==0)
        {
             fac[fac_num++]=i;
             while(num%i==0) num/=i; 
         }
     }
     if(num>1) fac[fac_num++]=num;
 }

欧拉函数：

/*1.欧拉函数是积性函数,但不是完全积性函数,即φ(mn)=φ(n)*φ(m)只在(n,m)=1时成立. 
2.对于一个正整数N的素数幂分解N=P1^q1*P2^q2*...*Pn^qn.
    φ(N)=N*(1-1/P1)*(1-1/P2)*...*(1-1/Pn).
3.除了N=2,φ(N)都是偶数.
4.设N为正整数,∑φ(d)=N (d|N).  求小于等于N的与N互质的数的和 ：ans=N*phi(N)/2;*/
/* 欧拉phi(x)函数等于不超过x且和x互素的整数个数。 */ 
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAXN=1000;
int phi[MAXN]; /* 单个欧拉函数值*/  
int euler_phi(int n)
{
    int m=sqrt(n+0.5),ans=n;
    for(int i=2;i<=m;i++)
    {
        if(n%i==0) ans=ans/i*(i-1);
        while(n%i==0)n/=i;
    }
    if(n>1) ans=ans/n*(n-1);
    return ans;
} 
/*欧拉函数 表*/  
void phi_table(int n)
{
    memset(phi,0,sizeof(phi));
    phi[1]=1;
    for(int i=2;i<=n;i++)
        if(!phi[i])
            for(int j=i;j<=n;j+=i)
            {
                if(!phi[j])phi[j]=j;
                phi[j]=phi[j]/i*(i-1);
            }
}

埃氏筛法：O（nlog(logn)）

#include<iostream>
#include<cstring>
using namespace std;

const int MAXN=1000;
int isprime[MAXN];
void getprime(int n)
{
    memset(isprime,1,sizeof(isprime));
    isprime[0]=isprime[1]=0;
    for(int  i=0;i*i<n;i++)
        if(isprime[i])
            for(int j=i*i;j<=n;j+=i)
                isprime[j]=0;
}

欧拉筛法：

const int MAXN=1000;
int cnt=0;
int prime[MAXN];
bool mark[MAXN];
void Prime(int x)
{
    for(int i=2;i<=x;i++)
    {
        if(!mark[i]) prime[++cnt]=i;
        for(int j=1;j<=cnt&&prime[j]*i<=x;j++)
        {
            mark[prime[j]*i]=1;
            if(i%prime[j]==0) break;
        }
    }
}

后缀数组：

#include<iostream>
#include<cstring>
using namespace std;

const int MAXN=100000+5;
int WA[MAXN],WB[MAXN],WV[MAXN],WS[MAXN];
int Rank[MAXN],Height[MAXN];
 
int cmp(int *r , int a, int b, int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void DA(char *r , int *sa , int n, int m)
{
    int i, j, p, *x = WA, *y = WB;
    for(i = 0; i < m; i++)  WS[i] = 0;
    for(i = 0; i < n; i++) WS[x[i] = r[i]]++;
    for(i = 1; i < m; i++) WS[i] += WS[i-1];
    for(i = n-1; i >= 0; i--) sa[--WS[x[i]]] = i;

    for(j = 1,p = 1; p < n ; j <<= 1,m = p)
    {
        for(p = 0, i = n - j; i < n; i++) y[p++]=i;
        for(i = 0; i < n; i++)
            if(sa[i] >= j)
                y[p++] = sa[i] - j;
        for(i = 0; i < n; i++) WV[i] = x[y[i]];
        for(i = 0; i < m; i++) WS[i] = 0;
        for(i = 0; i < n; i++) WS[WV[i]]++;
        for(i = 1; i < m; i++) WS[i] += WS[i-1];
        for(i = n-1; i >= 0; i--) sa[--WS[WV[i]]] = y[i];
        for(swap(x,y),p = 1,x[sa[0]] = 0,i = 1; i < n;i++)
            x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
    }
}

void calheight(char *r,int *sa,int n)
{
    int i,j,k=0;
    for(i=1;i<=n;i++)Rank[sa[i]]=i;
    for(i=0;i<n;Height[Rank[i++]]=k)
        for(k?k--:0,j=sa[Rank[i]-1];r[i+k]==r[j+k];k++);
    return;
}

char str[MAXN];
int sa[MAXN];

int main()
{
    cin>>str;
    int n=strlen(str);
    str[n]=0;
    DA(str,sa,n+1,128);
    calheight(str,sa,n);

    return 0;
}

 

最大子串：

int maxSubstr() {
    int sum = 0, answer = -INF;
    for (int i = 1; i <= n; i++) {
        sum += a[i];
        answer = max(answer, sum);
        sum = max(sum,0);
    }
    return answer;
}

 

 SG函数：（转自SimonS大佬征战亚洲赛时用的模板

#define MAX 1005  
/* 计算从1-n范围内的SG值。     
Array(存储可以走的步数，Array[0]表示可以有多少种走法)     
Array[]需要从小到大排序 */ 
/*HDU1847博弈SG函数  
1.可选步数为1-m的连续整数，直接取模即可，SG(x) = x % (m+1);  
2.可选步数为任意步，SG(x) = x;  
3.可选步数为一系列不连续的数，用GetSG(计算) */   

int SG[MAX], hash[MAX];  
void GetSG(int Array[], int n = MAX-1) 
{
    memset(SG, 0, sizeof(SG));
    for(int i = 0; i <= n; ++i)
    {
        memset(hash, 0, sizeof(hash));
        for(int j = 1; j <= Array[0]; ++j) 
        {
            if(i < Array[j]) break;
            hash[SG[i - Array[j]]] = 1;      
        }
        for(int j = 0; j <= n; ++j)
            if(!hash[j]){ SG[i] = j;break; }
    }
}

先占坑，慢慢填