Edge Insertions Research Articles

Dynamic Graph Coloring

In this paper we study the number of vertex recolorings that an algorithm needs to perform in order to maintain a proper coloring of a graph under insertion and deletion of vertices and edges. We present two algorithms that achieve different trade-offs between the number of recolorings and the number of colors used. For any d>0, the first algorithm maintains a proper O(mathcal {C} dN ^{1/d})-coloring while recoloring at most O(d) vertices per update, where mathcal {C} and N are the maximum chromatic number and maximum number of vertices, respectively. The second algorithm reverses the trade-off, maintaining an O(mathcal {C} d)-coloring with O(dN ^{1/d}) recolorings per update. The two converge when d = log N , maintaining an O(mathcal {C} log N)-coloring with O(log N) recolorings per update. We also present a lower bound, showing that any algorithm that maintains a c-coloring of a 2-colorable graph on N vertices must recolor at least varOmega (N ^frac{2}{c(c-1)}) vertices per update, for any constant c ge 2.

Minimum weight connectivity augmentation for planar straight-line graphs

We consider edge insertion and deletion operations that increase the connectivity of a given planar straight-line graph (PSLG), while minimizing the total edge length of the output. We show that every connected PSLG G=(V,E) in general position can be augmented to a 2-connected PSLG (V,E∪E+) by adding new edges of total Euclidean length ‖E+‖<2‖E‖, and this bound is the best possible. An optimal edge set E+ can be computed in O(|V|4) time; however the problem becomes NP-hard when G is disconnected. Further, we show that there is a sequence of edge insertions and deletions that transforms a connected PSLG G=(V,E) into a planar straight-line cycle G′=(V,E′) such that ‖E′‖≤2‖MST(V)‖, and the graph remains connected with edge length below ‖E‖+‖MST(V)‖ at all stages. These bounds are the best possible.

Incremental Exact Min-Cut in Polylogarithmic Amortized Update Time

We present a deterministic incremental algorithm for exactly maintaining the size of a minimum cut with O (log 3 n log log 2 n ) amortized time per edge insertion and O (1) query time. This result partially answers an open question posed by Thorup (2007). It also stays in sharp contrast to a polynomial conditional lower bound for the fully dynamic weighted minimum cut problem. Our algorithm is obtained by combining a sparsification technique of Kawarabayashi and Thorup (2015) or its recent improvement by Henzinger, Rao, and Wang (2017), and an exact incremental algorithm of Henzinger (1997). We also study space-efficient incremental algorithms for the minimum cut problem. Concretely, we show that there exists an O ( n log n /ε 2 ) space Monte Carlo algorithm that can process a stream of edge insertions starting from an empty graph, and with high probability, the algorithm maintains a (1+ε)-approximation to the minimum cut. The algorithm has O ((α ( n ) log 3 n )/ε 2 ) amortized update time and constant query time, where α ( n ) stands for the inverse of Ackermann function.

A parallel graph edit distance algorithm

Graph edit distance (GED) has emerged as a powerful and flexible graph matching paradigm that can be used to address different tasks in pattern recognition, machine learning, and data mining. GED is an error-tolerant graph matching problem which consists in minimizing the cost of the sequence that transforms a graph into another by means of edit operations. Edit operations are deletion, insertion and substitution of vertices and edges. Each vertex/edge operation has its associated cost defined in the vertex/edge cost function. Unfortunately, Unfortunately, the GED problem is NP-hard. The question of elaborating fast and precise algorithms is of first interest. In this paper, a parallel algorithm for exact GED computation is proposed. Our proposal is based on a branch-and-bound algorithm coupled with a load balancing strategy. Parallel threads run a branch-and-bound algorithm to explore the solution space and to discard misleading partial solutions. In the mean time, the load balancing scheme ensures that no thread remains idle. Experiments on 4 publicly available datasets empirically demonstrated that under time constraints our proposal can drastically improve a sequential approach and a naive parallel approach. Our proposal was compared to 6 other methods and provided more precise solutions while requiring a low memory usage.

Incremental Voronoi Diagrams

