<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 <cmath>
class Solution {
    set<double> solve2(double a, double b)
    {
        if (a != 0 && b != 0)
            return {a+b, a*b, a-b, b-a, a/b, b/a};
        else if (a == 0)
            return {b, 0, -b};
        else
            return {a, 0, -a};
    }

    const double epsilon = 0.001;

public:
    bool judgePoint24(vector<int>& cards) {
        //2, 2
        for (int i=0; i<4; i++)
            for (int j=0; j<4; j++)
            {
                if (j == i)
                    continue;
                auto  res_ij = solve2(cards[i], cards[j]);
                for (int k=0; k<4; k++)
                {
                    if (k == i || k == j)
                        continue;
                    for (int l=0;l<4; l++)
                    {
                        if (l == i || l == j || l == k)
                            continue;
                        auto res_kl = solve2(cards[k], cards[l]);
                        for (const auto& a: res_ij)
                            for (const auto& b: res_kl)
                            {
                                auto combine = solve2(a, b);
                                for (const auto& com: combine)
                                if (abs(com-24.0) < epsilon)
                                    return true;
                            }
                        for (const auto& ij: res_ij)
                        {
                            auto tmp = solve2(ij, cards[k]);
                            for (const auto& t: tmp)
                            {
                                {
                                auto tt = solve2(t, cards[l]);
                                for (const auto& ttt:tt)
                                {
                                    if (abs(ttt-24) < epsilon)
                                   
                                        return true;
                                }
                                }
                               
                            }

                        }
                    }
                }
            }

        
        return false;
    }
};
21666