1018 Public Bike Management

SumFunction

已于 2022-07-25 17:26:26 修改

阅读量66

点赞数

分类专栏： PAT备战文章标签：算法贪心算法深度优先

于 2022-07-25 17:22:07 首次发布

本文链接：https://blog.csdn.net/weixin_49801142/article/details/125979503

版权

PAT备战专栏收录该内容

135 篇文章 0 订阅

订阅专栏

这篇博客探讨了一种利用最短路算法和深度优先搜索解决单车在城市间调配的问题。作者首先预处理每个城市的单车需求，然后通过Dijkstra算法找到所有最短路径，并使用深搜遍历这些路径，寻找最佳的单车发放和收集策略，以确保路径上的城市都是perfect状态。过程中，博主还提到了为何选择深搜而非贪心策略的原因。

摘要由CSDN通过智能技术生成

题目描述
题目大意：沿途走过当前城市的时候，可以根据当前已经收集的单车进行发放或者索要。要保证走过的路径所有城市都为perfect 后面的城市不能给前面的城市发放，也就是后面如果多出5辆不能填给前面的
知识点：最短路，深搜（至于这个为什么不是贪心目前不晓得）
先求出所有的最短路，然后搜索所有最短路的收集或发放情况。

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int N = 510;
const int inf=1e9;
int cmax,n,sp,m;
vector<int> path,tempath;//一个保存最终的最优路径，一个保存当前搜索到的路径
vector<int> pre[N];//保存从当前节点的所有可能路径
int dist[N],v[N],g[N][N],s[N];
int min_need = inf;
int min_back = inf;
void dfs(int u){//深搜所有最短路径中的最佳方案
    tempath.push_back(u);
    if(u == 0){
        int tem_need=0,tem_back=0;
        for(int i = tempath.size()-1;i >= 0;i--){
            int uu = tempath[i];
            if(s[uu] < 0){//说明是需要单车
                if(tem_back < -s[uu]){//收集来的还不够
                    tem_need += -s[uu] - tem_back;
                    tem_back = 0;
                }else{
                    tem_back -= -s[uu];
                }
            }else{
                tem_back += s[uu];
            }
        }
        if(tem_need < min_need || (tem_need == min_need && tem_back < min_back)){
            min_need = tem_need;
            min_back = tem_back;
            path = tempath;
        }
    }
    for(int i = 0;i < pre[u].size();i++){
        dfs(pre[u][i]);
        tempath.pop_back();//搜索完该点需要恢复现场
    }
}
int main(){
    memset(g,0x3f,sizeof g);
    memset(dist,0x3f,sizeof dist);
    cin>>cmax>>n>>sp>>m;
    for(int i = 1;i <= n;i++){
        cin>>s[i];
        s[i] = s[i] - cmax/2;//先预处理该站点是要收集还是发放
    }
    for(int i = 0;i < m;i++){
        int a,b;
        cin>>a>>b>>g[a][b];
        g[b][a] = g[a][b]; 
    }
    dist[0] = 0;
    for(int i = 0;i <= n;i++){
        int t = -1;
        for(int j = 0;j <= n;j++)
            if(!v[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        v[t] = 1;
        for(int j = 0;j <= n;j++){
            if(!v[j] && dist[t] + g[j][t] <= dist[j]){
                if(dist[t] + g[j][t] == dist[j]){
                    pre[j].push_back(t);
                }else{
                    pre[j].clear();
                    pre[j].push_back(t);
                    dist[j] = dist[t] + g[j][t];
                }
            }
        }
    }
    dfs(sp);
    cout<<min_need<<" ";
    for(int i = path.size()-1;i >= 0;i--){
        if(i != 0)
            cout<<path[i]<<"->";
        else cout<<path[i];
    }
    cout<<" "<<min_back;
    return 0;
}