재귀 Archives - 어제와 내일의 나 그 사이의 이야기 생각의 흐름을 타고 다니며 만드는 블로그 Thu, 17 Oct 2024 10:19:12 +0000 ko-KR hourly 1 https://wordpress.org/?v=6.9.4 https://lycos7560.com/wp-content/uploads/2022/11/cropped-cropped-cropped-log-1-150x150-1-80x80.png 재귀 Archives - 어제와 내일의 나 그 사이의 이야기 32 32 백준 16953번 (A → B, C++) [BAEKJOON] https://lycos7560.com/cpp/%eb%b0%b1%ec%a4%80-16953%eb%b2%88-a-%e2%86%92-b-c-baekjoon/38376/ https://lycos7560.com/cpp/%eb%b0%b1%ec%a4%80-16953%eb%b2%88-a-%e2%86%92-b-c-baekjoon/38376/#respond Thu, 17 Oct 2024 08:40:22 +0000 https://lycos7560.com/?p=38376 A → B https://www.acmicpc.net/problem/16953 시간 제한 메모리 제한 제출 정답 맞힌 사람 정답 비율 2 초 512 MB 61243 25275 19996 39.758% 문제 정수 A를 B로 바꾸려고 한다. 가능한 연산은 다음과 같은 두 가지이다. A를 B로 바꾸는데 필요한 연산의 최솟값을 구해보자. 입력 첫째 줄에 A, B (1 ≤ A < B ≤ 109)가 주어진다. 출력 […]

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

]]> A → B

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초512 MB61243252751999639.758%

문제

정수 A를 B로 바꾸려고 한다. 가능한 연산은 다음과 같은 두 가지이다.

  • 2를 곱한다.
  • 1을 수의 가장 오른쪽에 추가한다. 

A를 B로 바꾸는데 필요한 연산의 최솟값을 구해보자.

입력

첫째 줄에 A, B (1 ≤ A < B ≤ 109)가 주어진다.

출력

A를 B로 바꾸는데 필요한 연산의 최솟값에 1을 더한 값을 출력한다.

만들 수 없는 경우에는 -1을 출력한다.

예제 입/출력 1

2 162
5

2 → 4 → 8 → 81 → 162

예제 입/출력 2

4 42
-1

2 → 4 → 8 → 81 → 162

예제 입/출력 3

100 40021
5

100 → 200 → 2001 → 4002 → 40021

출처

알고리즘 분류

통과된 코드

DFS(재귀)를 이용하여 해결

재귀를 수행하면서 조건을 만족할 수 없다면 Return

#include <iostream>
using namespace std;

int MinRes = INT16_MAX;
long long int Target = 0;

void Recursion(int _depth, long long int _val) {
    // 목표 값보다 크면 반환
    if (_val > Target)
        return;

    // 현재 깊이가 최소값보다 크면 반환
    if (_depth > MinRes)
        return;

    // 목표 값에 도달하면 최소 깊이 갱신
    if (Target == _val) {
        MinRes = min(MinRes, _depth);
        return;
    }

    // 재귀 호출을 통해 2를 곱하거나 1을 추가
    Recursion(_depth + 1, _val * 2);
    Recursion(_depth + 1, (_val * 10) + 1);
}

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

    long long int Start = 0;
    cin >> Start >> Target;
    
    // 초기 깊이는 1로 설정
    Recursion(1, Start);
    
    // 결과 출력: 만들 수 없는 경우 -1 출력
    if (INT16_MAX == MinRes)
        cout << -1;
    else
        cout << MinRes;
}

int => long long int

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

]]> https://lycos7560.com/cpp/%eb%b0%b1%ec%a4%80-16953%eb%b2%88-a-%e2%86%92-b-c-baekjoon/38376/feed/ 0 백준 1240번 (노드사이의 거리, C++) [BAEKJOON] https://lycos7560.com/cpp/%eb%b0%b1%ec%a4%80-1240%eb%b2%88-%eb%85%b8%eb%93%9c%ec%82%ac%ec%9d%b4%ec%9d%98-%ea%b1%b0%eb%a6%ac-c-baekjoon/37874/ https://lycos7560.com/cpp/%eb%b0%b1%ec%a4%80-1240%eb%b2%88-%eb%85%b8%eb%93%9c%ec%82%ac%ec%9d%b4%ec%9d%98-%ea%b1%b0%eb%a6%ac-c-baekjoon/37874/#respond Mon, 04 Mar 2024 15:51:29 +0000 https://lycos7560.com/?p=37874 백준 온라인 문제 1240번 문제에 대한 글입니다.
DFS 재귀 함수를 사용하여 해결하였습니다. (This is about question 1240 of Baekjun Online Problem.
Resolved using the DFS recursive function.)

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

]]>
목차 테이블
  1. 노드사이의 거리
  2. 통과된 코드

노드사이의 거리

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초128 MB90184874375253.638%

문제

 N개의 노드로 이루어진 트리가 주어지고 M개의 두 노드 쌍을 입력받을 때 두 노드 사이의 거리를 출력하라.

입력

첫째 줄에 노드의 개수 N과 거리를 알고 싶은 노드 쌍의 개수 M이 입력되고 다음 N-1개의 줄에 트리 상에 연결된 두 점과 거리를 입력받는다.

그 다음 줄에는 거리를 알고 싶은 M개의 노드 쌍이 한 줄에 한 쌍씩 입력된다.

출력

 M개의 줄에 차례대로 입력받은 두 노드 사이의 거리를 출력한다.

제한

  •  2 ≤ N ≤1,000 
  •  1 ≤ M ≤ 1,000 
  • 트리 상에 연결된 두 점과 거리는 10,000 이하인 자연수이다.
  • 트리 노드의 번호는 1부터 N까지 자연수이며, 두 노드가 같은 번호를 갖는 경우는 없다.

예제 입력 1

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

