USACO: The Primes

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 top to bottom. Both diagonals are read from left to right.

+---+---+---+---+---+
| 1 | 1 | 3 | 5 | 1 |
+---+---+---+---+---+
| 3 | 3 | 2 | 0 | 3 |
+---+---+---+---+---+
| 3 | 0 | 3 | 2 | 3 |
+---+---+---+---+---+
| 1 | 4 | 0 | 3 | 3 |
+---+---+---+---+---+
| 3 | 3 | 3 | 1 | 1 |
+---+---+---+---+---+ 

• The prime numbers' digits must sum to the same number.
• The digit in the top left-hand corner of the square is pre-determined (1 in the example).
• A prime number may be used more than once in the same square.
• If there are several solutions, all must be presented (sorted in numerical order as if the 25 digits were all one long number).
• A five digit prime number cannot begin with a zero (e.g., 00003 is NOT a five digit prime number).

PROGRAM NAME: prime3

INPUT FORMAT

A single line with two space-separated integers: the sum of the digits and the digit in the upper left hand corner of the square.

SAMPLE INPUT (file prime3.in)

11 1

OUTPUT FORMAT

Five lines of five characters each for each solution found, where each line in turn consists of a five digit prime number. Print a blank line between solutions. If there are no prime squares for the input data, output a single line containing "NONE".

SAMPLE OUTPUT (file prime3.out)

The above example has 3 solutions.

11351
14033
30323
53201
13313

11351
33203
30323
14033
33311

13313
13043
32303
50231
13331

解题思路：

从昨天就在做这道题，题目很简单，做法也很明显（当然可以有多种搜索策略），但是优化却很重要。

第一次写，直接暴力，9重循环，也没预处理数组直接在里面%10...0/10...0这样算，结果超时。

优化了一下，先把素数表打好，压线1.9XX秒过。

不爽，想优化一个高效的出来，于是决定代码全推了重写，今天出去玩了一天回来才算是有时间完成这个程序。

写这么狗血的代码，这种orz的感觉只有自己体验过的才能懂得。。。

 

策略：

尽量让大支在外重循环被剪掉：因为左上角的数字是固定的，这是比较大的一个限制，所以先穷举斜角、第一行、第一列三个素数。然后观察，发现这时另一个斜角的限制最大（3个数已经被确定），枚举它。接着是第二行、第二列，他们也都是3个数字的限制。接着是第三列（或第三行），第三列填上一个固定的值之后，其余空格都可以通过“各位数字和固定”这个条件推算出来。推算玩验证一下就ok了。

输出的时候再排下序。

 

PS：筛法素数表

很多人都知道这个方法，但是也有很多人并不能写出最出色的筛法——他们的算法中往往有很多重复。

这个我个人总结的几个要点：

1、筛法通过在当前数字表中去掉各个已知素数的倍数（2倍及2倍以上）来得到最终的素数表

2、设置一个上限size

3、初始条件，我们已知0和1不是素数，2是素数

4、每次去除完素数x的倍数，那么区间0 ~ (x + 1) ^ 2 - 1剩下的数都是素数

 

 

orz的代码：

