이진 검색 트리

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

문제

이진 검색 트리는 다음과 같은 세 가지 조건을 만족하는 이진 트리이다.

• 노드의 왼쪽 서브트리에 있는 모든 노드의 키는 노드의 키보다 작다.
• 노드의 오른쪽 서브트리에 있는 모든 노드의 키는 노드의 키보다 크다.
• 왼쪽, 오른쪽 서브트리도 이진 검색 트리이다.

전위 순회 (루트-왼쪽-오른쪽)은 루트를 방문하고, 왼쪽 서브트리, 오른쪽 서브 트리를 순서대로 방문하면서 노드의 키를 출력한다.

후위 순회 (왼쪽-오른쪽-루트)는 왼쪽 서브트리, 오른쪽 서브트리, 루트 노드 순서대로 키를 출력한다.

예를 들어, 위의 이진 검색 트리의 전위 순회 결과는 50 30 24 5 28 45 98 52 60 이고, 후위 순회 결과는 5 28 24 45 30 60 52 98 50 이다.

이진 검색 트리를 전위 순회한 결과가 주어졌을 때, 이 트리를 후위 순회한 결과를 구하는 프로그램을 작성하시오.

입력

트리를 전위 순회한 결과가 주어진다.

노드에 들어있는 키의 값은 10⁶보다 작은 양의 정수이다.

모든 값은 한 줄에 하나씩 주어지며, 노드의 수는 10,000개 이하이다.

같은 키를 가지는 노드는 없다.

출력

입력으로 주어진 이진 검색 트리를 후위 순회한 결과를 한 줄에 하나씩 출력한다.

예제 입력 1

50
30
24
5
28
45
98
52
60

예제 출력 1

5
28
24
45
30
60
52
98
50

출처

ICPC > Regionals > Asia Pacific > Thailand > 2011 ACM-ICPC Asia Phuket Regional Programming Contest B번

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 트리
• 재귀

통과된 코드

#include <iostream>

using namespace std;

struct BinaryNode
{
    int _Num;
    BinaryNode* _Left;
    BinaryNode* _Right;

    BinaryNode(int num)
        : _Num(num), _Left(nullptr), _Right(nullptr)
    {}

    void ArrayBinaryNode(int _n)
    {
        if (_Num > _n) {
            if (_Left == nullptr) _Left = new BinaryNode(_n);
            else _Left->ArrayBinaryNode(_n);
        }
        else {
            if (_Right == nullptr) _Right = new BinaryNode(_n);
            else _Right->ArrayBinaryNode(_n);
        }
    }
};

void PostorderTraverse(BinaryNode& CurrentNode)
{
    if (CurrentNode._Left != nullptr) PostorderTraverse(*CurrentNode._Left);
    if (CurrentNode._Right != nullptr) PostorderTraverse(*CurrentNode._Right);
    cout << CurrentNode._Num << "\n";
}


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

    int _N;
    cin >> _N;
    BinaryNode _RootNode(_N);
    while (true) {
        cin >> _N;
        if (cin.eof() == true)
            break;
        _RootNode.ArrayBinaryNode(_N);
    }

    PostorderTraverse(_RootNode);

	return 0;
}

