Leetcode-890 可能的二分法

struct UnionFindSet
{
    int *ID;
    int *Auxiliary;
    int GroupSum;
    int WeightOriginalTotal;
};

struct UnionFindSet* UnionFindSetInit(int WeightTotal)
{
    struct UnionFindSet *UFSet = (struct UnionFindSet *)malloc(sizeof(struct UnionFindSet));
    
    UFSet -> GroupSum = WeightTotal;
    UFSet -> WeightOriginalTotal = WeightTotal;
    
    UFSet -> ID = (int*)malloc(WeightTotal*sizeof(int));
    UFSet -> Auxiliary = (int*)malloc(WeightTotal*sizeof(int));
    
    int i;
    for(i = 0;i < WeightTotal;i ++)
    {
        UFSet -> ID[i] = i;
    }
    for(i = 0;i < WeightTotal;i ++)
    {
        UFSet -> Auxiliary[i] = 1;
    }
    
    return UFSet; 
}

int UnionFindSetFind(struct UnionFindSet* UFSet,int WeightNum)
{
    if(WeightNum>UFSet -> WeightOriginalTotal-1 || WeightNum<0)
    {
        return -1;
    }
    
    while(WeightNum != UFSet -> ID[WeightNum])
    {
        WeightNum = UFSet -> ID[WeightNum];
    }
    return WeightNum;
}

int UnionFindSetUnion(struct UnionFindSet* UFSet,int Weight_1,int Weight_2)
{
    int WeightRoot_1 = UnionFindSetFind(UFSet,Weight_1);
    int WeightRoot_2 = UnionFindSetFind(UFSet,Weight_2);
    
    if(WeightRoot_1 == -1 || WeightRoot_2 == -1)
    {
        return -1;
    }
    if(WeightRoot_1 == WeightRoot_2)
    {
        return 1;
    }
    
    if(UFSet -> Auxiliary[WeightRoot_1] < UFSet -> Auxiliary[WeightRoot_2])
    {
        UFSet -> ID[WeightRoot_1] = WeightRoot_2;
        UFSet -> Auxiliary[WeightRoot_2] += UFSet -> Auxiliary[WeightRoot_1];
    }
    else
    {
        UFSet -> ID[WeightRoot_2] = WeightRoot_1;
        UFSet -> Auxiliary[WeightRoot_1] += UFSet -> Auxiliary[WeightRoot_2];
    }
    
    UFSet -> GroupSum --;
    return 0;
}

bool UnionFindSetIsConnected(struct UnionFindSet* UFSet,int Weight_1,int Weight_2)
{
    return (UnionFindSetFind(UFSet,Weight_1) == UnionFindSetFind(UFSet,Weight_2));
}

class Solution
{
    public:
        bool possibleBipartition(int N, vector<vector<int>>& dislikes)
        {
            if(N==1)
                return true;
            struct UnionFindSet *UFSet1 = UnionFindSetInit(2000);
            struct UnionFindSet *UFSet2 = UnionFindSetInit(2000);
            vector<pair<int,int>> left;
            UnionFindSetUnion(UFSet1,dislikes[0][0],0);
            UnionFindSetUnion(UFSet2,dislikes[0][1],0);
            
            for(auto p:dislikes)
            {
                if(UnionFindSetIsConnected(UFSet1,p[0],0))
                {
                    if(UnionFindSetIsConnected(UFSet1,p[1],0))
                    {
                        return false;
                    }
                    UnionFindSetUnion(UFSet2,p[1],0);
                }
                else if(UnionFindSetIsConnected(UFSet2,p[0],0))
                {
                    if(UnionFindSetIsConnected(UFSet2,p[1],0))
                    {
                        return false;
                    }
                    UnionFindSetUnion(UFSet1,p[1],0);
                }
                else if(UnionFindSetIsConnected(UFSet1,p[1],0))
                {
                    if(UnionFindSetIsConnected(UFSet1,p[0],0))
                    {
                        return false;
                    }
                    UnionFindSetUnion(UFSet2,p[0],0);
                }
                else if(UnionFindSetIsConnected(UFSet2,p[1],0))
                {
                    if(UnionFindSetIsConnected(UFSet2,p[0],0))
                    {
                        return false;
                    }
                    UnionFindSetUnion(UFSet1,p[0],0);
                }
                else
                {
                    left.push_back(make_pair(p[0],p[1]));
                }
            }
            for(auto p:left)
            {
                if(UnionFindSetIsConnected(UFSet1,p.first,p.second)
                || UnionFindSetIsConnected(UFSet2,p.first,p.second))
                    return false;
            }
            return true;
        }
};