图论基础：图存+记忆化搜索

图的储存

储存图有很多种方式，在此介绍两种：邻接数组，邻接表
第一种虽然简单，但访问的时间和空间花销过大，因此第二种最为常见。
让我们分别看看它们是什么

在介绍之前，我们先解释一下此处说的“图”是什么。

在算法领域，图一般指多个节点之间相互连接的关系。
这就是一个简单的图：

从上图可以看出，节点之间的联系可以是有向的，也可以是无向的，把图分为有向图和无向图。
节点之间的“边”可以是有长度的，也可以是无长度的，这里的长度一般被称为“权值”，把图分为有权图和无权图。
注意，权值并不一定是边的长度，也可以是和边有关的值，需要具体问题具体分析。

现在，我们来介绍一下如何储存这种点和边的关系。

邻接数组

这是最为简单的方法，使用一个二维数组去储存点和边的关系。
我们只考虑最复杂的有权有向图，至于其他类型，可以从有权有向图简化得到。如无权有向图就是把权值改为1即可。

现在用邻接数组储存 1->2，权值为3
和2->5，权值为6的两条边

p[1000][1000];
p[1][2]=3;
p[2][5]=6;

不难理解，一维下标就是出发节点，二维下标就是连接节点。
$p[i]$储存了所有与节点$i$相邻的边，由此得名邻接数组。

假如是无向边 1<->2，权值为3
和2<->5，权值为6，只需正反都存一次即可。可视作无向边就是从那个节点出发都可以抵达另一个节点。

p[1000][1000];
p[1][2]=3;
p[2][1]=3;
p[2][5]=6;
p[5][2]=6;

邻接表

可以看出，邻接表访问的时间复杂度极其夸张，尤其当边比较稀疏时。
如果有一万个节点，那么我想知道节点A连的边就要把$dp[A]$的一万个节点全部遍历一次，而其中很多次遍历都毫无意义。

因此，我们试想，有没有一种结构可以把所有边紧密的连接在一起呢？

邻接表正是这种数据结果。它用一种链式结构来储存边，只需要遍历这个链式结构即可。
一般我们使用$vector<T>$来实现

vector<int> p[10000];//无权值边
//存入3->5,4->7
p[3].push_back(5);
p[4].push_back(7)
struct edge{int to;int len;
};
vector<edge> p[10000];//有权值边
//存入3->5,权值为8
p[3].push_back({5,8});

图的遍历

我们遍历一张图，通常采用DFS和BFS等方式。
我们需要根据具体问题，选择以什么方式遍历这张图能得到更好的答案。
例如，当问题需要遍历完一整个分支才能得到答案，优先选择DFS
而按层级优先的问题优先选择BFS。
DFS往往简单一点

P5318 【深基18.例3】查找文献

题目描述

小 K 喜欢翻看洛谷博客获取知识。每篇文章可能会有若干个（也有可能没有）参考文献的链接指向别的博客文章。小 K 求知欲旺盛，如果他看了某篇文章，那么他一定会去看这篇文章的参考文献（如果他之前已经看过这篇参考文献的话就不用再看它了）。

假设洛谷博客里面一共有 $n(n\le 10^5)$ 篇文章（编号为 1 到 $n$）以及 $m(m\le 10^6)$ 条参考文献引用关系。目前小 K 已经打开了编号为 1 的一篇文章，请帮助小 K 设计一种方法，使小 K 可以不重复、不遗漏的看完所有他能看到的文章。

这边是已经整理好的参考文献关系图，其中，文献 X → Y 表示文章 X 有参考文献 Y。不保证编号为 1 的文章没有被其他文章引用。

请对这个图分别进行 DFS 和 BFS，并输出遍历结果。如果有很多篇文章可以参阅，请先看编号较小的那篇(因此你可能需要先排序)。

输入格式

共 $m+1$ 行，第 1 行为 2 个数，$n$ 和 $m$，分别表示一共有 $n(n\le 10^5)$ 篇文章（编号为 1 到 $n$）以及$m(m\le 10^6)$ 条参考文献引用关系。

接下来 $m$ 行，每行有两个整数 $X,Y$ 表示文章 X 有参考文献 Y。

输出格式

共 2 行。
第一行为 DFS 遍历结果，第二行为 BFS 遍历结果。

