<p>You are given an integer array <code>cards</code> of length <code>4</code>. You have four cards, each containing a number in the range <code>[1, 9]</code>. You should arrange the numbers on these cards in a mathematical expression using the operators <code>[&#39;+&#39;, &#39;-&#39;, &#39;*&#39;, &#39;/&#39;]</code> and the parentheses <code>&#39;(&#39;</code> and <code>&#39;)&#39;</code> to get the value 24.</p>

<p>You are restricted with the following rules:</p>

<ul>
	<li>The division operator <code>&#39;/&#39;</code> represents real division, not integer division.

	<ul>
		<li>For example, <code>4 / (1 - 2 / 3) = 4 / (1 / 3) = 12</code>.</li>
	</ul>
	</li>
	<li>Every operation done is between two numbers. In particular, we cannot use <code>&#39;-&#39;</code> as a unary operator.
	<ul>
		<li>For example, if <code>cards = [1, 1, 1, 1]</code>, the expression <code>&quot;-1 - 1 - 1 - 1&quot;</code> is <strong>not allowed</strong>.</li>
	</ul>
	</li>
	<li>You cannot concatenate numbers together
	<ul>
		<li>For example, if <code>cards = [1, 2, 1, 2]</code>, the expression <code>&quot;12 + 12&quot;</code> is not valid.</li>
	</ul>
	</li>
</ul>

<p>Return <code>true</code> if you can get such expression that evaluates to <code>24</code>, and <code>false</code> otherwise.</p>

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

<pre>
<strong>Input:</strong> cards = [4,1,8,7]
<strong>Output:</strong> true
<strong>Explanation:</strong> (8-4) * (7-1) = 24
</pre>

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

<pre>
<strong>Input:</strong> cards = [1,2,1,2]
<strong>Output:</strong> false
</pre>

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

<ul>
	<li><code>cards.length == 4</code></li>
	<li><code>1 &lt;= cards[i] &lt;= 9</code></li>
</ul>

class Solution {
public:
    void recurse(int l, int r, vector<int> & cards, vector< vector < set < long double > > > &dp ) {
        // cout << " l " << l << " r " << r << endl;
        if(r < l) return;
        if(l > 4) return;
        if(dp[l][r].size() > 0) return;
        if(l==r) {
            dp[l][r].insert(cards[l]);return;
        }
        for(int m = l ; m < r ; m++) {
            recurse(l,m, cards, dp);
            recurse(m+1,r, cards,dp);
            for(auto i : dp[l][m]) {
                for(auto j : dp[m+1][r]) {
                    dp[l][r].insert(i*j);
                    dp[l][r].insert(i-j);
                    dp[l][r].insert(i+j);
                    dp[l][r].insert(i/j);
                    // cout << " in the l r " << l << " r " << r << " pushing " << 
                }
            }
        }
    }
    bool judgePoint24Helper(vector<int>& cards) {
        int lim = 4;
        // cout << " starting " << endl;
        vector< vector < set < long double > > > dp(lim, vector<set<long double>>(lim));
        for(int windowSize = 1 ; windowSize <= lim ; windowSize++) {
            for(int i = 0 ; i + windowSize - 1  < lim ; i++) {
                recurse(i, i + windowSize - 1, cards, dp);
            }
        }
        // cout << " done the loops " << endl;
        auto it = dp[0][3].lower_bound(23);

        for(int i = 0 ; i < lim ; i++) {
            for(int j = i ; j < lim ; j++) {
                cout << " for the range l " << i << " r " << j  << " values are :: " << endl;
                for(auto i : dp[i][j]) {
                    cout << i << endl;
                }
            }
        }


        while(it != dp[0][3].end()) {
            cout << " final values of " << *it << endl;
            if(*it > 25)break;
            if((long double)abs(*it - (long double)24) < (long double)0.0000000001) return true;
            it++;
        }

        return false;
    }

    bool judgePoint24(vector<int>& cards) {
        bool ans = false;
        sort(cards.begin(),cards.end());
        do{
            auto t = judgePoint24Helper(cards);
            ans |= t;
        }while(next_permutation(cards.begin(),cards.end()));
        return ans;
    }
};
25498