第四章 搜索

最新推荐文章于 2020-11-03 22:54:26 发布
最新推荐文章于 2020-11-03 22:54:26 发布
阅读量2.4k 收藏
点赞数 1
分类专栏： C++ 算法与数据结构 文章标签： 搜索 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jasschow/article/details/51615838
版权

深度优先搜索

计算数的全排列
#include<iostream>
#include<vector>
#include<iterator>
#include<algorithm>

using namespace std;

/*
将1-n全排列，目前到了从左到右的step位
box：从左到右存储
flags：1-n哪些已经用了
*/
void dfs(vector<int> & box, vector<bool> & flags, int step, int n)
{
    if (step == n)  //如果当前到n，说明0~n-1已经存了1~n，停止搜索
    {
        ostream_iterator<int> o_iter(cout, "");
        copy(box.begin(), box.end(), o_iter);
        cout << endl;
        return;
    }

    //此时站在第step位（从左到右），将没使用的数按1~3尝试
    for (int i = 1; i <= n; ++i)
    {
        if (flags[i - 1] == false)  //如果这个数是未使用的
        {
            //开始尝试使用
            box[step] = i;
            flags[i - 1] = true;
            //在这种使用方式下，处理下一位
            dfs(box, flags, step + 1, n);
            //把数放回，尝试下一个数
            flags[i - 1] = false;
        }
    }
}

int main(void)
{
    int n = 3;  //输入1-3的全排列
    vector<int> box(n);
    vector<bool> flags(n, false);
    dfs(box, flags, 0, n);  //从左边第一位开始尝试
    return 0;
}
深度优先搜索把每一种可能都去尝试一遍（for），当前步解决的情况下进入下一步，而下一步解决的方法和当前步是完全一样的。
//深度优先搜索的基本模型
void dfs(int step)
{
    判断边界
    尝试每一种可能 for(i = 1; i <= n; ++i)
    {
        继续下一步 dfs(step + 1);
    }
    返回
}
再次尝试用深度优先搜索解决暴力枚举
将数字1~9填入等式“??? + ??? = ???”使等式成立
#include<iostream>
#include<vector>

using namespace std;

void dfs(vector<int> & box, vector<bool> & flags, int step, int n, int & total)
{
    if (step == n)
    {
        int a = box[0] * 100 + box[1] * 10 + box[2];
        int b = box[3] * 100 + box[4] * 10 + box[5];
        int c = box[6] * 100 + box[7] * 10 + box[8];
        if (a + b == c)  //判断等式是否满足
        {
            cout << box[0] << box[1] << box[2] << '+'
                << box[3] << box[4] << box[5] << '='
                << box[6] << box[7] << box[8] << endl;
            ++total;
        }
        return;
    }

    for (int i = 1; i <= n; ++i)
    {
        if (flags[i - 1] == false)
        {
            //开始尝试使用
            box[step] = i;
            flags[i - 1] = true;
            //在这种使用方式下，处理下一位
            dfs(box, flags, step + 1, n, total);
            //把数放回，尝试下一个数
            flags[i - 1] = false;
        }
    }
}

int main(void)
{
    int n = 9;  //输入1-9的全排列，但是要使得???+???=???等式成立
    vector<int> box(n);
    vector<bool> flags(n, false);
    int total = 0;  //设置变量用于存储所有情况
    dfs(box, flags, 0, n, total);  //从左边第一位开始尝试

    cout << total / 2 << endl;

    return 0;
}

深度优先搜索迷宫

迷宫由n行m列的单元格组成，每个单元格要么是空地，要么是障碍物，任务是找到一条从迷宫的起点通往目的位置的最短路径。
按照右下左上的顺序尝试路径搜索。
#include<iostream>
#include<vector>
#include<algorithm>
#include<climits>
#include<iterator>

using namespace std;

struct Point
{
    int x;
    int y;
};

