789. 逃脱阻碍者

你在进行一个简化版的吃豆人游戏。你从 [0, 0] 点开始出发，你的目的地是 target = [xtarget, ytarget] 。地图上有一些阻碍者，以数组 ghosts 给出，第 i 个阻碍者从 ghosts[i] = [xi, yi] 出发。所有输入均为整数坐标 。

每一回合，你和阻碍者们可以同时向东，西，南，北四个方向移动，每次可以移动到距离原位置 1 个单位 的新位置。当然，也可以选择不动 。所有动作同时发生。

如果你可以在任何阻碍者抓住你之前到达目的地（阻碍者可以采取任意行动方式），则被视为逃脱成功。如果你和阻碍者同时到达了一个位置（包括目的地）都不算是逃脱成功。

只有在你有可能成功逃脱时，输出true；否则，输出false。

 
示例 1：

输入：ghosts = [[1,0],[0,3]], target = [0,1]
输出：true
解释：你可以直接一步到达目的地 (0,1) ，在 (1, 0) 或者 (0, 3) 位置的阻碍者都不可能抓住你。 

示例 2：

输入：ghosts = [[1,0]], target = [2,0]
输出：false
解释：你需要走到位于 (2, 0) 的目的地，但是在 (1, 0) 的阻碍者位于你和目的地之间。 

示例 3：

输入：ghosts = [[2,0]], target = [1,0]
输出：false
解释：阻碍者可以和你同时达到目的地。 

示例 4：

输入：ghosts = [[5,0],[-10,-2],[0,-5],[-2,-2],[-7,1]], target = [7,7]
输出：false

示例 5：

输入：ghosts = [[-1,0],[0,1],[-1,0],[0,1],[-1,0]], target = [0,0]
输出：true
 

提示：

1 <= ghosts.length <= 100
ghosts[i].length == 2
-10^4 <= xi, yi <= 10^4
同一位置可能有多个阻碍者 。
target.length == 2
-10^4 <= xtarget, ytarget <= 10^4

思路：

1.注意题目中的条件：所有动作同时发生。我们可以让阻碍者和主人公同时走，注意本题中虽然说每个人都可以选择四个方向走一步或者压根不走，但是对于阻碍者来说，走的越多越可能拦住主人公，同理对于主人公来说，走的越多越可能不被拦住，因此本题压根不需要考虑不走的情况。

我们让阻碍者首先BFS，等所有的阻碍者走完当前可以阻碍的点后，再让主人公BFS。如果某一个状态中(所有人都走第n步)，主人公没有办法走到第n步，表明主人公无法逃脱。对应状态为队列中不存在主人公的状态。

若主人公可以到达终点，则表明可以逃脱。

[注]：主人公已经到达的点对于阻碍者来说也是不可访问的点，因为如果阻碍者是后来的，那么基于BFS的步骤以及我们让阻碍者先走的特点，主人公一定至少比这个阻碍者多走一步，阻碍者追不上主人公。

class Solution {
public:

    struct Point
    {
        int coordX, coordY;
        bool isHinder;
    };

    int dir[4][2] = 
    {
        {0, 1},
        {0, -1},
        {1, 0},
        {-1, 0}
    };

    const int offset = 1e4;

    bool visited[20001][20001];

//可以让阻碍者先走 如果当前这一步不剩下可以让主人公走的点，或者说阻碍者先到了目标点 就失败 不必考虑阻碍者不动  按照贪心博弈的思想，两边按都应该尽可能地多动 才能走出去
// permittedCounts 表示现在在队列里的你的可允许点数
    bool escapeGhosts(vector<vector<int>>& ghosts, vector<int>& target)
    {
        int nGhostNum = ghosts.size(), nTargetX = target[0] + offset, nTargetY = target[1] + offset, nIndex, nX, newX, nY, newY, permittedCounts = 1, maxX = 0, maxY = 0;
        bool bIsHinder;
        queue<Point> que;
        memset(visited, 0, sizeof(visited));
        for(nIndex = 0; nIndex < nGhostNum; ++ nIndex) 
        {
            nX = ghosts[nIndex][0] + offset, nY = ghosts[nIndex][1] + offset;
            maxX = max(nX, maxX);
            maxY = max(nY, maxY);
            que.push(Point{nX, nY, true});
            visited[nX][nY] = true;
        }
        que.push(Point{offset, offset, false});
        visited[offset][offset] = true;
        Point point;
        while(!que.empty()) 
        {
            if(permittedCounts == 0)
            {
                return false;
            }

            point = que.front();
            que.pop();

            if(bIsHinder)
            {
                -- permittedCounts;
            }

            nX = point.coordX, nY = point.coordY, bIsHinder = point.isHinder;

            cout << nX << " " << nY << endl;

            if(nX == nTargetX && nY == nTargetY)
            {
                return bIsHinder ? false : true;
            }

            for(nIndex = 0; nIndex < 4; ++ nIndex)
            {
                newX = nX + dir[nIndex][0];
                newY = nY + dir[nIndex][1];
                if(newX >= 0 && newX <= maxX && newY >= 0 && newY <= maxY && !visited[newX][newY])
                {
                    visited[newX][newY] = true;
                    que.push(Point{newX, newY, bIsHinder});
                    if(bIsHinder)
                    {
                        ++ permittedCounts;
                    }
                }
            }

        }
        return false;
    }

};

2.实际上，我们从一个点出发，能够走k步到达的点集合构成了菱形边界。另外，我们可以让所有的阻碍者直接向终点走，这是因为阻碍者和主人公同时到达也算逃脱失败。所以如果主人公不能比阻碍者先到终点就一定失败，因此我们可以直接求解欧式距离。

如果存在一个阻碍者到达终点的欧式距离<=主人公，则主人公无法逃脱，否则一定可以逃脱。

class Solution {
public:

    bool escapeGhosts(vector<vector<int>>& ghosts, vector<int>& target) {
        int maxDis = 0, n = ghosts.size(), targetX = target[0], targetY = target[1];
        for(int i = 0; i < n; ++ i) {
            if(!i) {
                maxDis = abs(ghosts[i][0] - targetX) + abs(ghosts[i][1] - targetY);
            }else {
                maxDis = min(maxDis, abs(ghosts[i][0] - targetX) + abs(ghosts[i][1] - targetY));
            }
        }
        return maxDis > abs(targetX) + abs(targetY);
    }

};