Kotlin - Chapter 13: Graphs

* Bipartite Graph Validation
* Connect the Dots
* Count Islands
* Graph Deep Copy
* Longest Increasing Path
* Matrix Infection
* Merging Communities
* Prerequisites
* Shortest Path
* Shortest Transformation Sequence

Author: marttp

kotlin/Graphs/BipartiteGraphValidation.kt

@@ -0,0 +1,27 @@
+fun bipartiteGraphValidation(graph: List<List<Int>>): Boolean {
+    val colors = IntArray(graph.size)
+    // Determine if each graph component is bipartite.
+    for (i in graph.indices) {
+        if (colors[i] == 0 && !dfs(i, 1, graph, colors)) {
+            return false
+        }
+    }
+    return true
+}
+
+fun dfs(node: Int, color: Int, graph: List<List<Int>>, colors: IntArray): Boolean {
+    colors[node] = color
+    for (neighbor in graph[node]) {
+        // If the current neighbor has the same color as the current
+        // node, the graph is not bipartite.
+        if (colors[neighbor] == color) {
+            return false
+        }
+        // If the current neighbor is not colored, color it with the
+        // other color and continue the DFS.
+        if (colors[neighbor] == 0 && !dfs(neighbor, -color, graph, colors)) {
+            return false
+        }
+    }
+    return true
+}

kotlin/Graphs/ConnectTheDots.kt

@@ -0,0 +1,63 @@
+class UnionFind(size: Int) {
+    private val parent = IntArray(size) { it }
+    private val size = IntArray(size) { 1 }
+
+    fun union(x: Int, y: Int): Boolean {
+        var repX = find(x)
+        var repY = find(y)
+        if (repX != repY) {
+            if (size[repX] > size[repY]) {
+                parent[repY] = repX
+                size[repX] += size[repY]
+            } else {
+                parent[repX] = repY
+                size[repY] += size[repX]
+            }
+            // Return true if both groups were merged.
+            return true
+        }
+        // Return false if the points belong to the same group.
+        return false
+    }
+
+    fun find(x: Int): Int {
+        if (x == parent[x]) {
+            return x
+        }
+        parent[x] = find(parent[x])
+        return parent[x]
+    }
+}
+
+fun connectTheDots(points: List<List<Int>>): Int {
+    val n = points.size
+    // Create and populate a list of all possible edges.
+    val edges = mutableListOf<Triple<Int, Int, Int>>()
+    for (i in 0 until n) {
+        for (j in i + 1 until n) {
+            // Manhattan distance.
+            val cost =
+                    (Math.abs(points[i][0] - points[j][0]) + Math.abs(points[i][1] - points[j][1]))
+            edges.add(Triple(cost, i, j))
+        }
+    }
+    // Sort the edges by their cost in ascending order.
+    edges.sortBy { it.first }
+    val uf = UnionFind(n)
+    var totalCost = 0
+    var edgesAdded = 0
+    // Use Kruskal's algorithm to create the MST and identify its minimum cost.
+    for ((cost, p1, p2) in edges) {
+        // If the points are not already connected (i.e. their representatives are
+        // not the same), connect them, and add the cost to the total cost.
+        if (uf.union(p1, p2)) {
+            totalCost += cost
+            edgesAdded++
+            // If n - 1 edges have been added to the MST, the MST is complete.
+            if (edgesAdded == n - 1) {
+                return totalCost
+            }
+        }
+    }
+    return totalCost
+}

kotlin/Graphs/CountIslands.kt

@@ -0,0 +1,37 @@
+fun countIslands(matrix: MutableList<MutableList<Int>>): Int {
+    if (matrix.isEmpty()) {
+        return 0
+    }
+    var count = 0
+    for (r in matrix.indices) {
+        for (c in matrix[0].indices) {
+            // If a land cell is found, perform DFS to explore the full
+            // island, and include this island in our count.
+            if (matrix[r][c] == 1) {
+                dfs(r, c, matrix)
+                count++
+            }
+        }
+    }
+    return count
+}
+
+fun dfs(r: Int, c: Int, matrix: MutableList<MutableList<Int>>) {
+    // Mark the current land cell as visited.
+    matrix[r][c] = -1
+    // Define direction vectors for up, down, left, and right.
+    val dirs = listOf(Pair(-1, 0), Pair(1, 0), Pair(0, -1), Pair(0, 1))
+    // Recursively call DFS on each neighboring land cell to continue
+    // exploring this island.
+    for (d in dirs) {
+        val nextR = r + d.first
+        val nextC = c + d.second
+        if (isWithinBounds(nextR, nextC, matrix) && matrix[nextR][nextC] == 1) {
+            dfs(nextR, nextC, matrix)
+        }
+    }
+}
+
+fun isWithinBounds(r: Int, c: Int, matrix: MutableList<MutableList<Int>>): Boolean {
+    return r in matrix.indices && c in matrix[0].indices
+}

