Matrix construction algorithm - algorithm

Question

I have a small question related to optimization. I have a json, in which an array of elements describing the path, i.e. from the first one can rise to the second, from it to the right to the third, and so on.
[
{
"number": 1,
"upperLevel": 2
},
{
"number": 2,
"rightLevel": 3,
"leftLevel": 4
},
{
"number": 3,
"lowerLevel": 6
},
{
"number": 4,
"upperLevel": 5
},
{
"number": 5
},
{
"number": 6,
"lowerLevel": 7
},
{
"number": 7
}
]
These paths can be different.
I need to build a matrix out of this.
5 0 0
4 2 3
0 1 6
0 0 7
The problem is that the elements do not have an exact position where they are on the matrix, and it is not clear where to initially place the first element, so as not to go beyond the size of the array later. To avoid this, I specify the size twice as large as the number of elements, and put the first one in the center, so that wherever the path goes, it does not go beyond the boundaries.This is what my algorithm looks like.
val matrix = buildMatrix(
levels = data.map { it.number to it }.toMap(),
matrix = MutableList(data.size*2) { MutableList<Level?>(data.size*2) { null } },
obj = data.first(),
processedLevel = mutableSetOf(),
x = data.size,
y = data.size
)
matrix.reverse()
There is a bit of recursion here.
private fun buildMatrix(
levels: Map<Int, Level>,
matrix: MutableList<MutableList<Level?>>,
obj: Level,
processedLevel: MutableSet<Int>,
x: Int,
y: Int
): MutableList<MutableList<Level?>>{
if(processedLevel.contains(obj.number)) return matrix
matrix[y][x] = obj
processedLevel.add(obj.number)
if(obj.upperLevel != null) levels[obj.upperLevel]?.let { buildMatrix(levels, matrix, it, processedLevel, x, y+1) }
if(obj.rightLevel != null) levels[obj.rightLevel]?.let { buildMatrix(levels, matrix, it, processedLevel, x+1, y) }
if(obj.lowerLevel != null) levels[obj.lowerLevel]?.let { buildMatrix(levels, matrix, it, processedLevel, x, y-1) }
if(obj.leftLevel != null) levels[obj.leftLevel]?.let { buildMatrix(levels, matrix, it, processedLevel, x-1, y) }
return matrix
}
But in this case, there are many empty values. And the more elements there are in json, the more empty spaces there will be.
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 5 0 0 0 0 0 0 0
0 0 0 0 0 0 4 2 3 0 0 0 0 0
0 0 0 0 0 0 0 1 6 0 0 0 0 0
0 0 0 0 0 0 0 0 7 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
If someone needs it, then I display the matrix like this. println(matrix.reversed().joinToString("\n") { row -> row.map { it?.number ?: 0 }.joinToString(" ") })
To remove these blank lines, I wrote a function like this.
private fun removeEmptyLines(matrix: MutableList<MutableList<Level?>>): MutableList<MutableList<Level?>>{
matrix.removeIf { row ->
row.all { it == null }
}
val indexForRemove = mutableSetOf<Int>()
matrix.first().forEachIndexed { index, _ ->
if(matrix.all { it[index] == null }) indexForRemove.add(index)
}
indexForRemove.sortedDescending().forEach { index ->
matrix.forEach { it.removeAt(index) }
}
return matrix
}
And as a result, the result was obtained, which I described above, but it seems to me that this is not an ideal option, maybe someone has ideas on how this can be optimized? Thank you in advance.

Answer 1

You could first collect the coordinates of each position in a Map. That will allow you to start at any arbitrary coordinate and have negative coordinates. Then use the Map to find the minimal sized 2D array needed and populate it.
fun buildMatrix(data: List<Level>): List<List<Level?>> {
class Point(val x: Int, val y: Int)
val remaining = data.toMutableList()
val points = mutableMapOf(1 to Point(0, 0))
while (remaining.isNotEmpty()) {
val level = remaining.firstOrNull { it.number in points } ?: error("Invalid input data")
remaining.remove(level)
val point = points[level.number]!!
level.upperLevel?.let { points[it.number] = Point(point.x, point.y + 1) }
level.lowerLevel?.let { points[it.number] = Point(point.x, point.y - 1) }
level.leftLevel?.let { points[it.number] = Point(point.x - 1, point.y) }
level.rightLevel?.let { points[it.number] = Point(point.x + 1, point.y) }
}
val xOffset = -points.values.minBy(Point::x)!!.x
val yOffset = -points.values.minBy(Point::y)!!.y
val xMax = points.values.maxBy(Point::x)!!.x + xOffset
val yMax = points.values.maxBy(Point::y)!!.y + yOffset
val matrix = Array(yMax + 1) { arrayOfNulls<Level>(xMax + 1) }
for ((number, point) in points) {
matrix[point.y + yOffset][point.x + xOffset] = data.find { it.number == number }
}
return matrix.map(Array<Level?>::toList)
}

Answer 2

First of All change your json input to cover two type of information:
upperLevel, leftLevel.
So your input will change to this :
[
{
"number": 1,
"upperLevel": 2
},
{
"number": 2,
"leftLevel": 4
},
{
"number": 3,
"leftLevel": 2
},
{
"number": 4,
"upperLevel": 5
},
{
"number": 5
},
{
"number": 6,
"upperLevel": 3
},
{
"number": 7
"upperLevel": 6
}
]
Now every input has a tuple of index based on x(row) and y(column). When an element has an upperLevel the X coordinate will increase by 1 and y coordinate is equal to upper level. For example i1=(x2+1,y2) because the 1 is below the 2.
So final indexes will be as below:
i1=(x2+1,y2)
i2=(x4,y4+1)
i3=(x2,y2+1)
i4=(x5+1,y5)
i5=(0,0)
i6=(x3+1,y3)
i7=(x6+1,y6)
Since number 5 has no information we set it as (0,0) which is stop point for recursive function.
Now replace x5=0,y5=0 in the indexes and you will have:
i1=(x2+1,y2) = (2,1)
i2=(x4,y4+1) = (1,1)
i3=(x2,y2+1) = (1,2)
i4=(x5+1,y5) = (1,0)
i5=(0,0)
i6=(x3+1,y3) = (2,2)
i7=(x6+1,y6) = (3,2)
Please feel free to ask questions in comment.