Learn how to represent a directed and weighted graph using an edge list.

We start from a directed unweighted example, add weights to every edge, then store the graph as a tuple of a vertex list and an edge list. Each edge is a tuple of start node, end node, and weight. Order matters because the graph is directed.

Then we convert node values to indexes so you can jump straight to a vertex in constant time instead of scanning the vertex list. That keeps edge scans closer to O(E) instead of O(E + V).

This is part of a series covering all four combinations: directed vs undirected and weighted vs unweighted. Watch the earlier videos for basic graph terms and the other representations.

Leave a comment if you want a topic covered next.

00:00 Intro to directed weighted edge lists
01:05 Starting from the directed unweighted graph
01:35 Adding a weight to every edge
02:48 Graph as a vertex list plus edge list
03:35 Writing the vertex list
04:18 Node classes versus raw values
05:18 Writing directed weighted edges
05:45 Order matters on directed edges
06:38 Walking remaining outgoing edges
09:08 Why value-based edges scan slowly
10:29 Replacing node values with indexes
12:36 Constant-time jumps after an edge scan
14:13 Series wrap-up
14:45 Subscribe 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

Hello there! Let’s talk about representing a directed and weighted

graph inside your machine using an edge list representation.

That’s a lot of words, a lot of words. Okay, so I hope you watched my previous videos. You didn’t

necessarily need to watch the previous three where we talked about edge list

representation.

where we talked about edgeless representation on the other types of graphs we’re doing a directed

versus uh undirected and weighted versus unweighted and all four combinations of those

so uh you don’t need to watch those others if you’re just only interested in this but it’s

probably a good idea if you watch my other graph videos because we talk about basic graph

terminology and like you know what is a graph and stuff like that but for now we’re just going to

continue um the screenshot you’re looking at right now was the last part of the last video where we

Thank you.

the last part of the last video where we did a directed unweighted graph so I’m

gonna duplicate this real fast and I’m gonna start modifying it so we can

basically just move on with our lives so this is gonna be directed and also

weighted then I’m gonna erase a whole bunch of other stuff because it’s fun to

draw again I don’t know why but it is I like to do my drawings get that and then

And I’m going to get rid of that stuff.

Okay.

that stuff okay and i’ll get rid of this because i’d like to draw it okay i probably should have

gotten rid of it first so i guess the real first thing that i’m going to do after erasing all that

stuff is add weights to all the edges remember this has to be a weighted graph so this particular

graph you’re looking at right now is directed and unweighted so we have to add weights to all of

the edges in my previous videos we talked about what is the meaning of weights you know these

could be a cost these could be like some property like in a video game

property like in a video game uh whatever you want them to mean uh these could even be classes

with like complicated values um but for now i’m going to say i don’t know maybe this is an airport

map and the weights are how much gas it takes to fly from one city to another maybe a node is a

city number six and city number 12 you want to fly between them it’s like five million jillion

gallons of gas so let me just take a look real fast and make sure that i’m not forgetting

I mean, any edge.

getting any edge every single edge should have a weight i think there were nine edges here one two

three four five six seven eight nine so i should see nine weights one two three four five six seven

eight nine okay we’re now ready to start representing this and what’s going on with

this computer okay the first thing uh that we talk about in all of these you know recent related

videos is that in an edge list representation we’ll say

edge list representation, we’ll say that our graph is a tuple, meaning just like a collection of some

things. A tuple where the first item in the tuple is a vertex list or a node list, and the second

item is an edge list. Again, in previous videos, we talked about representing paths using nodes or

using edges. So the edge list path is going to come back to haunt us where we do our edge list

graph representation, which is different than an edge list path.

path. So how do we do our vertex list? That’s going to be pretty easy for this diagram.

I’m going to say that V is equal to, oh, it’s pink. Let me change the color to be more serious.

Okay. The vertex list is going to be a collection of just all the nodes, just naming all the nodes

or having all the nodes. I’m going to say it’s a vertex list or a node list, but really you

probably want this to be a vector I’ve been saying that recently because it’s faster to

because it’s faster to jump to a particular index in a vector

than it is in an actual linked list or some other list-like data structure.

So we’ve got a vertex list.

I’m just going to name all the nodes.

So for me particularly, I like to go from left to right.

You can sort them, you can do whatever you want.

They just need to all be in there.

So I’m just going to say every node that we see in the graph

is going to end up in this vertex list.

So we’ve got 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6.

So we’ve got all the nodes in there.

another point that I’ve been making in the in these recent videos is that in real life in your

code in your in your computer you don’t really want to just have this value three here you don’t

want to have this 12 value here that the 12 value that’s just the value that the node holds I mean

if you want everything to be really fast maybe you know keep it bare bones but for me I like to

have a full node class a full vertex class and make an instance of it so I can add a whole bunch

of custom properties and function

bunch of custom properties and functionality and other stuff onto my node so that that means i

couldn’t really put an integer there i would have to put a full node so keep in mind for yourself

you probably want to try it both ways but um you probably want to want an instance of a node class

and maybe stick the instance right there in the vector or maybe make a smart pointer and so like

you allocate you know a new pointer of an instance of the class or it’s a raw pointer it’s a smart

point or whatever so just keep in mind this diagram is

So just keep in mind, this diagram is more simple than your code, but we’re just diagramming

today.

Anyway, so we put all the nodes in there.

The next thing I need to do is represent the edges.

So I’m going to put E is equal to another list.

