두 동전

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

문제

N×M 크기의 보드와 4개의 버튼으로 이루어진 게임이 있다.

보드는 1×1크기의 정사각형 칸으로 나누어져 있고, 각각의 칸은 비어있거나, 벽이다.

두 개의 빈 칸에는 동전이 하나씩 놓여져 있고, 두 동전의 위치는 다르다.

버튼은 “왼쪽”, “오른쪽”, “위”, “아래”와 같이 4가지가 있다.

버튼을 누르면 두 동전이 버튼에 쓰여 있는 방향으로 동시에 이동하게 된다.

• 동전이 이동하려는 칸이 벽이면, 동전은 이동하지 않는다.
• 동전이 이동하려는 방향에 칸이 없으면 동전은 보드 바깥으로 떨어진다.
• 그 외의 경우에는 이동하려는 방향으로 한 칸 이동한다.이동하려는 칸에 동전이 있는 경우에도 한 칸 이동한다.

두 동전 중 하나만 보드에서 떨어뜨리기 위해 버튼을 최소 몇 번 눌러야하는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 보드의 세로 크기 N과 가로 크기 M이 주어진다. (1 ≤ N, M ≤ 20)

둘째 줄부터 N개의 줄에는 보드의 상태가 주어진다.

• o: 동전
• .: 빈 칸
• #: 벽

동전의 개수는 항상 2개이다.

출력

첫째 줄에 두 동전 중 하나만 보드에서 떨어뜨리기 위해 눌러야 하는 버튼의 최소 횟수를 출력한다.

만약, 두 동전을 떨어뜨릴 수 없거나, 버튼을 10번보다 많이 눌러야 한다면, -1을 출력한다.

예제 입력 1

1 2
oo

예제 출력 1

1

예제 입력 2

6 2
.#
.#
.#
o#
o#
##

예제 출력 2

3

예제 입력 3

6 2
..
..
..
o#
o#
##

예제 출력 3

3

예제 입력 4

5 3
###
.o.
###
.o.
###

예제 출력 4

-1

예제 입력 5

5 3
###
.o.
#.#
.o.
###

예제 출력 5

3

출처

• 문제를 번역한 사람: baekjoon

알고리즘 분류

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

통과된 코드

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

using namespace std;

int _N, _M, _Res = -1;
int _DxDy[4][2] = { { 1, 0}, { 0, -1}, { 0, 1}, { -1, 0} };
char _Map[20][20];
string _Str;

vector<pair<int,int>> _Coins;

struct CntPos
{
	pair<int,int> CoinOne;
	pair<int,int> CoinTwo;
	int Cnt;

	CntPos(int _x1, int _y1, int _x2, int _y2, int _cnt) 
		: CoinOne(make_pair(_x1, _y1)), CoinTwo(make_pair(_x2, _y2)), Cnt(_cnt) {}
};

