BJ17143 낚시왕

https://www.acmicpc.net/problem/17143

huntingShark(i); moveShark(); arrangeShark();
각 턴마다 필요한 위 함수들을 구현해 활용했다.

상어끼리 잡아먹어 정리하는 과정에서 초기화를 잘못해주는 실수를 했고,

또, ArrayList가 아닌 LinkedList를 이용해 각 리스트 인덱스에 접근하는 시간이 많이 들어 시간초과 문제가 생기기도 했다.

문제를 푸는 데에 많은 시간이 들었지만, 덕분에 두 리스트의 차이에 대해 다시 되새길 수 있는 계기가 되었다.

package day0413;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class KingofFishing {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st;
	static int R, C, M, answer = 0;
	static ArrayList<Shark> sList;
	static Shark[][] map;

	static class Shark implements Comparable<Shark> {
		int x;
		int y;
		int s; // 속력
		int d; // 방향
		int z; // 크기

		public Shark(int x, int y, int s, int d, int z) {
			super();
			this.x = x;
			this.y = y;
			this.s = s;
			this.d = d;
			this.z = z;
		}

		@Override
		public int compareTo(Shark o) {
			return this.x - o.x != 0 ? this.x - o.x : ((this.y - o.y != 0) ? this.y - o.y : (o.z - this.z));
		}
	}

	static void moveShark() {
		for (Shark s : sList) {
			switch (s.d) { // 상 하 우 좌
			case 1:
				s.x -= s.s % (R * 2 - 2);
				while (s.x < 0 || s.x >= R) {
					if (s.x < 0) {
						s.x = -s.x;
						s.d = 2;
					}
					if (s.x >= R) {
						s.x = (R - 1) - (s.x - (R - 1));
						s.d = 1;
					}
				}
				break;
			case 2:
				s.x += s.s % (R * 2 - 2);
				while (s.x < 0 || s.x >= R) {
					if (s.x < 0) {
						s.x = -s.x;
						s.d = 2;
					}
					if (s.x >= R) {
						s.x = (R - 1) - (s.x - (R - 1));
						s.d = 1;
					}
				}
				break;
			case 3:
				s.y += s.s % (C * 2 - 2);
				while (s.y < 0 || s.y >= C) {
					if (s.y < 0) {
						s.y = -s.y;
						s.d = 3;
					}
					if (s.y >= C) {
						s.y = (C - 1) - (s.y - (C - 1));
						s.d = 4;
					}
				}
				break;
			case 4:
				s.y -= s.s % (C * 2 - 2);
				while (s.y < 0 || s.y >= C) {
					if (s.y < 0) {
						s.y = -s.y;
						s.d = 3;
					}
					if (s.y >= C) {
						s.y = (C - 1) - (s.y - (C - 1));
						s.d = 4;
					}
				}
				break;
			}
		}
	}

	static void arrangeShark() { // 위치가 겹치는 상어 정리.
		map = new Shark[R][C];
		int size = sList.size();
		for (int i = size - 1; i >= 0; i--) {
			Shark s = sList.get(i);
			if (map[s.x][s.y] == null) {
				map[s.x][s.y] = s;
				continue;
			}
			if(map[s.x][s.y].z < s.z) {
				sList.remove(map[s.x][s.y]);
				map[s.x][s.y] = s;
			} else {
				sList.remove(s);
			}
		}
	}

	static void huntingShark(int idx) {
		for (int i = 0; i < R; i++) {
			if (map[i][idx] != null) {
				answer += map[i][idx].z;
				sList.remove(map[i][idx]);
				map[i][idx] = null;
				return;
			}
		}

	}

	static void printmap() {
		for (int i = 0; i < R; i++) {
			for (int j = 0; j < C; j++) {
				if (map[i][j] == null) {
					System.out.print("0 ");
				} else {
					System.out.print(map[i][j].z + " ");
				}
			}
			System.out.println();
		}
		System.out.println(answer);
	}

	public static void main(String[] args) throws IOException {
		st = new StringTokenizer(br.readLine());
		R = Integer.parseInt(st.nextToken());
		C = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		sList = new ArrayList<>();
		map = new Shark[R][C];
		for (int i = 0; i < M; i++) {
			st = new StringTokenizer(br.readLine());
			sList.add(new Shark(Integer.parseInt(st.nextToken()) - 1, Integer.parseInt(st.nextToken()) - 1,
					Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()),
					Integer.parseInt(st.nextToken())));
			Shark tmp = sList.get(i);
			map[tmp.x][tmp.y] = tmp;
		}
		//printmap();
		for (int i = 0; i < C; i++) {
			huntingShark(i);
			moveShark();
			arrangeShark();

			//printmap();
			

		}
		bw.append(answer + "");
		bw.flush();
	}
}