【并集查找虚拟节点】P1783 海滩防御|省选-

本文涉及知识点

P1783 海滩防御

题目描述

WLP 同学最近迷上了一款网络联机对战游戏（终于知道为毛 JOHNKRAM 每天刷洛谷效率那么低了），但是他却为了这个游戏很苦恼，因为他在海边的造船厂和仓库总是被敌方派人偷袭。于是，WLP 动用了他那丰满且充实的大脑（或许更偏向前者），想出了一个好主意，他把海滩分成垂直于海岸线的若干列，在其中的几列上放置几个信号塔，试图来监视整个海滩。然而，WLP 是一个非常心急的人，他把信号塔建好后才发现还需给信号塔供能，它们才能投入使用（这不是废话么），它们都有一个工作半径，一个圆形区域里的所有敌人都逃不过它们的监视，不过，WLP 发现，敌人们非常狡猾，除非他将道路完全封死，否则 WLP 的敌人可以走过一条任意弯曲的路（不一定走整点，但是不会出第 0 0 0 列和第 N N N 列构成的边界）来偷他的东西。

于是，WLP 就思考了：到底需要给每个信号塔多大的工作半径，才能将从海滩到内地的路径完全封死呢？他再次动用了他那丰满且充实的大脑，想了一堂数学课，终于，还是没想出来。于是，他向 LZZ 神犇求助（额...... CSUNSHINE 的身份是不是暴露了）。

终于，在 WLP：" %^!*@#!*(*!*#@$^&（此处省略无数卖萌场景）"的哀求下，LZZ 神犇写了一个程序，在一秒内就解决了问题。但是，邪恶的 LZZ 神犇决定要将这个难题共享给无数无辜的 OIer，所以，现在轮到你了。

输入格式

第一行两个整数 N N N 和 M M M，表示海滩被 WLP 分成的列数 0 , 1 , 2 , ⋯ , N 0,1,2,\cdots,N 0,1,2,⋯,N 和信号塔个数。

第 2 2 2 至第 M + 1 M+1 M+1 行，每行两个数 X i X_i Xi， Y i Y_i Yi 表示 1 , 2 , 3 , ⋯ , M 1,2,3,\cdots,M 1,2,3,⋯,M 号信号塔所在的列数和离开海滩的距离。

输出格式

一行一个实数，表示最小的工作半径，保留两位小数。

输入输出样例 #1

输入 #1

复制代码

输出 #1

复制代码

1.00

输入输出样例 #2

输入 #2

复制代码

100 2
30 50
90 100

输出 #2

复制代码

39.05

说明/提示

数据范围及约定

对于 10 % 10\% 10% 的数据： 1 ≤ M ≤ 10 1 \le M \le 10 1≤M≤10， 1 ≤ Y i ≤ 100 1 \le Y_i \le 100 1≤Yi≤100；
对于 30 % 30\% 30% 的数据： 1 ≤ M ≤ 50 1 \le M \le 50 1≤M≤50， 1 ≤ Y i ≤ 1 , 000 1 \le Y_i \le 1,000 1≤Yi≤1,000；
对于 80 % 80\% 80% 的数据： 1 ≤ M ≤ 500 1 \le M \le 500 1≤M≤500， 1 ≤ Y i ≤ 1 , 000 1 \le Y_i \le 1,000 1≤Yi≤1,000；
对于 100 % 100\% 100% 的数据： 1 ≤ M ≤ 800 1 \le M \le 800 1≤M≤800， 1 ≤ N ≤ 1000 1 \le N \le 1000 1≤N≤1000， 1 ≤ X i ≤ N 1 \le X_i \le N 1≤Xi≤N， 1 ≤ Y i ≤ 100 , 000 1 \le Y_i \le 100,000 1≤Yi≤100,000。

提示

注意，封锁海滩是指，敌人的深入程度是有限制的，若敌人绕过了所有的信号塔，并且可以长驱直入，那么就说明道路没有完全封锁。

并集查找（错误）

性质一 ：令列数最小的信号塔列号是c0，列数最大的信号塔是c1。

则 a n s ≥ m a x ( c 0 , N − c 1 ) ans \ge max(c0,N-c1) ans≥max(c0,N−c1)
性质二 ：将距离 ≤ 2 × a n s \le2\times ans ≤2×ans的信号塔连起来。存在任意从c0到c1的路径，则符合题意。如果有多个最左的塔，选择任意一个。

从上图可以看出，如果两个圆没有相切或相交，则无阻隔效果如果两个圆没有相切或相交，则无阻隔效果如果两个圆没有相切或相交，则无阻隔效果

增加两个虚拟节点M,M+1。M连通所有c0信号塔，M+1连通所有c1信号塔。

