玩玩24點（中）

時間  2020-01-16
標籤 玩玩 24點 简体版
原文   原文鏈接

《玩玩24點》系列：html

序

在上篇中，我用上位機程序遍歷了4個1~13的數的1820種組合，經過遞歸窮舉計算出其中1362組的24點接法，並轉換爲二進制形式，放到單片機程序中，減小了單片機24點遊戲程序的計算量，得到了不錯的遊戲體驗。數據結構

上篇的最後留了一個瘋狂暗示，但時至現在我也沒有實現出來，由於寫完上篇事後一直在準備各類比賽和考試，這兩天也在寫AVR單片機教程，一直都沒有空去管它。函數

寫這篇中篇的緣由，是幾個沒有做業寫甚至不須要高考的同窗在玩一種24點遊戲的升級版——用計算器按出5個1~20的隨機整數，經過四則運算得到不超過50的最大有理數。通過一整個晚自修的手算後，他們想起我以前寫的24點，來問我他們算出的是否是上界。性能

我寫算法注重可複用性，畢竟不是std::都不寫的OI。因而我很快就在上次程序的基礎上寫成了他們要的算法。測試

這個程序，以及人機計算能力的對比，雖然毫無懸念，可是先放一邊。我對上篇所寫的內容有一些更深的思考。優化

算式的可讀性

實際上這個24點程序還遠不完美。單片機常常在屏幕上輸出詭異的解法，好比10 * 12 = 120, 120 / 5 = 24，這些是不符合人類計算邏輯的，正常人想到的都是10 / 5 = 2, 2 * 12 = 24。一個可行的方法是把遞歸搜索的順序換一下，先減再加，先除後乘，在除法中優先用最大的數除以最小的數。但仍是會出現12 / 5 = 12/5, 12/5 * 10 = 24這樣的式子，最根本的算法仍是根據表達式創建樹，在樹上調整順序。也許4個數算24點的狀況不須要這麼複雜，但這是萬能的、具備可擴展性的作法（也有多是我想多了）。spa

這是上篇中提出的問題與解決方案，如今我認爲須要修改。命令行

首先，對於5, 10, 12的例子，我已經找到簡單方法來使程序輸出符合人類邏輯的算式了：搜索順序改成減法、加法、結果爲整數的除法、乘法、結果爲分數的除法（代碼能夠在後面的程序中找到，這裏就不單獨放了）。在更新算法後我試玩了幾十組，發現程序給出的結果都是比較正常的，所以這個問題至少在4數24點的問題中算是解決了。

其次，做爲看似更好的算法，即便我能克服學數據結構時對樹的恐懼，成功地用二叉樹表達了算式，「在樹上調整順序」的概念也是模糊的。用什麼規則來調整呢？若是是整數優先，那麼10 / 5能夠保證，可是在新的遊戲規則中，若是運算數是2, 3, 33，最優結果是99/2，程序會先計算33 * 3，再計算99 / 2，而個人思路會是33 * 1.5。那麼這算什麼規則呢？其餘的狀況呢？理不清。

因此，調整一下搜索順序，見好就收吧。

4數24點的優化

一位對計算機程序一無所知的數學競賽同窗對求解24點的算法十分感興趣。在我絞盡腦汁跟他解釋通這個程序後，他認爲這個算法很差，由於有大量的重複計算。

有道理。比方說1, 2, 3，原來的算法會先算1 + 2，替換爲3，用3, 3遞歸調用，獲得6，這是1 + 2 + 3，而後還有1 + 3 + 2和2 + 3 + 1；1, 2, 3, 4就更多了。

他提出「分治」的策略：24必定是由兩個中間結果加減乘除獲得的，而每一箇中間結果也都是由兩個運算數獲得的。在爲他憑空想出分治而震驚之餘，我指出這是錯的，這很顯然。

但這個想法仍是有必定啓發性的。爲了優化4數24點的求解算法，我想還不如枚舉出全部可能的運算結構算了：

  1. a * b * c * d

  2. a + b + c + d

  3. a * b + c + d

  4. a * b * (c + d)

  5. a * b * c + d

  6. a * (b + c + d)

  7. a * b + c * d

  8. (a + b) * (c + d)

  9. (a * b + c) * d

  10. (a + b) * c + d

其中+表明加或減，*表明乘或除。偶數序號的結構都是前一個奇數序號結構的對偶，指把加減與乘除互換，加括號保證原有的優先級。

inline bool read_bit(int c, int b)
{
    return c & (1 << b);
}

class fast_vector
{
public:
    void push_back(const Rational& r)
    {
        data[size++] = r;
    }
    Rational* begin()
    {
        return data;
    }
    Rational* end()
    {
        return data + size;
    }
private:
    Rational data[1 << max_count];
    int size = 0;
};

using vector_type = fast_vector;

void all_sum(const std::vector<Rational>& data, vector_type& result)
{
    auto end = (1 << data.size()) - 1;
    for (int c = 0; c != end; ++c)
    {
        Rational sum = 0;
        bool valid = true;
        for (int b = 0; b != data.size(); ++b)
            if (!read_bit(c, b))
                sum += data[b];
        for (int b = 0; b != data.size(); ++b)
            if (read_bit(c, b))
            {
                if (sum < data[b])
                {
                    valid = false;
                    break;
                }
                sum -= data[b];
            }
        if (valid)
            result.push_back(sum);
    }
}

