๋ฌธ์ ์ค๋ช
๊ธธ์ด๊ฐ N์ธ ์์ด์ด ์ฃผ์ด์ก์ ๋, ๊ทธ ์์ด์ ํฉ์ ๊ตฌํ๋ ค๊ณ ํ๋ค. ํ์ง๋ง, ๊ทธ๋ฅ ๊ทธ ์์ด์ ํฉ์ ๋ชจ๋ ๋ํด์ ๊ตฌํ๋ ๊ฒ์ด ์๋๋ผ, ์์ด์ ๋ ์๋ฅผ ๋ฌถ์ผ๋ ค๊ณ ํ๋ค. ์ด๋ค ์๋ฅผ ๋ฌถ์ผ๋ ค๊ณ ํ ๋, ์์น์ ์๊ด์์ด ๋ฌถ์ ์ ์๋ค. ํ์ง๋ง, ๊ฐ์ ์์น์ ์๋ ์(์๊ธฐ ์์ )๋ฅผ ๋ฌถ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๋ค ์๋ฅผ ๋ฌถ๊ฒ ๋๋ฉด, ์์ด์ ํฉ์ ๊ตฌํ ๋ ๋ฌถ์ ์๋ ์๋ก ๊ณฑํ ํ์ ๋ํ๋ค.
์๋ฅผ ๋ค๋ฉด, ์ด๋ค ์์ด์ด {0, 1, 2, 4, 3, 5}์ผ ๋, ๊ทธ๋ฅ ์ด ์์ด์ ํฉ์ ๊ตฌํ๋ฉด 0+1+2+4+3+5 = 15์ด๋ค. ํ์ง๋ง, 2์ 3์ ๋ฌถ๊ณ , 4์ 5๋ฅผ ๋ฌถ๊ฒ ๋๋ฉด, 0+1+(2*3)+(4*5) = 27์ด ๋์ด ์ต๋๊ฐ ๋๋ค.
์์ด์ ๋ชจ๋ ์๋ ๋จ ํ๋ฒ๋ง ๋ฌถ๊ฑฐ๋, ์๋๋ฉด ๋ฌถ์ง ์์์ผํ๋ค.
์์ด์ด ์ฃผ์ด์ก์ ๋, ์์ด์ ๊ฐ ์๋ฅผ ์ ์ ํ ๋ฌถ์์ ๋, ๊ทธ ํฉ์ด ์ต๋๊ฐ ๋๊ฒ ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์์ด์ ํฌ๊ธฐ N์ด ์ฃผ์ด์ง๋ค. N์ 10,000๋ณด๋ค ์์ ์์ฐ์์ด๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์, ์์ด์ ๊ฐ ์๊ฐ ์ฃผ์ด์ง๋ค. ์์ด์ ์๋ -10,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค.
์ถ๋ ฅ
์๋ฅผ ํฉ์ด ์ต๋๊ฐ ๋์ค๊ฒ ๋ฌถ์์ ๋ ํฉ์ ์ถ๋ ฅํ๋ค. ์ ๋ต์ ํญ์ 231๋ณด๋ค ์๋ค.
์ ์ถ๋ ฅ ์์
์ ๋ ฅ
4
-1
2
1
3
์ถ๋ ฅ
6
๋ด ๋ฌธ์ ํ์ด
import Foundation
let N = Int(readLine()!)!
var minus = [Int]()
var plus = [Int]()
var answer = 0
for _ in 0..<N {
let input = Int(readLine()!)!
if input <= 0 { minus.append(input) } // ์์
else if input == 1 { answer += 1 } // 1์ผ ๊ฒฝ์ฐ ๋ฐ๋ก answer์ ๋์
else { plus.append(input) } // ์์
}
plus.sort(by: >)
minus.sort(by: <)
if minus.count % 2 == 1 { answer += minus.removeLast() }
if plus.count % 2 == 1 { answer += plus.removeLast() }
while minus.count > 0 || plus.count > 0 {
if minus.count > 0 { answer += minus.removeLast() * minus.removeLast() }
if plus.count > 0 { answer += plus.removeLast() * plus.removeLast() }
}
print(answer)
๐ ๊ณฑํ์ ๋ ์ด๋์ด ๋๋ ์๋ฅผ ์ฐพ๊ณ , ๋ํ์ ๋ ์ด๋์ด ๋๋ ์๊ฐ ๋ฌด์์ธ์ง ์ ํํ ํ์ ํ๋ ๊ฒ์ด ํต์ฌ!
์ด ๋ฌธ์ ๋ ์์๋ถํฐ ์์๊น์ง ๋ชจ๋ ๋ค๋ฃจ๊ธฐ ๋๋ฌธ์ ์์์ผ ๊ฒฝ์ฐ, 0, 1์ผ ๊ฒฝ์ฐ, ๊ทธ๋ฆฌ๊ณ ์์์ผ ๊ฒฝ์ฐ๋ฅผ ๊ฐ๊ฐ ๊ณ ๋ คํด์ผํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ ํ๋ ๊ณ ๋ คํ ์ ์, ์์๋ ์์๋ ์ต๋ํ ์ ๋๊ฐ์ด ํฐ ์๋ผ๋ฆฌ ๊ณฑํด์ฃผ๋ ๊ฒ์ด ๋์ด ๋๋ค๋ ๊ฒ.
๊ทธ๋ฌ๋ฉด ์ด์ ์์ ์ ์ ๋ฅผ ํ ๋๋ก ์ฐ๋ฆฌ๊ฐ ์ฒ๋ฆฌํ ์ฌํญ๋ค์ ์ ๋ฆฌํด๋ณด์.
1) 0์ดํ์ ์(0๊ณผ ์์)๋ ์ ๋๊ฐ์ด ํฐ ์๋ถํฐ ์ฐจ๋ก๋ก ๊ณฑํด์ฃผ๋ ๊ฒ์ด ๋์ด๋ค.
2) 1์ ๋ช ๊ฐ๊ฐ ๋๋ ๋ํด์ฃผ๋ ๊ฒ์ด ๋์ด๋ค.
3) 2์ด์์ ์์๋ ํฐ ์๋ถํฐ ์ฐจ๋ก๋ก ๊ณฑํด์ฃผ๋ ๊ฒ์ด ๋์ด๋ค.
- ์์ ์ฌํญ๋ค์ ์ ์ ๋ก ๋ฌธ์ ๋ฅผ ํ์ดํ๊ธฐ ์ํด, ์๋ฅผ ์
๋ ฅ๋ฐ์ ๋ (0 ์ดํ / 1 / 2 ์ด์) ์ผ๋ก ๋๋์ด ๋ฐ์๋ค.
1์ ๊ฒฝ์ฐ์๋ ์ด์ฐจํผ ๋ํ๊ธฐ๋ง ํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์, ๋ฐ๋ก answer์ 1์ฉ ๋ํด์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ 0 ์ดํ์ ์๋ minus ๋ฐฐ์ด, 2 ์ด์์ ์๋ plus ๋ฐฐ์ด์ ๊ฐ๊ฐ ๋ด์์ฃผ์๋ค. - plus ๋ฐ minus ๋ฐฐ์ด์ ๋ด๊ธด ์๋ค์ ์ ๋๊ฐ์ด ํฐ ์๋ผ๋ฆฌ ๊ณฑํด์ค ์์ ์ด๊ธฐ์ ์๋ง๊ฒ ์ ๋ ฌํด์ฃผ์๋ค.
ํ์ง๋ง ์๋ฌด๋ฆฌ plus, minus ๋ฐฐ์ด์ ๋ด๊ธด ์๋ค์ด ๊ณฑํ์ ๋ ๋์ด ๋๋ ์์ผ์ง๋ผ๋,
๊ฐ ๋ฐฐ์ด์ ๋ด๊ธด ์์ ๊ฐ์๊ฐ ํ์์ผ ๊ฒฝ์ฐ์๋ ๊ณฑํด์ง ์ ์๋ ์๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์
๊ทธ ๋๋ ์ ์ผ ์์ ์๋ฅผ ๊ทธ๋ฅ ๋ํด์ฃผ๊ธฐ ์ํด์ ์ ๋๊ฐ ๊ธฐ์ค ์์ ์๊ฐ ๋ค๋ก ๊ฐ๋๋ก ์ ๋ ฌํ๋ค. - ๋๋จธ์ง ์ฐ์ฐ์ผ๋ก plus, minus ๋ฐฐ์ด์ ์์ ๊ฐ์๋ฅผ ํ์ธํ์ฌ ํ์์ผ ๊ฒฝ์ฐ์๋
answer์ ๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ฅผ ์ญ์ ํจ๊ณผ ๋์์ ๊ฐ์ ๋์ ํด์ฃผ์๋ค. - minus์ plus ๋ฐฐ์ด ๋ชจ๋ ๋ค์์๋ถํฐ ๋ ๊ฐ์ฉ ๊ณฑํด answer์ ๋์ ํ๋ ๋ฐฉ์์ผ๋ก ์ฐ์ฐํ๋ค.
๐ก ํผ๋๋ฐฑ
- ํ์ด ์ , ๋จผ์ ์ด๋ค ์๋ ๊ณฑํด์ผ ํ๊ณ ์ด๋ค ์๋ ๋ํด์ผํ ์ง ๋ฏธ๋ฆฌ ๊ณ ๋ คํ ํ์ ์ฝ๋๋ฅผ ์์ฑํ๋ ์ฝ๊ฒ ํ ์ ์์๋ค.
๋ฌธ์
'3๏ธโฃ Swift > Problem Solving' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift Algorithm] ํ๋ฆฐํฐ Programmers(Lv.2) (0) | 2021.08.19 |
---|---|
[Swift Algorithm] ๋ค์ง๊ธฐ BOJ #1439 (0) | 2021.08.19 |
[Swift Algorithm] ๊ฒ์์ ๋ง๋ ๋์ค์ด BOJ #2847 (0) | 2021.08.19 |
[Swift Algorithm] ์์ด๋ฒ๋ฆฐ ๊ดํธ BOJ #1541 (2) | 2021.08.18 |
[Swift Algorithm] ATM BOJ #11399 (0) | 2021.08.18 |
๋๊ธ