Skip to content
Related Articles

Related Articles

Count triplets in a sorted doubly linked list whose product is equal to a given value x
  • Difficulty Level : Hard
  • Last Updated : 04 Feb, 2021

Given a sorted doubly linked list of distinct nodes(no two nodes have the same data) and a value x. The task is to count the triplets in the list that product up to a given value x.

Examples:

Input: list = 1->2->4->5->6->8->9, x = 8 
Output:
Triplet is (1, 2, 4)

Input: list = 1->2->4->5->6->8->9, x = 120 
Output:
Triplet is (4, 5, 6) 

Naive Approach: Using three nested loops generate all triplets and check whether elements in the triplet product up to x or not.



Below is the implementation of the above approach: 

C++




// C++ implementation to count triplets
// in a sorted doubly linked list
// whose product is equal to a given value 'x'
#include <bits/stdc++.h>
using namespace std;
 
// structure of node of doubly linked list
struct Node {
    int data;
    struct Node *next, *prev;
};
 
// function to count triplets in a sorted doubly linked list
// whose product is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
    struct Node *ptr1, *ptr2, *ptr3;
    int count = 0;
 
    // generate all possible triplets
    for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)
        for (ptr2 = ptr1->next; ptr2 != NULL; ptr2 = ptr2->next)
            for (ptr3 = ptr2->next; ptr3 != NULL; ptr3 = ptr3->next)
 
                // if elements in the current triplet product up to 'x'
                if ((ptr1->data * ptr2->data * ptr3->data) == x)
 
                    // increment count
                    count++;
 
    // required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
    // allocate node
    struct Node* temp = new Node();
 
    // put in the data
    temp->data = data;
    temp->next = temp->prev = NULL;
 
    if ((*head) == NULL)
        (*head) = temp;
    else {
        temp->next = *head;
        (*head)->prev = temp;
        (*head) = temp;
    }
}
 
// Driver program to test above
int main()
{
    // start with an empty doubly linked list
    struct Node* head = NULL;
 
    // insert values in sorted order
    insert(&head, 9);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 5);
    insert(&head, 4);
    insert(&head, 2);
    insert(&head, 1);
 
    int x = 8;
 
    cout << "Count = "
         << countTriplets(head, x);
    return 0;
}

Java




// Java implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
import java.util.*;
 
// Represents node of a doubly linked list
class Node
{
    public int data;
    public Node prev, next;
    public Node(int val)
    {
        data = val;
        prev = null;
        next = null;
    }
}
 
class GFG
{
 
    // function to count triplets in
    // a sorted doubly linked list
    // whose sum is equal to a given value 'x'
    static int countTriplets(Node head, int x)
    {
        Node ptr1, ptr2, ptr3;
        int count = 0;
 
        // generate all possible triplets
        for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
            for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
                for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
 
                    // if elements in the current triplet sum up to 'x'
                    if ((ptr1.data * ptr2.data * ptr3.data) == x)
                         
                        // increment count
                        count++;
 
        // required count of triplets
        return count;
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    static Node insert(Node head, int val)
    {
        // allocate node
        Node temp = new Node(val);
 
        if (head == null)
            head = temp;
 
        else
        {
            temp.next = head;
            head.prev = temp;
            head = temp;
        }
     
        return head;
    }
 
    // Driver code
    public static void main(String []args)
    {
        // start with an empty doubly linked list
        Node head = null;
         
        // insert values in sorted order
        head = insert(head, 9);
        head = insert(head, 8);
        head = insert(head, 6);
        head = insert(head, 5);
        head = insert(head, 4);
        head = insert(head, 2);
        head = insert(head, 1);
 
        int x = 8;
        System.out.println("count = " + countTriplets(head, x));
    }
}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 implementation to count triplets
# in a sorted doubly linked list
# whose sum is equal to a given value 'x'
 
# Represents node of a doubly linked list
class Node:
    data = None
    prev = None
    next_ = None
 
