USACO: The Clocks

最新推荐文章于 2018-02-25 11:52:20 发布

原创最新推荐文章于 2018-02-25 11:52:20 发布 · 413 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#numbers #each #table #output #file #input

force-solution 专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一个关于九个钟的算法题目，目标是通过最少的操作步骤将所有钟的时间调整到12点整。提供了完整的C++代码实现，并通过暴力搜索的方式解决了问题，最终实现了所有测试案例的正确解答。

The Clocks
IOI'94 - Day 2 Consider nine clocks arranged in a 3x3 array thusly:

|-------|    |-------|    |-------|    
|       |    |       |    |   |   |    
|---O   |    |---O   |    |   O   |          
|       |    |       |    |       |           
|-------|    |-------|    |-------|    
    A            B            C

|-------|    |-------|    |-------|
|       |    |       |    |       |
|   O   |    |   O   |    |   O   |
|   |   |    |   |   |    |   |   |
|-------|    |-------|    |-------|
    D            E            F

|-------|    |-------|    |-------|
|       |    |       |    |       |
|   O   |    |   O---|    |   O   |
|   |   |    |       |    |   |   |
|-------|    |-------|    |-------|
    G            H            I

The goal is to find a minimal sequence of moves to return all the dials to 12 o'clock. Nine different ways to turn the dials on the clocks are supplied via a table below; each way is called a move. Select for each move a number 1 through 9 which will cause the dials of the affected clocks (see next table) to be turned 90 degrees clockwise.

Move	Affected clocks
1	ABDE
2	ABC
3	BCEF
4	ADG
5	BDEFH
6	CFI
7	DEGH
8	GHI
9	EFHI

Example

Each number represents a time accoring to following table:

9 9 12       9 12 12       9 12 12        12 12 12      12 12 12 
6 6 6  5 ->  9  9  9  8->  9  9  9  4 ->  12  9  9  9-> 12 12 12 
6 3 6        6  6  6       9  9  9        12  9  9      12 12 12

