首页 > 试题广场 >

附加题

[编程题]附加题
  • 热度指数：342 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
  • 算法知识视频讲解
二阶魔方又叫小魔方，是2*2*2的立方形结构。每一面都有4个块，共有24个块。每次操作可以将任意一面逆时针或者顺时针旋转90°，如将上面逆时针旋转90°操作如下。

Nero在小魔方上做了一些改动，用数字替换每个块上面的颜色，称之为数字魔方。魔方上每一面的优美度就是这个面上4个数字的乘积，而魔方的总优美度就是6个面优美度总和。
现在Nero有一个数字魔方，他想知道这个魔方在操作不超过5次的前提下能达到的最大优美度是多少。
魔方展开后每一块的序号如下图：

输入描述:
输入一行包含24个数字，按序号顺序给出魔方每一块上面的数字。所有数大小范围为[-100,100]。


输出描述:
输出一行包含一个数字，表示最大优美度。
示例1

输入

2 -3 -2 3 7 -6 -6 -7 9 -5 -9 -3 -2 1 4 -9 -1 -10 -5 -5 -10 -4 8 2

输出

8281
算法知识视频讲解
添加回答
霍七头像 霍七

【题解】最多五步，每一步都有6种可能，分别是前面，上面和右面顺时针或逆时针旋转90度。枚举就可以啦！

#include <iostream>
#include <algorithm>
using namespace std;
class Cube
{
    friend istream& operator>>(istream &in, Cube &obj);
private:
    int _up[4];
    int _down[4];
    int _left[4];
    int _right[4];
    int _front[4];
    int _back[4];
    int calnow() const;
    void upp();     // 上层顺时针旋转90度
    void upn();     // 上层逆时针旋转90度
    void rightp();  // 右层顺时针旋转90度
    void rightn();  // 右层逆时针旋转90度
    void frontp();  // 前层顺时针旋转90度
    void frontn();  // 前层逆时针旋转90度
public:
    int rotate(int) const;
};
istream& operator>>(istream &in, Cube &obj)
{
    in >> obj._up[0] >> obj._up[1] >> obj._up[2] >> obj._up[3];
    in >> obj._left[0] >> obj._left[1] >> obj._front[0] >> obj._front[1];
    in >> obj._right[0] >> obj._right[1] >> obj._left[2] >> obj._left[3];
    in >> obj._front[2] >> obj._front[3] >> obj._right[2] >> obj._right[3];
    in >> obj._down[0] >> obj._down[1] >> obj._down[2] >> obj._down[3];
    in >> obj._back[0] >> obj._back[1] >> obj._back[2] >> obj._back[3];
    return in;
}
int Cube::calnow() const
{
    int now[6] = { 1, 1, 1, 1, 1, 1 }, result = 0;
    for (int i = 0; i < 4; i++) {
        now[0] *= _up[i]; now[1] *= _down[i];
        now[2] *= _left[i]; now[3] *= _right[i];
        now[4] *= _front[i]; now[5] *= _back[i];
    }
    for (int i = 0; i < 6; i++) {
        result += now[i];
    }
    return result;
}
void Cube::upp()
{
    swap(_up[0], _up[1]);
    swap(_up[0], _up[3]);
    swap(_up[0], _up[2]);
    swap(_front[0], _left[0]); swap(_front[1], _left[1]);
    swap(_front[0], _back[3]); swap(_front[1], _back[2]);
    swap(_front[0], _right[0]); swap(_front[1], _right[1]);
}
void Cube::upn()
{
    swap(_up[0], _up[2]);
    swap(_up[0], _up[3]);
    swap(_up[0], _up[1]);
    swap(_front[0], _right[0]); swap(_front[1], _right[1]);
    swap(_front[0], _back[3]); swap(_front[1], _back[2]);
    swap(_front[0], _left[0]); swap(_front[1], _left[1]);
}
void Cube::rightp()
{
    swap(_right[0], _right[1]);
    swap(_right[0], _right[3]);
    swap(_right[0], _right[2]);
    swap(_front[1], _up[1]); swap(_front[3], _up[3]);
    swap(_front[1], _back[1]); swap(_front[3], _back[3]);
    swap(_front[1], _down[1]); swap(_front[3], _down[3]);
}
void Cube::rightn()
{
    swap(_right[0], _right[2]);
    swap(_right[0], _right[3]);
    swap(_right[0], _right[1]);
    swap(_front[1], _down[1]); swap(_front[3], _down[3]);
    swap(_front[1], _back[1]); swap(_front[3], _back[3]);
    swap(_front[1], _up[1]); swap(_front[3], _up[3]);
}
void Cube::frontp()
{
    swap(_front[0], _front[1]);
    swap(_front[0], _front[3]);
    swap(_front[0], _front[2]);
    swap(_up[2], _right[0]); swap(_up[3], _right[2]);
    swap(_up[2], _down[1]); swap(_up[3], _down[0]);
    swap(_up[2], _left[3]); swap(_up[3], _left[1]);
}
void Cube::frontn()
{
    swap(_front[0], _front[2]);
    swap(_front[0], _front[3]);
    swap(_front[0], _front[1]);
    swap(_up[2], _left[3]); swap(_up[3], _left[1]);
    swap(_up[2], _down[1]); swap(_up[3], _down[0]);
    swap(_up[2], _right[0]); swap(_up[3], _right[2]);
}
int Cube::rotate(int n) const
{
    Cube temp = *this;
    while (n != 0) {
        switch (n % 6)
        {
        case 1:temp.upp(); break;
        case 2:temp.upn(); break;
        case 3:temp.rightp(); break;
        case 4:temp.rightn(); break;
        case 5:temp.frontp(); break;
        default:temp.frontn(); break;
        }
        n /= 6;
    }
    return temp.calnow();
}

