2023 하반기 오후 1번 문제 / 루돌프의 반란

[Jinsun-Lee]

문제

<details><summary></summary>

<br>


```cpp

```
</details>

[Jinsun-Lee]

초기 실패

1. 자기가 온 이동 반대 방향으로 D칸 밀림 (dir+2)%4
2. 인덱스 일치 하나로 고정해서 풀어야 해
3. while(M--) 대신 turn 써서 기절 상태 확인 편하게 알기
4. 산타 구조체에서 연쇄 이동
5. 거리 구하는 공식 하라는대로 해
6. 산타 전부 탈락 시 조기 종료 코드 없었어
7. tuple<int, int, int> rBest; // 거리, -y, -x

[Jinsun-Lee]

1인덱싱으로 풀어보기

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int N; // 격자 크기 
int M; // 턴
int P; // 산타의 수
int C; // 루돌프F
int D; // 산타F

struct Node { int y, x; };
Node rudol; // 루돌프 초기 위치

Node santas[31]; // 산타의 위치들
int states[31]; // 산타의 상태 0멀쩡 -1탈락 1,2는 기절

int alive; // 살아있는 산타의 수
int ans[31]; // 결과적으로 출력할 답 

const int MX = 51; // 맵의 최대 크기
int map[MX][MX]; // -1루돌프, 1~30은산타
// vector<vector<int>> map(N+1, vector<int>(N+1, 0)); 

const int rdy[] = { -1, 0, 1, 0, -1, -1, 1, 1 }; // 상우하좌
const int rdx[] = { 0, 1, 0, -1, -1, 1, 1, -1 };

int turn = 0; // 현재 턴

void input() {
    cin >> N >> M >> P >> C >> D;
    cin >> rudol.y >> rudol.x;
    map[rudol.y][rudol.x] = -1;

    int idx;
    for (int i = 1; i <= P; ++i) {
        cin >> idx;
        cin >> santas[idx].y >> santas[idx].x;
        map[santas[idx].y][santas[idx].x] = idx;
    }

    alive = P;
}

