13-mj111

[mjj111]

🔗 문제 링크

백준 - 낚시왕
https://www.acmicpc.net/problem/17143

✔️ 소요된 시간

1시간 30분

✨ 수도 코드

해당 문제는 상어가 방향과 크기에 따라 이동하는 와중에 왼쪽 열에서 오른쪽 열로 상어를 잡는 문제입니다!
이후, 잡은 상어 크기의 합을 출력하면 됩니다.

먼저 주어진 입력을 받아주고

        for(int i = 1; i <= SARK_COUNT; i++) {
            st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            int speed = Integer.parseInt(st.nextToken());
            int direction = Integer.parseInt(st.nextToken());
            int size = Integer.parseInt(st.nextToken());

            map[x][y] = i;
            sharks.add(new Shark(i, x, y, speed, direction, size));
        }

한 열씩 잡으며, 상어를 이동시키면 됩니다.

        int answer = 0;
        for(int i = 1; i <= COLUMN; i++) {
            answer += getShark(i);
            moveShark();
        }

        System.out.println(answer);

상어를 잡을 떄는 주어진 열값에 의해 상어를 수집합니다.
여기서 중요한 점은, 해당 상어를 무효화 해야한다는 점입니다!
그렇기 때문에 상어를 죽었다 표시하고
주어진 map에서 지워줍니다.

    private static int getShark(int now) {
        for(int i = 1; i <= ROW; i++) {
            int sharkNumber = map[i][now];

            if(sharkNumber != 0) {
                Shark s = sharks.get(sharkNumber-1);
                s.alive = false;
                map[i][now] = 0;
                return s.size;
            }
        }
        return 0;
    }

상어를 이동시키는 방법은 주어진 방향으로 속도만큼 움직이도록 합니다.
여기서 주의할 점은 상어의 이동방향을 따라 움직이다 벽에 부딪힐 경우 방향을 반대로 틀고 이동시켜야한다는 점입니다!

    private static void moveShark() {
        int[][] copyMap = new int[ROW+1][COLUMN+1];

        for(Shark s : sharks) {
            if(!s.alive) continue;

            int speed = s.speed;
            while(speed-- > 0) {
                int nextX = s.x + dx[s.direction];
                int nextY = s.y + dy[s.direction];

                if(isOutRange(nextX, nextY)) {
                    s.changeDirection();
                    speed++;
                    continue;
                }

                s.x = nextX;
                s.y = nextY;
            }

            if(copyMap[s.x][s.y] != 0) {
                Shark op = sharks.get(copyMap[s.x][s.y] - 1);
                if(s.size < op.size) {
                    s.alive = false;
                    continue;
                } else {
                    op.alive = false;
                }
            }

            copyMap[s.x][s.y] = s.number;
        }

        for(int i = 1; i <= ROW; i++) {
            for(int j = 1; j <= COLUMN; j++) {
                map[i][j] = copyMap[i][j];
            }
        }
    }

📚 새롭게 알게된 내용

문제를 읽으면서 요구사항을 얻어내는데 조금 힘들었습니다..
더불어 Java로 구현하니 조금 더 어려운것도 느껴졌네요 ㅎ (이제는 파이썬으로 가겠습니다)

빡구현은 구현보다, 요구사항을 잘 이해하는게 관건임을 체감했습니다.

[9kyo-hwang]

후....

처음에는 격자 칸 크기가 최대 100 x 100 인 거 보고 매 반복마다 격자 쫙 훑어서 상어 옮기고 잡아먹는 처리를 하도록 작성했는데, 최대 14%쯤인가에서 시간초과나네요...

이론 상 낚시왕 옮기는 거 100번 x 매 이동마다 상어 잡기 최대 100칸 x 상어 이동을 위한 그리드 훑기 100 x 100... 따져보니 연산 1억번 넘길 수도 있겠다 싶더라구요...

그래서 상어 정보를 담는 배열을 생성해서 걔네들만 훑도록 수정하니 시간 안에 통과하네요 후...

빡구현은 정말 싫습니다...

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const vector<pair<int, int>> Offset{ {0, 0}, { -1, 0 }, {1, 0}, {0, 1}, {0, -1} };

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

struct FShark
{
    int R, C;
    int Speed;
    int Direction;
    int Size;
    bool IsDead;

    FShark(int InR, int InC, int InS, int InD, int InZ)
        : R(InR)
        , C(InC)
        , Speed(InS)
        , Direction(InD)
        , Size(InZ)
        , IsDead(false)
    {

    }
};

vector<FShark*> Sharks;
vector<vector<int>> Grid;

void Move()
{
    for (FShark* Shark : Sharks)
    {
        if (Shark->IsDead) continue;

        int Speed = Shark->Speed, Direction = Shark->Direction, Size = Shark->Size;
        int r = Shark->R, c = Shark->C;
        Grid[r][c] = -1;
        
        int nr, nc;
        while (true)
        {
            nr = r + Speed * Offset[Direction].first;
            nc = c + Speed * Offset[Direction].second;

            if (!OutOfBound(nr, nc))
            {
                break;
            }

            switch (Direction)
            {
            case 1:
                Speed -= (r - 1);
                r = 1;
                Direction = 2;
                break;
            case 2:
                Speed -= R - r;
                r = R;
                Direction = 1;
                break;
            case 3:
                Speed -= C - c;
                c = C;
                Direction = 4;
                break;
            case 4:
                Speed -= (c - 1);
                c = 1;
                Direction = 3;
                break;
            }
        }

        Shark->R = nr;
        Shark->C = nc;
        Shark->Direction = Direction;
    }
}

