解题思路

这是一道丑数的经典题目，主要思路如下：

  1. 问题分析：

    • 丑数是只包含因子2、3和5的数
    • 1是第一个丑数
    • 需要找到第 个丑数
    • 例如：1, 2, 3, 4, 5, 6, 8, 9, 10, 12是前10个丑数

  2. 解决方案：

    • 方法一：暴力法（给定代码的方案）
      • 从1开始遍历每个数
      • 判断是否是丑数
      • 直到找到第 个丑数
    • 方法二：动态规划（优化方案）
      • 用三个指针记录乘2、3、5的位置
      • 每次取最小值作为新的丑数
      • 更新对应指针

代码

#include <iostream>
using namespace std;

// 优化解法
int getNthUglyNumber(int n) {
    if(n <= 0) return 0;
    
    int* dp = new int[n];
    dp[0] = 1;
    int p2 = 0, p3 = 0, p5 = 0;
    
    for(int i = 1; i < n; i++) {
        int next2 = dp[p2] * 2;
        int next3 = dp[p3] * 3;
        int next5 = dp[p5] * 5;
        
        dp[i] = min(next2, min(next3, next5));
        
        if(dp[i] == next2) p2++;
        if(dp[i] == next3) p3++;
        if(dp[i] == next5) p5++;
    }
    
    int result = dp[n-1];
    delete[] dp;
    return result;
}

int main() {
    int n;
    while(cin >> n) {
        cout << getNthUglyNumber(n) << endl;
    }
    return 0;
}

import java.util.Scanner;

public class Main {
    public static int getNthUglyNumber(int n) {
        if(n <= 0) return 0;
        
        int[] dp = new int[n];
        dp[0] = 1;
        int p2 = 0, p3 = 0, p5 = 0;
        
        for(int i = 1; i < n; i++) {
            int next2 = dp[p2] * 2;
            int next3 = dp[p3] * 3;
            int next5 = dp[p5] * 5;
            
            dp[i] = Math.min(next2, Math.min(next3, next5));
            
            if(dp[i] == next2) p2++;
            if(dp[i] == next3) p3++;
            if(dp[i] == next5) p5++;
        }
        
        return dp[n-1];
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int n = sc.nextInt();
            System.out.println(getNthUglyNumber(n));
        }
        sc.close();
    }
}

def get_nth_ugly_number(n: int) -> int:
    if n <= 0:
        return 0
        
    dp = [0] * n
    dp[0] = 1
    p2 = p3 = p5 = 0
    
    for i in range(1, n):
        next2 = dp[p2] * 2
        next3 = dp[p3] * 3
        next5 = dp[p5] * 5
        
        dp[i] = min(next2, next3, next5)
        
        if dp[i] == next2:
            p2 += 1
        if dp[i] == next3:
            p3 += 1
        if dp[i] == next5:
            p5 += 1
    
    return dp[n-1]

def main():
    while True:
        try:
            n = int(input())
            print(get_nth_ugly_number(n))
        except EOFError:
            break

if __name__ == "__main__":
    main()

算法及复杂度

  • 算法：动态规划
  • 时间复杂度： - 只需要遍历一次
  • 空间复杂度： - 需要dp数组存储中间结果