가장 긴 증가하는 부분 수열 5

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

문제

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

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

입력

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

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

출력

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

둘째 줄에는 정답이 될 수 있는 가장 긴 증가하는 부분 수열을 출력한다.

6
10 20 10 30 20 50

4
10 20 30 50

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: harinboy, jh05013, kkw564, ldw0318, minho6428, sohnryang, surung9898, yeo2507
• 빠진 조건을 찾은 사람: Acka

비슷한 문제

• 11053번. 가장 긴 증가하는 부분 수열
• 11054번. 가장 긴 바이토닉 부분 수열
• 11055번. 가장 큰 증가하는 부분 수열
• 11722번. 가장 긴 감소하는 부분 수열
• 12015번. 가장 긴 증가하는 부분 수열 2
• 12738번. 가장 긴 증가하는 부분 수열 3
• 14002번. 가장 긴 증가하는 부분 수열 4

알고리즘 분류

• 이분 탐색
• 역추적
• 가장 긴 증가하는 부분 수열 문제

1차 시도 – 로직 그대로 구현

한 번의 입력(num)에 의해 생성된 새로운 시퀀스들을 임시로 저장

어떤 수열에도 붙을 수 없으면 독립된 시퀀스 시작

나중에 불필요한 시퀀스(같은 길이인데 꼬리가 큰 것)는 제거

#include <iostream>
#include <vector>

using namespace std;

int n; // 수열의 개수
vector<vector<int>> Sequences;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> n;
    if (n <= 0) return 0;

    int num;
    cin >> num;

    // 첫 번째 수로 초기 시퀀스 하나 생성
    vector<int> sequence;
    sequence.push_back(num);
    Sequences.push_back(sequence);

    for (int i = 1; i < n; i++)
    {
        cin >> num;
        int length = Sequences.size();

        bool canExtend = false;
        vector<vector<int>> newSequences;

        // 기존 시퀀스들을 모두 검사
        for (int j = 0; j < length; j++)
        {
            int last = Sequences[j].back();

            // 확장 가능한 경우 : 새로운 시퀀스 생성
            if (last < num)
            {
                canExtend = true;
                vector<int> extendedSeq = Sequences[j];
                extendedSeq.push_back(num);
                newSequences.push_back(extendedSeq);
            }
        }

        // 어떤 시퀀스에도 붙지 못하면 새로운 시퀀스 시작
        if (!canExtend)
        {
            vector<int> newSeq;
            newSeq.push_back(num);
            newSequences.push_back(newSeq);
        }

        // 새로 생긴 시퀀스들을 기존에 합침
        for (auto& seq : newSequences)
            Sequences.push_back(seq);

        // 최적 시퀀스 길이 및 꼬리값 계산
        int maxSeqSize = 0;
        int bestIndex = 0;
        int bestTail = 1000000001;

        for (int j = 0; j < (int)Sequences.size(); j++)
        {
            int sz = Sequences[j].size();
            int tail = Sequences[j].back();
            if (sz > maxSeqSize || (sz == maxSeqSize && tail < bestTail))
            {
                maxSeqSize = sz;
                bestTail = tail;
                bestIndex = j;
            }
        }

        // 가지치기: 같은 길이인데 꼬리값이 큰 시퀀스 제거
        for (int j = 0; j < (int)Sequences.size();)
        {
            int sz = Sequences[j].size();
            int tail = Sequences[j].back();

            if (sz == maxSeqSize && tail > bestTail)
            {
                Sequences.erase(Sequences.begin() + j);
            }
            else
            {
                j++;
            }
        }
    }

	// 결과 중 가장 긴 시퀀스 찾기
    int maxSize = 0;
    int bestIdx = 0;
    for (int i = 0; i < (int)Sequences.size(); i++)
    {
        if (Sequences[i].size() > maxSize)
        {
            maxSize = Sequences[i].size();
            bestIdx = i;
        }
    }

    cout << maxSize << "\n";
    for (int x : Sequences[bestIdx])
        cout << x << " ";

    return 0;
}

브루트포스 방식으로 모든 가능한 증가 수열을 시도하는 방법은 시간 초과 및 메모리 초과로 인하여 통과할 수 없음.

매 반복마다 Sequences의 크기가 기하급수적으로 늘어나는 구조

n개의 원소가 들어오면 2ⁿ에 비례하는 시퀀스로 통과하기 힘들다. (O(2ⁿ))

2차 시도 – 이분 탐색 + 인덱스 추적을 이용한 LIS 복원 / O(N log N)

최장 증가 수열 (LIS, Longest Increasing Subsequence)

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// (LIS, Longest Increasing Subsequence)

