【最短路-SPFA/Dijkstra】Codeforces Round #333 (Div. 2) C. The Two Routes

最新推荐文章于 2020-11-26 21:59:53 发布
最新推荐文章于 2020-11-26 21:59:53 发布
阅读量138 收藏
点赞数
分类专栏： # 最短路 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44049850/article/details/96730669
版权

Codeforces Round #333 (Div. 2) C. The Two Routes

  • 题意：有V个村庄，每两个村庄间都有路（铁路或公路，铁路和公路不重合，也就是说有铁路就没有公路），其中铁路有E条，让我们求从村庄1到村庄V的最短路径。如果沿着铁路走到不了或者沿着公路走到不了都输出-1，如果沿着铁路走和沿着公路走其各自最短路径的时间不一样，那就输出较大者。所有路径的边权都为1。
  • 思路：就是跑两个最短路的模板就可以了。就是要注意一下处理好边的情况就可以了，我这里是用的邻接矩阵来判断是不是铁路。

SPFA：
刚刚知道SPFA的一个小优化，就是用stack(后进后出)代替queue(后进前出)，会优化一点，十几ms，至于为什么我也不知道，可能是因为后进后出的话会先遍历完所有的点，所以会尽可能地减少重复入队的可能叭。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <map>
#define P(x) x>0?x:0
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef vector<int>:: iterator VITer;
const int maxV=405;
const int maxE=8e4;
int V,E;
bool mp[maxV][maxV];
bool T_inque[maxV],G_inque[maxV];
int T_dis[maxV],G_dis[maxV];
int T_head[maxV],G_head[maxV],T_cnt,G_cnt;
struct EDGE{
    int pre,to;
    EDGE(int a=0,int b=0):pre(a),to(b){}
};
EDGE T_edge[2*maxE];
EDGE G_edge[2*maxE];
void T_add_edge(int u,int v)
{
    T_edge[++T_cnt]=EDGE(T_head[u],v);
    T_head[u]=T_cnt;
}
void G_add_edge(int u,int v)
{
    G_edge[++G_cnt]=EDGE(G_head[u],v);
    G_head[u]=G_cnt;
}
void init()
{
    T_cnt=0;
    G_cnt=0;
    memset(mp, false, sizeof(mp));
    memset(T_head,-1, sizeof(T_head));
    memset(G_head,-1, sizeof(G_head));
}
int T_SPFA(int st,int ed)
{
    for(int i=1;i<=V;i++)
        T_dis[i]=(i==st ? 0 : INF);
    memset(T_inque,false, sizeof(T_inque));
    stack<int >s;
    s.push(st);
    T_inque[st]=true;
    while(!s.empty())
    {
        int tmp=s.top();
        s.pop();
        for(int i=T_head[tmp]; ~i ; i=T_edge[i].pre)
        {
            if(T_dis[T_edge[i].to]>T_dis[tmp]+1)
            {
                T_dis[T_edge[i].to]=T_dis[tmp]+1;
                if(!T_inque[T_edge[i].to])
                {
                    s.push(T_edge[i].to);
                    T_inque[T_edge[i].to]=true;
                }
            }
        }
        T_inque[tmp]= false;
    }
    return T_dis[ed];
}
int G_SPFA(int st,int ed)
{
    for(int i=1;i<=V;i++)
        G_dis[i]=(i==st ? 0 : INF);
    memset(G_inque,false, sizeof(G_inque));
    stack<int >s;
    s.push(st);
    G_inque[st]=true;
    while(!s.empty())
    {
        int tmp=s.top();
        s.pop();
        for(int i=G_head[tmp]; ~i ; i=G_edge[i].pre)
        {
            if(G_dis[G_edge[i].to]>G_dis[tmp]+1)
            {
                G_dis[G_edge[i].to]=G_dis[tmp]+1;
                if(!G_inque[G_edge[i].to])
                {
                    s.push(G_edge[i].to);
                    G_inque[G_edge[i].to]=true;
                }
            }
        }
        G_inque[tmp]= false;
    }
    return G_dis[ed];
}
int main()
{
    while(~scanf("%d%d",&V,&E))
    {
        init();
        for(int i=1;i<=E;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            T_add_edge(min(a,b),max(a,b));
            T_add_edge(max(a,b),min(a,b));
            mp[min(a,b)][max(a,b)]=true;
        }
        for(int i=1;i<=V;i++)
            for(int j=i+1;j<=V;j++)
                if(!mp[i][j])
                {
                    G_add_edge(i,j);
                    G_add_edge(j,i);
                }
        int GE=V*(V-1)/2-E;
        int ansT,ansG;
        if(GE==0||(ansT=T_SPFA(1,V))==INF||(ansG=G_SPFA(1,V))==INF)
            printf("-1\n");
        else
            printf("%d\n",max(ansT,ansG));
    }
    return 0;
}

