Submission #76565147

---

Source Code Expand

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <cmath>
#include <set>
#include <iomanip>
#include <queue>
#include <numeric>
#include<stack>
using namespace std;

#define LOCAL
#define ll long long
#define vll vector<ll>
#define vvll vector<vll>
#define Fast ios::sync_with_stdio(false); cin.tie(0);
#define inp(t) int t; cin >> t; while(t--){solve();}
#define Once int t=1; while(t--){solve();}
#define pb push_back
#define f(i,a,b) for(ll i = 0; i < a; i+=b)
#define ff first
#define ss second
void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << H;
    debug_out(T...);
}
template <typename T>
void debug_out(const vector<T>& v) {
    cerr << " [";
    for (int i = 0; i < (int)v.size(); i++) {
        cerr << v[i];
        if (i + 1 < (int)v.size()) cerr << ", ";
    }
    cerr << "]" << endl;
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// ================= CONSTANTS =================
const ll MOD = 998244353;
const ll INF = 1e18;
const int MAXN = 2e6;
long long gcd(long long a, long long b){ return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b){ return a / gcd(a, b) * b; }
// ================= SPF SIEVE =================
int spf[MAXN + 1];
void compute_spf() {
    for (int i = 1; i <= MAXN; i++) spf[i] = i;
    for (int i = 2; i * i <= MAXN; i++) {
        if (spf[i] == i) {
            for (int j = i * i; j <= MAXN; j += i)
                if (spf[j] == j) spf[j] = i;
        }
    }
}

ll prime_factors(ll x) {
    ll r = 0;
    while (x > 1){
        r++;
        ll p = spf[x];
        while (x % p == 0) x/=p;
    }
    return r;
}
ll max_factor(ll x) {
    ll r = 0;
    while (x > 1){
        r++;
        ll p = spf[x];
        while (x % p == 0) x/=p;
        if (x == 1){
            return p;
        }
    }
    return 1;
}

// // ================= INTERACTIVE =================
// ll query(int l, int r){
//     cout << "? " << l << ' ' << r << endl;
//     ll val;
//     cin >> val;
//     if(val == -1) exit(0);
//     return val;
// }

// // ================= COMBINATORICS =================
vector<ll> fact(MAXN + 1), inv_fact(MAXN + 1);
ll power(ll a, ll b, ll m = MOD) {
    ll res = 1;
    a %= m;
    while (b > 0) {
        if (b & 1)
            res = (res * a) % m;
        a = (a * a) % m;
        b >>= 1;
    }
    return res;
}
ll modInverse(ll n, ll m = MOD){
    return power(n, m - 2);
}

void precompute_factorials(ll m = MOD){
    fact[0] = 1;
    for (int i = 1; i <= MAXN; i++){
        fact[i] = (fact[i - 1] * i) % m;
    }
    inv_fact[MAXN] = power(fact[MAXN], m - 2);
    for (int i = MAXN - 1; i >= 0; i--){
        inv_fact[i] = (inv_fact[i + 1] * (i + 1)) % m;
    }
}

ll nCr(ll n, ll r, ll m = MOD){
    if (r < 0 || r > n) return 0;
    return (((fact[n] * inv_fact[r]) % m) * inv_fact[n - r]) % m;
}

// // ================= DSU =================

template <typename T>
class DSU {
public:
    unordered_map<T, T> parent;
    unordered_map<T, int> sz;

    void make_set(T v){
        if (parent.count(v)) return;
        parent[v] = v;
        sz[v] = 1;
    }

    T find(T v){
        if (parent[v] == v) return v;
        return parent[v] = find(parent[v]);
    }

    bool unite(T a, T b){
        a = find(a);
        b = find(b);
        if (a == b) return false;
        if (sz[a] < sz[b]) swap(a, b);
        parent[b] = a;
        sz[a] += sz[b];
        return true;
    }

    int get_size(T v){
        return sz[find(v)];
    }
};


// bool cmp(const vll a, const vll b){
//     if (a[0] > b[0]) return true;
//     else if (a[0] == b[0]){
//         if (a[1] > b[1]) return false;
//         return true;
//     }
//     return false;
// }

ll check(ll x){
    ll p = 6;
    ll v = 1;
    ll r = 10;
    ll val = 0;
    for (int i=0; i<9; i++){
        val += (((x + p) / r) * v);
        v *= 9;
        r *= 10;
        p *= 10;
    }
    return (x - val);
}

ll rec(ll l, ll r, vll &a, vvll &dp){
    if (l > r) return 0;
    if (dp[l][r] != INF) return dp[l][r];
    return dp[l][r] = max(a[l] - rec(l+1, r, a, dp), a[r] - rec(l, r - 1, a, dp));
}
void solve(){
    ll n,k;
    cin >> n >> k;
    vll a(n);
    f(i,n,1) cin >> a[i];
    cout << k + *max_element(a.begin(), a.end()) << endl;
}

int main(){
    Fast
    Once;
    return 0;
}

Submission Info

Judge Result