4. Counting number of inversions. We are given a sequence of n distinct numbers a1,..., an. We define an inversion to be a pair i aj. Give an O(nlogn) algorithm to count the number of inversions. (Hint: Consider modifying Merge Sort to return both the sorted array and the number of inversions. Use recursion to sort and count the inversions of the two halves. Then, during the merging process, count the number of inversions needed for the current recursive step.)

4. Counting number of inversions. We are given a sequence of n distinct numbers a1,..., an. We define an inversion to be a pair i aj. Give an O(nlogn) algorithm to count the number of inversions. (Hint: Consider modifying Merge Sort to return both the sorted array and the number of inversions. Use recursion to sort and count the inversions of the two halves. Then, during the merging process, count the number of inversions needed for the current recursive step.)

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

Consider the following problems for recursive definition/solution. Answer the following questions. [Remember that a recursive definition/solution requires base case and recursive case] Consider a list of numbers A {55,12,53,56,24,1,7,42}. Sort is by using Merge Sort. Show each step in dividing the list and conquering/combining it.
See the pseudo-code of the Binary Search using recursion below. Fill in the XXXX and YYYY in the code Algorithm BinarySearch (A,v,low,hi) Input: array A indexed from low to hi with items sorted from smallest to largest. We are searching for the item v Output: returns a location index of item v in array A; if v is not found, -1 is returned. if (low > hi) then return (-1); mid = (lo + hi)/2; if (A[mid] = v) then == return(mid); if (A[mid] < v) then return(BinarySearch(A, XXXX ,hi, v)); else return(BinarySearch(a, lo, YYYY, v)); О а. ХX: lo+1, YҮҮ: hi O b. XXXX: mid, YYYY: mid О с. ХXXX: lo, YYYY: hi O d. XXXX: lo+1, YYYY: hi-1 O e. XXXX: mid+1. YYYY: mid-1
Consider the following variant of Mergesort. If the array has more thantwo elements, it recursively sorts the first two-third and the last one-third. Then, it mergesthe first two-third with the last one-third. If the array has at most two elements, then ittrivially sorts the array. For completeness, here is the pseudocode for sorting the arrayA[l..r]. Write a recurrence relation for the worst-case running time of Newsort. Solve the recurrencerelation to obtain aΘ-bound on the running time of the algorithm, in terms of the lengthnof the array. You must use the tree method to solve the recurrence. You may also ignorefloors and ceilings in your calculations.
The following algorithm returns the position of the largest element in the array S. Write a recurrence equation for the number of comparisons tn needed to find the largest element. Use induction to show that the equation has the solution tn = n − 1. The top-level call is max position (1, n).
The recursive algorithm below takes as input an array A of distinct integers, indexed between s andf, and an integer k. The algorithm returns the index of the integer k in the array A, or ?1 if the integerk is not contained within A. Complete the missing portion of the algorithm in such a way that you makethree recursive calls to subarrays of approximately one third the size of A.• Write and justify a recurrence for the runtime T(n) of the above algorithm.• Use the recursion tree to show that the algorithm runs in time O(n).FindK(A,s,f,k)if s < fif f = s + 1if k = A[s] return sif k = A[f] return felseq1 = b(2s + f)=3cq2 = b(q1 + 1 + f)=2c... to be continued.else... to be continued.
01... ""Implementation of the Misra-Gries algorithm.Given a list of items and a value k, it returns the every item in the listthat appears at least n/k times, where n is the length of the array By default, k is set to 2, solving the majority problem. For the majority problem, this algorithm only guarantees that if there isan element that appears more than n/2 times, it will be outputed. If thereis no such element, any arbitrary element is returned by the algorithm.Therefore, we need to iterate through again at the end. But since we have filtredout the suspects, the memory complexity is significantly lower thanit would be to create counter for every element in the list. For example:Input misras_gries([1,4,4,4,5,4,4])Output {'4':5}Input misras_gries([0,0,0,1,1,1,1])Output {'1':4}Input misras_gries([0,0,0,0,1,1,1,2,2],3)Output {'0':4,'1':3}Input misras_gries([0,0,0,1,1,1]Output None"""..
Modify the Partition function so that after running it, any input array A is partitioned into three parts: the left part consisting of all elements < pivot, the middle part consisting of all elements = pivot, and the right part consisting of the rest Write down the pseudo-code for this modified version of the Partition function. (must be an in-place algorithm with Θ(n) time complexity.) Hint: Define three indices: i as the end of the left part, k as the end of the middle part, and j denoting the current index which is used in the for-loop.
II. Read each problem carefully and present an algorithm with the required running-time to solve each problem. 2. Let A be a sorted array of integers. You want to implement two functions: update (i, x) - which takes as input an index i in A and sets A[i] = x. For example, calling update (3,10) will set A[3] = 10. Note that array A might not be completely sorted after an update. is Sorted (i) - returns true if the subarray A[0... i] is sorted, otherwise it returns false. A straightforward implementation of the two operations using only the given array can be done as follows: update operation can directly change the value of A[i] to x. is Sorted will scan A[0] up to A[i] while checking if elements are non-decreasing. With the above implementations, update takes 0(1) time but is Sorted takes O(n) time. a. Give another implementation where update takes O(n) time while isSorted takes O(1) time. b. Describe how to use a balanced BST to implement both operations in O(log n) time. Discuss why…
II. Read each problem carefully and present an algorithm with the required running-time to solve each problem. 2. Let A be a sorted array of integers. You want to implement two functions: . update(i, x) - which takes as input an index i in A and sets A[i] = x. For example, calling update (3,10) will set A[3] = 10. Note that array A might not be completely sorted after an update. is Sorted(i) returns true if the subarray A[0... i] is sorted, otherwise it returns false. A straightforward implementation of the two operations using only the given array can be done as follows: update operation can directly change the value of A[i] to x. is Sorted will scan A[0] up to A[i] while checking if elements are non-decreasing. With the above implementations, update takes O(1) time but is Sorted takes O(n) time. b. Describe how to use a balanced BST to implement both operations in O(log n) time. Discuss why your implementation is correct, preferably using diagrams.
AssuAssume we want to analyze empirically 4 variants of the Quicksort algorithm by varying the selection of the pivot and the recursive call as follows: ● Try the following values when selecting a pivot: - Pick the last element as pivot - Pick a random element as pivot ● Do not make a recursive call to QuickSort when the list size falls below a given threshold, and use Insertion Sort to complete the sorting process instead. Try the following values for the threshold size: - Log2(N) - Sqrt(N) Therefore, you are asked: a. (12 points) Write the java code for the 4 Quicksort implementations. b. (5 points) Write a driver program that allows you to measure the running time in milliseconds of the 4 implementations for N = 10000, 20000, 40000, 80000 and 160000. For each data size N, generate a random list of N random integers ranging from 1 to 107 and use the same list to measure the running time of the 4 implementations. Present the results in the following table:me we want to analyze…
The following is a code for Bubble Sort... But a reversed one. (It sorts the array in descending order!) Determine and prove the loop invariant of the following code.
We can express insertion sort as a recursive procedure as follows. In order to sort A[1..n], we recursively sort A[1 .. n − 1] and then insert A[n] into the sorted array A[1..n- ..n - 1]. Write a recurrence for the running time of this recursive version of insertion sort.