洛谷 P2279 03湖南 消防局的设立

2016-05-30 16:18:17

题目链接: 洛谷 P2279 03湖南 消防局的设立

题目大意:

　　给定一棵树,选定一个节点的集合,使得所有点都与集合中的点的距离在2以内

解法1:

　　贪心

　　首先DFS转化为有根树,每次取最深节点的爷爷进入集合

 //消防局的设立 03湖南
 //贪心
 #include<stdio.h>
 #include<algorithm>
 using namespace std;
 const int maxn=;
 struct node
 {
     int deep;
     int id;
 };
 node f[maxn];
 int marked[maxn];
 int father[maxn];
 struct edge
 {
     int to;
     int next;
     edge(){}
     edge(int to,int next):to(to),next(next){}
 };
 edge n[maxn*];
 int head[maxn];
 int cnt;
 int N;
 int ans;
 void insert(int x,int y)
 {
     n[++cnt]=edge(y,head[x]);
     head[x]=cnt;
     n[++cnt]=edge(x,head[y]);
     head[y]=cnt;
     return ;
 }
 void DFS(int x,int depth)
 {
     f[x].deep=depth;
     for(int i=head[x];i;i=n[i].next)
     {
         if(n[i].to!=father[x])
         {
             father[n[i].to]=x;
             DFS(n[i].to,depth+);
         }
     }
     return ;
 }
 bool comp(node a,node b)
 {
     return a.deep>b.deep;
 }
 void clear(int x,int len)
 {
     marked[x]=;
     if(len==)return ;
     for(int i=head[x];i;i=n[i].next)
     {
         clear(n[i].to,len+);
     }
     return ;
 }
 int main()
 {
     scanf("%d",&N);
     for(int i=;i<=N;i++)
     {
         int x;
         scanf("%d",&x);
         insert(i,x);
     }
     for(int i=;i<=N;i++)
     {
         f[i].id=i;
     }
     father[]=;
     DFS(,);
     sort(f+,f+N+,comp);
     for(int i=;i<=N;i++)
     {
         if(marked[f[i].id]==)
         {
             clear(father[father[f[i].id]],);
             ans++;
         }
     }
     printf("%d",ans);
 }

解法2:

　　恶心的树状动归

　　方程很多,看了好多题解才有了一点点想法

　　　　DP[x][len]就表示以x为根的子树中距离根为len的点全部建立消防局的最小消耗数

　　　　　　同时我们规定在某一个点建立消防局的条件是这个点所染的点的子树(包括他自己)不存在不合法的点

　　　　为了方便:我们将DP[x][len]改写为min(DP[x][0.1.2.....len]),son表示x节点的儿子

　　　　现在来分析DP[x][0]

　　　　　　在根节点染色,最多影响到根节点的孙子.而要使孙子以下的节点都被染色,应该将3代,4代或者5代染色(即min(DP[son][2],DP[son][3],DP[son][4]))

　　　　　　又因为我们之前为了方便将DP[x][len]改写为了最小值,所以直接累加即可

　　　　　　　　(其中DP[son][0]和DP[son][1]并不会影响结果,因为浅的节点本身要染的点一定大于等于深的节点)

　　　　再来分析DP[x][3],DP[x][4](个人觉得这两个数组更像是用来辅助更新的,好像不应该放在DP数组里)

　　　　　　这个比较好理解,根的3代就是根的儿子的2代,DP[x][3]=sigma(DP[son][2]);

　　　　　　同样也容易得到,根的4代就是根的儿子的3代,DP[x][4]=sigma(DP[son][3]);

　　　　最后来看DP[x][2],DP[x][1];

　　　　　　DP[x][2],不难发现,我们选择一个孙子,根节点就会合法,但是根节点的其他侧枝就不一定了

　　　　　　　　所以我们优先将所有侧枝以最佳方案染掉,sigma(DP[son][2]),再选择孙子(+DP[son][1]),并去掉重复统计的数据(-DP[son][2]);

　　　　　　DP[x][1],不难发现,我们选择一个儿子,根节点和这个节点的兄弟就都合法了,但是根节点其他孙子们就不一定了

　　　　　　　　所以我们优先将所有的孙子们以最佳方案染掉,sigma(DP[son][3]),再选择儿子(+DP[son][0]),并去掉重复统计的数据(-DP[son][3]);

　　综上:方程为

　　　　DP[x][0]=sigma(DP[son][4])+1(本身建立的方案);

　　　　DP[x][1]=sigma(DP[son][3])-min(DP[son][3]-DP[son][0]);

　　　　DP[x][2]=sigma(DP[son][2])-min(DP[son][2]-DP[son][1]);

　　　　DP[x][3]=sigma(DP[son][2]);

　　　　DP[x][4]=sigma(DP[son][3]);

 //消防局的设立 (03湖南)
 //树状动归
 #include<stdio.h>
 #include<algorithm>
 using namespace std;
 const int maxn=;
 struct edge
 {
     int to;
     int next;
     edge(){}
     edge(int to,int next):to(to),next(next){}
 };
 edge n[maxn*];
 int N;
 int DP[maxn][];
 int cnt;
 int head[maxn];
 int father[maxn];
 void insert(int x,int y)
 {
     n[++cnt]=edge(x,head[y]);
     head[y]=cnt;
     n[++cnt]=edge(y,head[x]);
     head[x]=cnt;
     return ;
 }
 void DFS(int x)
 {
     DP[x][]=1e8;
     DP[x][]=1e8;
     for(int i=head[x];i;i=n[i].next)
     {
         if(n[i].to==father[x])continue;
         father[n[i].to]=x;
         DFS(n[i].to);
         DP[x][]+=DP[n[i].to][];
         DP[x][]+=DP[n[i].to][];
         DP[x][]+=DP[n[i].to][];
     }
     DP[x][]++;
     for(int i=head[x];i;i=n[i].next)
     {
         if(n[i].to==father[x])continue;
         DP[x][]=min(DP[x][],DP[x][]-DP[n[i].to][]+DP[n[i].to][]);
         DP[x][]=min(DP[x][],DP[x][]-DP[n[i].to][]+DP[n[i].to][]);
     }
     for(int i=;i<=;i++)
     {
         DP[x][i]=min(DP[x][i],DP[x][i-]);
     }
     return ;
 }
 int main()
 {
     scanf("%d",&N);
     for(int i=;i<=N;i++)
     {
         int x;
         scanf("%d",&x);
         insert(i,x);
     }
     DFS();
     printf("%d",DP[][]);
 }