计算4000000000以内最大的f(n)=n的值---字符串问题python实现（五）

问题：

       写一个函数，计算4 000 000 000 以内的最大的那个f(n)=n的值，函数f的功能是统计所有0到n之间所有含有数字1的数字和。比如：f(13)= 6，因为“1”在“1,2,3,4,5,6,7,8,9,10,11,12,13”中的总数是6（1,10,11,12,13）。

分析：

       一、简单方法 — 枚举

       采用“枚举法”对每个数都计算一遍1的个数，直到枚举完给定范围所有数，找到符合f(n)=n的数。此方法，代码效率极低，运算所需时间巨大。

python版本代码如下：

# -*- coding:utf-8 -*-
# 问题：写一个函数，计算4 000 000 000 以内的最大的那个f(n)=n的值，
#      函数f的功能是统计所有0到n之间所有含有数字1的数字和。比如：f(13)= 6，
#      因为“1”在“1,2,3,4,5,6,7,8,9,10,11,12,13”中的总数是6（1,10,11,12,13）。
# by chasdmeng
import time
def Calculation_One_Times(n):
    res = 0
    while n > 0:
        if n == 1:res +=1
        n /=10
    return res

if __name__ == ‘__main__‘:
    times = 0
    i = 0
    gMAX = 4000000000L
    start = time.time()
    while i < gMAX:
        times +=Calculation_One_Times(i)
        if times ==i:print "f(", i, ") = ", times
        i +=1
    end = time.time()
    print "time:",end - start

       主要采用剪枝算法对代码执行效率进行优化。求解MAX(f(n)=n)具体算法构建分析如下：

       1、求数字“0~n”中“1”的个数

       基本思想：

       t位数字n，求0到n所有数字“1”的数字和，可对1到t位（1对应个位），每个位置上“1”出现的次数分别统计，然后求和。

       假设，0到n之间的自然数范围内，统计第m位为“1”的个数和，可以分四步骤。第一步骤，假设第二、三步骤的前提条件为第1到第m-1位内各位数字取固定值a。第二步骤，求大于m位的数字中有多少个数字第m位为“1”。第三步骤，求等于m位的数字中有多少个数字第m位为“1”。第四步骤，把第1到第m-1位内各位数字变化考虑进去。如下图所示。

       在第二步骤中，需要分两种情况考虑：

      （a）给定数n的第m位非0

       大于m位的数字中第m位为“1”的数字个数是n/10^m。

        （b）给定数n的第m位为0
       对于m位的数字中第m位为“1”的数字个数为（n/10^m）-1。这里举例说明，n=300，m=2，由于300的第2位为0，此时n/10^m=3，若按（a）中方法求解得出在第1位固定取a 的条件下（第一步骤中规定的）大于2位的数字中第2位为“1”的数字个数是3，这显然是错误的，因为在0到300中这样的数只有“11a”、“21a”，此时正确个数应该是n/10^m-1=2。
      （c）合并考虑

       大于m位的数字中第m位为“1”的数字个数为(n/(10^(m-1))-1)/10。构造了一个通用公式可以包含（a）、（b）两种情况。原理是，n/10^m=(n/(10^(m-1)))/10，由于是对n做除是向下取整运算，在给定数n第m位非0情况下，n/10^m=(n/(10^(m-1)))/10=(n/(10^(m-1))-1)/10；而当给定数n第m位为0情况下，(n/10^m)-1=(n/(10^(m-1))-1)/10。可以举具体数字对其验证。
       在第三步骤中，由于在第一步骤假定的前提条件，满足求等于m位的数字中第m位为“1”的个数只有1个。这里举例说明，n=300，m=2，2位数字中第2位为“1”的数仅有“1a”。
       在第四步骤中，综合第一、二、三步骤后，在第1到第m-1位内各位数字取固定值a的条件下，第m位为“1”的个数和为(n/(10^(m-1))- 1)/10+1。下面把第1到第m-1位内各位数字变化考虑进去，由于在第1到第m-1位中每一位可以放0~9之间任意数，m-1位数共有“10^m-1”个。最终，0到n之间的自然数范围内，第m位为“1”的个数和((n/(10^(m-1))- 1)/10+1）*(10^(m-1))。
       小结：对以上分析结果给予公式化定义。Cm=((n/i - 1)/10 + 1)*i，其中i=10^(m-1)，n为任意自然数，Cm为0到n的数中第m位为1 的 个数和。

       求数字“0~n”中“1”个数的GetTimes()函数，python版代码如下：

def GetTimes(n):
    temp = n
    temp2 =1
    ret = 0
    i = 1
    while temp/i:
        ret +=(((temp/i-1)/10)+1)*i
        if(((temp/i)%10) == 1):
            ret -=i
            ret +=temp2
        i*=10
        temp2=n%i+1
    return ret

       2、从0到n位最大数之间1的总个数，寻找数学规律

       当n=1,2,3,...,6,...时，分别计算从0到n位最大数之间1的总个数，部分数据如下：

       0~9          ：1
       0~99        ：20 = 10*1 + 10
       0~999      ：300 = 10*20 + 100
       0~9999    ：4000 = 10*300 + 1000
       0~99999  ：50000 = 10*4000 + 10000
       0~999999：600000 = 10*50000 + 100000
       …                   …

       从中，可以发现如下规律：

       a1 = 1
       a2 = 10*a1 + 10
       …
       an = 10*an - 1 + 10^(n - 1)
       即0~9…9（n个9）之间1的个数为an=10*an-1+10^(n-1)个。

       这样，当计算任意一个数字n的0到n之间所有数字1的个数和时，可以采用将数字n拆分成0~9、0~99... 等部分进行之间计算。例如：n=123，可将n拆分为0~99和100~123计算：(1)0~99对应1的个数和直接可知为20；(2)百位数1的个数为23+1个；(3)剩下的0~23继续拆分为0~9、10~19、20~23，共两个0~9个数为2；(4)因为23中十位数2>1，十位为1的个数10；(5)现在就剩下20~23了，个数为1。所以，0~123中1的个数为20+24+2+10+1=57。

       因此，在求任意数0~n内所有1的个数和时，可以首先建立“int  gTable[10]”结构用于存放a1、a2、a3、...、a9、a10，其中an表示0~n内所有1的个数，然后将数n拆分为0~9、0~99... 等部分直接使用gTable的值进行计算。这种方式可以提高算法效率。

       生成gTable[]结构的TimesTable()函数，python版代码如下：

def TimesTable(n):
    return [GetTimes(10**(i+1) - 1) for i in xrange(n)]

       3、采用剪枝算法搜索0~n之间满足f(q)=q的数

       由于若对0~n的所有数据进行枚举验证f(q)=q，当n值很大时运算相当费时，从本文开头给出的“最简单方法”中可以感受到代码效率有多么低。为了优化算法提高效率可采用减枝算法，其思想是对0~n之间所有数建立搜索树，对不符合条件的搜索树进行剪枝，这样就可以极大缩小搜索范围，提高算法效率。如何构建剪枝规则呢？首先对这个问题进行数学化描述：

       定义1：设 f（x）=y，其中x∈ （0，n），f为x与对应的（0，x）上所有数字1的个数总和y的映射。

       先观察下f(n)的特点，可以发现f(n)是一个单调递增函数，这样可以归纳出它的特性：

       性质1：若有f（m）=a，f（t）=b，且m<t，则存在q∈（m，t）满足f（q）=q成立的条件是：b>m 且a< t。

       现在就可以应用“性质1”进行减枝操作。具体来说通过“性质1”可知，当对0~n的所有数据进行枚举验证f(q)=q时，若当f(t)=b<m或f(m)=a>n，则在[m，t]范围内不存在满足f(q)=q成立的数q，这样就可忽略掉[m，t]内这些自然数，直接跳到n+1往后继续枚举。在应用剪枝算法枚举符合条件的f(q)=q时，是以t-m为步长在0~n内逐段排查是否可剪枝，若t-m范围内不满足剪枝条件则进行枚举搜索。因此在进行剪枝算法时[m，t]的范围取多大适合呢？这是需要慎重考虑的问题，合理的[m，t]取值能让大幅提升算法执行效率。下面就对[m，t]步长L取值进行分析。

       [m，t]的取值依据是能最大化提升算法效率，由于在“2、从0到n位最大数之间1的总个数，寻找数学规律。”中设置了“int  gTable[10]”结构用于计算f(n)，gTable分别表示0~9中1个数和1、0~99中1个数和20、0~999中1的个数和300...，可见是以10^p倍增长，而且f(n)还需要使用gTable去求解，因此初步考虑将[m，t]步长L=10^p，虽然[m，t]取10的倍数，但p具体取多少，还需要继续分析。

        对于任意s位数m，设s位数的最大值为max(s)，则f(max(s))=gTable[s-1]，假定取[m，t]步长L=10^s也就是 t=m+10^s，设f(m)=a、f(m+10^s)=b，则有m<max(s)<m+10^s，由于f()为单调增函数，推出gT[s-1]=f(max(s))<f(m+10^s)=b，a<gTable[s-1]，又因为在0~10^10-1的范围内有max(s)>gTable[s-1]（可以举例验证），推出a<gTable[s-1]<max(s)<10+10^s，即a<m+10^s。f(m+10^s)=f(10^s-1)+m+1+f(m)=b，即b>m，因此根据性质1可知m=d*10^s时，取[m，t]步长L=10^s恒不满足减枝条件，同理步长L=10^(s+1)也无法满足剪枝条件，因此只能往下取值。对于任意s位数m，取步长L<=10^(s-1)某些数内可以满足减枝条件，举例来说，m=20，s=2，L=10^(s-1)=10，则在[20，30]内f(20)=12、f(30)=13，根据性质1可以剪枝掉[20，30]范围内的数。综上所述，对任意s位数m，m∈ （0，n），剪枝算法初始步长L=10^(s-1)   。

       性质2：若有f（m）=a，f（t）=b，且m<t，满足b>m 且a< t时，有f(q)=q，且q∈（m，b]。

       性质2是由性质1推到而来，性质2中将原来性质1中q∈（m，t）缩小为q∈（m，b）。首先在0~10^10-1的范围内满足性质1条件下可知b∈（m，t]，设f(b+1)=c，则在(b+1，t)内f(b+1)=c、f(t)=b根据性质1不存在q∈（b+1，t）使f(q)=q成立。所以，在（m，t）内使f(q)=q成立的q∈（m，b]。

        剪枝算法整体思想是：n位数m，步长L=10^(n-1)，在区间（m-1，m+L-1）判断是否满足f(m-1)>boundary或f(m+L-1)<m ，满足就直接跳到m=m+L计算，否则在区间（m-1，f(m+L-1)+L-1）上置步长L=L/10递归重复执行剪枝判断，当递归到步长L=1时，进行逐值枚举f(number)是否等于number。由于算法中m是从0开始枚举取值，以10的倍数递增，因此所有的m都应满足abc*10^s格式，也就是说，m取到的是10的倍数。因此有如下性质。

       性质3：m=abc*10^(n-1)，L=10^(n-1)，可知f(m-1+L)=f(m-1)+gTable[n-2]+count_one_m*L，其中count_one_m=f(m)-f(m-1)，也就是代表数字m本身包含1的个数。

       剪枝算法CalculationTimes()函数，python版代码如下 ： 

