火柴拼正方形

想象正方形的4条边是4个桶，将每个火柴棍回溯放置在每个桶中，放完N个后，检查4个桶中的长度和是否相同

优化剪枝：

1.N个火柴棍的总和对4取余是不是0，不是的话返回假

2.长度按照从大到小排序，先尝试长的，减少回溯的可能

3.每次放置时，每条边上不可放置超过总和1/4长度的火柴棍

class Solution {
public:
    bool makesquare(vector<int>& nums) {
        if(nums.size() < 4)
            return false;
        
        int sum =0;
        for(int i =0;i<nums.size();++i)
            sum += nums[i];
        
        if(sum%4 !=0)
            return false;
        
        sort(nums.rbegin(),nums.rend());
        
        int bucket[4] ={0};
        
        return generate(0,nums,sum/4,bucket);
    }
    
    bool generate(int i,vector<int>& nums, int target,int bucket[])
    {
        if(i ==nums.size())
            return bucket[0] == target && bucket[1] == target && bucket[2] == target && bucket[3] == target;
        
        for(int j =0;j<4;++j)//4个桶中尝试
        {
            if(bucket[j] + nums[i] > target)
                continue;
            
            bucket[j] += nums[i];//放在J桶里
            
            if(generate(i + 1,nums,target,bucket))
                return true;
            
            bucket[j] -= nums[i];//说明不应该把第i根火柴棍放在J，所以拿出来
        }
        return false;
    }
};

方法2：

位运算法

1.使用位运算法，构造出所有和为target（sum/4）的子集，存储在向量ok_subset中，这些是候选的边组合

2.遍历所有的ok_subset，两两进行对比，如果进行与运算的结果为0，说明这两个是无交集的两个集合（没有选择同样的火柴棍）这两个集合可以代表两个同时存在的满足条件的边，将这两个集合再求或，结果存储在ok_half中，它代表所有满足一般结果的情况

3.遍历所有ok_half，两两进行对比，如果ok_half[i]和ok_half[j]进行与运算的结果为0，则返回true（说明有4个满足条件的边），否则返回false

class Solution {
public:
    bool makesquare(vector<int>& nums) {
        if(nums.size() < 4)
            return false;
        
        int sum =0;
        for(int i =0;i<nums.size();++i)
            sum += nums[i];
        
        if(sum%4 !=0)
            return false;
        
        int target = sum/4;
        
        vector<int> _subset;
        vector<int> _half;
        
        int all = 1 << nums.size();//一共有2^n种集合的情况
        //然后检查对每种集合的情况，在Nums中对应位置的火柴棍长度之和是不是等于target
        for(int i =0;i<all;++i)
        {
            int sum = 0;
            for(int j =0;j<nums.size();++j)
            {
                if(i & (1<<j) )
                    sum += nums[j];               
            }
            if(sum == target)
                _subset.push_back(i);//存储这条可能是满足要求的边
            
        }
        
        //两两对比这些边，如果两个边可以同时存在于正方形中，就再存储他们
        for(int i =0;i<_subset.size();++i)
        {
            for(int j =i+1;j < _subset.size();++j)
            {
                if((_subset[i] & _subset[j]) == 0)//说明这两个集合没有用到相同的火柴，因为用到相同的火柴的话，在某一位都存在数，相与就不会为0了
                    _half.push_back( _subset[i] | _subset[j]);//两个集合相或，就相当于把他们合并在一起，形成“满足一半”条件的情况
            }
        }
        
        //已经有满足正方形一半的边了，再找另一半有没有满足的，有的话，就可以返回true了
        for(int i =0;i< _half.size();++i)
        {
            for(int j =i+1;j< _half.size();++j)
            {
                if((_half[i] & _half[j]) == 0)
                    return true;
            }
        }
        
        return false;
    }
};