<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:

    vector<double> getPossibleResults(double num1, double num2) {
        vector<double> results;
        results.push_back(num1 + num2);
        results.push_back(num1 * num2);
        results.push_back(num1 - num2);
        results.push_back(num2 - num1);

        if(abs(num2) > 1e-4)
            results.push_back(num1 / num2);

        if(abs(num1) > 1e-4)
            results.push_back(num2 / num1);    
        
        return results;
    }

    void isPossible24(vector<double> nums, bool &found24) {
        if(found24) {
            return;
        }

        int numsSize = nums.size();

        if(numsSize == 0) {
            return;
        }

        if(numsSize == 1) {
            if(abs(nums[0] - 24) < 1e-4)
                found24 = true;
            return;    
        }

        for(int idx1 = 0; idx1 < numsSize; idx1++) {
            for(int idx2 = idx1 + 1; idx2 < numsSize; idx2++) {
                double num1 = nums[idx1], num2 = nums[idx2];

                vector<double> newNums;

                for(int idx3 = 0; idx3 < numsSize; idx3++) {
                    if((idx3 != idx1) && (idx3 != idx2)) {
                        newNums.push_back(nums[idx3]);
                    }
                }

                vector<double> possibleResults = getPossibleResults(num1, num2);

                for(int idx3 = 0; idx3 < possibleResults.size(); idx3++) {
                    newNums.push_back(possibleResults[idx3]);
                    isPossible24(newNums, found24);

                    if(found24)
                        return;

                    newNums.pop_back();    
                }
            }
        }
    }
    bool judgePoint24(vector<int>& cards) {
        vector<double> doubleCards(cards.begin(), cards.end());
        bool found24 = false;
        isPossible24(doubleCards, found24);
        return found24;
    }
};
20023