24-H0ngJu

[H0ngJu]

🔗 문제 링크

아기상어

✔️ 소요된 시간

1.5H

✨ 수도 코드

문제요약
아기상어는 자신보다 작은 물고기만 먹을 수 있다. 주어진 공간에서 몇 초 동안 아기상어는 물고기를 먹을 수 있는가?
시간은 이동하는데 걸린 시간만 계산한다. 먹을 수 있는 물고기가 여러 마리인 경우, 가장 가까운 물고기를 먹는다.

문제를 보자마자 BFS라는 것을 다들 생각하셨을 것 같습니다.

이 문제가 까다롭다고 느낀건 단순한 BFS가 아니라, 갈 수 있는 노드(물고기)의 리스트가 생기면, 가장 가까운 곳을 가야 한다는 것을 추가로 관리 해줘야 한다는 점입니다.

그래서 저는 일단 tmp라는 임시 리스트들을 만들어주고,

아기 상어가 먹을 수 있는 물고기들의 위치와 거리를 넣어줬습니다.

tmp 리스트에 들어갈 수 있는 조건은

1. 아기 상어보다 작을 것
2. tmp 안에 있는 최소거리와 같거나 더 작을 것
   a. tmp 최소거리보다 더 작은 경우 : tmp를 초기화
   b. tmp 최소거리와 같은 경우 : tmp.appned()

즉,

if 0 < space[cx][cy] < baby:
            if dis < min_dis:
                min_dis = dis
                tmp = [(cx, cy)]
            elif dis == min_dis:
                tmp.append((cx, cy))

이렇게 됩니다.

그리고, 갈 수 있는 위치들을 다 조사했다면,
tmp 리스트 중에서 가장 작은 작은 것을 뽑아서, 아기 상어를 옮겨주면 됩니다.

여기까지 처리하고,,
당연히 통과겠지?하고 제출했는데 실패가 뜨더라고요

for i in range(N):
    for j in range(N):
        if space[i][j] == 9:
            x, y = i, j
            space[x][y] = 0 # 물고기가 아니기에 0으로 처리해줘야함!!!!!!!!!!!!!

처음 시작인 9에서,, 0으로 처리해줘야 한다는 걸 까먹고
또 한~참 들여다 봤습니다..

🤯🔨

📚 새롭게 알게된 내용

[9kyo-hwang]

허허 각 움직임마다 BFS 돌려서 최단거리 구할 생각이 왤케 안들었을까요...
한참 삽질하다가 겨우 떠올렸네요 ㅜ

전체 코드

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>
#include <algorithm>

using namespace std;

constexpr int BABY = 9;
const vector<pair<int, int>> Offset{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N; cin >> N;
    vector<vector<int>> Space(N, vector(N, 0));
    
    int X = 0, Y = 0;
    int SizeofBaby = 2, NumFishEaten = 0;
    
    for(int i = 0; i < N; ++i)
    {
        for(int j = 0; j < N; ++j)
        {
            cin >> Space[i][j];
            if(Space[i][j] == BABY)
            {
                X = i, Y = j;
                Space[i][j] = 0;
            }
        }
    }
    
    deque<tuple<int, int, int>> Q;
    vector<vector<bool>> Visited;
    
    auto CanEatFish = [&](int x, int y)
    {
        return 1 <= Space[x][y] && Space[x][y] < SizeofBaby;
    };
    
    auto CanMoveTo = [&](int x, int y)
    {
        if(x < 0 || x >= N || y < 0 || y >= N) return false;
        if(Visited[x][y]) return false;
        if(Space[x][y] > SizeofBaby) return false;
        
        return true;
    };
    
    int Tick = 0;
    while(true)
    {
        Q.clear();
        Visited.assign(N, vector(N, false));
        
        Q.emplace_back(X, Y, 0);
        Visited[X][Y] = true;
        
        int MinDistance = 400;
        vector<pair<int, int>> Candidates;
        
        while(!Q.empty())
        {
            const auto [x, y, d] = Q.front();
            Q.pop_front();
            
            if(CanEatFish(x, y))
            {
                if(d < MinDistance)
                {
                    MinDistance = d;
                    Candidates = {{x, y}};
                }
                else if(d == MinDistance)
                {
                    Candidates.emplace_back(x, y);
                }
            }
            
            for(const auto& [dx, dy] : Offset)
            {
                int nx = x + dx, ny = y + dy;
                if(!CanMoveTo(nx, ny)) continue;
                
                Visited[nx][ny] = true;
                Q.emplace_back(nx, ny, d + 1);
            }
        }
        
        if(Candidates.empty()) // Cannot Eat Fish Anymore
        {
            break;
        }
        
        pair<int, int> MinPoint = *min_element(Candidates.begin(), Candidates.end());
        Space[MinPoint.first][MinPoint.second] = 0;
        Tick += MinDistance;
        NumFishEaten++;
        
        if(SizeofBaby == NumFishEaten)
        {
            SizeofBaby++;
            NumFishEaten = 0;
        }
        
        X = MinPoint.first, Y = MinPoint.second;
    }
    
    cout << Tick;
    
    return 0;
}

