Develop Reference

Stack Overflow Error in a Self Calling Function in Java (Number of Islands)

I did some research on what causes a stack overflow errors, and I can conclude it is being caused by a recursive function in a program that is supposed to "count the number of islands" in an array. I understand what is causing the issue, but not sure why this is happening, or my main question is what to actually do about it. I found that if I slow down the program by having it repeatedly printing out something to the console, it works, but it takes forever to complete. Is there a way I can keep the program speed without the error, or a better way to solve the problem (search up "number of islands" to find the problem). Also, the array is two dimensional with a size of 1050 by 800.
public class NumOfIslands {
static boolean[][] dotMap = new boolean[1050][800];
static boolean visited[][] = new boolean[1050][800];
static int total = 0;
public static void main(String args[]) {
defineArrays();
run();
}
public static void findObjects(int xCord, int yCord) {
for(int y = yCord - 1; y <= yCord + 1; y++) {
for(int x = xCord - 1; x <= xCord + 1; x++) {
if(x > -1 && y > -1 && x < dotMap[0].length && y < dotMap.length) {
if((x != xCord || y != yCord) && dotMap[x][y] == true && visited[x][y] != true) {
visited[x][y] = true;
findObjects(x,y);
//System.out.println("test");
}
}
}
}
}
public static void defineArrays() {
for(int y = 0; y < 800; y++) {
for(int x = 0; x < 1050; x++) {
dotMap[x][y] = true;
}
}
}
public static int run() {
//dotMap = DisplayImage.isYellow;
System.out.println(dotMap.length + " " + dotMap[0].length);
int objects = 0;
for(int y = 439; y < 560/*dotMap[0].length*/; y++) {
for(int x = 70; x < 300/*dotMap.length*/; x++) {
if(dotMap[x][y] == true && visited[x][y] != true) {
visited[x][y] = true;
objects++;
findObjects(x,y);
}
}
}
System.out.println("total" + total);
System.out.println(objects);
return objects;
}
}

StackOverflowError reasons. In your example each call to findObjects adds 2 variables to the stack int x and int y from loops.
One of the fastest solution:
class Solution {
int m, n;
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) {
return 0;
}
m = grid.length;
n = grid[0].length;
int counter = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == '1') {
visit(grid, i, j);
counter++;
}
}
}
return counter;
}
public void visit(char[][] grid, int i, int j) {
if (i < 0 || i >= m || j < 0 || j >= n) {
return;
}
if (grid[i][j] == '0') {
return;
}
grid[i][j] = '0';
visit(grid, i - 1, j);
visit(grid, i + 1, j);
visit(grid, i, j - 1);
visit(grid, i, j + 1);
}
}
All recursive algorithms can be implemented with loops. One of the example is below. The Solution implements BFS (Breadth-first search) algorithm, more details on wikipedia.
class Solution {
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) {
return 0;
}
int nr = grid.length;
int nc = grid[0].length;
int num_islands = 0;
for (int r = 0; r < nr; ++r) {
for (int c = 0; c < nc; ++c) {
if (grid[r][c] == '1') {
++num_islands;
grid[r][c] = '0'; // mark as visited
Queue<Integer> neighbors = new LinkedList<>();
neighbors.add(r * nc + c);
while (!neighbors.isEmpty()) {
int id = neighbors.remove();
int row = id / nc;
int col = id % nc;
if (row - 1 >= 0 && grid[row-1][col] == '1') {
neighbors.add((row-1) * nc + col);
grid[row-1][col] = '0';
}
if (row + 1 < nr && grid[row+1][col] == '1') {
neighbors.add((row+1) * nc + col);
grid[row+1][col] = '0';
}
if (col - 1 >= 0 && grid[row][col-1] == '1') {
neighbors.add(row * nc + col-1);
grid[row][col-1] = '0';
}
if (col + 1 < nc && grid[row][col+1] == '1') {
neighbors.add(row * nc + col+1);
grid[row][col+1] = '0';
}
}
}
}
}
return num_islands;
}
}