void dfs(vector<vector<int>> & map, vector<vector<bool>> & flags,  //地图及地图标记
    Point curr, Point end,  //当前位置及目的位置
    int step, vector<Point> & path, int & min, vector<Point> & min_path)  //当前步长和当前路径，以及最短长度和最短路径
{
    if (curr.x == end.x && curr.y == end.y)
    {
        if (step < min)
        {
            min = step;
            min_path.resize(path.size());
            copy(path.begin(), path.end(), min_path.begin());
        }
        return;
    }

    static const vector<vector<int>> next = {
        {0, 1},  //向右
        {1, 0},  //向下
        {0, -1},  //向左
        {-1, 0}  //向上
    };

    for (const auto & direction : next)
    {
        //计算下一个点的坐标
        Point trypoint;
        trypoint.x = curr.x + direction[0];
        trypoint.y = curr.y + direction[1];

        //判断是否越界
        if (trypoint.x < 0 || trypoint.x >= map.size() 
            || trypoint.y < 0 || trypoint.y >= map[0].size())
            continue;

        if (map[trypoint.x][trypoint.y] == 0 && flags[trypoint.x][trypoint.y] == false)
        {
            //该点不是障碍且在路径中
            flags[trypoint.x][trypoint.y] = true;  //标记这个点已经走过
            path.push_back(trypoint);
            dfs(map, flags, trypoint, end, step + 1, path, min, min_path);  //下一个点
            path.pop_back();
            flags[trypoint.x][trypoint.y] = false;  //尝试结束，取消这个点的标记
        }
    }
}

int main(void)
{
    int rows = 5;  //行数
    int cols = 4;  //列数
    vector<vector<int>> map = {
        {0, 0, 1, 0},
        {0, 0, 0, 0},
        {0, 0, 1, 0},
        {0, 1, 0, 0},
        {0, 0, 0, 1},
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));  //行走标记
    //(向下为x，向右为y)
    //起点
    Point start;
    start.x = 0;
    start.y = 0;
    //终点
    Point end;
    end.x = 3;
    end.y = 2;

    vector<Point> path;  //搜索过程中尝试保存的路径
    path.push_back(start);  //路径的起点一定是(0, 0)
    vector<Point> min_path;  //最短路径
    int min = INT_MAX;  //最短路径长度
    dfs(map, flags, start, end, 0, path, min, min_path);  //从起点开始搜索

    cout << min << endl;
    for (auto iter = min_path.begin(); iter != min_path.end(); ++iter)
    {
        cout << '(' << iter->x << ',' << iter->y << ')';
        if (iter == min_path.end() - 1)
            break;
        cout << " ==> ";
    }
    cout << endl;

    //地图和路线的打印
    ostream_iterator<int> o_iter(cout, " ");
    cout << "原图" << endl;
    for (const auto & line : map)
    {
        copy(line.begin(), line.end(), o_iter);
        cout << endl;
    }
    cout << "走起" << endl;
    for (const auto & point : min_path)
        map[point.x][point.y] = 2;
    for (const auto & line : map)
    {
        copy(line.begin(), line.end(), o_iter);
        cout << endl;
    }

    return 0;
}
发明深度优先算法的是John E.Hopcroft和Robert E.Tarjan。1971~1972年，他们在斯坦福大学研究图的连通性（任意两点是否可以相互到达）和平面性（图中所有的边相互不交叉。在电路板上设计布线的时候，要求线与线不能交叉。这就是平面性的一个实际应用。）时，发明了这个算法，因此获得了1986年的图灵奖。
在授奖仪式上，当年全国象棋程序比赛的优胜者说他的程序用的就是深度优先算法，这是以奇制胜的关键。此外Tarjan是另外两位图灵奖得主Robert W.Floyd和Donald E.Knuth的学生。

广度优先搜索迷宫

深度优先搜索是沿着某条路直到走不通的时候回起点继续尝试，而广度优先搜索是通过一层层扩展的方法来搜索的。
使用队列模拟。
#include<iostream>
#include<vector>
#include<iterator>

using namespace std;

struct Point
{
    int x;
    int y;
    int last;  //上一个点，从哪个点来的，对第一个点无意义
};

