아무거나 내꺼 공부할래

[개념] 네트워크 선 자르기(Top-Down, 재귀, 메모이제이션) / c++ & c / 제한시간 없음

mero95 — Sat, 27 Feb 2021 14:05:36 +0900

▣ 문제

현수는 네트워크 선을 1m, 2m의 길이를 갖는 선으로 자르려고 합니다. 예를 들어 4m의 네트워크 선이 주어진다면

의 5가지 방법을 생각할 수 있습니다. (2)와 (3)과 (4)의 경우 왼쪽을 기준으로 자르는 위치가 다르면 다른 경우로 생각한다.

그렇다면 네트워크 선의 길이가 Nm라면 몇 가지의 자르는 방법을 생각할 수 있나요?

▣ 입력설명

- 첫째 줄은 네트워크 선의 총 길이인 자연수 N(3≤N≤45)이 주어집니다.

▣ 출력설명

- 첫 번째 줄에 부분증가수열의 최대 길이를 출력한다.

▣ 입력 예시

▣ 출력 예시

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
using namespace std;

int dy[101];

int dfs(int n) {
	if (dy[n] != 0) return dy[n];
	if (n == 1 || n == 2) return n;
	else {
		return dy[n] = dfs(n - 1) + dfs(n - 2);
	}
}

int main() {
	int n;
	scanf("%d", &n);
	printf("%d\n", dfs(n));

	return 0;
}

동적계획법(Dynamic Programming)은 Top-Down 형식으로도 문제를 해결할 수 있다.

Top-Down 방식으로 풀기 위해서는 재귀와 메모이제이션을 이용한다.

Bottom-Up에서는 제일 큰 문제에서 작은 문제로 나눠서 푸는 방식이다.

입력 예시를 예로 들어서 7M짜리 선을 먼저 생각해보면

제일 끝부분이 1M일떄 또는 2M일때로 나눠보면

		남은길이(6M)
		남은길이(5M)

가 될것이다.

이제 DFS함수를 사용해 6M짜리와 5M짜리도 계속해서 나눠준다.

DFS 결과

이때 중요 포인트는 D(1)와 D(2)를 통해 얻은 D(3)를 dy[ ]에 저장을 해줌으로써 다음 탐색을 할때 재사용을 할수 있게끔 해주는 방식이다(if (dy[n] != 0) return dy[n];).

이것이 메모이제이션이라 하고 이를 통해 시간을 훨씬 단축할 수 있다.

[개념] 네트워크 선 자르기(Bottom-Up, DP) / c++ & c / 제한시간 없음

mero95 — Sat, 27 Feb 2021 13:49:03 +0900

▣ 문제

현수는 네트워크 선을 1m, 2m의 길이를 갖는 선으로 자르려고 합니다. 예를 들어 4m의 네트워크 선이 주어진다면

의 5가지 방법을 생각할 수 있습니다. (2)와 (3)과 (4)의 경우 왼쪽을 기준으로 자르는 위치가 다르면 다른 경우로 생각한다.

그렇다면 네트워크 선의 길이가 Nm라면 몇 가지의 자르는 방법을 생각할 수 있나요?

▣ 입력설명

- 첫째 줄은 네트워크 선의 총 길이인 자연수 N(3≤N≤45)이 주어집니다.

▣ 출력설명

- 첫 번째 줄에 부분증가수열의 최대 길이를 출력한다.

▣ 입력 예시

▣ 출력 예시

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
using namespace std;

int dy[50];
int main() {
	int n;
	scanf("%d", &n);
	dy[1] = 1;
	dy[2] = 2;
	for (int i = 3; i <= n; i++) {
		dy[i] = dy[i - 1] + dy[i - 2];
	}
	printf("%d\n", dy[n]);

	return 0;
}

동적계획법(Dynamic Programming)이란 하나의 문제를 해결할 때 작은 문제를 큰 문제로 분할한 후 작은 문제를 해결한 결과를 저장해 큰 문제의 결과와 합치는 방식이다.

고등학교 수학에서 점화식을 생각하면 될것같다.

위 코드는 Bottom-Up 방식으로 문제를 풀었다.

