1003 Emergency (25分) Dijkstra/Bellman-Ford

原题链接

Dijkstra

注意

最短路径数与点权无关

出错点：

  else if(d[v] == d[u] + G[u][v] && w[v] < w[u] + weight[v])
                {
                    d[v] = d[u] + G[u][v];
                    num[v] += num[u];
                    w[v] = w[u] + weight[v];
                }

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
const int INF = 0x3fffffff;

//距离最短 救援队数量最多
int n, m, s, e;//n城市个数 m边数 s起点编号 e终点编号
int G[maxn][maxn], weight[maxn]; //G图的存储两城市间距离 weight存储救援队数量
int d[maxn], w[maxn]; //d源点到该城市的最近距离 w源点到该城市的最大救援队数量
int num[maxn];//存放源点到该点的最短路径数量
bool vis[maxn] = {false};

void dijkstra(int s)
{
    fill(d, d + maxn, INF);
    //初始化;
    d[s] = 0;
    w[s] = weight[s];
    num[s] = 1;
    for(int i = 0; i < n; i++)
    {
        int u = -1, MIN = INF;
        for(int j = 0; j < n; j++) //找d[]最小的
        {
            if(vis[j] == false && d[j] < MIN)
            {
                u = j;
                MIN = d[u]; //找到最小de
            }
        }
        if(u == -1) return;
        vis[u] = true;
        //更新 距离最短 距离相同就找救援队数量最大
        for(int v = 0; v < n; v++)
        {
            if(vis[v] == false && G[u][v] != INF) //可以访问
            {
                if(d[v] > d[u] + G[u][v])
                {
                    d[v] = d[u] + G[u][v];
                    num[v] = num[u];
                    w[v] = w[u] + weight[v];
                }
                else if(d[v] == d[u] + G[u][v])
                {
                    num[v] += num[u];//最短路径数与点权无关
                    if(w[v] < w[u] + weight[v])
                    {
                        d[v] = d[u] + G[u][v];
                        w[v] = w[u] + weight[v];
                    }
                }
            }
        }
    }

}
int main()
{
    int u, v, x;
    cin >> n >> m >> s >> e;
    fill(G[0], G[0] + maxn * maxn, INF);
    for(int i = 0; i < n; i++)
    {
        cin >> weight[i];
    }
    for(int i = 1; i <= m; i++)
    {
        cin >> u >> v >> x;
        G[u][v] = x;
        G[v][u] = x;
    }
    dijkstra(s);
    cout << num[e] << " " << w[e];
    return 0;
}

Bellman-Ford

#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
const int INF = 0x3fffffff;
struct node
{
    int v, dis;//v为邻接表的目标顶点，dis为邻接边的边权
    node(int _v, int _dis): v(_v), dis(_dis) {} //构造函数
};
//邻接表存储
vector<node> Adj[maxn]; //图G的邻接表
set<int> pre[maxn]; //记录前驱的数组
int n, m, s, e;//n为顶点数maxv为最大顶点数
int weight[maxn]; //每点的救援队数量
int d[maxn], w[maxn], num[maxn]; //起点到达各点的最短路径长度
//反复计算反复更新没有什么标记不标记一说

void Bellman(int s) //s是源点
{
    fill(d, d + maxn, INF);
    d[s] = 0;
    w[s] = weight[s];
    num[s] = 1;
    //以下为求解数组d的部分
    for(int i = 0; i < n - 1; i++) //对bellman-Ford的松弛算法不会超过n-1轮
    {
        for(int u = 0; u < n; u++)
        {
            for(int j = 0; j < Adj[u].size(); j++)
            {
                int v = Adj[u][j].v;
                int dis = Adj[u][j].dis;
                if(d[v] > d[u] + dis)
                {
                    d[v] = d[u] + dis;
                    w[v] = w[u] + weight[v];
                    num[v] = num[u];
                    pre[v].clear();
                    pre[v].insert(u);
                }
                else if(d[v] == d[u] + dis)
                {
                    if(w[v] < w[u] + weight[v])
                    {
                        w[v] = w[u] + weight[v];
                    }
                    pre[v].insert(u);
                    num[v] = 0; //重新统计num[v]
                    set<int>::iterator it;
                    for(it = pre[v].begin(); it != pre[v].end(); it++)
                    {
                        num[v] += num[*it];
                    }
                }
            }
        }
    }
}
int main()
{
    int u, v, dis;
    cin >> n >> m >> s >> e;
    for(int i = 0; i < n; i++)
    {
        cin >> weight[i];
    }
    for(int i = 0; i < m; i++)
    {
        cin >> u >> v >> dis;
        Adj[u].push_back(node(v, dis));
        Adj[v].push_back(node(u, dis));
    }
    Bellman(s);
    cout << num[e] << " " << w[e];
    return 0;
}