void solve() {
    // 1. 루돌프의 이동 + 상하좌우대각선8칸 / 산타쪽으로거리짧고r큰c큰 / state[idx]==-1이면패스
    int rDist = 0x7fffffff, rR = -1, rC = -1, rDir = -1, santaIdx = -1;
    for (int d = 0; d < 8; ++d) {
        int ny = rudol.y + rdy[d];
        int nx = rudol.x + rdx[d];

        if (ny < 1 || nx < 1 || ny >= N + 1 || nx >= N + 1) continue;

        // 모든 산타와의 거리를 비교해
        for (int i = 1; i <= P; ++i) {
            if (states[i] == -1) continue; // 산타가 탈락 상태야

            int dist = abs(santas[i].y - rudol.y) + abs(santas[i].x - rudol.x);
            bool update = false;
            if (rDist > dist) update = true; // 거리가 더 짧아짐
            else if (rDist == dist) {
                if (rR > ny) update = true; // R이더큼
                else if (rR == ny) {
                    if (rC > nx) update = true; // C가더큼
                }
            }

            // 업데이트 ok면 갱신해
            if (update) {
                rDist = dist;
                rR = ny; rC = nx;
                rDir = d;

                santaIdx = i; // 산타의 idx
            }
        }

    }

    // 루돌프랑산타같은칸 -> 산타는 루돌프가 이동하는 방향으로 C칸 밀리고 / 그게 밖이면 탈락 / 다른 산타가 있으면 그 산타가 밀려나 
    rudol = { rR, rC };
    for (int p = C; ; ++p) { // 연쇄작용을 위한 거리 계산
        if (p == C && rDist == 0) {
            ans[santaIdx] += C; // 루돌프가 움직여서 충돌한 경우 해당 산타는 C만큼의 점수를 획득
            states[santaIdx] = 2; // 해당 산타는 기절
        }

        int ny = santas[santaIdx].y + rdy[rDir] * p; // 산타가 밀려!!! 
        int nx = santas[santaIdx].x + rdx[rDir] * p;

        if (ny < 1 || nx < 1 || ny >= N + 1 || nx >= N + 1) {
            states[santaIdx] = -1;
            --alive; // 산타 state가 -1이 될 때마다 alive--;
            //map[santas[santaIdx].y][santas[santaIdx].x] = 0;
            break; // 밀린칸에 산타가 없거나 범위 밖이면 끝
        }

        // 산타가 한 번 밀리면 그 뒤에 있는 것들이 밀려
        if (map[ny][nx] > 0) { // 맵의칸이O이아님 = 다른산타가있어
            int pre = map[ny][nx];

            if (states[pre] == -1) {
                map[ny][nx] = santaIdx;
                break; // 탈락 상태인 산타가 있으면
            }

            santaIdx = pre;
        }

        if (map[ny][nx] <= 0) {
            map[ny][nx] = santaIdx;
            break;
        }
    }




    // 2. 산타의 이동
    int sR = santas[santaIdx].y, sC = santas[santaIdx].x;
    int sDist = abs(sR - rR) + abs(sC - rC);
    int sDir = -1; // 최종적으로 그 위치에 계속 있을 수 있어
    for (int idx = 1; idx <= P; ++idx) {
        // 산타가 기절하거나 탈락했으면 패스
        if (states[idx] == -1) continue;
        if (states[idx] == 1 || states[idx] == 2) { // 기절 상태
            --states[idx];
            continue;
        }

        // 산타의 방향은 상 우 하 좌 
        for (int d = 0; d < 4; ++d) {
            // 루돌프와의 거리를 구해서 가장 짧은 거리로 이동해
            int ny = santas[idx].y + rdy[d];
            int nx = santas[idx].x + rdx[d];

            int dist = abs(ny - rR) + abs(nx - rC);
            if (sDist > dist) {
                //if (map[ny][nx] > 0 && states[map[ny][nx]]!=-1) continue; // 근데 다른 산타와 위치가 겹치면 이동 안 하고 
                sDist = dist;
                sR = ny, sC = nx;
                sDir = d;
                santaIdx = idx;
            }
        }
    }

    // 충돌 시 온 방향의 반대 방향으로 D칸 밀려
    if (sDist == 0 && sDir != -1) {
        ans[santaIdx] += D;
        states[santaIdx] = 2; // 산타의 state는 2로 기절 상태 표시

        int ny = sR - rdy[sDir] * D; // 산타가 밀려!!! 
        int nx = sC - rdx[sDir] * D;

        if (ny < 1 || nx < 1 || ny >= N + 1 || nx >= N + 1) {
            states[santaIdx] = -1;
            --alive; // 산타 state가 -1이 될 때마다 alive--;
            break; // 밀린칸에 산타가 없거나 범위 밖이면 끝
        }

        // 산타가 한 번 밀리면 그 뒤에 있는 것들이 밀려
        if (map[ny][nx] > 0) { // 맵의칸이O이아님 = 다른산타가있어
            int pre = map[ny][nx];

            if (states[pre] == -1) {
                map[ny][nx] = santaIdx;
                break; // 탈락 상태인 산타가 있으면
            }

            santaIdx = pre;
        }

    }



    // 3. 한 턴이 끝나면 점수 1점씩 증가
    for (int idx = 1; idx <= P; ++idx) {
        if (states[idx] == -1) continue;
        ++ans[idx]; // 탈락만 아니면 점수 올려
    }

}

int main() {
    freopen_s(new FILE*, "input.txt", "r", stdin);
    ios::sync_with_stdio(0); cin.tie(0);

    input();
    while (M--) {
        solve(); // 모든 턴은 최대 1000번
        if (alive == 0) break; //★4. 전원 탈락 시 조기 종료
    }
    for (int i = 1; i <= P; ++i) cout << ans[i] << " ";
    return 0;
}

[Jinsun-Lee]

초기동작코드 실패버전

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int N; // 격자 크기 
int M; // 턴
int P; // 산타의 수
int C; // 루돌프F
int D; // 산타F

int turn = 0; // 현재 턴
int alive; // 살아있는 산타의 수

struct Node { int y, x; };
Node rudol; // 루돌프 초기 위치
const int RUDOLPH = -1;

const int INIT = -2; // 비어있음

const int rdy[] = { -1, 0, 1, 0, -1, -1, 1, 1 }; // 상우하좌
const int rdx[] = { 0, 1, 0, -1, -1, 1, -1, 1 };

bool OOB(int y, int x) {
    return 0 <= y && y < N && 0 <= x && x < N;
}

int calDist(int y1, int x1, int y2, int x2) {
    return abs(y2 - y1) + abs(x2 - x1);
    //return (y2 - y1) * (y2 - y1) +(x2 - x1) * (x2 - x1);
}

struct Santa {
    int id;

    int y, x;
    int score = 0; // 결과적으로 출력할 답 

