java算法竞赛图论必备技能-＞链式前向星 及 三种常见图的存储方式

最新推荐文章于 2022-11-25 22:27:03 发布
最新推荐文章于 2022-11-25 22:27:03 发布
阅读量572 收藏 7
点赞数
分类专栏： 个人记录 文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58428691/article/details/127979822
版权

        与其说java，不如说几乎所有算法竞赛中链式前向星是必不可少的技巧。其用途就是使用最少的空间来存储图，同时加快遍历速度。比如下面这组数据

第一行为三个正整数 n, m, s。
第二行起 m 行，每行三个非负整数 ui, vi, wi，表示从 ui 到 vi 有一条权值为 wi 的有向边。
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

        这里先讲一下邻接表和邻接矩阵，若直击链式前向星请看最后面部分。 

一. 邻接矩阵

        邻接矩阵是最简单的存储图的方式，直接开一个二维数组 int[][] g = new int[?][?] 进行图的存储。g[i][j] 表示结点 i 和结点 j 之间存在路径的情况，无权图中，0表示不存在路径，1表示存在路径。有权图中0表示不存在路径，0以外的数表示该路径的权值。

        邻接矩阵的优点很明显，就是简便。问题就是占用空间较大，遍历耗时长。打个比方，假如1≤n≤10000； 那么开出来的数组为 int[][] g = new int[10001][10001]，大小为10000*10000，占用了很大的空间。遍历图的时候，由于存储了很多无用的信息，会导致遍历的时候浪费了很多时间。

public class Main {
    static int n,m;
    static int[][] g = new int[10001][10001];
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        n=sc.nextInt();
        m=sc.nextInt();
        //有向图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            g[u][v]=1;
        }
        //无向图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            g[u][v]=1;
            g[v][u]=1;
        }
        //有向 有权 图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            int w=sc.nextInt();
            g[u][v]=w;
        }
        //无向 无权 图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            int w=sc.nextInt();
            g[u][v]=w;
            g[v][u]=w;
        }
    }
}

二. 邻接表

        不像c++那样可以使用vector，在java中vector几乎很少使用，至少目前来说我还没见过用vector的。一个很好的解决方式是用ArrayList。邻接表原理很简单，每一个1到n的结点都是一个单独的头结点，各种形成链表。每一个结点所连通的结点，都记录在该节点所形成的链表里面。也就是说，我们只记录可以去到的结点，那些无法直接到达的结点不记录，相当于只记录邻接矩阵中 g[i][j] == 1 的结点（i,j），g[i][j] == 0 的话，这个结点就不记录。在算法竞赛中我们就没有必要使用链表了，直接使用ArrayList效率一样的。

        邻接表占用空间明显比邻接矩阵少，而且只存储了有效信息，遍历速度也快很多。

无权图：

public class Main {
    static int n,m;
    static List<List<Integer>> g = new ArrayList<>();
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=0;i<=n;i++) g.add(new ArrayList<>());
        //无权 有向图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            g.get(u).add(v);
        }
        /*
        //无权 无向图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            g.get(u).add(v);
            g.get(v).add(u);
        }
        */
    }
}

        有权图麻烦一些，因为要记录权值，我们需要定义一个class，用来记录 可以到达的点 和 这一条边的权值 ，其实就是记录边的信息。

class node{
    int v;
    int w;
    public node(int v,int w){
        this.v=v;
        this.w=w;
    }
}

public class Main {
    static int n,m;
    static List<List<node>> g = new ArrayList<>();
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=0;i<=n;i++) g.add(new ArrayList<>());
        //有权 有向图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            int w=sc.nextInt();
            g.get(u).add(new node(v,w));
        }
        /*
        //有权 无向图
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            int w=sc.nextInt();
            g.get(u).add(new node(v,w));
            g.get(v).add(new node(u,w));
        }
        */
    }
}

三. 链式前向星

        链式前向星可以说是最好的存储图的方式了，虽然比前面两种复杂不少，但是空间使用 和 遍历效率都是极限的存在。很多难一点的图论算法题几乎都可以使用它，甚至有些不用它的话会运行超时。而对于天生就比c++慢很多的java而言，链式前向星无疑是救星！链式前向星和邻接表非常相似，c++里面可以使用结构体来构造前向星，但是java与之对应的class太臃肿，每一个class在堆中都要new出来，非常消耗性能。数据稍微大一点的题目，java直接鸡鸡。这时候最原始的数组表示法就来了！！！       

        下面是 有权有向图 的存储（其他形式的图的存储都可以从这里推出来，不多bb）：

public class Main {
    static int N = 10001;
    static int M = 10001;
    static int n,m,cnt;
    static int[] vv = new int[M];    //存储点u可以直接到达的点，相当于存储边
    static int[] ww = new int[M];    //存储边的权值
    static int[] to = new int[M];    //用于连接同一个点u可以直接到达的点
    static int[] he = new int[N];    //用于存储遍历的第一个点的信息
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            int w=sc.nextInt();
            addEdge(u,v,w);
        }
    }

    public static void addEdge(int u,int v,int w) {
        vv[++cnt] = v;
        ww[cnt]=w;
        to[cnt] = he[u];
        he[u] = cnt;
    }
}

        那么链式前向星究竟是如何存储图的呢，强烈建议把上面的数据自己模拟一下。只可意会不可言传，模拟一遍数据之后读者就恍然大悟了！

