Problem:
鉄道旅行 (Railroad Trip)
JOI 国には
N
個の都市があり，それぞれ 1, 2, . . . ,
N
の番号が付けられている．また，鉄道が
N
− 1 本あり，それぞれ 1, 2, . . . ,
N
− 1 の番号が付けられている．鉄道 i (1 ≤
i
≤
N
− 1) は，都市
i
と都市
i
+ 1 を双方向に結んでいる．
JOI 国の鉄道に乗車する方法として，紙の切符で乗車する方法と，IC カードで乗車する方法がある．
鉄道
i
に紙の切符で乗車する場合の運賃は
A
i
円である．
鉄道
i
に IC カードで乗車する場合の運賃は
B
i
円である．ただし，IC カードで鉄道
i
に乗車するには，鉄道
i
で使える IC カードを事前に購入しておく必要がある．鉄道
i
で使える IC カードを購入するには
C
i
円かかる．一度購入した IC カードは，何度でも使用することができる．
IC カードの方が金額の処理が簡単になるため，IC カードで乗車する場合の運賃の方が紙の切符で乗車する場合の運賃よりも安い．すなわち，
i
= 1, 2, . . . ,
N
− 1 に対して，
A
i
>
B
i
が成り立つ．IC カードの仕様は鉄道ごとにすべて異なるため，どの
i
に対しても，鉄道
i
で使える IC カードを他の鉄道で使用することはできない．
あなたは，JOI 国じゅうを旅行することにした．都市
P
1
から出発し，
P
2
,
P
3
, . . . ,
P
M
の順に都市を訪れる予定である．旅行は
M
− 1 日間の行程からなる．
j
日目 (1 ≤
j
≤
M
− 1) に都市
P
j
から都市
P
j+1
に鉄道で移動する．この際，いくつかの鉄道を乗り継いで移動することもある．また，同じ都市を二度以上訪れることがあるかもしれない．JOI 国の鉄道は速いので，どの都市からどの都市へも 1 日で移動することができる．
あなたは現在，どの鉄道の IC カードも持っていない．あなたは，あらかじめ，いくつかの鉄道の IC カー
ドを購入し，この旅行にかかる金額，すなわち，IC カード購入費用と乗車した鉄道の運賃の和をできるだけ少なくしたい．
課題
JOI 国の都市の数，旅行の行程，および JOI 国のそれぞれの鉄道の運賃と IC カードの価格が与えられる．このとき，旅行にかかる金額の最小値を求めるプログラムを作成せよ．
入力
標準入力から以下のデータを読み込め．
1 行目には，整数
N
,
M
が空白を区切りとして書かれている．これらはそれぞれ，JOI 国に都市が
N
個あり，旅行が
M
− 1 日間の行程からなることを表す.
2 行目には，
M
個の整数
P
1
,
P
2
, . . . ,
P
M
が空白を区切りとして書かれている．これらは，
j
日目 (1 ≤
j
≤
M
− 1) に都市
P
j
から都市
P
j+1
に鉄道で移動することを表す．
続く
N
− 1 行のうちの
i
行目 (1 ≤
i
≤
N
− 1) には，3 つの整数
A
i
,
B
i
,
C
i
が空白を区切りとして書かれている．これらはそれぞれ，鉄道
i
に紙の切符で乗車したときの運賃が
A
i
円，IC カードで乗車したときの運賃が
B
i
円，鉄道
i
で使える IC カードの金額が
C
i
円であることを表す．
出力
標準出力に，旅行にかかる金額の最小値を円単位で表す整数を 1 行で出力せよ．
制限
すべての入力データは以下の条件を満たす．
2 ≤
N
≤ 100 000．
2 ≤
M
≤ 100 000．
1 ≤
B
i
<
A
i
≤ 100 000 (1 ≤
i
≤
N
− 1)．
1 ≤
C
i
≤ 100 000 (1 ≤
i
≤
N
− 1)．
1 ≤
P
j
≤
N
(1 ≤
j
≤
M
)．
P
j
≠
P
j+1
(1 ≤
j
≤
M
− 1).
入出力例
入力例 1
4 4
1 3 2 4
120 90 100
110 50 80
250 70 130
出力例 1
550
この場合，旅行にかかる金額を最小にする方法は以下のとおりである．
鉄道 2 と鉄道 3 の IC カードを購入する．これには 80 + 130 = 210 円かかる．
1 日目に，都市 1 から都市 2 まで紙の切符を使って移動し，次に都市 2 から都市 3 まで IC カードを使って移動する．これには 120 + 50 = 170 円かかる．
2 日目に，都市 3 から都市 2 まで IC カードを使って移動する．これには 50 円かかる．
3 日目に，都市 2 から都市 3 まで IC カードを使って移動し，次に都市 3 から都市 4 まで IC カードを使って移動する．これには 50 + 70 = 120 円かかる．
このように移動すると，旅行にかかる金額の合計は 210 + 170 + 50 + 120 = 550 円となる．これが最小であるので，550 と出力する．
入力例 2
8 5
7 5 3 5 4
12 5 8
16 2 1
3 1 5
17 12 17
19 7 5
12 2 19
4 1 3
出力例 2
81
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

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

int sum[100000], p[100000];
int main() {
	int n, m; scanf("%d%d", &n, &m);
	rep(i, m) {
		scanf("%d", &p[i]); p[i]--;
		if (i) {
			sum[min(p[i], p[i - 1])]++;
			sum[max(p[i], p[i - 1])]--;
		}
	}
	ll ans = 0;
	rep(i, n - 1) {
		if (i)sum[i] += sum[i - 1];
		ll a, b, c; scanf("%lld%lld%lld", &a, &b, &c);
		ans += min(sum[i] * a, c + sum[i] * b);
	}
	printf("%lld\n", ans);
}
accuracy: 1
time_ms: 20
memory_kb: 4336
final_rank: 1

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<utility>
#include<set>
#include<deque>
#include <unordered_map>
#include<string>
#include<cmath>

using namespace std;

int MIN = -1e9;
const int MOD = 10000;

int main() {
	int N,M;
	cin >> N>>M;
	vector<long long>R(N,0);
	vector<vector<long long>>L(N - 1, vector<long long>(3,0));
	long long x, y;
	cin >> y;
	
	for (int i = 1; i < M; i++) {
		cin >> x;
		long long x2 = x;
		if (y > x) {
			swap(y, x);
		}
		R[y - 1] += 1;
		R[x - 1] -= 1;
		y = x2;
	}
	for (int i = 0; i < N - 1; i++) {	
		cin >> L[i][0] >> L[i][1] >> L[i][2];
	}
	
	for (int i = 1; i < N - 1; i++) {
		R[i] += R[i - 1];
		
	}
	long long ans = 0;
	
	for (int i = 0; i < N - 1; i++) {
		long long nk = R[i] * L[i][0];
		long long k= R[i] * L[i][1]+L[i][2];
		
		ans += min(nk, k);
	}

	cout << ans<<endl;
}
accuracy: 1
time_ms: 60
memory_kb: 9432
final_rank: 17

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include<utility>
#include<set>
#include<deque>
#include <unordered_map>
#include<string>
#include<cmath>

using namespace std;

int MIN = -1e9;
const int MOD = 10000;

int main() {
	int N,M;
	cin >> N>>M;
	vector<long long>R(N,0);
	vector<vector<long long>>L(N - 1, vector<long long>(3,0));
	long long x, y;
	cin >> y;
	
	for (int i = 1; i < M; i++) {
		cin >> x;
		long long x2 = x;
		if (y > x) {
			swap(y, x);
		}
		R[y - 1] += 1;
		R[x - 1] -= 1;
		y = x2;
	}
	for (int i = 0; i < N - 1; i++) {	
		cin >> L[i][0] >> L[i][1] >> L[i][2];
	}
	
	for (int i = 1; i < N - 1; i++) {
		R[i] += R[i - 1];
		
	}
	long long ans = 0;
	
	for (int i = 0; i < N - 1; i++) {
		int nk = R[i] * L[i][0];
		int k= R[i] * L[i][1]+L[i][2];
		
		ans += min(nk, k);
	}

	cout << ans<<endl;
}
accuracy: 0.6176470588235294
time_ms: 60
memory_kb: 9368
final_rank: 19

code_snippet: #include <iostream>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <cstdlib>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

