結果

問題 No.968 引き算をして門松列（その３）
コンテスト
ユーザー lam6er
提出日時 2025-04-16 15:44:35
言語 PyPy3
(7.3.15)
結果
WA  
実行時間 -
コード長 5,266 bytes
コンパイル時間 184 ms
コンパイル使用メモリ 81,720 KB
実行使用メモリ 82,892 KB
最終ジャッジ日時 2025-04-16 15:47:21
合計ジャッジ時間 2,882 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2
other WA * 10
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys

def is_valid(a, b, c):
    return a > 0 and b > 0 and c > 0 and a != b and b != c and a != c

def is_kadomatsu(a, b, c):
    if not is_valid(a, b, c):
        return False
    nums = sorted([a, b, c])
    mid = nums[1]
    return mid == a or mid == c

def check_case(A, B, C, X, Y, Z):
    min_cost = float('inf')
    found = False

    # Case 1: B is the largest, A is middle, C is smallest (B > A > C)
    # Constraints:
    # B - x - y > A - x - z → B - y > A - z → z > y + (A - B)
    # A - x - z > C - y - z → A - x > C - y → y > x + (C - A)
    # B - x - y > C - y - z → B - x > C - z → z > x + (C - B)
    # x + z < A
    # x + y < B
    # y + z < C
    # x, y, z >= 0

    # We can try small x, y, z values
    for x in range(0, 100):
        for y in range(max(x + (C - A) + 1, 0), x + (C - A) + 2):
            if x + y >= B:
                continue
            z1 = y + (A - B) + 1
            z2 = x + (C - B) + 1
            z = max(z1, z2)
            if z < 0:
                continue
            if x + z >= A:
                continue
            if y + z >= C:
                continue
            a = A - x - z
            b_val = B - x - y
            c_val = C - y - z
            if is_valid(a, b_val, c_val) and b_val > a and a > c_val:
                cost = x * X + y * Y + z * Z
                if cost < min_cost:
                    min_cost = cost
                    found = True

    # Case 2: B is the largest, C is middle, A is smallest (B > C > A)
    # Constraints:
    # B - x - y > C - y - z → B - x > C - z → z > x + (C - B)
    # C - y - z > A - x - z → C - y > A - x → x > y + (A - C)
    # B - x - y > A - x - z → B - y > A - z → z > y + (A - B)
    # x + z < A
    # x + y < B
    # y + z < C
    for x in range(0, 100):
        for z in range(max(x + (C - B) + 1, 0), x + (C - B) + 2):
            if x + z >= A:
                continue
            y1 = x - (A - C) - 1
            if y1 < 0:
                y = 0
                if x - y < (A - C) + 1:
                    continue
            else:
                y = y1
            if x + y >= B:
                continue
            z_check = max(y + (A - B) + 1, x + (C - B) + 1)
            if z < z_check:
                continue
            if y + z >= C:
                continue
            a = A - x - z
            b_val = B - x - y
            c_val = C - y - z
            if is_valid(a, b_val, c_val) and b_val > c_val and c_val > a:
                cost = x * X + y * Y + z * Z
                if cost < min_cost:
                    min_cost = cost
                    found = True

    # Case 3: B is the smallest, A is middle, C is largest (C > A > B)
    # Constraints:
    # C - y - z > A - x - z → C - y > A - x → x > y + (A - C)
    # A - x - z > B - x - y → A - z > B - y → y > z + (B - A)
    # C - y - z > B - x - y → C - z > B - x → x > z + (B - C)
    # x + z < A
    # x + y < B
    # y + z < C
    for y in range(0, 100):
        for z in range(max(y + (B - A) + 1, 0), y + (B - A) + 2):
            if y + z >= C:
                continue
            x1 = y + (A - C) + 1
            x2 = z + (B - C) + 1
            x = max(x1, x2)
            if x < 0:
                continue
            if x + z >= A:
                continue
            if x + y >= B:
                continue
            a = A - x - z
            b_val = B - x - y
            c_val = C - y - z
            if is_valid(a, b_val, c_val) and c_val > a and a > b_val:
                cost = x * X + y * Y + z * Z
                if cost < min_cost:
                    min_cost = cost
                    found = True

    # Case 4: B is the smallest, C is middle, A is largest (A > C > B)
    # Constraints:
    # A - x - z > C - y - z → A - x > C - y → y > x + (C - A)
    # C - y - z > B - x - y → C - z > B - x → x > z + (B - C)
    # A - x - z > B - x - y → A - z > B - y → y > z + (B - A)
    # x + z < A
    # x + y < B
    # y + z < C
    for z in range(0, 100):
        for x in range(max(z + (B - C) + 1, 0), z + (B - C) + 2):
            if x + z >= A:
                continue
            y1 = x + (C - A) + 1
            y2 = z + (B - A) + 1
            y = max(y1, y2)
            if y < 0:
                continue
            if x + y >= B:
                continue
            if y + z >= C:
                continue
            a = A - x - z
            b_val = B - x - y
            c_val = C - y - z
            if is_valid(a, b_val, c_val) and a > c_val and c_val > b_val:
                cost = x * X + y * Y + z * Z
                if cost < min_cost:
                    min_cost = cost
                    found = True

    return min_cost if found else -1

def main():
    input = sys.stdin.read().split()
    idx = 0
    T = int(input[idx])
    idx +=1
    for _ in range(T):
        A = int(input[idx])
        B = int(input[idx+1])
        C = int(input[idx+2])
        X = int(input[idx+3])
        Y = int(input[idx+4])
        Z = int(input[idx+5])
        idx +=6
        if is_kadomatsu(A, B, C):
            print(0)
            continue
        res = check_case(A, B, C, X, Y, Z)
        print(res if res != float('inf') else -1)

if __name__ == '__main__':
    main()
0