정화 코딩

[C++] 상어의 저녁식사 (백준 1671번)

jungh150c — Tue, 27 Jan 2026 16:43:40 +0900

https://www.acmicpc.net/problem/1671

왼쪽 그룹을 먹는 상어, 오른쪽 그룹을 먹히는 상어라고 생각해보자.

일단 한 상어가 최대 두 개의 상어만 먹을 수 있다고 했으니, 왼쪽 그룹에는 상어 하나 당 두 개의 노드를 두고 (총 2 * n개) 오른쪽 그룹에는 상어 하나 당 하나의 노드를 둔 다음 (총 n개), 먹을 수 있는 관계인 경우에 연결해주면 될 것 같다.

참고로, "이미 잡아먹힌 상어는 다른 상어들을 잡아먹을 수 없다"는 조건은 크게 신경 쓸 필요가 없다. 매칭 결과를 보고 먹히는 쪽부터 실행한다고 생각할 수 있다.

이제 여기서 한 가지만 더 주의하면 된다. (처음에 이걸 고려를 못 했는데 예제가 친절해서 금방 알아차릴 수 있었다.)

두 상어가 크기, 속도, 지능이 전부 동일하면 서로 잡아먹을 수 있기 때문이다.

나는 이를 처리하기 위해서 전부 동일한 쌍의 경우에는, 번호가 작은 상어가 잡아먹을 수 있다고 임의로 정해두고 간선을 연결하였다.

// Reference: green55 teamnote
// https://github.com/green5555/Teamnote/blob/master/TeamNote/BiMatch.cpp

#include <bits/stdc++.h>
using namespace std;

const int MAX = 151;
struct BiMatching {
    vector<int> adj[MAX+5];
    int iter, A[MAX+5], B[MAX+5], was[MAX+5];

    bool dfs(int u) {
        was[u] = iter;
        for (int v : adj[u]) {
            if (B[v] == -1) {
                A[u] = v;
                B[v] = u;
                return true;
            }
        }
        for (int v : adj[u]) {
            if (was[B[v]] != iter && dfs(B[v])) {
                A[u] = v;
                B[v] = u;
                return true;
            }
        }
        return false;
    }

    int biMatch(int n=MAX) {
        fill(A, A+n, -1);
        fill(B, B+n, -1);
        fill(was, was+n, 0);
        iter = 0;
        int res = 0;
        while (true) {
            iter++;
            int add = 0;
            for (int i = 0; i < n; i++) {
                if (A[i] == -1 && dfs(i)) {
                    add++;
                }
            }
            if (add == 0) {
                break;
            }
            res += add;
        }
        return res;
    }
};

void solve() {
    BiMatching bm;

    int n;
    cin >> n;

    vector<int> a(n);
    vector<int> b(n);
    vector<int> c(n);
    for (int i = 0; i < n; i++) cin >> a[i] >> b[i] >> c[i];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) continue;
            if (a[i] == a[j] && b[i] == b[j] && c[i] == c[j]) {
                if (i < j) {
                    bm.adj[i].push_back(j + 100);
                    bm.adj[i + 50].push_back(j + 100);
                }
            } else if (a[i] >= a[j] && b[i] >= b[j] && c[i] >= c[j]) {
                bm.adj[i].push_back(j + 100);
                bm.adj[i + 50].push_back(j + 100);
            }
        }
    }

    cout << n - bm.biMatch() << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

뉴비의 2025 ICPC Seoul Regional 예선 후기

jungh150c — Sun, 7 Dec 2025 01:35:29 +0900

서론

처음이자 마지막으로 나가는 ICPC이다. 졸업하기도 하고 나이도 그렇고 올해가 마지막 기회다.

PS를 시작한 건 최근은 아니지만 열심히 하기 시작한 게 최근이라서 뉴비라고 적었다. 1년도 안 된 것 같다. 사실 딱히 열심히도 아닌 것 같기도... 하핫

1년은 무슨 반년 정도 되는 것 같넹

작년에는 ICPC에 관심이 없었던 것 같다. 암튼 열심히 하다 보니 나가고 싶어져서 팀을 만들었다.

팀은 celina324, g_grain, jungh150 이렇게 구성되어 있고, 지지난번 SUAPC에도 이렇게 나갔던 것 같다.

워낙 은채랑 지은이 둘 다 학교에서 잘하는 편이기 때문에 1등을 못할 것 같다는 생각은 없었고, 그래서 가장 중요한 건 학교 별 1등 커트라인 넘기기였다. 그래서 골드 다 풀기를 목표로 계속 팀연습을 했었다.

대회

일단 한국어 문제 먼저 셋이 하나씩 읽어보기로 했다.

그런데 프린트된 문제지가 오는 데 15분은 걸려서 그동안 작은 노트북 화면에서 화면 분할로 옹기종기 모여서 봤다.

A. 최적의 분할 1WA (0:17)

각자 문제를 읽어보다가 celina324가 A가 쉬워 보인다고 하면서 이렇게 풀면 되지 않냐고 물어봤다.

사실 뒤늦게 후기를 적고 있는 상태고 틀렸던 코드는 따로 저장해두지 않아서 잘 기억이 안 나긴 하지만, 대충 앞에서 보면서 최소 인덱스가 달라질 때 자르는 풀이였던 것 같다.

여기서부터 좀 잘못됐는데... 일단 구현에 그나마 자신 있던 jungh150가 코드를 짜기로 해서 짰는데, 사실 난 다른 문제를 보고 있었어서 이 문제를 제대로 이해하지 못한 상태였고 그냥 celina324가 말한 대로 구현을 했다.

그렇게 제출해서 한번 틀린 다음에 문제부터 다시 읽고 풀이를 생각해 보니 반례를 금방 찾을 수 있었다. 내가 코드를 짜기 전에 문제를 읽고 같이 풀이 검증을 좀 하고 짜야 했는데 그러지 못해서 좀 미안했다.

A. 최적의 분할 CORRECT (0:42)

암튼 그래서 jungh150가 A 디버깅을 계속하고, celina324와 g_grain은 같이 F를 보고 있었던 것 같다.

어떻게 풀까 고민을 좀 하다가 다시 보니 n이 3000밖에 안 되길래 n 제곱 dp로 해결하면 되겠다 싶어서 바로 그렇게 구현해서 맞았다.

▼코드

#include <bits/stdc++.h>
using namespace std;

