{'fraction_non_alphanumeric': 0.08779761904761904, 'fraction_numerical': 0.0248015873015873, 'mean_word_length': 4.10632911392405, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Fast Constructions of Light-Weight Spanners for General Graphs

Since the pioneering works of Peleg and Schaffer [32], Althofer et al. [4], and Chandra et al. [13], it is known that for every weighted undirected n-vertex m-edge graph G = (V,E), and every integer k ≥ 1, there exists a ((2k − 1) · (1 + e))-spanner with O(n1+1/k) edges and weight O(k · n1/k) · ω(MST(G)), for an arbitrarily small constant e > 0. (Here ω(MST(G)) stands for the weight of the minimum spanning tree of G.) Nearly linear time algorithms for constructing (2k − 1)-spanners with nearly O(n1+1/k) edges were devised in [11, 38, 37]. However, these algorithms fail to guarantee any meaningful upper bound on the weight of the constructed spanners. 
 
To our knowledge, there are only two known algorithms for constructing sparse and light spanners for general graphs. One of them is the greedy algorithm of Althofer et al. [4], analyzed by Chandra et al. [13]. The drawback of the greedy algorithm is that it requires O(m · (n1+1/k + n · log n)) time. The other algorithm is due to Awerbuch et al. [7], from 1991. It constructs O(k)-spanners with O(k · n1+1/k · Λ) edges, weight O(k2 · n1/k · Λ) · ω(MST(G)), within time O(m · k · n1/k · Λ), where Λ is the logarithm of the aspect ratio of the graph. 
 
The running time of both these algorithms is unsatisfactory. Moreover, the usually faster algorithm of [7] pays for the speedup by significantly increasing both the stretch, the sparsity, and the weight of the resulting spanner. 
 
In this paper we devise an efficient algorithm for constructing sparse and light spanners. Specifically, our algorithm constructs ((2k−1)·(1+e))-spanners with O(k·n1+1/k) edges and weight O(k · n1/k) · ω(MST(G)), where e > 0 is an arbitrarily small constant. The running time of our algorithm is O(k · m + min{n · log n, m · α(n)}). Moreover, by slightly increasing the running time we can reduce the other parameters. These results address an open problem from the ESA'04 paper by Roditty and Zwick [38].