首页 > 试题广场 >

附加题

[编程题]附加题

热度指数：1879 时间限制：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

输出

算法知识视频讲解

Python

牛客155955564号

def top1(a):
a[0], a[1], a[4], a[22], a[23], a[9], a[10], a[20], a[21], a[15], a[18], a[19] =
a[10], a[4], a[18], a[20], a[22], a[0], a[19], a[21], a[23], a[1], a[15], a[9]
def top2(a):
top1(a), top1(a), top1(a)
def left1(a):
a[22], a[20], a[0], a[4], a[10], a[18], a[2], a[5], a[11], a[16], a[6], a[12] =
a[2], a[0], a[6], a[5], a[4], a[22], a[12], a[11], a[10], a[20], a[16], a[18]
def left2(a):
left1(a), left1(a), left1(a)
def back1(a):
a[23], a[22], a[9], a[1], a[0], a[4], a[8], a[3], a[2], a[5], a[7], a[6] =
a[8], a[9], a[7], a[3], a[1], a[23], a[6], a[2], a[0], a[22], a[5], a[4]
def back2(a):
back1(a), back1(a), back1(a)
def get_sum(a):
return a[0] * a[1] * a[2] *a[3] + a[6] * a[7] * a[12] * a[13] +
a[4] * a[5] * a[10] * a[11] + 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 change(a, n):
if n == 5:
return get_sum(a)
top1(a)
c1 = change(a, n+1)
top2(a)
top2(a)
c2 = change(a, n+1)
top1(a)
back1(a)
c3 = change(a, n+1)
back2(a)
back2(a)
c4 = change(a, n+1)
back1(a)
left1(a)
c5 = change(a, n+1)
left2(a)
left2(a)
c6 = change(a, n+1)
left1(a)
return max(c1, c2, c3, c4, c5, c6, get_sum(a))

if name == 'main':
a = list(map(int, input().split()))
print(max(change(a, 0), get_sum(a)))

发表于 2020-08-12 16:35:01 回复(0)

Python

阿耀哥

解题思路：首先说，我有点无耻了。程序验证没通过。但是我也监测实在是太困难了。我只能说我尽力了。我说说我的思路，哪位大神看看能帮我找出错在哪里了拜托拜托

1、首先写了一个函数y0，专门负责旋转魔方的。一共有6种旋转模式。分别列出了旋转后的置换结果。

2、又是挺无耻的，没写成放回的全排列，直接把所有的排列可能用循环写了。好在仅转动 5次。每次转动都有6种旋转模式。就是 6*6*6*6*6种全排列。

3、为了提高点效率，我把上述可能的结果做了筛查。

例如【0,0,0,0,1】的，这就是说，同一旋转模式连续4次。连续4次，相当于没动。则把4次连续的删掉。保留【1】。

还有一种可能，就是连续两次旋转的方向刚好相反，可以视为无效。即，如果是（0,1）（1,0）（4,5）（5,4）（2,3）（3,2）都是这样的情况。判断是可以通过

(a+b) in [1,9]&nbs***bsp;((a+b)==5 and (a in [2,3]))

因为和为5 有多种可能性。

例如【0,1,2,3,4】

编了一个函数guolv（），执行后结果为【2,3,4】。

其实思路不复杂，就是暴力。但是验证太困难了。我也不知道错在哪里了。

arr=[2,-3,-2,3,7,-6,-6,-7,9,-5,-9,-3,-2,1,4,-9,-1,-10,-5,-5,-10,-4,8,2]

