김치만두 먹고 공부하기

[2. 트리, 힙, 그래프] 힙

꿀꺽람 — Tue, 14 Mar 2023 17:48:42 +0900

힙(Heap)

힙의 특징은 다음과 같다.

- 최대 원소에 즉각적으로 접근할 수 있다. O(1)

- 원소 삽입과 삭제에 대해 O(logN)의 시간복잡도를 만족한다.

이러한 특징을 만족하기 위해 완전이진트리(Complete Binary Tree)를 이용한다.

* 완전 이진트리: 마지막 레벨의 노드를 제외하고는 모두 두 개의 자식이 있고, 마지막 레벨에서는 왼쪽부터 차례대로 노드 존재

위와 같은 완전 이진 트리 표현은 다른 노드를 가리키는 포인터를 저장할 필요가 없다.

그렇기 때문에 메모리 사용 측면에서 효율적이다.

부모노드에서 자식노드로 이동하는 것은 배열의 인덱스 계산으로 쉽게 이루어진다.

예를 들어, 부모 노드의 인덱스가 i라면, 자식 노드의 인덱스는 2 * i + 1, 2 * i + 2이다.

반대로 자식 노드의 인덱스가 i라면, 부모 노드의 인덱스는 (i - 1) / 2로 표현할 수 있다.

최대 힙과 최소 힙

최대 원소가 트리의 루트에 있도록 설정한 힙 -> 최대 힙

최소 원소가 트리의 루트에 있도록 설정한 힙 -> 최소 힙

최대 힙과 최소 힙을 유지하기 위해서 원소를 삽입하거나 삭제할 때 힙의 불변성을 유지해야 한다.

힙 연산 (원소 삽입)

원소 삽입 시에 가장 중요한 불변성은 완전 이진 트리를 유지하는 것이다.

이를 위해 배열의 맨 마지막 위치에 원소를 추가하는데,

마지막 레벨의 마지막 노드 바로 오른쪽에 새로운 노드를 추가하거나, 새로운 레벨을 추가하여 노드를 추가할 수 있다.

두 번째 조건은 모든 노드는 자식 노드보다 큰 값을 가지고 있어야 한다는 것이다.

힙의 가장 마지막 위치에 원소를 삽입하게 되면, 위 조건이 맞지 않는 경우가 생길 수 있다.

그럴 때에는 새로 삽입한 원소의 부모 노드와 값을 비교하고, 부모 노드보다 해당 노드가 더 크면 서로 Swap 하는 방식으로 삽입 연산을 수행한다.

완전 이진 트리의 높이는 최대 logN이므로, 삽입 연산의 시간 복잡도는 O(logN)으로 표현할 수 있다.

힙 연산 (원소 삭제)

힙에서는 항상 가장 큰 원소만 삭제할 수 있다.

힙의 최대 원소는 루트 노드에 존재하므로, 루트 노드를 삭제해야 한다.

이를 수행하기 위해 루트 노드와 힙의 마지막 노드를 교환한 후, 루트 노드를 삭제한다.

이렇게 하면 부모 노드가 자식 노드보다 큰 값을 만족하지 않을 수 있다.

그렇기 때문에 루트노드와 두 자식노드를 서로 비교하여 그 중 더 큰 노드와 교환한다.

이를 반복해서 수행하면서 힙의 조건을 만족하도록 연산을 수행한다.

힙 초기화하기

불변성을 유지하면서 힙을 초기화하는 가장 쉬운 방법은 비어있는 힙에 원소를 하나씩 추가하는 것이다.

그러나 이 방법은 O(NlogN)의 시간복잡도를 가지며 그렇게 효율적인 방법은 아니다.

힙 생성 알고리즘을 사용하면 이를 O(N) 시간에 초기화할 수 있다.

전체 트리의 아래쪽 서브 트리부터 힙 불변성을 만족하도록 힙을 업데이트하는 방법이다.

C++에서는 배열 또는 벡터의 반복자를 입력으로 받아 힙을 구성하는 std::make_heap() 함수를 제공하기도 한다.

[2. 트리, 힙, 그래프] 균형 트리, n항 트리

꿀꺽람 — Wed, 15 Feb 2023 18:49:42 +0900

https://dev-haram.online/67

[2. 트리, 힙, 그래프] 이진 검색 트리(Binary Search Tree)

이진 검색 트리 (Binary Search Tree) 이진 검색 트리는 다음과 같은 속성을 갖는 이진 트리이다. - 부모 노드의 값 >= 왼쪽 자식 노드의 값 - 부모 노드의 값 18, 15 < 18, 17 < 18 이기 때문에 위 그림처럼 17

dev-haram.online

앞선 게시글에서 이진 검색 트리에 대해 정리했다.

이진 검색 트리의 시간 복잡도에 대해 서술할 때, 트리의 삽입 순서에 따라 시간 복잡도가 달라진다고 언급했었다.

이를 조금 더 자세히 살펴보면,

위 그림에서 왼쪽 트리와 오른쪽 트리를 비교해보면, 오른쪽 트리가 더 균형이 잡혀있다고 할 수 있다.

균형 트리 (balanced tree)

위 그림에서 오른쪽 트리는 편향되지 않는 상태로, 균형이 잡혔다고 한다.

이러한 상황에서는 원소 검색의 시간복잡도가 감소하기 때문에 편향된 트리보다 훨씬 최적화 되어있다.

균형 트리를 만들기 위해서는 트리의 높이가 최적화되어야 한다. 그렇기 때문에 원소 삽입 또는 삭제 후에 트리 구성을 조정하여 최적 트리를 만들 수 있도록 구현해야 한다.

이렇게 편향성이 줄어든 BST를 높이 균형 BST (height-balanced BST) 라고 한다.

이러한 트리를 만드는 방법은 여러 가지가 존재하며, 이를 통해 AVL 트리, 레드-블랙 트리 등의 다양한 트리를 만들 수 있다.

N-항 트리

지금까지는 주로 이진 트리에 대해서 서술했지만, 각 노드의 자식이 두 개가 아닌 n 개의 자식을 갖는 트리를 n 항 트리라고 한다.

n개의 자식 노드는 vector 컨테이너를 이용하여 저장할 수 있다.

struct nTree{
    int data;
    std::vector<nTree*> children;
}

컴퓨터 파일 시스템 구조나 컴파일러 등에서 n 항 트리를 사용한다.

[2. 트리, 힙, 그래프] 이진 검색 트리(Binary Search Tree)

꿀꺽람 — Wed, 15 Feb 2023 16:55:28 +0900

