USACO 4.3.2 The Primes

搜索加各种剪枝，很悲剧写了N个小时还是超时，只好弃坑了。

（P.S. 谁能再告诉我一些优化思路。。。感激不尽。。。）

测试数据：

------- test 1 ----
11 2
------- test 2 ----
11 1
------- test 3 ----
17 7
------- test 4 ----
29 2
------- test 5 ----
19 8
------- test 6 ----
17 1
------- test 7 ----
19 5
------- test 8 ----
23 7
------- test 9 ----
23 1
------- test 10 ----
23 3

有毒的代码。。。。

#include <stdio.h>

int sum;
char isprime[100000];
int ptbl[10][10000];

pgen(void)
{
int i;
for(i=2; i<100000; ++i) {
if (!isprime[i]) {
if (i > 10000 &&
i % 10 + (i/10 % 10) + (i/100 % 10) + (i/1000) % 10 + i/10000 == sum) {
int c = i / 10000 % 10;
ptbl[c][++ptbl[c][0]] = i;
}
int t;
for(t=i+i; t<100000; t += i)
isprime[t] = 1;
}
}
for(i=0; i<10000; ++i) isprime[i] = 1;
}

//    printf("-->%d\n", (a/10000 * 10000) + (b/1000 % 10) * 1000 + (c / 100 % 10) * 100 + (c / 10 % 10) * 10 + e % 10);
//if (isprime[(a/10000 * 10000) + (b/1000 % 10) * 1000 + (c / 100 % 10) * 100 + (c / 10 % 10) * 10 + e % 10])

int isok(int a, int b, int c, int d, int e, int p2[], int p3[], int p4[], int p5[])
{
int p1[] = {a / 10000, b / 10000, c / 10000, d / 10000, e / 10000};
#define p p2
if (isprime[p[0] * 10000 + p[1] * 1000 + p[2] * 100 + p[3] * 10 + p[4]])
return 0;
#undef p
#define p p3
if (isprime[p[0] * 10000 + p[1] * 1000 + p[2] * 100 + p[3] * 10 + p[4]])
return 0;
#undef p
#define p p4
if (isprime[p[0] * 10000 + p[1] * 1000 + p[2] * 100 + p[3] * 10 + p[4]])
return 0;
#undef p
#define p p5
if (isprime[p[0] * 10000 + p[1] * 1000 + p[2] * 100 + p[3] * 10 + p[4]])
return 0;
int k1, k2, k3, k4, k5;
k1 = p1[0], k2 = p2[1], k3 = p3[2], k4 = p4[3], k5 = p5[4];
if (k1 + k2 + k3 + k4 + k5 != sum || isprime[k1 * 10000 + k2 * 1000 + k3 * 100 + k4 * 10 + k5])
return 0;
k1 = p1[4], k2 = p2[3], k3 = p3[2], k4 = p4[1], k5 = p5[0];
if (k1 + k2 + k3 + k4 + k5 != sum || isprime[k1 * 10000 + k2 * 1000 + k3 * 100 + k4 * 10 + k5])
return 0;
#undef p
#define p p1
return p[0] * 10000 + p[1] * 1000 + p[2] * 100 + p[3] * 10 + p[4];
#undef p
}

int ans[10000][5], index[10000], ansp;

int qcmp(const void *a, const void *b)
{

if (ans[*(int *)a][0] > ans[*(int *)b][0])
return 1;
else if (ans[*(int *)a][0] == ans[*(int *)b][0]) {
if (ans[*(int *)a][1] > ans[*(int *)b][1])
return 1;
else if (ans[*(int *)a][1] == ans[*(int *)b][1]) {
if (ans[*(int *)a][2] > ans[*(int *)b][2])
return 1;
else if (ans[*(int *)a][2] == ans[*(int *)b][2]) {
if (ans[*(int *)a][3] > ans[*(int *)b][3])
return 1;
else if (ans[*(int *)a][3] == ans[*(int *)b][3])
if (ans[*(int *)a][4] > ans[*(int *)b][4])
return 1;
}
}
}
return -1;
}

