BZOJ4622 [NOI 2003] 智破连环阵

题面

题意

有n个点需要被覆盖，你有m个半径为k的圆，每个圆覆盖的点是圆内（包括边界）编号连续的一些点，且每个圆只能使用一次，问至少要选择几个圆才能覆盖所有点。

做法

这个问题可以拆成两个子问题：
1.将n个点根据编号拆成k段。
2.判断m个圆与这k段的最大匹配是否是k。
可以发现第二个子问题可以用二分图的最大匹配轻松求解，而对于第一个子问题只能用搜索。
但是搜索的复杂度最劣为O（2^m），因此要加入一些剪枝：
1.贪心：如果圆a覆盖了点i且包含点i+1，那么一定存在一组最优解中a覆盖点i+1。
2.估价函数：考虑圆可以重复选择，那么我们就可以用dp求出后面几个点至少需要几个圆覆盖，并以此来进行最优性剪枝。
然后一边dfs，一边匹配判断此时的分组是否开行即可。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#define N 110
using namespace std;

int n,m,k,mx[N][N],ans,need[N],pp[N];
bool ok[N][N],have[N][N],mm[N][N],vis[N];
struct Node
{
    int x,y;
} wq[N],zd[N];

inline int len(Node u,Node v)
{
    return (u.x-v.x)*(u.x-v.x)+(u.y-v.y)*(u.y-v.y);
}

bool find(int u)
{
    int i,j;
    for(i=1; i<=m; i++)
    {
        if(vis[i] || !mm[u][i]) continue;
        vis[i]=1;
        if(!pp[i] || find(pp[i]))
        {
            pp[i]=u;
            return 1;
        }
    }
    return 0;
}

void dfs(int now,int sum)
{
    if(need[now]+sum>=ans) return;
    if(now>n)
    {
        ans=sum;
        return;
    }
    int i,j,cle[N],top;
    for(i=n; i>=now; i--)
    {
        if(!have[now][i]) continue;
        top=0;
        for(j=1; j<=m; j++)
        {
            if(mx[j][now]==i)
            {
                mm[sum+1][j]=1;
                cle[++top]=j;
            }
        }
        memset(vis,0,sizeof(vis));
        if(find(sum+1)) dfs(i+1,sum+1);
        for(j=1; j<=top; j++)
        {
            mm[sum+1][cle[j]]=0;
            if(pp[cle[j]]==sum+1) pp[cle[j]]=0;
        }
    }
}

int main()
{
    memset(need,0x3f,sizeof(need));
    int i,j;
    cin>>n>>m>>k;
    k*=k;
    for(i=1; i<=n; i++) scanf("%d%d",&wq[i].x,&wq[i].y);
    for(i=1; i<=m; i++) scanf("%d%d",&zd[i].x,&zd[i].y);
    need[n+1]=0;
    for(j=n; j>=1; j--)
    {
        for(i=1; i<=m; i++)
        {
            if(len(zd[i],wq[j])<=k)
            {
                ok[i][j]=1;
                ok[i][j+1]?mx[i][j]=mx[i][j+1]:mx[i][j]=j;
                have[j][mx[i][j]]=1;
                need[j]=min(need[j],need[mx[i][j]+1]+1);
            }
        }
    }
    ans=min(n,m);
    dfs(1,0);
    cout<<ans;
}