【leetcode】127. Word Ladder（未通过，3个方法全部超时）

最新推荐文章于 2024-08-06 16:08:10 发布
最新推荐文章于 2024-08-06 16:08:10 发布
阅读量266 收藏
点赞数
分类专栏： # LeetCode 文章标签： 算法 leetcode 动态规划 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxc120389574/article/details/105919762
版权

题目：
在这里插入图片描述

思路：
一开始我是想用直观的方法，，先求出diff数组（各个word之间不同char的数量，如下图所示），然后，从beginWord开始，顺着diff值为1的路径一直到endWord。但是超时了。测试了几个小用例，思路应该是正确的，但可能存在很多重复计算导致运算量剧增导致超时。
在这里插入图片描述

另一种方法，直接通过递归对wordList进行深度优先搜索，然后又超时了。

然后又尝试模仿Dijkstra算法，使用动态规划。然后submit结果是33/43 test cases passed，虽然超时了，但应该是正确的。

暂时没思路了，未完待续…在这里插入图片描述

代码实现：
第一种方法（超时）代码如下：

class Solution {
public:
    int getdiff(string s1, string s2){
        int diff = 0;
        for (int i = 0; i < s1.size(); ++i){
            if (s1[i] != s2[i]){
                ++diff;
            }
        }
        
        return diff;
    }
    
    
    void f(vector<string>& wordList, vector<bool> &isSelected, int i,bool isRowIndex, int cur_len, int &min, const string &endWord, vector<vector<int>>& diff){
        if (wordList[i] == endWord){
            if (cur_len < min){
                min = cur_len;
            }
            return ;
        }
        
        for (int ii = 0; ii < wordList.size(); ++ii){
            if (isSelected[ii] == true){
                continue;
            }
            if (isRowIndex){
                if (diff[i][ii] == 1){
                    isSelected[ii] = true;
                    f(wordList, isSelected, ii, 1-isRowIndex, cur_len+1, min, endWord, diff);
                    isSelected[ii] = false;
                }
            }else{
                if (diff[ii][i] == 1){
                    isSelected[ii] = true;
                    f(wordList, isSelected, ii, 1-isRowIndex, cur_len+1, min, endWord, diff);
                    isSelected[ii] = false;
                }
            }
        }
    }
    
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        
        // 判断endWord是否存在
        bool hasEndWord = false;
        for (int i = 0; i < wordList.size(); ++i){
            if (wordList[i] == endWord){
                hasEndWord = true;
                break;
            }
        }
        if (hasEndWord == false){
            return 0;
        }
        
        wordList.insert(wordList.begin(),beginWord);
        int word_num = wordList.size();
        vector<vector<int>> diff(word_num, vector<int>(word_num, 0));
        vector<bool> isSelected(word_num, false);
        int ans = INT_MAX;
        
        for (int i = 0; i < word_num; ++i){
            for (int j = i+1; j < word_num; ++j){
                diff[i][j] = diff[j][i] = getdiff(wordList[i], wordList[j]);
            }
        }
        
        isSelected[0] = true;
        f(wordList, isSelected, 0, true, 1, ans, endWord, diff);
        
        if (ans == INT_MAX){
            return 0;
        }
        
        return ans;
    }
};

第二种方法（超时）的代码如下：

class Solution {
public:
    
    int getdiff(string s1, string s2){
        int diff = 0;
        for (int i = 0; i < s1.size(); ++i){
            if (s1[i] != s2[i]){
                ++diff;
            }
        }
        
        return diff;
    }
    
    void f(vector<string>& wordList, string &preStr, string &endWord, int len, int &min, vector<bool> isSelected){
        
        for (int i = 0; i < wordList.size(); ++i){
            if (isSelected[i] == true || getdiff(preStr, wordList[i]) != 1){
                continue;
            }
            
            if (wordList[i] == endWord){
                if (len + 1 < min){
                    min = len+1;
                }
                return ;
            }
            
            isSelected[i] = true;
            f(wordList, wordList[i], endWord, len+1, min, isSelected);
            isSelected[i] = false;
        }
        
        return ;
    }
    
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        
        // 判断endWord是否存在
        bool hasEndWord = false;
        for (int i = 0; i < wordList.size(); ++i){
            if (wordList[i] == endWord){
                hasEndWord = true;
                break;
            }
        }
        if (hasEndWord == false){
            return 0;
        }
        
        int ans = INT_MAX;
        vector<bool> isSelected(wordList.size(), false);
        f(wordList, beginWord, endWord, 1, ans, isSelected);
        
        if (ans == INT_MAX){
            return 0;
        }
        
        return ans;
    }
};

