shaunrd0/klips
1
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Initial commit for working on weighted-graph implementation

Browse Source
This commit is contained in:
Shaun Reed 2021-07-16 12:28:41 -04:00
parent 64df3419a0
commit 835dbc7f7d
4 changed files with 485 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
cpp/algorithms/graphs/weighted/CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
################################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: A basic CMakeLists configuration to test RBT implementation ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
################################################################################
#
cmake_minimum_required(VERSION 3.15)
project(
#[[NAME]] WeightedGraph
VERSION 1.0
DESCRIPTION "Practice implementing and using weighted graphs in C++"
LANGUAGES CXX
)
add_library(lib-graph-weighted "lib-graph.cpp")
add_executable(graph-test-weighted "graph.cpp")
target_link_libraries(graph-test-weighted lib-graph-weighted)

140
cpp/algorithms/graphs/weighted/graph.cpp Normal file
View File

@ -0,0 +1,140 @@
/*##############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: An example of an object graph implementation ##
## Algorithms in this example are found in MIT Intro to Algorithms ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
################################################################################
*/
#include "lib-graph.hpp"
int main (const int argc, const char * argv[])
{
// We could initialize the graph with some localNodes...
std::vector<Node> localNodes{
{1, {2, 5}}, // Node 1
{2, {1, 6}}, // Node 2
{3, {4, 6, 7}},
{4, {3, 7, 8}},
{5, {1}},
{6, {2, 3, 7}},
{7, {3, 4, 6, 8}},
{8, {4, 6}},
};
Graph bfsGraphInit(localNodes);
std::cout << "\n\n##### Breadth First Search #####\n";
// Or we could use an initializer list...
// Initialize a example graph for Breadth First Search
Graph bfsGraph(
{
{1, {2, 5}}, // Node 1
{2, {1, 6}}, // Node 2...
{3, {4, 6, 7}},
{4, {3, 7, 8}},
{5, {1}},
{6, {2, 3, 7}},
{7, {3, 4, 6, 8}},
{8, {4, 6}},
}
);
// The graph traversed in this example is seen in MIT Intro to Algorithms
// + Chapter 22, Figure 22.3 on BFS
bfsGraph.BFS(bfsGraph.GetNodeCopy(2));
std::cout << "\nTesting finding a path between two nodes using BFS...\n";
// Test finding a path between two nodes using BFS
auto path = bfsGraph.PathBFS(
bfsGraph.GetNodeCopy(1), bfsGraph.GetNodeCopy(7)
);
// If we were returned an empty path, it doesn't exist
if (path.empty()) std::cout << "No valid path found!\n";
else {
// If we were returned a path, print it
std::cout << "\nValid path from " << path.front().number
<< " to " << path.back().number << ": ";
for (const auto &node : path) {
std::cout << node.number << " ";
}
std::cout << std::endl;
}
std::cout << "\n\n##### Depth First Search #####\n";
// Initialize an example graph for Depth First Search
Graph dfsGraph(
{
{1, {2, 4}},
{2, {5}},
{3, {5, 6}},
{4, {2}},
{5, {4}},
{6, {6}},
}
);
// The graph traversed in this example is seen in MIT Intro to Algorithms
// + Chapter 22, Figure 22.4 on DFS
dfsGraph.DFS();
std::cout << "\n\n##### Topological Sort #####\n";
// Initialize an example graph for Depth First Search
// + The order of initialization is important
// + To produce the same result as seen in the book
// ++ If the order is changed, other valid topological orders will be found
// The book starts on the 'shirt' node (with the number 6, in this example)
Graph topologicalGraph (
{
{1, {4, 5}}, // undershorts
{2, {5}}, // socks
{3, {}}, // watch
{4, {5, 7}}, // pants
{5, {}}, // shoes
{6, {8, 7}}, // shirt
{7, {9}}, // belt
{8, {9}}, // tie
{9, {}}, // jacket
}
);
// The graph traversed in this example is seen in MIT Intro to Algorithms
// + Chapter 22, Figure 22.4 on DFS
// Unlike the simple-graph example, this final result matches MIT Algorithms
// + Aside from the placement of the watch node, which is not connected
// + This is because the node is visited after all other nodes are finished
std::vector<Node> order =
topologicalGraph.TopologicalSort(topologicalGraph.GetNodeCopy(6));
std::cout << "\nTopological order: ";
while (!order.empty()) {
std::cout << order.back().number << " ";
order.pop_back();
}
std::cout << std::endl << std::endl;
// If we want the topological order to match what is seen in the book
// + We have to initialize the graph carefully to get this result -
Graph topologicalGraph2 (
{
{6, {8, 7}}, // shirt
{8, {9}}, // tie
{7, {9}}, // belt
{9, {}}, // jacket
{3, {}}, // watch
{1, {4, 5}}, // undershorts
{4, {5, 7}}, // pants
{5, {}}, // shoes
{2, {5}}, // socks
}
);
auto order2 = topologicalGraph2.TopologicalSort(*topologicalGraph2.NodeBegin());
std::cout << "\nTopological order: ";
while (!order2.empty()) {
std::cout << order2.back().number << " ";
order2.pop_back();
}
std::cout << std::endl;
}

