<p>You are given a string <code>s</code>.</p>

<p>A split is called <strong>good</strong> if you can split <code>s</code> into two non-empty strings <code>s<sub>left</sub></code> and <code>s<sub>right</sub></code> where their concatenation is equal to <code>s</code> (i.e., <code>s<sub>left</sub> + s<sub>right</sub> = s</code>) and the number of distinct letters in <code>s<sub>left</sub></code> and <code>s<sub>right</sub></code> is the same.</p>

<p>Return <em>the number of <strong>good splits</strong> you can make in <code>s</code></em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;aacaba&quot;
<strong>Output:</strong> 2
<strong>Explanation:</strong> There are 5 ways to split <code>&quot;aacaba&quot;</code> and 2 of them are good. 
(&quot;a&quot;, &quot;acaba&quot;) Left string and right string contains 1 and 3 different letters respectively.
(&quot;aa&quot;, &quot;caba&quot;) Left string and right string contains 1 and 3 different letters respectively.
(&quot;aac&quot;, &quot;aba&quot;) Left string and right string contains 2 and 2 different letters respectively (good split).
(&quot;aaca&quot;, &quot;ba&quot;) Left string and right string contains 2 and 2 different letters respectively (good split).
(&quot;aacab&quot;, &quot;a&quot;) Left string and right string contains 3 and 1 different letters respectively.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> s = &quot;abcd&quot;
<strong>Output:</strong> 1
<strong>Explanation:</strong> Split the string as follows (&quot;ab&quot;, &quot;cd&quot;).
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
	<li><code>s</code> consists of only lowercase English letters.</li>
</ul>

class Solution {
public:
    int numSplits(string s) {
        
        int res = 0;

        if(s.size() < 2)
            return res;

        int l = -1;
        int r = s.size();
        std::unordered_map<char, int> lSet;
        std::unordered_map<char, int> rSet;

        while(l + 1 < r)
        {
            if(lSet.size() < rSet.size())
            {
                l++;
                lSet[s[l]]++;
            }
            else
            {
                r--;
                rSet[s[r]]++;
            }
        }

        if(lSet.size() == rSet.size())
            //res = 0;
        //else
            res = 1;

        int lCpy = l;
        int rCpy = r; 
        std::unordered_map<char, int> lSetCpy = lSet;
        std::unordered_map<char, int> rSetCpy = rSet;
        
        //move Left
        while(lCpy + 1 > rSetCpy.size())
        {
            if((--lSetCpy[s[lCpy]]) == 0)
                lSetCpy.erase(s[lCpy]);

            lCpy--;
            rCpy--;

            rSetCpy[s[rCpy]]++;

            if(lSetCpy.size() == rSetCpy.size())
                res++;
            
        }

        //move Right
        while(s.size() - r > lSet.size())
        {
            if(--rSet[s[r]] == 0)
                rSet.erase(s[r]);

            r++;
            l++;

            lSet[s[l]]++;

            if(lSet.size() == rSet.size())
                res++;
            
        }

        return res;
    }
};
11400