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++ code of the above approach #include <bits/stdc++.h> using namespace std;
// Structure of node struct Node {
int data;
Node* next;
Node( int x)
: data(x), next(NULL)
{
}
}; // Function to count subarrays of 0 int countZeroFilledSubarrays( struct Node* head)
{ int n = 0, count = 0;
struct Node* current = head;
// Count the number of nodes in the
// linked list
while (current != NULL) {
n++;
current = current->next;
}
// Initialize the dp[] array with all
// elements set to zero
int dp[n] = { 0 };
// Iterate through the linked list and
// compute dp[] array
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;
}
// Sum up all the elements in the
// dp[] array
for ( int i = 0; i < n; i++) {
count += dp[i];
}
return count;
} // Driver code 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);
// Function call
cout << countZeroFilledSubarrays(head) << endl;
return 0;
} |
// Java program to count subarrays of 0 public class LinkedList {
static Node head;
static class Node {
int data;
Node next;
Node( int d) {
data = d;
next = null ;
}
}
// Function to count subarrays of 0
static int countZeroFilledSubarrays(Node head) {
int n = 0 ;
int count = 0 ;
Node current = head;
// Count the number of nodes in the
// linked list
while (current != null ) {
n += 1 ;
current = current.next;
}
// Initialize the dp[] array with all
// elements set to zero
int dp[] = new int [n];
// Iterate through the linked list and
// compute dp[] array
current = head;
for ( int i = 0 ; i < n; i++) {
if (current.data == 0 ) {
dp[i] = dp[i - 1 ] + 1 ;
}
current = current.next;
}
// Sum up all the elements in the
// dp[] array
for ( int i = 0 ; i < n; i++) {
count += dp[i];
}
return count;
}
// Driver code
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 );
// Function call
System.out.println(countZeroFilledSubarrays(head));
}
} // This code is contributed by Tapesh(tapeshdua420) |
# Python3 code of the above approach # Structure of node class Node:
def __init__( self , x):
self .data = x
self . next = None
# Function to count subarrays of 0 def countZeroFilledSubarrays(head):
n = 0
count = 0
current = head
# Count the number of nodes in the
# linked list
while current ! = None :
n + = 1
current = current. next
# Initialize the dp[] array with all
# elements set to zero
dp = [ 0 ] * n
# Iterate through the linked list and
# compute dp[] array
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
# Sum up all the elements in the
# dp[] array
for i in range (n):
count + = dp[i]
return count
# Driver code 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 )
# Function call
print (countZeroFilledSubarrays(head))
|
using System;
// Structure of node class Node
{ public int data;
public Node next;
public Node( int x)
{
data = x;
next = null ;
}
} class Program
{ // Function to count subarrays of 0
static int CountZeroFilledSubarrays(Node head)
{
int n = 0, count = 0;
Node current = head;
// Count the number of nodes in the
// linked list
while (current != null )
{
n++;
current = current.next;
}
// Initialize the dp[] array with all
// elements set to zero
int [] dp = new int [n];
// Iterate through the linked list and
// compute dp[] array
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;
}
// Sum up all the elements in the
// dp[] array
for ( int i = 0; i < n; i++)
{
count += dp[i];
}
return count;
}
// Driver code
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);
// Function call
Console.WriteLine(CountZeroFilledSubarrays(head));
// Keep the console window open
Console.ReadLine();
}
} |
// Structure of node class Node { constructor(x) {
this .data = x;
this .next = null ;
}
} // Function to count subarrays of 0 function countZeroFilledSubarrays(head) {
let n = 0;
let count = 0;
let current = head;
// Count the number of nodes in the
// linked list
while (current !== null ) {
n += 1;
current = current.next;
}
// Initialize the dp[] array with all
// elements set to zero
let dp = new Array(n).fill(0);
// Iterate through the linked list and
// compute dp[] array
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;
}
// Sum up all the elements in the
// dp[] array
for (let i = 0; i < n; i++) {
count += dp[i];
}
return count;
} // Driver code 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)); |
5
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++ code of the above approach #include <bits/stdc++.h> using namespace std;
// Structure of node struct Node {
int data;
Node* next;
Node( int x)
: data(x)
, next(NULL)
{
}
}; // Function to count subarrays of 0 int countZeroFilledSubarrays( struct Node* head)
{ int count = 0, pre = 0;
struct Node* current = head;
// traversing in linked list
while (current != NULL) {
if (current->data == 1)
pre = 0;
else
pre++;
count = count + pre;
current = current->next;
}
return count;
} // Driver code 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);
// Function call
cout << countZeroFilledSubarrays(head) << endl;
return 0;
} |
// Java code of the above approach import java.io.*;
// Structure of node class Node {
int data;
Node next;
Node( int x) {
data = x;
next = null ;
}
} public class Main {
// Function to count subarrays of 0
static int countZeroFilledSubarrays(Node head) {
int count = 0 , pre = 0 ;
Node current = head;
// traversing in linked list
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 );
// Function call
System.out.println(countZeroFilledSubarrays(head));
}
} |
# Python code of the above approach class Node:
def __init__( self , x):
self .data = x
self . next = None
def count_zero_filled_subarrays(head):
count = 0
pre = 0
current = head
# Traversing in linked list
while current is not None :
if current.data = = 1 :
pre = 0
else :
pre + = 1
count + = pre
current = current. next
return count
# Driver code 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 )
# Function call print (count_zero_filled_subarrays(head))
|
using System;
// Structure of node public class Node
{ public int data;
public Node next;
public Node( int x)
{
data = x;
next = null ;
}
} public class GFG
{ // Function to count subarrays of 0
public static int CountZeroFilledSubarrays(Node head)
{
int count = 0, pre = 0;
Node current = head;
// traversing in linked list
while (current != null )
{
if (current.data == 1)
pre = 0;
else
pre++;
count = count + pre;
current = current.next;
}
return count;
}
// Driver code
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);
// Function call
Console.WriteLine(CountZeroFilledSubarrays(head));
}
} // This code is contributed by Dwaipayan Bandyopadhyay |
// Structure of node class Node { constructor(x) {
this .data = x;
this .next = null ;
}
} // Function to count subarrays of 0 function count_zero_filled_subarrays(head) {
let count = 0;
let pre = 0;
let current = head;
// traversing in linked list
while (current !== null ) {
if (current.data === 1) {
pre = 0;
} else {
pre += 1;
}
count += pre;
current = current.next;
}
return count;
} // Driver code 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)); |
5
Time Complexity: O(n)
Auxiliary Space: O(1)
Related Articles: