UVa 10278 – Fire Station

0

Solution Idea:

In this problem the most challenging part is determine how the input is given.
Here for each test case number of edge in the graph is not fixed. You need to take input till end of file. For this strignstream class is used.

And the algorithmic idea is similar like complete search. Place an additional fire station on every intersection which do not contain any fire station already. and run dijkstra for this graph. every time you place a new fire station on an intersection you have to run a dijkstra taking that node as source and also the existing fire stations by input as source. just print the minimum intersection number which minimize the maximum distance.

```
#include &lt;bits/stdc++.h&gt;

#define pii              pair &lt;int,int&gt;
#define pll              pair &lt;long long,long long&gt;
#define sc               scanf
#define pf               printf
#define Pi               2*acos(0.0)
#define ms(a,b)          memset(a, b, sizeof(a))
#define pb(a)            push_back(a)
#define MP               make_pair
#define db               double
#define ll               long long
#define EPS              10E-10
#define ff               first
#define ss               second
#define sqr(x)           (x)*(x)
#define D(x)             cout&lt;&lt;#x &quot; = &quot;&lt;&lt;(x)&lt;&lt;endl
#define VI               vector &lt;int&gt;
#define DBG              pf(&quot;Hi\n&quot;)
#define MOD              1000000007
#define CIN              ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define SZ(a)            (int)a.size()
#define sf(a)            scanf(&quot;%d&quot;,&amp;a)
#define sfl(a)           scanf(&quot;%lld&quot;,&amp;a)
#define sff(a,b)         scanf(&quot;%d %d&quot;,&amp;a,&amp;b)
#define sffl(a,b)        scanf(&quot;%lld %lld&quot;,&amp;a,&amp;b)
#define sfff(a,b,c)      scanf(&quot;%d %d %d&quot;,&amp;a,&amp;b,&amp;c)
#define sfffl(a,b,c)     scanf(&quot;%lld %lld %lld&quot;,&amp;a,&amp;b,&amp;c)
#define stlloop(v)       for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define loop(i,n)        for(int i=0;i&lt;n;i++)
#define loop1(i,n)       for(int i=1;i&lt;=n;i++)
#define REP(i,a,b)       for(int i=a;i&lt;b;i++)
#define RREP(i,a,b)      for(int i=a;i&gt;=b;i--)
#define TEST_CASE(t)     for(int z=1;z&lt;=t;z++)
#define PRINT_CASE       printf(&quot;Case %d: &quot;,z)
#define CASE_PRINT       cout&lt;&lt;&quot;Case &quot;&lt;&lt;z&lt;&lt;&quot;: &quot;
#define all(a)           a.begin(),a.end()
#define intlim           2147483648
#define infinity         (1&lt;&lt;28)
#define ull              unsigned long long
#define gcd(a, b)        __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b)))

using namespace std;

/*----------------------Graph Moves----------------*/
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
//const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
//const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

//int Set(int N,int pos){return N=N | (1&lt;&lt;pos);}
//int reset(int N,int pos){return N= N &amp; ~(1&lt;&lt;pos);}
//bool check(int N,int pos){return (bool)(N &amp; (1&lt;&lt;pos));}
/*------------------------------------------------*/

struct data
{
int u,cost;
data(int a,int b)
{
u=a,cost=b;
}
bool operator &lt; (const data &amp;p) const
{
return cost&gt;p.cost;
}
};

vector&lt;int&gt;graph[600],cost[600];
ll dis[600];
bool vis[600];
set&lt;int&gt;st;
int f,k;

void all_clear(int n)
{
for(int i=0;i&lt;=550;i++)
{
graph[i].clear();
cost[i].clear();
dis[i]=(1&lt;&lt;28);
vis[i]=0;
}
st.clear();
}

ll dijkastra(int src)
{
for(int i=0;i&lt;600;i++) dis[i]=(1&lt;&lt;28);

priority_queue&lt;data&gt;Q;

stlloop(st)
{
dis[*it]=0;
Q.push(data(*it,0));
}
Q.push(data(src,0));
dis[src]=0;
ll ret=0;

while(!Q.empty())
{
data u=Q.top();
Q.pop();
for(int i=0;i&lt;SZ(graph[u.u]);i++)
{
int v=graph[u.u][i];
if(u.cost+cost[u.u][i]&lt;dis[v])
{
dis[v]=u.cost+cost[u.u][i];
Q.push(data(v,dis[v]));
}

}
}

for(int i=1;i&lt;=k;i++)
ret=max(ret,dis[i]);
return ret;
}

int main()
{

//    freopen(&quot;in.txt&quot;,&quot;r&quot;,stdin);
//    freopen(&quot;out.txt&quot;,&quot;w&quot;,stdout);
//    CIN;
int t;
cin&gt;&gt;t;
TEST_CASE(t)
{
//        vector&lt;int&gt;source;
cin&gt;&gt;f&gt;&gt;k;

all_clear(k);
st.clear();

for(int i=0;i&lt;f;i++)
{
int a;
cin&gt;&gt;a;
dis[a]=0;
st.insert(a);
vis[a]=1;
}

string str;
getline(cin,str);

while(1)
{
getline(cin,str);
stringstream ss(str);
if(str.empty()) break;
int a,b,c;
ss&gt;&gt;a&gt;&gt;b&gt;&gt;c;
graph[a].pb(b);
graph[b].pb(a);
cost[a].pb(c);
cost[b].pb(c);
}

int ans=1,maxi=100000000;
for(int i=1;i&lt;=k;i++)
{
if(vis[i]==0)
{
ll temp=dijkastra(i);
if(temp&lt;maxi)
{
maxi=temp;
ans=i;
}
}
}

cout&lt;&lt;ans&lt;&lt;endl;
if(z!=t)
cout&lt;&lt;endl;
}

return 0;
}

```