    def __init__(self, val):
        self.data = val
        self.prev = None
        self.next_ = None
 
# function to count triplets in
# a sorted doubly linked list
# whose sum is equal to a given value 'x'
def countTriplets(head, x):
    ptr1, ptr2, ptr3 = Node(0), Node(0), Node(0)
    count = 0
 
    # generate all possible triplets
    ptr1 = head
    while ptr1 is not None:
        ptr2 = ptr1.next_
        while ptr2 is not None:
            ptr3 = ptr2.next_
            while ptr3 is not None:
 
                # if elements in the current
                # triplet sum up to 'x'
                if ptr1.data * ptr2.data * ptr3.data == x:
 
                    # increment count
                    count += 1
                ptr3 = ptr3.next_
            ptr2 = ptr2.next_
        ptr1 = ptr1.next_
 
        # required count of triplets
        return count
 
# A utility function to insert a new node at the
# beginning of doubly linked list
def insert(head, val):
 
    # allocate node
    temp = Node(val)
    if head is None:
        head = temp
    else:
        temp.next_ = head
        head.prev = temp
        head = temp
 
    return head
 
# Driver Code
if __name__ == "__main__":
 
    # start with an empty doubly linked list
    head = Node(0)
 
    # insert values in sorted order
    head = insert(head, 9)
    head = insert(head, 8)
    head = insert(head, 6)
    head = insert(head, 5)
    head = insert(head, 4)
    head = insert(head, 2)
    head = insert(head, 1)
 
    x = 8
    print("count =", countTriplets(head, x))
 
# This code is contributed by
# sanjeev2552

C#




// C# implementation to count triplets
// in a sorted doubly linked list
// whose sum is equal to a given value 'x'
using System;
 
// Represents node of a doubly linked list
public class Node
{
    public int data;
    public Node prev, next;
    public Node(int val)
    {
        data = val;
        prev = null;
        next = null;
    }
}
 
class GFG
{
 
    // function to count triplets in
    // a sorted doubly linked list
    // whose sum is equal to a given value 'x'
    static int countTriplets(Node head, int x)
    {
        Node ptr1, ptr2, ptr3;
        int count = 0;
 
        // generate all possible triplets
        for (ptr1 = head; ptr1 != null; ptr1 = ptr1.next)
            for (ptr2 = ptr1.next; ptr2 != null; ptr2 = ptr2.next)
                for (ptr3 = ptr2.next; ptr3 != null; ptr3 = ptr3.next)
 
                    // if elements in the current triplet sum up to 'x'
                    if ((ptr1.data * ptr2.data * ptr3.data) == x)
                         
                        // increment count
                        count++;
 
        // required count of triplets
        return count;
    }
 
    // A utility function to insert a new node at the
    // beginning of doubly linked list
    static Node insert(Node head, int val)
    {
        // allocate node
        Node temp = new Node(val);
 
        if (head == null)
            head = temp;
 
        else
        {
            temp.next = head;
            head.prev = temp;
            head = temp;
        }
     
        return head;
    }
 
    // Driver code
    public static void Main(String []args)
    {
        // start with an empty doubly linked list
        Node head = null;
         
        // insert values in sorted order
        head = insert(head, 9);
        head = insert(head, 8);
        head = insert(head, 6);
        head = insert(head, 5);
        head = insert(head, 4);
        head = insert(head, 2);
        head = insert(head, 1);
 
        int x = 8;
        Console.WriteLine("count = " + countTriplets(head, x));
    }
}
 
// This code is contributed by Arnab Kundu
Output: 
Count = 1

 

Time Complexity: O(n^3) 
Auxiliary Space: O(1)

Method-2 (Hashing): Create a hash table with (key, value) tuples represented as (node data, node pointer) tuples. Traverse the doubly linked list and store each node’s data and its pointer pair(tuple) in the hash table. Now, generate each possible pair of nodes. For each pair of nodes, calculate the p_product(product of data in the two nodes) and check whether (x/p_product) exists in the hash table or not. If it exists, then also verify that the two nodes in the pair are not same to the node associated with (x/p_product) in the hash table and finally increment count. Return (count / 3) as each triplet is counted 3 times in the above process.

Below is the implementation of the above approach: 

C++




// C++ implementation to count triplets
// in a sorted doubly linked list
// whose product is equal to a given value 'x'
#include <bits/stdc++.h>
using namespace std;
 
// structure of node of doubly linked list
struct Node {
    int data;
    struct Node *next, *prev;
};
 
// function to count triplets in a sorted doubly linked list
// whose product is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
    struct Node *ptr, *ptr1, *ptr2;
    int count = 0;
 
