Stage 1: Break down the problem to that of covering a single interval.
Find the union of pairs in $A$ as follows:
Sort the intervals in $A$ by their starting position.
Go over them to find the first point that is not covered. Create an interval for this part. Repeat this starting from the left point of the next interval.
At the end we will have a list of non-overlapping intervals.
Call it $C$.
Note that we can break down the problem to the problem of covering a single interval in $C$. There are no intervals in $A$ that intersect more than one interval in $C$. So the problem is reduced to the problem of covering a given interval $[l,r]$ with the smallest number of intervals from $A$.
Stage 2: Find the smallest cover for each interval in $C$ using dynamic programming.
We use dynamic programming. Note that we only need to care about the end-points of intervals in $A$ that fall in $[l,r]$.
Sort the intervals in the increasing order according to their right end-points. If an interval is contained in another one remove it (remove redundant intervals).
Let $I_1,\cdots,I_n$ be the list of intervals in $A$. Let $l_k$ and $r_k$ refer to the index of the left and right end-points of interval $I_k$. Let the end-points of intervals in $A$ be $l=p_1< \cdots < p_m=r$.
We will use the dynamic programming with the following table:
$T[j,k]= \text{the size of smallest cover of $[p_1,p_j]$ using the first $k$ intervals.}$
In the following we explain how to compute $T[j,k]$.
If $j > r_k$ we cannot cover the interval as it is the interval with the right most end-point among $I_1,\cdots,I_k$. So there is no covering and we save value $\infty$.
In case $j \leq r_k$, we consider two cases: we use $I_k$ or we don't use it.
If we use $I_k$, we look for the smallest cover of $[p_1,p_{l_k}]$ with the first $k-1$ intervals. So we look at $T[l_k,k-1]$ and add one.
If we don't use $I_k$, we look for the smallest cover of $[p_1,p_j]$ with the first $k-1$ intervals. So we look at $T[j,k-1]$.
$$T[j,k] =
\begin{cases}
\min \{T[j,k-1] ,T[l_k,k-1]+1\} & j \leq r_k \\
\infty & o.w.
\end{cases}$$
Analysis: The worst-case running-time of the algorithm (on a RAM machine) is $O(n^2)$ where $n$ is the number of intervals.