第三种方法（动态规划，超时）的代码如下：

class Solution {
public:
    
    int getdiff(string s1, string s2){
        int diff = 0;
        for (int i = 0; i < s1.size(); ++i){
            if (s1[i] != s2[i]){
                ++diff;
            }
        }
        
        return diff;
    }
    
    void f(vector<string>& wordList, string &preStr, string &endWord, int len, int &min, vector<bool> isSelected){
        
        for (int i = 0; i < wordList.size(); ++i){
            if (isSelected[i] == true || getdiff(preStr, wordList[i]) != 1){
                continue;
            }
            
            if (wordList[i] == endWord){
                if (len + 1 < min){
                    min = len+1;
                }
                return ;
            }
            
            isSelected[i] = true;
            f(wordList, wordList[i], endWord, len+1, min, isSelected);
            isSelected[i] = false;
        }
        
        return ;
    }
    
  
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        
        // 判断endWord是否存在
        bool hasEndWord = false;
        int end_i;
        for (int i = 0; i < wordList.size(); ++i){
            if (wordList[i] == endWord){
                hasEndWord = true;
                end_i = i;
                break;
            }
        }
        if (hasEndWord == false){
            return 0;
        }
        
        /
        
        wordList.insert(wordList.begin(), beginWord);
        ++end_i;
        int word_nums = wordList.size();
        vector<bool> isSelected(word_nums, false);
        vector<int> dp(word_nums, INT_MAX);
        isSelected[0] = true;
        dp[0] = 1;
        
        int i = 0;
        while (true){
            int min = INT_MAX;
            int min_i = -1;
            for (int j = 0; j < word_nums; ++j){
                if (i == j || isSelected[j] == true){
                    continue ;
                }
                
                if (getdiff(wordList[i], wordList[j]) != 1){
                    if (dp[j] < min){
                        min = dp[j];
                        min_i = j;
                    }
                    continue;
                }
                
                // 更新dp
                if (dp[i] + 1 < dp[j]){
                    dp[j] = dp[i] + 1;
                }
                
                if (dp[j] < min){
                    min = dp[j];
                    min_i = j;
                }
            }
            
            if (min == INT_MAX || min_i == -1){
                break;
            }
            
            // 选出最小i
            isSelected[min_i] = true;
            i = min_i;
        }
        
        if (dp[end_i] == INT_MAX){
            return 0;
        }
        
        return dp[end_i];
    }
};

discuss:

