强化阶段 Day 22 算法笔记 10.3 图的遍历

最新推荐文章于 2024-09-14 20:30:05 发布
最新推荐文章于 2024-09-14 20:30:05 发布
阅读量271 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122260983
版权
本文深入探讨了图论中的关键算法，包括使用邻接矩阵和邻接表实现的BFS，以及寻找图中最大帮派首领的策略。通过对微博转发、城市争夺战和最深根节点问题的实例分析，阐述了如何运用这些算法解决实际问题。同时，文章还介绍了如何处理并消除图中的边，并通过层次编号优化搜索过程。
摘要由CSDN通过智能技术生成

目录

1.Head of a Gang

2.邻接矩阵版bfs

3.邻接表

4.带层号

5.Forwards on Weibo

6.Battle Over Cities

7.Deepest Root

1.Head of a Gang

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=2005;
int g[maxn][maxn]={0},weight[maxn]={0};
map<string,int> stringtoint;
map<string,int> gang;
map<int,string> inttostring;
bool vis[maxn]={false};
int n,k;

void dfs(int nowvisit,int &head,int &membernum,int &totalweight){
	membernum++;
	vis[nowvisit]=true;
	if(weight[nowvisit]>weight[head]){
		head=nowvisit;
	}
	for(int i=0;i<n;i++){
		if(g[i][nowvisit]>0){
			totalweight+=g[i][nowvisit];
			g[i][nowvisit]=g[nowvisit][i]=0;
			if(vis[i]==false){
				dfs(i,head,membernum,totalweight);
			}
		}
	}
}

void dfstrave(){
	for(int i=0;i<n;i++){
		if(vis[i]==false){
			int head=i,membernum=0,totalweight=0;
			dfs(i,head,membernum,totalweight);
			if(membernum>2&&totalweight>k){
				gang[inttostring[head]]=membernum;
			}
		}
	}
}

int numperson=0;
int change(string a){
	if(stringtoint.find(a)!=stringtoint.end()){
		return stringtoint[a];
	}else{
		stringtoint[a]=numperson;
		inttostring[numperson]=a;
		return numperson++;
	}
}

int main(){
	
	scanf("%d%d",&n,&k);
	string a,b;
	int w;
	for(int i=0;i<n;i++){
		cin>>a>>b>>w;
		int id1=change(a);
		int id2=change(b);
		g[id1][id2]+=w;
		g[id2][id1]+=w;
		weight[id1]+=w;
		weight[id2]+=w;
	}
	
	dfstrave();
	cout<<gang.size()<<endl;
	map<string,int>::iterator it;
	for(it=gang.begin();it!=gang.end();it++){
		cout<<it->first<<" "<<it->second<<endl;
	}
	
	
	return 0;
}

2.邻接矩阵版bfs

void bfs(int u){
	queue<int> q;
	q.push(u);
	inq[u]=true;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int v=0;v<n;v++){
			if(inq[v]==false&&g[u][v]!=inf){
				q.push(v);
				inq[v]=true;
			}
		}
	}
}

void bfstrave(){
	for(int u=0;u<n;u++){
		if(inq[u]==false){
			bfs(u);
		}
	}
}

3.邻接表

const int maxv=100000;
int n,g[maxv][maxv];
bool inq[maxv]={false};

void bfs(int u){
	queue<int> q;
	q.push(u);
	inq[u]=true;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int v=0;v<n;v++){
			if(inq[v]==false&&g[v][u]!=inf){
				q.push(v);
				inq[v]=true;
			}
		}
	}
}

4.带层号

void bfs(int s){
	queue<node> q;
	node start;
	start.layer=0;
	start.value=s;
	q.push(start);
	inq[start.value]=true;
	while(!q.empty()){
		node topnode=q.front();
		q.pop();
		int u=topnode.value;
		for(int i=0;i<adj[u].size();i++){
			node next=adj[u][i];
			next.layer=topnode.layer+1;
			if(inq[next.value]==false){
				q.push(next);
				inq[next.value]=true;
			}
		}
	}
}

5.Forwards on Weibo

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxv=1010;
struct node{
	int id;
	int layer;
};
vector<node> adj[maxv];
bool inq[maxv]={false};

int bfs(int s,int l){
	int forwardnum=0;
	node start;
	start.id=s;
	start.layer=0;
	queue<node> q;
	q.push(start);
	inq[start.id]=true;
	while(!q.empty()){
		node topnode=q.front();
		q.pop();
		int id=topnode.id;
		for(int i=0;i<adj[id].size();i++){
			node now=adj[id][i];
			now.layer=topnode.layer+1;
			if(inq[now.id]==false&&now.layer<=l){
				q.push(now);
				inq[now.id]=true;
				forwardnum++;
			}
		}
	}
	return forwardnum++;
}

