Greedily assigning scores to maximize the final result - c++

Question

You are given a time line of T days and a list of N scores. You have to assign each score to a day(among 1 to T) such that the total assigned score maximizes.
Although there are restrictions. Each score can be assigned to only a limited number of days X and also can be assigned to days occuring on or after a particular number Y.
Input is in the given Format :
T
N
Score X Y (150 4 1 means Score 150 can be assigned to atmost 4 days on or after day 1)
For eg :
T = 10
N = 5
150 4 1
120 4 3
200 2 7
100 10 5
50 5 1
Note = 2 Scores can have same value . Each day can be assigned at most 1 score.
The optimum result for above example would be : 150 150 150 150 120 120 200 200 120 120.
What i tried :
I sorted the list according to the scores and started assigning the highest scores first.
In the above example I would start with 200 and assign it to 7 and 8 days.
Similarly I would assign the next highest score 150 to 1,2,3 and 4 days.
and so on ...
But this would take O(N * T) time. N for iterting over list of scores and T for checking and assigning scores over the time line(in the worst case).
The goal is to maximise and calculate the final score.
Is there a more elegant way to do this? Like without even assigning the scores and thus doing away with the T part of O(N * T).

Answer 1

I coded up a pretty straight forward implementation of your algorithm:
#include <vector>
#include <algorithm>
#include <array>
constexpr int T = 10;
struct Item {
int score;
int count;
int min;
};
std::array<Item, 5> input={{
{150, 4, 1},
{120, 4, 3},
{200, 2, 7},
{100, 10, 5},
{50, 5, 1}
}};
std::array<bool, T> days{};
int main() {
// preprocess input
std::sort(input.begin(), input.end(), [](auto l, auto r) {return l.score > r.score; });
int totalScore = 0;
int lastFreeDay = T - 1;
[&] {
for (auto spec : input) {
// scan forward to find open spots for the scores
for (int pos = spec.min-1; spec.count && pos < lastFreeDay; ++pos) {
if (!days[pos]) {
days[pos] = true;
totalScore += spec.score;
spec.count--;
}
}
// we weren't able to assign all scores of this entry,
// so every day after spec.min has already a score assigned to it.
// lets scan backward and see where the last free one is
if (spec.count > 0) {
lastFreeDay = spec.min;
while (days[lastFreeDay]) {
if (--lastFreeDay == -1) {
return;
}
}
}
}
}();
return totalScore;
}
I'm not sure what the exact algorithmic complexity is, but you can see two things:
At the beginning, there are very few collisions, so the inner loop doesn't actually depend on T, so it behaves more like O(N*k) (where k is the average number of times you can assign a particular score).
Even if N grows very large, not all scores can actually be processed, because the algorithm can terminate early and compares the latest free day against the earliest da a score can be assigned to.
Of course, you can create an worst case input, where you have T*(T+1)/2 passes of the inner loop (for N == T and k = 1 and min_i = 1) but my gut feeling is that on average it is much better than O(N*T) or at least has a very small constant (actually, the sort could be the dominant factor).
Long story short: I'm pretty confident that your algorithm is in fact applicable in practice and could probably be further improved by more intelligent data structures as suggested by Prune.

Answer 2

If you maintain a table of available intervals, I believe that you can keep this to O(N + T). Don't range through the entire length T each time; just check your list of open intervals and begin at the first available interval that contains the input line's Y value. There will be no more than N/2 intervals in this "open" list, and either hashing or a binary search can keep the complexity under control.