The Internet Archive has a preservation copy of this work in our general collections.
The file type is `application/pdf`

.

## Filters

##
###
Perfect Matchings in O(n n) Time in Regular Bipartite Graphs
[article]

2010
*
arXiv
*
pre-print

*In*this paper we consider the well-studied problem of finding a perfect matching

*in*a

*d*-regular

*bipartite*graph on 2n nodes with m=nd

*edges*. ...

*In*a recent line of work by Goel, Kapralov and Khanna the

*O*(m)

*time*algorithm was improved first to

*Õ*(minm, n^2.5/

*d*) and then to

*Õ*(minm, n^2/

*d*). ... Remark 9 Our algorithm can be used to obtain a simple algorithm for

*edge*-

*coloring*

*bipartite*graphs with maximum degree

*d*

*in*

*time*

*O*(m

*log*n) (slightly worse than the best known

*O*(m

*log*

*d*) dependence obtained ...

##
###
Perfect matchings in o(nlogn) time in regular bipartite graphs

2010
*
Proceedings of the 42nd ACM symposium on Theory of computing - STOC '10
*

We also show that there does not exist a randomized algorithm that finds a matching

doi:10.1145/1806689.1806697
dblp:conf/stoc/GoelKK10
fatcat:wx4wlsgsmvhxliw7otjsezac54
*in*a regular*bipartite**multigraph*and takes*o*(n*log*n)*time*with high probability. ...*In*this paper we consider the well-studied problem of finding a perfect matching*in*a*d*-regular*bipartite*graph on 2n nodes with m = nd*edges*. ... Our algorithm can be used to obtain a simple algorithm for*edge*-*coloring**bipartite*graphs with maximum degree*d**in**time**O*(m*log*n) (slightly worse than the best known*O*(m*log**d*) dependence obtained*in*...##
###
Perfect Matchings in $O(n\log n)$ Time in Regular Bipartite Graphs

2013
*
SIAM journal on computing (Print)
*

We also show that there does not exist a randomized algorithm that finds a matching

doi:10.1137/100812513
fatcat:2fsrhiuj4jgptou63nhqonxqs4
*in*a regular*bipartite**multigraph*and takes*o*(n*log*n)*time*with high probability. ...*In*this paper we consider the well-studied problem of finding a perfect matching*in*a*d*-regular*bipartite*graph on 2n nodes with m = nd*edges*. ... Our algorithm can be used to obtain a simple algorithm for*edge*-*coloring**bipartite*graphs with maximum degree*d**in**time**O*(m*log*n) (slightly worse than the best known*O*(m*log**d*) dependence obtained*in*...##
###
Node-based scheduling with provable evacuation time

2015
*
2015 49th Annual Conference on Information Sciences and Systems (CISS)
*

*In*this setting, the minimum evacuation

*time*problem is equivalent to the classic

*multigraph*

*edge*

*coloring*problem, which is generally NP-hard. ... Instead, it is desirable to compute the schedules (or the

*colors*)

*in*an online fashion, i.e., to quickly compute one schedule at a

*time*. ... ACKNOWLEDGMENT This work was supported

*in*part by the NSF under Grants CNS-1449860, CNS-1065444, and ECCS-1231461. ...

##
###
Another Simple Algorithm for Edge-Coloring Bipartite Graphs

2005
*
IEICE Transactions on Fundamentals of Electronics Communications and Computer Sciences
*

with m

doi:10.1093/ietfec/e88-a.5.1303
fatcat:h5bdlai65bgbjixkw4a2ibizjq
*edges*and maximum degree*d**in**O*(m*log**d*+ (m/*d*)*log*(m/*d*))*time*. ... This algorithm, based on the framework of the*O*(m*log**d*+ (m/*d*)*log*(m/*d*)*log**d*) algorithm by Makino-Takabatake-Fujishige and the*O*(m*log*m) one by Alon, finds an optimal*edge*-*coloring*of a*bipartite*graph ...*Edge*-Sparsification*in*Step 4 costs*O*((n*log**d*)*log*2 2d ) =*O*(m*log**d*)*time*, since H is an xd-regular*bipartite**multigraph*with*O*(n*log**d*) distinct*edges*. Step 5 costs*O*(n)*time*. ...##
###
Finding the KT partition of a weighted graph in near-linear time
[article]

2021
*
arXiv
*
pre-print

We give a

arXiv:2111.01378v1
fatcat:w3basxih7vactpikdrcwtuqdy4
*O*(m*log*^4 n)*time*deterministic algorithm to compute a spanning forest of H. ...*In*a breakthrough work, Kawarabayashi and Thorup (J. ACM'19) gave a near-linear*time*deterministic algorithm for minimum cut*in*a simple graph G = (V,*E*). ... One can use Gabow's deterministic*O*(λm*log*n)*edge*connectivity algorithm [Gab95] for a*multigraph*with m*edges*and*edge*connectivity λ to check*in**time**O*(nd*log*n) =*O*(m) if the*edge*connectivity of ...##
###
Node-based Service-Balanced Scheduling for Provably Guaranteed Throughput and Evacuation Time Performance
[article]

2017
*
arXiv
*
pre-print

It is remarkable that NSB is both throughput-optimal and evacuation-

arXiv:1512.02328v2
fatcat:uz5t5spttzaotfg5eyuah37r6i
*time*-optimal if the underlying network graph is*bipartite*. ... NSB aims to give scheduling opportunities to heavily congested nodes*in*a balanced manner, by maximizing the total weight of the scheduled nodes*in*each scheduling cycle, where the weight of a node is ... Algorithm Complexity γ (Throughput) η (Evacuation*time*) General*Bipartite*General*Bipartite*MWM*O*(mn) 1 1 2 2 GMM*O*(m*log*m) ≥ 1/2 ≥ 1/2 2 2 MM*O*(m) ≥ 1/2 ≥ 1/2 2 2 MVM*O*(m √ n*log*n) ? ...##
###
Node-Based Service-Balanced Scheduling for Provably Guaranteed Throughput and Evacuation Time Performance

2018
*
IEEE Transactions on Mobile Computing
*

It is remarkable that NSB is both throughput-optimal and evacuation-

doi:10.1109/tmc.2017.2777828
fatcat:3wv4k2w7jjgcrm62rahwsii3ji
*time*-optimal if the underlying network graph is*bipartite*. ...*In*this paper, we adopt a novel node-based approach and propose a service-balanced online scheduling algorithm, called NSB, which gives balanced scheduling opportunities to the nodes with heavy workload ... Algorithm Complexity γ (Throughput) η (Evacuation*time*) General*Bipartite*General*Bipartite*MWM*O*(mn) 1 1 2 2 GMM*O*(m*log*m) ≥ 1/2 ≥ 1/2 2 2 MM*O*(m) ≥ 1/2 ≥ 1/2 2 2 MVM*O*(m √ n*log*n) unknown 1 ≤ 3/2 1 ...##
###
Node-based service-balanced scheduling for provably guaranteed throughput and evacuation time performance

2016
*
IEEE INFOCOM 2016 - The 35th Annual IEEE International Conference on Computer Communications
*

It is remarkable that NSB is both throughput-optimal and evacuation-

doi:10.1109/infocom.2016.7524617
dblp:conf/infocom/JiGS16
fatcat:saejdrrpxzf2jcrjz34kc47bfy
*time*-optimal if the underlying network graph is*bipartite*. ...*In*this paper, we adopt a novel node-based approach and propose a service-balanced online scheduling algorithm, called NSB, which gives balanced scheduling opportunities to the nodes with heavy workload ... Algorithm Complexity γ (Throughput) η (Evacuation*time*) General*Bipartite*General*Bipartite*MWM*O*(mn) 1 1 2 2 GMM*O*(m*log*m) ≥ 1/2 ≥ 1/2 2 2 MM*O*(m) ≥ 1/2 ≥ 1/2 2 2 MVM*O*(m √ n*log*n) unknown 1 ≤ 3/2 1 ...##
###
Network Coding Gaps for Completion Times of Multiple Unicasts
[article]

2020
*
arXiv
*
pre-print

Our results also hold for average completion

arXiv:1905.02805v3
fatcat:dq4mgw5s35cntgqubqvwpx2zvq
*time*, and more generally any ℓ_p norm of completion*times*. ...*In*this problem distinct packets at different nodes*in*a network need to be delivered to a destination specific to each packet, as fast as possible. ... Acknowledgements The authors would like to thank Mohsen Ghaffari for suggesting an improvement to Theorem 1.2 which resulted*in*a coding gap independent of n, Anupam Gupta for pointing out a simplification ...##
###
Dedicated Scheduling of Biprocessor Tasks to Minimize Mean Flow Time
[chapter]

2002
*
Lecture Notes in Computer Science
*

*In*this way we identify a borderline between NP-hard and polynomially solvable special cases. ... This paper investigates the complexity of scheduling biprocessor tasks on dedicated processors to minimize mean flow

*time*. ... If G = (V 1 ∪ V 2 ,

*E*) is a

*bipartite*graph

*in*which deg(x) ≥ deg (y) for each

*edge*xy with x ∈ V 1 , y ∈ V 2 then an optimal sum

*coloring*can be found

*in*

*time*

*O*(|

*E*|

*log*∆). ...

##
###
Edge-coloring algorithms
[chapter]

1995
*
Lecture Notes in Computer Science
*

*In*this paper, we survey recent advances and results on the classical

*edge*-

*coloring*problem as well as the generalized

*edge*-

*coloring*problems, called the f-

*coloring*and fg-

*coloring*problems. ...

*In*particular we review various upper bounds on the minimum number of

*colors*required to

*edge*-

*color*graphs, and present efficient algorithms to

*edge*-

*color*graphs with a number of

*colors*not exceeding the ... There exists a more efficient algorithm which, based on the divide and conquer,

*edge*-

*colors*a

*bipartite*

*multigraph*

*in*

*time*

*O*(m

*log*m) [8] . with [-~z~(a)J

*colors*

*in*

*time*

*O*(m(A(a) +

*e*)). ...

##
###
Computing Quartet Distance is Equivalent to Counting 4-Cycles
[article]

2020
*
arXiv
*
pre-print

[SODA 2013] presented an algorithm that computes this number

arXiv:1811.06244v2
fatcat:kdd6gz5g6zcfrb6wnjx2ztgpim
*in**𝒪*(ndlog n)*time*, where*d*is the maximum degree of a node. ... For trees with degrees bounded by*d*, by analysing the reduction more carefully, we are able to obtain an*Õ*(nd^0.77)*time*algorithm, which is again a nontrivial improvement on the previous bound of*𝒪*(ndlog ...*In*total there are at most 2 nodes of type (1) at each side of the graph. To conclude, we can construct the*bipartite**multigraph*M with*O*(|L|) non-zero*edges**in**O*(|L|*log*|L|)*time*. ...##
###
Decompositions to Degree-Constrainded Subgraphs Are Simply Reducible to Edge-Colorings

1999
*
Journal of combinatorial theory. Series B (Print)
*

*In*this paper we show that the problem can be simply reduced to the

*edge*-

*coloring*problem

*in*polynomial-

*time*. ... be

*edge*-

*colored*with k

*colors*. ... Thus we have |

*E*(G f k )| : [ |

*E*(P(v))|: v # V] =

*O*\ : v # V

*d*(v)(2 f ) 3

*log*2 f 2 +

*O*(|

*E*| (2 f ) 3

*log*2 f 2). ...

##
###
Fully Polynomial-Time Distributed Computation in Low-Treewidth Graphs

2022
*
Proceedings of the 34th ACM Symposium on Parallelism in Algorithms and Architectures
*

This is the first exact algorithm for the directed single-source shortest paths problem

doi:10.1145/3490148.3538590
fatcat:vwfkvxvzufcalg5ghaxf67pksq
*in*low-treewidth graphs attaining a*Õ*(𝜏*𝑂*(1)*𝐷*)-round running*time*. • Exact*bipartite*unweighted maximum matching ... can be computed*in**Õ*(𝜏 4*𝐷*+ 𝜏 7 ) rounds. ... The depth of 𝑇 is*𝑂*(*log*𝑛) and the running*time*of the algorithm is*Õ*(𝜏 2*𝐷*+ 𝜏 3 ) rounds. ...
« Previous

*Showing results 1 — 15 out of 838 results*