가장 긴 증가하는 부분 수열 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/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 어제와 내일의 나 그 사이의 이야기.

카드1

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

문제

N장의 카드가 있다. 각각의 카드는 차례로 1부터 N까지의 번호가 붙어 있으며,

1번 카드가 제일 위에, N번 카드가 제일 아래인 상태로 순서대로 카드가 놓여 있다.

이제 다음과 같은 동작을 카드가 한 장 남을 때까지 반복하게 된다.

우선, 제일 위에 있는 카드를 바닥에 버린다.

그 다음, 제일 위에 있는 카드를 제일 아래에 있는 카드 밑으로 옮긴다.

예를 들어 N=4인 경우를 생각해 보자.

카드는 제일 위에서부터 1234 의 순서로 놓여있다.

1을 버리면 234가 남는다. 여기서 2를 제일 아래로 옮기면 342가 된다.

3을 버리면 42가 되고, 4를 밑으로 옮기면 24가 된다.

마지막으로 2를 버리고 나면, 버린 카드들은 순서대로 1 3 2가 되고, 남는 카드는 4가 된다.

N이 주어졌을 때, 버린 카드들을 순서대로 출력하고,

마지막에 남게 되는 카드를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 정수 N(1 ≤ N ≤ 1,000)이 주어진다.

출력

첫째 줄에 버리는 카드들을 순서대로 출력한다.

제일 마지막에는 남게 되는 카드의 번호를 출력한다.

예제 입력 1

7

예제 출력 1

1 3 5 7 4 2 6

알고리즘 분류

• 구현
• 자료 구조
• 큐

통과된 코드

큐를 이용하여 상황을 구현하는 단순한 문제입니다.

#include <iostream>
#include <queue>
using namespace std;
queue<int> _MyQueue;
int _N;
int main()
{
	cin >> _N;
	for (int i = 1; i <= _N; i++)
		_MyQueue.push(i);
	while (true) {
		cout << _MyQueue.front() << " ";
		_MyQueue.pop();
		if (_MyQueue.empty())
			break;
		_MyQueue.push(_MyQueue.front());
		_MyQueue.pop();
	}
	return 0;
}

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

트라이(Trie)?

Trie data structure는 문자열을 효율적으로 저장하고 검색하는 데 사용되는 Tree와 유사한 데이터 구조입니다.

“Trie”라는 이름은 “트리”와 비슷하게 발음되는 “retrieval,”이라는 단어에서 유래되었습니다.

검색할 때 볼 수 있는 자동완성 기능, 사전 검색 등 문자열을 탐색하는데 특화되어있는 자료구조입니다.

“A”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”를 키로 둔 트라이.

이 예제에는 모든 자식 노드가 알파벳 순으로 왼쪽에서 오른쪽으로 정렬되어 있지는 않다. (루트 노드와 ‘t’ 노드)

Trie에서 각 node는 문자열의 단일 문자를 나타내고 node에서 나오는 가장자리는 문자열의 다음 문자를 나타냅니다.

Trie의 각 문자열은 root node에서 leaf node까지의 경로로 표시됩니다.

root node에는 연결된 문자가 없으며 각 leaf node는 데이터 세트의 전체 문자열을 나타냅니다.

Trie는 특히 공통 접두사를 공유하는 문자열을 검색할 때 문자열을 효율적으로 저장하고 검색하는 데 자주 사용됩니다.

예를 들어 Trie를 사용하여 단어 사전을 저장할 수 있습니다.

여기서 Trie의 각 node는 단어의 접두사를 나타냅니다.

Trie를 root node에서 leaf node로 이동하면 leaf node와 관련된 전체 단어를 빠르게 검색할 수 있습니다.

트라이(Trie)의 이점

1. 효율적인 접두사 검색

Trie는 특히 접두사 검색 쿼리에 효율적입니다.

root node에서 접두사를 나타내는 node로 Trie를 순회하면 해당 접두사로 시작하는 데이터 세트의 모든 문자열을 검색할 수 있습니다.

이는 자동 완성, 맞춤법 검사기 및 검색 엔진과 같은 응용 프로그램에서 유용합니다.

2. 공간 효율성

Trie는 해시 테이블과 같은 다른 데이터 구조에 비해 매우 공간 효율적일 수 있습니다.

문자열에 공통 접두사의 중복 저장을 방지하여 특히 문자열 수가 많은 데이터 세트의 경우 공간을 크게 절약할 수 있습니다.

3. 빠른 삽입 및 삭제

Trie는 문자열의 빠른 삽입 및 삭제를 지원하며 최악의 경우 O(m)의 시간 복잡도(m 문자열의 길이)입니다.

따라서 데이터 세트가 동적이며 자주 업데이트해야 하는 애플리케이션에서 유용합니다.

4. 예측 텍스트 입력

Trie는 자동 완성 시스템을 구현하는 데 사용할 수 있습니다.

