코딩하는 등산가

백준_1439 뒤집기(자바) / 문자열

미스터로즈 — Mon, 13 Dec 2021 09:52:38 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_1439 {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		char[] arr = br.readLine().toCharArray();
		int[] count = new int[2];
		char tmp = arr[0];
		
		count[tmp-'0']++;
		for (int i = 1; i < arr.length; i++) {
			if(tmp !=arr[i]) {
				count[arr[i]-'0']++;
				tmp = arr[i];
			}
		}
		
		System.out.println(Math.min(count[0], count[1]));
	}
}

※ 내 생각

이 문제는 문자열을 활용하는 문제입니다.

이 문제는 구역을 파악하고 0 인지 1인지 확인하면 됩니다.
구역의 수 만큼 비교하여 적은 값을 출력하면 됩니다.

백준_3060 욕심쟁이 돼지(자바) / 시뮬레이션

미스터로즈 — Wed, 1 Dec 2021 10:36:30 +0900

시간&메모리 제한

문제풀이

입력&출력

문제풀이

package com.Back;

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

public class Back_3060 {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int testCase = Integer.parseInt(br.readLine());
		
		StringTokenizer st;
		StringBuilder sb = new StringBuilder();
		for (int tc = 0; tc < testCase; tc++) {
			int N = Integer.parseInt(br.readLine());
			int ans = 1;
			int sum = 0;
			
			st = new StringTokenizer(br.readLine());
			
			for (int i = 0; i < 6; i++) {
				sum+=Integer.parseInt(st.nextToken());
			}
			
			while(sum<=N) {
				sum*=4;
				ans++;
			}
			sb.append(ans+"\n");
		}
		System.out.println(sb);
	}
}

※ 내 생각

이 문제는 시뮬레이션으로 푸는 문제입니다.

먼저 테스트케이스 수를 받아 오고 그 수 만큼 for문을 돌립니다.
for문을 통해 각각의 수를 sum으로 받고, 모든 돼지들이 양 옆, 본인, 맞은편을 더하기 때문에
기존의 값에 4배가 됩니다.

4배 한 값이 사료의 값보다 작을 때까지 for문을 돌려서 해결해 줍니다.

백준_7569 토마토(자바) / BFS

미스터로즈 — Tue, 30 Nov 2021 10:20:53 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_7569 {

	static int N, M, H , ans;
	static int[][][] arr;
	static int dx[] = { -1, 1, 0, 0, 0, 0 };
	static int dy[] = { 0, 0, -1, 1, 0, 0 };
	static int dz[] = { 0, 0, 0, 0, -1, 1 };
	static Queue<tomato> q;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		H = Integer.parseInt(st.nextToken());
		q = new LinkedList<>();
		arr = new int[M][N][H];

		for (int i = 0; i < H; i++) {
			for (int j = 0; j < M; j++) {
				st = new StringTokenizer(br.readLine());
				for (int k = 0; k < N; k++) {
					arr[j][k][i] = Integer.parseInt(st.nextToken());
					if (arr[j][k][i] == 1)
						q.add(new tomato(j, k, i));
				}
			}
		}
		bfs();
		
		for (int i = 0; i < H; i++) {
			for (int j = 0; j < M; j++) {
				for (int k = 0; k < N; k++) {
					if(arr[j][k][i]==0) {
						System.out.println("-1");
						System.exit(0);
					}
					ans = Math.max(ans, arr[j][k][i]);
				}
			}
		}
		System.out.println(ans-1);
	}

	private static void bfs() {
		while (!q.isEmpty()) {
			tomato t = q.poll();

			int x = t.x;
			int y = t.y;
			int z = t.z;
			
			for (int i = 0; i < 6; i++) {
				int xx = x + dx[i];
				int yy = y + dy[i];
				int zz = z + dz[i];
				
				if(xx>=0 && xx<M && yy>=0 && yy<N && zz>=0 && zz<H) {
					
					if(arr[xx][yy][zz]==0) {
						q.add(new tomato(xx,yy,zz));
						arr[xx][yy][zz]=arr[x][y][z]+1;
					}
				}
			}
		}
	}

	static class tomato {
		int x;
		int y;
		int z;

		public tomato(int x, int y, int z) {
			super();
			this.x = x;
			this.y = y;
			this.z = z;
		}

	}
}

※ 내 생각