Bottom-Up 방식은 문제에서 직관적으로 풀 수 있는 작은 문제를 푼다. 이를 통해 얻은 결과값으로 점화식을 세운후 반복문을 통해서 큰 문제로 확장시키는 것이다.

문제에서 선은 1m 또는 2m의 길이로 자른다고 한다. 그렇다면 1m의 선을 자를수 있는 방법은 1가지 2m의 선을 자를수 있는 방법은 2가지다 된다.

이러한 직관적인 결과를 구한 후 3m 짜리 선을 생각해보면 네트워크 선 제일 끝부분을 기준으로 1m를 이미 잘랐다고 가정한다.

남은 선 길이 (2M)

남은 선 길이 2M는 이전에 2가지 방법이 있다는점을 이용한다.

다음으로 네트워크 선 제일 끝부분 2M를 잘랐다고 가정한다.

남은 선 길이 (1M)

남은 선 길이 1M는 이전에 1가지 방법이 있다는 점을 이용한다.

결과적으로 3M 짜리 선의 가지수 = 2M 짜리 선의 가지수 + 1M 짜리 선의 가지수 라는 것을 알수있다.

이를 통해 점화식을 구하면 f(n) = f(n-1) + f(n-2) 를 알 수 있다.

[BJ] 1182번 : 부분수열의 합(재귀,DFS) /c++ & c / 제한시간 : 2초

mero95 — Thu, 25 Feb 2021 15:01:00 +0900

www.acmicpc.net/problem/1182

1182번: 부분수열의 합

첫째 줄에 정수의 개수를 나타내는 N과 정수 S가 주어진다. (1 ≤ N ≤ 20, |S| ≤ 1,000,000) 둘째 줄에 N개의 정수가 빈 칸을 사이에 두고 주어진다. 주어지는 정수의 절댓값은 100,000을 넘지 않는다.

www.acmicpc.net

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
using namespace std;

int ch[20];
int num[20];
int n, s, cnt = 0;

void partition(int level) {
	int i, temp = 0, check = 0;
	if (level == n) {
		for (i = 0; i < level; i++) {
			if (ch[i] == 1) {
				temp += num[i];
			}
			else check++;
		}
		if (check == level) return;
		if (temp == s)cnt++;
		return;
	}
	else {
		ch[level] = 1;
		partition(level + 1);
		ch[level] = 0;
		partition(level + 1);
	}
}

int main() {
	int i;
	scanf("%d %d", &n, &s);
	for (i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}

	partition(0);
	printf("%d\n", cnt);
	return 0;
}

각 레벨마다 num[level]값의 ch를 하나는 '1'로 나머지는 '0'으로 저장한다.

level == n 이 되었을때 ch[ ]값이 1인 것들만 temp에 더해주면

수열의 부분집합으로 표시할 수 있다. 결과값이 s와 같다면 cnt++

partition 함수에서 check는 공집합을 뜻한다. 즉, 모든 원소, num[ ],들의 ch 값이 0인것들은 cnt하기 직전에 return을 시켜준다.

이진트리 레벨 탐색의 개념을 사용함

[BJ] 1992번 : 쿼드트리(재귀) / c++ & c / 제한시간 : 2초

mero95 — Thu, 25 Feb 2021 14:05:33 +0900

www.acmicpc.net/problem/1992

1992번: 쿼드트리

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

www.acmicpc.net

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
using namespace std;

char map[65][65];
int n, p = 0;
char ans[100000];

void compress(int x, int y, int edge) {
	char temp; 
	int i, j;
	temp = map[x][y];
	if (edge == 1) {
		if (temp == '1')ans[p++] = '1';
		else ans[p++] = '0';
		return;
	}

	for (i = x; i < x + edge; i++) {
		for (j = y; j < y + edge; j++) {
			if (temp != map[i][j]) {
				ans[p++] = '(';
				compress(x, y, edge / 2);
				compress(x, y + edge / 2, edge / 2);
				compress(x + edge / 2, y, edge / 2);
				compress(x + edge / 2, y + edge / 2, edge / 2);
				ans[p++] = ')';
				return;
			}
		}
	}
	if (temp == '1') ans[p++] = '1';
	else ans[p++] = '0';
	return;
}