여기서 시스템은 사용자 입력을 기반으로 다음 단어나 구문을 제안합니다.

자주 사용되는 단어와 구문의 Trie를 저장함으로써

시스템은 사용자의 현재 입력을 기반으로 가장 가능성이 높은 다음 단어를 제안할 수 있습니다.

5. 낮은 메모리 오버헤드

Trie는 특히 ASCII 또는 유니코드와 같은 작은 문자 세트의 경우 메모리 오버헤드가 낮습니다.

따라서 임베디드 시스템 및 기타 메모리 제약 환경에서 사용하기에 적합합니다.

전반적으로 Trie 데이터 구조는 문자열의 데이터 세트를 효율적으로 저장하고 처리하기 위한 강력한 도구입니다.

특히 기본 사용 사례가 접두사를 검색하거나 시퀀스의 다음 단어를 예측하는 경우에 그렇습니다.

트라이(Trie)의 잠재적인 단점

1. 메모리 요구 사항

Trie는 특히 문자열이 길거나 문자 집합이 큰 경우

큰 문자열 데이터 세트를 저장하기 위해 상당한 양의 메모리를 요구할 수 있습니다.

이는 메모리 사용량이 중요한 환경이나 응용 프로그램에서의 사용을 제한할 수 있습니다.

2. 접두사가 아닌 쿼리에 대한 느린 검색 시간

Trie는 접두사 검색 쿼리에 효율적이지만 접두사가 아닌 쿼리에 대한 다른 데이터 구조보다 느릴 수 있습니다.

알고리즘이 쿼리와 일치하는 모든 문자열을 찾기 위해 각 노드의 전체 하위 트리를 탐색해야 하므로

해시 테이블과 같은 다른 데이터 구조에 비해 검색 시간이 느려질 수 있기 때문입니다.

3. 복잡성

Trie 데이터 구조의 구현 및 유지 관리는

엄청나게 큰 데이터 세트의 경우 또는 문자 집합이 매우 복잡한 경우에

다른 데이터 구조보다 더 복잡할 수 있습니다.

이로 인해 개발 시간이 길어지고 개발 비용이 높아질 수 있습니다.

4. 희소 데이터 집합에 대한 비효율적인 메모리 사용

데이터 집합에 희소 문자열이 많이 포함되어 있거나 공통 접두사가 거의 없는 경우

Trie는 가장 메모리 효율적인 데이터 구조가 아닐 수 있습니다.

이는 Trie가 많은 빈 노드를 저장해야 하므로 메모리가 낭비될 수 있기 때문입니다.

전반적으로 Trie 데이터 구조는 효율적인 문자열 처리를 위한 강력한 도구이지만

응용 프로그램의 특정 요구 사항에 따라 항상 최선의 선택이 아닐 수도 있습니다.

트라이(Trie)의 시간 복잡도

일반적으로 Trie의 생성 시간 복잡도는 O(M x L), 탐색 시간 복잡도는 O(L)이다.

제일 긴 문자열의 길이를 L이라 하고, 총 문자열들의 수를 M이라 할 때 시간 복잡도는 위와 같다.

생성 시간 복잡도는 모든 문자열 M 개를 넣어야 하고,

M 개에 대해서 트라이에 넣는 건 가장 긴 문자열 길이인 L 만큼 걸리므로 O(MxL)의 시간 복잡도를 가진다. (삽입은 O(L)이다.)

탐색 시간 복잡도는 트리를 제일 깊게 탐색하는 경우는 가장 긴 문자열 길이인 L까지 깊게 들어가는 것이므로 O(L)의 시간 복잡도를 가진다.

트라이(Trie) 구현 (C++)

#include <iostream>
#include <unordered_map>

using namespace std;

// TrieNode클래스를 사용하여 Trie의 각 노드를 표현
class TrieNode {

public:
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord;

    TrieNode() { 
        isEndOfWord = false;
    }
    
};

// Trie 클래스
class Trie {

    // Trie의 루트 노드에 대한 포인터인 Trie개인 멤버 변수
    private: 
        TrieNode* root; // 루트 노드

// 생성자새 인스턴스를 만들고 Trie를 초기화합
    public:
        Trie() {
            root = new TrieNode();
        }


    // 문자열을 받아 Trie에 추가합니다. 
    // 루트 노드에서 시작하여 Trie 아래로 이동하여 단어의 각 문자에 필요한 새 노드를 만듭니다.
    void insert(string word) {
        TrieNode* curr = root; // 시작
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) {
                // Trie에 없다면 새 노드 생성
                curr->children[c] = new TrieNode();
            }
            curr = curr->children[c]; // Trie에 이미 존재하는 경우 기존 노드로 이동
        }
        // 단어의 끝을 나타내는 isEndOfWord bool값
        curr->isEndOfWord = true;
    }

    // 단어를 검색합니다.
    bool search(string word) {
        TrieNode* curr = root;
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return curr->isEndOfWord;
    }

    // prefix(접두사)로 시작하는 단어가 Trie에 있는지 확인
    bool startsWith(string prefix) {
        TrieNode* curr = root;
        for (char c : prefix) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return true;
    }
};

