虚点连边求解洛谷P3393逃离僵尸岛

最新推荐文章于 2023-12-07 01:30:51 发布
最新推荐文章于 2023-12-07 01:30:51 发布
阅读量151 收藏
点赞数
分类专栏： # 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roadtohacker/article/details/118361642
版权

题目给出了若干个定义为被僵尸控制的城市，意思就是不能进入；若干个安全的城市花费为 p p p，若干个危险的城市花费为 q q q，现在问从 1 1 1到 n n n的最少花费

  • 思路很清晰，我们显然需要求出所有的危险城市的标号，这样跑一遍 d i j k s t r a dijkstra dijkstra就行了，问题是如何高效地筛选出危险城市呢？
  • 和僵尸控制的城市之间距离小于 s s s的城市被称为危险城市，因为僵尸控制的城市是给定的，如果想从每个僵尸控制的城市出发跑若干次最短路，无疑是正确的，但是时间上显然有些紧张，因为数据范围是 1 0 5 10^5 105，那么是否可以考虑 b f s 或 者 d f s bfs或者dfs bfs或者dfs呢？
  • 先来看如何 d f s dfs dfs搜索，使用 d a n g e r danger danger数组表示危险城市，程序如下
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
#define int long long
const int MAXN = 2e6 + 100;
int C[MAXN];
int vis[MAXN];
int dis[MAXN];
int head[MAXN];
int danger[MAXN];
struct Edge{
    int next;
    int to;
    int val;
}edge[MAXN];
struct st{
    int ID;
    int d;
    bool operator<(st x)const{
        return x.d < d;
    }
};
int cnt;
void Add_Edge(int u, int v, int w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].val = w;
    head[u] = cnt++;
}
priority_queue<st> q;
void dijstra(int s){
    st now;
    now.d = dis[s] = 0;
    now.ID = s;
    q.push(now);
    while(!q.empty()){
        now = q.top();
        q.pop();
        s = now.ID;
        if(vis[s]) continue;
        vis[s] = 1;
        for(int i=head[s];i!=-1;i=edge[i].next){
            if(!vis[edge[i].to] && dis[edge[i].to] > edge[i].val + dis[s]){
                dis[edge[i].to] = dis[s] + edge[i].val;
                now.ID = edge[i].to;
                now.d = dis[edge[i].to];
                q.push(now);
            }
        }
    }
}
int A[MAXN], B[MAXN];
void dfs(int u, int num, int s){
    if(num == s) return;
    if(vis[u]) return;
    vis[u] = 1;
    for(int i=head[u];i!=-1;i=edge[i].next){
        danger[edge[i].to] = 1;
        vis[edge[i].to] = 0;
        dfs(edge[i].to, num + 1, s);
    }
}
signed main(){
    int n, m, k, s, a, b;
    int p, q;
    scanf("%lld%lld%lld%lld", &n, &m, &k, &s);
    scanf("%lld%lld", &p, &q);
    for(int i=0;i<k;i++){
        scanf("%lld", &C[i]);
    }
    memset(head, -1, sizeof head);
    for(int i=0;i<m;i++){
        scanf("%lld%lld", &a, &b);
        Add_Edge(a, b, 1);
        Add_Edge(b, a, 1);
        A[i] = a;
        B[i] = b;
    }
    for(int i=0;i<k;i++){
        dfs(C[i], 0, s);
        memset(vis, 0, sizeof vis);//!!!;
    }
    // for(int i=1;i<=n;i++){
    //     if(danger[i]) cout << i << endl;
    // }
    // return 0;
    int w;
    cnt = 0;
    memset(head, -1, sizeof head);
    memset(dis, 0x3f, sizeof dis);
    for(int i=0;i<k;i++){
        vis[C[i]] = 1;
    }
    for(int i=0;i<m;i++){
        // if(vis[A[i]] || vis[B[i]]) continue;
        if(danger[B[i]]) w = q;
        else w = p;
        Add_Edge(A[i], B[i], w);
        if(danger[A[i]]) w = q;
        else w = p;
        Add_Edge(B[i], A[i], w);
    }
    dijstra(1);
    if(!danger[n]) cout << dis[n] - p;
    else cout << dis[n] - q;
    return 0;
}
  • 搜索时可能出现一个错误，这个问题有距离的限制，有可能出现覆盖问题，如下图，如果先搜索到4，假设搜到3刚好停止，如果将3标记，那么就有可能导致5无法被搜索到
    在这里插入图片描述
  • 解决的办法就是在将要进行 d f s dfs dfs的节点的 v i s vis vis置为0，而后在 d f s dfs dfs的时候将 v i s vis vis置为1，这样就可以防止节点之间的覆盖问题
  • 但是如果使用上述 d f s dfs dfs方法，过不了最后两个点，转为使用 b f s bfs bfs，时间及格
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
#define int long long
const int MAXN = 2e6 + 100;
int C[MAXN];
int vis[MAXN];
int dis[MAXN];
int head[MAXN];
int danger[MAXN];
struct Edge{
    int next;
    int to;
    int val;
}edge[MAXN];
struct st{
    int ID;
    int d;
    bool operator<(st x)const{
        return x.d < d;
    }
    st(){}
    st(int ID, int d){
        this->ID = ID;
        this->d = d;
    }
};
int cnt;
void Add_Edge(int u, int v, int w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].val = w;
    head[u] = cnt++;
}
priority_queue<st> q;
void dijkstra(int s){
    st now;
    now.d = dis[s] = 0;
    now.ID = s;
    q.push(now);
    while(!q.empty()){
        now = q.top();
        q.pop();
        s = now.ID;
        if(vis[s]) continue;
        vis[s] = 1;
        for(int i=head[s];i!=-1;i=edge[i].next){
            if(!vis[edge[i].to] && dis[edge[i].to] > edge[i].val + dis[s]){
                dis[edge[i].to] = dis[s] + edge[i].val;
                now.ID = edge[i].to;
                now.d = dis[edge[i].to];
                q.push(now);
            }
        }
    }
}
int A[MAXN], B[MAXN];
void bfs(int k, int s){
    queue<st> q;
    st now;
    while(!q.empty()) q.pop();
    for(int i=0;i<k;i++){
        now.ID = C[i];
        now.d = 0;
        dis[now.ID] = 0;
        q.push(now);
        while(!q.empty()){
            now = q.front();
            q.pop();
            danger[now.ID] = 1;
            if(now.d == s) continue;
            vis[now.d] = 0;
            for(int i=head[now.ID];i!=-1;i=edge[i].next){
                int v = edge[i].to;
                if(dis[v] > dis[now.ID] + 1){
                    dis[v] = dis[now.ID] + 1;
                    if(!vis[v]){
                        q.push(st(v, dis[v]));
                        vis[v] = 1;
                    }
                }
            }
        }
        memset(vis, 0, sizeof vis);
    }
}
signed main(){
    int n, m, k, s, a, b;
    int p, q;
    scanf("%lld%lld%lld%lld", &n, &m, &k, &s);
    scanf("%lld%lld", &p, &q);
    for(int i=0;i<k;i++){
        scanf("%lld", &C[i]);
    }
    memset(head, -1, sizeof head);
    for(int i=0;i<m;i++){
        scanf("%lld%lld", &a, &b);
        Add_Edge(a, b, 1);
        Add_Edge(b, a, 1);
        A[i] = a;
        B[i] = b;
    }
    memset(dis, 0x3f, sizeof dis);
    bfs(k, s);
    // for(int i=1;i<=n;i++){
    //     if(danger[i]) cout << i << endl;
    // }
    // return 0;
    int w;
    cnt = 0;
    memset(head, -1, sizeof head);
    memset(dis, 0x3f, sizeof dis);
    for(int i=0;i<k;i++){
        vis[C[i]] = 1;
    }
    for(int i=0;i<m;i++){
        if(vis[A[i]] || vis[B[i]]) continue;
        if(danger[B[i]]) w = q;
        else w = p;
        Add_Edge(A[i], B[i], w);
        if(danger[A[i]]) w = q;
        else w = p;
        Add_Edge(B[i], A[i], w);
    }
    dijkstra(1);
    if(!danger[n]) cout << dis[n] - p;
    else cout << dis[n] - q;
    return 0;
}

