<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> get_ops(double a, double b){
        vector<double> ans = {a+b, a*b, a-b, b-a};

        if(a){
            ans.push_back(b/a);
        }

        if(b){
            ans.push_back(a/b);
        }

        return ans;
    }

    bool is_possible(vector<double>& arr){
        int n = arr.size();

        if(n == 1){
            return abs(arr[0] - 24) <= 0.1;
        }

        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                vector<double> newList;

                for(int k=0;k<n;k++){
                    if(k!=i && k!=j){
                        newList.push_back(arr[k]);
                    }
                }

                for(double& res: get_ops(arr[i], arr[j])){
                    newList.push_back(res);

                    if(is_possible(newList)){
                        return true;
                    }

                    newList.pop_back();
                }
            }
        }

        return false;
    }

    set<double> apply_operations(double a, double b) {
    set<double> results;
    results.insert(a + b);   // Addition
    results.insert(a - b);   // Subtraction a - b
    results.insert(b - a);   // Subtraction b - a
    results.insert(a * b);   // Multiplication
    if (b) results.insert(a / b);  
    if (a) results.insert(b / a); 
    return results;
}

bool find_minimum_unformable_number(vector<double>& arr) {
    int n = arr.size();
    int full_mask = (1 << n) - 1;  
    vector<set<double>> dp(1 << n); 

   
    for (int i = 0; i < n; i++) {
        dp[1 << i].insert(arr[i]);
    }

   
    for (int mask = 1; mask <= full_mask; mask++) {
        // Iterate through all subsets (submasks) of the current mask
        for (int submask = mask; submask; submask = (submask - 1) & mask) {
            if (submask == mask) continue;  

            int complement_mask = mask ^ submask;  
            for (double val1 : dp[submask]) {
                for (double val2 : dp[complement_mask]) {
                    set<double> combined = apply_operations(val1, val2);
                    dp[mask].insert(combined.begin(), combined.end());
                }
            }
        }
    }

   
    set<double>& final_results = dp[full_mask];
    int smallest_unformable = 1;
    
    for(double i: dp[full_mask]){
        if(abs(i-24) <= 1e-5){
            return true;
        }
    }
    
    return false;
}

    bool judgePoint24(vector<int>& cards) {
        vector<double> arr(cards.begin(), cards.end());

        return find_minimum_unformable_number(arr);
    }
};
29878