Programa C++ para encontrar la longitud de la substring más larga sin repetir caracteres

Dada una string str , encuentre la longitud de la substring más larga sin repetir caracteres. 

• Para “ABDEFGABEF”, las substrings más largas son “BDEFGA” y “DEFGAB”, con una longitud de 6.
• Para «BBBB», la substring más larga es «B», con una longitud de 1.
• Para «GEEKSFORGEEKS», hay dos substrings más largas que se muestran en los diagramas a continuación, con una longitud de 7

La complejidad de tiempo deseada es O(n) donde n es la longitud de la string.

Método 1 (Simple: O (n ³ )) : Podemos considerar todas las substrings una por una y verificar para cada substring si contiene todos los caracteres únicos o no. Habrá n*(n+1)/2 substrings. Si una substring contiene todos los caracteres únicos o no, se puede verificar en tiempo lineal escaneándola de izquierda a derecha y manteniendo un mapa de los caracteres visitados. La complejidad temporal de esta solución sería O(n^3).

// C++ program to find the length of the longest substring
// without repeating characters
#include <bits/stdc++.h>
using namespace std;
  
// This functionr eturns true if all characters in str[i..j]
// are distinct, otherwise returns false
bool areDistinct(string str, int i, int j)
{
  
    // Note : Default values in visited are false
    vector<bool> visited(26);
  
    for (int k = i; k <= j; k++) {
        if (visited[str[k] - 'a'] == true)
            return false;
        visited[str[k] - 'a'] = true;
    }
    return true;
}
  
// Returns length of the longest substring
// with all distinct characters.
int longestUniqueSubsttr(string str)
{
    int n = str.size();
    int res = 0; // result
    for (int i = 0; i < n; i++)
        for (int j = i; j < n; j++)
            if (areDistinct(str, i, j))
                res = max(res, j - i + 1);
    return res;
}
  
// Driver code
int main()
{
    string str = "geeksforgeeks";
    cout << "The input string is " << str << endl;
    int len = longestUniqueSubsttr(str);
    cout << "The length of the longest non-repeating "
            "character substring is "
         << len;
    return 0;
}

The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7

Método 2 (Mejor : O(n ² )) La idea es usar ventana deslizante . Siempre que vemos repetición, eliminamos la ocurrencia anterior y deslizamos la ventana.

// C++ program to find the length of the longest substring
// without repeating characters
#include <bits/stdc++.h>
using namespace std;
  
int longestUniqueSubsttr(string str)
{
    int n = str.size();
    int res = 0; // result
  
    for (int i = 0; i < n; i++) {
          
        // Note : Default values in visited are false
        vector<bool> visited(256);   
  
        for (int j = i; j < n; j++) {
  
            // If current character is visited
            // Break the loop
            if (visited[str[j]] == true)
                break;
  
            // Else update the result if
            // this window is larger, and mark
            // current character as visited.
            else {
                res = max(res, j - i + 1);
                visited[str[j]] = true;
            }
        }
  
        // Remove the first character of previous
        // window
        visited[str[i]] = false;
    }
    return res;
}
  
// Driver code
int main()
{
    string str = "geeksforgeeks";
    cout << "The input string is " << str << endl;
    int len = longestUniqueSubsttr(str);
    cout << "The length of the longest non-repeating "
            "character substring is "
         << len;
    return 0;
}

The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7

Método 4 (Tiempo lineal) : Hablemos ahora de la solución de tiempo lineal. Esta solución utiliza espacio adicional para almacenar los últimos índices de caracteres ya visitados. La idea es escanear la string de izquierda a derecha, realizar un seguimiento de la substring de caracteres no repetidos de longitud máxima vista hasta ahora en res . Cuando recorremos la string, para saber la longitud de la ventana actual necesitamos dos índices. 
1) Índice final ( j ): Consideramos el índice actual como índice final. 
2) Índice inicial ( i ): Es igual que la ventana anterior si el carácter actual no estaba presente en la ventana anterior. Para verificar si el carácter actual estaba presente en la ventana anterior o no, almacenamos el último índice de cada carácter en una array lasIndex[]. Si lastIndex[str[j]] + 1 es más que el inicio anterior, entonces actualizamos el índice de inicio i. De lo contrario, mantenemos el mismo i.  

A continuación se muestra la implementación del enfoque anterior:

// C++ program to find the length of the longest substring
// without repeating characters
#include <bits/stdc++.h>
using namespace std;
#define NO_OF_CHARS 256
  
int longestUniqueSubsttr(string str)
{
    int n = str.size();
  
    int res = 0; // result
  
    // last index of all characters is initialized
    // as -1
    vector<int> lastIndex(NO_OF_CHARS, -1);
  
    // Initialize start of current window
    int i = 0;
  
    // Move end of current window
    for (int j = 0; j < n; j++) {
  
        // Find the last index of str[j]
        // Update i (starting index of current window)
        // as maximum of current value of i and last
        // index plus 1
        i = max(i, lastIndex[str[j]] + 1);
  
        // Update result if we get a larger window
        res = max(res, j - i + 1);
  
        // Update last index of j.
        lastIndex[str[j]] = j;
    }
    return res;
}
  
// Driver code
int main()
{
    string str = "geeksforgeeks";
    cout << "The input string is " << str << endl;
    int len = longestUniqueSubsttr(str);
    cout << "The length of the longest non-repeating "
            "character substring is "
         << len;
    return 0;
}

The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7

Complejidad de tiempo: O(n + d) donde n es la longitud de la string de entrada y d es el número de caracteres en el alfabeto de la string de entrada. Por ejemplo, si la string consta de caracteres ingleses en minúsculas, el valor de d es 26. 
Espacio auxiliar: O(d) 

Implementación alternativa: 

#include <bits/stdc++.h>
using namespace std;
  
int longestUniqueSubsttr(string s)
{
      
    // Creating a set to store the last positions 
    // of occurrence
    map<char, int> seen ;
    int maximum_length = 0;
  
    // Starting the initial point of window to index 0
    int start = 0;
  
    for(int end = 0; end < s.length(); end++) 
    {
          
        // Checking if we have already seen the element or
        // not
        if (seen.find(s[end]) != seen.end())
        {
              
            // If we have seen the number, move the start
            // pointer to position after the last occurrence
            start = max(start, seen[s[end]] + 1);
        }
  
        // Updating the last seen value of the character
        seen[s[end]] = end;
        maximum_length = max(maximum_length, 
                             end - start + 1);
    }
    return maximum_length;
}
  
// Driver code
int main()
{
    string s = "geeksforgeeks";
    cout << "The input String is " << s << endl;
    int length = longestUniqueSubsttr(s);
      
    cout<<"The length of the longest non-repeating character "
        <<"substring is "
        << length;
}
  
// This code is contributed by ukasp

The input String is geeksforgeeks
The length of the longest non-repeating character substring is 7

Como ejercicio, intente la versión modificada del problema anterior donde también necesita imprimir la longitud máxima de NRCS (el programa anterior solo imprime la longitud).

Consulte el artículo completo sobre Longitud de la substring más larga sin repetir caracteres para obtener más detalles.