728x90
반응형
  • 문제

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다. 순간이동을 하는 경우에는 1초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때, 수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 그리고, 가장 빠른 시간으로 찾는 방법이 몇 가지 인지 구하는 프로그램을 작성하시오.

  • 입력

첫 번째 줄에 수빈이가 있는 위치 N과 동생이 있는 위치 K가 주어진다. N과 K는 정수이다.

  • 출력

첫째 줄에 수빈이가 동생을 찾는 가장 빠른 시간을 출력한다.

둘째 줄에는 가장 빠른 시간으로 수빈이가 동생을 찾는 방법의 수를 출력한다.

  • 예제 입력
5 17
  • 예제 출력
4
2
  • 접근방식

N(5) -> K(17) 까지의 BFS 그래프

N에서 K까지의 최단거리를 구하고 해당 경우의수를 구하면 된다 > 최단거리는 BFS로 구하고 경우의수는 따로 카운터하기

  • 코드

 

#include <iostream>
#include <queue>
#include <algorithm>

using namespace std;

const int MAX = 100000;
int visited[MAX + 4], cnt[MAX+4];
int n, k;

void solve(int n, int k)
{
	if (n == k)
	{
		cout << 0 << endl << 1;
		return;
	}
	visited[n] = 1;
	cnt[n] = 1;
	queue<int> q;
	q.push(n);
	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		for (int next : {now - 1, now + 1, now * 2}) // 3가지 이동경우
		{
			if (0 <= next && next <= MAX)
			{
				if (!visited[next])
				{
					q.push(next);
					visited[next] = visited[now] + 1;
					cnt[next] += cnt[now];
				}
				else if (visited[next] == visited[now] + 1)
				{
					cnt[next] += cnt[now];
				}
			}
		}
	}
	cout << visited[k] - 1 << endl;
	cout << cnt[k];
}

int main()
{
	cin >> n >> k;
	solve(n, k);
	return 0;
}

 

 

12851번: 숨바꼭질 2

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때

www.acmicpc.net

 

728x90
반응형

'C++ > BOJ' 카테고리의 다른 글

[C++]/백준 17071번 숨바꼭질 5  (1) 2024.02.28
[C++]/백준 13913번 숨바꼭질 4  (0) 2024.02.28
[C++]/백준 16337번 괄호 추가하기  (1) 2024.02.28
[C++]/백준 12869번 뮤탈리스크  (0) 2024.02.28
[C++]/백준 4179번 불!  (0) 2024.02.20
728x90
반응형
  • 문제

길이가 N인 수식이 있다. 수식은 0보다 크거나 같고, 9보다 작거나 같은 정수와 연산자(+, -, ×)로 이루어져 있다. 연산자 우선순위는 모두 동일하기 때문에, 수식을 계산할 때는 왼쪽에서부터 순서대로 계산해야 한다. 예를 들어, 3+8×7-9×2의 결과는 136이다.

수식에 괄호를 추가하면, 괄호 안에 들어있는 식은 먼저 계산해야 한다. 단, 괄호 안에는 연산자가 하나만 들어 있어야 한다. 예를 들어, 3+8×7-9×2에 괄호를 3+(8×7)-(9×2)와 같이 추가했으면, 식의 결과는 41이 된다. 하지만, 중첩된 괄호는 사용할 수 없다. 즉, 3+((8×7)-9)×2, 3+((8×7)-(9×2))은 모두 괄호 안에 괄호가 있기 때문에, 올바른 식이 아니다.

수식이 주어졌을 때, 괄호를 적절히 추가해 만들 수 있는 식의 결과의 최댓값을 구하는 프로그램을 작성하시오. 추가하는 괄호 개수의 제한은 없으며, 추가하지 않아도 된다.

  • 입력

첫째 줄에 수식의 길이 N(1 ≤ N ≤ 19)가 주어진다. 둘째 줄에는 수식이 주어진다. 수식에 포함된 정수는 모두 0보다 크거나 같고, 9보다 작거나 같다. 문자열은 정수로 시작하고, 연산자와 정수가 번갈아가면서 나온다. 연산자는 +, -, * 중 하나이다. 여기서 *는 곱하기 연산을 나타내는 × 연산이다. 항상 올바른 수식만 주어지기 때문에, N은 홀수이다.

  • 출력

