感染法和广度优先搜索及时间复杂度分析 —— NC269999 小红走矩阵

最新推荐文章于 2024-08-01 12:00:00 发布
最新推荐文章于 2024-08-01 12:00:00 发布
阅读量1.9k 收藏 26
点赞数 43
文章标签： 宽度优先 矩阵 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1557137513/article/details/136620896
版权

题目来源：

牛客周赛 Round 36

题目如下：

题目 小红走矩阵
小红来到了一个n∗m的矩阵，她初始站在左上角，每次行走可以按“上下左右”中的一个方向走一步，但必须走到和当前格子不同的字符，也不能走到矩阵外。
小红想知道，从左上角走到右下角最少需要走多少步？

输入

第一行输入两个正整数n,m，用空格隔开。代表矩阵的行数和列数。

接下来的n行，每行输入一个长度为m的、仅由小写字母组成的字符串，用来表示矩阵。

1≤n,m≤1000

输出

如果无法到达右下角，则输出-1。 否则输出一个整数，代表行走的最小步数。

尝试：感染法：

将该问题视作图论中的连通性问题，周围四个字母若与被识别字母不同则说明这两个字母是连通的，则可以考虑考虑时间因素的感染法：

其图解如下：

希望：对每个传染源，我们需要记录周围可以传播的被传染者作为下一次传播的传染源，不重不漏。

定义结构体点，同时为了使用unordered_set（不重不漏）,使用自定义哈希函数：

struct Point {
    int x, y;
    // 重载相等操作符，用于std::unordered_set的去重
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
    Point(int iptx,int ipty){
        x = iptx; y = ipty;
    }
};

// 自定义哈希函数，用于std::unordered_set的哈希计算
namespace std {
    template <>
    struct hash<Point> {
        size_t operator()(const Point& p) const {
            return hash<double>()(p.x) ^ hash<double>()(p.y);
        }
    };
}

然后利用传染源去检测被传染者，并将这一回合的被传染者作为下一次的传染源，利用布尔矩阵记录某个点是否被传染。

如果没有传染到任何一个单位，那么infecting赋值为false，停止模拟传染：

bool infecting = true;
int tick = 0;

void testInfect(Point point,vector<string> charmap,vector<vector<bool>>& bmap,unordered_set<Point>& nextSource){
	int mx = charmap.size()-1;
	int my = charmap[0].size()-1;
	int x = point.x;
	int y = point.y;
	vector<vector<int>> testpoint = {{x+1,y},{x,y+1},{x-1,y},{x,y-1}};
	for(vector<int> p : testpoint){
		if((0<=p[0] && p[0]<=mx) && (0<=p[1] && p[1]<=my) && (charmap[p[0]][p[1]]!=charmap[x][y]) && (bmap[p[0]][p[1]]==false)){
			bmap[p[0]][p[1]] = true;
			infecting = true;
            nextSource.insert(Point(p[0],p[1]));
		}
	}
}

void scan(vector<string> charmap,vector<vector<bool>>& bmap,unordered_set<Point>& source){
	infecting = false;
	int mx = charmap.size()-1;
	int my = charmap[0].size()-1;
    unordered_set<Point> nextSource;
    for(Point sourcepoint : source){
        int x = sourcepoint.x;
        int y = sourcepoint.y;
        testInfect({x,y},charmap,bmap,nextSource);
    }
	if(infecting){
		tick++;
        source = nextSource;
	}
}

完整代码如下：

#include<bits/stdc++.h>
using namespace std;
bool infecting = true;
int tick = 0;

struct Point {
    int x, y;
    // 重载相等操作符，用于std::unordered_set的去重
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
    Point(int iptx,int ipty){
        x = iptx; y = ipty;
    }
};

// 自定义哈希函数，用于std::unordered_set的哈希计算
namespace std {
    template <>
    struct hash<Point> {
        size_t operator()(const Point& p) const {
            return hash<double>()(p.x) ^ hash<double>()(p.y);
        }
    };
}