int main(){
	
	int n,l;
	scanf("%d%d",&n,&l);
	int follownum,id;
	node user;
	for(int i=1;i<=n;i++){
		user.id=i;
		scanf("%d",&follownum);
		for(int j=0;j<follownum;j++){
			scanf("%d",&id);
			adj[id].push_back(user);
		}
	}
	
	int numquery;
	scanf("%d",&numquery);
	int s;
	for(int i=0;i<numquery;i++){
		memset(inq,false,sizeof(inq));
		scanf("%d",&s);
		int numforward=bfs(s,l);
		printf("%d\n",numforward);
	}
	
	return 0;
}

6.Battle Over Cities

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=1111;
vector<int> g[maxn];

int father[maxn];
bool vis[maxn];

int findfather(int x){
	int a=x;
	while(x!=father[x]){
		x=father[x];
	}
	while(a!=father[a]){
		int z=a;
		a=father[a];
		father[z]=x;
	}
	return x;
}

void union(int a,int b){
	int fa=findfather(a);
	int fb=findfather(b);
	if(fa!=fb){
		father[fa]=fb;
	}
}

void init(){
	for(int i=1;i<maxn;i++){
		father[i]=i;
		vis[i]=false;
	}
}



int main(){
	
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	for(int i=0;i<m;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
	}
	int current;
	for(int i=0;i<k;i++){
		scanf("%d",&current);
		init();
		for(int i=1;i<=n;i++){
			for(int j=0;j<g[i].size();j++){
				int u=i,v=g[i][j];
				if(u==current||v==current) continue;
				union(u,v);
			}
		}
		int block=0;
		for(int i=1;i<=n;i++){
			if(i==currnt) continue;
			int fa=findfather[i];
			if(vis[fa]==false){
				vis[fa]=true;
				block++;
			}
		}
		printf("%d\n",block-1);
	}
	
	return 0;
}
#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=1005;
vector<int> g[maxn];
bool vis[maxn];

int currentpoint;
void dfs(int v){
	if(v==currentpoint) return;
	vis[v]=true;
	for(int i=0;i<g[v].size();i++){
		if(vis[g[v][i]]==false){
			dfs(g[v][i]);
		}
	}
}