첫째 줄에 괄호를 적절히 추가해서 얻을 수 있는 결과의 최댓값을 출력한다. 정답은 2^31보다 작고, -2^31보다 크다.

  • 예제 입력
9
3+8*7-9*2
5
8*3+5
7
8*3+5+2
19
1*2+3*4*5-6*7*8*9*0
19
1*2+3*4*5-6*7*8*9*9
19
1-9-1-9-1-9-1-9-1-9
  • 예제 출력
136
64
66
0
426484
24
  • 접근방식

방향성이 있는 그래프로 보기

인덱스를 기반으로 누적합 증가, 방향성이 있는 그래프로 보기, 연산자는 따로 계산

  • 코드
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> num;
vector<char> oper_str;
int n, result = -999999999;
string s;

int oper(char a, int b, int c)
{
	if (a == '+')	return b + c;
	if (a == '-')	return b - c;
	if (a == '*')	return b * c;
}

void solve(int here, int _num)
{
	if (here == num.size() - 1)
	{
		result = max(result, _num);
		return;
	}

	solve(here + 1, oper(oper_str[here], _num, num[here + 1]));
	if (here + 2 <= num.size() - 1)
	{
		int temp = oper(oper_str[here + 1], num[here + 1], num[here + 2]);
		solve(here + 2, oper(oper_str[here], _num, temp));
	}
	return;
}

int main()
{
	cin >> n;
	cin >> s;

	for (int i = 0; i < n; i++)
	{
		if (i % 2 == 0)
		{
			num.push_back(s[i] - '0');
		}
		else
		{
			oper_str.push_back(s[i]);
		}
	}
	solve(0, num[0]);
	cout << result;
	return 0;
}

 

 

16637번: 괄호 추가하기

첫째 줄에 수식의 길이 N(1 ≤ N ≤ 19)가 주어진다. 둘째 줄에는 수식이 주어진다. 수식에 포함된 정수는 모두 0보다 크거나 같고, 9보다 작거나 같다. 문자열은 정수로 시작하고, 연산자와 정수가

www.acmicpc.net

728x90
반응형

'C++ > BOJ' 카테고리의 다른 글

[C++]/백준 13913번 숨바꼭질 4  (0) 2024.02.28
[C++]/백준 12851번 숨바꼭질 2  (0) 2024.02.28
[C++]/백준 12869번 뮤탈리스크  (0) 2024.02.28
[C++]/백준 4179번 불!  (0) 2024.02.20
[C++]/백준 16234번 인구 이동  (0) 2024.02.20
728x90
반응형
  • 문제

수빈이는 강호와 함께 스타크래프트 게임을 하고 있다. 수빈이는 뮤탈리스크 1개가 남아있고, 강호는 SCV N개가 남아있다.

각각의 SCV는 남아있는 체력이 주어져있으며, 뮤탈리스크를 공격할 수는 없다. 즉, 이 게임은 수빈이가 이겼다는 것이다.

뮤탈리스크가 공격을 할 때, 한 번에 세 개의 SCV를 공격할 수 있다.

  1. 첫 번째로 공격받는 SCV는 체력 9를 잃는다.
  2. 두 번째로 공격받는 SCV는 체력 3을 잃는다.
  3. 세 번째로 공격받는 SCV는 체력 1을 잃는다.

SCV의 체력이 0 또는 그 이하가 되어버리면, SCV는 그 즉시 파괴된다. 한 번의 공격에서 같은 SCV를 여러 번 공격할 수는 없다.

남아있는 SCV의 체력이 주어졌을 때, 모든 SCV를 파괴하기 위해 공격해야 하는 횟수의 최솟값을 구하는 프로그램을 작성하시오.

  • 입력

첫째 줄에 SCV의 수 N (1 ≤ N ≤ 3)이 주어진다. 둘째 줄에는 SCV N개의 체력이 주어진다. 체력은 60보다 작거나 같은 자연수이다.

  • 출력

첫째 줄에 모든 SCV를 파괴하기 위한 공격 횟수의 최솟값을 출력한다.

  • 예제 입력
3
12 10 4
3
54 18 6
1
60
3
1 1 1
2
60 40
  • 예제 출력
2
6
7
1
9
  • 접근방식

0,0,0 으로 가는 레벨을 구하면 된다.