int main() {
	int i;
	scanf("%d", &n);
	for (i = 0; i < n; i++)
			scanf("%s", &map[i]);

	compress(0, 0, n);
	for (i = 0; i < p; i++) {
		printf("%c", ans[i]);
	}
	puts("");
	return 0;
}

[BJ] 14889번 : 스타트와 링크 / c++ / 제한시간 : 2초

mero95 — Wed, 24 Feb 2021 17:41:20 +0900

▣ 문제

- 오늘은 스타트링크에 다니는 사람들이 모여서 축구를 해보려고 한다. 축구는 평일 오후에 하고 의무 참석도 아니다. 축구를 하기 위해 모인 사람은 총 N명이고 신기하게도 N은 짝수이다. 이제 N/2명으로 이루어진 스타트 팀과 링크 팀으로 사람들을 나눠야 한다.

BOJ를 운영하는 회사 답게 사람에게 번호를 1부터 N까지로 배정했고, 아래와 같은 능력치를 조사했다. 능력치 Sij는 i번 사람과 j번 사람이 같은 팀에 속했을 때, 팀에 더해지는 능력치이다. 팀의 능력치는 팀에 속한 모든 쌍의 능력치 Sij의 합이다. Sij는 Sji와 다를 수도 있으며, i번 사람과 j번 사람이 같은 팀에 속했을 때, 팀에 더해지는 능력치는 Sij와 Sji이다.

N=4이고, S가 아래와 같은 경우를 살펴보자.

i / j	1	2	3	4
1		1	2	3
2	4		5	6
3	7	1		2
4	3	4	5

예를 들어, 1, 2번이 스타트 팀, 3, 4번이 링크 팀에 속한 경우에 두 팀의 능력치는 아래와 같다.

스타트 팀: S12 + S21 = 1 + 4 = 5
링크 팀: S34 + S43 = 2 + 5 = 7

1, 3번이 스타트 팀, 2, 4번이 링크 팀에 속하면, 두 팀의 능력치는 아래와 같다.

스타트 팀: S13 + S31 = 2 + 7 = 9
링크 팀: S24 + S42 = 6 + 4 = 10

축구를 재미있게 하기 위해서 스타트 팀의 능력치와 링크 팀의 능력치의 차이를 최소로 하려고 한다. 위의 예제와 같은 경우에는 1, 4번이 스타트 팀, 2, 3번 팀이 링크 팀에 속하면 스타트 팀의 능력치는 6, 링크 팀의 능력치는 6이 되어서 차이가 0이 되고 이 값이 최소이다.

▣ 입력설명

- 첫째 줄에 N(4 ≤ N ≤ 20, N은 짝수)이 주어진다. 둘째 줄부터 N개의 줄에 S가 주어진다. 각 줄은 N개의 수로 이루어져 있고, i번 줄의 j번째 수는 Sij 이다. Sii는 항상 0이고, 나머지 Sij는 1보다 크거나 같고, 100보다 작거나 같은 정수이다.

▣ 출력설명

- 첫째 줄에 스타트 팀과 링크 팀의 능력치의 차이의 최솟값을 출력한다.

▣ 입력 예시

4
0 1 2 3
4 0 5 6
7 1 0 2
3 4 5 0

▣ 출력 예시

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
#include<cmath>
#include<algorithm>
using namespace std;

int map[21][21];
int ch[21];
int Apath[21];
int Bpath[21];
int num[21];
int n, mini = 2147000000;

void dfs(int start, int level) {
	int i, j;
	if (level == n/2) {
		int A = 0, B = 0, temp, h=0;

		for (j = 1; j <= n; j++) {
			if (ch[j] == 0) Bpath[h++] = j;
		}
		for (i = 0; i < level; i++) {
			for (j = 0; j < level; j++) {
				A += map[Apath[i]][Apath[j]];
				B += map[Bpath[i]][Bpath[j]];
			}
		}
		temp = abs(A - B);
		if (temp < mini) mini = temp;

	}
	else {
		for (i = start; i <= n; i++) {
			Apath[level] = num[i];
			ch[num[i]] = 1;
			dfs(i + 1, level + 1);
			ch[num[i]] = 0;
		}
	}
}

