우리는 n-ary 트리에서 LCA를 계산하기 위해 다양한 시간 복잡도를 갖는 다양한 방법을 살펴보았습니다.
방법 1: 순진한 방법(루트-노드 경로 계산) | 쿼리당 O(n)
방법 2: Sqrt 분해 사용 | O(제곱 H)
방법 3: 희소 행렬 DP 접근 방식 사용 | 오(로그인)
위의 모든 방법보다 쿼리 시간이 더 빠른 또 다른 방법을 연구해 보겠습니다. 따라서 우리의 목표는 LCA를 계산하는 것입니다. 일정한 시간 ~ O(1) . 우리가 그것을 어떻게 달성할 수 있는지 봅시다.
방법 4 : 범위 최소 쿼리 사용
우리는 논의했습니다 이진 트리를 위한 LCA 및 RMQ . 여기에서는 n-ary 트리에 대한 LCA 문제를 RMQ 문제 변환으로 논의합니다.
Pre-requisites:- LCA in Binary Tree using RMQ RMQ using sparse table
주요 개념 : 이 방법에서는 LCA 문제를 정적 배열에 대한 RMQ(Range 최소 쿼리) 문제로 줄입니다. 그런 다음 Range 최소 쿼리를 필수 LCA 쿼리와 연결합니다.
첫 번째 단계는 트리를 평면 선형 배열로 분해하는 것입니다. 이를 위해 오일러 워크(Euler Walk)를 적용할 수 있습니다. 오일러 워크는 그래프의 선주문 순회를 제공합니다. 따라서 우리는 트리에서 오일러 워크(Euler Walk)를 수행하고 방문할 때 노드를 배열에 저장합니다. 이 과정을 통해 트리가 감소합니다 > 
이제 일반적인 용어로 생각해 보겠습니다. 트리의 두 노드를 생각해 보세요. 두 노드를 모두 연결하는 경로는 정확히 하나이며 경로에서 가장 작은 깊이 값을 갖는 노드는 지정된 두 노드의 LCA가 됩니다.
이제 두 개의 서로 다른 노드를 선택하세요. ~에 그리고 다섯 오일러 워크 배열에서. 이제 u에서 v까지의 경로에 있는 모든 요소는 오일러 워크 배열의 노드 u와 v의 인덱스 사이에 놓이게 됩니다. 따라서 우리는 오일러 배열의 노드 u와 노드 v의 인덱스 사이의 최소 깊이를 가진 노드를 계산하면 됩니다.
이를 위해 우리는 RMQ 알고리즘을 적용할 수 있도록 오일러 워크 배열의 위치에 해당하는 모든 노드의 깊이를 포함하는 또 다른 배열을 유지 관리합니다.
아래에는 깊이 트랙 배열과 평행한 오일러 워크 배열이 나와 있습니다.
MVC 자바
예 :- 두 개의 노드를 고려하십시오. 노드 6 그리고 노드 7 오일러 배열에서. 노드 6과 노드 7의 LCA를 계산하기 위해 노드 6과 노드 7 사이의 모든 노드에 대해 가장 작은 깊이 값을 찾습니다.
그러므로 노드 1 가장 작습니다 깊이 값 = 0 따라서 이는 노드 6과 노드 7에 대한 LCA입니다.
구현:-
We will be maintaining three arrays 1) Euler Path 2) Depth array 3) First Appearance Index
오일러 경로(Euler Path)와 깊이(Depth) 배열은 위에서 설명한 것과 동일합니다.
첫 등장 지수 FAI[] : 첫 번째 모양 인덱스 배열은 오일러 경로 배열에 있는 모든 노드의 첫 번째 위치에 대한 인덱스를 저장합니다. FAI[i] = 오일러 워크 배열에서 i번째 노드가 처음으로 나타납니다.
위 방법의 구현은 다음과 같습니다.
구현:
C++// C++ program to demonstrate LCA of n-ary tree // in constant time. #include 'bits/stdc++.h' using namespace std; #define sz 101 vector < int > adj[sz]; // stores the tree vector < int > euler; // tracks the eulerwalk vector < int > depthArr; // depth for each node corresponding // to eulerwalk int FAI[sz]; // stores first appearance index of every node int level[sz]; // stores depth for all nodes in the tree int ptr; // pointer to euler walk int dp[sz][18]; // sparse table int logn[sz]; // stores log values int p2[20]; // stores power of 2 void buildSparseTable(int n) { // initializing sparse table memset(dp-1sizeof(dp)); // filling base case values for (int i=1; i<n; i++) dp[i-1][0] = (depthArr[i]>depthArr[i-1])?i-1:i; // dp to fill sparse table for (int l=1; l<15; l++) for (int i=0; i<n; i++) if (dp[i][l-1]!=-1 and dp[i+p2[l-1]][l-1]!=-1) dp[i][l] = (depthArr[dp[i][l-1]]>depthArr[dp[i+p2[l-1]][l-1]])? dp[i+p2[l-1]][l-1] : dp[i][l-1]; else break; } int query(int lint r) { int d = r-l; int dx = logn[d]; if (l==r) return l; if (depthArr[dp[l][dx]] > depthArr[dp[r-p2[dx]][dx]]) return dp[r-p2[dx]][dx]; else return dp[l][dx]; } void preprocess() { // memorizing powers of 2 p2[0] = 1; for (int i=1; i<18; i++) p2[i] = p2[i-1]*2; // memorizing all log(n) values int val = 1ptr=0; for (int i=1; i<sz; i++) { logn[i] = ptr-1; if (val==i) { val*=2; logn[i] = ptr; ptr++; } } } /** * Euler Walk ( preorder traversal) * converting tree to linear depthArray * Time Complexity : O(n) * */ void dfs(int curint prevint dep) { // marking FAI for cur node if (FAI[cur]==-1) FAI[cur] = ptr; level[cur] = dep; // pushing root to euler walk euler.push_back(cur); // incrementing euler walk pointer ptr++; for (auto x:adj[cur]) { if (x != prev) { dfs(xcurdep+1); // pushing cur again in backtrack // of euler walk euler.push_back(cur); // increment euler walk pointer ptr++; } } } // Create Level depthArray corresponding // to the Euler walk Array void makeArr() { for (auto x : euler) depthArr.push_back(level[x]); } int LCA(int uint v) { // trivial case if (u==v) return u; if (FAI[u] > FAI[v]) swap(uv); // doing RMQ in the required range return euler[query(FAI[u] FAI[v])]; } void addEdge(int uint v) { adj[u].push_back(v); adj[v].push_back(u); } int main(int argc char const *argv[]) { // constructing the described tree int numberOfNodes = 8; addEdge(12); addEdge(13); addEdge(24); addEdge(25); addEdge(26); addEdge(37); addEdge(38); // performing required precalculations preprocess(); // doing the Euler walk ptr = 0; memset(FAI-1sizeof(FAI)); dfs(100); // creating depthArray corresponding to euler[] makeArr(); // building sparse table buildSparseTable(depthArr.size()); cout << 'LCA(67) : ' << LCA(67) << 'n'; cout << 'LCA(64) : ' << LCA(64) << 'n'; return 0; }
// Java program to demonstrate LCA of n-ary // tree in constant time. import java.util.ArrayList; import java.util.Arrays; class GFG{ static int sz = 101; @SuppressWarnings('unchecked') // Stores the tree static ArrayList<Integer>[] adj = new ArrayList[sz]; // Tracks the eulerwalk static ArrayList<Integer> euler = new ArrayList<>(); // Depth for each node corresponding static ArrayList<Integer> depthArr = new ArrayList<>(); // to eulerwalk // Stores first appearance index of every node static int[] FAI = new int[sz]; // Stores depth for all nodes in the tree static int[] level = new int[sz]; // Pointer to euler walk static int ptr; // Sparse table static int[][] dp = new int[sz][18]; // Stores log values static int[] logn = new int[sz]; // Stores power of 2 static int[] p2 = new int[20]; static void buildSparseTable(int n) { // Initializing sparse table for(int i = 0; i < sz; i++) { for(int j = 0; j < 18; j++) { dp[i][j] = -1; } } // Filling base case values for(int i = 1; i < n; i++) dp[i - 1][0] = (depthArr.get(i) > depthArr.get(i - 1)) ? i - 1 : i; // dp to fill sparse table for(int l = 1; l < 15; l++) for(int i = 0; i < n; i++) if (dp[i][l - 1] != -1 && dp[i + p2[l - 1]][l - 1] != -1) dp[i][l] = (depthArr.get(dp[i][l - 1]) > depthArr.get( dp[i + p2[l - 1]][l - 1])) ? dp[i + p2[l - 1]][l - 1] : dp[i][l - 1]; else break; } static int query(int l int r) { int d = r - l; int dx = logn[d]; if (l == r) return l; if (depthArr.get(dp[l][dx]) > depthArr.get(dp[r - p2[dx]][dx])) return dp[r - p2[dx]][dx]; else return dp[l][dx]; } static void preprocess() { // Memorizing powers of 2 p2[0] = 1; for(int i = 1; i < 18; i++) p2[i] = p2[i - 1] * 2; // Memorizing all log(n) values int val = 1 ptr = 0; for(int i = 1; i < sz; i++) { logn[i] = ptr - 1; if (val == i) { val *= 2; logn[i] = ptr; ptr++; } } } // Euler Walk ( preorder traversal) converting // tree to linear depthArray // Time Complexity : O(n) static void dfs(int cur int prev int dep) { // Marking FAI for cur node if (FAI[cur] == -1) FAI[cur] = ptr; level[cur] = dep; // Pushing root to euler walk euler.add(cur); // Incrementing euler walk pointer ptr++; for(Integer x : adj[cur]) { if (x != prev) { dfs(x cur dep + 1); // Pushing cur again in backtrack // of euler walk euler.add(cur); // Increment euler walk pointer ptr++; } } } // Create Level depthArray corresponding // to the Euler walk Array static void makeArr() { for(Integer x : euler) depthArr.add(level[x]); } static int LCA(int u int v) { // Trivial case if (u == v) return u; if (FAI[u] > FAI[v]) { int temp = u; u = v; v = temp; } // Doing RMQ in the required range return euler.get(query(FAI[u] FAI[v])); } static void addEdge(int u int v) { adj[u].add(v); adj[v].add(u); } // Driver code public static void main(String[] args) { for(int i = 0; i < sz; i++) { adj[i] = new ArrayList<>(); } // Constructing the described tree int numberOfNodes = 8; addEdge(1 2); addEdge(1 3); addEdge(2 4); addEdge(2 5); addEdge(2 6); addEdge(3 7); addEdge(3 8); // Performing required precalculations preprocess(); // Doing the Euler walk ptr = 0; Arrays.fill(FAI -1); dfs(1 0 0); // Creating depthArray corresponding to euler[] makeArr(); // Building sparse table buildSparseTable(depthArr.size()); System.out.println('LCA(67) : ' + LCA(6 7)); System.out.println('LCA(64) : ' + LCA(6 4)); } } // This code is contributed by sanjeev2552
# Python program to demonstrate LCA of n-ary tree # in constant time. from typing import List # stores the tree adj = [[] for _ in range(101)] # tracks the eulerwalk euler = [] # depth for each node corresponding to eulerwalk depthArr = [] # stores first appearance index of every node FAI = [-1] * 101 # stores depth for all nodes in the tree level = [0] * 101 # pointer to euler walk ptr = 0 # sparse table dp = [[-1] * 18 for _ in range(101)] # stores log values logn = [0] * 101 # stores power of 2 p2 = [0] * 20 def buildSparseTable(n: int): # initializing sparse table for i in range(n): dp[i][0] = i-1 if depthArr[i] > depthArr[i-1] else i # dp to fill sparse table for l in range(1 15): for i in range(n): if dp[i][l-1] != -1 and dp[i+p2[l-1]][l-1] != -1: dp[i][l] = dp[i+p2[l-1]][l-1] if depthArr[dp[i][l-1] ] > depthArr[dp[i+p2[l-1]][l-1]] else dp[i][l-1] else: break def query(l: int r: int) -> int: d = r-l dx = logn[d] if l == r: return l if depthArr[dp[l][dx]] > depthArr[dp[r-p2[dx]][dx]]: return dp[r-p2[dx]][dx] else: return dp[l][dx] def preprocess(): global ptr # memorizing powers of 2 p2[0] = 1 for i in range(1 18): p2[i] = p2[i-1]*2 # memorizing all log(n) values val = 1 ptr = 0 for i in range(1 101): logn[i] = ptr-1 if val == i: val *= 2 logn[i] = ptr ptr += 1 def dfs(cur: int prev: int dep: int): global ptr # marking FAI for cur node if FAI[cur] == -1: FAI[cur] = ptr level[cur] = dep # pushing root to euler walk euler.append(cur) # incrementing euler walk pointer ptr += 1 for x in adj[cur]: if x != prev: dfs(x cur dep+1) # pushing cur again in backtrack # of euler walk euler.append(cur) # increment euler walk pointer ptr += 1 # Create Level depthArray corresponding # to the Euler walk Array def makeArr(): global depthArr for x in euler: depthArr.append(level[x]) def LCA(u: int v: int) -> int: # trivial case if u == v: return u if FAI[u] > FAI[v]: u v = v u # doing RMQ in the required range return euler[query(FAI[u] FAI[v])] def addEdge(u v): adj[u].append(v) adj[v].append(u) # constructing the described tree numberOfNodes = 8 addEdge(1 2) addEdge(1 3) addEdge(2 4) addEdge(2 5) addEdge(2 6) addEdge(3 7) addEdge(3 8) # performing required precalculations preprocess() # doing the Euler walk ptr = 0 FAI = [-1] * (numberOfNodes + 1) dfs(1 0 0) # creating depthArray corresponding to euler[] makeArr() # building sparse table buildSparseTable(len(depthArr)) print('LCA(67) : ' LCA(6 7)) print('LCA(64) : ' LCA(6 4))
// C# program to demonstrate LCA of n-ary // tree in constant time. using System; using System.Collections.Generic; public class GFG { static int sz = 101; // Stores the tree static List<int>[] adj = new List<int>[sz]; // Tracks the eulerwalk static List<int> euler = new List<int>(); // Depth for each node corresponding static List<int> depthArr = new List<int>(); // to eulerwalk // Stores first appearance index of every node static int[] FAI = new int[sz]; // Stores depth for all nodes in the tree static int[] level = new int[sz]; // Pointer to euler walk static int ptr; // Sparse table static int[] dp = new int[sz 18]; // Stores log values static int[] logn = new int[sz]; // Stores power of 2 static int[] p2 = new int[20]; static void buildSparseTable(int n) { // Initializing sparse table for(int i = 0; i < sz; i++) { for(int j = 0; j < 18; j++) { dp[ij] = -1; } } // Filling base case values for(int i = 1; i < n; i++) dp[i - 10] = (depthArr[i] > depthArr[i - 1]) ? i - 1 : i; // dp to fill sparse table for(int l = 1; l < 15; l++) for(int i = 0; i < n; i++) if (dp[il - 1] != -1 && dp[i + p2[l - 1]l - 1] != -1) dp[il] = (depthArr[dp[il - 1]] > depthArr[dp[i + p2[l - 1]l - 1]]) ? dp[i + p2[l - 1]l - 1] : dp[il - 1]; else break; } static int query(int l int r) { int d = r - l; int dx = logn[d]; if (l == r) return l; if (depthArr[dp[ldx]] > depthArr[dp[r - p2[dx]dx]]) return dp[r - p2[dx]dx]; else return dp[ldx]; } static void preprocess() { // Memorizing powers of 2 p2[0] = 1; for(int i = 1; i < 18; i++) p2[i] = p2[i - 1] * 2; // Memorizing all log(n) values int val = 1 ptr = 0; for(int i = 1; i < sz; i++) { logn[i] = ptr - 1; if (val == i) { val *= 2; logn[i] = ptr; ptr++; } } } // Euler Walk ( preorder traversal) converting // tree to linear depthArray // Time Complexity : O(n) static void dfs(int cur int prev int dep) { // Marking FAI for cur node if (FAI[cur] == -1) FAI[cur] = ptr; level[cur] = dep; // Pushing root to euler walk euler.Add(cur); // Incrementing euler walk pointer ptr++; foreach (int x in adj[cur]) { if (x != prev) { dfs(x cur dep + 1); euler.Add(cur); ptr++; } } } // Create Level depthArray corresponding // to the Euler walk Array static void makeArr() { foreach (int x in euler) depthArr.Add(level[x]); } static int LCA(int u int v) { // Trivial case if (u == v) return u; if (FAI[u] > FAI[v]) { int temp = u; u = v; v = temp; } // Doing RMQ in the required range return euler[query(FAI[u] FAI[v])]; } static void addEdge(int u int v) { adj[u].Add(v); adj[v].Add(u); } // Driver Code static void Main(string[] args) { int sz = 9; adj = new List<int>[sz]; for (int i = 0; i < sz; i++) { adj[i] = new List<int>(); } // Constructing the described tree int numberOfNodes = 8; addEdge(1 2); addEdge(1 3); addEdge(2 4); addEdge(2 5); addEdge(2 6); addEdge(3 7); addEdge(3 8); // Performing required precalculations preprocess(); // Doing the Euler walk ptr = 0; Array.Fill(FAI -1); dfs(1 0 0); // Creating depthArray corresponding to euler[] makeArr(); // Building sparse table buildSparseTable(depthArr.Count); Console.WriteLine('LCA(67) : ' + LCA(6 7)); Console.WriteLine('LCA(64) : ' + LCA(6 4)); } } // This code is contributed by Prince Kumar
let adj = []; for (let _ = 0; _ < 101; _++) { adj.push([]); } // tracks the eulerwalk let euler = []; // depth for each node corresponding to eulerwalk let depthArr = []; // stores first appearance index of every node let FAI = new Array(101).fill(-1); // stores depth for all nodes in the tree let level = new Array(101).fill(0); // pointer to euler walk let ptr = 0; // sparse table let dp = []; for (let _ = 0; _ < 101; _++) { dp.push(new Array(18).fill(-1)); } // stores log values let logn = new Array(101).fill(0); // stores power of 2 let p2 = new Array(20).fill(0); function buildSparseTable(n) { // initializing sparse table for (let i = 0; i < n; i++) { dp[i][0] = i - 1 >= 0 && depthArr[i] > depthArr[i - 1] ? i - 1 : i; } // dp to fill sparse table for (let l = 1; l < 15; l++) { for (let i = 0; i < n; i++) { if ( dp[i][l - 1] !== -1 && dp[i + p2[l - 1]][l - 1] !== -1 ) { dp[i][l] = depthArr[dp[i][l - 1]] > depthArr[dp[i + p2[l - 1]][l - 1]] ? dp[i + p2[l - 1]][l - 1] : dp[i][l - 1]; } else { break; } } } } function query(l r) { let d = r - l; let dx = logn[d]; if (l === r) { return l; } if (depthArr[dp[l][dx]] > depthArr[dp[r - p2[dx]][dx]]) { return dp[r - p2[dx]][dx]; } else { return dp[l][dx]; } } function preprocess() { // memorizing powers of 2 p2[0] = 1; for (let i = 1; i < 18; i++) { p2[i] = p2[i - 1] * 2; } // memorizing all log(n) values let val = 1; ptr = 0; for (let i = 1; i < 101; i++) { logn[i] = ptr - 1; if (val === i) { val *= 2; logn[i] = ptr; ptr += 1; } } } function dfs(cur prev dep) { // marking FAI for cur node if (FAI[cur] === -1) { FAI[cur] = ptr; } level[cur] = dep; // pushing root to euler walk euler.push(cur); // incrementing euler walk pointer ptr += 1; for (let x of adj[cur]) { if (x !== prev) { dfs(x cur dep + 1); // pushing cur again in backtrack // of euler walk euler.push(cur); // increment euler walk pointer ptr += 1; } } } // Create Level depthArray corresponding // to the Euler walk Array function makeArr() { for (let x of euler) { depthArr.push(level[x]); } } function LCA(u v) { // trivial case if (u === v) { return u; } if (FAI[u] > FAI[v]) { [u v] = [v u]; } // doing RMQ in the required range return euler[query(FAI[u] FAI[v])]; } function addEdge(u v) { adj[u].push(v); adj[v].push(u); } // constructing the described tree let numberOfNodes = 8; addEdge(1 2); addEdge(1 3); addEdge(2 4); addEdge(2 5); addEdge(2 6); addEdge(3 7); addEdge(3 8); // performing required precalculations preprocess(); // doing the Euler walk ptr = 0; FAI = new Array(numberOfNodes + 1).fill(-1); dfs(1 0 0); // creating depthArray corresponding to euler[] makeArr(); // building sparse table buildSparseTable(depthArr.length); console.log('LCA(67) : ' LCA(6 7)); console.log('LCA(64) : ' LCA(6 4));
산출
LCA(67) : 1 LCA(64) : 2
메모 : 우리는 쿼리당 일정한 시간 복잡도를 보장하기 위해 필요한 모든 2의 거듭제곱을 미리 계산하고 필요한 모든 로그 값도 미리 계산합니다. 그렇지 않으면 모든 쿼리 작업에 대해 로그 계산을 수행했다면 시간 복잡도가 일정하지 않았을 것입니다.
버블 정렬 파이썬
시간 복잡도: LCA에서 RMQ로의 변환 프로세스는 Euler Walk에 의해 수행됩니다. 에) 시간.
RMQ의 희소 테이블에 대한 전처리에는 O(nlogn) 시간이 소요되며 각 쿼리에 대한 응답은 일정한 시간 프로세스입니다. 따라서 전체 시간 복잡도는 O(nlogn)입니다. 오(1) 각 쿼리에 대해.
보조 공간: O(n+s)
퀴즈 만들기