문제

0부터 N까지의 정수 K개를 더해서 그 합이 N이 되는 경우의 수를 구하는 프로그램을 작성하시오.

덧셈의 순서가 바뀐 경우는 다른 경우로 센다(1+2와 2+1은 서로 다른 경우). 또한 한 개의 수를 여러 번 쓸 수도 있다.

입력

첫째 줄에 두 정수 N(1 ≤ N ≤ 200), K(1 ≤ K ≤ 200)가 주어진다.

출력

첫째 줄에 답을 1,000,000,000으로 나눈 나머지를 출력한다.

예제

예제 입력 1

1
2

20 2

예제 출력 1

1
2

21

예제 입력 2

1
2

6 4

예제 출력 2

1

84

내 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

const [N, K] = require("fs")
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split(" ")
  .map(Number);

const DP = Array.from({ length: N + 1 }, (_, i) => {
  if (i === 1) return Array.from({ length: K + 1 }, (_, i) => i + 1);
  return new Array(K + 1).fill(1);
});

for (let i = 2; i <= N; i++) {
  for (let j = 1; j <= K; j++) {
    DP[i][j] = (DP[i - 1][j] + DP[i][j - 1]) % 1000000000;
  }
}

console.log(DP[N][K - 1]);

• ✏️ N = 1인 경우 K = 1,2,3 …200 경우의 수를 생각해보았다.
  • ❗️ 1개의 수로 1을 만들 수 있는 경우의 수는 1가지이다.
  • 2개의 수로 1을 만들 수 있는 경우의 수는 0+1, 1+0으로 2가지이다.
  • 3개의 수로 1을 만들 수 있는 경우의 수는 0+0+1, 0+1+0, 1+0+0으로 3가지이다…
• N = 2인 경우 K = 1,2,3 …200 경우의 수를 생각해보았다.
  • ❗️ 1개의 수로 2를 만들 수 있는 경우의 수는 1가지이다.
  • 2개의 수로 2를 만들 수 있는 경우의 수는 1+1, 2+0, 0+2로 3가지이다.
  • 3개의 수로 2를 만들 수 있는 경우의 수는 1+1+0, 1+0+1, 0+1+1, 2+0+0, 0+2+0, 0+0+2로 6가지이다…

❗️의 조건을 가지고 DP[N][k] 2차원 배열에서, DP[N][1] = 1인 것을 알 수 있다.

✏️의 조건을 가지고 DP[1][k] = K 인 것을 알 수 있다.

위와 같은 점화식을 발견하였고 그에 알맞은 식을 만들었다.

댓글 공유

문제

정수 4를 1, 2, 3의 합으로 나타내는 방법은 총 7가지가 있다. 합을 나타낼 때는 수를 1개 이상 사용해야 한다.

• 1+1+1+1
• 1+1+2
• 1+2+1
• 2+1+1
• 2+2
• 1+3
• 3+1

정수 n이 주어졌을 때, n을 1, 2, 3의 합으로 나타내는 방법의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 정수 n이 주어진다. n은 양수이며 1,000,000보다 작거나 같다.

출력

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다.

예제

예제 입력 1

1
2
3
4
5

3
4
7
10

예제 출력 1

1
2
3

7
44
274

내 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

const input = require("fs")
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n")
  .map(Number);
const N = input.shift();

const DP = [0, 1, 2, 4];

input.forEach((num) => {
  for (let i = 4; i <= num; i++) {
    DP[i] = (DP[i - 3] + DP[i - 2] + DP[i - 1]) % 1000000009;
  }
  console.log(DP[num]);
});

• 1을 1,2,3으로 만들 수 있는 경우의 수, 2를 1,2,3으로 만들 수 있는 경우의 수, 3을 1,2,3으로 만들 수 있는 경우의 수는 직접 구할 수 있어서 구하였다.
• 4부터는 맨 마지막에 1,2,3이 오는 경우의 수를 나누어서 생각하였다.
  • 맨 마지막에 1이 오는 경우 ⇒ 1+1+1+1, 1+2+1, 2+1+1, 3+1 ⇒ DP[4-1]
  • 맨 마지막에 2가 오는 경우 ⇒ 1+1+2, 2+2 ⇒ DP[4-2]
  • 맨 마지막에 3이 오는 경우 ⇒ 1+3 ⇒ DP[4-3]

