옳은 길로 바르게

Dijkstra: 최단거리, 근데 이제 음수가 아닌 가중치를 곁들인.

snp0301 — Wed, 5 Nov 2025 16:44:30 +0900

2025년 11월 5일

Dijkstra는 가중치를 고려해 어떤 노드에서 다른 노드의 최단거리를 구할 때 사용할 수 있다.
음수 가중치나 싸이클이 있을 때는 사용할 수 없다.

BFS에서 queue에 enqueue할 때, 같은 거리를 가진 케이스들이 연속적으로 enqueue 됨을 보장해야 하는 것처럼
Dijkstra에서는 priority_queue(heap)을 사용해 지금 가진 정보가 최신 정보임을 보장해야 한다.

즉, pq를 믿어야 동작한다. pq는 greater<>와 같은 비교 기준을 가지고 노드를 배치하기 때문에

기준을 잘 정하고
기준에 맞게 heapPush 해야한다.

계속 dist 배열을 빼먹고 있다는 것은 Dijkstra를 이해하지 못했기 때문에 생기는 일이다.

mergeSort

snp0301 — Mon, 13 Oct 2025 19:07:37 +0900

Time Complexity

O(n log n)

Code


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

void merge(vector<int>& vec, int left, int mid, int right){
    int i,j,k;
    int fIdx = mid - left + 1;
    int sIdx = right - mid;

    vector<int> leftVc(fIdx), rightVc(sIdx);

    for(i=0; i<fIdx; ++i) leftVc[i] = vec[left+i];
    for(j=0; j<sIdx; ++j) rightVc[j] = vec[mid+1+j];

    i=0;
    j=0;
    k=left;

    while (i < fIdx && j <sIdx){
        if (leftVc[i] <= rightVc[j]){
            vec[k] = leftVc[i];
            ++i;
        }
        else{
            vec[k] = rightVc[j];
            ++j;
        }
        ++k;
    }

    while (i < fIdx){
        vec[k] = leftVc[i];
        ++i;
        ++k;
    }

    while (j < sIdx){
        vec[k] = rightVc[j];
        ++j;
        ++k;
    }
}

void mergeSort(vector<int>& vec, int left, int right){
    if (left <right){ // base case: size가 1인 경우 left == right가 true이므로 재귀 종료.
        int mid = left + (right - left) / 2;

        mergeSort(vec,left,mid);
        mergeSort(vec,mid+1,right);

        merge(vec, left, mid, right);
    }

}

binarySearch

snp0301 — Sun, 12 Oct 2025 16:39:23 +0900

Use binarySearch to find an element in sorted or monotonic space.

#include <iostream>
#include <vector>

using namespace std;

int binarySearch(vector<int> &arr, int x){
    int start = 0;
    int end = (int)arr.size() - 1;
    while (start <= end){
        int mid = start + (end - start) / 2;
        if (arr[mid] == x) return mid; // if found, return that index
        if (arr[mid] < x) start = mid + 1; // if x is greater than the middle one, ignore left half
        else end = mid - 1; // if x is smaller than the middle one, ignore right half
    }

    return -1; // if we couldn't find the element, return -1 or any failure sign code
}

Both average and worst case has O(log N) time complexity.

Is ++i better than i++?

snp0301 — Sat, 11 Oct 2025 21:50:11 +0900

Assuming that prefix and postfix operations perform the same computation,
++i is generally more efficient than i++ in terms of cost.

Since i++ requires storing the original value in a temporary register, ++i is slightly cheaper.

`++i`

    add rax, 1        ; i = i + 1

`i++`

    mov rcx, rax      ; old = i   (temporary value)
    add rax, 1        ; i = i + 1 (original value)

std::array vs std::vector

snp0301 — Fri, 10 Oct 2025 21:29:34 +0900

해당 포스트는 cppreference.com을 참조해 작성했습니다.

std::array

a container that encapsulates fixed size arrays.
it doesn't decay to T* automatically.

template<
    class T,
    std::size_t N
> struct array;

std::vector

a sequence container that encapsualteds dynamic size arrays.
Except for std::vector<bool> partial specialization, the element are stored contiguously, which means that elements can be accessed not only through iterators, but also using offsets to regular pointers to elements.
Vectors usually occupy more space than static arrays, because more memory is allocated to handle future growth. This way a vector does not need to reallocate each time an element is inserted, buy only when the additional memory is exhausted.

template<
    class T,
    class Allocator = std::allocator<T>
> class vector;