Data Structure on 孤筝の温暖小家

Data Structure Lab Report 8 - Critical Path

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 15:00:26 +0800

Data Structure Lab Report 8 - Critical Path

Author: 孤筝(lvbowen040427@163.com)

a. Problem Analysis

In the Critical Path Method (CPM), we need to identify the critical path in a project, which is the sequence of activities that determines the project’s total duration. To solve this problem, we first construct a data structure Activity to represent project activities and design a Project class to handle project calculations and output.

The calculation of the critical path primarily relies on two key steps:

Earliest Start Time (ES) Calculation: Starting from the initial event, we use topological sorting and dynamic programming to compute the earliest start time for each activity.
Latest Start Time (LS) Calculation: Starting from the final event, we perform a reverse traversal of the topological order and use dynamic programming to compute the latest start time for each activity.

By comparing the earliest and latest start times, we can identify the activities on the critical path, which are crucial for determining the project’s total duration.

b. Algorithm Design

1. Calculating Earliest Start Time

We use topological sorting and dynamic programming to compute the earliest start time. First, we identify all initial events (activities with no predecessors) and then traverse the graph starting from these events, updating the earliest start time for each activity.

// Calculate earliest start time
void calculateEarliestStart() {
    queue<int> q;
    for (const Activity& activity : activities) { // Traverse topological order
        if (activity.next.empty()) { // If a node's adjacency list is empty (i.e., it's an initial event)
            q.push(activity.id); // Enqueue
            earliestStart[activity.id] = 0; // Set earliest start time to 0
        }
    }

    while (!q.empty()) { // While queue is not empty
        int currentId = q.front(); // Dequeue the highest-priority event (currentId)
        q.pop();

        for (int nextId : activities[currentId].next) { // Traverse currentId's adjacency list
            earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
            // nextId's earliest start time = max{current recorded earliest start time, predecessor currentId's earliest start time + currentId's duration}
            q.push(nextId);
        }
    }
}

2. Calculating Latest Start Time

By traversing the topological order in reverse, we compute the latest start time. Starting from the final event, we iteratively update the latest start time for each activity.

// Calculate latest start time
void calculateLatestStart() {
    latestStart = earliestStart; // Initialize latest start time as earliest start time

    for (int i = activities.size() - 1; i >= 0; --i) { // Reverse traversal starting from the last event (i)
        for (int nextId : activities[i].next) {
            latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
            // Current event's latest start time = min{recorded latest start time, next event nextId's latest start time - current event i's duration}
        }
    }
}

c. Data Structure Design

We use two key data structures:

Activity Struct: Represents a project activity, including the activity ID, duration, and subsequent activities.

// Struct representing a project activity
struct Activity {
    int id;      // Activity ID
    int duration; // Duration
    vector<int> next; // Subsequent activities
};

Project Class: Manages the project, including methods for adding activities, calculating earliest and latest start times, printing the critical path, and displaying time information.

d. Debugging Process

During debugging, we focused on the following aspects:

Data Structure Correctness: Ensuring the Activity struct and Project class accurately represent project and activity relationships.
Algorithm Correctness: Verifying the correctness of the algorithms for calculating earliest and latest start times.
Output Accuracy: Checking if the printed critical path and time information meet expectations.

e. Output Results

After running the program, we obtained the following output:

Critical Path: 0 1 2 3 4 5 
Activity 0: ES=0, LS=0
Activity 1: ES=2, LS=2
Activity 2: ES=6, LS=6
Activity 3: ES=9, LS=9
Activity 4: ES=14, LS=14
Activity 5: ES=16, LS=16

From the results, we can see that the critical path consists of activities 0, 1, 2, 3, 4, and 5. The earliest and latest start times for each activity are correctly calculated, confirming the effectiveness of our algorithm and data structure design.

f. Source Code

#include 
#include 
#include 
#include 

using namespace std;

// Struct representing a project activity
struct Activity {
    int id;      // Activity ID
    int duration; // Duration
    vector<int> next; // Subsequent activities
};

