zoukankan      html  css  js  c++  java
  • 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
    ", (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
    ", p1);
                                            #define p p2
                                            printf("%d%d%d%d%d
    ", p[0], p[1], p[2], p[3], p[4]);
                                            #undef p
                                            #define p p3
                                            printf("%d%d%d%d%d
    ", p[0], p[1], p[2], p[3], p[4]);
                                            #undef p
                                            #define p p4
                                            printf("%d%d%d%d%d
    ", p[0], p[1], p[2], p[3], p[4]);
                                            #undef p
                                            #define p p5
                                            printf("%d%d%d%d%d
    
    ", 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("
    ");
                printf("%d
    %d
    %d
    %d
    %d
    ", 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;
    }
  • 相关阅读:
    python实现读取并显示图片的两种方法
    如何在jupyter中安装R
    FPGA设计千兆以太网MAC(3)——数据缓存及位宽转换模块设计与验证
    FPGA设计千兆以太网MAC(2)——以太网协议及设计规划
    FIFO深度计算
    【不定期更新】FPGA/IC岗位常见笔试面试题总结(基础知识)
    【原创】建立与保持时间裕量详细分析
    利用ZYNQ SOC快速打开算法验证通路(6)——利用AXI总线实时配置sysGen子系统
    【转载】泰勒展开式
    利用ZYNQ SOC快速打开算法验证通路(5)——system generator算法IP导入IP integrator
  • 原文地址:https://www.cnblogs.com/e0e1e/p/usaco_prime3.html
Copyright © 2011-2022 走看看