int main(void)
{
//    freopen("prime3.in", "r", stdin);
//    freopen("prime3.out", "w", stdout);
int a[5], b[5], c;
scanf("%d%d", &sum, &b[0]);

pgen();        // 生成素数表
int t6[5], t7[5];
for(c = 1; c <= ptbl[b[0]][0]; ++c) {
b[1] = ptbl[b[0]][c] / 1000 % 10,
b[2] = ptbl[b[0]][c] / 100 % 10,
b[3] = ptbl[b[0]][c] / 10 % 10,
b[4] = ptbl[b[0]][c] % 10;

if (b[1] && b[2] && b[3]) {
#define k 0
for(a[k] = 1; a[k] <= ptbl[b[k]][0]; ++a[k]) {
int t2[5], t3[5], t4[5], t5[5];
int p2[5], p3[5], p4[5], p5[5];
t6[k] = b[0];
t2[k] = p2[k] = ptbl[b[k]][a[k]] / 1000 % 10;
t3[k] = p3[k] = ptbl[b[k]][a[k]] / 100 % 10;
t4[k] = p4[k] = ptbl[b[k]][a[k]] / 10 % 10;
t5[k] = p5[k] = t7[k] = ptbl[b[k]][a[k]] % 10;

if (ptbl[b[0]][a[0]] / 1000 % 10 &&
ptbl[b[0]][a[0]] / 100 % 10 &&
ptbl[b[0]][a[0]] / 10 % 10) {
#undef k
#define k 1
for(a[k] = 1; a[k] <= ptbl[b[k]][0]; ++a[k]) {
t2[k] = t2[k-1] + (t6[k] = p2[k] = ptbl[b[k]][a[k]] / 1000 % 10);
t3[k] = t3[k-1] + (p3[k] = ptbl[b[k]][a[k]] / 100 % 10);
t4[k] = t4[k-1] + (t7[k] = p4[k] = ptbl[b[k]][a[k]] / 10 % 10);
t5[k] = t5[k-1] + (p5[k] = ptbl[b[k]][a[k]] % 10);
t6[k] += t6[k-1], t7[k] += t7[k-1];
if (t2[k] >= sum || t3[k] >= sum || t4[k] >= sum || t5[k] >= sum || t6[k] >= sum || t7[k] >= sum)
continue;
#undef k
#define k 2
for(a[k] = 1; a[k] <= ptbl[b[k]][0]; ++a[k]) {
t2[k] = t2[k-1] + (p2[k] = ptbl[b[k]][a[k]] / 1000 % 10);
t3[k] = t3[k-1] + (t7[k] = t6[k] = p3[k] = ptbl[b[k]][a[k]] / 100 % 10);
t4[k] = t4[k-1] + (p4[k] = ptbl[b[k]][a[k]] / 10 % 10);
t5[k] = t5[k-1] + (p5[k] = ptbl[b[k]][a[k]] % 10);
t6[k] += t6[k-1], t7[k] += t7[k-1];
if (t2[k] >= sum || t3[k] >= sum || t4[k] >= sum || t5[k] >= sum || t6[k] >= sum || t7[k] >= sum)
continue;
#undef k
#define k 3
for(a[k] = 1; a[k] <= ptbl[b[k]][0]; ++a[k]) {
t2[k] = t2[k-1] + (t7[k] = p2[k] = ptbl[b[k]][a[k]] / 1000 % 10);
t3[k] = t3[k-1] + (p3[k] = ptbl[b[k]][a[k]] / 100 % 10);
t4[k] = t4[k-1] + (t6[k] = p4[k] = ptbl[b[k]][a[k]] / 10 % 10);
t5[k] = t5[k-1] + (p5[k] = ptbl[b[k]][a[k]] % 10);
t6[k] += t6[k-1], t7[k] += t7[k-1];
if (t2[k] >= sum || t3[k] >= sum || t4[k] >= sum || t5[k] >= sum || t6[k] >= sum || t7[k] >= sum)
continue;
#undef k
#define k 4
for(a[k] = 1; a[k] <= ptbl[b[k]][0]; ++a[k]) {
t7[k] = b[4];
t2[k] = t2[k-1] + (p2[k] = ptbl[b[k]][a[k]] / 1000 % 10);
t3[k] = t3[k-1] + (p3[k] = ptbl[b[k]][a[k]] / 100 % 10);
t4[k] = t4[k-1] + (p4[k] = ptbl[b[k]][a[k]] / 10 % 10);
t5[k] = t5[k-1] + (t6[k] = p5[k] = ptbl[b[k]][a[k]] % 10);
t6[k] += t6[k-1], t7[k] += t7[k-1];
if (t2[k] != sum || t3[k] != sum || t4[k] != sum || t5[k] != sum || t6[k] != sum || t7[k] != sum)
continue;
int p1;
if (p1 = isok(ptbl[b[0]][a[0]],
ptbl[b[1]][a[1]],
ptbl[b[2]][a[2]],
ptbl[b[3]][a[3]],
ptbl[b[4]][a[4]], p2, p3, p4, p5)) {
index[ansp] = ansp;
ans[ansp][0] = ptbl[b[0]][a[0]],
ans[ansp][1] = ptbl[b[1]][a[1]],
ans[ansp][2] = ptbl[b[2]][a[2]],
ans[ansp][3] = ptbl[b[3]][a[3]],
ans[ansp][4] = ptbl[b[4]][a[4]];
++ansp;
/*
printf("%d\n", p1);
#define p p2
printf("%d%d%d%d%d\n", p[0], p[1], p[2], p[3], p[4]);
#undef p
#define p p3
printf("%d%d%d%d%d\n", p[0], p[1], p[2], p[3], p[4]);
#undef p
#define p p4
printf("%d%d%d%d%d\n", p[0], p[1], p[2], p[3], p[4]);
#undef p
#define p p5
printf("%d%d%d%d%d\n\n", p[0], p[1], p[2], p[3], p[4]);*/

}
}
}
}
}
}
}
}
}
if (ansp) {

qsort(index, ansp, sizeof(int), qcmp);
for(c=0; c<ansp; ++c) {
if (c) printf("\n");
printf("%d\n%d\n%d\n%d\n%d\n", ans[index[c]][0], ans[index[c]][1], ans[index[c]][2], ans[index[c]][3], ans[index[c]][4]);
}
} else printf("NONE");
return 0;
}