[But this might or might not be the `correct' answer; see below.]

PROGRAM NAME: clocks

INPUT FORMAT

Lines 1-3:

Three lines of three space-separated numbers; each number represents the start time of one clock, 3, 6, 9, or 12. The ordering of the numbers corresponds to the first example above.

SAMPLE INPUT (file clocks.in)

9 9 12
6 6 6
6 3 6

OUTPUT FORMAT

A single line that contains a space separated list of the shortest sequence of moves (designated by numbers) which returns all the clocks to 12:00. If there is more than one solution, print the one which gives the lowest number when the moves are concatenated (e.g., 5 2 4 6 < 9 3 1 1).

SAMPLE OUTPUT (file clocks.out)

4 5 8 9

  总结：这道题估摸着用暴力能过，所以直接写了，不过写起来还真挺麻烦的

/*
ID: geterns1
PROG: clocks
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

void move1(int clk[][3]){
	clk[0][0] = (clk[0][0] + 3) % 12;
	clk[0][1] = (clk[0][1] + 3) % 12;
//	clk[0][2] = (clk[0][2] + 3) % 12;
	clk[1][0] = (clk[1][0] + 3) % 12;
	clk[1][1] = (clk[1][1] + 3) % 12;
//	clk[1][2] = (clk[1][2] + 3) % 12;
//	clk[2][0] = (clk[2][0] + 3) % 12;
//	clk[2][1] = (clk[2][1] + 3) % 12;
//	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move2(int clk[][3]){
	clk[0][0] = (clk[0][0] + 3) % 12;
	clk[0][1] = (clk[0][1] + 3) % 12;
	clk[0][2] = (clk[0][2] + 3) % 12;
//	clk[1][0] = (clk[1][0] + 3) % 12;
//	clk[1][1] = (clk[1][1] + 3) % 12;
//	clk[1][2] = (clk[1][2] + 3) % 12;
//	clk[2][0] = (clk[2][0] + 3) % 12;
//	clk[2][1] = (clk[2][1] + 3) % 12;
//	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move3(int clk[][3]){
//	clk[0][0] = (clk[0][0] + 3) % 12;
	clk[0][1] = (clk[0][1] + 3) % 12;
	clk[0][2] = (clk[0][2] + 3) % 12;
//	clk[1][0] = (clk[1][0] + 3) % 12;
	clk[1][1] = (clk[1][1] + 3) % 12;
	clk[1][2] = (clk[1][2] + 3) % 12;
//	clk[2][0] = (clk[2][0] + 3) % 12;
//	clk[2][1] = (clk[2][1] + 3) % 12;
//	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move4(int clk[][3]){
	clk[0][0] = (clk[0][0] + 3) % 12;
//	clk[0][1] = (clk[0][1] + 3) % 12;
//	clk[0][2] = (clk[0][2] + 3) % 12;
	clk[1][0] = (clk[1][0] + 3) % 12;
//	clk[1][1] = (clk[1][1] + 3) % 12;
//	clk[1][2] = (clk[1][2] + 3) % 12;
	clk[2][0] = (clk[2][0] + 3) % 12;
//	clk[2][1] = (clk[2][1] + 3) % 12;
//	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move5(int clk[][3]){
//	clk[0][0] = (clk[0][0] + 3) % 12;
	clk[0][1] = (clk[0][1] + 3) % 12;
//	clk[0][2] = (clk[0][2] + 3) % 12;
	clk[1][0] = (clk[1][0] + 3) % 12;
	clk[1][1] = (clk[1][1] + 3) % 12;
	clk[1][2] = (clk[1][2] + 3) % 12;
//	clk[2][0] = (clk[2][0] + 3) % 12;
	clk[2][1] = (clk[2][1] + 3) % 12;
//	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move6(int clk[][3]){
//	clk[0][0] = (clk[0][0] + 3) % 12;
//	clk[0][1] = (clk[0][1] + 3) % 12;
	clk[0][2] = (clk[0][2] + 3) % 12;
//	clk[1][0] = (clk[1][0] + 3) % 12;
//	clk[1][1] = (clk[1][1] + 3) % 12;
	clk[1][2] = (clk[1][2] + 3) % 12;
//	clk[2][0] = (clk[2][0] + 3) % 12;
//	clk[2][1] = (clk[2][1] + 3) % 12;
	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move7(int clk[][3]){
//	clk[0][0] = (clk[0][0] + 3) % 12;
//	clk[0][1] = (clk[0][1] + 3) % 12;
//	clk[0][2] = (clk[0][2] + 3) % 12;
	clk[1][0] = (clk[1][0] + 3) % 12;
	clk[1][1] = (clk[1][1] + 3) % 12;
//	clk[1][2] = (clk[1][2] + 3) % 12;
	clk[2][0] = (clk[2][0] + 3) % 12;
	clk[2][1] = (clk[2][1] + 3) % 12;
//	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move8(int clk[][3]){
//	clk[0][0] = (clk[0][0] + 3) % 12;
//	clk[0][1] = (clk[0][1] + 3) % 12;
//	clk[0][2] = (clk[0][2] + 3) % 12;
//	clk[1][0] = (clk[1][0] + 3) % 12;
//	clk[1][1] = (clk[1][1] + 3) % 12;
//	clk[1][2] = (clk[1][2] + 3) % 12;
	clk[2][0] = (clk[2][0] + 3) % 12;
	clk[2][1] = (clk[2][1] + 3) % 12;
	clk[2][2] = (clk[2][2] + 3) % 12;
}
void move9(int clk[][3]){
//	clk[0][0] = (clk[0][0] + 3) % 12;
//	clk[0][1] = (clk[0][1] + 3) % 12;
//	clk[0][2] = (clk[0][2] + 3) % 12;
//	clk[1][0] = (clk[1][0] + 3) % 12;
	clk[1][1] = (clk[1][1] + 3) % 12;
	clk[1][2] = (clk[1][2] + 3) % 12;
//	clk[2][0] = (clk[2][0] + 3) % 12;
	clk[2][1] = (clk[2][1] + 3) % 12;
	clk[2][2] = (clk[2][2] + 3) % 12;
}

bool check(int clk[][3]){
	if (clk[0][0] != 0)
		return false;
	if (clk[0][1] != 0)
		return false;
	if (clk[0][2] != 0)
		return false;
	if (clk[1][0] != 0)
		return false;
	if (clk[1][1] != 0)
		return false;
	if (clk[1][2] != 0)
		return false;
	if (clk[2][0] != 0)
		return false;
	if (clk[2][1] != 0)
		return false;
	if (clk[2][2] != 0)
		return false;
	return true;
}

int main(){

ifstream ifs("clocks.in");
	ofstream ofs("clocks.out");
	int clocks[3][3];
	for (int i = 0; i < 3; i ++){
		for (int j = 0; j < 3; j ++){
			ifs >> clocks[i][j];
			clocks[i][j] %= 12;
		}
	}

void (* funPtr[9])(int [][3]) = { move1, move2, move3, move4, move5, move6, move7, move8, move9 };

int cpyCl[3][3];
	int times[9];
	for (times[0] = 0; times[0] < 4; times[0] ++){
		for (times[1] = 0; times[1] < 4; times[1] ++){
			for (times[2] = 0; times[2] < 4; times[2] ++){
				for (times[3] = 0; times[3] < 4; times[3] ++){
					for (times[4] = 0; times[4] < 4; times[4] ++){
						for (times[5] = 0; times[5] < 4; times[5] ++){
							for (times[6] = 0; times[6] < 4; times[6] ++){
								for (times[7] = 0; times[7] < 4; times[7] ++){
									for (times[8] = 0; times[8] < 4; times[8] ++){
										for (int i = 0; i < 3; i ++){
											for (int j = 0; j < 3; j ++){
												cpyCl[i][j] = clocks[i][j];
											}
										}
										for (int i = 0; i < 9; i ++){
											for (int j = 0; j < times[i]; j ++){
												funPtr[i](cpyCl);
											}
										}
										if (check(cpyCl)){
											bool first = true;
											for (int i = 0; i < 9; i ++){
												for (int j = 0; j < times[i]; j ++){
													if (first){
														ofs << i + 1;
														first = false;
													}
													else{
														ofs << " " << i + 1;
													}
												}
											}
											goto END;
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}

END:
	ofs << endl;

ifs.close();
	ofs.close();

return 0;
}

USER: Geterns Liu [geterns1]
TASK: clocks
LANG: C++

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.000 secs, 3016 KB]
   Test 2: TEST OK [0.000 secs, 3016 KB]
   Test 3: TEST OK [0.119 secs, 3016 KB]
   Test 4: TEST OK [0.043 secs, 3016 KB]
   Test 5: TEST OK [0.119 secs, 3016 KB]
   Test 6: TEST OK [0.119 secs, 3016 KB]
   Test 7: TEST OK [0.130 secs, 3016 KB]
   Test 8: TEST OK [0.140 secs, 3016 KB]
   Test 9: TEST OK [0.184 secs, 3016 KB]

All tests OK.
Your program ('clocks') produced all correct answers!  This is your
submission #5 for this problem.  Congratulations!

Here are the test data inputs:

------- test 1 -------
9 9 12
6 6 6
6 3 6
------- test 2 -------
12 9 12
9 9 9
12 9 12
------- test 3 -------
6 9 3
3 3 9
12 12 12
------- test 4 -------
9 3 9
9 9 9
9 9 9
------- test 5 -------
6 12 12
12 12 12
12 12 12
------- test 6 -------
3 12 9
6 6 6
12 12 12
------- test 7 -------
12 3 3
3 6 6
12 3 6
------- test 8 -------
12 3 9
9 12 12
3 6 9
------- test 9 -------
9 12 9
12 3 12
9 12 9

Keep up the good work!

Thanks for your submission!