int main(void)
{
    int rows = 5;  //行数
    int cols = 4;  //列数
    vector<vector<int>> map = {
        {0, 0, 1, 0},
        {0, 0, 0, 0},
        {0, 0, 1, 0},
        {0, 1, 0, 0},
        {0, 0, 0, 1},
    };
    static const vector<vector<int>> next = {
        { 0, 1 },  //向右
        { 1, 0 },  //向下
        { 0, -1 },  //向左
        { -1, 0 }  //向上
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));  //行走标记
    //(向下为x，向右为y)
    //起点
    Point start;
    start.x = 0;
    start.y = 0;
    //终点
    Point end;
    end.x = 3;
    end.y = 2;

    vector<Point> search;  //不用queue是因为要还原路径
    start.last = 0;
    search.push_back(start);
    int header = 0;
    bool isfind = false;

    while (header != search.size() && !isfind)  //队列不为空
    {
        for (const auto & direction : next)
        {
            Point trypoint;
            trypoint.x = search[header].x + direction[0];
            trypoint.y = search[header].y + direction[1];
            if (trypoint.x < 0 || trypoint.x >= map.size()
                || trypoint.y < 0 || trypoint.y >= map[0].size())  //判断是否越界
                continue;
            if (map[trypoint.x][trypoint.y] == 0 && flags[trypoint.x][trypoint.y] == false)
            {
                //该点不是障碍且在路径中
                //宽度优先搜索每个点只入队一次，不需要将flags还原
                flags[trypoint.x][trypoint.y] = true;
                trypoint.last = header;
                search.push_back(trypoint);
            }
            if (trypoint.x == end.x && trypoint.y == end.y)
            {
                //广度优先搜索找到一条路径就停止
                isfind = true;
                break;
            }
        }
        ++header;
    }

    //严格来说必须判断isfind才能确定是不是找到之后才跳出来的

    vector<Point> path;
    int curr_index = search.size() - 1;  //如果是找到之后跳出来，那么最后一个点一定是终点
    while (true)
    {
        path.push_back(search[curr_index]);
        if (curr_index == search[curr_index].last)  //已到起点，跳出
            break;
        curr_index = search[curr_index].last;
    }

    for (auto iter = path.rbegin(); iter != path.rend(); ++iter)
    {
        cout << '(' << iter->x << ',' << iter->y << ')';
        if (iter == path.rend() - 1)
            break;
        cout << " ==> ";
    }
    cout << endl;

    //地图和路线的打印
    ostream_iterator<int> o_iter(cout, " ");
    cout << "原图" << endl;
    for (const auto & line : map)
    {
        copy(line.begin(), line.end(), o_iter);
        cout << endl;
    }
    cout << "走起" << endl;
    for (const auto & point: path)
        map[point.x][point.y] = 2;
    for (const auto & line : map)
    {
        copy(line.begin(), line.end(), o_iter);
        cout << endl;
    }

    return 0;
}
1959年，Edward F.Moore率先在“如何从迷宫中寻找出路”这一问题中提出了广度优先搜索算法。1961年，C.Y.Lee在“电路板布线”这一问题中也独立提出了相同的算法。

再解炸弹人

枚举法没考虑是否能走到对应坐标点放置炸弹
可以通过广度优先搜索或者深度优先搜索来枚举所有可以到达的点，然后在这些可以到达的点上分别统计可以消灭的敌人数。
广度优先搜索解决方案
#include<iostream>
#include<vector>
#include<string>
#include<queue>

using namespace std;

struct Point
{
    int x;
    int y;
};

int getnum(const vector<string> & map, int i, int j)
{
    //在某个点放置炸弹能够消灭的敌人数
    int sum = 0;
    int x = i;
    int y = j;
    while (map[x][y] != '#')  //向下
    {
        if (map[x][y] == 'G')  //是敌人
            ++sum;
        ++x;
    }
    x = i;
    y = j;
    while (map[x][y] != '#')  //向上
    {
        if (map[x][y] == 'G')
            ++sum;
        --x;
    }
    x = i;
    y = j;
    while (map[x][y] != '#')  //向右
    {
        if (map[x][y] == 'G')
            ++sum;
        ++y;
    }
    x = i;
    y = j;
    while (map[x][y] != '#')  //向左
    {
        if (map[x][y] == 'G')
            ++sum;
        --y;
    }
    return sum;
}

int main(void)
{
    vector<string> map = {
        "#############",
        "#GG.GGG#GGG.#",
        "###.#G#G#G#G#",
        "#.......#..G#",
        "#G#.###.#G#G#",
        "#GG.GGG.#.GG#",
        "#G#.#G#.#.#.#",  //#G#.#G#.#.###，为了测试修改
        "##G...G.....#",
        "#G#.#G###.#G#",
        "#...G#GGG.GG#",
        "#G#.#G#G#.#G#",
        "#GG.GGG#G.GG#",
        "#############"
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));
    static const vector<vector<int>> next = {
        { 0, 1 },  //向右
        { 1, 0 },  //向下
        { 0, -1 },  //向左
        { -1, 0 }  //向上
    };

    queue<Point> search;
    search.push({ 3, 3 });  //队首，起始位置

    //统计最多的敌人数和坐标，假设起点最大，再四方广搜
    int max_count = getnum(map, 3, 3);
    int max_x = 3;
    int max_y = 3;

    //两重循环枚举每一点
    while (!search.empty())
    {
        for (const auto & direction : next)
        {
            Point trypoint;
            trypoint.x = search.front().x + direction[0];
            trypoint.y = search.front().y + direction[1];

            if (trypoint.x < 0 || trypoint.x >= map.size()
                || trypoint.y < 0 || trypoint.y >= map[0].size())  //判断是否越界
                continue;

            if (map[trypoint.x][trypoint.y] == '.' && flags[trypoint.x][trypoint.y] == false)
            {
                //该点不是障碍并且没走过
                flags[trypoint.x][trypoint.y] = true;  //没走过就走起
                search.push(trypoint);
                int sum = getnum(map, trypoint.x, trypoint.y);
                if (sum > max_count)
                {
                    max_count = sum;
                    max_x = trypoint.x;
                    max_y = trypoint.y;
                }
            }
        }
        search.pop();  //当前点扩展完，出队
    }

    cout << '(' << max_x << ',' << max_y << ")==>" << max_count << endl;

    return 0;
}
深度优先搜索解决方案
每走到一个新点就统计该点可以消灭的敌人数，并从该点继续尝试往下走，直到无路可走的时候返回，再尝试走其他方向，直到将所有可以走到的点都访问一遍，程序结束。
#include<iostream>
#include<vector>
#include<string>

