图算法专题：带/不带优化的Dijkstra、DFS

最新推荐文章于 2022-10-16 09:23:21 发布
最新推荐文章于 2022-10-16 09:23:21 发布
阅读量249 收藏 1
点赞数 1
分类专栏： ACM专题 ACM 文章标签： 图论 dijkstra dfs acm竞赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flying_Dutch/article/details/108354581
版权

一、Dijkstra+堆优化pq

例题：PAT A1072 Gas Station (30point(s))

AC代码

#include <iostream>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <functional>
#include <iomanip>
using namespace std;
#define ms(Arr,Val) memset(Arr,Val,sizeof(Arr))
#define INF 0x3f3f3f3f
typedef pair<int,int> P;

//20200902 06:45:25 ~-=0.5month
//AC 22ms G++6.5.0
//Dijkstra：求所有单S到其余所有点的最短路MinD,并按一定的筛选和判优条件输出
/*本代码使用了带堆优化(即pq)的Djikstra,时间复杂度O(VlogV+E)
 *注意点：
 *1) Case4用纯dfs会T;
 *2) Case0/2卡了判优条件(之前我的Cmp函数那块笔误了,以后少笔误！！！);
 *3) 还有就是G点和普通点建议连号,不然处理起来很不方便,容易WA.(1~N1+N2)
 */
struct Station{
    int id;
    double minD,avgD;
};
bool Cmp(const Station& s1,const Station& s2){
    if(s1.minD!=s2.minD) return s1.minD>s2.minD;
    else if(s1.avgD!=s2.avgD) return s1.avgD<s2.avgD;
    else return s1.id<s2.id;
}
const int MAXN = 1e3+10;
const int MAXG = 1e1;
int MinD[MAXN+5];
bool visited[MAXN+5];
vector<map<int,int>> G(MAXN+5);
vector<Station> stats(MAXG+5);
int N1,N2,R,maxRg,N;
bool flag;

int Idx(char c[]){
    int id;
    if(c[0]!='G'){
        sscanf(c,"%d",&id);
        return id;
    }
    else{
        sscanf(c+1,"%d",&id);
        return id+N1;
    }
}
void dijkstra(int S){
    ms(MinD,INF); ms(visited,false);
    MinD[S] = 0;
    priority_queue<P,vector<P>,greater<P>> q;
    q.push(P(MinD[S],S));
    while(!q.empty()){
        int x = q.top().second,m = q.top().first;
        q.pop();
        if(m>MinD[x]) continue;
        if(MinD[x]==INF) return;
        visited[x] = true;
        int d,l;
        for(auto it=G[x].begin();it!=G[x].end();++it){
            int d = it->first,l = it->second;
            if(!visited[d] && MinD[d]>MinD[x]+l){
                MinD[d] = MinD[x]+l;
                q.push(P(MinD[d],d));
            }
        }
    }
}

int main(){
//    freopen("input.txt","r",stdin);
//    freopen("myans.txt","w",stdout);
    char p1[5],p2[5];
    int ni,nj,l,minD,maxD;
    double sumD;
    while(~scanf("%d %d %d %d",&N1,&N2,&R,&maxRg)){
        G.clear(); G.resize(MAXN+5);
        stats.clear();
        N = N1+N2;
        for(int i=1;i<=R;++i){
            scanf("%s %s %d",p1,p2,&l);
            ni = Idx(p1); nj = Idx(p2);
            G[ni][nj] = G[nj][ni] = l;
        }
        for(int i=1;i<=N2;++i){
            dijkstra(i+N1);
            minD = INF; maxD = -1; sumD = 0;
            flag = true;
            for(int j=1;j<=N1;++j){
                if(MinD[j]>maxRg){
                    flag = false;
                    break;
                }
                sumD += MinD[j];
                maxD = max(maxD,MinD[j]);
                minD = min(minD,MinD[j]);
            }
            if(flag) stats.push_back(Station{i,minD,sumD/N1});
        }
        sort(stats.begin(),stats.end(),Cmp);
        if(!stats.size()) printf("No Solution\n");
        else printf("G%d\n%.1lf %.1lf\n",stats[0].id,stats[0].minD,int(stats[0].avgD*10+0.5)/10.0);
    }
    return 0;
}

二、Dijkstra普通版+DFS

例题：PAT A1111 Online Map (30point(s))

AC代码

#include <iostream>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdio>
#include <algorithm>
#include <functional>
using namespace std;
#define ms(Arr,Val) memset(Arr,Val,sizeof(Arr))
#define INF 0x3f3f3f3f

