bfs 和 dfs 专题

最新推荐文章于 2021-11-30 10:49:43 发布
最新推荐文章于 2021-11-30 10:49:43 发布
阅读量623 收藏
点赞数
分类专栏： 解题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Triose/article/details/47357387
版权
本文通过仓鼠球和Prime Ring Problem问题，探讨BFS（广度优先搜索）和DFS（深度优先搜索）的基本使用。仓鼠球问题中，需要计算仓鼠能到达的所有格子数。Prime Ring Problem则涉及FJ追赶逃犯的路径优化问题。文章总结了这两种算法的一般写法，并提及杭电1728题作为拓展应用。
摘要由CSDN通过智能技术生成

弄了个把星期总算有点自己的体会。。。还是以一道很老很简单的题来说

仓鼠球

时间限制(C/C++):1000MS/3000MS          运行内存限制:65536KByte
总提交:239            测试通过:59

描述

一日，仓鼠君在一个由10×10的格子构成的竞技场里滚球，每一块格子高度不同；
仓鼠君有特别的滚球技巧，可以每次精准地向前后左右四个方向中的一个滚动一格；
仓鼠君只能从高的格子向相邻的相同高度或更低的格子滚动；
如果两个格子高度差超过100（不含100），那么仓鼠君不能向这个格子移动，否则会摔碎自己的球；
仓鼠君不会抛弃他的球。

现在，给你每个格子的高度，问仓鼠君能够到达的所有格子的数目（包括开始时的格子）（在任何一个路线中经过的格子都算在结果中）。

输入

输入第一行是一个整数T(1<=T<=20)，代表测试数据的数量；
然后第一行是两个整数x和y，代表仓鼠君开始时的坐标(0<=x,y<=9)；
然后是一个10×10的矩阵，表示每个格子的高度(0<=h<=200)。

输出

对于每组数据在一行内输出一个整数，表示仓鼠君能够到达的所有格子数目（包括开始时的格子）（在任何一个路线中经过的格子都算在结果中）。

样例输入

1
0 0
200 199 198 197 196 195 194 193 192 191
199 198 197 196 195 194 193 192 191 190
198 197 196 195 194 193 192 191 190 189
197 196 195 194 193 192 191 190 189 188
196 195 194 193 192 191 190 189 188 187
195 194 193 192 191 190 189 188 187 186
194 193 192 191 190 189 188 187 186 185
193 192 191 190 189 188 187 186 185 184
192 191 190 189 188 187 186 185 184 183
191 190 189 188 187 186 185 184 183 182

样例输出

100

dfs写法：

<strong>#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                            
#define inf 0x3f3f3f3f                                            
#define FOR(i,a) for((i)=0;i<(a);(i)++)                            
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
#define N 15
bool vis[N][N];
int pic[N][N];
int dfs(int x,int y){
    int num = 0;
    if(vis[x][y])
        return num;
    else{
        num++;
        vis[x][y] = true;
        if(pic[x][y] >= pic[x][y+1] && pic[x][y] - pic[x][y+1] <= 100 && y + 1 <= 9)
            num += dfs(x,y+1);
        if(pic[x][y] >= pic[x][y-1] && pic[x][y] - pic[x][y-1] <= 100 && y - 1 >= 0)
            num += dfs(x,y-1);
        if(pic[x][y] >= pic[x-1][y] && pic[x][y] - pic[x-1][y] <= 100 && x - 1 >= 0)
            num += dfs(x-1,y);
        if(pic[x][y] >= pic[x+1][y] && pic[x][y] - pic[x+1][y] <= 100 && x + 1 <= 9)
            num += dfs(x+1,y);
        return num;
    }
}
int main(){
#ifndef ONLINE_JUDGE
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
#endif
	int t,x,y;
	sf(t);
	while(t--){
		memset(vis,false,sizeof(vis));
		sfd(x,y);
		for(int i = 0; i < 10; i++){
			for(int j = 0; j < 10; j++){
				scanf("%d",&pic[i][j]);
			}
		}
		pf(dfs(x,y));
	}
	return 0;
}</strong>

bfs写法： 

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                           
#define inf 0x3f3f3f3f                                            
#define FOR(i,a) for((i)=0;i<(a);(i)++)                           
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
#define N 15
bool vis[N][N];
int pic[N][N];
struct Point{
    int x;
    int y;
};
queue<Point> q;
const int go[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
bool Jud(Point next,Point first){
    if(next.x < 0)
        return false;
    if(next.y < 0)
        return false;
    if(vis[next.x][next.y])
        return false;
    if(next.x >= 10)
        return false;
    if(next.y >= 10)
        return false;
    if(pic[first.x][first.y] - pic[next.x][next.y] > 100)
        return false;
    if(pic[next.x][next.y] > pic[first.x][first.y])
        return false;
    return true;
}
int bfs(int x,int y){
    Point temp,next_step;
    temp.x = x; temp.y = y;
    q.push(temp);
    int num = 0;
    while(!q.empty()){
        temp = q.front();
        q.pop();
        vis[temp.x][temp.y] = true; <span style="white-space:pre">					</span>//为什么只有这句不行？
        num++;
        for(int i = 0; i < 4; i++){
            next_step.x = temp.x + go[i][0];
            next_step.y = temp.y + go[i][1];
            if(Jud(next_step,temp)){
                q.push(next_step);
                vis[next_step.x][next_step.y] = true;                //这里始终有个问题，为什么要加这一句，只有上面那句为什么出错？
            }
        }
    }
    return num;
}
int main(){
#ifndef ONLINE_JUDGE
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
#endif
    int t,x,y;
    sf(t);
    while(t--){
        memset(vis,false,sizeof(vis));
        while(!q.empty())
            q.pop();
        sfd(x,y);
        for(int i = 0; i < 10; i++){
            for(int j = 0; j < 10; j++){
                scanf("%d",&pic[i][j]);
            }
        }
        pf(bfs(x,y));
    }
    return 0;
}

DFS的简单题：

Prime Ring Problem

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 34250    Accepted Submission(s): 15147

Problem Description
A ring is compose of n circles as shown in diagram. Put natural number 1, 2, ..., n into each circle separately, and the sum of numbers in two adjacent circles should be a prime.

Note: the number of first circle should always be 1.


 

Input
n (0 < n < 20).
 

Output
The output format is shown as sample below. Each row represents a series of circle numbers in the ring beginning from 1 clockwisely and anticlockwisely. The order of numbers must satisfy the above requirements. Print solutions in lexicographical order.

You are to write a program that completes above process.

Print a blank line after each case.
 

Sample Input 
  
  

   
   6
8
 

Sample Output 
  
  

   
   Case 1:
1 4 3 2 5 6
1 6 5 2 3 4

Case 2:
1 2 3 8 5 6 7 4
1 2 5 8 3 4 7 6
1 4 7 6 5 8 3 2
1 6 7 4 3 8 5 2
 
题意是：输入一个n，表示这个环有n个位置。分别填入1 - n 个数，使得相邻相加的和为素数。如果有多种填法，按字典序输出所有。
典型DFS题。
代码： 
#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                            //INT_MAX
#define inf 0x3f3f3f3f                                            //int范围内可靠的无穷大
#define FOR(i,a) for((i)=0;i<(a);(i)++)                            //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
bool prime[40] = {0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0};
int a[25];
int vis[25];
void dfs(int s){                                                          //填第s个位置
    if(s == n){
        if(prime[a[s - 1] + 1]){
            for(int i = 0; i < n; i++){
                printf("%d%c",a[i],(i == n - 1 ? '\n' : ' '));
            }
        }
        return ;
    }
    for(int i = 2; i <= n; i++){
        if(vis[i])
            continue;
        vis[i] = true;      <span style="white-space:pre">							</span>//先标记
        if(prime[i + a[s - 1]]){
            a[s] = i;
            dfs(s + 1);
        }
        vis[i] = false;<span style="white-space:pre">								</span>//记得复位
    }
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
#endif
    int k = 0;
    a[0] = 1;
    while(sf(n)!=EOF){
        memset(vis,false,sizeof(vis));
        printf("Case %d:\n",++k);
        dfs(1);
        putchar(10);
    }
    return 0;
}


总结：标记和复位很重要也很巧妙。



典型BFS：

Catch That Cow
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 61445 Accepted: 19198

Description

Farmer John has been informed of the location of a fugitive cow and wants to catch her immediately. He starts at a point N (0 ≤ N ≤ 100,000) on a number line and the cow is at a point K (0 ≤ K ≤ 100,000) on the same number line. Farmer John has two modes of transportation: walking and teleporting.

* Walking: FJ can move from any point X to the points X - 1 or X + 1 in a single minute
* Teleporting: FJ can move from any point X to the point 2 × X in a single minute.

If the cow, unaware of its pursuit, does not move at all, how long does it take for Farmer John to retrieve it?

Input

Line 1: Two space-separated integers:  N and  K

Output

Line 1: The least amount of time, in minutes, it takes for Farmer John to catch the fugitive cow.

Sample Input

5 17

Sample Output

4
代码： 

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<map>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff                                            //INT_MAX
#define inf 0x3f3f3f3f                                            //int范围内可靠的无穷大
#define FOR(i,a) for((i)=0;i<(a);(i)++)                            //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}
template<class T> T lcm(T a, T b) {return a / gcd(a, b) * b;}
template<class T> inline T Min(T a, T b) {return a < b ? a : b;}
template<class T> inline T Max(T a, T b) {return a > b ? a : b;}
using namespace std;
int n,m;
#define N 100000
bool vis[N+10];
struct Node{
	int position;
	int time;
	Node(){
		position = 0;
		time = 0;
	}
};
queue<Node> q;
bool Jud(Node temp){
	if(temp.position < 0 || temp.position > N || vis[temp.position] )
		return false;
	return true;
}
int bfs(){
	while(!q.empty())
		q.pop();
	Node temp,next_step;
	temp.position = n;
	vis[n] = true;
	q.push(temp);
	int ans_time = 0;
	while(!q.empty()){
		temp = q.front();
		q.pop();
		if(temp.position == m){
			ans_time = temp.time;
			break;
		}
		next_step.position = temp.position - 1;
		next_step.time = temp.time + 1;
		if (Jud(next_step)) {
			q.push(next_step);
			vis[next_step.position] = true;
		}
		next_step.position = temp.position + 1;
		next_step.time = temp.time + 1;
		if (Jud(next_step)) {
			q.push(next_step);
			vis[next_step.position] = true;
		}
		next_step.position = temp.position * 2;
		next_step.time = temp.time + 1;
		if (Jud(next_step)) {
			q.push(next_step);
			vis[next_step.position] = true;
		}
	}
	return ans_time;
}
int main(){
#ifndef ONLINE_JUDGE
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
#endif
	while(sfd(n,m)!=EOF){
		if(n >= m)
			pf(n - m);
		else{
			memset(vis,false,sizeof(vis));
			pf(bfs());
		}
	}
	return 0;
}







总结：

以上几个例子基本上是bfs和dfs的一般写法。。。当然还有根据bfs和dfs拓展的算法。。以后往上加。

        对了  杭电有道题！1728  我已经连错三天了。。。

Triose
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BFS与DFS专题
WMXNLFD的博客
06-04 175
/* BFS: 1.空间是指数级别的 大！！ 2.不会有爆栈的风险 3.方便求最短、最小 DFS： 1.空间和深度成正比 小！！ 2.有爆栈的风险，比如树的深度最坏可能有十万层 3.不能搜 最短，最小 */ LeetCode 111. Minimum Depth of Binary Tree 给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明...
vjudge上的专题
Occult
06-07 4736
回文树 树分治 Splay 各种生成树 DLX覆盖
图论：DFS、BFS和优先级搜索框架实现最小支撑树、最短路
Escaping
08-19 484
1.BFS 优先访问最先发现的节点，可以根据FIFO队列的特点，选用队列实现 可以实现连通域分解和最短路径等问题。 等同于树结构中的层次遍历 //whole graph template <typename Tv, typename Te> void Graph<Tv,Te>::bfs(int s){ reset(); int clock=0...
BFS和DFS专题
辉哥仔
04-10 191
BFS： 1、空间是指数级别 大！！！ 2、不会有爆栈的风险 3、最短、最小 DFS： 1、空间和深度成正比 小！！！ 2、有爆栈的风险，比如树的深度最坏有1000000层 3、不能搜最短、最小 题目1：Given a binary tree, find its minimum depth.The minimum depth is the number of nodes ...
LeetCode中的BFS和DFS专题
raoxinyue的博客
02-10 385
LeetCode中的BFS和DFS专题 BFS广度优先，是按照层来扩展的；DFS深度优先，是“一条道走到黑”。 如果是一个规模为2的n次方的问题，那么BFS的时间复杂度是2的n次方，而DFS的时间复杂度是n。 一般用BFS来解决迷宫的最短路径问题，这是因为DFS走到终点的时候可能是绕了一大圈才到达终点。 BFS 1.空间大，是呈指数增长的 2.不会有爆栈的风险，申请的空间是堆空间 3.可以搜索最短...
笔试刷题BFS和DFS专题
excellent_sun的博客
08-07 744
BFS和DFS专题LeetCode 111 二叉树的最小深度 LeetCode 111 二叉树的最小深度 * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * ...
DFS和BFS专题
JavanLu的博客
11-30 310
DFS和BFS专题130. 被围绕的区域 130. 被围绕的区域 总的思想是寻找边界条件，使用标记数组。 class Solution { // 将需要的变量设置为全局变量 char[][] board; int rows; int cols; boolean[][] visited; public void solve(char[][] board) { /** 分析： 题目中提示的很明显要处理边界条件。
专题训练之BFS/DFS 二分
haoiyang的博客
02-27 211
文章目录一、DFS是什么？二、BFS是什么？三、BFS和DFS的区别四、需要注意的点五、二分是什么？六、专题题解1. Lake Counting2.Red and Black3. Accepted Necklace 一、DFS是什么？ dfs是指深度优先搜索。从我的理解来说，就是从一个节点出发，一直往下走，走到无法继续的时候，再返回上一层，继续尝试；直到走完所有情况，或者找到满足条件的。 二、BFS是什么？ bsf是指宽度优先搜索。从我的理解来说，就是从一个节点出发，一步步地走从该节点出发，实现所有的
dfs-bfs专题总结
yeyuluo的博客
12-19 270
dfs-bfs专题总结 A、油田 B、分可乐 C、find a way D、Phillip and Trains E、fire F、八皇后、 G、Rescure H、蜘蛛牌 I、BFS入门 J、Nightmare K、Fire Net L、Ice Cave M、诡异的楼梯 N、BFS+记录路径 O、推箱子 P、数独 Q、迷宫问题 唔，尽管吧bfs-dfs的题组做完了，但是也只是对于他们的代码以及基...
搜索专题——DFS
12-17
【DFS搜索】 深度优先搜索（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。...因此，在实际应用中，通常会结合其他算法如广度优先搜索（BFS）或动态规划等来优化问题的解决方案。
第二讲：复习专题之链表,指针,dfs&bfs.pptx
10-05
在C++编程语言中，链表、指针、深度优先搜索(DFS)和广度优先搜索(BFS)是重要的概念，这些概念在处理数据结构和算法时尤其关键。本讲将详细阐述这些主题。 首先，我们来看结构体，它是C++中定义自定义数据类型的一种...
专题5-搜索21
08-08
【专题5-搜索21】主要探讨了两个与程序设计相关的搜索问题，分别涉及马的遍历和细胞数量的计算。 1. **马的遍历**：这是一个经典的BFS（广度优先搜索）问题，通常被称为“骑士游走”或者“马在棋盘上的移动”。在这...
HDU 专题分类（2013年8月）
08-07
- **问题描述**：此题可能涉及图的遍历，特别是深度优先搜索(DFS)或广度优先搜索(BFS)，用于寻找森林中两点间的一条路径。 - **算法应用**：最短路径算法如Dijkstra或Bellman-Ford，用于计算两点之间的最短路径。 #...
ACM搜索专题报告
05-27
在ACM集训队中，常用搜索算法主要分为深度优先搜索（DFS）和广度优先搜索（BFS）。 深度优先搜索（DFS）算法： 深度优先搜索是一种沿着树的分支深入直到不能更深入时回溯的策略。它尝试从一个初始节点开始，探索尽...
1165 纪念品分组（要认真看题目！！！！！！！！！！）
Triose的专栏
02-26 4559
纪念品分组 时间限制(普通/Java):1000MS/3000MS          运行内存限制:65536KByte 总提交:35            测试通过:19 描述 ACM爱好者协会成功举办了月赛，fudq找来了cnsks、大帅、hjx1993、Anderson等众大牛帮忙负责月赛的纪念品发放工作。为使得参加月赛的同学所获得的纪念品价值相对均衡，他们要把购来的纪念品根据价格进
并查集的几道题目
Triose的专栏
08-11 2731
先从最简单的开始： 题意： 一共n个强盗，m条线索，输出有多少个独立团伙（同伙的同伙是同伙，老鼠的儿子会打洞） 样例输入： 10 9 1 2 3 4 5 2 4 6 2 6 8 7 9 7 1 6 2 4 样例输出： 3 代码： #include #include #include #include #include #include #include #inc
动态规划（dp）入门解题报告
Triose的专栏
07-30 2251
基本思想与策略     基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。     由于动态规划解决的问题多数有重叠子问题这个特点，为减少重复计算，对每
拓展欧几里得解方程ax+by=gcd(a,b)
Triose的专栏
02-26 2180
好吧，过年在家还是看了点点书，还自己给自己出了两道坑爹题。 这道题目一开始想了半天敲出来了，但是只对一组数据得出的答案是对的。。。。后来又写了一遍就对了。。。。 描述：   求出方程：ax+by=gcd(a,b)的初始解,输入a,b（int），输出x,y（空格隔开）; 输入： 60 22 22 60 12453 2467 输出： -4  11 11  -4 304  -1
ACM专题：搜索算法详解
无信息搜索不考虑问题的具体特性，如宽度优先搜索（BFS）和深度优先搜索（DFS）。有信息搜索则利用启发式信息来指导搜索，如A*算法，它结合了实际距离和估计的最优成本来优化搜索路径。 3. 回溯方法 回溯法是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值