현구의 개발 블로그

백준 1565 c++ N과 M (5)

현구구 — Tue, 9 Jul 2024 14:01:09 +0900

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

#include <iostream>
#include <algorithm>

using namespace std;

bool visit[8];
int result[8];
int arr[8];

void dfs(int n, int m, int cnt)
{
	if (cnt == m)
	{
		for (int i = 0; i < m; i++)
		{
			cout << result[i] << ' ';
		}
		cout << '\n';
		return;
	}
	for (int i = 0; i < n; i++)
	{
		if (visit[i] == false)
		{
			result[cnt] = arr[i];
			visit[i] = true;
			dfs(n, m, cnt + 1);
			visit[i] = false;
		}
	}
}

int main()
{
	int n, m;
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	sort(arr, arr + n);
	dfs(n, m, 0);
}

백준 15652 c++ N과 M (4)

현구구 — Tue, 9 Jul 2024 13:58:59 +0900

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

#include <iostream>

using namespace std;

bool visit[8];
int result[8];

void dfs(int start, int n, int m, int cnt)
{
	if (cnt == m)
	{
		for (int i = 0; i < m; i++)
		{
			cout << result[i] << ' ';
		}
		cout << '\n';
		return;
	}
	for (int i = start; i <= n; i++)
	{
		result[cnt] = i;
		dfs(i, n, m, cnt + 1);
	}
}

int main()
{
	int n, m;
	cin >> n >> m;
	dfs(1, n, m, 0);
}

백준 15651 c++ N과 M(3)

현구구 — Tue, 9 Jul 2024 13:56:38 +0900

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

#include <iostream>

using namespace std;

bool visit[8];
int result[8];

void dfs(int n, int m, int cnt)
{
	if (cnt == m)
	{
		for (int i = 0; i < m; i++)
		{
			cout << result[i] << ' ';
		}
		cout << '\n';
		return;
	}
	for (int i = 1; i <= n; i++)
	{
		result[cnt] = i;
		dfs(n, m, cnt + 1);
	}
}

int main()
{
	int n, m;
	cin >> n >> m;
	dfs(n, m, 0);
}

백준 15650 c++ N과 M (2)

현구구 — Tue, 9 Jul 2024 13:50:44 +0900

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

#include <iostream>

using namespace std;

bool visit[8];
int result[8];

void dfs(int start, int n, int m, int cnt)
{
	if (cnt == m)
	{
		for (int i = 0; i < m; i++)
		{
			cout << result[i] << ' ';
		}
		cout << '\n';
	}
	for (int i = start; i <= n; i++)
	{
		if (visit[i] == false) 
		{
			result[cnt] = i;
			visit[i] = true;
			dfs(i,n, m, cnt + 1);
			visit[i] = false;
		}
	}
}

int main()
{
	int n, m;
	cin >> n >> m;
	dfs(1, n, m, 0);
}

백준 15649 c++ N과 M (1)

현구구 — Tue, 9 Jul 2024 13:45:11 +0900

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

#include <iostream>

using namespace std;

bool visit[8];
int result[8];

void dfs(int n, int m, int cnt)
{
	if (cnt == m)
	{
		for (int i = 0; i < m; i++)
		{
			cout << result[i] << ' ';
		}
		cout << '\n';
	}
	for (int i = 1; i <= n; i++)
	{
		if (visit[i] == false)
		{
			result[cnt] = i;
			visit[i] = true;
			dfs(n, m, cnt + 1);
			visit[i] = false;
		}
	}
}

int main()
{
	int n, m;
	cin >> n >> m;
	dfs(n, m, 0);

}

백준 9095 1, 2, 3 더하기

현구구 — Tue, 9 Jul 2024 13:25:32 +0900

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

#include <iostream>

using namespace std;

int T = 0;

int main()
{
	cin >> T;
	int dp[11];
	dp[1] = 1;
	dp[2] = 2;
	dp[3] = 4;
	for (int i = 4; i <= 10; i++)
	{
		dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
	}
	while (T--)
	{
		int n;
		cin >> n;
		cout << dp[n] << '\n';
	}
}

백준 6064 c++ 카잉달력

현구구 — Tue, 9 Jul 2024 12:21:36 +0900

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

#include <iostream>

using namespace std;

int get_count;

int gcd(int x,int y) {
	if (y > x)
	{
		int tmp = x;
		x = y;
		y = tmp;
	}
	while ((x % y) != 0)
	{
		x = x % y;
		int tmp = x;
		x = y;
		y = tmp;
	}
	return y;
}

int lcm(int x,int y)
{
	return x * y / gcd(x, y);
}

int main()
{
	cin >> get_count;
	while (get_count--)
	{
		int m, n, x, y;
		cin >> m >> n >> x >> y;
		int limit = lcm(m, n);

		int result = -1;
		for (int i = x; i <= limit; i = i + m)
		{
			if ((i-y)%n == 0)
			{
				result = i;
				break;
			}
		}
		cout << result << '\n';

	}
}

14500 - 테트로미노

현구구 — Mon, 24 Jun 2024 14:16:17 +0900

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

#include <iostream>
#include <vector>

using namespace std;

int n, m;

int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,1,-1 };
int result = 0;
int arr[500][500];
bool visit[500][500];

void dfs(int count, int sum, int row, int col)
{
	if (count == 4)
	{
		if (result < sum)
		{
			result = sum;
		}
		return;
	}
	for (int i = 0; i < 4; i++)
	{
		int next_row = row + dx[i];
		int next_col = col + dy[i];
		if (next_row < 0 || next_col < 0 || next_row >= n || next_col >= m) // 범위 벗어나면
			continue;
		if (visit[next_row][next_col]) // 방문햇어도 스킵
			continue;
		visit[next_row][next_col] = true;
		dfs(count + 1, sum + arr[next_row][next_col], next_row, next_col);
		visit[next_row][next_col] = false;
	}
}


void Tshape(int row, int col) {
	int sum;

	// ㅗ 모양
	if (row - 1 >= 0 && col - 1 >= 0 && col + 1 < m) {
		sum = arr[row][col] + arr[row - 1][col] + arr[row][col - 1] + arr[row][col + 1];
		if (sum > result) result = sum;
	}

	// ㅜ 모양
	if (row + 1 < n && col - 1 >= 0 && col + 1 < m) {
		sum = arr[row][col] + arr[row + 1][col] + arr[row][col - 1] + arr[row][col + 1];
		if (sum > result) result = sum;
	}

	// ㅓ 모양
	if (row - 1 >= 0 && row + 1 < n && col + 1 < m) {
		sum = arr[row][col] + arr[row - 1][col] + arr[row + 1][col] + arr[row][col + 1];
		if (sum > result) result = sum;
	}

	// ㅏ 모양
	if (row - 1 >= 0 && row + 1 < n && col - 1 >= 0) {
		sum = arr[row][col] + arr[row - 1][col] + arr[row + 1][col] + arr[row][col - 1];
		if (sum > result) result = sum;
	}
}

int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cin >> arr[i][j];
		}
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			visit[i][j] = true;
			dfs(0,0,i,j);
			visit[i][j] = false;
			Tshape(i, j);
		}
	}
	cout << result;
}

1107 - 리모컨 c++

현구구 — Mon, 24 Jun 2024 14:06:27 +0900

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

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


using namespace std;

int n; // 이동하고자 하는 채널
int m; // 고장난 버튼 개수
bool ban[10];

int main()
{
	cin >> n >> m;
	for (int i = 0; i < m; i++)
	{
		int a;
		cin >> a;
		ban[a] = true;
	}

	if (n == 100) // 이미 목표일 때
	{
		cout << 0;
		return 0;
	}
	if (m == 10) // 다 고장 났을 때
	{
		cout << abs(n - 100);
		return 0;
	}
	int upper, lower;
	for (upper = n; upper < 999999; upper++)
	{
		string str = to_string(upper);
		bool pass = true;
		for (int i = 0; i < str.size(); i++)
		{
			if (ban[str[i] - '0']) // 고장난 버튼이 있으면 break
			{
				pass = false;
				break;
			}
		}
		if (pass)
			break;
	}

	for (lower = n; lower >= 0; lower--)
	{
		string str = to_string(lower);
		bool pass = true;
		for (int i = 0; i < str.size(); i++)
		{
			if (ban[str[i] - '0']) // 고장난 버튼이 있으면 break
			{
				pass = false;
				break;
			}
		}
		if (pass)
			break;
	} 
	if (lower < 0) // lower 가 음수가 될 수도 있기 때문에
	{
		lower = 999999;
	}

	int result = min((int)min(abs(n - lower) + to_string(lower).size() , abs(n - upper) + to_string(upper).size()), abs(n - 100));

	cout << result;
	return 0;
}

// 1. 한번에 그 근처로 이동하는 경우
// 1-1. 해당 목표의 위로
// 1-2. 해당 목표의 아래로
// 2. + - 만으로 이동하는 경우
// 3. 100이 들어온 경우
// 4. 다 고장났을 경우

백준 1476 c++ 날짜 계산

현구구 — Mon, 29 Jan 2024 10:23:24 +0900

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

1476번: 날짜 계산

준규가 사는 나라는 우리가 사용하는 연도와 다른 방식을 이용한다. 준규가 사는 나라에서는 수 3개를 이용해서 연도를 나타낸다. 각각의 수는 지구, 태양, 그리고 달을 나타낸다. 지구를 나타

www.acmicpc.net

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

int maxRange = 15 * 28 * 19;
vector<vector<bool>> arr(3, vector<bool>(maxRange, false));

void check(int n, int ESB)
{
	for (int i = n; i <= maxRange; i = i + ESB)
	{
		if (ESB == 15)
		{
			arr[0][i] = true;
		}
		else if (ESB == 28)
		{
			arr[1][i] = true;
		}
		else if (ESB == 19)
		{
			arr[2][i] = true;
		}
	}
}

int main()
{
	//입력
	int E, S, M;
	cin >> E >> S >> M;

	//알고리즘 
	check(E, 15);
	check(S, 28);
	check(M, 19);
	
	//출력	
	for (int i = 1; i <= maxRange; i++)
	{
		if (arr[0][i] && arr[1][i] && arr[2][i])
		{
			cout << i;
			break;
		}
	}
}

지구 / 태양 / 달
E / S / M <1 ≤ E ≤ 15, 1 ≤ S ≤ 28, 1 ≤ M ≤ 19>

1 / 2 / 3 이 주어졋다고 하면
1에 15를 계속 더해감
2에 28를 계속 더해감
3에 19를 계속 더해감

어느 순간 같아지는 값이 있을 것

백준 3085 c++ 사탕 게임

현구구 — Sun, 28 Jan 2024 18:38:03 +0900

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

3085번: 사탕 게임

예제 3의 경우 4번 행의 Y와 C를 바꾸면 사탕 네 개를 먹을 수 있다.

www.acmicpc.net

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

int maxCnt = 0;
vector<vector<char>> arr;
int n;

void checkMax()
{
	//가로 체크
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n - 1; j++)
		{
			char tmp = arr[i][j];
			int localMax = 1;
			while (tmp == arr[i][j + 1]) // 다음거랑 같다면
			{
				if (j + 1 == n - 1)
				{
					localMax++;
					break;
				}
				localMax++;
				j++;
			}
			if (maxCnt < localMax)
			{
				maxCnt = localMax;
			}
		}
	}
	//세로 체크
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n - 1; j++)
		{
			char tmp = arr[j][i];
			int localMax = 1;
			while (tmp == arr[j+1][i]) // 다음거랑 같다면
			{
				if (j + 1 == n - 1)
				{
					localMax++;
					break;
				}
				localMax++;
				j++;
			}
			if (maxCnt < localMax)
			{
				maxCnt = localMax;
			}
		}
	}
}

void changeRow()
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n - 1; j++)
		{
			char tmp = arr[i][j]; // 1회 교환
			arr[i][j] = arr[i][j + 1];
			arr[i][j + 1] = tmp;
			checkMax();
			arr[i][j + 1] = arr[i][j]; //원상복구
			arr[i][j] = tmp;
		}
	}
}

void changeCol()
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n - 1; j++)
		{
			char tmp = arr[j][i]; // 1회 교환
			arr[j][i] = arr[j+1][i];
			arr[j+1][i] = tmp;
			checkMax();
			arr[j+1][i] = arr[j][i]; //원상복구
			arr[j][i] = tmp;
		}
	}
}

int main()
{
	cin >> n;
	arr = vector<vector<char>>(n,vector<char>(n,0));
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cin >> arr[i][j];
		}
	}
	changeRow();
	changeCol();
	cout << maxCnt;
}

한 번 교체 > 가장 긴 연속 색 체크 > 다시 교체하여 원상복구

백준 2309 일곱 난쟁이 c++

현구구 — Sat, 27 Jan 2024 20:57:53 +0900

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

2309번: 일곱 난쟁이

아홉 개의 줄에 걸쳐 난쟁이들의 키가 주어진다. 주어지는 키는 100을 넘지 않는 자연수이며, 아홉 난쟁이의 키는 모두 다르며, 가능한 정답이 여러 가지인 경우에는 아무거나 출력한다.

www.acmicpc.net

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

int main()
{
	int arr[9];
	int sum = 0;
	for (int i = 0; i < 9; i++)
	{
		cin >> arr[i];
		sum += arr[i];
	}
	
	int not_nan = sum - 100;

	int n1, n2;

	sort(arr,arr+9);

	//난장이 아닌 애들 찾기
	for (int i = 0; i < 9; i++)
	{
		for (int j = i+1; j < 9; j++)
		{
			if (arr[i] + arr[j] == not_nan)
			{
				n1 = i;
				n2 = j;
			}
		}
	}

	for (int i = 0; i < 9; i++)
	{
		if ((i == n1) || (i == n2))
			continue;
		cout << arr[i] << '\n';
	}

}

백준 6588 c++ 골드바흐의 추측

현구구 — Sat, 27 Jan 2024 19:57:48 +0900

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

6588번: 골드바흐의 추측

각 테스트 케이스에 대해서, n = a + b 형태로 출력한다. 이때, a와 b는 홀수 소수이다. 숫자와 연산자는 공백 하나로 구분되어져 있다. 만약, n을 만들 수 있는 방법이 여러 가지라면, b-a가 가장 큰

www.acmicpc.net

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

vector<bool> prime(1000001,true);

void era()
{
	for (long long i = 2; i*i <= 1000000; i++)
	{
		for (long long j = i * i; j <= 1000000; j += i)
		{
			prime[j] = false;
		}
	}
}

int main()
{
	era();
	cin.tie(NULL);
	cout.tie(NULL);
	ios_base::sync_with_stdio(false);
	while (1)
	{
		long long n = 0;
		cin >> n;
		if (n == 0)
			break;
		for (long long i = 2; i <= n; i++)
		{
			if ((prime[i] == true) && (prime[n - i] == true))
			{
				cout << n << " = " << i << " + " << n - i <<'\n';
				break;
			}
		}
	}
}

백준 1929 c++ 소수 구하기

현구구 — Fri, 26 Jan 2024 12:32:20 +0900

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

1929번: 소수 구하기

첫째 줄에 자연수 M과 N이 빈 칸을 사이에 두고 주어진다. (1 ≤ M ≤ N ≤ 1,000,000) M이상 N이하의 소수가 하나 이상 있는 입력만 주어진다.

www.acmicpc.net

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

vector<bool> prime;

void era(unsigned int m_i) {
	prime[1] = false;
	for (int i = 2; i*i <= m_i; i++)
	{
		for (int j = i * i; j <= m_i; j = j + i)
		{
			prime[j] = false;
		}
	}
}

int main()
{
	// 입력
	unsigned int n, m;
	cin >> n >> m;
	prime = vector<bool>(m + 1, true);
	era(m);
	for (int i = n; i <= m; i++)
	{
		if (prime[i])
			cout << i << '\n';
	}
}

백준 1978 c++ 소수 찾기

