Problem:
B: 重さの範囲
問題
重さの異なる $N$ 色のボールがキューにたくさん入っています。キューには、先頭から
$1,2,3, \dots ,N-1,N,1,2,3, \dots ,N-1,N,1,2,3, \dots$ というふうに昇順にボールが並んでいて、
色 $N$ のボールの後ろにはまた色 $1$ のボールから順に入っています。
同じ色のボールはそれぞれ同じ重さであり、色 $i$ のボールの重さは $A_i$ です。
この状態から、キューの先頭からボールを $M$ 個取り出し、これを 1 つのグループとする作業を繰り返します。
そして、キューから取り出した各色のボールの総数がすべて等しくなったときにグループを作る作業をやめます。
なお、キューには十分な数のボールが入っており、グループを作る作業をやめるまでにキューの中身が空になることはありません。
たとえば、
$N=8, M=2$ のとき、{色1,色2}, {色3,色4}, {色5,色6}, {色7,色8} の 4 グループができます
(このとき各色のボールは 1 つずつ存在する)。
$N=4, M=3$ のとき、{色1,色2,色3}, {色4,色1,色2}, {色3,色4,色1}, {色2,色3,色4} の $4$
グループができます (このとき各色のボールはそれぞれ3つずつ存在する)。
このとき、各グループにおいて、
含まれるボールの重さの最大値と最小値の差をそのグループの
重さの範囲
と呼ぶことにします。
各グループの重さの範囲の総和を出力してください。
制約
$1 \le N \le 1000$
$1 \le M \le N$
$0 \le A_i \le 100$
入力は全て整数である
入力形式
入力は以下の形式で与えられます。
$N \ M$
$A_1 \cdots A_N$
出力
答えを 1 行で出力してください。また、末尾に改行も出力してください。
サンプル
サンプル入力 1
8 2
23 61 57 13 91 41 79 41
サンプル出力 1
170
重さの範囲の総和は $38+44+50+38=170$ となります。
サンプル入力 2
4 3
72 46 67 5
サンプル出力 2
222
重さの範囲の総和は $26+67+67+62=222$ となります。
サンプル入力 3
4 2
1 2 3 5
サンプル出力 3
3
重さの範囲の総和は $1+2=3$ となります。

Submitted solutions:

code_snippet: #include<iostream>
#include<queue>
using namespace std;
#define inRange(x,a,b) (a <= x && x < b)

