We start from the previous diagram and add weight costs on every single edge. The graph is a tuple consisting of a vertex list and an edge list. Vertices are listed from left to right. Edges are stored as triples with starting node, ending node, and weight.

We build the edge list by scanning nodes left to right so each undirected edge appears only once. Then we convert the representation to use indexes instead of node values. This lets you jump to any node in constant time when using a vector or array for the vertex list.

This makes operations on edges and nodes much faster than linear scans for both. Next up: directed graphs, both unweighted and weighted.

0:00 Introduction to Weighted Graphs
1:00 Adding Edge Weights
3:16 Creating the Vertex List
5:19 Building the Edge List
10:34 Completing the Value-Based List
10:44 Why Value-Based Is Slow
13:04 Converting to Index-Based
15:29 Benefits of Index Lookups
17:49 Wrap-Up and Next Videos
18:22 Thank You and Outro

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hey there! Hello there. Hey there. In the last video we talked about representing

an unweighted and undirected graph using the edge list representation inside your

machine. Now let’s talk about how to do that exact same thing with undirected

weighted graphs.

seeing on the screen right now is basically the last diagram that I drew on my previous video

where we talked about how to represent unweighted undirected graphs in the machine. You don’t

necessarily need to watch that video to understand this video but you probably want to watch a few

of my other previous graph videos to know the basics of graphs and edge lists and edge-based

paths and node-based paths and all that stuff. So for now I’m just going to continue from this

document. So let’s see, I’m going to duplicate

I’m going to duplicate this real fast I am going to just kind of modify the captions here because

we’re not going to do unweighted anywhere we’re going to say a weighted undirected graph did I

get that backwards I think sometimes people say undirected and then the weighted part after so

I’m just going to I’m just going to change it so it’s still undirected which means the edges don’t

have arrows so that’s fine but it’s going to be weighted now which means I have to assign a cost

of traveling along every single edge.

So I am going to just

so i am going to just sort of like erase a bunch of this stuff real fast erase these notations

uh you know what i’m going to erase all of this because i want you to you know see it

from start to finish okay so now i’m going to add weight costs on every single edge

um in the last video what i mentioned is that the the edge list representation of a graph in

the machine uh is basically your graph is a tuple that’s the orange you know marking

a tuple that’s the orange you know markings up here your graph is a tuple where the tuple consists

of a vertex list and also an edge list so we’ll do that from scratch together again but um let

me get the weights on there first what color do you want i don’t know i’m going to put arbitrary

numbers on all the edges just to say that every edge has a cost remember in a graph when you

travel along an edge if the edge has a weight then you consider that weight to be part of the cost

usually of traveling there so like if this was a network diagram

traveling there so like if this was a network diagram maybe these weights represent pings or

lags or bandwidth cost or something like that if this is like an airport diagram maybe the weights

represent gasoline or time or something like that so i’m going to do like four there we can repeat

weights if we really want to i’m going to line this up a little bit better that 12 looks gross

okay i think we’re okay now i have 14 all right did i forget anything raise your hand if i forgot

something

raise your hand if i forgot something oh i forgot okay did you raise your hand okay

i’m going to do the 13 and 6 uh let’s just put a 2 weight there you could put ones everywhere

if you wanted to i mean any any number is fine um also in an unweighted graph you kind of can

consider the number of hops to be a path cost which means you can kind of consider every uh

edge to just have a weight of one but for now we’re just gonna say this is the weighted graph

Okay, so the first…

okay so the first thing we need to do uh after that is make a vertex list so our vertex list

is just going to be a list of all of our vertices all of our nodes in the graph

how do we list them so for starters like we usually say vertex list but for me personally

this this particular data structure just that we’re going to type up on the bottom

i usually like to consider that a vector or an array at least because you can jump into a

Thank you.

uh because you can jump into a specific index in constant time which is really really fast if you

don’t know uh big o and time complexities check out my other videos but um it’s just really really

fast to jump to an index when you’re using an array or a vector but it’s kind of slow when

you’re using an actual linked list or some other data structure that makes you scan through it so

i’m going to say that my vertex list is actually a vector but i’ll keep calling it a list anyway

so we got the vertices uh we have to start naming them okay so the first thing is i’m going to do

we got the three there and we got the 13 and we got the 6 and the 12 and the 15 i’m just naming

all of the nodes in my graph i like to go from left to right because that makes it easier for

me to debug what i’m doing um you probably in your code i said this in the last video you probably

don’t want to store the actual value in your vertex list you probably actually want to create

an object of type node or of type vertex and give it the template data

and give it the template data type of in this case integer and then set the 13 inside of the class

it’s not as fast and memory efficient as just putting a number there but uh you know for me

i like more flexibility and i like to be able to do more powerful things with my stuff so i’m going

to say that 13 and all of the other nodes really that represents to me i made a brand new instance

of a class called node or vertex and then i set it up however i wanted and one of the things i did

set it up, we’ll stick to number 30.

things i did to set it up we’ll stick the number 13 inside of the class but for the for the diagram

it’s fine like this okay so we have our vertex list that’s the v if you’re looking at the uh

you know the v comma e the v part now we need to do the edge list so i’m going to say here’s my

edge list and we’re going to use the edge list representation like i talked about in previous

videos, which is basically a tuple where one tuple describes one edge. So in our

So, in our graph that we have right now, we definitely need a starting point and an ending point.

So, let me just start by looking at the 3 node, and I want to describe one of the edges for the 3.

So, the 3 goes to the 18 and the 13 and the 12.

I’m going to scan my eyes from left to right to make it a little more simple.

So, the 3 node, it connects to the 13 node, so I’m going to put a 3, 13.

the nodes doesn’t matter in an undirected graph so i could have easily put 13 and 3 it’s fine

you don’t want to duplicate it by putting 13 comma 3 sorry you don’t want to put 3 comma 13 and then

later put 13 comma 3. you don’t want to double it up because that would be like representing two

separate edges i’m just going to sort it in my mind before so that i don’t have to sort it again

later when i’m reading the graph which makes it faster for read operations but so 3 goes to 13

And then we have to represent the weight, so the tuple gets a little more complicated.

so the tuple gets a little more complicated than the last video just by a little bit i’m going to

say 3 comma 13 comma the weight which is just a 1 here and i think i mentioned this in my other

videos like a while back but uh the weight doesn’t have to be integer it could be a float it could be

any data type you wanted really as long as your algorithms support it and you have you know your

operator overloads all done and all that could be a full class just for the weight if you wanted to

but for this video it’s just going to be the weight is an integer so that’s the cost of

traveling

is an integer so that’s the cost of traveling along that one edge so notice how all of our

tuples have three items each it’s a triple tuple so i’m going to continue trying to represent uh

what the three touches so the three uh it touches the 13 and it also touches the 12 so i’m going to

say 3 goes to 12. what does that edge cost it costs us six because that’s the little pink six

there we’re done with that tuple so what else does three touch uh touches the 13 and then it touches

the

touches the 13 and then it touches the uh 12 and then it touches the 18. so i’m going to put an 18

there what does that edge cost it costs a four because there’s a pink little four at the very

top of the graph surprise you didn’t know that okay so then uh i’m sorry we’re going to move on

to the next node so we did the three already so i’m done with that i’m going to look at the 13.

where does the 13 connect it connects to the three but that’s to the left

because i’m this is why i like to scan my eyes from left to right i already know stuff on the

left is handled i don’t have to do it again so forget about the three i already described it

up here in the very first tuple three comma thirteen comma one i don’t want to describe it

again so forget about the three now the thirteen connects to the six so thirteen comma six and what

does that cost it costed two for our arbitrary labeling thirteen doesn’t touch any other node

so we’re done with the thirteen row and by the way i’m doing a line new lines here you don’t have to

to do that, I just

here you don’t have to do that i just like to i like to do one you know row per per start node

to make it look cooler and nicer okay so the uh 13 is done now let’s do the six

six touches the 13 but remember in the previous row we just handled that so i’m not going to do

it again the six to the right touches three other nodes you can see there are three lines

protruding on the right side of the six so um i’m just going to take those from left to right

It’s.

I’m just going to take those from left to right.