def CalculationTimes(number, weight, count_one, count, table):
    if weight == 0:
        count += count_one
        if number == count:
            print "f(", number, ") = ", number
        return count
    L=10**weight
    maxcount = count + table[weight - 1]
    maxcount += count_one*L
    if count > (number + L -1):
        return maxcount
    if maxcount < number:
        return maxcount
    L /= 10
    for i in range(10):
        if i == 1:
            count = CalculationTimes(number + i*L, weight - 1, count_one + 1, count, table)
        elif i == maxcount/n - 9:
            return maxcount
        else:
            count = CalculationTimes(number + i*L, weight - 1, count_one , count, table)
    return count

       其中，对应前面剪枝算法思想，这里number代表m，weight代表步长L=10^(s-1) 中的s-1，count_one表示数n中各个位置上1的个数，比如n=112，这count_one=2，table代表gTable[]，count代表f(m-1)。具体解释如下：

if weight == 0:
        count += count_one
        if number == count:
            print "f(", number, ") = ", number
        return count

    L=10**weight
    maxcount = count + table[weight - 1]
    maxcount += count_one*L
    if count > (number + L -1):
        return maxcount
    if maxcount < number:
        return maxcount

此部分代码功能执行剪枝操作，首先设置步长L=10^weight，根据性质3得f(number+L-1)=count+table[weight-1]+count_one*L，然后根据性质1判断是否可以剪枝，若符合条件直接忽略（number-1，number+L-1）范围内数字并跳转到number+L再计算。

    L /= 10
    for i in range(10):
        if i == 1:
            count = CalculationTimes(number + i*L, weight - 1, count_one + 1, count, table)
        elif i == maxcount/n - 9:
            return maxcount
        else:
            count = CalculationTimes(number + i*L, weight - 1, count_one , count, table)
    return count

       最后，给出整体实现代码。

