HDU 4606 Occupy Cities (计算几何+最短路+最小路径覆盖)

转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents    by---cxlove

题目：给出n个城市需要去占领，有m条线段是障碍物，有p个士兵可以用。占领城市有个先后顺序，每个士兵有个背包，占领城市之后，仅能补给一次背包。问背包容量最少是多少，可以用这P个士兵完成任务，起点任意 。

http://acm.hdu.edu.cn/showproblem.php?pid=4606

首先：枚举所有顶点，求一下距离，判断是否与线段相交。然后 floyd预处理最短路

之后是二分答案，判断是否可达

根据占领的先后顺序建边，根据二分的值判断不需要补给是否能够到达。

之后便是判断最小路径覆盖数是否小于等于P。

 

#include <iostream>

#include <queue>

#include <algorithm>

#include <cstdio>

#include <cstring>

#include <cmath>

using namespace std;

typedef long long LL;

const int N = 505;

const int M = 3000000;

const int INF = 100000;

const double eps = 1e-7;

inline int dcmp(double d){

    return d < -eps? -1 : d > eps;

}

inline double sqr(double d){

    return d * d;

}

struct Point {

    double x, y;

    Point (){}

    Point (double _x,double _y):x(_x),y(_y){}

    inline bool operator == (const Point &p)const {

        return (dcmp(x - p.x) == 0 && dcmp(y - p.y) == 0);

    }

    inline Point operator - (const Point &p)const {

        return Point(x - p.x,y - p.y);

    }

    inline double operator * (const Point &p)const {

        return x * p.y - y * p.x;

    }

    inline double operator / (const Point &p)const {

        return x * p.x + y * p.y;

    }

    inline double Distance(Point p){

        return sqrt(sqr(p.x - x) + sqr(p.y - y));

    }

    void input(){

        scanf ("%lf %lf", &x, &y);

    }

}p[N];

struct Line{

    Point a,b;

    void input(){

        a.input();

        b.input();

    }

    Line(){}

    Line(Point _a,Point _b):a(_a),b(_b){}

    inline bool operator == (const Line &l) const{

        return (a == l.a && b == l.b) || (a == l.b && b == l.a);

    }

    inline double operator * (const Point &p)const {

        return (b - a) * (p - a);

    }

    inline double operator / (const Point &p)const {

        return (p - a) / (p - b);

    }

    inline int SegCrossSeg(const Line &v){

        int d1 = dcmp((*this) * v.a);

        int d2 = dcmp((*this) * v.b);

        int d3 = dcmp(v * a);

        int d4 = dcmp(v * b);

        if((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;

        return ((d1 == 0 && dcmp((*this) / v.a) <= 0)

            ||(d2 == 0 && dcmp((*this) / v.b) <= 0)

            ||(d3 == 0 && dcmp(v / a) <= 0)

            ||(d4 == 0 && dcmp(v / b) <= 0) );

    }

}l[N];

int n , m , K , seq[N];

int match[N], vis[N];

double dist[N][N];

int tot , start[N];

struct Edge {

    int v, next;

}e[N * N];

void _add (int u , int v) {

    e[tot].v = v;

    e[tot].next = start[u];

    start[u] = tot ++;

}

bool dfs (int u) {

    for (int i = start[u] ; i != -1 ; i = e[i].next) {

        int v = e[i].v;

        if (! vis[v]) {

            vis[v] = 1;

            if(match[v] == -1 || dfs(match[v])) {

                match[v] = u;

                return true;

            }

        }

    }

    return false;

}

int hungry () {

    int ans = 0;

    memset (match , -1, sizeof(match)) ;

    for (int i = 1 ; i <= n ; i ++) {

        memset (vis , 0 , sizeof(vis));

        if (dfs(i)) ans ++;

    }

    return ans;

}

bool check (double mid) {

    tot = 0 ;

    memset (start , -1 , sizeof(start));

    for (int i =1 ; i <= n ; i ++) {

        for (int j = i + 1 ; j <= n ; j ++) {

            if(dist[seq[i]][seq[j]] <= mid) 

                _add (seq[i] , seq[j] + n);

        }

    }

    return n - hungry() <= K;

}

double solve(){

    double l = 0 , r = INF;

    double ans = -1;

    int cnt = 50;

    while(cnt --){

        double mid = (l + r) * 0.5;

        if(check(mid)){

            ans = mid;

            r = mid;

        }

        else l = mid;

    }

    return ans;

}

int main(){

    int t;

    scanf ("%d", &t);

    while (t --){

        scanf ("%d%d%d", &n, &m, &K);

        for (int i = 1 ; i <= n ; i ++){

            p[i].input();

        }

        for (int i = 1 ; i <= m ; i ++){

            l[i].input();

            p[n + (i - 1) * 2 + 1] = l[i].a;

            p[n + i * 2] = l[i].b;

        }

        for (int i = 1 ; i <= n + m * 2 ; i ++){

            for (int j = 1 ; j <= n + m * 2 ; j ++){

                if(i == j) dist[i][j] = 0.0;

                else {

                    bool flag = false;

                    for (int k = 1 ; k <= m ; k ++){

                        if(l[k] == Line(p[i] , p[j])) continue;

                        if (l[k].SegCrossSeg(Line(p[i] , p[j])) == 2) {

                            flag = true;

                            break ; 

                        }

                    }

                    if(flag) dist[i][j] = 1e9;

                    else dist[i][j] = p[i].Distance(p[j]);

                }

            }

        }

        for(int i = 1;i <= n;i ++){

            scanf("%d",&seq[i]);

        }

        for (int k = 1 ; k <= n + m * 2 ; k ++) {

            for (int i = 1 ; i <= n + m * 2 ; i ++) {

                for (int j = 1 ; j <= n + m * 2 ;j ++ ){

                    dist[i][j] = fmin(dist[i][j] , dist[i][k] + dist[k][j]);

                }

            }

        }

        double ans = solve();

        printf("%.2f\n",ans);

    }

    return 0;

}