using namespace std;

int getnum(const vector<string> & map, int i, int j)
{
    //在某个点放置炸弹能够消灭的敌人数
    int sum = 0;
    int x = i;
    int y = j;
    while (map[x][y] != '#')  //向下
    {
        if (map[x][y] == 'G')  //是敌人
            ++sum;
        ++x;
    }
    x = i;
    y = j;
    while (map[x][y] != '#')  //向上
    {
        if (map[x][y] == 'G')
            ++sum;
        --x;
    }
    x = i;
    y = j;
    while (map[x][y] != '#')  //向右
    {
        if (map[x][y] == 'G')
            ++sum;
        ++y;
    }
    x = i;
    y = j;
    while (map[x][y] != '#')  //向左
    {
        if (map[x][y] == 'G')
            ++sum;
        --y;
    }
    return sum;
}

void dfs(const vector<string> & map, vector<vector<bool>> & flags, int x, int y,
    int & max_x, int & max_y, int & max_count)  //记录最优值
{
    //统计当前点
    int sum = getnum(map, x, y);
    if (sum > max_count)
    {
        max_count = sum;
        max_x = x;
        max_y = y;
    }

    static const vector<vector<int>> next = {
        { 0, 1 },  //向右
        { 1, 0 },  //向下
        { 0, -1 },  //向左
        { -1, 0 }  //向上
    };
    //从该点开始深度搜索每个方向
    for (const auto & direction : next)
    {
        int try_x = x + direction[0];
        int try_y = y + direction[1];
        if (try_x < 0 || try_x >= map.size() || try_y < 0 || try_y >= map[0].size())
            continue;  //判断是否越界
        if (map[try_x][try_y] == '.' && flags[try_x][try_y] == false)
        {
            //该点不是障碍并且还没走过
            flags[try_x][try_y] = true;
            dfs(map, flags, try_x, try_y, max_x, max_y, max_count);  //尝试下一点
            //因为没有还原，所以终点就是能走到的点全部都标记了
        }
    }
}

int main(void)
{
    vector<string> map = {
        "#############",
        "#GG.GGG#GGG.#",
        "###.#G#G#G#G#",
        "#.......#..G#",
        "#G#.###.#G#G#",
        "#GG.GGG.#.GG#",
        "#G#.#G#.#.#.#",  //#G#.#G#.#.###，为了测试修改
        "##G...G.....#",
        "#G#.#G###.#G#",
        "#...G#GGG.GG#",
        "#G#.#G#G#.#G#",
        "#GG.GGG#G.GG#",
        "#############"
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));

    //统计最多的敌人数和坐标，假设起点最大，再四方广搜
    int max_count = getnum(map, 3, 3);
    int max_x = 3;
    int max_y = 3;
    dfs(map, flags, 3, 3, max_x, max_y, max_count);

    cout << '(' << max_x << ',' << max_y << ")==>" << max_count << endl;

    return 0;
}

宝岛冒险（着色问题）

用二维矩阵表示地图，数字表示海拔，0表示海洋，1-9表示陆地，给定一个降落位置，算出降落地所在岛的面积（格子数）。
广度优先搜索解决方案
从队列中取出点进行扩展（四个方向），当扩展出的点大于0时就加入队列，直到队列扩展完毕。所有被加入队列的点的总数就是小岛面积。
#include<iostream>
#include<vector>
#include<queue>
#include<iomanip>

using namespace std;

struct Point
{
    int x;
    int y;
};

