Kada的学习生活 » 名题 http://blog.okkey.net 程序设计、互联网、趣味生活 Tue, 07 Sep 2010 02:39:00 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 反转的数字相加 http://blog.okkey.net/1102.html http://blog.okkey.net/1102.html#comments Wed, 24 Feb 2010 14:38:13 +0000 Kada http://blog.okkey.net/?p=1102 43->34 　　注意，数字反转以后，数字的最前面和最后面不可能出现0！那么在先处理两个数相加的结果时，应该将最后方的0删除掉！ 　　如何避免多次的数字反转操作呢？可以参考自定义大数相加的算法！将数字按位相加，进行进位操作等！ 　　但是这里应该把两个数高位对齐再相加,相加时,从最高位加到最低位,并向低位进位，因为最后要反转过来！例如：1234与891的反转和，4321+198->4519->9154。表示为1234+8910->1+8, 2+9, 3+1+1, 4+0->9154。只需要一次的反转操作！ 　　注意，这里，接受两个数字的时候，按照字符串接收！ #include <iostream> #include <vector> #include <string> using namespace std; int main() {     string sa,sb,st;     vector<int> v;     vector<int>::iterator it;     int i,j,a,b;     int … 继续阅读 →]]> 　　数字的反转数：一个数，将其首尾倒置。例如4321的反转数便是1234。

　　编写一个程序，接受两个数字，并输出他们的反转数的和的反转数。例如，24和1。那么结果就是42+1->43->34

　　注意，数字反转以后，数字的最前面和最后面不可能出现0！那么在先处理两个数相加的结果时，应该将最后方的0删除掉！

　　如何避免多次的数字反转操作呢？可以参考自定义大数相加的算法！将数字按位相加，进行进位操作等！

　　但是这里应该把两个数高位对齐再相加,相加时,从最高位加到最低位,并向低位进位，因为最后要反转过来！例如：1234与891的反转和，4321+198->4519->9154。表示为1234+8910->1+8, 2+9, 3+1+1, 4+0->9154。只需要一次的反转操作！

　　注意，这里，接受两个数字的时候，按照字符串接收！

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

int main()
{
    string sa,sb,st;
    vector<int> v;
    vector<int>::iterator it;
    int i,j,a,b;
    int sum=0;
    int p=0;    // 进位标志
    int u=0;    // 输出标志

    cin>>sa>>sb;
    // 保证sa长度大于sb
    if(sa.size()<sb .size())
    {
        st=sa;
        sa=sb;
        sb=st;
    }
    for(i=0;i<sa.size();i++)
    {
        a = (sa[i]-'0') + 0;

        if(i >= sb.size())
            b = 0;
        else
            b = (sb[i]-'0') + 0;

        sum = a+b+p;
        p = sum / 10;
        v.push_back(sum%10);
    }

    // 最后一次进位
    if(p==1)
        v.push_back(1);

    // 删除后面的所有0
    while(1)
    {
        // 向量的最后一个元素的it位置为end()-1
        it = v.end()-1;
        if(*it==0)
            v.erase(it);
        else
            break;
    }

    // 实现从左边第一个非零开始输出
    for(j=0;j<v.size();j++)
    {
        if(u==0 && v[j]!=0)
            u=1;
        if(u==1)
            cout<<v[j];
    }
    cout<<endl;

    return 0;
}
]]> http://blog.okkey.net/1102.html/feed 44 求数字根小算法 http://blog.okkey.net/1097.html http://blog.okkey.net/1097.html#comments Tue, 23 Feb 2010 04:25:21 +0000 Kada http://blog.okkey.net/?p=1097 继续阅读 →]]> 　　一个正整数的数字根是通过计算该整数的各位的和产生的。如果一个整数的个位和是一位整数,那么这个数字就是该整数的数字根。如果该整数的各位和是两位或多位整数,那么,就需要重复计算各位的和,直到获得一位整数。

　　例如,考虑正整数 24。把 2 与 4 相加得到 6。由于 6 是一个一位整数,所以,6 就是24 的数字根。现在再来考虑正整数 39。3 与 9 相加等于 12。因为 12 不是一位整数,因而,需要重复处理。再把 1 加 2 得到 3,现在 3 已是一个一位整数了,那么 3 就是 39 的数字根。

　　编写一个程序，接受一个正整数，并求出他的数字根。

　　非常简单的题目。将接收到的正整数当作字符串，没一位都对应成0到9中的一位，加起来。如果加起来的和不是各位数，则重复这一过程。那么可以清除的得到递归或者循环的思路！

