leetcode 675. Cut Off Trees for Golf Event

675. Cut Off Trees for Golf Event

You are asked to cut off trees in a forest for a golf event. The forest is represented as a non-negative 2D map, in this map:

1. 0 represents the obstacle can't be reached.
2. 1 represents the ground can be walked through.
3. The place with number bigger than 1 represents a tree can be walked through, and this positive number represents the tree's height.

You are asked to cut off all the trees in this forest in the order of tree's height - always cut off the tree with lowest height first. And after cutting, the original place has the tree will become a grass (value 1). 

You will start from the point (0, 0) and you should output the minimum steps you need to walk to cut off all the trees. If you can't cut off all the trees, output -1 in that situation.

You are guaranteed that no two trees have the same height and there is at least one tree needs to be cut off.

Example 1:

Input: 
[
 [1,2,3],
 [0,0,4],
 [7,6,5]
]
Output: 6

Example 2:

Input: 
[
 [1,2,3],
 [0,0,0],
 [7,6,5]
]
Output: -1

Example 3:

Input: 
[
 [2,3,4],
 [0,0,5],
 [8,7,6]
]
Output: 6
Explanation: You started from the point (0,0) and you can cut off the tree in (0,0) directly without walking.

Hint: size of the given matrix will not exceed 50x50.

题目：从(0, 0)点开始按照2到大开始踩点，最少走多少步踩完。

方法一：map存需要踩的点的位置顺序，然后从每个点开始BFS算步数累计。

TLE。

class Solution {
public:
    int cutOffTree(vector<vector<int>>& forest)
    {
        row = forest.size();
        col = forest[0].size();
        map<int, pair<int, int>> point;
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (forest[i][j] > 1)
                    point[forest[i][j]] = make_pair(i, j);
            }
        }
        
        int ret = 0;
        pair<int, int> now_pos = make_pair(0, 0);
        
        for (auto it = point.begin(); it != point.end(); it ++)
        {
            int distance = get_distance(now_pos, forest, it->second.first, it->second.second);
            if (distance == -1) return -1;
            ret += distance;
            //cout<<"ret now is "<<ret<<endl<<endl;
        }
        return ret;
    }
private:
    int row;
    int col;
    int get_distance(pair<int, int>& now_pos, vector<vector<int>>& forest, int targetX, int targetY)
    {
        int a[4] = {0, 1, 0, -1};
        int b[4] = {1, 0, -1, 0};
        queue<pair<int, int> > que;
        que.push(now_pos);
        set<int> hash;
        hash.insert(now_pos.first * col + now_pos.second);  //hash表记录走过的路
        now_pos.first = targetX;    //目标位置变成下一次的起始位置
        now_pos.second = targetY;
        
        int ret = 0;
        while (!que.empty())
        {
            int size = que.size();
            for (int i = 0; i < size; i++)
            {
                int x = que.front().first, y = que.front().second;
                //cout<<x<<"-"<<y<<" ";
                que.pop();
                if ( x == targetX && y == targetY ) return ret;
                for (int j = 0; j < 4; j++)
                {
                    int _x = x + a[j], _y = y + b[j];
                    if ( isvaild(_x, _y) && forest[_x][_y] != 0 && hash.find(_x * col + _y) == hash.end())
                    {
                        que.push(make_pair(_x, _y));
                        hash.insert(_x * col + _y);
                    }
                }
            }
            //cout<<endl;
            ret ++;
        }
        return -1;
    }
    
    bool isvaild(int x, int y)
    {
        return x >= 0 && x < row && y >= 0 && y < col;
    }
};

然后我就找了很久到底什么比较慢！！

最后发现是BFS里面的hash表之前用的set查找，结果慢的一笔！

改为用二维数组来记录，空间换时间！！！

class Solution {
public:
    int cutOffTree(vector<vector<int>>& forest)
    {
        row = forest.size();
        col = forest[0].size();
        map<int, pair<int, int>> point;
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (forest[i][j] > 1)
                    point[forest[i][j]] = make_pair(i, j);
            }
        }
        
        int ret = 0;
        int startX = 0, startY = 0;
        
        for (auto it = point.begin(); it != point.end(); it ++)
        {
            queue<pair<int, int> > que;
            que.push(make_pair(startX, startY));
            vector<vector<bool>> hash(row, vector<bool> (col, false));
            hash[startX][startY] = true;  //hash表记录走过的路
            int targetX = it->second.first, targetY = it->second.second;
            
            startX = targetX;    //目标位置变成下一次的起始位置
            startY = targetY;
            bool hasfind = false;
            int distance = 0;
            while (!que.empty())
            {
                int size = que.size();
                for (int i = 0; i < size; i++)
                {
                    int x = que.front().first, y = que.front().second;
                    //cout<<x<<"-"<<y<<" ";
                    que.pop();
                    if ( x == targetX && y == targetY )
                    {
                        hasfind = true;
                        break;
                    }
                    for (int j = 0; j < 4; j++)
                    {
                        int _x = x + a[j], _y = y + b[j];
                        if ( isvaild(_x, _y) && forest[_x][_y] != 0 && !hash[_x][_y])
                        {
                            que.push(make_pair(_x, _y));
                            hash[_x][_y] = true;
                        }
                    }
                }
                if (hasfind)
                    break;
                distance ++;
            }
            if (!hasfind)   return -1;
            ret += distance;
            hasfind = false;
            //cout<<"ret now is "<<ret<<endl<<endl;
        }
        return ret;
    }
private:
    int a[4] = {0, 1, 0, -1};
    int b[4] = {1, 0, -1, 0};
    int row;
    int col;
    bool isvaild(int x, int y)
    {
        return x >= 0 && x < row && y >= 0 && y < col;
    }
};