공부공간

BOJ - 25307 ) 시루의 백화점 구경

개발자가될수있을까? — Fri, 8 Jul 2022 23:46:12 +0900

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

25307번: 시루의 백화점 구경

첫째 줄에 백화점의 세로 길이, 가로 길이, 마네킹과 떨어져야 하는 거리를 의미하는 정수 $N, M, K$가 공백으로 구분되어 주어진다. ($1 \leq N,M \leq 2\,000$, $0 \leq K \leq 4\,000$) 둘째 줄부터 $N$개의 줄

www.acmicpc.net

첫 시작점으로 부터 목적지(2) 까지 갈 수 있는지 확인한다 (bfs)

탐색전 마네킹거리(K, 마네킹 좌표에서 bfs로 k번이동하여 갈수있는곳)를 불가능 표시를 해두고

한번만 BFS를 진행하면 해결된다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class BOJ_25307 {
	
	
	public static boolean inRange(int yy, int xx, int n , int m) {return yy<n&&xx<m&&yy>=0&&xx>=0;}
	
	public static void main(String[] args) throws IOException {

			
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		

		ArrayDeque<int[]> dq = new ArrayDeque<>();
		ArrayList<int[]> node = new ArrayList<>();
		
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());
		

		int dir[][] = {{1,0},{-1,0},{0,1},{0,-1}};
 		int map[][] = new int[n][m];
		int sx= 0;
		int sy= 0;
		int ex= -987654321;
		int ey= -987654321;
		
		for(int i=0;i<n;++i) {
			st = new StringTokenizer(br.readLine());
			for(int j=0;j<m;++j) {
				map[i][j] = Integer.parseInt(st.nextToken());
				if(map[i][j] ==4) {sx=j;sy=i;} 
				if(map[i][j] ==2) {ex=j;ey=i;} 
				if(map[i][j] ==3) {node.add(new int[] {i,j});
				} 
			}
		}
		
		
		int size = node.size();
	
		for(int aa=0;aa<size;aa++) {
		    int i = node.get(aa)[0];
		    int j = node.get(aa)[1];
			
			dq.add(new int[] {i,j});
			map[i][j]=1;
			
			while(!dq.isEmpty()) {
				
				int now[] =dq.poll();
					for(int a=0;a<4;a++) {
						int nexty=now[0]+dir[a][0];
						int nextx=now[1]+dir[a][1];
						if(inRange(nexty,nextx,n,m)&&map[nexty][nextx]!=1&&dist(nexty,nextx,i,j,k)) {
							map[nexty][nextx]=1;
							dq.add(new int[] {nexty,nextx});
						}
					}
			}
		}
		
		
		
        int answer= 987654321;
		
		dq.add(new int[] {sy,sx,0});
		map[sy][sx] = 5; 
		
		top:
		while(!dq.isEmpty()) {
			int now[] = dq.poll();
			for(int a=0;a<4;a++) {
				
				int nexty=now[0]+dir[a][0];
				int nextx=now[1]+dir[a][1];
				
				if(inRange(nexty,nextx,n,m)
						&&map[nexty][nextx]<5
						  &&map[nexty][nextx]!=1
						     ) {
					
					if(map[nexty][nextx]==2) {
						answer = answer > now[2]+1 ? now[2]+1 : answer;
						break top;
				    }
					dq.add(new int[] {nexty,nextx,now[2]+1});
					map[nexty][nextx]=5;
				}
			}
		}
		
		System.out.println( answer==987654321 ? -1 : answer );

	
		
		
	}

	private static boolean dist(int nexty, int nextx, int i, int j, int k) {
		
		return (Math.abs(nextx-j)+Math.abs(nexty-i)) <=k;
	}

	
}

BOJ - 25308 ) 방사형 그래프

개발자가될수있을까? — Mon, 4 Jul 2022 21:04:53 +0900

오목/볼록 다각형을 판단하기위한 알고리즘으로 CCW를 사용한다.

CCW가 잘 설명되어 있는글은

https://jason9319.tistory.com/358

CCW와 CCW를 이용한 선분 교차 판별

PS에서 종종 이용되는 선분 교차 여부 판별을 CCW를 이용하여 비교적 간단(?)하게 할 수 있는 방법을 소개하려고 합니다. 그 전에 우선 CCW에 대하여 이야기 해보겠습니다. CCW는 Counterclockwise의 약자