이진 검색 트리 (Binary Search Tree)

이진 검색 트리는 다음과 같은 속성을 갖는 이진 트리이다.

- 부모 노드의 값 >= 왼쪽 자식 노드의 값

- 부모 노드의 값 <= 오른쪽 자식 노드의 값

이는, 부모 노드보다 작거나 같은 모든 원소는 항상 왼쪽에 있고 부모 노드보다 크거나 같은 원소는 항상 오른쪽에 있게 된다. 따라서 원소 검색을 위해 루트 노드부터 차례대로 값을 비교하는 경우, 각 단계마다 검색 범위가 절반으로 줄어든다.

BST가 마지막 레벨을 제외한 모든 노드에 두 개의 자식 노드가 있으면 BST의 검색 및 삽입 동작은 O(logN)의 시간복잡도를 갖는다. 이러한 형태의 이진 트리는 완전 이진 트리라고 한다.

BST에서 원소 검색

이진 검색 트리에서 원소를 검색할 때는 이진 검색 트리의 특징을 이용해 검색 범위를 반으로 줄이면서 수행할 수 있다.

위 그림과 같은 BST에서 숫자 7을 검색하기 위해 각 노드에서 어느 하위 노드로 이동할 지 정해야 한다.

루트 노드 (12)와 7을 비교하면 7이 더 작기 때문에 왼쪽 하위 노드로 이동한다.

이 후 10과 7을 또 비교하면 7이 더 작으므로 왼쪽 하위 노드로 이동하고, 이를 반복하여 4와 7을 비교하여 오른쪽 하위 노드로 이동한 후 숫자 7을 찾을 수 있다.

이러한 방식으로 현재 노드가 찾고자 하는 노드가 아닐 때마다 검색 범위가 반으로 줄어든다.

BST에 새 원소 삽입

위 그림과 같이 구성되어 있는 BST에서 숫자 18을 삽입하려면 어떻게 해야 할까?

새로운 원소를 추가하려면 먼저 원소가 삽입될 위치의 부모 노드를 찾아야 한다. 이는 원소 검색과 비슷한 방식으로 이루어진다.

12 < 18, 20 > 18, 15 < 18, 17 < 18 이기 때문에

위 그림처럼 17의 오른쪽 하위노드에 18이 삽입된다.

BST에서 원소 삭제하기

BST에서 원소를 삭제할 때에는 단순히 노드를 삭제하는 것 뿐만 아니라, 노드 삭제 후 전체 트리가 BST 속성을 만족하도록 해야 한다.

이를 위해서 첫 번째단계로 삭제할 노드를 찾는다. 이후에는 해당 노드의 자식 노드에 따라 수행할 행동이 달라지게 된다.

1) 삭제할 노드의 자식 노드가 없는 경우: 단순히 해당 노드를 삭제하면 된다.

2) 삭제할 노드의 자식 노드가 하나인 경우: 노드 삭제 후, 부모 노드의 포인터가 해당 자식 노드를 가리키도록 조정한다.

3) 삭제할 노드의 자식 노드가 두 개 있는 경우: 노드 삭제 후, 현재 노드를 후속 노드로 대체한다.

여기서 1번과 2번은 크게 복잡하지 않지만, 3번은 추가 작업이 필요하다.

3번의 후속노드란, 현재 노드 다음으로 큰 숫자를 가진 노드를 말한다. (현재 원소보다 큰 원소들 중에 가장 작은 원소)

그렇기 때문에, 이 후속노드를 찾기 위해서는 서브 트리에서 가장 왼쪽에 위치한 노드로 이동하면 된다.

위와 같은 BST에서 12를 삭제하고 싶을 때, 앞에 설명한 대로 노드 삭제 후, 현재 노드를 후속 노드로 대체하는 작업이 필요하다.

그러기 위해서는 먼저 '후속 노드'를 찾아야 한다.

후속 노드는 현재 노드(12) 보다 큰 값을 가진 노드 중 가장 작은 값을 가진 노드를 의마하기 때문에 12의 오른쪽 서브 트리에서 가장 왼쪽에 위치한 노드를 찾으면 된다.

위 BST에서 후속 노드는 15가 될 것이다.

그 후에는, 후속 노드 값을 루트 노드에 복사한다.

그 후에는 원래 후속 노드를 삭제해주어야 한다.

이 삭제 또한 앞에 서술한 과정과 동일하게 적용한다.

이 때, 후속 노드는 항상 오른쪽 자식 노드만 갖게 될 것이다. 만약 왼쪽 노드에 값이 존재했다면, 해당 후속 노드보다 작은 값이 서브 트리에 존재했다는 의미이므로 후속 노드가 올바르지 않다는 의미이다.

그래서 결국 해당 후속 노드까지 삭제하면,

위 그림과 같이 12가 삭제된 BST가 될 것이다.

시간 복잡도

트리 연산의 시간복잡도는 이론적으로는 매번 검색 범위가 반 씩 줄어들기 때문에 $ O(logN) $ 이다.

그러나, BST는 트리의 모양이 삽입 순서에 따라 달라진다는 점, 검색 범위가 항상 n/2씩 줄어든다는 것도 보장할 수 없기 때문에 시간 복잡도 $ O(logN) $이 항상 정확하다고 볼 수 없다.

균형 트리에서 조금 더 정확하게 시간 복잡도를 계산하는 방법을 다뤄보려 한다.

[펄어비스 x 경희 소융] 프로젝트 회고

꿀꺽람 — Mon, 6 Feb 2023 17:30:07 +0900

한 학기 동안 공들여서 진행한 프로젝트가 드디어 최종 발표로 끝을 냈다.

10/20 에 첫 주제 발표를 시작으로 2/2에 최종 발표를 마쳤으니까 대략.. 3달 반 정도 되지 않을까 싶다.

이번에 참가한 프로그램은 펄어비스와 경희대학교 소프트웨어융합학과에서 진행하는 펄어비스 인재양성 프로그램이다.

쉽게 말해 펄어비스에서 장학금을 제공하면서 경희대학교 소프트웨어융합학과 학생들을 키우고, 해당 학생들은 주제를 정하고 교수님의 피드백과 함께 프로젝트를 진행하면서 펄어비스의 기준에 걸맞는 최종 프로젝트 완성을 목표로 진행하게 된다.

물론 난 소프트웨어융합학과는 아니었지만 ㅎㅎ.. 대략 열명이 진행했는데, 이 중 나 포함 두 명이 컴퓨터공학과였다.

