IT公司笔试题算法部分（四）

15、现在小明一家过一座桥，过桥的时候是黑夜，所以必须有灯。现在小明过桥要1秒，小明的弟弟要3秒，小明的爸爸要6秒，小明的妈妈要八秒，小明的爷爷要12秒。每次此桥最多可过两人，而过桥的速度依过桥最慢者而定，而且灯在点燃后30秒就会熄灭。问小明一家如何过桥？（原本是个智力题，这里用程序来求解）

#include "stdafx.h"

#define N    5

#define SIZE 64

 

// 将人员编号：小明-0，弟弟-1，爸爸-2，妈妈-3，爷爷-4

// 每个人的当前位置：0--在桥左边， 1--在桥右边

int Position[N];   

// 过桥临时方案的数组下标； 临时方案； 最小时间方案；

int Index, TmpScheme[SIZE], Scheme[SIZE];  

// 最小过桥时间总和，初始值100；每个人过桥所需要的时间

int MinTime=100, Time[N]={1, 3, 6, 8, 12}; 

// 寻找最佳过桥方案。Remnant:未过桥人数; CurTime:当前已用时间;

// Direction:过桥方向,1--向右,0--向左

void Find(int Remnant, int CurTime, int Direction)

{

    if(Remnant==0){                               // 所有人已经过桥，更新最少时间及方案

        MinTime=CurTime;

        for(int i=0; i<SIZE && TmpScheme[i]>=0; i++)

        {

            Scheme[i]=TmpScheme[i];

        }

    }else if(Direction==1){                        // 过桥方向向右，从桥左侧选出两人过桥

        for(int i=0; i<N; i++)                   

        {

            if(Position[i]==0 && CurTime+Time[i]<MinTime){

                TmpScheme[Index++] = i;

                Position[i] = 1;

                for(int j=0; j<N; j++)           

                {

                    int TmpMax = (Time[i]>Time[j] ? Time[i] : Time[j]);

                    if(Position[j]==0 && CurTime+TmpMax<MinTime)

                    {

                        TmpScheme[Index++] = j;   

                        Position[j] = 1;       

                        Find(Remnant-2, CurTime+TmpMax, !Direction);

                        Position[j] = 0;       

                        TmpScheme[--Index] = -1;

                    }

                }

                Position[i] = 0;

                TmpScheme[--Index] = -1;

            }

        }

    }else{        // 过桥方向向左，从桥右侧选出一个人回来送灯

        for(int j=0; j<N; j++)

        {

            if(Position[j]==1 && CurTime+Time[j] < MinTime)

            {

                TmpScheme[Index++] = j;

                Position[j] = 0;

                Find(Remnant+1, CurTime+Time[j], !Direction);

                Position[j] = 1;

                TmpScheme[--Index] = -1;

            }

        }

    }

}

int main(int argc, char* argv[])

{

    for(int i=0; i<SIZE; i++)        // 初始方案内容为负值，避免和人员标号冲突

        Scheme[i] = TmpScheme[i] = -1;

 

Find(N, 0, 1);                   // 查找最佳方案

 

    printf("MinTime=%d:", MinTime); // 输出最佳方案

    for(int i=0; i<SIZE && Scheme[i]>=0; i+=3)

        printf(" %d-%d %d", Scheme[i], Scheme[i+1], Scheme[i+2]);

    printf("/b/b ");

    return getchar();

}

 

16、2005年11月金山笔试题。编码完成下面的处理函数。函数将字符串中的字符'*'移到串的前部分，前面的非'*'字符后移，但不能改变非'*'字符的先后顺序，函数返回串中字符'*'的数量。如原始串为：ab**cd**e*12，处理后为*****abcde12，函数并返回值为5。（要求使用尽量少的时间和辅助空间）

int change(char *str)                     /* 这个算法并不高效，从后向前搜索效率要高些 */

