PAT 1018 Public Bike Management (Dijkstra + dfs记录多条最短路径)

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

 

题目大意

杭州市的自行车站管理系统，每个站点都有一定数量的自行车，数量处于最大值一半的状态是“perfect condition”（有车可借，有空位可还车），如果数量是0，称之为“problem condition”，需要从调度中心去运送车辆。运送路程中，如果经过自行车站点，会顺带调整该站点的状态，多的车子带走，少的顺带补齐。已知各个自行车站点的通车时间，求问最短的行车路线，如果存在多个最短路线，那么需要补送自行车最少的一个是多少。 　　

1. 找最短路径；
2. 若不唯一，找其中需要送出自行车最少的路径；
3. 若还不唯一，找其中需要回收自行车最少的路径；

解题思路

题目的本质实质上是求带权单源最短路径，可以使用Dijkstra算法，但可能存在多个最短路径，所以还要在最后的结果中使用深度优先搜索判断哪个是最符合条件的。 

坑

只能沿着最短路径的方向收集多余自行车，分给后面的节点；后面节点多出来的不能填到前面去，只能计入回收总量。

例如路径上自行车数为5->0->10，并不能把最后一个节点上挪5个给中间的，需要送出5个，并回收5个。

测试点5和7。

参考文章：

https://blog.csdn.net/zhang35/article/details/104153985

https://blog.csdn.net/CV_Jason/article/details/81385228

#include <iostream>
#include <cstdio>
#include <vector>

#define INF 1000000000

using namespace std;

int dist[510];
vector<int> pre[510];
vector<int> path, tmp;
int g[510][510]; 
int s[510];
int vis[510];
int C, N, Sp, M;
int minNeed = INF;        //需要额外带的自行车
int back = INF;          //需要带回去的自行车 

/*
10 3 3 3
5 0 10
0 1 1
1 2 1
2 3 1
*/

//先假设最短路唯一，看看能得多少分
void dijkstra (int start)
{
    for(int i = 0; i <= N; ++i)
    {
        dist[i] = INF;
        vis[i] = 0;
    }
    dist[start] = 0;
    
    while(1)
    {
        int mark = -1, minDist = INF;
        for(int i = 0; i <= N; ++i)
        {
            if(!vis[i] && dist[i] < minDist)
            {
                minDist = dist[i];
                mark = i;
            }
        }
        
        if(mark == -1)
            break;
            
        vis[mark] = 1;
        
        for(int i = 0; i <= N; ++i)
        {
            if(!vis[i])
            {
                if(dist[mark] + g[mark][i] < dist[i])
                {
                    dist[i] = dist[mark] + g[mark][i];
                    pre[i].clear();
                    pre[i].push_back(mark);    // 记录路径 
                }
                else if(dist[mark] + g[mark][i] == dist[i])
                {
                    pre[i].push_back(mark);    // 记录路径
                }    
            }
        }
    }
    
}

void dfs(int v)
{
    // 深度优先路过的顶点,存入tmp 
    tmp.push_back(v);
    // 当到达顶点0的时候，开始计算
    if(v == 0)
    {
        int perfectnum = C/2;
        int difference;
        int need = 0;        //需要带的自行车 
        int available = 0;    //可用的(多余的)自行车    
        for(int i = tmp.size()-2; i >= 0; --i)
        {
            if(s[tmp[i]] > perfectnum)     
            {
                // 有单车多余 
                difference = s[tmp[i]] - perfectnum;
                available += difference;
            }
            else if(s[tmp[i]] < perfectnum)
            {
                // 单车不够 
                difference = perfectnum - s[tmp[i]];
                if(available >= 0)
                {
                    if(available > difference)
                    {
                        // 此时need数量不变 
                        available -= difference;
                    }
                    else
                    {
                        need += difference - available; 
                        available = 0;
                    }
                    
                }
            }
        }
        
        if(need < minNeed)
        {
            minNeed = need;
            back = available;
            path = tmp;
        } else if(need == minNeed && available < back)
        {
            back = available;
            path = tmp;
        }
        
        // 顶点在dfs访问结束后弹出 
        tmp.pop_back(); 
        return;    
    }
    
    for(int i = 0; i < pre[v].size(); ++i)
        dfs(pre[v][i]);
    
    tmp.pop_back();        // 该顶点在dfs访问结束后弹出 
}

int main()
{
    scanf("%d%d%d%d", &C, &N, &Sp, &M);
    for(int i = 1; i <= N; ++i)
        scanf("%d", &s[i]);
    
    for(int i = 0; i <= N; ++i)
    {
        for(int j = 0; j <= N; ++j)
        {
            if(i == j)
                g[i][j] = 0;
            else
                g[i][j] = INF;
        }
    }
    
    int a, b, cost;
    for(int i = 0; i < M; ++i)
    {
        scanf("%d%d%d", &a, &b, &cost);
        g[a][b] = g[b][a] = cost;
    }
    
    dijkstra(0);
    dfs(Sp);
    
    printf("%d 0", minNeed);
    
    int psize = path.size();
    for(int i = psize-2; i >= 0; --i)
    {
        printf("->%d", path[i]);
    }
    
    printf(" %d", back);

    return 0;
}