It’s touching the 12 at a cost of 14.

The 6 is also touching the 15 at a cost of 12, I think.

And the 6, you know, if I make mistakes, just leave it in a comment.

I will leave the video up so you can always remember my humiliation.

But I’m going to try my best.

I did not practice this.

6 touches the 15, and then the 6 touches the 18.

So 6 touches 18, and then it costs 9.

So now we’re probably done with the 6.

we’re probably done with the six um moving on uh one node to the right now we’re going to look at

the 12 okay so the 12 it touches 3 and 13 and 6 but those are already handled so forget it

the 12 touches the 15 we did not handle that right yeah because we’re going from left to right

uh and and then it costs us from going from 12 what am i doing it doesn’t touch the 15 oh my god

so the 12 touches the

uh so the 12 touches the uh the three which is already handled and it touches the

six which is already handled and then it only goes to the right to the 18. okay

anyway you know when i make mistakes on camera and i say do over i always go i don’t know why

so the 12 and the 18 uh it’s going to cost us three so then we’re done with the 12th so i’m

I’m going to go to the next one. We’ll look at the 15. The 15. 6 is already handled. 8.

6 is already handled, 18 is not handled yet, so I’m going to put 18 there, and it cost us $88, and then the 18 is the last one.

There’s nothing to do, because every node is on the left of the 18.

If you carefully, if you pause the video and look at every single node, you’ll see it’s already represented in a previous node.

So we’re officially done with the basic edge list representation of this graph, this undirected but weighted graph.

We need to do something else, though.

we need to do something else though i mentioned in the last video i’m going to repeat it in case

you didn’t watch the last video but we need to make sure that uh oh i guess i forgot to separate

those two things that means i have to duplicate the vertex list over here on the right side too

okay um so on the left this is okay but it’s kind of slow because what if we’re trying to look at uh

you know one particular edge let’s say that we we want to see what’s going on with this uh this

edge right here. Let’s say the 3 and the 13 edge, for whatever reason.

13 edge for whatever reason um i don’t know green 3 and the 13 edge okay so we’re looking at that

edge maybe for some reason we had just finished scanning uh maybe that’s not a fun edge well

what’s going on hello uh oh i forgot to set up a thing where you can make your cursor really

visible okay um actually so so this is not the most fun edge let me let me see about the 15 and

and 18-inch.

18 edge excuse me i had to take a drink of water so we’re going to look at this edge connecting

the 15 and the 18 node that’s a little more interesting so you can imagine maybe you were

doing a little scan uh if you know big o complexity by now we had to check out every single edge in

this edge list until we found the one that connected the 15 and the 18 so this was a linear

time scan based on the number of edges so this is just it’s scalable but it’s not very fast right so

We ended up kind of looking at this one.

so we ended up kind of looking at this one right here not fast um but what if we want to examine

uh some properties of the nodes or the vertices uh involved like the 15 and the 18.

here in this representation on the left we have the values we have the 15 value and the 18 value

we don’t really have a pointer to a full node object if that’s what you’re doing in your code

so um how do we get those those node objects we’re gonna have to do another linear scan we’re gonna

I’m gonna have to look at this one right here.

to look at this one right here oh that doesn’t match the value of 15 look at this one look at

this one look at this one we’re gonna have to scan every single node until we realize that it’s those

two at the end this is true even if it’s a vector uh holding your vertices because if we don’t know

the index then we have to actually just sweep through the whole vector so that’s really slow

it’s still kind of scalable but uh it’s not the best instead let’s update the the representation

on the right to have index

on the right to have indexes we did this in the last video but basically if you just kind of look

at this three node here the three node well let me let me copy this one more time the three node

corresponds to index zero which i forgot to write down my bad let me write that down for you real

fast get rid of that get rid of that get rid of that okay so i’m just going to update this vertex

list to just show you that if we have a vector or in a

that if we have a vector or an array then every single item has an index here’s index one index

two index three and four and five and then i guess i’ll just copy paste that to the other one since

i was too dumb to make an extra separated graph there um separated item okay so the uh the 15

sorry no the 13 the 3 and the 13 i guess i got to get rid of that that’s distracting me

I guess I gotta get rid of that, that’s distracting me.

The three and the 13,

those correspond to indexes zero and one

in the vertex list, right?

So zero and one, that’s the three and the 13.

So I’m just gonna change the values,

the T-type values, to the raw indexes.

It’s gonna seem a little weird at first,

and I’m gonna leave the weight alone,

because that’s totally fine.

We’re not gonna jump to a weight,

unless maybe you had a weight list, a weight vector,

if you wanted to make instances of weights.

You could do that, I’m not gonna do it.

do that i’m not going to do it so then again the 3 is a 0 the 12 is index 3 the 3 is another 0

the 18 is index 5. i’ll just do this for every single row so the 13 here is index 1 and then

the 6 index 2 notice how i’m just looking up here at the indexes of the vertex list and i’m just

changing the node values to the indexes where the nodes actually are in the vertex list so that’s a

So two.

vertex list so that’s a 2 and then the 12 is going to be a 3 and then the 6 is also going to be a 2

and the 15 is going to be a 4 and then the 6 is going to be a 2 and 18 is going to be 5

on to the next row the 12 node is index 3 the 18 node is index 5 uh the 15 node is index 4 and the

18 node is index 5 so whoa whoa correct me if i made a typo in the comments please i’ll release

another video as a thank you.

i’ll release another video as a thank you but uh now i’ve converted the whole entire representation

on the right side to an index based uh uh you know edge list so i’m gonna do this one over

here is by value and the one on the right is by index why is the one on the right better now

remember at some point we might have been scanning to find an edge well what did i just do wrong oh i

clicked over there okay we might have been scanning to find you know some edge so we’re like

Like, subscribe, and hit the bell icon to be notified when I post a new video. Thanks for watching, and I’ll see you in the next one.

Bye-bye.

edge so we’re like scanning scanning scanning scanning and then maybe we decide we’re trying

to figure out what’s going on with the two and the not the two and the four the uh the six and

the fifteen node right so that’s uh the six and the fifteen node that’s basically you know this

right here uh so now what if we want to do something with the nodes we want to do something

with the six node do something with the 15 node we don’t want to scan through the vertex list again

we don’t want to go scan scan scan scan scan that’s linear time that’s not as fast as it could

Could be.

That’s linear time, that’s not as fast as it could be.

So instead, we’ve already converted here so that we have indexes.

So if I look at the 2 and the 4, the 2 and the 4 represent indexes, not node values.

So this 2 tells me that I can go to index 2 to get the 6 node,

and the 4 tells me I can go to index 4 to get the 15 node.

Notice how I did not have to scan the vertex list to figure out where those nodes are.

And if you’re using a vector for your vertex list,

list then you can jump to every index in constant time so now if we were going to you know search

and do a bunch of stuff on edges we probably only had to spend linear time on the edge list but then

we only spent constant time uh to to manipulate each node whereas it would have been linear plus

linear uh in the past like on the left side that would have been uh you know if we’re going to do

stuff with with both the edges and the nodes it would have been o of linear time based on the

number of edges if we’re gonna do every

on the number of edges if we’re going to do every you know something to every single edge

plus linear time based on number of vertices but over here it’s going to be linear time of the

edges plus just constant time which basically means it’s going to be you know big o of just

the number of edges and i’m talking about a you know a fantasy scenario where we’re just going

to scan a bunch of stuff you can imagine there’s a whole bunch of different operations you could

do on a graph, and it would be very advantageous and fast.

very advantageous and fast if you could just jump to a node if you wanted to be able to manipulate

it directly um let’s see so i did i think 20 minutes already so i think this is going to be

it for for today’s video um and i’m going to do another video after this where we start working

with directed graphs so i’m going to do directed unweighted and then directed weighted so by the

time you watch all four of these videos

by the time you watch all four of these videos you’ll know how to represent all four types of

graphs in the machine okay anyway so thank you for watching this video i hope you learned a little

bit of stuff and had a little bit of fun i’ll see you next time tell your friends eat a chocolate

okay i’m outie hey everybody thanks for watching this video again from the bottom of my heart i