int main() {

    Trie trie;
    trie.insert("hello");
    trie.insert("world");
    trie.insert("hello world");

    cout << trie.search("hello") << "\n";      // output: 1 (true)
    cout << trie.search("hello world") << "\n"; // output: 1 (true)
    cout << trie.search("hi") << "\n";         // output: 0 (false)

    cout << trie.startsWith("hell") << "\n";    // output: 1 (true)
    cout << trie.startsWith("heaven") << "\n";  // output: 0 (false)

    return 0;
}

#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

// TrieNode클래스를 사용하여 Trie의 각 노드를 표현
class TrieNode {
public:
    unordered_map<char, TrieNode*> children;
    int num; // 연관된 단어의 개수를 저장
    TrieNode() {
        num = 0;
    }
};

// Trie 클래스
class Trie {

private: // Trie의 루트 노드에 대한 포인터인 Trie개인 멤버 변수
    TrieNode* root; // 루트 노드


public:
    Trie() { // 생성자새 인스턴스를 만들고 Trie를 초기화
        root = new TrieNode();
    }

    // 문자열을 받아 Trie에 추가합니다. 
    // 루트 노드에서 시작하여 Trie 아래로 이동하여 단어의 각 문자에 필요한 새 노드를 만듭니다.
    void insert(string word) {
        TrieNode* curr = root; // 시작
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) {
                // Trie에 없다면 새 노드 생성
                curr->children[c] = new TrieNode();
            }

            // Trie에 이미 존재하는 경우 기존 노드로 이동
            curr = curr->children[c];
            curr->num++; // 연관된 단어의 개수 추가
        }
    }

    // 단어를 검색합니다.
    // 연관된 단어의 개수가 1이라면 글자수 반환
    int search(string word) {
        TrieNode* curr = root;
        int cnt = 0;
        for (char c : word) {
            curr = curr->children[c];
            cnt++;
            if (curr->num == 1) {
                // 연관된 단어의 개수가 1이라면 
                // 자동완성
                return cnt;
            }
        }
        return 9999; // 문제에서 나올 수 없는 경우 
    }

    // prefix(접두사)로 시작하는 단어가 Trie에 있는지 확인
    int startsWith(string prefix) {
        TrieNode* curr = root;
        for (char c : prefix) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return curr->children.size();
    }

};

int solution(vector<string> words) {
    int answer = 0;
    Trie trie;
    for (auto& it : words) {
        trie.insert(it);
    }

    for (auto& it : words) {
        if (trie.startsWith(it) >= 1) {
            // 접두사로 시작하는 단어가 있다면 
            // 단어 전체를 입력해야한다.
            answer += it.length();
            continue;
        }

        // 자동완성 확인
        answer += trie.search(it);
    }

    return answer;
}

https://www.acmicpc.net/problemset?sort=ac_desc&algo=79 <- 트라이 연습 문제 모음

The post 알고리즘 – 트라이(Trie) 자료구조 appeared first on 어제와 내일의 나 그 사이의 이야기.

접두사

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

문제

접두사X 집합이란 집합의 어떤 한 단어가, 다른 단어의 접두어가 되지 않는 집합이다.

예를 들어, {hello}, {hello, goodbye, giant, hi}, 비어있는 집합은 모두 접두사X 집합이다.

하지만, {hello, hell}, {giant, gig, g}는 접두사X 집합이 아니다.

단어 N개로 이루어진 집합이 주어질 때, 접두사X 집합인 부분집합의 최대 크기를 출력하시오.

입력

첫째 줄에 단어의 개수 N이 주어진다. N은 50보다 작거나 같은 자연수이다.

둘째 줄부터 N개의 줄에는 단어가 주어진다.

단어는 알파벳 소문자로만 이루어져 있고, 길이는 최대 50이다.

집합에는 같은 단어가 두 번 이상 있을 수 있다.

출력

첫째 줄에 문제의 정답을 출력한다.

예제 입력 1

6
hello
hi
h
run
rerun
running

예제 출력 1

4

예제 입력 2

6
a
b
cba
cbc
cbb
ccc

예제 출력 2

6

예제 입력 3

6
a
ab
abc
abcd
abcde
abcdef

예제 출력 3

1

예제 입력 4

3
topcoder
topcoder
topcoding

예제 출력 4

2

출처

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 자료 구조
• 문자열
• 정렬
• 트리
• 트라이

통과된 코드

#include <iostream>
#include <set>
#include <unordered_map>

using namespace std;

// TrieNode클래스를 사용하여 Trie의 각 노드를 표현
class TrieNode {

public:
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord;

