一、BFS
eg1. 《算法笔记》P276
思路分析:
本题是连通块个数问题,利用搜索的方法来解决,DFS和BFS都可以。
方法一: DFS——适用于数据较小
写法1: 本题是要求在“0”里边搜索“1”,因而可以在DFS的过程当中,将已搜索到的“1”变为“0”,这样就避免了对同一个“1”的重复搜索。
写法2: 利用标记数组vis,标记出已经访问过的位置,避免重复访问。
方法二: BFS——适用于数据较大
代码——方法一
写法1
#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 100;
int n, m;
int matrix[maxn][maxn];
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};
void DFS(int x, int y)
{
matrix[x][y] = 0;
for(int i=0; i<4; i++)
{
int xx = x + X[i];
int yy = y + Y[i];
if(xx>=n || xx<0 || yy>=m || yy<0 || matrix[xx][yy]==0)
{
continue;
}
if(matrix[xx][yy] == 1)
{
DFS(xx, yy);
}
}
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d", &n, &m);
for(int x=0; x<n; x++)
{
for(int y=0; y<m; y++)
{
scanf("%d", &matrix[x][y]);
}
}
int ans = 0;
for(int x=0; x<n; x++)
{
for(int y=0; y<m; y++)
{
if(matrix[x][y]==1 && inq[x][y]==false)
{
ans++;
DFS(x, y);
}
}
}
printf("%d\n", ans);
fclose(stdin);
return 0;
}
写法2
#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 100;
int n, m;
int matrix[maxn][maxn];
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};
void DFS(int x, int y)
{
if(x>=n || x<0 || y>=m || y<0)
{
return ;
}
if(matrix[x][y]==0 || inq[x][y]==true)
{
return ;
}
inq[x][y] = true;
for(int i=0; i<4; i++)
{
int newX = x + X[i];
int newY = y + Y[i];
DFS(newX, newY);
}
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d", &n, &m);
for(int x=0; x<n; x++)
{
for(int y=0; y<m; y++)
{
scanf("%d", &matrix[x][y]);
}
}
int ans = 0;
for(int x=0; x<n; x++)
{
for(int y=0; y<m; y++)
{
if(matrix[x][y]==1 && inq[x][y]==false)
{
ans++;
DFS(x, y);
}
}
}
printf("%d\n", ans);
fclose(stdin);
return 0;
}
代码——方法二
#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 100;
struct node
{
int x, y;
}Node;
int n, m;
int matrix[maxn][maxn];
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};
bool judge(int x, int y)
{
if(x>=n || x<0 || y>=m || y<0)
{
return false;
}
if(matrix[x][y]==0 || inq[x][y]==true)
{
return false;
}
return true;
}
void BFS(int x, int y)
{
queue<node> Q;
Node.x = x;
Node.y = y;
Q.push(Node);
inq[Node.x][Node.y] = true;
while(!Q.empty())
{
node top = Q.front();
Q.pop();
for(int i=0; i<4; i++)
{
int newX = top.x + X[i];
int newY = top.y + Y[i];
if(judge(newX, newY))
{
Node.x = newX;
Node.y = newY;
Q.push(Node);
inq[Node.x][Node.y] = true;
}
}
}
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d", &n, &m);
for(int x=0; x<n; x++)
{
for(int y=0; y<m; y++)
{
scanf("%d", &matrix[x][y]);
}
}
int ans = 0;
for(int x=0; x<n; x++)
{
for(int y=0; y<m; y++)
{
if(matrix[x][y]==1 && inq[x][y]==false)
{
ans++;
BFS(x, y);
}
}
}
printf("%d\n", ans);
fclose(stdin);
return 0;
}
eg2. 《算法笔记》P278
思路分析:
将每个结点带上层次属性,进行BFS,输出end结点的层次即可。
注:如果需要输出最终层次,要使用BFS。 因为BFS采用队列可以存储下来每次遍历到的结点全部信息。而DFS采用迭代,我才疏学浅不知道怎么输出。。。。最后在输出end结点层次时,一定要记得把从队列中取出的结点信息赋给end,因为队列中的结点信息是副本,与真实的结点不一定一致。
代码
#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 110;
char maze[maxn][maxn];
bool inq[maxn][maxn] = {false};
int n, m; // n*m迷宫
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct node
{
int x, y;
int layer;
}start_, end_, Node;
bool judge(int x, int y)
{
if(x<0 || x>=n || y<0 || y>=m)
{
return false;
}
if(maze[x][y]=='*' || inq[x][y]==true)
{
return false;
}
return true;
}
void BFS()
{
queue<node> q;
q.push(start_);
inq[strat_.x][start_.y] = true;
while(!q.empty())
{
node top = q.front();
q.pop();
if(top.x==end_.x && top.y==end_.y) // 到达终止点
{
end_.layer = top.layer; // 一定要记得把值赋给end!!!!!!
break;
}
for(int i=0; i<4; i++)
{
int new_x = top.x + dx[i];
int new_y = top.y + dy[i];
if(judge(new_x, new_y) == true)
{
Node.x = new_x;
Node.y = new_y;
Node.layer = top.layer + 1;
q.push(Node);
inq[Node.x][Node.y] = true;
}
}
}
}
int main()
{
//freopen("input.txt", "r", stdin);
scanf("%d %d", &n, &m);
for(int x=0; x<n; x++)
{
getchar();
for(int y=0; y<m; y++)
{
scanf("%c", &maze[x][y]);
}
}
scanf("%d %d %d %d", &start_.x, &start_.y, &end_.x, &end_.y);
start_.layer = 0; // 出发点层次深度为0
BFS();
printf("%d\n", end_.layer);
//fclose(stdin);
return 0;
}
eg3. PAT A1091 Acute Stroke
题目大意:
给出一个三维数组,元素值为0、1。要求计算所有“1连通块”中元素的个数之和(连通块中1的个数要大于T,否则忽略)。
思路分析:
本题是三维的连通块计数,同二维方法一样,只不过多增加了两个搜索维度,用BFS即可解决。
注1:循环遍历时,一定要注意z轴是最外层循环!
注2:更新入队标记vis时,要在入队时更新,而不是在出队时,否则会带来影响!!!!!
代码(AC)
#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
struct node
{
int x, y, z;
}Node;
int m, n, l, t;
int pixel[1290][130][65]; // 三维矩阵
bool inq[1290][130][65] = {false}; // 入队标记
int dx[6] = {1, -1, 0, 0, 0, 0};
int dy[6] = {0, 0, 1, -1, 0, 0};
int dz[6] = {0, 0, 0, 0, 1, -1};
bool judge(int x, int y, int z)
{
if(x<0 || x>=m || y<0 || y>=n || z<0 || z>=l)
return false;
if(pixel[x][y][z]==0 || inq[x][y][z]==true)
return false;
return true;
}
int BFS(int x, int y, int z)
{
queue<node> q;
Node.x = x;
Node.y = y;
Node.z = z;
q.push(Node);
int num = 0; // 该连通块中 1 的个数
inq[Node.x][Node.y][Node.z] = true; // 更新状态
while(!q.empty())
{
node top = q.front();
q.pop();
num++; // 每从队列中取出一个,就 +1
//inq[top.x][top.y][top.z] = true;
// 因为inq表示已经在队列中,所以要在入队时更新状态,而不是在出队时,否则会有影响!!!
for(int i=0; i<6; i++)
{
int new_x = top.x + dx[i];
int new_y = top.y + dy[i];
int new_z = top.z + dz[i];
if(judge(new_x, new_y, new_z))
{
Node.x = new_x;
Node.y = new_y;
Node.z = new_z;
q.push(Node);
inq[Node.x][Node.y][Node.z] = true; // 更新状态
}
}
}
if(num >= t)
return num;
else
return 0;
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d %d %d", &m, &n, &l, &t);
for(int k=0; k<l; k++)
for(int i=0; i<m; i++)
for(int j=0; j<n; j++)
scanf("%d", &pixel[i][j][k]);
int ans = 0;
for(int k=0; k<l; k++)
{
for(int i=0; i<m; i++)
{
for(int j=0; j<n; j++)
{
if(pixel[i][j][k]==1 && inq[i][j][k]==false)
{
ans += BFS(i, j, k);
}
}
}
}
printf("%d\n", ans);
fclose(stdin);
return 0;
}
二、递归
递归的重点在于,找到递归边界和递归式。
eg1. 求解n的阶乘
int F(int n)
{
if(n==0) // 递归边界
return 1;
else
return F(n-1) * n; // 递归式
}
eg2. 斐波那契数列
int F(int n) // F(0)=1, F(1)=1, F(n)=F(n-1)+F(n-2)
{
if(n==0 || n==1)
return 1;
else
return F(n-1) + F(n-2);
}
eg3. 全排列问题
思路分析:
全排列问题是典型的递归问题,只需要每次都让任意一个数,分别作为递归子序列的第一个元素,直至元素个数达到n,达到递归边界。
代码
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 11;
int P[maxn]; // 输出序列
bool hashtable[maxn] = {false}; // 记录是否已被存储
int n;
void generateP(int index) // 处理第index位的输出
{
if(index > n)
{
for(int i=1; i<=n; i++)
{
printf("%d ", P[i]);
}
printf("\n");
return ;
}
for(int x=1; x<=n; x++)
{
if(hashtable[x] == false)
{
P[index] = x;
hashtable[x] = true;
generateP(index+1);
hashtable[x] = false;
}
}
}
int main()
{
scanf("%d", &n);
generateP(1);
return 0;
}
eg4. n皇后问题
思路分析:
n皇后问题是改进的全排列问题。唯一加的一个约束条件就是,任意两位置不能在同一对角线上 (行、列坐标之差不等)。
解法一: 得到全部全排列,筛选出任意两点不在同一对角线上的情况。
解法二: 在得到全排列的过程当中,便进行约束限制,如果出现在同一对角线上的情况,跳过不记录此情况。最终得到的全排列结果就是满足题意的结果。
代码——解法一
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const int maxn = 11;
int P[maxn];
bool hashtable[maxn] = {false};
int n;
int cnt = 0;
void generateP(int index) // 处理第index位的元素
{
if(index > n) // 递归边界
{
bool flag = true;
for(int i=1; i<=n; i++)
{
for(int j=i+1; j<=n; j++)
{
if(abs(i-j) == abs(P[i]-P[j])) // 任意两位置不在同一对角线上
{
flag = false;
break;
}
}
}
cnt += flag;
return ;
}
for(int x=1; x<=n; x++)
{
if(hashtable[x] == false)
{
P[index] = x;
hashtable[x] = true;
generateP(index+1);
hashtable[x] = false;
}
}
}
int main()
{
scanf("%d", &n);
generateP(1);
printf("%d", cnt);
return 0;
}
代码——解法二
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const int maxn = 11;
int P[maxn];
bool hashtable[maxn] = {false};
int n, cnt = 0;
void generateP(int index)
{
if(index > n)
{
cnt++; // 能到达的都是满足题意的解
return ;
}
for(int x=1; x<=n; x++)
{
if(hashtable[x] == false)
{
P[index] = x;
bool flag = true;
for(int pre=1; pre<index; pre++) // 当前位置的值与之前已插入的值进行比较
{
if(abs(pre-index) == abs(P[pre]-P[index]))
{
flag = false;
break;
}
}
if(flag == true)
{
P[index] = x;
hashtable[x] = true;
generateP(index+1);
hashtable[x] = false;
}
}
}
}
int main()
{
scanf("%d", &n);
generateP(1);
printf("%d", cnt);
return 0;
}
eg5. 素数环问题
题目大意:
给定1~n,将数字填入环中,使得任意相邻两数之和为素数。(第一个数字固定为1)
思路分析:
素数环问题也是一道典型的改进全排列问题,只是增加了一个相邻数字之和为素数的条件。
具体思路和n皇后问题一致,只是把约束条件更换了。且由于第一位已固定为1,所以main函数中调用此函数时,从第二位开始递归,因而传参为2。
代码
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const int maxn = 20;
int P[maxn];
bool hashtable[maxn] = {false};
int n;
void init()
{
fill(hashtable, hashtable+maxn, false);
fill(P, P+maxn, 0);
hashtable[1] = true;
P[1] = 1; // 第一个位置始终是1
}
bool isPrime(int a, int b)
{
int x = a + b;
if(x <= 1)
return false;
int sqr = (int)sqrt(1.0*x);
for(int i=2; i<=sqr; i++)
{
if(x%i == 0) // 不是素数
{
return false;
}
}
return true;
}
void generateP(int index)
{
if(index > n)
{
if(isPrime(P[n], 1) == true) // 最后一个元素与1之和为素数
{
for(int i=1; i<=n; i++)
{
printf("%d ", P[i]);
}
printf("\n");
}
return ;
}
for(int x=2; x<=n; x++)
{
if(hashtable[x] == false)
{
P[index] = x;
if(isPrime(P[index], P[index-1]) == true) // 之和是素数
{
P[index] = x;
hashtable[x] = true;
generateP(index+1);
hashtable[x] = false;
}
}
}
}
int main()
{
freopen("input.txt", "r", stdin);
int cnt = 1;
while(scanf("%d", &n) != EOF)
{
init();
printf("Case %d:\n", cnt++);
generateP(2); // 从第2位开始
}
fclose(stdin);
return 0;
}
eg6. 汉诺塔问题(一)
void tower(int n, char x, char y, char z) // n为圆盘数,x初始塔,y辅助塔,z目标塔 -> 把n个圆盘从x移至z
{
tower(n-1, x, z, y); // 把n-1个圆盘从x移至y
cout << "From " << x << "To " << z << endl;
tower(n-1, y, x, z); // 把n-1个圆盘从y移至z
}
eg7. 汉诺塔问题(三)
思路分析:
要将n个圆盘从A移到C:F(n)
①需要先将上面n-1个圆盘从A移到C:F(n-1)
②再将最后一个圆盘从A移到B:1
③再将n-1个圆盘从C移到A:F(n-1)
④再将最后一个圆盘从B移到C:1
⑤最后将n-1个圆盘从A移到C:F(n-1)
综上,F(n)=3*F(n-1)+2 && F(1)=2
代码:
long long F(int n)
{
if(n == 1)
return 2;
else
return 3*F(n-1)+2;
}
三、DFS
eg1. 背包问题
思路分析:
递归方式:每件物品都有选或者不选两种选择;
递归终点:访问完所有物品n or 总体积>V。
每次都要对物品进行选择,因此DFS函数的参数必须记录当前处理的物品编号index。
题目中涉及到物品的总重量和价值,因此也需要参数sumW、sumC来记录在处理当前物品之前已选物品的总重量和总价值。
如果不选index号物品,那么sumW、sumC就将不变,接下来处理index+1号物品;
如果选index号物品,那么sumW+w[index],sumC+c[index],接下来处理index+1号物品。
代码——未剪枝
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 30;
int w[maxn], c[maxn];
int n, V;
int maxValue = 0;
void DFS(int index, int sumW, int sumC)
{
if(index >= n) // 处理完所有物品(递归边界)
{
if(sumW <= V) // 选择在容量范围内的
{
maxValue = max(maxValue, sumC);
}
return ;
}
DFS(index+1, sumW, sumC); // 不选第index件物品
DFS(index+1, sumW+w[index], sumC+c[index]); // 选第index件物品
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d", &n, &V);
for(int i=0; i<n; i++)
{
scanf("%d", &w[i]); // 每件物品重量
}
for(int i=0; i<n; i++)
{
scanf("%d", &c[i]); // 每件物品价值
}
DFS(0, 0, 0); // 从第0件物品开始,初始价值、重量都为0
printf("%d", maxValue);
fclose(stdin);
return 0;
}
代码——剪枝
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 30;
int w[maxn], c[maxn];
int n, V;
int maxValue = 0;
void DFS(int index, int sumW, int sumC)
{
if(index >= n)
{
maxValue = max(maxValue, sumC); // 在所有满足题意的结果中找最大的
return ;
}
DFS(index+1, sumW, sumC); // 不选第index件商品
if(sumW+w[index] <= V) // 加入该物品后,不会超过容量限制
{
DFS(index+1, sumW+w[index], sumC+c[index]); // 选第index件商品
}
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d", &n, &V);
for(int i=0; i<n; i++)
{
scanf("%d", &w[i]); // 每件物品重量
}
for(int i=0; i<n; i++)
{
scanf("%d", &c[i]); // 每件物品价值
}
DFS(0, 0, 0); // 从第0件物品开始,初始价值、重量都为0
printf("%d", maxValue);
fclose(stdin);
return 0;
}
eg2. 给定n个整数,从中选择k个数,使之和为x。若存在多种情况,选择平方和最大的一个
代码
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int maxn = 30;
int A[maxn];
int n, k, x, max_sqr; // 从A中n数中选k个数,使其和为x
vector<int> ans, temp;
void DFS(int index, int nowK, int sum, int sqr)
{
if(nowK==k && sum==x)
{
if(sqr > max_sqr)
{
max_sqr = sqr;
ans = temp; // 更新最优方案
}
return ;
}
if(index>=n || sum>x || nowK>k)
{
return ;
}
//选index号
temp.push_back(A[index]);
DFS(index+1, nowK+1, sum+A[index], sqr+A[index]*A[index]); // 不放回的选取
// DFS(index, nowK+1, sum+A[index], sqr+A[index]*A[index]); // 有放回的选取
temp.pop_back();
// 不选index号
DFS(index+1, nowK, sum, sqr);
}
int main()
{
freopen("input.txt", "r", stdin);
scanf("%d %d %d", &n, &k, &x);
for(int i=0; i<n; i++)
{
scanf("%d", &A[i]);
}
DFS(0, 0, 0, 0);
for(int i=0; i<ans.size(); i++)
{
printf("%d ", ans[i]);
}
fclose(stdin);
return 0;
}