queue<CntPos> BfsQueue;

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] == 'o')
				_Coins.push_back({ i, j });
		}
	}

	BfsQueue.push(CntPos(_Coins[0].first, _Coins[0].second, _Coins[1].first, _Coins[1].second, 0));
	while (!BfsQueue.empty()) {
		CntPos _cntpos = BfsQueue.front();
		BfsQueue.pop();

		for (int i = 0; i < 4; i++) {
			bool CheckOne = false, CheckTwo = false;
			_Coins[0].first = _cntpos.CoinOne.first + _DxDy[i][0];
			_Coins[0].second = _cntpos.CoinOne.second + _DxDy[i][1];
			_Coins[1].first = _cntpos.CoinTwo.first + _DxDy[i][0];
			_Coins[1].second = _cntpos.CoinTwo.second + _DxDy[i][1];

			// 동전의 위치가 같다면 하나만 떨어뜨리는 조건에 맞지 않는다.
			if (_Coins[0] == _Coins[1]) continue;

			// 두 동전 중 하나만 보드에서 떨어뜨리기 위함
			if (_Coins[0].first < 0 || _Coins[0].second < 0 || _Coins[0].first >= _N || _Coins[0].second >= _M)
				CheckOne = true;
			if (_Coins[1].first < 0 || _Coins[1].second < 0 || _Coins[1].first >= _N || _Coins[1].second >= _M)
				CheckTwo = true;

			// 동전이 이동하려는 칸이 벽이면, 동전은 이동하지 않는다.
			if (!CheckOne && (_Map[_Coins[0].first][_Coins[0].second] == '#')) {
				_Coins[0].first = _cntpos.CoinOne.first;
				_Coins[0].second = _cntpos.CoinOne.second;
			}
			if (!(CheckTwo) && _Map[_Coins[1].first][_Coins[1].second] == '#') {
				_Coins[1].first = _cntpos.CoinTwo.first;
				_Coins[1].second = _cntpos.CoinTwo.second;
			}

			int _TCnt = _cntpos.Cnt;
			if (_TCnt >= 10) {
				_Res = -1;
				while (!BfsQueue.empty())
					BfsQueue.pop();
				break;
			}

			if (CheckOne ^ CheckTwo) {
				_Res = _TCnt + 1;
				while (!BfsQueue.empty())
					BfsQueue.pop();
				break;
			}
			else if(CheckOne && CheckTwo)
				continue;

			BfsQueue.push(CntPos(_Coins[0].first, _Coins[0].second, _Coins[1].first, _Coins[1].second, _TCnt + 1));
		}
	}

	cout << _Res;
	return 0;
}

생각보다 메모리를 많이 사용…

DFS 탐색을 이용한 백트레킹 방법이 시간과 메모리 부분에서 더 효율적이다.

DFS 참고 코드

https://hyeo-noo.tistory.com/126

#include <iostream>
#include <queue>
#include <cstring>
 
#define pii pair<int, int>
 
using namespace std;
 
 
int N, M, result = 1e9+7;
int Map[21][21];    // 2 : 동전 위치   0 : 벽 위치   1 : 빈칸
vector< pii > startP;
int dr[4] = {0, 0, 1, -1}, dc[4] = {1, -1, 0, 0};
 
void input(){
    // Map에서 벗어나는 경우는 -1로 설정
    memset(Map, -1, sizeof(Map));
    
    cin >> N >> M;
    string str;
    for(int i = 1; i <= N; i++){
        cin >> str;
        for(int j = 0; j < M; j++){
            if(str[j] == 'o'){
                Map[i][j+1] = 2;
                startP.push_back({i, j+1});
            }
            else if(str[j] == '#') Map[i][j+1] = 0;
            else Map[i][j+1] = 1;
        }
    }
}
 
bool isOut(const pii &A){
    if(A.first < 1 || A.first > N || A.second < 1 || A.second > M) return true;
    return false;
}
 
void dfs(pii A, pii B, int cnt){
    // 현재 result보다 cnt가 크다면 더이상의 탐색은 불필요
    if(result < cnt) return;
    
    // cnt 가 10보다 커지면 result값 갱신
    if(cnt > 10){
        result = min(result, cnt);
        return;
    }
    
    // 둘 다 떨어졌으면 되돌아감
    if(isOut(A) && isOut(B)) return;
    // 하나만 떨어졌으면 result를 최소 cnt값으로 교체
    else if((isOut(A) && !isOut(B)) || (!isOut(A) && isOut(B))){
        result = min(result, cnt);
        return;
    }
    
    for(int i = 0; i < 4; i++){
        pii An = {A.first + dr[i], A.second + dc[i]};
        pii Bn = {B.first + dr[i], B.second + dc[i]};
        if(!Map[An.first][An.second]) An = A;
        if(!Map[Bn.first][Bn.second]) Bn = B;
        
        dfs(An, Bn, cnt+1);
    }
}
 
int main(){
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    
    input();
    dfs(startP[0], startP[1], 0);
    
    if(result > 10) cout << -1;
    else cout << result;
    
    return 0;
}

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

비숍

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

문제

서양 장기인 체스에는 대각선 방향으로 움직일 수 있는 비숍(bishop)이 있다.

< 그림 1 >과 같은 정사각형 체스판 위에 B라고 표시된 곳에 비숍이 있을 때

