图论的最短路问题

Bellman-Ford:

#include<cstdio>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
#define MAX_V 10000
#define MAX_E 10000
#define INF 0x3f3f3f3f
struct edge
{
 	int from, to, cost;
};
edge es[MAX_E];
int d[MAX_V];

memset(edge,0,sizeof(edge));
memset(d,0,sizeof(d));

int V, E;
void shortest_path(int s)
{
	for(int i = 0; i < V; ++i) d[i] = INF;
	d[s] = 0;
	while(true)
	{
		bool update = false;
		for(int i = 0;i<E; ++i)
		{
			edge e = es[i];
			if(d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
			{
				d[e.to] = d[e.from] + e.cost;
				update = true;
			}
		}
	}
}
int main()
{
          return 0;
}

看有没有负圈：
<pre name="code" class="cpp">bool find_negative_loop()
{
    memset(d,0,sizeof(d));
    
    for(int i = 0; i < V;++i)
    {
        for(int j = 0; j < E; ++j)
        {
            edge e =es[j];
            if(d[e.to] > d[e.from] + e.cost)
            {
                d[e.to] = d[e.from] + e.cost;
                if(i==V-1) return true;
            }
        }
    }
}

Dijkstra：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAX_V 10000
#define INF 0x3f3f3f3f
int cost[MAX_V][MAX_V];
int d[MAX_V];
bool used[MAX_V];
int V;
void dijkstra(int s)
{
    fill(d, d+V, INF);
    fill(used, used+V, false);
    d[s] = 0;
    while(true)
    {
        int v = -1;
        for(int u = 0; u < V; ++u)
        {
            if(!used[u] &&(v==-1 || d[u] < d[v])) v = u;
        }
        if(v==-1) break;
        used[v]= true;
        for(int u = 0;u < V; ++u)
        {
            d[u] = min(d[u], d[v] + cost[v][u]);
        }
    }
}
int main()
{
    return 0;
}