#旋转
def y0(s,n):

    if n==0:
        # 沿y轴向前
        s[6],s[7],s[8],s[9],s[23],s[22],s[4],s[5],s[1],s[0],s[2],s[3]=s[4],s[5],s[6],s[7],s[8],s[9],s[23],s[22],s[3],s[1],s[0],s[2]
    elif n==1:
        #沿y轴向后
        s[4],s[5],s[6],s[7],s[8],s[9],s[23],s[22],s[3],s[1],s[0],s[2]=s[6],s[7],s[8],s[9],s[23],s[22],s[4],s[5],s[1],s[0],s[2],s[3]

    elif n==2:
        #沿x轴向前
        s[1],s[3],s[7],s[13],s[17],s[19],s[21],s[23],s[8],s[14],s[15],s[9]=s[7],s[13],s[17],s[19],s[21],s[23],s[1],s[3],s[14],s[15],s[9],s[8]
    elif n == 3:
        #沿x轴向后
        s[7],s[13],s[17],s[19],s[21],s[23],s[1],s[3],s[14],s[15],s[9],s[8]=s[1],s[3],s[7],s[13],s[17],s[19],s[21],s[23],s[8],s[14],s[15],s[9]
    elif n == 4:
        #沿z周逆时针
        s[6],s[7],s[13],s[12],s[8],s[14],s[17],s[16],s[11],s[5],s[2],s[3]=s[7],s[13],s[12],s[6],s[17],s[16],s[11],s[5],s[2],s[3],s[8],s[14]
    elif n == 5:
        #沿z周顺时针
        s[7],s[13],s[12],s[6],s[17],s[16],s[11],s[5],s[2],s[3],s[8],s[14]=s[6],s[7],s[13],s[12],s[8],s[14],s[17],s[16],s[11],s[5],s[2],s[3]

    return s
#求优美值
def addsum(s):
    return s[0]*s[1]*s[2]*s[3]+s[8]*s[9]*s[14]*s[15]+s[6]*s[7]*s[12]*s[13]+s[4]*s[5]*s[10]*s[11]+s[16]*s[17]*s[18]*s[19]+s[20]*s[21]*s[22]*s[23]

#筛掉无用的旋转
def guolv(g):
    def jiance(a,b):
        #a+b =1 有两种可能 a=0 b=1 或 a=1 b=0,方向刚好相反，视为无效
        #a+b =9 有两种可能 a=5 b=4 或 a=4 b=5,方向刚好相反，视为无效
        #a+b =5 则有多种可能，可能是（2,3） （1,4）  （0，5） ，只有（2,3）才有是 方向相反的过滤掉。
        if (a+b) in [1,9]&nbs***bsp;((a+b)==5 and (a in [2,3])):
            return 100,100
        else:
            return a,b

    for d in range(len(g)-1):
        g[d],g[d+1]=jiance(g[d],g[d+1])

    return list(filter(lambda r: r!=100, g))

n=6
#遍历出各种可能性
result_list=[]
for x in range(n):
    if guolv([x]) not in result_list:
        result_list.append(guolv([x]))    #插入只旋转1次情况
    for y in range(n):
        if guolv([x, y]) not in result_list:
            result_list.append(guolv([x, y])) #插入旋转2次情况
        for z in range(n):
            if guolv([x, y, z]) not in result_list:
                result_list.append(guolv([x, y, z]))  #插入旋转3次情况
            for w in range(n):
                if guolv([x, y, z, w]) not in result_list:
                    result_list.append(guolv([x, y, z, w])) #插入旋转4次情况
                for u in range(n):  #插入旋转5次情况
                    if x==y==z==w:    #前4次旋转方向一致，可以视为没变化
                        if [u] not in result_list:
                            result_list.append([u])
                    elif u==y==z==w: #后4次旋转方向一致，可以视为没变化
                        if [x] not in result_list:
                            result_list.append([x])
                    else:
                        if guolv([x,y,z,w,u]) not in result_list:
                            result_list.append(guolv([x, y, z, w, u]))

# print(result_list)
result=addsum(arr)
#遍历取最大值
for x in result_list:
    for y in x:
        arr=y0(arr, y)

    result=max(addsum(arr),result)

print(result)

编辑于 2020-02-09 00:11:00 回复(0)

Python

牛客447189284号

cubeArray = list(map(int,input().strip().split()))