int main()
{
    Cube cube; cin >> cube;
    int result = 0;
    for (int i = 1; i < 7776; i++) {
        result = max(result, cube.rotate(i));
    }
    cout << result;
    return 0;
}
发表于 2017-12-26 20:04:15 回复(1)
wwxgo头像 wwxgo
代码比较简洁，关键点在于发现每次操作本质上都是选一个面，然后面上的四个数字转动一位，面边的8个数字各自移动两位。
对于有些题解里说的只转动三个面，其实是一种优化。因为平行的两个面，一个面左转90度，相当于另一个面右转90度的结果。我的代码中没有这个优化，而是选择6个面左右转的情况。 
#include <iostream>
#include <algorithm>
#include <vector>
#include <limits.h>
using namespace std;

int ans;

// 6个面的关联下标，每次选一个面，面上数字转动1位，面边位置移动2位
int pa[6][4] = { {0,1,3,2}, {4,5,11,10}, {6,7,13,12},
	{8,9,15,14}, {16,17,19,18}, {20,21,23,22} };
int side[6][8] = { {9,8,7,6,5,4,22,23}, {0,2,6,12,16,18,20,22}, {2,3,8,14,17,16,11,5},
	{3,1,23,21,19,17,13,7}, {12,13,14,15,21,20,10,11},{18,19,15,9,1,0,4,10} };

void dfs(vector<int> &data,int step)
{
	int sum = 0; // update ans
	for (int j = 0; j < 6; j++)
		sum += data[pa[j][0]] * data[pa[j][1]] * data[pa[j][2]] * data[pa[j][3]];
	ans = max(ans, sum);

	if (step >= 5) return;
	vector<int> temp(24);
	int dir = -1; // 正时针or逆时针
	while (1) {
		for (int i = 0; i < 6; i++) { // 选一个面
			for (int j = 0; j < 24; j++) temp[j] = data[j];
			for (int j = 0; j < 4; j++) // 面上的数字转动
				temp[pa[i][j]] = data[pa[i][(j + dir + 4) % 4]];
			for (int j = 0; j < 8; j++) // 面边上的数字转动
				temp[side[i][j]] = data[side[i][(j + dir * 2 + 8) % 8]];
			dfs(temp, step + 1);
		}
		if (dir > 0) break; else dir *= -1;
	}
	
}

