SODA Jan 11, 2004Partial Sums1 Tight Bounds for the Partial-Sums Problem Mihai PǎtraşcuErik Demaine (presenting) MIT CSAIL.

Slides:



Advertisements
Similar presentations
Introduction to Algorithms
Advertisements

Xiaoming Sun Tsinghua University David Woodruff MIT
CSE 4101/5101 Prof. Andy Mirzaian Augmenting Data Structures.
COMP375 Computer Architecture and Organization Senior Review.
David Luebke 1 6/7/2014 CS 332: Algorithms Skip Lists Introduction to Hashing.
Cell-Probe Lower Bounds for Succinct Partial Sums Mihai P ă trașcuEmanuele Viola.
Succinct Data Structures for Permutations, Functions and Suffix Arrays
Algorithm Design Techniques: Greedy Algorithms. Introduction Algorithm Design Techniques –Design of algorithms –Algorithms commonly used to solve problems.
QuickSort Average Case Analysis An Incompressibility Approach Brendan Lucier August 2, 2005.
Arithmetic Coding. Gabriele Monfardini - Corso di Basi di Dati Multimediali a.a How we can do better than Huffman? - I As we have seen, the.
CSE332: Data Abstractions Lecture 14: Beyond Comparison Sorting Dan Grossman Spring 2010.
1 Cell Probe Complexity - An Invitation Peter Bro Miltersen University of Aarhus.
Advanced Algorithms Piyush Kumar (Lecture 12: Parallel Algorithms) Welcome to COT5405 Courtesy Baker 05.
(Data) STRUCTURES Mihai P ă trașcu. LSD dyn. marked ancestor reachability oracles in the butterfly partial match(1+ε)-ANN ℓ 1, ℓ 2 NN in ℓ 1, ℓ 2 3-ANN.
Divide-and-Conquer Recursive in structure –Divide the problem into several smaller sub-problems that are similar to the original but smaller in size –Conquer.
September 19, Algorithms and Data Structures Lecture IV Simonas Šaltenis Nykredit Center for Database Research Aalborg University
CSC1016 Coursework Clarification Derek Mortimer March 2010.
CPSC 689: Discrete Algorithms for Mobile and Wireless Systems Spring 2009 Prof. Jennifer Welch.
Approximate Range Searching in the Absolute Error Model Guilherme D. da Fonseca CAPES BEX Advisor: David M. Mount.
Tirgul 8 Universal Hashing Remarks on Programming Exercise 1 Solution to question 2 in theoretical homework 2.
Hash Tables1 Part E Hash Tables  
Facility Location with Nonuniform Hard Capacities Martin Pál Éva Tardos Tom Wexler Cornell University.
1 ES 314 Advanced Programming Lec 2 Sept 3 Goals: Complete the discussion of problem Review of C++ Object-oriented design Arrays and pointers.
Code Generation CS 480. Can be complex To do a good job of teaching about code generation I could easily spend ten weeks But, don’t have ten weeks, so.
5. 1 JPEG “ JPEG ” is Joint Photographic Experts Group. compresses pictures which don't have sharp changes e.g. landscape pictures. May lose some of the.
Towards Polynomial Lower Bounds for Dynamic Problems STOC 2010 Mihai P ă trașcu.
Computer Algorithms Lecture 11 Sorting in Linear Time Ch. 8
Mike 66 Sept Succinct Data Structures: Techniques and Lower Bounds Ian Munro University of Waterloo Joint work with/ work of Arash Farzan, Alex Golynski,
Slide 1 5. VHDL/Verilog Operators, Arrays and Indexes.
Hashtables David Kauchak cs302 Spring Administrative Talk today at lunch Midterm must take it by Friday at 6pm No assignment over the break.
Lecture 8. How to Form Recursive relations 1. Recap Asymptotic analysis helps to highlight the order of growth of functions to compare algorithms Common.
Problems and MotivationsOur ResultsTechnical Contributions Membership: Maintain a set S in the universe U with |S| ≤ n. Given an x in U, answer whether.
Space Efficient Data Structures for Dynamic Orthogonal Range Counting Meng He and J. Ian Munro University of Waterloo.
Unit III : Introduction To Data Structures and Analysis Of Algorithm 10/8/ Objective : 1.To understand primitive storage structures and types 2.To.
Brought to you by Max (ICQ: TEL: ) February 5, 2005 Advanced Data Structures Introduction.
Introduction n – length of text, m – length of search pattern string Generally suffix tree construction takes O(n) time, O(n) space and searching takes.
Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Cpt S 223 – Advanced Data Structures Course Review Midterm.
Sorting with Heaps Observation: Removal of the largest item from a heap can be performed in O(log n) time Another observation: Nodes are removed in order.
1 COMP3040 Tutorial 1 Analysis of algorithms. 2 Outline Motivation Analysis of algorithms Examples Practice questions.
Analyzing algorithms & Asymptotic Notation BIO/CS 471 – Algorithms for Bioinformatics.
TECH Computer Science Dynamic Sets and Searching Analysis Technique  Amortized Analysis // average cost of each operation in the worst case Dynamic Sets.
September 29, Algorithms and Data Structures Lecture V Simonas Šaltenis Aalborg University
Succinct Orthogonal Range Search Structures on a Grid with Applications to Text Indexing Prosenjit Bose, Carleton University Meng He, Unversity of Waterloo.
Lossless Compression CIS 465 Multimedia. Compression Compression: the process of coding that will effectively reduce the total number of bits needed to.
CSC 221: Recursion. Recursion: Definition Function that solves a problem by relying on itself to compute the correct solution for a smaller version of.
Module #12: Summations Rosen 5 th ed., §3.2 Based on our knowledge on sequence, we can move on to summations easily.
Algorithm Analysis CS 400/600 – Data Structures. Algorithm Analysis2 Abstract Data Types Abstract Data Type (ADT): a definition for a data type solely.
Introduction to Algorithms 6.046J/18.401J/SMA5503 Lecture 11 Prof. Erik Demaine.
Implicit Dictionaries with O(1) Modifications per Update and Fast Search Gianni Franceschini and Ian Munro  Elements kept in 1 st n positions of an array.
Data Structure II So Pak Yeung Outline Review  Array  Sorted Array  Linked List Binary Search Tree Heap Hash Table.
Advanced Data Structure By Kayman 21 Jan Outline Review of some data structures Array Linked List Sorted Array New stuff 3 of the most important.
Hashtables David Kauchak cs302 Spring Administrative Midterm must take it by Friday at 6pm No assignment over the break.
Lower bounds on data stream computations Seminar in Communication Complexity By Michael Umansky Instructor: Ronitt Rubinfeld.
Searching CSE 103 Lecture 20 Wednesday, October 16, 2002 prepared by Doug Hogan.
Internal Memory Pointer MachineRandom Access MachineStatic Setting Data resides in records (nodes) that can be accessed via pointers (links). The priority.
Dynamic Programming. What is Dynamic Programming  A method for solving complex problems by breaking them down into simpler sub problems. It is applicable.
F453 Module 8: Low Level Languages 8.1: Use of Computer Architecture.
Confluently Persistent Tries Eric Price, MIT joint work with Erik Demaine, MIT Stefan Langerman, Université Libre de Bruxelles.
Introduction to Algorithms
Data Structures: Disjoint Sets, Segment Trees, Fenwick Trees
Advanced Associative Structures
Data Structures: Segment Trees, Fenwick Trees
Introduction to Algorithms
Indistinguishability by adaptive procedures with advice, and lower bounds on hardness amplification proofs Aryeh Grinberg, U. Haifa Ronen.
It’s All (just) Bits 1) Numbers are bits 2) Text is bits
Topic 5: Heap data structure heap sort Priority queue
Data Structures & Algorithms
We have the following incomplete B&B tree:
Algorithms and Data Structures
Presentation transcript:

