Related Articles

# Connect a graph by M edges such that the graph does not contain any cycle and Bitwise AND of connected vertices is maximum

• Difficulty Level : Expert
• Last Updated : 30 Apr, 2021

Given an array arr[] consisting of values of N vertices of an initially unconnected Graph and an integer M, the task is to connect some vertices of the graph with exactly M edges, forming only one connected component, such that no cycle can be formed and Bitwise AND of the connected vertices is maximum possible.

Examples:

Input: arr[] = {1, 2, 3, 4}, M = 2
Output: 0
Explanation:
Following arrangement of M edges between the given vertices are:
1->2->3 (1 & 2 & 3 = 0).
2->3->4 (2 & 3 & 4 = 0).
3->4->1 (3 & 4 & 1 = 0).
1->2->4 (1 & 2 & 4 = 0).
Therefore, the maximum Bitwise AND value among all the cases is 0.

Input: arr[] = {4, 5, 6}, M = 2
Output: 4
Explanation:
Only possible way to add M edges is 4 -> 5 -> 6 (4 & 5 & 6 = 4).
Therefore, the maximum Bitwise AND value possible is 4.

Approach: The idea to solve the given problem is to generate all possible combinations of connecting vertices using M edges and print the maximum Bitwise AND among all possible combinations.

The total number of ways for connecting N vertices is 2N and there should be (M + 1) vertices to make only one connected component. Follow the steps to solve the given problem:

