算法课复习 -- 图、BFS

最新推荐文章于 2024-07-17 17:40:04 发布
最新推荐文章于 2024-07-17 17:40:04 发布
阅读量111 收藏
点赞数
分类专栏： 算法课复习 文章标签： 图论 bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40993793/article/details/86162233
版权

POJ #2492 : A Bug's Life

传送门：http://poj.org/problem?id=2492

题意：二分图染色。

思路：利用bfs或者dfs遍历即可，没染色的进行染色，染过的判断两点颜色是否一样。

（PE的每个case要空一行）

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e18 + 10;
const double _e = 10e-6;
const int maxn = 2010;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int t, n, m;
vector<int> G[maxn];
int used[maxn];

bool bfs()
{
	queue<int> que; 
	for (int i = 1; i <= n; i++) {
		if (used[i] == -1) {
			que.push(i); used[i] = 0;
			while (!que.empty()) {
				int u = que.front(); que.pop();
				for (int j = 0; j < G[u].size(); j++) {
					int v = G[u][j];
					if (used[v] == -1) {
						used[v] = (used[u] + 1) % 2;
						que.push(v);
					}
					else if (used[v] == used[u])
						return false;
				}
			}
		}
	}
	return true;
}

int main()
{
	scanf("%d", &t);
	for (int _ = 1; _ <= t; _++) {
		scanf("%d%d", &n, &m);
		for (int i = 0; i <= 2000; i++)
			G[i].clear();
		cl1(used);
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
			G[y].push_back(x);
		}		
		printf("Scenario #%d:\n", _);
		if (bfs())
			puts("No suspicious bugs found!");
		else
			puts("Suspicious bugs found!");
		printf("\n");
	}
	return 0;
}

 

POJ #2631 : Roads in the North

传送门：http://poj.org/problem?id=2631

题意：树上最远距离。

思路：先任取一点，求出到这点距离最远的点a，再求出点a到其他点的最远距离就是答案。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const int N = 410;
const double _e = 10e-6;
const int maxn = 10010;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, c;
int ans, ansid;
bool used[maxn];

struct node
{
	int id;
	int cost;
};

vector<node> G[maxn];

struct cmp
{
	bool operator()(node a, node b)
	{
		return a.cost > b.cost;
	}
};

void bfs(int u)
{
	used[u] = true;
	priority_queue<node, vector<node>, cmp> que;
	que.push(node{ u,0 });
	while (!que.empty()) {
		int u = que.top().id, d = que.top().cost; que.pop();
		ansid = u; ans = d;
		for (int i = 0; i < G[u].size(); i++) {
			node v = G[u][i];
			if (!used[v.id]) {
				used[v.id] = true;
				que.push(node{ v.id,d + v.cost });
			}
		}
	}
}

int main()
{
	while (~scanf("%d%d%d", &x, &y, &c)) {
		//if (x == 0)break;
		G[x].push_back(node{ y,c });
		G[y].push_back(node{ x,c });
	}
	cl0(used);
	bfs(1);
	cl0(used);
	bfs(ansid);
	printf("%d\n", ans);
	return 0;
}

 

UVA #11080 : Place the Guards

传送门：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2021

题意：有n个路口，m条路，国王准备在某些路口安排一些人来把守。在一个路口把守的人能够把守与他所在的路口相连的所有路。问每条路都有且仅有一人把守，最少需要多少人。若无法满足则输出-1。

思路：将路口分为有人把守（路口0）的和没人把守的（路口1）。

对于所有路口来说，路口0必定与路口1相邻（不然就会有多人把守一条路或者压根没人把守某条路了）。

因此转化为二分图染色问题了。对于每块连通图都进行二分染色，然后取需要染色次数少的那种颜色，相加即为答案。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e18 + 10;
const double _e = 10e-6;
const int maxn = 210;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int t, n, m;
vector<int> G[maxn];
int used[maxn];

int bfs()
{
	queue<int> que; int ans = 0;
	for (int i = 0; i < n; i++) {
		if (used[i] == -1) {
			int ans0 = 0, ans1 = 0;
			que.push(i); used[i] = 0; ans0++;
			while (!que.empty()) {
				int u = que.front(); que.pop();
				for (int j = 0; j < G[u].size(); j++) {
					int v = G[u][j];
					if (used[v] == -1) {
						used[v] = (used[u] + 1) % 2;
						if (used[v] == 0)ans0++;
						else ans1++;
						que.push(v);
					}
					else if (used[v] == used[u])
						return -1;
				}
			}
			if (ans0 == 0 || ans1 == 0)
				ans += max(ans0, ans1);
			else
				ans += min(ans0, ans1);
		}
	}
	return ans;
}

int main()
{
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d", &n, &m);
		for (int i = 0; i <= 200; i++)
			G[i].clear();
		cl1(used);
		while (m--) {
			scanf("%d%d", &x, &y);
			G[x].push_back(y);
			G[y].push_back(x);
		}
		int ans = bfs();
		printf("%d\n", ans);
	}
	return 0;
}

 

