๐งจ ๋ฐฑ์ค 11047๋ฒ
๋ฌธ์ ์ถ์ฒ : ๋ฐฑ์ค 11047๋ฒ
๋ฌธ์ ๋์ด๋ : ์ค๋ฒ1
๋ฌธ์ ๋งํฌ : www.acmicpc.net/problem/11047
11047๋ฒ: ๋์ 0
์ฒซ์งธ ์ค์ N๊ณผ K๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000) ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๋์ ์ ๊ฐ์น Ai๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ฃผ์ด์ง๋ค. (1 ≤ Ai ≤ 1,000,000, A1 = 1, i ≥ 2์ธ ๊ฒฝ์ฐ์ Ai๋ Ai-1์ ๋ฐฐ์)
www.acmicpc.net
๐งจ ์๊ณ ๋ฆฌ์ฆ ์ ํ ๋ฐ C++ ์ฝ๋
๋์ ๋ฌธ์ ์ผ๋ง๋ก ๋ํ์ ์ธ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๊ฐ์ฅ ํฐ ๋์ ๋จ์๋ถํฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ๋ด๊ฐ ์ํ๋ ๊ธ์ก K๋ฅผ ์ฑ์๋๊ฐ๋ฉด ๋๋ค. ๋ง์น stable sorting๊ณผ ๋น์ทํ ๋๋์ด๋๊น.. (x, y ์์ผ๋ก ์ ๋ ฌํ๋ ค๋ฉด y๋จผ์ ์ ๋ ฌํ๊ณ x ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ ๊ฒ์ฒ๋ผ)
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
vector<int> coin(n);
int target = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &coin[i]);
}
for (int i = n; i > 0; i--) {
target += k / coin[i - 1];
k = k % coin[i - 1];
}
printf("%d", target);
return 0;
}
๐งจ ๋ฐฑ์ค 4796๋ฒ
๋ฌธ์ ์ถ์ฒ : ๋ฐฑ์ค 4796๋ฒ
๋ฌธ์ ๋์ด๋ : ์ค๋ฒ5
๋ฌธ์ ๋งํฌ : www.acmicpc.net/problem/4796
4796๋ฒ: ์บ ํ
์ ๋ ฅ์ ์ฌ๋ฌ ๊ฐ์ ํ ์คํธ ์ผ์ด์ค๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค๋ ํ ์ค๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , L, P, V๋ฅผ ์์๋๋ก ํฌํจํ๊ณ ์๋ค. ๋ชจ๋ ์ ๋ ฅ ์ ์๋ int๋ฒ์์ด๋ค. ๋ง์ง๋ง ์ค์๋ 0์ด 3๊ฐ ์ฃผ์ด์ง๋ค.
www.acmicpc.net
๐งจ ์๊ณ ๋ฆฌ์ฆ ์ ํ ๋ฐ C++ ์ฝ๋
L < P < V ๋ง ์๊ฐํ๊ณ ํ๋ค๊ฐ ๋๋จธ์ง์ L ํฌ๊ธฐ์ ๋ฐ๋ผ ๋ง์ง๋ง์ ๋ํด์ฃผ๋ ์ผ ์๊ฐ ๋ฌ๋ผ์ง ์๋ ์์์ ๊นจ๋ฌ์๋ค. ๋ํ์ ์ธ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์๊ณ , ๋๋์ ์ฐ์ฐ์ ์ ์ด์ฉํ๋ฉด ๋์๋ค. ๊ฐ๊ฒฐํ ์ฝ๋๋ฅผ ์ํด ์ผํญ์ฐ์ฐ์ ? : ๋ฅผ ์ค๋๋ง์ ์จ๋ดค๋ค. ๊ฐ๋ ์ฑ์ ๋จ์ด์ง์ง๋ง ๊ฐ๊ฒฐํด์ ์ข๋ค.
#include <iostream>
using namespace std;
int main(void) {
int limit, period, vacation;
int target = 0;
int count = 1;
while (1) {
scanf("%d %d %d", &limit, &period, &vacation);
if (!limit && !period && !vacation)
break;
target = (vacation / period) * limit;
target += (vacation % period) > limit ? limit : (vacation % period);
printf("Case %d: %d\n", count, target);
count++;
}
return 0;
}
๐งจ ๋ฐฑ์ค 16435๋ฒ
๋ฌธ์ ์ถ์ฒ : ๋ฐฑ์ค 16435๋ฒ
๋ฌธ์ ๋์ด๋ : ์ค๋ฒ5
๋ฌธ์ ๋งํฌ : www.acmicpc.net/problem/16435
16435๋ฒ: ์ค๋ค์ดํฌ๋ฒ๋
์ฒซ ๋ฒ์งธ ์ค์ ๊ณผ์ผ์ ๊ฐ์ N (1 ≤ N ≤ 1,000) ๊ณผ ์ค๋ค์ดํฌ๋ฒ๋์ ์ด๊ธฐ ๊ธธ์ด ์ ์ L (1 ≤ L ≤ 10,000) ์ด ์ฃผ์ด์ง๋๋ค. ๋ ๋ฒ์งธ ์ค์๋ ์ ์ h1, h2, ..., hN (1 ≤ hi ≤ 10,000) ์ด ์ฃผ์ด์ง๋๋ค.
www.acmicpc.net
๐งจ ์๊ณ ๋ฆฌ์ฆ ์ ํ ๋ฐ C++ ์ฝ๋
์ค๋ค์ดํฌ๋ฒ๋.. ๋ฑ๊ณผ ์๋ฅผ ๋ฎ์๋๋ฐ ์ด๋ป๊ฒ ๊ท์ฝ๋ค๊ณ ํ ์ ์์ง..
์ค๋ค์ดํฌ๋ฒ๋์ ์ฒ์ ๊ธธ์ด๊ฐ L์ผ ๋ ๊ณผ์ผ๋ค์ ๋จน์ด ๋๋ฆด ์ ์๋ ์ต๋ ๊ธธ์ด๋ฅผ ๊ตฌํด์ผ ํ๋ฏ๋ก ๊ณผ์ผ์ ์ ๋ ฌํ๋ ์์ ์ด ํ์ํ๋ค. ๊ณผ์ผ์ ์ ๋ ฌํ์ฌ ๋ด๊ฐ ๋จน์ ์ ์๋ ๋ฒ์๋ ๋ชจ๋ ๋จน๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด๋ ์ ๋ ฌ์ c++ ์์ฒด sort ํจ์(nlogn์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋)๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฌธ์ ์๋ค. ์ ๋ ฌํด์ผ ํ๋ค๋ ์๊ฐ์ด ํต์ฌ์ด์๊ณ , ๊ทธ ์ธ์๋ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ทธ๋ฅ ๊ณ์ ๋จน์ผ๋ฉด ๋๋ค.์ด์ฏค ๋๋ฉด ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ํด์ง ๊ตฌํ ๋ฐฉ์์ ์์ง๋ง if ์กฐ๊ฑด๋ฌธ์ ๊ธฐ์ค์ผ๋ก ์ด๋ค ์ฒ๋ฆฌ๋ฅผ ํด ์ค ๊ฒ์ธ๊ฐ ๋ง ๊ฒ์ธ๊ฐ๋ก ๋๋ ์ ์์ ๊ฒ ๊ฐ๋ค. ๋๋ ๋๋์ ์ฐ์ฐ(๋ชซ๊ณผ ๋๋จธ์ง)์ ์ด์ฌํ ํ๋ฉด ๋๋ ๊ฑฐ ๊ฐ๋ค.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void) {
int N, L;
scanf("%d %d", &N, &L);
vector<int> fruit(N);
for (int i = 0; i < N; i++) {
scanf("%d", &fruit[i]);
}
sort(begin(fruit), end(fruit));
for (auto f : fruit) {
if (f <= L) {
L++;
}
}
printf("%d", L);
return 0;
}
๐งจ ๋ฐฑ์ค 13305๋ฒ
๋ฌธ์ ์ถ์ฒ : ๋ฐฑ์ค 13305๋ฒ
๋ฌธ์ ๋์ด๋ : ์ค๋ฒ4 (ํ์ง๋ง ์์ 3๋ฌธ์ ๋ณด๋ค ์ด๋ ค์ ๋ค)
๋ฌธ์ ๋งํฌ : www.acmicpc.net/problem/13305
13305๋ฒ: ์ฃผ์ ์
ํ์ค ์ ๋ ฅ์ผ๋ก ๋ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ์ฒซ ๋ฒ์งธ ์ค์๋ ๋์์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ N(2 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ ์ค์๋ ์ธ์ ํ ๋ ๋์๋ฅผ ์ฐ๊ฒฐํ๋ ๋๋ก์ ๊ธธ์ด๊ฐ ์ ์ผ ์ผ์ชฝ ๋๋ก๋ถํฐ N-1
www.acmicpc.net
๐งจ ์๊ณ ๋ฆฌ์ฆ ์ ํ ๋ฐ C++ ์ฝ๋
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํด ํธ๋ ๊ฑฐ๋ผ๋๋ฐ ์๊ฐ๋ณด๋ค ์ ๊ทผํ๊ธฐ ์ด๋ ค์ ๋ค.
1) ๋จธ๋ฆฌ์์ผ๋ก ์ด๋ป๊ฒ ํ์ด์ผ ํ ์ง ๊ฐ์ ์ค๋๋ฐ ๊ตฌํํ๊ธฐ ์ ๋งคํ๋ค. ์ฒซ๋ฒ์งธ๋ก ์๋ํ ๋ก์ง์, ํ์ฌ ๋ด๊ฐ ์๋ ๋์๋ฅผ ๊ธฐ์ค์ผ๋ก ์์ผ๋ก ๊ฐ์ผํ ๋์๋ค์ ์ฃผ์ ์ ๊ฐ๊ฒฉ์ ๋ฏธ๋ฆฌ ์ฒดํฌํด์ ์ง๊ธ ๊ธฐ๋ฆ์ ์ผ๋ง๋ ๋ฃ์์ง๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ์์ด์๋ค. ์ด์ค ๋ฃจํ๋ฅผ ์ฌ์ฉํด์ผํ๊ธฐ ๋๋ฌธ์ ์๋นํ ๋นํจ์จ์ ์ด์๊ณ ์ด์ํ๊ฒ length_error๋ ๋ง์ด ๋ฌ๋ค (์๋ง ์ด๋ ๋ฒกํฐ ์ ์ฐ๊ณ ์ด๋ ์ด๋ก ์ผ๋ค๋ฉด ํด๊ฒฐ๋์์ ์๋ ์๋ค) ๋๋ฒ์งธ๋ก ์๋ํ ๋ฐฉ๋ฒ์, ๋ด๊ฐ ๊ฐ์ฅ ์ต๊ทผ์ ๊ธฐ๋ฆ์ ๋ฃ์ ๊ณณ(min: ๊ธฐ๋ฆ๊ฐ์ด ์๊ธฐ ๋๋ฌธ์ ๊ธฐ๋ฆ์ ๋ฃ์์ ๊ฒ)์ min์ผ๋ก ๋๊ณ ํ์ฌ ๋์์ ๊ธฐ๋ฆ๊ฐ๊ณผ ๋น๊ตํ๋ ๊ฒ์ด๋ค. min์ ๊ณ์ ๊ฐฑ์ ํ๋ฉฐ, ์ฝ๋ ์์ผ๋ก๋ ๋งค๋ฒ ๋ฐ๋ก ๋ค์ ๋์๊น์ง์ ๊ฑฐ๋ฆฌ๋งํผ๋ง ๊ธฐ๋ฆ์ ๋ฃ๋ ๋ฐฉ์์ด์ง๋ง ์ฌ์ค์ (min ๊ฐ๊ฒฉ) * (๋ฐ๋ก ๋ค์ ๋์๊น์ง์ ๊ฑฐ๋ฆฌ) ์ด๋ฏ๋ก ์ฒซ๋ฒ์งธ ์๋ํ ๋ฐฉ๋ฒ๊ณผ ๊ฐ์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
2) ์์ ์ ์ถ๋ ฅ์ ๋ชจ๋ ๋ง๊ฒ ๋์๋๋ฐ ์ ์ถํด๋ณด๋ ๋ฐํ์์๋ฌ ๋ํ์ฅ ํํฐ์๋ค. OutofBounds, LengthError๊ฐ ๊ณ์ ๋จ๊ธธ๋ ๊ต์ฅํ ๋๊ฐํ๋ค. ๊ตฌ๊ธ๋งํ ์์ ๋ค ๋ณด๋๊น ๋๋ถ๋ถ vector๋ฅผ ์ ์ฐ๊ณ array๋ฅผ ์ผ๊ธธ๋ ๋๋ ๋ฒกํฐ ๋ฒ๋ฆฌ๊ณ ์ด๋ ์ด๋ก ๊ฐ์ํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์ด๋ ์ด๋ก ๊ฐ์ํ๋๊น ๊ฐ๋จํ ํด๊ฒฐ๋๋๋ฐ, ์์ผ๋ก๋ ๋ฒกํฐ์ begin(), end(), push_back ๋ฑ์ ๋ด์ฅํจ์๋ฅผ ์ธ ์ผ์ด ์๋๋ผ๋ฉด ๊ทธ๋ฅ ์ด๋ ์ด๋ฅผ ์จ์ผ๊ฒ ๋ค. ๋ช๋ฒ์ ์ ์ถ ๋์ ์ฑ๊ณตํด์ ๋คํ์ด๋ค. (์ต๊ทผ ํ์๋ ๋ฐฑ์ค ๋ฌธ์ ์ค์ ์ค๋ฅ ํด๊ฒฐ์ ์ ์ผ ์ค๋ ์๊ฐ์ ์ด ๋ฌธ์ ๊ฐ ์๋๊ฐ ์ถ๋ค)
#include <iostream>
#include <vector>
using namespace std;
int main(void)
{
int N;
long long link[100001];
long long node[100001];
scanf("%d", &N);
for(int i = 0; i < N - 1; i++) {
cin >> link[i];
}
for(int i = 0; i < N; i++) {
cin >> node[i];
}
long long target = 0;
long long min = node[0];
for(int i = 0; i < N - 1; i++) {
if(node[i] < min) {
min = node[i];
}
target += link[i] * min;
}
cout << target;
return 0;
}
๊ทธ๋ฆฌ๋ ๊ด๋ จ ๋ฌธ์ ๋ช ๊ฐ ๋ ํ์ด๋ด์ผ ๊ฐ์ด ์ฌ ๊ฑฐ ๊ฐ๋ค.
'Problem Solving > BOJ ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] C++ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด (3) (0) | 2021.01.12 |
---|---|
[BOJ] C++ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด (2) (0) | 2021.01.11 |
[BOJ] ๊ธฐ๋ณธ๊ตฌํ๋ฌธ์ - 2490๋ฒ, 2864๋ฒ (C++ ์ฝ๋) (0) | 2021.01.10 |
[BOJ] ๊ธฐ๋ณธ๊ตฌํ๋ฌธ์ - 1085๋ฒ, 3460๋ฒ, 9085๋ฒ, 5361๋ฒ, 10250๋ฒ (C++ ๊ตฌํ) (0) | 2021.01.07 |
[BOJ] ๊ธฐ๋ณธ๊ตฌํ๋ฌธ์ - 1330๋ฒ, 2525๋ฒ, 2588๋ฒ, 9498๋ฒ (C++ ์ฝ๋) (0) | 2021.01.07 |