Chapter 28. Graphs and Applications. Part1. Non-weighted Graphs

Transcription

1 Chapter 28 Graphs and Applications Part1. Non-weighted Graphs CIS265/506 Cleveland State University Prof. Victor Matos Adapted from: Introduction to Java Programming: Comprehensive Version, Eighth Edition by Y. Daniel Liang

2 Modeling Using Graphs Seattle Boston Chicago New York Denver San Francisco Kansas City Los Angeles Atlanta Dallas Houston Miami 2

3 Weighted Graph Animation 3

4 Seven Bridges of Königsberg A The city of Konigsberg is connected to two islands through seven bridges. C Island 1 D Island 2 B The city, islands, and bridge could be abstracted as a graph holding vertices and edges (bridges). The problem was to find a walk through the graph that would begin and end at the same vertex crossing each edge exactly once. A C B D 4

5 Seven Bridges of Königsberg No solution!! Def. A path that traverses all bridges once and also has the same starting and ending is called an Eulerian circuit. A, 3 Such a circuit exists if, and only if, the graph is connected, and there are no nodes of odd degree at all. A node degree is the count of edges adjacent to the node. C, 5 B, 3 D, 3 5 Leonhard Euler, 1707

6 Basic Graph Terminology 1. What is a graph? 2. Directed vs. undirected graphs 3. Weighted vs. non-weighted graphs 4. Adjacent vertices 5. Incident 6. Degree 7. Neighbor 8. loop Leonhard Euler,

7 Basic Graph Terminology 1. What is a graph? A graph G(V, E) is a representation of a set of vertices V and edges E. Two vertices v1 and v2 in V are related iff there is and edge e 12 in E connecting v1 and v2. Leonhard Euler,

8 Basic Graph Terminology 1. What is a graph? Seattle Chicago Boston New York Denver San Francisco Kansas City Los Angeles Atlanta Dallas Houston Miami 8

9 Basic Graph Terminology 2. Node, vertice, vertex 3. Parallel edge 4. Loops 5. Complete graph 6. Simple graph (connected, undirected, no loops, no parallel weighted) 9

10 Basic Graph Terminology 7. Spanning tree T of a connected, undirected graph G is a tree composed of all the vertices and some (or perhaps all) of the edges of G. A graph may have several Spanning trees! 10

11 Java: Representing Graphs Representing Vertices Representing Edges: Edge Array Edge Objects (POJO) Adjacency Matrices Adjacency Lists 11