输入输出样例 #1

输入 #1

8 9
1 2
1 3
1 4
2 5
2 6
3 7
4 7
4 8
7 8

输出 #1

1 2 5 6 3 7 8 4 
1 2 3 4 5 6 7 8

题解：
这是一个比较简单的题目，要求我们使用两种方法遍历这个图，较为简单，可以作为大家了解图论的第一步。
遍历方法是DFS和BFS，DFS的大致思路是一直递归到尽头后返回，继续探索后面的支路。
BFS的大致思路是逐层遍历，把每层的节点轮流入队。
具体思路可见上次发的文章。
BFS/DFS

#include<bits/stdc++.h>
using namespace std;
vector<int> p[100001];
int vis[100001];
void dfs(int now){vis[now]=1;vector<int>&temp=p[now];cout<<now<<" ";for(int& a:temp){if(vis[a]) continue;dfs(a);}return;
}
void bfs(const int& start){queue<int> q;q.push(start);cout<<start<<" ";vis[start]=1;while(q.size()){int now=q.front();//现在的文章的编号q.pop();for(auto&a:p[now]){//遍历每一个参考资料if(!vis[a]){cout<<a<<" ";vis[a]=1;q.push(a);}}}
}
int main(){int n,m;scanf("%d%d",&n,&m);for(int i=0;i<m;i++){int x,y;scanf("%d%d",&x,&y);vector<int>& temp=p[x];temp.push_back(y);}for(int i=1;i<=n;i++)sort(p[i].begin(),p[i].end());dfs(1);memset(vis,0,sizeof(vis));printf("\n");bfs(1);return 0;
}

P3916 图的遍历

题目描述

给出 $N$ 个点，$M$ 条边的有向图，对于每个点 $v$，求 $A(v)$ 表示从点 $v$ 出发，能到达的编号最大的点。

输入格式

第 $1$ 行 $2$ 个整数 $N,M$，表示点数和边数。

接下来 $M$ 行，每行 $2$ 个整数 $U_i,V_i$，表示边 $(U_i,V_i)$。点用 $1,2,\dots ,N$ 编号。

输出格式

一行 $N$ 个整数 $A(1),A(2),\dots ,A(N)$。

输入输出样例 #1

输入 #1

4 3
1 2
2 4
4 3

输出 #1

4 4 3 4

说明/提示

• 对于 $60\%$ 的数据，$1\le N,M\le 10^3$。
• 对于 $100\%$ 的数据，$1\le N,M\le 10^5$。

题解：
此题很明显需要用DFS，因为需要遍历完整个分支才能得到答案。

但是DFS遍历有两个劣势。第一个是非常容易超时，尤其是已经在已经访问过的节点需要重复访问的时候。

面对第一个问题，可以尝试记忆化搜索，也就是DFS+DP。

记忆化搜索的思路是，我把每个点可以到达的最大值记录下来，再return给上层的点知道。

这样下次需要遍历这个结构的时候，我只需要调用记录好的最大值就可以了，非常方便。

但是此题并不是有向无环图（DAG）。有环形结构，就会导致DFS在获取下层点数据的时候，返回会获取到上层点（请读者自行构想一个环形结构）
因此无法记忆化搜索。

那么如何避免这个问题？

既然找最大点那么麻烦，那就让最大点去找子结构吧！

这样我们只需要遍历整张图一次就可以，因为从大点开始遍历它的上层点的话，剩余的小点必定无法影响这个结果，不需要重复遍历。

也因此，我们需要反向建有向边，更便于大点去找上层结构。

#include<bits/stdc++.h>
using namespace std;
const int MAXN=100005;
int n,m;
vector<int> points[MAXN];
bool vis[MAXN];
int maxs[MAXN];void dfs(int start,int now){vector<int>& nowTos=points[now];vis[now]=1;for(int i=0,len=nowTos.size();i<len;i++){if(vis[nowTos[i]]){continue;}maxs[nowTos[i]]=start;dfs(start,nowTos[i]);}}int main(){cin>>n>>m;for(int i=0;i<m;i++){int x,y;cin>>x>>y;points[y].push_back(x);}for(int i=1;i<=n;i++)maxs[i]=i;for(int i=n;i>=1;i--){//让大点先去告诉子点，这样既不关心路径尽头是不是环形//（因为更新的值是一开始就注定的），也不用处理其他点dfs的遍历，因为越大的点优先级越高，从n遍历到1即可dfs(i,i);}for(int i=1;i<=n;i++)cout<<maxs[i]<<" ";return 0;
}

记忆化搜索

P1113 杂务

思路：

分析题目可知，此为有向无环图（DAG）

每项任务完成的最短时间，必定是前驱任务中最长时间的一项加上完成本项任务本身（其他快于最长前驱任务的可以同时完成）

而前驱任务的时长也可由此得出，并且满足动态规划的无后效性和最优子结构，故可以尝试DFS+dp记忆化搜索。

递推方程是 $dp[i]=dp[i]+max(dp[i的子节点])$

经过上面的分析，我们发现让前置任务较多的任务位于树形结构的上层更有利于DFS，（可以直接在循环内去找下层最大值）因此也采用反向建边的策略。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int MAXN=10005;
vector<int> points[MAXN];
int vis[MAXN];
int dp[MAXN];
int n;
int totoalMax=0;
void dfs(int i){//遍历下层，维护下层最大值，然后加上vector<int>& tos=points[i];int maxNum=0;for(int i=0,sz=tos.size();i<sz;i++){if(vis[tos[i]]){maxNum=max(dp[tos[i]],maxNum);continue;}dfs(tos[i]);}dp[i]+=maxNum;totoalMax=max(totoalMax,dp[i]);vis[i]=1;return;
}int main(){cin>>n;for(int i=1;i<=n;i++){int x,xt;cin>>x>>xt;dp[x]=xt;//初始化时间int temp;cin>>temp;while(temp){//建temp到x的反向边，防备反向遍历points[temp].push_back(x);cin>>temp;}}for(int i=n;i>0;i--){dfs(i);}cout<<totoalMax;return 0;
}

补充练习： P4017 最大食物链计数

题目背景

你知道食物链吗？Delia 生物考试的时候，数食物链条数的题目全都错了，因为她总是重复数了几条或漏掉了几条。于是她来就来求助你，然而你也不会啊！写一个程序来帮帮她吧。

题目描述

给你一个食物网，你要求出这个食物网中最大食物链的数量。

（这里的“最大食物链”，指的是生物学意义上的食物链，即最左端是不会捕食其他生物的生产者，最右端是不会被其他生物捕食的消费者。）

Delia 非常急，所以你只有 $1$ 秒的时间。

由于这个结果可能过大，你只需要输出总数模上 $80112002$ 的结果。

输入格式

第一行，两个正整数 $n、m$，表示生物种类 $n$ 和吃与被吃的关系数 $m$。

接下来 $m$ 行，每行两个正整数，表示被吃的生物A和吃A的生物B。

输出格式

一行一个整数，为最大食物链数量模上 $80112002$ 的结果。

输入输出样例 #1

输入 #1

5 7
1 2
1 3
2 3
3 5
2 5
4 5
3 4

输出 #1

5

说明/提示

各测试点满足以下约定：

【补充说明】

数据中不会出现环，满足生物学的要求。（感谢 @AKEE ）
本题仍然满足有向无环图，可以用与上题类似的思路解决，不过多赘述。

另外，本题数据规模较大，但记忆化搜索可以轻松通过，可见其在时间复杂度上的优越性。

代码：

#include<bits/stdc++.h>
using namespace std;
const int MOD=80112002;
const int MAXN=5005;
vector<int> p[MAXN];
int vis[MAXN],dp[MAXN];
int n,m,ans;
int dfs(int now){if(dp[now])return dp[now];vector<int>& tos=p[now];int len=tos.size();int tempAns=0;if(len==0){dp[now]=1;return 1;}for(int i=0;i<len;i++){tempAns=(tempAns+dfs(tos[i])%MOD)%MOD;}dp[now]=tempAns;return tempAns;
}
//寻找0入度的点：主函数循环+vis数组
int main(){cin>>n>>m;for(int i=0;i<m;i++){int a,b;cin>>a>>b;//b吃avis[a]=1;p[b].push_back(a);}for(int i=1;i<=n;i++){//无法确保1是0入度的if(vis[i])continue;ans=(ans+dfs(i)%MOD)%MOD;}cout<<ans;return 0;
}