acwing算法基础笔记第三章搜索与图论

已于 2023-08-26 23:07:05 修改
阅读量183 收藏 1
点赞数
文章标签： 算法 图论 笔记
于 2023-08-24 23:48:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d_mail/article/details/132439132
版权

BFS第一次搜到的点一定是离第一个点最近的点，
在这里插入图片描述
每个DFS都一定对应一条搜索树，
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;

const int N = 10;

int n;
int path[N];//path存储路径，到叶节点的时候，就填好路径上的点了，u等于0的时候在第一层，u为1为第二层，u为2在第三层，u等于3的时候是最后一层。所以u==n的时候是最后一层
bool st[N];
void dfs(int u)
{
    if (u== n)
    {
        for (int i = 0; i < n; i ++ ) printf("%d ", path[i]);
        puts("");
        return;
    }
    for (int i=1;i<= n; i ++ )
        if (!st[i])
        {
            path[u] = i;
            st[i] = true;//true表示用过了，
            dfs(u + 1);
            st[i] = false;//恢复现场
        }
}
int main()
{
    cin >> n;
    dfs(0);
    return 0;
}

在这里插入图片描述
在这里插入图片描述
每一行都要放一个皇后，并且只能放一个皇后，所以可以从前往后枚举每一行的皇后可以放到哪一个位置上，比如写出n行，即n个空位，如果在第一行的把皇后放到第一列就是1，第二行把皇后放到第三列就是3，即搜索顺序和全排列的搜索顺序是一样的，
剪枝：当前方案不合理，不用继续往下了，直接进行回溯，
在这里插入图片描述
第u行所在的对角线和反对角线是对应的直线的截距b，因为y-x可能为负数，所以补上n这个偏移量，反对角线是y+x，
时间复杂度n*n！

#include <iostream>
using namespace std;
const int N = 20;

int n;
char g[N][N];
bool col[N],dg[N], udg[N];//每列，每个主对角线，每个副对角线

void dfs(int u)//当前是枚举第u行的皇后应该放在哪里，
{
    if(u== n)
    {
        for (int i = 0;i< n; i ++ ) puts(g[i]);
        puts("");
        return;
    }
    for (int i=0;i<n; i ++ )
        if (!col[i] && !dg[u + i] && !udg[n - u + i])//从第一列开始枚举，这一列之前没有放过，并且对角线和反对角线上都没有放过，
        {
            g[u][i] ='Q';
            col[i] = dg[u + i] = udg[n - u + i] = true;//表示这一列以及对角线上已经有皇后了，
            dfs(u + 1);
            col[i] = dg[u + i] = udg[n - u + i] = false;//恢复现场
            g[u][i] ='.';//恢复main函数最开始把每个位置设置为点的状态，
        }
    
}
int main()
{
    cin >> n;
    for (int i= 0;i< n; i ++ )
        for (int j = 0; j< n; j ++ )
            g[i][j] ='.';
    dfs(0);
    return 0;  
}

时间复杂度2的n²次方

#include <iostream>
using namespace std;
const int N = 20;

int n;
char g[N][N];
bool row[N],col[N],dg[N], udg[N];//每列，每个主对角线，每个副对角线

