前言：针对明年秋招开始对算法及数据结构进行学习及复习，该贴主要通过Acwing 算法基础课，《代码随想录》，以及力扣题库进行学习，在此之前以及有一定的语言以及数据结构基础，每日将自己所刷的题目以及复习的题目进行记录，有同样需求的同学可以一起监督学习。(主要运用c、c++进行编程，期间还包括一些对语言的复习)
DAY 1
1.Acwing 846 树的重心 考察点：树与图的深度优先遍历DFS
- 基础知识：1.树是一种特殊的图 2.无向图(a-b)属于有向图(a-->b)
- 有向图的存储分为两种：1.邻接矩阵 g[a,b],不保存重边 2.邻接表(推荐使用)：其本质就是单链表，通过用多个单链表的方式将图拆解，每个单链表的头结点即为图中的每一个结点，为图中的每一个结点都开一个单链表，存储这个点可以到达的点。(一般选择头插法)
- 树与图的遍历 DFS BFS 深度优先通俗一点将就是一条路走到黑，广度优先就是一层一层遍历，但是这两种遍历方式对于每个点只会遍历一次 下面是该题的代码：分为两种，一种是DFS包括自身结点，另一种不包括
方法一：
#include<cstdio>
#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;
int ans = N;
bool st[N];
//在邻接表用头插法
void add(int a,int b)
{
e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
//深搜 dfs函数返回的是这个子节点包括其本身的节点数量
int dfs(int u)
{
st[u] = true;
int size = 0,sum = 0;
//遍历每一个头结点
for(int i = h[u];i !=-1;i = ne[i])
{
int j = e[i];//从邻接表回到图
if(st[j]) continue;
int s = dfs(j);
size = max(size,s);
sum += s;
}
size = max(size,n-sum-1);//-1是因为此时sum还没包括自身结点
ans = min(ans,size);
return sum+1;//包括自身结点
}
int main()
{
scanf("%d",&n);
memset(h,-1,sizeof h);
//生成无向图
for(int i = 0;i<n-1;i++)
{
int a,b;
scanf("%d%d",&a,&b);
add(a,b),add(b,a);
}
dfs(1);
printf("%d\n",ans);
return 0;
}
方法二 （引用acwing题解 作者：松鼠爱葡萄）
本题的本质是树的dfs， 每次dfs可以确定以u为重心的最大连通块的节点数，并且更新一下ans。
也就是说，dfs并不直接返回答案，而是在每次更新中迭代一次答案。
这样的套路会经常用到，在 树的dfs 题目中
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1e5 + 10; //数据范围是10的5次方
const int M = 2 * N; //以有向图的格式存储无向图，所以每个节点至多对应2n-2条边
int h[N]; //邻接表存储树，有n个节点，所以需要n个队列头节点
int e[M]; //存储元素
int ne[M]; //存储列表的next值
int idx; //单链表指针
int n; //题目所给的输入，n个节点
int ans = N; //表示重心的所有的子树中，最大的子树的结点数目
bool st[N]; //记录节点是否被访问过，访问过则标记为true
//a所对应的单链表中插入b a作为根
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
// dfs 框架
/*
void dfs(int u){
st[u]=true; // 标记一下，记录为已经被搜索过了，下面进行搜索过程
for(int i=h[u];i!=-1;i=ne[i]){
int j=e[i];
if(!st[j]) {
dfs(j);
}
}
}
*/
//返回以u为根的子树中节点的个数，包括u节点
int dfs(int u) {
int res = 0; //存储 删掉某个节点之后，最大的连通子图节点数
st[u] = true; //标记访问过u节点
int sum = 1; //存储 以u为根的树 的节点数, 包括u，如图中的4号节点
//访问u的每个子节点
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
//因为每个节点的编号都是不一样的，所以 用编号为下标 来标记是否被访问过
if (!st[j]) {
int s = dfs(j); // u节点的单棵子树节点数 如图中的size值
res = max(res, s); // 记录最大联通子图的节点数
sum += s; //以j为根的树 的节点数
}
}
//n-sum 如图中的n-size值，不包括根节点4；
res = max(res, n - sum); // 选择u节点为重心，最大的 连通子图节点数
ans = min(res, ans); //遍历过的假设重心中，最小的最大联通子图的 节点数
return sum;
}
int main() {
memset(h, -1, sizeof h); //初始化h数组 -1表示尾节点
cin >> n; //表示树的结点数
// 题目接下来会输入，n-1行数据，
// 树中是不存在环的，对于有n个节点的树，必定是n-1条边
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
add(a, b), add(b, a); //无向图
}
dfs(1); //可以任意选定一个节点开始 u<=n
cout << ans << endl;
return 0;
}
2. Acwing 847 图中点的层次 树与图的广度优先遍历
由于该题各个结点之间的权重均为1，故可以用宽搜来求最短距离，只有第一次遍历到的结点才是最短路径。模板如下：（伪代码）
queue<- 初始
while queue 不空
{
t<-队头
拓展t
}具体解法一如下：
#include <cstring>
#include <iostream>
using namespace std;
const int N=1e5+10;
int h[N], e[N], idx, ne[N];
int d[N]; //存储每个节点离起点的距离 d[1]=0
int n, m; //n个节点m条边
int q[N]; //存储层次遍历序列 0号节点是编号为1的节点
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; //0号节点是编号为1的节点
memset(d,-1,sizeof d);
d[1]=0; //存储每个节点离起点的距离
//当我们的队列不为空时
while(hh<=tt)
{
//取出队列头部节点
int t=q[hh++];
//遍历t节点的每一个邻边
for(int i=h[t];i!=-1;i=ne[i])
{
int j=e[i];
//如果j没有被扩展过
if(d[j]==-1)
{
d[j]=d[t]+1; //d[j]存储j节点离起点的距离，并标记为访问过
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;
}
解法二：
#include<cstdio>
#include<queue>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 100010;
int n,m;
int h[N],e[N],ne[N],idx;
int d[N];
void add(int a,int b)
{
e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
int bfs()
{
memset(d,-1,sizeof d);
queue<int> q;
d[1] = 0;
q.push(1);
while(q.size())
{
int t = q.front();
q.pop();
for(int i = h[t];i!=-1;i = ne[i])
{
int j = e[i];
if(d[j] == -1)
{
d[j] = d[t]+1;
q.push(j);
}
}
}
return d[n];
}
int main()
{
scanf("%d%d",&n,&m);
memset(h,-1,sizeof h);
for(int i = 0;i<m;i++)
{
int a,b;
scanf("%d%d",&a,&b);
add(a,b);
}
cout<<bfs()<<endl;
return 0;
}3.力扣 454 .四数相加 哈希表 map
该题不需要去重，所以大大降低了该题的难度 利用暴力法O(n^4)
哈希法：快速判断一个数是否出现过
解题步骤：因为数据类型为int，所以利用数组来存储不合适，所以选择set或者map，又因为即需要存储数值，还需要存储数值出现的次数，所以综合选择map来求解；通过将a,b分为一组，c,d分为一组一次来降低时间复杂度 首先求解a+b并且记录每组a+b出现的次数，在计算0-(c+d)并在AB组里寻找，并且用count 来记录出现的次数，值得注意的一点是，count每次加的是value的值。
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int,int>searchMap;//key:a+b的值；value:a+b数值出现的次数
//遍历A、B数组，统计两个数组元素之和及出现的次数，并放入到map
for(int a:nums1)
{
for(int b:nums2)
{
searchMap[a+b]++;
}
}
int count = 0;//统计a+b+c+d = 0 出现的次数
//在遍历C D数组时，统计0-(c+d)在map中出现的次数
for(int c:nums3)
{
for(int d:nums4)
{
if(searchMap.find(0-(c+d)) != searchMap.end())
{
count += searchMap[0-(c+d)];
}
}
}
return count;
}
};
扫一扫
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
