ProjectEuler - 11

问题 :

In the 20×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 × 63 × 78 × 14 = 1788696.

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

翻译：

在这20*20的矩阵中，求出横，竖，左斜，右斜相邻的四个数中乘积最大的四个数的积？

代码：

package projectEuler;

import java.io.ObjectInputStream.GetField;
import java.util.Scanner;

public class Problem11 {
	private static final int WIDTH = 20;
	private static final int HIGHT = 20;
	public static void main(String[] args) {
		int[][] array = new int[WIDTH][HIGHT];//要求矩阵
		long[][] max = new long[WIDTH][HIGHT];//存放以i，j为顶点的数的四个方向的积的最大值
		long[] temp = new long[4];//一个顶点四个方向的乘积
		Scanner s = new Scanner(System.in);
		for(int i=0; i<WIDTH; i++){
			for(int j=0; j<HIGHT; j++){
				array[i][j] = s.nextInt();
			}
		}
		System.out.println();
		for(int i=0; i<WIDTH; i++){
			for(int j=0; j<HIGHT; j++){
				temp[0]=temp[1]=temp[2]=temp[3]=0;
				temp[0] = getHorizontal(array,i,j);
				temp[1] = getVertical(array,i,j);
				temp[2] = getRightDiagonal(array,i,j);
				temp[3] = getLeftDiagonal(array,i,j);
				max[i][j] = getMax(temp);
			}
		}
		
		//打印每个顶点的四个方向乘积最大的值
		System.out.println();
		for(int i=0; i<WIDTH; i++){
			for(int j=0; j<HIGHT; j++){
				System.out.printf("%8d ", max[i][j]);
			}
			System.out.println();
		}
		
		System.out.println();
		System.out.println("Max="+getAllMax(max));
		
	}
	
	//得到所有四个方向乘积的最大值的矩阵的最大值
	static long getAllMax(long[][] arr){
		long maxNum = 0;
		for(int i=0; i<WIDTH; i++){
			for(int j=0; j<HIGHT; j++){
				if(arr[i][j] > maxNum){
					maxNum = arr[i][j];
				}
			}
		}
		return maxNum;
	}
	
	//得到顶点四个方向最大的值
	static long getMax(long[] arr) {
		int maxIndex = 0;
		for (int i = maxIndex + 1; i < arr.length; i++) {
			if (arr[i] > arr[maxIndex]) {
				maxIndex = i;
			}
		}
		return arr[maxIndex];
	}
	
	//一个顶点水平积
	static long getHorizontal(int[][] arr, int i, int j) {
		if (i + 3 < WIDTH) {
			return arr[i][j] * arr[i + 1][j] * arr[i + 2][j] * arr[i + 3][j];
		} else {
			return 0;
		}
	}
	
	//一个顶点竖排积
	static long getVertical(int[][] arr, int i, int j) {
		if (j + 3 < HIGHT) {
			return arr[i][j] * arr[i][j + 1] * arr[i][j + 2] * arr[i][j + 3];
		} else {
			return 0;
		}
	}
	
	//一个顶点右斜积
	static long getRightDiagonal(int[][] arr, int i, int j) {
		if (i + 3 < WIDTH && j + 3 < HIGHT) {
			return arr[i][j] * arr[i + 1][j + 1] * arr[i + 2][j + 2] * arr[i + 3][j + 3];
		} else {
			return 0;
		}
	}
	
	//一个顶点左斜积
	static long getLeftDiagonal(int[][] arr, int i, int j) {
		if (i - 3 >= 0 && j + 3 < HIGHT) {
			return arr[i][j] * arr[i-1][j+1] * arr[i-2][j+2] * arr[i-3][j+3];
		} else {
			return 0;
		}
	}
}

思路还是比较简单，关键是判断每个方向越界的条件。比如：水平的话就是i+3要小于width， 竖直就是j+3小于hight