LeetCode 127. Слово Ladder слово Solitaire (C ++ / Java)

тема:

Даны два слова ( beginWord и endWord ), и список слов по словарю, в найти длину кратчайшей последовательности преобразования из beginWord в endWord , например , что:

Только одна буква может быть изменена в то время.
Каждое преобразованное слово должно существовать в списке слов. Обратите внимание , что beginWord это не трансформированное слово.

Замечания:

Возвращает 0, если нет такой последовательности преобразований.
Все слова имеют одинаковую длину.
Все слова содержат только строчные буквы алфавита.
Вы не можете предположить, нет дубликатов в списке слов.
Можно считать beginWord и endWord не пусты и не то же самое.

Пример 1:

Входной сигнал: 
beginWord = "удар", 
endWord = "зубчатые", 
WordList = [ "горячий", "точка", "собака", "много", "журнал", "винтик"] 

Выход: 5 

Пояснение: В качестве одного кратчайшей трансформации это "хит" -> "горячая" -> "точка" -> "собака" -> "винтик", 
возвращает его длиной 5.

Пример 2:

Вход: 
beginWord = «хит» 
endWord = «винтик» 
словник = [ «горячий», «точка», «собака», «много», «Журнал»] 

Выход: 0 

Объяснения: endWord «винтик» не в словнике, следовательно , не возможно преобразование.

Анализ:

С учетом начала и окончания двух слов, и список слов, требует от нас, чтобы использовать список слов, чтобы соединить начало и конец слов, правило требует подключение время, чтобы изменить характер, и в списке, терминации слово в списке также требуется.

Мы можем использовать поиск в ширину, с начала словами, каждый символ в своей очереди, будет меняться от а до г, если измененное слово в списке, он записывается, и слова в коллекции, цель состоит в том, чтобы для предотвращения повторного поиска, например, собака-DOP-собака, это пустая трата времени, когда добавляется новое слово и последнее слово одно и то же число возвращается к шагу, если сохранить заданное слово поиск (очередь) пусто, оказались поиск закончился, и не нашли, вы можете вернуть 0.

Вы можете также использовать двухстороннюю поиск в ширину оптимизирован, в то время как идея заключается в том, чтобы начать поиск с самого начала слова и конца слова, но и путем изменения символов, а в списке слов будут добавлены два централизованного поиска, когда поиск из стороны слова, в поиск слова на другой стороне фокуса, которые появляются средства для понимания. Что же касается порядка поиска, если числа, когда один набор слов меньше, чем другие, это является одним из приоритетов, чтобы начать поиск из небольшого числа множеств.

Порядок действий:

C ++

класс решений {
 общественности :
     INT ladderLength ( строка beginWord, строка endWord, вектор < строка > & словник) {
         // набор <строка> ДИКТ; 
        unordered_set < строка > ДИКТ;
        для ( строка S: WordList) 
            dict.insert (S); 
        если (dict.count (endWord) == 0 )
             возвращает  0 ; 
        Очередь < строка > д; 
        q.push (beginWord); 
        INT л =beginWord.length ();
        INT шаг = 0 ;
        в то время как (! q.empty ()) { 
            шаг ++ ;
            INT Len = q.size ();
            для ( междунар я = 0 ; я <длина; ++ я) {
                 строка слово = q.front (); 
                q.pop (); 
                для ( Int J = 0 , J <L; ++ J) {
                     полукокса CH = слово [J];
                    для ( INT к = '' ; к <= ' г ' ; ++ к) {
                         если (к == ч)
                             продолжать ; 
                        Слово [J] = K;
                        если (слово == endWord)
                             возвращение шаг + 1 ;
                        если (dict.count (слово) == 0 )
                             продолжать ; 
                        q.push (слово); 
                        dict.erase (слово); 
                    }
                    Слово [у]  =ч; 
                } 
            } 
        } 
        Возвращают  0 ; 
    } 
};

// Двунаправленный BFS
 // Продолжительность: 28 мс, быстрее , чем 98,16% от C ++ онлайн представления для Ladder Word. 
класс решений {
 общественности :
     INT ladderLength ( строка beginWord, строка endWord, вектор < строка > & словник) {
         // набор <строка> ДИКТ; 
        unordered_set < строка > ДИКТ;
        для ( строка S: WordList) 
            dict.insert (S); 
        если (dict.count (endWord) == 0 )
             возвращает  0 ;
        unordered_set < строка > q1; 
        unordered_set < строка > q2; 
        q1.insert (beginWord); 
        q2.insert (endWord); 
        INT л = beginWord.length ();
        INT шаг = 0 ;
        в то время как (q1.empty () &&! q2.empty ()) { 
            шаг ++ ;
            если (q1.size ()> q2.size ()) 
                подкачки (q1, q2); 
            unordered_set < строка > д;
            для ( строк слова: q1) {
                для ( Int J = 0 , J <L; ++ J) {
                     полукокса CH = слово [J];
                    для ( INT к = ' ' ; к <= ' г ' ; ++ к) {
                         если (к == ч)
                             продолжать ; 
                        Слово [J] = K;
                        если (q2.count (слово))
                             возвращение шаг + 1если;
                        (dict.count (слово) == 0 )
                             продолжать ; 
                        q.insert (слово); 
                        dict.erase (слово); 
                    } 
                    Слово [J] = ч; 
                } 
            } 
            Подкачки (кв, q1); 
        } 
        Возвращает  0 ; 
    } 
};

Джава

класс решений {
     общественного  ИНТ ladderLength (String beginWord, String endWord, List <String> словник) { 
        Set <String> ДИКТ = новый HashSet <> (словник);
        если (! dict.contains (endWord))
             возвращение 0 ; 
        Queue <String> Q = новый ArrayDeque <> (); 
        q.offer (beginWord); 
        INT л = beginWord.length ();
        INT шаг = 0 ;
        в то время как (! q.isEmpty ()) { 
            шаг ++ ;
            INT Len = q.size ();
            для ( междунар я = 0; я <длина; ++ я) {
                 // строка слово = q.poll (); 
                StringBuilder слово = новый StringBuilder (q.poll ());
                для ( INT J = 0; J <л; ++ , к) {
                     символ ч = word.charAt (J);
                    для ( INT к = 'а'; к < 'г'; ++ к) {
                         если (ч == к)
                             продолжать ; 
                        word.setCharAt (J, (символ ) к); 
                        Строка ш = word.toString ();
                        если (w.equals (endWord))
                             возвращение шаг + 1 ;
                        если (! dict.contains (ш))
                             продолжить ; 
                        q.offer (ш); 
                        dict.remove (ш); 
                    } 
                    Word.setCharAt (к, ч); 
                } 
            } 
        } 
        Возвращают 0 ; 
    } 
}