Problem 4. Let S be a dynamic set of integers. At the beginning, S is empty. Then, new integers are added to it one by one, but never deleted. Let k be a fixed integer. Describe an algorithm to maintain the k largest integers in S. Your algorithm must use O(k) space at all times, no matter how large |S| is (note that |S| increases continuously, but your space cannot). Furthermore, it must process every integer insertion in O(log k) time. For example, suppose that k = 3, and that the sequence of integers inserted is 83, 21, 66, 5, 24, 76, 92, 32, 43... Your algorithm must be keeping {83,66, 24} after the insertion of 24, {83, 66, 76} after the insertion of 76, and {83, 76, 92} after the insertion of 43.

Problem 4. Let S be a dynamic set of integers. At the beginning, S is empty. Then, new integers are added to it one by one, but never deleted. Let k be a fixed integer. Describe an algorithm to maintain the k largest integers in S. Your algorithm must use O(k) space at all times, no matter how large |S| is (note that |S| increases continuously, but your space cannot). Furthermore, it must process every integer insertion in O(log k) time. For example, suppose that k = 3, and that the sequence of integers inserted is 83, 21, 66, 5, 24, 76, 92, 32, 43... Your algorithm must be keeping {83,66, 24} after the insertion of 24, {83, 66, 76} after the insertion of 76, and {83, 76, 92} after the insertion of 43.

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

We will be looking at a problem known as the partition problem. The partition problem is to determineif a given set can be partitioned into two subsets such that the sum of elements in both subsets is thesame. This is a variant of the 0-1 knapsack problem.Instead of printing 'Set can be partitioned', use Backtracking so that the python program print the partitioned subsets.Python program:# Returns true if there exists a sublist of list `nums[0…n)` with the given sum def subsetSum(nums, total): n = len(nums) # `T[i][j]` stores true if subset with sum `j` can be attained # using items up to first `i` items T = [[False for x in range(total + 1)] for y in range(n + 1)] # if the sum is zero for i in range(n + 1): T[i][0] = True # do for i'th item for i in range(1, n + 1): # consider all sum from 1 to total for j in range(1, total + 1): # don't include the i'th element if `j-nums[i-1]` is negative if…
Question 2: Implement sequential search and binary search algorithms on your computer. Note down run time for each algorithm on arrays of size (1, 250, 500, 750, 1000, 1250, 1500, 5000). For both algorithms, store the values 0 throughn 1 in order in the array, and use a variety of random search values in the range 0 to n 1 on each size n. Graph the resulting times. When is sequential search faster than binary search for a sorted array? Solution: Execution Time for Input Size(N) Search Element Execution Time for Sequential Search(n) Binary Search(logn)
Input: An odd integer B, and a set A= {a_1, . .. , a_2n} of 2n distinct positive integers. Question: Decide whether A can be partitioned inton disjoint pairs (a_i, a_j), where 1 s i
Algorithm Analysis Java
Now let's examine a Dynamic Program algorithm to solve this problem. 3.3 Let's say we have an array of length X+1. How would we define array[x]? or What is array[x] defined for?
Consider the following algorithms. Each algorithm operates on a list containing n elements, where nis a very large integer. I. An algorithm that accesses each element in the list twice II. An algorithm that accesses each element in the list n times III. An algorithm that accesses only the first 10 elements in the list, regardless of the size of the list Which of the algorithms run in reasonable time? A I only B III only I and II only D I, II, and II
Many computer applications involve searching through a set of data and sorting the data. A number of effi cient searching and sorting algorithms have been devised in order to reduce the runtime of these tedious tasks. In this problem we will consider how best to parallelize these tasks.Consider the following binary search algorithm (a classic divide and conquer algorithm) that searches for a value X in a sorted N-element array A and returns the index of matched entry:BinarySearch(A[0..N−1], X) {low = 0high = N −1while (low <= high) {mid = (low + high) / 2if (A[mid] >X)high = mid −1else if (A[mid] <X)low = mid + 1elsereturn mid // found}return −1 // not found}Assume that you have Y cores on a multi-core processor to run BinarySearch. Assuming that Y is much smaller than N, express the speedup factor you might expect to obtain for values of Y and N. Plot these on a graph.Next, assume that Y is equal to N. How would this affect your conclusions in your previous answer? If you…
Given an unsorted array of integers, write a function in Python to find the length of the longest increasing subsequence (LIS) in the array. For example, given the array [10, 9, 2, 5, 3, 7, 101, 18], the LIS is [2, 3, 7, 101], which has a length of 4. Your solution should have a time complexity of O(n log n), where n is the length of the input array. Here's some code to get you started: def longest increasing_subsequence(arr): # TODO: implement function pass # example usage arr = [10, 9, 2, 5, 3, 7, 101, 18] print(longest_increasing_subsequence(arr)) # should print 4
Compute time complexity of the given program. The complexity computation should be for the complete program. Map it on its relevant standard function. Computation should be clear. void swap(int *xp, int *yp) { int temp = *xp; *xp = *yp; *yp = temp; } // A function to implement bubble sort void bubbleSort(int arr[], int n) { int i, j; for (i = 0; i < n-1; i++) // Last i elements are already in place for (j = 0; j < n-i-1; j++) if (arr[j] > arr[j+1]) swap(&arr[j], &arr[j+1]); } /* Function to print an array */ void printArray(int arr[], int size) { int i; for (i = 0; i < size; i++) cout << arr[i] << " "; cout << endl; }
Code in python only.
Given a sorted array of n comparable items A, and a search value key, return the position (array index) of key in A if it is present, or -1 if it is not present. If key is present in A, your algorithm must run in order O(log k) time, where k is the location of key in A. Otherwise, if key is not present, your algorithm must run in O(log n) time.
Problem 2. Suppose we have an array A[1 : n] which consists of numbers {1,...,n} written in some arbitrary order (this means that A is a permutation of the set {1,...,n}). Our goal in this problem is to design a very fast randomized algorithm that can find an index i in this array such that A[i] mod 8 € {1,2}, i.e., the reminder of dividing A[i] by 8 is either 1 or 2. For simplicity, in the following, we assume that n itself is a multiple of 8 and is at least 8 (so a correct answer always exist). For instance, if n = 8 and the array is A = [8,7, 2,5, 4, 6,3, 1], we want to output either of indices 3 or 8. (a) Suppose we sample an index i from {1,...,n} uniformly at random. What is the probability that i is a correct answer, i.e., A[i] mod 8 E {1,2}? (b) Suppose we sample m indices from {1,...,n} uniformly at random and with repetition. What is the probability that none of these indices is a correct answer? Now, consider the following simple algorithm for this problem: Find-Index-1(A[1:…