int main()
{
	vector<int> data(24);
	for (int i = 0; i < 24; i++)
		cin >> data[i];
	ans = INT_MIN;
	dfs(data, 0);
	cout << ans;
	return 0;
}


编辑于 2020-08-16 10:27:01 回复(1)
南洋理工大学-LUWEI头像 南洋理工大学-LUWEI 
def compute(A):
    return A[0]*A[1]*A[2]*A[3] + A[4]*A[5]*A[10]*A[11] + A[6]*A[7]*A[12]*A[13] + A[8]*A[9]*A[14]*A[15] + A[16]*A[17]*A[18]*A[19] + A[20]*A[21]*A[22]*A[23]
 
def DS(A,i):
    if i == 0:
        return
#六种情况进行旋转，每次转动12个。
    A1 = A.copy()
    A1[1], A1[3],A1[7], A1[13], A1[17], A1[19],A1[21],A1[23],A1[8], A1[9],A1[14],A1[15] = A1[7], A1[13], A1[17], A1[19],A1[21],A1[23], A1[1], A1[3],A1[14], A1[8],A1[15],A1[9]
    res.append(compute(A1))
    DS(A1,i-1)
     
    A2 = A.copy()
    A2[1], A2[3],A2[7], A2[13], A2[17], A2[19],A2[21],A2[23],A2[8], A2[9],A2[14],A2[15] = A2[21],A2[23], A2[1], A2[3], A2[7], A2[13], A2[17],A2[19],A2[9], A2[15],A2[8],A2[14]
    res.append(compute(A2))
    DS(A2,i-1)
    
    A3 = A.copy()
    A3[4], A3[5], A3[6], A3[7], A3[8], A3[9], A3[23], A3[22],A3[0], A3[1], A3[2], A3[3] = A3[6], A3[7], A3[8], A3[9], A3[23], A3[22], A3[4], A3[5],A3[2], A3[0], A3[3], A3[1]
    res.append(compute(A3))
    DS(A3,i-1)
    
    A4 = A.copy()
    A4[4], A4[5], A4[6], A4[7], A4[8], A4[9], A4[23], A4[22],A4[0], A4[1], A4[2], A4[3] =  A4[23], A4[22], A4[4], A4[5], A4[6], A4[7], A4[8], A4[9],A4[1], A4[3], A4[0], A4[2]
    res.append(compute(A4))
    DS(A4,i-1)
    
    A5 = A.copy()
    A5[2], A5[3], A5[8], A5[14], A5[17], A5[16], A5[11], A5[5],A5[6], A5[7], A5[12], A5[13] = A5[8], A5[14], A5[17], A5[16], A5[11], A5[5], A5[2], A5[3], A5[7], A5[13], A5[6], A5[12]
    res.append(compute(A5))
    DS(A5,i-1)
     
    A6 = A.copy()
    A6[2], A6[3], A6[8], A6[14], A6[17], A6[16], A6[11], A6[5], A6[6], A6[7], A6[12], A6[13] =  A6[11], A6[5], A6[2], A6[3], A6[8], A6[14], A6[17], A6[16], A6[12], A6[6], A6[13], A6[7]
    res.append(compute(A6))
    DS(A6,i-1)
     
    i += -1
     
row= [int(i) for i in input().strip().split()]
res = [compute(row)]
i = 5
DS(row,i)
print(max(res))

发表于 2018-09-19 17:38:26 回复(0)
牛客50140947号头像 牛客50140947号
#include<iostream>
#include<climits>

using namespace std;

int ans=INT_MIN;

int calc(int* a){
    return a[0]*a[1]*a[2]*a[3]+a[4]*a[5]*a[10]*a[11]+a[6]*a[7]*a[12]*a[13]+a[8]*a[9]*a[14]*a[15]+a[16]*a[17]*a[18]*a[19]+a[20]*a[21]*a[22]*a[23];
}

