CodeForces - 598D Igor In the Museum （存储搜索结果）

Igor is in the museum and he wants to see as many pictures as possible.

Museum can be represented as a rectangular field of n × m cells. Each cell is either empty or impassable. Empty cells are marked with ‘.’, impassable cells are marked with ‘*’. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture.

At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one.

For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see.

Input
First line of the input contains three integers n, m and k (3 ≤ n, m ≤ 1000, 1 ≤ k ≤ min(n·m, 100 000)) — the museum dimensions and the number of starting positions to process.

Each of the next n lines contains m symbols ‘.’, ‘*’ — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can’t go out from the museum.

Each of the last k lines contains two integers x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) — the row and the column of one of Igor’s starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells.

Output
Print k integers — the maximum number of pictures, that Igor can see if he starts in corresponding position.
//输入输出打进编辑器会有问题，不贴了（卧槽我写备注怎么下意识打了两斜杠）

题目大意：进博物馆看画，博物馆分为一个个连通的单独空间，用“.”标记，还有用“*”标记的墙壁，墙的每一面都有画，问每个空间能看到几幅画。题目明确表示博物馆四周全是墙（那你是怎么进来的….），所以不用判范围。

寒假集训第一次模拟比赛打的题。当时样例很轻易就过了，但是….疯狂死于超时。回头再做这题，按照当时的思路重新打了个深搜（当时是打的宽搜），果不其然超时了，然后测试了一下，跟我想的一样，这题对于博物馆内的每一个空间，只能进行一次搜索，第二次进入这个空间就必须在O(1)的时间复杂度内求出结果。
由于每个空间里的任一点返回的结果都一样，对结果进行存储就好啦！一开始想到的是并查集那个思路，把空间内的每个点归为同一个集合，然后每次查找那个集合的数据。
后来想想那么麻烦干嘛，map存完事。。。于是搜索后把每个隔间都改成字母a、b、c，然后通过map来查询。还是怕超时，加了个io流模板，用上bufferedReader抢时间，妥妥ac。

AC代码：

public class Main {
    static int res;
    static char[][] field;
    static char type = 'a';
    static int[][] operate = { { 0, -1 }, { 0, 1 }, { -1, 0 }, { 1, 0 } };

    public static void main(String[] args) {
        InputReader reader = new InputReader();
        int n = reader.nextInt();
        int m = reader.nextInt();
        int k = reader.nextInt();
        field = new char[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            String get = reader.next();
            for (int j = 1; j <= m; j++) {
                field[i][j] = get.charAt(j - 1);
            }
        }
        HashMap<Character, Integer> storage = new HashMap<Character, Integer>();
        while (k-- > 0) {
            int x = reader.nextInt();
            int y = reader.nextInt();
            res = 0;
            if (field[x][y] == '.') {
                dfs(x, y);
                storage.put(type, res);
                type++;
                System.out.println(res);
            } else {
                System.out.println(storage.get(field[x][y]));
            }
        }
    }

    public static void dfs(int x, int y) {
        field[x][y] = type;
        for (int i = 0; i < 4; i++) {
            int nextX = x + operate[i][0];
            int nextY = y + operate[i][1];
            switch (field[nextX][nextY]) {
            case '.':
                dfs(nextX, nextY);
                break;
            case '*':
                res++;
                break;
            default:
                break;
            }
        }
    }
}

class InputReader {
    BufferedReader buf;
    StringTokenizer tok;

    InputReader() {
        buf = new BufferedReader(new InputStreamReader(System.in));
    }

    boolean hasNext() {
        while (tok == null || !tok.hasMoreElements()) {
            try {
                tok = new StringTokenizer(buf.readLine());
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    String next() {
        if (hasNext())
            return tok.nextToken();
        return null;
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    /*
     * BigInteger nextBigInteger() { return new BigInteger(next()); }
     * 
     * BigDecimal nextBigDecimal() { return new BigDecimal(next()); }
     */
}