Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Find K vertices in the graph which are connected to at least one of remaining vertices
Finding K vertices in the network that are connected to at least one of the remaining vertices may be done using DFS (Depth-First Search). Your beginning point should be one of the remaining vertices, and you should then perform a DFS on that vertex. Each vertex you come across while conducting the search will be noted, and it will be added to the group of similar vertices. Once K vertices have been located or all remaining vertices have been searched, keep repeating this. DFS aids in completing the assignment by carefully exploring the graph to find the K vertices that are still linked to at least one of the remaining vertices.
Methods Used
DFS
BFS
DFS
DFS (Depth-First Look) may be used in the situation of locating K vertices in the chart that are connected to at least one of the remaining vertices. Choose one of the remaining vertices, and then launch a DFS from that vertex. Check each vertex that has passed while exploring the chart and add it to the group of linked vertices. Continue examining the chart until K vertices have been constructed, the criteria have been identified, or all vertices have been examined. DFS enables the differentiating proof of K vertices that maintain links with at least one of the remaining vertices via the depth-first traversal, hence achieving the necessary aim.
Algorithm
Initialise a purge set "connectedVertices" to store the K vertices.
Select a vertex, startVertex," from the remaining vertices.
Create a purge stack "stack" for DFS traversal.
Push the "startVertex" onto the "stack".
While the "stack" isn't empty,
Pop a vertex "currentVertex" from the best of the "stack".
Mark "current vertex" as visited.
Add "currentVertex" to the "connectedVertices" set.
Iterate through the adjoining vertices of "currentVertex":
If the adjacent vertex is within the remaining vertices and not visited,
Push the adjoining vertex onto the "stack".
Repeat steps 2–5 until all K vertices have been distinguished or all remaining vertices have been explored.
Example
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
vector<int> findConnectedVertices(int startVertex, vector<vector<int>>& adjacencyList) {
int N = adjacencyList.size(); // Total number of vertices
vector<int> connectedVertices; // Set of connected vertices
vector<bool> visited(N, false); // Track visited vertices
stack<int> stack; // Stack for DFS traversal
stack.push(startVertex); // Push the startVertex onto the stack
while (!stack.empty()) {
int currentVertex = stack.top();
stack.pop();
if (!visited[currentVertex]) {
visited[currentVertex] = true;
connectedVertices.push_back(currentVertex);
for (int adjVertex : adjacencyList[currentVertex]) {
if (!visited[adjVertex]) {
stack.push(adjVertex);
}
}
}
}
return connectedVertices;
}
int main() {
int N = 7; // Total number of vertices
vector<vector<int>> adjacencyList(N);
// Add adjacency list for each vertex
adjacencyList[0] = {1, 2};
adjacencyList[1] = {0, 2};
adjacencyList[2] = {0, 1, 3};
adjacencyList[3] = {2, 4};
adjacencyList[4] = {3};
adjacencyList[5] = {6};
adjacencyList[6] = {5};
int startVertex = 0;
vector<int> connectedVertices = findConnectedVertices(startVertex, adjacencyList);
cout << "Connected Vertices: ";
for (int vertex : connectedVertices) {
cout << vertex << " ";
}
cout << endl;
return 0;
}
Output
Connected Vertices: 0 2 3 4 1
BSF
Within the setting of finding K vertices within the chart associated to at slightest one of the remaining vertices, BFS (Breadth-First Look) can be utilised. Begin by selecting a vertex from the remaining vertices and perform a BFS from that vertex. Amid the look, check each gone-by vertex and include it in the set of associated vertices. Investigate the chart level by level, guaranteeing that vertices at a closer distance are gone by some time since moving to another level. Rehash this preparation until K vertices are recognised or all remaining vertices are investigated. By navigating the chart in a breadth-first way, BFS helps in recognising the K vertices that keep up an association with at least one of the remaining vertices, finishing the assignment at hand.
Algorithm
Make an purge set S to store the associated vertices.
While K > and R isn't purge, do the following:
a. Select a vertex v from R.
b. Perform a breadth-first look (BFS) beginning from v.
c. Amid the BFS, stamp each gone by vertex and include it to S.
d. Decrement K by 1.
e. Evacuate V from R.
Return the set S containing the K-associated vertices.
The calculation chooses a vertex from the remaining vertices and performs a BFS on that vertex. It marks each gone-by vertex and incorporates it within the set of associated vertices. The strategy continues until either K vertices have been perceived or no remaining vertices have been cleared out.
Example
#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>
std::unordered_set<int> purgeVertices(int K, const std::vector<std::vector<int>>& graph) {
std::unordered_set<int> S;
std::vector<bool> visited(graph.size(), false);
auto bfs = [&](int start) {
std::queue<int> q;
q.push(start);
while (!q.empty()) {
int v = q.front();
q.pop();
if (!visited[v]) {
visited[v] = true;
S.insert(v);
K--;
if (K == 0) {
return;
}
for (int neighbor : graph[v]) {
if (!visited[neighbor]) {
q.push(neighbor);
}
}
}
}
};
for (int i = 0; i < graph.size() && K > 0; i++) {
bfs(i);
}
return S;
}
int main() {
// Example usage
int K = 3;
std::vector<std::vector<int>> graph = {
{1, 2},
{0, 2, 3},
{0, 1, 3},
{1, 2}
};
std::unordered_set<int> result = purgeVertices(K, graph);
// Print the resulting set
std::cout << "Purged vertices: ";
for (int v : result) {
std::cout << v << " ";
}
std::cout << std::endl;
return 0;
}
Output
Purged vertices: 2 1 0
Conclusion
This article gives an algorithmic approach to finding K vertices in a chart that are associated to at slightest one of the remaining vertices. The calculation utilises either Depth-First Look (DFS) or Breadth-First Look (BFS) to navigate the chart and recognise the specified vertices. It incorporates code scraps in C that execute the calculation utilising diverse capacities for the search operation. The article points to assist software engineers get it and execute the method of distinguishing associated vertices in a chart, subsequently encouraging different applications and examinations that depend on chart network.
52 Views
To Continue Learning Please Login