Submission #1126134

#	Time	Username	Problem	Language	Result	Execution time	Memory
1126134		_unknown_2010	Addk (eJOI21_addk)	C++20	0 / 100	47 ms	3396 KiB

Main

//#ifndef LOCAL
//#pragma GCC optimize ("Ofast")
//#pragma GCC optimize ("unroll-loops")
//#endif

#include <bits/stdc++.h>
using namespace std;
#define int int64_t
#define pb  push_back
#define vi vector
#define vii vector<pair<int,int>>
#define lb lower_bound
#define ub upper_bound
#define ins insert
#define ss second
#define ff first
#define TESTCASES
#define sz(x) int(x.size())
#define all(x) (x).begin(), (x).end()
#define seea(a,n) for(int i=0;i<n;i++){cin>>a[i];}
const int mod = 1E9+7;
const int MAXN=200000;
const int inf=1e18;

#ifndef khos
#define debug(...) 42
#endif 

#define debug(args...)                                                         \
    {                                                                          \
        cout << "[" << #args << "]: ";                                         \
        my::debug::debug_out(args);                                            \
        cout << endl;                                                          \
    }

namespace my::debug {
using std::cout;

template <typename T, typename = void>
struct is_container : std::false_type {};

template <typename T>
struct is_container<T, std::void_t<decltype(std::begin(std::declval<T>()))>>
    : std::true_type {};

template <typename T>
constexpr bool is_container_v = is_container<T>::value;

template <typename Test, template <typename...> class Ref>
struct is_specialization : std::false_type {};

template <template <typename...> class Ref, typename... Args>
struct is_specialization<Ref<Args...>, Ref> : std::true_type {};

template <typename Test, template <typename...> class Ref>
constexpr bool is_specialization_v = is_specialization<Test, Ref>::value;

// https://stackoverflow.com/a/47563100
template <std::size_t N>
struct num {
    static const constexpr auto value = N;
};

template <class F, std::size_t... Is>
void for_(F func, std::index_sequence<Is...>) {
    (func(num<Is>{}), ...);
}

template <std::size_t N, typename F>
void for_(F func) {
    for_(func, std::make_index_sequence<N>());
}

template <typename T>
constexpr auto is_coutable(int)
    -> decltype(std::cout << std::declval<T>(), std::true_type{}) {
    return std::true_type{};
}

template <typename T>
constexpr std::false_type is_coutable(...) {
    return std::false_type{};
}

template <typename T>
constexpr bool is_coutable_v = decltype(is_coutable<T>(0))::value;

template <typename T>
void single_out(T x) {
    if constexpr (std::is_same_v<T, std::string> | std::is_same_v<T, char*> ||
                  std::is_same_v<T, const char*>) {
        cout << '"' << x << '"';
    } else if constexpr (std::is_same_v<T, char>) {
        cout << x;
    } else if constexpr (std::is_integral_v<T> || std::is_floating_point_v<T> ||
                         std::is_enum_v<T> || std::is_pointer_v<T>) {
        cout << x;
    } else if constexpr (is_specialization_v<T, std::pair>) {
        cout << "(";
        single_out(x.first);
        cout << ", ";
        single_out(x.second);
        cout << ")";
    } else if constexpr (is_specialization_v<T, std::tuple>) {
        cout << "(";
        std::string sep = "";
        for_<std::tuple_size_v<T>>([&](auto i) {
            cout << exchange(sep, ", ");
            single_out(std::get<i.value>(x));
        });
        cout << ")";
    } else if constexpr (is_specialization_v<T, std::map> ||
                         is_specialization_v<T, std::unordered_map>) {
        cout << "{";
        std::string sep = "";
        for (auto [k, v] : x) {
            cout << exchange(sep, ", ");
            single_out(k);
            cout << ": ";
            single_out(v);
        }
        cout << "}";
    } else if constexpr (is_container_v<T>) {
        if constexpr (is_specialization_v<T, std::vector>) {
            cout << "[";
        } else cout << "{";
        std::string sep = "";
        for (auto i : x) {
            cout << exchange(sep, ", ");
            single_out(i);
        }
        if constexpr (is_specialization_v<T, std::vector>) {
            cout << "]";
        } else cout << "}";
    }
    // types without iterator, f*** you, c++ comittee
    else if constexpr (is_specialization_v<T, std::queue>) {
        cout << "{";
        std::string sep = "";
        while (x.size()) {
            cout << exchange(sep, ", ");
            single_out(x.front());
            x.pop();
        }
        cout << "}";

    } else if constexpr (is_specialization_v<T, std::stack> ||
                         is_specialization_v<T, std::priority_queue>) {
        std::vector<
            std::remove_cv_t<std::remove_reference_t<decltype(x.top())>>>
            v;
        while (x.size()) {
            v.push_back(x.top());
            x.pop();
        }

        if constexpr (is_specialization_v<T, std::stack>)
            std::reverse(v.begin(), v.end());

        cout << "{";
        std::string sep = "";
        for (auto i : v) {
            cout << exchange(sep, ", ");
            single_out(i);
        }
        cout << "}";
    }
    // lastly, if the expression (cout << x) compiles, use it
    else {
        static_assert(is_coutable_v<T>, "The type given to debug() is not supported.");
        cout << x;
    }
}

template <typename T, typename... Rest>
void debug_out(T, Rest...);

void debug_out();

template <typename T, typename... Rest>
void debug_out(T x, Rest... rest) {
    // single_out<std::remove_cv_t<std::decay_t<T>>>(x);
    single_out<std::remove_cv_t<T>>(x);
    if (sizeof...(rest) > 0) cout << ", ";
    debug_out(rest...);
}

void debug_out() {
}
}; // namespace my::debug
struct segtree{
    vi<int> tree;
    int sz;
    void init(int n){
        sz=1;
        while(sz<n)sz*=2;
        tree.assign(2*sz-1,0);
    }
    void update(int i,int v,int x,int lx,int rx){
        if(rx-lx==1){
            tree[x]=v;
            return;
        }
        int m=(lx+rx)/2;
        if(i<m)update(i,v,2*x+1,lx,m);
        else update(i,v,2*x+2,m,rx);
        tree[x]=tree[2*x+1]+tree[2*x+2];
    }
    void update(int i,int v){
        return update(i,v,0,0,sz);
    }
    int sum(int l,int r,int x,int lx,int rx){
        if(l>=rx || r<=lx)return 0;
        if(l<=lx && rx<=r){
            return tree[x];
        }
        int m=(lx+rx)/2;
        int s1=sum(l,r,2*x+1,lx,m);
        int s2=sum(l,r,2*x+2,m,rx);
        return s1+s2;
    }
    int sum(int l,int r){
        r+=1;
        return sum(l,r,0,0,sz);
    }
} sg, st;
int get(int l, int r){
    return sg.sum(l,r)-(l-1)*st.sum(l,r);
}
void solution(){
    int n,k;
    cin >> n >> k;
    vi<int> a(n+1);
    sg.init(n+1);
    st.init(n+1);
    for(int i=1; i<=n; i++){
        cin >> a[i];
        sg.update(i,a[i]*i);
        st.update(i,a[i]);
    }
    int q;
    cin >> q;
    while(q--){
        int op;
        cin >> op;
        if(op==1){
            int x;
            cin >> x;
        }
        else {
            int l,r,m;
            cin >> l >> r >> m;
            if(r-l+1<2*m){
                int val=(r-l+1)-m+1;
                int lx=r-(m-1),rx=l+(m-1);
                int ans=get(l,lx-1)+val*st.sum(lx,r)-get(rx+1,r);
                cout << ans << ' ';
            }
            else {
                int lx=l+m-1,rx=r-m+1;
                int ans=get(l,lx-1)+m*st.sum(lx,rx)+get(rx+1,r);
                cout << ans << ' ';
            }
        }
    }
}
int32_t main(){
    clock_t tStart = clock();
    #ifdef khos
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int q = 1;
    #ifdef TESTCASES
        //cin >> q;
    #endif
    while(q--) {
        solution();
        cout << '\n';
    }
    cerr<<fixed<<setprecision(3)<<"\nTime Taken: "<<(double)(clock()- tStart)/CLOCKS_PER_SEC<<endl;
}

Compilation message (stderr)

Main.cpp:29: warning: "debug" redefined
   29 | #define debug(args...)                                                         \
      | 
Main.cpp:26: note: this is the location of the previous definition
   26 | #define debug(...) 42
      |

• Subtask 1: 0 / 36
• Subtask 2: 0 / 56
• Subtask 3: 0 / 8