뚭

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

와 두번다시는 풀고 싶지는 않는문제네요
* 이후 얼음이 있는 칸 3개 또는 그 이상과 인접해있지 않은 칸은 얼음의 양이 1 줄어든다.
->3개 미만은 얼음이 줄어든다 (무슨 국어 문제인가.. ㅎ)
* 남아있는 얼음 중 가장 큰 덩어리가 차지하는 칸의 개수 얼음이 있는 칸이 얼음이 있는 칸과 인접해 있으면, 두 칸을 연결되어 있다고 한다. 덩어리는 연결된 칸의 집합
->연결된 얼음 덩어리들의 칸의 갯수의 합,즉 얼음은 bfs,dfs를 통해서 연결해서 얼음 덩어리들을 계산하라는 의미
 

import java.util.*;
import java.io.*;
import java.lang.*;
import java.io.*;
public class Main {
	public static int n;
	public static int q;
	public static int maps[][];
	public static int copyMaps[][];
	public static boolean bCheck[][];
	public static boolean initbCheck[][];
	public static boolean[][] visited; 
	public static int L;
	public static void prints(int tmpMap[][]){
		System.out.println();
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				System.out.print(tmpMap[i][j]+",");
			}
			System.out.println();
		}
	}
	public static class Ice {
		public int i;
		public int j;
		public Ice(int i,int j) {
			this.i=i;
			this.j=j;
		}
	}
	public static void Rotation(int starti, int startj){
		int cnt=1;
		int rStarti=starti*L;
		int rEndi=starti*L+L;
		int rStartj=startj*L;
		int rEndj=startj*L+L;

		int rLengthI=(rStarti+rEndi)/2;
		int rLengthJ=(rStartj+rEndj)/2;

		int rCountI=(rEndi-rStarti)/2;
		int rCountJ=(rEndi-rStarti)/2;

		//1 ->2
		for(int i=rStarti;i<rLengthI;i++){
			for(int j=rStartj;j<rLengthJ;j++){
				copyMaps[i][j+ rCountJ]=maps[i][j];
			}
		}
		//2->3
		for(int i=rStarti;i<rLengthI;i++){
			for(int j=rLengthJ;j<rEndj;j++){
				copyMaps[i+rCountI][j]=maps[i][j];
			}
		}

		//3->4
		for(int i=rLengthI;i<rEndi;i++){
			for(int j=rLengthJ ;j<rEndj;j++){
				copyMaps[i][j-rCountJ]=maps[i][j];
			}
		}
		//4->1
		for(int i=rLengthI;i<rEndi;i++){
			for(int j=rStartj;j<rLengthJ;j++){

				copyMaps[i-rCountI][j]=maps[i][j];
			}
		}
		//prints(copyMaps);
		
		

	}
	
	public static void Rotations(int starti, int startj) {
	    int rStarti = starti * L;
	    int rStartj = startj * L;
	    int[][] temp = new int[L][L];

	    for (int i = 0; i < L; i++) {
	        for (int j = 0; j < L; j++) {
	            temp[j][L - 1 - i] = maps[rStarti + i][rStartj + j];
	        }
	    }

	    for (int i = 0; i < L; i++) {
	        for (int j = 0; j < L; j++) {
	        	maps[rStarti + i][rStartj + j] = temp[i][j];
	        }
	    }
	}
	public static int bfs(int x, int y) {
	    if(maps[x][y] <= 0) return 0; 
	    int count = 1;
	    Queue<Ice> queue = new LinkedList<>();
	    queue.add(new Ice(x, y));
	    visited[x][y] = true;

	    while (!queue.isEmpty()) {
	        Ice current = queue.poll();
	        int i = current.i;
	        int j = current.j;

	        int[] di = {-1, 1, 0, 0}; 
	        int[] dj = {0, 0, -1, 1}; 

	        for (int k = 0; k < 4; k++) {
	            int ni = i + di[k];
	            int nj = j + dj[k];

	            if (ni >= 0 && ni < n && nj >= 0 && nj < n && !visited[ni][nj] && maps[ni][nj] > 0) {
	                queue.add(new Ice(ni, nj));
	                visited[ni][nj] = true;
	                count++; 
	            }
	        }
	    }
	    return count;
	}
	
	public static void main(String[] args) throws Exception {
		Scanner scan = new Scanner(System.in);
		n=scan.nextInt();
		q=scan.nextInt();
		double tmpn=Math.pow(2,n);
		n=(int)tmpn;
		maps=new int[n][n];
		copyMaps=new int[n][n];
		bCheck=new boolean[n][n];
		initbCheck=new boolean[n][n];
		visited = new boolean[n][n];

		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				maps[i][j]=scan.nextInt();
				copyMaps[i][j]=maps[i][j];
			}
		}
		for(int t=0;t<q;t++){
			
			L=scan.nextInt();

			double tmpL=Math.pow(2,L);
			L=(int)tmpL;
			//2x2
			//4x4
			//8x8
			int divide=n/L;
			
			
			for(int i=0;i<divide;i++){
				for(int j=0;j<divide;j++){
					Rotations(i,j);
				}
			}
			
			int diri[]= {-1,1,0,0};
			int dirj[]= {0,0,-1,1};
			
			ArrayList<Ice> saveIce=new ArrayList<>();
			for (int i = 0; i < n; i++) {
			    for (int j = 0; j < n; j++) {
			        int iceCnt = 0; 
			        for (int k = 0; k < 4; k++) {
			            int ni = i + diri[k];
			            int nj = j + dirj[k];
			            if (ni < 0 || nj < 0 || ni >= n || nj >= n) continue;
			           
			            if (maps[ni][nj] > 0) iceCnt++;
			        }
			        if (iceCnt < 3) {
			            saveIce.add(new Ice(i, j));
			        }
			    }
			}

			// 저장된 모든 칸의 얼음을 1 줄입니다.
			for (Ice ice : saveIce) {
			    maps[ice.i][ice.j] = Math.max(0, maps[ice.i][ice.j] - 1); 
			}
			
		}
		
		int sum=0;
		int maxs=0;
		for(int i=0;i<n;i++) {
			for(int j=0;j<n;j++) {
				if(maps[i][j]>=0) {
					sum+=maps[i][j];
				}
				
			}
		}
		System.out.println(sum);
		int maxSizeOfIce = 0;
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        if (!visited[i][j] && maps[i][j] > 0) {
            maxSizeOfIce = Math.max(maxSizeOfIce, bfs(i, j));
        }
    }
}
		System.out.println(maxSizeOfIce);
		//Rotation(0,1);

	}
}

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

