[DLX重复覆盖] hdu 4735 Little Wish~ lyrical step~

题意:

在一棵树上有n个节点,n-1条边,每条边有距离。

每个节点会给你原来是男孩还是女孩。

问最少要交换多少次,使得每个女孩都能被保护到。

保护到的条件是女孩和最近的男孩的距离小于等于D

思路:

首先要求一下mp[i][j],就是任意两个点之间的距离

这个方法随意都可以的。

因为男孩只能放在树上,所以行为树,列也为树

这样每次求出的cnt就是每次最多要有多少个男的在指定的树上

这时候就需要剪枝了

剪枝就是

1、如果x+h()>boy 需要男生数超过总的男生数 return

2、每次遍历一遍当前的ans[i],sum=Σnode[ans[i]],sum是已经确定有多少个男生不用换,如果x-sum>cnt,x-sum是最好的情况需要换几次,如果比cnt大就返回。

代码:

#include"stdio.h"
#include"algorithm"
#include"string.h"
#include"iostream"
#include"queue"
#include"map"
#include"vector"
#include"string"
using namespace std;
#define N 55*55*(55+55)
#define RN 55*55
#define CN 55+55
int haha,mp[55][55],node[55];
int boy;
struct DLX
{
    int n,m,C;
    int U[N],D[N],L[N],R[N],Row[N],Col[N];
    int H[RN],S[CN],cnt,ans[RN];
    void init(int _n,int _m)
    {
        n=_n;
        m=_m;
        for(int i=0; i<=m; i++)
        {
            S[i]=0;
            U[i]=D[i]=i;
            L[i]=(i==0?m:i-1);
            R[i]=(i==m?0:i+1);
        }
        C=m;
        for(int i=1; i<=n; i++) H[i]=-1;
    }
    void link(int x,int y)
    {
        C++;
        Row[C]=x;
        Col[C]=y;
        S[y]++;
        U[C]=U[y];
        D[C]=y;
        D[U[y]]=C;
        U[y]=C;
        if(H[x]==-1) H[x]=L[C]=R[C]=C;
        else
        {
            L[C]=L[H[x]];
            R[C]=H[x];
            R[L[H[x]]]=C;
            L[H[x]]=C;
        }
    }
    void del(int x)
    {
        for(int i=D[x]; i!=x; i=D[i])
        {
            R[L[i]]=R[i];
            L[R[i]]=L[i];
        }
    }
    void rec(int x)
    {
        for(int i=U[x]; i!=x; i=U[i])
        {
            R[L[i]]=i;
            L[R[i]]=i;
        }
    }
    int used[CN];
    int h()
    {
        int sum=0;
        for(int i=R[0]; i!=0; i=R[i]) used[i]=0;
        for(int i=R[0]; i!=0; i=R[i])
        {
            if(used[i]==0)
            {
                sum++;
                used[i]=1;
                for(int j=D[i]; j!=i; j=D[j]) for(int k=R[j]; k!=j; k=R[k]) used[Col[k]]=1;
            }
        }
        return sum;
    }
    void dance(int x)
    {
        if(x+h()>boy ) return ;

        int sum=0;
        for(int i=0; i<x; i++) sum+=node[ans[i]];
        if(x-sum>=cnt) return ;
        if(R[0]==0)
        {
            cnt=min(cnt,x-sum);
            return ;
        }
        int now=R[0];
        for(int i=R[0]; i!=0; i=R[i])
        {
            if(S[i]<S[now])
                now=i;
        }
        for(int i=D[now]; i!=now; i=D[i])
        {
            ans[x]=Row[i];
            del(i);
            for(int j=R[i]; j!=i; j=R[j]) del(j);
            dance(x+1);
            for(int j=L[i]; j!=i; j=L[j]) rec(j);
            rec(i);
        }
        return ;
    }
} dlx;
struct noe
{
    int to,next,v;
} edge[8000];
struct Tarjan
{
    int tot,n,m;
    int f[4000],x[4000],y[4000],z[4000],dis[4000],vis[4000],head[4000];
    void add_edge(int a,int b,int c)
    {
        edge[tot].to=b;
        edge[tot].next=head[a];
        edge[tot].v=c;
        head[a]=tot++;
    }

    int fin(int x)
    {
        if (f[x]!=x)
            return f[x]=fin(f[x]);
        return f[x];
    }
    void tarjan(int w)
    {
        int i;
        vis[w]=1;
        f[w]=w;
        for (i=1; i<=m; i++)
        {
            if (vis[y[i]] && x[i]==w) z[i]=fin(y[i]);
            if (vis[x[i]] && y[i]==w) z[i]=fin(x[i]);

        }

        for (i=head[w]; i!=-1; i=edge[i].next)
            if (vis[edge[i].to]==0)
            {
                dis[edge[i].to]=dis[w]+edge[i].v;
                tarjan(edge[i].to);
                f[edge[i].to]=w;
            }
    }
    void make(int _n)
    {
        n=_n;
        m=n*n;
        tot=0;
        memset(head,-1,sizeof(head));
        for(int i=1; i<n; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        memset(z,0,sizeof(z));
        memset(x,0,sizeof(x));
        memset(y,0,sizeof(y));
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                int tep=(i-1)*n+j;
                x[tep]=i;
                y[tep]=j;
            }
        }
        dis[1]=0;
        memset(vis,0,sizeof(vis));
        tarjan(1);
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                int tep=(i-1)*n+j;
                mp[i][j]=mp[j][i]=dis[x[tep]]+dis[y[tep]]-2*dis[z[tep]];
            }
        }
    }
} go;

