Timus 1318. Logarithm

最新推荐文章于 2025-09-10 21:15:00 发布

weixin_34349320

最新推荐文章于 2025-09-10 21:15:00 发布

阅读量195

点赞数

文章标签：开发工具 c#

本文详细解析Timus1318.Logarithm问题的算法实现过程，针对128-bit数进行XOR运算后取对数求和的挑战，介绍了高效的分治法解决方案及直接计算法。

Timus 1318. Logarithm 要求将一些 128-bit 数进行 XOR 运算后，取对数(只计算到整数部分)，然后求它们的和。

1318. Logarithm

Time Limit: 1.0 second
Memory Limit: 16 MB

Given a set A of N unordered 128-bit numbers. You are to compute a value of the function

where A _k — the k ^th element of A, log ₁₀X — the integer part of the decimal logarithm of X. We’ll assume that log ₁₀0 = 0.

Input

The first input line contains a number N <= 5000. In the following N lines there are 128-bit numbers A _k presented by sets of numbers (a _1k, a _2k, a _3k, a _4k), each of them lies in range from 0 to 2 ³²-1. The number A _k can be obtained from this set according to the formula

A _k = 2 ⁹⁶a _1k + 2 ⁶⁴a _2k + 2 ³²a _3k + a _4k.

Output

You are to output the value of the function for the given set.

Sample

input	output
2 0 0 0 2324 0 2332 0 0	44

Problem Author: Idea: Nikita Shamgunov, prepared by Nikita Shamgunov, Anton Botov
Problem Source: VIII Collegiate Students Urals Programming Contest. Yekaterinburg, March 11-16, 2004

解答如下(只保留 Main 方法)：

     static void Main()
    {
      UInt128[] numbers = UInt128.Read(Console.In);
       int v = 0 ;
       for ( int i = 0 ; i < numbers.Length - 1 ; i ++ )
         for ( int j = i + 1 ; j < numbers.Length; j ++ )
          v += UInt128.Log10(UInt128.Xor(numbers[i], numbers[j]));
      Console.WriteLine(v * 2 );
    }

这个程序的算法是非常直接了当的。程序中用到了 BigInteger 类，其源代码在浅谈 BigInteger 这篇随笔中。

因为 2¹²⁸ ≈ 3.4 x 10³⁸，所以在程序中使用一个数组来存储 10⁰, 10¹, ... 10³⁸ 各个数(程序中第 28 行)。在计算对数时，即程序中第 80 行开始的 Log10 方法中，使用二分搜索法在该数组中查找就行了。

这道题目限时是 1.0 秒。问题是我的这个程序运行时会超时，无法 Accept。我想不出来还有什么更快的方法了。谁可以告诉我更好的算法？

(以下是 2009-03-17 补充的，并于 2009-03-19 修改)

根据本文5楼的评论，参阅了数学研发论坛上的“关于一个运算优化的问题”的贴子，终于把这题通过了。

根据本文12楼的评论，修改后的程序的运行时间是 0.218 秒。

首先，根据该贴子，我们有以下定理：

如果 log ₂10 ⁿ < log ₂X < log ₂10 ⁿ⁺¹ 并且 log ₂Y < log ₂X，则：log ₁₀(X xor Y) = n

上面定理中的所有对数的值都要取整。实际上，log₂X 就表示 X 的二进制位数。同样，log₁₀X 就表示 X 的十进制位数。

利用上面的定理，就可以用分治法来解这道题。

