|
|
|
|
|
|
| #define DEBUG 0
|
|
|
| #include <algorithm>
|
| #include <functional>
|
| #include <numeric>
|
| #include <iostream>
|
| #include <iomanip>
|
| #include <cstdio>
|
| #include <cmath>
|
| #include <complex>
|
| #include <cstdlib>
|
| #include <ctime>
|
| #include <cstring>
|
| #include <cassert>
|
| #include <string>
|
| #include <vector>
|
| #include <list>
|
| #include <map>
|
| #include <set>
|
| #include <deque>
|
| #include <queue>
|
| #include <stack>
|
| #include <bitset>
|
| #include <sstream>
|
| using namespace std;
|
|
|
| #define LL long long
|
| #define LD long double
|
| #define PR pair<int,int>
|
|
|
| #define Fox(i,n) for (i=0; i<n; i++)
|
| #define Fox1(i,n) for (i=1; i<=n; i++)
|
| #define FoxI(i,a,b) for (i=a; i<=b; i++)
|
| #define FoxR(i,n) for (i=(n)-1; i>=0; i--)
|
| #define FoxR1(i,n) for (i=n; i>0; i--)
|
| #define FoxRI(i,a,b) for (i=b; i>=a; i--)
|
| #define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
|
| #define Min(a,b) a=min(a,b)
|
| #define Max(a,b) a=max(a,b)
|
| #define Sz(s) int((s).size())
|
| #define All(s) (s).begin(),(s).end()
|
| #define Fill(s,v) memset(s,v,sizeof(s))
|
| #define pb push_back
|
| #define mp make_pair
|
| #define x first
|
| #define y second
|
|
|
| template<typename T> T Abs(T x) { return(x<0 ? -x : x); }
|
| template<typename T> T Sqr(T x) { return(x*x); }
|
| string plural(string s) { return(Sz(s) && s[Sz(s)-1]=='x' ? s+"en" : s+"s"); }
|
|
|
| const int INF = (int)1e9;
|
| const LD EPS = 1e-9;
|
| const LD PI = acos(-1.0);
|
|
|
|
|
| #define GETCHAR getchar
|
| |
| |
|
|
|
|
| bool Read(int &x)
|
| {
|
| char c,r=0,n=0;
|
| x=0;
|
| for(;;)
|
| {
|
| c=GETCHAR();
|
| if ((c<0) && (!r))
|
| return(0);
|
| if ((c=='-') && (!r))
|
| n=1;
|
| else
|
| if ((c>='0') && (c<='9'))
|
| x=x*10+c-'0',r=1;
|
| else
|
| if (r)
|
| break;
|
| }
|
| if (n)
|
| x=-x;
|
| return(1);
|
| }
|
|
|
| bool ReadLL(LL &x)
|
| {
|
| char c,r=0,n=0;
|
| x=0;
|
| for(;;)
|
| {
|
| c=GETCHAR();
|
| if ((c<0) && (!r))
|
| return(0);
|
| if ((c=='-') && (!r))
|
| n=1;
|
| else
|
| if ((c>='0') && (c<='9'))
|
| x=x*10+c-'0',r=1;
|
| else
|
| if (r)
|
| break;
|
| }
|
| if (n)
|
| x=-x;
|
| return(1);
|
| }
|
|
|
| #define LIM 500005
|
| #define LIM2 1000000
|
|
|
| LL BLT[2][2][LIM2+1];
|
|
|
| void Update(int a,int b,int i,int v)
|
| {
|
| for (; i<=LIM2; i+=(i&-i))
|
| BLT[a][b][i]+=v;
|
| }
|
|
|
| void Update2(int a,int i,int v)
|
| {
|
| Update(a,0,i,v);
|
| Update(a,1,i,i*v);
|
| }
|
|
|
| LL Query(int a,int b,LL ii)
|
| {
|
| int i=(int)min(ii,(LL)LIM2);
|
| LL v=0;
|
| for(; i>0; i-=(i&-i))
|
| v+=BLT[a][b][i];
|
| return(v);
|
| }
|
|
|
| int main()
|
| {
|
| if (DEBUG)
|
| freopen("in.txt","r",stdin);
|
|
|
| int T,t;
|
| int N,M;
|
| int i,j,k;
|
| LL r1,r2,m,m2;
|
| LL tot,rem,cnt,sum;
|
| LL ans;
|
| static vector<PR> con[LIM];
|
| static int C[LIM],dep[LIM],cyc[LIM];
|
| static PR par[LIM];
|
| queue<int> Q;
|
| set<PR> S;
|
| set<PR>::iterator I;
|
|
|
| Read(T);
|
| Fox1(t,T)
|
| {
|
|
|
| Read(N),Read(M);
|
| Fox(i,N)
|
| {
|
| Read(j),Read(k),Read(C[i]);
|
| j--,k--;
|
| con[j].pb(mp(k,i));
|
| con[k].pb(mp(j,i));
|
| }
|
|
|
| Fill(dep,-1);
|
| Q.push(0),dep[0]=0;
|
| for(;;)
|
| {
|
| i=Q.front(),Q.pop();
|
| Fox(j,Sz(con[i]))
|
| if ((k=con[i][j].x)!=par[i].x)
|
| if (dep[k]>=0)
|
| goto Done;
|
| else
|
| Q.push(k),dep[k]=dep[i]+1,par[k]=mp(i,con[i][j].y);
|
| }
|
|
|
| Done:;
|
| Fill(cyc,0);
|
| cyc[con[i][j].y]=1;
|
| while (i!=k)
|
| if (dep[i]>dep[k])
|
| {
|
| cyc[par[i].y]=1;
|
| i=par[i].x;
|
| }
|
| else
|
| {
|
| cyc[par[k].y]=1;
|
| k=par[k].x;
|
| }
|
|
|
| Fox(i,N)
|
| {
|
| Update2(cyc[i],C[i],1);
|
| if (cyc[i])
|
| S.insert(mp(C[i],i));
|
| }
|
|
|
| ans=0;
|
| while (M--)
|
| {
|
| Read(i);
|
| if (i==1)
|
| {
|
|
|
| Read(i),i--;
|
| Update2(cyc[i],C[i],-1);
|
| if (cyc[i])
|
| S.erase(mp(C[i],i));
|
| Read(C[i]);
|
| Update2(cyc[i],C[i],1);
|
| if (cyc[i])
|
| S.insert(mp(C[i],i));
|
| }
|
| else
|
| {
|
|
|
| ReadLL(tot);
|
| r1=1,r2=(LL)1e13;
|
| while (r2>r1)
|
| {
|
| m=(r1+r2+1)>>1;
|
| rem=tot;
|
|
|
| cnt=Query(0,0,m);
|
| sum=Query(0,1,m);
|
| rem-=cnt*m - sum;
|
| if (rem<0)
|
| goto Bad;
|
|
|
| I=S.begin(),i=I->x;
|
| I++,j=I->x;
|
| if (m<=(j<<1))
|
| rem-=max(0LL,m - (i+j));
|
| else
|
| {
|
| m2=(m+1)>>1;
|
| cnt=Query(1,0,m2);
|
| sum=Query(1,1,m2);
|
| rem-=cnt*m2 - sum;
|
| if (m&1)
|
| rem++;
|
| }
|
| if (rem<0)
|
| {
|
| Bad:;
|
| r2=m-1;
|
| continue;
|
| }
|
| r1=m;
|
| }
|
| ans+=r1;
|
| }
|
| }
|
|
|
| printf("Case #%d: ",t);
|
| cout << ans << endl;
|
|
|
| Fox(i,N)
|
| con[i].clear();
|
| while (!Q.empty())
|
| Q.pop();
|
| S.clear();
|
| Fill(BLT,0);
|
| }
|
| return(0);
|
| } |