int main(){
  int n,m;
  cin >> n >> m;
  vector<int> p(m);
  rep(i,m){
    cin >> p[i];
    p[i]--; //0-based
  }
  vector<int> a(n-1),b(n-1),c(n-1);
  rep(i,n-1){
    cin >> a[i] >> b[i] >> c[i];
  }

  vector<int> cnt(n,0);
  rep(i,m-1){
    if(p[i]<p[i+1]){
      cnt[p[i]]++;
      cnt[p[i+1]]--;
    }
    else{
      cnt[p[i+1]]++;
      cnt[p[i]]--;
    }
  }
  vector<long long> res(n,0);
  res[0]=cnt[0];
  rep(i,n-1){
    res[i+1]=res[i]+cnt[i+1];
  }

  long long ans=0;
  rep(i,n-1){
    ans += min(a[i]*res[i],b[i]*res[i]+c[i]);
  }
  cout << ans << endl;
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 5752
final_rank: 14

code_snippet: #include <iostream>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <cstdlib>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

int main(){
  int n,m;
  cin >> n >> m;
  vector<int> p(m);
  rep(i,m){
    cin >> p[i];
    p[i]--; //0-based
  }
  vector<int> a(n-1),b(n-1),c(n-1);
  rep(i,n-1){
    cin >> a[i] >> b[i] >> c[i];
  }

  vector<int> cnt(n,0);
  rep(i,m-1){
    if(p[i]<p[i+1]){
      cnt[p[i]]++;
      cnt[p[i+1]]--;
    }
    else{
      cnt[p[i+1]]++;
      cnt[p[i]]--;
    }
  }
  vector<int> res(n,0);
  res[0]=cnt[0];
  rep(i,n-1){
    res[i+1]=res[i]+cnt[i+1];
  }

  long long ans=0;
  rep(i,n-1){
    ans += min(a[i]*res[i],b[i]*res[i]+c[i]);
  }
  cout << ans << endl;
  return 0;
}
accuracy: 0.6176470588235294
time_ms: 60
memory_kb: 5460
final_rank: 18

code_snippet: #include <iostream>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <cstring> // for memset
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

int main() {
    int N, M;
    cin >> N >> M;

    // 動的配列を使用して、各駅でのカウントを格納するための配列を確保
    vector<ll> countTable(N + 1, 0);

    // スケジュールを格納する配列を確保
    vector<int> schedule(M);
    for(int i = 0; i < M; i++) {
        cin >> schedule[i];
    }

    // 各区間のコストに関する配列を確保
    vector<ll> A(N), B(N), C(N);

    // コスト情報を入力
    for(int i = 1; i < N; i++) {
        cin >> A[i] >> B[i] >> C[i];
    }

    // スケジュールに基づいてカウントテーブルを更新
    for(int i = 0; i < M - 1; i++) {
        int from = schedule[i];
        int to = schedule[i + 1];
        if(from > to) {
            swap(from, to);
        }
        countTable[from]++;
        countTable[to]--;
    }

    // カウントテーブルの累積和を計算
    for(int i = 2; i < N; i++) {
        countTable[i] += countTable[i - 1];
    }

    ll ans = 0;

    // 各区間のコストを計算して合計
    for(int i = 1; i < N; i++) {
        if(countTable[i] * (A[i] - B[i]) - C[i] > 0) {
            ans += B[i] * countTable[i] + C[i];
        } else {
            ans += A[i] * countTable[i];
        }
    }

    // 最終結果を出力
    cout << ans << endl;

    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 6508
final_rank: 16

code_snippet: #line 1 "/opt/library/template.hpp"
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using i64 = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using f128 = __float128;

template <class T>
constexpr T infty = 0;
template <>
constexpr int infty<int> = 1'000'001'000;
template <>
constexpr ll infty<ll> = ll(infty<int>) * infty<int> * 2;
template <>
constexpr u32 infty<u32> = infty<int>;
template <>
constexpr u64 infty<u64> = infty<ll>;
template <>
constexpr i128 infty<i128> = i128(infty<ll>) * infty<ll>;
template <>
constexpr double infty<double> = infty<ll>;
template <>
constexpr long double infty<long double> = infty<ll>;
#define inf infty<ll>

using pi = pair<ll, ll>;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vector<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <class T>
using vvvvvc = vector<vvvvc<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;

#define vv(type, name, h, ...) \
  vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define vvv(type, name, h, w, ...)   \
  vector<vector<vector<type>>> name( \
      h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)       \
  vector<vector<vector<vector<type>>>> name( \
      a, vector<vector<vector<type>>>(       \
             b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))

#define rep1(a) for (ll _ = 0; _ < (ll)(a); ++_)
#define rep2(i, a) for (ll i = 0; i < (ll)(a); ++i)
#define rep3(i, a, b) for (ll i = a; i < (ll)(b); ++i)
#define rep4(i, a, b, c) for (ll i = a; i < (ll)(b); i += (c))
#define rrep1(a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep2(i, a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep3(i, a, b) for (ll i = (b)-1; i >= (ll)(a); --i)
#define rrep4(i, a, b, c) for (ll i = (b)-1; i >= (ll)(a); i -= (c))
#define overload4(a, b, c, d, e, ...) e
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)

#define all(x) (x).begin(),(x).end()
#define len(x) (ll)(x.size())
#define elif else if
#define bit(x, i) (((x)>>(i))&1)

#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second

#define stoi stoll
#define abs llabs

#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define LB(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define UB(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define UNIQUE(x) \
  sort(all(x)), x.erase(unique(all(x)), x.end()), x.shrink_to_fit()

ll popcnt(ll x) { return __builtin_popcountll(x); }
ll popcnt(u64 x) { return __builtin_popcountll(x); }
ll popcnt_mod_2(ll x) { return __builtin_parityll(x); }
ll popcnt_mod_2(u64 x) { return __builtin_parityll(x); }
ll topbit(ll x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll topbit(u64 x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll lowbit(ll x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }
ll lowbit(u64 x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }

template <typename T>
T floor(T a, T b) {
  return a / b - (a % b && (a ^ b) < 0);
}
template <typename T>
T ceil(T x, T y) {
  return floor(x + y - 1, y);
}
template <typename T>
T bmod(T x, T y) {
  return x - y * floor(x, y);
}
template <typename T>
pair<T, T> divmod(T x, T y) {
  T q = floor(x, y);
  return {q, x - q * y};
}

template<typename T> T SUM(const vector<T> &A) {
  T s = 0; for (auto &&a: A) s += a;
  return s;
}

// A[I[0]], A[I[1]], ...
template <typename T>
vc<T> rearrange(const vc<T> &A, const vi &I) {
  vc<T> B(len(I));
  rep(i, len(I)) B[i] = A[I[i]];
  return B;
}

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

inline void wt(const char c) { cout << c; }
inline void wt(const string s) { cout << s; }
inline void wt(const char *s) { cout << s; }

template <typename T>
void wt_integer(T x) {
  if (x < 0) { cout << (i64)(x); }
  else { cout << (u64)(x); }
}
template <typename T>
void wt_real(T x) {
  cout << fixed << setprecision(15) << (long double)(x);
}

inline void wt(int x) { wt_integer(x); }
inline void wt(ll x) { wt_integer(x); }
inline void wt(i128 x) { wt_integer(x); }
inline void wt(u32 x) { wt_integer(x); }
inline void wt(u64 x) { wt_integer(x); }
inline void wt(u128 x) { wt_integer(x); }
inline void wt(double x) { wt_real(x); }
inline void wt(long double x) { wt_real(x); }
inline void wt(f128 x) { wt_real(x); }

template <class T, class U>
void wt(const pair<T, U> val) {
  wt(val.first); wt(' '); wt(val.second);
}
template <size_t N = 0, typename T>
void wt_tuple(const T t) {
  if constexpr (N < std::tuple_size<T>::value) {
    if constexpr (N > 0) { wt(' '); }
    const auto x = std::get<N>(t);
    wt(x);
    wt_tuple<N + 1>(t);
  }
}
template <class... T>
void wt(tuple<T...> tpl) {
  wt_tuple(tpl);
}
template <class T, size_t S>
void wt(const array<T, S> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}
template <class T>
void wt(const vector<T> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}

void print() { wt('\n'); }
template <class Head, class... Tail>
void print(Head &&head, Tail &&... tail) {
  wt(head);
  if (sizeof...(Tail)) wt(' ');
  print(forward<Tail>(tail)...);
}

void YES(bool t = 1) { print(t ? "YES" : "NO"); }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = 1) { print(t ? "Yes" : "No"); }
void No(bool t = 1) { Yes(!t); }
void yes(bool t = 1) { print(t ? "yes" : "no"); }
void no(bool t = 1) { yes(!t); }
void onez(bool t = 1) { print(t ? 1 : 0); }
#define endl '\n'
#define dump(x) {cerr << #x " = " << x << '\n';}
#line 2 "main.cpp"

int solve();
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  while (!solve()) {break;}
  return 0;
}

int solve() {
  ll N, M;
  cin >> N >> M;
  vi P(M), A(N-1), B(N-1), C(N-1);
  rep(i, M) {
    cin >> P[i];
    P[i]--;
  }
  rep(i, N-1) cin >> A[i] >> B[i] >> C[i];
  vi s(N, 0);
  rep(i, M-1) {
    ll a = P[i];
    ll b = P[i+1];
    if (a > b) swap(a, b);
    s[a]++; s[b]--;
  }
  rep(i, 1, N) {
    s[i] += s[i-1];
  }
  ll ans = 0;
  rep(i, N-1) {
    ans += min(A[i]*s[i], B[i]*s[i]+C[i]);
  }
  print(ans);
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 7008
final_rank: 3

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

using namespace std;

struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      Add(a, b, x, 2 * k + 1, l, (l + r) / 2);
      Add(a, b, x, 2 * k + 2, (l + r) / 2, r);
      seg[k] = seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return 0;
    if (a <= l && r <= b)
      return seg[k] + add[k];
    return Query(a, b, 2 * k + 1, l, (l + r) / 2) + Query(a, b, 2 * k + 2, (l + r) / 2, r) + add[k];
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return Query(a, b, 0, 0, sz); }
};

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

  int N, M, P[100000];
  scanf("%d %d", &N, &M);
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    scanf("%d", &P[i]);
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    scanf("%d %d %d", &A, &B, &C);
    ret += min(used * A, C + used * B);
  }
  cout << ret << '\n';
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 5224
final_rank: 12