We study the amortized number of combinatorial changes (edge insertions and removals) needed to update the graph structure of the Voronoi diagram (and several variants thereof) of a set S of n sites in the plane as sites are added to the set. To that effect, we define a general update operation for planar graphs that can be used to model the incremental construction of several variants of Voronoi diagrams as well as the incremental construction of an intersection of halfspaces in \(\mathbb {R}^3\). We show that the amortized number of edge insertions and removals needed to add a new site to the Voronoi diagram is \(O(\sqrt{n})\). A matching \(\Omega (\sqrt{n})\) combinatorial lower bound is shown, even in the case where the graph representing the Voronoi diagram is a tree. This contrasts with the \(O(\log {n})\) upper bound of Aronov et al. (LATIN 2006: Theoretical Informatics. Lecture Notes in Computer Science, Springer, Berlin, 2006) for farthest-point Voronoi diagrams in the special case where the points are inserted in clockwise order along their convex hull. We then present a semi-dynamic data structure that maintains the Voronoi diagram of a set S of n sites in convex position. This data structure supports the insertion of a new site p (and hence the addition of its Voronoi cell) and finds the asymptotically minimal number K of edge insertions and removals needed to obtain the diagram of \(S \cup \{p\}\) from the diagram of S, in time \(O(K\,\mathrm {polylog}\ n)\) worst case, which is \(O(\sqrt{n}\;\mathrm {polylog}\ n)\) amortized by the aforementioned combinatorial result. The most distinctive feature of this data structure is that the graph of the Voronoi diagram is maintained explicitly at all times and can be retrieved and traversed in the natural way; this contrasts with other known data structures supporting nearest neighbor queries. Our data structure supports general search operations on the current Voronoi diagram, which can, for example, be used to perform point location queries in the cells of the current Voronoi diagram in \(O(\log n)\) time, or to determine whether two given sites are neighbors in the Delaunay triangulation.

Triple-Mode Ceramic Cavity Filters With Wide Spurious-Free Performance

A triple-mode silver-plated ceramic cavity filter with wide spurious-free response is presented. It uses single mode ceramic slabs as interfacing resonators with the cube to give wide spurious-free performance up to 4 GHz for an 1800-MHz base station filter. Three square apertures at the slab-cube interface give simple and flexible control of transmission zero placement while maintaining low insertion loss. The parallel nature of the slab-to-cube coupling allows a simple cuboid structure without chamfers or intermode coupling elements. A seven-pole filter in the DCS-1800 transmit band is built using a slab-slab-cube-slab-slab structure and measured. Along with wide spurious-free performance, the filter achieves around 1 dB of band edge insertion loss with more than 50 dB of attenuation, 20 MHz from the band edges, and from an 11-cm3 package. The near band performance shows all of the seven poles in the return loss. The insertion loss is 1.1 dB on the low side (1805 MHz), 1.0 dB on the high side (1880 MHz), and 0.6 dB at the band center. The wideband response shows more than 40 dB of attenuation up to the frequency 3.7 GHz.

Truss-based community search

We consider the community search problem defined upon a large graph G : given a query vertex q in G , to find as output all the densely connected subgraphs of G , each of which contains the query v . As an online, query-dependent variant of the well-known community detection problem, community search enables personalized community discovery that has found widely varying applications in real-world, large-scale graphs. In this paper, we study the community search problem in the truss-based model aimed at discovering all dense and cohesive k -truss communities to which the query vertex q belongs. We introduce a novel equivalence relation, k-truss equivalence , to model the intrinsic density and cohesiveness of edges in k -truss communities. Consequently, all the edges of G can be partitioned to a series of k -truss equivalence classes that constitute a space-efficient, truss-preserving index structure, EquiTruss. Community search can be henceforth addressed directly upon EquiTruss without repeated, time-demanding accesses to the original graph, G , which proves to be theoretically optimal. In addition, EquiTruss can be efficiently updated in a dynamic fashion when G evolves with edge insertion and deletion. Experimental studies in real-world, large-scale graphs validate the efficiency and effectiveness of EquiTruss, which has achieved at least an order of magnitude speedup in community search over the state-of-the-art method, TCP-Index.

TRIÈST

