Efficient algorithm for the vertex connectivity of trapezoid graphs

# Efficient algorithm for the vertex connectivity of trapezoid graphs

Aleksandar Ilić 33footnotemark: 3
Faculty of Sciences and Mathematics, Višegradska 33, 18000 Niš, Serbia
e-mail: aleksandari@gmail.com
###### Abstract

The intersection graph of a collection of trapezoids with corner points lying on two parallel lines is called a trapezoid graph. These graphs and their generalizations were applied in various fields, including modeling channel routing problems in VLSI design and identifying the optimal chain of non-overlapping fragments in bioinformatics. Using modified binary indexed tree data structure, we design an algorithm for calculating the vertex connectivity of trapezoid graph with time complexity , where is the number of trapezoids. Furthermore, we establish sufficient and necessary condition for a trapezoid graph to be bipartite and characterize trees that can be represented as trapezoid graphs.

Keywords: trapezoid graphs; vertex connectivity; algorithms; binary indexed tree.

AMS Classifications: 05C85, 68R10, 05C40.

## 1 Introduction

A trapezoid diagram consists of two horizontal lines and a set of trapezoids with corner points lying on these two lines. A graph is a trapezoid graph when a trapezoid diagram exists with trapezoid set , such that each vertex corresponds to a trapezoid and an edge exists if and only if trapezoids and intersect within the trapezoid diagram. A trapezoid between these lines has four corner points , , and – which represent the upper left, upper right, lower left and lower right corner points of trapezoid , respectively. No two trapezoids share a common endpoint (see Figure 1).

Trapezoid graphs were first investigated by Corneil and Kamula [6]. These graphs and their generalizations were applied in various fields, including modeling channel routing problems in VLSI design [8] and identifying the optimal chain of non-overlapping fragments in bioinformatics [1]. Given some labeled terminals on the upper and lower side of a two-sided channel, terminals with the same label will be connected in a common net. Each net can be modeled by a trapezoid that connects rightmost and leftmost terminals of that net on two horizontal lines. In the channel routing problem we want to connect all terminals of each net so that no two nets intersect. One can show [8] that two nets can be routed without intersection in the same layer if and only if their corresponding trapezoids do not intersect. Therefore, the number of colors needed to color the trapezoid graph is the number of layers needed to route the nets without intersection.

Let and denote the number of vertices and edges of a trapezoid graph . Ma and Spinrad [22] showed that trapezoid graphs can be recognized in time, while Mertzios and Corneil [23] designed structural trapezoid recognition algorithm based on the vertex splitting method in time, which is easier for implementation. Trapezoid graphs are perfect, subclass of cocomparability graphs and properly contain both interval graphs and permutation graphs. If and then the corresponding trapezoid reduces to a straight line, and the trapezoid graph reduces to a permutation graph if the condition holds for all . Similarly, the trapezoid graph reduces to the interval graph if and for all .

Many common graph problems, such as minimum connected dominating sets [25], all-pair shortest paths [24], maximum weighted cliques [2], all cut vertices [13], chromatic number and clique cover [10], all hinge vertices [3] in trapezoid graphs, can be solved in polynomial time. For other related problems see [4, 7, 17, 18]. Recently, Lin and Chen [19] presented algorithms for counting the number of vertex covers (VC), minimal VCs, minimum VCs and maximum minimal VCs in a trapezoid graph. Ilić and Ilić [14] improved algorithms for calculating the size and the number of minimum vertex covers (or independent sets), as well as the total number of vertex covers, and reduce the time complexity to . Ghosh and Pal [11] presented an efficient algorithm to find the maximum matching in trapezoid graphs, which turns out to be not correct [14].

Let be a simple undirected graph with . A vertex cut or separating set of a connected graph is a set of vertices whose removal disconnects . The connectivity or vertex connectivity (where is not complete) is the size of a smallest vertex cut. A graph is called –connected or –vertex–connected if its vertex connectivity is greater than or equal to . A complete graph with vertices, denoted by , has no vertex cuts, but by convention . A connected graph is said to be separable if its vertex connectivity is one. In that case, a vertex which disconnects the graph is called a cut-vertex or an articulation point.