还是先看看 C# 源程序吧：

  1 using System;
  2 using System.IO;
  3
  4 namespace Skyiv.Ben.Timus
  5 {
  6    // http://acm.timus.ru/problem.aspx?space=1 &num=1318
  7    sealed class T1318
  8   {
  9      static void Main()
10     {
11       var p = UInt128.Read(Console.In);
12       Array.Sort(p);
13       Console.WriteLine( 2 * Solve(p, 127 , 0 , p.Length - 1 ));
14     }
15
16      static int Solve(UInt128[] p, int bit, int low, int high)
17     {
18        if (bit < 3 || low >= high) return 0 ;
19       var mid = BinarySearch(p, bit, low, high);
20       var v = Solve(p, bit, low, high, mid);
21       v += Solve(p, bit - 1 , low, mid - 1 );
22       v += Solve(p, bit - 1 , mid, high);
23        return v;
24     }
25
26      static int Solve(UInt128[] p, int bit, int low, int high, int mid)
27     {
28        if (low >= mid || mid > high) return 0 ;
29       var n = UInt128.Log10s[bit];
30        if (n >= 0 ) return n * (mid - low) * (high - mid + 1 );
31        return Solve(p, bit - 1 , - n, low, mid - 1 , mid, high);
32     }
33
34      static int Solve(UInt128[] p, int bit, int n, int low0, int high0, int low1, int high1)
35     {
36        if (bit < 3 || low0 > high0 || low1 > high1) return 0 ;
37       var mid0 = BinarySearch(p, bit, low0, high0);
38       var mid1 = BinarySearch(p, bit, low1, high1);
39        if (UInt128.Powers[n].IsSetBit(bit)) return
40         ((mid0 - low0) * (mid1 - low1) + (high0 + 1 - mid0) * (high1 + 1 - mid1)) * (n - 1 ) +
41         Solve(p, bit - 1 , n, low0, mid0 - 1 , mid1, high1) +
42         Solve(p, bit - 1 , n, mid0, high0, low1, mid1 - 1 );
43        else return
44         ((mid0 - low0) * (high1 + 1 - mid1) + (high0 + 1 - mid0) * (mid1 - low1)) * n +
45         Solve(p, bit - 1 , n, low0, mid0 - 1 , low1, mid1 - 1 ) +
46         Solve(p, bit - 1 , n, mid0, high0, mid1, high1);
47     }
48
49      static int BinarySearch(UInt128[] p, int bit, int low, int high)
50     {
51       var isSet = false ;
52        int mid = 0 , i = low, j = high;
53        while (i <= j)
54          if (isSet = p[mid = (i + j) / 2 ].IsSetBit(bit)) j = mid - 1 ;
55          else i = mid + 1 ;
56        return isSet ? mid : (mid + 1 );
57     }
58   }
59
60    sealed class UInt128 : IComparable < UInt128 >
61   {
62      public static readonly UInt128[] Powers = new UInt128[ 39 ]; // 存放 10 的 0, 1,

, 38 次幂
63      public static readonly int [] Log10s = new int [ 128 ]; // 值域为: [-38, 38]
64      uint [] data;
65
66      static UInt128()
67     {
68       var log2s = new int [Powers.Length];
69       BigInteger p32 = BigInteger.Pow( 2 , 32 ), p64 = p32 * p32, p96 = p64 * p32, q = 1 ;
70        for (var i = 0 ; i < Powers.Length; i ++ , q *= 10 )
71       {
72         BigInteger r;
73         var u0 = uint .Parse(BigInteger.DivRem(q, p96, out r).ToString());
74         var u1 = uint .Parse(BigInteger.DivRem(r, p64, out r).ToString());
75         var u2 = uint .Parse(BigInteger.DivRem(r, p32, out r).ToString());
76         Powers[i] = new UInt128( uint .Parse(r.ToString()), u2, u1, u0);
77         log2s[i] = Powers[i].Log2();
78       }
79        for ( int i = 1 , j = 0 ; i < Log10s.Length; i ++ )
80       {
81          if (j < log2s.Length - 1 && i == log2s[j + 1 ]) j ++ ;
82         Log10s[i] = (i == log2s[j]) ? - j : j;
83       }
84     }
85
86     UInt128( params uint [] data)
87     {
88        this .data = new uint [ 128 / 32 ];
89        for ( int i = data.Length - 1 ; i >= 0 ; i -- ) this .data[i] = data[i];
90     }
91
92      static UInt128 FromInt32s( string s)
93     {
94       var u = s.Split();
95        return new UInt128( uint .Parse(u[ 3 ]), uint .Parse(u[ 2 ]), uint .Parse(u[ 1 ]), uint .Parse(u[ 0 ]));
96     }
97
98      public int CompareTo(UInt128 other)
99     {
100        if (data[ 3 ] > other.data[ 3 ]) return 1 ;
101        if (data[ 3 ] < other.data[ 3 ]) return - 1 ;
102        if (data[ 2 ] > other.data[ 2 ]) return 1 ;
103        if (data[ 2 ] < other.data[ 2 ]) return - 1 ;
104        if (data[ 1 ] > other.data[ 1 ]) return 1 ;
105        if (data[ 1 ] < other.data[ 1 ]) return - 1 ;
106        if (data[ 0 ] > other.data[ 0 ]) return 1 ;
107        if (data[ 0 ] < other.data[ 0 ]) return - 1 ;
108        return 0 ;
109     }
110
111      public static UInt128[] Read(TextReader reader)
112     {
113       var p = new UInt128[ int .Parse(reader.ReadLine())];
114        for (var i = p.Length - 1 ; i >= 0 ; i -- ) p[i] = UInt128.FromInt32s(reader.ReadLine());
115        return p;
116     }
117
118      int Log2()
119     {
120        int [] bs = { 0 , 32 , 64 , 96 };
121        for (var i = 3 ; i >= 0 ; i -- )
122       {
123         var u = data[i];
124          if (u == 0 ) continue ;
125          for (var bit = 31 ; bit >= 0 ; bit -- , u <<= 1 )
126            if (( ~ int .MaxValue & u) != 0 ) return bit + bs[i];
127       }
128        return - 1 ;
129     }
130
131      public bool IsSetBit( int bit)
132     {
133        return ((data[bit / 32 ] >> (bit % 32 )) & 1 ) != 0 ;
134     }
135   }
136 }

