考研用模板

bellman_ford

bellman_ford
#include<iostream>
#include<cstdio>
using namespace std;
 
#define MAX 0x3f3f3f3f
#define N 1010
int nodenum, edgenum, original; //点，边，起点
 
typedef struct Edge //边
{
	int u, v;
	int cost;
}Edge;
 
Edge edge[N];
int dis[N], pre[N];
 
bool Bellman_Ford()
{
	for(int i = 1; i <= nodenum; ++i) //初始化
		dis[i] = (i == original ? 0 : MAX);
	for(int i = 1; i <= nodenum - 1; ++i)
		for(int j = 1; j <= edgenum; ++j)
			if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //松弛（顺序一定不能反~）
			{
				dis[edge[j].v] = dis[edge[j].u] + edge[j].cost;
				pre[edge[j].v] = edge[j].u;
			}
			bool flag = 1; //判断是否含有负权回路
			for(int i = 1; i <= edgenum; ++i)
				if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)
				{
					flag = 0;
					break;
				}
				return flag;
}
 
void print_path(int root) //打印最短路的路径（反向）
{
	while(root != pre[root]) //前驱
	{
		printf("%d-->", root);
		root = pre[root];
	}
	if(root == pre[root])
		printf("%d\n", root);
}
 
int main()
{
	scanf("%d%d%d", &nodenum, &edgenum, &original);
	pre[original] = original;
	for(int i = 1; i <= edgenum; ++i)
	{
		scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);
	}
	if(Bellman_Ford())
		for(int i = 1; i <= nodenum; ++i) //每个点最短路
		{
			printf("%d\n", dis[i]);
			printf("Path:");
			print_path(i);
		}
	else
		printf("have negative circle\n");
	return 0;
}

DijkstraOnlogn静态链表

#define INF 0x3f3f3f3f
using namespace std;
int n,m,t1,t2,t3,len,dis[105],book[105],head[105];
struct edge{
    int des,w,next;}e[105];
struct node{
    int pos,cost;
    node(){};
    node(int pos,int cost):pos(pos),cost(cost){};
    friend bool operator< (node a,node b)
    {
        return a.cost>b.cost;
    }
};
void init()
{
    len=0;
    memset(dis,INF,sizeof(dis));
    memset(book,0,sizeof(book));
    memset(head,-1,sizeof(head));
}
void add(int t1,int t2,int t3)
{
    e[len].des=t2;
    e[len].w=t3;
    e[len].next=head[t1];
    head[t1]=len++;
}
void Dijkstra(int sx,int ex)
{
    priority_queue<node> q;
    q.push(node(sx,0));
    dis[sx]=0;
    while(!q.empty())
    {
        node now=q.top();
        q.pop();
        if(book[now.pos]==1) continue;
        book[now.pos]=1;
        if(now.pos==ex) break;
    for(int i=head[now.pos];i!=-1;i=e[i].next)
    {
        int id=e[i].des;
        if(dis[id]>dis[now.pos]+e[i].w)
        {
            dis[id]=dis[now.pos]+e[i].w;
            q.push(node(id,dis[id]));
        }
    }
    }
    cout<<dis[ex]<<endl;
}
int main()
{
    while(~scanf("%d %d",&n,&m)&&(n||m))
    {
        init();
        while(m--)
        {
            scanf("%d%d%d",&t1,&t2,&t3);
            add(t1,t2,t3);
            add(t2,t1,t3);
        }
        Dijkstra(1,n);
    }
    return 0;
}

Dijkstra O(n^2)

#define inf 0x3f3f3f3f
using namespace std;
int mp[1005][1005],book[1005],dis[1005];
int t1,t2,t3,n;
void Dij(int s,int e)
{
	dis[s]=0;
	int i,j;
	for(i=1;i<=n;i++)
	{
		int minw=inf,minv;
		for(j=1;j<=n;j++)
		{
			 if(book[j])  continue;
		     if(dis[j]<minw)
			 {
			     minv=j;
				 minw=dis[minv];	
			 }	
		}
		book[minv]=1;
		if(minv==e)  break;
		for(j=1;j<=n;j++)
		{
			if(book[j]||!mp[minv][j])  continue;
			if(dis[j]>dis[minv]+mp[minv][j])
			    dis[j]=dis[minv]+mp[minv][j];	
		}
	}
	cout<<dis[e]<<endl;
}
int main()
{  
   int t;
   while(~scanf("%d%d",&t,&n))
   {
   	   memset(mp,inf,sizeof(mp));
   	   memset(book,0,sizeof(book));
   	   memset(dis,inf,sizeof(dis));
   	   while(t--)
   	   {
		   scanf("%d%d%d",&t1,&t2,&t3);
		   if(t3>mp[t1][t2])	
		     continue;
		   mp[t1][t2]=mp[t2][t1]=t3;
	    }
	    Dij(1,n);
   }
   return 0;
}

拓扑

#define INF 0x3f3f3f3f
using namespace std;
int mp[105][105], indegree[105], m, n，f[maxn];
bool Topsort()
{
    int i,j,top=0,tmp=0;
    bool p=true;
    while(p)
    {

        p=false;
        top++;
        tmp=-1;
        for(i=0; i<=n-1; i++)
            if(indegree[i]==0)
            {
                p=true;
                //f[i]=top;
                tmp=i;
                break;
            }
        if(tmp==-1)
            continue;
        for(j=0; j<n; j++)
        {
            if(mp[tmp][j])
                indegree[j]--;
            indegree[tmp]=-1;
        }
    }
    top--;
    if(top<n)
        return false;
    return true;
}
int main()
{
	while(cin>>n>>m)
	{   if(n==0) break;
		memset(mp,0,sizeof(mp));
		memset(indegree,0,sizeof(indegree));
		int a, b;
		for(int i=0; i<m; i++)
		{
			cin>>a>>b;
			if(!mp[a][b])
			{
				mp[a][b] = 1;
				indegree[b]++;
			}
		}
		if(Topsort()) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

floyd

	
#define INF 0x3f3f3f3f
using namespace std;
const int maxn=2e5+5;
int dis[105][105];
int main()
{
    int N,M,t1,t2,t3;
    while(cin>>N>>M)
    {   memset(dis,INF,sizeof(dis));
        if(N==0 && M==0) break;
    for(int i=1;i<=M;i++)
    {
        scanf("%d %d %d",&t1,&t2,&t3);
        dis[t1][t2]=t3;
        dis[t2][t1]=t3;
    }
    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]);
    printf("%d\n",dis[1][N]);

    }
    return 0;
}

树的直径

void bfs(int num)
{
    queue<node> q;
    node temp1;
    temp1.cost=0;
    temp1.des=num;
    q.push(temp1);
    while(!q.empty())
    {
        for(vector<node>::iterator ite=mp[q.front().des].begin();ite!=mp[q.front().des].end();ite++)
        {
            if(book[ite->des]==0)
            {
                book[ite->des]=1;
                temp1.des=ite->des;
                temp1.cost=ite->cost+q.front().cost;
                q.push(temp1);
                if(maxs<temp1.cost)
                {
                    maxs=temp1.cost;
                    sta=temp1.des;
                }
            }
        }
        q.pop();
    }
}