def rotation_circle(cubeArray,opNum):
    if opNum==1:
        cubeArray_index_2 = cubeArray[2]
        cubeArray_index_3 = cubeArray[3]

        cubeArray[2] = cubeArray[8]
        cubeArray[3] = cubeArray[14]

        cubeArray[8] = cubeArray[17]
        cubeArray[14] = cubeArray[16]

        cubeArray[16] = cubeArray[5]
        cubeArray[17] = cubeArray[11]

        cubeArray[5] = cubeArray_index_3
        cubeArray[11] =cubeArray_index_2

        cubeArray_index_6 = cubeArray[6]

        cubeArray[6] = cubeArray[7]
        cubeArray[7] = cubeArray[13]
        cubeArray[13] = cubeArray[12]
        cubeArray[12] = cubeArray_index_6

    else:
        cubeArray_index_0 = cubeArray[0]
        cubeArray_index_1 = cubeArray[1]

        cubeArray[0] = cubeArray[9]
        cubeArray[1] = cubeArray[15]

        cubeArray[9] = cubeArray[19]
        cubeArray[15] = cubeArray[18]

        cubeArray[19] = cubeArray[10]
        cubeArray[18] = cubeArray[4]

        cubeArray[4] = cubeArray_index_1
        cubeArray[10] = cubeArray_index_0

        cubeArray_index_22 = cubeArray[22]

        cubeArray[22] = cubeArray[23]
        cubeArray[23] = cubeArray[21]
        cubeArray[21] = cubeArray[20]
        cubeArray[20] = cubeArray_index_22
    return cubeArray

def rotation_left_right(cubeArray,opNum):
    if opNum==1:
        cubeArray_index_23 = cubeArray[23]
        cubeArray_index_22 = cubeArray[22]

        cubeArray[23] = cubeArray[8]
        cubeArray[22] = cubeArray[9]

        cubeArray[8] = cubeArray[6]
        cubeArray[9] = cubeArray[7]

        cubeArray[6] = cubeArray[4]
        cubeArray[7] = cubeArray[5]

        cubeArray[4] = cubeArray_index_23
        cubeArray[5] =cubeArray_index_22

        cubeArray_index_3 = cubeArray[3]

        cubeArray[3] = cubeArray[2]
        cubeArray[2] = cubeArray[0]
        cubeArray[0] = cubeArray[1]
        cubeArray[1] = cubeArray_index_3
    else:
        cubeArray_index_21 = cubeArray[21]
        cubeArray_index_20 = cubeArray[20]

        cubeArray[21] = cubeArray[14]
        cubeArray[20] = cubeArray[15]

        cubeArray[14] = cubeArray[12]
        cubeArray[15] = cubeArray[13]

        cubeArray[12] = cubeArray[10]
        cubeArray[13] = cubeArray[11]

        cubeArray[10] = cubeArray_index_21
        cubeArray[11] = cubeArray_index_20

        cubeArray_index_18 = cubeArray[18]

        cubeArray[18] = cubeArray[19]
        cubeArray[19] = cubeArray[17]
        cubeArray[17] = cubeArray[16]
        cubeArray[16] = cubeArray_index_18
    return cubeArray

def rotation_up_down(cubeArray,opNum):
    if opNum==1:
        cubeArray_index_21 = cubeArray[21]
        cubeArray_index_23 = cubeArray[23]

        cubeArray[21] = cubeArray[17]
        cubeArray[23] = cubeArray[19]

        cubeArray[17] = cubeArray[7]
        cubeArray[19] = cubeArray[13]

        cubeArray[7] = cubeArray[1]
        cubeArray[13] = cubeArray[3]

        cubeArray[1] = cubeArray_index_21
        cubeArray[3] =cubeArray_index_23

        cubeArray_index_14 = cubeArray[14]

        cubeArray[14] = cubeArray[8]
        cubeArray[8] = cubeArray[9]
        cubeArray[9] = cubeArray[15]
        cubeArray[15] = cubeArray_index_14
    else:
        cubeArray_index_20 = cubeArray[20]
        cubeArray_index_22 = cubeArray[22]

        cubeArray[20] = cubeArray[16]
        cubeArray[22] = cubeArray[18]

        cubeArray[16] = cubeArray[6]
        cubeArray[18] = cubeArray[12]

        cubeArray[6] = cubeArray[0]
        cubeArray[12] = cubeArray[2]

        cubeArray[0] = cubeArray_index_20
        cubeArray[2] = cubeArray_index_22

        cubeArray_index_4 = cubeArray[4]

        cubeArray[4] = cubeArray[10]
        cubeArray[10] = cubeArray[11]
        cubeArray[11] = cubeArray[5]
        cubeArray[5] = cubeArray_index_4
    return cubeArray