void all_pro(const std::vector<Rational>& data, vector_type& result)
{
    auto end = (1 << data.size()) - 1;
    for (int c = 0; c != end; ++c)
    {
        Rational pro = 1;
        bool valid = true;
        for (int b = 0; b != data.size(); ++b)
        {
            if (read_bit(c, b))
            {
                if (data[b] == 0)
                {
                    valid = false;
                    break;
                }
                pro /= data[b];
            }
            else
                pro *= data[b];
        }
        if (valid)
            result.push_back(pro);
    }
}

bool test_sum(const Rational& lhs, const Rational& rhs)
{
    if (lhs + rhs == target)
        return true;
    if (lhs < rhs && rhs - lhs == target)
        return true;
    if (rhs < lhs && lhs - rhs == target)
        return true;
    return false;
}

bool test_pro(const Rational& lhs, const Rational& rhs)
{
    if (lhs * rhs == target)
        return true;
    if (rhs != 0 && rhs / lhs == target)
        return true;
    if (lhs != 0 && lhs / rhs == target)
        return true;
    return false;
}

bool solve(int a, int b, int c, int d)
{
    std::vector<Rational> data(4);
    data[0] = a;
    data[1] = b;
    data[2] = c;
    data[3] = d;

    // a * b * c * d
    {
        vector_type pro;
        all_pro(data, pro);
        for (const auto& r : pro)
            if (r == target)
                return true;
    }

    // a + b + c + d
    {
        vector_type sum;
        all_sum(data, sum);
        for (const auto& r : sum)
            if (r == target)
                return true;
    }

    // a * b + c + d
    for (int i = 0; i != 3; ++i)
        for (int j = i + 1; j != 4; ++j)
        {
            auto pm = data;
            pm.erase(pm.begin() + j);
            pm.erase(pm.begin() + i);
            std::vector<Rational> md{ data[i], data[j] };
            vector_type pro;
            all_pro(md, pro);
            for (const auto& r : pro)
            {
                pm.push_back(r);
                vector_type sum;
                all_sum(pm, sum);
                for (const auto& r : sum)
                    if (r == target)
                        return true;
                pm.pop_back();
            }
        }

    // a * b * (c + d)
    for (int i = 0; i != 3; ++i)
        for (int j = i + 1; j != 4; ++j)
        {
            auto md = data;
            md.erase(md.begin() + j);
            md.erase(md.begin() + i);
            std::vector<Rational> pm{ data[i], data[j] };
            vector_type sum;
            all_sum(pm, sum);
            for (const auto& r : sum)
            {
                md.push_back(r);
                vector_type pro;
                all_pro(md, pro);
                for (const auto& r : pro)
                    if (r == target)
                        return true;
                md.pop_back();
            }
        }

    // a * b * c + d
    for (int i = 0; i != 4; ++i)
    {
        auto md = data;
        md.erase(md.begin() + i);
        vector_type pro;
        all_pro(md, pro);
        for (const auto& r : pro)
            if (test_sum(data[i], r))
                return true;
    }

    // a * (b + c + d)
    for (int i = 0; i != 4; ++i)
    {
        auto pm = data;
        pm.erase(pm.begin() + i);
        vector_type sum;
        all_sum(pm, sum);
        for (const auto& r : sum)
            if (test_pro(data[i], r))
                return true;
    }

    // a * b + c * d
    for (int i = 0; i != 3; ++i)
        for (int j = i + 1; j != 4; ++j)
        {
            auto md2 = data;
            md2.erase(md2.begin() + j);
            md2.erase(md2.begin() + i);
            decltype(md2) md1{ data[i], data[j] };
            vector_type pro1, pro2;
            all_pro(md1, pro1);
            all_pro(md2, pro2);
            for (const auto& r1 : pro1)
                for (const auto& r2 : pro2)
                    if (test_sum(r1, r2))
                        return true;
        }

    // (a + b) * (c + d)
    for (int i = 0; i != 3; ++i)
        for (int j = i + 1; j != 4; ++j)
        {
            auto pm2 = data;
            pm2.erase(pm2.begin() + j);
            pm2.erase(pm2.begin() + i);
            decltype(pm2) pm1{ data[i], data[j] };
            vector_type sum1, sum2;
            all_sum(pm1, sum1);
            all_sum(pm2, sum2);
            for (const auto& r1 : sum1)
                for (const auto& r2 : sum2)
                    if (test_pro(r1, r2))
                        return true;
        }

    // (a * b + c) * d
    for (int i = 0; i != 3; ++i)
        for (int j = i + 1; j != 4; ++j)
        {
            auto rest = data;
            rest.erase(rest.begin() + j);
            rest.erase(rest.begin() + i);
            std::vector<Rational> md{ data[i], data[j] };
            vector_type pro;
            all_pro(md, pro);
            for (const auto& r : pro)
            {
                for (int k = 0; k != 2; ++k)
                {
                    std::vector<Rational> pm{ r, rest[k] };
                    vector_type sum;
                    all_sum(pm, sum);
                    for (const auto& r : sum)
                        if (test_pro(r, rest[1 - k]))
                            return true;
                }
            }
        }

    // (a + b) * c + d
    for (int i = 0; i != 3; ++i)
        for (int j = i + 1; j != 4; ++j)
        {
            auto rest = data;
            rest.erase(rest.begin() + j);
            rest.erase(rest.begin() + i);
            std::vector<Rational> pm{ data[i], data[j] };
            vector_type sum;
            all_sum(pm, sum);
            for (const auto& r : sum)
            {
                for (int k = 0; k != 2; ++k)
                {
                    std::vector<Rational> md{ r, rest[k] };
                    vector_type pro;
                    all_pro(md, pro);
                    for (const auto& r : pro)
                        if (test_sum(r, rest[1 - k]))
                            return true;
                }
            }
        }

    return false;
}

int main()
{
    auto start_time = std::clock();
    int count = 0;
    for (int a = 1; a <= max_num; ++a)
        for (int b = a; b <= max_num; ++b)
            for (int c = b; c <= max_num; ++c)
                for (int d = c; d <= max_num; ++d)
                    if (solve(a, b, c, d))
                        ++count;
    std::cout << count << std::endl;
    std::cout << (static_cast<double>(std::clock()) - start_time) * 1000
        / CLOCKS_PER_SEC << "ms" << std::endl;
    return 0;
}

Integer爲int，Rational和Expression的定義見上篇。

原算法沒有使用std::vector數據結構，因爲STL的糟糕性能，我寫了個不涉及動態內存分配的fast_vector來替換存儲運算結果的std::vector；運算數的懶得改了。

算法的核心在於all_sum函數，用於求出data數組中的元素經過加減法能夠獲得的全部結果：

void all_sum(const std::vector<Rational>& data, vector_type& result)
{
    auto end = (1 << data.size()) - 1;
    for (int c = 0; c != end; ++c)
    {
        Rational sum = 0;
        bool valid = true;
        for (int b = 0; b != data.size(); ++b)
            if (!read_bit(c, b))
                sum += data[b];
        for (int b = 0; b != data.size(); ++b)
            if (read_bit(c, b))
            {
                if (sum < data[b])
                {
                    valid = false;
                    break;
                }
                sum -= data[b];
            }
        if (valid)
            result.push_back(sum);
    }
}

函數用一個整數c表示data數組中各元素取加號仍是減號，當二進制c的第b位爲0時（最低位爲第0位），下標爲b的元素取加號，不然取減號；c取不到0b11...1（data.size()個1），是由於不能全部元素都取減號。對於每一個c，若是算出來的值是有效的，就把它追加到結果的數組中去。我把返回值寫成了引用參數，雖然編譯器極可能RVO（返回值優化），我仍是手動寫出來以明確我提高性能的意圖。

all_pro函數相似，只不過計算的是積與商。

程序在VS2019中編譯，配置爲Release、x86，在沒插電的最節能配置下的i7-7700HQ上測試，從命令行調用，優化算法的平均運行時間爲55ms，而原算法爲82ms，是有明顯提高的。

機率問題

在一篇研究24點遊戲的文章中，有這樣一句話：

其實還有一個緣由，就是有解的機率過小了。4個數字的話也就大約80%的題能算，若是算上人頭牌，可解的題就只有75%了。

沒錯，在1820種可能的4數組合中，有1362種有解，比例爲74.8%。

可是注意，我說的是「比例」而不是「機率」，這二者是有區別的。要計算「有解的機率」，必須先肯定出題的方式。

若是是從1820道題目的題庫中等機率地選擇一道，相似與上篇中提到的單片機程序同樣，這樣每一道題被選中都是古典概型中的基本事件，有解機率就是74.8%。

若是是從52張撲克牌中等機率地選擇4張，那麼機率就不是74.8%，由於每一種題目出現的機率是不相等的。好比，6, 6, 6, 6出現的機率爲\(1 / C_{52}^{4}\)，而1, 2, 3, 4出現的機率爲\(4! / C_{52}^{4}\)，二者相差24倍。每一種4數的有序排列都是古典概型中的基本事件，有解機率須要從新計算。

std::set<std::vector<Integer>> solution;
int solved = 0;
int total = 0;
int card[4];
std::vector<Integer> comb(4);
for (card[0] = 0; card[0] != 49; ++card[0])
    for (card[1] = card[0] + 1; card[1] != 50; ++card[1])
        for (card[2] = card[1] + 1; card[2] != 51; ++card[2])
            for (card[3] = card[2] + 1; card[3] != 52; ++card[3])
            {
                ++total;
                for (int i = 0; i != 4; ++i)
                    comb[i] = card[i] / 4 + 1;
                if (solution.find(comb) != solution.end())
                    ++solved;
            }
std::cout << solved << " / " << total << std::endl;

其中，solution已經保存了有解的4數組合。程序的輸出爲：

217817 / 270725

這個比例爲80.5%，也是這種模型下有解的機率。

新款50點遊戲

未完待續，明天更。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程