Count Zero filled Subarrays in a Binary Linked list
Last Updated :
16 Sep, 2023
Given a binary linked list that consists of the 1s and 0s nodes, the task is to find the number of zero-filled subarrays in the linked list. A zero-filled subarray is a contiguous subarray of nodes containing all zeroes.
Examples:
Input: List = 1->0->1->0->0->1->0
Output: 5
Explanation:
- There are 4 occurrences of 0 as subarrays in a linked list.
- There is 1 occurrence of 0->0 as subarrays in a linked list.
The total number of zero-filled subarrays is 5.
Input: List = 0->0->0->0->0->0->0->1
Output: 28
Explanation:
- There are 7 occurrences of 0 as subarrays in a linked list.
- There are 6 occurrences of 0->0 as subarrays in a linked list.
- There are 5 occurrences of 0->0->0 as a subarrays in a linked list.
- There are 4 occurrences of 0->0->0->0 as a subarrays in a linked list.
- There are 3 occurrences of 0->0->0->0->0 as a subarrays in a linked list.
- There are 2 occurrences of 0->0->0->0->0->0 as a subarrays in a linked list.
- There are 1 occurrences of 0->0->0->0->0->0->0 as a subarrays in a linked list.
The total number of zero-filled subarrays is 28.
Approach 1: Using Dynamic programming
This can be solved with the following idea:
We can use an array dp[] to store the lengths of all the zero-filled subarrays ending at each node of the linked list. We can then iterate through the linked list and compute the lengths of all zero-filled subarrays that end at each node.
Steps involved in the implementation of the code:
- We need to first count the number of nodes in the linked list, which will give us the size of the dp[] array we need to create. We can do this by iterating through the linked list and incrementing a counter variable n for each node.
- We can now create the dp[] array of size n and initialize all its elements to zero. This array will store the lengths of all the zero-filled subarrays ending at each node of the linked list.
- We can then iterate through the linked list and for each node, we need to compute the length of the zero-filled subarray that ends at that node.
- If the current node is one, then we know that there are no zero-filled subarrays that end at this node. So we can simply set dp[i] = 0, where i is the index of the current node in the linked list.
- If the current node is a zero, then we need to compute the length of the zero-filled subarray that ends at this node. To do this, we need to look at the length of the zero-filled subarray that ended at the previous node. If the previous node was also a zero, then we can simply add one to the length of the zero-filled subarray that ended at the previous node. If the previous node was one, then the length of the zero-filled subarray that ends at the current node is just one.
- After we have computed the lengths of all the zero-filled subarrays that end at each node, we can simply sum up all the elements in the dp[] array to get the total number of zero-filled subarrays in the linked list.
Below is the code for the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
Node( int x)
: data(x), next(NULL)
{
}
};
int countZeroFilledSubarrays( struct Node* head)
{
int n = 0, count = 0;
struct Node* current = head;
while (current != NULL) {
n++;
current = current->next;
}
int dp[n] = { 0 };
current = head;
for ( int i = 0; i < n; i++) {
if (current->data == 0) {
dp[i] = (i > 0) ? dp[i - 1] + 1 : 1;
}
current = current->next;
}
for ( int i = 0; i < n; i++) {
count += dp[i];
}
return count;
}
int main()
{
Node* head = new Node(1);
head->next = new Node(0);
head->next->next = new Node(1);
head->next->next->next = new Node(0);
head->next->next->next->next = new Node(0);
head->next->next->next->next->next = new Node(1);
head->next->next->next->next->next->next = new Node(0);
cout << countZeroFilledSubarrays(head) << endl;
return 0;
}
|
Java
public class LinkedList {
static Node head;
static class Node {
int data;
Node next;
Node( int d) {
data = d;
next = null ;
}
}
static int countZeroFilledSubarrays(Node head) {
int n = 0 ;
int count = 0 ;
Node current = head;
while (current != null ) {
n += 1 ;
current = current.next;
}
int dp[] = new int [n];
current = head;
for ( int i = 0 ; i < n; i++) {
if (current.data == 0 ) {
dp[i] = dp[i - 1 ] + 1 ;
}
current = current.next;
}
for ( int i = 0 ; i < n; i++) {
count += dp[i];
}
return count;
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.head = new Node( 1 );
list.head.next = new Node( 0 );
list.head.next.next = new Node( 1 );
list.head.next.next.next = new Node( 0 );
list.head.next.next.next.next = new Node( 0 );
list.head.next.next.next.next.next = new Node( 1 );
list.head.next.next.next.next.next.next = new Node( 0 );
System.out.println(countZeroFilledSubarrays(head));
}
}
|
Python3
class Node:
def __init__( self , x):
self .data = x
self . next = None
def countZeroFilledSubarrays(head):
n = 0
count = 0
current = head
while current ! = None :
n + = 1
current = current. next
dp = [ 0 ] * n
current = head
for i in range (n):
if current.data = = 0 :
dp[i] = dp[i - 1 ] + 1 if i > 0 else 1
current = current. next
for i in range (n):
count + = dp[i]
return count
if __name__ = = '__main__' :
head = Node( 1 )
head. next = Node( 0 )
head. next . next = Node( 1 )
head. next . next . next = Node( 0 )
head. next . next . next . next = Node( 0 )
head. next . next . next . next . next = Node( 1 )
head. next . next . next . next . next . next = Node( 0 )
print (countZeroFilledSubarrays(head))
|
C#
using System;
class Node
{
public int data;
public Node next;
public Node( int x)
{
data = x;
next = null ;
}
}
class Program
{
static int CountZeroFilledSubarrays(Node head)
{
int n = 0, count = 0;
Node current = head;
while (current != null )
{
n++;
current = current.next;
}
int [] dp = new int [n];
current = head;
for ( int i = 0; i < n; i++)
{
if (current.data == 0)
{
dp[i] = (i > 0) ? dp[i - 1] + 1 : 1;
}
current = current.next;
}
for ( int i = 0; i < n; i++)
{
count += dp[i];
}
return count;
}
static void Main( string [] args)
{
Node head = new Node(1);
head.next = new Node(0);
head.next.next = new Node(1);
head.next.next.next = new Node(0);
head.next.next.next.next = new Node(0);
head.next.next.next.next.next = new Node(1);
head.next.next.next.next.next.next = new Node(0);
Console.WriteLine(CountZeroFilledSubarrays(head));
Console.ReadLine();
}
}
|
Javascript
class Node {
constructor(x) {
this .data = x;
this .next = null ;
}
}
function countZeroFilledSubarrays(head) {
let n = 0;
let count = 0;
let current = head;
while (current !== null ) {
n += 1;
current = current.next;
}
let dp = new Array(n).fill(0);
current = head;
for (let i = 0; i < n; i++) {
if (current.data === 0) {
dp[i] = (i > 0 ? dp[i - 1] + 1 : 1);
}
current = current.next;
}
for (let i = 0; i < n; i++) {
count += dp[i];
}
return count;
}
let head = new Node(1);
head.next = new Node(0);
head.next.next = new Node(1);
head.next.next.next = new Node(0);
head.next.next.next.next = new Node(0);
head.next.next.next.next.next = new Node(1);
head.next.next.next.next.next.next = new Node(0);
console.log(countZeroFilledSubarrays(head));
|
Time Complexity: O(n)
Auxiliary Space: O(n)
Approach 2: Using simple mathematics
In this approach, we will not use dp[] array to store the current zero-filled subarray. This can be solved by the following idea.
We will use two variables ‘count’ and ‘pre’. Where ‘ans’ describes the the total zero-filled subarrays while ‘pre’ describes the continuious zeros.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
Node( int x)
: data(x)
, next(NULL)
{
}
};
int countZeroFilledSubarrays( struct Node* head)
{
int count = 0, pre = 0;
struct Node* current = head;
while (current != NULL) {
if (current->data == 1)
pre = 0;
else
pre++;
count = count + pre;
current = current->next;
}
return count;
}
int main()
{
Node* head = new Node(1);
head->next = new Node(0);
head->next->next = new Node(1);
head->next->next->next = new Node(0);
head->next->next->next->next = new Node(0);
head->next->next->next->next->next = new Node(1);
head->next->next->next->next->next->next = new Node(0);
cout << countZeroFilledSubarrays(head) << endl;
return 0;
}
|
Java
import java.io.*;
class Node {
int data;
Node next;
Node( int x) {
data = x;
next = null ;
}
}
public class Main {
static int countZeroFilledSubarrays(Node head) {
int count = 0 , pre = 0 ;
Node current = head;
while (current != null ) {
if (current.data == 1 )
pre = 0 ;
else
pre++;
count += pre;
current = current.next;
}
return count;
}
public static void main(String[] args) {
Node head = new Node( 1 );
head.next = new Node( 0 );
head.next.next = new Node( 1 );
head.next.next.next = new Node( 0 );
head.next.next.next.next = new Node( 0 );
head.next.next.next.next.next = new Node( 1 );
head.next.next.next.next.next.next = new Node( 0 );
System.out.println(countZeroFilledSubarrays(head));
}
}
|
Python
class Node:
def __init__( self , x):
self .data = x
self . next = None
def count_zero_filled_subarrays(head):
count = 0
pre = 0
current = head
while current is not None :
if current.data = = 1 :
pre = 0
else :
pre + = 1
count + = pre
current = current. next
return count
head = Node( 1 )
head. next = Node( 0 )
head. next . next = Node( 1 )
head. next . next . next = Node( 0 )
head. next . next . next . next = Node( 0 )
head. next . next . next . next . next = Node( 1 )
head. next . next . next . next . next . next = Node( 0 )
print (count_zero_filled_subarrays(head))
|
C#
using System;
public class Node
{
public int data;
public Node next;
public Node( int x)
{
data = x;
next = null ;
}
}
public class GFG
{
public static int CountZeroFilledSubarrays(Node head)
{
int count = 0, pre = 0;
Node current = head;
while (current != null )
{
if (current.data == 1)
pre = 0;
else
pre++;
count = count + pre;
current = current.next;
}
return count;
}
public static void Main( string [] args)
{
Node head = new Node(1);
head.next = new Node(0);
head.next.next = new Node(1);
head.next.next.next = new Node(0);
head.next.next.next.next = new Node(0);
head.next.next.next.next.next = new Node(1);
head.next.next.next.next.next.next = new Node(0);
Console.WriteLine(CountZeroFilledSubarrays(head));
}
}
|
Javascript
class Node {
constructor(x) {
this .data = x;
this .next = null ;
}
}
function count_zero_filled_subarrays(head) {
let count = 0;
let pre = 0;
let current = head;
while (current !== null ) {
if (current.data === 1) {
pre = 0;
} else {
pre += 1;
}
count += pre;
current = current.next;
}
return count;
}
const head = new Node(1);
head.next = new Node(0);
head.next.next = new Node(1);
head.next.next.next = new Node(0);
head.next.next.next.next = new Node(0);
head.next.next.next.next.next = new Node(1);
head.next.next.next.next.next.next = new Node(0);
console.log(count_zero_filled_subarrays(head));
|
Time Complexity: O(n)
Auxiliary Space: O(1)
Related Articles:
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...