丑数

定义

丑数的定义是指只包含质因数2、3、5的正整数。认为1是第一个丑数。1、2、3、4、5、6...
广义的丑数不限定质因数为2，3，5，而是给定一个数组。

丑数：判断给定的整数是不是丑数。
很简单，直接判断是否只包含这三种因子。也就是当它们能够整除2的时候，就一直做除法。3、5同理。最后得到结果为1就是丑数。不然就是有其他因子。

public boolean isUgly(int num) {
    if(num<=0){
        return false;
    }
    //判断是否只包含这三种因子
    while((num&1)==0){
        num>>=1;
    }
    while(num%3==0){
        num/=3;
    }
    while(num%5==0){
        num/=5;
    }
    return num==1;
}

第n个丑数

丑数 II：找出第n个丑数。丑数序列是1、2、3、4、5、6、8、9...

动态规划

每个丑数都是由前面某个数x2或者x3或者x5得到的。保留三个指针，第一个指针指向2要乘以的“某个数”，第二个指针指向3要乘以的某个数。

丑数序列是从小到大排列的，所以要对2、3、5乘以之后得到的结果作为候选值，来比较大小，选择最小的。如果最小值是2乘积得到的结果，则2对应的指针需要后移。可能同时存在2、3乘积得到的结果都是最小值，这时候他们的指针都要后移。

比如上图，当已有1、2、3、4、5，此时，i2指向2，代表2要取的乘数为res[2]=3，对应候选值23=6,3要取的乘数为res[1]=2,对应候选值32=6，5要取的乘数为res[1]=2,对应候选值为5*2=10.三个候选值中，最小值是6，且2和3都对应6，所以i2和i3同时向后走。

public int nthUglyNumber(int n) {
    if(n<=0){
        return -1;
    }
    int factor2=0,factor3=0,factor5=0;
    int[] res=new int[n];
    res[0]=1;
    for(int i=1;i<n;i++){
        int candi2=res[factor2]*2;
        int candi3=res[factor3]*3;
        int candi5=res[factor5]*5;
        int min=Math.min(Math.min(candi2,candi3),candi5);
        res[i]=min;
        if(min==candi2){
            factor2++;
        }
        if(min==candi3){
            factor3++;
        }
        if(min==candi5){
            factor5++;
        }
    }
    return res[n-1];
}

堆