程序中，Main 方法位于第 9 到 14 行。第 11 行读取输入到一个 UInt128 数组中。第 12 行将该数组排序。第 13 行调用 Solve 方法进行分治法递归计算来解题。其中传入的参数 127 表示从 UInt128 的最高位开始，逐步往低位计算。

在第 16 到 24 行的 Solve 方法中，第 19 行的 mid 指示数组 p 的首个使第 bit 位为 1 的元素。这样，根据 mid 就把数组 p 的元素分为两组，第 20 行调用第二个 Solve 方法处理这两组之间的元素。第 21 和 22 行递归调用 Solve 自身分别处理这两组内的元素。

在第 26 到 32 行的第二个 Solve 方法中，如果发现这两组元素满足上面定理的条件，则在第 30 行直接将计算结果返回。否则，就在第 31 行调用第三个 Solve 方法来处理。

在第 34 到 47 行的第三个 Solve 方法中，继续根据低一位的第 bit 位再把这两组元素分别分为两组。这四组元素之间异或后的对数值不是 n 就是 n - 1。这时根据 10ⁿ 的二进制表示法中第 bit 位来判断是哪种情况。其中有两组可以直接得到结果，另外两组就递归地调用自身来处理。

实际上这整个程序都没有进行过 Xor 和 Log₁₀ 运算，而是不断通过分组进行处理。

第 60 到 136 行就是 UInt128 类。

第 62 行的 powers 静态数组存放 10⁰, 10¹, ..., 10³⁸。

第 63 行的 Log10s 静态数组存放的是 log₁₀2ⁿ，其中 n 从 0 到 127。这个数组的意思是指定的二进制位的数所对应的十进制数有几位，并且该位数第一个出现时对应的数组元素取负值。这个数组在程序的第 29 行用来判断是否满足上述定理的条件。

第 64 行的 data 数组使用 4 个 UInt32 来表示 UInt128。