하지만 위와 같은 방법으로 하게되면 n이 1,000,000이 주어졌을 때, 반복문은 n-3회 진행하므로 시간초과가 난다. 심지어 테스트 케이스 수가 T개 주어지는 만큼 n-3회 반복해야 하므로 매우 오래걸릴 수도 있게된다.

즉, input 값 중에서 가장 큰 값으로 반복문 한번만 순회한 다음, 완성된 DP 배열에서 해당 값을 찾는 식으로 방법을 바꿨다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

const input = require("fs")
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n")
  .map(Number);
const N = input.shift();

function solution(n, arr) {
  if (n < 4) return arr[n - 1];

  for (let i = 4; i <= n; i++) {
    DP[i] = (DP[i - 3] + DP[i - 2] + DP[i - 1]) % 1000000009;
  }
  return arr;
}

const DP = [0, 1, 2, 4];
solution(Math.max(...input), DP);

input.forEach((num) => {
  console.log(DP[num]);
});

댓글 공유

문제

RGB거리에는 집이 N개 있다. 거리는 선분으로 나타낼 수 있고, 1번 집부터 N번 집이 순서대로 있다.

집은 빨강, 초록, 파랑 중 하나의 색으로 칠해야 한다. 각각의 집을 빨강, 초록, 파랑으로 칠하는 비용이 주어졌을 때, 아래 규칙을 만족하면서 모든 집을 칠하는 비용의 최솟값을 구해보자.

• 1번 집의 색은 2번 집의 색과 같지 않아야 한다.
• N번 집의 색은 N-1번 집의 색과 같지 않아야 한다.
• i(2 ≤ i ≤ N-1)번 집의 색은 i-1번, i+1번 집의 색과 같지 않아야 한다.

입력

