codeforces——1455 A-E

Educational Codeforces Round 99 (Rated for Div. 2)

A. Strange Functions

B. Jumps

C. Ping-pong

D. Sequence and Swaps

E. Four Points

---

A. Strange Functions

水

    for i in range(int(input())):
        m = input()
        print(len(m))

B. Jumps

找规律，列出几个例子就能发现

    ans_sum = [0,]
    for i in range(1, 1415):
        ans_sum.append(ans_sum[i-1]+i)
    for i in range(int(input())):
        flag = int(input())
        for j in range(1,len(ans_sum)):
            if ans_sum[j] >= flag:
                if ans_sum[j]-1 == flag:
                    print(j+1)
                else:
                    print(j)
                break

C. Ping-pong

这种博弈只有一个类型的特例，在示例中已有体现

    for i in range(int(input())):
        flag = input().split(' ')
        n, m = int(flag[0]), int(flag[1])
        if m != 0 and n != 0:
            n -= 1
        print(str(n) + ' ' + flag[1])

D. Sequence and Swaps

模拟，但是存在特例，即后半部分已经符合要求不需要交换

    for i in range(int(input())):
        flag = input().split(' ')
        n, m = int(flag[0]), int(flag[1])
        flag = [int(v) for v in input().split(' ')]
        count = 0
        for j in range(len(flag)):
            if flag[j] > m:
                for k in range(j+1, len(flag)):
                    if flag[k] < flag[k-1]:
                        flag[j], m = m, flag[j]
                        count += 1
                        break
            if flag[j-1] > flag[j] and j != 0:
                count = -1
                break
        print(count)

E. Four Points

1.一共四个点，构成正方形的可能排列 (左下，右下，左上，右上)，共计 24 种即全排列

2.正方形的可能边长为四个点之间的横坐标或纵坐标之差，四个点共计 12 种可能性

3. 1 和 2 构成共计 24*12 种可能性，对每种 可以计算出 位于横坐标的边长范围为 [x3 - x2, x4 - x1]，纵坐标边长范围为 [y3 - y2, y4 - y1]

4. 然后计算完成 该种可能 所需补偿移动

    import itertools
     
    for t in range(int(input())):
        points, sides, ans = [], [0, ], -1
        for i in range(4):
            points.append([int(v) for v in input().split(' ')])
        
        #可能边长
        for i in range(0, 3):
            for j in range(i + 1, 4):
                sides.append(abs(points[i][0] - points[j][0]))
                sides.append(abs(points[i][1] - points[j][1]))
     
        #全排列
        for point in itertools.permutations(points, 4):
            x1, x2 = min(point[0][0], point[2][0]), max(point[0][0], point[2][0])
            x3, x4 = min(point[1][0], point[3][0]), max(point[1][0], point[3][0])
     
            y1, y2 = min(point[0][1], point[1][1]), max(point[0][1], point[1][1])
            y3, y4 = min(point[2][1], point[3][1]), max(point[2][1], point[3][1])
     
            #边长范围
            side_x_l, side_x_r = x3 - x2, x4 - x1
            side_y_l, side_y_r = y3 - y2, y4 - y1
     
            #边长范围负值时进行修正
            if side_y_r < 0 or side_x_r < 0:
                continue
            if side_x_l < 0:
                side_x_l = 0
            if side_y_l < 0:
                side_y_l = 0
     
            #初始移动值
            count_temp = x2 - x1 + x4 - x3 + y2 - y1 + y4 - y3
            #边长可能
            for side in set(sides):
                count = count_temp

                #移动值补偿
                if side_x_l > side or side_x_r < side:
                    count += min(abs(side - side_x_l), abs(side - side_x_r)) * 2
                if side_y_l > side or side_y_r < side:
                    count += min(abs(side - side_y_l), abs(side - side_y_r)) * 2
     
                if ans == -1 or count < ans:
                    ans = count
     
        print(ans)