    TrieNode() {
        isEndOfWord = false;
    }

};

// Trie 클래스
class Trie {

    // Trie의 루트 노드에 대한 포인터인 Trie개인 멤버 변수
private:
    TrieNode* root; // 루트 노드

// 생성자새 인스턴스를 만들고 Trie를 초기화합
public:
    Trie() {
        root = new TrieNode();
    }

    // 문자열을 받아 Trie에 추가합니다. 
    // 루트 노드에서 시작하여 Trie 아래로 이동하여 단어의 각 문자에 필요한 새 노드를 만듭니다.
    void insert(string word) {
        TrieNode* curr = root; // 시작
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) 
                curr->children[c] = new TrieNode(); // Trie에 없다면 새 노드 생성
            
            curr = curr->children[c]; // Trie에 이미 존재하는 경우 기존 노드로 이동
        }
        // 단어의 끝을 나타내는 isEndOfWord bool값
        curr->isEndOfWord = true;
    }

    // prefix(접두사)로 시작하는 단어가 Trie에 있는지 확인
    int startsWith(string prefix) {
        TrieNode* curr = root;
        for (char c : prefix) {
            if (curr->children.find(c) == curr->children.end()) 
                return curr->children.size();
            
            curr = curr->children[c];
        }
        return curr->children.size();
    }
};

int main() {

    Trie trie;
    int N;
    set<string> myV;
    string str;

    cin >> N;

    for (int i = 0; i < N; i++) {
        cin >> str;
        myV.insert(str); // set으로 중복 제거
        trie.insert(str);
    }

    int res = myV.size();

    for (auto &it : myV) 
        if (trie.startsWith(it) >= 1 ) res--;
    
    cout << res;

    return 0;
}

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

접두사 찾기

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

문제

문자열 S의 접두사란 S의 가장 앞에서부터 부분 문자열을 의미한다.

예를 들어, S = “codeplus”의 접두사는 “code”, “co”, “codepl”, “codeplus”가 있고, “plus”, “s”, “cude”, “crud”는 접두사가 아니다.

총 N개의 문자열로 이루어진 집합 S가 주어진다.

입력으로 주어지는 M개의 문자열 중에서 집합 S에 포함되어 있는 문자열 중

적어도 하나의 접두사인 것의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 문자열의 개수 N과 M (1 ≤ N ≤ 10,000, 1 ≤ M ≤ 10,000)이 주어진다.

다음 N개의 줄에는 집합 S에 포함되어 있는 문자열이 주어진다.

다음 M개의 줄에는 검사해야 하는 문자열이 주어진다.

입력으로 주어지는 문자열은 알파벳 소문자로만 이루어져 있으며, 길이는 500을 넘지 않는다.

집합 S에 같은 문자열이 여러 번 주어지는 경우는 없다.

출력

첫째 줄에 M개의 문자열 중에 총 몇 개가 포함되어 있는 문자열 중 적어도 하나의 접두사인지 출력한다.

예제 입력 1

5 10
baekjoononlinejudge
startlink
codeplus
sundaycoding
codingsh
baekjoon
star
start
code
sunday
coding
cod
online
judge
plus

예제 출력 1

7

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: besyia0k0, jh05013
• 문제의 오타를 찾은 사람: Green55

알고리즘 분류

• 자료 구조
• 문자열
• 트리
• 트라이

통과된 코드

#include <iostream>
#include <unordered_map>

using namespace std;

// TrieNode클래스를 사용하여 Trie의 각 노드를 표현
class TrieNode {

public:
    unordered_map<char, TrieNode*> children;
};

// Trie 클래스
class Trie {

    // Trie의 루트 노드에 대한 포인터인 Trie개인 멤버 변수
private:
    TrieNode* root; // 루트 노드

// 생성자새 인스턴스를 만들고 Trie를 초기화합
public:
    Trie() {
        root = new TrieNode();
    }

    // 문자열을 받아 Trie에 추가합니다. 
    // 루트 노드에서 시작하여 Trie 아래로 이동하여 단어의 각 문자에 필요한 새 노드를 만듭니다.
    void insert(string word) {
        TrieNode* curr = root; // 시작
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end())
                curr->children[c] = new TrieNode(); // Trie에 없다면 새 노드 생성

            curr = curr->children[c]; // Trie에 이미 존재하는 경우 기존 노드로 이동
        }
    }

    // prefix(접두사)로 시작하는 단어가 Trie에 있는지 확인
    bool startsWith(string prefix) {
        TrieNode* curr = root;
        for (char c : prefix) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return true;
    }
};

int main() {

    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    // cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
    cin.tie(NULL);
    cout.tie(NULL);

    Trie trie;
    int N, M, res = 0;
    string str;

    cin >> N >> M;

    for (int i = 0; i < N; i++) {
        cin >> str;
        trie.insert(str); // 트라이 입력
    }

    for (int i = 0; i < M; i++) {
        cin >> str;
        if (trie.startsWith(str)) res++; // 접두사 확인
    }

    cout << res;

    return 0;
}

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

