SIFTER

This paper focuses on Dynamic Implementation using Array and Linked list. In the data structure concept, the list plays a major role in the allocation of data where it is a general overview of creating a node in a linked list using an array with the initialization of size. The node contains data and is interconnected to the next node in the sequence via their links which perform the search operation where the space and time complexity are not wasted in these analyses. Linked lists are a great way to store a theoretically infinite amount of data with a small and versatile amount of code. The amount of data stored increases linearly with the number of nodes in the list (space-o(n)) where linked lists are more efficient than arrays. It is observed that considering the time complexity when there is a variation in data set linked array is almost reaches close to array whenever dataset is high also linked array has better time complexity than linked list when the searching element is in middle and last. Considering the space complexity linked array is almost 2 times and 4 times less space is needed than array and linked list respectively.

Binary embedding refers to methods for embedding points in $\mathbb {R}^{d}$ into vertices in the Hamming cube of dimension ${\mathcal{O}}(d)$ , such that the normalized Hamming distance between the codes preserves a prespecified distance between vectors in the original space. A common approach to binary embedding is to use random projection , followed by one-bit quantization to produce binary codes. Of particular interest, in this letter, is sparse circulant binary embedding (SCBE), where a sparse random circulant matrix with random sampling at a rate of $1-s$ for $s\in (0, 1)$ is used for random projection. The SCBE has the space complexity ${\mathcal{O}}((1-s)d)$ , while unstructured random projection has the space complexity ${\mathcal{O}}(d^2)$ . We present an asymptotic analysis of SCBE, when $d$ approaches $\infty$ , showing that the performance of SCBE is comparable to that of binary embedding with unstructured random projection whilethe former has the space complexity ${\mathcal{O}}((1-s)d)$ and the time complexity ${\mathcal{O}}(d\log d)$ but the latter has both space and time complexities ${\mathcal{O}}(d^2)$ .

The top-k variation of the Subset Sum problem can be successfully used in solving some popular problems in Recommendation Systems as well as other domains. Given a set of n real numbers, we generate the k best subsets so that the sums of their elements are minimized, where k is a positive integer chosen by the user. Our solution methodology is based on constructing a metadata structure G for a given n. The metadata structure G is constructed as a layered directed acyclic graph where in each node an n-bit vector is kept from which a suitable subset can be retrieved. The explicit construction of the whole graph is never needed; only an implicit traversal is carried out in an output-sensitive manner to reduce the total time and space requirement. We then improve the efficiency of our algorithm by reporting each subset incrementally, doing away with the storage of the bit vector in each node. We have implemented our algorithms and compared one of the variations with an existing algorithm, which illustrates the superiority of our algorithm by a constant factor both with respect to time and space complexity.

WITHDRAWN: Spearman rank correlation based bagging ensemble bayes optimal classification for genomic predictive pattern analytics

We initiate the systematic study of the energy complexity of algorithms (in addition to time and space complexity) based on Landauer's Principle in physics, which gives a lower bound on the amount of energy a system must dissipate if it destroys information. We propose energy-aware variations of three standard models of computation: circuit RAM, word RAM, and transdichotomous RAM. On top of these models, we build familiar high-level primitives such as control logic, memory allocation, and garbage collection with zero energy complexity and only constant-factor overheads in space and time complexity, enabling simple expression of energy-efficient algorithms. We analyze several classic algorithms in our models and develop low-energy variations: comparison sort, insertion sort, counting sort, breadth-first search, Bellman-Ford, Floyd-Warshall, matrix all-pairs shortest paths, AVL trees, binary heaps, and dynamic arrays. We explore the time/space/energy trade-off and develop several general techniques for analyzing algorithms and reducing their energy complexity. These results lay a theoretical foundation for a new field of semi-reversible computing and provide a new framework for the investigation of algorithms.

