图论模板（一）

迪杰斯特拉dijkstra

1. 找到所有未确定点中距离要求点最近的点。
2. 确定到此点的最小距离。
3. 更新此点到其他点的距离

朴素

#include<iostream>
#include<cstring>
using namespace std;
const int N=1e5+10;
int e[N*2],ne[N*2],w[N*2],h[N],idx;
int d[N];
int n,m;
bool st[N];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

void dijkstra()
{
    memset(d,0x3f,sizeof(d));
    d[1]=0;
    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
            if(!st[j]&&(t==-1 || d[t]>d[j])) t=j;
        st[t]=1;
        for(int j=h[t];j!=-1;j=ne[j])
        {
            int k=e[j];
            d[k]=min(d[k],d[t]+w[j]);
        }
    }
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof(h));
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    dijkstra();
    if(d[n]>=0x3f3f3f3f) cout<<-1;
    else cout<<d[n];
 }

迪杰斯特拉（堆版）

#include<iostream>
#include <cstring>
#include<queue>
#define x first
#define y second

using namespace std;
typedef pair<int,int> PII;
const int N=1e5+10;
int n,m,d[N];
int h[N],e[N*2],idx,ne[N*2],w[N*2];
bool st[N];

void add(int a,int b,int c)
{
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}

void dijkstra()
{
    memset(d,0x3f,sizeof(d));
    priority_queue<PII,vector<PII>,greater<PII>> heap;
    d[1]=0;
    heap.push({0,1});
    while(heap.size())
    {
        PII t=heap.top();
        heap.pop();
        
        if(st[t.y]) continue;
        st[t.y]=1;
        
        for(int j=h[t.y];j!=-1;j=ne[j])
        {
            int k=e[j];
            if(w[j]+d[t.y]<d[k]) 
            {
                d[k]=d[t.y]+w[j];
                heap.push({d[k],k});
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof(h));
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    
    dijkstra();
    if(d[n]>=0x3f3f3f3f) cout<<-1;
    else cout<<d[n];
}

bellman_ford算法

1. 不管三七二十一，枚举需要的k条边，每条边都枚举一次O（nm）
2. 标准点到每个点距离为无穷，到本身距离为0
3. 注意用back保存上一步，防止使用不该用的点
4. d[j]=min(d[i]+c,d[j])
5. 判断需要的点是否大于0x3f3f3f3f/2.

#include<iostream>
#include<cstring>

using namespace std;
const int N=1e5+10;

struct Node
{
    int a,b,c;
}e[N];
int d[N];
int back[N];
int n,m,k;

int pan()
{
    memset(d,0x3f,sizeof(d));
    d[1]=0;
    for(int i=1;i<=k;i++)
    {
        memcpy(back,d,sizeof(d));
        for(int j=0;j<m;j++)
        {
            int a=e[j].a,b=e[j].b,c=e[j].c;
            d[b]=min(d[b],back[a]+c);
        }
    }
    
    return d[n];
}

int main()
{
    cin>>n>>m>>k;
    
    for(int i=0;i<m;i++) cin>>e[i].a>>e[i].b>>e[i].c;
    
    if(pan()>=0x3f3f3f3f/2) cout<<"impossible";
    else cout<<pan();
    
}

拓扑排序

1. 将每条边读入，读入一条边a->b,d[b]++
2. 找到当前入度为0的点，入队q[++tt]=i
3. 对每一个队内元素往下找，相当于砍掉一条边，如果此时这条边的对应值入度为0，则入队。

#include<iostream>
#include<cstring>
using namespace std;
const int N=1e5+10;
int e[N*2],ne[N*2],w[N*2], h[N],d[N], n,m,idx;
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int q[N];
int pai()
{
    int hh=0,tt=-1;
    for(int i=1;i<=n;i++)
        if(!d[i]) q[++tt]=i;
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(--d[j]==0) q[++tt]=j;
        }
    }
    return tt==n-1;
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof(h));
    for(int i=1;i<=m;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        d[b]++;
    }
    if(pai())
        for(int i=0;i<n;i++) cout<<q[i]<<' ';
    else cout<<-1;
}