An algorithm for the con due-date determination and sequencing problem

For a set of n jobs with deterministic processing times and common starting times, the problem is to determine the optimal constant flow allowance k^* for the CON due-date assignment method and the optimal sequence σ^* which minimizes the weighted average of missed due-dates. As k^* and σ^* cannot be independently determined, we propose an algorithm which systematically searches for the optimal solution. Although the algorithm has time complexity of 0(2ⁿn²), it is considerably more efficient than the exhaustive enumeration method which considers all n! possible sequences.     

Communication Complexity of Gossiping by Packets

This paper considers the problem of gossiping with packets of limited size in a network with a cost function. We show that the problem of determining the minimum cost necessary to perform gossiping among a given set of participants with packets of limited size is NP-hard. We also give an approximate (with respect to the cost) gossiping algorithm. The ratio between the cost of an optimal algorithm and the approximate one is less than 1 + 2(k− 1)/n, wherenis the number of nodes participating in the gossiping process andk≤n− 1 is the upper bound on the number of individual blocks of information that a packet can carry. We also analyze the communication time and communication complexity, i.e., the product of the communication cost and time, of gossiping algorithms.     

Refined memorization for vertex cover

Memorization is a technique which allows to speed up exponential recursive algorithms at the cost of an exponential space complexity. This technique already leads to the currently fastest algorithm for fixed-parameter vertex cover, whose time complexity is O(k^1.2832k^1.5+kn), where n is the number of nodes and k is the size of the vertex cover. Via a refined use of memorization, we obtain an O(k^1.2759k^1.5+kn) algorithm for the same problem. We moreover show how to further reduce the complexity to O(k^1.2745k⁴+kn).     

Delay-Constrained,Low-Cost Multicast Routing in Multimedia Networks

Support for multimedia applications is a major objective of future high speed networks. Multimedia applications are usually resource intensive, have stringent quality of service (QoS) requirements, and in many cases involve large multicast groups. Multicasting enables these applications to scale to a large number of users without overloading the network and server resources. This paper focuses on developing low-cost, delay-bounded multicast trees to support the QoS requirements of multimedia applications. The approach taken in the development of the multicast trees is to decouple the cost optimization from bounding the delay by first building a low-cost tree and then handling any delay violations that may occur in the tree. Three new heuristics are proposed. The first two heuristics, delay-constrained low-cost inexpensive multicasting (SLIM) and SLIM+, use the least-cost path between the multicast nodes to incrementally build a multicast tree that satisfies the delay requirements of the multicast nodes. Their complexity is O(n³), where n is the number of nodes in the network. The third heuristic, K-SLIM, builds a set of k shortest paths and uses these paths in an attempt to further reduce the cost of the multicast tree without violating the delay requirements of the multicast nodes. Its time complexity is O(kn³ log(n)), where k, a user-defined parameter, denotes the number of shortest paths to be considered. Our simulation results show that K-SLIM on average outperforms other well-known heuristics. The results also show that SLIM+ produces low-cost, delay-bounded trees with an average cost close to the average cost of the trees produced by K-SLIM but with much lower processing overhead.     

Cache-oblivious index for approximate string matching

This paper revisits the problem of indexing a text for approximate string matching. Specifically, given a text T of length n and a positive integer k, we want to construct an index of T such that for any input pattern P, we can find all its k-error matches in T efficiently. This problem is well-studied in the internal-memory setting. Here, we extend some of these recent results to external-memory solutions, which are also cache-oblivious. Our first index occupies O((nlog^kn)/B) disk pages and finds all k-error matches with O((|P|+occ)/B+log^knloglog_Bn) I/Os, where B denotes the number of words in a disk page. To the best of our knowledge, this index is the first external-memory data structure that does not require Ω(|P|+occ+poly(logn)) I/Os. The second index reduces the space to O((nlogn)/B) disk pages, and the I/O complexity is O((|P|+occ)/B+log^k(k+1)nloglogn).     

An efficient solution algorithm for boundary element equations

