leetcode word-lader

最新推荐文章于 2024-08-30 22:58:17 发布
原创 最新推荐文章于 2024-08-30 22:58:17 发布 · 114 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了从一个单词到另一个单词的最短转换序列问题，利用字典作为辅助，并详细介绍了使用深度优先搜索（DFS）和广度优先搜索（BFS）两种算法解决该问题的方法。

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, 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 length5.
Note:
Return 0 if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.

//DFS 空间过大
class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) 
    {
        if (start == end)
            return 1;
        int Res = INT_MAX;
        vector<bool> bvec(dict.size(), false);
        vector< vector<string> > res;
        vector<string> tmp;
        tmp.push_back(start);
        Find(start, end, dict, bvec, res, tmp);
        for(int i=0;i<res.size();i++)
        {
            Res = Res < res[i].size()?Res:res[i].size();
            //for (int j=0;j<res[i].size();j++)
                //cout<<res[i][j]<< " ";
            //cout<<endl;
        }
        return Res;
    }
    void Find(string cur, string end, unordered_set<string> &dict, vector<bool> &bvec, vector< vector<string> > &res, vector<string> &tmp)
    {
        if (IfOneDiff(cur,end))
        {
            tmp.push_back(end);
            res.push_back(tmp);
            tmp.pop_back();
        }
        unordered_set<string> ::iterator  iter = dict.begin();
        for (int i=0;i<dict.size();i++,iter++)
        {
            if (!bvec[i] && IfOneDiff(cur, *iter))
            {
                tmp.push_back(*iter);
                bvec[i] = true;
                Find(*iter, end, dict, bvec, res, tmp);
                bvec[i] = false;
                tmp.pop_back();
            }
        }
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

 
//DFS 去掉额外空间  时间太久
class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) 
    {
        if (start == end)
            return 1;
        int res = INT_MAX;
        vector<bool> bvec(dict.size(), false);
        vector<string> tmp;
        tmp.push_back(start);
        Find(start, end, dict, bvec, res, tmp);
        return res;
    }
    void Find(string cur, string end, unordered_set<string> &dict, vector<bool> &bvec, int &res, vector<string> &tmp)
    {
        if (IfOneDiff(cur,end))
        {
            tmp.push_back(end);
            res = res<tmp.size()?res:tmp.size();
            tmp.pop_back();
            return;//发现提前退出，不需要继续查找
        }
        unordered_set<string> ::iterator  iter = dict.begin();
        for (int i=0;i<dict.size();i++,iter++)
        {
            if (!bvec[i] && IfOneDiff(cur, *iter))
            {
                tmp.push_back(*iter);
                bvec[i] = true;
                Find(*iter, end, dict, bvec, res, tmp);
                bvec[i] = false;
                tmp.pop_back();
            }
        }
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

//此题目适合用BFS，因为BFS能很快获得最小次数而提前终止，DFS则不能
//BFS

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) 
    {
        queue<pair<string, int> > que;
        que.push(make_pair(start, 1));
        dict.insert(end);
        unordered_set<string> ::iterator  it = dict.find(start);//去掉start   不去也行
        if (it != dict.end())
            dict.erase(it);
        while(!que.empty())
        {
            pair<string, int> tmp =  que.front();
            int size = dict.size();
            que.pop();
            unordered_set<string> ::iterator  iter = dict.begin();
            if (tmp.first == end) 
                return tmp.second;
            for (int i=0;i<size;i++)
            {
                if (IfOneDiff(tmp.first, *iter))
                {
                    que.push(make_pair(*iter, tmp.second+1));
                    dict.erase(iter++);//这里一定要去掉   不然时间太久不通过
                }
               else
                    iter++;
            }
        }
        return 0;
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

//BFS 修改

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) 
    {
        queue<pair<string, int> > que;
        que.push(make_pair(start, 1));
        dict.insert(end);
        unordered_set<string> ::iterator  it = dict.find(start);//去掉start   不去也行
        if (it != dict.end())
            dict.erase(it);
        while(!que.empty())
        {
            pair<string, int> tmp =  que.front();
            int size = dict.size();
            que.pop();
            unordered_set<string> ::iterator  iter = dict.begin();
            if (tmp.first == end) 
                return tmp.second;
            while (dict.end() != iter)
            {
                if (IfOneDiff(tmp.first, *iter))
                {
                    que.push(make_pair(*iter, tmp.second+1));
                    //前面一层遍历过的，后面不需要再重复，重复的话肯定不是最小
                    //会改变传入的dict，或者也可以用bool标记每个是否被遍历过
                    dict.erase(iter++);//这里一定要去掉   不然时间太久不通过
                }
               else
                    iter++;
            }
        }
        return 0;
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

测试

#include<vector>
#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<limits.h>
using namespace std;
class Solution1 {
public:
    int ladderLength(string start, string end, set<string> &dict) 
    {
        if (start == end)
            return 1;
        int Res = INT_MAX;
        vector<bool> bvec(dict.size(), false);
        vector< vector<string> > res;
        vector<string> tmp;
        tmp.push_back(start);
        Find(start, end, dict, bvec, res, tmp);
        for(int i=0;i<res.size();i++)
        {
            Res = Res < res[i].size()?Res:res[i].size();
            //for (int j=0;j<res[i].size();j++)
                //cout<<res[i][j]<< " ";
            //cout<<endl;
        }
        return Res;
    }
    void Find(string cur, string end, set<string> &dict, vector<bool> &bvec, vector< vector<string> > &res, vector<string> &tmp)
    {
        if (IfOneDiff(cur,end))
        {
            tmp.push_back(end);
            res.push_back(tmp);
            tmp.pop_back();
        }
        set<string> ::iterator  iter = dict.begin();
        for (int i=0;i<dict.size();i++,iter++)
        {
            if (!bvec[i] && IfOneDiff(cur, *iter))
            {
                tmp.push_back(*iter);
                bvec[i] = true;
                Find(*iter, end, dict, bvec, res, tmp);
                bvec[i] = false;
                tmp.pop_back();
            }
        }
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

class Solution2 {
public:
    int ladderLength(string start, string end, set<string> &dict) 
    {
        if (start == end)
            return 1;
        int res = INT_MAX;
        vector<bool> bvec(dict.size(), false);
        vector<string> tmp;
        tmp.push_back(start);
        Find(start, end, dict, bvec, res, tmp);
        return res;
    }
    void Find(string cur, string end, set<string> &dict, vector<bool> &bvec, int &res, vector<string> &tmp)
    {
        if (IfOneDiff(cur,end))
        {
            tmp.push_back(end);
            res = res<tmp.size()?res:tmp.size();
            tmp.pop_back();
            return;
        }
        set<string> ::iterator  iter = dict.begin();
        for (int i=0;i<dict.size();i++,iter++)
        {
            if (!bvec[i] && IfOneDiff(cur, *iter))
            {
                tmp.push_back(*iter);
                bvec[i] = true;
                Find(*iter, end, dict, bvec, res, tmp);
                bvec[i] = false;
                tmp.pop_back();
            }
        }
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

class Solution {
public:
    int ladderLength(string start, string end, set<string> &dict) 
    {
        queue<pair<string, int> > que;
        que.push(make_pair(start, 1));
        dict.insert(end);
        set<string> ::iterator  it = dict.find(start);
        if (it != dict.end())
            dict.erase(it);
        while(!que.empty())
        {
            pair<string, int> tmp =  que.front();
            int size = dict.size();
            que.pop();
            set<string> ::iterator  iter = dict.begin();
            if (tmp.first == end) 
                return tmp.second;
            for (int i=0;i<size;i++)
            {
                if (IfOneDiff(tmp.first, *iter))
                {
                    que.push(make_pair(*iter, tmp.second+1));
                    dict.erase(iter++);
                }
               else
                    iter++;
            }
        }
        return 0;
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

class Solution3 {
public:
    int ladderLength(string start, string end, set<string> &dict) 
    {
        queue<pair<string, int> > que;
        que.push(make_pair(start, 1));
        dict.insert(end);
        set<string> ::iterator  it = dict.find(start);//去掉start   不去也行
        if (it != dict.end())
            dict.erase(it);
        while(!que.empty())
        {
            pair<string, int> tmp =  que.front();
            int size = dict.size();
            que.pop();
            set<string> ::iterator  iter = dict.begin();
            if (tmp.first == end) 
                return tmp.second;
            while (dict.end() != iter)
            {
                if (IfOneDiff(tmp.first, *iter))
                {
                    que.push(make_pair(*iter, tmp.second+1));
                    dict.erase(iter++);//这里一定要去掉   不然时间太久不通过
                }
               else
                    iter++;
            }
        }
        return 0;
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

//"a","c",["a","b","c"]
int main()
{
    Solution3 s;
    set<string> dict;
    //["hot","dot","dog","lot","log"]
    dict.insert("hot");
    dict.insert("dot");
    dict.insert("dog");
    dict.insert("lot");
    dict.insert("log");
    cout<<s.ladderLength("hit", "cog", dict)<<endl;
}
LeetCode刷题---反转链表
元清的博客
12-03 2821
给你单链表的头节点head，请你反转链表，并返回反转后的链表。
LeetCode刷题--- 零钱兑换
元清的博客
04-19 1688
给你一个整数数组coins，表示不同面额的硬币；以及一个整数amount，表示总金额。 计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回-1。 你可以认为每种硬币的数量是无限的。
leetcode---约瑟夫环
weixin_36378508的博客
10-18 1448
解法一分析： 循环的开始和结束：循环的结束取决于圈内是否还有“人”，可以用一个变量alive表示初始人数，每一次出圈，alive - 1。判断alive是否非0即可。 如果这个人在圈内，number + 1； 如果这个人不在圈内，number + 0。 那么，在报数的时候，不需要考虑这个人在不在圈内（每一个人都需要加1或加0，所以，可以在这块优化一下程序）。 def joseph(count, doom): alive = count #幸存人数 number = 0 #计数，当number.
leetcode--石子游戏
weixin_40714134的博客
04-04 4088
石子游戏 Alice 和 Bob 用几堆石子在做游戏。一共有偶数堆石子，排成一行；每堆都有 正 整数颗石子，数目为 piles[i] 。 游戏以谁手中的石子最多来决出胜负。石子的 总数 是 奇数 ，所以没有平局。 Alice 和 Bob 轮流进行，Alice 先开始 。 每回合，玩家从行的 开始 或 结束 处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止，此时手中 石子最多 的玩家 获胜 。 假设 Alice 和 Bob 都发挥出最佳水平，当 Alice 赢得比赛时返回 true ，当 Bob .
LeetCode - 9 回文数
最新发布
优快云
08-30 2万+
回文数的特点是正序和倒序都一样，比如整数 121 的倒序也是 121，因此 121 是回文数。给你一个整数 x ，如果 x 是一个回文整数，返回 true；否则，返回 false。解释：从左向右读, 为 -121。从右向左读, 为 121-。因此它不是一个回文数。回文数 是指正序（从左向右）和倒序（从右向左）读都是一样的整数。解释：从右向左读, 为 01。例如，121 是回文，而 123 不是。注意：按照题目要求，本题负数都不是回文数。输入：x = -121。输入：x = 121。
Leetcode---二维数组问题
yj
11-29 3287
1380. 矩阵中的幸运数 - 力扣（LeetCode） (leetcode-cn.com)https://leetcode-cn.com/problems/lucky-numbers-in-a-matrix/ 1. 其中**matrix 表示二维数组，matrixSize代表二维数组第一维的大小，也就是可以理解成有多少行；int* matrixColSize是一个一维数组，代表每一行有多少列，即matColSize[0]代表第 0 行有matColSize[0]列，matCol...
leetcode---回文数
赵佳敏的博客
02-14 7427
题目描述 给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。 回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。 示例 1： 输入：x = 121 输出：true 示例 2： 输入：x = -121 输出：false 解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 示例 3： 输入：x = 10 输出：false 解释：从右向左读, 为 01 。因此它不是一个回文数。 .
leetcode---快乐数
一只在cv道路上爬行的小乌龟~
01-12 2787
刷到快乐数，我快乐了！！！ class Solution: def isHappy(self, n: int) -> bool: def help(x): temp = list(map(int,[i for i in str(x)])) num=0 for i in temp: num+=i**2 return num arrive
Leetcode 题解 - 动态规划-0-1 背包（1）：问题简介
qq_40320556的博客
06-03 2080
0-1 背包 有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。 定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论： 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件...
LeetCode：0-1背包问题
钱多多先森
05-02 4625
1、问题描述 给定物品的重量 weights=[1, 2, 5, 6, 7] 对应的价值 values=[1, 6, 18, 22, 28] 背包能装的最大重量为 capicity=11 问：我们用这个背包装什么物品能获得最大价值？ 注意1：每件物品只有一 件 注意2：最终重量不能超过背包所能承载的重量 参照视频详解：哔哩哔哩 0-1背包问题 本题采用动态规划， 因为问题的本身含最优子结构。什么是动态规划问题？ 在现实生活中，有一类活动的过程，由于它的特殊性，可将过程分成若干个互相联系的阶段； 在它的
精选资源
LeetCode 101 - A LeetCode Grinding Guide (C++ Version).rar
03-20
《LeetCode 101 - A LeetCode Grinding Guide (C++ Version)》是一本专为C++程序员设计的深入解析LeetCode算法问题的指南。这本书采用彩色版，以直观的方式讲解了各种数据结构和算法，旨在帮助读者磨练编程技能，...
精选资源
LeetCode 101 - A LeetCode Grinding Guide (C Version).pdf
06-27
《LeetCode 101 - A LeetCode Grinding Guide (C++ Version)》是一本面向有一定C++编程基础，但缺乏刷题经验读者的教科书和工具书。作者高畅（Chang Gao）基于其在准备实习和秋招过程中对LeetCode题目的整理和刷题...
精选资源
离线和leetcode-leetcode-cn-cli:为leetcode-cn.com工作
07-06
leetcode-cli 一个享受 leetcode 的高效 cli 工具！ 非常感谢 leetcode.com，一个非常棒的网站！ ⦙⦙⦙⦙⦙⦙⦙⦙ 一个很打问题的方法。 问题来缓解离线思考。 编码前的源代码。 居住和与 leetcode.com。 下载你...
精选资源
leetcode答案-leetcode--python:leetcode--python
06-30
这个压缩包“leetcode--python”显然包含了与LeetCode相关的Python解题代码，可能是一个开源项目，用于存储用户或社区成员解决LeetCode问题的Python实现。 **LeetCode概述** LeetCode提供了一系列的算法和数据结构...
分支算法的时间复杂度
pynash123的博客
12-16 2840
记录一下 表示将原问题分解成 a 个 规模大小为 N/b 的子问题，合并这 a 个子问题的代价是 Θ(N^K) （N^k 表示 N 的 k 次方） T(N)=aT(N/b)+Θ(N^K) T(N)的解有以下三种情况： T(N)=O(N(logab)) 当 a > bk 时 T(N)=O(Nk log^N) 当 a = bk 时 T(N)=O(Nk) 当 a &l...
scikit-learning 多项式回归应用房价预测
pynash123的博客
04-14 1147
将sklearn.datasets中的load_boston房价数据用多项式回归进行训练，并画出学习曲线 import matplotlib.pyplot as plt import numpy as np from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split fr...
leetcode:链表中环的入口结点
pynash123的博客
08-16 761
题目： //给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; */ 思路: 快慢指针，快指针每次前进两个长度，慢指针每次前进一个长度，若存在环，则一定会在环内相遇。 假设起点到环入...
leetcode surrounded-regions
pynash123的博客
04-07 582
Given a 2D board containing’X’and’O’, capture all regions surrounded by’X’. A region is captured by flipping all’O’s into’X’s in that surrounded region . For example, X X X X X O O X X X O X X O X X A...
LeetCode1-240题Java中文题解合集
1. leetCode-126-Word-LadderII.md - 知识点：单词梯度II问题。这是一道涉及图的广度优先搜索（BFS）和深度优先搜索（DFS）的题目，需要构建一个图，并找到两个单词之间的所有最短路径。题目难度较高，涉及算法包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值