๐ ๋ฌธ์ ๋ชฉ๋ก
- [๐ฅ1] 2748 - ํผ๋ณด๋์น ์ 2
- [๐ฅ3] 11727 - 2รn ํ์ผ๋ง 2
- [๐ฅ1] 1149 - RGB๊ฑฐ๋ฆฌ
[๐ฅ4] 17404 - RGB๊ฑฐ๋ฆฌ 2(ํต๊ณผ X)
1. ํผ๋ณด๋์น ์ 2
์ฌ๊ท๋ฅผ ์ด์ฉํ๋ฉด ์๊ฐ์ด๊ณผ๊ฐ ๋๋ฏ๋ก ๋ฉ๋ชจ์ด์ ์ด์
์ ์ฌ์ฉํด์ผ ํ๋ค.
๋ฐ๋ก ํ๊ธด ํ๋๋ฐ ๋ฒ์โฆ์ด๋ฐ ์ค์๋ ํ์ง ๋ง์!
์ฐธ ๊ธ ์ฐ๋๊น ์๊ฐ๋ฌ๋๋ฐ ๊ตณ์ด n๊ฐ ๋ฐฐ์ด์ ๋ง๋ค ํ์ ์์ด 3๊ฐ๋ง์ผ๋ก ๊ฐฑ์ ํด๊ฐ๋ฉฐ ํ์ด๋ ๋๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<iostream>
#include<vector>
using namespace std;
int main() {
int n;
vector<long long> fib;
cin >> n;
fib.assign(n+1, 0);
fib[1] = 1;
for (int i = 2; i <= n; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
cout << fib[n];
}
2. 2รn ํ์ผ๋ง 2
์ด ๋ฌธ์ ํ 5๋ฒ์ ํ์ง ์์์๊น?ใ
ใ
๊ทธ๋์ ํ์ด๋ ๋ฐ๋ก ๋ ์ฌ๋๋ค.
2รn ์ง์ฌ๊ฐํ์ ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ์ = 2ร(n-1) ์ง์ฌ๊ฐํ์ ์ฑ์ฐ๋ ์ + 2ร(n-2) ์ง์ฌ๊ฐํ์ ์ฑ์ฐ๋ ์*2 ์ด๋ค.
์๋๋ฉด 2ร(n-1) ์ง์ฌ๊ฐํ์์ โ1ร2์ง๋ฆฌ ํ๋โ๋ฅผ ์ฑ์ด ๊ฒ์ด๊ฑฐ๋
2ร(n-1) ์ง์ฌ๊ฐํ์์ โ2ร1์ง๋ฆฌ ๋๊ฐโ or โ2ร2์ง๋ฆฌ ํ๋โ๋ฅผ ์ฑ์ด๊ฑฐ๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋๊น.
๊ทธ๋ฆฌ๊ณ base case๋ฅผ n=0์ผ๋ 1, n=1์ผ๋ 1๋ก ์ค์ ํด์คฌ๋๋ฐ, ๋ญ ๊ฒฐ๊ณผ๊ฐ์ ๊ฐ์ง๋ง โ2ร0 ์ง์ฌ๊ฐํโ์ผ๋ก ์๊ฐํ๋ฉด ํผ๋์ด ์์ ์ ์์ผ๋ฏ๋ก n=1์ 1๋ก, n=2๋ฅผ 3์ผ๋ก ์ค์ ํด์ฃผ๋ ๊ฒ๋ ์ข์ ๊ฒ ๊ฐ๋ค.
์ด ๋ฌธ์ ๋ฅผ ์์ ์โฆ์ฒ์์ ํ ๋๋ 2ร2์นธ์ 1ร2์ง๋ฆฌ ๋๊ฐ๋ก ์ฑ์ฐ๋ ๋ฐฉ๋ฒ ๋๋ฌธ์ด์๋์ง ์๋ฌดํผ ์ฝ์ง์ ์ข ํ๋ ๊ธฐ์ต์ด ๋๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<iostream>
using namespace std;
int main() {
int n;
int cnt[1001] = { 0 };
cin >> n;
cnt[0] = 1;
cnt[1] = 1;
for (int i = 2; i <= n; i++) {
cnt[i] = (cnt[i - 1] + cnt[i - 2] * 2) % 10007;
}
cout << cnt[n];
}
3. RGB๊ฑฐ๋ฆฌ
๋ณด์๋ง์ ํ๋ก๊ทธ๋๋จธ์ค์ ๋
๋ฐ๋จน๊ธฐ ๋ฌธ์ ๊ฐ ์๊ฐ๋ฌ๋ค. ๊ฑฐ์ ๋๊ฐ์ ๋ฌธ์ ์ธ๋ฐโฆ ๋น์์ ๋จธ๋ฆฌ๋ฅผ ์ธ๋งค๊ณ ํ์์ง๋ง ๋์ ํ ์๊ฐ์ด ์ ๋์ ๊ฒฐ๊ตญ ํ์ด๋ฅผ ๋ดค๋๋ฌ๋ค.
์ฌ์ค์ ์ด๋ฒ์๋ ๋ฐ๋ก ๋ ์ฌ๋ฆฌ์ง ๋ชปํ๊ณ ..ใ
๋ด๊ฐ ์ ์ด๋ ค์ํ์๋์ง ๋์ง์ด๋ณด๋ค๊ฐ ํ์ด๊ฐ ์๊ฐ๋ฌ๋ค.
์ฒ์์ ํ ๋ ์ด๋ ค์์ ๋๊ผ๋ ์ด์ ๊ฐ โn๋ฒ์งธ ์ค์์ ์ด๋ค ์ธ๋ฑ์ค๋ฅผ ์ ํํ๋๋์ ๋ฐ๋ผ ๊ทธ ์ด์ ์ ํ์ด ๋ฐ๋์๋ ์๋ค(์ํฅ์ ์ค๋ค)โ ๋ผ๊ณ ์๊ฐํ๊ธฐ ๋๋ฌธ์ธ๋ฐ,
์ด์ ์ค์์ ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ์ ์ธํ ๋๋จธ์ง ์ค ๋ฒ ์คํธ ๊ฐ์ ๊ตฌํด์ ํ์ฌ ์ธ๋ฑ์ค๊ฐ์ ๋์ ํด๋์ผ๋ฉด, ์ด์ฐจํผ ์ธ๋ฑ์ค๊ฐ ์๋ก ๊ฒน์น์ง ์์ผ๋ฏ๋ก ๋ ์ด์ ์ด์ ์ ์ ๊ฒฝ์ธ ํ์๊ฐ ์์ด์ง๊ฒ ๋๋ค. (์ค๋ช
ํ๊ธฐ๊ฐ ์ข ์ด๋ ค์ด ๊ฒ ๊ฐ๋ค๐ฅฒ)
์๋ฌดํผ ๊ทธ๋ ๊ฒ ํ์ด์ ํต๊ณผ๋ ํ๋๋ฐ ์ฝ๋๊ฐ ์๋ฌด๋๋ ๋ณด๊ธฐ ์ฝ์ง ์์์ ๋ค๋ฅธ ์คํฐ๋์ ๋ถ๋ค์ด ์ง ๋ฐฉ์์ผ๋ก ๊ณ ์ณค๋ค.
์ฝ๋
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
29
30
31
32
33
34
#include<iostream>
using namespace std;
int min(int a, int b) {
return ((a < b) ? a : b);
}
int main() {
int n;
int stacked_cost[3] = { 0 };
cin >> n;
for (int i = 0; i < n; i++) {
int cur_cost[3];
for (int j = 0; j < 3; j++) {
cin >> cur_cost[j];
int prev_min_cost = INT32_MAX;
for (int k = 0; k < 3; k++) {
if ((j != k) && (prev_min_cost > stacked_cost[k])) prev_min_cost = stacked_cost[k];
}
cur_cost[j] += prev_min_cost;
}
for (int j = 0; j < 3; j++) {
stacked_cost[j] = cur_cost[j];
}
}
cout << min(stacked_cost[0], min(stacked_cost[1], stacked_cost[2]));
}
์ฝ๋ #2
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
#include<iostream>
using namespace std;
int min(int a, int b) {
return (a < b) ? a : b;
}
int main() {
int n;
int cost[1001][3];
cin >> n;
for (int i = 0; i < 3; i++) {
cin >> cost[1][i];
}
for (int i = 2; i <= n; i++) {
for (int j = 0; j < 3; j++) {
cin >> cost[i][j];
}
cost[i][0] += min(cost[i - 1][1], cost[i - 1][2]);
cost[i][1] += min(cost[i - 1][0], cost[i - 1][2]);
cost[i][2] += min(cost[i - 1][0], cost[i - 1][1]);
}
cout << min(cost[n][0], min(cost[n][1], cost[n][2]));
}
4. RGB๊ฑฐ๋ฆฌ (ํต๊ณผ X)
ํ์ฐธ์ ์๊ฐํ์ผ๋โฆ ํ์ด๋ฅผ ์๊ฐํด๋ด์ง ๋ชปํ๋ค.
์ ๋ฌธ์ ์์ ์ฒซ์ค์ ์ ์ธํ๊ณ ๋น์ฉ์ ๊ตฌํ ๋ค์ ๋๋ฒ์งธ ์ค์ ์ ํํ ์ธ๋ฑ์ค์ ๋ง์ง๋ง์ค ์ ํ ์ธ๋ฑ์ค๋ฅผ ์ ์ธ์ํค๊ณ ๋น๊ตํ๋โฆ ๋ญ ๊ทธ๋ฐ ๋ฐฉ๋ฒ์ ์๊ฐํ๊ณ ์งฐ๋๋ฐ. ์๋ฌด๋๋ ์์ฐ์ฐฎ๊ธฐ๋ ํ๋ค.
๊ทผ๋ฐ ์์ ๋ ์ง๋ฌธ๊ธ์ ์ฌ๋ผ์จ ๋ฐ๋ก ๋์ด ๊ฐ๊ฐ ๋ค ์ ๋์์, ์๊ฐ์ด ๊ฑธ๋ฆฌ๋๋ผ๋ ์ฌ๋งํ๋ฉด ํ์ด ๋ณด์ง ๋ง๊ณ ๊ณ ์ณ๋ณด์ ํ๋๋ฐ
๊ณ ์น๊ณ ์ ์ถํด๋ ๊ณ์ ์คํจ๊ฐ ๋จ๋ ๋ด๊ฐ ํ์คํ ๋์น ๋ถ๋ถ์ด ์๋ ๊ฒ ๊ฐ์ ๊ฒฐ๊ตญ ํ์ด๋ฅผ ๋ดค๋ค. ์๋ ์ด๋ฐ ๋ฐฉ๋ฒ์ด.ใ
ใ
ใ
OTL
ํ๋ฌ ๋ค์ ๋ค์ ํ์ด๋ณด๊ณ ํ์ด ์์ฑํด์ผ๊ฒ ๋ค.