void testInfect(Point point,vector<string> charmap,vector<vector<bool>>& bmap,unordered_set<Point>& nextSource){
	int mx = charmap.size()-1;
	int my = charmap[0].size()-1;
	int x = point.x;
	int y = point.y;
	vector<vector<int>> testpoint = {{x+1,y},{x,y+1},{x-1,y},{x,y-1}};
	for(vector<int> p : testpoint){
		if((0<=p[0] && p[0]<=mx) && (0<=p[1] && p[1]<=my) && (charmap[p[0]][p[1]]!=charmap[x][y]) && (bmap[p[0]][p[1]]==false)){
			bmap[p[0]][p[1]] = true;
			infecting = true;
            nextSource.insert(Point(p[0],p[1]));
		}
	}
}

void scan(vector<string> charmap,vector<vector<bool>>& bmap,unordered_set<Point>& source){
	infecting = false;
	int mx = charmap.size()-1;
	int my = charmap[0].size()-1;
    unordered_set<Point> nextSource;
    for(Point sourcepoint : source){
        int x = sourcepoint.x;
        int y = sourcepoint.y;
        testInfect({x,y},charmap,bmap,nextSource);
    }
	if(infecting){
		tick++;
        source = nextSource;
	}
}

int main(){
	int x,y;
	cin >> x >> y;
	vector<string> charmap(x);
	vector<vector<bool>> bmap(x,vector<bool>(y,false));
	bmap[0][0]=true;
	for(int i=0;i<x;i++){
		cin >> charmap[i];
	}
    unordered_set<Point> source;
    Point start = Point(0,0);
    source.insert(start);
	while(infecting){
		if(bmap[x-1][y-1]==true){
			cout << tick;
			return 0;
		}
		scan(charmap,bmap,source);
	}
	cout << -1;
	return 0;
}

过了一部分用例，剩下的用例超时了。。

时间复杂度分析：

主要组成部分

  1. 主函数 (main)

    • 读取输入：O(x)，其中 x 是地图的行数。
    • 初始化数据结构：O(xy)，其中 y 是地图的列数。

  2. scan 函数

    • 遍历 source 集合，并对每个元素调用 testInfect 函数。

  3. testInfect 函数

    • 对每个源点，检查其上下左右四个方向是否可以感染新的点，并将可感染的点添加到下一轮的源点集合中。

时间复杂度分析

  1. 初始化复杂度

    • 初始化地图和布尔矩阵的复杂度为 O(xy)。

  2. 感染过程复杂度

    • 每次感染过程中，最坏情况下，每个格子都可能被作为源点处理一次，即每个格子都可能被遍历一次来尝试感染其周围的格子。
    • 对于每个源点，testInfect 函数会检查其四个方向，是一个常数时间操作，即 O(1)。
    • 最坏情况下，整个地图上的每个点都至少被遍历一次作为源点，因此这部分的时间复杂度是 O(xy)。

  3. 哈希表操作复杂度

    • 插入和查找操作通常是 O(1)，在极端情况下（极端的哈希冲突）可能退化到 O(n)，但这种情况很少见，特别是使用良好设计的哈希函数时。
    • 在这个场景中，由于 unordered_set 中存储的元素数量最多与地图大小相同，即 O(xy)，因此这部分操作的平均情况可以认为是 O(1)。

总结

  • 初始化：O(xy)
  • 每轮感染：O(xy)（每个点最多被处理一次）
  • 哈希表操作：平均 O(1)，不会显著影响总体时间复杂度

因此，总体时间复杂度是 O(xy)。这里假设感染过程会覆盖整个地图，即每个点至少被访问一次。实际的运行时间可能由于地图的具体内容和感染的起始位置而有所不同，但从理论上讲，这是对该算法时间复杂度的一个合理估计。

之后我参照题解，结合个人的代码习惯重新写了一遍新的算法：具体思路：