#include <iostream>
#include <sstream>
#include <string>
#include <map>
using namespace std;

// 字符到数字的映射 '0'->0,'1'->1...
map<char,int> m;

// 初始化映射
void init()
{
    int i;
    for(i=0;i<10;i++)
    {
        m['0'+i]=i;
    }
}

// 将数字转换为字符串
string convertToString(const unsigned int &x)
{
    ostringstream o;
    if(o<<x)
        return o.str();
    return "";
}


// 求数字根
int root(const string &s)
{
    int i,sum;
    string ss=s;
    while(ss.length()>1)
    {
        for(sum=0,i=0;i<ss .length();i++)
        {
            sum += m[ss[i]];
        }
        ss = convertToString(sum);
    }
    return sum;
}

int main()
{
    init(); // 初始化映射容器
    unsigned int n;
   
    cin>>n;
    cout<<root(convertToString(n))<<endl;

    return 0;
}

　　如果仔细观察一下数字根的产生规则，可以发现更方便的方法！每次取出数字中的一位与剩下的相加，循环往复到之剩下一位数为止。比如12345，那么它的数字根可以这样产生，1234+5得到1239，123+9得到132，13+2得到15，1+5得到６。与一次性分解开来相加是一样的结果。而实现这样的加法只需用%运算即可。

#include <iostream>
using namespace std;

int main()
{
    unsigned int sum;
    cin>>sum;

    while(sum>10)
        sum=sum/10+sum%10;
    cout< <sum<<endl;
   
    return 0;
}

　　两个程序真实天壤之别阿！哈哈！

]]> http://blog.okkey.net/1097.html/feed 12 C语言名题系列：连续整数和 http://blog.okkey.net/1081.html http://blog.okkey.net/1081.html#comments Mon, 08 Feb 2010 06:41:37 +0000 Kada http://blog.okkey.net/?p=1081 继续阅读 →]]> 　　编写一个程序，读入一个正整数，把所有的连续的，和与给定的正整数相等的正整数们找出来。例如，如果输入为27，于是发现2+3+4+5+6+7，8+9+10,13+14为27，那么共有3个组合。如果输入的数字是10000，那么就有18加到142，297加到1328，388加到412以及1998加到2002这4组。

　　通常的算法是，将所有小于n/2的连续正整数的和的情况算出来与n比较。

#include <stdio.h>
#include <stdlib.h>

void main()
{
    char line[100];
    long sum, i, j, n;
    int count = 0;

    printf("请输入整数n:");
    gets(line);
    n = atol(line);

    for(i=1; i< =n/2+1; i++)
    {
        for(sum=i,j=i+1; j<=n/2+1; j++)
        {
            sum += j;
            if(sum == n)
            {
                printf("%d -- %d\n", i, j);
                count++;
                continue;
            }
        }
    }
    if(count > 0)
        printf("共有%d种连续整数和等于%ld\n", count, n);
    else
        printf("没有解\n");
}

　　但是这样的算法太慢速了！进行了太多的加法！因为在程序中，i与j的关系永远满足1< =i<=n,i+1<=j<=n/2+1,i

　　如何减少加法的次数呢？可以参考等值首尾和的算法思路。

　　先求出一个和，sum是1+2加到i,并且sum是第一个大于等于给定值n的整数和。例如，如果n为27,那么sum=1+2+3+4+5+6+7=28。于是，如果i+(i+1)加到j大于n 那么去掉小的一端，及sum变为(i+1)+(i+2)加到j。相应的如果小于sum小于n，则大的一端在增加,即sum=i+(i+1)加到j+(j+1)。不断重复，直到i大于n/2。

　　代码如下：

#include <stdio.h>
#include <stdlib.h>

void main()
{
    long left, right;
    long sum;
    long n;
    int count = 0;
    char line[100];
   
    printf("请输入n:");
    gets(line);
    n = atol(line);

    for(sum=0,right=1; sum<n ; sum+=right++);

    for(left=1, right--; left<=n/2; )
    {
        if(sum > n)
            sum -= (left++);
        else
        {
            if(sum == n)
            {
                printf("%d -- %d\n", left, right);
                count++;
            }
            sum += (++right);
        }
    }
    if(count > 0)
        printf("共有%d种连续整数和等于%ld\n", count, n);
    else
        printf("没有解\n");
}
]]> http://blog.okkey.net/1081.html/feed 11 C语言名题系列：简单的fibonacci数列算法 http://blog.okkey.net/973.html http://blog.okkey.net/973.html#comments Sun, 31 Jan 2010 10:38:54 +0000 Kada http://blog.okkey.net/?p=973 继续阅读 →]]> 　　Fibonacci数列是指1， 1， 2， 3， 5， 8， 13， 21， 34， ····这样的数列。用式子描述即f1, f2, fn, f1=1, f2=1, 其后fn=fn-1+fn-2。