code_snippet: #include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 1e5+5;
int seg[MAXN << 2] = {0}, add[MAXN << 2] = {0}, P[MAXN], u[MAXN], v[MAXN];
void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
        return;
    } else if (a <= l && r <= b) {
        add[k] += x;
    } else {
        Add(a, b, x, 2 * k + 1, l, (l + r) / 2);
        Add(a, b, x, 2 * k + 2, (l + r) / 2, r);
        seg[k] = seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
    }
}
int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
        return (0);
    if (a <= l && r <= b)
        return (seg[k] + add[k]);
    return (Query(a, b, 2 * k + 1, l, (l + r) / 2) +
            Query(a, b, 2 * k + 2, (l + r) / 2, r) + add[k]);
}
int main() {
    int N, M;
    scanf("%d %d", &N, &M);
    for (int i = 0; i < M; i++) {
        scanf("%d", &P[i]);
        --P[i];
    }
    for (int i = 1; i < M; i++) {
        u[i] = min(P[i - 1], P[i]), v[i] = max(P[i - 1], P[i]);
        Add(u[i], v[i], 1, 0, 0, N);
    }
    long long ret = 0;
    for (int i = 0; i < N - 1; i++) {
        long long used = Query(i, i + 1, 0, 0, N);
        int A, B, C;
        scanf("%d %d %d", &A, &B, &C);
        ret += min(used * A, C + used * B);
    }
    printf("%lld\n", ret);
    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 5420
final_rank: 13

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

#define MAXN 100003

struct SegmentTree {
    int seg[4 * MAXN] = {0}, add[4 * MAXN] = {0};
    int sz;

    SegmentTree(int n) {
        sz = 1;
        while (sz < n)
            sz *= 2;
    }

    void Add(int a, int b, int x, int k, int l, int r) {
        if (a >= r || b <= l) {
            return;
        } else if (a <= l && r <= b) {
            add[k] += x;
        } else {
            int mid = (l + r) / 2;
            Add(a, b, x, 2 * k + 1, l, mid);
            Add(a, b, x, 2 * k + 2, mid, r);
            seg[k] = seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
        }
    }

    int Query(int a, int b, int k, int l, int r) {
        if (a >= r || b <= l)
            return 0;
        if (a <= l && r <= b)
            return seg[k] + add[k];
        int mid = (l + r) / 2;
        return Query(a, b, 2 * k + 1, l, mid) + Query(a, b, 2 * k + 2, mid, r) + add[k];
    }

    void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
    int Query(int a, int b) { return Query(a, b, 0, 0, sz); }
};

int main() {
    int N, M, P[MAXN];
    scanf("%d %d", &N, &M);
    SegmentTree segtree(N);
    for (int i = 0; i < M; i++) {
        scanf("%d", &P[i]);
        --P[i];
    }
    for (int i = 1; i < M; i++) {
        int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
        segtree.Add(u, v, 1);
    }
    long long ret = 0;
    for (int i = 0; i < N - 1; i++) {
        long long used = segtree.Query(i, i + 1);
        int A, B, C;
        scanf("%d %d %d", &A, &B, &C);
        ret += min(used * A, C + used * B);
    }
    printf("%lld\n", ret);
    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 6304
final_rank: 15

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (__builtin_expect((a >= r || b <= l), 0)) {
      return;
    } else if (__builtin_expect((a <= l && r <= b), 0)) {
      add[k] += x;
    } else {
      Add(a, b, x, 2 * k + 1, l, (l + r) / 2);
      Add(a, b, x, 2 * k + 2, (l + r) / 2, r);
      seg[k] =
          seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (__builtin_expect((a <= l && r <= b), 1))
      return (seg[k] + add[k]);
    if (__builtin_expect((a >= r || b <= l), 0))
      return 0;
    return (Query(a, b, 2 * k + 1, l, (l + r) / 2) +
            Query(a, b, 2 * k + 2, (l + r) / 2, r) + add[k]);
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return (Query(a, b, 0, 0, sz)); }
};
int main() {
  int N, M, P[100000];
  scanf("%d %d", &N, &M);
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    scanf("%d", &P[i]);
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i+= 2) {
    long long used1 = segtree.Query(i, i + 1);
    long long used2 = i + 1 < N - 1 ? segtree.Query(i+1, i + 2) : 0;
    int A1, B1, C1, A2, B2, C2;
    scanf("%d %d %d", &A1, &B1, &C1);
    if (i + 1 < N - 1)
        scanf("%d %d %d", &A2, &B2, &C2);
    ret += min(used1 * A1, C1 + used1 * B1);
    if (i + 1 < N - 1)
        ret += min(used2 * A2, C2 + used2 * B2);
  }
  cout << ret << endl;
}
accuracy: 1
time_ms: 60
memory_kb: 5208
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      Add(a, b, x, 2 * k + 1, l, (l + r) / 2);
      Add(a, b, x, 2 * k + 2, (l + r) / 2, r);
      int left = seg[2 * k + 1] + add[2 * k + 1];  // Compute once, reuse
      int right = seg[2 * k + 2] + add[2 * k + 2]; // Compute once, reuse
      seg[k] = left + right;
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return (0);
    if (a <= l && r <= b)
      return (seg[k] + add[k]);
    return (Query(a, b, 2 * k + 1, l, (l + r) / 2) +
            Query(a, b, 2 * k + 2, (l + r) / 2, r) + add[k]);
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return (Query(a, b, 0, 0, sz)); }
};
int main() {
  ios_base::sync_with_stdio(false); // Make cin and cout faster
  cin.tie(NULL);
  int N, M, P[100000];
  cin >> N >> M;
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    cin >> P[i];
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  int ret = 0; // Replace long long with int
  for (int i = 0; i < N - 1; i++) {
    int used = segtree.Query(i, i + 1);
    int A, B, C;
    cin >> A >> B >> C;
    ret += min(used * A, C + used * B);
  }
  cout << ret << endl;
}
accuracy: 0.5882352941176471
time_ms: 20
memory_kb: 4952
final_rank: 20

