【Acm】算法之美—Fire Net

题目概述：Fire Net

 

　　Suppose  that we have a square city with straight streets. A map of a city is a square  board with n rows and n columns, each representing a street or a piece of  wall.

　　A  blockhouse is a small castle that has four openings through which to shoot. The  four openings are facing North, East, South, and West, respectively. There will  be one machine gun shooting through each opening.

　　Here we  assume that a bullet is so powerful that it can run across any distance and  destroy a blockhouse on its way. On the other hand, a wall is so strongly built  that can stop the bullets.

　　The goal  is to place as many  blockhouses in a city as possible so that no two can destroy each other. A  configuration of blockhouses is legal  provided that no two blockhouses are on the same horizontal row or vertical  column in a map unless there is at least one wall separating them. In this  problem we will consider small square cities (at most 4x4) that contain walls  through which bullets cannot run through.

　　The  following image shows five pictures of the same board. The first picture is the  empty board, the second and third pictures show legal configurations, and the  fourth and fifth pictures show illegal configurations. For this board, the  maximum number of blockhouses in a legal configuration is 5; the second picture  shows one way to do it, but there are several other ways.

　　Your  task is to write a program that, given a description of a map, calculates the  maximum number of blockhouses that can be placed in the city in a legal  configuration.

　　he  input file contains one or more map descriptions, followed by a line containing  the number 0 that signals the end of the file. Each map description begins with  a line containing a positive integer n that is  the size of the city; n will be  at most 4. The next n lines  each describe one row of the map, with a '.'  indicating an open space and an uppercase 'X'  indicating a wall. There are no spaces in the input file.

　　For each  test case, output one line containing the maximum number of blockhouses that can  be placed in the city in a legal configuration.

Sample  input:

4
.X..
....
XX..
....
2
XX
.X
3
.X.
X.X
.X.
3
...
.XX
.XX
4
....
....
....
....
0

Sample  output:

5
1
5
2
4

 

 

简单描述

　　题是英文的，重要的语句我已经标出来了，其实题的意思很简单：

　　在一个n*n(最大为4*4)的矩形表格中，由你指定在哪些表格不空(用"X"表示，代表wall),哪些表格是空的(用"."表示，可以建blockhouses)，现在要在空的(".")表格中写O(建blockhouses),要求就是在水平或者竖直方向上不能有两个O直接或间接相邻，问最多可以写几个O(建blockhouses)？

 

题目分析

　　1、不空的表格由自己决定，即为输入的一部分

　　2、在水平或者竖直方向上不能有两个O直接或间接相邻，意味着需要作遍历判断

　　3、最多可以写几个O(建blockhouses)，意味着需要对所有表格进行分析

　　下面贴出源代码，其中我对最主要的代码都作了详细的注释

 

解题算法

 

 1 #include < stdio.h>
 2 
 3 char map[4][4];
 4 
 5 int best,n;
 6 
 7 int CanPut(int row, int col)
 8 
 9 /*
10 *检测与前行或者与前列是否存在冲突,即原文中的
11 *no two blockhouses are on the same horizontal row or vertical column in a map unless there is at least one wall separating them
12 *如果bullets cannot run through，则返回1
13 *否则bullets can run through，返回0
14 */
15           
16 {
17     int i;    
18     for (i = row - 1; i >= 0; i--)        
19     {        
20         if (map[i][col] == 'O') return 0;        
21         if (map[i][col] == 'X') break;        
22     }    
23     for (i = col - 1; i >= 0; i--)        
24     {
25         if (map[row][i] == 'O') return 0;
26         if (map[row][i] == 'X') break;        
27     }
28     return 1;
29 }
30 
31 void solve(int k,int tot)
32 /*
33 *calculates the maximum number of blockhouses that can be placed in the city in a legal configuration
34 *k表示被检测的map单元个数
35 *tot表示可以放置blockhouses的个数
36 */
37 {
38     int x,y;
39     if(k==n*n)//保证整个地图都被检测过
40     {        
41         if(tot>best)              
42         {
43             best=tot;    
44             return;  
45         }
46     }
47     else
48     {
49         x=k/n; //先逐行进行检测
50         y=k%n; //逐列进行检测
51         if((map[x][y]=='.') && (CanPut(x,y) ) )//是open space，并且 bullets cannot run through
52         {
53             map[x][y]='O';//'0'表示已经检测过并且可放置blockhouses，即将tot+1
54             solve(k+1,tot+1);//map[x][y]可以放置blockhouses，则从map[(k+1)/n][(k+1)%n]开始继续检测,即逐行进行检测，并且tot+1
55             map[x][y]='.';//在恢复堆栈的时候，还原map原来的数据
56         }
57         solve(k+1,tot);//若map[k/n][k%n]存在bullets can run through，则继续从map[(k+1)/n][(k+1)%n]开始逐行检测
58     }
59 }
60 int main()
61 {
62     int i,j;
63     scanf("%d",&n);
64     while(n>0)
65     {
66         for(i=0;i< n;i++)
67         {
68             for(j=0;j< n;j++)
69             {
70                 scanf("%1s",&map[i][j]);//输入单个字符并且忽略空白
71             }
72         }
73         best=0;
74         solve(0,0);
75         printf("%d\n",best);
76         n=0;//预防scanf失败,reset n
77         scanf("%d",&n);
78     }
79     return 0;
80 }
View Code

 

 

posted @ 2013-06-27 17:38  Leo.cheng  阅读(1007)  评论(0)  编辑  收藏  举报