Written in Java Design a recursive algorithm to find the longest increasing sequence of numbers in a rectangular grid. For example, if the grid contains 97 47 56 36 35 57 41 13 89 36 98 75 25 45 26 17 then the longest increasing sequence of numbers is the sequence of length eight consisting of 17, 26, 36, 41, 47, 56, 57, 97. Design an algorithm that solves the same problem but allows for non-decreasing sequences; thus there may be duplicates in the increasing sequence. Can i get help cleaning this up. it needs to be able to allow duplicates
Java Code
import java. util. Stack;
public class {
private static void (int[][] grid, int r, int c) {
int[][] g = new int[r][c];
for (int a = 0; a < r; a++) {
for (int b = 0; b < c; b++) {
g[a][b] = 1;
}
}
int maxLen = -1;
int idx1 = -1;
int idx2 = -1;
for(int a = 0; a < r; a++){
for(int b = 0; b < c; b++){
if(a > 0 && Math. abs(grid[a][b]-grid[a-1][b])==1){ g[a][b] = Math. max(g[a][b], g[a-1][b]+1);
}
if(b > 0 && Math. abs(grid[a][b]-grid[a][b-1])==1){ g[a][b] = Math. max(g[a][b], g[a][b-1]+1);
}
if(maxLen {
maxLen = g[a][b];
idx1 = a;
idx2 = b;
}
}
}
display(grid, g, maxLen, idx1, idx2);
}
private static void display(int[][] grid, int[][] g, int maxLen, int idx1, int idx2){
Stack s1 = new Stack<>();
while(maxLen >= 1){
s1.add(grid[idx1][idx2]);
if(idx1>0 && Math. abs(g[idx1-1][idx2]-g[idx1][idx2])= =1){
idx1--;
}
else if(idx2 >0 && Math. abs(g[idx1][idx2-1]-g[idx1][idx2])= =1){
idx2--;
}
maxLen--;
}
Stack s2 = helper(s1);
for(Integer integer : s2){
System. out. print(integer+" ");
}

}
public static Stack helper(Stack input){
Stack tempStack = new Stack();
while(!input. isEmpty()){
int temp = input. pop();
while (!tempStack. isEmpty() && tempStack. peek() > temp){
input push(tempStack. pop());
}
tempStack. push(temp);
}
return tempStack;
}
}