标签：sz head dist int Kruskal Dijkstra maxn luogu4768 void

[luogu4768] [NOI2018] 归程 (Dijkstra+Kruskal重构树)

题面

题面较长，这里就不贴了

分析

看到不能经过有积水的边，即不能经过边权小于一定值的边，我们想到了kruskal重构树。我们把边按海拔高度从大到小排序，然后建立一棵Kruskal重构树。

树上维护什么呢？我们除了在点上记录高度外，把最底层的点1~n的权值设为点i到1的最短路径长度，然后维护子树最小值。我们在Kruskal重构树上从v开始树上倍增，找到深度最浅的高度>=水位线的点x，这样x子树中的点都是开车可以到达的，而最小步行距离就是x子树中的点对应到原图上后，到点1的距离。

代码

//https://www.luogu.org/problem/P4768
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
#define maxn 200000
#define maxm 400000
#define maxlogn 23
using namespace std;
typedef long long ll;
int t;
int n,m,q,k,s;
struct graph {
    struct edge {
        int from;
        int to;
        int next;
        int len;
        int height;
        friend bool operator < (edge p,edge q){
            return p.height>q.height;
        }
    }E[maxm*2+5]; 
    int sz=1;
    int head[maxn*2+5];
    void clear(){
        memset(head,0,sizeof(head));
        sz=1;
    }
    void add_edge(int u,int v,int l,int h){
        sz++;
        E[sz].from=u;
        E[sz].to=v;
        E[sz].next=head[u];
        E[sz].len=l;
        E[sz].height=h;
        head[u]=sz;
        sz++;
        E[sz].from=v;
        E[sz].to=u;
        E[sz].next=head[v];
        E[sz].len=l;
        E[sz].height=h;
        head[v]=sz;
    } 
}G;

struct tree{
    struct edge{
        int from;
        int to;
        int next;
    }E[(maxn+maxn)*2+5];
    int head[maxn+maxn+5];
    int sz=1;
    void clear(){
        memset(head,0,sizeof(head));
        sz=1;
    }
    void add_edge(int u,int v){
        sz++;
        E[sz].from=u;
        E[sz].to=v;
        E[sz].next=head[u];
        head[u]=sz;
        sz++;
        E[sz].from=v;
        E[sz].to=u;
        E[sz].next=head[v];
        head[v]=sz;
    }
}T; 


struct heap_node{
    ll dist;
    int id;
    heap_node(){
        
    }
    heap_node(int _id,ll _dist){
        id=_id;
        dist=_dist;
    }
    friend bool operator < (heap_node p,heap_node q){
        return p.dist>q.dist;
    }
};
int vis[maxn+5];
ll dist[maxn+5];
void dijkstra(int s){
    memset(dist,0x3f,sizeof(dist));
    memset(vis,0,sizeof(vis));
    dist[s]=0;
    priority_queue<heap_node>q;
    q.push(heap_node(s,0));
    while(!q.empty()){
        int x=q.top().id;
        q.pop();
        if(vis[x]) continue;
        vis[x]=1;
        for(int i=G.head[x];i;i=G.E[i].next){
            int y=G.E[i].to;
            if(dist[y]>dist[x]+G.E[i].len){
                dist[y]=dist[x]+G.E[i].len;
                q.push(heap_node(y,dist[y]));
            }
        }
    }
}

int newn=0;
int fa[maxn*2+5]; 
int find(int x){
    if(fa[x]==x) return x;
    else return fa[x]=find(fa[x]);
}

int log2n;
int hi[maxn*2+5];
ll dmin[maxn*2+5];
int deep[maxn*2+5];
int anc[maxn*2+5][maxlogn+5]; 
void dfs(int x,int fa){
    deep[x]=deep[fa]+1;
    anc[x][0]=fa;
    for(int i=1;i<=log2n;i++) anc[x][i]=anc[anc[x][i-1]][i-1];
    for(int i=T.head[x];i;i=T.E[i].next){
        int y=T.E[i].to;
        if(y!=fa){
            dfs(y,x);
            dmin[x]=min(dmin[x],dmin[y]);
        }
    }
}
ll query(int x,int lim){
    for(int i=log2n;i>=0;i--){
        if(anc[x][i]!=0&&hi[anc[x][i]]>lim){
            x=anc[x][i];
        }
    }
    return dmin[x];
}
void kruskal(){//建出kruskal重构树 
    newn=n;
    for(int i=1;i<=n*2;i++) fa[i]=i;
    sort(G.E+2,G.E+1+G.sz);
    for(int i=2;i<=G.sz;i++){
        int x=G.E[i].from;
        int y=G.E[i].to;
        int fx=find(x);
        int fy=find(y);
        if(fx!=fy){
            newn++;
            T.add_edge(fx,newn);
            T.add_edge(fy,newn);
            fa[fx]=newn;
            fa[fy]=newn;
            hi[newn]=G.E[i].height;
        }
    }
    log2n=log2(newn);
    memset(dmin,0x3f,sizeof(dmin));
    for(int i=1;i<=n;i++) dmin[i]=dist[i]; 
    dfs(newn,0);
}

void ini(){
    T.clear();
    G.clear();
    memset(anc,0,sizeof(anc));
    memset(deep,0,sizeof(deep));
    memset(dist,0x3f,sizeof(dist));
    memset(vis,0,sizeof(vis));
    memset(dmin,0x3f,sizeof(dmin));
}

int main() {
    freopen("return.in","r",stdin);
    freopen("return.out","w",stdout);
    int u,v,l,a;
    ll v0,p0;
    ll lastans;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d",&n,&m);
        lastans=0;
        ini();
        for(int i=1;i<=m;i++){
            scanf("%d %d %d %d",&u,&v,&l,&a);
            G.add_edge(u,v,l,a);
        }
        dijkstra(1);
        kruskal();
        scanf("%d %d %d",&q,&k,&s);
        for(int i=1;i<=q;i++){
            scanf("%lld",&v0);
            v0=(v0+k*lastans-1)%n+1;
            scanf("%lld",&p0);
            p0=(p0+k*lastans)%(s+1);
            lastans=query(v0,p0);
            printf("%lld\n",lastans);
        }   
    } 
}

标签：sz,head,dist,int,Kruskal,Dijkstra,maxn,luogu4768,void
来源： https://www.cnblogs.com/birchtree/p/11305193.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。