793 research outputs found

    Faster Algorithms for Semi-Matching Problems

    Full text link
    We consider the problem of finding \textit{semi-matching} in bipartite graphs which is also extensively studied under various names in the scheduling literature. We give faster algorithms for both weighted and unweighted case. For the weighted case, we give an O(nmlogn)O(nm\log n)-time algorithm, where nn is the number of vertices and mm is the number of edges, by exploiting the geometric structure of the problem. This improves the classical O(n3)O(n^3) algorithms by Horn [Operations Research 1973] and Bruno, Coffman and Sethi [Communications of the ACM 1974]. For the unweighted case, the bound could be improved even further. We give a simple divide-and-conquer algorithm which runs in O(nmlogn)O(\sqrt{n}m\log n) time, improving two previous O(nm)O(nm)-time algorithms by Abraham [MSc thesis, University of Glasgow 2003] and Harvey, Ladner, Lov\'asz and Tamir [WADS 2003 and Journal of Algorithms 2006]. We also extend this algorithm to solve the \textit{Balance Edge Cover} problem in O(nmlogn)O(\sqrt{n}m\log n) time, improving the previous O(nm)O(nm)-time algorithm by Harada, Ono, Sadakane and Yamashita [ISAAC 2008].Comment: ICALP 201

    Locally Optimal Load Balancing

    Full text link
    This work studies distributed algorithms for locally optimal load-balancing: We are given a graph of maximum degree Δ\Delta, and each node has up to LL units of load. The task is to distribute the load more evenly so that the loads of adjacent nodes differ by at most 11. If the graph is a path (Δ=2\Delta = 2), it is easy to solve the fractional version of the problem in O(L)O(L) communication rounds, independently of the number of nodes. We show that this is tight, and we show that it is possible to solve also the discrete version of the problem in O(L)O(L) rounds in paths. For the general case (Δ>2\Delta > 2), we show that fractional load balancing can be solved in poly(L,Δ)\operatorname{poly}(L,\Delta) rounds and discrete load balancing in f(L,Δ)f(L,\Delta) rounds for some function ff, independently of the number of nodes.Comment: 19 pages, 11 figure

    All-Norm Load Balancing in Graph Streams via the Multiplicative Weights Update Method

    Get PDF
    In the weighted load balancing problem, the input is an n-vertex bipartite graph between a set of clients and a set of servers, and each client comes with some nonnegative real weight. The output is an assignment that maps each client to one of its adjacent servers, and the load of a server is then the sum of the weights of the clients assigned to it. The goal is to find an assignment that is well-balanced, typically captured by (approximately) minimizing either the ?_?- or ??-norm of the server loads. Generalizing both of these objectives, the all-norm load balancing problem asks for an assignment that approximately minimizes all ?_p-norm objectives for p ? 1, including p = ?, simultaneously. Our main result is a deterministic O(log n)-pass O(1)-approximation semi-streaming algorithm for the all-norm load balancing problem. Prior to our work, only an O(log n)-pass O(log n)-approximation algorithm for the ?_?-norm objective was known in the semi-streaming setting. Our algorithm uses a novel application of the multiplicative weights update method to a mixed covering/packing convex program for the all-norm load balancing problem involving an infinite number of constraints

    Improved Bounds for Distributed Load Balancing

    Get PDF
    In the load balancing problem, the input is an nn-vertex bipartite graph G=(CS,E)G = (C \cup S, E) and a positive weight for each client cCc \in C. The algorithm must assign each client cCc \in C to an adjacent server sSs \in S. The load of a server is then the weighted sum of all the clients assigned to it, and the goal is to compute an assignment that minimizes some function of the server loads, typically either the maximum server load (i.e., the \ell_{\infty}-norm) or the p\ell_p-norm of the server loads. We study load balancing in the distributed setting. There are two existing results in the CONGEST model. Czygrinow et al. [DISC 2012] showed a 2-approximation for unweighted clients with round-complexity O(Δ5)O(\Delta^5), where Δ\Delta is the maximum degree of the input graph. Halld\'orsson et al. [SPAA 2015] showed an O(logn/loglogn)O(\log{n}/\log\log{n})-approximation for unweighted clients and O(log2 ⁣n/loglogn)O(\log^2\!{n}/\log\log{n})-approximation for weighted clients with round-complexity polylog(n)(n). In this paper, we show the first distributed algorithms to compute an O(1)O(1)-approximation to the load balancing problem in polylog(n)(n) rounds. In the CONGEST model, we give an O(1)O(1)-approximation algorithm in polylog(n)(n) rounds for unweighted clients. For weighted clients, the approximation ratio is O(logn)O(\log{n}). In the less constrained LOCAL model, we give an O(1)O(1)-approximation algorithm for weighted clients in polylog(n)(n) rounds. Our approach also has implications for the standard sequential setting in which we obtain the first O(1)O(1)-approximation for this problem that runs in near-linear time. A 2-approximation is already known, but it requires solving a linear program and is hence much slower. Finally, we note that all of our results simultaneously approximate all p\ell_p-norms, including the \ell_{\infty}-norm

    Nearly-Linear Time LP Solvers and Rounding Algorithms for Scheduling Problems

    Get PDF
    We study nearly-linear time approximation algorithms for non-preemptive scheduling problems in two settings: the unrelated machine setting, and the identical machine with job precedence constraints setting, under the well-studied objectives such as makespan and weighted completion time. For many problems, we develop nearly-linear time approximation algorithms with approximation ratios matching the current best ones achieved in polynomial time. Our main technique is linear programming relaxation. For the unrelated machine setting, we formulate mixed packing and covering LP relaxations of nearly-linear size, and solve them approximately using the nearly-linear time solver of Young. For the makespan objective, we develop a rounding algorithm with (2+?)-approximation ratio. For the weighted completion time objective, we prove the LP is as strong as the rectangle LP used by Im and Li, leading to a nearly-linear time (1.45 + ?)-approximation for the problem. For problems in the identical machine with precedence constraints setting, the precedence constraints can not be formulated as packing or covering constraints. To achieve the nearly-linear running time, we define a polytope for the constraints, and leverage the multiplicative weight update (MWU) method with an oracle which always returns solutions in the polytope

    Scheduling with processing set restrictions : a survey

    Get PDF
    2008-2009 > Academic research: refereed > Publication in refereed journalAccepted ManuscriptPublishe
    corecore