골드3 문제인데..ㅋㅋ 두번 다시는 풀고 싶지않는 문제 생각을 좀 해야하네여 ㅎㅎ 

import java.util.*;
import java.io.*;
public class Main {
	public static int n;
	public static int maps[][];
	public static int copyMaps[][];
	public static int ci;
	public static int cj;
	public static int outsand=0;
	public static void Prints(int tmpmaps[][]){
		System.out.println();

		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				System.out.print(tmpmaps[i][j]+",");
			}
			System.out.println();
		}
		System.out.println();
	}
	public static void checking(int checki,int checkj,int input ){
		if(checki> n-1 ||checkj >n-1||checki<0||checkj<0){
			//System.out.println("sendout:"+input);
			outsand=outsand+input;

		}else{
			maps[checki][checkj] = maps[checki][checkj]+input;
		}
	}
	public static void spread(int mci,int mcj,int diri,int dirj,int index ,int pi,int pj){
		//Prints(maps);
		int tmp=maps[mci][mcj];
		maps[mci][mcj]=0;

		int two=  (int)(tmp*0.02);
		int one=  (int)(tmp*0.01);
		int seven=  (int)(tmp*0.07);
		int ten=  (int)(tmp*0.1);
		int five=  (int)(tmp*0.05);
		int alpa=tmp-(two*2+one*2+seven*2+ten*2+five);
		int alpai=mci+diri;
		int alpaj=mcj+dirj;
		/*
		System.out.println("alpa:"+alpa);
		System.out.println("two:"+two);
		System.out.println("seven:"+seven);
		System.out.println("ten:"+ten);
		System.out.println("five:"+five);
		System.out.println("five:"+one);*/
		checking(mci + diri * 2,mcj + dirj * 2, five );
		if(index==0){
			checking(mci+2,mcj, two );
			checking(mci-2,mcj, two );

			checking(alpai-1,alpaj, ten );
			checking(alpai+1,alpaj, ten );

			checking(mci-1,mcj, seven );
			checking(mci+1,mcj, seven );

			checking(pi-1,pj, one );
			checking(pi+1,pj, one );
		}else{
			checking(mci,mcj-2, two );
			checking(mci,mcj+2, two );

			checking(alpai,alpaj-1, ten );
			checking(alpai,alpaj+1, ten );

			checking(mci,mcj-1, seven );
			checking(mci,mcj+1, seven );

			checking(pi,pj-1, one );
			checking(pi,pj+1, one );
		}
		checking(alpai,alpaj, alpa );
		//Prints(maps);
	}
	public static void Rotation(int index){
			if(index%2==1){
				//left 0
				for(int i=0;i<index;i++){
					int tmpi=ci;
					int tmpj=cj;
					ci=ci;
					cj=cj-1;
					if(maps[ci][cj]>0){
						spread(ci,cj,0,-1,0,tmpi,tmpj);
					}
				}
				//copyMaps[][]=maps[ci][cj];
				// down 1
				for(int i=0;i<index;i++){
					int tmpi=ci;
					int tmpj=cj;
					ci=ci+1;
					cj=cj;
					if(maps[ci][cj]>0){
						spread(ci,cj,1,0,1,tmpi,tmpj);
					}
				}
			}else{
				//right 2
				for(int i=0;i<index;i++) {
					int tmpi=ci;
					int tmpj=cj;
					ci = ci;
					cj = cj + 1;
					if(maps[ci][cj]>0){
						spread(ci,cj,0,1,0,tmpi,tmpj);
					}
				}
				// up 3
				for(int i=0;i<index;i++) {
					int tmpi=ci;
					int tmpj=cj;
					ci = ci - 1;
					cj = cj;
					if(maps[ci][cj]>0){
						spread(ci,cj,-1,0,1,tmpi,tmpj);
					}
				}
			}

		//left 1 0
		//down 1 0
		//right 2 1
		//up 2 1
		//..
		//right 6
		//up 6

		//left 6
	}

	public static void main(String[] args) throws Exception {
		Scanner scan = new Scanner(System.in);
		n = scan.nextInt();
		maps=new int[n][n];
		copyMaps=new int[n][n];

		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				int tmp=scan.nextInt();
				maps[i][j]=tmp;
				copyMaps[i][j]=tmp;
			}
		}

		 ci=n/2;
		 cj=n/2;
		//System.out.println("center:"+ci+","+cj);
		for(int i=0;i<n-1;i++) {
			Rotation( i +1 );
		}
		//System.out.println("center:"+ci+","+cj);

		//last left
		for(int i=0;i<n-1;i++){
			int tmpi=ci;
			int tmpj=cj;
			ci=ci;
			cj=cj-1;
			if(maps[ci][cj]>0){
				spread(ci,cj,0,-1,0,tmpi,tmpj);
			}
		}
		//System.out.println("center:"+ci+","+cj);
		System.out.println(outsand);
	}
}

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

그리드 문제이고 우선순위 큐만 잘 커스텀하면 쉽게 푸는 문제네요.

import java.util.*;
import java.io.*;
public class Main {
	public static void Prints(PriorityQueue<Meetings>q){

	}
	public static class Meetings{
		public int start;
		public int end;
		public Meetings(int start, int end){
			this.start=start;
			this.end=end;
		}
	}
	public static void main(String[] args) throws Exception {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt();
		Comparator<Meetings> comparator =new Comparator<Meetings>(){
			@Override
			public int compare(Meetings m1, Meetings m2){
				if(m1.start<m2.start){
					return -1;
				}else if(m1.start>m2.start) {
					return 1;
				}
				return 0;
			}
		};
		Comparator<Meetings> comparator2 =new Comparator<Meetings>(){
			@Override
			public int compare(Meetings m1, Meetings m2){
				if(m1.end<m2.end){
					return -1;
				}else if(m1.end>m2.end) {
					return 1;
				}
				return 0;
			}
		};

		PriorityQueue<Meetings>q=new PriorityQueue<>(comparator);
		for(int i=0;i<n;i++){
			int start=scan.nextInt();
			int end=scan.nextInt();
			q.add(new Meetings(start,end));
		}

		PriorityQueue<Meetings>save=new PriorityQueue<>(comparator2);

		while (!q.isEmpty()){
			Meetings mstart=q.peek();
			q.poll();
			//System.out.println(mstart.start+","+mstart.end);
			//for(int i=0; i<save.size(); i++){
			if(save.size()>0){
				if( save.peek().end <= mstart.start ){
					save.poll();
					//	break;
				}
			}


			save.add(mstart);

		}
		System.out.println(save.size());
	}
}

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

