stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// メモ用の DP テーブル

long long dp[100010];



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];

    

    // 足湯 0 のコストは 0

    if (i == 0) return 0;

    

    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足湯 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足湯 i-2 から来た場合

    

    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;

    

    // 答え

    cout << rec(N-1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.795980348691249x):
#include <iostream>

#include <vector>

using namespace std;



template<class T> inline bool chmin(T& a, T b) {

    if (a > b) {

        a = b;

        return true;

    }

    return false;

}



const long long INF = 1LL << 60; // 十分大きい値とする



// 入力と，メモ用の DP テーブル

int N;

vector<long long> h;

vector<long long> dp;



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];



    // 足場 0 のコストは 0

    if (i == 0) return 0;



    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足場 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足場 i-2 から来た場合



    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    // 入力受け取り

    cin >> N;

    h.resize(N);

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    dp.assign(N, INF);



    // 答え

    cout << rec(N-1) << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// DP テーブル

long long dp[100010];



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));

        if (i > 1) chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N-1] << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.795504863954262x):
#include <iostream>

#include <vector>

using namespace std;



template<class T> inline bool chmin(T& a, T b) {

    if (a > b) {

        a = b;

        return true;

    }

    return false;

}



const long long INF = 1LL << 60; // 十分大きい値とする



// 入力と，メモ用の DP テーブル

int N;

vector<long long> h;

vector<long long> dp;



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];



    // 足場 0 のコストは 0

    if (i == 0) return 0;



    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足場 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足場 i-2 から来た場合



    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    // 入力受け取り

    cin >> N;

    h.resize(N);

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    dp.assign(N, INF);



    // 答え

    cout << rec(N-1) << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// メモ用の DP テーブル

long long dp[100010];



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];

    

    // 足湯 0 のコストは 0

    if (i == 0) return 0;

    

    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足湯 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足湯 i-2 から来た場合

    

    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;

    

    // 答え

    cout << rec(N-1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7829973524641098x):
#include <iostream>

#include <vector>

using namespace std;

const long long INF = 1LL << 60; // 十分大きい値とする



int main() {

    // 入力

    int N; cin >> N;

    vector<long long> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 配列 dp を定義 (配列全体を無限大を表す値に初期化)

    vector<long long> dp(N, INF);



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        if (i == 1) dp[i] = abs(h[i] - h[i - 1]);

        else dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), 

                         dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N - 1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// DP テーブル

long long dp[100010];



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));

        if (i > 1) chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N-1] << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7825253049677088x):
#include <iostream>

#include <vector>

using namespace std;

const long long INF = 1LL << 60; // 十分大きい値とする



int main() {

    // 入力

    int N; cin >> N;

    vector<long long> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 配列 dp を定義 (配列全体を無限大を表す値に初期化)

    vector<long long> dp(N, INF);



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        if (i == 1) dp[i] = abs(h[i] - h[i - 1]);

        else dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), 

                         dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N - 1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// メモ用の DP テーブル

long long dp[100010];



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];

    

    // 足湯 0 のコストは 0

    if (i == 0) return 0;

    

    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足湯 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足湯 i-2 から来た場合

    

    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;

    

    // 答え

    cout << rec(N-1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7874502718277272x):
#include <iostream>

#include <vector>

using namespace std;



template<class T> void chmin(T &a, T b) {

    if (a > b) a = b;

}



const long long INF = 1LL<<60;



int main() {

    int N; cin >> N;

    vector<int> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    vector<long long> dp(N, INF);

    dp[0] = 0;

    

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i-1] + abs(h[i] - h[i-1]));

        if (i > 1) {

            chmin(dp[i], dp[i-2] + abs(h[i] - h[i-2]));

        }   

    }

    

    cout << dp[N-1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// DP テーブル

long long dp[100010];



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));

        if (i > 1) chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N-1] << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7869770454235538x):
#include <iostream>

#include <vector>

using namespace std;



template<class T> void chmin(T &a, T b) {

    if (a > b) a = b;

}



const long long INF = 1LL<<60;



int main() {

    int N; cin >> N;

    vector<int> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    vector<long long> dp(N, INF);

    dp[0] = 0;

    

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i-1] + abs(h[i] - h[i-1]));

        if (i > 1) {

            chmin(dp[i], dp[i-2] + abs(h[i] - h[i-2]));

        }   

    }

    

    cout << dp[N-1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// メモ用の DP テーブル

long long dp[100010];



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];

    

    // 足湯 0 のコストは 0

    if (i == 0) return 0;

    

    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足湯 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足湯 i-2 から来た場合

    

    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;

    

    // 答え

    cout << rec(N-1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7878261550873926x):
#include <iostream>

#include <vector>

using namespace std;



template<class T> void chmin(T &a, T b) {

    if (a > b) a = b;

}



