๋ฐฑ์ค 2668 ์ซ์๊ณ ๋ฅด๊ธฐ[JAVA]
- -
๐๋งํฌ
2668 ์ซ์๊ณ ๋ฅด๊ธฐ Gold5
โ ๏ธ๋ฌธ์
์ธ๋ก ๋ ์ค, ๊ฐ๋ก๋ก N๊ฐ์ ์นธ์ผ๋ก ์ด๋ฃจ์ด์ง ํ๊ฐ ์๋ค. ์ฒซ์งธ ์ค์ ๊ฐ ์นธ์๋ ์ ์ 1, 2, …, N์ด ์ฐจ๋ก๋๋ก ๋ค์ด ์๊ณ ๋์งธ ์ค์ ๊ฐ ์นธ์๋ 1์ด์ N์ดํ์ธ ์ ์๊ฐ ๋ค์ด ์๋ค. ์ฒซ์งธ ์ค์์ ์ซ์๋ฅผ ์ ์ ํ ๋ฝ์ผ๋ฉด, ๊ทธ ๋ฝํ ์ ์๋ค์ด ์ด๋ฃจ๋ ์งํฉ๊ณผ, ๋ฝํ ์ ์๋ค์ ๋ฐ๋ก ๋ฐ์ ๋์งธ ์ค์ ๋ค์ด์๋ ์ ์๋ค์ด ์ด๋ฃจ๋ ์งํฉ์ด ์ผ์นํ๋ค. ์ด๋ฌํ ์กฐ๊ฑด์ ๋ง์กฑ์ํค๋๋ก ์ ์๋ค์ ๋ฝ๋, ์ต๋๋ก ๋ง์ด ๋ฝ๋ ๋ฐฉ๋ฒ์ ์ฐพ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์๋ฅผ ๋ค์ด, N=7์ธ ๊ฒฝ์ฐ ์๋์ ๊ฐ์ด ํ๊ฐ ์ฃผ์ด์ก๋ค๊ณ ํ์.

