Skip to content
Related Articles

Related Articles

Maximize length of the String by concatenating characters from an Array of Strings

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 01 Aug, 2022
Improve Article
Save Article

Find the largest possible string of distinct characters formed using a combination of given strings. Any given string has to be chosen completely or not to be chosen at all. 

Examples:

Input: strings =”abcd”, “efgh”, “efgh” 
Output: 8
Explanation: 
All possible combinations are {“”, “abcd”, “efgh”, “abcdefgh”}. 
Therefore, maximum length possible is 8.

Input: strings = “123467890” 
Output: 10
Explanation: 
All possible combinations are: “”, “1234567890”. 
Therefore, the maximum length possible is 10. 

 

Approach: The idea is to use Recursion

Follow the steps below to solve the problem:

  • Iterate from left to right and consider every string as a possible starting substring.
  • Initialize a HashSet to store the distinct characters encountered so far.
  • Once a string is selected as starting substring, check for every remaining string, if it only contains characters which have not occurred before. Append this string as a substring to the current string being generated.
  • After performing the above steps, print the maximum length of a string that has been generated.

Below is the implementation of the above approach:

C++




// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if all the
// string characters are unique
bool check(string s)
{
 
    set<char> a;
 
    // Check for repetition in
    // characters
    for (auto i : s) {
        if (a.count(i))
            return false;
        a.insert(i);
    }
 
    return true;
}
 
// Function to generate all possible strings
// from the given array
vector<string> helper(vector<string>& arr,
                    int ind)
{
 
    // Base case
    if (ind == arr.size())
        return { "" };
 
    // Consider every string as
    // a starting substring and
    // store the generated string
    vector<string> tmp
        = helper(arr, ind + 1);
 
    vector<string> ret(tmp.begin(),
                    tmp.end());
 
    // Add current string to result of
    // other strings and check if
    // characters are unique or not
    for (auto i : tmp) {
        string test = i + arr[ind];
        if (check(test))
            ret.push_back(test);
    }
 
    return ret;
}
 
// Function to find the maximum
// possible length of a string
int maxLength(vector<string>& arr)
{
    vector<string> tmp = helper(arr, 0);
 
    int len = 0;
 
    // Return max length possible
    for (auto i : tmp) {
        len = len > i.size()
                ? len
                : i.size();
    }
 
    // Return the answer
    return len;
}
 
// Driver Code
int main()
{
    vector<string> s;
    s.push_back("abcdefgh");
 
    cout << maxLength(s);
 
    return 0;
}

Java




// Java program to implement 
// the above approach
import java.util.*;
import java.lang.*;
 
class GFG{
 
// Function to check if all the
// string characters are unique
static boolean check(String s)
{
    HashSet<Character> a = new HashSet<>();
     
    // Check for repetition in
    // characters
    for(int i = 0; i < s.length(); i++)
    {
        if (a.contains(s.charAt(i)))
        {
            return false;
        }
        a.add(s.charAt(i));
    }
    return true;
}
 
// Function to generate all possible
//  strings from the given array
static ArrayList<String> helper(ArrayList<String> arr,
                                int ind)
{
    ArrayList<String> fin = new ArrayList<>();
    fin.add("");
       
    // Base case
    if (ind == arr.size() )
        return fin;
     
    // Consider every string as
    // a starting substring and
    // store the generated string
    ArrayList<String> tmp = helper(arr, ind + 1);
     
    ArrayList<String> ret = new ArrayList<>(tmp);
     
    // Add current string to result of
    // other strings and check if
    // characters are unique or not
    for(int i = 0; i < tmp.size(); i++)
    {
        String test = tmp.get(i) +
                      arr.get(ind);
                         
        if (check(test))
            ret.add(test);
    }
    return ret;
}
 
// Function to find the maximum
// possible length of a string
static int maxLength(ArrayList<String> arr)
{
    ArrayList<String> tmp = helper(arr, 0);
     
    int len = 0;
     
    // Return max length possible
    for(int i = 0; i < tmp.size(); i++)
    {
        len = len > tmp.get(i).length() ? len : 
                    tmp.get(i).length();
    }
       
    // Return the answer
    return len;
}
 
// Driver code
public static void main (String[] args)
{
    ArrayList<String> s = new ArrayList<>();
    s.add("abcdefgh");
     
    System.out.println(maxLength(s));
}
}
 
// This code is contributed by offbeat

Python3




# Python3 program to implement
# the above approach
  
# Function to check if all the
# string characters are unique
def check(s):
     
    a = set()
  
    # Check for repetition in
    # characters
    for i in s:
        if i in a:
            return False
             
        a.add(i)
  
    return True
  
# Function to generate all possible
# strings from the given array
def helper(arr, ind):
  
    # Base case
    if (ind == len(arr)):
        return [""]
  
    # Consider every string as
    # a starting substring and
    # store the generated string
    tmp = helper(arr, ind + 1)
  
    ret = tmp
  
    # Add current string to result of
    # other strings and check if
    # characters are unique or not
    for i in tmp:
        test = i + arr[ind]
         
        if (check(test)):
            ret.append(test)
  
    return ret
     