흠 조금 시간이 걸렸네요 

키포인트는 

명령횟수가  10^9이어서 시간초과가 발생합니다. 그래서 회전의 경우 원복되는 상황은 그대로인걸 감안해서 %를 이용해서 횟수를 줄이면됩니다.

키포인트:

  int parms = (2 * (n - 2 * i) + 2 * (m - 2 * i) - 4);
            int rotations = k % parms;

package test01;
import java.util.*;
import java.lang.*;
import java.io.*;

public class Main {
    public static int[][] maps;
    public static int[][] copymaps;
    public static int n, m, k;

    public static void prtints(int[][] maps, int n, int m) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(maps[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void rotation(int startr, int endr, int startc, int endc) {
        // top
        for (int i = startc + 1; i <= endc; i++) {
            copymaps[startr][i - 1] = maps[startr][i];
        }
        // left
        for (int i = startr; i < endr; i++) {
            copymaps[i + 1][startc] = maps[i][startc];
        }
        // right
        for (int i = startr + 1; i <= endr; i++) {
            copymaps[i - 1][endc] = maps[i][endc];
        }
        // bottom
        for (int i = startc; i < endc; i++) {
            copymaps[endr][i + 1] = maps[endr][i];
        }
       
        for (int i = startr; i <= endr; i++) {
            for (int j = startc; j <= endc; j++) {
                maps[i][j] = copymaps[i][j];
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();
        k = scan.nextInt();
        maps = new int[n][m];
        copymaps = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int tmp = scan.nextInt();
                maps[i][j] = tmp;
                copymaps[i][j] = tmp;
            }
        }

        int ci = Math.min(n, m) / 2;

        for (int i = 0; i < ci; i++) {
            int parms = (2 * (n - 2 * i) + 2 * (m - 2 * i) - 4);
            int rotations = k % parms;
            for (int t = 0; t < rotations; t++) {
                rotation(i, n - 1 - i, i, m - 1 - i);
            }
        }

        prtints(maps, n, m);
    }
}

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

쉬운 문제이고 개인적으로 실버 1 정도 수준인듯하네요.

난이도는 골드5라고하는데 흠 쉽네요

import java.util.*;
import java.io.*;
public class Main {
	public static int A;
	public static int B;
	public static boolean bOkay=true;
	public static ArrayList<String> anws=new ArrayList<>();
	public static void Prints(){
		System.out.println();
		for(int i=0;i<B;i++){
			for(int j=0;j<A;j++){
				if(maps[i][j].bCheck==true){
					System.out.print(1+",");
				}else{
					System.out.print(0+",");
				}
			}
			System.out.println();
		}
		System.out.println();

	}
	public static class Robot{
		public int x;
		public int y;
		public int dir;
		public Robot(int x,int y, int dir){
			this.x=x;
			this.y=y;
			this.dir=dir;
		}
	}
	public static class RMaps{
		public int rnum;
		public boolean bCheck=false;
		public RMaps(int rnum, boolean bCheck){
			this.rnum=rnum;
			this.bCheck=bCheck;
		}
	}

	public static class TestCommand{
		public int r;
		public char command;
		public int loop;
		public TestCommand(int r,char command, int loop){
			this.r=r;
			this.command=command;
			this.loop=loop;
		}
	}

	public static void forword(int x, int y,int dir,int rnum){
		switch (dir){
			case 0:
				//n
				int checkY=y-1;
				if(checkY<0){
					//wall
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[checkY][x].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[checkY][x].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				robots.get(rnum).y=checkY;
				break;
			case 1:
				//w
				int checkX=x-1;
				if(checkX<0){
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[y][checkX].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[y][checkX].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}
				robots.get(rnum).x=checkX;
				break;
			case 2:
				//s
				int checkY2=y+1;
				if(checkY2>=B){
					//wall
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[checkY2][x].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[checkY2][x].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}
				robots.get(rnum).y=checkY2;
				break;
			case 3:
				int checkX2=x+1;
				if(checkX2>=A){
					//wall
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[y][checkX2].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[y][checkX2].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}
				robots.get(rnum).x=checkX2;
				break;
			default:
				break;
		}
	}

	public static RMaps maps[][];
	public static ArrayList<Robot> robots=new ArrayList<>();
	public static ArrayList<TestCommand> testCommands=new ArrayList<>();
	public static void main(String[] args) throws Exception {
		Scanner scan= new Scanner(System.in);
		 A=scan.nextInt(); //5
		 B=scan.nextInt(); //4
		maps=new RMaps[B][A];//4 x 5
		int n=scan.nextInt();
		int m=scan.nextInt();

		for(int i=0;i<B;i++){//y 4
			for(int j=0;j<A;j++){//x 5
				maps[i][j]=new RMaps(-1,false);
			}
		}

		for(int i=0;i<n;i++){
			int x=scan.nextInt()-1; // 5
			int y=B-scan.nextInt();  // 4
			String dir=scan.next();
			int d=0;
			if(dir.charAt(0)=='N'){
				d=0;
			}else if(dir.charAt(0)=='W'){
				d=1;
			}
			else if(dir.charAt(0)=='S'){
				d=2;
			}
			else if(dir.charAt(0)=='E'){
				d=3;
			}
			robots.add(new Robot(x,y,d));
			maps[y][x].bCheck=true;
			maps[y][x].rnum=i;
		}
		//Prints();
		for(int i=0;i<m;i++){
			int r=scan.nextInt();
			String command=scan.next();
			int loop=scan.nextInt();
			testCommands.add(new TestCommand(r,command.charAt(0),loop));
		}


		for(int t=0;t<testCommands.size();t++){
				int rnum=testCommands.get(t).r-1;
				char commad=testCommands.get(t).command;
				int loop =testCommands.get(t).loop;


				int initx=robots.get(rnum).x;
				int inity=robots.get(rnum).y;

				bOkay=true;

				for(int i=0;i<loop;i++){
					int x=robots.get(rnum).x;
					int y=robots.get(rnum).y;
					int dir=robots.get(rnum).dir;
					switch(commad){
						case 'L':
							dir=dir+1;
							robots.get(rnum).dir=dir%4;
							break;
						case 'R':
							dir=dir-1;
							if(dir<0){
								dir=3;
							}
							robots.get(rnum).dir=dir%4;
							break;
						case 'F':
							forword(x,y,dir,rnum);
							if(bOkay==false){
								i=loop+1;
								continue;
							}
							break;
						default:
							break;
					}
				}

				if(bOkay==true){

					maps[inity][initx].bCheck=false;
					maps[inity][initx].rnum=-1;
					maps[robots.get(rnum).y][robots.get(rnum).x].rnum=rnum;
					maps[robots.get(rnum).y][robots.get(rnum).x].bCheck=true;
					//Prints();

					//System.out.println(robots.get(rnum).x+","+robots.get(rnum).y+","+robots.get(rnum).dir);
				}

			if(anws.size()>0){
				break;
			}
		}

		if(anws.size()>0){
			System.out.print(anws.get(0));
		}else{
			System.out.print("OK");
		}
	}
}

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

음 문제 자체는 어렵지 않았고

조금 헤맷던 부분이 문제를 잘못읽어서 시간이 걸렸던 문제입니다.

import java.util.*;
import java.io.*;
public class Main {
	public static int A;
	public static int B;
	public static boolean bOkay=true;
	public static ArrayList<String> anws=new ArrayList<>();
	public static void Prints(){
		System.out.println();
		for(int i=0;i<B;i++){
			for(int j=0;j<A;j++){
				if(maps[i][j].bCheck==true){
					System.out.print(1+",");
				}else{
					System.out.print(0+",");
				}
			}
			System.out.println();
		}
		System.out.println();

	}
	public static class Robot{
		public int x;
		public int y;
		public int dir;
		public Robot(int x,int y, int dir){
			this.x=x;
			this.y=y;
			this.dir=dir;
		}
	}
	public static class RMaps{
		public int rnum;
		public boolean bCheck=false;
		public RMaps(int rnum, boolean bCheck){
			this.rnum=rnum;
			this.bCheck=bCheck;
		}
	}

	public static class TestCommand{
		public int r;
		public char command;
		public int loop;
		public TestCommand(int r,char command, int loop){
			this.r=r;
			this.command=command;
			this.loop=loop;
		}
	}

	public static void forword(int x, int y,int dir,int rnum){
		switch (dir){
			case 0:
				//n
				int checkY=y-1;
				if(checkY<0){
					//wall
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[checkY][x].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[checkY][x].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				robots.get(rnum).y=checkY;
				break;
			case 1:
				//w
				int checkX=x-1;
				if(checkX<0){
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[y][checkX].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[y][checkX].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}
				robots.get(rnum).x=checkX;
				break;
			case 2:
				//s
				int checkY2=y+1;
				if(checkY2>=B){
					//wall
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[checkY2][x].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[checkY2][x].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}
				robots.get(rnum).y=checkY2;
				break;
			case 3:
				int checkX2=x+1;
				if(checkX2>=A){
					//wall
					int tmp=rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into the wall";
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}

				if(maps[y][checkX2].bCheck==true){
					//robot collision
					int tmp=rnum+1;
					int tmp2=maps[y][checkX2].rnum+1;
					String tmpAnw="Robot "+tmp+" crashes into robot "+tmp2;
					anws.add(tmpAnw);
					bOkay=false;
					break;
				}
				robots.get(rnum).x=checkX2;
				break;
			default:
				break;
		}
	}

	public static RMaps maps[][];
	public static ArrayList<Robot> robots=new ArrayList<>();
	public static ArrayList<TestCommand> testCommands=new ArrayList<>();
	public static void main(String[] args) throws Exception {
		Scanner scan= new Scanner(System.in);
		 A=scan.nextInt(); //5
		 B=scan.nextInt(); //4
		maps=new RMaps[B][A];//4 x 5
		int n=scan.nextInt();
		int m=scan.nextInt();

		for(int i=0;i<B;i++){//y 4
			for(int j=0;j<A;j++){//x 5
				maps[i][j]=new RMaps(-1,false);
			}
		}

		for(int i=0;i<n;i++){
			int x=scan.nextInt()-1; // 5
			int y=B-scan.nextInt();  // 4
			String dir=scan.next();
			int d=0;
			if(dir.charAt(0)=='N'){
				d=0;
			}else if(dir.charAt(0)=='W'){
				d=1;
			}
			else if(dir.charAt(0)=='S'){
				d=2;
			}
			else if(dir.charAt(0)=='E'){
				d=3;
			}
			robots.add(new Robot(x,y,d));
			maps[y][x].bCheck=true;
			maps[y][x].rnum=i;
		}
		//Prints();
		for(int i=0;i<m;i++){
			int r=scan.nextInt();
			String command=scan.next();
			int loop=scan.nextInt();
			testCommands.add(new TestCommand(r,command.charAt(0),loop));
		}


		for(int t=0;t<testCommands.size();t++){
				int rnum=testCommands.get(t).r-1;
				char commad=testCommands.get(t).command;
				int loop =testCommands.get(t).loop;


				int initx=robots.get(rnum).x;
				int inity=robots.get(rnum).y;

				bOkay=true;

				for(int i=0;i<loop;i++){
					int x=robots.get(rnum).x;
					int y=robots.get(rnum).y;
					int dir=robots.get(rnum).dir;
					switch(commad){
						case 'L':
							dir=dir+1;
							robots.get(rnum).dir=dir%4;
							break;
						case 'R':
							dir=dir-1;
							if(dir<0){
								dir=3;
							}
							robots.get(rnum).dir=dir%4;
							break;
						case 'F':
							forword(x,y,dir,rnum);
							if(bOkay==false){
								i=loop+1;
								continue;
							}
							break;
						default:
							break;
					}
				}

				if(bOkay==true){

					maps[inity][initx].bCheck=false;
					maps[inity][initx].rnum=-1;
					maps[robots.get(rnum).y][robots.get(rnum).x].rnum=rnum;
					maps[robots.get(rnum).y][robots.get(rnum).x].bCheck=true;
					//Prints();

					//System.out.println(robots.get(rnum).x+","+robots.get(rnum).y+","+robots.get(rnum).dir);
				}

			if(anws.size()>0){
				break;
			}
		}

		if(anws.size()>0){
			System.out.print(anws.get(0));
		}else{
			System.out.print("OK");
		}
	}
}

2024.03.17 - [프로그래밍언어/JAVA] - 순수 JAVA JPA

https://github.com/hibernate/

먼저 hibernate 란 뭘까? 
Hibernate는 자바 기반의 객체 관계 매핑(ORM) 라이브러리입니다. ORM은 객체 지향 프로그래밍 언어를 사용하여 데이터베이스와의 상호작용을 추상화하는 프로그래밍 기법 중 하나로, 개발자가 객체 지향적인 방식으로 데이터베이스를 다룰 수 있게 해줍니다. Hibernate는 이 ORM을 구현한 대표적인 프레임워크 중 하나입니다.
Hibernate의 주요 목적은 Java 어플리케이션에서 사용하는 데이터베이스 작업을 단순화하고, 데이터베이스와 객체 사이의 불일치를 해결하는 것입니다. 이를 통해 개발자는 복잡한 JDBC(Java Database Connectivity) 코드를 작성하는 대신, 더 간결하고 객체 지향적인 코드로 데이터베이스 작업을 수행할 수 있습니다.
-chat gpt-
chat gpt 선생님께서는 이렇게 설명하신다.역시나 정확하시다. 
 
그렇다면 hibrernate의 github을 통해서 코드와 현재 사용중인 내 코드와 비교하면서 확인해보자.
https://github.com/hibernate/hibernate-orm

일반적으로  gradle을 이용하면  hibernate를 사용할수 있습니다.
실제 라이브러리는

이런식으로 있습니다. hibernate 대략적인 구조를 보죠.

유저 가이드를 통해서 보면 이런식으로 되어있습니다.
그렇다면 대략적인 형태를 보았으니 코드로 확인해보자! 
 
spring jpa 의 순수 jpa에서 확인할수 잇지만 필자는 spring jpa로 개발을 많이 하기때문에 spring jpa 로 확인해보겠습니다.
 
jpaRepostory의 구현체이다. 
SimpleJpaRepository 클래스 실제로 실행된다면 아래의 클래스가 jpaRepostory가 실행됩니다.
여기서 라이브러리를 보면 

package org.springframework.data.jpa.repository.support;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import javax.persistence.EntityManager;
import javax.persistence.LockModeType;
import javax.persistence.NoResultException;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.ParameterExpression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.convert.QueryByExamplePredicateBuilder;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.provider.PersistenceProvider;
import org.springframework.data.jpa.repository.query.EscapeCharacter;
import org.springframework.data.jpa.repository.query.QueryUtils;
import org.springframework.data.jpa.repository.support.QueryHints.NoHints;
import org.springframework.data.repository.query.FluentQuery;
import org.springframework.data.support.PageableExecutionUtils;
import org.springframework.data.util.ProxyUtils;
import org.springframework.data.util.Streamable;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

@Repository
@Transactional(
    readOnly = true
)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
    private static final String ID_MUST_NOT_BE_NULL = "The given id must not be null!";
    private final JpaEntityInformation<T, ?> entityInformation;
    private final EntityManager em;
    private final PersistenceProvider provider;
    @Nullable
    private CrudMethodMetadata metadata;
    private EscapeCharacter escapeCharacter;

    public SimpleJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
        this.escapeCharacter = EscapeCharacter.DEFAULT;
        Assert.notNull(entityInformation, "JpaEntityInformation must not be null!");
        Assert.notNull(entityManager, "EntityManager must not be null!");
        this.entityInformation = entityInformation;
        this.em = entityManager;
        this.provider = PersistenceProvider.fromEntityManager(entityManager);
    }

    public SimpleJpaRepository(Class<T> domainClass, EntityManager em) {
        this(JpaEntityInformationSupport.getEntityInformation(domainClass, em), em);
    }

    public void setRepositoryMethodMetadata(CrudMethodMetadata crudMethodMetadata) {
        this.metadata = crudMethodMetadata;
    }

    public void setEscapeCharacter(EscapeCharacter escapeCharacter) {
        this.escapeCharacter = escapeCharacter;
    }

    @Nullable
    protected CrudMethodMetadata getRepositoryMethodMetadata() {
        return this.metadata;
    }

    protected Class<T> getDomainClass() {
        return this.entityInformation.getJavaType();
    }

    private String getDeleteAllQueryString() {
        return QueryUtils.getQueryString("delete from %s x", this.entityInformation.getEntityName());
    }

    private String getCountQueryString() {
        String countQuery = String.format("select count(%s) from %s x", this.provider.getCountQueryPlaceholder(), "%s");
        return QueryUtils.getQueryString(countQuery, this.entityInformation.getEntityName());
    }

    @Transactional
    public void deleteById(ID id) {
        Assert.notNull(id, "The given id must not be null!");
        this.delete(this.findById(id).orElseThrow(() -> {
            return new EmptyResultDataAccessException(String.format("No %s entity with id %s exists!", this.entityInformation.getJavaType(), id), 1);
        }));
    }

    @Transactional
    public void delete(T entity) {
        Assert.notNull(entity, "Entity must not be null!");
        if (!this.entityInformation.isNew(entity)) {
            Class<?> type = ProxyUtils.getUserClass(entity);
            T existing = this.em.find(type, this.entityInformation.getId(entity));
            if (existing != null) {
                this.em.remove(this.em.contains(entity) ? entity : this.em.merge(entity));
            }
        }
    }

    @Transactional
    public void deleteAllById(Iterable<? extends ID> ids) {
        Assert.notNull(ids, "Ids must not be null!");
        Iterator var2 = ids.iterator();

        while(var2.hasNext()) {
            ID id = var2.next();
            this.deleteById(id);
        }

    }

    @Transactional
    public void deleteAllByIdInBatch(Iterable<ID> ids) {
        Assert.notNull(ids, "Ids must not be null!");
        if (ids.iterator().hasNext()) {
            if (this.entityInformation.hasCompositeId()) {
                List<T> entities = new ArrayList();
                ids.forEach((id) -> {
                    entities.add(this.getReferenceById(id));
                });
                this.deleteAllInBatch(entities);
            } else {
                String queryString = String.format("delete from %s x where %s in :ids", this.entityInformation.getEntityName(), this.entityInformation.getIdAttribute().getName());
                Query query = this.em.createQuery(queryString);
                if (Collection.class.isInstance(ids)) {
                    query.setParameter("ids", ids);
                } else {
                    Collection<ID> idsCollection = (Collection)StreamSupport.stream(ids.spliterator(), false).collect(Collectors.toCollection(ArrayList::new));
                    query.setParameter("ids", idsCollection);
                }

                query.executeUpdate();
            }

        }
    }

    @Transactional
    public void deleteAll(Iterable<? extends T> entities) {
        Assert.notNull(entities, "Entities must not be null!");
        Iterator var2 = entities.iterator();

        while(var2.hasNext()) {
            T entity = var2.next();
            this.delete(entity);
        }

    }

    @Transactional
    public void deleteAllInBatch(Iterable<T> entities) {
        Assert.notNull(entities, "Entities must not be null!");
        if (entities.iterator().hasNext()) {
            QueryUtils.applyAndBind(QueryUtils.getQueryString("delete from %s x", this.entityInformation.getEntityName()), entities, this.em).executeUpdate();
        }
    }

    @Transactional
    public void deleteAll() {
        Iterator var1 = this.findAll().iterator();

        while(var1.hasNext()) {
            T element = var1.next();
            this.delete(element);
        }

    }

    @Transactional
    public void deleteAllInBatch() {
        this.em.createQuery(this.getDeleteAllQueryString()).executeUpdate();
    }

    public Optional<T> findById(ID id) {
        Assert.notNull(id, "The given id must not be null!");
        Class<T> domainType = this.getDomainClass();
        if (this.metadata == null) {
            return Optional.ofNullable(this.em.find(domainType, id));
        } else {
            LockModeType type = this.metadata.getLockModeType();
            Map<String, Object> hints = new HashMap();
            this.getQueryHints().withFetchGraphs(this.em).forEach(hints::put);
            return Optional.ofNullable(type == null ? this.em.find(domainType, id, hints) : this.em.find(domainType, id, type, hints));
        }
    }

    protected QueryHints getQueryHints() {
        return (QueryHints)(this.metadata == null ? NoHints.INSTANCE : DefaultQueryHints.of(this.entityInformation, this.metadata));
    }

    /** @deprecated */
    @Deprecated
    public T getOne(ID id) {
        return this.getReferenceById(id);
    }

    /** @deprecated */
    @Deprecated
    public T getById(ID id) {
        return this.getReferenceById(id);
    }

    public T getReferenceById(ID id) {
        Assert.notNull(id, "The given id must not be null!");
        return this.em.getReference(this.getDomainClass(), id);
    }

    public boolean existsById(ID id) {
        Assert.notNull(id, "The given id must not be null!");
        if (this.entityInformation.getIdAttribute() == null) {
            return this.findById(id).isPresent();
        } else {
            String placeholder = this.provider.getCountQueryPlaceholder();
            String entityName = this.entityInformation.getEntityName();
            Iterable<String> idAttributeNames = this.entityInformation.getIdAttributeNames();
            String existsQuery = QueryUtils.getExistsQueryString(entityName, placeholder, idAttributeNames);
            TypedQuery<Long> query = this.em.createQuery(existsQuery, Long.class);
            if (!this.entityInformation.hasCompositeId()) {
                query.setParameter((String)idAttributeNames.iterator().next(), id);
                return (Long)query.getSingleResult() == 1L;
            } else {
                Iterator var7 = idAttributeNames.iterator();

                while(var7.hasNext()) {
                    String idAttributeName = (String)var7.next();
                    Object idAttributeValue = this.entityInformation.getCompositeIdAttributeValue(id, idAttributeName);
                    boolean complexIdParameterValueDiscovered = idAttributeValue != null && !query.getParameter(idAttributeName).getParameterType().isAssignableFrom(idAttributeValue.getClass());
                    if (complexIdParameterValueDiscovered) {
                        return this.findById(id).isPresent();
                    }

                    query.setParameter(idAttributeName, idAttributeValue);
                }

                return (Long)query.getSingleResult() == 1L;
            }
        }
    }

    public List<T> findAll() {
        return this.getQuery((Specification)null, (Sort)Sort.unsorted()).getResultList();
    }

    public List<T> findAllById(Iterable<ID> ids) {
        Assert.notNull(ids, "Ids must not be null!");
        if (!ids.iterator().hasNext()) {
            return Collections.emptyList();
        } else if (!this.entityInformation.hasCompositeId()) {
            Collection<ID> idCollection = Streamable.of(ids).toList();
            ByIdsSpecification<T> specification = new ByIdsSpecification(this.entityInformation);
            TypedQuery<T> query = this.getQuery(specification, (Sort)Sort.unsorted());
            return query.setParameter(specification.parameter, idCollection).getResultList();
        } else {
            List<T> results = new ArrayList();
            Iterator var3 = ids.iterator();

            while(var3.hasNext()) {
                ID id = var3.next();
                this.findById(id).ifPresent(results::add);
            }

            return results;
        }
    }

    public List<T> findAll(Sort sort) {
        return this.getQuery((Specification)null, (Sort)sort).getResultList();
    }

    public Page<T> findAll(Pageable pageable) {
        return (Page)(isUnpaged(pageable) ? new PageImpl(this.findAll()) : this.findAll((Specification)null, pageable));
    }

    public Optional<T> findOne(@Nullable Specification<T> spec) {
        try {
            return Optional.of(this.getQuery(spec, Sort.unsorted()).getSingleResult());
        } catch (NoResultException var3) {
            return Optional.empty();
        }
    }

    public List<T> findAll(@Nullable Specification<T> spec) {
        return this.getQuery(spec, Sort.unsorted()).getResultList();
    }

    public Page<T> findAll(@Nullable Specification<T> spec, Pageable pageable) {
        TypedQuery<T> query = this.getQuery(spec, pageable);
        return (Page)(isUnpaged(pageable) ? new PageImpl(query.getResultList()) : this.readPage(query, this.getDomainClass(), pageable, spec));
    }

    public List<T> findAll(@Nullable Specification<T> spec, Sort sort) {
        return this.getQuery(spec, sort).getResultList();
    }

    public <S extends T> Optional<S> findOne(Example<S> example) {
        try {
            return Optional.of(this.getQuery(new ExampleSpecification(example, this.escapeCharacter), example.getProbeType(), (Sort)Sort.unsorted()).getSingleResult());
        } catch (NoResultException var3) {
            return Optional.empty();
        }
    }

    public <S extends T> long count(Example<S> example) {
        return executeCountQuery(this.getCountQuery(new ExampleSpecification(example, this.escapeCharacter), example.getProbeType()));
    }

    public <S extends T> boolean exists(Example<S> example) {
        Specification<S> spec = new ExampleSpecification(example, this.escapeCharacter);
        CriteriaQuery<Integer> cq = this.em.getCriteriaBuilder().createQuery(Integer.class);
        cq.select(this.em.getCriteriaBuilder().literal(1));
        this.applySpecificationToCriteria(spec, example.getProbeType(), cq);
        TypedQuery<Integer> query = this.applyRepositoryMethodMetadata(this.em.createQuery(cq));
        return query.setMaxResults(1).getResultList().size() == 1;
    }

    public boolean exists(Specification<T> spec) {
        CriteriaQuery<Integer> cq = this.em.getCriteriaBuilder().createQuery(Integer.class);
        cq.select(this.em.getCriteriaBuilder().literal(1));
        this.applySpecificationToCriteria(spec, this.getDomainClass(), cq);
        TypedQuery<Integer> query = this.applyRepositoryMethodMetadata(this.em.createQuery(cq));
        return query.setMaxResults(1).getResultList().size() == 1;
    }

    public <S extends T> List<S> findAll(Example<S> example) {
        return this.getQuery(new ExampleSpecification(example, this.escapeCharacter), example.getProbeType(), (Sort)Sort.unsorted()).getResultList();
    }

    public <S extends T> List<S> findAll(Example<S> example, Sort sort) {
        return this.getQuery(new ExampleSpecification(example, this.escapeCharacter), example.getProbeType(), (Sort)sort).getResultList();
    }

    public <S extends T> Page<S> findAll(Example<S> example, Pageable pageable) {
        ExampleSpecification<S> spec = new ExampleSpecification(example, this.escapeCharacter);
        Class<S> probeType = example.getProbeType();
        TypedQuery<S> query = this.getQuery(new ExampleSpecification(example, this.escapeCharacter), probeType, (Pageable)pageable);
        return (Page)(isUnpaged(pageable) ? new PageImpl(query.getResultList()) : this.readPage(query, probeType, pageable, spec));
    }

    public <S extends T, R> R findBy(Example<S> example, Function<FluentQuery.FetchableFluentQuery<S>, R> queryFunction) {
        Assert.notNull(example, "Sample must not be null!");
        Assert.notNull(queryFunction, "Query function must not be null!");
        Function<Sort, TypedQuery<S>> finder = (sort) -> {
            ExampleSpecification<S> spec = new ExampleSpecification(example, this.escapeCharacter);
            Class<S> probeType = example.getProbeType();
            return this.getQuery(spec, probeType, (Sort)sort);
        };
        FluentQuery.FetchableFluentQuery<S> fluentQuery = new FetchableFluentQueryByExample(example, finder, this::count, this::exists, this.em, this.escapeCharacter);
        return queryFunction.apply(fluentQuery);
    }

    public long count() {
        return (Long)this.em.createQuery(this.getCountQueryString(), Long.class).getSingleResult();
    }

    public long count(@Nullable Specification<T> spec) {
        return executeCountQuery(this.getCountQuery(spec, this.getDomainClass()));
    }

    @Transactional
    public <S extends T> S save(S entity) {
        Assert.notNull(entity, "Entity must not be null.");
        if (this.entityInformation.isNew(entity)) {
            this.em.persist(entity);
            return entity;
        } else {
            return this.em.merge(entity);
        }
    }

    @Transactional
    public <S extends T> S saveAndFlush(S entity) {
        S result = this.save(entity);
        this.flush();
        return result;
    }

    @Transactional
    public <S extends T> List<S> saveAll(Iterable<S> entities) {
        Assert.notNull(entities, "Entities must not be null!");
        List<S> result = new ArrayList();
        Iterator var3 = entities.iterator();

        while(var3.hasNext()) {
            S entity = var3.next();
            result.add(this.save(entity));
        }

        return result;
    }

    @Transactional
    public <S extends T> List<S> saveAllAndFlush(Iterable<S> entities) {
        List<S> result = this.saveAll(entities);
        this.flush();
        return result;
    }

    @Transactional
    public void flush() {
        this.em.flush();
    }

    /** @deprecated */
    @Deprecated
    protected Page<T> readPage(TypedQuery<T> query, Pageable pageable, @Nullable Specification<T> spec) {
        return this.readPage(query, this.getDomainClass(), pageable, spec);
    }

    protected <S extends T> Page<S> readPage(TypedQuery<S> query, final Class<S> domainClass, Pageable pageable, @Nullable Specification<S> spec) {
        if (pageable.isPaged()) {
            query.setFirstResult((int)pageable.getOffset());
            query.setMaxResults(pageable.getPageSize());
        }

        return PageableExecutionUtils.getPage(query.getResultList(), pageable, () -> {
            return executeCountQuery(this.getCountQuery(spec, domainClass));
        });
    }

    protected TypedQuery<T> getQuery(@Nullable Specification<T> spec, Pageable pageable) {
        Sort sort = pageable.isPaged() ? pageable.getSort() : Sort.unsorted();
        return this.getQuery(spec, this.getDomainClass(), sort);
    }

    protected <S extends T> TypedQuery<S> getQuery(@Nullable Specification<S> spec, Class<S> domainClass, Pageable pageable) {
        Sort sort = pageable.isPaged() ? pageable.getSort() : Sort.unsorted();
        return this.getQuery(spec, domainClass, sort);
    }

    protected TypedQuery<T> getQuery(@Nullable Specification<T> spec, Sort sort) {
        return this.getQuery(spec, this.getDomainClass(), sort);
    }

    protected <S extends T> TypedQuery<S> getQuery(@Nullable Specification<S> spec, Class<S> domainClass, Sort sort) {
        CriteriaBuilder builder = this.em.getCriteriaBuilder();
        CriteriaQuery<S> query = builder.createQuery(domainClass);
        Root<S> root = this.applySpecificationToCriteria(spec, domainClass, query);
        query.select(root);
        if (sort.isSorted()) {
            query.orderBy(QueryUtils.toOrders(sort, root, builder));
        }

        return this.applyRepositoryMethodMetadata(this.em.createQuery(query));
    }

    /** @deprecated */
    @Deprecated
    protected TypedQuery<Long> getCountQuery(@Nullable Specification<T> spec) {
        return this.getCountQuery(spec, this.getDomainClass());
    }

    protected <S extends T> TypedQuery<Long> getCountQuery(@Nullable Specification<S> spec, Class<S> domainClass) {
        CriteriaBuilder builder = this.em.getCriteriaBuilder();
        CriteriaQuery<Long> query = builder.createQuery(Long.class);
        Root<S> root = this.applySpecificationToCriteria(spec, domainClass, query);
        if (query.isDistinct()) {
            query.select(builder.countDistinct(root));
        } else {
            query.select(builder.count(root));
        }

        query.orderBy(Collections.emptyList());
        return this.em.createQuery(query);
    }

    private <S, U extends T> Root<U> applySpecificationToCriteria(@Nullable Specification<U> spec, Class<U> domainClass, CriteriaQuery<S> query) {
        Assert.notNull(domainClass, "Domain class must not be null!");
        Assert.notNull(query, "CriteriaQuery must not be null!");
        Root<U> root = query.from(domainClass);
        if (spec == null) {
            return root;
        } else {
            CriteriaBuilder builder = this.em.getCriteriaBuilder();
            Predicate predicate = spec.toPredicate(root, query, builder);
            if (predicate != null) {
                query.where(predicate);
            }

            return root;
        }
    }

    private <S> TypedQuery<S> applyRepositoryMethodMetadata(TypedQuery<S> query) {
        if (this.metadata == null) {
            return query;
        } else {
            LockModeType type = this.metadata.getLockModeType();
            TypedQuery<S> toReturn = type == null ? query : query.setLockMode(type);
            this.applyQueryHints(toReturn);
            return toReturn;
        }
    }

    private void applyQueryHints(Query query) {
        this.getQueryHints().withFetchGraphs(this.em).forEach(query::setHint);
    }

    private static long executeCountQuery(TypedQuery<Long> query) {
        Assert.notNull(query, "TypedQuery must not be null!");
        List<Long> totals = query.getResultList();
        long total = 0L;

        Long element;
        for(Iterator var4 = totals.iterator(); var4.hasNext(); total += element == null ? 0L : element) {
            element = (Long)var4.next();
        }

        return total;
    }

    private static boolean isUnpaged(Pageable pageable) {
        return pageable.isUnpaged();
    }

    private static class ExampleSpecification<T> implements Specification<T> {
        private static final long serialVersionUID = 1L;
        private final Example<T> example;
        private final EscapeCharacter escapeCharacter;

        ExampleSpecification(Example<T> example, EscapeCharacter escapeCharacter) {
            Assert.notNull(example, "Example must not be null!");
            Assert.notNull(escapeCharacter, "EscapeCharacter must not be null!");
            this.example = example;
            this.escapeCharacter = escapeCharacter;
        }

        public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            return QueryByExamplePredicateBuilder.getPredicate(root, cb, this.example, this.escapeCharacter);
        }
    }

    private static final class ByIdsSpecification<T> implements Specification<T> {
        private static final long serialVersionUID = 1L;
        private final JpaEntityInformation<T, ?> entityInformation;
        @Nullable
        ParameterExpression<Collection<?>> parameter;

        ByIdsSpecification(JpaEntityInformation<T, ?> entityInformation) {
            this.entityInformation = entityInformation;
        }

        public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            Path<?> path = root.get(this.entityInformation.getIdAttribute());
            this.parameter = cb.parameter(Collection.class);
            return path.in(this.parameter);
        }
    }
}

 
hibernate에서 사용하는 라이브러리이다.

 
 
