k短路

最新推荐文章于 2024-04-30 18:30:00 发布
最新推荐文章于 2024-04-30 18:30:00 发布
阅读量365 收藏
点赞数 1
分类专栏： 图论差不多是背背默默
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Onozuka_Komachi/article/details/81842628
版权

有一个A*写法？
然后我并不是很会…应该就是直接搜吧？
正常写法是..先从终点建反向边的最短路树。
对于任意一条不在最短路树上的边，
定义其权值 w=Disv+w−Disu w = D i s v + w − D i s u ，
即多绕的路程长度。
考虑取一个不在最短路树上的边的序列（可能有重复），
那么应满足对于相邻的两条边，
满足 vi v i 是 ui u i 在最短路树上的孩子或 vi=ui v i = u i ，
这样才能在不走这些边的情况下走原先的最短路，
其中显然有 v0=s v 0 = s 。
那么我只要对于某个点 x x ，
求出x及 x x <script type="math/tex" id="MathJax-Element-8">x</script>祖先形成的有序边表，
就可以用优先队列瞎搞求答案了？
好像是这样的…但是有序边表并不好搞
事实上弄个可持久化左偏树合并一下就可以了（（

Code
#include<bits/stdc++.h>
using namespace std;

#define Death Komachi
#define Uni All Right
#define REP(i,a,b) for(int i=(a),i##_end_=(b);i<i##_end_;++i)
#define DREP(i,a,b) for(int i=(a),i##_end_=(b);i>i##_end_;--i)
#define LREP(i,a) for(int i=Head[a];i;i=Next[i])
#define M 200004
#define LL long long

void Rd(int &x){
    static char c;x=0;
    while((c=getchar())<48);
    do x=(x<<3)+(x<<1)+(c^48);
    while((c=getchar())>47);
}

int n,m,s,t,K;

int V[M],W[M],Next[M],Head[M],tot;
void Add_Edge(int u,int v,int w){
    Next[++tot]=Head[u],V[Head[u]=tot]=v,W[tot]=w;
}

struct Node{
    int x;LL w;
    bool operator <(const Node &_)const{
        return w>_.w;
    }
};
int D[M],E[M],Tail[M],Pre[M];
LL Dis[M],Val[M];

priority_queue<Node>Q;
inline bool chkmin(LL &a,const LL &b){return b<a?a=b,1:0;}

int Rt[M];
static const int MX=M*30;
int Ch[MX][2],Ht[MX],ID[MX],trp;
void Build(int *A,int &x,int n){
//这是一个线性的建堆...相关资料可以在网上找（反正就是线性的
    if(!n)return;
    x=trp+1;
    REP(i,1,n+1){
        int j=trp+i,nt=i<<1;
        Ch[j][0]=nt<=n?trp+nt:0;nt++;
        Ch[j][1]=nt<=n?trp+nt:0;
        ID[j]=E[i];
    }
    DREP(i,n,0){
        int x=trp+i,a,b;
        Ht[x]=Ht[Ch[x][0]]+1;
        while(a=Ch[x][0]){
            if((b=Ch[x][1]) && Val[ID[b]]<Val[ID[a]])swap(a,b);
            if(Val[ID[a]]<Val[ID[x]])swap(ID[x],ID[a]),x=a;
            else break;
        }
    }
    trp+=n;
}
//左偏树合并
int Merge(int p,int q){
    if(!p||!q)return p|q;
    if(Val[ID[p]]>Val[ID[q]])swap(p,q);
    int x=++trp,&l=Ch[x][0],&r=Ch[x][1];
    ID[x]=ID[p];
    l=Ch[p][0];
    r=Merge(Ch[p][1],q);
    if(Ht[l]<Ht[r])swap(l,r);
    Ht[x]=Ht[l]+1;
    return x;
}