HDU #1372 : Knight Moves

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=1372

题意：8*8的棋盘上，走马步从一个点到另一点的最短距离。

思路：利用bfs预处理所有点间的最短距离即可。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const int N = 410;
const double _e = 10e-6;
const int maxn = 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int xx[8] = { -2,-2,-1,1,1,-1,2,2 };
int yy[8] = { -1,1,2,2,-2,-2,1,-1 };

bool used[maxn][maxn];
int dis[maxn][maxn][maxn][maxn];

struct node
{
	int x, y;
	int d;
};

vector<node> G[maxn];

struct cmp
{
	bool operator()(node a, node b)
	{
		return a.d > b.d;
	}
};

void bfs(int ux, int uy)
{
	used[ux][uy] = true; dis[ux][uy][ux][uy] = 0;
	priority_queue<node, vector<node>, cmp> que;
	que.push(node{ ux,uy,0 });
	while (!que.empty()) {
		node u = que.top(); que.pop();
		for (int i = 0; i < 8; i++) {
			int vx = u.x + xx[i], vy = u.y + yy[i];
			if (vx <= 0 || vx > 8 || vy <= 0 || vy > 8)continue;
			if (!used[vx][vy]) {
				used[vx][vy] = true;
				dis[ux][uy][vx][vy] = u.d + 1;
				que.push(node{ vx,vy,u.d + 1 });
			}
		}
	}
}

int main()
{
	for (int i = 1; i <= 8; i++) {
		for (int j = 1; j <= 8; j++) {
			cl0(used);
			bfs(i, j);
		}
	}
	int x, y;
	char x1, y1;
	while (~scanf("%c%d %c%d", &x1, &x, &y1, &y)) {
		getchar();
		printf("To get from %c%d to %c%d takes %d knight moves.\n", x1, x, y1, y, dis[x1 - 'a' + 1][x][y1 - 'a' + 1][y]);
	}
	return 0;
}

 

