The k-means method is one of the most widely used clustering algorithms, drawing its popularity from its speed in practice. Recently, however, it was shown to have exponential worst-case running time. In order to close the gap between practical performance and theoretical analysis, the k-means method has been studied in the model of smoothed analysis. But even the smoothed analyses so far are unsatisfactory as the bounds are still super-polynomial in the number n of data points. In this article, we settle the smoothed running time of the k-means method. We show that the smoothed number of iterations is bounded by a polynomial in n and 1/σ, where σ is the standard deviation of the Gaussian perturbations. This means that if an arbitrary input data set is randomly perturbed, then the k-means method will run in expected polynomial time on that input set.

We investigate the problem of finding reverse nearest neighbors efficiently. Although provably good solutions exist for this problem in low or fixed dimensions, to this date the methods proposed in high dimensions are mostly heuristic. We introduce a method that is both provably correct and efficient in all dimensions, based on a reduction of the problem to one instance of $\e$-nearest neighbor search plus a controlled number of instances of {\em exhaustive $r$-\pleb}, a variant of {\em Point Location among Equal Balls} where all the $r$-balls centered at the data points that contain the query point are sought for, not just one. The former problem has been extensively studied and elegantly solved in high dimensions using Locality-Sensitive Hashing (LSH) techniques. By contrast, the latter problem has a complexity that is still not fully understood. We revisit the analysis of the LSH scheme for exhaustive $r$-\pleb using a somewhat refined notion of locality-sensitive family of hash function, which brings out a meaningful output-sensitive term in the complexity of the problem. Our analysis, combined with a non-isometric lifting of the data, enables us to answer exhaustive $r$-\pleb queries (and down the road reverse nearest neighbors queries) efficiently. Along the way, we obtain a simple algorithm for answering exact nearest neighbor queries, whose complexity is parametrized by some {\em condition number} measuring the inherent difficulty of a given instance of the problem.

The k-means method is one of the most widely used clustering algorithms, drawing its popularity from its speed in practice. Recently, however, it was shown to have exponential worst-case running time. In order to close the gap between practical performance and theoretical analysis, the k-means method has been studied in the model of smoothed analysis. But even the smoothed analyses so far are unsatisfactory as the bounds are still super-polynomial in the number n of data points. In this paper, we settle the smoothed running time of the k-means method. We show that the smoothed number of iterations is bounded by a polynomial in n and 1/sigma, where sigma is the standard deviation of the Gaussian perturbations. This means that if an arbitrary input data set is randomly perturbed, then the k-means method will run in expected polynomial time on that input set.

We show a worst-case lower bound and a smoothed upper bound on the number of iterations performed by the Iterative Closest Point (ICP) algorithm. First proposed by Besl and McKay, the algorithm is widely used in computational geometry where it is known for its simplicity and its observed speed. The theoretical study of ICP was initiated by Ezra, Sharir and Efrat, who bounded its worst-case running time between Omega(n logn) and O(n(2)d)(d). We substantially tighten this gap by improving the lower bound to Omega(n/d)(d+1). To help reconcile this bound with the algorithm's observed speed, we also show the smoothed complexity of ICP is polynomial, independent of the dimensionality of the data. Using similar methods, we improve the best known smoothed upper bound for the popular k-means method to n(O(k)), once again independent of the dimension.

We study the use of viral marketing strategies on social networks that seek to maximize revenue from the sale of a single product. We propose a model in which the decision of a buyer to buy the product is influenced by friends that own the product and the price at which the product is offered. The influence model we analyze is quite general, naturally extending both the Linear Threshold model and the Independent Cascade model, while also incorporating price information. We consider sales proceeding in a cascading manner through the network, i.e. a buyer is offered the product via recommendations from its neighbors who own the product. In this setting, the seller influences events by offering a cashback to recommenders and by setting prices (via coupons or discounts) for each buyer in the social network. This choice of prices for the buyers is termed as the seller’s strategy. Finding a seller strategy which maximizes the expected revenue in this setting turns out to be NP-hard. However, we propose a seller strategy that generates revenue guaranteed to be within a constant factor of the optimal strategy in a wide variety of models. The strategy is based on an influence-and-exploit idea, and it consists of finding the right trade-off at each time step between: generating revenue from the current user versus offering the product for free and using the influence generated from this sale later in the process.

The approximate Nearest Neighbor (NN) search problem asks to pre-process a given set of points $P$ in such a way that, given any query point $q$, one can retrieve a point in $P$ that is approximately closest to $q$. Of particular interest is the case of points lying in high dimensions, which has seen rapid developments since the introduction of the Locality-Sensitive Hashing (LSH) data structure by Indyk and Motwani. Combined with a space decomposition by Har-Peled, the LSH data structure can answer approximate NN queries in sub-linear time using polynomial (in both $d$ and $n$) space. Unfortunately, it is not known whether Har-Peled's space decomposition can be maintained efficiently under point insertions and deletions, so the above solution only works in a static setting. In this paper we present a variant of Har-Peled's decomposition, based on random semi-regular grids, which can achieve the same query time with the added advantage that it can be maintained efficiently even under adversarial point insertions and deletions. The outcome is a new data structure to answer approximate NN queries efficiently in dynamic settings. Another related problem known as Reverse Nearest Neighbor (RNN) search is to find the influence set of a given query point $q$, i.e. the subset of points of $P$ that have $q$ as their nearest neighbor. Although this problem finds many practical applications, very little is known about its complexity. In particular, no algorithm is known to solve it in high dimensions in sub-linear time using sub-exponential space. In this paper we show how to pre-process the data points, so that Har-Peled's space decomposition combined with modified LSH data structures can solve an approximate variant of the RNN problem efficiently, using polynomial space. The query time of our approach is bounded by two terms: the first one is sub-linear in the size of $P$ and corresponds roughly to the incompressible time needed to locate the query point in the data structure; the second one is proportional to the size of the output, which is a set of points as opposed to a single point for (approximate) NN queries. An interesting feature of our RNN solution is that it is flexible enough to be applied indifferently in monochromatic or bichromatic settings.