    // unordered_map 'um' implemented as hash table
    unordered_map<int, Node*> um;
 
    // insert the <node data, node pointer> tuple in 'um'
    for (ptr = head; ptr != NULL; ptr = ptr->next)
        um[ptr->data] = ptr;
 
    // generate all possible pairs
    for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)
        for (ptr2 = ptr1->next; ptr2 != NULL; ptr2 = ptr2->next) {
 
            // p_product = product of elements in the current pair
            int p_product = (ptr1->data * ptr2->data);
 
            // if 'x/p_product' is present in 'um' and
            // either of the two nodes
            // are not equal to the 'um[x/p_product]' node
            if (um.find(x / p_product) != um.end() && um[x / p_product] != ptr1
                && um[x / p_product] != ptr2)
 
                // increment count
                count++;
        }
 
    // required count of triplets
    // division by 3 as each triplet is counted 3 times
    return (count / 3);
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
    // allocate node
    struct Node* temp = new Node();
 
    // put in the data
    temp->data = data;
    temp->next = temp->prev = NULL;
 
    if ((*head) == NULL)
        (*head) = temp;
    else {
        temp->next = *head;
        (*head)->prev = temp;
        (*head) = temp;
    }
}
 
// Driver program to test above functions
int main()
{
    // start with an empty doubly linked list
    struct Node* head = NULL;
 
    // insert values in sorted order
    insert(&head, 9);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 5);
    insert(&head, 4);
    insert(&head, 2);
    insert(&head, 1);
 
    int x = 8;
 
    cout << "Count = "
         << countTriplets(head, x);
    return 0;
}

Java




// Java implementation to count triplets
// in a sorted doubly linked list whose
// product is equal to a given value 'x'
import java.io.*;
import java.util.*;
 
// Structure of node of doubly linked list
class Node
{
    int data;
    Node next, prev;
}
 
class GFG{
     
// Function to count triplets in a sorted
// doubly linked list whose product is
// equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    Node ptr, ptr1, ptr2;
    int count = 0;
     
    // Unordered_map 'um' implemented
    // as hash table
    Map<Integer,
        Node> um = new HashMap<Integer,
                               Node>();
                                
    // Insert the <node data, node pointer>
    // tuple in 'um'
    for(ptr = head; ptr != null; ptr = ptr.next)
    {
        um.put(ptr.data, ptr);
    }
     
    // Generate all possible pairs
    for(ptr1 = head;
        ptr1 != null;
        ptr1 = ptr1.next)
    {
        for(ptr2 = ptr1.next;
            ptr2 != null;
            ptr2 = ptr2.next)
        {
             
            // p_product = product of elements
            // in the current pair
            int p_product = (ptr1.data * ptr2.data);
             
            // If 'x/p_product' is present in 'um' and
            // either of the two nodes are not equal
            // to the 'um[x/p_product]' node
            if (um.containsKey(x / p_product) &&
                um.get(x / p_product) != ptr1 &&
                um.get(x / p_product) != ptr2)
            {
                 
                // Increment count
                count++;
            }
        }
    }
     
    // Required count of triplets
    // division by 3 as each triplet
    // is counted 3 times
    return (count / 3);
}
 
