์ฐ๋ฃ ์ฑ์ฐ๊ธฐ ์ฑ๊ณต
2 ์ด 128 MB 5856 1716 1320 28.897% ๋ฌธ์
์ฑ๊ฒฝ์ด๋ ํธ๋ญ์ ์ ๊ธ ์์์ ์ด์ ํ๋ค๊ฐ ํธ๋ญ์ ์ฐ๋ฃํฑํฌ์ ๊ฐ์๊ธฐ ๊ตฌ๋ฉ์ด ๋์ 1km๋ฅผ ๊ฐ๋๋ฐ 1L์ ์ฐ๋ฃ๊ฐ ์ ๋๊ฐ๊ฒ ๋์๋ค. ์ด๊ฒ์ ๊ณ ์น๊ธฐ ์ํด์๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ง์์ ๊ฐ์ผ ํ๋ค. ๊ทธ๋ฐ๋ฐ ๊ทธ๋ฅ ๊ฐ๋ค๊ฐ๋ ์ค๊ฐ์ ์ฐ๋ฃ๊ฐ ๋ค ๋น ์ง ์๊ฐ ์๋ค. ๋คํ์ค๋ฝ๊ฒ๋ ์ ๊ธ ๊ณณ๊ณณ์ ์ฐ๋ฃ๋ฅผ ์ฑ์ธ ์ ์๋ ์ฃผ์ ์๊ฐ N๊ฐ ์๋ค. ๊ทธ๋ฐ๋ฐ ์ ๊ธ ์์์ ์ค๊ฐ์ ์ฐจ๋ฅผ ๋ฉ์ถ๋ ํ์๋ ๋งค์ฐ ์ํํ ํ์์ด๋ฏ๋ก ์ฃผ์ ์์์ ๋ฉ์ถ๋ ํ์๋ฅผ ์ต์ํ ํ๋ ค ํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋คํ์ด๋ ์ฑ๊ฒฝ์ด์ ํธ๋ญ์ ๋งค์ฐ ์ข์์ ์ฐ๋ฃ ํฑํฌ์๋ ์ฐ๋ฃ์ ์ ํ์ด ์์ด ๋ง์ด ์ถฉ๋ถํ ๋ง์ด ๋ฃ์ ์ ์๋ค๊ณ ํ๋ค. ๊ฐ๊ฐ์ ์ฃผ์ ์์ ์์น์, ๊ฐ ์ฃผ์ ์์์ ์ป์ ์ ์๋ ์ฐ๋ฃ์ ์์ด ์ฃผ์ด์ ธ ์์ ๋, ์ฃผ์ ์์์ ๋ฉ์ถ๋ ํ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๊ธ์ ์ผ์ง์ ์ด๊ณ , ์ฑ๊ฒฝ์ด์ ํธ๋ญ๊ณผ ์ฃผ์ ์๋ ๋ชจ๋ ์ผ์ง์ ์์ ์๋ค. ์ฃผ์ ์๋ ๋ชจ๋ ์ฑ๊ฒฝ์ด์ ํธ๋ญ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฅธ์ชฝ์ ์๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ ์์ ๊ฐ์ N(1 ≤ N ≤ 10,000)๊ฐ ์ฃผ์ด์ง๊ณ ๋ ๋ฒ์งธ ์ค๋ถํฐ N+1๋ฒ์งธ ์ค ๊น์ง ์ฃผ์ ์์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ์ฃผ์ ์์ ์ ๋ณด๋ ๋๊ฐ์ ์ ์ a,b๋ก ์ด๋ฃจ์ด ์ ธ ์๋๋ฐ a(1 ≤ a ≤ 1,000,000)๋ ์ฑ๊ฒฝ์ด์ ์์ ์์น์์ ์ฃผ์ ์ ๊น์ง์ ๊ฑฐ๋ฆฌ, ๊ทธ๋ฆฌ๊ณ b(1 ≤ b ≤ 100)๋ ๊ทธ ์ฃผ์ ์์์ ์ฑ์ธ ์ ์๋ ์ฐ๋ฃ์ ์์ ์๋ฏธํ๋ค. ๊ทธ๋ฆฌ๊ณ N+2๋ฒ์งธ ์ค์๋ ๋ ์ ์ L๊ณผ P๊ฐ ์ฃผ์ด์ง๋๋ฐ L(1 ≤ L ≤ 1,000,000)์ ์ฑ๊ฒฝ์ด์ ์์น์์ ๋ง์๊น์ง์ ๊ฑฐ๋ฆฌ, P(1 ≤ P ≤ 1,000,000)๋ ํธ๋ญ์ ์๋ ์๋ ์ฐ๋ฃ์ ์์ ์๋ฏธํ๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ ์์์ ๋ฉ์ถ๋ ํ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ๋ง์์ ๋์ฐฉํ์ง ๋ชปํ ๊ฒฝ์ฐ -1์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1 ๋ณต์ฌ
4 4 4 5 2 11 5 15 10 25 10
์์ ์ถ๋ ฅ 1 ๋ณต์ฌ
3โ
17๋ฒ๋ง์ ๋ง์ถ ๋ฌธ์ ์ด๋ค.
์ฐ๋ฃํ๋, ๊ฑฐ๋ฆฌํ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ํด์ผ๋๋ค๋ ๊ฒ์ 3๋ถ๋ง์ ์์๋๋๋ฐ ๊ฒฐ๊ตญ ์ดํ๋์ ํ์๋ค.
๊ฒฐ๊ตญ ๊ณ์ ์ด ๋ฌธ์ ๋ฅผ ํ๋ฆฐ ์ด์ ๋
๋ถ๋ช ์ฐ๋ฃ๋ฅผ ๊ธฐ์ค์ผ๋ก ํ์๋, ๊ฐ์์๋ ์ฃผ์ ์(์ฃผ์ ์์ ๊ฑฐ๋ฆฌ๊ฐ ์ฐ๋ฃ๋ณด๋ค ์์ ๊ฒฝ์ฐ)์ ์ฐ๋ฃ์ ์์ ๊ทธ๋ฅ ๋ํด์ฃผ๋ฉด ๋๋ค.
์ ์ด๊ฑธ ํท๊ฐ๋ ธ๋์ง๋ ๋ชจ๋ฅด๊ฒ ์ง๋ง, ์ฐ๋ฃ์ ์ ์ ์ต๋๊ฑฐ๋ฆฌ๋ก ์ก๊ณ ๋๋ ค๋๊ฐ๋ฉด ๋๋๋ฐ ์ ๋ฅ์์ ์์น๋ฅผ ์ก์์คฌ๋ค.
๊ทธ๋ฆฌ๊ณ ๊ฑฐ๊ธฐ์ ๊ฐ ๊ฑฐ๋ฆฌ๋งํผ ๋นผ์ฃผ๊ณ , ์ฐ๋ฃ๋งํผ ๋ํด์ฃผ๊ณ . ์ด๋ฐ ๊ณผ์ ์์ ๋ฐ๋ก๊ฐ ์๊ธด ๊ฒ ๊ฐ๋ค.
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
priority_queue<pair<int,int>, vector<pair<int,int>>, less<>>pq_fuel;
vector<pair<int,int>>v;
int N,L,P,ans, st,arr[10000];
int main(){
cin>>N;
for(int i=0; i<N; i++){
int a, b;
cin>>a>>b;
v.push_back({a,b});
}
sort(v.begin(), v.end());
cin>>L>>P;
while(P+st < L){
for(int i=0; i<v.size(); i++){
if(arr[i]) continue;
if(P >= v[i].first) {
arr[i] = 1;
pq_fuel.push({v[i].second, v[i].first});
}
}
if(pq_fuel.empty()){
cout<<-1;
return 0;
}
P += pq_fuel.top().first;
pq_fuel.pop();
ans += 1;
}
cout<<ans;
}