poj1328Radar Installation

poj1328Radar Installation

原博文地址：https://blog.csdn.net/deepmindman/article/details/52278572

思路一：
1）将小岛从左到右编号1~n。
2）访问第一个小岛，根据小岛坐标计算出雷达在海岸线上的坐标范围，取该区间的最右侧建立雷达。
3） 继续访问下一座小岛，如果该小岛处于已经建立的雷达范围内，跳过。如果不在范围内，同2）建立新的雷达站。
4）访问所有的小岛，结束。
可以用以下测试样例判断：
2 2
1 1
2 2

0 0
Case 1:1

思路二：
1）根据每座小岛的坐标计算出每座小岛对应海岸线上可以放置雷达的范围。
2）按输入的顺序对小岛编号，从编号1开始求出与小岛 i 具有共同雷达范围的其他小岛 i1,i2,i3…，将 i,i1,i2,i3…组成集合，并置visit[i], visit[i1],visit[i2],visit[i3]为1，代表已经访问过。
3）遍历所有的小岛，得到N个集合，N即为雷达站的个数。
可以用以下测试样例判断：
9 3
0 2
-3 2
-4 2
-5 2
3 2
6 2
9 2
12 2
15 2
0 0
Case 1:4

正确的思路：与思路二很相近，只不过增加了一步排序。
1）根据每座小岛的坐标计算出每座小岛对应海岸线上可以放置雷达的范围。
2) 将每个小岛对应的雷达设置范围进行排序，使得每个雷达范围的最小值递增。
3）按照2）的顺序对小岛编号，从编号1开始求出与小岛 i 具有共同雷达范围的其他小岛 i1,i2,i3…，将 i,i1,i2,i3…组成集合，并置visit[i],visit[i1],visit[i2],visit[i3]为1，代表已经访问过。
4）遍历所有的小岛，得到N个集合，N即为雷达站的个数。
测试样例：
3 2
1 0
-3 -1
2 1

0 0
Case 1: -1

2 2
1 1
2 2

0 0
Case 2: 1

5 4
-2 2
1 2
0 3
3 3
4 3
0 0
Case 3: 1

AC源码：

#include<iostream>
#include<list>
#include<vector>
#include<cmath>
#include<algorithm>
#include<set>
#include<fstream>
using namespace std;
 
struct node
{
	float l;
	float r;	
};
 
bool comp(const node &a,const node &b)
{
	return a.l<b.l;	
}
 
int subsetn(vector<node> s);
bool isIntersect(node a,node b);
node calIntersect(node a,node b);
 
int main()
{
	int n;	
	float d;
	cin>>n>>d;
	for(int i=0;n!=0||d!=0;cin>>n>>d,i++)
	{
		//save the data!
		vector<pair<float,float> >v(n);
		for(int j=0;j<n;j++)
		{
			cin>>v[j].first>>v[j].second;
		}
		//decide the condition.
		bool flag = true;
		if(d<0)
		{
			cout<<"Case "<<i+1<<": "<<-1<<endl;	
			flag = false;
		}
		else
		{
			for(int j=0;j<n;j++)
			{
				if(v[j].second>d || v[j].second<0)
				{
					cout<<"Case "<<i+1<<": "<<-1<<endl;
					flag = false;
					break;
				}	
		    }			 
		}
		//solve the problem when flag == true
		if(flag == true)
		{
			//make the set of range
			vector<node> s(n);
			for(int j=0;j<n;j++)
			{
				s[j].l = v[j].first - sqrt(pow(d,2)-pow(v[j].second,2));
				s[j].r = v[j].first + sqrt(pow(d,2)-pow(v[j].second,2));
				//cout<<s[j].l<<' '<<s[j].r<<endl;	
			}
			//work out the public subset
			sort(s.begin(),s.end(),comp);
			cout<<"Case "<<i+1<<": "<<subsetn(s)<<endl;
		}
		else
		{
			//do nothing!
		}
	}
 
	return 0;
}
 
 
int subsetn(vector<node> s)
{
	vector<set<int> > record;
	vector<bool> visit(s.size(),false);
	
	for(int i=0;i<s.size();i++)
	{
		set<int> stemp;
		if(visit[i] == false)
		{
			visit[i] = true;
			stemp.insert(i);
			node ntemp = s[i];
			for(int j=0;j<s.size();j++)
			{
				if(visit[j]==false && isIntersect(ntemp,s[j]))
				{
					visit[j] = true;
					stemp.insert(j);
					ntemp = calIntersect(ntemp,s[j]);
				}
			}
			record.push_back(stemp);
		}
	}
 
	return record.size();
}
 
bool isIntersect(node a,node b)
{
	return a.r >= b.l && b.r >= a.l;
}
 
node calIntersect(node a,node b)
{
	node result;
	result.l = max(a.l,b.l);
	result.r = min(a.r,b.r);
	return result;
}