Regions Cut By Slashes

 

Disjoint Set Union (Graph)

Intuition

Let's shift our perspective and consider slashes as connectors rather than dividers. Imagine each cell as a graph with four vertices at its corners, with slashes acting as edges between these vertices. The following diagram illustrates this concept:

cell as a graph

In this paradigm, a slash can be represented as follows:

  • A / slash connects the top-right point of a cell to the bottom-left point.
  • A \ slash connects the top-left point to the bottom-right point.
  • An empty space doesn't add any new connections.

The edges of the grid form the boundaries of the graph, creating an initial region. As we connect vertices (slashes), cycles may form, indicating the creation of new regions within the graph. By tracking the total number of cycles formed while iterating over all slashes, we determine the final count of regions.

To manage connected components, we use a DSU (Disjoint Set Union) data structure. We start by connecting the boundary points as the first region. As we process each cell, we treat each slash as an edge and union the corresponding vertices. If a union operation reveals that the vertices already share the same parent, it indicates a cycle, prompting us to increment our counter.

Algorithm

Main method regionsBySlashes:

  • Initialize variables:
    • gridSize to the length of grid.
    • pointsPerSide to gridSize + 1.
    • totalPoints to pointsPerSide * pointsPerSide.
  • Create an array parentArray to represent the disjoint set, initialized with -1.
  • Loop over the each point:
    • If the point lies on the border, set its parent to 0.
  • Set parent[0] (top-left corner) to -1 to make it the root.
  • Initialize regionCount to 1, accounting for the border region.
  • Iterate through each cell (i, j) in the grid:
    • If it's a forward slash (/):
      • Calculate the topRight and bottomLeft indices.
      • Call union on these points and add the result to regionCount.
    • If it's a backslash (\\):
      • Calculate the topLeft and bottomRight indices.
      • Call union on these points and add the result to regionCount.
  • Return the final regionCount.

Helper method find:

  • Define a method find with parameters: parentArray and the node.
  • If parentArray[node] is equal to -1:
    • node does not have any parent. Return node.
  • Set parentArray[node] to the parent of parentArray[node] using the find method. Return parentArray[node].

Helper method union:

  • Define a method union with parameters: parentArray and nodes node1 and node2.
  • Set parent1 to parent2 to the parents of node1 and node2 respectively.
  • If parent1 is equal to parent2, return 1.
  • Set parentArray[parent2] to parent1.
  • Return 0.

Comments

Post a Comment

Popular posts from this blog

LeetCode 3Sum

Question Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0. Notice that the solution set must not contain duplicate triplets. Brute force We can run 3 loops to check each possible triplets, we also need to eliminate the duplicates from both sides. this method will work but will work but will give time limit exceed after time constraints. To do this in given time limit we need to sort the array first and Create a loop that fixes the left most integer. This reduces the problem to 2sum for remaining array. For each loop iteration where duplicates are skipped, we need to do a left/right iteration using while loop. my code:
Read more

30. Substring with Concatenation of All Words

Problem Statement You are given a string s and an array of strings words. All the strings of words are of the same length. A concatenated substring in s is a substring that contains all the strings of any permutation of words concatenated. For example, if words = ["ab","cd","ef"], then "abcdef", "abefcd", "cdabef", "cdefab", "efabcd", and "efcdab" are all concatenated strings. "acdbef" is not a concatenated substring because it is not the concatenation of any permutation of words. Return the starting indices of all the concatenated substrings in s. You can return the answer in any order. Example 1: Input: s = "barfoothefoobarman", words = ["foo","bar"] Output: [0,9] Explanation: Since words.length == 2 and words[i].length == 3, the concatenated substring has to be of length 6. The substring starting at 0 is "barfoo". It is the concaten...
Read more

Lowest common ancestor in a binary Tree

Approach Define a recursive function rec that takes three parameters: root (the current node), p (first node to find the lowest common ancestor for), and q (second node to find the lowest common ancestor for). Check if the current node root is null or if it is either p or q . If any of these conditions is true, return the current node root as the lowest common ancestor. Recursively call the rec function for the left subtree of the current node and assign the result to a variable l . Recursively call the rec function for the right subtree of the current node and assign the result to a variable r . Check if both l and r are not null. If so, it means that p and q are found on different subtrees of the current node, and the current node root is their lowest common ancestor. Return the current node root . If l is null, it means that both p and q are on the right subtree (or not present in the tree). Return r . If none of the above conditions are met, it means ...
Read more