The post 백준 5639번 (이진 검색 트리, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

트리의 지름

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

문제

트리(tree)는 사이클이 없는 무방향 그래프이다.

트리에서는 어떤 두 노드를 선택해도 둘 사이에 경로가 항상 하나만 존재하게 된다.

트리에서 어떤 두 노드를 선택해서 양쪽으로 쫙 당길 때, 가장 길게 늘어나는 경우가 있을 것이다.

이럴 때 트리의 모든 노드들은 이 두 노드를 지름의 끝 점으로 하는 원 안에 들어가게 된다.

이런 두 노드 사이의 경로의 길이를 트리의 지름이라고 한다.

정확히 정의하자면 트리에 존재하는 모든 경로들 중에서 가장 긴 것의 길이를 말한다.

입력으로 루트가 있는 트리를 가중치가 있는 간선들로 줄 때, 트리의 지름을 구해서 출력하는 프로그램을 작성하시오.

아래와 같은 트리가 주어진다면 트리의 지름은 45가 된다.

트리의 노드는 1부터 n까지 번호가 매겨져 있다.

입력

파일의 첫 번째 줄은 노드의 개수 n(1 ≤ n ≤ 10,000)이다.

둘째 줄부터 n-1개의 줄에 각 간선에 대한 정보가 들어온다.

간선에 대한 정보는 세 개의 정수로 이루어져 있다.

첫 번째 정수는 간선이 연결하는 두 노드 중 부모 노드의 번호를 나타내고, 두 번째 정수는 자식 노드를, 세 번째 정수는 간선의 가중치를 나타낸다.

간선에 대한 정보는 부모 노드의 번호가 작은 것이 먼저 입력되고, 부모 노드의 번호가 같으면 자식 노드의 번호가 작은 것이 먼저 입력된다.

루트 노드의 번호는 항상 1이라고 가정하며, 간선의 가중치는 100보다 크지 않은 양의 정수이다.

출력

첫째 줄에 트리의 지름을 출력한다.

예제 입력 1

12
1 2 3
1 3 2
2 4 5
3 5 11
3 6 9
4 7 1
4 8 7
5 9 15
5 10 4
6 11 6
6 12 10

예제 출력 1

45

출처

• 문제의 오타를 찾은 사람: apjw6112
• 데이터를 추가한 사람: dlwjsgud12, shg9411, tony9402, yongdol503

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 트리
• 깊이 우선 탐색

백준 1167번 문제와 비슷한 문제

통과된 코드

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

unsigned short _V, _ResNode;
int _Res;
bool isvisted[100001];

struct Node
{
    unsigned short Number;
    vector<pair<unsigned short, unsigned short>> Connections;
    Node(unsigned short _num) : Number(_num) { };
};

vector<Node> Nodes;

void DFS(unsigned short cntNode, int _dist)
{
    isvisted[cntNode] = true;
    if (Nodes[cntNode].Connections.size() == 1 && _ResNode != cntNode) {
        if (_Res < _dist) {
            _Res = _dist;
            _ResNode = cntNode;
        }
        return;
    }

    for (auto& it : Nodes[cntNode].Connections) {
        if (isvisted[it.first])
            continue;
        DFS(it.first, _dist + it.second);
    }
}


int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> _V;
    for (int i = 0; i <= _V; i++)
        Nodes.push_back(Node(i));

    unsigned short _n1, _n2, _d;
    for (int i = 0; i < _V - 1; i++) {
        cin >> _n1 >> _n2 >> _d;
        Nodes[_n1].Connections.push_back({ _n2, _d });
        Nodes[_n2].Connections.push_back({ _n1, _d });
    }

    _Res = 0;
    _ResNode = 1;
    DFS(1, 0);
    for (int i = 1; i <= _V; i++)
        isvisted[i] = false;
    _Res = 0;
    DFS(_ResNode, 0);
    cout << _Res;
    return 0;
}

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

트리의 지름

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

문제

트리의 지름이란, 트리에서 임의의 두 점 사이의 거리 중 가장 긴 것을 말한다.

트리의 지름을 구하는 프로그램을 작성하시오.

입력

트리가 입력으로 주어진다.

먼저 첫 번째 줄에서는 트리의 정점의 개수 V가 주어지고 (2 ≤ V ≤ 100,000)

둘째 줄부터 V개의 줄에 걸쳐 간선의 정보가 다음과 같이 주어진다.

정점 번호는 1부터 V까지 매겨져 있다.

먼저 정점 번호가 주어지고, 이어서 연결된 간선의 정보를 의미하는 정수가 두 개씩 주어지는데,

하나는 정점번호, 다른 하나는 그 정점까지의 거리이다.

예를 들어 네 번째 줄의 경우 정점 3은 정점 1과 거리가 2인 간선으로 연결되어 있고,

정점 4와는 거리가 3인 간선으로 연결되어 있는 것을 보여준다. 각 줄의 마지막에는 -1이 입력으로 주어진다.

주어지는 거리는 모두 10,000 이하의 자연수이다.

출력

첫째 줄에 트리의 지름을 출력한다.

