Approach

Check if all input value are identical.

Solution Code

#include <iostream>
#include <vector>

bool checkUniform(const std::vector<int>& values) {
    for(size_t i = 1; i < values.size(); ++i) {
        if(values[i] != values[0]) return false;
    }
    return true;
}

int main() {
    int testCases;
    std::cin >> testCases;
    
    while(testCases--) {
        std::vector<int> inputs(4);
        for(auto &val : inputs) std::cin >> val;
        std::cout << (checkUniform(inputs) ? "NO\n" : "YES\n");
    }
    return 0;
}

Crossing Street Problem

Approach

Consider different traffic light scenarios:

• Green light:
  • Sufficient time remaining: Cross immediately
  • Insufficient time: Wait for next cycle
• Red light: Wait until green

Solution Code

#include <iostream>

int calculateTime(int greenDur, int redDur, int crossTime, char current) {
    if(current == 'G') {
        return (greenDur >= crossTime) ? crossTime : crossTime + greenDur + redDur;
    }
    return redDur + crossTime;
}

int main() {
    int g, r, k, t;
    char state;
    std::cin >> g >> r >> k >> t >> state;
    std::cout << calculateTime(g, r, t, state) << "\n";
    return 0;
}

String Coloring Problem

Approach

Color each character individually since single-character segments are white by default.

Solution Code

#include <iostream>
#include <string>

void printColorRanges(int length) {
    std::cout << length << "\n";
    for(int i = 1; i <= length; ++i) {
        std::cout << i << " " << i << "\n";
    }
}

int main() {
    int tests;
    std::cin >> tests;
    while(tests--) {
        int n;
        std::string s;
        std::cin >> n >> s;
        printColorRanges(n);
    }
    return 0;
}

Energy Necklace Problem

Approach

Maintain prefix and suffix maximmus to find optimal remaining segments after operations.

Solution Code

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

int maxEnergy(std::vector<int>& gems, int operations) {
    int size = gems.size();
    if(size == 1) return gems[0];
    
    std::vector<int> prefixMax(size), suffixMax(size);
    prefixMax[0] = gems[0];
    for(int i = 1; i < size; ++i) {
        prefixMax[i] = std::max(prefixMax[i-1], gems[i]);
    }
    
    suffixMax[size-1] = gems.back();
    for(int i = size-2; i >= 0; --i) {
        suffixMax[i] = std::max(suffixMax[i+1], gems[i]);
    }
    
    int maxLen = std::max(2, size - operations);
    int result = 0;
    for(int i = 0; i <= size - maxLen; ++i) {
        result = std::max(result, prefixMax[i] + suffixMax[i + maxLen - 1]);
    }
    return result;
}

int main() {
    int testCases;
    std::cin >> testCases;
    while(testCases--) {
        int n, k;
        std::cin >> n >> k;
        std::vector<int> items(n);
        for(auto &item : items) std::cin >> item;
        std::cout << maxEnergy(items, k) << "\n";
    }
    return 0;
}