<p>Suppose I have an interval (a,b), and a number of subintervals {(a<sub>i</sub>,b<sub>i</sub>)}<sub>i</sub> whose union is all of (a,b).  Is there an efficient way to choose a minimal-cardinality subset of these subintervals which still covers (a,b)?</p>

Sounds like dynamic programming.
Here's an illustration of the algorithm (assume intervals are in a list sorted by ending time):
```
```
//works backwards from the end
int minCard(int current, int must_end_after)
{
    if (current < 0)
        if (must_end_after == 0)
            return 0; //no more intervals needed
        else
            return infinity; //doesn't cover (a,b)
        
    if (intervals[current].end < must_end_after)
        return infinity; //doesn't cover (a,b)
   
    return min( 1 + minCard(current - 1, intervals[current].start),
                    minCard(current - 1, must_end_after) );
    //include current interval or not?
}
```
```
But it should also involve caching (memoisation).