126. Word Ladder II \ 507. Perfect Number

最新推荐文章于 2025-08-12 19:58:42 发布
最新推荐文章于 2025-08-12 19:58:42 发布
阅读量580 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Leetcode 文章标签： leetcode 507 word ladder leetcode-java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/c602273091/article/details/68061346
本文解析了 Word Ladder II 和 Perfect Number 两道算法题的解题思路与代码实现。Word Ladder II 需要找出从开始单词到目标单词的所有最短转换路径；而 Perfect Number 则需要判断一个数是否为完美数。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

26. Word Ladder II

题目描述

Given two words (beginWord and endWord), and a dictionary’s word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:

  • Only one letter can be changed at a time
  • Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

For example,

Given:

beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]
Return
  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

Note:

  1. Return an empty list if there is no such transformation sequence.
  2. All words have the same length.
  3. All words contain only lowercase alphabetic characters.
  4. You may assume no duplicates in the word list.
  5. You may assume beginWord and endWord are non-empty and are not the same.

这道题目可以使用回溯、DFS或者BFS来计算。

代码实现

法一：回溯

这个版本的回溯是会超时的，做过一些改进依然在某些case超时。

class Solution {
public:
    int cur_shotest_len = INT_MAX;

    __inline int isClose(const string a, const string b, int len) {
        int cnt = 0;
        while(len--) 
            if(a[len] != b[len]) cnt++;
        return cnt;
    }

    void backTracking(vector<vector<string>>& res, vector<string>& cur, string beginWord, string endWord, vector<string> wordList, int size, int len, vector<int>& rec, int stt) {
        if(isClose(beginWord, endWord, len) == 0) {
            if(cur_shotest_len > cur.size()) 
                while(!res.empty()) res.pop_back();
            if(cur_shotest_len < cur.size()) return;
            cur_shotest_len = cur.size();
            res.push_back(cur);
            return;
        }

        for(int i = 0; i < size; i++) {
            if(rec[i] == 0 && cur.size() + 1 <= cur_shotest_len && isClose(beginWord, wordList[i], len) == 1) {
                rec[i] = 1;
                cur.push_back(wordList[i]);
                backTracking(res, cur, wordList[i], endWord, wordList, size, len, rec, i+1);
                cur.pop_back();
                rec[i] = 0;
            }
        }
    }

    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        int size = wordList.size();
        vector<vector<string>> res;
        if(!size) return res;

        vector<string> cur;
        vector<int> rec(size, 0);
        int word_len = beginWord.size();
        cur.push_back(beginWord);
        backTracking(res, cur, beginWord, endWord, wordList, size, word_len, rec, 0);

        return res;
    }
};

对它改进的一个版本，还有一个case无法通过：

class Solution {
public:
    int cur_shotest_len = INT_MAX;
    vector<vector<string>> res;
    vector<string> cur;
    vector<vector<int>> dis;

    __inline int isClose(const string a, const string b, int len) {
        int cnt = 0;
        while(len--) 
            if(a[len] != b[len]) cnt++;
        return cnt;
    }

    void backTracking(string beginWord, string endWord, vector<string> wordList, int size, int len, int lst) {

        if(dis[lst+1][size+1] == 0) {
            if(cur_shotest_len > cur.size()) 
                while(!res.empty()) res.pop_back();
            if(cur_shotest_len < cur.size()) return;
            cur_shotest_len = cur.size();
            res.push_back(cur);
            return;
        }

        for(int i = 0; i < size; i++) {
            if(cur.size() + 1 <= cur_shotest_len) {
                if(dis[lst+1][i+1] == 1) {
                    cur.push_back(wordList[i]);
                    backTracking(wordList[i], endWord, wordList, size, len, i);
                    cur.pop_back();
                }
            }
        }
    }

    void countDis(int size, int len, string beginWord, string endWord, vector<string> wordList) {
        dis[0][size+1] = isClose( beginWord, endWord, len);
        dis[size+1][0] = dis[0][size+1];

        for(int col = 0; col < size; col++) { 
            dis[0][col+1] = isClose( beginWord, wordList[col], len);
            dis[col+1][0] = dis[0][col+1];
        }    
        for(int row = 0; row < size; row++) {
            dis[row+1][size+1] = isClose( endWord, wordList[row], len);
            dis[size+1][row+1] = dis[row+1][size+1];
        }
        for(int row = 0; row < size; row++) 
            for(int col = row+1; col < size; col++) {
                dis[row+1][col+1] = isClose( wordList[col], wordList[row], len);
                dis[col+1][row+1] = dis[row+1][col+1];
            }    
    }

    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        int size = wordList.size();

        if(!size) return res;

        int word_len = beginWord.size();

        dis.resize(size+2);
        for(int i = 0; i < size+2; i++) dis[i].resize(size+2, 0);

        cur.push_back(beginWord);
        cur_shotest_len = size + 2;

        countDis(size, word_len, beginWord, endWord, wordList);

        backTracking(beginWord, endWord, wordList, size, word_len, -1);

