The Primes[USACO]

最新推荐文章于 2024-04-30 17:09:10 发布
最新推荐文章于 2024-04-30 17:09:10 发布
阅读量110 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/doublemystery/archive/2013/04/11/3015053.html
版权

这道题无论横着，竖着，一行/列来整体放都会超时，想不到什么好办法。只好写了个超长的switch case语句，想清楚瞅仔细，就省得调试麻烦了。

//00-17-11-18-03
//21-04-22-08-15
//12-19-05-20-10
//23-07-24-06-16
//02-13-09-14-01

上图是处理顺序，从00--24.  实际只用了15个case，因为有一些是可以计算出来的。之所以是这个顺序是为了把循环次数小的case放前头。运行速度还是很快的。

 

 

/*
ID: zhangyc1
LANG: C++
TASK: prime3
*/
//00-17-11-18-03
//21-04-22-08-15
//12-19-05-20-10
//23-07-24-06-16
//02-13-09-14-01
#include <fstream>
#include <iostream>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <algorithm>
using namespace std;

stringstream os;
ofstream fileout("prime3.out");

int nFirstNum, nCommonSum;
// 因为sqrt(99999)=316.23，计算base为
int arrBasePrimeSet[100], nSizeBasePrimeSet = 0;
bool arrIsPrime[10][10][10][10][10];
bool bFound = false;
int arrMul[5] = {10000, 1000, 100, 10, 1};
int arrLastNum[4] = {1, 3, 7, 9};
int arrSumLine[5], arrSumCol[5], arrSumDia[2];
vector<string> vtRs;
int arrNum[5][5];

void getBasePrimeSet()
// 筛法求2-317内素数
{
    bool arrIsPrime[318];
    memset(arrIsPrime, 1, sizeof(arrIsPrime));
    int nPos = 2;
    while (nPos < 318)
    {
        arrBasePrimeSet[nSizeBasePrimeSet] = nPos;
        nSizeBasePrimeSet++;

        int nThresh = 317 / nPos;
        for (int i = 2; i < nThresh; i++)
        {
            arrIsPrime[i * nPos] = false;
        }
        nPos++;
        while (nPos < 318 && arrIsPrime[nPos] == false)
            nPos++;
    }
}
// 10000至99999内满足和为nCommonSum
void getValidPrimeSet()
{
    int arrDigit[5];
    for (int i = 10001; i <= 99999; i++)
    {
        int nTemp = i;
        for (int j = 4; j >= 0; j--)
        {
            arrDigit[j] = nTemp % 10;
            nTemp /= 10;
        }

        if (arrDigit[0] + arrDigit[1] + arrDigit[2] + arrDigit[3] + arrDigit[4] == nCommonSum)
        {
            bool bValid = true;
            for (int j = 0; j < nSizeBasePrimeSet; j++)
            {
                if (i % arrBasePrimeSet[j] == 0)
                {
                    bValid = false;
                    break;
                }
            }
            if (bValid)
            {
                arrIsPrime[arrDigit[0]][arrDigit[1]][arrDigit[2]][arrDigit[3]][arrDigit[4]] = true;
            }
        }
    }
}

void prepairData()
{
    ifstream filein("prime3.in");
    filein >> nCommonSum >> nFirstNum;
    filein.close();
    memset(arrIsPrime, 0, sizeof(arrIsPrime));
}

void recordRs()
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            os << arrNum[i][j];
        }
    }
    string str;
    os >> str;
    os.clear();
    vtRs.push_back(str);
}

