www.acmicpc.net/problem/14500

 

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

처음엔 경우의 수를 적게 생각하고 풀어서 계속 틀린 문제이다.

 

천천히 대칭을 포함한 경우의 수 19가지를 생각하고 그에 맞게 최대값을 구해주었다.

 

나 같은 경우에는 크게 5가지로 나누었다.

 

네모 모양 1가지 경우의 수를 계산하고

 

3개짜리 테트리스에 1개를 모든 방향에 붙인다는 생각으로 크게 2가지, 작게 7가지씩 14가지를 구성하였고

 

또한 2개짜리에 2개를 붙이는 경우를 2개씩 총 4가지를 계산해주었다.

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

int map[501][501];
int N, M, ans, temp;

int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	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 - 1; i++) {	// 네모모양 계산
		for (int j = 0; j < M - 1; j++) {
			ans = max(ans, map[i][j] + map[i + 1][j + 1] + map[i + 1][j] + map[i][j + 1]);
		}
	}
	for (int i = 0; i < N - 2; i++) {	//세로 3개짜리에 1개 붙이기
		for (int j = 0; j < M; j++) {
			temp = map[i][j] + map[i + 1][j] + map[i + 2][j];
			if (i + 3 < N) {
				ans = max(ans, temp + map[i + 3][j]);
			}
			if (j - 1 >= 0) {
				ans = max(ans, temp + map[i][j - 1]);
				ans = max(ans, temp + map[i + 1][j - 1]);
				ans = max(ans, temp + map[i + 2][j - 1]);
			}
			if (j + 1 < M) {
				ans = max(ans, temp + map[i][j + 1]);
				ans = max(ans, temp + map[i + 1][j + 1]);
				ans = max(ans, temp + map[i + 2][j + 1]);
			}
		}
	}
	for (int i = 0; i < N; i++) {	//가로 3개짜리에 1개 붙이기
		for (int j = 0; j < M - 2; j++) {
			temp = map[i][j] + map[i][j + 1] + map[i][j + 2];
			if (j + 3 < M) {
				ans = max(ans, temp + map[i][j + 3]);
			}
			if (i - 1 >= 0) {
				ans = max(ans, temp + map[i - 1][j]);
				ans = max(ans, temp + map[i - 1][j + 1]);
				ans = max(ans, temp + map[i - 1][j + 2]);
			}
			if (i + 1 < N) {
				ans = max(ans, temp + map[i + 1][j]);
				ans = max(ans, temp + map[i + 1][j + 1]);
				ans = max(ans, temp + map[i + 1][j + 2]);
			}
		}
	}
	for (int i = 0; i < N - 2; i++) {	//세로 2개짜리에 2개 붙이기
		for (int j = 0; j < M; j++) {
			temp = map[i][j] + map[i + 1][j];
			if (j - 1 >= 0) {
				ans = max(ans, temp + map[i+1][j - 1] + map[i + 2][j - 1]);
			}
			if (j + 1 < M) {
				ans = max(ans, temp + map[i+1][j + 1] + map[i + 2][j + 1]);
			}
		}
	}
	for (int i = 0; i < N; i++) {		//가로 2개짜리에 2개 붙이기
		for (int j = 0; j < M - 2; j++) {
			temp = map[i][j] + map[i][j + 1];
			if (i + 1 < N) {
				ans = max(ans, temp + map[i + 1][j + 1] + map[i + 1][j + 2]);
			}
			if (i - 1 >= 0) {
				ans = max(ans, temp + map[i - 1][j + 1] + map[i - 1][j + 2]);
			}
		}
	}
	cout << ans << "\n";
}

www.acmicpc.net/problem/3190

 

3190번: 뱀

 'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

삼성 기출문제를 풀기 시작하여 첫문제로 정한 구현문제이다.

 

처음엔 조건을 보고 약간 겁먹었는데

 

천천히 조건을 보고 각 칸을 뱀의 몸, 사과, 빈 공간, 벽으로 나누었고

 

뱀은 덱을 사용해 구현하였다.

 

또한 다음 위치를 항상 저장하고 방향변수 및 시간 변수를 사용해서 풀었고

 

방향 전환을 할때 현재 방향을 고려하여 방향을 바꿔주었다.

 

#define _CRT_SECURE_NO_WARINGS
#include <iostream>
#include <deque>
#include <vector>
#include <algorithm>
using namespace std;