第 66 到 84 行的静态构造函数用来初始化以上两个静态数组。

UInt128 类的其它方法也都很简单，就不多说了。

(以下是 2009-03-26 补充的)

这个程序还可以优化，即事先计算出静态数组 Powers 和 Log10s 的值，不使用 BigInteger 类。将递归中没有改变的参数 p 外提为类的字段。如下所示：

  1 using System;
  2 using System.IO;
  3
  4 namespace Skyiv.Ben.Timus
  5 {
  6    // http://acm.timus.ru/problem.aspx?space=1 &num=1318
  7    sealed class T1318
  8   {
  9      static UInt128[] p;
10      static int n;
11
12      static void Main()
13     {
14       Array.Sort(p = UInt128.Read(Console.In));
15       Console.WriteLine( 2 * Solve( 127 , 0 , p.Length - 1 ));
16     }
17
18      static int Solve( int bit, int low, int high)
19     {
20        if (bit < 3 || low >= high) return 0 ;
21       var mid = BinarySearch(bit, low, high);
22        return Solve(bit, low, high, mid) +
23         Solve(bit - 1 , low, mid - 1 ) +
24         Solve(bit - 1 , mid, high);
25     }
26
27      static int Solve( int bit, int low, int high, int mid)
28     {
29        if (low >= mid || mid > high) return 0 ;
30       n = UInt128.Log10s[bit];
31        if (n >= 0 ) return n * (mid - low) * (high - mid + 1 );
32       n = - n;
33        return Solve(bit - 1 , low, mid - 1 , mid, high);
34     }
35
36      static int Solve( int bit, int low0, int high0, int low1, int high1)
37     {
38        if (bit < 3 || low0 > high0 || low1 > high1) return 0 ;
39       var mid0 = BinarySearch(bit, low0, high0);
40       var mid1 = BinarySearch(bit, low1, high1);
41        return UInt128.Powers[n].IsSetBit(bit) ?
42         (((mid0 - low0) * (mid1 - low1) + (high0 + 1 - mid0) * (high1 + 1 - mid1)) * (n - 1 ) +
43         Solve(bit - 1 , low0, mid0 - 1 , mid1, high1) +
44         Solve(bit - 1 , mid0, high0, low1, mid1 - 1 )) :
45         (((mid0 - low0) * (high1 + 1 - mid1) + (high0 + 1 - mid0) * (mid1 - low1)) * n +
46         Solve(bit - 1 , low0, mid0 - 1 , low1, mid1 - 1 ) +
47         Solve(bit - 1 , mid0, high0, mid1, high1));
48     }
49
50      static int BinarySearch( int bit, int low, int high)
51     {
52       var isSet = false ;
53        int mid = 0 , i = low, j = high;
54        while (i <= j)
55          if (isSet = p[mid = (i + j) / 2 ].IsSetBit(bit)) j = mid - 1 ;
56          else i = mid + 1 ;
57        return isSet ? mid : (mid + 1 );
58     }
59   }
60
61    sealed class UInt128 : IComparable < UInt128 >
62   {
63      public static readonly UInt128[] Powers =
64     {
65        new UInt128( 1 , 0 , 0 , 0 ),
66        new UInt128( 10 , 0 , 0 , 0 ),
67        new UInt128( 100 , 0 , 0 , 0 ),
68        new UInt128( 1000 , 0 , 0 , 0 ),
69        new UInt128( 10000 , 0 , 0 , 0 ),
70        new UInt128( 100000 , 0 , 0 , 0 ),
71        new UInt128( 1000000 , 0 , 0 , 0 ),
72        new UInt128( 10000000 , 0 , 0 , 0 ),
73        new UInt128( 100000000 , 0 , 0 , 0 ),
74        new UInt128( 1000000000 , 0 , 0 , 0 ),
75        new UInt128( 1410065408 , 2 , 0 , 0 ),
76        new UInt128( 1215752192 , 23 , 0 , 0 ),
77        new UInt128( 3567587328 , 232 , 0 , 0 ),
78        new UInt128( 1316134912 , 2328 , 0 , 0 ),
79        new UInt128( 276447232 , 23283 , 0 , 0 ),
80        new UInt128( 2764472320 , 232830 , 0 , 0 ),
81        new UInt128( 1874919424 , 2328306 , 0 , 0 ),
82        new UInt128( 1569325056 , 23283064 , 0 , 0 ),
83        new UInt128( 2808348672 , 232830643 , 0 , 0 ),
84        new UInt128( 2313682944 , 2328306436 , 0 , 0 ),
85        new UInt128( 1661992960 , 1808227885 , 5 , 0 ),
86        new UInt128( 3735027712 , 902409669 , 54 , 0 ),
87        new UInt128( 2990538752 , 434162106 , 542 , 0 ),
88        new UInt128( 4135583744 , 46653770 , 5421 , 0 ),
89        new UInt128( 2701131776 , 466537709 , 54210 , 0 ),
90        new UInt128( 1241513984 , 370409800 , 542101 , 0 ),
91        new UInt128( 3825205248 , 3704098002 , 5421010 , 0 ),
92        new UInt128( 3892314112 , 2681241660 , 54210108 , 0 ),
93        new UInt128( 268435456 , 1042612833 , 542101086 , 0 ),
94        new UInt128( 2684354560 , 1836193738 , 1126043566 , 1 ),
95        new UInt128( 1073741824 , 1182068202 , 2670501072 , 12 ),
96        new UInt128( 2147483648 , 3230747430 , 935206946 , 126 ),
97        new UInt128( 0 , 2242703233 , 762134875 , 1262 ),
98        new UInt128( 0 , 952195850 , 3326381459 , 12621 ),
99        new UInt128( 0 , 932023908 , 3199043520 , 126217 ),
100        new UInt128( 0 , 730304488 , 1925664130 , 1262177 ),
101        new UInt128( 0 , 3008077584 , 2076772117 , 12621774 ),
102        new UInt128( 0 , 16004768 , 3587851993 , 126217744 ),
103        new UInt128( 0 , 160047680 , 1518781562 , 1262177448 )
104     };
105      public static readonly int [] Log10s =
106     {
107        0 , 0 , 0 , - 1 , 1 , 1 , - 2 , 2 , 2 , - 3 , 3 , 3 , 3 , - 4 , 4 , 4 , - 5 , 5 , 5 , - 6 , 6 , 6 , 6 , - 7 , 7 , 7 ,
108        - 8 , 8 , 8 , - 9 , 9 , 9 , 9 , - 10 , 10 , 10 , - 11 , 11 , 11 , - 12 , 12 , 12 , 12 , - 13 , 13 , 13 ,
109        - 14 , 14 , 14 , - 15 , 15 , 15 , 15 , - 16 , 16 , 16 , - 17 , 17 , 17 , - 18 , 18 , 18 , 18 ,
110        - 19 , 19 , 19 , - 20 , 20 , 20 , - 21 , 21 , 21 , 21 , - 22 , 22 , 22 , - 23 , 23 , 23 ,
111        - 24 , 24 , 24 , 24 , - 25 , 25 , 25 , - 26 , 26 , 26 , - 27 , 27 , 27 , 27 , - 28 , 28 , 28 ,
112        - 29 , 29 , 29 , - 30 , 30 , 30 , - 31 , 31 , 31 , 31 , - 32 , 32 , 32 , - 33 , 33 , 33 ,
113        - 34 , 34 , 34 , 34 , - 35 , 35 , 35 , - 36 , 36 , 36 , - 37 , 37 , 37 , 37 , - 38 , 38
114     };
115      uint [] data;
116
117     UInt128( params uint [] data)
118     {
119        this .data = new uint [ 128 / 32 ];
120        for ( int i = data.Length - 1 ; i >= 0 ; i -- ) this .data[i] = data[i];
121     }
122
123      public int CompareTo(UInt128 other)
124     {
125        if (data[ 3 ] > other.data[ 3 ]) return 1 ;
126        if (data[ 3 ] < other.data[ 3 ]) return - 1 ;
127        if (data[ 2 ] > other.data[ 2 ]) return 1 ;
128        if (data[ 2 ] < other.data[ 2 ]) return - 1 ;
129        if (data[ 1 ] > other.data[ 1 ]) return 1 ;
130        if (data[ 1 ] < other.data[ 1 ]) return - 1 ;
131        if (data[ 0 ] > other.data[ 0 ]) return 1 ;
132        if (data[ 0 ] < other.data[ 0 ]) return - 1 ;
133        return 0 ;
134     }
135
136      public bool IsSetBit( int bit)
137     {
138        return ((data[bit / 32 ] >> (bit % 32 )) & 1 ) != 0 ;
139     }
140
141      public static UInt128[] Read(TextReader reader)
142     {
143       var p = new UInt128[ int .Parse(reader.ReadLine())];
144        for (var i = p.Length - 1 ; i >= 0 ; i -- )
145       {
146         var u = reader.ReadLine().Split();
147         p[i] = new UInt128( uint .Parse(u[ 3 ]), uint .Parse(u[ 2 ]), uint .Parse(u[ 1 ]), uint .Parse(u[ 0 ]));
148       }
149        return p;
150     }
151   }
152 }

