๋ฌธ์
์ฐ์ธ๋ํ๊ต ์๊ฐ์ ์ฒญ์ด ์ผ๋ง ์ ๋ถํฐ ๋ฐ๋์ด, ๋ง์ผ๋ฆฌ์ง ์ ๋๋ก ๋ฐ๋์๋ค. ์ด ์ ๋๋ ๊ฐ๊ฐ์ ํ์๋ค์๊ฒ ๋ง์ผ๋ฆฌ์ง๋ฅผ ์ฃผ์ด ๋ฃ๊ณ ์ถ์ ๊ณผ๋ชฉ์ ๋ง์ผ๋ฆฌ์ง๋ฅผ ๊ณผ๋ชฉ๋น 1~36์ ๋ถ๋ฐฐํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ชจ๋ ๋ถ๋ฐฐ๊ฐ ๋์ด ๋๋ฉด ๊ณผ๋ชฉ์ ๋ํด์ ๋ง์ผ๋ฆฌ์ง๋ฅผ ๋ง์ด ํฌ์ํ ์์ผ๋ก ๊ทธ ๊ณผ๋ชฉ์ ์๊ฐ์ธ์๋งํผ ์ ์ฒญ๋๋ ๋ฐฉ์์ด๋ค.
์ฑ์ค์ด๋ ์ฐ์ธ๋ํ๊ต ์ฌํ ์ค์ธ ํ์์ด๋ค. ์ฑ์ค์ด๋ ์ ๋ฒ ์๊ฐ์ ์ฒญ์์ ์คํจํ์ฌ ํดํ์ ํ๊ธฐ ๋๋ฌธ์ ์ด๋ฒ ์๊ฐ์ ์ฒญ๋ง์ ํ์ฌ์ ์ผ๋ก ์ฑ๊ณตํ๋ ค๊ณ ํ๋ค. ๊ทธ๋์ ์ฑ์ค์ด๋ ํ๊ต ํํ์ด์ง๋ฅผ ๋ซ์ด๋ฒ๋ ธ๋ค.
๊ทธ ๋๋ถ์ ๋ค๋ฅธ ์ฌ๋๋ค์ด ์ ์ฒญํ ๋ง์ผ๋ฆฌ์ง๋ฅผ ๋ณผ ์ ์๊ฒ ๋์๋ค. ์ฑ์ค์ด๋ ์ฃผ์ด์ง ๋ง์ผ๋ฆฌ์ง๋ก ์ต๋ํ ๋ง์ ๊ณผ๋ชฉ์ ์ ์ฒญํ๊ณ ์ถ์ด ํ๋ค. (๋ด๊ฐ ๋ง์ผ๋ฆฌ์ง๋ฅผ ๋ฃ๊ณ ์ดํ์ ๊ณผ๋ชฉ์ ์ ์ฒญํ๋ ์ฌ๋์ ์๋ค) ๋ง์ผ๋ฆฌ์ง๋ ํ ๊ณผ๋ชฉ์ 1์์ 36๊น์ง ๋ฃ์ ์ ์๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ๊ณผ๋ชฉ ์ n (1 ≤ n ≤ 100)๊ณผ ์ฃผ์ด์ง ๋ง์ผ๋ฆฌ์ง m (1 ≤ m ≤ 100)์ด ์ฃผ์ด์ง๋ค. ๊ฐ ๊ณผ๋ชฉ๋ง๋ค 2์ค์ ์ ๋ ฅ์ด ์ฃผ์ด์ง๋๋ฐ ์ฒซ์งธ ์ค์๋ ๊ฐ ๊ณผ๋ชฉ์ ์ ์ฒญํ ์ฌ๋ ์ Pi๊ณผ ๊ณผ๋ชฉ์ ์๊ฐ์ธ์ Li์ด ์ฃผ์ด์ง๊ณ ๊ทธ ๋ค์ ์ค์๋ ๊ฐ ์ฌ๋์ด ๋ง์ผ๋ฆฌ์ง๋ฅผ ์ผ๋ง๋ ๋ฃ์๋์ง ์ฃผ์ด์ง๋ค. (1 ≤ Pi ≤100, 1 ≤ Li ≤ 100)
(๋จ ๋ง์ผ๋ฆฌ์ง๊ฐ ๊ฐ๋ค๋ฉด ์ฑ์ค์ด์๊ฒ ์ฐ์ ์์๊ฐ ์ฃผ์ด์ง๋ค๊ณ ํ์.)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ด์ง ๋ง์ผ๋ฆฌ์ง๋ก ์ต๋๋ก ๋ค์ ์ ์๋ ๊ณผ๋ชฉ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1 ๋ณต์ฌ
5 76
5 4
36 25 1 36 36
4 4
30 24 25 20
6 4
36 36 36 36 36 36
2 4
3 7
5 4
27 15 26 8 14
์์ ์ถ๋ ฅ 1 ๋ณต์ฌ
4
ํ์ด๊ณผ์
๋ฌธ์ ์ ์ ๊ทผํ๋ ๋ฐฉ์์ ํฌ๊ฒ ์ด๋ ต์ง์์๋ค.
๋ฌธ์ ๋ก ์ฃผ์ด์ง ์กฐ๊ฑด๋ค์ ๊ทธ๋๋ก ์ฝ๋๋ก ์ฎ๊ธธ ์ ์์ผ๋ฉด ๋๋ต์ ์ธ ์ฝ๋๊ตฌํ๋ฐฉ์์ ์๊ฐํ ์ ์์๊ณ , ์ธ๋ถ์ ์ผ๋ก ์ด๋ป๊ฒ ๋ก์ง์ ๊ตฌ์ฑํด์ผ
ํจ์จ์ ์ผ๋ก ์ฝ๋๊ฐ ๋์๊ฐ ์ ์๋๋๋ฅผ ์๊ฐํ์๋ ์๊ฐ์ธ์๋ค์ ๋ง์ผ๋ฆฌ์ง๋ฅผ ์ ๋ ฌ์์ผ์ ๋ด๊ฐ ๋น๊ต์์ผ์ผํ๋ ๊ฐ์ ๋ฝ์์ค๊ณ ๊ทธ ๊ฐ๋ค์ ๋ชจ์ ์ ๋ ฌ์ํจ๋ค์ ์์๊ฐ๋ถํฐ ๋ง์ผ๋ฆฌ์ง๋ฅผ ์ฐจ๊ฐํ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํ์ ํ๋ ํฌ๊ฒ ์ด๋ ต์ง์๊ฒ ์งํํ ์ ์์๋ค.
code
#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
int n, m, p, l, temp, count;
std::vector <int> v, v_temp;
std::cin >> n >> m;
for(int i = 0; i < n; i++)
{
std::cin >> p >> l;
for(int j = 0; j < p; j++) {
std::cin >> temp;
v_temp.push_back(temp);
}
std::sort(v_temp.begin(), v_temp.end());
if (l - p > 0) v.push_back(1);
else v.push_back(v_temp[p - l]);
v_temp.clear();
}
std::sort(v.begin(), v.end());
count = 0;
for(int i = 0; i < v.size(); i++) {
if (m >= v[i]) {
m = m - v[i];
count++;
}
}
std::cout << count;
return (0);
}
ํ๊ธฐ
ํฐํ์ ์ง๋ ๊ณผ์ ์ด ํฌ๊ฒ ์ด๋ ค์ด๋ก์ง์ ์๋์๋๊ฑฐ๊ฐ์์ ๊ธ๋ฐฉํ์์๋ค.
'Algorithm > ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 1912๋ฒ - ์ฐ์ํฉ (C++) (0) | 2023.07.06 |
---|---|
[๋ฐฑ์ค] 11501๋ฒ - ์ฃผ์ (C++) (0) | 2023.07.04 |
[๋ฐฑ์ค] 1260๋ฒ - DFS์ BFS (C++) (0) | 2023.07.02 |
[๋ฐฑ์ค] 11724๋ฒ - ์ฐ๊ฒฐ ์์์ ๊ฐ์ (C++) (1) | 2023.07.01 |
[๋ฐฑ์ค] 14940๋ฒ - ์ฌ์ด ์ต๋จ๊ฑฐ๋ฆฌ (C++) (0) | 2023.07.01 |