728x90

문제

 

 

접근 방식

우선순위 큐를 활용해서 풀 수 있는 문제로 우선순위 큐를 덱처럼 사용하면 된다.

 

원할 때마다 언제든지 가장 작은 값을 빼거나 가장 큰 값을 뺄 수 있어야 하기 때문에

최소힙과 최대힙에 동일하게 수를 추가해 준 후에

가장 큰 값을 빼야 하는 경우에는 최대힙에서 반대의 경우는 최소힙에서 빼주면 된다.

 

이때 조심해야할게 반대쪽에서 뺀 수는 반대쪽에만 사라지고 다른 한쪽에는 존재하기 때문에

맵을 이용해서 수마다 등장 횟수를 카운팅 해준 후에 수들을 큐에서 꺼낼 때마다

꺼낸 수가 등장 횟수가 남아있는지 확인하여 다른 쪽의 큐와 상태를 유지해 줄 수 있다.

 

예를 들면 최대값을 하나 빼려고 최대힙에서 9라는 숫자를 꺼냈는데

해당 숫자의 카운트가 0이라면 최소힙에서 빼서 사라진 값이기에

해당 수를 건너 뛰고 최대힙에서 카운트가 0이 아닌 수를 찾을 때까지

계속해서 수를 꺼내주면 된다.

 

풀이

public class Main {

	private static HashMap<Integer, Integer> countMap;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		StringBuilder sb = new StringBuilder();

		int t = Integer.parseInt(br.readLine());

		while (t-- > 0) {
			int k = Integer.parseInt(br.readLine());

			PriorityQueue<Integer> minQ  = new PriorityQueue<>();
			PriorityQueue<Integer> maxQ  = new PriorityQueue<>(Collections.reverseOrder());
			countMap = new HashMap<>();

			while (k-- > 0) {
				st = new StringTokenizer(br.readLine());

				String command = st.nextToken();
				int n = Integer.parseInt(st.nextToken());

				if (command.equals("I")) {
					minQ.offer(n);
					maxQ.offer(n);
					countMap.put(n, countMap.getOrDefault(n, 0) + 1);
					continue;
				}

				if (countMap.isEmpty()) continue;

				poll(n > 0 ? maxQ : minQ);
			}

			if (countMap.isEmpty()) sb.append("EMPTY").append("\n");
			else {
				int max = poll(maxQ);
				sb.append(max).append(" ").append(countMap.isEmpty() ? max : poll(minQ)).append("\n");
			}
		}

		System.out.println(sb);
	}

	private static int poll(PriorityQueue<Integer> pq) {
		int num = 0;

		while (true) {
			num = pq.poll();
			int count = countMap.getOrDefault(num, 0);

			if (count == 0) continue;

			if (count == 1) countMap.remove(num);
			else countMap.put(num, count - 1);

			break;
		}

		return num;
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 1260번 : DFS와 BFS  (1) 2024.01.24
[백준] 11724번 : 연결 요소의 개수  (0) 2024.01.24
[백준] 1781번 : 컵라면  (1) 2024.01.22
[백준] 1655번 : 가운데를 말해요  (1) 2024.01.22
[백준] 1715번 : 카드 정렬하기  (1) 2024.01.22
728x90

문제

 

 

접근 방식

정말 쉬운데 하고 풀었다가 바로 틀려버린 문제다...

 

데드라인이 빠른 순으로 정렬하고 같다면 보상이 큰 순으로 정렬한 후에

그대로 반복문을 돌면서 더해줬더니 예제는 맞지만 제출하니 틀렸다.

 

예제가 하나뿐이라 생각하지 못한 케이스가 있었는데

데드라인이 나중이라도 이전 데드라인 문제를 생략하고

이후의 데드라인 문제를 푸는 것이 좋을 때가 있다.

2 30
2 20
3 60
3 50

 

위와 같이 데드라인이 2일 때 2개를 선택하는 것보단

둘 다 선택하지 않고 데드라인이 3일 때를 선택하는 것이 더 효율적이다.

 

그래서 정렬은 그대로 유지하되 최소힙을 사용해 이전에 선택한 값이

이후에 선택할 값보다 비효율적인 경우 교체해줘야 한다.

2 30
2 20
최소힙 {20, 30}

3 60
최소힙 {30, 60}

3 50
최소힙 {50, 60}

 

예를 들어, 위와 같이 데드라인이 2인 경우를 모두 최소힙에 넣어둔 후에

데드라인이 3이고 보상이 60일 때는 최소힙에 있는 20과 60을 교체해주면 될 것이고

다음 경우인 데드라인이 3이고 보상이 50인 경우도 30과 50을 교체해주면 된다.

 

 

풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;

		int n = Integer.parseInt(br.readLine());
		long max = 0;

		PriorityQueue<Exam> sorted = new PriorityQueue<>(
			(o1, o2) -> o1.d != o2.d ? o1.d - o2.d : -(o1.c - o2.c)
		);

		PriorityQueue<Integer> cup = new PriorityQueue<>();

		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());

			sorted.offer(new Exam(st.nextToken(), st.nextToken()));
		}

		while (!sorted.isEmpty()){
			Exam exam = sorted.poll();

			int size = cup.size();

			if (size < exam.d) {
				cup.offer(exam.c);
				max += exam.c;
			}
			else if (size == exam.d && cup.peek() < exam.c) {
				int prev = cup.poll();
				cup.offer(exam.c);
				max += (exam.c - prev);
			}
		}

		System.out.println(max);
	}

	private static class Exam {
		int d;
		int c;

		public Exam(String d, String c) {
			this.d = Integer.parseInt(d);
			this.c = Integer.parseInt(c);
		}
	}
}

 