void rotate(int *a, int step){
    ans = max(calc(a), ans);
    int b[24];
    for(int i=0;i<24;i++) b[i]=a[i];
    if(step == 0) return;
    for(int i=0;i<6;i++){
        for(int j=0;j<24;j++) a[j]=b[j];
        if(i==0){
            swap(a[6],a[7]);
            swap(a[6],a[13]);
            swap(a[6],a[12]);
            swap(a[5],a[3]);
            swap(a[11],a[2]);
            swap(a[5],a[14]);
            swap(a[11],a[8]);
            swap(a[5],a[16]);
            swap(a[11],a[17]);
        }
        if(i==1){
            swap(a[6],a[7]);
            swap(a[7],a[12]);
            swap(a[7],a[13]);
            swap(a[5],a[16]);
            swap(a[11],a[17]);
            swap(a[5],a[14]);
            swap(a[11],a[8]);
            swap(a[5],a[3]);
            swap(a[11],a[2]);
        }
        if(i==2){
            swap(a[0],a[1]);
            swap(a[0],a[3]);
            swap(a[0],a[2]);
            swap(a[4],a[23]);
            swap(a[5],a[22]);
            swap(a[4],a[8]);
            swap(a[5],a[9]);
            swap(a[4],a[6]);
            swap(a[5],a[7]);
        }
        if(i==3){
            swap(a[0],a[1]);
            swap(a[1],a[2]);
            swap(a[1],a[3]);
            swap(a[4],a[6]);
            swap(a[5],a[7]);
            swap(a[4],a[8]);
            swap(a[5],a[9]);
            swap(a[4],a[23]);
            swap(a[5],a[22]);
        }
        if(i==4){
            swap(a[4],a[5]);
            swap(a[4],a[11]);
            swap(a[4],a[10]);
            swap(a[22],a[2]);
            swap(a[20],a[0]);
            swap(a[22],a[12]);
            swap(a[20],a[6]);
            swap(a[22],a[18]);
            swap(a[20],a[16]);
        }
        if(i==5){
            swap(a[4],a[5]);
            swap(a[5],a[10]);
            swap(a[5],a[11]);
            swap(a[22],a[18]);
            swap(a[20],a[16]);
            swap(a[22],a[12]);
            swap(a[20],a[6]);
            swap(a[22],a[2]);
            swap(a[20],a[0]);
        }
        rotate(a,step-1);
    }
}

int main(){
    int a[24];
    for(int i=0;i<24;i++) cin>>a[i];
    rotate(a,5);
    cout<<ans<<endl;
    return 0;
}
发表于 2022-03-11 19:21:02 回复(0)
Racle头像 Racle

//

//  我也是调了一万年，发现只有三个面能转。

//  与上面几位思路不同，我是将几个面旋转之后的位置变化手动找出来，这样个人认为能省不少事，写代码转换也是要自己推一遍旋转，不如直接写来的有效率，代码如下。

//  InterView

//

//  Created by Racle on 2018/8/23.

//  Copyright © 2018年 Racle. All rights reserved.

//


#include <stdio.h>

#include <vector>

#include <set>

#include <iostream>

using namespace std;


set<vector<int>> s;

int next_[][24] = {

    {2,0,3,1,6,7,8,9,23,22,10,11,12,13,14,15,16,17,18,19,20,21,5,4},   //顶顺

    {1,3,0,2,23,22,4,5,6,7,10,11,12,13,14,15,16,17,18,19,20,21,9,8},   //顶逆

    {0,21,2,23,4,5,6,1,9,15,10,11,12,3,8,14,16,7,18,13,20,17,22,19},   //右下

    {0,7,2,13,4,5,6,17,14,8,10,11,12,19,15,9,16,21,18,23,20,1,22,3},   //右上

    {0,1,11,5,4,16,12,6,2,9,10,17,13,7,3,15,14,8,18,19,20,21,22,23},//前顺

    {0,1,8,14,4,3,7,13,17,9,10,2,6,12,16,15,5,11,18,19,20,21,22,23},//前逆

    

};