One of the important application of image encryption is storing confidential and important images on a local device or a database in such a way that only the authorized party can view or perceive it. The current image encryption technique employs the genetic algorithm to increase confusion in the image, but compromises in time and space complexity. The other method employs chaos or pseudo random number generating systems which have fast and highly sensitive keys but fails to make the image sufficiently noisy and is risky due to its deterministic nature. We propose a technique which employs the non-deterministic, optimizing power of genetic algorithm and the space efficiency and key sensitivity of chaotic systems into a unified, efficient algorithm which will retain the merits of both the methods whereas tries to minimize their demerits in a software system. The encryption process proceeds in two steps, generating two keys. First, an encryption sequence is generated using Lorenz Chaotic system of differential equation. The seed values used are the user’s actual key having key sensitivity of 10-14. Second, the encrypted image’s genetic encryption sequence is generated which will result in an encrypted image with entropy value greater than 7.999 thus ensuring the image is very noisy. Proposed technique uses variations of Lorenz system seed sets to generate all random mutations and candidate solutions in Genetic encryption. Since only the seed sets leading to desired solution is stored, space efficiency is higher compared to storing the entire sequences. Using this image encryption technique we will ensure that the images are hidden securely under two layers of security, one chaotic and other non-deterministic.

The classic buffer insertion algorithm of van Ginneken has time and space complexity O(n/sup 2/), where n is the number of possible buffer positions. For more than a decade, van Ginneken's algorithm has been the foundation of buffer insertion. In this paper, we present a new algorithm that computes the same optimal buffer insertion, but runs much faster. For 2-pin nets, our time complexity is O(nlogn) and space complexity is O(n). For multipin nets, our time complexity is O(nlog/sup 2/n) and space complexity is O(nlogn). The speedup is achieved by four novel techniques: predictive pruning, candidate tree, fast redundancy check, and fast merging. On industrial test cases, the new algorithms is 2-80 times faster than van Ginneken's algorithm and uses 1/4-1/500 of the memory. Since van Ginneken's algorithm and its variations are used by most existing algorithms on buffer insertion and buffer sizing, our new algorithm significantly improves the performance of all these algorithms. The predictive pruning technique has been applied to buffer cost minimization (Shi et al., 2004), and significantly improved the running time.

This paper introduces a new heuristic function with high efficiency for an optimum solving of the 8 - puzzle, this one being the double of the Chebyshev distance. The comparative study is realized among this new heuristic (Chebyshev heuristic), the Hamming h euristic and the Manhattan heuristic using A* algorithm implemented in Java. The Chebyshev heuristic function is more informed than Hamming and Manhattan heuristics. This paper also presents the necessary stages in object oriented development of an interactive software dedicated to simulate the A* search algorithm for 8 -puzzle. The modeling of the software is achieved through specific UML diagrams representing the phases of analysis, design and implementation, the system thus being described in a clear and practical manner. In order to confirm the obtained theoretical results which show that Chebyshev heuristic is more efficient, two performance criteria were used: space complexity and time complexity. The space complexity was measured by the number of generated nodes from the search tree, by the number of the expanded nodes and by the effective branching factor. The time complexity was measured by the running time. From the experimental results obtained by using the Chebyshev heuristic, improvements were obs erved regarding space and time complexity of A* algorithm versus Hamming and Manhattan heuristics.

Succinct arguments of knowledge are computationally-sound proofs of knowledge for NP where the verifier’s running time is independent of the time complexity of the NP nondeterministic machine for the considered language.Existing succinct argument constructions are, typically, based on techniques that combine cryptographic hashing and probabilistically-checkable proofs (PCPs), and thus, in light of today’s state-of-the-art PCP technology, are quite inefficient: either one uses long PCP proofs with lots of redundancy to make the verifier fast but at the cost of making the prover slow, or one uses short PCP proofs to make the prover fast but at the cost of making the verifier slow.To obtain better efficiency, we propose to investigate the alternative approach of constructing succinct arguments based on multi-prover interactive proofs (MIPs) and stronger cryptographic techniques:(1) We construct a one-round succinct MIP of knowledge protocol where (i) each prover is highly efficient in terms of time AND space, and ALSO (ii) the verifier is highly efficient.(2) We show how to transform any one round MIP protocol to a succinct four-message argument (with a single prover), while preserving the time and space efficiency of the original MIP protocol.As a main tool for this transformation, we construct a succinct multi-function commitment that (a) allows the sender to commit to a vector of functions in time and space complexity that are essentially the same as those needed for a single evaluation of the functions, and (b) ensures that the receiver’s running time is essentially independent of the function. The scheme is based on fully-homomorphic encryption (and no additional assumptions are needed for our succinct argument).(3) In addition, we revisit the problem of non-interactive succinct arguments of knowledge (SNARKs), where known impossibilities rule out solutions based on black-box reductions to standard assumptions. We formulate a natural (though non-standard) variant of homomorphic encryption that has a homomorphism-extraction property. We then show that his primitive essentially allows to “squash” our interactive protocol, while again preserving time and space efficiency. We further show that this variant is, in fact, implied by the existence of SNARKs.