jason9319.tistory.com

이글을 판단하면 된다.

Z=0인 두 벡터를 연결한다면, 1 > 2 > 3 순서의 ccw값이 ( z=0 인 외적값 )

양수면 반시계방향에 위치에있다

0이면 일직선상에있다 ( 외적으로 만드는 평행사변형의 넓이값이 0이라는뜻)

음수면 시계방향으로 세점이 위치해있다.

를 이용하여, 점들간 ( 3점으로 했는데 모든점으로 확장해도 통과할듯하다 )의 ccw값이 음수이면,

시계방향으로 점들이 배열된다는 뜻이고, 이는 볼록다각형이랑는 말과 동치이다.

점의 좌표는 방사형 그래프를 원점으로 두고, 각 꼭지점은 pi/4 이므로 이를 이용하여 각 좌표를 계산할 수 있다.

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

25308번: 방사형 그래프

게임 캐릭터의 능력치를 한 눈에 보기 좋게 나타내는 방법으로 방사형 그래프가 있다. 캐릭터는 8개의 능력치를 갖고 있고 각 능력치를 $a_1, a_2, \cdots, a_8$이라고 하면, 그래프는 팔각형 형태이고

www.acmicpc.net

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

class BOJ_25308{
	public static int input[] = new int[8];
	public static int order[] = {0,1,2,3,4,5,6,7};
	public static void main(String[] args) throws IOException {
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		for(int i=0;i<8;i++) {input[i] = Integer.parseInt(st.nextToken());}
		int answer=0;
		do {

		    boolean isPossible = true;
			for(int i=0;i<8;i++) {
			
				float result_ccw = ccw(
						                   new float[] { (float) - (input[order[i%8]] / Math.sqrt(2)),  (float) (input[order[i%8]] / Math.sqrt(2)) }
					                     , new float[] { (float)   0  ,  (float) (input[order[(i+1)%8]])}
					                     , new float[] { (float)  (input[order[(i+2)%8]] / Math.sqrt(2)),  (float) (input[order[(i+2)%8]] / Math.sqrt(2))}
					                   );
				if(result_ccw >= 0) {
					isPossible =false;
				}
				if(!isPossible) {
					break;
				}
			}
			
			
					
			
			if(isPossible) {
				answer++;
			}
		} while(nextPermutation(order));
		System.out.println(answer);
	}
	

	public static float ccw(float []a, float []b, float []c) {
		// ccw 계산 , 일직선에 올수 없다( 정수이기 때문 )
		return (a[0]*b[1]+b[0]*c[1]+c[0]*a[1])-(b[0]*a[1]+c[0]*b[1]+a[0]*c[1]);
		
	}
	static boolean nextPermutation(int[] arr) {
		
		int i=7;
		while( i>0 && arr[i-1] >= arr[i] ) --i; 
		if(i==0) return false;
		
		int j = 7;
		while(arr[i-1]>=arr[j]) --j;
		
		int temp = order[i-1];
		order[i-1] = order[j];
		order[j] = temp;
		
		int k = 7;
		while(i<k) {
		    temp=order[i];
		    order[i]=order[k];
		    order[k]=temp;
			++i; --k;
		}
		return true;		
	}
}

BOJ - 25306 ) 연속 XOR

개발자가될수있을까? — Wed, 29 Jun 2022 22:31:32 +0900

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

25306번: 연속 XOR

3에서 5까지의 자연수는 3, 4, 5로, 세 개 존재한다. 세 수를 XOR한 값은 (3 XOR 4) XOR 5 = 7 XOR 5 = 2 이다.

www.acmicpc.net

XOR연산(결합,교환) 특성에 의해 1-(A-1) 까지와 1-B까지 숫자에 대한 XOR이

A-B까지 XOR이 같게된다.

첫번째 자리를 제외한 비트를 나열해보면, 모두 주기를 띄고있다.( 0011 00001111 ... )

따라서 2^N으로 비트를 밀면서 해당 번째가 00에속하는지 11에 속하는지 먼저 판단하고,

