Problem:
D: 日焼け - Suntan -
物語
あいずにゃんは若ヶ松高校のプログラミングコンテスト部、通称ぷろこん部に所属する2年生である。天使のようにかわいい。
あいずにゃんは今年の夏フェスに参加する予定なので、聴きに行くバンドのスケジュールを立てた。
ここで心配なのが日焼けだ。
ライブはすべて野外で行われるが、あいずにゃんは日焼けしやすい体質なので長時間野外で紫外線を浴びすぎるとすぐ日焼けしてしまう。
ライブがない間は屋内に避難することでできるだけ紫外線を回避するつもりだが、ライブ中はどうしても日に当たってしまう。
そこであいずにゃんは日焼け止めを塗ることで紫外線対策をすることを考えた。
問題
日焼け止めを塗ると、塗った時間から
T
分間だけその効果を得ることができる。
日焼け止めは1回しか塗ることができないため、効果的に使いたい。
あいずにゃんは、ライブの開始時刻から終了時刻までは野外にいて、それ以外では屋内にいる。
あいずにゃんが聴く予定のライブスケジュールが与えられるので、野外にいる間で日焼け止めの効果を得られる最大の時間の長さを求めよ。
入力形式
入力は次の形式で与えらえる。
T
N
s_1
t_1
...
s_N
t_N
1行目では日焼け止めの効果を得られる時間を表す整数
T
が与えられる。
2行目ではあいずにゃんが聴くライブの数を表す整数
N
が与えられる。
続く
N
行には、あいずにゃんが
i
番目に聴くライブの開始時刻を表す整数
s_i
と終了時刻を表す整数
t_i
が空白区切りで与えられる。
制約
1 ≤ T ≤ 10^{15}
1 ≤ N ≤ 10^5
0 ≤ s_i < t_i ≤ 10^{15}
(
1 ≤ i ≤ N
)
(i+1)
番目のライブの開始時刻は
i
番目のライブの終了時刻と同じかそれよりも遅い。すなわち、
t_i ≤ s_{i+1}
(
1 ≤ i < N
)
出力
野外にいる間で日焼け止めの効果を得られる最大の時間の長さを1行で出力せよ。
入力例1
20
1
0 10
出力例1
10
入力例2
20
1
0 100
出力例2
20
入力例3
9
3
1 5
9 11
13 20
出力例3
7
入力例4
25
5
9 12
15 20
21 25
28 40
45 60
出力例4
21

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
#define rep(i,s,n) for (int i = (int)(s); i < (int)(n); i++)
#define all(v) begin(v),end(v)
using namespace std;
using ll = long long;

bool chmin(auto &a, auto b){ return a > b ? a = b, 1 : 0; }
bool chmax(auto &a, auto b){ return a < b ? a = b, 1 : 0; }

bool ispali(int n){
    string s = to_string(n);
    string t = s;
    reverse(all(t));
    return s == t;
}

const int iinf = 1e9;

void solve(){
    ll t; cin >> t;
    int n; cin >> n;
    vector<ll> a;
    rep(i,0,n){
        ll l, r; cin >> l >> r;
        a.push_back(l);
        a.push_back(r);
    }
    vector<ll> rui(n*2+1);
    rep(i,0,n*2){
        rui[i+1] = rui[i] + (i % 2 == 0 ? 0 : a[i] - a[i-1]);
    }
    rui.erase(rui.begin());
    rui.push_back(rui.back());
    ll ans = 0;
    rep(i,0,n*2){
        ll le = a[i];
        ll ri = le + t;
        int id = lower_bound(all(a),ri) - a.begin();
        if (id % 2 == 0){
            chmax(ans,rui[id]-rui[i]);
        }
        else {
            chmax(ans,rui[id-1]-rui[i] +ri-a[id-1]);
        }
    }
    cout << ans << endl;
}

int main(){
    solve();
}
accuracy: 1
time_ms: 50
memory_kb: 7120
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
	ll t;cin>>t;
	ll n;cin>>n;
	vector<ll>s(n),tt(n);
	vector<ll>v;
	for (int i=0;i<n;i++){
		cin>>s[i]>>tt[i];
		v.push_back(s[i]);
		v.push_back(tt[i]);
	}
	
	v.push_back((ll)1e17);
	
	vector<ll> tar(2*n+1);
	for (int i=0;i<n;i++) {
		if(i>0)tar[2*i]=tar[2*i-1]+tt[i-1]-s[i-1];
		tar[2*i+1]=tar[2*i];
	}
	tar[2*n]=tar[2*n-1]+tt[n-1]-s[n-1];
	
	ll ans=0;
	for(int i=0;i<n;i++) {
		int idx=int(upper_bound(v.begin(),v.end(),s[i]+t)-v.begin());
		//cout<<idx<<endl;
		if (idx%2==0){
			//ending
			ans=max(ans,tar[idx]-tar[2*i]);	
			//cout<<tar[idx]-tar[2*i]<<endl;
		}else{
			//starting
			ans=max(ans,tar[idx]+s[i]+t-s[idx/2]-tar[2*i]);
			//cout<<tar[idx]+s[i]+t-s[idx/2]-tar[2*i]<<endl;
		}
	}
	cout<<ans<<endl;
	
	
}
accuracy: 1
time_ms: 60
memory_kb: 7812
final_rank: 15

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

void fileIO(void) {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
}

void fastIO(void) { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); }
# define int long long

vector<int> s;
vector<int> e;
vector<int> val;
int calc(int low, int high){
    int ans = 0;

    int low_st  = lower_bound(s.begin(), s.end(), low) - s.begin();
    int low_en  = lower_bound(e.begin(), e.end(), low) - e.begin();

    int high_st = lower_bound(s.begin(), s.end(), high) - s.begin();
    int high_en = lower_bound(e.begin(), e.end(), high) - e.begin();

    int l, r;

    if(low_st > low_en && low < e[low_en] /*handle edge*/ ) {
        l = low_st - 1;
        ans = s[l] - low;
    }
    else l = low_st;

    if(high_st > high_en && high <= e[high_en] ) {
        r = high_en;
        ans += high - e[r];
    }
    else r = high_en-1;

    ans += val[r+1] - val[l];

    return ans;
}

signed main(){
    fastIO();

    int t, n;
    cin >> t >> n;
    val.push_back(0);
    for (int i = 0; i < n; ++i) {
        int l, r;
        cin >> l >> r;
        l++, r++;
        s.push_back(l);
        e.push_back(r);
        val.push_back(r-l + val.back());
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans = max(ans, calc(s[i], s[i]+t));
        ans = max(ans, calc(e[i], e[i]+t));
        ans = max(ans, calc(s[i]-t, s[i] ));
        ans = max(ans, calc(e[i]-t, e[i]));
    }
    cout << ans << endl;


}
accuracy: 1
time_ms: 50
memory_kb: 5712
final_rank: 7

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

void fileIO(void) {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
}

void fastIO(void) { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); }
# define int long long

vector<int> s;
vector<int> e;
vector<int> val;
int calc(int low, int high){
    int ans = 0;

    if(low < 1)
        low = 1;

    int low_st  = lower_bound(s.begin(), s.end(), low) - s.begin();
    int low_en  = lower_bound(e.begin(), e.end(), low) - e.begin();

    int high_st = lower_bound(s.begin(), s.end(), high) - s.begin();
    int high_en = lower_bound(e.begin(), e.end(), high) - e.begin();

    int l, r;

    if(low_st > low_en && low < e[low_en] /*handle edge*/ ) {
        l = low_st - 1;
        ans = s[l] - low;
    }
    else l = low_st;

    if(high_st > high_en && high <= e[high_en] ) {
        r = high_en;
        ans += high - e[r];
    }   
    else r = high_en-1;

    ans += val[r+1] - val[l];

    return ans;
}

signed main(){
    fastIO();

    int t, n;
    cin >> t >> n;
    val.push_back(0);
    for (int i = 0; i < n; ++i) {
        int l, r;
        cin >> l >> r;
        l++, r++;
        s.push_back(l);
        e.push_back(r);
        val.push_back(r-l + val.back());
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans = max(ans, calc(s[i], s[i]+t));
        ans = max(ans, calc(e[i], e[i]+t));
        ans = max(ans, calc(s[i]-t, s[i] ));
        ans = max(ans, calc(e[i]-t, e[i]));

    }
    cout << ans << endl;


}
accuracy: 1
time_ms: 50
memory_kb: 5664
final_rank: 5

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

void fileIO(void) {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
}

void fastIO(void) { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); }
# define int long long

vector<int> s;
vector<int> e;
vector<int> val;
int calc(int low, int high){
    int ans = 0;

    if(low < 1)
        low = 1;
    if(high < 1)
        high = 1;

    int low_st  = lower_bound(s.begin(), s.end(), low) - s.begin();
    int low_en  = lower_bound(e.begin(), e.end(), low) - e.begin();

    int high_st = lower_bound(s.begin(), s.end(), high) - s.begin();
    int high_en = lower_bound(e.begin(), e.end(), high) - e.begin();

    int l, r;

    if(low_st > low_en && low < e[low_en] /*handle edge*/ ) {
        l = low_st - 1;
        ans = s[l] - low;
    }
    else l = low_st;

    if(high_st > high_en && high <= e[high_en] ) {
        r = high_en;
        ans += high - e[r];
    }
    else r = high_en-1;

    ans += val[r+1] - val[l];

    return ans;
}

signed main(){
    fastIO();

    int t, n;
    cin >> t >> n;
    val.push_back(0);
    for (int i = 0; i < n; ++i) {
        int l, r;
        cin >> l >> r;
        l++, r++;
        s.push_back(l);
        e.push_back(r);
        val.push_back(r-l + val.back());
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans = max(ans, calc(s[i], s[i]+t));
        ans = max(ans, calc(e[i], e[i]+t));
        ans = max(ans, calc(s[i], s[i]-t));
        ans = max(ans, calc(e[i], e[i]-t));

    }
    cout << ans << endl;


}
accuracy: 1
time_ms: 50
memory_kb: 5664
final_rank: 5

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;

long long N, T;
long long A[1 << 18];
long long B[1 << 18];
long long C[1 << 18];

int main() {
	// Step 1. Input
	cin >> T >> N;
	for (int i = 1; i <= N; i++) cin >> A[i] >> B[i];
	for (int i = 1; i <= N; i++) C[i] = B[i] - A[i];
	for (int i = 1; i <= N; i++) C[i] += C[i - 1];

	// Step 2. Brute Force
	long long Answer = 0;
	for (int i = 1; i <= N; i++) {
		int pos1 = lower_bound(A + 1, A + N + 1, A[i] + T) - A;
		pos1 -= 1;
		long long tm1 = C[pos1 - 1] - C[i - 1];
		long long tm2 = max(0LL, min(A[i] + T, B[pos1]) - A[pos1]);
		Answer = max(Answer, tm1 + tm2);
	}
	cout << Answer << endl;
	return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 8296
final_rank: 17

code_snippet: #include <iostream>
#include <map>
using namespace std;

map<long long int,long long int> ms;
map<long long int,int> top;
long long int sums[100003];

int main() {
	// your code goes here
	long long int s1=0,t1;
	int n1;
	cin>>t1;
	cin>>n1;
	for(int i=0;i<n1;i++){
		long long int s,e;
		cin>>s>>e;
		ms[s]=e;
		sums[i]=s1;
		top[s]=i;
		s1+=(e-s);
	}
	long long int ans=0;
	map<long long int,long long int>::iterator it1,it2;
	for(it1=ms.begin();it1!=ms.end();it1++){
		long long int s2,t2;
		t2=(*it1).first+t1;
		it2=ms.upper_bound(t2);
		if(it2!=ms.begin())it2--;
		long long int te,ts,anst;
		te=(*it2).second;
		ts=(*it2).first;
		anst=sums[top[ts]]-sums[top[(*it1).first]];
		te=(te>t2?t2:te);
		anst+=(te-ts);
		ans=ans>anst?ans:anst;
	}
	cout<<ans<<endl;
	return 0;
}
accuracy: 1
time_ms: 170
memory_kb: 16384
final_rank: 20

code_snippet: #include<stdio.h>
int main()
{
    int n,i;
    long long hi,s[100010],t[100010];
    
    scanf("%lld %d",&hi,&n);
    for(i=0;i<n;i++) scanf("%lld %lld",&s[i],&t[i]);
    
    int m=0;
    long long head=s[0],sum=0,ans=0;
    for(i=0;i<n;i++){
        sum += t[i]-s[i];
        while(t[i]-head > hi){
            if(s[m] <= t[i]-hi && t[i]-hi < t[m]){
                head = t[i]-hi;
                sum -= head-s[m];
            } else {
                sum -= t[m]-head;
                m++;
                head = s[m];
            }
        }
        if(ans < sum) ans = sum;
    }
    printf("%lld\n",ans);
    
    return(0);
}
accuracy: 1
time_ms: 20
memory_kb: 4260
final_rank: 1

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int n;
    long long hi,s[100010],t[100010];
    
    cin >> hi >> n;
    for(int i=0;i<n;i++) cin >> s[i] >> t[i];
    
    int m=0;
    long long head=s[0],sum=0,ans=0;
    for(int i=0;i<n;i++){
        sum += t[i]-s[i];
        while(t[i]-head > hi){
            if(s[m] <= t[i]-hi && t[i]-hi < t[m]){
                head = t[i]-hi;
                sum -= head-s[m];
            } else {
                sum -= t[m]-head;
                m++;
                head = s[m];
            }
        }
        ans = max(ans,sum);
    }
    cout << ans << endl;
    
    return(0);
}
accuracy: 1
time_ms: 70
memory_kb: 4664
final_rank: 8

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

// macro
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()

// code starts
int main()
{
  ll tl;cin>>tl;
  ll n;cin>>n;
  vector<ll> s(n);
  vector<ll> t(n);
  ll i;
  rep(i,n)cin>>s[i]>>t[i];
  vector<ll> sum(n+1,0);
  rep(i,n)
  {
    sum[i+1]=sum[i]+(t[i]-s[i]);
  }
  ll ans=0;
  map<ll,ll> m;
  rep(i,n)
  {
    m.insert({s[i],i});
    m.insert({t[i],i});
  }
  rep(i,n)
  {
    ll kans=0;
    ll kst=s[i];
    ll kend=kst+tl;
    auto it=m.lower_bound(kend);
    if(it==m.end())
    {
      ll low=max(i,(ll)0);
      kans=sum[n]-sum[low];
    }
    else
    {
      pair<ll,ll> p;
      p=*it;
      ll time,ind;
      time=p.first;
      ind=p.second;
      if(s[ind]==time)
      {
        kans=sum[ind]-sum[i];
      }
      else
      {
        kans=sum[ind]-sum[i];
        kans+=kend-s[ind];
      }
    }
    ans=max(ans,kans);
  }
  /*
  rep(i,n)
  {
    ll kans=0;
    ll kst=s[i];
    ll kend=s[i]+tl-1;
    ll inds=lower_bound(all(s),kend)-s.begin();
    ll indt=lower_bound(all(t),kend)-t.begin();
    inds--;
    indt--;
    if(s[inds]<=t[indt])
    {
      kans+=sum[indt+1]-sum[i];
    }
    else
    {
      kans+=sum[indt+1]-sum[i];
      kans+=kend-t[inds]+1;
    }
    ans=max(ans,kans);
  }*/
  cout<<ans<<endl;
}
accuracy: 1
time_ms: 140
memory_kb: 17608
final_rank: 19

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;
typedef long long int lli;
typedef pair<lli, lli> pll;

int main(){
    lli t,n;
    cin >> t >> n;

    vector<pair<lli, lli>> p(n);
    for(int i=0; i<n; i++){
        cin >> p[i].first >> p[i].second;
    }

    vector<lli> len(n+1, 0);
    for(int i=0; i<n; i++){
        len[i+1] = len[i] +p[i].second -p[i].first;
    }
    lli ans = 0;
    for(int i=0; i<n; i++){
        lli b = p[i].first;
        lli e = b+t;
        int idx = lower_bound(p.begin(), p.end(), pll(e, 0)) -p.begin() -1;
        lli sub = len[idx] -len[i];
        if(p[idx].first < e){
            sub += min(e-p[idx].first, p[idx].second-p[idx].first);
        }
        ans = max(ans, sub);
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 5208
final_rank: 13

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ll long long
#define pp pair<ll,ll>
#define ld long double
#define all(a) (a).begin(),(a).end()
#define mk make_pair
ll MOD=998244353;
int inf=1000001000;
ll INF=1e18+5;
ll mod=INF;


int main() {
    ll T;
    int n;
    cin >> T >> n;
    vector<ll> s(n),t(n);
    rep(i,n) cin >> s[i] >> t[i];
    s.push_back(INF);
    int r=1,m=0;
    ll u=0,ans=0;
    rep(i,n){
        while(true){
            if (r==1){
                if (s[i]+T<s[m]) break;
                u+=t[m]-s[m];
                m++;
                r=0;
            }
            else if (r==0){
                if (s[i]+T<t[m-1]) break;
                r=1;
            }
        }
        if (r==0) ans=max(ans,u-(t[m-1]-s[i]-T));
        else ans=max(ans,u);
        u-=t[i]-s[i];
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 70
memory_kb: 5276
final_rank: 9

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i,n) for (int i = 0; i < (n); ++i)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF=1LL<<60;
const int inf=(1<<30)-1;
const int mod=1e9+7;
int dx[8]={1,0,-1,0,-1,-1,1,1};
int dy[8]={0,1,0,-1,-1,1,-1,1};
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll t;cin >> t;
    int n;cin >> n;
    vector<ll> s(n),e(n),sum(n+1);
    ll ans=0;
    for(int i=0;i<n;i++){
        cin >> s[i] >> e[i];
        sum[i+1]=sum[i]+e[i]-s[i];
    }
    for(int i=0;i<n;i++){
        int u=lower_bound(s.begin(),s.end(),s[i]+t)-s.begin();
        int v=lower_bound(e.begin(),e.end(),s[i]+t)-e.begin();
        if(u==v){
            chmax(ans,sum[u]-sum[i]);
        }
        else{
            chmax(ans,sum[v]-sum[i]+t+s[i]-s[v]);
        }
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 20
memory_kb: 5220
final_rank: 2

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


signed main(){
    ios::sync_with_stdio(false);
	cin.tie(0);
    cout << fixed << setprecision(20);

    int64_t R, n;
    cin >> R;
    cin >> n;
    vector<int64_t> S(n), T(n);

    for (int i = 0; i < n; i++)
        cin >> S[i] >> T[i];

    vector<int64_t> csum(n + 1);
    for (int i = 0; i < n - 1; i++){
        csum[i + 1] = csum[i] + S[i + 1] - T[i];
    }
    csum[n] = csum[n - 1];

    int64_t ma = 0;
    for (int i = 0; i < n; i++){
        int l = i - 1, r = n;
        while (r - l > 1){
            int mid = (l + r) / 2;
            if (S[i] + R > S[mid]){
                l = mid;
            } else {
                r = mid;
            }
        }

        if (l == i - 1)
            ma = R;
        else {
            ma = max(ma, R - (csum[l] - csum[i] + max(0L, S[i] + R - T[l]))); 
        }
    }
    cout << ma << endl;
}
accuracy: 1
time_ms: 20
memory_kb: 5256
final_rank: 3

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

int main() {
    ll T, N, res = 0;
    cin >> T >> N;
    ll A[N], B[N];
    ll S[N + 1];
    S[0] = 0;
    rep(i, N) cin >> A[i] >> B[i], S[i + 1] = S[i] + B[i] - A[i];

    rep(i, N) {
        ll l = -1, r = N;
        while (r - l > 1) {
            ll m = (l + r) / 2;
            if (A[m] < A[i] + T) {
                l = m;
            } else {
                r = m;
            }
        }
        ll time = S[l] - S[i] + min(B[l], A[i] + T) - A[l];
        res = max(res, time);
    }
    cout << res << endl;
}
accuracy: 1
time_ms: 80
memory_kb: 5428
final_rank: 14

code_snippet: /*  -*- coding: utf-8 -*-
 *
 * 2801.cc: Suntan
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 100000;
const int MAX_M = MAX_N * 2;

/* typedef */

typedef long long ll;

/* global variables */

ll as[MAX_N], bs[MAX_N], ss[MAX_N + 1];

/* subroutines */


/* main */

int main() {
  ll t;
  int n;
  scanf("%lld%d", &t, &n);

  for (int i = 0; i < n; i++) {
    scanf("%lld%lld", as + i, bs + i);
    ss[i + 1] = ss[i] + (bs[i] - as[i]);
  }

  ll maxl = 0;
  for (int i = 0; i < n; i++) {
    ll ti = as[i] + t;
    int k = upper_bound(bs, bs + n, ti) - bs;
    //printf("k=%d\n", k);

    ll l = ss[k] - ss[i];
    if (k < n && as[k] < ti) l += ti - as[k];
    if (maxl < l) maxl = l;
  }

  printf("%lld\n", maxl);
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 5556
final_rank: 4

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;

int main() {
	long long int T, N, temp[10][100100], temp2 = 0, ans = 0, i, j = 0, tempT, temp3 = 0;

	cin >> T >> N;

	for (i = 0; i < N; i++) {
		cin >> temp[0][i] >> temp[1][i];
	}


	for (i = 0; i < N; i++) {
		tempT = temp[0][i] + T; 
		if (i != 0) { ans -= temp[1][i - 1] - temp[0][i - 1] + temp3;}

		while (j < N && temp[1][j] <= tempT) {
			ans += temp[1][j] - temp[0][j];
			j++;
		}
		if (j < N && temp[0][j] <= tempT) {
			temp3 = tempT - temp[0][j]; 
			ans += temp3;
		}
		else temp3 = 0;
		temp2 = max(temp2, ans);
	}
	cout << temp2 << endl;

	//cin >> T;


	return 0;
}
accuracy: 1
time_ms: 100
memory_kb: 4648
final_rank: 16

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
  int T,n;
  int s[100010],t[100010];
  cin>>T>>n;
  for(int i=0;i<n;i++){
    cin>>s[i]>>t[i];
  }
  int l=0,r=0;
  int sum=0;
  int ans=0;
  for(;l<n;l++){
    if(t[l]-s[l]>=T){
      ans=T;
      break;
    }
    for(;r<n;r++){
      if(t[r]>s[l]+T)break;
      sum+=t[r]-s[r];
    }
    if(t[r]>s[l]+T)ans=max(ans,sum+max(0LL,s[l]+T-s[r]));
    ans=max(ans,sum);
    sum-=t[l]-s[l];
  }
  cout<<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 4660
final_rank: 11

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

template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}

//INSERT ABOVE HERE
signed main(){
  Int t,n;
  cin>>t>>n;
  vector<Int> a(n),b(n);
  for(Int i=0;i<n;i++) cin>>a[i]>>b[i];
  vector<Int> s(n+1);
  for(Int i=0;i<n;i++) s[i+1]=s[i]+(b[i]-a[i]);

  Int ans=0;
  for(Int i=0;i<n;i++){
    Int k=lower_bound(b.begin(),b.end(),a[i]+t)-b.begin();
    Int res=s[k]-s[i];
    if(k<n) res+=max((Int)0,(a[i]+t)-a[k]);
    chmax(ans,res);
    //cout<<i<<":"<<k<<":"<<res<<endl;    
  }
  cout<<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 5200
final_rank: 12

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;


//namespace cent {
//
//	struct Edge {
//		int src;
//		int dst;
//		long long int cost;
//	};
//	using Graph = vector<vector<Edge>>;
//
//	class Centroid {
//	private:
//		int dfs(const Graph&g, const int now, const int from, vector<int>&ch_nums, const vector<int>&oks) {
//			int sum = 1;
//			for (auto &&e : g[now]) {
//				if (e.dst == from || oks[e.dst] != -1)continue;
//				else {
//					sum += dfs(g, e.dst, e.src, ch_nums, oks);
//				}
//			}
//			return ch_nums[now] = sum;
//		}
//
//		int find_centroid(const int asize, const vector<vector<Edge>>&graph, const int pre_root, const int pre_from, const vector<int>&ch_nums, const vector<int>&oks) {
//			for (auto&& e : graph[pre_root]) {
//				if (e.dst == pre_from)continue;
//				if (oks[e.dst] != -1)continue;
//				if (ch_nums[e.dst]>asize / 2)return find_centroid(asize, graph, e.dst, e.src, ch_nums, oks);
//			}
//			return pre_root;
//		}
//
//		void dfs2(const Graph&g, const int root,const int now, const int from, const vector<int>&oks,int depth) {
//			mp[make_pair(root,now)]=depth;
//			for (auto &&e : g[now]) {
//				if (e.dst == from || oks[e.dst] != -1)continue;
//				else {
//					dfs2(g,root,e.dst,e.src,oks,depth+1);
//				}
//			}
//		};
//
//
//		void cent(const vector<vector<Edge>>&graph, vector<int>&oks, const int root, const int from, vector<vector<int>>&centroid_edges, int& fst_centroid, int depth, vector<int>&ch_nums) {
//			dfs(graph, root, from, ch_nums, oks);
//
//			int cent_id = find_centroid(ch_nums[root], graph, root, from, ch_nums, oks);
//
//
//			dfs2(graph,cent_id,cent_id,-1,oks,0);
//			lens1[cent_id][make_pair(0,0)]--;
//			lens2[cent_id][0]--;
//
//
//			oks[cent_id] = depth;
//
//			//for (auto&& e : graph[cent_id]) {
//			//	if (e.dst == from)continue;
//			//	if (oks[e.dst] != -1)continue;
//
//			//	dfs2(graph, e.dst, e.dst, e.src, oks,e.cost%mod,e.cost%mod,1);
//
//			//	for (auto&& l1 : lens1[e.dst]) {
//			//		int keta = l1.first.second;
//			//		long long int num = l1.first.first;
//
//			//		long long int need = (mod - num) / mod_pow(10, keta);
//			//		need%=mod;
//			//		auto it = lens2[e.dst].find(need);
//			//		if (it != lens2[e.dst].end()) {
//			//			ans -= l1.second*it->second;
//			//		}
//			//	}
//			//	lens1[e.dst].clear();
//			//	lens2[e.dst].clear();
//			//}
//
//			if (from != -1) {
//				centroid_edges[from].push_back(cent_id);
//			}
//			else {
//				fst_centroid = cent_id;
//			}
//			for (auto&& e : graph[cent_id]) {
//				if (e.dst == from)continue;
//				if (oks[e.dst] != -1)continue;
//				cent(graph, oks, e.dst, e.src, centroid_edges, fst_centroid, depth + 1, ch_nums);
//			}
//		}
//
//	public:
//
//		map<pair<int,int>,int>mp;
//
//		vector<map<pair<long long int,int>, long long int>>lens1;
//		vector<map<long long int, long long int>>lens2;
//		vector<vector<int>> centroid_graph;
//		vector<int>ts;
//		vector<int>parents;
//		vector<int>oks;
//		vector<int>anss;
//
//		//fst:root  snd:centroid_graph
//		void init(const Graph&g) {
//			lens1.resize(g.size());
//			lens2.resize(g.size());
//			oks = vector<int>(g.size(), -1);
//			int root = -1;
//			centroid_graph.resize(g.size());
//			parents = vector<int>(g.size(), -1);
//			ts=vector<int>(g.size(),-1);
//			anss=vector<int>(g.size(),100000);
//
//			vector<int>ch_nums(g.size());
//			cent(g, oks, 0, -1, centroid_graph, root, 0, ch_nums);
//
//			for (int i = 0; i < centroid_graph.size(); ++i) {
//				for (auto&& e : centroid_graph[i]) {
//					parents[e] = i;
//				}
//			}
//			return ;
//		}
//	}centroid;
//
//
//	void addEdge(Graph& g, int a, int b, long long int c) {
//		g[a].push_back(Edge{ a,b,c });
//		g[b].push_back(Edge{ b,a,c });
//	}
//}


//const int mod = 1000000007;
//struct Mod {
//public:
//	int num;
//	Mod() : Mod(0) { ; }
//	Mod(long long int n) : num((n % mod + mod) % mod) {
//		static_assert(mod<INT_MAX / 2, "mod is too big, please make num 'long long int' from 'int'");
//	}
//	Mod(int n) : Mod(static_cast<long long int>(n)) { ; }
//	operator int() { return num; }
//};
//
//Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
//Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
//Mod operator+(const Mod a, const long long int  b) { return b + a; }
//Mod operator++(Mod &a) { return a + Mod(1); }
//Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); }
//Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
//Mod operator--(Mod &a) { return a - Mod(1); }
//Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); }
//Mod operator*(const long long int a, const Mod b) { return Mod(a)*b; }
//Mod operator*(const Mod a, const long long int b) { return Mod(b)*a; }
//Mod operator*(const Mod a, const int b) { return Mod(b)*a; }
//Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
//Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
//Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
//Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
//Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
//Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
//Mod operator*=(Mod& a, const long long int &b) { return a = a * b; }
//Mod operator^(const Mod a, const int n) {
//	if (n == 0) return Mod(1);
//	Mod res = (a * a) ^ (n / 2);
//	if (n % 2) res = res * a;
//	return res;
//}
//Mod mod_pow(const Mod a, const long long  int n) {
//	if (n == 0) return Mod(1);
//	Mod res = mod_pow((a * a), (n / 2));
//	if (n % 2) res = res * a;
//	return res;
//}
//
////mod が素数の場合のみ　違う場合はextend euclid を用いる。
//Mod inv(const Mod a) { return a ^ (mod - 2); }
//Mod operator/(const Mod a, const Mod b) {
//	assert(b.num != 0);
//	return a * inv(b);
//}
//Mod operator/(const long long int a, const Mod b) {
//	return Mod(a) / b;
//}
//Mod operator/=(Mod &a, const Mod b) {
//	return a = a / b;
//}
//
//#define MAX_MOD_N 1024000
//
//Mod fact[MAX_MOD_N], factinv[MAX_MOD_N];
//void init(const int amax = MAX_MOD_N) {
//	fact[0] = Mod(1); factinv[0] = 1;
//	for (int i = 0; i < amax - 1; ++i) {
//		fact[i + 1] = fact[i] * Mod(i + 1);
//		factinv[i + 1] = factinv[i] / Mod(i + 1);
//	}
//}
//Mod comb(const int a, const int b) {
//	return fact[a] * factinv[b] * factinv[a - b];
//}
//
//vector<int>primes;
//void hurui(const int amax=3500) {
//	static bool flag = false;
//	if (flag)return;
//	vector<int>sos;
//	sos = vector<int>(amax + 1, true);
//	sos[0] = false; sos[1] = false;
//	for (int i = 2; i <= amax; ++i) {
//		if (sos[i]) {
//			for (int j = 2 * i; j <= amax; j += i)sos[j] = false;
//		}
//	}
//	for (int i = 0; i <= amax; ++i) {
//		if (sos[i]) {
//			primes.push_back(i);
//		}
//	}
//	flag = true;
//}
//
//
//struct query {
//	int u;
//	int v;
//	map<int,int>mp;
//};
//
//map<int, int>mk_mp(const int a) {
//	int rest(a);
//	map<int,int>as;
//	for (auto pr : primes) {
//		while (rest%pr == 0) {
//			as[pr]++;
//			rest /= pr;
//		}
//	}
//	if (rest!=1)as[rest]++;
//	return as;
//}
//
//#define Seg_Max_N (1<<18) 
//
//class Tree {
//public:
//	Tree(int V, int root) : V(V), root(root), cnum(V), place(V), id(V) {
//		T.resize(V);
//		for (int i = 0; i < MAXLOGV; i++) {
//			parent[i].resize(V);
//		}
//		depth.resize(V);
//	}
//	// uとvをつなぐ
//	// lcaを求めることが主目的なので無向グラフとしている
//	void unite(int u, int v) {
//		T[u].push_back(v);
//		T[v].push_back(u);
//	}
//	void unite(vector<vector<int>>&e) {
//		T = e;
//	}
//	// initする
//	// コンストラクタだけじゃなくてこれも呼ばないとlcaが求められないぞ
//	void init() {
//		dfs(root, 0, 0);
//		int id = 0;
//		getid(root, 0, id);
//	}
//	// uとvのlcaを求める
//	int lca(int u, int v) const {
//		if (depth[u] > depth[v]) swap(u, v);
//		for (int k = 0; k < MAXLOGV; k++) {
//			if ((depth[v] - depth[u]) >> k & 1) {
//				v = parent[k][v];
//			}
//		}
//		if (u == v) return u;
//		for (int k = MAXLOGV - 1; k >= 0; k--) {
//			if (parent[k][u] != parent[k][v]) {
//				u = parent[k][u];
//				v = parent[k][v];
//			}
//		}
//		return parent[0][u];
//	}
//	// uとvの距離を求める
//	// edgeを定義しないといけない時はこれじゃダメ
//	int dist(int u, int v) const {
//		int p = lca(u, v);
//		return (depth[u] - depth[p]) + (depth[v] - depth[p]);
//	}
//	int dfs(int v, int p, int d) {
//		parent[0][v] = p;
//		depth[v] = d;
//		cnum[v] = 0;
//		for (int i = 1; i < MAXLOGV; i++) {
//			parent[i][v] = parent[i - 1][parent[i - 1][v]];
//		}
//		for (int next : T[v]) {
//			if (next != p) cnum[v] += dfs(next, v, d + 1);
//		}
//		return cnum[v] + 1;
//	}
//
//	void dfs2(int v, int p, vector<vector<int>>&doubles, const vector<int>&nums) {
//		for (int next : T[v]) {
//			if (next != p) dfs2(next, v, doubles, nums);
//		}
//		doubles[0][v] = nums[v];
//		for (int j = 1; j < MAXLOGV; ++j) {
//			doubles[j][v] = min(doubles[j][v], doubles[j - 1][v]);
//		}
//		for (int j = 0; j < MAXLOGV - 1; ++j) {
//			doubles[j + 1][parent[j][v]] = min(doubles[j + 1][parent[j][v]], doubles[j][v]);
//		}
//	}
//	//ここでは親から距離2^iの部分木の最小値を求めている
//	vector<vector<int>>get_doubles(const vector<int>&nums) {
//		vector<vector<int>>doubles(MAXLOGV, vector<int>(V, 1e9));
//		dfs2(root, -1, doubles, nums);
//		return doubles;
//	}
//
//	void getid(const int v, const int p, int &nplace) {
//		place[v] = nplace;
//		id[nplace] = v;
//		nplace++;
//		for (int next : T[v]) {
//			if (next != p) getid(next, v, nplace);
//		}
//	}
//	static const int MAXLOGV = 25;
//	// グラフの隣接リスト表現
//	vector<vector<int> > T;
//	// 頂点の数
//	int V;
//	// 根ノードの番号
//	int root;
//
//	// 親ノード
//	vector<int> parent[MAXLOGV];
//	// 根からの深さ
//	vector<int> depth;
//
//	//子の数
//	vector<int>cnum;
//
//	//変換
//	vector<int>place;
//	vector<int>id;
//
//};
//
//vector<int>pas;
//void adfs(vector<pair<int, int>>&lrs, vector<int>&tos,const vector<vector<int>>&edges, const int now, const int from,int &id) {
//	tos[now]=id;
//	lrs[tos[now]].first=id++;
//	for (auto e : edges[now]) {
//		if (e == from) {
//			pas[now] = from;
//			continue;
//		}
//		adfs(lrs,tos,edges,e,now,id);
//	}
//	lrs[tos[now]].second=id;
//}
//
//vector<pair<int, int>>get_lrs(vector<int>&tos,const vector<vector<int>>&edges, const int root) {
//	pas.resize(tos.size());pas[0]=-1;
//	vector<pair<int,int>>lrs(edges.size());
//	int id=0;
//	adfs(lrs,tos,edges,0,-1,id);
//	return lrs;
//}


namespace FastFourierTransform
{
	using C = complex< double >;

	void DiscreteFourierTransform(vector< C > &F, bool rev)
	{
		const int N = (int)F.size();
		const double PI = (rev ? -1 : 1) * acos(-1);
		for (int i = 0, j = 1; j + 1 < N; j++) {
			for (int k = N >> 1; k > (i ^= k); k >>= 1);
			if (i > j) swap(F[i], F[j]);
		}
		C w, s, t;
		for (int i = 1; i < N; i <<= 1) {
			for (int k = 0; k < i; k++) {
				w = polar(1.0, PI / i * k);
				for (int j = 0; j < N; j += i * 2) {
					s = F[j + k];
					t = C(F[j + k + i].real() * w.real() - F[j + k + i].imag() * w.imag(),
						F[j + k + i].real() * w.imag() + F[j + k + i].imag() * w.real());
					F[j + k] = s + t, F[j + k + i] = s - t;
				}
			}
		}
		if (rev) for (int i = 0; i < N; i++) F[i] /= N;
	}

	vector< int> Multiply(const vector< int > &A, const vector<int > &B)
	{
		int sz = 1;
		while (sz <= A.size() + B.size()) sz <<= 1;
		vector< C > F(sz), G(sz);
		for (int i = 0; i < A.size(); i++) F[i] = A[i];
		for (int i = 0; i < B.size(); i++) G[i] = B[i];
		DiscreteFourierTransform(F, false);
		DiscreteFourierTransform(G, false);
		for (int i = 0; i < sz; i++) F[i] *= G[i];
		DiscreteFourierTransform(F, true);
		vector< int > X(A.size() + B.size() - 1);
		for (int i = 0; i < A.size() + B.size() - 1; i++) X[i] = F[i].real() + 0.5;
		return (X);
	}
};



int main()
{
	long long int T;cin>>T;
	int N;cin>>N;
	vector<pair<long long int,long long int>>ps;
	vector<long long int>sums(N+1);
	sums[0]=0;
	for (int i = 0; i < N; ++i) {
		long long int l,r;cin>>l>>r;
		ps.emplace_back(l,r);
		sums[i+1]=sums[i]+r-l;
	}
	long long int ans=0;
	for (int i = 0; i < N; ++i) {
		auto it=lower_bound(ps.begin(),ps.end(),make_pair(ps[i].first+T,0ll));
		int j=it-ps.begin()-1;
		auto p(ps[j]);
		if (p.second < ps[i].first + T) {

			long long int nans = sums[j]-sums[i] + ps[j].second-ps[j].first;
			ans=max(ans,nans);
		}
		else {

			long long int nans = sums[j]-sums[i] + ps[i].first + T - ps[j].first;
			ans=max(ans,nans);
		}
	}
	cout<<ans<<endl;
	return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 5708
final_rank: 18