And this probably does need to be a linked list or a list like data structure and not

a vector.

There’s not much point in jumping to an index.

I don’t know.

You could probably come up with one.

But anyway, so the edge list is going to be a list of tuples that describe one edge at

a time.

at a time so every little parenthesis that i put here that’s going to represent one edge so again

for me i like to go from left to right i’m going to start on the left node and i’m going to say

that the start node is three and remember this is a directed graph which means the order if you

looked at my previous videos the hang on the order of the nodes actually matters a lot like i can put

3 and 13 but i cannot put 13 comma 3 because the first item in the tuple is supposed to be the

The first item in the tuple is supposed to be the starting node.

And if you see, I only have like an edge going from 3 to 13.

I don’t have one going from 13 to 3.

So 13 comma 3 would be invalid.

It would be totally bad.

So I’m going to say the 3 goes out to the 13.

So the 3 comes first and the 13 is second.

And then I have to describe how much it costs.

So that’s the third item in that one particular tuple.

It’s going to be a 1 because the cost of that one particular edge is 1.

one gasoline one

one millisecond delay one time whatever so then the next item is going to be where else does the

three go to the three doesn’t go anywhere else so we’re done representing the three at least as a

start node so next up uh i’m going to look at the 13 where does the 13 go to it goes to the six it

doesn’t go to the three the three goes to 13 but this the 13 doesn’t go to the three so 13 goes to

six and it costs six because that’s the cost of the edge there’s two sixes here

the edge. There’s two 6s here, a little confusing, but that’s because one is a node and one is a

weight. The 13 does not go out anywhere else, so we’re done with the 13. I like to make, you know,

different rows for every single start node. You don’t have to do that. Next up, I’m going to look

at the 6. The 6 does not go out to the 13. The 6 does not go out to the 18. There is a connection

there, but it’s going in the other direction. The 6 goes to the 12 and also to the 15. So the 6 goes

to the 12, and that cost us $5,000.

to the 12 and that cost us five because that was the weight we assigned and the six also goes to

the 15 with a cost of i think i just wrote seven in a weird way um so we go from six to fifteen it

costs us seven and then we’re done looking at the outgoing edges of these six let me just double

check out out yes now we’re ready to move on to the uh the 12 node the 12 node has one outgoing

connection it goes out to the three did i get that wrong in the last video leave a comment

Did I get that wrong in the last video?

Leave a comment.

I don’t know.

And then we’re done with the 12 node.

Now we look at the 15 node.

Oh, that’s why I had that feeling,

because the 15 didn’t go anywhere.

15 has incoming connections, but no outgoing connections,

so we actually can’t write it down here.

There’s no need.

Then we look at the 18 node.

The 18 has outgoing connections to four other nodes.

To the three, with a cost of three.

Am I mind-tripping myself when I’m doing these duplicates?

18 also goes out to the 6 with the cost of 8.

Didn’t trick myself that time.

The 18 also goes out to the 12 with the cost of 2.

And then the 18 also goes out to 15 with the cost of 9.

I just realized recently it’s a good idea to make faces at the camera for emotional thumbnails.

I don’t know if you’ve picked up on that yet, but yeah.

if you’ve picked up on that yet but yeah so let me just double check that i’ve got like nine edges

and nine entries one two three four five six seven eight nine so i think i probably did it all right

now there’s a problem um i’ve been talking about this in in the recent videos there’s a problem

with this type of representation what if you are scanning through the edge list and you’re like

well i’m scanning this edge and that edge and that edge and that edge and that edge and then i come

to the 18-6 edge

and I think, well now I found

and i think well now i found some edge that was interesting for whatever reason

maybe if i was scanning or doing some kind of like a operation that might have costed linear time so

you don’t have to know about this uh this is in other videos but basically it’s not incredibly

scalable it’s not incredibly fast it is technically scalable just not incredible

linear time based on the number of edges so that kind of sucks because if i wanted to do something

with those nodes with the 18 and

with those nodes with the 18 and the six node i would then have to do another linear scan

to find each node i’d have to go into my vertex list and i’d have to say well where the heck are

those things where’s 18 nope nope nope nope nope uh found the 18 and then there’s another scan

to find the six so really this is going to end up being um linear time based on the number of edges

and also the number of vertices so that’s a little bit slower not

a little bit slower not too great the upgrade that we’re going to do which we’ve been doing

in all the other videos of of these recent edge list representations is i’m going to

first i’m going to duplicate the vertex list like this

and then i’m going to show you that each node each vertex has an index so i’m going to say

one this is index two it’s index three when i type too hard i think my hand shakes the table

that kind of sucks i need shock absorbers for my galumpiness oh so we have uh an index for every

single vertex what if we uh what if we copy pasted the edge list over here on the left

um what’s going on it’s not oh there it is dumb okay what if we copy pasted it and then we

converted all of the values.

at all of the values uh or um i guess you maybe on the left side if you if you’re doing this in

the code you might put pointers instead of values so we’ll just say that we’ll convert the pointers

or these values into indexes so this first tuple we’re describing the edge that goes between 3 and

13 with the cost of 1 3 is sitting at index 0 in the vertex list so i’m going to change it to a 0

13 is sitting at index 1 I’m going to leave the weight alone and

I’m going to leave the weight alone, and then I’m just going to convert every other tuple

to indexes. So the 13 node, that’s sitting at index 1. The 6 node is sitting at index 2,

leave the weight alone. The 6 node is at index 2, the 12 node is at index 3.

