la manipulación de datos de cadena con mapas de entrada de datos muy grande

Didula Egodage:

He resuelto dos cadenas problema en HackerRank

Aquí está el problema.

Dados dos cadenas, determinar si comparten una subcadena común. Una subcadena puede ser tan pequeño como un carácter.

Por ejemplo, las palabras "un", "y", "arte" compartir la subcadena común. Las palabras "ser" y "gato" no comparten una subcadena.

Función descriptiva

Completar los twoStrings de función en el editor a continuación. Se debe devolver una cadena, ya sea SÍ o NO en función de si las cadenas comparten una subcadena común.

twoStrings tiene el parámetro siguiente (s):

S1, S2: dos cuerdas a analizar.

Formato de salida

Para cada par de cuerdas, volver SÍ o NO.

Sin embargo, cuando las cadenas muy largas son sometidos, mi código no se ejecuta dentro del límite de tiempo. Cualquier sugerencia para mejorar la eficiencia? Creo que puedo mejorar la subcadena encontrar con el uso de la API de corriente. Pero no estoy seguro de cómo usarlo en este contexto. Podría alguien ayudarme a entender esto mejor?

public static void main(String[] args) {
    String s1 = "hi";
    String s2 = "world";
    checkSubStrings(s1, s2);
}

static void checkSubStrings(String s1, String s2) {
    Map<String, Long> s1Map = new HashMap<>();
    Map<String, Long> s2Map = new HashMap<>();
    findAllSubStrings(s1, s1Map);
    findAllSubStrings(s2, s2Map);
    boolean isContain = s2Map.entrySet().stream().anyMatch(i -> s1Map.containsKey(i.getKey()) );
    if (isContain) {
        System.out.println("YES");
    } else {
        System.out.println("NO");
    }
}

static void findAllSubStrings(String s, Map<String, Long> map) {
    for (int i = 0; i < s.length(); i++) {
        String subString = s.substring(i);
        for (int j = subString.length(); j > 0; j--) {
            String subSubString = subString.substring(0, j);
            if (map.containsKey(subSubString)) {
                map.put(subSubString, map.get(subSubString) + 1);
            } else {
                if (!subSubString.equals(""))
                    map.put(subSubString, 1L);
            }
        }
    }
}

Actualizar

Acabo de resolver la cuestión mediante HashSets.

Optimicé el código usando Set. Ahora se ejecuta con grandes cadenas.

static String twoStrings(String s1, String s2) {
    String result = null;
    Set<Character> s1Set = new HashSet<>();
    Set<Character> s2Set = new HashSet<>();
    for(char a : s1.toCharArray()){
        s1Set.add(a);
    }
    for(char a : s2.toCharArray()){
        s2Set.add(a);
    }
    boolean isContain = s2Set.stream().anyMatch(s1Set::contains);

    if(isContain){
        result = "YES";
    } else {
        result = "NO";
    }
    return result;
}

Andy Turner:

Si 2 cadenas comparten una N (> = 2) caracteres encadenados, también comparten un carácter subcadena N-1 (porque se puede cortar un personaje fuera de la final de la subcadena común, y esto todavía se pueden encontrar en ambas cadenas). La extensión de este argumento, también comparten una subcadena de 1 carácter.

Por lo tanto, todo lo que necesita para comprobar son subseries de un solo carácter.

Llene sus mapas con subseries de un solo carácter en su lugar, y se evitará la creación (y comprobar) subseries innecesarios. (Y sólo tiene que utilizar un conjunto en lugar de un mapa, nunca utiliza las cuentas).

// Yields a `Set<Integer>`, which can be used directly to check.
return s.codePoints().boxed().collect(Collectors.toSet());