모노미노도미노

• 3차배열로 하나로 초록, 파랑 모두 구현
  x, y초록구간에서 사용한후 시계방향으로 90도 회전해서 파랑구간에서 사용

• 1 => 블럭하나
  2 => 가로로 긴 블럭
  3 => 세로로 긴 블럭
  types 배열에 저장한다

  블럭이 삭제 당하면서 3(세로로 긴 블럭)이 1(블럭하나)가 되기도 한다

• 삭제 함수 구현(del) 블럭을 내려주는 함수 구현(lean)

• 삭제가 되었다면 lean을 호출하고 또 다시 del을 호출한다 삭제 할 것이 없다면 함수를 빠져나온다

import java.util.Scanner;

public class Main {

	static int[][][] map;
	static int[][] types;
	static int score = 0;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int N = sc.nextInt();

		types = new int[2][N + 1];

		map = new int[2][10][4];

		for (int i = 1; i <= N; i++) {
			int type = sc.nextInt();
			types[0][i] = type;
			if (type == 2)
				types[1][i] = 3;
			else if (type == 3)
				types[1][i] = 2;
			else
				types[1][i] = 1;
			int x = sc.nextInt();
			int y = sc.nextInt();
      //초록구간
			for (int j = 4; j < 11; j++) {
				if (type == 1 && (j == 10 || map[0][j][y] != 0)) {
					map[0][j - 1][y] = i;
					break;
				}
				if (type == 2 && (j == 10 || (map[0][j][y] != 0 || map[0][j][y + 1] != 0))) {
					map[0][j - 1][y] = i;
					map[0][j - 1][y + 1] = i;
					break;
				}
				if (type == 3 && (j == 10 || map[0][j][y] != 0)) {
					map[0][j - 1][y] = i;
					map[0][j - 2][y] = i;
					break;
				}
			}
      //파랑구간
			int tmp = x;
			x = y;
			y = 3 - tmp;
			for (int j = 4; j < 11; j++) {
				if (type == 1 && (j == 10 || map[1][j][y] != 0)) {
					map[1][j - 1][y] = i;
					break;
				}
				if (type == 2 && (j == 10 || (map[1][j][y] != 0))) {
					map[1][j - 1][y] = i;
					map[1][j - 2][y] = i;
					break;
				}
				if (type == 3 && (j == 10 || map[1][j][y] != 0 || map[1][j][y - 1] != 0)) {
					map[1][j - 1][y] = i;
					map[1][j - 1][y - 1] = i;
					break;
				}
			}
			del();
		}
		int num = 0;
		for (int k = 0; k < 2; k++) {
			for (int i = 6; i < 10; i++) {
				for (int j = 0; j < 4; j++) {
					if (map[k][i][j] != 0)
						num++;
				}
			}
		}
		System.out.println(score);
		System.out.println(num);
	}
	//한줄이 차거나 0,1에 블럭이 있을경우 삭제해주는 함수
	static void del() {
		for (int k = 0; k < 2; k++) {
			boolean[] check = new boolean[2];
			// 한줄이 다 차면 삭제하는 로직 먼저해준다
			loop: for (int i = 6; i < 10; i++) {
				for (int j = 0; j < 4; j++) {
					if (map[k][i][j] == 0)
						continue loop;
				}
				check[k] = true;
				score++;
				for (int j = 0; j < 4; j++) {
					if (types[k][map[k][i][j]] == 3)
						types[k][map[k][i][j]] = 1;
					map[k][i][j] = 0;
				}
				
			}
			// lean으로 보내는 함수
			if (check[0] || check[1])
				lean(check);
			check = new boolean[2];
			int cnt = 0;
			// 0, 1번 행렬에 값이 있을 경우 삭제하는 로직
			for (int i = 4; i < 6; i++) {
				for (int j = 0; j < 4; j++) {
					if (map[k][i][j] != 0) {
						cnt++;
						check[k] = true;
						break;
					}
				}
			}
			for (int i = 10 - cnt; i < 10; i++) {
				for (int j = 0; j < 4; j++) {
					if (types[k][map[k][i][j]] == 3)
						types[k][map[k][i][j]] = 1;
					map[k][i][j] = 0;
				}
			}
			// lean으로 보내는 함수
			if (check[0] || check[1])
				lean(check);
		}
	}
	//블럭을 확인하고 최대한 아래로 내려준다
	static void lean(boolean[] lean) {
		for (int n = 0; n < 2; n++) {
			if (!lean[n])
				continue;
			for (int i = 9; i >= 4; i--) {
				for (int j = 0; j < 4; j++) {
					if (map[n][i][j] == 0)
						continue;
					if (types[n][map[n][i][j]] == 1) {
						int tmp = map[n][i][j];
						for (int k = i + 1; k < 11; k++) {
							if (k == 10 || (k < 10 && map[n][k][j] != 0)) {
								map[n][i][j] = 0;
								map[n][k - 1][j] = tmp;
								break;
							}
						}
					}
					if (types[n][map[n][i][j]] == 3 && map[n][i][j] == map[n][i - 1][j]) {
						int tmp = map[n][i][j];
						for (int k = i + 1; k < 11; k++) {
							if (k == 10 || (k < 10 && map[n][k][j] != 0)) {
								map[n][i][j] = 0;
								map[n][i - 1][j] = 0;
								map[n][k - 1][j] = tmp;
								map[n][k - 2][j] = tmp;
								break;
							}
						}
					}
					if (types[n][map[n][i][j]] == 2) {
						int tmp = map[n][i][j];
						for (int k = i + 1; k < 11; k++) {
							if (k == 10 || (k < 10 && (map[n][k][j] != 0 || map[n][k][j + 1] != 0))) {
								map[n][i][j] = 0;
								map[n][i][j + 1] = 0;
								map[n][k - 1][j] = tmp;
								map[n][k - 1][j + 1] = tmp;
								break;
							}
						}
						j++;
					}
				}
			}
		}
		del();
	}
}