【USACO3.1.3】丑数 恶心搜索题

TLE方法：

依次找出丑数，从最小的丑数开始用K个素数来扩增，如果这些扩曾出的数字P，没有被加入队列，那么就加入队列。 扩增完后，当前最小丑数出队。 从下一个丑数开始扩增……

我用了SPLAY，我把队列大小限制在50W以内……然后第N个出队的才是正确答案。 40W都不行…… 如果不限制队列大小，貌似计算太慢太慢…… 只能过11个测试点。

Compiling...
Compile: OK

Executing...
Test 1: TEST OK [0.003 secs, 3504 KB]
Test 2: TEST OK [0.003 secs, 3504 KB]
Test 3: TEST OK [0.005 secs, 3504 KB]
Test 4: TEST OK [0.032 secs, 3636 KB]
Test 5: TEST OK [0.049 secs, 3768 KB]
Test 6: TEST OK [0.211 secs, 4692 KB]
Test 7: TEST OK [0.084 secs, 4032 KB]
Test 8: TEST OK [0.062 secs, 3900 KB]
Test 9: TEST OK [0.003 secs, 3504 KB]
Test 10: TEST OK [0.003 secs, 3504 KB]
Test 11: TEST OK [0.003 secs, 3504 KB]

> Run 12: Execution error:

/*
TASK:humble
LANG:C++
*/

#include <cstdio>

int k, n;
int a[102];
void init()
{
scanf("%d%d", &k, &n);
for (int i = 0; i != k; ++ i) scanf("%d", &a[i]);
}

struct node
{
node *c[2];
int key, size;
node()
{
key = size = 0;
c[0] = c[1] = this;
}
node(int KEY_, node *c0, node *c1)
{
key = KEY_;
c[0] = c0;
c[1] = c1;
}
node* rz(){return size = c[0] -> size + c[1] -> size + 1, this;}
}Tnull, *null = &Tnull;

const int maxint = 0x7fffffff;
struct splay
{
node *root;
splay()
{
root = (new node(*null)) -> rz();
root -> key = maxint;
}

void zig(bool d)
{
node *t = root -> c[d];
root -> c[d] = null -> c[d];
null -> c[d] = root;
root = t;
}

void zigzig(bool d)
{
node *t = root -> c[d] -> c[d];
root -> c[d] -> c[d] = null -> c[d];
null -> c[d] = root -> c[d];
root -> c[d] = null -> c[d] -> c[!d];
null -> c[d] -> c[!d] = root -> rz();
root = t;
}

void finish(bool d)
{
node *t = null -> c[d], *p = root -> c[!d];
while (t != null)
{
t = null -> c[d] -> c[d];
null -> c[d] -> c[d] = p;
p = null -> c[d] -> rz();
null -> c[d] = t;
}
root -> c[!d] = p;
}

void select(int k)//谁有k个儿子
{
int t;
while (1)
{
bool d = k > (t = root -> c[0] -> size);
if (k == t || root -> c[d] == null) break;
if (d) k -= t + 1;
bool dd = k > (t = root -> c[d] -> c[0] -> size);
if (k == t || root -> c[d] -> c[dd] == null) {zig(d);break;}
if (dd) k -= t + 1;
d != dd ? zig(d), zig(dd) : zigzig(d);
}
finish(0), finish(1);
root -> rz();
}

void search(int x)
{
while (1)
{
bool d = x > root -> key;
if (root -> c[d] == null) break;
bool dd = x > root -> c[d] -> key;
if (root -> c[d] -> c[dd] == null) {zig(d); break;}
d != dd ? zig(d), zig(dd) : zigzig(d);
}
finish(0), finish(1);
root -> rz();
if (x > root -> key) select(root -> c[0] -> size + 1);
}

void ins(int x)
{
search(x);
node *oldroot = root;
root = new node(x, oldroot -> c[0], oldroot);
oldroot -> c[0] = null;
oldroot -> rz();
root -> rz();
}
void del(int x)
{
search(x);
node *oldroot = root;
root = root -> c[1];
select(0);
root -> c[0] = oldroot -> c[0];
root -> rz();
delete oldroot;
}
int sel(int k){return select(k - 1), root -> key;}
int ran(int x){return search(x), root -> c[0] -> size + 1;}
}sp;

void doit()
{
sp.ins(1);
int count = -1;
while (1)
{
int now = sp.sel(1);
++ count;
if (count == n)
{
printf("%d\n",now);
return;
}
if (sp.root -> size >= 2000000) continue;
for (int i = 0; i != k; ++ i)
{
long long tmp = (long long)now * a[i];
if (tmp > 2000000000) continue;
sp.search(tmp);
int p = sp.root -> key;
if (sp.root->key == tmp) continue;
else sp.ins(tmp);
}
now = sp.sel(1);
sp.del(now);
}
}

int main()
{
freopen("humble.in","r",stdin);
freopen("humble.out","w",stdout);
init();
doit();
return 0;
}


正确方法：

思路： 假如已经有P个丑数，那么我可以把这P个丑数，分别和K个已知素数进行相乘，得到的最小的（同时不能是已经得到的丑数），就是第P+1个丑数。

这其中有一个搜索优化。

第i个素数， 假如和第j个丑数，产生了最小的，也就是第p+1个丑数。 那么这第i个素数，以后如果要产生第X个丑数，他一定从第j个丑数之后搜索。【有点拗口】

细节： 从丑数5，可以产生5*2 = 10.  从丑数2， 可以产生2*5 = 10.  所以在进行产生丑数运算前，要先保证，所有的第i个素数，和他们“当前搜索丑是数j” ，保证素数i * 丑数j > 第P个丑数。

Executing...
Test 1: TEST OK [0.003 secs, 3756 KB]
Test 2: TEST OK [0.003 secs, 3756 KB]
Test 3: TEST OK [0.003 secs, 3756 KB]
Test 4: TEST OK [0.005 secs, 3756 KB]
Test 5: TEST OK [0.008 secs, 3756 KB]
Test 6: TEST OK [0.022 secs, 3756 KB]
Test 7: TEST OK [0.005 secs, 3756 KB]
Test 8: TEST OK [0.005 secs, 3756 KB]
Test 9: TEST OK [0.003 secs, 3756 KB]
Test 10: TEST OK [0.003 secs, 3756 KB]
Test 11: TEST OK [0.003 secs, 3756 KB]
Test 12: TEST OK [0.081 secs, 3756 KB]

All tests OK.

/*
TASK:humble
LANG:C++
*/
#include <cstdio>

int k, n;
int a[102], w[102]={0}, x[100005] = {1};

int main()
{
freopen("humble.in","r",stdin);
freopen("humble.out","w",stdout);
scanf("%d%d", &k, &n);
for (int i = 0; i != k; ++ i) scanf("%d", &a[i]);

for (int j = 1; j <= n; ++ j)
{
int tmp = 0x7fffffff, wz;
for (int i = 0; i != k; ++ i)
while (x[w[i]] * a[i] <= x[j - 1]) ++ w[i];
for (int i = 0; i != k; ++ i)
{
if (x[w[i]] * a[i] < tmp)
{
tmp = x[w[i]] * a[i];
wz = i;
}
}
++ w[wz];
x[j] = tmp;
}
printf("%d\n", x
);
return 0;
}