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

#include <vector>
#include <cmath>

class Solution {
public:
    bool judgePoint24(std::vector<int>& cards) {
        double a = cards[0], b = cards[1], c = cards[2], d = cards[3], temp = 0;
        double epsilon = 1e-6;

        for (int i = 1; i < 24; i++) {
            double apb = a + b;
            double amb = a - b;
            double axb = a * b;
            double adb = a / b;

            double cpd = c + d;
            double cmd = c - d;
            double cxd = c * d;
            double cdd = c / d;

            if (std::fabs(axb + cpd - 24) < epsilon)
                return true;
            if (std::fabs(axb - cpd - 24) < epsilon)
                return true;
            if (std::fabs(axb * cpd - 24) < epsilon)
                return true;

            if (std::fabs(axb + cmd - 24) < epsilon)
                return true;
            if (std::fabs(axb / cmd - 24) < epsilon)
                return true;

            if (std::fabs(axb + cxd - 24) < epsilon)
                return true;
            if (std::fabs(axb - cxd - 24) < epsilon)
                return true;
            if (std::fabs(axb * cxd - 24) < epsilon)
                return true;

            if (std::fabs(axb + cdd - 24) < epsilon)
                return true;
            if (std::fabs(axb - cdd - 24) < epsilon)
                return true;
            if (std::fabs(axb * cdd - 24) < epsilon)
                return true;

            if (std::fabs(axb * c + d - 24) < epsilon)
                return true;
            if (std::fabs(axb * c - d - 24) < epsilon)
                return true;

            if (std::fabs(axb / c + d - 24) < epsilon)
                return true;
            if (std::fabs(axb / c - d - 24) < epsilon)
                return true;

            if (std::fabs(apb + cpd - 24) < epsilon)
                return true;
            if (std::fabs(apb * cpd - 24) < epsilon)
                return true;

            if (std::fabs(apb + cmd - 24) < epsilon)
                return true;
            if (std::fabs(apb * cmd - 24) < epsilon)
                return true;

            if (std::fabs(amb * cxd - 24) < epsilon)
                return true;

            if (std::fabs(amb * cmd - 24) < epsilon)
                return true;

            if (std::fabs(apb * c + d - 24) < epsilon)
                return true;
 
            if (std::fabs(a / (b - cdd) - 24) < epsilon)
                return true;
            if (std::fabs(a / (cdd - b) - 24) < epsilon)
                return true;

            if (std::fabs((a - cdd) * b - 24) < epsilon)
                return true;
            if (std::fabs((c + adb) * d - 24) < epsilon)
                return true;
            if (std::fabs((apb - c) * d - 24) < epsilon)
                return true;

            temp = a;
            a = b;
            b = c;
            c = d;
            d = temp;

            if (i % 4 == 0) {
                temp = c;
                c = d;
                d = temp;
            }

            if (i % 8 == 0) {
                temp = b;
                b = c;
                c = temp;
            }

            if (i % 16 == 0) {
                temp = b;
                b = d;
                d = temp;
            }
        }

        return false;
    }
};

9073