Boundary element techniques result in the solution of a linear system of equations of the type HU = GQ + B, which can be transformed into a system of equations of the type AX = F. The coefficient matrix A requires the storage of a full matrix on the computer. This storage requirement, of the order of n^*n memory positions (n = number of equations), for a very large n is often considered negative for the boundary element method. Here, two algorithms are presented where the memory requirements to solve the system are only n^*(n - 1)/2 and n^*n/4 respectively. The algorithms do not necessitate any external storage devices nor do they increase the computational efforts.     

Hadamard tensors and lower bounds on multiparty communication complexity

We develop a new method for estimating the discrepancy of tensors associated with multiparty communication problems in the “Number on the Forehead” model of Chandra, Furst, and Lipton. We define an analog of the Hadamard property of matrices for tensors in multiple dimensions and show that any k-party communication problem represented by a Hadamard tensor must have Ω(n/2 ^k ) multiparty communication complexity. We also exhibit constructions of Hadamard tensors. This allows us to obtain Ω(n/2 ^k ) lower bounds on multiparty communication complexity for a new class of explicitly defined Boolean functions.     

An efficient algorithm for attention-driven image interpretation from segments

In the attention-driven image interpretation process, an image is interpreted as containing several perceptually attended objects as well as the background. The process benefits greatly a content-based image retrieval task with attentively important objects identified and emphasized. An important issue to be addressed in an attention-driven image interpretation is to reconstruct several attentive objects iteratively from the segments of an image by maximizing a global attention function. The object reconstruction is a combinational optimization problem with a complexity of 2^N which is computationally very expensive when the number of segments N is large. In this paper, we formulate the attention-driven image interpretation process by a matrix representation. An efficient algorithm based on the elementary transformation of matrix is proposed to reduce the computational complexity to 3ωN(N-1)²/2, where ω is the number of runs. Experimental results on both the synthetic and real data show a significantly improved processing speed with an acceptable degradation to the accuracy of object formulation.     

A Probabilistic Algorithm for k -SAT Based on Limited Local Search and Restart

A simple probabilistic algorithm for solving the NP-complete problem k -SAT is reconsidered. This algorithm follows a well-known local-search paradigm: randomly guess an initial assignment and then, guided by those clauses that are not satisfied, by successively choosing a random literal from such a clause and changing the corresponding truth value, try to find a satisfying assignment. Papadimitriou [11] introduced this random approach and applied it to the case of 2-SAT, obtaining an expected O(n ² ) time bound. The novelty here is to restart the algorithm after 3n unsuccessful steps of local search. The analysis shows that for any satisfiable k -CNF formula with n variables the expected number of repetitions until a satisfying assignment is found this way is (2? (k-1)/ k) ⁿ . Thus, for 3-SAT the algorithm presented here has a complexity which is within a polynomial factor of (\frac 4 3 ) ⁿ . This is the fastest and also the simplest among those algorithms known up to date for 3-SAT achieving an o(2 ⁿ ) time bound. Also, the analysis is quite simple compared with other such algorithms considered before.     

Higher-order Voronoi diagrams on triangulated surfaces

We study the complexity of higher-order Voronoi diagrams on triangulated surfaces under the geodesic distance, when the sites may be polygonal domains of constant complexity. More precisely, we show that on a surface defined by n triangles the sum of the combinatorial complexities of the order-j Voronoi diagrams of m sites, for j=1,…,k, is O(k²n²+k²m+knm), which is asymptotically tight in the worst case.     

Computing the subset partial order for dense families of sets

We give an algorithm to compute the subset partial order (called the subset graph) for a family F of sets containing k sets with N elements in total and domain size n. Our algorithm requires O(nk²/logk) time and space on a Pointer Machine. When F is dense, i.e. N=Θ(nk), the algorithm requires O(N²/log²N) time and space. We give a construction for a dense family whose subset graph is of size Θ(N²/log²N), indicating the optimality of our algorithm for dense families. The subset graph can be dynamically maintained when F undergoes set insertions and deletions in O(nk/logk) time per update (that is sub-linear in N for the case of dense families). If we assume words of b?k bits, allow bits to be packed in words, and use bitwise operations, the above running time and space requirements can be reduced by a factor of blog(k/b+1)/logk and b²log(k/b+1)/logk respectively.     

Improving bounds on link failure tolerance of the star graph

