PAT (Advanced Level) Practice A1018 Public Bike Management （30 分）(C++)（甲级）(无向图、Dijkstra、DFS)

原题链接：A1018 Public Bike Management

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
#include <ctime>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
using namespace std;

const int MAX = 510, INF = 1<<30;
typedef struct Node
{
    int v, d;//v是连接的站点，D为花费的时间
    Node(int _v, int _d) : v(_v), d(_d) {}
} Node;
int Cmax, N, Sp, M;
vector<Node> G[MAX];//用图来存贮两站点间的距离（花费的时间）
int weight[MAX] = {0};//每个站点目前所拥有的车辆数目
int d[MAX];//最小距离
bool visited[MAX] = {0};
vector<int> pre[MAX];//前驱

void Dijkstra(int s)//Dijkstra求解单元最短路径
{
    fill(d, d+MAX, INF);
    d[s] = 0;
    for(int i=0; i<=N; i++)
    {
        int MIN = INF, u = -1;
        for(int v=0; v<=N; v++)
        {
            if(!visited[v] && d[v] < MIN)
            {
                MIN = d[v], u = v;
            }
        }
        if(u == -1) return ;
        visited[u] = 1;
        for(int j=0; j<(int)G[u].size(); j++)
        {
            int v = G[u][j].v, dis = G[u][j].d;
            if(!visited[v])
            {
                if(d[u] + dis < d[v])
                {
                    d[v] = d[u] + dis;
                    pre[v].clear();//有更短路径则之前存储的前驱需清零
                    pre[v].push_back(u);
                }
                else if(d[u] + dis == d[v])
                {
                    pre[v].push_back(u);
                }
            }
        }
    }
}

int send = INF, fetch = 0;
vector<int> path, temp_path;
void DFS(int s)
{
    if(s == 0)
    {
        temp_path.push_back(s);
        int temp_send = 0, temp_fetch = 0;
        for(int i=(int)temp_path.size()-2; i>=0; i--)//此处需要倒序
        {
            if(temp_fetch + weight[temp_path[i]] - Cmax/2 > 0)//从别的站点拿出来的足够补齐则直接补上
            {
                temp_fetch += weight[temp_path[i]] - Cmax/2;
            }
            else//不够则需要从PBMC带出来
            {
                temp_send -= temp_fetch + weight[temp_path[i]] - Cmax/2;
                temp_fetch = 0;
            }
        }
        if(temp_send < send)//更新最优值
        {
            send = temp_send;
            fetch = temp_fetch;
            path = temp_path;
        }
        else if(temp_send == send && temp_fetch < fetch)
        {
            fetch = temp_fetch;
            path = temp_path;
        }
        temp_path.pop_back();
        return ;
    }
    temp_path.push_back(s);
    for(int i=0; i<(int)pre[s].size(); i++)
    {
        DFS(pre[s][i]);
    }
    temp_path.pop_back();
}

int main()
{
    int Si, Sj, Tij;
    scanf("%d %d %d %d", &Cmax, &N, &Sp, &M);
    for(int i=1; i<=N; i++) scanf("%d", &weight[i]);
    for(int i=0; i<M; i++)
    {
        scanf("%d %d %d", &Si, &Sj, &Tij);
        G[Si].push_back(Node(Sj, Tij));
        G[Sj].push_back(Node(Si, Tij));
    }
    Dijkstra(0);//使用Dijkstra算法找出最短路径信息，存储于pre中
    DFS(Sp);//DFS遍历所有最短路径，找出带出去的最少，取回来最少的那条
    printf("%d 0", send);//打印
    for(int i=(int)path.size()-2; i>=0; i--)
    {
        printf("->%d", path[i]);
    }
    printf(" %d", fetch);
    return 0;
}