1018 Public Bike Management (30)（30 分）

---

---

1 题目

There is a public bike service in Hangzhou City which provides great convenience to the tourists from all over the world. One may rent a bike at any station and return it to any other stations in the city.
The Public Bike Management Center (PBMC) keeps monitoring the real-time capacity of all the stations. A station is said to be in perfect condition if it is exactly half-full. If a station is full or empty, PBMC will collect or send bikes to adjust the condition of that station to perfect. And more, all the stations on the way will be adjusted as well.
When a problem station is reported, PBMC will always choose the shortest path to reach that station. If there are more than one shortest path, the one that requires the least number of bikes sent from PBMC will be chosen.

Figure 1 illustrates an example. The stations are represented by vertices and the roads correspond to the edges. The number on an edge is the time taken to reach one end station from another. The number written inside a vertex S is the current number of bikes stored at S. Given that the maximum capacity of each station is 10. To solve the problem at S~3~, we have 2 different shortest paths:
1. PBMC -> S~1~ -> S~3~. In this case, 4 bikes must be sent from PBMC, because we can collect 1 bike from S~1~ and then take 5 bikes to S~3~, so that both stations will be in perfect conditions.
2. PBMC -> S~2~ -> S~3~. This path requires the same time as path 1, but only 3 bikes sent from PBMC and hence is the one that will be chosen.
Input Specification:
Each input file contains one test case. For each case, the first line contains 4 numbers: C~max~ (<= 100), always an even number, is the maximum capacity of each station; N (<= 500), the total number of stations; S~p~, the index of the problem station (the stations are numbered from 1 to N, and PBMC is represented by the vertex 0); and M, the number of roads. The second line contains N non-negative numbers C~i~ (i=1,…N) where each C~i~ is the current number of bikes at S~i~ respectively. Then M lines follow, each contains 3 numbers: S~i~, S~j~, and T~ij~ which describe the time T~ij~ taken to move betwen stations S~i~ and S~j~. All the numbers in a line are separated by a space.
Output Specification:
For each test case, print your results in one line. First output the number of bikes that PBMC must send. Then after one space, output the path in the format: 0->S~1~->…->S~p~. Finally after another space, output the number of bikes that we must take back to PBMC after the condition of S~p~ is adjusted to perfect.
Note that if such a path is not unique, output the one that requires minimum number of bikes that we must take back to PBMC. The judge’s data guarantee that such a path is unique.

Sample Input:

10 3 3 5
6 7 0
0 1 1
0 2 1
0 3 3
1 3 1
2 3 1

Sample Output:

3 0->2->3 0

题目链接：https://pintia.cn/problem-sets/994805342720868352/problems/994805489282433024

2 解题思路

　　题目大意：杭州市的自行车站管理系统，每个站点都有一定数量的自行车，数量处于最大值一半的状态是“perfect condition”（有车可借，有空位可还车），如果数量是0，称之为“problem condition”，需要从调度中心去运送车辆。运送路程中，如果经过自行车站点，会顺带调整该站点的状态，多的车子带走，少的顺带补齐。已知各个自行车站点的通车时间，求问最短的行车路线，如果存在多个最短路线，那么需要补送自行车最少的一个是多少。
　　解题思路：题目的本质实质上是求带权单源最短路径，可以使用Dijkstra算法，但可能存在多个最短路径，所以还要在最后的结果中使用深度优先搜索判断哪个是最符合条件的。
　　每个自行车站可以看做一个顶点，每条路可以看做带权路径，注意，顶点的状态有三个，不需要执行任何操作的perfect condition，目标修复顶点 problem condition，以及介于两者之间需要操作的顶点。在计算完最短路径之后，从目标顶点返回到0顶点，计算需要补送的自行车数量（need），以及需要带走的自行车的数量（back）。注意，出了proble condition顶点之外，其余顶点的自行车数量，有可能是多的，就是最后还要带回到0顶点一些自行车。

3 AC代码

/*
** @Brief:No.1018 of PAT advanced level.
** @Author:Jason.Lee
** @Date:2018-8-03
*/