나는 전에 소융 수업인 게임 PX 디자인 수업을 들었었고, 해당 수업에서 언리얼에 대해 배울 수 있었기 때문에 언리얼 엔진에 큰 거부감은 없었다. 하지만 언리얼에 익숙치 않다면 프로젝트 시작 전에 언리얼 튜토리얼이라도 공부하는 것을 추천한다..

우선 다음학기에 또 이런 기회가 열린다면 참가할 마음이 있는 사람들에게 전하고 싶다.

진짜 무조건 해보세요

물론 조금 빡세긴 하다. 아무래도 장학금을 받고 펄어비스와 연구과제를 진행하는 것이다 보니 주제 정하는 것부터 어렵다. ㅋㅋ ㅠㅠ

그럼에도 불구하고 추천하는 이유는 나는 이 프로그램으로 엄청 많은 것을 배웠고 앞으로 배우고 공부하고 싶은 것도 더 많아졌기 때문이다.

내 주제는 Combustion Simulation for Buildings 였다.

빌딩에서의 연소 시뮬레이션을 주제로 프로젝트를 진행했고, 빌딩에서 불이 퍼지는 모습을 구현하고 이를 영상과 발표에서 시각화하며 프로젝트를 완성하였다.

주제 발표를 시작으로 2주에 한 번씩 교수님께 현재 진행상황에 대한 발표를 진행했고, 두 번 발표를 진행한 후 중간 발표, 또 그 후 두 번 정도 발표를 진행한 후 최종 발표를 진행했다. 시험기간이 겹칠 때는 발표를 한 주 정도 쉬어가기도 했다.

주제 선정

주제 정할 때부터 엄청 고민을 많이 했는데, 나는 two minute papers라는 유튜브 채널에서 흥미로운 주제를 찾아서 이를 다르게 적용시켜보는 식으로 주제를 정했다.

사실 처음부터 연소 시뮬레이션을 하고 싶은 건 아니었고, 주제 후보가 여러 개 있었다.

아래는 내가 주제 선정할 때 생각해봤던 주제들이다.

이들 중 너무 어렵거나, 너무 간단하거나 혹은 대충 구글링해봤을 때 자료가 턱없이 부족한 주제들을 제외했더니 연소 시뮬레이션이 남았고, 그렇게 주제를 정하게 되었다.

저 중에서는 아직도 해보고 싶은 주제들이 많다. 특히 사운드소스가 공간 상에서 반사되고 굴절되고,, 등등 공간에서의 사운드 표현을 해보고싶었는데 너무 어려울 것 같아서 포기했었다. 나중에라도 꼭 해보고 싶은 주제이다.

프로젝트 진행

프로젝트는 약 3단계 정도로 개발을 진행했다.

Heat Transfer - Biological & Physical Attributes - Fire Simulation

의 단계로 진행되었는데,

이 중 가장 공들였던 Heat Transfer에 대해서 간단하게 말하려고 한다.

먼저 이 주제를 선택한 이상 가장 잘 보여줘야 할 것은 '이게 정말 열이 잘 전달되어 불이 퍼지는가' 였다.

그냥 대충 퍼지게 불 피워놓고 '건물에서 불이 퍼지는 모습을 구현하였습니다.' 는 부족했다. 이를 시각화하는 무언가가 필요했고, 나는 Vertex Color를 이용하여 각 버텍스들에게 열이 어떤 속도로 전달되고 있고, 발화점에 도달했는지, 언제쯤 발화점에 도달할 지 등에 대해 시각화하는 과정을 추가하였다.

Unity에서는 버텍스 관련 문서들도 많고 전에 인턴할 때 몇 번 다뤄봤었기 때문에 언리얼도 비슷하겠지~ 하고 일단 뛰어들었다.

삽질을 그냥 지구 내핵까지 했다. ㅋㅋ

삽질 과정에서 구글링해서 나오는 코드들을 넣어서 돌려봤고, 각 코드들의 한계점까지 파악하게 되었다.

겨우 찾아서 와 됐다!! 하면 다른 기능이 안되고.. 또 그게 되면 이게 안되고..

뭐 알지도 못하는 상태에서 시작하니까 Vertex, Vertex Instance 에서 아주 애를 먹었고 이게 해결되니까 Vertex Color에서, 그 다음은 Vertex Position에서 끊임없이 막혔다. 진짜 산 넘어 산이었다. ㅋㅋㅋㅋ ㅜㅜ

막힌 부분에 대해서는 나중에 따로 정리해서 업로드하려고 한다. 나와 비슷한 문제를 겪고 있는 사람들이 삽질을 덜 하길 바라면서.. ㅋㅋ ㅜㅠ

하루종일 해결하다가 새벽쯤에 이게 대체 왜 안되지.. 하고 구글링으로 겨우 찾아낸 자료가 '이렇게 하면 원래 안되는 거였네..' 인 날은 현타가 미친듯이 왔다.. 뭔가 하루를 다 썼는데 결국 원점인 느낌..? 학기 중에 진행한 프로젝트였기에 몇 번 이렇게 데이고 난 후에는 그냥 프로젝트 개발 시작 전에 무조건 과제, 공부를 다 마치고 진행하려고 했다.

내가 원하는 버텍스 관련 함수를 찾으려고 구글을 다 뒤졌는데도 안나와서 처음으로 언리얼 포럼에다가 질문도 작성해봤다. 근데 답은 안달렸다. ㅋㅋ ㅠㅠ

그래서 결국 엔진 코드까지 뜯어봤다.

이쯤에서 IDE 영업 하나 하자면..

"Jetbrains의 Rider" 진짜 갓 IDE 내가 써본것들 중 최고다. (물론 써본거라곤 VS, VSCode가 전부다.)

jetbrains는 Pycharm, IntelliJ로 유명한데, 나는 Unreal / Unity 와 호환이 되는 Rider를 사용하였다.

https://www.jetbrains.com/rider/

Rider: The Cross-Platform .NET IDE from JetBrains

Develop .NET, ASP.NET, .NET Core, Xamarin or Unity applications on Windows, Mac, Linux

www.jetbrains.com

그냥 진짜 엄청 편하다. 기존 코드 뜯어보기도 편하고, 디버그 / 빌드 툴도 엄청 잘 되어 있고, Git 버전 관리도 굉장히 편하게 할 수 있다. (머지 툴 최고) 로컬 히스토리도 확인할 수 있고 클래스, 함수 document 작성도 굉장히 편리하다.

