轻松周赛赛题：能否被8整除【很有意思的一个数学题】

本文摘抄自：http://www.cnblogs.com/preacher/p/4090102.html

 

题目链接：http://student.csdn.net/mcs/programming_challenges

题目描述：

给定一个非负整数，问能否重排它的全部数字，使得重排后的数能被8整除。 输入格式： 多组数据，每组数据是一个非负整数。非负整数的位数不超过10000位。 输出格式 每组数据输出一行,YES或者NO，表示能否重排它的全部数字得到能被8整除的数。注意： 重排可以让0开头。

 

这个题目假如不考虑数据范围比较大会造成严重超时的情况，最容易想到的思路是：将数字全排列，验证是否可被8整除，例如123的全排列：123、231、312、213、132、321   (共3！=6种)。以下为提供全排序处理此问题的方法，当然这种方法网上随处可见：

class Program
    {
        static int Count = 1;
        static int DivNum = 8;

        /*
         * 
         *  1,2:  {1,2},{2,1}
         *  1,2,3:   
         *       {3,1,2},{1,3,2},{1,2,3}     ( {1,2}中随机插入3 )
         *       {3,2,1},{2,3,1},{2,1,3}     ( {2,1}中随机插入3 )
         * 
         * 1，2,3，4：
         *      就是在上面的六组数字中随机插入4
         * 
         * 依次类推
         */

        static void Main(string[] args)
        {
            string[] arr = new string[]
            {
             "11223344",
             "23456798",
             "89289238",
             "23458203945829345"
            };

            foreach (string item in arr)
            {
                if (Perm(item.ToCharArray(), 0))
                    Console.WriteLine("  {0}   Yes", item);
                else
                    Console.WriteLine("  {0}   No", item);
            }
        }

        static void Swap(ref Char lc,ref Char rc)
        {
            Char tmp = lc;
            lc = rc;
            rc = tmp;
        }

        static bool Perm(char[] arrChar, int cur)
        {
            if (cur == arrChar.Length - 1)
            {
                long val1 = 0;

                if (long.TryParse(new string(arrChar), out val1) && val1 % DivNum == 0)
                {
                    return true;
                }
                else
                    return false;
            }
            else
            {
                for (int i = cur; i < arrChar.Length; i++)
                {
                    Swap(ref arrChar[cur], ref arrChar[i]);
                    if (Perm(arrChar, cur + 1))
                        return true;
                    Swap(ref arrChar[cur], ref  arrChar[i]);
                }
            }
            return false;
        }
    }

不过众所周知，n！数量级的算法都比较恐怖一点的（只要数据稍微大一点，常规的数据类型基本难以处理，更何况本题目要处理的是10000的阶乘啊，想想都恐怖）

 

下面是另一种思路：

其实，这道题使用归纳法比较好，为什么？题目有提示 非负整数的位数不超过10000位 ，这意味着什么呢？非负整数的长度可能达到9999位，如果这么大的数使用全排序，估计计算机要死了，更何况我家自用开发机是8年前的老古董，想的出这种馊主意，它肯定受不了了。所以要借助归纳法，为什么可以用归纳法？呵呵，我猜的，别笑，我说得是实话，我猜测它可以使用归纳法，那么就得找出它遵循什么规律了，下面开始做一些假设过程：

 

怎么样，简单吧，只要判断末三位组成的数字能被8整除，这个数必然能被8整除。

string aaa = "123123213840213849102384192034801923480192381234";
            int length = aaa.Length - 3;

            for (int x = 0; x < length; x++)//对应百位
            {
                for (int y = 0; y < length; y++)//对应十位
                {
                    if (y == x) 
                        continue;

                    for (int z = 0; z < length; z++)//对应个位
                    {
                        if (z == x || z == y)
                            continue;

                        if (Convert.ToInt32(new string(new char[] { aaa[x], aaa[y], aaa[z] })) % 8 == 0)
                        {
                            char[] arr = aaa.ToCharArray();

                            Swap(ref arr[x], ref arr[length + 0]);
                            Swap(ref arr[y], ref arr[length + 1]);
                            Swap(ref arr[z], ref arr[length + 2]);

                            Console.WriteLine("重排后字符串 ： " + new string(arr));
                            goto GT_1;
                        }
                    }
                }
            }

就是枚举百位、十位和个位。

 

重新审视一下，你会发现上面这个直接枚举的方法还是不够理想：数量级达到10^12，也比较恐怖了的……怎么办呢？

 

下面是一些优化的思路：

（基于上面说的：想要判断n是否满足n%8==0，只要判断n的末尾3位数字是否能被8整除即可。）

优化思路一：

判断是否可以整除8可以检查(i << 29) 是否等于0；

因为Int32%8==0和Int32<<29==0是同样的效果。  （这个怎么理解呢？其实是这样的： Int32<<29 把前面的29位二进制数移掉，最后的三位如果不等于0就是小于8的数字。毕竟0~7的二进制数才3位嘛，保留后三位其实就是保留了n mod 8的结果。）

这个做法很巧妙，不过呢，据说：操作系统寄存器内的取模运算，也是用的移位。（呵呵似乎这个优化没有太明显的效果）

优化思路二：

先写出从000-999所有能被8乘除的数, 一共125个

然后判断输入的数字中, 是否含有这125个数中的任何一个

比方说, 128能被8整除
那么如果输入的数字中同时含有1,2,8这三个数, 那么这个输入就是符合条件的

 

嗯，这个思路很好很不错。从编程实现来说呢就是要：

先统计输入的字符串里面0到9各自出现的次数（保存到数组int a[10]当中。）

然后预先把000到999之间能被8整除的那125个数左右存到数组b[ ]当中。

最后，逐一检验b数组的每一个元素的值，判断b[i]的三个位是否都在a数组的统计结果当中有非0个的存在即可。

代码不写了呵呵

 

话说回来，统计a[ ]的值时，应该不是一定非得扫描完整个字符串。只要a[0]~a[9]的值都>=3就行了。当然，假如扫描完了都没法实现“a[0]~a[9]的值都>=3”，那也不要紧了。直接进入下一步吧