时钟问题

最新推荐文章于 2021-05-22 21:06:09 发布

志存高远CS

最新推荐文章于 2021-05-22 21:06:09 发布

阅读量491

点赞数 2

分类专栏： ACM算法

本文链接：https://blog.csdn.net/qq_36950065/article/details/54755070

版权

ACM算法专栏收录该内容

26 篇文章 0 订阅

订阅专栏

有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

种操作对应一个二维数组。这一题实质类似熄灯问题和画家问题。其共通点在于：操作对环境的改变是无序的，每个操作都会影响到周围的状态。同时每一种操作都有周期性限制，也即最多需要几次操作，多于这个次数产生循环。熄灯问题中，每个灯最多熄灯一次，因为灯只有两种状态，并且循环。而这里，有4种循环的状态，因此每个移动操作顶多使用3次。我们对移动方法1,2,3进行枚举，每种方法无非实施0-3次，也即一共4^3=64种情况。这些情况之间并非没有关系。例如，我们确定了1,2,3的情况数，那么得到一个灯A,B,C的状态，而只有移动4能够改变A，移动5能够改变B，移动6能够改变C，那么移动4-6的次数也确定了。同样，这时只有移动7能够改变D，移动9能够改变F，这时移动7和9的次数也确定了。最后，时钟A,B,C,D,F都已经到达12点，E,G,H,I还没确定，只剩下移动8能够改变GHI，所以只要检查E是否已经到达12点以及，GHI的时钟数是否相等就行了。最后找到一个移动次数最小的情况。
这题也可以用暴力搜索，因为最多有4^9个组合，不会超时。
这题还可以列出一个方程组，九个未知数，通过高斯消元法来解方程组。

#include<iostream>
#include<stdio.h>
using namespace std;
int main()
{
int station[9] = {0};
for (int i = 0; i < 9; i++)
cin>>station[i];
int move_count[9] = {0};
int min_count = 10000;
for (int i1 = 0; i1 < 4; i1++)
for (int i2 = 0; i2 < 4; i2++)
for (int i3 = 0; i3 < 4; i3++)
for (int i4 = 0; i4 < 4; i4++)
for (int i5 = 0; i5 < 4; i5++)
for (int i6 = 0; i6 < 4; i6++)
for (int i7 = 0; i7 < 4; i7++)
for (int i8 = 0; i8 < 4; i8++)
for (int i9 = 0; i9 < 4; i9++)
{
if ((0 == (i1 + i2 + i4 + station[0]) % 4) && (0 == (i1 + i2 + i3 + i5 + station[1])
% 4) && (0 == (i2 + i3 + i6 + station[2]) % 4) && (0 == (i1 + i4 + i5 + i7 +
station[3]) % 4) && (0 == (i1 + i3 + i5 + i7 + i9 + station[4]) % 4) && (0 ==
(i3 + i5 + i6 + i9 + station[5])% 4) && (0 == (i4 + i7 + i8 + station[6]) % 4)
&& (0 == (i5 + i7 + i8 + i9 + station[7])% 4) && (0 == (i6 + i8 + i9 + station[8]) % 4))
{
int sum = i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
if (min_count > sum)
{
min_count = sum;
move_count[0] = i1;
move_count[1] = i2;
move_count[2] = i3;
move_count[3] = i4;
move_count[4] = i5;
move_count[5] = i6;
move_count[6] = i7;
move_count[7] = i8;
move_count[8] = i9;
}
}
}
int cur = 0;
for (cur = 0; cur < 9; cur++)
while (move_count[cur]--)
cout<<cur + 1<<" ";
cout<<endl;
return 0;
}
1. //拨钟问题
2. #include"stdafx.h"
3. #include<iostream>
4. #include<vector>
5. using namespace std;
6. //钟表输入
7. int clock[3][3]={3, 3 ,0,
8. 2, 2, 2,
9. 2, 1, 2};
10. int mainRoot[9]={3,3,3,3,3,3,3,3,3};//当前的最短路径
11. void isOk(const int i1,const int i2 ,const int i3);//如果验证成功那么返回1 否则返回0
12. void enumerate()//将前3行的拨钟数目进行枚举返回枚举方法循环写在这里面
13. {
15. int i1=0;int i2=0;int i3=0;//初始时前三种方法都使用0次
16. for(int i=0;i<4;i++)
17. {
18. i2=0;
19. for(int j=0;j<4;j++)
20. {
21. i1=0;
22. for(int l=0;l<4;l++)//I1次数
23. {
24. isOk(i1,i2,i3);
25. i1++;
26. }
27. i2++;
28. }
29. i3++;
30. }
31. return ;//结果存在mainRoot中
34. }
35. /*
37. 1 ABDE
38. 2 ABC
39. 3 BCEF
40. 4 ADG
41. 5 BDEFH
42. 6 CFI
43. 7 DEGH
44. 8 GHI
45. 9 EFHI
46. */
47. void isOk(const int i1,const int i2 ,const int i3)//如果验证成功那么返回1 否则返回0
48. {
49. int i4=(4-(clock[0][0]+i1+i2)%4)%4;//确定a
50. int i5=(4-(clock[0][1]+i1+i2+i3)%4)%4;//确定B
51. int i6=(4-(clock[0][2]+i2+i3)%4)%4; //确定C
52. int i7=(4-(clock[1][0]+i1+i4+i5)%4)%4;//确定D
53. int i8=(4-(clock[2][0]+i4+i7)%4)%4;//确定G
54. int i9=(4-(clock[1][1]+i1+i3+i5+i7)%4)%4;//确定E
55. //f h i
56. if((clock[1][2]+i3+i5+i9)%4==0 && (clock[2][1]+i5+i7+i8+i9)%4==0 && (clock[2][2]+i6+i8+i9)%4==0)//满足条件
57. {
59. int resultTemp[9]={i1,i2,i3,i4,i5,i6,i7,i8,i9};
60. int sum=(mainRoot[1]+mainRoot[2]+mainRoot[3]+mainRoot[4]+mainRoot[5]+mainRoot[6]+mainRoot[7]+mainRoot[8]+mainRoot[0]);
61. if((i1+i2+i3+i4+i5+i6+i7+i8+i9)<sum)//找到了更优秀的解
62. {
63. for(int i=0;i<9 ;i++)
64. {
65. mainRoot[i]=resultTemp[i];//更新解决方案
67. }
68. return;
69. }
70. else//不符合要求直接return继续寻找
71. {
72. return;
73. }
75. }
76. return ;
77. }
79. int main()
80. {
82. for(int i=0;i<3;i++)
83. {
84. for(int j=0;j<3;j++)
85. {
86. cout<<clock[i][j]<<" ";
87. }
88. cout<<endl;
89. }
90. enumerate();//将前3行的拨钟数目进行枚举返回枚举方法
92. for(int i=0;i<9;i++)
93. {
95. cout<<"step "<<i+1<<" "<<mainRoot[i]<<endl;
97. }
99. return 0;
101. }