1. LCA(Lowest Common Ancestor) ์๊ณ ๋ฆฌ์ฆ์ด๋?
2. ์ด๋ป๊ฒ ์ฐพ์ ์ ์์๊น?
2.1. Level๊ณผ ๋ถ๋ชจ ๋ ธ๋ ๊ตฌํ๊ธฐ
2.2. LCA ๋ฉ์ธ ๋ก์ง
1. LCA(Lowest Common Ancestor) ์๊ณ ๋ฆฌ์ฆ์ด๋?
๋ ๊ฐ์ ๋ ธ๋์ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ณตํต๋ ๋ถ๋ชจ๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋งํ๋ค.
2. ์ด๋ป๊ฒ ์ฐพ์ ์ ์์๊น?

์์ ํธ๋ฆฌ์์ 9์ 13์ ๊ณตํต ๋ถ๋ชจ๋ ๋์ ๋ฐ๋ก ์์ ์๋ 2์ด๋ค. ๋ฌผ๋ก 9์ 13๊ณผ ๊ฐ์ด ๊ฐ์ Level์ ์๋ ๋ ธ๋์ธ ๊ฒฝ์ฐ์ ๋ ๋ ธ๋์ Level์ ๋์์ ํ๋์ฉ ์ค์ฌ๊ฐ๋ฉฐ ์ฐพ์ ์ ์๊ฒ ์ง๋ง ๋ง์ฝ ์๋ก ๋ค๋ฅธ Level์ ์๋ ๊ฒฝ์ฐ ๋์์ ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋ค ํ๋ค ๊ณตํต ๋ถ๋ชจ๋ฅผ ์ฐพ์ ์ ์๋ค. ๋ฐ๋ผ์ Level์ด ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ ํ๋์ ๋ ธ๋๋ฅผ ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋๋ก ํ์ฌ ๊ฐ์ Level๋ก ๋ง์ถฐ์ค์ผ๋ง ํ๋ค.
์ ๋ฆฌํ์๋ฉด, ๋ ๊น์ Level์ ์๋ ๋ ธ๋์ Level์ ์ค์ฌ ์์ Level์ ์๋ ๋ ธ๋์ ๋์ผํ๊ฒ ๋ง์ถฐ์ค์ผ ํ๋ค.
2.1. Level๊ณผ ๋ถ๋ชจ ๋ ธ๋ ๊ตฌํ๊ธฐ
์ฐ์ ์์ ๋ก์ง์ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋น์ฐํ๊ฒ๋ ๊ฐ ๋ ธ๋์ Level๊ณผ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ๊ตฌํด์ผ๋ง ํ๋ค. BFS๋ฅผ ํ์ฉํ๋ฉด ๋ชจ๋ ๋ ธ๋์ Level๊ณผ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ๊ตฌํ ์ ์๋ค.
Level๊ณผ ๋ถ๋ชจ ๋ ธ๋ ๊ตฌํ๊ธฐ ๋ถ๋ถ์ ์ฝ๋๋ก ์ง์ ๊ตฌํํด๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
private void initialized(int[] tree) {
Queue<Integer> queue = new LinkedList<>();
queue.add(1);
levels[1] = 0;
parents[1] = 0;
while(!queue.isEmpty()) {
int temp = queue.poll();
int leftNode = temp*2;
int rightNode = temp*2+1;
if(leftNode < tree.length) {
queue.add(leftNode);
levels[leftNode] = levels[temp] + 1;
parents[leftNode] = temp;
}
if(rightNode < tree.length) {
queue.add(rightNode);
levels[rightNode] = levels[temp] + 1;
parents[rightNode] = temp;
}
}
}
2.2. LCA ๋ฉ์ธ ๋ก์ง
์ด์ ํ์ํ ๋ฐ์ดํฐ๋ค์ ๋ชจ๋ ๊ตฌํ์ผ๋, ๋ฉ์ธ ๋ก์ง ๊ตฌํ๋ง ๋จ์๋ค.
์ฐ๋ฆฌ๋ ์์์ ํ์ธํ๋ค์ํผ ๊ฐ์ Level์ ์๋ ๋ ธ๋๋ค์ LCA๋ฅผ ๊ตฌํ๋ ๊ฒ์ด ํจ์ฌ ์ฝ๋ค๋ ๊ฒ์ ์๊ณ ์๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฅ ๋จผ์ ๋ ์ค ๊น์ Level์ ์์นํ ๋ ธ๋๋ฅผ ๊ณจ๋ผ ์์ Level์ ๋ ธ๋์ ๋์ผํ Level๋ก ์ฎ๊ฒจ์ค์ผ ํ๋ค. ์ฆ, Level์ด ๊ฐ์์ง ๋ ๊น์ง ๊น์ Level์ ์์นํ ๋ ธ๋๋ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ํตํด ์๋ก ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ์ผ ํ๋ค.
์ฝ๋๋ก ์ง์ ๊ตฌํํด๋ณด์.
private int lca(int a, int b) {
int aDepth = levels[a];
int bDepth = levels[b];
while(aDepth > bDepth) {
a = parents[a];
aDepth--;
}
while(aDepth < bDepth) {
b = parents[b];
bDepth--;
}
while(a!=b) {
a = parents[a];
b = parents[b];
aDepth--;
bDepth--;
}
return a;
}