携程0914笔试题解

第一题

边长为n的正方形，横竖切共计k刀，要求切的每个矩形大小项目，求矩形的面积，保留两位小数

打卡题，直接横切k//2刀，竖切k-k//2刀

n, k = [int(item) for item in input().split()]
def f(n, k):
    x = k//2
    y = k - x
    return n*n/(x+1)/(y+1)

print("%.2f" % round(f(n, k),2))

第二题

t个测试用例，输入两个2*2的01矩阵a和b，每步交换相邻的两个元素，求a->b的步数

思路是求两个矩阵mat1,mat2的和sum1,sum2，如果不相等返回-1，mat1==mat2返回0，
剩下的只有sum1==1,sum1==2,sum1==3三种情况，求mat=mat1+mat2

1. sum1==1
   mat会有[[1 0][0 1]] [[1 1][0 0]] [[1 0][1 0]]的情况，对行列分别求和，和存在2的情况只用交换1次，其他情况交换2次
2. sum1==2
   mat会有[[1 1][1 1]] [[2 1][1 0]] [[2 0][1 1]]的情况，对行列分别求和，和存在2且不是[[1 1][1 1]]的情况只用交换1次，其他情况交换2次
3. 和1类似，求和存在2和4的情况

def switch_time(mat1, mat2):
    if mat1 == mat2:
        return 0
    sum1 = mat1[0][0] + mat1[1][0] + mat1[0][1] + mat1[1][1]
    sum2 = mat2[0][0] + mat2[1][0] + mat2[0][1] + mat2[1][1]
    if sum1 != sum2:
        return -1
    mat = [[0, 0], [0, 0]]
    for i in range(2):
        for j in range(2):
            mat[i][j] = mat1[i][j] + mat2[i][j]
    # print(mat)
    if sum1 == 1:
        if sum(mat[0]) == 2 or sum(mat[1]) == 2 or mat[0][0]+mat[1][0] == 2 or mat[0][1]+mat[1][1] == 2:
            return 1
        else:
            return 2
    elif sum1 == 2:
        if mat[0][0] == 1 and mat[0][1] == 1 and mat[1][0] == 1 and mat[1][1] == 1:
            return 2
        elif sum(mat[0]) == 2 or sum(mat[1]) == 2 or mat[0][0]+mat[1][0] == 2 or mat[0][1]+mat[1][1] == 2:
            return 1
        else:
            return 2
    else:
        if sum(mat[0])%2 == 0 or sum(mat[1])%2 == 0 or (mat[0][0]+mat[1][0])%2 == 0 or (mat[0][1]+mat[1][1])%2 == 0:
            return 1
        else:
            return 2

t = int(input())
for i in range(t):
    mat1 = []
    mat2 = []
    for j in range(2):
        mat1.append([int(item) for item in input().split()])
    for j in range(2):
        mat2.append([int(item) for item in input().split()])
    # print(mat1, mat2)
    print(switch_time(mat1, mat2))

第三题

输入t个用例，长度为n的数组nums，数组颜色colors分别是R和B和nums的数字一一对应，R只能加，B只能减，求加减之后数组的最大值-最小值

思路是先遍历一遍nums，记录r和b对应的最大值和最小值

1. 当不存在r或b的时候，直接返回存在的颜色最大值-最小值
2. 当r的最小值大于b的最大值的时候，这时不能改变数字大小，返回max_r - min_b
3. 当r的最小值小于b的最大值小于r的最大值的时候，这是也不能改变数字大小，返回max_r - min(min_b,min_r)
4. 其他情况返回r、b的范围最大值

def solve(n, nums, colors):
    min_r = 1000000001
    max_r = 0
    min_b = 1000000001
    max_b = 0
    flag1 = False
    flag2 = False
    for i in range(n):
        if colors[i] == 'R':
            min_r = min(min_r, nums[i])
            max_r = max(max_r, nums[i])
            flag1 = True
        if colors[i] == 'B':
            min_b = min(min_b, nums[i])
            max_b = max(max_b, nums[i])
            flag2 = True
    if flag1 and flag2:
        if min_r > max_b:
            return max_r - min_b
        if min_r < max_b < max_r:
            return max_r - min(min_b,min_r)
        return max(max_b-min_b, max_r-min_r)
    if flag1:
        return max_r-min_r
    if flag2:
        return max_b-min_b

t = int(input())
for i in range(t):
    n = int(input())
    nums = [int(item) for item in input().split()]
    colors = input()
    print(solve(n, nums, colors))

第四题

边长为n的正方形中包含1-n*n的所有数字，每个元素的权重等于周围元素的和，求矩阵权重和最大值

四个角的元素计算2次，四条边的元素计算3次，中间的元素计算4次，所以要把小的数字放在角和边上
四角分别是1234，权重和为20
中心的元素共有(n-2)^2，范围是(n-2)^2到n^2
四边的元素共有n^2-(n-2)^2，范围是n^2-(n-2)^2-4到n^2-(n-2)^2
用等差数列公式求和即可

def get_sum_arr(a1, n):
    return a1 * n - (n * (n-1)//2)

def solve(n):
    center_num = 0
    if n>2:
        center_num = get_sum_arr(n * n, (n-2)*(n-2)) * 4

    edge_sum = get_sum_arr(4 * n - 4, 4 * n -8) * 3
    cornner_sum = 20
    return (center_num + edge_sum + cornner_sum) % 1000000007

n = int(input())
print(solve(n))