apply LaTeX 2

3. Algorithms/01. Algorithm Complexity Analysis/README.md

@@ -79,88 +79,84 @@
   - 그 함수 $g(n)$은 어떤 2차 함수 $cn^{2}$ 보다는 궁극적으로 **좋다**고 (기울기가 **낮다**고) 말할 수 있다.
 - 어떤 알고리즘의 시간복잡도가 $O(f(n))$이라면
   - 입력의 크기 $n$에 대해서 이 알고리즘의 수행시간은 **아무리 늦어도** $f(n)$은 된다. ($f(n)$이 상한이다.)
-  - 다시 말하면, 이 알고리즘의 수행시간은 `f(n)`보다 절대로 더 느릴 수는 없다는 말이다.
+  - 다시 말하면, 이 알고리즘의 수행시간은 $f(n)$보다 절대로 더 느릴 수는 없다는 말이다.
   - “최악의 경우 이 정도 시간이면 된다”
+
 #### Tight Upper Bound
 - 이 알고리즘은 어떠한 경우에도 이 상한을 넘지 않는다.
-  - “길어야 $N$` 시간이면 된다”가 사실이라면 당연히 “길어야 $N^{2}$ 시간이면 된다”라거나 “길어야 $N^{3}$ 시간이면 된다”도 사실
+  - “길어야 $N$ 시간이면 된다”가 사실이라면 당연히 “길어야 $N^{2}$ 시간이면 된다”라거나 “길어야 $N^{3}$ 시간이면 된다”도 사실
   - 알고리즘의 특성을 표현하는 데는 tight upper bound를 사용해야 함.
-  - Say “$2n$ is $O(n)$” instead of “$2n$ is $`O(n^{2})$”
+  - Say " $2n$ is $O(n)$ ", instead of " $2n$ is $O(n^{2})$ "
 - Use the simplest expression of the class
-  - Say “$3n + 5$ is $O(n)$” instead of “$3n + 5$ is $O(3n)$”
+  - Say “ $3n + 5$ is $O(n)$ ”, instead of “ $3n + 5$ is $O(3n)$ ”
 
 #### Big O 표기법 : 증명 ✩
 
 1. 부등식을 세워라
+    - e.g., $n^2 + 10n \geq c \cdot n^{2}$
+3. 부등식을 만족하는 $c$, $N$을 pick!
+4. Verify
 
-- eg, `n²+10n ≤ c⋅n²`
-
-2. 부등식을 만족하는 c, N을 pick!
-3. Verify
-
-##### 예시
-
-- `n² + 10n` ∈ `O(n²)`
-  - (1) n ≥ 10인 모든 정수 n에 대해서 `n² + 10n ≤ 2n²`이 성립한다. 그러므로, **c = 2 와 N = 10을 선택**하면, “Big O ”의 정의에 의해서 `n² + 10n ∈ O(n²)`이라고 결론 지을 수 있다.
-  - (2) n ≥ 1인 모든 정수 n에 대해서 `n² + 10n ≤ n² + 10n² = 11n²`이 성립한다. 그러므로, **c = 11와 N = 1을 선택**하면, “Big O”의 정의에 의해서 `n² + 10n ∈ O(n²)` 이라고 결론 지을 수 있다.
+##### 예시 
+$n^{2} + 10n \in O(n^{2})$
+- (1) $n \geq 10$인 모든 정수 $n$에 대해서 $n^2 + 10n \leq 2n^{2}$이 성립한다. 그러므로, $c = 2$와 $N = 10$을 선택하면, “Big O ”의 정의에 의해서 $n^{2} + 10n \in O(n^{2})$이라고 결론 지을 수 있다.
+- (2) $n \geq 1$인 모든 정수 $n$에 대해서 $n^2 + 10n \leq n^2 + 10n^2 = 11n^2$이 성립한다. 그러므로, $c = 11$와 $N = 1$을 선택하면, “Big O”의 정의에 의해서 $n^2 + 10n \in O(n^{2})$ 이라고 결론 지을 수 있다.
 
 ### Asymptotic Analysis
 
 - **Big-picture** approach
-- 실행시간이 “grows proportionally to `f(n)`” 한다는 사실만으로 충분
-- 실제 실행 시간은 `c(constant factor)⋅f(n)` 이 됨
-- 어떤 알고리즘의 worst-case가 `g(N) = 60N² + 5N + `이라면
-  - `g(N) = O(N²)` : `g(N)`의 growth rate는 `N²`의 growth rate과 같다.
+- 실행시간이 “grows proportionally to $f(n)$” 한다는 사실만으로 충분
+- 실제 실행 시간은 $c \cdot f(n)$ 이 됨 ($c$: constant factor)
+- 어떤 알고리즘의 worst-case가 $g(N) = 60N^2 + 5N + 3$이라면
+  - $g(N) = O(N^{2})$ : $g(N)$의 growth rate는 $N^{2}$의 growth rate과 같다.
 
 ### 대표적인 복잡도 카테고리
 
 #### Polynomial Time
 
