给定具有V个顶点和E个边缘的二进制值无向图，任务是找到图的所有连接组件的十六进制等效项。可以将二进制值图视为仅具有二进制数(0或1)作为顶点值。
例子：
Input: E = 4, V = 7
Output:
Chain = 0 1 Hexadecimal equivalent = 1
Chain = 0 0 0 Hexadecimal equivalent = 0
Chain = 1 1 Hexadecimal equivalent = 3
Explanation:
In case of the first connected component, the binary chain is [0, 1]
Hence, the binary string = “01” and binary number = 01
So, the hexadecimal equivalent = 1
Input: E = 6, V = 10
Output:
Chain = 1 Hexadecimal equivalent = 1
Chain = 0 0 1 0 Hexadecimal equivalent = 2
Chain = 1 1 0 Hexadecimal equivalent = 6
Chain = 1 0 Hexadecimal equivalent = 2
方法：想法是使用深度优先搜索遍历来跟踪无向图中的连接组件，如本文所述。对于每个连接的组件，将显示二进制字符串，并按照本文中的说明从二进制值计算出等效的十六进制值并将其打印出来。
下面是上述方法的实现：
C++
// C++ implementation to find
// hexadecimal equivalents of
// all connected components
#include
using namespace std;
// Function to traverse the undirected
// graph using the Depth first traversal
void depthFirst(int v,
vector graph[],
vector& visited,
vector& storeChain)
{
// Marking the visited
// vertex as true
visited[v] = true;
// Store the connected chain
storeChain.push_back(v);
for (auto i : graph[v]) {
if (visited[i] == false) {
// Recursive call to
// the DFS algorithm
depthFirst(i, graph,
visited,
storeChain);
}
}
}
// Function to create map between binary
// number and its equivalent hexadecimal
void createMap(unordered_map* um)
{
(*um)["0000"] = '0';
(*um)["0001"] = '1';
(*um)["0010"] = '2';
(*um)["0011"] = '3';
(*um)["0100"] = '4';
(*um)["0101"] = '5';
(*um)["0110"] = '6';
(*um)["0111"] = '7';
(*um)["1000"] = '8';
(*um)["1001"] = '9';
(*um)["1010"] = 'A';
(*um)["1011"] = 'B';
(*um)["1100"] = 'C';
(*um)["1101"] = 'D';
(*um)["1110"] = 'E';
(*um)["1111"] = 'F';
}
// Function to return hexadecimal
// equivalent of each connected
// component
string hexaDecimal(string bin)
{
int l = bin.size();
int t = bin.find_first_of('.');
// Length of string before '.'
int len_left = t != -1 ? t : l;
// Add min 0's in the beginning
// to make left substring length
// divisible by 4
for (int i = 1;
i <= (4 - len_left % 4) % 4;
i++)
bin = '0' + bin;
// If decimal point exists
if (t != -1) {
// Length of string after '.'
int len_right = l - len_left - 1;
// Add min 0's in the end to
// make right substring length
// divisible by 4
for (int i = 1;
i <= (4 - len_right % 4) % 4;
i++)
bin = bin + '0';
}
// Create map between binary
// and its equivalent hex code
unordered_map
bin_hex_map;
createMap(&bin_hex_map);
int i = 0;
string hex = "";
while (1) {
// Extract from left,
// substring of size 4 and add
// its hex code
hex += bin_hex_map[bin.substr(i, 4)];
i += 4;
if (i == bin.size())
break;
// If '.' is encountered add it
// to result
if (bin.at(i) == '.') {
hex += '.';
i++;
}
}
// Required hexadecimal number
return hex;
}
// Function to find the hexadecimal
// equivalents of all connected
// components
void hexValue(
vector graph[],
int vertices,
vector values)
{
// Initializing boolean array
// to mark visited vertices
vector visited(10001,
false);
// Following loop invokes
// DFS algorithm
for (int i = 1; i <= vertices;
i++) {
if (visited[i] == false) {
// Variable to hold
// temporary length
int sizeChain;
// Container to store
// each chain
vector storeChain;
// DFS algorithm
depthFirst(i, graph,
visited,
storeChain);
// Variable to hold each
// chain size
sizeChain = storeChain.size();
// Container to store
// values of vertices of
// individual chains
int chainValues[sizeChain + 1];
// Storing the values of
// each chain
for (int i = 0;
i < sizeChain; i++) {
int temp = values[storeChain[i] - 1];
chainValues[i] = temp;
}
// Printing binary chain
cout << "Chain = ";
for (int i = 0;
i < sizeChain; i++) {
cout << chainValues[i]
<< " ";
}
cout << "\t";
// Converting the array
// with vertex
// values to a binary string
// using string stream
stringstream ss;
ss << chainValues[0];
string s = ss.str();
for (int i = 1;
i < sizeChain; i++) {
stringstream ss1;
ss1 << chainValues[i];
string s1 = ss1.str();
s.append(s1);
}
// Printing the hexadecimal
// values
cout << "Hexadecimal "
<< "equivalent = ";
cout << hexaDecimal(s)
<< endl;
}
}
}
// Driver Program
int main()
{
// Initializing graph in the
// form of adjacency list
vector graph[1001];
// Defining the number of
// edges and vertices
int E, V;
E = 4;
V = 7;
// Assigning the values
// for each vertex of the
// undirected graph
vector values;
values.push_back(0);
values.push_back(1);
values.push_back(1);
values.push_back(1);
values.push_back(0);
values.push_back(1);
values.push_back(1);
// Constructing the
// undirected graph
graph[1].push_back(2);
graph[2].push_back(1);
graph[3].push_back(4);
graph[4].push_back(3);
graph[4].push_back(5);
graph[5].push_back(4);
graph[6].push_back(5);
graph[5].push_back(6);
graph[6].push_back(7);
graph[7].push_back(6);
hexValue(graph, V, values);
return 0;
} Java
// Java implementation to find
// hexadecimal equivalents of
// all connected components
import java.io.*;
import java.util.*;
class GFG{
// Function to traverse the undirected
// graph using the Depth first traversal
static void depthFirst(int v,
List> graph,
boolean[] visited,
List storeChain)
{
// Marking the visited
// vertex as true
visited[v] = true;
// Store the connected chain
storeChain.add(v);
for(int i : graph.get(v))
{
if (visited[i] == false)
{
// Recursive call to
// the DFS algorithm
depthFirst(i, graph, visited,
storeChain);
}
}
}
// Function to create map between binary
// number and its equivalent hexadecimal
static void createMap(Map um)
{
um.put("0000", '0');
um.put("0001", '1');
um.put("0010", '2');
um.put("0011", '3');
um.put("0100", '4');
um.put("0101", '5');
um.put("0110", '6');
um.put("0111", '7');
um.put("1000", '8');
um.put("1001", '9');
um.put("1010", 'A');
um.put("1011", 'B');
um.put("1100", 'C');
um.put("1101", 'D');
um.put("1110", 'E');
um.put("1111", 'F');
}
// Function to return hexadecimal
// equivalent of each connected
// component
static String hexaDecimal(String bin)
{
int l = bin.length();
int t = bin.indexOf('.');
// Length of string before '.'
int len_left = t != -1 ? t : l;
// Add min 0's in the beginning to make
// left substring length divisible by 4
for(int i = 1;
i <= (4 - len_left % 4) % 4;
i++)
bin = '0' + bin;
// If decimal point exists
if (t != -1)
{
// Length of string after '.'
int len_right = l - len_left - 1;
// Add min 0's in the end to make right
// substring length divisible by 4
for(int i = 1;
i <= (4 - len_right % 4) % 4;
i++)
bin = bin + '0';
}
// Create map between binary and its
// equivalent hex code
Map bin_hex_map = new HashMap();
createMap(bin_hex_map);
int i = 0;
String hex = "";
while (true)
{
// One by one extract from left, substring
// of size 4 and add its hex code
hex += bin_hex_map.get(bin.substring(i, i + 4));
i += 4;
if (i == bin.length())
break;
// If '.' is encountered add it
// to result
if (bin.charAt(i) == '.')
{
hex += '.';
i++;
}
}
// Required hexadecimal number
return hex;
}
// Function to find the hexadecimal
// equivalents of all connected
// components
static void hexValue(List> graph,
int vertices,
List values)
{
// Initializing boolean array
// to mark visited vertices
boolean[] visited = new boolean[1001];
// Following loop invokes DFS algorithm
for(int i = 1; i <= vertices; i++)
{
if (visited[i] == false)
{
// Variable to hold
// temporary length
int sizeChain;
// Container to store each chain
List storeChain = new ArrayList();
// DFS algorithm
depthFirst(i, graph, visited, storeChain);
// Variable to hold each chain size
sizeChain = storeChain.size();
// Container to store values
// of vertices of individual chains
int[] chainValues = new int[sizeChain + 1];
// Storing the values of each chain
for(int j = 0; j < sizeChain; j++)
{
int temp = values.get(
storeChain.get(j) - 1);
chainValues[j] = temp;
}
// Printing binary chain
System.out.print("Chain = ");
for(int j = 0; j < sizeChain; j++)
{
System.out.print(chainValues[j] + " ");
}
System.out.println();
System.out.print("\t");
// Converting the array with
// vertex values to a binary
// string
String s = "";
for(int j = 0; j < sizeChain; j++)
{
String s1 = String.valueOf(
chainValues[j]);
s += s1;
}
// Printing the hexadecimal
// values
System.out.println("Hexadecimal " +
"equivalent = " +
hexaDecimal(s));
}
}
}
// Driver code
public static void main(String[] args)
{
// Initializing graph in the
// form of adjacency list
@SuppressWarnings("unchecked")
List> graph = new ArrayList();
for(int i = 0; i < 1001; i++)
graph.add(new ArrayList());
// Defining the number
// of edges and vertices
int E = 4, V = 7;
// Assigning the values for each
// vertex of the undirected graph
List values = new ArrayList();
values.add(0);
values.add(1);
values.add(1);
values.add(1);
values.add(0);
values.add(1);
values.add(1);
// Constructing the undirected graph
graph.get(1).add(2);
graph.get(2).add(1);
graph.get(3).add(4);
graph.get(4).add(3);
graph.get(4).add(5);
graph.get(5).add(4);
graph.get(6).add(5);
graph.get(5).add(6);
graph.get(6).add(7);
graph.get(7).add(6);
hexValue(graph, V, values);
}
}
// This code is contributed by jithin 输出：
Chain = 0 1
Hexadecimal equivalent = 1
Chain = 1 1 0 1 1
Hexadecimal equivalent = 1B
时间复杂度： O(V 2 )
DFS算法要求O(V + E)复杂度，其中V，E是无向图的顶点和边缘。此外，在每次迭代时都需要获得十六进制等效值，这需要额外的O(V)复杂度才能进行计算。因此，总体复杂度为O(V 2 ) 。