그래프로 표현하였을때 3개의 scv가 0,0,0이 되는 최소 레벨을 구하면 된다. > bfs로 해결 가능

단, scv의 체력이 0 이하가 되었을때는 음수로 되지 않게 예외처리 필요

  • 코드
#include <iostream>
#include <queue>
#include <algorithm>

using namespace std;

int n, scv[3], visited[64][64][64];

int _a[6][3] =
{
	{9, 3, 1},
	{9, 1, 3},
	{3, 1, 9},
	{3, 9, 1},
	{1, 3, 9},
	{1, 9, 3}
};

struct A
{
	int a, b, c;
};

queue<A> q;

int bfs(int a, int b, int c)
{
	visited[a][b][c] = 1;
	q.push({ a,b,c });
	while (q.size())
	{
		int a = q.front().a;
		int b = q.front().b;
		int c = q.front().c;
		q.pop();

		if (visited[0][0][0])	break;
		for (int i = 0; i < 6; i++)
		{
			// 음수 방지
			int na = max(0, a - _a[i][0]);
			int nb = max(0, b - _a[i][1]);
			int nc = max(0, c - _a[i][2]);

			if (visited[na][nb][nc])	continue;
			visited[na][nb][nc] = visited[a][b][c] + 1;
			q.push({ na,nb,nc });
		}
	}
	return visited[0][0][0] - 1;
}

int main()
{
	cin >> n;

	for (int i = 0; i < n; i++)
	{
		cin >> scv[i];
	}
	cout << bfs(scv[0], scv[1], scv[2]);
	return 0;
}

 

 

12869번: 뮤탈리스크

1, 3, 2 순서대로 공격을 하면, 남은 체력은 (12-9, 10-1, 4-3) = (3, 9, 1)이다. 2, 1, 3 순서대로 공격을 하면, 남은 체력은 (0, 0, 0)이다.

www.acmicpc.net

 

728x90
반응형

'C++ > BOJ' 카테고리의 다른 글

[C++]/백준 12851번 숨바꼭질 2  (0) 2024.02.28
[C++]/백준 16337번 괄호 추가하기  (1) 2024.02.28
[C++]/백준 4179번 불!  (0) 2024.02.20
[C++]/백준 16234번 인구 이동  (0) 2024.02.20
[C++]/백준 2589번 보물섬  (0) 2024.02.20
728x90
반응형
  • 문제

지훈이는 미로에서 일을 한다. 지훈이를 미로에서 탈출하도록 도와주자!

미로에서의 지훈이의 위치와 불이 붙은 위치를 감안해서 지훈이가 불에 타기전에 탈출할 수 있는지의 여부, 그리고 얼마나 빨리 탈출할 수 있는지를 결정해야한다.

지훈이와 불은 매 분마다 한칸씩 수평또는 수직으로(비스듬하게 이동하지 않는다) 이동한다.

불은 각 지점에서 네 방향으로 확산된다.

지훈이는 미로의 가장자리에 접한 공간에서 탈출할 수 있다.

지훈이와 불은 벽이 있는 공간은 통과하지 못한다.

  • 입력

입력의 첫째 줄에는 공백으로 구분된 두 정수 R과 C가 주어진다. 단, 1 ≤ R, C ≤ 1000 이다. R은 미로 행의 개수, C는 열의 개수이다.

다음 입력으로 R줄동안 각각의 미로 행이 주어진다.

각각의 문자들은 다음을 뜻한다.

  • #: 벽
  • .: 지나갈 수 있는 공간
  • J: 지훈이의 미로에서의 초기위치 (지나갈 수 있는 공간)
  • F: 불이 난 공간

J는 입력에서 하나만 주어진다.

  • 출력

지훈이가 불이 도달하기 전에 미로를 탈출 할 수 없는 경우 IMPOSSIBLE 을 출력한다.

지훈이가 미로를 탈출할 수 있는 경우에는 가장 빠른 탈출시간을 출력한다.

  • 예제 입력
4 4
####
#JF#
#..#
#..#
  • 예제 출력
3
  • 접근방식

bfs로 불의 최단거리와 병훈이의 최단거리를 비교해나간다. + 불은 1개 이상 존재함 (1개만 존재하는게 아닐수도 있음), 불이 없는 경우도 존재하기 때문에 높은 수의 변수를 지정해놓음

  • 코드
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <stack>
#include <queue>
#include <cstring>