비숍은 대각선 방향으로 움직여 O로 표시된 칸에 있는 다른 말을 잡을 수 있다.

그런데 체스판 위에는 비숍이 놓일 수 없는 곳이 있다.

< 그림 2 >에서 체스판에 색칠된 부분은 비숍이 놓일 수 없다고 하자.

이와 같은 체스판에 서로가 서로를 잡을 수 없도록 하면서 비숍을 놓는다면 < 그림 3 >과 같이 최대 7개의 비숍을 놓을 수 있다. 

색칠된 부분에는 비숍이 놓일 수 없지만 지나갈 수는 있다.

정사각형 체스판의 한 변에 놓인 칸의 개수를 체스판의 크기라고 한다.

체스판의 크기와 체스판 각 칸에 비숍을 놓을 수 있는지 없는지에 대한 정보가 주어질 때,

서로가 서로를 잡을 수 없는 위치에 놓을 수 있는 비숍의 최대 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 체스판의 크기가 주어진다.

체스판의 크기는 10이하의 자연수이다.

둘째 줄부터 아래의 예와 같이 체스판의 각 칸에 비숍을 놓을 수 있는지 없는지에 대한 정보가 체스판 한 줄 단위로 한 줄씩 주어진다.

비숍을 놓을 수 있는 곳에는 1, 비숍을 놓을 수 없는 곳에는 0이 빈칸을 사이에 두고 주어진다.

출력

첫째 줄에 주어진 체스판 위에 놓을 수 있는 비숍의 최대 개수를 출력한다.

예제 입력 1

5
1 1 0 1 1
0 1 0 0 0
1 0 1 0 1
1 0 0 0 0
1 0 1 1 1

예제 출력 1

7

출처

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2007 > 초등부 5번

알고리즘 분류

• 백트래킹

비숍은 같은 색깔의 비숍만 잡을 수 있다.

다른 색에 있는 비숍까지 모든 경우의 수를 고려한다면 시간 초과가 발생

아래의 코드는 재귀적으로 BackTracking을 구현한 코드

N x N 크기의 체스판에서 N개의 퀸을 배치하는 모든 경우를 탐색

각 칸마다 O(N) 시간이 소요되고, N x N 크기의 체스판에 N개의 퀸을 배치하므로

총 시간 복잡도는 O(N^N) => 시간초과

시간 초과 코드

#include <iostream>
using namespace std;
constexpr int _MAX = 10;
int _N, _Res;
bool _Map[_MAX][_MAX];
bool _Dx[19], _Dy[19];

void BackTracking(int _Cnt, int _x)
{
	int _dxy, _sum;
	for (int i = _x; i < _N; i++)
		for (int j = 0; j < _N; j++) {
			if (!_Map[i][j]) continue;
			_dxy = i - j + _N - 1;
			_sum = i + j;
			if (_Dx[_dxy] || _Dy[i + j]) continue;
			_Dx[_dxy] = true;
			_Dy[_sum] = true;
			BackTracking(_Cnt + 1, i);
			_Dx[_dxy] = false;
			_Dy[_sum] = false;
		}

	_Res = max(_Res, _Cnt);
}

int main()
{
	ios_base::sync_with_stdio(false);
	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];
	BackTracking(0, 0);
	cout << _Res;
	return 0;
}

통과된 코드

아래의 코드는 하얀 칸에 올 수 있는 비숍의 최댓값과

검은칸에 올 수 있는 비숍의 최댓값을 따로 구한 후 합한 결과를 출력해준다.

비숍을 해당 칸에 놓는 경우 / 안 놓는 경우 => 2가지

N / 2 칸을 N^2으로 탐색하지만 흑/백 2번이므로 => N^2

약 O(2^N^2)의 시간 복잡도를 가진다.

#include <iostream>
using namespace std;
constexpr int _MAX = 10;
int _N, _Res, _ResSum;
bool _Map[_MAX][_MAX];
bool _CheckX[19], _CheckY[19];

