Recovering Secret Values from Sum Permutations

Given a collection of seven integers that represent a permutation of $A, B, C, A+B, B+C, A+C,$ and $A+B+C$ (with the constraint $A \le B \le C$), the objective is to isolate the original base values. Sorting the input array in ascending order immediately separates $A$ and $B$ as the first two elements, since any positive summation inherently exceeds its individual components. The third position in the sorted sequence contains either $C$ or $A+B$. If the sum of the initial two elemenst matches the third element, $C$ must occupy the fourth position. Otherwise, the third element is $C$. This deterministic mapping holds because $A+B+C$ is strictly larger than all other derived values.

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    std::vector<long long> inputs(7);
    for (auto &val : inputs) {
        std::cin >> val;
    }

    std::sort(inputs.begin(), inputs.end());

    long long first = inputs[0];
    long long second = inputs[1];
    long long third = (first + second == inputs[2]) ? inputs[3] : inputs[2];

    std::cout << first << " " << second << " " << third << "\n";
    return 0;
}

Evaluating Contiguous Segments for Mean Presence

The task requires counting how many contiguous subarrays contain an element that exact matches the arithmetic mean of that subarray. With $N$ capped at $100$, an exhaustive enumeration of all possible ranges operates within acceptable time limits. By iterating through every valid starting index $i$ and extending to every ending index $j$, a cumulative sum can be maintained. For each window, if the total sum divides evenly by the window length, the calculated average is verified against the elements within that specific range. A counter increments only when a matching element is found.

#include <iostream>
#include <vector>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    if (!(std::cin >> n)) return 0;

    std::vector<int> petal_counts(n);
    for (int &val : petal_counts) std::cin >> val;

    int valid_segments = 0;
    for (int i = 0; i < n; ++i) {
        int running_sum = 0;
        for (int j = i; j < n; ++j) {
            running_sum += petal_counts[j];
            int segment_len = j - i + 1;
            
            if (running_sum % segment_len == 0) {
                int target_avg = running_sum / segment_len;
                bool found = false;
                for (int k = i; k <= j; ++k) {
                    if (petal_counts[k] == target_avg) {
                        found = true;
                        break;
                    }
                }
                if (found) ++valid_segments;
            }
        }
    }

    std::cout << valid_segments << "\n";
    return 0;
}

Grid Trajectory Simulation and Intersection Resolution

Entities traverse an unbounded Cartesian grid either eastward or northward at a constant rate of one unit per hour. Movement terminates when an entity attempts to occupy a cell whose resources were previously depleted. Simulating this process hour-by-hour is inefficient due to large coordinate bounds, so an event-driven approach is required.

For each pair consisting of an eastbound and a northbound entity, compute their potential intersection coordinates. Calculate the time required for each to reach thatt point. The entity requiring less time arrives first and consumes the cell. The trailing entity will halt upon arrival, but only if the leading entity was not interrupted beforehand. All valid intersection scenarios are stored as events, sorted by the arrival time of the leading entity. Processing these events in chronological order allows for accurate halt distance assignment. Entities that never encounter a pre-consumed cell maintain infinite movement potential.

#include <iostream>
#include <vector>
#include <algorithm>

struct Agent {
    int id;
    char heading;
    long long start_x, start_y;
    long long travel_limit = -1;
};

struct Event {
    long long lead_time;
    long long coord_x, coord_y;
    int leader_idx, follower_idx;
    
    bool operator<(const Event &other) const {
        return lead_time < other.lead_time;
    }
};

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int total_agents;
    std::cin >> total_agents;
    std::vector<Agent> agents(total_agents);
    for (int i = 0; i < total_agents; ++i) {
        agents[i].id = i;
        std::cin >> agents[i].heading >> agents[i].start_x >> agents[i].start_y;
    }

    std::vector<Event> intersections;
    for (int i = 0; i < total_agents; ++i) {
        for (int j = 0; j < total_agents; ++j) {
            if (agents[i].heading == 'E' && agents[j].heading == 'N') {
                long long meet_x = agents[j].start_x;
                long long meet_y = agents[i].start_y;
                
                if (meet_x <= agents[i].start_x || meet_y <= agents[j].start_y) continue;

                long long time_east = meet_x - agents[i].start_x;
                long long time_north = meet_y - agents[j].start_y;

                if (time_east < time_north) {
                    intersections.push_back({time_east, meet_x, meet_y, i, j});
                } else if (time_north < time_east) {
                    intersections.push_back({time_north, meet_x, meet_y, j, i});
                }
            }
        }
    }

    std::sort(intersections.begin(), intersections.end());

    for (const auto &evt : intersections) {
        if (agents[evt.follower_idx].travel_limit != -1) continue;
        if (agents[evt.leader_idx].travel_limit != -1 && agents[evt.leader_idx].travel_limit < evt.lead_time) continue;
        
        agents[evt.follower_idx].travel_limit = evt.lead_time;
    }

    for (const auto &a : agents) {
        if (a.travel_limit == -1) {
            std::cout << "Infinity\n";
        } else {
            std::cout << a.travel_limit << "\n";
        }
    }

    return 0;
}