The edge cut of is a group of edges whose total removal disconnects the graph. The edge–connectivity is the size of a smallest edge cut. In the simple case in which cutting a single edge would disconnect the graph, that edge is called a bridge. Let be minimum vertex degree of , then

 κ(G)≤λ(G)≤δ(G).

Since the strength of the network is proportional to , graph connectivity is one of the most fundamental problem in graph theory. Even and Tarjan [9] have obtained time sequential algorithm for finding vertex connectivity of a general graph. The authors in [21] obtained parallel algorithm for testing –vertex connectivity in interval graphs. Ghosh and Pal in [12] presented rather complicated algorithm with a lot of different cases to solve the vertex connectivity problem, which takes time and space for a trapezoid graph. In this paper, we designed an algorithm with time complexity for calculating the vertex connectivity of a trapezoid graph.

The rest of the paper is organized as follows. In Section 2 we introduce the modified binary indexed tree data structure. In Section 3 we design time algorithm for calculating the vertex connectivity of trapezoid graphs, improving the algorithm from [12]. In Section 4 we establish sufficient and necessary condition for a trapezoid graph to be bipartite and characterize trees that can be represented as trapezoid graphs. We close the paper in Section 5 by proposing topics for the further research.

## 2 Modified binary indexed data structure

The binary indexed tree (BIT) is an efficient data structure for maintaining the cumulative frequencies. We will modify this standard structure to work with minimal/maximal partial summations.

Let be an array of elements. The modified binary indexed tree (MBIT) supports the following basic operations:

1. for given value and index , add to the element , ;

2. for given interval , find the sum of values , .

3. for given interval , find the minimum value among partial sums , .

Naive implementation of these operations have complexities , and , respectively. We can achieve better complexity, if we speed up the second and third operation which will also affect the first operation.

The main idea of the modified binary indexed tree structure is that sum of elements from the segment can be represented as sum of appropriate set of subsegments. The MBIT structure is based on decomposition of the cumulative sums into segments and the operations to access this data structure are based on the binary representation of the index. This way the time complexity for all operations will be the same .

The structure is a complete binary tree with the root node 1. Its leafs correspond to the elements from the array , starting from left to right in the last level. Therefore, the elements of the array are stored at the positions starting from to , where is the depth of the binary tree (defined as the smallest integer such that ). The internal nodes store the cumulative values of the leafs in the subtrees rooted at these nodes. This implies that the value of the internal node is just the cumulative value of its two children. The parent of the node is , while the left and the right child of the node are and , respectively. By definition, it follows that the number of nodes in MBIT is at most , while the depth is .

In addition to the values of the array , for each node we will keep two information: will be the sum of the values of all nodes in ’s subtree, and will be the minimum possible cumulative sum of ’s in the subtree rooted at (starting at the leftmost node in the subtree). We will demonstrate how to compute these fields using only information at each node and its children. The sum of the ’s of the subtree rooted at node will simply be

 sum[x]=sum[2x]+sum[2x+1].

The minimum cumulative sum can either be in the left subtree or in the right subtree. If it is in the left subtree, it is simply , while if it is in the right subtree, we have to add the cumulative sum up till the right subtree to the minimum value of the right subtree . Finally, we get

 min_sum[x]=min(min_sum[2x],sum[2x]+min_sum[2x+1]).

For the update procedure, we just need to traverse the vertices from the leaf to the root and update the values in the parent vertices based on the above formulas. For the query procedure, we traverse the binary tree in a top-down manner starting from the root vertex . The important thing it to maintain the partial sums of the array (starting from ). If the leaf that stores belongs to the left child – we just go left and do nothing; otherwise we update the partial sum of the left subtree and the index, and go right.

For detailed implementation see Algorithms 1 and 2. The structure is space-efficient in the sense that it needs the same amount of storage as just a simple array of elements. Furthermore we can use fast bitwise operations (xor, and, shift left) for more efficient implementation.

###### Theorem 1

Calculating the sum of the elements from to , calculating the minimum value among partial sums , and updating the element in the modified binary indexed tree is performed in time, .

This approach is very similar to the problem regarding calculating the point of maximum overlap among intervals (see [5] Problem 14-1), that can be solved using red-black trees.

###### Example 2

