搜索算法之深度优先算法

概述

Depth First Search------一条路走到黑

栗一：扑克牌的放法

       编号为1-3的三张扑克牌和编号为1-3的盒子，一个盒子放一张牌，一共有多少种放法。

栗二：员工重要性

给定一个保存员工信息的数据结构，它包含了员工唯一的id，重要度 和 直系下属的id。现在输入一个公司的所有员工信息，以及单个员工id，返回这个员工和他所有下属的重要度之和。
示例 1:

输入: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
输出: 11
解释:
员工1自身的重要度是5，他有两个直系下属2和3，而且2和3的重要度均为3。因此员工1的总重要度是 5 + 3 + 3 = 11。
DFS(id) { 1.获取当前id对应的重要度 2.累加所有直接下属的重要度 for()：累加DFS(subid) for循环就是终止条件，如果没有下属就停止了，返回当前累加的值 }

/*
// Employee info
class Employee {
public:
    // It's the unique ID of each node.
    // unique id of this employee
    int id;
    // the importance value of this employee
    int importance;
    // the id of direct subordinates
    vector<int> subordinates;
};
*/
class Solution {
public:
    int DFS(int id, unordered_map<int, Employee*>& info)
    {
        int ret = info[id]->importance;
        for(int subid : info[id]->subordinates)
        {
            ret += DFS(subid,info)
        }
        return ret;
    }
    int getImportance(vector<Employee*> employees, int id) {
        if(employees.empty())
            return 0;
        unordered_map<int, Employee*> info;
        for(auto e : employee)
        {
            info[e->id] = e;
        }
        return DFS(id,info);
    }
};

栗3.图像渲染

有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

示例 1:

输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。

来源：力扣
DFS(int x, int y) { 1.修改(x,y)颜色 2.搜索上下左右是否有相同颜色 { DFS(上下左右)，每个点只需要修改一次 } }

static int nextP[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
class Solution {
public:
    void DFS(vector<vector<int>>& image, int row, int col, int x, int y, int newColor, int oldColor, vector<vector<int>>& book)
    {
        image[x][y] = newColor;
        book[x][y] = 1;
        for(int i = 0; i<4; i++)
        {
            int nx = x+nextP[i][0];
            int ny = y+nextP[i][1];
            if(nx >= row || nx<0 || ny>=col || ny<0)
                continue;
            if(image[nx][ny] == oldColor && book[nx][ny] == 0)
            {
                DFS(image,row,col,nx,ny,newColor,oldColor,book);
            }
        }
    }
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        if(image.empty())
            return image;
        int row = image.size();
        int col = image[0].size();
        vector<vector<int>> book(row,vector<int>(col,0));
        int oldColor = image[sr][sc];
        DFS(image, row, col, sr, sc, newColor, oldColor, book);
        return image;
    }
};

栗4. 被X包围的O

把被包围的O变为X，全包围。
示例:

X X X X
X O O X
X X O X
X O X X

运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

来源：力扣
先把跟边缘O连通的O（找到了就做标记，比如改为A），再搜索数组，找到刚才没有找到的O，将之变为X，遇到A将之改为O
DFS(int x,int y) { 1.标记（x，y）：和边连通的'O' 2.搜索上下左右 { 如果为'O'，则为和边连通的 } }

static int nextP[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
class Solution {
public:
    void DFS(vector<vector<char>>& board,int row, int col, int x, int y)
    {
        board[x][y] = 'A';
        for(int i = 0; i<4; ++i)
        {
            int nx = x+nextP[i][0];
            int ny = y+nextP[i][1];
            if(nx>=row || nx<0 || ny >= col || ny<0)
                continue;
            if(board[nx][ny] == 'O')
                DFS(board,row,col,nx,ny);
        }
    }
    void solve(vector<vector<char>>& board) {
        if(board.empty())
            return;
        int row=board.size();
        int col = board[0].size();
        //第一列，最后一列
        for(int i = 0; i< row; ++i)
        {
                if(board[i][0] == 'O')
                    DFS(board,row,col,i,0);
                if(board[i][col-1] == 'O')
                    DFS(board,row,col,i,col-1);        
        }
         //第一行，最后一行
         for(int i = 0; i< col; ++i)
        {
                if(board[0][i] == 'O')
                    DFS(board,row,col,0,i);
                if(board[row-1][i] == 'O')
                    DFS(board,row,col,row-1,i);        
        }
        for(int i = 0; i<row; i++)
        {
            for(int j = 0; j<col; j++)
            {
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                if(board[i][j] == 'A')
                    board[i][j] = 'O';
            }
        }
    }
};