　　现在考虑，如何写一个程序，接受参数n，返回第n个fibonacci数值呢？

　　通常的办法是用递归：即从n开始，依次调用自身求出f(n-1)和f(n-2)。代码如下：

unsigned long fibonacci(int n)
{
    if(n==2 || n==1)
        return 1;
    else
        return fibonacci(n-1) + fibonacci(n-2);
}

　　虽然一目了然，但是效率实在太低。比如计算fibonacci(8)时，递归调用计算f(7)与f(6)，而计算f(7)时，又计算f(6)与f(5）,那么f(6)的计算就重复了！如此一出来，计算f(n)时，将会重复计算n-3次！n不需要很大时，计算出f(n)都已经是相当慢的！

　　根据fibonacci的性质，可以设计一种非递归的方法。效率会高一些。取代递归的，当然是循环。

　　思路：因为计算f(n）时，需要计算f(n-1)+f(n-2)。如果程序保留了f(n),f(n-1),f(n-2)。那么计算f(n+1)时。需要计算f(n）+ f(n-1)。那么要保留f(n-1)与f(n)丢掉f(n-2)。程序中，用f1与f2代表fn-2与fn-1，temp是fn-2，当计算出f2后，调整f2与f1的值，进行新的f1与f2的计算。
　　代码如下：

unsinged long fibonacci(int n)
{
    unsigned long temp, f1, f2;
    int i;
    for(f1=f2=1, i=3; i<=n; i++)
    {
        temp = f1+f2;
        f1=f2;
        f2=temp;
    }
    return f2;
}

　　其实求f(n)时还有一个可行的办法，可以马上得到值，而不用花费太多时间。那就是先将所求范围内的f[n]数列的结果算出来。存到数组里面。直接通过下标访问即可。

#define MAX 1000

unsigned long fib[MAX];

void genfib()
{
    int i;
    fib[0] = fib[1] = 1;
    for(i=2;i<MAX;i++)
    {
        fib[i] = fib[i-1]+fib[i-2];
    }
}

usigned long fibonacci(int n)
{
    return fib[i];
}

　　这个算法很简单，也很高效，但是要预先耗费太多的内存！

]]> http://blog.okkey.net/973.html/feed 6 C语言名题系列：快速的指数运算算法 http://blog.okkey.net/939.html http://blog.okkey.net/939.html#comments Fri, 29 Jan 2010 14:21:50 +0000 Kada http://blog.okkey.net/?p=939 继续阅读 →]]> 　　如果n与m是整数，那么m^n就是求m的n此方，即把m连乘n次！
　　用算法描述起来很简单！在n次循环内不断自乘m，或者递归调用n次乘法即可，但是这极其没有效率！

　　其实，可以将指数运算分解。注意到x^4可以由x^2自乘得到。

　　思路：当求m的n次方时，n可能是2k(偶数),可能是2k+1（奇数）,可能是0(不需要乘）.那么在计算m^n时，可以分成3部分进行递归。第一部分：n为0，不用计算。第2部分：n是偶数,递归计算m的n/2次方。第三部分：n是奇数，即表示为n=2k+1，那么递归调用计算m的n/2次方，再自乘m即可。
　　代码如下：

unsigned long  recursive_power(unsigned long m, unsigned long n)
{
     unsigned long temp;

     if (n == 0)              // m^0 = 1
          return 1;
     else if (n & 0x01UL == 0)
     {    // n为偶数则n % 2 == 0
          // 注意：n & 0x01UL == 0判断是否偶数更有效率
       temp = recursive_power(m, n >> 1);
          return temp * temp; // m^(2k) = (m^k)^2
     }
     else     // n为奇数, m^n=m*m^(n-1)
          return m * recursive_power(m, n-1);
}

　　其实上面的算法还是效率太低了！Kada上学期的《密码学》课程中，用于产生大指数的平方重复运算，可以将计算次数减少到2Log2N！

　　数学描述如下：求m的n次方时，将n写成二进制：n=n0+n1^2+n2^2+···+nk-1^k-1,其中ni为0或1，i为0到k-1。比如45用二进制表示为101101，那么m^45=m^(2^5)m^(2^3)m^(2^1)m^(2^0);

　　思路如下：在二进制表示中，从右往左的第i位，那么指数中就有m^(2^i)这一项，从右往左，如果第i位为1，可以把m^(2^i)乘到一个临时保存变量的结果当中（初值为1）。

　　如何计算m^(2^i)呢？要先将10进制的n不断mod2运算，得到二进制表示？其实两个过程可以同时进行！
　　代码如下：

unsigned long iterative_power(unsigned long m, unsigned long n)
{
     unsigned long  temp = 1;

     while (n > 0) {
          if (n & 0x01UL == 1) // n mod 2 = 1
               temp *= m;     // m^(2^i)在结果中
          m *= m;             // 平方重复
          n >>= 1;            // n = n/2 进行下一轮二进制转换
     }
     return temp;
}
]]> http://blog.okkey.net/939.html/feed 8 C语言名题系列：因子分解 http://blog.okkey.net/935.html http://blog.okkey.net/935.html#comments Thu, 28 Jan 2010 13:11:25 +0000 Kada http://blog.okkey.net/?p=935 继续阅读 →]]> 　　根据算数基本定理，任何一个整数n>1都可以表示为素数的乘积，切在不考虑顺序的情况下，该表达式是唯一的！即n=p1·p2·····pn。