“Ogni lassada xe persa.” 1 -- Proverb from Trieste, Italy. We present trièst , a suite of one-pass streaming algorithms to compute unbiased, low-variance, high-quality approximations of the global and local (i.e., incident to each vertex) number of triangles in a fully dynamic graph represented as an adversarial stream of edge insertions and deletions. Our algorithms use reservoir sampling and its variants to exploit the user-specified memory space at all times. This is in contrast with previous approaches, which require hard-to-choose parameters (e.g., a fixed sampling probability) and offer no guarantees on the amount of memory they use. We analyze the variance of the estimations and show novel concentration bounds for these quantities. Our experimental results on very large graphs demonstrate that trièst outperforms state-of-the-art approaches in accuracy and exhibits a small update time.

Disk-based shortest path discovery using distance index over large dynamic graphs

The persistent alternation of the internet world is changing networks rapidly. Shortest path discovery, especially over dynamic networks such as web page links, telephone or route networks, and ontologies, has received intense attention because of its importance for services in IoT. For example, when a new road is newly opened or becomes unavailable for any unexpected reason, the shortest paths must be recomputed. The system should respond promptly to its users with the updated recommended paths. In this paper, we propose a disk-based shortest path method that updates the shortest paths in a very large dynamic graph efficiently. The proposed method uses partial shortest paths as indices for efficient shortest path discovery. We classify the changes in the graph into four cases, such as the insertion or deletion of edges and the increase or decrease of edge weights. Our proposed strategy considers updating only the corresponding parts of the indices for each case. Our experiments on real-world dynamic datasets verify that the proposed framework updates the shortest paths 4 to 50 times faster than the existing type of framework.

Adaptive Cluster Tendency Visualization and Anomaly Detection for Streaming Data

The growth in pervasive network infrastructure called the Internet of Things (IoT) enables a wide range of physical objects and environments to be monitored in fine spatial and temporal detail. The detailed, dynamic data that are collected in large quantities from sensor devices provide the basis for a variety of applications. Automatic interpretation of these evolving large data is required for timely detection of interesting events. This article develops and exemplifies two new relatives of the visual assessment of tendency (VAT) and improved visual assessment of tendency (iVAT) models, which uses cluster heat maps to visualize structure in static datasets. One new model is initialized with a static VAT/iVAT image, and then incrementally (hence inc-VAT/inc-iVAT) updates the current minimal spanning tree (MST) used by VAT with an efficient edge insertion scheme. Similarly, dec-VAT/dec-iVAT efficiently removes a node from the current VAT MST. A sequence of inc-iVAT/dec-iVAT images can be used for (visual) anomaly detection in evolving data streams and for sliding window based cluster assessment for time series data. The method is illustrated with four real datasets (three of them being smart city IoT data). The evaluation demonstrates the algorithms’ ability to successfully isolate anomalies and visualize changing cluster structure in the streaming data.

The emergence of “super-groups” in dynamical networks

We study a model for the generation of networks, where the number of nodes is constant and the edges are inserted into the network gradually based on non-liner preferential attachment. This model combines the ER random model with the BA scale-free networks, leading to a transition of degree distribution from homogeneity to heterogeneity. With the increase of a diversity parameter γ, the insertion of edges will give rise to some “super-groups” which are small groups of nodes with a large proportion of the edges in the network. This model has a huge application in the modelling and analyzing the emergence of “super-groups” in social, technological, and economical networks.

Nonbinary Quasi-Regular QC-LDPC Codes Derived From Cycle Codes

Nonbinary ultra sparse codes, particularly regular cycle codes, are known to approach Shannon-limit performance as the Galois field $ \mathrm {GF}(q)$ order is sufficiently large. Good cycle codes can result from a class of algebraically defined graphs called cages. Meanwhile, when smaller $q$ is desirable, the cycle codes are outperformed by quasi-regular codes. In this letter, we propose a code construction method that takes a cage as a starting point and then progressively inserts a few additional edges into the graph. The edge insertion is terminated as soon as the code performance stops improving. Our simulation results show that the obtained quasi-regular codes outperform cyclic codes for fields up to GF(64) and its performance is slightly better than the quasi-regular improved-Progressive Edge Growth-based codes. The proposed algorithm preserves the block-circulant structure of the initial cage-based graph; therefore, it can be used for structured or quasi-cyclic codes design.

