深度优先搜索

ccming11

已于 2024-09-28 13:42:41 修改

阅读量411

点赞数 12

文章标签：深度优先算法开发语言 c++

于 2024-09-28 13:41:16 首次发布

本文链接：https://blog.csdn.net/ccming11/article/details/142614779

版权

第1关：效益最佳问题

第2关：选书

第3关：城堡问题

第1关：效益最佳问题

任务描述
有A，B，C，D，E五人从事J1，J2，J3，J4，J5五项工作，每人只能从事一项，他们的效益如下。

每人选择五项工作中的一项，在各种选择的组合中，找到效益最高的的一种组合输出。

问题分析
⒈用数组ｆ储存工作选择的方案；数组ｇ存放最优的工作选择方案；数组ｐ用于表示某项工作有没有被选择了。
⒉(1)选择ｐ(i)=0的第i项工作；
(2)判断效益是否高于max已记录的效益，若高于则更新ｇ数组及max的值。
⒊搜索策略: 回溯法（深度优先搜索dfs）。

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <iomanip>
using namespace std;

int data[6][6] = {{0,0,0,0,0,0},
                  {0,13,11,10,4,7},  // A 的工作效益
                  {0,13,10,10,8,5},   // B 的工作效益
                  {0,5,9,7,7,4},     // C 的工作效益
                  {0,15,12,10,11,5}, // D 的工作效益
                  {0,10,11,8,8,4}};  // E 的工作效益

int max1 = 0, g[10], f[10];
bool p[6] = {0};

int go(int step, int t) {
    if (step == 6) { 
        if (t > max1) {
            max1 = t; 
            for (int i = 1; i <= 5; i++) {
                g[i] = f[i]; 
            }
        }
        return 0;
    }

    for (int i = 1; i <= 5; i++) {
        if (!p[i]) {
            p[i] = true; 
            f[step] = i; 
            go(step + 1, t + data[step][i]);
            p[i] = false;
        }
    }

    return 0;
}

int main() {
    go(1, 0);

    for (int i = 1; i <= 5; i++) {
        cout << char(64 + i) << ":J" << g[i] << setw(3);
    }
    cout << endl;

    cout << "supply:" << max1 << endl;

    return 0;
}

预期输出

A:J5 B:J3 C:J4 D:J1 E:J2

supply:50

第2关：选书

任务描述
学校放寒假时，信息学竞赛辅导老师有A，B，C，D，E五本书，要分给参加培训的张、王、刘、孙、李五位同学，每人只能选一本书。老师事先让每个人将自己喜欢的书填写在如下的表格中。然后根据他们填写的表来分配书本，希望设计一个程序帮助老师求出所有可能的分配方案，使每个学生都满意。

问题分析
可用穷举法，先不考虑“每人都满意” 这一条件，这样只剩“每人选一本且只能选一本”这一条件。在这个条件下，可行解就是五本书的所有全排列，一共有5！=120种。然后在120种可行解中一一删去不符合“每人都满意”的解，留下的就是本题的解答。
为了编程方便，设1，2，3，4，5分别表示这五本书。这五个数的一种全排列就是五本书的一种分发。例如54321就表示第5本书（即E）分给张，第4本书（即D）分给王，……，第1本书（即A）分给李。“喜爱书表”可以用二维数组来表示，1表示喜爱，0表示不喜爱。

算法设计：S1：产生5个数字的一个全排列；
S2：检查是否符合“喜爱书表”的条件，如果符合就打印出来；
S3：检查是否所有的排列都产生了，如果没有产生完，则返回S1；
S4：结束。

上述算法有可以改进的地方。比如产生了一个全排列12345，从表中可以看出，选第一本书即给张同学的书，1是不可能的，因为张只喜欢第3、4本书。这就是说，1××××一类的分法都不符合条件。由此想到，如果选定第一本书后，就立即检查一下是否符合条件，发现1是不符合的，后面的四个数字就不必选了，这样就减少了运算量。换句话说，第一个数字只在3、4中选择，这样就可以减少3/5的运算量。同理，选定了第一个数字后，也不应该把其他4个数字一次选定，而是选择了第二个数字后，就立即检查是否符合条件。例如，第一个数选3，第二个数选4后，立即检查，发现不符合条件，就应另选第二个数。这样就把34×××一类的分法在产生前就删去了。又减少了一部分运算量。

综上所述，改进后的算法应该是：在产生排列时，每增加一个数，就检查该数是否符合条件，不符合，就立刻换一个，符合条件后，再产生下一个数。因为从第I本书到第I+1本书的寻找过程是相同的，所以可以用回溯算法。算法设计如下：

