Problem p02537 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define pb push_back
#define mk make_pair
#define MAX 1000001
ll prime[MAX];
#define FAST                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define mod 1000000007
#define gcd __gcd
// ll rec(vector<vector<ll> >& dp,vector<ll>& arr,int n,int i,int k,int w)
// {
//   ll ans=0;
//   if(i>=n)
//     return 0;

//   if(dp[i][k]!=-1)
//     return dp[i][k];

//   if(k!=0)
//   ans=max(rec(dp,arr,n,i+1,w,w),arr[i]+rec(dp,arr,n,i+1,k-1,w));
//   else
//   ans=max(rec(dp,arr,n,i+1,k,w),rec(dp,arr,n,i+1,w,w));

//   return dp[i][k]=ans;

// }

ll t[1200002] = {0};
void build(vector<ll> &a, int v, int tl, int tr) {
  if (tl == tr) {
    t[v] = a[tl];
  } else {
    int tm = (tl + tr) / 2;
    build(a, v * 2, tl, tm);
    build(a, v * 2 + 1, tm + 1, tr);
    t[v] = max(t[v * 2], t[v * 2 + 1]);
  }
}

ll maxi(int v, int tl, int tr, int l, int r) {
  if (l > r)
    return 0;
  if (l == tl && r == tr) {
    return t[v];
  }
  int tm = (tl + tr) / 2;
  return max(maxi(v * 2, tl, tm, l, min(r, tm)),
             maxi(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}

void update(int v, int tl, int tr, int pos, ll new_val) {
  if (tl == tr) {
    t[v] = new_val;
  } else {
    int tm = (tl + tr) / 2;
    if (pos <= tm)
      update(v * 2, tl, tm, pos, new_val);
    else
      update(v * 2 + 1, tm + 1, tr, pos, new_val);
    t[v] = max(t[v * 2], t[v * 2 + 1]);
  }
}

struct hash_pair {
  template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
    auto hash1 = hash<T1>{}(p.first);
    auto hash2 = hash<T2>{}(p.second);
    return hash1 ^ hash2;
  }
};

// int temp[1000002]={0};

// void sieve()
// {

//   for(int i=1;i<1000002;i++)
//     temp[i]=1;

//   for(int i=2;i<1000002;i++)
//   {
//      temp[i]++;
//       for(int j=i*2;j<1000002;j+=i)
//       {
//         temp[j]++;;
//       }
//   }

// }

int main() {

  ll n, k;
  cin >> n >> k;
  vector<ll> a(n);
  for (int i = 0; i < n; i++)
    cin >> a[i];

  int m = 300000;
  int l, r;
  int ans = 0, temp;
  for (int i = 0; i < n; i++) {
    temp = a[i] - k;
    l = max(1, temp);
    temp = a[i] + k;
    r = min(m, temp);
    temp = maxi(1, 1, m, l, r);
    update(1, 1, m, a[i], temp + 1);
    ans = max(ans, temp + 1);
  }
  cout << ans;

  return 0;
}
/*

*/


Error: TLE

Fixed submission:

#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define pb push_back
#define mk make_pair
#define MAX 1000001
ll prime[MAX];
#define FAST                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define mod 1000000007
#define gcd __gcd
// ll rec(vector<vector<ll> >& dp,vector<ll>& arr,int n,int i,int k,int w)
// {
//   ll ans=0;
//   if(i>=n)
//     return 0;

//   if(dp[i][k]!=-1)
//     return dp[i][k];

//   if(k!=0)
//   ans=max(rec(dp,arr,n,i+1,w,w),arr[i]+rec(dp,arr,n,i+1,k-1,w));
//   else
//   ans=max(rec(dp,arr,n,i+1,k,w),rec(dp,arr,n,i+1,w,w));

//   return dp[i][k]=ans;

// }

// ll t[400008];
//  void build(vector<ll>& a, int v, int tl, int tr) {
//      if (tl == tr) {
//          t[v] = a[tl];
//      } else {
//          int tm = (tl + tr) / 2;
//          build(a, v*2, tl, tm);
//          build(a, v*2+1, tm+1, tr);
//          t[v] = max(t[v*2] ,t[v*2+1]);
//      }
//  }

// ll maxi(int v, int tl, int tr, int l, int r) {
//     if (l > r)
//         return 0;
//     if (l == tl && r == tr) {
//         return t[v];
//     }
//     int tm = (tl + tr) / 2;
//     return max(maxi(v*2, tl, tm, l, min(r, tm)) ,maxi(v*2+1, tm+1, tr, max(l,
//     tm+1), r));
// }

// void update(int v, int tl, int tr, int pos, ll new_val) {
//     if (tl == tr) {
//         t[v] = new_val;
//     } else {
//         int tm = (tl + tr) / 2;
//         if (pos <= tm)
//             update(v*2, tl, tm, pos, new_val);
//         else
//             update(v*2+1, tm+1, tr, pos, new_val);
//         t[v] = max(t[v*2] ,t[v*2+1]);
//     }
// }

struct hash_pair {
  template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
    auto hash1 = hash<T1>{}(p.first);
    auto hash2 = hash<T2>{}(p.second);
    return hash1 ^ hash2;
  }
};

int temp[1000002] = {0};

void sieve() {

  for (int i = 1; i < 1000002; i++)
    temp[i] = 1;

  for (int i = 2; i < 1000002; i++) {
    temp[i]++;
    for (int j = i * 2; j < 1000002; j += i) {
      temp[j]++;
      ;
    }
  }
}
int k;
int rec(vector<int> &a, int i, int n, vector<int> &dp) {

  if (i >= n)
    return 0;

  if (dp[i] != -1)
    return dp[i];

  int c = 1;
  for (int j = i + 1; j < n; j++)
    if (abs(a[i] - a[j]) <= k)
      if (dp[j] == -1)
        c = max(c, 1 + rec(a, j, n, dp));
      else {
        c = max(c, 1 + dp[j]);
      }
  return dp[i] = c;
}

int main() {

  int n;
  cin >> n >> k;

  vector<int> a(n);
  for (int i = 0; i < n; i++) {
    cin >> a[i];
  }
  vector<int> dp(n, -1);

  cout << rec(a, 0, n, dp);

  return 0;
}
/*

*/