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

• Difficulty Level : Medium
• Last Updated : 01 Aug, 2022

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 ``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 helper(vector& arr,``                    ``int` `ind)``{` `    ``// Base case``    ``if` `(ind == arr.size())``        ``return` `{ ``""` `};` `    ``// Consider every string as``    ``// a starting substring and``    ``// store the generated string``    ``vector tmp``        ``= helper(arr, ind + 1);` `    ``vector 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& arr)``{``    ``vector 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 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 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 helper(ArrayList arr,``                                ``int` `ind)``{``    ``ArrayList 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 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.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 arr)``{``    ``ArrayList 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 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

 ``

Output

`8`

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

Efficient Approach (Using Dynamic Programming):

## C++

 `#include ``using` `namespace` `std;` `int` `maxLength(vector& A)``{``    ``vector > 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 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