LightOJ 1313 - Protect the Mines（凸包）

1313 - Protect the Mines

PDF (English)

Statistics

Forum

Time Limit: 2 second(s)

Memory Limit: 32 MB

You are a rich man, and recently you bought a place which contains some mines of rare metals like gold, platinum etc. As the metals are rare, their cost is also so high. So, you need to protect them from thieves. But things are not as easy as it looks.

So, you called a bunch of engineers to make some wired fences around the mines. As they were just engineers (not problem solvers!), they drilled some holes in random places. The idea was to put some pillars on the drilled holes and after that some wires should be set in the pillars, and finally electrifying the wires would be the completion. And of course, each mine should be surrounded by a fence. Wires should be placed between two pillars, in straight lines. The engineers drilled the holes in positions such that some of the mines might not be covered by any fences.

However, your plan is that, you can put some guards in mines that are not surrounded by any fence. To guard a single mine, it would cost G dollars, and a pillar cost is P dollars. As you are a rich man, the costs of wires are too small that they can be ignored. So, you want to put guards in some mines and surround some other mines by fences, but you want to find the optimal cost to protect all the mines. The fences may or may not be convex.

In bird's eye view, we can get the following figure (fig 1) for sample 1. There are seven pre-drilled holes (marked as circles), and six mine positions (marked as squares). The straight lines show the wires and the closed regions form the fences. The figure shows one of the optimal solutions.

 

Fig 1

So, you have to find the minimum cost for executing your plan.

Input

Input starts with an integer T (≤ 100), denoting the number of test cases.

Each case starts with a line containing four integers N (3 ≤ N ≤ 100), M (1 ≤ M ≤ 100), G (1000 ≤ G ≤ 2000) and P (100 ≤ P ≤ 200), N denotes the number of pre-drilled holes, and M denotes the number of mines. This line is followed by N lines that describe the positions of the holes, and then by M lines that describe the positions of the mines. All positions are given as pairs of integers x y on one line (0 ≤ x, y ≤ 1000). You can assume that no two positions (of holes and mines) coincide and that no three positions are collinear.

Output

For each case, print the case number and the minimum cost to protect all the mines.

Sample Input	Output for Sample Input
2 7 6 1000 100 0 0 20 0 1 10 39 10 1 20 39 20 20 30 3 9 37 9 3 21 37 21 18 24 50 24 4 3 1500 100 0 0 0 10 10 0 10 10 5 4 4 1 8 6	Case 1: 1600 Case 2: 300

 

---

PROBLEM SETTER: JANE ALAM JAN

 

 

首先根据题目意思，

一个mine如果可以被holes覆盖的话，肯定在一个三角形里面，因为G比P至少大10倍，所以最佳策略就是把可以覆盖的全部覆盖掉，其余的加士兵上去。

 

首先求一下凸包，把凸包内部的所有mines都找出来。

然后搞floyed, 就是看最少几步可以形成环，把所有都包括进来，

debug了好久，太坑了，以后写几何要慎重了。

/* ***********************************************
Author        :kuangbin
Created Time  :2014/4/22 19:32:10
File Name     :E:\2014ACM\专题学习\计算几何\凸包\LightOJ1313.cpp
************************************************ */

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