int main()
{
    ios::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);

    int N;
    std::cin >> N;

    vector<int> input(N);
    for (int i = 0; i < N; i++)
        std::cin >> input[i];

    vector<int> tail;  // LIS를 구성하는 인덱스들
    vector<int> prev_idx(N, -1);  //각 요소가 LIS에 포함될 때, 그 직전 요소의 인덱스를 저장


    for (int i = 0; i < N; i++)
    {
        // 이분 탐색으로 input[i]가 tail 배열에서 들어가야 할 위치 찾기
        int lo = 0;
        int hi = (int)tail.size() - 1;
        int pos = (int)tail.size(); // 기본값은 맨 뒤

        while (lo <= hi)
        {
            int mid = (lo + hi) / 2;
            // input[i]보다 크거나 같은 첫 번째 tail 원소 위치(pos)를 찾
            if (input[tail[mid]] < input[i])
            {
                lo = mid + 1;
            }
            else
            {
                pos = mid;
                hi = mid - 1;
            }
        }

        // 이전 인덱스 설정
        if (pos > 0)
        {
            prev_idx[i] = tail[pos - 1];
        }
        else
        {
            prev_idx[i] = -1;  // 첫 번째 요소
        }

        // tail 업데이트
        if (pos == (int)tail.size())
        {
            tail.push_back(i);
        }
        else
        {
            tail[pos] = i;
        }
    }

    // 결과: LIS 길이
    int lis_len = (int)tail.size();
    std::cout << lis_len << "\n";

    // 실제 LIS 수열 재구성
    vector<int> lis;
    for (int idx = tail.back(); idx != -1; idx = prev_idx[idx])
    {
        lis.push_back(input[idx]);
    }
    reverse(lis.begin(), lis.end());

    for (int v : lis)
        std::cout << v << " ";
    std::cout << "\n";

    return 0;
}

input[i]가 들어가야 할 위치(pos)를 찾음

즉, tail 배열 내에서 input[i]보다 작지만 가장 큰 값 다음 위치를 찾는다.

prev_idx[i]는 input[i] 바로 앞에 올 LIS 원소의 인덱스입니다.

pos > 0이면 → 현재 원소가 “길이 pos+1″짜리 LIS의 마지막이 되므로 “그 바로 이전 원소”는 tail[pos - 1]

pos == 0이면 → 수열의 첫 번째 원소이므로 이전이 없음

pos == tail.size() → input[i]가 지금 까지의 모든 수보다 크므로 LIS 길이 1 증가

그렇지 않으면 → 기존 LIS 후보 중 “끝값이 더 큰 것”을 input[i]로 치환 (더 작은 끝값 유지)

예시 1

input = [5, 2, 8, 6, 3, 6, 9, 7]

예시 2

이분 탐색을 이용한 LIS 구성 로직

input = [3, 5, 2, 7, 4, 1, 8]

--------------------------------

i=0 (값: 3)
tail: [] (빈 배열)
이분탐색: tail.size() = 0 → while문 스킵
pos = 0 (기본값)

prev_idx[0] = -1 (pos=0이므로)
tail 업데이트: pos == tail.size() → push_back(0)
결과: tail = [0] (값: [3])

--------------------------------

i=1 (값: 5)
tail: [0] (값: [3])
이분탐색:
  lo=0, hi=0, mid=0
  input[tail[0]] = 3 < 5 → lo = mid+1 = 1
  lo=1 > hi=0 → 종료
pos = tail.size() = 1

prev_idx[1] = tail[0] = 0 (5 앞에 3)
tail 업데이트: push_back(1)
결과: tail = [0,1] (값: [3,5])

--------------------------------

i=2 (값: 2)
tail: [0,1] (값: [3,5])
이분탐색:
  lo=0, hi=1, mid=0
  input[tail[0]] = 3 >= 2 → pos=0, hi=-1
  lo=0 > hi=-1 → 종료
pos = 0

prev_idx[2] = -1 (pos=0이므로)
tail 업데이트: tail[0] = 2
결과: tail = [2,1] (값: [2,5])

--------------------------------

i=3 (값: 7)
tail: [2,1] (값: [2,5])
이분탐색:
  lo=0, hi=1, mid=0: input[tail[0]]=2 < 7 → lo=1
  lo=1, hi=1, mid=1: input[tail[1]]=5 < 7 → lo=2
  lo=2 > hi=1 → 종료
pos = tail.size() = 2

prev_idx[3] = tail[1] = 1 (7 앞에 5)
tail 업데이트: push_back(3)
결과: tail = [2,1,3] (값: [2,5,7])

--------------------------------

i=4 (값: 4)
tail: [2,1,3] (값: [2,5,7])
이분탐색:
  lo=0, hi=2, mid=1: input[tail[1]]=5 >= 4 → pos=1, hi=0
  lo=0, hi=0, mid=0: input[tail[0]]=2 < 4 → lo=1
  lo=1 > hi=0 → 종료
pos = 1

prev_idx[4] = tail[0] = 2 (4 앞에 2)
tail 업데이트: tail[1] = 4
결과: tail = [2,4,3] (값: [2,4,7])

--------------------------------

i=5 (값: 1)
tail: [2,4,3] (값: [2,4,7])
이분탐색:
  lo=0, hi=2, mid=1: input[tail[1]]=4 >= 1 → pos=1, hi=0
  lo=0, hi=0, mid=0: input[tail[0]]=2 >= 1 → pos=0, hi=-1
  lo=0 > hi=-1 → 종료
pos = 0

