16-mjj111

[mjj111]

🔗 문제 링크

루돌프의 반란

✔️ 소요된 시간

3시간...

✨ 수도 코드

해당 문제는 주어진 방식에 맞춰 루돌프를 움직이고,
산타를 움직인 뒤,
살아있는 산타에게 점수 상승을 시켜
결과적으로 각 산타가 점수가 얼마있는지 출력하면 됩니다.

while santas.has_living() and turn < m:
    turn += 1
    rudolph.move(santas, board, turn)
    santas.move(rudolph, board, turn)
    santas.alive_plus()
santas.print_points()

루돌프가 움직일 때는 루돌프와 산타간의 거리가 가깝고, x좌표가 크고 y좌표가 큰 순으로
최적의 산타를 가져옵니다.

def move(self, santas, board, turn):
        santa = santas.get_clost(self.x, self.y)

루돌프가 산타를 향해 돌진하는데 만약 부딪혔다면 연쇄적으로 산타는 한 칸씩 밀려나야합니다.

            else:
                santas.check(santa, board, self.dx[direction], self.dy[direction])

밀려난 산타는 자신이 떨어질 위치에 존재할 산타를 한 칸씩 재귀를 통해 밀어줍니다.

def check(self, santa, board, move_x, move_y) :
        if board[santa.x][santa.y] == 0:
            board[santa.x][santa.y] = santa.number
            return 
        
        located_santa = self.santa_dict[board[santa.x][santa.y]]
        board[santa.x][santa.y] = santa.number

        located_santa.x += move_x
        located_santa.y += move_y 

        if is_out(located_santa.x, located_santa.y):
            located_santa.is_out = True
            return 

        self.check(located_santa, board, move_x, move_y) 

산타의 움직임은 조금 복잡합니다.
산타의 순번대로 접근하여 움직이되, 만약 기절한 상태거나 장외일 경우 움직이지 못합니다.

        for santa in self.santa_list:
            if santa.is_out or santa.is_sturned >= turn:
                continue

현재 산타를 기준으로 루돌프를 향해 갈 수 있는 최적의 방향으로 움직입니다.

def move(self, rudolph, board, turn):
            ...
            now_distance = get_distance(santa.x, santa.y, rudolph.x, rudolph.y)
            best_distance = now_distance
            best_move = None

            for i in range(4):
                next_x = santa.x + self.dx[i]
                next_y = santa.y + self.dy[i]

                if is_out(next_x, next_y) or board[next_x][next_y] >= 1:
                    continue

                next_distance = get_distance(next_x, next_y, rudolph.x, rudolph.y)
                if next_distance < best_distance:
                    best_distance = next_distance
                    best_move = (next_x, next_y, i)

            if best_move:
                next_x, next_y, direction = best_move
                board[santa.x][santa.y] = 0
                santa.x, santa.y = next_x, next_y

                if board[next_x][next_y] == 0:  
                    board[santa.x][santa.y] = santa.number

만약 산타가 움직이다가 루돌프를 만날겨우 산타의 힘만큼 다시 뒤로 물러나 지며,
물러나질때, 다른 산타가 있으면 도미노처럼 한 칸씩 밀립니다.

               ....
                elif board[next_x][next_y] == -1:
                    santa.point += self.power 
                    santa.is_sturned = turn + 1

                    direction = (direction + 2) % 4 
                    move_x, move_y = self.dx[direction], self.dy[direction]

                    next_x = santa.x + move_x * self.power 
                    next_y = santa.y + move_y * self.power 
                    
                    if is_out(next_x, next_y) :
                        santa.is_out = True 
                        continue 

                    santa.x, santa.y = next_x, next_y
                    self.check(santa, board, move_x, move_y)

각 턴이 끝날 때마다, 장내에 있는 산타는 점수를 획득합니다.

def alive_plus(self):
        for santa in self.santa_list:
            if not santa.is_out: 
                santa.point += 1

이후 각 산타의 점수를 출력합니다..

def print_points(self):
        for santa in self.santa_list:
            print(santa.point, end = " ")

📚 새롭게 알게된 내용

이 정도의 빡구현은, 일단 설계하고 구현한뒤에
하나씩 결과를 출력해서 디버깅하는 방향으로 진행해야할 것같습니다.