void solve() {
    int n;
    cin >> n;

    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    vector<int> b(n);
    for (int i = 0; i < n; i++) cin >> b[i];

    vector<vector<int>> adp(n, vector<int>(n));
    vector<vector<int>> bdp(n, vector<int>(n));

    for (int i = 0; i < n; i++) {
        int minidx = i;
        for (int j = i; j < n; j++) {
            adp[i][j] = minidx;
            if (a[j] < a[minidx]) {
                minidx = j;
                adp[i][j] = minidx;
            }
        }
    }

    for (int i = 0; i < n; i++) {
        int minidx = i;
        for (int j = i; j < n; j++) {
            bdp[i][j] = minidx;
            if (b[j] < b[minidx]) {
                minidx = j;
                bdp[i][j] = minidx;
            }
        }
    }

    int ans = 0;
    int s = 0;
    while (s < n) {
        for (int e = n - 1; e >= 0; e--) {
            if (adp[s][e] == bdp[s][e]) {
                s = e + 1;
                ans++;
                break;
            }
        }
    }

    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

F. Inverse Look-and-Say 1WA (0:59)

A를 풀고 나서 F를 보고 있던 celina324와 g_grain 쪽으로 갔더니 간단히 문제 설명을 해줬다. 둘은 그냥 쭉 읽어보면서 풀면 쉬운데 입력 크기가 너무 커서 어떻게 해야 되는지 모르겠다며 규칙을 찾아야 되나 고민하고 있었다.

입력을 봤는데 문자열로 읽는다 쳤을 때 길이가 1000밖에 안되어서 왜 고민 중인 거지? 싶었다. 그래서 그냥 읽으면서 확인하면 되는 거 아니냐고 물어보니 둘이 엥 그러네??? 했다.

그래서 다시 jungh150가 컴퓨터 쪽으로 와서 풀었는데 틀렸다.

F. Inverse Look-and-Say 3WA CORRECT (1:33)

다 같이 디버깅을 하다가 celina324는 I를 보러 가고 jungh150와 g_grain이 F 디버깅을 했다.

위에서 말했듯 좀 시간이 지난 뒤에 후기를 적는 거라 어느 순간에 뭘 고쳐서 제출했는지 정확히는 기억이 안 나지만 대략적인 흐름은 이랬다.

jungh150가 아! 이런 경우도 생각해야 되네 하고 제출하고 틀리고

또 jungh150가 아 이거 때문인가? 하고 제출하고 틀리고

g_grain이 아!! 0이면 어쩌구 저쩌구 해서 jungh150가 아 맞네! 하고 제출하고 틀리고

jungh150가 아 0일 때 이것도 처리해야 되네 하고 제출하고 맞았다.

ㅋㅋㅋ

▼코드

#include <bits/stdc++.h>
using namespace std;

void solve() {
    string s;
    cin >> s;

    int n = s.size();

    if (n % 2 == 1) {
        cout << -1 << '\n';
        return;
    }

    string ans = "";
    for (int i = 0; i < n; i += 2) {
        char a = s[i];
        char b = s[i + 1];
        if (a == '0') {
            cout << -1 << '\n';
            return;
        }
        if (b == '0' && i == 0) {
            cout << -1 << '\n';
            return;
        }
        if (i >= 2 && b == s[i - 1]) {
            cout << -1 << '\n';
            return;
        }
        for (int j = 0; j < a - '0'; j++) ans += b;
    }
    
    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

I. 이차 방정식 CORRECT (2:47)

풀고 나서 다 같이 I를 봤다. 진짜 어떻게 푸는 건지 감이 안 왔다.

브루트포스가 가능할 것 같기는 한데, 탐색 범위를 구하는 것도 어려웠다.

느낌 상 이것까지 풀어야 본선 진출할 수 있을 것 같은데 감도 안 잡히니까 너무 불안했다.

내 기억이 맞다면 진짜 하나도 모르겠어서 다른 문제도 살짝 들낙해봤던 것 같은데 슼보를 보고 다시 돌아왔던 것 같다.

일단 뭐라도 해보자 싶어서 jungh150는 규칙이 보일까 싶어 탐색 범위를 널널하게 잡은 브루트포스 코드를 짜서 돌려보고 있었고, g_grain과 celina324는 옆에서 뭔가 엄청 열심히 적고 있었다.

g_grain이 근의 공식에서 (p^2-4kp) 가 제곱수가 되려면 p에 대한 이차 함수를 그려봤을 때 p=2k 대칭이니까 p의 합은 결국 2k * (p의 개수)라는 엄청난 발견을 해냈다!

그 말을 들은 멍청한 jungh150가 오 대박!! 그러네!! 천재당 그럼 이제 어케 하지?를 시전하고 있을 때, celina324가 자기가 규칙을 찾은 것 같다면서 내 코드를 돌려볼 수 있냐고 물어봤다. 그래서 celina324가 불러주는 예제들을 넣어보니 전부 다 잘 나오는 거다!!

celina324한테 어떻게 한거냐고 물어보니까 뭐라고 설명해줬는데 사실 잘 기억이 안 난다. 너무 흥분한 상태이기도 하고 시간이 많이 남은 상황은 아니었어서 마음이 급해서 이해가 잘 안 됐다.

그래서 그냥 답을 어떻게 구하면 되는 건지 물어봐서 jungh150가 그걸 그대로 구현해서 냈고 맞았다.

솔직히 기대 안 하고 냈는데 한 번에 맞아서 깜짝 놀랐고 도파민이 미쳤었고 손이 떨렸었다. 시간도 13분밖에 안 남은 상태로 맞아서 더 그랬다.

다 같이 은채 복복복 삼만번 정도 하고 나서 슼보를 봤더니 우리 학교 중에 3솔 한 팀이 없었기 때문에 본선 진출하겠다고 생각하고 남은 시간을 편하게 보냈던 것 같다.

▼코드

#include <bits/stdc++.h>
using namespace std;

void solve() {
    long long k;
    cin >> k;

    long long n = 4 * k * k;
    vector<long long> a;
    for (long long x = 1; x < sqrt(n) + 1; x++) {
        if (n % x == 0) {
            if ((x + n/x) % 2 == 0) {
                a.push_back(x);
                a.push_back(n / x);
            }
        }
    }

    long long sz = a.size();
    cout << sz << ' ' << 2 * k * sz << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

그 당시 지은이랑 은채가 한바닥 썼던 증명 ㅜㅜ 은채도 마지막에 손 떨렸대

대회 후에 (사실 방금) 다시 증명을 해봤다. 좀 간단히 정리해보겠다.

우선 문제에 나와있는 방정식인 x^2 + px + kp = 0에 근의 공식을 적용한다. 근이 정수여야 하므로 그 식에서 루트 안에 있는 항이 제곱수여야 한다.

참고로,

p가 짝수이면 p^2은 4의 배수고, 루트 안의 항이 4의 배수기 때문에 루트 벗겨도 짝수고, 분자가 전부 짝수여서 전체는 정수

p가 홀수이면 p^2 홀수고 -4kp는 짝수니까 둘을 더한 건 홀수로, 루트 벗겨도 홀수고, 분자가 홀수+홀수여서 짝수니까 전체는 정수

따라서, 루트 안의 항이 제곱수이기만 하면 근은 항상 정수를 만족한다.

(이걸 대회 때는 증명하지 못했는데 자연스럽게 성립하는 거여서 다행이었다.)

루트 안에 있는 항이 제곱수여야 한다는 것을 p^2 - kp = q^2 (q는 정수) 라고 표현한다.

여기서 완전제곱으로 묶기 위해서 4k^2을 더해주고 빼준다. 그러면 (p - 2k)^2 이런 식으로 묶이게 되고, 4k^2은 우항으로 넘긴다.

좌항인 (p - 2k)^2 - q^2에 합차 공식을 적용하면 (p - 2k + q)(p - 2k - q) = 4k^2 이런 식으로 정리할 수 있다.

어느 정도 식 정리는 되었는데, 좀 더 편하게 보기 위해서 p - 2k = p' 라고 치환해보자.

p가 정수니까 p'도 정수여야 하고, q도 정수이다. 두 정수의 곱이 4k^2이라는 것은 둘은 서로 쌍이 되는 4k^2의 약수라는 것이다.

단, 이 두 약수의 차이는 짝수여야 한다. 두 수의 차이가 2q이기 때문이다.

따라서, 4k^2의 약수 쌍(둘 다 4k^2으로 나눠지면서 곱하면 4k^2이 되는 두 수)들을 보면서 차가 짝수인 수들의 개수를 세면 된다.

▼대회 이후 수정한 코드

#include <bits/stdc++.h>
using namespace std;

void solve() {
    long long k;
    cin >> k;

    long long n = 4 * k * k;
    long long cnt = 0;
    for (long long x = 1; x < sqrt(n) + 1; x++) {
        if (n % x == 0) {
            if (abs(n/x - x) % 2 == 0) cnt += 2;
        }
    }

    cout << cnt << ' ' << 2 * k * cnt << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

대회 종료 12분 전 스코어보드(프리즈 상태)이다. 이때는 106등이었다.

대회 후

최종 스코어보드이다. 84등으로 마무리했고, 학교 1등으로 본선에 진출하게 되었다.

그리고 학교별 1등 커트라인은 2솔이었다. I를 못 풀어도 갈 수 있었기에 은채는 살짝 아쉬워했지만 나는 그래도 3솔로 당당히? 갈 수 있어서 좋았다!!!

제출 기록

후기

A는 예상보다 티어가 살짝 높았는데 I가 예상보다 좀 낮았다. 나는 수학을 못하는 것 같다.

ICPC 예선을 참여하면서 포기한 것들이 있는데, 그래도 본선에 나갈 수 있어서 후회는 없고 다행인 것 같다.

본선 후기로 빨리 써야 하는뎅

[C++] 열혈강호 5 (백준 11408번) - 최소 비용 최대 유량 (Min Cost Max Flow)

jungh150c — Sat, 6 Dec 2025 00:18:04 +0900

https://www.acmicpc.net/problem/11408

기본적인 최대 유량 문제 풀듯이 하되, 각 단계마다 현재 잔여 그래프에서 최단 거리 알고리즘을 이용해 최소 비용 증가 경로를 찾고, 그 경로로 유량을 흘려준다. 최단 거리를 구할 때는 벨만 포드 알고리즘을 약간 변형시켜 평균 실행 시간을 줄인 SPFA를 사용하였다.

// Reference: green55 teamnote
// https://github.com/green5555/Teamnote/blob/master/TeamNote/MCMF.cpp

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<ll, ll> pll;

//O(VEf), Average = O(Ef)
const int MAX=2010;
struct MinCostMaxFlow{
    struct edg{ int pos, cap, rev; ll cost; };
    vector<edg> adj[MAX];
    void clear(){
        for(int i=0; i<MAX; i++) adj[i].clear();
    }
    void add_edge(int from, int to, int cap, int cost){
        adj[from].push_back({to, cap, (int)adj[to].size(), cost});
        adj[to].push_back({from, 0, (int)adj[from].size()-1, -cost});
    }
    ll dist[MAX];
    int pa[MAX], pe[MAX];
    bool inque[MAX];
    bool spfa(int src, int sink){
        memset(dist, 0x3f, sizeof(dist));
        memset(inque, 0, sizeof(inque));
        queue<int> que;
        dist[src] = 0;
        inque[src] = 1;
        que.push(src);
        bool ok = 0;
        while(!que.empty()){
            int x = que.front();
            que.pop();
            if(x == sink) ok = 1;
            inque[x] = 0;
            for(int i=0; i<adj[x].size(); i++){
                edg e = adj[x][i];
                if(e.cap > 0 && dist[e.pos] > dist[x] + e.cost){
                    dist[e.pos] = dist[x] + e.cost;
                    pa[e.pos] = x;
                    pe[e.pos] = i;
                    if(!inque[e.pos]){
                        inque[e.pos] = 1;
                        que.push(e.pos);
                    }
                }
            }
        }
        return ok;
    }
    pll match(int src, int sink){
        ll min_cost=0, max_flow=0;
        while(spfa(src, sink)){
            int cap = 1e9;
            for(int pos = sink; pos != src; pos = pa[pos]){
                cap = min(cap, adj[pa[pos]][pe[pos]].cap);
            }
            min_cost += dist[sink] * cap;
            max_flow += cap;
            for(int pos = sink; pos != src; pos = pa[pos]){
                int rev = adj[pa[pos]][pe[pos]].rev;
                adj[pa[pos]][pe[pos]].cap -= cap;
                adj[pos][rev].cap += cap;
            }
        }
        return {min_cost, max_flow};
    }
};

void solve() {
    MinCostMaxFlow mcmf;

    int n, m;
    cin >> n >> m;

    for (int i = 1; i < n + 1; i++) {
        int cnt;
        cin >> cnt;
        mcmf.add_edge(2008, i, 1, 0); // s -> 직원
        while (cnt--) {
            int j, x;
            cin >> j >> x;
            mcmf.add_edge(i, j + 1000, 1, x); // 직원 -> 일
        }
    }

    for (int j = 1; j < m + 1; j++) {
        mcmf.add_edge(j + 1000, 2009, 1, 0); // 일 -> t
    }

    pll ans = mcmf.match(2008, 2009);
    cout << ans.second << '\n' << ans.first << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

[C++] 열혈강호 3 (백준 11377번)

jungh150c — Fri, 5 Dec 2025 20:53:20 +0900

https://www.acmicpc.net/problem/11377

이렇게 중간 노드를 하나 만들어서 거기로 k만큼 흘려주도록 모델링하면

이렇게 된다.

// Reference: green55 teamnote
// https://github.com/green5555/Teamnote/blob/master/TeamNote/Ed-Karp.cpp

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> pii;

const int MAX = 2010, INF = INT_MAX;
struct maxflow {
    struct edge {
        int next, cap, flow = 0, rev_idx;
        edge() {}
        edge(int n, int c) : next(n), cap(c) {}
        int remain() {
            return cap - flow;
        }
    };
    vector<edge> adj[MAX];
    void makeEdge(int u, int v, int c) {
        adj[u].emplace_back(v, c);
        adj[v].emplace_back(u, 0);
        adj[u].back().rev_idx = adj[v].size() - 1;
        adj[v].back().rev_idx = adj[u].size() - 1;
    }
    int parent[MAX];
    pii path[MAX];
    int solve(int S, int E) {
        int ans = 0;
        queue<int> q;
        while (1) {
            memset(parent, -1, sizeof(parent));
            q.push(S);
            while (!q.empty()) {
                int u = q.front(); q.pop();
                for (int i = 0; i < adj[u].size(); ++i) {
                    auto &e = adj[u][i];
                    if (e.remain() > 0 && parent[e.next] == -1) {
                        parent[e.next] = u;
                        path[e.next] = { u, i };
                        q.emplace(e.next);
                    }
                }
            }
            if (parent[E] == -1) break;
            int ret = INF;
            for (int i = E; i != S; i = parent[i])
                ret = min(ret, adj[path[i].first][path[i].second].remain());
            for (int i = E; i != S; i = parent[i]) {
                auto &e = adj[path[i].first][path[i].second];
                e.flow += ret;
                adj[e.next][e.rev_idx].flow -= ret;
            }
            ans += ret;
        }
        return ans;
    }
};

void solve() {
    maxflow mf;

    int n, m, k;
    cin >> n >> m >> k;

    mf.makeEdge(2008, 2007, k); // s -> 중간 노드
    for (int i = 1; i < n + 1; i++) {
        int cnt;
        cin >> cnt;
        mf.makeEdge(2008, i, 1); // s -> 직원
        mf.makeEdge(2007, i, 1); // 중간 노드 -> 직원
        while (cnt--) {
            int j;
            cin >> j;
            mf.makeEdge(i, j + 1000, 1); // 직원 -> 일
        }
    }

    for (int j = 1; j < m + 1; j++) {
        mf.makeEdge(j + 1000, 2009, 1); // 일 -> t
    }

    cout << mf.solve(2008, 2009) << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

[C++] 북서풍 (백준 5419번) - 스위핑 + 세그먼트 트리

jungh150c — Fri, 21 Nov 2025 01:56:38 +0900

https://www.acmicpc.net/problem/5419

스위핑 아이디어

우리가 하고 싶은 것: 각 섬마다 자신보다 북서쪽에 있는 섬들이 몇 개인지 -> 그것들의 합을 구하면 정답

그러므로 섬들을 x 기준 오름차순, y 기준 내림차순으로 정렬해두자.

그렇게 정렬해둔 다음에, 앞에서부터 보면서 각 섬 기준 북서쪽에 있는 섬들이 몇 개인지 셀 때 지금까지 본 섬 중 자기보다 y값이 크거나 같은 섬이 몇 개였는지만 세면 된다.

자기 기준으로 북서쪽 섬이 몇 개인지 확인 후, 자기 섬도 등록해야 한다.

세그먼트 트리 아이디어

지금까지 본 섬들 중 자기보다 y값이 크거나 같은 섬이 몇 개인지를 빠르게 구하기 위해서 세그먼트 트리를 사용해야 한다.

-> 세그먼트 트리에 저장해야 하는 값: 지금까지 본 섬들의 y값 분포

즉, 자기 기준으로 북서쪽 섬이 몇 개인지는 구간 합 쿼리로, 자기 섬 등록은 업데이트로 처리하면 된다.

p.s. 좌표 압축

좌표 범위가 크기 때문에 좌표 압축을 해주어야 한다.

y값들에 대해서만 좌표 압축을 해주면 된다.

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

int ysz;

struct SegTree {
    vector<long long> tree;

    long long update(int idx, int l, int r, int target, long long val) {
        if (target < l || target > r) return tree[idx];
        if (l == r) return tree[idx] = tree[idx] + val;
        int m = (l + r) / 2;
        return tree[idx] = update(idx * 2, l, m, target, val) + update(idx * 2 + 1, m + 1, r, target, val);
    }
    
    long long query(int idx, int l, int r, int wl, int wr) {
        if (wr < l || wl > r) return 0;
        if (wl <= l && wr >= r) return tree[idx];
        int m = (l + r) / 2;
        return query(idx * 2, l, m, wl, wr) + query(idx * 2 + 1, m + 1, r, wl, wr);
    }
    
    long long update(int target, long long val) {
        return update(1, 0, ysz, target, val);
    }
    
    long long query(int wl, int wr) {
        return query(1, 0, ysz, wl, wr);
    }
};

// x 기준 오름차순, x 같으면 y 기준 내림차순
bool compare(pair<int,int> &a, const pair<int,int> &b) {
    if (a.first == b.first) return a.second > b.second;
    else return a.first < b.first;
}

void solve() {
    int n;
    cin >> n;
    
    vector<pair<int, int>> p(n);
    vector<int> ycom;
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        p[i] = {x, y};
        ycom.push_back(y);
    }

    sort(p.begin(), p.end(), compare);
    sort(ycom.begin(), ycom.end());
    ycom.erase(unique(ycom.begin(), ycom.end()), ycom.end());
    
    ysz = ycom.size() + 1;

    SegTree seg; // 지금까지 본 섬들의 y값 별 개수를 저장하는 세그먼트 트리
    seg.tree.assign(4 * ysz + 1, 0);

    long long ans = 0;
    for (auto [x, y]: p) {
        int yidx = lower_bound(ycom.begin(), ycom.end(), y) - ycom.begin();
        ans += seg.query(yidx, ysz);
        seg.update(yidx, 1);
    }

    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    cin >> T;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

[논문 리뷰] Meerkat: Audio-Visual Large Language Model for Grounding in Space and Time

jungh150c — Tue, 18 Nov 2025 12:07:07 +0900

https://www.ecva.net/papers/eccv_2024/papers_ECCV/papers/08071.pdf

https://arxiv.org/abs/2407.01851

Meerkat: Audio-Visual Large Language Model for Grounding in Space and Time

Leveraging Large Language Models' remarkable proficiency in text-based tasks, recent works on Multi-modal LLMs (MLLMs) extend them to other modalities like vision and audio. However, the progress in these directions has been mostly focused on tasks that on

arxiv.org

1. Introduction

LLM의 발전과 멀티모달 확장

최근 몇 년간 대규모 언어모델(LLM)의 비약적인 발전 -> 인간 수준의 이해력과 추론 능력 달성

instruction fine-tuning (지시 기반 미세조정) 패러다임 도입 -> 자연어 명령어를 이해하고 적합한 작업을 수행할 수 있게 됨

이러한 LLM를 다른 모달리티와 결합하는 흐름으로 확장됨 but 오디오는 상대적으로 덜 연구된 영역

기존 연구의 한계: Coarse-grained 중심

기존의 MLLM(멀티모달 LLM)의 한계:

1. 주로 coarse-grained (거시적인) task에 초점: 캡셔닝(audio captioning), 질의응답(audio QA) 등의 비교적 단순한 작업

2. fine-grained (세밀한) 오디오-비주얼 이해 부족: 일부 MLLM을 grounding에 사용하기 시작했지만 여전히 시각 정보에만 집중하거나 세밀한 이해 불가능

문제의식과 연구 목표

연구 목표: LLM을 통해 fine-grained (정밀한) 오디오-비주얼 이해를 달성하고자 함

but 어려운 이유:

1. 입출력 포맷의 다양성: 서로 다른 과제를 하나의 프레임워크에서 처리해야 함

2. 대규모 데이터셋의 부재: grounding 학습에 적합한 audio-visual 데이터셋

Meerkat 제안: 첫 Unified Audio-Visual LLM

기존 모델들(ex. BuboGPT, TimeChat)의 한계: coarse-grained task에 초점 & cross-modality fusion(교차 모달 결합)이 없어 fine-grained 이해 불가능

-> 이 문제들을 해결하기 위해 Meerkat 제안

Meerkat의 두 가지 핵심 모듈

1. Modality Alignment Module (모달리티 정렬 모듈): 최적 운송 기반으로 패치 레벨의 약한 감독 학습

2. Cross-modal Attention Consistency Module (교차 어텐션 일관성 모듈): cross-attention 히트맵을 강제하여 일관성 유지

=> 이 두 모듈이 오디오-비주얼 통합 표현 학습을 가능하게 함

MeerkatBench와 AVFIT Dataset

Meerkat 모델을 학습시키고 검증하기 위해 MeerkatBench와 AVFIT Dataset을 함께 제시

MeerkatBench: 5가지의 오디오-비주얼 과제를 통합한 벤치마크
1) Audio-referred Image Grounding
2) Image-guided Audio Temporal Localization
3) Audio-Visual Fact Checking
4) Audio-Visual Question Answering
5) Audio-Visual Captioning

AVFIT Dataset
약 3백만(3M)개의 instruction-tuning 샘플로 구성된 대규모 데이터셋
fine-grained 오디오-비주얼 이해를 학습하도록 설계됨

주요 기여

1. 세밀한 공간적/시간적 gounding이 가능한 최초의 오디오-비주얼 LLM인 Meerkat 제시

2. 5가지 오디오-비주얼 학습 과제를 통합한 MeerkatBench와 대규모 AVFIT dataset 제시

3. 모든 벤치마크 과제에서 State-of-the-Art 성능 달성

2. Related Works

Multi-modal Large Language Models

LLM의 지시 수행 (instruction-following) 능력 -> LLM을 다른 모달리티로 확장하려는 흐름

LLM을 멀티모달로 확장하기 위한 두 가지 주요 접근 방식

1. Latent Alignment 방식

LLM은 고정하고 학습된 비주얼 인코더를 통해 latent alignment (잠재 공간 정렬) 학습

ex. MiniGPT-4, X-LLM, Video-ChatGPT

2. Cross-attention 삽입 방식

LLM 내부에 cross-attention 층을 추가하여 멀티모달 정보를 처리할 수 있도록

ex. Otter, LLaMA-Adapter

기존 연구의 한계: 대부분 시각 정보에 집중, coarse-grained tasks 위주

이 연구의 목표: LLM에 강한 오디오-비주얼 이해 능력 부여

Fine-grained Multi-modal Understanding

범용 MLLM의 발전 -> 비전-언어(vision-language) 혹은 비디오 이해(video understanding) 과제를 통합적으로 다룰 수 있게 됨

+ MLLM에 region-based grounding tasks(영역 기반 그라운딩 과제)를 통합시키려는 시도도 나타남

기존 연구의 한계: 단일 모달리티(보통 비전-언어)에 제한됨

이 연구의 목표: 오디오-비주얼 과제 통합 프레임워크 제시

3. Methodology

Meerkat의 전체적인 구조

3.1. Multi-modal Feature Extraction

Image Encoder (이미지 특징 추출)

하나의 배치에 k 장의 이미지

- H: 이미지 높이

- W: 이미지 너비

- C: 채널 수 (RBG이면 3)

사용 모델: CLIP ViT-B/16

이미지 한 장은 토큰 (패치) 단위로 쪼개진 다음에 패치 임베딩으로 표현됨

- z_I: 이미지 임베딩

- S_I: 이미지 토큰 (패치) 개수

- D_I: 각 토큰의 임베딩 차원

Audio Encoder (오디오 특징 추출)

하나의 배치에 k 개의 오디오

- F: 스펙트럼 성분 개수

- T: 시간 프레임 개수

사용 모델: CLAP Audio Transformer

오디오 한 개는 토큰 (시간 구간) 단위로 쪼개진 다음에 패치 임베딩으로 표현됨

- z_A: 오디오 임베딩

- S_A: 오디오 토큰 (시간 구간) 수

- D_A: 각 토큰의 임베딩 차원

LLM

사용 모델: Llama 2-Chat (7B)

텍스트 명령은 LLM의 토크나이저를 통해 토큰 시퀀스로 변환된 다음에 임베딩으로 변환됨

- S_T: 텍스트 토큰 수

- D_T: 각 토큰의 임베딩 차원

각 모달리티 임베딩의 차원이 다름 -> 이를 맞춰추기 위해 추가적인 선형 변환 층 (linear projection layer)

이미지, 오디오 임베딩이 LLM에 맞춰짐 -> LLM이 Meerkat의 통합 인터페이스 역할을 함

3.2. Audio-Visual Feature Alignment

오디오와 비주얼 간의 의미적 정렬을 학습하기 위해 두 수준의 정렬을 사용

1) Audio-Visual Optimal Transport Alignment Module (AVOpT)