really appreciate it i do hope you did learn something and have some fun uh if you could do

me a please a small little favor could you please

please, a small little favor. Could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking at right now?

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making

videos in general. So please do me a kindness and subscribe. You know, sometimes I’m sleeping

in the middle of the night and I just wake up because I know somebody subscribed.

just wake up because i know somebody subscribed or followed it just wakes me up and i get filled

with joy that’s exactly what happens every single time so you could do it as a nice favor to me or

you could you could troll me if you want to just wake me up in the middle of the night just subscribe

and then i’ll i’ll just wake up i promise that’s what will happen also uh if you look at the middle

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the

where you can just kind of like see all the videos i published and the services and tutorials and

things that i offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

or errata or just future videos that you want to see please leave a comment or if you just want to

say hey what’s up what’s going on you know just send me a comment whatever i also wake up for

those in the middle of the night i get i wake up in a cold sweat and i’m like it would really it

really mean the world to me I would really appreciate

it really mean the world to me i would really appreciate it so again thank you so much for

watching this video and enjoy the cool music as as i fade into the darkness which is coming for us all

Teksting av Nicolai Winther

Thanks for watching!

Thank you.

The post How to Represent Undirected Weighted Graphs Using Edge Lists appeared first on NeuralLantern.com.

Learn how to represent an unweighted undirected graph using an edge list. We build a sample graph with nodes and edges, then show the vertex list and edge list as tuples. See why storing indexes instead of node values makes lookups faster in constant time. Follow along as we list every connection without duplicates. This is the first in a series covering all four combinations of weighted and directed graphs with edge lists.

00:00 Introduction to Edge List Representation
00:56 Drawing a Sample Graph with Nodes
02:05 Adding Undirected Unweighted Edges
03:10 Graph as a Tuple of Vertex and Edge Lists
03:40 Building the Vertex List
04:24 Storing Nodes as Objects with Indexes
06:13 Creating the Edge List of Tuples
07:00 Listing Edges by Node Values
11:36 Limitations of Storing Node Values
12:30 Switching to Index-Based Edge List
14:08 Constant-Time Lookups with Indexes
16:54 Summary of the Edge List Method
17:16 Preview of Next Videos in the Series
17:44 Closing Remarks and Subscribe Request

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there! Let’s talk about representing an unweighted,

undirected graph in your machine using an edge list representation.

Okay, so hopefully you watched my previous videos. If you haven’t, you might want to take a step back

and check them out. We talked about, you know, what is a graph? What are some basic rules and

terminology of a graph? Not graph and paper, but a graph. And we talked about representing paths

in graphs.

representing paths in graphs using either a list of nodes or a list of edges and we’re going to

take the edge list concept one step further and we’re going to actually just say this whole graph

is being represented as an edge list it’ll make sense in a little bit but uh so the first thing

i’m going to do is try to set up my stuff which is always set up wrong because i’m the one setting it

up and it always gets messed up okay so i got a graph paper and uh oh i got to make this other

thing full screen. Sorry.

um i’m going to draw a random graph just real fast so i’m going to do i don’t know just some random

nodes so remember a graph is a collection of nodes and edges doesn’t even have to have edges but you

know we’ll just say so we’re going to do that’s bad let me try one more time we’ll get that okay

so we get i’m trying to get this circle perfect because i’m gonna have to duplicate it rare okay

i’ve got a node here and i’m just going to give it an arbitrary value i’m going to say it’s got a 3

and then i’m going to duplicate it a few times just to make a graph that is a little bit

interesting so we have something uh something to kind of challenge us i guess so it’s not

incredibly boring um and then i’m going to change some of the values here and then well i’ll change

the next ones and then we’ll start looking at edges which edges do we want to make okay so

right now we’re just making a graph make this graph along with me if you want to or uh you

you know, after you.

to or uh you know after you think you understand do another graph on your own

okay so i’m gonna make some edges right now remember this is going to be an undirected

unweighted graph so the edges are just going to be lines they’re not going to have direction on

them and they’re not going to have weights on them i’m going to do a line over here i’m just

randomly doing lines doesn’t really matter um what we do exactly the point is going to be let’s

practice represented

be let’s practice representing this graph okay so i’m just making a random graph it’s kind of like

a little bit dense i don’t know um maybe i’ll just stop there and then i’ll add a wonky line just

just to prove we can be cool about this i don’t know we’ll do another one right here so it’s a

slightly more interesting graph okay so um that’s just a graph and uh what i’m going to do is i’m

going to say this is a, you know, an unweighted, oops, weighted.

oops waited undirected uh graph and we’re going to use the edge list of representation

i have spell check on this i really hope i do nope okay i guess i forgot to fix that months ago

all right so then the next thing we’re going to do is uh we’re going to look at the idea of like

how do we start with the edge list representation okay um the first thing i’m going to say is that

our graph

that the our graph in an edge list representation is a tuple just meaning it’s you know some things

put together if you know tuples encoding already uh the tuple is going to consist of a collection

of vertices and edges what’s going to be an edge list don’t make fun of my ease please

anyway so uh let’s do the first thing is going to be the vertex list so how do we represent the

vertex list or the node list well i’m just going to say that my vertex list v

to say that my vertex list v is equal to something and we’ll just put inside of this

some vertices so the easiest way when you’re kind of drawing this right now is i’m just going to

start putting the values of the node i’m going to say well here’s a three and uh i guess i could

sort them for whatever reason uh if we’re going to do binary search on them later but we’re not

going to i’m just going to maybe you know what i’ll go from left to right so that’ll make more

sense, just visually. So I’ll go from left to right. 3, 13, 6, 12.

3, 13, 6, 12, and a 15, and an 18.

You can see all of those are nodes, right?

Somebody stop me if I forgot a node.

Okay, here’s the thing though.

What are we actually storing in this vertex list?

You probably don’t want to store the node values.

I mean, you could be a little slow and dumb though,

but we want the option to be a little bit faster later

and also the option to turn these vertices into full classes,

like give them extra properties and whatever.

So what I’m going to say is that…

So what I’m going to say is that I’m writing down the number 3 and the number 13 here for you, but you should imagine in your code you would have an object of type vertex or node, like a full class, and you would basically be stuffing pointers inside of that vector, inside of that list.

I keep saying list. It is called an edge list representation, but you can probably imagine

that this could just as easily be a vector. If you’ve seen my other videos, you know what that is.

but uh so i want to be able to index this uh faster so for me personally i make this a vector

and not an actual list but we’re going to call it a list anyway so three should be a pointer

uh to a full node object uh smart pointer raw pointer whatever you want 13 should be a full

pointer to an entire uh entirely different node object with just 13 assigned as its uh template

type value because we’re making this a vector we can actually index

can actually index uh the nodes right so like this is like index 0 for the 3 node index 1 for the 13

node so i’m just going to put the indexes here whoops just to drive the point home a little

bit further so if i told you hey let’s do uh the node at index 2 you would know that is the node

that is in the very middle with the value of 6 because index 0 and 1 and 2 brings you to this

node right here um which is a 6 so this is going to this is going to help us later let me save this

Real fast, by the way.

let me save this real fast by the way i’m just going to do that okay so uh the next thing that

we need to do is uh make an edge list the edge list is really where it’s all at that’s really

where all the data is it’s going to tell us exactly where everything is or it’s going to

describe the whole graph pretty much so the edge list is another we’ll say that’s a list this could

be like a linked list or vector or whatever you want i’m just going to say it’s a linked list

and every item in the list is going to be another tuple so remember above the graph itself was a

tuple containing a vertex list and an edge list so the edge list is a list of tuples

meaning you know items bundled together for one tuple and then just like a list of those

so what i’m going to try to do is describe every single edge uh one by one using one tuple each

inside of the edge list so the first thing i’m going to do just you know to make this a little

little bit easier.

thing I want to do just you know to make this a little bit easier is I’m going to ignore the

indexes for the vertex list and I’m going to say let’s describe everything happening from the three

node outwards or just to every other node so the three node itself I’m going to look at its

connections from left to right so the three node let’s just start by putting a three here

maybe I should describe the legend real fast the tuples will basically be the start node

and then the end node