prev_idx[5] = -1
tail 업데이트: tail[0] = 5
결과: tail = [5,4,3] (값: [1,4,7])

--------------------------------

i=6 (값: 8)

tail: [5,4,3] (값: [1,4,7])
이분탐색:
  lo=0, hi=2, mid=1: input[tail[1]]=4 < 8 → lo=2
  lo=2, hi=2, mid=2: input[tail[2]]=7 < 8 → lo=3
  lo=3 > hi=2 → 종료
pos = tail.size() = 3

prev_idx[6] = tail[2] = 3 (8 앞에 7)
tail 업데이트: push_back(6)
결과: tail = [5,4,3,6] (값: [1,4,7,8])

The post 백준 14003번 (가장 긴 증가하는 부분 수열 5, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

가운데를 말해요

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

문제

백준이는 동생에게 “가운데를 말해요” 게임을 가르쳐주고 있다.

백준이가 정수를 하나씩 외칠때마다 동생은 지금까지 백준이가 말한 수 중에서 중간값을 말해야 한다.

만약, 그동안 백준이가 외친 수의 개수가 짝수개라면 중간에 있는 두 수 중에서 작은 수를 말해야 한다.

예를 들어 백준이가 동생에게 1, 5, 2, 10, -99, 7, 5를 순서대로 외쳤다고 하면, 동생은 1, 1, 2, 2, 2, 2, 5를 차례대로 말해야 한다.

백준이가 외치는 수가 주어졌을 때, 동생이 말해야 하는 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 백준이가 외치는 정수의 개수 N이 주어진다.

N은 1보다 크거나 같고, 100,000보다 작거나 같은 자연수이다.

그 다음 N줄에 걸쳐서 백준이가 외치는 정수가 차례대로 주어진다.

정수는 -10,000보다 크거나 같고, 10,000보다 작거나 같다.

출력

한 줄에 하나씩 N줄에 걸쳐 백준이의 동생이 말해야 하는 수를 순서대로 출력한다.

예제 입력 1

7
1
5
2
10
-99
7
5

예제 출력 1

1
1
2
2
2
2
5

출처

• 문제를 만든 사람: ntopia
• 데이터를 추가한 사람: pichulia
• 문제를 각색한 사람: baekjoon

알고리즘 분류

• 자료 구조
• 우선순위 큐

1차 시도 – 배열 인덱스 (실패 / 시간 초과)

배열을 기반으로, 중간값의 인덱스(currentMedian)를 유지하면서 새로운 값이 들어올 때마다 leftCount, rightCount를 조정하는 방식

#include <iostream>
using namespace std;

int n = 0;
int num[20001] = { 0 };  // 값의 출현 횟수 (index = value + 10000)
int currentMedian = 0;   // 현재 중간값의 인덱스
int leftCount = 0;       // 중간값보다 작은 값들의 개수
int rightCount = 0;      // 중간값보다 큰 값들의 개수

// 실제 값 => 배열 인덱스로 변환
inline int GetIndex(int value) 
{
    return value + 10000;
}

// 배열 인덱스 => 실제 값으로 변환
inline int GetValue(int index) 
{
    return index - 10000;
}

int FindMedianOptimized(int newValue, int total)
{
    int newIdx = GetIndex(newValue);
    num[newIdx]++;

    // 새 값의 위치에 따라 좌우 카운트 조정
    if (newIdx < currentMedian) leftCount++;
    else if (newIdx > currentMedian) rightCount++;
    else rightCount++; // 같은 값일 경우 간단히 오른쪽으로 분류

    // 목표 중간 위치 계산
    int targetPos = (total + 1) / 2;

    // 중간값 인덱스를 왼쪽으로 이동 (왼쪽 원소가 너무 많을 때)
    while (leftCount >= targetPos) {
        currentMedian--;
        leftCount -= num[currentMedian];
        rightCount += num[currentMedian];
    }

    // 중간값 인덱스를 오른쪽으로 이동 (왼쪽 원소가 부족할 때)
    while (leftCount + num[currentMedian] < targetPos) {
        leftCount += num[currentMedian];
        currentMedian++;
        rightCount -= num[currentMedian];
    }

    // 현재 중간값 반환
    return GetValue(currentMedian);
}

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

    cin >> n;
    int value = 0;

    // 첫 번째 입력값으로 초기화
    cin >> value;
    num[GetIndex(value)]++;
    currentMedian = GetIndex(value);
    leftCount = 0;
    rightCount = 0;

    // 첫 번째 값 => 중간값
    cout << value << "\n"; 

    for (int i = 2; i <= n; ++i) 
    {
        cin >> value;
        cout << FindMedianOptimized(value, i) << "\n";
    }

    return 0;
}

시간 초과의 원인

새로운 값이 입력될 때마다 currentMedian을 1씩 이동하며 왼쪽/오른쪽 카운트를 갱신

currentMedian의 이동 거리는 입력된 값의 분포에 따라서 문제가 생길 수 있음.

// 최악의 경우
-10000, -9999, -9998, ... , 9999, 10000

매번 새로운 값이 들어올 때마다 currentMedian이 오른쪽 끝으로 한 칸씩 이동

매번 while 루프가 최대 20,000번 반복되는 불상사가 생길 수 있음

입력 n = 100,000일 때 최악의 복잡도: O(n * 20000) = 2,000,000,000 (20억)

currentMedian 부분을 개선 또는 다른 알고리즘을 사용하는 방법이 더 좋아보임

2차 시도 – Two Heaps 방식 (성공)

maxHeap(왼쪽) + minHeap(오른쪽)으로 균형 유지

maxHeap: 중간값 이하의 값들 저장 (왼쪽 절반)

minHeap: 중간값 이상의 값들 저장 (오른쪽 절반)

균형 조정 시 힙에서 한 번씩 push/pop → O(log n)

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

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

    int n;
    cin >> n;

    priority_queue<int> maxHeap;                            // 왼쪽 절반 (최대 힙)
    priority_queue<int, vector<int>, greater<int>> minHeap;  // 오른쪽 절반 (최소 힙)

    for (int i = 0; i < n; ++i) 
    {
        int value;
        cin >> value;

        // 값 삽입: 왼쪽/오른쪽 균형 유지
        if (maxHeap.empty() || value <= maxHeap.top())
            maxHeap.push(value);
        else
            minHeap.push(value);

        // 두 힙의 크기 균형 조정 (왼쪽 = 오른쪽 또는 +1)
        if (maxHeap.size() > minHeap.size() + 1) {
            minHeap.push(maxHeap.top());
            maxHeap.pop();
        }
        else if (minHeap.size() > maxHeap.size()) {
            maxHeap.push(minHeap.top());
            minHeap.pop();
        }

        // 현재 중간값 출력
        cout << maxHeap.top() << "\n";
    }

    return 0;
}

입력: [1, 5, 2, 10, -5, 8, 3]

단계별 힙 상태:

1. value=1
   maxHeap: [1]      minHeap: []
   중간값: 1

2. value=5
   maxHeap: [1]      minHeap: [5]
   중간값: 1

3. value=2
   maxHeap: [2, 1]   minHeap: [5]
   중간값: 2

4. value=10
   maxHeap: [2, 1]   minHeap: [5, 10]
   중간값: 2

5. value=-5
   maxHeap: [2, 1, -5] minHeap: [5, 10]
   중간값: 2

6. value=8
   maxHeap: [2, 1, -5] minHeap: [5, 8, 10]
   중간값: 2

7. value=3
   maxHeap: [3, 2, -5, 1] minHeap: [5, 8, 10]
   중간값: 3

The post 백준 1655번 (가운데를 말해요, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

강호네 회사에는 직원이 N명이 있고, 해야할 일이 M개가 있다.

직원은 1번부터 N번까지 번호가 매겨져 있고, 일은 1번부터 M번까지 번호가 매겨져 있다.

각 직원은 자신이 할 수 있는 일들 중 한 개의 일만 담당할 수 있고, 각각의 일을 담당하는 사람은 1명이어야 한다.

각각의 직원이 할 수 있는 일의 목록이 주어졌을 때, M개의 일 중에서 최대 몇 개를 할 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 직원의 수 N과 일의 개수 M이 주어진다. (1 ≤ N, M ≤ 1,000)

둘째 줄부터 N개의 줄의 i번째 줄에는 i번 직원이 할 수 있는 일의 개수와 할 수 있는 일의 번호가 주어진다.

출력

첫째 줄에 강호네 회사에서 할 수 있는 일의 개수를 출력한다.

예제 입력 1

5 5
2 1 2
1 1
2 2 3
3 3 4 5
1 1

예제 출력 1

4

출처

• 문제를 만든 사람: baekjoon
• 어색한 표현을 찾은 사람: doju
• 데이터를 추가한 사람: rubix, woojw911

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> employee[1001];
int works[1001];       
bool visited[1001];      

bool DFS(int n) 
{

    for (int work : employee[n]) 
    {
        if (visited[work]) 
            continue;

        visited[work] = true;

        if (works[work] == 0 || DFS(works[work])) 
        {
            works[work] = n;
            return true;
        }
    }

    return false;
}

int main() 
{

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, work;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> work;
            employee[i].push_back(work);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

해당 문제와 코드가 같은 문제

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

The post 백준 11375번 (열혈강호, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

농부 존은 소 축사를 완성하였다. 축사 환경을 쾌적하게 유지하기 위해서, 존은 축사를 M개의 칸으로 구분하고, 한 칸에는 최대 한 마리의 소만 들어가게 계획했다.

첫 주에는 소를 임의 배정해서 축사를 운영했으나, 곧 문제가 발생하게 되었다. 바로 소가 자신이 희망하는 몇 개의 축사 외에는 들어가기를 거부하는 것이다.

농부 존을 도와 최대한 많은 수의 소가 축사에 들어갈 수 있도록 하는 프로그램을 작성하시오.

축사의 번호는 1부터 M까지 매겨져 있다.

입력

첫째 줄에 소의 수 N과 축사의 수 M이 주어진다. (1 ≤ N, M ≤ 200)

둘째 줄부터 N개의 줄에는 각 소가 들어가기 원하는 축사에 대한 정보가 주어진다.

i번째 소가 들어가기 원하는 축사의 수 S_i (0 ≤ S_i ≤ M)이 먼저 주어지고, 이후 S_i개의 축사 번호가 주어진다.

같은 축사 번호가 두 번 이상 주어지는 경우는 없다.

출력

첫째 줄에 축사에 들어갈 수 있는 소의 최댓값을 출력한다.

예제 입력 1

5 5
2 2 5
3 2 3 4
2 1 5
3 1 2 5
1 2

예제 출력 1

4

https://www.acmicpc.net/board/view/137221

예제 입력 A

4 3
1 1
1 2
1 3
1 3

예제 출력 A

3

예제 입력 B

4 3
0
0
0
0

예제 출력 B

0

예제 입력 C

4 3
1 1
1 2
2 1 2
2 1 2

예제 출력 C

2

예제 입력 D

50 40
2 24 21
1 39
4 30 31 15 18
2 21 3
4 21 40 39 30
1 20
5 20 30 4 29 25
3 39 9 33
1 32
5 27 22 36 2 11
1 9
5 35 29 14 38 1
3 28 22 1
4 18 20 29 22
3 5 11 38
2 36 30
5 9 17 35 10 19
3 18 31 7
3 4 36 30
4 24 12 9 14
3 28 2 27
3 13 6 2
3 6 37 39
4 5 26 15 16
3 25 6 36
2 9 31
3 17 6 7
5 27 4 13 29 30
1 1
1 12
5 3 1 38 8 5
2 14 12
3 17 39 12
3 30 15 26
2 21 3
3 7 6 11
2 28 13
2 25 16
2 19 16
1 13
5 39 24 34 29 33
2 40 10
3 6 35 40
1 37
2 24 35
4 11 22 3 29
3 19 7 16
1 14
1 38
5 31 14 28 19 6

예제 출력 D

39

출처

• 데이터를 추가한 사람: djm03178, rubix
• 문제의 오타를 찾은 사람: hun3555

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> cowInfo[201]; // 각 소가 원하는 축사 리스트
int barnMatch[201];       // barnMatch[b] = 소 번호 (b번 축사에 배정된 소)
bool visited[201];        // DFS 방문 체크

// 축사 매칭 시도
bool DFS(int cow) 
{

    for (int barn : cowInfo[cow]) 
    {
        if (visited[barn]) 
            continue;

        visited[barn] = true;

        // 이 축사가 비었거나, 이미 배정된 소가 다른 축사로 갈 수 있다면
        if (barnMatch[barn] == 0 || DFS(barnMatch[barn])) 
        {
            barnMatch[barn] = cow;
            return true;
        }
    }

    return false;
}

int main() 
{

    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, barn;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> barn;
            cowInfo[i].push_back(barn);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

백준에 해당 문제와 코드가 같은 문제

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

The post 백준 2188번 (축사 배정, C++) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

가장 긴 감소하는 부분 수열

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

문제

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

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

입력

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

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

출력

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

6
10 30 10 20 20 10

3

5
5 5 5 5 5

1

6
10 9 8 7 6 5

6

8
50 40 30 60 20 10 70 5

5

출처

• 문제를 만든 사람: baekjoon

비슷한 문제

• 11053번. 가장 긴 증가하는 부분 수열
• 11054번. 가장 긴 바이토닉 부분 수열
• 11055번. 가장 큰 증가하는 부분 수열
• 12015번. 가장 긴 증가하는 부분 수열 2
• 12738번. 가장 긴 증가하는 부분 수열 3
• 14002번. 가장 긴 증가하는 부분 수열 4
• 14003번. 가장 긴 증가하는 부분 수열 5

알고리즘 분류

• 다이나믹 프로그래밍

이진 탐색을 활용한 LDS (Longest Decreasing Subsequence, 최장 감소 부분 수열)

O(N log N)

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

pair<int, vector<int>> FindLDS(const vector<int>& input)
{
    int n = input.size();
    vector<int> tail; // 각 길이별 LDS의 마지막 원소 인덱스
    vector<int> prev_idx(n, -1); // 이전 원소의 인덱스 추적

    for (int i = 0; i < n; i++)
    {
        int lo = 0;
        int hi = (int)tail.size() - 1;
        int pos = (int)tail.size();

        while (lo <= hi)
        {
            int mid = (lo + hi) / 2;
            if (input[tail[mid]] > input[i])
            {
                lo = mid + 1;
            }
            else
            {
                pos = mid;
                hi = mid - 1;
            }
        }

        if (pos > 0)
        {
            prev_idx[i] = tail[pos - 1];
        }
        else
        {
            prev_idx[i] = -1;
        }

        if (pos == (int)tail.size())
        {
            tail.push_back(i);
        }
        else
        {
            tail[pos] = i;
        }
    }

    vector<int> lds;
    for (int idx = tail.back(); idx != -1; idx = prev_idx[idx])
    {
        lds.push_back(input[idx]);
    }
    reverse(lds.begin(), lds.end());

    return { tail.size(), lds };
}

int main()
{
    ios::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);

    int N;
    std::cin >> N;

    vector<int> input(N);
    for (int i = 0; i < N; i++)
        std::cin >> input[i];

    auto lds = FindLDS(input);

    cout << lds.first;

    return 0;
}

input = [9, 4, 3, 2, 5]

input = [10, 8, 6, 5, 7, 4, 3, 2, 9]

The post 백준 11722번 (가장 긴 감소하는 부분 수열, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 매겨져 있다.

바구니에는 공이 1개씩 들어있고, 처음에는 바구니에 적혀있는 번호와 같은 번호가 적힌 공이 들어있다.

도현이는 앞으로 M번 공을 바꾸려고 한다. 도현이는 공을 바꿀 바구니 2개를 선택하고, 두 바구니에 들어있는 공을 서로 교환한다.

공을 어떻게 바꿀지가 주어졌을 때, M번 공을 바꾼 이후에 각 바구니에 어떤 공이 들어있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N (1 ≤ N ≤ 100)과 M (1 ≤ M ≤ 100)이 주어진다.

둘째 줄부터 M개의 줄에 걸쳐서 공을 교환할 방법이 주어진다.

각 방법은 두 정수 i j로 이루어져 있으며, i번 바구니와 j번 바구니에 들어있는 공을 교환한다는 뜻이다. (1 ≤ i ≤ j ≤ N)

도현이는 입력으로 주어진 순서대로 공을 교환한다.

출력

1번 바구니부터 N번 바구니에 들어있는 공의 번호를 공백으로 구분해 출력한다.

예제 입력 1

5 4
1 2
3 4
1 4
2 2

예제 출력 1

3 1 4 2 5

출처

• 문제를 만든 사람: baekjoon
• 문제의 오타를 찾은 사람: onjo0127

알고리즘 분류

• 구현
• 시뮬레이션

통과된 코드

단순한 구현 문제

#include <iostream>

using namespace std;

int N, M;
int Arr[101] = { 0 };

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

	cin >> N >> M;

    for (int i = 1; i <= N; i++)
        Arr[i] = i;

	int t1, t2;

    for (int i = 0; i < M; i++) {
        cin >> t1 >> t2;
		swap(Arr[t1], Arr[t2]);
    }

    for (int i = 1; i <= N; i++)
		cout << Arr[i] << " ";

    return 0;
}

The post 백준 10813번 (공 바꾸기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

상근이는 문자열에 폭발 문자열을 심어 놓았다.

폭발 문자열이 폭발하면 그 문자는 문자열에서 사라지며, 남은 문자열은 합쳐지게 된다.

폭발은 다음과 같은 과정으로 진행된다.

• 문자열이 폭발 문자열을 포함하고 있는 경우에, 모든 폭발 문자열이 폭발하게 된다.
  남은 문자열을 순서대로 이어 붙여 새로운 문자열을 만든다.
• 새로 생긴 문자열에 폭발 문자열이 포함되어 있을 수도 있다.
• 폭발은 폭발 문자열이 문자열에 없을 때까지 계속된다.

상근이는 모든 폭발이 끝난 후에 어떤 문자열이 남는지 구해보려고 한다.

남아있는 문자가 없는 경우가 있다. 이때는 “FRULA”를 출력한다.

폭발 문자열은 같은 문자를 두 개 이상 포함하지 않는다.

입력

첫째 줄에 문자열이 주어진다. 문자열의 길이는 1보다 크거나 같고, 1,000,000보다 작거나 같다.

둘째 줄에 폭발 문자열이 주어진다. 길이는 1보다 크거나 같고, 36보다 작거나 같다.

두 문자열은 모두 알파벳 소문자와 대문자, 숫자 0, 1, …, 9로만 이루어져 있다.

출력

첫째 줄에 모든 폭발이 끝난 후 남은 문자열을 출력한다.

예제 입력 1

mirkovC4nizCC44
C4

예제 출력 1

mirkovniz

예제 입력 2

12ab112ab2ab
12ab

예제 출력 2

FRULA

출처

Contest > Croatian Open Competition in Informatics > COCI 2013/2014 > Contest #5 3번

• 문제를 번역한 사람: baekjoon
• 문제의 오타를 찾은 사람: chan4928
• 시간 제한을 수정한 사람: jh05013
• 데이터를 추가한 사람: limequeen, mrseos

알고리즘 분류

• 자료 구조
• 문자열
• 스택

통과된 코드

#include <iostream>
#include <string>

using namespace std;

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

    string S, C;
    cin >> S >> C;

    string Res; 

    for (char ch : S)
    {
        Res.push_back(ch);

        // Res의 마지막 부분이 c와 같은지 확인
        if (Res.size() >= C.size() && Res.substr(Res.size() - C.size()) == C)
        {
            // 문자열에서 폭발 문자열 제거
            Res.erase(Res.size() - C.size()); 
        }
    }

    cout << (Res.empty() ? "FRULA" : Res);

    return 0;
}

예시
ch = 'm': Res = "m"
ch = 'i': Res = "mi"
ch = 'r': Res = "mir"
ch = 'k': Res = "mirk"
ch = 'o': Res = "mirko"
ch = 'v': Res = "mirkov"
ch = 'C': Res = "mirkovC"
ch = '4': Res = "mirkovC4"
ch = 'n': Res = "mirkovn"
ch = 'i': Res = "mirkovni"
ch = 'z': Res = "mirkoviz"
ch = 'C': Res = "mirkovnizC"
ch = 'C': Res = "mirkovnizCC"
ch = '4': Res = "mirkovnizCC4"
ch = '4': Res = "mirkovnizC4"
Res = “mirkovniz”

The post 백준 9935번 (문자열 폭발, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

피보나치 수는 0과 1로 시작한다. 0번째 피보나치 수는 0이고, 1번째 피보나치 수는 1이다.

그 다음 2번째 부터는 바로 앞 두 피보나치 수의 합이 된다.

이를 식으로 써보면 F_n = F_n-1 + F_n-2 (n ≥ 2)가 된다.

n=17일때 까지 피보나치 수를 써보면 다음과 같다.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597

n이 주어졌을 때, n번째 피보나치 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 n이 주어진다. n은 1,000,000,000,000,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 n번째 피보나치 수를 1,000,000,007으로 나눈 나머지를 출력한다.

예제 입력 1

1000

예제 출력 1

517691607

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 수학
• 분할 정복을 이용한 거듭제곱

문제를 그대로 구현한 코드

답은 정확하게 나오지만 N의 크기가 증가하면 증가할 수록 연산량이 증가하여 시간초과 결과가 나오는 것은 당연하다.

#include <iostream>

using namespace std;

long long int N, t1, t2, t3;

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

	cin >> N;
    t1 = 0;
    t2 = 1;
    t3 = 1;

	if (N == 0) cout << t1;
	else if (N == 1) cout << t2;
	else if (N == 2) cout << t3;
    else 
    {
        for (int i = 2; i < N; i++)
        {
            t1 = t2 % 1000000007;
            t2 = t3 % 1000000007;
            t3 = (t1 + t2) % 1000000007;
        }
    }

	cout << t3 << endl;
    return 0;
}

피보나치 수를 더 좋은 방법으로 해결하는 방법은 아래 링크에 자세하게 설명되어 있다.

https://www.acmicpc.net/blog/view/28

위의 게시글의 내용을 살펴보면 2가지로 문제를 해결하고 있다.

통과된 코드

메모이제이션, 홀수/짝수를 이용한 풀이법을 적용한 코드

#include <iostream>
#include <map>

using namespace std;

map<long long, long long> d; // 메모이제이션을 위한 map
const long long mod = 1000000007; 

// 피보나치 수를 재귀적으로 계산하는 함수
long long Fibonacci_recursive(long long n) {
    if (n <= 0) {
        return 0;
    }
    else if (n == 1 || n == 2) {
        return 1;
    }
    else if (d.count(n) > 0) {
        return d[n];
    }
    else {
        // n이 홀수
        if (n % 2 == 1) {
            long long m = (n + 1) / 2;
            long long t1 = Fibonacci_recursive(m);
            long long t2 = Fibonacci_recursive(m - 1);
            d[n] = t1 * t1 + t2 * t2;
            d[n] %= mod;
            return d[n];
        }
        else { // n이 짝수
            long long m = n / 2;
            long long t1 = Fibonacci_recursive(m - 1);
            long long t2 = Fibonacci_recursive(m);
            d[n] = (2LL * t1 + t2) * t2;
            d[n] %= mod;
            return d[n];
        }
    }
}

int main() {
    long long n;
    cin >> n; // 입력값 받기
    cout << Fibonacci_recursive(n) << '\n'; // n번째 피보나치 수 출력
    return 0;
}

개인적으로 이런 수학적인 문제는 어느 정도 고민해보다 검색해보는 것이 공부하는 데 더 도움이 되는 것 같다.

The post 백준 11444번 (피보나치 수 6, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

은하는 긴 막대에 N개의 과일이 꽂혀있는 과일 탕후루를 만들었습니다.

과일의 각 종류에는 1부터 9까지의 번호가 붙어있고, 앞쪽부터 차례로  번 과일이 꽂혀있습니다.

과일 탕후루를 다 만든 은하가 주문을 다시 확인해보니 과일을 두 종류 이하로 사용해 달라는 요청이 있었습니다.

탕후루를 다시 만들 시간이 없었던 은하는, 막대의 앞쪽과 뒤쪽에서 몇 개의 과일을 빼서 두 종류 이하의 과일만 남기기로 했습니다.

앞에서 a개, 뒤에서 b개의 과일을 빼면  번 과일, 총 N – (a + b)개가 꽂혀있는 탕후루가 됩니다.

이렇게 만들 수 있는 과일을 두 종류 이하로 사용한 탕후루 중에서, 과일의 개수가 가장 많은 탕후루의 과일 개수를 구하세요.

입력

첫 줄에 과일의 개수 N이 주어집니다. 

둘째 줄에 탕후루에 꽂힌 과일을 의미하는 N개의 정수  이 공백으로 구분되어 주어집니다. 

출력

문제의 방법대로 만들 수 있는 과일을 두 종류 이하로 사용한 탕후루 중에서, 과일의 개수가 가장 많은 탕후루의 과일 개수를 첫째 줄에 출력하세요.

예제 입력 1

5
5 1 1 2 1

예제 출력 1

4

과일을 앞에서 1개, 뒤에서 0개의 과일을 빼면 남은 과일은 1, 1, 2, 1번 과일이 꽂혀있는 탕후루가 됩니다.

과일의 개수는 4개입니다.

예제 입력 2

3
1 1 1

예제 출력 2

3

탕후루가 이미 두 종류 이하의 과일로만 이루어져 있습니다.

예제 입력 3

9
1 2 3 4 5 6 7 8 9

예제 출력 3

2

과일을 앞에서 3개, 뒤에서 4개의 과일을 빼면 남은 과일은 4, 5번 과일이 꽂혀있는 탕후루가 됩니다.

과일의 개수는 2개입니다.

출처

Contest > solved.ac > solved.ac Grand Arena #3 > Division 2 C번

Contest > solved.ac > solved.ac Grand Arena #3 > Division 1 A번

• 문제를 만든 사람: cologne, havana723, solvedac
• 문제를 검수한 사람: cologne, cozyyg, gs18115, moonrabbit2, seonah

알고리즘 분류

• 구현
• 브루트포스 알고리즘
• 두 포인터

통과된 코드

map 자료구조, 두 포인터 알고리즘을 이용하여 문제를 해결

#include <iostream>
#include <map>

using namespace std;

int N;
int Arr[200000];

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

    cin >> N;

    for (int i = 0; i < N; i++)
        cin >> Arr[i];

    map<int, int> fruitCount;
    int left = 0, right = 0, maxLen = 0;

    while (right < N) 
    {
        // 오른쪽 과일 추가
        fruitCount[Arr[right]]++;

        while (fruitCount.size() > 2) 
        { 
            // 과일 종류가 2개 초과하면 줄이기
            fruitCount[Arr[left]]--;
            if (fruitCount[Arr[left]] == 0)
                fruitCount.erase(Arr[left]);
            left++;
        }

        // 최대 길이 갱신
        maxLen = max(maxLen, right - left + 1);
        right++;
    }

    cout << maxLen << "\n";

    return 0;
}

Arr[] 범위를 20,000으로 오타를 내고 제출하여 계속 오답을 받았다. (올바른 범위는 200,000)

The post 백준 30804번 (과일 탕후루, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

FizzBuzz 문제는 i=1,2,⋯ 에 대해 다음 규칙에 따라 문자열을 한 줄에 하나씩 출력하는 문제입니다.

•  i가 3의 배수이면서 5의 배수이면 “FizzBuzz”를 출력합니다.
•  i가 3의 배수이지만 5의 배수가 아니면 “Fizz”를 출력합니다.
•  i가 3의 배수가 아니지만 5의 배수이면 “Buzz”를 출력합니다.
•  i가 3의 배수도 아니고 5의 배수도 아닌 경우 i를 그대로 출력합니다.

FizzBuzz 문제에서 연속으로 출력된 세 개의 문자열이 주어집니다.

이때, 이 세 문자열 다음에 올 문자열은 무엇일까요?

입력

FizzBuzz 문제에서 연속으로 출력된 세 개의 문자열이 한 줄에 하나씩 주어집니다.

각 문자열의 길이는 8 이하입니다. 입력이 항상 FizzBuzz 문제에서 연속으로 출력된 세 개의 문자열에 대응됨이 보장됩니다.

출력

연속으로 출력된 세 개의 문자열 다음에 올 문자열을 출력하세요.

여러 문자열이 올 수 있는 경우, 아무거나 하나 출력하세요.

예제 입력 1

Fizz
Buzz
11

예제 출력 1

Fizz

예제 입력 2

980803
980804
FizzBuzz

예제 출력 2

980806

힌트

FizzBuzz 문제의 i = 1 ,⋯, 20에 대한 출력은 다음과 같습니다.

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz

출처

Contest > solved.ac > solved.ac Grand Arena #2 B번

• 문제를 검수한 사람: ai4youej, bnb2011, chansol, cologne, cozyyg, gs18115, havana723, jh05013, moonrabbit2, pichulia, shiftpsh
• 문제를 만든 사람: cologne, solvedac

알고리즘 분류

• 수학
• 문자열

통과된 코드

#include <iostream>
#include <string>

using namespace std;

string Input[3];

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

    for (int i = 0; i < 3; i++)
        cin >> Input[i];

    for (int i = 0; i < 3; i++) {
        if (Input[i][0] == 'F' || Input[i][0] == 'B')
            continue;

        int Num = stoi(Input[i]) + 3 - i;
        if (Num % 15 == 0) cout << "FizzBuzz";
        else if (Num % 5 == 0) cout << "Buzz";
        else if (Num % 3 == 0) cout << "Fizz";
        else cout << Num;
        return 0;
    }

    cout << "FizzBuzz";

    return 0;
}

The post 백준 28702번 (FizzBuzz, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.