POJ_2387 Til the Cows Come Hom 【最短路】

一、题目

POJ2387

二、分析

Bellman-Ford算法

　该算法是求单源最短路的，核心思想就是不断去更新到起点的最短距离，更新的前提是没有负边。如果有负边需要手动控制循环次数。

Dijkstra算法

　同样是单源最短路，它的核心是

　(1) 找到最短距离已经确定的顶点，再从该顶点出发，更新与它相邻的点的最短距离。

　(2) 对于最短距离已经确定的点不再更新。

Floyd算法

　可以求解任意两点之间的最短距离。但是这题会TLE。

三、AC代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <fstream>
using namespace std;
const int MAXN = 2e3+14;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cost;
}E[MAXN<<1];
int T, N, C;
int dist[MAXN];
void Bellman_Ford()
{
    memset(dist, INF, sizeof(dist));
    dist[1] = 0;
    while(1)
    {
        bool flag = 0;
        for(int i = 0; i < C; i++)
        {
            if(dist[E[i].from] != INF && dist[E[i].to] > dist[E[i].from] + E[i].cost)
            {
                dist[E[i].to] = dist[E[i].from] + E[i].cost;
                flag = 1;
            }
        }
        if(!flag)
            break;
    }
}
int main()
{
    //freopen("in.txt", "r", stdin);
    scanf("%d%d", &T, &N);
    C = 0;
    int a, b ,c;
    for(int i = 0; i < T; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        E[C].from = a, E[C].to = b, E[C].cost = c;
        C++;
        E[C].from = b, E[C].to = a, E[C].cost = c;
        C++;
    }
    Bellman_Ford();   
    printf("%d
", dist[N]);
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <fstream>
#include <vector>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int MAXN = 2e3+14;
const int INF = 0x3f3f3f3f;
struct edge
{
    int from, to, cost;
    edge(int f, int t, int c)
    {
        from = f, to = t, cost = c;
    }
};
vector<edge> G[MAXN];
priority_queue<P> pq;
int T, N;
int dist[MAXN];

void Dijkstra(int s)
{
    memset(dist, INF, sizeof(dist));
    dist[s] = 0;
    pq.push(P(0, s));
    while(!pq.empty())
    {
        P p = pq.top();
        pq.pop();
        int v = p.second;
        if(dist[v] < p.first)
            continue;
        for(int i = 0; i < G[v].size(); i++)
        {
            edge e = G[v][i];
            if(dist[e.to] > dist[v] + e.cost)
            {
                dist[e.to] = dist[v] + e.cost;
                pq.push(P(dist[e.to], e.to));
            }
            
        }
    }
}

int main()
{
    //freopen("in.txt", "r", stdin);
    scanf("%d%d", &T, &N);
    int a, b ,c;
    for(int i = 0; i < T; i++)
    {
        scanf("%d%d%d", &a, &b, &c);
        G[a].push_back(edge(a, b, c));
        G[b].push_back(edge(b, a, c));
    }
    Dijkstra(1);   
    printf("%d
", dist[N]);
    return 0;
}