12 Seattle Boston Representing Vertices San Francisco Denver Chicago Kansas City New York A vertex could be an object of any type. Los Angeles Dallas Atlanta Houston Miami String[ ] vertices = { Seattle, San Francisco, ; public class City { private String cityname; private int population;... City[ ] vertices = {city0, city1, ; List<String> vertices; 12

13 Representing Edges: Edge Array int[][] edges = {{0, 1, {0, 3 {0, 5, {1, 0, {1, 2, ; There is an edge between city0 and city1 13

14 Representing Edges: Edge Object public class Edge { int v1, v2; public Edge(int v1, int v2) { this.v1 = v1; this.v 2 = v2; List<Edge> list = new ArrayList<Edge>(); list.add( new Edge(0, 1) ); list.add( new Edge(0, 3) );

15 Representing Edges: Adjacency Matrix int[][] adjacencymatrix = { {0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, // Seattle {1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // San Francisco {0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, // Los Angeles {1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, // Denver {0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, // Kansas City {1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, // Chicago {0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, // Boston {0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, // New York {0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, // Atlanta {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, // Miami {0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, // Dallas {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0 // Houston ; Entry adjacencymatrix[i][j] is 1 if there is an edge connecting city-i and city-j 15

16 Representing Edges: Adjacency List List<Integer>[ ] neighbors = new LinkedList<Integer>[12]; Seattle San Francisco Los Angeles Denver Kansas City Chicago Boston New York Atlanta Miami Dallas Houston neighbors[0] neighbors[1] neighbors[2] neighbors[3] neighbors[4] neighbors[5] neighbors[6] neighbors[7] neighbors[8] neighbors[9] neighbors[10] neighbors[11]

17 Modeling Graphs In a style similar to the Java Collection Framework we will define 1. an interface named Graph that contains all common operations of graphs and 2. an abstract class named AbstractGraph that partially implements the Graph interface. 3. Many concrete graphs may be added to the design. For example, we will define such graphs named UnweightedGraph and WeightedGraph. UnweightedGraph Graph AbstractGraph WeightedGraph 17 Interface Abstract Class Concrete Classes

18 Modeling Graphs 18

19 Modeling Graphs 19

20 Graph Traversals - Trees Depth-first search (DFS) and breadth-first search (BFS) Both traversals result in a spanning tree, which can be modeled using a class. 20

21 Depth-First Search (DFS) 1. In the case of a tree, DFS search starts from the root (similar to pre-order navigation). 2. In a graph, the search can start from any vertex. 21 dfs(vertex v) { visit v; for each neighbor w of v if (w has not been visited) { dfs(w);

22 DFS Depth-First Search Example Begin at node

23 DFS Depth-First Search Example Seattle Boston Chicago New York Denver San Francisco Kansas City Los Angeles Atlanta Dallas Houston Miami 23

24 Applications of the DFS 1. Detecting whether a graph is connected. Search the graph starting from any vertex. If the number of vertices searched is the same as the number of vertices in the graph, the graph is connected. Otherwise, the graph is not connected 2. Detecting / finding a path between two vertices. 3. Finding all connected components. A connected component is a maximal connected subgraph in which every pair of vertices are connected by a path. 4. Detecting / Finding a cycle in a graph. 24

25 Breadth-First Search (BFS) With breadth-first traversal of a tree, the nodes are visited level by level. 1. First the root is visited, 2. then all the children of the root, 3. then the grandchildren of the root from left to right, 4. and so on. 25

26 BFS Breadth-First Search Algorithm bfs(vertex v) { create an empty queue for storing vertices to be visited; add v into the queue; mark v visited; while the queue is not empty { dequeue a vertex, say u, from the queue process u; for each neighbor w of u if w has not been visited { add w into the queue; mark w visited; 26

27 BFS Breadth-First Search Example Queue: 0 Queue: Queue: isvisited[0] = true isvisited[1] = true isvisited[2] = true isvisited[3] = true isvisited[4] = true 27

28 BFS Breadth-First Search Example Seattle Boston Chicago New York Denver San Francisco Kansas City Los Angeles Atlanta Dallas Houston Miami 28

29 29 Applications of the BFS 1. Detecting whether a graph is connected. A graph is connected if there is a path between any two vertices in the graph. 2. Detecting whether there is a path between two vertices. 3. Finding a shortest path between two vertices. You can prove that the path between the root and any node in the BFS tree is the shortest path between the root and the node 4. Finding all connected components. A connected component is a maximal connected subgraph in which every pair of vertices are connected by a path. 5. Detecting /Finding whether there is a cycle in the graph. 6. Testing whether a graph is bipartite. A graph is bipartite if the vertices of the graph can be divided into two disjoint sets such that no edges exist between vertices in the same set.

30 Programming Excersice Represent the following graph. Traverse using DFS and BFS 30

31 BFS & DFS Programming Exercise public static void main(string[] args) { Graph<String> graph = new Graph<String>(); graph.addvertice("v0"); graph.addvertice("v1"); graph.addvertice("v2"); graph.addvertice("v3"); graph.addvertice("v4"); graph.addvertice("v5"); graph.addedge(0,1); graph.addedge(1,2); graph.addedge(1,3); graph.addedge(1,4); graph.addedge(4,5); graph.addedge(2,5); graph.addedge(3,5); graph.showdata(); System.out.println("\nDFS >>> "); graph.clearvisitedmarkers(); graph.dfs(0); System.out.println("\nBFS >>> "); graph.clearvisitedmarkers(); graph.bfs(0); 31

32 BFS & DFS Programming Exercise public class Graph <E> { private ArrayList<E> vertices; private ArrayList< ArrayList<Integer> > neighbors; private ArrayList<Boolean> visitedmarkers; public Graph() { vertices = new ArrayList<E>(); neighbors = new ArrayList < ArrayList<Integer> >(); visitedmarkers = new ArrayList<Boolean>(); public void addvertice(e newvertice){ vertices.add(newvertice); visitedmarkers.add(false); neighbors.add(new ArrayList<Integer>() ); public void addedge( int v1, int v2){ ArrayList<Integer> adjacent1 = neighbors.get(v1); if (!adjacent1.contains(v2)) neighbors.get(v1).add(v2); ArrayList<Integer> adjacent2 = neighbors.get(v2); if (!adjacent2.contains(v1)) neighbors.get(v2).add(v1); 32

33 BFS & DFS Programming Exercise public void markverticeasvisited(int v){ visitedmarkers.set(v, true); public void clearvisitedmarkers(){ for(int i=0; i<vertices.size(); i++){ visitedmarkers.set(i, false); public void showdata() { for (int i=0; i<vertices.size(); i++){ System.out.printf("\nVertice[%d]= %s", i, vertices.get(i)); for (int i=0; i < vertices.size(); i++){ System.out.printf("\nneighbors[%d]: ", i); ArrayList<Integer> adjacent = neighbors.get(i); //showdata for (int j=0; j<adjacent.size(); j++){ System.out.printf(" %d,", adjacent.get(j) ); 33

34 BFS & DFS Programming Exercise public void dfs(int v) { visitedmarkers.set(v, true); for(int n : neighbors.get(v)){ if (!visitedmarkers.get(n)){ System.out.printf("[v%d-v%d] ", v, n); dfs(n); //dfs 34

35 BFS & DFS Programming Excersice public void bfs(int v){ ArrayList<Integer> queue = new ArrayList<Integer>(); clearvisitedmarkers(); visitedmarkers.set(v, true); System.out.printf("BFS >>> starting at: v%d \n", v); queue.add(v); while(queue.size() > 0){ int currentdequeuedvertice = queue.remove(0); ArrayList<Integer> adjacents = neighbors.get(currentdequeuedvertice); for(int i=0; i<adjacents.size(); i++){ int adjacentnode = adjacents.get(i); if (!visitedmarkers.get(adjacentnode)){ System.out.printf("[v%d-v%d] ", currentdequeuedvertice, adjacentnode); queue.add(adjacentnode); visitedmarkers.set(adjacentnode, true); //if 35 //bfs //while //for

36 Case: The Nine Tail Problem 1. Nine coins are placed in a three by three matrix with some face up and some face down. 2. A legal move is to take any coin that is face up and reverse it, together with the coins adjacent to it (this does not include coins that are diagonally adjacent). 3. Your task is to find the minimum number of the moves that lead to all coins face down. H H H T T T H H H H H H T H T T T T T T T T T T T T T 36

37 Case: The Nine Tail Problem 37 H H H T T T H H H H H H T H T T T T T T T T T T T T T

38 Finding Eulerian Paths An Eulerian path traverses each edge of a connected graph G exactly once. It exists only if there are no more than two odd nodes. 1. Pick an odd vertex to start. 2. From that vertex move to a node using an unvisited edge. 3. Mark that edge as visited (see note) 4. Try to repeat 2-4 until all edges have been traversed Note: DFS algorithm marks nodes as visited. More than two odd nodes no Euler Path

39 The Hamiltonian Path Problem Def. A Hamiltonian path in a graph is a path that visits each vertex in the graph exactly once. Def. A Hamiltonian cycle is a cycle that visits each vertex in the graph exactly once and returns to the starting vertex. Notes: Problem is NP-Complete Many applications such as: Scheduling the Traveling Salesman Itinerary. 39