여러분의 다리가 되어 드리겠습니다!

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

문제

선린월드에는 N개의 섬이 있다. 섬에는 1, 2, …, N의 번호가 하나씩 붙어 있다. 

그 섬들을 N – 1개의 다리가 잇고 있으며, 어떤 두 섬 사이든 다리로 왕복할 수 있다.

어제까지는 그랬다.

“왜 다리가 N – 1개밖에 없냐, 통행하기 불편하다”며 선린월드에 불만을 갖던 욱제가 다리 하나를 무너뜨렸다!

안 그래도 불편한 통행이 더 불편해졌다. 서로 왕복할 수 없는 섬들이 생겼기 때문이다.

일단 급한 대로 정부는 선린월드의 건축가를 고용해,

서로 다른 두 섬을 다리로 이어서 다시 어떤 두 섬 사이든 왕복할 수 있게 하라는 지시를 내렸다.

그런데 그 건축가가 당신이다! 안 그래도 천하제일 코딩대회에 참가하느라 바쁜데…

입력

첫 줄에 정수 N이 주어진다. (2 ≤ N ≤ 300,000)

그 다음 N – 2개의 줄에는 욱제가 무너뜨리지 않은 다리들이 잇는 두 섬의 번호가 주어진다.

출력

다리로 이을 두 섬의 번호를 출력한다.

여러 가지 방법이 있을 경우 그 중 아무거나 한 방법만 출력한다.

예제 입력 1

4
1 2
1 3

예제 출력 1

1 4

“4 1″이나 “2 4”, “4 3” 등 가능한 정답은 많이 있지만, 아무거나 하나만 출력해야 한다.

예제 입력 2

2

예제 출력 2

1 2

예제 입력 3

5
1 2
2 3
4 5

예제 출력 3

3 4

출처

High School > 선린인터넷고등학교 > 제3회 천하제일 코딩대회 D번

• 문제를 만든 사람: jh05013

알고리즘 분류

• 자료 구조
• 그래프 이론
• 그래프 탐색
• 분리 집합

접근 방법

통과된 코드

#include <iostream>

using namespace std;

constexpr int MAX = 300001;

int N, v, u;

int parent[MAX];

void MakeSet(int n)
{
	for (int i = 1; i <= n; i++)  parent[i] = i;
}

int Find(int x) {

	if (parent[x] != x) parent[x] = Find(parent[x]); // Path compression

	return parent[x];
}

void Unite(int x, int y) {
	int rootX = Find(x);
	int rootY = Find(y);
	parent[rootY] = rootX; // Make rootX the parent of rootY
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N;
	MakeSet(N);
	for (int i = 0; i < N - 2; i++) {
		cin >> v >> u;
		Unite(v, u);
	}

	int first, second = -1;
	first = Find(1);
	for (int i = 2; i <= N; i++) {
		if (Find(i) != first) {
			second = Find(i);
			break;
		}
	}

	cout << first << " " << second;

	return 0;
}

