사전캠프 15일차

같은 조원들과 알고리즘 스터디를 시작했다.

매일마다 2문제씩 풀고 의견을 나누기로 했는데 좋을거같다.

 

1931번 회의실

다들 람다식을 잘 쓰는걸 보고 뭔가 부러웠다. 다들 코드는 거의 유사했다. 

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int n = Integer.parseInt(bf.readLine());
        int [][] arr = new int[n][2];
        for(int i=0;i<n;i++) {
        	StringTokenizer st = new StringTokenizer(bf.readLine());
        	arr[i][0] = Integer.parseInt(st.nextToken());
        	arr[i][1] = Integer.parseInt(st.nextToken());
        }
        //끝나는 시간을 기준으로 정렬 끝나는 시간이 같다면 시작하는 시간 순으로 정렬
        Arrays.sort(arr, new Comparator<int[]>() {
			@Override
			public int compare(int[] o1, int[] o2) {
				// TODO Auto-generated method stub
				if(o1[1]==o2[1]) return o1[0] - o2[0];
				else return o1[1] - o2[1];
			}
        });
        int endTime = arr[0][1]; // 이전 회의가 끝나는 시간
        int count = 1; //사용 가능한 회의의 최대 개수
        for(int i=1;i<n;i++) {
        	  if(arr[i][0] >= endTime) {
        		  count++;
        		  endTime = arr[i][1];
        	  }
        }
       bw.write(String.valueOf(count));
       bw.flush();
       bw.close();
    }
}

 

1541 잃어버린 괄호

나머지 팀원들은 split을 이용해서 -가 나오면 자르고 그 사이를 더하는 식으로 문제를 풀었다. 나는 StringTokenizer를 사용해서 +와- 가 나오면 자르고 Queue에 넣는 식으로 문제를 풀었다. StringTokenizer를 이용해서 - 만 자르고 나머지 끼리는 더한 다음에 빼주는 식이 제일 좋은 방법인거 같다! 

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(bf.readLine(),"+-",true);
        Queue <Integer> q = new LinkedList<>();
        int sum = Integer.parseInt(st.nextToken());
        while(st.hasMoreTokens()) {
        	String op = st.nextToken();
        	if(op.equals("-")) {
        		while(!q.isEmpty()) {
        			sum -= q.poll();
        		}	
        	q.add(Integer.parseInt(st.nextToken()));
        	}
        	else {
        		if(q.isEmpty()) {
        			sum += Integer.parseInt(st.nextToken());
        		}
        		else {
        			q.add(Integer.parseInt(st.nextToken()));
        		}
        	}
     }
        while(!q.isEmpty()) {
        	sum -= q.poll();
        }
        bw.write(String.valueOf(sum));
        bw.flush();
        bw.close();
   
    }
}

 

 

14891번 톱니바퀴

이 문제는 나 혼자 푼 시뮬레이션 문제로 시뮬레이션 문제를 풀다 보니 막 어렵진 않은데 코드가 굉장히 길어져서 디버깅이 굉장히 중요한 유형인거 같다! 또한 문제가 발생하면 문제가 발생한 부분을 찾는게 굉장히 쉽지 않아서 맨 처음부터 잘 짜야할거 같다. 또한 코드를 조금 더 깔끔하게 짤 수 있었는데 아쉽다!

public class Main {
	public static int [][] arr;
	public static boolean turn[] ; 
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        arr = new int[4][8];
        for(int i=0;i<4;i++) {
        	StringTokenizer st = new StringTokenizer(bf.readLine(),"01",true);
        	for(int j=0;j<8;j++) {
        		arr[i][j] = Integer.parseInt(st.nextToken());
        	}
        }
        int n = Integer.parseInt(bf.readLine());
        for(int i=0;i<n;i++) {
        	turn = new boolean[4];
        	StringTokenizer st = new StringTokenizer(bf.readLine());
        	int topni = Integer.parseInt(st.nextToken());
        	int dir = Integer.parseInt(st.nextToken());
        	if(topni == 1) {
        		turn[0] = true;
        		for(int j=0;j<3;j++) {
        			if(arr[j][2]==arr[j+1][6]) {
        				break;
        			}
        			else {
        				turn[j+1] = true;
        			}
        		}
        	}
        	else if(topni==2) {
        		turn[1] = true;
        		dir = dir * -1;
        		if(arr[0][2]!=arr[1][6]) {
        			turn[0] = true;
        		}
        		for(int j=1;j<3;j++) {
        			if(arr[j][2]==arr[j+1][6]) {
        				break;
        			}
        			else {
        				turn[j+1] = true;
        			}
        		}
        	}
        	else if(topni==3) {
        		turn[2] = true;
        		if(arr[2][2]!=arr[3][6]) {
        			turn[3] = true;
        		}
        		for(int j=2;j>0;j--) {
        			if(arr[j][6]==arr[j-1][2]) {
        				break;
        			}
        			else {
        				turn[j-1] = true;
        			}
        		}
        	}
        	else {
        		turn[3] = true;
        		dir = dir * -1;
        		for(int j=3;j>0;j--) {
        			if(arr[j][6]==arr[j-1][2]) {
        				break;
        			}
        			else {
        				turn[j-1] = true;
        			}
        		}
        	}
        	for(int k=0;k<4;k++) {
        		check(k,dir);
        		dir  = dir * -1 ;
        	}
        }
        int sum =0;
        int count = 1;
       	for(int i=0;i<4;i++) {
       		if(arr[i][0]==1) {
       			sum += count;
       		}
       		count *= 2;
       	}
       	bw.write(String.valueOf(sum));
        bw.flush();
        bw.close();
   
    }
    public static void check(int t, int dir) {
    	if(turn[t]) {
    		if(dir==1) {
    			rightMove(t);
    		}
    		else {
    			leftMove(t);
    		}
    		
    	}
    }
    public static void leftMove(int a) {
    	int temp = arr[a][0];
    	for(int i=1;i<8;i++) {
    		arr[a][i-1] = arr[a][i];
    	}
    	arr[a][7] = temp;
    }
    public static void rightMove(int a) {
    	int temp = arr[a][7];
    	for(int i=7;i>0;i--) {
    		arr[a][i] = arr[a][i-1];
    	}
    	arr[a][0] = temp;
    }
}

 

앞으로는 이렇게 알고리즘 스터디용 문제 2개를 풀고 남은 시간에 시뮬레이션 문제를 쭉 풀거같다!