題目描述

SC 省 MY 市有著龐大的地下水管網路，嘟嘟是 MY 市的水管局長（就是管水管的啦），嘟嘟作為水管局長的工作就是：每天供水公司可能要將一定量的水從 x 處送往 y 處，嘟嘟需要為供水公司找到一條從 A 至 B 的水管的路徑，接著通過資訊化的控制中心通知路徑上的水管進入準備送水狀態，等到路徑上每一條水管都準備好了，供水公司就可以開始送水了。嘟嘟一次只能處理一項送水任務，等到當前的送水任務完成了，才能處理下一項。

在處理每項送水任務之前，路徑上的水管都要進行一系列的準備操作，如清洗、消毒等等。嘟嘟在控制中心一聲令下，這些水管的準備操作同時開始，但由於各條管道的長度、內徑不同，進行準備操作需要的時間可能不同。供水公司總是希望嘟嘟能找到這樣一條送水路徑，路徑上的所有管道全都準備就緒所需要的時間儘量短。嘟嘟希望你能幫助他完成這樣的一個選擇路徑的系統，以滿足供水公司的要求。另外，由於 MY 市的水管年代久遠，一些水管會不時出現故障導致不能使用，你的程式必須考慮到這一點。

不妨將 MY 市的水管網路看作一幅簡單無向圖（即沒有自環或重邊）：水管是圖中的邊，水管的連線處為圖中的結點。

輸入輸出格式

輸入格式：
輸入檔案第一行為 3 個整數：N , M , Q 分別表示管道連線處（結點）的數目、目前水管（無向邊）的數目，以及你的程式需要處理的任務數目（包括尋找一條滿足要求的路徑和接受某條水管壞掉的事實）。

以下 M 行，每行 3 個整數 x , y和 t ，描述一條對應的水管。x 和 y 表示水管兩端結點的編號，t 表示準備送水所需要的時間。我們不妨為結點從 1 至 N編號，這樣所有的 x 和 y 都在範圍[1,N] 內。

以下 Q 行，每行描述一項任務。其中第一個整數為 k ：

若 k=1 則後跟兩個整數 A 和 B ，表示你需要為供水公司尋找一條滿足要求的從 A 到 B 的水管路徑；

若 k=2 ，則後跟兩個整數 x 和 y ，表示直接連線 x 和 y 的水管宣佈報廢（保證合法，即在此之前直接連線 x 和 y 尚未報廢的水管一定存在）。

輸出格式：
按順序對應輸入檔案中每一項 k=1 的任務，你需要輸出一個數字和一個回車/換行符。該數字表示：你尋找到的水管路徑中所有管道全都完成準備工作所需要的時間（當然要求最短）。

輸入輸出樣例

輸入樣例#1：
4 4 3
1 2 2
2 3 3
3 4 2
1 4 2
1 1 4
2 1 4
1 1 4
輸出樣例#1：
2
3

測試資料中宣佈報廢的水管不超過 5000 條；且任何時候我們考慮的水管網路都是連通的，即從任一結點 A 必有至少一條水管路徑通往任一結點 B 。

注：此處資料為原題資料，原題資料不強（因為存在此題的資料加強版），故將時限由3 秒改為1 秒。

分析：兩點距離可以看作是最小生成樹上的距離，用LCT維護最小生成樹。我們可以倒著做，相當於每次多了一條邊，考慮這條邊，加入有可能出現環(只是有可能)，出現環時就要cut掉環上最大邊，所以要LCT維護一個樹上最大邊，以及記錄這條邊的id，加入一條邊(x,y)，只需比較x到y在原來的樹上的最長邊與當前邊的權值，如果當前邊更優則加入cut掉最大邊，加入當前邊。
程式碼在洛谷可以過，bzoj嘛，邊就不可以暴力了，我修改時查詢斷掉的邊是哪一條是純暴力= =，搞成二分就好了，還有快讀+O2，可以過的。

程式碼：

#include <iostream>
#include <cstdio>
#include <algorithm>

const int maxn=1200001;

using namespace std;

struct node{
    int l,r,fa,s,id;
    bool rev;
}t[maxn];

struct ask{
    int x,y,time,ans;
}q[maxn];

struct adge{
    int x,y,next,time,id;
}g[maxn];

int n,m,i,x,y,val[maxn],ls[maxn],flow,op,cnt,j,test;
int from[maxn],to[maxn];

bool isroot(int x)
{
    return (x!=t[t[x].fa].l) && (x!=t[t[x].fa].r);
}

void updata(int x)
{
    if (t[t[x].l].s>t[t[x].r].s)
    {
        t[x].s=t[t[x].l].s;
        t[x].id=t[t[x].l].id;
    }
    else
    {
        t[x].s=t[t[x].r].s;
        t[x].id=t[t[x].r].id;
    }
    if (val[x]>t[x].s) t[x].s=val[x],t[x].id=x;
}