int N, K, L, cnt;		//기본 변수 3개, 시간변수
int dv, tv;		//방향변수, 방향전환 벡터 위치변수
int map[102][102];
deque<pair<int, int>> snake;
vector <pair<int, char>> v;

int main() {
	int a, b;
	char c;
	cin >> N;
	cin >> K;
	for (int i = 0; i < K; i++) {
		cin >> a >> b;
		map[a][b] = 1;
	}
	cin >> L;
	for (int i = 0; i < L; i++) {
		cin >> a >> c;
		v.push_back({ a,c });
	}
	a = 1, b = 2;
	snake.push_back({ 1, 1 });	//초기 뱀 세팅
	map[1][1] = 3;
	for (int i = 0; i <= N + 1; i++) {	//초기 벽 세팅
		map[0][i] = 2;
		map[i][0] = 2;
		map[i][N + 1] = 2;
		map[N + 1][i] = 2;
	}
	while (1) {
		snake.push_front({ a,b });	//뱀 머리 넣기
		cnt++;
		if (map[a][b] == 0) {		//공간이 빈 경우
			map[snake.front().first][snake.front().second] = 3;
			map[snake.back().first][snake.back().second] = 0;
			snake.pop_back();
		}
		else if (map[a][b] == 1) {		//사과가 있는 경우
			map[snake.front().first][snake.front().second] = 3;
		}
		else {		//뱀의 몸이나 벽일 경우
			break;
		}
		if (tv < v.size() && cnt == v[tv].first) {		//방향전환
			if (v[tv].second == 'L') {		//왼쪽
				if (dv == 0) {
					dv = 3;
				}
				else {
					dv -= 1;
				}
			}
			else {		//오른쪽
				if (dv == 3) {
					dv = 0;
				}
				else {
					dv += 1;
				}
			}
			tv++;
		}
		if (dv == 0) {		//다음 칸 이동
			b++;
		}
		else if (dv == 1) {
			a++;
		}
		else if (dv == 2) {
			b--;
		}
		else {
			a--;
		}
	}
	cout << cnt << "\n";
	return 0;
}

www.acmicpc.net/problem/13458

 

13458번: 시험 감독

첫째 줄에 시험장의 개수 N(1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄에는 각 시험장에 있는 응시자의 수 Ai (1 ≤ Ai ≤ 1,000,000)가 주어진다. 셋째 줄에는 B와 C가 주어진다. (1 ≤ B, C ≤ 1,000,000)

www.acmicpc.net

쉬운 문제임에도 불구하고 시간초과와 변수 크기 때문에 꽤나 애먹었다..

 

또한 올림/내림 함수를 까먹어서 찾았고 또한 int형 숫자 두개를 나누면 절대 double형으로 결과값이 나오지 않는 다는 것도 알게 되었다.

 

오랜만에 푸는 문제였는데 브론즈임에도 불구하고 유의해야 할 점이 많이 있어서 기록하게 되었다.

 

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

long long N, A, B, ans;
double C;
vector<double> lec;

int main() {
	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> A;
		lec.push_back(A);
	}
	cin >> B >> C;
	ans += N;
	for (int i = 0; i < N; i++) {
		lec[i] -= B;
		if (lec[i] > 0) {
			ans += ceil(lec[i] / C);
		}
	}
	cout << ans << "\n";
	return 0;
}

'알고리즘 공부 > C++' 카테고리의 다른 글

[C++] 백준 14500번: 테트로미노  (0) 2021.03.25
[C++] 백준 3190번: 뱀  (0) 2021.03.19
[C++] 백준 1992번: 쿼드트리  (0) 2020.11.30
[C++] 백준 2583번: 영역 구하기  (0) 2020.11.30
[C++] 백준 2343번: 기타 레슨  (0) 2020.11.30

www.acmicpc.net/problem/1992

 

1992번: 쿼드트리

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1≤N ≤64의 범위를 가진다. 두 번째 줄부터는 길이 N 의 문자열이 N 개 들어온다. 각 문자열은 0 또는

www.acmicpc.net

분할 정복의 대표격인 문제인 쿼드 트리이다.

 

예전에 프로그래머스 월간 챌린지에서 비슷한 문제가 나온적이 있었다. 그땐 개념을 제대로 몰라 막 풀었는데 이번에는 재귀를 사용해서 푸는 법을 알게 되어 이를 사용해 풀 수 있었다.

 