728x90

문제

 

 

접근 방식

수가 하나씩 추가될 때마다 현재까지의 수 중에서 중간값을 출력해야 하고

현재까지 부른 수가 짝수 개면 중간값은 둘 중 더 작은 수를 출력한다.

 

무식하게 생각하면 매번 수를 부를 때마다 정렬해서 중간 인덱스를 출력하는

방법을 떠올릴 수 있지만 문제의 제한 시간과 입력을 생각하면 불가능하다.

 

최소힙과 최대힙 우선순위 큐를 각각 하나씩 만들어서 특정 상황에 맞게

수를 저장하고 꺼내는 방식으로 효율적으로 풀 수 있는 문제다.

 

예를 들어 현재까지 주어진 수가 짝수 개일 때를 생각해 보면

현재 수가 이전까지의 중간값보다 작은 경우를 살펴보면 다음과 같다.

4 5 10 (11) 12 15 20	// 중간값 11
>> 6 이 입력으로 들어옴
4 5 6 (10 11) 12 15 20 // 중간값이 두개지만 더 작은 10을 선택

 

짝수일 때는 중간 값이 두 개가 될 수 있고 이 중에서 가장 작은 첫 번째 값을

골라야 하기 때문에 이 때는 최대힙에서 값을 꺼내 중간값으로 바꿔주고

이전의 중앙값을 최소힙에 다시 넣어준다.

최대힙 6 5 4
중간값 10
최소힙 11 12 15 20

 

위와 같이 최대힙, 중간값, 최소힙이 구성된다.

 

즉, 최대힙에서는 중간값보다 작은 값들을, 최소힙에서는 중간값보다 큰 값들을

정렬된 상태로 꺼낼 수 있으니 입력받은 수가 중간값보다 큰지 작은지에 따라

상황에 맞게 수를 꺼내고 저장하면 매번 정렬을 하지 않고 중간값을 알 수 있다.

 

풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();

		int n = Integer.parseInt(br.readLine());
		PriorityQueue<Integer> right = new PriorityQueue<>();
		PriorityQueue<Integer> left = new PriorityQueue<>(Collections.reverseOrder());

		int center = Integer.parseInt(br.readLine());
		sb.append(center).append("\n");

		for (int i = 2; i <= n; i++) {
			int x = Integer.parseInt(br.readLine());

			if (i % 2 == 0) {
				if (center > x) {
					left.offer(x);
					right.offer(center);
					center = left.poll();
				} else {
					right.offer(x);
				}
			} else {
				if (center <= x) {
					right.offer(x);
					left.offer(center);
					center = right.poll();
				} else {
					left.offer(x);
				}
			}

			sb.append(center).append("\n");
		}

		System.out.println(sb);
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 7662번 : 이중 우선순위 큐  (0) 2024.01.24
[백준] 1781번 : 컵라면  (1) 2024.01.22
[백준] 1715번 : 카드 정렬하기  (1) 2024.01.22
[백준] 2075번 : N번째 큰 수  (0) 2024.01.22
[백준] 1927번 : 최소 힙  (0) 2024.01.22
728x90