　　写一个程序，读入一个正整数，把它的所有质因子找出来。例如，输入是72，72=2³·3²。质因数有2和3，为方便起见，将输出写成因数(指数)的形式！如输入72，则输出为2(3)3(2)。

　　思路：用质数依次去除n，从2开始一直到除不尽为止。如果除了i次，那么有2(i)。同样的道理3，5，7，···也按同样的办法处理！每一次除不尽时的余数，作为下次的被除数！

　　代码如下：

#include  <stdio .h>
#include  <stdlib .h>

#define   MAXSIZE  100
#define   PRINT(fact, exp) printf("%ld(%ld)", fact, exp)

void main(void)
{
    unsigned long  n, work;
    int            count = 0;
    int            i, k;
    char           line[100], *dummy;

   
    printf("因数分解，输入一个整数 --> ");
    gets(line);
    n = strtoul(line, &dummy, 10);

    // 单独处理质因子2
    for (i=0,work=n; (work & 0x01UL)==0 && work>1; work>>=1,i++);
    if(i>0)
        PRINT(2, i);

    // 处理其它素因子
    for (k = 3; k < = work; k += 2)
    {
        for (i = 0; work % k == 0 && work > 1; work /= k, i++);
        if(i>0)
            PRINT(k, i);
    }

    printf("\n");
}

]]> http://blog.okkey.net/935.html/feed 20 C语言名题系列：线性筛法求素数 http://blog.okkey.net/911.html http://blog.okkey.net/911.html#comments Tue, 26 Jan 2010 13:47:28 +0000 Kada http://blog.okkey.net/?p=911 继续阅读 →]]> 　　在用“筛法”求素数时，每次筛除素数的动作，其实有很多是重复的！比如，如果一个数是3*5*7*9，那么删除的时候，它会被作为3的倍数，5的倍数，7的倍数，9的倍数，被重复判断删除4次。类似的，较大的数有较多的因数，那么，删除它所耗费的时间会很多！如何来优化“筛法”的算法，使之不重复呢？

　　思路如下：从2开始，先删除2²，2³，2³，···，接着删除2·3，2²·3，2³·3，···，而此时并不删除3。再删除2·5，2²·5，2³·5，···，接下来2·7，2²·7，2³·7，···。一般而言，当发现p是一个素数时，先删除p²，p³，p³，···这一系列合数。因为p是素数，所以p²，p³，p³，···不可能被其它数整除。接着，找出比p大，但是第一个没有被删除的数q。再删除p·q，p²·q，p³·q，···。因为p是素数，q为目前为止未删除。所以p^¡·q之前也没有被删除。

　　证明上面这点很重要。如果p^i·q之前已经被删除的话，那么依照上面讲的法则。一定有一个小于p的素数a，使得存在a^k·b=p^i·q，这样，删除a的倍数时，会把p^i·q删除掉。不过，a^k·b=p^i·q并且a<p这是不可能的！因为a与p都为素数，它们之间无法互相整除。为满足等式，必须有p^i整除q，即q=a^k·(b/q^i)。这样以来，q便是a的倍数了！在删除a的倍数时，q已经被删除！与q是大于p的未被删除的性质矛盾！

