Algorithm 图形时间复杂性

最近我参加了谷歌的编码考试，有一些关于图形数据结构的问题，

---

其中一个问题是，他们给出了一个有N个节点和M条边的无向图G，他给出了Q个查询，在每个查询中，他给出了X Y W，其中我们必须检查是否有一条从X到Y的路径，每个边最多必须包含权重，这可以在

O（N log N+Q log Q）

中解决，而您的DFS解决方案是

O（m*q）

和adj矩阵解是

O（n^2）

空间

要快速解决此问题，您需要知道DSU（Disjiont Set Union）数据结构（也称为Union Find）。它支持一些节点的高效

O（log n）

并集，并且可以在

O（log n）

按权重对所有给定边进行升序排序

按权重对所有给定查询进行升序排序（也保存查询索引，因为输出需要按顺序进行）

现在逐个处理查询，如果查询要求有边的路径

>t；
而（t--）
{
cin>>n>>m>>q；
向量（n+1，-1），答案（q）；
矢量方向；//>v>>w；
把_向后推（{w，u，v}）；
}
对于（inti=0；i>x>>y>>W；
push_back（{W，x，y，i}）；
}
排序（edges.begin（）、edges.end（））；
排序（querys.begin（），querys.end（））；
int-edgeId=0；
用于（自动查询：查询（&Q）{
而（edgeId#include <bits/stdc++.h>
using namespace std;

int Find(int u, vector<int>&P)
{
    return P[u] < 0 ? u : P[u] = Find(P[u],P);
}

void Union(int u, int v, vector<int>&P)
{
    u=Find(u,P);
    v=Find(v,P);
    if(u==v)return;
    P[u]=v;
}

int main()
{
    //input is quite large so we might need fast I/O
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0); 

    int t,n,m,q;
    cin>>t;

    while(t--)
    {
        cin>>n>>m>>q;
        vector<int>P(n+1,-1),answers(q);
        vector<array<int,3>>edges; //<storing edges as [w, u, v]
        vector<array<int,4>>queries; //<storing queries as [W, x, y, queryId]

        for(int i=0; i<m; i++)
        {
            int u,v,w;
            cin>>u>>v>>w;
            edges.push_back({w,u,v});
        }

        for(int i=0; i<q; i++)
        {
            int x,y,W;
            cin>>x>>y>>W;
            queries.push_back({W,x,y,i});
        }

        sort(edges.begin(),edges.end());
        sort(queries.begin(),queries.end());

        int edgeId = 0;

        for(auto&query : queries){
            while(edgeId < edges.size() && edges[edgeId][0] <= query[0]){
                Union(edges[edgeId][1], edges[edgeId][2], P);
                edgeId++;
            }
            answers[query[3]] = Find(query[1],P) == Find(query[2], P);
        }

        for(int i=0; i<q; i++)
            cout<<answers[i]<<(i+1==q?"\n":" ");
    }

}