第六章 图笔记

最新推荐文章于 2024-06-25 23:08:59 发布
最新推荐文章于 2024-06-25 23:08:59 发布
阅读量188 收藏
点赞数
原文链接：http://www.cnblogs.com/dean-SunPeishuai/p/10896899.html
版权

上次老师检查笔记时，我的第五章笔记还没有整理完整，后来又进行了补充，请老师再看一看：https://www.cnblogs.com/dean-SunPeishuai/p/10674881.html

                                                                                          图

  1.邻接矩阵实现

   邻接矩阵的构建：

Mgraph<T>::Mgraph(T a[], int n, int e)//邻接矩阵的构建
{
    vertex = n;
    arcnum = e;
    for (int i = 0; i < vertexnum; i++)//初始化顶点
    {
        vertex[i] = a[i];
    }
            memset(arc,0,sizeof(arc));
            for (int i = 0; i < arcnum; i++)
            {
                int x,y;
                scanf("%d%d",&x,&y);
                    arc[x][y]=1;
                    arc[y][x]=1;
            }

}

 深度优先搜索：

template<class T>
void Mgraph<T>::DFS(int v)
{
    cout << vertex[v] << " "; visit[v] =1;
    for (int i = 0; i < vertexnum; i++)
    {
        if (arcnum[v][i] == 1 && visit[i] == 0) DFS(i);
    }

}

广度优先深搜：

template<class T>
void Mgraph<T>::BFS(int v)
{
    int Queue[MaxSize];
    int front = rear = -1;//借助数组模拟队列先进先出的功能
    cout << vertex[v] << " "; visit[v] = 1;
    Queue[++rear] = 1;
    while (front != rear)
    {
        v = queue[++front];
        for (int i = 0; i < vertexnum; i++)
        {
            if (visit[i] == 0 && arc[v][i] == 1)
            {
                cout << vertex[i] << " ";
                visit[i] = 1;
                Queue[++rear] = i;
            }
        }
    }
}

 2.邻接链表实现（未定义visit[]，仅将代码流程过一遍）

#include<bits/stdc++.h>
using namespace std;
template<class T>
struct ArcNode//边表
{
    int adjvex;
    ArcNode *next;
};
template<class T>//顶点表
struct VertexNode
{
    T vertex;
    ArcNode *firstedge;
};
const int MaxSize = 100;    //图的最大顶点数
template <class T>
class ALGraph
{
public:
    ALGraph(T a[], int n, int e);
    ~ALGraph;
    void DFSTraverse(int v);
    void BFSTraverse(int v);
private:
    VertexNode adjlist[MaxSize];
    int vertexNum, arcNum;
};
/*         构建函数          */
template<class T>
ALGraph<T>::ALGraph(T a[], int n, int e)
{
    vertexNum = n; arcNum = e;
    for (int i = 0; i < vertexNum; i++)
    {
        
        adjlist[i].vertex = a[i];
        adjlist[i].firstedge = NULL;
    }
    for (int j = 0; j < arcNum; j++)
    {
        int x, y;
        cin >> x >> y;
        s = new ArcNode<T>;//生成邻接点序号y的边表节点s
        s->adjvex = y;//j将边表s插入到第x个边表的头部
        s->next = adjlist[x].firstedge;
        djlist[x].firstedge = s;
    }
}
/*       深度优先遍历          */
template<class T>
void ALGraph<T>::DFSTraverse(int v)
{
    cout << adjlist[v].vertex;
    visit[v] = 1;
    ArcNode<T> p = adjlist[v].firstedge;
    while (p)
    {
        int j = p.adjvex;
        if (vistt[j] == 0) DFSTraverse(j);
        p = p->next;
    }

}
/*         广度优先搜索          */
template<class T>
void ALGraph<T>::BFSTraverse(int v)
{
    int Q[MaxSize];
    memset(Q, 0, sizeof(Q));
    int front = rear = -1;
    cout << adjlist[v].vertex;
    visit[v] = 1;
    Q[++rear] = v;
    while (front!=rear)
    {
        v = Q[++front];
        ArcNode<T> p = adjlist[v].firstedge;
        while (p)
        {
            int j = p->adjvex;
            if (visit[j] == 0)
            {
                cout << adjlist[j].vertex;
                visit[j] = 1;
                Q[++rear] = j;
                
            }
            p = p->next;
        }
    }
}