{

     int count = 0;                       /* 记录串中字符'*'的个数 */

     for(int i=0, j=0; str[i]; i++)       /* 重串首开始遍历 */

     {

         if(str[i]=='*'){                 /* 遇到字符'*' */

              for(j=i-1; str[j]!='*'&&j>=0; j--) /* 采用类似插入排序的思想，将*前面 */

                   str[j+1]=str[j];             /* 的非*字符逐个后移，直到遇到*字符 */

              str[j+1] = '*';

              count++;

         }

     }

     return count;

}

int main(int argc, char* argv[])

{

     char str[] = "ab**cd**e*12";

     printf("str1=%s/n", str);

     printf("str2=%s, count=%d", str, change(str));

     return getchar();

}

// 终于得到一个比较高效的算法，一个网友提供，应该和金山面试官的想法一致。算法如下：

int change(char *str)

{

     int i,j=strlen(str)-1;

     for(i=j; j>=0; j--)

     {

         if(str[i]!='*'){

              i--;

         }else if(str[j]!='*'){

              str[i] = str[j];

              str[j] = '*';

              i--;

         }

     }

     return i+1;

}

 

17、2005年11月15日华为软件研发笔试题。实现一单链表的逆转。

#include "stdafx.h"

 

typedef char eleType;       // 定义链表中的数据类型

typedef struct listnode     // 定义单链表结构

{

     eleType data;

     struct listnode *next;

}node;

 

node *create(int n)         // 创建单链表，n为节点个数

{

     node *p = (node *)malloc(sizeof(node));  

     node *head = p;    head->data = 'A';

     for(int i='B'; i<'A'+n; i++)

     {                 

         p = (p->next = (node *)malloc(sizeof(node)));

         p->data = i;

         p->next = NULL;       

     }

     return head;

}

 

 

void print(node *head)      // 按链表顺序输出链表中元素

{

     for(; head; head = head->next)

         printf("%c ", head->data); 

     printf("/n");

}

 

node *reverse(node *head, node *pre) // 逆转单链表函数。这是笔试时需要写的最主要函数

{

     node *p=head->next;

     head->next = pre;

     if(p)

         return reverse(p, head);

     else

         return head;

}

 

int main(int argc, char* argv[])

{

     node *head = create(6);

     print(head);

     head = reverse(head, NULL);

     print(head);

     return getchar();

}

 

18、编码实现字符串转整型的函数（实现函数atoi的功能），据说是神州数码笔试题。如将字符串 ”+123”à123, ”-0123”à-123, “123CS45”à123, “123.45CS”à123, “CS123.45”à0

#include "stdafx.h"

int str2int(const char *str)         // 字符串转整型函数

{

     int i=0, sign=1, value = 0;

     if(str==NULL) return NULL;      // 空串直接返回 NULL

     if(str[0]=='-' || str[0]=='+'){ // 判断是否存在符号位

         i = 1;

         sign = (str[0]=='-' ? -1 : 1);

     }

     for(; str[i]>='0' && str[i]<='9'; i++)    // 如果是数字，则继续转换

         value = value * 10 + (str[i] - '0');

     return sign * value;

}

int main(int argc, char *argv[])

{

     char *str = "-123.45CS67";

     int val = str2int(str);

     printf("str=%s/tval=%d/n", str, val);

     return getchar();

}

 

19、歌德巴赫猜想。任何一个偶数都可以分解为两个素数之和。

#include "stdafx.h"

#include "math.h"

int main(int argc, char* argv[])

{

     int Even=78, Prime1, Prime2, Tmp1, Tmp2;

     for(Prime1=3; Prime1<=Even/2; Prime1+=2)

     {

         for(Tmp1=2,Tmp2=sqrt(float(Prime1)); Tmp1<=Tmp2 && Prime1%Tmp1 != 0; Tmp1++);

         if(Tmp1<=Tmp2) continue;

         Prime2 = Even-Prime1;

         for(Tmp1=2,Tmp2=sqrt(float(Prime2)); Tmp1<=Tmp2 && Prime2%Tmp1 != 0; Tmp1++);

         if(Tmp1<=Tmp2) continue;

         printf("%d=%d+%d/n", Even, Prime1, Prime2);

     }

     return getchar();

}