hdu 4606 Occupy Cities （计算几何+最短路+有向图最小路径覆盖）

题意：在平面坐标系上，给你n个城市点，m条障碍（两断点坐标确定的线段），现有p个士兵（士兵可从任意点开始分布在图中），士兵不可以穿越障碍（但可以从它端点经过），每个士兵有一个等容量的背包，背包可以支撑的的路程就是背包容量，到城市可以全部补给，一个城市补给一个士兵后就不能再次补给了。现在问背包容量最少可以设置为多少。占领城市的顺序是给定的。

思路：先预处理出城市到城市的距离，floyd就可以。要让士兵依次占领城市，若城市i需在城市j之前占领，且两城市之间的距离不大于背包容量，就可以连一条边。最后构造出一个有向图，图中若i到j连边，说明士兵可以在攻占i城市之后攻占j城市。那么攻占所有城市的士兵总是就是这个有向图的最小路径覆盖。二分背包容量，对每次的容量计算最少需要多少士兵，若士兵数小于要求，则该容量还可能减少。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;

#define eps 1e-8
#define LL long long
#define INF 0x3f3f3f3f
#define zero(x) (((x)>0?(x):-(x))<eps)

struct point
{
    double x,y;
};

const int maxn=101;

vector <int> map[maxn];

int T,n,m,p,ans,ppsum;
int t[maxn],tt[maxn],citypos[maxn],father[maxn];
double wl,wr,mid,bag;
double dis[maxn*3][maxn*3];
point city[maxn],bar[maxn*2],pp[maxn*3];

double xmult(point p1,point p2,point p0){
	return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}

inline double distancexy(point p1,point p2)
{
    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
}
inline int opposite_side(point p1,point p2,point l1,point l2){
	return xmult(l1,p1,l2)*xmult(l1,p2,l2)<-eps;
}

//判两线段相交,不包括端点和部分重合
int intersect_ex(point u1,point u2,point v1,point v2){
	return opposite_side(u1,u2,v1,v2)&&opposite_side(v1,v2,u1,u2);
}

bool find(int x)
{
    for(int i=0;i<map[x].size();i++)
        if(tt[map[x][i]])
        {
            tt[map[x][i]]=0;
            if((father[map[x][i]]==0) || (find(father[map[x][i]])))
            {
                father[map[x][i]]=x;
                return 1;
            }
        }
    return 0;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&p);//n个城市，m个障碍，p个士兵
        for(int i=1;i<=n;i++)
        {
            scanf("%lf%lf",&city[i].x,&city[i].y);
            pp[i].x=city[i].x;
            pp[i].y=city[i].y;
        }
        ppsum=n;
        for(int i=1;i<=m;i++)
        {
            scanf("%lf%lf%lf%lf",&bar[i*2-1].x,&bar[i*2-1].y,&bar[i*2].x,&bar[i*2].y);
                pp[++ppsum].x=bar[i*2-1].x;
            pp[ppsum].y=bar[i*2-1].y;
            pp[++ppsum].x=bar[i*2].x;
            pp[ppsum].y=bar[i*2].y;
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&t[i]);
            citypos[t[i]]=i;
        }
        memset(dis,0,sizeof(dis));
        for(int i=1;i<=ppsum;i++)
            for(int j=1;j<=ppsum;j++)
                if(i!=j)
                {
                    for(int k=1;k<=m;k++)
                        if(intersect_ex(pp[i],pp[j],bar[k*2-1],bar[k*2]))
                        {
                            dis[i][j]=INF;
                            break;
                        }
                    if(dis[i][j]!=INF)
                        dis[i][j]=distancexy(pp[i],pp[j]);

                }
        for(int k=1;k<=ppsum;k++)
            for(int i=1;i<=ppsum;i++)
                for(int j=1;j<=ppsum;j++)
                    if(dis[i][j]>dis[i][k]+dis[k][j])
                        dis[i][j]=dis[i][k]+dis[k][j];
        wl=wr=0;
        for(int i=1;i<=ppsum;i++)
            for(int j=1;j<=ppsum;j++)
                if(dis[i][j]>wr)
                    wr=dis[i][j];
        bag=wr;
        wr*=2;
        while(wr-wl>eps)
        {
            mid=(wl+wr)/2;
            for(int i=1;i<=n;i++)
            {
                map[i].clear();
                for(int j=1;j<=n;j++)
                    if(i!=j  && citypos[i]<citypos[j] && dis[i][j]<=mid)
                        map[i].push_back(j);
            }
            ans=0;
            memset(father,0,sizeof(father));
            for(int i=1;i<=n;i++)
            {
                memset(tt,1,sizeof(tt));
                if(find(i))
                    ans++;
            }
            if(n-ans<=p)
            {
                wr=mid;
                bag=mid;
            }
            else
                wl=mid;
        }
        printf("%.2lf\n",bag);
    }
    return 0;
}