Let and . The elements of the array will be stored on positions to and to . The node 5 will contain the following information

 sum[5]=sum[20]+sum[21]+sum[22]+sum[23]=A[5]+A[6]+A[7]+A[8]
 min_sum[5]=min(A[5],A[5]+A[6],A[5]+A[6]+A[7],A[5]+A[6]+A[7]+A[8]).

If we change the value , we will start from the corresponding index and change the following nodes of the modified binary index tree: 21, 10, 5, 2 and 1. If we want to calculate the minimum among partial sums with elements , we calculate the following minimum

 min(min_sum[2],sum[2]+min_sum[6],sum[2]+sum[6]+min_sum[28]).

## 3 The algorithm for the vertex connectivity

Let denote the set of trapezoids in the trapezoid graph . For simplicity, the trapezoid in that corresponds to vertex in is called trapezoid . Without loss of generality, the points on each horizontal line of the trapezoid diagram are labeled with distinct integers between and .

Trapezoid lies entirely to the left of trapezoid , denoted by , if and . It follows that is a partial order over the trapezoid set and is a strictly partially ordered set.

###### Lemma 3

[12] Two vertices and of a trapezoid graph are not adjacent iff either () and or () and .

Define a cut line as line that passes through the intervals and on the upper and the bottom horizontal line, respectively, and does not contain the integer points . For a such cut, let be the number of trapezoids that have common points with the line . Define if there are no trapezoids completely left and no trapezoids completely right of the line .

###### Lemma 4

Let be a trapezoid graph. Then

 κ(G)=min1≤x≤2n, 1≤y≤2nN(x,y).

Proof. Let be a vertex cut of the graph with the minimum cardinality . The removal of disconnects , and consider the component that contains a trapezoid with the smallest upper left corner . Let be the maximum value among upper right corners in the component , , and let be the maximum value among lower right corners in the component , . Since the right border of trapezoids from form concave broken line – the line that passes through intervals and is one cut of a trapezoid graph. It follows that . The other inequality follows immediately, and this completes the proof.

Note that in the above theorem the points and , as well as and , can be excluded from the consideration.

Therefore, one can traverse all values and and compute the number of trapezoids that have non-empty intersection with the line determined by the intervals and . The important thing is to ensure that there are trapezoids lying entirely to the left and to the right of the line . This can be easily done in .

We will first precompute the leftmost and the rightmost trapezoids for each interval from the upper line. Let be the index of a trapezoid with and minimal lower right corner . Similarly let be the index of a trapezoid with and maximal lower left corner . If there are no such trapezoids, set the values of and to . We need additional arrays and , such that contains the index of the trapezoid with the left or right coordinate equal to on the upper line, and similarly for the bottom line. This can be done in linear time as shown in Algorithm 3 (implementation for the array is similar and, thus, omitted).

We will traverse the coordinates on the upper line from to , and skip the values with or . For each value between and , we need to calculate the number of trapezoids that cut the line . The trapezoid cuts the line if

• it contains the interval ;

• it is left trapezoid with the lower right corner greater than , i. e. if and ;

• it is right trapezoid with the lower left corner less than or equal to , i. e. if and .

Furthermore, we will maintain the binary array of length that indicates whether the trapezoid contains the interval . In other words, if and only if . Since no two trapezoids have a common corner, we can update this array in the constant time by traversing from to . Therefore, for each trapezoid with we easily check whether this trapezoid is on the left of or on the right of . We can also keep the number of left and right trapezoids in the variables and (see Algorithm 5).

In order to calculate the minimum value for the fixed coordinate, we will traverse coordinates, and count the number of trapezoids with that intersect the line . The idea is to calculate the cumulative sum by adding for each coordinate of right trapezoids and by adding for each coordinate of left trapezoids. The starting value of the cumulative sum is . The number is equal to the number of trapezoids that contain the interval plus the cumulative sum. The pseudo-code of this approach is given in Algorithm 4.

###### Example 5

The vertex connectivity of the graph in Figure 1 is two. For , we have the following parameters , , and for and . The execution of Algorithm 4 is presented in Table 1.

From the above table, we conclude that the minimum value of cumulative sums from to equals 1 and it is achieved for . This shows that the vertex connectivity of is less than or equal to .