kotlin/Graphs/GraphDeepCopy.kt

@@ -0,0 +1,36 @@
+import ds.GraphNode
+
+/*
+    Definition of GraphNode:
+    data class GraphNode(
+        val value: Int,
+        val neighbors: MutableList<GraphNode> = mutableListOf()
+    )
+*/
+
+fun graphDeepCopy(node: GraphNode?): GraphNode? {
+    if (node == null) {
+        return null
+    }
+    return dfs(node, mutableMapOf())
+}
+
+fun dfs(node: GraphNode, cloneMap: MutableMap<GraphNode, GraphNode>): GraphNode {
+    // If this node was already cloned, then return this previously
+    // cloned node.
+    if (node in cloneMap) {
+        return cloneMap[node]!!
+    }
+    // Clone the current node.
+    val clonedNode = GraphNode(node.value)
+    // Store the current clone to ensure it doesn't need to be created
+    // again in future DFS calls.
+    cloneMap[node] = clonedNode
+    // Iterate through the neighbors of the current node to connect
+    // their clones to the current cloned node.
+    for (neighbor in node.neighbors) {
+        val clonedNeighbor = dfs(neighbor, cloneMap)
+        clonedNode.neighbors.add(clonedNeighbor)
+    }
+    return clonedNode
+}

kotlin/Graphs/LongestIncreasingPath.kt

@@ -0,0 +1,40 @@
+fun longestIncreasingPath(matrix: List<List<Int>>): Int {
+    if (matrix.isEmpty()) {
+        return 0
+    }
+    var res = 0
+    val m = matrix.size
+    val n = matrix[0].size
+    val memo = Array(m) { IntArray(n) }
+    // Find the longest increasing path starting at each cell. The
+    // maximum of these is equal to the overall longest increasing
+    // path.
+    for (r in matrix.indices) {
+        for (c in matrix[0].indices) {
+            res = maxOf(res, dfs(r, c, matrix, memo))
+        }
+    }
+    return res
+}
+
+fun dfs(r: Int, c: Int, matrix: List<List<Int>>, memo: Array<IntArray>): Int {
+    if (memo[r][c] != 0) {
+        return memo[r][c]
+    }
+    var maxPath = 1
+    val dirs = listOf(-1 to 0, 1 to 0, 0 to -1, 0 to 1)
+    // The longest path starting at the current cell is equal to the
+    // longest path of its larger neighboring cells, plus 1.
+    for (d in dirs) {
+        val (nextR, nextC) = r + d.first to c + d.second
+        if (isWithinBounds(nextR, nextC, matrix) && matrix[nextR][nextC] > matrix[r][c]) {
+            maxPath = maxOf(maxPath, 1 + dfs(nextR, nextC, matrix, memo))
+        }
+    }
+    memo[r][c] = maxPath
+    return maxPath
+}
+
+fun isWithinBounds(r: Int, c: Int, matrix: List<List<Int>>): Boolean {
+    return r in matrix.indices && c in matrix[0].indices
+}

kotlin/Graphs/MatrixInfection.kt

@@ -0,0 +1,49 @@
+fun matrixInfection(matrix: MutableList<MutableList<Int>>): Int {
+    val dirs = listOf(-1 to 0, 1 to 0, 0 to -1, 0 to 1)
+    val queue = ArrayDeque<Pair<Int, Int>>()
+    var ones = 0
+    var seconds = 0
+    // Count the total number of uninfected cells and add each infected
+    // cell to the queue to represent level 0 of the level-order
+    // traversal.
+    for (r in matrix.indices) {
+        for (c in matrix[0].indices) {
+            if (matrix[r][c] == 1) {
+                ones++
+            } else if (matrix[r][c] == 2) {
+                queue.add(r to c)
+            }
+        }
+    }
+    // Use level-order traversal to determine how long it takes to
+    // infect the uninfected cells.
+    while (queue.isNotEmpty() && ones > 0) {
+        // 1 second passes with each level of the matrix that's explored.
+        seconds++
+        for (i in 0 until queue.size) {
+            val (r, c) = queue.removeFirst()
+            // Infect any neighboring 1s and add them to the queue to be
+            // processed in the next level.
+            for ((dr, dc) in dirs) {
+                val nextR = r + dr
+                val nextC = c + dc
+                if (isWithinBounds(nextR, nextC, matrix) && matrix[nextR][nextC] == 1) {
+                    matrix[nextR][nextC] = 2
+                    ones--
+                    queue.add(nextR to nextC)
+                }
+            }
+        }
+    }
+    // If there are still uninfected cells left, return -1. Otherwise,
+    // return the time passed.
+    return if (ones == 0) {
+        seconds
+    } else {
+        -1
+    }
+}
+
+fun isWithinBounds(r: Int, c: Int, matrix: List<List<Int>>): Boolean {
+    return r in matrix.indices && c in matrix[0].indices
+}

kotlin/Graphs/MergingCommunities.kt

@@ -0,0 +1,49 @@
+class UnionFind(size: Int) {
+
+    private val parent = IntArray(size) { it }
+    private val size = IntArray(size) { 1 }
+
+    // With comment
+    fun union(x: Int, y: Int) {
+        val repX = find(x)
+        val repY = find(y)
+        if (repX != repY) {
+            // If 'repX' represents a larger community, connect
+            // 'repY 's community to it.
+            if (size[repX] > size[repY]) {
+                parent[repY] = repX
+                size[repX] += size[repY]
+            } else {
+                // Otherwise, connect 'repX's community to 'repY'.
+                parent[repX] = repY
+                size[repY] += size[repX]
+            }
+        }
+    }
+
+    fun find(x: Int): Int {
+        if (x == parent[x]) {
+            return x
+        }
+        // Path compression.
+        parent[x] = find(parent[x])
+        return parent[x]
+    }
+
+    fun getSize(x: Int): Int {
+        return size[find(x)]
+    }
+}
+
+class MergingCommunities(n: Int) {
+
+    private val uf = UnionFind(n)
+
+    fun connect(x: Int, y: Int) {
+        uf.union(x, y)
+    }
+
+    fun getCommunitySize(x: Int): Int {
+        return uf.getSize(x)
+    }
+}

kotlin/Graphs/Prerequisites.kt

@@ -0,0 +1,33 @@
+fun prerequisites(n: Int, prerequisites: List<List<Int>>): Boolean {
+    val graph = mutableMapOf<Int, MutableList<Int>>()
+    val inDegrees = IntArray(n)
+    // Represent the graph as an adjacency list and record the in-
+    // degree of each course.
+    for ((prerequisite, course) in prerequisites) {
+        graph.getOrPut(prerequisite) { mutableListOf() }.add(course)
+        inDegrees[course]++
+    }
+    val queue = ArrayDeque<Int>()
+    // Add all courses with an in-degree of 0 to the queue.
+    for (i in inDegrees.indices) {
+        if (inDegrees[i] == 0) {
+            queue.add(i)
+        }
+    }
+    var enrolledCourses = 0
+    // Perform topological sort.
+    while (queue.isNotEmpty()) {
+        val node = queue.removeFirst()
+        enrolledCourses++
+        for (neighbor in graph[node] ?: mutableListOf()) {
+            inDegrees[neighbor]--
+            // If the in-degree of a neighboring course becomes 0, add
+            // it to the queue.
+            if (inDegrees[neighbor] == 0) {
+                queue.add(neighbor)
+            }
+        }
+    }
+    // Return true if we've successfully enrolled in all courses.
+    return enrolledCourses == n
+}

kotlin/Graphs/ShortestPath.kt

@@ -0,0 +1,36 @@
+import java.util.PriorityQueue
+
+fun shortestPath(n: Int, edges: List<List<Int>>, start: Int): List<Int> {
+    val graph = hashMapOf<Int, MutableList<Pair<Int, Int>>>()
+    val distances = MutableList(n) { Int.MAX_VALUE }
+    distances[start] = 0
+    // Represent the graph as an adjacency list.
+    for ((u, v, w) in edges) {
+        graph.computeIfAbsent(u) { mutableListOf() }.add(v to w)
+        graph.computeIfAbsent(v) { mutableListOf() }.add(u to w)
+    }
+    val minHeap = PriorityQueue<Pair<Int, Int>>(compareBy { it.first })
+    minHeap.add(0 to start) // (distance, node)
+    // Use Dijkstra's algorithm to find the shortest path between the start node
+    // and all other nodes.
+    while (minHeap.isNotEmpty()) {
+        val (currDist, currNode) = minHeap.poll()
+        // If the current distance to this node is greater than the recorded
+        // distance, we've already found the shortest distance to this node.
+        if (currDist > distances[currNode]) {
+            continue
+        }
+        // Update the distances of the neighboring nodes.
+        for ((neighbor, weight) in graph[currNode] ?: emptyList()) {
+            val neighborDist = currDist + weight
+            // Only update the distance if we find a shorter path to this
+            // neighbor.
+            if (neighborDist < distances[neighbor]) {
+                distances[neighbor] = neighborDist
+                minHeap.add(neighborDist to neighbor)
+            }
+        }
+    }
+    // Convert all infinity values to -1, representing unreachable nodes.
+    return distances.map { if (it == Int.MAX_VALUE) -1 else it }
+}