　　根据上面的证明，线性筛法所做的操作不会重复！因为求小于n的素数时，p最大不会超过√n，所以p^2< =n。同样，对于任意p^i·q也必须限定在n的范围以内。

#include  <stdio.h>
#include  <stdlib .h>

#define   MAXSIZE    1000
#define   NEXT(x)    x = next[x]
#define   REMOVE(x)  { next[previous[x]] = next[x];          \
                       previous[next[x]] = previous[x];      \
                     }
#define   INITIAL(n) { unsigned long i;                      \
                       for (i = 2; i < = n; i++)              \
                            previous[i] = i-1, next[i] = i+1;\
                       previous[2] = next[n] = NULL;         \
                     }

void main(void)
{
     unsigned long  previous[MAXSIZE+1]; // 指向前数
     unsigned long  next[MAXSIZE+1];     // 指向后数
     unsigned long  prime, fact, i, mult;
     unsigned long  n;
     unsigned long  count = 0;
     char           line[100], dummy;

     printf("\n线性筛法求素数");
     printf("\n====================");
     printf("\n\n求出2到n之间的素数，输入n --> ");
     gets(line);
     n = strtoul(line, &dummy, 10);
 
     INITIAL(n);              // 初始化序列
     for (prime = 2; prime*prime < = n; NEXT(prime))
          for (fact = prime; prime*fact <= n; NEXT(fact))
               for (mult = prime*fact; mult <= n; mult *= prime)
                    REMOVE(mult);       // 删除p^i·q

     for (i = 2; i != NULL; NEXT(i)) {
          if (count % 8 == 0)  printf("\n");
          printf("%6ld", i);
          count++;
     }
     printf("\n\n2到n之间的素数共有%d个", count);
}

　　如果不仔细琢磨这个程序，确实很难看懂！程序使用了3个循环来实现删除的操作。并将初始化，删除，移位的操作定义为简短的宏定义。如果实在看不懂的话，可以拿出笔来，简单的走一遍程序。弄清楚，删除以及移动目标是如何实现的！细细体会previous和next数组的作用，以及删除的实现！

　　比如，previous[3],previous[4],previous[5]分别为2，3，4。next[2], next[3], next[4], next[5]的值分别为3，4，5，6。再每一轮删除之后，每个previous[i]和next[i]数组中的元素将会指出i之前与之后的最近的未被删除的素数！REMOVE(4)之后，previous[5]=previous[4]=3，next[3] = next[4] = 5。换句话说，就是4被删除了，5的前面一位此时指向3，3的后面一位指向5。

　　真的是非常巧妙啊！Kada的笔记中贴出的代码，有些都是20年前的计算机学家或者数学家，以及专业的人士发表在相关杂志的！若非几十年的锤炼，实在难以精尖！

]]> http://blog.okkey.net/911.html/feed 16 C语言名题系列：筛法求素数 http://blog.okkey.net/907.html http://blog.okkey.net/907.html#comments Tue, 26 Jan 2010 03:23:53 +0000 Kada http://blog.okkey.net/?p=907 继续阅读 →]]> 　　如果整数 n ≠ 0，±1。如果除了显然因数 ±1 和 ±n 以外，n没有其他因数，那么 n 叫做素数。如：2，3，5，7是素数，4，6，10，15是合数。

　　根据素数的性质，有这样的定理：1、设 n 是一个正合数，p 是 n 的一个大于1的最小正因数，则 p 一定是素数。2、设 n 是一个正整数，如果对所有的素数 p ≤ √n，都有 p 不整除 n，则 n 一定是素数。

　　根据两条定理，可以得到寻找素数的群定性方法，通常叫做 埃拉托斯散筛法。
　　筛法具体描述如下：对于任意给定的整数 N ，要求出所有不超过 N 的素数。列出 N 个整数，从中删除小于等于√n的所有素数p1, …, pk的倍数。然后依次删除余下的整数（不包括1）就是所要求的不超过 N 的素数。
　　如果让你用筛法求出 2 到 某个数 之间的所有素数，如何用代码实现呢？

　　思路：用一个数组x[0], x[1], …来存储3,5,7,11…這些奇数，因此，x[i]中所有存储的数就是2i+3。将所有元素初始状态设置为未筛除，然后依次去掉其中的合数。

