Return to Answer

As you suggest: Discrete (quantized) approaches like BFS, DFS, Dijkstra, A* etc. are typically used with traditional graphs, which form a discrete space.

For continuous (non-quantized) spaces, hill climbing suits better. Continuous (top) vs discrete:

That is, you can take a floating point space like this:

...and move intelligently across it, i.e. perform pathfinding, without needing individual quanta, i.e. nodes or cells. Note that the wireframe shown here exists only to indicate continuous values at that point as defined by f, not any kind of discrete topology. That is, there are infinite values available between every pair of grid lines (i.e. it is a real space).

We can see an example of hill climbing here:

The algorithm is a simple one: find the closest point where the value is higher than the current point, and go there. This is simple enough in a static environment such a set of walls or mountains on a 2D plane.

But how does this relate to, say, seeking an enemy agent in a game? Agents can release/diffuse a scent on every update that creates a "hill" around them that follows them around, and allows others to seek them in that space. You can learn more about this by looking into collaborative diffusion.

Alternative

You can use classification, or "step" / quantise a continuous space (in 2 or 3 dimensions, this is but a 1D example):

float continuous = ...; //some floating point value in range 0..1 with precision down to n decimal places
int numSteps = 5; //some arbitrary integer value
int steppedInt = continuous * numSteps;
float steppedFloat = steppedInt / numSteps; will be e.g. 0.0, 0.2, 0.4, 0.6, or 0.8

...Then operate on it using traditional discrete algorithms like A*.

As you suggest: Discrete (quantized) approaches like BFS, DFS, Dijkstra, A* etc. are typically used with traditional graphs, which form a discrete space.

For continuous (non-quantized) spaces, hill climbing suits better. Continuous (top) vs discrete:

That is, you can take a floating point space like this:

...and move intelligently across it, i.e. perform pathfinding, without needing individual quanta, i.e. nodes or cells. Note that the wireframe shown here exists only to indicate continuous values at that point as defined by f, not any kind of discrete topology. That is, there are infinite values available between every pair of grid lines (i.e. it is a real space).

We can see an example of hill climbing here:

The algorithm is a simple one: find the closest point where the value is higher than the current point, and go there. This is simple enough in a static environment such a set of walls or mountains on a 2D plane.

But how does this relate to, say, seeking an enemy agent in a game? Agents can release/diffuse a scent on every update that creates a "hill" around them that follows them around, and allows others to seek them in that space. You can learn more about this by looking into collaborative diffusion.

Alternative

You can use classification, or "step" / quantise a continuous space (in 2 or 3 dimensions, this is but a 1D example):

float continuous = ...; //some floating point value in range 0..1 with precision down to n decimal places
int numSteps = 5; //some arbitrary integer value
int steppedInt = continuous * numSteps;
float steppedFloat = steppedInt / numSteps; //will be e.g. 0.0, 0.2, 0.4, 0.6, or 0.8

...Then operate on it using traditional discrete algorithms like A*.

As you suggest: Discrete (quantized) approaches like BFS, DFS, Dijkstra, A* etc. are typically used with traditional graphs, which form a discrete space.

For continuous (non-quantized) spaces, hill climbing suits better. Continuous (top) vs discrete:

That is, you can take a floating point space like this:

...and move intelligently across it, i.e. perform pathfinding, without needing individual quanta, i.e. nodes or cells. Note that the wireframe shown here exists only to indicate continuous values at that point as defined by f, not any kind of discrete topology. That is, there are infinite values available between every grid line (it is a real space).

We can see an example of hill climbing here:

The algorithm is a simple one: find the closest point where the value is higher than the current point, and go there. This is simple enough in a static environment such a set of walls or mountains on a 2D plane.

But how does this relate to, say, seeking an enemy agent in a game? Agents can release/diffuse a scent on every update that creates a "hill" around them that follows them around, and allows others to seek them in that space. You can learn more about this by looking into collaborative diffusion.

Alternative

You can use classification, or "step" / quantise a continuous space (in 2 or 3 dimensions, this is but a 1D example):

float continuous = ...; //some floating point value in range 0..1 with precision down to n decimal places
int numSteps = 5; //some arbitrary integer value
int steppedInt = continuous * numSteps;
float steppedFloat = steppedInt / numSteps; will be e.g. 0.0, 0.2, 0.4, 0.6, or 0.8

...Then operate on it using traditional discrete algorithms like A*.

As you suggest: Discrete (quantized) approaches like BFS, DFS, Dijkstra, A* etc. are typically used with traditional graphs, which form a discrete space.