괄호를 넣어줘야되는 부분이 좀 까다로워서 고민을 많이 했는데 함수 호출전에 미리 넣어주는 방식으로 해결할 수 있었다.

 

이전에 Z라는 문제를 풀었는데 그때 답지를 보며 공부한 것이 크게 도움되었다.

 

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int N;
int quad[65][65];
string ans;

void dfs(int x, int y, int z) {
	int check = 0;
	for (int i = x; i < x + z; i++) {
		for (int j = y; j < y + z; j++) {
			if (quad[x][y] != quad[i][j]) {
				check = 1;
				break;
			}
		}
	}
	if (check == 0) {
		ans += to_string(quad[x][y]);
	}
	else {
		z = z / 2;
		ans += "(";
		if (z == 1) {
			ans += to_string(quad[x][y]);
			ans += to_string(quad[x][y + 1]);
			ans += to_string(quad[x + 1][y]);
			ans += to_string(quad[x + 1][y + 1]);
		}
		else {
			dfs(x, y, z);
			dfs(x, y + z, z);
			dfs(x + z, y, z);
			dfs(x + z, y + z, z);
		}
		ans += ")";
	}
	return;
}

int main() {
	int c = 0;
	scanf("%d", &N);
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			scanf("%1d", &quad[i][j]);
		}
	}
	dfs(0, 0, N);
	cout << ans;
	return 0;
}

www.acmicpc.net/problem/2583

 

2583번: 영역 구하기

첫째 줄에 M과 N, 그리고 K가 빈칸을 사이에 두고 차례로 주어진다. M, N, K는 모두 100 이하의 자연수이다. 둘째 줄부터 K개의 줄에는 한 줄에 하나씩 직사각형의 왼쪽 아래 꼭짓점의 x, y좌표값과 오

www.acmicpc.net

처음엔 모눈종이가 거꾸로 되있고 좌표로 직사각형을 입력받아야해서 조금 생각을 해야했다.

 

하지만 그 후엔 그냥 단순히 DFS를 구현하면 되는 쉬운 문제였다.

 

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

int m, n, k, cnt;
int map[101][101];
int visit[101][101];
vector<int> ans;
int dx[4] = { 0, 1, 0, -1 };
int dy[4] = { 1,0,-1,0 };

void dfs(int a, int b) {
	cnt++;
	for (int i = 0; i < 4; i++) {
		if (a + dx[i] >= 0 && a + dx[i] < n 
			&& b + dy[i] >= 0 && b +dy[i] < m
			&& visit[a + dx[i]][b + dy[i]] == 0 && map[a + dx[i]][b + dy[i]] == 0) {
			visit[a + dx[i]][b + dy[i]] = 1;
			dfs(a + dx[i], b + dy[i]);
		}
	}
	return;
}

int main() {
	int a, b, c, d;
	cin >> m >> n >> k;
	for (int i = 0; i < k; i++) {
		cin >> a >> b >> c >> d;
		for (int j = a; j < c; j++) {
			for (int k = b; k < d; k++) {
				map[j][k] = 1;
			}
		}
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			if (visit[i][j] == 0 && map[i][j] == 0) {
				visit[i][j] = 1;
				cnt = 0;
				dfs(i, j);
				ans.push_back(cnt);
			}
		}
	}
	sort(ans.begin(), ans.end());
	cout << ans.size() << "\n";
	for (int i = 0; i < ans.size(); i++) {
		cout << ans[i] << " ";
	}
	return 0;
}

www.acmicpc.net/problem/2343

 

2343번: 기타 레슨

강토는 자신의 기타 레슨 동영상을 블루레이로 만들어 판매하려고 한다. 블루레이에는 총 N개의 레슨이 들어가는데, 블루레이를 녹화할 때, 레슨의 순서가 바뀌면 안 된다. 순서가 뒤바뀌는 경

www.acmicpc.net

처음엔 정렬되지 않은 벡터를 이분탐색을 어떻게 진행하지 고민했었던 문제이다. 예전에 L사 코테를 봤을 때 나왔던 문제랑 매우 유사해서 꼭 풀어보고 싶었다!

 

다소 좀 생소한 이분 탐색 유형인 것 같아 고민을 좀 했었는데 반례 모음을 보고 풀 수 있었다.

 

이분 탐색을 진행할때 left와 right의 초기 값에도 신경을 써야된다는 것을 알 수 있었다.

 