# -*- coding:utf-8 -*-
# 问题：写一个函数，计算4 000 000 000 以内的最大的那个f(n)=n的值，
#      函数f的功能是统计所有0到n之间所有含有数字1的数字和。比如：f(13)= 6，
#      因为“1”在“1,2,3,4,5,6,7,8,9,10,11,12,13”中的总数是6（1,10,11,12,13）。
# by chasdmeng
import time 
def GetTimes(n):
    temp = n
    temp2 =1
    ret = 0
    i = 1
    while temp/i:
        ret +=(((temp/i-1)/10)+1)*i
        if(((temp/i)%10) == 1):
            ret -=i
            ret +=temp2
        i*=10
        temp2=n%i+1
    return ret
def TimesTable(n):
    return [GetTimes(10**(i+1) - 1) for i in xrange(n)]
def CountOne(n):
    count = 0
    while n:
        if (n%10) == 1:count +=1
        n /=10
    return count
def CalculationTimes(number, weight, count_one, count, table):
    if weight == 0:
        count += count_one
        if number == count:
            print "f(", number, ") = ", number
        return count
    L=10**weight
    maxcount = count + table[weight - 1]
    maxcount += count_one*L
    if count > (number + L -1):
        return maxcount
    if maxcount < number:
        return maxcount
    L /= 10
    for i in range(10):
        if i == 1:
            count = CalculationTimes(number + i*L, weight - 1, count_one + 1, count, table)
        elif i == maxcount/n - 9:
            return maxcount
        else:
            count = CalculationTimes(number + i*L, weight - 1, count_one , count, table)
    return count

if __name__ == ‘__main__‘:
    n = 0
    weight = 0
    count = 0
    count_one = 0
    gMAX = 4000000000L
    start = time.time()
    table = TimesTable(10)
    while n < gMAX:
        count = CalculationTimes(n, weight, count_one , count, table)
        L = 10**weight
        n += L
        if (n/L)/10 == 1: weight +=1
        count_one = CountOne(n)
    end = time.time()
    print "time:",end - start

                                                                                                                                                         by       chasdmeng

参考文献：

      博客：http://blog.csdn.net/livelylittlefish/article/details/2768348

      书籍：《程序员面试宝典（第4版）》P240，面试例题5

计算4000000000以内最大的f(n)=n的值---字符串问题python实现（五）,布布扣,bubuko.com

计算4000000000以内最大的f(n)=n的值---字符串问题python实现（五）

原文：http://blog.csdn.net/chasdmeng/article/details/25916395