문제

 

 

접근 방식

맨 처음에 문제를 풀 때는 잘못 이해해서 정렬을 사용해서 풀 수도 있을 줄 알았는데

문제를 제대로 이해하고 보니 중간중간 계산 결과를 다시 넣을 때마다

정렬을 한다면 매우 비효율적이기 때문에 우선순위 큐를 사용해서 풀었다.

10 // 10개의 수가 주어졌을 때
123
456
234
998
12
7
876
887
455
234

 

만약 위와 같은 입력이 주어졌을 때 계산 순서는 다음과 같다.

7 + 12 = 19
19 + 123 = 142
142 + 234 = 376
376 + 234 = 610
610 + 455 = 1065
1065 + 456 = 1521
1521 + 876 = 2397
2397 + 887 = 3284
3284 + 998 = 4282

 

위 순서대로 계산하여 결과를 모두 더하면 13696이라는 답이 나오는데

이는 잘못된 풀이다.

7 + 12 = 19
19 + 123 = 142
142 + 234 = 376
234 + 376 = 610
455 + 456 = 911
610 + 876 = 1486
887 + 911 = 1798
998 + 1486 = 2484
1798 + 2484 = 4282

 

위와 같이 계산해서 결과를 모두 더했을 때 12108이라는 답이 나와야 정답이다.

 

처음 입력 받은 것을 정렬된 상태로 그대로 더하기만 해서 되는 문제가 아니라

두 카드 묶음을 더할 때마다 생기는 하나의 카드 묶음을 포함해서

다시 정렬된 상태로 계산해야 하기 때문이다.

 

이런 문제 때문에 처음 언급했던 것처럼 매번 정렬을 할 수도 없기 때문에

우선순위 큐를 사용해서 풀면 효율적인 것이다.

 

최소 힙의 규칙을 통해 항상 오름차순으로 우선순위 큐에서 값을 넣고 꺼낼 수 있기 때문에

두 카드 묶음을 합치고 합친 값을 다시 큐에 넣고 이를 반복하기만 하면

매번 정렬을 할 필요 없이 효율적으로 계산할 수 있다.

 

 

풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());
		int sum = 0;
		int min = 0;

		PriorityQueue<Integer> pq = new PriorityQueue<>();

		for (int i = 0; i < n; i++) pq.offer(Integer.parseInt(br.readLine()));

		while (!pq.isEmpty()) {
			if (sum == 0) sum = pq.poll();
			else {
				sum += pq.poll();
				pq.offer(sum);
				min += sum;
				sum = 0;
			}
		}

		System.out.println(min);
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 1781번 : 컵라면  (1) 2024.01.22
[백준] 1655번 : 가운데를 말해요  (1) 2024.01.22
[백준] 2075번 : N번째 큰 수  (0) 2024.01.22
[백준] 1927번 : 최소 힙  (0) 2024.01.22
[백준] 11286번 : 절댓값 힙  (1) 2024.01.21
728x90

문제

 

 

접근 방식

배열에 수를 모두 저장한 후에 정렬하고 끝에서 n번째 인덱스를 출력해도 풀리는 문제지만

우선순위 큐를 이용해서 좀 더 효율적으로 풀 수 있다.

 

최소 힙으로도 풀 수 있지만 최대 힙으로 푸는 것이 더 효율적이니

자바에서 제공하는 우선순위 큐 기준으로는 생성자 파라미터로 정렬 기준을

역순으로 주어 최대 힙을 사용할 수 있다.

 

최대 힙에 입력 받은 수들을 모두 넣어준 후에

n개를 꺼내면 n번째 큰 수가 나오게 된다.

 

풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;

		int n = Integer.parseInt(br.readLine());
		int nNum = 0;

		PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());

			for (int j = 0; j < n; j++) {
				pq.offer(Integer.parseInt(st.nextToken()));
			}
		}

		while (n-- > 0) {
			nNum = pq.poll();
		}

		System.out.println(nNum);
	}
}

 

728x90

문제

 

 

접근 방식

최소 힙을 구현하는 문제다.

C++의 STL이나 자바의 유틸 클래스에 이미 구현된 우선순위 큐를

사용해서 편하게 풀 수도 있지만 구현해봐야 어떤 원리로

동작하는지를 이해하기 쉽기 때문에 직접 구현해봤다.

 

최소 힙은 부모가 자식보다 작은 값을 가지고 있는 이진 트리 구조여야 하기 때문에

새로운 값을 추가할 때는 가장 마지막 자식 노드에 값을 추가한 후에

해당 노드가 부모 노드보다 큰지 검사하면서 만약 더 작다면 부모 노드와 바꿔주면 된다.

 

반대로 가장 작은 값을 하나 꺼낼 때는 최소 힙의 구조상 무조건 최상위 부모 노드가

가장 작은 값에 해당하기 때문에 해당 값을 출력하고 삭제해주면 된다.

 

풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();

		int n = Integer.parseInt(br.readLine());

		MinHeap minHeap = new MinHeap();

		while (n-- > 0) {
			int x = Integer.parseInt(br.readLine());

			if (x != 0) minHeap.offer(x);
			else sb.append(minHeap.poll()).append("\n");
		}

		System.out.println(sb);
	}

	private static class MinHeap {
		int[] heap = new int[100001];
		int size = 0;

		void offer(int x) {
			heap[++size] = x;
			int idx = size;

			while (idx != 1) {
				int cur = idx/2;

				if (heap[idx] > heap[cur]) break;

				swap(idx, cur);

				idx = cur;
			}
		}

		int poll() {
			if (size == 0) return 0;

			int r = heap[1];
			heap[1] = heap[size--];
			int idx = 1;

			while (idx * 2 <= size) {
				int left = idx * 2;
				int right = left + 1;
				int min = left;

				if (right <= size && heap[right] < heap[left]) min = right;
				if (heap[min] >= heap[idx]) break;

				swap(min, idx);

				idx = min;
			}

			return r;
		}

		void swap(int x, int y) {
			int tmp = heap[x];
			heap[x] = heap[y];
			heap[y] = tmp;
		}
	}
}

 

728x90

문제

 

 

접근 방식

우선순위큐 최소힙을 사용해서 풀 수 있는 문제로

직접 구현해서 풀 수도 있지만 자바에서 제공하는 우선순위 큐를 사용하여 풀었다.

 

두 가지 방식으로 풀어봤는데 첫 번째는 우선순위 큐의 생성자에

파라미터로 정렬 기준을 제공해 문제에서 요구하는 순서대로 정렬되게 하는 방법이고

 

두 번째 방법은 우선순위 큐에 모두 절댓값으로 변환해 양수인 값만 저장하면서

맵에 음수인 경우만 카운팅 하는 방법이다.

 

우선 첫 번째 방법부터 살펴보면

정렬기준을 절댓값이 같다면 더 작은 값이 먼저 나와야 하니

abs(x) == abs(y) 라면 x - y를 리턴해주고

두 수의 절댓값이 다르다면 절댓값이 더 작은 수가 앞에 오면 되니

abs(x) - abs(y)를 리턴해주면 된다.

 

두 번째 방법은 자바에서 우선순위 큐의 기본 원리가 최소힙이 적용된 상태니

입력받은 수를 모두 양수로 바꾸어서 큐에 저장한다.

 

이때 입력 받은 수가 음수라면 따로 만들어둔 맵에 해당 절댓값을 키로 가진

값을 1씩 증가시키고 입력으로 0이 들어올 때마다

음수가 카운팅 된 게 남아있으면 음수로 바꾸어 출력해 주고 카운트를 1씩 줄여주면 되고

카운팅이 남아있지 않다면 양수를 출력해 주면 된다.

 

풀이