The 6 node again is at index 2. The 15 node is at index 4, again leave the weights alone.

The 12 node is sitting at index 3, the 3 node is sitting at index 0, leave the weight alone.

The 18 node is sitting at index 5.

The 3 node is sitting at index 0.

I think I’m going too fast.

I’m probably going to screw something up.

We’ve got index 5 there for the 18, and then 6 is index 2.

18 is index 5.

12 is index 3.

18 is index 5.

15 is index 4.

So all I did was just convert every node value or pointer, if it’s in your code, to an index that references the vertex list.

the vertex list why would I want to do this okay so like last time we said we

would do O of E it would be linear time based on the number of edges if we’re

performing some sort of a search or examination of all the edges so we have

to like scan all the edges and then eventually we come to something we’re

interested in maybe we realize oh that’s that’s a special edge we want to see

what’s going on there maybe we want to grab those nodes and extract more

information from them or modify them or do something to them this representation

tells us

this representation tells us exactly where to go,

because this 5 is an index, it’s not a node value.

Same thing for the 2.

So index 5 gives us the 18,

and index 2 gives us the 6.

Notice how we still actually were looking for the 18 and 6 nodes,

like we were in the previous, I guess, representation.

So now, instead of scanning the vertex list,

we can just jump directly to an index,

jump directly to an index and you know remember like if you’re using an array or a vector it’s

going to be constant time to jump to an index it’s like very very fast it’s the holy grail

of time complexities so it’s really going to be something like o of e plus c or one or whatever

you want to call it but it’s going to reduce to just o of e so it’s going to be a little bit

faster notice how you know this one is going to take more time than that one maybe i’ll put it in

red to make the

it in red to make the the more than the greater than operator feel feel bad and evil but anyway

this is how you do edgeless representation if you’re interested in the in all four uh types

of graphs being represented with an edgeless representation check out all my other videos

please leave a comment with ideas for stuff you want me to go over but i think i’m finished with

this video it’s been 15 minutes already i don’t remember what i forgot to say but i guess we’re

done now thank you so much for watching

we’re done now thank you so much for watching i hope you learned a little bit of stuff and had a

little bit of fun i’ll see you in the next video i’m gonna get my gear i’m just kidding i’m gonna

eat a bunch of cookies i’m just kidding i shouldn’t do that but i probably will

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 subscribe and follow

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 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 could feel

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 videos I published, and the services, and

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 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. I’m like this

It would really it really mean the world to me. I would really appreciate it. So again, thank you

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.

ご視聴ありがとうございました

Teksting av Nicolai Winther

Hey there!

The post Directed Weighted Graph Edge List Representation appeared first on NeuralLantern.com.

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.

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.

Hello there. Lets talk about graphs and whether they are connected or not or maybe whether they are strongly connected versus weakly connected. We look at undirected graphs first and show what makes a graph connected meaning every node can reach every other node by a path. We add edges and check the connections step by step while also noting subgraphs. Then we switch to directed graphs and explain strongly connected versus weakly connected. Strongly connected follows the edge directions for every path. Weakly connected ignores the directions and checks if the graph would still be connected. Examples show how adding edges changes the status of the graph.

00:00 Introduction to Graph Connectedness
00:01 Drawing Nodes and a Disconnected Graph
01:56 Defining a Connected Graph
03:21 Introducing Subgraphs
04:48 Adding Edges to Create a Connected Graph
06:32 Adding Directions to Create a Directed Graph
08:03 Strongly Connected Versus Weakly Connected
08:34 Removing an Edge to Show Disconnection
09:29 Checking and Achieving Weak Connectivity
11:18 Adding Edges to Create a Strongly Connected Graph
13:20 Confirming the Strongly Connected Graph
13:32 Conclusion
14:17 Outro 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 graphs and whether they’re connected or not or maybe whether they’re

strongly connected versus weakly connected versus not connected. You never know.

Okay, so hopefully you’ve seen my previous videos by now where we just talked about the basics of

paper here i’m just going to start drawing a graph remember graphs are nodes and edges where

the nodes are like little t-type data structures that can hold a specific type of value um so i’m

going to say our our nodes hold integers um i think i made that one too small that’s okay

and the edges uh could have weights or maybe not weights at all depending on if you have

a weighted or an unweighted graph so i’m just going to start duplicating my nodes a little bit

going to make a random graph. I need to probably change these values. Technically your graphs

should support duplicate values in the nodes and also the weights, but I don’t want to because

it’s easier to talk about the graph when all the values are distinct. So for starters, we have a

bunch of nodes and they’re not really connected to each other. Is this a valid graph? Yeah it is.

It’s just not a connected graph. So the terminology that we’re going to use for

undirected graphs meaning the edges don’t have direction is going to be connected or not you

know i usually just say a not connected graph or a disconnected graph so just basically like

connected or not connected okay so this is a not connected graph i’m going to say not connected

not cinnamon i’m thinking about food as usual

connected graph why is it not a connected graph well to define what does it mean to be a connected

graph it just means that every single node can find a path to every single other node

in an undirected graph so we can just double check this real fast we can say you know can

node number two find a path to uh you know let me put a question here let’s say we’re going to check

you should be checking all the nodes one by one by one to see if if the node in particular can

first node that can’t do it means the whole graph is not considered connected so you know two it

can’t reach one so that means it’s not a connected graph so this is not a connected graph because one

