数据结构之图（最小生成树+最短路径）

基本概念

连通：若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即可 
}