Algorithm to build streets in a city with minimum cost? - c++

Question

Question details:
Rashof is the mayor of EMLand. EMLand consists of intersections and streets. There is exactly one path from each intersection to any of the other intersections. Intersections are denoted by positive intergers 1...n.
A construction company has offered Rashof to rebuild all streets of the EMLand, but Rashof can choose at most k of them to be rebuilt. The Construction company has offered a new length for each street which means after the street is rebuilt the length of the street changes.
Now Rashof as the mayor of the city must choose wisely so as to minimize sum of lengths of paths between all pairs of intersections.
Help Rashof!
Algorithm:
Notations: old edge length is L , new length is L' and set of edges E .
Count(C) number of edges(E') whose length is going to decrease i.e. L' < L
If C is less than or equal to K then
        take all edges(E') into account i.e. Update length of all such edges in E
Else
        1 . Sort all edges(E') based on (L'- L) in ascending order
        2 . Sort those edges(E'' ⊆ E') whose (L'-L) is same based on L' in descending order
        3.hoose 1st K edges(E''' ⊆ E') and update length of all such edges in E
Construct Graph G with Edge E and length L
Apply any shortest distance algorithm or DFS to find distance b/w each pair of node .
Implementation of above algorithm using priority queue and Dijkstra algorithm.
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
struct s{
int x;
int y;
int a;
int b;
int c;
};
const int MAX = 100000;
const long long INF = 100000000000000000;
vector< pii > G[MAX];
long long d[MAX];
void dijkstra(long long start) {
int u, v, i, c, w;
priority_queue< pii, vector< pii >, greater< pii > > Q;
for(i=0;i<MAX;i++){
d[i]=INF;
}
Q.push(pii(0, start));
d[start] = 0;
while(!Q.empty()) {
u = Q.top().second; // node
c = Q.top().first; // node cost so far
Q.pop(); // remove the top item.
if(d[u] < c) continue;
for(i = 0; i < G[u].size(); i++) {
v = G[u][i].first; // node
w = G[u][i].second; // edge weight
if(d[v] > d[u] + w) {
d[v] = d[u] + w;
//cout<<d[v];
Q.push(pii(d[v], v));
}
}
}
}
bool func(const s s1,const s s2) { return (s1.c < s2.c); }
bool func2(const s s1,const s s2) { return (s1.b < s2.b); }
int main() {
long long n, e, u, V, w,x,y,a,b,t,i,j,k,res,z=2;
s S;
vector<s> v;
map<pair<int,int>,int> m;
map<pair<int,int>,int>::iterator it;
cin>>t;
while(t--){
cin>>n>>k;
for(i = 1; i <= n; i++) G[i].clear();
v.clear();
m.clear();
for(i=1;i<n;i++){
cin>>x>>y>>a>>b;
if(b<a){
S.x = x;
S.y =y;
S.a=a;
S.b=b;
S.c=b-a;
v.push_back(S);
}
m[make_pair(x,y)]=a;
}
if(v.size()<=k){
for(i=0;i<v.size();i++){
m[make_pair(v[i].x,v[i].y)]=v[i].b;
}
it = m.begin();
for(;it!=m.end();++it){
u = it->first.first;
V = it->first.second;
w = it->second;
G[u].push_back(pii(V, w));
G[V].push_back(pii(u, w));
}
res = 0;
for(i=1;i<=n;i++){
dijkstra(i);
for(j= 1; j <= n; j++) {
if(i == j) continue;
if(d[j] >= INF) ;
else res+=d[j];
}
}
cout<<res/z<<"\n";
}
else{
sort(v.begin(),v.end(),func);
for(i=0;i<v.size();i++){
j = i;
while(v[i].c==v[j].c&&j<v.size())j++;
sort(v.begin()+i,v.begin()+j,func2);
i=j;
}
for(i=0;i<k;i++){
m[make_pair(v[i].x,v[i].y)]=v[i].b;
}
it = m.begin();
for(;it!=m.end();++it){
u = it->first.first;
V = it->first.second;
w = it->second;
G[u].push_back(pii(V, w));
G[V].push_back(pii(u, w));
}
res = 0;
for(i=1;i<=n;i++){
dijkstra(i);
for(j= 1; j <= n; j++) {
if(i == j) continue;
if(d[j] >= INF) ;
else res+=d[j];
}
}
cout<<res/z<<"\n";
}
}
return 0;
}
It passes only 2 test cases out of 9 test cases . Why this algorithm didn't work ?
or What are the modification should be done in this algorithm to get accepted ?
Reference:
Rashof, Mayor of EMLand

Answer 1

Traverse the tree/graph (eg nonrecursive DFS starting from any node) and count the number of times each edge is used (number of nodes on one side * number of nodes on the other side)
For each possible rebuild multiply delta by count
Sort
Profit

Answer 2

Notice that this is a tree, so, each edge connects two connected components.
Assume that we have edge connect between two connected components A and B, which contains n and m numbers of intersections, so, by decreasing the edge by x unit, we will decrease the total distance by n*m*x.
A---B---C----E
| |
| |
D---- -----F
Look at the graph above, edge between B and C connect two connected components, (A,B,D) and (C,E,F), decreasing the weight of this edge will decrease the distance between (A,B,D) and (C,E,F)
So, the algorithm is to select k edges, which has the largest n*m*x (if x is positive).