Dijkstra【链式前向星】:
做了个小小的优化：dij终点取出来就可以直接return了。
然后今天发现dij有些概念模糊叭，反正就是又模拟了一遍dij，重新理解了一下。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <map>
#define P(x) x>0?x:0
#define INF 0x3f3f3f3f

using namespace std;
typedef long long ll;
typedef vector<int>:: iterator VITer;
const int maxV=405;
const int maxE=8e4;
int V,E;
bool mp[maxV][maxV];
struct EDGE{
    int pre,to;
    EDGE(int a=0,int b=0):pre(a),to(b){}
};
EDGE T_edge[maxE*2],G_edge[maxE*2];
int T_head[maxV],G_head[maxV],T_cnt,G_cnt;
int T_dis[maxV],G_dis[maxV];
bool T_vis[maxV],G_vis[maxV];
void T_add_edge(int u,int v)
{
    T_edge[++T_cnt]=EDGE(T_head[u],v);
    T_head[u]=T_cnt;
}
void G_add_edge(int u,int v)
{
    G_edge[++G_cnt]=EDGE(G_head[u],v);
    G_head[u]=G_cnt;
}
void init()
{
    T_cnt=0;
    G_cnt=0;
    memset(T_head,-1, sizeof(T_head));
    memset(G_head,-1, sizeof(G_head));
    memset(mp,false, sizeof(mp));
}
struct node{
    int point,val;
    node(int a=0,int b=0):point(a),val(b){}
    friend bool operator < (node n1,node n2) { return n1.val>n2.val; }
};
int T_dijkstra(int st,int ed)
{
    memset(T_vis,false,sizeof(T_vis));
    for(int i=1;i<=V;i++)
        T_dis[i]=(i==st ? 0 : INF);
    priority_queue<node>pq;
    pq.push(node(st,T_dis[st]));
    while(!pq.empty())
    {
        node tmp=pq.top();
        if(tmp.point==ed)
            return T_dis[ed];
        if(T_vis[tmp.point])
            continue;
        pq.pop();
        T_vis[tmp.point]=true;
        for(int i=T_head[tmp.point]; ~i ; i=T_edge[i].pre)
        {
            if(T_dis[T_edge[i].to]>T_dis[tmp.point]+1)
            {
                T_dis[T_edge[i].to]=T_dis[tmp.point]+1;
                pq.push(node(T_edge[i].to,T_dis[T_edge[i].to]));
            }
        }
    }
    return -1;
}
int G_dijkstra(int st,int ed)
{
    memset(G_vis,false,sizeof(G_vis));
    for(int i=1;i<=V;i++)
        G_dis[i]=(i==st ? 0 : INF);
    priority_queue<node>pq;
    pq.push(node(st,G_dis[st]));
    while(!pq.empty())
    {
        node tmp=pq.top();
        if(tmp.point==ed)
            return G_dis[ed];
        if(G_vis[tmp.point])
            continue;
        pq.pop();
        G_vis[tmp.point]=true;
        for(int i=G_head[tmp.point]; ~i ; i=G_edge[i].pre)
        {
            if(G_dis[G_edge[i].to]>G_dis[tmp.point]+1)
            {
                G_dis[G_edge[i].to]=G_dis[tmp.point]+1;
                pq.push(node(G_edge[i].to,G_dis[G_edge[i].to]));
            }
        }
    }
    return -1;
}
int main()
{
    while(~scanf("%d%d",&V,&E))
    {
        init();
        for(int i=1;i<=E;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            T_add_edge(a,b);
            T_add_edge(b,a);
            mp[min(a,b)][max(a,b)]=true;
        }
        for(int i=1;i<=V;i++)
            for(int j=i+1;j<=V;j++)
                if(!mp[i][j])
                {
                    G_add_edge(i,j);
                    G_add_edge(j,i);
                }
        int GE=V*(V-1)/2-E;
        int ansT,ansG;
        if(GE==0||(ansT=T_dijkstra(1,V))==-1||(ansG=G_dijkstra(1,V))==-1)
            printf("-1\n");
        else
            printf("%d\n",max(ansT,ansG));
    }
    return 0;
}