code_snippet: #pragma GCC optimize ("Ofast")
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    }
    if (a <= l && r <= b) {
      add[k] += x;
    } else {
      int mid = (l + r) / 2;
      Add(a, b, x, 2 * k + 1, l, mid);
      Add(a, b, x, 2 * k + 2, mid, r);
      seg[k] = seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return 0;
    if (a <= l && r <= b)
      return seg[k] + add[k];
    int mid = (l + r) / 2;
    return Query(a, b, 2 * k + 1, l, mid) + Query(a, b, 2 * k + 2, mid, r) + add[k];
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return Query(a, b, 0, 0, sz); }
};

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int N, M, P[100000];
  scanf("%d %d", &N, &M);
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    scanf("%d", &P[i]);
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    scanf("%d %d %d", &A, &B, &C);
    ret += min(used * A, C + used * B);
  }
  printf("%lld\n", ret);
}
accuracy: 1
time_ms: 60
memory_kb: 5204
final_rank: 10

code_snippet: #include <iostream>
#include <vector>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      int mid = (l + r) / 2;
      int k1 = 2 * k + 1, k2 = 2 * k + 2;
      Add(a, b, x, k1, l, mid);
      Add(a, b, x, k2, mid, r);
      seg[k] = seg[k1] + add[k1] + seg[k2] + add[k2];
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return (0);
    if (a <= l && r <= b)
      return (seg[k] + add[k]);
    int mid = (l + r) / 2;
    int k1 = 2 * k + 1, k2 = 2 * k + 2;
    return (Query(a, b, k1, l, mid) +
            Query(a, b, k2, mid, r) + add[k]);
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return (Query(a, b, 0, 0, sz)); }
};

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  
  int N, M, P[100000];
  cin >> N >> M;
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    cin >> P[i];
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = P[i - 1], v = P[i];
    if(u > v) swap(u,v);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    cin >> A >> B >> C;
    ret += (used * A < C + used * B) ? used * A : C + used * B;
  }
  cout << ret << "\n";
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 5216
final_rank: 6