/* ID: geterns1 PROG: prime3 LANG: C++ */ #include <iostream> #include <fstream> #include <cstdio> #include <cmath> #include <cstdlib> #include <cstring> #include <algorithm> using namespace std; const int size = 99999; bool prime[size + 1]; int digits[1000][5], cnt = 0; int solution[1000][5], tol = 0; int idxListf[500], cntf = 0; //for those with first digit f int idxList024[10][10][10][50], cnt024[10][10][10]; int idxList013[10][10][10][50], cnt013[10][10][10]; bool checkDigit[10][10][10][10][10]; int main(){ freopen("prime3.in", "r", stdin); freopen("prime3.out", "w", stdout); // int s, f, i, j, k, l, m, n, o; scanf("%d %d", &s, &f); //check primes using sieve method memset(prime, true, sizeof(prime)); prime[0] = prime[1] = false; // int root = int(sqrt(float(size))); for (i = 2; i <= root; i ++) if (prime[i]) for (j = i; i * j <= size; j ++) prime[i * j] = false; //select all the possible primes, in digits int digSum; for (i = 10000; i < 100000; i ++){ if (prime[i]){ digits[cnt][0] = i / 10000; digits[cnt][1] = i % 10000 / 1000; digits[cnt][2] = i % 1000 / 100; digits[cnt][3] = i % 100 / 10; digits[cnt][4] = i % 10; // digSum = 0; for (j = 0; j < 5; j ++) digSum += digits[cnt][j]; if (digSum == s) cnt ++; } } /* ud c0 c1 c3 r0 o o o o o r1 o o o o o o o o o ? o o c23 o r34 o o r42 o o ld */ memset(cnt024, 0, sizeof(cnt024)); memset(cnt013, 0, sizeof(cnt013)); memset(checkDigit, false, sizeof(checkDigit)); for (i = 0; i < cnt; i ++){ if (digits[i][0] == f) idxListf[cntf ++] = i; idxList024[digits[i][0]][digits[i][2]][digits[i][4]][cnt024[digits[i][0]][digits[i][2]][digits[i][4]] ++] = i; idxList013[digits[i][0]][digits[i][1]][digits[i][3]][cnt013[digits[i][0]][digits[i][1]][digits[i][3]] ++] = i; checkDigit[digits[i][0]][digits[i][1]][digits[i][2]][digits[i][3]][digits[i][4]] = true; } // int ud, ld, r0, r1, c0, c1, c3; int r34, r42, c23, orz; //choose upper diagonal for (i = 0; i < cntf; i ++){ ud = idxListf[i]; //choose col 0 for (j = 0; j < cntf; j ++){ c0 = idxListf[j]; //choose row 0 for (k = 0; k < cntf; k ++){ r0 = idxListf[k]; //choose lowwer diagonal for (l = 0; l < cnt024[digits[c0][4]][digits[ud][2]][digits[r0][4]]; l ++){ ld = idxList024[digits[c0][4]][digits[ud][2]][digits[r0][4]][l]; //choose col 1 for (m = 0; m < cnt013[digits[r0][1]][digits[ud][1]][digits[ld][1]]; m ++){ c1 = idxList013[digits[r0][1]][digits[ud][1]][digits[ld][1]][m]; //choose row 1 for (n = 0; n < cnt013[digits[c0][1]][digits[ud][1]][digits[ld][3]]; n ++){ r1 = idxList013[digits[c0][1]][digits[ud][1]][digits[ld][3]][n]; //choose col 3 for (o = 0; o < cnt013[digits[r0][3]][digits[r1][3]][digits[ud][3]]; o ++){ c3 = idxList013[digits[r0][3]][digits[r1][3]][digits[ud][3]][o]; //find r42 r42 = s - digits[c0][4] - digits[c1][4] - digits[c3][4] - digits[ud][4]; if (r42 > -1 && r42 < 10 && checkDigit[digits[c0][4]][digits[c1][4]][r42][digits[c3][4]][digits[ud][4]]){ //find c23 c23 = s - digits[r0][2] - digits[r1][2] - digits[ud][2] - r42; if (c23 > -1 && c23 < 10 && checkDigit[digits[r0][2]][digits[r1][2]][digits[ud][2]][c23][r42]){ r34 = s - digits[c0][3] - digits[c1][3] - c23 - digits[ud][3]; //find r34 if (r34 > -1 && r34 < 10 && checkDigit[digits[c0][3]][digits[c1][3]][c23][digits[ud][3]][r34]){ //at last... orz = s - digits[c0][2] - digits[c1][2] - digits[ud][2] - digits[c3][2]; if (s - digits[r0][4] - digits[r1][4] - r34 - digits[ud][4] == orz && orz > -1 && orz < 10 && checkDigit[digits[c0][2]][digits[c1][2]][digits[ud][2]][digits[c3][2]][orz] && checkDigit[digits[r0][4]][digits[r1][4]][orz][r34][digits[ud][4]]){ solution[tol][0] = digits[r0][0] * 10000 + digits[r0][1] * 1000 + digits[r0][2] * 100 + digits[r0][3] * 10 + digits[r0][4]; solution[tol][1] = digits[r1][0] * 10000 + digits[r1][1] * 1000 + digits[r1][2] * 100 + digits[r1][3] * 10 + digits[r1][4]; solution[tol][2] = digits[c0][2] * 10000 + digits[c1][2] * 1000 + digits[ud][2] * 100 + digits[c3][2] * 10 + orz; solution[tol][3] = digits[c0][3] * 10000 + digits[c1][3] * 1000 + c23 * 100 + digits[c3][3] * 10 + r34; solution[tol][4] = digits[c0][4] * 10000 + digits[c1][4] * 1000 + r42 * 100 + digits[c3][4] * 10 + digits[ud][4]; tol ++; } } } } } } } } } } } //selection sort the solutions bool larger; int tmp[5], hlp; for (i = 0; i < tol; i ++){ hlp = i; //select for (j = i + 1; j < tol; j ++){ larger = false; for (k = 0; k < 5; k ++){ if (solution[hlp][k] > solution[j][k]){ larger = true; break; } else if (solution[hlp][k] < solution[j][k]) break; } if (larger) hlp = j; } //swap if (hlp != i){ for (j = 0; j < 5; j ++) tmp[j] = solution[i][j]; for (j = 0; j < 5; j ++) solution[i][j] = solution[hlp][j]; for (j = 0; j < 5; j ++) solution[hlp][j] = tmp[j]; } } // for (i = 0; i < tol; i ++){ for (j = 0; j < 5; j ++) printf("%d/n", solution[i][j]); if (i < tol - 1) printf("/n"); } if (tol == 0) printf("NONE/n"); // fclose(stdin); fclose(stdout); return 0; }