Here is an answer to part a (on which you base your part b answer).
The product of the polynomials ax + b and cx + d is the polynomial
acx2 + (ad + bc)x + bd. That is, the goal is to compute
the three coefficients of the degree 2 polynomial ex2 + fx + g,
which are
e = ac, f = ad + bc, g = bd.
Thus 4 coefficient multiplications and one addition suffice.
An alternate formulation is
e = ac, g = bd, f = (a+b)(c+d) - e - g.
This requires 3 coefficient multiplications and 4 additions/subtractions.
Much as Strassen's algorithm takes advantage of recursive application
of a 7 multiplication, 18 addition scheme for 2 by 2 matrix multiplication,
here we can exploit the 3 mult, 4 add/sub method recursively.
By the way, this divide and conquer approach to polynomial multiplication is known as Karatsuba's method.
You are not asked to do part c of the problem. Just for interest, here is
a sketch of an answer. A n bit number k can be written in binary as
k = k0 + k12 + k322 + ... + k(n-1)2n-1.
Two n bit numbers can be multiplied by (1) converting them
to polynomials in this way, (2) multiplying the polynomials using Karatsuba's
method, and (3) propagating carries.
For step (3),
note that step (2) results in a polynomial of degree 2n-2, whose coefficients are
as large as n instead of being single bits. It is of the form
m = m0 + m1x + m32x + ... + m(2n-2)x2n-2.
The sum of all the
coefficients is no more than n2.
We may propogate carries by this algorithm:
carry = 0; m2n-1 = 0;
for (i = 0; i < 2n; ++i)
{ temp = mi + carry;
mi = first bit of temp (temp%2);
carry = temp shifted right one bit (temp/2);
}
In the loop,
the addition to compute temp is O(lg(n)), because carry's value never exceeds
n2, so the adding of one bit to carry has at most 2lg(n) bit carries. (carries within carries!). The subsequent two lines of bit fiddling
can be done in constant time with suitable implementation detail.
Thus the total cost of carry propogation is O(n*lg(n)).
The recurrence for the overall integer multiplication algorithm is then T(n) = 3*T(n/2) + O(n*lg(n)), whose solution by the master theorem is Θ(nlg(3)).