POJ 2831 Can We Build This One：次小生成树【N^2预处理】

题目链接：http://poj.org/problem?id=2831

题意：

　　给你一个图，每条边有边权。

　　然后有q组询问(i,x)，问你如果将第i条边的边权改为x，这条边是否有可能在新的最小生成树中。

题解：

　　更改边权相当于新添加了一条边。

　　新边在新MST中的充要条件是：

　　　　加入新边后，在原来的MST上形成的环中，有一条旧边的边权>=x。

　　　　（因为如果这样的话，新边可以替换掉那条最大的边）

　　所以可以预处理出 maxn[i][j]：在原来的MST上，任意两点间路径上的最大边权。

　　dfs即可。

　　对于每一个新访问到的节点i，枚举每一个已访问过的节点j，那么：

　　　　maxn[i][j] = maxn[j][i] = max(maxn[j][fa[i]], v[fa[i]][i])

　　复杂度O(N^2)。

AC Code:

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define MAX_N 1005
#define MAX_M 100005

using namespace std;

struct E
{
    int s;
    int t;
    int len;
    E(int _s,int _t,int _len)
    {
        s=_s;
        t=_t;
        len=_len;
    }
    E(){}
    friend bool operator < (const E &a,const E &b)
    {
        return a.len<b.len;
    }
};

struct Edge
{
    int dest;
    int len;
    Edge(int _dest,int _len)
    {
        dest=_dest;
        len=_len;
    }
    Edge(){}
};

int n,m,q;
int s[MAX_M];
int t[MAX_M];
int v[MAX_M];
int par[MAX_N];
int maxn[MAX_N][MAX_N];
bool vis[MAX_N];
vector<E> e;
vector<Edge> edge[MAX_N];

void read()
{
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&s[i],&t[i],&v[i]);
        e.push_back(E(s[i],t[i],v[i]));
    }
}

void init_union_find()
{
    for(int i=1;i<=n;i++)
    {
        par[i]=i;
    }
}

int find(int x)
{
    return par[x]==x ? x : par[x]=find(par[x]);
}

void unite(int x,int y)
{
    int px=find(x);
    int py=find(y);
    if(px==py) return;
    par[px]=py;
}

bool same(int x,int y)
{
    return find(x)==find(y);
}

int kruskal()
{
    init_union_find();
    sort(e.begin(),e.end());
    int cnt=0;
    int res=0;
    for(int i=0;i<e.size();i++)
    {
        E temp=e[i];
        if(!same(temp.s,temp.t))
        {
            cnt++;
            res+=temp.len;
            unite(temp.s,temp.t);
            edge[temp.s].push_back(Edge(temp.t,temp.len));
            edge[temp.t].push_back(Edge(temp.s,temp.len));
        }
    }
    return cnt==n-1 ? res : -1;
}

void dfs(int now)
{
    vis[now]=true;
    for(int i=0;i<edge[now].size();i++)
    {
        Edge temp=edge[now][i];
        if(!vis[temp.dest])
        {
            for(int j=1;j<=n;j++)
            {
                if(vis[j])
                {
                    maxn[j][temp.dest]=maxn[temp.dest][j]=max(maxn[j][now],temp.len);
                }
            }
            dfs(temp.dest);
        }
    }
}

void work()
{
    kruskal();
    memset(maxn,0,sizeof(maxn));
    memset(vis,false,sizeof(vis));
    dfs(1);
    int i,x;
    while(q--)
    {
        scanf("%d%d",&i,&x);
        if(x<=maxn[s[i]][t[i]]) printf("Yes
");
        else printf("No
");
    }
}

int main()
{
    read();
    work();
}