Light oj 1252 - Maintaining Communities（树形dp）

1252 - Maintaining Communities

PDF (English)

Statistics

Forum

Time Limit: 2 second(s)

Memory Limit: 32 MB

Tracking Communities in social networks, like facebook, twitter etc, are one of the most exiting works in the field of Artificial Intelligence now-a-days. A community is a group of people who are connected. Two persons are connected and form a community if they are directly connected or connected via some other persons. That means if person A and B are connected and B and C are also connected then Aand C are connected and they all belong to the same community. It is quite obvious that, one single person can also form a community by himself.

Now you are given a description of a community where there are n persons and the connections between some pairs of the persons. You can assume that they do form a community and their connection is given such that if you want to find two peoples connectivity information, you will find exactly one path between them.

Now maintaining a connection between a pair requires some cost. And unfortunately, the social networking site cannot afford keeping a community which requires a cost of more than K. For example, say A and B and B and C are connected and cost(A, B) = 5, cost(B, C) = 2. Then if K ≥ 7, they can afford this community. Otherwise they cannot.

So, they have made a plan, and that is they will break the community. They want to break the community into multiple communities such that each community requires maintenance cost no more than K. But if there are too many communities people may leave the network, that's why they want the minimum number of communities. Since you are the best, they find no option but to ask you.

Input

Input starts with an integer T (≤ 200), denoting the number of test cases.

Each case starts with a line containing two integers n (1 ≤ n ≤ 100) and K (1 ≤ K ≤ 100). Each of the next n - 1 lines contains three integers u v w (1 ≤ u, v ≤ n, 1 ≤ w ≤ 100, u ≠ v) meaning that there is a connection between person u and v and the maintenance cost of this connection is w.

Output

For each case, print the case number and the minimum number of communities they have to maintain.

Sample Input	Output for Sample Input
2 3 1 1 2 2 2 3 2 4 12 1 2 5 2 3 10 1 4 7	Case 1: 3 Case 2: 2

 

---

PROBLEM SETTER: JANE ALAM JAN, ZOBAYER HASAN

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<stack>
#include<vector>
#include<map>

#define L(x) (x<<1)
#define R(x) (x<<1|1)
#define MID(x,y) ((x+y)>>1)

#define bug printf("hihi\n")

#define eps 1e-12

typedef long long ll;
using namespace std;
#define INF 0x3f3f3f3f
#define N 205

int dp[N][N];

struct stud{
  int to,ne,len;
}e[N*2];

int head[N];
int num;
int n,k;

inline void add(int u,int v,int len)
{
    e[num].to=v;
    e[num].len=len;
    e[num].ne=head[u];
    head[u]=num++;
}

void dfs(int u,int pre)
{
      int i,j;
      for(int v=0;v<=k;v++)
        dp[u][v]=1;         //首先每个点为一个快
      for(int i=head[u];i!=-1;i=e[i].ne)
      {
          int to=e[i].to;

          if(to==pre) continue;
          dfs(to,u);


          for(int v=k;v>=0;v--)
              {
                  int t=INF;
                  for(int vv=0;vv<=k;vv++)
                 {
                    t=min(dp[to][vv],t);
                    if(v+vv+e[i].len<=k)
                       dp[u][v+vv+e[i].len]=min(dp[u][v+vv+e[i].len],dp[u][v]+dp[to][vv]-1);
                  }
                dp[u][v]+=t;
              }
      }
}

int main()
{

   int i,j,t,ca=0;
   scanf("%d",&t);
   while(t--)
   {
       scanf("%d%d",&n,&k);
       memset(head,-1,sizeof(head));
       num=0;
       int u,v,len;
       i=n-1;
       while(i--)
       {
           scanf("%d%d%d",&u,&v,&len);
           add(u,v,len);
           add(v,u,len);
       }
       dfs(1,-1);

       int ans=INF;
       for(int i=0;i<=k;i++)
           ans=min(ans,dp[1][i]);
       printf("Case %d: %d\n",++ca,ans);
   }
   return 0;
}