๐งก๋ฌธ์ ์ค๋ช
์คํธ๋ ์์ฆ ๋ํ์ค ๊ฒ์์ ํน ๋น ์ ธ ์์ต๋๋ค. ๋ํ์ค ๊ฒ์์ ์คํธ๊ฐ ๋ณด์ ํ ๋ณ์ฌ n
๋ช
์ผ๋ก ์ฐ์๋๋ ์ ์ ๊ณต๊ฒฉ์ ์์๋๋ก ๋ง๋ ๊ฒ์์
๋๋ค. ๋ํ์ค ๊ฒ์์ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ผ๋ก ์งํ๋ฉ๋๋ค.
์คํธ๋ ์ฒ์์ ๋ณ์ฌ n
๋ช
์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
๋งค ๋ผ์ด๋๋ง๋ค enemy[i]
๋ง๋ฆฌ์ ์ ์ด ๋ฑ์ฅํฉ๋๋ค.
๋จ์ ๋ณ์ฌ ์ค enemy[i]
๋ช
๋งํผ ์๋ชจํ์ฌ enemy[i]
๋ง๋ฆฌ์ ์ ์ ๋ง์ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ๋จ์ ๋ณ์ฌ๊ฐ 7๋ช
์ด๊ณ , ์ ์ ์๊ฐ 2๋ง๋ฆฌ์ธ ๊ฒฝ์ฐ, ํ์ฌ ๋ผ์ด๋๋ฅผ ๋ง์ผ๋ฉด 7 - 2 = 5๋ช
์ ๋ณ์ฌ๊ฐ ๋จ์ต๋๋ค.
๋จ์ ๋ณ์ฌ์ ์๋ณด๋ค ํ์ฌ ๋ผ์ด๋์ ์ ์ ์๊ฐ ๋ ๋ง์ผ๋ฉด ๊ฒ์์ด ์ข
๋ฃ๋ฉ๋๋ค.
๊ฒ์์๋ ๋ฌด์ ๊ถ์ด๋ผ๋ ์คํฌ์ด ์์ผ๋ฉฐ, ๋ฌด์ ๊ถ์ ์ฌ์ฉํ๋ฉด ๋ณ์ฌ์ ์๋ชจ์์ด ํ ๋ผ์ด๋์ ๊ณต๊ฒฉ์ ๋ง์ ์ ์์ต๋๋ค.
๋ฌด์ ๊ถ์ ์ต๋ k
๋ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์คํธ๋ ๋ฌด์ ๊ถ์ ์ ์ ํ ์๊ธฐ์ ์ฌ์ฉํ์ฌ ์ต๋ํ ๋ง์ ๋ผ์ด๋๋ฅผ ์งํํ๊ณ ์ถ์ต๋๋ค.
์คํธ๊ฐ ์ฒ์ ๊ฐ์ง๊ณ ์๋ ๋ณ์ฌ์ ์ n
, ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฌด์ ๊ถ์ ํ์ k
, ๋งค ๋ผ์ด๋๋ง๋ค ๊ณต๊ฒฉํด์ค๋ ์ ์ ์๊ฐ ์์๋๋ก ๋ด๊ธด ์ ์ ๋ฐฐ์ด enemy
๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์คํธ๊ฐ ๋ช ๋ผ์ด๋๊น์ง ๋ง์ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐์ ํ์ฌํญ
n
โค 1,000,000,000k
โค 500,000enemy
์ ๊ธธ์ด โค 1,000,000enemy[i]
โค 1,000,000enemy[i]
์๋ i + 1 ๋ผ์ด๋์์ ๊ณต๊ฒฉํด์ค๋ ์ ์ ์๊ฐ ๋ด๊ฒจ์์ต๋๋ค.enemy[i]
์ ๊ธธ์ด๋ฅผ return ํด์ฃผ์ธ์.๐์ ์ถ๋ ฅ ์
n | k | enemy | result |
---|---|---|---|
7 | 3 | [4, 2, 4, 5, 3, 3, 1] | 5 |
2 | 4 | [3, 3, 3, 3] | 4 |
๐์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์#1
์ ์ถ๋ ฅ ์#2
๐๋์ ํ์ด
์ฒ์ ๋์ ํ์ด๋ ์ด๋ฌํ ๋๋์ด์๋ค
ํจ์จ์ฑ ๋ฌธ์ ๋ ๊ทธ๋ ๊ณ ํ์ด ์์ฒด๊ฐ ์๋ชป๋์๋ค๋๊ฑธ ๊นจ๋ซ๊ณ ์ฐธ๊ณ ํ ๋งํ ๋ฌธ์๋ฅผ ์ฐพ๊ธฐ ์์ํ์
function solution(n, k, enemy) {
let result = 0
const sortedEnemy = enemy.sort((a,b) => b-a).slice(0,k).sort((a,b) => a-b)
for(let i = 0 ; i < enemy.length ; i ++) {
// ๋ฌด์ ๊ถ์ ์ฌ์ฉํด์ผํ๋ ๊ฒฝ์ฐ๋ผ๋ฉด
const useNoDie = sortedEnemy.indexOf(enemy[i])
if(useNoDie > -1) {
sortedEnemy.splice(useNoDie,1)
k--
// ์ด๋ฒ ๋ณ์ฌ๋ฅผ ๋ง์ ์ ์๋ ๋ณ๋ ฅ์ด๋ ๋ฌด์ ๊ถ์ด ์๋ค๋ฉด
} else if(n >= enemy[i]) {
n-=enemy[i]
} else if(k > 0) {
k--
} else {
break
}
result++
}
// ๋ชจ๋ ๋ผ์ด๋๋ฅผ ๋ง์ ์ ์๋ค๋ฉด
if(result === enemy.length) {
return enemy.length
}
return result
}
์ด ๋ฌธ์ ๋ ์ด๋ถํ์
์ผ๋ก ํด๊ฒฐํด์ผํ๋ค. ์๋๋ฉด ํ
๋ฅผ ์ฌ์ฉํ ์์
์ ํด์ผํ๋๋ฐ ๋ ์ด๋ถํ์
ํ์ด๋ฒ์ด ์กฐ๊ธ ๋ ๋ง๋ ๊ฒ ๊ฐ์
function solution(n, k, enemy) {
// ์ด๋ถ ํ์์ ์งํํ๊ธฐ ์ํ left, mid, right ๋ณ์ ์ ์ธ
let [left, right] = [0, enemy.length]
let mid = Math.floor((left+right)/2)
while(left <= right) {
// ํด๋น ํ์์์ ์ฌ์ฉ๋ ๊ธธ์ด ๋ด๋ฆผ์ฐจ ์(k ์์ง์ ์ํจ)
const curSlice = enemy.slice(0, mid).sort((a,b) => b-a)
let noDie = k
// ์ ์ ํ ๋จ์ ์๋ ๋ณ์ฌ์ ์
const curEnemy = curSlice.reduce((acc, cur) => {
// ๋ฌด์ ๊ถ์ด ์๋ค๋ฉด
if(noDie > 0) {
noDie--
return acc
}
return acc+cur
}, 0)
// ์๋ ๋ณ์ฌ๋ฅผ ๋ฌด์ ๊ถ ํ๋ ๋ด์ ๋ชจ๋ ๋ฌด์ฐ๋ฅผ ์ ์๋๊ฐ?
if(n-curEnemy >= 0 && noDie >= 0) {
left = mid + 1
} else {
right = mid - 1
}
mid = Math.floor((left+right)/2)
}
return left-1
}
์ง์ง ๊ธฐ๊ฐ ๋งํ ํ์ด๋ฒ์ ๋๋ค
์ด๋ถํ์์ผ๋ก ํ ์๊ฐ๋ ๋ชปํ์ต๋๋ค..