A1111 Online Map

A1111 Online Map 🔥🔥🔥

💙content
https://pintia.cn/problem-sets/A1111
condition 1 : output the fastest one among the shortest paths
condition 2 : output the one that passes through the fewest intersections

🐶【Dijkstra + DFS】
🛠 skill

❗️issue

💥 error
1.wrong code for Dijkstra when finding the u and MIN
👇 is not u == j

		int u = -1 , MIN = INF;
        for(int j = 0; j != V; j++){
            if(vis[j] == false && d[j] < MIN ){
                u == j;
                MIN = d[u];
            }
        }

correct

		int u = -1 , MIN = INF;
        for(int j = 0; j != V; j++){
            if(vis[j] == false && d[j] < MIN ){
                u = j;
                MIN = d[j];
            }
        }

⭐️solution
!!!key!!!—>

💻 code

#include <bits/stdc++.h>
const int maxn = 510;
const int INF = 99999999;
using namespace std;

int N , M , st , ed;
int G[maxn][maxn] , d[maxn];
bool vis[maxn] = {false};
int timeMin = INF , depthMin = INF;
vector<int> pre[maxn];
vector<int> path , tempPath;

int T[maxn][maxn] , t[maxn];
vector<int> pre_time[maxn];
vector<int> path_time , temp_time_path;

void dij_dis(int s){
    fill(d , d + maxn , INF);
    memset(vis , false , sizeof(vis));
    d[s] = 0;
    for(int i = 0; i != N; i++){
        int u = -1 , MIN = INF;
        for(int v = 0; v != N; v++){
            if(vis[v] == false && d[v] < MIN){
                u = v;
                MIN = d[v];

            }
        }
        if(u == -1) return;
        vis[u] = true;

        for(int v = 0; v != N; v++){
            if(vis[v] == false && G[u][v] < INF){
               if(G[u][v] + d[u] < d[v]){
                    d[v] = G[u][v] + d[u];
                    pre[v].clear();
                    pre[v].push_back(u);
               }
               else if(d[u] + G[u][v] == d[v]){
                    pre[v].push_back(u);
               }
            }
        }
    }
}

void DFS_dis(int v){
    if(v == st){
        tempPath.push_back(v);
        int time = 0;
        for(int i = tempPath.size() - 1; i != 0; i--){
            int id1 = tempPath[i] , id2 = tempPath[i - 1];
            time += T[id1][id2];
        }
        if(time < timeMin){
            timeMin = time;
            path = tempPath;
        }
        tempPath.pop_back();
        return;
    }

    tempPath.push_back(v);
    for(int i = 0; i != pre[v].size(); i++){
        DFS_dis(pre[v][i]);
    }
    tempPath.pop_back();
}

void dij_time(int s){
    fill(t , t + maxn , INF);
    memset(vis , false , sizeof(vis));
    t[s] = 0;
    for(int i = 0; i != N; i++){
        int u = -1 , MIN = INF;
        for(int j = 0; j != N; j++){
            if(vis[j] ==false && t[j] < MIN){
                u = j;
                MIN = t[j];
            }
        }
        if(u == -1) return;
        vis[u] = true;

        for(int v = 0; v != N; v++){
            if(vis[v] == false && T[u][v] < INF){
                if(t[u] + T[u][v] < t[v]){
                    t[v] = T[u][v] + t[u];
                    pre_time[v].clear();
                    pre_time[v].push_back(u);
                }
                else if(t[u] + T[u][v] == t[v]){
                    pre_time[v].push_back(u);
                }
            }
        }
    }
}

void DFS_time(int v){
    if(v == st){
        temp_time_path.push_back(v);
        if(temp_time_path.size() < depthMin){
            depthMin = temp_time_path.size();
            path_time = temp_time_path;
        }
        temp_time_path.pop_back();
        return;
    }
    temp_time_path.push_back(v);
    for(int i = 0; i != pre_time[v].size(); i++){
        DFS_time(pre_time[v][i]);
    }
    temp_time_path.pop_back();
}

int main()
{
    cin >> N >> M;
    fill(G[0] , G[0] + maxn * maxn , INF);
    fill(T[0] , T[0] + maxn * maxn , INF);
    int id1 , id2 , isd , l , tt;
    for(int i = 0; i != M; i++){

        cin >> id1 >> id2 >> isd >> l >> tt;
        if(isd == 0){
            G[id1][id2] = G[id2][id1] = l;
            T[id1][id2] = T[id2][id1] = tt;
        }
        else{
            G[id1][id2] = l;
            T[id1][id2] = tt;
        }
    }
    cin >> st >> ed;
    dij_dis(st);
    DFS_dis(ed);


    dij_time(st);
    DFS_time(ed);

    if(path == path_time){
        cout << "Distance = " << d[ed] << "; ";
        cout << "Time = " << t[ed] << ": ";
        for(int i = path_time.size() - 1; i != 0; i--){
            cout << path_time[i] << " -> ";
        }
        cout << path_time[0] <<endl;
    }
    else{
        cout << "Distance = " << d[ed] << ": ";
        for(int i = path.size() - 1; i != 0; i--){
            cout << path[i] << " -> ";
        }
        cout << path[0] <<endl;
        cout << "Time = " << t[ed] << ": ";
        for(int i = path_time.size() - 1; i != 0; i--){
            cout << path_time[i] << " -> ";
        }
        cout << path_time[0] <<endl;
    }


    return 0;
}