The post 백준 17352번 (여러분의 다리가 되어 드리겠습니다!, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

회의준비

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

문제

KOI 준비를 위해 회의를 개최하려 한다.

주최측에서는 회의에 참석하는 사람의 수와 참석자들 사이의 관계를 따져 하나 이상의 위원회를 구성하려고 한다.

위원회를 구성하는 방식은 다음과 같다.

1. 서로 알고 있는 사람은 반드시 같은 위원회에 속해야 한다.

2. 효율적인 회의 진행을 위해 위원회의 수는 최대가 되어야 한다.

이런 방식으로 위원회를 구성한 후에 각 위원회의 대표를 한 명씩 뽑아야 한다.

각 위원회의 대표만이 회의 시간 중 발언권을 가지며,

따라서 회의 참석자들이 자신의 의견을 말하기 위해서는 자신이 속한 위원회의 대표에게 자신의 의견을 전달해야 한다.

그런데 각 참석자는 자신이 알고 있는 사람에게만 의견을 전달할 수 있어 대표에게 의견을 전달하기 위해서는 때로 여러 사람을 거쳐야 한다.

대표에게 의견을 전달하는 경로가 여러 개 있을 경우에는 가장 적은 사람을 거치는 경로로 의견을 전달하며

이때 거치는 사람의 수를 참석자의 의사전달시간이라고 한다.

위원회에서 모든 참석자들의 의사전달시간 중 최댓값이 최소가 되도록 대표를 정하는 프로그램을 작성하시오.

예를 들어 1번, 2번, 3번 세 사람으로 구성되어 있는 위원회에서 1번과 2번, 2번과 3번이 서로 알고 있다고 하자.

1번이 대표가 되면 3번이 대표인 1번에게 의견을 전달하기 위해서 2번을 거쳐야만 한다.

반대로 3번이 대표가 되어도 1번이 대표인 3번에게 의견을 전달하려면 2번을 거쳐야만 한다.

하지만 2번이 대표가 되면 1번과 3번 둘 다 아무도 거치지 않고 대표에게 직접 의견을 전달 할 수 있다.

따라서 이와 같은 경우 2번이 대표가 되어야 한다.

입력

첫째 중에 회의에 참석하는 사람의 수 N이 주어진다.

참석자들은 1부터 N까지의 자연수로 표현되며 회의에 참석하는 인원은 100 이하이다.

둘째 줄에는 서로 알고 있는 관계의 수 M이 주어진다.

이어 M개의 각 줄에는 서로 아는 사이인 참석자를 나타내는 두개의 자연수가 주어진다.

출력

첫째 줄에는 구성되는 위원회의 수 K를 출력한다.

다음 K줄에는 각 위원회의 대표 번호를 작은 수부터 차례로 한 줄에 하나씩 출력한다.

한 위원회의 대표가 될 수 있는 사람이 둘 이상일 경우 그중 한 명만 출력하면 된다.

예제 입력 1

8
7
1 2
2 3
4 5
5 6
4 6
6 7
7 4

예제 출력 1

3
2
4
8

추가 반례

예제 입력 A

100
0

예제 출력 A

100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

예제 입력 B

9
8
1 2
2 3
3 4
4 5
4 6
4 7
4 8
4 9

예제 출력 B

1
3

예제 입력 C

5
4
5 1
1 2
2 3
3 4

예제 출력 C

1
2

출처

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2004 > 중등부 3번

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2004 > 고등부 3번

• 데이터를 추가한 사람: eightco
• 문제의 오타를 찾은 사람: sky1357

알고리즘 분류

• 자료 구조
• 그래프 이론
• 그래프 탐색
• 분리 집합
• 플로이드–워셜

통과된 코드

Floyd-Warshall 알고리즘을 이용하여 의사전달 시간의 최솟값을 구한다.

그 후에 Union-Find를 이용하여 위원회의 개수와 대표를 구하면 된다.

(분리 집합 + 플로이드 와샬 문제)

#include <iostream>
#include <vector>
#include <set>

using namespace std;

// N : 참석하는 사람
int N, K, f, b;

constexpr int INF = INT32_MAX/2;

constexpr int MAX = 101;

vector<pair<int, int>> graph[MAX];

int disArr[MAX][MAX];

int sumArr[MAX];

// 유니온 root노드 배열
int uArr[MAX];

set<int> checkSet;

//부모를 찾는 함수
//모든 경로가 부모를 가르키게 함
//상수 시간의 복잡도
int Find(int x)
{
	if (uArr[x] == x) return x;
	else return uArr[x] = Find(uArr[x]);
}

//두 노드를 연결 시키는 것
//기준을 정해서 연결시키는 것이 헷갈리지 않음
//작은쪽이 부모 or 큰쪽이 부모
void Union(int x, int y)
{
	x = Find(x);
	y = Find(y);
	if (x != y) {
		if (sumArr[x] <= sumArr[y]) uArr[y] = x;
		else uArr[x] = y;
	}
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N >> K;

	// 유니온 배열 초기화
	for (int i = 1; i <= N; i++) uArr[i] = i;

	// 서로를 알고 있음(양방향)
	for (int i = 0; i < K; i++) {
		cin >> f >> b;
		graph[f].push_back(make_pair(b, 1));
		graph[b].push_back(make_pair(f, 1));
	}

	// 최단 거리 배열 disArr 배열을 INF 초기화
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			disArr[i][j] = INF;
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 0; j < graph[i].size(); j++) {
			int v = graph[i][j].first;
			int weight = graph[i][j].second;
			disArr[i][v] = weight;
		}
	}

	// Floyd-Warshall 알고리즘
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {
				if (i == j) disArr[i][j] = 0;
				else disArr[i][j] = min(disArr[i][j], disArr[i][k] + disArr[k][j]);
			}
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			
			if (disArr[i][j] == INF) continue;
			// 의사전달시간 중 최대값이 최소가 되도록 대표를 선출
			sumArr[i] = max(sumArr[i], disArr[i][j]); 
		}
	}

	for (int i = 1; i <= N; i++) {
		for (int j = 0; j < graph[i].size(); j++) {
			// Union Find를 사용하여 위원회를 구성
			Union(i, graph[i][j].first);
		}
	}

	// 결과를 출력
	// Set을 이용하여 위원회의 개수와 대표를 저장
	for (int i = 1; i <= N; i++) checkSet.insert(Find(i));
	
	cout << checkSet.size() << "\n";
	for (auto& it : checkSet) cout << it << "\n";

	return 0;
}

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

뱀과 사다리 게임

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