and then the end node and then the uh well the weight if there was a weight but we’re doing an

unweighted graph so it’s really just going to be a tuple of two items the other thing to keep

in mind is that because this is an undirected graph it really doesn’t make a difference what

node is the start node and what node is the end node you can just swap them and it’s totally fine

for me personally i’d rather you know sort before assigning the start node and end node that way

when i read the graph later it’s a little bit faster because i wouldn’t have to check in both

directions but

wouldn’t have to check in both directions but it really honestly doesn’t matter right now so

start node and end node so the start node here is 3 and the end node is going to be 13 so that’s the

first thing that we’re doing that’s the first tuple and then i’m going to say what else does

the 3 connect to it connects to the not the 6 it connects to the 12. okay so the 3 connects to the

12. again we could have said 12 comma 3 wouldn’t have mattered but i’m just going to try to keep

it sorted so then

keep it sorted so then what else does the three connect to it connects to the uh the 18 doesn’t

connect to the 15 and just confirm that if i’m looking at the three i can see three lines

touching it so that means okay there’s got to be three tuples for the for the e for the three so

i’m going to say three connects to the 18. and now i’ve described everything happened to do with the

three note i will simply continue let’s see should i do like a new line maybe i should try to do a

new line for every

try to do a new line for every start node so this is easier to look at okay so i’m going to do that

and i’m going to say the next line is we’ll start at the 13 this time so the 13 the 13 is also

connected to the 3 because it goes in both directions with an undirected graph but we

already described that connection with that first row so 3 comma 13 describes 13 comma 3 i don’t

want to duplicate edges so forget about that let’s look at what else 13 is connected to it’s connected

it to the six

connected to it’s connected to the six so I’m just going to put 13 comma 6 and then that’s the end of

the 13’s connections oh I could have used tabs for that hang on let me do that okay so now let’s look

at the six node six is not connected to the three it is connected to the 13 but we already described

the 13 6 connection in the previous row so forget that and then I’m just going to look to the right

So the 6 is connected to the 12 and the 15.

the 12 and the 15 12 and the 15 and also the 18 so i’m going to do 6 comma 12 maybe i’m going to

do a copy paste here real fast just to make it easier 6 12 and 6 15 and 6 18 so again all i’m

doing is describing you know what other nodes the current node is touching and i’m going to do that

using a tuple that just has one node and has another node and that’s pretty much it so when

we’re done with this

it so when we’re done with this uh we’re going to look at the 12 node 12 node it’s connected to

the six already handled it’s connected to the three it’s already handled and it’s connected

to the 18 not handled yet so i’m going to say 12 goes out to 18. okay then we’re going to look at

the 15 node 15 and 6 that’s already handled in that third row so forget that 15 and 18 that is

is not

15 and 18 that is not handled yet so we’re going to do 15.18 by the way this is one benefit of

going from left to right visually all i really have to do is just look my eyes to the right and

i’ll see nodes that i need to take care of and if i look my eyes to the left i’ll see nodes that i

already took care of if that makes sense so now that we’re done with the 15 let’s see we did 3 13

6 12 15 let’s just take care of the 18 if there’s anything left to take care of i can guarantee

there’s not going to be.

there’s not going to be because every node the 18 is the node on the farthest you know the furthest

to the right so everything on the left is already handled so we don’t even have to put anything for

the 18 node okay give me a second to clean up this graph real fast i think i want to maybe

move this up a little bit okay uh now here’s the thing though we’ve only named node values so if

we wanted to i don’t know let’s say check to see if the uh let’s say we have an edge we’re looking

Thank you.

let’s say we have an edge we’re looking at the 3 comma 13 edge and we’re asking now do both of

those nodes exist the edge describes these two nodes do they exist or uh maybe let’s look at

the three here and we want to figure out just you know what other nodes does three touch so we start

iterating through all the edges here how can we actually get a pointer to that node to manipulate

it in the code right now it’s okay because it’s a diagram but you know this is not very

diagram but you know this is not very good storing values directly in this notation in your code you

probably want to store pointer uh pointers there but maybe not necessarily smart pointers they take

a little bit of extra memory and it’s kind of cumbersome but um we could store an index into

this vertex list to make things a little bit faster let me show you what i mean but first i’m

going to duplicate this list that we just made already, duplicate it over here, and

over here and maybe i’ll label the first one and i’ll say so we already have start node and end

node i’m going to say e underscore by value so we’re storing the edge list by node values and

then here we’re going to store nodes by their index in the vertex list so what do i mean by

index well okay right here the first node that we’re mentioning is the three well look at the

three node in the vertex list it’s at index zero right so i’m just going to put a zero

zero right so i’m just gonna put a zero that’s it change it to an index then i look at the 13

that’s index one and then i look at the three again that’s index zero um and then the 12 is

index three and then the three again is index zero and the 18 is index five um if that was too fast

i’m sorry just rewind and play it back in slow motion i think this video is already getting way

too long so then i do the same thing for every single other tuple so the 13 node um that is

node um that is index one so i’m going to put a one there the sixth node is index two go on to

the next node so the sixth node is index two and then the 12 is index three and the six is two and

the 15 is actually four the six again is two the 18 is five move on to the 12 node here uh that’s

index 3, 18 node is index 5, and then

the 15

and then uh the 15 is index 4 and then 18 again is index 5 so now on you know on both sides like

in both of these edge lists uh i’m representing the graph it’s just that one can be a little bit

more efficient than the other uh for example if i was going to let’s just say i wanted to scan

every single edge in the graph well i could scan this list right here in linear time so linear time

based on the number of edges and every single time i see an edge i can jump directly to the

Corresponding.

jump directly to the corresponding vertex or node in constant time because i have an index

so for example let’s say uh you know this uh the sixth node um touching the 15 node so that

particular edge right there let me i want to be more interactive here how can i do this okay

uh suppose i want to do

612 node and so that’s going to be pointing to this edge right up here i want to see you know

what’s going on with both of those nodes well if i was looking at the value-based edge list

and i wanted to get a hold of let’s say the sixth node itself so i can like do something with that

vertex like delete it or move it or just whatever i would have to then scan the entire vertex list

i’d have to go you know this one this one this one this one this one until i eventually found

the corresponding value.

uh the corresponding value this wouldn’t really support duplicate values either

uh it would be kind of hard to do that but uh i’ve i’ve slowed down the program it’s linear

time based on the number of vertexes and if you’re already doing linear time based on the number of

edges this is like it’s technically still a scalable data structure but it’s not super fast

it could be faster on the other hand uh so like i just said uh sorry for repeating myself if we did

the index

the index based uh edge list it says two three here which is the 612 how can i find the sixth

node well i just look at index two and instead of scanning oh gosh hang on

i’m not as fast as i used to be okay dude there’s like did you see that uh

a whole bunch of pink dots everywhere now what have i done okay

So, uh…

so uh i’m looking at the 612 edge i see that the indexes are two and three that means in constant

time i can just jump directly to i guess i’ll put it in red in constant time index two right there

and index three right there i do not have to scan the vertex list or the vector i guess if it was a

vertex list like an actual linked list then i’d still have to scan because it’s linear time to do

it but if it’s a vector

But if it’s a vector or an array, I can just jump to an index in constant time, so it’s way faster.

So what I’m trying to say is that this representation is what you want to do in the code when it comes to, I don’t know, representing diagrams and stuff.

I don’t know. The one on the left is more human friendly.

So this is the basic idea for how to represent an unweighted and also undirected graph in the machine using the edge list method of representation.

i guess i’m going to cut the video i hope you learned a little bit of stuff and had

a little bit of fun in the next video i think i’m going to do uh weighted uh undirected graphs

and this i’m going to do four videos for this one representation type i’m going to do unweighted

undirected and then weighted and undirected and then unweighted and directed i’m gonna

do all four combinations all right see you in the next video thanks for watching

hey everybody thanks for watching this video again from the bottom of my heart i really appreciate it

i do hope you did learn something and have some fun if you could do me a please a small little

favor could you please subscribe and follow this channel or these videos or whatever it is you do

on the current social media website that you’re looking at right now it would really mean the

world to me and it’ll help make more videos and grow this community so we’ll be able to do more

videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

just i’ll be able to keep making videos in general so please do do me a kindness and uh and subscribe

you know sometimes i’m sleeping in the middle of the night and i just wake up because i know

somebody subscribed or followed it just wakes me up and i get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could you could troll me

if you want to just wake me up in the middle of the night just subscribe and then i’ll i’ll just

wake up i promise that’s what will happen also uh if you look at the middle of the screen right now

you should see a QR code, which

screen right now you should see a QR code which you can scan in order to go to the website which

I think is also named somewhere at the bottom of this video and it’ll take you to my main website

where you can just kind of like see all the videos I published and the services and tutorials and

things that I offer and all that good stuff and if you have a suggestion for clarifications or

errata or just future videos that you want to see please leave a comment or if you just want to say

hey what’s up what’s going on you know just send

what’s going on? You know, just send me a comment, whatever. I also wake up for those in the middle

of the night. I get, I wake up in a cold sweat and I’m like, it would really, it really mean

the world to me. I would really appreciate it. So again, thank you so much for watching this video

and, um, enjoy the cool music as, as I fade into the darkness, which is coming for us all.

Thanks for watching!

The post How to Represent an Unweighted Undirected Graph with an Edge List appeared first on NeuralLantern.com.

Hey there, let’s talk about paths inside of a graph. We draw a directed weighted graph and compare node-based paths to edge-based paths. Node lists alone cannot tell which edge you took when parallel edges have different costs. Edge-based paths use tuples of start, destination and weight so every route is clear.

We also cover simple paths with no repeated edges or vertices, cyclic paths that start and end on the same node, and how a cycle proves the graph is cyclic. Then we explain DAGs, directed acyclic graphs, with examples that stay acyclic and ones that gain cycles.

This sets up algorithms for later videos. Leave a comment with topics you want next. Thanks for watching and please subscribe.

00:00 Introduction to Graph Paths
00:28 Drawing a Sample Graph
02:25 What is a Path
02:42 Node-Based Paths
03:27 Adding Weights and Parallel Edges
04:34 Example Paths with Different Costs
07:19 Edge-Based Paths
07:35 Representing Paths with Tuples
11:35 Order Matters in Directed Graphs
12:52 Simple Paths
15:34 Cyclic Paths
18:22 Directed Acyclic Graphs DAGs
19:08 Building a DAG Example
21:41 Adding a Cycle to Break the DAG
23:15 Conclusion and Future Videos

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hey there, let’s talk about paths inside of a graph.

Okay, so first thing that I’ll say is you probably should have watched my other videos already so that you understand at least the basics of graphs or maybe you already know and you just came here for a little extra.

So let’s just draw a sample graph here.

I’m going to do like random nodes.

Let’s see what am I supposed to do.

I’m supposed to like full screen that.

I’m going to draw some random nodes with some random values inside of them.

So I’m just going to do like a three here.

Maybe like a three like that.

And then I’m going to duplicate this a few times.

So I’m going to go.

This is a valid graph.

It’s just not a connected graph as we talked about in my last video.

So I’m just going to do this.

I guess that’s okay.

I’m going to change all these numbers.

Even though your graph should be able to support duplicate values in the nodes,

it’s going to be really hard to explain.

So I’m just going to change all this stuff.

9 here and then like 22.

I think that’s probably good.

So I’m going to do this.

And this.

Okay.

So still a valid graph, but there’s no chance that we could have a path anywhere in this

entire graph.

anywhere in this entire graph so that sucks we could by the way do a path

with a undirected graph but I kind of feel like I want to do direction on all

the edges so let’s see let’s do direction and also weight I’m gonna like draw an

arrow here and arrow here there I’m gonna draw edges first in a way that it

like I could find a path almost anywhere I want so I’m just going to like draw a bunch of edges

maybe like another edge over here nope that’s wrong how about this maybe another edge going up

here and an edge going up here and an edge going down there I’m just going to draw a whole bunch

of edges in the hopes that we’ll have a decent graph with lots of path possibilities okay I guess

Oh, no, no, this is not a complete graph.

I’ve just drawn a graph where you can kind of get everywhere.

Okay, so, well, I mean, what is a path?

It’s just sort of like, you know, some sort of a representation of how do you get from

one start node to some destination node, like a map.

So the first thing that we could do is we could say, let’s make a path based on nodes.

I’m going to say node-based paths.

Actually, let me get rid of this and put it on the next slide.

We’ll do this, duplicate it, that way I have the original.

Let’s pretend that our path is going to be just a list of nodes that we travel through.

So I’m going to say node-based and we’ll have one path, we’ll say path1 and then path2,

maybe we’ll do like a second path.

well at first we might think this is totally fine but uh later on it’ll get confusing in terms of

which edge did we actually take so let me show you let me show you what i mean i’m first going

to add weights to all the edges so i’m just going to do like you know four and a three over here

and then like a one and a two little one and then like a six and then like a four i’m just adding

random weights or random costs to all of the edges and um then eventually let’s see when i

let’s see when I finish doing all of that eventually we can probably realize that we

could add more than one edge going from the same start to the same destination node but give it a

different weight so that we have a little bit more of a choice so suppose for the sake of argument

that we have this six and the four here the six can go to the four at a cost of four but maybe the

a cost of one. I don’t know why it’s there. I don’t know why the four is there. Also,

we’ll just say this is our graph. So you can have edges like this that go to the same start

and destination nodes, but have different weights. So a path that is based on nodes

doesn’t really have enough information to tell us which edge we took. Let me show you what I mean.

So suppose we want to get from node, I don’t know, node three, I’ll put an S here for start.

for start. And then I guess I’ll put a D for destination or donut. I’ll put a D there on

node number 22. So we’ll say we’re going to go from node three to node 22. So start and destination

a path based, sorry, a node based path, path one, we could say maybe let’s go from the three

to the six to the four to the 12 to the nine to the 22 and that tells you all the notes that

you would hop on another path could be let’s see that first path when we went from three one six

four twelve nine uh 22 when we go from the six to the four we could have a second path here

that goes from three to one to six to four but takes a different edge this is kind of what i’m

this is kind of what i’m trying to show you notice that we have two different paths i’m going to do

one in uh maybe red so it’s going to be three one six four so from three to one and then six

and then we’ll travel along that four edge once we get to the four we’ll go 12 and then once we

Then the other path, path number two, let’s say that we chose the other edge.

We chose the six to the four edge that only cost us one.

So it would kind of look the same for the most part, except when we finally get to that

other node, we’re actually going to be going this way, right?

And then we’re going to go up and then to the right and then down.

So if you look at this carefully for a little while, maybe pause the video.

These are actually two totally different paths with two totally different costs.

different costs. So, um, you know, the cost of the orange, let me write it in orange.

It’s going to be five plus one. So six, and then a seven there, and then a eight, nine there. And

then, uh, then I guess like a 15 there and then a 16 there. So the cost of the orange pass is going

to be 16. If we switch to the red path, the only difference is the choice of edge we took between

we took between the six and the four node.

So we would increase our cost by three.

So the red path would be a cost of 19.

But how can you tell the difference in a path

that is based on a node?

It doesn’t have enough information, right?

So what we’re gonna do instead

is we’re gonna use edge-based paths.

Edge-based paths.

In some places, you know, you can use node-based paths.

That’s totally fine.

fine but for me I’m going to say let’s do edge based paths edge based paths and now we just have

to figure out how to add that extra information into the path so going from the three to the one

we’re actually traveling along an edge right we’re traveling along that five edge so let’s just stick

a tuple in there a tuple meaning just a little collection of values for those of you in c++ if

items we’re going to use three item tuples tuples not always limited to three items it could be two

three four even probably one um or much more so i’m going to say let’s use a tuple that has three

items per item or tuple and we’ll just say that we specify the start node and then the destination

node so we start at three we go to one and then the weight of the edge that we choose to travel

but we’re putting enough information into our hop

that this can be considered an edge-based path.

So when we go to the one node,

we ended on the one node, sorry, we’ve gone to the one node.

We just ended there.

So we could start on the one node for the next tuple

because then we’re going to go to the,