-> 패치 수준의 약한 감독 정렬 (weak supervision, global-level)

설계 동기: fine-grained supervision (세밀한 감독) 학습을 바로 학습시키는 대신, 먼저 weak supervision (약한 감독) 학습을 먼저 시키는 것이 효과적이라는 것이 입증됨

배경 연구 1: siamese network에서 EMD(Earth Mover Distance)와 OT(Optimal Transport; 최적 운송) 기반 알고리즘이 사용됨 -> 쿼리 이미지와 서포트 이미지 강 패치 수준의 정렬 수행

배경 연구 2: 비전-언어 모델에서도 OT 기반 방법이 확장되어 사용됨 -> 이미지의 패치와 문장의 단어 간 정렬 수행

배경 연구 3: 한 모달리티를 선형 투영(linear projection)을 통해 다른 모달리티 공간으로 옮겨서 정렬 수행 (OT 대신 선형 투영 사용)

문제 인식: CLIP(이미지 인코더)와 CLAP(오디오 인코더)는 각각 따로 학습됨 -> 두 임베딩이 서로 다른 의미 공간(semantic space)에 있음

-> 패치 레벨의 정렬이 이미지와 오디오 사이의 의미적 일관성(semantic consistency)을 향상시킴 (대조 학습보다 더 나음)