가장 중요한게 EntitiManger를 먼저 보자.

 private final EntityManager em;

 
코드에

hibernate에서 사용하는걸 코드에서 볼수 있습니다.
그렇다면 

 
Session 클래스를 보자.
보면 EntityMager를 상속받는 Hiberante 라이브러리에 있는 클래스이다.

 
그렇다면 다음 구조를 확인해보자.
SessionImpl 클래스이다.

 
즉 이런식의 구조로 되어있네요. 
 
그렇다면 간단하게 jpa Repostory의 findAll을 보자 
prodocts->finaAll();
 
SimpleJpaReopository .findAll()

 public List<T> findAll() {
        return this.getQuery((Specification)null, (Sort)Sort.unsorted()).getResultList();
    }

finAll()->GetQuery(spec,sort)

protected TypedQuery<T> getQuery(@Nullable Specification<T> spec, Sort sort) {
        return this.getQuery(spec, this.getDomainClass(), sort);
    }

finAll()-> GetQuery( spec,sort )->getQuery( spec,domainClass,sort );

protected <S extends T> TypedQuery<S> getQuery(@Nullable Specification<S> spec, Class<S> domainClass, Sort sort) {
        CriteriaBuilder builder = this.em.getCriteriaBuilder();
        CriteriaQuery<S> query = builder.createQuery(domainClass);
        Root<S> root = this.applySpecificationToCriteria(spec, domainClass, query);
        query.select(root);
        if (sort.isSorted()) {
            query.orderBy(QueryUtils.toOrders(sort, root, builder));
        }

        return this.applyRepositoryMethodMetadata(this.em.createQuery(query));
    }

 
