傳送門

這整場都不會……這題想二分不會check

其實check很好寫，考慮一個mid的實際意義
即為check在不靠近每個star及邊界mid距離內的前提下，能不能到達\((n,m)\)
其實可以轉化一下，以每個star為圓心，mid為半徑畫圓
如果兩個圓相交就在這兩個圓之間連邊
並查集維護連通性，如果上下邊界連通就說明所有可行路徑都被封上了
可以\(O(k^2logn)\)二分

但是還有\(O(k^2)\)解法：
考慮是什麼在限制整條路徑上的最小值
如果將所有star之間連邊，就一定有幾條權值最小的邊連出了一條從上邊界到下邊界的鏈
無論如何都必須通過這條鏈
可以構建一棵最小生成樹，就確保了權值最小
那問題可以轉化為在權值最小的這條鏈上找一條權值最大的邊

• 解最小值最大問

prim板子：
我承認當年因為覺得kruskal複雜度更優我prim是水過去的，但事實上完全圖上kruskal多個log

void prim() {
	memset(d, 127, sizeof(d));
	d[1]=0;
	for (int i=1,x; i<n; ++i) {
		x=0;
		for (int j=1; j<=n; ++j) 
			if (!vis[j] && (!x||d[j]<d[x])) x=j;
		vis[x]=1;
		for (int j=1; j<=n; ++j) if (!vis[j]) d[j]=min(d[j], dis[x][j]);
	}
}
 

其它細節見程式碼註釋

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define N 6005
#define ll long long 
#define ld long double
#define usd unsigned
#define ull unsigned long long
//#define int long long 

#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf, 1, 1<<21, stdin)), p1==p2?EOF:*p1++)
char buf[1<<21], *p1=buf, *p2=buf;
inline int read() {
	int ans=0, f=1; char c=getchar();
	while (!isdigit(c)) {if (c=='-') f=-f; c=getchar();}
	while (isdigit(c)) {ans=(ans<<3)+(ans<<1)+(c^48); c=getchar();}
	return ans*f;
}

int n, m, k;
double x[N], y[N];

namespace force{
	double ans=1e30;
	void solve() {
		for (int i=1; i<=k; ++i) {
			ans=min(ans, min(y[i], 1.0*m-y[i]));
			for (int j=i+1; j<=k; ++j) ans=min(ans, sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])));
		}
		printf("%.8lf\n", ans);
		exit(0);
	}
}

namespace task_MLE{
	double dis[N][N], d[N];
	short fa[N];
	bool vis[N];
	inline int find(int p) {return fa[p]==p?p:fa[p]=find(fa[p]);}
	void solve() {
		//cout<<double(sizeof(dis))/1024/1024<<endl;
		memset(d, 0x7f, sizeof(d));
		memset(dis, 0x7f, sizeof(dis));
		for (int i=1; i<=k; ++i) 
			for (int j=1; j<=k; ++j) 
				if (i!=j) dis[i][j]=dis[j][i]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])); //, cout<<"dis"<<i<<' '<<j<<' '<<dis[i][j]<<endl;
		for (int i=1; i<=k; ++i) dis[i][k+1]=dis[k+1][i]=y[i];
		for (int i=1; i<=k; ++i) dis[i][k+2]=dis[k+2][i]=1.0*m-y[i];
		for (int i=1; i<=k+2; ++i) fa[i]=i;
		d[1]=0;
		for (int i=1,x; i<=k+1; ++i) {
			x=0;
			for (int j=1; j<=k+2; ++j) 
				if (!vis[j] && (!x||d[j]<d[x])) x=j;
			vis[x]=1; fa[find(x)]=find(1);
			//cout<<"x: "<<x<<endl;
			for (int j=1; j<=k+2; ++j) if (!vis[j]) d[j]=min(d[j], dis[x][j]); //, cout<<"d["<<j<<"]: "<<d[j]<<endl;
			if (find(k+1)==find(k+2)) break;
		}
		double maxn=0;
		for (int i=1; i<=k+2; ++i) if (vis[i]) maxn=max(maxn, d[i]);
		printf("%.8lf\n", maxn/2);
	}
}

namespace task{
	double d[N], ans;
	short fa[N];
	bool vis[N];
	inline int find(int p) {return fa[p]==p?p:fa[p]=find(fa[p]);}
	inline double dis(int i, int j) {
		if (i>k||j>k) {
			if (i>k&&j>k) return 1e30;
			if (i<=k) swap(i, j);
			return (i==k+1)?y[j]:(1.0*m-y[j]);
		}
		else return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
	}
	void solve() {
		memset(d, 0x7f, sizeof(d));
		for (int i=1; i<=k+2; ++i) fa[i]=i;
		d[k+1]=0;
		int cnt=0;
		for (int i=1,x; i<=k+1; ++i) {
			cnt=i;
			x=0;
			for (int j=1; j<=k+2; ++j) 
				if (!vis[j] && (!x||d[j]<d[x])) x=j;
			vis[x]=1; fa[find(x)]=find(k+1);
			//cout<<x<<endl;
			// 這裡一開始的寫法是因為沒有注意到只有從k+1開始搜，才能滿足所搜到的所有能對答案產生貢獻的點都在連線上下邊界的最小路徑上
			// 由於prim的性質，我們所加到集合中的點不一定會在那條最小路徑上，但考慮最後當我們加入一個點，k+1和k+2變得連通時
			// 這個點一定在最小路徑上，而之前加的點分兩種情況
			// 若不在最小路徑上，則由它擴展出來的點也不在最小路徑上，因為我們要求最大值，最後一定需要加入權值更大的邊使圖連通，所以它一定不對答案產生貢獻
			// 若在最小路徑上，注意一個事情（這裡被卡了）， 因為prim維護的是點集，而且是基於連通性擴充套件的，所以可以構造出一種情況，
			// 使後加的邊權值更小（之前它因為和已知集合中的點沒有連邊而沒有被選進去），所以**prim所擴充套件的邊權值不一定遞增**
			for (int j=1; j<=k+2; ++j) if (!vis[j]) d[j]=min(d[j], dis(x, j)); //, cout<<"d["<<j<<"]: "<<d[j]<<endl;
			if (find(k+1)==find(k+2) || i==k+1) {
				double maxn=0;
				for (int i=1; i<=k+2; ++i) if (vis[i]) maxn=max(maxn, d[i]);
				printf("%.8lf\n", maxn/2);
				//printf("%.8lf\n", d[x]/2);
				exit(0);
			}
		}
	}
}

signed main()
{
	#ifdef DEBUG
	freopen("1.in", "r", stdin);
	#endif
	
	n=read(); m=read(); k=read();
	for (int i=1; i<=k; ++i) x[i]=read(), y[i]=read();
	//if (k==1) {printf("%.8lf", max(y[1], m-y[1])/2); return 0;}
	//if (k==2) {printf("%.8lf", min(min(max(y[1], m-y[1]), max(y[2], m-y[2])), sqrt((x[1]-x[2])*(x[1]-x[2])+(y[1]-y[2])*(y[1]-y[2])))/2); return 0;}
	//force::solve();
	task::solve();

	return 0;
}