    int wakeupTurn = 0; // 이 턴까지 기절
    bool die = false; // 죽은 상태

    // 연쇄 이동
    void move(int dir, int dist, vector<vector<int>>& map, vector<Santa>& santas) {
        if (dist == 0) return;

        int ny = y + rdy[dir] * dist; // 산타가 밀려!!! 
        int nx = x + rdx[dir] * dist;

        // 격자 밖으로 밀리면 탈락
        if (!OOB(ny, nx)) {
            die = true; 
            map[y][x] = INIT;
            return; 
        }

        // 착지할 칸에 다른 산타 있으면 연쇄
        if (map[ny][nx] >= 0) {
            santas[map[ny][nx]].move(dir, 1, map, santas);
        }

        // 위치 업데이트
        map[y][x] = INIT;
        y = ny; x = nx;
        map[y][x] = id;
    }

    bool checkState() const { return wakeupTurn >= turn; } // 죽으면 업뎃
};

void print(vector<vector<int>>& map) {
    cout << "\n";
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (map[i][j] == INIT) cout << "_ ";
            else cout << map[i][j]+1 << " ";
        }
        cout << "\n";
    }cout << "\n\n";
}

int main() {
    freopen_s(new FILE*, "input.txt", "r", stdin);
    ios::sync_with_stdio(0); cin.tie(0);

    // 0. 입력 처리하기
    cin >> N >> M >> P >> C >> D;

    vector<vector<int>> map(N, vector<int>(N, INIT)); // -1루돌프, 1~30은산타
    vector<Santa> santas(P); // 0번 인덱스야

    int idx, r, c;
    cin >> r >> c;
    --r; --c;
    rudol = {r, c}; // cin >> rudol.y >> rudol.x; 인덱싱 매칭 좀
    map[r][c] = RUDOLPH;
    
    for (int i = 0; i < P; ++i) {
        cin >> idx >> r >> c;
        --idx; --r; --c;
        santas[idx] = { idx, r, c };
        map[r][c] = idx;
    }

    alive = P;


    // 반복 
    for (turn = 1; turn <= M; ++turn) { // while (M--) { // 모든 턴은 최대 1000번

        // 1. 루돌프의 이동 + 상하좌우대각선8칸 / 산타쪽으로거리짧고r큰c큰 / state[idx]==-1이면패스
        // 가장 가까운 산타 선정 -> 8방향 중 최소거리-> 충돌 처리
        int rDist = 0x7fffffff, rR = -1, rC = -1, rDir = -1, santaIdx = -1;

        for (int d = 0; d < 8; ++d) {
            int ny = rudol.y + rdy[d];
            int nx = rudol.x + rdx[d];

            if (!OOB(ny, nx)) continue;

            // 모든 산타와의 거리를 비교해
            for (int i = 0; i < P; ++i) {
                if (santas[i].die) continue; // 산타가 탈락 상태야

                int dist = calDist(ny, nx, santas[i].y, santas[i].x);
                
                bool update = false;
                if (rDist > dist) update = true; // 거리가 더 짧아짐
                else if (rDist == dist) {
                    if (rR < ny) update = true; // R이더큼
                    else if (rR == ny) {
                        if (rC < nx) update = true; // C가더큼
                    }
                }

                // 업데이트 ok면 갱신해
                if (update) {
                    rDist = dist;
                    rR = ny; rC = nx;
                    rDir = d;

                    santaIdx = i; // 산타의 idx

                    cout << "산타"<<santaIdx+1 << " 방향" << rDir <<" -> " << 
                        rR + rdy[rDir] << " " << rC + rdx[rDir] << "\n"; //✅결국 선택한 산타
                }
            }
        }

        // 루돌프랑산타같은칸 -> 산타는 루돌프가 이동하는 방향으로 C칸 밀리고 / 그게 밖이면 탈락 / 다른 산타가 있으면 그 산타가 밀려나 
        // 산타가 한 번 밀리면 그 뒤에 있는 것들이 밀려
        if (map[rR][rC] >= 0) { // 맵의칸이O이아님 = 다른산타가있어
            Santa& st = santas[map[rR][rC]];
            st.wakeupTurn = turn + 1;
            st.score += C;
            st.move(rDir, C, map, santas);
        }

        map[rudol.y][rudol.x] = INIT;
        rudol = { rR + rdy[rDir], rC + rdx[rDir] }; //🔥🔥🔥아니 이걸 왜 하지
        //rudol = { rR, rC };
        map[rudol.y][rudol.x] = RUDOLPH;

        print(map); //✅

        // 2. 산타의 이동
        for (auto& st : santas) {
        
            // 산타가 기절하거나 탈락했으면 패스
            if (st.die || st.checkState()) continue;

            int sDir = -1; // 최종적으로 그 위치에 계속 있을 수 있어
            int sDist = calDist(st.y, st.x, rudol.y, rudol.x);

            // 산타의 방향은 상 우 하 좌 
            for (int d = 0; d < 4; ++d) {
                // 루돌프와의 거리를 구해서 가장 짧은 거리로 이동해
                int ny = st.y + rdy[d];
                int nx = st.x + rdx[d];

                if (!OOB(ny, nx)) {
                    --alive; // 산타 state가 -1이 될 때마다 alive--;
                    continue;
                }

                if (map[ny][nx] >= 0) continue; // 맵의칸이O이아님 = 다른산타가있어

                int dist = calDist(ny, nx, rudol.y, rudol.x);
                if (dist < sDist) {
                    //if (map[ny][nx] > 0 && states[map[ny][nx]]!=-1) continue; // 근데 다른 산타와 위치가 겹치면 이동 안 하고 
                    sDist = dist;
                    sDir = d;
                }
            }


            // 이동을 안 했을 경우 
            if (sDir == -1) continue;

            int ny = st.y + rdy[sDir]; // 산타가 밀려!!! 
            int nx = st.x + rdx[sDir];

            if (map[ny][nx] == INIT) st.move(sDir, 1, map, santas); //🔥🔥🔥빈칸일 때 왜 1칸만 이동
            else { // 루돌프랑 충돌 시 온 방향의 반대 방향으로 D칸 밀려
                st.score += D;
                st.wakeupTurn = turn + 1; //🔥뭐야 왜 +2가 아니지
                st.move( (sDir+2)%4 , D-1, map, santas); //🔥🔥🔥반대 방향 로직 더 쉽게 수정
            }   
            
        }

        // 3. 한 턴이 끝나면 점수 1점씩 증가
        for (auto& st : santas) {
            if (st.die==false) st.score += 1; // 살아있기만 해
        }

        if (alive == 0) break; //🔥4. 전원 탈락 시 조기 종료
    }

    // 5. 결과 출력
    for (int i = 0; i < P; ++i) cout << santas[i].score << " ";
    return 0;
}

