2017"百度之星"程序设计大赛

Problem Description

哗啦啦村袭击了喵哈哈村！

度度熊为了拯救喵哈哈村，带着自己的伙伴去救援喵哈哈村去了！度度熊与伙伴们很快的就过来占据了喵哈哈村的各个军事要地，牢牢的守住了喵哈哈村。

但是度度熊发现，这是一场旷日持久的战斗，所以度度熊决定要以逸待劳，保存尽量多的体力，去迎战哗啦啦村的战士。

于是度度熊决定派尽量多的人去休息，但是同时也不能松懈对喵哈哈村的保护。

换句话而言，度度熊希望尽量多的人休息，而且存在一个包围圈由剩下的人组成，且能够恰好的包围住喵哈哈村的所有住房（包括边界）。

请问最多能让多少个人休息呢？

 

Input

本题包含若干组测试数据。

第一行一个整数n，表示喵哈哈村的住房数量。

接下来n行，每行两个整数(x1[i],y1[i])，表示喵哈哈村的住房坐标。

第n+1行一个整数m，表示度度熊的士兵数量。

接下来m行，每行两个整数(x2[i],y2[i])，表示度度熊伙伴的坐标。

满足:

1<=n,m<=500

-10000<=x1[i],x2[i],y1[i],y2[i]<=10000

 

Output

请输出最多的人员休息的数目。

如果无法保护整个村庄的话，输出"ToT"

 

Sample Input

2

1 1

2 2

4

0 0

0 4

4 2

4 0

1

1 1

2

0 0

0 1

 

Sample Output

1

ToT

 

网上看到一中方法，度度熊的士兵数量有m个，喵哈哈村的住房数量有n个，假设n个住房全在度度熊伙伴 i--j 的右侧或者线上，则 i 到 j 连接一条长度为1的单向边。

之后就可以得到一张图了，其中最小的环就是最优方案，G[i][j]是从 i 到 j 的最短路。那么最大的m-G[i][i]就是答案了。

当然要考虑没有的应该。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
const int N = 550;
struct Point {
    int x, y;
};
int n, m, G[N][N];
Point a[N], b[N];
int mymin (int x,int y){return x<y?x:y;}
bool check(Point a, Point b, Point c) {
    if(a.x > b.x && a.x > c.x) return true;
    if(a.x < b.x && a.x < c.x) return true;
    if(a.y < b.y && a.y < c.y) return true;
    if(a.y > b.y && a.y > c.y) return true;
    return false;
}
double fun(Point a, Point b, Point c) {
    double x1 = a.x - c.x, y1 = a.y - c.y;
    double x2 = b.x - c.x, y2 = b.y - c.y;
    return x1 * y2 - x2 * y1;
}
int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 1; i <= n; i ++) {
            scanf("%d %d", &a[i].x, &a[i].y);
        }
        scanf("%d", &m);
        for(int i = 1; i <= m; i ++) {
            scanf("%d %d", &b[i].x, &b[i].y);
        }
        for(int i = 1; i <= m; i ++) {
            for(int j = 1; j <= m; j ++) {
                G[i][j] = INF;
            }
        }
        for(int i = 1; i <= m; i ++) {
            for(int j = 1; j <= m; j ++) {
                bool flag = true;
                for(int k = 1; k <= n; k ++) {
                    if(fun(a[k], b[j], b[i]) < 0) flag = false;
                    if(fun(a[k], b[j], b[i]) == 0 && check(a[k], b[j], b[i])) flag = false;
                    if(!flag) break;
                }
                if(flag) G[i][j] = 1;
            }
        }
        for(int i = 1; i <= m; i ++) {
            for(int j = 1; j <= m; j ++) {
                if(G[j][i] == INF) continue;
                for(int k = 1; k <= m; k ++) {
                    G[j][k] = mymin(G[j][k], G[j][i] + G[i][k]);
                }
            }
        }
        int ans = INF;
        for(int i = 1; i <= m; i ++) {
            ans = mymin(ans, G[i][i]);
        }
        if(ans > m) printf("ToT
");
        else printf("%d
",m - ans);
    }
    return 0;
}

