Weighted Vertex Cover Problem
The weighted vertex cover problem aims to find the minimum weight vertex cover in a graph where vertices have associated weights. It is an optimization version of the basic vertex cover problem.
Some key aspects:
 Graph has weighted vertices
 Find subset of vertices that covers all edges
 Minimize total weight of chosen vertex cover
Java example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 int minVertexCover(Graph graph) {
int[] vertices = graph.getVertices();
int[] weights = graph.getWeights();
int n = vertices.length;
int[][] dp = new int[n+1][1<<n];
// Compute minimum vertex covers bottomup
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1<<n); mask++) {
// Try including/excluding vertex i
dp[i][mask] = Math.min(include, exclude);
}
}
// Result is full vertex cover using all nodes
return dp[n][(1<<n)1];
}

C++ example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 int minVertexCover(Graph graph) {
vector<int> vertices = graph.getVertices();
vector<int> weights = graph.getWeights();
int n = vertices.size();
vector<vector<int>> dp(n+1, vector<int>(1<<n, 0));
// Bottomup dynamic programming
for (int i = 1; i <= n; i++) {
for (int mask = 0; mask < (1<<n); mask++) {
// Compute options
dp[i][mask] = min(include, exclude);
}
}
return dp[n][(1<<n)1]; // Full vertex cover
}

Python example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 def minVertexCover(graph):
@cache
def dfs(node, mask):
if mask == completed_mask:
return 0
cost = float('inf')
for next_node in graph[node]:
if (mask & (1<<next_node)) == 0:
cost = min(cost, dfs(next_node, mask  (1<<next_node)) + graph.weights[next_node])
return cost
return dfs(0, 1)

The weighted version of vertex cover has applications in resource optimization and scheduling.
The Weighted Vertex Cover Problem is an extension of the Vertex Cover Problem. Each vertex has an associated weight, and the goal is to find the smallest set of vertices such that every edge is touched by at least one vertex in the set, while minimizing the total weight of the vertices selected. In simpler terms, you have to find the least “expensive” set of vertices that covers all edges.
Algorithm
 Identify Edges: List all edges in the graph.
 Identify Vertex Weights: Associate a weight with each vertex.
 Select Vertices: Choose vertices that connect these edges.
 Minimize Weight: Minimize the total weight of the selected vertices.
Java Code
In Java, you can use data structures like HashMap to hold vertex weights and a HashSet for the cover.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 import java.util.HashMap;
import java.util.HashSet;
public class WeightedVertexCover {
public static void main(String[] args) {
int[][] graph = {{0, 1}, {0, 2}, {1, 3}, {3, 4}};
HashMap<Integer, Integer> weights = new HashMap<>(); // vertex, weight
weights.put(0, 1);
weights.put(1, 2);
weights.put(2, 1);
weights.put(3, 2);
weights.put(4, 3);
HashSet<Integer> cover = new HashSet<>();
int totalWeight = 0;
for (int[] edge : graph) {
if (!cover.contains(edge[0]) && !cover.contains(edge[1])) {
if (weights.get(edge[0]) <= weights.get(edge[1])) {
cover.add(edge[0]);
totalWeight += weights.get(edge[0]);
} else {
cover.add(edge[1]);
totalWeight += weights.get(edge[1]);
}
}
}
System.out.println("Vertex Cover: " + cover);
System.out.println("Total Weight: " + totalWeight);
}
}

C++ Code
In C++, you can use std::map
to keep track of vertex weights and std::set
for the vertex cover.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 #include <iostream>
#include <map>
#include <set>
#include <vector>
int main() {
std::vector<std::pair<int, int>> graph = {{0, 1}, {0, 2}, {1, 3}, {3, 4}};
std::map<int, int> weights = {{0, 1}, {1, 2}, {2, 1}, {3, 2}, {4, 3}}; // vertex, weight
std::set<int> cover;
int totalWeight = 0;
for (auto &edge : graph) {
if (cover.find(edge.first) == cover.end() && cover.find(edge.second) == cover.end()) {
if (weights[edge.first] <= weights[edge.second]) {
cover.insert(edge.first);
totalWeight += weights[edge.first];
} else {
cover.insert(edge.second);
totalWeight += weights[edge.second];
}
}
}
std::cout << "Vertex Cover: ";
for (int vertex : cover) {
std::cout << vertex << " ";
}
std::cout << "\nTotal Weight: " << totalWeight << std::endl;
return 0;
}

Python Code
Python’s dictionaries can serve to hold the vertex weights, and a set can be used for the vertex cover.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 graph = [(0, 1), (0, 2), (1, 3), (3, 4)]
weights = {0: 1, 1: 2, 2: 1, 3: 2, 4: 3} # vertex: weight
cover = set()
total_weight = 0
for edge in graph:
if edge[0] not in cover and edge[1] not in cover:
if weights[edge[0]] <= weights[edge[1]]:
cover.add(edge[0])
total_weight += weights[edge[0]]
else:
cover.add(edge[1])
total_weight += weights[edge[1]]
print("Vertex Cover:", cover)
print("Total Weight:", total_weight)

This provides a straightforward approach to solving the Weighted Vertex Cover Problem using basic data structures in Java, C++, and Python. Again, note that this is a heuristic approach and may not provide the minimum weighted vertex cover for all graphs. Advanced algorithms like dynamic programming can provide an optimal solution.