or more nodes violate the rule of you have to be able to reach every single other node okay so that

means if we want a connected graph we probably just have to start adding edges so I’m going to

go ahead and uh let me let me write the word connected here and then I can like either circle

cross it out. So right now we have no, this is not a connected graph. I’m going to start adding

edges. We’re going to stick with an undirected graph for now. So I’m going to connect two and one

and two and nine, maybe one and 13. Actually, you know what? I’m going to erase this edge

and maybe connect these over here. And the thing is, this is a valid graph that you’re looking at.

it’s just not a connected graph.

Some other terminology I didn’t mention in other videos

is that we can have subgraphs.

We have like a subgraph here and another subgraph here.

Those are basically just two different portions of the same graph

that appear to be connected within themselves.

So those are subgraphs.

You can probably tell right away that this is not a connected graph.

You can double check to be sure.

You know, it’s good to do things the hard way

so you don’t get the wrong answer

when you’re really trying to figure something out.

So let’s look at two.

So let’s look at two. Can two reach one? Yes. So that’s good. Can two reach nine? Yeah,

it just hops to one and then hops to nine. So two can reach one and also nine. That’s good.

Can two reach three? Nope. So this is still not a connected graph.

Okay, I’m going to add one more edge. And then we’ll just check again.

Where do you think I’m going to do it? Maybe if I add, I’ll add a funky edge going from 13 to like

to like nine or something just so it feels a little bit more awkward okay let’s check one by

one by one let me actually get rid of this edge on the previous slide so we can still say that’s

not connected let’s check one by one by one every node must be able to reach every single other

node so I’m gonna look at two and I’m gonna say all right two can it reach one yes can it reach

to nine. So that’s good. Can it reach three? Yeah, it can go from two to one to nine to 13

to three, and then it can reach three. And because we just saw that it went through 13 to reach three,

that means two can reach every single other node. This is going to be more important as a double

check when we have directed graphs in a second. So two is good. So the next thing you want to do is

the next thing you want to do is just move on to some other node and do the exact same process you

know can can nine reach a one yes okay it can reach a one can it reach a two yeah it goes through

the one can it reach the 13 yep can it reach the three yep okay so we just check every single

destination node starting at the node nine but here’s a little bit of a shortcut try to find a

node that is right next to a node that you know can reach everything and if the node in question

that previously connected node, vertex,

then we know that that node in particular is also connected.

So what I’m saying is the one,

instead of checking every single other node in the graph,

which might be really hard

if we have a whole bunch of nodes in our graph,

we’ll just ask, can the one reach the two?

Because if it can, the two can reach everything.

So that means the one actually can reach everything as well.

So the one can reach the two.

So the one is connected to everything.

the three, the three can reach the one and the one can reach everything. I’m doing things the

hard way on purpose just to prove a point. So the three can reach everything. The 13 can reach the

three in one hop. So the 13 can reach everything. The nine, it can reach the one and it can reach

the 13 in one hop. So the nine can also actually reach everything. So that means this is indeed a

the next thing that we’re going to do is add direction to our graph you know we could do like

more examples maybe leave a comment if you want me to do some super extra complicated examples for

just a undirected and connected graph i’m ignoring weight by the way because it doesn’t really matter

for these purposes so let’s upgrade our graph so uh maybe i should put a question mark here

that would have been a good idea we’re just asking you know is it connected or not

And I’m just going to start adding direction to every single edge.

Let’s see if I’m following my notes.

Single node, subgraphs, right?

Well, it wasn’t connected at first and then we started adding.

Okay, so that’s basically okay.

Let’s add direction to every single edge.

So every single edge has to have a direction

or every single edge has to have no direction.

You can’t really mix and match.

So I’m just going to go through every single edge and add a direction like this.

and you know to be fair I think I’ve said this in my other videos an undirected edge is kind of the

same thing as a directed edge going in or two directed edges going in both directions so this

3 and 13 what’s going on with my computer hello this 3 and 13 edge it would have kind of been the

same as just having two edges going in opposite directions so maybe I’ll just do that right now

for this huge weird edge I’m just going to put like an arrow over here instead of totally redrawing

Then I double check that every single edge has a direction so that I have a valid graph.

And now I can ask, is this connected or not?

Actually, when it comes to a directed graph, you don’t really have connected or not anymore.

You have strongly connected versus weakly connected.

Maybe I should just separate these words and then just kind of like move them.

So let’s get rid of this.

to this save this over here move it down so what am i talking about um well first let me remove an

edge real quick i’ll remove this edge right here so now we have two sub graphs in this graph you

can tell for sure if this was an undirected graph it would not be connected but now that we’re

dealing with direction we have to ask is it strongly connected versus weakly so what does

can every node reach every other node if you obey the direction of the edges so that’s clearly not

true there’s no edge at all that even connects this one and nine so it’s definitely not strongly

connected weakly connected on the other hand means if you temporarily ignore the direction

of the edges then could you consider the graph connected so if we pretended that there were no

arrows here would we think that it’s a connected graph if the answer is yes then it’s at least a

So this is not weakly connected because if this was an undirected graph, it’s not even connected at all.

So that sucks.

I’m going to go ahead and add another edge here.

So I’m going to add an edge from 2 to 9.

So the first thing is, oh, sorry, I have to add another edge.

Let me do from 1 to 13 for fun.

So now the first thing is, let’s check to see if this is a strongly connected graph.

node is unreachable by any other node so this is definitely not strongly