예제 입력 1

5
1 3 2 -1
2 4 4 -1
3 1 2 4 3 -1
4 2 4 3 3 5 6 -1
5 4 6 -1

예제 출력 1

11

출처

• 문제의 오타를 찾은 사람: ababc1005, cfghj101, WeissBlume
• 문제를 만든 사람: author5
• 데이터를 추가한 사람: djm03178

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 트리
• 깊이 우선 탐색

통과된 코드

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

int _V,  _ResNode, _Res;
bool isvisted[100001];

struct Node
{
	int Number;
	vector<pair<int, int>> Connections;
	Node(int _num) : Number(_num) { };
};

vector<Node> Nodes;

void DFS(int cntNode, int _dist) 
{
	isvisted[cntNode] = true;
	if (Nodes[cntNode].Connections.size() == 1 && _ResNode != cntNode) {
		if (_Res < _dist) {
			_Res = _dist;
			_ResNode = cntNode;
		}
		return;
	}

	for (auto& it : Nodes[cntNode].Connections) { 
		if (isvisted[it.first])
			continue;
		DFS(it.first, _dist + it.second);
	}
}


int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _V;
	for (int i = 0; i <= _V; i++) 
		Nodes.push_back(Node(i));
	
	int _n1, _n2, _d;
	for (int i = 1; i <= _V; i++) {
		cin >> _n1;
		while (true) {
			cin >> _n2;
			if (_n2 == -1) break;
			cin >> _d;
			Nodes[_n1].Connections.push_back({ _n2, _d});
		}
	}

	_Res = 0;
	_ResNode = 1;
	DFS(1, 0);
	for (int i = 1; i <= _V; i++)
		isvisted[i] = false;
	_Res = 0;
	DFS(_ResNode, 0);
	cout << _Res;
	return 0;
}

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

트리 순회

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

문제

이진 트리를 입력받아 전위 순회(preorder traversal), 중위 순회(inorder traversal),

후위 순회(postorder traversal)한 결과를 출력하는 프로그램을 작성하시오.

예를 들어 위와 같은 이진 트리가 입력되면,

전위 순회한 결과 : ABDCEFG // (루트) (왼쪽 자식) (오른쪽 자식)

중위 순회한 결과 : DBAECFG // (왼쪽 자식) (루트) (오른쪽 자식)

후위 순회한 결과 : DBEGFCA // (왼쪽 자식) (오른쪽 자식) (루트)

가 된다.

입력

첫째 줄에는 이진 트리의 노드의 개수 N(1 ≤ N ≤ 26)이 주어진다.

둘째 줄부터 N개의 줄에 걸쳐 각 노드와 그의 왼쪽 자식 노드, 오른쪽 자식 노드가 주어진다.

노드의 이름은 A부터 차례대로 알파벳 대문자로 매겨지며, 항상 A가 루트 노드가 된다.

자식 노드가 없는 경우에는 .으로 표현한다.

출력

첫째 줄에 전위 순회, 둘째 줄에 중위 순회, 셋째 줄에 후위 순회한 결과를 출력한다.

각 줄에 N개의 알파벳을 공백 없이 출력하면 된다.

예제 입력 1

7
A B C
B D .
C E F
E . .
F . G
D . .
G . .

예제 출력 1

ABDCEFG
DBAECFG
DBEGFCA

알고리즘 분류

• 트리
• 재귀

통과된 코드

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

struct Node;
vector<Node> NodesV;
void PreorderTraverse(int _Cnt);
void PostorderTraverse(int _Cnt);
void InorderTraverse(int _Cnt);
int _N;
char _C, _L, _R;

struct Node
{
	int _Node;

	Node* _LeftNode;
	Node* _RightNode;

	Node(char _node)
	{
		_LeftNode = NULL;
		_RightNode = NULL;
		_Node = (int)_node - 65;
	}

	void ChangeNodeLeft(char NodeC)
	{
		if (NodeC == '.') return;
		_LeftNode = &NodesV[(int)NodeC - 65];
	}