what are we doing first, red?

I think we’re doing red first, yeah.

We go from the one node to the six nodes.

So I’m going to go comma six.

and then we choose which edge to travel along that’s just the one edge and so 161 means start

at the one node and at the six node and take the one weighted edge then do the same thing

again for the next tuple so we’re at the six now where are we going to go we’re going to go to the

four and then we choose the edge that costs four and then for the next tuple we’re on the four

I’m going to say 12 is the destination and which edge did we choose the two even though there’s

only one choice at least we have enough information for all edges in our entire path so then again

we’re at the 12 we’re going to go to the 9 so I’m going to put a common 9 there and then we choose

to take the edge that uh what was that cost six I can’t read anymore um let me actually just look

real fast six I guess I overrode it I’m just going to assume that it’s a six um I’ve got

I guess I could erase it real fast

or move it or something

okay let’s see what is that

yeah it’s a 6 okay

so we’re on the 12 we’re going to go to the 9

and we choose to take the edge that costs 6

then we’re on the 9

and we choose to go to the 22

using the edge that costs 2

and then this last thing doesn’t need to be done

because we have the entirety of the path

in our edge based list

So I’m actually just going to copy paste this entire path and stick it into the second path

because remember the only difference between the first path and the second path that we

chose is when we were going from 6 to 4 we chose the 1 edge instead of the 4 edge.

So now look at this, I can just change that 4 to a 1 and now we definitely have two different

paths and because we’re using edges to describe our path we can tell the difference.

You know in a computer program we would know exactly which edge to travel along or even

which edge to travel along or even just a user moving their finger along a graph or whatever.

So in my opinion, edge-based paths are a little bit better.

They’re also better because if you practice writing down edge lists like this,

then you get a lot closer to a representation of a graph in your machine called an edge list.

So in an edge list, oops, I put ed light.

I don’t know why I did that.

And now the computer’s not responding.

So my mistake is immortalized.

my mistake is immortalized. Edge list representation of a graph is basically a graph is equal to

a tuple where one item in the tuple is a list of vertices and another item in the tuple

is a list of edges. So if you learn how to do edge-based paths, then you’re already a step

closer to being able to represent a graph inside of your computer program in the machine.

So another thing that I want to point out is that since this graph has direction,

the order of the start node and the destination node absolutely matters for example if we have

this three comma one here indicating we start at three and we end at one well that means there must

be an edge that points from three to one otherwise this is an invalid path if for some reason

if for some reason let me get rid of this here there’s too much stuff on the screen

three this is invalid because it’s saying that we have to start at the one node and end at the three

node but the one node has no has no edge going to the three node so this is totally invalid

does that make sense i hope it makes sense to you if this was an undirected graph where every single

edge did not have direction then the order actually wouldn’t even matter you would just

to see if an edge existed.

So let’s see, we talked about different paths.

You know, typically you would want to choose

the lowest cost path,

but there are algorithms that we can use

in future videos to compute paths.

Let’s see, something called a simple path

is where every single edge in the path is distinct.

So for example, I don’t know,

let’s say we had like a really gross path here.

Let me get rid of, let me get rid of some of this.

Let me get rid of some of this.

Get rid of the oranges maybe.

So that this is a little slightly easier to read.

Let’s see.

Did we choose?

Oh, I have to fix this.

Let’s fix the three and then the one.

And then we chose the four.

So this is the red path indeed.

So a simple path is, nope, I accidentally erased like an extra edge or something.

So I got to do one from the four to the 12.

Okay.

to the 12 okay let me just do that real fast from the 4 to the 12. at a cost of 2. okay so a simple

path is something where you don’t repeat edges so i can also write down simple path here simple path

if this was not a simple path then we would just basically have to repeat an edge somewhere

so um if any of the edges or vertices were repeated this would not be a simple path so let me just i

would not be a simple path so let me just I don’t know let me just update this real fast let’s say

we do oh what should we do let’s do I don’t know when we go from three to one to six to four

let’s go back from four to six and then we’ll take the other edge back to four and then we’ll

go up to 12 so this will be like um not a simple path if we say gosh I should have written this

this down before i drew it three to one and then one to six and then six to four and then four back

to six okay so i’m going to add another tuple so starting at four going back to six and taking

that three edge i think is what we’re looking at and then another tuple to get back when we go from

six to four and then take the um one cost edge and then once we’re at four then we can go four

cost of two and then 12 to nine at a cost of six and then nine to 22 at a cost of two okay so

i mean i’m just saying you can make a path where you just repeat a whole bunch of the edges and

nodes and you’re just like going in a circle forever like whatever you really want it’s not

necessarily going to be an efficient path or something that an algorithm should produce

but you can have a path like that maybe your character is just going crazy in the game and

because we repeat stuff on the previous slide.

Since we did not repeat anything, this is a simple path.

Okay, let’s see.

Something else that I wanna talk about is a cyclic path.

A cyclic path is basically a path

where you start and end on the same node.

Being able to find a cyclic path in a graph

is a way that you can prove that the graph is itself cyclic.

is itself cyclic. Let me try to get rid of this here. Yeah, there we go. Okay, so just

pretend for the sake of argument that I’m just kind of looking around and I’m trying to find,

you know, some path that proves I can start at the same node and end on that node without

repeating edges. So let’s see. Right, so I’m going to do take the three and go to the six.

to the six and then so i want to try if i start on the three then i want to try to find a way to get

back to the three again so i go from three to six and then i can go from six to four

and then if i go from four to six over here i’m not repeating that edge going from six to four i’m

using a new edge from four to six and then i can go from six to three again not actually repeating

means I have found a cycle in the graph. Let me just describe this path real fast in terms of

edges. So we started on three. Oops. We started on three and then we went to six and it cost us three.

And then once we were on six, we went to four. So I’m going to go from six to four. And we chose

the edge that cost us four. And then once we were on the four, we just went backwards to the six.

four going to six and we took the edge that cost three once we were on six we took the six to three

edge so six to three whoops six to three edge and that cost us three yeah did I do that right

when we go from the three to the six in the beginning I wrote down a three but I should

have written down a two hopefully you cringed on my behalf right because I was I think that red

on the left side so my brain was looking at the three but we were really taking the arrow that

points down from the three to the six so there’s a two there let me just double check one more time

six to four at cost of four four to six at cost of three six two three at cost of three

so we have started and ended uh on the same node and therefore we have found a cycle in this graph

which means this graph is cyclic what is cyclic just means it’s a graph that has a cycle

It’s a graph that has a cycle anywhere inside of it.

So this is a cyclic graph.

Make sense?

Okay, why is this important?

Well, there’s kind of like a special type of graph called a DAG,

which means a directed…

Here, let me write this down real fast.

On the next slide, so that we don’t get confused.

On the next slide, I’m going to say we have a DAG

is basically a directed…

directed, acyclic graph. What does A mean when it’s in front of something? It just means it’s

not that thing. So acyclic means not cyclic and then graph. So in some algorithms you are required

to, you know, like have a DAG before you can even use the algorithm or if you’re being tested

somewhere. So let’s just start by, you know, drawing like a little bit of a graph and we’ll

have a graph that qualifies. So I have a little graph here. If it was empty,

I don’t know if you could call it a DAG or not. I think I would because it’s empty. It could be

directed. So we have like a graph here. I would call this a DAG because it’s a graph. We don’t

have any edges, but like I could assume that this would be a directed graph. But just to make this

a better example, let’s just say we have like two nodes here. And you could also probably assume

DAG because you could assume that there are no edges in this graph but if we did add an edge

a second from now then it would be directed not the best example but so let’s just add an edge here

oh actually let’s add an edge that’s undirected real fast from from two to six and then maybe

I’ll just kind of duplicate some of these we’ll do a couple more so I can just make this more

so ask yourself is this a DAG directed acyclic well there are no cycles that I can see in the

graph there’s no paths that you can find to kind of like end where you started but this is a it is

a graph and I don’t see any cycles but it’s not directed because these edges don’t have direction

so that means right away we have to upgrade every single edge to have direction so I guess I was

going to draw a bunch more edges and now I’m just going to only draw this one edge