code_snippet: #include <cstdio>

struct SegmentTree {
  int* seg;
  int* add;
  int sz;

  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg = new int[sz * 2 + 1];
    add = new int[sz * 2 + 1];
    for (int i = 0; i < sz * 2 + 1; i++) {
      seg[i] = 0;
      add[i] = 0;
    }
  }

  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      int mid = (l + r) / 2;
      Add(a, b, x, 2 * k + 1, l, mid);
      Add(a, b, x, 2 * k + 2, mid, r);
      seg[k] = seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
    }
  }

  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return 0;
    if (a <= l && r <= b)
      return seg[k] + add[k];
    int mid = (l + r) / 2;
    return Query(a, b, 2 * k + 1, l, mid) + Query(a, b, 2 * k + 2, mid, r) + add[k];
  }

  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }

  int Query(int a, int b) { return Query(a, b, 0, 0, sz); }

  ~SegmentTree() {
    delete[] seg;
    delete[] add;
  }
};

int main() {
  int N, M, P[100000];
  scanf("%d %d", &N, &M);
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    scanf("%d", &P[i]);
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = (P[i - 1] < P[i] ? P[i - 1] : P[i]);
    int v = (P[i - 1] < P[i] ? P[i] : P[i - 1]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    scanf("%d %d %d", &A, &B, &C);
    ret += (used * A < C + used * B ? used * A : C + used * B);
  }
  printf("%lld\n", ret);

  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 4764
final_rank: 9

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

struct SegmentTree {
  vector<int> seg, add;
  int sz;

  SegmentTree(int n) {
    sz = 1;
    while (sz < n) sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }

  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) return;
    if (a <= l && r <= b) {
      add[k] += x;
    } else {
      int mid = (l + r) / 2;
      int k1 = 2 * k + 1;
      int k2 = 2 * k + 2;
      Add(a, b, x, k1, l, mid);
      Add(a, b, x, k2, mid, r);
      seg[k] = seg[k1] + add[k1] + seg[k2] + add[k2];
    }
  }

  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l) return 0;
    if (a <= l && r <= b) return seg[k] + add[k];
    int mid = (l + r) / 2;
    return Query(a, b, 2 * k + 1, l, mid) +
           Query(a, b, 2 * k + 2, mid, r) + add[k];
  }

  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return Query(a, b, 0, 0, sz); }
};

