Problem:
スコーン配達計画
愛歌さんの家は、小さな喫茶店を経営しています。愛歌さんのお母さんが焼くスコーンはとても美味しくて、店はとても繁盛していました。
ウェイトレスである愛歌さんの仕事の一つは、次々と焼き上がるスコーンを、お客様の席まで届けることです。焼きあがったスコーンはお盆の上に乗せられ、カウンターの上に一列に並べられます。
i
番目のお盆の上に乗っているスコーンの数を
K
i
としましょう。愛歌さんは、それぞれのお客様にちょうど
m
個のスコーンを運ばなければなりません。愛歌さんは一度にいくつでもお盆を持つことができ、また複数のお盆から 1 人のお客様にスコーンを配ったり、１つのお盆から複数のお客様に配っても構いません。
喫茶店にはとてもたくさんのお客様がやってくるので、カウンターに置いてある全てのスコーンを運んでも、全てのお客様に届けることはできません。しかし、できるだけ多くのお客様に届けた後で、
m
個に満たない数のスコーンが余ることもあるかもしれません。そのようなスコーンは、お手伝いのご褒美として、愛歌さんが貰えることになりました。
ここでふと、愛歌さんは考えました。一度に全てのお盆を持つのではなく、一部のお盆だけを持ってお客様にスコーンを届けると、余るスコーンの数も違ってくるはずです。適切にお盆を選ぶことで、より多くのスコーンが余るようにできるかもしれません。愛歌さんは、作為的にお盆を選んでいることをお母さんに見抜かれないように、カウンターの上の1つの連続した範囲のお盆を選ぶことにしました。また、残ったお盆はお父さんやお母さんが運んでしまうので、愛歌さんがスコーンをもらうチャンスは一度しかありません。
さて、愛歌さんは最大いくつのスコーンを貰えるでしょうか？計算するプログラムを書いてください。お盆の数
n
は 1 以上 30,000以下、
m
は 1 以上 100,000 以下です。また数列の各要素
K
i
は 0 以上 2
32
-1 です。
入力
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下のとおりです。
1行目
n
m
（整数 整数；半角空白区切り）
2行目 お盆上のスコーンの情報
K
1
K
2
...
K
n
（すべて整数 ; 半角空白区切り）
K
i
:
i
番目のお盆上のスコーンの数
データセットの数は 50 を超えません。
出力
データセットごとに、もらえるスコーンの最大数を１行に出力します。
入力例
5 11
11 27 34 45 56
8 5
0 2 1 5 4 6 8 3
5 2
2 4 2 4 6
10 18
10 15 12 31 12 50 11 23 43 181
1 100
5
0 0
出力例
8
4
0
17
5

Submitted solutions:

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

using ll = long long;
using P = pair<int, int>;

int main() {
    int n, m;
    while(cin >> n >> m, n) {
        vector<int> a(n+1);
        for(int i=1; i<=n; ++i) {
            cin >> a[i];
            a[i] %= m;
            (a[i] += a[i-1]) %= m;
        }
        int res = 0;
        set<int> s;
        s.insert(0);
        for(int i=1; i<=n; ++i) {
            auto it = s.upper_bound(a[i]);
            res = max(res, a[i]);
            if(it != s.end()) {
                res = max(res, (a[i] - *it + m) % m);
            }
            s.insert(a[i]);
        }
        cout << res << endl;
    }
}
accuracy: 1
time_ms: 100
memory_kb: 4684
final_rank: 7

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    while (cin >> n >> m, n) {
        vector<ll> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
            a[i] %= m;
        }
        ll res = 0;
        set<ll> st;
        st.insert(0);
        ll sum = 0;
        for (int i = 0; i < n; i++) {
            sum += a[i];
            sum %= m;
            auto it = st.lower_bound(sum + 1);
            if (it == st.end()) {
                res = max(res, sum);
            } else {
                res = max(res, m - (*it - sum));
            }
            st.insert(sum);
        }

        cout << res << "\n";
    }
}
accuracy: 1
time_ms: 60
memory_kb: 4876
final_rank: 4

