Chenfan Blog

Do cool things that matter.

0%

The 2014 ACMICPC Asia Regional Guangzhou Online

Posted on Edited on In

【A】-_-///

【B】线段树+位运算（感觉可出）

【C】地图BFS，找最长线

【D】地图BFS，加上各种复杂情况的最短路-_-

【E】-_-///

【F】三分+圆与线段的交点，计算几何

【G】-_-///

【H】线段树+树链剖分

【I】后缀数组+二分

【J】DFS搜索

这场网赛当时自己完成了的也就是两道地图题，过去好久了才想到还是该记录下来…

C、Wang Xifeng’s Little Plot

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Problem Description

《Dream of the Red Chamber》(also 《The Story of the Stone》) is one of the Four Great Classical Novels of Chinese literature, and it is commonly regarded as the best one. This novel was created in Qing Dynasty, by Cao Xueqin. But the last 40 chapters of the original version is missing, and that part of current version was written by Gao E. There is a heart breaking story saying that after Cao Xueqin died, Cao’s wife burned the last 40 chapter manuscript for heating because she was desperately poor. This story was proved a rumor a couple of days ago because someone found several pages of the original last 40 chapters written by Cao.

In the novel, Wang Xifeng was in charge of Da Guan Yuan, where people of Jia family lived. It was mentioned in the newly recovered pages that Wang Xifeng used to arrange rooms for Jia Baoyu, Lin Daiyu, Xue Baochai and other teenagers. Because Jia Baoyu was the most important inheritor of Jia family, and Xue Baochai was beautiful and very capable , Wang Xifeng didn’t want Jia Baoyu to marry Xue Baochai, in case that Xue Baochai might take her place. So, Wang Xifeng wanted Baoyu’s room and Baochai’s room to be located at two ends of a road, and this road should be as long as possible. But Baoyu was very bad at directions, and he demanded that there could be at most one turn along the road from his room to Baochai’s room, and if there was a turn, that turn must be ninety degree. There is a map of Da Guan Yuan in the novel, and redists (In China English, one whose job is studying 《Dream of the Red Chamber》is call a “redist”) are always arguing about the location of Baoyu’s room and Baochai’s room. Now you can solve this big problem and then become a great redist.

Input

The map of Da Guan Yuan is represented by a matrix of characters ‘.’ and ‘#’. A ‘.’ stands for a part of road, and a ‘#’ stands for other things which one cannot step onto. When standing on a ‘.’, one can go to adjacent ‘.’s through 8 directions: north, north-west, west, south-west, south, south-east,east and north-east.

There are several test cases.

For each case, the first line is an integer N(0<N<=100) ,meaning the map is a N × N matrix.

Then the N × N matrix follows.

The input ends with N = 0.

Output

For each test case, print the maximum length of the road which Wang Xifeng could find to locate Baoyu and Baochai’s rooms. A road’s length is the number of ‘.’s it includes. It’s guaranteed that for any test case, the maximum length is at least 2.

Sample Input

3
#.#
##.
..#
3
…
##.
..#
3
…
###
..#
3
…
##.
…
0

Sample Output

3
4
3
5

题意

给出一张图，’.’表示路，’#’表示墙，要求找出一条最长的路，路径上只允许转弯一次。

分析

本题首先应该看到虽然要求是可以向八个方向走，但是由于转弯只能是90°的直角弯，所以上下左右四个方向与另外四个方向是完全独立的。

所以直观的想法是分成两组进行BFS，从起点开始（起点应该为某一条路的尽头），记录下上一个点到达当前点的方向、是否转过弯，每一次向下一个点搜索的方向只有三个，记录沿途的最长距离即可。

这道题的代码写得太朴素了，方向这里写了一次复制了7遍，，，都不好意思贴出来了，，，-_-///

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
/* ***********************************************
MYID    : Chen Fan
LANG    : G++
PROG    : C1003
************************************************ */

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

int dx1[4]={-1,1,1,-1};
int dy1[4]={-1,-1,1,1};
int dx2[4]={-1,0,1,0};
int dy2[4]={0,-1,0,1};
int ans;
bool ma[110][110];
int num[110][110];