	void ChangeNodeRight(char NodeC)
	{
		if (NodeC == '.') return;
		_RightNode = &NodesV[(int)NodeC - 65];
	}
};

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

	cin >> _N;
	for (int i = 0; i < _N; i++) {
		Node TNode = Node((char)(65 + i));
		NodesV.push_back((char)(65 + i));
	}

	for (int i = 0; i < _N; i++) {
		cin >> _C >> _L >> _R;
		NodesV[(int)_C - 65].ChangeNodeLeft(_L);
		NodesV[(int)_C - 65].ChangeNodeRight(_R);
	}

	PreorderTraverse(0);
	cout << "\n";
	PostorderTraverse(0);
	cout << "\n";
	InorderTraverse(0);
	return 0;
}

void PreorderTraverse(int _Cnt)
{
	cout << (char)(_Cnt + 65);
	if (NodesV[_Cnt]._LeftNode != NULL)
		PreorderTraverse(NodesV[_Cnt]._LeftNode->_Node);
	if (NodesV[_Cnt]._RightNode != NULL)
		PreorderTraverse(NodesV[_Cnt]._RightNode->_Node);
}

void PostorderTraverse(int _Cnt)
{
	if (NodesV[_Cnt]._LeftNode != NULL)
		PostorderTraverse(NodesV[_Cnt]._LeftNode->_Node);
	cout << (char)(_Cnt + 65);
	if (NodesV[_Cnt]._RightNode != NULL)
		PostorderTraverse(NodesV[_Cnt]._RightNode->_Node);
}

void InorderTraverse(int _Cnt)
{
	if (NodesV[_Cnt]._LeftNode != NULL)
		InorderTraverse(NodesV[_Cnt]._LeftNode->_Node);
	if (NodesV[_Cnt]._RightNode != NULL)
		InorderTraverse(NodesV[_Cnt]._RightNode->_Node);
	cout << (char)(_Cnt + 65);
}

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

트리의 부모 찾기

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

문제

루트 없는 트리가 주어진다.

이때, 트리의 루트를 1이라고 정했을 때, 각 노드의 부모를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 노드의 개수 N (2 ≤ N ≤ 100,000)이 주어진다.

둘째 줄부터 N-1개의 줄에 트리 상에서 연결된 두 정점이 주어진다.

출력

첫째 줄부터 N-1개의 줄에 각 노드의 부모 노드 번호를 2번 노드부터 순서대로 출력한다.

예제 입력 1

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

예제 출력 1

4
6
1
3
1
4

예제 입력 2

12
1 2
1 3
2 4
3 5
3 6
4 7
4 8
5 9
5 10
6 11
6 12

예제 출력 2

1
1
2
3
3
4
4
5
5
6
6

출처

• 문제를 만든 사람: baekjoon
• 잘못된 조건을 찾은 사람: jh05013

알고리즘 분류

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

통과괸 코드

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

using namespace std;

struct Node
{
    int _Number;
    int _Parent = -1;
    vector<int> _Nodes;
    Node(int p_Number)
    {
        _Number = p_Number;
    }
};

queue<int> _MyQueue;
vector<Node> _NodesV;
int _N;

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

    cin >> _N;
    for (int i = 0; i <= _N; i++) {
        Node _NewNode(i);
        _NodesV.push_back(_NewNode);
    }
    for (int i = 1; i < _N; i++) {
        int _First, _Second;
        cin >> _First >> _Second;
        _NodesV[_First]._Nodes.push_back(_Second);
        _NodesV[_Second]._Nodes.push_back(_First);
    }

    _MyQueue.push(1);
    while (!_MyQueue.empty()) {
        int CntNode = _MyQueue.front();
        _MyQueue.pop();
        for (auto& it : _NodesV[CntNode]._Nodes) {
            if (_NodesV[it]._Parent != -1) continue;
            _NodesV[it]._Parent = CntNode;
            _MyQueue.push(it);
        }
    }

    for (int i = 2; i <= _N; i++) {
        cout << _NodesV[i]._Parent << "\n";
    }

    return 0;
}

The post 백준 11725번 (트리의 부모 찾기, C++) [BAEKJOON] 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 어제와 내일의 나 그 사이의 이야기.