def sum_caculation(cubeArray):
    sumArray = 0
    sumArray += cubeArray[0]*cubeArray[1]*cubeArray[2]*cubeArray[3]
    sumArray += cubeArray[4] * cubeArray[5] * cubeArray[10] * cubeArray[11]
    sumArray += cubeArray[6] * cubeArray[7] * cubeArray[12] * cubeArray[13]
    sumArray += cubeArray[8] * cubeArray[9] * cubeArray[14] * cubeArray[15]
    sumArray += cubeArray[16] * cubeArray[17] * cubeArray[18] * cubeArray[19]
    sumArray += cubeArray[20] * cubeArray[21] * cubeArray[22] * cubeArray[23]
    return sumArray

def rotation_judgement(j,cubeArray,maxSum):
    if j ==0:
        cubeArray = rotation_circle(cubeArray,1)
        maxSum = max(maxSum,sum_caculation(cubeArray))
    elif j==1:
        cubeArray = rotation_circle(cubeArray, 2)
        maxSum = max(maxSum, sum_caculation(cubeArray))

    elif j==2:
        cubeArray = rotation_circle(cubeArray, 1)
        cubeArray = rotation_circle(cubeArray, 1)
        cubeArray = rotation_circle(cubeArray, 1)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    elif j==3:
        cubeArray = rotation_circle(cubeArray, 2)
        cubeArray = rotation_circle(cubeArray, 2)
        cubeArray = rotation_circle(cubeArray, 2)
        maxSum = max(maxSum, sum_caculation(cubeArray))


    elif j==4:
        cubeArray = rotation_left_right(cubeArray, 1)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    elif j==5:
        cubeArray = rotation_left_right(cubeArray, 2)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    elif j==6:
        cubeArray = rotation_left_right(cubeArray, 1)
        cubeArray = rotation_left_right(cubeArray, 1)
        cubeArray = rotation_left_right(cubeArray, 1)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    elif j==7:
        cubeArray = rotation_left_right(cubeArray, 2)
        cubeArray = rotation_left_right(cubeArray, 2)
        cubeArray = rotation_left_right(cubeArray, 2)
        maxSum = max(maxSum, sum_caculation(cubeArray))


    elif j==8:
        cubeArray = rotation_up_down(cubeArray, 1)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    elif j==9:
        cubeArray = rotation_up_down(cubeArray, 2)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    elif j==10:
        cubeArray = rotation_up_down(cubeArray, 1)
        cubeArray = rotation_up_down(cubeArray, 1)
        cubeArray = rotation_up_down(cubeArray, 1)
        maxSum = max(maxSum, sum_caculation(cubeArray))
    else:
        cubeArray = rotation_up_down(cubeArray, 2)
        cubeArray = rotation_up_down(cubeArray, 2)
        cubeArray = rotation_up_down(cubeArray, 2)
        maxSum = max(maxSum, sum_caculation(cubeArray))


    return cubeArray,maxSum


maxSum = -100*100*100*100*6-1
cubeArray1 = cubeArray[:]
for i in range(12):
    cubeArray = cubeArray1[:]
    cubeArray,maxSum = rotation_judgement(i,cubeArray,maxSum)
    cubeArray2 = cubeArray[:]
    for j in  range(12):
        cubeArray = cubeArray2[:]
        cubeArray, maxSum = rotation_judgement(j, cubeArray, maxSum)
        cubeArray3 = cubeArray[:]
        for k in range(12):
            cubeArray = cubeArray3[:]
            cubeArray, maxSum = rotation_judgement(k, cubeArray, maxSum)
            cubeArray4 = cubeArray[:]
            for l in range(12):
                cubeArray = cubeArray4[:]
                cubeArray, maxSum = rotation_judgement(l, cubeArray, maxSum)
                cubeArray5 = cubeArray[:]
                for q in range(12):
                    cubeArray = cubeArray5[:]
                    cubeArray, maxSum = rotation_judgement(q, cubeArray, maxSum)

print(maxSum)

编辑于 2019-04-09 14:35:13 回复(6)