Finding minimum necessary volume of gas container - c++

Question

I found this problem somewhere in a contest and haven't been able to come up with a solution yet.
There is the N cities with coordinates (x, y). I have to go from first
city and reach the second city. There is a gas station in each city.
So I have to find minimum necessary volume of gas container to reach
the final city.
For example:
Input:
3
17 4
19 4
18 5
Output:
1.414
Here, my way is: 1->3->2
I'm using simple brute-force method, but it so slow. How can I optimize my code?
Maybe there is a better solution?
#include <iostream>
#include <algorithm>
#include <stack>
#include <math.h>
#include <cstring>
#include <iomanip>
#include <map>
#include <queue>
#include <fstream>
using namespace std;
int n, used[203];
double min_dist;
struct pc {
int x, y;
};
pc a[202];
double find_dist(pc a, pc b) {
double dist = sqrt( (a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y) );
return dist;
}
void functio(double d, int used[], int k, int step) {
used[k] = 1;
if(k == 1) {
if(d < min_dist) {
min_dist = d;
}
used[k] = 0;
return;
}
for(int i = 1; i < n; ++i) {
if(i != k && used[i] == 0) {
double temp = find_dist(a[k], a[i]);
if(temp > d) {
if(temp < min_dist)
functio(temp, used, i, step + 1);
}
else {
if(d < min_dist)
functio(d, used, i, step + 1);
}
}
}
used[k] = 0;
}
int main() {
cin >> n;
for(int i = 0; i < n; ++i)
cin >> a[i].x >> a[i].y;
min_dist = 1000000;
memset(used, 0, sizeof(used));
functio(0, used, 0, 0);
cout << fixed << setprecision(3) << min_dist << endl;
}

Answer 1

The minimum spanning tree has the neat property of encoding all of the paths between vertices that minimize the length of the longest edge on the path. For Euclidean MST, you can compute the Delaunay triangulation and then run your favorite O(m log n)-time algorithm (on a graph with m = O(n) edges) for a total running time of O(n log n). Alternatively, you could run Prim with a naive priority queue for an O(n^2)-time algorithm with a good constant (especially if you exploit SIMD).

Answer 2

So what you are trying to optimise in your algorithm is the longest distance you travel between two cities. Because that's how big your gas tank needs to be.
This is a variation on shortest path, because there you're trying to optimise the enire path length.
I think you could get away with this:
make a list of edges. (the distance between each pair of cities)
remove the longest edge from the list, unless this causes the destination to become unreachable.
once you cannot remove the longest path anymore, that means that this is your limiting factor in going to your destination. The rest of the route doesn't matter anymore.
Then in the end you should have a list of edges that make up a path between source and destination.
I haven't proven this solution to be optimal, so no guarantees. But consider this: if you remove the longest path, there are only shorter paths to take, so the maximum leg distance won't increase.
About the complexity, time complexity is O(n log n) because you have to sort the edges.
Memory complexity is O(n^2)
This is probably not the most efficient algorithm, because it is a graph-algorithm, and makes no use of the fact that the cities are on an euclidean plane. There is probably some optimisation there...

Answer 3

You can reduce time complexity to O(n^2*log(n)) using binary search which will run within the 1 second time limit. The idea behind the binary search is if we can reach city 2 from city 1 using x volume there is no need to check for higher volume container. If we cannot reach using using this then we need more than x volume. To check if we can reach city 2 using x volume you can use BFS. If two cities are within x distance of each other then its possible to move from one to the another and we can say they are connected by edge.
Code:
int vis[203];
double eps=1e-8;
struct pc {
double x, y;
};
double find_dist(pc &a, pc &b) {
double dist=sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
return dist;
}
bool can(vector<pc> &v, double x) { // can we reach 2nd city with volume x
int n=v.size();
vector<vector<int>> graph(n, vector<int>(n, 0)); // graph in adjacency matrix form
// set edges in graph
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
if(i==j) continue; //same city
double d=find_dist(v[i], v[j]);
if(d<=x) graph[i][j]=1; // can reach from city i to city j using x volume
}
}
// perform BFS
memset(vis, 0, sizeof(vis));
queue<int> q;
q.push(0); // we start from city 0 (0 absed index)
vis[0]=1;
while(!q.empty()) {
int top=q.front();
q.pop();
if(top==1) return true; // can reach city 2 (1 in 0-based index)
for(int i=0; i<n; i++) {
if(top!=i && !vis[i] && graph[top][i]==1) {
q.push(i);
vis[i]=1;
}
}
}
return false; // can't reach city 2
}
double calc(vector<pc> &v) { // calculates minimum volume using binary search
double lo=0, hi=1e18;
while(abs(hi-lo)>eps) {
double mid=(lo+hi)/2;
if(can(v, mid)) {
hi=mid; // we need at most x volume
} else{
lo=mid; // we need more than x volumer
}
}
return lo;
}