免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
12下一页
最近访问板块 发新帖
查看: 29590 | 回复: 12
打印 上一主题 下一主题

[算法] 变态的算法题 [复制链接]

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
1 [报告]
发表于 2011-05-14 02:17 |显示全部楼层
晕死,这里哪有用到乘法啊,分明就只有加法。

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
2 [报告]
发表于 2011-05-14 02:20 |显示全部楼层
我给个思路吧。

不用去算数。

char N[21]

用循环的方式。

先计算 21 一个 1 的结果,
然后是  20 个 1 , 一个 2 ...
依次类推

在每次便利中,寻找一个可能的 21 个数字的排序使得结合的大叔是一样大的。

大数用 long long 就可以表示了吧?

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
3 [报告]
发表于 2011-05-14 02:21 |显示全部楼层
利用  99 乘法表,直接查表不通过计算。

晕死,我马上写一个,我对这个数字的确切大小非常感兴趣。

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
4 [报告]
发表于 2011-05-14 02:38 |显示全部楼层
晕死。 穷举法都不需要3分钟就跑出来了

我还以为这3分钟时间限制是要多牛逼的算法 ....

看来硬件的发展还是可以解放脑力的啊

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
5 [报告]
发表于 2011-05-14 06:02 |显示全部楼层
折腾啊我!!

cai@cai ~/workspace/n21cal $ time ./Debug/n21cal  
1732949 种组合
the number is 128468643043731391252