// A utility function to insert a new
// node at the beginning of doubly linked list
static Node insert(Node head, int data)
{
     
    // Allocate node
    Node temp = new Node();
     
    // Put in the data
    temp.data = data;
    temp.next = temp.prev = null;
     
    if (head == null)
    {
        head = temp;
    }
    else
    {
        temp.next = head;
        head.prev = temp;
        head = temp;
    }
    return head;
}
 
// Driver code
public static void main(String[] args)
{
     
    // Start with an empty doubly linked list
    Node head = null;
     
    // Insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
     
    int x = 8;
     
    System.out.println("Count = " +
                       countTriplets(head, x));
}
}
 
// This code is contributed by avanitrachhadiya2155

Python3




# Python3 implementation to
# count triplets in a sorted
# doubly linked list whose
# product is equal to a given
# value 'x'
from math import ceil
 
# structure of node of doubly
# linked list
class Node:
   
    def __init__(self, x):
       
        self.data = x
        self.next = None
        self.prev = None
 
# function to count triplets
# in a sorted doubly linked
# list whose product is equal
# to a given value 'x'
def countTriplets(head, x):
 
    ptr, ptr1, ptr2 = None, None, None
    count = 0
 
    # unordered_map 'um' implemented
    # as hash table
    um = {}
 
    # insert the  tuple in 'um'
    ptr = head
    while ptr != None:
        um[ptr.data] = ptr
        ptr = ptr.next
 
    # generate all possible pairs
    ptr1 = head
     
    while ptr1 != None:
        ptr2 = ptr1.next
        while ptr2 != None:
 
            # p_product = product of
            # elements in the current
            # pair
            p_product = (ptr1.data *
                         ptr2.data)
 
            # if 'x/p_product' is present
            # in 'um' and either of the
            # two nodes are not equal to
            # the 'um[x/p_product]' node
            if ((x / p_product) in um and
               (x / p_product) != ptr1 and
                um[x / p_product] != ptr2):
 
                # increment count
                count += 1
            ptr2 = ptr2.next
        ptr1 = ptr1.next
 
    # required count of triplets
    # division by 3 as each triplet
    # is counted 3 times
    return (count // 3)
 
# A utility function to insert a
# new node at the beginning of
# doubly linked list
def insert(head, data):
   
    # allocate node
    temp = Node(data)
 
    # put in the data
    temp.data = data
    temp.next = temp.prev = None
 
    if (head == None):
        head = temp
    else:
        temp.next = head
        head.prev = temp
        head = temp
    return head
 
# Driver code
if __name__ == '__main__':
   
    # start with an empty
    # doubly linked list
    head = None
 
    # insert values in sorted
    # order
    head = insert(head, 9)
    head = insert(head, 8)
    head = insert(head, 6)
    head = insert(head, 5)
    head = insert(head, 4)
    head = insert(head, 2)
    head = insert(head, 1)
 
    x = 8
    print("Count =",
           countTriplets(head, x))
 
# This code is contributed by Mohit Kumar 29

C#




// C# implementation to count triplets
// in a sorted doubly linked list whose
// product is equal to a given value 'x'
using System;
using System.Collections.Generic;
 
// Structure of node of doubly linked list
class Node
{
    public int data;
    public Node next, prev;
}
 
class GFG
{
 
// Function to count triplets in a sorted
// doubly linked list whose product is
// equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    Node ptr, ptr1, ptr2;
    int count = 0;
      
    // Unordered_map 'um' implemented
    // as hash table
    Dictionary<int, Node> um = new Dictionary<int, Node>();
     
    // Insert the <node data, node pointer>
    // tuple in 'um'
    for(ptr = head; ptr != null; ptr = ptr.next)
    {
        um.Add(ptr.data, ptr);
    }
     // Generate all possible pairs
    for(ptr1 = head;
        ptr1 != null;
        ptr1 = ptr1.next)
    {
        for(ptr2 = ptr1.next;
            ptr2 != null;
            ptr2 = ptr2.next)
        {
              
            // p_product = product of elements
            // in the current pair
            int p_product = (ptr1.data * ptr2.data);
              
            // If 'x/p_product' is present in 'um' and
            // either of the two nodes are not equal
            // to the 'um[x/p_product]' node
            if (um.ContainsKey(x / p_product) &&
                um[x / p_product] != ptr1 &&
                um[x / p_product] != ptr2)
            {
                  
                // Increment count
                count++;
            }
        }
    }
      
    // Required count of triplets
    // division by 3 as each triplet
    // is counted 3 times
    return (count / 3);
}
 
// A utility function to insert a new
// node at the beginning of doubly linked list
static Node insert(Node head, int data)
{
      
    // Allocate node
    Node temp = new Node();
      
    // Put in the data
    temp.data = data;
    temp.next = temp.prev = null;   
    if (head == null)
    {
        head = temp;
    }
    else
    {
        temp.next = head;
        head.prev = temp;
        head = temp;
    }
    return head;
}
  
// Driver code    
static public void Main ()
{
   
    // Start with an empty doubly linked list
    Node head = null;
      
    // Insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);   
    int x = 8;
    Console.WriteLine("Count = " + countTriplets(head, x));
}
}
 
