HDU 5682 zxa and leaf

zxa and leaf

Time Limit: 5000/2500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 341    Accepted Submission(s): 116

Problem Description

zxa have an unrooted tree with n nodes, including (n−1) undirected edges, whose nodes are numbered from 1 to n . The degree of each node is defined as the number of the edges connected to it, and each node whose degree is 1 is defined as the leaf node of the tree.

zxa wanna set each node's beautiful level, which must be a positive integer. His unrooted tree has m(1≤m≤n) leaf nodes, k(1≤k≤m) leaf nodes of which have already been setted their beautiful levels, so that zxa only needs to set the other nodes' beautiful levels.

zxa is interested to know, assuming that the ugly level of each edge is defined as the absolute difference of the beautiful levels between two nodes connected by this edge, and the ugly level of the tree is the maximum of the ugly levels of **all the edges on this tree**, then what is the minimum possible ugly level of the tree, can you help him?

 

Input

The first line contains an positive integer T , represents there are T test cases.

For each test case:

The first line contains two positive integers n and k , represent the tree has n nodes, k leaf nodes of which have already been setted their beautiful levels.

The next (n−1) lines, each line contains two distinct positive integers u and v , repersent there is an undirected edge between node u and node v .

The next k lines, each lines contains two positive integers u and w , repersent node u is a leaf node, whose beautiful level is w .

There is a blank between each integer with no other extra space in one line.

It's guaranteed that the input edges constitute a tree.

1≤T≤10,2≤n≤5⋅104,1≤k≤n,1≤u,v≤n,1≤w≤109

 

Output

For each test case, output in one line a non-negative integer, repersents the minimum possible ugly level of the tree.

 

Sample Input

  
  

   
   2
3 2
1 2
1 3
2 4
3 9
6 2
1 2
1 3
1 4
2 5
2 6
3 6
5 9
  
  

 

Sample Output

  
  

   
   3
1


   
   

    
    

     
     Hint
    
    
If you need a larger stack size, please use #pragma comment(linker, "/STACK:102400000,102400000") and submit your solution using C++.

   
   
   
    
  
  

 

Source

BestCoder Round #83

 

Recommend

wange2014   |   We have carefully selected several similar problems for you:   5717  5716  5715  5714  5713 

题意就是告诉你某一个树，某一些点的权值已经确定，现在定义不同u，v并且相连的难看度是他们权值差的绝对值，问这个权值最小是什么多少。

首先二分答案，然后确定一个根，遍历整个树，去判断是否都满足答案。

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int M=5*1e4+1000;
int ind[M],val[M],idmax[M],idmin[M];
vector<int>v[M];
inline void getmax(int &a,int b)
{
    if(a<=b)
        a=b;
}
inline void getmin(int &a,int b)
{
    if(a>=b)
        a=b;
}
int dfs(int ans,int x,int fa)
{
    idmax[x]=1e9;
    idmin[x]=-1e9;
    if(val[x])
        idmax[x]=idmin[x]=val[x];
    for(int i=v[x].size()-1; i>=0; i--)
    {
        int kid=v[x][i];
        if(kid==fa)
            continue;
        if(!dfs(ans,kid,x))
            return 0;
        int min1=idmin[kid]-ans;
        int max1=idmax[kid]+ans;
        getmax(idmin[x],min1);
        getmin(idmax[x],max1);
    }
    return idmin[x]<=idmax[x];
}
bool check(int ans,int root)
{
    return dfs(ans,root,0);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,k;
        for(int i=1; i<=M; i++)
        {
            ind[i]=0;
            val[i]=0;
            v[i].clear();
        }
        cin>>n>>k;
        for(int i=1; i<=n-1; i++)
        {
            int x,y;
            cin>>x>>y;
            v[x].push_back(y);
            v[y].push_back(x);
            ind[x]++;
            ind[y]++;
        }
        for(int i=1; i<=k; i++)
        {
            int x,y;
            cin>>x>>y;
            val[x]=y;
        }
        int root;
        if(n==2)
            root=1;
        else
            for(int i=1; i<=n; i++)
                if(ind[i]!=1)
                {
                    root=i;
                    break;
                }
        int l=0,r=1e9;
        while(l<r)
        {
            int mid=(l+r)>>1;
            if(check(mid,root))
                r=mid;
            else
                l=mid+1;
        }
        cout<<l<<endl;
    }
    return 0;
}