예제 출력 1

2
7

출처

  • 빠진 조건을 찾은 사람: hg7258

알고리즘 분류

통과된 코드

DFS를 이용하여 탐색

리펙토링하면 메모리와 시간을 더 줄일 수 있음

#include <iostream>
#include <vector>

using namespace std;

constexpr int MAX = 1001;

int N, M, _End;

vector<int> Nodes[MAX];
vector<int> Distances[MAX][MAX];
bool IsVisted[MAX];


void DFS(int _Len, int _CurNode)
{
	if (_End == _CurNode) {
		cout << _Len << '\n';
		return;
	}

	for (int i = 0; i < Nodes[_CurNode].size(); i++)
	{
		int NextNode = Nodes[_CurNode][i];
		if (IsVisted[NextNode]) 
			continue;
		IsVisted[NextNode] = true;
		DFS(_Len + *Distances[_CurNode][NextNode].begin(), NextNode);
		IsVisted[NextNode] = false;
	}

}

int main()
{
	cin >> N >> M;
	int _S, _E, _D;
	for (int i = 0; i < N-1; i++) {
		cin >> _S >> _E >> _D;
		Nodes[_S].push_back(_E);
		Nodes[_E].push_back(_S);
		Distances[_S][_E].push_back(_D);
		Distances[_E][_S].push_back(_D);
	}

	for (int i = 0; i < M; i++) {
		cin >> _S >> _E;
		_End = _E;
		IsVisted[_S] = true;
		DFS(0, _S);
		IsVisted[_S] = false;
	}


	return 0;
}

방문 체크를 빼먹어서 틀렸다.

추가

    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    cin.tie(NULL);
    cout.tie(NULL);
#include <iostream>
#include <vector>

using namespace std;

constexpr int MAX = 1001;

int N, M, _End;

vector<int> Nodes[MAX];
vector<int> Distances[MAX][MAX];
bool IsVisted[MAX];


void DFS(int _Len, int _CurNode)
{
	if (_End == _CurNode) {
		cout << _Len << '\n';
		return;
	}

	for (int i = 0; i < Nodes[_CurNode].size(); i++)
	{
		int NextNode = Nodes[_CurNode][i];
		if (IsVisted[NextNode]) 
			continue;
		IsVisted[NextNode] = true;
		DFS(_Len + *Distances[_CurNode][NextNode].begin(), NextNode);
		IsVisted[NextNode] = false;
	}

}

int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    cin.tie(NULL);
    cout.tie(NULL);
	cin >> N >> M;
	int _S, _E, _D;
	for (int i = 0; i < N-1; i++) {
		cin >> _S >> _E >> _D;
		Nodes[_S].push_back(_E);
		Nodes[_E].push_back(_S);
		Distances[_S][_E].push_back(_D);
		Distances[_E][_S].push_back(_D);
	}

	for (int i = 0; i < M; i++) {
		cin >> _S >> _E;
		_End = _E;
		IsVisted[_S] = true;
		DFS(0, _S);
		IsVisted[_S] = false;
	}


	return 0;
}

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

]]> https://lycos7560.com/cpp/%eb%b0%b1%ec%a4%80-1240%eb%b2%88-%eb%85%b8%eb%93%9c%ec%82%ac%ec%9d%b4%ec%9d%98-%ea%b1%b0%eb%a6%ac-c-baekjoon/37874/feed/ 0 백준 5639번 (이진 검색 트리, C++) [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-5639%eb%b2%88-%ec%9d%b4%ec%a7%84-%ea%b2%80%ec%83%89-%ed%8a%b8%eb%a6%ac-c-baekjoon/36556/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-5639%eb%b2%88-%ec%9d%b4%ec%a7%84-%ea%b2%80%ec%83%89-%ed%8a%b8%eb%a6%ac-c-baekjoon/36556/#respond Wed, 23 Aug 2023 04:20:19 +0000 https://lycos7560.com/?p=36556 백준 온라인 저지 5639번 문제 '이진 검색 트리' 에 대한 글입니다. 단순한 재귀를 이용하여 해결하였습니다. (Baekjoon Online Judge Number 5639 This article is about the binary search tree. It was solved using simple recursion.)

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

]]>
목차 테이블
  1. 이진 검색 트리

이진 검색 트리

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
1 초256 MB3544213888982138.260%

문제

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

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

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

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

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

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

입력

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

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

모든 값은 한 줄에 하나씩 주어지며, 노드의 수는 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번

알고리즘 분류

통과된 코드

#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://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-5639%eb%b2%88-%ec%9d%b4%ec%a7%84-%ea%b2%80%ec%83%89-%ed%8a%b8%eb%a6%ac-c-baekjoon/36556/feed/ 0 백준 21736번 (헌내기는 친구가 필요해, C++) [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-21736%eb%b2%88-%ed%97%8c%eb%82%b4%ea%b8%b0%eb%8a%94-%ec%b9%9c%ea%b5%ac%ea%b0%80-%ed%95%84%ec%9a%94%ed%95%b4-c-baekjoon/36032/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-21736%eb%b2%88-%ed%97%8c%eb%82%b4%ea%b8%b0%eb%8a%94-%ec%b9%9c%ea%b5%ac%ea%b0%80-%ed%95%84%ec%9a%94%ed%95%b4-c-baekjoon/36032/#respond Wed, 12 Jul 2023 22:14:25 +0000 https://lycos7560.com/?p=36032 백준 21736번 '헌내기는 친구가 필요해' 문제에 대한 글입니다. 재귀를 이용한 'DFS Search'을 이용하여 해결하였습니다. (Baekjoon Number 21736 This is an article about the problem of "The old man needs a friend." It was solved by using 'DFS Search' using recursive.)

The post 백준 21736번 (헌내기는 친구가 필요해, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

]]>
목차 테이블
  1. 헌내기는 친구가 필요해

