生成树

　　生成树

　　即使是基础的算法也能出很难的题啊。

　　先来一个板子题：

　　[模板]最小生成树：https://www.luogu.org/problemnew/show/P3366

　　

# include <cstdio>
# include <iostream>
# include <cstring>

using namespace std;

int G[5002][5002]={0},M[5002]={0};
bool f[5002]={false};

int main()
{
    
    int n,m,x,y,z;
    memset(G,0x7f,sizeof(G));
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        if (G[x][y]>=z)
          G[x][y]=G[y][x]=z;
        }
    memset(M,0x7f,sizeof(M));    
    M[1]=0;
    memset(f,1,sizeof(f));
    for (int i=1;i<=n;i++)
    {
        int k=0;
        for (int j=1;j<=n;j++)
          if ((f[j]!=0)&&(M[j]<M[k])) k=j;
        f[k]=false;
        for (int j=1;j<=n;j++)
          if (f[j]&&M[j]>G[k][j])
            M[j]=G[k][j];
    }
    int A=0,S=0;
    for (int i=1;i<=n;i++)
      A+=f[i];
    if (A!=0) {printf("orz");
    return 0;}
    for (int i=1;i<=n;i++)
      S+=M[i];
    cout<<S;
    return 0;
 } 

　　

// luogu-judger-enable-o2
# include <cstdio>
# include <iostream>
# include <algorithm>
# define R register int

using namespace std;

int fx,fy,n,m,ans,S;
int F[5009];
struct edge
{
    int x,y,co;
}g[200009];

bool cmp(edge a,edge b)
{
    return a.co<b.co;
}

int father(int x)
{
    if(x!=F[x]) return F[x]=father(F[x]);
    return x;
}

int main()
{
    scanf("%d%d",&n,&m);
    S=n;
    for (R i=1;i<=m;++i)
        scanf("%d%d%d",&g[i].x,&g[i].y,&g[i].co);
    sort(g+1,g+1+m,cmp);
    for (R i=1;i<=n;++i)
        F[i]=i;
    for (R i=1;i<=m;++i)
    {
        fx=father(g[i].x);
        fy=father(g[i].y);
        if(fx!=fy)
            F[fx]=fy,S--,ans+=g[i].co;
    }
    if(S!=1)
        printf("orz");
    else
        printf("%d",ans);
    return 0;
}

　　$Prim$的时间复杂度：$O(V^{2})$；

　　$Kruskal$时间复杂度：$O(ElogE)$

　　虽然$Kruskal$用的比较多，但是在处理近乎完全图的时候还是$Prim$比较快($E=V^{2}$)

　　听说还有一种针对没有重复权值的图的算法：$Boruvka$,对于随机图来说$O(V+E)$，听起来还是很不错的，不过我觉得现在还没必要学这个。

　　爱的供养：https://www.luogu.org/problemnew/show/P2266

　　昨天做了NOI同步赛，赛后学了一种感觉很有用的Kruskal重构树，现在通过一道题来学习一下。

　　归程：https://www.luogu.org/problemnew/show/P4768

　　题意概述：给定一张无向图，每条边有长度和海拔，每次给定一个起点和水平面，要求开车走海拔高于水平面的边，再找一个地方下车走，最终到达1号，求走路这一部分的最小长度，强制在线。

　　先从一号点跑$Dijkstra$求出每一个点到一号点的最短路，这一步是不可能省略的。现在考虑暴力，每次读入起点后跑BFS，可以得到50分。考虑离线，按照每次的水平面进行排序，把高于水平面的点进行合并（并查集），在同一个并查集中的点说明可以开车互相到达，这个并查集的权值就是这一些点里面离一号最近的点的权值。说的好，但是强制在线啊。可持久化并查集听说有卡过的，然而我不会。

　　看看合并的顺序像不像一棵树呀。首先按照海拔排序，用kruskal的思路进行合并，每次将$f[u]$,$f[v]$连到一个新建的虚点上：点权为这条边的海拔，显然全部合并完后就会形成一棵树，这棵树就叫kruskal重构树。每次我们在这棵树上往上爬，当爬到最大的小于这次海平面的点时就说明如果海平面是这么大，这个点就只能合并到这里为止了。因为重构出的树的点权是单调的，可以树上倍增。如果学过这个算法的话这道题其实就是个模板，对于NOI选手应该是签到题？（听说这题卡SPFA）

　　