　　现在考虑如何删除合数。从x[0],x[1]…如果x[i]未被筛出，则其为质数，删除其所有倍数，依次往下走。但x[i]中储存的值是2i+3,而2i+3的倍数在数组中的什么地方呢？因为数组中全部是奇数，所以2i+3的倍数可以表示为(2n+1)(2i+3),根据(2n+1)(2i+3) = 2n(2i+3)+2i+3 = 2[n(2i+3)+i]+3，知道x[i]对应的数(即2i+3)的倍数的位置为n(2i+3)+i。当n=1是，值为(2i+3)+i,当n=2时，值为(2i+3)+i+(2i+3), 依次类推，用(2i+3)+i作为初值，删掉对应的x[]，再加上2i+3，删掉对应的数，直到无数可删。因为最后的一个素数可以表示为2N+3,所以筛法求出的为2到N之间的素数。
　　代码如下：

#include  <stdio .h>

#define   MAXSIZE   200
#define   DELETED     1
#define   KEPT        0

void main(void)
{
     int  sieve[MAXSIZE+1];   /* 待筛数组  */
     int  count = 1;          /* 素数总数  */
     int  prime;            
     int  i, k;              

     printf("\n埃拉托斯散筛法");
     printf("\n=========================");
     printf("\n\n2 到 %d 之间的素数为：\n", MAXSIZE*2+3);

     for (i = 0; i < = MAXSIZE; i++)
          sieve[i] = KEPT;    /* 初始状态未筛出  */

     for (i = 0; i <= MAXSIZE; i++)
          if (sieve[i] == KEPT) {
               prime = i + i + 3;
               count++;
               for (k = prime + i; k <= MAXSIZE; k += prime)
                    sieve[k] = DELETED; //筛出
          }

     printf("\n%6d", 2);
     for (i = 0, k = 2; i <= MAXSIZE; i++)
          if (sieve[i] == KEPT) {
               if (k > 10) {
                    printf("\n");
                    k = 1;
               }
               printf("%6d", 2*i+3);
               k++;
          }
     printf("\n\n总共有 %d 个素数。", count);
}

　　其实算法简单，只不过化简了一个公式。利用了位置之间的关系。但是叙述起来比较麻烦。因为偶数不会是素数，所以本算法中，一开始存储的待筛数组全部为奇数。其实还可以在最初状态下，不考虑3的倍数，5的倍数等等。这个筛法可以再改进的！

]]> http://blog.okkey.net/907.html/feed 20 C语言名题系列：等值首尾和 http://blog.okkey.net/850.html http://blog.okkey.net/850.html#comments Tue, 19 Jan 2010 14:28:24 +0000 Kada http://blog.okkey.net/?p=850 继续阅读 →]]> 　　假设有一个数组x[]，它有n个元素，每一个都大于零，称x[0]+x[1]+…+x[i]为前置和(Prefix_Sum)，而x[j]+x[j-1]+…+x[n-1]为后置和(Suffix_Sum)。写一个程序，求出数组x[]中有多少组相同的前置和与后置和！

　　如果x[]的元素是3,6,2,1,4,5,2，于是x[]的前置和有以下7个，即3,9,11,12,16,21,23，而后置和有2,7,11,12,14,20,23;于是11,12与23这3对就是值相同的前置和与后置和，因为：11=3+6+2=2+5+4, 12=3+6+1=2+5+4+1。而23是整个数组的和，所以前置和与后置和相同。
　　
　　如果算出全部的和，将耗费较多的时间与空间！但是请使用更简单的算法！

　　思路：用一个指针从头往尾走，记录下到此为止的前置和。用另一个指针，记录下到此为止的后置和！如果相等则等到一组。如果当前前置和大于后置和，则向前移动后置指针以增大后置和！相应的，用对称的方法处理后置和大于前置和的情况。

　　代码及真相如下：