헌내기는 친구가 필요해

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
1 초 (하단 참고)1024 MB34031990166860.943%

문제

2020년에 입학한 헌내기 도연이가 있다. 도연이는 비대면 수업 때문에 학교에 가지 못해 학교에 아는 친구가 없었다.

드디어 대면 수업을 하게 된 도연이는 어서 캠퍼스 내의 사람들과 친해지고 싶다. 

도연이가 다니는 대학의 캠퍼스는 N x M 크기이며 캠퍼스에서 이동하는 방법은 벽이 아닌 상하좌우로 이동하는 것이다.

예를 들어, 도연이가 (x, y)에 있다면 이동할 수 있는 곳은 (x+1, y), (x, y+1), (x-1, y), (x, y-1)이다.

단, 캠퍼스의 밖으로 이동할 수는 없다.

불쌍한 도연이를 위하여 캠퍼스에서 도연이가 만날 수 있는 사람의 수를 출력하는 프로그램을 작성해보자.

입력

첫째 줄에는 캠퍼스의 크기를 나타내는 두 정수 N (1 ≤ N ≤ 600), M (1 ≤ M ≤ 600)이 주어진다.

둘째 줄부터 N개의 줄에는 캠퍼스의 정보들이 주어진다. 

O는 빈 공간, X는 벽, I는 도연이, P는 사람이다. 

I가 한 번만 주어짐이 보장된다.

출력

첫째 줄에 도연이가 만날 수 있는 사람의 수를 출력한다.

단, 아무도 만나지 못한 경우 TT를 출력한다.

예제 입력 1

3 5
OOOPO
OIOOX
OOOXP

예제 출력 1

1

예제 입력 2

3 3
IOX
OXP
XPP

예제 출력 2

TT

출처

University > 숙명여자대학교 > 제1회 숙명여자대학교 교내 알고리즘 경진대회 (SMUPC) C번

알고리즘 분류

통과된 코드

DFS 탐색을 재귀로 구현하여 문제를 해결

#include <iostream>
using namespace std;
int _Res = 0, _N, _M;
int _DxDy[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
char _Map[600][600];
string _Str;
char _Temp;
pair<int, int> StartPos;

// 재귀를 이용한 DFS (Depth-First Search) 탐색 
void DFSSearch(int _CntX, int _CntY)
{
	for (int j = 0; j < 4; j++) {
		int _dx = _CntX + _DxDy[j][0];
		int _dy = _CntY + _DxDy[j][1];
		if (_dx >= _N || _dy >= _M || _dx < 0 || _dy < 0)
			continue;
		if (_Map[_dx][_dy] == 'X')
			continue;
		if (_Map[_dx][_dy] == 'P')
			_Res++;
		// 방문처리 대신에 X(벽)으로 마킹
		_Map[_dx][_dy] = 'X';
		DFSSearch(_dx, _dy);
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M;
	for (int i = 0; i < _N; i++) {
		cin >> _Str;
		for (int j = 0; j < _M; j++) {
			_Map[i][j] = _Str[j];
			if (_Str[j] == 'I') {
				StartPos = make_pair(i, j);
				_Map[i][j] = 'X';
			}
		}
	}
	
	DFSSearch(StartPos.first, StartPos.second);

	if (_Res == 0) cout << "TT"; 
	else  cout << _Res;

	return 0;
}

The post 백준 21736번 (헌내기는 친구가 필요해, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

]]> https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-21736%eb%b2%88-%ed%97%8c%eb%82%b4%ea%b8%b0%eb%8a%94-%ec%b9%9c%ea%b5%ac%ea%b0%80-%ed%95%84%ec%9a%94%ed%95%b4-c-baekjoon/36032/feed/ 0 Programmers 92342 양궁대회 [2022 KAKAO BLIND RECRUITMENT] https://lycos7560.com/cpp/programmers/programmers-92342-%ec%96%91%ea%b6%81%eb%8c%80%ed%9a%8c-2022-kakao-blind-recruitment/35277/ https://lycos7560.com/cpp/programmers/programmers-92342-%ec%96%91%ea%b6%81%eb%8c%80%ed%9a%8c-2022-kakao-blind-recruitment/35277/#respond Fri, 02 Jun 2023 12:22:01 +0000 https://lycos7560.com/?p=35277 Programmers 92342번 '양궁대회' 문제에 대한 글입니다. 재귀를 이용한 완전 탐색으로 해결하였습니다. (This article is about the issue of 'Archery Competition' in Programmers 92342. It was solved by a complete search using recursive. [2022 KAKAO BLIND RECRUITMENT]) [2022 KAKAO BLIND RECRUITMENT]

The post Programmers 92342 양궁대회 [2022 KAKAO BLIND RECRUITMENT] appeared first on 어제와 내일의 나 그 사이의 이야기.

]]>
목차 테이블
  1. 양궁대회
  2. 통과된 코드

양궁대회

https://school.programmers.co.kr/learn/courses/30/lessons/92342

문제 설명

카카오배 양궁대회가 열렸습니다.

라이언은 저번 카카오배 양궁대회 우승자이고 이번 대회에도 결승전까지 올라왔습니다.

결승전 상대는 어피치입니다.

카카오배 양궁대회 운영위원회는 한 선수의 연속 우승보다는 다양한 선수들이 양궁대회에서 우승하기를 원합니다.