이 문제는 BFS를 활용해서 푸는 문제입니다.

3차원 배열 식으로 푸는 문제였고, 방문 여부를 익지 않은 토마토에 대해서만
큐에 담아주는 식으로 풀어주면 됩니다.

3차원이므로 4방 탐색이 아닌 6방 탐색을 진행해야 합니다. 상하좌우위아래로 진행하면 됩니다.

백준_1927 최소힙(자바) / 우선순위 큐

미스터로즈 — Fri, 26 Nov 2021 09:17:51 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_1927 {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		PriorityQueue<Integer> pq = new PriorityQueue<>();
		
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < N; i++) {
			int tmp = Integer.parseInt(br.readLine());
			
			if(tmp==0) {
				if(pq.size()==0) {
					sb.append("0\n");
				}else {
					sb.append(pq.poll()+"\n");
				}
			}else {
				pq.add(tmp);
			}
		}
		System.out.println(sb);
	}
}

※ 내 생각

이 문제는 우선순위 큐인 자료구조를 이용하는 문제입니다.

우선 순위 큐는 정렬 조건을 만들어 놓으면 알아서 정렬을 진행해 줍니다.
따라서 값을 넣어주고 맨 앞에 있는 것을 출력해주면 됩니다.

백준_1246 온라인 판매(자바) / 그리디

미스터로즈 — Thu, 25 Nov 2021 09:41:48 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_1246 {

	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());
		
		ArrayList<Integer> arr = new ArrayList<>();
		
		for (int i = 0; i < M; i++) {
			arr.add(Integer.parseInt(br.readLine()));
		}
		
		Collections.sort(arr);
		
		int ans = 0;
		int max = 0;
		
		for (int i = 0; i < M; i++) {
			int tmp = arr.get(i);
			int tmpsum = 0;
			
			if(M-i<N) {
				tmpsum = tmp * (M-i);
			}else {
				tmpsum = tmp * N;
			}
			
			if(tmpsum>max) {
				max = tmpsum;
				ans = tmp;
			}
		}
		System.out.println(ans + " "+ max);
	}
}

※ 내 생각

이 문제는 그리디 알고리즘을 활용하는 문제입니다.

먼저 값을 입력한 다음에 정렬을 진행합니다.
정렬해준 값을 기준으로 for문을 돌려서 각 위치에서의 최댓값을 구해줍니다.

이 때, M과 N의 크기를 고려해서 진행하면 됩니다.

백준_16953 A->B (자바) / 탐색

미스터로즈 — Tue, 23 Nov 2021 09:36:03 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_16953 {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		int A = Integer.parseInt(st.nextToken());
		int B = Integer.parseInt(st.nextToken());
		
		int ans =1;
		
		while(true) {
			if(A==B) {
				break;
			}
			if(A>B) {
				ans = -1;
				break;
			}
			String tmp = String.valueOf(B);
			if(B%2!=0 && tmp.charAt(tmp.length()-1)!='1') {
				ans = -1;
				break;
			}
			
			if(B%2==0) {
				B/=2;
			}else {
				tmp = tmp.substring(0,tmp.length()-1);
				B = Integer.parseInt(tmp);
			}
			
			ans++;
		}
		System.out.println(ans);
	}
}

※ 내 생각

이 문제는 탐색을 활용하는 문제입니다.

각 문자에 대해서 탐색을 진행하고 문제를 해결할 수 있습니다.
A가 아닌 B를 기준으로 진행을 하고, B에 따라 조건을 보고
해당하지 않으면 예외로 처리하여 while문을 나가게 만들어줍니다.

백준_4307 개미(자바) / 구현

미스터로즈 — Sat, 20 Nov 2021 08:33:36 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_4307 {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int testCase = Integer.parseInt(br.readLine());
		StringTokenizer st;
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < testCase; i++) {
			st = new StringTokenizer(br.readLine());
			
			int l = Integer.parseInt(st.nextToken());
			int n = Integer.parseInt(st.nextToken());
			
			int arr[] = new int[n];
			int min = Integer.MAX_VALUE;
			int max = 0;
			
			for (int j = 0; j < n; j++) {
				arr[j] = Integer.parseInt(br.readLine());
				if(arr[j]>=l/2) {
					min = Math.min(min, arr[j]);
				}else {
					max = Math.max(max, arr[j]);
				}
			}
			Arrays.sort(arr);
			sb.append(Math.max(l - min, max) + " " + Math.max(l - arr[0], arr[n-1])+"\n");
		}
		System.out.println(sb);
	}
}

