刘汝佳 算法竞赛-入门经典 第二部分 算法篇 第六章 2（Binary Trees）

112 - Tree Summing

　　 题目大意：给出一个数，再给一颗树，每个头节点的子树被包含在头节点之后的括号里，寻找是否有从头节点到叶子的和与给出的数相等，如果有则输出yes，没有输出no！

　　解题思路：按照括号匹配的原则，调用栈，求从头节点到叶子节点的和！

　　解题代码：

//Author    :Freetion
//file        :112 - Tree Summing

#include <stdio.h>
#include <iostream>
#include <stack>
#include <string.h>
using namespace std;

#define Local
int main()
{
#ifdef Local
    freopen ("data.in", "r", stdin);
    freopen ("data.out", "w", stdout);
#endif
    stack <char> bracket;
    int num[100000];
    int mat, cun, wei, sum;
    bool flag = false, zh = true;
    while (~scanf ("%d", &mat))
    {
        flag = false;
        char ch;
        cun = sum = wei = 0;
        while (!bracket.empty())
            bracket.pop();
        while (cin >> ch)
        {
            if (ch == '(')
            {
                wei = 0;
                zh = true;
                bracket.push(ch);
            }
            else if (ch == ')')
            {
                wei = 0;
                zh = true;
                bracket.pop();
                if (bracket.size() == cun)
                {
                    for (int i = 0; i <= cun; i ++)
                        sum += num[i];
                    if (sum == mat)
                        flag = true;
                    else sum = 0;
                }
                if (bracket.empty())
                    break;
            }
            else
            {
                if (ch == '-')
                    zh = false;
                else if(wei)
                {
                    if (!zh)
                        num[cun] = -num[cun];
                    num[cun] = 10*num[cun] + ch - '0';
                    if (!zh)
                        num[cun] = -num[cun];
                }
                else
                {
                
                    cun = bracket.size() - 1;
                    num[cun] = ch - '0';
                    wei ++;
                    if (!zh)
                        num[cun] = -num[cun];
                }
                
            }
        }
        if (flag)
            printf ("yes\n");
        else printf ("no\n");
    }
    return 0;
}

 

548 - Tree

　　题目大意：给出一颗二叉树的中序遍历和后序遍历，求从头节点到叶子节点的最小和，并且将获得该最小和的路径的叶子节点的值输出。

　　解题思路：根据中序遍历和后序遍历递归建树，找到最小和，并保存该路径的叶子节点的值！

　　解题代码：

//Author    :Freetion
//file        :548 - Tree ¸ù¾Ý¶þ²æÊ÷ÖÐÐò±éÀú½á¹ûÓëºóÐò±éÀú½á¹ûÖع¹¶þ²æÊ÷

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <sstream>  
using namespace std;

//#define Local

struct node
{
    int min_sum;
    int min_leaf;
}Min;

void find_minsum(const int& mid, int len_mid, const int& back, int len_back, int sum)
{
    if (len_back == 0)
    { 
    //    cout << " ( ) ";
        return ;
    }
    if (len_back == 1)
    {
        sum += *(&back);
        if (sum < Min.min_sum)
        {
            Min.min_sum = sum;
            Min.min_leaf = *(&back);
        }
        else if (sum == Min.min_sum)
        {
            if (back < Min.min_leaf)
                Min.min_leaf = *(&back);
        }
    //    cout << " ( " << *(&back)<< " ) ";
        return ;
    }
    int k = -1;
    for (int i = 0; i < len_mid; i ++)
        if (*(&mid+i) == *(&back+(len_back-1)))
        {
            k = i;
            break;
        }
    sum += *(&back+(len_back-1));
//    cout << " ( " << *(&back+(len_back-1));
    find_minsum(*(&mid), k, *(&back), k, sum);
    
    find_minsum(*(&mid+k+1), len_mid-k-1, *(&back + k), len_mid-k-1, sum);
//    cout << " ) ";
}

