๋ฌธ์
์นด์ง๋ ธ์์ ์ ์ผ ์ธ๊ธฐ ์๋ ๊ฒ์ ๋ธ๋์ญ์ ๊ท์น์ ์๋นํ ์ฝ๋ค. ์นด๋์ ํฉ์ด 21์ ๋์ง ์๋ ํ๋ ๋ด์์, ์นด๋์ ํฉ์ ์ต๋ํ ํฌ๊ฒ ๋ง๋๋ ๊ฒ์์ด๋ค. ๋ธ๋์ญ์ ์นด์ง๋ ธ๋ง๋ค ๋ค์ํ ๊ท์ ์ด ์๋ค.
ํ๊ตญ ์ต๊ณ ์ ๋ธ๋์ญ ๊ณ ์ ๊น์ ์ธ์ ์๋ก์ด ๋ธ๋์ญ ๊ท์น์ ๋ง๋ค์ด ์๊ทผ, ์ฐฝ์์ด์ ๊ฒ์ํ๋ ค๊ณ ํ๋ค.
๊น์ ์ธ ๋ฒ์ ผ์ ๋ธ๋์ญ์์ ๊ฐ ์นด๋์๋ ์์ ์ ์๊ฐ ์ฐ์ฌ ์๋ค. ๊ทธ ๋ค์, ๋๋ฌ๋ N์ฅ์ ์นด๋๋ฅผ ๋ชจ๋ ์ซ์๊ฐ ๋ณด์ด๋๋ก ๋ฐ๋ฅ์ ๋๋๋ค. ๊ทธ๋ฐ ํ์ ๋๋ฌ๋ ์ซ์ M์ ํฌ๊ฒ ์ธ์น๋ค.
์ด์ ํ๋ ์ด์ด๋ ์ ํ๋ ์๊ฐ ์์ N์ฅ์ ์นด๋ ์ค์์ 3์ฅ์ ์นด๋๋ฅผ ๊ณจ๋ผ์ผ ํ๋ค. ๋ธ๋์ญ ๋ณํ ๊ฒ์์ด๊ธฐ ๋๋ฌธ์, ํ๋ ์ด์ด๊ฐ ๊ณ ๋ฅธ ์นด๋์ ํฉ์ M์ ๋์ง ์์ผ๋ฉด์ M๊ณผ ์ต๋ํ ๊ฐ๊น๊ฒ ๋ง๋ค์ด์ผ ํ๋ค.
N์ฅ์ ์นด๋์ ์จ์ ธ ์๋ ์ซ์๊ฐ ์ฃผ์ด์ก์ ๋, M์ ๋์ง ์์ผ๋ฉด์ M์ ์ต๋ํ ๊ฐ๊น์ด ์นด๋ 3์ฅ์ ํฉ์ ๊ตฌํด ์ถ๋ ฅํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์นด๋์ ๊ฐ์ N(3 ≤ N ≤ 100)๊ณผ M(10 ≤ M ≤ 300,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ์นด๋์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ฉฐ, ์ด ๊ฐ์ 100,000์ ๋์ง ์๋๋ค.
ํฉ์ด M์ ๋์ง ์๋ ์นด๋ 3์ฅ์ ์ฐพ์ ์ ์๋ ๊ฒฝ์ฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ M์ ๋์ง ์์ผ๋ฉด์ M์ ์ต๋ํ ๊ฐ๊น์ด ์นด๋ 3์ฅ์ ํฉ์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ
5 21 5 6 7 8 9 |
์์ ์ถ๋ ฅ
21 |
๋ฌธ์ ํ์ด
์์ ํ์ ๋ฌธ์ ๋ฅผ ํ๊ณ ์ถ์ด์ ๋ฐฑ์ค์์ ์ฐพ์๋ณธ ๋ฌธ์ ๋ค.
n๊ฐ์ ์นด๋์ค์์ 3๊ฐ์ ์นด๋๋ฅผ ๋ฝ์ ๊ทธ ํฉ์ด m์ ๊ฐ์ฅ ๊ทผ์ ํ๋ฉด ๋๋ค.
์ฃผ์ด์ง ์นด๋ ์ค ํ๋๋ฅผ ๋จผ์ ์ ํํ๊ณ ๋๋จธ์ง 2๊ฐ๋ฅผ ์ฌ๊ท ํธ์ถ์ ์ด์ฉํด ๊ตฌํ๋ค
-
์ฃผ์ด์ง ์นด๋๋ค - cards
-
์ด ํฉ - sum
- ๋ช ๊ฐ์งธ ์นด๋๋ฅผ ์ ํํ๋์ง - cnt
์์ง ๋ต์ ์์ ์ํ๊น์ง๋ ๊ตฌํ์ง ๋ชปํ์ง๋ง ๋ค๋ฅธ ๋ธ๋ก๊ทธ๋ฅผ ์ดํด๋ณด๋ ์์ ํ์์ผ๋ก๋ ํ๋ฆฌ๋ ๋ฌธ์ ์๋ค.
์ฌ์ค ์ด๋ ๊ฒ ํ์ง ์๊ณ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ํ์์ผ๋ ์๊พธ ๋ฐฑ์ค์์ ํ๋ ธ๋ค๊ณ ๋์์ ๋ด ์ฝ๋๊ฐ ๋ด๊ฐ ๋ชจ๋ฅด๋ ๋ฌธ์ ๊ฐ ์๊ตฌ๋ ํ๊ณ ๋ฐ๋ก ๋ ๋ ค๋ฒ๋ ธ๋ค. ๊ทธ๋์ ๋ฐ์ ์ฝ๋๋ https://jaimemin.tistory.com/856 ๋์ ์ฝ๋๋ฅผ ๊ฑฐ์ ๋ฐฐ๋ ์ฝ๋์ด๋ค.
/* n์ฅ์ ์นด๋์ค์์ m์ ๊ฐ์ฅ ๊ฐ๊น์ด ์นด๋ 3์ฅ์ ํฉ์ ์ถ๋ ฅ */
/* 2019-07-09 ๋ธ๋์ */
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n,m;
int result;
vector<int> cards;
void pick(int idx, int cnt, int sum) {
if (cnt == 3 && sum <= m)
{
result = max(result, sum);
return;
}
if (idx >= n || cnt > 3 || sum > m) return;
pick(idx + 1, cnt + 1, sum + cards[idx]);
pick(idx + 1, cnt, sum);
}
int main() {
int temp;
cin >> n >> m;
cards.resize(n);
for (int i = 0; i < n; i++) { cin >> cards[i]; }
sort(cards.begin(), cards.end(), greater<int>()); // ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
pick(0, 0, 0);
cout << result;
}
์ฌ์ค ๋น ๋ฅด๊ฒ ์ฐพ๊ณ ์ถ์ด์ ๋ฒกํฐ๋ฅผ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ํด์ ์ฐพ๋ ๋ฐฉ๋ฒ์ ์ ํํ์ง๋ง ์ด ๋ฌธ์ ์์ ๊ทธ๋ด ํ์๊น์ง ์์ด๋ณด์ธ๋ค.
pick ํจ์์์๋ ์นด๋๋ฅผ ๋ฝ๊ณ ์ ๊ฑฐํ๋ค. ๋จผ์ 3์ฅ์ ์นด๋๋ฅผ ๋ค ๋ฝ๊ณ sum์ด ์ ์ ๋ m๋ณด๋ค ์๋ค๋ฉด result์ ๊ฐ์ ๋ฐ๊ฟ์ค๋ค. ์ด๋ m๋ณด๋ค ์์ ๊ฒฝ์ฐ์ ์๋ ๋ค์ํ์ง๋ง ์ฐ๋ฆฌ๋ ๊ฐ์ฅ ๊ทผ์ ํ ๊ฒฐ๊ณผ๋ฅผ ์ป๊ณ ์ถ์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ result์ ๊ฐ์ ์ ์ฅํ๊ณ max ํจ์๋ฅผ ์ด์ฉํด ๋ค์ ๊ตฌํ sum๊ณผ์ ๋์ ๋น๊ต๋ฅผ ํ๋ค.
๋ฒกํฐ๋ฅผ ์ํํ๋ ๊ณผ์ ์์ idx๊ฐ ๋ฒ์๋ฅผ ๋ฒ์ด๋๊ฑฐ๋ 3์ฅ ์ด์์ ์นด๋๋ฅผ ๋ฝ์๊ฑฐ๋ sum์ด m๋ณด๋ค ํฌ๋ค๋ฉด ํ์์ ์ฆ์ ์ค๋จํ๋ค.
์์ ๋๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๋๋ผ๋ฉด ์ฌ๊ท ํ์์ ํตํด ๋ฒกํฐ์ ๋ค์ idx๋ฅผ ํ์ํ๋๋ฐ ์ด๋ ํ์ฅ์ ์นด๋๋ฅผ ์ด๋ฏธ ๋ฝ์๋ค๋ ๋ป์ด๋ฏ๋ก cnt๋ ์ฆ๊ฐํ๊ณ sum๋ ์ฆ๊ฐํด์ ๊ตฌํ๋ค.
๋๋ฒ์งธ if๋ฌธ์ ๊ฑธ๋ฆฌ์ง ์๋๋ค๋ฉด 3์ฅ์ ์นด๋๋ฅผ ๋ฝ๊ณ ๊ทธ sum์ m์ ๋์ง ์์๋๊น์ง ๊ณ์ pickํจ์์ ๋ค์ด๊ฐ๊ฒ ๋๋ค. ์ฐ๋ฆฌ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ํ๊ธฐ ๋๋ฌธ์ ๋ฝ์ ์นด๋๋ฅผ ์ ๊ฑฐ ํด ์ฃผ๋ ๊ณผ์ ์ด ํ์ํ๋ค. ๊ทธ๊ฒ ๋ฐ๋ก ๊ทธ ๋ค์ ์ฝ๋๋ค.
์ฌ์ค ์์ง ์๋ฒฝํ๊ฒ ์ดํด๋ฅผ ๋ชปํด์ ์ ๋ชจ๋ฅด๊ฒ ๋ค. ์์ ํ์์ ์ข ๋ ์ด์ฌํ ๊ณต๋ถํด๋ณด๊ณ ๋ค์ ํ๋ฒ ํ์ด๋ด์ผ๊ฒ ๋ค.