// This code is contributed by rag2127
Output: 
Count = 1

 

Time Complexity: O(n^2) 
Auxiliary Space: O(n)

Method-3 (Use of two pointers): Traverse the doubly linked list from left to right. For each current node during the traversal, initialize two pointers first = pointer to the node next to the current node and last = pointer to the last node of the list. Now, count pairs in the list from first to the last pointer that product up to the value (x / current node’s data) (algorithm described in this post). Add this count to the total_count of triplets. Pointer to the last node can be found only once in the beginning.

Below is the implementation of the above approach:  

C++




// C++ implementation to count triplets
// in a sorted doubly linked list
// whose product is equal to a given value 'x'
#include <bits/stdc++.h>
using namespace std;
 
// structure of node of doubly linked list
struct Node {
    int data;
    struct Node *next, *prev;
};
 
// function to count pairs whose product equal to given 'value'
int countPairs(struct Node* first, struct Node* second, int value)
{
    int count = 0;
 
    // The loop terminates when either of two pointers
    // become NULL, or they cross each other (second->next
    // == first), or they become same (first == second)
    while (first != NULL && second != NULL && first != second
           && second->next != first) {
 
        // pair found
        if ((first->data * second->data) == value) {
 
            // increment count
            count++;
 
            // move first in forward direction
            first = first->next;
 
            // move second in backward direction
            second = second->prev;
        }
 
        // if product is greater than 'value'
        // move second in backward direction
        else if ((first->data * second->data) > value)
            second = second->prev;
 
        // else move first in forward direction
        else
            first = first->next;
    }
 
    // required count of pairs
    return count;
}
 
// function to count triplets in a sorted doubly linked list
// whose product is equal to a given value 'x'
int countTriplets(struct Node* head, int x)
{
    // if list is empty
    if (head == NULL)
        return 0;
 
    struct Node *current, *first, *last;
    int count = 0;
 
    // get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last->next != NULL)
        last = last->next;
 
    // traversing the doubly linked list
    for (current = head; current != NULL; current = current->next) {
 
        // for each current node
        first = current->next;
 
        // count pairs with product(x / current->data) in the range
        // first to last and add it to the 'count' of triplets
        count += countPairs(first, last, x / current->data);
    }
 
    // required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
void insert(struct Node** head, int data)
{
    // allocate node
    struct Node* temp = new Node();
 
    // put in the data
    temp->data = data;
    temp->next = temp->prev = NULL;
 
    if ((*head) == NULL)
        (*head) = temp;
    else {
        temp->next = *head;
        (*head)->prev = temp;
        (*head) = temp;
    }
}
 
// Driver program to test above
int main()
{
    // start with an empty doubly linked list
    struct Node* head = NULL;
 
    // insert values in sorted order
    insert(&head, 9);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 5);
    insert(&head, 4);
    insert(&head, 2);
    insert(&head, 1);
 
    int x = 8;
 
    cout << "Count = "
         << countTriplets(head, x);
    return 0;
}