通过在最小堆的堆顶取值得到最小值。并且如果有连续都是min则要一直取。
每次遍历得到res[i]时，把res[i]和三个因子相乘得到的结果放入最小堆中。
这样的时间复杂度为O(nlogn）。

超级丑数

变形的丑数：
超级丑数:找第n个超级丑数。所有质因数都是质数列表primes数组（长度k）里的数。

思路：类似上面丑数的解决方式，但是需要把三个元素扩展到对数组的处理。

动态规划

求res[i]时，是求k个质因数乘以自己的乘数得到的候选数的集合中的最小值。然后谁和最小值相等，则谁的指针后移。
时间复杂度为O(N*k）

堆

对应上一题的用堆的解法，也是直接把求res[i]，并把res[i]和所有prime的乘积放入堆中。

动态规划+堆

根据动态规划的解法，可以稍微优化是用最小堆来保存这k个数的候选数，拿出最小值，并把它对应的质因数下标后移。并且如果还有最小值，则继续后移。
时间复杂度O(N x m x logk），m是连续能有多少个相等的。

public int nthSuperUglyNumber(int n, int[] primes) {
    if(n<=0){
        return -1;
    }
    int m=primes.length;
    int[] res=new int[n];
    res[0]=1;
    int[] factors=new int[m];
    PriorityQueue<int[]> queue=new PriorityQueue<>((a,b)->(a[0]-b[0]));
    for(int i=0;i<m;i++){
        queue.add(new int[]{res[factors[i]]*primes[i],i});
    }
    for(int i=1;i<n;i++){
        int[] node=queue.poll();
        int min=node[0];
        int id=node[1];
        res[i]=min;//注意这个要放在前面来，res[++factors[id]]可能需要
        queue.add(new int[]{res[++factors[id]]*primes[id],id});
        while(!queue.isEmpty()&&queue.peek()[0]==min){
            node=queue.poll();
            id=node[1];
            queue.add(new int[]{res[++factors[id]]*primes[id],id});
        }
    }
    return res[n-1];
}

特殊的丑数，只要求能整除任意一个

丑数 III:找到第n个丑数。这道题的丑数和之前的都不一样，”丑数是可以被a或b或c整除的正整数“。

输入：n = 5, a = 2, b = 11, c = 13
输出：10
解释：丑数序列为 2, 4, 6, 8, 10, 11, 12, 13... 其中第 5 个是 10。

结果在 [1, 2 * 10^9] 的范围内
n, a, b, c <= 10⁹
这里能看到6能够整除2，但是6包含因子3并不在a、b、c中。所以只要求能整除，并不要求所有因子都在abc中。

这里如果套用以前的做法，用i2代替res[i2]，则会超时，因为n,abc的范围是<=10^{9，求n的时候，需要O(N*3)的时间。}

用以前类似堆的做法：对每个i，都把i*a,b,c加入堆中。然后获得第n个（这里可以不用动态更新，所以可以完全加入之后再排序）。——时间复杂度也是O(NlogN)，会超时。

在O(N)都会超时的情况下，只能想到O(logN）了，所以可以尝试用二分查找。对于找到的mid，判断是不是第n个。
找x是第几个丑数：就是找[0,x]有多少个数能被a或者b或者c整除。0~x有多少个数能被a整除意味着x/a有多少个。

画个韦恩图，避免把同时是ab的倍数的重复计算。总共有：cnt=x/a+x/b+x/c-x/a/b-x/a/c-x/b/c+x/a/b/c
注意这里不能用x/a/b代表x同时能够被a、b整除。因为当a=4，b=6，其实x只需要能整除12，就能整除a和b。所以应该求最小公倍数
x/a+x/b+x/b-x/lcm(a,b)-x/lcm(b,c)-x/lcm(a,c)+x/lcm(a,b,c)

找到这样的x后，x不一定是丑数。如果p是第n个丑数，x属于[p+min(a,b,c))（左闭右开的区间）都能满足x对应的cnt=n。所以二分法求得n对应的mid后，需要在[mid,mid-min(a,b,c)）上找到能够%a或者b或者c的。这个方法时间当a、b、c都不小时，复杂度有点高

第一个满足条件的

找到满足条件的第一个mid即可。

注意ab的最小公倍数有可能超出int范围，需要用long表示。

public int nthUglyNumber(int n, int a, int b, int c) {
    long lcm_ab=getLCM(a,b);
    long lcm_ac=getLCM(a,c);
    long lcm_bc=getLCM(b,c);
    long lcm_abc=getLCM(lcm_ab,c);
    int min=Math.min(Math.min(a,b),c);
    int left=min;
    int right=2000000000;
    while(left<=right){
        int mid=((right-left)>>1)+left;
        long cnt=getCnt(mid,lcm_ab,lcm_ac,lcm_bc,lcm_abc,a,b,c);
        if(cnt<n){//右
            left=mid+1;
        }else if(cnt>n){//左
            right=mid-1;
        }else{//cnt==n
            if(getCnt(mid-1,lcm_ab,lcm_ac,lcm_bc,lcm_abc,a,b,c)<n){//第一个=
                return mid;
            }else{//左
                right=mid-1;
                left=Math.max(left,mid-min+1);//这里能够稍微缩小一下left的范围

            }
        }
    }
    return -1;
}

private long getCnt(long mid,long lcm_ab,long lcm_bc,long lcm_ac,long lcm_abc,int a,int b,int c){//求[0,mid]有多少个数字能被abc整除
    return (mid/a+mid/b+mid/c-mid/lcm_ac-mid/lcm_bc-mid/lcm_ab+mid/lcm_abc);
}

private long getLCM(long a,long b){//求最小公倍数
    long gcd=getGCD(a,b);
    return a/gcd*b;
}

private long getGCD(long a,long b){
    if(a<b){
        long tmp=b;
        b=a;
        a=tmp;
    }
    while(b!=0){
        long mod=a%b;
        long chu=a/b;
        a=b;
        b=mod;
    }
    return a;
}

找到后直接计算

之前提到“找到这样的x后，x不一定是丑数。如果p是第n个丑数，x属于[p+min(a,b,c))（左闭右开的区间）都能满足x对应的cnt=n。”其实mid-min(mid%a,mid%b,mid%c)就能得到比mid小，离mid最近的满足条件的数。

public int nthUglyNumber(int n, int a, int b, int c) {
    long lcm_ab=getLCM(a,b);
    long lcm_ac=getLCM(a,c);
    long lcm_bc=getLCM(b,c);
    long lcm_abc=getLCM(lcm_ab,c);
    //System.out.println(lcm_ab+" "+lcm_ac+" "+lcm_bc+" "+lcm_abc);
    int min=Math.min(Math.min(a,b),c);
    int left=min;
    int right=2000000000;
    int mid=0;
    while(left<=right){
        mid=((right-left)>>1)+left;
        long cnt=getCnt(mid,lcm_ab,lcm_ac,lcm_bc,lcm_abc,a,b,c);
        //System.out.println(mid+":"+cnt);
        if(cnt<n){//右
            left=mid+1;
        }else if(cnt>n){//左
            right=mid-1;
        }else{//cnt==n
            break;
        }
    }

    mid=mid-Math.min(Math.min(mid%a,mid%b),mid%c);
    return mid;
}