void CheckBishop(int _bishopCnt, int _x, bool _isOdd)
{
	int _dxy, _sum;
	for (int i = _x; i < _N; i++)
		for (int j = 0; j < _N; j++) {
			if (!_Map[i][j]) continue;
			_dxy = i - j + _N - 1;
			_sum = i + j;
			if (_CheckX[_dxy] || _CheckY[i + j] || _sum % 2 == _isOdd) continue;
			_CheckX[_dxy] = true;
			_CheckY[_sum] = true;
			CheckBishop(_bishopCnt + 1, i, _isOdd);
			_CheckX[_dxy] = false;
			_CheckY[_sum] = false;
		}

	_Res = max(_Res, _bishopCnt);
}

int main()
{
	ios_base::sync_with_stdio(false);
	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];
	CheckBishop(0, 0, false);
	_ResSum += _Res;
	_Res = 0;
	CheckBishop(0, 0, true);
	_ResSum += _Res;
	cout << _ResSum;
	return 0;
}

제출된 답 중에서 0ms 도 있다… 세상에는 괴물이 많다.

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

N-Queen

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

문제

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다.

N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (1 ≤ N < 15)

출력

첫째 줄에 퀸 N개를 서로 공격할 수 없게 놓는 경우의 수를 출력한다.

예제 입력 1

5 17

예제 출력 1

2

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 브루트포스 알고리즘
• 백트래킹

통과된 코드

#include <iostream>
#include <cmath>
using namespace std;
constexpr int Max = 15; // 체스판의 최대 
int _N, _Res, _Queen[Max];

bool CheckQueens(int _row)
{
	for (int i = 0; i < _row; i++) {
		// 절대값으로 대각선으로 전부 확인
		if (_Queen[i] == _Queen[_row] || ( abs(_Queen[i] - _Queen[_row]) == abs(i - _row))) {
			return false;
		}
	}
	return true;
}

void BackTracing(int _row) {
	// N번째까지 왔다면 경우의 수 추가
	if (_row == _N) {
		_Res++;
		return; 
	}

	for (int _col = 0; _col < _N; _col++) {
		_Queen[_row] = _col;
		//해당 행이 가능한지 확인한다.
		if (CheckQueens(_row)) 
			BackTracing(_row + 1);
	}
}

int main()
{
	cin >> _N; // 체스판의 크기 입력
	BackTracing(0); // 백트레킹으로 체크
	cout << _Res;
	return 0;
}

더 효율적인 코드

DFS 탐색을 이용한 백트레킹

dy dx를 대각선으로 표현하여 검사

#include <iostream>
using namespace std;
constexpr int Max = 15;
int _N, _Res;
// 체스판 
bool MapArr[Max];
//체스판의 대각선을 표현하기위한 변수
//대각선은 2N - 1개 필요
bool dx[29], dy[29];

void BackTracking(int level)
{
	if (level == _N) {
		_Res++;
		return;
	}
	for (int i = 0; i < _N; i++) {
		//현재 열, 왼쪽 대각선 및 오른쪽 대각선에 이미 배치된 여왕이 없는지 확인
		// dx, dy는 체스판의 특정한 위치를 나타내는 변수가 아니다.
		// dx, dy를 이용하여 대각선을 추적하는 것
		// 배열의 각 인덱스는 dx대각선을 나타내며 해당 인덱스의 값은 대각선이 여왕에 의해 점유되는지 여부를 나타냅니다. 
		if (!MapArr[i] && !dx[i - level + _N] && !dy[i + level]) {
			
			MapArr[i] = dx[i - level + _N] = dy[i + level] = true;
			BackTracking(level + 1);
			MapArr[i] = dx[i - level + _N] = dy[i + level] = false;
		}
	}
}

int main() {
	_Res = 0;
	cin >> _N;
	BackTracking(0);
	cout << _Res;
}

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

N과 M (12)

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

문제

N개의 자연수와 자연수 M이 주어졌을 때,

아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

N개의 자연수 중에서 M개를 고른 수열

같은 수를 여러 번 골라도 된다.

고른 수열은 비내림차순이어야 한다.

=> 길이가 K인 수열 A가 A₁ ≤ A₂ ≤ … ≤ A_K-1 ≤ A_K를 만족하면, 비내림차순이라고 한다.

