丑数

题目

把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

思路

所谓的一个数m是另一个数n的因子，是指n能被m整除，也就是n%m==0。根据丑数的定义，丑数只能被2、3和5整除。根据丑数的定义，丑数应该是另一个丑数乘以2、3或者5的结果（1除外）。因此我们可以创建一个数组，里面的数字是排好序的丑数，每一个丑数都是前面的丑数乘以2、3或者5得到的。

这个思路的关键问题在于怎样保证数组里面的丑数是排好序的。对乘以2而言，肯定存在某一个丑数T2，排在它之前的每一个丑数乘以2得到的结果都会小于已有最大的丑数，在它之后的每一个丑数乘以乘以2得到的结果都会太大。我们只需要记下这个丑数的位置，同时每次生成新的丑数的时候，去更新这个T2。对乘以3和5而言，也存在着同样的T3和T5。

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if(index <1){
            return 0;
        }
        int twoCount =0;
        int threeCount =0;
        int fiveCount =0;
        int[] dp = new int[index];
        dp[0] = 1;
        for(int i =1;i<index;i++){
           dp[i] = Math.min(Math.min(dp[twoCount]*2,dp[threeCount]*3),dp[fiveCount]*5);
            if(dp[twoCount]*2 ==dp[i]){
                twoCount++;
            }
            if(dp[threeCount]*3 ==dp[i]){
                threeCount++;
            }
            if(dp[fiveCount]*5 ==dp[i]){
                fiveCount++;
            }
        }
        return dp[index-1];
    }
}

代码(判断是不是丑数)

public boolean isUgly(int num) {
        if(num == 0){
            return false;
        }
        while (num != 1){
            if(num % 2 == 0){
                num /= 2;
                continue;
            }
            if(num % 3 == 0){
                num /= 3;
                continue;
            }
            if(num % 5 == 0){
                num /= 5;
                continue;
            }
            return false;
        }

        return true;
        
    }

代码2

 //控制乘以2的位置，假设得到一个丑数是乘以2得到的，
        //那么下一次就是数组中的下一个丑数可能达到。

public class isUgly {
    public static void main(String[] args) {
        int num = 1500;
        System.out.println(GetUglyNumber_Solution(num));
    }
    public static int GetUglyNumber_Solution(int index) {
        if(index <= 0)
            return 0;
        int [] res = new int[index];
        res[0] = 1;
        //先把1放入
        int m2 = 0;
        //控制乘以2的位置，假设得到一个丑数是乘以2得到的，
        //那么下一次就是数组中的下一个丑数可能达到。
        int m3 = 0;
        int m5 = 0;
        for (int i = 1; i < index; i++) {
            int min = Math.min(res[m2]*2, Math.min(res[m3]*3, res[m5]*5));
            res[i] = min;
            //最小的那个作为当前的丑数
            //判断是由谁乘以得到的
            if(res[m2] *2 == min)
                //假设res[1]是乘以2得到的丑数，那么下一次就要判断
                //是否是res[2]乘以2可能得到丑数，所以就要++
                m2++;
            if(res[m3]*3 == min)
                m3++;
            if(res[m5]*5 == min)
                m5++;
        }
        return res[index - 1];
    }

LeetCode中判断某个数是否丑数

class Solution{
	public boolean isUgly(int num){
		if(num==Integer.MAX_VALUE)
			return false;
		List<Integer>list=new ArrayList<>();
		list.add(1);
		int t2=0,t3=0,t5=0;
		int curNum=1,i=0;
		while(curNum<num){
			curNum=min(list.get(t2)*2,list.get(t3)*3,list.get(t5)*5);
			list.add(curNum); i++;
			if(list.get(t2)*2==list.get(i)) t2++;
			if(list.get(t3)*3==list.get(i)) t3++;
			if(list.get(t5)*5==list.get(i)) t5++;
		}
		if(curNum==num)
			return true;
		else return false;
	}
	public int min(int a,int b,int c){
		int res=a>b?b:a;
		return res>c?c:res;
	}
}