HDU4606 Occupy Cities 计算几何+最小路径覆盖

题目大意如下

在一个二维坐标系中，有n个城市，坐标给出来了，然后有p个士兵要去占领这n个城市，但是路上有m个路障，都是线段，士兵不能越过路障前进。

每个士兵都有相同容量大小的一个干粮袋，每到一个城市他就能补充满自己的干粮袋。中途走路时走一个单位长度就消耗一个单位的干粮。

现在问的是这些个干粮袋最小的容量是多少，前提是保证p个士兵能占领完这n个城市，城市被占领顺序也是题目给好的，必须遵守

思路：P个士兵占领n个城市，可以看成p个士兵走出了p个路径，覆盖了所有的点。   但是题目没要求每个士兵都必须去占领。 也就是只要最小路径覆盖小于等于p个就代表所有的城市能被p个士兵去占领了。

最小路径覆盖的要求之一就是有向，无环，在题目中的体现就是城市被占领时必须有顺序。

这就符合一个拓扑序列了。所以就可以进行最小路径覆盖

然后整体的步骤就是，刚开始把各个点之间的距离先算出来，因为有障碍，所以必须把这些线段的两个端点都加入到点集中一块算，预处理两点距离时，就看两点之间有没有线段挡着，挡着就先按不可达算，注意处理线段交的时候端点相交不要管，因为还是可以过去。  没挡着就按照直线距离算。 然后floyd处理一下，任意两点之间的距离就算出来了

算出来后我们就要求干粮袋的容量了，一般的方法就是二分求可行性。 

对于二分的一个值，我们就建立一遍图，任意两点的距离不大于这个值才可以连边。

当然注意我们是按照题目中给的那个占领顺序，前边的可以向后边的连边，反之不能

然后求路径覆盖。判断是否可行

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define eps 1e-8
#define MAXN 333
#define INF 1111111111
using namespace std;
typedef double TYPE;
struct POINT
{
    TYPE x;
    TYPE y;
    POINT() : x(0), y(0) {};
    POINT(TYPE _x_, TYPE _y_) : x(_x_), y(_y_) {};
    bool operator == (const POINT &p)const
    {
        return (fabs(x - p.x) < eps && fabs(y - p.y) < eps);
    }
}p[MAXN];
TYPE Distance(const POINT & a, const POINT & b)
{
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
struct SEG
{
    POINT a; //起点
    POINT b; //终点
    SEG() {};
    SEG(POINT _a_, POINT _b_):a(_a_),b(_b_) {};
    bool operator == (const SEG &p)const
    {
        return (p.a == a && p.b == b) || (p.b == a && p.a == b);
    }
}seg[MAXN];
TYPE Cross(const POINT & a, const POINT & b, const POINT & o)
{
    return (a.x - o.x) * (b.y - o.y) - (b.x - o.x) * (a.y - o.y);
}
bool IsIntersect(const SEG & u, const SEG & v)
{
    return (Cross(v.a, u.b, u.a) * Cross(u.b, v.b, u.a) > 0) &&
           (Cross(u.a, v.b, v.a) * Cross(v.b, u.b, v.a) > 0) &&
           (max(u.a.x, u.b.x) > min(v.a.x, v.b.x)) &&
           (max(v.a.x, v.b.x) > min(u.a.x, u.b.x)) &&
           (max(u.a.y, u.b.y) > min(v.a.y, v.b.y)) &&
           (max(v.a.y, v.b.y) > min(u.a.y, u.b.y));
}
int seq[MAXN];
struct node
{
    int v, next;
}edge[MAXN * MAXN];
int e, head[MAXN], mark[MAXN], cx[MAXN], cy[MAXN], n, m, so;
double dis[MAXN][MAXN];
void insert(int x, int y)
{
    edge[e].v = y;
    edge[e].next = head[x];
    head[x] = e++;
}
int path(int u)
{
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].v;
        if(!mark[v])
        {
            mark[v] = 1;
            if(cy[v] == -1 || path(cy[v]))
            {
                cx[u] = v;
                cy[v] = u;
                return 1;
            }
        }
    }
    return 0;
}
int gao()
{
    int ans = 0;
    memset(cx, -1, sizeof(cx));
    memset(cy, -1, sizeof(cy));
    for(int i = 1; i <= n; i++)
    {
        memset(mark, 0, sizeof(mark));
        ans += path(i);
    }
    return ans;
}
void floyd(int n)
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(dis[i][k] + dis[k][j] < dis[i][j])
                    dis[i][j] = dis[i][k] + dis[k][j];
}
bool ok(double mid)
{
    e = 0;
    memset(head, -1, sizeof(head));
    for(int i = 1; i <= n; i++)
        for(int j = i + 1; j <= n; j++)
            if(dis[seq[i]][seq[j]] <= mid)
                insert(seq[i], seq[j] + n);
    int x = gao();
    if(n - x <= so) return true;
    return false;
}
void slove()
{
    double l = 0, r = INF;
    double ans = -1;
    while(r - l > eps)
    {
        double mid = (l + r) / 2;
        if(ok(mid)) {ans = mid; r = mid;}
        else l = mid;
    }
    printf("%.2f\n", ans);
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d%d", &n, &m, &so);
        for(int i = 1; i <= n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
        for(int i = 1; i <= m; i++)
        {
            scanf("%lf%lf%lf%lf", &seg[i].a.x, &seg[i].a.y, &seg[i].b.x, &seg[i].b.y);
            p[n + i * 2 - 1] = seg[i].a;
            p[n + i * 2] = seg[i].b;
        }
        for(int i = 1; i <= n; i++) scanf("%d", &seq[i]);
        for(int i = 1; i <= n + m * 2; i++)
            for(int j = 1; j <= n + m * 2; j++)
            {
                if(i == j) {dis[i][j] = 0; continue;}
                int flag = false;
                for(int k = 1; k <= m; k++)
                {
                    if(seg[k] == SEG(p[i], p[j])) continue;
                    if(IsIntersect(seg[k], SEG(p[i], p[j])))
                    {
                        flag = true;
                        break;
                    }
                }
                if(flag) dis[i][j] = INF;
                else dis[i][j] = Distance(p[i], p[j]);
            }

        floyd(n + m * 2);
        slove();
    }
    return 0;
}