• Initialize two variables, say AND and ans as 0 to store the maximum Bitwise AND, and Bitwise AND of nodes of any possible connected component respectively.
• Iterate over the range [1, 2N] using a variable, say i, and perform the following steps:
• If i has (M + 1) set bits, then find the Bitwise AND of the position of set bits and store it in the variable, say ans.
• If the value of AND exceeds ans, then update the value of AND as ans.
• After completing the above steps, print the value of AND as the resultant maximum Bitwise AND.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum Bitwise``// AND of connected components possible``// by connecting a graph using M edges``int` `maximumAND(``int` `arr[], ``int` `n, ``int` `m)``{``    ``// Stores total number of``    ``// ways to connect the graph``    ``int` `tot = 1 << n;` `    ``// Stores the maximum Bitwise AND``    ``int` `mx = 0;` `    ``// Iterate over the range [0, 2^n]``    ``for` `(``int` `bm = 0; bm < tot; bm++) {``        ``// Store the Bitwise AND of``        ``// the connected vertices``        ``int` `andans = 0;` `        ``// Store the count of the``        ``// connected vertices``        ``int` `count = 0;` `        ``// Check for all the bits``        ``for` `(``int` `i = 0; i < n; ++i) {``            ``// If i-th bit is set``            ``if` `((bm >> i) & 1) {``                ``// If the first vertex is added``                ``if` `(count == 0) {``                    ``// Set andans equal to arr[i]``                    ``andans = arr[i];``                ``}``                ``else` `{``                    ``// Calculate Bitwise AND``                    ``// of arr[i] with andans``                    ``andans = andans & arr[i];``                ``}` `                ``// Increase the count of``                ``// connected vertices``                ``count++;``            ``}``        ``}` `        ``// If number of connected vertices``        ``// is (m + 1), no cycle is formed``        ``if` `(count == (m + 1)) {``            ``// Find the maximum Bitwise``            ``// AND value possible``            ``mx = max(mx, andans);``        ``}``    ``}` `    ``// Return the maximum``    ``// Bitwise AND possible``    ``return` `mx;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `M = 2;` `    ``cout << maximumAND(arr, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum Bitwise``// AND of connected components possible``// by connecting a graph using M edges``static` `int` `maximumAND(``int` `arr[], ``int` `n, ``int` `m)``{``    ` `    ``// Stores total number of``    ``// ways to connect the graph``    ``int` `tot = ``1` `<< n;` `    ``// Stores the maximum Bitwise AND``    ``int` `mx = ``0``;` `    ``// Iterate over the range [0, 2^n]``    ``for``(``int` `bm = ``0``; bm < tot; bm++)``    ``{``        ` `        ``// Store the Bitwise AND of``        ``// the connected vertices``        ``int` `andans = ``0``;` `        ``// Store the count of the``        ``// connected vertices``        ``int` `count = ``0``;` `        ``// Check for all the bits``        ``for``(``int` `i = ``0``; i < n; ++i)``        ``{``            ` `            ``// If i-th bit is set``            ``if` `(((bm >> i) & ``1``) != ``0``)``            ``{``                ` `                ``// If the first vertex is added``                ``if` `(count == ``0``)``                ``{``                    ` `                    ``// Set andans equal to arr[i]``                    ``andans = arr[i];``                ``}``                ``else``                ``{``                    ` `                    ``// Calculate Bitwise AND``                    ``// of arr[i] with andans``                    ``andans = andans & arr[i];``                ``}` `                ``// Increase the count of``                ``// connected vertices``                ``count++;``            ``}``        ``}` `        ``// If number of connected vertices``        ``// is (m + 1), no cycle is formed``        ``if` `(count == (m + ``1``))``        ``{``            ` `            ``// Find the maximum Bitwise``            ``// AND value possible``            ``mx = Math.max(mx, andans);``        ``}``    ``}` `    ``// Return the maximum``    ``// Bitwise AND possible``    ``return` `mx;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `};``    ``int` `N = arr.length;``    ``int` `M = ``2``;` `    ``System.out.println(maximumAND(arr, N, M));``}``}` `// This code is contributed by souravghosh0416`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum Bitwise``# AND of connected components possible``# by connecting a graph using M edges``def` `maximumAND(arr, n, m):``  ` `    ``# Stores total number of``    ``# ways to connect the graph``    ``tot ``=` `1` `<< n` `    ``# Stores the maximum Bitwise AND``    ``mx ``=` `0` `    ``# Iterate over the range [0, 2^n]``    ``for` `bm ``in` `range``(tot):``      ` `        ``# Store the Bitwise AND of``        ``# the connected vertices``        ``andans ``=` `0` `        ``# Store the count of the``        ``# connected vertices``        ``count ``=` `0` `        ``# Check for all the bits``        ``for` `i ``in` `range``(n):``          ` `            ``# If i-th bit is set``            ``if` `((bm >> i) & ``1``):``              ` `                ``# If the first vertex is added``                ``if` `(count ``=``=` `0``):``                  ` `                    ``# Set andans equal to arr[i]``                    ``andans ``=` `arr[i]``                ``else``:``                    ``# Calculate Bitwise AND``                    ``# of arr[i] with andans``                    ``andans ``=` `andans & arr[i]` `                ``# Increase the count of``                ``# connected vertices``                ``count ``+``=` `1` `        ``# If number of connected vertices``        ``# is (m + 1), no cycle is formed``        ``if` `(count ``=``=` `(m ``+` `1``)):``          ` `            ``# Find the maximum Bitwise``            ``# AND value possible``            ``mx ``=` `max``(mx, andans)` `    ``# Return the maximum``    ``# Bitwise AND possible``    ``return` `mx` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``]``    ``N ``=` `len``(arr)``    ``M ``=` `2` `    ``print` `(maximumAND(arr, N, M))` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to find the maximum Bitwise``// AND of connected components possible``// by connecting a graph using M edges``static` `int` `maximumAND(``int``[] arr, ``int` `n, ``int` `m)``{``    ` `    ``// Stores total number of``    ``// ways to connect the graph``    ``int` `tot = 1 << n;`` ` `    ``// Stores the maximum Bitwise AND``    ``int` `mx = 0;`` ` `    ``// Iterate over the range [0, 2^n]``    ``for``(``int` `bm = 0; bm < tot; bm++)``    ``{``        ` `        ``// Store the Bitwise AND of``        ``// the connected vertices``        ``int` `andans = 0;`` ` `        ``// Store the count of the``        ``// connected vertices``        ``int` `count = 0;`` ` `        ``// Check for all the bits``        ``for``(``int` `i = 0; i < n; ++i)``        ``{``            ` `            ``// If i-th bit is set``            ``if` `(((bm >> i) & 1) != 0 )``            ``{``                ` `                ``// If the first vertex is added``                ``if` `(count == 0)``                ``{``                    ` `                    ``// Set andans equal to arr[i]``                    ``andans = arr[i];``                ``}``                ``else``                ``{``                    ` `                    ``// Calculate Bitwise AND``                    ``// of arr[i] with andans``                    ``andans = andans & arr[i];``                ``}`` ` `                ``// Increase the count of``                ``// connected vertices``                ``count++;``            ``}``        ``}`` ` `        ``// If number of connected vertices``        ``// is (m + 1), no cycle is formed``        ``if` `(count == (m + 1))``        ``{``            ` `            ``// Find the maximum Bitwise``            ``// AND value possible``            ``mx = Math.Max(mx, andans);``        ``}``    ``}`` ` `    ``// Return the maximum``    ``// Bitwise AND possible``    ``return` `mx;``}`` ` `// Driver Code``static` `public` `void` `Main ()``{``    ``int``[] arr = { 1, 2, 3, 4 };``    ``int` `N = arr.Length;``    ``int` `M = 2;``    ` `    ``Console.WriteLine(maximumAND(arr, N, M));``}``}` `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``
Output:
`0`

Time Complexity: O((2N)*N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up