알고리즘 유형 트레이너

queue<int> q;
visited[start] = true;
q.push(start);
while (!q.empty()) {
    int u = q.front(); q.pop();
    for (int v : adj[u]) {
        if (!visited[v]) {
            visited[v] = true;
            q.push(v);
        }
    }
}

int dp[1001];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= N; i++)
    dp[i] = dp[i-1] + dp[i-2];

sort(meetings.begin(), meetings.end(),
     [](auto& a, auto& b){ return a.second < b.second; });
int cnt = 0, last = 0;
for (auto& [s, e] : meetings) {
    if (s >= last) { cnt++; last = e; }
}

// lower_bound 직접 구현
int lo = 0, hi = n - 1, ans = n;
while (lo <= hi) {
    int mid = (lo + hi) / 2;
    if (arr[mid] >= target) { ans = mid; hi = mid - 1; }
    else lo = mid + 1;
}

// 파라메트릭 서치
long long lo = 1, hi = 1e9, ans = 0;
while (lo <= hi) {
    long long mid = (lo + hi) / 2;
    if (check(mid)) { ans = mid; lo = mid + 1; }
    else hi = mid - 1;
}

int lo = 0, sum = 0, ans = INT_MAX;
for (int hi = 0; hi < n; hi++) {
    sum += arr[hi];
    while (sum >= S) {
        ans = min(ans, hi - lo + 1);
        sum -= arr[lo++];
    }
}

int sum = 0, maxSum;
for (int i = 0; i < K; i++) sum += arr[i];
maxSum = sum;
for (int i = K; i < n; i++) {
    sum += arr[i] - arr[i - K];
    maxSum = max(maxSum, sum);
}

vector<long long> prefix(n + 1, 0);
for (int i = 0; i < n; i++)
    prefix[i + 1] = prefix[i] + arr[i];
// 구간 [l, r] 합 = prefix[r+1] - prefix[l]

long long power(long long a, long long n, long long mod) {
    if (n == 0) return 1;
    long long half = power(a, n / 2, mod);
    half = half * half % mod;
    if (n % 2) half = half * a % mod;
    return half;
}

// STL nth_element가 퀵 셀렉트 구현
nth_element(arr.begin(), arr.begin() + k, arr.end());
// arr[k]가 k번째로 작은 원소로 확정됨

stack<char> st;
for (char c : s) {
    if (c == '(') st.push(c);
    else {
        if (st.empty()) { cout << "NO"; return; }
        st.pop();
    }
}
cout << (st.empty() ? "YES" : "NO");

deque<int> dq;  // 인덱스 저장
for (int i = 0; i < n; i++) {
    while (!dq.empty() && dq.front() <= i - K) dq.pop_front();
    while (!dq.empty() && arr[dq.back()] >= arr[i]) dq.pop_back();
    dq.push_back(i);
    if (i >= K - 1) cout << arr[dq.front()] << ' ';
}

unordered_map<int, int> seen;
for (int i = 0; i < n; i++) {
    int need = target - arr[i];
    if (seen.count(need)) {
        cout << seen[need] << " " << i;
        return;
    }
    seen[arr[i]] = i;
}

bool used[MAX];
vector<int> perm;

void solve(int depth) {
    if (depth == N) { /* perm 출력 */ return; }
    for (int i = 1; i <= N; i++) {
        if (used[i]) continue;
        used[i] = true;
        perm.push_back(i);
        solve(depth + 1);
        perm.pop_back();
        used[i] = false;
    }
}

// dp[mask][i] = mask 상태에서 i에 도착하는 최소 비용
dp[1][0] = 0;
for (int mask = 1; mask < (1 << N); mask++)
    for (int u = 0; u < N; u++) {
        if (!(mask & (1 << u))) continue;
        for (int v = 0; v < N; v++) {
            if (mask & (1 << v)) continue;
            int next = mask | (1 << v);
            dp[next][v] = min(dp[next][v], dp[mask][u] + dist[u][v]);
        }
    }

priority_queue<pii, vector<pii>, greater<pii>> pq;
dist[start] = 0;
pq.push({0, start});
while (!pq.empty()) {
    auto [d, u] = pq.top(); pq.pop();
    if (d > dist[u]) continue;
    for (auto [v, w] : adj[u]) {
        if (dist[u] + w < dist[v]) {
            dist[v] = dist[u] + w;
            pq.push({dist[v], v});
        }
    }
}

