[JZOJ5094]鴿子

題目大意

給定平面上的n 個關鍵點，以及m 個待選點。
你要從m 個待選點中選擇儘量少的點來觀察所有的關鍵點。一個關鍵點能被觀察到，當且僅當它在一個選擇了的待選點上，或者在兩個選擇了的待選點的線段上，抑或是在三個待選點圍成的三角形內。
輸出最少要選的待選點數，無解輸出−1 。

n≤105,m≤500 ，座標絕對值不超過109

---

題目分析

顯然，我選擇一些待選點，它們能觀察到到的區域就是它們的凸包。
那麼我現在相當於要選擇儘量少的點，使得它們的凸包包含了所有關鍵點。
利用凸的定義進一步轉化：選擇儘量少的點，使得它們的凸包包含了關鍵點的凸包。
這個怎麼求呢？考慮兩個待選點之間的有向邊，如果凸包在這條有向邊的逆時針方向，我就連這條邊。那麼最後我對這個圖求一個長度最小的簡單環就是答案了。這個可以使用Floyd 在O(n3) 的時間複雜度內解決。
現在考慮怎麼連邊，枚舉兩個待選點然後在凸包上判斷好像不太可做。那麼考慮枚舉一個待選點，然後O(n) 求出其在凸包上的兩條切線，就可以得出有向邊的可行角度區間，接着再枚舉另一個待選點直接叉積判斷就好了。
時間複雜度O(m3+nm+nlogn) 。

---

代碼實現

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cfloat>
#include <cctype>
#include <cmath>

using namespace std;

int read()
{
    int x=0,f=1;
    char ch=getchar();
    while (!isdigit(ch)) f=ch=='-'?-1:f,ch=getchar();
    while (isdigit(ch)) x=x*10+ch-'0',ch=getchar();
    return x*f;
}

typedef long long db;

const int N=100050;
const int M=505;

struct P
{
    db x,y;

    P(db x_=0.,db y_=0.){x=x_,y=y_;}

    P operator+(P const p)const{return P(x+p.x,y+p.y);}
    P operator-(P const p)const{return P(x-p.x,y-p.y);}
    P operator*(db const k)const{return P(x*k,y*k);}

    db operator^(P const p)const{return x*p.y-y*p.x;}
}mon[M],pts[N];

struct poly
{
    P p[N];
    int tot;

    bool inside(P pts)
    {
        bool ret=0;
        for (int i=1;i<tot;++i) ret^=(p[i].y-pts.y>=0&&p[i+1].y-pts.y<0)||(p[i].y-pts.y<0&&p[i+1].y-pts.y>=0);
        return ret;
    }
}ch;

bool cmp1(int x,int y){return pts[y].x-pts[x].x>0||pts[x].x==pts[y].x&&pts[y].y-pts[x].y>0;}
bool cmp2(int x,int y){return pts[x].x-pts[y].x>0||pts[x].x==pts[y].x&&pts[x].y-pts[y].y>0;}

int kth[N],stack[N];
bool able[M][M];
int f[M][M];
int n,m,ans,top;

void update(int &x,int y){x=x<y?x:y;}

void Convex_Hull()
{
    for (int i=1;i<=n;++i) kth[i]=i;
    sort(kth+1,kth+1+n,cmp1);
    top=0;
    for (int i=1;i<=n;++i)
    {
        P p=pts[kth[i]];
        for (;top>1&&((pts[stack[top]]-pts[stack[top-1]])^(p-pts[stack[top-1]]))<=0;--top);
        stack[++top]=kth[i];
    }
    for (int i=1;i<=top;++i) ch.p[++ch.tot]=pts[stack[i]];
    for (int i=1;i<=n;++i) kth[i]=i;
    sort(kth+1,kth+1+n,cmp2);
    top=0;
    for (int i=1;i<=n;++i)
    {
        P p=pts[kth[i]];
        for (;top>1&&((pts[stack[top]]-pts[stack[top-1]])^(p-pts[stack[top-1]]))<=0;--top);
        stack[++top]=kth[i];
    }
    for (int i=2;i<=top;++i) ch.p[++ch.tot]=pts[stack[i]];
}

void pre()
{
    for (int i=1;i<=m;++i)
    {
        if (ch.inside(mon[i])) continue;
        P v1=ch.p[1]-mon[i],v2=ch.p[1]-mon[i];
        for (int j=2;j<=ch.tot;++j)
        {
            P v=ch.p[j]-mon[i];
            if (!v.x&&!v.y) continue;
            if (!v1.x&&!v1.y||(v^v1)>0) v1=v;
            if (!v2.x&&!v2.y||(v2^v)>0) v2=v;
        }
        v2=v2*(-1.0);
        for (int j=1;j<=m;++j)
        {
            P v=mon[j]-mon[i];
            if (i!=j) able[i][j]=(v^v1)>=0&&(v2^v)>=0;
        }
    }
}

void dp()
{
    for (int i=1;i<=m;++i)
        for (int j=1;j<=m;++j)
            f[i][j]=m*2;
    for (int i=1;i<=m;++i)
        for (int j=1;j<=m;++j)
            if (able[i][j]) f[i][j]=1;
    for (int k=1;k<=m;++k)
        for (int i=1;i<=m;++i)
            for (int j=1;j<=m;++j)
                update(f[i][j],f[i][k]+f[k][j]);
    ans=m*2;
    for (int i=1;i<=m;++i) update(ans,f[i][i]);
    if (ans==m*2) ans=-1;
}

int main()
{
    freopen("pigeon.in","r",stdin),freopen("pigeon.out","w",stdout);
    n=read(),m=read();
    for (int i=1,x,y;i<=n;++i) x=read(),y=read(),pts[i]=P(x,y);
    Convex_Hull();
    for (int i=1,x,y;i<=m;++i) x=read(),y=read(),mon[i]=P(x,y);
    pre(),dp(),printf("%d\n",ans);
    fclose(stdin),fclose(stdout);
    return 0;
}