11영역에 속한다면, 해당 1의 누적개수가 짝수개면 0 홀수개면 1로 비트를 바꾸어준다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		long n = Long.parseLong(st.nextToken());
		long m = Long.parseLong(st.nextToken());
		
		System.out.println((XOR(n-1)
				 ^XOR(m)));
	}

	private static long XOR(long num) {
		long answer =0;
		if(num%2==1) {
			if( ((num+1)/2)%2==1) {answer++;}
		} else {
			if( ((num)/2)%2==1) {answer++;}
		}
		
	 for(long i=1;i<=num;i*=2) {
			if( (num%(i*2))>=i&&
					 (((num%(i*2))&1)==0) ) {
				answer ^=i;
			}
		
		}
		return answer;
	}
}

BOJ - 2559 ) 수열

개발자가될수있을까? — Mon, 27 Jun 2022 23:42:01 +0900

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

2559번: 수열

첫째 줄에는 두 개의 정수 N과 K가 한 개의 공백을 사이에 두고 순서대로 주어진다. 첫 번째 정수 N은 온도를 측정한 전체 날짜의 수이다. N은 2 이상 100,000 이하이다. 두 번째 정수 K는 합을 구하기

www.acmicpc.net

K개가 될때까지 더하고, 이후에는 K길이 전만큼은 빼주면서 현재 인덱스 값을 더해주며 진행한다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

	public static void main(String[] args) throws IOException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int N = Integer.parseInt(st.nextToken());
		int K = Integer.parseInt(st.nextToken());
		int now= 0;
		int answer=-987654321;
		int arr[] = new int[N];
		st = new StringTokenizer(br.readLine());
		for(int i=0;i<N;) {arr[i] = Integer.parseInt(st.nextToken());++i;}
		for(int i=0;i<N;) {
			if(i<K-1) {
				now+=arr[i];
			} else {
				now+=arr[i];
				answer = answer > now ? answer : now;
				now-=arr[i-K+1];
				
			}
			++i;
		}
		System.out.println(answer);
		 
	}

}

BOJ - 1525 ) 퍼즐

개발자가될수있을까? — Sat, 25 Jun 2022 09:03:39 +0900

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

1525번: 퍼즐

세 줄에 걸쳐서 표에 채워져 있는 아홉 개의 수가 주어진다. 한 줄에 세 개의 수가 주어지며, 빈 칸은 0으로 나타낸다.

www.acmicpc.net

BFS를 통하여
1 2 3
4 5 6
7 8 0

인 경우에 도달할 수 있는지 확인해주자

ArrayList의 Clone() 메소드를 통하여 현재값과 동일한 객체를 쉽게 만들 수 있다.

(방문체크용)

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

public class Main {

	public static void main(String[] args) throws IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
	
		
		HashMap<ArrayList, Integer> visit = new HashMap<>();
        
		int dir[][] = {{1,0},{-1,0},{0,-1},{0,1}};
		ArrayDeque<ArrayList<Integer>> dq = new ArrayDeque<>();
		
		ArrayList<Integer> al = new ArrayList<>();
		for(int i=0;i<3;) {
			StringTokenizer st = new StringTokenizer(br.readLine());
			for(int j=0;j<3;) {
				int now = Integer.parseInt(st.nextToken());
				al.add(now);
				++j;
			}
			++i;
		}
		int cnt =0;
		dq.add(al);
		visit.put((ArrayList<Integer>)al.clone(),0);
		while(!dq.isEmpty()) {
			int size = dq.size();
			cnt++;
			while(size>0) {
				
				al = dq.poll();
				int index = findZeroPos(al);
				int y = index/3;
				int x = index%3;
				for(int i=0;i<4;) {
					int nexty=y+dir[i][0];
					int nextx=x+dir[i][1];
					if(nexty>=0&&nextx>=0&&nexty<3&&nextx<3) {
						Collections.swap(al, y*3+x, nexty*3+nextx);
						if(!visit.containsKey(al)) {
							dq.add((ArrayList<Integer>) al.clone());
							visit.put((ArrayList<Integer>) al.clone(), cnt);
						}
						Collections.swap(al, nexty*3+nextx ,y*3+x);
					}
					++i;
				}
				size--;
			}
		}
		al.clear();
		for(int i=1;i<=8;) {
			al.add(i);
			++i;
		}
		al.add(0);
		if(visit.containsKey(al)) {
			System.out.println(visit.get(al));
		} else {
			System.out.println("-1");
		}
	}

	private static int findZeroPos(ArrayList<Integer> al) {
		int size =al.size();
		for(int i=0;i<size;) {
			if(al.get(i)==0) return i;
			++i;
		}
		return -1;
	}
}

