This paper presents a new method and a constraint-based objective function to solve two problemsrelated to the design of optical telecommunication networks, namely the Synchronous Optical Net-work Ring Assignment Problem (SRAP) and the Intra-ring Synchronous Optical Network DesignProblem (IDP). These network topology problems can be represented as a graph partitioning withcapacity constraints as shown in previous works. We present here a new objective function and anew local search algorithm to solve these problems. Experiments conducted in C
In @cite_4 the SRAP problem is considered. They propose three greedy algorithms with different heuristics, the , the and the . The first two algorithms start by assigning each node to a different ring. At each iteration they reduce the number of rings by merging two rings @math and @math if @math is a feasible ring for the capacity constraint. In the edge-based heuristic, the two rings with the maximum weight edge are merged. While in the cut-based heuristic, the two rings with the maximum total weight of the edges with one endpoint in each of them, are merged. Algorithm shows the pseudo code for the edge-based heuristic.
@cite_4
2002547394 1530649098 1989921461 2156512439
We consider the problem of interconnecting a set of customer sites using bidirectional SONET rings of equal capacity. Each site is assigned to exactly one ring and a special ring, called the federal ring, interconnects the other rings together. The objective is to minimize the total cost of the network subject to a ring capacity limit where the capacity of a ring is determined by the total bandwidth required between sites assigned to the same ring plus the total bandwidth request between these sites and sites assigned to other rings.We present exact, integer-programming based solution techniques and fast heuristic algorithms for this problem. We compare the results from applying the heuristic algorithms with those produced by the exact methods for real-world as well as randomly generated problem instances. We show that two of the heuristics find solutions that cost at most twice that of an optimal solution. Empirical evidence indicates that in practice the algorithms perform much better than their theoretical bound and often find optimal solutions. We consider the two-dimensional geometric knapsack problem defined as follows. Given a collection of rectangular axis-parallel items with weights, we want to find a maximum weight subset of the items that can be packed into a rectangular knapsack, i.e., which can be assigned positions within the knapsack such that the items are pairwise non-overlapping. The goal is to compute the optimal collection of items together with a feasible packing. The problem arises naturally in several applications, and various special cases of the problem have been studied. For the general case the best known result is a (2 + e)-approximation algorithm, while the only hardness result is NP-hardness. Our main result is a (1 + e)-approximation algorithm that runs in quasi-polynomial time, provided that the input data consists of (quasi-)polynomially bounded integers. We achieve this result in the setting with and without allowing rotation of the items. Our key technical contribution is to show the existence of a partition for the knapsack into a small number of rectangular boxes. Intuitively, this partition describes the segmentation of the knapsack in some near-optimal solution into large items, areas containing items that are high and thin, and areas containing items that are small and wide. Handling the interaction between these three types of items is a core bottleneck in the design of approximation algorithms for the problem and our partition allows to control this at only marginal cost. In particular, it is so powerful that we do not even need to round the sizes of the items, which is a canonical step in algorithms for geometric knapsack, geometric bin-packing, etc. Finally, we present new algorithms for two-dimensional knapsack and two-dimensional bin-packing under (1 + e)-resource augmentation with a substantially better running time dependence on e (although at the expense of requiring quasi-polynomial time). The objective value of our computed solutions is as good as the optimum without additional resources. Here we exploit a recent result showing the existence of certain low-complexity low weight separators for sets of non-overlapping rectangles. Given @math elements with non-negative integer weights @math and an integer capacity @math , we consider the counting version of the classic knapsack problem: find the number of distinct subsets whose weights add up to at most @math . We give the first deterministic, fully polynomial-time approximation scheme (FPTAS) for estimating the number of solutions to any knapsack constraint (our estimate has relative error @math ). Our algorithm is based on dynamic programming. Previously, randomized polynomial-time approximation schemes (FPRAS) were known first by Morris and Sinclair via Markov chain Monte Carlo techniques, and subsequently by Dyer via dynamic programming and rejection sampling. In addition, we present a new method for deterministic approximate counting using read-once branching programs. Our approach yields an FPTAS for several other counting problems, including counting solutions for the multidimensional knapsack problem with a constant number of constraints, the general integer knapsack problem, and the contingency tables problem with a constant number of rows. In the first part of this paper we show a similarity between the principle of Structural Risk Minimization Principle (SRM) (Vapnik, 1982) and the idea of Sparse Approximation, as defined in (Chen, Donoho and Saunders, 1995) and Olshausen and Field (1996). Then we focus on two specific (approximate) implementations of SRM and Sparse Approximation, which have been used to solve the problem of function approximation. For SRM we consider the Support Vector Machine technique proposed by V. Vapnik and his team at AT &T Bell Labs, and for Sparse Approximation we consider a modification of the Basis Pursuit De-Noising algorithm proposed by Chen, Donoho and Saunders (1995). We show that, under certain conditions, these two techniques are equivalent: they give the same solution and they require the solution of the same quadratic programming problem.