[2016-02-08][UVA][548][Tree]

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

#include <vector>

#include <list>

#include <map>

#include <set>

#include <deque>

#include <queue>

#include <stack>

#include <bitset>

#include <algorithm>

#include <functional>

#include <numeric>

#include <utility>

#include <sstream>

#include <iostream>

#include <iomanip>

#include <cstdio>

#include <cmath>

#include <cstdlib>

#include <cctype>

#include <string>

#include <cstring>

#include <cstdio>

#include <cmath>

#include <cstdlib>

#include <ctime>

using namespace std;

typedef long long LL;

#define CLR(x,y) memset((x),(y),sizeof((x)))

#define FOR(x,y,z) for(int (x)=(y);(x)<(z);(x)++)

#define FORD(x,y,z) for(int (x)=(y);(x)>=(z);(x)--)

#define FOR2(x,y,z) for((x)=(y);(x)<(z);(x)++)

#define FORD2(x,y,z) for((x)=(y);(x)>=(z);(x)--)

const int maxn = 10000 + 100;

int in[maxn],post[maxn];

char tmp[maxn * 7];

int res,hysum;

void dfs(int L1,int R1,int L2,int R2,int sum){

        if(L1 == R1 &&  hysum > sum + in[L1] ){

                res = in[L1];

                hysum = sum + in[L1];

        }

        if(L1 >= R1)    return ;

        //find root in inorder

        int root = post[R2];  

        int i = 0;

        while(in[i] != root)    i++;

        //len of lson: i - L1

        dfs(L1,i - 1,L2,L2 + i - L1 - 1,sum + root);

        dfs(i + 1,R1,L2 + i - L1,R2 - 1,sum + root);

}

int main(){

        while(gets(tmp)){

                int a,i = 0;

                char *p = tmp;

                while( ~sscanf(p,"%d",&a)){

                        in[i++] = a;

                        do{

                                p++;a /= 10;

                        }while(a);

                        while(*p && isspace(*p))        p++;

                }

                gets(tmp);

                i = 0,p = tmp;

                while( ~sscanf(p,"%d",&a)){

                        post[i++] = a;

                        do{

                                p++;a /= 10;

                        }while(a);

                        while(*p && isspace(*p))        p++;

                }

                res = maxn;

                hysum = maxn * maxn;

                dfs(0,i - 1,0,i - 1,0);

                printf("%d\n",res);

        }

    return 0;

}