语源科技BlogJava-平行的宇宙,折射的生命

算24点算法整理和原理说明

DeEpBLuE222 — Tue, 06 Jan 2009 07:04:00 GMT

给定4个整数，其中每个数字只能使用一次；任意使用 + - * / ( ) ，构造出一个表达式，使得最终结果为24，这就是常见的算24点的游戏。这方面的程序很多，一般都是穷举求解。本文介绍一种典型的算24点的程序算法，并给出两个具体的算24点的程序：一个是面向过程的C实现，一个是面向对象的java实现。

基本原理是穷举4个整数所有可能的表达式，然后对表达式求值。

表达式的定义： expression = (expression|number) operator (expression|number)

因为能使用的4种运算符 + - * / 都是2元运算符，所以本文中只考虑2元运算符。2元运算符接收两个参数，输出计算结果，输出的结果参与后续的计算。

由上所述，构造所有可能的表达式的算法如下：

(1) 将4个整数放入数组中
(2) 在数组中取两个数字的排列，共有 P(4,2) 种排列。对每一个排列，
(2.1) 对 + - * / 每一个运算符，
(2.1.1) 根据此排列的两个数字和运算符，计算结果
(2.1.2) 改表数组：将此排列的两个数字从数组中去除掉，将 2.1.1 计算的结果放入数组中
(2.1.3) 对新的数组，重复步骤 2
(2.1.4) 恢复数组：将此排列的两个数字加入数组中，将 2.1.1 计算的结果从数组中去除掉

可见这是一个递归过程。步骤 2 就是递归函数。当数组中只剩下一个数字的时候，这就是表达式的最终结果，此时递归结束。

在程序中，一定要注意递归的现场保护和恢复，也就是递归调用之前与之后，现场状态应该保持一致。在上述算法中，递归现场就是指数组，2.1.2 改变数组以进行下一层递归调用，2.1.3 则恢复数组，以确保当前递归调用获得下一个正确的排列。

括号 () 的作用只是改变运算符的优先级，也就是运算符的计算顺序。所以在以上算法中，无需考虑括号。括号只是在输出时需加以考虑。

#include
#include
#include

#using <System.dll>
#using <System.Configuration.Install.dll>

using namespace std;
using namespace System;
using namespace System::Diagnostics;

const double PRECISION = 1E-6;
const int COUNT_OF_NUMBER = 4;
const int NUMBER_TO_BE_CAL = 24;

double number[COUNT_OF_NUMBER];
string expression[COUNT_OF_NUMBER];

bool Search(int n)
{
if (n == 1) {
if ( fabs(number[0] - NUMBER_TO_BE_CAL) < PRECISION ) {
cout << expression[0] <<" = 24"<< endl;
return true;
} else {
return false;
}
}

for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
double a, b;
string expa, expb;

a = number[i];
b = number[j];
number[j] = number[n - 1];

expa = expression[i];
expb = expression[j];
expression[j] = expression[n - 1];

expression[i] = '(' + expa + '+' + expb + ')';
number[i] = a + b;
if ( Search(n - 1) ) return true;

expression[i] = '(' + expa + '-' + expb + ')';
number[i] = a - b;
if ( Search(n - 1) ) return true;

expression[i] = '(' + expb + '-' + expa + ')';
number[i] = b - a;
if ( Search(n - 1) ) return true;

expression[i] = '(' + expa + '*' + expb + ')';
number[i] = a * b;
if ( Search(n - 1) ) return true;

if (b != 0) {
expression[i] = '(' + expa + '/' + expb + ')';
number[i] = a / b;
if ( Search(n - 1) ) return true;
}
if (a != 0) {
expression[i] = '(' + expb + '/' + expa + ')';
number[i] = b / a;
if ( Search(n - 1) ) return true;
}

number[i] = a;
number[j] = b;
expression[i] = expa;
expression[j] = expb;
}
}
return false;
}

void main()
{
for (int i = 0; i < COUNT_OF_NUMBER; i++) {
char buffer[20];
int x;
cin >> x;
number[i] = x;
itoa(x, buffer, 10);
expression[i] = buffer;
}

if ( Search(COUNT_OF_NUMBER) ) {
cout << "Success." << endl;
} else {
cout << "Fail." << endl;
}
}

DeEpBLuE222 2009-01-06 15:04 发表评论

关于Java3D在AMD64位系统中的安装问题

DeEpBLuE222 — Wed, 31 Dec 2008 16:30:00 GMT

不知道是sun公司故意忽悠我们还是怎么的,因为我的系统是AMD64位双核的,想在本机上配置一下java3d环境,所以找了一下,首先下了一个window/AMD64 的安装程序,居然提示"此类型处理器不适合安装……"，郁闷，只好用Zip binaries 了,晕居然提示少2个dll(s),但是解压包里只有一个dll，汗，难道sun公司帮意忽悠人的，没办法，只好google解决办法了，国内论坛好像没找到解决方法，无意中看到一个国外论坛网友回贴，也是遇到同样问题的，“A-ha. I was assuming that the AMD64 was a build for the 64-bit AMD chipset, not a target OS. Yes, when I use the i586 build things are happy.

Thanks. ” 我就下了一个i586的，居然可以用，哎，可能真如那位老兄说的那样（但我是AMD64位的CPU，win32的OS）,不理解。不过至少还是能用的。

DeEpBLuE222 2009-01-01 00:30 发表评论

转载:在C++中实现foreach循环

DeEpBLuE222 — Wed, 10 Dec 2008 09:40:00 GMT

转载:在C++中实现foreach循环

