CCF系列之I’m stuck!(201312-5)

试题名称： I’m stuck! 

时间限制： 1.0s 

内存限制： 256.0MB 

问题描述：　

问题描述

　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
　　'#': 任何时候玩家都不能移动到此方格；
　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
　　此外，玩家不能移动出地图。
　　请找出满足下面两个性质的方格个数：
　　1. 玩家可以从初始位置移动到此方格；
　　2. 玩家不可以从此方格移动到目标位置。

输入格式

　　输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。
　　接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个'S'和一个'T'。

输出格式

　　如果玩家在初始位置就已经不能到达终点了，就输出“I'm stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。

样例输入

5 5
--+-+
..|#.
..|##
S-+-T
####.

样例输出

2

样例说明

　　如果把满足性质的方格在地图上用'X'标记出来的话，地图如下所示：
　　--+-+
　　..|#X
　　..|##
　　S-+-T
　　####X

　

解题思路:　

　　　　1、深度遍历，选择队列。

　　　　2、方向和图形符号相互对应。

　　

　　　　

根据标准代码分析（java）：

　　

package ccf_text2013_12;

import java.util.*;
/**
 * I'm stuck!
 * 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
　　'#': 任何时候玩家都不能移动到此方格；
　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
　　此外，玩家不能移动出地图。
　　请找出满足下面两个性质的方格个数：
　　1. 玩家可以从初始位置移动到此方格；
　　2. 玩家不可以从此方格移动到目标位置。
 * @author Hello stranger
 *
 */
public class ImStuck2 {
    
    public static void main(String[] args) {
        
        new ImStuck2().run();
    }

    public void run() {
        
        Scanner fin = new Scanner(System.in);
        
        int R = fin.nextInt();
        
        int C = fin.nextInt();            //判断图形的行和列
        
        String first = fin.nextLine();   //跳过输入的换行（输入行列之后会打一个换行）
        
        //System.out.println(first);
        
        int[][] board = new int[R + 2][C + 2];
        
        char[][] picture = new char[R][C];  //为了验证计算出的结果是否在图形上显示正确
        
        int rowStart = 0, colStart = 0, rowEnd = 0, colEnd = 0;  //起点和终点所在的行列
        
        for (int i = 1; i <= R; ++i) {    
            
            //读取输入的图形标志，并将图形标志转化为数字标示并保存在数组中,关键在于这些数字
            /**
             *   #   ===   0
             *   -   ===   5
             *   |   ===   0xA   == 10
             *   +   ===   0xF   == 15
             *   S   ===   0xF   == 15
             *   T   ===   0xF   == 15
             *   .   ===   0x8   == 8
             *   
             */
            String line = fin.nextLine();
            
            for (int j = 1; j <= C; ++j) {
                
                char c = line.charAt(j - 1);
                
                picture[i-1][j-1] = c;
                
                switch (c) {
                
                case '#':
                    
                    break;    
                    
                case '-':
                    
                    board[i][j] = 5;
                    
                    break;
                    
                case '|':
                    
                    board[i][j] = 0xA;
                    
                    break;
                    
                case '+':
                    
                case 'S':
                    
                case 'T':
                    
                    board[i][j] = 0xF;
                    
                    break;
                    
                case '.':
                    
                    board[i][j] = 0x8;
                    
                    break;
                    
                default:
                    
                    break;
                    
                }
                if (c == 'S') {
                    
                    rowStart = i;
                    
                    colStart = j;                //起点所在的行列
                    
                } else if (c == 'T') {
                    
                    rowEnd = i;
                    
                    colEnd = j;                    //终点所在的行列
                }
            }
        }
        System.out.println("用户输入的图形为：");
        printCharArray(picture);
        printNumArray(board);
        int[] dr = new int[] { 0, -1, 0, 1 };              //行数  同行、上一行（向上）、 同行、 下一行（向下）
        
        int[] dc = new int[] { 1, 0, -1, 0 };               //列数 下一列（向右）、 同列、上一列（向左）、同列
        
        
        // Scan 1: find all cells which can reach T
        
        boolean[][] visited = new boolean[R + 2][C + 2];      //默认均为false
                
        boolean[][] canReachT = new boolean[R + 2][C + 2];    //默认均为false
        
        initVisited(visited);                                //数组边框为true，中间为false
        
        canReachT[rowEnd][colEnd] = true;
        
        visited[rowEnd][colEnd] = true;                        //重点的值设为true
        
        Queue<Integer> queue = new LinkedList<Integer>();
        
        queue.add(rowEnd);
        
        queue.add(colEnd);                    //队列有一个特点就是先进先出，这样就可以采用深度优先遍历
        
        
        while (!queue.isEmpty()) {
            
            int r = queue.remove();
            
            int c = queue.remove();
            
            for (int i = 0; i < 4; ++i) {
                
                int nr = r + dr[i];
                
                int nc = c + dc[i];        //判断顺序是 向右，向下，向左，向上(四个方向)
                
                if (visited[nr][nc])    //边框+已经判定可以到达终点的点
                    
                    continue;
                
                if ((board[nr][nc] & (1 << ((i + 2) % 4))) != 0) {  
                    
                    /**
                     *   方向                        右    下    左    上
                     *      i                             0    1    2    3
                     *      t = (i + 2) % 4             2    3    0    1    
                     *      x = 1 << t                     4    8    1    2     
                     *   #   ===   0x0   ==  0    & x  0    0    0    0    
                     *   -   ===   0x5   ==  5    & x  4    0    1    0
                     *   |   ===   0xA   == 10    & x  0    8    0    2
                     *   +   ===   0xF   == 15    & x  4    8    1    2
                     *   S   ===   0xF   == 15    & x  4    8    1    2
                     *   T   ===   0xF   == 15    & x  4    8    1    2
                     *   .   ===   0x8   ==  8    & x  0    8    0    0
                     *   
                     */
                    
                    //将上下左右和数字表示的图标对应起来，如果在这个方向可以走的话，就执行if语句
                    
                    canReachT[nr][nc] = true;   //这个数组里面值为false的即为玩家不可以从此方格移动到目标位置。
                    
                    queue.add(nr);
                    
                    queue.add(nc);
                    
                    visited[nr][nc] = true;
                }
            }
        }
        
        printBealoonArray(visited);
    
        if (!canReachT[rowStart][colStart]) {
            
            System.out.println("I'm stuck!");
            
            return;
        }
        // Scan 2: get result  同理
        
        boolean[][] rCanReach = new boolean[R + 2][C + 2];
        
        initVisited(visited);
        
        queue.clear();
        
        visited[rowStart][colStart] = true;
        
        rCanReach[rowStart][colStart] = true;
        
        queue.add(rowStart);
        
        queue.add(colStart);
        
        while (!queue.isEmpty()) {
            
            int r = queue.remove();
            
            int c = queue.remove();
            
            for (int i = 0; i < 4; ++i) {
                
                if ((board[r][c] & (1 << i)) == 0)
                    
                    continue;
                
                int nr = r + dr[i];
                
                int nc = c + dc[i];
                
                if (visited[nr][nc])
                    
                    continue;
                
                if (board[nr][nc] == 0)
                    
                    continue;
                
                rCanReach[nr][nc] = true;  //这个数组里面值为true的即为玩家可以从初始位置移动到此方格
                
                queue.add(nr);
                
                queue.add(nc);
                
                visited[nr][nc] = true;
            }
        }
        int result = 0;
        
        //符合两个条件的图所位于的行列
        
        for (int i = 1; i <= R; ++i) {
            
            for (int j = 1; j <= C; ++j) {
                
                if (rCanReach[i][j] && (!canReachT[i][j])){
                    
                    ++result;
                    
                    picture[i-1][j-1] = 'X';
                    
                }    
                    
            }
        }
        
        System.out.println("经过计算之后的图形为：");
        
        printCharArray(picture);
        
        System.out.println("满足条件的位置有 " + result + " 个。");
    }
    