구현 후 결과값을 비교했는데 틀리면,
빡구현 문제는 구현이 복잡해서 디버깅이 어려우므로
중간마다 확인할 수 있게 구현을 분리하면 좋을 것 같아요 🤔

[9kyo-hwang]

2시간 박고 GG 쳤습니다..
명준님 코드 보고 갈아엎었는데도 안되네요 ㅜ
나중에 재도전 하겠습니다...

틀린 전체 코드

#include <iostream>
#include <vector>
#include <set>
#include <unordered_map>
#include <algorithm>

using namespace std;

constexpr int MAX_DISTANCE = 2500;
const vector<pair<int, int>> SantaOffset{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
const vector<pair<int, int>> RudolphOffset{{-1, 0}, {-1, 1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}};

inline int GetDistanceBetween(int r1, int c1, int r2, int c2)
{
    return (r1 - r2) * (r1 - r2) + (c1 - c2) * (c1 - c2);
}

struct FSanta
{
    int Power;
    int Number;
    int R, C;
    bool bOut;
    int Score;
    int StunnedTurn;

    FSanta(int InPower, int InNumber, int InR, int InC)
    : Power(InPower)
    , Number(InNumber)
    , R(InR)
    , C(InC)
    , bOut(false)
    , Score(0)
    , StunnedTurn(0)
    {}
};

struct FRudolph
{
    int Power;
    int R, C;
    
    FRudolph(int InPower, int InR, int InC)
    : Power(InPower)
    , R(InR)
    , C(InC)
    {}
};

int N, M, P, C, D;
vector<vector<int>> Board;
FRudolph* Rudolph;
vector<FSanta*> SantaList;
unordered_map<int, FSanta*> SantaMap;

inline bool OutOfBound(int r, int c)
{
    return !(1 <= r && r <= N && 1 <= c && c <= N);
}

inline bool bAllSantasOut()
{
    for(const FSanta* Santa : SantaList)
    {
        if(false == Santa->bOut)
        {
            return false;
        }
    }

    return true;
}

void Interaction(FSanta* InSanta, const int dr, const int dc)
{
    if(Board[InSanta->R][InSanta->C] == 0)
    {
        Board[InSanta->R][InSanta->C] = InSanta->Number;
        return;
    }

    FSanta* Santa = SantaMap[Board[InSanta->R][InSanta->C]];
    Board[InSanta->R][InSanta->C] = InSanta->Number;

    Santa->R += dr;
    Santa->C += dc;

    if(OutOfBound(Santa->R, Santa->C))
    {
        Santa->bOut = true;
        return;
    }

    Interaction(Santa, dr, dc);
}

FSanta* GetNearestSanta()
{
    vector<FSanta*> Candidates;
    int NearestDistance = MAX_DISTANCE;

    for(FSanta* Santa : SantaList)
    {
        if(Santa->bOut)
        {
            continue;
        }

        int Distance = GetDistanceBetween(Rudolph->R, Rudolph->C, Santa->R, Santa->C);
        if(Distance < NearestDistance)
        {
            Candidates.clear();
            NearestDistance = Distance;
            Candidates.emplace_back(Santa);
        }
        else if(Distance == NearestDistance)
        {
            Candidates.emplace_back(Santa);
        }
    }

    sort(Candidates.begin(), Candidates.end(),
    [&](const FSanta* Lhs, const FSanta* Rhs)
    {
        if(Lhs->R == Rhs->R) return Lhs->C > Rhs->C;
        return Lhs->R > Rhs->R;
    });

    return Candidates.front();
}

void MoveRudolph(int InTurn)
{
    FSanta* NearestSanta = GetNearestSanta();
    int NearestDistance = MAX_DISTANCE;
    int NearestDirection = -1;

    for(int Dir = 0; Dir < RudolphOffset.size(); ++Dir)
    {
        int nr = Rudolph->R + RudolphOffset[Dir].first;
        int nc = Rudolph->C + RudolphOffset[Dir].second;

        if(OutOfBound(nr, nc))
        {
            continue;
        }

        int Distance = GetDistanceBetween(nr, nc, NearestSanta->R, NearestSanta->C);
        if(Distance < NearestDistance)
        {
            NearestDirection = Dir;
            NearestDistance = Distance;
        }
    }

    int nr = Rudolph->R + RudolphOffset[NearestDirection].first;
    int nc = Rudolph->C + RudolphOffset[NearestDirection].second;
    
    Board[Rudolph->R][Rudolph->C] = 0;
    Rudolph->R = nr, Rudolph->C = nc;
    Board[Rudolph->R][Rudolph->C] = -1;

    if(nr == NearestSanta->R && nc == NearestSanta->C)
    {
        NearestSanta->Score += Rudolph->Power;
        NearestSanta->StunnedTurn = InTurn;
        NearestSanta->R += RudolphOffset[NearestDirection].first * Rudolph->Power;
        NearestSanta->C += RudolphOffset[NearestDirection].second * Rudolph->Power;

        if(OutOfBound(NearestSanta->R, NearestSanta->C))
        {
            NearestSanta->bOut = true;
        }
        else
        {
            Interaction(NearestSanta, RudolphOffset[NearestDirection].first, RudolphOffset[NearestDirection].second);
        }
    }
}

void MoveSanta(int InTurn)
{
    for(FSanta* Santa : SantaList)
    {
        if(Santa->bOut || InTurn < Santa->StunnedTurn + 2)
        {
            continue;
        }

        int NearestDistance = GetDistanceBetween(Rudolph->R, Rudolph->C, Santa->R, Santa->C);
        int NearestDirection = -1;
        for(int Dir = 0; Dir < SantaOffset.size(); ++Dir)
        {
            int nr = Santa->R + SantaOffset[Dir].first;
            int nc = Santa->C + SantaOffset[Dir].second;
            
            if(OutOfBound(nr, nc) || Board[nr][nc] >= 1)
            {
                continue;
            }

            int Distance = GetDistanceBetween(Rudolph->R, Rudolph->C, nr, nc);
            if(Distance < NearestDistance)
            {
                NearestDistance = Distance;
                NearestDirection = Dir;
            }
        }

        if(NearestDirection == -1)
        {
            continue;
        }

        int nr = Santa->R + SantaOffset[NearestDirection].first;
        int nc = Santa->C + SantaOffset[NearestDirection].second;

        Board[nr][nc] = 0;
        Santa->R = nr, Santa->C = nc;
        if(Board[nr][nc] == 0)
        {
            Board[nr][nc] = Santa->Number;
        }
        else if(Board[nr][nc] == -1)
        {
            Santa->Score += Santa->Power;
            Santa->StunnedTurn = InTurn;

            int Reverse = (NearestDirection + 2) % 4;
            int dr = SantaOffset[Reverse].first;
            int dc = SantaOffset[Reverse].second;

            nr = Santa->R + dr * Santa->Power;
            nc = Santa->C + dc * Santa->Power;

            if(OutOfBound(nr, nc))
            {
                Santa->bOut = true;
            }
            else
            {
                Santa->R = nr;
                Santa->C = nc;
                Interaction(Santa, dr, dc);
            }
        }
    }
}

int main() 
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> M >> P >> C >> D;

    int Rr, Rc; cin >> Rr >> Rc;

    Rudolph = new FRudolph(C, Rr, Rc);

    Board.assign(N + 1, vector<int>(N + 1, 0));
    Board[Rr][Rc] = -1;

    for(int i = 0; i < P; ++i)
    {
        int Pn, Sr, Sc; cin >> Pn >> Sr >> Sc;
        Board[Sr][Sc] = Pn;

        FSanta* Santa = new FSanta(D, Pn, Sr, Sc);
        SantaList.push_back(Santa);
        SantaMap[Pn] = Santa;
    }

    sort(SantaList.begin(), SantaList.end(),
    [&](const FSanta* Lhs, const FSanta* Rhs)
    {
        return Lhs->Number < Rhs->Number;
    });

    for(int Turn = 1; false == bAllSantasOut() && Turn <= M; ++Turn)
    {
        MoveRudolph(Turn);
        MoveSanta(Turn);
        for(FSanta* Santa : SantaList)
        {
            if(false == Santa->bOut)
            {
                Santa->Score++;
            }
        }
    }

    for(const FSanta* Santa : SantaList)
    {
        cout << Santa->Score << " ";
    }

    return 0;
}