int main()
{
    int t,cas=1;
    cin>>t;
    while(t--)
    {
        int n,d;
        scanf("%d%d",&n,&d);
        boy=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&node[i]);
            if(node[i]==1) boy++;
        }
        go.make(n);
        dlx.init(n,n);
        for(int j=1; j<=n; j++)
        {
            for(int k=1; k<=n; k++)
            {
                if(mp[j][k]<=d) dlx.link(j,k);
            }
        }
        dlx.cnt=999;
        dlx.dance(0);
        printf("Case #%d: %d\n",cas++,dlx.cnt==999?-1:dlx.cnt);
    }
    return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-06 03:48:37

[DLX重复覆盖] hdu 4735 Little Wish~ lyrical step~的相关文章

hdu 4735 Little Wish~ lyrical step~(DLX)

题目链接:hdu 4735 Little Wish~ lyrical step~ 题意: 有n个节点的树,每个节点可能是男孩,可能是女孩,节点之间有距离,现在要让所有的女孩周围距离D之内有男孩,问最小需要交换多少次男孩和女孩的位置. 题解: 把每个节点对小于D距离的全部link起来,然后DLX爆艹,意义就是选n个节点去覆盖全部节点,如果这个节点是女生,那么就是要替换的点.然后不断更新答案. 1 #include<bits/stdc++.h> 2 #define F(i,a,b) for(int

[DLX重复覆盖] hdu 2828 Lamp

题意: 有N个灯M个开关 每个灯的ON和OFF状态都能控制一个灯是否亮 给出N行,代表对于每个灯 哪些开关的哪个状态可以使得第i个灯亮 思路: 这里需要注意一个问题 如果开关1的ON 状态和开关2的ON状态能使得1号灯亮 那么开关1.2同时处于ON的时候 1号灯也是亮的.意思就是只要有一个开关使得灯亮,灯就亮了. 简单的DLX 重复覆盖 行为每个开关的两个状态2*m行,列为n个灯 在搜索的同时标记一下哪个开关被用过了 那么另一个状态也不能用了 代码: #include"stdio.h"

HDU 4735 Little Wish~ lyrical step~(DLX , 重复覆盖)

解题思路: DLX 的模板题,重复覆盖. #include <stdio.h> #include <string.h> #include <iostream> #include <algorithm> #include <vector> #include <queue> #include <set> #include <map> #include <string> #include <math

[DLX重复覆盖] hdu 3498 whosyourdaddy

题意: 给N个怪,M个关系. 每个关系代表a和b是邻居. 然后问每次攻击你可以攻击一个怪以及它的全部邻居 问最少需要几次攻击能把怪全部杀死. 思路: 怪为行和列,然后对面每个怪的邻居都是这个怪的列建图. 也是比较裸的重复覆盖. 代码: #include"cstdlib" #include"cstdio" #include"cstring" #include"cmath" #include"queue" #i

[DLX重复覆盖] hdu 3656 Fire station

题意: N个点,再点上建M个消防站. 问消防站到每个点的最大距离的最小是多少. 思路: DLX直接二分判断TLE了. 这时候一个很巧妙的思路 我们求的距离一定是两个点之间的距离 因此我们把距离都求一遍排序一下. 然后用下标二分  这样就AC了. 代码: #include"stdio.h" #include"algorithm" #include"string.h" #include"iostream" #include&quo

HDU 5046 Airport(DLX重复覆盖)

HDU 5046 Airport 题目链接 题意:给定一些机场,要求选出K个机场,使得其他机场到其他机场的最大值最小 思路:二分+DLX重复覆盖去判断即可 代码: #include <cstdio> #include <cstring> using namespace std; const int MAXNODE = 4005; const int MAXM = 65; const int MAXN = 65; const int INF = 0x3f3f3f3f; int K;

[ACM] HDU 2295 Radar (二分+DLX 重复覆盖)

Radar Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2593    Accepted Submission(s): 1012 Problem Description N cities of the Java Kingdom need to be covered by radars for being in a state of

FZU 1686 神龙的难题(DLX重复覆盖)

FZU 1686 神龙的难题 题目链接 题意:中文题 思路:每一个1看成列,每个位置作为左上角的矩阵看成行,dlx重复覆盖即可 代码: #include <cstdio> #include <cstring> using namespace std; const int MAXNODE = 66666; const int INF = 0x3f3f3f3f; const int MAXM = 230; const int MAXN = 230; int K; struct DLX

FZU 1686 神龙的难题 DLX重复覆盖

DLX重复覆盖: 需要一个A*函数剪支 Problem 1686 神龙的难题 Accept: 462    Submit: 1401 Time Limit: 1000 mSec    Memory Limit : 32768 KB  Problem Description 这是个剑与魔法的世界.英雄和魔物同在,动荡和安定并存.但总的来说,库尔特王国是个安宁的国家,人民安居乐业,魔物也比较少.但是.总有一些魔物不时会进入城市附近,干扰人民的生活.就要有一些人出来守护居民们不被魔物侵害.魔法使艾米莉