提出 1db30378-6266-43f5-b1e1-be67196cd554

コード

#ifndef MAIN
#define MAIN
#include __FILE__
#define mp make_pair

string toup(string s)
{
    rep(i, s.at(i)) {
        if (s.at(i) >= 'a' && s.at(i) <= 'z') {
            s.at(i) -= 32;
        }
    }
    return s;
}

string tolow(string s)
{
    rep(i, s.at(i)) {
        if (s.at(i) >= 'A' && s.at(i) <= 'Z') {
            s.at(i) += 32;
        }
    }
    return s;
}

bool isPalindrome(const std::string& str) {
    int left = 0;
    int right = str.size() - 1;
    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        ++left;
        --right;
    }
    return true;
}

void _main()
{
    cint(n);
    cvec(n,h);
    cint(d);
    vector<int> l(d),r(d),x(d),a(d),b(d);
    bool alllrsame=true;
    rep(i,d){
        cin>>l[i]>>r[i]>>x[i]>>a[i]>>b[i];
        if(l[i]!=r[i]) alllrsame=false;
    }
    if(alllrsame){
        rep(i,d){
            h[l[i]]+=x[i];
            cout<<*max_element(h.begin()+a[i]-1,h.begin()+b[i]-1)<<endl;
        }
    }
    else{
        rep(i,d){
            repf(j,l[i]-1,r[i]){
                h[j]+=x[i];
            }
            cout<<*max_element(h.begin()+a[i]-1,h.begin()+b[i]-1)<<endl;
        }
    }
}

#else
#define MAIN
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")

#if __has_include(<bits/stdc++.h>)
#include <bits/stdc++.h>
#else
import std;
#endif
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
using modint10 = modint1000000007;
using motint9 = modint998244353;
#endif
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<string> strvec;

constexpr ll mod10 = 1000000007;
constexpr ll mod9 = 998244353;
constexpr ll inf = 10000000000000000;

#define int ll
#define double ld
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repf(i, s, n) for (int i = s; i < (int)(n); i++)
template <class... Args>
void __y_input(Args &...arg)
{
    (cin >> ... >> arg);
}

template <class... Args>
void __y_input_vec_1(int p, Args &...args)
{
    (cin >> ... >> args[p]);
}
template <class Arg>
void __y_input_vec_resize(int size, Arg& arg)
{
    arg.resize(size);
}
template <class... Args>
void __y_input_vec(int n, Args &...args)
{
    (__y_input_vec_resize(n, args), ...);
    rep(i, n)
    {
        (__y_input_vec_1(i, args), ...);
    }
}

#define cint(...)  \
    int __VA_ARGS__; \
    __y_input(__VA_ARGS__)

#define cdbl(...)     \
    double __VA_ARGS__; \
    __y_input(__VA_ARGS__)

#define cstr(...)     \
    string __VA_ARGS__; \
    __y_input(__VA_ARGS__)

#define cit(t, ...) \
    t __VA_ARGS__;    \
    __y_input(__VA_ARGS__)

#define cvec(n, ...)       \
    vector<int> __VA_ARGS__; \
    __y_input_vec(n, __VA_ARGS__)

#define cvect(t, n, ...) \
    vector<t> __VA_ARGS__; \
    __y_input_vec(n, __VA_ARGS__)

#define last cout << endl
#define yn(bl) (bl ? "Yes" : "No")

ostream& yesno(bool bl)
{
    cout << yn(bl);
    return cout;
}
typedef array<int, 2> xy;
typedef array<int, 3> xyz;

template <typename T>
inline void sort(T& vec)
{
    return sort(vec.begin(), vec.end());
}
template <typename T>
inline void rsort(T& vec)
{
    return sort(vec.rbegin(), vec.rend());
}

namespace __yc
{
    template <typename T>
    struct __set : public std::set<T>
    {
        inline void Merge(set<T>& other)
        {
            if (this->size() < other.size())
            {
                other.merge(*this);
                swap(*this, other);
            }
            else
            {
                this->merge(other);
            }
            return;
        }
    };
    template <typename T>
    struct set : public __set<T>
    {
        inline void merge(set<T>& other)
        {
            this->Merge(other);
        }
    };
}

#define set __yc::set

void _main();
signed main()
{
    cin.tie(0);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    _main();
    return 0;
}

#endif
結果

問題	点数	言語	結果	実行時間	メモリ
H. Gardening Diary	0	C++ (gcc)	TLE	2104 ms	8396 KiB