vector<long long> dist(N+1, INF);
dist[start] = 0;
for (int i = 0; i < N-1; i++)
    for (auto& [u, v, w] : edges)
        if (dist[u] != INF && dist[u] + w < dist[v])
            dist[v] = dist[u] + w;
// 음수 사이클: 한 번 더 돌려서 갱신되면 존재

for (int k = 1; k <= N; k++)
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= N; j++)
            dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

queue<int> q;
for (int i = 1; i <= N; i++)
    if (indeg[i] == 0) q.push(i);
while (!q.empty()) {
    int u = q.front(); q.pop();
    result.push_back(u);
    for (int v : adj[u])
        if (--indeg[v] == 0) q.push(v);
}
// result.size() != N → 사이클 존재

sort(edges.begin(), edges.end(), [](auto& a, auto& b){ return a.w < b.w; });
int total = 0, cnt = 0;
for (auto& [u, v, w] : edges) {
    if (unite(u, v)) {
        total += w;
        if (++cnt == N - 1) break;
    }
}

int parent[MAX], rnk[MAX];
void init(int n) { for (int i = 0; i <= n; i++) parent[i] = i, rnk[i] = 0; }
int find(int x) { return parent[x] == x ? x : parent[x] = find(parent[x]); }
bool unite(int a, int b) {
    a = find(a); b = find(b);
    if (a == b) return false;
    if (rnk[a] < rnk[b]) swap(a, b);
    parent[b] = a;
    if (rnk[a] == rnk[b]) rnk[a]++;
    return true;
}

vector<int> getPi(string& p) {
    int m = p.size();
    vector<int> pi(m, 0);
    int j = 0;
    for (int i = 1; i < m; i++) {
        while (j > 0 && p[i] != p[j]) j = pi[j-1];
        if (p[i] == p[j]) pi[i] = ++j;
    }
    return pi;
}

struct Trie {
    int children[26] = {};
    bool isEnd = false;
} nodes[MAX_NODES];
int cnt = 1;

void insert(const string& s) {
    int cur = 0;
    for (char c : s) {
        int idx = c - 'a';
        if (!nodes[cur].children[idx])
            nodes[cur].children[idx] = cnt++;
        cur = nodes[cur].children[idx];
    }
    nodes[cur].isEnd = true;
}

int tree[4 * MAX];
void build(int node, int s, int e, int arr[]) {
    if (s == e) { tree[node] = arr[s]; return; }
    int mid = (s + e) / 2;
    build(2*node, s, mid, arr);
    build(2*node+1, mid+1, e, arr);
    tree[node] = tree[2*node] + tree[2*node+1];
}
int query(int node, int s, int e, int l, int r) {
    if (r < s || e < l) return 0;
    if (l <= s && e <= r) return tree[node];
    int mid = (s + e) / 2;
    return query(2*node, s, mid, l, r) + query(2*node+1, mid+1, e, l, r);
}

int sp[LOG][MAX];
void build(int arr[], int n) {
    for (int i = 0; i < n; i++) sp[0][i] = arr[i];
    for (int k = 1; (1 << k) <= n; k++)
        for (int i = 0; i + (1 << k) <= n; i++)
            sp[k][i] = min(sp[k-1][i], sp[k-1][i + (1 << (k-1))]);
}
int query(int l, int r) {
    int k = __lg(r - l + 1);
    return min(sp[k][l], sp[k][r - (1 << k) + 1]);
}

vector<bool> is_prime(N+1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i <= N; i++)
    if (is_prime[i])
        for (int j = i*i; j <= N; j += i)
            is_prime[j] = false;

vector<int> sorted_vals(arr, arr + n);
sort(sorted_vals.begin(), sorted_vals.end());
sorted_vals.erase(unique(sorted_vals.begin(), sorted_vals.end()), sorted_vals.end());

for (int i = 0; i < n; i++)
    arr[i] = lower_bound(sorted_vals.begin(), sorted_vals.end(), arr[i])
             - sorted_vals.begin();