A faster FPTAS for knapsack problem with cardinality constraint

Mining data streams in resource constrained environments has emerged as a challenging research issue for the data mining community in the past two years. Several approaches have been proposed to tackle the challenges of limited capabilities for small devices that generate or receive data streams. These approaches try to approximate the mining results with acceptable accuracy and efficiency in space and time complexity. However these approaches are not resource-aware. In this paper, a thorough discussion about the state of the art of mining data streams is presented followed by a formalization of our Algorithm Output Granularity (AOG) approach in mining data streams. The incorporation of AOG within a generic ubiquitous data mining system architecture is shown and discussed. The industrial applications of AOG-based mining techniques are given and discussed.

Visual vocabulary construction is an integral part of the popular Bag-of-Features (BOF) model. When visual data scale up (in terms of the dimensionality of features or/and the number of samples), most existing algorithms (e.g. k-means) become unfavorable due to the prohibitive time and space requirements. In this paper we propose the random locality sensitive vocabulary (RLSV) scheme towards efficient visual vocabulary construction in such scenarios. Integrating ideas from the Locality Sensitive Hashing (LSH) and the Random Forest (RF), RLSV generates and aggregates multiple visual vocabularies based on random projections, without taking clustering or training efforts. This simple scheme demonstrates superior time and space efficiency over prior methods, in both theory and practice, while often achieving comparable or even better performances. Besides, extensions to supervised and kernelized vocabulary constructions are also discussed and experimented with.KeywordsRandom ForestHash FunctionVisual WordReproduce Kernel Hilbert SpaceMean Average PrecisionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Recent work on the problem of mapping pipelined or parallel computations onto linear array, shared memory, and host-satellite systems is extended. It is shown how these problems can be solved even more efficiently when computation module execution times are bounded from below, intermodule communication times are bounded from above, and the processors satisfy certain homogeneity constraints. The improved algorithms have significantly lower time and space complexities than the more general algorithms: in one case, an O(nm/sup 3/) time algorithm for mapping m modules onto n processors is replaced with an O(nm log m) time algorithm, and the space requirements are reduced from O(nm/sup 2/) to O(m). Run-time complexity is reduced further with parallel mapping algorithms based on these improvements, which run on the architectures for which they create mappings.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A number of algorithms are available for computing the simulation relation on Kripke structures and on labelled transition systems representing concurrentsystems. Among them, the algorithm by Ranzato and Tapparo~[2007] has the best time complexity, while the algorithm by Gentilini et al.~[2003]~--~successivelycorrected by van Glabbeek and Ploeger~[2008]~--~has thebest space complexity. Both space and time complexities are critical issues in a simulation algorithm, in particular memory requirements are crucial in the context of model checking when dealing with large state spaces.We propose here a new simulation algorithm thatis obtained as a space saving modification of the time efficient algorithm by Ranzato and Tapparo: a symbolic representation of sets is embedded in thisalgorithm so that any set of states manipulated by the algorithm can be efficiently stored as a set of blocks of a suitable state partition. It turns out that this new simulation algorithm retains a space complexity comparable with Gentilini et al.'s algorithm while improving on Gentilini et al.'s time bound.

Recognition of multiple moving objects is a very important task for achieving user-cared knowledge to send to the base station in wireless video-based sensor networks. However, video based sensor nodes, which have constrained resources and produce huge amount of video streams continuously, bring a challenge to segment multiple moving objects from the video stream online. Traditional efficient clustering algorithms such as DBSCAN cannot run time-efficiently and even fail to run on limited memory space on sensor nodes, because the number of pixel points is too huge. This paper provides a novel algorithm named Inter-Frame Change Directing Online clustering (IFCDO clustering) for segmenting multiple moving objects from video stream on sensor nodes. IFCDO clustering only needs to group inter-frame different pixels, thus it reduces both space and time complexity while achieves robust clusters the same as DBSCAN. Experiment results show IFCDO clustering excels DBSCAN in terms of both time and space efficiency.