264、醜數 II | 演算法（leetcode，附思維導圖 + 全部解法）300題

零 標題：演算法（leetcode，附思維導圖 + 全部解法）300題之（264）醜數 II

一 題目描述

二 解法總覽（思維導圖）

三 全部解法

1 方案1

1)程式碼：

// 方案1：“自己。三指標法”。

// 想法：
// 因為每個數字都要被計算三次，一次是乘以2，一次是乘以3，一次是乘以5，
// 所以定義三個指標 —— index_2、index_3、index_5。
// 這三個指標的起點是一樣的，都是0，
// 如果當前的數字是乘以2得到的，就將 index_2 向後移動，
// 如果當前的是乘以3得到的，就將 index_3 向後移動，
// 如果當前的是乘以5得到的，就將 index_5 向後移動。

// 思路：
// 1）狀態初始化：resList = [1], index_2 = 0, index_3 = 0, index_5 = 0; 。

// 2）核心：迴圈處理，條件為 resList.length < n 。
// 2.1）求得下一個醜數 temp = Math.min(resList[index_2] * 2, resList[index_3] * 3, resList[index_5] * 5) 。
// 2.2）看當前醜數是乘哪個數得到的，那麼對應的指標就向後移動。
// 2.3）將當前醜數塞到 陣列 resList 裡。

// 3）返回結果 resList[n-1] 。
var nthUglyNumber = function(n) {
    // 1）狀態初始化：resList = [1], index_2 = 0, index_3 = 0, index_5 = 0; 。
    let resList = [1],
        index_2 = 0,
        index_3 = 0,
        index_5 = 0;

    // 2）核心：迴圈處理，條件為 resList.length < n 。
    while(resList.length < n){
        // 2.1）求得下一個醜數 temp = Math.min(resList[index_2] * 2, resList[index_3] * 3, resList[index_5] * 5) 。
        let temp = Math.min(resList[index_2] * 2, resList[index_3] * 3, resList[index_5] * 5);
        // 可以用 switch 代替 3個if語句、顯得逼格高。不知道為啥行不通 很奇怪！！
        // switch(temp){
        //     case resList[index_2] * 2:
        //         index_2++;
        //         break;
        //     case resList[index_3] * 3:
        //         index_3++;
        //         break;
        //     case resList[index_5] * 5:
        //         index_5++;
        //         break;
        // }

        // 2.2）看當前醜數是乘哪個數得到的，那麼對應的指標就向後移動。
        if(temp === resList[index_2] * 2){
            index_2++;
        }
        if(temp === resList[index_3] * 3){
            index_3++;
        }
        if(temp === resList[index_5] * 5){
            index_5++;
        }

        // 2.3）將當前醜數塞到 陣列 resList 裡。
        resList.push(temp);
    }

    // 3）返回結果 resList[n-1] 。
    return resList[n-1];
};

2 方案2

1)程式碼：

// 方案2 “官方。最小堆法”。
// 參考：
// 1）https://leetcode.cn/problems/ugly-number-ii/solution/chou-shu-ii-by-leetcode-solution-uoqd/

// 思路：
// 1）初始化：factors = [2, 3, 5];
// set = new Set(), heap = new MinHeap(), ugly = 1; set.add(1); heap.insert(1); 。
// 2）核心：迴圈 n - 1次，每次都從最小堆的頂堆中取值。
// 3）返回結果 ugly 。

// 最小堆
// TODO：重新手撕。
class MinHeap {
    constructor() {
        this.heap = [];
    }

    getParentIndex(i) {
        return (i - 1) >> 1;
    }

    getLeftIndex(i) {
        return i * 2 + 1;
    }

    getRightIndex(i) {
        return i * 2 + 2;
    }

    shiftUp(index) {
        if(index === 0) {
            return;
        }

        const parentIndex = this.getParentIndex(index);
        if(this.heap[parentIndex] > this.heap[index]){
            this.swap(parentIndex, index);
            this.shiftUp(parentIndex);
        }  
    }

    swap(i1, i2) {
        const temp = this.heap[i1];
        this.heap[i1]= this.heap[i2];
        this.heap[i2] = temp;
    }

    insert(value) {
        this.heap.push(value);
        this.shiftUp(this.heap.length - 1);
    }

    pop() {
        this.heap[0] = this.heap.pop();
        this.shiftDown(0);
        return this.heap[0];
    }

    shiftDown(index) {
        const leftIndex = this.getLeftIndex(index);
        const rightIndex = this.getRightIndex(index);

        if (this.heap[leftIndex] < this.heap[index]) {
            this.swap(leftIndex, index);
            this.shiftDown(leftIndex);
        }
        if (this.heap[rightIndex] < this.heap[index]){
            this.swap(rightIndex, index);
            this.shiftDown(rightIndex);
        }
    }

    peek() {
        return this.heap[0];
    }

    size() {
        return this.heap.length;
    }
}

var nthUglyNumber = function(n) {
    // 1）初始化：factors = [2, 3, 5];
    // set = new Set(), heap = new MinHeap(), ugly = 1; set.add(1); heap.insert(1); 。
    const factors = [2, 3, 5];
    let set = new Set(),
        heap = new MinHeap(),
        ugly = 1;
    set.add(1);
    heap.insert(1);

    // 2）核心：迴圈 n - 1次，每次都從最小堆的頂堆中取值。
    for (let i = 0; i < n; i++) {
        ugly = heap.pop();
        for (const factor of factors) {
            const next = ugly * factor;
            if (!set.has(next)) {
                set.add(next);
                heap.insert(next);
            }
        }
        
    }

    // 3）返回結果 ugly 。
    return ugly;
};

四 資源分享 & 更多

1 歷史文章 - 總覽

2 博主簡介

碼農三少 ，一個致力於編寫 極簡、但齊全題解（演算法） 的博主。
專注於 一題多解、結構化思維 ，歡迎一起刷穿 LeetCode ~