const long long INF = 1LL<<60;



int main() {

    int N; cin >> N;

    vector<int> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    vector<long long> dp(N, INF);

    dp[0] = 0;

    

    for (int i = 0; i < N; ++i) {

        if (i + 1 < N) {

            chmin(dp[i + 1], dp[i] + abs(h[i] - h[i+1]));

        }

        if (i + 2 < N) {

            chmin(dp[i + 2], dp[i] + abs(h[i] - h[i+2]));

        }

    }

    

    cout << dp[N-1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// DP テーブル

long long dp[100010];



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));

        if (i > 1) chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N-1] << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7873528291683483x):
#include <iostream>

#include <vector>

using namespace std;



template<class T> void chmin(T &a, T b) {

    if (a > b) a = b;

}



const long long INF = 1LL<<60;



int main() {

    int N; cin >> N;

    vector<int> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    vector<long long> dp(N, INF);

    dp[0] = 0;

    

    for (int i = 0; i < N; ++i) {

        if (i + 1 < N) {

            chmin(dp[i + 1], dp[i] + abs(h[i] - h[i+1]));

        }

        if (i + 2 < N) {

            chmin(dp[i + 2], dp[i] + abs(h[i] - h[i+2]));

        }

    }

    

    cout << dp[N-1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// メモ用の DP テーブル

long long dp[100010];



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];

    

    // 足湯 0 のコストは 0

    if (i == 0) return 0;

    

    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足湯 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足湯 i-2 から来た場合

    

    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;

    

    // 答え

    cout << rec(N-1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7958635296711718x):
#include <iostream>

#include <vector>

using namespace std;

const long long INF = 1LL<<60; // 無限大を表す値 (十分大きい値に定める)



// 入力

int N;

vector<long long> h;



// メモ化配列

vector<long long> dp;



long long rec(int i) {

    // 終端条件

    if (i == 0) return 0;



    // 計算済みならば返す

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



    long long result = INF;

    if (i - 1 >= 0) result = min(result, rec(i-1) + abs(h[i] - h[i-1]));

    if (i - 2 >= 0) result = min(result, rec(i-2) + abs(h[i] - h[i-2]));

    

    // 答えをメモ化しながら返す

    return dp[i] = result;

}



int main() {

    cin >> N;

    h.resize(N);

    for (int i = 0; i < N; ++i) cin >> h[i];

    dp.assign(N+1, -1); // メモ化用配列を初期化

    cout << rec(N-1) << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// DP テーブル

long long dp[100010];



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));

        if (i > 1) chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N-1] << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7953880758619514x):
#include <iostream>

#include <vector>

using namespace std;

const long long INF = 1LL<<60; // 無限大を表す値 (十分大きい値に定める)



// 入力

int N;

vector<long long> h;



// メモ化配列

vector<long long> dp;



long long rec(int i) {

    // 終端条件

    if (i == 0) return 0;



    // 計算済みならば返す

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



    long long result = INF;

    if (i - 1 >= 0) result = min(result, rec(i-1) + abs(h[i] - h[i-1]));

    if (i - 2 >= 0) result = min(result, rec(i-2) + abs(h[i] - h[i-2]));

    

    // 答えをメモ化しながら返す

    return dp[i] = result;

}



int main() {

    cin >> N;

    h.resize(N);

    for (int i = 0; i < N; ++i) cin >> h[i];

    dp.assign(N+1, -1); // メモ化用配列を初期化

    cout << rec(N-1) << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// メモ用の DP テーブル

long long dp[100010];



long long rec(int i) {

    // DP の値が更新されていたらそのままリターン

    if (dp[i] < INF) return dp[i];

    

    // 足湯 0 のコストは 0

    if (i == 0) return 0;

    

    // i-1, i-2 それぞれ試す

    long long res = INF;

    chmin(res, rec(i-1) + abs(h[i] - h[i - 1])); // 足湯 i-1 から来た場合

    if (i > 1) chmin(res, rec(i-2) + abs(h[i] - h[i - 2])); // 足湯 i-2 から来た場合

    

    // 結果をメモしながら、返す

    return dp[i] = res;

}



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];

    

    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;

    

    // 答え

    cout << rec(N-1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7834494855898049x):
#include <iostream>

#include <vector>

using namespace std;

const long long INF = 1LL<<60; // 無限大を表す値 (十分大きい値に定める)



