Finding minimum length of consecutive sub-series containing all distinct input strings - algorithm

Question

I have the following question and I am unsure how to approach. I would like some help/hints with designing an efficient algorithm for the following requirements
Input
The first line of the input contains an integer N, which is length of the series.
This is followed by N lines, each of which contains a string containing only lower case characters.
1<=N<=100000.
Length of each string is between 1 and 10 (inclusive).
Output
Output the minimum length of the consecutive sub-series which contains all distinct strings.
Sample Input
6
letitbe
mihon
mihon
omi
omi
letitbe
Sample Output
18
Explanation: the last 4 consecutive strings contains all unique strings with the minimum length (smallest number of characters)

Answer 1

If I understood this correctly, you want the subseries which:
Contains at least 1 instance of "letitbe, "mihon" and "omi"
Has the lowest possible sum of string lengths
Here is how to do this efficiently, code in C#, algorithm explained in comments:
static void Main(string[] args)
{
// Input
var elements = new List<string> { "letitbe", "mihon", "mihon", "omi", "omi", "letitbe" };
// Find distinct elements
var distinctElements = elements.Distinct().ToList();
// Create a dictionary that tells us how many copies of each element we have in the current subseries, initialize all values to 0
var copiesOfElementInCurrentSubseries = distinctElements.ToDictionary(key => key, value => 0);
// The sum of lengths of strings in the current subseries
// Our goal is to minimize this
var lengthOfCurrentSubseries = 0;
// How many distinct elements are covered by the current subseries
// The condition under which we minimize lengthOfCurrentSubseries is that numberOfElementsCoveredByCurrentSubseries equals distinctElements
var numberOfElementsCoveredByCurrentSubseries = 0;
// We remember the solution in these
var bestStartIndex = 0;
var bestLength = elements.Sum(e => e.Length);
var bestNum = elements.Count;
// Start with startIndex and endIndex at 0, increase endIndex until we cover all distinct elements
// The subseries from startIndex to endIndex (inclusive) is our current subseries
for (int startIndex = 0, endIndex = 0; endIndex < elements.Count; endIndex++)
{
// We add the element at endIndex to our current subseries:
// If we found an element that previously wasn't covered, increase the count of covered elements
// Note that we never decrease this, because once we find a solution that covers all elements, we never make a change which "loses" some element
if (copiesOfElementInCurrentSubseries[elements[endIndex]] == 0)
{
numberOfElementsCoveredByCurrentSubseries++;
}
// Increase the number of copies of the element we added
copiesOfElementInCurrentSubseries[elements[endIndex]]++;
// Increase the total length of subseries by this element's length
lengthOfCurrentSubseries += elements[endIndex].Length;
// Initially, we will just loop increasing endIndex until all elements are covered
// Once we are covering all elements, try to improve the solution
if (numberOfElementsCoveredByCurrentSubseries == distinctElements.Count)
{
// Move startIndex to the right as far as possible while still covering all elements
while (copiesOfElementInCurrentSubseries[elements[startIndex]] > 1)
{
lengthOfCurrentSubseries -= elements[startIndex].Length;
copiesOfElementInCurrentSubseries[elements[startIndex]]--;
startIndex++;
}
// If the new solution is better, remember it
if (lengthOfCurrentSubseries < bestLength)
{
bestLength = lengthOfCurrentSubseries;
bestStartIndex = startIndex;
bestNum = endIndex - startIndex + 1;
}
}
// Now we add another element by moving endIndex one place to the right, then try improving the solution by moving startIndex to the right, and we repeat this process...
}
Console.WriteLine(string.Join(" ", elements.Skip(bestStartIndex).Take(bestNum)));
}
Note that even though this has nested loops, the inner while loop can have at most length of input steps total in all passes of the inner loop combined, as startIndex keeps its value and always moves to the right.
In case you are unfamiliar with C# - Dictionary is basically a hashtable - it can efficiently look up values based on keys (as long as the keys have a good hash function, which strings do).