int btf(vector<int> &v){    //计算当前状态的优美度

    int arr[] = {0,1,2,3,4,5,10,11,6,7,12,13,8,9,14,15,16,17,18,19,20,21,22,23};

    int res = 0,k=1;

    for (int i=0; i<24; i++) {

        k *= v[arr[i]];

        if((i+1)%4==0){

            res += k;

            k=1;

        }

    }

    return res;

}


void turn(vector<int> v,int step,int &i_max){   //递归计算，由于限制了5次，时间和空间绝对够用

    if(step>5)  return ;

    i_max = max(i_max, btf(v)); //判断是否最大

    

    vector<int> record;

    for (int i=0; i<6; i++) {

        for (int j=0; j<24; j++) {

            record.push_back(v[next_[i][j]]);

        }

        turn(record, step+1, i_max);

        record.clear();

    }

}


int main(){

    int res = -2147483648,k;

    vector<int> v(24);

    for(int i=0; i<24; i++){

        cin>>k;

        v[i] = k;

    }

    turn(v, 0, res);

    cout<<res<<endl;

    return 0;

}



编辑于 2018-08-23 23:01:42 回复(0)
C/C++
yjk89446746头像 yjk89446746
代码调了不下十次，看了shiqito的AC代码才发现魔方6个面只有3个面能转？？？
那题目：每次操作可以将任意一面逆时针或者顺时针旋转90°，这**坑人啊？？？
注释掉3个面，果然能过了....无语 
#include<iostream>
using namespace std;
int sum(int *a){
    
    int sum=0;
    sum+=a[0]*a[1]*a[2]*a[3];
    sum+=a[4]*a[5]*a[10]*a[11];
    sum+=a[6]*a[7]*a[12]*a[13];
    sum+=a[8]*a[9]*a[14]*a[15];
    sum+=a[16]*a[17]*a[18]*a[19];
    sum+=a[20]*a[21]*a[22]*a[23];
    return sum;
}
static int Max=0;
void move1(int *a){
    int buf[8]={0,2,6,12,16,18,20,22};
    int tmp=a[buf[0]],tmpp=a[buf[1]];
    for (int i=0; i<6; i+=2) {
        a[buf[i]]=a[buf[i+2]];
        a[buf[i+1]]=a[buf[i+3]];
    }
    a[buf[7]]=tmpp;
    a[buf[6]]=tmp;
    int buff[4]={5,11,10,4};
    tmp=a[buff[0]];
    for (int i=0; i<3; i++) {
        a[buff[i]]=a[buff[i+1]];
    }
    a[buff[3]]=tmp;
    return;
}
void demove1(int *a){
    int buf[8]={0,2,6,12,16,18,20,22};
    int tmp=a[buf[6]],tmpp=a[buf[7]];;
    for (int i=7; i>1; i-=2) {
        a[buf[i]]=a[buf[i-2]];
        a[buf[i-1]]=a[buf[i-3]];
    }
    a[buf[0]]=tmp;
    a[buf[1]]=tmpp;
    int buff[4]={5,11,10,4};
    tmp=a[buff[3]];
    for (int i=3; i>0; i--) {
        a[buff[i]]=a[buff[i-1]];
    }
    a[buff[0]]=tmp;
    return;
}
void move2(int *a){
    int buf[8]={1,3,7,13,17,19,21,23};
    int tmp=a[buf[0]],tmpp=a[buf[1]];
    for (int i=0; i<6; i+=2) {
        a[buf[i]]=a[buf[i+2]];
        a[buf[i+1]]=a[buf[i+3]];
    }
    a[buf[7]]=tmpp;
    a[buf[6]]=tmp;
    int buff[4]={8,14,15,9};
    tmp=a[buff[0]];
    for (int i=0; i<3; i++) {
        a[buff[i]]=a[buff[i+1]];
    }
    a[buff[3]]=tmp;
    return;
}
void demove2(int *a){
    int buf[8]={1,3,7,13,17,19,21,23};
    int tmp=a[buf[6]],tmpp=a[buf[7]];;
    for (int i=7; i>1; i-=2) {
        a[buf[i]]=a[buf[i-2]];
        a[buf[i-1]]=a[buf[i-3]];
    }
    a[buf[0]]=tmp;
    a[buf[1]]=tmpp;
    int buff[4]={8,14,15,9};
    tmp=a[buff[3]];
    for (int i=3; i>0; i--) {
        a[buff[i]]=a[buff[i-1]];
    }
    a[buff[0]]=tmp;
    return;
}
void move3(int *a){
    int buf[8]={4,5,6,7,8,9,23,22};
    int tmp=a[buf[0]],tmpp=a[buf[1]];
    for (int i=0; i<6; i+=2) {
        a[buf[i]]=a[buf[i+2]];
        a[buf[i+1]]=a[buf[i+3]];
    }
    a[buf[7]]=tmpp;
    a[buf[6]]=tmp;
    int buff[4]={0,2,3,1};
    tmp=a[buff[0]];
    for (int i=0; i<3; i++) {
        a[buff[i]]=a[buff[i+1]];
    }
    a[buff[3]]=tmp;
    return;
}
void demove3(int *a){
    int buf[8]={4,5,6,7,8,9,23,22};
    int tmp=a[buf[6]],tmpp=a[buf[7]];;
    for (int i=7; i>1; i-=2) {
        a[buf[i]]=a[buf[i-2]];
        a[buf[i-1]]=a[buf[i-3]];
    }
    a[buf[0]]=tmp;
    a[buf[1]]=tmpp;
    int buff[4]={0,2,3,1};
    tmp=a[buff[3]];
    for (int i=3; i>0; i--) {
        a[buff[i]]=a[buff[i-1]];
    }
    a[buff[0]]=tmp;
    return;
}
void move4(int *a){
    int buf[8]={10,11,12,13,14,15,21,20};
    int tmp=a[buf[0]],tmpp=a[buf[1]];
    for (int i=0; i<6; i+=2) {
        a[buf[i]]=a[buf[i+2]];
        a[buf[i+1]]=a[buf[i+3]];
    }
    a[buf[7]]=tmpp;
    a[buf[6]]=tmp;
    int buff[4]={17,19,18,16};
    tmp=a[buff[0]];
    for (int i=0; i<3; i++) {
        a[buff[i]]=a[buff[i+1]];
    }
    a[buff[3]]=tmp;
    return;
}
void demove4(int *a){
    int buf[8]={10,11,12,13,14,15,21,20};
    int tmp=a[buf[6]],tmpp=a[buf[7]];;
    for (int i=7; i>1; i-=2) {
        a[buf[i]]=a[buf[i-2]];
        a[buf[i-1]]=a[buf[i-3]];
    }
    a[buf[0]]=tmp;
    a[buf[1]]=tmpp;
    int buff[4]={17,19,18,16};
    tmp=a[buff[3]];
    for (int i=3; i>0; i--) {
        a[buff[i]]=a[buff[i-1]];
    }
    a[buff[0]]=tmp;
    return;
}
void move5(int *a){
    int buf[8]={2,3,8,14,17,16,11,5};
    int tmp=a[buf[0]],tmpp=a[buf[1]];
    for (int i=0; i<6; i+=2) {
        a[buf[i]]=a[buf[i+2]];
        a[buf[i+1]]=a[buf[i+3]];
    }
    a[buf[7]]=tmpp;
    a[buf[6]]=tmp;
    int buff[4]={7,13,12,6};
    tmp=a[buff[0]];
    for (int i=0; i<3; i++) {
        a[buff[i]]=a[buff[i+1]];
    }
    a[buff[3]]=tmp;
    return;
}
void demove5(int *a){
    int buf[8]={2,3,8,14,17,16,11,5};
    int tmp=a[buf[6]],tmpp=a[buf[7]];;
    for (int i=7; i>1; i-=2) {
        a[buf[i]]=a[buf[i-2]];
        a[buf[i-1]]=a[buf[i-3]];
    }
    a[buf[0]]=tmp;
    a[buf[1]]=tmpp;
    int buff[4]={7,13,12,6};
    tmp=a[buff[3]];
    for (int i=3; i>0; i--) {
        a[buff[i]]=a[buff[i-1]];
    }
    a[buff[0]]=tmp;
    return;
}
void move6(int *a){
    int buf[8]={0,1,9,15,19,18,10,4};
    int tmp=a[buf[0]],tmpp=a[buf[1]];
    for (int i=0; i<6; i+=2) {
        a[buf[i]]=a[buf[i+2]];
        a[buf[i+1]]=a[buf[i+3]];
    }
    a[buf[7]]=tmpp;
    a[buf[6]]=tmp;
    int buff[4]={21,23,22,22};
    tmp=a[buff[0]];
    for (int i=0; i<3; i++) {
        a[buff[i]]=a[buff[i+1]];
    }
    a[buff[3]]=tmp;
    return;
}
void demove6(int *a){
    int buf[8]={0,1,9,15,19,18,10,4};
    int tmp=a[buf[6]],tmpp=a[buf[7]];;
    for (int i=7; i>1; i-=2) {
        a[buf[i]]=a[buf[i-2]];
        a[buf[i-1]]=a[buf[i-3]];
    }
    a[buf[0]]=tmp;
    a[buf[1]]=tmpp;
    int buff[4]={21,23,22,20};
    tmp=a[buff[3]];
    for (int i=3; i>0; i--) {
        a[buff[i]]=a[buff[i-1]];
    }
    a[buff[0]]=tmp;
    return;
}
void move(int *a,int t){
    int tmp = sum(a);
    if(tmp>Max)Max=tmp;
    if(t==0){
        return;
    }else{
//        move1(a);
//        move(a,t-1);
//        demove1(a);
        move2(a);
        move(a,t-1);
        demove2(a);
        move3(a);
        move(a,t-1);
        demove3(a);
//        move4(a);
//        move(a,t-1);
//        demove4(a);
        move5(a);
        move(a,t-1);
        demove5(a);
//        move6(a);
//        move(a,t-1);
//        demove6(a);
        
//        demove1(a);
//        move(a,t-1);
//        move1(a);
        demove2(a);
        move(a,t-1);
        move2(a);
        demove3(a);
        move(a,t-1);
        move3(a);
//        demove4(a);
//        move(a,t-1);
//        move4(a);
        demove5(a);
        move(a,t-1);
        move5(a);
//        demove6(a);
//        move(a,t-1);
//        move6(a);
    }
}
int main(){
    int a[24]={0};
    int i=0;
    while (i<24) {
        cin>>a[i];
        i++;
    }
    move(a,5);
    cout<<Max;
    return 0;
}