Determination of the minimum number of faulty links, f(n,k), that make every n-k-dimensional sub-star graph S_n-k faulty in an n-dimensional star network S_n, has been the subject of several studies. Bounds on f(n,k) have already been derived, and it is known that f(n,1)=n+2. Here, we improve the bounds on f(n,k). Specifically, it is shown that f(n,k)?(k+1)F(n,k), where F(n,k) is the minimum number of faulty nodes that make every S_n-k faulty in S_n. The complexity of f(n,k) is shown to be O(n²k) which is an improvement over the previously known upper bound of O(n³); this result in a special case leads to f(n,2)=O(n^↑2), settling a conjecture introduced in an earlier paper. A systematic method to derive the labels of the faulty links in case of f(n,1) is also introduced.     

Chromatic distribution of k-nearest neighbors of a line segment in a planar colored point set

Let P be a set of n colored points distributed arbitrarily in R². The chromatic distribution of the k-nearest neighbors of a query line segment ? is to report the number of points of each color among the k-nearest points of the query line segment. While solving this problem, we have encountered another interesting problem, namely the semicircular range counting query. Here a set of n points is given. The objective is to report the number of points inside a given semicircular range. We propose a simple algorithm for this problem with preprocessing time and space complexity O(n³), and the query time complexity O(logn). Finally, we propose the algorithm for reporting the chromatic distribution of k nearest neighbors of a query line segment. Using our proposed technique for semicircular range counting query, it runs in O(log²n) time.     

On linear interpolation under interval data

Some results related to the problem of interpolation of n vertical segments (x_k, Y_k), k = 1,…,n, in the plane with generalized polynomial functions that are linear combinations of m basic functions are presented. It is proved that the set of interpolating functions (if not empty) is bounded in every subinterval (x_k, x_k+1) by two unique such functions η_k⁻ and η_k⁺. An algorithm with result verification for the determination of the boundary functions η_k⁻, η_k⁺ and for their effective tabulation is reported and some examples are discussed.     

A note on the decoding complexity of error-correcting codes

A time-space tradeoff lower bound for the decoding complexity of asymptotically good error-correcting codes for oblivious write-k-times branching programs is proved. Specifically, we prove that the computation time T and space S of every oblivious write-k-times branching program that decodes an asymptotically good error-correcting code with block length n satisfy S⋅Tk=Ω((n/k)^k+1).     

Incomplete k-ary n-cube and its derivatives

Incomplete or pruned k-ary n-cube, n⩾3, is derived as follows. All links of dimension n−1 are left in place and links of the remaining n−1 dimensions are removed, except for one, which is chosen periodically from the remaining dimensions along the intact dimension n−1. This leads to a node degree of 4 instead of the original 2n and results in regular networks that are Cayley graphs, provided that n−1 divides k. For $\text{n=3}\text{(n=5)}$, the preceding restriction is not problematic, as it only requires that k be even (a multiple of 4). In other cases, changes to the basis network to be pruned, or to the pruning algorithm, can mitigate the problem. Incomplete k-ary n-cube maintains a number of desirable topological properties of its unpruned counterpart despite having fewer links. It is maximally connected, has diameter and fault diameter very close to those of k-ary n-cube, and an average internode distance that is only slightly greater. Hence, the cost/performance tradeoffs offered by our pruning scheme can in fact lead to useful, and practically realizable, parallel architectures. We study pruned k-ary n-cubes in general and offer some additional results for the special case n=3.     

A faster parameterized algorithm for set packing

We present an efficient parameterized algorithm for the (k,t)-set packing problem, in which we are looking for a collection of k disjoint sets whose union consists of t elements. The complexity of the algorithm is O(²O(t)nNlogN). For the special case of sets of bounded size, this improves the O(k(ck)n) algorithm of Jia et al. [J. Algorithms 50 (1) (2004) 106].     

Robustness of star graph network under link failure

The star graph is an attractive underlying topology for distributed systems. Robustness of the star graph under link failure model is addressed. Specifically, the minimum number of faulty links, f(n, k), that make every (n − k)-dimensional substar S_n−k faulty in an n-dimensional star network S_n, is studied. It is shown that f(n,1)=n+2. Furthermore, an upper bound is given for f(n, 2) with complexity of O(n³) which is an improvement over the straightforward upper bound of O(n⁴) derived in this paper.