특히 Unreal Engine 코드 뜯어볼 때가 가장 편했다. 원하는 함수, 변수, 클래스 명 등을 검색하거나 Usage 찾는 과정이 엄청 편하고 손쉽게 가능했다.

Rider로 Jetbrains의 ide에 입문한 나는 .. 이제 모든 IDE를 다 바꾸기 시작했다.. C++/C는 CLion, Python은 Pycharm 등을 사용하고 있는데 만족도 200%다. 대학생은 무료니까 아직 인생 IDE를 찾지 못했다면 한번 고려해보는 것도 좋을 것 같다!

(그리고 일단 이뻐서 코드 짤 맛이 난다.)

결국 엔진 코드에서 vertex color, position, index 등등이 어떤 식으로 구성되어 있는 지를 확인했고, 여러 시행착오 끝에 하나하나씩 해결할 수 있었다.

비록 삽질도 많이하고 어려움도 많았지만 그래도 점점 완성되어가는 모습이 뿌듯했다.

프로젝트 결과물

2/2에 프로젝트 최종 발표를 진행했다.

발표는 온라인으로 진행되었고, 펄어비스 관계자분들도 들어오셔서 발표를 들어주셨다.

발표에는 3분 내외의 최종 영상과 5분의 ppt 발표를 준비했다.

Combustion Simulation for Buildings_7_최종발표.pdf

0.71MB

위 pdf를 발표자료로 사용하였고, 최종 영상은 교수님 유튜브에 올라와있다. 구경하세요~~

https://www.youtube.com/watch?v=7byZo9cqBuI

교수님께서 '흠잡을데가 없다'라고 하셨다.

뿌듯 그 자체였다.

교수님 유튜브 메인 영상으로 올라왔다!

후기

진짜 어려웠다. 처음 해보는 게 너무 많았고 모르는 것도 많아 애초에 시작을 어디서부터 해야할지도 감이 안잡혔다.

학기 중이었기에 다른 학교 공부/과제랑도 겹쳐 머릿속에서 할 일들이 뒤죽박죽 섞여있었다. 특히 발표 3 ~ 4일전에는 그냥 집에 박혀서 프로젝트만 했다. 인스타 스토리에서도 적었다시피 구조짜고 알고리즘 짜고.. 꿈에서도 코딩하고.. 나도 모르게 부담감을 갖고 진행한 것 같기도 하다. 물론 그 부담감은 잘하고 싶어서 그런거겠지만.. ㅎㅎ

그냥 잘하고 싶었다. 좋은 기회이니만큼 내 최선을 다해서 프로젝트를 해보고 싶었고, 발표때마다 다른 분들 발표보면서 자극도 많이 받고 대단하다는 생각도 했다. 주제 정할 때는 내가 모르는 게 너무 많아서 어디서부터 검색해봐야 할지도 감이 안 잡혔고, 프로젝트를 시작한 후에는 처음에 짰던 구조를 계속 뒤엎고, 알고리즘 뒤엎고 하면서 어설프지만 완성해갔다. 내 프로젝트가 완벽하다고 하지는 못하겠다. 아직 고칠 점들이 많고, 시뮬레이션이지만 실제와는 조금 거리가 있는 것 같다. 나중에 시간이 난다면 더 보완해보고 싶다.

진짜 값진 경험이 된 것 같다. 많이 배우고, 진짜 많은 것을 경험했다. 일주일동안 해결안되던 문제가 해결되는 순간 그냥 뿌듯함 그 자체였다. 이 경험을 통해 배우고 싶은 것도 더 많아졌고, 차근차근 공부해서 블로그에다 정리해 업로드하려고 한다.ㅎㅎ

앞으로 더 공부 열심히 해서 성장하자!!

[Computer Vision] 2. Camera, Geometry and Photometry

꿀꺽람 — Sat, 4 Feb 2023 15:34:30 +0900

Camera

1. Camera Array

카메라 여러대를 이용해서 3D Mesh Model을 얻는 기술이다.

Static Objec는 카메라 한대로도 가능하다.

2. Lens Array (Integral Imaging)

여러 시점의 렌즈를 통해 3D 모델을 얻는 기술이다.

이를 위해서는 모두 같은 동률의 렌즈가 필요한데, 비싸다.

카메라 모듈 하나에 약 1000원 정도인데, 렌즈를 15개를 넣으면 15000원..

사업성이 충분하지 않다.

3. Digital Holography (CGH)

레이저를 이용해서 사물의 Absolute Depth를 파악하여 3D 모델을 얻는 기술이다.

Hologram Mark

다른 건 3D 모델을 2D 화면으로 3D 모델을 가져오는 기술이었는데, 이거는 3D 모델을 3D 환경에서 볼 수 있다.(3D 데이터의 현실감 상승, 시점을 이동하면 내가 보는 영상도 변함)

4. Normal Sensor (Photon-X)

사물의 Relative Depth를 파악하여 3D 모델을 얻는 기술이다.

빛의 회전 감도에 따라 Relative 거리를 측정할 수 있다. (빛이 다시 돌아오면서 회전한다.)

5. Structured Light (Stereo Reconstruction)

pattern Tracking

특정 패턴을 가진 빛을 쏴서 해당 패턴이 맞춰지는 조건으로 3D 모델을 맞춘다.

Accuracy와 Precision의 차이점
- Accuracy: 정확도 (Truth)
- Precision: 정밀도 (항상 같은 값)
  
  카메라는 Accuracy가 낮다

6. Kinect V1

직진성을 가진 레이저 빛을 물체에 쏴서 빛이 도착하는 시간을 계산하여 3D data를 얻는다.

time of flight

7. Time of Flight

Kinect V1은 Time of Flight 사용한다.

빛이 도착하는 시간으로 distance 계산한다.

실제로는 빛을 기다리지 않고 빛의 위상차를 이용한다. (근적외선 파장의 빛)

active sensor:

ex. RIDAR

8. Laser Scanning

Color Camera

Digital Image

3D로 펼쳐진 세상을 2D의 Digital Image로 변환시킬 때, 눈으로 보는 것과 카메라로 찍은 Image의 차이를 생각해보자.

3D Data가 사라지게 된다.
눈으로 느낄 수 있는 질감을 카메라의 픽셀로 표현할 수 없다.
공간 Quantization 으로 인한 이미지 Blur가 생긴다.
영상일 경우 시간 Quantization 으로 인해 frame 사이의 loss가 생긴다.
Color 표현 능력이 줄어든다.

이러한 문제점을 해결해야 3D 데이터를 2D image로 완벽히 구현할 수 있을 것이다.