将所有距离升序排序，并处理各百年。如果没连通则连通并判断N和n+1是否连通，max(性质一的结果,最大边/2.0)
时间复杂度：O(nnlogn)

并集查找

上面的小圆，没有任何用。

解决办法：M和M+1也有权，就水平距离。其它点是距离 ÷ 2 距离\div 2 距离÷2

代码

核心代码

cpp 复制代码

#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>
#include<list>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t);
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	cin >> n;
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}
template<class T = int>
vector<T> ReadNotNum() {
	vector<T> ret;
	T tmp;
	while (cin >> tmp) {
		ret.emplace_back(tmp);
		if ('\n' == cin.get()) { break; }
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<int N = 1'000'000>
class COutBuff
{
public:
	COutBuff() {
		m_p = puffer;
	}
	template<class T>
	void write(T x) {
		int num[28], sp = 0;
		if (x < 0)
			*m_p++ = '-', x = -x;

		if (!x)
			*m_p++ = 48;

		while (x)
			num[++sp] = x % 10, x /= 10;

		while (sp)
			*m_p++ = num[sp--] + 48;
		AuotToFile();
	}
	void writestr(const char* sz) {
		strcpy(m_p, sz);
		m_p += strlen(sz);
		AuotToFile();
	}
	inline void write(char ch)
	{
		*m_p++ = ch;
		AuotToFile();
	}
	inline void ToFile() {
		fwrite(puffer, 1, m_p - puffer, stdout);
		m_p = puffer;
	}
	~COutBuff() {
		ToFile();
	}
private:
	inline void AuotToFile() {
		if (m_p - puffer > N - 100) {
			ToFile();
		}
	}
	char  puffer[N], * m_p;
};

template<int N = 1'000'000>
class CInBuff
{
public:
	inline CInBuff() {}
	inline CInBuff<N>& operator>>(char& ch) {
		FileToBuf();
		ch = *S++;
		return *this;
	}
	inline CInBuff<N>& operator>>(int& val) {
		FileToBuf();
		int x(0), f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行		
		return *this;
	}
	inline CInBuff& operator>>(long long& val) {
		FileToBuf();
		long long x(0); int f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行
		return *this;
	}
	template<class T1, class T2>
	inline CInBuff& operator>>(pair<T1, T2>& val) {
		*this >> val.first >> val.second;
		return *this;
	}
	template<class T1, class T2, class T3>
	inline CInBuff& operator>>(tuple<T1, T2, T3>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val);
		return *this;
	}
	template<class T1, class T2, class T3, class T4>
	inline CInBuff& operator>>(tuple<T1, T2, T3, T4>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val) >> get<3>(val);
		return *this;
	}
	template<class T = int>
	inline CInBuff& operator>>(vector<T>& val) {
		int n;
		*this >> n;
		val.resize(n);
		for (int i = 0; i < n; i++) {
			*this >> val[i];
		}
		return *this;
	}
	template<class T = int>
	vector<T> Read(int n) {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) {
			*this >> ret[i];
		}
		return ret;
	}
	template<class T = int>
	vector<T> Read() {
		vector<T> ret;
		*this >> ret;
		return ret;
	}
private:
	inline void FileToBuf() {
		const int canRead = m_iWritePos - (S - buffer);
		if (canRead >= 100) { return; }
		if (m_bFinish) { return; }
		for (int i = 0; i < canRead; i++)
		{
			buffer[i] = S[i];//memcpy出错			
		}
		m_iWritePos = canRead;
		buffer[m_iWritePos] = 0;
		S = buffer;
		int readCnt = fread(buffer + m_iWritePos, 1, N - m_iWritePos, stdin);
		if (readCnt <= 0) { m_bFinish = true; return; }
		m_iWritePos += readCnt;
		buffer[m_iWritePos] = 0;
		S = buffer;
	}
	int m_iWritePos = 0; bool m_bFinish = false;
	char buffer[N + 10], * S = buffer;
};