class Project {
private:
    vector<Activity> activities; // Vector storing project activities
    vector<int> earliestStart;   // Earliest start time
    vector<int> latestStart;     // Latest start time

public:
    // Add an activity
    void addActivity(int id, int duration, const vector<int>& next) {
        activities.push_back({id, duration, next});
    }

    // Calculate earliest start time
    void calculateEarliestStart() {
        queue<int> q;
        for (const Activity& activity : activities) { // Traverse topological order
            if (activity.next.empty()) { // If a node's adjacency list is empty (i.e., it's an initial event)
                q.push(activity.id); // Enqueue
                earliestStart[activity.id] = 0; // Set earliest start time to 0
            }
        }

        while (!q.empty()) { // While queue is not empty
            int currentId = q.front(); // Dequeue the highest-priority event (currentId)
            q.pop();

            for (int nextId : activities[currentId].next) { // Traverse currentId's adjacency list
                earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
                // nextId's earliest start time = max{current recorded earliest start time, predecessor currentId's earliest start time + currentId's duration}
                q.push(nextId);
            }
        }
    }

    // Calculate latest start time
    void calculateLatestStart() {
        latestStart = earliestStart; // Initialize latest start time as earliest start time

        for (int i = activities.size() - 1; i >= 0; --i) { // Reverse traversal starting from the last event (i)
            for (int nextId : activities[i].next) {
                latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
                // Current event's latest start time = min{recorded latest start time, next event nextId's latest start time - current event i's duration}
            }
        }
    }

    // Print the critical path
    void printCriticalPath() {
        cout << "Critical Path: ";
        for (const Activity& activity : activities) { // Traverse topological order
            if (earliestStart[activity.id] == latestStart[activity.id]) { // Critical path activities have ES == LS
                cout << activity.id << " ";
            }
        }
        cout << endl;
    }

    // Print earliest and latest start times
    void printTimeInfo() {
        for (const Activity& activity : activities) {
            cout << "Activity " << activity.id << ": ES=" << earliestStart[activity.id]
                 << ", LS=" << latestStart[activity.id] << endl;
        }
    }

    // Constructor for initialization
    Project(int numActivities) : earliestStart(numActivities), latestStart(numActivities) {}

};

int main() {
    Project project(6); // Assume there are 6 activities

    // Add activities in the format: activity ID, duration, subsequent activity IDs
    project.addActivity(0, 2, {1});
    project.addActivity(1, 4, {2});
    project.addActivity(2, 3, {3});
    project.addActivity(3, 5, {4});
    project.addActivity(4, 2, {5});
    project.addActivity(5, 1, {});

    // Calculate earliest and latest start times
    project.calculateEarliestStart();
    project.calculateLatestStart();

    // Print critical path and time information
    project.printCriticalPath();
    project.printTimeInfo();

    return 0;
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 7 – Kruskal's Algorithm and the Minimum Spanning Tree Problem, Dijkstra's Algorithm and the Shortest Path Problem in Weighted Graphs

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:58:44 +0800

Data Structure Lab Report 7 – Kruskal's Algorithm and the Minimum Spanning Tree Problem, Dijkstra's Algorithm and the Shortest Path Problem in Weighted Graphs

Author: 孤筝(lvbowen040427@163.com)

Kruskal’s Algorithm for Generating Minimum Spanning Trees

a Problem Analysis

We need to use Kruskal’s algorithm to find the minimum spanning tree (MST) for a graph with 10 nodes and 20 edges. Kruskal’s algorithm is based on a greedy approach, constructing the MST by iteratively selecting edges with the smallest weights while ensuring no cycles are formed.

b Algorithm Design

Key Steps of Kruskal’s Algorithm:

Edge Sorting:

All edges are sorted in ascending order of their weights.

sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {
    return a.weight < b.weight;
});

