Leetcode新手学习之路--DFS

【210题】课程表 II

class Solution {
public:
    void dfs(int i)
    {
        if (visite[i] == 2) {
            return;
        }
        if (visite[i] == 1) { // 有环
            invalid = true;
            return;
        }
        visite[i] = 1;
        if (depCourses.find(i) != depCourses.end()) {
            for (auto it : depCourses[i]) {
                dfs(it);
            }
        }
        visite[i] = 2;
        result.push_back(i);
    }

    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        visite.resize(numCourses, 0);
        for (auto const &course : prerequisites) {
            depCourses[course[0]].push_back(course[1]);
        }
        for (int i = 0; i < numCourses; i++) {
            if (visite[i] == 0) {
                dfs(i);
            }
            if (invalid) {
                break;
            }
        }
        if (invalid) {
            return {};
        }
        return result;
    }

private:
    unordered_map<int, vector<int>> depCourses;
    vector<int> visite; // 0--未遍历，1--正在遍历，2--已遍历
    vector<int> result;
    bool invalid;
};

934. 最短的桥 思路
     leecode 岛屿问题模板几乎只要和二维数组+dfs联系，几乎一定会用到
     代码块1 代码块3 经典dfs
     重点是代码块2的bfs。
     来自网上一些大神的 bfs岛屿问题模板，直接套用即可。
     bfs遍历上下左右，用dfs模板中的四次判断太麻烦了。直接用题中int r = dirR[d] + f.first;int c = dirC[d] + f.second;
     确定x,y坐标即可。

typedef struct {
    int r;
    int c;
} Pos;

class Solution {
public:
    // 代码块1
    int shortestBridge(vector<vector<int>>& A) {
        list<Pos> lst;
        int R = A.size();
        int L = A[0].size();
        bool isMerged = false;
        // dfs寻找第一个岛屿，并把1全部赋值为2
        for (int i = 0; i < R; i++) {
            if (isMerged) {
                break;
            }
            for (int j = 0; j < L; j++) {
                if (A[i][j] == 1) {
                    dfs(i, j, A, lst);
                    isMerged = true;
                    break;
                }
            }
        }

        //代码块2, 开始在第一个岛屿bfs
        int step = 0;
        int row[4] = {-1, 1, 0, 0};
        int colum[4] = {0, 0, -1, 1};
        while (!lst.empty()) {
            int nums = lst.size();
            for (int k = 0; k < nums; k++) {
                Pos pos = lst.front();
                lst.pop_front();
                for (int t = 0; t < 4; t++) {
                    int tmph = pos.r + row[t];
                    int tmpl = pos.c + colum[t];
                    if (tmph < 0 || tmph >= R || tmpl < 0 || tmpl >= L) {
                        continue;
                    }
                    if (A[tmph][tmpl] == 1) {
                        return step;
                    } else if (A[tmph][tmpl] == 2) {
                        continue;
                    } else if (A[tmph][tmpl] == 0) {
                        Pos tmp = {tmph, tmpl};
                        lst.push_back(tmp);
                        A[tmph][tmpl] = 2;
                    }
                }
            }
            step++;
        }
        return step;
    }

    // 代码块3
    void dfs(int i, int j, vector<vector<int>>& A, list<Pos>& lst)
    {
        //cout << i << " " << j << endl;
        Pos pos = {i, j};
        lst.push_back(pos);
        A[i][j] = 2;
        int row[4] = {-1, 1, 0, 0};
        int colum[4] = {0, 0, -1, 1};
        for (int k = 0; k < 4; k++) {
            int h = i + row[k];
            int l = j + colum[k];
            if (h < 0 || h >= A.size() || l < 0 || l >= A[0].size()) {
                continue;
            }
            if (A[h][l] == 1) {
                dfs(h, l, A, lst);
            } else if (A[h][l] == 0) {
                continue;
            }
        }
    }
};

531. 孤独像素 I 解法

