Comparison between AC and DC power flow analyses
The DC load flow is based on the Fast Decoupled Load Flow introduced by Stott and Alsac in 1974.

Stott and Alsac proposed the new sequential algorithm for solving classic power flow problems. The FDLF algorithm is very fast because it exploits the loose physical connection between active (MW) and reactive (MVAr) power flow in transmission systems.

\begin{align*}
P_i = \sum_{k=1}^N|V_i||V_k|(G_{ik}\cos(\theta_{i}-\theta_k) + B_{ik}\sin(\theta_i-\theta_k)\\
Q_i = \sum_{k=1}^N|V_i||V_k|(G_{ik}\sin(\theta_{i}-\theta_k) - B_{ik}\cos(\theta_i-\theta_k)
\end{align*}

In a transmission system, both G and the difference in voltage angles over a line will be small. This means that reasonable approximations are G = 0, sin(øi-øk) = (øi-øk) and cos(øi-øk) = 1.  

The two (simplified) equations above are calculated sequentially, where the voltage magnitudes are constant in the first, and voltage angles are constant in the second. Note that it's not P and Q that are calculated in the two equations, but the voltage angles and magnitudes. After calculating the angles, these are used when calculating reactive power mismatch. This reactive power mismatch is used as Q when calculating the voltage magnitudes. The updated voltage magnitudes and angles are used to calculate the active power mismatch, P, which again is used to update the angles. This iterative process goes on until the desired accuracy is achieved. At last, the angles and magnitudes are used to calculate the branch flows.

\begin{align*}
Q_i = -b_k +\sum_{j=1,j\neq k}^N|b_{kj}|(|V_k|-|V_j|)\\
P_i = \sum_{j=1,j\neq k}^N(|B_{kj}|(\theta_k-\theta_j))\\
\end{align*}

As you can see, the voltage angles are not included when calculating the reactive power, whereas the voltage magnitude is not included when calculating the active power flow. Nevertheless, the expressions gives the exact power injections (to the desired accuracy).

The reason why this is accurate is because the voltage magnitudes are used when calculating the angles, and vice-versa. They are therefore not needed when calculating the power injections.   

In the DC power flow, the iterative process described above is skipped. This means that the voltage angles are calculated without taking reactive power and voltage magnitudes into consideration. Now, the real power injection will be calculated the exact same way as above, using the same equation:

\begin{align*}
P_i = \sum_{j=1,j\neq k}^N(|B_{kj}|(\theta_k-\theta_j))\\
\end{align*}

The difference now is that the voltage angles won't be accurate, as the iterative steps are skipped. The solution is therefore only an approximation. 

Now, if you try to use these angles and unity voltage to calculate the reactive power flow you won't get the desired results. As you can see from above, you can't use any of the approximations used in the FDLF algorithm, as the voltage angles aren't included in the final power injection equations. Therefore, you would need to use the equations in the top:

\begin{align*}
Q_i = \sum_{k=1}^N|V_i||V_k|(G_{ik}\sin(\theta_{i}-\theta_k) - B_{ik}\cos(\theta_i-\theta_k)
\end{align*}

Here, the simplifications the Gik*sin(øi-øk) will be very close to zero, and Bik*cos(øi-øk) will be very close to Bik. The most dominant terms in this equation will therefore be |Vi||Vk|. Now, these are unity, thus the result will be close to just Bik, which obviously can't be correct.

You could however use the angles calculated in the DC load flow, calculate the reactive power mismatch, and use this to get updated voltage magnitudes and thus an approximation to the reactive power flow. As you might realize, that's identical to the first iteration of the FDLF algorithm. You might be lucky and get a good approximation, but it may just as well be way off.

Note that the DC approximation is only good in transmission systems and other systems where X/R is high (preferably >10). The FDLF algorithm may be used in systems with lower X/R ratio, but the convergence characteristic will be very bad, thus the Full Newton-Rhapson Load Flow algorithm will probably be faster.