패치 임베딩 z_I, z_A를 확률 분포로 표현 (각 모달리티의 임베딩 집합을 질량이 분포된 확률 공간으로 보는 것)

목표: 이미지 패치 분포와 오디오 패치 분포를 맞추는 최소 비용 분포를 찾는 것

=> 확률 분포 간 Wasserstein Distance (WD = EMD) 구하기

요약: AVOpT는 이미지와 오디오의 패치 임베딩을 확률 분포로 보고, Earth Mover’s Distance 기반 Optimal Transport 를 이용해 두 분포 간 최소 운송 비용을 계산함으로써 패치 수준에서 의미적으로 일관된 약한 정렬(weak alignment)을 수행하는 모듈

2) Audio-Visual Attention Consistency Enforcement Module (AVACE)

-> 객체 단위의 강한 감독 정렬 (strong supervision, local-level)

설계 동기: AVOpT는 패치 수준의 약한 정렬을 제공하지만, 아직 오디오와 비주얼 간 구체적인 객체 수준(region-level) 인식은 부족함 (상대 모달리티의 세부 정보를 충분히 반영하지 X)

상호정보를 주입하기 위해 Cross-Attention 구조 사용

문제: 주의 분산 (inconsistency) -> 단순 cross-attention만 사용하면 오디오의 attention이 이미지 전체로 퍼짐

