# Zombie Clusters Hackerrank Solution ((EXCLUSIVE))

## Zombie Clusters: A Fun and Tricky Problem on HackerRank

If you are looking for a challenging and fun problem to practice your algorithms and data structures skills, you might want to try the Zombie Clusters problem on HackerRank. In this problem, you are given a matrix of 0s and 1s, where each row and column represents a person, and a 1 means that the person is infected by a zombie virus. Your task is to find out how many zombie clusters are there in the matrix, where a cluster is defined as a group of infected people who are connected horizontally, vertically, or diagonally.

## zombie clusters hackerrank solution

For example, given the following matrix:

1100

1110

0110

0001

There are two zombie clusters: one consisting of the first three rows and columns, and another consisting of the last element.

## How to Solve the Zombie Clusters Problem

One possible way to solve this problem is to use a depth-first search (DFS) algorithm. DFS is a technique that explores a graph by starting from a node and visiting all its neighbors recursively, until there are no more nodes to visit. In this case, we can treat the matrix as a graph, where each element is a node, and there is an edge between two nodes if they are adjacent and both infected. Then, we can loop through the matrix and perform a DFS for each infected node that has not been visited yet, marking it as visited and incrementing the cluster count. This way, we can find all the connected components of infected nodes in the matrix.

Here is a possible implementation of this solution in Python:

```python

def zombieCluster(zombies):

# convert the matrix to a list of lists of integers

zombies = [list(map(int, row)) for row in zombies]

# get the number of rows and columns

n = len(zombies)

m = len(zombies[0])

# initialize the cluster count to zero

count = 0

# initialize a set to store the visited nodes

visited = set()

# define a helper function to perform DFS

def dfs(i, j):

# mark the current node as visited

visited.add((i, j))

# loop through the four directions: up, down, left, right

for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:

# get the next row and column indices

ni = i + di

nj = j + dj

# check if they are valid and not visited

if 0 <= ni < n and 0 <= nj < m and (ni, nj) not in visited:

# check if they are infected

if zombies[ni][nj] == 1:

# continue the DFS from this node

dfs(ni, nj)

# loop through the matrix

for i in range(n):

for j in range(m):

# check if the current node is infected and not visited

if zombies[i][j] == 1 and (i, j) not in visited:

# perform DFS from this node and increment the cluster count

dfs(i, j)

count += 1

# return the cluster count

return count

```

## How to Test Your Solution

Once you have written your code, you can test it on HackerRank's online platform. HackerRank provides a set of test cases for each problem, and you can see the expected output and your output for each test case. You can also run your code on custom input and see the result. To test your solution, you need to submit your code on the problem page and wait for the verdict. If your code passes all the test cases, you will get a success message and a score. If your code fails some test cases, you will get a failure message and a partial score. You can also see the details of each test case and the error message if any.

Here are some sample test cases for the Zombie Clusters problem:

Input:

4

1100

1110

0110

0001

Output:

2

Input:

5

10000

01000

00100

00010

00001

Output:

5

Input:

3

101

010

101

Output:

1

## How to Improve Your Solution

If you have solved the problem using DFS, you might wonder if there is a better way to do it. One possible improvement is to use a union-find data structure instead of DFS. Union-find is a technique that maintains a collection of disjoint sets and supports two operations: find and union. Find returns the representative element of the set that contains a given element, and union merges two sets that contain two given elements. In this case, we can use union-find to keep track of the zombie clusters by iterating through the matrix and merging the sets of infected nodes that are adjacent. Then, we can count the number of distinct sets at the end.

Here is a possible implementation of this solution in Java:

