How to re-order units based on their degree of desirable neighborhood ? (in Processing)

Question

I would need help to implement an algorithm allowing the generation of building plans, that I\'ve recently stumbled on while reading Professor Kostas Terzidis\' latest publicat

Answer 1

I'm sure the Professor Kostas Terzidis would be an excellent computer theory researcher, but his algorithm explanations don't help at all.

First, the adjacency matrix has no sense. In the questions comments you said:

"the higher that value is, the higher the probability that the two spaces are adjecent is"

but m[i][i] = 0, so that means people in the same "office" prefer other offices as neighbor. That's exactly the opposite that you'd expect, isn't it? I suggest to use this matrix instead:

With 1 <= i, j <= 5:

              +----------------+
              | 10  6  1  5  2 |
              |    10  1  4  0 |
    m[i][j] = |       10  8  0 |  
              |          10  3 |
              |             10 |
              +----------------+

With this matrix,

• The highest value is 10. So m[i][i] = 10 means exactly what you want: People in the same office should be together.
• The lowest value is 0. (People who shouldn't have any contact at all)

The algorithm

Step 1: Start putting all places randomly

(So sorry for 1-based matrix indexing, but it's to be consistent with adjacency matrix.)

With 1 <= x <= 5 and 1 <= y <= 7:

            +---------------------+
            | -  -  1  2  1  4  3 |
            | 1  2  4  5  1  4  3 |
  p[x][y] = | 2  4  2  4  3  2  4 |
            | -  -  -  -  3  2  4 |
            | -  -  -  -  5  3  3 |
            +---------------------+

Step 2: Score the solution

For all places p[x][y], calculate the score using the adjacency matrix. For example, the first place 1 has 2 and 4 as neighbors, so the score is 11:

score(p[1][3]) = m[1][2] + m[1][4] = 11

The sum of all individual scores would be the solution score.

Step 3: Refine the current solution by swapping places

For each pair of places p[x1][y1], p[x2][y2], swap them and evaluate the solution again, if the score is better, keep the new solution. In any case repeat the step 3 till no permutation is able to improve the solution.

For example, if you swap p[1][4] with p[2][1]:

            +---------------------+
            | -  -  1  1  1  4  3 |
            | 2  2  4  5  1  4  3 |
  p[x][y] = | 2  4  2  4  3  2  4 |
            | -  -  -  -  3  2  4 |
            | -  -  -  -  5  3  3 |
            +---------------------+

you'll find a solution with a better score:

before swap

score(p[1][3]) = m[1][2] + m[1][4] = 11
score(p[2][1]) = m[1][2] + m[1][2] = 12

after swap

score(p[1][3]) = m[1][1] + m[1][4] = 15
score(p[2][1]) = m[2][2] + m[2][2] = 20

So keep it and continue swapping places.

Some notes

• Notice the algorithm will always finalize given that at some point of the iteration you won't be able to swap 2 places and have a better score.
• In a matrix with N places there are N x (N-1) possible swaps, and that can be done in a efficient way (so, no brute force is needed).

Hope it helps!