SODA Jan 11, 2004Partial Sums1 Tight Bounds for the Partial-Sums Problem Mihai PǎtraşcuErik Demaine (presenting) MIT CSAIL

SODA Jan 11, 2004Partial Sums2 The Problem Maintain A[1..n] under: update(k, Δ) modify A[k] = A[k] + Δ sum(k) report A[1] + … + A[k] select(x) return k such that sum(k) ≤ σ < sum(k+1) Motivation  range query (1D)  many applications in the literature list indexing, dynamic ranking [Dietz 89] dynamic arrays [Raman et al 2001] arithmetic coding [Fenwick 94] …  playground for lower bound techniques (many results)

SODA Jan 11, 2004Partial Sums3 Restricted models: group, semigroup  can only use algebraic operations as black box General models: RAM, cell probe  integers  word size: b ≥ lg n  update parameter Δ limited to δ bits ( δ ≤ b ) natural in applications all previous studies considered this

SODA Jan 11, 2004Partial Sums4 Results, old and new Upper bounds don’t use precomputed table standard operations (multiplication, shifts, bitwise) New, powerful lower bound technique ModelUpper BoundsLower Bounds semigroup O(lg n)Ω(lg n / lglg n) [Yao85] Ω(lg n) [HF98] group O(lg n)Ω(lg n / lglg n) [FS89] Ω(lg n) NEW RAM cell probe O(lg n / lglg n) for δ = O(lglg n) [Die89] O(lg n / lg (b / δ)) NEW Ω(lg n / lg b) [FS89] Ω(lg n / lg (b / δ)) NEW other: bit-probe model, dynamic word problems

SODA Jan 11, 2004Partial Sums5 Upper bounds: The Big Picture Build a tree with branching factor B ≈ b/δ Handle all operations in O(1) for arrays of size B  O(lg n / lg B) running times A[1]A[2]A[3]A[4]A[5]A[6]A[7]A[8]A[9]

SODA Jan 11, 2004Partial Sums6 Upper Bounds: The Small Picture  even with small δ, partial sums can get large after many updates  break each sum in two components: S[i] = B[i] + C[i] B[i] holds value of S[i] from some past moment C[i] holds more recent changes  after a few updates, B[i] is rebuilt (constant time, amortized)  C[i] must remain small after few updates  hold packed in a word and use multiplication tricks to update Select  break into runs of sums, separated by big gaps  use the fusion structure [FW93] to select among runs big gaps  infrequent updating  sums inside each run are close  delta-encode relative to head can pack in a word, and use more bit tricks

SODA Jan 11, 2004Partial Sums7 Lower Bounds: Trees Again?  bound only read instructions  build a tree over the sequence of operations (i.e. update, sum)  each read instruction is characterized by: read time r : the read happens while handling operation r write time w : the cell was last written while handling operation w Op1Op2Op3Op4Op5Op6Op7Op8 time wr

SODA Jan 11, 2004Partial Sums8 Lower Bounds: Node Complexity  associate each read with LCA(r, w)  prove average case lower bound for each node  sum up lower bounds  not double-counting  holds in average case Op1Op2Op3Op4Op5Op6Op7Op8 time wr LCA(r,w)

SODA Jan 11, 2004Partial Sums9 Lower Bounds: Encoding To prove lower bound for one node, consider scenario:  you don’t know anything about the left subtree  but you know all reads with r in the right subtree, and w in the left subtree  can simulate data structure, get output to queries from right subtree  output encodes a lot of info about left subtree  many read instructions wr not known known

SODA Jan 11, 2004Partial Sums10 Lower Bounds: Last Slide  idea works well for δ = b  problem for smaller δ : one word (or one read instruction) can contain a lot of information  solution: future request are unpredictable  unlikely that one read instruction helps future queries [ ~ round elimination lemma in communication complexity ]

SODA Jan 11, 2004Partial Sums11 Open Problems / Recent progress SOLVED: lower bound for select problem: output of query encodes little information SOLVED: lower bounds on tradeoff between update & query times SOLVED: technique applied to other problems (dynamic connectivity) These are harder. Require: smart encoding schemes, more probabilities OPEN: offline problem (likely very hard) OPEN: bit-probe model problem: cell addresses (not cell contents) make encoding large

SODA Jan 11, 2004Partial Sums12 The End