따라서, 양궁대회 운영위원회는 결승전 규칙을 전 대회 우승자인 라이언에게 불리하게 다음과 같이 정했습니다.

  1. 어피치가 화살 n발을 다 쏜 후에 라이언이 화살 n발을 쏩니다.
  2. 점수를 계산합니다.
    1. 과녁판은 아래 사진처럼 생겼으며 가장 작은 원의 과녁 점수는 10점이고 가장 큰 원의 바깥쪽은 과녁 점수가 0점입니다. 
    2. 만약, k(k는 1~10사이의 자연수)점을 어피치가 a발을 맞혔고 라이언이 b발을 맞혔을 경우 더 많은 화살을 k점에 맞힌 선수가 k 점을 가져갑니다.
      단, a = b일 경우는 어피치가 k점을 가져갑니다. k점을 여러 발 맞혀도 k점 보다 많은 점수를 가져가는 게 아니고 k점만 가져가는 것을 유의하세요.
      또한 a = b = 0 인 경우, 즉, 라이언과 어피치 모두 k점에 단 하나의 화살도 맞히지 못한 경우는 어느 누구도 k점을 가져가지 않습니다.
    • 예를 들어, 어피치가 10점을 2발 맞혔고 라이언도 10점을 2발 맞혔을 경우 어피치가 10점을 가져갑니다.
    • 다른 예로, 어피치가 10점을 0발 맞혔고 라이언이 10점을 2발 맞혔을 경우 라이언이 10점을 가져갑니다.
    • 모든 과녁 점수에 대하여 각 선수의 최종 점수를 계산합니다.
  3. 최종 점수가 더 높은 선수를 우승자로 결정합니다.
    단, 최종 점수가 같을 경우 어피치를 우승자로 결정합니다.

현재 상황은 어피치가 화살 n발을 다 쏜 후이고 라이언이 화살을 쏠 차례입니다.

라이언은 어피치를 가장 큰 점수 차이로 이기기 위해서 n발의 화살을 어떤 과녁 점수에 맞혀야 하는지를 구하려고 합니다.

화살의 개수를 담은 자연수 n, 어피치가 맞힌 과녁 점수의 개수를 10점부터 0점까지 순서대로 담은 정수 배열 info가 매개변수로 주어집니다.

이때, 라이언이 가장 큰 점수 차이로 우승하기 위해 n발의 화살을 어떤 과녁 점수에 맞혀야 하는지를

10점부터 0점까지 순서대로 정수 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

만약, 라이언이 우승할 수 없는 경우(무조건 지거나 비기는 경우)는 [-1]을 return 해주세요.

제한사항
  • 1 ≤ n ≤ 10
  • info의 길이 = 11
    • 0 ≤ info의 원소 ≤ n
    • info의 원소 총합 = n
    • info의 i번째 원소는 과녁의 10 - i 점을 맞힌 화살 개수입니다. ( i는 0~10 사이의 정수입니다.)
  • 라이언이 우승할 방법이 있는 경우, return 할 정수 배열의 길이는 11입니다.
    • 0 ≤ return할 정수 배열의 원소 ≤ n
    • return할 정수 배열의 원소 총합 = n (꼭 n발을 다 쏴야 합니다.)
    • return할 정수 배열의 i번째 원소는 과녁의 10 - i 점을 맞힌 화살 개수입니다. ( i는 0~10 사이의 정수입니다.)
    • 라이언이 가장 큰 점수 차이로 우승할 수 있는 방법이 여러 가지 일 경우, 가장 낮은 점수를 더 많이 맞힌 경우를 return 해주세요.
      • 가장 낮은 점수를 맞힌 개수가 같을 경우 계속해서 그다음으로 낮은 점수를 더 많이 맞힌 경우를 return 해주세요.
      • 예를 들어, [2,3,1,0,0,0,0,1,3,0,0]과 [2,1,0,2,0,0,0,2,3,0,0]를 비교하면 [2,1,0,2,0,0,0,2,3,0,0]를 return 해야 합니다.
      • 다른 예로, [0,0,2,3,4,1,0,0,0,0,0]과 [9,0,0,0,0,0,0,0,1,0,0]를 비교하면[9,0,0,0,0,0,0,0,1,0,0]를 return 해야 합니다.
  • 라이언이 우승할 방법이 없는 경우, return 할 정수 배열의 길이는 1입니다.
    • 라이언이 어떻게 화살을 쏘든 라이언의 점수가 어피치의 점수보다 낮거나 같으면 [-1]을 return 해야 합니다.
입출력 예
ninforesult
5[2,1,1,1,0,0,0,0,0,0,0][0,2,2,0,1,0,0,0,0,0,0]
1[1,0,0,0,0,0,0,0,0,0,0][-1]
9[0,0,1,2,0,1,1,1,1,1,1][1,1,2,0,1,2,2,0,0,0,0]
10[0,0,0,0,0,0,0,0,3,4,3][1,1,1,1,1,1,1,1,0,0,2]
입출력 예 설명

입출력 예 #1

어피치와 라이언이 아래와 같이 화살을 맞힐 경우,

과녁 점수어피치가 맞힌 화살 개수라이언이 맞힌 화살 개수결과
1023라이언이 10점 획득
912라이언이 9점 획득
810어피치가 8점 획득
710어피치가 7점 획득
600
500
400
300
200
100
000

어피치의 최종 점수는 15점, 라이언의 최종 점수는 19점입니다. 4점 차이로 라이언이 우승합니다.

하지만, 라이언이 아래와 같이 화살을 맞힐 경우 더 큰 점수 차로 우승할 수 있습니다.

과녁 점수어피치가 맞힌 화살 개수라이언이 맞힌 화살 개수결과
1020어피치가 10점 획득
912라이언이 9점 획득
812라이언이 8점 획득
710어피치가 7점 획득
601라이언이 6점 획득
500
400
300
200
100
000

어피치의 최종 점수는 17점, 라이언의 최종 점수는 23점입니다. 6점 차이로 라이언이 우승합니다.

따라서 [0,2,2,0,1,0,0,0,0,0,0]을 return 해야 합니다.

입출력 예 #2

라이언이 10점을 맞혀도 어피치가 10점을 가져가게 됩니다.

따라서, 라이언은 우승할 수 없기 때문에 [-1]을 return 해야 합니다.

입출력 예 #3

