24点解法

#include <stdio.h>
#include <vector>
#include <string>

class fraction
{
public:
    fraction(int numerator, int denominator = 1)
    {
        if(numerator%denominator == 0)
        {
            numerator_ = numerator/denominator;
            denominator_ = 1;
        }
        else
        {
            numerator_ = numerator;
            denominator_ = denominator;
        }
    }

    fraction operator+(const fraction & f)
    {
        int numerator = numerator_*f.denominator_ + denominator_*f.numerator_;
        int denominator = denominator_*f.denominator_;


        return fraction(numerator, denominator);
    }

    fraction operator-(const fraction & f)
    {
        int numerator = numerator_*f.denominator_ - denominator_*f.numerator_;
        int denominator = denominator_*f.denominator_;

        return fraction(numerator, denominator);
    }

    fraction operator*(const fraction & f)
    {
        int numerator = numerator_*f.numerator_;
        int denominator = denominator_*f.denominator_;

        return fraction(numerator, denominator);
    }

    fraction operator/(const fraction & f)
    {
        int numerator = numerator_*f.denominator_;
        int denominator = denominator_*f.numerator_;

        return fraction(numerator, denominator);
    }

    bool operator==(int num)
    {
        return numerator_/denominator_ == num && numerator_%denominator_ == 0;
    }

    bool operator!=(int num)
    {
        return !this->operator==(num);
    }

private:
    int numerator_;
    int denominator_;
};

std::string format24(std::vector<int> & vNum, std::vector<int> & vPoint)
{
    if(vNum.size() != 4 && vPoint.size() != 5)
    {
        return "";
    }

    std::string exp1[4];
    switch(vPoint[0])
    {
        case 0:
            exp1[0] = std::to_string(vNum[0]);
            exp1[1] = std::to_string(vNum[1]);
            exp1[2] = std::to_string(vNum[2]);
            exp1[3] = std::to_string(vNum[3]);
            break;
        case 1:
            exp1[0] = std::to_string(vNum[0]);
            exp1[1] = std::to_string(vNum[2]);
            exp1[2] = std::to_string(vNum[1]);
            exp1[3] = std::to_string(vNum[3]);
            break;
        case 2:
            exp1[0] = std::to_string(vNum[0]);
            exp1[1] = std::to_string(vNum[3]);
            exp1[2] = std::to_string(vNum[1]);
            exp1[3] = std::to_string(vNum[2]);
            break;
        case 3:
            exp1[0] = std::to_string(vNum[1]);
            exp1[1] = std::to_string(vNum[2]);
            exp1[2] = std::to_string(vNum[0]);
            exp1[3] = std::to_string(vNum[3]);
            break;
        case 4:
            exp1[0] = std::to_string(vNum[1]);
            exp1[1] = std::to_string(vNum[3]);
            exp1[2] = std::to_string(vNum[0]);
            exp1[3] = std::to_string(vNum[2]);
            break;
        case 5:
            exp1[0] = std::to_string(vNum[2]);
            exp1[1] = std::to_string(vNum[3]);
            exp1[2] = std::to_string(vNum[0]);
            exp1[3] = std::to_string(vNum[1]);
            break;
    };

    std::string exp2[3];
    switch(vPoint[1])
    {
        case 0:
            exp2[0] = "(" + exp1[0] + "+" + exp1[1] +")";
            break;
        case 1:
            exp2[0] = "(" + exp1[0] + "-" + exp1[1] +")";
            break;
        case 2:
            exp2[0] = "(" + exp1[1] + "-" + exp1[0] +")";
            break;
        case 3:
            exp2[0] = "(" + exp1[0] + "*" + exp1[1] +")";
            break;
        case 4:
            exp2[0] = "(" + exp1[0] + "/" + exp1[1] +")";
            break;
        case 5:
            exp2[0] = "(" + exp1[1] + "/" + exp1[0] +")";
            break;
    }
    exp2[1] = exp1[2];
    exp2[2] = exp1[3];

    std::string exp3[3];
    switch(vPoint[2])
    {
        case 0:
            exp3[0] = exp2[0];
            exp3[1] = exp2[1];
            exp3[2] = exp2[2];
            break;
        case 1:
            exp3[0] = exp2[0];
            exp3[1] = exp2[2];
            exp3[2] = exp2[1];
            break;
        case 2:
            exp3[0] = exp2[1];
            exp3[1] = exp2[2];
            exp3[2] = exp2[0];
            break;
    }


    std::string exp4[2];
    switch(vPoint[3])
    {
        case 0:
            exp4[0] = "(" + exp3[0] + "+" + exp3[1] +")";
            break;
        case 1:
            exp4[0] = "(" + exp3[0] + "-" + exp3[1] +")";
            break;
        case 2:
            exp4[0] = "(" + exp3[1] + "-" + exp3[0] +")";
            break;
        case 3:
            exp4[0] = "(" + exp3[0] + "*" + exp3[1] +")";
            break;
        case 4:
            exp4[0] = "(" + exp3[0] + "/" + exp3[1] +")";
            break;
        case 5:
            exp4[0] = "(" + exp3[1] + "/" + exp3[0] +")";
            break;
    }
    exp4[1] = exp3[2];

    std::string exp5;
    switch(vPoint[4])
    {
        case 0:
            exp5 =  exp4[0] + "+" + exp4[1];
            break;
        case 1:
            exp5 = exp4[0]  + "-" +  exp4[1];
            break;
        case 2:
            exp5 = exp4[1]  + "-" +  exp4[0];
            break;
        case 3:
            exp5 = exp4[0]  + "*" +  exp4[1];
            break;
        case 4:
            exp5 = exp4[0]  + "/" +  exp4[1];
            break;
        case 5:
            exp5 = exp4[1]  + "/" +  exp4[0];
            break;
    }

    printf("%s = 24\n", exp5.c_str());
    return exp5;
}