using namespace std;

// 가장 빠른 탈출시간 -> bfs
// 불은 네방향으로 확산
// 불의 최단거리와 병훈이의 최단거리 비교
// ret = person_check[y][x] 부분 C6385오류 발생

const int INF = 987654321;
char a[1004][1004];
int n, m, sx, sy, dx[4] = { -1,0,1,0 }, dy[4] = { 0,-1,0,1 }, ret, y, x;
int fire_check[1004][1004], person_check[1004][1004];
bool in(int a, int b) 
{
	return 0 <= a && a < n && 0 <= b && b < m;
}

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

	queue<pair<int, int>> q;
	cin >> n >> m;
	fill(&fire_check[0][0], &fire_check[0][0] + 1004 * 1004, INF);
	for (int i = 0; i < n; i++)
    {
		for (int j = 0; j < m; j++)
        {
			cin >> a[i][j];
			if (a[i][j] == 'F')
            {
				fire_check[i][j] = 1; q.push({ i, j });
			}
			else if (a[i][j] == 'J')
            {
				sy = i; sx = j;
			}
		}
	}

	while (q.size()) // 불의 최단거리 먼저 구하기
    {
		tie(y, x) = q.front();
		q.pop();
		for (int i = 0; i < 4; i++)
        {
			int ny = y + dy[i];
			int nx = x + dx[i];
			if (!in(ny, nx)) continue;
			if (fire_check[ny][nx] != INF || a[ny][nx] == '#') continue;
			fire_check[ny][nx] = fire_check[y][x] + 1;
			q.push({ ny, nx });
		}
	}

	person_check[sy][sx] = 1;
	q.push({ sy,sx });
	while (q.size())
    {
		int y = q.front().first;
		int x = q.front().second;
		q.pop();
		if (x == m - 1 || y == n - 1 || x == 0 || y == 0) // 빠져 나오는 부분
        {
			ret = person_check[y][x];
			break;
		}
		for (int i = 0; i < 4; i++)
        {
			int ny = y + dy[i];
			int nx = x + dx[i];
			if (!in(ny, nx)) continue;
			if (person_check[ny][nx] || a[ny][nx] == '#') continue;
			if (fire_check[ny][nx] <= person_check[y][x] + 1) continue;
			person_check[ny][nx] = person_check[y][x] + 1;
			q.push({ ny, nx });
		}
	}
	if (ret != 0) cout << ret << "\n";
	else cout << "IMPOSSIBLE \n";
	return 0;
}
 

4179번: 불!

입력의 첫째 줄에는 공백으로 구분된 두 정수 R과 C가 주어진다. 단, 1 ≤ R, C ≤ 1000 이다. R은 미로 행의 개수, C는 열의 개수이다. 다음 입력으로 R줄동안 각각의 미로 행이 주어진다. 각각의 문자

www.acmicpc.net

728x90
반응형

'C++ > BOJ' 카테고리의 다른 글

[C++]/백준 16337번 괄호 추가하기  (1) 2024.02.28
[C++]/백준 12869번 뮤탈리스크  (0) 2024.02.28
[C++]/백준 16234번 인구 이동  (0) 2024.02.20
[C++]/백준 2589번 보물섬  (0) 2024.02.20
[C++]/백준 17298번 오큰수  (0) 2023.01.20
728x90
반응형
  • 문제

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모든 나라는 1×1 크기이기 때문에, 모든 국경선은 정사각형 형태이다.

오늘부터 인구 이동이 시작되는 날이다.

인구 이동은 하루 동안 다음과 같이 진행되고, 더 이상 아래 방법에 의해 인구 이동이 없을 때까지 지속된다.

  • 국경선을 공유하는 두 나라의 인구 차이가 L명 이상, R명 이하라면, 두 나라가 공유하는 국경선을 오늘 하루 동안 연다.
  • 위의 조건에 의해 열어야하는 국경선이 모두 열렸다면, 인구 이동을 시작한다.
  • 국경선이 열려있어 인접한 칸만을 이용해 이동할 수 있으면, 그 나라를 오늘 하루 동안은 연합이라고 한다.
  • 연합을 이루고 있는 각 칸의 인구수는 (연합의 인구수) / (연합을 이루고 있는 칸의 개수)가 된다. 편의상 소수점은 버린다.
  • 연합을 해체하고, 모든 국경선을 닫는다.

