# B-business-NC14545(dp Backpack + concurrent search)

Keywords: Dynamic Programming codeforce AcWing

Title No.: NC14545
Time limit: 1 second for C / C + + and 2 seconds for other languages
Space limitation: C/C++ 32768K, other languages 65536K
64bit IO Format: %lld

## Title Description

Xiao d is a local tyrant engaged in real estate. Everyone has the means to do business. Of course, interpersonal relationship needs to be put in the first place.

Xiao d needs to list a interpersonal relationship table every month, indicating that they have an interpersonal network of people engaged in real estate, but his energy is limited, so he can only communicate with people he can contact. For example, if 1 knows 2 and 2 knows 3, then 1 can contact 3 for communication. Of course, 1 and 2 can also communicate.

Xiao d is also very smart. He knows who he communicates with deeply and gains great benefits. Then he lists an interest table according to his own ideas, indicating how much energy he needs to communicate with these people and how much benefit he can obtain.

Little d wants to know how much benefit he can get in his energy range.

Set the number of small d as 1, and limit the number of communication times corresponding to a person to 1

## Enter Description:

```This question contains multiple groups of inputs. Input a number t in the first line to represent the number of groups of test data
In the first row of each group of data, enter three numbers, N,M and C, indicating the total number of individuals in this interpersonal network, the number of relationships in the network, and the energy value of small d
Next, N-1 lines, two numbers ai, Bi in each line. Here, line i indicates that it takes ai's energy to recognize with the person numbered i+1, and the benefit value that can be obtained is bi.
Next, in line M, there are two numbers x and Y in each line, indicating that the person numbered x can contact the person numbered y
t<=50
2<=N<=10000
1<=M<=10*N
1<=ai，bi<=10
1<=C<=500
1<=x,y<=N```

## Output Description:

`The output contains a line that represents the maximum benefit that small d can obtain`

Example 1

```1
5 3 7
5 10
3 2
4 3
1 100
1 2
2 3
1 4```

## output

`10`
```//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<iomanip>
#include<cstring>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<cassert>
#include<sstream>
#include<algorithm>
using namespace std;
const int mod=1e9+7;
typedef long long  ll;
#define ls (p<<1)
#define rs (p<<1|1)
#define mid (l+r)/2
#define over(i,s,t) for(register long long i=s;i<=t;++i)
#define lver(i,t,s) for(register long long i=t;i>=s;--i)
const int MAXN = 305;
const int INF = 0x3f3f3f3f;
const int N=5e4+7;
const int maxn=1e5+5;
const double EPS=1e-10;
const double Pi=3.1415926535897;
//inline double max(double a,double b){
//    return a>b?a:b;
//}
//inline double min(double a,double b){
//    return a<b?a:b;
//}

int xd[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int yd[8] = {1, 0, -1, 0, -1, 1, -1, 1};

//void Fire(){
//    queue<node> p;
//    p.push({fx,fy,0});
//    memset(fire, -1, sizeof(fire));
//    fire[fx][fy]=0;
//    while(!p.empty()){
//        node temp=p.front();
//        p.pop();
//        for(int i=0;i<8;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m||fire[x][y]!=-1){
//                continue;
//            }
//            fire[x][y]=temp.val+1;
//            p.push({x,y,temp.val+1});
//        }
//    }
//}
//int bfs(){
//    queue<node> p;
//    memset(vis, 0, sizeof(vis));
//    p.push({sx,sy,0});
//    while (!p.empty()) {
//        node temp=p.front();
//        vis[temp.x][temp.y]=1;
//        p.pop();
//        for(int i=0;i<4;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m)  continue;
//            if(x==ex&&y==ey&&temp.val+1<=fire[x][y]) return temp.val+1;
//            if(vis[x][y]||temp.val+1>=fire[x][y]||a[x][y]=='#') continue;
//            p.push({x,y,temp.val+1});
//        }
//    }
//    return -1;
//}

//One dimensional hash
//int n;
//string s;
//int bas=131;
//typedef unsigned long long ull;
//const ull mod1=100001651;
//ull a[100010];
//ull Hash(string s){
//    ll ans=0;
//    for(int i=0;i<s.size();i++){
//        ans*=bas;
//        ans+=int(s[i]);
//        ans%=mod1;
//    }
//    return ans;
//}

//Two dimensional hash
//using lom=unsigned long long ;
//const lom bas1=131,bas2=233;
//const int M=505;
//int n,m;
//char a[M][M];
//lom _hash[M][M];
//lom p1[M],p2[M];
//
//
//void init(){
//    p1[0]=1;
//    p2[0]=1;
//    for(int i=1;i<=505;i++){
//        p1[i]=p1[i-1]*bas1;
//        p2[i]=p2[i-1]*bas2;
//
//    }
//}
//void Hash(){
//    _hash[0][0]=_hash[0][1]=_hash[1][0]=0;
//    For (int i = 1; I < = n; I + +) {/ / prefix and
//        for(int j=1;j<=m;j++){
//            _hash[i][j]=_hash[i][j-1]*bas1+a[i][j]-'a';
//        }
//    }
//    For (int i = 1; I < = n; I + +) {/ / 2D prefix and
//        for(int j=1;j<=m;j++){
//            _hash[i][j]+=_hash[i-1][j]*bas2;
//        }
//    }
//
//}

int n,m,c;
int a[1000010];
int b[1000010];
ll dp[1010];
int fa[1000010];
void init(){
for(int i=0;i<=n;i++){
fa[i]=i;
}
}
int find(int x){
if(x==fa[x]) return x;
return fa[x]=find(fa[x]);
}
void Union(int x,int y){
int xx=find(x);
int yy=find(y);
if(xx!=yy){
fa[xx]=yy;
}
}
int  main(){
int t;
cin>>t;
while (t--) {
memset(dp,0,sizeof(dp));
cin>>n>>m>>c;
init();
for(int i=2;i<=n;i++){
cin>>a[i]>>b[i];
}
for(int i=0;i<m;i++){
int x,y;
cin>>x>>y;
Union(x,y);
}
for(int i=2;i<=n;i++){
if(find(1)==find(i)){
for(int j=c;j>=0;j--){
if(j-a[i]>=0){
dp[j]=max(dp[j],dp[j-a[i]]+b[i]);
}
}
}
}
cout<<dp[c]<<endl;
}
}
```

Posted by plouka on Sun, 19 Sep 2021 01:41:24 -0700