어피치와 라이언이 아래와 같이 화살을 맞힐 경우,

과녁 점수어피치가 맞힌 화살 개수라이언이 맞힌 화살 개수결과
1001라이언이 10점 획득
901라이언이 9점 획득
812라이언이 8점 획득
723라이언이 7점 획득
600
512라이언이 5점 획득
410어피치가 4점 획득
310어피치가 3점 획득
210어피치가 2점 획득
110어피치가 1점 획득
010어피치가 0점 획득

어피치의 최종 점수는 10점, 라이언의 최종 점수는 39점입니다.

29점 차이로 라이언이 우승합니다.

하지만 라이언이 아래와 같이 화살을 맞힐 경우,

과녁 점수어피치가 맞힌 화살 개수라이언이 맞힌 화살 개수결과
1001라이언이 10점 획득
901라이언이 9점 획득
812라이언이 8점 획득
720어피치가 7점 획득
601라이언이 6점 획득
512라이언이 5점 획득
412라이언이 4점 획득
310어피치가 3점 획득
210어피치가 2점 획득
110어피치가 1점 획득
010어피치가 0점 획득

어피치의 최종 점수는 13점, 라이언의 최종 점수는 42점입니다.

이 경우도 29점 차이로 라이언이 우승합니다.

하지만, 첫 번째 경우와 두 번째 경우를 비교했을 때,

두 번째 경우가 두 경우 중 가장 낮은 점수인 4점을 더 많이 맞혔기 때문에 

[1,1,2,3,0,2,0,0,0,0,0]이 아닌 [1,1,2,0,1,2,2,0,0,0,0]을 return 해야 합니다.

입출력 예 #4

가장 큰 점수 차이로 이기는 경우 중에서 가장 낮은 점수를 가장 많이 맞힌,

10~3점을 한 발씩 맞히고 나머지 두 발을 0점에 맞히는 경우인 [1,1,1,1,1,1,1,1,0,0,2]를 return 해야 합니다.

제한시간 안내
  • 정확성 테스트 : 10초

통과된 코드

재귀를 이용한 완전 탐색으로 문제를 해결하였다.

#include <string>
#include <vector>

using namespace std;

int _N, _LionRes, _ApeachRes, _Maxdiff;

vector<int> _Answer = { -1 };

bool Check(vector<int>& _Answer, vector<int>& _ComparisonV)
{
    for (int i = 10; i >= 0; i--) {
        if (_Answer[i] < _ComparisonV[i]) return true;
        else if (_Answer[i] > _ComparisonV[i]) return false;
    }
    return false;
}

// 완전 탐색
void Search(vector<int>& _apeachV, vector<int>& _ryanV, int _cnt, int _pivot)
{
    if (_cnt == _N) {
        _ApeachRes = 0; _LionRes = 0;
        for (int i = 0; i < 10; i++) {
            if (_apeachV[i] < _ryanV[i]) _LionRes += (10 - i);
            else if (_apeachV[i] > 0) _ApeachRes += (10 - i);
        }

        int _DiffValue = _LionRes - _ApeachRes;
        if ((_DiffValue > 0 && _Maxdiff <= _DiffValue)) {
            if (_Maxdiff == _DiffValue && !Check(_Answer, _ryanV)) return;
            _Maxdiff = _DiffValue;
            _Answer = _ryanV;
        }
        return;
    }

    // 피봇을 이용하여 중복을 제거
    for (int i = _pivot; i <= 10; i++) {
        _ryanV[i]++;
        Search(_apeachV, _ryanV, _cnt + 1, i);
        _ryanV[i]--;
    }

}

vector<int> solution(int n, vector<int> info) {
    _N = n;
    vector<int> _BaseV = { 0,0,0,0,0,0,0,0,0,0,0 };
    Search(info, _BaseV, 0, 0);
    return _Answer;
}

The post Programmers 92342 양궁대회 [2022 KAKAO BLIND RECRUITMENT] appeared first on 어제와 내일의 나 그 사이의 이야기.

]]> https://lycos7560.com/cpp/programmers/programmers-92342-%ec%96%91%ea%b6%81%eb%8c%80%ed%9a%8c-2022-kakao-blind-recruitment/35277/feed/ 0 백준 1991번 (트리 순회, C++) [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1991%eb%b2%88-%ed%8a%b8%eb%a6%ac-%ec%88%9c%ed%9a%8c-c-baekjoon/34768/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1991%eb%b2%88-%ed%8a%b8%eb%a6%ac-%ec%88%9c%ed%9a%8c-c-baekjoon/34768/#respond Sat, 13 May 2023 14:48:11 +0000 https://lycos7560.com/?p=34768 백준 1991번 '트리 순회' 문제에 대한 글입니다. 재귀를 이용하여 해결하였습니다.recursive function
(This article is about the issue of 'Tree Tour' in Baekjoon Number 1991. I solved it by using recursive function.)

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

]]>
목차 테이블
  1. 트리 순회
  2. 통과된 코드

트리 순회

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초128 MB45305296702270566.529%

문제

이진 트리를 입력받아 전위 순회(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://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1991%eb%b2%88-%ed%8a%b8%eb%a6%ac-%ec%88%9c%ed%9a%8c-c-baekjoon/34768/feed/ 0 백준 1992번 (쿼드트리, C++, DivideAndConquer) / 추가 반례 [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1992%eb%b2%88-%ec%bf%bc%eb%93%9c%ed%8a%b8%eb%a6%ac-c-divideandconquer-baekjoon/33181/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1992%eb%b2%88-%ec%bf%bc%eb%93%9c%ed%8a%b8%eb%a6%ac-c-divideandconquer-baekjoon/33181/#respond Wed, 15 Feb 2023 20:32:23 +0000 https://lycos7560.com/?p=33181 백준(BAEKJOON) 1992번 '쿼드트리' 문제에 대한 글입니다. '분할 정복' 알고리즘을 이용하여 해결하였습니다. (This is an article about the problem of 'Quad Tree' in 1992 by BAEKJOON. We solved it using 'DivideAndConquer' algorithm.)

The post 백준 1992번 (쿼드트리, C++, DivideAndConquer) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

]]>
목차 테이블
  1. 쿼드트리
  2. 통과된 코드
  3. 추가 반례