Incremental Algorithm for Maintaining a DFS Tree for Undirected Graphs

Depth First Search (DFS) tree is a fundamental data structure for graphs used in solving various algorithmic problems. However, very few results are known for maintaining DFS tree in a dynamic environment--insertion or deletion of edges. We present the first algorithm for maintaining a DFS tree for an undirected graph under insertion of edges. For processing any arbitrary online sequence of edge insertions, this algorithm takes total $$O(n^2)$$O(n2) time.

A comparative study on the reliability of co-authorship networks with emphases on edges and nodes

A scientific co-authorship network may be modeled by a graph G composed of k nodes and m edges. Researchers that make up this network may be interpreted as its nodes and the link between these agents (co-authored papers) as its edges. Current work evaluated and compared the reliability measure of networks with two emphases: 1) On nodes (perfectly reliable edges) and 2) On edges (perfectly reliable nodes). Specifically, the reliability of a fictitious co-authorship network at a given time t was analyzed taking into account, first, the reliability of nodes (researchers) equal and different, and, second, the reliability of edges (co-authorship relations), equal and different. Additionally, centrality measures of nodes were obtained to identify situations where the insertion of an edge significantly increased the reliability of the network. Results showed that the reliability of the co-authorship network focusing on edges is more sensitive to changes in individual reliabilities than the reliability of the network focusing on nodes. Additionally, the use of centrality measures was viable to identify possible insertions of edges or co-authorship relations to increase the reliability of the network in the two approaches.

A tighter insertion-based approximation of the crossing number

Let G be a planar graph and F a set of additional edges not yet in G. The multiple edge insertion problem (MEI) asks for a drawing of $$G+F$$ with the minimum number of pairwise edge crossings, such that the subdrawing of G is plane. Finding an exact solution to MEI is NP-hard for general F. We present the first polynomial time algorithm for MEI that achieves an additive approximation guarantee—depending only on the size of F and the maximum degree of G, in the case of connected G. Our algorithm seems to be the first directly implementable one in that realm, too, next to the single edge insertion. It is also known that an (even approximate) solution to the MEI problem would approximate the crossing number of the F-almost-planar graph $$G+F$$ , while computing the crossing number of $$G+F$$ exactly is NP-hard already when $$|F|=1$$ . Hence our algorithm induces new, improved approximation bounds for the crossing number problem of F-almost-planar graphs, achieving constant-factor approximation for the large class of such graphs of bounded degrees and bounded size of F.

Dynamic Maintenance of a Shortest-Path Tree on Homogeneous Batches of Updates

A dynamic graph algorithm is called batch if it is able to update efficiently the solution of a given graph problem after multiple updates at a time (i.e., a batch) take place on the input graph. In this article, we study batch algorithms for maintaining a single-source shortest-path tree in graphs with positive real edge weights. In particular, we focus our attention on homogeneous batches, that is, either incremental (containing only edge insertion and weight decrease operations) or decremental (containing only edge deletion and weight increase operations) batches, which model realistic dynamic scenarios like transient vertex failures in communication networks and traffic congestion/decongestion phenomena in road networks. We propose two new algorithms to process either incremental or decremental batches, respectively, and a combination of these two algorithms that is able to process arbitrary sequences of incremental and decremental batches. All these algorithms are update sensitive ; namely, they are efficient with respect to the number of vertices in the shortest-path tree that change their parents and/or their distances from the source as a consequence of a batch. This makes unfeasible an effective comparison on a theoretical basis of our new algorithms with the solutions known in the literature, which in turn are analyzed with respect to others and different parameters. For this reason, in order to evaluate the quality of our approach, we provide also an extensive experimental study including our new algorithms and the most efficient previous batch algorithms. Our experimental results complement previous studies and show that the various solutions can be consistently ranked on the basis of the type of homogeneous batch and of the underlying network. As a result, our work can be helpful in selecting a proper solution depending on the specific application scenario.

Maintaining centdians in a fully dynamic forest with top trees