定义结构体point,记录点坐标信息和走到该点的最小步数：

const int INF = 0x3f3f3f3f;

struct point{
    int x,y,minstep;
    point(int iptx,int ipty){
        x=iptx;y=ipty;minstep=INF;
    }
};

构建广度优先搜索函数：当队列不为空，检测队首点是否能感染周围四个点：检测能感染的条件：

i.边界条件：检测的四个点不能超过边界。

ii.最小步数条件：周围点的最小步数大于从队首点最小步数+1。

一旦能感染，则将周围被感染的点加入队列末尾。无论是否能感染，都将队首元素弹出。

广度优先搜索代码如下：

void bfs(vector<string> charmap,vector<vector<point>>& pointmap){
    int mx=charmap.size()-1;
    int my=charmap[0].size()-1;
    queue<point> q;
    q.push(pointmap[0][0]);
    vector<int> dx = {1,-1,0,0}; vector<int> dy = {0,0,1,-1};
    while(q.size()){
        point cur = q.front();
        int cstep = cur.minstep+1;
        for(int i=0;i<4;i++){
            int x = cur.x;int y = cur.y;
            int cx = cur.x + dx[i];int cy=cur.y + dy[i];
            if(0<=cx && cx<=mx && 0<=cy && cy<=my && 
            charmap[x][y]!=charmap[cx][cy] &&
            (pointmap[cx][cy].minstep > cstep)){
                pointmap[cx][cy].minstep = cstep;
                q.push(pointmap[cx][cy]);
            }
        }
        q.pop();
    }
}

完整代码如下：

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;

struct point{
    int x,y,minstep;
    point(int iptx,int ipty){
        x=iptx;y=ipty;minstep=INF;
    }
};

void bfs(vector<string> charmap,vector<vector<point>>& pointmap){
    int mx=charmap.size()-1;
    int my=charmap[0].size()-1;
    queue<point> q;
    q.push(pointmap[0][0]);
    vector<int> dx = {1,-1,0,0}; vector<int> dy = {0,0,1,-1};
    while(q.size()){
        point cur = q.front();
        int cstep = cur.minstep+1;
        for(int i=0;i<4;i++){
            int x = cur.x;int y = cur.y;
            int cx = cur.x + dx[i];int cy=cur.y + dy[i];
            if(0<=cx && cx<=mx && 0<=cy && cy<=my && 
            charmap[x][y]!=charmap[cx][cy] &&
            (pointmap[cx][cy].minstep > cstep)){
                pointmap[cx][cy].minstep = cstep;
                q.push(pointmap[cx][cy]);
            }
        }
        q.pop();
    }
}

int main(){
    int x,y;
    cin >> x >> y;
    vector<string> charmap(x);
    for(int i=0;i<x;i++){
        cin >> charmap[i];
    }
    vector<vector<point>> pointmap(x,vector<point>(y,point(0,0)));
    for(int i=0;i<x;i++){
        for(int j=0;j<y;j++){
            pointmap[i][j]=point(i,j);
        }
    }
    pointmap[0][0].minstep=0;
    bfs(charmap,pointmap);
    if(pointmap[x-1][y-1].minstep==INF){
        cout << -1;
        return 0;
    }
    else{
        cout << pointmap[x-1][y-1].minstep;
        return 0;
    }
}

这段代码能全过，时间复杂度分析如下：

主要组成部分

  1. 主函数 (main)

    • 读取输入：O(x)，其中 x 是地图的行数。
    • 初始化 pointmap：O(xy)，其中 y 是地图的列数。

  2. bfs 函数

    • 广度优先搜索过程，每个点最多被访问一次。

时间复杂度分析

  1. 初始化复杂度

    • 初始化 charmap 和 pointmap 的复杂度为 O(xy)。

  2. 广度优先搜索复杂度 (bfs)

    • 在 BFS 中，每个点至多入队一次，并且出队后检查其四个方向的邻居。对于每个点，检查和更新四个方向的操作是常数时间的，即 O(1)。
    • 因此，对于整个地图上的 x\times y 个点，总的时间复杂度为 O(xy)。

总结

  • 初始化：O(xy)
  • 广度优先搜索 (bfs)：O(xy)

因此，这段代码的总体时间复杂度是 O(xy)。这意味着算法的执行时间与地图的大小线性相关，对于每个格子，算法最多处理一次。这是广度优先搜索在这类问题上的典型表现。

很怪，两个算法的时间复杂度都是O(xy)，第一个在部分用例上会超时，第二个却能过。

说实话我还是觉得第一个比较容易想到。这也许涉及到常数优化方面的内容，但本人才疏学浅，就不展开了。希望大佬能指出问题所在。

感谢你能看到这里。

钱铭锐
关注
广度优先搜索构建迷宫（BFS算法）动态构建过程_深度优先算法时间复杂度
11-23
**广度优先搜索（BFS）**是一种在图或树中搜索节点的算法，它从根节点开始，然后逐层地探索所有相邻节点，直到找到目标节点或遍历完所有节点。在迷宫生成中，BFS算法常用于构建一个随机但可解的路径结构。 在迷宫...
深度优先搜索与广度优先搜索
Hopefully Sky的博客
07-10 7603
算法是作用于具体数据结构之上的，深度优先搜索算法和广度优先搜索算法都是基于“图”这种数据结构的。
广度优先搜索
weixin_45730532的博客
05-16 1319
广度优先搜索
【每日一题】【最短路】【BFS】小红走矩阵 “葡萄城杯”牛客周赛 Round 53 F题 C++
最新发布
weixin_72899100的博客
08-01 989
【每日一题】【最短路】【BFS】小红走矩阵 “葡萄城杯”牛客周赛 Round 53 F题 C++
广度优先搜索（BFS）算法
beenles的博客
06-07 3859
广度优先搜索算法（BFS）是一种用于遍历图形结构的算法，它从一个起始顶点开始，先依次访问这个顶点的所有邻居顶点，然后再按照距离逐层遍历图中的所有顶点。BFS算法使用队列数据结构来实现，在访问完一个顶点后，将其未被访问的邻居加入队列中，并标记为已访问，然后从队列中取出下一个未被访问的顶点，重复以上过程，直到队列为空为止。BFS算法可以用于解决图中的许多问题，例如找出两个顶点之间的最短路径、判断图是否为二分图等。BFS算法的时间复杂度为O(V+E)，其中V为顶点数，E为边数。
2021寒假——洛谷刷题计划（35题）
DanmoSAMA的博客~
01-29 5014
（寒假结束后关闭私密） P5705 【深基2.例7】数字反转 题目描述 输入一个不小于 100100 且小于 10001000，同时包括小数点后一位的一个浮点数，例如 123.4123.4 ，要求把这个数字翻转过来，变成 4.3214.321 并输出。 输入格式 一行一个浮点数 输出格式 一行一个浮点数 #include <stdio.h> int Strlen(char str[]); void StrReverse(char str[]); //这里不需要考虑传入二级指针......
牛客周赛 Round 36-----＞E.小红的小红走矩阵
qq_75103498的博客
03-11 302
构造算法
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素表示图中两个节点之间是否存在边。如果节点i与节点j之间存在边，则邻接矩阵的[i]...
分析算法时间复杂度java.zip
10-13
6. **图**：图数据结构用于表示对象之间的关系，常用操作包括遍历（深度优先搜索DFS、广度优先搜索BFS）和查找最短路径等，时间复杂度与图的结构有关。 在Java中，理解和分析这些数据结构及其操作的时间复杂度，...
深度优化搜索，字典树
u014114223的博客
04-12 1021
小红来到了一个n∗m的矩阵，她初始站在左上角，每次行走可以按“上下左右”中的一个方向走一步，但必须走到和当前格子不同的字符，也不能走到矩阵外。小红想知道，从左上角走到右下角最少需要走多少步？
广度优先搜索算法（BFS）的原理
小白
04-02 1517
它的思想是从起始点开始，依次访问其所有直接相邻的节点，然后再依次访问这些相邻节点的相邻节点，直到找到目标节点或者搜索完整个图。BFS一般采用队列来实现，从起始节点开始将其放入队列中，然后循环从队列中取出一个节点，遍历该节点的所有相邻节点，将未访问的相邻节点加入队列中。接下来，我们从队列的左侧（即队头）取出一个节点node，如果该节点就是我们要找的目标节点end，那么我们就返回distance[end]，表示起始节点到目标节点的距离。可以发现，起始节点A到目标节点F的最短距离为2，符合我们预期的结果。
数据结构与算法 —— 图的搜索算法（广度/深度优先搜索）以及python实现
‘’
04-21 4090
图的搜索算法：图的搜索是指从图的某个顶点出发，沿着边连接的其他顶点，最后到达目标顶点的过程。根据搜索过程中访问节点的顺序，图搜索算法可以分为“广度优先搜索”和“深度优先搜索”两类。一、广度优先搜索（这两种搜索算法的核心操作都是搜索和扩展节点，只是在选择下一个节点的方式上有所不同。广度优先搜索选择最近扩展的节点的相邻节点作为下一个要扩展的节点，而深度优先搜索则选择当前节点的一个未被访问的子节点作为下一个要扩展的节点。
牛客周赛51：小红走矩阵（二分+bfs）
2301_80718054的博客
07-20 537
来源：牛客网。
广度优先搜索及其与DFS的比较和时间复杂度
weixin_52634719的博客
12-28 1868
非连通图 访问一个点，接下来去访问它的邻接点，扩大一层，再去访问邻接点的邻接点，又扩大一层， 和树的层次遍历很像：先是根结点，然后是根结点的孩子，然后是根结点孩子的孩子，从左到右。现在是从顶点出发，到邻接点，再到邻接点的邻接点。 树的层次遍历是用队列实现的，先根结点入队，然后是孩子入队，这里也用队列准备好，头尾指针。也把visit数组准备好 这里讲的有点乱 非递归算法，队列，把每一个邻接点入队 时间效率分析： DFS和B...
深度和广度优先搜索算法
weixin_33701617的博客
12-05 489
在社交网络中，有一个六度分割理论，具体是说，世界上任何互不相识的两人，平均只需要六步就能够建立起联系。一个用户的一度连接用户就是他的好友，二度连接用户就是他好友的好友，三度连接用户就是他好友好友的好友。 给定一个用户，如何找出这个用户的所有三度（包括一度、二度和三度）好友关系呢？ 1. 什么是 “搜索” 算法 我们知道，算法都是作用于某种...
LeetCode 886. 可能的二分法
weixin_62275996的博客
10-17 600
🌈🌈😄😄 欢迎来到茶色岛独家岛屿，本期将为大家揭晓可能的二分法，做好准备了么，那么开始吧 🌲🌲🐴🐴
LeetCode：542. 01 矩阵————中等
Kinght_123的博客
07-28 301
目录题目解题思路Code运行结果 题目 542. 01 矩阵 给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。 两个相邻元素间的距离为 1 。 示例 1： 输入：mat = [[0,0,0],[0,1,0],[0,0,0]] 输出：[[0,0,0],[0,1,0],[0,0,0]] 示例 2： 输入：mat = [[0,0,0],[0,1,0],[1,1,1]] 输出：[[0,0,0],[0,1,0],[1,2,1]]
广度优先搜索的时间复杂度和空间复杂度
06-02
广度优先搜索的时间复杂度为O(V+E)，其中V是顶点数，E是边数。这是因为在最坏情况下，每个顶点和每条边都会被访问一次。 广度优先搜索的空间复杂度也为O(V+E)，因为需要使用一个队列来存储待访问的节点，最坏情况下...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值