(5/5)

- Write a C program that uses the “pebble game” technique to test if an input graph is
*minimally rigid*(in two dimensions). The first line of the input will be*n*, the number of vertices.*n*will not exceed 100. Each of the remaining 2*n*– 3 lines will contain two values in the range 0 . . .*n*– 1 to designate an undirected edge. (Self-loops and parallel edges will not be included.) Each input line should be echoed to the output before being processed. The last line of your output should be either 1) an indication that the graph is minimally rigid (“Laman”) or 2) an indication that the last edge processed is “redundant” along with the set of vertices giving the rigid subgraph for the redundant - If a pebble is moved, you should output the vertices on the pebble’s
- Submit your C program on Canvas 10:45 am (section 004) or 1:45 pm (section 003) on December 3. Comments at the beginning of the source file should include: your name, your ID number, and the command used to compile your code on Omega (5 point penalty for non-compliance).

- The input is easily read by using scanf(). Do not prompt for a file name!
- The following bar-and-joint system has
*n*= 6 vertices, 2*n*– 3 = 9 edges, and is initialized with two pebbles at each vertex: - The first rule of the pebble game changes an undirected edge between vertices
*x*and*y*to a directed edge from*x*to*y*. Before applying this rule, both vertices must have two pebbles. After applying this rule,*x*will have just one pebble and*y*will still have two - The second rule allows a pebble to be moved against the direction of a path. i.e. the path
- To analyze rigidity, the two rules may be applied in any order with the goal of making all edges
- The following characterizations of Laman give an algorithmically expensive way of testing rigidity:

*The edges of a graph G *= (*V*, *E*) *are independent (non-redundant) in two dimensions if and only if no subgraph G*´ = (*V*´,

*E*´) *(with n*´ *vertices) has more than 2n*´ *- 3 edges.*

*(Corollary) A graph with 2n - 3 edges is rigid in two dimensions if and only if no subgraph G´ (with n*´ *vertices) has more than 2n´ - 3 edges.*

- Jacobs and Hendrickson further developed the “pebble game” technique to test rigidity in O⎛⎜
*n*2⎞⎟ time:

Place two pebbles at each vertex. for each input edge {x y}

Attempt to get two pebbles (four total) at vertices x and y. This may be done using BFS (or DFS) to find a directed path to a vertex (other than x or y) with a pebble. After

the vertex is found, the path must be reversed. if four pebbles are achieved

Use one pebble on x to record the directed edge x ® y. else

// Only three pebbles were achieved for {x y}.

{x y} is a redundant edge.

The vertices reached during the last search induce a rigid subgraph. exit(0)

// All edges have been directed . . . Graph is minimally rigid

8.Due to the limited number of edges (2*n *- 3) and the characteristics of the pebble game, only a simple table is needed to store the pebbling status. Other data structures will be needed to support the graph search technique that you choose

9.Your solution must take O⎛⎜*n*2⎞⎟ time, so no adjacency matrices.

10.Inputs a.dat and lab5fall19.c.dat are minimally rigid. Inputs lab5fall19.b.dat and

lab5fall19.d.dat are not.

(5/5)

DescriptionIn this final assignment, the students will demonstrate their ability to apply two majorconstructs of the C programming language – Fu

Path finding involves finding a path from A to B. Typically we want the path to have certain properties,such as being the shortest or to avoid going t

Develop a program to emulate a purchase transaction at a retail store. Thisprogram will have two classes, a LineItem class and a Transaction class. Th

1 Project 1 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of

1 Project 2 Introduction - the SeaPort Project series For this set of projects for the course, we wish to simulate some of the aspects of a number of