void Dij(){
    memset(Dis,63,sizeof(Dis));
    Q.push((Node){t,Dis[t]=0});

    int r=0;
    while(!Q.empty()){
        int x=Q.top().x,y;
        LL w=Q.top().w;Q.pop();
        if(w!=Dis[x])continue;
        D[++r]=x;
        LREP(i,x)if(chkmin(Dis[y=V[i]],w+W[i]))
            Q.push((Node){y,Dis[y]}),Pre[y]=i^1;
    }
    int id=0;
    REP(i,1,r+1){
        int x=D[i],y,p=0;
        LREP(j,x+n)if(j!=Pre[x])
            Val[id]=W[j]+Dis[Tail[id]=V[j]]-Dis[x],E[++p]=id++;
        Build(E,Rt[x],p);
        if(x!=t)Rt[x]=Merge(Rt[x],Rt[V[Pre[x]]]);
    }
}

void Work(){
    if(!(--K)){printf("%lld\n",Dis[s]);return;}
    if(Rt[s])Q.push((Node){Rt[s],Dis[s]+Val[ID[Rt[s]]]});

    while(!Q.empty()){
        int x=Q.top().x;
        LL w=Q.top().w;Q.pop();
        if(!(--K)){printf("%lld\n",w);return;}
        #define AddNode(a) if(a)Q.push((Node){a,w+Val[ID[a]]});
        AddNode(Rt[Tail[ID[x]]]);
        //加入这条边后 再加入其它边的情况
        w-=Val[ID[x]];
        AddNode(Ch[x][0]);
        AddNode(Ch[x][1]);
        //继续从该点选择比这条边大的其它边的情况
    }
    puts("-1");
}
int main(){
    Rd(n),Rd(m);
    tot=1;
    while(m--){
        int u,v,w;
        Rd(u),Rd(v),Rd(w);
        Add_Edge(v,u,w);
        Add_Edge(u+n,v,w);
    }
    Rd(s),Rd(t),Rd(K);
    if(s==t)K++;
    Dij();
    Work();
    return 0;
}

然后是后面那个第k长路的题…

#include<bits/stdc++.h>
using namespace std;

#define Death Komachi
#define Uni All Right
#define REP(i,a,b) for(int i=(a),i##_end_=(b);i<i##_end_;++i)
#define DREP(i,a,b) for(int i=(a),i##_end_=(b);i>i##_end_;--i)
#define LREP(i,a) for(int i=Head[a];i;i=Next[i])
#define M 600004
#define MP 2000004
#define LL long long
#define INF 0xc0c0c0c0

int n,m,s,t,K;

int V[MP],W[MP],Next[MP],Head[M],tot;
int Deg[M];

void Add_Edge(int u,int v,int w){
    Next[++tot]=Head[u],V[Head[u]=tot]=v,W[tot]=w;
}
void AddEdge(int u,int v,int w){
//  cerr<<u<<' '<<v<<' '<<w<<endl;
    Add_Edge(v,u,w),++Deg[u];
    Add_Edge(u+n,v,w);
}

struct Node{
    int x,w;
    bool operator <(const Node &_)const{
        return w<_.w;
    }
};
int D[M],E[M],Tail[M],Pre[M];
int Dis[M],Val[M];

priority_queue<Node>Q;

inline bool chkmax(int &a,const int &b){return a<b?a=b,1:0;}

int Rt[M];
static const int MX=M*60;
int Ch[MX][2],Ht[MX],ID[MX],trp;
void Build(int *A,int &x,int n){
    if(!n){x=0;return;}
    x=trp+1;
    REP(i,1,n+1){
        int j=trp+i,nt=i<<1;
        Ch[j][0]=nt<=n?trp+nt:0;nt++;
        Ch[j][1]=nt<=n?trp+nt:0;
        ID[j]=E[i];
    }
    DREP(i,n,0){
        int x=trp+i,a,b;
        Ht[x]=Ht[Ch[x][0]]+1;
        while(a=Ch[x][0]){
            if((b=Ch[x][1]) && Val[ID[b]]>Val[ID[a]])swap(a,b);
            if(Val[ID[a]]>Val[ID[x]])swap(ID[x],ID[a]),x=a;
            else break;
        }
    }
    trp+=n;
}
int Merge(int p,int q){
    if(!p||!q)return p|q;
    if(Val[ID[p]]<Val[ID[q]])swap(p,q);
    int x=++trp,&l=Ch[x][0],&r=Ch[x][1];
    ID[x]=ID[p];
    l=Ch[p][0];
    r=Merge(Ch[p][1],q);
    if(Ht[l]<Ht[r])swap(l,r);
    Ht[x]=Ht[l]+1;
    return x;
}
void Dij(){
    int l=1,r=0;

    Dis[t]=0;
    REP(i,1,n+1)if(!Deg[i])D[++r]=i;

    while(l<=r){
        int x=D[l++],y;
        LREP(i,x){
            if(chkmax(Dis[y=V[i]],Dis[x]+W[i]))Pre[y]=i^1;
            if(!(--Deg[y]))D[++r]=y;
        }
    }

    int id=0;
    REP(i,1,r+1){
        int x=D[i],y,p=0;
        if(Dis[x]==INF)continue;
        LREP(j,x+n){
            if(j!=Pre[x])
                Val[id]=W[j]+Dis[Tail[id]=V[j]]-Dis[x],E[++p]=id++;
        }
//      cerr<<i<<":"<<endl;
//      REP(j,0,p)cerr<<Val[E[j]]<<' '<<Tail[E[j]]<<endl;
        Build(E,Rt[x],p);
        if(x!=t)Rt[x]=Merge(Rt[x],Rt[V[Pre[x]]]);//cerr<<V[Pre[x]]<<' '<<x<<' '<<W[Pre[x]]<<endl;
    }
}