189
cpp/algorithms/graphs/weighted/lib-graph.cpp Normal file
View File

@ -0,0 +1,189 @@
/*##############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: Driver program to test object graph implementation ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
################################################################################
*/
#include "lib-graph.hpp"
InfoBFS Graph::BFS(const Node& startNode) const
{
// Create local object to track the information gathered during traversal
InfoBFS searchInfo;
// Create a queue to visit discovered nodes in FIFO order
std::queue<const Node *> visitQueue;
// Mark the startNode as in progress until we finish checking adjacent nodes
searchInfo[startNode.number].discovered = Gray;
// Visit the startNode
visitQueue.push(&startNode);
// Continue to visit nodes until there are none left in the graph
while (!visitQueue.empty()) {
// Remove thisNode from the visitQueue, storing its vertex locally
const Node * thisNode = visitQueue.front();
visitQueue.pop();
std::cout << "Visiting node " << thisNode->number << std::endl;
// Check if we have already discovered all the adjacentNodes to thisNode
for (const auto &adjacent : thisNode->adjacent) {
if (searchInfo[adjacent.GetNumber()].discovered == White) {
std::cout << "Found undiscovered adjacentNode: " << adjacent.GetNumber()
<< "\n";
// Mark the adjacent node as in progress
searchInfo[adjacent.GetNumber()].discovered = Gray;
searchInfo[adjacent.GetNumber()].distance =
searchInfo[thisNode->number].distance + 1;
searchInfo[adjacent.GetNumber()].predecessor =
&GetNode(thisNode->number);
// Add the discovered node the the visitQueue
visitQueue.push(&GetNode(adjacent.GetNumber()));
}
}
// We are finished with this node and the adjacent nodes; Mark it discovered
searchInfo[thisNode->number].discovered = Black;
}
// Return the information gathered from this search, JIC caller needs it
return searchInfo;
}
std::deque<Node> Graph::PathBFS(const Node &start, const Node &finish) const
{
// Store the path as copies of each node
// + If the caller modifies these, it will not impact the graph's data
std::deque<Node> path;
InfoBFS searchInfo = BFS(start);
const Node * next = searchInfo[finish.number].predecessor;
bool isValid = false;
do {
// If we have reached the start node, we have found a valid path
if (*next == Node(start)) isValid = true;
// Add the node to the path as we check each node
// + Use emplace_front to call the Node copy constructor
path.emplace_front(*next);
// Move to the next node
next = searchInfo[next->number].predecessor;
} while (next != nullptr);
// Use emplace_back to call Node copy constructor
path.emplace_back(finish);
// If we never found a valid path, erase all contents of the path
if (!isValid) path.erase(path.begin(), path.end());
// Return the path, the caller should handle empty paths accordingly
return path;
}
InfoDFS Graph::DFS() const
{
// Track the nodes we have discovered
InfoDFS searchInfo;
int time = 0;
// Visit each node in the graph
for (const auto& node : nodes_) {
std::cout << "Visiting node " << node.number << std::endl;
// If the node is undiscovered, visit it
if (searchInfo[node.number].discovered == White) {
std::cout << "Found undiscovered node: " << node.number << std::endl;
// Visiting the undiscovered node will check it's adjacent nodes
DFSVisit(time, node, searchInfo);
}
}
return searchInfo;
}
InfoDFS Graph::DFS(const Node &startNode) const
{
// Track the nodes we have discovered
InfoDFS searchInfo;
int time = 0;
auto startIter = std::find(nodes_.begin(), nodes_.end(),
Node(startNode.number, {})
);
// beginning at startNode, visit each node in the graph until we reach the end
while (startIter != nodes_.end()) {
std::cout << "Visiting node " << startIter->number << std::endl;
// If the startIter is undiscovered, visit it
if (searchInfo[startIter->number].discovered == White) {
std::cout << "Found undiscovered node: " << startIter->number << std::endl;
// Visiting the undiscovered node will check it's adjacent nodes
DFSVisit(time, *startIter, searchInfo);
}
startIter++;
}
// Once we reach the last node, check the beginning for unchecked nodes
startIter = nodes_.begin();
// Once we reach the initial startNode, we have checked all nodes
while (*startIter != startNode) {
std::cout << "Visiting node " << startIter->number << std::endl;
// If the startIter is undiscovered, visit it
if (searchInfo[startIter->number].discovered == White) {
std::cout << "Found undiscovered node: " << startIter->number << std::endl;
// Visiting the undiscovered node will check it's adjacent nodes
DFSVisit(time, *startIter, searchInfo);
}
startIter++;
}
return searchInfo;
}
void Graph::DFSVisit(int &time, const Node& startNode, InfoDFS &searchInfo) const
{
searchInfo[startNode.number].discovered = Gray;
time++;
searchInfo[startNode.number].discoveryFinish.first = time;
// Check the adjacent nodes of the startNode
for (const auto &adjacent : startNode.adjacent) {
auto iter = std::find(nodes_.begin(), nodes_.end(),
Node(adjacent.GetNumber(), {}));
// If the adjacentNode is undiscovered, visit it
// + Offset by 1 to account for 0 index of discovered vector
if (searchInfo[iter->number].discovered == White) {
std::cout << "Found undiscovered adjacentNode: "
<< GetNode(adjacent.GetNumber()).number << std::endl;
// Visiting the undiscovered node will check it's adjacent nodes
DFSVisit(time, *iter, searchInfo);
}
}
searchInfo[startNode.number].discovered = Black;
time++;
searchInfo[startNode.number].discoveryFinish.second = time;
}
std::vector<Node> Graph::TopologicalSort(const Node &startNode) const
{
InfoDFS topological = DFS(GetNode(startNode.number));
std::vector<Node> order(nodes_);
auto comp = [&topological](const Node &a, const Node &b) {
return (topological[a.number].discoveryFinish.second <
topological[b.number].discoveryFinish.second);
};
std::sort(order.begin(), order.end(), comp);
// The topologicalOrder is read right-to-left in the final result
// + Output is handled in main as FILO, similar to a stack
return order;
}