connected because all the other nodes would be would have to be able to reach

too alright so first thing you could do just to very quickly check is just look

at every single node and ask is it reachable you know by anything and then

after that you can do things the hard way so it’s not strongly connected what

about weakly connected if we ignore the direction of the graph sorry if we

then yeah, we could reach every single node from every other node. Let’s just double check that

real fast. I’m going to say, you know, the two node, if we’re ignoring direction, can it reach

the one? Yes. Can it reach the 13? Yes. The three? Yes. Can it reach the nine? Yes. So that means the

two node is sort of like weakly connected to every other node in the graph. Do the same thing for the

one node. Previously, we just said, you know, check everything one by one or use a shortcut.

one by one or use a shortcut. So I’m going to use the shortcut. The one node, if we ignore direction

can reach the two nodes. So I’m going to say the one is weakly connected, at least everything else.

I’m not even going to check to see if it’s strongly connected to everything else. I think the answer

is no, but we do the same thing for the 13. The 13 can reach the one pretty fast. The three can

reach the 13. The nine can reach the two. So every single node can weakly reach. That’s not an

a weakly connected graph. Okay, cool. How can we make this a strongly connected graph? Well,

we just have to add a bunch of edges. So that’s what I’m going to do. I’m going to kind of like

look at what is missing here. So we’ll ask the two, can the two reach and let’s obey the direction

of the edges again. Can the two reach the one? Yes. Can the two reach the 13? Yes. Can it reach

Yes, so that means right now the two is strongly connected to everything else.

So we’re on track for a strongly connected graph.

We then look at the one node and we realize that the one node,

it can reach the 13 and the three and it can also reach the nine,

but it can’t reach the two.

That’s one thing that was blocking us last time from saying strongly connected.

So we just have to add another edge if we want this to be a strongly connected graph.

We have to figure out how can we get the one to reach the two.

the 2 we can go through something if we want to that’s fine we can also just

write an edge that just goes back to the 2 but that’s I don’t know that’s kind of

boring I’m gonna make an edge that goes from 1 to 9 and then I’m gonna make an

edge that goes from 9 to 2 so looking at the 1 node it can now reach the 2 if we

go through the 9 so that’s good can the 1 reach the 9 yes can the 1 reach the 13

three yes okay so the one node can now reach every single other node so now we’re a little bit more

on track for a strongly connected graph look at the 13 node can it reach the one node um actually

yes if we go from 13 to 9 and then 2 and then 1 we can reach the one node since we know the one

node is connected to everything else we can now say that the 13 node is connected to everything

13 so i’ll say three is connected to everything the nine node can reach the two node which is

connected to everything so that means the nine node is also connected to everything and at this

point we now have a strongly connected graph it’s not weakly connected it’s stronger than that

any questions um so let’s see we added a bunch of uh edges i think maybe this is actually all we

need to do for this particular video because we’re just going to talk about connectedness

going to talk about connectedness about 15 minutes not too bad all right so i think i’m

going to leave it here drop a comment if you want to do way more complicated examples if you want to

provide me a sample graph that’s awful and i could just i don’t know in the sometime in the future i

could record a video about it um or just let me know your thoughts thank you so much for watching

this video i hope you had a little bit of fun and i hope you learned a little bit of stuff i’m outie

Patowdy.

Alright, let’s see.

I’m going to do this.

Whoa. Can you see that guy in the background?

Oh, shoot.

I’m just kidding.

I set that as the screensaver.

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,

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

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 just wake up. I promise

that’s what will 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

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

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

Thank you.

so

I’m going to go ahead and get started.

so

Yeah, I think I’m good.

Hello there.

Let’s talk about whether a graph is connected or not,

or maybe whether it’s strongly connected or weakly connected or not connected at all.

You never know.

The post Graph Connectedness Explained: Connected Strongly Connected and Weakly Connected appeared first on NeuralLantern.com.

In this video we break down the four main types of graphs used in computer science: undirected unweighted, undirected weighted, directed unweighted, and directed weighted.

We start with the basic idea of graphs – collections of nodes (vertices) and edges – and then explore each type with clear examples. Learn how these graphs represent real-world relationships like computer networks, airport routes, road maps, and game maps.

Perfect for anyone learning data structures, algorithms, or preparing for coding interviews.

00:00 Introduction to Graphs
00:19 Basic Graph Definition
00:48 Nodes and Vertices
01:01 Empty Graph Example
01:17 Graph Implementation Concepts
02:02 Node Data and Templates
03:22 Adding Nodes
04:00 Adding Edges
04:44 What Graphs Represent
05:36 Graph Use Cases
06:56 Real-World Examples
08:35 Four Types of Graphs
08:52 Undirected Unweighted Graph
10:40 Unweighted as Unit Weights
11:40 Undirected Weighted Graph
13:32 Weighted Graph Benefits
15:52 Directed Weighted Graph
19:50 Directed Unweighted Graph
20:32 Summary of Four Graph Types
21:19 Closing 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

Hello there! Let’s talk about four different types of graphs that you can use and how they relate to computer science.

Okay, so you can see like I’ve got like a blank little graph paper up here.

I’m going to talk about graphs and just the very basic idea of graphs in general

and then show you the four different types of graphs that we have.

about how to implement graphs inside the machine, time complexities, maybe graph algorithms,

and a whole bunch of stuff, terminology, everything. Okay, so the first thing is, I guess I’m going to

assume probably most of you have sort of seen a graph before and you kind of understand a little