문제

뱀과 사다리 게임을 즐겨 하는 큐브러버는 어느 날 궁금한 점이 생겼다.

주사위를 조작해 내가 원하는 수가 나오게 만들 수 있다면, 최소 몇 번만에 도착점에 도착할 수 있을까?

게임은 정육면체 주사위를 사용하며, 주사위의 각 면에는 1부터 6까지 수가 하나씩 적혀있다.

게임은 크기가 10×10이고, 총 100개의 칸으로 나누어져 있는 보드판에서 진행된다.

보드판에는 1부터 100까지 수가 하나씩 순서대로 적혀져 있다.

플레이어는 주사위를 굴려 나온 수만큼 이동해야 한다.

예를 들어, 플레이어가 i번 칸에 있고, 주사위를 굴려 나온 수가 4라면, i+4번 칸으로 이동해야 한다.

만약 주사위를 굴린 결과가 100번 칸을 넘어간다면 이동할 수 없다.

도착한 칸이 사다리면, 사다리를 타고 위로 올라간다.

뱀이 있는 칸에 도착하면, 뱀을 따라서 내려가게 된다.

즉, 사다리를 이용해 이동한 칸의 번호는 원래 있던 칸의 번호보다 크고,

뱀을 이용해 이동한 칸의 번호는 원래 있던 칸의 번호보다 작아진다.

게임의 목표는 1번 칸에서 시작해서 100번 칸에 도착하는 것이다.

게임판의 상태가 주어졌을 때, 100번 칸에 도착하기 위해 주사위를 굴려야 하는 횟수의 최솟값을 구해보자.

입력

첫째 줄에 게임판에 있는 사다리의 수 N(1 ≤ N ≤ 15)과 뱀의 수 M(1 ≤ M ≤ 15)이 주어진다.

둘째 줄부터 N개의 줄에는 사다리의 정보를 의미하는 x, y (x < y)가 주어진다.

x번 칸에 도착하면, y번 칸으로 이동한다는 의미이다.

다음 M개의 줄에는 뱀의 정보를 의미하는 u, v (u > v)가 주어진다.

u번 칸에 도착하면, v번 칸으로 이동한다는 의미이다.

1번 칸과 100번 칸은 뱀과 사다리의 시작 또는 끝이 아니다.

모든 칸은 최대 하나의 사다리 또는 뱀을 가지고 있으며, 동시에 두 가지를 모두 가지고 있는 경우는 없다.

항상 100번 칸에 도착할 수 있는 입력만 주어진다.

출력

100번 칸에 도착하기 위해 주사위를 최소 몇 번 굴려야 하는지 출력한다.

예제 입력 1

3 7
32 62
42 68
12 98
95 13
97 25
93 37
79 27
75 19
49 47
67 17

1. 5를 굴려 6으로 이동한다.
2. 6을 굴려 12로 이동한다. 이 곳은 98로 이동하는 사다리가 있기 때문에, 98로 이동한다.
3. 2를 굴려 100으로 이동한다.

예제 출력 1

3

예제 입력 2

4 9
8 52
6 80
26 42
2 72
51 19
39 11
37 29
81 3
59 5
79 23
53 7
43 33
77 21

1. 5를 굴려 6으로 이동하고, 사다리를 이용해 80으로 이동한다. 
2. 6을 굴려 86으로
3. 6을 또 굴려 92로
4. 6을 또 굴려 98로 이동하고
5. 2를 굴려 100으로 이동한다.

예제 출력 2

5

출처

• 문제를 번역한 사람: baekjoon
• 빠진 조건을 찾은 사람: jh05013

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색

https://kr.123rf.com/photo_27714698_%EB%B1%80%EA%B3%BC-%EC%82%AC%EB%8B%A4%EB%A6%AC-%EB%B3%B4%EB%93%9C-%EA%B2%8C%EC%9E%84.html

접근 방법

너비 우선 검색(BFS)을 사용하여 시작 위치에서 최종 위치까지의 최단 경로를 찾으면 됩니다.

BFS 탐색 시 Queue에는 사각형의 위치와 해당 사각형에 도달하는 데 필요한 주사위 횟수를 저장합니다.

Queue에서 꺼내고 방문한 각 사각형에 대해 주사위를 굴리고 (1 – 6)

주사위 만큼 다음 사각형으로 이동하고 주사위 횟수 + 1 을 해줍니다.

이 과정에서 사다리와 뱀에 대한 구현과 이동할 위치의 최소 주사위 횟수를 이용하여 경우의 수를 줄입니다.

최종 위치에 도달할 때까지 위의 과정을 반복합니다.

BFS 탐색을 어느 정도 알고 있다면 아래의 코드로 풀이를 쉽게 이해 가능하다.

통과된 코드

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

constexpr int MAX = 101;

constexpr int INF = INT32_MAX;