이유: CLAP은 문장-오디오 쌍으로 학습되었기 때문

-> cross-modality attention map 사용 (ground-truth bounding box를 이용해 마스크 M 정의)

목표: 객체 내부(마스크=1) → attention을 최대화 / 객체 외부(마스크=0) → attention을 최소화

3.3. Overall training objective

전체적인 학습 과정

4. MeerkatBench: A Unified Benchmark Suite for Fine-grained Audio-Visual Understanding

4.1. Task Overview

Fine-grained tasks

1) Audio-Referred Image Grounding (ARIG): 주어진 오디오에 대응하는 영상 내 객체의 위치를 찾는 과제

2) Image-Guided Audio Temporal Localization (IGATL): 주어진 이미지에 대응하는 오디오의 시간 구간을 찾는 과제

3) Audio-Visual Fact Checking (AVFC): 주어진 오디오와 영상의 내용이 서로 일치하는지 판단하는 과제

Coarse-grained tasks

4) Audio-Visual Question Answering (AVQA): 주어진 오디오+영상 정보를 종합해 자연어 질문에 답하는 과제

5) Audio-Visual Captioning (AVCap): 주어진 오디오+영상을 종합해 문장 설명(caption)을 생성하는 과제

4.2. AVFIT-3M: Audio Visual Finegrained Instruction Tuning Dataset