Java




// Java implementation to count triplets
// in a sorted doubly linked list
// whose product is equal to a given value 'x'
import java.util.*;
 
class GFG
{
     
// structure of node of doubly linked list
static class Node
{
    int data;
    Node next, prev;
};
 
// function to count pairs whose product
// equal to given 'value'
static int countPairs(Node first, Node second,
                      int value)
{
    int count = 0;
 
    // The loop terminates when either of two pointers
    // become null, or they cross each other (second.next
    // == first), or they become same (first == second)
    while (first != null && second != null &&
            first != second && second.next != first)
    {
 
        // pair found
        if ((first.data * second.data) == value)
        {
 
            // increment count
            count++;
 
            // move first in forward direction
            first = first.next;
 
            // move second in backward direction
            second = second.prev;
        }
 
        // if product is greater than 'value'
        // move second in backward direction
        else if ((first.data * second.data) > value)
            second = second.prev;
 
        // else move first in forward direction
        else
            first = first.next;
    }
 
    // required count of pairs
    return count;
}
 
// function to count triplets in
// a sorted doubly linked list
// whose product is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    // if list is empty
    if (head == null)
        return 0;
 
    Node current, first, last;
    int count = 0;
 
    // get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last.next != null)
        last = last.next;
 
    // traversing the doubly linked list
    for (current = head; current != null;
        current = current.next)
    {
 
        // for each current node
        first = current.next;
 
        // count pairs with product(x / current.data)
        // in the range first to last and
        // add it to the 'count' of triplets
        count += countPairs(first, last, x / current.data);
    }
 
    // required count of triplets
    return count;
}
 
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int data)
{
    // allocate node
    Node temp = new Node();
 
    // put in the data
    temp.data = data;
    temp.next = temp.prev = null;
 
    if ((head) == null)
        (head) = temp;
    else
    {
        temp.next = head;
        (head).prev = temp;
        (head) = temp;
    }
    return head;
}
 
