Get the naive approach out of the way: We have a set of $n$ candidate toys, out of which we need to select $k$ such that the total cost is equal to $d$.
Lets consider the most naive approach to check if $k$ such toys:
exhaustively consider all $\binom{n}{k}$ possible combinations of toys and for each such $k$-set check whether the total price is equal to $d$.
But,
$$
\binom{n}{k} \le n^{k}
$$
while for a given $k$-set, the total price is checked in $O(k)$.
Hence, the total running time for this naive procedure is
$$
O(k n^{k}).
$$
For $k=2$, this is clearly an $O(n^{2})$ algorithm, but not $o(n^{2})$.
Second approach. A second, relatively straightforward approach is to classify items in $d$ bins according to their price (like a histogram, but well.. not exactly). Why is this useful? If our final pair contains an item of cost $i$ (i.e., from bin $i$) then the second item must be from bin $d-i$.
Consider $d$ bins labeled $1, \dots, d$ with the $i$th bin corresponding to price $i$.
This can be implemented as array with $d$ entries; access of entry $i$ costs $O(1)$.
We scan the toys in $O(n)$ and place each toy in the suitable bin according to its price.
In fact, we do not need to store all items. All we want is to store one item per bin (if one exists). As a special case, if $d$ is even, then in bin $d/2$ we store up to two items because two items of price $d/2$ can give total price $d$, but this does not affect the total complexity.
We scan the toys, and if a toy has price $i$ we access bin $i$ in $O(1)$, check if it is empty. If not, we can discard the item (because we already have an item of price $i$). If the bin is empty, we put that item in bin $i$. (As already mentioned, special care is taken for bin $d/2$ when $d$ is even.)
This procedure is completed in $O(n)$.
Now, if we choose an item/toy from bin $i$, $1\le i < d$, then the second toy can only be in bin $d-i$. We can scan the bins as follows: check if bins $d-1$ and $1$ are empty. If both are not empty, then return the items stored in the two bins.
If either or both are empty, continue by checking bins $2$ and $d-2$.
This procedure can be completed in $O(d)$, and hence the entire procedure is completed in time $O(n+d)$.
If $d = o(n^{2})$, then this algorithm satisfies our requirements.
If not, we would have see how to improve it.
Third approach: A third approach is to sort the $n$ items according to their price from lowest to highest price. This takes $O(n \log n)$. Once we have the sorted array of items, we can start scanning from the first and last position (keeping two pointers, call them left and right). If the total price is greater than $d$, then we have to reduce it, so we move the right pointer one position to the left. If the price is less than $d$, we move the left pointer one position to the right. See where this is going? This procedure is dominated by the original sorting and is done in $O(n\log n) = o(n^{2})$. (edit I guess if $d$ is a free parameters of the problem, then possibly we need an additional $O(\log d)$ factor when we do the sorting... and if $d$ is too large, then this can still lead to problems.)
