想到了一个新的解法，求20亿以内的双立方数只用1秒。

最近在园子里看到了几篇关于这个双立方数的文章，自己也很有兴趣，希望能找到一个好的算法。

题目要求：双倍超立方数是指一个正整数可以正好被拆分为两种不同的a^3+b^3的方式，其中a,b均为整数且0<a<=b。对于任何一个指定的 int n, 返回所有的小于等于n的双倍超立方数的个数。

最开始想到的算法是这样的：

 1。找到所有的小于给定的最大整数N的所有立方数，就是满足 y=x*x*x （x,y都为正整数）的 y，并把它们都存在一个Hash表里。

 2。 遍历所有从1到N的每一个整数n，作如下处理：

　　　　2.1 遍历Hash表中的每一个小于等于 n/2 的立方数 y，如果 n-y 存在于 Hash表中，则说明 n可以表述为两个立方数的和。

　　　　2.2 如果正好存在两个 y ,满足2.1的条件，则n满足题设条件。

 3。输出满足条件的n的个数。

 但是这样的思路，无论怎么优化，一旦N>10^8,都不会小于一分钟。

后来，突发奇想，我为什么要测试每一个n是不是满足条件呢，为什么不倒过来，通过y来计算n呢？

于是有了现在的这个算法：

1。 找到所有的小于给定的最大整数N的所有立方数，就是满足 y=x*x*x （x,y都为正整数）的 y，并把它们都存在一个链表(或者是数组)List里。

2。对List的每一个立方数y1，作如下处理：

　　对List里的每一个大于等于y1的立方数y2，计算y1+y2,并把计算结果保存在一个字典 Dic 里，key为y1+y2,value为 1 ，如果字典中已存在key=y1+y2,

　　则 Dic[y1+y2]的value加1。

 3。找到Dic中所有value为2的key,并输出其个数。

由于List的中的元素数量（小于N的开立方）远远小于N，所以算法效率有了质的提高，在N=2*10^9的情况下，小于1秒。

下面是实现：

 1        private static int GetDoubleCubeCount(int n)
 2        {
 3            int[] arCubes = new int[(int)Math.Floor(Math.Pow(n, 1.0 / 3))];
 4            Dictionary<int, int> dicDblTubes = new Dictionary<int, int>();
 5
 6            int t = 1;
 7            int index = 0;
 8            int doubleCube = 0;
 9
10            while (index < arCubes.Length)
11            {
12                arCubes[index++] = t * t * t;
13                t++;
14            }
15
16            for (int i = 0; i < arCubes.Length; i++)
17            {
18                for (int j = i; j < arCubes.Length; j++)
19                {
20                    doubleCube = arCubes[i] + arCubes[j];
21                    if (doubleCube > n) break;
22
23                    if (dicDblTubes.ContainsKey(doubleCube))
24                    {
25                        dicDblTubes[doubleCube]++;
26                    }
27                    else
28                    {
29                        dicDblTubes.Add(doubleCube, 1);
30                    }
31                }
32            }
33
34            n = 0;
35
36            foreach (int value in dicDblTubes.Values)
37            {
38                if (value == 2)
39                {
40                    n++;
41                }
42            }
43            return n;
44        }

上面的实现仅仅是对思路的完整实现，应该还有很大的优化空间，哪位朋友要是有更好的想法，或者是优化的方法，还希望能多多交流。 由于俺的电脑是单核的，没有优化算法适应多核，多核的话，应该更快啦。