int  head_tail(int  x[], int n)
{
     int  prefix     = 0, suffix     = 0;
     int  prefix_idx = 0, suffix_idx = n-1;
     int  count = 0;

     while (suffix_idx >= 0 && prefix_idx < = n-1)
          if (prefix < suffix)      /* 前置和小   */
               prefix += x[prefix_idx++];
          else if (prefix > suffix) /* 后置和小   */
               suffix += x[suffix_idx--];
          else {                    /* 得到等值对: */
               count++;             /* 增加计数 */
               prefix += x[prefix_idx++]; /* 移动前后和指针*/
               suffix += x[suffix_idx--];
          }
     return count;
}
]]> http://blog.okkey.net/850.html/feed 13 C语言名题系列：最短距离 http://blog.okkey.net/836.html http://blog.okkey.net/836.html#comments Sat, 16 Jan 2010 12:38:48 +0000 Kada http://blog.okkey.net/?p=836 y[j]，则y数组中y[j]前面的元素与x[i]的距离都大于d，因为数组是从小到大排列的。就像1, 4, 8, 9和0, 2, 3, 4, 10两个数组中，|8-3| < |8-2| < |8-0|一样！相应的：如果y[j]>x[i]，则x中x[i]前面的元素与y[j]的距离都要大于d！因此，发现x[i]>y[j]时，固定i，增加j，可以使d越来越小！直到y[j]>x[i]时，同样的道理固定j，增加i可使d越来越小！用一个变量记录下最小的d即可！ 　　代码与真相： #include <limits .h> #define  min(x, y)     ((x) < (y) ? (x) : (y)) int  min_distance(int x[], int y[], int m, int n) { … 继续阅读 →]]> 　　题目：已知两个元素从小到大排列的数组x[]与y[]，请编写一个程序算出两个数组元素间彼此之间的绝对值中最小的一个数，此值叫做数组的最短距离！

　　如果x[i]与y[j]是两个元素，那么|x[i]-y[j]|就是这两个元素之间的距离，所有的距离的最小值即为所求。如果x中有m个元素，y中有n个元素，则有m*n个距离！

　　思路：利用两个数组排序好的特性，可用不必计算m*n个距离！如果d为x[i]与y[j]的距离！如果x[i]>y[j]，则y数组中y[j]前面的元素与x[i]的距离都大于d，因为数组是从小到大排列的。就像1, 4, 8, 9和0, 2, 3, 4, 10两个数组中，|8-3| < |8-2| < |8-0|一样！相应的：如果y[j]>x[i]，则x中x[i]前面的元素与y[j]的距离都要大于d！因此，发现x[i]>y[j]时，固定i，增加j，可以使d越来越小！直到y[j]>x[i]时，同样的道理固定j，增加i可使d越来越小！用一个变量记录下最小的d即可！
　　代码与真相：

#include <limits .h>
#define  min(x, y)     ((x) < (y) ? (x) : (y))

int  min_distance(int x[], int y[], int m, int n)
{
     int  minimum = INT_MAX;
     int  i = 0, j = 0;

     while (i < m && j < n)
          if (x[i] >= y[j]) {
               minimum = min(minimum, x[i]-y[j]);
               j++;
          }
          else {
               minimum = min(minimum, y[j]-x[i]);
               i++;
          }
     return minimum;
}

　　说明：保存最小值的变量需要有一个初始值。其值要大于所有可能的距离值才行！所以引入了极限值INT_MAX，并且通过x[i]与y[j]的大小关系控制，避免了调用abs函数。 ]]> http://blog.okkey.net/836.html/feed 8 C语言名题系列:等值数目 http://blog.okkey.net/829.html http://blog.okkey.net/829.html#comments Fri, 15 Jan 2010 14:10:24 +0000 Kada http://blog.okkey.net/?p=829 继续阅读 →]]> 　　题目：给定两个由递增排序好的数组，找出他们有多少等值对。如f[]:1,2,3,5,7,8和g[]:2,3,7,8有四对相等的值，所以答案为4。

　　分析：要写出好的算法还是要充分利用数组已排序好这一特性！因为两个数组都已经排序好！如果f[i]g[j]，则将g[j+1]与f[i]比较！否则它们相等，总数累加后，两个数组都向后比较。这样一来，当其中一个数组的元素被访问完时，则得到答案！其实比较的过程是两个数组一上一下，轮流向前推进的过程！
　　

　　代码及真相在此：

