DataStructureAndAlgorithm/2023204/main.cpp

#include <stdio.h>
#define DEAD false
#define ALIVE true
// 'Natural count' is the name of the node when all the nodes in the tree is
// alive. xxx_num denotes the count as the question described.

int ans[30] = {0};
int dead_nodes_num[105] = {0};
int total_dead_nodes = 0;
int target_nodes_num[105] = {0};
int total_target_nodes = 0;

struct SeveralContinuedDeadNode {
    bool status;
    int length; // Caution that when status == dead and length == 1, the node
                // itself is alive.
};

struct SearchResult {
    int next_ans_pos;         // pos in the ans[] array.
    int count_in_father_line; // natural count.
};

SearchResult find_node(int target, int start_num, int next_dead_node_num_ptr,
                       SeveralContinuedDeadNode *upper_line, int upper_line_segment_count,
                       int layer) {
    int spawned_node_max_num = start_num - 1;
    int segment_count = upper_line_segment_count;
    SeveralContinuedDeadNode current_line_node[200] = {0};
    int current_line_len = 0;
    bool all_dead = true;

    // Spawing all the nodes in current line
    for (int upper_line_iter = 0; upper_line_iter < upper_line_segment_count; upper_line_iter++) {
        if (upper_line[upper_line_iter].status == DEAD) {
            current_line_node[current_line_len] = upper_line[upper_line_iter];
            current_line_node[current_line_len].length *= 2;
            current_line_len++;
        }
        else {
            all_dead = false;
            int total_spawned_after = spawned_node_max_num + upper_line[upper_line_iter].length * 2;
            while (dead_nodes_num[next_dead_node_num_ptr] <= total_spawned_after &&
                   next_dead_node_num_ptr < total_dead_nodes) {
                if (dead_nodes_num[next_dead_node_num_ptr] - spawned_node_max_num > 1) {
                    current_line_node[current_line_len] = SeveralContinuedDeadNode{
                        ALIVE, dead_nodes_num[next_dead_node_num_ptr] - spawned_node_max_num - 1};
                    current_line_len++; // things before this new dead node
                }
                current_line_node[current_line_len] =
                    SeveralContinuedDeadNode{DEAD, 1}; // this new dead node
                current_line_len++;

                spawned_node_max_num = dead_nodes_num[next_dead_node_num_ptr]; // we now spawned to
                                                                               // this dead node.
                next_dead_node_num_ptr++;
            }
            if (spawned_node_max_num < total_spawned_after) {
                current_line_node[current_line_len] =
                    SeveralContinuedDeadNode{ALIVE, total_spawned_after - spawned_node_max_num};
                current_line_len++;
            }

            spawned_node_max_num = total_spawned_after;
        }
    }

    if (all_dead) {
        return SearchResult{1, -1};
    }

    if (target <= spawned_node_max_num) {
        ans[0] = target;
        int natural_pos = -1, num = start_num - 1;
        for (int i = 0; i < current_line_len; i++) {
            if (current_line_node[i].status == DEAD) {
                natural_pos += current_line_node[i].length;
                num += (current_line_node[i].length == 1);
                if (num == target) {
                    return SearchResult{1, natural_pos / 2};
                }
                continue;
            }

            // Now deal with alive nodes
            if (num + current_line_node[i].length < target) {
                natural_pos += current_line_node[i].length;
                num += current_line_node[i].length;
            }
            else {
                // if we made it here, then the target > num + current_line_node[i].length
                return SearchResult{1, (natural_pos + target - num) / 2};
            }
        }
        return SearchResult{1, -1};
    }
    else {
        SearchResult current_line_pos =
            find_node(target, spawned_node_max_num + 1, next_dead_node_num_ptr, current_line_node,
                      current_line_len, layer + 1);
        if (current_line_pos.count_in_father_line < 0) {
            // The path does not exist.
            return SearchResult{1, -1};
        }

        int natural_count = -1, num = start_num - 1;
        for (int i = 0; i < current_line_len; i++) {
            natural_count += current_line_node[i].length;
            if (current_line_node[i].status == ALIVE || current_line_node[i].length == 1) {
                num += current_line_node[i].length;
            }

            if (natural_count >= current_line_pos.count_in_father_line) {
                num -= natural_count - current_line_pos.count_in_father_line;
                ans[current_line_pos.next_ans_pos++] = num;
                break;
            }
        }
        return SearchResult{current_line_pos.next_ans_pos,
                            current_line_pos.count_in_father_line / 2};
    }
}

int main() {
    scanf("%d %d", &total_dead_nodes, &total_target_nodes);
    for (int i = 0; i < total_dead_nodes; i++) {
        scanf("%d", &dead_nodes_num[i]);
    }
    if (dead_nodes_num[0] == 1) {
        for (int i = 0; i < total_target_nodes; i++) {
            printf("0\n");
        }
    }
    else {
        int current_target = 0;
        SeveralContinuedDeadNode firstline = SeveralContinuedDeadNode{ALIVE, 1};
        for (int i = 0; i < total_target_nodes; i++) {
            scanf("%d", &current_target);
            SearchResult result = find_node(current_target, 2, 0, &firstline, 1, 2);
            if (result.count_in_father_line == -1) {
                printf("0\n");
            }
            else {
                printf("1 ");
                for (int j = result.next_ans_pos - 1; j >= 0; j--) {
                    printf("%d ", ans[j]);
                }
                printf("\n");
            }
        }
    }

    return 0;
}