So this is definitely a DAG if we just sort of do it like this, maybe another edge like this,

because I don’t know about you, but I cannot find any path that allows me to start and end

on the same node. Let’s just double check it. We’ll do the two. Can we find our way back to

the two? No, because there are no incoming edges to the two. All right, that’s good. Let me just

do a check here. What about the six? If we go out to the six, from the six to the four to the

6 from the 6 to the 4 to the 11 it would have been dangerous if we could get to the 2 but we

can’t even get to the 2 so that’s fine that means the 6 is okay we cannot find our way back there

the 4 we can go to the 11 but we can’t go any further we’re at a dead end we can’t even go to

the 6 that means the 4 can’t find its way back to itself where you can’t find a path that goes back

the 11 has only incoming edges so that’s automatically you know a dead end so all of

nodes qualify as we could not start and also end at that node with a single path so that’s good

that means this is a DAG a directed acyclic graph if you want to make this into not a DAG just figure

out how to add a path so that you end up with a cycle so what was the first thing we did the 2

goes to the 6 goes to the 4 goes to 11 then it’s a dead end we could either add an edge from 11 to 2

to make a cycle but that’s a little bit too easy right because if you see any pair of nodes

right because if you see any pair of nodes with arrows kind of pointing back and forth between the

two nodes then right away that alone is a cycle so I’m just going to maybe do an arrow or an edge

pointing from four to two then it doesn’t look so much like a cycle although it’s not too hard

to realize that there is a cycle in this graph in this graph so this is not a DAG let me show you

and then from four to two.

And therefore we would have a cycle.

So this whole graph is not considered acyclic.

This graph has a cycle.

And if we want to do an edge-based path,

we don’t have weights on this graph right now.

So we could describe the path as such.

We could say, start at two, go to six.

And if your edge list is of a graph

that doesn’t even have weight at all,

then you don’t really need that third item in the tuple.

item in the tuple you can just do a start node and a destination node this does kind of preclude

you from having parallel edges you know two different edges that point from the same start

node to the same end node so as i go from two to six and then from six to uh four and then from

four to two and then we have a cycle and that’s it okay i think this is all i really wanted to

talk about for this particular video in future videos we’re going to do algorithms and then

some others up already that have graph properties and connectedness and definitions and things like

that. So leave a comment asking about some algorithm or some property of a graph that

you might be interested in. Otherwise, thank you so much for watching this video. I hope you learned

a little bit of stuff. And I hope you had a little bit of fun. I’ll see you in the next video.

Yeah, I’m gonna go eat some cookies. No, I shouldn’t do that. But I’m still going to.

Hey everybody, thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow

this channel or these videos or whatever it is you do on the current social media website

that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able

better videos or just I’ll be able to keep making videos in general so please

do do me a kindness and and subscribe you know sometimes I’m sleeping in the

middle of the night and I just wake up because I know somebody subscribed or

followed it just wakes me up and I get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could

you control me if you want to just wake me up in the middle of the night just

subscribe and then I’ll just wake up I promise that’s what will happen also if

if you look at the middle of the screen right now you should see a qr code which you can scan

in order to go to the website which i think is also named somewhere at the bottom of this video

and it’ll take you to my main website where you can just kind of like see all the videos i

published and the services and tutorials and things that i offer and all that good stuff and

if you have a suggestion for uh clarifications or errata or just future videos that you want to see

Or if you just want to say, hey, what’s up?

What’s going on?

You know, just send me a comment, whatever.

I also wake up for those in the middle of the night.

I get, I wake up in a cold sweat and I’m like,

it would really, it really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music as I fade into the darkness,

which is coming for us all.

so

Thank you.

I’m going to go ahead and get started.

Thank you.

The post Graph Paths Explained: Node vs Edge Based, Simple Paths, Cycles and DAGs appeared first on NeuralLantern.com.

Learn graph basics: nodes, edges, neighbors, adjacency. Undirected vs directed, unweighted vs weighted. Representations including edge list, adjacency list, and matrix. Great intro for computer science students.

00:00 Graph Basics Introduction
00:41 Nodes and Edges
01:20 Node and Edge Classes in C++
03:46 Simple Graph Examples
04:29 Adding Edges – Undirected Unweighted
05:26 Real World Uses of Graphs
07:08 Graph Terminology – Neighbors and Adjacency
08:32 Edges Incident on Nodes
09:20 Graph Representations – Edge List
09:59 Adjacency List
10:27 Adjacency Matrix
11:19 Directed Graphs
13:04 Weighted Graphs and Path Costs
15:24 Video Conclusion

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about graphs in the context of data structures and computer science.

I just want to talk to you about some of the basics of graphs, some ways that we could

implement them in the future, and some terminology. Okay, so for starters, we have a little

For starters, we have a little blank graph sheet here.

If you saw my previous video, you’ll know already that this is a valid graph.

It’s just totally empty.

There’s nothing on it.

But let me draw some data in this graph.

So graphs are collections of nodes and edges, or vertices and edges, or vertex and edges.

The nodes themselves, they are custom classes sometimes, other times not.

But you can imagine that they hold some sort of custom data.

of custom data so i know i did this in my last video but i just want to emphasize that this graph

class if we’re talking about c plus plus it should be a template class meaning we can specify a

custom data type that the nodes will hold and also a custom data type that the edges will have as

their weight you know typically when you see examples of this in the wild it’s just going to

floats and strings exotic custom classes depending on your use case it may or may not be useful to do

that but so we’ll have a data type for our nodes and i’ll call it like n type for like our node

type and then we’ll do another one called e type for edge type i don’t know if that’s the best way

to write those but i’m just going to do it anyway imagine that your glass your graph like we said

So I’m going to put a node class here.

You can imagine this as a vertex class.

And I’m going to say that this node holds an n type data.

And we’ll just call it data or node value or whatever you want.

And then the same thing for the edges.

We’ll say we have an edge class.

I think in my last video, instead of doing a node class, I did a vertex class.

It’s kind of all the same.

We’ll say we have an e type and we’ll call it weight or value or data if you want.

or value or data if you want but I think weight is a little bit closer to what we’re going to

actually be doing with it and what do I mean by n type and e type like what are those data types

there that just means these are placeholder tokens so when the user actually uses your graph by

making an instance of your graph class like they create an actual graph off of your blueprint

class here they might decide that they want integers inside of their nodes so that’s what

They might decide that they want floats inside of your nodes, inside of their nodes, or some

other data type.

And so that means like at runtime or at, I think actually at compile time for C++, this

end type would actually change to int if they chose to use integers on the inside.

Same thing would happen for the edge, whatever they choose for the E-type token is just going

to end up being used at compile time to replace that E-type.

So I don’t know.

Here’s an example.

example, I got a fly in my room, it’s bothering me. Imagine the user says I want a graph.

And I’ll call it G. And so they just have to kind of specify the two data types, maybe they want the

graph to have integer values in the nodes. And maybe, you know, floating point double precision

floating point values on the edges. In terms of weights, you know, you could do something like

And we have edges and this graph right here is valid.

It’s just one node kind of floating around by itself.

This graph is also still valid, even though we have two nodes that are floating unconnected

and also with the same value.

I’m just going to change the value to be different.

Maybe I’ll get rid of this extra thing here.

So this is a valid graph still.

We could have like a whole bunch of nodes all over the place and they don’t really have

to be connected.

This is still a valid graph.

change this to like a three, maybe change this to like an 11, change that to a six.

What else can I change?

How about like a 13?

How about like a 17?

Are there any duplicates?

I don’t think I see any.

All right.

So this is a valid graph.

The next thing that we could add to our graph is edges.

So edges are, you know, little mini data structures that connect nodes.

In this particular graph, I’m choosing to not have direction on my edges, which means this is a special type of graph.

Or four that we talked about in the previous video.

This is unweighted and also undirected, meaning there’s no weight assigned to the edges,

which means that template weight value or the weight data type that we just talked about before.

It’s kind of useless for this particular graph because I’m saying it’s unweighted.

well uh all the edges if we wanted to travel through the graph along the edges we could just

sort of go in any direction we felt like so this is unweighted and undirected