int coincidence_count(int f[], int g[], int m, int n)
{
     int  i,j;
     int  count;
     count = i = j = 0;
     while (i < m && j < n)
          if (f[i] < g[j])
               i++;
          else if (f[i] > g[j])
               j++;
          else
               count++, i++, j++;
     return count;
}

]]> http://blog.okkey.net/829.html/feed 8 C语言名题系列:支配值数目 http://blog.okkey.net/811.html http://blog.okkey.net/811.html#comments Thu, 14 Jan 2010 12:41:20 +0000 Kada http://blog.okkey.net/?p=811 g[j]的对数！如f：2，3，5，7，9和g：1，2，4，6，7中，2>1,3>1,3>2,5>1,5>2,5>4,7>1,7>2,7>4,7>6,9>7,9>6,9>4,9>2,9>1！有15组这样的关系，所以答案为15。 　　老规矩，尽量使代码简短！最少的元素访问次数！ 　　本题的关键在于，利用数组排序好的性质！思路如下：f[i]大于g[j]，则f[i]后面的元素都大于g[j]。利用一个变量count来记录满足大于关系的对数，如果f[i]>g[j]时，count增加f中i后的元素个数，并将j后移，否则将i后移，拿f中更大的元素与当前g[j]比较！这样一来，当访问完其中一个数组的元素时，便得出了答案！没有必要将两个数组都走一遍！ 　　 　　代码及真相： int  gt_count(int f[], int g[], int m, int n) {      int  i, j;      int  count;      count = i = j = 0;      while (i < m && … 继续阅读 →]]> 　　题目：给定两个排序好的数组f[]和g[]，计算满足f[i]>g[j]的对数！如f：2，3，5，7，9和g：1，2，4，6，7中，2>1,3>1,3>2,5>1,5>2,5>4,7>1,7>2,7>4,7>6,9>7,9>6,9>4,9>2,9>1！有15组这样的关系，所以答案为15。

　　老规矩，尽量使代码简短！最少的元素访问次数！

　　本题的关键在于，利用数组排序好的性质！思路如下：f[i]大于g[j]，则f[i]后面的元素都大于g[j]。利用一个变量count来记录满足大于关系的对数，如果f[i]>g[j]时，count增加f中i后的元素个数，并将j后移，否则将i后移，拿f中更大的元素与当前g[j]比较！这样一来，当访问完其中一个数组的元素时，便得出了答案！没有必要将两个数组都走一遍！
　　
　　代码及真相：

int  gt_count(int f[], int g[], int m, int n)
{
     int  i, j;
     int  count;

     count = i = j = 0;
     while (i < m && j < n)
          if (f[i] <= g[j])
               i++;
          else
               j++, count += m - i;
     return count;
}
]]> http://blog.okkey.net/811.html/feed 11 C语言名题系列:最长平台 http://blog.okkey.net/800.html http://blog.okkey.net/800.html#comments Wed, 13 Jan 2010 14:14:18 +0000 Kada http://blog.okkey.net/?p=800 继续阅读 →]]> 　　手头有一本书C语言名题集，很不错！上面大多是知名问题，也给出很多精妙的解决办法。趁着假期，接着习练。将进行连载，每天分享一个题目，敬请关注！
　　最长平台问题：已知一个已经从小到大排序的数组，这个数组中的的一个平台（Plateau）就是连续的一串值相同的元素，并且这个串元素不能再延伸。例如，在1，2，2，3，3，3，4，5，5，6中1，2-2，3-3-3，4，5-5，6都是平台，试编写一个函数，接收一个数组，并把这个数组中的最长平台所含的个数作为返回值，如上例中3-3-3就是最长平台，该平台中一共有3个3，故函数返回值为3。
　　要求使用最少的变量，最少的查询次数以及最少的程序语句！
　　本题目关键在于利用数组已经从小到大排序的性质！利用一个变量记录L平台长度(至少为1)，如果当前元素X[i]与其后L距离处的元素X[i+L]相等，则他们之间的元素也是相等的，因为数组时从小到大排序好的！有了这个思路，问题便简单了！

int longest_plateau(int x[], int n)
{
     int  length = 1;         /* plateau length >= 1.     */
     int  i;

     for (i = 1; i < n; i++)
          if (x[i] == x[i-length])
               length++;
     return length;
}

　　以上是一个计算机科学家89年给出的解法！现在来考虑问题的扩展，假若数组并未排序好，请给出找出最长平台的办法！我的思路如下：若当前比较的两个元素不相等，则将平台长度置为1，继续向后比较。返回找的的多个平台中的最大值即可！有代码有真相：

#define max(x, y) ( (x) > (y) ) ? (x) : (y)
int kz_plateau(int x[], int n)
{
    int length = 1, maxlen = 1;
    int i;
    for(i=1; i<n; i++)
    {
        if(x[i] == x[i-length])
            length++;
        else
        {
            maxlen = max(maxlen, length);
            length = 1;
        }
    }
    return maxlen;
}
]]> http://blog.okkey.net/800.html/feed 17