int main() {
	int i, j, a;
	scanf("%d", &n);
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= n; j++) {
			scanf("%d", &map[i][j]);
		}
	}
	for (i = 1; i <= n; i++) {
		num[i] = i;
	}
	dfs(1, 0);
	printf("%d\n", mini);
	return 0;
}

num[ ] : 사람들 번호

Apath[ ] : A팀에 속한 사람들

Bpath[ ] : B팀에 속한 사람들

조합(Combination)을 이용해서 양쪽 팀을 나누고 해당 팀에 속하는 선수들의 능력치를 더해준다.

min값을 설정해서 차이가 제일 작은 값을 출력

[BJ] 토마토(BFS) / c++ / 제한시간 : 1초

mero95 — Tue, 23 Feb 2021 16:00:45 +0900

▣ 문제

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자 모양 상자의 칸에 하나씩 넣어서 창고에 보관한다.

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토의 인접한 곳은 왼쪽, 오른쪽, 앞, 뒤 네 방향에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지, 그 최소 일수를 알고 싶어 한다.

토마토를 창고에 보관하는 격자모양의 상자들의 크기와 익은 토마토들과 익지 않은 토마토들의 정보가 주어졌을 때, 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

▣ 입력설명

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 상자에 담긴 토마토의 정보가 주어진다. 하나의 줄에는 상자 가로줄에 들어있는 토마토의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다.

토마토가 하나 이상 있는 경우만 입력으로 주어진다.

▣ 출력설명

여러분은 토마토가 모두 익을 때까지의 최소 날짜를 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

▣ 입력 예시

6 4
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 1

▣ 출력 예시

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;

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

struct cur {
	int x;
	int y;
	cur(int a, int b) {
		x = a;
		y = b;
	}
};

int main() {
	int n, m, i, j, max = -2147000000, ch = 0;
	queue<cur> Q;
	scanf("%d %d", &m, &n);
	for (i = 1; i <= n; i++)
		for (j = 1; j <= m; j++)
			scanf("%d", &map[i][j]);
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			if (map[i][j] != 0) ch++;
		}
	}
	if (ch == n * m) {
		printf("0\n");
		return 0;
	}
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			if (map[i][j] == 1) Q.push(cur(i, j));
		}
	}

	while (!Q.empty()) {
		cur pos = Q.front();
		Q.pop();
		for (int k = 0; k < 4; k++) {
			int xx, yy;
			xx = pos.x + dx[k];
			yy = pos.y + dy[k];
			if (xx<1 || xx>n || yy<1 || yy>m) continue;
			if (map[xx][yy] == 0) {
				map[xx][yy] = map[pos.x][pos.y] + 1;
				if (map[xx][yy] > max)max = map[xx][yy];
				Q.push(cur(xx, yy));
			}
		}
	}
	ch = 0;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			if (map[i][j] == 0) ch++;
		}
	}
	if (ch != 0) {
		printf("-1\n");
		return 0;
	}
	printf("%d\n", max - 1);
	return 0;
}

인프런에서 하던 BFS유형과 비슷한 백준문제

www.acmicpc.net/problem/7576

미로의 최단거리 통로(BFS) / c++ / 제한시간 없음

mero95 — Tue, 23 Feb 2021 15:06:18 +0900

▣ 문제

7*7 격자판 미로를 탈출하는 최단경로의 경로수를 출력하는 프로그램을 작성하세요. 경로수는 출발점에서 도착점까지 가는데 이동한 횟수를 의미한다. 출발점은 격자의 (1, 1) 좌표이고, 탈 출 도착점은 (7, 7)좌표이다. 격자판의 1은 벽이고, 0은 도로이다. 격자판의 움직임은 상하좌우로만 움직인다. 미로가 다음과 같다면

위와 같은 경로가 최단 경로이며 경로수는 12이다.

▣ 입력설명

- 첫 번째 줄부터 7*7 격자의 정보가 주어집니다.

▣ 출력설명

- 첫 번째 줄에 최단으로 움직인 칸의 수를 출력한다. 도착할 수 없으면 -1를 출력한다.

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;

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

struct cur {
	int x;
	int y;
	cur(int a, int b) {
		x = a;
		y = b;
	}
};