-- `O(1)` : constant complexity
+- $O(1)$ : constant complexity
   - 입력자료수에 무관
   - 해쉬
-- `O(loglog n)`
-- `O(log n)` : logarithmic complexity
+- $O( \log \log n)$
+- $O( \log n)$ : logarithmic complexity
   - divide & conquer
   - 이진 검색
-- `O(n)` : linear complexity
+- $O(n)$ : linear complexity
   - scan 검색
-- `O(n log n)`
+- $O(n \log n)$
   - 병합 정렬, quick 정렬...
-- `O(n^k)` (k ≥ 1)
-  - `O(n2)` : quadratic complexity
+- $O(n^{k})$ $(k ≥ 1)$
+  - $O(N^{2})$ : quadratic complexity
     - 이중 loop, 삽입정렬, 선택정렬...
-  - `O(n3)` : cubic complexity
+  - $O(n^{3})$ : cubic complexity
     - 삼중 loop, 행렬의 곱셈
 
 #### Exponential Time
 
-- `O(2n)` : exponential complexity
+- $O(2^{n})$ : exponential complexity
   - Knapsack problem, Fibonacci, Hanoi...
 
 ### Ω 표기법
 
 - 정의 : 점근적 하한 (Asymptotic Tight Lower Bound)
-
-  - 주어진 복잡도 함수 `f(n)`에 대해서 `g(n) ∈ Ω(f(n)`이면 다음을 만족한다.
-  - n ≥ N인 모든 정수 n에 대해서 `g(n) ≥ c⋅f(n)`이 성립하는 실수 c>0와 음이 아닌 정수 N이 존재한다.
-
-- `g(n) ∈ Ω(f(n))` 읽는 방법:
-  - `g(n)`은 `f(n)`의 오메가(omega)
+  - 주어진 복잡도 함수 $f(n)$에 대해서 $g(n) \in \Omega(f(n))$이면 다음을 만족한다.
+  - $n \geq N$인 모든 정수 $n$에 대해서 $g(n) ≥ c \cdot f(n)$이 성립하는 실수 $c>0$와 음이 아닌 정수 $N$이 존재한다.
+- $g(n) \in \Omega(f(n))$ 읽는 방법:
+  - $g(n)$은 $f(n)$의 오메가(omega)
 
 <img width="334" alt="스크린샷 2022-04-14 오후 10 05 25" src="https://user-images.githubusercontent.com/73745836/163396716-7236fc0f-cca6-489c-a835-f82c3756f2ae.png">
 
-- 어떤 알고리즘의 시간복잡도가 `Ω(f(n))`이라면,
-  - 입력의 크기 n에 대해서 이 알고리즘의 수행시간은 아무리 빨라도 `f(n)`밖에 되지 않는다. (`f(n)`이 하한이다.)
+- 어떤 알고리즘의 시간복잡도가 $\Omega (f(n))$이라면,
+  - 입력의 크기 $n$에 대해서 이 알고리즘의 수행시간은 아무리 빨라도 $f(n)$밖에 되지 않는다. ($f(n)$이 하한이다.)
   - “최소한 이만한 시간은 걸린다”
-  - 모든 정렬 알고리즘은 `Ω(N)`. N개의 데이터를 정렬하는데 N개 모두를 읽지 않고 정렬을 완료할 수는 없기 때문. ✩
+  - 모든 정렬 알고리즘은 $\Omega (N)$. $N$개의 데이터를 정렬하는데 $N$개 모두를 읽지 않고 정렬을 완료할 수는 없기 때문. ✩
 
 ### Summary ✩
 
 ![IMG_5B36BB702193-1](https://user-images.githubusercontent.com/73745836/163398342-b7255be9-0006-4d7c-aad8-399b6c7553d5.jpeg)
 
-- “The running time is `O(f(n))`” => Worst case is `O(f(n))`
-- “Running time is `Ω(f(n))`” => Best case is `Ω(f(n))`
+- “The running time is $O(f(n))$” => Worst case is $O(f(n))$
+- “Running time is $\Omega (f(n))$” => Best case is $\Omega (f(n))$
 
 ## 순환 (recursion)