how to find max sum of adjacent elements in 2d array from a starting point - algorithm

Question

there is 4x4 2d array such as, (range of each element between 0 and 9)
4512
3712
1345
3312
i'm trying to find max of 4 adjacent elements from a point.
( not including diagonal )
for example, if picking a point (1,2) for starting,
can move (1,1) or (2,2) or (1,3) adjacent element from (1,2).
if you choose (2,2) for next, you can move (2,1) or (3,2) or (2,3).
and so on until pick 4 elements.
if you pick 4 elements like,
(1,2)->(2,2)->(2,1)->(1,1)
sum of this is 3 + 7 + 5 + 4 = 19
i'm trying to make possible candidates using dfs or bfs.
but, it can't make the above for the candidate, (1,1) -> (1,2) -> (2,1) -> (2,2)
is there any solution for this problem?

Answer 1

One possible way is to create predefined constants of 5 tetrominoes (sorry, can't post images) with all rotations and reflections (of course you don't need to rotate 'square' or reflect symmetric ones). Then you can take each of these constants and map your starting point to each point of chosen constant.
Another approach is to enumerate tetrominoes algorithmically. Some algorithms are described in wikipedia.

Answer 2

Not complete answer yet
Using dynamic programming.
In sum array(s), value at position (i,j) contains maximum sum possible using (i,j) element and element in direction right or down only.
Missing chain: Will not consider chain of elements like (0,0), (0,1), (1,1) and (1,0)
var array = [
[4, 5, 1, 2],
[3, 7, 1, 2],
[1, 3, 4, 5],
[3, 3, 1, 2],
]
var sum1 = array;
var sum2 = getNextOrderSum(sum1, array);
var sum3 = getNextOrderSum(sum2, array);
var sum4 = getNextOrderSum(sum3, array);
print(sum4);
// Given max sum array of n adjacent elements and original array
// Return max sum array of n+1 adjacent elements
function getNextOrderSum(input, array) {
var sum = [];
for (var i = 0; i < input.length; i++) {
sum[i] = [];
for (var j = 0; j < input[0].length; j++) {
sum[i][j] = array[i][j] + Math.max(get(input, i, j + 1), get(input, i + 1, j));
}
}
return sum;
}
// Utility method to get i,j element of array with boundary checks
function get(array, i, j) {
if (i < 0 || j < 0)
return 0;
if (i >= array.length)
return 0;
if (j >= array[0].length)
return 0;
return array[i][j];
}
// Utility method for printing
function print(array) {
var s = "";
for (var i = 0; i < array.length; i++) {
s += array[i].toString() + "\n"
}
console.log(s);
}

Answer 3

Use a 3D array dp[n][m][4]
where n and m are dimensions of array
and the 4 is used to tell the position of element in chain.
Base case-
We store value of elment (i,j) in dp[i][j][k] if k=3 or when element is last one in chain or if i and j are out of bounds of array (trivial case).
DP formula-
Let function used for doing task be dpFUNCTION()
dp[i][j][k]=array[i][j] + mAX( dpFUNCTION(i+1,j,k+1), dpFUNCTION(i,j+1,k+1), dpFUNCTION(i-1,j,k+1), dpFUNCTION(i,j-1,k+1));
EDIT-
Lets start with simple case and extend it to your problem. Actually you can do most DP questions this way ie by breaking into simple form and extend it.
1)Now, if we only have to find max of adjacent numbers of a number in array we can simply fill dp1[i][j] with-
dp1[i][j]=max(array[i-1][j], array[i+1][j], array[i][j+1], array[i][j-1]);
//max of adjacent numbers
2)Now, if we have to find max of 2 adjacent numbers we can make use of our dp1[][] array as follows-
dp2[i][j]= max(array[i-1][j]+dp1[i-1][j], array[i-1][j]+dp1[i-1][j], array[i-1][j]+dp1[i-1][j], array[i-1][j]+dp1[i-1][j]);
As for chain of length 2, we need to get sum of its adjacent number(say array[i-1][j]) and max of its ajacent numbers(which was computed stored in dp[i-1][j]). Then we store max of all adjacent numbers in dp2.
3)Similarly, if length of chain is 3, we make use of dp2[][] as follows-
dp3[i][j]= max(array[i-1][j]+dp2[i-1][j], array[i-1][j]+dp2[i-1][j], array[i-1][j]+dp2[i-1][j], array[i-1][j]+dp2[i-1][j]);
4)Finally, for chain of length 4, we get-
dp4[i][j]= max(array[i-1][j]+dp3[i-1][j], array[i-1][j]+dp3[i-1][j], array[i-1][j]+dp3[i-1][j], array[i-1][j]+dp3[i-1][j]);
Which is the required solution and what I did was club all these 4 arrays into dp[n][m][4] and filled it a bit chaotic way instead of doing it in steps as explained. You could use same approach even when diagonals are included.