int main() {
	int i, j, cnt = 1, ans = 0;
	queue<cur> Q;
	for (i = 1; i <= 7; i++)
		for (j = 1; j <= 7; j++)
			scanf("%d", &map[i][j]);

	Q.push(cur(1, 1));
	map[1][1] = 1;
	while (!Q.empty()) {
		int xx, yy;
		cur pos = Q.front();
		Q.pop();
		for (i = 0; i < 4; i++) { 
			xx = pos.x + dx[i];
			yy = pos.y + dy[i];
			if (xx < 1 || xx>7 || yy < 1 || yy>7) continue;
			if (map[xx][yy] == 0) {
				Q.push(cur(xx, yy));
				map[xx][yy] = map[pos.x][pos.y] + 1;
				if (xx == 7 && yy == 7) {
					ans = map[xx][yy];
					break;
				}
			}
		}
	}
	if (map[7][7] == 0) printf("-1\n");
	else printf("%d\n", ans - 1);
	return 0;
}

코드의 키포인트는 map[ ][ ]의 값에 BFS 탐색할떄 레벨값으로 바꿔서 저장시키는것이다.

한번 움직일때마다 이전 경로(Path)의 값보다 1씩 증가시키면 미로를 탐색하면서 BFS의 레벨값을 알 수 있다.

예전에 해보았던 유형이었음

미로 최단거리는 BFS로

섬나라 아일랜드(BFS) / c++ / 제한시간 없음

mero95 — Tue, 23 Feb 2021 14:16:46 +0900

▣ 문제

섬나라 아일랜드의 지도가 격자판의 정보로 주어집니다. 각 섬은 1로 표시되어 상하좌우와 대 각선으로 연결되어 있으며, 0은 바다입니다. 섬나라 아일랜드에 몇 개의 섬이 있는지 구하는 프로그램을 작성하세요.

만약 위와 같다면

▣ 입력설명

- 첫 번째 줄에 자연수 N(1<=N<=20)이 주어집니다. 두 번째 줄부터 격자판 정보가 주어진다.

▣ 출력설명

- 첫 번째 줄에 섬의 개수를 출력한다.

▣ 입력 예시

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

▣ 출력 예시

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;

struct cur {
	int x;
	int y;
	cur(int a, int b) {
		x = a;
		y = b;
	}
};
int map[21][21];
int dx[8] = { 0,1,1,1,0,-1,-1,-1 };
int dy[8] = { -1,-1,0,1,1,1,0,-1 };
int n;

int main() {
	int i, j, cnt = 0;
	scanf("%d", &n);
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= n; j++) {
			scanf("%d", &map[i][j]);
		}
	}
	queue<cur> Q;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <=n ; j++) {
			if (map[i][j] == 1) {
				Q.push(cur(i, j));
				map[i][j] = 0;
				while (!Q.empty()) {
					cur temp = Q.front();
					Q.pop();
					for (int k = 0; k < 8; k++) {
						int xx, yy;
						xx = temp.x + dx[k];
						yy = temp.y + dy[k];
						if (map[xx][yy] == 1) {
							Q.push(cur(xx, yy));
							map[xx][yy] = 0;
						}
					}
				}
				cnt++;
			}
		}
	}
	printf("%d\n", cnt);
	return 0;
}

map[ ][ ] 전체를 탐색하면서 1이 발견되면 큐(Queue)를 활용해 BFS를 사용한다. while문이 끝날떄마다 cnt++을 해준다.

비교적 간단한 예시의 BFS

구조체(Struct)를 사용하는법에 좀 더 익숙해져야 할듯

피자 배달 거리(삼성 SW역량평가, DFS) / c++ / 제한시간 없음

mero95 — Mon, 22 Feb 2021 17:10:49 +0900

▣ 문제

N×N 크기의 도시지도가 있습니다. 도시지도는 1×1크기의 격자칸으로 이루어져 있습니다. 각 격자칸에는 0은 빈칸, 1은 집, 2는 피자집으로 표현됩니다. 각 격자칸은 좌표(행번호, 열 번호) 로 표현됩니다. 행번호는 1번부터 N번까지이고, 열 번호도 1부터 N까지입니다.