각 나라의 인구수가 주어졌을 때, 인구 이동이 며칠 동안 발생하는지 구하는 프로그램을 작성하시오.

  • 입력

첫째 줄에 N, L, R이 주어진다. (1 ≤ N ≤ 50, 1 ≤ L ≤ R ≤ 100)

둘째 줄부터 N개의 줄에 각 나라의 인구수가 주어진다. r행 c열에 주어지는 정수는 A[r][c]의 값이다. (0 ≤ A[r][c] ≤ 100)

인구 이동이 발생하는 일수가 2,000번 보다 작거나 같은 입력만 주어진다.

  • 출력

인구 이동이 며칠 동안 발생하는지 첫째 줄에 출력한다.

  • 예제 입력
2 20 50
50 30
20 40
2 40 50
50 30
20 40
2 20 50
50 30
30 40
3 5 10
10 15 20
20 30 25
40 22 10
4 10 50
10 100 20 90
80 100 60 70
70 20 30 40
50 20 100 10
  • 예제 출력
1
0
1
2
3
  • 접근방식

dfs로 조건에 만족하는 (l 이상, r 이하) 곳을 찾아 해당 좌표가 가지고 있는 값과 좌표를 저장후 국경 공유가 된 상태에서 평균을 내어 다시 넣어주기

  • 코드
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <stack>
#include <queue>
#include <cstring>

using namespace std;

// 국경을 공유하는 두 나라 인구 차이가 l이상, r이하면 국경 공유(연합)
// 연합을 이루고 있는 각 칸의 인구수는     연합의 인구수 / 연합을 이루고 있는 칸의 개수
// 인구 이동을 할수 없을때까지 반복 (dfs)

int visited[54][54], _map[54][54];
int n, l, r, sum, cnt;

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

vector<pair<int, int>> x_y_save;

void dfs(int y, int x, vector<pair<int, int>>& v) 
{
    for (int i = 0; i < 4; i++) 
    {
        int ny = y + dy[i];
        int nx = x + dx[i];
        if (nx < 0 || nx >= n || ny < 0 || ny >= n || visited[ny][nx])
            continue;
        if (abs(_map[ny][nx] - _map[y][x]) >= l && abs(_map[ny][nx] - _map[y][x]) <= r) 
        {
            visited[ny][nx] = 1;
            v.push_back({ ny,nx });
            sum += _map[ny][nx];
            dfs(ny, nx, v);
        }
    }
}

int main() {
    cin >> n >> l >> r;
    for (int i = 0; i < n; i++) 
    {
        for (int j = 0; j < n; j++) 
        {
            cin >> _map[i][j];
        }
    }

    while (1) {
        bool flag = 0;
        memset(visited, 0, sizeof(visited));
        for (int i = 0; i < n; i++) 
        {
            for (int j = 0; j < n; j++) 
            {
                if (!visited[i][j]) 
                {
                    x_y_save.clear();
                    visited[i][j] = 1;
                    x_y_save.push_back({ i,j });
                    sum = _map[i][j];
                    dfs(i, j, x_y_save);
                    if (x_y_save.size() == 1) 
                        continue;

                    for (pair<int, int> b : x_y_save) 
                    {
                        _map[b.first][b.second] = sum / x_y_save.size();
                        flag = 1;
                    }
                }
            }
        }
        if (!flag) 
            break;
        cnt++;
    }
    cout << cnt;
    return 0;
}
 

16234번: 인구 이동

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모

www.acmicpc.net

 

728x90
반응형

'C++ > BOJ' 카테고리의 다른 글

[C++]/백준 12869번 뮤탈리스크  (0) 2024.02.28
[C++]/백준 4179번 불!  (0) 2024.02.20
[C++]/백준 2589번 보물섬  (0) 2024.02.20
[C++]/백준 17298번 오큰수  (0) 2023.01.20
[C++]/백준 1325번 효율적인 해킹  (0) 2023.01.20
728x90
반응형
  • 문제

