Perfect License Plates
Python 3.6, 150 bytes

f=lambda n,t=-1,p=-1,a=0:sum(f(n-1,*((t,c+p*(p&gt;=0),a),((t&lt;0 or t)*(p&lt;0 or p),-1,a-c))[c&lt;0])for c in range(-26,10))if n else 0&lt;(t&lt;0 or t)*(p&lt;0 or p)==a


results:

f(2) = 18
f(3) = 355
f(4) = 8012
f(5) = 218153


Ungolfed version with explanation:

digits=[*range(10)]
letters=[*range(1,27)]

def f(n, dt=-1, dp=-1, lt=0):
    if n:
        for d in digits:
            yield from f(n - 1,
                         dt,
                         d if dp &lt; 0 else dp + d,
                         lt
                         )

        for l in letters:
            yield from f(n - 1,
                         dp if dt &lt; 0 else dt if dp &lt; 0 else dt*dp,
                         -1,
                         lt + l
                         )
    else:
        yield 0 &lt; lt == (dt&lt;0 or dt)*(dp&lt;0 or dp)


The problem boils down to searching a tree in which each level of the tree corresponds to a position in a license plate number and each node has 36 children (10 digits and 26 letters).  The function does a recursive search of the tree, accumulating the values for the digits and letters as it goes.  

n is the number of levels to search. 
dp accumulates the sum of a group of digits.
dt accumulates the product of the digit sums.
lt accumulates the sum of the letter values.

For dp and dt, a value &lt; 0 indicates it is not initialized.


Golf included, converting the for loops to sums of generators:

sum(f(n-1, 
      dt,
      d if dp &lt; 0 else dp + d,
      lt) for d in digits)
+
sum(f(n-1,
      dp if dt&lt;0 else dt if dp&lt;0 else dt*dp,
      -1,
      lt+l) for l in letters)


Then combining the generators.  Encode letters, A to Z, as -1 to -26 and digits as 0 to 9.  So the sum becomes:

sum(f(n-1, *args) for c in range(-26, 10)),


where args is:

((dp if dt&lt;0 else dt if dp&lt;0 else dt*dp, -1, lt-l) if c &lt;0 else
 (dt, d if dp&lt;0 else dp+d, lt))


The rest of the golfing is converting the function to a lambda, shortening variable names, and simplifying expressions.