算24点 c#实现

算24点 就是 给 四个数字，这四个数字 值的范围是1到13，经过 加减乘除 的办法 使得结果是 24

实现办法

class Node
        {
            public Node(double val,String e)
            {
                value = val;
                exp = e;
            }
            public Node()
            {

            }
           public double value;
           public String exp;
        }

有这样一个节点，数值部分存的就是 计算的数值结果，初始就是 输入的数值。

字符串部分记录的就是 两个数字计算的过程

举个例子 输入 两个值 1 2 和另外2个值 ，那么就初始两个 节点 node1 node2, 假设另外两个节点 为 node3 node4

node1.value=1,node1.exp="1",

node2.value=2,node2.exp="2",

若是这两个值进行一个加运算，获得一个新的节点node5

node5.value=3,node5.exp="(1+2)",

这样的话就剩三个节点 node3 node4 node5 进行接下来的计算就可怡

计算的过程就是递归，终止条件就是 输入的数组只有两个值，若是这两个值 经过+ - * / 可以计算获得24 就输出，不然就终止，

整个算法以下，没有去重

    class Node
        {
            public Node(double val,String e)
            {
                value = val;
                exp = e;
            }
            public Node()
            {

            }
           public double value;
           public String exp;
        }
        static void countProcess(List<Node> list)
        {
            if (list.Count < 2)
                return;
            if (list.Count == 2)
            {
                if (list[0].value + list[1].value == 24)
                {
                    Console.WriteLine(list[0].exp+"+"+list[1].exp);
               }
                if (list[0].value * list[1].value == 24)
                {
                    Console.WriteLine(list[0].exp + "*" + list[1].exp);
                }
                if (list[0].value / list[1].value == 24)
                {
                    Console.WriteLine(list[0].exp + "/" + list[1].exp);
                }
                if (list[1].value / list[0].value == 24)
                {
                    Console.WriteLine(list[1].exp + "/" + list[0].exp);
                }
                if (list[0].value - list[1].value == 24)
                {
                    Console.WriteLine(list[0].exp + "-" + list[1].exp);
                }
                if (list[1].value - list[0].value == 24)
                {
                    Console.WriteLine(list[1].exp + "-" + list[0].exp);
                }
                return;
           }
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = i + 1; j < list.Count; j++)
                {
                    List<Node> clist = new List<Node>(list);
                    //clist.CopyTo()
                    //clist = list;
                    //list.CopyTo(clist);
                    clist.Remove(list[i]);
                    clist.Remove(list[j]);

                    double a=list[i].value+list[j].value;
                    Node aa = new Node();
                    aa.value = a;
                    aa.exp = "("+list[i].exp + "+" + list[j].exp+")";
                    clist.Add(aa);
                    countProcess(clist);
                    clist.Remove(aa);

                    double b = list[i].value * list[j].value;
                    Node bb = new Node();
                    bb.value = b;
                    bb.exp = "(" + list[i].exp + "*" + list[j].exp + ")";
                    clist.Add(bb);
                    countProcess(clist);
                    clist.Remove(bb);

                    double c = list[i].value - list[j].value;
                    Node cc = new Node();
                    cc.value = c;
                    cc.exp = "(" + list[i].exp + "-" + list[j].exp + ")";
                    clist.Add(cc);
                    countProcess(clist);
                    clist.Remove(cc);


                    double d = list[j].value - list[i].value;
                    Node dd = new Node();
                    dd.value = d;
                    dd.exp = "(" + list[j].exp + "-" + list[i].exp + ")";
                    clist.Add(dd);
                    countProcess(clist);
                    clist.Remove(dd);

                    if (list[j].value != 0)
                    {
                        double e = list[i].value / list[j].value;
                        Node ee = new Node();
                        ee.value = e;
                        ee.exp = "(" + list[i].exp + "/" + list[j].exp + ")";
                        clist.Add(ee);
                        countProcess(clist);
                        clist.Remove(ee);
                    }


                    if (list[i].value != 0)
                    {
                        double f = list[j].value / list[i].value;
                        Node ff = new Node();
                        ff.value = f;
                        ff.exp = "(" + list[j].exp + "/" + list[i].exp + ")";
                        clist.Add(ff);
                        countProcess(clist);
                        clist.Remove(ff);
                    }
                    

                    
                   
                }
            }

        }
        static void Main(string[] args)
        {
            String a = Console.ReadLine();
            String b = Console.ReadLine();
            String c = Console.ReadLine();
            String d = Console.ReadLine();

            List<Node> list = new List<Node>();
            list.Add(new Node(Convert.ToDouble(a),a));
            list.Add(new Node(Convert.ToDouble(b), b));
            list.Add(new Node(Convert.ToDouble(c), c));
            list.Add(new Node(Convert.ToDouble(d), d));

            countProcess(list);

            Console.ReadKey();

        }