数据结构与算法——搜索

最新推荐文章于 2022-06-04 14:20:00 发布
最新推荐文章于 2022-06-04 14:20:00 发布
阅读量131 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 算法 c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxr916/article/details/117926540
版权

文章目录

1.内容概述

在这里插入图片描述

2.岛屿数量

2.1 题目描述

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

示例 2：

输入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
输出：3

2.2 DFS深度搜索算法思路

在这里插入图片描述
在这里插入图片描述

#include<iostream>
#include<vector>
using namespace std;

void DFS(vector<vector<int>>& mark, vector<vector<char>>& grid, int x, int y) {
    mark[x][y] = 1;

    int dx[] = { -1,1,0,0 };
    int dy[] = { 0,0,-1,1 };
    for (int i = 0; i < 4; i++) {
        int new_x = x + dx[i];
        int new_y = y + dy[i];

        if (new_x < 0 || new_y < 0 || new_x >= mark.size() || new_y >= mark[new_x].size()) {
            continue;
        }
        if (mark[new_x][new_y] == 0 && grid[new_x][new_y] == '1') {
            DFS(mark, grid, new_x, new_y);
        }
    }
}

int main()
{
    vector<vector<char>> grid = { {'1','1','1','0','0'},
                                  {'1','1','0','0','0'},
                                  {'0','0','1','0','0'},
                                  {'0','0','0','1','1'} 
                                };
    vector<vector<int>> mark = { {0,0,0,0,0},
                                 {0,0,0,0,0},
                                 {0,0,0,0,0},
                                 {0,0,0,0,0},
    };
    DFS(mark, grid, 1, 1);
    for (int i = 0 ; i<mark.size(); i++) {
        for (int j = 0; j < mark[i].size(); j++) {
            cout << mark[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

1 1 1 0 0
1 1 0 0 0
0 0 0 0 0
0 0 0 0 0

2.3 BFS宽度搜索算法思路

在这里插入图片描述在这里插入图片描述

2.4 C++代码实现

在这里插入图片描述

class Solution {
public:
    void DFS(vector<vector<int>>& mark,vector<vector<char>>& grid,int x,int y){
        mark[x][y]=1;

        int dx[]={-1,1,0,0};
        int dy[]={0,0,-1,1};
        for(int i=0;i<4;i++){
            int new_x=x+dx[i];
            int new_y=y+dy[i];

            if(new_x<0||new_y<0||new_x>=mark.size()||new_y>=mark[new_x].size()){
                continue;
            }
            if(mark[new_x][new_y]==0&&grid[new_x][new_y]=='1'){
                DFS(mark,grid,new_x,new_y);
            }
        }
    }
    void BFS(vector<vector<int>>& mark, vector<vector<char>>& grid, int x, int y) {
        queue<pair<int, int>> Q;
        int dx[] = { -1,1,0,0 };
        int dy[] = { 0,0,-1,1 };

        Q.push(make_pair(x, y));
        mark[x][y] = 1;

        while (!Q.empty()) {
            x = Q.front().first;
            y = Q.front().second;
            Q.pop();

            for (int i = 0; i < 4; i++) {
                int new_x = x + dx[i];
                int new_y = y + dy[i];

                if (new_x < 0 || new_y < 0 || new_x >= mark.size() || new_y >= mark[new_x].size()) {
                    continue;
                }
                if (mark[new_x][new_y] == 0 && grid[new_x][new_y] == '1') {
                    mark[new_x][new_y] = 1;
                    Q.push(make_pair(new_x, new_y));
                }
            }
        }
    }
    int numIslands(vector<vector<char>>& grid) {
       int island=0;
       vector<vector<int>> mark;
       for(int i=0;i<grid.size();i++){
           mark.push_back(vector<int>());
           for(int j=0;j<grid[i].size();j++){
               mark[i].push_back(0);
           }
       } 

       for(int x=0;x<grid.size();x++){
           for(int y=0;y<grid[x].size();y++){
               if(mark[x][y]==0&&grid[x][y]=='1'){
                   DFS(mark,grid,x,y);//或者BFS(mark,grid,x,y);
                   island++;
               }
           }
       } 
       return island;

    }
};

3.单词接龙

3.1 题目描述

字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：

序列中第一个单词是 beginWord 。
序列中最后一个单词是 endWord 。
每次转换只能改变一个字母。
转换过程中的中间单词必须是字典 wordList 中的单词。

给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0。

示例 1：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：5
解释：一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。

示例 2：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：0
解释：endWord "cog" 不在字典中，所以无法进行转换。

3.2 算法思路

在这里插入图片描述
在这里插入图片描述

	bool connect(const string& word1,const string& word2){
        int cnt=0;
        for(int i=0;i<word1.length();i++){
            if(word1[i]!=word2[i]){
                cnt++;
            }
        }
        return cnt==1;
    }
    void construct_graph(string& beginWord,vector<string>& wordList,map<string,vector<string>>& graph){
        wordList.push_back(beginWord);
        for(int i=0;i<wordList.size();i++){
            graph[wordList[i]]=vector<strng>();
        }
        for(int i=0;i<wordList.size();i++){
            for(int j=i+1;j<wordList.size();j++){
                if(connect(wordList[i]),wordList[j]){
                    graph[wordList[i]].push_back(wordList[j]);
                    graph[wordList[j]].push_back(wordList[i]);
                }
            }
        }
    }

3.3 C++代码实现

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool connect(const string& word1,const string& word2){
        int cnt=0;
        for(int i=0;i<word1.length();i++){
            if(word1[i]!=word2[i]){
                cnt++;
            }
        }
        return cnt==1;
    }
    void construct_graph(string& beginWord,vector<string>& wordList,map<string,vector<string>>& graph){
        wordList.push_back(beginWord);
        for(int i=0;i<wordList.size();i++){
            graph[wordList[i]]=vector<string>();
        }
        for(int i=0;i<wordList.size();i++){
            for(int j=i+1;j<wordList.size();j++){
                if(connect(wordList[i],wordList[j])){
                    graph[wordList[i]].push_back(wordList[j]);
                    graph[wordList[j]].push_back(wordList[i]);
                }
            }
        }
    }
    int BFS_graph(string& beginWord,string& endWord,map<string,vector<string>>& graph){
        queue<pair<string,int>> Q;
        set<string> visit;

        Q.push(make_pair(beginWord,1));
        visit.insert(beginWord);

        while(!Q.empty()){
            string node=Q.front().first;
            int step=Q.front().second;
            Q.pop();

            if(node==endWord){
                return step;
            }
            vector<string> neighbor=graph[node];
            for(int i=0;i<neighbor.size();i++){
                if(visit.find(neighbor[i])==visit.end()){
                    Q.push(make_pair(neighbor[i],step+1));
                    visit.insert(neighbor[i]);
                }
            }
        }
        return 0;
    }
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        map<string,vector<string>> graph;
        construct_graph(beginWord,wordList,graph);
        int result=BFS_graph(beginWord,endWord,graph);
        return result;
    }
};

4.单词接龙 II

4.1 题目描述

按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> … -> sk 这样的单词序列，并满足：

每对相邻的单词之间仅有单个字母不同。
转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。
注意，beginWord 不必是字典 wordList 中的单词。
sk == endWord

给你两个单词 beginWord 和 endWord ，以及一个字典 wordList 。请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表 [beginWord, s1, s2, …, sk] 的形式返回。

示例 1：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
解释：存在 2 种最短的转换序列：
"hit" -> "hot" -> "dot" -> "dog" -> "cog"
"hit" -> "hot" -> "lot" -> "log" -> "cog"

示例 2：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：[]
解释：endWord "cog" 不在字典 wordList 中，所以不存在符合要求的转换序列。

4.2 算法思路

在这里插入图片描述
在这里插入图片描述

5.火柴拼正方形

5.1 题目描述

还记得童话《卖火柴的小女孩》吗？现在，你知道小女孩有多少根火柴，请找出一种能使用所有火柴拼成一个正方形的方法。不能折断火柴，可以把火柴连接起来，并且每根火柴都要用到。

输入为小女孩拥有火柴的数目，每根火柴用其长度表示。输出即为是否能用所有的火柴拼成正方形。

示例 1:

输入: [1,1,2,2,2]
输出: true

解释: 能拼成一个边长为2的正方形，每边两根火柴。

示例 2:

输入: [3,3,3,3,4]
输出: false

解释: 不能用所有火柴拼成一个正方形。

5.2 算法思路

在这里插入图片描述

5.3 代码实现

class Solution {
public:
    bool makesquare(vector<int>& matchsticks) {
        if(matchsticks.size()<4){
            return false;
        }
        int sum=0;
        for(int i=0;i<matchsticks.size();i++){
            sum+=matchsticks[i];
        }
        if(sum%4){
            return false;
        }
        sort(matchsticks.rbegin(),matchsticks.rend());
        int bucket[4]={0};
        return generate(0,matchsticks,sum/4,bucket);
    }
private:
    bool generate(int i,vector<int>& matchsticks,int target,int bucket[]){
        if(i>=matchsticks.size()){
            return bucket[0]==target&&bucket[1]==target&&bucket[2]==target&&bucket[3]==target;
        }
        for(int j=0;j<4;j++){
            if(bucket[j]+matchsticks[i]>target){
                continue;
            }
            bucket[j]+=matchsticks[i];
            if(generate(i+1,matchsticks,target,bucket)){
                return true;
            }
            bucket[j]-=matchsticks[i];
        }
        return false;
    }
};

5.4 算法思路2

在这里插入图片描述

5.5 代码实现

class Solution {
public:
    bool makesquare(vector<int>& matchsticks){
        if(matchsticks.size()<4){
            return false;
        }
        int sum=0;
        for(int i=0;i<matchsticks.size();i++){
            sum+=matchsticks[i];
        }
        if(sum%4){
            return false;
        }
        int target=sum/4;
        vector<int> ok_subset;
        vector<int> ok_half;
        int all=1<<matchsticks.size();
        for(int i=0;i<all;i++){
            int sum=0;
            for(int j=0;j<matchsticks.size();j++){
                if(i&(1<<j)){
                    sum+=matchsticks[j];
                }
            }
            if(sum==target){
                ok_subset.push_back(i);
            }
        }

        for(int i=0;i<ok_subset.size();i++){
            for(int j=i+1;j<ok_subset.size();j++){
                if((ok_subset[i]&ok_subset[j])==0){
                    ok_half.push_back(ok_subset[i]|ok_subset[j]);
                }
            }
        }
        for(int i=0;i<ok_half.size();i++){
            for(int j=i+1;j<ok_half.size();j++){
                if((ok_half[i]&ok_half[j])==0){
                    return true;
                }
            }
        }
        return false;
    }
}
二二牧人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——从零开始学习（一）基础概念篇
csdn_aiyang的博客
12-06 25万+
前言 数据结构：是指相互之间存在一种或多种特定关系的数据元素的集合用计算机存储、组织数据的方式。数据结构分别为逻辑结构、（存储）物理结构和数据的运算三个部分。 为什么要学数据结构？ 首先，因为数据结构作为计算机专业的专业基础课程，是计算机考研的必考科目之一，如果打算报考计算机专业的研究生，你必须学好它；其次，数据结构是计算机软考、计算机等级考试等相关考试的必考内容之一，想要顺利通过这些考...
网格搜索 C++实现 机器暴力参数优化
jario9014的专栏
03-26 927
网格搜索 C++实现 机器暴力参数优化： 参数设置和实现原理见下图，后面附带C++源码(个人原创)，帮助解决C++程序参数优化问题。 一般放那跑一夜，最好的参数就出来了，哈哈，还是比较方便滴。 有问题记得留言讨论。。 class JrGrid { public: JrGrid() { /* --搜索初始化设置-- */ m_para_num = 3; // 参数个数
阿里机器学习训练营 Day 3 lightGBM 学习笔记
weixin_45758909的博客
12-09 417
此笔记为阿里云天池机器学习训练营笔记，学习地址：https://tianchi.aliyun.com/s/1fc36a7e103eb9948c974f638e83a83b 感谢教程及阿里云提供平台 1.学习内容概括 lightGBM是什么 LightGBM是2017年由微软推出的可扩展机器学习系统，是微软旗下DMKT的一个开源项目，由2014年首届阿里巴巴大数据竞赛获胜者之一柯国霖老师带领开发。它是一款基于GBDT（梯度提升决策树）算法的分布式梯度提升框架，为了满足缩短模型计算时间的需求，LightGBM的
网格搜索算法
04-23
网格搜索算法，优化向量机。对于向量机的参数进行最优化处理
网格搜索法
xiachong27的博客
08-28 7万+
网格搜索法是指定参数值的一种穷举搜索方法，通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。 即，将各个参数可能的取值进行排列组合，列出所有可能的组合结果生成“网格”。然后将各组合用于SVM训练，并使用交叉验证对表现进行评估。在拟合函数尝试了所有的参数组合后，返回一个合适的分类器，自动调整至最佳参数组合，可以通过clf.best_params_获得参数值       版...
数据结构与算法——算法
小田是个程序员的博客欢迎你的到来呀~
06-04 1万+
算法是对特定问题求解的步骤的一种具体描述，算法是指令的有有限序列，其中每一条指令表示一个或是多个操作，用于解决某个问题。本文主要讲解了数据结构与算法——算法的基本概念，知识点详细。...
数据结构与算法——绪论
小田是个程序员的博客欢迎你的到来呀~
05-28 1798
数据结构与算法绪论一章，总结数据结构基本概念和三要素比较重要的理论部分，图文结合的方式更加有助于小伙伴们对抽象理论知识的理解，对于学习数据结构和算法的小伙伴可是纯纯干货，不要错过呀！！！
数据结构与算法——冒泡排序
chen18221987993的博客
09-08 2613
目录 前言 一、冒泡排序算法介绍 二、冒泡排序算法原理 三、示例分析 四、实现代码 前言 冒泡排序是一种常用的排序方法。它是一种具有“交换”性质的排序方法。 一、冒泡排序算法介绍 冒泡是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端
java数据结构与算法 ——冒泡法
weixin_59796310的博客
01-14 1537
java数据结构与算法 ——冒泡法
算法分析与设计一元二次方程求解
05-28
一元三次方程求解 题目描述 有形如：ax3+bx2+cx+d=0 这样的一个一元三次方程。给出该方程中各项的系数(a，b，c，d 均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)，且根与根之差的绝对值>=1。要求三个实根 输入格式 多组输入(<=20组数据，读入以EOF结尾) 每组输入四个数字，a，b，c，d (4个数绝对值小等于30) 输出格式 每组输出一行结果，由小到大输出3个根(保留两位有效数字) 样例输入 1 -5 -4 20 样例输出 -2.00 2.00 5.00
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
数据结构与算法——专栏索引篇
01-20
数据结构与算法是计算机科学的基础，对于任何编程领域而言，理解和掌握它们都是至关重要的。本专栏将通过C语言这一基础且灵活的语言来深入探讨这些概念，以提供更全面的实践训练。C语言的特性使得在实现数据结构和...
数据结构与算法——C++版
08-25
Mark Allen Weiss《数据结构与算法——C++语言描述》原书第三版，中文
武汉理工大学数据结构与算法实验——欢乐连连看
06-03
武汉理工大学的“数据结构与算法实验——欢乐连连看”是一门将理论学习与实践应用相结合的课程，旨在帮助学生深入理解并掌握这些核心概念。在这个实验项目中，学生们通过实现一个基于经典游戏“欢乐连连看”的程序来...
武汉理工大学数据结构与算法实验——景区管理系统
06-03
1.实验目的 (1)掌握图的定义和图的存储结构 ...使用图的数据结构来保存景区景点信息，为用户提供创建图、査询景点信息、旅游景点导航、搜索最短路径、铺设电路规划等功能，本次实验和后面章节实验一起来完成这些功能。
机器学习（四）——模型调参利器 gridSearchCV（网格搜索）
热门推荐
爱吃串串的瘦子的博客
10-16 19万+
gridSearchCV（网格搜索）的参数、方法及示例 1.简介 GridSearchCV的sklearn官方网址： http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV GridSearc...
网格搜索（调参）与数据预处理
pochy的博客
09-28 1万+
网格搜索 Grid Search 网格搜索是一种调参手段；穷举搜索：在所有候选的参数选择中，通过循环遍历，尝试每一种可能性，表现最好的参数就是最终的结果。其原理就像是在数组里找最大值。（为什么叫网格搜索？以有两个参数的模型为例，参数a有3种可能，参数b有4种可能，把所有可能性列出来，可以表示成一个3*4的表格，其中每个cell就是一个网格，循环过程就像是在每个网格里遍历、搜索，所以叫grid ...
数据结构——图的C语言实现
zxr916的博客
03-18 3580
1.什么是图？ 2.图的抽象数据结构 3.如何在程序中表示一个图？ 3.1 邻接矩阵 3.2 邻接表 4.图的遍历 4.1 深度优先搜索 4.2 广度优先搜索

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值