int main()
{
#ifdef Local
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif
    int mid[10005], back[10005];
    string tmp;
    int cun_mid, cun_back;
    string str;
    while (getline(cin, str))
    {
        Min.min_sum = 0x3fffffff;
        cun_mid = cun_back = 0;
        
        istringstream in(str);
        while (in >> tmp)
        {
            int len = tmp.size();
            mid[cun_mid] = 0;
            for (int i = 0; i < len; i ++)
            {
                mid[cun_mid] = 10 * mid[cun_mid] + tmp[i] - '0';
            }
            cun_mid ++;
        }
        
        getline(cin, str);
        istringstream input(str);
        while (input >> tmp)
        {
            int len = tmp.size();
            back[cun_back] = 0;
            for (int i = 0; i < len; i ++)
            {
                back[cun_back] = 10 * back[cun_back] + tmp[i] - '0';
            }
            cun_back ++;
        }
        
        find_minsum(*mid, cun_mid, *back, cun_back, 0);
    //    cout << endl;
        cout << Min.min_leaf << endl;
    }
}

 

297 - Quadtrees

　　解题思路：递归建树，寻找黑节点，找到后将该节点所占像素累加起来，最后输出！

　　解题代码：

//Author    :Freetion
//file        :297 - Quadtrees

#include <stdio.h>
#include <string>
#include <iostream>
using namespace std;

struct TREE
{
    bool black;
    struct TREE *leaf[4];
}tree;
TREE *root1, *root2;
char *q;
int sum;

TREE* build_tree()
{
    TREE *root = new TREE;
    root -> black = 0;
    if(*q == 'p')
    {
        for (int i = 0; i < 4; i ++)
        {
            q ++;
            root -> leaf[i] = build_tree();
        }
    }
    else
    {
        if (*q == 'f')
            root -> black = 1;
        for (int i = 0; i < 4; i ++)
            root -> leaf[i] = NULL;
    }
    return root;
}

void print(TREE *root)
{
    if (root == NULL)
        return;
    printf ("(%d", root -> black);
    for (int i = 0; i < 4; i ++)
        print (root -> leaf[i]);
    printf (")");
    return ;
}

void DFS(TREE *root1, TREE *root2, int cen)//cen代表深度
{
    if (root1 == NULL && root2 == NULL)
        return ;
    if (root1 == NULL)
    {
        if (root2 -> black)
        {
            sum += (1 << (10 - 2*cen)); 
            return;
        }
        for (int i = 0; i < 4; i ++)
            DFS(root1, root2 -> leaf[i], cen + 1);
        return ;
    }
    if (root2 == NULL)
    {
        if (root1 -> black)
        {
            sum += (1 << (10 - 2*cen));
            return ;
        }
        for (int i = 0; i < 4; i ++)
            DFS(root1 -> leaf[i], root2, cen + 1);
        return ;
    }
    if (root1 -> black || root2 -> black)
    {
        sum += (1 << (10 - 2*cen));
        return ;
    }
    for (int i = 0; i < 4; i ++)
        DFS (root1 -> leaf[i], root2 -> leaf[i], cen + 1);
}

int main()
{
    int T;
    scanf ("%d", &T);
    getchar();
    string tre1, tre2, tresum;
    while (T--)
    {
        sum = 0;
        getline(cin, tre1);
        getline(cin, tre2);
        q = &tre1[0];
        root1 = build_tree();
        q = &tre2[0];
        root2 = build_tree();
/*
        print (root1);
        printf ("\n");
        print (root2);
        printf ("\n");
*/
        DFS(root1, root2, 0);
        printf ("There are %d black pixels.\n", sum);
    }
}

 

712 - S-Trees

　　此题Submission error先把代码放这。

//Author    :Freetion
//file        :712 - S-Trees

#include <stdio.h>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

const int max_p = 20;
struct cen
{
    string str;
    int num;
    bool operator < (const cen c) const
    {
        return str < c.str;
    }
};

