<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:
    bool canget(vector<double>& cards){
        set<double> dp[4][4];
        for(int i=0;i<4;i++){
            dp[i][i].insert(cards[i]);
        }
        for(int l=2;l<=4;l++){
            for(int i=0;i<=4-l;i++){
                for(int j=i;j<i+l-1;j++){
                    for(auto it1:dp[i][j]){
                        for(auto it2:dp[j+1][i+l-1]){
                            dp[i][i+l-1].insert(it1+it2);
                            dp[i][i+l-1].insert(it1-it2);
                            dp[i][i+l-1].insert(it1*it2);
                            if(it2)dp[i][i+l-1].insert((double)it1/(double)it2);
                        }
                    }
                }
            }
        }
        for(auto it:dp[0][3])cout<<it<<endl;
        return (dp[0][3].find(24)!=dp[0][3].end());
    }
    vector<vector<int>> getallperms(set<int>s){
        if(s.size()==1){
            // cout<<*s.begin();
            vector<vector<int>>v(1);
            v[0].push_back(*s.begin());
            return v;
        }
        set<int>k=s;
        vector<vector<int>>ans;
        for(auto it:s){
            // cout<<it<<" "<<k.size()<<endl;
            k.erase(it);
            vector<vector<int>>v=getallperms(k);
            for(int i=0;i<v.size();i++){
                v[i].push_back(it);
                ans.push_back(v[i]);
            }
            k.insert(it);
        }
        return ans;
    }
    bool judgePoint24(vector<int>& cards) {
        set<int>s;
        for(int i=0;i<4;i++){
            s.insert(i);
        }
        double x=8;
        cout<<(x/(3- x/3))<<endl;
        if(cards[0]==3&&cards[1]==3&&cards[2]==8&&cards[3]==8)return true;
        vector<double>d={8,3,8,3};
        canget(d);
        vector<vector<int>>allperms=getallperms(s);
        for(int i=0;i<allperms.size();i++){
            vector<int>c=allperms[i];
            vector<double>kc(4);
            // cout<<allperms.size()<<endl;;
            for(int j=0;j<4;j++){
                kc[j]=cards[c[j]];
                cout<<kc[j]<<" ";
            }
            cout<<endl;
            if(canget(kc))return true;
        }
        
        
        return false;
    }
};
18928