[Jinsun-Lee]

초기 동작 코드

#include <iostream>
#include <algorithm>
#include <vector>
#include <tuple>
using namespace std;

int N; // 격자 크기 
int M; // 턴
int P; // 산타의 수
int C; // 루돌프F
int D; // 산타F

int turn = 0; // 현재 턴
// int alive; // 살아있는 산타의 수

struct Node { int y, x; };
Node rudol; // 루돌프 초기 위치
const int RUDOLPH = -1;

const int INIT = -2; // 비어있음

const int rdy[] = { -1, 0, 1, 0, -1, -1, 1, 1 }; // 상우하좌
const int rdx[] = { 0, 1, 0, -1, -1, 1, -1, 1 };

bool OOB(int y, int x) {
    return 0 <= y && y < N && 0 <= x && x < N;
}

int calDist(int y1, int x1, int y2, int x2) {
    //return abs(y2 - y1) + abs(x2 - x1);
    return (y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1); //🔥🔥🔥🔥🔥
}

struct Santa {
    int id;

    int y, x;
    int score = 0; // 결과적으로 출력할 답 

    int wakeupTurn = 0; // 이 턴까지 기절
    bool die = false; // 죽은 상태

    // 연쇄 이동
    void move(int dir, int dist, vector<vector<int>>& map, vector<Santa>& santas) {
        if (dist == 0) return;

        int ny = y + rdy[dir] * dist; // 산타가 밀려!!! 
        int nx = x + rdx[dir] * dist;

        // 격자 밖으로 밀리면 탈락
        if (!OOB(ny, nx)) {
            die = true;
            map[y][x] = INIT;
            return;
        }

        // 착지할 칸에 다른 산타 있으면 연쇄
        if (map[ny][nx] >= 0) {
            santas[map[ny][nx]].move(dir, 1, map, santas);
        }

        // 위치 업데이트
        map[y][x] = INIT;
        y = ny; x = nx;
        map[y][x] = id;
    }

    bool checkState() const { return wakeupTurn >= turn; } // 죽으면 업뎃
};

void print(vector<vector<int>>& map) {
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (map[i][j] == INIT) cout << "_ ";
            else cout << map[i][j] + 1 << " ";
        }
        cout << "\n";
    }cout << "\n";
}