code_snippet: /* -*- coding: utf-8 -*-
 *
 * 0254.cc: スコーン配達計画
 */

#include<cstdio>
#include<set>
#include<algorithm>
 
using namespace std;

/* constant */

const int MAX_N = 30000;

/* typedef */

typedef long long ll;
typedef set<int> si;

/* global variables */

int ass[MAX_N + 1];

/* subroutines */

/* main */

int main() {
  for (int n, m; scanf("%d%d", &n, &m), n > 0;) {
    for (int i = 0; i < n; i++) {
      ll ai;
      scanf("%lld", &ai);
      ass[i + 1] = (ass[i] + ai % m) % m;
    }

    int maxd = 0;
    si ps;
    for (int i = 0; i < n; i++) {
      ps.insert(ass[i]);
      auto sit = ps.upper_bound(ass[i + 1]);
      int d = (m + ass[i + 1] - (sit != ps.end() ? *sit : *ps.begin())) % m;
      maxd = max(maxd, d);
    }

    printf("%d\n", maxd);
  }

  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 4332
final_rank: 1

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



int main() {
	// your code goes here
while(true){
	int n,m;
	long long int s1,ans;
	set<long long int> ss;
	cin>>n>>m;
	if (n+m==0) break;
	ss.insert(0);
	s1=0;
	ans=0;
	for(int i=0;i<n;i++){
		long long int t,s2;
		cin>>t;
		s1=(s1+t)%m;
		set<long long int>::iterator it=ss.lower_bound((s1+1)%m);
		if (it!=ss.end()){
			s2=(s1+(m-(*it)))%m;
			ans=max(ans,s2);
		}
		ans=max(ans,s1);
		ss.insert(s1);
	}
	cout<<ans<<endl;
}
	return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 4296
final_rank: 8

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



int main() {
	// your code goes here
while(true){
	int n,m;
	long long int s1,ans;
	set<long long int> ss;
	cin>>n>>m;
	if (n+m==0) break;
	ss.insert(0);
	s1=0;
	ans=0;
	for(int i=0;i<n;i++){
		long long int t,s2;
		cin>>t;
		s1=(s1+t)%m;
		s2=(m+(m-s1-1))%m;
		set<long long int>::iterator it=ss.lower_bound(s2);
		if (it!=ss.end()){
			s2=(s1+(*it))%m;
			ans=max(ans,s2);
		}
		if(it!=ss.begin()){
			it--;
			s2=(s1+(*it))%m;
			ans=max(ans,s2);
		}
		ans=max(ans,s1);
		ss.insert(s1);
	}
	cout<<ans<<endl;
}
	return 0;
}
accuracy: 0.5
time_ms: 90
memory_kb: 3288
final_rank: 20

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
typedef long long int lli;

int main(){
    while(1){
        lli n,m;
        cin >> n >> m;
        if(n == 0) break;

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

        lli ans = 0;
        set<lli> b;
        b.insert(0);
        for(int i=1; i<=n; i++){
            if(*b.begin() < a[i]){
                ans = max(ans, a[i] -*b.begin());
            }
            if(b.upper_bound(a[i]) != b.end()){
                ans = max(ans, a[i] -*b.upper_bound(a[i]) +m);
            }
            b.insert(a[i]);
        }
        cout << ans << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 4344
final_rank: 9

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

int main(){
    while(1){
        int n,m;
        cin >> n >> m;
        if(n == 0) break;

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

        int ans = 0;
        set<int> b;
        b.insert(0);
        for(int i=1; i<=n; i++){
            if(*b.begin() < a[i]){
                ans = max(ans, a[i] -*b.begin());
            }
            if(b.upper_bound(a[i]) != b.end()){
                ans = max(ans, a[i] -*b.upper_bound(a[i]) +m);
            }
            b.insert(a[i]);
        }
        cout << ans << endl;
    }
    return 0;
}
accuracy: 0.75
time_ms: 120
memory_kb: 4164
final_rank: 14

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

using namespace std;

int N, M;
vector<int> SconeData;
set<int> DpScone;

void solve() {
	int sum, maxScone;
	set<int>::iterator it;

	sum = 0;
	for (int i = 0; i < N; ++i) {
		sum += SconeData[i] % M;
		SconeData[i] = sum%M;
	}

	maxScone = 0;
	for (int i = 0; i < N; ++i) {
		it = DpScone.upper_bound(SconeData[i]);
		if (it != DpScone.end()) {
			maxScone = max(maxScone, (SconeData[i] - *it + M) % M);
		}
		else {
			maxScone = max(maxScone, SconeData[i]);
		}
		DpScone.insert(SconeData[i]);
	}
	
	cout << maxScone << endl;
}

int main() {
	int num;

	while (cin >> N >> M, N) {
		SconeData.clear();
		DpScone.clear();
		for (int i = 0; i < N; ++i) {
			cin >> num;
			SconeData.push_back(num);
		}
		solve();
	}
	
	return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 4236
final_rank: 6

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

using namespace std;

int N, M;
vector<int> SconeData;
set<int> DpScone;

void solve() {
	int sum, maxScone;
	set<int>::iterator it;

	sum = 0;
	for (int i = 0; i < N; ++i) {
		sum += SconeData[i];
		SconeData[i] = sum%M;
	}

	maxScone = 0;
	for (int i = 0; i < N; ++i) {
		it = DpScone.upper_bound(SconeData[i]);
		if (it != DpScone.end()) {
			maxScone = max(maxScone, (SconeData[i] - *it + M) % M);
		}
		else {
			maxScone = max(maxScone, SconeData[i]);
		}
		DpScone.insert(SconeData[i]);
	}
	
	cout << maxScone << endl;
}

int main() {
	int num;

	while (cin >> N >> M, N) {
		SconeData.clear();
		DpScone.clear();
		for (int i = 0; i < N; ++i) {
			cin >> num;
			SconeData.push_back(num);
		}
		solve();
	}
	
	return 0;
}
accuracy: 0.5
time_ms: 70
memory_kb: 3384
final_rank: 18

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

using namespace std;

int N, M;
vector<int> SconeData;


void solve() {
	int sum, maxScone;
	set<int> DpScone;
	set<int>::iterator it;

	sum = 0;
	for (int i = 0; i < N; ++i) {
		sum += SconeData[i];
		SconeData[i] = sum%M;
	}

	maxScone = 0;
	for (int i = 0; i < N; ++i) {
		it = DpScone.upper_bound(SconeData[i]);
		if (it != DpScone.end()) {
			maxScone = max(maxScone, (SconeData[i] - *it + M) % M);
		}
		else {
			maxScone = max(maxScone, SconeData[i]);
		}
		DpScone.insert(SconeData[i]);
	}
	
	cout << maxScone << endl;
}

int main() {
	int num;

	while (cin >> N >> M, N) {
		SconeData.clear();
		for (int i = 0; i < N; ++i) {
			cin >> num;
			SconeData.push_back(num);
		}
		solve();
	}
	
	return 0;
}
accuracy: 0.5
time_ms: 70
memory_kb: 3396
final_rank: 19

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

using namespace std;

int N, M;
int SconeData[30000];
vector<int> RestScone;
set<int> DpScone;


void solve() {
	int sum, maxScone;
	set<int>::iterator it;

	sum = 0;
	for (int i = 0; i < N; ++i) {
		sum += SconeData[i];
		RestScone.push_back(sum%M);
	}

	maxScone = 0;
	for (unsigned int i = 0; i < N; ++i) {
		maxScone = max(maxScone, RestScone[i]);
		it = DpScone.upper_bound(RestScone[i]);
		if (it != DpScone.end()) {
			maxScone = max(maxScone, (RestScone[i] - *it + M) % M);
		}
		DpScone.insert(RestScone[i]);
	}
	
	cout << maxScone << endl;
}

int main() {

	while (cin >> N >> M, N) {
		RestScone.clear();
		DpScone.clear();
		for (int i = 0; i < N; ++i) {
			cin >> SconeData[i];
		}
		solve();
	}
	
	return 0;
}
accuracy: 0.5
time_ms: 70
memory_kb: 3336
final_rank: 16

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

using namespace std;

int N, M;
int SconeData[30000];
vector<int> RestScone;
set<int> DpScone;


void solve() {
	int sum, maxScone;
	set<int>::iterator it;

	sum = 0;
	for (int i = 0; i < N; ++i) {
		sum += SconeData[i];
		RestScone.push_back(sum%M);
	}

	maxScone = 0;
	for (unsigned int i = 0; i < RestScone.size(); ++i) {
		
		maxScone = max(maxScone, RestScone[i]);
		it = DpScone.upper_bound(RestScone[i]);
		if (it != DpScone.end()) {
			maxScone = max(maxScone, (RestScone[i] - *it + M) % M);
		}
		DpScone.insert(RestScone[i]);
	}
	
	cout << maxScone << endl;
}

int main() {

	while (cin >> N >> M, N) {
		RestScone.clear();
		DpScone.clear();
		for (int i = 0; i < N; ++i) {
			cin >> SconeData[i];
		}
		solve();
	}
	
	return 0;
}
accuracy: 0.5
time_ms: 70
memory_kb: 3288
final_rank: 15

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

using namespace std;

int N, M;
int SconeData[30000];
vector<int> RestScone;
set<int> DpScone;


void solve() {
	int sum, maxScone;
	set<int>::iterator it;

	sum = 0;
	for (int i = 0; i < N; ++i) {
		sum += SconeData[i];
		RestScone.push_back(sum%M);
	}

	maxScone = 0;
	for (unsigned int i = 0; i < RestScone.size(); ++i) {
		DpScone.insert(RestScone[i]);
		maxScone = max(maxScone, RestScone[i]);
		it = DpScone.upper_bound(RestScone[i]);
		if (it != DpScone.end()) {
			maxScone = max(maxScone, (RestScone[i] - *it + M) % M);
		}
	}
	
	cout << maxScone << endl;
}

int main() {

	while (cin >> N >> M, N) {
		RestScone.clear();
		DpScone.clear();
		for (int i = 0; i < N; ++i) {
			cin >> SconeData[i];
		}
		solve();
	}
	
	return 0;
}
accuracy: 0.5
time_ms: 70
memory_kb: 3368
final_rank: 17

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

int main() {
    int n, m;
    while(cin >> n >> m, n){
        vector<ll> v(n);
        for (auto &&i : v) scanf("%lld", &i);
        ll S = 0;
        set<ll> s;
        s.emplace(0);
        ll ans = 0;
        for (int i = 0; i < n; ++i) {
            (S += v[i]) %= m;
            auto a = s.upper_bound(S);
            if(a != s.end()){
                ans = max(ans, (S-*a+m)%m);
            }else {
                ans = max(ans, S-*s.begin());
            }
            s.emplace(S);
        }
        cout << ans << "\n";
    }
    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 4532
final_rank: 3

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

int main() {
    int n, m;
    while(cin >> n >> m, n){
        vector<int> v(n);
        for (auto &&i : v) scanf("%d", &i);
        int S = 0;
        set<int> s;
        s.emplace(0);
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            (S += v[i]) %= m;
            auto a = s.upper_bound(S);
            if(a != s.end()){
                ans = max(ans, (S-*a+m)%m);
            }else {
                ans = max(ans, S-*s.begin());
            }
            s.emplace(S);
        }
        cout << ans << "\n";
    }
    return 0;
}
accuracy: 0.75
time_ms: 70
memory_kb: 4196
final_rank: 12

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

#define int long long

signed main(){

    int n, m;
    while(cin >> n >> m, n != 0){
        int num = 0;
        int a[30010];
        int b[30010];

        multiset<int> st;
        for(int i = 0;i < n;i++){
            cin >> a[i];
            num += a[i];
            num %= m;
            b[i] = num;
            st.insert(b[i]);
        }

        int ans = 0;

        num = 0;
        for(int i = 0;i < n;i++){
            auto itr = st.lower_bound(num);
            if(itr == st.begin()){
                itr = st.end();
                itr--;
            }else{
                itr--;
            }

            ans = max(ans, (m + (*itr) - num) % m);

            num = b[i];
            st.erase(st.lower_bound(num));
        }
        cout << ans << endl;

    }

    return 0;
}
accuracy: 1
time_ms: 140
memory_kb: 4952
final_rank: 11

code_snippet: #include <string>
#include <vector>
#include <iostream>
#include <queue>
#include <functional>
#include <algorithm>
#include <random>
#include <cmath>
#include <climits>
#include <iomanip>
#include <cfloat>
#include <set>
int main() {
	int n, m; std::cin >> n >> m;
	while (n != 0) {
		std::vector<long long int> scone(n);
		for (auto &s : scone) std::cin >> s;
		scone[0] %= m;
		for (auto i = 1; i < n; ++i) scone[i] = (scone[i] + scone[i - 1]) % m;
		std::set<long long int> set;
		long long int result = 0;
		for (const auto s : scone) {
			set.insert(s);
			auto upper = set.upper_bound(s);
			if (upper != set.end()) {
				if (result < m - (*upper) + s) result = m - (*upper) + s;
			}
			else {
				if (result < s) result = s;
			}
		}
		std::cout << result << std::endl;
		std::cin >> n >> m;
	}
}
accuracy: 1
time_ms: 110
memory_kb: 4304
final_rank: 5

code_snippet: #include <string>
#include <vector>
#include <iostream>
#include <queue>
#include <functional>
#include <algorithm>
#include <random>
#include <cmath>
#include <climits>
#include <iomanip>
#include <cfloat>
#include <set>
int main() {
	int n, m; std::cin >> n >> m;
	while (n != 0) {
		std::vector<int> scone(n);
		for (auto &s : scone) std::cin >> s;
		scone[0] %= m;
		for (auto i = 1; i < n; ++i) scone[i] = (scone[i] + scone[i - 1]) % m;
		std::set<int> set;
		int result = 0;
		for (const auto s : scone) {
			set.insert(s);
			auto upper = set.upper_bound(s);
			if (upper != set.end()) {
				if (result < m - (*upper) + s) result = m - (*upper) + s;
			}
			else {
				if (result < s) result = s;
			}
		}
		std::cout << result << std::endl;
		std::cin >> n >> m;
	}
}
accuracy: 0.75
time_ms: 110
memory_kb: 4128
final_rank: 13

code_snippet: #include <set>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
	cin.tie(0);
	ios_base::sync_with_stdio(false);
	int N, M;
	while (cin >> N >> M, N) {
		set<int> s; int S = 0, mn = 1 << 30, ans = 0;
		for (int i = 0; i <= N; ++i) {
			long long X;
			if (i >= 1) cin >> X;
			S = (S + X) % M;
			set<int>::iterator ptr = s.lower_bound(S + 1);
			if (ptr != s.end()) {
				ans = max(ans, S - *ptr + M);
			}
			ans = max(ans, S - mn);
			mn = min(mn, S);
			s.insert(S);
		}
		cout << ans << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 4344
final_rank: 2

code_snippet: #include<iostream>
#include<set>
#include<algorithm>
using namespace std;
typedef long long ll;

int main(){
    int n, m;
    while(cin >> n >> m, n+m){
        ll k[n];
        for(int i = 0; i < n; i++)  cin >> k[i], k[i] %= m;
        for(int i = 1; i < n; i++)  k[i] = (k[i]+k[i-1])%m;
        set<ll> s;
        s.insert(0);
        ll ans = 0;
        for(int i = 0; i < n; i++){
            auto r = s.upper_bound(k[i]);
            if(r == s.end())    r = s.begin();
            ans = max(ans, (k[i]-(*r)+m)%m);
            s.insert(k[i]);
        }
        cout << ans << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 4544
final_rank: 10