图的存储

使用邻接表来存储

#include <bits/stdc++.h>
using namespace std;
struct edge{
    int u,v;
};
vector<edge>e;
int n,m;//n个点，m条边

//如何证明一条边存在呢？直接枚举即可
bool find_edge(int u,int v)
{
    for(int i=1;i<=m;i++)
    if(e[i].u==u&&e[i].v==v) return true;
    return false;
}

//使用邻接表来实现这张图
int main()
{
    cin>>n>>m;
    e.resize(m+1);
    for(int i=1;i<=m;i++)
    {
        cin>>e[i].u>>e[i].v;
    }
}

使用邻接矩阵来存储

配合动态数组

#include <bits/stdc++.h>
using namespace std;

int n,m;//n个点，m条边

vector<vector<int> >adj;

bool find_edge(int u,int v)
{
    return adj[u][v];
}


//使用邻接矩阵来实现这张图
int main()
{
    cin>>n>>m;
    adj.resize(n+1);
    for(int i=1;i<=m;i++)
    {
        int u,v;
        cin>>u>>v;
        adj[u].push_back(v);
        //若为无向图 adj[v].push_back(u);
    }
}

链式前向星

1.这个知识点需要学习一下链表的知识，否则不好理解。
2.我们把每条边看成了一个结点，这个结点存v，w，next，然后head数组，每一个head[i]相当于每一条链表的头节点指向的下一个地址，i相当于第i条链表，每一条链表存的对应的边的集合，通过next连接起来。
3.建议画图去实现一下，会发现就是类似于链表的头插法。实在不会b站搜视频看看。

#include <bits/stdc++.h>
using namespace std;
const int N=1005;
int n,m,idx;
//相当于头插法
 struct Edge{
    int to;//到达点
    int w;//边权
    int next;//同一个边集合中的下一个边点索引
    //可以理解成链表中的下一个节点的地址
}edge[N];

int head[N];//i相当于第几个链表，head[i]的值相当于链表中的头节点指向的下一个节点的地址

void add(int u,int v, int w)
{
    edge[idx].to=v;
    edge[idx].w=w;
    edge[idx].next=head[u];//类似更新指针
    head[u]=idx++;//更新链表的头节点的下一个地址
    
}

int main()
{
    memset(head,-1,sizeof head);
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);//加边
        /*
        无向图
        add(u,v,w);
        add(v,u,w);
        
        */
    }
    
    //遍历所有边
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i];j!=-1;j=edge[i].next)
        {
            //添加代码
        }
    }
    
    
    
    
}

拿邻接表为例写出dfs遍历

#include <bits/stdc++.h>
using namespace std;
vector<vector<int> >edge;
bool vis[10005];
int n,m;//n个点，m条边
//用栈来实现
void dfs(int x)
{
    stack<int>st;
    st.push(x);
    vis[x]=1;
    while(!st.empty())
    {
        int from=st.top();
        st.pop();
        for(auto to:edge[from])
        {
            if(!vis[to]){
                vis[to]=true;
                st.push(to);
            }
        }
    }
    
}
/*
//写成递归
void dfs(int u)
{
    vis[u]=1;
    for(auto t:edge[u])
    {
        if(!vis[t]) dfs(t);
    }
}
*/



//使用邻接表来实现这张图
int main()
{
    cin>>n>>m;
    edge.resize(n+1);
    for(int i=1;i<=m;i++)
    {
        int u,v;
        edge[u].push_back(v);
    }
}

拿邻接表为例写出bfs遍历

#include <bits/stdc++.h>
using namespace std;
vector<vector<int> >edge;
bool vis[10005];
int n,m;//n个点，m条边
void bfs(int x)
{
    queue<int>q;
    q.push(x);
    vis[x]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(auto t:edge[u])
        {
            if(!vis[t]){
                vis[t]=1;
                q.push(v);
            }
        }
    }
    
}


int main()
{
    cin>>n>>m;
    edge.resize(n+1);
    for(int i=1;i<=m;i++)
    {
        int u,v;
        edge[u].push_back(v);
    }
}