134
cpp/algorithms/graphs/weighted/lib-graph.hpp Normal file
View File

@ -0,0 +1,134 @@
/*##############################################################################
## Author: Shaun Reed ##
## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ##
## About: An example of an object graph implementation ##
## Algorithms in this example are found in MIT Intro to Algorithms ##
## ##
## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ##
################################################################################
*/
#ifndef LIB_GRAPH_HPP
#define LIB_GRAPH_HPP
#include <iostream>
#include <algorithm>
#include <map>
#include <utility>
#include <vector>
#include <queue>
#include <unordered_set>
#include <unordered_map>
/******************************************************************************/
// Structures for tracking information gathered from various traversals
struct Node;
// Color represents the discovery status of any given node
// + White is undiscovered, Gray is in progress, Black is fully discovered
enum Color {White, Gray, Black};
// Information used in all searches
struct SearchInfo {
// Coloring of the nodes is used in both DFS and BFS
Color discovered = White;
};
// Information that is only used in BFS
struct BFS : SearchInfo {
// Used to represent distance from start node
int distance = 0;
// Used to represent the parent node that discovered this node
// + If we use this node as the starting point, this will remain a nullptr
const Node *predecessor = nullptr;
};
// Information that is only used in DFS
struct DFS : SearchInfo {
// Create a pair to track discovery / finish time
// + Discovery time is the iteration the node is first discovered
// + Finish time is the iteration the node has been checked completely
// ++ A finished node has considered all adjacent nodes
std::pair<int, int> discoveryFinish;
};
// Store search information in unordered_maps so we can pass it around easily
// + Allows each node to store relative information on the traversal
using InfoBFS = std::unordered_map<int, struct BFS>;
using InfoDFS = std::unordered_map<int, struct DFS>;
/******************************************************************************/
// Node structure for representing a graph
struct Link;
struct Node {
public:
// Constructors
Node(const Node &rhs) = default;
Node & operator=(Node rhs) {
if (this == &rhs) return *this;
swap(*this, rhs);
return *this;
}
Node(int num, std::vector<Link> adj) : number(num), adjacent(std::move(adj)) {}
friend void swap(Node &a, Node &b) {
std::swap(a.number, b.number);
std::swap(a.adjacent, b.adjacent);
}
int number;
std::vector<Link> adjacent;
// Define operator== for std::find; And comparisons between nodes
bool operator==(const Node &b) const { return this->number == b.number;}
// Define an operator!= for comparing nodes for inequality
bool operator!=(const Node &b) const { return this->number != b.number;}
};
struct Link {
explicit Link(Node *n, int w=0) : node(n), weight(w) {}
Node *node;
int weight;
inline int GetNumber() const { return node->number;}
};
/******************************************************************************/
// Graph class declaration
class Graph {
public:
// Constructor
explicit Graph(std::vector<Node> nodes) : nodes_(std::move(nodes)) {}
// Breadth First Search
InfoBFS BFS(const Node& startNode) const;
std::deque<Node> PathBFS(const Node &start, const Node &finish) const;
// Depth First Search
InfoDFS DFS() const;
// An alternate DFS that checks each node of the graph beginning at startNode
InfoDFS DFS(const Node &startNode) const;
// Visit function is used in both versions of DFS
void DFSVisit(int &time, const Node& startNode, InfoDFS &searchInfo) const;
// Topological sort, using DFS
std::vector<Node> TopologicalSort(const Node &startNode) const;
// Returns a copy of a node with the number i within the graph
// + This uses the private, non-const accessor GetNode() and returns a copy
inline Node GetNodeCopy(int i) { return GetNode(i);}
// Return a constant iterator for reading node values
inline std::vector<Node>::const_iterator NodeBegin() { return nodes_.cbegin();}
private:
// A non-const accessor for direct access to a node with the number value i
inline Node & GetNode(int i)
{ return *std::find(nodes_.begin(), nodes_.end(), Node(i, {}));}
// For grabbing a const qualified node
inline const Node & GetNode(int i) const
{ return *std::find(nodes_.begin(), nodes_.end(), Node(i, {}));}
std::vector<Node> nodes_;
};
#endif // LIB_GRAPH_HPP