void dfs(int x,int y, int s)
{
    if (y == n) y=0,x++ ;//如果某一行y到达最后一列出界后会返回下一行的开头，
    if (x == n)
    {
        if (s == n)
        {
            for (int i = 0;i< n; i ++ ) puts(g[i]);
            puts("");
        }
        return;
    }
    // 不放皇后
    dfs(x,y + 1,s);
    // 放皇后
    if (!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
    {
        g[x][y] ='Q';
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
        dfs(x, y+1 ,s + 1);
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
        g[x][y] ='.';
    }

}

int main()
{
    cin >> n;
    for (int i= 0;i< n; i ++ )
        for (int j = 0; j< n; j ++ )
            g[i][j] ='.';
    dfs(0,0,0);//从左端点开始搜，并且记录一下一共有多少个皇后
    return 0;  
}

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

在这里插入图片描述
不用写四个判断，可以用向量表示，向上下左右让对应的坐标减就可以，
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef pair<int, int> PII;
const int N = 110;
int n, m;
int g[N][N];//g【】【】数组存的是图
int d[N][N];//d【】【】数组存的是每一个点到起点的距离，
PII q[N *N],Prev[N][N];
int bfs()
{
    int hh = 0, tt = 0;//模拟队列，队头队尾
    q[0] = {0,0};
    
    memset(d,-1,sizeof d);//把所有距离初始化为-1表示这一点没有走过，
    d[0][0] = 0;//表示走过了
    
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0,1, 0, -1};
    
    while (hh <=tt)//队列不空
    {
        auto t = q[hh ++ ];//每一次取出队头元素的坐标，尝试往上下左右四个方向的坐标扩展，不用写四个判断，可以用向量来表示，往上就是横坐标减一，纵坐标不变，往右就是横坐标不变，纵坐标加一，往下就是横坐标加一，纵坐标不变，往左就是横坐标不变，纵坐标减一，
        
        for (int i= 0;i<4; i ++ )//每一次枚举一下四个方向
        {
            int x = t.first + dx[i],y = t.second + dy[i];//x，y表示沿着这个方向走会走到哪一个点，
            if (x >= 0 && x< n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)//g[x][y] == 0表示这个点是空地，因为g如果为-1表示是墙，d[x][y] == -1表示这个点还没有走过，
            {
                d[x][y] = d[t.first][t.second] + 1;//只有第一次搜到了才会更新它，即从-1的状态变成0，表示这个点是第一次走过
                Prev[x][y]=t;//记录前一个点是什么，
                q[ ++ tt] = {x,y};//把点加进来

            }
        }
    }
    int x = n- 1,y=m-1;
    while (x||y)
    {
        cout << x <<' '<< y << endl;
        auto t = Prev[x][y];
        x = t.first,y = t.second;
    }

    return d[n - 1][m - 1];//把右下角的点的距离输出初来就可以了，

}
int main()
{
    cin >> n >> m;
    
    for (int i= 0;i<n;i++ )
        for (int j=0;j<m;j++ )
        cin >>g[i][j];
        
    cout << bfs() << endl;
    return 0;
}

树是一种特殊的图，无向图是一种特殊的有向图，对于每一条无向边，建两条边就可以了，所以只需要考虑有向图如何存储就可以了，
图的邻接表存储
在这里插入图片描述

在这里插入图片描述

数和图的存储：邻接表

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 100010,M = N*2;
int h[N], e[M], ne[M], idx;
//h[]数组存的是n个链表的链表头，e[]存的是所有结点的值，ne[]存的是每个结点的next值是多少
//初始化单链表就是让单链表的头结点指向-1，现在有n个头结点，就让n个头结点指向-1就可以了，

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

int main()
{
    memset(h,-1, sizeof h);
}

树和图的遍历，

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 100010,M = N*2;
int n,m;
int h[N], e[M], ne[M], idx;
//h[]数组存的是n个链表的链表头，e[]存的是所有结点的值，ne[]存的是每个结点的next值是多少
//初始化单链表就是让单链表的头结点指向-1，现在有n个头结点，就让n个头结点指向-1就可以了，
bool st[N];//st[]数组存哪些点已经被遍历过了，只需遍历一次，
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
    st[u] = true; // 标记一下，已经被搜过了
    for (int i = h[u];i != -1; i = ne[i])
    {
        int j = e[i];//j存一下当前链表里的点对应图里面的点的编号是多少，
        if (!st[j]) dfs(j);//如果j没有被搜过就一直搜，搜到底
    }
    
}

int main()
{
    memset(h,-1, sizeof h);
    
    dfs(1);
}