현구구 — Fri, 26 Jan 2024 12:23:06 +0900

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

1978번: 소수 찾기

첫 줄에 수의 개수 N이 주어진다. N은 100이하이다. 다음으로 N개의 수가 주어지는데 수는 1,000 이하의 자연수이다.

www.acmicpc.net

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

vector<bool> prime(1001, true);

void era(int num) {
	prime[1] = false;
	for (int i = 2; i*i <= num; i++)
	{
		for (int j = i * i; j <= num; j = j + i)
		{
			prime[j] = false;
		}
	}
}

int main()
{
	era(1000);
	// 입력
	int n;
	cin >> n;
	vector<int> arr;
	int ans = 0;
	for (int i = 0; i < n; i++)
	{
		int input;
		cin >> input;
		if (prime[input] == true)
		{
			ans++;
		}
	}
	cout << ans;
	
}

백준 2609 c++ 최대공약수와 최소공배수

현구구 — Thu, 25 Jan 2024 15:25:15 +0900

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

2609번: 최대공약수와 최소공배수

첫째 줄에는 입력으로 주어진 두 수의 최대공약수를, 둘째 줄에는 입력으로 주어진 두 수의 최소 공배수를 출력한다.

www.acmicpc.net

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

int gcd(int big, int small)
{
	while (big % small)
	{
		int tmp = big % small;
		big = small;
		small = tmp;
	}
	return small;
}

int lcm(int big,int small,int gcd_p)
{
	return big * small / gcd_p;
}

int main()
{
	int b, s;
	cin >> b >> s;
	int gcd_o = gcd(b, s);
	cout << gcd(b, s) <<'\n' << lcm(b, s, gcd_o);

}

백준 17425 c++ 약수의 합

현구구 — Thu, 25 Jan 2024 15:15:03 +0900

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

17425번: 약수의 합

두 자연수 A와 B가 있을 때, A = BC를 만족하는 자연수 C를 A의 약수라고 한다. 예를 들어, 2의 약수는 1, 2가 있고, 24의 약수는 1, 2, 3, 4, 6, 8, 12, 24가 있다. 자연수 A의 약수의 합은 A의 모든 약수를 더

www.acmicpc.net

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

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	
	vector<long long> g(1000001, 0);

	for (long long i = 1; i <= 1000000; i++)
	{
		for (long long j = i; j <= 1000000; j = j + i) // j는 i의 배수
		{
			g[j] = g[j] + i; //여기는 일단 f() 단계 j의 모든 약수의 합
		}
		g[i] = g[i - 1] + g[i]; // g[i] = g[i - 1] + f[i] 의 의미
	}

	int t;
	cin >> t;
	while (t--)
	{
		int n;
		cin >> n;
		cout << g[n]<<'\n';
	}
}

백준 17427 c++ 약수의 합 2

현구구 — Thu, 25 Jan 2024 14:12:02 +0900

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

17427번: 약수의 합 2

www.acmicpc.net

#include <iostream>
using namespace std;

int main()
{
	long long n;
	cin >> n;
	long long ans = 0;
	for (long long i = 1; i <= n; i++)
	{
		ans = ans + (n / i) * i;
	}
	cout << ans;
}

규칙성을 찾아야 하는 문제

백준 16926 c++ 배열 돌리기 1

현구구 — Tue, 23 Jan 2024 12:10:05 +0900

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

16926번: 배열 돌리기 1

크기가 N×M인 배열이 있을 때, 배열을 돌려보려고 한다. 배열은 다음과 같이 반시계 방향으로 돌려야 한다. A[1][1] ← A[1][2] ← A[1][3] ← A[1][4] ← A[1][5] ↓ ↑ A[2][1] A[2][2] ← A[2][3] ← A[2][4] A[2][5]

www.acmicpc.net

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

void rotate(int depth, vector<vector<int>>& inputArr, int row, int col)
{
	vector<vector<int>> tmp(row, vector<int>(col, 0));
	for (int k = 0; k < depth; k++)
	{
		int r1 = k;
		int c1 = k;
		int r2 = row - k - 1;
		int c2 = col - k - 1;
		//좌
		for (int i = r2 - 1; i >= r1; i--)
		{
			tmp[i + 1][c1] = inputArr[i][c1];
		}
		//하
		for (int i = c2 - 1; i >= c1; i--)
		{
			tmp[r2][i + 1] = inputArr[r2][i];
		}
		//우
		for (int i = r1 + 1; i <= r2; i++)
		{
			tmp[i - 1][c2] = inputArr[i][c2];
		}
		//상
		for (int i = c1 + 1; i <= c2; i++)
		{
			tmp[r1][i - 1] = inputArr[r1][i];
		}
	}
	inputArr = tmp;
}

int main()
{
	int n, m, r;
	cin >> n >> m >> r;
	vector<vector<int>> arr(n,vector<int>(m,0));
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cin >> arr[i][j];
		}
	}
	int minL = min(n, m);
	if (!(minL % 2 == 0)) // 2로 안나누어지면 return
		return 0;
	
	int cnt = minL / 2; //총 cnt 만큼의 묶음이 나옴
	
	while (r--)
	{
		rotate(cnt, arr, n, m);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cout << arr[i][j]<<' ';
		}
		cout << '\n';
	}


}

그냥 하드코딩을 상하좌우로 해주면 된다

백준 1037 c++ 약수

현구구 — Tue, 23 Jan 2024 10:36:28 +0900

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

1037번: 약수

첫째 줄에 N의 진짜 약수의 개수가 주어진다. 이 개수는 50보다 작거나 같은 자연수이다. 둘째 줄에는 N의 진짜 약수가 주어진다. 1,000,000보다 작거나 같고, 2보다 크거나 같은 자연수이고, 중복되

www.acmicpc.net

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

void sortArr(vector<long long> &inputarr)
{
	for (int i = 0; i < inputarr.size(); i++)
	{
		for (int j = 1; j < inputarr.size(); j++)
		{
			if (inputarr[j - 1] > inputarr[j]) //앞이 뒤보다 크다면
			{
				int temp = 0;//임시
				temp = inputarr[j - 1];
				inputarr[j - 1] = inputarr[j];
				inputarr[j] = temp;
			}
		}
	}
}

int main()
{
	int n = 0; //약수의 개수
	cin >> n;
	vector<long long> arr(n, 0);
	//배열 입력 받기
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}

	int ans; //정답
	//약수가 하나만 있을 경우
	if (n == 1)
	{
		ans = arr[0] * arr[0];
	}
	else //정렬 해야함
	{
		sortArr(arr);
		ans = arr[0] * arr[n - 1];
	}
	cout << ans;
}

배열을 정렬 후 약수 중 (가장 작은 수 * 가장 큰 수) = N이다.

백준 4375 c++ 1

현구구 — Mon, 22 Jan 2024 11:11:57 +0900

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

4375번: 1

2와 5로 나누어 떨어지지 않는 정수 n(1 ≤ n ≤ 10000)가 주어졌을 때, 각 자릿수가 모두 1로만 이루어진 n의 배수를 찾는 프로그램을 작성하시오.

www.acmicpc.net

x % n = (x % n) % n

#include <iostream>

using namespace std;

int main()
{
	int n;
	while (cin >> n)
	{
		int one = 1;
		long long ans = 1;
		while (1)
		{
			if (one % n == 0)
			{
				cout << ans << '\n';
				break;
			}
			else
			{
				ans++;
				one = one * 10 + 1;
				one = one % n;
			}
		}
	}
}

백준 2904 c++ 수학은 너무 쉬워

현구구 — Thu, 9 Mar 2023 23:21:50 +0900

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

2904번: 수학은 너무 쉬워

첫째 줄에 N이 주어진다. (1 ≤ N ≤ 100) 둘째 줄에는 종이에 적혀있는 수 N개가 주어진다. 수는 모두 1,000,000보다 작거나 같은 양의 정수이다.

www.acmicpc.net

문제

상근이의 할머니는 매우 유명한 수학자이다. 할머니는 매일 수학 문제로 상근이를 힘들게 한다. 할머니는 종이 N장에 숫자를 하나씩 쓴 다음 상근이에게 준다. 그 다음 상근이는 다음과 같이 문제를 풀어야 한다.

두 수 A와 B를 고르고, A를 나눌 수 있는 소수 X를 고른다. 그 다음, A를 지우고 A/X를 쓰고, B를 지우고 B×X를 쓴다.

상근이는 위의 행동을 무한히 반복할 수 있다. 할머니는 상근이가 만든 수를 보고 점수를 계산한다. 점수가 높을수록 할머니는 상근이에게 사탕을 많이 준다. 점수는 종이에 적혀있는 모든 수의 최대공약수이다.

상근이가 얻을 수 있는 가장 높은 점수를 구하는 프로그램을 작성하시오. 또, 그 점수를 얻으려면 최소 몇 번 해야 하는지도 구한다.

입력

첫째 줄에 N이 주어진다. (1 ≤ N ≤ 100) 둘째 줄에는 종이에 적혀있는 수 N개가 주어진다. 수는 모두 1,000,000보다 작거나 같은 양의 정수이다.

출력

첫째 줄에 상근이가 얻을 수 있는 가장 큰 점수와 최소 몇 번 만에 그 점수를 얻을 수 있는지를 출력한다.

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

using namespace std;

int N;
bool isPrime[1000001];//소수 판별
vector<int> prime;

void Era()
{
	memset(isPrime, true, sizeof(isPrime));//일단 다 true로
	isPrime[0] = false;
	isPrime[1] = false;
	for (int i = 2; i <= 1000000; i++)
	{
		for (int j = i+i; j <= 1000000; j = j+i)
		{
			isPrime[j] = false;
		}
	}
	for (int i = 2; i <= 1000000; i++)
	{
		if (isPrime[i])
			prime.push_back(i);
	}
}

int main()
{
	Era();//에라토스테네스의 체 소수판별
	cin >> N;
	vector<int> card(N,0);//입력 받을 카드

	//전체적으로 해당 소수가 사용된 횟수
	vector<int>allPrimeCnt(prime.size(), 0);
	//2중 배열 numPrimeCount[a][b] = 3 // a번쨰 수를 소인수분해 했을 때 소수 b가 3개 있음
	vector<vector<int>> numPrimeCount(N, vector<int>(prime.size(), 0));

	for (int i = 0; i < N; i++)
	{
		cin >> card[i];
	}

	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < prime.size(); j++)
		{
			while (card[i] % prime[j] == 0)//소수로 나누어 떨어지면
			{
				allPrimeCnt[j]++;//해당 소수는 사용되었으므로 증가
				numPrimeCount[i][j]++;//해당 카드에 사용된 소수 증가
				card[i] = card[i] / prime[j];
			}
		}
	}

	int score = 1;//최대 점수
	int moveCount = 0;//소수 이동 카운트
	for (int i = 0; i < prime.size(); i++)
	{
		if (allPrimeCnt[i] / N > 0)//만약 소수를 N카드에 모두 분배할 수 있다면
		{
			int need = allPrimeCnt[i] / N;
			score = score * pow(prime[i],need);

			for (int j = 0; j < N; j++)
			{
				if (numPrimeCount[j][i] < need)
				{
					moveCount = moveCount + (need - numPrimeCount[j][i]);
				}
			}
		}
	}

	cout << score << " " << moveCount;
}

백준 16954 c++ 움직이는 미로 탈출

현구구 — Sat, 4 Mar 2023 17:27:19 +0900

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

16954번: 움직이는 미로 탈출

욱제는 학교 숙제로 크기가 8×8인 체스판에서 탈출하는 게임을 만들었다. 체스판의 모든 칸은 빈 칸 또는 벽 중 하나이다. 욱제의 캐릭터는 가장 왼쪽 아랫 칸에 있고, 이 캐릭터는 가장 오른쪽

www.acmicpc.net

문제

욱제는 학교 숙제로 크기가 8×8인 체스판에서 탈출하는 게임을 만들었다. 체스판의 모든 칸은 빈 칸 또는 벽 중 하나이다. 욱제의 캐릭터는 가장 왼쪽 아랫 칸에 있고, 이 캐릭터는 가장 오른쪽 윗 칸으로 이동해야 한다.

이 게임의 특징은 벽이 움직인다는 점이다. 1초마다 모든 벽이 아래에 있는 행으로 한 칸씩 내려가고, 가장 아래에 있어서 아래에 행이 없다면 벽이 사라지게 된다. 욱제의 캐릭터는 1초에 인접한 한 칸 또는 대각선 방향으로 인접한 한 칸으로 이동하거나, 현재 위치에 서 있을 수 있다. 이동할 때는 빈 칸으로만 이동할 수 있다.

1초 동안 욱제의 캐릭터가 먼저 이동하고, 그 다음 벽이 이동한다. 벽이 캐릭터가 있는 칸으로 이동하면 더 이상 캐릭터는 이동할 수 없다.

욱제의 캐릭터가 가장 오른쪽 윗 칸으로 이동할 수 있는지 없는지 구해보자.

입력

8개 줄에 걸쳐서 체스판의 상태가 주어진다. '.'은 빈 칸, '#'는 벽이다. 가장 왼쪽 아랫칸은 항상 벽이 아니다.

출력

욱제의 캐릭터가 가장 오른쪽 윗 칸에 도착할 수 있으면 1, 없으면 0을 출력한다.

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

//상하좌우, 대각선, 제자리
int dx[9] = {1,-1,0,0,1,1,-1,-1,0};
int dy[9] = {0,0,1,-1,-1,1,-1,1,0};

char map[8][8];
bool visit[8][8][20];

struct group
{
	int row;
	int col;
	int count; // count에 따라 캐릭터가 이동하고 벽이 내려옴
};

void bfs()
{
	queue<group> q;
	q.push({7,0,0});
	visit[7][0][0] = true;
	while (!q.empty())
	{
		int nowX = q.front().row;
		int nowY = q.front().col;
		int nowCount = q.front().count;
		q.pop();
		for (int i = 0; i < 9; i++)
		{
			int nextX = nowX + dx[i];
			int nextY = nowY + dy[i];
			if (nextX == 0 && nextY == 7)//다음 칸이 목표 칸이면
			{
				cout << 1;
				return;
			}
			if (visit[nextX][nextY][nowCount + 1])
				continue;
			//범위 벗어나면 스킵
			if (nextX < 0 || nextX >= 8 || nextY < 0 || nextY >= 8)
				continue;
			//가려는 칸이 벽이라면 스킵
			if (map[nextX - nowCount][nextY] == '#' && nextX - nowCount >= 0)
				continue;
			//이동한다음 벽을 마주친다면
			if (map[nextX - nowCount - 1][nextY] == '#' && nextX - nowCount - 1 >= 0)
				continue;
			//위 조건들에 해당 안된다면
			visit[nextX][nextY][nowCount + 1] = true;
			q.push({ nextX, nextY, nowCount + 1 });
		}
	}
	cout << 0;
}

int main()
{
	for (int i = 0; i < 8; i++)
	{
		for (int j = 0; j < 8; j++)
		{
			cin >> map[i][j];
		}
	}

	bfs();
}

백준 16933 c++ 벽 부수고 이동하기 3

현구구 — Fri, 3 Mar 2023 11:25:40 +0900

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

16933번: 벽 부수고 이동하기 3

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 1,000), K(1 ≤ K ≤ 10)이 주어진다. 다음 N개의 줄에 M개의 숫자로 맵이 주어진다. (1, 1)과 (N, M)은 항상 0이라고 가정하자.

www.acmicpc.net

문제

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로로 이동하려 한다. 최단경로는 맵에서 가장 적은 개수의 칸을 지나는 경로를 말하는데, 이때 시작하는 칸과 끝나는 칸도 포함해서 센다. 이동하지 않고 같은 칸에 머물러있는 경우도 가능하다. 이 경우도 방문한 칸의 개수가 하나 늘어나는 것으로 생각해야 한다.