int main(){
    int n, m;
    cin >> n >> m;
    int a[n];
    for(int i = 0; i < n; i++)  cin >> a[i];
    priority_queue<pair<int,int>> l, r;
    int ans = 0, cur = 0;
    do{
        for(int j = 0; j < m; j++)  l.push({-a[cur%n], cur}), r.push({a[cur%n], cur}), cur++;
        while(!inRange(l.top().second, cur-m, cur)) l.pop();
        while(!inRange(r.top().second, cur-m, cur)) r.pop();
        ans += r.top().first+l.top().first;
    }while(cur%n);
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 17888
final_rank: 13

code_snippet: #include <bits/stdc++.h>
                                            #include<iostream>
                                            #include<cstdio>
                                            #include<vector>
                                            #include<queue>
                                            #include<map>
                                            #include<cstring>
                                            #include<string>
                                            #include <math.h>
                                            #include<algorithm>
                                        //    #include <boost/multiprecision/cpp_int.hpp>
                                            #include<functional>
                                   #define int long long
                                            #define inf  1000000007
                                            #define pa pair<int,int>
                                            #define ll long long
                                            #define pal pair<double,double>
                                            #define ppap pair<pa,int>
                                    //  #define PI 3.14159265358979323846
                                            #define paa pair<int,char>
                                            #define  mp make_pair
                                            #define  pb push_back
                                            #define EPS (1e-10)
                                            #define equals(a,b) (fabs((a)-(b))<EPS)
    int dx[4]={0,-1,0,1};
    int dy[4]={1,0,-1,0};
                                            using namespace std;
                                   			class pa3{
                                            	public:
                                            	int x,y,z;
                                            	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
                                            	bool operator < (const pa3 &p) const{
                                            		if(x!=p.x) return x<p.x;
                                            		if(y!=p.y) return y<p.y;
                                            		 return z<p.z;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                   				bool operator > (const pa3 &p) const{
                                            		if(x!=p.x) return x>p.x;
                                            		if(y!=p.y) return y>p.y;
                                            		 return z>p.z;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa3 &p) const{
                                            		return x==p.x && y==p.y && z==p.z;
                                            	}
                                            		bool operator != (const pa3 &p) const{
                                            			return !( x==p.x && y==p.y && z==p.z);
                                            	}
                                            
                                            };
                                            
                                            class pa4{
                                            	public:
                                            	double x;
                                            	int y,z,w;
                                            	pa4(double x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
                                            	bool operator < (const pa4 &p) const{
                                            		if(x!=p.x) return x<p.x;
                                            		if(y!=p.y) return y<p.y;
                                            		if(z!=p.z)return z<p.z;
                                            		return w<p.w;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator > (const pa4 &p) const{
                                            		if(x!=p.x) return x>p.x;
                                            		if(y!=p.y) return y>p.y;
                                            		if(z!=p.z)return z>p.z;
                                            		return w>p.w;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa4 &p) const{
                                            		return x==p.x && y==p.y && z==p.z &&w==p.w;
                                            	}
                                            		
                                            
                                            };
                                            class pa2{
                                            	public:
                                            	int x,y;
                                            	pa2(int x=0,int y=0):x(x),y(y) {}
                                            	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
                                            	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
                                            	bool operator < (const pa2 &p) const{
                                            		return y != p.y ? y<p.y: x<p.x;
                                            	}
                                            	bool operator > (const pa2 &p) const{
                                            		return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa2 &p) const{
                                            		return abs(x-p.x)==0 && abs(y-p.y)==0;
                                            	}
                                            	bool operator != (const pa2 &p) const{
                                            		return !(abs(x-p.x)==0 && abs(y-p.y)==0);
                                            	}
                                            		
                                            
                                            };
                                            
                                                   #define ppa pair<int,pas>
                                            class Point{
                                            	public:
                                            	double x,y;
                                            	Point(double x=0,double y=0):x(x),y(y) {}
                                            	Point operator + (Point p) {return Point(x+p.x,y+p.y);}
                                            	Point operator - (Point p) {return Point(x-p.x,y-p.y);}
                                            	Point operator * (double a) {return Point(x*a,y*a);}
                                            	Point operator / (double a) {return Point(x/a,y/a);}
                                            	double absv() {return sqrt(norm());}
                                            	double norm() {return x*x+y*y;}
                                            	bool operator < (const Point &p) const{
                                            		return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const Point &p) const{
                                            		return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;
                                            	}
                                            };
                                            typedef Point Vector;
                                     #define pl pair<int,pas>
                                            struct Segment{
                                            Point p1,p2;
                                            };
                                             double dot(Vector a,Vector b){
                                            	return a.x*b.x+a.y*b.y;
                                            }
                                            double cross(Vector a,Vector b){
                                            	return a.x*b.y-a.y*b.x;
                                            }
                                        
                bool parareru(Point a,Point b,Point c,Point d){
                //	if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
                	return abs(cross(a-b,d-c))<EPS;
                }
                double distance_ls_p(Point a, Point b, Point c) {
                  if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
                  if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
                  return abs(cross(b-a, c-a)) / (b-a).absv();
                }
                bool is_intersected_ls(Segment a,Segment b) {
                	if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
                	if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&&parareru((a.p2),(a.p1),(a.p1),(b.p1))){
                //		cout<<"sss"<<endl;
                		if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
                		if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
                		if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
                		if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
                		return false;
                	}
                  else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
                }
                 
                double segment_dis(Segment a,Segment b){
                	if(is_intersected_ls(a,b))return 0;
                	double r=distance_ls_p(a.p1, a.p2, b.p1);
                	r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
                	r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
                	r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
                	return r;
                }
                Point intersection_ls(Segment a, Segment b) {
                  Point ba = b.p2-b.p1;
                  double d1 = abs(cross(ba, a.p1-b.p1));
                  double d2 = abs(cross(ba, a.p2-b.p1));
                  double t = d1 / (d1 + d2);
                 
                  return a.p1 + (a.p2-a.p1) * t;
                }
                 
                                string itos( int i ) {
                                ostringstream s ;
                                s << i ;
                                return s.str() ;
                                }
                                 
                                int gcd(int v,int b){
                                	if(v>b) return gcd(b,v);
                                	if(v==b) return b;
                                	if(b%v==0) return v;
                                	return gcd(v,b%v);
                                }
                 
                                double distans(double x1,double y1,double x2,double y2){
                                	double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
                                	return sqrt(rr);
                                	
                                }
                                int mod;
           //     int pr[2000010];
             //   int inv[2000010];
               
                int beki(int wa,int rr,int warukazu){
                	if(rr==0) return 1%warukazu;
                	if(rr==1) return wa%warukazu;
                	if(rr%2==1) return (beki(wa,rr-1,warukazu)*wa)%warukazu;
                	int zx=beki(wa,rr/2,warukazu);
                	return (zx*zx)%warukazu;
                }
                /*
    double bekid(double w,int r){
    	if(r==0) return 1.0;
    	if(r==1) return w;
    	if(r%2) return bekid(w,r-1)*w;
    	double f=bekid(w,r/2);
    	return f*f;
    }
                
    			int comb(int nn,int rr){
    				int r=pr[nn]*inv[rr];
    				r%=mod;
    				r*=inv[nn-rr];
    				r%=mod;
    				return r;
    			}
                
                void gya(int ert){
                	pr[0]=1;
                	for(int i=1;i<ert;i++){
                		pr[i]=(pr[i-1]*i)%mod;
                	}
                	for(int i=0;i<ert;i++) inv[i]=beki(pr[i],mod-2,mod);
                	
                }
                */
              //   cin.tie(0);
    		//	ios::sync_with_stdio(false);
    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            
                 //sort(ve.begin(),ve.end(),greater<int>());
                                         //----------------kokomade tenpure------------
                //vector<double> ans(100000000),ans2(100000000)
string s;
int n,m;
int a[1003]={0};
int b[3];
vector<int> ve;
    signed main(){
               cin.tie(0);
    		ios::sync_with_stdio(false);
    	char e='A';
    	
    	int ans1=0,ans2=0;
    	cin>>n>>m;
    	int g=gcd(n,m);
    	int l=n*m/g;
    	
    	for(int i=0;i<n;i++)cin>>a[i];
    	
 int ans=0;   
    	int c=0;
    	for(int j=0;;j=(j+m)%n){
    		if(j==0 && c!=0) break;
    		int mi=inf,ma=-inf;
    		for(int i=j;i<j+m;i++){
    			mi=min(mi,a[i%n]);
    			ma=max(ma,a[i%n]);
    		}
    		ans+=ma-mi;
    		c++;
    	}
    	cout<<ans<<endl;
    	return 0;
    	
            }
accuracy: 1
time_ms: 10
memory_kb: 3236
final_rank: 7

code_snippet: #include <bits/stdc++.h>
using namespace std;
/*{{{*/  //template
#define rep(i,n) for(int i=0;i<(int)(n);i++)
constexpr int INF = numeric_limits<int>::max()/2;
constexpr long long LINF = numeric_limits<long long>::max()/3;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr<<#x<<":"<<x<<endl
#define debug2(x,y) cerr<<#x<<","<<#y":"<<x<<","<<y<<endl
//struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double{ double d; explicit Double(double x) : d(x){} };
ostream& operator<<(ostream& os,const Double x){ os << fixed << setprecision(20) << x.d; return os; }
template<typename T> ostream& operator<<(ostream& os,const vector<T>& vec){ os << "["; for(const auto& v : vec){ os << v << ","; } os << "]"; return os; }
template<typename T,typename U> ostream& operator<<(ostream& os,const pair<T,U>& p){ os << "(" << p.first << ","<< p.second <<")"; return os; }
template<typename T> ostream& operator<<(ostream& os,const set<T>& st){ os<<"{"; for(T v:st) os<<v<<","; os <<"}"; return os; }
template<typename T,typename U> inline void chmax(T &x,U y){ if(y>x) x = y; }
template<typename T,typename U> inline void chmin(T &x,U y){ if(y<x) x = y; }
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a,ll b){ if(b==0) return a; else return gcd(b,a%b); }
//constexpr double eps = 1e-14; 
constexpr double eps = 1e-10; 
constexpr ll mod = 1e9+7;
const int dx[]={1,0,-1,0} ,dy[] = {0,1,0,-1};
/*}}}*/

int main(){
    ll n,m;
    cin >> n >> m;
    vi a(n);
    rep(i,n) cin >> a[i];

    int lcm = n * m / gcd(n,m);

    vector<int> b(lcm);
    for(int i=0;i<lcm;i++) b[i] = a[i%n];

    int index = 0;
    ll ans = 0;
    while(index < lcm){
        ll max = numeric_limits<ll>::min();
        ll min = numeric_limits<ll>::max();
        for(int i=0;i<m;i++){
            chmax(max,b[index + i]);
            chmin(min,b[index + i]);
        }
        ans += max - min;
        index += m;
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 6520
final_rank: 8

code_snippet: #include <stdio.h>
#include <algorithm>

using namespace std;

int N, M;
int A[1000];
int dp_max[2000][2000];
int dp_min[2000][2000];

int main()
{
	scanf("%d %d", &N, &M);
	for(int i = 0; i < N; i++)
	{
		scanf("%d", &A[i]);
	}

	dp_max[0][0] = A[0];
	dp_min[0][0] = A[0];
	for(int i = 1; i < 2 * N; i++)
	{
		int w = A[i % N];
		dp_max[i][i] = w;
		dp_min[i][i] = w;
		for(int j = 0; j < i; j++)
		{
			dp_max[j][i] = std::max(dp_max[j][i - 1], w);
			dp_min[j][i] = std::min(dp_min[j][i - 1], w);
		}
	}

	long ans = 0;
	for(int i = 0; ; i += M)
	{
		if(i != 0 && i % N == 0) break;
		int j = i % N;
		ans += dp_max[j][j + M - 1] - dp_min[j][j + M - 1];
	}
	printf("%d\n", ans);

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 30100
final_rank: 14

code_snippet: #include<bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
  int n,m;
  cin>>n>>m;
    queue<int>q;
    int a[n],ans=0;
    r(i,n)cin>>a[i];
    int lcm=n*m/__gcd(n,m);
    r(i,lcm)q.push(a[i%n]);
    r(i,lcm){
        int l=1e9,r=0,p;
      for(int k=0;k<m;k++){
        p=q.front();q.pop();
        l=min(l,p);
        r=max(r,p);
        i++;
      }
      ans+=r-l;
      i--;
    }
    cout<<ans<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 6748
final_rank: 9

code_snippet: #include<cstdio>
#include<algorithm>
#include<functional>
using namespace std;
int main(void)
{
	int i,j,p,n,m,a[1000],sum,mi,mx,p2;
	scanf("%d %d",&n,&m);
	for(i=0;i<n;i++)	scanf("%d",&a[i]);
	sum=0;
	p=0;
	while(1)	{
		mi=a[p];	mx=a[p];
		p=(p+1)%n;
		for(i=1;i<m;i++)	{
			mi=min(mi,a[p]);
			mx=max(mx,a[p]);
			p=(p+1)%n;
		}
		sum+=mx-mi;
		if(p==0)	break;
	}
	printf("%d\n",sum);
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 2748
final_rank: 1

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

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
  if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
  if(x > y) x = y;
}


const double EPS = 1e-10;
const double PI  = acos(-1.0);
const LL MOD = 1e9+7;

int main(){
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int N, M; cin >> N >> M;
  VL xs(N);
  REP(i,N) cin >> xs[i];

  int lcm = N * M / __gcd(N, M);
  LL ans = 0;
  set<int> q;
  for(int i=0;i<lcm;++i){
	q.insert(xs[i%N]);
	if((i+1)%M == 0){
	  ans += *--end(q) - *begin(q);
	  q.clear();
	}
  }
  cout << ans << endl;

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

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

int lcm(int a, int b)
{
    return a / std::__gcd(a, b) * b;
}

int main()
{
    int N, M;
    std::cin >> N >> M;
    
    std::vector<int> A(N);
    for (int i = 0; i < N; i++) {
        std::cin >> A[i];
    }
    
    int res = 0;
    int max = INT_MIN, min = INT_MAX;
    for (int i = 0, j = 0; i < lcm(N, M); i++, j++) {
        max = std::max(max, A[i % N]);
        min = std::min(min, A[i % N]);
        
        if (j + 1 == M) {
            res += max - min;
            j = -1;
            max = INT_MIN;
            min = INT_MAX;
        }
    }
    std::cout << res << std::endl;    
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3096
final_rank: 11

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

int lcm(int a, int b)
{
    return a / std::__gcd(a, b) * b;
}

int main()
{
    int N, M;
    std::cin >> N >> M;
    
    std::vector<int> A(N);
    for (int i = 0; i < N; i++) {
        std::cin >> A[i];
    }
    
    long long res = 0;
    int max = INT_MIN, min = INT_MAX;
    for (int i = 0, j = 0; i < lcm(N, M); i++, j++) {
        max = std::max(max, A[i % N]);
        min = std::min(min, A[i % N]);
        
        if (j + 1 == M) {
            res += max - min;
            j = -1;
            max = INT_MIN;
            min = INT_MAX;
        }
    }
    std::cout << res << std::endl;    
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3096
final_rank: 11

code_snippet: #include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define each(a,x) for(auto a : (x))
#define all(a) (a).begin(),(a).end()
#define chmin(a,b) ((a) = min((a),(b)))
#define chmax(a,b) ((a) = max((a),(b)))
#define in_range(x,l,r) ((l)<=(x) && (x)<(r))
#define printvec(a) rep(i,a) cout << a[i] << " \n"[i+1==(a).size()];
#define fs first
#define sc second
#define em emplace
#define eb emplace_back
#define sz size()
#define MP make_pair
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<string> vs;

const ll INF = 1e8;
const D EPS = 1e-8;
const ll MOD = 1e9+7;

int main(){
  ll n,m;
  cin >> n >> m;
  vl a(n);
  rep(i,n) cin >> a[i];

  ll l = n/__gcd(n,m), cur = 0;
  ll sum = 0;
  rep(azu,l){
    ll min_v = a[cur], max_v = a[cur];
    rep(i,m){
      chmin(min_v, a[cur]);
      chmax(max_v, a[cur]);
      cur = (cur + 1) % n;
    }
    sum += max_v - min_v;
  }
  cout << sum << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3080
final_rank: 3

code_snippet: #include<algorithm>
#include<iostream>
#include<vector>
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a)  (a).begin(),(a).end()
#define pb emplace_back

int main(){
    int N,M;
    cin>>N>>M;
    vector<int> A(N);
    rep(i,N)cin>>A[i];
    
    vector<int> v(N);    //v[i]: A[i]~A[i+M-1]?????§?????°????????????????????¨???????????°???????????????
    
    //v[i]????±?????????????( O(N M logM) )
    rep(i,N){
        vector<int> tmp;
        for(int j=i;j<i+M;j++) tmp.pb( A[j%N] );
        
        sort(all(tmp));
        int maxi = tmp[tmp.size()-1];
        int mini = tmp[0];
        
        v[i] = maxi - mini;
    }
    
    int ans = 0;
    int lcm = N*M/__gcd(N,M);
    
    rep(i,lcm/M){   //????\???? LCM(N,M)/M ???????????????LCM(N,M)/M????????°??????????????§??????
        int index = (i*M)%N;
        ans+=v[index];
    }
    cout<<ans<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3144
final_rank: 5

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
 
#define rep(i, n) for (int i = 0; i < int(n); ++i)
typedef long long i64;
 
int gcd(int x, int y) {
	return y ? gcd(y, x % y) : x;
}
 
int a[1000];
 
int main() {
	// your code goes here
	int n, m;
	cin >> n >> m;
	rep(i, n) {
		cin >> a[i];
	}
	// Pick nm/gcd(n, m) = lcm(n, m) times.
	i64 tot = 0;
	int g = gcd(n, m);
	rep(i, n / g) {
		vector<int> t;
		rep(j, m) {
			// (i * m + j) % n -th is taken
			t.push_back(a[(i * m + j) % n]);
		}
		sort(t.begin(), t.end());
		tot += t[t.size() - 1] - t[0];
	}
	cout << tot << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3092
final_rank: 4

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = numeric_limits<int>::max();

int gcd(int a,int b){
  if(b > a)swap(a,b);
  if(a % b == 0)return b;
  else return gcd(b,a%b);
}

int main(void){
  ll n,m;
  ll a[1100];
  cin >> n >> m;
  for(int i = 0;i < n;++i)cin >> a[i];
  int now = 0;
  ll res = 0;
  ll r = (n*m)/gcd(n,m);
  r /= m;
  for(int i = 0;i < r;++i){
    ll ma = 0;
    ll mi = inf;
    for(int j = 0;j < m;++j){
      ma = max(ma,a[now]);
      mi = min(mi,a[now]);
      ++now;
      now %= n;
    }
    res += ma - mi;
  }
  cout << res << endl;
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3048
final_rank: 2

code_snippet: #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define ALL(A) A.begin(), A.end()

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int N, M; cin >> N >> M;
	vector<int> a(N, 0);
	rep (i, N) cin >> a[i];

	int g = __gcd(N, M);
	int L = N * M / g;
	int numGroup = L / M; 

	vector<int> Group[numGroup];
	rep (i, numGroup) Group[i].clear();
	rep (i, L){
		Group[i/M].push_back(a[i%N]);
	} // end rep
	
	rep (i, numGroup){
		sort(ALL(Group[i]));
//		cerr << "max: " << Group[i][Group[i].size() - 1] << " min: " << Group[i][0] << endl; 
	} // end rep


	int res = 0;
	rep (i, numGroup){
		int range = Group[i][Group[i].size() - 1] - Group[i][0];
		res += range;
	} // end rep

	cout << res << endl;

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 6900
final_rank: 10