PAT (Advanced Level) 1018 Public Bike Management (30 分)

序：
一道dijkstra + dfs，边权 + 点权，反向dfs，最短路径记录pre，两个二级变量minneed、minback，比较复杂

题目概述：
给定边权和点权，求已知起点终点的最短距离；若相同，为了满足每个途径的节点都满足cmax/2的单车数，取最少的携带单车量；若还是相同，再取最少的带回单车量。

分析：
1.变量准备：
inf，边权，dis，点权，visit，pre，temppath，path，minneed，minback，camx，n，sp，m；
2.初始化fill：
注意对2维的fill必须是以下格式：

fill(e[0], e[0] + 510 * 510, inf);

千万不要少了[0]！

3.处理输入
4.dijkstra
dis初值
遍历n+1次：
选dis最小且未visit
标记true
再次遍历n+1次：
找出未visit的且uv联通的，进行更新pre和dis
5.dfs（记得回溯）
插入新的v
若v为0：判断need和back，及时更新，回溯
根据pre进行dfs
回溯

6.输出

//最短路径dijkstra
//最少分配dfs
//inf设置，边权，距离dis，点权，visit
//pre记录最短路径的前一个端点，方便输出
//temppath 和 path
//dfs：先push，后反向判断是否为0，若否，则继续dfs+pre，最后都要pop
//dijkstra：更新pre和dis

#include<bits/stdc++.h>
using namespace std;

const int inf = 999999;
int e[510][510], dis[510], weight[510];//weight减去cmax / 2，正数表示多余，负数表示亏损
bool visit[510];
vector<int> pre[510], temppath, path;//pre记录最短路径的前一个节点
int minneed = inf, minback = inf;
int cmax, n, sp, m;

void dfs(int v)
{
    temppath.push_back(v);
    //如果反向dfs到达起点,已经保证是最短路径
    if(v == 0)
    {
        int need = 0, back = 0;
        //从起点开始遍历
        for(int i = temppath.size() - 1; i >= 0; i--)
        {   
            int id = temppath[i];//注意是temppath对应的序号
            if(weight[id] >= 0)
            {
                back += weight[id];
            }
            else
            {
                //如果back足够抵消亏损
                if(back >= -weight[id])
                    back += weight[id];
                else
                {
                    need += -weight[id] - back;
                    back = 0;
                }
            }
        }
        //与min比较
        if(need < minneed)
        {
            minneed = need;
            minback = back;
            path = temppath;
        }
        else if(need == minneed && back < minback)
        {
            minback = back;
            path = temppath;
        }
        //回溯
        temppath.pop_back();
        return;
    }
    //正常遍历
    for(int i = 0; i < pre[v].size(); i++)
        dfs(pre[v][i]);
    //回溯
    temppath.pop_back();
    return;
}

int main()
{
    //首先初始化e和dis
    fill(e[0], e[0] + 510 * 510, inf);
    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]);
        weight[i] -= cmax / 2;
    }
    for(int i = 0; i < m; i++)
    {
        int a, b, c;
        scanf("%d %d %d", &a, &b, &c);
        e[a][b] = e[b][a] = c;
    }
    
    //dijkstra
    dis[0] = 0;//0作为起点
    //负责生成pre
    for(int i = 0; i <= n; i++)
    {
        int u = -1, minn = inf;
        //找出未visit中的dis最小的
        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;//标记已参观
        
        for(int v = 0; v <= n; v++)
        {
            if(visit[v] == false && e[u][v] != inf)
            {
                if(dis[u] + e[u][v] < dis[v])
                {
                    dis[v] = dis[u] + e[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if(dis[u] + e[u][v] == dis[v])
                {
                    pre[v].push_back(u);
                }
            }
        }
    }
    
    dfs(sp);
    
    printf("%d ", minneed);
    for(int i = path.size() - 1; i >= 0 ; i--)
    {
        if(i != 0) printf("%d->", path[i]);
        else printf("%d ", path[i]);
    }
    printf("%d\n", minback);
    return 0;
}

总结：
经典dfs+dijkstra：
dfs步骤：加入新节点，判断，遍历，回溯
dijkstra步骤：起点设置，找dis最小，记录true，遍历未访问的可联通节点并更新

fill注意：2维的fill记得用e【0】！！！2维的fill记得用e【0】！！！2维的fill记得用e【0】！！！（之前已经卡过一次了）