IEEEXtreme 10.0

Xtreme 10.0 - Mysterious Maze

题目来源第10届IEEE极限编程大赛

https://www.hackerrank.com/contests/ieeextreme-challenges/challenges/mysterious-maze

There is a valuable treasure that is hidden below a complex maze. The maze is made of rooms and are square in shape, and a maze of size N will have N × N rooms with all of them closed initially. When a room is open, one can enter into it from any of its adjacent open rooms; two rooms are adjacent if they share a common wall.

The maze was built in a way that it opens itself by opening its rooms randomly. A maze is said to be open if there is at least one path from any one of the rooms facing the top of the maze to any room on the bottom side facing the treasure. Anyone, who attempts to enter the maze without being able to reach the treasure and return, will be cruelly killed by the maze.

The local government has spent years researching the maze and figured out a way to determine the sequence of rooms being opened in almost real time. Based on this data, the government has posed the following challenge, with a small percentage of the treasure to whomever solves the problem:

Given the sequence of room openings, determine when the maze becomes open, or if it remains closed throughout.

Input Format

Input begins with a single integer N, which denotes the size of maze.

All of the next lines (except the last one) denotes the sequence of the rooms the maze is opening. Each line contains 2 integers X and Y which denotes the row and column of the room opened by the maze. The last line just includes -1 and marks the end of input.

Constraints

1 <= X, Y <= N <= 1000

Output Format

Output a single integer R based on the final status of the maze. R denotes the number of room openings that occur before the maze first becomes open, or -1 if the maze remains closed.

Sample Input

Sample Output

-1

Explanation

It is easy to understand if you plot the maze. The following is the state of the maze at the end of the inputs. Xindicates that a room is closed and O that a room is open. Note that there is no path from the top of the maze to the bottom of the maze.

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

Consider the second input sample (which is available if you click on the Run Code button):

Below is a figure with the maze after 7 rooms are open. Note that there is no path from the top of the maze to the bottom of the maze, and therefore the maze is closed.

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

However, after 8th room is open, there is a path, as shown below:

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

Thus, the expected output is:

题目解析

这个题目像是一个搜索题，从上侧出发看是否能够搜索到下侧。搜索一次需要O(M^2)。每开一次门，都需要搜索1次。复杂度就到了10^9，铁定会超时。

迷宫是否连通，有点像两个节点是否是1类。判断两个节点是否是1类，可以用并查集嘛。

每打开一个房间，就将上下左右的房间合并成1类，需要O(log(M))的时间。

上侧和下侧分别建立一个虚拟节点，初始与第1行的房间和最后1行的房间相连。

每打开一个房间，判断上侧虚拟节点是否与下侧虚拟节点节点是否属于同一类。如果属于同一类，迷宫则被打通了。

总的复杂度为O(Nlog(M))。

程序

C++

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int find(vector<int> &parent, int x) {
    int px;
    if(parent[x] < 0) {
        px = x;
    }
    else {
        px = find(parent, parent[x]);
        parent[x] = px;
    }
    return px;
}

void union_(vector<int> &parent, int x, int y) {
    int px = find(parent, x);
    int py = find(parent, y);
    
    if(px != py) {
        
        if(parent[px] < parent[py]) {
            parent[px] += parent[py];
            parent[py] = px;
        }
        else {
            parent[py] += parent[px];
            parent[px] = py;
        }
    }
}

bool legal(int x, int y, int H) {
    return (x >=1 && x <= H) && (y >= 1 && y <=H);
}

int pos2Index(int x, int y, int H) {
    return (x-1) * H + (y-1);
}

int main() {
    int H;
    cin >> H;
    vector<int> parent(H*H+2, -1);
    vector<vector<bool> > maze(H+2, vector<bool>(H+2, 0));
    
    for(int i=1; i<=H; i++) {
        union_(parent, pos2Index(1, i, H), H*H);
        union_(parent, pos2Index(H, i, H), H*H+1);
    }
    
    int dir[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    int count = 1;
    while(true) {
        int x, y;
        cin >> x;
        if(x == -1) {
            cout << -1 << endl;
            break;
        }
        cin >> y;
        maze[x][y] = true;
        for(int d=0; d<4; d++) {
            int nx = x + dir[d][0];
            int ny = y + dir[d][1];
            
            if(legal(nx, ny, H) && maze[nx][ny]) {
                union_(parent, pos2Index(x, y, H), pos2Index(nx, ny, H));
            }
        }
        if(find(parent, H*H) == find(parent, H*H+1)) {
            cout << count;
            break;
        }
        count++;
    }
    
    return 0;
}

博客中的文章均为 meelo 原创，请务必以链接形式注明本文地址

原文地址：https://www.cnblogs.com/meelo/p/6079168.html