        return res;
    }
};

上面的优化只是把距离提前计算好，然后调用。但是这个算法的瓶颈在于查找距离为一的过程。

所以需要在这个部分进行优化。

class Solution {
public:
    int cur_shotest_len = INT_MAX;
    vector<vector<string>> res;
    vector<string> cur;
    vector<vector<int>> dis;
    vector<bool> rec; // with zero

    __inline int isClose(const string a, const string b, int len) {
        int cnt = 0;
        while(len--)  if(a[len] != b[len]) cnt++;
        return cnt;
    }

    void backTracking(string beginWord, string endWord, vector<string>& wordList, int size, int len, int lst) {
        int range = dis[lst+1].size();
        for(int i = 0; i < range; i++) {
            if(cur.size() + 1 <= cur_shotest_len) {
                cur.push_back(wordList[dis[lst+1][i]-1]);
                if(rec[dis[lst+1][i]]) {
                    if(cur_shotest_len > cur.size()) 
                        while(!res.empty()) res.pop_back();
                    if(cur_shotest_len < cur.size()) { cur.pop_back(); return;}
                    cur_shotest_len = cur.size();
                    res.push_back(cur);
                    cur.pop_back();
                    return;
                }                    
                else 
                    backTracking(wordList[dis[lst+1][i] - 1], endWord, wordList, size, len, dis[lst+1][i]-1);
                cur.pop_back();
            }
        }
    }

    void countDis(int size, int len, string beginWord, string endWord, vector<string> wordList) {
        int tmp = isClose( beginWord, endWord, len);
        if(!tmp) rec[0] = true;

        for(int col = 0; col < size; col++) { 
            tmp = isClose( beginWord, wordList[col], len);
            if(tmp == 1) 
                dis[0].push_back(col+1);
        }    
        for(int row = 0; row < size; row++) {
            tmp = isClose( endWord, wordList[row], len);
            if(!tmp)  rec[row+1] = true;
        }
        for(int row = 0; row < size; row++) 
            for(int col = row+1; col < size; col++) {
                tmp = isClose( wordList[col], wordList[row], len);
                if(tmp == 1) {
                    dis[col+1].push_back(row+1);
                    dis[row+1].push_back(col+1);
                }    
            }    
    }

    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        int size = wordList.size();

        if(!size) return res;

        int word_len = beginWord.size();

        dis.resize(size + 1);

        rec.resize(size + 1, false);

        cur.push_back(beginWord);
        cur_shotest_len = size + 2;

        countDis(size, word_len, beginWord, endWord, wordList);

        backTracking(beginWord, endWord, wordList, size, word_len, -1);

        return res;
    }
};

AC的代码参考了：https://discuss.leetcode.com/topic/40902/clean-but-the-best-submission-68ms-in-c-well-commented/2

现在还在优化中。。。

507. Perfect Number

题目描述

We define the Perfect Number is a positive integer that is equal to the sum of all its positive divisors except itself.

Now, given an integer n, write a function that returns true when it is a perfect number and false when it is not.

Example:

Input: 28
Output: True
Explanation: 28 = 1 + 2 + 4 + 7 + 14

Note: The input number n will not exceed 100,000,000. (1e8)

代码实现

