[2019 KAKAO BLIND RECRUITMENT] 블록 게임(Java, 간단한 코드)

## 접근.

---

1. 블록을 이루고 있는 4개 정사각형의 위치를 가지고 있는 자료구조를 만든다. 

 

 

 

2. 블록들중에서, 없어질 수 있는 블록들 후보에 대해서 인덱스 자료구조를 만든다.

* |__, __|, ㅗ, _|, |_ 이렇게 총 5가지이다.

 

 

 

3. 후보들이 검은 블록으로 지워지는지 확인하기 위해서는, 상대적으로 위에 위치한 블록들중에 지울 수 있는 건 모두 지워야 확인이 가능하다. 즉, 지워지는지 체크하기 위해서 후보들을 정렬할 필요가 있다. 가장 나중에 입력된 1 X 1 정사각형을 기준으로 내림차순 정렬을 한다.

 

* 가장 나중에 입력된 1 X 1 정사각형이 모든 블록에서 행(ROW)이 가장 작다. 가장 낮은 위치의 1 X 1 정사각형을 사용해야, 지워질 수 있는 블록들을 모두 사라진 상태에서 속이 꽉 채워진 직사각형을 만들 수 있는지 확인이 가능하다.

 

 

 

 

## 해설코드(Java).

---

import java.util.*;
import java.io.*;
import java.lang.*;
 
class Solution {
    class Item{
        int r, c;
        Item(int r, int c){
            this.r = r;
            this.c = c;
        }
    }
    
    public int solution(int[][] board) {
        int answer = 0;
        
        ArrayList<ArrayList<Item>> aList = new ArrayList<>();
        ArrayList<Integer> canList = new ArrayList<>();
        
        for(int i = 0; i < 201; i++)
            aList.add(new ArrayList<Item>());
        
        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board.length; j++){
                 if(board[i][j] != 0)
                     aList.get(board[i][j]).add(new Item(i, j));
            }
        }
        
        for(int i = 0 ; i < aList.size(); i++){
            ArrayList<Item> aListList = aList.get(i);
            if(aListList.size() != 4)
                continue;
            
            Item i1 = aListList.get(0);
            Item i2 = aListList.get(1);
            Item i3 = aListList.get(2);
            Item i4 = aListList.get(3);
            
            if(i2.r == i3.r && i3.r == i4.r && i2.c + 1 == i3.c && i3.c + 1 == i4.c && i1.r + 1 == i2.r){
                if(i1.c == i2.c){
                    //|___
                    canList.add(i);
                }else if(i1.c == i4.c){
                    //___|
                    canList.add(i);
                }else if(i1.c == i3.c){
                    // ㅗ
                    canList.add(i);
                }
            }else if(i1.c == i2.c && i2.c == i4.c && i1.r + 1 == i2.r && i2.r + 1 == i4.r 
                     && i3.r == i4.r && i3.c + 1 == i4.c){
                //_|
                canList.add(i);
            }else if(i1.c == i2.c && i2.c == i3.c && i1.r + 1 == i2.r && i2.r + 1 == i3.r
                    && i3.r == i4.r && i3.c + 1 == i4.c){
                // |_
                canList.add(i);
            }
        }
        
        Collections.sort(canList, new Comparator<Integer>(){
           public int compare(Integer i1, Integer i2){
               Item item1 = aList.get(i1).get(3);
               Item item2 = aList.get(i2).get(3);
               
               if(item1.r == item2.r){
                   return Integer.compare(item1.c, item2.c);
               }else
                   return Integer.compare(item1.r, item2.r);
           } 
        });
        
        
        for(int i : canList){
            ArrayList<Item> list = aList.get(i);
            boolean flag = true;
            
            int firstC = list.get(0).c;
            for(int j = 1; j < list.size(); j++){
                int r = list.get(j).r;
                int c = list.get(j).c;
                
                if(c == firstC)
                    continue;
                
                while(r >= 0){
                    if(board[r][c] != 0 && board[r][c] != i) {
                        flag = false;
                        break;
                    }
                    r -= 1;
                }
            }
                            
            if(flag) {
                for(Item item : list)
                    board[item.r][item.c] = 0;
                answer += 1;
            }
            
            //System.out.println(i);
        }       
        
        return answer;
    }
}