int main() {
  int N, M, P[100000];
  scanf("%d %d", &N, &M);
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    scanf("%d", &P[i]);
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    scanf("%d %d %d", &A, &B, &C);
    ret += min(used * A, C + used * B);
  }
  printf("%lld\n", ret);
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 4756
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz <<= 1;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      int mid = (l + r) >> 1;
      int k1 = k << 1;
      Add(a, b, x, k1 + 1, l, mid);
      Add(a, b, x, k1 + 2, mid, r);
      seg[k] = seg[k1 + 1] + add[k1 + 1] + seg[k1 + 2] + add[k1 + 2];
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return (0);
    if (a <= l && r <= b)
      return (seg[k] + add[k]);
    int mid = (l + r) >> 1;
    int k1 = k << 1;
    return (Query(a, b, k1 + 1, l, mid) +
            Query(a, b, k1 + 2, mid, r) + add[k]);
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return (Query(a, b, 0, 0, sz)); }
};

int scan() {
  int n = 0, ch = getchar_unlocked();
  while (ch < '0' || ch > '9') ch = getchar_unlocked();
  while (ch >= '0' && ch <= '9') {
    n = (n << 3) + (n << 1) + ch - '0';
    ch = getchar_unlocked();
  }
  return n;
}

int main() {
  int N = scan(), M = scan(), P[100000];
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    P[i] = scan();
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A = scan(), B = scan(), C = scan();
    ret += min(used * A, C + used * B);
  }
  cout << ret << endl;
}
accuracy: 1
time_ms: 30
memory_kb: 5160
final_rank: 2

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

using namespace std;