void remove(int x)
{
    if (!isroot(x)) remove(t[x].fa);
    if (t[x].rev)
    {
        t[x].rev^=1;
        swap(t[x].l,t[x].r);
        if (t[x].l) t[t[x].l].rev^=1;
        if (t[x].r) t[t[x].r].rev^=1;
    }
}

void rttr(int x)
{
    int y=t[x].l;
    t[x].l=t[y].r;
    if (t[y].r) t[t[y].r].fa=x;
    if (x==t[t[x].fa].l) t[t[x].fa].l=y;
    else if (x==t[t[x].fa].r) t[t[x].fa].r=y;
    t[y].fa=t[x].fa;
    t[x].fa=y;
    t[y].r=x;
    updata(x); updata(y);
}

void rttl(int x)
{
    int y=t[x].r;
    t[x].r=t[y].l;
    if (t[y].l) t[t[y].l].fa=x;
    if (x==t[t[x].fa].l) t[t[x].fa].l=y;
    else if (x==t[t[x].fa].r) t[t[x].fa].r=y;
    t[y].fa=t[x].fa;
    t[x].fa=y;
    t[y].l=x;
    updata(x);updata(y);
}

void splay(int x)
{
    remove(x);
    while (!isroot(x))
    {
        int p=t[x].fa,g=t[p].fa;
        if (isroot(p))
        {
            if (t[p].l==x) rttr(p);
                      else rttl(p);
        }
        else
        {
            if (x==t[p].l)
            {
                if (p==t[g].l) rttr(p),rttr(g);
                          else rttr(p),rttl(g);
            }
            else
            {
                if (p==t[g].l) rttl(p),rttr(g);
                          else rttl(p),rttl(g);
            }
        }
    }
}

void access(int x)
{
    int y=0;
    while (x)
    {
        splay(x);
        t[x].r=y;
        updata(x);
        y=x;x=t[x].fa;
    }
}

void makeroot(int x)
{
    access(x);
    splay(x);
    t[x].rev^=1;
}

int find(int x)
{
    if (isroot(x)) return x;
    else return find(t[x].fa);
}

void cut(int x,int y)
{
    makeroot(x);
    access(y);
    splay(y);
    t[x].fa=0;t[y].l=0;
}

void link(int x,int y)
{
    makeroot(x);
    access(y);
    splay(y);
    t[x].fa=y;
}

bool cmp(adge x,adge y)
{
    return x.time>y.time;
}

bool check(int x,int y)
{
     makeroot(x);
     access(y);
     splay(y);
     return find(x)==y;
}

int getint()

 {

    char ch = getchar();

    for ( ; ch > '9' || ch < '0'; ch = getchar());

    int tmp = 0;

    for ( ; '0' <= ch && ch <= '9'; ch = getchar())

      tmp = tmp * 10 + int(ch) - 48;

    return tmp;

 } 

int main()
{
    n=getint();m=getint();test=getint();
    for (i=1;i<=m;i++)
    {
        x=getint();y=getint();flow=getint();                
        g[i].x=x;
        g[i].y=y;
        g[i].next=ls[x];
        g[i].id=i+n;
        g[i].time=0x3f3f3f3f;
        val[n+i]=flow;
        ls[x]=i;
        from[i]=x;
        to[i]=y;
    }   
    for (i=1;i<=test;i++)
    {
        op=getint();x=getint();y=getint();
        if (op==2)
        {                   
            for (j=ls[x];j>0;j=g[j].next)//就是這裡，按邊的x排序，改成二分
            {
                if (g[j].y==y)
                {
                    g[j].time=i;
                    break;
                } 
            }
            for (j=ls[y];j>0;j=g[j].next)//還有這裡
            {
                if (g[j].y==x) 
                {
                    g[j].time=i;
                    break;
                }
            }
        }
        else q[++cnt].x=x,q[cnt].y=y,q[cnt].time=i;
    }    
    sort(g+1,g+m+1,cmp);
    j=1;    
    for (i=cnt;i>0;i--)
    {
        while ((g[j].time>q[i].time) && (j<=m))
        {
            if (check(g[j].x,g[j].y) && (t[g[j].y].s>val[g[j].id]))
            {
                int u=t[g[j].y].id;
                cut(from[u-n],u);
                cut(u,to[u-n]);
            }
            link(g[j].x,g[j].id);
            link(g[j].id,g[j].y);
            j++;
        }
        makeroot(q[i].x);
        access(q[i].y);
        splay(q[i].y);
        q[i].ans=t[q[i].y].s;
    }   
    for (i=1;i<=cnt;i++) printf("%d\n",q[i].ans);
    return 0;
}