bool check(int xx,int yy)
{
    int temp1=0,temp2=0;
    for (int i=0;i<4;i++) 
    {
        temp1+=ma[xx+dx1[i]][yy+dy1[i]];
        temp2+=ma[xx+dx2[i]][yy+dy2[i]];
    }
    if (temp1>0||temp2>0) return true;
    else return false;
}

typedef struct nod{
    int x,y,fx;
    bool zw;
} node;
node q[10010];

void doit(int xx,int yy)
{
    int head=1,tail=1;
    memset(num,0,sizeof(num));
    q[head].x=xx;
    q[head].y=yy;
    q[head].fx=-1;
    q[head].zw=false;
    num[xx][yy]=1;
    while (head<=tail)
    {
        if (ma[q[head].x-1][q[head].y-1]&&num[q[head].x-1][q[head].y-1]==0&&(q[head].fx==-1||q[head].fx==0||q[head].fx==1||q[head].fx==2))
        {
            tail++;
            q[tail].x=q[head].x-1;
            q[tail].y=q[head].y-1;
            if (q[head].fx==0||q[head].fx==-1) 
            {
                q[tail].fx=0;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=0;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
        }
        if (ma[q[head].x-1][q[head].y+1]&&num[q[head].x-1][q[head].y+1]==0&&(q[head].fx==-1||q[head].fx==0||q[head].fx==1||q[head].fx==3))
        {
            tail++;
            q[tail].x=q[head].x-1;
            q[tail].y=q[head].y+1;
            if (q[head].fx==1||q[head].fx==-1) 
            {
                q[tail].fx=1;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=1;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
        }
        if (ma[q[head].x+1][q[head].y-1]&&num[q[head].x+1][q[head].y-1]==0&&(q[head].fx==-1||q[head].fx==0||q[head].fx==2||q[head].fx==3))
        {
            tail++;
            q[tail].x=q[head].x+1;
            q[tail].y=q[head].y-1;
            if (q[head].fx==2||q[head].fx==-1) 
            {
                q[tail].fx=2;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=2;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
            
        }
        if (ma[q[head].x+1][q[head].y+1]&&num[q[head].x+1][q[head].y+1]==0&&(q[head].fx==-1||q[head].fx==1||q[head].fx==2||q[head].fx==3))
        {
            tail++;
            q[tail].x=q[head].x+1;
            q[tail].y=q[head].y+1;
            if (q[head].fx==3||q[head].fx==-1) 
            {
                q[tail].fx=3;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=3;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
        }
        head++;
    }
    
    head=1;tail=1;
    memset(num,0,sizeof(num));
    num[xx][yy]=1;
    while (head<=tail)
    {
        if (ma[q[head].x-1][q[head].y]&&num[q[head].x-1][q[head].y]==0&&(q[head].fx==-1||q[head].fx==0||q[head].fx==1||q[head].fx==2))
        {
            tail++;
            q[tail].x=q[head].x-1;
            q[tail].y=q[head].y;
            if (q[head].fx==0||q[head].fx==-1) 
            {
                q[tail].fx=0;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=0;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
        }
        if (ma[q[head].x][q[head].y-1]&&num[q[head].x][q[head].y-1]==0&&(q[head].fx==-1||q[head].fx==0||q[head].fx==1||q[head].fx==3))
        {
            tail++;
            q[tail].x=q[head].x;
            q[tail].y=q[head].y-1;
            if (q[head].fx==1||q[head].fx==-1) 
            {
                q[tail].fx=1;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=1;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
        }
        if (ma[q[head].x][q[head].y+1]&&num[q[head].x][q[head].y+1]==0&&(q[head].fx==-1||q[head].fx==0||q[head].fx==2||q[head].fx==3))
        {
            tail++;
            q[tail].x=q[head].x;
            q[tail].y=q[head].y+1;
            if (q[head].fx==2||q[head].fx==-1) 
            {
                q[tail].fx=2;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=2;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
            
        }
        if (ma[q[head].x+1][q[head].y]&&num[q[head].x+1][q[head].y]==0&&(q[head].fx==-1||q[head].fx==1||q[head].fx==2||q[head].fx==3))
        {
            tail++;
            q[tail].x=q[head].x+1;
            q[tail].y=q[head].y;
            if (q[head].fx==3||q[head].fx==-1) 
            {
                q[tail].fx=3;
                q[tail].zw=q[head].zw;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else 
            if (q[head].zw==false)
            {
                q[tail].fx=3;
                q[tail].zw=true;
                num[q[tail].x][q[tail].y]=num[q[head].x][q[head].y]+1;
                if (ans<num[q[tail].x][q[tail].y]) ans=num[q[tail].x][q[tail].y];
            } else tail--;
        }
        head++;
    }
}

int main()
{
    //freopen("C1003.txt","r",stdin);
    
    int n;
    scanf("%d",&n);
    while (n)
    {
        getchar();
        memset(ma,0,sizeof(ma));
        for (int i=1;i<=n;i++)
        {
            for (int j=1;j<=n;j++)
            {
                char c;
                scanf("%c",&c);
                if (c=='.') ma[i][j]=true;
            }
            getchar();
        }
        
        ans=0;
        for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
        if (ma[i][j]&&check(i,j)) doit(i,j);
        
        printf("%d\n",ans);
        scanf("%d",&n);
    }
    
    return 0;
}

启发

对于这种初看8个方向，然后相互没有关系的一定注意分开考虑。

D、Saving Tang Monk

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Problem Description

《Journey to the West》(also 《Monkey》) is one of the Four Great Classical Novels of Chinese literature. It was written by Wu Cheng’en during the Ming Dynasty. In this novel, Monkey King Sun Wukong, pig Zhu Bajie and Sha Wujing, escorted Tang Monk to India to get sacred Buddhism texts.

During the journey, Tang Monk was often captured by demons. Most of demons wanted to eat Tang Monk to achieve immortality, but some female demons just wanted to marry him because he was handsome. So, fighting demons and saving Monk Tang is the major job for Sun Wukong to do.

Once, Tang Monk was captured by the demon White Bones. White Bones lived in a palace and she cuffed Tang Monk in a room. Sun Wukong managed to get into the palace. But to rescue Tang Monk, Sun Wukong might need to get some keys and kill some snakes in his way.

The palace can be described as a matrix of characters. Each character stands for a room. In the matrix, ‘K’ represents the original position of Sun Wukong, ‘T’ represents the location of Tang Monk and ‘S’ stands for a room with a snake in it. Please note that there are only one ‘K’ and one ‘T’, and at most five snakes in the palace. And, ‘.’ means a clear room as well ‘#’ means a deadly room which Sun Wukong couldn’t get in.

There may be some keys of different kinds scattered in the rooms, but there is at most one key in one room. There are at most 9 kinds of keys. A room with a key in it is represented by a digit(from ‘1’ to ‘9’). For example, ‘1’ means a room with a first kind key, ‘2’ means a room with a second kind key, ‘3’ means a room with a third kind key… etc. To save Tang Monk, Sun Wukong must get ALL kinds of keys(in other words, at least one key for each kind).

For each step, Sun Wukong could move to the adjacent rooms(except deadly rooms) in 4 directions(north, west, south and east), and each step took him one minute. If he entered a room in which a living snake stayed, he must kill the snake. Killing a snake also took one minute. If Sun Wukong entered a room where there is a key of kind N, Sun would get that key if and only if he had already got keys of kind 1,kind 2 … and kind N-1. In other words, Sun Wukong must get a key of kind N before he could get a key of kind N+1 (N>=1). If Sun Wukong got all keys he needed and entered the room in which Tang Monk was cuffed, the rescue mission is completed. If Sun Wukong didn’t get enough keys, he still could pass through Tang Monk’s room. Since Sun Wukong was a impatient monkey, he wanted to save Tang Monk as quickly as possible. Please figure out the minimum time Sun Wukong needed to rescue Tang Monk.

Input

There are several test cases.

For each case, the first line includes two integers N and M(0 < N <= 100, 0<=M<=9), meaning that the palace is a N×N matrix and Sun Wukong needed M kinds of keys(kind 1, kind 2, … kind M).

Then the N × N matrix follows.

The input ends with N = 0 and M = 0.

Output

For each test case, print the minimum time (in minutes) Sun Wukong needed to save Tang Monk. If it’s impossible for Sun Wukong to complete the mission, print “impossible”(no quotes).

Sample Input

3 1
K.S
##1
1#T
3 1
K#T
.S#
1#.
3 2
K#T
.S.
21.
0 0

Sample Output

5
impossible
8

题意

又是一道地图题，题目要求为从起点（悟空的位置）出发，按顺序通过m个点，最后到达终点（唐僧的位置），最后输出impossible或者全程的最短距离。

分析

当时看到题目就傻了好久，需要处理的问题太多：

  1. 钥匙可能有多把，即地图上好多个1，好多个2……

  2. 蛇的问题，刚开始看的时候还没觉得什么，以为标记一下经过的时候时间+1即可，后来发现有点不对，看了比赛时其他人的提问才知道原来我觉得不对的地方是真不对，有蛇的点经过一次之后蛇就会被杀死！！下次再经过就成了普通点！！

首先解决第一个问题，BFS搜距离+DFS选择路径：

这张图的大小最大只有100*100，总点数最大是10000，考虑最坏情况，即图中的所有点中都有钥匙，9种钥匙均匀分布大约是（9998/9=1110），然后1000^9是……///-_-///……妈蛋，当时没考虑这么多，现在想想如果真的碰到这么大的数据量，我这么做真是早就爆了……

我把所有钥匙相同的点都编为1组，然后用BFS搜出相邻两组所有点对之间的距离，最后从起点（第0组）开始，DFS找出到达终点（第m+1组）的路径。

接下来是第二个更加棘手的情况：

分析下面这张图：

1
2
3
4
5
K....
.....
..s..
.....
....T

从左上角到达右下角每一点的距离：

1
2
3
4
5
01234
12345
23556
34567
45678

发现一个重要规律！即如果能够不走有蛇的点，那么一定能找出一条同样短的路不经过有蛇点。也就是说，若是最短路中经过了有蛇点，那么这个点是必定要走的，否则另外找一条路花费的代价会比消灭这条蛇的1点时间更大，即例如出现下面这种情况。

1
2
3
4
5
K....
.....
#S##.
.....
T....

穿越蛇点的代价肯定比绕开走要小。
然后看到题目特别指出最多只会出现5条蛇，于是就有了我下面的尝试算法：

  1. 将所有的蛇拿掉，做一次BFS+DFS操作，得到一个完成全程的最短距离ans；

  2. 放上一条蛇（把那个点标记为耗时2），再做一次BFS+DFS操作，得到一个完成全程的最短距离ans0。若ans0比ans更大，说明这个有蛇点是必须要经过的，记录一下，若ans0与ans相等则说明该点可以不经过，不影响结果；

  3. 拿掉之前的那条蛇，放上下一条蛇，并依此完成以上操作，判断每一个有蛇点是否都是必须经过的，不断记录即可。

最终答案为ans加上必须要经过的蛇点的个数

这里最为担心的是完成一次BFS+DFS操作需要的耗时问题，就像上面提到的，不用说极限情况，可能稍微接近一些极限的数据出来就会TLE，更不用说下面还要把这种操作再重复5次了。

幸运的是最后木有超…只能说出题的大大给的数据还没有到灭绝弱队的地步（哭）

hdu这道题有耗时更少的，一会再去找找其他神牛的题解好了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
/* ***********************************************
MYID    : Chen Fan
LANG    : G++
PROG    : D1004
************************************************ */

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef struct nod{
    int  x,y;
} node;
node lis[11][1000];
node q[20000];
int an[11][1000][1000];
int ma[110][110],num[110][110];
bool flag[110][110];
bool state[110][1000][6];
bool done;
int ns;
node ss[6];

int n,m,ans;

int dx[]={-1,0,1,0};
int dy[]={0,-1,0,1};

int doit(int sx,int sy,int ex,int ey)
{
    int head=1,tail=1,ret=0;
    q[head].x=sx;
    q[head].y=sy;
    memset(num,0,sizeof(num));
    memset(flag,0,sizeof(flag));
    flag[q[head].x][q[head].y]=true;
    bool done=false;
    while (head<=tail)
    {
        if (q[head].x==ex&&q[head].y==ey)
        {
            done=true;
            ret=num[q[head].x][q[head].y];
            break;
        }
        for (int i=0;i<4;i++)
        if (ma[q[head].x+dx[i]][q[head].y+dy[i]]&&(num[q[head].x+dx[i]][q[head].y+dy[i]]==0||num[q[head].x+dx[i]][q[head].y+dy[i]]>num[q[head].x][q[head].y]+ma[q[head].x+dx[i]][q[head].y+dy[i]]))
        {
            num[q[head].x+dx[i]][q[head].y+dy[i]]=num[q[head].x][q[head].y]+ma[q[head].x+dx[i]][q[head].y+dy[i]];
            if (!flag[q[head].x+dx[i]][q[head].y+dy[i]])
            {
                tail++;
                q[tail].x=q[head].x+dx[i];
                q[tail].y=q[head].y+dy[i];
                flag[q[head].x+dx[i]][q[head].y+dy[i]]=true;
            }
        }
        flag[q[head].x][q[head].y]=false;
        head++;
    }
    if (done) return ret;
    else return -1;
}

void dfs(int s,int t,int tot)
{
    if (s==m+1)
    {
        if (ans>tot) 
        {
            ans=tot;
            done=true;
        }
        return;
    }
    for (int i=1;i<=lis[s+1][0].x;i++)
    if (an[s][t][i]!=-1)
    {
        dfs(s+1,i,tot+an[s][t][i]);
    }
}

int main()
{
    //freopen("D1004.txt","r",stdin);
    
    scanf("%d%d",&n,&m);
    while (!(n==0&&m==0))
    {
        getchar();
        memset(ma,0,sizeof(ma));
        memset(lis,0,sizeof(lis));
        ns=0;
        for (int i=1;i<=n;i++)
        {
            for (int j=1;j<=n;j++)
            {
                char c;
                scanf("%c",&c);
                switch(c)
                {
                    case 'K':
                        lis[0][0].x=1;
                        lis[0][1].x=i;lis[0][1].y=j;
                        ma[i][j]=1;
                        break;
                    case 'T':
                        lis[m+1][0].x=1;
                        lis[m+1][1].x=i;lis[m+1][1].y=j;
                        ma[i][j]=1;
                        break;
                    case 'S':
                        ns++;
                        ss[ns].x=i;ss[ns].y=j;
                        ma[i][j]=1;
                        break;
                    case '.':
                        ma[i][j]=1;
                        break;
                    case '#':
                        break;
                    default:
                        ma[i][j]=1;
                        lis[c-'0'][0].x++;
                        lis[c-'0'][lis[c-'0'][0].x].x=i;
                        lis[c-'0'][lis[c-'0'][0].x].y=j;
                }
            }
            getchar();
        }
        
        ans=0;
        memset(an,0,sizeof(an));
        for (int i=0;i<=m;i++)
        {
            for (int j=1;j<=lis[i][0].x;j++)
            for (int k=1;k<=lis[i+1][0].x;k++)
            an[i][j][k]=doit(lis[i][j].x,lis[i][j].y,lis[i+1][k].x,lis[i+1][k].y);
        }
        done=false;
        ans=2147483647;
        dfs(0,1,0);
        if (done)
        {
            int ans0=ans;
            int temp=0;
            for (int p=1;p<=ns;p++)
            {
                if (p>1) ma[ss[p-1].x][ss[p-1].y]=1;
                ans=0;
                ma[ss[p].x][ss[p].y]=2;
                memset(an,0,sizeof(an));
                for (int i=0;i<=m;i++)
                {
                    for (int j=1;j<=lis[i][0].x;j++)
                    for (int k=1;k<=lis[i+1][0].x;k++)
                    an[i][j][k]=doit(lis[i][j].x,lis[i][j].y,lis[i+1][k].x,lis[i+1][k].y);
                }
                done=false;
                ans=2147483647;
                dfs(0,1,0);
                if (ans>ans0) temp++;
            }
            printf("%d\n",ans0+temp);
        }
        else printf("impossible\n");
        
        scanf("%d%d",&n,&m);
    }
    
    return 0;
}
Related Posts