Count Zero filled Subarrays in a Binary Linked list

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:

• Introduction to Linked List – Data Structure and Algorithm Tutorials