CCF201403 无线网络【限制型最短路】

问题描述

　　目前在一个很大的平面房间里有 n 个无线路由器,每个无线路由器都固定在某个点上。任何两个无线路由器只要距离不超过 r 就能互相建立网络连接。
　　除此以外,另有 m 个可以摆放无线路由器的位置。你可以在这些位置中选择至多 k 个增设新的路由器。
　　你的目标是使得第 1 个路由器和第 2 个路由器之间的网络连接经过尽量少的中转路由器。请问在最优方案下中转路由器的最少个数是多少?

输入格式

　　第一行包含四个正整数 n,m,k,r。(2 ≤ n ≤ 100,1 ≤ k ≤ m ≤ 100, 1 ≤ r ≤ 10⁸)。
　　接下来 n 行,每行包含两个整数 x_i 和 y_i,表示一个已经放置好的无线 路由器在 (x_i, y_i) 点处。输入数据保证第 1 和第 2 个路由器在仅有这 n 个路由器的情况下已经可以互相连接(经过一系列的中转路由器)。
　　接下来 m 行,每行包含两个整数 x_i 和 y_i,表示 (x_i, y_i) 点处可以增设 一个路由器。
　　输入中所有的坐标的绝对值不超过 10⁸,保证输入中的坐标各不相同。

输出格式

　　输出只有一个数,即在指定的位置中增设 k 个路由器后,从第 1 个路 由器到第 2 个路由器最少经过的中转路由器的个数。

样例输入

5 3 1 3
0 0
5 5
0 3
0 5
3 5
3 3
4 4
3 0

样例输出

2

题解思路：

1.首先建图，对于任意两个距离小于 r 的点连无向边。边权设为 1。当找到1与2的最短路，那么中转的点的数量就是dis[2] - 1。

2.因为是在m个点选择k个点增设。那么每次从队列中选择一个点进行松弛的时候，要判断 to 的编号是否大于 n ，以及目前已经选择了多少个点，不得超过k。

3.用vis[][]二维数组来记录状态，表示 i 点在已经选择增设了 k 个点的情况下 是否存在于队列中。

4.需要注意在比较距离是否小于r时，数据会爆int。要先转化成ll型或者直接开ll型的数组。

代码如下：

 #include<stdio.h>
 #include<string.h>
 #include<queue>
 #define mem(a, b) memset(a, b, sizeof(a))
 typedef long long ll;
 using namespace std;
 const int MAXN = ;
 const int inf = 0x3f3f3f3f;

 int n, m, k;
 ll r; //n + m个点 其中 m 个点是可选择添入的 最后可增设其中 k 个点。
 ll x[MAXN], y[MAXN];
 int head[MAXN], cnt, vis[MAXN][], dis[MAXN];

 struct Edge
 {
     int to, next, w;
 }edge[MAXN * (MAXN - )];

 struct Node
 {
     int pot, num;
 }node;

 void add(int a, int b, int c)
 {
     cnt ++;
     edge[cnt].to = b;
     edge[cnt].w = c;
     edge[cnt].next = head[a];
     head[a] = cnt;
 }

 void spfa()
 {
     queue<Node> Q;
     node.pot = , node.num = ;
     dis[] = ;
     vis[][] = ;
     Q.push(node);
     while(!Q.empty())
     {
         Node a = Q.front();
         Q.pop();
         vis[a.pot][a.num] = ;
         for(int i = head[a.pot]; i != -; i = edge[i].next)
         {
             int to = edge[i].to;
             int p = a.num;
             if(to > n)
                 p ++;
             if(dis[to] > dis[a.pot] + edge[i].w && p <= k)
             {
                 dis[to] = dis[a.pot] + edge[i].w;
                 if(!vis[to][p])
                 {
                     vis[to][p] = ;
                     node.pot = to, node.num = p;
                     Q.push(node);
                 }
             }
         }
     }
 }

 int main()
 {
     mem(head, -), cnt = ;
     mem(vis, ), mem(dis, inf);
     scanf("%d%d%d%lld", &n, &m, &k, &r);
     for(int i = ; i <= n + m; i ++)
         scanf("%lld%lld", &x[i], &y[i]);
     for(int i = ; i < n + m; i ++)
     {
         for(int j = i + ; j <= n + m; j ++)
         {
             if((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) <= r * r)
             {
                 add(i, j, );
                 add(j, i, );
             }
         }
     }
     spfa();
     printf("%d\n", dis[] - );
     return ;
 }

 /*
 测试数据：
 5 3 1 3
 0 0
 5 5
 0 3
 0 5
 3 5
 3 3
 4 4
 3 0
 2

 10 1 1 2
 0 0
 3 1
 -2 0
 -2 2
 -2 4
 -2 6
 0 6
 2 6
 2 4
 2 2
 2 0
 1

 10 1 1 2
 0 0
 3 1
 -2 0
 -2 2
 -2 4
 -2 6
 0 6
 2 6
 2 4
 2 2
 3 0
 8

 6 3 2 50000000
 0 0
 50000000 100000000
 100000000 100000000
 100000000 0
 100000000 50000000
 50000000 0
 -100000000 50000000
 0 50000000
 0 100000000
 2
 */