입력

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

둘째 줄에 N개의 수가 주어진다.

입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

예제 입력 1

3 1
4 4 2

예제 출력 1

2
4

예제 입력 2

4 2
9 7 9 1

예제 출력 2

1 1
1 7
1 9
7 7
7 9
9 9

예제 입력 3

4 4
1 1 2 2

예제 출력 3

1 1 1 1
1 1 1 2
1 1 2 2
1 2 2 2
2 2 2 2

출처

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

알고리즘 분류

• 백트래킹

통과된 코드

자료구조 set을 이용하여 숫자의 중복을 제거 및 정렬

#include <iostream>
#include <set>

using namespace std;

int _N, _M, _Temp, _Arr[8], _Num[8];

void RecursiveFunction(int _X, int _Len) 
{
    if (_Len == _M) {
        for (int i = 0; i < _M; i++)
            cout << _Arr[i] << " ";
        cout << "\n";
        return;
    }

    for (int i = _X; i < _N; i++) {
        _Arr[_Len] = _Num[i];
        RecursiveFunction(i, _Len + 1);
    }
    return;
}

int main()
{
    set<int> _MySet;
    cin >> _N >> _M;
    for (int i = 0; i < _N; i++) {
        cin >> _Temp;
        _MySet.insert(_Temp);
    }

    int _Cnt = 0;

    for (auto& iter : _MySet) 
        _Num[_Cnt++] = iter;
    
    _N = _MySet.size();
    RecursiveFunction(0, 0);
    return 0;
}

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

N과 M (8)

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

문제

N개의 자연수와 자연수 M이 주어졌을 때,

아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

N개의 자연수는 모두 다른 수이다.

N개의 자연수 중에서 M개를 고른 수열

같은 수를 여러 번 골라도 된다.

고른 수열은 비내림차순이어야 한다.

=> 길이가 K인 수열 A가 A₁ ≤ A₂ ≤ … ≤ A_K-1 ≤ A_K를 만족하면, 비내림차순이라고 한다.

입력

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

둘째 줄에 N개의 수가 주어진다.

입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

예제 입력 1

3 1
4 5 2

예제 출력 1

2
4
5

예제 입력 2

4 2
9 8 7 1

예제 출력 2

1 1
1 7
1 8
1 9
7 7
7 8
7 9
8 8
8 9
9 9

예제 입력 3

4 4
1231 1232 1233 1234

예제 출력 3

1231 1231 1231 1231
1231 1231 1231 1232
1231 1231 1231 1233
1231 1231 1231 1234
1231 1231 1232 1232
1231 1231 1232 1233
1231 1231 1232 1234
1231 1231 1233 1233
1231 1231 1233 1234
1231 1231 1234 1234
1231 1232 1232 1232
1231 1232 1232 1233
1231 1232 1232 1234
1231 1232 1233 1233
1231 1232 1233 1234
1231 1232 1234 1234
1231 1233 1233 1233
1231 1233 1233 1234
1231 1233 1234 1234
1231 1234 1234 1234
1232 1232 1232 1232
1232 1232 1232 1233
1232 1232 1232 1234
1232 1232 1233 1233
1232 1232 1233 1234
1232 1232 1234 1234
1232 1233 1233 1233
1232 1233 1233 1234
1232 1233 1234 1234
1232 1234 1234 1234
1233 1233 1233 1233
1233 1233 1233 1234
1233 1233 1234 1234
1233 1234 1234 1234
1234 1234 1234 1234

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 백트래킹

통과된 코드

재귀를 이용하여 출력

#include <iostream>
#include <algorithm>
using namespace std;
int _N, _M, _Arr[8], _Num[8];
void RecursiveFunction(int _X, int _Len) {
    if (_Len == _M) {
        for (int i = 0; i < _M; i++) 
            cout << _Arr[i] << " ";
        cout << "\n";
        return;
    }

    for (int i = _X; i < _N; i++) {
        _Arr[_Len] = _Num[i];
        RecursiveFunction(i, _Len + 1);
    }
    return;
}
int main() 
{
    cin >> _N >> _M;
    for (int i = 0; i < _N; i++)
        cin >> _Num[i];
    sort(_Num, _Num + _N); // 정렬
    RecursiveFunction(0, 0);
    return 0;
}

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