Djikstra【邻接矩阵】
这个题的话，其实是个稠密图，用链式前向星的话空间占据其实很大，也比较麻烦，时间优势差不多也没有多少。这时候用邻接矩阵就比较合适，省空间，也比较好写，一哈就写出来了。（听别人的建议所以补上的，确实比上面两个代码短也合适）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <list>
#include <map>
#define INF 0x3f3f3f3f
#define P(x) x>0 ? x : 0
#define MID l + r >> 1
#define lsn rt << 1
#define rsn rt << 1 | 1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr

using namespace std;
typedef long long ll;
typedef vector<int>:: iterator VITer;
const int maxN=405;
int mp[maxN][maxN],dis[maxN],vis[maxN];
int n,m;
struct node{
    int to,val;
    node(int a=0,int b=0):to(a),val(b){}
    friend bool operator < (node n1,node n2) { return n1.val>n2.val; }
};

int dijkstra(int st,int ed,int road)//铁路是1，公路是0
{
    memset(vis,0, sizeof(vis));
    for(int i=1;i<=n;i++)
        dis[i]=(i==st ? 0 : INF);
    priority_queue<node>pq;
    pq.push(node(st,dis[st]));
    while(!pq.empty())
    {
        node tmp=pq.top();
        pq.pop();
        if(vis[tmp.to])
            continue;
        for(int i=1;i<=n;i++)
        {
            if(mp[tmp.to][i]!=-1)
            {
                if(road && mp[tmp.to][i])//铁路
                {
                    if(dis[i]>dis[tmp.to]+1)
                    {
                        dis[i]=dis[tmp.to]+1;
                        pq.push(node(i,dis[i]));
                    }
                }
                else if(!road && !mp[tmp.to][i])//公路
                {
                    if(dis[i]>dis[tmp.to]+1)
                    {
                        dis[i]=dis[tmp.to]+1;
                        pq.push(node(i,dis[i]));
                    }
                }
            }
        }
        vis[tmp.to]=1;
    }
    return dis[ed];
}

void init()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                mp[i][j]=-1;
            else
                mp[i][j]=0;
        }
    }
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(int i=1;i<=m;i++)
        {
            int a,b; scanf("%d%d",&a,&b);
            mp[a][b]=1;
            mp[b][a]=1;
        }
        int T=dijkstra(1,n,1);
        int G=dijkstra(1,n,0);
        if(T==INF||G==INF)
            printf("-1\n");
        else
            printf("%d\n",max(T,G));
    }
    return 0;
}

My_Feeling：

  1. 过这道题用了5h+，QAQ，tcl，真的醉了，还好今天休息，不然我要疯了，还要哭了QAQ，这道题可是排位赛的时候有人半小时过了的，我做了那么久，tcl，我tcl
  2. 最开始的时候敲的是SPFA，后来交了之后CE？？？？？什么情况？？？？？？开始的时候多敲了一部分并查集，因为开始题意搞错了，所以用了并查集，后来又读了一遍发现理解错了，用不到，但是没删就交了，于是CE？？？？？我把它删了之后就没有CE了？？？跟这个有关系吗？它开始running了，然后T在了54组样例，当时还忘记了CF可以看错误样例。就先去吃了个饭，吃饭的时候还重新算了下时间复杂度，在范围内啊，但还是怕就卡了时间叭。然后知道用stack可以优化SPFA，于是试了一下，发现还是T在了54组。于是我就坚信它是卡了时间，于是我就又敲了一遍Dijkstra，然后20组就T了？？？？？？？什么情况。然后又到处优化了点小地方之后还是一样的T在了20组。
  3. 然后！！就突然灵光闪现想起可以看错误样例，然后看了下第54组，发现【第一行400 1】【第二行1 400】，然后就开始调试，发现CLion报错，运行不了？？？？是哪里的问题，找了半天没找出来，看了下数组也开够了，但是就是运行不了？？？？？后来我就想（小心思不可取）：把这组样例特判一下，本来是放在了处理完了G_edge[ ]的后面，然后发现还是不能跑，然后我又换在了那个for循环的前面然后交了，！竟然真的给过了……然后又开始debug，发现还是有的地方不能跑，出现了问题，CLion报错。到底是哪里？？？哎，好崩溃。后来的后来的后来，我发现我跑mp [ ][ ]的点跑错了，我(1,1)(2,2)这种点也跑了，所以数组溢出了QAQ，我的天呐！！！怪不得之前第一发CE了！QAQ……然后我就交了，然后SPFA就过了。
  4. 我的那个Dijkstra也是跟SPFA一样跑了(1,1)这种点，然后改了这里之后发现还是不能跑，？？？？调试的时候发现T_head[ ]，莫名其妙出现了G_head[ ]里面的值，开始的时候没有，到后来的时候就有了，为什么？？？又是后来的后来，我发现QAQ我的G_edge[ ]数组少开了一倍，我哭！！！啊啊啊，然后改了之后果然也过了
  5. 其实我的经历远不止这些，五个小时啊！QAQ，反正就各种错误叭。tcl
