uva 112 Tree Summing

将原来的代码改了一个BUG即是存在负数后就AC了，但是时间不好，0.112

实际上本题就是由扩展前序序列来建树，然后遍历，算路径的题目，考查了二叉树的基本知识，很好

 

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define LEN sizeof(struct BTree)

#define MAX 10010

char num[MAX][20],stack[MAX];

struct BTree

{

    int data;

    struct BTree *lchild,*rchild;

}*pre;

int top,count,flag;



void CUT()

{

    int i=0,j=0;

    while( !(stack[i]>='0' && stack[i]<='9' || stack[i]=='-') ) i++;

    while(stack[i]>='0' && stack[i]<='9' || stack[i]=='-') { num[count][j++]=stack[i];  stack[i]='*'; i++; }

    num[count][j]='\0';  count++;

}

int move()

{

    int i;

    for(i=top-1; i>=0; i--)  if(stack[i]=='(') break;

    return i-1;

}

void input()

{

    char ch;

    while(1)

    {

        ch=getchar();

        if(ch==' ' || ch=='\n')  continue;

        else if(ch=='(')   

        {

            stack[++top]=ch;

            if(top>0 && ( stack[top-1]>='0' && stack[top-1]<='9' || stack[top-1]=='-'))

                CUT();

        }

        else if(ch>='0' && ch<='9' || ch=='-')  stack[++top]=ch;

        else

        {

            stack[++top]=ch;

            if(stack[top-1]=='(')

            { num[count][0]='#'; num[count][1]='\0'; count++; top-=2;}

            else top=move();

        }

        if(top<0)  {ch=getchar();return;}

    }

}

void create_BTree(struct BTree* *T,int *i)

{

    int a;

    (*i)++;

    if(num[*i][0]=='#')   (*T)=NULL;

    else

    {

        if(num[*i][0]!='-')

        sscanf(num[*i] , "%d" , &a);

        else

        { sscanf(num[*i]+1 , "%d" , &a); a=0-a; }

        (*T)=(struct BTree*)malloc(LEN);

        (*T)->data=a;

        create_BTree( &((*T)->lchild) , i);

        create_BTree( &((*T)->rchild) , i);

    }

}

void DFS_BTree(struct BTree *T)

{

     if(!T)  return ;

     printf("%d ",T->data);

     DFS_BTree(T->lchild);

     DFS_BTree(T->rchild);

}



void search(struct BTree *T , int key , int sum)

{

    if(flag)  return ;

    if(!T)

    {

        if(!pre->lchild  && !pre->rchild && sum==key)  flag=1;

        return ;

    }

    else

    {

        sum+=T->data;

        pre=T; search(T->lchild , key , sum);

        if(flag)  return ;

        pre=T; search(T->rchild , key , sum);

        if(flag)  return ;

    }

}

int main()

{

    int i,key,sum;  struct BTree *T;

    while(scanf("%d",&key)!=EOF)

    {

        top=-1; count=0; 

        input();

//        for(i=0; i<count; i++) printf("%s  ",num[i]);  printf("\n");

        i=-1; create_BTree(&T,&i);

//         DFS_BTree(T);  printf("\n");

        if(!T)  {printf("no\n"); continue;}

        flag=sum=0; pre=T; search(T,key,sum);

        if(flag)  printf("yes\n");

        else      printf("no\n");

    }

    return 0;

}

 

仔细思考为什么建树的过程顺便计算结果就会WA，一定要把建树过程中同时遍历的程序写出来，因为这样时间将大大提高！

一直WA的原因是，左右孩子指针可能是野指针

经过总结和教训，指针在竞赛中是不适用的，所以尽量避免指针，即便是树这种数据结构也尽量用数组来实现

//悲剧的是时间没有提高多少！！！

 

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define LEN sizeof(struct BTree)

#define MAX 100010

#define INF 1948723892  //用INF表示#