void bfs(vector<vector<int>> & map, vector<vector<bool>> & flags, int x, int y, int color)
{
    static const vector<vector<int>> next = {
        { 0, 1 },  //向右
        { 1, 0 },  //向下
        { 0, -1 },  //向左
        { -1, 0 }  //向上
    };

    queue<Point> search;
    search.push({ x, y });  //起始坐标
    flags[x][y] = true;

    while (!search.empty())
    {
        for (const auto & direction : next)
        {
            Point trypoint;
            trypoint.x = search.front().x + direction[0];
            trypoint.y = search.front().y + direction[1];
            if (trypoint.x < 0 || trypoint.x >= map.size()
                || trypoint.y < 0 || trypoint.y >= map[0].size())
                continue;  //判断是否越界
            if (map[trypoint.x][trypoint.y] >= 1 &&
                map[trypoint.x][trypoint.y] <= 9 &&
                flags[trypoint.x][trypoint.y] == false)
            {
                //每个点只入队一次，所以需要标记
                flags[trypoint.x][trypoint.y] = true;
                search.push(trypoint);
            }
        }
        //当前点处理完毕，染色，出队
        map[search.front().x][search.front().y] = color;
        search.pop();
    }
}

int main(void)
{
    vector<vector<int>> map = {
        {1, 2, 1, 0, 0, 0, 0, 0, 2, 3},
        {3, 0, 2, 0, 1, 2, 1, 0, 1, 2},
        {4, 0, 1, 0, 1, 2, 3, 2, 0, 1},
        {3, 2, 0, 0, 0, 1, 2, 4, 0, 0},
        {0, 0, 0, 0, 0, 0, 1, 5, 3, 0},
        {0, 1, 2, 1, 0, 1, 5, 4, 3, 0},
        {0, 1, 2, 3, 1, 3, 6, 2, 1, 0},
        {0, 0, 3, 4, 8, 9, 7, 5, 0, 0},
        {0, 0, 0, 3, 7, 8, 6, 0, 1, 2},
        {0, 0, 0, 0, 0, 0, 0, 0, 1, 0}
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));
    //输出原始地图
    for (const auto & line : map)
    {
        for (const auto & point : line)
            cout << setw(3) << point;
        cout << endl;
    }

    //给出一个降落点就得出一个岛屿
    //遍历整个地图，把所有可降落点搜索一次并标记，找出所有岛屿
    int color = -1;
    for (int i = 0; i < map.size(); ++i)
    {
        for (int j = 0; j < map[i].size(); ++j)
        {
            if (map[i][j] >= 1 && map[i][j] <= 9)  //被填充的肯定是-1、-2、-3……
            {
                bfs(map, flags, i, j, color);
                --color;
            }
        }
    }

    //输出染色地图
    cout << "共有" << (-color - 1) << "个岛屿" << endl;
    for (const auto & line : map)
    {
        for (const auto & point : line)
            cout << setw(3) << point;
        cout << endl;
    }

    return 0;
}
深度优先搜索解决方案
这种方法又叫着色法——以某个点为源点对其邻近的点进行着色。
#include<iostream>
#include<vector>
#include<iomanip>

using namespace std;

void dfs(vector<vector<int>> & map, vector<vector<bool>> & flags, int x, int y, int color)
{
    static const vector<vector<int>> next = {
        { 0, 1 },  //向右
        { 1, 0 },  //向下
        { 0, -1 },  //向左
        { -1, 0 }  //向上
    };

    map[x][y] = color;  //对当前点进行着色

    for (const auto & direction : next)
    {
        int tx = x + direction[0];
        int ty = y + direction[1];

        if (tx < 0 || tx >= map.size() || ty < 0 || ty >= map[0].size())
            continue;  //判断是否越界

        if (map[tx][ty] >= 1 && map[tx][ty] <= 9 && flags[tx][ty] == false)
        {
            //是陆地并且还没搜索过
            flags[tx][ty] = true;
            dfs(map, flags, tx, ty, color);
        }
    }
}