이번 문제에서는 낮과 밤이 번갈아가면서 등장한다. 가장 처음에 이동할 때는 낮이고, 한 번 이동할 때마다 낮과 밤이 바뀌게 된다. 이동하지 않고 같은 칸에 머무르는 경우에도 낮과 밤이 바뀌게 된다.

만약에 이동하는 도중에 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면, 벽을 K개 까지 부수고 이동하여도 된다. 단, 벽은 낮에만 부술 수 있다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

입력

출력

첫째 줄에 최단 거리를 출력한다. 불가능할 때는 -1을 출력한다.

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

int N, M, K;
int map[1001][1001];
bool visit[1001][1001][11];//row, col, 벽을 부순 횟수

int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,1,-1 };

int result = -1;

struct group
{
	int row;
	int col;
	int count;
	int destroy;
	int day;
};

void bfs()
{
	queue<group> q;
	q.push({ 0,0,1,0,0 });//day = 0 낮 / day = 1 밤
	visit[0][0][0] = true;//0,0까지 0번 벽을 뚫고 감
	while (!q.empty())
	{
		int nowX = q.front().row;//현재 행
		int nowY = q.front().col;//현재 열
		int nowCount = q.front().count;//현재 칸 까지 이동 카운트
		int nowDestroy = q.front().destroy;//현재까지 벽을 부순 횟수
		int nowDay = q.front().day;//0이면 낮 / 1이면 밤
		q.pop();

		if ((nowX == N - 1) && (nowY == M - 1))//목표 지점 도달
		{
			result = nowCount;
			return;
		}

		for (int i = 0; i < 4; i++)
		{
			int nextX = nowX + dx[i];
			int nextY = nowY + dy[i];
			if ((nextX < 0 || nextX >= N) || (nextY < 0 || nextY >= M))//다음 칸이 범위 벗어나면 스킵
				continue;

			//다음칸이 통로일 때
			if (map[nextX][nextY] == 0)
			{
				if (visit[nextX][nextY][nowDestroy] == false)//방문한적 없다면
				{
					visit[nextX][nextY][nowDestroy] = true;//방문처리
					if (nowDay == 0)//현재 낮이라면
						q.push({ nextX, nextY, nowCount + 1, nowDestroy, 1 });
					else//현재 밤이라면
						q.push({ nextX, nextY, nowCount + 1, nowDestroy, 0 });
				}
			}
			//다음칸이 벽일 때
			else if (map[nextX][nextY] == 1)
			{
				if (nowDestroy < K)//현재 벽 부순 횟수가 K보다 작을때만
				{
					if (visit[nextX][nextY][nowDestroy + 1] == false)//다음칸을 방문하지 않았다면
					{
						if (nowDay == 0)//현재 낮이라면
						{
							visit[nextX][nextY][nowDestroy + 1] = true;
							q.push({ nextX, nextY, nowCount + 1, nowDestroy + 1, 1 });
                            //다음칸으로 갈 때 밤으로 바뀌므로 1넣음
						}
						else//현재 밤이라면
						{
							q.push({ nowX,nowY,nowCount + 1,nowDestroy,0 });
                            //다음칸으로 갈 때 밤으로 바뀌므로 0넣음
						}
					}
				}
			}
		}
	}
}

int main()
{
	cin >> N >> M >> K;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			scanf("%1d", &map[i][j]); //공백이 없어도 숫자 하나씩만 입력받기
		}
	}

	bfs();

	cout << result;
}

백준 14442 c++ 벽 부수고 이동하기 2

현구구 — Sun, 19 Feb 2023 01:36:38 +0900

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

14442번: 벽 부수고 이동하기 2

www.acmicpc.net

문제

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로로 이동하려 한다. 최단경로는 맵에서 가장 적은 개수의 칸을 지나는 경로를 말하는데, 이때 시작하는 칸과 끝나는 칸도 포함해서 센다.

만약에 이동하는 도중에 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면, 벽을 K개 까지 부수고 이동하여도 된다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

입력

출력

첫째 줄에 최단 거리를 출력한다. 불가능할 때는 -1을 출력한다.

#include<iostream>
#include<string>
#include<queue>
using namespace std;
 
int N, M, K;
int map[1001][1001];
int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,1,-1 };
bool visit[1001][1001][10];

int result = -1;

struct group
{
	int row;
	int col;
	int count;
	int destroy;
};

void bfs()
{
	queue<group> q;
	q.push({ 0,0,1,0 });
	visit[0][0][0] = true;//0,0까지 0번 벽을 뚫고 감
	while (!q.empty())
	{
		int nowX = q.front().row;
		int nowY = q.front().col;
		int nowCount = q.front().count;
		int nowDestroy = q.front().destroy;
		q.pop();

		if ((nowX == N - 1) && (nowY == M - 1))//목표 지점 도달
		{
			result = nowCount;
			return;
		}

		for (int i = 0; i < 4; i++)
		{
			int nextX = nowX + dx[i];
			int nextY = nowY + dy[i];
			if ((nextX < 0 || nextX >= N) || (nextY < 0 || nextY >= M))//다음 칸이 범위 벗어나면 스킵
				continue;
			if (visit[nextX][nextY][nowDestroy] == true)//다음 칸까지 nowDestroy만큼 뚫고 간 적 있다면 스킵
				continue;
			if (map[nextX][nextY] == 0)//다음이 통로라면
			{
				visit[nextX][nextY][nowDestroy] = true;
				q.push({ nextX,nextY,nowCount + 1, nowDestroy });
			}
			if (map[nextX][nextY] == 1 && nowDestroy<K)//다음 칸이 벽이고 벽을 K만큼 안부쉈다면
			{
				visit[nextX][nextY][nowDestroy + 1] = true;
				q.push({ nextX,nextY,nowCount + 1, nowDestroy + 1 });
			}
		}
	}
}

int main()
{
	cin >> N >> M >> K;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			scanf("%1d", &map[i][j]); //공백이 없어도 숫자 하나씩만 입력받기
		}
	}

	bfs();

	cout << result;
}

백준 16946 c++ 벽 부수고 이동하기 4

현구구 — Wed, 15 Feb 2023 22:26:13 +0900

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

16946번: 벽 부수고 이동하기 4

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 한 칸에서 다른 칸으로 이동하려면, 두 칸이 인접해야 한다. 두 칸이

www.acmicpc.net

문제

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 한 칸에서 다른 칸으로 이동하려면, 두 칸이 인접해야 한다. 두 칸이 변을 공유할 때, 인접하다고 한다.

각각의 벽에 대해서 다음을 구해보려고 한다.

벽을 부수고 이동할 수 있는 곳으로 변경한다.
그 위치에서 이동할 수 있는 칸의 개수를 세어본다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

입력

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 1,000)이 주어진다. 다음 N개의 줄에 M개의 숫자로 맵이 주어진다.

출력

맵의 형태로 정답을 출력한다. 원래 빈 칸인 곳은 0을 출력하고, 벽인 곳은 이동할 수 있는 칸의 개수를 10으로 나눈 나머지를 출력한다.

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

int N, M;
int map[1001][1001];
int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,1,-1 };
bool visit[1001][1001];

void bfs(int row, int col)
{
	queue<pair<int, int>> q;
	vector<pair<int, int>> v;
	q.push(make_pair(row,col));
	visit[row][col] = true;
	int result = 1;
	while (!q.empty())
	{
		int nowX = q.front().first;
		int nowY = q.front().second;
		q.pop();

		for (int i = 0; i < 4; i++)
		{
			int nextX = nowX + dx[i];
			int nextY = nowY + dy[i];
			if ((nextX < 0 || nextX >= N) || (nextY < 0 || nextY >= M))//범위 벗어나면 스킵
				continue;

			if (map[nextX][nextY] == 0 && visit[nextX][nextY] == false) //다음 칸이 방문한 적 없는 통로이면
			{
				q.push(make_pair(nextX, nextY));
				visit[nextX][nextY] = true;
				result++;
			}
			if (map[nextX][nextY] != 0 && visit[nextX][nextY] == false)//다음 칸이 방문한 적 없는 벽이라면
			{
				v.push_back(make_pair(nextX, nextY));
				visit[nextX][nextY] = true;
			}
		}
	}
	for (int i = 0; i < v.size(); i++)
	{
		map[v[i].first][v[i].second] += result;
		visit[v[i].first][v[i].second] = false;
	}
}

int main()
{
	//입력
	cin >> N >> M;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			scanf("%1d", &map[i][j]); //공백이 없어도 숫자 하나씩만 입력받기
		}
	}

	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (map[i][j] != 0)//현재칸이 통로가 아니면 스킵
				continue;
			if (visit[i][j])//현재칸이 0이지만 방문했다면 스킵
				continue;
			bfs(i, j); //0이고 방문안한 곳에서 bfs 실행
		}
	}
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			cout << map[i][j] % 10;
		}
		cout << '\n';
	}
}

1. map을 탐색하며 0인 부분에서 bfs실행

2. bfs실행하여 상하좌우 탐색하며

2-1 => 0을 만났을 때 count++

2-2 => 1을 만났을 때 vector안에 벽 정보를 넣음

3. bfs함수가 끝날 때 bfs에서 탐색한 0들에 인접한 벽에 대해 (2-2에서 vector에 넣었던 벽들) 지금까지 count값을 더해준다.

백준 2206 c++ 벽 부수고 이동하기

현구구 — Sat, 11 Feb 2023 15:34:28 +0900

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

2206번: 벽 부수고 이동하기

N×M의 행렬로 표현되는 맵이 있다. 맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다. 당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로

www.acmicpc.net

문제

만약에 이동하는 도중에 한 개의 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면, 벽을 한 개 까지 부수고 이동하여도 된다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

입력

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 1,000)이 주어진다. 다음 N개의 줄에 M개의 숫자로 맵이 주어진다. (1, 1)과 (N, M)은 항상 0이라고 가정하자.

출력

첫째 줄에 최단 거리를 출력한다. 불가능할 때는 -1을 출력한다.

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

int N, M;
int map[1001][1001];
int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,1,-1 };
bool visit[1001][1001][2];

int result = -1;

struct group
{
	int row;
	int col;
	int count;
	int destroy;
};

void bfs()
{
	queue<group> q;
	q.push({0,0,1,0});
	visit[0][0][0] = true;
	while (!q.empty())
	{
		int nowX = q.front().row;
		int nowY = q.front().col;
		int nowCount = q.front().count;
		int nowDestroy = q.front().destroy;
		q.pop();

		if ((nowX == N-1) && (nowY == M-1))//목표 지점 도달
		{
			result = nowCount;
			return;
		}

		for (int i = 0; i < 4; i++)
		{
			int nextX = nowX + dx[i];
			int nextY = nowY + dy[i];
			if ((nextX < 0 || nextX >= N) || (nextY < 0 || nextY >= M))//범위 벗어나면 스킵
				continue;
			if (map[nextX][nextY] == 1 && nowDestroy == 0)//다음 칸이 벽이고 벽을 부순적이 없다면
			{
				visit[nextX][nextY][nowDestroy+1] = true;
				q.push({ nextX,nextY,nowCount + 1, nowDestroy + 1 });
			}
			if(map[nextX][nextY] == 0 && !visit[nextX][nextY][nowDestroy])//다음이 통로고 간 적 없다면
			{
				visit[nextX][nextY][nowDestroy] = true;
				q.push({ nextX,nextY,nowCount + 1, nowDestroy });
			}
		}
	}
}

int main()
{
	cin >> N >> M;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			scanf("%1d", &map[i][j]); //공백이 없어도 숫자 하나씩만 입력받기
		}
	}

	bfs();

	cout << result;
}

백준 12886 c++ 돌 그룹

현구구 — Fri, 10 Feb 2023 11:43:16 +0900

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

12886번: 돌 그룹

오늘 강호는 돌을 이용해 재미있는 게임을 하려고 한다. 먼저, 돌은 세 개의 그룹으로 나누어져 있으며 각각의 그룹에는 돌이 A, B, C개가 있다. 강호는 모든 그룹에 있는 돌의 개수를 같게 만들려

www.acmicpc.net

문제

오늘 강호는 돌을 이용해 재미있는 게임을 하려고 한다. 먼저, 돌은 세 개의 그룹으로 나누어져 있으며 각각의 그룹에는 돌이 A, B, C개가 있다. 강호는 모든 그룹에 있는 돌의 개수를 같게 만들려고 한다.

강호는 돌을 단계별로 움직이며, 각 단계는 다음과 같이 이루어져 있다.

크기가 같지 않은 두 그룹을 고른다. 그 다음, 돌의 개수가 작은 쪽을 X, 큰 쪽을 Y라고 정한다. 그 다음, X에 있는 돌의 개수를 X+X개로, Y에 있는 돌의 개수를 Y-X개로 만든다.

A, B, C가 주어졌을 때, 강호가 돌을 같은 개수로 만들 수 있으면 1을, 아니면 0을 출력하는 프로그램을 작성하시오.

입력

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

출력

돌을 같은 개수로 만들 수 있으면 1을, 아니면 0을 출력한다.

틀린코드(메모리 초과)

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

int a, b, c;
int result = 0;
bool visit[1501][1501][1501];

struct group
{
	int A;
	int B;
	int C;
};//먼저 그룹 3개를 만듬

void pick(int& small, int& big)
{
	if (small == big)
		return;
	if (small > big)
	{
		int tmp = big;
		big = small;
		small = tmp;
	}
	big = big - small;
	small = small * 2;

}

void bfs()
{
	queue<group> q;
	q.push({ a,b,c });
	visit[a][b][c] = true;
	while (!q.empty())
	{
		int nowA = q.front().A;
		int nowB = q.front().B;
		int nowC = q.front().C;//3가지 현재 그룹 지정
		q.pop();
		if ((nowA == nowB) && (nowA == nowC))// 3개 같으면 리턴
		{
			result = 1;
			return;
		}
		for (int i = 0; i < 3; i++)
		{
			int nextA = nowA;
			int nextB = nowB;
			int nextC = nowC;
			if (i == 0)
			{
				pick(nextA, nextB);
				if (visit[nextA][nextB][nextC])
					continue;
				cout << nextA << nextB << nextC << '\n';
				visit[nextA][nextB][nextC] = true;
				q.push({ nextA, nextB, nextC });
			}
			if (i == 1)
			{
				pick(nextA, nextC);
				if (visit[nextA][nextB][nextC])
					continue;
				cout << nextA << nextB << nextC << '\n';
				visit[nextA][nextB][nextC] = true;
				q.push({ nextA, nextB, nextC });
			}
			if (i == 2)
			{
				pick(nextB, nextC);
				if (visit[nextA][nextB][nextC])
					continue;
				cout << nextA << nextB << nextC << '\n';
				visit[nextA][nextB][nextC] = true;
				q.push({ nextA, nextB, nextC });
			}
		}
	}
	return;
}

int main()
{
	cin >> a >> b >> c;
	bfs();
	cout << result;
}

맞은 코드

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

int a, b, c;
int result = 0;
bool visit[1501][1501];
int sum;

struct group
{
	int A;
	int B;
};//2개만 만들어도 됨

void pick(int& small, int& big)
{
	if (small == big)
		return;
	if (small > big)
	{
		int tmp = big;
		big = small;
		small = tmp;
	}
	big = big - small;
	small = small * 2;

}

void bfs()
{
	queue<group> q;
	q.push({ a,b });
	visit[a][b] = true;
	while (!q.empty())
	{
		int nowA = q.front().A;
		int nowB = q.front().B;//3가지 현재 그룹 지정 // C는 자동 배정 sum - a - b
		q.pop();
		if ((nowA == nowB) && (nowA == sum-nowA-nowB))// 3개 같으면 리턴
		{
			result = 1;
			return;
		}
		for (int i = 0; i < 3; i++)
		{
			int nextA = nowA;
			int nextB = nowB;
			int nextC = sum - nowA - nowB;
			if (i == 0)
			{
				pick(nextA, nextB);
				if (visit[nextA][nextB])
					continue;
				visit[nextA][nextB] = true;
				q.push({ nextA, nextB });
			}
			if (i == 1)
			{
				pick(nextA, nextC);
				if (visit[nextA][nextC])
					continue;
				visit[nextA][nextC] = true;
				q.push({ nextA, nextC });
			}
			if (i == 2)
			{
				pick(nextB, nextC);
				if (visit[nextB][nextC])
					continue;
				visit[nextB][nextC] = true;
				q.push({ nextB, nextC });
			}
		}
	}
	return;
}