struct SegmentTree {
    vector<int> seg, add;
    int sz;
    SegmentTree(int n) {
        sz = 1;
        while (sz < n) sz *= 2;
        seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
    }
    void Add(int a, int b, int x, int k, int l, int r) {
        if (a >= r || b <= l) return;
        else if (a <= l && r <= b) add[k] += x;
        else {
            Add(a, b, x, 2 * k + 1, l, (l + r) / 2);
            Add(a, b, x, 2 * k + 2, (l + r) / 2, r);
            seg[k] = seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
        }
    }
    int Query(int a, int b, int k, int l, int r) {
        if (a >= r || b <= l) return 0;
        if (a <= l && r <= b) return seg[k] + add[k];
        return Query(a, b, 2 * k + 1, l, (l + r) / 2) + Query(a, b, 2 * k + 2, (l + r) / 2, r) + add[k];
    }
    void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
    int Query(int a, int b) { return Query(a, b, 0, 0, sz); }
};

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    int N, M, P[100000];
    cin >> N >> M;
    SegmentTree segtree(N);
    for (int i = 0; i < M; i++) {
        cin >> P[i];
        --P[i];
    }
    for (int i = 1; i < M; i++) {
        int u = P[i - 1] < P[i] ? P[i - 1] : P[i], v = P[i - 1] > P[i] ? P[i - 1] : P[i];
        segtree.Add(u, v, 1);
    }
    long long ret = 0;
    for (int i = 0; i < N - 1; i++) {
        long long used = segtree.Query(i, i + 1);
        int A, B, C;
        cin >> A >> B >> C;
        ret += min(used * A, C + used * B);
    }
    cout << ret << endl;
}
accuracy: 1
time_ms: 50
memory_kb: 5184
final_rank: 4

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz *= 2;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      Add(a, b, x, 2 * k + 1, l, (l + r) / 2);
      Add(a, b, x, 2 * k + 2, (l + r) / 2, r);
      seg[k] =
          seg[2 * k + 1] + add[2 * k + 1] + seg[2 * k + 2] + add[2 * k + 2];
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return (0);
    if (a <= l && r <= b)
      return (seg[k] + add[k]);
    return (Query(a, b, 2 * k + 1, l, (l + r) / 2) +
            Query(a, b, 2 * k + 2, (l + r) / 2, r) + add[k]);
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return (Query(a, b, 0, 0, sz)); }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int N, M, P[100000];
  cin >> N >> M;
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    cin >> P[i];
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    cin >> A >> B >> C;
    ret += min(used * A, C + used * B);
  }
  cout << ret << '\n';
  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 5216
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
  vector<int> seg, add;
  int sz;
  SegmentTree(int n) {
    sz = 1;
    while (sz < n)
      sz <<= 1;
    seg.assign(sz * 2 + 1, 0), add.assign(sz * 2 + 1, 0);
  }
  void Add(int a, int b, int x, int k, int l, int r) {
    if (a >= r || b <= l) {
      return;
    } else if (a <= l && r <= b) {
      add[k] += x;
    } else {
      Add(a, b, x, 2 * k + 1, l, (l + r) >> 1);
      Add(a, b, x, 2 * k + 2, (l + r) >> 1, r);
      int left = seg[2 * k + 1] + add[2 * k + 1];
      int right = seg[2 * k + 2] + add[2 * k + 2];
      seg[k] = left + right;
    }
  }
  int Query(int a, int b, int k, int l, int r) {
    if (a >= r || b <= l)
      return (0);
    if (a <= l && r <= b)
      return (seg[k] + add[k]);
    return (Query(a, b, 2 * k + 1, l, (l + r) >> 1) +
            Query(a, b, 2 * k + 2, (l + r) >> 1, r) + add[k]);
  }
  void Add(int a, int b, int x) { Add(a, b, x, 0, 0, sz); }
  int Query(int a, int b) { return (Query(a, b, 0, 0, sz)); }
};
int main() {
  int N, M, P[100000];
  scanf("%d %d", &N, &M);
  SegmentTree segtree(N);
  for (int i = 0; i < M; i++) {
    scanf("%d", &P[i]);
    --P[i];
  }
  for (int i = 1; i < M; i++) {
    int u = min(P[i - 1], P[i]), v = max(P[i - 1], P[i]);
    segtree.Add(u, v, 1);
  }
  long long ret = 0;
  for (int i = 0; i < N - 1; i++) {
    long long used = segtree.Query(i, i + 1);
    int A, B, C;
    scanf("%d %d %d", &A, &B, &C);
    ret += min(used * A, C + used * B);
  }
  printf("%lld\n", ret);
}
accuracy: 1
time_ms: 50
memory_kb: 5208
final_rank: 5