树和图的深度优先遍历，因为每一个点都只会被遍历一次，所以树的图的深度优先遍历和宽度优先遍历时间复杂度都是O（n+m）都是和点数以及边数成线性关系的，
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 100010,M = N*2;
int n;
int h[N], e[M], ne[M], idx;
//h[]数组存的是n个链表的链表头，e[]存的是所有结点的值，ne[]存的是每个结点的next值是多少
//初始化单链表就是让单链表的头结点指向-1，现在有n个头结点，就让n个头结点指向-1就可以了，
bool st[N];//st[]数组存哪些点已经被遍历过了，只需遍历一次，
int ans=N;//记录全局的答案，最小的最大值，
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
} 
//返回以u为根的子树中的点的数量，
int dfs(int u)
{
    st[u] = true; // 标记一下，已经被搜过了
    int sum = 1,res = 0;//当前这个点算一个点，res记录把这个点删了之后，每一个连通块的最大值，
    for (int i = h[u];i != -1; i = ne[i])
    {
        int j = e[i];//j存一下当前链表里的点对应图里面的点的编号是多少，
        if (!st[j]) 
        {
            int s = dfs(j);//如果j没有被搜过就一直搜，搜到底，用s表示当前的子树的大小
            res = max(res,s);//当前子树也算是一个连通块，所以与res求max
            sum += s;//以u的儿子结点为根节点的子树是以u为根节点的子树的一部分，所以sum要加上s，
        }
        
    }
    res = max(res,n-sum);//结束后，以u为根节点的子树的上面那一部分的连通块也要算，即n-sum，
    
    ans = min(ans,res);//次数ans存的就是把这个点删除后的最大的连通块的点数，和res取min，
    return sum;
    
}

int main()
{
    cin>> n;
    memset(h,-1, sizeof h);
    for(int i = 0;i<n-1;i++)
    {
        int a,b;
        cin >>a>>b;
        add(a,b),add(b,a);
        
    }
    dfs(1);
    cout<<ans<<endl;
    return 0;
}

宽度优先遍历
在这里插入图片描述
在这里插入图片描述
因为图里面边的权值都是1，所以可以用宽搜来求最短距离，
在这里插入图片描述

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;
int d[N], q[N];//d【】是距离，q【】是队列，初始化d数组，
void add(int a, int b)
{
    e[idx] = b,ne[idx] = h[a], h[a] = idx ++ ;
}

int bfs()
{
   int hh = 0,tt = 0;
   q[0] = 1; //第一个元素的是起点1
   
   memset(d,-1,sizeof d);//-1表示没有被遍历过，
   
    d[1] = 0;
    
    while (hh <= tt)//队列不空
    {
        int t = q[hh ++ ];//获取队头
        for (int i = h[t]; i != -1; i = ne[i])//扩展当前的点
        {
            int j= e[i];
            if (d[j] == -1)//j没有被遍历过
            {
                d[j] = d[t] + 1;//扩展
                q[ ++ tt] = j;//把j加入队列
            }
        }
        
    }
    return d[n];
}
int main()
{
    cin >> n >> m;
    
    memset(h,-1, sizeof h);
    
    for (int i=0;i<m;i++ )
    {
        int a, b;
        cin>> a>> b;
        add(a,b);
    }

    cout << bfs() << endl;
    
    return 0;
}

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

拓扑序列是针对有向图来说的，无向图没有拓扑序列，拓扑序列就是给出一个序列后，所有的边都是从前指向后面的，
在这里插入图片描述
有环就无法写出拓扑序列了，一个有向无环图一定存在一个拓扑序列，有向无环图也被称为拓扑图
所有入度为0的点都可以排在当前最前面的位置，一个无环图至少存在一个入度为0的点，
在这里插入图片描述
一个有向无环图的拓扑序不一定是唯一的，

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;
int d[N], q[N];//d【】是点的入度，q【】是队列，
void add(int a, int b)
{
    e[idx] = b,ne[idx] = h[a], h[a] = idx ++ ;
}
bool topsort()
{
    int hh = 0,tt = -1;
    
    for (int i = 1; i <= n; i ++ )
        if (!d[i])//把所有入度为0的点加入到队列里，
            q[ ++ tt] = i;
            
    while (hh <= tt)//队列不空就取出来队头元素
    {
        int t = q[hh ++ ];//出队的顺序就是拓扑序，由于出队只是把指针往后移动了一位，前面的顺序都是不变的，因此当我们把所有点都遍历完了之后队列里面现在的队列即q【】里面的次序恰好就是拓扑序，
        
        for (int i = h[t]; i != -1; i = ne[i])//拓展队头元素
        {
            int j = e[i];//找到出边
            d[j] --;//让入度减减
            if (d[j] == 0)q[ ++ tt] = j;//如果入度为0，就把j加到队列里
        }
    }
    return tt == n - 1;//最后判断一下是不是所有点都入队了。说明队列里一共进了n个点，
}

