๋ฌธ์
์ธํ์ํ์๋ ATM์ด 1๋๋ฐ์ ์๋ค. ์ง๊ธ ์ด ATM์์ N๋ช ์ ์ฌ๋๋ค์ด ์ค์ ์์๋ค. ์ฌ๋์ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ๋งค๊ฒจ์ ธ ์์ผ๋ฉฐ, i๋ฒ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ Pi๋ถ์ด๋ค.
์ฌ๋๋ค์ด ์ค์ ์๋ ์์์ ๋ฐ๋ผ์, ๋์ ์ธ์ถํ๋๋ฐ ํ์ํ ์๊ฐ์ ํฉ์ด ๋ฌ๋ผ์ง๊ฒ ๋๋ค. ์๋ฅผ ๋ค์ด, ์ด 5๋ช ์ด ์๊ณ , P1 = 3, P2 = 1, P3 = 4, P4 = 3, P5 = 2 ์ธ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์. [1, 2, 3, 4, 5] ์์๋ก ์ค์ ์ ๋ค๋ฉด, 1๋ฒ ์ฌ๋์ 3๋ถ๋ง์ ๋์ ๋ฝ์ ์ ์๋ค. 2๋ฒ ์ฌ๋์ 1๋ฒ ์ฌ๋์ด ๋์ ๋ฝ์ ๋ ๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์, 3+1 = 4๋ถ์ด ๊ฑธ๋ฆฌ๊ฒ ๋๋ค. 3๋ฒ ์ฌ๋์ 1๋ฒ, 2๋ฒ ์ฌ๋์ด ๋์ ๋ฝ์ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์, ์ด 3+1+4 = 8๋ถ์ด ํ์ํ๊ฒ ๋๋ค. 4๋ฒ ์ฌ๋์ 3+1+4+3 = 11๋ถ, 5๋ฒ ์ฌ๋์ 3+1+4+3+2 = 13๋ถ์ด ๊ฑธ๋ฆฌ๊ฒ ๋๋ค. ์ด ๊ฒฝ์ฐ์ ๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ํ์ํ ์๊ฐ์ ํฉ์ 3+4+8+11+13 = 39๋ถ์ด ๋๋ค.
์ค์ [2, 5, 1, 4, 3] ์์๋ก ์ค์ ์๋ฉด, 2๋ฒ ์ฌ๋์ 1๋ถ๋ง์, 5๋ฒ ์ฌ๋์ 1+2 = 3๋ถ, 1๋ฒ ์ฌ๋์ 1+2+3 = 6๋ถ, 4๋ฒ ์ฌ๋์ 1+2+3+3 = 9๋ถ, 3๋ฒ ์ฌ๋์ 1+2+3+3+4 = 13๋ถ์ด ๊ฑธ๋ฆฌ๊ฒ ๋๋ค. ๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ํ์ํ ์๊ฐ์ ํฉ์ 1+3+6+9+13 = 32๋ถ์ด๋ค. ์ด ๋ฐฉ๋ฒ๋ณด๋ค ๋ ํ์ํ ์๊ฐ์ ํฉ์ ์ต์๋ก ๋ง๋ค ์๋ ์๋ค.
์ค์ ์ ์๋ ์ฌ๋์ ์ N๊ณผ ๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ Pi๊ฐ ์ฃผ์ด์ก์ ๋, ๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ํ์ํ ์๊ฐ์ ํฉ์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ฌ๋์ ์ N(1 ≤ N ≤ 1,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ Pi๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ Pi ≤ 1,000)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ํ์ํ ์๊ฐ์ ํฉ์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
ํ์ด
๊ฐ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ์ ์ ์์๋๋ก ๊ณ์ฐํด์ฃผ๋ฉด ๋๋ค.
๋ฌธ์ ๋ ๋ ์ธ์ถํ๋ ์๊ฐ์ ํฉ์ธ๋ฐ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค.
1. ์๊ฐ๋ณต์ก๋ O(n^2) : ๋๊ตฌ๋ ์๊ฐํ ์ ์๋ ๋ฐฉ๋ฒ.
2. ์๊ฐ๋ณต์ก๋ O(n) : ๊ฐ ์๊ฐ์ด ๋์ค๋ ๋น๋๋ฅผ ๊ณ์ฐํ๋ฉด ๋๋ค.
ex) time : 1 2 3 4 5 ๋ผ๊ณ ํ๋ฉด
์ฒซ ๋ฒ์งธ ์ฌ๋ : 1
๋ ๋ฒ์งธ ์ฌ๋ : 1 + 2
์ธ ๋ฒ์งธ ์ฌ๋ : 1 + 2 + 3
๋ค ๋ฒ์งธ ์ฌ๋ : 1 + 2 + 3 + 4
๋ค์ฏ๋ฒ์งธ ์ฌ๋ : 1 + 2 + 3 + 4 + 5
-> 1๋ถ * 5๋ฒ + 2๋ถ * 4๋ฒ + 3๋ถ * 3๋ฒ + 4๋ถ * 2๋ฒ + 5๋ถ * 1๋ฒ
-> ์์์ผ๋ก ๋ํ๋ด๋ฉด time[i] * (n-i)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n;
// ์
๋ ฅ
cin >> n;
vector<int> time(n, 0);
for (int i=0; i<n; i++)
cin >> time[i];
// ์ฐ์ฐ
sort(time.begin(), time.end());
// ์ถ๋ ฅ (1)
int result = 0, sum;
for (int i=0; i<n; i++){
sum = 0;
for (int j=0; j<=i; j++)
sum += time[j];
result += sum;
}
// ์ถ๋ ฅ (2) : ์๊ฐ๋ณต์ก๋ ๊ฐ์
// (n-i)์ ๋น๋๋ก ์๊ฐ
int result = 0;
for (int i=0; i<n; i++)
result += (time[i] * (n-i));
cout << result;
}
'โจ Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค/C++] 19636๋ฒ: ์์ ์๋ฎฌ๋ ์ด์ (0) | 2022.07.02 |
---|---|
[๋ฐฑ์ค/C++] 11651๋ฒ: ์ขํ ์ ๋ ฌํ๊ธฐ2 (0) | 2022.07.02 |
[๋ฐฑ์ค/C++] 10994๋ฒ: ๋ณ ์ฐ๊ธฐ - 19 (0) | 2022.06.28 |
[๋ฐฑ์ค/C++] 1946๋ฒ: ์ ์ ์ฌ์ (0) | 2022.06.28 |
[๋ฐฑ์ค/C++] 1431๋ฒ: ์๋ฆฌ์ผ ๋ฒํธ (0) | 2022.06.28 |
๋๊ธ