LeetBoss

最新推荐文章于 2020-12-16 10:05:25 发布

原创最新推荐文章于 2020-12-16 10:05:25 发布 · 677 阅读

0 ·

CC 4.0 BY-SA版权

这篇博客里记录俩类题目

1. AC 15％一下

2. 经典DP

BOSS 1 : Word Ladder

Given two words (beginWord and endWord), and a dictionary, find the length of shortest transformation sequence from beginWord to endWord, such that:

Only one letter can be changed at a time
Each intermediate word must exist in the dictionary

For example,

Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

先看一段吉祥三宝的分析，个人认为是这个题目最好大理解方式。

Analysis:

This problem can be abstracted as a tree level-order traversal problem. In binary tree level-order traversal, we find the next level node via the left and right pointer, but in this problem, we search the string in dictionary, if the their distance is 1, we add it to queue for next level traversal, and delete it from queue.

To record the distance, we also maintain another queue, in which stores the current string’s distance to the root string.

When we delete a string from dict, it is possible that the deleted string will be used in another path. To illustrate this problem, see:

(1) When dogs are in the same level:

        hot
        / 
      hog  dot
       |    |
      dog  dog
       |    |
      dig  dig

Where start is “hot”, and end is “dig”, when we visit hot->hog->dog, dog is deleted, but dog is also needed in hot->dot->dog. When dog are in the same level, it is fine since the distance is the same.

(2) When dog is reused in deeper level, see:

        hot
        / 
      hog  dot
       |    |
      dog  dot
       |    |
      dig  dag
            |
           dog
            |
           dig

It is still fine. Because the minimum distance is already found when dog needs to be reused.

The search of possible 1-distance strings takes O(N*L) time, where N is the number of alphabetical letters, and L is the length of a string in dictionary

"分析来自

---吉祥三宝的博客

代码相对清晰，简洁。注意return 的时候不需要加一，加一是在把该item存入queue的时候做的，所以在item入queue时候，对应的存距离的queue2里存的就是它最终的距离。

然后这里记录的是每个item 的距离，不需要level这个概念了。也就不需要一层一层处理，直接一个一个来。

    public int ladderLength(String start, String end, Set
  
    dict) {
        //Just another version of lvl order traversal of BFS
        LinkedList
   
     q1 = new LinkedList
    
     ();
        LinkedList
     
       q2 = new LinkedList
      
       ();
        dict.add(end);
        q1.add(start);
        q2.add(1);//q2 record the distance(no. of items) from start to the corresponding str in q1
        
        while(!q1.isEmpty()){
            String item = q1.poll();
            int minDist = q2.poll();
            
            if(item.equals(end))
                return minDist;
            //add all possible edges of current item to expand nxt lvl
            //after the last item of current lvl is processed, we have a complete list of items of nxt lvl in our queue then
            //we don't need to differentiate lvl here, just go till the end, because we keep distance for each item but for lvl 
            for(int i=0; i

BOSS2 : Word Break

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

这个题做了多少遍了，每一遍对这个DP都有新的认识。。。

这个题我在我DP之章里分析写的很细了，这里不重复里。

这个题recursion和dp俩个方法很绕，正好反着，但是如果真正理解了，也不会混淆。

这个题recursion就简单很多，包括Word Break2，都是很经典的Back Tracking的题目。

 public boolean wordBreak(String s, Set
  
    wordDict) {
        boolean[][] dp = new boolean[s.length()][s.length()];

        for(int i=s.length()-1;i>=0;i--){
            for(int j=i; j

同时我把 palindrome partition || 的DP做法也放在这里，这俩道题神似。