For the efficient implementation, we will use the modified binary indexed tree data structure. The array will correspond to the lower coordinates from to . For each trapezoid with , assign and if is a left trapezoid, and assign and if is a right trapezoid. In order to find the minimum value of for , we can just return . The only problem is to ensure that there is at least one left trapezoid for each unit interval . We can solve this by setting for the value and taking this into account when calculating the minimum values. The number is big enough and all partial sums before the index will be greater than (we update the vertex connectivity only if is less than or equal to ). At the end we need to handle the special case – when is a complete graph. The pseudo-code of this algorithm is presented below.

Since every trapezoid will be added and removed exactly once from the modified binary indexed tree data structure, the total time complexity is . This modified data structure with variable left ends is a novel approach to the best of our knowledge and makes this problem very interesting.

We conclude this section by summing the results in the following theorem.

###### Theorem 6

The proposed algorithm calculates the vertex connectivity of a trapezoid graph with vertices in time and space .

## 4 Bipartiteness criteria and tree representation

In this section we establish local test for bipartiteness of trapezoid graphs.

###### Theorem 7

The trapezoid graph is bipartite if and only if it does not contain a triangle.

Proof. The first part directly follows from the well-known result: the graph is bipartite if and only if it does not contain odd cycles.

Let be a triangle-free trapezoid graph and let be the smallest odd cycle contained in with . It can be easily seen that there are no chords in , i. e. there are no edges of the form with (otherwise we could find smaller odd cycle). Consider the intersection of the trapezoids and . If their intersection is a trapezoid with height equal to the distance of two parallel lines (see the first part of Figure 2), then all trapezoids must be on the right side of – which is impossible, since must have common points with . Otherwise, the trapezoids and have intersection as shown in the second part of Figure 2. Without loss of generality we can assume that the trapezoids and are independent and positioned as shown in the figure. In order to connect the trapezoids and by a path of trapezoids – some trapezoids of this path must intersect either or , which is impossible.

Therefore, the graph does not contain cycles of odd length and it follows that is bipartite.

Note that from the above proof it follows that each cycle of length greater than four contains a chord (an edge joining two nodes that are not adjacent in the cycle).

A caterpillar graph is a tree such that if all pendent vertices and their incident edges are removed, the remainder of the graph forms a path. Let be a caterpillar with vertices obtained from a path by attaching pendent vertices to the vertex , , where . It can be easily seen that each caterpillar has trapezoid representation as triangle-free interval graph [15].

Assume now that tree is not a caterpillar and has trapezoid representation. Then it contains a vertex with neighbors , such that each vertex has another neighbor different than , . The trapezoids , and corresponding to the vertices , and are independent. Without loss of generality we can assume the order . Since all trapezoids , and intersect the trapezoid , it can be easily seen that all neighbors of (trapezoid in particular) also must intersect . This is a contradiction, and does not have trapezoid representation. Therefore, we proved the following

###### Theorem 8

A trapezoid graph represents a tree if and only if it is a caterpillar.

## 5 Concluding remarks

In this paper we presented an efficient algorithm for calculating the vertex connectivity number of a trapezoid graph. We leave as an open problem to design efficient algorithm for finding the edge connectivity number in trapezoid graphs.

The –trapezoid graphs are an extension of trapezoid graphs to higher dimension orders. The –dimensional box representation of a graph consists of mappings and such that is the lower and the upper corner of a box where two vertices of the graph are joined by an edge iff their corresponding boxes are incomparable [10]. If a graph has such a representation, it is a –trapezoid graph. If we additionally have a weight on the vertices of then the –trapezoid graph is weighted. For the case , we have simple trapezoid graphs.

Another generalization are circular trapezoid graphs – the intersection graphs of circular trapezoids between two parallel (concentric) circles [20]. It seems that the presented approach can be modified and adapted for calculating the vertex connectivity number of –trapezoid graphs and circular trapezoid graphs.

Acknowledgement. This work was supported by Research Grants 174010 and 174033 of Serbian Ministry of Education and Science.

## References