//8:18~8:25~16:47 ~0.5day
//AC 203ms G++6.5.0
//Dijkstra+DFS: 必须用此法,直接用dfs不论如何剪枝Case4都会TLE...
/*原先v1代码用纯dfs做的,结果Case4一直T,于是参考柳神和晴神(算法笔记书)的代码,写出了v2,然后就AC了。
 */
struct Road{
    int l,t;
};
const int MAXN = 5e2;
const int MAXC = 1e4;
bool visited[MAXN+5];
vector<vector<int>> G(MAXN+5);  //原图
vector<vector<int>> pG(MAXN+5); //Dijkstra简化后的逆序有向图,图中只包含从S到其它联通点的反向一级最短路
map<int,map<int,Road>> Map;
int MinD[MAXN+5]; //nodeId->minLen
int MinT[MAXN+5]; //nodeId->minTime
vector<int> path,sPath,fPath;
int N,R,S,D,minD,minT;
int minTime,minSteps;

void dijkstra1(){ //正向dijkstra: 将G简化为只含从S到其它联通点的反向一级最短路的有向图pG。
    for(int i=0;i<N;++i){
        int x = -1, MIN = INF;          //寻找V-S中MinD最小的节点x
        for(int j=0;j<N;++j){
            if(!visited[j] && MinD[j]<MIN){
                x = j;
                MIN = MinD[j];
            }
        }
        if(x==-1) return;               //找不到直接RET
        visited[x] = true;              //visited置位 (即x并入S)
        for(int j=0;j<G[x].size();++j){ //以x为中转对V-S更新MinD和pG
            int d = G[x][j];
            if(!visited[d]){
                int curD = MinD[x]+Map[x][d].l;
                if(curD<MinD[d]){
                    MinD[d] = curD;
                    pG[d].clear();
                    pG[d].push_back(x);
                }
                else if(curD==MinD[d]){
                    pG[d].push_back(x);
                }
            }
        }
    }
}
void dfs1(int x,int totalTime){ //逆向dfs：在pG上从D出发遍历查找到S的2~n级最短路。
    if(x==S){                   //(注)：1)形参表长为n,包括1个当前待拓展的节点Id,及其余n-1级判优信息;
        if(totalTime<minTime){  //      2)不需要用visited,因为pG里都是各点的最短路,不可能有回头路.
            minTime = totalTime;//      3)其他写法和原来的纯dfs一样,比如仍可以加入一些剪枝操作.
            sPath = path;
        }
        return;
    }
    for(int i=0;i<pG[x].size();++i){
        int s = pG[x][i];
        if(totalTime+Map[s][x].t>minTime) continue;
        path.push_back(s);
        dfs1(s,totalTime+Map[s][x].t);
        path.pop_back();
    }
}
void dijkstra2(){ //正向
    for(int i=0;i<N;++i){
        int x = -1, MIN = INF;
        for(int j=0;j<N;++j){
            if(!visited[j] && MinT[j]<MIN){
                x = j;
                MIN = MinT[j];
            }
        }
        if(x==-1) return;
        visited[x] = true;
        for(int j=0;j<G[x].size();++j){
            int d = G[x][j];
            if(!visited[d]){
                int curT = MinT[x]+Map[x][d].t;
                if(curT<MinT[d]){
                    MinT[d] = curT;
                    pG[d].clear();
                    pG[d].push_back(x);
                }
                else if(curT==MinT[d]){
                    pG[d].push_back(x);
                }
            }
        }
    }
}
void dfs2(int x,int steps){ //逆向
    if(x==S){
        if(steps<minSteps){
            minSteps = steps;
            fPath = path;
        }
        return;
    }
    for(int i=0;i<pG[x].size();++i){
        int s = pG[x][i];
        if(steps+1>minSteps) continue;
        path.push_back(s);
        dfs2(s,steps+1);
        path.pop_back();
    }
}
bool isIdent(){
    if(sPath.size()!=fPath.size()) return false;
    for(int i=0;i<sPath.size();++i){
        if(sPath[i]!=fPath[i]) return false;
    }
    return true;
}

int main(){
//    freopen("input.txt","r",stdin);
//    freopen("myans.txt","w",stdout);
    int ni,nj,oneWay,l,t;
    while(~scanf("%d %d",&N,&R)){
        G.clear(); G.resize(MAXN+5);
        Map.clear();
        for(int i=0;i<R;++i){
            scanf("%d %d %d %d %d",&ni,&nj,&oneWay,&l,&t);
            G[ni].push_back(nj);
            Map[ni][nj] = Road{l,t};
            if(oneWay==0){
                G[nj].push_back(ni);
                Map[nj][ni] = Road{l,t};
            }
        }
        scanf("%d %d",&S,&D);
        for(int i=1;i<=2;++i){
            ms(visited,false); ms(MinD,INF); ms(MinT,INF);
            pG.clear(); pG.resize(MAXN+5);
            path.clear();
            MinD[S] = MinT[S] = 0;
            minTime = minSteps = INF;
            if(i==1){
                dijkstra1();
                dfs1(D,0);
                minD = MinD[D];
            }
            else{
                dijkstra2();
                dfs2(D,0);
                minT = MinT[D];
            }
        }
        if(!isIdent()){
            printf("Distance = %d: ",minD);
            for(int i=sPath.size()-1;i>=0;--i){
                printf("%d -> ",sPath[i]);
            }
            printf("%d\nTime = %d: ",D,minT);
            for(int i=fPath.size()-1;i>=0;--i){
                printf("%d -> ",fPath[i]);
            }
        }
        else{
            printf("Distance = %d; Time = %d: ",minD,minT);
            for(int i=sPath.size()-1;i>=0;--i){
                printf("%d -> ",sPath[i]);
            }
        }
        printf("%d\n",D);
    }
    return 0;
}

三、纯DFS

例题：PAT A1030 Travel Plan (30point(s))

AC代码

#include <iostream>
#include <cstring>
#include <string>
#include <map>
#include <queue>
#include <vector>
#include <cstdio>
#include <algorithm>
using namespace std;
#define ms(Arr,Val) memset(Arr,Val,sizeof(Arr))
#define INF 1<<30

//10:38~11:01 23min
//AC 5ms G++6.5.0
//dfs裸题,两级判优: ZOJ上该题测试数据太基础,不加任何剪枝优化也能AC。。。对算法的时间性能要求太低了
/*与Bailian1724 Roads的对比：
 *POJ那题是要求在totalCost<=K的前提下找到totalLen最短的路线,比本题情况要复杂,需要在minLen上进一步剪枝,开单个数字记录minL无法回溯,
 *故使用minL[r.d][totalCost]表示费用为totalCost,且当前节点是r.d时的minLen值。
 */
struct Road{
    int d,l,t; //dest,distance,cost
};
const int MAXN = 5e2;
bool visited[MAXN+5];
vector<vector<Road>> G(MAXN+5);
int path[MAXN+5];
int bestPath[MAXN+5];
int N,R,S,D;
int minLen,minCost,minSteps;

void dfs(int x,int totalLen,int totalCost,int steps){
    if(x==D){
        if(totalLen<minLen || totalLen==minLen && totalCost<minCost){
            minLen = totalLen;
            minCost = totalCost;
            minSteps = steps;
            for(int i=0;i<=minSteps;++i) bestPath[i] = path[i];
        }
        return;
    }
    Road r;
    for(int i=0;i<G[x].size();++i){
        r = G[x][i];
        if(!visited[r.d]){
            if(totalLen+r.l>minLen) continue;
            if(totalLen==minLen && totalCost+r.t>minCost) continue;
            visited[r.d] = true;
            path[steps+1] = r.d;
            dfs(r.d,totalLen+r.l,totalCost+r.t,steps+1);
            visited[r.d] = false;
        }
    }
}

int main(){
//    freopen("input.txt","r",stdin);
//    freopen("myans.txt","w",stdout);
    int ni,nj,l,t;
    while(cin>>N>>R>>S>>D){
        for(int i=0;i<G.size();++i) G[i].clear();
        ms(visited,false); ms(path,0); ms(bestPath,0);
        for(int i=0;i<R;++i){
            cin>>ni>>nj>>l>>t;
            G[ni].push_back(Road{nj,l,t});
            G[nj].push_back(Road{ni,l,t});
        }
        minLen = minCost = minSteps = INF;
        visited[S] = true;
        path[0] = S;
        dfs(S,0,0,0);
        for(int i=0;i<=minSteps;++i){
            cout<<bestPath[i]<<" ";
        }
        cout<<minLen<<" "<<minCost<<endl;
    }
    return 0;
}

四、总结

算法适用场景特点备注
Dijkstra（pq）+DFS无负权图，要求路径或多级判优速度快，复杂度O(VlogV+E)推荐考试时写这个（节约时间）
Dijkstra（pq）无负权图，不输出路径速度快，复杂度O(VlogV+E) 
纯DFS无限制，全通用时间上较慢 
Flying_Dutch
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单源最短路径 DIJ算法（无堆优化）
Mollnn
07-17 1098
单源最短路径 DIJ算法（无堆优化）
dijkstra算法（无优化）
m0_62558103的博客
04-16 412
dijkstra算法是一种单源最短路算法，适用于无负边权的情况 分为朴素dijkstra O(n^2) (稠密图)和堆优化版本的dijkstra O(mlogn) （稀疏图） 本文为朴素版dijkstra算法模板，dis[i]数组表示起点s到任意点的最短路径长度。 #include<iostream> #include<cstring> using namespace std; const int inf=0x3f3f3f3f; int e[1005][1005],dis[1
dfs算法c语言 寻路,关于算法：在寻路中，DFS和Dijkstra有什么区别？
weixin_36455339的博客
05-25 282
我正在研究DFS和Dijkstra。在我的简单测试案例中，大多数都表明DFS更快。在我的测试案例中，传递每个节点的成本相同。但是在寻路中，大多数人更喜欢Dijkstra而不是DFS，因为Dijkstra如此精确。那么，DFS和Dijkstra有什么区别？另外，每种算法的优缺点是什么？由于Dijkstras本质上是BFS的泛化，因此基本上是DFS vs BFS何时可行的复制品？我不同意@Dukeli...
朴素版与堆优化版的Dijkstra算法
最新发布
weixin_53515812的博客
10-16 182
【代码】朴素版与堆优化版的Dijkstra算法。
【算法笔记】单源最短路问题——Dijkstra算法（无优化/优先队列/set优化）
天生我材必有用，千金散尽还复来。
08-13 3302
Dijkstra算法可在O(mlog⁡m)O(mlogm)或O(mlog⁡n)O(mlogn)的时间内求解无负权单源最短路问题。本文中，我们将详细介绍算法的原理、实现，以及常用的两种优化。另外，Dijkstra算法也不要乱用，比如说多源的最短路，用Dijkstra求解的复杂度只有O(nmlog⁡m)O(nmlogm)，但太麻烦，如果数据范围允许，直接用Floyd就能在O(n3)O(n3)...
标准C的图的实现+BFS和DFS遍历+Dijkstra算法+Prim算法+Kruskal算法实现
04-06
在这个项目中，"标准C的图的实现+BFS和DFS遍历+Dijkstra算法+Prim算法+Kruskal算法实现"涵盖了图的多种核心操作和算法。接下来，我们将详细讨论这些知识点。 首先，我们来看图的实现。在标准C语言中，图可以使用...
C++算法：图算法 （第3版）.rar
06-25
Dijkstra算法是最著名的单源最短路径算法，适用于带权重的图；Floyd-Warshall算法则可求解所有节点对之间的最短路径。这些算法广泛应用于路由选择、交通导航等场景。 最后，网络流问题研究如何在网络中高效地分配...
swift-algorithm:一堆带有Swift的算法
03-28
- 最短路径算法：Dijkstra算法和Bellman-Ford算法用于求解单源最短路径问题。 6. **字符串处理**： - KMP算法：在字符串中查找子串出现的位置，避免了不必要的回溯。 - Rabin-Karp滚动哈希：用于高效地进行字符...
30个经典算法汇总_带文档和源码
09-06
3. **图算法**：如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法、Kruskal算法，这些在解决网络问题、路由选择和社交网络分析中十分关键。 4. **动态规划(DP)**：如背包问题、最长公共子序列(LCS)...
坐在马桶上看算法(pdf带目录)
08-23
这本书带有目录，使得读者可以方便地查找和学习自己感兴趣的算法主题。 算法是计算机科学的灵魂，是解决复杂问题的有效工具。本书涵盖了基础的排序算法、搜索算法、图论算法以及一些高级算法，旨在帮助读者理解和...
未优化的dijkstra模板
String_idiot的博客
03-25 180
7-10 Dijkstra算法（模板） (30 分) 给一个n(1 ≤ n ≤ 2500) 个点 m(1 ≤ m ≤ 6200) 条边的无向图，求 s 到 t 的最短路。 输入格式: 第一行四个由空格隔开的整数 n、m、s、t。 之后的 m 行，每行三个正整数 si 、ti 、wi(1≤wi≤10^9 )，表示一条从si到 ti长度为 wi的边。 输出格式: 一个整数，表示从s 到t 的最短路径长度。数据保证至少存在一条道路。 输入样例: 7 11 5 4 2 4 2 1 4 3 7 2 2 3 4 3 5
简述dfs,bfs,Dijkstra思想及区别
hxshine的博客
05-24 1万+
在做pat的时候，用dfs写了一道题的解超时，看别人的解法时，发现别人用了Dijkstra算法，瞬间自己就混乱了，因为之前也看过Dijkstra，bfs算法，但是当时居然都傻傻分不清楚了，所以决定写一篇总结一下。 一：广度优先算法(BFS)         先搜索邻居，搜完邻居再搜邻居的邻居。 其中俩个思想：1.双端队列不为空则循环
Dijkstra算法修改 + dfs算法的总结
一天无聊
06-01 1048
Dijkstra + dfs 参考Dijkstra算法的改进 前提：Dijkstra算法的思路和实现请看最短路径算法之二：Dijkstra总结 介绍 Dijkstra算法和dfs算法的结合主要解决最短路径的边权之和、点权之和以及打印最短路径结点等问题。 通过Dijkstra算法找出单源点最短路径，在通过dfs 算法遍历最短路径中的结点。主要实现的方法是在Dijkstra算法每次更新dis数组的时候对可变大小的数组（vector）进行插入清除等操作，将每次更新的最短路径结点的前驱结点加入到 vector 中。
DFS算法
Sigmoid
01-29 186
void dfs(int now, int pre, int d[], vector<int> tree[])//Depth first search { int u;//u traverse all points in tree[now][] for(int i = 0; i < (int)tree[now].size(); ++i){ if ((u = tree[now][i]) != pre) { d[u] = d[now] +
PAT (Basic Level) 1045 柳婼、旭神两大思路分析【测试点】样例
qq_53269459的博客
02-19 449
1045 快速排序 (25 分) 著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。 给定划分后的 N 个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？ 例如给定 N=5N = 5N=5, 排列是1、3、2、4、5。则： 1 的左边没有元素，右边的元素都比它大，所以它可能是主元； 尽管 3 的左边元素都比它小，但其右边的 2 比它小，所以它不能是主元； 尽管 2 的右边元素都比它大，但其左边
C++ 求最短路径问题之Dijkstra算法（一）
YF_Li123的博客
07-02 2万+
求最短路径之Dijkstra算法 Dijkstra算法是用来求单源最短路径问题，即给定图G和起点s，通过算法得到s到达其他每个顶点的最短距离。 基本思想：对图G(V,E)设置集合S，存放已被访问的顶点，然后每次从集合V-S中选择与起点s的最短距离最小的一个顶点（记为u），访问并加入集合S。之后，令u为中介点，优化起点s与所有从u能够到达的顶点v之间的最短距离。这样的操作执行n次（n为顶点个数）
Dijkstra 之最短路径算法(无优化版本) By ACReaper
weixin_30750335的博客
04-26 83
最短路径，其实就是求我们日常生活中，从某点到达某点的最短路径，Dijkstra用了一种变通的方式，它是求出从源点到达所有点的最短路径长度。 分析: 这个算法采用的是贪心思想，而贪心算法能否达到最后，有两个必要不充分条件 1.必须要有最优子结构 2.必须具备贪心选择属性 1.最优子结构: 我们设d(i,j)表示从，结点Vi到Vj的最短路径值，则d（i，j） = ...
单源最短路 Dijkstra 算法原理详解、代码实现和复杂度分析
热门推荐
Alan-zzx的博客
02-05 2万+
图的最短路问题 图 (Graph) 是用途最广泛的数据结构之一，类似 Google 地图、百度地图等地图软件中寻找两地之间的路径，就需要将地图抽象成一张图，从图中计算得到合适的路径。 图分为很多种，例如：无向图，有向图，有向加权图等等，最简单的搜索算法深度优先和广度优先搜索都是用于无向图或有向图查找路径的，而针对加权的图的最短路，这两个方法就不管用了。 最短路的算法有很多种，我们今天要了解的是 D...
Dijkstra+DFS模板总结
Bing's Blog
03-02 1290
关于Dijstra的初级运用是，在第一标尺的基础上有下面三个角度： 边权：c[maxn] = {maxn}, cost[manx][maxn] = {inf}; 点权：w[maxn] = {0}, weight[maxn] = {0}; 最短路径条数：num[maxn] = {0}; a1003.cpp 用到了其中的两个，作为模板来刻意练习，练习如何将问题结构化，模板化。再额外补充边权的代码，不是这
17 7 图5-最短路径1
08-03
第七章 图7.1 图的定义和术语7.2 图的存储结构7.3 图的遍历7.4 图的连通7.5 有向无环图及其应用7.6 最短路径一．最短路径q 若用带权图表示交通

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值