_7许
关注
专栏目录
最短路的Floyd-Dijkstra-Spfa板子
02-06
做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..
图论- 最短路- Bellman-Ford 算法与 SPFA.rar
09-16
SPFA是基于队列的一种启发式最短路径算法，主要针对Dijkstra算法在处理负权重边时的不足。虽然其具体实现细节可能因人而异，但通常包括以下步骤： 1. 初始化：创建一个队列，将源点加入队列，并将其到源点的距离设...
hairrrrr#1200_Problems#aw851.spfa求最短路1
07-25
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。接下来 m 行每行包含三个整数 x,y,z，表示存在
蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf
最新发布
02-18
### 图论中最短路径问题——Bellman-Ford算法与SPFA #### 1. 引言 在图论中，最短路径问题是一类非常重要的问题。它涉及到在一个加权图中找到从一个节点到另一个节点之间的最短路径。这类问题在实际应用中有着广泛...
E. Even Degree 【欧拉回路】
L_X_
10-17 1812
题目链接 题意 给一张图，当结点u，v的度不都是奇数时，我们可以删掉结点u，v之间的边。问：最多能删掉多少条边，并按照删除的顺序输出边的序号。题目不保证图是连通的，但是保证所有点的度在初始时都为偶数，也就是保证每个连通块都是一个欧拉回路。 思路 对于一个欧拉回路，我们先假装删除一条边让其变成一个欧拉通路，此时存在两个奇数度点。我们选择一个作为起点，一个作为终点。我们 dfs 从起点遍历到终点，在回溯时才往栈中存边，那么从栈底到栈顶就是正确的合法路径。问题是怎么找到这个路径呢？ 在欧拉通路中删边时，我
U41492 树上数颜色【dsu on tree】
L_X_
04-04 721
题目链接 题意：有一棵以 111 为根结点的树，树上每个结点有一个颜色，多组询问：问以 uuu 为根的子树上共有多少种不同的颜色。 解决该题，最暴力的做法就是对于每一棵子树都dfs一遍统计出答案，统计完清空：O(n2)O(n^2)O(n2)。但“听说”可以用dsu on tree优化： dsu on tree [ O(nlogn)O(nlogn)O(nlogn) ] 统计以结点 uuu 为根结点...
Find The Multiple（DFS/BFS）
L_X_
01-15 674
Find The Multiple 给定一个正整数n，请编写一个程序来寻找n的一个非零的倍数m，这个m应当在十进制表示时每一位上只包含0或者1。你可以假定n不大于200且m不多于100位。 提示：本题采用Special Judge，你无需输出所有符合条件的m，你只需要输出任一符合条件的m即可。 Input 输入包含多组数据，每组数据仅一行，只包含一个正整数n (1 &amp;amp;lt;= n &amp;amp;lt;= 20...
【判断MST的唯一性】POJ 1679 The Unique MST
L_X_
10-28 658
POJ 1679 The Unique MST 这道题非常非常非常非常非常的坑 不管怎么样吧，过了n久终于过了，而且还很迷。 说说AC思路： 我们将每条边的序号记录在id里 第一次，我们将边权升序，id降序，找到MST，记录MST所用的边的序号 第二次，我们将边权升序，id升序，找到MST，记录MST所用的边的序号 如果两次mst的结果不同，说明没有MST唯一 如果相同，那么我们将两次找到的MS...
F. Strange Memory
L_X_
11-26 590
题目链接 题意：给定一个结点个数为 nnn 的根为 111 的有根树，每个结点有一个权值 a[i]a[ i ]a[i]。我们需要找到所有满足 KaTeX parse error: Can't use function '\^' in math mode at position 6: a[u] \̲^̲{} a[v] == a[lc… 的点对 u,v{u, v}u,v ，统计所有这些点对 KaTeX parse error: Can't use function '\^' in math mode at p
P3376 【模板】网络最大流【EK算法+Dinic算法解】
L_X_
02-22 404
EK算法+Dinic算法
【BFS】 计蒜客T1214
L_X_
01-21 387
计蒜客T1214 就是一个带状态的简单搜索。 我真的吐了，比赛的时候MLE了n发，结果就差一个inque数组我就过了……因为没有判断相同点的相同状态有没有在队列中，所以爆了。我吐了我吐了我吐了我真的吐了……qaq 总而言之我太菜了。这个题疯狂MLE。想到是队列出了问题。但是愣死就是没想到再加一个数组。太久没做搜索了。 队长说的没错，连大一的都不如。 #include <iostr...
史莱姆（BFS）
L_X_
03-01 358
题目链接：https://ac.nowcoder.com/acm/problem/21722 题目大意：每个点都有特定的魔物，每个魔物有特定的攻击力，然后史莱姆要从起点到终点救静，当他的攻击力小于等于魔物的攻击力的时候他才能经过，求能够使史莱姆到达终点的他的初始攻击力最小是多少。 题解：这个就是用二分答案结合bfs来找就可以了。 #include &lt;iostream&gt; #include...
Three Kingdoms（BFS状压）（HDU3442）
L_X_
03-09 329
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3442 题目大意：就是有ABCDE五种塔，（其实不是塔，但是还是可以把它们看成塔），然后每种塔有特定的攻击范围和攻击力，其中，只有C可以走，其他的塔不能走。我们要从起点走到终点，看是否能走到，能走到就要找最小的伤害值。 另外就是每种塔的攻击只能有一次。 题解：我们先将每个点的伤害预处理一下，然后就开始b...
【两点间路径边权最大差值最小化】HDU 1598 find the most comfortable road
L_X_
10-31 324
HDU 1598 find the most comfortable road 枚举最小边权，找MST，在这个过程中，当起点和终点连在一起之后，就是一个差值 枚举完所有的边，找到差值最小 这个过程中总是可以找到使得两点间的边权最大差值最小的路径，没有反例就是证明 #include <iostream> #include <cstdio> #include <alg...
【拓扑排序+链式前向星+dp】SWUST Power OJ 2842 套娃问题
L_X_
07-18 311
SWUST Power OJ 2842 套娃问题 题意： 有n个套娃（三个属性长宽高l,w,h），ZQ的身高为m（ZQ可翻转），他要可以站在最里层的套娃里，也就是强制性要求套娃的高大于m。问最多有多少层的套娃。【一个俄罗斯套娃必须严格小于另一个才能放入其中】 思路： 对套娃的长宽高排序，使得l>w>h 建边构图DAG：跑两个for循环，如果tw[ i ]严格小于tw[ j ]，即...
【经典】DFS（棋盘问题）
L_X_
12-22 299
DFS（棋盘问题） 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 Input 输入含有多组测试数据。 每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n &amp;lt;= 8 , k ...
Connect（CF 1130C）——BFS
L_X_
03-01 296
题目链接：http://codeforces.com/problemset/problem/1130/C 题目大意：地图上有土地和水，爱丽丝要从起点到终点，但是她只能走土地，所以我们要建造最多一只桥让她到达终点。建桥的消耗是两点之间的距离的平方，问消耗最少是多少。 题解：就是两个队列，一个放起点能到的位置，一个放终点能到的位置，然后就遍历完所有的可行点的建桥消耗，取最小值。 起始可以将起点能走的区...
Fire!（双BFS）
L_X_
01-18 281
题目链接：https://vjudge.net/contest/274927#problem/H 题目大意：就是joe在迷宫值班（是真的不知道为啥要在迷宫值班），然后突然就着火了，最重要的是可以有不止一个地方着火！！！！！！！！然后判断joe能不能逃出去。 思路：就是先搜火势，记录下火势蔓延到每个点所需要的时间，然后再搜joe，看能否走出去。思路很好理解，嗯。 #include &amp;lt;stdio...
最短路徑算法详解：Dijkstra、Floyd、Bellman-Ford与SPFA
本文档是关于最短路问题的教程，涵盖了Dijkstra算法、Floyd算法、Bellman-Ford算法以及SPFA算法。这些算法都是解决图论中的经典问题，旨在寻找网络中两点间的最短路径或者所有点对的最短路径。 最短路徑問題是图论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值