17140 이차원 배열과 연산

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.StringTokenizer;

class Pair implements Comparable<Pair>{
	
	
	int number;
	int count;
	
	Pair(int number, int count) {
		this.number = number;
		this.count = count;
	}
	
	// 리스트 정렬
	// 1) 수의 등장 횟수 적은 -> 많은 (순서)
	// 2) 작은 수 -> 큰 수 (순서)
	public int compareTo(Pair p) {		
		
		if(this.count>p.count) {
			return 1;
		}else if(this.count < p.count) {			
			return -1;
			
		}else {
			
			if(this.number>p.number) {
				return 1;
			}else {
				return -1;
			}
			
		}		
	}	
}

public class Main {		
	
	static int r;
	static int c;
	static int k;
	static int input[][];	
	
	public static void main(String[] args) throws IOException{	
	
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st= new StringTokenizer(br.readLine(), " " );
		r = Integer.parseInt(st.nextToken());
		c = Integer.parseInt(st.nextToken());
		k = Integer.parseInt(st.nextToken());
		input = new int [101][101];
		
		
		for(int i=1; i<=3; i++) {
			 st= new StringTokenizer(br.readLine(), " " );
			for(int j= 1; j<=3; j++) {
				input[i][j] = Integer.parseInt(st.nextToken());
				
			}
		}	
		
		int result = solve(input);		
		
		if(result>100) {
			System.out.println("-1");
		}else {
			System.out.println(result);
		}
	}
	

	
	public static int solve(int input[][]) {	
	
		int row_number = 3; // 행 개수  (맨 처음 = 3)
		int col_number= 3; // 열 개수 (맨 처음 = 3)			
		HashMap<Integer, Integer> map = new HashMap<>(); // 수의 등장 횟수 파악 -> HashMap 사용
		List<Pair> list = new ArrayList<>(); // 정렬 위해 리스트 사용 
		int time = 0;
		int max_list_length =0;
		
		while(true) {
				
			if(time>100) {
				break;
			}
			
			if(input[r][c] == k) {
				break;
			}
			
			int input2[][] = new int[101][101];				
			max_list_length = 0;
			
			
			// R 연산 -> 행 기준 정렬
			// 행 개수 >= 열 개수 
			if(row_number>=col_number) {			
			
				for(int i=1; i<=row_number; i++) {
					
					for(int j=1; j<=col_number; j++) {
						
						int value = input[i][j];	
						if(value!=0) {
							map.put(value,map.getOrDefault(value, 0)+1);					
						}
					}				
					
					// 하나의 행이 끝나면 
					// map 에 넣은 것을 list 에 넣어서 정렬 
					for(Integer key:map.keySet()) {					
						list.add(new Pair(key, map.get(key)));				
					}
					
					Collections.sort(list);
					
					// 행렬크기 [100][100]으로 유지.
					for (int k = list.size()-1; k >= 50; k--) {
				            list.remove(k);
				      }		
					
					// list.size()*2 -> 
			        // 리스트에는 Pair(number, count) 로 들어가 있고
			        // 행렬에는 number, count 값을 각각 넣어야 하므로
			        // *2 함.		
					max_list_length = Math.max(list.size()*2, max_list_length);
					int n = 1;			
					
					//list 에 있는 것을 input 행렬의 행에 넣어줌.				 
					for(int k = 0; k<list.size(); k++) {
					
						input2[i][n++] = list.get(k).number;					
						input2[i][n++] = list.get(k).count;				
						
					}
					map.clear();
					list.clear();
				}
				col_number = max_list_length;				
		
			// C 연산 -> 열 기준 정렬
			// 행 개수 < 열 개수 
			}else {					
				
				// 여기까지
				for(int i=1; i<=col_number; i++) {
					
					for(int j=1; j<=row_number; j++) {
				
						int value = input[j][i];
						
						if(value!=0) {
							
							map.put(value,map.getOrDefault(value, 0)+1);
						
						}
					}	
					
					
					// 하나의 열이 끝나면 
					// map 에 넣은 것을 list 에 넣어서 정렬 
					for(Integer key:map.keySet()) {					
						list.add(new Pair(key, map.get(key)));				
					}
					
					Collections.sort(list);				
					int n = 1;
					
					
			        for (int k = list.size()-1; k >= 50; k--) {
			            list.remove(k);
			        }
					
			        
			             
			        max_list_length = Math.max(list.size()*2, max_list_length);
				
					//list 에 있는 것을 input2 행렬의 열에 넣어줌.
					for(int k = 0; k<list.size(); k++) {							
						
						input2[n++][i] = list.get(k).number;					
						input2[n++][i] = list.get(k).count;					
						
					}
					map.clear();
					list.clear();
				}
				row_number = max_list_length;
				
				
		}
		
	
		// 배열 깊은 복사  
		for(int i=0; i<input2.length; i++) {
			System.arraycopy(input2[i],0,input[i],0, input2[0].length);
		}
		
		time++;	
	   }
		
     return time;
	}
}

 

 

 

[핵심]

- 처음부터 배열 크기를 [100][100]으로 설정해서 계속 사용

- hashmap을 사용해서 각 수의 등장 횟수 구함.

- list를 이용해서 정렬

 

참고 블로그 : https://tussle.tistory.com/819

[백준] code.plus(시뮬레이션과 구현,JAVA)17140번, 이차원 배열과 연산