int main() {

    int N;

    cin >> N;

    vector<long long> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];



    vector<long long> dp(N, INF);

    dp[0] = 0;

    for (int i = 1; i < N; ++i) {

        if (i-1 >= 0) 

            dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]));

        if (i-2 >= 0)

            dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]));

    }

    cout << dp[N-1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

#include <cstdlib>

using namespace std;

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

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



const long long INF = 1LL << 60;



// 入力

int N;

long long h[100010];



// DP テーブル

long long dp[100010];



int main() {

    int N; cin >> N;

    for (int i = 0; i < N; ++i) cin >> h[i];



    // 初期化 (最小化問題なので INF に初期化)

    for (int i = 0; i < 100010; ++i) dp[i] = INF;



    // 初期条件

    dp[0] = 0;



    // ループ

    for (int i = 1; i < N; ++i) {

        chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));

        if (i > 1) chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));

    }



    // 答え

    cout << dp[N-1] << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.782977318391426x):
#include <iostream>

#include <vector>

using namespace std;

const long long INF = 1LL<<60; // 無限大を表す値 (十分大きい値に定める)



int main() {

    int N;

    cin >> N;

    vector<long long> h(N);

    for (int i = 0; i < N; ++i) cin >> h[i];



    vector<long long> dp(N, INF);

    dp[0] = 0;

    for (int i = 1; i < N; ++i) {

        if (i-1 >= 0) 

            dp[i] = min(dp[i], dp[i-1] + abs(h[i] - h[i-1]));

        if (i-2 >= 0)

            dp[i] = min(dp[i], dp[i-2] + abs(h[i] - h[i-2]));

    }

    cout << dp[N-1] << endl;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

using namespace std;

int n;

vector<int> h(100000);

vector<int> cost(100000);



int ans(int n)

{

    if (cost.at(n) != -1)

        return cost.at(n);

    cost.at(n) = min(ans(n - 1) + abs(h.at(n) - h.at(n - 1)), ans(n - 2) + abs(h.at(n) - h.at(n - 2)));

    return cost.at(n);

}



int main()

{

    cin >> n;

    for (int i = 0; i < n; i++)

    {

        cin >> h.at(i);

        cost.at(i) = -1;

    }

    cost.at(0) = 0;

    cost.at(1) = abs(h.at(1) - h.at(0));

    cout << ans(n - 1) << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.7955343519274236x):
#include <bits/stdc++.h>

using namespace std;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

typedef long long int ll;

int main()

{

    int n;

    cin >> n;

    vector<int> h(n);

    vector<ll> dp(n + 10, 1e15);

    rep(i, n)

    {

        cin >> h[i];

    }

    dp[0] = 0;

    rep(i, n)

    {

        dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));

        dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));

    }

    cout << dp[n - 1] << endl;

}
// Slower C++ solution:
// freopen("input.txt", "rt", stdin);

// freopen("output.txt", "wt", stdout);

//#define _GLIBCXX_DEBUG//only for debugging

/*BISMILLAH UR RAHMAN*/ 

#include <bits/stdc++.h>

#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cout<<fixed<<setprecision(10);

#define endl "\n"

#define pb push_back

#define all(v) v.begin(),v.end()

#define debug(x) std::cerr << #x << ": " << (x) << '\n';

#define sz(x) int(x.size())

#define INF INT_MAX;

using namespace std;

typedef long long int ll;

typedef pair<ll,ll> ii;

int arr[int(1e5+10)];

int cnt[int(1e5+10)];

int dp(int n)

{

  if(n<=0)return int(1e9+1);

  if(cnt[n]!=-1)return cnt[n];

  int ans=INF;

  ans=min(abs(arr[n]-arr[n-2])+dp(n-2),abs(arr[n]-arr[n-1])+dp(n-1));

  return cnt[n]=ans;



}

int main()

{  

  fast

  int n;

  cin>>n;

  for(int i=1;i<=n;++i)cin>>arr[i];

  memset(cnt,-1,sizeof(cnt));

  cnt[1]=0;

  cout<<dp(n);



  

  



}

// Faster C++ solution for the same problem (measured speedup: 1.3934651337352286x):
// freopen("input.txt", "rt", stdin);

// freopen("output.txt", "wt", stdout);

//#define _GLIBCXX_DEBUG//only for debugging

/*BISMILLAH UR RAHMAN*/ 

#include <bits/stdc++.h>

#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cout<<fixed<<setprecision(10);

#define endl "\n"

#define pb push_back

#define all(v) v.begin(),v.end()

#define debug(x) std::cerr << #x << ": " << (x) << '\n';

#define sz(x) int(x.size())

#define INF INT_MAX;

using namespace std;

typedef long long int ll;

typedef pair<ll,ll> ii;

int arr[int(1e5+10)];

int dp[int(1e5+10)];

int main()

{  

  fast

  int n;

  cin>>n;

  for(int i=1;i<=n;++i)cin>>arr[i];

  dp[1]=0;dp[2]=abs(arr[2]-arr[1]);

  for(int i=3;i<=n;++i)

  {

    dp[i]=min(abs(arr[i]-arr[i-2])+dp[i-2],abs(arr[i]-arr[i-1])+dp[i-1]);



  }

 cout<<dp[n]<<endl;

  

  



}