참고한 반례모음: bingorithm.tistory.com/10

 

"백준 2343번-기타 레슨" 반례 모음

www.acmicpc.net/problem/2343 2343번: 기타 레슨 강토는 자신의 기타 레슨 동영상을 블루레이로 만들어 판매하려고 한다. 블루레이에는 총 N개의 레슨이 들어가는데, 블루레이를 녹화할 때, 레슨의 순서

bingorithm.tistory.com

 

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cmath>
#include <queue>
#include <algorithm>
using namespace std;

int n, m;
long long sum[100001];

int main() {
	int x;
	vector<int> v;
	cin >> n >> m;
	for (int i = 0; i < n; i++) {
		cin >> x;
		v.push_back(x);
	}
	int left = *max_element(v.begin(), v.end());
	int right = 10000 * n;

	while (left <= right) {
		int c = 1;
		int mid = (left + right) / 2;
		for (int i = 0; i < v.size(); i++) {
			sum[c] += v[i];
			if (sum[c] > mid) {
				sum[c] -= v[i];
				c++;
				sum[c] += v[i];
			}
		}
		if (c > m) {
			left = mid + 1;
		}
		else {
			right = mid - 1;
		}
		for (int i = 1; i <= m; i++) {
			sum[i] = 0;
		}
	}
	cout << left;
	return 0;
}

www.acmicpc.net/problem/2665

 

2665번: 미로만들기

첫 줄에는 한 줄에 들어가는 방의 수 n(1≤n≤50)이 주어지고, 다음 n개의 줄의 각 줄마다 0과 1이 이루어진 길이가 n인 수열이 주어진다. 0은 검은 방, 1은 흰 방을 나타낸다.

www.acmicpc.net

첨에 어떻게 접근할 지 고민하다가 방금 푼 문제였던 벽 부수고 이동하기의 코드를 활용해서 풀었다.

 

사실 최솟값이 필요없기 때문에 좀 비효율적으로 코드를 짠 것 같아서 좀 아쉽다..

 

다음에 풀 때는 그 전의 바꾼 방갯수를 비교해서 최신화하는 식을 짜봐야겠다..

 

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <queue>
using namespace std;

struct map {
    int x, y, w;
};

int n, ans = -1;
int a[51][51];
int dist[51][51][100];
const int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, 1, 0, -1 };

int bfs(int b) {
    queue<map> q;
    q.push({ 0, 0, 0 });
    dist[0][0][0] = 1;
    while (!q.empty()) {
        int x = q.front().x;
        int y = q.front().y;
        int w = q.front().w;
        q.pop();
        if (x == n - 1 && y == n - 1) {
            return dist[x][y][w];
        }
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            if (dist[nx][ny][w]) continue;
            if (a[nx][ny] == 1) {
                dist[nx][ny][w] = dist[x][y][w] + 1;
                q.push({ nx, ny, w });
            }
            if (a[nx][ny] == 0 && w < b) {
                dist[nx][ny][w+1] = dist[x][y][w] + 1;
                q.push({ nx, ny, w+1 });
            }
        }
    }
    return -1;
}

int main() {
    int b = 0;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%1d", &a[i][j]);
        }
    }
    while (1) {
        ans = bfs(b);
        if (ans >= 0) {
            printf("%d", b);
            break;
        }
        else {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    for (int k = 0; k <= b; k++) {
                        dist[i][j][k] = 0;
                    }
                }
            }
        }
        b++;
    }
    return 0;
}

www.acmicpc.net/problem/2206

 

2206번: 벽 부수고 이동하기

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

www.acmicpc.net

정말 고민을 많이 한 문제였는데.. 접근방식이 계속 틀린 것이 문제였다...

 

BFS에 다가 자신의 상태를 저장을 해주어야 하는데 그 생각을 못하고 시작점과 끝점에서 BFS를 두번돌려서 만나는 지점이 같으면 벽을 부수는 걸로 접근을 했었다.

 

답지를 보기 싫었는데 결국 보게 되서 좀 아쉬운 문제였고 아직 멀었구나 느꼈다..

 

참고 블로그: rebas.kr/658

 

BOJ 2206 · 벽 부수고 이동하기

알고리즘 분류 : BFS  BFS를 통해 최단 거리를 구할 수 있는 문제다. 미로 탐색에서 약간 변형된 문제이며, 벽을 최대 1개만 부셔서 이동할 수 있다. 벽을 부수지 않거나(0), 벽을 1개 부시는(1) 경우

