2805๋ฒ: ๋๋ฌด ์๋ฅด๊ธฐ
์ฒซ์งธ ์ค์ ๋๋ฌด์ ์ N๊ณผ ์๊ทผ์ด๊ฐ ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ ๋๋ฌด์ ๊ธธ์ด M์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000) ๋์งธ ์ค์๋ ๋๋ฌด์ ๋์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋๋ฌด์ ๋์ด์ ํฉ์ ํญ์ M๋ณด
www.acmicpc.net
๋ฌธ์
์๊ทผ์ด๋ ๋๋ฌด M๋ฏธํฐ๊ฐ ํ์ํ๋ค. ๊ทผ์ฒ์ ๋๋ฌด๋ฅผ ๊ตฌ์ ํ ๊ณณ์ด ๋ชจ๋ ๋งํด๋ฒ๋ ธ๊ธฐ ๋๋ฌธ์, ์ ๋ถ์ ๋ฒ๋ชฉ ํ๊ฐ๋ฅผ ์์ฒญํ๋ค. ์ ๋ถ๋ ์๊ทผ์ด๋ค ์ง ๊ทผ์ฒ์ ๋๋ฌด ํ ์ค์ ๋ํ ๋ฒ๋ชฉ ํ๊ฐ๋ฅผ ๋ด์ฃผ์๊ณ , ์๊ทผ์ด๋ ์๋ก ๊ตฌ์ ํ ๋ชฉ์ฌ์ ๋จ๊ธฐ๋ฅผ ์ด์ฉํด์ ๋๋ฌด๋ฅผ ๊ตฌํ ๊ฒ์ด๋ค.
๋ชฉ์ฌ์ ๋จ๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ด ๋์ํ๋ค. ๋จผ์ , ์๊ทผ์ด๋ ์ ๋จ๊ธฐ์ ๋์ด H๋ฅผ ์ง์ ํด์ผ ํ๋ค. ๋์ด๋ฅผ ์ง์ ํ๋ฉด ํฑ๋ ์ด ๋ ์ผ๋ก๋ถํฐ H๋ฏธํฐ ์๋ก ์ฌ๋ผ๊ฐ๋ค. ๊ทธ ๋ค์, ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด๋ฅผ ๋ชจ๋ ์ ๋จํด๋ฒ๋ฆฐ๋ค. ๋ฐ๋ผ์, ๋์ด๊ฐ H๋ณด๋ค ํฐ ๋๋ฌด๋ H ์์ ๋ถ๋ถ์ด ์๋ฆด ๊ฒ์ด๊ณ , ๋ฎ์ ๋๋ฌด๋ ์๋ฆฌ์ง ์์ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, ํ ์ค์ ์ฐ์ํด์๋ ๋๋ฌด์ ๋์ด๊ฐ 20, 15, 10, 17์ด๋ผ๊ณ ํ์. ์๊ทผ์ด๊ฐ ๋์ด๋ฅผ 15๋ก ์ง์ ํ๋ค๋ฉด, ๋๋ฌด๋ฅผ ์๋ฅธ ๋ค์ ๋์ด๋ 15, 15, 10, 15๊ฐ ๋ ๊ฒ์ด๊ณ , ์๊ทผ์ด๋ ๊ธธ์ด๊ฐ 5์ธ ๋๋ฌด์ 2์ธ ๋๋ฌด๋ฅผ ๋ค๊ณ ์ง์ ๊ฐ ๊ฒ์ด๋ค. (์ด 7๋ฏธํฐ๋ฅผ ์ง์ ๋ค๊ณ ๊ฐ๋ค) ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด๋ ์์ ์ ์ ๋๋ 0์ด๋ค.
์๊ทผ์ด๋ ํ๊ฒฝ์ ๋งค์ฐ ๊ด์ฌ์ด ๋ง๊ธฐ ๋๋ฌธ์, ๋๋ฌด๋ฅผ ํ์ํ ๋งํผ๋ง ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ค. ์ด๋, ์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด์ ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋๋ฌด์ ์ N๊ณผ ์๊ทผ์ด๊ฐ ์ง์ผ๋ก ๊ฐ์ ธ๊ฐ๋ ค๊ณ ํ๋ ๋๋ฌด์ ๊ธธ์ด M์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000)
๋์งธ ์ค์๋ ๋๋ฌด์ ๋์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋๋ฌด์ ๋์ด์ ํฉ์ ํญ์ M๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ธฐ ๋๋ฌธ์, ์๊ทผ์ด๋ ์ง์ ํ์ํ ๋๋ฌด๋ฅผ ํญ์ ๊ฐ์ ธ๊ฐ ์ ์๋ค. ๋์ด๋ 1,000,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ ์ ๋๋ 0์ด๋ค.
์ถ๋ ฅ
์ ์ด๋ M๋ฏธํฐ์ ๋๋ฌด๋ฅผ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด์ ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
ํ์ด๊ณผ์
ํด๋น๋ฌธ์ ๋ ์๊ฐ์ ํ์ด ๋นก๋นกํ๊ฒ ์ฃผ์ด์ ธ์ ์ด์งํ์์ด๋ผ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด์ผํ๋ ๋ฌธ์ ์๋ค.
์ถ๋ ฅ๊ฐ์ผ๋ก ๋์ฌ ์ ์๋ ๊ฐ์ 0 ~ ๋๋ฌด์ ์ต๋๊ฐ (max) ์ด๋ฏ๋ก ๊ทธ ๊ฐ๋ค์ค ์ด์งํ์์ผ๋ก ๊ฒฝ์ฐ์ ์๋ฅผ ์ค์ฌ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค.
code
#include <iostream>
#include <algorithm>
#include <vector>
std::vector <int> trees;
void binarySearch(int n, int m)
{
long long start, end, mid, sum;
start = 0;
end = trees[trees.size() - 1];
while (true)
{
mid = (start + end) / 2;
sum = 0;
for (int i = 0; i < trees.size(); i++) {
if (mid < trees[i])
sum += trees[i] - mid;
}
if (sum == m || start > end) break;
if (sum > m) start = mid + 1;
else if (sum < m) end = mid - 1;
}
std::cout << mid << "\n";
}
int main(void)
{
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int n, m, tree;
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
std::cin >> tree;
trees.push_back(tree);
}
std::sort(trees.begin(), trees.end());
binarySearch(n, m);
return (0);
}
ํ๊ธฐ
๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์์๋ ๋ญ๊ฐ ์ฐ์ฐํ ๋๋์ด ๋๋ ๋ฌธ์ ๊ฐ๋ค.
์ด๋ ๊ฒ ๋๋ฌธ์ ์ด๋ ๊ฒ ์ฝ๋๋ฅผ ์์ฑํด์ผํด๊ฐ ์๋๋ผ ํ ์คํธ์ผ์ด์ค๋ฅผ ๋๋ฆฌ๋ค๋ณด๋ "์ด๋ ๊ฒ ํ๋ฉด ๋์ง์์๊น?" ํ๊ณ ์ด๋ฆผ์ง์ํ์ฌ ํ์๋ค.
'Algorithm > ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 4963๋ฒ - ์ฌ์ ๊ฐ์ (C++) (1) | 2023.09.11 |
---|---|
[๋ฐฑ์ค] 5525๋ฒ - IOIOI (C++) (0) | 2023.09.10 |
[๋ฐฑ์ค] 17219๋ฒ - ๋น๋ฐ๋ฒํธ ์ฐพ๊ธฐ (C++) (0) | 2023.09.08 |
[๋ฐฑ์ค] 16928๋ฒ - ๋ฑ๊ณผ ์ฌ๋ค๋ฆฌ ๊ฒ์ (C++) (1) | 2023.09.07 |
[๋ฐฑ์ค] 9205๋ฒ - ๋งฅ์ฃผ ๋ง์๋ฉด์ ๊ฑธ์ด๊ฐ๊ธฐ (C++) (0) | 2023.09.06 |