void Update()
{
    for (int Index = 0; Index < M; ++Index)
    {
        FShark* Shark = Sharks[Index];
        if (Shark->IsDead) continue;

        int R = Shark->R, C = Shark->C;
        if (Grid[R][C] == -1)
        {
            Grid[R][C] = Index;
        }
        else
        {
            int OtherIndex = Grid[R][C];
            FShark* Other = Sharks[OtherIndex];

            if (Shark->Size > Other->Size)
            {
                Other->IsDead = true;
                Grid[R][C] = Index;
            }
            else
            {
                Shark->IsDead = true;
            }
        }
    }
}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);

    cin >> R >> C >> M;
    Sharks.resize(M);
    Grid.assign(R + 1, vector<int>(C + 1, -1));

    for (int i = 0; i < M; ++i)
    {
        int r, c, s, d, z; cin >> r >> c >> s >> d >> z;
        Grid[r][c] = i;
        Sharks[i] = new FShark(r, c, s, d, z);
    }

    int Answer = 0;
    for (int c = 1; c <= C; ++c)
    {
        for (int r = 1; r <= R; ++r)
        {
            const int Index = Grid[r][c];
            if (Index > -1)
            {
                Answer += Sharks[Index]->Size;
                Sharks[Index]->IsDead = true;
                Grid[r][c] = -1;
                break;
            }
        }

        Move();
        Update();
    }

    cout << Answer;

    return 0;
}

[9kyo-hwang]

매 상어마다 한 칸씩 이동 판정을 주는 것도 생각보다 시간을 좀 잡아먹는 것 같습니다.
처음에 시간 안에 통과한 코드가 느린 게 약간 이 문제도 있는 것 같습니다.
speed랑 방향을 이용해 다음 좌표를 한 번에 얻고, bound를 넘어가는 것에 대한 보정을 주는 형식으로 반복 횟수를 줄이는 것도 좋을 것 같습니다.

[mjj111]

저 당시에 스피드에 맞춰서 평 튕기는 인덱스 계산하기 보다 그냥 speed 안에 동작하도록 하는게 계산해보니 시간 초과가 안남는 크기라서 그랬던거같아요!

빡구현 빨리 푸는데 집중해서 정신이 없었어요 ㅋㅋㅋㅋㅋ ㅠ

[9kyo-hwang]

각 상어가 좌표 정보와 살았는가/죽었는가 정보도 들고 있으니,
Move 함수 내에서는 상어를 옮기는 기능만 하고 상어 잡아먹는 처리는 별도의 함수에서 처리하게 하는 것도 좋을 것 같습니다.

[gjsk132]

배열에 상어 정보를 넣고,
낚시왕이 있는 열에서 가장 땅에 가까운 상어를 잡습니다

그 후 살아있는 상어 수만큼 pop해줘서
상어의 위치에 상어의 크기가 그대로 인지 확인하는 과정으로 생사여부를 확인하고
상어를 이동시키는 것을 반복해서 해결했습니다!

전체 코드

from collections import deque

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

R, C, M = map(int,input().split())

shark_cnt = M
dq = deque([])

table = [[0]*C for _ in range(R)]

for _ in range(M):
    r, c, s, d, z = map(int, input().split())

    if not s:
        s = s % (2*R-2) if d <= 2 else s % (2*C-2)

    table[r-1][c-1] = max(table[r-1][c-1], z)
    dq.append((r-1, c-1, s, d, z))

result = 0

for i in range(C):
    
    # fishing
    for j in range(R):
        if not table[j][i]:
            continue
        
        result += table[j][i]
        table[j][i] = 0
        break

    # shark_check
    for _ in range(shark_cnt):
        r, c, s, d, z = dq.popleft()

        if not table[r][c] == z:
            shark_cnt -= 1
            continue
        else:
            table[r][c] = 0
            dq.append(( r, c, s, d, z ))

    # shark_move
    for _ in range(shark_cnt):
        
        r, c, s, d, z = dq.popleft()

        # 1 : 위 / 2 : 아래 / 3 : 오른쪽 / 4 : 왼쪽
        if d <= 2:
            r += -s if d==1 else s

            while not 0 <= r < R:
                r = abs(r) if r < 0 else 2*R-2-r
                d = 1 if d==2 else 2

        else:
            c += s if d == 3 else -s

            while not 0 <= c < C:
                c = abs(c) if c <0 else 2*C-2-c
                d = 3 if d == 4 else 4

        table[r][c] = max(table[r][c], z)
        dq.append((r, c, s, d, z))
    
print(result)

나름 스무스하게 풀어서 기분이 좋네요 :)

[xxubin04]

조금 구현하다가 너무 복잡해서 포기했네요.. 수고많으셨습니다!!
상어가 끝에 다다랐을 때 방향 바꿔주는 것도 일일이 해주어야 하고, 그리고 바뀐 위치도 계속 갱신해주어야 하는게 생각보다 어렵네요.
이뿐만 아니라 같은 위치에 여러 상어가 있으면 크기 비교해주는 거랑 가장 위의 상어가 낚시되어 없어지는 것도 생각해야하고 여러모로 복잡한 문제네요..😭