AVFIT-3M: MeerkatBench의 학습 기반이 되는 대규모 학습 데이터셋

- 총 샘플 수: 약 3백만 (3M) 멀티모달 instruction–response 쌍

- 형태: 대화식 instruction–response 형식

- 구성 방법: 2 step

Step 1. Adaptation of Public Datasets (공개 데이터셋 재구성)

1) Direct Collection (직접 수집) <- VGG-SS, AVSBench, Flickr-SoundNet, LLP, AVQA, MUSIC-AVQA, VALOR

2) Semi-automated Pairing (반자동 구성) <- Openimages, PASCAL, AudioSet, VGG-Sound (사전에 만들어둔 lookup table을 보고 같은 클래스로 매칭시키는 것)

Step 2. GPT-Assisted Instruction Generation (GPT 기반 지시문 생성)

기존의 instruction tuning 데이터셋들은 주로 coarse-grained task에 초점 -> fine-grained (공간/시간 단위) 오디오-비주얼 이해에는 적합하지 않음. -> 그래서 세 가지 방법으로 이 문제 개선

1) 오디오와 연결될 객체의 공간 좌표를 포함 -> region-level 이해 강화

2) 오디오 이벤트의 시간 구간을 입출력에 포함 -> temporal reasoning 학습 유도

3) GPT-3.5로 각 태스크 별 예시를 다양하게 생성 + GPT-4로 재프롬프트하여 품질 향상

=> 이 세 과정으로 여러 개의 지시 포맷을 생성 (not specific instruction): 지시 포맷은 special token을 포함함

학습 시점에 이 스페셜 토큰들이 실제 데이터로 대체되는 것.

5. Experiments and Results

5.1. Baselines

Meerkat의 독창성: Meerkat은 오디오-비주얼 공간적/시간적 그라운딩을 모두 통합한 최초의 MLLM임

-> 따라서 task 별로 가장 유사한 baseline을 선정하여 공정하게 비교함

task1) ARIG: BuboGPT’s

task2) IGATL: TimeChat

task3) AVFC: X-InstructBLIP

task4) AVQA: Macaw-LLM

task5) AVCap: PandaGPT, VideoLlama

5.2. Main Results

1) Audio-Referred Image Grounding (ARIG)

주어진 오디오에 대응하는 영상 내 객체의 위치를 찾는 과제

2) Image-Guided Audio Temporal Localization (IGATL)

주어진 이미지에 대응하는 오디오의 시간 구간을 찾는 과제

성능이 좋은 이유: AVOpT, AVACE 두 가지 모듈을 사용하기 때문

3) Audio-Visual Fact Checking (AVFC)

주어진 오디오와 영상의 내용이 서로 일치하는지 판단하는 과제

학습에 GT 박스나 시간 구간이 직접적으로 사용되지 않음에도 fine-grained task인 이유: global한 장면이 아니라 객체, 시간 구간 등 세부적 정보에 집중해야 하기 때문

model의 response: 이진 답변 (True/False)

type1) 이미지의 박스 안의 개체가 오디오의 소리를 내는지 판단 (공간 중심)

type2) 이미지 속 객체가 해당 시간 구간의 오디오와 관련이 있는지 판단 (시간 중심)