N과 M (2)

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

문제

자연수 N과 M이 주어졌을 때,

아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열

고른 수열은 오름차순이어야 한다.

입력

첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며,

각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

예제 입력 1

3 1

예제 출력 1

1
2
3

예제 입력 2

4 2

예제 출력 2

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

예제 입력 3

4 4

예제 출력 3

1 2 3 4

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 백트래킹

통과된 코드

#include <iostream>

using namespace std;

int _N, _M, _Arr[8], _Num[8];

void RecursiveFunction(int _X, int _Len) {
    if (_Len == _M) {
        for (int i = 0; i < _M; i++) 
            cout << _Arr[i] << " ";
        cout << "\n";
        return;
    }

    for (int i = _X; i < _N; i++) {
        _Arr[_Len] = _Num[i];
        RecursiveFunction(i + 1, _Len + 1);
    }
    return;
}

int main() 
{
    cin >> _N >> _M;
    for (int i = 0; i < _N; i++)
        _Num[i] = i + 1;
    RecursiveFunction(0, 0);
    return 0;
}

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

N과 M (5)

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

문제

N개의 자연수와 자연수 M이 주어졌을 때,

아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

N개의 자연수는 모두 다른 수이다.

N개의 자연수 중에서 M개를 고른 수열

입력

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

둘째 줄에 N개의 수가 주어진다.

입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

예제 입력 1

3 1
4 5 2

예제 출력 1

2
4
5

예제 입력 2

4 2
9 8 7 1

예제 출력 2

1 7
1 8
1 9
7 1
7 8
7 9
8 1
8 7
8 9
9 1
9 7
9 8

예제 입력 3

4 4
1231 1232 1233 1234

예제 출력 3

1231 1232 1233 1234
1231 1232 1234 1233
1231 1233 1232 1234
1231 1233 1234 1232
1231 1234 1232 1233
1231 1234 1233 1232
1232 1231 1233 1234
1232 1231 1234 1233
1232 1233 1231 1234
1232 1233 1234 1231
1232 1234 1231 1233
1232 1234 1233 1231
1233 1231 1232 1234
1233 1231 1234 1232
1233 1232 1231 1234
1233 1232 1234 1231
1233 1234 1231 1232
1233 1234 1232 1231
1234 1231 1232 1233
1234 1231 1233 1232
1234 1232 1231 1233
1234 1232 1233 1231
1234 1233 1231 1232
1234 1233 1232 1231

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 백트래킹

통과된 코드

#include <iostream>
#include <algorithm>

using namespace std;

int _N, _M, _Arr[8], _Num[8];
bool _NumBool[8];
void RecursiveFunction(int _X, int _Len) {
    if (_Len == _M) {
        for (int i = 0; i < _M; i++)
            cout << _Arr[i] << " ";
        cout << "\n";
        return;
    }

    for (int i = 0; i < _N; i++) {
        if (_NumBool[i]) continue;
        _Arr[_Len] = _Num[i];
        _NumBool[i] = true;
        RecursiveFunction(i, _Len + 1);
        _NumBool[i] = false;
    }

    return;
}

int main()
{
    cin >> _N >> _M;
    for (int i = 0; i < _N; i++)
        cin >> _Num[i];
    sort(_Num, _Num + _N); // 정렬
    RecursiveFunction(0, 0);
    return 0;
}

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

N과 M (9)

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

문제

N개의 자연수와 자연수 M이 주어졌을 때,

아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

N개의 자연수 중에서 M개를 고른 수열

입력

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

둘째 줄에 N개의 수가 주어진다.

입력으로 주어지는 수는 10,000보다 작거나 같은 자연수이다.

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며, 각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

예제 입력 1

3 1
4 4 2

예제 출력 1

2
4

예제 입력 2

4 2
9 7 9 1

예제 출력 2

1 7
1 9
7 1
7 9
9 1
9 7
9 9