// 计算几何int 版，注意如果超int,相应的要改为long long
const int maxp = 1010;
struct Point
{
    int x,y;
    Point(){}
    Point(int _x,int _y)
    {
        x = _x; y = _y;
    }
    void input()
    {
        scanf("%d%d",&x,&y);
    }
    bool operator == (Point b)const
    {
        return x == b.x && y == b.y;
    }
    bool operator < (Point b)const
    {
        return x == b.x ? y < b.y : x < b.x;
    }
    Point operator - (const Point &b)const
    {
        return Point(x-b.x,y-b.y);
    }
    int operator ^ (const Point &b)const
    {
        return x*b.y - y*b.x;
    }
    int operator *(const Point &b)const
    {
        return x*b.x + y*b.y;
    }
    double len2()
    {
        return x*x + y*y;
    }
};
struct Line
{
    Point s,e;
    Line(){}
    Line(Point _s,Point _e)
    {
        s = _s;
        e = _e;
    }
    //点和直线关系
    //1 在左侧
    //2 在右侧
    //3 在直线上
    int relation(Point p)
    {
        int c = (p-s)^(e-s);
        if(c < 0)return 1;
        else if(c > 0)return 2;
        else return 3;
    }
    bool pointonseg(Point p)
    {
        return ((p-s)^(e-s)) == 0 && ((p-s)*(p-e)) <= 0;
    }
};
struct polygon
{
    int n;
    Point p[maxp];
    void input(int _n)
    {
        n = _n;
        for(int i = 0;i < n;i++)
            p[i].input();
    }
    struct cmp
    {
        Point p;
        cmp(const Point &p0){p = p0;}
        bool operator()(const Point &aa,const Point &bb)
        {
            Point a = aa, b = bb;
            int d = (a-p)^(b-p);
            if(d == 0)
                return (a-p).len2() < (b-p).len2();
            return d > 0;
        }
    };
    void norm()
    {
        Point mi = p[0];
        for(int i = 1;i < n;i++)
            mi = min(mi,p[i]);
        sort(p,p+n,cmp(mi));
    }
    void getconvex(polygon &convex)
    {
        sort(p,p+n);
        convex.n = n;
        for(int i = 0;i < min(n,2);i++)
        {
            convex.p[i] = p[i];
        }
        if(n <= 2)return;
        int &top = convex.n;
        top = 1;
        for(int i = 2;i < n;i++)
        {
            while(top && ((convex.p[top]-p[i])^(convex.p[top-1]-p[i]))<=0)
                top--;
            convex.p[++top] = p[i];
        }
        int temp = top;
        convex.p[++top] = p[n-2];
        for(int i = n-3;i >= 0;i--)
        {
            while(top != temp && ((convex.p[top]-p[i])^(convex.p[top-1]-p[i]))<=0)
                top--;
            convex.p[++top] = p[i];
        }
        convex.norm();
    }
    //判断点和任意多边形的关系
    //3 点上
    //2 边上
    //1 内部
    //0 外部
    int relation(Point q)
    {
        for(int i = 0;i < n;i++)
        {
            if(p[i] == q)return 3;
        }
        for(int i = 0;i < n;i++)
        {
            if(Line(p[i],p[(i+1)%n]).pointonseg(q))return 2;
        }
        int cnt = 0;
        for(int i = 0;i < n;i++)
        {
            int j = (i+1)%n;
            int k = ((q-p[j])^(p[i]-p[j]));
            int u = (p[i].y-q.y);
            int v = (p[j].y-q.y);
            if(k > 0 && u < 0 && v >= 0)cnt++;
            if(k < 0 && v < 0 && u >= 0)cnt--;
        }
        return cnt != 0;
    }
};
Point mines[maxp];
Point mines2[maxp];
int cnt;
polygon A,B;
bool check(Line v)
{
    for(int i = 0;i < cnt;i++)
        if(v.relation(mines2[i]) != 1)
            return false;
    return true;
}
int a[110][110];
int b[110][110];
int c[110][110];
int solve(polygon A)
{
    int n = A.n;
    memset(a,0,sizeof(a));
    for(int i = 0;i < n;i++)
        for(int j = 0;j < n;j++)
            if(i != j && check(Line(A.p[i],A.p[j])))
                a[i][j] = 1;
    for(int i = 0;i < n;i++)
        for(int j = 0;j < n;j++)
            b[i][j] = a[i][j];
    for(int s = 2;s <= n;s++)
    {
        for(int i = 0;i < n;i++)
            for(int j = 0;j < n;j++)
                c[i][j] = b[i][j];
        memset(b,0,sizeof(b));
        for(int i = 0;i < n;i++)
            for(int j = 0;j < n;j++)
                for(int k = 0; k < n;k++)
                    if(c[i][k] && a[k][j])
                        b[i][j] = 1;
        for(int i = 0;i < n;i++)
            if(b[i][i])
                return s;
    }
    return -1;
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int T;
    int n,m,g,p;
    int iCase = 0;
    scanf("%d",&T);
    while(T--)
    {
        iCase++;
        scanf("%d%d%d%d",&n,&m,&g,&p);
        A.input(n);
        for(int i = 0;i < m;i++)
            mines[i].input();
        A.getconvex(B);
        cnt = 0;
        //找出在凸包内的
        for(int i = 0;i < m;i++)
            if(B.relation(mines[i]) == 1)
                mines2[cnt++] = mines[i];
        int ans1 = (m-cnt)*g;
        int tmp = 0;
        if(cnt)tmp = solve(A);
        printf("Case %d: %d\n",iCase,ans1 + tmp*p);
    }
    return 0;
}