int main()
{

}

 prime算法：自己之前的理解

     Prime算法的思想是枚举各个点能够到到达的所有路，找出他们之间最短的，首先选择一个顶点加入生成树，然后找出一条边加入到生成树，重复n-1次，直到把所有的节点都加入到生成树中，在此算法里面需要一个dis数组，不过它和迪杰斯特拉算法的不同之处在于，迪杰斯特拉的思想是dis[i]表示从1到顶点i的最小距离，而Prime算法中,dis[i]代表每个项点到离他最近的点的距离，然后通过松弛操作得出结果 ，时间复杂度为O（N^2）。

 求最小生成树Prime模板：

using namespace std;
int dis[108],map1[108][108],vis[108];
#define INF 0x3f3f3f3f
int n;
int  prime()
{
    memset(vis,0,sizeof(vis));
    int ans=0,cnt=0,k=0,minn=INF;
    vis[1]=1;
    cnt++;
    while(cnt<n)
    {
        minn=INF;///就这个地方忘记了，然后、、、、、、
        for(int i=1;i<=n;i++)//查找没有访问过的，距离当前最小生成树最小的边
        {
            if(!vis[i]&&dis[i]<minn)
            {
                minn=dis[i];
                k=i;//标记下来边的临界点
            }
        }
        cnt++;
        vis[k]=1;//标记访问过的点
        ans+=dis[k];
 
       for(int j=1;j<=n;j++)///由于新加的点，其他的点到最下生成树的点距离可能变短，更新哪些到最小生成树变短的点
       {
          if(!vis[j]&&dis[j]>map1[k][j])
            dis[j]=map1[k][j];
       }
    }
    return ans;
}
--------------------- 
作者：sean(SunPeishuai) 
来源：CSDN 
原文：https://blog.csdn.net/SunPeishuai/article/details/84719169 
版权声明：本文为博主原创文章，转载请附上博文链接！

poj:6:prim算法求最小生成树

题目： 连接：http://sdau.openjudge.cn/graph/6/

分析：裸的最小生成树

代码：

#include<bits/stdc++.h>
using namespace std;
int dis[108], map1[108][108], vis[108];
#define INF 0x3f3f3f3f
int n, e;
void  prime()
{
    memset(vis, 0, sizeof(vis));
    int ans = 0, cnt = 0, k = 0, minn = INF;
    vis[1] = 1;
    cnt++;
    while (cnt < n)
    {
        minn = INF;///就这个地方忘记了，然后、、、、、、
        for (int i = 1; i <= n; i++)
        {
            if (!vis[i] && dis[i] < minn)
            {
                minn = dis[i];
                k = i;
            }
        }
        cout << minn << " ";
        cnt++;
        vis[k] = 1;
        ans += dis[k];
        for (int j = 1; j <= n; j++)///由于新加的点，其他的点到最下生成树的点距离可能变短，更新哪些到最小生成树变短的点
        {
            if (!vis[j] && dis[j] > map1[k][j])
                dis[j] = map1[k][j];
        }
    }
}
int main()
{

    scanf("%d%d", &n, &e);
    memset(dis, INF, sizeof(dis));
    memset(map1, INF, sizeof(map1));
    for(int i=1;i<=n;i++)
        for (int j = 1; j <= n; j++)
        {
            scanf("%d", &map1[i][j]);
        }
    for (int i = 1; i <= n; i++)
    {
        dis[i] = map1[1][i];
    }
    prime();
    cout << endl;
    system("pause");
    return 0;
}

 Kruskal算法思想：

   此算法是求最小生成树的另一只种算法，首先，将图上面的权值按照从小到大的顺序排列，最终连成n-1条边。按照排列好的顺序，在连线的过程中可能会遇到已经连通的点，需要用并查集进行辅助判断两个分量上的点是否已经联通。

