hdu4770:Lights Against Dudely（回溯 + 修剪）

称号：hdu4770:Lights Against Dudely

题目大意：相同是n*m的矩阵代表room，房间相同也有脆弱和牢固之分，如今要求要保护脆弱的房间。须要将每一个脆弱的房间都照亮，可是牢固的房间不同意照到灯。

灯是成L形的，即在x，y上有一盏灯，那么（x - 1， y）和（x。 y + 1）就能够被照亮。当然包含（x。y）。题目又提供了一盏特殊的灯，它能够该改变方向。可是仅仅有一盏，能够用也能够不用。一个房间最多一盏灯。

问要将这些脆弱的房间都照亮最少须要多少盏灯。

解题思路：题目有说脆弱的房间最多15间，那么先枚举哪间脆弱的房间放特殊的灯，特殊的灯又须要枚举四个方向，之后的就都是普通的灯。

复杂度（15 * 4 * 2^14）将近1000000，再加上仅仅要碰到一个房间它不能被照亮就返回，而且这里考虑到普通灯的形状。所以回溯的时候是从左下角開始往右上角方向走。这是为了在比較前面得到较小的灯数目。那么回溯中有个剪枝就能剪掉较早的剪掉不符合的情况。剪枝：假设到中间的灯的数量比最小的大或是相等。就能够直接返回。

注意：这里灯的四个方向的坐标一定要细心，错在这找了一下午。还有中间不是有标记房间的状态：是否被照亮，这里回溯要改回原来的值这个地方也要小心。

由于可能有的灯原先就是亮的。

原先状态不一致。所以用tem数组做了记录。还有放在这个位置的灯若是照到了牢固的房间，或是已经放了灯的房间。这样的情况是不行的。可是灯能够照在边界上，这样的是能够的。感觉比較难的就是在回溯状态恢复这一块，一定要细心。

代码：

#include <stdio.h>
#include <string.h>

const int N = 205;
const int INF = 0x3f3f3f3f;
int n, m;
char g

;
int visit

; //标记房间是否被照亮
int mm;
struct Tem {     //暂时数组存放回溯后要恢复的状态

int x, y, v;
};

const int dir[4][2][2] = {{{-1,0}, {0, 1}},  //特殊灯的四个方向
{{1, 0}, {0, 1}},
{{0, -1}, {1, 0}},
{{0, -1}, {-1, 0}}};

int Min (const int x, const int y) { return x < y?

x: y; }

bool influence (int x, int y, int d, Tem * tem) {  //d代表的是灯的方向  这个函数是用来处理这个位置的灯能影响到的房间。能够推断灯能不能放这个位置

tem[0].v = visit[x][y];
tem[0].x = x;
tem[0].y = y;
visit[x][y] = 1;
int nx = x + dir[d][0][0];
int ny = y + dir[d][0][1];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {

if (g[nx][ny] == '#')
return false;
else {

tem[1].v = visit[nx][ny];
tem[1].x = nx;
tem[1].y = ny;
visit[nx][ny] = 1;
}
}

int nx1 = x + dir[d][1][0];
int ny1 = y + dir[d][1][1];
if (nx1 >= 0 && nx1 < n && ny1 >= 0 && ny1 < m ) {

if (g[nx1][ny1] == '#')
return false;
else {

tem[2].v = visit[nx1][ny1];
tem[2].x = nx1;
tem[2].y = ny1;
visit[nx1][ny1] = 1;
}
}

return true;
}

void undo (Tem * tem) {   //回溯恢复visit状态

for (int i = 0; i < 3; i++)
if (tem[i].v != -1)
visit[tem[i].x][tem[i].y] = tem[i].v;
}

void dfs (int x, int y, int num) {  //从左下角往右上角走

int newx, newy;
if (x == -1) {

mm = Min (mm, num);
return;
}

newy = y + 1;
newx = x;
if (newy >= m) {
newx = x - 1;
newy = 0;
}

if (g[x][y] == '.') {         // 推断脆弱的房间是否要放灯

bool flag = 0;
if (visit[x][y]) {     //已经被照亮的房间能够考虑不放灯
dfs(newx, newy, num);
flag = 1;
}

if (num + 1 >= mm)    //剪枝  大于等于最小值直接返回
return;

Tem tem[3];           //放灯的情况
memset (tem, -1, sizeof (tem));
if (influence (x, y, 0, tem)) {

g[x][y] = 'X';
dfs (newx, newy, num + 1);
undo(tem);
g[x][y] = '.';

} else {

undo(tem);    //不论能否够放都须要恢复状态，这个是由于我写的influence函数
if (!flag)    //剪枝  这个房间不能被照亮直接返回
return;
}

} else
dfs (newx, newy, num);
}

void solve () {   //枚举特殊灯的位置。特殊灯的方向

mm = INF;
memset (visit, 0, sizeof (visit));
bool flag = 1;
Tem tem[3];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] == '.') {

flag = 0;
g[i][j] = 'X';
for (int k = 0; k < 4; k++) {

memset (tem, -1, sizeof (tem));
memset (visit, 0, sizeof (visit));

if (influence (i, j, k, tem))
dfs (n - 1, 0, 1);
undo(tem);
}
g[i][j] = '.';
}

if (mm == INF) {

if (flag)
printf ("0\n");
else
printf ("-1\n");
}
else
printf ("%d\n", mm);
}

int main () {

while (scanf ("%d%d", &n, &m), n || m) {

for (int i = 0; i < n; i++)
scanf ("%s", g[i]);
solve();
}
return 0;
}

測试例子：

2 2

##

##

2 3

#..

..#

3 3

###

#.#

###

4 2

#.

..

.#

..

1 1

.

2 1

.

#

1 2

#.

1 5

.#...

1 4

.#..

2 5

...#.

####.

6 4

#.##

..#.

#.#.

#..#

....

....

5 5

#..#.

##.#.

####.

#.###

#..##

2 2

..

#.

2 2

..

..

2 2

##

.#

2 2

##

#.

2 3

###

#..

2 3

#.#

#.#

0 0

输出：

0

2

-1

2

1

1

1

3

2

3

7

4

1

2

1

1

1

-1