```java

public class Solution

// define a class to represent a union-find data structure

static class UnionFind

// store the parent of each element

int[] parent;

// store the rank of each element (used for path compression)

int[] rank;

// store the number of elements in each set (used for counting clusters)

int[] size;

// store the number of distinct sets

int count;

// constructor: initialize the data structure with n elements

public UnionFind(int n)

parent = new int[n];

rank = new int[n];

size = new int[n];

count = n;

// initially, each element is its own parent, has rank 0, and size 1

for (int i = 0; i < n; i++)

parent[i] = i;

rank[i] = 0;

size[i] = 1;

// find: return the representative element of the set that contains x

public int find(int x)

// if x is not its own parent, recursively find its parent and update it (path compression)

if (parent[x] != x)

parent[x] = find(parent[x]);

return parent[x];

// union: merge the sets that contain x and y

public void union(int x, int y)

// find the representatives of x and y

int px = find(x);

int py = find(y);

// if they are already in the same set, do nothing

if (px == py) return;

// otherwise, compare their ranks and attach the lower rank to the higher rank (union by rank)

if (rank[px] > rank[py])

parent[py] = px;

size[px] += size[py]; // update the size of px's set

else if (rank[px] < rank[py])

parent[px] = py;

size[py] += size[px]; // update the size of py's set

else

parent[py] = px;

size[px] += size[py]; // update the size of px's set

rank[px]++; // increment the rank of px's set

count--; // decrement the number of distinct sets

// getCount: return the number of distinct sets

public int getCount()

return count;

// getSize: return the number of elements in the set that contains x

public int getSize(int x)

return size[find(x)];

public static void main(String[] args)

Scanner sc = new Scanner(__System.in__);

int n = sc.nextInt(); // read the number of rows/columns in the matrix

String[] zombies = new String[n]; // create an array to store the matrix as strings

for (int i = 0; i < n; i++)

zombies[i] = sc.next(); // read each row as a string

sc.close(); // close the scanner

System.out.println(zombieCluster(zombies)); // print the result

public static int zombieCluster(String[] zombies)

int n = zombies.length; // get the number of rows/columns in the matrix

UnionFind uf = new UnionFind(n); // create a union-find data structure with n elements

for (int i = 0; i < n; i++) // loop through each row

for (int j = i + 1; j < n; j++) // loop through each column after i (to avoid duplicates)

if (zombies[i].charAt(j) == '1') // check if there is an edge between i and j (both infected)

uf.union(i, j); // merge their sets in union-find

return uf.getCount(); // return the number of distinct sets in union-find

```

## How to Learn More About the Problem and Its Applications

The Zombie Clusters problem is not only a fun and challenging exercise, but also a useful one. It can help you learn more about graph algorithms and data structures, which are widely used in computer science and engineering. Graphs are mathematical models that represent the relationships between objects, such as networks, social media, maps, etc. Algorithms and data structures are techniques that help you manipulate and store data efficiently and effectively. Learning how to use them can help you solve many real-world problems and improve your coding skills.

One possible application of the Zombie Clusters problem is to model the spread of infectious diseases. In this case, the matrix represents a population of people, and a 1 means that the person is infected by a disease. The clusters represent the groups of people who can infect each other through direct contact. By finding the number and size of the clusters, we can estimate the risk of an outbreak and the potential impact of interventions such as vaccination or quarantine.

## Conclusion

In this article, we have discussed the Zombie Clusters problem on HackerRank, which asks you to find the number of zombie clusters in a matrix of 0s and 1s. We have shown two possible ways to solve this problem: using depth-first search (DFS) or union-find data structure. We have also explained how to test your solution, compare it with others, and learn more about the problem and its applications. We hope you have enjoyed this article and learned something new. Happy coding!

## Conclusion

In this article, we have discussed the Zombie Clusters problem on HackerRank, which asks you to find the number of zombie clusters in a matrix of 0s and 1s. We have shown two possible ways to solve this problem: using depth-first search (DFS) or union-find data structure. We have also explained how to test your solution, compare it with others, and learn more about the problem and its applications. We hope you have enjoyed this article and learned something new. Happy coding! d282676c82

__https://www.grupoovap.com/group/grupo-govap/discussion/0de367d6-c129-4c7e-ba8a-d1ae0442313e__

__https://www.shul.org.au/group/mysite-231-group/discussion/14a3c917-d95a-4ab0-8196-bc0cc504a196__