不过我做的有点复杂了，先是用m个点建立一个凸包，然后判断n个点是否都在凸包内，然后一个for循环每次从m中删除一个点重新建立一个凸包，看能否包含n个点，不能的话就不删除，能的话肯定删除掉。

但是答案一直错误。。。。。代码先放这。

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const int N = 550;
double EPS = 1e-10;
int n, m, ans, cnt;
// double add(double a,double b) {
//     if(abs(a+b) < EPS * (abs(a) + abs(b))) return 0;
//     return a + b;
// }
struct Point{
    int x, y;
    Point(){}
    Point(int x, int y) :x(x), y(y) {}
    Point operator + (Point p) {
        return Point(x + p.x, y + p.y);
    }
    Point operator - (Point p) {
        return Point(x - p.x, y - p.y);
    }
    Point operator * (int d) {
        return Point(x*d, y*d);
    }
    int dot(Point p) {    //内积
        return x * p.x + y * p.y;
    }
    int det(Point p) {    //外积
        return x * p.y - y * p.x;
    }
};
Point qs[N], qu[N];
bool vis[N];
vector<Point> ps;
bool cmp(Point x, Point y) {
    if(x.x != y.x) return x.x < y.x;
    else return x.y < y.y;
}
vector<Point> convex_hull(Point *ps, int n) {
    sort(ps, ps+n, cmp);
    int k = 0;
    vector<Point> qs(n*2);
    for(int i = 0; i < n; i ++) {   //下侧
        if(vis[i])continue;
        while(k > 1 && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) k--;
        qs[k++] = ps[i];
    }
    for(int i = n-2, t = k; i >= 0; i --) { //上侧
        if(vis[i])continue;
        while(k > t && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) k--;
        qs[k++] = ps[i];
    }
    cnt = k-1;
    qs.resize(k-1);
    return qs;
}
bool check() {
    for(int i = 0; i < n; i ++) {
        if(m - ans == 1) {
            if(qs[i].x != ps[0].x || qs[i].y != ps[0].y) return false;
        } else if(m - ans == 2){
            if((qs[i] - ps[0]).det(ps[1] - qs[i]) !=  0) return false;
        } else {
            for(int j = 0; j < cnt; j ++) {
                if((qs[i] - ps[j]).det(ps[(j+1)%cnt] - qs[i]) > 0) {
                    // printf("%d %d
",(qs[i] - ps[j]).x,(qs[i] - ps[j]).y);
                    // printf("%d %d
",(qs[i] - ps[j]).x,(qs[i] - ps[j]).y);
                    // printf("%d ++
",(qs[i] - ps[j]).det(ps[(j+1)%cnt] - qs[i]) );
                    // printf("%d  %d
",i,j);
                    return false;
                }
            }
        }
    }
    return true;
}
int main() {
    while(scanf("%d",&n) != EOF) {
        memset(vis, false, sizeof(vis));
        ans = 0;
        for(int i = 0; i < n; i ++) {
            scanf("%d %d", &qs[i].x, &qs[i].y);
        }
        scanf("%d", &m);
        for(int i = 0; i < m; i ++) {
            scanf("%d %d", &qu[i].x, &qu[i].y);
        }
        ps = convex_hull(qu, m);
        // for(int i = 0; i < ps.size(); i ++) {
        //     printf("%d %d
",ps[i].x, ps[i].y);
        // }
        if(!check()) {
            printf("ToT
");
            continue;
        }
        for(int i = 0; i < m; i ++) {
            if(m - ans == 1)break;
            vis[i] = true;
            ps.clear();
            ps = convex_hull(qu, m);
            if(check()) {
                ans ++;
                continue;
            }
            else vis[i] = false;
        }
        printf("%d
",ans);
        ps.clear();
    }
    return 0;
}