// 사다리와 뱀을 저장한다.
vector<int> graph[MAX];

// BFS 탐색을 위한 Queue
queue<pair<int,int>> myQueue;

// BFS 탐색에서 주사위의 카운트,
// 방문처리 용도로 사용
int map[MAX];

int N, M, tempO, tempT, result;

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    //cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N >> M;

	// 맵을 전부 INF(INT32_MAX)로 변경한다.
	fill(map, map + MAX, INF);

	// 사다리와 뱀의 경로를 넣어준다.
	for (int i = 0; i < N + M; i++) {
		cin >> tempO >> tempT;
		// tempO -> tempT
		graph[tempO].push_back(tempT);
	}

	// 1번에서 시작, 주사위 횟수 0
	myQueue.push(make_pair(1,0));

	while (!myQueue.empty()) {

		int now = myQueue.front().first;
		int cnt = myQueue.front().second;
		myQueue.pop();

		// 결과에 도착했다면 넘어간다.
		if (now == 100) {
			result = cnt;
			break;	
		} 

		for (int i = 1; i <= 6; i++) {

			int tempNow = now + i;

			// 만약 101과 크거나 같다면 넘어간다.
			// 어파치 100에 도착했을때가 큐에 들어가 있어서 
			// 결과에 영향이 없다.
			if (tempNow >= MAX) continue;

			// 해당 칸에 있는 사다리와 뱀을 확인하고 적용한다.
			for (int j = 0; j < graph[tempNow].size(); j++) {
				tempNow = graph[tempNow][j];
			}

			// 해당 칸에 도착할때의 카운트가 기존의 카운트보다 크다면
			// 넘어간다.
			if (map[tempNow] <= cnt + 1) continue;

			map[tempNow] = cnt + 1;
			myQueue.push(make_pair(tempNow, map[tempNow]));
		}
	}

	cout << result;

	return 0;
}

추가 반례

예제 입력 A

2 1
7 94
8 94
55 54

예제 출력 A

2

예제 입력 B

2 1
2 60
30 98
65 25

예제 출력 B

4

예제 입력 C

2 1
2 50
51 100
52 2

예제 출력 C

2

The post 백준 16928번 (뱀과 사다리 게임, C++, BFS) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

절댓값 힙

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

문제

절댓값 힙은 다음과 같은 연산을 지원하는 자료구조이다.

1. 배열에 정수 x (x ≠ 0)를 넣는다.

2. 배열에서 절댓값이 가장 작은 값을 출력하고, 그 값을 배열에서 제거한다.

절댓값이 가장 작은 값이 여러개일 때는, 가장 작은 수를 출력하고, 그 값을 배열에서 제거한다.

프로그램은 처음에 비어있는 배열에서 시작하게 된다.

입력

첫째 줄에 연산의 개수 N(1≤N≤100,000)이 주어진다.

다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 x가 주어진다.

만약 x가 0이 아니라면 배열에 x라는 값을 넣는(추가하는) 연산이고,

x가 0이라면 배열에서 절댓값이 가장 작은 값을 출력하고 그 값을 배열에서 제거하는 경우이다.

입력되는 정수는 -2³¹보다 크고, 2³¹보다 작다.

예제 입력 1

18
1
-1
0
0
0
1
1
-1
-1
2
-2
0
0
0
0
0
0
0

예제 출력 1

-1
1
0
-1
-1
1
1
-2
2
0

출처

• 문제를 만든 사람: baekjoon
• 잘못된 조건을 찾은 사람: dkim
• 데이터를 추가한 사람: nova9128
• 문제의 오타를 찾은 사람: sgchoi5, youngminz, zerozero

비슷한 문제

• 1927번. 최소 힙
• 11279번. 최대 힙

알고리즘 분류

• 자료 구조
• 우선순위 큐

priority_queue의 성질을 이용하여 해결하였다.

아래의 자료구조만 이해한다면 쉽게 해결할 수 있는 문제

https://chanhuiseok.github.io/posts/algo-54/ <- 해당 사이트에서 정독하면 쉽게 이해가능합니다.

통과된 코드

#include <iostream>
#include <cmath>
#include <queue>

using namespace std;

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> myPQ;

pair<int, int> tempP;

int N, tempO, tempT;

int main()
{

    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> N;

	for (int i = 0; i < N; i++) {

		cin >> tempO;

		if (tempO == 0) {
			if (myPQ.empty()) cout << 0 << "\n";
			else {
				tempP = myPQ.top();
				cout << tempP.first * tempP.second << "\n";
				myPQ.pop();
			}
			continue;
		}

		if (tempO > 0) tempT = 1; // 나중에 출력을 쉽게 하기 위해서 1로 만들어준다.
		else tempT = -1; // 나중에 출력을 쉽게 하기 위해서 -1로 만들어준다.

		myPQ.push(make_pair(abs(tempO), tempT));
	}

	return 0;
}

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