보물섬 지도를 발견한 후크 선장은 보물을 찾아나섰다. 보물섬 지도는 아래 그림과 같이 직사각형 모양이며 여러 칸으로 나뉘어져 있다. 각 칸은 육지(L)나 바다(W)로 표시되어 있다. 이 지도에서 이동은 상하좌우로 이웃한 육지로만 가능하며, 한 칸 이동하는데 한 시간이 걸린다. 보물은 서로 간에 최단 거리로 이동하는데 있어 가장 긴 시간이 걸리는 육지 두 곳에 나뉘어 묻혀있다. 육지를 나타내는 두 곳 사이를 최단 거리로 이동하려면 같은 곳을 두 번 이상 지나가거나, 멀리 돌아가서는 안 된다.

예를 들어 위와 같이 지도가 주어졌다면 보물은 아래 표시된 두 곳에 묻혀 있게 되고, 이 둘 사이의 최단 거리로 이동하는 시간은 8시간이 된다.

보물 지도가 주어질 때, 보물이 묻혀 있는 두 곳 간의 최단 거리로 이동하는 시간을 구하는 프로그램을 작성하시오.

  • 입력

첫째 줄에는 보물 지도의 세로의 크기와 가로의 크기가 빈칸을 사이에 두고 주어진다. 이어 L과 W로 표시된 보물 지도가 아래의 예와 같이 주어지며, 각 문자 사이에는 빈 칸이 없다. 보물 지도의 가로, 세로의 크기는 각각 50이하이다.

  • 출력

첫째 줄에 보물이 묻혀 있는 두 곳 사이를 최단 거리로 이동하는 시간을 출력한다.

  • 예제 입력
5 7
WLLWWWL
LLLWLLL
LWLWLWW
LWLWLLL
WLLWLWW
  • 예제 출력
8
  • 접근방식

n*m bfs로 방문 처리를 하면서 제일 먼 거리 탐색

  • 코드
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <stack>
#include <queue>
#include <cstring>

using namespace std;

//bfs

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

char _map[54][54];
int visited[54][54];
int n, m, _max;

void bfs(int y, int x)
{
    memset(visited, 0, sizeof(visited));
    visited[y][x] = 1;
    queue<pair<int, int>> q;
    q.push({ y,x });
    while (q.size())
    {
        tie(y, x) = q.front();
        q.pop();
        for (int i = 0; i < 4; i++)
        {
            int ny = y + dy[i];
            int nx = x + dx[i];
            if (ny < 0 || ny >= n || nx < 0 || nx >= m || visited[ny][nx])
                continue;
            if (_map[ny][nx] == 'W')
                continue;
            visited[ny][nx] = visited[y][x] + 1;
            q.push({ ny,nx });
            _max = max(_max, visited[ny][nx]); // 제일 먼것이 보물임
        }
    }
}

int main() 
{
    cin >> n >> m;

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> _map[i][j];
        }
    }

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (_map[i][j] == 'L')
                bfs(i, j);
        }
    }

    cout << _max - 1;
    return 0;
}
 

2589번: 보물섬

보물섬 지도를 발견한 후크 선장은 보물을 찾아나섰다. 보물섬 지도는 아래 그림과 같이 직사각형 모양이며 여러 칸으로 나뉘어져 있다. 각 칸은 육지(L)나 바다(W)로 표시되어 있다. 이 지도에서

www.acmicpc.net

 

 

728x90
반응형

'C++ > BOJ' 카테고리의 다른 글

[C++]/백준 4179번 불!  (0) 2024.02.20
[C++]/백준 16234번 인구 이동  (0) 2024.02.20
[C++]/백준 17298번 오큰수  (0) 2023.01.20
[C++]/백준 1325번 효율적인 해킹  (0) 2023.01.20
[C++]/백준 2636번 치즈  (0) 2023.01.20
728x90
반응형

블루스택에서 빌드된 앱이 실행되지 않아 로그캣으로 확인해본 결과 이렇게 뜬다. 해결법은 간단한데

Project Settings > Resolution and Presentation 에서 Optimized Frame Pacing을 비활성화 해주면 된다.

728x90
반응형
728x90
반응형

23.3월 ~ 23.11월 까지의 잔디

지난날의 내 잔디가 전부 사라졌다. 퇴사하게 되면서 프로젝트에서 제외됨으로서 잔디가 모두 사라졌다..

728x90
반응형

'일상' 카테고리의 다른 글

2025.01.15 기술 면접 피드백  (0) 2025.01.15

+ Recent posts