此处为Kruskal以前自己总结的模板：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
#define N 100+20
#define M 100000+20
using namespace std;
struct node
{
    int x;
    int y;
    int v;
}map1[5008];
int n,m,fa[5008];
int fin(int u)
{
    if(fa[u]==u)
        return u;
    else
    {
        fa[u]=fin(fa[u]);///并查集的路径压缩
        return fa[u];
    }
}
int mix(int a,int b)
{
    int f1=fin(a);
    int f2=fin(b);
    if(f1!=f2)
    {
        fa[f2]=f1;
        return 1;
    }
    return 0;
}
int cmp(node a,node b)
{
    return a.v<b.v;
}
int main()
{
   while(scanf("%d",&n)!=EOF)
   {
       int ans=0,cnt=0;
       if(n==0) break;
       m=n*(n-1)/2;
       memset(fa,0,sizeof(fa));///
       for(int i=1;i<=m;i++)
       {
           scanf("%d%d%d",&map1[i].x,&map1[i].y,&map1[i].v);
       }
       sort(map1+1,map1+m+1,cmp);
       for(int i=1;i<=n;i++)///并查集的初始化
       {
           fa[i]=i;
       }
 
 
       //kruskal算法
       for(int i=1;i<=m;i++)///从小到达枚举边
       {
           if(mix(map1[i].x,map1[i].y))///若加的边构不成环则加上
           {
               cnt++;
               ans+=map1[i].v;
           }
           if(cnt==n-1) break;
       }
       printf("%d\n",ans);
   }
   return 0;
}
View Code

 

5:kruskal算法求最小生成树

题目：连接http://sdau.openjudge.cn/graph/5/

分析：略

代码：

#include<bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define N 100+20
#define M 100000+20
using namespace std;
struct node
{
    int x;
    int y;
    int v;
}map1[5008];
int n, m, fa[5008], map2[1000][1000];
int fin(int u)//并查集查找
{
    if (fa[u] == u)
        return u;
    else
    {
        fa[u] = fin(fa[u]);///并查集的路径压缩
        return fa[u];
    }
}
int mix(int a, int b)//连接
{
    int f1 = fin(a);
    int f2 = fin(b);
    if (f1 != f2)
    {
        fa[f2] = f1;
        if(a<b)//在此处输出一条边的两个连接点
        cout << a << " " << b << " ";
        else {
            cout << b<< " " << a<< " ";
        }
        return 1;
    }
    return 0;
}
int cmp(node a, node b)
{
    return a.v < b.v;
}
int main()
{
    int n, e, v,cnt=0;
    scanf("%d%d", &n, &e);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            scanf("%d", &map2[i][j]);
        }
    int t = 1;
    for (int i =1; i <= n-1; i++)//此处为适应模板做的适当处理
        for (int j = i+1; j <=n; j++)
        {
            map1[t].x = i; map1[t].y = j; 
            if(map2[i][j] != 0 && map2[i][j] != 100){
                map1[t].v = map2[i][j];
                t++;
            }

        }
    sort(map1 + 1, map1 + 1 + e, cmp);
    for (int i = 1; i <= n; i++) fa[i] = i;//并查集的初始化
    /*       kruskal算法      */
    for (int i = 1; i <= e; i++)//从小到大枚举边 
    {
        if(mix(map1[i].x, map1[i].y))
       {
            cnt++;
       }
        if (cnt == n - 1) break;
    }
    cout << endl;
    system("pause");
    return 0;
}

 dijkstra求最短路径：‘

题目：http://sdau.openjudge.cn/graph/1/

分析:直接套模板就行，自己之前刘汝佳的模板忘记怎么用输出路径了，尴尬。就从网上扒了一个模板改的。

代码：

#include<stdio.h>
#include<string.h>
#define INF 1e9
#define maxn 1001
bool vis[maxn];
int adj[maxn][maxn],dis[maxn],pre[maxn];//pre[]记录前驱
int n, m;
void dijkstra(int v)
{
    int i, j, u , min;
    for(i=0;i<n;i++)///v到所点的距离初始化
    {
         dis[i]=adj[v][i];
         vis[i]=0;
         if(i!=v&&adj[v][i]!=INF)pre[i] = v;
         else pre[i] = -1;
    }
    vis[v]=1;dis[v]=0;
    for(i=0;i<n;i++)
    {
        min = INF;
        for(j=0;j<n;j++)
        {
            if(!vis[j]&&min > dis[j])
            {
                min = dis[j];
                u = j;
            }
        }
        if(min == INF)break;
        vis[u]=1;
        for(j=0;j<n;j++)
        {
            if(!vis[j]&&adj[u][j]!=INF&&dis[u]+adj[u][j]<dis[j])
            {
                dis[j] = adj[u][j] + dis[u];
                pre[j] = u;
            }
        }
    }
}
int main()
{
        int start,end1, x, y, w;
        scanf("%d%d",&n,&m);///n个节点，m条边
        scanf("%d%d",&start,&end1);///起点--->终点
        for(int i=0;i<n;i++)///初始化
        {
            for(int j=0;j<n;j++)
                if(i==j)adj[i][j]=0;
                else adj[i][j] = INF;
        }
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&w);
            adj[x][y] = w;
        }
        dijkstra(start);///起点
        if(dis[end1]==1e9){
            printf("no answer\n");
        }else{
        printf("%d\n",dis[end1]);  //以下为输出路径
        int p, len=0, ans[maxn];
        p = end1;
        while(p!=0)
        {
            ans[len++] = p;
            p = pre[p];

        }
        printf("v%d ",start);
        for(int i=len-1;i>=0;i--)
            printf("v%d ",ans[i]);
        }
    return 0;
}

 floyd求最短路径

题目：http://sdau.openjudge.cn/graph/2/

分析：略

代码：

/*floyd算法，打印路径模板*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>
#define N 1005
#define INF 0x3f3f3f3f

using namespace std;

int mapp[N][N], path[N][N];//path[i][j]的含义：从i到j的路径中，i的下一个点。
int n,m;//顶点数,边数
void init()
{
    int i, j;
    for (i = 0; i < n; i++)
        for (j = 0; j <n; j++)
        {
            if (i == j)    mapp[i][j] = 0;
            else mapp[i][j] = INF;
        }
}
void floyd()
{
    for (int i = 0; i <N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            if (mapp[i][j] == INF) path[i][j] = -1;///i不能直接到j
            else path[i][j] = j;///i到j路径的下一个点为j
        }
    }
    int i, j, k;
    for (k = 0; k <n; k++)
    {
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (mapp[i][k] < INF && mapp[k][j] < INF && mapp[i][j] > mapp[i][k] + mapp[k][j])
                {
                    mapp[i][j] = mapp[i][k] + mapp[k][j];
                    path[i][j] = path[i][k];//从i到j的下一个顶点为i到k的下一个顶点
                }
            }
        }
    }
}

int main()
{
        scanf("%d%d", &n, &m);
        int a, b, c;
        init();

        for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &a, &b, &c);
            mapp[a][b]=c;//无向图
        }
        floyd();//打印路径
        int T, start, end;
        for(int i=0;i<n;i++)
        {
          for(int j=0;j<n;j++)
          {
            if(i!=j)
            {
                start=i;
                end=j;
                if(mapp[start][end]==INF)
                {
                    cout<<"no answer"<<endl;
                }
                else
                {
                    printf("%d ",mapp[start][end]);
                    int tmp = start;
                    printf("v%d ",start);
                    while (tmp!= end)
                    {
                      printf("v%d ",path[tmp][end]);
                      tmp = path[tmp][end];
                    }
                }
                 printf("\n");
              }
          }

        }
    return 0;
}

 

转载于:https://www.cnblogs.com/dean-SunPeishuai/p/10896899.html

Matlab笔记 第六章 高阶绘图
Xu_big_candy的博客
06-27 1223
B站台湾大学郭彦甫教授Matlab课程笔记（P6）
西瓜书第六章读书笔记,标题11个字
07-25
西瓜书第六章读书笔记,标题11个字
第六章笔记
qq_43239615的博客
11-28 95
数据结构第6章笔记
weixin_43467615的博客
11-28 174
@TOC
866数据结构笔记 - 第六章 图
qq_45331246的博客
11-15 2965
866数据结构、湖南大学考研、图
王道数据结构课代表 - 考研数据结构 第六章 图 究极精华总结笔记
clzZ2的博客
01-18 6527
数据结构与算法 笔记导航🚥🚥🚥 🥬 第一章 绪论 🥕 第二章 线性表 🥪 第三章 栈和队列 🍊 第四章 串-KMP(看毛片算法) 🍒 第五章 树和二叉树 🍀 第六章 图 🍚 第七章 查找(B树、散列表) 🧄 第八章 排序 (内部排序：八大排序动图演示与实现 + 外部排序) 🍔 数据结构与算法 复试精简笔记 🎨 408 全套初复试笔记汇总 传送门 🏃‍🏃‍🏃‍ 如果本篇文章对大家起到帮助的话，跪求各位帅哥美女们，求赞👍 、求收藏、求关注！
第六章数据库笔记
sdau20171747的博客
12-05 172
数据结构_笔记_第6章：图
dc12499574的博客
08-07 109
笔记
数字信号处理第一章重点复习笔记
香草味冰淇淋
06-25 1729
（1）定义：系统某时刻的输出y(n)只取决于此时刻x(n)和以前的输入x(n-1),x(n-2)…而和以后的n时刻无关；y(n)=T[x(n)] y(n-m)=T[x(n-m)] m位任意常数。两公式结合起来：y(n)=T[ax1(n)+bx2(n)]=ay1(n)+ay2(n)设序列为x(n)，则序列y(n)=x(n-m)表示将序列x(n)进行移位。（3）x(mn)和x(n/m)定义为对x(n)的时间尺度变换；设序列为x(n)，则序列y(n)=x(-n)表示以n=0的。
数据挖掘复习笔记第六章——分类
weixin_51206814的博客
11-03 870
第六章 分类 6.1 分类、回归与聚类 分类和回归是两种数据分析形式，用于提取描述重要数据类或预测未来的数据趋势的模型。 分类：预测类对象的分类标号（离散值） 回归：建立连续函数值模型 6.2 分类的应用案例 6.3 分类概念 分类过程 测试集要独立于训练样本集，否则会出现“过分拟合”(overfitting)的情况 6.4 常用的分类方法 6.4.1 K-近邻 给定一个未知样本，k-最近邻分类法搜索模式空间，找出最接近未知样本的k个训练样本；然后使用k个最临近者中最公共的类来预测当前样本
第6章 二次型
a131529的博客
06-14 1192
本笔记是对李永乐《辅导讲义》中各章节涉及的进行整理。本笔记主要用以应对夏令营面试中可能会问到的方面的问题，比较，如果您对这些内容感兴趣，建议参考原书。大佬可自行绕路。
第13章 图形用户接口-教程与笔记习题
05-19
在本章“第13章 图形用户接口-教程与笔记习题”中，我们将深入探讨在ARM9嵌入式系统设计中至关重要的图形用户接口（GUI）的概念、设计原则和实现方法。ARM9处理器是广泛应用在嵌入式领域的32位微处理器，其高效的...
四川大学《电路》考研 第十六章 傅里叶级数-教程与笔记习题
05-19
在四川大学的《电路》考研教程中，傅里叶级数是第十六章的重点内容。本章内容主要涵盖了对信号进行傅里叶级数展开的基本理论和方法，包括信号的周期延拓、三角函数展开以及指数形式的傅里叶级数等。 傅里叶级数可以...
离散数学第六章复习笔记.docx
01-13
离散数学第六章复习笔记 在离散数学中，等价关系是一个非常重要的概念。等价关系是指具有自反、对称和传递性质的关系。在集合论中，等价关系是一个基本的概念，它可以帮助我们更好地理解集合之间的关系。 首先，...
计算机网络第一章笔记.docx
07-26
以下是对计算机网络第一章笔记的详细解析： 首先，计算机网络按照作用范围分类，可以分为广域网（WAN）、城域网（MAN）、局域网（LAN）和个人区域网（PAN）。WAN覆盖广泛，通常是互联网的核心，使用高速链路。MAN...
C#ASP.NET网络进销存管理系统源码数据库 SQL2008源码类型 WebForm
最新发布
11-15
ASP.NET网络进销存管理系统源码 内含一些新技术的使用，使用的是VS .NET 2008平台采用标准的三层架构设计，采用流行的AJAX技术 使操作更加流畅，统计报表使用FLASH插件美观大方专业。适合二次开发类似项目使用，可以节省您 开发项目周期，源码统计报表部分需要自己将正常功能注释掉的源码手工取消掉注释。这是我在调试程 序时留下的。也是上传源码前的疏忽。 您下载后可以用VS2008直接打开将注释取消掉即可正常使用。 技术特点：1、采用目前最流行的.net技术实现。2、采用B/S架构，三层无限量客户端。 3、配合SQLServer2005数据库支持 4、可实现跨越地域和城市间的系统应用。 5、二级审批机制，简单快速准确。 6、销售功能手写AJAX无刷新，快速稳定。 7、统计报表采用Flash插件美观大方。8、模板式开发，能够快速进行二次开发。权限、程序页面、 基础资料部分通过后台数据库直接维护，可单独拿出继续开发其他系统 9、数据字典，模块架构图，登录页面和主页的logo图片 分别放在DOC PSD 文件夹中
(源码)基于ZooKeeper的分布式服务管理系统.zip
11-15
# 基于ZooKeeper的分布式服务管理系统 ## 项目简介 本项目是一个基于ZooKeeper的分布式服务管理系统，旨在通过ZooKeeper的协调服务功能，实现分布式环境下的服务注册、发现、配置管理以及分布式锁等功能。项目涵盖了从ZooKeeper的基本操作到实际应用场景的实现，如分布式锁、商品秒杀等。 ## 项目的主要特性和功能 1. 服务注册与发现通过ZooKeeper实现服务的动态注册与发现，支持服务的动态上下线。 2. 分布式锁利用ZooKeeper的临时顺序节点特性，实现高效的分布式锁机制，避免传统锁机制中的“羊群效应”。 3. 统一配置管理通过ZooKeeper集中管理分布式系统的配置信息，实现配置的动态更新和实时同步。 4. 商品秒杀系统结合分布式锁和ZooKeeper的监听机制，实现高并发的商品秒杀功能，确保库存的一致性和操作的原子性。 ## 安装使用步骤 1. 环境准备
23python3项目.zip
11-15
23python3项目
技术资料分享AL422B很好的技术资料.zip
11-15
技术资料分享AL422B很好的技术资料.zip
深入理解C++基础第一章精华笔记
资源摘要信息:"C++编程语言第一章笔记" 1. C++基础知识概述 C++是一种静态类型、编译式、通用的编程语言，广泛用于系统/应用软件开发、游戏开发、驱动程序、高性能服务器和客户端开发等领域。本章节主要介绍了C++的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值