Question

I have the following problem:

• Let there be n projects.
• Let Fi(x) equal to the number of points you will obtain if you spent
  x units of time working on project i.
• You have T units of time to use and work on any project you would
  like.

The goal is to maximize the number of points you will earn and the F functions are non-decreasing.

The F functions have diminishing marginal return, in other words spending x+1 unit of time working on a particular project will yield less of an increase in total points earned from that project than spending x unit of time on the project did.

I have come up with the following O(nlogn + Tlogn) algorithm but I am supposed to find an algorithm running in O(n + Tlogn):

sum = 0
schedule[]
gain[] = sort(fi(1))

for sum < T
    getMax(gain) // assume that the max gain corresponds to project "P"
    schedule[P]++
    sum++
    gain.sortedInsert(Fp(schedule[P] + 1) - gain[P])
    gain[P].sortedDelete()

return schedule

That is, it takes O(nlogn) to sort the initial gain array and O(Tlogn) to run through the loop. I have thought through this problem more than I care to admit and cannot come up with an algorithm that would run in O(n + Tlogn).

Answer 1

For the first case, use a Heap, constructing the heap will take O(n) time, and each ExtractMin & DecreaseKey function call will take O(logN) time.

For the second case construct a nXT table where ith column denotes the solution for the case T=i. i+1 th column should only depend on the values on the ith column and the function F, hence calculatable in O(nT) time. I did not think all the cases thoroughly but this should give you a good start.