첫 번째 풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();

		int n = Integer.parseInt(br.readLine());

		PriorityQueue<Integer> pq = new PriorityQueue<>((a, b)->
			Math.abs(a) == Math.abs(b) ? (a - b) : (Math.abs(a) - Math.abs(b)));

		for (int i = 0; i < n; i++) {
			int x = Integer.parseInt(br.readLine());

			if (x != 0) {
				pq.offer(x);
			} else {
				sb.append(pq.isEmpty() ? 0 : pq.poll()).append("\n");
			}
		}

		System.out.println(sb);
	}
}

 

두 번째 풀이

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();

		int n = Integer.parseInt(br.readLine());

		PriorityQueue<Integer> pq = new PriorityQueue<>(n);
		Map<Integer, Integer> countMap = new HashMap<>();

		for (int i = 0; i < n; i++) {
			int x = Integer.parseInt(br.readLine());

			if (x != 0) {
				int abs = Math.abs(x);
				int count = countMap.getOrDefault(abs, 0);

				if (x < 0) count++;

				countMap.put(abs, count);

				pq.offer(abs);
			} else {
				if (pq.isEmpty()) sb.append(0).append("\n");
				else {
					int num = pq.poll();
					int count = countMap.get(num);

					if (count != 0) {
						sb.append(-num).append("\n");
						countMap.put(num, count - 1);
					} else {
						sb.append(num).append("\n");
					}
				}
			}
		}

		System.out.println(sb);
	}
}

'Java > Algorithms' 카테고리의 다른 글

[백준] 2075번 : N번째 큰 수  (0) 2024.01.22
[백준] 1927번 : 최소 힙  (0) 2024.01.22
[백준] 18808번 : 스티커 붙이기  (0) 2024.01.19
[백준] 1700번 : 멀티탭 스케줄링  (0) 2024.01.17
[백준] 1744번 : 수 묶기  (0) 2024.01.11
728x90

문제

 

접근 방식

문제의 포인트는 배열을 돌리는 것인데 직접 원소들을 움직일 수도 있지만

90도씩 회전할 때마다 배열의 요소들이 어떻게 움직이는지만 안다면

배열을 움직이지 않고도 풀 수 있다.

 

 

만약 위와 같은 n행 m열의 스티커 배열이 주어졌다고 가정했을 때

배열을 90도씩 회전시켜 보겠다.

 

 

우선 오른쪽으로 90도 회전시켰을 때를 살펴보면

행과 열이 뒤집히고 뒤집히기 전의 n행부터 1번째행까지의 첫 열의 값들이

첫 행에 위치하고 있고 그 아래줄부터는 다시 n행부터 1번째행까지의 두 번째 열의 값들이

위치하고 있는 것을 알 수 있다.

 

 

인덱스를 정리하면 위와 같다.

 

 

한 번 더 90도를 회전하면 위와 같고

다시 행과 열이 뒤집혀 원본 상태에서 인덱스만 뒤집히기 때문에

원본 배열을 거꾸로 읽어주면 된다.

 

 

인덱스는 위와 같다.

 

 

마지막으로 90도 회전시키면 위와 같이

다시 행과 열이 뒤집히고 처음 90도 회전시킨 상태의

반대로 배열을 읽어주면 된다.

 

 

인덱스는 위와 같다.

 

실제로 배열의 원소들을 움직일 수도 있지만 배열이 돌아갈 때마다

원소들이 어떻게 움직이는지를 알아둔다면 나중에 비슷한 문제를 풀 때

도움이 될 거 같기에 한 번 규칙을 찾아서 풀어봤다.

 

풀고 나서 비트 연산을 통한 풀이도 봤는데 아직 이런 방법으로는 풀이를 못 떠올리겠다...

 

시뮬레이션 문제들은 기능이나 중복된 코드들을 메서드로 분리하여

간결하고 가독성 있게 풀 수도 있지만 막상 풀고 나서 코드를 정리하려니 귀찮아서

풀 때부터 메서드로 분리하려고 노력해야겠다.

풀이

public class Main {