int main()
{
	cin >> a >> b >> c;
	sum = a + b + c;
	bfs();
	cout << result;
}

틀린코드에서는 struct를 활용하여 큐에 변수 3개를 넣었고, A,B,C각각 체크?방문을 기록하는 bool형 배열 역시 3차원으로 체크하였다보니 메모리초과가 나서 틀렸다.

맞은 코드드에서는 3개의 그룹 중 2개의 값이 정해지면 나머지 하나는 자동적으로 sum - a - b로 정해진다는 것을 이용하여 struct의 변수 개수를 줄이고 visit 배열 역시 2차원으로 줄여 메모리를 줄였다.

백준 14502 c++ 연구소

현구구 — Thu, 9 Feb 2023 23:21:39 +0900

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

14502번: 연구소

인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다. 연구소는 크

www.acmicpc.net

문제

인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다.

연구소는 크기가 N×M인 직사각형으로 나타낼 수 있으며, 직사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는 빈 칸, 벽으로 이루어져 있으며, 벽은 칸 하나를 가득 차지한다.

일부 칸은 바이러스가 존재하며, 이 바이러스는 상하좌우로 인접한 빈 칸으로 모두 퍼져나갈 수 있다. 새로 세울 수 있는 벽의 개수는 3개이며, 꼭 3개를 세워야 한다.

예를 들어, 아래와 같이 연구소가 생긴 경우를 살펴보자.

2 0 0 0 1 1 0
0 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

이때, 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 곳이다. 아무런 벽을 세우지 않는다면, 바이러스는 모든 빈 칸으로 퍼져나갈 수 있다.

2행 1열, 1행 2열, 4행 6열에 벽을 세운다면 지도의 모양은 아래와 같아지게 된다.

2 1 0 0 1 1 0
1 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 1 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

바이러스가 퍼진 뒤의 모습은 아래와 같아진다.

2 1 0 0 1 1 2
1 0 1 0 1 2 2
0 1 1 0 1 2 2
0 1 0 0 0 1 2
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

벽을 3개 세운 뒤, 바이러스가 퍼질 수 없는 곳을 안전 영역이라고 한다. 위의 지도에서 안전 영역의 크기는 27이다.

연구소의 지도가 주어졌을 때 얻을 수 있는 안전 영역 크기의 최댓값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 지도의 세로 크기 N과 가로 크기 M이 주어진다. (3 ≤ N, M ≤ 8)

둘째 줄부터 N개의 줄에 지도의 모양이 주어진다. 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 위치이다. 2의 개수는 2보다 크거나 같고, 10보다 작거나 같은 자연수이다.

빈 칸의 개수는 3개 이상이다.

출력

첫째 줄에 얻을 수 있는 안전 영역의 최대 크기를 출력한다.

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

int N, M;
int map[8][8];

int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,1,-1 };



int bfs()//바이러스 퍼지게 하는거
{
	queue<pair<int, int>> q;
	int copyMap[8][8];
	//맵 카피
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			copyMap[i][j] = map[i][j];
		}
	}

	//바이러스의 처음 위치 찾아서 q에 넣자
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (map[i][j] == 2)
			{
				q.push(make_pair(i, j));
			}
		}
	}
	while (!q.empty())
	{
		int nowX = q.front().first;
		int nowY = q.front().second;
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			int nextX = nowX + dx[i];
			int nextY = nowY + dy[i];
			if ((nextX < 0 || nextX >= N) || (nextY < 0 || nextY >= M))//범위 벗어났으면 continue
				continue;
			if (copyMap[nextX][nextY] == 0)//만약 바이러스 인접 칸이 0이라면 해당칸을 바이러스로 바꾸고 queue에 넣자
			{
				copyMap[nextX][nextY] = 2;
				q.push(make_pair(nextX, nextY));
			}
		}
	}
	int count = 0;
	//반복문 끝나면 0개수 세기
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (copyMap[i][j] == 0)
				count++;
		}
	}
	return count;
}

int result = 0;

void dfs(int count)
{
	if (count == 3)//3칸 다 채움
	{
		result = max(result, bfs());
		return;
	}
	
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (map[i][j] == 0)
			{
				map[i][j] = 1;
				dfs(count + 1);
				map[i][j] = 0;
			}
		}
	}
	return;
}

int main()
{
	cin >> N >> M;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			cin >> map[i][j];
		}
	}
	dfs(0);
	cout << result;
}

백준 9019 c++ DSLR

현구구 — Wed, 8 Feb 2023 14:55:16 +0900

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

9019번: DSLR

네 개의 명령어 D, S, L, R 을 이용하는 간단한 계산기가 있다. 이 계산기에는 레지스터가 하나 있는데, 이 레지스터에는 0 이상 10,000 미만의 십진수를 저장할 수 있다. 각 명령어는 이 레지스터에

www.acmicpc.net

문제

네 개의 명령어 D, S, L, R 을 이용하는 간단한 계산기가 있다. 이 계산기에는 레지스터가 하나 있는데, 이 레지스터에는 0 이상 10,000 미만의 십진수를 저장할 수 있다. 각 명령어는 이 레지스터에 저장된 n을 다음과 같이 변환한다. n의 네 자릿수를 d1, d2, d3, d4라고 하자(즉 n = ((d1 × 10 + d2) × 10 + d3) × 10 + d4라고 하자)

D: D 는 n을 두 배로 바꾼다. 결과 값이 9999 보다 큰 경우에는 10000 으로 나눈 나머지를 취한다. 그 결과 값(2n mod 10000)을 레지스터에 저장한다.
S: S 는 n에서 1 을 뺀 결과 n-1을 레지스터에 저장한다. n이 0 이라면 9999 가 대신 레지스터에 저장된다.
L: L 은 n의 각 자릿수를 왼편으로 회전시켜 그 결과를 레지스터에 저장한다. 이 연산이 끝나면 레지스터에 저장된 네 자릿수는 왼편부터 d2, d3, d4, d1이 된다.
R: R 은 n의 각 자릿수를 오른편으로 회전시켜 그 결과를 레지스터에 저장한다. 이 연산이 끝나면 레지스터에 저장된 네 자릿수는 왼편부터 d4, d1, d2, d3이 된다.

위에서 언급한 것처럼, L 과 R 명령어는 십진 자릿수를 가정하고 연산을 수행한다. 예를 들어서 n = 1234 라면 여기에 L 을 적용하면 2341 이 되고 R 을 적용하면 4123 이 된다.

여러분이 작성할 프로그램은 주어진 서로 다른 두 정수 A와 B(A ≠ B)에 대하여 A를 B로 바꾸는 최소한의 명령어를 생성하는 프로그램이다. 예를 들어서 A = 1234, B = 3412 라면 다음과 같이 두 개의 명령어를 적용하면 A를 B로 변환할 수 있다.

1234 →L 2341 →L 3412
1234 →R 4123 →R 3412

따라서 여러분의 프로그램은 이 경우에 LL 이나 RR 을 출력해야 한다.

n의 자릿수로 0 이 포함된 경우에 주의해야 한다. 예를 들어서 1000 에 L 을 적용하면 0001 이 되므로 결과는 1 이 된다. 그러나 R 을 적용하면 0100 이 되므로 결과는 100 이 된다.

입력

프로그램 입력은 T 개의 테스트 케이스로 구성된다. 테스트 케이스 개수 T 는 입력의 첫 줄에 주어진다. 각 테스트 케이스로는 두 개의 정수 A와 B(A ≠ B)가 공백으로 분리되어 차례로 주어지는데 A는 레지스터의 초기 값을 나타내고 B는 최종 값을 나타낸다. A 와 B는 모두 0 이상 10,000 미만이다.

출력

A에서 B로 변환하기 위해 필요한 최소한의 명령어 나열을 출력한다. 가능한 명령어 나열이 여러가지면, 아무거나 출력한다.

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

bool visit[10001];


int D(int num)
{
	num = num * 2;
	if (num > 9999)
	{
		return num % 10000;
	}
	else
		return num;
}

int S(int num)
{
	if (num == 0)
	{
		return 9999;
	}
	else
		return num - 1;
}

int L(int num)
{
	return (num % 1000) * 10 + (num / 1000);
}

int R(int num)
{
	return num / 10 + (num % 10) * 1000;

}

void bfs(int start, int target)
{
	queue<pair<int,string>> q; //현재 숫자, 현재 숫자에 오기까지 과정
	q.push(make_pair(start,""));
	visit[start] = true;
	while (!q.empty())
	{
		int root = q.front().first;
		string str = q.front().second;

		q.pop();
		if (root == target)
		{
			cout << str <<'\n';
			return;
		}
		for (int i = 0; i < 4; i++)
		{
			int now = root;
			if (i == 0)
			{
				int next = D(now);
				if (visit[next])
					continue;
				q.push(make_pair(next,str + "D"));
				visit[next] = true;
			}
			if (i == 1)
			{
				int next = S(now);
				if (visit[next])
					continue;
				q.push(make_pair(next, str + "S"));
				visit[next] = true;
			}
			if (i == 2)
			{
				int next = L(now);
				if (visit[next])
					continue;
				q.push(make_pair(next, str + "L"));
				visit[next] = true;
			}
			if (i == 3)
			{
				int next = R(now);
				if (visit[next])
					continue;
				q.push(make_pair(next, str + "R"));
				visit[next] = true;
			}
		}
	}
	return;
}

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

	int T;
	cin >> T;
	while (T--)
	{
		int start, target;
		cin >> start >> target;
		memset(visit, false, sizeof(visit));
		bfs(start, target);
	}
}

백준 16948 c++ 데스 나이트

현구구 — Tue, 7 Feb 2023 11:04:10 +0900

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

16948번: 데스 나이트

게임을 좋아하는 큐브러버는 체스에서 사용할 새로운 말 "데스 나이트"를 만들었다. 데스 나이트가 있는 곳이 (r, c)라면, (r-2, c-1), (r-2, c+1), (r, c-2), (r, c+2), (r+2, c-1), (r+2, c+1)로 이동할 수 있다. 크

www.acmicpc.net

문제

게임을 좋아하는 큐브러버는 체스에서 사용할 새로운 말 "데스 나이트"를 만들었다. 데스 나이트가 있는 곳이 (r, c)라면, (r-2, c-1), (r-2, c+1), (r, c-2), (r, c+2), (r+2, c-1), (r+2, c+1)로 이동할 수 있다.

크기가 N×N인 체스판과 두 칸 (r1, c1), (r2, c2)가 주어진다. 데스 나이트가 (r1, c1)에서 (r2, c2)로 이동하는 최소 이동 횟수를 구해보자. 체스판의 행과 열은 0번부터 시작한다.

데스 나이트는 체스판 밖으로 벗어날 수 없다.

입력

첫째 줄에 체스판의 크기 N(5 ≤ N ≤ 200)이 주어진다. 둘째 줄에 r1, c1, r2, c2가 주어진다.

출력

첫째 줄에 데스 나이트가 (r1, c1)에서 (r2, c2)로 이동하는 최소 이동 횟수를 출력한다. 이동할 수 없는 경우에는 -1을 출력한다.

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

int N;
int r1, c1, r2, c2;
int visit[200][200];
int dx[] = { -2,-2,0,0,2,2 };
int dy[] = { -1,1,-2,2,-1,1 };
bool found;

void bfs()
{
	queue<pair<int, int>>q;
	q.push(make_pair(r1, c1));

	while (!q.empty())
	{
		int nowR = q.front().first;
		int nowC = q.front().second;
		q.pop();
		int count = visit[nowR][nowC] + 1;

		for (int i = 0; i < 6; i++)
		{
			int nextR = nowR + dx[i];
			int nextC = nowC + dy[i];
			if ((nextR < 0 || nextR >= N) || (nextC < 0 || nextC >= N))//범위 밖이면 스킵
				continue;
			if (visit[nextR][nextC] != 0)//이미 차있으면
				continue;
			if (nextR == r2 && nextC == c2)//다음이 답이면?
			{
				found = true;
				visit[r2][c2] = count;
				return;
			}
			visit[nextR][nextC] = count;
			q.push(make_pair(nextR, nextC));
		}
	}
	return;
}

int main()
{
	cin >> N;
	cin >> r1 >> c1 >> r2 >> c2;
	bfs();
	if (found == true)
		cout << visit[r2][c2];
	else
		cout << -1;
}

백준 16928 c++ 뱀과 사다리 게임

현구구 — Mon, 6 Feb 2023 10:40:17 +0900

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

16928번: 뱀과 사다리 게임

첫째 줄에 게임판에 있는 사다리의 수 N(1 ≤ N ≤ 15)과 뱀의 수 M(1 ≤ M ≤ 15)이 주어진다. 둘째 줄부터 N개의 줄에는 사다리의 정보를 의미하는 x, y (x < y)가 주어진다. x번 칸에 도착하면, y번 칸으

www.acmicpc.net

문제

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

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

게임은 정육면체 주사위를 사용하며, 주사위의 각 면에는 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번 칸에 도착하기 위해 주사위를 최소 몇 번 굴려야 하는지 출력한다.

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

int map[107];
bool visit[107];

int L;
int S;

int result;
int ladder[107];
int snake[107];

void bfs()
{
	queue<pair<int,int>> q;
	q.push(make_pair(1, 0)); //첫 칸은 1이고 이동횟수는 0
	visit[1] = true;
	while (!q.empty())
	{
		int start = q.front().first;
		int count = q.front().second;
		q.pop();
		if (start == 100)//시작 칸이 100이면 break
		{
			result = count;
			break;
		}
		for (int i = 1; i <= 6; i++)
		{
			int next = start + i;
			if(ladder[next]!=0)//만약 해당칸에 사다리가 있으면
			{
				next = ladder[next];
			}
			if (snake[next] != 0)//해당칸에 뱀이 있으면
			{
				next = snake[next];
			}
			//다음 칸이 지나간 칸이면 패스
			if (visit[next] == true)
				continue;
			if (next > 100)//다음칸이 100보다 커도 패스
				continue;
			visit[next] = true;
			q.push(make_pair(next,count+1));
		}
	}
}

int main()
{
	//입력
	cin >> L >> S;
	for (int i = 0; i < L; i++)
	{
		int a, b;
		cin >> a >> b;
		ladder[a] = b;
	}
	for (int i = 0; i < S; i++)
	{
		int a, b;
		cin >> a >> b;
		snake[a] = b;
	}
	bfs();
	cout << result;
}

백준 12100 c++ 2048(Easy)

현구구 — Sun, 5 Feb 2023 23:04:22 +0900

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

12100번: 2048 (Easy)

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2

www.acmicpc.net

문제

2048 게임은 4×4 크기의 보드에서 혼자 즐기는 재미있는 게임이다. 이 링크를 누르면 게임을 해볼 수 있다.

이 게임에서 한 번의 이동은 보드 위에 있는 전체 블록을 상하좌우 네 방향 중 하나로 이동시키는 것이다. 이때, 같은 값을 갖는 두 블록이 충돌하면 두 블록은 하나로 합쳐지게 된다. 한 번의 이동에서 이미 합쳐진 블록은 또 다른 블록과 다시 합쳐질 수 없다. (실제 게임에서는 이동을 한 번 할 때마다 블록이 추가되지만, 이 문제에서 블록이 추가되는 경우는 없다)

