[jobdu]丑数

由于思维的惯性，用了queue。后来发现一要注意要用集合判重，二是每次往queue里放的多，后来溢出了，要用long long。但这样要用数组，集合，队列，内存多。效率是O(n*logn)的。

#include <iostream>
#include <algorithm>
#include <memory.h>
#include <vector>
#include <queue>
#include <set>
#include <functional>
#define LEN 1505
#define ulong unsigned long long
using namespace std;

ulong dp[LEN];

int main()
{
    priority_queue<ulong, vector<ulong>, greater<ulong> > que;
    set<ulong> visit;
    que.push(1);
    visit.insert(1);
    int i = 0;
    while (i < LEN) {
        i++;
        int node = que.top();
        que.pop();
        dp[i] = node;
        if (visit.count(node*2) == 0) {
            que.push(node*2);
            visit.insert(node*2);
        }
        if (visit.count(node*3) == 0) {
            que.push(node*3);
            visit.insert(node*3);
        }
        if (visit.count(node*5) == 0) {
            que.push(node*5);
            visit.insert(node*5);
        }
    }
    int n;
    while (cin >> n) {
        cout << dp[n] << endl;
    }
}

另有效率O(n)，空间O(1)的方法。因为本质上是已有的丑数*2，*3，*5的结果在竞争，那么每次记录*2，*3，*5的丑数的编号（用数组记录已经生成的丑数），然后比较产生最小的，就是下一个丑数。

http://blog.csdn.net/acm_zl/article/details/10613073

#include <iostream>
#include <memory.h>
#define MIN(a,b) a<b?a:b
#define LEN 1505
#define ulong unsigned long long
using namespace std;

ulong ugly[LEN];

int main()
{
    memset(ugly, 0, sizeof(ugly));
    ugly[1] = 1;
    int index2 = 1;
    int index3 = 1;
    int index5 = 1;
    for (int i = 2; i < LEN; i++)
    {
        ulong m2 = 2 * ugly[index2];
        ulong m3 = 3 * ugly[index3];
        ulong m5 = 5 * ugly[index5];
        int tmp = MIN(m2, m3);
        ulong m = MIN(tmp, m5);
        ugly[i] = m;
        if (m == m2) index2++;
        if (m == m3) index3++;
        if (m == m5) index5++;
    }

    int n;
    while (cin >> n) {
        cout << ugly[n] << endl;
    }
}