1. After the delete-min, we have n-1 elements left, which start out as
separate heaps but then get merged into larger heaps, until they all
have different degrees at their roots. In this merge process, the only
steps that can happen are that two trees with the same shape can merge,
doubling their number of nodes and increasing the root degree by one. So
each tree will have size that is a power of two, 2^d where d is the
degree at the root. At the end of the delete-min process, there will be
one tree for each nonzero bit in the binary representation of n-1. So
the number of trees equals this number of nonzero bits.

2a. Let T(i) be the number of nodes in a minimal tree with the Fibonacci
heap degree property. So T(0)=1, T(1)=2, T(2)=3 (two degree-zero
children of a degree-two node), and T(3)=5 (two degree-zero children,
and one degree-one child).

2b. Insert nine elements and delete one (as in question 1), creating a
tree with eight children in it, and degree three at the root. If we let
the tree nodes be the letters ABCDEFGH, and we write a tree rooted at X
as X( subtrees rooted at X's children ), then this tree has the
structure A(B C(D) E(F G(H))). Now decrease the priorities of D and G so
that their subtrees are promoted to different trees (or delete the
elements in these subtrees). The remaining tree looks like A(B C E(F)),
a tree with five nodes in it and root degree three.

3a. To make the amortization cancel out the actual time for a
delete-min, the potential function for a binary heap with n items needs
to be at least proportional to n log n. So even though the actual time
for initializing an n-item heap, the change in potential function (going
from zero to the potential of the new heap) causes the amortized time to
be O(n log n).

3b. No, because this method can't be used to improve the time for
decrease-priority operations, which are the slow part of the binary-heap
version of Dijkstra's algorithm.