쿼드트리

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초128 MB37409228361791761.630%

문제

흑백 영상을 압축하여 표현하는 데이터 구조로 쿼드 트리(Quad Tree)라는 방법이 있다.

흰 점을 나타내는 0과 검은 점을 나타내는 1로만 이루어진 영상(2차원 배열)에서 같은 숫자의 점들이 한 곳에 많이 몰려있으면,

쿼드 트리에서는 이를 압축하여 간단히 표현할 수 있다.

주어진 영상이 모두 0으로만 되어 있으면 압축 결과는 “0”이 되고, 모두 1로만 되어 있으면 압축 결과는 “1”이 된다.

만약 0과 1이 섞여 있으면 전체를 한 번에 나타내지를 못하고,

왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래, 이렇게 4개의 영상으로 나누어 압축하게 되며,

이 4개의 영역을 압축한 결과를 차례대로 괄호 안에 묶어서 표현한다

위 그림에서 왼쪽의 영상은 오른쪽의 배열과 같이 숫자로 주어지며,

이 영상을 쿼드 트리 구조를 이용하여 압축하면 “(0(0011)(0(0111)01)1)“로 표현된다.

N ×N 크기의 영상이 주어질 때, 이 영상을 압축한 결과를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다.

N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다.

두 번째 줄부터는 길이 N의 문자열이 N개 들어온다.

각 문자열은 0 또는 1의 숫자로 이루어져 있으며, 영상의 각 점들을 나타낸다.

출력

영상을 압축한 결과를 출력한다.

예제 입력 1

8
11110000
11110000
00011100
00011100
11110000
11110000
11110011
11110011

예제 출력 1

((110(0101))(0010)1(0001))

출처

  • 데이터를 추가한 사람: kofgb

알고리즘 분류

통과된 코드

분할정복 알고리즘을 이용하여 문제를 해결하였다.

일단 해당 구역의 모든 값이 같은지 확인한다.

다르다면 왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래

이렇게 4개의 영상으로 나누어서 다시 확인한다. (분할 정복)

#include <iostream>

using namespace std;

int N;

char map[64][64];

string result;

void DivisionalConquest(int x, int y, int w)
{
	bool check = true;
	for (int i = 0; i < w ; i++) {
		for (int j = 0; j < w; j++) {
			if (map[x][y] != map[x + i][y + j]) check = false;
		}
		if (!check) break;
	}

	if (check) {
		result.push_back(map[x][y]);
		return;
	}
	else if (w == 1) {
		for (int i = 0; i < w; i++) {
			for (int j = 0; j < w; j++) {
				result.push_back(map[x + i][y + j]);
			}
		}

		return;
	}

	result.push_back('(');
	DivisionalConquest(x , y, w / 2);
	DivisionalConquest(x , y + w / 2, w / 2);
	DivisionalConquest(x + w / 2, y, w / 2);
	DivisionalConquest(x + w / 2, y + w / 2, w / 2);
	result.push_back(')');


}

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

	cin >> N;

	string str;

	for (int i = 0; i < N; i++) {
		cin >> str;
		for (int j = 0; j < str.length(); j++) {
			map[i][j] = str[j];
		}
	}

	DivisionalConquest(0, 0, N);

	cout << result;

	return 0;
}

추가 반례

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

예제 입력 A

8
11110000
11110000
00011100
00011100
11110000
11110000
11110011
11110011

예제 출력 A

((110(0101))(0010)1(0001))

예제 입력 B

16
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000
1111000011110000

예제 출력 B

((1010)(1010)(1010)(1010))

예제 입력 C

32
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000
11110000111100001111000011110000

예제 출력 C

(((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010)))

예제 입력 D

64
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000
1111000011110000111100001111000011110000111100001111000011110000

예제 출력 D

((((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010)))(((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010)))(((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010)))(((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))((1010)(1010)(1010)(1010))))

예제 입력 E

1

예제 출력 E

1

The post 백준 1992번 (쿼드트리, C++, DivideAndConquer) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

]]> https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1992%eb%b2%88-%ec%bf%bc%eb%93%9c%ed%8a%b8%eb%a6%ac-c-divideandconquer-baekjoon/33181/feed/ 0 백준 10815번 (숫자 카드, C++, Binary Search) [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-10815%eb%b2%88-%ec%88%ab%ec%9e%90-%ec%b9%b4%eb%93%9c-c-binary-search-baekjoon/5862/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-10815%eb%b2%88-%ec%88%ab%ec%9e%90-%ec%b9%b4%eb%93%9c-c-binary-search-baekjoon/5862/#respond Tue, 31 Jan 2023 13:12:25 +0000 https://lycos7560.com/?p=5862 백준(BAEKJOON) 10815번 '숫자 카드' 문제에 대한 글입니다. 'Binary Search' 를 이용하여 해결하였습니다. (This is an article about the 'number card' problem in BAEKJOON 10815. I solved it using 'Binary Search'.)

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

]]>

숫자 카드

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초256 MB70735322522313744.720%

문제

숫자 카드는 정수 하나가 적혀져 있는 카드이다.

상근이는 숫자 카드 N개를 가지고 있다. 

정수 M개가 주어졌을 때,

이 수가 적혀있는 숫자 카드를 상근이가 가지고 있는지 아닌지를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다.

둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다.

숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

두 숫자 카드에 같은 수가 적혀있는 경우는 없다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다.

넷째 줄에는 상근이가 가지고 있는 숫자 카드인지 아닌지를 구해야 할 M개의 정수가 주어지며,