rebas.kr

이 블로그의 해답이 제일 깔끔하고 이해가 잘되었다.

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <queue>
using namespace std;

struct map {
    int x, y, w;
};

int n, m;
int a[1001][1001];
int dist[1001][1001][2];
const int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, 1, 0, -1 };

int bfs() {
    queue<map> q;
    q.push({ 0, 0, 0 });
    dist[0][0][0] = 1;
    while (!q.empty()) {
        int x = q.front().x;
        int y = q.front().y;
        int w = q.front().w;
        q.pop();
        if (x == n - 1 && y == m - 1) {
            return dist[x][y][w];
        }
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (dist[nx][ny][w]) continue;
            if (a[nx][ny] == 0) {
                dist[nx][ny][w] = dist[x][y][w] + 1;
                q.push({ nx, ny, w });
            }
            if (a[nx][ny] == 1 && w == 0) {
                dist[nx][ny][1] = dist[x][y][w] + 1;
                q.push({ nx, ny, 1 });
            }
        }
    }
    return -1;
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%1d", &a[i][j]);
        }
    }
    printf("%d", bfs());
    return 0;
}

www.acmicpc.net/problem/9663

 

9663번: N-Queen

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

www.acmicpc.net

백트래킹의 대표적인 문제이다.

 

처음엔 2차원배열로 풀려고 했는데 결국 실패해서 힌트를 보고 풀 수 있었다. 어차피 하나의 열과 하나의 행에 하나의 퀸만 놓을 수 있기 떄문에 1차원 배열로 풀 수 있는 문제였다.

 

대각선 처리가 좀 까다로웠는데 각 행의 차이와 열의 차이가 동일하지 않는 다는 것을 아는 것이 포인트였다.

 

참고: chanhuiseok.github.io/posts/baek-1/

 

[백준] 9663번 - N-Queen

컴퓨터/IT/알고리즘 정리 블로그

chanhuiseok.github.io

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

int N, ans;
int map[16];

void dfs(int cnt) {
	int check = 0;
	if (cnt == N) {
		ans++;
		return;
	}
	for (int i = 0; i < N; i++) {
		map[cnt] = i;
		for (int j = 0; j < cnt; j++) {
			if (map[j] == map[cnt] || cnt - j == abs(map[cnt] - map[j])) {
				check = 1;
				break;
			}
		}
		if (check == 0) {
			dfs(cnt + 1);
		}
		else {
			check = 0;
		}
	}

}

int main() {
	cin >> N;
	dfs(0);
	cout << ans;
	return 0;
}

www.acmicpc.net/problem/17070

 

17070번: 파이프 옮기기 1

유현이가 새 집으로 이사했다. 새 집의 크기는 N×N의 격자판으로 나타낼 수 있고, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 (r, c)로 나타낼 수 있다. 여기서 r은 행의 번호, c는 열의

www.acmicpc.net

문제 자체는 DP로 분류되어 있었는데 dfs로 푸니까 간단하게 풀린 문제였다.

 

처음에 DP로 풀려고 하다가 시간을 많이 사용했는데 이런걸 생각하면 너무 분류에 집중해서 풀지 않아도 될 것 같다!

 

푸는 방법은 일단 파이프를 가로, 세로, 대각선 3가지 모드가 있다고 생각하고 각 모드에 맞게 모든 경우의 수를 진행해주었다. 크기가 최대 16*16이라 DFS가 터지지 않을 것 같았다.

 

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

int n, ans;
int map[17][17];

void dfs(int x, int y, int mode) {
	if (x == n && y == n) {
		ans++;
		return;
	}
	if (mode == 0 || mode == 2) {
		if (y + 1 <= n && map[x][y + 1] == 0) {
			dfs(x, y + 1, 0);
		}
	}
	if (mode == 1 || mode == 2) {
		if (x + 1 <= n && map[x + 1][y] == 0) {
			dfs(x + 1, y, 1);
		}
	}
	if (x + 1 <= n && y + 1 <= n && map[x + 1][y + 1] == 0 
		&& map[x][y+1] == 0 && map[x+1][y] == 0) {
		dfs(x + 1, y + 1, 2);
	}
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> map[i][j];
		}
	}
	dfs(1, 2, 0);
	cout << ans;
	return 0;
}

+ Recent posts