도시에는 각 집마다 “피자배달거리”가 았는데 각 집의 피자배달거리는 해당 집과 도시의 존재 하는 피자집들과의 거리 중 최소값을 해당 집의 “피자배달거리”라고 한다. 집과 피자집의 피자배달거리는 |x1-x2|+|y1-y2| 이다. 예를 들어, 도시의 지도가 아래와 같다면

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

(1, 2)에 있는 집과 (2, 3)에 있는 피자집과의 피자 배달 거리는 |1-2| + |2-3| = 2가 된다. 최근 도시가 불경기에 접어들어 우후죽순 생겼던 피자집들이 파산하고 있습니다. 도시 시장은 도시에 있는 피자집 중 M개만 살리고 나머지는 보조금을 주고 폐업시키려고 합니다.

시장은 살리고자 하는 피자집 M개를 선택하는 기준으로 도시의 피자배달거리가 최소가 되는 M개의 피자집을 선택하려고 합니다.

도시의 피자 배달 거리는 각 집들의 피자 배달 거리를 합한 것을 말합니다.

▣ 입력설명

- 첫째 줄에 N(2 ≤ N ≤ 50)과 M(1 ≤ M ≤ 12)이 주어진다. 둘째 줄부터 도시 정보가 입력된다.

▣ 출력설명

- 첫째 줄에 M개의 피자집이 선택되었을 때 도시의 최소 피자배달거리를 출력한다

▣ 입력 예시

4 4
0 1 2 0
1 0 2 1
0 2 1 2
2 0 1 2

▣ 출력 예시

<코드>

#pragma warning(disable:4996)
#include<stdio.h>
#include<vector>
#include<cmath>
#include<algorithm>
#define x first
#define y second
using namespace std;

int n, m, ans, mini = 2147000000;
vector<pair<int, int> > pizza;
vector<pair<int, int> > house;
int visit[20];

void dfs(int s, int level) {
	int i, j;
	int sum = 0;
	int temp;
	if (level == m) {
		for (j = 0; j < house.size(); j++) {
			int dis = 2147000000;
			for (int k = 0; k < m; k++) {
				temp = abs(house[j].x - pizza[visit[k]].x) + abs(house[j].y - pizza[visit[k]].y);
				if (temp < dis)dis = temp;
			}
			sum += dis;
		}
		if (sum < mini)mini = sum;
	}
	else {
		for (i = s; i < pizza.size(); i++) {
			visit[level] = i;
			dfs(i + 1, level + 1);
		}
	}
}

int main() {
	int i, j, a;
	scanf("%d %d", &n, &m);
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= n; j++) {
			scanf("%d", &a);
			if (a == 1)house.push_back(make_pair(i, j));
			else if (a == 2)pizza.push_back(make_pair(i, j));
		}
	}
	dfs(0,0);
	printf("%d\n", mini);
	return 0;
}

visit[ ]에 몇번째 피자집이 선택되었는지를 입력한다.

if(level==m)에서 각 선택한 피자집과 집의 좌표를 temp에 저장시키고 그 합은 sum에 저장한다.

제일 작은 sum 값을 mini에 저장시키고 마지막으로 출력한다.

문제를 풀때 조합을 염두해두고 풀어야하는 유형

백준에도 똑같은 문제가 있다. 참고하시길

www.acmicpc.net/problem/15686

[개념] 조합 구하기 / c & c++ / 제한시간 없음

mero95 — Mon, 22 Feb 2021 14:48:33 +0900

#pragma warning(disable:4996)
#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;

int n, r;
int ch[20];

void dfs(int s, int L) {
	if (L == r) {
		for (int j = 0; j < L; j++) {
			printf("%d ", ch[j]);
		}
		puts("");
	}
	else {
		for (int i = s; i < n; i++) {
			ch[L] = i;
			dfs(i + 1, L + 1);
		}
	}
}

int main() {
	scanf("%d %d", &n, &r);
	dfs(0, 0);
	return 0;
}

위 코드는 정말 간단한 nCr를 코드로 작성한 것이다.

여러 문제에서 조합(Combination)을 사용하는 경우가 많은데

문제마다 if(L==r) 에서의 코드만 잘 변형시키면 문제 없음!