    /**
     * 预先初始化数组的时候多了边框，因为visited数组默认为false
     * 此函数的目的是使得visited数组边框的默认值变为true
     * 使得visited数组中间的值默认为false
     * @param visited
     */
    
    private void initVisited(boolean[][] visited) {
        
        int R = visited.length - 2;
        
        int C = visited[0].length - 2;
        
        for (int i = 0; i <= R + 1; ++i) {
            
            visited[i][0] = true;
            
            visited[i][C + 1] = true;
        }
        for (int j = 0; j <= C + 1; ++j) {
            
            visited[0][j] = true;
            
            visited[R + 1][j] = true;
        }
        for (int i = 1; i <= R; ++i) {
            
            for (int j = 1; j <= C; ++j) {
                
                visited[i][j] = false;

            }

        }

    }
    /**
     * 打印数组中保存的值
     * 在此程序中为  输出等价于图形的数字数组
     * @param queue
     */
    public static void printNumArray(int[][] board){
        
        System.out.println("=======================begin int board array=====================");
        
        for (int i = 0; i < board.length; ++i) {    
            
            for (int j = 0; j < board[i].length; ++j) {
                
                System.out.print(board[i][j]+"	");
            }
            System.out.println();
        }
        System.out.println("===========================end========================");
    }
    
    /**
     * 打印char数组中保存的值
     * 在此程序中为  输出图形
     * @param queue
     */
    public static void printCharArray(char[][] picture){
        
        System.out.println("=======================begin char picture array=====================");
        
        for (int i = 0; i < picture.length; ++i) {    
            
            for (int j = 0; j < picture[i].length; ++j) {
                
                System.out.print(picture[i][j]);
            }
            System.out.println();
        }
        System.out.println("===========================end========================");
    }
    
    /**
     * 打印boolean数组中保存的值
     * @param queue
     */
    public static void printBealoonArray(boolean[][] visted){
        
        System.out.println("=======================begin Boolean visted array =====================");
        
        for (int i = 0; i < visted.length; ++i) {    
            
            for (int j = 0; j < visted[i].length; ++j) {
                
                System.out.print(visted[i][j]+"	");
            }
            System.out.println();
        }
        System.out.println("===========================end========================");
    }
    /**
     * 打印队列中保存的值
     * @param queue
     */
    public static void  printQueue(Queue<Integer> queue){
        
        Iterator it = queue.iterator();
        
        System.out.println("=======================begin queue=====================");
        
        int i = 0;
        
        while(it.hasNext()){
            
            System.out.print(it.next() + "	");
            
            if((++i)%2 == 0){
                
                System.out.println();
            }
        }
        System.out.println("===========================end========================");
    }
}

