传送门

这整场都不会……这题想二分不会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;
}复制