// DFS深度优先遍历（不知为何，就是超时）
class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> dict(wordList.begin(), wordList.end());
        queue<string> todo;
        todo.push(beginWord);
        int ladder = 1; // 我们要的答案
        
        while (!todo.empty()){ // 一层一层地遍历
            int n = todo.size(); // 记录当前一层的word个数，因为后面会逐个再添加新word
            for (int i = 0; i < n; ++i){ // 遍历一层
                string word = todo.front(); 
                todo.pop();
                if (word == endWord){
                    return ladder;
                }
                dict.erase(word);
                
                for (int j = 0; j < word.size(); ++j){ // 对word中每个char都变换成26个字母试下
                    char c = word[j]; // 保护现场
                    for (int k = 0; k < 26; ++k){ // 每个char的26种情况
                        word[j] = 'a' + k;
                        if (dict.find(word) != dict.end()){ // 如果dict存在ta
                            todo.push(word);
                        }
                    }
                    word[j] = c; // 恢复现场
                }
            }
            
            ++ladder;
        }
        
        return 0;
    }
};
拓荒探险者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode126—Word Ladder II
上善若水
05-26 4718
LeetCode126—Word Ladder II
Leetcode算法学习日志-127 Word Ladder
Zarlove的博客
10-26 501
Leetoce 127 Word Ladder 题目原文 Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that: On
leetcode超时？
Leiroy的博客
04-20 6721
在leetcode上做算法题目的时候为什么会超时？计算机究竟1s可以执行多少次操作？ 文章目录在leetcode上做算法题目的时候为什么会超时？计算机究竟1s可以执行多少次操作？超时是怎么回事从硬件配置看计算机的性能测试实验完整测试代码总结 超时是怎么回事 大家在leetcode上练习算法的时候应该都遇到过一种错误是“超时”。也就是说程序运行的时间超过了规定的时间，一般OJ（online judge）的超时时间就是1s，也就是用例数据输入后最多要1s内得到结果，下文为了方便讲解，暂定超时时间就是1s
python | LeetCode笔记 | 超过时间限制的一些解决策略
南瓜派三蔬
03-31 4441
以空间换时间
浅谈 刷算法题时遇到运行超时异常 的解决办法
m0_63191002的博客
04-20 1153
最近在牛客、leetcode 刷算法题时发现一个奇怪的问题，明明解题思路、所用算法与题解一致，并且在本地IDE运行是通过的，但是在牛客、leetcode 却没办法AC，出现一个叫做 运行超时 的异常。通过查阅资料、反复验证之后，找出了一个有效的解决办法。
Leetcode中你的代码执行之后显示超出时间限制
weixin_44980842的博客
10-01 4752
Leetcode中但凡是你的代码执行之后显示超出时间限制 比如： 那么必定是你写的代码不够完善甚至是还存在错误！
Leetcode:超出时间限制
xiaodidididi521的博客
06-28 8455
Leetcode:超出时间限制
用C语言实现Leetcode题目.zip
03-16
用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现...
126.Word Ladder II 词语阶梯二【LeetCode单题讲解系列】
08-31
126.Word_Ladder_II_词语阶梯二【LeetCode单题讲解系列】
hackhu2019#LeetCode#LeetCode31. 下一个排列1
07-25
来源：力扣（LeetCode） 链接：：过滤特殊情况，
catwang01#Algorithm#Leetcode 91. 解码方法1
07-25
Leetcode 91. 解码方法问题描述算法解法1解法1:def numDecodings(self, s: str) -> int:if 10 <= int
leetcode296-.leetcode:.leetcode
06-30
leetcode 296 .leetcode leetcode 刷题专用 日期 解决的题目 通过的提交 通过提交率 全站排名 2021/05/07 234/2074 381/601 63.39% 43409 2021/05/06 233/2073 380/600 63.33% 43607 2021/04/27 232/2063 379/599 63...
【LeetCode-超时优化】
qq_20386411的博客
01-28 182
【代码】【LeetCode-超时优化】
什么？导致我leetcode超时的不是算法是并发？
clownote
02-16 1305
我写 leetcode 居然超时了！原因居然不是因为蒟蒻如我只会低效算法，而是手闲使用了并发！这是一场并发引起的血案！
O(n) 的算法居然超时了，此时的 n 究竟是多大？
程序员吴师兄的博客
01-24 1842
一些同学可能对计算机运行的速度还没有概念，就是感觉计算机运行速度应该会很快，那么在leetcode上做算法题目的时候为什么会超时呢？计算机究竟1s可以执行多少次操作呢？接下来探讨一下这个...
leetcode 219超时方案
看清这个世界
12-20 404
class Solution: def containsNearbyDuplicate(self, nums, k): if nums is None or len(nums) == 0 or k == 0: return False num_list = [] for item in nums: ...
leetcode 刷题总结
lands92的专栏
10-28 502
1 Two Sum    求数组中等于target的两个数的下标 数组 O(n*n) O(n)，用HashMap存已遍历部分 2 Add Two Numbers 两数相加，数用链表表示，低位在头，高位在尾 链表 当l1、l2不为空或tmp不为0时，依次相加，得到tmp，tmp%10即当前位，tmp/10为进位 3 Longest Substring With
LeetCode[127. Word Ladder] 题解 难度[medium]
cs_linyf的博客
09-06 2946
C++语言，使用BFS解决word ladder问题
代码随想录算法训练营第七天（一）| 454.四数相加II 383. 赎金信
最新发布
xiaowutongxue666的博客
08-06 512
给你四个整数数组nums1nums2nums3和nums4，数组长度都是n，请你计算有多少个元组2两个元组如下：1。
leetcode 2031. 1 比 0 多的子数组个数
12-16
leetcode 2031题是一道有关于子数组的问题。问题的要求是求出给定数组中，1的个数比0多的子数组的个数。我们可以通过遍历数组的每个元素，然后计算以该元素结尾的子数组中，1的个数比0多的个数。 我们可以定义一个变量count，用来记录当前遍历到的元素前面的子数组中，1的个数比0多的个数。初始化count为0。然后开始遍历数组。 对于当前遍历的元素，如果是1，则count加1。如果是0，则count减1。然后判断count的值。 如果count大于0，则说明当前元素前面的子数组中，1的个数比0多，我们将结果加上count。 如果count等于0，则说明当前元素前面的子数组中，1的个数和0的个数相等，我们将结果加上1，表示当前子数组中加上这个元素后，1的个数比0多。 最后，我们将结果返回，即为所求的答案。 下面是具体的代码实现： ```python def countSubarrays(nums): count = 0 result = 0 for num in nums: if num == 1: count += 1 else: count -= 1 if count > 0: result += count elif count == 0: result += 1 return result ``` 以上就是针对leetcode 2031题的问题，求解1比0多的子数组个数的详细解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值