Image Formation

카메라는 3D를 2D로 Projection하는 것과 같다.

카메라의 원리를 생각해보자.

왼쪽과 같은 Object가 있다고 생각했을 때, 모든 빛을 받는 단순한 Film 센서가 있다고 생각해보자.

이 센서에는 모든 빛이 다 들어오기 때문에 물체의 상이 맺히지 않게 된다.

즉, 렌즈로서의 역할을 수행할 수 없다는 뜻이다. (카메라의 기능을 수행하지 못한다.)

Pinhole Camera

그래서 나타난 카메라가 Pinhole Camera이다.

아까의 Object-Film 구조에서 중간에 구멍이 뚫린 장애물을 하나 놓는다.

그럼, 한 곳에서 반사되는 여러 방향의 빛 중 해당 구멍으로 지나가는 빛만 Film에 도달한다.

이를 이용하면 앞서 나왔던 여러 빛에 의한 Blurring 현상을 사라지게 만들 수 있게 된다.

그러나, 이 방식을 사용하게 되면 Film에 들어오는 빛의 양 자체가 적어지게 된다. 그럼 밝기 자체가 낮아져서 물체를 명확하게 볼 수 없게 된다.

구멍 주변에 아주 살짝 막히는 빛들 조차 차단되기 때문에, 구멍 앞에 렌즈를 붙여서 빛을 모아주는 역할을 하게 된다.

아래 그림을 보면 더 쉽게 이해할 수 있을 것이다.

당연하게도, pinhole의 구멍이 커질수록 film에 들어가는 빛의 양은 많아지므로 밝기가 커지지만, Blurring 현상도 생기게 된다.

밝기는 밝아지고, Blurring 현상도 막기 위해 앞서 설명한 것처럼 구멍 앞에 렌즈를 부착하게 되고, 이 렌즈 크기에 따라 화질 또한 커지게 된다.

Camera obscura

앞서 설명한 Pinhole Camera의 방식을 이용해 많은 화가들이 그림을 그렸다고 한다.

Projective Geometry

위 두 사진을 보면, 3D의 물체를 2D image로 projection 시켰을 때 Length정보와 Angles 정보가 명확하지 않고 사라지는 것을 느낄 수 있다.

그 대신, Straight Line 직선은 여전히 직선이다. (Shape은 유지되지 않는다.)

이 직선 정보로 3D data를 얻어낼 수 있다.

Vanishing points and lines

소실점에 대해서 들어봤을 것이다.

평행한 직선은 원근법에 의해 image 상에서 소실점이 생긴다.

한 image 내에서 소실점이 생기는 부분들을 연결했을 때 Vanishing Line이 생기게 된다.

위 그림처럼 왼쪽의 평행한 선들이 모여 왼쪽 Vanishing Point을 만들고, 오른쪽 벽의 선들이 모여 오른쪽에 Vanishing point를 만들게 된다.

이 두 Vanishing point를 연결하여 Vanishing Line을 만들게 된다.

이 때, Vertical로 사진을 보게되면 2차원에서 평행한 것을 알 수 있다. 2차원에서 평행한 선들은 3차원에서도 평행하게 된다.

사람들이 만든 것들은 평행하고 대칭적인 것이 많은데, 이를 이용해 후에 2D Image를 3D Data로 표현할 수 있게 된다.

Image Geometry

Image의 물체에서 3D 위치 데이터를 얻는 개념에 대해 생각해보자.

위 그림은 물체가 실제 세상에서 World Coordinate System으로 나타낸 그림이다.

이 때 원점(origin)은 정해져있지 않다.

위 그림은 물체의 카메라 상으로 Camera Coordinate System을 나타낸 모습이다.

Z 축은 Optic Axis, 즉 빛이 투과하는 광로를 나타낸다.

원점은 렌즈의 중심이 될 수 있다.

결국, Image의 기하학 정보를 알아내는 것의 처음은, World Coordinate 정보를 Camera Coordinate 정보로 변환하고, 이를 통해 Image Coordinate정보를 알아내 Pixel Coordinate로 변환하는 것이다.

Image Photometry

이미지의 3D Color 정보를 얻을 수 있는 방식에 대해 생각해보자.

광원에서 광자를 방출하게 되면, Photon은 물체에 닿아 우리 눈으로 들어오게 된다.

이때, 빛의 Spectrum별로 빛의 반사량이 다르고, 빛이 선택적으로 반사되기 때문에 같은 물체여도 부분적으로 다르게 보이게 된다.

Irradiance는 단위 면적 Surface가 받는 Radiant Flux, Radiance는 한 지점에서 특정 한 방향으로 내보내는 복사량정도로 대충 정리할 수 있을 것 같다.

Incoming Light에 Outgoing Light가 대략 하나씩 매칭이 된다면 거울이 될테고, 모든 곳으로 퍼지게 되면 일반 벽처럼 느끼게 될 것이다.

위 그림은 각 물체 자체가 나타내는 파장에 대한 정보이다.

여기서 Albedo라는 개념이 나오는데, 이는 물질 자체가 어떤 파장의 빛을 반사하는 지에 대한 정보라고 말할 수 있다.

결국 해당 물질에서 반사되는 빛을 감지하여 색상 정보를 얻을 수 있는 방법은 아래 그림과 식을 이용하게 된다.

[2. 트리, 힙, 그래프] 트리

꿀꺽람 — Wed, 18 Jan 2023 22:41:50 +0900

선형 자료 구조로 표현할 수 없는 대표적인 문제로 계층적 문제(hierarchical problem)와 순환 종속성(cyclic dependency) 문제가 있다.

회사의 조직도, 대학의 교과 과정 계층도 등은 계층적으로 데이터를 표현해야 한다. 이 때 사용하는 자료 구조는 트리 (tree)이다.

위 그림처럼 트리는 계층을 구성한다. 데이터가 저장된 부분은 노드(node)라고 부르고, 노드와 노드 사이를 잇는 선을 edge라고 부른다.

가장 맨 위에 나타나는 노드를 root node라고 한다.

트리의 기본 구조에 대한 요약이었고, 트리의 원소를 순회하는 방법은 세 가지로 나뉜다.

전위 순회 (preorder traversal)

이 방법은 현재 노드를 먼저 방문하고, 그 다음은 현재 노드의 왼쪽 하위 노드를, 마지막으로는 현재 노드의 오른쪽 하위 노드를 재귀적인 방식으로 방문한다.

preorder 방식을 코드로 구현하면 다음과 같이 구현할 수 있다.

