Exemple #1
0
    def test_solve(self):
        """Test solve

        Args:
            self: TestShortestPathDjikstrasAlgorithm

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        Given Graph: 
        0--1 
        | | 
        3--2--4--5
        '''
        input_graph = UndirectedGraph()
        input_graph.add_edge(0, 1, 4)  # u, v, weight
        input_graph.add_edge(1, 2, 3)
        input_graph.add_edge(2, 3, 1)
        input_graph.add_edge(3, 0, 2)
        input_graph.add_edge(2, 4, 3)
        input_graph.add_edge(4, 5, 2)

        shortest_path_problem = ShortestPathDjikstrasAlgorithm(input_graph)

        # When
        result = shortest_path_problem.solve()

        # Then
        self.assertEqual(result, {0: 0, 1: 4, 2: 3, 3: 2, 4: 6, 5: 8})
Exemple #2
0
    def test_solve(self):
        """Test solve

        Args:
            self: TestFindBridgesInAGraph

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        Given Graph: 
        0--1 
        | | 
        3--2--4--5
        '''
        input_graph = UndirectedGraph()
        input_graph.add_edge(0, 1)
        input_graph.add_edge(1, 2)
        input_graph.add_edge(2, 3)
        input_graph.add_edge(3, 0)
        input_graph.add_edge(2, 4)
        input_graph.add_edge(4, 5)

        find_bridges_problem = FindBridgesInAGraph(input_graph)

        # When
        result = find_bridges_problem.solve()

        # Then
        self.assertEqual(result, [(4, 5), (2, 4)])
    def test_solve(self):
        """Test solve

        Args:
            self: TestDetectCycleInUndirectedGraphUnionFind

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        Given Graph: 
        0--1 
        | | 
        3--2 
        '''
        graph = UndirectedGraph()
        graph.add_edge(0, 1)
        graph.add_edge(1, 2)
        graph.add_edge(2, 3)
        graph.add_edge(3, 0)

        detect_cycle_problem = DetectCycleInUndirectedGraphUnionFind(graph)

        # When
        result = detect_cycle_problem.solve()

        # Then
        self.assertTrue(result)
    def test_solve_not_cycle(self):
        """Test solve (not cycle)

        Args:
            self: TestFindHamiltonianCycle

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        Given Graph: 
        0--1 
        | | 
        3 2 
        '''
        graph = UndirectedGraph()
        graph.add_edge(0, 1)
        graph.add_edge(1, 2)
        # graph.add_edge(2, 3)
        graph.add_edge(3, 0)

        hamiltonian_cycle_problem = FindHamiltonianCycle(graph)

        # When
        result = hamiltonian_cycle_problem.solve()

        # Then
        self.assertEqual(result, [])
    def test_solve_not_a_cycle(self):
        """Test solve (not a cycle)

        Args:
            self: TestDetectCycleInUndirectedGraph

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        
        Given Graph: 
        1--2 
        |  | 
        4  3 
        '''
        graph = UndirectedGraph()
        graph.add_edge(1, 2)
        graph.add_edge(2, 3)
        graph.add_edge(4, 1)

        detect_cycle_problem = DetectCycleInUndirectedGraph(graph)

        # When
        result = detect_cycle_problem.solve()

        # Then
        self.assertFalse(result)
Exemple #6
0
    def create_graph(self):
        """Create a undirected graph

        Args:

        Returns:
            Graph

        Raises:
            None
        """
        graph = UndirectedGraph()
        for i in range(len(self.input_characters_matrix)):
            for j in range(len(self.input_characters_matrix[0])):
                self.add_neighbors(self.input_characters_matrix, i, j, graph)
        return graph
    def test_solve(self):
        """Test solve

        Args:
            self: TestMinimumSpanningTreePrimsAlgorithm

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        Given Graph: 
        0--1 
        | | 
        3--2--4--5
        '''
        input_graph = UndirectedGraph()
        input_graph.add_edge(0, 1, 4)  # u, v, weight
        input_graph.add_edge(1, 2, 3)
        input_graph.add_edge(2, 3, 1)
        input_graph.add_edge(3, 0, 2)
        input_graph.add_edge(2, 4, 3)
        input_graph.add_edge(4, 5, 2)

        min_spanning_tree_problem = MinimumSpanningTreePrimsAlgorithm(
            input_graph)

        # When
        result = min_spanning_tree_problem.solve()

        # Then
        self.assertEqual(result, [(2, 0, 3), (1, 3, 2), (3, 2, 1), (3, 2, 4),
                                  (2, 4, 5)])
Exemple #8
0
    def test_undirected_graph(self):
        """Test for UnDirectedGraph

        Args:
            self: TestGraph

        Returns:
            None

        Raises:
            None
        """
        # Given
        '''
        Note : All the edges are Undirected 
        Given Graph: 
        1--2 
        | | 
        4--3 
        '''
        graph = UndirectedGraph()
        graph.add_edge(1, 2)
        graph.add_edge(2, 3)
        graph.add_edge(3, 4)
        graph.add_edge(4, 1)

        # Then
        self.assertEqual(graph.get_vertices(), [1, 2, 3, 4])
        self.assertEqual(graph.get_vertices_count(), 4)
        self.assertEqual(graph.get_neighbors(1), [2, 4])
        self.assertEqual(graph.get_neighbors(2), [1, 3])
        self.assertEqual(graph.get_neighbors(3), [2, 4])
        self.assertEqual(graph.get_neighbors(4), [3, 1])
        self.assertEqual(graph.get_adjacency_list(), [(None, 1, 2), (None, 1, 4), (None, 2, 3), (None, 3, 4)])
        self.assertEqual(graph.get_adjacency_list_for_vertex(1), [(None, 1, 2), (None, 1, 4)])