编辑于 2018-08-05 16:54:35 回复(0)
苏打饼干加干酪头像 苏打饼干加干酪 
#include<iostream>
#include<cmath>
using namespace std;
class cubic
{
    int a[24] = { 0 };
public:
    cubic(int ab[24])
    {
        for (int i = 0; i<24; i++)
            a[i] = ab[i];
        return;
    }
    int BeautyNum()
    {
        int sum = 0;
        sum += a[0] * a[1] * a[2] * a[3];
        sum += a[4] * a[5] * a[10] * a[11];
        sum += a[6] * a[7] * a[12] * a[13];
        sum += a[8] * a[9] * a[14] * a[15];
        sum += a[16] * a[17] * a[18] * a[19];
        sum += a[20] * a[21] * a[22] * a[23];
        return sum;
    }
    void TurnLeft()
    {
        int m, n;
        m = a[2]; n = a[3];
        a[2] = a[11]; a[3] = a[5];
        a[11] = a[17]; a[5] = a[16];
        a[17] = a[8]; a[16] = a[14];
        a[8] = m; a[14] = n;

        m = a[6]; 
        a[6] = a[12];
        a[12] = a[13];
        a[13] = a[7];
        a[7] = m;
        
        return;
    }
    void TurnRight()
    {
        int m, n;
        m = a[2]; n = a[3];
        a[2] = a[8]; a[3] = a[14];
        a[8] = a[17]; a[14] = a[16];
        a[17] = a[11]; a[16] = a[5];
        a[11] = m; a[5] = n;

        m = a[6];
        a[6] = a[7];
        a[7] = a[13];
        a[13] = a[12];
        a[12] = m;
        return;

    }
    void TurnUp()
    {
        int m, n;
        m = a[1]; n = a[3];
        a[1] = a[7]; a[3] = a[13];
        a[7] = a[17]; a[13] = a[19];
        a[17] = a[21]; a[19] = a[23];
        a[21] = m; a[23] = n;

        m = a[14];
        a[14] = a[15];
        a[15] = a[9];
        a[9] = a[8];
        a[8] = m;
        return;
    }
    void TurnDown()
    {
        int m, n;
        m = a[1]; n = a[3];
        a[1] = a[21]; a[3] = a[23];
        a[21] = a[17]; a[23] = a[19];
        a[17] = a[7]; a[19] = a[13];
        a[7] = m; a[13] = n;

        m = a[14];
        a[14] = a[8];
        a[8] = a[9];
        a[9] = a[15];
        a[15] = m;
        return;
    }
    void TurnClock()
    {
        int m, n;
        m = a[12]; n = a[13];
        a[12] = a[10]; a[13] = a[11];
        a[10] = a[21]; a[11] = a[20];
        a[21] = a[14]; a[20] = a[15];
        a[14] = m; a[15] = n;

        m = a[16];
        a[16] = a[18];
        a[18] = a[19];
        a[19] = a[17];
        a[17] = m;
        return;
    }    
    void TurnAnti()
    {
        int m, n;
        m = a[12]; n = a[13];
        a[12] = a[14]; a[13] = a[15];
        a[14] = a[21]; a[15] = a[20];
        a[21] = a[10]; a[20] = a[11];
        a[10] = m; a[11] = n;
        m = a[16];
        a[16] = a[17];
        a[17] = a[19];
        a[19] = a[18];
        a[18] = m;
        return;
    }


};
int max(int a[],int m)
{
    int size = m;
    int max = a[0];
    for (int i = 1; i<size; i++)
    {
        if (max<a[i])
            max = a[i];
    }
    return max;
}
int TurnBeauty(cubic mc, int k)
{
    if (k == 0)
    {
        return mc.BeautyNum();
    }
    else
    {
        cubic m1 = mc, m2 = mc, m3 = mc, m4 = mc, m5 = mc, m6 = mc;
        int n[7],m=7;
        m1.TurnLeft();
        n[0] = TurnBeauty(m1, k - 1);
        m2.TurnRight();
        n[1] = TurnBeauty(m2, k - 1);
        m3.TurnUp();
        n[2] = TurnBeauty(m3, k - 1);
        m4.TurnDown();
        n[3] = TurnBeauty(m4, k - 1);
        m5.TurnClock();
        n[4] = TurnBeauty(m5, k - 1);
        m6.TurnAnti();
        n[5] = TurnBeauty(m6, k - 1);
        n[6] = mc.BeautyNum();
        return max(n,m);
    }
}
int main()
{
    int a[24] ;
    for (int i = 0; i<24; i++)
        cin >> a[i];
    cubic mc(a);
    cout << TurnBeauty(mc, 5);
    return 0;
}

发表于 2018-08-28 18:02:05 回复(0)
提交观点

问题信息

模拟 穷举 算法工程师 2018 字节跳动 递归
上传者：小小
难度：
7条回答 2296浏览

热门推荐

通过挑战的用户

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号