static void preOrder(node* start)
{
    if(!start)
    	return;
    cout << start->position << ", ";
    preOrder(start->first);
    preOrder(start->second);
}

중위 순회 (in-order traversal)

중위 순회 방법은 왼쪽 노드를 먼저 방문하고, 현재 노드, 오른쪽 노드를 방문한다.

in-order 방식을 코드로 구현하면 다음과 같다.

static void inOrder(node* start)
{
    if(!start)
    	return;
        
    inOrder(start->first);
    cout << start->position << ", ";
    inOrder(start->second);
}

후위 순회 (post-order traversal)

이 방법은 두 자식 노드를 먼저 방문한 후, 현재 노드를 방문한다.

post-order 방식을 코드로 구현하면 다음과 같다.

static void postOrder(node* start)
{
    if(!start)
    	return;
        
    postOrder(start->first);
    postOrder(start->second);
    cout << start->position << ", ";
}

레벨 순서 순회 (level order traversal)

트리의 맨 위 레벨부터 아래 레벨까지, 왼쪽 노드에서 오른쪽 노드 순서로 방문한다.

레벨 순서 순회는 다음 코드와 같이 작성할 수 있다.

static void levelOrder(node* start){
    if(!start)
        return;

    queue<node*> q;
    q.push(start);

    while (!q.empty()){
        int size = q.size();
        for(int i = 0; i < size; i++){
            auto current = q.front();
            q.pop();

            cout << current->position << ", ";
            if(current->first)
                q.push(current->first);
            if(current->second)
                q.push(current->second);
        }
        cout << "\n";
    }
}

알고리즘 - 백준 11053 (가장 긴 증가하는 부분 수열)

꿀꺽람 — Wed, 18 Jan 2023 19:16:35 +0900

문제 링크: https://www.acmicpc.net/problem/11053

11053번: 가장 긴 증가하는 부분 수열

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오. 예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이

www.acmicpc.net

문제

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 Ai가 주어진다. (1 ≤ Ai ≤ 1,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

풀이 및 코드

입력 수열에서 가장 긴 증가하는 부분 수열을 구할 수 있는 방법을 표로 나타내면 다음과 같다.

[0]	[1]	[2]	[3]	[4]	[5]
10	20	10	30	20	50
1	2 (10, 20)	1	3 (10, 20, 30)	2 (10, 20)	4 (10, 20, 30, 50)

위 표를 풀어서 쓰면 다음과 같이 쓸 수 있다.

[0]이 포함되는 부분 수열 중 가장 긴 증가하는 부분 수열은 {10}으로 원소의 개수는 1개이다.

[1]이 포함되는 부분 수열 중 가장 긴 증가하는 부분 수열은 {10, 20}으로 원소의 개수는 2개이다.

[2]이 포함되는 부분 수열 중 가장 긴 증가하는 부분 수열은 {10}으로 원소의 개수는 1개이다.

이런 식으로 마지막 [5]이 포함되는 부분 수열 중 가장 긴 증가하는 부분 수열은 {10, 20, 30, 50}으로 원소의 개수는 4개이다.

결국,

1) 각 [i] 번째의 원소의 개수를 구하기 위해서는 [0] ~ [i - 1]까지의 원소들 중 [i] 번째의 원소보다 작은 것들을 뽑고,

2) 작은 것들 중 가장 큰 원소의 개수에 1을 더한 것과 같다.

위에 말로 풀어 쓴 식을 코드로 표현하면 다음과 같다.

#include <iostream>
using namespace std;

int input[1000];
int dp[1000];
int main(){
    int n;
    cin >> n;

    for(int i = 0; i < n; i++){
        cin >> input[i];
    }

    dp[0] = 1;
    int result = 1;
    for(int i = 1; i < n; i++){
        int temp = 0;
        dp[i] = 1;
        for(int j = 0; j < i; j++){
            if(input[i] > input[j]){
                if(temp < dp[j]){
                    temp = dp[j];
                    dp[i] = temp + 1;
                }
            }
        }
        if(result < dp[i])
            result = dp[i];
    }

    cout << result << endl;

    return 0;
}

https://github.com/haram1117/AlgorithmStudy/commit/d7649d19c48b70fb9a8ff6bc1fd679dbb6fa2196

DP11053 · haram1117/AlgorithmStudy@d7649d1

Show file tree Showing 7 changed files with 82 additions and 35 deletions.

github.com

알고리즘 - 백준 11052 (카드 구매하기)

꿀꺽람 — Tue, 17 Jan 2023 20:27:23 +0900

문제 링크: https://www.acmicpc.net/problem/11052

11052번: 카드 구매하기

첫째 줄에 민규가 구매하려고 하는 카드의 개수 N이 주어진다. (1 ≤ N ≤ 1,000) 둘째 줄에는 Pi가 P1부터 PN까지 순서대로 주어진다. (1 ≤ Pi ≤ 10,000)

www.acmicpc.net

문제

요즘 민규네 동네에서는 스타트링크에서 만든 PS카드를 모으는 것이 유행이다.

PS카드는 PS(Problem Solving)분야에서 유명한 사람들의 아이디와 얼굴이 적혀있는 카드이다. 각각의 카드에는 등급을 나타내는 색이 칠해져 있고, 다음과 같이 8가지가 있다.

전설카드
레드카드
오렌지카드
퍼플카드
블루카드
청록카드
그린카드
그레이카드

카드는 카드팩의 형태로만 구매할 수 있고, 카드팩의 종류는 카드 1개가 포함된 카드팩, 카드 2개가 포함된 카드팩, ... 카드 N개가 포함된 카드팩과 같이 총 N가지가 존재한다.

민규는 카드의 개수가 적은 팩이더라도 가격이 비싸면 높은 등급의 카드가 많이 들어있을 것이라는 미신을 믿고 있다. 따라서, 민규는 돈을 최대한 많이 지불해서 카드 N개 구매하려고 한다. 카드가 i개 포함된 카드팩의 가격은 Pi원이다.

예를 들어, 카드팩이 총 4가지 종류가 있고, P1 = 1, P2 = 5, P3 = 6, P4 = 7인 경우에 민규가 카드 4개를 갖기 위해 지불해야 하는 금액의 최댓값은 10원이다. 2개 들어있는 카드팩을 2번 사면 된다.

P1 = 5, P2 = 2, P3 = 8, P4 = 10인 경우에는 카드가 1개 들어있는 카드팩을 4번 사면 20원이고, 이 경우가 민규가 지불해야 하는 금액의 최댓값이다.