[tgyuuAn]

와 저 첨에 BFS로 하다가 너무 신경써야할 부분이 많아서,

물고기 크기(최대), 물고기 스택(최대), 걸린 시간(최소), y(최소), x(최소) 힙으로 돌렸는데...

BFS도 가능하군요.........

from heapq import *
import sys

def input(): return sys.stdin.readline().rstrip()

N = int(input())
board = []
start = None
for row_idx in range(N):
    row = list(map(int, input().split()))
    if 9 in row: start = row_idx, (row.index(9))
    board.append(row)

board[start[0]][start[1]] = 0
dx = [0, -1, 1, 0]
dy = [-1, 0, 0, 1]

deq = []
heappush(deq,(-2, 0, 0, start[0], start[1]))
visited = set(start)
answer = 0
max_stack = 0
max_size = 2
while deq:
    now_size, now_stack, now_time, now_y, now_x = heappop(deq)
    now_size *= -1
    now_stack *= -1
    
    if max_size >= now_size and max_stack > now_stack: continue
    if max_size > now_size: continue

    if board[now_y][now_x] != 0 and board[now_y][now_x] < now_size:
        board[now_y][now_x] = 0
        visited = set()
        
        if now_stack + 1 == now_size: 
            now_size += 1
            now_stack = 0

        else: now_stack += 1
    
        max_size = now_size
        max_stack = now_stack
        answer += now_time
        now_time = 0
        
    for dir in range(4):
        new_y = now_y + dy[dir]
        new_x = now_x + dx[dir]

        if new_x < 0 or new_x >= N: continue
        if new_y < 0 or new_y >= N: continue
        if (new_x, new_y) in visited: continue
        if board[new_y][new_x] > max_size: continue
    
        heappush(deq,(now_size * -1, now_stack * -1, now_time + 1, new_y, new_x))
        visited.add((new_x, new_y))
    
print(answer)

아오 문제 잘못읽어서 시간을 와장창 날렸네요.......... ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ

같거나 작은 거만 지나갈 수 있는 거였군아....

[tgyuuAn]

얜 모에요 ??????

[H0ngJu]

ㅇㅣ 아이는 저번주 월요일 내다버린 pr..........

[tgyuuAn]

갈 수 있는 곳 tmp에 다 넣어놓고

마지막에 최소 거리랑 조건에 부합하는 곳으로 순간이동 ㅎㄷㄷㄷㄷㄷㄷㄷ

이걸 왜 생각 못했지...

[alstjr7437]

tmp를 이렇게 깔끔히 쓸 수 있군요 저는 너무 더럽게 썻네요 ㄷㄷㄷㄷㄷ....

[alstjr7437]

저는 약간 정석의 방법을 사용했어요!!

근데 물고기 찾고 먹는 부분에서 조금 오류가 걸렸던...

1. while문 돌기
2. bfs에서 갈 수 있는 물고기 찾아서 먹기
3. 이동한 거리를 더해준다
4. 다음 while문에서 다음 이동할 곳을 찾는다
5. 다음 이동할 곳이 없으면 break

식으로 풀었습니다!

from collections import deque

dx, dy = [0,0,-1,1], [1,-1,0,0]

N = int(input())
map = [list(map(int, input().split())) for _ in range(N)]

baby_shark = 2
shark_eaten = 0

for i in range(N):
    for j in range(N):
        if map[i][j] == 9:
            now_x, now_y = i, j
            map[i][j] = 0

def bfs():
    global now_x, now_y, baby_shark, shark_eaten

    queue = deque()
    queue.append((now_x, now_y))
    visited = [[False] * N for _ in range(N)]
    visited[now_x][now_y] = True
    distance = [[0] * N for _ in range(N)]
    temp = []

    while queue:
        x, y = queue.popleft()

        for i in range(4):
            nx, ny = x + dx[i], y + dy[i]
            if 0 <= nx < N and 0 <= ny < N:
                if not visited[nx][ny] and map[nx][ny] <= baby_shark:
                    queue.append((nx, ny))
                    visited[nx][ny] = True
                    distance[nx][ny] = distance[x][y] + 1
                    if 0 < map[nx][ny] < baby_shark:
                        temp.append((nx, ny, distance[nx][ny]))

    if temp:
        # 가장 가까운 물고기 찾기
        temp.sort(key=lambda x: (x[2], x[0], x[1]))
        target_x, target_y, dist = temp[0]

        # 물고기 먹기
        map[target_x][target_y] = 0
        shark_eaten += 1
        if shark_eaten == baby_shark:
            baby_shark += 1
            shark_eaten = 0

        now_x, now_y = target_x, target_y
        return dist  # 이동한 거리 반환

    return 0  # 더 이상 먹을 물고기가 없을 때

total_time = 0

while True:
    time = bfs()
    if time == 0:
        break
    total_time += time

print(total_time)

[alstjr7437]

tmp를 이렇게 깔끔히 쓸 수 있군요 저는 너무 더럽게 썻네요 ㄷㄷㄷㄷㄷ....