um let’s see what else can i show you real fast okay so let’s talk about um well really fast let’s

talk about the uses that you can have for a graph i think i talked about this in the last video

but um you know what can we use graphs for some people think they’re databases they’re not really

They’re not really databases.

You could technically do that, but it would be pretty slow.

There are much better data structures for databases.

Really what graphs are mostly used for is to represent relationships between different

things.

I think I said this in the last video.

Imagine if every single node that you see here is a city and the edges represent flight

paths.

So we could fly between city seven and 11.

Oh, that’s funny.

I’m hungry for candy bar now.

between city seven and 11 and back and you know back in the other direction if we want to but we

can’t actually fly from city seven to six because there’s no edge there so we could represent

computer networks we could represent road maps airports dependency graphs game maps you could

say like every node is somewhere your character could stand and an edge represents where your

or represents a connection to another node so that you know your character could move there

there’s all sorts of different things that you could represent with the graph but

it’s not necessarily a fast database it’s more of like a relationship

not to be confused with relational database which is supposed to be lightning fast

like if i wanted to search for the number 17 in this graph it’s not going to be log time like a

proper database should be it’s not going to be constant time like a hash table based database

or like a no sql or whatever um so we have undirected and unweighted uh we talked about

like different uses let’s talk a little bit about terminology okay for starters notice how there’s

no hierarchy in this graph in other videos we’re going to talk about binary search trees and we

have to have like a hierarchy there’s no parent there’s no child in these graphs there’s no uh

you know like grandchildren ancestors descendants because there’s not really like a hierarchy it’s

It’s just things are connected to each other or they’re not.

But we can have something called neighbors.

For example, if you can reach a node in one hop, then you might be able to call that a neighbor.

So 6 and 17, those are neighbors.

Maybe I’ll just type neighbors right here.

Oops, neighbors.

Because we can reach them in one hop.

Later on, or especially if I don’t remember to mention this,

to our graph, then something is only considered a neighbor if you can reach it while respecting

the direction of the graph. So we have like neighbors as 6 and 17. So that means 6 and 11

are also neighbors. 6 and 12, not neighbors because they can’t reach each other in one hop.

Let’s see. Adjacency is basically the same thing. I can’t remember. I think we use adjacency more

often in directed graphs, but we could say that 6 and 17 are adjacent to each other,

adjacent to each other, which is in this context, sort of a synonym for neighbors.

Okay. Something else that I want to talk about in terms of edges,

edges are considered to be incident upon nodes or vertices. So like, you know,

if I have an arrow that just kind of points to these two things, I could say,

you know, edge is incident upon three and 12. It’s just, it just means,

and 12th. Okay, what else should we talk about? We should talk about connected versus, no,

that’s another video. Okay, I’m going to do another video for connected versus not connected graphs.

Maybe I should mention that there are three ways that we can represent a graph, and then maybe I’ll

upgrade to a directed graph in a second. If you want to know about the four different types of

graphs, see my previous video. But for now, I’m going to say there are three ways we could

to represent these graphs. The first way, and I’m talking about how can you represent these

graphs inside of the machine? Like how can your computer store and process this graph and maybe

run algorithms on it? So the first way that we could represent, at least that I’m going to talk

about, is an edge list. Edge lists are super simple. I’m going to do a dedicated video just

for edge lists in the future. They’re not very fast, but they’re very easy to implement. So

So honestly, if you’re just starting with this stuff, I would recommend just implementing an edge list first

The next thing that you can do to represent a graph in the machine is make an adjacency list

Adjacency lists are just a little bit more complicated

But they’re typically faster than edge lists. Not always not in all cases and

In terms of time complexity, you might not feel like you notice much of a difference

but empirically

the option of skipping a lot of examinations when you don’t need to examine something,

you kind of skip it.

We’ll talk more about that in the future.

But we have an edge list and adjacency list of representation.

And then we have an adjacency matrix.

I wish I had spell check on this.

Otherwise, this is going to be humiliating.

An adjacency matrix is sometimes a lightning fast representation of a graph.

At first, you might think, wow, that’s amazing.

I’m always going to use that.

always going to use that. But all of these representations have strengths and weaknesses.

None of them are better than the others in every single circumstance. So, you know, computer science

and data structures, it’s all about weighing the pros and cons and picking the right representation

or algorithm or whatever that’s best for you and the code and the data that you’re actually going

to run. So three different ways that we can represent a graph in the future. And let’s see,

already on this. We talked about the basic ways to use them sort of. We talked about neighbors

and adjacency. Oh, I got to upgrade to a directed graph real fast just to kind of show you the

difference here. Okay, so I’m going to duplicate this and I’m just going to start adding direction

to all my edges. In my previous video, we talked about this. If you add direction to even one edge,

then you have to add direction to all the other edges. Otherwise, you will have an invalid graph.

graph so notice how I add a direction to one edge I now have an invalid graph so

I’m just gonna do this change every single edge so that every single edge

has a direction you know the basic thing we kind of talked about this in my

previous video is that when traveling through the graph you’re supposed to

only be able to travel in the direction of an edge which means if you look at

this thing right now you’re supposed to be able to go from 11 to 7 but you’re

be able to go from 7 to 11 because that violates the direction of the edge. When we add direction

we’re sort of like reducing you know the flexibility of the graph so you can imagine

that the previous version that was undirected it was sort of like every single edge here

was really two edges pointing in opposite directions if that makes sense. So if you

wanted to make sure that you could go back and forth between edge sorry between node 7 and 11

the opposite direction you can also do things called parallel edges which is just to say

i’m going to add multiple edges that that go in the same direction from the same start node to

the same end node but i’m not going to do that here that makes it more complicated for some

representations but we can just sort of add a whole bunch of edges i’m just going to say one

going back and forth there and so forth remember in my previous video we talked about weighted edges

about weighted edges which means we could add a cost to traveling along an edge so you could say

something like uh i don’t know going from 7 to 12 let’s add another edge here if there was a cost

on all these weights maybe i should just add that for fun we could maybe calculate which path would

be better so let’s say we got ones over here and we got fives over here um and maybe like a like

and I’m going to do like an eight.

By the way, these sixes don’t have to be the same.

You could just be two different numbers.

So I’m going to do like a three here.

And let me just see, have I added a weight to every single edge?

So I know I did this in the previous video,

but I want to do it again real fast.

If we chose to take a path from seven to 12,

and we said seven to 11, and then 11 to 12,

that’s a very specific path, which is,

it’s going to cost us five to go along that first,

as you have to go along that first edge and then the second edge is going to cost us six

and we’re only traveling along two edges so the total cost of that path is 11.

On the other hand let me actually make this look pink.

On the other hand if we’re taking a different path we might come up with a different cost

depending on the graph. So let’s say we start at 11 start at 7 maybe we want to go down to 3

to three and then from three we’ll go to 12 well that might be a different cost so i’m going to say

the cost of this particular path is traveling it’s going to cost us one to go down that first edge

and then a two to go down that second edge which means the total cost of getting to 12 is only 3

if we take that orange path versus 11 if we take that pink path i hope you’re starting to visualize

how graphs might be useful to visualize costs if this is a network map we just figured out that

network map we just figured out that one route through the network might be faster or less

costly than the other or if this is like an airport map maybe you do want to take you know

that layover that goes down south instead of that layover that goes east in terms of

i don’t know frequent fire miles that it costs you or money it costs you or jet fuel that it

That’s all I wanted to talk about in this video.

I’m going to make one more video today.

Well, it’ll be released.

I don’t know when, but like in my present moment.

I’m going to make another video right after this

where we just talk about connected graphs versus not connected graphs.

Thank you so much for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

See you in the future.

Okay.

In the future.

in the future.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

happen also if you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named somewhere at the bottom of

this video and it’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

if you have a suggestion for clarifications or errata or just future videos that you want to

videos that you want to see please leave a comment or if you just want to say hey what’s up what’s

going on you know just send me a comment whatever i also wake up for those in the middle of the

night i get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

would really appreciate it so again thank you so much for watching this video and um enjoy the cool

so

Thank you.

The post Graph Basics in Data Structures: Nodes, Edges, and Representations appeared first on NeuralLantern.com.