Building adjacency graph out of chessboard (for dijkstra)

Question

I ran into a problem where I wanted to add a little feature to my homework and it turned out to be overwhelming for me (read bold sentences for question without context).

My program has a list of about 35 items in it, containing information about the map I'm supposed to work with. It can have the following elements:

"Wall" with its coordinates (X, Y), in the dijkstra it is supposed to have weight 100.
"Tree" with cords (X, Y), weight 3

I have a 10x10 map laid out like a chessboard, which means 100 tiles, and 35 items. "Nothing" in the list means weight 1 in dijkstra (it means a normal route)

To make the dijkstra work and be able to find a shortest path between two tiles, I have to build an adjacency graph. My problem here is, how to define tiles "around" the current tile, if all I have is that list?

Only adjacent tiles in the shape of "+" have edges in the graph between them, but I have to run through the list every time to check if there is something on it?

Any lead on the problem would be greatly appreciated, also if you can point me to a source with a code sample, that could also do. I only see really messy code with a lot of "if-elseif-elseif..." to solve that.

Thank you for your time!

Edit: I ended up using @kraskevich 's suggested way, and it works excellent, but all the answers and suggestions were really useful, thank you very much everyone!

This seems based on a misunderstanding, there is no need to *actually build* a graph for Dijkstra, it's perfectly fine (and actually more common) to have the graph "exist" implicitly. — harold, Jun 02 '17 at 18:36
@harold Do you have a pseudo code or just a description somewhere from which I could build the dijkstra without the graph? I would love that! — Dragonturtle, Jun 02 '17 at 18:39
The pseudo code is exactly the same, it never even mentions graphs anyway. Unless you're looking at weirdly low-level pseudo code. — harold, Jun 02 '17 at 18:47
I was looking at this: https://www.programmingalgorithms.com/algorithm/dijkstra%27s-algorithm — Dragonturtle, Jun 02 '17 at 19:01

score 2 · Accepted Answer · answered Jun 02 '17 at 19:13

You don't really need to build a graph. Just create a 10x10 table and put the weight of the corresponding items into it:

board = 10x10 array filled with 1
for item in list:
    if item is a tree:
         board[item.row][item.column] = 3
    else if item is a wall:
         board[item.row][item.column] = 100

After that, you can treat pairs (row, col) of coordinates as vertices and update the distance for 4 adjacent cells when you process a tile. That's it. Sure, you can also create a graph with 100 vertices and add edges explicitly from a tile to all 4 adjacent cells (the weight is the weight of the end of the edge tile) and use a standard implementation.

The most convenient way to iterate over adjacent cells is as follows:

delta_rows = [-1, 1, 0, 0]
delta_cols = [0, 0, -1, 1]
...
for direction = 0 .. 3
     new_row = row + delta_rows[direction]
     new_col = col + delta_cols[direction]
     if is_valid(new_row, new_col)
          // do something

score 1 · Answer 2 · answered Jun 02 '17 at 20:04

It should be straightforward to implement Dijkstra based on this generic graph interface:

interface Graph<T> {
  Iterable<T> adjacentNodes(T node);
  double getDistance(T node, T adjacent);
}

So now all we need to do is to fill it for your case:

class Field {
  final int x;
  final int y;
  int value = 1;
  Field (int x, int y) {
    this.x = x;
    this.y = y;
  }
}

class ChessboardGraph implements Graph<Field> {
  Field[][] board = new Filed[10][10];

  ChessboardGraph(List<Entry> list) {
    for (int x = 0; x < 10; x++) {
      for (int y = 0; y < 10; y++) {
        board[x][y] = new Field(x, y);
      }
    }
    for (Entry e: list) {
      board[e.x][e.y].value = e.value == TREE ? 3 : 100;
    }
  }

  Iterable<Field> adjacentNodes(Field node) {
    ArrayList result = new ArrayList<>();
    int x = node.x;
    int y = node.y;
    if (x > 0) {
      if (y > 0) {
        result.add(board[x - 1][y - 1]);
      }
      if (y < 9) {
        result.add(board[x - 1][y + 1]);
      }
    }
    if (x < 9) {
      if (y > 0) {
        result.add(board[x + 1][y - 1]);
      }
      if (y < 9) {
        result.add(board[x + 1][y + 1]);
      }
    }
  }

  double getDistance(Field node, Field adjacent) {
    assert Math.abs(node.x - adjacent.x) + Math.abs(node.y - adjacent.y) == 1;
    return board[adjacent.x][adjacent.y];
  }
}

Building adjacency graph out of chessboard (for dijkstra)

2 Answers2