int main()
{
    cin >> n >> m;
    
    memset(h,-1,sizeof h);
    for (int i =0;i < m; i ++ )
    {
       int a, b;
       cin >> a >> b;
       add(a, b);
       d[b] ++ ;//插入边，更新入度，一条a指向b的边，则b的入度加一，
    }
    if (topsort())//如果存在拓扑序就输出出来，不存在就输出-1
    {
        for (int i = 0; i< n; i ++ ) printf("%d ", q[i]);
        puts("");
    }
    else puts("-1"); 
    
    return 0;
}

最短路

一只QAQ
关注
Acwing-基础算法课笔记之搜索与图论
weixin_73381974的博客
01-15 1165
在上面的例子中，mySet.count(elementToFind) 返回元素 elementToFind 在 unordered_set 中出现的次数，因为在 unordered_set 中每个元素都是唯一的，所以该函数实际上只能返回 1 或 0。然后节点 1 接下来有两个路径分别是节点 2 和节点 3，填写距离两个节点的路径权值，并填写前面节点的记号，因为距离节点 2 最近，所以选择节点 2 的路径，并标记节点 2 已被经过。需要算出u的最大子树的节点数和u上面的部分的节点数，然后取二者的最大值即可。
acwing算法基础课第三讲搜索与图论复习总结
qqqlllkkk的博客
03-10 437
最近备考蓝桥杯，准备把之前算法基础课题目都复习一遍，冲(*^▽^*) 1.排列数字 这里的排列数字排列的是组合数 通过深度优先搜索来做 st[]数组判断每个数字是否使用过(因为组合数排列，每个数字只能用一次) 深度优先搜索的题目可以先画出递归搜索树 依据枚举到了哪个位置来进行搜索dfs(u) 如果u从0开始搜索,当u==n时说明0-n-1这n个位置已经搜索完了,输出一组排列,return回上一层递归，进行下一次搜索 #include <iostream> #include
【AcWing算法基础课】第三章 搜索与图论
你的博客
07-05 1373
AcWing算法基础课笔记
Acwing算法基础课学习笔记
togph的博客
04-16 1867
Acwing 算法基础学习笔记
[Acwing算法基础课]3.搜索与图论（一）笔记
欢迎光临失去理智(sxhthreo)的博客~
08-04 258
回溯、恢复现场 第一种搜索顺序：按行枚举 第二种搜索顺序：一个一个格子进行搜索。 1.2 BFS 当所有边的权重都为1时，才可以使用求解最短路径问题。 ​ 若需要输出路径，则可以在后添加一句代码用于存储当前元素的前一个元素【记录路径】，然后在函数返回前输出路径： 1.3 图的存储方式与遍历 树是无环连通图，是一种特殊的图。图分为有向图和无向图。给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。重心定义：重心是
AcWing算法基础课笔记 ------ 第三章 搜索与图论
layfolk的博客
02-28 1186
本篇博客记录AcWing算法基础课中的一些有关图论的算法，从熟知的dfs和bfs算法，再到求解单源路径，还有多源路径，最小生成树，以及二分图。
AcWing 算法基础课笔记 第三讲 搜索与图论
weixin_46524238的博客
11-11 307
别看
AcWing算法基础课 | AcWing基础课题集汇总，超详细笔记整理
热门推荐
qq_45832461的博客
06-11 1万+
万字长文撰写史上最全的AcWing算法基础课题集，每道题会给出多种解法，不局限于一种思路，可以帮助读者从不同角度思考题目。算法代码简洁，适合背诵记忆，方便读者后期复盘巩固
acwing算法基础课(第三讲 搜索与图论)，面试完整版
2401_84411849的博客
04-20 952
Java架构进阶面试及知识点文档笔记这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理Java分布式高级面试问题解析文档其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！互联网Java程序员面试必备问题解析及文档学习笔记Java架构进阶视频解析合集。
算法基础课 acwing
Destiny_159的博客
09-06 6385
算法基础课 本博客基于acwing算法基础课,所做笔记 目的在于方便复习 课程链接:https://www.acwing.com/activity/content/introduction/11/ 主讲人:yxc 上课的时候理解算法的主要思想 课后把模板背过,并且调试题目,多重复,多敲 第一讲 基础算法 快速排序 调整区间的方法: 1、暴力，需要开辟两个数组 2、双指针 1、i往后面扫描，当i指向的数字小于等于x，就继续往后，当指向的数字大于x的时候停下 2、此时j往前面扫描，当j指向的数字大于x
AcWing算法题常用代码模板
Lyf_Ah的博客
11-18 6899
一、基础算法 1、常用代码模板 快速排序算法模板 —— 模板题 AcWing 785. 快速排序 算法步骤： ​ ①确定分界点 ​ ②调整区间 ​ ③递归处理左右两段 Tips： ​ ①如果输入数据量比较大的话，用scanf输入更快，不要使用cin。 ​ ②只要背诵一种万能模板即可避开所有边界问题。 ​ ③考试时一般不会用到快排，面试时喜欢考察。 ​ ④ #include<bits/stdc++.h>包含了目前c++所包含的所有头文件 。 ​ ⑤分治一般用不到，只要掌握快速排序和归并排序就行。
算法基础课 模板题笔记：动态规划
www.h y p e r p l a s m a.top
04-22 1797
AcWing算法基础课 动态规划模板题笔记
C++ | Leetcode C++题解之第514题自由之路
Ddddddd_158的博客
10-27 411
C++ | Leetcode C++题解之第514题自由之路
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 394
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
最新发布
weixin_47868976的博客
10-31 724
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
【支持在线评测】二叉树计算
春秋招笔试突围
10-28 76
给定一个二叉树，请生成一个新的二叉树，使得新树中的每个节点的值等于原始树中该节点的左子树和右子树所有节点值的和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。首先，需要根据给定的中序遍历和前序遍历序列重建原始二叉树。这是因为只有重建出原始树的结构，才能正确计算每个节点的子树和。在重建树的过程中，同时计算每个节点的子树和。输出一行整数，表示生成的新二叉树（求和树）的中序遍历序列，以空格分隔。最后，对重建并计算好子树和的树进行中序遍历，输出结果。
算法笔记：Day-04（二维前缀和）
2302_78571314的博客
10-26 458
这道题真的很好，板子题😁。代码第一个方法是构造方法，构造出以左上角为a[0][0],右下角为a[i][j]的矩阵的和所构成的矩阵。然后第二个方法就可以计算任意子矩阵和了。
【深搜算法】（第四篇）
weixin_73861555的博客
10-27 1287
然⽽，通过观察我们可以发现，如果我们先删除最底部的叶⼦节点，然后再处理删除后的节点，最终的结果并不会受到影响。因此，在处理完⼦节点后，我们仍然需要处理当前节点。3. 函数作⽤：整合⽗节点的信息与当前节点的信息计算当前节点数字，并向下传递，在回溯时返回当前⼦树（当前节点作为⼦树根节点）数字和。前序遍历按照根节点、左⼦树、右⼦树的顺序遍历⼆叉树的所有节点，通常⽤于⼦节点的状态依赖于⽗节点状态的题⽬。后序遍历按照左⼦树、右⼦树、根节点的顺序遍历⼆叉树的所有节点，通常⽤于⽗节点的状态依赖于⼦节点状态的题⽬。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3670
BSP驱动开发工程师-OS、4 道编程题
保研机试Acwing算法基础课笔记精要
资源摘要信息:"保研机试，Acwing算法基础课笔记_Acwing-Basic-Notes.zip" 知识点概览： 1. 保研机试概念与重要性 2. Acwing算法平台介绍 3. 算法基础课程内容概述 4. 笔记文件结构与重点内容 5. 学习资源获取与利用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值