보시면 EntityManger가 가지고 있는 Criteria api 를 이용해서 쿼리문을 작성해서 

query.select(root);
        if (sort.isSorted()) {
            query.orderBy(QueryUtils.toOrders(sort, root, builder));
        }

데이터를 불러옵니다. 
 
applySpecificationToCriteria // check 용
applyRepositoryMethodMetadata // check 용
 
이런식으로 대략적으로 흘러갑니다.
 
다음에는 데이터를 조회할때나 저장할때 어떻게 흘러가는지 디버깅 모드로 한번 확인해보겠습니다.
 
 

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

흠 아무리 봐도 스택 문제보단 그리드 문제같은 문제 ... ㅎㅎ ;; 

시간 복잡도랑 메모리 초과 문제가 발생할수 있습니다.

시간 복잡도는 O(N^2)를 회피해야합니다.

최대한 O(N) 가깝게 for  문을 돌려야 하네요. ㅎㅎ 

import java.util.*;
import java.io.*;

public class Main {
	public static class Tower{
		public long tower;
		public long index;
		public Tower(long tower,long index) {
			this.tower=tower;
			this.index=index;
		}
	}
	public static void main(String[] args) throws Exception {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		int n=Integer.parseInt(bf.readLine());
		
		long tower[]=new long[n];
		long send[]=new long[n];
		
		StringTokenizer stmp=new StringTokenizer(bf.readLine()," ");
		Stack<Tower> stacks=new Stack<>();
		for(int i=0 ;i<n;i++) {
			tower[i] = Long.parseLong(stmp.nextToken());
			while(!stacks.isEmpty()) {
				if(tower[i]>stacks.peek().tower) {
					stacks.pop();
				}else {
					System.out.print(stacks.peek().index+" ");
					break;
				}
			}
			//9 5 7
			if(stacks.empty()){
	            System.out.print(0 + " ");
	        }
			stacks.push( new Tower (tower[i], i+1 ));
		}
		
		
	}
}