__喵喵喵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法复习--python
weixin_46880949的博客
12-28 592
文章目录分治归并排序快速排序二分查找动态规划矩阵连乘最长公共子序列多段图最短路径贪心算法活动安排问题哈夫曼编码最小生成数（prim)最小生成树（kruskal)其他删除数字深度广度优先遍历判断一个byte里面有多少个bit的值为1最大和连续子序列百钱分鸡数字模糊切绳子 分治 归并排序 代码 #归并排序 a=[1,9,0,7,6,8] def merge(left,right): list_=[] i,j=0,0 while i<len(left) and j<len(ri
js代码-js版算法复习
07-16
"js代码-js版算法复习"这个主题，无疑是对JavaScript编程中常用算法的一次深入学习和巩固。在这个压缩包中，有两个主要文件：`main.js`和`README.txt`。 `main.js`通常包含了实际的JavaScript代码实现，可能是各种...
BFS 搜索 写代码思路（顺序）
大脑袋剑客
08-15 3333
#include #include using namespace std; queue qu; void bfs() { while(!qu.empty())//只要队列不为空就往下搜索 { int s = qu.front(); //取出队列最前面的元素 if(满足终止条件)break；//找到终点，跳出队列 qu.pop(
算法基础复习-BFS、DFS
codfishXY的博客
11-29 168
1. BFS（Breadth First Search） 原理：从一个节点开始向其邻节点扩散，遇到目标节点停止 应用 树的层序遍历（leetcode 102） public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> ret = new ArrayList<List<Integer>>(); if (root == null) re
DFS算法、BFS算法再复习-原理-实例-实现方法
Marshal Zheng的博客
04-14 667
DFS算法、BFS算法再复习 文章目录DFS算法、BFS算法再复习深度优先遍历（DFS）实例实现方法广度优先搜索（BFS）实现方法 做题时遇到了有些可以用DFS算法解决的问题，所以再复习一下DFS算法和BFS算法。 深度优先遍历（DFS） 访问起始顶点 若当前访问的顶点的邻接顶点有未被访问的，任选一个访问，反之回退到最近访问过的顶点，直到与起始顶点相通的全部顶点都访问完毕。 对连通图以上结束。对...
算法复习课.rar
05-09
《算法复习课》 在计算机科学领域，算法是解决问题的核心工具，它们是程序的灵魂，能够高效地处理数据、解决计算问题。本课程旨在帮助学习者深入理解和掌握算法的基础知识，提高编程技能，为后续的软件开发和数据...
NOIP NOI 信息学竞赛 ACM-ICPC POJ（北京大学在线评测系统）刷题推荐 OI复习计划 算法大纲
10-04
在图算法方面，了解深度优先遍历、广度优先遍历、最短路径算法、最小生成树算法、拓扑排序、二分图最大匹配和最大流的增广路算法。数据结构方面，熟悉字符串、排序、并查集、哈希表和二分查找等。搜索技巧和剪枝也是...
数据结构与算法理论复习
04-12
图的常见算法包括深度优先搜索（DFS）和广度优先搜索（BFS），以及最短路径算法，如Dijkstra算法和Floyd-Warshall算法。图在社交网络、路由选择和网络优化等问题中都有广泛的应用。 线性表是我们最基础的数据结构之...
【C++】P10287 [GESP样题 七级] 最长不下降子序列 题解_动态规划dp_图论_拓扑排序_洛谷_算法竞赛
YLCHUP的博客
07-15 1210
P10287题解，图论+dp，一道有难度的思维题，讲解得很详细，一看就能懂。快来看ヾ(•ω•`)o
代码随想录学习 54day 图论 A star算法
qq_40445763的博客
07-17 426
【代码】代码随想录学习 54day 图论 A star算法。
代码随想录：图论_01基础
weixin_51503393的博客
07-13 420
邻接矩阵是从节点的角度来表示图，有多少节点就申请多大的二维数组。给定一个有 n 个节点的有向无环图，节点编号从 1 到 n。请编写一个函数，找出并返回所有从节点 1 到节点 n 的路径。graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）邻接表是从边的数量来表示图，有多少边 才会申请对应大小的链表。
图论建模技巧搜集
hlhgzx的博客
07-16 486
搜集图论建模技巧，建图技巧。
代码随想录学习 day54 图论 Bellman_ford 队列优化算法（又名SPFA） 学习
qq_40445763的博客
07-17 291
【代码】代码随想录学习 54day 图论 Bellman_ford 队列优化算法（又名SPFA） 学习。
代码随想三刷图论篇2
张丁花的博客
07-16 717
【代码】代码随想三刷图论篇2。
数据分析的核心技能和方法
07-19
数据分析的核心技能和方法
毕业设计javajsp人寿保险销售网站(ssh)-qkrp源码含文档工具包
07-19
毕业设计javajsp人寿保险销售网站(ssh)-qkrp源码含文档工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 平湖人寿保险公司保险销售网站分为用户和管理员两个部分 前台部分（用户界面）： 1、资讯浏览功能： （1）新闻资讯浏览 （2）新闻资讯查询 （3）公司简介 （4）通知公告 2、用户登录注册功能： （1）注册 （2）登录 3、用户管理功能 （1）个人信息管理 （2）订单管理 4、保险购买功能： （1）保险产品浏览 （2）保险产品查询 （3）保险产品购买 后台管理（管理员界面） 1、管理员登录功能： 管理员在管理员登录界面输入用户名和密码，即可登录管理员的界面。 2、资讯管理功能： （1）新闻资讯管理 （2）公司简介管理 （3）通知公告管理 3、保险产品管理： （1）保险产品信息管理 （2）保险产品查询 4、会员管理： （1）会员删除 （2）会员级别管理 5、统计管理： （1）保险产品销售量统计 （2）有效会员数量统计 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程
毕业设计javajsp公共课考试系统(ssh)-qlkrp源码工具包
最新发布
07-19
毕业设计javajsp公共课考试系统(ssh)-qlkrp源码工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 题库 试卷信息管理 阅卷 统计功能 包含：源码、数据库脚本、环境工具包、相同框架项目的安装教程（在说明文档中）
算法导论期末复习python
10-30
算法导论是计算机科学中非常重要的一门课程，它涵盖了计算机算法的设计、分析与应用。期末复习是为了加深对所学知识的理解和掌握，为考试做好充分准备。 使用Python语言进行算法导论的复习是一种很好的选择。Python是一种强大且易于上手的编程语言，具有简洁的语法和丰富的库支持。下面是几个复习的重点： 1. 熟悉Python的基本语法和数据结构：掌握Python的基本数据类型如列表、字典和集合，并了解它们的操作与性能。 2. 掌握常见排序算法：复习插入排序、归并排序、快速排序等常见的排序算法，并能够灵活应用它们解决实际问题。 3. 熟悉图算法：学习图的表示方法，以及广度优先搜索(BFS)和深度优先搜索(DFS)等基本的图算法。 4. 熟练应用动态规划算法：了解动态规划的基本思想，复习使用动态规划解决背包问题、最长公共子序列等典型问题。 5. 学习贪心算法：了解贪心算法的概念和特点，熟悉使用贪心算法解决活动选择、哈夫曼编码等问题。 6. 熟练掌握分治算法：复习分治算法的基本思想和应用，熟悉使用分治算法解决最大子数组和矩阵乘法等问题。 7. 复习基本的算法分析方法：熟悉时间复杂度和空间复杂度的概念，掌握算法的渐进分析方法。 在复习过程中，可以通过参考教材、课堂笔记和习题集等资料进行练习和巩固所学知识。此外，可以参考一些算法导论的相关网上资源和在线教育平台上的课程进行深入学习。最重要的是，要坚持刷题，多进行实际编码练习，巩固所学算法的理解和应用能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值