이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다

출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서,

각 수가 적힌 숫자 카드를 상근이가 가지고 있으면 1을, 아니면 0을 공백으로 구분해 출력한다.

예제 입력 1

5
6 3 2 10 -10
8
10 9 -5 2 3 4 5 -10

예제 출력 1

1 0 0 1 1 0 0 1

출처

알고리즘 분류

순회 형식으로 구현하면 숫자 하나를 확인할때 마다 500,000번의 연산이 필요하다. (시간 초과)

순회로 확인하는 방법보다 더 빠른 탐색 방법이 필요한데

이럴 때 binary search를 이용하여 탐색의 시간 복잡도를 O(logN)으로 만들 수 있다.

코드는 재귀적으로 작성하였고 해설 참고하면 쉽게 이해가 가능하다.

통과된 코드

#include <iostream>
#include <algorithm>

using namespace std;

constexpr int MAX = 500000;

int arr[MAX];

int N , M, target;

// 이분 탐색 함수
bool BinarySearch(int tArr[MAX], int start, int end, int target)
{
	if (start > end) return false; // 만족하는 결과가 없다 false return

	int mid = (start + end) / 2; // 중간 값을 찾아준다.

	if (arr[mid] == target)	return true; // 만족하는 결과!! true return

	// 찾는 수가 더 작다면, 검사 범위를 더 작게해서 다시 이분탐색 // 결과가 나오면 return
	// 찾는 수가 더 크면, 검사 범위를 더 크게해서 다시 이분탐색 // 결과가 나오면 return
	if (arr[mid] > target) return BinarySearch(arr, start, mid - 1, target);
	else return BinarySearch(arr, mid + 1, end, target);
}

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 >> arr[i];
	
	// 이분 탐색을 위한 오름차순 정렬을 수행한다.
	sort(arr, arr + N);

	// 탐색할 숫자의 개수를 입력받는다.
	cin >> M;

	for (int i = 0; i < M; i++) {
		
		cin >> target;
		
		// 이진 탐색 후 출력
		cout << BinarySearch(arr, 0, N - 1, target) << "\n";

	}

	return 0;
}

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

]]> https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-10815%eb%b2%88-%ec%88%ab%ec%9e%90-%ec%b9%b4%eb%93%9c-c-binary-search-baekjoon/5862/feed/ 0 백준 1780번 (종이의 개수, C++, DivideAndConquer) [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1780%eb%b2%88-%ec%a2%85%ec%9d%b4%ec%9d%98-%ea%b0%9c%ec%88%98-c-divideandconquer-baekjoon/5718/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1780%eb%b2%88-%ec%a2%85%ec%9d%b4%ec%9d%98-%ea%b0%9c%ec%88%98-c-divideandconquer-baekjoon/5718/#respond Sun, 29 Jan 2023 07:52:12 +0000 https://lycos7560.com/?p=5718 백준(BAEKJOON) 1780번 "종이의 개수" 문제에 대한 글입니다. 재귀를 이용한 "분할정복" 알고리즘을 이용하여 해결하였습니다. (This is an article on the issue of "Number of Paper" in BAEKJOON 1780. It was solved using a "divisional conquest" algorithm using recursive.)

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

]]>

종이의 개수

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
2 초256 MB35301209691572058.541%

문제

N×N크기의 행렬로 표현되는 종이가 있다.

종이의 각 칸에는 -1, 0, 1 중 하나가 저장되어 있다.

우리는 이 행렬을 다음과 같은 규칙에 따라 적절한 크기로 자르려고 한다.

1. 만약 종이가 모두 같은 수로 되어 있다면 이 종이를 그대로 사용한다.

2. (1)이 아닌 경우에는 종이를 같은 크기의 종이 9개로 자르고, 각각의 잘린 종이에 대해서 (1)의 과정을 반복한다.

이와 같이 종이를 잘랐을 때, -1로만 채워진 종이의 개수, 0으로만 채워진 종이의 개수,

1로만 채워진 종이의 개수를 구해내는 프로그램을 작성하시오.

입력

첫째 줄에 N(1 ≤ N ≤ 37, N은 3k 꼴)이 주어진다.

다음 N개의 줄에는 N개의 정수로 행렬이 주어진다.

출력

첫째 줄에 -1로만 채워진 종이의 개수를, 둘째 줄에 0으로만 채워진 종이의 개수를,

셋째 줄에 1로만 채워진 종이의 개수를 출력한다.

예제 입력 1

9
0 0 0 1 1 1 -1 -1 -1
0 0 0 1 1 1 -1 -1 -1
0 0 0 1 1 1 -1 -1 -1
1 1 1 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0
0 1 -1 0 1 -1 0 1 -1
0 -1 1 0 1 -1 0 1 -1
0 1 -1 1 0 -1 0 1 -1

예제 출력 1

10
12
11

출처

알고리즘 분류

분할정복 문제

종이가 모두 같다면 카운트

아니면 9부분으로 나눈 후에 다시 확인

길이가 1 (3^0)이 될때 까지 해당 로직을 반복한다.

통과된 코드

#include <iostream>
#include <cmath>

using namespace std;

constexpr int MAX = 2187;

int map[MAX][MAX];

int N;

// 0 = 0 / 1 = 1 / -1 = 2
int result[3];