void Work(){
    while(!Q.empty())Q.pop();
    if(!(--K)){printf("%d\n",Dis[s]);return;}
    if(Rt[s])Q.push((Node){Rt[s],Dis[s]+Val[ID[Rt[s]]]});

    while(!Q.empty()){
        int x=Q.top().x;
        int w=Q.top().w;Q.pop();
//      cerr<<w<<endl;
        if(!(--K)){printf("%d\n",w);return;}
        #define AddNode(a) if(a)Q.push((Node){a,w+Val[ID[a]]});
        AddNode(Rt[Tail[ID[x]]]);
        w-=Val[ID[x]];
        AddNode(Ch[x][0]);
        AddNode(Ch[x][1]);
    } 
    puts("-1");
}
int T;
int main(){
    scanf("%d",&T);
    while(T--){
        trp=0,tot=1;
        scanf("%d%d",&m,&K);

        n=m*2+2;
        s=n-1,t=n;

        memset(Pre,0,n+1<<2);
        memset(Deg,0,n+1<<2);
        memset(Dis,192,n+1<<2);

        int C[2],c;
        REP(i,1,m+1){
            scanf("%d%d%d",&C[0],&C[1],&c);
            if(i!=1){
                AddEdge(i-1,i,0);
                AddEdge(i-1+m,i+m,0);
                AddEdge(i-1,i+c*m,C[0]);
                AddEdge(i-1+m,i+c*m,C[1]);
            }
            else AddEdge(s,i,0),AddEdge(s,i+c*m,C[0]);
        }
        AddEdge(m,t,0);
        AddEdge(m+m,t,0);

        Dij();
        Work();

        memset(Head,0,n+1<<3);
    }
    return 0;
}
Onozuka_Komachi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
可持久化可并堆优化k短路
beginend
02-13 495
问题 对于带权有向图，定义路径的长度为经过的边的权值之和。两条路径不同当且仅当经过边的顺序不同。给一个带权有向图 GGG 以及起点和终点 s,ts,ts,t，求 GGG 中 sss 到 ttt 权值前 kkk 小的路径。 朴素做法 问题转化 定义 disxdis_xdisx​ 表示从 xxx 到 ttt 的最短路长度，权值为 www 的边 e:u→ve:u\to ve:u→v 的花费 δ(e)=disv−disu+w\delta(e)=dis_v-dis_u+wδ(e)=disv​−disu​+w 可以理解
A*算法—第K短路
热门推荐
This is Mendez.
07-25 1万+
A*算法—第K短路A* 算法（这里的* 英文就读作star），是一种启发式搜索的方法，它离我们并不遥远，常用的BFS就是A*算法的一种特例。启发式搜索：DFS与BFS都属于非启发式搜索，又称盲目型搜索，它们最大的不同就是启发式搜索的选择不是盲目的，可以通过一个启发函数进行选择。 现在看一下下面的两张图，就可以很形象的理解了： 假如正常的搜索方式，我们会不断移动，直至遇到障碍物，显然这种方法是
图论 —— k 短路
Alex_McAvoy的博客
10-11 4607
【概述】 所谓 k 短路问题，是指给定一个具有 n 个点 m 条边的带正权有向图，再给定起点 S 与终点 T，询问从 S 到 T 的所有权和中，第 k 短的路径的长度。 k 短路问题的解决方法有两种，一种是利用A*算法求解，另一种是利用最短路算法与可持久化堆结合求解。 【A*算法】 对于 Dijkstra 算法，有一个结论是：当一个点第 k 次出队的时候，此时路径长度就是 s 到它的第 k...
K短路
Mudrobot的博客
05-11 3503
其实这个才是最短路的一个非常好的应用。那么下面我们就来讲一讲具体如何实现吧。 先确保自己已经熟练掌握了两种最短路的求解方法！！！ 这里有传送门： 1、SPFA 2、Dijsktra priority！ 然后我们先大体讲一讲思路，第k短路顾名思义就是我们要找到反正不是最短的一条路，那怎么办呢？我们这个时候就会发现我们不能像实现各种最短路算法的方法一样刷dis刷出第k短路，那么这个时候又...
最短路问题——K短路问题 / 次短路问题
最新发布
指北针_N的博客
04-30 599
最短路问题——K短路问题 / 次短路问题。​ 最短路问题中的非常著名的Dijkstra算法、Floyd-Warshall算法以及经典的练习题，大家可以去下面的链接看哈。 Dijkstra算法、Floyd-Warshall算法。A*算法 给定一个图，定义起点𝑠和终点𝑡，以及数字𝑘；求𝑠到𝑡的第𝑘短的路。允许环路。相同长度的不同路径，也被认为是完全不同的。 思路：用A*算法求解。把从𝑠到𝑡的路径分为两部分：从𝑠到中间某个
【学习笔记】左偏树的可持久化（【模板】k短路 / [SDOI2010]魔法猪学院）
09-28 273
md！拖了两周多，终于看懂了
k短路算法说明和程序源码
09-14
k短路算法，有算法的说明和程序的源码
k短路算法-word
02-07
在最短路算法基础上编制的k短路算法，简洁方便，很容易套用
求K短路的模板
09-24
A* dijstra k短路 求法：反向建边 通过dijstra做预处理 最短路作为A*的评估函数 通过A* 将目标点出队列K次 如果原点和终点相同出栈K+1次
A-star和第k短路和次小生成树和Yen和MPS寻路算法.doc
05-07
A-star算法、第k短路、次小生成树、Yen算法和MPS寻路算法。 A-star算法是一种静态路网中求解最短路最有效的方法。该算法的核心是估价函数f(n)，它是节点n从初始点到目标点的估价函数。估价函数可以表示为f(n)=g(n)+...
KDUANLU.zip_K._KSP_K短路_单亲遗传算法
09-19
《K短路问题与单亲遗传算法的深入探讨》 在优化问题的求解领域，K短路问题（KSP，K Shortest Path Problem）是一个经典的网络流问题，广泛应用于物流配送、交通规划以及计算机网络设计等多个领域。该问题旨在寻找...
HDU5960 可持久化左偏树 k短路问题
litble的成(tui)长(fei)史
01-26 1009
题目大意 有一堆项目,每个项目有三个权值(cost0,cost1,color)&quot; role=&quot;presentation&quot;&gt;(cost0,cost1,color)(cost0,cost1,color)(cost_0,cost_1,color),你要选择一些项目顺序执行,并给出你总花费的计算方式,求花费第k 大的工作方式. 题目分析 建图 转化为求k短路的话,必须要把权值取相反数,然后答案
k短路模板（洛谷P2483 [SDOI2010]魔法猪学院）（k短路，最短路，左偏树，priority_queue）...
a83229442的博客
10-04 171
你谷数据够强了，以前的A*应该差不多死掉了。 所以，小伙伴们快来一起把YL顶上去把！戳这里！ 俞鼎力的课件 需要掌握的内容： Dijkstra构建最短路径树。 可持久化堆（使用左偏树，因其有二叉树结构且能动态合并。构建方法类似可持久化线段树）。 #include<bits/stdc++.h> #define RG register #define R RG int using...
JDFZ 2978 第K短路 可持久化堆+A*思想
-Claude
08-31 1938
JDFZ 2978 第K短路 可持久化堆+A*思想
ST03Day3 可持久化
Deep_Kevin的娱乐空间
08-17 145
正题 可持久化线段树写了太多遍了，回去主要练习的就是可持久化并查集，可持久化非旋treap，可持久化左偏树（可并堆），k短路以及一系列k小的题目。 板子就不说了。 可持久化并查集是基于可持久化数组的，可持久化数组可以直接使用可持久化线段树来维护，所以在按秩合并的情况下加一个log就可以。 mex · 改 先考虑离线的时候怎么做，按右端点排序，线段树维护每个权值出现的最大位置和最大位置的最小值，然后在线段树上二分即可。在线直接考虑可持...
左偏树
小康的博客
10-24 541
左偏树的定义：左偏树是一种可并堆的实现。左偏树是一棵二叉树，它的节点除了和二叉树的节点一样具有左右子树外，还有两个属性：键值和距离。节点 i 的距离(dis(i)) 是节点 i 到它的后代中，最近的外节点所经过的边数（节点i称为外节点(external node)，当且仅当节点 i 的左子树或右子树为空）。特别的，如果节点 i 本身是外节点，则它的距离为0；而空节点的距离规为-1 。 左偏树的性...
[学习笔记]k短路
weixin_34195364的博客
05-16 176
A*：我已经忘了怎么写了，反正n=30，m=1000都能卡掉。。。 正解：可持久化左偏树+堆维护可能集合 原论文：http://www.docin.com/p-1387370338.html 概括： 结论： 1.t为根求最短路树T，定义P'为路径s-t的路径P和T没有交集的部分，P’和P都是有序边集 对于P'中相邻边一定存在tail和head的祖先后代关系（或者重合） 2.新定...
[A* K短路 || 可持久化堆] POJ 2449 Remmarguts' Date
雯舞
05-02 560
这就是裸的k短路了  学习一发A*的姿势：http://yzmduncan.iteye.com/blog/1162759 这个S==T的坑要注意 #include #include #include #include #include #define V G[p].v using namespace std; inline char nc() { static char buf[
【算法学习】左偏树
Pengwill's Blog
09-27 3793
左偏树 左偏树是一种可以快速合并的可并堆，相对于普通的二叉堆，左偏树的合并可以做到log(p1+p2)log(p_1 + p_2)log(p1​+p2​)，是一种十分优秀的数据结构。 性质 左偏树是一种可并堆的实现，是一颗二叉树，它除了有二叉树的左右儿子，还有2个属性，键和距离。下面是左偏树的一些基本性质。 节点的键值小于或等于左右子节点的键值。这是左偏树的堆性质。 节点的左子节点的距离不小于右...
k短路算法matlab
08-13
对于K短路算法的实现，你可以使用Matlab编程语言来完成。以下是一个简单的示例代码： ```matlab function [paths, costs] = kShortestPaths(graph, source, target, k) % 初始化变量 paths = cell(k, 1); costs ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值