์ด ๊ฒฝ์ฐ์๋ ์ฒซ์งธ ์ค์์ 1, 3, 5๋ฅผ ๋ฝ๋ ๊ฒ์ด ๋ต์ด๋ค. ์ฒซ์งธ ์ค์ 1, 3, 5๋ฐ์๋ ๊ฐ๊ฐ 3, 1, 5๊ฐ ์์ผ๋ฉฐ ๋ ์งํฉ์ ์ผ์นํ๋ค. ์ด๋ ์งํฉ์ ํฌ๊ธฐ๋ 3์ด๋ค. ๋ง์ฝ ์ฒซ์งธ ์ค์์ 1๊ณผ 3์ ๋ฝ์ผ๋ฉด, ์ด๋ค ๋ฐ๋ก ๋ฐ์๋ ์ ์ 3๊ณผ 1์ด ์์ผ๋ฏ๋ก ๋ ์งํฉ์ด ์ผ์นํ๋ค. ๊ทธ๋ฌ๋, ์ด ๊ฒฝ์ฐ์ ๋ฝํ ์ ์์ ๊ฐ์๋ ์ต๋๊ฐ ์๋๋ฏ๋ก ๋ต์ด ๋ ์ ์๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ N(1≤N≤100)์ ๋ํ๋ด๋ ์ ์ ํ๋๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ ์ค๋ถํฐ๋ ํ์ ๋์งธ ์ค์ ๋ค์ด๊ฐ๋ ์ ์๋ค์ด ์์๋๋ก ํ ์ค์ ํ๋์ฉ ์ ๋ ฅ๋๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฝํ ์ ์๋ค์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๊ณ , ๊ทธ ๋ค์ ์ค๋ถํฐ๋ ๋ฝํ ์ ์๋ค์ ์์ ์๋ถํฐ ํฐ ์์ ์์๋ก ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค.
๐๋ถ์
๊ฐ ๋ฐฐ์ด์ ์ซ์๋ค์ด ์ฌ์ดํด์ ์ด๋ฃจ๋์ง ํ์ธํ๋ ๋ฌธ์ ์ด๋ค. ์์ ์์ ๋ก ๋ฐ์ ธ๋ณด๋ฉด 1-3 3-1๋ก ์ฐ๊ฒฐ๋์ด ์๋๋ฐ ์ธ๋ฑ์ค์ ๋ฐธ๋ฅ์ ์งํฉ์ด ๋์ผํ๋ ค๋ฉด ์ฌ์ดํด์ด ์กด์ฌํ ๋๊น์ง ๊ณ์ ๋ฐธ๋ฅ(3) -> ์ธ๋ฑ์ค ๊ฒ์(1), ๊ฒ์๋ ๋ฐธ๋ฅ(3) -> ์ธ๋ฑ์ค ๊ฒ์(1) ๋ฐ๋ณตํ๋ค ๋ณด๋ฉด ์ฌ์ดํด์ด ์๊ธด๋ค. ํด๋น ์ฌ์ดํด์ ์ถ์ถํด๋ด๋ ๊ฒ์ด ์ฃผ์ ํฌ์ธํธ์๋ค.
1. ๋ณ์ ์ ์ธ์ ์๋ ์ฝ๋์ ๊ฐ์ด ํ์๋ค. N์ ๊ฐ, ๋ฐฐ์ด์ ์ ์ฅํ arr๋ฐฐ์ด, ๋ฐฉ๋ฌธํ๋์ง๋ฅผ ํ์ํ visited๋ฐฐ์ด, ์ฌ์ดํด์ด ์กด์ฌํ ๊ฒฝ์ฐ ํด๋น์ซ์๊ฐ ์ฌ์ดํด์ ํฌํจ๋์๋์ง ํ์ธํ cycle๋ฐฐ์ด, ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ ๋ ์ธ result ํ๋ฅผ ์์ฑํ๋ค.
static int N;
static int[] arr;
static boolean[] visited;
static boolean[] cycle;
static Queue<Integer> result = new LinkedList();
2.N์ ๊ฐ๊ณผ ๋ฐฐ์ด๋ค์ ์ด๊ธฐํํด์ฃผ๊ณ arr๋ฐฐ์ด์ ์ ๋ ฅ๋ฐ๋๋ค.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine());
arr = new int[N + 1];
visited = new boolean[N + 1];
cycle = new boolean[N + 1];
for (int i = 1; i <= N; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
3.์ฌ์ดํด์ ์ฒดํฌํ ํ๋ฅผ ์์ฑํ๋ค. ์ฌ์ดํด์ด ์กด์ฌํ๊ฑฐ๋, ์ด๋ฏธ ๋ฐฉ๋ฌธํ๋ ์ซ์์ผ ๊ฒฝ์ฐ ๋๊น์ง, ์ธ๋ฑ์ค-๋ฐฐ์ด[๋ฐธ๋ฅ1]-๋ฐฐ์ด[๋ฐธ๋ฅ2] ์ ํ์์ผ๋ก ๊ณ์ ๊ฒ์ํ๊ณ ํ์ ์ถ๊ฐํด์ค๋ค. ์ฌ์ดํด์ด ์๊ฒผ๋๋ผ๋ ํ์๋ ์ ์ฒด ์ซ์๋ค์ด ์ฌ์ดํด์ ํฌํจ๋๋ ๊ฒ์ ์๋๋ค. ์ฌ์ดํด์ด ์์๋ ๋ฒํธ๊น์ง ํ์์ ์๋ฅด๊ณ ์ฌ์ดํด์ด ์์๋ ๋ฒํธ๋ถํฐ ๊ฒฐ๊ณผ ์ฌ์ดํด ๋ฐฐ์ด์ ํฌํจ์์ผ์ค๋ค.
for (int i = 1; i <= N; i++) {
if(!visited[i]) {
Queue<Integer> q = new LinkedList<>();
q.add(i);
int number = arr[i];
while(!visited[number]) {
q.add(number);
visited[number] = true;
number = arr[number];
}
if (q.contains(number)) {
while(q.peek() != number) {
q.poll();
}
while (!q.isEmpty()) {
cycle[q.poll()] = true;
}
}
}
}
โ์ ์ฒด ์ฝ๋
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
class Main {
static int N;
static int[] arr;
static boolean[] visited;
static boolean[] cycle;
static Queue<Integer> result = new LinkedList();
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine());
arr = new int[N + 1];
visited = new boolean[N + 1];
cycle = new boolean[N + 1];
for (int i = 1; i <= N; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
for (int i = 1; i <= N; i++) {
if(!visited[i]) {
Queue<Integer> q = new LinkedList<>();
q.add(i);
int number = arr[i];
while(!visited[number]) {
q.add(number);
visited[number] = true;
number = arr[number];
}
if (q.contains(number)) {
while(q.peek() != number) {
q.poll();
}
while (!q.isEmpty()) {
cycle[q.poll()] = true;
}
}
}
}
for (int i = 1; i <= N; i++) {
if(cycle[i]){
result.offer(i);
}
}
System.out.println(result.size());
while (!result.isEmpty()) {
System.out.println(result.poll());
}
}
}
๐๊ฒฐ๊ณผ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑ์ค 1106 ํธํ [JAVA] (0) | 2023.08.02 |
---|---|
๋ฐฑ์ค 1765 ๋ญ์ธ์ ํ ์ ํ๊ธฐ[JAVA] (0) | 2023.08.02 |
๋ฐฑ์ค 1068 ํธ๋ฆฌ[JAVA] (0) | 2023.07.30 |
๋ฐฑ์ค 18430 ๋ฌด๊ธฐ๊ณตํ[JAVA] (0) | 2023.07.29 |
์์คํ ๊ณต๊ฐ ๊ฐ์ฌํฉ๋๋ค