void dfs(int nDepth)
{
    switch (nDepth)
    {
    case 0:
        arrNum[0][0] = nFirstNum;
        arrSumLine[0] = nFirstNum;
        arrSumCol[0] = nFirstNum;
        arrSumDia[0] = nFirstNum;
        dfs(1);
    	break;
    case 1:
        for (int i = 0; i < 4; i++)
        {
            arrNum[4][4] = arrLastNum[i];
            arrSumLine[4] += arrLastNum[i];
            arrSumCol[4] += arrLastNum[i];
            arrSumDia[0] += arrLastNum[i];
            if (arrSumLine[4] <= nCommonSum && arrSumCol[4] <= nCommonSum && arrSumDia[0] <= nCommonSum)
            {
                dfs(2);
            }
            arrSumLine[4] -= arrLastNum[i];
            arrSumCol[4] -= arrLastNum[i];
            arrSumDia[0] -= arrLastNum[i];
        }
        break;
    case 2:
        for (int i = 0; i < 4; i++)
        {
            arrNum[4][0] = arrLastNum[i];
            arrSumLine[4] += arrLastNum[i];
            arrSumCol[0] += arrLastNum[i];
            arrSumDia[1] += arrLastNum[i];
            if (arrSumLine[4] <= nCommonSum && arrSumCol[0] <= nCommonSum && arrSumDia[1] <= nCommonSum)
            {
                dfs(3);
            }
            arrSumLine[4] -= arrLastNum[i];
            arrSumCol[0] -= arrLastNum[i];
            arrSumDia[1] -= arrLastNum[i];
        }
        break;
    case 3:
        for (int i = 0; i < 4; i++)
        {
            arrNum[0][4] = arrLastNum[i];
            arrSumLine[0] += arrLastNum[i];
            arrSumCol[4] += arrLastNum[i];
            arrSumDia[1] += arrLastNum[i];
            if (arrSumLine[0] <= nCommonSum && arrSumCol[4] <= nCommonSum && arrSumDia[1] <= nCommonSum)
            {
                dfs(4);
            }
            arrSumLine[0] -= arrLastNum[i];
            arrSumCol[4] -= arrLastNum[i];
            arrSumDia[1] -= arrLastNum[i];
        }
        break;
    case 4:
        for (int i = 0; i <= 9; i++)
        {
            arrNum[1][1] = i;
            arrSumLine[1] += i;
            arrSumCol[1] += i;
            arrSumDia[0] += i;
            if (arrSumLine[1] <= nCommonSum && arrSumCol[1] <= nCommonSum && arrSumDia[0] <= nCommonSum)
            {
                dfs(5);
            }
            arrSumLine[1] -= i;
            arrSumCol[1] -= i;
            arrSumDia[0] -= i;
        }
        break;
    case 5:
        for (int i = 0; i <= 9; i++)
        {
            int nLeft = nCommonSum - i - arrSumDia[0];
            if (nLeft >= 0 && nLeft <= 9 && arrIsPrime[arrNum[0][0]][arrNum[1][1]][i][nLeft][arrNum[4][4]])
            {
                arrNum[2][2] = i;
                arrNum[3][3] = nLeft;
                arrSumLine[2] += i, arrSumLine[3] += nLeft;
                arrSumCol[2] += i, arrSumCol[3] += nLeft;
                arrSumDia[0] = nCommonSum;
                arrSumDia[1] += i;
                dfs(7);
                arrSumLine[2] -= i, arrSumLine[3] -= nLeft;
                arrSumCol[2] -= i, arrSumCol[3] -= nLeft;
                arrSumDia[0] = nCommonSum - i  - nLeft;
                arrSumDia[1] -= i;
            }
        }
        break;
    case 7:
        for (int i = 0; i <= 9; i++)
        {
            int nLeft = nCommonSum - i - arrSumDia[1];
            if (nLeft >= 0 && nLeft <= 9 && arrIsPrime[arrNum[4][0]][i][arrNum[2][2]][nLeft][arrNum[0][4]])
            {
                arrNum[3][1] = i;
                arrNum[1][3] = nLeft;
                arrSumLine[3] += i, arrSumLine[1] += nLeft;
                arrSumCol[1] += i, arrSumCol[3] += nLeft;
                arrSumDia[1] = nCommonSum;
                dfs(9);
                arrSumLine[3] -= i, arrSumLine[1] -= nLeft;
                arrSumCol[1] -= i, arrSumCol[3] -= nLeft;
                arrSumDia[1] = nCommonSum - i  - nLeft;
            }
        }
        break;
    case 9:
        for (int i = 0; i < 4; i++)
        {
            arrNum[4][2] = arrLastNum[i];
            arrSumLine[4] += arrLastNum[i];
            arrSumCol[2] += arrLastNum[i];
            if (arrSumLine[4] <= nCommonSum && arrSumCol[2] <= nCommonSum)
            {
                dfs(10);
            }
            arrSumLine[4] -= arrLastNum[i];
            arrSumCol[2] -= arrLastNum[i];
        }
        break;
    case 10:
        for (int i = 0; i < 4; i++)
        {
            arrNum[2][4] = arrLastNum[i];
            arrSumLine[2] += arrLastNum[i];
            arrSumCol[4] += arrLastNum[i];
            if (arrSumLine[2] <= nCommonSum && arrSumCol[4] <= nCommonSum)
            {
                dfs(11);
            }
            arrSumLine[2] -= arrLastNum[i];
            arrSumCol[4] -= arrLastNum[i];
        }
        break;
    case 11:
        for (int i = 1; i <= 9; i++)
        {
            arrNum[0][2] = i;
            arrSumLine[0] += i;
            arrSumCol[2] += i;
            if (arrSumLine[0] <= nCommonSum && arrSumCol[2] <= nCommonSum)
            {
                dfs(12);
            }
            arrSumLine[0] -= i;
            arrSumCol[2] -= i;
        }
        break;
    case 12:
        for (int i = 1; i <= 9; i++)
        {
            arrNum[2][0] = i;
            arrSumLine[2] += i;
            arrSumCol[0] += i;
            if (arrSumLine[2] <= nCommonSum && arrSumCol[0] <= nCommonSum)
            {
                dfs(13);
            }
            arrSumLine[2] -= i;
            arrSumCol[0] -= i;
        }
        break;
    case 13:
        for (int i = 0; i < 4; i++)
        {
            int nLeft = nCommonSum - arrSumLine[4] - arrLastNum[i];
            if (nLeft > 0 && nLeft <= 9 && arrIsPrime[arrNum[4][0]][arrLastNum[i]][arrNum[4][2]][nLeft][arrNum[4][4]])
            {
                arrNum[4][1] = arrLastNum[i], arrNum[4][3] = nLeft;
                arrSumLine[4] = nCommonSum;
                arrSumCol[1] += arrLastNum[i], arrSumCol[3] += nLeft;
                dfs(15);
                arrSumLine[4] -= nLeft + arrLastNum[i];
                arrSumCol[1] -= arrLastNum[i], arrSumCol[3] -= nLeft;
            }
        }
        break;
    case 15:
        for (int i = 0; i < 4; i++)
        {
            int nLeft = nCommonSum - arrSumCol[4] - arrLastNum[i];
            if (nLeft > 0 && nLeft <= 9 && arrIsPrime[arrNum[0][4]][arrLastNum[i]][arrNum[2][4]][nLeft][arrNum[4][4]])
            {
                arrNum[1][4] = arrLastNum[i], arrNum[3][4] = nLeft;
                arrSumCol[4] = nCommonSum;
                arrSumLine[1] += arrLastNum[i], arrSumLine[3] += nLeft;
                dfs(17);
                arrSumCol[4] -= nLeft + arrLastNum[i];
                arrSumLine[1] -= arrLastNum[i], arrSumLine[3] -= nLeft;
            }
        }
        break;
    case 17:
        for (int i = 1; i <= 9; i++)
        {
            int nLeft1 = nCommonSum - arrSumLine[0] - i;
            int nLeft2 = nCommonSum - arrSumCol[1] - i;
            int nLeft3 = nCommonSum - arrSumLine[2] - nLeft2;
            if (nLeft1 > 0 && nLeft1 <= 9  && nLeft2 >= 0 && nLeft2 <= 9 && nLeft3 >= 0 && nLeft3 <= 9 && 
                nLeft1 + nLeft3 + arrSumCol[3] == nCommonSum && 
                arrIsPrime[arrNum[0][0]][i][arrNum[0][2]][nLeft1][arrNum[0][4]] &&
                arrIsPrime[arrNum[2][0]][nLeft2][arrNum[2][2]][nLeft3][arrNum[2][4]] &&
                arrIsPrime[i][arrNum[1][1]][nLeft2][arrNum[3][1]][arrNum[4][1]] &&
                arrIsPrime[nLeft1][arrNum[1][3]][nLeft3][arrNum[3][3]][arrNum[4][3]])
            {
                arrNum[0][1] = i, arrNum[0][3] = nLeft1, arrNum[2][1] = nLeft2, arrNum[2][3] = nLeft3;
                arrSumLine[0] = arrSumLine[2] = arrSumCol[1] = arrSumCol[3] = nCommonSum;
                dfs(21);
                arrSumLine[0] -= i + nLeft1, arrSumLine[2] -= nLeft2 + nLeft3;
                arrSumCol[1] -= i + nLeft2, arrSumCol[3] -= nLeft1 + nLeft3;
            }
        }
        break;
    case 21:
        for (int i = 1; i <= 9; i++)
        {
            int nLeft1 = nCommonSum - arrSumLine[1] - i;
            int nLeft2 = nCommonSum - arrSumCol[0] - i;
            int nLeft3 = nCommonSum - arrSumLine[3] - nLeft2;
            if (nLeft2 > 0 && nLeft2 <= 9 && nLeft1 >= 0 && nLeft1 <= 9 && nLeft3 >= 0 && nLeft3 <= 9 && 
                nLeft1 + nLeft3 + arrSumCol[2] == nCommonSum && 
                arrIsPrime[i][arrNum[1][1]][nLeft1][arrNum[1][3]][arrNum[1][4]] &&
                arrIsPrime[nLeft2][arrNum[3][1]][nLeft3][arrNum[3][3]][arrNum[3][4]] &&
                arrIsPrime[arrNum[0][0]][i][arrNum[2][0]][nLeft2][arrNum[4][0]] &&
                arrIsPrime[arrNum[0][2]][nLeft1][arrNum[2][2]][nLeft3][arrNum[4][2]])
            {
                arrNum[1][0] = i, arrNum[3][0] = nLeft2, arrNum[1][2] = nLeft1, arrNum[3][2] = nLeft3;
                recordRs();
            }
        }
        break;
    }
}

