vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges)
{
vector<vector<int>> adjacency_list(n);
vector<summary> summaries(n);
for (size_t e = 0; e < edges.size(); e++)
{
adjacency_list[edges[e].first].push_back(edges[e].second);
adjacency_list[edges[e].second].push_back(edges[e].first);
}
first_pass(-1, 0, adjacency_list, summaries);
second_pass(-1, 0, 0, adjacency_list, summaries);
vector<int> result;
int min_max = 100000;
for (int i = 0; i < n; i++)
{
min_max = min(min_max, summaries[i].get_max());
}
for (int i = 0; i < n; i++)
{
if (summaries[i].get_max() == min_max)
{
result.push_back(i);
}
}
return result;
}
int main() {
h_dijkstra dijk;
size_t n = 100000;
size_t max_edges = 100;
size_t max_weight = 100;
h_dijkstra::adjacency_list_t adjacency_list(n);
srand (time(NULL));
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < ((rand() % max_edges) + 1); j++) {
adjacency_list[i].push_back(h_dijkstra::neighbor(rand() % (n), rand() % max_weight));
}
}
std::vector<h_dijkstra::weight_t> min_distance;
std::vector<h_dijkstra::vertex_t> previous;
dijk.sssp(0, adjacency_list, min_distance, previous);
std::cout << "Distance from 0 to 4: " << min_distance[4] << std::endl;
//std::list<vertex_t> path = DijkstraGetShortestPathTo(4, previous);
//std::cout << "Path : ";
//std::copy(path.begin(), path.end(), std::ostream_iterator<vertex_t>(std::cout, " "));
//std::cout << std::endl;
return 0;
};
/**
* @brief Return adjacency list for Dijkstra algo
*/
adjacency_list_t Labyrinth::getAdjacencyList()
{
adjacency_list_t adjacency_list(static_cast<int> (this->getNbCells()));
this->generateGraph(adjacency_list, 0, -1);
return adjacency_list;
}
vector<vertex_t> ShortestPath::dijkstra(string filename, vertex_t source_out, vertex_t dest_out)
{
// remember to insert edges both ways for an undirected graph
adjacency_list_t adjacency_list(REFERENCE_POINT_NUMBER);
readFile(filename.c_str(), adjacency_list);
int SOURCE_REVERSE, SOURCE = source_out;
int DEST_REVERSE, DEST = dest_out;
SOURCE_REVERSE = DEST;
DEST_REVERSE = SOURCE;
vector<weight_t> min_distance;
vector<vertex_t> previous;
vector<weight_t> min_distance_reverse;
vector<vertex_t> previous_reverse;
int dist;
vector<vertex_t> realpath;
DijkstraComputePaths(SOURCE, adjacency_list, min_distance, previous);
DijkstraComputePaths(SOURCE_REVERSE, adjacency_list, min_distance_reverse, previous_reverse);
cout << "min :" << min_distance[DEST] << endl;
cout << "min_reverse : " << min_distance_reverse[DEST_REVERSE] << endl;
vector<vertex_t> path;
if(min_distance[DEST] > min_distance_reverse[DEST_REVERSE])
{
dist = min_distance_reverse[DEST_REVERSE];
path = DijkstraGetShortestPathTo(DEST_REVERSE, previous_reverse);
}
else
{
dist = min_distance[DEST];
path = DijkstraGetShortestPathTo(DEST, previous);
for (int i = 0; i < path.size()/2; ++i)
{
vertex_t temp = path[i];
path[i] = path[path.size() - 1 - i];
path[path.size() - 1 - i] = temp;
}
}
cout << "Distance : " << dist << endl;
//printPath(path);
return path;
}
void create_vertex_face_lookup(const mesh::indices_t& FaceFirstLoops, const mesh::indices_t& FaceLoopCounts, const mesh::indices_t& LoopFirstEdges, const mesh::indices_t& EdgePoints, const mesh::indices_t& ClockwiseEdges, const mesh::points_t& Points, mesh::indices_t& PointFirstFaces, mesh::counts_t& PointFaceCounts, mesh::indices_t& PointFaces)
{
std::vector<std::vector<size_t> > adjacency_list(Points.size());
const size_t face_begin = 0;
const size_t face_end = face_begin + FaceFirstLoops.size();
for(size_t face = face_begin; face != face_end; ++face)
{
const size_t loop_begin = FaceFirstLoops[face];
const size_t loop_end = loop_begin + FaceLoopCounts[face];
for(size_t loop = loop_begin; loop != loop_end; ++loop)
{
const size_t first_edge = LoopFirstEdges[loop];
for(size_t edge = first_edge; ;)
{
adjacency_list[EdgePoints[edge]].push_back(face);
edge = ClockwiseEdges[edge];
if(edge == first_edge)
break;
}
}
}
PointFirstFaces.assign(Points.size(), 0);
PointFaceCounts.assign(Points.size(), 0);
PointFaces.clear();
const size_t point_begin = 0;
const size_t point_end = point_begin + Points.size();
for(size_t point = point_begin; point != point_end; ++point)
{
PointFirstFaces[point] = PointFaces.size();
PointFaceCounts[point] = adjacency_list[point].size();
PointFaces.insert(PointFaces.end(), adjacency_list[point].begin(), adjacency_list[point].end());
}
}
/// Convenience function for reconstructing grains and calcuating averages, adjacencies
int Dataset::calculate_grain_info(){
reconstruct_grains();
average_orientations();
adjacency_list();
return 1;
}
adjacency_list_t make_graph(Landscape landscape)
{
int cnt = 0;
adjacency_list_t adjacency_list(landscape.width*landscape.height);
for(int i = 0; i < landscape.height; i++)
{
for(int j = 0; j < landscape.width; j++)
{
if (landscape.getTile(j, i).walkSpeed() == 0) {
cnt++;
continue;
}
if(i == 0)
{
/////////////////////////////////
for(int i1 = 0; i1 < 2; i1++)
{
for(int j1 = -1; j1 < 2; j1++)
{
if( (j == 0 && j1 == -1) || (j == landscape.width-1 && j1 == 1) )
{
continue;
}
double weight = 1;
if (isDiagonal(i1, j1)) {
weight = 1./sqrt(2.);
}
if( !( (i1 == 0) && (j1 == 0) ) )
{
if (landscape.getTile(j+j1, i+i1).walkSpeed() != 0) {
adjacency_list[cnt].push_back(neighbor(cnt + j1 + landscape.width*i1, weight));
}
}
}
}
//////////////////////////////////
}
else if(i == landscape.height - 1)
{
/////////////////////////////////
for(int i1 = -1; i1 < 1; i1++)
{
for(int j1 = -1; j1 < 2; j1++)
{
double weight = 1;
if (isDiagonal(i1, j1)) {
weight = 1./sqrt(2.);
}
if( (j == 0 && j1 == -1) || (j == landscape.width-1 && j1 == 1) )
{
continue;
}
if( !( (i1 == 0) && (j1 == 0) ) )
{
if ( landscape.getTile(j+j1, i+i1).walkSpeed() != 0 )
{
adjacency_list[cnt].push_back(neighbor(cnt + j1 + landscape.width*i1, weight));
}
}
}
}
//////////////////////////////////
}
else
{
/////////////////////////////////
for(int i1 = -1; i1 < 2; i1++)
{
for(int j1 = -1; j1 < 2; j1++)
{
double weight = 1;
if (isDiagonal(i1, j1)) {
weight = 1./sqrt(2.);
}
if( (j == 0 && j1 == -1) || (j == landscape.width-1 && j1 == 1) )
{
continue;
}
if( !( (i1 == 0) && (j1 == 0) ) )
{
if ( landscape.getTile(j+j1, i+i1).walkSpeed() != 0)
{
adjacency_list[cnt].push_back(neighbor(cnt + j1 + landscape.width*i1, weight));
}
}
}
}
//////////////////////////////////
}
cnt++;
}
}
//print_neighbour(adjacency_list, cnt);
return adjacency_list;
}
