Vijos1016.北京2008的挂钟

试题请参见: https://vijos.org/p/1016

题目概述

在2008北京奥运会雄伟的主会场的墙上, 挂着如上图所示的3*3的九个挂钟(一开始指针即时针指向的位置请根据输入数据调整). 然而此次奥运会给与了大家一个机会, 去用最少的移动操作改变上面的挂钟的时间全部为12点正(我们只考虑时针). 然而每一次操作并不是任意的, 我们必须按照下面给出的列表对于挂钟进行改变. 每一次操作我们给而且必须给指定的操作挂钟进行, 每一个挂钟顺时针转动90度. 列表如下:

操作	指定的操作挂钟
1	ABDE
2	ABC
3	BCEF
4	ADG
5	BDEFH
6	CFI
7	DEGH
8	GHI
9	EFHI

解题思路

这题解法有很多, 但是我们注意到就算穷举运算量也并不大. 于是我们就使用穷举.

有一个简单的”剪枝”, 每一个操作的最大次数为3次(即[0, 4)). 因为当时钟被调整到4次之后又会回到原点, 这显然不是最优解.

遇到的问题

一些非常低级的小问题:

循环变量没有初始化

输出的时候写错了循环变量等

源代码

#include <iostream>

const size_t NUMBER_OF_CLOCKS           = 9;
const size_t NUMBER_OF_OPERATIONS       = 9;
/**
* 最大操作次数.
* 由于操作4次会回到原点, 没有必要继续搜索.
*/
const size_t MAX_NUMBER_OF_OPERATIONS   = 4;

/**
* 获取当前对各个时钟操作的次数.
* @return 对各个时钟操作的次数
*/
int getOperationTimes(int* operations) {
int operationTimes = 0;

for ( size_t i = 0; i < NUMBER_OF_CLOCKS; ++ i ) {
operationTimes += operations[i];
}
return operationTimes;
}

/**
* 获取最优的调整方案
* @param  clocks - 当前每个时钟的时间([0, 4)的整数)
* @param  bestOperations - 对各个时钟最佳操作的次数
* @return 每个操作进行次数的数组
*/
void getBestSolution(int* clocks, int* bestOperations) {
/**
* 存储时钟的初始状态.
* 用于回溯, 在搜索失败后的rollback.
*/
int mirrorClocks[NUMBER_OF_CLOCKS] = {0};

/**
* 存储对时钟的操作.
*/
int operations[NUMBER_OF_OPERATIONS][NUMBER_OF_CLOCKS] = {
{ 1, 1, 0, 1, 1, 0, 0, 0, 0 },
{ 1, 1, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 1, 1, 0, 1, 1, 0, 0, 0 },
{ 1, 0, 0, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 0, 1, 1, 1, 0, 1, 0 },
{ 0, 0, 1, 0, 0, 1, 0, 0, 1 },
{ 0, 0, 0, 1, 1, 0, 1, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 1, 1, 1 },
{ 0, 0, 0, 0, 1, 1, 0, 1, 1 }
};

/**
* 存储当前对各时钟操作的计数.
* 记录对每个时钟操作的次数.
*/
int currentOperations[NUMBER_OF_CLOCKS] = {0};

for ( size_t i = 0; i < NUMBER_OF_CLOCKS; ++ i ) {
mirrorClocks[i] = clocks[i];
}

for ( currentOperations[0] = 0 ; currentOperations[0] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[0] ) {
for ( currentOperations[1] = 0 ; currentOperations[1] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[1] ) {
for ( currentOperations[2] = 0 ; currentOperations[2] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[2] ) {
for ( currentOperations[3] = 0 ; currentOperations[3] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[3] ) {
for ( currentOperations[4] = 0 ; currentOperations[4] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[4] ) {
for ( currentOperations[5] = 0 ; currentOperations[5] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[5] ) {
for ( currentOperations[6] = 0 ; currentOperations[6] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[6] ) {
for ( currentOperations[7] = 0 ; currentOperations[7] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[7] ) {
for ( currentOperations[8] = 0 ; currentOperations[8] < MAX_NUMBER_OF_OPERATIONS; ++ currentOperations[8] ) {
// Rollback
for ( size_t i = 0; i < NUMBER_OF_CLOCKS; ++ i ) {
clocks[i] = mirrorClocks[i];
}

bool isSuccessful = true;
for ( size_t i = 0; i < NUMBER_OF_CLOCKS; ++ i ) {
for ( size_t j = 0; j < NUMBER_OF_OPERATIONS; ++ j ) {
clocks[i] += currentOperations[j] * operations[j][i];
}
clocks[i] %= 4;

if ( clocks[i] != 0 ) {
isSuccessful = false;
break;
}
}

if ( !isSuccessful ) {
continue;
}
// Save the solution
int currentOperationTimes = getOperationTimes(currentOperations);
int bestOperationTimes = getOperationTimes(bestOperations);
if ( currentOperationTimes < bestOperationTimes ) {
for ( size_t i = 0; i < NUMBER_OF_OPERATIONS; ++ i ) {
bestOperations[i] = currentOperations[i];
}
}
}
}
}
}
}
}
}
}
}
}

int main() {
/**
* 存储时钟当前的状态.
* 在搜索时不断改变.
*/
int clocks[NUMBER_OF_CLOCKS] = {0};

/**
* 存储当前对各时钟操作计数的最优解.
*/
int bestOperations[NUMBER_OF_OPERATIONS] = { 10, 10, 10, 10, 10, 10, 10, 10, 10 };

for ( size_t i = 0; i < NUMBER_OF_CLOCKS; ++ i ) {
std::cin >> clocks[i];
}

getBestSolution(clocks, bestOperations);

for ( size_t i = 0; i < NUMBER_OF_OPERATIONS; ++ i ) {
for ( int j = 0; j < bestOperations[i]; ++ j ) {
std::cout << ( i + 1 ) << " ";
}
}
std::cout << std::endl;
return 0;
}