算法基础——搜索题目(持续更新）

最新推荐文章于 2024-08-24 14:08:21 发布
最新推荐文章于 2024-08-24 14:08:21 发布
阅读量388 收藏 8
点赞数 5
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73683197/article/details/139707082
版权

文章目录

BFS

Flood Fill

题单：

  1. 池塘计数

  2. 城堡问题

  3. 山峰和山谷

最短路

题单：

  1. 迷宫问题

  2. 武士风度的牛

  3. 抓住那头牛

多源BFS

题单：

  1. 矩阵距离:初始队首元素不只有一个

最小步数模型

题单：

  1. 魔板

双端队列

题单：

  1. 电路维修
#include<bits/stdc++.h>

using namespace std;
#define x first
#define y second

typedef pair<int,int> PII;
const int N=510;
int r,c;
char g[N][N];
int dist[N][N];

int bfs(){
    char move[]="\\/\\/";
    int mx[]={-1,-1,1,1};
    int my[]={-1,1,1,-1};
    int ix[]={-1,-1,0,0};
    int iy[]={-1,0,0,-1};
    
    memset(dist,0x3f,sizeof dist);
    dist[0][0]=0;
    deque<PII> q;
    q.push_front({0,0});
    
    while(q.size()){
        auto t=q.front();
        q.pop_front();
        
        if(t.x==r&&t.y==c) return dist[r][c];
        
        for(int i=0;i<4;i++){
            int ax=t.x+mx[i];
            int ay=t.y+my[i];
            int bx=t.x+ix[i];
            int by=t.y+iy[i];
            
            if(ax<0||ax>r||ay<0||ay>c) continue;
            
            int w=g[bx][by]!=move[i];
            int d=dist[t.x][t.y]+w;
            if(d<dist[ax][ay]){
                dist[ax][ay]=d;
                if(!w) q.push_front({ax,ay});
                else q.push_back({ax,ay});
            }
        }
    }
    return -1;
}

signed main(){
    int t;
    cin>>t;
    while(t--){
        cin>>r>>c;
        
        //优化1
        //if(r+c & 1 ){
        //    puts("NO SOLUTION");
        //    continue;
        //}
        
        for(int i=0;i<r;i++) cin>>g[i];
        int res=bfs();
        if(res==-1) puts("NO SOLUTION"); //（1）
        else cout<<res<<endl;
    }
    return 0;
}

双向广搜

题单：

  1. 字串变换
// 采用单向bfs搜索
// 数据一旦加强就过不了

# include<bits/stdc++.h>

using namespace std;
string A,B;
const int N=21;
vector<string> a(N),b(N);
int n;

int bfs(){
    unordered_map<string,int> d;
    queue<string> q;
    q.push(A);
    while(q.size()){
        string t = q.front();
        q.pop();
        
        if(t==B) return d[t];
        
        for(int i = 0; i < t.size(); i++){
            for(int j=0; j < n; j ++){
                if(t.substr(i,a[j].size()) == a[j]){
                    string sub=t.substr(0,i)+b[j]+t.substr(i+a[j].size());
                    if(!d.count(sub)){
                        d[sub]=d[t]+1;
                        q.push(sub);
                    }
                }
            }
        }
    }
    
    return -1;
}

signed main(){
    
    cin>>A>>B;
    while(cin>>a[n]>>b[n++]);
    int t=bfs();
    if(t!=-1) cout<<t<<endl;
    else puts("NO ANSWER!");
    
    
    return 0;
}

// 采用双向bfs搜索
// y总版
# include<bits/stdc++.h>

using namespace std;
string A,B;
const int N=21;
vector<string> a(N),b(N);
unordered_map<string,int> da,db;
int n;

int extend(queue<string>& q, unordered_map<string,int> &da,unordered_map<string,int> &db,vector<string> &a,vector<string> &b){
    
    int d = da[q.front()];
    
    while(q.size()&&da[q.front()]==d){
        string t = q.front();
        q.pop();
        for(int i=0;i<t.size();i++){
            for(int j=0;j<n;j++){
                if(t.substr(i,a[j].size())==a[j]){
                    string sub = t.substr(0,i)+b[j]+t.substr(i+a[j].size());
                    if(db.count(sub)) return db[sub]+da[t]+1;
                    if(!da.count(sub)){
                        q.push(sub);
                        da[sub]=da[t]+1;
                    }
                }
            }
        }
        
    }
    return 11;
}

int bfs(){
    if(A==B) return 0;
    queue<string> qa,qb;
    unordered_map<string,int> da,db;
    qa.push(A);
    qb.push(B);
    da[A]=0,db[B]=0;
    int step=0;
    while(qa.size()&&qb.size()){
        int t;
        if(qa.size()>qb.size()){
            t=extend(qb,db,da,b,a);
        }
        else{
            t=extend(qa,da,db,a,b);
        }
        if(t<=10) return t;
        if(++step==10) return -1;
    }
    
    return -1;
}

signed main(){
    
    cin>>A>>B;
    while(cin>>a[n]>>b[n++]);
    int t=bfs();
    if(t!=-1) cout<<t<<endl;
    else puts("NO ANSWER!");
    
    
    return 0;
}

// 采用单向bfs搜索
# include<bits/stdc++.h>

using namespace std;
string A,B;
const int N=21;
vector<string> a(N),b(N);
unordered_map<string,int> da,db;
int n;

int extend(queue<string>& q, unordered_map<string,int> &da,unordered_map<string,int> &db,vector<string> &a,vector<string> &b){
    
    int d = da[q.front()];
    
    while(q.size()&&da[q.front()]==d){
        string t = q.front();
        q.pop();
        if(da[t]==d){
            for(int i=0;i<t.size();i++){
                for(int j=0;j<n;j++){
                    if(t.substr(i,a[j].size())==a[j]){
                        string sub = t.substr(0,i)+b[j]+t.substr(i+a[j].size());
                        if(db.count(sub)) return db[sub]+da[t]+1;
                        if(!da.count(sub)){
                            q.push(sub);
                            da[sub]=da[t]+1;
                        }
                    }
                }
            }
        }
        else break;
        
    }
    return 11;
}

int bfs(){
    if(A==B) return 0;
    queue<string> qa,qb;
    unordered_map<string,int> da,db;
    qa.push(A);
    qb.push(B);
    da[A]=0,db[B]=0;
    int step=0;
    while(qa.size()&&qb.size()){
        int t;
        if(qa.size()>qb.size()){
            t=extend(qb,db,da,b,a);
        }
        else{
            t=extend(qa,da,db,a,b);
        }
        if(t<=10) return t;
        if(++step==10) return -1;
    }
    
    return -1;
}

signed main(){
    
    cin>>A>>B;
    while(cin>>a[n]>>b[n++]);
    int t=bfs();
    if(t!=-1) cout<<t<<endl;
    else puts("NO ANSWER!");
    
    
    return 0;
}

A*

题单：

  1. 第K短路

  2. 八数码:

    在基础课的基础上需要知道记录每一步的操作，可通过记录上一次的状态推得

DFS

DFS之搜索顺序

  3. 分成互质组

优秀题解

#include<iostream>

using namespace std;
const int N=11;
int ans=N; //记录最优解,求最小因此初始化为最大
int n;
int a[N],st[N];
int ga[N][N]; //存储每组的元素

int gcd(int x,int y){
    return y?gcd(y,x%y):x;
}

bool check(int g,int gr,int x){
    for(int i=0;i<gr;i++){
        if(gcd(ga[g][i],x)>1) return false;
    }
    return true;
}

//g表示当前是第几组，gr表示当前组的元素个数
//start表示从a数组的哪一个位置开始找放入组内的数，
//从而确定每个数是否需要开新的组，可以恒为零
//
bool dfs(int g,int gr,int start,int tot){ 
    if(g>=ans) return 0;
    if(tot==n) ans=g;
    
    int flag = 1;
    //如果i从0开始就会死循环，
    //不确定是不是因为时间限制，
    //不知道有没有死循环
    for(int i=start;i<n;i++){
        if(!st[i]&&check(g,gr,a[i])){
            st[i]=1;
            ga[g][gr]=a[i];
            dfs(g,gr+1,start+1,tot+1);
            st[i]=0;    //恢复st[i]是考虑第i个数放在不同组的情况
            flag=0;
        }
    }
    //只要新开一组就start=0开始找可以放进新组中的数
    //这些数包括回溯恢复的一些数，因为当它们在不同组时，
    //和不同的数组成的团可能让新开组的数的后一个数放进去，
    //体现在同级的循环上;
    if(flag) dfs(g+1,0,0,tot);
}

signed main(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    dfs(1,0,0,0);
    cout<<ans<<endl;
    return 0;
}

DFS之剪枝

  1. 小猫爬山

排序找最小分支

方案数大于最大数剪枝

枚举小猫，考虑开新车放小猫

#include<bits/stdc++.h>

using namespace std;
const int N=18;
int n,m;
int a[N],sum[N];
int ans = N;

void dfs(int u,int k){
    if(k>=ans) return;
    
    if(u==n){   //当枚举完小猫之后，赋k值
        ans=k;
        return ;
    }
    
    for(int i=0;i<k;i++){
        if(sum[i]+a[u]<=m){
            sum[i]+=a[u];
            dfs(u+1,k);
            sum[i]-=a[u];
        }
    }
    
    sum[k]=a[u];
    dfs(u+1,k+1);
    sum[k]=0;
}

signed main(){
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>a[i];
    sort(a,a+n);
    reverse(a,a+n);
    
    dfs(0,0);
    cout<<ans<<endl;
    return 0;
}
  1. 数独

位运算+dfs

#include<bits/stdc++.h>

using namespace std;
const int N=9,M=1<<N;
int col[N],row[N],g[3][3];
int ones[M],lg[M];
char s[100];

void init(){
    for(int i=0;i<N;i++){
        col[i] = (1<<N) - 1;    //不加括号的位运算不能得到结果
        row[i] = (1<<N) - 1;
    }
    
    for(int i=0;i<3; i++){
        for(int j=0 ;j < 3 ; j++){
            g[i][j] = (1<<N) - 1;
        }
    }
}

int lowbit(int x){
    return x&-x;
}

void draw(int x,int y,int t,bool flag){
    
    if(flag){
        s[x*N+y] = '1'+t;
    }
    else{
        s[x*N+y] = '.';
    }
    
    int v=1<<t;
    if(!flag) v=-v;
    
    row[x] -= v;
    col[y] -= v;
    g[x/3][y/3] -= v;
    
}

int get(int x,int y){
    return row[x]&col[y]&g[x/3][y/3];
}

bool dfs(int cnt){
    if(!cnt) return true;
    
    int minv=10;
    int x,y;
    
    for(int i = 0; i < N ; i++){
        for(int j=0; j < N ; j++){
            if(s[i*N + j]=='.'){
                int v = get(i,j);
                if(ones[v]<minv){
                    minv= ones[v];
                    x=i,y=j;
                }
            }
        }
    }
    
    int v = get(x,y);
    for(int i=v;i;i-=lowbit(i)){
        int t = lg[lowbit(i)];
        draw(x,y,t,true);
        if(dfs(cnt-1)) return true;
        draw(x,y,t,false);
    }
    return false;
}



signed main(){
    
    for(int i = 0;i<1<<N;i++){
        for(int j=0;j<N ; j++){
            ones[i]+=((i>>j) & 1);
        }
    }
    
    
    
    for(int i=0;i<N ;i++) lg[1<<i] = i;
    
    while(cin>>s,s[0]!='e'){
        init();
        int cnt=0;
        for(int i=0,k=0;i<N;i++){
            for(int j=0;j<N;j++,k++){
                if(s[k]=='.'){
                    cnt++;
                }
                else{
                    int t=s[k]-'1'; 
                    draw(i,j,t,true);
                }
            }
        }
        dfs(cnt);
        puts(s);
    }
    return 0;
}
  1. 木棒

二分木棍最小值，向左找，dfs找到可以满足等长的总共木棒数，枚举木棒，将木棍放入，但其实木棍最长也就64，不会爆int，所以从1开始枚举就好了

#include<bits/stdc++.h>

using namespace std;
const int N=70;
int n;
int a[N],v[N];
int sum,length;

//枚举木棒
bool dfs(int u,int cur,int start){
  if((u)*length==sum) return true;
  if(cur==length) return dfs(u+1,0,0);
  
  for(int i=start;i<n;i++){
    if(!v[i]&&cur+a[i]<=length){
      v[i]=1;
      if(dfs(u,cur+a[i],i+1)) return true;
      v[i]=0;
      
      if(!cur||cur+a[i]==length) return false;
      
      int j=i;
      while(j<n&&a[i]==a[j]) j++;
      i=j-1;
    }
  }
  return false;
}



signed main(){
  while(cin>>n,n!=0){
    length = 1;
    sum=0;
    memset(v,0,sizeof v);
    for(int i=0;i<n;i++){
      cin>>a[i];
      sum+=a[i];
    }
    
    sort(a, a + n);
    reverse(a, a + n);
    
    while(true){
      if(sum%length==0&&dfs(0,0,0)){
        cout<<length<<endl;
        break;
      }
      length++;
    }
  }
  return 0;
}
  1. 生日蛋糕

DFS之迭代加深

  1. 加成序列

双向DFS

  1. 送礼物

IDA*

  1. 排书

  2. 回转游戏

wlwhonest
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【基础算法训练】—— 深度优先搜索
weixin_52621323的博客
05-16 750
被DFS强行欺负
备战秋招——常规算法笔试题集锦（持续更新）
要做更好的自己的Vicky_ Blog
06-24 1658
1.任何一个递归过程都可以转换成非递归过程(✓) 2.Hanoi问题 假设个盘子的Hanoi问题需要次操作来完成，三根柱子分别为A，B，C，则实现算法主要分为三个步骤： 1）把n-1个盘子由 A 移到 B 2）把第n个盘子 由 A 移到 C 3）把n-1个盘子由 B 移到 C 可以看出，此问题是一个递归问题：。 个盘子的Hanoi问题的总移动次数为：。 3.设哈希表长为11，哈希函...
LeetCode——单链表相关题目（持续更新）
2301_76836325的博客
08-13 278
LeetCode.21——合并两个有序链表： LeetCode.203——移除链表元素： LeetCode.206——反转链表： LeetCode——剑指offer.22-链表中倒数第k个结点： LeetCode.876——链表中间结点 LeetCode.LCR-027——回文链表 LeetCode.160——相交链表
【算法基础——第四讲】二分
m0_63233163的博客
05-05 214
大家好，我是quicklysleap，算法学习笔记系列持续更新中 文章目录一、前言二、二分算法的介绍三、二分算法的运用1. 整数二分模板2.浮点数二分模板最后 一、前言 二分，是一种求极值的算法，通常已知答案的取值范围，然后每次取取值范围的中点，判断之是否可行，然后找可行的一半处理。 二、二分算法的介绍 二分查找的最优时间复杂度为O(1) 。 二分查找的平均时间复杂度和最坏时间复杂度均为 O(logn)。因为在二分搜索过程中，算法每次都把查询的区间减半，所以对于一个长度为n 的数组，至多会进行.
算法笔记合集（附题目链接）——持续更新
Uupton的博客
02-25 1362
一、数 1 标题0
Java数据结和算法——目录(持续更新)
菜不是原罪
02-28 405
旨在具体将每个基础算法过一遍，用较短和较精炼的话将每种结构特点总结出来，供自己以后方便阅读。配合以代码和题目的练习达到入门的门槛，加油，奥里给！ 目录 综述 为啥要学算法:算法开篇——什么是算法，学习算法有什么用 数组 Task01. 两数之和 难度：简单 https://leetcode-cn.com/problems/two-sum/ Task02. 删除排序数组中的重复项 难度：简单 h...
基础算法——深度优先经典——岛屿问题
MDeleter的博客
01-17 3224
在此之前，我曾见过许多的学生提及算法唯恐避之不及，几乎所有人都知道算法只不过是思考问题的方法，但很遗憾，大部分人并未体会到算法的乐趣所在，而是被所谓的一些优秀者口中的“神圣”的算法策略给唬住，而不敢向前。
Python编程题——LeedCode系列 持续更新
weixin_46043035的博客
11-07 201
注：持续更新LeedCode题库题解，更新过的会持续更新多种解法，力求最忧解；
数据结构与算法——BFS(广度优先搜索)
大三计算机在读，分享我的算法之路
08-17 1840
广度优先搜索（Breadth-First Search，简称BFS）是一种遍历或搜索树和图的算法，也称为宽度优先搜索，BFS算法从图的某个节点开始，依次对其所有相邻节点进行探索和遍历，然后再对这些相邻节点的相邻节点进行探索，直到遍历完所有的节点。
【基础算法训练】—— 字符串
weixin_52621323的博客
05-02 1051
记录每天写的一些习题，有leetcode ，有洛谷，集中一点，登峰造极
刷题遇到的一些题目（Java）——持续更新
12-22
1. 末尾0的个数——滴滴笔试题 题目描述：输入一个正整数n,求n!(即阶乘)末尾有多少个0？ 比如: n = 10; n! = 3628800,所以答案为2 原题链接：...
明算理、知算法——“一个数除以分数”课后反思.doc
05-26
### 明算理、知算法——“一个数除以分数”的教学反思 #### 一、引言 在数学教育中，计算教学往往被视为基础而重要的一环，然而它也常常被认为是枯燥乏味的。如何让计算教学变得生动有趣，成为每位教师都需要面对...
Java经典算法50题——答案下载！
04-11
这50题涵盖了数据结构、排序算法、搜索算法等多个领域，旨在帮助程序员深化对基础理论的理解，并提高实际问题解决能力。通过解决这些题目，你可以熟悉并掌握各种常用算法，从而在实际工作中更加游刃有余。 首先，让...
力扣刷题总结c++ 解题报告（持续更新中）（csdn）————程序.pdf
12-05
这些题目展示了C++在解决算法问题时的灵活性和效率，涉及了数据结构（如数组、链表、哈希表、栈和队列）、基本操作（如字符串处理、整数转换、位运算）以及多种算法思想（如暴力求解、动态规划、双指针、滑动窗口、...
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 796
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
C语言刷题日记(附详解)(2)
最新发布
ixiaotang_的博客
08-24 1063
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 396
哈希表解决存在重复元素二问题
智能微气候:精准调控背后的算法革命
u010079117的博客
08-20 922
通过迁移学习,优化后的策略可快速移植到新的设施环境、新的作物品种,实现农业专家知识的规模化复用。农业知识图谱是智慧农业的基础设施。未来,LLM与5G、IoT等新一代信息技术的融合,将进一步提升设施农业的智能化水平,实现更精准、更高效、更环保的设施种植模式。另一方面,LLM可以学习农业专家的经验知识,通过知识蒸馏等技术,将专家经验转化为可解释、可迁移的计算机程序,助力农业生产智能化。温室、养殖舍等设施通过对光、温、水、气、肥等环境要素的调控,为作物和畜禽营造最适宜的生长环境,实现农业生产的高产、优质、高效。
最小区间00
青釉Oo的博客
08-21 430
最小区间
设计与实现：计算机调度算法实战——FCFS, RoundRobin & PrioritySchedual
题目要求设计一个名为JobSchedual的类，用于实现三种经典的调度算法：先来先服务(FCFS)、轮询(Round Robin)和优先级调度(Priority Scheduling)。参与者需要处理的Job结构体包含id、enter_time（进入系统时间）、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值