# Function to find the maximum
# possible length of a string
def maxLength(arr):
 
    tmp = helper(arr, 0)
  
    l = 0
  
    # Return max length possible
    for i in tmp:
        l = l if l > len(i) else len(i)
  
    # Return the answer
    return l
 
# Driver Code
if __name__=='__main__':
     
    s = []
    s.append("abcdefgh")
  
    print(maxLength(s))
  
# This code is contributed by pratham76

C#




// C# program to implement
// the above approach
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
 
class GFG{
     
// Function to check if all the
// string characters are unique
static bool check(string s)
{
 
    HashSet<char> a = new HashSet<char>();
 
    // Check for repetition in
    // characters
    for(int i = 0; i < s.Length; i++)
    {
        if (a.Contains(s[i]))
        {
            return false;
        }
        a.Add(s[i]);
    }
    return true;
}
 
// Function to generate all possible
// strings from the given array
static ArrayList helper(ArrayList arr,
                        int ind)
{
     
    // Base case
    if (ind == arr.Count)
        return new ArrayList(){""};
 
    // Consider every string as
    // a starting substring and
    // store the generated string
    ArrayList tmp = helper(arr, ind + 1);
 
    ArrayList ret = new ArrayList(tmp);
 
    // Add current string to result of
    // other strings and check if
    // characters are unique or not
    for(int i = 0; i < tmp.Count; i++)
    {
        string test = (string)tmp[i] +
                    (string)arr[ind];
                         
        if (check(test))
            ret.Add(test);
    }
    return ret;
}
 
// Function to find the maximum
// possible length of a string
static int maxLength(ArrayList arr)
{
    ArrayList tmp = helper(arr, 0);
 
    int len = 0;
 
    // Return max length possible
    for(int i = 0; i < tmp.Count; i++)
    {
        len = len > ((string)tmp[i]).Length ? len :
                    ((string)tmp[i]).Length;
    }
     
    // Return the answer
    return len;
}
     
// Driver Code
public static void Main(string[] args)
{
    ArrayList s = new ArrayList();
    s.Add("abcdefgh");
 
    Console.Write(maxLength(s));
}
}
 
// This code is contributed by rutvik_56

Javascript




<script>
    // Javascript program to implement the above approach
     
    // Function to check if all the
    // string characters are unique
    function check(s)
    {
        let a = new Set();
 
        // Check for repetition in
        // characters
        for(let i = 0; i < s.length; i++)
        {
            if (a.has(s[i]))
            {
                return false;
            }
            a.add(s[i]);
        }
        return true;
    }
 
    // Function to generate all possible
    //  strings from the given array
    function helper(arr, ind)
    {
        let fin = [];
        fin.push("");
 
        // Base case
        if (ind == arr.length)
            return fin;
 
        // Consider every string as
        // a starting substring and
        // store the generated string
        let tmp = helper(arr, ind + 1);
 
        let ret = tmp;
 
        // Add current string to result of
        // other strings and check if
        // characters are unique or not
        for(let i = 0; i < tmp.length; i++)
        {
            let test = tmp[i] + arr[ind];
 
            if (check(test))
                ret.push(test);
        }
        return ret;
    }
 
    // Function to find the maximum
    // possible length of a string
    function maxLength(arr)
    {
        let tmp = helper(arr, 0);
 
        let len = 0;
 
        // Return max length possible
        for(let i = 0; i < tmp.length; i++)
        {
            len = len > tmp[i].length ? len : tmp[i].length;
        }
 
        // Return the answer
        return len;
    }
     
    let s = [];
    s.push("abcdefgh");
      
    document.write(maxLength(s));
 
// This code is contributed by suresh07.
</script>

Output

8

Time Complexity: O(2N
Auxiliary Space: O(N * 2N)
 

Efficient Approach (Using Dynamic Programming): 

C++




#include <bits/stdc++.h>
using namespace std;
 
int maxLength(vector<string>& A)
{
    vector<bitset<26> > dp
        = { bitset<26>() }; // auxiliary dp storage
    int res = 0; // will store number of unique chars in
                 // resultant string
    for (auto& s : A) {
        bitset<26> a; // used to track unique chars
        for (char c : s)
            a.set(c - 'a');
        int n = a.count();
        if (n < s.size())
            continue; // duplicate chars in current string
 
        for (int i = dp.size() - 1; i >= 0; --i) {
            bitset<26> c = dp[i];
            if ((c & a).any())
                continue; // if 1 or more char common
            dp.push_back(c | a); // valid concatenation
            res = max(res, (int)c.count() + n);
        }
    }
    return res;
}
 
int main()
{
    vector<string> v = { "ab", "cd", "ab" };
    int ans = maxLength(v);
    cout << ans; // resultant answer string : cfbdghzest
    return 0;
}

Output

10

Time Complexity: O(N^2) 
Auxiliary Space: O(N * 26)
 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!