예제 입력 3

4 4
1 1 1 1

예제 출력 3

1 1 1 1

출처

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

알고리즘 분류

• 백트래킹

통과된 코드

#include <iostream>
#include <algorithm>

using namespace std;

int _N, _M, _Arr[8], _Num[8];
bool _NumBool[8]; // 중복을 확인

void RecursiveFunction(int _Len) 
{
    if (_Len == _M) {
        for (int i = 0; i < _M; i++)
            cout << _Arr[i] << " ";
        cout << "\n";
        return;
    }

    int _Temp = 0;
    for (int i = 0; i < _N; i++) {
        if (!_NumBool[i] && _Num[i] != _Temp) {
            _Arr[_Len] = _Num[i];
            _Temp = _Arr[_Len];
            _NumBool[i] = true;
            RecursiveFunction(_Len + 1);
            _NumBool[i] = false;    
        }
    }
    return;
}

int main()
{
    cin >> _N >> _M;
    for (int i = 0; i < _N; i++) 
        cin >> _Num[i];
    sort(_Num, _Num + _N);
    RecursiveFunction(0);
    return 0;
}

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

N과 M (4)

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

문제

자연수 N과 M이 주어졌을 때,

아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성하시오.

1부터 N까지 자연수 중에서 M개를 고른 수열

같은 수를 여러 번 골라도 된다.

고른 수열은 비내림차순이어야 한다.

=> 길이가 K인 수열 A가 A₁ ≤ A₂ ≤ … ≤ A_K-1 ≤ A_K를 만족하면, 비내림차순이라고 한다.

입력

첫째 줄에 자연수 N과 M이 주어진다. (1 ≤ M ≤ N ≤ 8)

출력

한 줄에 하나씩 문제의 조건을 만족하는 수열을 출력한다.

중복되는 수열을 여러 번 출력하면 안되며,

각 수열은 공백으로 구분해서 출력해야 한다.

수열은 사전 순으로 증가하는 순서로 출력해야 한다.

예제 입력 1

3 1

예제 출력 1

1
2
3

예제 입력 2

4 2

예제 출력 2

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

예제 입력 3

3 3

예제 출력 3

1 1 1
1 1 2
1 1 3
1 2 2
1 2 3
1 3 3
2 2 2
2 2 3
2 3 3
3 3 3

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 백트래킹

통과된 코드

#include <iostream>

using namespace std;

int _N, _M, _Arr[8], _Num[8];

void RecursiveFunction(int _X, int _Len) {
    if (_Len == _M) {
        for (int i = 0; i < _M; i++) 
            cout << _Arr[i] << " ";
        cout << "\n";
        return;
    }

    for (int i = _X; i < _N; i++) {
        _Arr[_Len] = _Num[i];
        RecursiveFunction(i, _Len + 1);
    }
    return;
}

int main() 
{
    cin >> _N >> _M;
    for (int i = 0; i < _N; i++)
        _Num[i] = i + 1;
    RecursiveFunction(0, 0);
    return 0;
}

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

좋은수열

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

문제

숫자 1, 2, 3으로만 이루어지는 수열이 있다.
임의의 길이의 인접한 두 개의 부분 수열이 동일한 것이 있으면, 그 수열을 나쁜 수열이라고 부른다.
그렇지 않은 수열은 좋은 수열이다.

다음은 나쁜 수열의 예이다.

• 33
• 32121323
• 123123213

다음은 좋은 수열의 예이다.

• 2
• 32
• 32123
• 1232123

길이가 N인 좋은 수열 들을 N자리의 정수로 보아 그 중 가장 작은 수를 나타내는
수열을 구하는 프로그램을 작성하라.

예를 들면, 1213121과 2123212는 모두 좋은 수열이지만
그 중에서 작은 수를 나타내는 수열은 1213121이다.

입력

입력은 숫자 N하나로 이루어진다. N은 1 이상 80 이하이다.

출력

첫 번째 줄에 1, 2, 3으로만 이루어져 있는 길이가 N인 좋은 수열 들 중에서 가장 작은 수를
나타내는 수열만 출력한다.
수열을 이루는 1, 2, 3 들 사이에는 빈칸을 두지 않는다.