#include 
#include 
#include 
using namespace std;
// 设置最大值的上限 
const int inf = 99999999;
int cmax, n, sp, m;
// minNeed 是最小需求，minBack是最小 
int minNeed = inf, minBack = inf;
// 数组下标作为顶点标记，e存储边信息，dis更新距离信息，weight记录每个顶点的权重 
int e[510][510], dis[510], weight[510];
// visit 记录是否访问过 
bool visit[510];

vector<int> pre[510];// 每个顶点向下一个顶点，可能存在多个选择 
vector<int> path, temppath;

//深度优先遍历，输入顶点V，开始对其进行dfs搜索
//注意搜索方向是从sp顶点到0顶点，且搜索路径是已经被Dijkstra算法优化过的路径 
void dfs(int v) {
    // 深度优先路过的顶点，存入到temppath 
    temppath.push_back(v);
    // 当到达顶点0的时候，开始计算 
    if(v == 0) {
        int need = 0, back = 0;
        for(int i = temppath.size() - 1; i >= 0; i--) {
            int id = temppath[i];
            // 该顶点的自行车处于多的状态 
            if(weight[id] > 0) {
                //
                back += weight[id];
            } else {
                // 该顶点的自行车处于少或者完美状态 
                if(back > (0 - weight[id])) {
                    // 如果back中是足够的，先从back中扣出 
                    back += weight[id];
                } else {
                    // 如果back不够，那么需要从need中借 
                    need += ((0 - weight[id]) - back);
                    back = 0;
                }
            }
        }
        //计算最小的需求 
        if(need < minNeed) {
            minNeed = need;
            minBack = back;
            path = temppath;
            //计算最小需求中带回来最少的 
        } else if(need == minNeed && back < minBack) {
            minBack = back;
            path = temppath;
        }
        // 顶点在dfs访问结束后弹出 
        temppath.pop_back();
        return ;
    }

    for(int i = 0; i < pre[v].size(); i++)
        dfs(pre[v][i]);
    // 该顶点在dfs访问结束后弹出 
    temppath.pop_back();
}
int main() {
    // 初始化二维数组e 
    fill(e[0], e[0] + 510 * 510, inf);
    // 初始化数组dis  
    fill(dis, dis + 510, inf);
    scanf("%d%d%d%d", &cmax, &n, &sp, &m);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &weight[i]);
        // 直接计算得到，相对于perfect状态的需求 
        weight[i] = weight[i] - cmax / 2;
    }
    for(int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        scanf("%d", &e[a][b]);
        e[b][a] = e[a][b];
    }
    // 顶点0到自身的距离自然是0 
    dis[0] = 0;
    // 双重for循环遍历整张图，Dijkstra算法 
    // 外层循环表示遍历0~N个顶点 
    for(int i = 0; i <= n; i++) {
        // 选出距离顶点0距离最小的顶点u
        int u = -1, minn = inf;
        for(int j = 0; j <= n; j++) {
            if(visit[j] == false && dis[j] < minn) {
                u = j;
                minn = dis[j];
            }
        }
        if(u == -1) break;
        visit[u] = true;
        // 该循环的作用是通过e来更新u顶点与其他顶点的最小路径 
        for(int v = 0; v <= n; v++) {
            if(visit[v] == false && e[u][v] != inf) {
                // 更新u顶点到v顶点的更小值 
                if(dis[v] > dis[u] + e[u][v]) {
                    dis[v] = dis[u] + e[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }else if(dis[v] == dis[u] + e[u][v]) {
                    // u v 之间可能存在多个最短路径 
                    pre[v].push_back(u);
                }
            }
        }
    }
    // 对problem station 进行深度优先搜索，以选取多个路径当中最符合条件的一个 
    dfs(sp);
    printf("%d 0", minNeed);
    for(int i = path.size() - 2; i >= 0; i--)
        printf("->%d", path[i]);
    printf(" %d", minBack);
    return 0;
} 

4 总结

　　题目其实不是特别难，但是怎么都做不对，最后参考的柳婼大神的代码，才AC，看来对Dijkstra算法还是不太熟。搭建PAT新官网的童鞋有点粗心大意，犯了一个低级错误——