PAT1018 Public Bike Management【dfs】【最短路】

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

题意：

给定一个图，一个目的地和每个节点上的自行车数量。

现在要找到从0到目的地的一条最短路，并且对这条路径上的点的自行车数目进行调度使得每个节点的自行车数量都是某个定值。

可以从前面经过的节点搬运自行车到后面的节点，0号节点的自行车是无穷多的。

如果最短路不唯一，要求找到从0号带出的自行车数量最小的方案。

如果还是不唯一，要求找到带回0号的自行车数量最小的方案。

思路：

刚开始直接就想要同时最优化路径和调度车数量跑dijkstra了。但是这样是不对的。

应该要先完最短路，否则会出现前面的某个节点就出现了最短路相同而选择了另一条车少的但是影响了后面的最短路。

总之就是这样跑出来的最短路，并不是时间最短的。

所以我们应该要先跑最短路，然后再在几条最短路里面搜索他们各自调度自行车的数量。这里用dfs

每次搜索到了目的地就看看是不是比原答案更优。

//#include<bits/stdc++>
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<stdlib.h>
#include<queue> 
#include<map>
#include<stack>
#include<set>

#define LL long long
#define ull unsigned long long
#define inf 0x7f7f7f7f 

using namespace std;

int cmax, n, spro, m, perf;
const int maxn = 505;
vector<pair<int, int> > g[maxn];
int bike_num[maxn];

bool vis[maxn];
int d[maxn];
int cnt[maxn];
int prv[maxn];

int findmin()
{
    int mmm = inf, id = -1;
    for(int i = 0; i <= n; i++){
        if(!vis[i] && d[i] < mmm){
            mmm = d[i];
            id = i;
        }
    }
    return id;
}
void dijkstra()
{
    memset(d, 0x3f, sizeof(d));
    for(int i = 0; i < g[0].size(); i++){
        d[g[0][i].first] = g[0][i].second;
    }
    vis[0] = true;
    d[0] = 0;
    
    while(1){
//        int mmm = inf, id;
//        for(int j = 0; j <= n; j++){
//            if(d[j] < mmm && !vis[j]){
//                mmm = d[j];
//                id = j;
//            }
//        }
        int id = findmin();
        if(id == -1)break;
        vis[id] = true;
        for(int j = 0; j < g[id].size(); j++){
            int v = g[id][j].first, t = g[id][j].second;
            if(d[id] + t < d[v]){
                d[v] = d[id] + t;
            }
        }
        
    }
}

int bring, take;
int ans_bring = inf, ans_take = inf;
vector<int>path, ans_path;
void dfs(int u)
{
    if(u == spro){
        if(ans_bring > bring || ans_bring == bring && ans_take > take){
            ans_bring = bring;
            ans_take = take;
            ans_path = path;
            return;
        }
    }
    for(int i = 0; i < g[u].size(); i++){
        int v = g[u][i].first, t = g[u][i].second;
        int tmpbring = bring, tmptake = take;
        
        if(!vis[v] && t + d[u] == d[v]){
            vis[v] = true;
            path.push_back(v);
            take += bike_num[v];
            if(take < 0){
                bring -= take;
                take = 0;
            }
            dfs(v);
            vis[v] = false;
            path.pop_back();
            bring = tmpbring;
            take = tmptake;
        }
    }
}

int main()
{
    scanf("%d%d%d%d", &cmax, &n, &spro, &m);
    perf = cmax / 2;
    for(int i = 1; i <= n; i++){
        scanf("%d", &bike_num[i]);
        bike_num[i] -= perf;
    }
    for(int i = 0; i < m; i++){
        int u, v, t;
        scanf("%d%d%d", &u, &v, &t);
        g[u].push_back(make_pair(v, t));
        g[v].push_back(make_pair(u, t));
    }
    
    dijkstra();
    //cout<<d[spro]<<endl;
    memset(vis, 0, sizeof(vis));
    vis[0] = true;
    dfs(0);
    
    printf("%d 0", ans_bring);
    for(int i = 0; i < ans_path.size(); i++){
        printf("->%d", ans_path[i]);
    } 
    printf(" %d
", ans_take);
    
    return 0;    
}