real        0m11.479s
user        0m11.165s
sys        0m0.268s

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
6 [报告]
发表于 2011-05-14 06:03 |显示全部楼层
本帖最后由 蔡万钊 于 2011-05-14 06:32 编辑

  1. /*
  2. ============================================================================
  3. Name        : n21cal.c
  4. Author      :
  5. Version     :
  6. Copyright   : Your copyright notice
  7. Description : Hello World in C, Ansi-style
  8. ============================================================================
  9. */

  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>

  13. typedef struct {
  14.         unsigned long h;
  15.         unsigned long l;
  16. }bignumber;

  17. bignumber table[10]={
  18.                 {0,0},
  19.                 {0UL,1UL},
  20.                 {0UL,2097152UL},
  21.                 {0UL,10460353203UL},
  22.                 {0UL,4398046511104UL},
  23.                 {0UL,476837158203125UL},
  24.                 {0UL,21936950640377856UL},
  25.                 {0UL,558545864083284007UL},
  26.                 {0UL,9223372036854775808UL},

  27.                 {0x5UL,0xEE7E56E3721F2929UL},

  28. };

  29. bignumber del(bignumber a, bignumber b)
  30. {
  31.         bignumber c= {0,0};
  32.         c.l = a.l - b.l;

  33.         if(a.l < b.l )
  34.         {
  35.                 a.h --;
  36. //                c.l++;
  37.         }

  38.         c.h = a.h - b.h;

  39.         return c;
  40. }

  41. bignumber add(bignumber a, bignumber b)
  42. {
  43.         bignumber c= {0,0};

  44.         c.l = a.l + b.l;

  45.         if( ( (-1UL) - a.l ) < b.l)
  46.                 c.h ++;
  47.         c.h += a.h + b.h;

  48.         return c;
  49. }


  50. //获得对应的数字
  51. bignumber get_table( int i)
  52. {

  53.         return table[i];

  54. }

  55. bignumber get_n_i(int b , int i )
  56. {
  57.         bignumber c = {0};
  58.         for(; i >0 ; i--)
  59.                 c = add(c , get_table(b));
  60.         return c;
  61. }

  62. int inline mylog2( unsigned long x)
  63. {
  64.         int i;

  65.         static unsigned long logtable[64] ={
  66.                         0x8000000000000000,
  67.                         0x4000000000000000,
  68.                         0x2000000000000000,
  69.                         0x1000000000000000,
  70.                         0x800000000000000,
  71.                         0x400000000000000,
  72.                         0x200000000000000,
  73.                         0x100000000000000,
  74.                         0x80000000000000,
  75.                         0x40000000000000,
  76.                         0x20000000000000,
  77.                         0x10000000000000,
  78.                         0x8000000000000,
  79.                         0x4000000000000,
  80.                         0x2000000000000,
  81.                         0x1000000000000,
  82.                         0x800000000000,
  83.                         0x400000000000,
  84.                         0x200000000000,
  85.                         0x100000000000,
  86.                         0x80000000000,
  87.                         0x40000000000,
  88.                         0x20000000000,
  89.                         0x10000000000,
  90.                         0x8000000000,
  91.                         0x4000000000,
  92.                         0x2000000000,
  93.                         0x1000000000,
  94.                         0x800000000,
  95.                         0x400000000,
  96.                         0x200000000,
  97.                         0x100000000,
  98.                         0x80000000,
  99.                         0x40000000,
  100.                         0x20000000,
  101.                         0x10000000,
  102.                         0x8000000,
  103.                         0x4000000,
  104.                         0x2000000,
  105.                         0x1000000,
  106.                         0x800000,
  107.                         0x400000,
  108.                         0x200000,
  109.                         0x100000,
  110.                         0x80000,
  111.                         0x40000,
  112.                         0x20000,
  113.                         0x10000,
  114.                         0x8000,
  115.                         0x4000,
  116.                         0x2000,
  117.                         0x1000,
  118.                         0x800,
  119.                         0x400,
  120.                         0x200,
  121.                         0x100,
  122.                         0x80,
  123.                         0x40,
  124.                         0x20,
  125.                         0x10,
  126.                         0x8,
  127.                         0x4,
  128.                         0x2,
  129.                         0x1,
  130.         };

  131.         for( i  = 0 ; i < 64 ; i++)
  132.         {
  133.                 if (x & logtable[i]) return i;
  134.         }
  135.         return -1;
  136. }

  137. bignumber  dvi_10(bignumber a)
  138. {
  139.         bignumber t;
  140.         int tmp = mylog2(a.h);

  141.         t.h  = ((a.h << tmp) | a.l >> ( 64 - tmp)) / 10 ;

  142.         unsigned long yu = ((a.h << tmp) | a.l >> ( 64 - tmp)) % 10;

  143.         t.l = (((a.l << tmp )>> tmp) | (yu << (64 - tmp))) / 10;

  144.         tmp = mylog2(t.l);

  145.         a.h = t.h >> tmp;

  146.         a.l = t.l | ( t.h <<  (  64 - tmp  )) ;

  147.         return a;
  148. }

  149. void inline revstr(char *str)
  150. {   //省去一变量, 时间换空间法
  151.     char *head = str, *tail = str + strlen(str) -1;
  152.     for(; head < tail; *head=*head ^ *tail, *tail=*head ^ *tail, *head=*head++ ^ *tail--);
  153. }


  154. void inline to_str(bignumber n, char N[22])
  155. {
  156.         //基本原理是,
  157. //        寻找个位,然后 除以 10
  158. //        继续
  159.         int cur=0;

  160.         do{
  161.                 bignumber n3=n,n2 = dvi_10(n);

  162.                 n3 = del(n3,n2);
  163.                 n3 = del(n3,n2);
  164.                 n3 = del(n3,n2);
  165.                 n3 = del(n3,n2);
  166.                 n3 = del(n3,n2);

  167.                 n3 = del(n3,n2);
  168.                 n3 = del(n3,n2);
  169.                 n3 = del(n3,n2);
  170.                 n3 = del(n3,n2);
  171.                 n3 = del(n3,n2);

  172.                 N[cur++] = '0' + n3.l;

  173.                 n = n2;

  174.         }while( n.h  || n.l   );

  175.         revstr(N);


  176. }

  177. int inline charcnt(const char *ptr, unsigned char ch)
  178. {
  179.     int count = 0;
  180.     while(*ptr)
  181.     {
  182.                if(ch == *ptr)
  183.                {
  184.                      count++;
  185.                }
  186.                ptr++;
  187.     }
  188.     return count;
  189. }



  190. int main(void)
  191. {
  192.         char  N[22]="";

  193.         int n0,n1,n2,n3,n4,n5,n6,n7,n8,n9;

  194.         for(n9 = 1 ; n9 <= 21 ; n9++)
  195.                 for(n8 = 0 ; n8 <= 21 - n9 ; n8++)
  196.                         for(n7 = 0 ; n7 <= 21 -n9 - n8 ; n7++)
  197.                                 for(n6 = 0 ; n6 <= 21 -n9 - n8 -n7 ; n6++)
  198.                                         for(n5 = 0 ; n5 <= 21 -n9 - n8 -n7 -n6; n5++)
  199.                                                 for(n4 = 0 ; n4 <= 21 -n9 - n8 -n7 -n6 -n5 ; n4++)
  200.                                                         for(n3 = 0 ; n3 <= 21 -n9 - n8 -n7 -n6 -n5 -n4 ; n3++)
  201.                                                                 for(n2 = 0 ; n2 <= 21 -n9 - n8 -n7 -n6 -n5 -n4 -n3; n2++)
  202.                                                                         for(n1 = 0 ; n1 <= 21  -n9 - n8 -n7 -n6 -n5 -n4 -n3 -n2; n1++)
  203.                                                                         {
  204.                                                                                 n0 = 21 - n9 - n8 - n7 - n6 - n5 - n4
  205.                                                                                                 - n3 - n2 - n1;

  206.                                                                                 bignumber sum = { 0 };

  207.                                                                                 sum.l = n1;
  208.                                                                                 sum = add(sum, get_n_i(2, n2));
  209.                                                                                 sum = add(sum, get_n_i(3, n3));
  210.                                                                                 sum = add(sum, get_n_i(4, n4));
  211.                                                                                 sum = add(sum, get_n_i(5, n5));
  212.                                                                                 sum = add(sum, get_n_i(6, n6));
  213.                                                                                 sum = add(sum, get_n_i(7, n7));
  214.                                                                                 sum = add(sum, get_n_i(8, n8));
  215.                                                                                 sum = add(sum, get_n_i(9, n9));

  216.                                                                                 static long loop;

  217.                                                                                 ++loop;

  218.                                                                                 if(sum.h <= 4)
  219.                                                                                         continue;

  220.                                                                                 //开始校验

  221. //                                                                                转化为字符串

  222.                                                                                 to_str(sum, N );

  223. //                                                                                统计 0 1 2 3 4 5 6 7 8 9 的个数

  224.                                                                                 if(charcnt(N,'9') == n9)
  225.                                                                                         if(charcnt(N,'8') == n8)
  226.                                                                                                 if(charcnt(N,'7') == n7)
  227.                                                                                                         if(charcnt(N,'6') == n6)
  228.                                                                                                                 if(charcnt(N,'5') == n5)
  229.                                                                                                                         if(charcnt(N,'4') == n4)
  230.                                                                                                                                 if(charcnt(N,'3') == n3)
  231.                                                                                                                                         if(charcnt(N,'2') == n2)
  232.                                                                                                                                                 if(charcnt(N,'1') == n1)
  233.                                                                                                                                                
  234.                                                                                                                                                 {
  235.                                                                                                                                                                 printf("%ld 种组合\n", loop);

  236.                                                                                                                                                                 printf("the number is %s\n", N);
  237.                                                                                                                                                 }

  238.                                                                                 memset(N,0,22);
  239.                                                                         }




  240.         return EXIT_SUCCESS;
  241. }

复制代码

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
7 [报告]
发表于 2011-05-14 06:05 |显示全部楼层
我真 TM 有功夫折腾啊! 居然折腾了这么久。
对 KBTiller 表示佩服。

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
8 [报告]
发表于 2011-05-14 06:36 |显示全部楼层
奇怪,怎么算都只有一个结果的啊!!! 为何我的只能那个算出一个结果来!!!!

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
9 [报告]
发表于 2011-05-15 02:36 |显示全部楼层
这个循环嵌套的深度少
更好
KBTiller 发表于 2011-05-14 09:23



    还是嵌套了9层呢!

论坛徽章:
3
2015年辞旧岁徽章
日期:2015-03-03 16:54:152015年迎新春徽章
日期:2015-03-04 09:58:11数据库技术版块每日发帖之星
日期:2015-08-30 06:20:00
10 [报告]
发表于 2011-05-17 00:26 |显示全部楼层
回复 61# KBTiller

是。貌似有人说要至少 一个9 , 没9 是不行的 ~~~

就这样写了。

问题是怎么算都只有一个结果,而不是2个,一定是哪里漏了。
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP