5๊ฐ์ ์ซ์ [1, 5, 2, 6, 8]์ด ์ฃผ์ด์ก์ ๋
์ด ์ค ๋จ ํ๋์ ์ซ์๋ง ๋ ๋ฐฐ๋ก ํด์, ์ธ์ ํ ์ซ์๊ฐ์ ์ฐจ์ด์ ํฉ์ด ์ต๋๊ฐ ๋๋๋ก ํด๋ณด์ธ์.
์ ๋ฌธ์ ๋ ๋จ์ํ๊ฒ, ๋ชจ๋ ์์น์ ์ซ์๋ฅผ 2๋ฐฐ์ฉ ํด๋ณด๋ ์์ ํ์์ ์งํํด ๋ณผ ์ ์์ต๋๋ค.
1. ์ฒซ ๋ฒ์งธ ์ซ์ 1์ 2๋ฐฐ๋ฅผ ํ๋ ๊ฒฝ์ฐ
[2, 5, 2, 6, 8]์ด ๋๋ฏ๋ก, ์ธ์ ํ ์ซ์๊ฐ์ ์ฐจ์ด์ ํฉ์ 3 + 3 + 4 + 2 = 12๊ฐ ๋ฉ๋๋ค.
2. ๋ ๋ฒ์งธ ์ซ์ 5์ 2๋ฐฐ๋ฅผ ํ๋ ๊ฒฝ์ฐ
[1, 10, 2, 6, 8]์ด ๋จ๊ฒ ๋๋ฏ๋ก, ์ธ์ ํ ์ซ์๊ฐ์ ์ฐจ์ด์ ํฉ์ 9 + 8 + 4 + 2 = 23์ด ๋ฉ๋๋ค.
3. ์ธ ๋ฒ์งธ ์ซ์ 2์ 2๋ฐฐ๋ฅผ ํ๋ ๊ฒฝ์ฐ
[1, 5, 4, 6, 8]์ด ๋จ๊ฒ ๋๋ฏ๋ก, ์ธ์ ํ ์ซ์๊ฐ์ ์ฐจ์ด์ ํฉ์ 4 + 1 + 2 + 2 = 9๊ฐ ๋ฉ๋๋ค.
4. ๋ค ๋ฒ์งธ ์ซ์ 6์ 2๋ฐฐ๋ฅผ ํ๋ ๊ฒฝ์ฐ
[1, 5, 2, 12, 8]์ด ๋จ๊ฒ ๋๋ฏ๋ก, ์ธ์ ํ ์ซ์๊ฐ์ ์ฐจ์ด์ ํฉ์ 4 + 3 + 10 + 4 = 21์ด ๋ฉ๋๋ค.
5. ๋ค์ฏ ๋ฒ์งธ ์ซ์ 8์ 2๋ฐฐ๋ฅผ ํ๋ ๊ฒฝ์ฐ
[1, 5, 2, 6, 16]์ด ๋จ๊ฒ ๋๋ฏ๋ก, ์ธ์ ํ ์ซ์๊ฐ์ ์ฐจ์ด์ ํฉ์ 4 + 3 + 4 + 10 = 21์ด ๋ฉ๋๋ค.
๋ฐ๋ผ์ ์ต๋๋ 23์ด ๋ฉ๋๋ค.
์ด์ฒ๋ผ ๊ฐ ์๋ฆฌ์ ๋ํด ์ํฉ์ ์ผ์ผ์ด ๊ฐ์ ํด๋ณด๊ณ ์งํํด๋ณด๋ ์์ ํ์ ๋ฐฉ๋ฒ์ ์ด์ฉํ๋ฉด, ๋ฌธ์ ๋ฅผ ๊น๋ํ๊ฒ ํด๊ฒฐํ ์ ์์ต๋๋ค.
๋ง์ฝ ์ต๋๊ฐ์ ๊ตฌํ๋ ์์ ํ์ ์ฝ๋๊ฐ ์๋ค๊ณ ๊ฐ์ ํฉ์๋ค.
๊ทธ๋ฌ๋ฉด max_val ๊ฐ์ ์ด๊ธฐ๊ฐ์, ๋ค์ด์ฌ ์ ์๋ ๊ฐ๋ค๋ณด๋ค ํจ์ฌ ์์ ๊ฐ์ผ๋ก ์ก์์ผ ํฉ๋๋ค.
์ด ๊ฒฝ์ฐ์ max_val์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ์ด๊ธฐ๊ฐ์ผ๋ก ๋ฃ์ด์ค ๋ค ์งํํ๋ ๋ฐฉ๋ฒ๋ ์์ง๋ง,
์์ ํ์ ์ ํ์์๋ ์ฒซ ๋ฒ์งธ ์์ ๊ฐ์ ๊ตฌํ๋ ๊ฒ ์์ฒด๊ฐ ๊ฐ๋จํ์ง ์๊ธฐ ๋๋ฌธ์, ์ด๊ธฐ๊ฐ์ผ๋ก ์์ฃผ ์์ ๊ฐ์ ์ก์ ์ฃผ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ต๋๊ฐ์ ๊ตฌํด์ฃผ๋ ๊ฒฝ์ฐ์๋ ๋ค์๊ณผ ๊ฐ์ด #include <climits>๋ฅผ ์ถ๊ฐํ์ฌ max_val์ INT_MIN ๊ฐ์,
์ต์๊ฐ์ ๊ตฌํด์ฃผ๋ ๊ฒฝ์ฐ์๋ min_val์ INT_MAX๋ฅผ ์ด๊ธฐ๊ฐ์ผ๋ก ๋ฃ์ด์ฃผ๋ ๊ณผ์ ์ด ํ์ํฉ๋๋ค.
์ฐ์ต๋ฌธ์ : ๋ชจ์ด์
n๊ฐ์ ์ง์ด x = 1์์ x = n๊น์ง ์์๋๋ก ๋์ฌ์๊ณ , ๊ฐ๊ฐ ๋ช ์ ์ฌ๋์ด ์ด๊ณ ์์ต๋๋ค. ์ด๋ค์ ํ์๋ฅผ ์ํด n๊ฐ์ ์ง ์ค ํ ๊ณณ์ ์ ๋ถ ๋ชจ์ด๋ ค๊ณ ํฉ๋๋ค. ์ ์ ํ ์ง์ ์ ํํ์ฌ ๋ชจ๋ ์ฌ๋๋ค์ ์ด๋ ๊ฑฐ๋ฆฌ์ ํฉ์ด ์ต์๊ฐ ๋๋๋ก ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์ธ์.
์ ๋ ฅ ํ์
์ฒซ ๋ฒ์งธ ์ค์ n์ด ์ฃผ์ด์ง๋๋ค.
๋ ๋ฒ์งธ ์ค์๋ ๊ฐ ์ง์ ์ ์ด๊ณ ์๋ ์ฌ๋ ์์ ํด๋นํ๋ n๊ฐ์ ์ซ์๊ฐ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋๋ค.
- 1 ≤ n ≤ 100
- 1 ≤ ≤ 100
์ถ๋ ฅ ํ์
๊ฐ๋ฅํ ์ด๋ ๊ฑฐ๋ฆฌ์ ํฉ ์ค ์ต์๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
๋์ ํ์ด
#include <iostream>
#include <climits>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
int people[101] = {0,};
cin>>n;
for(int i=0; i<n; ++i){
cin >> people[i];
}
int sum = 0;
int answer = INT_MAX;
for(int i=0; i<n; ++i){
sum = 0;
for(int j=0; j<n; ++j){
if(j==i) continue;
int d = abs(j-i);
sum += people[j]*d;
}
if(answer > sum) answer = sum;
}
cout << answer;
return 0;
}
์ํ์์ min / max ์ ์ธ์์๋ ์ ์๊ฐ์ ์ต๋/์ต์๋ฅผ ๋ฃ์ด๋๋ ๊ฑธ ์์ง๋ง์!
'๐ ์๊ณ ๋ฆฌ์ฆ > Code Tree' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฝ๋ํธ๋ฆฌ] BFS ํ์ / ๊ฐ ์ ์๋ ๊ณณ๋ค (0) | 2023.02.22 |
---|---|
[์ฝ๋ํธ๋ฆฌ] BFS ํ์ / ๋ค ๋ฐฉํฅ ํ์ถ ๊ฐ๋ฅ ์ฌ๋ถ ํ๋ณํ๊ธฐ (0) | 2023.02.22 |
[์ฝ๋ํธ๋ฆฌ] Greedy - ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ / ๋์ ์ฐ์ต๋ฌธ์ (0) | 2023.02.22 |
[์ฝ๋ํธ๋ฆฌ] Backtracking - ๋ฐฑํธ๋ํน / ์ฌ๊ท ์ฐ์ต๋ฌธ์ (0) | 2023.02.21 |
[์ฝ๋ํธ๋ฆฌ] DFS / BFS (0) | 2023.02.21 |