|
|
|
|
|
|
|
#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);
|
|
} |
