結果

問題 No.968 引き算をして門松列（その３）
ユーザー gew1fw
提出日時 2025-06-12 20:05:28
言語 PyPy3
(7.3.15)
結果
WA  
実行時間 -
コード長 4,284 bytes
コンパイル時間 163 ms
コンパイル使用メモリ 81,672 KB
実行使用メモリ 83,620 KB
最終ジャッジ日時 2025-06-12 20:12:03
合計ジャッジ時間 2,205 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2
other WA * 10
権限があれば一括ダウンロードができます

ソースコード

diff # 

import sys

def is_valid(a, b, c):
    if a == b or b == c or a == c:
        return False
    sorted_nums = sorted([a, b, c])
    middle = sorted_nums[1]
    return middle != b

def compute_case(A, B, C, X, Y, Z):
    if is_valid(A, B, C):
        return 0
    min_cost = float('inf')
    
    cases = [
        (lambda a, b, c: (b > a and a > c), 'B>A>C'),
        (lambda a, b, c: (b > c and c > a), 'B>C>A'),
        (lambda a, b, c: (a > c and c > b), 'A>C>B'),
        (lambda a, b, c: (c > a and a > b), 'C>A>B'),
    ]
    
    for condition, desc in cases:
        a = A
        b = B
        c = C
        possible = False
        a_new, b_new, c_new = 0, 0, 0
        
        if desc == 'B>A>C':
            c_new = min(C, a-1, b-2)
            if c_new < 1:
                continue
            a_new = c_new + 1
            b_new = a_new + 1
            if b_new > b or a_new > a or c_new > c:
                continue
            delta_a = a - a_new
            delta_b = b - b_new
            delta_c = c - c_new
            a1 = (delta_a + delta_b) // 2
            a2 = (delta_b - (delta_a - a1)) 
            a3 = delta_a - a1
            if a1 < 0 or a2 < 0 or a3 < 0:
                continue
            if a1 + a2 == delta_b and a2 + a3 == delta_c and a1 + a3 == delta_a:
                cost = a1 * X + a2 * Y + a3 * Z
                if cost < min_cost:
                    min_cost = cost
                    possible = True
        
        if desc == 'B>C>A':
            a_new = min(C, b-1, a-2)
            if a_new < 1:
                continue
            c_new = a_new + 1
            b_new = c_new + 1
            if b_new > b or a_new > a or c_new > c:
                continue
            delta_a = a - a_new
            delta_b = b - b_new
            delta_c = c - c_new
            a1 = (delta_a + delta_b) // 2
            a2 = (delta_b - (delta_a - a1))
            a3 = delta_a - a1
            if a1 < 0 or a2 < 0 or a3 < 0:
                continue
            if a1 + a2 == delta_b and a2 + a3 == delta_c and a1 + a3 == delta_a:
                cost = a1 * X + a2 * Y + a3 * Z
                if cost < min_cost:
                    min_cost = cost
                    possible = True
        
        if desc == 'A>C>B':
            b_new = min(B, c-1, a-2)
            if b_new < 1:
                continue
            c_new = b_new + 1
            a_new = c_new + 1
            if a_new > a or c_new > c or b_new > b:
                continue
            delta_a = a - a_new
            delta_b = b - b_new
            delta_c = c - c_new
            a3 = (delta_a + delta_c) // 2
            a2 = (delta_c - (delta_a - a3))
            a1 = delta_a - a3
            if a1 < 0 or a2 < 0 or a3 < 0:
                continue
            if a1 + a3 == delta_a and a2 + a3 == delta_c and a1 + a2 == delta_b:
                cost = a1 * X + a2 * Y + a3 * Z
                if cost < min_cost:
                    min_cost = cost
                    possible = True
        
        if desc == 'C>A>B':
            b_new = min(B, a-1, c-2)
            if b_new < 1:
                continue
            a_new = b_new + 1
            c_new = a_new + 1
            if c_new > c or a_new > a or b_new > b:
                continue
            delta_a = a - a_new
            delta_b = b - b_new
            delta_c = c - c_new
            a3 = (delta_a + delta_c) // 2
            a1 = (delta_a - a3)
            a2 = delta_b - a1
            if a1 < 0 or a2 < 0 or a3 < 0:
                continue
            if a1 + a3 == delta_a and a2 + a3 == delta_c and a1 + a2 == delta_b:
                cost = a1 * X + a2 * Y + a3 * Z
                if cost < min_cost:
                    min_cost = cost
                    possible = True
    
    if min_cost == float('inf'):
        return -1
    else:
        return min_cost

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
        res = compute_case(A, B, C, X, Y, Z)
        print(res)

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