algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-07 17:56:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix bound checks in flood fill (fixes #2836) (#2974)

Browse Source
This commit is contained in:
Nikhil Bisht
2022-03-12 15:26:43 +05:30
committed by GitHub
parent 63637c439d
commit 260a302563
3 changed files with 175 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
src/main/java/com/thealgorithms/backtracking/FloodFill.java Normal file
View File

@ -0,0 +1,69 @@
package com.thealgorithms.backtracking;
/**
* Java program for Flood fill algorithm.
* @author Akshay Dubey (https://github.com/itsAkshayDubey)
*/
public class FloodFill {
/**
* Get the color at the given co-odrinates of a 2D image
*
* @param image The image to be filled
* @param x The x co-ordinate of which color is to be obtained
* @param y The y co-ordinate of which color is to be obtained
*/
public static int getPixel(int[][] image, int x, int y) {
return image[x][y];
}
/**
* Put the color at the given co-odrinates of a 2D image
*
* @param image The image to be filed
* @param x The x co-ordinate at which color is to be filled
* @param y The y co-ordinate at which color is to be filled
*/
public static void putPixel(int[][] image, int x, int y, int newColor) {
image[x][y] = newColor;
}
/**
* Fill the 2D image with new color
*
* @param image The image to be filed
* @param x The x co-ordinate at which color is to be filled
* @param y The y co-ordinate at which color is to be filled
* @param newColor The new color which to be filled in the image
* @param oldColor The old color which is to be replaced in the image
* @return
*/
public static void floodFill(int[][] image, int x, int y, int newColor, int oldColor) {
if(x < 0 || x >= image.length) return;
if(y < 0 || y >= image[x].length) return;
if(getPixel(image, x, y) != oldColor) return;
putPixel(image, x, y, newColor);
/* Recursively check for horizontally & vertically adjacent coordinates */
floodFill(image, x + 1, y, newColor, oldColor);
floodFill(image, x - 1, y, newColor, oldColor);
floodFill(image, x, y + 1, newColor, oldColor);
floodFill(image, x, y - 1, newColor, oldColor);
/* Recursively check for diagonally adjacent coordinates */
floodFill(image, x + 1, y - 1, newColor, oldColor);
floodFill(image, x - 1, y + 1, newColor, oldColor);
floodFill(image, x + 1, y + 1, newColor, oldColor);
floodFill(image, x - 1, y - 1, newColor, oldColor);
}
}

114
src/main/java/com/thealgorithms/dynamicprogramming/FloodFill.java
View File

@ -1,114 +0,0 @@
package com.thealgorithms.dynamicprogramming;
/**
* Java program for Flood fill algorithm.
* @author Akshay Dubey (https://github.com/itsAkshayDubey)
*/
public class FloodFill {
/**
* Get the color at the given co-odrinates of a 2D image
*
* @param image The image to be filled
* @param x_co_ordinate The x co-ordinate of which color is to be obtained
* @param y_co_ordinate The y co-ordinate of which color is to be obtained
*/
public static int getPixel(int[][] image, int x_co_ordinate, int y_co_ordinate) {
return image[x_co_ordinate][y_co_ordinate];
}
/**
* Put the color at the given co-odrinates of a 2D image
*
* @param image The image to be filed
* @param x_co_ordinate The x co-ordinate at which color is to be filled
* @param y_co_ordinate The y co-ordinate at which color is to be filled
*/
public static void putPixel(int[][] image, int x_co_ordinate, int y_co_ordinate, int new_color) {
image[x_co_ordinate][y_co_ordinate] = new_color;
}
/**
* Fill the 2D image with new color
*
* @param image The image to be filed
* @param x_co_ordinate The x co-ordinate at which color is to be filled
* @param y_co_ordinate The y co-ordinate at which color is to be filled
* @param new_color The new color which to be filled in the image
* @param old_color The old color which is to be replaced in the image
* @return
*/
public static void floodFill(int[][] image, int x_co_ordinate, int y_co_ordinate, int new_color, int old_color) {
if(x_co_ordinate >= 0 && y_co_ordinate >= 0 && getPixel(image, x_co_ordinate, y_co_ordinate) == old_color) {
putPixel(image, x_co_ordinate, y_co_ordinate, new_color);
floodFill(image, x_co_ordinate + 1, y_co_ordinate, new_color, old_color);
floodFill(image, x_co_ordinate - 1, y_co_ordinate, new_color, old_color);
floodFill(image, x_co_ordinate, y_co_ordinate + 1, new_color, old_color);
floodFill(image, x_co_ordinate, y_co_ordinate - 1, new_color, old_color);
floodFill(image, x_co_ordinate + 1, y_co_ordinate - 1, new_color, old_color);
floodFill(image, x_co_ordinate - 1, y_co_ordinate + 1, new_color, old_color);
floodFill(image, x_co_ordinate + 1, y_co_ordinate + 1, new_color, old_color);
floodFill(image, x_co_ordinate - 1, y_co_ordinate - 1, new_color, old_color);
}
}
/**
* This method will print the 2D image matrix
*
* @param image The image to be printed on the console
*/
public static void printImageArray(int[][] image) {
for(int i=0 ; i<image.length ; i++) {
for(int j=0 ; j<image[0].length ; j++) {
System.out.print(image[i][j]+" ");
}
System.out.println();
}
}
// Driver Program
public static void main(String[] args) {
//Input 2D image matrix
int[][] image = {
{0,0,0,0,0,0,0},
{0,3,3,3,3,0,0},
{0,3,1,1,5,0,0},
{0,3,1,1,5,5,3},
{0,3,5,5,1,1,3},
{0,0,0,5,1,1,3},
{0,0,0,3,3,3,3}
};
floodFill(image,2,2,2,1);
/* Output ==>
* 0 0 0 0 0 0 0
0 3 3 3 3 0 0
0 3 2 2 5 0 0
0 3 2 2 5 5 3
0 3 5 5 2 2 3
0 0 0 5 2 2 3
0 0 0 3 3 3 3
* */
//print 2D image matrix
printImageArray(image);
}
}

106
src/test/java/com/thealgorithms/backtracking/FloodFillTest.java Normal file
View File

@ -0,0 +1,106 @@
package com.thealgorithms.backtracking;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
class FloodFillTest {
@Test
void testForEmptyImage()
{
int image[][] = {};
int expected[][] = {};
FloodFill.floodFill(image, 4, 5, 3, 2);
assertArrayEquals(expected, image);
}
@Test
void testForSingleElementImage()
{
int image[][] = {{1}};
int expected[][] = {{3}};
FloodFill.floodFill(image, 0, 0, 3, 1);
assertArrayEquals(expected, image);
}
@Test
void testForImageOne()
{
int image[][] = {
{ 0,0,0,0,0,0,0 },
{ 0,3,3,3,3,0,0 },
{ 0,3,1,1,5,0,0 },
{ 0,3,1,1,5,5,3 },
{ 0,3,5,5,1,1,3 },
{ 0,0,0,5,1,1,3 },
{ 0,0,0,3,3,3,3 }
};
int expected[][] = {
{ 0,0,0,0,0,0,0 },
{ 0,3,3,3,3,0,0 },
{ 0,3,2,2,5,0,0 },
{ 0,3,2,2,5,5,3 },
{ 0,3,5,5,2,2,3 },
{ 0,0,0,5,2,2,3 },
{ 0,0,0,3,3,3,3 }
};
FloodFill.floodFill(image,2,2,2,1);
assertArrayEquals(expected, image);
}
@Test
void testForImageTwo()
{
int image[][] = {
{ 0,0,1,1,0,0,0 },
{ 1,1,3,3,3,0,0 },
{ 1,3,1,1,5,0,0 },
{ 0,3,1,1,5,5,3 },
{ 0,3,5,5,1,1,3 },
{ 0,0,0,5,1,1,3 },
{ 0,0,0,1,3,1,3 }
};
int expected[][] = {
{ 0,0,2,2,0,0,0 },
{ 2,2,3,3,3,0,0 },
{ 2,3,2,2,5,0,0 },
{ 0,3,2,2,5,5,3 },
{ 0,3,5,5,2,2,3 },
{ 0,0,0,5,2,2,3 },
{ 0,0,0,2,3,2,3 }
};
FloodFill.floodFill(image, 2, 2, 2, 1);
assertArrayEquals(expected, image);
}
@Test
void testForImageThree()
{
int image[][] = {
{ 1,1,2,3,1,1,1 },
{ 1,0,0,1,0,0,1 },
{ 1,1,1,0,3,1,2 }
};
int expected[][] = {
{ 4,4,2,3,4,4,4 },
{ 4,0,0,4,0,0,4 },
{ 4,4,4,0,3,4,2 },
};
FloodFill.floodFill(image, 0, 1, 4, 1);
assertArrayEquals(expected, image);
}
}