<그림 1>의 경우에서 위로 블록을 이동시키면 <그림 2>의 상태가 된다. 여기서, 왼쪽으로 블록을 이동시키면 <그림 3>의 상태가 된다.

<그림 4>의 상태에서 블록을 오른쪽으로 이동시키면 <그림 5>가 되고, 여기서 다시 위로 블록을 이동시키면 <그림 6>이 된다. 여기서 오른쪽으로 블록을 이동시켜 <그림 7>을 만들 수 있다.

<그림 8>의 상태에서 왼쪽으로 블록을 옮기면 어떻게 될까? 2가 충돌하기 때문에, 4로 합쳐지게 되고 <그림 9>의 상태가 된다.

<그림 10>에서 위로 블록을 이동시키면 <그림 11>의 상태가 된다.

<그림 12>의 경우에 위로 블록을 이동시키면 <그림 13>의 상태가 되는데, 그 이유는 한 번의 이동에서 이미 합쳐진 블록은 또 합쳐질 수 없기 때문이다.

마지막으로, 똑같은 수가 세 개가 있는 경우에는 이동하려고 하는 쪽의 칸이 먼저 합쳐진다. 예를 들어, 위로 이동시키는 경우에는 위쪽에 있는 블록이 먼저 합쳐지게 된다. <그림 14>의 경우에 위로 이동하면 <그림 15>를 만든다.

이 문제에서 다루는 2048 게임은 보드의 크기가 N×N 이다. 보드의 크기와 보드판의 블록 상태가 주어졌을 때, 최대 5번 이동해서 만들 수 있는 가장 큰 블록의 값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2보다 크거나 같고, 1024보다 작거나 같은 2의 제곱꼴이다. 블록은 적어도 하나 주어진다.

출력

최대 5번 이동시켜서 얻을 수 있는 가장 큰 블록을 출력한다.

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int N = 0;
int map[20][20];
int result;

string dir[4] = { "up", "down", "left", "right" };//방향

void move(int arr[][20], string type)//type에 따라 이동을 다른 방식으로 진행
{
	if (type == "up")
	{
		for (int i = 0; i < N - 1; i++)
		{
			for (int j = 0; j < N; j++)
			{
				bool Check = false;
				if (arr[i][j] == 0)//본인이 0(통로)일 경우
				{
					int k = i + 1;//k는 본인의 아래 칸
					while (k <= N - 1)//k가 범위 내에 있을 동안
					{
						if (arr[k][j] != 0)//본인의 아래인 k도 0(통로)가 아니면 check를 true로 하고 break
						{
							Check = true;
							break;
						}
						k++;//k도 0 이라면 1 증가해서 한칸 더 아래로
					}

					if (Check == true)//check가 true일 때 처음 0의 위치까지 arr[k][j]를 위로 올린다.
					{
						arr[i][j] = arr[k][j];
						arr[k][j] = 0;
					}
				}
			}
		}
	}
	if (type == "down")
	{
		for (int i = N - 1; i > 0; i--)
		{
			for (int j = 0; j < N; j++)
			{
				bool Check = false;
				if (arr[i][j] == 0)
				{
					int k = i - 1;
					while (k >= 0)
					{
						if (arr[k][j] != 0)
						{
							Check = true;
							break;
						}
						k--;
					}
					if (Check == true)
					{
						arr[i][j] = arr[k][j];
						arr[k][j] = 0;
					}
				}
			}
		}
	}
	if (type == "left")
	{
		for (int i = 0; i < N; i++)
		{
			for (int j = 0; j < N - 1; j++)
			{
				bool Check = false;
				if (arr[i][j] == 0)
				{
					int k = j + 1;
					while (k <= N - 1)
					{
						if (arr[i][k] != 0)
						{
							Check = true;
							break;
						}
						k++;
					}
					if (Check == true)
					{
						arr[i][j] = arr[i][k];
						arr[i][k] = 0;
					}
				}
			}
		}
	}
	if (type == "right")
	{
		for (int i = 0; i < N; i++)
		{
			for (int j = N - 1; j > 0; j--)
			{
				bool Check = false;
				if (arr[i][j] == 0)
				{
					int k = j - 1;
					while (k >= 0)
					{
						if (arr[i][k] != 0)
						{
							Check = true;
							break;
						}
						k--;
					}
					if (Check == true)
					{
						arr[i][j] = arr[i][k];
						arr[i][k] = 0;
					}
				}
			}
		}
	}

}

void sum(int arr[][20], string type)
{
	if (type == "up")
	{
		for (int i = 1; i < N; i++)
		{
			for (int j = 0; j < N; j++)
			{
				if (arr[i][j] == arr[i-1][j])//만약 본인과 한칸 위의 숫자가 같다면
				{
					arr[i-1][j] = arr[i-1][j] + arr[i][j];//자신을 한칸 위의 숫자에 더하고
					arr[i][j] = 0;//자신은 0으로
				}
			}
		}
	}
	if (type == "down")
	{
		for (int i = N-2; i >= 0 ; i--)
		{
			for (int j = 0; j < N; j++)
			{
				if (arr[i][j] == arr[i + 1][j])
				{
					arr[i + 1][j] = arr[i + 1][j] + arr[i][j];
					arr[i][j] = 0;
				}
			}
		}
	}
	if (type == "left")
	{
		for (int i = 0; i < N; i++)
		{
			for (int j = 1; j < N; j++)
			{
				if (arr[i][j] == arr[i][j - 1])
				{
					arr[i][j - 1] = arr[i][j - 1] + arr[i][j];
					arr[i][j] = 0;
				}
			}
		}
	}
	if (type == "right")
	{
		for (int i = 0; i < N; i++)
		{
			for (int j = N-2; j >= 0; j--)
			{
				if (arr[i][j] == arr[i][j + 1])
				{
					arr[i][j + 1] = arr[i][j + 1] + arr[i][j];
					arr[i][j] = 0;
				}
			}
		}
	}
}


void dfs(int count, int root[][20])
{
	//종료 시점
	if (count == 5)
	{
		for (int i = 0; i < N; i++)
		{
			for (int j = 0; j < N; j++)
			{
				result = max(result, root[i][j]);//한 칸씩 돌며 최대값 갱신
			}
		}
		return;
	}

	for (int i = 0; i < 4; i++)
	{
		//부모 맵 지정(복사)
		int parentMap[20][20];
        //부모 맵 1개를 토대로 4가지 방향 이동 move를 시킬 것이기 때문에 미리 저장해둔다.
		for (int k = 0; k < N; k++)
		{
			for (int j = 0; j < N; j++)
			{
				parentMap[k][j] = root[k][j];
			}
		}
		//이동
		move(parentMap, dir[i]);
        //합치고
		sum(parentMap, dir[i]);
        //중간에 0이 있는 곳을 매꾸기 위해 다시 move
		move(parentMap, dir[i]);
		dfs(count + 1, parentMap);//count 1 증가시키고 이동 + 합치기 가 완료된 map이 새로운 루트맵으로 dfs진행
	}

}


int main()
{
	//입력
	cin >> N;
	for(int i = 0; i < N; i++)
	{
		for (int j = 0; j < N; j++)
		{
			cin >> map[i][j];
		}
	}

	dfs(0, map);
	cout << result;
}

1. dfs 재귀로 한 레벨에서 상하좌우 모든 경우의 수 진행

2. 트리에서 다음 레벨로 내려가기 전 root 노드를 모든 자식이 참조 할 수 있게끔 parentMap에 미리 저장

3. 상/하/좌/우 에 따라 이동방식, 합치기 방식 각기 다르게 구현

백준 13460 c++ 구슬 탈출 2

현구구 — Fri, 3 Feb 2023 23:10:18 +0900

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

13460번: 구슬 탈출 2

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B'

www.acmicpc.net

문제

스타트링크에서 판매하는 어린이용 장난감 중에서 가장 인기가 많은 제품은 구슬 탈출이다. 구슬 탈출은 직사각형 보드에 빨간 구슬과 파란 구슬을 하나씩 넣은 다음, 빨간 구슬을 구멍을 통해 빼내는 게임이다.

보드의 세로 크기는 N, 가로 크기는 M이고, 편의상 1×1크기의 칸으로 나누어져 있다. 가장 바깥 행과 열은 모두 막혀져 있고, 보드에는 구멍이 하나 있다. 빨간 구슬과 파란 구슬의 크기는 보드에서 1×1크기의 칸을 가득 채우는 사이즈이고, 각각 하나씩 들어가 있다. 게임의 목표는 빨간 구슬을 구멍을 통해서 빼내는 것이다. 이때, 파란 구슬이 구멍에 들어가면 안 된다.

이때, 구슬을 손으로 건드릴 수는 없고, 중력을 이용해서 이리 저리 굴려야 한다. 왼쪽으로 기울이기, 오른쪽으로 기울이기, 위쪽으로 기울이기, 아래쪽으로 기울이기와 같은 네 가지 동작이 가능하다.

각각의 동작에서 공은 동시에 움직인다. 빨간 구슬이 구멍에 빠지면 성공이지만, 파란 구슬이 구멍에 빠지면 실패이다. 빨간 구슬과 파란 구슬이 동시에 구멍에 빠져도 실패이다. 빨간 구슬과 파란 구슬은 동시에 같은 칸에 있을 수 없다. 또, 빨간 구슬과 파란 구슬의 크기는 한 칸을 모두 차지한다. 기울이는 동작을 그만하는 것은 더 이상 구슬이 움직이지 않을 때 까지이다.

보드의 상태가 주어졌을 때, 최소 몇 번 만에 빨간 구슬을 구멍을 통해 빼낼 수 있는지 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에는 보드의 세로, 가로 크기를 의미하는 두 정수 N, M (3 ≤ N, M ≤ 10)이 주어진다. 다음 N개의 줄에 보드의 모양을 나타내는 길이 M의 문자열이 주어진다. 이 문자열은 '.', '#', 'O', 'R', 'B' 로 이루어져 있다. '.'은 빈 칸을 의미하고, '#'은 공이 이동할 수 없는 장애물 또는 벽을 의미하며, 'O'는 구멍의 위치를 의미한다. 'R'은 빨간 구슬의 위치, 'B'는 파란 구슬의 위치이다.

입력되는 모든 보드의 가장자리에는 모두 '#'이 있다. 구멍의 개수는 한 개 이며, 빨간 구슬과 파란 구슬은 항상 1개가 주어진다.

출력

최소 몇 번 만에 빨간 구슬을 구멍을 통해 빼낼 수 있는지 출력한다. 만약, 10번 이하로 움직여서 빨간 구슬을 구멍을 통해 빼낼 수 없으면 -1을 출력한다.

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int dx[4] = { 1,-1,0,0 };
int dy[4] = { 0,0,-1,1 };//상하좌우

int N, M;//행,열
char arr[10][10];
bool visitR[10][10];
bool visitB[10][10];

int redX = 0;
int redY = 0;
int blueX = 0;
int blueY = 0;

int result = -1;

void move(int& nowX, int& nowY, int dirX, int dirY, int& count)
{
	while (arr[nowX + dirX][nowY + dirY] != '#' && arr[nowX][nowY] != 'O')//현재 위치가 O가 아니고, 다음 위치가 벽#이 아니라면
	{
		count += 1;
		nowX = nowX + dirX;
		nowY = nowY + dirY;
	}
}
//참조를 써서 인자를 리턴할까?


void bfs()
{
	queue<pair<int, int>> Rq;
	queue<pair<int, int>> Bq;
	queue<int> countQ;
	//먼저 각 현재 위치를 큐에 넣고
	Rq.push(make_pair(redX, redY));
	Bq.push(make_pair(blueX, blueY));
	countQ.push(0);

	while (!Rq.empty())
	{
		int redNx = Rq.front().first;
		int redNy = Rq.front().second;
		int blueNx = Bq.front().first;
		int blueNy = Bq.front().second;

		int count = countQ.front();

		Rq.pop();
		Bq.pop();
		countQ.pop();

		if (count >= 10)
		{
			result = -1;
			break;
		}
		for (int i = 0; i < 4; i++)
		{
			int rX = redNx;
			int rY = redNy;
			int bX = blueNx;
			int bY = blueNy;
			 
			int ncount = count + 1;

			int redCnt = 0;
			int blueCnt = 0;
			move(rX, rY, dx[i], dy[i], redCnt);
			move(bX, bY, dx[i], dy[i], blueCnt);

			if (arr[bX][bY] == 'O')//case 1 파랑구슬이 구멍으로 갔다면 스킵
			{
				continue;
			}
			if (arr[rX][rY] == 'O')//case 2 빨간구슬만 구멍으로 갔다면 답을 찾았으므로 리턴
			{
				result = ncount;
				return;
			}
			if (rX == bX && rY == bY)//case 3 빨간구슬과 파란구슬 위치가 같다면
			{
				if (redCnt > blueCnt)//빨간구슬이 더 많이 이동했다는건 파랑구슬보다 더 뒤에 있었다는거
				{
					rX -= dx[i];
					rY -= dy[i];
				}
				else
				{
					bX -= dx[i];
					bY -= dy[i];
				}
			}
			Rq.push(make_pair(rX, rY));
			Bq.push(make_pair(bX, bY));
			countQ.push(ncount);
		}
	}
	result = -1;
}

int main()
{
	//입력
	cin >> N >> M;

	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			cin >> arr[i][j];
			if (arr[i][j] == 'R')
			{
				redX = i;
				redY = j;
			}
			if (arr[i][j] == 'B')
			{
				blueX = i;
				blueY = j;
			}
		}
	}
	bfs();
	cout << result;
}

백준 1062 c++ 가르침

현구구 — Thu, 2 Feb 2023 13:45:44 +0900

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

1062번: 가르침

첫째 줄에 단어의 개수 N과 K가 주어진다. N은 50보다 작거나 같은 자연수이고, K는 26보다 작거나 같은 자연수 또는 0이다. 둘째 줄부터 N개의 줄에 남극 언어의 단어가 주어진다. 단어는 영어 소문

www.acmicpc.net

문제

남극에 사는 김지민 선생님은 학생들이 되도록이면 많은 단어를 읽을 수 있도록 하려고 한다. 그러나 지구온난화로 인해 얼음이 녹아서 곧 학교가 무너지기 때문에, 김지민은 K개의 글자를 가르칠 시간 밖에 없다. 김지민이 가르치고 난 후에는, 학생들은 그 K개의 글자로만 이루어진 단어만을 읽을 수 있다. 김지민은 어떤 K개의 글자를 가르쳐야 학생들이 읽을 수 있는 단어의 개수가 최대가 되는지 고민에 빠졌다.

남극언어의 모든 단어는 "anta"로 시작되고, "tica"로 끝난다. 남극언어에 단어는 N개 밖에 없다고 가정한다. 학생들이 읽을 수 있는 단어의 최댓값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 단어의 개수 N과 K가 주어진다. N은 50보다 작거나 같은 자연수이고, K는 26보다 작거나 같은 자연수 또는 0이다. 둘째 줄부터 N개의 줄에 남극 언어의 단어가 주어진다. 단어는 영어 소문자로만 이루어져 있고, 길이가 8보다 크거나 같고, 15보다 작거나 같다. 모든 단어는 중복되지 않는다.

출력

첫째 줄에 김지민이 K개의 글자를 가르칠 때, 학생들이 읽을 수 있는 단어 개수의 최댓값을 출력한다.

#include <iostream>
#include <string>
using namespace std;
bool alpha[26];
int N, K;
string arr[50];
int result = 0;

bool check(int index)//체크된 알파벳으로 몇 개 단어를 다 돌 수 있는지 확인 
{
	for (int i = 4; i < arr[index].size()-4; i++)//앞 뒤 4글자씩은 고정이므로 탐색x
	{
		if (!alpha[arr[index][i] - 'a'])//체크안된 알파벳이면 false 체크면 true
			return false;
	}
	return true;
}