class CUnionFind
{
public:
	CUnionFind(int iSize) :m_vNodeToRegion(iSize)
	{
		for (int i = 0; i < iSize; i++)
		{
			m_vNodeToRegion[i] = i;
		}
		m_iConnetRegionCount = iSize;
	}
	CUnionFind(vector<vector<int>>& vNeiBo) :CUnionFind(vNeiBo.size())
	{
		for (int i = 0; i < vNeiBo.size(); i++) {
			for (const auto& n : vNeiBo[i]) {
				Union(i, n);
			}
		}
	}
	int GetConnectRegionIndex(int iNode)
	{
		int& iConnectNO = m_vNodeToRegion[iNode];
		if (iNode == iConnectNO)
		{
			return iNode;
		}
		return iConnectNO = GetConnectRegionIndex(iConnectNO);
	}
	void Union(int iNode1, int iNode2)
	{
		const int iConnectNO1 = GetConnectRegionIndex(iNode1);
		const int iConnectNO2 = GetConnectRegionIndex(iNode2);
		if (iConnectNO1 == iConnectNO2)
		{
			return;
		}
		m_iConnetRegionCount--;
		if (iConnectNO1 > iConnectNO2)
		{
			m_vNodeToRegion[iConnectNO1] = iConnectNO2;
		}
		else
		{
			m_vNodeToRegion[iConnectNO2] = iConnectNO1;
		}
	}

	bool IsConnect(int iNode1, int iNode2)
	{
		return GetConnectRegionIndex(iNode1) == GetConnectRegionIndex(iNode2);
	}
	int GetConnetRegionCount()const
	{
		return m_iConnetRegionCount;
	}
	//vector<int> GetNodeCountOfRegion()//各联通区域的节点数量
	//{
	//	const int iNodeSize = m_vNodeToRegion.size();
	//	vector<int> vRet(iNodeSize);
	//	for (int i = 0; i < iNodeSize; i++)
	//	{
	//		vRet[GetConnectRegionIndex(i)]++;
	//	}
	//	return vRet;
	//}
	std::unordered_map<int, vector<int>> GetNodeOfRegion()
	{
		std::unordered_map<int, vector<int>> ret;
		const int iNodeSize = m_vNodeToRegion.size();
		for (int i = 0; i < iNodeSize; i++)
		{
			ret[GetConnectRegionIndex(i)].emplace_back(i);
		}
		return ret;
	}
private:
	vector<int> m_vNodeToRegion;//各点所在联通区域的索引,本联通区域任意一点的索引，为了增加可理解性，用最小索引
	int m_iConnetRegionCount;
};

class Solution {
public:
	double Ans(const int N, vector<pair<int, int>>& xy) {
		const int M = xy.size();
		CUnionFind uf(M + 2);
		vector<tuple<double, int, int>> edge;
		for (int i = 0; i < M; i++) {
			edge.emplace_back(xy[i].first, i, M);
			edge.emplace_back(N - xy[i].first, i, M + 1);
			for (int j = i + 1; j < M; j++) {
				const double d = sqrt(Dis2(xy[i], xy[j]));
				edge.emplace_back(d / 2.0, i, j);
			}
		}
		sort(edge.begin(), edge.end());
		for (const auto& [d, u, v] : edge) {
			if (uf.IsConnect(u, v)) { continue; }
			uf.Union(u, v);
			if (uf.IsConnect(M, M + 1)) { return d; }
		}
		return 0;
	}
	double Dis2(pair<int, int>& p1, pair<int, int>& p2) {
		return ((double)p1.first - p2.first) * ((double)p1.first - p2.first) + ((double)p1.second - p2.second) * ((double)p1.second - p2.second);
	}
};

int main() {
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG
	ios::sync_with_stdio(0); cin.tie(nullptr); cout.tie(nullptr);
	int N;
	cin >> N;
	auto xy = Read<pair<int, int>>();
#ifdef _DEBUG
	printf("N=%d", N);
	Out(xy, "xy");
#endif // DEBUG
	auto res = Solution().Ans(N,xy);
	printf("%.2lf", res);
	return 0;
}

单元测试

cpp 复制代码

int N;
		vector<pair<int, int>> xy;
		TEST_METHOD(TestMethod11)
		{
			N = 5,xy={ {1,5},{3,5},{5,5},{4,30},{2,15} };
			auto res = Solution().Ans(N,xy);
			AssertEx(1.0, res);
		}
		TEST_METHOD(TestMethod12)
		{
			N = 100,xy={ {30,50},{90,100} };
			auto res = Solution().Ans(N, xy);
			AssertEx(39.05, res, 0.005);
		}
		TEST_METHOD(TestMethod13)
		{
			N = 100, xy = { {50,1},{50,100} };
			auto res = Solution().Ans(N, xy);
			AssertEx(50.0, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标及时的反馈拉伸区（难度合适）专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者操作系统：win10 开发环境： VS2022 C++17

如无特殊说明，本算法用**C++**实现。

【并集查找 虚拟节点】P1783 海滩防御|省选-

本文涉及知识点

P1783 海滩防御

题目描述

输入格式

输出格式

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

说明/提示

数据范围及约定

提示

并集查找（错误）

并集查找

代码

核心代码

单元测试

扩展阅读

视频课程

测试环境

【并集查找虚拟节点】P1783 海滩防御|省选-