(Challenge)BFS Special Judge
2ํ์ฐจ ํ์ด ํ๋ฆฐ ์ด์
bfs ์์ ์
๋ ฅ๋ฐ์ ๋ 1์ ๋นผ์ฃผ์ง ์์์ ํ์ ๋ฃ๊ณ ๋บ ๊ฑด(x) 0์ธ๋ฐ, order[0] = 1, x = 0์ผ๋ก ๊ฐ์ง ์๊ธฐ ๋๋ฌธ์ 0์ด๋ผ๋ ์ค๋ต์ ์ถ๋ ฅํ๋ค.(์ฌ์ค์ ์ ๋๋ก ์ ์คํ๋ ๊ฒ์)
ํ๊ฐ ๋น์์ ๋ 0์ ์ถ๋ ฅํ๊ณ ํ๋ก๊ทธ๋จ์ ์ข
๋ฃํด์ผํ๋ค.?
ํ๊ฐ ๋น์์ผ๋ฉด ํ๋ก๊ทธ๋จ์ ์ข
๋ฃํ๋ ๊ฒ๊น์ง ์๊ฒ ๋๋ฐ ์ 0์ ์ถ๋ ฅํ๋?
order์ ์์๊ฐ x์ ์ธ์ ๋
ธ๋์ธ์ง ํ์ธํ๋ ๊ฒ์ ๊ตฌํํ๋ ๊ฒ์ด๋ค!
x์ ์ธ์ ๋
ธ๋๋ฅผ ๋ฐ๋ก ํ์ ๋ฃ๋ ๊ฒ ์๋๋ผ, ์ธ์ ๋
ธ๋๋ค์ parent๋ผ๋ ๋ฐฐ์ด์ ์ ์ฅํ๊ณ , ์ธ์ ๋
ธ๋ ๊ฐฏ์๋ฅผ ์ธ์ค๋ค.
์๋ฅผ ๋ค์ด x=0, x์ ์ธ์ ๋
ธ๋๊ฐ 1,2 2๊ฐ์ผ ๋ parent[0]=1,parent[0]=2๋ ์ ๋์ง๋ง, parent[1]=0,parent[2]=0 ์ ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ x์ ์ธ์ ๋
ธ๋๋ฅผ ์ธ๋ฑ์ค๋ก ํ๋ parent ๋ฐฐ์ด์ ๊ฐ์ผ๋ก x๋ฅผ ๋ฃ์ด์ค๋ค!
์ธ์ ๋
ธ๋ ๊ฐฏ์๋งํผ order ๋ฐฐ์ด ๊ฐ๋ค์ ํ์ ๋ฃ์ด์ค๋ค!
๋จ, ํ์ ๋ฃ์ ๋, parent[order ๋ฐฐ์ด ๊ฐ]์ด x์ธ์ง(x์ ์ธ์ ๋
ธ๋์ธ์ง) ํ์ธํ๊ณ ๋ฃ์ด์ค๋ค! ๋ง์ผ๋ฉด ํ์ ๋ฃ๊ณ , ์๋๋ฉด ์์๊ฐ ํ๋ฆฐ ๊ฒ์ด๋ฏ๋ก 0์ ์ถ๋ ฅํ๊ณ ํ๋ก๊ทธ๋จ ์ข
๋ฃ!
m์ด ์กด์ฌํ๋ ์ด์ , ์๋ฏธ
m์ 1์์ ์์ํ๋ค. ๋จ์ํ ํ์ ํฌ๊ธฐ๋ฅผ ์๋ฏธํ๋ ๊ฒ์ด ์๋๋ผ ํ์ ๋ฃ์ ์, order ๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ ๋๋ค! ์๋ํ๋ฉด order[0]์์ ์์ํ๊ณ , ์ด๊ฒ์ ์ธ์ ๋
ธ๋๋ order[1]๋ถํฐ cnt(์ธ์ ๋
ธ๋ ๊ฐฏ์)๋งํผ์ด๊ธฐ ๋๋ฌธ์ 1(m)๋ถํฐ cnt๋งํผ ํ์ ๋ฃ๊ณ ! m=1-> m+cnt=3 ์ผ๋ก ์
๋ฐ์ดํธํด์ค๋ค! m=3์ ์๋ฏธ๋ ๊ทธ ๋ค์ ์ ์ ์ ์ธ์ ๋
ธ๋ ์ถ๊ฐ๋ order[3]๋ถํฐ cnt๋งํผ ์ถ๊ฐํ๋ค๋ ๊ฒ์ด๋ค!
import java.util.*;
public class BFS_SpecialJudge_2nd {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
ArrayList<Integer>[] a = new ArrayList[n];
int[] parent = new int[n];//n๋งํผ ์์ฑํ๋ ๊ฒ ๋ง๋?
boolean[] c = new boolean[n];
int[] order = new int[n];
for(int i=0;i<n;i++) {
a[i] = new ArrayList<>();
}
for(int i=0;i<n-1;i++) {//๊ฐ์ ์ ๋ณด ์ ์ฅ~
int u = sc.nextInt()-1;
int v = sc.nextInt()-1;
a[u].add(v);a[v].add(u);
}
for(int i=0;i<n;i++) {
order[i] = sc.nextInt()-1;
}
//์ธ์ ๋
ธ๋๋ฅผ ๋๋ฉด์ ์ธ์ ๋
ธ๋ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ parent๋ฐฐ์ด์ ์์ฑํ๊ณ , ํ์ฌ ์ ์ x์ ์ธ์ ๋
ธ๋ ๊ฐฏ์๋ฅผ ์ธ์ค๋ค!
Queue<Integer> q = new LinkedList<Integer>();
q.add(0);c[0] = true;
int m=1;
for(int i=0;i<n;i++) {//i๋ 0๋ถํฐ ์ ์ ๊ฐฏ์๋งํผ ๋ฐ๋ณตํ๋ค. order[0]๋ถํฐ order[n-1]๊น์ง.
//Round1.ํ์์ ๊บผ๋ธ x(0)์ order[0] ๋น๊ต.
//Round2.x(0)์ ์ธ์ ๋
ธ๋๋ฅผ ํ์ ๋ฃ์๊ธฐ ๋๋ฌธ์
// x(0)์ ์ธ์ ๋
ธ๋์ order[1]๊ณผ ๋น๊ต. - x์ ์ธ์ ๋
ธ๋ : 1,2 ์ด๊ณ order:0 1 2 3 ๋๋ 0 2 1 3์ผ ๋
//parent[1] = 0, parent[2] = 0 1,2 ๋๋ค parent ๊ฐ์ด x์ด๋ฏ๋ก(์ธ์ ๋
ธ๋๊ฐ x) ๋ง์กฑ~!
//์ด๋ฌํ n๊ฐ์ ์ ์ ์ ๋ํด order์ ๊ฐ ๊ฐ๊ณผ ๋น๊ต ์ฐ์ฐ์ n๊ฐ ๋งํผ๋ฐ๋ณตํ๊ธฐ ๋๋ฌธ์ for(i=0~n)๋๋ ค์ค๋ค!
if(q.isEmpty()) {//ํ๊ฐ ๋น๋ฉด? bfs ๋ค ๋์๋ค๋ ๋ป.๊ทผ๋ฐ ์ 0์ถ๋ ฅํ๊ณ ์ข
๋ฃํ๋?
System.out.println(0);
System.exit(0);
}
int x = q.remove();
if(x != order[i]) {
System.out.println(0);
System.exit(0);
}
int cnt=0;
for(int y:a[x]) {
if(c[y]==false) {
parent[y] = x;cnt++;//์ธ์ ๋
ธ๋ ๊ฐฏ์ ์ผ๋ค!
}
}
for(int j=0;j<cnt;j++) {
if(m+j>=n || parent[order[m+j]] != x) {
System.out.println(0);
System.exit(0);
}
q.add(order[m+j]);
c[order[m+j]]=true;
}
m+=cnt;
}
System.out.println(1);
}
}