2015 Multi-University Training Contest 1 hdu 5290 Bombing plan

Bombing plan

Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 416    Accepted Submission(s): 96

Problem Description

Kingdom Y is in the war with kingdom X. Kingdom X consists of N cities,there are N-1 bidirectional roads which are all 1 long ，each of them connect a pair of cities,the N cities are all connect by the N-1 bidirectional.People can travel through the roads.

Now kingdom Y is going to bomb kingdom X. Every city of kingdom X has its own value W. If city i was to be bombed, then all the cities that lie within the distance W(i) from city i would be destroyed as well. The king of kingdom Y wants to know the minimum bombing time that can destroy all the cities in kingdom X. Could you help him?

 

Input

There are multiple test cases. Please process till EOF.
In each test case: 
First line: an integer n(n<=10^5) indicating the number of city
Second line:contain n numbers w[i](0<=w[i]<=100) ,indicating that the value of city[i],
Next n - 1 lines: each contains two numbers ui and vi, (1 ≤ ui,vi<=n), indicates that there’s one road connecting city ui and vi.

 

Output

For each case,output one number, denotes the minimum number of bombing times.

 

Sample Input

5

1 1 1 1 1

1 2

2 3

3 4

4 5

 

Sample Output

2

 

Author

FZUACM

 

Source

2015 Multi-University Training Contest 1

 

解题：dp

令F[i][j]为以i为根的子树，能向子树外拓展j个节点最少需要炸毁几个城市。G[i][j]为以i为根的子树，子树内有节点未被炸毁，且距离根为j最少需要炸毁几个城市。 
转移方程: 
不炸毁u点 

 

$F[u][j] = F[v][j+1] + min(F[k][0\dots j+1,G[k][0\dots j])$

$G[u][0] = F[u][0]$

$G[u][j] = G[v][j-1] + min(F[k][0\dots j-1],G[k][0\dots j-1])$

 

炸毁u点

$F[u][w[u]] = 1 + min(F[v][0\dots w[u]+1],G[v][w[u]])$

 

 

 #include <bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 struct arc {
     int to,next;
     arc(int x = ,int y = -) {
         to = x;
         next = y;
     }
 } e[maxn<<];
 int head[maxn],d[maxn],n,tot;
 void add(int u,int v) {
     e[tot] = arc(v,head[u]);
     head[u] = tot++;
     e[tot] = arc(u,head[v]);
     head[v] = tot++;
 }
 int q[maxn],p[maxn],de[maxn],hd,tl;
 int F[maxn][],G[maxn][],A[maxn][],B[maxn][];
 int main() {
     int u,v,a,b;
     while(~scanf("%d",&n)) {
         for(int i = ; i <= n; ++i)
             scanf("%d",d+i);
         tot = ;
         memset(head,-,sizeof head);
         memset(G,-,sizeof G);
         memset(F,-,sizeof F);
         memset(A,-,sizeof A);
         memset(B,-,sizeof B);
         for(int i = ; i < n; ++i) {
             scanf("%d%d",&u,&v);
             add(u,v);
         }
         p[q[hd = tl = ] = ] = -;
         while(hd <= tl) {
             de[u = q[hd++]] = ;
             for(int i = head[u]; ~i; i = e[i].next) {
                 if(e[i].to != p[u]) {
                     p[e[i].to] = u;
                     q[++tl] = e[i].to;
                 }
             }
         }
         while(tl >= ) {
             v = q[tl--];
             if(p[v] >= ) de[p[v]] = max(de[p[v]],de[v]+);
             if(!de[v]) {
                 if(d[v] >= ) {
                     F[v][d[v]] = ;
                     for(int i = ; i < d[v]; ++i) A[v][i] = -;
                     for(int i = d[v]; i < ; ++i) A[v][i] = ;
                 }
                 G[v][] = ;
                 for(int i = ; i <= ; ++i) B[v][i] = ;
                 continue;
             }

             for(int i = ; i <= min(,de[v]); ++i) {
                 G[v][i] = ;
                 for(int j = head[v]; ~j; j = e[j].next) {
                     u = e[j].to;
                     if(u == p[v]) continue;
                     a = B[u][i-];
                     b = A[u][];
                     if(a == - && b == -) {
                         G[v][i] = -;
                         break;
                     }
                     if(a == -) a = maxn;
                     if(b == -) b = maxn;
                     G[v][i] += min(a,b);
                 }
                 if(G[v][i] == -) break;
             }

             if(d[v] >= ) {
                 F[v][d[v]] = ;
                 for(int i = head[v]; ~i; i = e[i].next) {
                     u = e[i].to;
                     if(u == p[v]) continue;
                     a = A[u][];
                     b = -;
                     if(d[v] > ) b = B[u][d[v]-];
                     if(a == - && b == -) {
                         F[v][d[v]] = -;
                         break;
                     }
                     if(a == -) a = maxn;
                     if(b == -) b = maxn;
                     F[v][d[v]] += min(a,b);
                 }
             }

             for(int i = head[v]; ~i; i = e[i].next) {
                 u = e[i].to;
                 if(u == p[v]) continue;
                 for(int j = ; j <= ; ++j)
                     if(F[u][j] != -) {
                         int tmp = ;
                         for(int k = head[v]; ~k; k = e[k].next) {
                             if(e[k].to != u && e[k].to != p[v]) {
                                 a = A[e[k].to][];
                                 b = -;
                                 if(j -  >= ) b = B[e[k].to][j-];
                                 if(a == - && b == -) {
                                     tmp = -;
                                     break;
                                 }
                                 if(a == -) a = maxn;
                                 if(b == -) b = maxn;
                                 tmp += min(a,b);
                             }
                         }
                         if(tmp != - && (F[v][j-] == - || F[v][j-] > F[u][j] + tmp))
                             F[v][j-] = F[u][j] + tmp;
                     }
             }
             A[v][] = F[v][];
             B[v][] = G[v][];
             for(int i = ; i <= ; ++i) {
                 A[v][i] = A[v][i-];
                 if(F[v][i] != - && (A[v][i] == - || A[v][i] > F[v][i]))
                     A[v][i] = F[v][i];
                 B[v][i] = B[v][i-];
                 if(G[v][i] != - && (B[v][i] == - || B[v][i] > G[v][i]))
                     B[v][i] = G[v][i];
             }
         }
         int ret = -;
         for(int i = ; i <= ; ++i)
             if(F[][i] != - && (ret == - || ret > F[][i]))
                 ret = F[][i];
         printf("%d\n",ret);
     }
     return ;
 }
 /*
 5
 1 1 1 1 1
 1 2
 2 3
 3 4
 4 5
 */