int main()
{
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
    int leaf[max_p];
    int n, cas = 1;
    cen ce[10];
    while (scanf ("%d", &n) == 1 && n)
    {
        printf ("S-Tree #%d:\n", cas ++);
        for (int i = 0; i < n; i ++)
            cin >> ce[i].str;
        for (int i = 0; i < 2*(n+1); i ++)
            scanf ("%1d", &leaf[i]);
        int que;
        scanf ("%d", &que);
        while (que--)
        {
            for (int i = 0; i < n; i ++)
                scanf ("%1d", &ce[i].num);
            sort (ce, ce+n);
            int node = 1;
            for (int i = 0; i < n; i ++)
            {
                if (ce[i].num)
                    node = 2*node + 1;
                else node = 2*node;
            }
            printf ("%d", leaf[node - (1<<n)]);
        }
        printf ("\n\n");
    }
}

 

699 - The Falling Leaves

　　题目大意：给一颗树的先序遍历，-1代表空节点，那么给出的便是满二叉树，求从左到右竖直在一条直线的节点的和，并从左到有输出。子节点与父节点水平距离为1。

　　解题思路：先把树存入，后按照节点位置累加和，运用map容器可运用负数作下标，怎很容易保存节点位置。

　　解题代码：

//Author    :Freetion
//file        :699 - The Falling Leaves

#include <stdio.h>
#include <iostream>
#include <string>
#include <map>
using namespace std;

struct node
{
    int num;
    int pos;
    node *left, *right;
};
int in;
int Min;
int Max;
map <int, int> stor;
node* build(int pos)
{
    int x;
    if (scanf ("%d", &x) == -1 || (x == -1 && in == 0))
        return NULL;
    in ++;
    node *root = new node;
    if (x != -1)
    {
        root -> pos = pos;
        root -> num = x;
        root -> left = build(pos - 1);
        Min = (Min < pos - 1) ? Min : pos - 1;
        root -> right = build(pos + 1);
        Max = (Max > pos + 1) ? Max : pos + 1;
    }
    if (x == -1)
    {
        root -> left = NULL;
        root -> right = NULL;
    }
    return root;
}

void fall_leaf(node *root)
{
    if (root == NULL)
        return;
    if (root != NULL)
    {
        stor[root -> pos] += root -> num;
        fall_leaf(root -> left);
        fall_leaf(root -> right);
        return;
    }
}

int main()
{
//    freopen("data.in", "r", stdin);
//    freopen("data.out", "w", stdout);
    int cas = 1;
    while (1)
    {
        Min = 0x3fffffff;
        Max = -0x3fffffff;
        in = 0;
        stor.clear();
        node *root = build(0);
        if (root == NULL)
            break;

        fall_leaf(root);
        printf ("Case %d:\n", cas ++);
        for (int i = Min+1; i < Max; i ++)
            printf ("%d%c", stor[i], (i == Max-1) ? '\n' : ' ');
        printf ("\n");
    }
    
}

 

327 - Evaluating Simple C Expressions

　　题目意思很显然。

　　解题思路：直接模拟各种运算符结合的情况。

　　解题代码：

//Author    :Freetion
//file        :327 - Evaluating Simple C Expressions

#define Local
#include <iostream>
#include <stdio.h>
#include <string.h>

int num[200];
char ope[100000];
bool appear[200];

void give_value()
{
    memset(appear, 0, sizeof(appear));
    for (int i = 97; i <= 'z'; i ++)
        num[i] = i - 96;
    return ;
}