void dfs(int count, int start)
{
	if (count == K - 5)//알파벳 선택이 끝나면 몇개를 만족하는지 확인 시작
	{
		int sum = 0;
		for (int i = 0; i < N; i++)
		{
			if (check(i))
			{
				sum++;
			}
		}
		result = max(result, sum);//만족한 단어 개수 갱신
		return;
	}

	for (int i = start; i < 26; i++)
	{
		if (alpha[i])//이미 체크 돼있으면
			continue;
		alpha[i] = true;
		dfs(count + 1, i);
		alpha[i] = false;
	}
	return;
}

int main()
{
	//필수 알파벳 5개 a,n,t,c,i
	alpha['a' - 'a'] = true;
	alpha['n' - 'a'] = true;
	alpha['t' - 'a'] = true;
	alpha['c' - 'a'] = true;
	alpha['i' - 'a'] = true;

	//입력
	cin >> N >> K;
	for (int i = 0; i < N; i++)
	{
		cin >> arr[i];
	}
	if (K < 5)
		cout << 0;
	else
	{
		dfs(0, 0);
		cout << result;
	}
}

엘리듬(3일차) - 메인메뉴, 스테이지 클리어

현구구 — Wed, 1 Feb 2023 20:10:42 +0900

메인메뉴

다음과 같은 UI작업을 먼저 해주었다.

빈 오브젝트 GameManagerLobby 를 만들고 새로운 스크립트 LobbyGameManager를 생성한다.

코드는 다음과 같이 작성한다.

checkRuben bool형 변수를 활용하여 panel의 키고 끄는 것을 제어한다.

생성해둔 버튼에 새로운 스크립트 LevelSelection을 생성한다.

코드는 다음과 같다 bool형 변수 unlocked를 통해 image의 A값을 제어한다.

또한 버튼을 눌렀을 시 씬을 불러오는 함수를 작성하고 인자로는 이동할 맵 이름을 문자열로 입력받도록 한다.

새로운 오브젝트 & 스크립트인 MainManager를 생성한다. 해당 오브젝트는 플레이어의 현재 클리어한 stage를 저장할 것 이므로 모든 맵에 이 오브젝트가 들어있어야 한다.

nowStage는 클리어한 스테이지를 저장하며 stages배열에는 맵의 버튼 오브젝트들을 넣는다.

또한 GameClear()함수를 통해 해당 맵에서 게임을 클리어 하면 nowStage를 1 증가시켜 저장하는 함수를 간단하게 작성하였다.

Load같은 경우는 Update함수안에 넣어 지속적으로 불러올 수 있도록 하였다.

간단하게 게임화면에 clear버튼을 생성하고 MainManager 스크립트의 GameClear함수를 실행하였다.

NowStage변수가 0 -> 1로 증가하였고 스테이지 이미지도 불이 들어온 모습이다.

백준 1987 c++ 알파벳

현구구 — Wed, 1 Feb 2023 11:28:22 +0900

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

1987번: 알파벳

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다. 말은 상하좌우로 인접한 네 칸 중의 한 칸으

www.acmicpc.net

문제

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다.

말은 상하좌우로 인접한 네 칸 중의 한 칸으로 이동할 수 있는데, 새로 이동한 칸에 적혀 있는 알파벳은 지금까지 지나온 모든 칸에 적혀 있는 알파벳과는 달라야 한다. 즉, 같은 알파벳이 적힌 칸을 두 번 지날 수 없다.

좌측 상단에서 시작해서, 말이 최대한 몇 칸을 지날 수 있는지를 구하는 프로그램을 작성하시오. 말이 지나는 칸은 좌측 상단의 칸도 포함된다.

입력

첫째 줄에 R과 C가 빈칸을 사이에 두고 주어진다. (1 ≤ R,C ≤ 20) 둘째 줄부터 R개의 줄에 걸쳐서 보드에 적혀 있는 C개의 대문자 알파벳들이 빈칸 없이 주어진다.

출력

첫째 줄에 말이 지날 수 있는 최대의 칸 수를 출력한다.

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

int R, C;//행, 열
string arr[20];//입력받은 문자열
bool alpha[26];//알파벳 A~Z 체크
int result;

int dx[4] = {0,0,-1,1};//상하좌우
int dy[4] = {1,-1,0,0};


void dfs(int count, int row, int col)//인자는 이동횟수, 행, 열
{
	result = max(count, result);//함수 실행마다 최대값 갱신
	alpha[arr[row][col] - 'A'] = true;//현재 위치의 알파벳 true체크

	

	for (int i = 0; i < 4; i++)
	{
		int nextX = row + dx[i];
		int nextY = col + dy[i];
		if ((nextX >=0&&nextX<R)&&(nextY>=0&&nextY<C))//범위 안에 있을 때
		{
			if (alpha[arr[nextX][nextY] - 'A'] == true)//이미 지나간 알파벳이면 스킵
				continue;
			else
			{
				dfs(count + 1, nextX, nextY);

			}
		}
	}
	alpha[arr[row][col] - 'A'] = false;//해당 칸에서 함수 종료시 false로 전환
	return;
}

int main()
{
	cin >> R >> C;
	for (int i = 0; i < R; i++)
	{
		cin >> arr[i];
	}

	dfs(1, 0, 0);
	cout << result;

}

백준 4574 c++ 스도미노쿠

현구구 — Tue, 31 Jan 2023 23:12:34 +0900

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

4574번: 스도미노쿠

입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스의 첫째 줄에는 채워져 있는 도미노의 개수 N이 주어진다. (10 ≤ N ≤ 35) 다음 N개 줄에는 도미노 하나를 나타내는 U LU V LV가

www.acmicpc.net

문제

스도쿠가 세계적으로 유행이 된 이후에, 비슷한 퍼즐이 매우 많이 나왔다. 게임 매거진 2009년 7월호에는 스도쿠와 도미노를 혼합한 게임인 스도미노쿠가 소개되었다.

이 퍼즐은 스도쿠 규칙을 따른다. 스도쿠는 9×9 크기의 그리드를 1부터 9까지 숫자를 이용해서 채워야 한다. 스도쿠는 다음과 같은 조건을 만족하게 숫자를 채워야 한다.

각 행에는 1부터 9까지 숫자가 하나씩 있어야 한다.
각 열에는 1부터 9까지 숫자가 하나씩 있어야 한다.
3×3크기의 정사각형에는 1부터 9가지 숫자가 하나씩 있어야 한다.

스도미노쿠의 그리드에는 1부터 9까지 숫자가 쓰여져 있고, 나머지 72칸은 도미노 타일 36개로 채워야 한다. 도미노 타일은 1부터 9까지 서로 다른 숫자의 가능한 쌍이 모두 포함되어 있다. (1+2, 1+3, 1+4, 1+5, 1+6, 1+7, 1+8, 1+9, 2+3, 2+4, 2+5, ...) 1+2와 2+1은 같은 타일이기 때문에, 따로 구분하지 않는다. 도미노 타일은 회전 시킬 수 있다. 또, 3×3 크기의 정사각형의 경계에 걸쳐서 놓여질 수도 있다.

왼쪽 그림은 퍼즐의 초기 상태를 나타내고, 오른쪽은 퍼즐을 푼 상태이다.

스도미노쿠의 퍼즐의 초기 상태가 주어졌을 때, 퍼즐을 푸는 프로그램을 작성하시오.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스의 첫째 줄에는 채워져 있는 도미노의 개수 N이 주어진다. (10 ≤ N ≤ 35) 다음 N개 줄에는 도미노 하나를 나타내는 U LU V LV가 주어진다. U는 도미노에 쓰여 있는 한 숫자이고, LU는 길이가 2인 문자열로 U의 위치를 나타낸다. V와 LV는 도미노에 쓰여 있는 다른 숫자를 나타낸다. 도미노의 위치는 문제에 나와있는 그림을 참고한다. 입력으로 주어지는 도미노의 각 숫자 위치는 항상 인접해 있다.

N개의 도미노의 정보가 주어진 다음 줄에는 채워져 있는 숫자의 위치가 1부터 9까지 차례대로 주어진다. 위치는 도미노의 위치를 나타낸 방법과 같은 방법으로 주어진다.

모든 도미노와 숫자가 겹치는 경우는 없다.

입력의 마지막 줄에는 0이 하나 주어진다.

출력

각 퍼즐에 대해서, 스도쿠를 푼 결과를 출력한다. 항상 답이 유일한 경우만 입력으로 주어진다.

#include <iostream>
#include <string>
#include <cstring> //memset
using namespace std;


int arr[9][9];
bool row[9][10];//row[a][b] == true : a열에 b가 있다.
bool col[9][10];
bool miniArr[3][3][10]; //miniArr[a][b][c] == true : c가 [a,b] 3x3 타일안에 있다.
bool tile[10][10];//tile[a][b] == ture : a와 b가 세트인 타일이 있다.

bool fin;
int puzzle = 1;

void reset()
{
	fin = false;
	memset(arr, 0, sizeof(arr));
	memset(row, false, sizeof(row));
	memset(col, false, sizeof(col));
	memset(miniArr, false, sizeof(miniArr));
	memset(tile, false, sizeof(tile));
}

bool checkRow(int posX,int posY, int num1, int num2)//<가로>(posX,posY)에 num1, (posX, posY+1)에 num2를 넣어도 될까?
{
	if (row[posX][num1] == true || row[posX][num2]==true)
		return false;
	if (col[posY][num1] == true || col[posY + 1][num2] == true)
		return false;
	if (miniArr[posX / 3][posY / 3][num1] == true || miniArr[posX / 3][(posY + 1) / 3][num2] == true)
		return false;
	return true;

}

bool checkCol(int posX, int posY, int num1, int num2)//<세로>(posX,posY)에 num1, (posX+1, posY)에 num2를 넣어도 될까?
{
	if (row[posX][num1] == true || row[posX+1][num2] == true)
		return false;
	if (col[posY][num1] == true || col[posY][num2] == true)
		return false;
	if (miniArr[posX / 3][posY / 3][num1] == true || miniArr[(posX + 1) / 3][posY / 3][num2] == true)
		return false;
	return true;
}

void WriteRow(int posX, int posY, int num1, int num2, bool state)
{
	if (state == true)
	{
		arr[posX][posY] = num1;
		arr[posX][posY + 1] = num2;

		row[posX][num1] = true;
		row[posX][num2] = true;

		col[posY][num1] = true;
		col[posY + 1][num2] = true;

		miniArr[posX / 3][posY / 3][num1] = true;
		miniArr[posX / 3][(posY + 1) / 3][num2] = true;

		tile[num1][num2] = true;
		tile[num2][num1] = true;
	}
	else if (state == false)
	{
		arr[posX][posY] = 0;
		arr[posX][posY + 1] = 0;

		row[posX][num1] = false;
		row[posX][num2] = false;

		col[posY][num1] = false;
		col[posY + 1][num2] = false;

		miniArr[posX / 3][posY / 3][num1] = false;
		miniArr[posX / 3][(posY + 1) / 3][num2] = false;

		tile[num1][num2] = false;
		tile[num2][num1] = false;
	}
}

void WriteCol(int posX, int posY, int num1, int num2, bool state)
{
	if (state == true)
	{
		arr[posX][posY] = num1;
		arr[posX + 1][posY] = num2;

		row[posX][num1] = true;
		row[posX + 1][num2] = true;

		col[posY][num1] = true;
		col[posY][num2] = true;

		miniArr[posX / 3][posY / 3][num1] = true;
		miniArr[(posX + 1) / 3][posY / 3][num2] = true;

		tile[num1][num2] = true;
		tile[num2][num1] = true;
	}
	else if (state == false)
	{
		arr[posX][posY] = 0;
		arr[posX + 1][posY] = 0;

		row[posX][num1] = false;
		row[posX + 1][num2] = false;

		col[posY][num1] = false;
		col[posY][num2] = false;

		miniArr[posX / 3][posY / 3][num1] = false;
		miniArr[(posX + 1) / 3][posY / 3][num2] = false;

		tile[num1][num2] = false;
		tile[num2][num1] = false;
	}
}

void dfs(int count)
{
	if (fin)
		return;
	if (count == 81)
	{
		cout << "Puzzle " << puzzle<<'\n';
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 9; j++)
			{
				cout << arr[i][j];
			}
			cout << '\n';
		}
		fin = true;
		puzzle++;
		return;
	}

	int x = count / 9;
	int y = count % 9;

	if (arr[x][y] != 0)//이미 차있으면 다음으로
		dfs(count + 1);
	else
	{
		//가로 판별
		if (y <= 7 && arr[x][y+1] == 0)
		{
			for (int i = 1; i <= 9; i++)
			{
				for (int j = i + 1; j <= 9; j++)
				{
					if (tile[i][j] == false)
					{
						if (checkRow(x, y, i, j))//가로 만족 시
						{
							WriteRow(x, y, i, j, true);
							dfs(count + 1);
							WriteRow(x, y, i, j, false);
						}
						if (checkRow(x, y, j, i))
						{
							WriteRow(x, y, j, i, true);
							dfs(count + 1);
							WriteRow(x, y, j, i, false);
						}
					}
				}
			}
		}

		//세로 판별 바꿔야됨
		if (x <= 7 && arr[x+1][y] == 0)
		{
			for (int i = 1; i <= 9; i++)
			{
				for (int j = i+1; j <= 9; j++)
				{
					if (tile[i][j] == false)
					{
						if (checkCol(x, y, i, j))//세로 만족 시
						{
							WriteCol(x, y, i, j, true);
							dfs(count + 1);
							WriteCol(x, y, i, j, false);
						}
						if (checkCol(x, y, j, i))
						{
							WriteCol(x, y, j, i, true);
							dfs(count + 1);
							WriteCol(x, y, j, i, false);
						}
					}
				}
			}
		}

	}
}


int main()
{
	//입력
	while (1)
	{
		int N;
		cin >> N;
		if (N == 0)
			break;
		
		for (int i = 0; i < N; i++)
		{
			int num1, num2;
			string pos1, pos2;
			cin >> num1 >> pos1 >> num2 >> pos2;
			int x = pos1[0] - 'A';
			int y = pos1[1] - '0' - 1;
			int x2 = pos2[0] - 'A';
			int y2 = pos2[1] - '0' - 1;

			arr[x][y] = num1;
			arr[x2][y2] = num2;

			//같은 행
			row[x][num1] = true;
			row[x2][num2] = true;
			//같은 열
			col[y][num1] = true;
			col[y2][num2] = true;
			//같은 3x3 칸
			miniArr[x/3][y/3][num1] = true;
			miniArr[x2/3][y2/3][num2] = true;
			//해당 타일 존재 여부
			tile[num1][num2] = true;
			tile[num2][num1] = true;
		}
		for (int i = 1; i <= 9; i++)
		{
			string pos;
			cin >> pos;
			int x = pos[0] - 'A';
			int y = pos[1] - '0' - 1;
			arr[x][y] = i;
			row[x][i] = true;
			col[y][i] = true;
			miniArr[x/3][y/3][i] = true;
		}

		dfs(0);
		reset();
	}
}

백준 2580 c++ 스도쿠

현구구 — Sun, 29 Jan 2023 16:41:46 +0900

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

2580번: 스도쿠

스도쿠는 18세기 스위스 수학자가 만든 '라틴 사각형'이랑 퍼즐에서 유래한 것으로 현재 많은 인기를 누리고 있다. 이 게임은 아래 그림과 같이 가로, 세로 각각 9개씩 총 81개의 작은 칸으로 이루

www.acmicpc.net

문제

스도쿠는 18세기 스위스 수학자가 만든 '라틴 사각형'이랑 퍼즐에서 유래한 것으로 현재 많은 인기를 누리고 있다. 이 게임은 아래 그림과 같이 가로, 세로 각각 9개씩 총 81개의 작은 칸으로 이루어진 정사각형 판 위에서 이뤄지는데, 게임 시작 전 일부 칸에는 1부터 9까지의 숫자 중 하나가 쓰여 있다.