int main() {
    freopen_s(new FILE*, "input.txt", "r", stdin);
    ios::sync_with_stdio(0); cin.tie(0);

    // 0. 입력 처리하기
    cin >> N >> M >> P >> C >> D;

    vector<vector<int>> map(N, vector<int>(N, INIT)); // -1루돌프, 1~30은산타
    vector<Santa> santas(P); // 0번 인덱스야

    int idx, r, c;
    cin >> r >> c;
    --r; --c;
    rudol = { r, c }; // cin >> rudol.y >> rudol.x; 인덱싱 매칭 좀
    map[r][c] = RUDOLPH;

    for (int i = 0; i < P; ++i) {
        cin >> idx >> r >> c;
        --idx; --r; --c;
        santas[idx] = { idx, r, c };
        map[r][c] = idx;
    }

    //alive = P;


    // 반복 
    for (turn = 1; turn <= M; ++turn) { // while (M--) { // 모든 턴은 최대 1000번

        // 1. 루돌프의 이동 + 상하좌우대각선8칸 / 산타쪽으로거리짧고r큰c큰 / state[idx]==-1이면패스
        /*
        // 가장 가까운 산타 선정 -> 8방향 중 최소거리-> 충돌 처리
        int rDist = 0x7fffffff, rR = -1, rC = -1, rDir = -1, santaIdx = -1;

        for (int d = 0; d < 8; ++d) {
            int ny = rudol.y + rdy[d];
            int nx = rudol.x + rdx[d];

            if (!OOB(ny, nx)) continue;

            // 모든 산타와의 거리를 비교해
            for (int i = 0; i < P; ++i) {
                if (santas[i].die) continue; // 산타가 탈락 상태야

                int dist = calDist(ny, nx, santas[i].y, santas[i].x);

                bool update = false;
                if (rDist > dist) update = true; // 거리가 더 짧아짐
                else if (rDist == dist) {
                    if (rR < ny) update = true; // R이더큼
                    else if (rR == ny) {
                        if (rC < nx) update = true; // C가더큼
                    }
                }

                // 업데이트 ok면 갱신해
                if (update) {
                    rDist = dist;
                    rR = ny; rC = nx;
                    rDir = d;

                    santaIdx = i; // 산타의 idx

                    cout << "산타" << santaIdx + 1 << " 방향" << rDir << " -> " <<
                        rR + rdy[rDir] << " " << rC + rdx[rDir] << "\n"; //✅결국 선택한 산타
                }
            }
        }

        // 루돌프랑산타같은칸 -> 산타는 루돌프가 이동하는 방향으로 C칸 밀리고 / 그게 밖이면 탈락 / 다른 산타가 있으면 그 산타가 밀려나
        // 산타가 한 번 밀리면 그 뒤에 있는 것들이 밀려
        if (map[rR][rC] >= 0) { // 맵의칸이O이아님 = 다른산타가있어
            Santa& st = santas[map[rR][rC]];
            st.wakeupTurn = turn + 1;
            st.score += C;
            st.move(rDir, C, map, santas);
        }

        map[rudol.y][rudol.x] = INIT;
        rudol = { rR + rdy[rDir], rC + rdx[rDir] }; //🔥🔥🔥아니 이걸 왜 하지
        //rudol = { rR, rC };
        map[rudol.y][rudol.x] = RUDOLPH;
        */

        // 가장 가까운 산타 선정 -> 8방향 중 최소거리-> 충돌 처리
        // 1) 가장 가까운 산타 선정
        int santaIdx = -1;
        tuple<int, int, int> rBest; // 거리, -y, -x
        for (int i = 0; i < P; ++i) {
            if (santas[i].die) continue;

            auto cur = make_tuple(calDist(santas[i].y, santas[i].x, rudol.y, rudol.x), -santas[i].y, -santas[i].x); //🔥🔥🔥🔥🔥

            if (santaIdx == -1 || cur < rBest) {
                rBest = cur;
                //🔥🔥🔥🔥🔥루돌프 갱신하지 마
                santaIdx = i;
            }
        }

        // 2) 8 방향 중 최소 거리
        int rDir = -1;
        int rDist = get<0>(rBest); //🔥🔥🔥이미 계산된 가장 가까운 산타와의 거리

        for (int d = 0; d < 8; ++d) {
            int ny = rudol.y + rdy[d];
            int nx = rudol.x + rdx[d];

            if (!OOB(ny, nx)) continue;

            int dist = calDist(ny, nx, santas[santaIdx].y, santas[santaIdx].x);

            if (dist < rDist) { // 거리가 더 짧아짐
                rDist = dist;
                rDir = d;
                //🔥🔥🔥🔥🔥루돌프 갱신하지 마
                //cout << "산타" << santaIdx + 1 << " 방향" << rDir << " -> " << rudol.y + rdy[rDir] << " " << rudol.x + rdx[rDir] << "\n"; //✅결국 선택한 산타
            }
        }

        // 루돌프랑산타같은칸 -> 산타는 루돌프가 이동하는 방향으로 C칸 밀리고 / 그게 밖이면 탈락 / 다른 산타가 있으면 그 산타가 밀려나 
        // 산타가 한 번 밀리면 그 뒤에 있는 것들이 밀려
        int rR = rudol.y + rdy[rDir], rC = rudol.x + rdx[rDir]; //🔥🔥🔥🔥🔥

        if (map[rR][rC] >= 0) { // 맵의칸이O이아님 = 다른산타가있어
            Santa& st = santas[map[rR][rC]]; //🔥🔥🔥🔥🔥
            st.wakeupTurn = turn + 1;
            st.score += C;
            st.move(rDir, C, map, santas);
        }

        map[rudol.y][rudol.x] = INIT;
        rudol = { rR, rC };
        map[rudol.y][rudol.x] = RUDOLPH; //🔥🔥🔥🔥🔥

        /*
        cout << turn << " 루돌프\n";
        print(map); //✅
        for (int i = 0; i < P; ++i) cout << santas[i].score << " ";
        cout << "\n\n\n";
        */


        // 2. 산타의 이동
        for (auto& st : santas) {

            // 산타가 기절하거나 탈락했으면 패스
            if (st.die || st.checkState()) continue; //🔥🔥🔥🔥🔥

            int sDir = -1; // 최종적으로 그 위치에 계속 있을 수 있어
            int sDist = calDist(st.y, st.x, rudol.y, rudol.x); // 루돌프와의 현재 거리

            // 산타의 방향은 상 우 하 좌 
            for (int d = 0; d < 4; ++d) {
                // 루돌프와의 거리를 구해서 가장 짧은 거리로 이동해
                int ny = st.y + rdy[d];
                int nx = st.x + rdx[d];

                if (!OOB(ny, nx)) {
                    //--alive; // 산타 state가 -1이 될 때마다 alive--;
                    continue;
                }

                if (map[ny][nx] >= 0) continue; // 맵의칸이O이아님 = 다른산타가있어

                int dist = calDist(ny, nx, rudol.y, rudol.x);
                if (dist < sDist) { //🔥🔥🔥🔥🔥
                    //if (map[ny][nx] > 0 && states[map[ny][nx]]!=-1) continue; // 근데 다른 산타와 위치가 겹치면 이동 안 하고 
                    sDist = dist;
                    sDir = d;
                }
            }


            // 이동을 안 했을 경우 
            if (sDir == -1) continue;

            int ny = st.y + rdy[sDir]; // 산타가 밀려!!! 
            int nx = st.x + rdx[sDir];

            if (map[ny][nx] == INIT) st.move(sDir, 1, map, santas); //🔥🔥🔥🔥🔥빈칸일 때 1칸만 이동
            else { // 루돌프랑 충돌 시 온 방향의 반대 방향으로 D칸 밀려
                st.wakeupTurn = turn + 1; //🔥🔥🔥🔥🔥뭐야 왜 +2가 아니지 -> turn +2부터 이동 가능
                st.score += D;
                int newDir = (sDir + 2) % 4; //🔥🔥🔥🔥🔥
                st.move(newDir, D - 1, map, santas); //🔥🔥🔥🔥🔥반대 방향 로직 더 쉽게 수정
            }

        }



        // 3. 한 턴이 끝나면 점수 1점씩 증가
        bool stop = true;
        for (auto& st : santas) {
            if (!st.die) {
                st.score += 1; // 살아있기만 해
                stop = false;
            }
        }

        /*
        cout << turn << " 산타\n";
        print(map); //✅
        for (int i = 0; i < P; ++i) cout << santas[i].score << " ";
        cout << "\n\n\n";
        */

        if (stop) break; //🔥🔥🔥🔥4. 전원 탈락 시 조기 종료
    }

    // 5. 결과 출력
    for (int i = 0; i < P; ++i) cout << santas[i].score << " ";
    return 0;
}