int solve()
{
    int ans = 0;
    int add = 0, red = 0;
    int start = 0;
    int len = strlen(ope);
    for (int i = 0; i < len; i ++)
    {
        if (ope[i] == ' ')
            continue;
        if (ope[i] == '-')
        {
            red ++;
            if (red == 2 && add == 0 && start)
            {
                int j = i;
                while (ope[j] == ' ' || ope[j] == '-' || ope[j] == '+')
                    j --;
                num[ope[j]] --;
                red = 0;
                start = 0;
            }
        }
        else if (ope[i] == '+')
        {
            add ++;
            if (red == 0 && add == 2 && start)
            {
                int j = i;
                while (ope[j] == ' ' || ope[j] == '-' || ope[j] == '+')
                    j --;
                num[ope[j]] ++;
                add = 0;
                start = 0;
            }
        }
        else
        {
            start = 1;
            if (add == 1 && red == 2)
            {
                num[ope[i]] --;
                ans += num[ope[i]];
            }
            else if (add == 2 && red == 1)
            {
                num[ope[i]] ++;
                ans -= num[ope[i]];
            }
            else if (add == 0 && red == 1)
                ans -= num[ope[i]];
            else if ((add == 3 || add == 2)&& red == 0)
            {
                num[ope[i]] ++;
                ans += num[ope[i]];
            }
            else if (add == 0 && (red == 3 || red == 2))
            {
                num[ope[i]] --;
                if (red == 3)
                    ans -= num[ope[i]];
                else ans += num[ope[i]];
            }
            else
                ans += num[ope[i]];
            appear[ope[i]] = 1;
            add = red = 0;
        }
    }
    return ans;
}

int main()
{
#ifdef Local
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif
    while (gets(ope))
    {
        int ans;
        give_value();
        printf ("Expression: %s\n", ope);
        ans = solve();
        
        printf ("    value = %d\n", ans);
        for (int i = 'a'; i <= 'z'; i ++)
            if (appear[i])
            printf ("    %c = %d\n", i, num[i]);
    }
}

 

839 - Not so Mobile

　　题目大意：给出一个杠杆，w1，d1，w2，d2，判断杠杆是否平衡，即w1*d1 == w2*d2；如果w1 为 0则说明，左边杠杆下还有杠杆，w2为0亦然。判断所有杠杆是否平衡。

　　解题思路：按照输入直接递归判断。

　　解题代码：

//Author    :Freetion
//file        :839 - Not so Mobile

#include <stdio.h>
#include <math.h>
#include <string>
#include <iostream>
using namespace std;

int w1, d1, w2, d2;
int flag;

int DFS(int w1, int d1, int w2, int d2)
{
    scanf ("%d%d%d%d", &w1, &d1, &w2, &d2);
    if (w1 == 0)
        w1 = DFS(w1, d1, w2, d2);
    if (w2 == 0)
        w2 = DFS(w1, d1, w2, d2);
    if (w1*d1 != w2*d2)
        flag = 0;
    return (w1 + w2);
}

int main()
{
    int T;
    int w1, d1, w2, d2;
    scanf ("%d", &T);
    while (T--)
    {
        flag = 1;
        DFS(0, 0, 0, 0);
        if (flag)
            printf ("YES\n");
        else printf ("NO\n");
        if (T)
            puts("");
    }
    return 0;
}

 

10562 - Undraw the Trees

　　题意也很显然。

　　解题代码：

//Author    :Freetion
//file        :10562 - Undraw the Trees
        #define Local
#include <string>
#include <stdio.h>
#include <iostream>
using namespace std;

string tree[210];
int cun;

void DFS(int D, int B)
{
    int i;
    for (i = B; i >= 0; i --)
        if (tree[D][i] != '-')
            break;
    for (i ++; i < tree[D].size() && tree[D][i] == '-'; i ++)
    {
        if (i >= tree[D+1].size())
            break;
        if (tree[D+1][i] != ' ' && tree[D+1][i] != '#')
        {
            printf ("%c(", tree[D+1][i]);
            if (D+2 < cun && tree[D+2][i] == '|')
                DFS(D+3, i);
            else printf(")");
        }
    }
    printf (")");
    return;
}

int main()
{
#ifdef Local
    freopen ("data.in", "r", stdin);
    freopen ("data.out", "w", stdout);
#endif
    int T;
    tree[0].clear();
    for (int i = 0; i < 210; i ++)
            tree[0] += '-';
    scanf ("%d", &T);
    getchar();
    while (T--)
    {
        cun = 1;
        while (1)
        {
            getline(cin, tree[cun]);
            if (tree[cun][0] == '#')
                break;
            cun ++;
        }
        printf ("(");
        DFS(0, 0);
        printf ("\n");
    }
    return 0;
}