첫째 줄에 집의 수 N(2 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 각 집을 빨강, 초록, 파랑으로 칠하는 비용이 1번 집부터 한 줄에 하나씩 주어진다. 집을 칠하는 비용은 1,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 모든 집을 칠하는 비용의 최솟값을 출력한다.

예제

예제 입력 1

1
2
3
4
5

3
26 40 83
49 60 57
13 89 99

예제 출력 1

1
2

96

예제 입력 2

1
2
3
4
5

3
1 100 100
100 1 100
100 100 1

예제 출력 2

1
2

3

예제 입력 3

1
2
3
4
5

3
1 100 100
100 100 100
1 100 100

예제 출력 3

1
2

102

예제 입력 4

1
2
3
4
5
6
7
8

6
30 19 5
64 77 64
15 19 97
4 71 57
90 86 84
93 32 91

예제 출력 4

1
2

208

예제 입력 5

1
2
3
4
5
6
7
8
9
10

8
71 39 44
32 83 55
51 37 63
89 29 100
83 58 11
65 13 15
47 25 29
60 66 19

예제 출력 5

1

253

내 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

const [N, ...arr] = require("fs")
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n");
const input = arr.map((houseCosts) => houseCosts.split(" ").map(Number));

function solution(n, rgb) {
  const DP = Array.from({ length: n + 1 }, () => new Array(3).fill(0));
  DP[1] = rgb[0];
  for (let i = 2; i <= n; i++) {
    DP[i][0] = Math.min(DP[i - 1][1], DP[i - 1][2]) + rgb[i - 1][0];
    DP[i][1] = Math.min(DP[i - 1][0], DP[i - 1][2]) + rgb[i - 1][1];
    DP[i][2] = Math.min(DP[i - 1][1], DP[i - 1][0]) + rgb[i - 1][2];
  }
  console.log(Math.min(...DP[n]));
}

solution(+N, input);

• 처음에는 1번째 집이 R,G,B를 선택하는 경우의 수를 구하고 이를 이 중 가장 작은 것을 가지고 다음 집을 구한다고 생각했다. 생각은 했는데 이를 코드로 어떻게 짜야할지 생각을 못해서 경우의수를 일일히 적어보고 패턴을 찾아보려고 했다.
• 하지만 못찾아서 다른 사람의 해설을 참고하였다. 문제가 복잡해보이지만 단순하게 생각하면 인접한 집끼리는 같은 색상을 가질 수 없다는 것이 전부이다.

우선, DP 배열을 만들고 해당 DP[i][0]은 i번째 집을 Red로 색칠하는 비용을 저장한다.

• DP[1] = input[0] 이 성립한다.
• 이후 i = 2 부터 반복문을 진행한다.
  1. DP[2]가 R로 색칠될 경우의 비용을 저장한다. ⇒ DP[2]가 R 이기 위해서는 DP[1]에서 G, B로 색칠되어야만 가능하다. 즉 DP[1]에서 G, B를 칠하는 비용 중 최소값을 구하고 이에 input의 2번째 집에 해당하는 비용 중 R을 색칠하는 비용을 더해주면 DP[2][0] 즉, 2번째 집을 R로 칠할 때 최소 비용을 구할 수 있다.
  2. DP[2][1]은 이전 집에서 R, B 중 최소값에다가 input의 2번째 집에 해당하는 비용 중 G을 색칠하는 비용을 더해주면 DP[2][1]의 최솟값을 구할 수 있다.

댓글 공유

문제

어떤 동물원에 가로로 두칸 세로로 N칸인 아래와 같은 우리가 있다.

이 동물원에는 사자들이 살고 있는데 사자들을 우리에 가둘 때, 가로로도 세로로도 붙어 있게 배치할 수는 없다. 이 동물원 조련사는 사자들의 배치 문제 때문에 골머리를 앓고 있다.

동물원 조련사의 머리가 아프지 않도록 우리가 2*N 배열에 사자를 배치하는 경우의 수가 몇 가지인지를 알아내는 프로그램을 작성해 주도록 하자. 사자를 한 마리도 배치하지 않는 경우도 하나의 경우의 수로 친다고 가정한다.

입력

첫째 줄에 우리의 크기 N(1≤N≤100,000)이 주어진다.

출력

첫째 줄에 사자를 배치하는 경우의 수를 9901로 나눈 나머지를 출력하여라.

예제

예제 입력 1

1

4

예제 출력 1

1

41

내 코드

N = 3 까지의 경우의 수를 적고나서 점화식을 생각해보았다. 처음에는 DP[i] = 2*DP[i-1] + (2**(i-1) - 1) 이라고 생각했는데 오답이였다.

다시 점화식을 세웠다.

1

DP[i] = 2 * DP[i - 1] + DP[i - 2];

1
2
3
4
5
6
7
8
9

const input = +require("fs").readFileSync("/dev/stdin").toString().trim();

const DP = [0, 3, 7, 17];

for (let i = 4; i <= input; i++) {
  DP[i] = (2 * DP[i - 1] + DP[i - 2]) % 9901;
}

console.log(DP[input]);

위 처럼 직접 경우의 수를 다 계산할 수 있었지만, DP를 2차원 배열로 설정하고 첫번째 칸에 공백이 오는경우, 좌측에 사자 채우는 경우, 우측에 사자 채우는 경우를 나눠서 구해볼 수 도 있을 것 같다.

댓글 공유

문제

오르막 수는 수의 자리가 오름차순을 이루는 수를 말한다. 이때, 인접한 수가 같아도 오름차순으로 친다.

예를 들어, 2234와 3678, 11119는 오르막 수이지만, 2232, 3676, 91111은 오르막 수가 아니다.

수의 길이 N이 주어졌을 때, 오르막 수의 개수를 구하는 프로그램을 작성하시오. 수는 0으로 시작할 수 있다.

입력

첫째 줄에 N (1 ≤ N ≤ 1,000)이 주어진다.

출력

첫째 줄에 길이가 N인 오르막 수의 개수를 10,007로 나눈 나머지를 출력한다.

예제

예제 입력 1

1

1

예제 출력 1

1

10

예제 입력 2

1

2

예제 출력 2

1

55

예제 입력 3

1

3

예제 출력 3

1

220

내 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

const length = +require("fs").readFileSync("/dev/stdin").toString().trim();

function Sum(arr) {
  return arr.reduce((acc, cur) => acc + cur, 0);
}

const DP = Array.from({ length: length + 1 }, (_, i) => {
  if (i === 1) return new Array(10).fill(1);
  if (i === 2) return Array.from({ length: 10 }, (_, i) => 10 - i);
  return Array(10).fill(0);
});

for (let i = 3; i <= length; i++) {
  for (let j = 0; j <= 9; j++) {
    for (let k = j; k <= 9; k++) {
      DP[i][j] += DP[i - 1][k] % 10007;
    }
  }
}

console.log(Sum(DP[length]) % 10007);

• 길이가 i이고, j로 시작하는 수로 오름차순을 만들 수 있는 경우의 수를 DP 배열에 저장하였다.

1
2

// 점화식
DP[i][j] = DP[i-1]의 j~9까지의 합

댓글 공유

문제

상근이의 여동생 상냥이는 문방구에서 스티커 2n개를 구매했다. 스티커는 그림 (a)와 같이 2행 n열로 배치되어 있다. 상냥이는 스티커를 이용해 책상을 꾸미려고 한다.

상냥이가 구매한 스티커의 품질은 매우 좋지 않다. 스티커 한 장을 떼면, 그 스티커와 변을 공유하는 스티커는 모두 찢어져서 사용할 수 없게 된다. 즉, 뗀 스티커의 왼쪽, 오른쪽, 위, 아래에 있는 스티커는 사용할 수 없게 된다.

모든 스티커를 붙일 수 없게된 상냥이는 각 스티커에 점수를 매기고, 점수의 합이 최대가 되게 스티커를 떼어내려고 한다. 먼저, 그림 (b)와 같이 각 스티커에 점수를 매겼다. 상냥이가 뗄 수 있는 스티커의 점수의 최댓값을 구하는 프로그램을 작성하시오. 즉, 2n개의 스티커 중에서 점수의 합이 최대가 되면서 서로 변을 공유 하지 않는 스티커 집합을 구해야 한다.

위의 그림의 경우에 점수가 50, 50, 100, 60인 스티커를 고르면, 점수는 260이 되고 이 것이 최대 점수이다. 가장 높은 점수를 가지는 두 스티커 (100과 70)은 변을 공유하기 때문에, 동시에 뗄 수 없다.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스의 첫째 줄에는 n (1 ≤ n ≤ 100,000)이 주어진다. 다음 두 줄에는 n개의 정수가 주어지며, 각 정수는 그 위치에 해당하는 스티커의 점수이다. 연속하는 두 정수 사이에는 빈 칸이 하나 있다. 점수는 0보다 크거나 같고, 100보다 작거나 같은 정수이다.

출력

각 테스트 케이스 마다, 2n개의 스티커 중에서 두 변을 공유하지 않는 스티커 점수의 최댓값을 출력한다.

예제

예제 입력 1

1
2
3
4
5
6
7
8

2
5
50 10 100 20 40
30 50 70 10 60
7
10 30 10 50 100 20 40
20 40 30 50 60 20 80

예제 출력 1

1
2

260
290

내 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

const input = require("fs")
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n");
const T = +input.shift();
function sticker(n, arr) {
  let DP = Array.from({ length: 2 }, () => Array(n).fill(0));

  DP[0][1] = arr[0][0];
  DP[1][1] = arr[1][0];
  for (let i = 2; i <= n; i++) {
    DP[0][i] = Math.max(DP[1][i - 1], DP[1][i - 2]) + +arr[0][i - 1];
    DP[1][i] = Math.max(DP[0][i - 1], DP[0][i - 2]) + +arr[1][i - 1];
  }
  return Math.max(...DP.flat(1));
}

let answer = [];
for (let i = 0; i < T; i++) {
  let k = input.splice(0, 1);
  let arr = [];
  arr.push(input.splice(0, 1).join("").split(" ").map(Number));
  arr.push(input.splice(0, 1).join("").split(" ").map(Number));
  answer.push(sticker(k, arr));
}

console.log(answer.join("\n"));

해설

DP 배열은 2차원 배열이고 2n 스티커이기 때문에, DP는 2행으로 구성된다.

1. DP[0][1]은 2n 스티커에서 0번째 행의 1열의 스티커 점수를 나타낸다.
2. DP[1][1]은 2n 스티커에서 1번째 행의 1열 스티커 점수를 나타낸다.

댓글 공유