欧拉练习第11题[Project Euler 011]之我见

一次无意中看到cnblogs上讨论的欧拉练习第11题http://www.cnblogs.com/zhouyinhui/archive/2011/02/15/1954801.html，感觉应该可以从相邻两组的比较上进行优化。今天晚上终于熬夜把程序写出来了，虽然结果对了，但肯定还有许多的不足之处，希望大家不吝指正。

题目（黄色背景是要找出的结果）：

In the 20 x 20 grid below, four numbers along a diagonal line have been marked in red.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 x 63 x 78 x 14 = 1788696.

What is the greatest product of four adjacent numbers in any direction (up, down, left, right, or diagonally) in the 20 x 20 grid? 

我的解答：

#include <iostream> using namespace std; class NumGroup { int *_p[4]; int _dir; public: void modify(int *p, int dir) { _p[0] = p; _dir = dir; switch (_dir) { case 0: _p[1] = _p[0]+1; _p[2] = _p[1]+1; _p[3] = _p[2]+1; break; case 1: _p[1] = _p[0]+20; _p[2] = _p[1]+20; _p[3] = _p[2]+20; break; case 2: _p[1] = _p[0]+20-1; _p[2] = _p[1]+20-1; _p[3] = _p[2]+20-1; break; case 3: _p[1] = _p[0]+20+1; _p[2] = _p[1]+20+1; _p[3] = _p[2]+20+1; break; } } // dir:方向 0右 1下 2左下 3右下 NumGroup(int *p, int dir) { modify(p, dir); } int Mul() { return *_p[0] * *_p[1] * *_p[2] * *_p[3]; } bool hasZero() { return *_p[0]==0 || *_p[1]==0 || *_p[2]==0 || *_p[3]==0; } // 跟它的下一组比较乘积大小 // 因为它跟它相邻组有三个数相同，唯一不同的数的大小即决定乘积的大小。（包含0除外） int compNext() { switch (_dir) { case 0: return *_p[0] - *(_p[3]+1); case 1: return *_p[0] - *(_p[3]+20); case 2: return *_p[0] - *(_p[3]+19); case 3: return *_p[0] - *(_p[3]+21); } return 0; } int * firstPoint() { return _p[0]; } }; int main() { char* source[] = { "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08", "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00", "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65", "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91", "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80", "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50", "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70", "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21", "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72", "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95", "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92", "16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57", "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58", "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40", "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66", "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69", "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36", "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16", "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54", "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48" }; int data[20][20]; for (int i = 0; i < 20; i++) { sscanf(source[i], "%02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d", data[i], data[i]+1, data[i]+2, data[i]+3, data[i]+4, data[i]+5, data[i]+6, data[i]+7, data[i]+8, data[i]+9, data[i]+10, data[i]+11, data[i]+12, data[i]+13, data[i]+14, data[i]+15, data[i]+16, data[i]+17, data[i]+18, data[i]+19); } int max = 0; // 找出横向最大乘积 for (int i = 0; i < 20; i++) { int j = 0; NumGroup MaxNG(data[i]+j, 0); while (j<17) { // 找到第一个不含0的组 while (j<17 && MaxNG.hasZero()) { j++; MaxNG.modify(data[i]+j, 0); } while (j<17 && !MaxNG.hasZero()) { // 当后续组比自己小或到结尾处的时候，判断自身乘积是否比当前最大乘积大。 if (j==16 || MaxNG.compNext()>0) { int mm = MaxNG.Mul(); if (mm > max) { max = mm; } } j++; MaxNG.modify(data[i]+j, 0); } } } // 找出纵向最大乘积 for (int i = 0; i < 20; i++) { int j = 0; NumGroup MaxNG(data[j]+i, 1); while (j<17) { // 找到第一个不含0的组 while (j<17 && MaxNG.hasZero()) { j++; MaxNG.modify(data[j]+i, 1); } while (j<17 && !MaxNG.hasZero()) { // 当后续组比自己小或到结尾处的时候，判断自身乘积是否比当前最大乘积大。 if (j==16 || MaxNG.compNext()>0) { int mm = MaxNG.Mul(); if (mm > max) { max = mm; } } j++; MaxNG.modify(data[j]+i, 1); } } } // 找出左下方向最大乘积 for (int i = 3; i < 20; i++) { int j = 0; NumGroup MaxNG(data[j]+i-j, 2); int len = i-2; while (j<len) { // 找到第一个不含0的组 while (j<len && MaxNG.hasZero()) { j++; MaxNG.modify(data[j]+i-j, 2); } while (j<len && !MaxNG.hasZero()) { // 当后续组比自己小或到结尾处的时候，判断自身乘积是否比当前最大乘积大。 if (j==len-1 || MaxNG.compNext()>0) { int mm = MaxNG.Mul(); if (mm > max) { max = mm; } } j++; MaxNG.modify(data[j]+i-j, 2); } } } for (int i = 1; i < 17; i++) { int j = i; NumGroup MaxNG(data[j]+19+i-j, 2); int len = 17; while (j<len) { // 找到第一个不含0的组 while (j<len && MaxNG.hasZero()) { j++; MaxNG.modify(data[j]+19+i-j, 2); } while (j<len && !MaxNG.hasZero()) { // 当后续组比自己小或到结尾处的时候，判断自身乘积是否比当前最大乘积大。 if (j==len-1 || MaxNG.compNext()>0) { int mm = MaxNG.Mul(); if (mm > max) { max = mm; } } j++; MaxNG.modify(data[j]+19+i-j, 2); } } } // 找出右下方向最大乘积 for (int i = 0; i < 17; i++) { int j = 0; NumGroup MaxNG(data[j]+i+j, 3); int len = 17-i; while (j<len) { // 找到第一个不含0的组 while (j<len && MaxNG.hasZero()) { j++; MaxNG.modify(data[j]+i+j, 3); } while (j<len && !MaxNG.hasZero()) { // 当后续组比自己小或到结尾处的时候，判断自身乘积是否比当前最大乘积大。 if (j==len-1 || MaxNG.compNext()>0) { int mm = MaxNG.Mul(); if (mm > max) { max = mm; } } j++; MaxNG.modify(data[j]+i+j, 3); } } } for (int i = 1; i < 17; i++) { int j = i; NumGroup MaxNG(data[j]+j-i, 3); int len = 17; while (j<len) { // 找到第一个不含0的组 while (j<len && MaxNG.hasZero()) { j++; MaxNG.modify(data[j]+j-i, 3); } while (j<len && !MaxNG.hasZero()) { // 当后续组比自己小或到结尾处的时候，判断自身乘积是否比当前最大乘积大。 if (j==len-1 || MaxNG.compNext()>0) { int mm = MaxNG.Mul(); if (mm > max) { max = mm; } } j++; MaxNG.modify(data[j]+j-i, 3); } } } cout << max << endl; return 0; }