[Python] SW Expert Academy #5644 무선 충전

📚문제: #5644 무선 충전(모의 SW 역량테스트)

전체 코드

# 5644 무선 충선

# 충전한 양의 합의 최댓값을 구하는 함수
def max_charge(BC, time, t):
    
    # 전체 합
    total = 0
    
    # 이동 방향, 이동X, 상, 우, 하, 좌
    dr = [0, -1, 0, 1, 0]
    dc = [0, 0, 1, 0, -1]
    
    # A, B의 위치, 초기화
    A_loc = [0, 0]
    B_loc = [9, 9]
    
    # 0초일 때 처리
    A_dist_start = []
    B_dist_start = []
    
    for charger in BC:
        
        coord, C, P, K = charger
        
        X, Y = coord
        
        r = Y-1
        c = X-1
        
        # 거리
        A_d = abs(r-0) + abs(c-0)
        B_d = abs(r-9) + abs(c-9)
        
        # 범위 내에 들어오면 충전이 가능한 BC 목록에 넣는다.
        if A_d <= C:
            
            A_dist_start.append(K)
        
        if B_d <= C:
            
            B_dist_start.append(K)

    # 초기화
    max_val = -1
    
    if len(A_dist_start) > 0 and len(B_dist_start) == 0:

        # 최대값 계산
        for val_A in A_dist_start:
            
            cal = BC_dict[val_A]
            
            # 갱신    
            max_val = max(max_val, cal)

        # 누적
        total += max_val
        
    elif len(A_dist_start) == 0 and len(B_dist_start) > 0:

        # 최대값 계산
        for val_B in B_dist_start:
            
            cal = BC_dict[val_B]
            
            # 갱신    
            max_val = max(max_val, cal)

        # 누적
        total += max_val

    elif len(A_dist_start) > 0 and len(B_dist_start) > 0:
    
        # 최대값 계산
        for val_A in A_dist_start:
            
            
            for val_B in B_dist_start:

                cal = BC_dict[val_A]
                
                # 두개의 값이 다를 때
                if val_B != val_A:
                    
                    cal += BC_dict[val_B]
                
                # 갱신    
                max_val = max(max_val, cal)

        # 누적
        total += max_val
    
    # 주어진 시간동안 실행
    for i in range(time):
        
        # 현재 위치를 가져온다.
        A_r, A_c = A_loc
        B_r, B_c = B_loc
        
        # 새로운 위치
        A_r, A_c = A_r + dr[path_A[i]], A_c + dc[path_A[i]]
        B_r, B_c = B_r + dr[path_B[i]], B_c + dc[path_B[i]]
        
        # A, B와 각 BC 사이의 거리
        A_dist = []
        B_dist = []
        
        # 모든 BC와 거리 계산
        for charger in BC:
            
            # 좌표, 충전 범위, 처리량, BC 번호
            coord, C, P, K = charger

            X, Y = coord
            
            # 좌표계 변환
            r = Y-1
            c = X-1
            
            # 거리
            A_d = abs(r-A_r) + abs(c-A_c)
            B_d = abs(r-B_r) + abs(c-B_c)
            
            # 범위 내에 들어오면 충전이 가능한 BC 목록에 넣는다.
            if A_d <= C:
                
                A_dist.append(K)
            
            if B_d <= C:
                
                B_dist.append(K)
        
        # 초기화
        max_val = -1
            
        if len(A_dist) > 0 and len(B_dist) == 0:

            # 최대값 계산
            for val_A in A_dist:
                
                cal = BC_dict[val_A]
                
                # 갱신    
                max_val = max(max_val, cal)

            # 누적
            total += max_val
            
        elif len(A_dist) == 0 and len(B_dist) > 0:

            # 최대값 계산
            for val_B in B_dist:
                
                cal = BC_dict[val_B]
                
                # 갱신    
                max_val = max(max_val, cal)

            # 누적
            total += max_val

        elif len(A_dist) > 0 and len(B_dist) > 0:
        
            # 최대값 계산
            for val_A in A_dist:
                
                for val_B in B_dist:

                    cal = BC_dict[val_A]
                    
                    # 두개의 값이 다를 때
                    if val_B != val_A:
                        
                        cal += BC_dict[val_B]
                    
                    # 갱신    
                    max_val = max(max_val, cal)

            # 누적
            total += max_val
                
        A_loc = [A_r, A_c]
        B_loc = [B_r, B_c]

    # 답안 출력
    print("#{} {}".format(t, total))

# 총 테스트 케이스의 수 T
T = int(input())

# T개의 테스트 케이스
for t in range(1, T+1):
    
    # 총 이동 시간, Battery Charger의 개수
    time, BC_num = map(int, input().split())
    
    # A의 이동정보
    path_A = list(map(int, input().split()))
    
    # B의 이동정보
    path_B = list(map(int, input().split()))
    
    # Battery Charger
    BC = []
    
    
    # 배터리 사전
    BC_dict = {}
    
    # Battery Charger의 정보
    for i in range(1, BC_num+1):
        
        # 좌표 (X, Y), 충전 범위(C), 처리량(P)
        X, Y, C, P = map(int, input().split())
        
        # 배터리 사전에 추가
        BC_dict[i] = P
        
        val = ((X,Y), C, P, i)
        
        BC.append(val)
    
    # 함수 실행
    max_charge(BC, time, t)