The sort function sorts the elements in a container based on a specified comparison rule. Here, it sorts edges in ascending order of their weights, allowing Kruskal’s algorithm to select edges with the smallest weights first. 1. edges.begin() and edges.end(): These parameters define the range of elements to be sorted. begin() returns an iterator to the first element, and end() returns an iterator to the position after the last element. 2. [](const Edge& a, const Edge& b) { return a.weight < b.weight; }: This is a lambda expression that defines the comparison rule. It compares two edges a and b based on their weights and returns true if a.weight is less than b.weight, ensuring ascending order. 3. const Edge& a and const Edge& b are the parameters of the lambda function, representing the two edges being compared. 4. return a.weight < b.weight; ensures that edges are sorted in ascending order of their weights.

Union-Find Initialization:

Initialize the Union-Find (Disjoint Set Union, DSU) data structure, where each node is initially its own parent.

The Union-Find data structure is used to manage sets of elements, supporting two primary operations: Find (to determine the root of an element) and Union (to merge two sets).
Basic Operations:
1. Find: Determines the root of an element, which identifies the set it belongs to.
2. Union: Merges two sets by connecting their roots.
Implementation Details:
- Typically implemented using arrays where each element’s value represents its parent. Initially, each element is its own parent.
Optimizations:
- Path Compression: During the Find operation, the path from the element to its root is flattened, improving future Find operations.
- Union by Rank: During the Union operation, the smaller tree (in terms of depth) is attached to the root of the larger tree to keep the tree balanced and operations efficient.

Edge Traversal:

Traverse the sorted edges, adding each edge to the MST if it does not form a cycle.

Implementation:

// Kruskal's Algorithm
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) { // Input: edge list and number of nodes
    // Sort edges by weight in ascending order
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
// Parameters: start iterator, end iterator, lambda expression (comparison function)
{
        return a.weight < b.weight; // Comparison rule: sort edges by weight in ascending order
    });

    // Initialize Union-Find
    UnionFind uf(numNodes); // UnionFind(size)

    // Store edges of the MST
    vector<Edge> result;

    // Traverse sorted edges
    for (const Edge& edge : edges) {
        // Check if adding this edge forms a cycle
        if (uf.find(edge.start) != uf.find(edge.end)) { // If the start and end nodes are in different sets (subtrees)
            // No cycle formed, add edge to MST
            result.push_back(edge);
            uf.unite(edge.start, edge.end); // Merge the two subtrees (mark as the same set) to prevent cycles
        }
    }

    return result;
}

c Data Structure Design

1. Edge Struct:

// Edge struct
struct Edge {
    int start, end, weight; // Start node, end node, and weight of the edge
};

The Edge struct represents an edge in the graph, containing the start node, end node, and weight.

2. UnionFind Class:

