OpenJudge-NOI/2.1基本算法之枚举-1816：拨钟问题
1816：拨钟问题
总时间限制: 1000ms 内存限制: 65536kB
描述
有9个时钟，排成一个3*3的矩阵。
|-------| |-------| |-------|
| | | | | | |
|---O | |---O | | O |
| | | | | |
|-------| |-------| |-------|
A B C
|-------| |-------| |-------|
| | | | | |
| O | | O | | O |
| | | | | | | | |
|-------| |-------| |-------|
D E F
|-------| |-------| |-------|
| | | | | |
| O | | O---| | O |
| | | | | | | |
|-------| |-------| |-------|
G H I
(图 1)现在需要用最少的移动，将9个时钟的指针都拨到12点的位置。共允许有9种不同的移动。如下表所示，每个移动会将若干个时钟的指针沿顺时针方向拨动90度。
移动 影响的时钟
1 ABDE
2 ABC
3 BCEF
4 ADG
5 BDEFH
6 CFI
7 DEGH
8 GHI
9 EFHI 输入
9个整数，表示各时钟指针的起始位置，相邻两个整数之间用单个空格隔开。其中，0=12点、1=3点、2=6点、3=9点。
输出
输出一个最短的移动序列，使得9个时钟的指针都指向12点。按照移动的序号从小到大输出结果。相邻两个整数之间用单个空格隔开。
样例输入
3 3 0
2 2 2
2 1 2 样例输出
4 5 8 9 题解
由题可知，一共有9种不同的移动，那么我们将每一种移动对应于一种操作(operation),简写成op。每种操作都会影响若干个时钟，那么我们将每种操作影响的时钟转换为每个时钟受哪些操作的影响。如下所示：
A 1 2 4
B 1 2 3 5
C 2 3 6
D 1 4 5 7
E 1 3 5 7 9
F 3 5 6 9
G 4 7 8
H 5 7 8 9
I 6 8 9又因为每次操作会将若干个时钟转动90度，所以当同一个操作进行4次，其实就是旋转了360度，相当于没有操作。(一种操作做四次和不做是一样的)所以每种操作做的次数为：0，1，2，3。一共有9种操作，所以枚举次数为4的9次方，暴力枚举就是一个9重循环。最后用一个变量sum来累加每个时钟被操作后的指向，如果累加完后sum=0，那么说明找到了一个移动序列使得9个时钟的指针都指向12点。但此时我们并不知道找到的是否就是最短的序列，所以还要进行比较取操作次数的最小值。
方法一 暴力枚举
代码如下：
#include<iostream>
using namespace std;
int ori[10];
int op[10];
int result[10];
int main()
{
int sum,min=28,moves;
for(int i=1; i<10; ++i)
cin >> ori[i];
for(op[1]=0; op[1]<4; ++op[1])
for(op[2]=0; op[2]<4; ++op[2])
for(op[3]=0; op[3]<4; ++op[3])
for(op[4]=0; op[4]<4; ++op[4])
for(op[5]=0; op[5]<4; ++op[5])
for(op[6]=0; op[6]<4; ++op[6])
for(op[7]=0; op[7]<4; ++op[7])
for(op[8]=0; op[8]<4; ++op[8])
for(op[9]=0; op[9]<4; ++op[9])
{
sum=0;
sum+=(ori[1]+op[1]+op[2]+op[4])%4;
sum+=(ori[2]+op[1]+op[2]+op[3]+op[5])%4;
sum+=(ori[3]+op[2]+op[3]+op[6])%4;
sum+=(ori[4]+op[1]+op[4]+op[5]+op[7])%4;
sum+=(ori[5]+op[1]+op[3]+op[5]+op[7]+op[9])%4;
sum+=(ori[6]+op[3]+op[5]+op[6]+op[9])%4;
sum+=(ori[7]+op[4]+op[7]+op[8])%4;
sum+=(ori[8]+op[5]+op[7]+op[8]+op[9])%4;
sum+=(ori[9]+op[6]+op[8]+op[9])%4;
if(sum==0)
{
moves=0;
for(int i=1; i<10; ++i)
moves+=op[i];
if(moves<min)
{
min=moves;
for(int i=1; i<10; ++i)
result[i]=op[i];
}
}
}
for(int i=1; i<10; ++i)
{
while(result[i]--)
{
cout << i << " ";
}
}
return 0;
}枚举的核心问题就是：
1.怎样去枚举？
2.在答案正确的情况下，怎么减少枚举次数？
所以这道题怎么减少枚举次数呢？
枚举中有一个十分重要的思想—局部思想法，它的基本思路如下：
如果存在某个局部, 一旦这个局部的状态被确定, 那么剩余其他部分的状态只能是确定的一种, 或者不多的n 种, 那么就只需枚举这个局部的状态即可。
所以我们来看这道题，看能不能找到一个局部使得枚举的次数减少。不难发现操作1，2，3为一个局部。例如，当我们确定了操作1，2，3的次数以后，得到A,B,C这三个时钟的指针的指向，此时只有操作4能够改变A时钟的的指针方向，使它能指向12点。同理，只有操作5才能够改变B时钟的指针方向，只有操作6才能够改变C时钟的指针方向。那么操作4-6的次数也就确定了。同样，继续往下，现在操作1-6的次数都确定了，只有操作7才能改变D时钟的指针方向，只有操作8才能改变G时钟的指针方向,只有操作9才能改变F时钟的指针方向。
这样操作1-9的次数都被确定了，A,B,C,D,G,F这6个时钟的指针都指向了12点，只有E,H,I这三个时钟指针方向还没有确定。所以剩下只用判断E,H,I这三个时钟的指针指向12点没有，如果都指向了12点，那说明找到了一个序列使得9个时钟的指针都指向了12点。
所以根据局部思想的方法，我们只需对操作1，2，3进行枚举，枚举的次数为4的3次方=64次。
方法二 局部枚举
代码如下：
#include<iostream>
using namespace std;
int ori[10];
int op[10];
int result[10];
int main()
{
int min=28,moves,e,h,i;
for(int i=1; i<10; ++i)
cin >> ori[i];
for(op[1]=0; op[1]<4; ++op[1])
for(op[2]=0; op[2]<4; ++op[2])
for(op[3]=0; op[3]<4; ++op[3])
{
op[4]=(4-(ori[1]+op[1]+op[2])%4)%4;//确定A
op[5]=(4-(ori[2]+op[1]+op[2]+op[3])%4)%4;//确定B
op[6]=(4-(ori[3]+op[2]+op[3])%4)%4;//确定C
op[7]=(4-(ori[4]+op[1]+op[4]+op[5])%4)%4;//确定D
op[8]=(4-(ori[7]+op[4]+op[7])%4)%4;//确定G
op[9]=(4-(ori[6]+op[3]+op[5]+op[6])%4)%4;//确定F
e=(ori[5]+op[1]+op[3]+op[5]+op[7]+op[9])%4;
h=(ori[8]+op[5]+op[7]+op[8]+op[9])%4;
i=(ori[9]+op[6]+op[8]+op[9])%4;
if((e+h+i)==0)//判断E,H,I这三个时钟指针都指向12点没有
{
moves=0;
for(int i=1; i<10; ++i)
moves+=op[i];
if(moves<min)
{
min=moves;
for(int i=1; i<10; ++i)
result[i]=op[i];
}
}
}
for(int i=1; i<10; ++i)
{
while(result[i]--)
{
cout << i << " ";
}
}
return 0;
}感谢观看！如有错误，还请指出。
此题来源于http://noi.openjudge.cn/ch0201/1816/
同时我也向大家推荐中国大学MOOC上的来自北京大学郭炜老师的课程—程序设计与算法（二）算法基础。