예제 입력 1

7

예제 출력 1

1213121

출처

Olympiad > 한국정보올림피아드 > KOI 1997 > 중등부 1번

• 문제의 오타를 찾은 사람: busyhuman, mwy3055

알고리즘 분류

• 백트래킹

1차 시도
BFS로 모든 경우를 다 만들어 놓고 시작하려니 N이 80 이 되는 순간 프로그램이 나락을 간다.

실패코드

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

using namespace std;

queue<pair<int,int>> myQueue;

int N;

void BFS(int N)
{
	myQueue.push({0, N});

	while (!myQueue.empty())
	{
		int x = myQueue.front().first;
		int n = myQueue.front().second;
		myQueue.pop();

		cout << n << " \n";
		if (n == 0)
		{
			//cout << x << " \n";
			continue;
		}
		for (int i = 1; i <= 3; i++)
		{
			if (i == 1)
			{
				myQueue.push({ x + 1 * pow(10, n - 1), n-1 });
			}
			else if (i == 2)
			{
				myQueue.push({ x + 2 * pow(10, n - 1), n - 1 });
			}
			else if (i == 3)
			{
				myQueue.push({ x + 3 * pow(10, n - 1), n - 1 });
			}
		}
	}

}


int main()
{
	cin >> N;
	BFS(N);
	return 0;
}

계산 중 깊이를 측정해보니 이건 노답 이라는 것을 깨달았다.

DFS로 변경
목표는 가장 낮은 숫자를 찾는 것 => 1부터 시작해서 탐색

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

using namespace std;

int N;

void DFS(int n, int value)
{
	if (n == 0)
	{
		cout << value << "\n";
		return;
	}

	for (int i = 1; i <= 3; i++)
	{
		if (i == 1)
		{
			DFS(n - 1, value + 1 * pow(10, n - 1));
		}
		else if (i == 2)
		{
			DFS(n - 1, value + 2 * pow(10, n - 1));
		}
		else if (i == 3)
		{
			DFS(n -1, value + 3 * pow(10, n - 1));
		}
	}
}

int main()
{
	cin >> N;
	DFS(N, 0);
	cout << "end";
	return 0;
}

N은 80까지 가능
80 자리…
string 으로 변환….

#include <iostream>
#include <string>

using namespace std;

int N;

void DFS(int n, string value)
{
	if (n == 0)
	{
		cout << value << "\n";
		return;
	}

	
	for (int i = 1; i <= 3; i++)
	{
		if (i == 1)
		{
			DFS(n - 1, value + '1');
		}
		else if (i == 2)
		{
			DFS(n - 1, value + '2');
		}
		else if (i == 3)
		{
			DFS(n - 1, value + '3');
		}
	}
}

int main()
{
	cin >> N;
	DFS(N, "");
	cout << "end";
	return 0;
}

조건에 부합하는 가장 처음 값이 정답

성공 코드(DFS)

#include <iostream>
#include <string>

using namespace std;

int N;
string number;

void DFS(char ch, int cnt)
{
	// 제일 먼저 조건에 부합하는 숫자가 답
	if (cnt - 1 == N) { 
		cout << number; 
		exit(0);
	}
	
	number += ch;
	
	for (int i = 1; i <= cnt/2; i++)
	{
		string a = number.substr(cnt - i, i);
		string b = number.substr(cnt - i * 2, i);

		if (a == b){ 
			// 나쁜 수열이면 지우고 리턴
			number.erase(cnt - 1);
			return;
		}
	}

	for (int i = 1; i <= 3; i++)
	{
		DFS(i + '0', cnt + 1);
	}

	// cnt - 1 자리가 성립하지 않을 경우
	number.erase(cnt - 1);
}

int main()
{
	cin >> N;
	for (int i = 1; i <= 3; i++)
	{
		// '0' 에서 i 만큼 더하면 i
		DFS(i + '0', 1);
	}

	return 0;
}

The post 백준 2661번 (좋은수열, C++, Backtracking) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.