bit about it already, but I’ll say that a graph is basically a collection of nodes, also known as

vertices or vertexes, and edges, which are the lines that connect nodes to each other. This screen

See, this is a valid graph.

I’m not talking about the graphing paper.

It’s just an empty graph.

There’s nothing there.

So it’s still valid.

It’s just blank.

Okay, so then what I want to do is start drawing some nodes.

What are the nodes again?

Those are just vertices.

Those are just like little data structure objects you can imagine in the code.

I don’t want to get too far ahead of myself, but imagine that you have a class called graph.

This is just one way to imagine.

We have a class called graph and then a nested class inside of a graph called a node or a vertex

If you want to be more fancy

So the vertex class itself by the way

This is not always going to be the way that you actually do this in your code the other representations that we’ll talk about sooner a little bit easier, but

The vertex class itself needs to basically hold some data

Depending on your implementation it might know about who it’s connected to maybe the graph knows that instead

instead. In my implementations, the graph is going to know everything, but the vertex or the node

itself needs to hold one piece of data. That’s kind of the whole point. So I’m going to say that

the data type that these nodes hold are just integers. So I’m just going to put like a six in

here just to indicate we have one node and the templated data type that it holds is an integer.

And the specific integer for this specific node is just the number six. You can have any template

any template type if you really want to you can people put floats in there you could put a custom

custom class in there whatever you want but i just want to show you that we have a class called

vertex or node and inside of it’s got a template type maybe just to make this a little bit more

clear i’ll say you can imagine inside the vertex class uh there is a template type and we’ll call

it uh i don’t know node node value type or something and we’ll call it data and then up

I’m doing C++ up here.

We have to kind of define the whole graph class as a template class.

Now, of course, you could define the vertex class as the template class,

but if you define the graph class as a template, then it all kind of falls through.

So I’m just going to say class node value type.

And so if you’ve written template classes before in C++,

now you know that the user can instance the graph and at the same time,

specify what is the data type of the stuff that the nodes hold.

the stuff that the nodes hold.

We do the same thing for edges too,

but notice how there are no nodes that are connected to each other.

So we have no edges in this graph.

This is still a valid graph,

but we could just sort of copy a node just for fun and say,

all right, we’ve got two nodes now, two vertices.

They could have the same value if you want.

Graphs are supposed to, you know, support duplicate values in the nodes,

but I’m just going to change the value here.

This is also a valid graph.

You don’t really need edges to have a valid graph.

edges to have a valid graph. This is just something called a something called a graph that is not

connected. We’ll talk about all that terminology and how to detect it in a future video. For now,

I’m just going to say we have like a little graph here, which is kind of boring, but I’m going to

add an edge. An edge is basically just, you know, a little mini data structure that connects two

nodes. Depending on the way you represent this in the machine, which we’ll talk about in future

well, a whole bunch of different ways.

You could imagine this as a full-fledged class,

although that’s not always going to be the way that we represent an actual edge.

So imagine that we have a nested class called edge.

And inside the edge class, we’ve got, you know, some stuff.

We could have a weight, which means the cost of traveling against the edge.

We could have many other properties.

For now, I’ll just try to keep it simple.

is pretty much a collection of vertices and edges and some sort of connection.

What is a graph really for?

Some people at first think that a graph is another way to represent a database.

I’m going to erase this thing over here.

Graphs, you could sort of use them as databases,

but they’re not very good as databases because

it would be really, really slow to search through the graph

to find some piece of data that you’re looking for.

It could be like a linear time database.

better would be to take this graph and add a bunch of rules as you probably have found

in my other videos by now and turn it into a binary search tree.

A binary search tree is lightning fast.

It runs in log time.

Hash tables are faster than binary search trees, but basically a graph is always going

to be way slower than a binary search tree unless the binary search tree is severely

imbalanced.

But that’s something for another video.

Anyway, so we have a graph and it’s not a good database.

What would a graph be good for?

would a graph be good for? Well, graphs are usually pretty good to help you represent

relationships between things. For example, the six and the one, imagine the six is something,

maybe it’s a computer, maybe it’s a city, maybe it’s, I don’t know, like a train station,

and the edges could represent connections. So I’m just going to start changing these values

have some nodes just kind of hanging out off to the side, not really connected to anything.

Maybe not great for your particular use case, but like it’s a valid graph. So I’m just going to,

I’m just going to connect this and try to make this into a better graph.

That’s a little bit more interesting. So we’ve got graphs that do a whole bunch of different

things. Let me change these values real fast. I’ll maybe turn that into a 13 and turn that

So imagine that we have like a little connection here, a little connection here, maybe another

connection here and another one there.

And you know, you are allowed to have connections that sort of look weird, like going from this

six all the way around to this 13.

That’s totally valid also.

So I’ve basically just drawn a random graph, random nodes and random edges.

Imagine that every single node here is a computer in a computer network and imagine every edge

every edge which connects the nodes is just some sort of a connection let’s say a network cable

or a wi-fi signal or something like that so if you imagine it that way then this graph could

represent a network topology a bunch of computers connected together if these were cities and this

is like actually maybe these are airports in cities you could imagine a graph could represent

the relationship between different airports in which planes will fly notice on this graph just

that the uh you know the uh the city number one uh there are no flights connecting it directly to

city 44 but you could probably imagine well if we take a flight to uh from city one to city 10 and

then from city 10 to 44 then we can get from one to 44 we just have to be clever about our connecting