항상 경곗값의 테스트케이스를 조심하자

BOJ - 1865 ) 웜홀

개발자가될수있을까? — Wed, 22 Jun 2022 20:56:17 +0900

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

1865번: 웜홀

첫 번째 줄에는 테스트케이스의 개수 TC(1 ≤ TC ≤ 5)가 주어진다. 그리고 두 번째 줄부터 TC개의 테스트케이스가 차례로 주어지는데 각 테스트케이스의 첫 번째 줄에는 지점의 수 N(1 ≤ N ≤ 500),

www.acmicpc.net

MCMF(Minimum Cost Maximum Flow)를 위한 SPFA(Shortest Path Faster Algorithm) 공부중 푼문제

1-N 의 정점에서 SPFA를 실행하여 음의 사이클이 있는지 확인한다.

SPFA는 벨만-포드 알고리즘과 유사하게 작동하는데, 벨만 포드가 모든 간선에대해서 경로 업데이트를 진행한다면

SPFA는 변화가 있는 노드를 큐에넣고 큐가 더이상 진행되지 않을때까지 경로 업데이트를 진행한다.

벨만 포드 알고리즘에서 V-1번 이후 경로업데이트가 이루어지면 음의 사이클을 존재함을 판단하는데

SPFA에서는 특정노드를 N번 이상 방문한다면 음의 사이클이 존재함을 판단한다.

package algorithm_2022;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class BOJ_1865 {

	public static void main(String[] args) throws IOException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		StringBuilder sb = new StringBuilder();
		
		int T = Integer.parseInt(st.nextToken());
		for(int i=0;i<T;) {
			
			st = new StringTokenizer(br.readLine());
			
			int N = Integer.parseInt(st.nextToken());
			int M = Integer.parseInt(st.nextToken());
			int W = Integer.parseInt(st.nextToken());
			
			ArrayList<int []> nodes[] = new ArrayList[N];
 			for(int j=0;j<N;) {
 				nodes[j] = new ArrayList<>();
 				++j;
 			}
			
 			for(int j=0;j<M;) {
 				st = new StringTokenizer(br.readLine());
 				int S = Integer.parseInt(st.nextToken())-1;
 				int E = Integer.parseInt(st.nextToken())-1;
 				int TI = Integer.parseInt(st.nextToken());
 				nodes[S].add(new int[] {E,TI});
 				nodes[E].add(new int[] {S,TI});
 				++j;
 			}
 			
 			for(int j=0;j<W;) {
 				st = new StringTokenizer(br.readLine());
 				int S = Integer.parseInt(st.nextToken())-1;
 				int E = Integer.parseInt(st.nextToken())-1;
 				int TI = Integer.parseInt(st.nextToken());
 				nodes[S].add(new int[] {E,-TI});
 				++j;
 			}
 			
 			boolean infinite = false;
 			ArrayDeque<Integer> dq = new ArrayDeque<>();
 			top:
 			for(int j=0;j<N;) {
 			    // 모든 노드를 시작점으로 SPFA를 실행하여 음수 사이클이 존재하는지 파악
 				
 			  	int cnt[] = new int[N];
 			  	int cost[] = new int[N];
 			  	Arrays.fill(cost, 987654321);
 			  	boolean InQ[] = new boolean[N];
 				
 				dq.add(j);
 				cnt[j]=1;
 				InQ[j]=true;
 				
 				while(!dq.isEmpty()) {
 					int now = dq.poll();
 					InQ[now] = false;
 					int size = nodes[now].size();
 					for(int k=0;k<size;) {

 						int next = nodes[now].get(k)[0];
 						int pathValue = nodes[now].get(k)[1];
 						if(cost[next] > cost[now] + pathValue) {
 							cost[next] = cost[now] + pathValue;
 							if(!InQ[next]) {
 								InQ[next] = true;
 								if(++cnt[next]>N) {
 									infinite=true;
 									break top;
 								}
 								dq.add(next);
 							}
 						}
 						k++;
 					}
 				}
 				++j;
 			}
 			if(infinite) {
 				sb.append("YES\n");
 			} else {
 				sb.append("NO\n");	
 			}
 			++i;
		}
		System.out.println(sb.toString());
		
	}

}

