叠盒子的问题

最新推荐文章于 2024-05-25 12:48:15 发布

sinall

最新推荐文章于 2024-05-25 12:48:15 发布

阅读量1.2k

点赞数

分类专栏： Algorithm 文章标签： colors vector iostream c iterator each

本文链接：https://blog.csdn.net/sinall/article/details/1670837

版权

Algorithm 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

题目

见 http://community.csdn.net/Expert/TopicView3.asp?id=5623795
You have four colored cubes. Each side of each cube is a single color,
and there are four colors: blue (B), red (R), green (G) and yellow (Y).
Describing the six faces as front, back, left, right, top, bottom,
the cube colors are:

Cube Front Back Left Right Top Bottom
1 R B G Y B Y
2 R G G Y B B
3 Y B R G Y R
4 Y G B R R R

The objective is to find ways to stack the four cubes as a vertical column
so that each side of the column is showing all four colors. In a programming
language of your choice, write a program to find all successful permutations.

Please submit the following:
1. Initial estimate of time required for the task
2. Actual time taken for the task
3. Any assumptions you made
4. Source code of solution (preferably with Unit Test code)

解答

#include < iostream >

#include < vector >

#include < map >

#include < algorithm >

#include < iterator >

using namespace std;

typedef vector < int > Cuba; // 盒子

typedef vector < Cuba > Cuba_Copy; // 盒子的各种状态，用类似“前左后右上下”的方式表示

typedef vector < Cuba > Stack; // 堆起来的盒子

void init_stack(Stack & _stack);

void get_all_copies( const Stack & _stack, Cuba_Copy & cc); // 获取盒子的各种状态

void test_all_possibilities( const Stack & _stack); // 测试各种状态的盒子堆起来的是否满足要求

bool valid_stack( const Stack & _stack); // 测试某一种可能的状态是否满足要求，下同

bool valid_stack( const Cuba & c1, const Cuba & c2, const Cuba & c3, const Cuba & c4);

ostream & operator << (ostream & os, const Cuba & cuba); // 打印盒子状态

int main( void )

{

Stack _stack;

init_stack(_stack);

test_all_possibilities(_stack);

return 0;

}

void init_stack(Stack & _stack)

{

Cuba cuba1(6); // BRGY 1，2，4，8表示

cuba1[0] = 2;

cuba1[1] = 1;

cuba1[2] = 4;

cuba1[3] = 8;

cuba1[4] = 1;

cuba1[5] = 8;

_stack.push_back(cuba1);

cuba1[0] = 2;

cuba1[1] = 4;

cuba1[2] = 4;

cuba1[3] = 8;

cuba1[4] = 1;

cuba1[5] = 1;

_stack.push_back(cuba1);

cuba1[0] = 8;

cuba1[1] = 1;

cuba1[2] = 2;

cuba1[3] = 4;

cuba1[4] = 8;

cuba1[5] = 2;

_stack.push_back(cuba1);

cuba1[0] = 8;

cuba1[1] = 4;

cuba1[2] = 1;

cuba1[3] = 2;

cuba1[4] = 2;

cuba1[5] = 2;

_stack.push_back(cuba1);

}

void get_all_copies( const Cuba & cuba, Cuba_Copy & cc)

{

cout << "get all copies of Cuba " << cuba << endl

<< "F,L,B,R,T,B," << endl

<< "------------" << endl;

for (int i = 0; i < 3; ++i)

{

Cuba temp(cuba);

rotate(temp.begin(), temp.begin() + 2*i, temp.end());

swap(temp[1], temp[2]); // 比如前后左右，必须搞成前左后右才能用rotate的方法获得4种不同的状态。

for (int j = 0; j < 4; ++j)

{

rotate(temp.begin(), temp.begin() + 1, temp.begin() + 4);

cc.push_back(temp);

cout << temp << endl;

swap(temp[1], temp[2]); // 上下颠倒后，左右也颠倒了

swap(temp[4], temp[5]); // 上下颠倒

cc.push_back(temp);

cout << temp << endl;

}

void test_all_possibilities( const Stack & _stack)

{

int count = 0;

vector<Cuba_Copy> v_cc(4);

for (int i = 0; i < 4; ++i)

{

get_all_copies(_stack[i], v_cc[i]);

}

for (int i1 = 0; i1 < v_cc[0].size(); ++i1)

{

for (int i2 = 0; i2 < v_cc[1].size(); ++i2)

{

for (int i3 = 0; i3 < v_cc[2].size(); ++i3)

{

for (int i4 = 0; i4 < v_cc[3].size(); ++i4)

{

if (valid_stack(v_cc[0][i1], v_cc[1][i2], v_cc[2][i3], v_cc[3][i4]))

{

cout << "validating " << endl

<< v_cc[0][i1] << endl

<< v_cc[1][i2] << endl

<< v_cc[2][i3] << endl

<< v_cc[3][i4] << endl;

++count;

}

cout << "There are " << count << " successful cases." << endl;

}

// 每面和为15才能保证该面有4色。

bool valid_stack( const Cuba & c1, const Cuba & c2, const Cuba & c3, const Cuba & c4)

{

return (c1[0] + c2[0] + c3[0] + c4[0] == 15)

&& (c1[1] + c2[1] + c3[1] + c4[1] == 15)

&& (c1[2] + c2[2] + c3[2] + c4[2] == 15)

&& (c1[3] + c2[3] + c3[3] + c4[3] == 15);

}

bool valid_stack( const Stack & _stack)

{

return (_stack[0][0] + _stack[1][0] + _stack[2][0] + _stack[3][0] == 15)

&& (_stack[0][1] + _stack[1][1] + _stack[2][1] + _stack[3][1] == 15)

&& (_stack[0][2] + _stack[1][2] + _stack[2][2] + _stack[3][2] == 15)

&& (_stack[0][3] + _stack[1][3] + _stack[2][3] + _stack[3][3] == 15);

}

ostream & operator << (ostream & os, const Cuba & cuba)

{

static map<int, char> map_color;

static bool init = false;

if (!init)

{

map_color[1] = 'B';

map_color[2] = 'R';

map_color[4] = 'G';

map_color[8] = 'Y';

}

cout << map_color[cuba[0]] << ","

<< map_color[cuba[1]] << ","

<< map_color[cuba[2]] << ","

<< map_color[cuba[3]] << ","

<< map_color[cuba[4]] << ","

<< map_color[cuba[5]] << ",";

return os;

}