In this paper, we consider the problem of maintaining the centdians in a fully dynamic forest. A forest is said to be fully dynamic if edge insertions, edge deletions, and changes of vertex weights are allowed. Centdian is a specific kind of facility that integrates the notions of center and median by taking a convex combination on the objective functions of both problems. This work extends the results in Alstrup et al. [2] within the same time complexity, i.e., linear time preprocessing and O(logn) per update, where n is the number of vertices of the components being updated.

Efficient and Dynamic Algorithms for Alternating Büchi Games and Maximal End-Component Decomposition

The computation of the winning set for Büchi objectives in alternating games on graphs is a central problem in computer-aided verification with a large number of applications. The long-standing best known upper bound for solving the problem is Õ ( n · m ), where n is the number of vertices and m is the number of edges in the graph. We are the first to break the Õ ( n · m ) boundary by presenting a new technique that reduces the running time to O ( n 2 ). This bound also leads to O ( n 2 )-time algorithms for computing the set of almost-sure winning vertices for Büchi objectives (1) in alternating games with probabilistic transitions (improving an earlier bound of Õ ( n · m )), (2) in concurrent graph games with constant actions (improving an earlier bound of O ( n 3 )), and (3) in Markov decision processes (improving for m &gt; n 4/3 an earlier bound of O ( m · √ m )). We then show how to maintain the winning set for Büchi objectives in alternating games under a sequence of edge insertions or a sequence of edge deletions in O ( n ) amortized time per operation. Our algorithms are the first dynamic algorithms for this problem. We then consider another core graph theoretic problem in verification of probabilistic systems, namely computing the maximal end-component decomposition of a graph. We present two improved static algorithms for the maximal end-component decomposition problem. Our first algorithm is an O ( m · √ m )-time algorithm, and our second algorithm is an O ( n 2 )-time algorithm which is obtained using the same technique as for alternating Büchi games. Thus, we obtain an O (min {m · √ m , n 2 })-time algorithm improving the long-standing O ( n · m ) time bound. Finally, we show how to maintain the maximal end-component decomposition of a graph under a sequence of edge insertions or a sequence of edge deletions in O ( n ) amortized time per edge deletion, and O ( m ) worst-case time per edge insertion. Again, our algorithms are the first dynamic algorithms for this problem.

Incentive Based Data Sharing in Delay Tolerant Mobile Networks

Mobile wireless devices play important roles in our daily life, e.g., users often use such devices to take pictures and share with friends via opportunistic peer-to-peer links, which however are intermittent in nature, and hence require the store-and-forward feature proposed in Delay Tolerant Networks to provide useful data sharing opportunities. Moreover, mobile devices may not be willing to forward data items to other devices due to the limited resources. Hence, effective data dissemination schemes need to be designed to encourage nodes to collaboratively share data. We propose a Multi-Receiver Incentive-Based Dissemination (MuRIS) scheme that allows nodes to cooperatively deliver information of interest to one another via chosen paths utilizing few transmissions. Our scheme exploits local historical paths and users' interests information maintained by each node. In addition, the charge and rewarding functions incorporated within our scheme stimulate cooperation among nodes such that the nodes have no incentive to launch edge insertion attacks. Furthermore, our charge and rewarding functions are designed such that the chosen delivery paths mimic efficient multicast tree that results in fewer delivery hops. Extensive simulation studies using real human contact-based mobility traces show that our scheme outperforms existing methods in terms of delivery ratio and transmission efficiency.

Covering tree with stars

We study the tree edit distance (TED) problem with edge deletions and edge insertions as edit operations. We reformulate a special case of this problem as Covering Tree with Stars (CTS): given a tree T and a set $$\mathcal {S}$$ S of stars, can we connect the stars in $$\mathcal {S}$$ S by adding edges between them such that the resulting tree is isomorphic to T? We prove that in the general setting, CST is NP-complete, which implies that the TED considered here is also NP-hard, even when both input trees have diameters bounded by 10. We also show that, when the number of distinct stars is bounded by a constant k, CTS can be solved in polynomial time, by presenting a dynamic programming algorithm running in $$O(|V(T)|^2\cdot k\cdot |V(\mathcal{S})|^{2k})$$ O ( | V ( T ) | 2 · k · | V ( S ) | 2 k ) time.