第一行为三个正整数 n, m, s。
第二行起 m 行，每行三个非负整数 ui, vi, wi，表示从 ui 到 vi 有一条权值为 wi 的有向边。
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

        那么，我们又该如何遍历图呢？

public class Main {
    static int N = 10001;
    static int M = 10001;
    static int n,m,cnt;
    static int[] vv = new int[M];
    static int[] ww = new int[M];
    static int[] to = new int[M];
    static int[] he = new int[N];
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=1;i<=m;i++){
            int u=sc.nextInt();
            int v=sc.nextInt();
            int w=sc.nextInt();
            addEdge(u,v,w);
        }
        
        for(int u=1;u<=n;u++){
            //u是当前结点
            for(int i=he[u];i>0;i=to[i]){
                //int i=he[u];i>0;i=to[i] ,这一段的意思是遍历u结点所有直接相连通的结点
                int v=vv[i];    //v就是u结点直接连通的结点
                int w=ww[i];    //w是u->v这条边的权值
            }
        }
    }

    public static void addEdge(int u,int v,int w) {
        vv[++cnt] = v;
        ww[cnt]=w;
        to[cnt] = he[u];
        he[u] = cnt;
    }
}

        不理解的小伙伴再模拟一遍数据吧！！！

       over！！！

玛卡左家陇分卡
关注
专栏目录
链式前向星——最完美图解
rainchxy的博客
05-18 8283
图的存储方法很多，最常见的除了邻接矩阵、邻接表和边集数组外，还有链式前向星。链式前向星是一种静态链表存储，用边集数组和邻接表相结合，可以快速访问一个顶点的所有邻接点，在算法竞赛中广泛应用。 链式前向星存储包括两种结构： 边集数组：edge[ ]，edge[i]表示第i条边； 头结点数组：head[ ]，head[i]存以i为起点的第一条边的下标(在edge[]中的下标) struct node{ int to,next,w; }edge[maxe];//边集数组，边数一般要设置比ma...
DIJ --迪杰斯特拉最短路算法 c++ 链式前向星优化
weixin_46732865的博客
05-09 713
本文首先讲解原理 后讲解源代码 原理 DIJ算法，迪杰斯特拉算法，求最短路径 给出一张图，给出各个点间的距离（不能到达视为无穷大），给出一个顶点，将之视为出发点，求出这个点到其余所有点的最短路径。 思想介绍 两个集合 S 和U ，S集合最开始只有给定的出发点，U集合是除了出发点之外的所有点。U集合中所有点都表示为 距离出发点距离xxx的点， 例如 S{A} U{ B(4),C(7),D(无穷大）}这样表示 最开始把U中距离出发点最小的加入到S集合中，并且要审查U中集合是否因为S集合中点的加入，使
用链式前向星存储图
寻找快乐
08-04 753
图最常用的存储结构主要是邻接矩阵和邻接表。当顶点数太大时，用二维数组表示的邻接矩阵可能超内存（MLE），而用邻接表的编码工作量较大，此时，使用vector数组或链式前向星模拟邻接表是不错的选择。因vector数组容易理解，这里仅介绍链式前向星存储图。 设有向图的顶点数n=5，边数m=10，输入的边用三个整数from, to, w，分别表示一条边的起点（弧尾顶点）、终点（弧头顶点），边上的权值。输入的10条边如下： 3 4 7 4 1 3 1 3 5 2 4 8 3 2 5...
链式前向星(java)实现
qq_35866365的博客
11-13 327
这个先上代码吧 void add(int i, int j){ expand(i), expand(j); to.push_back(j);//和next里面对应着变的结束定点 next.put_back(info[i]);//这边是记录对应定点前最后一条边的位置 info[i] = to.size()-1;//更新当前的最后位置 } 这个是增加一条边，虽然也就几行，但是理解起来确实蛮难的。...
java链式前向星
weixin_45665566的博客
06-16 297
这是java的链式前向星，存图非常好用。 不带权： static int next[]=new int[N],to[]=new int[N],h[]=new int[N],idx=0; //注意：h数组初始化时全部为-1 static void add(int a,int b) { to[idx]=b;next[idx]=h[a];h[a]=idx++; } 带权： static int next[]=new int[N],to[]=new int[N]，w[]=new int[N],h[]=
图的存储（链式前向星）
智障
08-18 4928
/*所谓的这种存储边的方法，就是邻接链表在的静态实现（人称：池子法） *就是比较省时间开销 */ #include #include #define MAXM 1000005 #define MAXN 10005 struct node { int v, w, pre; }edge[MAXM<<1]; int p[MAXN], nEdge; //p每个点相关边的起始位置，nEdg
链式前向星代码实现
菜鸡的博客
08-22 693
代码： #include<bits/stdc++.h> const int maxx=100010; using namespace std; struct node { int to;//表示第i条边的终点 int next;//表示与第i条边同起点的下一条边的存储位置 int w;//权值 } edge[maxx]; int head[maxx]; i...
cpp代码-链式前向星模板
07-16
链式前向星模板是图论算法中常用的一种数据结构设计，主要应用于邻接表表示图，特别是有向图和无向图。在C++编程中，它可以帮助我们高效地处理图的各种操作，如添加边、查找边以及进行深度优先搜索（DFS）和广度优先...
链式前向星_链式前向星_星_
10-03
链式前向星是一种在图论中用于存储图数据结构的方法，尤其适用于稀疏图（边的数量远小于顶点数量的平方）。它以高效的空间利用率和便捷的边操作著称，是图算法实现中的常见选择。 在传统的邻接矩阵表示法中，一个图...
图论——链式前向星（个人认为比较易懂的理解方式）
qq_35501306的博客
05-22 2863
目录链式前向星概括链式前向星范例链式前向星实现完整代码样例输入样例输出 链式前向星概括 以同起点为一条链，数组head[a]存储起点a的最新录入的一条边的索引，每条边以结构体的形式存储该边信息（该边终点，权值，同起点的边中的上一条边即上一次录入的边的位置），所有边构成一个结构体数组。 很多帖子说到的是存储的是下一条边，这种理解很容易给人误导，应该是每一条边都能通过自身结构体存储的信息回溯到上一条边，所以叫前向星。 假如我们要找出一条a -> b的边，先根据head[a]找出从起点a出发的所有边里最新录
# 快速看懂链式向前星（JAVA实现）、构建图
qq_37795916的博客
03-29 1265
快速看懂链式向前星（JAVA实现） 1.概念 它是一种存储图数据的一种方法，使用它可以轻易完成图的构建。相比于邻接矩阵更容易实现，只是不如邻接矩阵灵活。它和邻接表类似，只不过它是用的头插法，每个点形成的链条顺序和邻接表相反。 它由边集数组edges[]和头结点head[]数组构成 edges[i]表示数组中存放的第 i 条边，head[i]表示以i为起点的第一条边的下标，比如2这个点，以他为起点有两条边，假设边输入顺序为1->2(第0条边)、2->3(第1条边)、2->4(第2条边
链式前向星
Geek_sun的博客
02-29 321
Nodes from the Root Time Limit : 3000/1000ms (Java/Other)Memory Limit : 65535/32768K (Java/Other) Total Submission(s) : 40Accepted Submission(s) : 9 Font:Times New Roman|Verdana|Georgia ...
链式前向星存储图
Wuko666的博客
01-10 971
第七天链式前向星存图 图片如下所示 本代码存的是有向图，图示为无向图。 #include<iostream> using namespace std; const int maxn = 100; struct node//to 边的终点编号，w 权值， next 以 x 为起点的上一条边的编号 { int to,w,next; }e[maxn]; //head[]数组下标表示起点编号，head[]数组里面的值表示在e[maxn]中开始的下标编号 int cnt, head[maxn];
链式前向星及其简单应用
JSPang的博客
05-12 816
Djisktra + 链式前向星建图 + PriorityQueue堆优化【附Java代码模板题解】
最新发布
仰望天空，妳我亦是行人.
11-25 1337
朴素算法的时间复杂度是n的平方，而一般题目给的数据都是差不多le5,这时候肯定会爆用堆优化来降低时间复杂度时间复杂度降到nlogn+m。
图的存储——链式前向星
Happig的博客
02-05 440
前向星 前向星是一种特殊的边集数组,我们把边集数组中的每一条边按照起点从小到大排序,如果起点相同就按照终点从小到大排序,并记录下以某个点为起点的所有边在数组中的起始位置和存储长度,那么前向星就构造好了 以下图为例构造前向星： len[i]记录所有以i为起点的边在数组中的存储长度 head[i]记录以i为起点的边集在数组中的第一个存储位置 利用前向星，我们可以O(len[i])的时间找到以i为起...
Java实现链式向前向星与spfa
qq_42728686的博客
06-17 235
import java.util.*; class node{ int to; int v; int next; int form; } public class hello{ static int [] head= new int [10000]; static int cnt=0; static int [] inq = new int [10000]; static node [] e =new node[10000]; st.
链式前向星教学
PK__PK的博客
11-03 2196
链式前向星：这是一种存图结构，也被称为静态建表存图的方式，它是一种在时间和空间上最优的存图结构。无论是建图还是遍历图效率最高的存图的方式。 数据结构： struct Edgenode{ int to; int w; int next; }; int head[n]; EdgeNode Edges[m]; Edgendoe结构体中，有三个变量，第一个变量to，代表这条边的终点在哪，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玛卡左家陇分卡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值