[mjj111]

2시간 박고 GG 쳤습니다.. 명준님 코드 보고 갈아엎었는데도 안되네요 ㅜ 나중에 재도전 하겠습니다...

틀린 전체 코드

코드 보니까 매 차 움직이는거 print 해서 디버깅하면, 추가 1시간안에 푸실거 같은데요..?

[gjsk132]

루돌프 머리 깨질 것 같아요.... 그만할래요...ㅜㅠㅠ

충돌이랑 상호작용하는데서, 루돌프가 목표를 저한테로 돌렸는지 죽을 것 같아서, 포기했슴니다.🥲

포기...

input = open("input.txt").readline

size, turn, santa_alive, r_force, s_force = map(int,input().split())

r_x, r_y = map(int,input().split())
limit = float('inf')

s_offset = [(-1,0), (0, 1), (1, 0), (0, -1)]

santa_poses = [0]*santa_alive

# 0 : alive / 1: stun / 2 : dead
santa_status = [0]*santa_alive

santa_score = [0]*santa_alive

for _ in range(santa_alive):
    s_num, s_x, s_y = map(int,input().split())
    santa_poses[s_num-1] = [s_x, s_y]

def rudolph_move(r_x, r_y):
    nearest_idx = 0
    n_x, n_y = 0, 0
    min_dist = limit

    for idx, pos in enumerate(santa_poses):
        sx, sy = pos
        dist = pow((r_x-sx), 2) + pow((r_y-sy), 2)

        if dist > min_dist:
            continue
        elif dist == min_dist:
            if sx < n_x:
                continue
            
            if sx == n_x and sy < n_y:
                continue
        
        min_dist = dist
        n_x, n_y = sx, sy
        nearest_idx = idx

    force = [0, 0]

    if r_x > santa_poses[nearest_idx][0]:
        r_x -= 1
        force[0] -= 1
    elif r_x < santa_poses[nearest_idx][0]:
        r_x += 1
        force[0] += 1
    
    if r_y > santa_poses[nearest_idx][1]:
        r_y -= 1
        force[1] -= 1
    elif r_y < santa_poses[nearest_idx][1]:
        r_y += 1
        force[1] += 1

    return r_x, r_y, force, nearest_idx

