# Check if given Circles form a single Component

• Difficulty Level : Hard
• Last Updated : 28 Oct, 2022

Given a 2-D array A[][] of size NÃ—3, where each element of the array consists of {x, y, r}, where x and y are coordinates of that circle and r is the radius of that circle, the task is to check all the circles form a single component where a component is the set of connected circles.

Note: Two circles are connected if they touch or intersect each other.

Examples:

Input: A[][] = {{0, 0, 2}, {0, 3, 3}, {0, 6, 1}, {1, 0, 1}}
Output: true
Explanation: All circles are connected to every other circle.

Input: A[][] = {{0, 0, 1}, {0, 3, 1}, {0, 4, 1}, {1, 0, 1}}
Output: false
Explanation: Circles at index 0 and 3 form a single component
while circle 1 and 2 form separate component.
Since there are multiple components, the output is false.

Approach: The solution to the problem can be derived using the following idea

The idea is to construct a graph from the given input and check if corresponding vertices touch or intersect each other and in the end find that the graph forms a single connected component or not [i.e. if all the vertices can be visited starting from any vertex].

Following are the steps to implement the above approach:

• For every circle in A, find the distance between their centers.
• If the distance <= sum of radius
• connect both the vertices representing these circles
• Perform a DFS from a single node on the graph.
• Now check in the visited array
• If there is any unvisited vertex, return false.
• Return true if there is no unvisited vertex.

Below is the code implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `// Function to create a graph from the` `// array of the circles` `vector > constructGraph(``int` `Arr[][3], ``int` `n)` `{` `  ``vector > graph(n, vector<``int``>());` `  ``for` `(``int` `u = 0; u < n; u++) {` `    ``for` `(``int` `v = u + 1; v < n; v++) {` `      ``int` `x1 = Arr[u][0];` `      ``int` `y1 = Arr[u][1];` `      ``int` `r1 = Arr[u][2];` `      ``int` `x2 = Arr[v][0];` `      ``int` `y2 = Arr[v][1];` `      ``int` `r2 = Arr[v][2];` `      ``double` `dist = ``sqrt``((x1 - x2) * (x1 - x2)` `                         ``+ (y1 - y2) * (y1 - y2));` `      ``if` `(r1 + r2 >= dist) {` `        ``graph[u].push_back(v);` `        ``graph[v].push_back(u);` `      ``}` `    ``}` `  ``}` `  ``return` `graph;` `}`   `// Function to perform DFS on the graph`   `void` `dfsVisit(``int` `v, vector<``bool``>& visited,` `              ``vector > graph)` `{` `  ``visited[v] = ``true``;` `  ``for` `(``auto` `nbr : graph[v]) {` `    ``if` `(!visited[nbr]) {` `      ``dfsVisit(nbr, visited, graph);` `    ``}` `  ``}` `}`   `// Function to check whether the` `// circle form a single component or not` `bool` `isSingleComponent(``int` `arr[][3], ``int` `n)` `{` `  ``vector > graph = constructGraph(arr, 4);` `  ``vector<``bool``> visited(n, 0);` `  ``dfsVisit(0, visited, graph);` `  ``for` `(``int` `i = 0; i < n; i++) {` `    ``if` `(!visited[i])` `      ``return` `false``;` `  ``}` `  ``return` `true``;` `}`   `int` `main()` `{` `  ``int` `A[][3] = {` `    ``{ 0, 0, 2 }, { 0, 3, 3 }, { 0, 6, 1 }, { 1, 0, 1 }` `  ``};`   `  ``// Function Call` `  ``cout << (isSingleComponent(A, 4)) << endl;` `  ``;` `}`   `// This code is contributed by garg28harsh.`

## Java

 `// Java program to implement the approach`   `import` `java.util.*;`   `public` `class` `GFG {`   `    ``// Function to create a graph from the` `    ``// array of the circles` `    ``static` `ArrayList >` `    ``constructGraph(``int``[][] Arr)` `    ``{` `        ``int` `n = Arr.length;` `        ``ArrayList > graph` `            ``= ``new` `ArrayList<>();` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``graph.add(``new` `ArrayList<>());` `        ``}` `        ``for` `(``int` `u = ``0``; u < n; u++) {` `            ``for` `(``int` `v = u + ``1``; v < n; v++) {` `                ``int` `x1 = Arr[u][``0``];` `                ``int` `y1 = Arr[u][``1``];` `                ``int` `r1 = Arr[u][``2``];` `                ``int` `x2 = Arr[v][``0``];` `                ``int` `y2 = Arr[v][``1``];` `                ``int` `r2 = Arr[v][``2``];` `                ``double` `dist` `                    ``= Math.sqrt((x1 - x2) * (x1 - x2)` `                                ``+ (y1 - y2) * (y1 - y2));` `                ``if` `(r1 + r2 >= dist) {` `                    ``graph.get(u).add(v);` `                    ``graph.get(v).add(u);` `                ``}` `            ``}` `        ``}` `        ``return` `graph;` `    ``}`   `    ``// Function to perform DFS on the graph` `    ``static` `void` `    ``dfsVisit(``int` `v, ``boolean``[] visited,` `             ``ArrayList > graph)` `    ``{` `        ``visited[v] = ``true``;` `        ``for` `(Integer nbr : graph.get(v)) {` `            ``if` `(!visited[nbr]) {` `                ``dfsVisit(nbr, visited, graph);` `            ``}` `        ``}` `    ``}`   `    ``// Function to check whether the` `    ``// circle form a single component or not` `    ``static` `boolean` `isSingleComponent(``int``[][] arr)` `    ``{` `        ``int` `n = arr.length;` `        ``ArrayList > graph` `            ``= constructGraph(arr);` `        ``boolean``[] visited = ``new` `boolean``[n];` `        ``dfsVisit(``0``, visited, graph);` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``if` `(!visited[i])` `                ``return` `false``;` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `A[][] = { { ``0``, ``0``, ``2` `},` `                      ``{ ``0``, ``3``, ``3` `},` `                      ``{ ``0``, ``6``, ``1` `},` `                      ``{ ``1``, ``0``, ``1` `} };`   `        ``// Function Call` `        ``System.out.println(isSingleComponent(A));` `    ``}` `}`

