Results 1 
8 of
8
Active Learning on Trees and Graphs
"... We investigate the problem of active learning on a given tree whose nodes are assigned binary labels in an adversarial way. Inspired by recent results by Guillory and Bilmes, we characterize (up to constant factors) the optimal placement of queries so to minimize the mistakes made on the nonqueried ..."
Abstract

Cited by 19 (3 self)
 Add to MetaCart
(Show Context)
We investigate the problem of active learning on a given tree whose nodes are assigned binary labels in an adversarial way. Inspired by recent results by Guillory and Bilmes, we characterize (up to constant factors) the optimal placement of queries so to minimize the mistakes made on the nonqueried nodes. Our query selection algorithm is extremely efficient, and the optimal number of mistakes on the nonqueried nodes is achieved by a simple and efficient mincut classifier. Through a simple modification of the query selection algorithm we also show optimality (up to constant factors) with respect to the tradeoff between number of queries and number of mistakes on nonqueried nodes. By using spanning trees, our algorithms can be efficiently applied to general graphs, although the problem of finding optimal and efficient active learning algorithms for general graphs remains open. Towards this end, we provide a lower bound on the number of mistakes made on arbitrary graphs by any active learning algorithm using a number of queries which is up to a constant fraction of the graph size.
A framework for speeding up priorityqueue operations
, 2004
"... Abstract. We introduce a framework for reducing the number of element comparisons performed in priorityqueue operations. In particular, we give a priority queue which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the worstcase cost of O(log n) with at most log n + O ..."
Abstract

Cited by 8 (7 self)
 Add to MetaCart
(Show Context)
Abstract. We introduce a framework for reducing the number of element comparisons performed in priorityqueue operations. In particular, we give a priority queue which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the worstcase cost of O(log n) with at most log n + O(1) element comparisons per minimum deletion and deletion, improving the bound of 2log n + O(1) on the number of element comparisons known for binomial queues. Here, n denotes the number of elements stored in the data structure prior to the operation in question, and log n equals max {1,log 2 n}. We also give a priority queue that provides, in addition to the abovementioned methods, the prioritydecrease (or decreasekey) method. This priority queue achieves the worstcase cost of O(1) per minimum finding, insertion, and priority decrease; and the worstcase cost of O(log n) with at most log n + O(log log n) element comparisons per minimum deletion and deletion. CR Classification. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data
Two new methods for transforming priority queues into doubleended priority queues
 CPH STL Report
, 2006
"... Abstract. Two new ways of transforming a priority queue into a doubleended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of doubleended priorityqueue operations. Using an efficient priority queue, the first transformation can pr ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
(Show Context)
Abstract. Two new ways of transforming a priority queue into a doubleended priority queue are introduced. These methods can be used to improve all known bounds for the comparison complexity of doubleended priorityqueue operations. Using an efficient priority queue, the first transformation can produce a doubleended priority queue which guarantees the worstcase cost of O(1) for findmin, findmax, and insert; and the worstcase cost of O(lg n) including at most lg n + O(1) element comparisons for delete, but the data structure cannot support meld efficiently. Using a meldable priority queue that supports decrease efficiently, the second transformation can produce a meldable doubleended priority queue which guarantees the worstcase cost of O(1) for findmin, findmax, and insert; the worstcase cost of O(lg n) including at most lg n + O(lg lg n) element comparisons for delete; and the worstcase cost of O(min {lg m, lg n}) for meld. Here, m and n denote the number of elements stored in the data structures prior to the operation in question, and lg n is a shorthand for log 2 (max {2, n}). 1.
An experimental evaluation of navigation piles
, 2006
"... Abstract. A navigation pile, which can be used as a priority queue, is an extension of a selection tree. In a compact form the whole data structure requires only a linear number of bits in addition to the elements stored. In this paper, we study the practical efficiency of three different implementa ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
Abstract. A navigation pile, which can be used as a priority queue, is an extension of a selection tree. In a compact form the whole data structure requires only a linear number of bits in addition to the elements stored. In this paper, we study the practical efficiency of three different implementations of navigation piles and compare their efficiency against two implementations of binary heaps. The results of our experiments show that navigation piles are a good alternative to heaps when element moves are expensive—even if heaps store pointers to elements instead of elements. Based on the experimental comparison of the three navigationpile implementations it is clear that care should be taken when applying space saving strategies that increase the number of instructions performed. In addition to our experimental findings, we give a new and simple way of dynamizing a static navigation pile. Furthermore, we introduce a pointerbased navigation pile which is inherently dynamic in its nature and can be made to support deletions as well. 1.
Priority queues and sorting for readonly data
 In Proceedings of the 10th Theory and Applications of Models of Computation, volume 7876 of Lecture Notes in Computer Science
, 2013
"... ..."
(Show Context)
A note on meldable heaps relying on datastructural bootstrapping∗
"... Abstract. We introduce a meldable heap which guarantees the worstcase cost of O(1) for findmin, insert, and meld with at most 0, 3, and 3 element comparisons for the respective operations; and the worstcase cost of O(lg n) with at most 3 lgn+ O(1) element comparisons for delete. Our data structur ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We introduce a meldable heap which guarantees the worstcase cost of O(1) for findmin, insert, and meld with at most 0, 3, and 3 element comparisons for the respective operations; and the worstcase cost of O(lg n) with at most 3 lgn+ O(1) element comparisons for delete. Our data structure is asymptotically optimal and nearly constantfactor optimal with respect to the comparison complexity of all the meldableheap operations. Furthermore, the data structure is also simple and elegant. 1.
Miniproject: Safe standardlibrary containers
"... Abstract. In this project the goal is to develop the safe * family of containers for the CPH STL. The containers to be developed should be safer and more reliable than any of the existing implementations. A special focus should be put on strong exception safety since none of the existing prototypes ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. In this project the goal is to develop the safe * family of containers for the CPH STL. The containers to be developed should be safer and more reliable than any of the existing implementations. A special focus should be put on strong exception safety since none of the existing prototypes available at the CPH STL can give this guarantee for all operations. In spite of the safety requirements, the strict runningtime requirements specified in the C++ standard, and additional requirements specified in the CPH STL design documents, must be fulfilled.
An extended truth about heaps ⋆
"... Abstract. We describe a number of alternative implementations for the heap functions, which are part of the C++ standard library, and provide a through experimental evaluation of their performance. In our benchmarking framework the heap functions are implemented using the same set of utility functio ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We describe a number of alternative implementations for the heap functions, which are part of the C++ standard library, and provide a through experimental evaluation of their performance. In our benchmarking framework the heap functions are implemented using the same set of utility functions, the utility functions using the same set of policy functions, and for each implementation alternative only the utility functions need be modified. This way the programs become homogeneous and the underlying methods can be compared fairly. Our benchmarks show that the conflicting results in earlier experimental studies are mainly due to test arrangements. No heapifying approach is universally the best for all kinds of inputs and ordering functions, but the bottomup heapifying performs well for most kinds of inputs and ordering functions. We examine several approaches that improve the worstcase performance and make the heap functions even more trustworthy. 1