char num[MAX][20],stack[MAX];

struct BTree

{

    int data;

    struct BTree *lchild,*rchild;

}*pre;   //建树时记录前驱结点

int top,count,ok,len;

int a[MAX];

void CUT()

{

    int i=0,j=0;

    while( !(stack[i]>='0' && stack[i]<='9' || stack[i]=='-') ) i++;

    while(stack[i]>='0' && stack[i]<='9' || stack[i]=='-') 

{ num[count][j++]=stack[i];  stack[i]='*'; i++; }

    num[count][j]='\0';

    if(num[count][0]!='-')  sscanf(num[count],"%d",&a[count]);

    else                 {sscanf(num[count]+1,"%d",&a[count]); a[count]=0-a[count];}

    count++;

}

int move()

{

    int i;

    for(i=top-1; i>=0; i--)  if(stack[i]=='(') break;

    return i-1;

}

void input()

{

    char ch;

    while(1)

    {

        ch=getchar();

        if(ch==' ' || ch=='\n')  continue;

        else if(ch=='(')   

        {

            stack[++top]=ch;

            if(top>0 && ( stack[top-1]>='0' && stack[top-1]<='9' || stack[top-1]=='-'))

                CUT();

        }

        else if(ch>='0' && ch<='9' || ch=='-')  stack[++top]=ch;

        else

        {

            stack[++top]=ch;

            if(stack[top-1]=='(')

            { num[count][0]='#'; num[count][1]='\0'; a[count]=INF; count++; top-=2;}

            else top=move();

        }

        if(top<0)  {ch=getchar();return;}

    }

}

void create_BTree(struct BTree* *T,int sum,int key,int mark)

{

    len++;

    if(a[len]==INF)   

    {

        (*T)=NULL;  //先赋空

        if(mark==2 && !(pre->lchild)  && sum==key) ok=1;

        return ;

//这个判断就是造成不断WA的原因，我们的目的其实是判断这个结点是不是叶子，抑或还只是缺了其中一个孩子，只有是叶子才能//赋值，判断叶子不能直接的 !pre->lchild  && !pre->rchild  因为这两个可能是野指针！

//试想一下扩展前序建树，其实和前序遍历的顺序是相同的，先是根结点，再左孩子，再右孩子，如果是叶子结点，那么左右孩子必//定为空，假设这个结点是左孩子，你能单纯地判断!pre->rchild吗？不能，因为这个时候的rchild是野指针，甚至都还没赋值，//你都不知道它还没有数据。有一个判断是一定准确的，那就是！如果这次的递归是用右边递归进来，而且是空结点，那么就只需要//判断前驱的左孩子是不是空，但问题是怎么知道这次的递归是用右边递归进来，那就是用mark来标记！

//所以现在可以理解这个判断了吧 mark==2 && !(pre->lchild)  && sum==key 是从右边递归进来的，而前驱

//的左孩子又是空，而sum又等于key，那就是这个结点了



    }

    else

    {

        pre=(*T)=(struct BTree*)malloc(LEN);

        (*T)->data=a[len];

        sum=sum+a[len]; 

        pre=(*T);  mark=1; create_BTree( &((*T)->lchild) , sum , key,mark); 

        if(ok)  return ;   //在每个递归函数的出口加一个判断条件，如果已经找到答案就直接返回

        pre=(*T);  mark=2; create_BTree( &((*T)->rchild) , sum , key,mark);  

        if(ok)  return ;   //在每个递归函数的出口加一个判断条件，如果已经找到答案就直接返回

    }

}

int main()

{

    int i,key,sum,mark;  struct BTree *T;

    while(scanf("%d",&key)!=EOF)

    {

        top=-1; count=0; 

        input();

        len=-1; ok=sum=0; pre=NULL; mark=0; create_BTree(&T,sum,key,mark);

        if(ok==1)  printf("yes\n");

        else       printf("no\n");

    }

    return 0;

}