编程艺术之美，代码也玩穿越

来源：互联网发布：java架构设计文档编辑：程序博客网时间：2024/04/19 09:54

在印刷行业信息化实践中，总是能遇到各种极富挑战性的需求，将我们推向疯癫的边缘。

最近要求实现版位预估算法，按照实际的组版规则进行计算。接过分析建模，抽象出如下的算法模型：

*计算是否存在值X1,X2,...,Xm,使等式成立m*X1+(m-1)*X2+(m-3)*X3+...+Xm=E

*如果可解，取解集中各X的值，要求X1尽可能大，其次是X2，...Xm，X确定情况下存在多解，则E取最大

*已知条件：

*1）其中E为36，32，23，18中的一个数字

*2）m，X1,X2,...,Xm为零或正整数

*3）m的值已知

*4）X1,X2,...,Xm的最大值已知

*求解思路：

*将以上算法抽象成m*X1=E-Y1，Y1=(m-1)*X2+(m-3)*X3+...+Xm，

*然后对X1和Y1进行求解，对Y1的求解转化为(m-1)*X2=Y1-Y2，Y2=(m-3)*X3+...+Xm，以此类推

*最终在Yn为0时，得出解

*如果不存在Yn=0，则解不存在

代码如下：

        /// <summary>
        /// 基于不同盒数组合的版位预估算法
        /// </summary>
        /// <param name="templist">盒数以及个数的组合链表，存放m以及对应的X的最大值</param>
        /// <param name="retInfo">符合组版条件的求解结果，格式如 |m_index,m,x</param>
        /// <param name="E">版面要求的位置数</param>
        /// <param name="m_index">templist的当前索引</param>
        /// <param name="xmax_index">templist中X最大值存放的位置索引</param>
        /// <param name="info">解的传递传递过程信息。格式如 |m_index,m,x</param>
        /// <returns>如果返回值为true则取得解，返回false，则中止本次循环</returns>
        private bool PB_Through(ArrayList templist, ref StringBuilder retInfo, int E, int m_index, int xmax_index, string info)
        {
            //先计算是否存在X=（E-Y）/m，即Y=E-m*X
            //实际中不会存在m>E的情况，因为在m=E的时候就已经被解决掉了
            //以下算法带着templist，retlist 在算法梦境中玩穿越，看仔细了
            //write by chenrl 2011.5.23

            int m = ((int[])templist[m_index])[0];
            int xmax = ((int[])templist[m_index])[xmax_index];
            //允许中间的Xn等于0
            for (int x = E / m; (x >= 0) && (x <= xmax); x--) //for语句中 用到2个判断条件，还真是第一次-_-
            {
                //提取各梦境x的值？或者考虑如何将本次梦境的X值带入到下个梦境？
                //   该x的存储以及传递必须是值传递，在求解后能对templist中的X最大值进行更改
                //   此处考虑用字符串，每次穿越后，追加 "|"+"m_index"+","+m+","+x

                StringBuilder sinfo = new StringBuilder();//如果需要变动，则将变动的X值以及当前位置索引写入到info
                sinfo.Append(info);
                sinfo.Append("|");
                sinfo.Append(m_index);
                sinfo.Append(",");
                sinfo.Append(m);
                sinfo.Append(",");
                sinfo.Append(x);
             
                int y = E - (m * x);
                if (y == 0)//梦境中解决问题，处理后返回现实
                {
                    //各m,X的值都已经在sinfo中，完成穿越
                    #region 以下代码丰收穿越结果，操作templist，将解带回到现实
                    //将组合结果写入到retInfo
                    retInfo = sinfo; //StringBuilder类似属于引用传递
                    //更新更新templist中的X最大值
                    string[] infos = sinfo.ToString().TrimStart('|').Split('|');
                    foreach (string str in infos)
                    {
                        ((int[])templist[int.Parse(str[0].ToString())])[xmax_index] -= int.Parse(str[2].ToString());
                    }
                    #endregion 以下代码丰收穿越结果，操作templist，将解带回到现实
                    return true;
                }
                else //当前梦境中无法解决问题，继续产生新的梦境，进行穿越
                {                   
                    //穿越前判断是否是最后一个梦境
                    if(m_index<(templist.Count-1))
                    {
                        return PB_Through(templist,ref retInfo, E, m_index + 1, xmax_index, info);
                    }
                }
            }
            return false;
        }

不过这区区50行代码，却默默体现了代码算法之美。

回顾设计，从组版算法分析->流程图描述->算法建模->算法实现，我觉一路走来不容易。循环计算的问题，最终还是要回到递归中来。每个递归其实就是一个梦境，程序员设计的梦境，每个程序员都是造梦师。

0 0