int main(void)
{
    vector<vector<int>> map = {
        {1, 2, 1, 0, 0, 0, 0, 0, 2, 3},
        {3, 0, 2, 0, 1, 2, 1, 0, 1, 2},
        {4, 0, 1, 0, 1, 2, 3, 2, 0, 1},
        {3, 2, 0, 0, 0, 1, 2, 4, 0, 0},
        {0, 0, 0, 0, 0, 0, 1, 5, 3, 0},
        {0, 1, 2, 1, 0, 1, 5, 4, 3, 0},
        {0, 1, 2, 3, 1, 3, 6, 2, 1, 0},
        {0, 0, 3, 4, 8, 9, 7, 5, 0, 0},
        {0, 0, 0, 3, 7, 8, 6, 0, 1, 2},
        {0, 0, 0, 0, 0, 0, 0, 0, 1, 0}
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));
    //输出原始地图
    for (const auto & line : map)
    {
        for (const auto & point : line)
            cout << setw(3) << point;
        cout << endl;
    }

    //给出一个降落点就得出一个岛屿
    //遍历整个地图，把所有可降落点搜索一次并标记，找出所有岛屿
    int color = -1;
    for (int i = 0; i < map.size(); ++i)
    {
        for (int j = 0; j < map[i].size(); ++j)
        {
            if (map[i][j] >= 1 && map[i][j] <= 9)  //被填充的肯定是-1、-2、-3……
            {
                flags[i][j] = true;
                dfs(map, flags, i, j, color);
                --color;
            }
        }
    }

    //输出染色地图
    cout << "共有" << (-color - 1) << "个岛屿" << endl;
    for (const auto & line : map)
    {
        for (const auto & point : line)
            cout << setw(3) << point;
        cout << endl;
    }

    return 0;
}
这就是求一个图中独立子图的个数，这个算法叫做Floodfill漫水填充法（种子填充法）。Floodfill在计算机图形学中有着非常广泛的运用，比如图像分割、物体识别等等。另外Windows下画图软件的油漆桶就是基于这个算法的，当需要给某个密闭区域涂色或者更改某个密闭区域的颜色时，程序自动选中与种子点（鼠标单击点）周边颜色相同的区域，接着将该区域替换成指定的颜色。PhotoShop的魔术棒选择工具也可以基于这个算法实现。
具体算法描述：查找种子点周边的点，将与种子点颜色相近的点（设置阈值以确定）入队作为新种子，并对新入队的种子也进行同样的扩展操作，这样就选取了和最初种子相近颜色的区域。

水管工游戏

只有两种管道，一种弯管一种直管。弯管有4种状态，直管有2种状态。
  • 上右
  • 右下
  • 下左
  • 左上
  • 左右
  • 上下
出水口有四个方向
  • 左
  • 上
  • 右
  • 下
从最左边进，从最右边出
#include<iostream>
#include<vector>

using namespace std;

enum PIPE_TYPE {
    TREE, L_UR, L_RD, L_DL, L_LU, I_H, I_V
};

enum IN_DIRECTION {
    IN_LEFT, IN_UP, IN_RIGHT, IN_DOWN
};

struct Point
{
    int x;
    int y;
};

void dfs(const vector<vector<PIPE_TYPE>> & map, vector<vector<bool>> & flags,
    int x, int y, IN_DIRECTION direction, vector<Point> & path)
{
    if (x == map.size() - 1 && y == map[0].size())
    {
        for (const auto & point : path)
            cout << '(' << point.x << ',' << point.y << ')' << ' ';
        cout << endl;
        return;
    }

    //判断是否越界
    if (x < 0 || x >= map.size() || y < 0 || y >= map[0].size())
        return;

    //判断这个管道是否已经使用过
    if (flags[x][y] == true)
        return;

    flags[x][y] = true;  //标记使用当前管道

    path.push_back({ x, y });

    //如果当前是直管
    if (map[x][y] == I_H || map[x][y] == I_V)
    {
        //进水口在左边，只能使用I_H情况
        if (direction == IN_LEFT)
            dfs(map, flags, x, y + 1, IN_LEFT, path);
        //进水口在上边，只能使用I_V情况
        else if (direction == IN_UP)
            dfs(map, flags, x + 1, y, IN_UP, path);
        //进水口在右边，只能使用I_H情况
        else if (direction == IN_RIGHT)
            dfs(map, flags, x, y - 1, IN_RIGHT, path);
        //进水口在下面，只能使用I_V情况
        else
            dfs(map, flags, x - 1, y, IN_DOWN, path);
    }
    //如果当前是弯管
    else
    {
        if (direction == IN_LEFT)
        {
            dfs(map, flags, x + 1, y, IN_UP, path);  //L_DL
            dfs(map, flags, x - 1, y, IN_DOWN, path);  //L_LU
        }
        else if (direction == IN_UP)
        {
            dfs(map, flags, x, y + 1, IN_LEFT, path);  //L_UR
            dfs(map, flags, x, y - 1, IN_RIGHT, path);  //L_LU
        }
        else if (direction == IN_RIGHT)
        {
            dfs(map, flags, x - 1, y, IN_DOWN, path);  //L_UR
            dfs(map, flags, x + 1, y, IN_UP, path);  //L_RD
        }
        else
        {
            dfs(map, flags, x, y + 1, IN_LEFT, path);  //L_RD
            dfs(map, flags, x, y - 1, IN_RIGHT, path);  //L_DL
        }
    }

    flags[x][y] = false;  //取消标记

    path.pop_back();  //将当前尝试的坐标出栈
}