// luogu-judger-enable-o2
# include <cstdio>
# include <cstring>
# include <iostream>
# include <queue>
# include <set>
# include <algorithm>
# define R register int

inline int min (int a,int b) { if(a<b) return a; return b; }
const int maxn=5e5+10;
const int maxm=2e6+10;
int cnt,T,n,m,h,da,k,s,fx,fy,u,v,l,a,p;
int kh,firs[maxn<<1],F[maxn<<1][22],f[maxn<<1],val[maxn<<1];
bool vis[maxn<<1];
long long d[maxn<<1],ans=0,mind[maxn<<1];
typedef std::pair <long long,int> pii;
std::priority_queue <pii,std::vector<pii>,std::greater<pii> > q;
int firs_k[maxm<<1];
struct edge
{
    int too,nex,l,a; //l长度,a海拔 
}g[maxm<<1];
struct lin
{
    int x,y,a;
}G[maxm];
struct kru_tree
{
    int nex,too;
}kru[maxm<<1];

inline void add (int x,int y,int l,int a)
{
    g[++h].too=y;
    g[h].nex=firs[x];
    g[h].l=l;
    g[h].a=a;
    firs[x]=h;
}

inline void dij (int s)
{
    memset(d,127,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s]=0;
    while (q.size()) q.pop();
    q.push(std::make_pair(d[s],s));
    int j,beg;
    while (q.size())
    {
        beg=q.top().second;
        q.pop();
        if(vis[beg]) continue;
        vis[beg]=true;
        for (R i=firs[beg];i;i=g[i].nex)
        {
            j=g[i].too;
            if(d[beg]+g[i].l>=d[j]) continue;
            d[j]=d[beg]+g[i].l;
            q.push(std::make_pair(d[j],j));
        }
    }
}

void add_edge(int x,int y)
{
    kru[++kh].too=y;
    kru[kh].nex=firs_k[x];
    firs_k[x]=kh;
}

bool cmp (lin a,lin b)
{
    return a.a>b.a;
}

int father (int x) { return f[x]?f[x]=father(f[x]):x; }

void dfs (int x)
{
    for (R i=firs_k[x];i;i=kru[i].nex)
        dfs(kru[i].too),mind[x]=min(mind[x],mind[ kru[i].too]),F[ kru[i].too ][0]=x;
    if(x<=n) mind[x]=d[x];
}

int main()
{
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&n,&m);
        ans=0,cnt=n,kh=0;
        memset(firs,0,sizeof(firs));
        memset(F,0,sizeof(F));
        memset(mind,127,sizeof(mind));
        memset(firs_k,0,sizeof(firs_k));
        memset(f,0,sizeof(f));
        memset(val,0,sizeof(val));
        h=0;
        for (R i=1;i<=m;++i)
        {
            scanf("%d%d%d%d",&u,&v,&l,&a);
            add(u,v,l,a);
            add(v,u,l,a);
            G[i].x=u;
            G[i].y=v;
            G[i].a=a;
        }
        dij(1);
        std::sort(G+1,G+1+m,cmp);
        for (R i=1;i<=m;++i)
        {
            fx=father(G[i].x);
            fy=father(G[i].y);
            if(fx==fy) continue;
            f[fx]=f[fy]=++cnt;
            add_edge(cnt,fx);
            add_edge(cnt,fy);
            val[cnt]=G[i].a;
        }
        dfs(cnt);
        scanf("%d%d%d",&da,&k,&s);
        for (int j=1;j<=21;++j)
            for (int i=1;i<=cnt;++i)
                F[i][j]=F[ F[i][j-1] ][j-1];
        for (R i=1;i<=da;++i)
        {
            scanf("%d%d",&v,&p);
            v=(v+(long long)k*ans-1)%n+1;
            p=(p+(long long)k*ans)%(s+1);
            for (int j=21;j>=0;--j)
                if(val[ F[v][j] ]>p) v=F[v][j];
            ans=mind[v];
            printf("%lld
",ans);
        }
    }
    return 0;
}