void ConquestDivison(int x, int y, int w)
{
	// 종이의 길이가 1(3^0) 이라면 해당 종이의 카운트를 증가시켜 줍니다.
	if (w == 0) { 
		if (map[x][y] == -1) result[2]++;
		else result[map[x][y]]++;
		return;
	}

	int number = map[x][y];
	int temp = pow(3, w);
	bool check = true;
	for (int i = 0; i < temp; i++) {
		for (int j = 0; j < temp; j++) {
			// 모든 부분이 서로 같은지 체크합니다.
			// 다르다면 빠져나가고 마킹해줍니다.
			if (number == map[x + i][y + j]) { continue; }
			else {
				check = false;
				break;
			}
		}
		if (!check) break;
	}

	if (check) { // 모든 부분이 같다면 해강 종이의 카운트를 올려줍니다.
		if (number == -1) result[2]++;
		else result[map[x][y]]++;
		return;
	}
	
	int temp2 = pow(3, w - 1);

	// 분할 정복 9등분
	ConquestDivison(x              , y              , w - 1);
	ConquestDivison(x              , y + temp2      , w - 1);
	ConquestDivison(x              , y + 2 * (temp2), w - 1);

	ConquestDivison(x + temp2	   , y				, w - 1);
	ConquestDivison(x + temp2	   , y + temp2		, w - 1);
	ConquestDivison(x + temp2	   , y + 2 * (temp2), w - 1);

	ConquestDivison(x + 2 * (temp2), y	            , w - 1);
	ConquestDivison(x + 2 * (temp2), y + temp2	    , w - 1);
	ConquestDivison(x + 2 * (temp2), y + 2 * (temp2), w - 1);
}


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++) {
		for (int j = 0; j < N; j++) {
			cin >> map[i][j];
		}
	}

	// N이 3의 몇승인지 확인합니다.
	int k = 0;
	int temp = N;
	while (temp != 1) {
		temp /= 3;
		k++;
	}
	
	ConquestDivison(0, 0, k);

	cout << result[2] << "\n" << result[0] << "\n" << result[1];

	return 0;
}

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

]]> https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-1780%eb%b2%88-%ec%a2%85%ec%9d%b4%ec%9d%98-%ea%b0%9c%ec%88%98-c-divideandconquer-baekjoon/5718/feed/ 0 백준 11403번 (경로 찾기, C++) [BAEKJOON] https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-11403%eb%b2%88-%ea%b2%bd%eb%a1%9c-%ec%b0%be%ea%b8%b0-c-baekjoon/5674/ https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-11403%eb%b2%88-%ea%b2%bd%eb%a1%9c-%ec%b0%be%ea%b8%b0-c-baekjoon/5674/#respond Fri, 27 Jan 2023 16:04:07 +0000 https://lycos7560.com/?p=5674 백준(BAEKJOON) 11403번 '경로 찾기' 문제에 대한 글입니다. 재귀 방식을 이용하여 해결하였습니다. (This is an article about the 'finding route' problem in BAEKJOON 11403. It was resolved using a recursive method.)

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

]]>

경로 찾기

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

시간 제한메모리 제한제출정답맞힌 사람정답 비율
1 초256 MB37990225051650458.953%

문제

가중치 없는 방향 그래프 G가 주어졌을 때, 모든 정점 (i, j)에 대해서,

i에서 j로 가는 경로가 있는지 없는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 정점의 개수 N (1 ≤ N ≤ 100)이 주어진다.

둘째 줄부터 N개 줄에는 그래프의 인접 행렬이 주어진다.

i번째 줄의 j번째 숫자가 1인 경우에는 i에서 j로 가는 간선이 존재한다는 뜻이고, 0인 경우는 없다는 뜻이다.

i번째 줄의 i번째 숫자는 항상 0이다.

출력

총 N개의 줄에 걸쳐서 문제의 정답을 인접행렬 형식으로 출력한다.

정점 i에서 j로 가는 경로가 있으면 i번째 줄의 j번째 숫자를 1로, 없으면 0으로 출력해야 한다.

예제 입력 1

3
0 1 0
0 0 1
1 0 0

예제 출력 1

1 1 1
1 1 1
1 1 1

예제 입력 2

7
0 0 0 1 0 0 0
0 0 0 0 0 0 1
0 0 0 0 0 0 0
0 0 0 0 1 1 0
1 0 0 0 0 0 0
0 0 0 0 0 0 1
0 0 1 0 0 0 0

예제 출력 2

1 0 1 1 1 1 1
0 0 1 0 0 0 1
0 0 0 0 0 0 0
1 0 1 1 1 1 1
1 0 1 1 1 1 1
0 0 1 0 0 0 1
0 0 1 0 0 0 0

예제 입력 3

7
0 0 0 1 0 0 0
0 0 0 0 0 0 1
0 0 0 0 0 0 0
0 0 0 0 1 1 0
1 0 0 0 0 0 0
0 0 0 0 0 0 1
0 0 1 0 0 0 0

예제 출력 3

1 0 1 1 1 1 1
0 0 1 0 0 0 1
0 0 0 0 0 0 0
1 0 1 1 1 1 1
1 0 1 1 1 1 1
0 0 1 0 0 0 1
0 0 1 0 0 0 0

출처

  • 문제를 만든 사람: baekjoon
  • 데이터를 추가한 사람: degurii

알고리즘 분류

통과된 코드

#include <iostream>

using namespace std;

constexpr int MAXN = 101;

bool map[MAXN][MAXN];
bool mapcheck[MAXN][MAXN];

int N, temp;

void check(int start, int end)
{
    mapcheck[start][end] = true;
    map[start][end] = true;

    for (int i = 1; i <= N; i++) {
        if (map[end][i] && !mapcheck[start][i]) {
            check(start, i);
        } 
    } 
}

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 = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            cin >> map[i][j];
        }
    }

    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            if (map[i][j] == true && mapcheck[i][j] != true) {
                mapcheck[i][j] = true;
                check(i, j);
            }
        }
    }

    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            cout << map[i][j] << " ";
        }
        cout << "\n";
    }

	return 0;
}

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

]]> https://lycos7560.com/cpp/baekjoon_online_judge/%eb%b0%b1%ec%a4%80-11403%eb%b2%88-%ea%b2%bd%eb%a1%9c-%ec%b0%be%ea%b8%b0-c-baekjoon/5674/feed/ 0