各种模板（part 2）

堆：

using namespace dui //堆
{
    #include<queue> //需要的库
    priority_queue < int > Q; //定义一个Q的大根堆,top（）为较大的
    priority_queue < int,vector < int >,greater< int > > q; //定义一个q的小根堆。top()为较小的
    q.empty() //判断队空
    q.push(x) //将x放入队列
    q.pop() //将队头删除
    q.size() //返回堆中元素个数
    q.top() //返回队头
    
    //在结构体中自己定义优先级
    struct node
    {
        int id,v;
        friend bool operator < (node n1, node n2)
        {
            return n1.v>n2.v; //要满足的条件
        }
    }f[maxn];
    priority_queue<node>q;
}

图论：

图的建立+遍历

using namespace tu //图
{
    int len=0,linkk[maxn];
    struct node //邻接表
    {
        int x,y,v;
    }e[maxn];
    init(int xx,int yy,int vv)
    {
        e[++len].y=linkk[xx];linkk[xx]=len;
        e[len].x=yy;e[len].v=vv;
    }
    
    struct node    // 边表
    {
        int x,y;
    }e[maxn];
    
    void dfs(int k) //邻接矩阵的dfs
    {
        for(int i=1;i<=n;i++)
        {
            if((a[k][i])&&(!f[i]))
            {
                f[i]=1;
                dfs(i);
            }
        }
    }
    
    void dfs(int k) //邻接表的dfs
    {
        for(int i=linkk[k];i;i=e[i].y)
        {
            if(!f[e[i].x])
            {
                f[e[i].x]=1;
                dfs(e[i].x);
            }
        }
    }
}

floyed+dijkstra（最短路，邻接矩阵）

void floyed()    //神算法,,邻接矩阵
    {
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
    }
    
    void dijkstra(int st)    //邻接矩阵
    {
        for(int i=1;i<=n;i++)
            dis[i]=a[st][i];
        memset(vis,0,sizeof(vis));
        vis[st]=1;dis[st]=0;
        for(int i=1;i<=n;i++)
        {
            int minn=999999;
            int k=0;
            for(int j=1;j<=n;j++)
            {
                if((!vis[j])&&(dis[j]<minn))
                {
                    minn=dis[j];
                    k=j;
                }
            }
            if(k==0)    return;
            vis[k]=1;
            for(int j=1;j<=n;j++)
            {
                if(!vis[j]&&(dis[k]+a[k][j]<dis[j]))
                {
                    dis[j]=dis[k]+a[k][j];
                }
            }
        }
    }

bellman-ford（最短路，判负环，边表）

int bellman-ford(int st) //边表
    {
        memset(dis,10,sizeof(dis));
        dis[st]=0;
        bool rel=0;
        for(int i=1;i<=n;i++)
        {
            rel=0;
            for(int j=1;j<=len;j++)
            {
                if(dis[e[j].x]+a[j].v<dis[a[j].y])
                {
                    dis[a[j].y]=dis[e[j].x]+a[j].v;
                    rel=1;
                }
            }
            if(!rel)
                return 0; //没有松弛，结束
        }
        return 1; //迭代n次，又负环
    }

SPFFA（最短路，邻接表）

void SPFA(int st) //邻接表
    {
        memset(dis,10,sizeof(dis));
        memset(vis,0,sizeof(vis));
        int q[maxn],head=0,tail=1;
        dis[st]=0;vis[st]=1;q[1]=sr;
        while(head<=tail)
        {
            int tn=q[++head];via[tn]=0;
            int te=linkk[tn];
            for(int i=te;i;i=e[i].y)
            {
                int tmp=e[i].x;
                if(dis[tmp]>dis[tn]+e[i].v)
                {
                    dis[tmp]=dis[tn]+e[i].v;
                    if(!vis[tmp])
                    {
                        q[++tail]=tmp;
                        vis[tmp]=1;
                    }
                }
            }
        }
    }

prim（最小生成树，邻接矩阵）

void prim(int st) //最小生成树,邻接矩阵
    {
        memset(dis,10,sizeof(dis));
        memset(vis,0,sizeof(vis));
        vis[st]=1;sum=0;
        for(int i=1;i<n;i++)
        {
            int minn=a[0][0],c=0;
            for(int j=1;j<=n;j++)
            {
                if(!vis[j]&&dis[j]<minn)
                {
                    minn=dis[j];
                    c=j;
                }
            }
            vis[c]=1;
            sum+=minn;
            for(int j=1;j<=n;j++)
            {
                if(a[c][j]<dis[j]&&!vis[j])
                    dis[j]=a[c][j];
            }
        }
    }

kruskal（最小生成树，边表）

kruskal //边表+并查集
    {
        struct node // 边表
        {
            int x,y;
        }e[maxn];
        int getfa(int k)
        {
            if(fa[k]==k) return k;
            fa[k]=getfa(fa[k]);
            return fa[k];
        }
        void meg(int x,int y)
        {
            int fx=getfa(x);
            int fy=getfa(y);
            fa[fx]=fy;
        }
        bool jud(int x,int y)
        {
            int fx=getfa(x);
            int fy=getfa(y);
            return fx==fy;
        }
        bool mys(node a,node b)
        {
            return a.v<b.v;
        }
        void kruskal()
        {
            for(int i=1;i<=n;i++)
                fa[i]=i;
            sort(e+1,e+1+m,mys);
            int cal=0;
            for(int i=1;i<=len;i++)
            {
                int fx=getfa(e[i].x);
                int fy=getfa(e[i].y);
                if(fx!=fy)
                {
                    meg(fx,fy);
                    if(++cal==n-1);
                    return ;
                }
            }
        }
    }