For continuous (non-quantized) spaces, hill climbing suits better. Continuous (top) vs discrete:

That is, you can take a floating point space like this:

...and move intelligently across it, i.e. perform pathfinding, without needing individual quanta, i.e. nodes or cells. Note that the wireframe shown here exists only to indicate continuous values at that point as defined by f, not any kind of discrete topology. That is, there are infinite values available between every pair of grid lines (i.e. it is a real space).

We can see an example of hill climbing here:

The algorithm is a simple one: find the closest point where the value is higher than the current point, and go there. This is simple enough in a static environment such a set of walls or mountains on a 2D plane.

But how does this relate to, say, seeking an enemy agent in a game? Agents can release/diffuse a scent on every update that creates a "hill" around them that follows them around, and allows others to seek them in that space. You can learn more about this by looking into collaborative diffusion.

Alternative

You can use classification, or "step" / quantise a continuous space (in 2 or 3 dimensions, this is but a 1D example):

float continuous = ...; //some floating point value in range 0..1 with precision down to n decimal places
int numSteps = 5; //some arbitrary integer value
int steppedInt = continuous * numSteps;
float steppedFloat = steppedInt / numSteps; will be e.g. 0.0, 0.2, 0.4, 0.6, or 0.8

...Then operate on it using traditional discrete algorithms like A*.

As you suggest: Discrete (quantized) approaches like BFS, DFS, Dijkstra, A* etc. are typically used with traditional graphs, which form a discrete space.

For continuous (non-quantized) spaces, hill climbing suits better. Continuous (top) vs discrete:

[![enter image description here][1]][1]

That is, you can take a floating point space like this:

[![enter image description here][3]][3]

...and move intelligently across it, i.e. perform pathfinding, without needing individual quanta, i.e. nodes or cells. Note that the wireframe shown here exists only to indicate continuous values at that point as defined by f, not any kind of discrete topology. That is, there are infinite values available between every grid line (it is a real space).

Looking again at hill climbing, we can see an example here.

[![enter image description here][2]][2] The algorithm is a simple one: find the closest point where the value is higher than the current point, and go there. This is simple enough in a static environment such a set of walls or mountains on a 2D plane.

But how does this relate to, say, seeking an enemy agent in a game? Agents can release/diffuse a scent on every update that creates a "hill" around them that follows them around, and allows others to seek them in that space. You can learn more about this by looking into collaborative diffusion.

Alternative

There is nothing stopping you from discretising a continuous space and then operating on it using traditional algorithms like A*. This can be as simple as stepping (albeit in 2 or 3 dimensions):

float continuous = ...; //some floating point value in range 0..1 with precision down to n decimal places
int numSteps = 5; //some arbitrary integer value
int steppedInt = continuous * numSteps;
float steppedFloat = steppedInt / numSteps; will be e.g. 0.0, 0.2, 0.4, 0.6, or 0.8

...or as complex as using classification to quantise the problem space. [1]: https://i.sstatic.net/qgBLZ.png [2]: https://i.sstatic.net/3p2Oh.png [3]: https://i.sstatic.net/tUtrP.png

As you suggest: Discrete (quantized) approaches like BFS, DFS, Dijkstra, A* etc. are typically used with traditional graphs, which form a discrete space.

For continuous (non-quantized) spaces, hill climbing suits better. Continuous (top) vs discrete:

That is, you can take a floating point space like this:

...and move intelligently across it, i.e. perform pathfinding, without needing individual quanta, i.e. nodes or cells. Note that the wireframe shown here exists only to indicate continuous values at that point as defined by f, not any kind of discrete topology. That is, there are infinite values available between every grid line (it is a real space).

We can see an example of hill climbing here:

The algorithm is a simple one: find the closest point where the value is higher than the current point, and go there. This is simple enough in a static environment such a set of walls or mountains on a 2D plane.

But how does this relate to, say, seeking an enemy agent in a game? Agents can release/diffuse a scent on every update that creates a "hill" around them that follows them around, and allows others to seek them in that space. You can learn more about this by looking into collaborative diffusion.

Alternative

You can use classification, or "step" / quantise a continuous space (in 2 or 3 dimensions, this is but a 1D example):

float continuous = ...; //some floating point value in range 0..1 with precision down to n decimal places
int numSteps = 5; //some arbitrary integer value
int steppedInt = continuous * numSteps;
float steppedFloat = steppedInt / numSteps; will be e.g. 0.0, 0.2, 0.4, 0.6, or 0.8

...Then operate on it using traditional discrete algorithms like A*.