PAT A1018 Public Bike Management (30 分) Dijkstra算法

       题目大意：给出一张图，图上节点0代表自行车中心，节点1~N代表自行车站。每个自行车站有最大容量C，最佳状态是自行车数量为C/2。现在从节点0到达某个节点，求出最短的路径，同时，调整在这一路径上的每一个自行车站，使它们的数量都达到最佳。如果最短路径有多条，输出需要从节点0带出的自行车数量最少的一条，如果这样的最短路径仍有多条，输出最后需要带回节点0的自行车数量最少的一条。

       常规的dijkstra + dfs问题，主要是两个尺度的处理，即需要带出的自行车数量 send 的计算方法和需要带回的自行车 take 的计算方法。找到最短路径后，从节点0的下一个节点开始遍历，take += 当前节点车数 - 最佳车数， 如果 take < 0，说明从前面的站点带出的 take 辆车仍然不够，需要从节点0带出车， send -= take，同时 take = 0。可以在开始的输入时，就将每个节点的权赋值为 当前节点车数 - 最佳车数， 方便处理。

AC代码如下：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int CMAX, N, D, M;
const int MAXN = 510;
const int INF = 1e9;
int G[MAXN][MAXN], d[MAXN], weight[MAXN];
bool visited[MAXN];
vector<int> pre[MAXN];

void Dijkstra(int s)
{
    fill(d, d + MAXN, INF);
    d[s] = 0;
    for (int i = 0; i < N; ++i)
    {
        int u = -1, MIN = INF;
        for (int j = 0; j < N; ++j)
        {
            if(!visited[j] && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return;
        visited[u] = true;
        for (int k = 0; k < N; ++k)
        {
            if(!visited[k] && G[u][k] < INF)
            {
                int dis = G[u][k];
                if(d[u] + dis < d[k])
                {
                    d[k] = d[u] + dis;
                    pre[k].clear();
                    pre[k].push_back(u);
                }
                else if(d[u] + dis == d[k]) pre[k].push_back(u);
            }
        }
    }
}

int optTake = INF, optSend = INF;
vector<int> path, tmpPath;
void DFS(int s, int v)
{
    if(s == v)
    {
        tmpPath.push_back(v);
        int take = 0, send = 0;
        for(int i = tmpPath.size() - 2; i >= 0; i--)
        {
            take += weight[tmpPath[i]];
            if(take < 0)
            {
                send -= take;
                take = 0;
            }
        }
        if(send < optSend)
        {
            optSend = send;
            optTake = take;
            path = tmpPath;
        }
        else if(send == optSend && take < optTake)
        {
            optSend = send;
            optTake = take;
            path = tmpPath;
        }
        tmpPath.pop_back();
        return;
    }
    tmpPath.push_back(v);
    for (int i = 0; i < pre[v].size(); ++i)
    {
        DFS(s, pre[v][i]);
    }
    tmpPath.pop_back();
}

int main()
{
    cin >> CMAX >> N >> D >> M;
    N++;
    fill(G[0], G[0] + MAXN * MAXN, INF);
    for (int i = 1; i < N; ++i)
    {
        int tmp;
        scanf("%d", &tmp);
        weight[i] = tmp - CMAX / 2;
    }
    for (int i = 0; i < M; ++i)
    {
        int u, v, dis;
        cin >> u >> v >> dis;
        G[u][v] = G[v][u] = dis;
    }
    Dijkstra(0);
    DFS(0, D);
    reverse(path.begin(), path.end());
    printf("%d ", optSend);
    for (int i = 0; i < path.size(); ++i)
    {
        printf("%d", path[i]);
        if(i < path.size() - 1) printf("->");
    }
    printf(" %d\n", optTake);
    return 0;
}