Consider array A of n numbers. We want to design a dynamic programming algorithm to find the maximum sum of consecutive numbers with at least one number. Clearly, if all numbers are positive, the maximum will be the sum of all the numbers. On the other hand, if all of them are negative, the maximum will be the largest negative number. The complexity of your dynamic programming algorithm must be O(n²). However, the running time of the most efficient algorithm is O(n). Design the most efficient algorithm you can and answer the following questions based on it. To get the full points you should design the O(n) algorithm. However, if you cannot do that, still answer the following questions based on your algorithm and you will get partial credit. (a) tion(s) to subproblem(s). Briefly explain how it computes the solution. Do not forget the base case(s) of your recursion. Write the recursion that computes the optimal solution recursively based on the solu-

Consider array A of n numbers. We want to design a dynamic programming algorithm to find the maximum sum of consecutive numbers with at least one number. Clearly, if all numbers are positive, the maximum will be the sum of all the numbers. On the other hand, if all of them are negative, the maximum will be the largest negative number. The complexity of your dynamic programming algorithm must be O(n²). However, the running time of the most efficient algorithm is O(n). Design the most efficient algorithm you can and answer the following questions based on it. To get the full points you should design the O(n) algorithm. However, if you cannot do that, still answer the following questions based on your algorithm and you will get partial credit. (a) tion(s) to subproblem(s). Briefly explain how it computes the solution. Do not forget the base case(s) of your recursion. Write the recursion that computes the optimal solution recursively based on the solu-

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

Suppose that each row of an n × n array A consists of 1's and 0's such that in any row of A all the 1's come before any O's in that row. Assuming that A is already in memory, describe an algorithm running in O(n) time for finding the row that contains the most 1's. Write the algorithm following the style of your course-notes.
Suppose that you have five different algorithms (A, B, C, D and E) for solving a problem. To solve a problem of size n, the number of operations used by each algorithm is as follows. As n grows, which algorithm uses the most operations? Algorithm number of operations n2+n3 B 2n+1 log n' 26+ log n n(logn)? +1 n100 Algorithm D Algorithm C Algorithm A Algorithm B o Algorithm E
1. Asymptotics. Given an array A of n integers, you'd like to output a two-dimensional n x n array B in which B[i, j] = max {A[i], A[i + 1],..., A[j]} for each i < j. For i j the value of B[i, j] can be left as is. for i = 1,2, η for j = i + 1, n " Compute the maximum of the entries A[i], A[i + 1], , A[j]. Store the maximum value in B[i, j]. (a) Find a function of such that the running time of the algorithm is O(f(n)), and clearly explain why. (b) For the same function f argue that the running time of the algorithm is also (f(n)). (This establishes an asymptotically tight bound (f(n)).) (c) Design and analyze a faster algorithm for this problem. You should give an algorithm with running O(g(n)), where lim→∞ g(n)/f(n) = 0.
You want to design an algorithm, called minMax(A,p,r), that takes an array of integers and indexes of the first and last elements, and returns the minimum and maximum values in that range. Now write the pseudo code of a divide and conquer (and therefore, recursive) algorithm with the same time complexity (Θ(n)). You can assume that p ≤ r. Also, in your code, you can return two numbers by returning a pair, e.g. “return (a, b)”, and can save the output in a similar way, e.g. “(a, b) = minMax(parameters)”. (Short answer please)
I need the answer as soon as possible
Program this
Let A be an array of size n storing positive integers. Write an algorithm(pseudo code) that takes array A and replaced each unique element of A by-1. For example, if A=(5,20,41,5,35,6,6) then after you run the algorithm, A=(5,-1,-1,5,-1,6,6). Compute time complexity of your algorithm.
In Python: Let n be a (large) positive integer of your choice. We want to know which of the two Quicksort algorithms methods (he Lomuto method and the Hoare method) is superior when sorting arrays containing n elements. To answer this question, you will run Quicksort on 10000 random permutations of [1,2,3, . . . , n], on each of your two Quicksort algorithms.
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
Below is a list of functions that commonly appear in complexity analyzes as a function of the size n of the problem. Sort the functions in ascending order of growth rate, that is, the slowest growing one is 1, and so on. Note that the functions are described in the notation O(.), which represents the cost of the algorithm as a function of the predominant term of the cost expression.
Consider the following three sorting algorithms: Insertion Sort, Heapsort, and Quicksort. Here are three statements. A. Iam an incredibly fast sorting algorithm that runs in O(n log n) time on average, though my worst case run time is O(n2). B. I run very quickly for small values of n, but unfortunately am really slow when n is large. My average run time is O(n2). C. I am an in-place sorting algorithm whose average case and worst case running time is O(n log n). For each statement (A, B, C), determine the correct sorting algorithm.
Consider the following recursive algorithm, where // denotes integer division: 3//2 = 1, 5//2 = 2, etc. F(n):if n <= 1: returnF(n//2)for i from 0 to n for j from 0 to n//2 print(i+j) Let function T(n) denote the running time of this algorithm. Derive T(n) and prove its worst case timecomplexity