虚点连边

  • 这个思路非常优秀，想法是这样的，加上一个虚点，因为这里面 0 0 0这个点没有被用到，所以人工加上一个 0 0 0点，把这个点和被僵尸占领的城市都连上，那么如果我从这个0点开始跑一边最短路，那么如果得到 d i s dis dis数组的值 ≤ s + 1 \leq s+1 ≤s+1，那么这个城市就是危险城市，因为被僵尸占领的城市和 0 0 0点之间的距离是1，这样时间复杂度显然可以大大降低，也是这道题的正解
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
using namespace std;
#define int long long
const int MAXN = 2e6 + 100;
int C[MAXN];
int vis[MAXN];
int dis[MAXN];
int head[MAXN];
int danger[MAXN];
struct Edge{
    int next;
    int to;
    int val;
}edge[MAXN];
struct st{
    int ID;
    int d;
    bool operator<(st x)const{
        return x.d < d;
    }
    st(){}
    st(int ID, int d){
        this->ID = ID;
        this->d = d;
    }
};
int cnt;
void Add_Edge(int u, int v, int w){
    edge[cnt].next = head[u];
    edge[cnt].to = v;
    edge[cnt].val = w;
    head[u] = cnt++;
}
priority_queue<st> q;
void dijkstra(int s){
    st now;
    now.d = dis[s] = 0;
    now.ID = s;
    q.push(now);
    while(!q.empty()){
        now = q.top();
        q.pop();
        s = now.ID;
        if(vis[s]) continue;
        vis[s] = 1;
        for(int i=head[s];i!=-1;i=edge[i].next){
            if(!vis[edge[i].to] && dis[edge[i].to] > edge[i].val + dis[s]){
                dis[edge[i].to] = dis[s] + edge[i].val;
                now.ID = edge[i].to;
                now.d = dis[edge[i].to];
                q.push(now);
            }
        }
    }
}
int A[MAXN], B[MAXN];
signed main(){
    int n, m, k, s, a, b;
    int p, q;
    scanf("%lld%lld%lld%lld", &n, &m, &k, &s);
    scanf("%lld%lld", &p, &q);
	memset(head, -1, sizeof head);
    for(int i=0;i<k;i++){
        scanf("%lld", &C[i]);
		Add_Edge(0, C[i], 1);
		Add_Edge(C[i], 0, 1);
	}
    for(int i=0;i<m;i++){
        scanf("%lld%lld", &a, &b);
        Add_Edge(a, b, 1);
        Add_Edge(b, a, 1);
	    A[i] = a;
        B[i] = b;
    }
    memset(dis, 0x3f, sizeof dis);
    dijkstra(0);//从0开始跑最短路，找危险城市
	for(int i=1;i<=n;i++){
		if(dis[i] <= s + 1) danger[i] = 1;
	}
    int w;
    cnt = 0;
    memset(head, -1, sizeof head);
    memset(dis, 0x3f, sizeof dis);
	memset(vis, 0, sizeof vis);
    for(int i=0;i<k;i++){
        vis[C[i]] = 1;
    }
    for(int i=0;i<m;i++){
        if(vis[A[i]] || vis[B[i]]) continue;
        if(danger[B[i]]) w = q;
        else w = p;
        Add_Edge(A[i], B[i], w);
        if(danger[A[i]]) w = q;
        else w = p;
        Add_Edge(B[i], A[i], w);
    }
    dijkstra(1);
    if(!danger[n]) cout << dis[n] - p;
    else cout << dis[n] - q;
    return 0;
}
Clarence Liu
关注
专栏目录
BVP_CDM_lowtqj_Thomas!_中心化差分法求解两点边值问题_源码
10-04
在本项目中，我们主要探讨的是使用中心化差分法来解决两点边值问题，并结合Thomas算法处理三对角线性方程组。这是一典型的数值分析与计算方法的应用，通常在科学计算和工程问题中非常常见。 首先，我们要了解**中心...
【洛谷】题解目录
以太以北
09-30 2457
练习就是考试，考试就是练习
并查集+虚点 [NOI2001]食物链（洛谷 P2024）
不知所云的博客
05-31 303
[NOI2001]食物链 题目描述 动物王国中有三类动物 A,B,C，这三类动物的食物链构成了有趣的环形。A 吃 B，B 吃 C，C 吃 A。 现有 N 个动物，以 1 － N 编号。每个动物都是 A,B,C 中的一种，但是我们并不知道它到底是哪一种。 有人用两种说法对这 N 个动物所构成的食物链关系进行描述： 第一种说法是 1 X Y，表示 X 和 Y 是同类。 第二种说法是 2 X Y，表示 X 吃 Y 。 此人对 N 个动物，用上述两种说法，一句接一句地说出 K 句话，这 K 句话有的是真的，有的是假
有限元法求解常微分方程--两点边值问题
08-22
在本案例中，我们讨论的是如何利用有限元法来求解特定类型的常微分方程——两点边值问题。 两点边值问题指的是一个一维常微分方程，它在区间[a, b]上的两端点a和b处具有特定的边界条件。具体来说，给定方程 `-u''(x...
基于C++实现的casadi优化求解NMPC源码(带详细注释).zip
09-21
基于C++实现的casadi优化求解NMPC源码(带详细注释).zip基于C++实现的casadi优化求解NMPC源码(带详细注释).zip基于C++实现的casadi优化求解NMPC源码(带详细注释).zip基于C++实现的casadi优化求解NMPC源码(带详细注释)...
MATLAB求解内点惩罚（可）.txt
03-03
MATLAB求解内点惩罚
最小生成树算法及例题
ComingLiu的博客
01-01 2096
什么是生成树？对连通图进行遍历，过程中经过的点和边的组合可看成一棵树，也叫生成树 目录最小生成树引入Prim算法习题Kruskal算法一个非常好的学习视频 最小生成树引入 世界上有着许许多多的铁路线、公路线，想要从一个城市到另一个城市修一条线路需要许多资金，当然，修路的方式有多种多样，现在我们想知道如何修路能使得这些城市之间形成一个通信网，并且使得总耗费最少呢？ 假设有n个城市，那么我们最少需要修n-1条路，这是明显的，把这些路连在一起，加上城市节点，就构成了一棵生成树，在这些生成树中，边权之和最小的.
最小斯坦纳树算法介绍
ComingLiu的博客
12-07 1460
斯坦纳树
匈牙利算法求解二分图最大匹配问题
ComingLiu的博客
11-22 1212
这是一个非常简单的问题，描述如下，给你两部分的点，问你最大匹配数是多少、 简单描述一下算法流程，首先我们先匹配左边，蓝1先匹配红2；接下来到蓝2，只能匹配红2，但是这这时候发现红2已经有主了，根据匈牙利算法思想，这时候回溯，找谁匹配的红2，发现是蓝1，那么这时候看看蓝1还有没有别的选择，一看可以是红4，所以这时候让蓝1匹配红4，蓝2匹配红2；之后是蓝3，先让他匹配红1，没矛盾；现在得到的二分图如下所示 那么现在轮到蓝4了，他只能跟红4匹配，但是红4已经有主了，这时候回溯看蓝1，他还有一个选择是红2，但
Floyd-Warshall算法及例题
ComingLiu的博客
01-18 1039
Floyd算法概要练习练习一练习二 概要 Floyd可以一次性求出所有节点之间的最短距离 这种算法主要采用了动态规划的思想，假设求从i到j的最短路径，那么寻找一个中间位置k，如果从i到k距离加上k到j的距离比直接从i到j小，那么就更新从i到j的最短路径 根据上面的设想，Floyd是由三层for循环组成的，第一层for循环显然是k，因为我们不知道谁来借助k，所以k应该放在最外面；里面的两层分别是i和j，这不难理解。 朴素的Floyd如下 void Floyd(int n){ for(int k=1
倍增求解最近公共祖先（LCA）问题
ComingLiu的博客
02-11 770
Lowest Common Ancestors介绍简要分析和朴素思路倍增算法 介绍 对于一棵树，常常有这样的问题，如下图，求出6和8节点的最近公共祖先节点 祖先节点就是指当前节点沿着链向上经过的节点，最近公共祖先节点就是两个询问节点沿着树链往上走直至相遇的第一个节点 简要分析和朴素思路 看完问题介绍直接能想到的做法就是沿着节点往上走，直到两个节点相遇，第一个位置就是LCA，为了验证这个想法，还是要找道题试一试 模板题 首先要建图，刚开始学习算法，主要掌握算法原理，除此之外越方便越好，那么最方便的建图
网络流及几种算法FF、EK、Dinic
ComingLiu的博客
12-26 758
网络流
树链剖分----使用线段树维护
ComingLiu的博客
07-19 547
在这里插入代码片
双连通分量回顾与总结
ComingLiu的博客
02-17 496
双连通分量定义点双连通分量割点割边边双连通分量 定义 点双连通分量 割点 割边 边双连通分量
AOE网的关键路径
ComingLiu的博客
01-03 494
目录引入AOE网的判断拓扑排序事件的最早发生时间和最晚发生时间活动的最早开始时间和最晚开始时间 引入 生活中往往有着这样的场景，我们想做一件事情，但是需要做其他的事情来达到这件事情，例如，学数据结构之前，首先需要学一门程序设计语言，还要学习离散数学，如果学语言需要耗费半年时间，学离散数学需要一年事件，那么我们能学数据结构需要的最短时间是一年 但是，这样的场景往往出现在工程项目中，往往有许许多多的事件和活动，我们需要做的是找到能够影响整个工程进行时间的那一条路径，这个过程类似于木桶原理，这条路径应该是最长的
2 - sat 原理和简单例题
ComingLiu的博客
02-19 437
问题 有nnn个布尔变量，其中一些布尔变量之间有限制关系，用所有nnn个布尔变量组成序列，使得其满足所有限制关系；判断序列是否存在，这就是SAT(Satisfiability)SAT(Satisfiability)SAT(Satisfiability)问题，如果每个限制关系只涉及两个变量，则是2−SAT2-SAT2−SAT问题 因为方案的数量是O(2n)O(2^n)O(2n)的，所以一般只输出有无方案或者输出一组方案（字典序最小）等等 原理 就只用语言描述了，不懂可以看oi-wiki或者知乎或者洛
Codeforces Round #809 (Div. 2) E. Qpwoeirut and Vertices kruskal重构树+LCA+ST表
ComingLiu的博客
07-20 238
Codeforces Round #809 (Div. 2)
使用Tarjan算法计算强连通分量
ComingLiu的博客
07-02 237
SCC强连通分量Tarjan算法求解SCC练习 强连通分量 强连通分量（Strongly Connected Component）简称SCC 首先要理解一个定义，什么是强连通分量 所谓强连通，有两个点uuu和vvv，从uuu到vvv有一条路径，从vvv到uuu也有一条路径，那么说这两个点之间是强连通的，也叫做互相可达；如果一个有向图GGG中的任意两个点之间都是强连通的，那么就说这个图是一个强连通图 强连通分量。如果一个有向图GGG不是强连通图，那么可以把它分成多个子图，且每个子图的内部是强连通的，而且这些
洛谷p1789C语言代码
最新发布
11-07
题目P1789（C语言代码）通常是指在线编程平台洛谷（LeetCode in C）上的一个问题。在这个平台上，你可以找到各种算法题目，并查看其他用户提供的C语言解决方案。每个问题都有详细的描述、输入输出样例以及提交代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clarence Liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值