flights um let’s see so we could do like road maps airport maps the worldwide web is basically a graph

at least from a certain perspective electrical circuits that are connected to each other

are connected to each other even game maps what if your character is allowed to stand here in

in space number three on some map and the character is only allowed to travel to space 13 or

space 6 but not directly to space 1 well it could be a map that helps you understand where your

character can go in a game okay so that’s like the basic idea of of what a graph is and uh how it

actual four types of graphs that I’m going to go over in more detail in future videos. Let’s see,

what time is it right now? We got like 10 minutes. Okay, so I can still kind of make this fast.

So the first type of graph that we’re looking at right now is actually something called an

undirected, unweighted graph. Why is it, let’s see, let me write this down first. It’s an undirected,

undirected, unweighted graph. So why is this undirected? Because the edges don’t have direction.

If I was standing in, you know, city six and I wanted to like drive or fly or whatever

from city six to city three, then I should be able to do it because this edge that connects

them doesn’t really say that I have to go in one direction or the other. I could also go to city

three and then just walk right back or fly right back to city six. There’s no direction. So there’s

no direction. So there’s an this that’s that’s why this is an undirected graph. This is an

unweighted graph because we haven’t specified a cost for traveling along an edge. For example,

if you know, if you’re at city three here, and you want to fly to city 13, how much jet fuel

does it cost? How much time does it cost? If three is a computer and 13 is a computer,

and the edges like a network cable, like how much money does it cost to transmit the data?

transmit the data or what is the lag in milliseconds.

You know, you can represent all sorts of things with these edges,

but there’s no value on these edges,

which means there are no weights to these edges.

So that’s why this is an undirected and also unweighted graph.

Uh, the first upgrade that I want to do is just kind of show you what you can

sort of assume about an unweighted graph. This is not always true.

It just depends on who you talk to and what your application implementations are.

So imagine the node that goes from six, sorry, the edge that goes from six to one.

If it’s an unweighted graph, you could just probably imagine that every weight is just a one.

The point being that it always costs the same amount to travel along every edge,

because in an unweighted graph, we don’t differentiate between the different edges

in terms of their costs.

We could just put a bunch of ones on all these edges.

And it would still, you know, basically be considered an unweighted graph.

It depends on who you talk to.

maybe all the weights are zero, maybe all the weights are 10 or whatever.

But, you know, usually I put a one there because I’d like to imagine the cost could just be the number of hops.

So, for example, if I wanted to go from city six to city 10,

I could probably, you know, start at city six and then go to city one and then hop to city 10.

How many actual hops did I do? I did two.

I could also come up with that number by just looking at the sum of all the weights of all the edges.

all the edges. So notice how when I go from six to one, that costs me one weight or one hop. And

then when I go from one to 10, that’s another one. So if you put ones on all the edges in an

unweighted graph, then you’re kind of saying the total cost of some path is really just the number

of hops. So it’s up to you. Anyway, that’s unweighted and undirected. Let’s upgrade this

see we have an undirected and unweighted and i’m just going to duplicate this real fast and change

this to a weighted graph so undirected but also weighted and the thing is as soon as you start

putting numbers on a graph on the edges of a graph well then it’s considered weighted so even even a

graph that has all ones on all the edges you could also call that weighted but now you have the

freedom since it is considered a weighted graph to just assign different values to all the edges

to all the edges. Again, these edges are a class sometimes, or you can think of them that way

inside the graph. And the edge weights themselves are definitely considered a T type, a templated

type, which means, you know, right now I’m clearly typing integers, but you could type some other

data type. You could type floats. You could type some weird data type, like a string.

Whether or not that’s going to be useful depends on your program, you know, what you’re trying to

you know, what you’re trying to do with the graph. But let’s see, I think I’ve added custom numbers

to every single edge. So now this is definitely an undirected, but weighted graph. That’s the

second type of graph that we’re talking about. Okay, what’s what’s cool about a weighted graph?

Well, imagine again, that this is an airport map, where we’re representing relationships between,

you know, cities, like where can we fly and stuff. We’re basically saying at this point,

it’s going to cost you 44 of something.

Maybe this is a graph representing jet fuel or time or frequent flyer points or something like that.

If you consider your edges to be custom classes,

you could even put a whole bunch of different types of values in your graph at the same time

to make it a little bit more flexible.

But for now, we’ll just say there’s one templated type,

which means if we go back up to this code real fast, where was that code at?

Where was that code at?

And we had, you know, our rough idea of, you know, what the, what the graph holds, you

know, it holds like vertices and edges.

We could upgrade this just a little bit to say that there is a, an edge value type.

So I’m going to say class edge value, edge weight type, something like that.

for the edge so that I can save characters. And then here, I’ll change this to a type for the

node. This is why we call it T type. There’s like, we put the keyword template here in C++.

And then sometimes people just use T’s here for these tokens. So I’m just going to say

the type of data that a node can hold is going to be the T node. And then the type of data that

the edge could hold would be the T edge. We’ll call that data. Or we could call that weight,

because usually that data comes into play when you’re traveling along an edge, right? So there’s

traveling along an edge, right? So there’s like two different types here. Anyway, so we got an

undirected and unweighted graph. If we traveled from city six to city one, that costs us 44. But

if you look at the graph a little bit more closely, we could take the longer way around. We could say

go from six to three, and then go from three to 13. And then actually, let me change the color

to orange so that you can see there’s different paths, six to three, and then three to 13,

