CCF201403-4 无线网络（100分)

试题编号：	201403-4
试题名称：	无线网络
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述 　　目前在一个很大的平面房间里有 n 个无线路由器,每个无线路由器都固定在某个点上。任何两个无线路由器只要距离不超过 r 就能互相建立网络连接。 　　除此以外,另有 m 个可以摆放无线路由器的位置。你可以在这些位置中选择至多 k 个增设新的路由器。 　　你的目标是使得第 1 个路由器和第 2 个路由器之间的网络连接经过尽量少的中转路由器。请问在最优方案下中转路由器的最少个数是多少? 输入格式 　　第一行包含四个正整数 n,m,k,r。(2 ≤ n ≤ 100,1 ≤ k ≤ m ≤ 100, 1 ≤ r ≤ 10 8)。 　　接下来 n 行,每行包含两个整数 x i 和 y i,表示一个已经放置好的无线 路由器在 (x i, y i) 点处。输入数据保证第 1 和第 2 个路由器在仅有这 n 个路由器的情况下已经可以互相连接(经过一系列的中转路由器)。 　　接下来 m 行,每行包含两个整数 x i 和 y i,表示 (x i, y i) 点处可以增设 一个路由器。 　　输入中所有的坐标的绝对值不超过 10 8,保证输入中的坐标各不相同。 输出格式 　　输出只有一个数,即在指定的位置中增设 k 个路由器后,从第 1 个路 由器到第 2 个路由器最少经过的中转路由器的个数。 样例输入 5 3 1 3 0 0 5 5 0 3 0 5 3 5 3 3 4 4 3 0 样例输出 2

问题链接：CCF201403试题。

问题描述：（参见上文）。

问题分析：这是一个求最优问题，通常用BFS（广度优先搜索）来实现。据称，该问题还可以用SPFA算法来实现。

程序说明：数组visit[][]用于标记路径上访问过的点。

#include <iostream>
#include <queue> 

using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
const int N = 1000;
struct {
	long long x;
	long long y;	
}input[200];//输入 

struct node{
	long long x;
	long long y;
	int step;//路径长度 
	int kCount;//路径上新增节点个数 
	int pathNum;//路径编号 
}; 
int num = 0;
bool  visit[N][200];//记录每一条路径上节点是否被访问 
//广度优先算法
int bfs(int n,int m,int k,int begin,int end,long long r){
	int max;
   /* for(int i=0;i<N;i++){//初始化二维数组visit 
		for(int j=0;j<200;j++){
			visit[i][j] = false;
		} 
	}*/
    node start,front;
	start.x = input[begin].x;
	start.y = input[begin].y;
	start.step = 0;
	start.kCount = 0;
	start.pathNum = num++;
	visit[start.pathNum][begin] = true;//标记start.pathNUm 这条路径上的节点 begin被访问； 
	queue<node> q;
	q.push(start); 
	
	while(!q.empty()){
		front = q.front();
		q.pop();
		//到达终点 return 
		if(front.x == input[end].x && front.y == input[end].y){
			//cout<<"========"<<front.pathNum<<"========";
			return front.step - 1;
		}
		//搜索可以连接的路由器 
		if(front.kCount == k){
			max = n;
		} else{
			max = n + m;
		}
		for(int i=0;i<max;i++){
			node v;
			//如果被访问过 则跳过 
			if(visit[front.pathNum][i]==true){
				continue;
			} 
			//如果不符合 r 条件 则跳过 
			if((front.x - input[i].x) * (front.x - input[i].x) + (front.y - input[i].y) * (front.y - input[i].y) > r*r){
				
				continue;		
			}
			v.x = input[i].x;
			v.y = input[i].y;
			v.step = front.step + 1;
			if(i>=n){
				v.kCount = front.kCount + 1;
				
			}else{
				
				v.kCount = front.kCount;
			}
			v.pathNum = num++;
			if(num >= N){
				num = 0;
			}
			//标志维护 
			for(int j=0;j<n+k;j++){
				visit[v.pathNum][j] = visit[front.pathNum][j]; 
			}
			visit[v.pathNum][i] = true;
			
			q.push(v);
				
		}	
	}
	return 0;
} 



int main() {
	int n,m,k;
	long long r;
	cin>>n>>m>>k>>r;
	for(int i=0;i<n+m;i++){	
		cin>>input[i].x>>input[i].y;
	}
    
	int ans = bfs(n,m,k,0,1,r);
	cout<<ans;
	return 0;
}

1. 测试数据：  
2. 5 3 1 3 
3. 0 0 
4. 5 5 
5. 0 3 
6. 0 5 
7. 3 5 
8. 3 3 
9. 4 4 
10. 3 0 
11. 2 
12.  
13. 10 1 1 2 
14. 0 0 
15. 3 1 
16. -2 0 
17. -2 2 
18. -2 4 
19. -2 6 
20. 0 6 
21. 2 6 
22. 2 4 
23. 2 2 
24. 2 0 
25. 1 
26.  
27. 10 1 1 2 
28. 0 0 
29. 3 1 
30. -2 0 
31. -2 2 
32. -2 4 
33. -2 6 
34. 0 6 
35. 2 6 
36. 2 4 
37. 2 2 
38. 3 0 
39. 8 
40.  
41. 6 3 2 50000000 
42. 0 0 
43. 50000000 100000000 
44. 100000000 100000000 
45. 100000000 0 
46. 100000000 50000000 
47. 50000000 0 
48. -100000000 50000000 
49. 0 50000000 
50. 0 100000000 
51. 2 

网上的大部分算法下面的测试是通不过的：

10 4 2 1
0 0
5 0
0 1
0 2
0 3
1 3
3 0
3 1
3 2
3 3
1 0
2 0
2 3
4 0
10