优化后程序的运行时间降低到 0.156 秒。

另外，按以下方法直接计算也是可以的，运行时间为 0.406 秒。

1 using System;
2 using System.IO;
3
4 namespace Skyiv.Ben.Timus
5 {
6    // http://acm.timus.ru/problem.aspx?space=1 &num=1318
7    sealed class T1318b
8   {
9      static readonly int nUInt = 128 / 32 ;
10
11      static void Main()
12     {
13       var p = Read(Console.In);
14       Console.WriteLine( 2 * Solve(p));
15     }
16
17      static uint [] Read(TextReader reader)
18     {
19       var n = int .Parse(reader.ReadLine());
20       var p = new uint [n * nUInt];
21        for (var i = 0 ; i < n; i ++ )
22       {
23         var ss = reader.ReadLine().Split();
24          for (var j = 0 ; j < nUInt; j ++ ) p[i * nUInt + j] = uint .Parse(ss[j]);
25       }
26        return p;
27     }
28
29      static int Solve( uint [] p)
30     {
31       var v = 0 ;
32        for (var i = p.Length / nUInt - 1 ; i > 0 ; i -- )
33          for (var j = i - 1 ; j >= 0 ; j -- )
34         {
35           var u = i * nUInt;
36           var y = j * nUInt;
37           var a = p[u] ^ p[y];
38           var b = p[u + 1 ] ^ p[y + 1 ];
39           var c = p[u + 2 ] ^ p[y + 2 ];
40           var d = p[u + 3 ] ^ p[y + 3 ];
41            if (a == 0 && b == 0 && c == 0 ) goto label1;
42            if (a > 1262177448 || a == 1262177448 && (b > 1518781562 || b == 1518781562 && c >= 160047680 )) { v += 38 ; continue ; }
43            if (a > 126217744 || a == 126217744 && (b > 3587851993 || b == 3587851993 && c >= 16004768 )) { v += 37 ; continue ; }
44            if (a > 12621774 || a == 12621774 && (b > 2076772117 || b == 2076772117 && c >= 3008077584 )) { v += 36 ; continue ; }
45            if (a > 1262177 || a == 1262177 && (b > 1925664130 || b == 1925664130 && c >= 730304488 )) { v += 35 ; continue ; }
46            if (a > 126217 || a == 126217 && (b > 3199043520 || b == 3199043520 && c >= 932023908 )) { v += 34 ; continue ; }
47            if (a > 12621 || a == 12621 && (b > 3326381459 || b == 3326381459 && c >= 952195850 )) { v += 33 ; continue ; }
48            if (a > 1262 || a == 1262 && (b > 762134875 || b == 762134875 && c >= 2242703233 )) { v += 32 ; continue ; }
49            if (a > 126 || a == 126 && (b > 935206946 || b == 935206946 && (c > 3230747430 || c == 3230747430 && d > 2147483647 ))) { v += 31 ; continue ; }
50            if (a > 12 || a == 12 && (b > 2670501072 || b == 2670501072 && (c > 1182068202 || c == 1182068202 && d > 1073741823 ))) { v += 30 ; continue ; }
51            if (a > 1 || a == 1 && (b > 1126043566 || b == 1126043566 && (c > 1836193738 || c == 1836193738 && d > 2684354559 ))) { v += 29 ; continue ; }
52            if (a > 0 || b > 542101086 || b == 542101086 && (c > 1042612833 || c == 1042612833 && d > 268435455 )) { v += 28 ; continue ; }
53            if (b > 54210108 || b == 54210108 && (c > 2681241660 || c == 2681241660 && d > 3892314111 )) { v += 27 ; continue ; }
54            if (b > 5421010 || b == 5421010 && (c > 3704098002 || c == 3704098002 && d > 3825205247 )) { v += 26 ; continue ; }
55            if (b > 542101 || b == 542101 && (c > 370409800 || c == 370409800 && d > 1241513983 )) { v += 25 ; continue ; }
56            if (b > 54210 || b == 54210 && (c > 466537709 || c == 466537709 && d > 2701131775 )) { v += 24 ; continue ; }
57            if (b > 5421 || b == 5421 && (c > 46653770 || c == 46653770 && d > 4135583743 )) { v += 23 ; continue ; }
58            if (b > 542 || b == 542 && (c > 434162106 || c == 434162106 && d > 2990538751 )) { v += 22 ; continue ; }
59            if (b > 54 || b == 54 && (c > 902409669 || c == 902409669 && d > 3735027711 )) { v += 21 ; continue ; }
60            if (b > 5 || b == 5 && (c > 1808227885 || c == 1808227885 && d > 1661992959 )) { v += 20 ; continue ; }
61            if (b > 0 || c > 2328306436 || c == 2328306436 && d > 2328306435 ) { v += 19 ; continue ; }
62            if (c > 232830643 || c == 232830643 && d > 2808348671 ) { v += 18 ; continue ; }
63            if (c > 23283064 || c == 23283064 && d > 1569325055 ) { v += 17 ; continue ; }
64            if (c > 2328306 || c == 2328306 && d > 1874919423 ) { v += 16 ; continue ; }
65            if (c > 232830 || c == 232830 && d > 2764472319 ) { v += 15 ; continue ; }
66            if (c > 23283 || c == 23283 && d > 276447231 ) { v += 14 ; continue ; }
67            if (c > 2328 || c == 2328 && d > 1316134911 ) { v += 13 ; continue ; }
68            if (c > 232 || c == 232 && d > 3567587327 ) { v += 12 ; continue ; }
69            if (c > 23 || c == 23 && d > 1215752191 ) { v += 11 ; continue ; }
70            if (c > 2 || c == 2 && d > 1410065407 ) { v += 10 ; continue ; }
71         label1:
72            if (c > 0 || d > 999999999 ) { v += 9 ; continue ; }
73            if (d > 99999999 ) { v += 8 ; continue ; }
74            if (d > 9999999 ) { v += 7 ; continue ; }
75            if (d > 999999 ) { v += 6 ; continue ; }
76            if (d > 99999 ) { v += 5 ; continue ; }
77            if (d > 9999 ) { v += 4 ; continue ; }
78            if (d > 999 ) { v += 3 ; continue ; }
79            if (d > 99 ) { v += 2 ; continue ; }
80            if (d > 9 ) { v ++ ; continue ; }
81         }
82        return v;
83     }
84   }
85 }

返回目录