// Union-Find implementation
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
// `parent` stores the root of each node, initially set to itself; `rank` approximates tree depth, initialized to 0
        for (int i = 0; i < size; ++i) {
            parent[i] = i; // Root initially set to itself
        }
    }

    int find(int x) { // Find the root of a node
        if (x != parent[x]) { // If `x` is not its own parent (has an ancestor)
            parent[x] = find(parent[x]); // Path compression: set parent to root
        }
        return parent[x]; // Return the root
    }

    void unite(int x, int y) { // Merge two subtrees
        int rootX = find(x); // Root of `x`
        int rootY = find(y); // Root of `y`

        if (rootX != rootY) { // If `x` and `y` are in different sets (subtrees)
            if (rank[rootX] < rank[rootY]) {
                // If `x`'s subtree is shallower than `y`'s
                parent[rootX] = rootY;
                // Attach `x`'s subtree to `y`'s to avoid increasing depth
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else { // If subtrees have the same depth
                parent[rootX] = rootY; // Attach `x`'s subtree to `y`'s
                rank[rootY]++; // Increment depth after merge
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

The UnionFind class implements the Union-Find data structure for cycle detection. The find function locates the root of a node, and the unite function merges two sets.
In the constructor, the rank array is initialized to 0, representing the approximate depth of each tree. Initially, each node is its own tree with depth 0.
During unite, the rank array ensures that the smaller tree is attached to the larger one to maintain balance and efficiency.

d Debugging Process

During debugging, intermediate outputs (e.g., sorted edges, MST construction steps, and Union-Find states) were examined to verify the algorithm’s correctness. Edge cases, such as disconnected graphs, were also tested.

e Output

Graph:
0 - 1 : 4
0 - 2 : 1
1 - 3 : 2
1 - 4 : 8
2 - 5 : 3
2 - 6 : 7
3 - 7 : 5
3 - 8 : 1
4 - 9 : 6
5 - 6 : 2
6 - 8 : 6
7 - 9 : 3
8 - 9 : 9
1 - 2 : 2
3 - 4 : 3
5 - 7 : 4
6 - 9 : 7
0 - 3 : 6
2 - 8 : 5
4 - 5 : 4
Edges in the minimum spanning tree:
0 - 2 : 1
3 - 8 : 1
1 - 3 : 2
1 - 2 : 2
5 - 6 : 2
2 - 5 : 3
3 - 4 : 3
7 - 9 : 3
5 - 7 : 4

f Source Code

#include 
#include 
#include  // For `sort`

using namespace std;

// Edge struct
struct Edge {
    int start, end, weight; // Start node, end node, and weight of the edge
};

// Union-Find implementation
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
// `parent` stores the root of each node, initially set to itself; `rank` approximates tree depth, initialized to 0
        for (int i = 0; i < size; ++i) {
            parent[i] = i; // Root initially set to itself
        }
    }

    int find(int x) { // Find the root of a node
        if (x != parent[x]) { // If `x` is not its own parent (has an ancestor)
            parent[x] = find(parent[x]); // Path compression: set parent to root
        }
        return parent[x]; // Return the root
    }

    void unite(int x, int y) { // Merge two subtrees
        int rootX = find(x); // Root of `x`
        int rootY = find(y); // Root of `y`

        if (rootX != rootY) { // If `x` and `y` are in different sets (subtrees)
            if (rank[rootX] < rank[rootY]) {
                // If `x`'s subtree is shallower than `y`'s
                parent[rootX] = rootY;
                // Attach `x`'s subtree to `y`'s to avoid increasing depth
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else { // If subtrees have the same depth
                parent[rootX] = rootY; // Attach `x`'s subtree to `y`'s
                rank[rootY]++; // Increment depth after merge
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

// Kruskal's Algorithm
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) { // Input: edge list and number of nodes
    // Sort edges by weight in ascending order
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
// Parameters: start iterator, end iterator, lambda expression (comparison function)
{
        return a.weight < b.weight; // Comparison rule: sort edges by weight in ascending order
    });

    // Initialize Union-Find
    UnionFind uf(numNodes); // UnionFind(size)

    // Store edges of the MST
    vector<Edge> result;

    // Traverse sorted edges
    for (const Edge& edge : edges) {
        // Check if adding this edge forms a cycle
        if (uf.find(edge.start) != uf.find(edge.end)) { // If the start and end nodes are in different sets (subtrees)
            // No cycle formed, add edge to MST
            result.push_back(edge);
            uf.unite(edge.start, edge.end); // Merge the two subtrees (mark as the same set) to prevent cycles
        }
    }

    return result;
}

int main() {
    // Create a graph with 10 nodes
    int numNodes = 10;

    // Manually define edges with start, end, and weight
    vector<Edge> edges = {
        {0, 1, 4},
        {0, 2, 1},
        {1, 3, 2},
        {1, 4, 8},
        {2, 5, 3},
        {2, 6, 7},
        {3, 7, 5},
        {3, 8, 1},
        {4, 9, 6},
        {5, 6, 2},
        {6, 8, 6},
        {7, 9, 3},
        {8, 9, 9},
        {1, 2, 2},
        {3, 4, 3},
        {5, 7, 4},
        {6, 9, 7},
        {0, 3, 6},
        {2, 8, 5},
        {4, 5, 4}
    };
    // Output the graph
    cout << "Graph:" << endl;
    for (const Edge& edge : edges) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }
    // Run Kruskal's algorithm
    vector<Edge> minSpanningTree = kruskal(edges, numNodes);

    // Output edges in the MST
    cout << "Edges in the minimum spanning tree:" << endl;
    for (const Edge& edge : minSpanningTree) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }

    return 0;
}

Dijkstra’s Algorithm for Solving Shortest Path in Weighted Graphs

a Problem Analysis

The code implements Dijkstra’s algorithm to solve the single-source shortest path problem in a weighted graph. Given an adjacency matrix representation of the graph, the algorithm computes the shortest distances from a specified start node to all other nodes.

b Algorithm Design

1. Initialization

int n = graph.size();
distances.resize(n, INF);

Analysis: The number of nodes n is determined from the graph’s size. The distances array is initialized with INF (infinity), representing initially unknown distances.

2. Priority Queue Setup

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
distances[start] = 0;
pq.push({0, start});

Analysis: A priority queue pq is created to manage nodes by their current shortest distance. The start node’s distance is set to 0, and it is added to the queue.

3. Main Loop

while (!pq.empty()) {
    int u = pq.top().second;
    pq.pop();

    for (int v = 0; v < n; ++v) {
        if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
            distances[v] = distances[u] + graph[u][v];
            pq.push({distances[v], v});
        }
    }
}

Analysis: The loop extracts the node u with the smallest current distance. For each neighbor v of u, if a shorter path is found via u, the distance is updated, and v is added to the queue.

4. Termination

Analysis: The algorithm terminates when the queue is empty, having processed all nodes and finalized their shortest distances.

c Data Structure Design

1. Graph (Adjacency Matrix)

typedef vector<vector<int>> Graph;

Analysis: The Graph is represented as a 2D vector where graph[u][v] holds the weight of the edge from node u to v. A weight of 0 indicates no edge.

2. Distances Array

vector<int> distances;

Analysis: The distances array stores the shortest known distances from the start node to each node, initialized to INF and updated during the algorithm’s execution.

3. Priority Queue

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

Analysis: The priority queue pq holds pairs of distances and nodes, ordered by distance. The greater comparator ensures the smallest distance is always processed first.

d Debugging Process

Intermediate outputs (e.g., queue states, distance updates) were logged to verify correctness.
Edge cases (e.g., no edges, negative weights) were tested to ensure robustness.
Multiple test cases confirmed the algorithm’s accuracy and efficiency.

e Output

The final output shows the shortest distances from the start node to all other nodes, matching expectations.

Distance from node 0 to 0: 0
Distance from node 0 to 1: 2
Distance from node 0 to 2: 3
Distance from node 0 to 3: 9
Distance from node 0 to 4: 6

f Source Code

#include 
#include 
#include  // For priority_queue
#include  // For INT_MAX

using namespace std;

#define INF INT_MAX

// Graph representation using adjacency matrix
typedef vector<vector<int>> Graph;
// 2D vector where graph[u][v] represents the weight of the edge from node `u` to `v`

// Dijkstra's Algorithm
void dijkstra(const Graph& graph, int start, vector<int>& distances) {
// Input: graph, start node, and distances array
    int n = graph.size(); // Number of nodes
    distances.resize(n, INF);  // Initialize distances to infinity

    // Priority queue to manage nodes by their current shortest distance
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
// Pairs are {distance, node}, stored in a vector, ordered by distance (smallest first)

    distances[start] = 0;  // Distance from start to itself is 0
    pq.push({0, start});   // Add start node to the queue

    while (!pq.empty()) {
        int u = pq.top().second;  // Extract the node with the smallest current distance
        pq.pop();

        for (int v = 0; v < n; v++) {
            if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
                // If a shorter path to `v` is found via `u`, update the distance
                distances[v] = distances[u] + graph[u][v];
                pq.push({distances[v], v});  // Add the updated distance and node to the queue
            }
        }
    }
}

int main() {
    // Example graph represented as an adjacency matrix
    Graph graph = {
        {0, 2, 4, 0, 0},
        {0, 0, 1, 7, 0},
        {0, 0, 0, 0, 3},
        {0, 0, 0, 0, 1},
        {0, 0, 0, 0,

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!