and then 13 to one, even though we took more hops,

and that might have been considered more expensive

in an unweighted graph,

you can see that the cost of the first path

from six to one, that’s 44.

And the cost of the second path is seven plus three,

that’s 10, and then plus nine, so that’s 19.

So if we take the long way,

it actually costs us less

of whatever we’ve determined this unit is.

You know, less jet fuel, less time, less whatever.

less whatever these graphs in the machine are not necessarily going to be to scale because the

machine in your computer your computer doesn’t really keep track of like the physical positioning

of all these nodes and edges it just can keeps track of the relationship between the nodes and

the edges and the weights and all that stuff so two different paths that we could take to get

from six to one one of the paths is less expensive um or less time costly or just whatever and a graph

data structure can kind of help us figure that out if we’re using an algorithm that understands

weights okay so undirected and unweighted let’s add direction so um i’m going to erase this stuff

right here real quick and in an undirected graph remember you can just kind of go in either

direction along any edge but in a directed graph every single edge needs to have a direction so as

I change one of the edges to have direction, then I must change all of the edges to have direction

as well. So I’m just saying, okay, as soon as I did that, now this is an invalid graph

because some of the edges don’t have direction. So now I need to fix everything. So I just,

I’m going to arbitrarily and randomly choose a direction for every single edge like this.

And then as soon as I’m done, I’m going to deal, I guess, with that giant edge

that giant edge. So I’m going to go like that. So let’s see, all the edges seem to have direction.

Now I’m just going to hand draw an arrow on one side of this giant edge. Okay. So this is directed

and also weighted. What can we do with the directed graph? Well, it just basically tells

you which direction you’re allowed to travel in. What if you have an airport where city six can

only fly to city one, but city one, for some reason, never flies to city six. You got to take

take like the long way you got to go from city one to 13 to three to six that’s something that

a graph could help you represent what if your character in your game can only go in one direction

but not the other direction okay no problem i mean that’s pretty much it you’re only allowed

to travel in the same direction as the edge points but now we have a graph that is a lot less

flexible because for example before we used to be able to go from city uh 10 to city 44 and then

then come back again later if we wanted in the opposite direction. We can no longer do that

because this edge only goes to 10. It doesn’t even go to 44. We can’t even ever actually get to 44.

How do you sort of solve that? Well, just add another edge in the opposite direction.

In graphs, you are allowed to do something called a parallel edge,

which just basically means, you know, two edges between the same pair of nodes that just point

in the same direction. You’re also allowed to do, you know, opposite facing edges. So

edges so i just added a second edge there going from 10 to 44 and now if i was you know hanging

out in city 10 i could just go back and forth between city 10 and 44 as much as i wanted to

oh i forgot to add an edge weight for that new edge which means i wrote down an invalid graph

so i’m just going to say two so uh maybe the wind is blowing in in your favor when you’re going from

city 10 to city 44 maybe it’s blowing against you if you’re talking about city 44 to city 10 you

you know whatever but you just have to have edge uh edge weight on every single edge

okay so uh that’s directed and also weighted um and you can probably imagine previously when we

had an undirected um graph when there was just like you know one edge going between uh two nodes

and there was no direction on it like you know 44 to 10 if we just had like one edge with no

have two edges each going in the opposite direction so we have directed and weighted i think the last

thing that we didn’t do was directed and unweighted right so we have let me just double check real

fast here we have undirected and unweighted and then we had undirected and weighted and then

directed and weighted okay so now let’s do um i’m getting lost already oh my gosh i can’t believe i

I saw undirected and unweighted so we did undirected twice already undirected so we’re

going to do directed and unweighted next okay so the next graph a little bit less useful than

what we’re looking at this this type of graph is a little bit more useful we’re going to do

directed and unweighted oh my god okay directed and unweighted so directed and unweighted you

Directed and unweighted, you can imagine, just means we get rid of all these weights.

And then we keep the direction on all the edges.

So this means we can keep track of where we’re allowed to go, if we’re pathfinding or just whatever.

But we don’t really know what it costs to travel between the different graphs.

So that’s directed and unweighted.

Let’s see here.

I’m going to just duplicate this or just make a new blank slide.

Okay, undirected, oh gosh, I’ve got pink letters.

Let’s see, undirected plus unweighted.

And we’ve got undirected plus weighted.

And then we’ve got directed plus unweighted.

I don’t think I’m writing these down in the same order,

but that’s okay.

And then we’ve got directed plus weighted.

So basically, you know, four types of graphs

that we can talk about.

In future videos, we’re going to go over graphs

in more detail.

We’ll talk about graph terminology,

maybe some pathfinding algorithms.

And yeah, so this is just a basic intro.

How much time do we spend already?

Oh God, we spent so much time.

Spent like 22 minutes.

Dang, man, even the smallest thing takes time.

So I’ll see you in a future video

when we talk more and more and more about graphs

and other data structures concepts.

Thanks for watching this video.

I hope you learned a little bit of stuff

I hope you learned a little bit of stuff and had a little bit of fun.

I’m out of here.

Go.

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.

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 you control me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will 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

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 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 I’m like

it would really it really mean the world to me I would really appreciate it so

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

Thank you.

I’m going to go ahead and get started.

Thank you.

Hello there.

Let’s talk about the four types of…

Hello there.

The post 4 Graph Types: Undirected vs Directed, Weighted vs Unweighted appeared first on NeuralLantern.com.