def santa_move(idx):
    
    sx, sy = santa_poses[idx]

    min_dist = pow((r_x-sx), 2) + pow((r_y-sy), 2)

    m_x, m_y = 0, 0

    for dx, dy in s_offset:
        px, py = sx + dx, sy + dy

        dist = pow((r_x-px), 2) + pow((r_y-py), 2)
        if dist < min_dist:
            min_dist = dist
            m_x, m_y = dx, dy

    return sx+m_x, sy+m_y, [m_x, m_y]

def santa_interaction(idx2, move):
    
    sx, sy = santa_poses[idx2]
    sx += move[0]
    sy += move[1]

    if not 0 <= sx < size or not 0 <= sy < size:
        santa_status[idx2] = 2
    else:
        santa_poses[idx2] = [sx, sy]
        
        if [sx, sy] in santa_poses:
            santa_interaction(santa_poses.index([sx, sy]), move)

    return

r_x, r_y, move, idx = rudolph_move(r_x, r_y)

# 루돌프가 산타한테 충돌할 때
if [r_x, r_y] == santa_poses[idx]:
    sx, sy = santa_poses[idx]

    sx += r_force * move[0]
    sy += r_force * move[1]

    if not 0 <= sx < size or not 0 <= sy < size:
        santa_status[idx] = 2
    else:
        santa_status[idx] = 1
        santa_poses[idx] = [sx, sy]

        if [sx, sy] in santa_poses:
            santa_interaction(santa_poses.index([sx, sy]), move)

print(santa_poses)

# 산타의 움직임
for idx in range(santa_alive):
    if santa_status[idx] == 2:
        continue
    elif santa_status[idx] == 1:
        santa_status[idx] = 0
    
    sx, sy, move = santa_move(idx)
    
    if [r_x, r_y] == santa_poses[idx]:
        sx -= s_force * move[0]
        sy -= s_force * move[1]

        if not 0 <= sx < size or not 0 <= sy < size:
            santa_status[idx] = 2
        else:
            santa_poses[idx] = [sx, sy]
            santa_status[idx] = 1

            if [sx, sy] in santa_poses:
                santa_interaction(santa_poses.index([sx, sy]), move)

print(santa_poses)
print(santa_status)
print(r_x, r_y)