• [1] M. I. Abouelhoda, E. Ohlebusch, Chaining algorithms for multiple genome comparison, J. Discrete Algorithms 3 (2005) 321–341.
• [2] D. Bera, M. Pal, T. K. Pal, An efficient algorithm to generate all maximal cliques on trapezoid graphs, Int. J. Comput. Math. 79 (2002) 1057–1065.
• [3] D. Bera, M. Pal, T. K. Pal, An Efficient Algorithm for Finding All Hinge Vertices on Trapezoid Graphs, Theory Comput. Systems 36 (2003) 17–27.
• [4] F. Cheah, D. G. Corneil, On the structure of trapezoid graphs, Discrete Appl. Math. 66 (1996) 109–133.
• [5] T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein, Introduction to Algorithms, Second Edition, MIT Press, 2001.
• [6] D. G. Corneil, P. A. Kamula, Extensions of permutation and interval graphs, In: Proceedings of 18th Southeastern Conference on Combinatorics, Graph Theory and Computing, 1987, 267–275.
• [7] C. Crespelle, P. Gambette, Unrestricted and complete Breadth First Search of trapezoid graphs in time, Inform. Process. Lett. 110 (2010) 497–502.
• [8] I. Dagan, M. C. Golumbic, R. Y. Pinter, Trapezoid graphs and their coloring, Discrete Appl. Math. 21 (1988) 35–46.
• [9] S. Even, R. E. Tarjan, Network flow and testing graph connectivity, Inform. Process. Lett. 4 (1975) 507–518.
• [10] S. Felsner, R. Müller, L. Wernisch, Trapezoid graphs and generalizations, geometry and algorithms, Discrete Appl. Math. 74 (1997) 13–32.
• [11] P. K. Ghosh, M. Pal, An efficient algorithm to find the maximum matching on trapezoid graphs, J. Korean Soc. Ind. Appl. Math. IT Series 9 (2) (2005) 13–20.
• [12] P. K. Ghosh, M. Pal, An efficient algorithm to solve connectivity problem on trapezoid graphs, J. Appl. Math. & Computing 24 (2007) 141–154.
• [13] M. Hota, M. Pal, T. K. Pal, Optimal sequential and parallel algorithms to compute all cut vertices on trapezoid graphs, Comput. Optim. Appl. 27 (1) (2004) 95–113.
• [14] A. Ilić, A. Ilić, On vertex covers and matching number of trapezoid graphs, (2011), submitted.
• [15] E. Jürgen, Extremal interval graphs, J. Graph Theory 17 (1993) 117–127.
• [16] R. M. Karp, Reducibility among combinatorial problems, In: R. E. Miller, J. W. Thatcher (Eds.), Complexity of Computer Computation, Plenum Press, New York, 1972, 85–103.
• [17] Y. D. Liang, Domination in trapezoid graphs, Inform. Process. Lett. 52 (1994) 309–315.
• [18] Y. D. Liang, Steiner set and connected domination in trapezoid graphs, Inform. Process. Lett. 56 (1995) 101–108.
• [19] M. S. Lin, Y. J. Chen, Counting the number of vertex covers in trapezoid graph, Inform. Process. Lett. 109 (2009) 1187–1192.
• [20] Y. L. Lin, Circular and circle trapezoid graphs, J. Sci. Eng. Tech. 2 (2006) 11–17.
• [21] T. W. Kao, S. J. Horng, Computing -Vertex Connectivity on an Interval Graph, International Conference on Parallel Processing ICPP’94, Vol. 3 (1994) 218–221.
• [22] T. H. Ma, J. P. Spinrad, On the 2-chain subgraph cover and related problems, J. Algorithms 17 (1994) 251–268.
• [23] G. B. Mertzios, D. G. Corneil, Vertex splitting and the recognition of trapezoid graphs, Technical Report AIB-2009-16, RWTH Aachen University, 2009.
• [24] S. Mondal, M. Pal, T. K. Pal, An optimal algorithm for solving all-pairs shortest paths on trapezoid graphs, Int. J. Comput. Eng. Sci. (IJCES) 3 (2002) 103–116.
• [25] Y. T. Tsai, Y. L. Lin, F. R. Hsu, Efficient algorithms for the minimum connected domination on trapezoid graphs, Inform. Sci. 177 (2007) 2405–2417.
You are adding the first comment!
How to quickly get a good reply:
• Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
• Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
• Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters