Problem:
暑い日々 (Hot days)
問題
日本が冬であるこの時期，南半球にあるオーストラリアでは暑い日が続いている．オーストラリアに住む IOI 君は，ある D 日間の天気予報をもとに，着る服の計画を立てることにした．i 日目 (1 ≦ i ≦ D) の最高気温は T
i
度であると予報されている．
IOI 君は N 種類の服を持っており，それらには 1 から N までの番号がついている．服 j (1 ≦ j ≦ N) は最高気温が A
j
度以上 B
j
度以下の日に着るのに適している．また，それぞれの服には「派手さ」とよばれる整数が定まっており，服 j の派手さは C
j
である．
D 日間のそれぞれに対し，IOI 君は，最高気温が天気予報に従ったときに着るのに適した服のうち 1 つを着る服として選ぶ．同じ服を何度選んでもよいし，D 日間で一度も選ばれない服があってもよい．
似ている服を連続して着ることをなるべく避けようと思った IOI 君は，連続する日に着る服の派手さの差の絶対値の合計をできるだけ大きくしようと考えた．すなわち，i 日目に服 x
i
を選んだとして，値 |C
x
1
- C
x
2
| + |C
x
2
- C
x
3
| + … + |C
x
D-1
- C
x
D
| を最大にしたい．この最大値を求めるプログラムを作成せよ．
入力
入力は 1 + D + N 行からなる．
1 行目には，2 つの整数 D, N (2 ≦ D ≦ 200，1 ≦ N ≦ 200) が空白を区切りとして書かれている．D は服の計画を立てる日数，N は IOI 君が持っている服の種類の数を表す．
続く D 行のうちの i 行目 (1 ≦ i ≦ D) には，1 つの整数 T
i
(0 ≦ T
i
≦ 60) が書かれている．これは，i 日目の最高気温が T
i
度であると予報されていることを表す．
続く N 行のうちの j 行目 (1 ≦ j ≦ N) には，3 つの整数 A
j
, B
j
, C
j
(0 ≦ A
j
≦ B
j
≦ 60，0 ≦ C
j
≦ 100) が書かれている．これらは，服 j は最高気温が A
j
度以上 B
j
度以下の日に着るのに適しており，派手さが C
j
であることを表す．
最高気温が天気予報に従ったときに着るのに適した服が，D 日間のどの日に対しても 1 つ以上存在することが保証されている．
出力
連続する日に着る服の派手さの差の絶対値の合計，すなわち，値 |C
x
1
- C
x
2
| + |C
x
2
- C
x
3
| + … + |C
x
D-1
- C
x
D
| の最大値を 1 行で出力せよ．
入出力例
入力例 1
3 4
31
27
35
20 25 30
23 29 90
21 35 60
28 33 40
出力例 1
80
入出力例 1 において，1 日目の服の候補は服 3 と服 4 であり，2 日目の服の候補は服 2 と服 3 であり，3 日目の服の候補は服 3 のみである．1 日目に服 4 を，2 日目に服 2 を，3 日目に服 3 を選ぶ．すなわち，x
1
= 4，x
2
= 2，x
3
= 3 とする．このとき，1 日目と 2 日目の服の派手さの差の絶対値は |40 - 90| = 50 であり，2 日目と 3 日目の服の派手さの差の絶対値は |90 - 60| = 30 である．合計は 80 となり，これが最大値である．
入力例 2
5 2
26
28
32
29
34
30 35 0
25 30 100
出力例 2
300
入出力例 2 において，1 日目には服 2 を，2 日目には服 2 を，3 日目には服 1 を，4 日目には服 2 を，5 日目には服 1 を選ばなければならない．このとき，求める値は |100 - 100| + |100 - 0| + |0 - 100| + |100 - 0| = 300 となる．
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define _GLIBCXX_DEBUG
using namespace std;
using std::cout;
using std::cin;
using std::endl;
using ll=long long;
using ld=long double;
ll ILL=2167167167167167167;
const int INF=2100000000;
const ll mod=998244353;
#define rep(i,a) for (ll i=0;i<a;i++)
#define all(p) p.begin(),p.end()
template<class T> using _pq = priority_queue<T, vector<T>, greater<T>>;
template<class T> ll LB(vector<T> &v,T a){return lower_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> ll UB(vector<T> &v,T a){return upper_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> bool chmin(T &a,const T &b){if(a>b){a=b;return 1;}else return 0;}
template<class T> bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}else return 0;}
template<class T> void So(vector<T> &v) {sort(v.begin(),v.end());}
template<class T> void Sore(vector<T> &v) {sort(v.begin(),v.end(),[](T x,T y){return x>y;});}
void yneos(bool a){if(a) cout<<"Yes\n"; else cout<<"No\n";}
template<class T> void vec_out(vector<T> &p){for(int i=0;i<(int)(p.size());i++){if(i) cout<<" ";cout<<p[i];}cout<<"\n";}

