CODEWITHSUNDEEP
c++dijkstra
user2394968
user2394968

Reputation: 33

Trouble with Dijkstra , finding all minimum paths

We have a problem here, we're trying to find all the shortest paths in graph from one node to another. We have already implemented dijkstra but we really dont know how to find them all.

Do we have to use BFS?

#include <vector>
#include <iostream>
#include <queue>
using namespace std;

typedef pair <int, int> dist_node;
typedef pair <int, int> edge;
const int MAXN = 10000;
const int INF = 1 << 30;
vector <edge> g[MAXN];
int d[MAXN];
int p[MAXN];

int dijkstra(int s, int n,int t){
    for (int i = 0; i <= n; ++i){
        d[i] = INF;  p[i] = -1;
    }
    priority_queue < dist_node, vector <dist_node>,greater<dist_node> > q;
    d[s] = 0;
    q.push(dist_node(0, s));
    while (!q.empty()){
        int dist = q.top().first;
        int cur = q.top().second;
        q.pop();
        if (dist > d[cur]) continue;
        for (int i = 0; i < g[cur].size(); ++i){
            int next = g[cur][i].first;
            int w_extra = g[cur][i].second;
            if (d[cur] + w_extra < d[next]){
                d[next] = d[cur] + w_extra;
                p[next] = cur;
                q.push(dist_node(d[next], next));
            }
        }
    }
    return d[t];
}

vector <int> findpath (int t){
    vector <int> path;
    int cur=t;
    while(cur != -1){
        path.push_back(cur);
        cur = p[cur];
    }
    reverse(path.begin(), path.end());
    return path;
}

This is our code, we believe we have to modify it but we really don't know where.

Upvotes: 3

Views: 503

Answers (1)

i Code 4 Food
i Code 4 Food

Reputation: 2154

Currently, you are only saving/retrieving one of the shortest paths that you happen to find. Consider this example:

4 nodes
0 -> 1
0 -> 2
1 -> 3
2 -> 3

It becomes clear that you cannot have a single p[] value for each position, as in fact the 4th node (3) has 2 previous valid nodes: 1 and 2.

You could thus replace it with a vector<int> p[MAXN]; and work as follows:

if (d[cur] + w_extra < d[next]){
    d[next] = d[cur] + w_extra;
    p[next].clear();
    p[next].push_back(cur);
    q.push(dist_node(d[next], next));
}
else if(d[cur] + w_extra == d[next]){
    p[next].push_back(cur); // a new shortest way of hitting this same node
}

You will also need to update your findpath() function as it will need to deal with "branches" resulting in several multiple paths, possibly an exponentially huge amount of paths depending on the graph. If you just need to print the paths, you could do something like this:

int answer[MAXN];

void findpath (int t, int depth){
    if(t == -1){ // we reached the initial node of one shortest path
        for(int i = depth-1; i >= 0; --i){
            printf("%d ", answer[i]);
        }
        printf("%d\n", last_node); // the target end node of the search
        return;
    }
    for(int i = p[t].size()-1; i >= 0; --i){
        answer[depth] = p[t][i];
        findpath(p[t][i], depth+1);
    }
}

Note you'll need to do p[s].push_back(-1) at the beginning of your dijkstra, besides clearing this vector array between cases.

Upvotes: 1

Related Questions