type3) 이미지의 박스 안의 객체가 특정 시간 구간의 오디오의 소리와 일치하는지 판단 (공간+시간 통합)

type4) 오디오가 이미지 속 장면과 관련이 있는지 판단 -> 의미적 매칭 (global, 전반적)

4) Audio-Visual Question Answering (AVQA)

주어진 오디오+영상 정보를 종합해 자연어 질문에 답하는 과제

5) Audio-Visual Captioning (AVCap)

주어진 오디오+영상을 종합해 문장 설명(caption)을 생성하는 과제

Meerkat이 coarse-grained 과제에도 잘 확장되는 이유: 정밀한 오디오-비주얼 의미 이해를 학습했기 때문

=> Meerkat은 fine-grained task와 coarse-grained task 모두를 처리할 수 있는 범용 멀티모달 모델 (MLLM)

5.3. Ablation Study

Study1) 단일 과제 학습(single-task) vs. 통합 다중 과제 학습(multi-task) 비교

multi-task 학습이 single-task 학습보다 전반적으로 더 좋은 성능

fine-grained task로 학습한 모델은 coarse-grained task에서도 매우 좋은 성능을 보임

반대로, coarse-grained task 학습을 추가한다고 fine-grained task 성능이 크게 향상되지는 않음

-> 즉, fine-grained task 학습이 훨씬 중요한 역할을 함

Study2) 전체 LLM 파라미터 미세조정(full fine-tuning) vs. LoRA 기반 경량 미세조정(LoRA fine-tuning) 비교

cf. LoRA(Low-Rank Adaptation): LLM 전체 파라미터를 직접 업데이트하지 않고, 작은 low-rank 행렬을 추가 학습함으로써 메모리/시간 효율적으로 fine-tuning하는 방법

LoRA rank 값 r = {4, 16, 32}으로 실험

-> r=4,16는 성능 낮고 r=32는 full fine-tuning보다도 약간 더 성능이 좋음

LoRA가 fine-tuning 시 기존 LLM의 일반화 성질을 보존하면서 필요한 영역만 정교하게 조정한 것

5.4. Qualitative Analysis

정성적 비교로 Meerkat의 강점을 시각적으로 보여줌

6. Conclusions and Future Works

Meerkat은 오디오-비주얼 입력을 동시에 처리하고 공간적+시간적 세부 정보까지 이해할 수 있는 강력한 multi-modal LLM이다.

AVOpT 모듈 + AVACE 모듈 -> 시청각 정보에 대한 강력한 조합적 이해력(compositional understanding) -> 다양하고 복잡한 멀티모달 과제 처리 가능

훈련용 데이터셋 AVFIT, 평가용 벤치마크 MeerkatBench -> 앞으로의 AV-LLM 연구에 표준으로 사용될 수 있는 기반을 마련

다양한 downstream task에 대해서 일관되게 SOTA 성능 달성

향후 연구 방향

1) LLM-guided AV Segmentation: LLM 기반의 보다 정밀한 시청각 불할로 발전시킬 예정

2) Video 확장 및 시간적 과제: 영상을 직접 입력으로 받을 수 있게 하여 video temporal grounding, video summarization 등의 과제 가능하도록

3) 대규모 Video-centric 데이터 구축: 대규모 비디오 중심 멀티모달 데이터셋과 복잡한 추론(Reasoning) 평가 벤치마크

[C++] 도미노 (백준 4196번)

jungh150c — Sat, 15 Nov 2025 03:17:21 +0900

https://www.acmicpc.net/problem/4196

첨엔 그냥 scc 개수를 구해서 틀렸다.

그런데 1과 2가 같은 scc이고 3과 4가 같은 scc이면서 2에서 3으로 가는 간선이 있는 경우를 생각해보면, scc 개수는 2이지만 답은 1이다.

왜냐하면 1을 넘어뜨리면 같은 scc인 2도 자연스럽게 넘어지고 따라서 3, 4도 넘어지기 때문이다.

따라서 이 문제는 scc를 구한 뒤, in-degree가 0인 (다른 것에 의해서 넘어지지 않는) scc의 개수만을 세야 한다.

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

vector<vector<int>> adj1;
vector<vector<int>> adj2;
vector<bool> vst;
stack<int> stk;
vector<int> scc;
int idx;

void dfs1(int cur) {
    vst[cur] = true;
    for (int nxt: adj1[cur]) {
        if (!vst[nxt]) dfs1(nxt);
    }
    stk.push(cur);
}

void dfs2(int cur) {
    vst[cur] = true;
    scc[cur] = idx;
    for (int nxt: adj2[cur]) {
        if (!vst[nxt]) dfs2(nxt);
    }
}