the problem is in this function
public static void findObjects(int xCord, int yCord) {
for(int y = yCord - 1; y <= yCord + 1; y++) {
for(int x = xCord - 1; x <= xCord + 1; x++) {
if(x > -1 && y > -1 && x < dotMap[0].length && y < dotMap.length) {
if((x != xCord || y != yCord) && dotMap[x][y] == true && visited[x][y] != true) {
visited[x][y] = true;
findObjects(x,y);
//System.out.println("test");
}
}
}
}
}`
at here you are builiding a stack of recursive calls to findobjects and ultimately it has no termination condition so it ends up at infinite stacks of findobjects, so my solution is if you are just checking that if x and y varaibles are not equal and visited[x][y] is not true then there is no need to call for recursion just comment the recursive call, because your loop already do what you want the recursive call to do.
public static void findObjects(int xCord, int yCord) {
for(int y = yCord - 1; y <= yCord + 1; y++) {
for(int x = xCord - 1; x <= xCord + 1; x++) {
if(x > -1 && y > -1 && x < dotMap[0].length && y < dotMap.length) {
if((x != xCord || y != yCord) && dotMap[x][y] == true && visited[x][y] != true) {
visited[x][y] = true;
//findObjects(x,y);
//System.out.println("test");
}
}
}
}
}

A* Pathfinding very slow

I wrote a pathfinding algorithm for android. It seems to be running very slowly and I can not figure out why. I have asked a similar question before, but I didn't get the answers I was looking for (And I have changed code since then). Here is my path finding class :
public class Pathfinding {
private static Node[][] grid;
private static NodeComparator nodeComparator;
static{
nodeComparator = new NodeComparator();
}
public static class NodeComparator implements Comparator<Node> {
#Override
public int compare(Node node1, Node node2) {
if(node1.F > node2.F){
return 1;
}
else if(node1.F < node2.F){
return -1;
}
else{
return 0;
}
}
}
public static Array<Node> findPath(Node start, Node finish, Node[][] _grid) {
Array<Node> path = new Array<Node>();
Array<Node> openList = new Array<Node>();
Array<Node> closedList = new Array<Node>();
grid = _grid;
if(start == null){
return path;
}
if(finish == null){
return path;
}
Node currentNode = start;
currentNode.G = 0;
currentNode.H = getHeuristic(currentNode, finish);
currentNode.parent = null;
openList.add(currentNode);
System.out.println("PATHFINDING STARTED ||| startPos : " + start.position + " finishPos : " + finish.position);
while (openList.size > 0) {
//Sorts open nodes lowest F value to heighest
openList.sort(nodeComparator);
currentNode = openList.first();
//If path is found, return
if (currentNode == finish) {
System.out.println("PATH FOUND...RETURNING -gat5");
return constructPath(currentNode);
}
openList.removeValue(currentNode, true);
closedList.add(currentNode);
int counter = 0;
for (Node neighbor : getNeighbors(currentNode)) {
if (!closedList.contains(neighbor, true)) { //If neighbor not in closed list
if(neighbor != null) { //If neighbor not wall
if(counter == 4){
counter++;
}
int movementCost = checkMovementCost(counter);
if (openList.contains(neighbor, true)) {
if (currentNode.G + movementCost < neighbor.G) {
neighbor.parent = currentNode;
}
} else {
openList.add(neighbor);
neighbor.parent = currentNode;
neighbor.H = getHeuristic(currentNode, finish);
neighbor.G = neighbor.parent.G + movementCost;
}
counter++;
}
}
}
System.out.println(counter);
}
System.out.println("NO FINAL");
System.out.println("NO PATH FOUND RETURNING...");
path.add(start);
return path;
}
private static int checkMovementCost(int neighbor) {
int movementCost = 0;
switch (neighbor) {
//Diagonal
case 0:
case 2:
case 6:
case 8:
movementCost = 16;
break;
//Not Diagonal
case 1:
case 3:
case 5:
case 7:
movementCost = 10;
break;
}
return movementCost;
}
public static Array<Node> constructPath(Node finish) {
Array<Node> pathNodes = new Array<Node>();
Node currentNode = finish;
pathNodes.add(currentNode);
while (currentNode.parent != null) {
currentNode = currentNode.parent;
pathNodes.add(currentNode);
}
return pathNodes;
}
private static float getHeuristic(Node start, Node finish){
int H = 0;
H += Math.abs(start.position.x - finish.position.x);
H += Math.abs(start.position.y - finish.position.y);
return H;
}
private static Array<Node> getNeighbors(Node node){
Array<Node> neighbors = new Array<Node>();
int x = (int)node.position.x;
int y = (int)node.position.y;
if(x - 1 > 0 && x - 1 < grid.length && y + 1 < grid.length && y + 1 > 0){
neighbors.add(grid[x - 1][y + 1]);
}
else{
neighbors.add(null);
}
if(x > 0 && x < grid.length && y + 1 < grid.length && y + 1 > 0){
neighbors.add(grid[x][y + 1]);
}
else{
neighbors.add(null);
}
if(x + 1 > 0 && x + 1 < grid.length && y + 1 < grid.length && y + 1 > 0){
neighbors.add(grid[x + 1][y + 1]);
}
else{
neighbors.add(null);
}
if(x - 1 > 0 && x - 1 < grid.length && y < grid.length && y > 0){
neighbors.add(grid[x - 1][y]);
}
else{
neighbors.add(null);
}
if(x > 0 && x < grid.length && y < grid.length && y > 0){
neighbors.add(grid[x][y]);
}
else{
neighbors.add(null);
}
if(x + 1 > 0 && x + 1 < grid.length && y < grid.length && y > 0){
neighbors.add(grid[x + 1][y]);
}
else{
neighbors.add(null);
}
if(x - 1 > 0 && x - 1 < grid.length && y - 1 < grid.length && y - 1> 0){
neighbors.add(grid[x - 1][y - 1]);
}
else{
neighbors.add(null);
}
if(x > 0 && x < grid.length && y - 1 < grid.length && y - 1 > 0){
neighbors.add(grid[x][y - 1]);
}
else{
neighbors.add(null);
}
if(x + 1 > 0 && x + 1 < grid.length && y - 1 < grid.length && y - 1 > 0){
neighbors.add(grid[x + 1][y - 1]);
}
else{
neighbors.add(null);
}
return neighbors;
}
}
Thank you so much for your help!
**Some more information : ** When I run this algorithm only once, it works fine. But once I run it 3+ times, it starts lose framerate fast. My grid I am using is 200x200.

If your evaluation of the paths is as simple as you are pointing out, probably the slowness of the algorithm has something do do with the ordering that you do in each iteration of the algorithm.
//Sorts open nodes lowest F value to heighest
openList.sort(nodeComparator);
Just using PriorityQueue to order the nodes to be expanded by the algorithm results in a much more efficient implementation. If you want, take a look to the implementation details of the A* algorithm implemented in the library hipster4j. This works in Android, too.
Hope my answer helps.

Reversi (Othello) Java simple program returns wrong moves

I've been trying to implement simple program that returns valid move of Reversi / Othello game.
Unfortunately, it doesn't work and I cannot really see why. It returns [2,2] which is certainly not valid move.
//myColor, opponentColor, Reversi move etc. are already defined.
I would be glad if you pointed out flaw in my system.
#Override
public ReversiMove makeNextMove(int[][] board) {
for (int y = 0; y < 8; y++) {
for (int x = 0; x < 8; x++) {
if (board[y][x] != myColor && board[y][x] != opponentColor) {
int nextX = x + 1;
while (nextX < 7 && board[y][nextX] == this.opponentColor) {
if (board[y][nextX + 1] == this.myColor) {
return new ReversiMove(y,x);
}
nextX++;
}
nextX = x - 1;
while (nextX > 0 && board[y][nextX] == this.opponentColor) {
if (board[y][nextX - 1] == this.myColor) {
return new ReversiMove(y,x);
}
nextX--;
}
int nextY = y + 1;
while (nextY < 7 && board[nextY][x] == this.opponentColor) {
if (board[nextY + 1][x] == this.myColor) {
return new ReversiMove(y,x);
}
nextY++;
}
nextY = y - 1;
while (nextY > 0 && board[nextY][x] == this.opponentColor) {
if (board[nextY - 1][x] == this.myColor) {
return new ReversiMove(y,x);
}
nextY--;
}
nextX = x + 1;
nextY = y + 1;
while (nextX < 7 && nextY < 7 && board[nextY][nextX] == this.opponentColor) {
if (board[nextY + 1][nextX + 1] == this.myColor) {
return new ReversiMove(y,x);
}
nextX++;
nextY++;
}
nextX = x - 1;
nextY = y - 1;
while (nextX > 0 && nextY > 0 && board[nextY][nextX] == this.opponentColor) {
if (board[nextY - 1][nextX - 1] == this.myColor) {
return new ReversiMove(y,x);
}
nextX--;
nextY--;
}
nextX = x + 1;
nextY = y - 1;
while (nextX < 7 && nextY > 0 && board[nextY][nextX] == this.opponentColor) {
if (board[nextY - 1][nextX + 1] == this.myColor) {
return new ReversiMove(y,x);
}
nextX++;
nextY--;
}
nextX = x - 1;
nextY = y + 1;
while (nextX > 0 && nextY < 7 && board[nextY][nextX] == this.opponentColor) {
if (board[nextY + 1][nextX - 1] == this.myColor) {
return new ReversiMove(y,x);
}
nextX--;
nextY++;
}
}
}
}
return new ReversiMove(-1, -1);
}
}

board[x][y] structure...
sometime refer as:
board[y][nextX] instead of board[nextX][y]

Conway's game of life out of boundaries when counting neighbours - java

I am trying to create the game of life in java but I have difficulty writing the part that checks the number of neighbours. I understand that the problem is when the program gets to the edges of the grid it won't work because the indexes are greater/smaller than the bounds of the array. So the problem is in my Neighbours(). I am not sure how to fix it, I tried expanding the if statements and I also tried putting the whole set of statements in a while loop. The program seems to be working unless there are live cells at the edges of the grid. Any suggestions on this? Thanks in advance.
import java.io.*;
import java.util.Scanner;
public class LifeGrid
{
public int[][] grid;
public int[][] newgrid;
public int getX()
{
return grid[0].length;
}
public int getY()
{
return grid.length;
}
public int getcurrentgen()
{
return currentgen;
}
public int currentgen=0;
// modify neighbours out of boundary problem.
int Neighbours(int x, int y)
{
int neighbours = 0;
if (grid[y][x-1] == 1)
{ neighbours++; }
if (grid[y][x+1] ==1)
{ neighbours++; }
if (grid[y+1][x-1] ==1)
{ neighbours++; }
if (grid[y+1][x+1] ==1)
{ neighbours++; }
if (grid[y+1][x] ==1)
{ neighbours++; }
if (grid[y-1][x-1] ==1)
{ neighbours++; }
if (grid[y-1][x+1] ==1)
{ neighbours++; }
if (grid[y-1][x] ==1)
{ neighbours++; }
return neighbours;
}
public LifeGrid(int x, int y, String filename)
{
grid = new int [y][x];
newgrid = new int[y][x];
File input = new File(filename);
Scanner sc;
try
{
sc = new Scanner(input);
}
catch (FileNotFoundException e)
{
System.out.println("File error");
return;
}
for ( y=0; y< getY(); y++)
{
String line = sc.nextLine();
for( x = 0; x < getX(); x++)
{
if (line.charAt(x) == '*')
{
grid[y][x] = 1;
}
else
{
grid[y][x] = 0;
}
}
}
}
public void run()
{
show();
while(getcurrentgen() < 3)
{
setup();
grid = newgrid;
currentgen++;
show();
}
}
public void setup()
{
for (int y = 0; y < getY(); y++)
{
for (int x = 0;x < getX();x++)
{
if (grid[y][x]== 1)
{
if (Neighbours(x,y) < 2)
{
newgrid[y][x] = 0;
}
if (Neighbours(x,y) > 3)
{
newgrid[y][x] = 0;
}
if (Neighbours(x,y) == 3 || Neighbours(x,y) == 2)
{
newgrid[y][x] = 1;
}
}
if(grid[y][x]==0)
{
if(Neighbours(x,y) == 3)
{
newgrid[y][x]= 1;
}
}
}
}
}
public void show()
{
for(int y =0; y < getY(); y++)
{
for(int x = 0; x < getX(); x++)
{
System.out.print(grid[y][x]);
}
System.out.println();
}
System.out.println("Current generation: "+getcurrentgen());
}
}

you need to add checks for all your points to make sure they are not on boundary. This means checking for both x and y coordinates:
if (x > 0 && grid[y][x - 1] == 1) {
neighbours++;
}
if (x < grid[y].length - 1 && grid[y][x + 1] == 1) {
neighbours++;
}
if (x > 0 && y < grid.length - 1 && grid[y + 1][x - 1] == 1) {
neighbours++;
}
if (x < grid[y].length - 1 && y < grid.length - 1 && grid[y + 1][x + 1] == 1) {
neighbours++;
}
if (y < grid.length - 1 && grid[y + 1][x] == 1) {
neighbours++;
}
if (x > 0 && y > 0 && grid[y - 1][x - 1] == 1) {
neighbours++;
}
if (y > 0 && x < grid[y].length - 1 && grid[y - 1][x + 1] == 1) {
neighbours++;
}
if (y > 0 && grid[y - 1][x] == 1) {
neighbours++;
}

int Neighbours(int x, int y) is called with x=0 and y=0, right?
How do you then evaluate grid[y-1][x-1]?

Where you have
if (grid[y][x-1] == 1)
You just need to skip if this would go out of bounds:
if (x > 0 && grid[y][x-1] == 1)
And similar for all of the others.

Java passing value back as 3 but shows as zero

For some reason the 'numAlive' variable shows as 3 but when passed back to numAlivePass it appears as '0' This is for Conways game of life
Edited as per comments below
public int countLiveNeighbour(int x, int y){
int numAlive = 0;
if(x >= 3 && y >= 3 && x < HEIGHT-3 && y < WIDTH-3)
{
if(generation[x][y+1] == ALIVE) {numAlive++;}
if(generation[x][y-1] == ALIVE) {numAlive++;}
if(generation[x+1][y] == ALIVE) {numAlive++;}
if(generation[x+1][y+1] == ALIVE) {numAlive++;}
if(generation[x+1][y-1] == ALIVE) {numAlive++;}
if(generation[x-1][y-1] == ALIVE) {numAlive++;}
if(generation[x-1][y+1] == ALIVE) {numAlive++;}
}
if(x ==31 && y==16){
System.out.println("ALIVE INclass: " + numAlive);
}
return numAlive;
}
//cell will be alive in next generation if alive cells = 3 or if already alive then 2 or 3
private int aliveCell(int x, int y){
int numAlivePass = 0;
numAlivePass = countLiveNeighbour(x, y);
if(x ==31 && y==16){
System.out.println(" NumAlivePass(ed) = " +numAlivePass+ " Live Neighbour Call = " + countLiveNeighbour(x, y));
}
int aliveState= 0;
if(x ==31 && y==16){
System.out.println(x + " x val 1, " + y + " x val 1, ALIVE 1: " + numAlivePass + " Alive State 1: " + aliveState);
}
if (numAlivePass > 3 || numAlivePass < 2){
aliveState = DEAD;
}
if(numAlivePass == 3){
aliveState = ALIVE;
System.out.println("Alive");
}
if (generation[x][y] == ALIVE && numAlivePass == 2){
aliveState = ALIVE;
System.out.println("Alive");
}
return aliveState;
}
This is all the code in this class inclusive of the code above:
package game_of_life;
import java.awt.Color;
import java.awt.Graphics;
public class CellularAnimation implements Animatable{
public static final int ALIVE = -1;
public static final int DEAD = 0;
public static final int HEIGHT = 100;
public static final int WIDTH = 100;
public static final int CELL_SIZE = 5;
int generation[][] = new int[HEIGHT][WIDTH];
int nextGeneration[][] = new int[HEIGHT][WIDTH];
public int getCellStatus(int x, int y) {
// TODO Auto-generated method stub
return generation[x][y];
}
public void populateNextGen(){
for(int x=0; x<=WIDTH-1; x++){
for(int y=0; y<=HEIGHT-1; y++){
nextGeneration[x][y] = aliveCell(x,y);
}
}
for(int x=0; x<=WIDTH-1; x++){
for(int y=0; y<=HEIGHT-1; y++){
generation[x][y] = nextGeneration[x][y];
}
}
}
public void initialise(){
for(int i = 0;i<HEIGHT-1;i++){
for(int z = 0;z<WIDTH-1;z++){
generation[z][i]= DEAD;
}
}
System.out.println("test1");
generation[30][15]= ALIVE;
generation[30][16]= ALIVE;
generation[30][17]= ALIVE;
}
public int countLiveNeighbour(int x, int y){
int numAlive = 0;
if(x >= 3 && y >= 3 && x < HEIGHT-3 && y < WIDTH-3)
{
if(generation[x][y++] == ALIVE) {numAlive++;}
if(generation[x][y--] == ALIVE) {numAlive++;}
if(generation[x++][y] == ALIVE) {numAlive++;}
if(generation[x++][y++] == ALIVE) {numAlive++;}
if(generation[x++][y--] == ALIVE) {numAlive++;}
if(generation[x--][y--] == ALIVE) {numAlive++;}
if(generation[x--][y++] == ALIVE) {numAlive++;}
}
if(x ==31 && y==16){
System.out.println("ALIVE INclass: " + numAlive);
}
return numAlive;
}
//cell will be alive in next generation if alive cells = 3 or if already alive then 2 or 3
private int aliveCell(int x, int y){
int numAlivePass = 0;
numAlivePass = countLiveNeighbour(x, y);
if(x ==31 && y==16){
System.out.println(" NumAlivePass(ed) = " +numAlivePass+ " Live Neighbour Call = " + countLiveNeighbour(x, y));
}
int aliveState= 0;
if(x ==31 && y==16){
System.out.println(x + " x val 1, " + y + " x val 1, ALIVE 1: " + numAlivePass + " Alive State 1: " + aliveState);
}
if (numAlivePass > 3 || numAlivePass < 2){
aliveState = DEAD;
}
if(numAlivePass == 3){
aliveState = ALIVE;
System.out.println("Alive");
}
if (generation[x][y] == ALIVE && numAlivePass == 2){
aliveState = ALIVE;
System.out.println("Alive");
}
return aliveState;
}
#Override
public void step() {
populateNextGen();
//paint(null);
//implement paint ect here
}
#Override
public void paint(Graphics pGraphics) {
//super.paint(pGraphics);
for(int i = 0; i<HEIGHT; i++){
for(int z = 0; z<WIDTH; z++){
if(generation[z][i] == ALIVE){
pGraphics.setColor(Color.BLACK);
System.out.println("test");
}
else{
pGraphics.setColor(Color.WHITE);
}
pGraphics.fillRect(z*CELL_SIZE,i*CELL_SIZE, CELL_SIZE, CELL_SIZE);
}
}
}
#Override
public int getWidth() {
// TODO Auto-generated method stub
return WIDTH*CELL_SIZE;
}
#Override
public int getHeight() {
// TODO Auto-generated method stub
return HEIGHT*CELL_SIZE;
}
}