换啤酒问题

近日微信上有人传防痴呆问题：

2块钱买一瓶啤酒，四个瓶盖可以换一瓶啤酒，两个空瓶可以换一瓶啤酒，十块钱共能喝几瓶啤酒？

这个问题如果心算，如果就直肠子贪心法算的话，主要看记忆力。一般能心算出结果和零头的属于记忆力不错的，年轻人也不一定行。

如果在纸上算，只要不是太粗心的人，都能算出结果。但是学过一定数学的人，都怕这不是最优的结果。

其实假设单一解，贪心地算，这样一道题，结果很简单就是能喝15瓶酒，余下1个空瓶和三个瓶盖。但是如果我们列方程根据这些物品的价值来算，设啤酒价值为a，酒瓶价值为b，瓶盖价值为c，显然方程就是这样：

2￥ = a+b+c
2b = a+b+c
4c = a+b+c

很容易解出：

a = 0.5￥, b = 1￥, c = 0.5￥

这样，如果理想兑换的话（酒瓶和瓶盖能直接折算成钱/酒），10块钱能喝二十瓶啤酒，但这违反了题设的商业模式，显然无法做到。（但如果允许退款，是可以做到的，也是这道题目原题的答案）

貌似最优情况，也至少是要余下一个空瓶和一个瓶盖，但这也是不可能的。这个在数学结构上能够证明（从数学上应该能论证余b+2c和b+c是不可能的），也能用程序进行穷举证明，程序（穷举递归）如下：

using System;

namespace beers
{
    class Program
    {
        class Asset
        {
            public Asset(int dollars)
            {
                Dollars = dollars;
            }

            public Asset(Asset other)
            {
                Beers = other.Beers;
                Dollars = other.Dollars;
                Bottles = other.Bottles;
                Caps = other.Caps;
                Record = other.Record;
            }

            public int Beers;
            public int Dollars;
            public int Bottles;
            public int Caps;

            // TODO string builder? it's just a tiny puzzle, don't worry about it
            public string Record;

            public bool ConsumeDollars()
            {
                if (Dollars >= 2)
                {
                    Dollars -= 2;
                    Beers++;
                    Bottles++;
                    Caps++;
                    Record += string.Format("use 2 dollars\n");
                    return true;
                }
                return false;
            }

            public bool ConsumeBottles()
            {
                if (Bottles >= 2)
                {
                    Bottles -= 2;
                    Beers++;
                    Bottles++;
                    Caps++;
                    Record += string.Format("use 2 bottles\n");
                    return true;
                }
                return false;
            }

            public bool ConsumeCaps()
            {
                if (Caps >= 4)
                {
                    Caps -= 4;
                    Beers++;
                    Bottles++;
                    Caps++;
                    Record += string.Format("use 4 caps\n");
                    return true;
                }
                return false;
            }
        }

        static Asset Solve(Asset input)
        {
            var o1 = new Asset(input);
            o1 = o1.ConsumeDollars() ? Solve(o1) : null;

            var o2 = new Asset(input);
            o2 = o2.ConsumeBottles() ? Solve(o2) : null;

            var o3 = new Asset(input);
            o3 = o3.ConsumeCaps() ? Solve(o3) : null;

            if (o1 != null && (o2 == null || o1.Beers > o2.Beers) && (o3 == null || o1.Beers > o3.Beers))
            {
                return o1;
            }

            if (o2 != null && (o3 == null || o2.Beers > o3.Beers))
            {
                return o2;
            }

            if (o3 != null)
            {
                return o3;
            }

            return input;
        }

        static void Main(string[] args)
        {
            var ini = new Asset(10);
            var opt = Solve(ini);
            Console.WriteLine("result: {0} beers + {1} bottles {2} caps", opt.Beers, opt.Bottles, opt.Caps);
            Console.WriteLine("process:\n{0}", opt.Record);
        }
    }
}