[PAT]A1018(Public Bike Management)踩坑及解题思路

原题回顾

PAT_A1018原文链接

1018 Public Bike Management (30分)

作者: CHEN, Yue
单位: 浙江大学
时间限制: 400 ms
内存限制: 64 MB
代码长度限制: 16 KB

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.

The above figure 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₃, we have 2 different shortest paths:
1.PBMC -> S₁ -> S₃. In this case, 4 bikes must be sent from PBMC, because we can collect 1 bike from S₁ and then take 5 bikes to S₃, so that both stations will be in perfect conditions.
2.PBMC -> S₂ -> S₃. 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_iis 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 between 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₁->...->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

解题思路及注意点

• 第一遍做时立马就选择了用Dijkstra算法解决诸如此类最短路径类问题(曾自学过算法笔记，对此印象比较深刻)，但是有一个问题是无法在路径中确定最优解，只能把所有最短路径确定后，再去选择其中最优的一条，所以必须在其中穿插DFS算法，根据前驱结点递归来得到所有路径。
• 我对题目的第一个误解是认为从PBMC要么是往外带，要么是往回带，总之不会即带出又带回，这样显然多此一举，按照这样的思路写出代码后发现有两个测试点未通过，于是又重新读了几遍题目，并经过几次不断尝试修改代码(其实就是DFS部分)，最后发现题目的设定是这样的：假如路径为 A->B->C->D，如果在B点发现车辆不够，需要补充，那么就必须要从始发地A多带出缺少的车辆，无论此时C和D是什么状态，即使C、D全部爆满，也与A没有关系，可以理解为一直向前走不回头，所以，如果目的地的车辆大于满载的一半，那么无论前面的地点缺多少辆车，总会把目的地多余的车辆直接送回总部，与路径上的所有点无关。 于是将代码的DFS部分修改后顺利通过了所有测试点。

代码部分

#include 
#include 
#include 
using namespace std;
const int maxn = 1010;
const int INF = 0x3fffffff;

int c, n, ed, m; //最大容量，顶点数，目的地，边数
int G[maxn][maxn], d[maxn], weight[maxn]; //邻接矩阵，最短路径，点权
vector pre[maxn]; //前驱结点
vector tempPath, Path; //当前路径，最优路径
bool vis[maxn]; //是否访问过
int minOut = INF, minBack = INF; //优化结果

void Dijkstra(int s) //标准Dijkstra算法
{
    fill(d, d + maxn, INF);
    d[s] = 0;
    for (int i = 0; i <= n; i++) //因为加上了顶点，所以一共循环n+1次，每次都找到距离最短的点
    {
        int u = -1, MIN = INF; //u使d[u]最短
        for (int j = 0; j <= n; j++)
        {
            if (vis[j] == false && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
        }
        if (u == -1) //找不到可达点，说明搜索完毕
            return;
        vis[u] = true; //已访问
        for (int v = 0; v <= n; v++)
        {
            if (vis[v] == false && G[u][v] != INF) //未访问过且可到达
            {
                if (d[u] + G[u][v] < d[v])
                {
                    d[v] = d[u] + G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if (d[u] + G[u][v] == d[v])
                {
                    pre[v].push_back(u);
                }
            }
        }
    }
}

void DFS(int v)
{
    if (v == 0)
    {
        tempPath.push_back(v);
        int Out = 0, Back = 0; //需要带出的车辆数目，需要带回的车辆数目
        int take = 0; //路上搜集到的自行车数目
        for (int i = tempPath.size() - 1; i >= 0; i--)
        {
            int id = tempPath[i];
            if (weight[id] > (c / 2)) //超过一半，加入收集量
                take += weight[id] - (c / 2);
            if (weight[id] < (c / 2))
                take -= (c / 2) - weight[id]; //不足一半，用搜集量去弥补，不够的话take变为负值
            if (take < 0) // 一旦take为负说明从起点到目前的结点需要从基地带出才够
            {
                Out += abs(take); //带出的车辆累加
                take = 0; //从基地带出车辆弥补负值的take，take置0
            }
        }
        if (take > 0) //到目的地后全部补充完毕仍有多余车辆
            Back = take; //带回
        else
            Back = 0; // take<=0说明不足或刚好够，不用带回
        if (Out < minOut) //优化Out
        {
            Path = tempPath;
            minOut = Out;
            minBack = Back;
        }
        else if (Out == minOut && Back < minBack)
        {
            Path = tempPath;
            minOut = Out;
            minBack = Back;
        }
        tempPath.pop_back();
        return;
    }
    tempPath.push_back(v);
    for (int i = 0; i < pre[v].size(); i++)
    {
        DFS(pre[v][i]);
    }
    tempPath.pop_back();
}

int main()
{
    fill(G[0], G[0] + maxn * maxn, INF); //初始所有结点之间均不可达
    scanf("%d%d%d%d", &c, &n, &ed, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &weight[i]);
    }
    weight[0] = c / 2;
    int u, v;
    for (int i = 0; i < m; i++)
    {
        scanf("%d%d", &u, &v);
        scanf("%d", &G[u][v]);
        G[v][u] = G[u][v];
    }
    Dijkstra(0);
    DFS(ed);
    printf("%d ", minOut);
    for (int i = Path.size() - 1; i >= 0; i--)
    {
        printf("%d", Path[i]);
        if (i != 0)
            printf("->");
    }
    printf(" %d\n", minBack);
    return 0;
}

跨专业数据结构初学者，疏漏在所难免，欢迎指正～