나머지 빈 칸을 채우는 방식은 다음과 같다.

각각의 가로줄과 세로줄에는 1부터 9까지의 숫자가 한 번씩만 나타나야 한다.
굵은 선으로 구분되어 있는 3x3 정사각형 안에도 1부터 9까지의 숫자가 한 번씩만 나타나야 한다.

위의 예의 경우, 첫째 줄에는 1을 제외한 나머지 2부터 9까지의 숫자들이 이미 나타나 있으므로 첫째 줄 빈칸에는 1이 들어가야 한다.

또한 위쪽 가운데 위치한 3x3 정사각형의 경우에는 3을 제외한 나머지 숫자들이 이미 쓰여있으므로 가운데 빈 칸에는 3이 들어가야 한다.

이와 같이 빈 칸을 차례로 채워 가면 다음과 같은 최종 결과를 얻을 수 있다.

게임 시작 전 스도쿠 판에 쓰여 있는 숫자들의 정보가 주어질 때 모든 빈 칸이 채워진 최종 모습을 출력하는 프로그램을 작성하시오.

입력

아홉 줄에 걸쳐 한 줄에 9개씩 게임 시작 전 스도쿠판 각 줄에 쓰여 있는 숫자가 한 칸씩 띄워서 차례로 주어진다. 스도쿠 판의 빈 칸의 경우에는 0이 주어진다. 스도쿠 판을 규칙대로 채울 수 없는 경우의 입력은 주어지지 않는다.

출력

모든 빈 칸이 채워진 스도쿠 판의 최종 모습을 아홉 줄에 걸쳐 한 줄에 9개씩 한 칸씩 띄워서 출력한다.

스도쿠 판을 채우는 방법이 여럿인 경우는 그 중 하나만을 출력한다.

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

int arr[9][9];
vector<pair<int, int>> zeroPosition;//0의 위치

int countZero = 0;//0의 개수

bool finish = false;//정답 case가 2가지 이상 출력되는거 방지


bool check(int row, int col)//넣어볼까 하는거
{
	//숫자가 같은 칸이 있다면 false출력

	//가로 탐색
	for (int i = 0; i < 9; i++)
	{
		if (arr[row][i] == arr[row][col] && i != col)
			return false;
	}
	//세로 탐색
	for (int i = 0; i < 9; i++)
	{
		if (arr[i][col] == arr[row][col] && i != row)
			return false;
	}

	//3x3 탐색
	int miniRow = row / 3;
	int miniCol = col / 3;

	for (int i = 3 * miniRow; i < 3 * miniRow + 3; i++)
	{
		for (int j = 3 * miniCol; j < 3 * miniCol + 3; j++)
		{
			if (arr[i][j] == arr[row][col] && (row != i && row != j))
				return false;
		}
	}
	return true;
}

void dfs(int count)
{
	if (count == countZero)//0을 다 채웠다면 출력
	{
		for (int i = 0; i < 9; i++)
		{
			for (int j = 0; j < 9; j ++ )
			{
				cout << arr[i][j]<<' ';
			}
			cout << '\n';
		}
		finish = true;
		return;
	}

	int x = zeroPosition[count].first;
	int y = zeroPosition[count].second;
	//0의 위치에 1~9 숫자를 넣어보고 check함수로 결정
	for (int i = 1; i <= 9; i++)
	{
		arr[x][y] = i;
		if (check(x, y))
			dfs(count + 1);
		if (finish)
			return;
	}
	arr[x][y] = 0;//알맞은 값 못찾았을 경우 다시 0으로
	//해당 dfs에서 값을 못찾았으면 백트래킹을 통해 다른 값을 찾아야 하므로 0으로 돌려놈
	return;
}


int main()
{
	//입력
	for (int i = 0; i < 9; i++)
	{
		for (int j = 0; j < 9; j++)
		{
			cin >> arr[i][j];

			if (arr[i][j] == 0)
			{
				zeroPosition.push_back(make_pair(i, j));
				countZero++;
			}
		}
	}

	dfs(0);

}

엘리듬(2일차) - 장애물 피격, 일시정지, 재시작, 체력바 UI

현구구 — Sat, 28 Jan 2023 17:10:06 +0900

1.플레이어 피격

Player 스크립트에 getDamage변수를 추가한다. 장애물에 닿았을 경우 해당 변수는 true가 된다.

Obstacle 태그를 가진 장애물안에 있을 경우 getDamage 변수를 true로 만들어주고

플레이어 컬러에서 알파값을 0.7을 줘서 살짝 흐리도록 만들어준다.

OnTriggerExit에서는 Obstacle태그를 가진 장애물에서 빠져나갈 때, getDamage를 다시 false로 만들고 컬러도 원래대로 되돌린다.

2.HP바

Slider UI를 하나 생성하고 이름은 HPBar로 한다.

Fill부분은 Color를 빨간색으로, Background부분 Color는 검은색으로 맞춘다.

새로운 스크립트 HPBar를 생성하고 다음과 같이 코드를 작성한다.

Player 컴포넌트를 받아와서 getDamage 변수가 true일 경우 curHP를 getDamage만큼 깍고

HandleHP함수를 하나 생성해서 value값을 조절하여 체력바가 깍이도록 한다.

3. 게임 재시작

다음과 같은 UI를 생성한다.

GameManager 스크립트에서 게임오버 UI인 gamOverSet 과 HP변수가 담겨있는 hpBar변수를 받아온다.

브금과 장애물 생성 변수를 false로 바꾸는 GameStop함수를 작성하고 GameOver함수에서 UI를 띄우며 GameStop함수를 실행하도록 한다.

그리고 Update에서 hp가 0밑으로 떨어졌을 경우 GameOver함수를 실행하도록한다.

4.일시정지

PauseButton을 하나 생성하고

버튼을 눌렀을 경우 띄울 UI를 생성한다.

PauseMenu 스크립트를 하나 생성하여 다음과 같이 코드를 작성한다.

esc버튼을 눌렀을 경우 각각 PauseGame 함수와 ResumeGame함수를 실행시키도록한다.

Time.timeScale이 0일 경우 게임이 멈추며 1일 경우 게임이 진행된다.

해당 함수들은 버튼을 클릭했을 경우에도 작동되도록 클라이언트에서 연결한다.

백준 9663 c++ N-Queen

현구구 — Sat, 28 Jan 2023 15:41:01 +0900

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

9663번: N-Queen

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다. N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

문제

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

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

입력

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

출력

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

#include <iostream>
using namespace std;

int N;
int result;
int col[15];//col[x] = 1 // x행의 queen위치는 1열

bool check(int row)
{
	for (int i = 0; i < row; i++)
	{
		if (col[row] == col[i] || row - i == abs(col[row] - col[i]))//세로, 대각선에 퀸이 있다면 false
			return false;
	}
	return true;
}

void dfs(int row)
{
	if (row == N)
	{
		result++;
		return;
	}
	for (int i = 0; i < N; i++)
	{
		col[row] = i;//일단 해당 row의 i열에 퀸을 넣어보고
		if (check(row))//check함수를 통해 다른 퀸과 안 닿는지 검사
		{
			dfs(row + 1);//통과하면 다음 행으로
		}
	}
    return;
}

int main()
{
	cin >> N;

	dfs(0);
	cout << result;
}

엘리듬(1일차) - 캐릭터 이동, 매트로놈 생성,장애물 소환

현구구 — Fri, 27 Jan 2023 22:00:49 +0900

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

1. 플레이어 이동

Collider - 장애물과 맵 경계선과의 출돌을 위한 컴포넌트

Rigidbody - 플레이어에게 힘을 주기 위한 컴포넌트(실질적인 이동) BodyType은 스크립트로 제어 할 것이기 때문에 Kinematic으로 설정해둔다.

이 기본 컴포는트를 추가한 다음 새로운 컴포넌트를 생성하고 이름은 Player로 한다.

다음과 같이 Box Collider로 경계선을 구분짓는다.

Is Trigger를 체크해주어 플레이어가 해당 경계선에 닿았을 경우 그 이상으로 움직이지 못하게 설정해줄거다.

Player스크립트로 가서 변수들을 선언하고 SpriteRenderer변수같은 경우는 컴포넌트를 받아와야 하므로 Awake함수에서 초기화 해준다.

move함수를 만든다.

만약 Border에 닿은 상태에서 그 이상으로 키가 눌러진다면 h와 v각각을 0으로 만들어 경계 밖으로 나갈 수 없도록 한다.

위 if문에 걸리지 않는다면 현재위치 curPos 에 nextPos를 더해주어 플레이어를 이동시킨다. 이 때 Time.deltaTime을 곱해주어야 컴퓨터 성능간에 플레이 차이가 발생하지 않는다.

마지막으로 횡 이동인 h가 음수, 즉 왼쪽방향으로 이동할 경우 flipX를 true로 만들어 플레이어가 왼쪽을 바라보도록 한다.

2. 매트로놈 생성

사각형을 늘려 회전하며 bpm을 알 수 있도록 하는 오브젝트를 생성하고 스크립트를 추가한다.

https://www.musicca.com/ko/metronome

온라인 메트로놈 | Musicca

오디오 및 비주얼 비트를 활용한 무료 온라인 메트로놈. BPM을 선택하거나 템포를 맞추세요. 연습할 때 큰 도움이 됩니다.

www.musicca.com

해당 사이트에서 불러올 노래의 bpm을 파악하여 bpm변수로 지정하고

다음과 같이 코드를 작성한다.

노래가 켜졌을 때, 60/bpm만큼의 시간이 지났을 때 45도 오브젝트를 회전하도록한다.

bpm은 배경화면 오브젝트에 AudioSource 컴포넌트를 추가하여 해당 컴포넌트에 넣어두었고

다음과 같은 스크립트를 추가하여 3초 뒤 브금이 실행되도록 하였다.

3.장애물 생성

먼저 장애물이 나올 위치에 R,G,B,A 값을 조정하여 경고 오브젝트를 하나 생성한다.

Invoke를 통해 1초뒤에 해당 위치에 장애물을 소환하고 자신을 삭제하도록하는 스크립트를 추가한다.

또한 장애물이 될 오브젝트도 하나 생성한다.

경고 오브젝트와 다르게 Rigidbody 와 Collider 컴포넌트를 추가하고 IsTrigger를 선택한다.

여기도 역시 새로운 스크립트를 작성한다.

Invoke를 통해 1초뒤 자신을 삭제시키도록 한다.

완성된 오브젝트는 프리펩으로 저장한다.

빈 오브젝트를 생성하고 GameManager 스크립트를 작성한다.

먼저 장애물들이 소환될 위치를 빈 오브젝트로 지정하고

다음과 같이 아이콘으로 보기 쉽게 나타낸다.

GameManager 스크립트의 변수 선언은 다음과 같다.

spawnPoints - 장애물을 소환할 위치들의 배열

warnObject - 경고표시를 소환할 프리팹

bpm - 박자에 맞춰 장애물을 소환할 시간변수

currentTime - 현재 시간 변수

SpawnWarn이라는 함수를 만들어 숫자 0~6사이에 Instantiate를 통해 경고 오브젝트를 생성하도록한다.

이 SpawnWarn 함수는 Update에서 일정 시간이 지나야만 실행되도록 코드를 작성한다.

백준 16198 c++ 에너지 모으기

현구구 — Fri, 27 Jan 2023 10:57:12 +0900

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

16198번: 에너지 모으기

N개의 에너지 구슬이 일렬로 놓여져 있고, 에너지 구슬을 이용해서 에너지를 모으려고 한다. i번째 에너지 구슬의 무게는 Wi이고, 에너지를 모으는 방법은 다음과 같으며, 반복해서 사용할 수 있

www.acmicpc.net

문제

N개의 에너지 구슬이 일렬로 놓여져 있고, 에너지 구슬을 이용해서 에너지를 모으려고 한다.

i번째 에너지 구슬의 무게는 Wi이고, 에너지를 모으는 방법은 다음과 같으며, 반복해서 사용할 수 있다.

에너지 구슬 하나를 고른다. 고른 에너지 구슬의 번호를 x라고 한다. 단, 첫 번째와 마지막 에너지 구슬은 고를 수 없다.
x번째 에너지 구슬을 제거한다.
Wx-1 × Wx+1의 에너지를 모을 수 있다.
N을 1 감소시키고, 에너지 구슬을 1번부터 N번까지로 다시 번호를 매긴다. 번호는 첫 구슬이 1번, 다음 구슬이 2번, ... 과 같이 매겨야 한다.

N과 에너지 구슬의 무게가 주어졌을 때, 모을 수 있는 에너지 양의 최댓값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 에너지 구슬의 개수 N(3 ≤ N ≤ 10)이 주어진다.

둘째 줄에는 에너지 구슬의 무게 W1, W2, ..., WN을 공백으로 구분해 주어진다. (1 ≤ Wi ≤ 1,000)

출력

첫째 줄에 모을 수 있는 에너지의 최댓값을 출력한다.

#include <iostream>
using namespace std;

int N;//횟수
int arr[10];//숫자 입력받을 배열
int check[10];//기준점으로 지정했을 때 true로
int sum[8];//한번의 재귀에서 합들을 저장할 배열
int MAX = 0;//합의 최대값

void dfs(int count)
{
	if (count == N - 2)
	{
		int result = 0;
		for (int i = 0; i < 8; i++)
		{
			result += sum[i];//모든 합 더해주기
		}
		MAX = max(MAX, result);//기존 max값과 비교
		return;
	}

	for (int i = 1; i < N - 1; i++)
	{
		if (check[i])//이미 체크한 기준점이면 continue
			continue;
		check[i] = true;//현재 기준점을 true로
		int front = i - 1;
		int back = i + 1;
		while (check[front])//true 기준점으로 사용되지 않은 앞까지 땡긴다.
			front--;
		while (check[back])//반대로 뒤로 땡김
			back++;
		sum[count] = arr[front] * arr[back];
		dfs(count + 1);
		check[i] = false;
	}

}

int main()
{
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		cin >> arr[i];
	}

	dfs(0);
	cout << MAX;

}

백준 16197 c++ 두 동전

현구구 — Thu, 26 Jan 2023 13:39:13 +0900

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

16197번: 두 동전

N×M 크기의 보드와 4개의 버튼으로 이루어진 게임이 있다. 보드는 1×1크기의 정사각형 칸으로 나누어져 있고, 각각의 칸은 비어있거나, 벽이다. 두 개의 빈 칸에는 동전이 하나씩 놓여져 있고,

www.acmicpc.net

문제

N×M 크기의 보드와 4개의 버튼으로 이루어진 게임이 있다. 보드는 1×1크기의 정사각형 칸으로 나누어져 있고, 각각의 칸은 비어있거나, 벽이다. 두 개의 빈 칸에는 동전이 하나씩 놓여져 있고, 두 동전의 위치는 다르다.

버튼은 "왼쪽", "오른쪽", "위", "아래"와 같이 4가지가 있다. 버튼을 누르면 두 동전이 버튼에 쓰여 있는 방향으로 동시에 이동하게 된다.

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

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

입력

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

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

o: 동전
.: 빈 칸
#: 벽

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

출력

첫째 줄에 두 동전 중 하나만 보드에서 떨어뜨리기 위해 눌러야 하는 버튼의 최소 횟수를 출력한다. 만약, 두 동전을 떨어뜨릴 수 없거나, 버튼을 10번보다 많이 눌러야 한다면, -1을 출력한다.

#include <iostream>
using namespace std;

int n, m;
char arr[21][21];
int dx[] = { 1,-1,0,0 };//상하좌우
int dy[] = { 0,0,-1,1 };

int nx[2];//현재 코인의 위치
int ny[2];

int minimum = 11;
bool check;

