[SWEA_모의SW역량테스트] 5644번 - 무선충전

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRDL1aeugDFAUo

SW Expert Academy

SWEA 시뮬레이션 문제다.

두 유저가 돌아다니는 경로가 주어졌을 때 시뮬레이션 결과 얻을 수 있는 최대 충전량을 구하는 문제다.

단순 시뮬레이션으로 브루트포스로 구현해도 Pass가 된다.

 

아래는 C언어 기반 정답코드.

다음주 목요일 (2020.1.30) 현대모비스 SW테스트에서 3문제중 1문제는 꼭 C로 풀어야한다고 해서 C 연습할겸 C로 짜봤다. 확실히 C++ STL이 편한걸 느꼈다.

 

#include <stdio.h>
//#pragma warning(disable:4996)
#define _CRT_SECURE_NO_WARNINGS
typedef struct BC{
    int origin_r, origin_c, P;
}BC;
typedef struct dir{
    int dr, dc;
}dir;
dir direction[5] = { { 0, 0 }, { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
 
BC p_map[10][10][8];
int cnt[10][10]; // 루프돌때 0부터 이 값 미만의 개수확인.
int A_r, A_c, B_r, B_c;
int A_mov[100];
int B_mov[100];
// 정지, 북,동,남,서
// 입력받을 때 
 
int abs_diff(int a, int b){
    int c = a - b;
    if (c > 0) return a - b;
    else return b - a;
}
 
int max(int a, int b){
    if (a > b)
        return a;
    else
        return b;
}
 
void reset_p(){
    for (int i = 0; i < 10; i++){
        for (int j = 0; j < 10; j++){
            cnt[i][j] = 0;
            for (int k = 0; k < 8; k++){
                p_map[i][j][k].origin_r = -1;
                p_map[i][j][k].origin_c = -1;
                p_map[i][j][k].P = -1;
            }
        }
    }
    for (int i = 0; i < 100; i++){
        A_mov[i] = -1;
        B_mov[i] = -1;
    }
    A_r = 0, A_c = 0, B_r = 9, B_c = 9;
}
 
int main(){
    int T;
    scanf("%d", &T);
    for (int tc = 1; tc <= T; tc++){
        reset_p();
        int M, A;
        scanf("%d %d", &M, &A);
        // 행적 입력
        for (int m = 0; m < M; m++){
            scanf("%d", &A_mov[m]);
        }
        for (int m = 0; m < M; m++){
            scanf("%d", &B_mov[m]);
        }
        // BC 정보 입력.
        for (int a = 0; a < A; a++){
            int row, col, C, P;
            scanf("%d %d %d %d", &col, &row, &C, &P);
            int idx = cnt[row - 1][col - 1];
            p_map[row - 1][col - 1][idx].P = P;
            p_map[row - 1][col - 1][idx].origin_r = row - 1;
            p_map[row - 1][col - 1][idx].origin_c = col - 1;
            cnt[row - 1][col - 1]++;
            int base_r = row - 1, base_c = col - 1;
            for (int new_r = base_r - C; new_r <= base_r + C; new_r++){
                for (int new_c = base_c - C; new_c <= base_c + C; new_c++){
                    if (new_r == base_r && new_c == base_c) continue;
                    if (new_r >= 0 && new_r < 10 && new_c >= 0 && new_c < 10){ // 범위 내에 있고,                        
                        if (abs_diff(new_r, base_r) + abs_diff(new_c, base_c) <= C){ // 조건 만족하는 범위내라면 추가.
                            int idx2 = cnt[new_r][new_c];
                            p_map[new_r][new_c][idx2].P = P;
                            p_map[new_r][new_c][idx2].origin_r = base_r;
                            p_map[new_r][new_c][idx2].origin_c = base_c;
                            cnt[new_r][new_c]++;
                        }
                    }
                }
            }
        }
        // 모든 BC정보 입력 완료.
        int sum_A = 0, sum_B = 0;
        for (int m = 0; m < M; m++){
            if (m == 0){
                // 처음이라면 첫 위치 검사.
                if (cnt[A_r][A_c] > 0){
                    int max_val = p_map[A_r][A_c][0].P;
                    for (int j = 0; j < cnt[A_r][A_c]; j++){
                        if (max_val < p_map[A_r][A_c][j].P){
                            max_val = p_map[A_r][A_c][j].P;
                        }
                    }
                    sum_A += max_val;
                }
 
                if (cnt[B_r][B_c] > 0){
                    int max_val = p_map[B_r][B_c][0].P;
                    for (int j = 0; j < cnt[B_r][B_c]; j++){
                        if (max_val < p_map[B_r][B_c][j].P){
                            max_val = p_map[B_r][B_c][j].P;
                        }
                    }
                    sum_B += max_val;
                }
            }
 
            // 이동
            A_r += direction[A_mov[m]].dr;
            A_c += direction[A_mov[m]].dc;
            B_r += direction[B_mov[m]].dr;
            B_c += direction[B_mov[m]].dc;
            int maxsum = -1;
            int add2A = 0, add2B = 0;
            if (cnt[A_r][A_c] > 0 && cnt[B_r][B_c] == 0){
                // A만 충전
                int max_ele = -1;
                for (int i = 0; i < cnt[A_r][A_c]; i++){
                    if (max_ele < p_map[A_r][A_c][i].P){
                        max_ele = p_map[A_r][A_c][i].P;
                    }
                }
                add2A = max_ele;
                sum_A += add2A;
            }
            else if (cnt[A_r][A_c] == 0 && cnt[B_r][B_c] > 0){
                // B만 충전
                int max_ele = -1;
                for (int i = 0; i < cnt[B_r][B_c]; i++){
                    if (max_ele < p_map[B_r][B_c][i].P){
                        max_ele = p_map[B_r][B_c][i].P;
                    }
                }
                add2B = max_ele;
                sum_B += add2B;
            }
            else if (cnt[A_r][A_c] > 0 && cnt[B_r][B_c] > 0){
                for (int i = 0; i < cnt[A_r][A_c]; i++){
                    for (int j = 0; j < cnt[B_r][B_c]; j++){
                        BC A_side = p_map[A_r][A_c][i];
                        BC B_side = p_map[B_r][B_c][j];
                        if (A_side.origin_r == B_side.origin_r && A_side.origin_c == B_side.origin_c){
                            // 동일한 BC 골랐다면
                            if (maxsum < A_side.P){
                                maxsum = A_side.P;
                                add2A = A_side.P / 2;
                                add2B = A_side.P / 2;
                            }
                        }
                        else{
                            // 다른 BC 골랐다면
                            if (maxsum < A_side.P + B_side.P){
                                maxsum = A_side.P + B_side.P;
                                add2A = A_side.P;
                                add2B = B_side.P;
                            }
                        }
                    }
                }
                sum_A += add2A;
                sum_B += add2B;
            }
        }
        printf("#%d %d\n", tc, sum_A+sum_B);
    }
    return 0;
}