Count number of pairs of strings which on joining contain all vowels
Your Code:


Don't use &lt;bits/stdc++.h&gt;, it's unportable and inefficient. See "Why should I not #include &lt;bits/stdc++.h>?" for the details.
Don't use using namespace std;, that namespace just isn't designed for it. See "Why is “using namespace std” considered bad practice?" for more background.
Invest in some better names. Being too parsimonious there hurts, even though brevity is a virtue.
Format your code consistentently.


Sometimes you have space around binary operators (other than comma, which only should be followed by a space), sometimes you forget.
Add a space after ; when it isn't followed by the next line, meaning a loop's head.
Also add a space after #include, for, if, and while.
You don't have to use a block for single statements, but please don't put them on the same line, at the least separate them with a space.

C++ does not have VLAs. Just use a std::vector instead.
While in general, keeping the scope of a variable minimal is a good idea, there are exceptions. One of them is efficiency. Always spinning up a new std::string means being unable to re-use the buffer. Not that you really need the whole string at once, anyway.
One reason you should minimise a variables scope, is that it allows you to initialise it to the proper value, instead of leaving it uninitialised or, horrors of horrors, adding a spurious dummy-initialisation.
That also allows you to avoid writing the type (Almost Always auto), and making it const or even constexpr.
There are compound-assignment-operators for most binary operators. Like a |= b for a = a | b. Using them leads to shorter, more readable code.
When you want to output a single character, why not use a character-literal? It's potentially even slightly more efficient.
return 0; is implicit for main(). Take it or leave it, but be aware.


The Algorithm:

Your algorithm uses \$O(\#characters+\#words^2)\$ time and \$O(max\_word\_length + \#words)\$ space.

An optimal algorithm only needs \$O(\#characters+2^{\#vowels})\$ time and \$O(2^{\#vowels})\$ space:


For every word:


Set the bits for all the vowels contained.
Increment the count on the indicated bin.

For every vowel:


Iterate the bins containing words with that vowel.
Add the count to the respective bin without that vowel.

For all bins:
Multiply the count in the bin with the count in the complementary bin, and add that.
Subtract twice the count in the bin for words containing all vowels. Those account for all self-pairings.
The answer is half the calculated number, as we counted double.


Exercise for the attentive reader: Save half the multiplications this algorithm uses.