※ 내 생각

이 문제는 구현과 수학을 이용해서 푸는 문제입니다.

각 케이스를 분류해서 max 값과 min 값을 분류 합니다.
분류된 값을 통해 원하는 경우를 출력해줍니다.

백준_1913 달팽이(자바) / 구현

미스터로즈 — Fri, 19 Nov 2021 09:57:02 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_1913 {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		int K = Integer.parseInt(br.readLine());
		int[][] arr = new int[N][N];

		int a = N / 2;
		int b = N / 2;
		int l = 1;
		int n = 1;

		while (true) {
			for (int i = 0; i < l; i++) {
				arr[a][b] = n++;
				a--;
			}
			if ((n - 1) == N * N)break;
			for (int i = 0; i < l; i++) {
				arr[a][b] = n++;
				b++;
			}
			l++;
			for (int i = 0; i < l; i++) {
				arr[a][b] = n++;
				a++;
			}
			for (int i = 0; i < l; i++) {
				arr[a][b] = n++;
				b--;
			}
			l++;
		}
		StringBuilder sb = new StringBuilder();

		int x = 0;
		int y = 0;
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				sb.append(arr[i][j] + " ");
				if(K == arr[i][j]) {
					x = i+1;
					y = j+1;
				}
			}
			sb.append("\n");
		}
		sb.append(x+" "+y);
		System.out.println(sb);
	}

}

※ 내 생각

이 문제는 구현을 활용하는 문제입니다.

방향을 바꿔가며 값을 넣어주는 문제입니다.
배열에 값을 넣어주고 마지막에 원하는 위치 및 배열을 출력해줍니다.

백준_3273 두 수의 합(자바) / 투 포인트

미스터로즈 — Thu, 18 Nov 2021 09:27:20 +0900

시간&메모리 제한

문제

입력&출력

문제풀이

package com.Back;

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

public class Back_3273 {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int N = Integer.parseInt(br.readLine());
		StringTokenizer st = new StringTokenizer(br.readLine());
		int[] arr = new int[N];
		for (int i = 0; i < N; i++) {
			arr[i]=Integer.parseInt(st.nextToken());
		}
		Arrays.sort(arr);
		int ans = Integer.parseInt(br.readLine());
		int cnt = 0;
		int start = 0;
		int end = N-1;
		int sum=0;
		while(start<end) {
			sum=arr[start]+arr[end];
			if(sum==ans) {
				cnt++;
				start++;
			}else if(sum<ans) {
				start++;
			}else {
				end--;
			}
			
		}
		System.out.println(cnt);
	}
}

※ 내 생각

이 문제는 정렬, 투 포인터를 활용하는 문제입니다.

먼저 정렬을 해줍니다. 정렬을 진행한 다음에 맨 처음 값과 맨 마지막 값을 더해줍니다.

투 포인트를 이용해서 합과 찾고자 하는 값이 같으면 정답과 시작 값을 더해줍니다.
찾고자 하는 값이 더 크면 처음 값을 더해줍니다.
합이 더 크면 마지막 값을 빼서 합을 줄여줍니다.

백준_14235 크리스마스 선물

미스터로즈 — Wed, 17 Nov 2021 09:16:28 +0900

시간&메모리 제한

문제풀이

입력&출력

문제풀이

package com.Back;

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

public class Back_14235 {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
		
		StringTokenizer st;
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			if(a==0) {
				if(pq.size()==0) {
					sb.append("-1\n");
				}else {
					sb.append(pq.poll()+"\n");
				}
					
			}else {
				for (int j = 0; j < a; j++) {
					pq.add(Integer.parseInt(st.nextToken()));
				}
			}
		}
		System.out.println(sb);
	}
}

※ 내 생각

이 문제는 우선순위 큐를 이용하여 문제를 해결할 수 있습니다.

우선순위 큐의 정렬 조건을 내림차순이 되게 만들어 줍니다.
for문에서 a가 0이면 pq의 사이즈를 확인하고 비어 있으면 -1을 비어 있지 않으면 하나 꺼내 출력을 하면 됩니다.

a가 0이 아니면 a의 갯수 만큼 pq에 추가를 해줍니다.