마지막으로, P1 = 3, P2 = 5, P3 = 15, P4 = 16인 경우에는 3개 들어있는 카드팩과 1개 들어있는 카드팩을 구매해 18원을 지불하는 것이 최댓값이다.

카드 팩의 가격이 주어졌을 때, N개의 카드를 구매하기 위해 민규가 지불해야 하는 금액의 최댓값을 구하는 프로그램을 작성하시오. N개보다 많은 개수의 카드를 산 다음, 나머지 카드를 버려서 N개를 만드는 것은 불가능하다. 즉, 구매한 카드팩에 포함되어 있는 카드 개수의 합은 N과 같아야 한다.

입력

첫째 줄에 민규가 구매하려고 하는 카드의 개수 N이 주어진다. (1 ≤ N ≤ 1,000)

둘째 줄에는 Pi가 P1부터 PN까지 순서대로 주어진다. (1 ≤ Pi ≤ 10,000)

출력

첫째 줄에 민규가 카드 N개를 갖기 위해 지불해야 하는 금액의 최댓값을 출력한다.

풀이 및 코드

각 i 별로 카드 i개를 갖기 위해 지불해야 하는 금액의 최댓값을 dp 배열에 저장해놓는다.

해당 예제에 대해 dp 배열을 작성해보면 다음과 같다.

1	5	6	7
1
max(5, 1+1) = 5
max(6, 5 + 1) = 6
max(7, 6 + 1, 5 + 5) = 10

P4에 대해서만 설명해보면,

4개의 카드가 들어있는 카드 팩 한개 (7)

3개의 카드가 들어있는 카드 팩 한개 + 1개의 카드가 들어있는 카드 팩 한개 (6 + 1)

2개의 카드가 들어있는 카드 팩 두개 (5 + 5)

이 세 경우 중 가장 큰 최댓값을 구하면 10이 나오게 된다.

이 과정을 코드로 나타내면 다음과 같다.

#include <iostream>
using namespace std;

int input[1000];
int dp[1000];
int main(){
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> input[i];
    }

    for(int i = 0; i < n; i++){
        dp[i] = input[i];
        for(int j = 0; j < float(i) / 2; j++){
            dp[i] = max(dp[i], dp[j] + dp[i - j - 1]);
        }
    }

    cout << dp[n - 1] << endl;

    return 0;
}

https://github.com/haram1117/AlgorithmStudy/commit/f3fb3b7149c700c83b3ff6463032570b8c418d75

DP11052 · haram1117/AlgorithmStudy@f3fb3b7

Show file tree Showing 7 changed files with 64 additions and 34 deletions.

github.com

[1. 리스트, 스택, 큐] 컨테이너 어댑터

꿀꺽람 — Tue, 17 Jan 2023 20:01:50 +0900

컨테이너 어댑터(container adaptor)

기존의 컨테이너를 변형하여 꼭 필요한 인터페이스만을 제공하여 만든 컨테이너로, C++에서 제공하는 컨테이너 어댑터는 std::stack, std::queue, std::priority_queue가 있다.

std::stack

std::stack은 std::deque을 기본 컨테이너로 사용한다.

데이터 처리와 보관을 위해 LIFO(Last In First Out, 후입선출) 구조를 사용하고 한쪽 끝에서만 데이터의 삽입과 삭제가 이루어진다.

벡터와 덱에서 이러한 기능을 기본적으로 지원하지만, 직접 스택처럼 사용하기에는 기능이 너무 많다.

그래서 의도하지 않은 동작과 코드를 잘못 작성하는 경우를 방지하기 위해 스택에 꼭 필요한 인터페이스만을 제공한다.

아래 코드에서 stack의 기본적인 함수들을 사용하였다.

#include <iostream>
#include <stack>
using namespace std;

int main(){
    stack<int> stack1;
    // deque에서의 push_back()함수를 사용하여 구현한다.
    stack1.push(1);
    stack1.push(2);
    stack1.push(3);

    cout << "stack1 size: " << stack1.size() << "\n"; // 출력 stack1 size: 3

    // 출력: 3 2 1 (LIFO)
    while(!stack1.empty()){
        cout << stack1.top() << "\t"; // deque에서의 back() 함수를 사용한다.
        stack1.pop(); // deque에서의 pop_back() 함수를 사용한다.
    }

    cout << "\n";

    cout << "stack1 size: " << stack1.size() << "\n"; // 출력 stack1 size: 0
}

stack에서 vector가 아닌 deque을 사용하는 이유는 원소 저장 공간을 재할당할 때 vector는 전체 원소를 이동해야 하기 때문이다. 그렇기에 deque을 사용하는 것이 효율적인데, 경우에 따라 vector나 list를 사용할 때도 존재한다.

다음과 같이 코드를 작성하면 vector나 list를 기본 컨테이너로 사용할 수 있다.

stack<int, std::vector<int>> stk;
stack<int, std::list<int>> stk;

스택의 모든 연산은 시간 복잡도가 O(1)이다. 스택에서 기본 컨테이너로 함수 호출을 전달하는 과정은 인라인(inline) 형식으로 호출될 수 있다.

std::queue

stack은 LIFO 구조를 사용하지만 queue는 FIFO 구조를 사용한다.

std::stack과 같은 이유로 std::deque을 기본 컨테이너로 사용하고, stack과 같은 방식으로 모든 함수는 시간 복잡도가 O(1)이다.

각 함수들은 다음과 같이 사용할 수 있다.

#include <iostream>
#include <queue>
using namespace std;

int main(){
    queue<int> queue1;

    // deque의 push_back()을 사용한다.
    queue1.push(1);
    queue1.push(2);
    queue1.push(3);

    cout << "queue1 size: " << queue1.size() << "\n"; // 출력: queue1 size: 3

    // 출력: 1 2 3 (FIFO)
    while (!queue1.empty()){
        cout << queue1.front() << "\t";
        queue1.pop();
    }

    cout << "\nqueue1 size: " << queue1.size(); // 출력: queue1 size: 0
}

std::priority_queue

priority queue는 heap 구조를 제공한다.

heap은 컨테이너에서 가장 작거나 큰 원소에 빠르게 접근할 수 있는 자료구조로, 최소/최대 원소에 접근하는 동작은 O(1)의 시간복잡도를 갖고 원소 삽입은 O(logN) 시간복잡도로 동작한다.

stack과 queue와 달리 priority_queue는 std::vector를 기본 컨테이너로 사용한다. (필요한 경우 변경 가능하다.)