namespace atcoder {
 
namespace internal {
 
template <class T> struct simple_queue {
    std::vector<T> payload;
    int pos = 0;
    void reserve(int n) { payload.reserve(n); }
    int size() const { return int(payload.size()) - pos; }
    bool empty() const { return pos == int(payload.size()); }
    void push(const T& t) { payload.push_back(t); }
    T& front() { return payload[pos]; }
    void clear() {
        payload.clear();
        pos = 0;
    }
    void pop() { pos++; }
};
 
}  // namespace internal
 
}  // namespace atcoder
namespace atcoder {
 
template <class Cap> struct mf_graph {
  public:
    mf_graph() : _n(0) {}
    mf_graph(int n) : _n(n), g(n) {}
 
    int add_edge(int from, int to, Cap cap) {
        assert(0 <= from && from < _n);
        assert(0 <= to && to < _n);
        assert(0 <= cap);
        int m = int(pos.size());
        pos.push_back({from, int(g[from].size())});
        g[from].push_back(_edge{to, int(g[to].size()), cap});
        g[to].push_back(_edge{from, int(g[from].size()) - 1, 0});
        return m;
    }
 
    struct edge {
        int from, to;
        Cap cap, flow;
    };
 
    edge get_edge(int i) {
        int m = int(pos.size());
        assert(0 <= i && i < m);
        auto _e = g[pos[i].first][pos[i].second];
        auto _re = g[_e.to][_e.rev];
        return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
    }
    std::vector<edge> edges() {
        int m = int(pos.size());
        std::vector<edge> result;
        for (int i = 0; i < m; i++) {
            result.push_back(get_edge(i));
        }
        return result;
    }
    void change_edge(int i, Cap new_cap, Cap new_flow) {
        int m = int(pos.size());
        assert(0 <= i && i < m);
        assert(0 <= new_flow && new_flow <= new_cap);
        auto& _e = g[pos[i].first][pos[i].second];
        auto& _re = g[_e.to][_e.rev];
        _e.cap = new_cap - new_flow;
        _re.cap = new_flow;
    }
 
    Cap flow(int s, int t) {
        return flow(s, t, std::numeric_limits<Cap>::max());
    }
    Cap flow(int s, int t, Cap flow_limit) {
        assert(0 <= s && s < _n);
        assert(0 <= t && t < _n);
 
        std::vector<int> level(_n), iter(_n);
        internal::simple_queue<int> que;
 
        auto bfs = [&]() {
            std::fill(level.begin(), level.end(), -1);
            level[s] = 0;
            que.clear();
            que.push(s);
            while (!que.empty()) {
                int v = que.front();
                que.pop();
                for (auto e : g[v]) {
                    if (e.cap == 0 || level[e.to] >= 0) continue;
                    level[e.to] = level[v] + 1;
                    if (e.to == t) return;
                    que.push(e.to);
                }
            }
        };
        auto dfs = [&](auto self, int v, Cap up) {
            if (v == s) return up;
            Cap res = 0;
            int level_v = level[v];
            for (int& i = iter[v]; i < int(g[v].size()); i++) {
                _edge& e = g[v][i];
                if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0) continue;
                Cap d =
                    self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
                if (d <= 0) continue;
                g[v][i].cap += d;
                g[e.to][e.rev].cap -= d;
                res += d;
                if (res == up) break;
            }
            return res;
        };
 
        Cap flow = 0;
        while (flow < flow_limit) {
            bfs();
            if (level[t] == -1) break;
            std::fill(iter.begin(), iter.end(), 0);
            while (flow < flow_limit) {
                Cap f = dfs(dfs, t, flow_limit - flow);
                if (!f) break;
                flow += f;
            }
        }
        return flow;
    }
 
    std::vector<bool> min_cut(int s) {
        std::vector<bool> visited(_n);
        internal::simple_queue<int> que;
        que.push(s);
        while (!que.empty()) {
            int p = que.front();
            que.pop();
            visited[p] = true;
            for (auto e : g[p]) {
                if (e.cap && !visited[e.to]) {
                    visited[e.to] = true;
                    que.push(e.to);
                }
            }
        }
        return visited;
    }
 
  private:
    int _n;
    struct _edge {
        int to, rev;
        Cap cap;
    };
    std::vector<std::pair<int, int>> pos;
    std::vector<std::vector<_edge>> g;
};
 
}  // namespace atcoder
using namespace atcoder;

void solve();
// oddloop
int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int t=1;
	//cin>>t;
	rep(i,t) solve();
}

