
๐งก๋ฌธ์  ์ค๋ช
์คํธ๋ ์์ฆ ๋ํ์ค ๊ฒ์์ ํน ๋น ์ ธ ์์ต๋๋ค. ๋ํ์ค ๊ฒ์์ ์คํธ๊ฐ ๋ณด์ ํ ๋ณ์ฌ 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
}
์ง์ง ๊ธฐ๊ฐ ๋งํ ํ์ด๋ฒ์ ๋๋ค
์ด๋ถํ์์ผ๋ก ํ ์๊ฐ๋ ๋ชปํ์ต๋๋ค..