Maximize product of lengths of strings having no common characters

Given an array arr[] consisting of N strings, the task is to find the maximum product of the length of the strings arr[i] and arr[j] for all unique pairs (i, j), where the strings arr[i] and arr[j] contain no common characters.

Examples:

Input: arr[] = {“abcw”, “baz”, “foo”, “bar”, “xtfn”, “abcdef”}
Output: 16
Explanation: The strings “abcw” and “xtfn” have no common characters in it. Therefore, the product of the length of both the strings = 4 * 4 = 16, which is maximum among all possible pairs.

Input: arr[] = {“a”, “aa”, “aaa”, “aaaa”}
Output: 0

Naive Approach: The idea is to generate all the pairs of strings and use a map to find the common character between them, if there are no common character between them, then use the product of their length to maximize the result.

Follow the steps below to implement the above idea:

• Generate all pairs of strings say, s1 and s2.
• Use a map to find the common character between the strings s1 and s2.
• Check if there is any common character between them:
  • If there is no common character between them then use the product of their length and maximize the result.
• Finally, return the result.

Below is the implementation of the above approach:

C++

// C++ program to find the find the maximum product of the
// length of the strings arr[i] and arr[j] for all unique
// pairs (i, j), where the strings arr[i] and arr[j] contain
// no common characters.
#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum product of the length of the
// strings
int maximizeProduct(vector<string>& arr)
{
    int n = arr.size();

    // This store the maximum product of string's length
    int result = 0;

    // Iterate to find the 1st string
    for (int i = 0; i < n; i++) {
        string s1 = arr[i];
        int len1 = arr[i].size();

        // Map to store the unique character
        unordered_map<char, int> unmap;
        for (auto c1 : s1)
            unmap[c1]++;

        // Iterate to find the 2nd string
        for (int j = i + 1; j < n; j++) {
            string s2 = arr[j];
            int len2 = arr[j].size();

            bool flag = false;

            for (int k = 0; k < s2.size(); k++) {

                // Check if the characters of s2 are common
                // with s1 characters or not
                if (unmap.count(s2[k])) {
                    flag = true;
                    break;
                }
            }

            // This verify that there is no common character
            // between s1 and s2.
            if (flag == false) {
                result = max(result, len1 * len2);
            }
        }
    }

    return result;
}

// Driver code
int main()
{
    vector<string> arr
        = { "abcw", "baz", "foo", "bar", "xtfn", "abcdef" };

    int result = maximizeProduct(arr);

    // Print the output
    cout << result;

    return 0;
}

Java

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;

class GFG {
    // Java program to find the find the maximum product of
    // the length of the strings arr[i] and arr[j] for all
    // unique pairs (i, j), where the strings arr[i] and
    // arr[j] contain no common characters.

    // Function to find the maximum product of the length of
    // the strings
    static int maximizeProduct(String[] arr)
    {
        int n = arr.length;

        // This store the maximum product of string's length
        int result = 0;

        // Iterate to find the 1st string
        for (int i = 0; i < n; i++) {
            String s1 = arr[i];
            int len1 = arr[i].length();

            // Map to store the unique character
            HashMap<Character, Integer> unmap
                = new HashMap<>();
            for (char c : s1.toCharArray()) {
                if (unmap.containsKey(c)) {
                    unmap.put(c, unmap.get(c) + 1);
                }
                else
                    unmap.put(c, 1);
            }
            // Iterate to find the 2nd string
            for (int j = i + 1; j < n; j++) {
                String s2 = arr[j];
                int len2 = arr[j].length();

                boolean flag = false;

                for (int k = 0; k < s2.length(); k++) {

                    // Check if the characters of s2 are
                    // common with s1 characters or not
                    if (unmap.containsKey(s2.charAt(k))) {
                        flag = true;
                        break;
                    }
                }

                // This verify that there is no common
                // character between s1 and s2.
                if (flag == false) {
                    result = Math.max(result, len1 * len2);
                }
            }
        }

        return result;
    }

    // Driver Code
    public static void main(String args[])
    {
        String[] arr = { "abcw", "baz",  "foo",
                         "bar",  "xtfn", "abcdef" };

        int result = maximizeProduct(arr);

        // Print the output
        System.out.println(result);
    }
}

Python3

# Python3 program to find the find the maximum product of the
# length of the strings arr[i] and arr[j] for all unique
# pairs (i, j), where the strings arr[i] and arr[j] contain
# no common characters.