void solve() {
    int n, m;
    cin >> n >> m;

    adj1 = vector<vector<int>>(n + 1);
    adj2 = vector<vector<int>>(n + 1);

    for (int i = 0; i < m; i++) {
        int x, y;
        cin >> x >> y;
        adj1[x].push_back(y);
        adj2[y].push_back(x);
    }

    vst = vector<bool>(n + 1, false);
    for (int i = 1; i < n + 1; i++) {
        if (!vst[i]) dfs1(i);
    }

    vst = vector<bool>(n + 1, false);
    scc = vector<int>(n + 1, -1);
    idx = 0;
    while (!stk.empty()) {
        int x = stk.top();
        stk.pop();
        if (!vst[x]) {
            dfs2(x);
            idx++;
        }
    }

    vector<int> sccin(idx, 0);
    for (int cur = 1; cur < n + 1; cur++) {
        for (int nxt: adj1[cur]) {
            if (scc[cur] != scc[nxt]) {
                sccin[scc[nxt]]++;
            }
        }
    }

    int ans = 0;
    for (int i = 0; i < idx; i++) {
        if (sccin[i] == 0) ans++;
    }
    cout << ans << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    cin >> T;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

[C++] Strongly Connected Component (백준 2150번) - 강한 연결 요소

jungh150c — Sat, 15 Nov 2025 02:23:51 +0900

강한 연결 요소 - Strongly Connected Component (SCC)

방향 그래프에서 모든 정점 쌍 사이에 경로가 존재할 때, 그 그래프는 강하게 연결되어 있다고 한다.

방향 그래프에서 모든 정점 쌍 사이에 경로가 존재하는 최대 부분 그래프를 강한 연결 요소라고 한다.

Kosaraju 알고리즘: scc를 구하는 알고리즘

adj1: 원래 방향 그래프의 인접 리스트

adj2: 원래 그래프의 간선을 모두 반대로 뒤집은 그래프의 인접 리스트

dfs1: 원래 그래프를 dfs로 탐색함. 탐색하면서 완료 정점을 stack에 담음.

dfs2: stack의 정점들을 pop하면서 반전 그래프를 dfs로 탐색함. => dfs2 호출 횟수가 강한 연결 요소 개수

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

int v, e;
vector<vector<int>> adj1;
vector<vector<int>> adj2;
vector<bool> vst;
stack<int> stk;
vector<int> tmp;

void dfs1(int cur) {
    vst[cur] = true;
    for (int nxt: adj1[cur]) {
        if (!vst[nxt]) dfs1(nxt);
    }
    stk.push(cur);
}

void dfs2(int cur) {
    vst[cur] = true;
    tmp.push_back(cur);
    for (int nxt: adj2[cur]) {
        if (!vst[nxt]) dfs2(nxt);
    }
}

void solve() {
    cin >> v >> e;

    adj1 = vector<vector<int>>(v + 1);
    adj2 = vector<vector<int>>(v + 1);

    for (int i = 0; i < e; i++) {
        int a, b;
        cin >> a >> b;
        adj1[a].push_back(b);
        adj2[b].push_back(a);
    }

    vst = vector<bool>(v + 1, false);
    for (int i = 1; i < v + 1; i++) {
        if (!vst[i]) dfs1(i);
    }

    vector<vector<int>> ans;
    vst = vector<bool>(v + 1, false);
    while (!stk.empty()) {
        int x = stk.top();
        stk.pop();
        if (!vst[x]) {
            tmp = vector<int>();
            dfs2(x);
            ans.push_back(tmp);
        }
    }

    for (int i = 0; i < ans.size(); i++) {
        sort(ans[i].begin(), ans[i].end());
    }
    sort(ans.begin(), ans.end());

    cout << ans.size() << '\n';
    for (int i = 0; i < ans.size(); i++) {
        for (int x: ans[i]) cout << x << ' ';
        cout << "-1\n";
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

[C++] 단방향 링크 네트워크 (백준 3295번)

jungh150c — Sat, 15 Nov 2025 01:18:16 +0900

https://www.acmicpc.net/problem/3295

그래프의 구조가 링이거나 선형 배열이라는 것은 그래프를 이루는 각 노드들의 in-degree도 최대 1이고 out-degree도 최대 1이라는 것이다.

그리고 k개의 노드로 이루어진 링의 가치가 k이고 k개의 노드로 이루어진 선형 배열의 가치가 k라는 것은 어떤 그래프에서 각 노드의 in-degree도 최대 1이고 out-degree도 최대 1이 되도록 간선들을 선택했을 때의 간선 개수 자체가 가치가 된다는 뜻이다.

따라서 왼쪽에 출발 노드 집합을 두고 오른쪽에 도착 노드 집합을 두고 최대 이분 매칭을 구하면 된다.

// Reference: green55 teamnote
// https://github.com/green5555/Teamnote/blob/master/TeamNote/BiMatch.cpp

#include <bits/stdc++.h>
using namespace std;

const int MAX = 2000;
struct BiMatching {
    vector<int> adj[MAX+5];
    int iter, A[MAX+5], B[MAX+5], was[MAX+5];

    bool dfs(int u) {
        was[u] = iter;
        for (int v : adj[u]) {
            if (B[v] == -1) {
                A[u] = v;
                B[v] = u;
                return true;
            }
        }
        for (int v : adj[u]) {
            if (was[B[v]] != iter && dfs(B[v])) {
                A[u] = v;
                B[v] = u;
                return true;
            }
        }
        return false;
    }

    int biMatch(int n=MAX) {
        fill(A, A+n, -1);
        fill(B, B+n, -1);
        fill(was, was+n, 0);
        iter = 0;
        int res = 0;
        while (true) {
            iter++;
            int add = 0;
            for (int i = 0; i < n; i++) {
                if (A[i] == -1 && dfs(i)) {
                    add++;
                }
            }
            if (add == 0) {
                break;
            }
            res += add;
        }
        return res;
    }
};

void solve() {
    BiMatching bm;

    int n, m;
    cin >> n >> m;

    while (m--) {
        int a, b;
        cin >> a >> b;
        bm.adj[a].push_back(b + 1000);
    }

    cout << bm.biMatch() << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    cin >> T;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)

[C++] 돌멩이 제거 (백준 1867번)

jungh150c — Thu, 13 Nov 2025 11:59:31 +0900

https://www.acmicpc.net/problem/1867

목적은 모든 돌멩이를 제거하는 것이다.

하나의 돌멩이는 하나의 행과 하나의 열 위에 놓여 있다. 그 말은, 해당 돌멩이를 제거하기 위해서는 그 행에서 뛰거나 그 열에서 뛰어야 한다는 뜻이다.

한 쪽에는 행 노드들이 있고 한 쪽에는 열 노드들이 있다고 생각해보면, 돌멩이는 하나의 행과 하나의 열을 연결해주는 간선의 역할을 한다고 생각할 수 있다. 따라서 이렇게 이분 그래프가 만들어진다.

여기서 모든 돌(간선)을 커버하기 위해 필요한 최소 정점 수는 이분 그래프에서의 최소 정점 커버 (Minimum Vertex Cover) 문제이며, 쾨니그 정리에 의해 이는 최대 이분 매칭의 크기와 같다고 한다.

// Reference: green55 teamnote
// https://github.com/green5555/Teamnote/blob/master/TeamNote/BiMatch.cpp

#include <bits/stdc++.h>
using namespace std;

const int MAX = 1001;
struct BiMatching {
    vector<int> adj[MAX+5];
    int iter, A[MAX+5], B[MAX+5], was[MAX+5];

    bool dfs(int u) {
        was[u] = iter;
        for (int v : adj[u]) {
            if (B[v] == -1) {
                A[u] = v;
                B[v] = u;
                return true;
            }
        }
        for (int v : adj[u]) {
            if (was[B[v]] != iter && dfs(B[v])) {
                A[u] = v;
                B[v] = u;
                return true;
            }
        }
        return false;
    }

    int biMatch(int n=MAX) {
        fill(A, A+n, -1);
        fill(B, B+n, -1);
        fill(was, was+n, 0);
        iter = 0;
        int res = 0;
        while (true) {
            iter++;
            int add = 0;
            for (int i = 0; i < n; i++) {
                if (A[i] == -1 && dfs(i)) {
                    add++;
                }
            }
            if (add == 0) {
                break;
            }
            res += add;
        }
        return res;
    }
};

void solve() {
    BiMatching bm;

    int n, k;
    cin >> n >> k;

    while (k--) {
        int r, c;
        cin >> r >> c;
        bm.adj[r].push_back(c + 500);
    }

    cout << bm.biMatch() << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int T = 1;
    for (int i = 0; i < T; i++) {
        solve();
    }
}

(AC)