[Leetcode] Breadth-first Search

Posted 2022-12-09 stary_yan

[Leetcode] Breadth-first Search

Description

Analysis

It is easy to understand the question. To be simple, we just need to reach the position in the graph in a specific order and calculate the minimal necessary steps. So, the difficult point is just to calculate the minimal steps between two points by using BFS. That is, we need to BFS many times, but don’t worry, it is OK.

Code

I have to mention that, whenever push a point into the queue, we have to set the visited of that point to true, which can save time.

class Solution 
public:
    int BFS(int n, int m, pair<int, int> &start, pair<int, int> &end, vector<vector<int>> &forest) 
        vector<vector<bool>> visited(n, vector<bool>(m, false));
        queue<pair<int, int>> node_queue;
        visited[start.first][start.second] = true;
        int step = 0;
        node_queue.push(start);
        int size = 0;
        while (!node_queue.empty()) 
            size = node_queue.size();
            while (size--) 
                start = node_queue.front();
                node_queue.pop();
                if (start == end)  return step; 
                if (start.first > 0 && !visited[start.first - 1][start.second] && forest[start.first - 1][start.second] != 0) 
                    node_queue.push(pair<int, int>(start.first - 1, start.second));
                    visited[start.first - 1][start.second] = true;
                
                if (start.first < n - 1 && !visited[start.first + 1][start.second] && forest[start.first + 1][start.second] != 0) 
                    node_queue.push(pair<int, int>(start.first + 1, start.second));
                    visited[start.first + 1][start.second] = true;
                
                if (start.second > 0 && !visited[start.first][start.second - 1] && forest[start.first][start.second - 1] != 0) 
                    node_queue.push(pair<int, int>(start.first, start.second - 1));
                    visited[start.first][start.second - 1] = true;
                
                if (start.second < m - 1 && !visited[start.first][start.second + 1] && forest[start.first][start.second + 1] != 0) 
                    node_queue.push(pair<int, int>(start.first, start.second + 1));
                    visited[start.first][start.second + 1] = true;
                
            
            step++;
        
        return -1;
    
    int cutOffTree(vector<vector<int>>& forest) 
        int n = forest.size();
        int m = forest[0].size();
        vector<int> orders;
        map<int, pair<int, int>> records;
        for (int i = 0; i < n; i++) 
            for (int j = 0; j < m; j++) 
                if (forest[i][j] != 0 && forest[i][j] != 1) 
                    orders.push_back(forest[i][j]);
                    records[forest[i][j]] = pair<int, int>(i, j);
                
            
        
        sort(orders.begin(), orders.end());
        pair<int, int> start(0, 0);
        int steps = 0;
        int tmp = 0;
        for (int i = 0; i < orders.size(); i++) 
            // cout << orders[i] << endl;
            tmp = BFS(n, m, start, records[orders[i]], forest);
            // cout << tmp << endl;
            if (tmp == -1) 
                return -1;
             else 
                steps += tmp;
                start = records[orders[i]];
            
        
        return steps;
    
;

Time Complexity: O(m^2 n^2)