使用过C#、PHP这些更高级语言的朋友一定知道foreach循环。foreach语句给编程带来了很大的方便，减少了代码，并增加了程序的可读性。C++虽然不支持foreach关键字，但C++是一门强大的语言，只要稍微用一点小技巧，也可以在C++中使用foreach循环。
在C#中，foreach语句的效果让人吃惊。foreach语句省去了复杂而又类似的循环控制语句，使代码非常简洁明了。下面的例子可以清楚地看到这一点。

假有一个类型为ContainerType类型的容器Container，它的每个元素的类型为ElementType。
在C#中，数组就是这样一种容器。
在C++中，stl的vector、map等也是这样的容器。
如果要遍历容器Container的每个元素，在C#中可以使用如下代码：

foreach( ElementType element in Container)
{ // 使用element访问该元素
}

而在C++中，通常的代码都会是这样：

Container::iterator iter;
for (iter = Container.begin(); iter!=Container.end(); iter++)
{ // 使用(*iter)访问该元素
}

显然C#中的代码更清晰的多。而C++的代码中包含了变量声明和循环控制，显得更复杂了。也许您对这一点增加的复杂性并不在意，但本着勿因善小而不为的原则，以及一点思考精神，我决定让C++也拥有使用foreach循环的能力。

C++的宏很适合做这种事情。问题在于如何做的更像C#中的那种样式。如果在访问元素的代码块的前面和后面各加一个宏，那么这件事情就变得毫无意义，并很可笑。

我们只能使用一个宏，并命名为foreach。在这个宏后面的代码块将可以像在C#中那样可以使用一个变量名来遍历容器中的所有元素。宏中声明的变量不能污染到程序中其它部分的命名间，而这些变量又不在访问元素的代码块中声明。这样的要求使这个问题变成一种考验代码技巧的有趣问题。

C++语言控制能力的强大使它确实可以支持foreach语句。这要用到两个技巧：1，for循环的第一条语句可以声明局部变量；2，充分利用for循环的过程控制能力。

C++中的foreach语句定义宏如下：

#define foreach(elementType, element, containerType, container) "
    for (containerType::iterator iter = container.begin(); iter != container.end(); iter++)"
        for (bool go = true; go;)"
            for (elementType & element = *iter;go; go=false)

宏中定义了三重for循环。第一重的意义很清楚：使用容器的遍历者遍历容器中的元素。第二、第三重for循环其实只能执行一次，其主要目的是声明element变量。C++的变量引用类型使后面的元素访问代码块可以直接使用element变量。

foreach宏的参数依次为：元素类型，元素名，容器类型，容器名。

假设有个vector如下面的定义：
vector v;

那么遍历v可以使用下面的代码：

foreach(int, e, vector<int>, v)
{//使用(e)来访问v的元素
}

是不是很像C#中的foreach语句呢？我写了一小段程序，看看这个宏是不是真的能工作，代码如下：

#include <iostream>
#include <vector>
using namespace std;

// 在C++中使用 foreach 循环
#define foreach(elementType, element, containerType, container) "
    for (containerType::iterator iter = container.begin(); iter != container.end(); iter++)"
       for (bool go = true; go;)"
           for (elementType & element = *iter;go; go=false)

int main()
{
    vector<int> v;
    for (int i=0; i<10; ++i)
       v.push_back(i);
    foreach(int, e, vector<int>, v) // 在这里使用foreach语句
    {
       printf("%d"n", e);
    }
}

结果输出很正确！

事实上，在C++中，for语句以及其它语句，它们的本质是基于计算机指令的过程控制语句，而C#中的foreach语句，可以看作是基遍历者这种设计模式的语句。编程语言从只基于计算机指令到基于设计模式，这应该也算是软件发展的进步吧。

在C++中使用文中定义的foreach语句并不能提高程序的效率，也不会明显降低效率。foreach宏只能在代码层面上有些好处，减少一些重复的代码，增加一点可读性。设计这个宏，就当是个趣味技巧题，玩一玩，并支持一下那些坚决拥抱C++的朋友们。

作者：苏林

DeEpBLuE222 2008-12-10 17:40 发表评论

求素数的简单算法(二)

DeEpBLuE222 — Wed, 10 Dec 2008 09:12:00 GMT

#include <list>
#include <iostream>
#include <math.h>

using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
    int index=1;
    double temp;
    int tmp;
    list<int> intlist;
    cout<<"The prime number[ "<<index<<"] :"<<2<<endl;
    for(int i=3;i<10000;i++)
    {
        bool mark=true;
        temp=sqrt(double(i));
        tmp=temp;
        for(int j=2;j<=tmp;j++)
        {
            if(i % j ==0)
            {
                mark=false;
                break;
            }
        }
        if(mark)
        {
            index++;
            intlist.push_back(i);
            cout<<"The prime number[ "<<index<<"] :"<<i<<endl;
        }
    }
    return 0;
}

DeEpBLuE222 2008-12-10 17:12 发表评论

求素数的简单算法(一)

DeEpBLuE222 — Wed, 10 Dec 2008 08:14:00 GMT

下面是求2到10000之间的素数:

#include <list>
#include <iostream>

using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
    int index=1;
    list<int> intlist;
    list<int>::iterator it;
    intlist.push_back(2);
    cout<<"The prime number[ "<<index<<"] :"<<2<<endl;
    for(int i=2;i<10000;i++){
        bool mark=true;
        for(it=intlist.begin();it!=intlist.end();it++)
        {

            if(i % (*it) == 0)
            {
                mark=false;
                break;
            }

        }
                    if(mark)
            {
                index++;
                intlist.push_back(i);
                cout<<"The prime number[ "<<index<<"] :"<<i<<endl;
            }

         }
    return 0;
}