## Python3

 `import` `math` `class` `GFG :` `  `  `    ``# Function to create a graph from the` `    ``# array of the circles` `    ``@staticmethod` `    ``def`  `constructGraph( Arr) :` `        ``n ``=` `len``(Arr)` `        ``graph ``=`  `[]` `        ``i ``=` `0` `        ``while` `(i < n) :` `            ``graph.append( [])` `            ``i ``+``=` `1` `        ``u ``=` `0` `        ``while` `(u < n) :` `            ``v ``=` `u ``+` `1` `            ``while` `(v < n) :` `                ``x1 ``=` `Arr[u][``0``]` `                ``y1 ``=` `Arr[u][``1``]` `                ``r1 ``=` `Arr[u][``2``]` `                ``x2 ``=` `Arr[v][``0``]` `                ``y2 ``=` `Arr[v][``1``]` `                ``r2 ``=` `Arr[v][``2``]` `                ``dist ``=` `math.sqrt((x1 ``-` `x2) ``*` `(x1 ``-` `x2) ``+` `(y1 ``-` `y2) ``*` `(y1 ``-` `y2))` `                ``if` `(r1 ``+` `r2 >``=` `dist) :` `                    ``graph[u].append(v)` `                    ``graph[v].append(u)` `                ``v ``+``=` `1` `            ``u ``+``=` `1` `        ``return` `graph` `      `  `    ``# Function to perform DFS on the graph` `    ``@staticmethod` `    ``def` `dfsVisit( v,  visited,  graph) :` `        ``visited[v] ``=` `True` `        ``for` `nbr ``in` `graph[v] :` `            ``if` `(``not` `visited[nbr]) :` `                ``GFG.dfsVisit(nbr, visited, graph)` `                `  `    ``# Function to check whether the` `    ``# circle form a single component or not` `    ``@staticmethod` `    ``def`  `isSingleComponent( arr) :` `        ``n ``=` `len``(arr)` `        ``graph ``=` `GFG.constructGraph(arr)` `        ``visited ``=` `[``False``] ``*` `(n)` `        ``GFG.dfsVisit(``0``, visited, graph)` `        ``i ``=` `0` `        ``while` `(i < n) :` `            ``if` `(``not` `visited[i]) :` `                ``return` `False` `            ``i ``+``=` `1` `        ``return` `True` `      `  `    ``# Driver Code` `    ``@staticmethod` `    ``def` `main( args) :` `        ``A ``=` `[[``0``, ``0``, ``2``], [``0``, ``3``, ``3``], [``0``, ``6``, ``1``], [``1``, ``0``, ``1``]]` `        `  `        ``# Function Call` `        ``print``(GFG.isSingleComponent(A))` `    `  `if` `__name__``=``=``"__main__"``:` `    ``GFG.main([])` `    `  `    ``# This code is contributed by aaityaburujwale.`

## Javascript

 `// Javascript program to implement the approach`   `// Function to create a graph from the` `// array of the circles` `function` `constructGraph(Arr, n) {` `  ``let graph = ``new` `Array(n);` `  ``for` `(let i = 0; i < n; i++) graph[i] = [];` `  ``for` `(let u = 0; u < n; u++) {` `    ``for` `(let v = u + 1; v < n; v++) {` `      ``let x1 = Arr[u][0];` `      ``let y1 = Arr[u][1];` `      ``let r1 = Arr[u][2];` `      ``let x2 = Arr[v][0];` `      ``let y2 = Arr[v][1];` `      ``let r2 = Arr[v][2];` `      ``let dist = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));` `      ``if` `(r1 + r2 >= dist) {` `        ``graph[u].push(v);` `        ``graph[v].push(u);` `      ``}` `    ``}` `  ``}`   `  ``return` `graph;` `}`   `// Function to perform DFS on the graph`   `function` `dfsVisit(v, visited, graph) {` `  ``visited[v] = ``true``;`   `  ``for` `(let nbr of graph[v]) {` `    ``if` `(!visited[nbr]) {` `      ``dfsVisit(nbr, visited, graph);` `    ``}` `  ``}` `}`   `// Function to check whether the` `// circle form a single component or not` `function` `isSingleComponent(arr, n) {` `  ``let graph = constructGraph(arr, 4);` `  ``let visited = ``new` `Array(n);` `  ``for` `(let i = 0; i < n; i++) visited[i] = 0;`   `  ``dfsVisit(0, visited, graph);` `  ``for` `(let i = 0; i < n; i++) {` `    ``if` `(!visited[i]) ``return` `false``;` `  ``}` `  ``return` `true``;` `}`   `let A = [` `  ``[0, 0, 2],` `  ``[0, 3, 3],` `  ``[0, 6, 1],` `  ``[1, 0, 1],` `];`   `// Function Call` `console.log(isSingleComponent(A, 4));`   `// This code is contributed by ishankhandelwals.`

Output

`true`

Time Complexity: O(N2)
Auxiliary Space:  O(N2)

My Personal Notes arrow_drop_up
Related Articles