class Solution {
public:
    bool checkPerfectNumber(int num) {
        int half = ceil(sqrt(num)), res = 1;
        for(int i = 2; i < half; i++) if(num%i == 0) {
            res += i + (num/i);
        }
        res += ceil(sqrt(num)) == floor(sqrt(num))? half:0;
        return res == num;
    }
};
leetcode:126. 单词接龙 II
uncle_ll的博客
07-31 607
我们可以从起点词开始DFS，也可以从终点词开始DFS，我选择后者，遇到起点词，就找到一条满足条件的路径，推入结果数组，然后回溯，直到找出所有最短路径。比如hit->hot->hit，又变回来，即重复访问节点，徒增路径长度。让单词的每个字母逐个改动，生成25个新单词。选出存在于wordList的，就是“邻居单词”。的最短转换序列，如果不存在这样的转换序列，返回一个空列表。每个单词节点有自己的层，它的“邻居”是它可变成的单词，属于下一层。这很像BFS考察当前层出列的节点，带出下一层的节点入列。...
126.Word Ladder II 词语阶梯二【LeetCode单题讲解系列】
08-31
126.Word_Ladder_II_词语阶梯二【LeetCode单题讲解系列】
Leetcode 126. Word Ladder II Python BFS 实现
chelseajcole的专栏
06-29 1611
题目：126.Word Ladder II https://leetcode.com/problems/word-ladder-ii/ Given two words (beginWordandendWord), and a dictionary's word list, find all shortest transformation sequence(s) frombeginWor...
BluePrism.WordLadder
03-21
《C#实现BluePrism.WordLadder：探索图算法在解决文字阶梯问题中的应用》 在信息技术领域，算法是解决问题的关键工具，而C#作为一款强大的编程语言，常常被用来实现各种复杂算法。本篇文章将深入探讨一个名为"Blue...
js-leetcode题解之126-word-ladder-ii.js
11-04
在leetcode的编程挑战中，126号问题“Word Ladder II”是一个较为复杂的单词转换游戏。问题要求编写一个算法找到所有单词转换序列的最短路径，这些单词序列由给定单词列表中的单词组成，每个单词仅比前一个单词的...
《Leetcode》-面试题-hot100-回溯
乐于创作，乐于分享，志于创作高价值博文
08-11 974
本文整理了8道回溯算法相关的中等难度LeetCode题目，包括全排列、子集、电话号码字母组合、组合总和、括号生成、单词搜索、分割回文串和N皇后问题。每道题目都提供了示例、解题思路和Python代码实现，其中全排列使用回溯法标记已用元素，子集问题通过控制起始索引避免重复，组合总和允许元素重复使用，N皇后采用集合记录攻击范围。这些题目展示了回溯算法在组合、排列、搜索等场景的典型应用模式：递归探索所有可能解，通过剪枝优化效率。
(LeetCode 面试经典 150 题) 226. 翻转二叉树 (深度优先搜索dfs )
记录一些刷过的题并分享学习心得
08-12 332
【代码】(LeetCode 面试经典 150 题) 226. 翻转二叉树 (深度优先搜索dfs )
leetcode-hot-100 (图论）
weixin_73557167的博客
08-11 634
图论
leetcode 11. 盛最多水的容器 -java
weixin_41624462的博客
08-09 196
这是因为木桶底部长度在指针在两头时是最大的，指针内移x轴长度一定会减小，这时如果想要获取更大面积，需要获取两个height里较小的那个，让他增大，面积才会增大，所以较小的元素的指针向内循环，寻找更大的值，一直到左右两个指针重合，结束循环。改进：接水 - 接多少水取决于短版的长度，所以可以使用双指针法，每次比较，保留较大元素的指针不动，较小元素的指针平移寻找更大的指针，直到两个指针相遇。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。说明：你不能倾斜容器。
leetcode2461：长度为K子数组中的最大和（定长滑动窗口+哈希去重）
lyh2004_08的博客
08-10 299
这道LeetCode题目要求找到长度为k的子数组，其所有元素必须唯一，且和最大。核心解法结合滑动窗口和哈希表：滑动窗口维护固定长度的子数组和，哈希表确保元素唯一性。当哈希表大小等于k时，说明当前窗口满足条件，更新最大和即可。时间复杂度O(N)，空间复杂度O(k)。关键点在于正确维护哈希表的元素计数，并在和超过整数范围时使用long类型存储。该解法高效地解决了固定长度窗口与元素唯一性的双重约束问题。
Leetcode 3645. Maximum Total from Optimal Activation Order
codename_cys的博客
08-10 446
Leetcode 3645. Maximum Total from Optimal Activation Order
分治-快排-215.数组中的第k个最大元素-力扣(LeetCode)
black_bear_white的博客
08-08 307
leetcode 231. 2 的幂 简单
2401_88085478的博客
08-09 230
请你判断该整数是否是 2 的幂次方。你能够不使用循环/递归解决此问题吗？
LeetCode每日一题，2025-8-10
m0_58809631的博客
08-10 151
第一个存储了排序后的 2 的幂的字符串表示。第二个存储了字符数组对象的引用字符串表示。这两个静态代码块不一样。
day48 力扣739. 每日温度 力扣496.下一个更大元素 I 力扣503.下一个更大元素II
2401_87983916的博客
08-11 700
因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。我们主要是对nums2分析，如果遇到nums2[st.top()]<nums2[i]时，我们要多分析一段是否这个nums2[i]是否在nums1[i]里。是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。天，下一个更高温度出现在几天后。- 2 ，用加粗斜体标识，nums2 = [1,3,4,
力扣前200题字符串总结
qq_44072579的博客
08-09 370
并且按照从大到小的顺序依次枚举。用哈希表存循环小数的位置。两个数组遍历，考虑进位。
力扣面试150题--阶乘后的零，Pow（x,n)直线上最多的点
qq_46634167的博客
08-11 464
对于乘法出现低位0，只有可能由以下可能基于以上这两点，我们可以找到一个共同特征，但是这里又出现一个问题：254可以得到2个0，252只能得到一个0，我们需要统一，不然还是无法统计，但是我们直到25可以表示为5*5，对这样我们就只统计5的个数。
力扣-394.字符串解码
最新发布
weixin_46878941的博客
08-12 172
小结：采用双栈法，一个栈存数字即重复次数，另一个栈存储的是需要与内层结果拼接的前缀字符串，而。保存的是当前最内层正在处理的字符串。
Leetcode-19. 删除链表的倒数第 N 个结点
JXL1860的博客
08-09 158
第二次遍历，将要删除的节点跳过，即让前驱节点指向要删除节点的下一个节点。第一次遍历链表，得到链表长度。来统一处理删除头结点的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值