void process()
{
    getBasePrimeSet();
    getValidPrimeSet();
    dfs(0);
    if (vtRs.size() == 0)
    {
        fileout << "NONE\n";
    }
    else
    {
        sort(vtRs.begin(), vtRs.end());
        string strTemp;
        for (vector<string>::const_iterator it = vtRs.begin(); it != vtRs.end(); it++)
        {
            if (it != vtRs.begin())
            {
                fileout << endl;
            }
            strTemp = *it;
            fileout << strTemp.substr(0, 5) << "\n" << strTemp.substr(5, 5) << "\n" << strTemp.substr(10, 5) << "\n" << strTemp.substr(15, 5) << "\n"
                << strTemp.substr(20, 5) << "\n";
        }
    }
}

int main(){
    prepairData();
    process();
    fileout.close(); 
    return 0;
}

　　

转载于:https://www.cnblogs.com/doublemystery/archive/2013/04/11/3015053.html

weixin_30655219
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
primes.c
03-20
primes.c
USACO 4.3 The Primes
jasison
04-18 677
题意： 给两个值，sum和head，求出所有
usaco training 4.3.2 The Primes 题解
阿蒋的专栏
02-27 2110
序言：总算AC了。我花了一个半小时编完了程序，又花了两个小时调试程序，眼睛都花了。尽管在种种挫折前，我屡次萌生“放弃此题，随便贴个代码”的想法，但最终还是挺过去了。 这种方阵题很是多见。原来我都是直接暴力地顺序枚举（准确地说是有顺序枚举）。但是在这个题目面前，效率显然是非常低的。经过很长时间的探索，我总结出了一张枚举顺序的图。
[USACO 6.4.1] The Primes
weixin_30544657的博客
08-04 93
题目大意 　　给一个5*5的矩阵,在每个格子里面填入0~9这10个数字.要求行从左往右读,列从上往下读,两条对角线从上往下读是一个5位素数且不含前导0. 　　现在给出了开头的数字和行,列,对角线之和,求符合规定的所有数字矩阵. 题解 　　这是一道搜索题. 　　但盲目的搜索是会TLE的.因此,我们应当采用合理的剪枝. 　　由题目可知,加入行列对角线我们知道了任意4位数,我们可以推出第5位...
USACO 4.3.2 the primes
inc(Arthur's fighting)
04-13 651
人的一生中总能遇到几道想prime3这样百做不厌的好题！啥也不多说了，祭出代码吧！/* ID: wangqia6 TASK: prime3 LANG: C++ */ #include #include using namespace std; struct { long num[6],next; } node[100000]; struct matrix { long rec[6][6]; } ans[10000]; long tmp[6][6],hea
USACO Section 4.3 The Primes - 好恶心的搜索
zzyzzy12
01-17 1252
看题目名字是质数..以为是水题...读完题目更觉得是水题..范围这么小..先打个质数表不就秒了么~~结果...纠结了一下午一晚上..写了150行代码终于整出来了...确实这题就是搜索..但要讲究策略.     1.先打表是必须的..注意的是这个表打得是既是素数且每位相加又是所要求的数的5位数..并且了为避免重复计算..在这里就可以把每个符合要求的数给拆分好记录...     2.我这里不论是确
F.c.zip_The Prime
09-21
prime finding it is realy good for finding primes that algorithm finds the primes O(n)
primes:PRIMES 游戏
06-05
素数 的克隆。 贡献 列维·安东·汉施密德 弗洛里安·维德迈尔
primes_panel
03-19
primes_panel
New-folder-(4).rar_The Common
09-23
We begin with choosing two random large distinct primes p and q. We also pick e, a random integer that is relatively prime to (p-1)*(q-1). The random integer e is the encryption exponent. Let n = p*...
usaco 4.3.2 The Primes
mnlm1991的专栏
12-25 609
<br />开始的时候自己写的代码最多只能过7组数据。我一直想不把输出存起来，直接找到一个就输出，这样的话就只能一行一行枚举，这样的话填的时候限制条件就很少了。搞到最后所有可以想到的剪枝都用了，还是只能过7组数据。没办法只好搜一下解题报告，原来别人都是把输出存起来的。这样的话限制条件就多了。<br />填表顺序：<br />第一行，第一列；<br />左下到右上；<br />左上到右下；<br />第二行，第二列，第四行，第四列；<br />第三行，第三列；<br />这样的顺序就是为了使限制条件尽可能的多
USACO The Primes 解题报告
thestoryofsnow的专栏
08-05 591
感觉不会再爱了。
USACO 4.3.2 The Primes
weixin_30266829的博客
04-11 75
搜索加各种剪枝，很悲剧写了N个小时还是超时，只好弃坑了。 （P.S. 谁能再告诉我一些优化思路。。。感激不尽。。。） 测试数据： ------- test 1 ----11 2------- test 2 ----11 1------- test 3 ----17 7------- test 4 ----29 2------- test 5 ----19 8------- test...
USACO6.4-The Primes
weixin_30611509的博客
11-25 66
The Primes IOI'94 In the square below, each row, each column and the two diagonals can be read as a five digit prime number. The rows are read from left to right. The columns are read from to...
USACO: The Primes
03-12 287
The Primes<br />IOI'94<br />In the square below, each row, each column and the two diagonals can be read as a five digit prime number. The rows are read from left to right. The columns are read from top to bottom. Both diagonals are read from left to right
USACO 6.4.1 The Primes 搜索剪枝
Frontier_Setter的博客
02-14 273
http://train.usaco.org/usacoprob2?a=gY0nBCREMEt&amp;S=prime3题目大意：往一个5*5的方阵填数字，最左上角数字给定，要求每一行每一列两个对角线（都是从左到右看）是一个五位素数，且的五位上的数字之和确定（给定）一道令人绝望的搜索题，尝试了四个版本终于过了虽然搜索题给人的感觉往往是麻烦又没什么意义，但这道题（也确实如此）让我第一次接触到了搜索树...
The Primes
原味
11-22 637
题意：有一个大小为N的数列，数列中都是以正整数代表的价格，求最长的降序子列的长度以及个数（子列中元素的先后顺序要与原来的数列中相同，而且对于全部元素都相等的子列只能算作一个） 解题思路： 用price[0...N-1]来代表这个数列，用f[i] = j来代表以price[i]为第一个元素的最长降序子列的长度为j初始条件f[N - 1] = 1，倒序滚雪球的过程：f[i] = max{f[j
C++类型转换攻略
无敌岩雀的博客
04-30 1473
在C++编程中，类型转换（Type Conversion）是一个核心概念，它指的是将一个数据类型的值转换为另一个数据类型的值的过程。这种转换可能是隐式的（由编译器自动执行），也可能是显式的（由程序员通过特定的语法明确指示）。类型转换在编程中至关重要，因为它允许程序员灵活地处理不同数据类型的数据，并能够在需要时将它们转换为兼容的类型，以便进行进一步的计算或操作。
【全国青少年信息素养大赛智能算法挑战赛初中模拟卷】
最新发布
qq_56949201的博客
04-30 695
5. C++中的`std::shared_ptr`是一个智能指针，它允许多个指针共享对一个对象的所有权。5. C++中的`std::unique_lock`是一个智能锁，它提供了可互斥的锁机制。5. C++中的`std::unique_ptr`是一个智能指针，它拥有它所指向的对象。2. C++中的`std::stack`容器基于`std::deque`实现。9. 在C++中，哪个关键字用于声明一个函数是内联的，并且是类的成员函数？4. 在C++中，`catch`块必须紧跟在`try`块之后。
matlab primes
02-13
在MATLAB中，primes函数是一个用于生成素数的内置函数。它可以返回小于或等于给定输入值的所有素数。primes函数的语法如下： primes(n) 其中，n是一个正整数，表示要生成素数的范围。primes函数将返回一个包含小于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值