void solve(){
	int D,N;
	cin>>D>>N;
	vector<int> T(D);
	vector<int> A(N),B(N),C(N);
	vector<int> dp(N,-INF);
	rep(i,D) cin>>T[i];
	rep(i,N){
		cin>>A[i]>>B[i]>>C[i];
		if(A[i]<=T[0]&&T[0]<=B[i]) dp[i]=0;
	}
	rep(day,D-1){
		vector<int> n_dp(N,-INF);
		rep(i,N) rep(j,N){
			if(dp[j]==-INF) continue;
			if(A[i]<=T[day+1]&&T[day+1]<=B[i]){
				chmax(n_dp[i],dp[j]+abs(C[i]-C[j]));
			}
		}
		swap(n_dp,dp);
	}
	int ans=0;
	rep(i,N) chmax(ans,dp[i]);
	cout<<ans<<"\n";
}
accuracy: 1
time_ms: 10
memory_kb: 3368
final_rank: 10

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<list>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<iomanip>
#include<sstream>
#include<regex>
#include<random>
using namespace std;
#define int long long
#define uint unsigned long long
const int mod=1e9+7;
const int Mod=998244353;
const int inf=mod*mod;
const double eps=1e-9;
int dp[200][200];
signed main(){
	int d,n,t[200],a[200],b[200],c[200];
	cin>>d>>n;
	for(int i=0;i<d;i++)
		cin>>t[i];
	for(int i=0;i<n;i++)
		cin>>a[i]>>b[i]>>c[i];
	for(int i=0;i<d;i++)
		for(int j=0;j<n;j++)
			dp[i][j]=-1;
	for(int i=0;i<n;i++)
		if(a[i]<=t[0]&&t[0]<=b[i])
			dp[0][i]=0;
	for(int i=1;i<d;i++)
		for(int j=0;j<n;j++)
			for(int k=0;k<n;k++)
				if(dp[i-1][k]>=0&&a[j]<=t[i]&&t[i]<=b[j])
					dp[i][j]=max(dp[i][j],dp[i-1][k]+abs(c[j]-c[k]));
	int ans=0;
	for(int i=0;i<n;i++)
		ans=max(ans,dp[d-1][i]);
	cout<<ans<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3672
final_rank: 14

code_snippet: #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using pii = pair<int, int>;

void chmax(int &a, int b) { if (a < b) a = b; }
void chmin(int &a, int b) { if (a > b) a = b; }

int dp[205][205];

int main() {
  int D, N;
  cin >> D >> N;
  vector<int> T(D), A(N), B(N), C(N);
  rep(i, D) cin >> T[i];
  rep(i, N) cin >> A[i] >> B[i] >> C[i];

  rep(i, D) rep(j, N) rep(k, N) {
    if (i == 0) continue;
    if (T[i] < A[j] || B[j] < T[i]) continue;
    if (T[i - 1] < A[k] || B[k] < T[i - 1]) continue;
    chmax(dp[i + 1][j], dp[i][k] + abs(C[j] - C[k]));
  }

  int ans = 0;
  rep(i, N) chmax(ans, dp[D][i]);
  cout << ans << endl;
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3604
final_rank: 13

code_snippet: #include <iostream>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <algorithm>
#include <utility>
#define INF 1000000100
using namespace std;

void dijkstra(set<long> * v, map<pair<long, long>,long> * mp, long N, long total,vector<long>* retval);

class Cloth {
private:
long a;
long b;
long c;
public:
Cloth(long a, long b, long c);
bool is_wearable(long T);
long distance(Cloth * cloth);
};

Cloth::Cloth(long _a, long _b, long _c){
        a=_a;
        b=_b;
        c=_c;
}

bool Cloth::is_wearable(long T){
        if(a<=T and T<=b) {
                return true;
        }
        else{
                return false;
        }
}

long Cloth::distance(Cloth* cloth){
        return abs(c-cloth->c);
}

int main(void){
        long D,N;
        cin>>D>>N;
        vector<long> temperatures;
        vector<Cloth> clothes;
        for(long i=0; i<D; i++) {
                long temp;
                cin>>temp;
                temperatures.push_back(temp);
        }
        for(long i=0; i<N; i++) {
                long a,b,c;
                cin>>a>>b>>c;
                Cloth C = Cloth(a,b,c);
                clothes.push_back(C);
        }
        set<long>* v = new set<long> [D*N];
        map<pair<long,long>, long> mp;
        for(long i=0; i<D*N; i++) {
                v[i].clear();
        }


        for(long i=0; i<D-1; i++) {
                for(long j=0; j<N; j++) {
                        if(!(clothes[j].is_wearable(temperatures[i]))) {
                                continue;
                        }
                        for(long k=0; k<N; k++) {
                                if(!(clothes[k].is_wearable(temperatures[i+1]))) {
                                        continue;
                                }
                                v[i*N+j].insert((i+1)*N+k);

                                mp[make_pair(i*N+j,(i+1)*N+k)] = clothes[j].distance(&(clothes[k]));
                        }
                }
        }
        vector<long> retval;
        dijkstra(v, &mp, N, N*D, &retval);
        long ans=0;
        for(long i=0; i<N; i++) {
                ans = max(ans, retval[N*D-i-1]);
        }

        cout<<ans<<endl;
        return 0;
}

void dijkstra(set<long> * v, map<pair<long, long>,long> * mp, long N, long total,vector<long>* retval){
        retval->clear();
        for(long i=0; i<total; i++) {
                retval->push_back(-1*INF);
        }
        for(long i=0; i<N; i++) {
                (*retval)[i]=0;
        }
        set<long> updated, next;
        updated.clear();
        for(int i=0; i<N; i++) {
                updated.insert(i);
        }
        while(!updated.empty()) {
                next.clear();
                for(auto iter=updated.begin(); iter!=updated.end(); iter++) {
                        for(auto iter2=v[*iter].begin(); iter2!=v[*iter].end(); iter2++) {
                                long weight=(*mp)[make_pair(*iter,*iter2)];
                                if((*retval)[*iter2]<(*retval)[*iter]+weight) {
                                        (*retval)[*iter2]=(*retval)[*iter]+weight;
                                        next.insert(*iter2);
                                }
                        }
                }
                updated.swap(next);
        }
}
accuracy: 1
time_ms: 410
memory_kb: 109344
final_rank: 20

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;

#define rep(i,n) for (int i = 0; i < (n); ++i)
#define repe(i,n) for (int i = 0; i <= (n); ++i)
#define reps(i,s,n) for (int i = (s); i < (n); ++i)
#define vi vector<ll>
#define len(x) (int)(x).size()


template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }

ll inf = (1 << 30);
int MOD = 1'000'000'007;

static const int NIL = -1;
static const ll NMAX = 1'000'000 + 5;

ll n;

ll dod[NMAX];






int main(void) {


	int d, n;//日数　服の種類
	cin >> d >> n;

	vi tp(d), l(n), h(n), ds(n);

	rep(i, d) cin >> tp[i];
	rep(j, n) cin >> l[j] >> h[j] >> ds[j];

	vector<vector<ll>> dp(d, vector<ll>(n, -1));


	rep(j, n) {

		if (l[j] <= tp[0] && tp[0] <= h[j]) dp[0][j] =0;
	}

	ll ans = 0;
	reps(i, 1, d) {
		rep(j, n) {
			rep(k, n) {

				if (l[k] <= tp[i] && tp[i] <= h[k] && dp[i - 1][j] != -1) {

					ll scr = abs(ds[j] - ds[k]);
					chmax(dp[i][k], dp[i - 1][j] + scr);
				}
			}
		}
	}

	rep(i, n) chmax(ans, dp[d - 1][i]);

	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3276
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;
 
int main() {
  int D,N;
  cin >> D >> N;
  
  vector<int> T(D);
  for (int i = 0; i < D; i++) cin >> T.at(i);
  
  vector<vector<int>> ABC(N, vector<int>(3));
  for (int i = 0; i < N; i++) cin >> ABC.at(i).at(0)
                                   >> ABC.at(i).at(1)
                                   >> ABC.at(i).at(2);
  
  vector<vector<vector<int>>> dp( D , 
          vector<vector<int>>   ( N ,
                  vector<int>   ( N, -1)));
  
  for (int i = 0; i < N; i++) {
    if (ABC.at(i).at(0) <= T.at(0) && T.at(0) <= ABC.at(i).at(1)) {
      for (int j = 0; j < N; j++) {
        dp.at(0).at(i).at(j) = 0;
      }
    }
  }

  for (int i = 1; i < D; i++) {
    for (int j = 0; j < N; j++) {
      
      if (ABC.at(j).at(0) <= T.at(i) && T.at(i) <= ABC.at(j).at(1)) {

        for (int k = 0; k < N; k++) {
          dp.at(i).at(j).at(k) = 0;
        
          for (int l = 0; l < N; l++) {
            if (dp.at(i-1).at(k).at(l) == -1) continue;
            dp.at(i).at(j).at(k) = max(dp.at(i).at(j).at(k),
                                       dp.at(i-1).at(k).at(l) + abs(ABC.at(k).at(2) - ABC.at(j).at(2)));
          }
        }
        
      }
      
    }
  }
  
  int ans = 0;
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      ans = max(ans, dp.at(D-1).at(i).at(j));
    }
  }
  
  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 570
memory_kb: 35908
final_rank: 18

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vb=vector<bool>;
using vvb=vector<vb>;
using vd=vector<double>;
using vvd=vector<vd>;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using pll=pair<ll,ll>;
using tll=tuple<ll,ll>;
using vs=vector<string>;
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define rep(i,n) range(i,0,n)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define range(i,a,n) for(int i=(a);i<(n);i++)

#define LINF    	((ll)1ll<<60)
#define INF     	((int)1<<30)
#define EPS     	(1e-9)
#define MOD     	(1000000007ll)
#define fcout(a)	cout<<setprecision(a)<<fixed
#define fs 			first
#define sc			second
#define PI			3.1415926535897932384

int dx[]={1,0,-1,0,1,-1,-1,1},dy[]={0,1,0,-1,1,1,-1,-1};
template<class S,class T>ostream&operator<<(ostream&os,pair<S,T>p){os<<"["<<p.first<<", "<<p.second<<"]";return os;};
template<class S>auto&operator<<(ostream&os,vector<S>t){bool a=1; for(auto s:t){os<<(a?"":" ")<<s; a=0;} return os;}
void OUT(bool b){cout<<(b?"YES":"NO")<<endl;}
void Out(bool b){cout<<(b?"Yes":"No")<<endl;}
void out(bool b){cout<<(b?"yes":"no")<<endl;}
int popcnt(int x) { return __builtin_popcount(x); }
int popcnt(ll x) { return __builtin_popcountll(x); }
int clz(int x) { return 31 - __builtin_clz(x); }
int clz(ll x) { return 63 - __builtin_clzll(x); }
int ctz(int x) { return __builtin_ctz(x); }
int ctz(ll x) { return __builtin_ctzll(x); }

class compare {
public:
	bool operator()(tuple<ll, ll> a, tuple<ll, ll> b) {
		return (get<1>(a) > get<1>(b));
	}
};

int dp[201][201];

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	ll n,d;
	//dp[last][day]
	cin>>d>>n;
	vi t(d),a(n),b(n),c(n);
	rep(i,d)cin>>t[i];
	rep(i,n)cin>>a[i]>>b[i]>>c[i];
	rep(i,201){
		rep(j,201){
			dp[j][i]=-1;
		}
	}
	rep(i,d){
		rep(j,n){
			rep(k,n){
				if(a[k]<=t[i]&&t[i]<=b[k]){
					dp[k][i+1]=max(dp[k][i+1],dp[j][i]+((dp[j][i]!=-1)?abs(c[j]-c[k]):1));
				}
			}
		}
	}
	int ans=0;
	rep(i,n){
		ans=max(ans,dp[i][d]);
	}
	cout<<ans<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3364
final_rank: 9

code_snippet: #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <limits>
#include <fstream>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, -1, sizeof(mat))
typedef long long ll;
int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);
  int D,N;cin>>D>>N;
  int T[D];FOR(i,0,D)cin>>T[i];
  int A[N],B[N],C[N];
  FOR(i,0,N)cin>>A[i]>>B[i]>>C[i];
  ll dp[D][N];
  CLR(dp);
  FOR(i,0,N){
    if(T[0]>=A[i]&&T[0]<=B[i]){
      dp[0][i]=0;
    }
  }
  ll ans=0;
  FOR(i,0,D-1){
    FOR(j,0,N){
      if(dp[i][j]==-1)continue;
      // i+1日目にkをきる
      FOR(k,0,N){
        if(T[i+1]>=A[k]&&T[i+1]<=B[k]){
          dp[i+1][k]=max(dp[i+1][k],dp[i][j]+abs(C[j]-C[k]));
          ans=max(ans,dp[i+1][k]);
        }
      }
    }
  }
  cout<<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3400