기본적으로는 비교자 std::less를 사용하여 최대 힙으로 생성되며, 이 또한 비교자를 이용하면 변경할 수 있다.

새로운 원소를 삽입할 때마다 최대 또는 최소 원소가 최상위에 위치하도록 설정해야 하기 때문에 heapity 알고리즘을 구현해야 한다. (O(logn))

다음 코드와 같이 간단하게 priority queue를 사용할 수 있다.

#include <iostream>
#include <queue>
using namespace std;

int main(){
    priority_queue<int> priorityQueue1;

    priorityQueue1.push(1);
    priorityQueue1.push(2);
    priorityQueue1.push(3);
    priorityQueue1.push(5);
    priorityQueue1.push(7);
    priorityQueue1.push(2);
    priorityQueue1.push(20);
    priorityQueue1.push(1);

    cout << "priorityQueue1 size: " << priorityQueue1.size() << "\n"; // 출력: priorityQueue1 size: 3

    // 출력: 20      7       5       3       2       2       1       1
    while (!priorityQueue1.empty()){
        cout << priorityQueue1.top() << "\t";
        priorityQueue1.pop();
    }

    cout << "\npriorityQueue1 size: " << priorityQueue1.size(); // 출력: priorityQueue1 size: 0


    priority_queue<int, vector<int>, greater<int>> priorityQueue2;

    priorityQueue2.push(1);
    priorityQueue2.push(2);
    priorityQueue2.push(3);
    priorityQueue2.push(5);
    priorityQueue2.push(7);
    priorityQueue2.push(2);
    priorityQueue2.push(20);
    priorityQueue2.push(1);

    cout << "priorityQueue1 size: " << priorityQueue2.size() << "\n"; // 출력: priorityQueue2 size: 3

    // 출력: 1       1       2       2       3       5       7       20
    while (!priorityQueue2.empty()){
        cout << priorityQueue2.top() << "\t";
        priorityQueue2.pop();
    }

    cout << "\npriorityQueue2 size: " << priorityQueue2.size(); // 출력: priorityQueue2 size: 0

}

경우에 따라 다른 컨테이너를 사용해야 할 텐데, 어떤 경우에 어떤 컨테이너가 맞는지 알기 위해 작은 프로토 타입을 만들고 성능을 측정하는 과정도 필요하다.

https://quick-bench.com/

Quick C++ Benchmarks

Quickly benchmark C++ runtimes

quick-bench.com

벤치마킹을 쉽게 수행할 수 있는 벤치마킹 프로그램의 도움을 받아 결과를 비교해볼 수 있다.

[1. 리스트, 스택, 큐] C++ std::deque

꿀꺽람 — Sun, 15 Jan 2023 23:21:08 +0900

std::deque

벡터는 가변 길이 배열이고, push_front() 또는 pop_front() 같은 함수는 비용이 많이 든다. (다 하나씩 밀어줘야 함)

std::deque를 통해 이런 단점을 극복할 수 있다. (double-ended queue)

덱(deque)의 구조

- push_front(), pop_front(), push_back(), pop_back() 동작이 O(1) 시간 복잡도로 동작해야 한다.
- 모든 원소에 대해 임의 접근 동작이 O(1) 시간 복잡도로 동작해야 한다.
- 덱 중간에서 원소 삽입 또는 삭제는 O(n) 시간 복잡도로 동작해야 하며, 실제로는 최대 n/2 단계로 동작한다. (n: 덱의 크기)

- 덱은 자료구조가 벡터와 비슷하지만 앞쪽과 뒤쪽으로 보두 확장할 수 있다.

- 원소 삽입 시 해당 위치에서 가장 가까운 끝 쪽으로 나머지 원소를 이동하기에 n/2 단계의 시간 복잡도를 갖는다.

- 크기가 같은 여러 개의 메모리 청크를 사용하여 데이터를 저장한다.

- 청크의 인덱스 및 크기를 이용하여 특정 위치의 원소가 어느 청크에 저장되어 있는지 알 수 있다.

- 벡터와 리스트에서 제공되는 함수를 조합한 것 이상의 기능을 제공한다. (capacity() 함수는 지원되지 않는다.)

- 임의 접근 반복자도 제공된다.

예제 코드는 다음과 같다.

#include <iostream>
#include <deque>
using namespace std;
int main(){
    deque<int> deq = {1, 2, 3, 4, 5};
    deq.push_front(0); // {0, 1, 2, 3, 4, 5}
    deq.push_back(6); // {0, 1, 2, 3, 4, 5, 6}

    deq.insert(deq.begin() + 2, 10); // {0, 1, 10, 2, 3, 4, 5, 6}

    deq.pop_back(); // {0, 1, 10, 2, 3, 4, 5}
    deq.pop_front(); // {1, 10, 2, 3, 4, 5}

    deq.erase(deq.begin() + 1); // {1, 2, 3, 4, 5}

    deq.erase(deq.begin() + 3, deq.end()); // {1, 2, 3}

    for(auto i : deq)
        cout << i << " ";
    return 0;
}

덱은 데이터 맨 뒤와 맨 앞에서도 매우 빠르게 원소의 삽입과 삭제가 가능하다.

또한 데이터 중간에서의 삽입 또는 삭제에 대한 시간복잡도는 벡터와 같지만, 실제로는 벡터보다 약간 더 빠르다.

김치만두 먹고 공부하기

[2. 트리, 힙, 그래프] 힙

[2. 트리, 힙, 그래프] 균형 트리, n항 트리

[2. 트리, 힙, 그래프] 이진 검색 트리(Binary Search Tree)

[펄어비스 x 경희 소융] 프로젝트 회고

[Computer Vision] 2. Camera, Geometry and Photometry

Camera

1. Camera Array

2. Lens Array (Integral Imaging)

3. Digital Holography (CGH)

4. Normal Sensor (Photon-X)

5. Structured Light (Stereo Reconstruction)

카메라는 Accuracy가 낮다

6. Kinect V1

7. Time of Flight

8. Laser Scanning

Color Camera

Digital Image

Image Formation

Pinhole Camera

Camera obscura

Projective Geometry

Vanishing points and lines

Image Geometry

Image Photometry

[2. 트리, 힙, 그래프] 트리

알고리즘 - 백준 11053 (가장 긴 증가하는 부분 수열)

알고리즘 - 백준 11052 (카드 구매하기)

[1. 리스트, 스택, 큐] 컨테이너 어댑터

std::stack

std::queue

std::priority_queue

[1. 리스트, 스택, 큐] C++ std::deque

std::deque