We investigate the problem of finding approximate reverse nearest neighbors efficiently in high dimensions. Given a point cloud $P$ and a parameter $\e$, our goal is to preprocess $P$ in a way that enables us to quickly return the set of reverse nearest neighbors of any query point $q$ among the points of $P$, plus possibly a small set of false positives that are $\e$-close to being true reverse nearest neighbors. Although provable solutions exist for this problem in low or fixed dimensions, to this date the methods proposed in high dimensions are mostly heuristic. We propose a method that is both provably-good and provably-efficient in all dimensions, based on a reduction of the problem to a small number of instances of the now classical $\e$-nearest neighbor search and $r$-neighbors reporting problems. Although the former has been extensively studied and elegantly solved in high dimensions using Locality-Sensitive Hashing techniques (LSH), the latter has a complexity that is still not well understood. We propose a new analysis of the LSH scheme for $r$-neighbors reporting, which brings out a meaningful output-sensitive term in the complexity of the problem, and which down the road enables us to solve the approximate reverse nearest problem, thanks to our reduction. Along the way, we propose a method to perform exact nearest neighbor search, whose analysis sheds new light on the problem by introducing a notion of {\em condition number} measuring the inherent complexity of a given instance.

Lloyd's method (also known as the k-means method) and Iterative Closest Point are two prominent algorithms that use local search to sacrifice accuracy guarantees for speed and simplicity. On the large-scale data sets that arise in practice, this trade-off is appealing, and both algorithms are very widely used. Previously however, little was known about the worst-case running time of either algorithm, and there was no satisfactory explanation as to why they are fast in practice. In this work, we begin by showing that worst-case complexity cannot offer such an explanation because surprisingly, both algorithms have super-polynomial worst-case running time. To reconcile this shortcoming with the algorithms' observed speed, we turn to the model of smoothed analysis, where running time is measured only after adding a small amount of random noise to the input. We show that in this model, both Lloyd's method and Iterative Closest Point have polynomial complexity. This implies any worst-case scenario requires a pathological placement of points, which is extremely unlikely in practice. We also observe that Lloyd's method, for all of its advantages, can give arbitrarily bad output even on real-world data sets. We introduce k-means++, which tweaks the initialization procedure for Lloyd's method to get an algorithm with provable accuracy guarantees. Experiments show k-means++ is both faster and more accurate than Lloyd's method in practice, often by considerable margins. We believe this is the first k-means clustering algorithm that combines theoretical guarantees with positive experimental results.

We say a permutation π "avoids" a pattern σ if no length |σ| subsequence of π is ordered in precisely the same way as σ. For example, π avoids (1, 2, 3) if it contains no increasing subsequence of length three. It was recently shown by Marcus and Tardos that the number of permutations of length n avoiding any fixed pattern is at most exponential in n. This suggests the possibility that if π is known a priori to avoid a fixed pattern, it may be possible to sort π in as little as linear time. Fully resolving this possibility seems very challenging, but in this paper, we demonstrate a large class of patterns σ for which σ-avoiding permutations can be sorted in O ( n log log log n ) time.

The k-means method is a widely used clustering technique that seeks to minimize the average squared distance between points in the same cluster. Although it offers no accuracy guarantees, its simplicity and speed are very appealing in practice. By augmenting k-means with a very simple, randomized seeding technique, we obtain an algorithm that is Θ(logk)-competitive with the optimal clustering. Preliminary experiments show that our augmentation improves both the speed and the accuracy of k-means, often quite dramatically.

The k-means method is an old but popular clustering algorithm known for its observed speed and its simplicity. Until recently, however, no meaningful theoretical bounds were known on its running time. In this paper, we demonstrate that the worst-case running time of k-means is superpolynomial by improving the best known lower bound from Ω (n) iterations to 2 Ω(√ n ) .

We analyze protocols for disseminating a collection of data blocks over a network of peers with a view towards Bit-Torrent and related peer-to-peer networks. Unlike previous work, we accurately model the distribution of the individual data blocks, a process which is critical to the parallelism that makes BitTorrent successful in practice. We also consider multiple network topologies and routing algorithms. We first demonstrate several routing algorithms that distribute b data blocks on a network with diameter d and maximum degree D in O(D(b + d)) phases of concurrent downloads with high probability. This is tight within a factor of D. We also specialize to the networks used by BitTorrent and we improve this bound to O(b ln n) phases where n is the number of clients. Finally, we discuss several practical extensions to BitTorrent, one of which improves the bound to a near-optimal O (b + (ln n)2) phases.

The k-means method is an old but popular clustering algorithm known for its speed and simplicity. Until recently, however, no meaningful theoretical bounds were known on its running time. In this paper, we demonstrate that the worst-case running time of k-means is superpolynomial by improving the best known lower bound from $\Omega(n)$ iterations to $2^{\Omega(\sqrt{n})}$. To complement this lower bound, we show a smoothed-analysis type polynomial time upper bound for k-means.