`
t0uch
  • 浏览: 58316 次
  • 性别: Icon_minigender_1
  • 来自: 柳州
社区版块
存档分类
最新评论

880版本四阶幻方,我的机器上跑用了34ms

    博客分类:
  • C
阅读更多

闲来无事,改进改进,多说无益,贴代码,看帖要回帖啊各位

  1. #include < iostream >   
  2. #include < time.h >   
  3.   
  4. using namespace std;   
  5.   
  6. struct uni   
  7. {   
  8.     int a, b, c, d;   
  9. };   
  10.   
  11. uni can[1032];   
  12. const unsigned long punk = 1UL << 2;   
  13. int sum = 0, sum_all = 0;   
  14.   
  15. bool test_4num( int a, int b, int c, int d )   
  16. {   
  17.     int i;   
  18.   
  19.     for ( i = 0;i <= sum;++i )   
  20.     {   
  21.         if ( can[i].a == d &&   
  22.                 can[i].b == c &&   
  23.                 can[i].c == b &&   
  24.                 can[i].d == a )   
  25.             return false;   
  26.     }   
  27.   
  28.     return true;   
  29. }   
  30.   
  31. void get_all_num()   
  32. {   
  33.     for ( int i = 1;i <= 16;++i )   
  34.     {   
  35.         for ( int j = 1;j <= 16;++j )   
  36.         {   
  37.             for ( int k = 1; k <= 16; ++k )   
  38.             {   
  39.                 for ( int l = 1;l <= 16;++l )   
  40.                 {   
  41.                     if ( i != j && i != k && i != l && j != k && j != l && k != l && i + j + k + l == 34 && test_4num( i, j, k, l ) )   
  42.                     {   
  43.                         can[sum].a = i;   
  44.                         can[sum].b = j;   
  45.                         can[sum].c = k;   
  46.                         can[sum].d = l;   
  47.   
  48.                         ++sum;   
  49.                     }   
  50.                 }   
  51.             }   
  52.         }   
  53.     }   
  54.   
  55.     //cout << sum << endl;   
  56. }   
  57.   
  58. void p_rint( const int sq[] )   
  59. {   
  60.     cout << "i wIll gIvE yOu sOme coLoR 2CC! " << sum_all << endl;   
  61.     cout << sq[0] << " " << sq[1] << " " << sq[2] << " " << sq[3] << endl;   
  62.     cout << sq[4] << " " << sq[5] << " " << sq[6] << " " << sq[7] << endl;   
  63.     cout << sq[8] << " " << sq[9] << " " << sq[10] << " " << sq[11] << endl;   
  64.     cout << sq[12] << " " << sq[13] << " " << sq[14] << " " << sq[15] << endl << endl;   
  65. }   
  66.   
  67. __inline bool fill_in_line( const int c1[], const int c2[] )   
  68. {   
  69.     int sq[16], k, l;   
  70.     unsigned long a, b, c, d;   
  71.   
  72.     sq[0] = c1[0];   
  73.     sq[5] = c1[1];   
  74.     sq[10] = c1[2];   
  75.     sq[15] = c1[3];   
  76.   
  77.     a = punk | ( 1UL << ( sq[0] * 2 ) ) | ( 1UL << ( sq[5] * 2 ) ) | ( 1UL << ( sq[10] * 2 ) ) | ( 1UL << ( sq[15] * 2 ) );   
  78.   
  79.     sq[3] = c2[0];   
  80.     sq[6] = c2[1];   
  81.     sq[9] = c2[2];   
  82.     sq[12] = c2[3];   
  83.   
  84.     b = punk | ( 1UL << ( sq[3] * 2 ) ) | ( 1UL << ( sq[6] * 2 ) ) | ( 1UL << ( sq[9] * 2 ) ) | ( 1UL << ( sq[12] * 2 ) );   
  85.   
  86.     if ( ( a & b ) == punk )   
  87.     {   
  88.         for ( k = 1;k <= 16;++k )   
  89.         {   
  90.             sq[4] = k;   
  91.             sq[7] = 34 - sq[4] - sq[5] - sq[6];   
  92.             sq[11] = 34 - sq[3] - sq[7] - sq[15];   
  93.             sq[8] = 34 - sq[9] - sq[10] - sq[11];   
  94.   
  95.             if ( sq[7] > 0 && sq[7] <= 16 && sq[11] > 0 && sq[11] <= 16 && sq[8] > 0 && sq[8] <= 16 &&   
  96.                     sq[4] != sq[7] && sq[4] != sq[11] && sq[4] != sq[8] &&   
  97.                     sq[7] != sq[11] && sq[7] != sq[8] && sq[11] != sq[8] )   
  98.             {   
  99.                 c = punk | ( 1UL << ( sq[4] * 2 ) ) | ( 1UL << ( sq[7] * 2 ) ) | ( 1UL << ( sq[11] * 2 ) ) | ( 1UL << ( sq[8] * 2 ) );   
  100.   
  101.                 if ( ( b & c ) == punk && ( a & c ) == punk )   
  102.                 {   
  103.                     for ( l = 1;l <= 16;++l )   
  104.                     {   
  105.                         sq[1] = l;   
  106.                         sq[13] = 34 - sq[1] - sq[5] - sq[9];   
  107.                         sq[14] = 34 - sq[12] - sq[13] - sq[15];   
  108.                         sq[2] = 34 - sq[0] - sq[1] - sq[3];   
  109.   
  110.                         if ( sq[13] > 0 && sq[13] <= 16 && sq[14] > 0 && sq[14] <= 16 && sq[2] > 0 && sq[2] <= 16 &&   
  111.                                 sq[1] != sq[13] && sq[1] != sq[14] && sq[1] != sq[2] &&   
  112.                                 sq[13] != sq[14] && sq[13] != sq[2] && sq[14] != sq[2] )   
  113.                         {   
  114.                             d = punk | ( 1UL << ( sq[1] * 2 ) ) | ( 1UL << ( sq[13] * 2 ) ) | ( 1UL << ( sq[14] * 2 ) ) | ( 1UL << ( sq[2] * 2 ) );   
  115.   
  116.                             if ( ( a & d ) == punk && ( b & d ) == punk && ( c & d ) == punk && sq[0] + sq[4] + sq[8] + sq[12] == 34 && sq[2] + sq[6] + sq[10] + sq[14] == 34 )   
  117.                             {   
  118.                                 sum_all++;   
  119.                                 //p_rint(sq);   
  120.                             }   
  121.                         }   
  122.                     }   
  123.                 }   
  124.             }   
  125.         }   
  126.     }   
  127.   
  128.     return true;   
  129. }   
  130.   
  131. void fill_in_eight()   
  132. {   
  133.     int cse1[4], cse2[4], i, j;   
  134.     unsigned long m, n;   
  135.   
  136.     for ( i = 0;i < sum;i++ )   
  137.     {   
  138.         for ( j = i + 1;j < sum;j++ )   
  139.         {   
  140.             m = punk | ( 1UL << ( can[i].a * 2 ) ) | ( 1UL << ( can[i].b * 2 ) ) | ( 1UL << ( can[i].c * 2 ) ) | ( 1UL << ( can[i].d * 2 ) );   
  141.             n = punk | ( 1UL << ( can[j].a * 2 ) ) | ( 1UL << ( can[j].b * 2 ) ) | ( 1UL << ( can[j].c * 2 ) ) | ( 1UL << ( can[j].d * 2 ) );   
  142.   
  143.             if ( ( m & n ) == punk )   
  144.             {   
  145.                 cse1[0] = can[i].a;   
  146.                 cse1[1] = can[i].b;   
  147.                 cse1[2] = can[i].c;   
  148.                 cse1[3] = can[i].d;   
  149.   
  150.                 cse2[0] = can[j].a;   
  151.                 cse2[1] = can[j].b;   
  152.                 cse2[2] = can[j].c;   
  153.                 cse2[3] = can[j].d;   
  154.   
  155.                 fill_in_line( cse1, cse2 );   
  156.             }   
  157.         }   
  158.     }   
  159. }   
  160.   
  161. int main()   
  162. {   
  163.     time_t t;   
  164.     get_all_num();   
  165.   
  166.     
  167.     t = clock();   
  168.   
  169.     fill_in_eight();   
  170.   
  171.     cout << "time consumed: " << clock() - t << " ms" << endl;   
  172.        
  173.     cout << sum_all << endl;   
  174.     return 0;   
  175. }   

 

分享到:
评论
2 楼 Sing 2008-02-20  
我的机器上大约需要200ms左右,改进的效率还是比较高的
1 楼 stephen 2007-10-10  
不如说明一下你的这个程序在同类程序中算是好的还是坏的?如果是好的,好在什么方面?你这样放代码出来,估计没什么人有兴趣看,除了准备抄作业的之外,:)

相关推荐

    用JAVA写的幻方

    Java编写的幻方是一种利用编程技术实现数学概念的实例,幻方是一个n×n的方阵,其中每个单元格填充了一个不同的自然数,从1开始,使得每行、每列以及两条对角线上的数字之和都相等。在本案例中,重点是使用Java编程...

    定时器1ms汇编和c版本方波的产生程序

    本篇文章将深入探讨如何使用汇编和C语言来编写一个1ms方波产生的程序。 首先,我们来理解方波生成的基本原理。方波是一种周期性变化的电信号,其特征是高电平和低电平时间相等,因此周期的半数即为方波的占空比。在...

    产生200ms的方波

    用定时器产生200ms的方波,void Init_Timer0(void) { TMOD |= 0x01; //使用模式1,16位定时器,使用"|"符号可以在使用多个定时器时不受影响 //TH0=0x00; //给定初值,这里使用定时器最大值从0开始计数一直到...

    51单片机教程实例49-产生200mS方波

    本教程实例49着重于如何使用51单片机产生200毫秒(mS)的方波信号。方波信号在许多电子系统中都有应用,如定时器、脉冲控制、通信和信号检测等。下面我们将详细探讨如何实现这个功能。 首先,要理解51单片机的...

    OP07CP运放设计四阶带通滤波Multisim仿真源码,Multisim14版本可打开运行.zip

    标题中的“OP07CP运放设计四阶带通滤波Multisim仿真源码”表明我们关注的是一个使用OP07CP运算放大器设计的四阶带通滤波器的电路模型,这个模型是通过Multisim软件进行仿真的。Multisim是一款广泛应用于电子电路设计...

    基于OP07CP运放设计的四阶带通滤波Multisim14仿真源文件,Multisim14版本可打开运行.zip

    标题中的“基于OP07CP运放设计的四阶带通滤波Multisim14仿真源文件”指的是一个使用模拟集成电路OP07CP作为核心元件设计的四阶带通滤波器的电路模型,该模型是用Multisim 14这个电子设计自动化软件进行的仿真。...

    51单片机定时器0产生200mS方波keil工程文件C源文件

    本文将深入探讨如何使用51单片机的定时器0来产生200毫秒(mS)的方波信号,并结合keil μVision(通常称为keil5)IDE进行C语言编程。 51单片机的定时器0是其内部的一种硬件资源,它能够计数CPU的时钟周期,以实现...

    200ms方波

    在给定的代码片段中,我们观察到一系列与微控制器定时器操作相关的程序代码,主要是在MCS-51系列微控制器上实现200ms方波的生成。MCS-51是一种广泛使用的8位微控制器,因其性价比高、易于编程而受到工程师们的青睐。...

    MS VSS V6版本管理工具

    MS VSS V6,全称为Microsoft Visual SourceSafe 2005,是微软推出的一款版本控制系统,主要用于软件开发过程中的源代码和文档管理。这款工具在V6版本中提供了丰富的功能,帮助团队协同工作,跟踪代码变更,以及维护...

    51单片机定时器产生1mS方波keil工程文件C源文件

    本文将深入探讨如何使用51单片机的定时器来产生1毫秒(mS)的方波,并结合提供的keil工程文件进行解析。 51单片机的定时器是其核心功能之一,它可以实现定时或计数任务。在这个场景中,我们将关注定时器作为计数器...

    msado15.dll 32位和64位各版本的ADO都有,最新整理至Win10系统

    msado15.dll 32位和64位各版本的ADO都有,整理更新至Win10操作系统。 msado15.dll版本号说明: 版本号以5.0开头的或含有 nt 一般是windows2000的文件。 版本号以5.1开头的或含有 xp、xpsp1、xpsp2、xpsp3 信息的...

    msado15.dll 32位和64位各版本的ADO都有

    32位版本适用于运行在32位Windows系统上的应用程序,如Windows XP、Windows Server 2003等。而64位版本则是为64位Windows系统(如Windows 7、Windows Server 2008 R2及更高版本)设计的。在开发跨平台的应用程序时,...

    四阶带通滤波电路multisim14仿真源文件.zip

    Multisim14及其以上版本提供了丰富的元件库和先进的仿真功能,使得四阶带通滤波电路的建模和分析变得更加便捷。 四阶带通滤波电路的构建通常由多个无源元件(如电容、电感、电阻)和有源元件(如运算放大器)组成。...

    四阶切比雪夫带通滤波器

    四阶切比雪夫带通滤波器。中心频率1.675GHz,带宽大于200MHz,带内插损小于0.5dB。

    基于模拟退火算法的八幻方问题求解

    基于模拟退火算法寻找八幻方问题的解 项目 内容 时间 2020.11.13 作者 xiabee 主要算法 随机算法; 模拟退火 0x00 目录结构 . ├── Images ├── out.cpp ├── README.md └── result.jpg 代码文件:out.cpp ...

    msword.h,msword.cpp。用于VC控制WORD

    Word2003的COM接口可能与更新版本的Word有所不同,所以在较新的系统上使用时可能需要进行一些调整。 在VC++项目中,首先需要添加对`msword.cpp`的引用,这样编译器才能找到实现的代码。然后在源文件中`#include "ms...

    四阶-龙格库塔求积分

    四阶龙格库塔方法通过以下四个步骤来近似解出在某区间[x, x+h]上的积分: 1. **第一步 (k1)**: 计算一小步长h,然后用初始值y(x)和f(x, y)计算导数的近似值: k1 = h * f(x, y) 2. **第二步 (k2)**: 使用k1的结果...

    48-产生1mS方波.rar 51单片机基础例程

    【51单片机基础例程】:这个压缩包文件主要包含了51系列单片机的一个基础应用示例,即如何生成1毫秒周期的方波。51单片机,全称为Intel 8051,是微控制器领域中非常经典且广泛使用的一款芯片,由美国英特尔公司推出...

    MSMARCO 机器阅读理解数据集.7z

    MSMARCO 是机器阅读理解数据集,其包含的 1,010,916 个匿名问题均来自 Bing 的搜索查询日志,日志中均包含 AI 生成的答案和 182,669 条人为重写的答案,该数据集还包含从 3,563,535 个文档中提取的 8,841,823 个段落...

    ms12-020 for exe版本

    【标题】"ms12-020 for exe版本"涉及的是微软在2012年发布的一个严重安全漏洞,该漏洞主要影响Windows操作系统中的远程桌面协议(RDP)。MS12-020,也被称为“CVE-2012-0166”,是一个远程代码执行漏洞,攻击者可以...

Global site tag (gtag.js) - Google Analytics