Ethereum 사이드 체인 VS L2체인

개발자가될수있을까? — Sun, 19 Jun 2022 20:56:33 +0900

https://www.web3.university/article/sidechains-vs-layer2s

Ethereum Sidechains vs Layer 2s: What’s the Difference?

www.web3.university

https://www.ddengle.com/yanatu/15044384

이더리움 레이어2(L2) 솔루션 총 정리 - 쟁선의야나투 - 땡글닷컴

이더리움 레이어2(L2) 솔루션 총 정리 원문 : Xangle Originals L2(레이어2) 솔루션은 이더리움 메인넷의 확장성 문제를 해결하기 위해 설계된 별도의 레이어로, 최대한 빠르고 저렴하게 트랜젝션

www.ddengle.com

결론은 이더리움 메인체인의 과부하로 인한 L1 (이더)를 확장하는가 (사이드체인) ? L2에서 배치성으로 처리후에
L1에 반영하는가의 차이이고 앞으로 이더리움 부하해소를위해서 다양한 방법들이 나오지 않을까..

SQL 튜닝 기초

개발자가될수있을까? — Fri, 17 Jun 2022 16:01:55 +0900

https://programmingyoon.tistory.com/265?category=785985

배치 튜닝에서 마법사 같은 힌트절 삼총사 ? USE_HASH, FULL, PARALLEL

USE_HASH, FULL, PARALLEL 3가지 힌트절은 배치성 쿼리에서 가장 많이 사용되는 힌트절이다. 한마디로 대용량 데이터 처리 및 조회에 빈번하게 사용하는 힌트절이다. 위의 3가지 힌트절만 잘 조합하여

programmingyoon.tistory.com

배치쿼리 튜닝시 사용할 힌트 3종류

INDEX와 힌트(PARALLEL은 DBA와 논의) 기초

단순 컬럼 조회를 leading하는거면 옵티마이저가 최적의 실행계획을 실행하겠지만,

고객원장, 수익성적재와같은 대량테이블을 활용하여 특정 배치를 짤때에는 병렬처리나 접근방식을 지정해주는게 좋다.

물론 팀에서 정형화된 힌트절 (insert나 select시에) 이있지만 알고 사용하고 특정상황에서는 실행계획을 참고하여

튜닝까지 진행해야한다.

BOJ - 21609 ) 상어 중학교

개발자가될수있을까? — Sun, 29 May 2022 16:33:30 +0900

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

21609번: 상어 중학교

상어 중학교의 코딩 동아리에서 게임을 만들었다. 이 게임은 크기가 N×N인 격자에서 진행되고, 초기에 격자의 모든 칸에는 블록이 하나씩 들어있고, 블록은 검은색 블록, 무지개 블록, 일반 블록

www.acmicpc.net

매번 가장큰 size를 가진 일반 블록을 찾기위해 NXN을 탐색한다.

(사이즈가 같은경우는 무지개 블록이, 무지개블록이 같은경우는 대표블록의 Y,X값을 참조)

해당 블록이 그룹이 되는 조건을 BFS를 진행하며 확인해준다. ( size가 1이면 그룹이 될 수 없다 )

또한, 점수를 획득할 그룹이 지정되면 반시계반향으로 돌리는 로직과 ( y,x -> 한변의 길이-x,y )

중력을 받아서 아래로 내려오는 로직을 미리 구현해 놓으면, 필요할 때에 호출하여 사용하면된다.

구현문제는 비슷한 유형 ( 시계/반시계 회전, 특정 조건으로 배열 새로제작 )을 띄기 때문에

양치기로 구현 속도를 빠르게 줄일 수 있다.

package algorithm_2022;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class boj_21609 {

	public static int ignore =0;
	public static class node{
		  int size;
		  int rainbow;
		  int RepreY;
		  int RepreX;
		  boolean isGroup;
		  ArrayList<int[]> coord;
		  public node() {
			  size=0; rainbow=0; RepreY=0; RepreX=0; isGroup=false;
			  coord = new ArrayList<>();
		 }
		
	}
	public static void main(String[] args) throws IOException {
		
	  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	  StringTokenizer st = new StringTokenizer(br.readLine());
	  
	  int N = Integer.parseInt(st.nextToken());
	  int M = Integer.parseInt(st.nextToken());
	  ignore = M+1;
	  boolean isContinue = true;
	  int [][] dir = {{1,0},{-1,0},{0,1},{0,-1}};
	  ArrayDeque<int []> dq = new ArrayDeque<>();
	  PriorityQueue<node> pq = new PriorityQueue<>(new Comparator<node>() {
		  @Override
		public int compare(node o1, node o2) {
			// 넓이,무지개 블록수, 대표블록의 행, 대표블록의 열
			if(o1.size>o2.size) return -1;
			else if(o1.size<o2.size) return 1;
			else {
				if(o1.rainbow>o2.rainbow) return -1;
				else if(o1.rainbow<o2.rainbow) return 1;
				else {
					if(o1.RepreY>o2.RepreY) return -1;
					else if(o1.RepreY<o2.RepreY) return 1;
					else {
						if(o1.RepreX>o2.RepreX) return -1;
						else if(o1.RepreX<o2.RepreX) return 1;
						else return 0;
					}
				}
			}
		}
	  });
	  int map[][] = new int[N][N];
	  int answer =0;
	  for(int y=0;y<N;y++) {st = new StringTokenizer(br.readLine()); for(int x=0;x<N;x++) {map[y][x] = Integer.parseInt(st.nextToken());}}
	  // end of input
	  while(isContinue) {
		  // 방문 체크
		  boolean isVisit[][] = new boolean[N][N];
		 
		  node n = new node();
		
		  
		  for(int y=0;y<N;y++) {
			  for(int x=0;x<N;x++) {
				  if(map[y][x]!=0 && map[y][x]!=-1&& !isVisit[y][x] && map[y][x]!=ignore) {
					 
					// bfs 
					n = new node();
					n.size=0;
					n.rainbow=0;
					n.RepreY = -1;
					n.RepreX = -1;
				    
					dq.clear();
				    dq.add(new int[] {y,x,map[y][x]});
				    isVisit[y][x] = true;
				    while(!dq.isEmpty()) {
				    	int now[] = dq.poll();
				    	int nowy = now[0];
				    	int nowx = now[1];
				    	int nowc = now[2];
				    	n.size++;
				    	if(n.size>=2&&!n.isGroup) {
				    		n.isGroup = true;
				    	} else if(n.size==1){
				    		// 작은것들이 기준블록의 대상이됨
				    	    n.RepreY=y;
				    	    n.RepreX=x;
				    	    n.coord.add(new int[] {y,x});
				    	}
				    	
				    	for(int i=0;i<4;i++) {
				    		int nexty=nowy +dir[i][0];
				    		int nextx=nowx +dir[i][1];
				    		if(nexty>=0&&nextx>=0&&nexty<N&&nextx<N) {
				    			if(map[nexty][nextx]!=-1 || map[nexty][nextx] !=ignore) {
				    				if(map[nexty][nextx]==0 && !isRainBow(n.coord,nexty,nextx)) {
				    					n.rainbow++;
				    					dq.add(new int[] {nexty,nextx,nowc});
					    				n.coord.add(new int[] {nexty,nextx});
				    				} else {
				    					if(!isVisit[nexty][nextx] && map[nexty][nextx] == nowc) {
				    						isVisit[nexty][nextx] = true;
				    						dq.add(new int[] {nexty,nextx,nowc});
						    				n.coord.add(new int[] {nexty,nextx});
						    				  if(n.RepreY > nexty) {
						    					  n.RepreY = n.RepreY > nexty ? nexty : n.RepreY;
				    		                      n.RepreX = nextx;
						    				  } else if(n.RepreY==nexty) {
						    					  n.RepreX = n.RepreX > nextx ? nextx : n.RepreX;
						    				  }
				    					}
				    				}
				    			}
				    		}
				    	}
				    }
				    
				    
				    if(n.isGroup) {
						  pq.add(n);
					  }
				  }
			  }
		  }
		 
		  if(pq.size()==0) {
			  isContinue = false;
			  break;
		  } else {
			  isContinue = true;
			  n =pq.poll();
			  // pq의 맨 처음하나를 ignore 처리하고 
			  answer += (n.size)*(n.size);
			  for ( int[] co : n.coord) {
				map[co[0]][co[1]] = ignore;
			  }
			  pq.clear();
		  }
		  map = gravity(map);
		  map = autoclockwise(map);
		  map = gravity(map);
	  }
	  
	  System.out.println(answer);
	}

	private static boolean isRainBow(ArrayList<int[]> coord, int nexty, int nextx) {
		for (int[] is : coord) {if(is[0]==nexty&&is[1]==nextx) return true;}
		return false;
	}

	public static int[][] gravity(int [][] map){
		// 검정블록은 움직이지 않는다.
		int len = map.length;
		int rMap[][] = new int[len][len];
		for(int y=0;y<len;y++) for(int x=0;x<len;x++) rMap[y][x] = ignore;
		
		for(int x=0;x<len;x++) {
			for(int y=len-1;y>=0;y--) {
				if(map[y][x]==ignore || map[y][x]== -1) {
					rMap[y][x] = map[y][x];
				} else {
				  // 일반이거나 무지개 
				  if(y==len-1) {
					  rMap[y][x] = map[y][x];
				  } else {
					  // 맨바닥이면, 그냥 넣고 
					  // 아니면, 검정을 만나거나 다른값을 만날때까지 현재에서 위로 찾음
					  int nexty = y+1;
					  for(;nexty<len;nexty++) {
						  if(rMap[nexty][x]!=ignore) {
							  break;
						  }
					  }
					  rMap[--nexty][x] = map[y][x];
				  }
				}
			}
		}
		return rMap;
	}
	
	public static int[][] autoclockwise(int [][]map){
		// 반시계
		int len = map.length;
		int rMap[][] = new int[len][len];
		
		for(int y=0;y<len;y++) {
			for(int x=0;x<len;x++) {
				rMap[len-1-x][y] = map[y][x];
			}
		}
		return rMap;
	}
}

BOJ - 2493 ) 탑

개발자가될수있을까? — Wed, 11 May 2022 21:30:37 +0900

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

2493번: 탑

첫째 줄에 탑의 수를 나타내는 정수 N이 주어진다. N은 1 이상 500,000 이하이다. 둘째 줄에는 N개의 탑들의 높이가 직선상에 놓인 순서대로 하나의 빈칸을 사이에 두고 주어진다. 탑들의 높이는 1 ��

www.acmicpc.net

Stack 자료구조를 사용하여 현재까지의 탑의 높이를 저장하여

내 왼쪽의 탑들중 신호를 수신하는 탑을 찾는 문제이다.

수신되는 탑을 찾기위하여 현재까지 저장된 높이가 내높이보다 크면 add연산을 진행하고

작다면 나보다 큰 높이가 나올때까지 poll연산을 진행한다.

package algorithm_2022;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;

public class boj_2439 {

	public static void main(String[] args) throws IOException {
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
	    int n = Integer.parseInt(st.nextToken());
	    int arr[] = new int[n];
	    int index[] = new int[n];
	    Stack<int[]> s = new Stack<>();
	    st = new StringTokenizer(br.readLine());
	    for(int i=0;i<n;i++) {arr[i] = Integer.parseInt(st.nextToken());}
	    
	    for(int i=n-1;i>=0;i--) {
	    	if(s.isEmpty()) {
	    		s.add(new int[] {arr[i],i});
	    		continue;
	    	}
	    	
	    	if(s.peek()[0] > arr[i]) {
	    		s.add(new int[] {arr[i],i});
	    	} else {
	    	   while(s.peek()[0] < arr[i]) {
	    		   index[s.peek()[1]] = i+1;
	    		   s.pop();
	    		   if(s.isEmpty()) break;
	    	   }
	    	   s.add(new int[] {arr[i],i});
	    	}
	    }
	    StringBuilder sb = new StringBuilder();
	    for(int i=0;i<n;i++) {
	      sb.append(index[i]+" ");	
	    } System.out.println(sb.toString());

    }

}