int main(void)
{
    vector<vector<PIPE_TYPE>> map = {
        {I_H, L_DL, I_H, L_DL},
        {L_UR, I_H, L_DL, TREE},
        {L_RD, L_DL, I_H, L_UR},
        {I_V, L_UR, L_UR, I_H},
        {L_UR, I_H, I_H, L_LU}
    };
    vector<vector<bool>> flags(map.size(), vector<bool>(map[0].size(), false));

    vector<Point> path;

    dfs(map, flags, 0, 0, IN_LEFT, path);

    return 0;
}
jasschow
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二章 搜索 【未完结】
辉小歌的博客
08-25 163
目录Flood Fill1097. 池塘计数 Flood Fill 1097. 池塘计数 #include<bits/stdc++.h> using namespace std; const int N=1e3+10; char a[N][N]; int st[N][N],n,m,ans; int dx[8]={-1,-1,-1,0,0,1,1,1}; int dy[8]={-1,0,1,-1,1,-1,0,1}; void flood(int x,int y) { queue<
搜索篇
越看越喜欢啊
01-14 611
ACM题集：https://blog.csdn.net/weixin_39778570/article/details/83187443 搜索 树与图的遍历 树的DFS序列，时间戳，树的深度，重心 图的联通块划分与大小 拓扑排序，可达性统计 深度&amp;amp;amp;&amp;amp;amp;广搜 深度优先搜索DFS(洛谷) 广度优先搜索BFS(洛谷) 剪枝常用技巧 带有技巧的搜索（洛谷，优先搜索顺序，不可能剪...
2020 蓝桥杯大学 B 组省赛模拟赛（一） J. 程序设计：迷宫 (广度优先搜索）
weixin_44014982的博客
03-20 481
有一个 n×m 的迷宫，其中 . 表示空地， * 表示障碍物。除此之外，有 q 个单向传送门：如果进入格子 (a_i,b_i)，那么会被立即传送到 (c_i,d_i)。保证每个点至多是一个传送门的入口。 如果传送门最终传送到障碍物上，那么将会卡在障碍物上不能移动。 在传送门内部传送的花费是 00，在空地上每次可以往周围四个格子移动，花费是 11。 现在我们想知道从 (1,1) 走到 (x,y) 的...
[ CodeForces 1063 B ] Labyrinth 优先队列
c_czl的博客
06-17 195
给出一个四联通的N×M网格图和起点。图中有一些位置是障碍物。 现在上下移动步数不限，向左至多走a步，向右至多走b步，求从起点出发能到达多少个空地。 优先cur.l+cur.r小的，因为差值恒定 #include <iostream> #include <cstdio> #include <algorithm> #include <cstri...
POJ2195 最佳匹配
KING_JENSEN的专栏
04-30 580
题目意思：         给定N个房子，以及N个人所在的位置，求如何走，使得所走的总距离最短。         测试案例： 给定 N*M 的矩阵，矩阵是由 ‘H’(房子)，‘m’(人), '.'(空地) 构成的。 思路：将图中的房子以及人取出来重新构图，构成一个二分图，然后求这个二分图的最佳匹配。 分别建立 容器(数组，向量等)来放置 房子，以及人，然后算出 每个人和每个房子之间的距离，
Codeforces Round #622 (Div. 2) C2. Skyscrapers (hard version)
放荡者的茶会
02-23 1374
C2. Skyscrapers (hard version) time limit per test3 seconds memory limit per test512 megabytes inputstandard input outputstandard output This is a harder version of the problem. In this version n≤5000...
《集体智慧编程》第四章 搜索引擎数据集
12-11
《集体智慧编程》一书第四章探讨的主题是搜索引擎数据集，这一章主要涵盖了搜索引擎背后的基础原理、数据结构以及处理大规模信息的关键技术。在互联网时代，搜索引擎已成为获取信息的重要工具，而构建一个高效的搜索...
第 4 章 搜索策略1
08-03
【第 4 章 搜索策略1】主要探讨了在解决计算机科学中搜索问题时的不同策略，包括盲目搜索和启发式搜索。搜索是解决不良结构或非结构化问题的有效方法，尤其在缺乏完整信息或者现有算法复杂度较高的情况下。本章分为...
微信小程序开发教程第四章：首页面开发
03-29
首先需要实现首页效果图如下：Template 名片很多，需要用模板、这里需要微信提供的基础组件大致是 input（搜索框）、action-sheet（右边是个底部下拉菜单，需要下拉菜单）、S ...       进行了各种准备与配置后，...
第四章搜索策略.ppt
12-12
状态空间的盲目搜索策略 宽度优先搜索 深度优先搜索 有界深度优先搜索 代价树的宽度优先搜索 代价树的深度优先搜索 估价函数与择优搜索 状态空间的启发式搜索策略 图的有序搜索与A*算法 A*算法应用举例 博弈树的启发...
人工智能：第4章 搜索策略部分参考答案.doc
07-09
《人工智能：第4章 搜索策略》 在人工智能领域，搜索策略是解决复杂问题的关键工具之一。本章主要探讨了如何运用搜索策略来解决实际问题，例如农夫渡河问题和圆盘问题。这两个问题都是典型的约束满足问题，需要通过...
51nod1835 完全图 容斥+dp
olahiuj的博客
11-29 532
Description初始有n个点，任意两个点之间有一条无向边，现在要移除一些无向边（至少一条），问移除后有恰好m个连通块的方案数是多少。 两个方案不同当且仅当存在至少一条无向边在某个方案中被移除，但是在另一个方案中没被移除。 答案可能很大请模一个998,244,353。Input第一行读入n,m。 1<=m<=n<=500Output第一行输出方案数。Solution首先讲一下怎么做m=1的
BZOJ 3782 上学路线 动态规划+Lucas定理
世界
05-28 2536
题目大意：给定一张N∗MN*M的网格图，有TT个坏点，求左上角走到右下角的方案数对PP取模后的值首先把坏点和终点以xx坐标为第一键值，yy坐标为第二键值排序 令fif_i表示从原点不经过任何坏点走到第ii个点的个数，那么有DP方程： fi=Cxixi+yi−∑xj<=xi,yj<=yiC(xi−xj)(xi−xj)+(yi−yj)∗fjf_i=C_{x_i+y_i}^{x_i}-\sum_{x_
codeforces F. Decreasing Heights
忘梦心的博客
05-19 332
题目 题意： 给你一个n∗mn*mn∗m的矩阵，现在你可以从0,00,00,0开始走，每一次的高度都可以比之前的+1or−1+1or-1+1or−1也就是0,0−>1,10,0->1,10,0−>1,1可以是2−>1or2−>32->1or2->32−>1or2−>3，可能高度和可以走的高度不一样，那么你可以将原先的高度增加/减少，问需要改变的高度总量最少是多少。 思路： 我们从0,00,00,0开始走，对于每一个i,ji,ji,j我们设需要改变的高度.
重做 poj 2195（KM算法）
sdjzujxc的专栏
02-22 405
//KM算法求解最小权，二分最优匹配 #include #include #include #include #include using namespace std; #define INF 99999999 #define maxn 105 char str[maxn][maxn];//存输入的字符数组 int lx[maxn],ly[maxn];//顶标 int x
迷宫问题(解救小哈)
qq_45845001的博客
11-03 1235
文章目录解救小哈完整代码读入数据输出数据总结 解救小哈 迷宫由n行m列的单元格组成(n和m都<=50)，每个单元格要么是空地要么是障碍物。小哼要以最快的速度解救小哈，帮助小哼找到一条从迷宫起点通往小哈所在位置的最短路径。注：障碍物不能走，也不能走到迷宫之外。 首先我们可以用一个二维数组来储存这个迷宫，刚开始的时候，小哼处于迷宫的入口处(1,1)，小哈在(p,q)。就是找从(1,1)到(p,q)的最短路径。小哼一开始在(1,1)他只能往右或者往下走。先让小哼往右边走，直到走不通了再回到这里，然后再.
搜索——迷宫问题
vina的博客
07-22 477
问题 X: 迷宫问题 时间限制: 1 Sec  内存限制: 128 MB 提交: 53  解决: 21 [提交][状态][讨论版][命题人:quanxing] 题目描述 定义一个二维数组： int maze[5][5] = { 0,1,0,0,0, 0,1,0,1,0, 0,0,0,0,0, 0,1,1,1,0, 0,0,0,1,0, }; 它表示一个迷宫，其中的1表示墙壁，...
第六章 最短路径
jasschow的专栏
06-12 3759
最短路径问题
C语言数据结构：第4章-串的存储与运算
在C语言版的数据结构课程中，第四章专门探讨了串（String）这一主题，它是计算机科学中非数值处理的重要组成部分。串作为一种特殊的线性表，其数据元素始终是字符型的，常用于表示文本信息，如汇编程序中的源代码、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值