int Search(i)
{
for (j=1;j<=5;j++)
{
if (第i个同学分给第j本书符合条件)
{
记录第i个数
if (i==5) 打印一个解;
else Search(i+1);
删去第i 个数
}
}
}

#include<cstdio>
#include<iostream>
#include<cstdlib>
using namespace std;

int book[6], c = 0;
bool flag[6];
bool like[6][6] = {
    {0, 0, 0, 0, 0, 0},
    {0, 0, 0, 1, 1, 0},  // 张同学的喜好
    {0, 1, 1, 0, 0, 1},  // 王同学的喜好
    {0, 0, 1, 1, 0, 0},  // 刘同学的喜好
    {0, 0, 0, 0, 1, 0},  // 孙同学的喜好
    {0, 0, 1, 0, 0, 1}   // 李同学的喜好
};

int search(int i);
int print();

int main() {
    for (int i = 1; i <= 5; i++) flag[i] = 1;
    search(1);
    return 0;
}

int search(int i) {
    if (i == 6) {
        print(); 
        return 0;
    }

    for (int j = 1; j <= 5; j++) {
        if (like[i][j] && flag[j]) { 
            book[i] = j;
            flag[j] = 0;
            search(i + 1);
            flag[j] = 1;
        }
    }
    return 0;
}

int print() {
    c++;
    cout << "answer " << c << ":\n";
    for (int i = 1; i <= 5; i++) {
        cout << i << ": " << char(64 + book[i]) << endl;
    }
}

预期输出

answer 1:

1: C

2: A

3: B

4: D

5: E

第3关：城堡问题

任务描述

输入
程序从标准输入设备读入数据。第一行是两个整数，分别是南北向、东西向的方块数。在接下来的输入行里，每个方块用一个数字(0≤p≤50)描述。用一个数字表示方块周围的墙，1表示西墙，2表示北墙，4表示东墙，8表示南墙。每个方块用代表其周围墙的数字之和表示。城堡的内墙被计算两次，方块(1,1)的南墙同时也是方块(2,1)的北墙。输入的数据保证城堡至少有两个房间。

输出
城堡的房间数、城堡中最大房间所包括的方块数。结果显示在标准输出设备上。

样例输入
4
7
11 6 11 6 3 10 6
7 9 6 13 5 15 5
1 10 12 7 13 7 5
13 11 10 8 10 12 13

样例输出
5
9

例：11的二进制为1011，每一位二进制分别表示“南墙”“东墙”“北墙”“西墙”，为1表示有墙，为0表示没墙。
按位与运算符&的使用：如：11&4 <=> 1011 & 0100 = 0000 = 0。相同为1，不同为0。
竖式：1011
&0100
-----
0000
解题思路：
对每个方块，深度优先搜索（DFS），从而给这个方块能够达到的所有位置染色。最后统计出一共有多少种颜色，以及每种颜色的数量。
比如：
1 1 2 2 3 3 3
1 1 1 2 3 4 3
1 1 1 5 3 5 3
1 5 5 5 5 5 3
从而一共有5个房间，最大的房间（1）占据9个格子。

#include<iostream>
#include<stack>
#include<cstring>
using namespace std;

int R, C;  
int rooms[60][60];
int color[60][60];
int maxRoomArea = 0, roomNum = 0; 
int roomArea; 

void Dfs(int i, int k) {
    color[i][k] = roomNum;
    roomArea++;
    
    // 西方向
    if ((rooms[i][k] & 1) == 0 && !color[i][k - 1]) {
        Dfs(i, k - 1);
    }
    // 北方向
    if ((rooms[i][k] & 2) == 0 && !color[i - 1][k]) {
        Dfs(i - 1, k);
    }
    // 东方向
    if ((rooms[i][k] & 4) == 0 && !color[i][k + 1]) {
        Dfs(i, k + 1);
    }
    // 南方向
    if ((rooms[i][k] & 8) == 0 && !color[i + 1][k]) {
        Dfs(i + 1, k);
    }
}

int main() {
    cin >> R >> C;
    
    for (int i = 1; i <= R; i++)
        for (int k = 1; k <= C; k++)
            cin >> rooms[i][k];
    memset(color, 0, sizeof(color));
    for (int i = 1; i <= R; i++) {
        for (int k = 1; k <= C; k++) {
            if (!color[i][k]) { 
                ++roomNum;
                roomArea = 0; 
                Dfs(i, k); 
                maxRoomArea = max(roomArea, maxRoomArea); 
            }
        }
    }

    cout << roomNum << endl; 
    cout << maxRoomArea << endl; 

    return 0;
}

预期输出