//인자 count, 1번동전 위치, 2번동전 위치
void dfs(int count, int nx1, int ny1,int nx2,int ny2)
{
	if (count == 10)
	{
		return;
	}

	for (int i = 0; i < 4; i++)
	{
		int nextX1 = nx1+dx[i];
		int nextY1 = ny1+dy[i];
		int nextX2 = nx2+dx[i];
		int nextY2 = ny2+dy[i];

		if ((nextX1 < 0 || nextX1 >= n || nextY1 < 0 || nextY1 >= m) && (nextX2 < 0 || nextX2 >= n || nextY2 < 0 || nextY2 >= m))//2개다 범위 밖으로 나갔을 때
		{
			continue;
		}
		else if ((nextX1 >= 0 && nextX1 < n && nextY1 >= 0 && nextY1 < m) && (nextX2 >= 0 && nextX2 < n && nextY2 >= 0 && nextY2 < m))//2개다 범위 안일때
		{
			if (arr[nextX1][nextY1] == '#' && arr[nextX2][nextY2] == '#')
				continue;
			if (arr[nextX1][nextY1] == '#')
			{
				nextX1 = nx1;
				nextY1 = ny1;
			}
			if (arr[nextX2][nextY2] == '#')
			{
				nextX2 = nx2;
				nextY2 = ny2;
			}
			dfs(count + 1, nextX1, nextY1, nextX2, nextY2);
		}
		else
		{
			minimum = min(minimum, count+1);
			return;
		}
	}
}

int main()
{
	//입력
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cin >> arr[i][j];
		}
	}
	//코인 위치 저장
	int k = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			if (arr[i][j] == 'o')
			{
				nx[k] = i;
				ny[k] = j;//현재 코인의 위치 초기화
				k++;
			}
		}
	}
	
	dfs(0, nx[0], ny[0], nx[1], ny[1]);

	if (minimum == 11)
		cout << -1;
	else
		cout << minimum;

	return 0;
}

백준 15658 c++ 연산자 끼워넣기(2)

현구구 — Wed, 25 Jan 2023 10:23:42 +0900

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

15658번: 연산자 끼워넣기 (2)

N개의 수로 이루어진 수열 A1, A2, ..., AN이 주어진다. 또, 수와 수 사이에 끼워넣을 수 있는 연산자가 주어진다. 연산자는 덧셈(+), 뺄셈(-), 곱셈(×), 나눗셈(÷)으로만 이루어져 있다. 연산자의 개수

www.acmicpc.net

문제

N개의 수로 이루어진 수열 A1, A2, ..., AN이 주어진다. 또, 수와 수 사이에 끼워넣을 수 있는 연산자가 주어진다. 연산자는 덧셈(+), 뺄셈(-), 곱셈(×), 나눗셈(÷)으로만 이루어져 있다. 연산자의 개수는 N-1보다 많을 수도 있다. 모든 수의 사이에는 연산자를 한 개 끼워넣어야 하며, 주어진 연산자를 모두 사용하지 않고 모든 수의 사이에 연산자를 끼워넣을 수도 있다.

우리는 수와 수 사이에 연산자를 하나씩 넣어서, 수식을 하나 만들 수 있다. 이때, 주어진 수의 순서를 바꾸면 안 된다.

예를 들어, 6개의 수로 이루어진 수열이 1, 2, 3, 4, 5, 6이고, 주어진 연산자가 덧셈(+) 3개, 뺄셈(-) 2개, 곱셈(×) 1개, 나눗셈(÷) 1개인 경우에는 총 250가지의 식을 만들 수 있다. 예를 들어, 아래와 같은 식을 만들 수 있다.

1+2+3-4×5÷6
1÷2+3+4-5×6
1+2÷3×4-5+6
1÷2×3-4+5+6
1+2+3+4-5-6
1+2+3-4-5×6

식의 계산은 연산자 우선 순위를 무시하고 앞에서부터 진행해야 한다. 또, 나눗셈은 정수 나눗셈으로 몫만 취한다. 음수를 양수로 나눌 때는 C++14의 기준을 따른다. 즉, 양수로 바꾼 뒤 몫을 취하고, 그 몫을 음수로 바꾼 것과 같다. 이에 따라서, 위의 식 4개의 결과를 계산해보면 아래와 같다.

1+2+3-4×5÷6 = 1
1÷2+3+4-5×6 = 12
1+2÷3×4-5+6 = 5
1÷2×3-4+5+6 = 7
1+2+3+4-5-6 = -1
1+2+3-4-5×6 = -18

N개의 수와 연산자가 주어졌을 때, 만들 수 있는 식의 결과가 최대인 것과 최소인 것을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1보다 크거나 같고, 4N보다 작거나 같은 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수, 곱셈(×)의 개수, 나눗셈(÷)의 개수이다.

출력

첫째 줄에 만들 수 있는 식의 결과의 최댓값을, 둘째 줄에는 최솟값을 출력한다. 연산자를 어떻게 끼워넣어도 항상 -10억보다 크거나 같고, 10억보다 작거나 같은 결과가 나오는 입력만 주어진다. 또한, 앞에서부터 계산했을 때, 중간에 계산되는 식의 결과도 항상 -10억보다 크거나 같고, 10억보다 작거나 같다.

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

int N;
vector<int> input;
int MAX = INT_MIN;
int MIN = INT_MAX;
int oper[4]; //oper[0] == +
			//oper[1] == -
			//oper[2] == *
			//oper[3] == /
int operArr[10];

void dfs(int count)
{
	if (count == N)
	{
		int result = input[0];
		for (int i = 1; i < N; i++)
		{
			switch (operArr[i])
			{
			case 1:
				result = result + input[i];
				break;
			case 2:
				result = result - input[i];
				break;
			case 3:
				result = result * input[i];
				break;
			case 4:
				result = result / input[i];
				break;

			}
		}
		MAX = max(MAX, result);
		MIN = min(MIN, result);
		return;
	}
	for (int i = 0; i < 4; i++)
	{
		if (oper[i] > 0)
		{
			operArr[count] = i+1;
			oper[i]--;
			dfs(count + 1);
			oper[i]++;
		}
	}
}

int main()
{
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		int getNum;
		cin >> getNum;
		input.push_back(getNum);
	}

	for (int i = 0; i < 4; i++)
	{
		cin >> oper[i];
	}
	dfs(1);
	cout << MAX << '\n' << MIN;

}

백준 14225 c++ 부분수열의 합

현구구 — Tue, 24 Jan 2023 21:11:09 +0900

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

14225번: 부분수열의 합

수열 S가 주어졌을 때, 수열 S의 부분 수열의 합으로 나올 수 없는 가장 작은 자연수를 구하는 프로그램을 작성하시오. 예를 들어, S = [5, 1, 2]인 경우에 1, 2, 3(=1+2), 5, 6(=1+5), 7(=2+5), 8(=1+2+5)을 만들

www.acmicpc.net

문제

수열 S가 주어졌을 때, 수열 S의 부분 수열의 합으로 나올 수 없는 가장 작은 자연수를 구하는 프로그램을 작성하시오.

예를 들어, S = [5, 1, 2]인 경우에 1, 2, 3(=1+2), 5, 6(=1+5), 7(=2+5), 8(=1+2+5)을 만들 수 있다. 하지만, 4는 만들 수 없기 때문에 정답은 4이다.

입력

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

둘째 줄에는 수열 S가 주어진다. S를 이루고있는 수는 100,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 수열 S의 부분 수열의 합으로 나올 수 없는 가장 작은 자연수를 출력한다.

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

int N;
vector<int> getNum;
bool check[2000001];

void Recur(int count, int sum)//재귀적으로 부분수열의 합을 탐색할 함수
{
	check[sum] = true;
	if (count == N)
		return;
	Recur(count + 1, sum);
	Recur(count + 1, sum+getNum[count]);
}


int main()
{
	cin >> N;
	
	for (int i = 0; i < N; i++)
	{
		int n;
		cin >> n;
		getNum.push_back(n);
	}

	Recur(0, 0);

	for (int i = 1; i < 2000000; i++)//처음부터 시작해서 체크안한 가장 작은 수 출력
	{
		if (!check[i])
		{
			cout << i;
			break;
		}
	}
}

백준 11725 c++ 트리의 부모 찾기

현구구 — Mon, 23 Jan 2023 20:40:16 +0900

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

11725번: 트리의 부모 찾기

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

www.acmicpc.net

문제

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

입력

첫째 줄에 노드의 개수 N (2 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N-1개의 줄에 트리 상에서 연결된 두 정점이 주어진다.

출력

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

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

int N;
vector<int> rel[100001];//관련성을 나타내는 배열
int pre[100001];//이전 노드(여기서는 부모 노드)
bool visit[100001];

void bfs(int start)
{
	queue<int> q;
	q.push(start);
	visit[start] = true;
	while (!q.empty())
	{
		int x = q.front();
		q.pop();
		for (int i = 0; i < rel[x].size(); i++)
		{
			if (visit[rel[x][i]])
				continue;
			pre[rel[x][i]] = x;
			visit[rel[x][i]] = true;
			q.push(rel[x][i]);
		}

	}
}

int main()
{
	cin >> N;
	for (int i = 1; i < N; i++)
	{
		int x, y;
		cin >> x >> y;
		rel[x].push_back(y);
		rel[y].push_back(x);
	}
	bfs(1);
	for (int i = 2; i <= N; i++)
	{
		cout << pre[i] << '\n';
	}
}

백준 14888 c++ 연산자 끼워넣기

현구구 — Fri, 20 Jan 2023 11:14:05 +0900

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

14888번: 연산자 끼워넣기

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수,

www.acmicpc.net

문제

N개의 수로 이루어진 수열 A1, A2, ..., AN이 주어진다. 또, 수와 수 사이에 끼워넣을 수 있는 N-1개의 연산자가 주어진다. 연산자는 덧셈(+), 뺄셈(-), 곱셈(×), 나눗셈(÷)으로만 이루어져 있다.

우리는 수와 수 사이에 연산자를 하나씩 넣어서, 수식을 하나 만들 수 있다. 이때, 주어진 수의 순서를 바꾸면 안 된다.

예를 들어, 6개의 수로 이루어진 수열이 1, 2, 3, 4, 5, 6이고, 주어진 연산자가 덧셈(+) 2개, 뺄셈(-) 1개, 곱셈(×) 1개, 나눗셈(÷) 1개인 경우에는 총 60가지의 식을 만들 수 있다. 예를 들어, 아래와 같은 식을 만들 수 있다.

1+2+3-4×5÷6
1÷2+3+4-5×6
1+2÷3×4-5+6
1÷2×3-4+5+6

1+2+3-4×5÷6 = 1
1÷2+3+4-5×6 = 12
1+2÷3×4-5+6 = 5
1÷2×3-4+5+6 = 7

N개의 수와 N-1개의 연산자가 주어졌을 때, 만들 수 있는 식의 결과가 최대인 것과 최소인 것을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수, 곱셈(×)의 개수, 나눗셈(÷)의 개수이다.

출력

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


int N;
vector<int> input;//숫자 입력 배열
int MAX = INT_MIN;
int MIN = INT_MAX;
int oper[4]; //oper[0] == +
			//oper[1] == -
			//oper[2] == *
			//oper[3] == /
int operArr[10];//dfs다 돌고 oper순서를 담을 배열

void dfs(int count)
{
	if (count == N)
	{
		int result = input[0];
		for (int i = 1; i < N; i++)
		{
			switch (operArr[i])
			{
			case 1:
				result = result + input[i];
				break;
			case 2:
				result = result - input[i];
				break;
			case 3:
				result = result * input[i];
				break;
			case 4:
				result = result / input[i];
				break;

			}
		}
		MAX = max(MAX, result);
		MIN = min(MIN, result);
		return;
	}
	for (int i = 0; i < 4; i++)
	{
    	//만약 해당 연산자가 있다면 
		if (oper[i] > 0)
		{
			operArr[count] = i+1;
			oper[i]--;
			dfs(count + 1);
			oper[i]++;
		}
	}
}

int main()
{
	//입력
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		int getNum;
		cin >> getNum;
		input.push_back(getNum);
	}

	for (int i = 0; i < 4; i++)
	{
		cin >> oper[i];
	}
	dfs(1);
	cout << MAX << '\n' << MIN;

}

백준 1339 c++ 단어 수학

현구구 — Thu, 19 Jan 2023 11:17:59 +0900

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

1339번: 단어 수학

첫째 줄에 단어의 개수 N(1 ≤ N ≤ 10)이 주어진다. 둘째 줄부터 N개의 줄에 단어가 한 줄에 하나씩 주어진다. 단어는 알파벳 대문자로만 이루어져있다. 모든 단어에 포함되어 있는 알파벳은 최대

www.acmicpc.net

문제

민식이는 수학학원에서 단어 수학 문제를 푸는 숙제를 받았다.

단어 수학 문제는 N개의 단어로 이루어져 있으며, 각 단어는 알파벳 대문자로만 이루어져 있다. 이때, 각 알파벳 대문자를 0부터 9까지의 숫자 중 하나로 바꿔서 N개의 수를 합하는 문제이다. 같은 알파벳은 같은 숫자로 바꿔야 하며, 두 개 이상의 알파벳이 같은 숫자로 바뀌어지면 안 된다.

예를 들어, GCF + ACDEB를 계산한다고 할 때, A = 9, B = 4, C = 8, D = 6, E = 5, F = 3, G = 7로 결정한다면, 두 수의 합은 99437이 되어서 최대가 될 것이다.

N개의 단어가 주어졌을 때, 그 수의 합을 최대로 만드는 프로그램을 작성하시오.

입력

첫째 줄에 단어의 개수 N(1 ≤ N ≤ 10)이 주어진다. 둘째 줄부터 N개의 줄에 단어가 한 줄에 하나씩 주어진다. 단어는 알파벳 대문자로만 이루어져있다. 모든 단어에 포함되어 있는 알파벳은 최대 10개이고, 수의 최대 길이는 8이다. 서로 다른 문자는 서로 다른 숫자를 나타낸다.

출력

첫째 줄에 주어진 단어의 합의 최댓값을 출력한다.

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

int N;
vector<string> input;//문자열 입력 받을 벡터
int alphasize[26];//알파벳이 사용된 자리수
int alphaToInt[26];//해당 알파벳에 부여하는 숫자
bool check[26];//이미 숫자가 부여된 알파벳인지 검사

int findMax()
{
	//알파벳의 자리수 구하기
	for (int i = 0; i < N; i++)
	{
		int k = 1;
        //1의자리부터 돌며 해당 알파벳에 k = 1부터 10씩 곱해지는 자리수를 대입한다.
		for (int j = input[i].size()-1; j>=0 ; j--)
		{
			alphasize[input[i][j] - 'A'] += k;
			k = k*10;
		}
	}
    
	//알파벳에 부여하는 숫자
	int give = 9;
	for (int i = 0; i < 9; i++)
	{
        int tmp = 0;
        //이미 check한 알파벳이면 tmp를 늘린다.
		while (1)
		{
			if (check[tmp])
				tmp++;
			else
				break;
		}
        //모든 알파벳을 돌며 현재 tmp보다 자리수가 큰 알파벳을 찾으면 tmp교체
		for (int j = 1; j < 26; j++)
		{
			if (alphasize[tmp] < alphasize[j])
			{
				if (!check[j])
				{
					tmp = j;
				}
			}
		}
		check[tmp] = true;
		alphaToInt[tmp] = give;
		give--;
	}
	int max = 0;
	
    //자리수에 부여된 숫자를 곱하여 max값을 구한다
	for (int i = 0; i < 26; i++)
	{
		max = max + (alphaToInt[i] * alphasize[i]);
	}

	return max;

}

int main()
{
	//입력
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		string getString;
		cin >> getString;
		input.push_back(getString);
	}

	cout << findMax();
}

유니티 Visual Studio 자동완성 안될 때

현구구 — Wed, 18 Jan 2023 19:54:32 +0900

Edit -> Preferences에 들어가서

해당 부분 에디터를 비주얼 스튜디오로 바꿔주면 된다.