class Solution {
public:
    void dfs(int i, int j, vector<vector<char>>& picture, vector<vector<int>>& visit)
    {
        visit[i][j] = 1;
        for (int t = 0; t < picture.size(); t++) {
            if (visit[t][j] == 1) {
                continue;
            }
            visit[t][j] = 1;
            if (picture[t][j] == 'W') {
                continue;
            } else {
                dfs(t, j, picture, visit);
                picture[i][j] = 'S';
                picture[t][j] = 'S';
            }
        }

        for (int t = 0; t < picture[0].size(); t++) {
            if (visit[i][t] == 1) {
                continue;
            }
            visit[i][t] = 1;
            if (picture[i][t] == 'W') {
                continue;
            } else {
                dfs(i, t, picture, visit);
                picture[i][j] = 'S';
                picture[i][t] = 'S';
            }
        }
    }

    int findLonelyPixel(vector<vector<char>>& picture) {
        int R = picture.size();
        int L = picture[0].size();
        vector<int> tmp(L, 0);
        vector<vector<int>> visit(R, tmp);
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < L; j++) {
                if (picture[i][j] == 'B') {
                    dfs(i, j, picture, visit);
                }
            }
        }
        int count = 0;
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < L; j++) {
                if (picture[i][j] == 'B') {
                    count++;
                }
            }
        }
        return count;
    }
};

332. 重新安排行程

typedef struct {
    string s;
    bool isUsed;
} MyStruct;

class Solution {
public:
    static bool Cmp(MyStruct a, MyStruct b)
    {
        return (a.s < b.s);
    }

    void MySort(vector<MyStruct>& s)
    {
        sort(s.begin(), s.end(), Cmp);
    }

    int dfscnt = 0;
    void dfs(string from, unordered_map<string, vector<MyStruct>>& mp, int& cnt, int aimCnt, vector<string>& output)
    {
        cnt++;
        //printf("dfscnt=%d, from=%s\n", dfscnt++, from.c_str());
        output.push_back(from);
        if (cnt == aimCnt) {
            return;
        }
        for (auto it = mp[from].begin(); it != mp[from].end(); it++) {
            //cout << "it.s=" << it->s << endl;
            if (it->isUsed) {
                continue;
            }
            it->isUsed = true;
            dfs(it->s, mp, cnt, aimCnt, output);
            if (cnt != aimCnt) {
                cnt--;
                it->isUsed = false;
                output.pop_back();
            } else {
            	break;
            }
        }
    }

    vector<string> findItinerary(vector<vector<string>>& tickets) {
        if (tickets.size() == 0) {
            return {};
        }
        vector<string> output;
        unordered_map<string, vector<MyStruct>> mp;
        for (int i = 0; i < tickets.size(); i++) {
            MyStruct it = {tickets[i][1], false};
            mp[tickets[i][0]].push_back(it);
        }
        
        for (auto& it : mp) {
            if (it.second.size() > 1) {
                MySort(it.second);
                //cout << "\n" << it.first << ": ";
                for (auto ii : it.second) {
                    //cout << ii.s << " ";
                }
            }
        }
        int aimCnt = tickets.size() + 1;
        int cnt = 0;
        //cout << endl;
        dfs("JFK", mp, cnt, aimCnt, output);

        return output;
    }
};

695. 岛屿的最大面积

#define DIRS 4

class Solution {
public:
    void dfs(int i, int j, vector<vector<int>>& grid, vector<vector<int>>& visit, int& cnt, int& maxnum)
    {
        visit[i][j] = 1;
        int R = grid.size();
        int L = grid[0].size();
        int row[DIRS] = {-1, 1, 0, 0};
        int col[DIRS] = {0, 0, -1, 1};
        for (int k = 0; k < DIRS; k++) {
            int x = i + row[k];
            int y = j + col[k];
            if (x < 0 || x >= R || y < 0 || y >= L) {
                continue;
            }
            if (visit[x][y] == 1) {
                continue;
            }
            if (grid[x][y] == 1) {
                cnt++;
                dfs(x, y, grid, visit, cnt, maxnum);
            }
        }
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int maxnum = 0;
        int R = grid.size();
        if (R == 0) {
            return 0;
        }
        int L = grid[0].size();
        vector<vector<int>> visit(R, vector<int>(L, 0));
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < L; j++) {
                if (grid[i][j] == 1 && visit[i][j] == 0) {
                    int cnt = 1;
                    dfs(i, j, grid, visit, cnt, maxnum);
                    maxnum = std::max(cnt, maxnum);
                }
            }
        }
        return maxnum;
    }
};