PKU_ACM_1164_The Castle

http://acm.pku.edu.cn/JudgeOnline/problem?id=1164  原题

 

类似于迷宫搜索的简单题

 

2. import java.io.*;
3. import java.util.*;
5. public class Main
6. {
7.     static Room[][] matrix;
8.     static int row;
9.     static int col;
10.     public static void main(String[] args) throws Exception
11.     {
12.         readFile();
13.         for(int i=0; i<row; i++)
14.         {
15.             for(int j=0; j<col; j++)
16.             {
17.                 if(!matrix[i][j].bFlag)
18.                 {
19.                     process(i,j);
20.                     sumCount++;
21.                     if(maxCount>INF)
22.                     {
23.                         INF = maxCount;
24.                     }
25.                     maxCount=0;
26.                 }
27.             }
28.         }
29.         System.out.print(sumCount);
30.         System.out.print("/n"+INF);
31.     }
33.     public static void readFile() throws Exception
34.     {
35.         BufferedReader br = new BufferedReader(
36.             new InputStreamReader(System.in));
37.         StringTokenizer st = null;
38.         row = Integer.valueOf(br.readLine());
39.         col = Integer.valueOf(br.readLine());
40.         matrix = new Room[row][col];
41.         int count = 0;
42.         while(count<row)
43.         {
44.             st = new StringTokenizer(br.readLine()," ");
45.             int j = 0;
46.             Room room = null;
47.             while(st.hasMoreTokens())
48.             {
49.                 room = new Room(Integer.valueOf(st.nextToken()));
50.                 matrix[count][j] = room;
51.                 j++;
52.             }
53.             count++;
54.         }
55.     }
57.     static void displayRoom()
58.     {
59.         for(int i=0; i<row; i++)
60.         {
61.             for(int j=0; j<col; j++)
62.                 System.out.println(matrix[i][j]);
63.             System.out.println();
64.         }
65.     }
68.     static int sumCount = 0;
69.     static int maxCount = 0;
70.     static int INF = 0;
71.     static void process(int i,int j)
72.     {
73.         if(i<0 || j<0 || i>=row || j>=col)
74.             return;
75.         if(matrix[i][j].bFlag)
76.             return;
77.         maxCount++;
78.         matrix[i][j].bFlag = true;
79.         if(matrix[i][j].states[0][1]==2)
80.         {
81.             process(i-1,j);
82.         }
83.         if(matrix[i][j].states[1][2]==2)
84.         {
85.             process(i,j+1);
86.         }
87.         if(matrix[i][j].states[2][1]==2)
88.         {
89.             process(i+1,j);
90.         }
91.         if(matrix[i][j].states[1][0]==2)
92.         {
93.             process(i,j-1);
94.         }
95.         
96.         
97.     }
99.     
100.     static class Room
101.     {
102.         int[][] states = new int[3][3];
103.         boolean bFlag = false;
104.         Room(int flag)
105.         {
106.             states[1][1] = 1;
107.             switch(flag)
108.             {
109.             case 0:
110.                 states[0][1] = 2;
111.                 states[1][2] = 2;
112.                 states[1][0] = 2;
113.                 states[2][1] = 2;
114.                 break;
115.             case 1:
116.                 states[0][1] = 2;
117.                 states[1][2] = 2;
118.                 states[2][1] = 2;
119.                 break;
120.             case 2:
121.                 states[1][0] = 2;
122.                 states[1][2] = 2;
123.                 states[2][1] = 2;
124.                 break;
125.             case 3:
126.                 states[1][2] = 2;
127.                 states[2][1] = 2;
128.                 break;
129.             case 4:
130.                 states[0][1] = 2;
131.                 states[1][0] = 2;
132.                 states[2][1] = 2;
133.                 break;
134.             case 5:
135.                 states[0][1] = 2;
136.                 states[2][1] = 2;
137.                 break;
138.             case 6:
139.                 states[1][0] = 2;
140.                 states[2][1] = 2;
141.                 break;
142.             case 7:
143.                 states[2][1] = 2;
144.                 break;
145.             case 8:
146.                 states[0][1] = 2;
147.                 states[1][0] = 2;
148.                 states[1][2] = 2;
149.                 break;
150.             case 9:
151.                 states[0][1] = 2;
152.                 states[1][2] = 2;
153.                 break;
154.             case 10:
155.                 states[1][0] = 2;
156.                 states[1][2] = 2;
157.                 break;
158.             case 11:
159.                 states[1][2] = 2;
160.                 break;
161.             case 12:
162.                 states[0][1] = 2;
163.                 states[1][0] = 2;
164.                 break;
165.             case 13:
166.                 states[0][1] = 2;
167.                 break;
168.             case 14:
169.                 states[1][0] = 2;
170.                 break;
171.             case 15:
172.                 break;
173.             }
174.         }
176.         public String toString()
177.         {
178.             for(int i=0; i<3; i++)
179.             {
180.                 for(int j=0; j<3; j++)
181.                     System.out.print(states[i][j] + " ");
182.                 System.out.println();
183.             }
184.             return "";
185.         }
186.     }
187. }