# Function to find the maximum product of the length of the
# strings


def maximizeProduct(arr):

    n = len(arr)

    # This store the maximum product of string's length
    result = 0

    # Iterate to find the 1st string
    for i in range(n):
        s1 = arr[i]
        len1 = len(arr[i])

        # Map to store the unique character
        unmap = {}
        for c in s1:
            if(c in unmap):
                unmap += 1

            unmap = 1

        # Iterate to find the 2nd string
        for j in range(i+1, n):
            s2 = arr[j]
            len2 = len(arr[j])

            flag = False

            for k in range(len(s2)):

                # Check if the characters of s2 are common
                # with s1 characters or not
                if (s2[k] in unmap):
                    flag = True
                    break

            # This verify that there is no common character
            # between s1 and s2.
            if (flag == False):
                result = max(result, len1 * len2)

    return result


# Driver code
arr = ["abcw", "baz",  "foo",  "bar",  "xtfn", "abcdef"]
result = maximizeProduct(arr)

# Print the output
print(result)

# This code is contributed by shinjanpatra

C#

// C# program to find the find the maximum product of the
// length of the strings arr[i] and arr[j] for all unique
// pairs (i, j), where the strings arr[i] and arr[j] contain
// no common characters.
using System;
using System.Collections.Generic;

public class Test {

    // Function to find the maximum product of the length of
    // the strings
    static int maximizeProduct(List<string> arr)
    {
        int n = arr.Count;

        // This store the maximum product of string's length
        int result = 0;

        // Iterate to find the 1st string
        for (int i = 0; i < n; i++) {
            string s1 = arr[i];
            int len1 = arr[i].Length;

            // Map to store the unique character
            Dictionary<char, int> unmap
                = new Dictionary<char, int>();
            foreach(char c in s1)
            {
                if (unmap.ContainsKey(c))
                    unmap++;
                else
                    unmap.Add(c, 1);
            }

            // Iterate to find the 2nd string
            for (int j = i + 1; j < n; j++) {
                string s2 = arr[j];
                int len2 = arr[j].Length;
                bool flag = false;
                for (int k = 0; k < s2.Length; k++) {

                    // Check if the characters of s2 are
                    // common with s1 characters or not
                    if (unmap.ContainsKey(s2[k])) {
                        flag = true;
                        break;
                    }
                }

                // This verify that there is no common
                // character between s1 and s2.
                if (flag == false) {
                    result = Math.Max(result, len1 * len2);
                }
            }
        }
        return result;
    }

    // Driver code
    public static void Main()
    {
        List<string> arr
            = new List<string>{ "abcw", "baz",  "foo",
                                "bar",  "xtfn", "abcdef" };
        int result = maximizeProduct(arr);

        // Print the output
        Console.WriteLine(result);
    }
}

// This code is contributed by ishankhandelwals.

Javascript

<script>

// JavaScript program to find the find the maximum product of the
// length of the strings arr[i] and arr[j] for all unique
// pairs (i, j), where the strings arr[i] and arr[j] contain
// no common characters.

// Function to find the maximum product of the length of the
// strings
function maximizeProduct(arr)
{
    let n = arr.length;

    // This store the maximum product of string's length
    let result = 0;

    // Iterate to find the 1st string
    for (let i = 0; i < n; i++) {
        let s1 = arr[i];
        let len1 = arr[i].length;

        // Map to store the unique character
        let unmap = new Map();
        for (let c of s1){
            if(unmap.has(c)){
                unmap.set(c,unmap.get(c)+1);
            }
            unmap.set(c,1);
        }

        // Iterate to find the 2nd string
        for (let j = i + 1; j < n; j++) {
            let s2 = arr[j];
            let len2 = arr[j].length;

            let flag = false;

            for (let k = 0; k < s2.length; k++) {

                // Check if the characters of s2 are common
                // with s1 characters or not
                if (unmap.has(s2[k])) {
                    flag = true;
                    break;
                }
            }

            // This verify that there is no common character
            // between s1 and s2.
            if (flag == false) {
                result = Math.max(result, len1 * len2);
            }
        }
    }

    return result;
}

// Driver code
let arr = [ "abcw", "baz",  "foo",  "bar",  "xtfn", "abcdef" ];
let result = maximizeProduct(arr);

// Print the output
document.write(result,"</br>");

// This code is contributed by shinjanpatra

</script>

Output

16

Time Complexity: O(N² * M), where M is the maximum length of the string.
Auxiliary Space: O(M)