int main(){
	
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	int a,b;
	for(int i=0;i<m;i++){
		scanf("%d%d",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
	}
	for(int i=0;i<k;i++){
		int block=0;
		scanf("%d",&currentpoint);
		memset(vis,false,sizeof(vis));
		for(int i=1;i<=n;i++){
			if(i!=currentpoint&&vis[i]==false){
				dfs(i);
				block++;
			}
		}
		printf("%d\n",block-1);
	}
	
	return 0;
}

7.Deepest Root

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=10005;
int father[maxn];
vector<int> g[maxn];
bool isroot[maxn]={false};

int findfather(int x){
	int a=x;
	while(x!=father[x]){
		x=father[x];
	}
	while(a!=father[a]){
		int z=a;
		a=father[a];
		father[z]=x;
	}
	return x;
}

void unions(int x,int y){
	int fx=findfather(x);
	int fy=findfather(y);
	if(fx!=fy){
		father[fx]=fy;
	}
}

void init(int n){
	for(int i=1;i<=n;i++){
		father[i]=i;
	}
}

int calblock(int n){
	int block=0;
	for(int i=1;i<=n;i++){
		isroot[findfather(i)]=true;
	}
	for(int i=1;i<=n;i++){
		block+=isroot[i];
	}
	return block;
}

int maxh=0;
vector<int> temp,ans;

void dfs(int u,int height,int pre){
	if(height>maxh){
		temp.clear();
		temp.push_back(u);
		maxh=height;
	}else if(height==maxh){
		temp.push_back(u);
	}
	for(int i=0;i<g[u].size();i++){
		if(g[u][i]==pre) continue;
		dfs(g[u][i],height+1,u);
	}
}

int main(){
	
	int n;
	scanf("%d",&n);
	init(n);
	for(int i=0;i<n-1;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
		unions(a,b);
	}
	int block=calblock(n);
	if(block!=1){
		printf("Error: %d components\n",block);
	}else{
		dfs(1,1,-1);
		ans=temp;
		dfs(ans[0],1,-1);
		for(int i=0;i<temp.size();i++){
			ans.push_back(temp[i]);
		}
		sort(ans.begin(),ans.end());
		printf("%d\n",ans[0]);
		for(int i=1;i<ans.size();i++){
			if(ans[i]!=ans[i-1]){
				printf("%d\n",ans[i]);
			}
		}
	}
	
	
	return 0;
}

是小肖啊！
关注
第11周 【项目3 - 图遍历算法实现】
qq_39837019的博客
11-16 338
/*   *Copyright  (c)2017,烟台大学计算机与控制工程学院       *All rights reservrd.            *作者：李欣豪  *完成时间：2017年11月16日       *版本号：v1.0       *问题描述: 实现图遍历算法，分别输出如下图结构的深度优先(DFS)遍历序列和广度优先遍历(BFS)序列。
第11周项目3- 图遍历算法实现
Rachel_71的博客
11-09 283
问题及代码： /*  * Copyright(c) 2017,烟台大学计算机学院  * All rights reserved.  * 文件名称:cpp1.  * 作    者:薛瑞琪  * 完成日期:2017 年 11 月 9 日  * 版 本 号:v1.0  *  * 问题描述: 实现图遍历算法，分别输出如下图结构的深度优先(DFS)遍历序列和广度优先遍历(BFS)序列。 
Day 46 算法笔记之提高篇（4）10.3 图的遍历
aixiaoxiao13的博客
11-28 199
目录 1.深度优先搜索 1.1邻接矩阵 2.2邻接表 2.3 Head of a Gang 2.广度优先搜索 2.1邻接矩阵 2.2邻接表 2.3层号版 2.4Forwards on Weibo 3.Battle Over Cities 3.1图 3.2并查集 4.Deepest Root 1.深度优先搜索 1.1邻接矩阵 const int maxv = 1000; const int inf = 100000000; int n,g[maxv][maxv]; bo
codeup《算法笔记》题目索引（题目+解析+代码）
热门推荐
漫浸天空的雨色的备忘录~
04-27 3万+
黑色的题目没有题解（题目本身错误，或者后端判题机有问题，或者博主本身能力不足做不出来= =），还请多担待~~ 如果想考PAT，不是很建议刷codeup里面的题目，如果有时间可以看一下我总结的经验，希望能帮助到你~~传送门——PAT考试经验总结（甲乙级均适用）~~想满分的请看这里！~~ 《算法笔记》2.1小节——C/C++快速入门->基本数据类型 《算法笔记》2.2小节——C/C++快速入...
算法笔记（胡凡）学习笔记@Kaysen
Kaysen_Zhao的博客
08-12 2364
本文旨在记录算法笔记学习过程中的收获和一些知识点，部分易错知识点只针对个人而言，CCF-CSP考试冲鸭！！！ Chapter 2 C/C++快速入门（易错知识点） 2.1 基本数据类型 变量定义注意区分大小写。 一、整型 整型int，32bit（4Byte），取值范围是，绝对值在范围内的整数都可以定义成int。 长整型long long，64bit（8Byte），取值范围是，绝对值超过的整数就需要用long long存储。 ...
JavaScript笔记
shine_my的博客
03-13 3294
JavaScript笔记
C++个人复习笔记（四）
TakahashiRyosuke的博客
06-12 535
文章目录第八章 继承 (Inheritance)8.1 引入8.1.1 为什么需要继承 why inherit？8.1.2 引例8.1.3 结论 第八章 继承 (Inheritance) 8.1 引入 8.1.1 为什么需要继承 why inherit？ 在 C++中代码的可重用性(software reusability)是通过继承(inheritance)这一机制来实现的。 如果没有掌握继承性，就没有掌握类与对象的精华。 8.1.2 引例 在”老师“与”学生“之前，代码重用性的思考。 //引例 //老师
狂神说MySQL学习笔记
Monk_Monster的博客
07-20 2285
目录 MySQL 1、初识MySQL 1.1为什么学数据库 1.2 什么是数据库 1.3 数据库分类 1.4 MySQL简介 1.5连接数据库 2、操作数据库 2.1操作数据库 2.2数据库的列类型 2.3数据库的字段类型（重点） 2.4 创建数据库表 2.5数据表的类型 2.6修改删除表 3、MySQL数据管理 3.1外键（了解） 3.2 DML语言（全记住） 3.3添加 3.4 修改 3.5 删除 4、DQL查询数据（最重点） 4.1DQL 4.2指定查询字
狂神说---MySQL笔记
m0_60139894的博客
12-06 2631
1、初始MySQL javaEE：企业级java开发 Web 前端（页面：展示，数据！） 后台（连接点：连接数据库JDBC，连接前端（控制，控制视图跳转，和给前端传递数据）） 数据库（存数据，Txt，Excel，word） 1.1、为什么学习数据库 岗位需求 现在的世界，大数据时代 得数据者得天下 被迫需求：存数据 数据库是所有软件体系中最核心得存在 DBA 1.2、什么是数据库 数据库（DB，DataBase） 概念:数据仓库，软件，安装在操作系统（window，linux，mac，…）之上！SQL，可以
算法知识点——常用输入输出数据的方式
5233的博客
09-12 316
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1221
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 330
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 514
64. 最小路径和。
拥塞控制算法为何失效，网络为何难以测量？
最新发布
Netfilter
09-14 4587
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 620
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
18068 选择排序
huang1xiao1sheng的博客
09-11 455
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
二分系列(二分查找)9/12
2301_78191305的博客
09-12 993
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
选择排序
shylyly_的博客
09-13 1102
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完
春节特辑：图解密训练Day6 - 图的算法实践
本文主要介绍了图相关的数据结构与算法知识，并提供了LeetCode上的相关练习题，目的是帮助学习者巩固和提高对图的理解与应用能力。在春节期间的7天特训中，作者整理了30个必知必会的代码实现，其中第六天聚焦于图。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值