void addEdge(vertex_t src, vertex_t dst, weight_t weight) {
if (max(src,dst) >= l.size()) {
l.resize(max(src, dst) + 1);
}
l[src].push_back(edge(dst, weight));
}
void DijkstraComputePaths(vertex_t source,
const adjacency_list_t &adjacency_list,
vector<weight_t> &min_distance,
vector<vertex_t> &previous)
{
int n = adjacency_list.size();
min_distance.clear();
min_distance.resize(n, max_weight);
min_distance[source] = 0;
previous.clear();
previous.resize(n, -1);
set<pair<weight_t, vertex_t> > vertex_queue;
vertex_queue.insert(make_pair(min_distance[source], source));
while (!vertex_queue.empty())
{
weight_t dist = vertex_queue.begin()->first;
vertex_t u = vertex_queue.begin()->second;
vertex_queue.erase(vertex_queue.begin());
// Visit each edge exiting u
const vector<neighbor> &neighbors = adjacency_list[u];
for (vector<neighbor>::const_iterator it = neighbors.begin(); it != neighbors.end(); it++)
{
vertex_t v = it->target;
weight_t weight = it->weight;
weight_t distance_through_u = dist + weight;
if (distance_through_u < min_distance[v])
{
vertex_queue.erase(make_pair(min_distance[v], v));
min_distance[v] = distance_through_u;
previous[v] = u;
vertex_queue.insert(make_pair(min_distance[v], v));
}
}
}
}
bool isReachable(vertex_t u, vertex_t v) {
stack<edge> q;
q.push(edge(u, 1));
vector<bool> visited(l.size(), false);
if (u == v) {
return true;
}
while (!q.empty()) {
edge curr = q.top();
q.pop();
if (visited[curr.target]) {
continue;
}
else {
visited[curr.target] = true;
}
if (curr.target == v) {
return true;
}
for (auto v = l[curr.target].begin(); v != l[curr.target].end(); v++) {
q.push(edge(v->target, v->target));
}
}
return false;
}
//Shortest length from source to all other vertices
//Output in vector min_distance
void Map::DijkstraComputePaths(int source,
const adjacency_list_t &adjacency_list,
std::vector<double> &min_distance,
std::vector<int> &previous)
{
int n = adjacency_list.size();
min_distance.clear();
min_distance.resize(n, max_weight);
min_distance[source] = 0;
previous.clear();
previous.resize(n, -1);
std::set<std::pair<double, int> > vertex_queue;
vertex_queue.insert(std::make_pair(min_distance[source], source));
while (!vertex_queue.empty())
{
double dist = vertex_queue.begin()->first;
int u = vertex_queue.begin()->second;
vertex_queue.erase(vertex_queue.begin());
// Visit each edge exiting u
const std::vector<neighbor> &neighbors = adjacency_list[u];
for (std::vector<neighbor>::const_iterator neighbor_iter = neighbors.begin();
neighbor_iter != neighbors.end();
neighbor_iter++)
{
int v = neighbor_iter->target;
double weight = neighbor_iter->weight;
double distance_through_u = dist + weight;
if (distance_through_u < min_distance[v]) {
vertex_queue.erase(std::make_pair(min_distance[v], v));
min_distance[v] = distance_through_u;
previous[v] = u;
vertex_queue.insert(std::make_pair(min_distance[v], v));
}
}
}
}
void DijkstraComputePaths(vertex_t source,
const adjacency_list_t &adjacency_list,
std::vector<weight_t> &min_distance,
std::vector<vertex_t> &previous)
{
int n = adjacency_list.size();
min_distance.clear();
min_distance.resize(n, max_weight);
min_distance[source] = 0;
previous.clear();
previous.resize(n, -1);
std::set<std::pair<weight_t, vertex_t> > vertex_queue;
vertex_queue.insert(std::make_pair(min_distance[source], source));
while (!vertex_queue.empty())
{
weight_t dist = vertex_queue.begin()->first;
vertex_t u = vertex_queue.begin()->second;
vertex_queue.erase(vertex_queue.begin());
// Visit each edge exiting u
const std::vector
void DFS(vertex_t start) {
stack<edge> q;
q.push(edge(start, 1));
vector<bool> visited(l.size(), false);
while (!q.empty()) {
edge curr = q.top();
q.pop();
if (visited[curr.target]) {
continue;
}
else {
visited[curr.target] = true;
}
cout << curr.target << endl;
for (auto v = l[curr.target].begin(); v != l[curr.target].end(); v++) {
q.push(edge(v->target, v->target));
}
}
}