void point24_2(fraction p1, fraction p2, std::vector<int> & vNum, std::vector<int> & vPoint)
{

    if(p1+p2 == 24)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(0);
        format24(vNum, vPoint1);
    }

    if(p1-p2 == 24)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(1);
        format24(vNum, vPoint1);
    }

    if(p2-p1 == 24)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(2);
        format24(vNum, vPoint1);
    }

    if(p1*p2  == 24)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(3);
        format24(vNum, vPoint1);
    }

    if(p2 != 0 &&  p1/p2 == 24)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(4);
        format24(vNum, vPoint1);
    }

    if(p1 != 0 &&  p2/p1 == 24)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(5);
        format24(vNum, vPoint1);
    }
}

void point24_3_1(fraction p1, fraction p2, fraction p3, std::vector<int> & vNum, std::vector<int> & vPoint)
{
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(0);
        point24_2(p1+p2, p3, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(1);
        point24_2(p1-p2, p3, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(2);
        point24_2(p2-p1, p3, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(3);
        point24_2(p1*p2, p3, vNum, vPoint1);
    }

    if(p2 != 0)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(4);
        point24_2(p1/p2, p3, vNum, vPoint1);
    }

    if(p1 != 0)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(5);
        point24_2(p2/p1, p3, vNum, vPoint1);
    }
}

void point24_3(fraction p1, fraction p2, fraction p3, std::vector<int> & vNum, std::vector<int> & vPoint)
{
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(0);
        point24_3_1(p1, p2, p3, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(1);
        point24_3_1(p1, p3, p2, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(2);
        point24_3_1(p2, p3, p1, vNum, vPoint1);
    }
}

void point24_4_1(fraction p1, fraction p2, fraction p3, fraction p4, std::vector<int> & vNum, std::vector<int> & vPoint)
{
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(0);
        point24_3(p1+p2, p3, p4, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(1);
        point24_3(p1-p2, p3, p4, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(2);
        point24_3(p2-p1, p3, p4, vNum, vPoint1);
    }

    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(3);
        point24_3(p1*p2, p3, p4, vNum, vPoint1);
    }

    if(p2 != 0)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(4);
        point24_3(p1/p2, p3, p4, vNum, vPoint1);
    }

    if(p1 != 0)
    {
        std::vector<int> vPoint1 = vPoint;
        vPoint1.push_back(5);
        point24_3(p2/p1, p3, p4, vNum, vPoint1);
    }
}

void point24_4(fraction p1, fraction p2, fraction p3, fraction p4, std::vector<int> & vNum)
{
    {
        std::vector<int> vPoint;
        vPoint.push_back(0);
        point24_4_1(p1, p2, p3, p4, vNum, vPoint);
    }

    {
        std::vector<int> vPoint;
        vPoint.push_back(1);
        point24_4_1(p1, p3, p2, p4, vNum, vPoint);
    }

    {
        std::vector<int> vPoint;
        vPoint.push_back(2);
        point24_4_1(p1, p4, p2, p3, vNum, vPoint);
    }

    {
        std::vector<int> vPoint;
        vPoint.push_back(3);
        point24_4_1(p2, p3, p1, p4, vNum, vPoint);
    }

    {
        std::vector<int> vPoint;
        vPoint.push_back(4);
        point24_4_1(p2, p4, p1, p3, vNum, vPoint);
    }

    {
        std::vector<int> vPoint;
        vPoint.push_back(5);
        point24_4_1(p3, p4, p1, p2, vNum, vPoint);
    }
}

void point24(int p1, int p2, int p3, int p4)
{
    std::vector<int> vNum;
    vNum.push_back(p1);
    vNum.push_back(p2);
    vNum.push_back(p3);
    vNum.push_back(p4);
    point24_4(fraction(p1), fraction(p2), fraction(p3), fraction(p4), vNum);
}

int main()
{
    point24(3, 3, 8, 8);
    return 0;
}