基本概念
连通：若a->b存在路径，即为连通
连通图：该图中任意两点均连通，即为连通图
连通分量：下图为无向图，但存在三个连通分量
强连通图：双向的连通图
强连通分量：有向图中的双向连通
图的存储结构
邻接矩阵：顺序存储，二维数组耗费大量空间
原理：有路径flag=1，flag=0；
①无向图中为对称矩阵
②有向图中A [ i ] [ j ]，i->j 或 j->i
邻接表：链式存储+顺序存储
图的遍历
DFS
1.变量设置：
map【】【】地图数组
book【】【】标记数组
dx【】，dy【】方向数组
2.终止条件
3.核心：
标记
递归dfs
回溯（取消标记）
#include<stdio.h>
int a[110][110]; //地图,0为通路，1为障碍物
int book[110][110]; //标记数组
int minn=999999,step;
int hx,hy; //终点
int min(int a,int b)
{
return a<b?a:b;
}
void dfs(int x,int y,int step)
{
//方向数组
int dx[4]= {1,-1,0,0};
int dy[4]= {0,0,1,-1};
int tx,ty;
//终止条件
if(hx==x&&y==hy)
{
minn=min(minn,step);
return ; //回溯
}
for(int i=1; i<=4; i++)
{
int tx=x+dx[i];
int ty=y+dy[i];
if((a[tx][ty]==0)&&(book[tx][ty]==0))
{
book[tx][ty]=1; //已走标记
dfs(tx,ty,step+1);
book[tx][ty]=0; //取消标记
}
}
return ;
}
int main()
{
int n,m;
scanf("%d %d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
scanf("%d",&a[i][j]);
}
dfs(sx,sy); //起点
printf("%d",step);
} BFS
1.结构体，x,y,step
2.首先起点入队，队首向四周扩展并将点（队尾）入队，直到不能扩展则队首出队，此时队尾变为队首，重复上述操作
#include<bits/stdc++.h>
using namespace std;
int a[100][100],v[100][100];
struct point
{
int x;
int y;
int step;
};
queue<point> r;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
int main()
{
//输入
int n , m ,startx,starty,p,q;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&a[i][j]);
scanf("%d%d%d%d",&startx,&starty,&p,&q);
//BFS
point start;
start.x=startx;
start.y=starty;
start.step=0;
r.push(start);//将起点入队
v[startx][starty]=1;
int flag=0;
while(!r.empty())
{
int x=r.front().x,y=r.front().y;
if(x==p&&y==q)
{
flag=1;
printf("%d",r.front().step);
break;
}
for(int k=0;k<=3;k++)
{
int tx,ty;
tx=x+dx[k];
ty=y+dy[k];
if(a[tx][ty]==1&&v[tx][ty]==0)
{
//入队
point temp;
temp.x=tx;
temp.y=ty;
temp.step=r.front().step+1;
r.push(temp);
v[tx][ty]=1;
}
}
r.pop();//队首出队
}
if(flag==0)
printf("no answer!");
return 0;
}
/*
5 4
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3
*/
最小生成树
原理：
生成树：一个连通图的生成树是一个极小的连通子图，n个结点n-1条边；
最小生成树：边的权值之和最小的生成树，即从a->b的最短
若多一条边，则会构成回路（双向），若少一条边，则会缺一条路径；
算法实现：
Prim算法（稠密图）
从某一个单独结点开始，每次找权值最小的边，并连接其后继结点，构成整个最小生成树（n点n-1边）
#include <stdio.h>
#include <string.h>
#define INF 0x3f3f3f3f //无穷大
int n, m,a[1001][1001], dis[100001], ans;
int book[100001];
int main()
{
memset(dis, INF, sizeof(dis)); //初始化dis【】大值
dis[1] = 0; //起点自己到自己距离为0
scanf("%d %d", &n,&m);
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
scanf("%d", &a[i][j]); //二维数组存图，i->j
}
}
for(int i = 1; i <= n; i++)
{
int t = 0;
for(int j = 1; j <= n; j++)
{
if(!book[j] && dis[j] < dis[t]) //寻找未标记且权值最短边（类似kruskal找最小边）
{
t = j; //记录最短边的终点t
}
}
book[t] = 1; //标记，代表已加入最小生成树
for(int j = 1; j <= n; j++)
{
if(!book[j] && a[t][j] < dis[j]) //更新最短距离
{
dis[j] = a[t][j];
}
}
}
for(int i = 1; i <= n; i++)
{
ans +=dis[i]; //把所有在最小生成树中的点的权值加起来
}
printf("%d", ans);
return 0;
}
Kruskal算法（稀疏图）
从最小的边开始找，并连接最小边的两个结点，直到整个图形成最小生成树（n点n-1边）
#include<stdio.h>
#include<stdlib.h>
int n,m;
long long sum;
int fa[200005];
int cnt=0;
struct node
{
int x;
int y;
int z;
} a[200005];
void init(int n)
{
for(int i = 1; i <= n; i++)
{
fa[i] = i;
}
}
int find(int x)
{
if(x==fa[x])
return x;
else
return find(fa[x]);
}
int cmp(const void*a,const void*b)
{
struct node aa=*(struct node*)a;
struct node bb=*(struct node*)b;
return aa.z>bb.z?1:-1; //升序
//降序：return aa.z>bb.z?-1:1;
}
int main()
{
int v,k=0;
scanf("%d", &n);
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
scanf("%d", &v);
if(j > i) //无向存图
{
k++;
a[k].x = i;
a[k].y = j;
a[k].z = v;
}
}
}
qsort(a + 1, a + k + 1, sizeof(a[1]),cmp);//排序函数
for(int i = 1; i <= m; i++)
{
int x=find(a[i].x);
int y=find(a[i].y);
if(x!=y) //合并
{
f[y]=x;
sum+=a[i].z; //权值相加
cnt++;
}
if(cnt==n-1) //n个点，n-1条边，边用完跳出循环
break;
}
printf("lld\n",sum);
return 0;
}
0
最短路径
从a->b的权值最小的一条路径
多源Floyed
原理：利用三重循环，实时更新最短路径；
1.含义：
a【i】【j】：i--j 直接距离
a【i】【k】+ a【k】【j】：i--j 间接距离（经过k中转站）
2.解释：
求 i--j 的最短路径则讨论 i--j，i--1站点--j，i-2站点--j，i--3站点--j... ...
依次枚举比大小，实时更新
单源Dijkstra
int dijk(int from,int to) //单源点到目标点
{
int dis[N]; //距离数组
int book[N]; //标记数组
int map[N][N]; //存储两点间距离
int pos; //每次最短路径的站点
//book[from]=1; //标记起点
//初始化
memset(book,0,sizeof(book));
for(int i=1; i<=n; i++)
{
dis[i]=map[from][i]; //最初单源点到目标点的直达的距离，无中转站
}
//每次找最小边，连接其两点
for(int i=1; i<=n; i++) //遍历1-n个站点
{
int min=INF;
for(int j=1; j<=n; j++)
{
if(min>dis[j]) //每次找最小边的对应点pos
{
min=dis[j];
pos=j;
}
}
book[pos]=1; //找到并标记该点pos
for(int k=1; k<=n; k++) //列举从1-n的站点，到达pos点的最短路径
{
if((dis[pos]>dis[k]+map[k][pos])&&!book[k])
{
dis[pos]=dis[k]+map[k][pos];
}
}
}
return dis[to]; //所有站点的dis【】已经标记，找需求to即可
}