	private static int n;
	private static int m;
	private static int r;
	private static int c;
	private static int[][] sticker;
	private static int[][] notebook;

	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());
		int k = Integer.parseInt(st.nextToken());
		int result = 0;

		notebook = new int[n][m];

		for (int i = 0; i < k; i++) {
			st = new StringTokenizer(br.readLine());

			r = Integer.parseInt(st.nextToken());
			c = Integer.parseInt(st.nextToken());

			sticker = new int[r][c];

			int plus = 0;

			for (int j = 0; j < r; j++) {
				st = new StringTokenizer(br.readLine());

				for (int l = 0; l < c; l++) {
					int num = Integer.parseInt(st.nextToken());
					sticker[j][l] = num;
					if (num == 1) plus++;
				}
			}

			if (stick()) result += plus;
		}

		System.out.println(result);
	}

	private static boolean stick() {
		for (int rota = 0; rota < 4; rota++) {
			if (rota % 2 == 0) {
				for (int i = 0; i <= n - r; i++) {
					for (int j = 0; j <= m - c; j++) {
						if (rotation(rota, i, j)) return true;
					}
				}
			} else {
				for (int i = 0; i <= n - c; i++) {
					for (int j = 0; j <= m - r; j++) {
						if (rotation(rota, i, j)) return true;
					}
				}
			}
		}
		return false;
	}

	private static boolean rotation(int rota, int st, int ed) {
		int a = 0;
		if (rota == 0) {
			for (int i = 0; i < r; i++) {
				int b = 0;
				for (int j = 0; j < c; j++) {
					if (sticker[i][j] == 1 && notebook[st + a][ed + b] == 1) return false;
					b++;
				}
				a++;
			}
			paste(rota, st, ed);
		} else if (rota == 1) {
			for (int i = 0; i < c; i++) {
				int b = 0;
				for (int j = r - 1; j >= 0; j--) {
					if (sticker[j][i] == 1 && notebook[st + a][ed + b] == 1) return false;
					b++;
				}
				a++;
			}
			paste(rota, st, ed);
		} else if (rota == 2) {
			for (int i = r - 1; i >= 0; i--) {
				int b = 0;
				for (int j = c - 1; j >= 0; j--) {
					if (sticker[i][j] == 1 && notebook[st + a][ed + b] == 1) return false;
					b++;
				}
				a++;
			}
			paste(rota, st, ed);
		} else {
			for (int i = c - 1; i >= 0; i--) {
				int b = 0;
				for (int j = 0; j < r; j++) {
					if (sticker[j][i] == 1 && notebook[st + a][ed + b] == 1) return false;
					b++;
				}
				a++;
			}
			paste(rota, st, ed);
		}

		return true;
	}

	private static void paste(int rota, int st, int ed) {
		if (rota == 0) {
			for (int i = 0; i < r; i++) {
				int b = 0;
				for (int j = 0; j < c; j++) {
					if (sticker[i][j] == 1) notebook[st][ed + b] = 1;
					b++;
				}
				st++;
			}
		} else if (rota == 1) {
			for (int i = 0; i < c; i++) {
				int b = 0;
				for (int j = r - 1; j >= 0; j--) {
					if (sticker[j][i] == 1) notebook[st][ed + b] = 1;
					b++;
				}
				st++;
			}
		} else if (rota == 2) {
			for (int i = r - 1; i >= 0; i--) {
				int b = 0;
				for (int j = c - 1; j >= 0; j--) {
					if (sticker[i][j] == 1) notebook[st][ed + b] = 1;
					b++;
				}
				st++;
			}
		} else {
			for (int i = c - 1; i >= 0; i--) {
				int b = 0;
				for (int j = 0; j < r; j++) {
					if (sticker[j][i] == 1) notebook[st][ed + b] = 1;
					b++;
				}
				st++;
			}
		}
	}
}

 

'Java > Algorithms' 카테고리의 다른 글

[백준] 1927번 : 최소 힙  (0) 2024.01.22
[백준] 11286번 : 절댓값 힙  (1) 2024.01.21
[백준] 1700번 : 멀티탭 스케줄링  (0) 2024.01.17
[백준] 1744번 : 수 묶기  (0) 2024.01.11
[백준] 2170번 : 선 긋기  (1) 2024.01.11

+ Recent posts