final_rank: 11

code_snippet: #include "bits/stdc++.h"

using namespace std;

int main(void){
	int dp[210][210],a[210],b[210],c[210],t[210],d,n,i,j,k,ans=0;
	fill(dp[0],dp[210],0);
	cin >> d >> n;
	for(i=0; i<d; i++){
		cin >> t[i];
	}
	for(j=0; j<n; j++){
		cin >> a[j] >> b[j] >> c[j];
	}
	for(k=1; k<d; k++){

		for(i=0; i<n; i++){
			if(a[i]<=t[k] && b[i]>=t[k]){

				for(j=0; j<n; j++){
					if(a[j]<=t[k-1] && b[j]>=t[k-1]){
						dp[k][i] = max(dp[k][i],dp[k-1][j]+abs(c[i]-c[j]));
					}
				}

			}
		}

	}
	for(i=0; i<n; i++){
		ans = max(ans,dp[d-1][i]);
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3264
final_rank: 6

code_snippet: //============================================================================
// Name        : JOI.cpp
// Author      : Akari Fujii
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <cctype>
#include <string>
#include<algorithm>

using namespace std;


// 1. dp?????????
int dp[201][201];
// 2. n????????????
int d,n;
int a[201],b[201],c[201],t[201];
// ???. calc????????????
int calc(int k,int m){

	// 8. dp???????????°??????
	if(dp[k][m]>=0)return dp[k][m];
	if(t[m]<a[k]||t[m]>b[k])return -1;
	for(int i=1; i<n+1; ++i){
		if(calc(i,m-1)>=0)dp[k][m]=max(dp[k][m],abs(c[k]-c[i])+calc(i,m-1));
	}
	return dp[k][m];

}

int main() {

	cin>>d>>n;

	// 3. ?????????
	for(int i=0;i<201;++i){
		for(int j=0;j<201;++j){
			dp[i][j]=-1;
		}
	}
	// 4.??\???
	for(int i=1; i<d+1; ++i)cin>>t[i];
	for(int j=1; j<n+1; ++j)cin>>a[j]>>b[j]>>c[j];

	// 5. ???????????¨??????

	for(int j=1; j<n+1; ++j){
		if(t[1]>=a[j]&&t[1]<=b[j]){
			dp[j][1]=0;
		}
	}

	// 6. ??????

	int total=0;
	for(int i=1;i<n+1;++i){
		total=max(total,calc(i,d));
	}
	cout<<total<<endl;
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3264
final_rank: 16

code_snippet: //============================================================================
// Name        : JOI.cpp
// Author      :
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

// 1. dp?????????
int dp[201][201];
// 2. n?????????
int D,N;
int T[201];
int A[205],B[205],C[205];

// 7. calc?????????
int calc(int k,int m){
	// 8. dp???????????°??????
	if(dp[k][m]>=0)return dp[k][m];
	if(T[m]<A[k] || T[m]>B[k])return -1;
	// 9. dp????¨????
	for(int i=0;i<N;i++){
		int P=calc(i,m-1);
		if(P>=0)dp[k][m]=max(dp[k][m],abs(C[k]-C[i])+dp[i][m-1]);
	}


	return dp[k][m];
}
int main() {
	cin>>D>>N;

	//3.?????????
	for(int i=0;i<201;i++){
		for(int j=0;j<201;j++){
			dp[i][j]=-1;
		}
	}
	//4.??\???
	for(int i=1;i<D+1;i++){
		cin>>T[i];
	}
	for(int i=0;i<N;i++){
		cin>>A[i]>>B[i]>>C[i];
	}



	//5.???????????¨???
	for(int i=0;i<N;i++){
		if(T[1]>=A[i] && T[1]<=B[i])dp[i][1]=0;
	}


	//6.??????
	int total=0;
	for(int i=0;i<N;i++){
		total=max(total,calc(i,D));
	}

	cout<<total<<endl;



	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3200
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;

#define llong long long 
typedef struct data{
	int low;
	int high;
	int eva;
}data;
int D, N;
int temp[201];
data kind[200];
int score[201][200][200];

int solve(int d, int k, int yk){
	if(score[d][k][yk] != -1) return score[d][k][yk];
	if(d == D) return score[d][k][yk] = fabs(kind[k].eva - kind[yk].eva);

	int e = 0;
	for(int i = 0; i < N; i++){
		data use = kind[i];
		if(use.low > temp[d + 1] || use.high < temp[d + 1]) continue;
		int sum;
		if(d > 1)sum = fabs(kind[k].eva - kind[yk].eva) + solve(d + 1, i, k);
		else sum = solve(d + 1, i, k);
		e = max(e, sum);
	}

	return score[d][k][yk] = e;
}

int main(){
	fill_n(temp, 201, -1);
	fill_n(**score, 201 * 200 * 200, -1);
	cin >> D >> N;
	for(int i = 1; i <= D; i++){
		cin >> temp[i];
	}
	for(int i = 0; i < N; i++){
		cin >> kind[i].low >> kind[i].high >> kind[i].eva;
	}

	cout << solve(0, 0, 0) << endl;
	return 0;
}
accuracy: 1
time_ms: 360
memory_kb: 34508
final_rank: 17

code_snippet: #include<bits/stdc++.h>
using namespace std;
int dp[810][810];
int main(void)
{
	int d,n,i,j,k,sel[810],a[810],b[810],c[810],data,mx=-1;
	cin>>d>>n;
	for(i=1;i<=d;i++) cin>>sel[i];
	for(i=1;i<=n;i++) cin>>a[i]>>b[i]>>c[i];
	for(i=1;i<=d;i++) for(j=1;j<n;j++) dp[i][j]=0;
	for(i=1;i<=d;i++) {
		for(j=1;j<=n;j++) {
			if(a[j]<=sel[i]&&sel[i]<=b[j]) {
				for(k=1;k<=n;k++) {
					if(a[k]<=sel[i+1]&&sel[i+1]<=b[k]) {
						data=abs(c[j]-c[k]);
					}
					dp[i+1][k]=max(dp[i][j]+data,dp[i+1][k]) ;
				}
			}
		}
	}
	for(i=1;i<=n;i++) mx=max(mx,dp[d][i]);
	cout<<mx<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3736
final_rank: 15

code_snippet: #include <bits/stdc++.h>

using namespace std;

int D,N;
int temp[201];
int cloth[201][3];
int a[201][201][201];


int dp(int d,int yk,int k){
	if(d > 0){
		if(!(cloth[k][0] <= temp[d] && cloth[k][1] >= temp[d]))return 0;
	}

	if(a[d][yk][k] >= 0) return a[d][yk][k];

	if(d == D){
		return a[d][yk][k] = fabs(cloth[yk][2] - cloth[k][2]) ;
	}

	int eva = 0;
	int sum = 0;
	for(int i = 1; i <= N ;i++){
		if(d < 2){
			sum = dp(d+1, k, i);
			eva = max(eva,sum);
		}else{
			sum = dp(d +1, k, i) + fabs(cloth[yk][2] - cloth[k][2]);
			// cout <<d <<" "<< yk << " "<<k <<" "<< sum << endl;
			eva = max(eva,sum);
		}
	}

	return a[d][yk][k] = eva;


	// long long int eva = 0;
	// long long int sum = 0;
	// if(d >= 2){

	// 	eva = fabs(yeva - cloth[k][2]);
	// }

	// if(d == D){
	// 	// cout<<d<<" "<<k<<" "<<eva<<endl;
	// 	return a[d][k] = eva;
	// }


	// for(int i = 1;i <= N;i++){
	// 	if(d == 0){
	// 		eva = max(eva, dp(d+1, i, 0));
	// 	}else if( d == 1){
	// 		// cout<<sum<< " "<<eva<<endl;
	// 		// cout<<eva<<" "<<dp(d+1,i,cloth[k][2])<<endl;
	// 		eva = max(eva,dp(d+1, i, cloth[k][2]));
	// 	}else{
	// 		sum = dp(d+1,i,cloth[k][2]) + eva;
	// 		cout<<d<<" "<<dp(d+1,i,cloth[k][2])<<" "<<eva <<" "<<sum<<endl;
	// 		// cout<<eva<<" "<<dp(d+1,i,cloth[k][2])<<endl;
	// 		eva = max(eva,sum);
	// 	}
	// }
	// // cout << d <<" " <<k<<" " << eva <<endl; 
	// return a[d][k] = eva;
}


int main(){
	fill_n(temp,201,-1);
	fill_n(*cloth,201*3,-1);
	fill_n(**a,201*201*201,-1);
	cin >> D >> N;
	for(int i = 1;i <= D;i++){
		cin >>temp[i];
	}
	for(int i = 1;i <= N;i++){
		for(int j = 0;j < 3;j++){
			cin >> cloth[i][j];
		}
	}
	cout << dp(0,0,0) << endl;
}
accuracy: 1
time_ms: 770
memory_kb: 34808
final_rank: 19

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <string>
#include <cstdio>
#define INF 100000000

using namespace std;
int dp[205][205] = { 0 }, t[205], a[205], b[205], c[205];
int main(){
	int d, n;
	cin >> d >> n;
	for (int i = 1; i <= d; i++) {
		cin >> t[i];
	}
	for (int j = 1; j <= n; j++) {
		cin >> a[j] >> b[j] >> c[j];
	}
	for (int i = 0; i < 201; i++) {
		for (int j = 0; j < 201; j++) {
			dp[i][j] = -1;
		}
	}
	for (int i = 1; i <= n; i++) {
		if (a[i] <= t[1] && t[1] <= b[i]) dp[1][i] = 0;
	}
	for (int i = 2; i <= d; i++) {
		for (int k = 1; k <= n; k++) {
			for (int j = 1; j <= n; j++) {
				if (a[j] <= t[i] && t[i] <= b[j]&&a[k]<=t[i-1]&&t[i-1]<=b[k]) {
					dp[i][j] = max(dp[i][j], dp[i - 1][k] + abs(c[k] - c[j]));
				}
			}
		}
	}
	int ans = -1;
	for (int i = 1; i <= n; i++) {
		if (ans < dp[d][i]) ans = dp[d][i];
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3264
final_rank: 6

code_snippet: #include <iostream>
#include <cstring>
#include <algorithm>
#include <math.h>
#define MOD 1000000007
using namespace std;

int main()
{
	int d, n,ans;
	int t[202],a[202],b[202],c[202];
	int dp[202][202] = {};
	cin >> d >> n;
	int i,j,k;
	for (i = 0; i < d; i++){
		cin >> t[i];
	}
	for (i = 0; i < n; i++){
		cin >> a[i] >> b[i] >> c[i];
	}
	for (i = 0; i < d - 1; i++){
		for (j = 0; j < n; j++){
			for (k = 0; k < n; k++){
				if (a[k] <= t[i] && b[k] >= t[i] && a[j] <= t[i + 1] && b[j] >= t[i + 1] && dp[i + 1][j] <= dp[i][k] + abs(c[k] - c[j])){
					dp[i + 1][j] = dp[i][k] + abs(c[k] - c[j]);
				}
			}
		}
	}
	ans = 0;
	for (i = 0; i < n; i++){
		ans = max(ans, dp[d - 1][i]);
	}
	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3260
final_rank: 5

code_snippet: #include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,int> plli;
typedef pair<int,pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;

#define int long long
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>=0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()

const ll mod = 1e9 + 7;
const ll INF = 1<<30;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const double pi = 3.141592653589793;

int d,n;
int t[205];
vector<pair<int ,pair<int,int>>> cab;
vector<vector<int>> cl(65);
int dp[205][205];

signed main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin  >> d >> n;
    rep(i,d) cin >> t[i];
    rep(i,n){
        int a,b,c;
        cin >> a >> b >> c;
        cab.pb(make_pair(c,make_pair(a,b)));
    }
    rep(i,d)rep(j,n){
        int l=cab[j].se.fi;
        int r=cab[j].se.se;
        if (l<=t[i] && t[i]<=r) cl[t[i]].pb(j);
    }
    rep(i,d+1)rep(j,n) dp[i][j]=-INT_MAX;
    for (auto i: cl[t[0]]){
        for (auto j: cl[t[1]]){
            dp[2][j]=max(dp[2][j],abs(cab[i].fi-cab[j].fi));
        }
    }
    rep2(i,2,d)rep(j,n){
        for (auto k: cl[t[i]]){
            dp[i+1][k]=max(dp[i+1][k],dp[i][j]+abs(cab[j].fi-cab[k].fi));
        }
    }
    int ans=0;
    rep(j,n) ans=max(ans,dp[d][j]);
    cout << ans << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3576
final_rank: 12

code_snippet: #include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <functional>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <deque>
#include <ctime>

using namespace std;

#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define pb push_back
#define mp make_pair
#define all(r) (r).begin(),(r).end()
#define rall(r) (r).rbegin(),(r).rend()
#define fi first
#define se second

typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int INF = 1e9;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
double EPS = 1e-8;
const double PI = acos(-1);

int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
int d,n;
int t[210];
int a[210],b[210],c[210];
int dp[210][210];

int main(){
	cin >> d >> n;
	for(int i=0; i<d; i++){
		cin >> t[i];
	}
	for(int i=0; i<n; i++){
		cin >> a[i] >> b[i] >> c[i];
	}

	for(int i=0; i<d; i++){
		for(int j=0; j<n; j++){
			if(a[j] <= t[i] && t[i] <= b[j]){
				dp[i][j] = 0;
			}
			else{
				dp[i][j] = -INF;
			}
		}
	}
	//????????????????????§?????????????????\???????????¨??§?????????????????¨?????¨????????????


	for(int i=d-2; i >= 0; i--){
		for(int j=0; j < n; j++){
			for(int k=0; k < n;  k++){
				if(dp[i][j] >= 0){
					dp[i][j] = max(dp[i][j],
					dp[i+1][k] + abs(c[j] - c[k]));
				}
			}
		}
	}

	int max = 0;

	for(int i=0; i < n; i++){
		if(dp[0][i] > max){
			max = dp[0][i];
		}
	}

	cout << max << endl;

}
accuracy: 1
time_ms: 10
memory_kb: 3232
final_rank: 4

code_snippet: #include <iostream>
#include <algorithm>
#include <climits>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

#define INF 1145141919

int D, N;
int dp[210][210];
int T[210];
int A[210], B[210], C[210];

int main() {
  cin >> D >> N;
  for (int i=0; i<D; i++) cin >> T[i];
  for (int i=0; i<N; i++) cin >> A[i] >> B[i] >> C[i];

  for (int i=0; i<D; i++) {
    for (int j=0; j<N; j++) {
      dp[i][j] = -INF;
    }
  }
  for (int i=0; i<N; i++) {
    if (T[0] >= A[i] && T[0] <= B[i]) dp[0][i] = 0;
  }
  for (int i=0; i<D; i++) {
    for (int j=0; j<N; j++) {
      for (int k=0; k<N; k++) {
        if (T[i+1] >= A[k] && T[i+1] <= B[k]) {
          dp[i+1][k] = max(dp[i+1][k], dp[i][j] + abs(C[j] - C[k]));
        }
      }
    }
  }
  int ans = 0;
  for (int i=0; i<N; i++) {
    ans = max(ans, dp[D-1][i]);
  }
  cout << ans << "\n";
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3212
final_rank: 3

code_snippet: #include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;

const int INF = -100000000;

int main(){
  int d,n,a[200],b[200],c[200],t[200];
  scanf("%d %d",&d,&n);
  for(int i=0;i<d;i++) scanf("%d",t+i);
  for(int i=0;i<n;i++) scanf("%d %d %d",a+i,b+i,c+i);
  int dp[200][200];
  fill(dp[0],dp[0]+200,INF);
  for(int i=0;i<d;i++){
    for(int j=0;j<n;j++){
      if(i==0){
        if(a[j]<=t[i]&&t[i]<=b[j]){
          dp[i][j] = 0;
        }
        continue;
      }
      dp[i][j] = 0;
      for(int k=0;k<n;k++){
        if(a[j]<=t[i]&&t[i]<=b[j]){
          dp[i][j] = max(dp[i][j],dp[i-1][k]+max(c[j],c[k])-min(c[j],c[k]));
        }
      }
    }
  }
  int ans = 0;
  for(int i=0;i<n;i++) ans = max(ans,dp[d-1][i]);
  printf("%d\n",ans);
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 2908
final_rank: 1