运行结果如下：

　　  

　　 

标准代码如下（java）：

　　

package ccf_text2013_12;

import java.util.*;
/**
 * I'm stuck!
 * 　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：
　　'#': 任何时候玩家都不能移动到此方格；
　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；
　　'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；
　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；
　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；
　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。
　　此外，玩家不能移动出地图。
　　请找出满足下面两个性质的方格个数：
　　1. 玩家可以从初始位置移动到此方格；
　　2. 玩家不可以从此方格移动到目标位置。
 * @author Hello stranger
 *
 */
public class ImStuck {
    public static void main(String[] args) {
        new ImStuck().run();
    }

    public void run() {
        Scanner fin = new Scanner(System.in);
        int R = fin.nextInt();
        int C = fin.nextInt();
        fin.nextLine();
        int[][] board = new int[R + 2][C + 2];
        int rowStart = 0, colStart = 0, rowEnd = 0, colEnd = 0;
        for (int i = 1; i <= R; ++i) {
            String line = fin.nextLine();
            for (int j = 1; j <= C; ++j) {
                char c = line.charAt(j - 1);
                switch (c) {
                case '#':
                    break;
                case '-':
                    board[i][j] = 5;
                    break;
                case '|':
                    board[i][j] = 0xA;
                    break;
                case '+':
                case 'S':
                case 'T':
                    board[i][j] = 0xF;
                    break;
                case '.':
                    board[i][j] = 0x8;
                    break;
                default:
                    break;
                }
                if (c == 'S') {
                    rowStart = i;
                    colStart = j;
                } else if (c == 'T') {
                    rowEnd = i;
                    colEnd = j;
                }
            }
        }
        int[] dr = new int[] { 0, -1, 0, 1 };
        int[] dc = new int[] { 1, 0, -1, 0 };
        // Scan 1: find all cells which can reach T
        boolean[][] visited = new boolean[R + 2][C + 2];
        boolean[][] canReachT = new boolean[R + 2][C + 2];
        initVisited(visited);
        canReachT[rowEnd][colEnd] = true;
        visited[rowEnd][colEnd] = true;
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.add(rowEnd);
        queue.add(colEnd);
        while (!queue.isEmpty()) {
            int r = queue.remove();
            int c = queue.remove();
            for (int i = 0; i < 4; ++i) {
                int nr = r + dr[i];
                int nc = c + dc[i];
                if (visited[nr][nc])
                    continue;
                if ((board[nr][nc] & (1 << ((i + 2) % 4))) != 0) {
                    canReachT[nr][nc] = true;
                    queue.add(nr);
                    queue.add(nc);
                    visited[nr][nc] = true;
                }
            }
        }
        /*
         * for (int i = 1; i <= R; ++i) { for (int j = 1; j <= C; ++j) { if
         * (canReachT[i][j]) { System.out.println("i = " + i + ", j = " + j); }
         * } }
         */
        if (!canReachT[rowStart][colStart]) {
            System.out.println("I'm stuck!");
            return;
        }
        // Scan 2: get result
        boolean[][] rCanReach = new boolean[R + 2][C + 2];
        initVisited(visited);
        queue.clear();
        visited[rowStart][colStart] = true;
        rCanReach[rowStart][colStart] = true;
        queue.add(rowStart);
        queue.add(colStart);
        while (!queue.isEmpty()) {
            int r = queue.remove();
            int c = queue.remove();
            for (int i = 0; i < 4; ++i) {
                if ((board[r][c] & (1 << i)) == 0)
                    continue;
                int nr = r + dr[i];
                int nc = c + dc[i];
                if (visited[nr][nc])
                    continue;
                if (board[nr][nc] == 0)
                    continue;
                rCanReach[nr][nc] = true;
                queue.add(nr);
                queue.add(nc);
                visited[nr][nc] = true;
            }
        }
        int result = 0;
        for (int i = 1; i <= R; ++i) {
            for (int j = 1; j <= C; ++j) {
                /*
                 * if (rCanReach[i][j]) { System.out.println("i = " + i +
                 * ", j = " + j); }
                 */
                if (rCanReach[i][j] && (!canReachT[i][j]))
                    ++result;
            }
        }
        System.out.println(result);
    }

    private void initVisited(boolean[][] visited) {
        int R = visited.length - 2;
        int C = visited[0].length - 2;
        for (int i = 0; i <= R + 1; ++i) {
            visited[i][0] = true;
            visited[i][C + 1] = true;
        }
        for (int j = 0; j <= C + 1; ++j) {
            visited[0][j] = true;
            visited[R + 1][j] = true;
        }
        for (int i = 1; i <= R; ++i) {
            for (int j = 1; j <= C; ++j) {
                visited[i][j] = false;

            }

        }

    }
}