// Driver code
public static void main(String args[])
{
    // start with an empty doubly linked list
    Node head = null;
 
    // insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
 
    int x = 8;
 
    System.out.println( "Count = "+ countTriplets(head, x));
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 implementation to count triplets
# in a sorted doubly linked list whose
# product is equal to a given value 'x'
      
# Structure of node of doubly linked list
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.next = None
        self.prev = None
 
# Function to count pairs whose product
# equal to given 'value'
def countPairs(first, second, value):
     
    count = 0
  
    # The loop terminates when either of two pointers
    # become None, or they cross each other (second.next
    # == first), or they become same (first == second)
    while (first != None and second != None and
            first != second and second.next != first):
 
        # Pair found
        if ((first.data * second.data) == value):
             
            # Increment count
            count += 1
  
            # Move first in forward direction
            first = first.next
  
            # Move second in backward direction
            second = second.prev
  
        # If product is greater than 'value'
        # move second in backward direction
        elif ((first.data * second.data) > value):
            second = second.prev
  
        # Else move first in forward direction
        else:
            first = first.next
  
    # Required count of pairs
    return count
  
# Function to count triplets in a sorted
# doubly linked list whose product is
# equal to a given value 'x'
def countTriplets(head, x):
 
    # If list is empty
    if (head == None):
        return 0
  
    count = 0
  
    # Get pointer to the last node of
    # the doubly linked list
    last = head
     
    while (last.next != None):
        last = last.next
         
    current = head
     
    # Traversing the doubly linked list
    while current != None:
         
        # For each current node
        first = current.next
  
        # Count pairs with product(x / current.data)
        # in the range first to last and
        # add it to the 'count' of triplets
        count += countPairs(first, last,
                            x // current.data)
        current = current.next
  
    # Required count of triplets
    return count
 
# A utility function to insert a new node
# at the beginning of doubly linked list
def insert(head, data):
 
    # Allocate node
    temp = Node(data)
  
    # Put in the data
    temp.data = data
    temp.next = temp.prev = None
  
    if ((head) == None):
        (head) = temp
    else:
        temp.next = head
        (head).prev = temp
        (head) = temp
     
    return head
 
# Driver code
if __name__=='__main__':
     
    # Start with an empty doubly linked list
    head = None
  
    # Insert values in sorted order
    head = insert(head, 9)
    head = insert(head, 8)
    head = insert(head, 6)
    head = insert(head, 5)
    head = insert(head, 4)
    head = insert(head, 2)
    head = insert(head, 1)
  
    x = 8
  
    print( "Count = " + str(countTriplets(head, x)))
 
# This code is contributed by rutvik_56

C#




// C# implementation to count triplets
// in a sorted doubly linked list
// whose product is equal to a given value 'x'
using System;
 
class GFG
{
      
// structure of node of doubly linked list
class Node
{
    public int data;
    public Node next, prev;
};
  
// function to count pairs whose product
// equal to given 'value'
static int countPairs(Node first, Node second,
                      int value)
{
    int count = 0;
  
    // The loop terminates when either of two pointers
    // become null, or they cross each other (second.next
    // == first), or they become same (first == second)
    while (first != null && second != null &&
            first != second && second.next != first)
    {
  
        // pair found
        if ((first.data * second.data) == value)
        {
  
            // increment count
            count++;
  
            // move first in forward direction
            first = first.next;
  
            // move second in backward direction
            second = second.prev;
        }
  
        // if product is greater than 'value'
        // move second in backward direction
        else if ((first.data * second.data) > value)
            second = second.prev;
  
        // else move first in forward direction
        else
            first = first.next;
    }
  
    // required count of pairs
    return count;
}
  
// function to count triplets in
// a sorted doubly linked list
// whose product is equal to a given value 'x'
static int countTriplets(Node head, int x)
{
    // if list is empty
    if (head == null)
        return 0;
  
    Node current, first, last;
    int count = 0;
  
    // get pointer to the last node of
    // the doubly linked list
    last = head;
    while (last.next != null)
        last = last.next;
  
    // traversing the doubly linked list
    for (current = head; current != null;
        current = current.next)
    {
  
        // for each current node
        first = current.next;
  
        // count pairs with product(x / current.data)
        // in the range first to last and
        // add it to the 'count' of triplets
        count += countPairs(first, last, x / current.data);
    }
  
    // required count of triplets
    return count;
}
  
// A utility function to insert a new node at the
// beginning of doubly linked list
static Node insert(Node head, int data)
{
    // allocate node
    Node temp = new Node();
  
    // put in the data
    temp.data = data;
    temp.next = temp.prev = null;
  
    if ((head) == null)
        (head) = temp;
    else
    {
        temp.next = head;
        (head).prev = temp;
        (head) = temp;
    }
    return head;
}
  
// Driver code
public static void Main(String []args)
{
    // start with an empty doubly linked list
    Node head = null;
  
    // insert values in sorted order
    head = insert(head, 9);
    head = insert(head, 8);
    head = insert(head, 6);
    head = insert(head, 5);
    head = insert(head, 4);
    head = insert(head, 2);
    head = insert(head, 1);
  
    int x = 8;
  
    Console.WriteLine( "Count = "+ countTriplets(head, x));
}
}
 
// This code is contributed by Rajput-Ji
Output: 
Count = 1

 

Time Complexity: O(n^2) 
Auxiliary Space: O(1)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

 

My Personal Notes arrow_drop_up
Recommended Articles
Page :