本文精选了多个经典算法题目，涵盖深度优先搜索、广度优先搜索、结构体排序等技术要点，通过实例详细解析了每种算法的应用场景及实现方法。
题目链接：http://sustoj.com/JudgeOnline/contest.php?cid=1042
1：俊俊家里有矿，连通块问题，dfs经典入门例题，希望大家掌握。
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 100+8;
char oil[maxn][maxn]; // 油田
int vis[maxn][maxn]; // 标记数组 去重 判断结点是否被访问
int cnt; // 连通块数量
int n, m; // n行 m列
void dfs(int x, int y) // 深搜
{
if(x < 0 || x >= n || y < 0 || y >= m) return ; // 出界
if(oil[x][y] != '@' || vis[x][y]) return ; // 不是油田 已经访问
vis[x][y] = 1; // 标记结点已经被访问
for(int i = -1; i <= 1; i++){
for(int j = -1; j <= 1; j++){ // 向八个方向搜索
if(i || j) dfs(x+i, y+j);
}
}
}
int main()
{
while(scanf("%d %d",&n, &m) == 2 && n && m){
memset(vis, 0, sizeof(vis)); // 初始化 每个结点都没有被访问
cnt = 0;
for(int i = 0; i < n; i++) scanf("%s", oil[i]);
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(oil[i][j] == '@' && !vis[i][j]) { // 找到油田 而且没有被访问 才深搜
dfs(i, j);
cnt++;
}
}
}
printf("%d\n", cnt);
}
return 0;
}问题 B: 路痴的XX（搜索例题）BFS + 路径打印
题解：先广搜找到终点确定最短路径，然后回溯打印路径。BFS 经典题目 希望大家掌握。
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
using namespace std;
const int maxn = 10+8;
int a[maxn][maxn]; // 地图数组
int vis[maxn][maxn]; // 标记数组 去重 避免访问重复状态
int step[maxn][maxn]; // step[i][j] 表示起点(i, j)的最短路径
int dx[] = {-1, 1, 0, 0}; // 方向数组
int dy[] = {0, 0, -1, 1}; //
struct node{ // 用结点 表示 某个位置的状态
int x; // 行
int y; // 列
int cnt; // 走到当前位置的步数
node(int x = 0, int y = 0, int cnt = 0){ // 构造器初始化
this->x = x;
this->y = y;
this->cnt = cnt;
}
};
node fa[maxn][maxn]; // 父亲数组 用来回溯打印路径
int check(int x, int y) // 判断下一个结点能不能被访问
{
if(x < 0 || x > 4 || y < 0 || y > 4) return 0; //出界
if(a[x][y] == 1 || vis[x][y]) return 0; // 不能走 已经被走过
return 1;
}
void bfs()
{
memset(vis, 0, sizeof(vis)); // 初始化 每个位置都没有被走过
queue<node>q; // 队列
node now; // 初始化起点
now.x = 0, now.y = 0, now.cnt = 0;
q.push(now); // 起点入队
step[now.x][now.y] = 0;
while(!q.empty()){ // 当队列不空
now = q.front(); // 取队首
q.pop(); // 弹出队列
vis[now.x][now.y] = 1; // 标记被访问
step[now.x][now.y] = now.cnt; // 步数赋值
if(now.x == 4 && now.y == 4) return; // 找到终点
for(int i = 0; i < 4; i++){ // 向四个方向搜索
node next;
next.x = now.x + dx[i];
next.y = now.y + dy[i];
if(check(next.x, next.y)){ // 判断是否能走
next.cnt = now.cnt + 1; // 步数+1
q.push(next); // 结点入队
fa[next.x][next.y] = now; // now结点走到 next结点
} // 所以 next 的父亲 是 now
}
}
return ;
}
void print_path(node u)
{
stack<node>s; // 栈
for(;;){
s.push(u); // 入栈
if(step[u.x][u.y] == 0) break; // 找到起点
u = fa[u.x][u.y]; // 回溯
}
while(!s.empty()){ // 栈不空
printf("(%d, %d)\n", (s.top()).x, (s.top()).y); // 打印位置
s.pop(); // 出栈
}
return ;
}
int main()
{
for(int i = 0; i < 5; i++){
for(int j = 0; j < 5; j++){
scanf("%d", &a[i][j]); // 读入地图
}
}
bfs(); // 搜索
printf("%d\n",step[4][4]);
node ans(4, 4, step[4][4]); // 构造器初始化
print_path(ans);
return 0;
}
问题 C: “下班啦，打卡成功！”
题解：结构体排序， 今天大家学会结构体了吧。
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 200+8;
struct student{
string s;
int time;
};
student st[maxn];
int n;
bool cmp(student a, student b)
{
if(a.time > b.time || (a.time == b.time && a.s < b.s)) return 1;
return 0;
}
int main()
{
int h, m;
while(scanf("%d", &n) == 1){
for(int i = 0; i < n; i++){
cin >> st[i].s;
scanf("%d:%d", &h, &m);
st[i].time = h*60 + m;
}
sort(st, st+n, cmp);
cout << st[0].s << endl;
}
return 0;
}
问题 D: 红红去小寨
题解：这道题每一数字看作一个状态，枚举状态就是枚举数字，然后判重。找到最短路径后，乘以时间就是最少用时。
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int maxn = 100000+8;
int vis[maxn];
int step[maxn];
int n, k;
int check(int num)
{
if(num < 0 || num > 100000 || vis[num] ) return 0;
return 1;
}
void bfs()
{
memset(vis, 0, sizeof(vis));
memset(step, 0, sizeof(step));
queue<int>q;
q.push(n);
vis[n] = 1;
step[n] = 0;
while(!q.empty()){
int now = q.front();
q.pop();
if(now == k) return ;
if(check(now + 1)){
q.push(now + 1);
vis[now + 1] = 1;
step[now + 1] = step[now] + 1;
}
if(check(now -1)){
q.push(now -1);
vis[now -1] = 1;
step[now -1] = step[now] + 1;
}
if(check(now + now)){
q.push(now + now);
vis[now + now] = 1;
step[now + now] = step[now] + 1;
}
}
return ;
}
int main()
{
while(scanf("%d %d", &n, &k) == 2){
bfs();
int ans = step[k]*10;
printf("%d:%d\n", ans/60, ans%60);
}
return 0;
}
问题 E: 奇怪的电梯
题解：同样是去枚举状态，枚举可能出现的数值，然后判重。
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 200+8;
int updown[maxn];
int vis[maxn];
int step[maxn];
int n, a, b;
int check(int num)
{
if(num <= 0 || num > n || vis[num] ) return 0;
return 1;
}
void bfs()
{
queue<int>q;
memset(vis, 0, sizeof(vis));
memset(step, -1, sizeof(step));
q.push(a);
vis[a] = 1;
step[a] = 0;
while(!q.empty()){
int now = q.front();
q.pop();
if(now == b) return ;
for(int i = -1; i <= 1; i++){
if(i){
int next = now + i*updown[now];
if(check(next)){
q.push(next);
vis[next] = 1;
step[next] = step[now] + 1;
}
}
}
}
return ;
}
int main()
{
while(scanf("%d", &n) == 1){
if(n == 0) break;
scanf("%d %d",&a, &b);
for(int i = 1; i <= n; i++) scanf("%d", &updown[i]);
bfs();
printf("%d\n",step[b]);
}
return 0;
}
问题 F: 肥宅快乐水（搜索例题）倒水问题
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 100+1; // 108 TLE
int vis[maxn][maxn][maxn]; // 标记数组
int v[5];
struct cup{ // 结构体 记录状态
int v[5];
int cnt;
}temp;
void pour(int a, int b) // 将a杯中的水 倒入 b杯中
{
int sum = temp.v[a] + temp.v[b];
if(sum >= v[b]){
temp.v[b] = v[b];
}
else temp.v[b] = sum;
temp.v[a] = sum - temp.v[b];
}
void bfs()
{
queue<cup>q; // 声明队列
memset(vis, 0, sizeof(vis)); // 初始化
cup cur;
cur.v[1] = v[1];
cur.v[2] = 0;
cur.v[3] = 0;
cur.cnt = 0;
q.push(cur); // 入队
vis[v[1]][0][0] = 1;
while(!q.empty()){ // 队列非空
cur = q.front(); // 取队首
q.pop(); // 出队
if(cur.v[2] == 0 && cur.v[1] == cur.v[3]) { //找到目标状态
// printf("%d %d\n", cur.v[1], cur.v[3]);
printf("%d\n",cur.cnt);
return ;
}
for(int i = 1; i <= 3; i++){ // 互相倒水
for(int j = 1; j <= 3; j++){
if(i != j){ // 不能将水倒给自己
temp = cur;
pour(i, j); // 倒水
if(!vis[temp.v[1]][temp.v[2]][temp.v[3]]){ // 判重
temp.cnt++;
q.push(temp);
vis[temp.v[1]][temp.v[2]][temp.v[3]] = 1;
}
}
}
}
}
printf("NO\n");
return ;
}
int main()
{
while(scanf("%d %d %d", &v[1], &v[2], &v[3]) == 3 && v[1] && v[2] && v[3]){
if(v[2] > v[3]){ // 最后平分的水一定会在最大的两个杯子里里面
int t = v[2];
v[2] = v[3];
v[3] = t;
}
bfs();
}
return 0;
}
问题 G: 绝地求生
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <queue>
using namespace std;
typedef pair <int, int> pii;
const int maxn = 1000 + 5, INF = 0x3f3f3f3f;
char G[maxn][maxn];
int t, n, m, ans;
bool vis[maxn][maxn];
int dist[maxn][maxn], F[maxn][maxn];
pii B, now, Next;
vector <pii> Fire;
void bfs1() {
memset(vis, false, sizeof vis);
memset(F, INF, sizeof F);
queue <pii> Q;
for(int i = 0; i < Fire.size(); i ++) {
Q.push(Fire[i]);
F[Fire[i]. first][Fire[i].second] = 0;
}
while(!Q.empty()) {
now = Q.front(); Q.pop();
for(int i = -1; i <= 1; i ++) {
for(int j = -1; j <= 1; j ++) {
if(abs(i - j) == 1) {
Next = make_pair(now.first + i, now.second + j);
if(!vis[Next.first][Next.second] && Next.first >= 0 && Next.second >= 0 && Next.first < n && Next.second < m) {
if( G[Next.first][Next.second] != '#') {
Q.push(Next);
F[Next.first][Next.second] = F[now.first][now.second] + 1;
vis[Next.first][Next.second] = true;
}
}
}
}
}
}
}
int bfs2() {
queue <pii> Q;
Q.push(B);
memset(dist, 0, sizeof dist);
memset(vis, false, sizeof vis);
while(!Q.empty()) {
now = Q.front(); Q.pop();
if(now.first == 0 || now.first == n - 1 || now.second == 0 || now.second == m - 1) {
// cout << now.first << ' ' << now.second << endl;
return dist[now.first][now.second] + 1;
}
for(int i = -1; i <= 1; i ++) {
for(int j = -1; j <= 1; j ++) {
if(abs(i - j) == 1) {
Next = make_pair(now.first + i, now.second + j);
if(!vis[Next.first][Next.second] && G[Next.first][Next.second] != '#') {
if(Next.first >= 0 && Next.second >= 0 && Next.first < n && Next.second < m) {
if(dist[now.first][now.second] + 1 < F[Next.first][Next.second]) {
dist[Next.first][Next.second] = dist[now.first][now.second] + 1;
Q.push(Next);
vis[Next.first][Next.second] = true;
}
}
}
}
}
}
}
return -1;
}
int main() {
cin >> t;
while(t --) {
cin >> n >> m;
for(int i = 0; i < n; i ++) {
cin >> G[i];
for(int j = 0; j < m; j ++) {
if(G[i][j] == 'D') {
B = make_pair(i, j);
}
if(G[i][j] == 'F') {
Fire.push_back(make_pair(i, j));
}
}
}
bfs1();
// for(int i = 0; i < n; i ++) {
// for(int j = 0; j < m; j ++) {
// printf("%d ", F[i][j]);
// }
// printf("\n");
// }
ans = bfs2();
if(ans == -1) printf("Bad answer\n");
else printf("%d\n", ans);
Fire.clear();
}
return 0;
}问题 H: 八数码 （搜索例题） 状态空间搜索
解法1： 用set 判重
#include<cstdio> // 用 set 判重
#include<cstring>
#include<set>
using namespace std;
typedef int State[9]; // 定义状态类型 定义了一个数组 别名为State
const int maxn = 1000000 + 8; // 状态太多 不开大数组 无法搜索
State st[maxn], goal; // 状态数组
int dist[maxn]; // 距离数组
set<int>vis; // set 判重 将九宫格映射到int
const int dx[] = {-1, 1, 0, 0}; // 方向
const int dy[] = {0, 0, -1, 1};
// BFS 返回目标状态在st数组中的下标
void init_lookup_table() // 初始化
{
vis.clear();
}
int try_to_insert(int s) // 状态下标
{
int v = 0;
for(int i = 0; i < 9; i++) v = v*10 + st[s][i];
if(vis.count(v)) return 0; // 判重
vis.insert(v);
return 1;
}
int bfs()
{
init_lookup_table(); // 初始化查找表
int front = 1, rear = 2; // 不使用下标 0 因为 0 被当作不存在
while(front < rear){ // 判断队列是否为空
State& s = st[front]; // 用引用 简化代码 起始状态
if(memcmp(goal, s, sizeof(s)) == 0) return front; // 找到目标状态
int z;
for(z = 0; z < 9; z++) if(!s[z]) break; // 找到 0 的 位置
int x = z/3, y = z%3; // 找到 行列
for(int d = 0; d < 4; d++){
int newx = x + dx[d];
int newy = y + dy[d];
int newz = newx*3 + newy;
if(newx >= 0 && newx < 3 && newy >= 0 && newy < 3){
// 合法移动
State& t = st[rear]; // 声明应用 改变t 就会改变st[rear]
memcpy(&t, &s, sizeof(s)); // 整体复制 扩展新结点 内存拷贝
t[newz] = s[z]; // 移动 单个移动
t[z] = s[newz]; // 下一个状态
dist[rear] = dist[front] + 1; // 更新新结点距离值
if(try_to_insert(rear)) rear++; // 如果成功插入查找表 修改队尾指针
}
}
front++;
}
return 0;
}
int main()
{
for(int i = 0; i < 9; i++) scanf("%d", &st[1][i]);
for(int i = 0; i < 9; i++) scanf("%d", &goal[i]);
int ans = bfs();
if(ans > 0) printf("%d\n", dist[ans]);
else printf("-1\n");
return 0;
}
解法2： 用hash判重
#include<cstdio> // 用 hash 判重
#include<cstring>
using namespace std;
const int maxn = 1000000+8;
typedef int State[9];
State st[maxn], goal;
int dist[maxn];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
const int hashsize = 1000000+8;
int head[hashsize];
int next[hashsize];
void init_lookup_table()
{
memset(head, 0, sizeof(head));
}
int hash(State& s)
{
int v = 0;
for(int i = 0; i < 9; i++) v = v*10 + s[i];
return v%hashsize;
}
int try_to_insert(int s )
{
int h = hash(st[s]);
int u = head[h]; // 从表头开始查找链表
while(u){
if(memcmp(st[u], st[s], sizeof(st[s])) == 0) return 0;
u = next[u];
}
next[s] = head[h]; // 链表链接
head[h] = s;
return 1;
}
int bfs()
{
init_lookup_table();
int front = 1, rear = 2;
while(front < rear){
State& s = st[front];
if(memcmp(goal, s, sizeof(s)) == 0) return front;
int z;
for(z = 0; z < 9; z++) if(!s[z]) break;
int x = z/3, y = z%3;
for(int d = 0; d < 4; d++){
int newx = x + dx[d];
int newy = y + dy[d];
int newz = newx*3 + newy;
if(newx >= 0 && newx < 3 && newy >= 0 && newy < 3 ){
State& t = st[rear];
memcpy(&t, &s, sizeof(s)); // 整体移动九宫格
t[newz] = s[z]; // 移动一次
t[z] = s[newz];
dist[rear] = dist[front] + 1;
if(try_to_insert(rear)) rear++;
}
}
front++;
}
return 0;
}
int main()
{
for(int i = 0; i < 9; i++) scanf("%d", &st[1][i]);
for(int i = 0; i < 9; i++) scanf("%d", &goal[i]);
int ans = bfs();
if(ans > 0) printf("%d\n", dist[ans]);
else printf("-1\n");
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
