problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p03173 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define int long long
int32_t main() {
int n;
cin >> n;
int a[n + 1];
int csum[n + 1];
a[0] = 0;
csum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
csum[i] = a[i] + csum[i - 1];
}
int dp[n + 1][n + 1];
memset(dp, 0, sizeof dp);
int row, temp;
for (int col = 2; col <= n; col++) {
row = 1;
temp = col;
while (row <= n && temp <= n) {
dp[row][temp] = INT_MAX;
for (int k = row; k < temp; k++) {
dp[row][temp] = min(dp[row][temp], dp[row][k] + dp[k + 1][temp] +
csum[temp] - csum[row - 1]);
}
row++;
temp++;
}
}
cout << dp[1][n];
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define int long long
int32_t main() {
int n;
cin >> n;
int a[n + 1];
int csum[n + 1];
a[0] = 0;
csum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
csum[i] = a[i] + csum[i - 1];
}
int dp[n + 1][n + 1];
memset(dp, 0, sizeof dp);
int row, temp;
for (int col = 2; col <= n; col++) {
row = 1;
temp = col;
while (row <= n && temp <= n) {
dp[row][temp] = 9999999999999999;
for (int k = row; k < temp; k++) {
dp[row][temp] = min(dp[row][temp], dp[row][k] + dp[k + 1][temp] +
csum[temp] - csum[row - 1]);
}
row++;
temp++;
}
}
cout << dp[1][n];
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,307 | 981,308 | u536383397 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, T b) {
if (a > b)
a = b;
}
const long long INF = 1LL << 60;
int N;
int a[410];
int b[410];
long long dp[410][410];
bool ischecked[410][410] = {false};
//累積和の保持
long long init() {
b[0] = a[0];
for (int i = 1; i < N; ++i)
b[i] = b[i - 1] + a[i];
}
//累積和の取り出し
long long get(int L, int R) { return b[R] - b[L - 1]; }
long long rec(int L, int R) {
if (L == R)
return 0;
if (ischecked[L][R])
return dp[L][R];
ischecked[L][R] = true;
long long ret = INF;
for (int i = L; i < R; ++i)
chmin(ret, rec(L, i) + rec(i + 1, R) + get(L, R));
return dp[L][R] = ret;
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i)
cin >> a[i];
init();
cout << rec(0, N - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, T b) {
if (a > b)
a = b;
}
const long long INF = 1LL << 60;
int N;
long long a[410];
long long b[410];
long long dp[410][410];
bool ischecked[410][410] = {false};
//累積和の保持
long long init() {
b[0] = a[0];
for (int i = 1; i < N; ++i)
b[i] = b[i - 1] + a[i];
}
//累積和の取り出し
long long get(int L, int R) { return b[R] - b[L - 1]; }
long long rec(int L, int R) {
if (L == R)
return 0;
if (ischecked[L][R])
return dp[L][R];
ischecked[L][R] = true;
long long ret = INF;
for (int i = L; i < R; ++i)
chmin(ret, rec(L, i) + rec(i + 1, R) + get(L, R));
return dp[L][R] = ret;
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i)
cin >> a[i];
init();
cout << rec(0, N - 1) << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 981,313 | 981,314 | u843175622 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
long long helper(vector<long long> &vec, vector<vector<long long>> &dp,
long long l, long long r) {
if (l == r)
return 0;
if (l + 1 == r)
return dp[l][r] = vec[l] + vec[r];
if (dp[l][r] != -1)
return dp[l][r];
long long ans = LLONG_MAX, sum = 0;
for (long long i = l; i <= r; ++i) {
sum += vec[i];
}
for (long long i = l; i < r; ++i) {
ans = min(ans, sum + helper(vec, dp, l, i) + helper(vec, dp, i + 1, r));
}
return dp[l][r] = ans;
}
int main() {
long long n;
cin >> n;
vector<long long> vec(n, 0);
for (long long i = 0; i < n; i++)
cin >> vec[i];
vector<vector<long long>> dp(n, vector<long long>(n, 0));
cout << helper(vec, dp, 0, n - 1);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
long long helper(vector<long long> &vec, vector<vector<long long>> &dp,
long long l, long long r) {
if (l == r)
return 0;
if (l + 1 == r)
return dp[l][r] = vec[l] + vec[r];
if (dp[l][r] != -1)
return dp[l][r];
long long ans = LLONG_MAX, sum = 0;
for (long long i = l; i <= r; ++i) {
sum += vec[i];
}
for (long long i = l; i < r; ++i) {
ans = min(ans, sum + helper(vec, dp, l, i) + helper(vec, dp, i + 1, r));
}
return dp[l][r] = ans;
}
int main() {
long long n;
cin >> n;
vector<long long> vec(n, 0);
for (long long i = 0; i < n; i++)
cin >> vec[i];
vector<vector<long long>> dp(n, vector<long long>(n, -1));
cout << helper(vec, dp, 0, n - 1);
}
| [
"literal.number.change",
"call.arguments.change"
] | 981,315 | 981,316 | u492789403 | cpp |
p03173 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define int long long int
#define endl "\n"
#define PI 3.14159265
int MAX_CHARS = 10000;
const int mod = 1e9 + 7;
const int INF = LONG_LONG_MAX;
inline int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
inline int pow(int a, int n, int mod) {
if (n == 0)
return 1;
int p = pow(a, n / 2, mod);
p = (p % mod * p % mod) % mod;
if (n % 2)
return (p % mod * a % mod) % mod;
else
return p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n][n];
int pre[n];
pre[0] = a[0];
for (int i = 1; i < n; i++)
pre[i] = pre[i - 1] + a[i];
for (int len = 1; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = len + i - 1;
dp[i][j] = 1e18;
// cout<<i<<" "<<j<<endl;
if (len == 1) {
dp[i][j] = 0;
continue;
}
if (len == 2) {
dp[i][j] = a[i] + a[j];
continue;
}
int x = pre[j] - (i - 1 >= 0 ? pre[i - 1] : 0);
for (int k = i + 1; k <= j - 1; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + x);
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define int long long int
#define endl "\n"
#define PI 3.14159265
int MAX_CHARS = 10000;
const int mod = 1e9 + 7;
const int INF = LONG_LONG_MAX;
inline int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
inline int pow(int a, int n, int mod) {
if (n == 0)
return 1;
int p = pow(a, n / 2, mod);
p = (p % mod * p % mod) % mod;
if (n % 2)
return (p % mod * a % mod) % mod;
else
return p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n][n];
int pre[n];
pre[0] = a[0];
for (int i = 1; i < n; i++)
pre[i] = pre[i - 1] + a[i];
for (int len = 1; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = len + i - 1;
dp[i][j] = 1e18;
// cout<<i<<" "<<j<<endl;
if (len == 1) {
dp[i][j] = 0;
continue;
}
if (len == 2) {
dp[i][j] = a[i] + a[j];
continue;
}
int x = pre[j] - (i - 1 >= 0 ? pre[i - 1] : 0);
for (int k = i; k <= j - 1; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + x);
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 981,319 | 981,320 | u452103000 | cpp |
p03173 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define int long long int
#define endl "\n"
#define PI 3.14159265
int MAX_CHARS = 10000;
const int mod = 1e9 + 7;
const int INF = LONG_LONG_MAX;
inline int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
inline int pow(int a, int n, int mod) {
if (n == 0)
return 1;
int p = pow(a, n / 2, mod);
p = (p % mod * p % mod) % mod;
if (n % 2)
return (p % mod * a % mod) % mod;
else
return p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n][n];
int pre[n];
pre[0] = a[0];
for (int i = 1; i < n; i++)
pre[i] = pre[i - 1] + a[i];
for (int len = 1; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = len + i - 1;
dp[i][j] = 1e7;
// cout<<i<<" "<<j<<endl;
if (len == 1) {
dp[i][j] = 0;
continue;
}
if (len == 2) {
dp[i][j] = a[i] + a[j];
continue;
}
int x = pre[j] - (i - 1 >= 0 ? pre[i - 1] : 0);
for (int k = i + 1; k <= j - 1; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + x);
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define int long long int
#define endl "\n"
#define PI 3.14159265
int MAX_CHARS = 10000;
const int mod = 1e9 + 7;
const int INF = LONG_LONG_MAX;
inline int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
inline int pow(int a, int n, int mod) {
if (n == 0)
return 1;
int p = pow(a, n / 2, mod);
p = (p % mod * p % mod) % mod;
if (n % 2)
return (p % mod * a % mod) % mod;
else
return p;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n][n];
int pre[n];
pre[0] = a[0];
for (int i = 1; i < n; i++)
pre[i] = pre[i - 1] + a[i];
for (int len = 1; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = len + i - 1;
dp[i][j] = 1e18;
// cout<<i<<" "<<j<<endl;
if (len == 1) {
dp[i][j] = 0;
continue;
}
if (len == 2) {
dp[i][j] = a[i] + a[j];
continue;
}
int x = pre[j] - (i - 1 >= 0 ? pre[i - 1] : 0);
for (int k = i; k <= j - 1; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + x);
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 981,321 | 981,320 | u452103000 | cpp |
p03173 | #include <bits/stdc++.h>
#include <cstring>
#include <limits>
using namespace std;
#define ll long long int
#define X first
#define Y second
#define fw(i, start, end) for (ll i = start; i < end; ++i)
#define fe(i, start, end) for (ll i = start; i <= end; ++i)
#define L(T) \
ll T; \
cin >> T; \
while (T--)
#define FASTIO \
ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
#define endl "\n"
ll dp[420][420];
ll n;
ll a[420];
ll s[420];
ll summa(ll i, ll j) { return s[j] - s[i - 1]; }
ll solve(ll i, ll j) {
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = INT_MAX;
if (i == j)
return dp[i][j] = 0;
if (j - i == 1)
return dp[i][j] = a[i] + a[j];
// fe(L, 1, j)
// {
// fe(R, L, j)
// {
// dp[L][R] = min(dp[L][R], solve(L, R - 1) + solve(L - 1, R));
// }
// }
fw(L, i, j) {
dp[i][j] = min(dp[i][j], solve(i, L) + solve(L + 1, j) + summa(i, j));
}
return dp[i][j];
}
int main() {
FASTIO
// L(T)
{
cin >> n;
memset(s, 0, sizeof s);
fw(i, 1, n + 1)
{
cin >> a[i];
// s[i] += a[i];
}
fw(i, 1, n + 1) s[i] = s[i - 1] + a[i];
memset(dp, -1, sizeof dp);
solve(1, n);
cout << dp[1][n] << endl;
}
return 0;
} | #include <bits/stdc++.h>
#include <cstring>
#include <limits>
using namespace std;
#define ll long long int
#define X first
#define Y second
#define fw(i, start, end) for (ll i = start; i < end; ++i)
#define fe(i, start, end) for (ll i = start; i <= end; ++i)
#define L(T) \
ll T; \
cin >> T; \
while (T--)
#define FASTIO \
ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
#define endl "\n"
ll dp[420][420];
ll n;
ll a[420];
ll s[420];
ll summa(ll i, ll j) { return s[j] - s[i - 1]; }
ll solve(ll i, ll j) {
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = LONG_LONG_MAX;
if (i == j)
return dp[i][j] = 0;
if (j - i == 1)
return dp[i][j] = a[i] + a[j];
// fe(L, 1, j)
// {
// fe(R, L, j)
// {
// dp[L][R] = min(dp[L][R], solve(L, R - 1) + solve(L - 1, R));
// }
// }
fw(L, i, j) {
dp[i][j] = min(dp[i][j], solve(i, L) + solve(L + 1, j) + summa(i, j));
}
return dp[i][j];
}
int main() {
FASTIO
// L(T)
{
cin >> n;
memset(s, 0, sizeof s);
fw(i, 1, n + 1)
{
cin >> a[i];
// s[i] += a[i];
}
fw(i, 1, n + 1) s[i] = s[i - 1] + a[i];
memset(dp, -1, sizeof dp);
solve(1, n);
cout << dp[1][n] << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 981,324 | 981,325 | u161386534 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mp make_pair
#define pb push_back
#define fi first
#define si second
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define F(a, n) \
for (int i = 0; i < n; i++) { \
cin >> a[i]; \
}
#define F1(a, n) \
for (int i = 1; i <= n; i++) { \
cin >> a[i]; \
}
#define P(a, n) \
for (int i = 0; i < n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define P1(a, n) \
for (int i = 1; i <= n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define NF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cin >> a[i][j]; \
} \
}
#define NF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cin >> a[i][j]; \
} \
}
#define PNF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define PNF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define AS 200001
#define mod 1000000007
#define MAX LLONG_MAX
ll dp[405][405];
vector<ll> A;
ll min(ll a, ll b) {
a = a < b ? a : b;
return a;
}
int solve() {
ll n = A.size();
for (int d = 1; d < n; d++) {
ll i = 0, j = d;
while (j < n) {
ll ans = MAX;
for (int k = i; k < j; k++) {
ans =
min(ans, dp[i][k] + dp[k + 1][j] + (A[j] - (i > 0 ? A[i - 1] : 0)));
}
dp[i][j] = ans;
i++;
j++;
}
}
return dp[0][n - 1];
}
int main() {
memset(dp, 0, sizeof dp);
fastIO;
ll n;
cin >> n;
for (ll i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
if (i != 0)
A.pb(tmp + A[i - 1]);
else
A.pb(tmp);
}
cout << solve() << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mp make_pair
#define pb push_back
#define fi first
#define si second
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define F(a, n) \
for (int i = 0; i < n; i++) { \
cin >> a[i]; \
}
#define F1(a, n) \
for (int i = 1; i <= n; i++) { \
cin >> a[i]; \
}
#define P(a, n) \
for (int i = 0; i < n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define P1(a, n) \
for (int i = 1; i <= n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define NF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cin >> a[i][j]; \
} \
}
#define NF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cin >> a[i][j]; \
} \
}
#define PNF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define PNF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define AS 200001
#define mod 1000000007
#define MAX LLONG_MAX
ll dp[405][405];
vector<ll> A;
ll min(ll a, ll b) {
a = a < b ? a : b;
return a;
}
ll solve() {
ll n = A.size();
for (int d = 1; d < n; d++) {
ll i = 0, j = d;
while (j < n) {
ll ans = MAX;
for (int k = i; k < j; k++) {
ans =
min(ans, dp[i][k] + dp[k + 1][j] + (A[j] - (i > 0 ? A[i - 1] : 0)));
}
dp[i][j] = ans;
i++;
j++;
}
}
return dp[0][n - 1];
}
int main() {
memset(dp, 0, sizeof dp);
fastIO;
ll n;
cin >> n;
for (ll i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
if (i != 0)
A.pb(tmp + A[i - 1]);
else
A.pb(tmp);
}
cout << solve() << '\n';
return 0;
} | [] | 981,328 | 981,329 | u677037883 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
static const int64_t INF = 1000000000000000000;
int main() {
int N;
cin >> N;
vector<int64_t> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
int64_t dp[N][N];
for (int i = 0; i < N; i++)
dp[i][i] = 0;
for (int l = 1; l <= N - 1; l++) {
int64_t sum = 0;
for (int a = 0; a <= l; a++)
sum += A[a];
for (int i = 0; i < N - l; i++) {
int j = i + l;
int64_t ans = INF;
for (int k = i; k < j; k++)
if (dp[i][k] + dp[k + 1][j] < ans)
ans = dp[i][k] + dp[k + 1][j];
dp[i][j] = sum + ans;
sum += (A[i + l - 1] - A[i]);
}
}
cout << dp[0][N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
static const int64_t INF = 1000000000000000000;
int main() {
int N;
cin >> N;
vector<int64_t> A(N);
for (int i = 0; i < N; i++)
cin >> A.at(i);
int64_t dp[N][N];
for (int i = 0; i < N; i++)
dp[i][i] = 0;
for (int l = 1; l <= N - 1; l++) {
int64_t sum = 0;
for (int a = 0; a <= l; a++)
sum += A[a];
for (int i = 0; i < N - l; i++) {
int j = i + l;
int64_t ans = INF;
for (int k = i; k < j; k++)
if (dp[i][k] + dp[k + 1][j] < ans)
ans = dp[i][k] + dp[k + 1][j];
dp[i][j] = sum + ans;
sum += (A[i + l + 1] - A[i]);
}
}
cout << dp[0][N - 1] << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 981,334 | 981,333 | u101018317 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
unsigned long long int dp2[n + 1] = {0};
int i, j, k;
for (i = 0; i < n; i++) {
cin >> a[i];
dp2[i + 1] = dp2[i] + a[i];
}
unsigned long long int dp[n][n], m;
for (i = 0; i < n; i++) {
dp[i][i] = 0;
}
for (i = 1; i < n; i++) {
for (j = 0; j < n; j++) {
if (j + i < n) {
m = 1e20;
for (k = i + j - 1; k >= 0; k--) {
m = min(dp[j][k] + dp[k + 1][i + j] + dp2[i + j + 1] - dp2[j], m);
}
dp[j][j + i] = m;
dp[j + i][j] = m;
}
}
}
cout << dp[0][n - 1] << endl;
/*for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
unsigned long long int dp2[n + 1] = {0};
int i, j, k;
for (i = 0; i < n; i++) {
cin >> a[i];
dp2[i + 1] = dp2[i] + a[i];
}
unsigned long long int dp[n][n], m;
for (i = 0; i < n; i++) {
dp[i][i] = 0;
}
for (i = 1; i < n; i++) {
for (j = 0; j < n - 1; j++) {
if (j + i < n) {
m = 1e18;
for (k = i + j - 1; k >= j; k--) {
m = min(dp[j][k] + dp[k + 1][i + j] + dp2[i + j + 1] - dp2[j], m);
}
dp[j][j + i] = m;
dp[j + i][j] = m;
}
}
}
cout << dp[0][n - 1] << endl;
/*for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.number.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 981,342 | 981,341 | u639413043 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
long long int dp2[n + 1] = {0};
int i, j, k;
for (i = 0; i < n; i++) {
cin >> a[i];
dp2[i + 1] = dp2[i] + a[i];
}
long long int dp[n][n], m;
for (i = 0; i < n; i++) {
dp[i][i] = 0;
}
for (i = 1; i < n; i++) {
for (j = 0; j < n; j++) {
if (j + i < n) {
m = 1e18;
for (k = i + j - 1; k >= 0; k--) {
m = min(dp[j][k] + dp[k + 1][i + j] + dp2[i + j + 1] - dp2[j], m);
}
dp[j][j + i] = m;
dp[j + i][j] = m;
}
}
}
cout << dp[0][n - 1] << endl;
/*for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
unsigned long long int dp2[n + 1] = {0};
int i, j, k;
for (i = 0; i < n; i++) {
cin >> a[i];
dp2[i + 1] = dp2[i] + a[i];
}
unsigned long long int dp[n][n], m;
for (i = 0; i < n; i++) {
dp[i][i] = 0;
}
for (i = 1; i < n; i++) {
for (j = 0; j < n - 1; j++) {
if (j + i < n) {
m = 1e18;
for (k = i + j - 1; k >= j; k--) {
m = min(dp[j][k] + dp[k + 1][i + j] + dp2[i + j + 1] - dp2[j], m);
}
dp[j][j + i] = m;
dp[j + i][j] = m;
}
}
}
cout << dp[0][n - 1] << endl;
/*for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
return 0;
} | [
"variable_declaration.type.widen.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 981,343 | 981,341 | u639413043 | cpp |
p03173 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MOD = 1e9 + 7;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 30)
ll dp[440][440];
ll sum[440][440];
ll a[440];
int main() {
int n;
cin >> n;
rep(i, n) cin >> a[i];
rep(l, n) {
sum[l][l + 1] = a[l];
for (int r = l + 2; r <= n; r++) {
sum[l][r] = sum[l][r - 1] + a[r - 1];
}
}
for (int width = 2; width <= n; width++) {
for (int l = 0; l + width <= n; l++) {
int r = l + width;
dp[l][r] = LINF;
for (int m = l + 1; m < r; m++) {
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m][r] + sum[l][r]);
}
}
}
cout << dp[0][n] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MOD = 1e9 + 7;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
ll dp[440][440];
ll sum[440][440];
ll a[440];
int main() {
int n;
cin >> n;
rep(i, n) cin >> a[i];
rep(l, n) {
sum[l][l + 1] = a[l];
for (int r = l + 2; r <= n; r++) {
sum[l][r] = sum[l][r - 1] + a[r - 1];
}
}
for (int width = 2; width <= n; width++) {
for (int l = 0; l + width <= n; l++) {
int r = l + width;
dp[l][r] = LINF;
for (int m = l + 1; m < r; m++) {
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m][r] + sum[l][r]);
}
}
}
cout << dp[0][n] << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 981,356 | 981,357 | u503228842 | cpp |
p03173 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MOD = 1e9 + 7;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 30)
ll dp[440][440];
ll sum[440][440];
ll a[440];
int main() {
int n;
cin >> n;
rep(i, n) cin >> a[i];
rep(l, n) {
sum[l][l + 1] = a[l];
for (int r = l + 2; r <= n; r++) {
sum[l][r] = sum[l][r - 1] + a[r - 1];
}
}
for (int width = 2; width <= n; width++) {
for (int l = 0; l + width <= n; l++) {
int r = l + width;
dp[l][r] = INF;
for (int m = l + 1; m < r; m++) {
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m][r] + sum[l][r]);
}
}
}
cout << dp[0][n] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MOD = 1e9 + 7;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
ll dp[440][440];
ll sum[440][440];
ll a[440];
int main() {
int n;
cin >> n;
rep(i, n) cin >> a[i];
rep(l, n) {
sum[l][l + 1] = a[l];
for (int r = l + 2; r <= n; r++) {
sum[l][r] = sum[l][r - 1] + a[r - 1];
}
}
for (int width = 2; width <= n; width++) {
for (int l = 0; l + width <= n; l++) {
int r = l + width;
dp[l][r] = LINF;
for (int m = l + 1; m < r; m++) {
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m][r] + sum[l][r]);
}
}
}
cout << dp[0][n] << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"assignment.value.change",
"identifier.change"
] | 981,358 | 981,357 | u503228842 | cpp |
p03173 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MOD = 1e9 + 7;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 30)
int dp[440][440];
int sum[440][440];
int a[440];
int main() {
int n;
cin >> n;
rep(i, n) cin >> a[i];
rep(l, n) {
sum[l][l + 1] = a[l];
for (int r = l + 2; r <= n; r++) {
sum[l][r] = sum[l][r - 1] + a[r - 1];
}
}
for (int width = 2; width <= n; width++) {
for (int l = 0; l + width <= n; l++) {
int r = l + width;
dp[l][r] = INF;
for (int m = l + 1; m < r; m++) {
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m][r] + sum[l][r]);
}
}
}
cout << dp[0][n] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MOD = 1e9 + 7;
#define INF ((1 << 30) - 1)
#define LINF (1LL << 60)
ll dp[440][440];
ll sum[440][440];
ll a[440];
int main() {
int n;
cin >> n;
rep(i, n) cin >> a[i];
rep(l, n) {
sum[l][l + 1] = a[l];
for (int r = l + 2; r <= n; r++) {
sum[l][r] = sum[l][r - 1] + a[r - 1];
}
}
for (int width = 2; width <= n; width++) {
for (int l = 0; l + width <= n; l++) {
int r = l + width;
dp[l][r] = LINF;
for (int m = l + 1; m < r; m++) {
dp[l][r] = min(dp[l][r], dp[l][m] + dp[m][r] + sum[l][r]);
}
}
}
cout << dp[0][n] << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change"
] | 981,359 | 981,357 | u503228842 | cpp |
p03173 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll MAX = 1e9 + 1;
const int MOD = 1e9 + 7;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<vector<pair<ll, ll>>> dp(
n + 1, vector<pair<ll, ll>>(n + 1, make_pair(INT_MAX, 0)));
// dp[i][j] ~ tuple of 1. min cost to combine a[i:j]
// 2. size of current slime
// dp[i][i] = (0, a[i])
// dp[i][j].first = min{ dp[i][k].first + dp[k+1][j].first } for k = i ...
// j-1 update dp[i][j].second accordingly
for (int level = 0; level < n; level++) {
for (int i = 0; i < n - level; i++) {
int j = i + level;
if (level == 0)
dp[i][j] = make_pair(0, a[i]);
else {
for (int k = i; k <= j - 1; k++) {
ll lCost = dp[i][k].first;
ll lSize = dp[i][k].second;
ll rCost = dp[k + 1][j].first;
ll rSize = dp[k + 1][j].second;
ll total = lCost + rCost + lSize + rSize;
if (total < dp[i][j].first)
dp[i][j] = make_pair(total, lSize + rSize);
}
}
}
}
// for (int i = 0; i < n; i++) {
// for (int j = 0; j < n; j++) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
//}
cout.precision(20);
cout << dp[0][n - 1].first << endl;
}
int main() {
solve();
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll MAX = 1e9 + 1;
const int MOD = 1e9 + 7;
void solve() {
int n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<vector<pair<ll, ll>>> dp(
n + 1, vector<pair<ll, ll>>(n + 1, make_pair(LLONG_MAX, 0)));
// dp[i][j] ~ tuple of 1. min cost to combine a[i:j]
// 2. size of current slime
// dp[i][i] = (0, a[i])
// dp[i][j].first = min{ dp[i][k].first + dp[k+1][j].first } for k = i ...
// j-1 update dp[i][j].second accordingly
for (int level = 0; level < n; level++) {
for (int i = 0; i < n - level; i++) {
int j = i + level;
if (level == 0)
dp[i][j] = make_pair(0, a[i]);
else {
for (int k = i; k <= j - 1; k++) {
ll lCost = dp[i][k].first;
ll lSize = dp[i][k].second;
ll rCost = dp[k + 1][j].first;
ll rSize = dp[k + 1][j].second;
ll total = lCost + rCost + lSize + rSize;
if (total < dp[i][j].first)
dp[i][j] = make_pair(total, lSize + rSize);
}
}
}
}
// for (int i = 0; i < n; i++) {
// for (int j = 0; j < n; j++) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
//}
cout.precision(20);
cout << dp[0][n - 1].first << endl;
}
int main() {
solve();
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 981,360 | 981,361 | u896475222 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int mod = 1e9 + 7;
ll dp[405][405];
int main() {
int n;
cin >> n;
memset(dp, 0x1c, sizeof(dp));
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto sum = [&](int l, int r) {
ll s = 0;
for (int i = l; i <= r; i++) {
s += a[i];
}
return s;
};
for (int i = n - 1; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (i == j) {
dp[i][j] = 0;
} else {
int s = sum(i, j);
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int mod = 1e9 + 7;
ll dp[405][405];
int main() {
int n;
cin >> n;
memset(dp, 0x1c, sizeof(dp));
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto sum = [&](int l, int r) {
ll s = 0;
for (int i = l; i <= r; i++) {
s += a[i];
}
return s;
};
for (int i = n - 1; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (i == j) {
dp[i][j] = 0;
} else {
ll s = sum(i, j);
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
| [
"variable_declaration.type.change"
] | 981,364 | 981,365 | u500482384 | cpp |
p03173 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#define fir first
#define sec second
#define sz(s) (s).size()
#define pb push_back
#define get(n) scanf("%d", &n);
#define gets(s) \
string s; \
cin >> (s);
#define prfi(n) printf("%d", &n);
#define prfd(n) printf("%lf", &n);
#define All(s) (s).begin(), (s).end()
#define rep(i, j) for (int(i) = 0; (i) < (j); (i)++)
#define For(i, j, k) for (int(i) = (j); (i) < (k); (i)++)
#define drep(i, j) for (int(i) = (j); (i) >= 0; (i)--)
#define Ford(i, j, k) for (int(i) = (j); i >= (k); i--)
#define vfor(c, v) for (auto(c) : (v))
#define lpi(n) for (int i = 0; i < (n); i++)
#define lpj(n) for (int j = 0; j < (n); j++)
#define lpz(n) for (int z = 0; z < (n); z++)
#define mem(a, b) memset(a, b, sizeof(a));
#define dump(x) std::cout << #x << " = " << (x) << std::endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using ull = unsigned long long int;
using ll = long long;
using ld = long double;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using qi = std::queue<int>;
using vpii = std::vector<std::pair<int, int>>;
using vpll = std::vector<pll>;
using namespace std;
const int Mod = (1e9) + 7;
const int INF = 1e9 + 19;
const ll INFL = 1e18 + 19;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int dx2[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int dy2[] = {1, 0, -1, 1, 0, -1, 1, 0, -1};
//_____________________________________Templates_________________________________________//
template <class T1, class T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> inline void pri(T a) { cout << a << endl; }
template <class Z> using vec = vector<Z>;
// mainly use for dynamic prog
template <class T1, class T2> void update(T1 &a, T2 b) {
a += b;
if (a > Mod)
a %= Mod;
}
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
bool pairsort(pll pl, pll pr) {
if (pl.first == pr.first)
return pl.second > pr.second;
return pl.first < pr.first;
}
int cntbit(ll a, int n, int j) {
int res = 0;
For(i, j, n) {
if (a >> i & 1) {
res++;
}
}
return res;
}
vector<int> make_bit(int a) {
vector<int> res;
lpi(32) if (a & (1 << i)) res.pb(i);
return res;
}
bool stdbit(int a, int b) { return a & (1 << b); }
int GCD(int a, int b) {
if (b > a)
return GCD(b, a);
if (a % b == 0)
return b;
else
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int roundup(int a, int b) {
if (a % b == 0)
return a / b;
else
return (a + b) / b;
}
int rounddown(int a, int b) {
if (a % b == 0)
return a / b;
else {
return (a - b) / b;
}
}
ll pow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res *= a;
a *= a;
n = n >> 1;
}
return res;
}
ll GetDiviserCount(ll N) //約数の個数
{
ll res = 1;
For(i, 2, sqrt(N) + 1) {
ll cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
res *= (cnt + 1);
if (N == 1)
break;
}
if (N != 1)
res *= 2;
return res;
}
vll GetDivisor(ll N) //約数列挙
{
vll res;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.pb(i);
if (i * i != N)
res.pb(N / i);
}
}
sort(All(res));
return res;
}
//_____________________ following sorce code_________________________//
const int max_n = 3 * (1e5) + 1;
const int max_m = 83 * (1e5) + 1;
int n, m, k;
ll N;
int h, w;
vvi tree;
string S;
int a, b, c;
vi v;
int ans;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
IN(n);
vll a(n);
vll sum(n + 1);
rep(i, n) IN(a[i]);
rep(i, n) sum[i + 1] = sum[i] + a[i];
vvll dp(n + 1, vll(n + 1, INF));
rep(i, n) {
dp[i][i] = 0;
dp[i][i + 1] = 0;
}
For(i, 2, n + 1) {
rep(j, n) {
int ma = j + i;
if (ma > n)
continue;
For(k, j + 1, ma) {
chmin(dp[j][ma], dp[j][k] + dp[k][ma] + (sum[ma] - sum[j]));
}
}
}
ll ans = dp[0][n];
cout << ans << endl;
// for(auto c : ans){cout << c << endl;}
// cout << fixed << setprecision(15) << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#define fir first
#define sec second
#define sz(s) (s).size()
#define pb push_back
#define get(n) scanf("%d", &n);
#define gets(s) \
string s; \
cin >> (s);
#define prfi(n) printf("%d", &n);
#define prfd(n) printf("%lf", &n);
#define All(s) (s).begin(), (s).end()
#define rep(i, j) for (int(i) = 0; (i) < (j); (i)++)
#define For(i, j, k) for (int(i) = (j); (i) < (k); (i)++)
#define drep(i, j) for (int(i) = (j); (i) >= 0; (i)--)
#define Ford(i, j, k) for (int(i) = (j); i >= (k); i--)
#define vfor(c, v) for (auto(c) : (v))
#define lpi(n) for (int i = 0; i < (n); i++)
#define lpj(n) for (int j = 0; j < (n); j++)
#define lpz(n) for (int z = 0; z < (n); z++)
#define mem(a, b) memset(a, b, sizeof(a));
#define dump(x) std::cout << #x << " = " << (x) << std::endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using ull = unsigned long long int;
using ll = long long;
using ld = long double;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using qi = std::queue<int>;
using vpii = std::vector<std::pair<int, int>>;
using vpll = std::vector<pll>;
using namespace std;
const int Mod = (1e9) + 7;
const int INF = 1e9 + 19;
const ll INFL = 1e18 + 19;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int dx2[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int dy2[] = {1, 0, -1, 1, 0, -1, 1, 0, -1};
//_____________________________________Templates_________________________________________//
template <class T1, class T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> inline void pri(T a) { cout << a << endl; }
template <class Z> using vec = vector<Z>;
// mainly use for dynamic prog
template <class T1, class T2> void update(T1 &a, T2 b) {
a += b;
if (a > Mod)
a %= Mod;
}
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
bool pairsort(pll pl, pll pr) {
if (pl.first == pr.first)
return pl.second > pr.second;
return pl.first < pr.first;
}
int cntbit(ll a, int n, int j) {
int res = 0;
For(i, j, n) {
if (a >> i & 1) {
res++;
}
}
return res;
}
vector<int> make_bit(int a) {
vector<int> res;
lpi(32) if (a & (1 << i)) res.pb(i);
return res;
}
bool stdbit(int a, int b) { return a & (1 << b); }
int GCD(int a, int b) {
if (b > a)
return GCD(b, a);
if (a % b == 0)
return b;
else
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int roundup(int a, int b) {
if (a % b == 0)
return a / b;
else
return (a + b) / b;
}
int rounddown(int a, int b) {
if (a % b == 0)
return a / b;
else {
return (a - b) / b;
}
}
ll pow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res *= a;
a *= a;
n = n >> 1;
}
return res;
}
ll GetDiviserCount(ll N) //約数の個数
{
ll res = 1;
For(i, 2, sqrt(N) + 1) {
ll cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
res *= (cnt + 1);
if (N == 1)
break;
}
if (N != 1)
res *= 2;
return res;
}
vll GetDivisor(ll N) //約数列挙
{
vll res;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.pb(i);
if (i * i != N)
res.pb(N / i);
}
}
sort(All(res));
return res;
}
//_____________________ following sorce code_________________________//
const int max_n = 3 * (1e5) + 1;
const int max_m = 83 * (1e5) + 1;
int n, m, k;
ll N;
int h, w;
vvi tree;
string S;
int a, b, c;
vi v;
int ans;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
IN(n);
vll a(n);
vll sum(n + 1);
rep(i, n) IN(a[i]);
rep(i, n) sum[i + 1] = sum[i] + a[i];
vvll dp(n + 1, vll(n + 1, INFL));
rep(i, n) {
dp[i][i] = 0;
dp[i][i + 1] = 0;
}
For(i, 2, n + 1) {
rep(j, n) {
int ma = j + i;
if (ma > n)
continue;
For(k, j + 1, ma) {
chmin(dp[j][ma], dp[j][k] + dp[k][ma] + (sum[ma] - sum[j]));
}
}
}
ll ans = dp[0][n];
cout << ans << endl;
// for(auto c : ans){cout << c << endl;}
// cout << fixed << setprecision(15) << ans << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 981,366 | 981,367 | u264405855 | cpp |
p03173 | /*input
4
10 20 30 40
*/
#include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
const int SINF = 1000000009;
const ll INF = 1000000000000000018;
#define sp cout << " "
#define nl cout << "\n"
#define all(c) (c).begin(), (c).end()
#define prec(n) cout << fixed << setprecision(n)
#define PI 3.14159265358979323846264338327951
#define ifalse ios_base::sync_with_stdio(false), cin.tie(NULL)
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto x : v) {
os << x << " ";
}
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
/******************************** START *********************************/
const int N = 405;
vector<ll> v;
ll dp[N][N];
int main() {
ifalse;
int n;
cin >> n;
v.resize(n + 1);
for (int i = 0; i < n; i++) {
cin >> v[i + 1];
}
for (int i = 1; i <= n; i++) {
v[i] += v[i - 1];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (i == j) {
dp[i][j] = 0;
} else {
dp[i][j] = INF;
}
}
}
ll ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + v[j] - v[i - 1]);
}
}
}
cout << dp[1][n], nl;
return 0;
} | /*input
5
10 10 10 10 10
*/
#include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
const int SINF = 1000000009;
const ll INF = 1000000000000000018;
#define sp cout << " "
#define nl cout << "\n"
#define all(c) (c).begin(), (c).end()
#define prec(n) cout << fixed << setprecision(n)
#define PI 3.14159265358979323846264338327951
#define ifalse ios_base::sync_with_stdio(false), cin.tie(NULL)
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto x : v) {
os << x << " ";
}
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
/******************************** START *********************************/
const int N = 405;
vector<ll> v;
ll dp[N][N];
int main() {
ifalse;
int n;
cin >> n;
v.resize(n + 1);
for (int i = 0; i < n; i++) {
cin >> v[i + 1];
}
for (int i = 1; i <= n; i++) {
v[i] += v[i - 1];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (i == j) {
dp[i][j] = 0;
} else {
dp[i][j] = INF;
}
}
}
ll ans = 0;
for (int i = n - 1; i >= 1; i--) {
for (int j = i + 1; j <= n; j++) {
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + v[j] - v[i - 1]);
}
}
}
cout << dp[1][n], nl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change"
] | 981,368 | 981,369 | u464574147 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll a[401];
ll dp[401][401];
ll get(int i, int j) { return a[j] - (i > 0 ? a[i - 1] : 0); }
ll solve(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = INT_MAX;
for (int k = i; k < j; k++)
dp[i][j] = min(dp[i][j],
solve(i, k) + solve(k + 1, j) + get(i, k) + get(k + 1, j));
return dp[i][j];
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 1; i < n; i++)
a[i] += a[i - 1];
cout << solve(0, n - 1) << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll a[401];
ll dp[401][401];
ll get(int i, int j) { return a[j] - (i > 0 ? a[i - 1] : 0); }
ll solve(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = 1e17;
for (int k = i; k < j; k++)
dp[i][j] = min(dp[i][j],
solve(i, k) + solve(k + 1, j) + get(i, k) + get(k + 1, j));
return dp[i][j];
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 1; i < n; i++)
a[i] += a[i - 1];
cout << solve(0, n - 1) << endl;
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,388 | 981,389 | u879906354 | cpp |
p03173 | #include <algorithm>
#include <climits>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <set>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define mod 1000000007
ll dp[405][405];
int main() {
for (int i = 0; i < 405; i++)
for (int j = 0; j < 405; j++)
dp[i][j] = INT_MAX;
int n;
cin >> n;
vector<ll> a(n);
for (ll &x : a)
cin >> x;
std::vector<ll> prefix_sum(n);
prefix_sum[0] = a[0];
for (int i = 1; i < n; ++i) {
prefix_sum[i] = prefix_sum[i - 1] + a[i];
}
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
for (int i = l; i < r; i++)
if (l == 0)
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + prefix_sum[r]);
else
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + prefix_sum[r] -
prefix_sum[l - 1]);
}
}
cout << dp[0][n - 1];
return 0;
} | #include <algorithm>
#include <climits>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <set>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define mod 1000000007
ll dp[405][405];
int main() {
for (int i = 0; i < 405; i++)
for (int j = 0; j < 405; j++)
dp[i][j] = 1e18;
int n;
cin >> n;
vector<ll> a(n);
for (ll &x : a)
cin >> x;
std::vector<ll> prefix_sum(n);
prefix_sum[0] = a[0];
for (int i = 1; i < n; ++i) {
prefix_sum[i] = prefix_sum[i - 1] + a[i];
}
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
for (int i = l; i < r; i++)
if (l == 0)
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + prefix_sum[r]);
else
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + prefix_sum[r] -
prefix_sum[l - 1]);
}
}
cout << dp[0][n - 1];
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,398 | 981,399 | u545278207 | cpp |
p03173 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll prefix[402];
ll cost[402][402];
ll sum(int l, int r) { return prefix[r] - (l > 0 ? prefix[l - 1] : 0); }
int main() {
int n;
cin >> n;
vector<int> nums(n);
for (auto &x : nums) {
cin >> x;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cost[i][j] = 1e15;
}
prefix[i] = nums[i] + (i ? nums[i - 1] : 0);
cost[i][i] = 0;
}
for (int l = n - 1; l >= 0; l--)
for (int r = l + 1; r < n; r++)
for (int k = l; k < r; k++)
cost[l][r] = min(cost[l][r], cost[l][k] + cost[k + 1][r] + sum(l, r));
cout << cost[0][n - 1] << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll prefix[402];
ll cost[402][402];
ll sum(int l, int r) { return prefix[r] - (l > 0 ? prefix[l - 1] : 0); }
int main() {
int n;
cin >> n;
vector<int> nums(n);
for (auto &x : nums) {
cin >> x;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cost[i][j] = 1e15;
}
prefix[i] = nums[i] + (i ? prefix[i - 1] : 0);
cost[i][i] = 0;
}
for (int l = n - 1; l >= 0; l--)
for (int r = l + 1; r < n; r++)
for (int k = l; k < r; k++)
cost[l][r] = min(cost[l][r], cost[l][k] + cost[k + 1][r] + sum(l, r));
cout << cost[0][n - 1] << endl;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 981,404 | 981,405 | u270654502 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll n, ans = 0, A[401], dp[401][401][2] = {0}, inf = 1e18;
int main() {
cin >> n;
rep(i, n) cin >> A[i];
rep(i, n) rep(j, n - i) {
if (i == 0)
dp[1][j][0] = A[j];
else
dp[i + 1][j][1] = inf;
rep(k, i) {
ll x = dp[i + 1][j][1];
dp[i + 1][j][1] =
min(dp[i + 1][j][1], dp[i - k][j][0] + dp[k + 1][j + i - k][0] +
dp[i - k][j][1] + dp[k + 1][j + i - k][1]);
if (x != dp[i + 1][j][1])
dp[i + 1][j][0] = dp[i - k][j][0] + dp[k + 1][j + i - k][0];
}
}
cout << dp[n][0] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll n, ans = 0, A[401], dp[401][401][2] = {0}, inf = 1e18;
int main() {
cin >> n;
rep(i, n) cin >> A[i];
rep(i, n) rep(j, n - i) {
if (i == 0)
dp[1][j][0] = A[j];
else
dp[i + 1][j][1] = inf;
rep(k, i) {
ll x = dp[i + 1][j][1];
dp[i + 1][j][1] =
min(dp[i + 1][j][1], dp[i - k][j][0] + dp[k + 1][j + i - k][0] +
dp[i - k][j][1] + dp[k + 1][j + i - k][1]);
if (x != dp[i + 1][j][1])
dp[i + 1][j][0] = dp[i - k][j][0] + dp[k + 1][j + i - k][0];
}
}
cout << dp[n][0][1] << "\n";
} | [] | 981,406 | 981,407 | u441296840 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
void min_self(ll &a, ll b) { a = min(a, b); }
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &x : a) {
cin >> x;
}
vector<vector<ll>> dp(n, vector<ll>(n, 1e13 + 5));
vector<int> prefix(n);
prefix[0] = a[0];
for (int i = 1; i < n; i++) {
prefix[i] = a[i] + prefix[i - 1];
}
for (int L = n - 1; L >= 0; L--) {
for (int R = L; R < n; R++) {
if (L == R) {
dp[L][R] = 0;
} else {
for (int k = L; k < R; k++) {
min_self(dp[L][R], dp[L][k] + dp[k + 1][R] + prefix[R] -
(L > 0 ? prefix[L - 1] : 0));
}
}
}
}
cout << dp[0][n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
void min_self(ll &a, ll b) { a = min(a, b); }
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &x : a) {
cin >> x;
}
vector<vector<ll>> dp(n, vector<ll>(n, 1e13 + 5));
vector<ll> prefix(n);
prefix[0] = a[0];
for (int i = 1; i < n; i++) {
prefix[i] = a[i] + prefix[i - 1];
}
for (int L = n - 1; L >= 0; L--) {
for (int R = L; R < n; R++) {
if (L == R) {
dp[L][R] = 0;
} else {
for (int k = L; k < R; k++) {
min_self(dp[L][R], dp[L][k] + dp[k + 1][R] + prefix[R] -
(L > 0 ? prefix[L - 1] : 0));
}
}
}
}
cout << dp[0][n - 1] << endl;
}
| [] | 981,420 | 981,421 | u906885500 | cpp |
p03173 | // https://atcoder.jp/contests/dp/tasks/dp_n
#include <bits/stdc++.h>
using namespace std;
typedef std::pair<int, int> ipair;
#define int long long
#define pb push_back
#define ff first
#define INF INT_MAX
#define ss second
#define fr(i, j, a) for (int i = j; i < a; i++)
#define cnt_ones(x) __builtin_popcount(x)
#define all(x) x.begin(), x.end()
#define sz size()
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<ipair>
#define mp make_pair
#define mod 1000000007
#define IOS \
std::ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
void init() {
int n;
cin >> n;
vector<int> slimes(n);
for (int &i : slimes)
cin >> i;
vector<vector<int>> dp(n, vector<int>(n));
// dp[l][r] - min cost occured while merging [l,r]
auto sum = [&](int L, int R) {
int s = 0;
for (int i = L; i <= R; ++i) {
s += slimes[i];
}
return s;
};
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
else {
int s = sum(l, r);
dp[l][r] = 1e9;
for (int k = l; k < r; k++) {
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + 1][r] + s);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
int32_t main() {
IOS;
init();
return 0;
}
| // https://atcoder.jp/contests/dp/tasks/dp_n
#include <bits/stdc++.h>
using namespace std;
typedef std::pair<int, int> ipair;
#define int long long
#define pb push_back
#define ff first
#define INF INT_MAX
#define ss second
#define fr(i, j, a) for (int i = j; i < a; i++)
#define cnt_ones(x) __builtin_popcount(x)
#define all(x) x.begin(), x.end()
#define sz size()
#define vi vector<int>
#define vvi vector<vector<int>>
#define vp vector<ipair>
#define mp make_pair
#define mod 1000000007
#define IOS \
std::ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
void init() {
int n;
cin >> n;
vector<int> slimes(n);
for (int &i : slimes)
cin >> i;
vector<vector<int>> dp(n, vector<int>(n));
// dp[l][r] - min cost occured while merging [l,r]
auto sum = [&](int L, int R) {
int s = 0;
for (int i = L; i <= R; ++i) {
s += slimes[i];
}
return s;
};
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
else {
int s = sum(l, r);
dp[l][r] = 1e18;
for (int k = l; k < r; k++) {
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + 1][r] + s);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
int32_t main() {
IOS;
init();
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 981,430 | 981,431 | u130958693 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<ll> v(n);
vector<ll> sum(n);
for (ll i = 0; i < n; i++) {
cin >> v[i];
if (i == 0)
sum[i] = v[i];
else
sum[i] = v[i] + sum[i - 1];
}
vector<vector<ll>> dp(n, vector<ll>(n, 0));
for (ll j = 0; j < n; j++) {
for (ll i = j - 1; i >= 0; i--) {
dp[i][j] = INT_MAX;
for (ll k = i; k < j; k++) {
ll s = 0;
s = sum[j];
if (i > 0)
s -= sum[i - 1];
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s);
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<ll> v(n);
vector<ll> sum(n);
for (ll i = 0; i < n; i++) {
cin >> v[i];
if (i == 0)
sum[i] = v[i];
else
sum[i] = v[i] + sum[i - 1];
}
vector<vector<ll>> dp(n, vector<ll>(n, 0));
for (ll j = 0; j < n; j++) {
for (ll i = j - 1; i >= 0; i--) {
dp[i][j] = LLONG_MAX;
for (ll k = i; k < j; k++) {
ll s = 0;
s = sum[j];
if (i > 0)
s -= sum[i - 1];
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s);
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 981,432 | 981,433 | u249211191 | cpp |
p03173 | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
// using Graph = vector<vector<edge>>;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
// const ll mod = 1000000007;
const ll mod = 1000000007ll;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define brep(n) for (int bit = 0; bit < (1 << n); bit++)
#define bbrep(n) for (int bbit = 0; bbit < (1 << n); bbit++)
#define erep(i, container) for (auto &i : container)
#define itrep(i, container) for (auto i : container)
#define irep(i, n) for (ll i = n - 1; i >= (ll)0ll; i--)
#define rrep(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define reprep(i, j, h, w) rep(i, h) rep(j, w)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define VEC(type, name, n) \
std::vector<type> name(n); \
rep(i, n) std::cin >> name[i];
#define pb push_back
#define pf push_front
#define query \
int qq; \
std::cin >> qq; \
rep(qqq, qq)
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a), 0ll)
#define keta fixed << setprecision
#define vout(a) \
erep(qxqxqx, a) std::cout << qxqxqx << ' '; \
std::cout << std::endl;
#define vvector(name, typ, m, n, a) \
vector<vector<typ>> name(m, vector<typ>(n, a))
//#define vvector(name,typ,m,n)vector<vector<typ> > name(m,vector<typ> (n))
#define vvvector(name, t, l, m, n, a) \
vector<vector<vector<t>>> name(l, vector<vector<t>>(m, vector<t>(n, a)));
#define vvvvector(name, t, k, l, m, n, a) \
vector<vector<vector<vector<t>>>> name( \
k, vector<vector<vector<t>>>(l, vector<vector<t>>(m, vector<t>(n, a))));
#define case std::cout << "Case #" << qqq + 1 << ": "
#define res resize
#define as assign
#define ffor for (;;)
#define ppri(a, b) std::cout << a << " " << b << std::endl
#define pppri(a, b, c) std::cout << a << " " << b << " " << c << std::endl
#define aall(x, n) (x).begin(), (x).begin() + (n)
#define ssum(a) accumulate(a, 0ll)
#define stirng string
//#define grid_input(a,type) int h,w;std::cin >>
//h>>w;vvector(a,type,h,w,0);reprep(i,j,h,w)std::cin >> a[i][j];
// typedef long long T;
ll ceil(ll a, ll b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
// const ll INF64 =3223372036854775807ll;
const ll INF64 = 9223372036854775807ll;
// const ll INF64 = 9223372036854775ll;
const ll MOD = 1000000007ll;
// const ll MOD = 1000003ll;
const ll OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n, ll MOD) { //累乗の余剰
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
//メモ
// tuple<hoge,huga,foo> tのget関数はget<i>(t)
// resizeはメンバ関数
//三項演算子を覚えよう
// a?b:cと書くと aならばbの処理をする
// i本目にbitをたてる -> (1<<i)
int main() {
int n;
std::cin >> n;
VEC(int, a, n);
vvector(dp, ll, n + 1, n + 1, 0);
// rep(i,n)dp[i][i+1]=a[i];
a.insert(a.begin(), 0);
rep(i, n) a[i + 1] += a[i];
// vout(a);
rrep(i, 2, n + 1) {
rep(j, n - i + 1) {
ll d = INF64;
rep(k, i - 1) {
chmin(d, dp[j][j + k + 1] + dp[j + k + 1][i + j]);
// pppri(j,j+k+1,i+j);
}
dp[j][i + j] = d + a[i + j] - a[j];
// pppri(i,j,dp[j][i+j]);
}
}
/*
rep(i,n+1){
vout(dp[i]);
std::cout << std::endl;
}
*/
std::cout << dp[0][n] << std::endl;
} | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
// using Graph = vector<vector<edge>>;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
// const ll mod = 1000000007;
const ll mod = 1000000007ll;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define brep(n) for (int bit = 0; bit < (1 << n); bit++)
#define bbrep(n) for (int bbit = 0; bbit < (1 << n); bbit++)
#define erep(i, container) for (auto &i : container)
#define itrep(i, container) for (auto i : container)
#define irep(i, n) for (ll i = n - 1; i >= (ll)0ll; i--)
#define rrep(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define reprep(i, j, h, w) rep(i, h) rep(j, w)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define VEC(type, name, n) \
std::vector<type> name(n); \
rep(i, n) std::cin >> name[i];
#define pb push_back
#define pf push_front
#define query \
int qq; \
std::cin >> qq; \
rep(qqq, qq)
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a), 0ll)
#define keta fixed << setprecision
#define vout(a) \
erep(qxqxqx, a) std::cout << qxqxqx << ' '; \
std::cout << std::endl;
#define vvector(name, typ, m, n, a) \
vector<vector<typ>> name(m, vector<typ>(n, a))
//#define vvector(name,typ,m,n)vector<vector<typ> > name(m,vector<typ> (n))
#define vvvector(name, t, l, m, n, a) \
vector<vector<vector<t>>> name(l, vector<vector<t>>(m, vector<t>(n, a)));
#define vvvvector(name, t, k, l, m, n, a) \
vector<vector<vector<vector<t>>>> name( \
k, vector<vector<vector<t>>>(l, vector<vector<t>>(m, vector<t>(n, a))));
#define case std::cout << "Case #" << qqq + 1 << ": "
#define res resize
#define as assign
#define ffor for (;;)
#define ppri(a, b) std::cout << a << " " << b << std::endl
#define pppri(a, b, c) std::cout << a << " " << b << " " << c << std::endl
#define aall(x, n) (x).begin(), (x).begin() + (n)
#define ssum(a) accumulate(a, 0ll)
#define stirng string
//#define grid_input(a,type) int h,w;std::cin >>
//h>>w;vvector(a,type,h,w,0);reprep(i,j,h,w)std::cin >> a[i][j];
// typedef long long T;
ll ceil(ll a, ll b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
// const ll INF64 =3223372036854775807ll;
const ll INF64 = 9223372036854775807ll;
// const ll INF64 = 9223372036854775ll;
const ll MOD = 1000000007ll;
// const ll MOD = 1000003ll;
const ll OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n, ll MOD) { //累乗の余剰
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
//メモ
// tuple<hoge,huga,foo> tのget関数はget<i>(t)
// resizeはメンバ関数
//三項演算子を覚えよう
// a?b:cと書くと aならばbの処理をする
// i本目にbitをたてる -> (1<<i)
int main() {
int n;
std::cin >> n;
VEC(ll, a, n);
vvector(dp, ll, n + 1, n + 1, 0);
// rep(i,n)dp[i][i+1]=a[i];
a.insert(a.begin(), 0);
rep(i, n) a[i + 1] += a[i];
// vout(a);
rrep(i, 2, n + 1) {
rep(j, n - i + 1) {
ll d = INF64;
rep(k, i - 1) {
chmin(d, dp[j][j + k + 1] + dp[j + k + 1][i + j]);
// pppri(j,j+k+1,i+j);
}
dp[j][i + j] = d + a[i + j] - a[j];
// pppri(i,j,dp[j][i+j]);
}
}
/*
rep(i,n+1){
vout(dp[i]);
std::cout << std::endl;
}
*/
std::cout << dp[0][n] << std::endl;
} | [] | 981,436 | 981,437 | u539011156 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int find(ll a[], int n) {
ll c[n + 1][n + 1];
ll sums[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
ll s = 0;
for (int j = i; j <= n; j++) {
s += a[j];
sums[i][j] = s;
}
}
for (int s = 0; s < n; s++) {
for (int i = 1, j = i + s; i <= n && j <= n; i++, j++) {
if (i == j)
c[i][j] = 0;
else if (j == i + 1)
c[i][j] = sums[i][j];
else {
c[i][j] = INT64_MAX;
for (int k = i; k < j; k++) {
ll temp = c[i][k] + c[k + 1][j] + sums[i][k] + sums[k + 1][j];
c[i][j] = min(c[i][j], temp);
}
}
}
}
return c[1][n];
}
int main() {
int n;
cin >> n;
ll a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << find(a, n);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll find(ll a[], int n) {
ll c[n + 1][n + 1];
ll sums[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
ll s = 0;
for (int j = i; j <= n; j++) {
s += a[j];
sums[i][j] = s;
}
}
for (int s = 0; s < n; s++) {
for (int i = 1, j = i + s; i <= n && j <= n; i++, j++) {
if (i == j)
c[i][j] = 0;
else if (j == i + 1)
c[i][j] = sums[i][j];
else {
c[i][j] = INT64_MAX;
for (int k = i; k < j; k++) {
ll temp = c[i][k] + c[k + 1][j] + sums[i][k] + sums[k + 1][j];
c[i][j] = min(c[i][j], temp);
}
}
}
}
return c[1][n];
}
int main() {
int n;
cin >> n;
ll a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << find(a, n);
return 0;
}
| [] | 981,438 | 981,439 | u535367554 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int find(int a[], int n) {
ll c[n + 1][n + 1];
ll sums[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
int s = 0;
for (int j = i; j <= n; j++) {
s += a[j];
sums[i][j] = s;
}
}
for (int s = 0; s < n; s++) {
for (int i = 1, j = i + s; i <= n && j <= n; i++, j++) {
if (i == j)
c[i][j] = 0;
else if (j == i + 1)
c[i][j] = sums[i][j];
else {
c[i][j] = INT64_MAX;
for (int k = i; k < j; k++) {
ll temp = c[i][k] + c[k + 1][j] + sums[i][k] + sums[k + 1][j];
c[i][j] = min(c[i][j], temp);
}
}
}
}
return c[1][n];
}
int main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << find(a, n);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll find(ll a[], int n) {
ll c[n + 1][n + 1];
ll sums[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
ll s = 0;
for (int j = i; j <= n; j++) {
s += a[j];
sums[i][j] = s;
}
}
for (int s = 0; s < n; s++) {
for (int i = 1, j = i + s; i <= n && j <= n; i++, j++) {
if (i == j)
c[i][j] = 0;
else if (j == i + 1)
c[i][j] = sums[i][j];
else {
c[i][j] = INT64_MAX;
for (int k = i; k < j; k++) {
ll temp = c[i][k] + c[k + 1][j] + sums[i][k] + sums[k + 1][j];
c[i][j] = min(c[i][j], temp);
}
}
}
}
return c[1][n];
}
int main() {
int n;
cin >> n;
ll a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << find(a, n);
return 0;
}
| [
"variable_declaration.type.change"
] | 981,440 | 981,439 | u535367554 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int find(int a[], int n) {
ll c[n + 1][n + 1];
ll sums[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
int s = 0;
for (int j = i; j <= n; j++) {
s += a[j];
sums[i][j] = s;
}
}
for (int s = 0; s < n; s++) {
for (int i = 1, j = i + s; i <= n && j <= n; i++, j++) {
if (i == j)
c[i][j] = 0;
else if (j == i + 1)
c[i][j] = sums[i][j];
else {
c[i][j] = INT32_MAX;
for (int k = i; k < j; k++) {
ll temp = c[i][k] + c[k + 1][j] + sums[i][k] + sums[k + 1][j];
c[i][j] = min(c[i][j], temp);
}
}
}
}
return c[1][n];
}
int main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << find(a, n);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll find(ll a[], int n) {
ll c[n + 1][n + 1];
ll sums[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
ll s = 0;
for (int j = i; j <= n; j++) {
s += a[j];
sums[i][j] = s;
}
}
for (int s = 0; s < n; s++) {
for (int i = 1, j = i + s; i <= n && j <= n; i++, j++) {
if (i == j)
c[i][j] = 0;
else if (j == i + 1)
c[i][j] = sums[i][j];
else {
c[i][j] = INT64_MAX;
for (int k = i; k < j; k++) {
ll temp = c[i][k] + c[k + 1][j] + sums[i][k] + sums[k + 1][j];
c[i][j] = min(c[i][j], temp);
}
}
}
}
return c[1][n];
}
int main() {
int n;
cin >> n;
ll a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << find(a, n);
return 0;
}
| [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change"
] | 981,441 | 981,439 | u535367554 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
int a[401];
ll dp[401][401];
ll solve(int l, int r) {
if (dp[l][r] != -1)
return dp[l][r];
int sum = 0;
if (l == r)
return 0;
for (int i = l; i <= r; i++) {
sum += a[i];
}
ll mn = 1e18;
for (int i = l; i < r; i++) {
mn = min(mn, solve(l, i) + solve(i + 1, r));
}
sum += mn;
return dp[l][r] = sum;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dp[i][j] = -1;
}
// solve(0, n-1);
// for(int i = 0; i < n; i++)
// {
// for(int j = 0; j < n; j++)
// {
// cout << dp[i][j] << ' ';
// }
// cout << endl;
// }
cout << solve(0, n - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
int a[401];
ll dp[401][401];
ll solve(int l, int r) {
if (dp[l][r] != -1)
return dp[l][r];
ll sum = 0;
if (l == r)
return 0;
for (int i = l; i <= r; i++) {
sum += a[i];
}
ll mn = 1e18;
for (int i = l; i < r; i++) {
mn = min(mn, solve(l, i) + solve(i + 1, r));
}
sum += mn;
return dp[l][r] = sum;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dp[i][j] = -1;
}
// solve(0, n-1);
// for(int i = 0; i < n; i++)
// {
// for(int j = 0; j < n; j++)
// {
// cout << dp[i][j] << ' ';
// }
// cout << endl;
// }
cout << solve(0, n - 1) << endl;
} | [
"variable_declaration.type.change"
] | 981,449 | 981,450 | u048420094 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
int a[401];
ll dp[401][401];
ll solve(int l, int r) {
if (dp[l][r] != -1)
return dp[l][r];
int sum = 0;
if (l == r)
return 0;
for (int i = l; i <= r; i++) {
sum += a[i];
}
ll mn = 0x7fffffff;
for (int i = l; i < r; i++) {
mn = min(mn, solve(l, i) + solve(i + 1, r));
}
sum += mn;
return dp[l][r] = sum;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dp[i][j] = -1;
}
// solve(0, n-1);
// for(int i = 0; i < n; i++)
// {
// for(int j = 0; j < n; j++)
// {
// cout << dp[i][j] << ' ';
// }
// cout << endl;
// }
cout << solve(0, n - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
int a[401];
ll dp[401][401];
ll solve(int l, int r) {
if (dp[l][r] != -1)
return dp[l][r];
ll sum = 0;
if (l == r)
return 0;
for (int i = l; i <= r; i++) {
sum += a[i];
}
ll mn = 1e18;
for (int i = l; i < r; i++) {
mn = min(mn, solve(l, i) + solve(i + 1, r));
}
sum += mn;
return dp[l][r] = sum;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dp[i][j] = -1;
}
// solve(0, n-1);
// for(int i = 0; i < n; i++)
// {
// for(int j = 0; j < n; j++)
// {
// cout << dp[i][j] << ' ';
// }
// cout << endl;
// }
cout << solve(0, n - 1) << endl;
} | [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change"
] | 981,451 | 981,450 | u048420094 | cpp |
p03173 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
vector<ll> prefix;
ll dp[401][401];
ll minCost(vector<int> a, int i, int j) {
if (i >= j) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
ll sum = 0;
if (i > 0) {
sum = prefix[j] - prefix[i - 1];
} else {
sum = prefix[j];
}
ll ans = INT_MAX;
for (int k = i; k < j; k++) {
ll int temp = sum + minCost(a, i, k) + minCost(a, k + 1, j);
ans = min(ans, temp);
}
return dp[i][j] = ans;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
prefix.resize(n);
prefix[0] = a[0];
for (int i = 1; i < n; i++) {
prefix[i] = a[i] + prefix[i - 1];
}
memset(dp, -1, sizeof(dp));
cout << minCost(a, 0, n - 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
vector<ll> prefix;
ll dp[401][401];
ll minCost(vector<ll int> a, int i, int j) {
if (i >= j) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
ll sum = 0;
if (i > 0) {
sum = prefix[j] - prefix[i - 1];
} else {
sum = prefix[j];
}
ll ans = LLONG_MAX;
for (int k = i; k < j; k++) {
ll int temp = sum + minCost(a, i, k) + minCost(a, k + 1, j);
ans = min(ans, temp);
}
return dp[i][j] = ans;
}
int main() {
int n;
cin >> n;
vector<ll int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
prefix.resize(n);
prefix[0] = a[0];
for (int i = 1; i < n; i++) {
prefix[i] = a[i] + prefix[i - 1];
}
memset(dp, -1, sizeof(dp));
cout << minCost(a, 0, n - 1) << endl;
}
| [
"variable_declaration.value.change",
"identifier.change"
] | 981,454 | 981,455 | u348267046 | cpp |
p03173 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[401][401];
ll prefix[401];
ll v[401];
ll solve(int i, int j) {
if (i >= j) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
ll ans = LLONG_MAX;
ll s;
if (i > 0) {
s = prefix[j] - prefix[i - 1];
} else {
s = prefix[j];
}
for (int k = i; k < j; k++) {
ll left;
ll right;
if (dp[i][k] != -1) {
left = dp[i][k];
} else {
left = solve(i, k);
dp[i][k] = left;
}
if (dp[k + 1][j] != -1) {
right = dp[k + 1][j];
} else {
right = solve(k + 1, j);
dp[k + 1][j] = right;
}
ll temp = s + left + right;
ans = min(ans, temp);
}
return dp[i][j] = ans;
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> v[i];
}
prefix[0] = v[0];
for (int i = 1; i < n; i++) {
prefix[i] = prefix[i - 1] + v[i];
}
cout << solve(0, n);
} |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[401][401];
ll prefix[401];
ll v[401];
ll solve(int i, int j) {
if (i >= j) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
ll ans = LLONG_MAX;
ll s;
if (i > 0) {
s = prefix[j] - prefix[i - 1];
} else {
s = prefix[j];
}
for (int k = i; k < j; k++) {
ll left;
ll right;
if (dp[i][k] != -1) {
left = dp[i][k];
} else {
left = solve(i, k);
dp[i][k] = left;
}
if (dp[k + 1][j] != -1) {
right = dp[k + 1][j];
} else {
right = solve(k + 1, j);
dp[k + 1][j] = right;
}
ll temp = s + left + right;
ans = min(ans, temp);
}
return dp[i][j] = ans;
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> v[i];
}
prefix[0] = v[0];
for (int i = 1; i < n; i++) {
prefix[i] = prefix[i - 1] + v[i];
}
cout << solve(0, n - 1);
} | [
"expression.operation.binary.add"
] | 981,456 | 981,457 | u348267046 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
const int N = 405;
const int A = 1e9 + 5;
int sl[N];
int64_t dp[N][N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> sl[i], dp[i][i] = 0;
auto sum = [&](int L, int R) {
int64_t s = 0;
for (int i = L; i <= R; i++) {
s += sl[i];
}
return s;
};
for (int len = 2; len <= n; len++) {
for (int L = 1; L <= n - len + 1; L++) {
int R = L + len - 1;
dp[L][R] = INT32_MAX;
int64_t s = sum(L, R);
for (int i = L; i < R; i++) {
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i + 1][R] + s);
}
}
}
cout << dp[1][n];
// for (int i = 1; i <= n; i++) {
// for (int j = 1; j <= n; j++) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 405;
const int A = 1e9 + 5;
int sl[N];
int64_t dp[N][N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> sl[i], dp[i][i] = 0;
auto sum = [&](int L, int R) {
int64_t s = 0;
for (int i = L; i <= R; i++) {
s += sl[i];
}
return s;
};
for (int len = 2; len <= n; len++) {
for (int L = 1; L <= n - len + 1; L++) {
int R = L + len - 1;
dp[L][R] = INT64_MAX;
int64_t s = sum(L, R);
for (int i = L; i < R; i++) {
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i + 1][R] + s);
}
}
}
cout << dp[1][n];
// for (int i = 1; i <= n; i++) {
// for (int j = 1; j <= n; j++) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 981,469 | 981,470 | u479813076 | cpp |
p03173 | #include <bits/stdc++.h>
#define FAST_INPUT \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define ll long long
using namespace std;
const int mxn = 405;
ll dp[mxn][mxn];
ll INF = 1e18 + 100;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto sum = [&](int L, int R) {
int s = 0;
for (int i = L; i <= R; i++) {
s += a[i];
}
return s;
};
for (int L = n - 1; L >= 0; L--) {
for (int R = L; R < n; R++) {
if (L == R) {
dp[L][R] = 0;
} else {
dp[L][R] = INF;
ll s = sum(L, R);
for (int i = L; i <= R - 1; i++) {
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i + 1][R] + s);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
int main() {
FAST_INPUT;
solve();
return 0;
}
| #include <bits/stdc++.h>
#define FAST_INPUT \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define ll long long
using namespace std;
const int mxn = 405;
ll dp[mxn][mxn];
ll INF = 1e18 + 100;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto sum = [&](int L, int R) {
ll s = 0;
for (int i = L; i <= R; i++) {
s += a[i];
}
return s;
};
for (int L = n - 1; L >= 0; L--) {
for (int R = L; R < n; R++) {
if (L == R) {
dp[L][R] = 0;
} else {
dp[L][R] = INF;
ll s = sum(L, R);
for (int i = L; i <= R - 1; i++) {
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i + 1][R] + s);
}
}
}
}
cout << dp[0][n - 1] << endl;
}
int main() {
FAST_INPUT;
solve();
return 0;
}
| [
"variable_declaration.type.change"
] | 981,485 | 981,486 | u278805281 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
const ll INF = 2e18;
int n;
vector<int> nums(405, 0);
ll sum(int l, int r) {
ll sum = 0;
for (int i = l; i <= r; i++) {
sum += nums[i];
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#define int ll
cin >> n;
for (int i = 0; i <= n; i++)
cin >> nums[i];
vector<vector<int>> dp(n + 1, vector<int>(n + 1, INF));
for (int left = n; left >= 1; left--) {
for (int right = 1; right <= n; right++) {
if (right < left)
continue;
if (left == right) {
dp[left][left] = 0;
continue;
}
int summation = sum(left, right);
for (int i = left; i <= right - 1; i++) {
dp[left][right] =
min(dp[left][right], dp[left][i] + dp[i + 1][right] + summation);
}
}
}
cout << dp[1][n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
const ll INF = 2e18;
int n;
vector<int> slimes(405, 0);
ll sum(int l, int r) {
ll sum = 0;
for (int i = l; i <= r; i++) {
sum += slimes[i];
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#define int ll
cin >> n;
for (int i = 1; i <= n; i++)
cin >> slimes[i];
vector<vector<int>> dp(n + 1, vector<int>(n + 1, INF));
for (int left = n; left >= 1; left--) {
for (int right = 1; right <= n; right++) {
if (right < left)
continue;
if (left == right) {
dp[left][left] = 0;
continue;
}
int summation = sum(left, right);
for (int i = left; i <= right - 1; i++) {
dp[left][right] =
min(dp[left][right], dp[left][i] + dp[i + 1][right] + summation);
}
}
}
cout << dp[1][n] << endl;
return 0;
}
| [
"variable_declaration.name.change",
"identifier.change",
"assignment.value.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 981,487 | 981,488 | u414957786 | cpp |
p03173 | /*
() ()()()() () () () () ()
()() () () ()() () ()() ()() ()
() () () () () () () () () () () ()
()()()() () () () () () ()()()() () () ()
() () () () () ()() () () () ()()
() () ()()()() () () () () () ()
*/
#include <bits/stdc++.h>
#define MOD (int)(1e9 + 7)
#define SIZE (int)(1e5 + 5)
#define all(x) x.begin(), x.end()
#define si(i) scanf("%d", &i)
#define sf(f) scanf("%f", &f)
#define pi(i) printf("%d", i)
#define pd(d) printf("%lf", d)
#define deb(x) cout << #x << " is " << x << "\n";
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define prDouble(x) cout << fixed << setprecision(10) << x;
#define IOfast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
int64_t exponentiation(int64_t base, int exp) {
if (exp == 0)
return 1;
if (exp == 1)
return base;
int64_t t = exponentiation(base, exp / 2);
t = (t * t);
if (exp % 2 == 0)
return t;
else
return base * t;
}
int64_t dp[401][401];
int64_t solve(vector<int64_t> &arr, int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int64_t sum = accumulate(arr.begin() + i, arr.begin() + j + 1, 0);
int64_t ans = LLONG_MAX;
for (int k = i; k < j; k++)
ans = min(solve(arr, i, k) + solve(arr, k + 1, j), ans);
ans += sum;
return dp[i][j] = ans;
}
int main() {
IOfast;
int q = 1;
// cin>>q;
memset(dp, -1, sizeof(dp));
while (q--) {
int n;
cin >> n;
vector<int64_t> arr(n);
for (auto &item : arr)
cin >> item;
cout << solve(arr, 0, n - 1);
}
return 0;
}
| /*
() ()()()() () () () () ()
()() () () ()() () ()() ()() ()
() () () () () () () () () () () ()
()()()() () () () () () ()()()() () () ()
() () () () () ()() () () () ()()
() () ()()()() () () () () () ()
*/
#include <bits/stdc++.h>
#define MOD (int)(1e9 + 7)
#define SIZE (int)(1e5 + 5)
#define all(x) x.begin(), x.end()
#define si(i) scanf("%d", &i)
#define sf(f) scanf("%f", &f)
#define pi(i) printf("%d", i)
#define pd(d) printf("%lf", d)
#define deb(x) cout << #x << " is " << x << "\n";
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define prDouble(x) cout << fixed << setprecision(10) << x;
#define IOfast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
int64_t exponentiation(int64_t base, int exp) {
if (exp == 0)
return 1;
if (exp == 1)
return base;
int64_t t = exponentiation(base, exp / 2);
t = (t * t);
if (exp % 2 == 0)
return t;
else
return base * t;
}
// int in_between;
// vector <int> index[26];
int64_t dp[401][401];
int64_t solve(vector<int64_t> &arr, int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int64_t sum = accumulate(arr.begin() + i, arr.begin() + j + 1, (int64_t)0);
int64_t ans = LLONG_MAX;
for (int k = i; k < j; k++)
ans = min(solve(arr, i, k) + solve(arr, k + 1, j), ans);
ans += sum;
return dp[i][j] = ans;
}
// int arr[(int)1e3+1][(int)1e3+1];
int main() {
IOfast;
int q = 1;
// cin>>q;
memset(dp, -1, sizeof(dp));
while (q--) {
int n;
cin >> n;
vector<int64_t> arr(n);
for (auto &item : arr)
cin >> item;
cout << solve(arr, 0, n - 1);
}
return 0;
}
| [
"type_conversion.add"
] | 981,496 | 981,497 | u651612828 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define nn 401
#define inf (1LL << 60)
int n;
int a[nn], dp[nn][nn], sum[nn][nn];
void preprocess() {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
sum[i][j] = a[j] + ((j == i) ? 0 : sum[i][j - 1]);
}
}
}
int solve(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int minCost = INT_MAX;
for (int k = i; k < j; k++) {
minCost = min(minCost, sum[i][j] + solve(i, k) + solve(k + 1, j));
}
return dp[i][j] = minCost;
}
int32_t main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
preprocess();
cout << solve(1, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define nn 401
#define inf (1LL << 60)
int n;
int a[nn], dp[nn][nn], sum[nn][nn];
void preprocess() {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
sum[i][j] = a[j] + ((j == i) ? 0 : sum[i][j - 1]);
}
}
}
int solve(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int minCost = inf;
for (int k = i; k < j; k++) {
minCost = min(minCost, sum[i][j] + solve(i, k) + solve(k + 1, j));
}
return dp[i][j] = minCost;
}
int32_t main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
preprocess();
cout << solve(1, n);
}
| [
"variable_declaration.value.change",
"identifier.change"
] | 981,498 | 981,499 | u093748998 | cpp |
p03173 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long int
#define mp make_pair
#define pb push_back
#define fi first
#define si second
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define F(a, n) \
for (int i = 0; i < n; i++) { \
cin >> a[i]; \
}
#define F1(a, n) \
for (int i = 1; i <= n; i++) { \
cin >> a[i]; \
}
#define P(a, n) \
for (int i = 0; i < n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define P1(a, n) \
for (int i = 1; i <= n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define NF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cin >> a[i][j]; \
} \
}
#define NF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cin >> a[i][j]; \
} \
}
#define PNF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define PNF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define AS 200001
#define mod 1000000007
#define inf (1LL << 60)
ll dp[3001][3001];
ll sum[3001][3001];
ll solve(vector<int> &v, int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll minCost;
for (int k = i; k < j; k++) {
minCost = (minCost, sum[i][j] + solve(v, i, k) + solve(v, k + 1, j));
}
return dp[i][j] = minCost;
}
void preprocess(vector<int> &v, int n) {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
sum[i][j] = v[j] + ((j == i) ? 0 : sum[i][j - 1]);
}
}
}
int main() {
fastIO int n;
cin >> n;
vector<int> v;
memset(dp, -1, sizeof dp);
v.resize(n + 1);
F1(v, n);
preprocess(v, n);
// P1(v, n);
cout << solve(v, 1, n);
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long int
#define mp make_pair
#define pb push_back
#define fi first
#define si second
#define fastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define F(a, n) \
for (int i = 0; i < n; i++) { \
cin >> a[i]; \
}
#define F1(a, n) \
for (int i = 1; i <= n; i++) { \
cin >> a[i]; \
}
#define P(a, n) \
for (int i = 0; i < n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define P1(a, n) \
for (int i = 1; i <= n; i++) { \
cout << a[i] << ' '; \
} \
cout << endl;
#define NF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cin >> a[i][j]; \
} \
}
#define NF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cin >> a[i][j]; \
} \
}
#define PNF(a, n, m) \
for (int i = 0; i < n; i++) { \
for (int j = 0; j < m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define PNF1(a, n, m) \
for (int i = 1; i <= n; i++) { \
for (int j = 1; j <= m; j++) { \
cout << a[i][j] << ' '; \
} \
cout << endl; \
} \
cout << endl;
#define AS 200001
#define mod 1000000007
#define inf (1LL << 60)
ll dp[3001][3001];
ll sum[3001][3001];
ll solve(vector<int> &v, int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll minCost = inf;
for (int k = i; k < j; k++) {
minCost = min(minCost, sum[i][j] + solve(v, i, k) + solve(v, k + 1, j));
}
return dp[i][j] = minCost;
}
void preprocess(vector<int> &v, int n) {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
sum[i][j] = v[j] + ((j == i) ? 0 : sum[i][j - 1]);
}
}
}
int main() {
fastIO int n;
cin >> n;
vector<int> v;
memset(dp, -1, sizeof dp);
v.resize(n + 1);
F1(v, n);
preprocess(v, n);
// P1(v, n);
cout << solve(v, 1, n);
} | [
"variable_declaration.value.change",
"call.add"
] | 981,504 | 981,505 | u409668302 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf pow(10, 18);
vector<ll> arr;
vector<vector<ll>> dp;
vector<vector<ll>> cost;
pair<ll, ll> help(int i, int j) {
if (i > j)
return {0, 0};
if (i == j) {
dp[i][j] = arr[i];
cost[i][j] = dp[i][j];
return {0, dp[i][j]};
}
if (cost[i][j] != -1)
return {cost[i][j], dp[i][j]};
ll mn = inf;
for (int x = i; x < j; x++) {
auto p1 = help(i, x), p2 = help(x + 1, j);
dp[i][j] = p1.second + p2.second;
mn = min(p1.first + p2.first + dp[i][j], mn);
}
cost[i][j] = mn;
return {cost[i][j], dp[i][j]};
}
int main() {
int n;
cin >> n;
arr.resize(n);
dp.resize(n, vector<ll>(n, -1));
cost.resize(n, vector<ll>(n, -1));
for (int i = 0; i < n; i++)
cin >> arr[i];
auto x = help(0, n - 1);
cout << x.first - x.second;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf pow(10, 18);
vector<ll> arr;
vector<vector<ll>> dp;
vector<vector<ll>> cost;
pair<ll, ll> help(int i, int j) {
if (i > j)
return {0, 0};
if (i == j) {
dp[i][j] = arr[i];
cost[i][j] = dp[i][j];
return {0, dp[i][j]};
}
if (cost[i][j] != -1)
return {cost[i][j], dp[i][j]};
ll mn = inf;
for (int x = i; x < j; x++) {
auto p1 = help(i, x), p2 = help(x + 1, j);
dp[i][j] = p1.second + p2.second;
mn = min(p1.first + p2.first + dp[i][j], mn);
}
cost[i][j] = mn;
return {cost[i][j], dp[i][j]};
}
int main() {
int n;
cin >> n;
arr.resize(n);
dp.resize(n, vector<ll>(n, -1));
cost.resize(n, vector<ll>(n, -1));
for (int i = 0; i < n; i++)
cin >> arr[i];
auto x = help(0, n - 1);
cout << x.first;
return 0;
} | [
"expression.operation.binary.remove"
] | 981,506 | 981,507 | u651012287 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll maxn = 1e9 + 7;
ll dp[500][500]; // dp[i][j] represents total cost from i to j;
vector<ll> v;
ll sum(ll l, ll r) {
ll s = 0;
for (ll i = l; i <= r; i++)
s += v[i];
return s;
}
int main() {
ll n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
ll x;
cin >> x;
v.push_back(x);
}
for (ll l = n - 1; l >= 0; l--) {
for (ll r = l; r < n; r++) {
if (l == r) {
dp[l][r] = 0;
continue;
}
dp[l][r] = maxn;
ll s = sum(l, r);
for (i = l; i < r; i++)
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + s);
}
}
cout << dp[0][n - 1] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll maxn = 1e18 + 7;
ll dp[500][500]; // dp[i][j] represents total cost from i to j;
vector<ll> v;
ll sum(ll l, ll r) {
ll s = 0;
for (ll i = l; i <= r; i++)
s += v[i];
return s;
}
int main() {
ll n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
ll x;
cin >> x;
v.push_back(x);
}
for (ll l = n - 1; l >= 0; l--) {
for (ll r = l; r < n; r++) {
if (l == r) {
dp[l][r] = 0;
continue;
}
dp[l][r] = maxn;
ll s = sum(l, r);
for (i = l; i < r; i++)
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + s);
}
}
cout << dp[0][n - 1] << "\n";
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 981,509 | 981,510 | u857888442 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp[3001][3001];
ll sum[3001][3001];
ll slimes(vector<ll> &v, int i, int j) {
if (i == j) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
ll minCost = INT_MAX;
for (int k = i; k < j; k++) {
minCost = min(minCost, sum[i][j] + slimes(v, i, k) + slimes(v, k + 1, j));
}
return dp[i][j] = minCost;
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
sum[i][j] = v[j] + ((j == i) ? 0 : sum[i][j - 1]);
}
}
cout << slimes(v, 0, n - 1);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll dp[3001][3001];
ll sum[3001][3001];
ll slimes(vector<ll> &v, int i, int j) {
if (i == j) {
return 0;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
ll minCost = 1000000000000000;
for (int k = i; k < j; k++) {
minCost = min(minCost, sum[i][j] + slimes(v, i, k) + slimes(v, k + 1, j));
}
return dp[i][j] = minCost;
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
sum[i][j] = v[j] + ((j == i) ? 0 : sum[i][j - 1]);
}
}
cout << slimes(v, 0, n - 1);
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,516 | 981,515 | u510516229 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
#define debug(var) \
do { \
std::cout << #var << " : "; \
view(var); \
} while (0)
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
view(v);
}
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int MOD = 1000000007;
const int INF = 1e9;
const int mod = 1000000007;
const int inf = 1e9;
#define PI acos(-1);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int ddx[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int ddy[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int f[410][410] = {0};
int dp[410][410];
int n;
vector<ll> a;
vector<ll> sum;
ll rec(int i, int j) {
if (f[i][j] == 1)
return dp[i][j];
f[i][j] = 1;
if (i == j)
return 0;
ll ret = 1e18;
for (int k = i; k < j; k++) {
chmin(ret, rec(i, k) + rec(k + 1, j));
}
return dp[i][j] = ret + sum[j + 1] - sum[i];
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sum.assign(n + 1, 0);
for (int i = 0; i < n; i++)
sum[i + 1] = sum[i] + a[i];
ll ans = rec(0, n - 1);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
#define debug(var) \
do { \
std::cout << #var << " : "; \
view(var); \
} while (0)
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
view(v);
}
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int MOD = 1000000007;
const int INF = 1e9;
const int mod = 1000000007;
const int inf = 1e9;
#define PI acos(-1);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int ddx[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int ddy[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int f[410][410] = {0};
ll dp[410][410];
int n;
vector<ll> a;
vector<ll> sum;
ll rec(int i, int j) {
if (f[i][j] == 1)
return dp[i][j];
f[i][j] = 1;
if (i == j)
return 0;
ll ret = 1e18;
for (int k = i; k < j; k++) {
chmin(ret, rec(i, k) + rec(k + 1, j));
}
return dp[i][j] = ret + sum[j + 1] - sum[i];
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sum.assign(n + 1, 0);
for (int i = 0; i < n; i++)
sum[i + 1] = sum[i] + a[i];
ll ans = rec(0, n - 1);
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 981,519 | 981,520 | u279033107 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
#define debug(var) \
do { \
std::cout << #var << " : "; \
view(var); \
} while (0)
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
view(v);
}
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int MOD = 1000000007;
const int INF = 1e9;
const int mod = 1000000007;
const int inf = 1e9;
#define PI acos(-1);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int ddx[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int ddy[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int f[410][410] = {0};
int dp[410][410];
int n;
vector<int> a;
vector<int> sum;
ll rec(int i, int j) {
if (f[i][j] == 1)
return dp[i][j];
f[i][j] = 1;
if (i == j)
return 0;
ll ret = 1e18;
for (int k = i; k < j; k++) {
chmin(ret, rec(i, k) + rec(k + 1, j));
}
return dp[i][j] = ret + sum[j + 1] - sum[i];
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sum.assign(n + 1, 0);
for (int i = 0; i < n; i++)
sum[i + 1] = sum[i] + a[i];
ll ans = rec(0, n - 1);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
#define debug(var) \
do { \
std::cout << #var << " : "; \
view(var); \
} while (0)
template <typename T> void view(T e) { std::cout << e << std::endl; }
template <typename T> void view(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void view(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
view(v);
}
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int MOD = 1000000007;
const int INF = 1e9;
const int mod = 1000000007;
const int inf = 1e9;
#define PI acos(-1);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int ddx[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int ddy[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int f[410][410] = {0};
ll dp[410][410];
int n;
vector<ll> a;
vector<ll> sum;
ll rec(int i, int j) {
if (f[i][j] == 1)
return dp[i][j];
f[i][j] = 1;
if (i == j)
return 0;
ll ret = 1e18;
for (int k = i; k < j; k++) {
chmin(ret, rec(i, k) + rec(k + 1, j));
}
return dp[i][j] = ret + sum[j + 1] - sum[i];
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sum.assign(n + 1, 0);
for (int i = 0; i < n; i++)
sum[i + 1] = sum[i] + a[i];
ll ans = rec(0, n - 1);
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 981,521 | 981,520 | u279033107 | cpp |
p03173 | #include <bits/stdc++.h>
#define endl '\n'
#define PI 3.14159265358979323844
#define DECIMAL(n) \
std::cout << std::fixed; \
std::cout << std::setprecision(n);
#define mp make_pair
#define pb push_back
#define int long long int
#define forr(i, a, b) for (int i = a; i < b; ++i)
using namespace std;
int dp[3000][3000];
int csum[3000][3000];
void pre(int *a, int n) {
forr(i, 1, n + 1) {
forr(j, i, n + 1) {
if (i == j)
csum[i][j] = a[j];
else
csum[i][j] = (a[j] + csum[i][j - 1]);
}
}
}
int mixtures(int *a, int s, int e) {
if (s == e)
return 0;
if (dp[s][e] != -1)
return dp[s][e];
int ans = (1 << 60);
forr(i, s, e) {
ans = min(ans, (mixtures(a, s, i) + mixtures(a, i + 1, e) + csum[s][e]));
}
return dp[s][e] = ans;
}
signed main() {
int n;
cin >> n;
int a[n + 5];
forr(i, 1, n + 1) cin >> a[i];
memset(dp, -1, sizeof dp);
memset(csum, 0, sizeof csum);
pre(a, n);
cout << mixtures(a, 1, n);
} | #include <bits/stdc++.h>
#define endl '\n'
#define PI 3.14159265358979323844
#define DECIMAL(n) \
std::cout << std::fixed; \
std::cout << std::setprecision(n);
#define mp make_pair
#define pb push_back
#define int long long int
#define forr(i, a, b) for (int i = a; i < b; ++i)
using namespace std;
int dp[3000][3000];
int csum[3000][3000];
void pre(int *a, int n) {
forr(i, 1, n + 1) {
forr(j, i, n + 1) {
if (i == j)
csum[i][j] = a[j];
else
csum[i][j] = (a[j] + csum[i][j - 1]);
}
}
}
int mixtures(int *a, int s, int e) {
if (s == e)
return 0;
if (dp[s][e] != -1)
return dp[s][e];
int ans = (1ll << 60);
forr(i, s, e) {
ans = min(ans, (mixtures(a, s, i) + mixtures(a, i + 1, e) + csum[s][e]));
}
return dp[s][e] = ans;
}
signed main() {
int n;
cin >> n;
int a[n + 5];
forr(i, 1, n + 1) cin >> a[i];
memset(dp, -1, sizeof dp);
memset(csum, 0, sizeof csum);
pre(a, n);
cout << mixtures(a, 1, n);
} | [] | 981,531 | 981,532 | u594918324 | cpp |
p03173 | #include <iostream>
using namespace std;
long rec(int a[], int n, long **mem, int i, int j, int sum[]) {
if (i == j)
return 0;
if (mem[i][j] != 1e18)
return mem[i][j];
for (int k = i; k <= j; k++)
mem[i][j] =
min(mem[i][j], rec(a, n, mem, i, k, sum) +
rec(a, n, mem, k + 1, j, sum) + sum[j + 1] - sum[i]);
return mem[i][j];
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
long **mem = new long *[n + 1];
for (int i = 0; i <= n; i++) {
mem[i] = new long[n + 1];
for (int j = 0; j <= n; j++)
mem[i][j] = 1e18;
}
int sum[n + 1];
for (int i = 1; i <= n; i++)
sum[i] = a[i - 1];
sum[0] = 0;
for (int i = 1; i <= n; i++)
sum[i] += sum[i - 1];
cout << rec(a, n, mem, 0, n - 1, sum);
} | #include <iostream>
using namespace std;
long rec(int a[], int n, long **mem, int i, int j, long sum[]) {
if (i == j)
return 0;
if (mem[i][j] != 1e18)
return mem[i][j];
for (int k = i; k <= j; k++)
mem[i][j] =
min(mem[i][j], rec(a, n, mem, i, k, sum) +
rec(a, n, mem, k + 1, j, sum) + sum[j + 1] - sum[i]);
return mem[i][j];
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
long **mem = new long *[n + 1];
for (int i = 0; i <= n; i++) {
mem[i] = new long[n + 1];
for (int j = 0; j <= n; j++)
mem[i][j] = 1e18;
}
long sum[n + 1];
for (int i = 1; i <= n; i++)
sum[i] = a[i - 1];
sum[0] = 0;
for (int i = 1; i <= n; i++)
sum[i] += sum[i - 1];
cout << rec(a, n, mem, 0, n - 1, sum);
} | [
"variable_declaration.type.primitive.change"
] | 981,537 | 981,538 | u933124026 | cpp |
p03173 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<long> v(n);
for (int i = 1; i <= n; i++)
cin >> v[i];
v[0] = 0;
for (int i = 1; i <= n; i++)
v[i] += v[i - 1];
long dp[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++)
dp[i][j] = 1e18;
}
for (int i = 0; i <= n; i++)
dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
for (int k = i; k < j; k++)
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + v[j] - v[i - 1]);
}
}
cout << dp[1][n];
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<long> v(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i];
v[0] = 0;
for (int i = 1; i <= n; i++)
v[i] += v[i - 1];
long dp[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++)
dp[i][j] = 1e18;
}
for (int i = 0; i <= n; i++)
dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
for (int k = i; k < j; k++)
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + v[j] - v[i - 1]);
}
}
cout << dp[1][n];
} | [
"assignment.change"
] | 981,539 | 981,540 | u933124026 | cpp |
p03173 | #include <bits/stdc++.h>
#define db(x) cout << x << " "
#define db1(x) cout << x << '\n'
#define db2(x, y) cout << x << " " << y << '\n'
#define db3(x, y, z) cout << x << " " << y << " " << z << '\n'
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define pair(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define ll long long int
#define vi vector<ll>
#define pi pair<ll, ll>
#define vpi vector<pair<ll, ll>>
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
#define mod 1000000007
#define MAX_N 100000
using namespace std;
// int dx[4] = {1,-1,0,0};
// int dy[4] = {0,0,1,-1};
ll dp[401][401];
ll prefixSum[401];
ll get(vector<ll> &arr, ll i, ll j) {
if (i >= j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll ans = LLONG_MAX;
for (int k = i + 1; k <= j; k++) {
ll temp = get(arr, i, k - 1) + get(arr, k, j);
ll sum = prefixSum[j];
if (i - 1 >= 0)
sum -= prefixSum[i - 1];
ans = min(ans, temp + sum);
}
return dp[i][j] = ans;
}
void preprocess(vector<ll> &arr, ll n) {
prefixSum[0] = arr[0];
repA(i, 1, n - 1) prefixSum[i] = prefixSum[i - 1] + arr[i];
}
void solve() {
ll n;
cin >> n;
memset(dp, 0, sizeof(dp));
vector<ll> arr(n);
rep(i, n) cin >> arr[i];
preprocess(arr, n);
ll result = INT_MAX;
for (int len = 2; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = i + len - 1;
ll ans = INT_MAX;
for (int k = i + 1; k <= j; k++) {
ll temp = dp[i][k - 1] + dp[k][j];
ll sum = prefixSum[j];
if (i - 1 >= 0)
sum -= prefixSum[i - 1];
ans = min(ans, temp + sum);
}
dp[i][j] = ans;
result = min(result, ans);
}
}
db1(dp[0][n - 1]);
}
int main() {
int t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
#define db(x) cout << x << " "
#define db1(x) cout << x << '\n'
#define db2(x, y) cout << x << " " << y << '\n'
#define db3(x, y, z) cout << x << " " << y << " " << z << '\n'
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define pair(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define ll long long int
#define vi vector<ll>
#define pi pair<ll, ll>
#define vpi vector<pair<ll, ll>>
#define ff first
#define ss second
#define all(a) a.begin(), a.end()
#define mod 1000000007
#define MAX_N 100000
using namespace std;
// int dx[4] = {1,-1,0,0};
// int dy[4] = {0,0,1,-1};
ll dp[401][401];
ll prefixSum[401];
ll get(vector<ll> &arr, ll i, ll j) {
if (i >= j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll ans = LLONG_MAX;
for (int k = i + 1; k <= j; k++) {
ll temp = get(arr, i, k - 1) + get(arr, k, j);
ll sum = prefixSum[j];
if (i - 1 >= 0)
sum -= prefixSum[i - 1];
ans = min(ans, temp + sum);
}
return dp[i][j] = ans;
}
void preprocess(vector<ll> &arr, ll n) {
prefixSum[0] = arr[0];
repA(i, 1, n - 1) prefixSum[i] = prefixSum[i - 1] + arr[i];
}
void solve() {
ll n;
cin >> n;
memset(dp, 0, sizeof(dp));
vector<ll> arr(n);
rep(i, n) cin >> arr[i];
preprocess(arr, n);
ll result = LLONG_MAX;
for (int len = 2; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = i + len - 1;
ll ans = LLONG_MAX;
for (int k = i + 1; k <= j; k++) {
ll temp = dp[i][k - 1] + dp[k][j];
ll sum = prefixSum[j];
if (i - 1 >= 0)
sum -= prefixSum[i - 1];
ans = min(ans, temp + sum);
}
dp[i][j] = ans;
result = min(result, ans);
}
}
db1(dp[0][n - 1]);
}
int main() {
int t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
}
| [
"variable_declaration.value.change",
"identifier.change"
] | 981,544 | 981,545 | u483789716 | cpp |
p03173 | /*
Author : DemonStar
*/
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC
// target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, \
tree_order_statistics_node_update>
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pi pair<int, int>
#define pl pair<long long, long long>
#define pld pair<long double, long double>
#define endl '\n'
#define loop(i, n) for (ll i = 0; i < n; i++)
#define rep(i, begin, end) \
for (__typeof(begin) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define all(x) x.begin(), x.end()
#define vl vector<ll>
#define vi vector<int>
#define ml map<ll, ll>
#define vpl vector<pair<ll, ll>>
const ll mod = 1e9 + 7;
template <typename T, typename TT>
ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto &i : t)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v)
is >> t;
return is;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v)
is >> t.first >> t.second;
return is;
}
int main() {
ll n;
cin >> n;
vl v(n);
cin >> v;
rep(i, 1, n) v[i] += v[i - 1];
vector<vl> dp(n, vl(n, 1e9));
for (int i = n - 1; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (i == j)
dp[i][j] = 0;
else {
for (int k = i; k < j; k++)
dp[i][j] = min(dp[i][j],
dp[i][k] + dp[k + 1][j] + v[j] - (i ? v[i - 1] : 0));
}
}
}
cout << dp[0][n - 1] << endl;
#ifdef LOCAL
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
} | /*
Author : DemonStar
*/
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC
// target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx2,tune=native")
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, \
tree_order_statistics_node_update>
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pi pair<int, int>
#define pl pair<long long, long long>
#define pld pair<long double, long double>
#define endl '\n'
#define loop(i, n) for (ll i = 0; i < n; i++)
#define rep(i, begin, end) \
for (__typeof(begin) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define all(x) x.begin(), x.end()
#define vl vector<ll>
#define vi vector<int>
#define ml map<ll, ll>
#define vpl vector<pair<ll, ll>>
const ll mod = 1e9 + 7;
template <typename T, typename TT>
ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto &i : t)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v)
is >> t;
return is;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v)
is >> t.first >> t.second;
return is;
}
int main() {
ll n;
cin >> n;
vl v(n);
cin >> v;
rep(i, 1, n) v[i] += v[i - 1];
vector<vl> dp(n, vl(n, 1e18));
for (int i = n - 1; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (i == j)
dp[i][j] = 0;
else {
for (int k = i; k < j; k++)
dp[i][j] = min(dp[i][j],
dp[i][k] + dp[k + 1][j] + v[j] - (i ? v[i - 1] : 0));
}
}
}
cout << dp[0][n - 1] << endl;
#ifdef LOCAL
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 981,550 | 981,551 | u831139780 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define sz(x) ((long long)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const ld eps = 1e-9;
const ld pi = acosl(-1);
const int mod = 998244353;
const int mod1 = 1e9 + 7;
mt19937_64 rnd(time(0));
void faster() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
}
signed main() {
faster();
// freopen("in", "r", stdin);
// freopen("out", "w", stdout);
//______________________________________
/*__*/ double start = clock(); /*__*/
//_____________________________________
ll n;
cin >> n;
ll a[n];
ll dp[n][n];
ll cost[n][n];
for (ll i = 0; i < n; i++) {
cin >> a[i];
cost[i][i] = a[i];
dp[i][i] = 0;
}
for (ll sz = 1; sz < n; sz++) {
for (ll l = 0; l + sz < n; l++) {
ll r = l + sz;
ll mn = INT_MAX;
for (ll l1 = l; l1 < r; l1++) {
ll now = 0;
now = cost[l][l1] + cost[l1 + 1][r] + dp[l][l1] + dp[l1 + 1][r];
mn = min(mn, now);
}
dp[l][r] = mn;
cost[l][r] = cost[l][r - 1] + a[r];
// cout << l << " " << r << " " << mn << " " << cost[l][r] << endl;
}
}
cout << dp[0][n - 1] << endl;
//______________________________________
cerr << "Time " << (clock() - start) * 1.0 / CLOCKS_PER_SEC << "s\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define sz(x) ((long long)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const ld eps = 1e-9;
const ld pi = acosl(-1);
const int mod = 998244353;
const int mod1 = 1e9 + 7;
mt19937_64 rnd(time(0));
void faster() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
}
signed main() {
faster();
// freopen("in", "r", stdin);
// freopen("out", "w", stdout);
//______________________________________
/*__*/ double start = clock(); /*__*/
//_____________________________________
ll n;
cin >> n;
ll a[n];
ll dp[n][n];
ll cost[n][n];
for (ll i = 0; i < n; i++) {
cin >> a[i];
cost[i][i] = a[i];
dp[i][i] = 0;
}
for (ll sz = 1; sz < n; sz++) {
for (ll l = 0; l + sz < n; l++) {
ll r = l + sz;
ll mn = 1e15;
for (ll l1 = l; l1 < r; l1++) {
ll now = 0;
now = cost[l][l1] + cost[l1 + 1][r] + dp[l][l1] + dp[l1 + 1][r];
mn = min(mn, now);
}
dp[l][r] = mn;
cost[l][r] = cost[l][r - 1] + a[r];
// cout << l << " " << r << " " << mn << " " << cost[l][r] << endl;
}
}
cout << dp[0][n - 1] << endl;
//______________________________________
cerr << "Time " << (clock() - start) * 1.0 / CLOCKS_PER_SEC << "s\n";
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,552 | 981,553 | u834005964 | cpp |
p03173 | #include <iostream>
using namespace std;
const long long INF = 1LL << 60;
int N;
long long a[409];
long long dp[409][409];
long long solve(int l, int r) {
if (l == r)
return 0;
if (dp[l][r] != 0)
return dp[l][r];
long long res = INF;
for (int i = l; i < r; i++)
res = min(res, solve(l, i) + solve(i + 1, r));
res += a[r];
if (l)
res -= a[l - 1];
return dp[l][r] = res;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (i)
a[i] += a[i - 1]; // 累積和を取る
}
cout << solve(1, N) << endl;
return 0;
} | #include <iostream>
using namespace std;
const long long INF = 1LL << 60;
int N;
long long a[409];
long long dp[409][409];
long long solve(int l, int r) {
if (l == r)
return 0;
if (dp[l][r] != 0)
return dp[l][r];
long long res = INF;
for (int i = l; i < r; i++)
res = min(res, solve(l, i) + solve(i + 1, r));
res += a[r];
if (l)
res -= a[l - 1];
return dp[l][r] = res;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (i)
a[i] += a[i - 1]; // 累積和を取る
}
cout << solve(0, N - 1) << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 981,554 | 981,555 | u047554023 | cpp |
p03173 | // ysh_gpta
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
typedef long long ll;
#define vb vector<bool>
#define vi vector<ll>
#define vvi vector<vi>
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define mkp make_pair
#define pb push_back
#define INF 1000000000000000
#define MOD 1000000007
#define ff first
#define ss second
#define FastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// ll gcd( ll a, ll b ){if(b==0) return a; else return gcd( b, a%b );}
// ll ncr(ll n,ll r){ll ans=1;r=min(r,n-r);for (int
// i=1;i<=r;i++){ans*=(n-r+i);ans/=i;}return ans;} void printArray(vi &v){for(int
// i=0;i<v.size();i++) cout<<v[i]<<endl; cout<<endl; }
ll dp[405][405];
ll sum[405];
ll solve(ll i, ll j) {
if (i > j)
return 0;
if (j - i == 1)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll mn = INT_MAX;
for (ll k = i + 1; k < j; k++)
mn = min(mn, solve(i, k) + solve(k, j) + sum[j] - sum[i]);
return dp[i][j] = mn;
}
int main() {
FastIO ll n;
cin >> n;
vi v(n);
sum[0] = 0;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> v[i];
sum[i + 1] = sum[i] + v[i];
}
// for(ll l=2;l<=n;l++){
// for(ll i=0;i<n-l+1;i++){
// ll j=i+l-1;
// if(l==2){
// dp[i][j]=dp[i][j-1]+dp[i+1][j];
// }else{
// dp[i][j] =
// min(dp[i][j-1]+v[j]+sum[j]-sum[i],dp[i+1][j]+v[i]+sum[j+1]-sum[i+1]);
// }
// }
// }
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++)
// cout<<dp[i][j]<<" ";
// cout<<endl;
// }
cout << solve(0, n);
return 0;
} | // ysh_gpta
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
typedef long long ll;
#define vb vector<bool>
#define vi vector<ll>
#define vvi vector<vi>
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define mkp make_pair
#define pb push_back
#define INF 1000000000000000
#define MOD 1000000007
#define ff first
#define ss second
#define FastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// ll gcd( ll a, ll b ){if(b==0) return a; else return gcd( b, a%b );}
// ll ncr(ll n,ll r){ll ans=1;r=min(r,n-r);for (int
// i=1;i<=r;i++){ans*=(n-r+i);ans/=i;}return ans;} void printArray(vi &v){for(int
// i=0;i<v.size();i++) cout<<v[i]<<endl; cout<<endl; }
ll dp[405][405];
ll sum[405];
ll solve(ll i, ll j) {
if (i > j)
return 0;
if (j - i == 1)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll mn = LONG_LONG_MAX;
for (ll k = i + 1; k < j; k++)
mn = min(mn, solve(i, k) + solve(k, j) + sum[j] - sum[i]);
return dp[i][j] = mn;
}
int main() {
FastIO ll n;
cin >> n;
vi v(n);
sum[0] = 0;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> v[i];
sum[i + 1] = sum[i] + v[i];
}
// for(ll l=2;l<=n;l++){
// for(ll i=0;i<n-l+1;i++){
// ll j=i+l-1;
// if(l==2){
// dp[i][j]=dp[i][j-1]+dp[i+1][j];
// }else{
// dp[i][j] =
// min(dp[i][j-1]+v[j]+sum[j]-sum[i],dp[i+1][j]+v[i]+sum[j+1]-sum[i+1]);
// }
// }
// }
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++)
// cout<<dp[i][j]<<" ";
// cout<<endl;
// }
cout << solve(0, n);
return 0;
} | [
"variable_declaration.value.change",
"identifier.change"
] | 981,559 | 981,560 | u898771121 | cpp |
p03173 | // ysh_gpta
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
typedef long long ll;
#define vb vector<bool>
#define vi vector<ll>
#define vvi vector<vi>
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define mkp make_pair
#define pb push_back
#define INF 1000000000000000
#define MOD 1000000007
#define ff first
#define ss second
#define FastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// ll gcd( ll a, ll b ){if(b==0) return a; else return gcd( b, a%b );}
// ll ncr(ll n,ll r){ll ans=1;r=min(r,n-r);for (int
// i=1;i<=r;i++){ans*=(n-r+i);ans/=i;}return ans;} void printArray(vi &v){for(int
// i=0;i<v.size();i++) cout<<v[i]<<endl; cout<<endl; }
ll dp[405][405];
ll sum[405];
ll solve(ll i, ll j) {
assert(j > i);
if (j - i == 1)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll mn = INT_MAX;
for (ll k = i + 1; k < j; k++)
mn = min(mn, solve(i, k) + solve(k, j) + sum[j] - sum[i]);
return dp[i][j] = mn;
}
int main() {
FastIO ll n;
cin >> n;
vi v(n);
sum[0] = 0;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> v[i];
sum[i + 1] = sum[i] + v[i];
}
// for(ll l=2;l<=n;l++){
// for(ll i=0;i<n-l+1;i++){
// ll j=i+l-1;
// if(l==2){
// dp[i][j]=dp[i][j-1]+dp[i+1][j];
// }else{
// dp[i][j] =
// min(dp[i][j-1]+v[j]+sum[j]-sum[i],dp[i+1][j]+v[i]+sum[j+1]-sum[i+1]);
// }
// }
// }
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++)
// cout<<dp[i][j]<<" ";
// cout<<endl;
// }
cout << solve(0, n);
return 0;
} | // ysh_gpta
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
typedef long long ll;
#define vb vector<bool>
#define vi vector<ll>
#define vvi vector<vi>
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define mkp make_pair
#define pb push_back
#define INF 1000000000000000
#define MOD 1000000007
#define ff first
#define ss second
#define FastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// ll gcd( ll a, ll b ){if(b==0) return a; else return gcd( b, a%b );}
// ll ncr(ll n,ll r){ll ans=1;r=min(r,n-r);for (int
// i=1;i<=r;i++){ans*=(n-r+i);ans/=i;}return ans;} void printArray(vi &v){for(int
// i=0;i<v.size();i++) cout<<v[i]<<endl; cout<<endl; }
ll dp[405][405];
ll sum[405];
ll solve(ll i, ll j) {
assert(j > i);
if (j - i == 1)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll mn = LONG_LONG_MAX;
for (ll k = i + 1; k < j; k++)
mn = min(mn, solve(i, k) + solve(k, j) + sum[j] - sum[i]);
return dp[i][j] = mn;
}
int main() {
FastIO ll n;
cin >> n;
vi v(n);
sum[0] = 0;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> v[i];
sum[i + 1] = sum[i] + v[i];
}
// for(ll l=2;l<=n;l++){
// for(ll i=0;i<n-l+1;i++){
// ll j=i+l-1;
// if(l==2){
// dp[i][j]=dp[i][j-1]+dp[i+1][j];
// }else{
// dp[i][j] =
// min(dp[i][j-1]+v[j]+sum[j]-sum[i],dp[i+1][j]+v[i]+sum[j+1]-sum[i+1]);
// }
// }
// }
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++)
// cout<<dp[i][j]<<" ";
// cout<<endl;
// }
cout << solve(0, n);
return 0;
} | [
"variable_declaration.value.change",
"identifier.change"
] | 981,561 | 981,562 | u898771121 | cpp |
p03173 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
#define max(x, y) ((x) > (y) ? (x) : (y))
#define min(x, y) ((x) < (y) ? (x) : (y))
Int a[432];
Int sum[432];
Int dp[432][432];
Int n;
int main() {
cin >> n;
for (int i = 0; i < 432; i++)
for (int j = 0; j < 432; j++)
dp[i][j] = INF;
for (int i = 1; i <= n; i++)
cin >> a[i], sum[i] = sum[i - 1] + a[i];
for (int dif = 1; dif <= n; dif++) {
for (int i = 1; i + dif <= n + 1; i++) {
int j = i + dif;
if (dif == 1) {
dp[i][j] = 0;
} else {
for (int k = i + 1; k < j; k++) {
dp[i][j] =
min(dp[i][j], dp[i][k] + dp[k][j] + sum[j - 1] - sum[i - 1]);
}
}
// cout << i << " " << j << " " << dp[i][j] << endl;
}
}
cout << dp[1][n + 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
#define max(x, y) ((x) > (y) ? (x) : (y))
#define min(x, y) ((x) < (y) ? (x) : (y))
Int a[432];
Int sum[432];
Int dp[432][432];
Int n;
int main() {
cin >> n;
for (int i = 0; i < 432; i++)
for (int j = 0; j < 432; j++)
dp[i][j] = INF;
for (int i = 1; i <= n; i++)
cin >> a[i], sum[i] = sum[i - 1] + a[i];
for (int dif = 1; dif <= n; dif++) {
for (int i = 1; i + dif <= n + 1; i++) {
int j = i + dif;
if (dif == 1) {
dp[i][j] = 0;
} else {
for (int k = i + 1; k < j; k++) {
dp[i][j] =
min(dp[i][j], dp[i][k] + dp[k][j] + sum[j - 1] - sum[i - 1]);
}
}
// cout << i << " " << j << " " << dp[i][j] << endl;
}
}
cout << dp[1][n + 1] << endl;
return 0;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 981,568 | 981,569 | u299869545 | cpp |
p03173 | // youngjinp20
// 2020 03
#include <bits/stdc++.h>
#define by(x) [](const auto &a, const auto &b) { return a.x < b.x; }
#define byr(x) [](const auto &a, const auto &b) { return a.x > b.x; }
#define smax(a, b) ((a) < (b) ? ((a) = (b), true) : false)
#define smin(a, b) ((a) > (b) ? ((a) = (b), true) : false)
using namespace std;
typedef long long ll;
const int MAX = 401;
int N;
ll a[MAX];
ll dp[MAX][MAX];
ll sum[MAX];
ll solve(int l, int r) {
if (dp[l][r])
return dp[l][r];
if (l == r)
return 0;
ll cost = 1e9;
for (int i = l; i < r; i++) {
smin(cost, solve(l, i) + solve(i + 1, r));
}
return dp[l][r] = cost + sum[r] - sum[l - 1];
}
int main() {
cin >> N;
ll ct = 0;
for (int i = 1; i <= N; i++) {
cin >> a[i];
ct += a[i];
sum[i] = ct;
}
cout << solve(1, N);
return 0;
}
| // youngjinp20
// 2020 03
#include <bits/stdc++.h>
#define by(x) [](const auto &a, const auto &b) { return a.x < b.x; }
#define byr(x) [](const auto &a, const auto &b) { return a.x > b.x; }
#define smax(a, b) ((a) < (b) ? ((a) = (b), true) : false)
#define smin(a, b) ((a) > (b) ? ((a) = (b), true) : false)
using namespace std;
typedef long long ll;
const int MAX = 401;
int N;
ll a[MAX];
ll dp[MAX][MAX];
ll sum[MAX];
ll solve(int l, int r) {
if (dp[l][r])
return dp[l][r];
if (l == r)
return 0;
ll cost = 1e18;
for (int i = l; i < r; i++) {
smin(cost, solve(l, i) + solve(i + 1, r));
}
return dp[l][r] = cost + sum[r] - sum[l - 1];
}
int main() {
cin >> N;
ll ct = 0;
for (int i = 1; i <= N; i++) {
cin >> a[i];
ct += a[i];
sum[i] = ct;
}
cout << solve(1, N);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 981,572 | 981,573 | u688683948 | cpp |
p03173 | #include <bits/stdc++.h>
#include <iomanip>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
P dp[400][400];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> dp[i][i].first;
dp[i][i].second = 0;
}
for (int i = 1; i < n; i++)
for (int j = 0; j < n - i; j++) {
dp[j + i][j].first = dp[j + i - 1][j].first + dp[j + i][j + i].first;
dp[j + i][j].second = dp[j + i - 1][j].second + dp[j + i][j + i].second;
rep(k, i - 1) {
dp[j + i][j].second =
min(dp[j + i][j].second,
dp[j + i - 2 - k][j].second + dp[j + i][j + i - 1 - k].second);
}
dp[j + i][j].second += dp[j + i][j].first;
}
cout << dp[n - 1][0].second << endl;
}
| #include <bits/stdc++.h>
#include <iomanip>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
pair<ll, ll> dp[400][400];
int main() {
int n;
cin >> n;
rep(i, n) {
cin >> dp[i][i].first;
dp[i][i].second = 0;
}
for (int i = 1; i < n; i++)
for (int j = 0; j < n - i; j++) {
dp[j + i][j].first = dp[j + i - 1][j].first + dp[j + i][j + i].first;
dp[j + i][j].second = dp[j + i - 1][j].second + dp[j + i][j + i].second;
rep(k, i - 1) {
dp[j + i][j].second =
min(dp[j + i][j].second,
dp[j + i - 2 - k][j].second + dp[j + i][j + i - 1 - k].second);
}
dp[j + i][j].second += dp[j + i][j].first;
}
cout << dp[n - 1][0].second << endl;
}
| [
"variable_declaration.type.change"
] | 981,574 | 981,575 | u164112876 | cpp |
p03173 | //#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize(3)
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC target("sse3","sse2","sse")
//#pragma GCC target("avx","sse4","sse4.1","sse4.2","ssse3")
//#pragma GCC target("f16c")
//#pragma GCC optimize("inline","fast-math","unroll-loops","no-stack-protector")
//#pragma GCC diagnostic error "-fwhole-program"
//#pragma GCC diagnostic error "-fcse-skip-blocks"
//#pragma GCC diagnostic error "-funsafe-loop-optimizations"
//#pragma GCC diagnostic error "-std=c++14"
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#define PB push_back
#define PF push_front
#define LB lower_bound
#define UB upper_bound
#define fr(x) freopen(x, "r", stdin)
#define fw(x) freopen(x, "w", stdout)
#define iout(x) printf("%d\n", x)
#define lout(x) printf("%lld\n", x)
#define REP(x, l, u) for (ll x = l; x < u; x++)
#define RREP(x, l, u) for (ll x = l; x >= u; x--)
#define complete_unique(a) a.erase(unique(a.begin(), a.end()), a.end())
#define mst(x, a) memset(x, a, sizeof(x))
#define all(a) begin(a), end(a)
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MP make_pair
#define lowbit(x) ((x) & (-(x)))
#define lson (ind << 1)
#define rson (ind << 1 | 1)
#define se second
#define fi first
#define sz(x) ((int)x.size())
#define EX0 exit(0);
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
using namespace __gnu_pbds; // required
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef vector<ll> VLL;
typedef vector<int> VI;
const int block_size = 320;
typedef complex<ll> point;
const ll mod = 1e9 + 7;
const ll inf = 1e9 + 7;
const ld eps = 1e-9;
const db PI = atan(1) * 4;
template <typename T> inline int sign(const T &a) {
if (a < 0)
return -1;
if (a > 0)
return 1;
return 0;
}
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifndef ONLINE_JUDGE
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define dbg(...) \
{}
#endif
template <typename T, typename S> inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S> inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T> inline void in(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
ull twop(ll x) { return 1ULL << x; }
ll MOD(ll a, ll m) {
a %= m;
if (a < 0)
a += m;
return a;
}
ll inverse(ll a, ll m) {
a = MOD(a, m);
if (a <= 1)
return a;
return MOD((1 - inverse(m, a) * m) / a, m);
}
template <typename A, typename B> inline void in(A &x, B &y) {
in(x);
in(y);
}
template <typename A, typename B, typename C> inline void in(A &x, B &y, C &z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A &x, B &y, C &z, D &d) {
in(x);
in(y);
in(z);
in(d);
}
template <typename T> T sqr(T x) { return x * x; }
ll gcd(ll a, ll b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return abs(a);
}
ll fast(ll a, ll b, ll mod) {
if (b < 0)
a = inverse(a, mod), b = -b;
ll ans = 1;
while (b) {
if (b & 1) {
b--;
ans = ans * a % mod;
} else {
a = a * a % mod;
b /= 2;
}
}
return ans % mod;
}
namespace SOLVE {
const int maxn = 410;
int dp[maxn][maxn];
int a[maxn];
const int UNSOLVED = 0;
int solve(int l, int r) {
if (l == r) {
return 0;
} else {
if (dp[l][r] != inf) {
return dp[l][r];
} else {
for (int m = l; m < r; m++) {
dp[l][r] = min(dp[l][r], solve(l, m) + solve(m + 1, r));
}
for (int i = l; i <= r; i++) {
dp[l][r] += a[i];
}
return dp[l][r];
}
}
}
void main() {
int n;
cin >> n;
REP(i, 0, n) { REP(j, 0, n) dp[i][j] = inf; }
REP(i, 0, n) cin >> a[i];
cout << solve(0, n - 1);
}
} // namespace SOLVE
signed main() {
#ifndef ONLINE_JUDGE
#endif
int t = 1;
// in(t);
for (int i = 1; i <= t; i++) {
// cout<<"Case #"<<i<<":";
SOLVE::main();
}
// clock_t st = clock();
// while(clock() - st < 3.0 * CLOCKS_PER_SEC){
//
// }
return 0;
}
| //#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize(3)
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC target("sse3","sse2","sse")
//#pragma GCC target("avx","sse4","sse4.1","sse4.2","ssse3")
//#pragma GCC target("f16c")
//#pragma GCC optimize("inline","fast-math","unroll-loops","no-stack-protector")
//#pragma GCC diagnostic error "-fwhole-program"
//#pragma GCC diagnostic error "-fcse-skip-blocks"
//#pragma GCC diagnostic error "-funsafe-loop-optimizations"
//#pragma GCC diagnostic error "-std=c++14"
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
#define PB push_back
#define PF push_front
#define LB lower_bound
#define UB upper_bound
#define fr(x) freopen(x, "r", stdin)
#define fw(x) freopen(x, "w", stdout)
#define iout(x) printf("%d\n", x)
#define lout(x) printf("%lld\n", x)
#define REP(x, l, u) for (ll x = l; x < u; x++)
#define RREP(x, l, u) for (ll x = l; x >= u; x--)
#define complete_unique(a) a.erase(unique(a.begin(), a.end()), a.end())
#define mst(x, a) memset(x, a, sizeof(x))
#define all(a) begin(a), end(a)
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MP make_pair
#define lowbit(x) ((x) & (-(x)))
#define lson (ind << 1)
#define rson (ind << 1 | 1)
#define se second
#define fi first
#define sz(x) ((int)x.size())
#define EX0 exit(0);
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
using namespace __gnu_pbds; // required
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef vector<ll> VLL;
typedef vector<int> VI;
const int block_size = 320;
typedef complex<ll> point;
const ll mod = 1e9 + 7;
const ll inf = 1e9 + 7;
const ld eps = 1e-9;
const db PI = atan(1) * 4;
template <typename T> inline int sign(const T &a) {
if (a < 0)
return -1;
if (a > 0)
return 1;
return 0;
}
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifndef ONLINE_JUDGE
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define dbg(...) \
{}
#endif
template <typename T, typename S> inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S> inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T> inline void in(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
ull twop(ll x) { return 1ULL << x; }
ll MOD(ll a, ll m) {
a %= m;
if (a < 0)
a += m;
return a;
}
ll inverse(ll a, ll m) {
a = MOD(a, m);
if (a <= 1)
return a;
return MOD((1 - inverse(m, a) * m) / a, m);
}
template <typename A, typename B> inline void in(A &x, B &y) {
in(x);
in(y);
}
template <typename A, typename B, typename C> inline void in(A &x, B &y, C &z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A &x, B &y, C &z, D &d) {
in(x);
in(y);
in(z);
in(d);
}
template <typename T> T sqr(T x) { return x * x; }
ll gcd(ll a, ll b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return abs(a);
}
ll fast(ll a, ll b, ll mod) {
if (b < 0)
a = inverse(a, mod), b = -b;
ll ans = 1;
while (b) {
if (b & 1) {
b--;
ans = ans * a % mod;
} else {
a = a * a % mod;
b /= 2;
}
}
return ans % mod;
}
namespace SOLVE {
const int maxn = 410;
ll dp[maxn][maxn];
int a[maxn];
const int UNSOLVED = 0;
ll solve(int l, int r) {
if (l == r) {
return 0;
} else {
if (dp[l][r] != inf * inf) {
return dp[l][r];
} else {
for (int m = l; m < r; m++) {
dp[l][r] = min(dp[l][r], solve(l, m) + solve(m + 1, r));
}
for (int i = l; i <= r; i++) {
dp[l][r] += a[i];
}
return dp[l][r];
}
}
}
void main() {
int n;
cin >> n;
REP(i, 0, n) { REP(j, 0, n) dp[i][j] = inf * inf; }
REP(i, 0, n) cin >> a[i];
cout << solve(0, n - 1);
}
} // namespace SOLVE
signed main() {
#ifndef ONLINE_JUDGE
#endif
int t = 1;
// in(t);
for (int i = 1; i <= t; i++) {
// cout<<"Case #"<<i<<":";
SOLVE::main();
}
// clock_t st = clock();
// while(clock() - st < 3.0 * CLOCKS_PER_SEC){
//
// }
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 981,576 | 981,577 | u337802798 | cpp |
p03173 | #include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
// A
// int main()
//{
// int n, h;
// std::vector<int> heights;
//
// cin >> n;
// for (int i = 0; i < n; ++i)
// {
// cin >> h;
// heights.push_back(h);
// }
//
// vector<int> m(n, 0);
// m[0] = 0;
// m[1] = abs(heights[1] - heights[0]);
//
// for (int i = 2; i < n; ++i)
// {
// m[i] = min(m[i - 2] + abs(heights[i] - heights[i - 2]), m[i - 1] +
// abs(heights[i] - heights[i - 1]));
// }
//
// cout << m[n - 1];
//}
// B
// int main()
//{
// int n, k, h;
// std::vector<int> heights;
//
// cin >> n >> k;
// for (int i = 0; i < n; ++i)
// {
// cin >> h;
// heights.push_back(h);
// }
//
// vector<int> m(n, 0);
// m[0] = 0;
//
// for (int i = 1; i < n; ++i)
// {
// int m_min = INT_MAX;
// for (int j = 1; j <= k; ++j)
// {
// if (i - j < 0) break;
// int m_cur = m[i - j] + abs(heights[i] - heights[i - j]);
// if (m_cur < m_min) m_min = m_cur;
// }
// m[i] = m_min;
// }
//
// cout << m[n - 1];
//}
// C
// int main()
//{
// size_t n;
// cin >> n;
// vector<vector<int>> activities;
//
// int a, b, c;
// for (size_t i = 0; i < n; ++i)
// {
// cin >> a >> b >> c;
// vector<int> acts;
// acts.push_back(a);
// acts.push_back(b);
// acts.push_back(c);
// activities.push_back(acts);
// }
//
// vector<vector<int>> m(n, vector<int>(3, 0));
//
// for (int j = 0; j < 3; ++j)
// {
// m[0][j] = activities[0][j];
// }
//
// for (size_t i = 1; i < n; ++i)
// {
// m[i][0] = activities[i][0] + max(m[i - 1][1], m[i - 1][2]);
// m[i][1] = activities[i][1] + max(m[i - 1][0], m[i - 1][2]);
// m[i][2] = activities[i][2] + max(m[i - 1][0], m[i - 1][1]);
// }
//
// cout << *max_element(m[n-1].begin(), m[n-1].end());
//}
// D
// int main()
//{
// int n, W;
// cin >> n >> W;
// vector<int> weights;
// vector<long long> values;
//
// int w, v;
// for (int i = 0; i < n; ++i)
// {
// cin >> w >> v;
// weights.push_back(w);
// values.push_back(v);
// }
//
// vector<vector<long long>> m(n + 1, vector<long long>(W + 1, 0));
//
// for (int j = 0; j <= W; ++j)
// {
// m[0][j] = 0;
// }
//
// for (int i = 1; i <=n; ++i)
// {
// int index = i - 1;
// for (int j = 0; j <= W; ++j)
// {
// if (weights[index] > j)
// {
// m[i][j] = m[i - 1][j];
// }
// else
// {
// m[i][j] = max(m[i - 1][j], m[i - 1][j - weights[index]] +
// values[index]);
// }
// }
// }
//
// cout << m[n][W];
//}
// E
// int main()
//{
// int n;
// long long W;
// cin >> n >> W;
// vector<long long> weights;
// vector<int> values;
//
// long w;
// int v;
// int MAX_V = 0;
// for (int i = 0; i < n; ++i)
// {
// cin >> w >> v;
// weights.push_back(w);
// values.push_back(v);
// MAX_V += v;
// }
//
// //const int MAX_V = 10;
// vector<vector<long long >> m(n + 1, vector<long long>(MAX_V + 1, 0));
// m[0][0] = 0;
// for (int j = 1; j <= MAX_V; ++j)
// {
// m[0][j] = W + 1;
// }
//
//
// for (int i = 1; i <= n; ++i)
// {
// int index = i - 1;
// for (int j = 0; j <= MAX_V; ++j)
// {
// if (values[index] > j)
// {
// m[i][j] = m[i - 1][j];
// }
// else
// {
// m[i][j] = min(m[i - 1][j], m[i - 1][j - values[index]]
//+ weights[index]);
// }
// }
// }
//
// int max_value = -1;
// for (int j = 0; j <= MAX_V; ++j)
// {
// if (m[n][j] != W + 1) max_value = j;
// }
//
// cout << max_value;
//}
// int lcs(const string& x, const string& y, int m, int n)
//{
// if (m == 0 || n == 0) return 0;
// if (x[m - 1] == y[n - 1]) return 1 + lcs(x, y, m - 1, n - 1);
// return max(lcs(x, y, m - 1, n), lcs(x, y, m, n - 1));
//}
// F
// int main()
//{
// string s, t;
// cin >> s >> t;
//
// //int res = lcs(s, t, s.length(), t.length());
//
// vector<vector<int>> m(s.length() + 1, vector<int>(t.length() + 1, 0));
// /*for (size_t i = 0; i <= s.length(); ++i)
// {
// m[i][0] = "";
// }
//
// for (size_t j = 0; j <= t.length(); ++j)
// {
// m[0][j] = "";
// }*/
//
// size_t sl = s.length();
// size_t tl = t.length();
//
// for (size_t i = 1; i <= sl; ++i)
// {
// for (size_t j = 1; j <= tl; ++j)
// {
// if (s[i - 1] == t[j - 1])
// {
// m[i][j] = m[i - 1][j - 1] + 1;
// }
// else
// {
// if (m[i - 1][j] >= m[i][j - 1])
// {
// m[i][j] = m[i - 1][j];
// }
// else
// {
// m[i][j] = m[i][j-1];
// }
// }
// }
// }
//
// string res = "";
// size_t i = s.length();
// size_t j = t.length();
// while (i > 0 && j > 0)
// {
// if (m[i][j] == m[i][j - 1])
// j--;
// else if (m[i][j] == m[i - 1][j])
// i--;
// else
// {
// res = s[i - 1] + res;
// i--;
// j--;
// }
// }
//
// cout << res;
//
//}
// G
// void dfs(int node, const vector<vector<int>>& adj, vector<bool>& vis,
// vector<int>& depths)
//{
// vis[node] = true;
//
// for (int i = 0; i < adj[node].size(); ++i)//children
// {
// const int child_node = adj[node][i];
//
// if (!vis[child_node])
// dfs(child_node, adj, vis, depths);
//
// depths[node] = max(depths[node], 1 + depths[child_node]);
// }
//}
//
//
// int main()
//{
// int n, m;
//
// cin >> n >> m;
//
//
// vector<vector<int>> adj(n, vector<int>());
// int xi, yi;
//
//
// for (int i = 0; i < m; ++i)
// {
// cin >> xi >> yi;
// adj[xi-1].push_back(yi-1);
// }
//
// vector<bool> vis(n, false);
// vector<int> depths(n, 0);
//
// for (int i = 0; i < n; ++i)
// {
// if (vis[i]) continue;
// dfs(i, adj, vis, depths);
// }
//
// cout << *max_element(depths.begin(), depths.end());
//
//}
// H
// int main()
//{
// int H, W;
//
// cin >> H >> W;
//
// vector<string> grid;
// string s;
// for (int i = 0; i < H; ++i)
// {
// cin >> s;
// grid.push_back(s);
// }
//
// vector<vector<int>> dp(H + 1, vector<int>(W + 1));
// for (int i = 0; i <= H; ++i)
// {
// dp[i][0] = 0;
// }
// for (int j = 0; j <= W; ++j)
// {
// dp[0][j] = 0;
// }
//
//
// for (int i = 1; i <= H; ++i)
// {
// for (int j = 1; j <= W; ++j)
// {
// if (i == 1 && j == 1)
// dp[i][j] = 1;
// else if (grid[i-1][j-1] == '#')
// dp[i][j] = 0;
// else
// dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) %
//(1000000007);
// }
// }
//
// cout << dp[H][W];
//
//}
// void get_variants(int size, const vector<int>& cur_var, vector<vector<int>>&
// all_vars)
//{
// if (cur_var.size() == size)
// {
// all_vars.push_back(cur_var);
// return;
// }
//
// //0
// vector<int> new_var = cur_var;
// new_var.push_back(0);
// get_variants(size, new_var, all_vars);
//
// //1
// new_var = cur_var;
// new_var.push_back(1);
// get_variants(size, new_var, all_vars);
//}
// I
// int main()
//{
//
//
// int n;
// cin >> n;
//
// vector<double> p(n);
// double pi;
//
// for (int i = 0; i < n; ++i)
// {
// cin >> pi;
// p[i] = pi;
// }
//
//
// //pd[i][j] - вероятность получить j heads в i монетах
//
// vector<vector<double>> dp(n + 1, vector<double>(n + 1));
// dp[0][0] = 1.0;
//
// // Iterating for every coin
// for (int i = 1; i <= n; ++i)
// {
// const auto prob = p[i - 1];
// // j represents the numbers of heads
// for (int j = 0; j <= i; ++j)
// {
// // If number of heads is equal to zero
// // there there is only one possiblity
// if (j == 0)
// {
// dp[i][j] = dp[i - 1][j] * (1 - prob);
// }
// else
// {
// dp[i][j] = dp[i - 1][j] * (1 - prob) + dp[i - 1][j -
//1] * prob;
// }
// }
// }
//
// double res = 0.0;
// // When the number of heads is greater than (n+1)/2
// // it means that heads are greater than tails as
// // no of tails + no of heads is equal to n for
// // any permuation of heads and tails
//
// for (int j = (n + 1) / 2; j <= n; ++j)
// res += dp[n][j];
//
// cout.precision(10);
// cout << res;
//
//}
// J
// int main()
//{
// const int SIZE = 310;
// double dp[SIZE][SIZE][SIZE];
//
// int n;
// cin >> n;
//
// vector<int> a(n);
// double ai;
//
// int c1 = 0, c2 = 0, c3 = 0;
//
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// if (ai == 1) c1++;
// else if (ai == 2) c2++;
// else c3++;
// }
//
//
// //pd[i][j][k] - ожидаемое число ходов до конца, если осталось
// //i размера 1
// //j размера 2
// //k размера 3
//
//
// dp[0][0][0] = 0;
//
// for (int k = 0; k < SIZE; ++k)
// {
// for (int j = 0; j + k < SIZE; ++j)
// {
// for (int i = 0; i + j + k < SIZE; ++i)
// {
// if (i == 0 && j == 0 && k == 0) continue;
// double pi = 1.0 * i / (i + j + k);
// double pj = 1.0 * j / (i + j + k);
// double pk = 1.0 * k / (i + j + k);
//
// if (i)
// dp[i][j][k] += pi * dp[i - 1][j][k];
// if (j)
// dp[i][j][k] += pj * dp[i + 1][j - 1][k];
// if (k)
// dp[i][j][k] += pk * dp[i][j + 1][k - 1];
//
// dp[i][j][k] += 1.0 * n / (i + j + k);//выкинули номер с пустой
// тарелкой
// }
// }
// }
//
// cout.precision(10);
// cout << dp[c1][c2][c3];
//
//}
// K
// int main()
//{
// int n, k;
// cin >> n >> k;
// vector<int> a(n);
// int ai;
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// }
//
// //dp[i] - TRUE if first player wins if there are i stones remaining
//
// vector<bool> dp(k + 1, false);
// for (int stones = 0; stones <=k; ++stones)
// {
// for (int x :a)
// {
// if (stones >= x && !dp[stones-x])
// {
// dp[stones] = true;
// }
// }
// }
//
// cout << (dp[k] ? "First" : "Second");
//
// return 0;
//}
// L
// int main()
//{
// int n;
// cin >> n;
//
// vector<int> a(n);
// int ai;
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// }
//
// //dp[i][j] - выигрыш текущего игрока при положении левого указателя - i
//и правого - j
//
// const int nax = 3005;
// long long dp[nax][nax];
//
// for (int l = n - 1; l >= 0; --l)
// {
// for (int r = l; r < n; ++r)
// {
// if (l == r)
// dp[l][r] = a[l];
// else
// dp[l][r] = max(a[l] - dp[l + 1][r], a[r] - dp[l][r -
//1]);
// }
// }
//
//
// cout << dp[0][n - 1];
//
// return 0;
//}
// M
// const int n_max = 105;
// const int k_max = 100005;
// const int MOD = 1e9 + 7;
//
// inline int add(int a, int b)
//{
// a += b;
// if (a >= MOD) a -= MOD;
// return a;
//}
//
// inline int sub(int a, int b)
//{
// a -= b;
// if (a < 0) a += MOD;
// return a;
//}
//
// int main()
//{
// int n, k;
// cin >> n >> k;
//
// vector<int> a(n);
// int ai;
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// }
//
// //dp[i][j] - число способов поделить j конфет между i детьми
//
// int dp[n_max][k_max];
// int prefix[n_max][k_max];
//
// for (int i =0; i<=n; ++i)
// {
// dp[i][0] = 1;
// prefix[i][0] = 1;
// }
// for (int j = 0; j<=k; ++j)
// {
// prefix[0][j] = 1;
// }
//
//
// for (int i = 1; i <= n; ++i)
// {
// for (int j = 1; j <= k; ++j)
// {
// // coefficient of x^j is prefix[i - 1][j - a[i] : j];
// int first = (j - a[i-1] - 1 >= 0) ? prefix[i - 1][j - a[i-1]
//- 1] : 0; int last = prefix[i - 1][j]; dp[i][j] = sub(last, first);
// prefix[i][j] = add(prefix[i][j - 1], dp[i][j]);
//
//
// /*int sum = 0;
// for (int l = 0; l <= a[i-1]; ++l)
// {
// if (j - l >= 0)
// sum += dp[i - 1][j - l];
// }
// dp[i][j] = sum % 1000000007;*/
// }
// }
//
// cout << dp[n][k];
//}
inline long long sum(const int *a, int l, int r) {
long long s = 0;
for (int i = l; i <= r; ++i)
s += a[i];
return s;
}
// N
int main() {
int n, ai;
cin >> n;
const int N_MAX = 405;
int a[N_MAX];
for (int i = 0; i < n; ++i) {
cin >> ai;
a[i] = ai;
}
const int nax = 405;
long long dp[nax][nax];
// dp[i][j] - the minimum total cost of combining interval [i,j] into one
// vertex
for (int L = n - 1; L >= 0; --L) {
for (int R = L; R < n; ++R) {
if (L == R) {
dp[L][R] = 0;
} else {
dp[L][R] = INT_MAX;
long long s = sum(a, L, R);
for (int i = L; i < R; ++i) {
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i + 1][R] + s);
}
}
}
}
cout << dp[0][n - 1];
;
} | #include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
// A
// int main()
//{
// int n, h;
// std::vector<int> heights;
//
// cin >> n;
// for (int i = 0; i < n; ++i)
// {
// cin >> h;
// heights.push_back(h);
// }
//
// vector<int> m(n, 0);
// m[0] = 0;
// m[1] = abs(heights[1] - heights[0]);
//
// for (int i = 2; i < n; ++i)
// {
// m[i] = min(m[i - 2] + abs(heights[i] - heights[i - 2]), m[i - 1] +
// abs(heights[i] - heights[i - 1]));
// }
//
// cout << m[n - 1];
//}
// B
// int main()
//{
// int n, k, h;
// std::vector<int> heights;
//
// cin >> n >> k;
// for (int i = 0; i < n; ++i)
// {
// cin >> h;
// heights.push_back(h);
// }
//
// vector<int> m(n, 0);
// m[0] = 0;
//
// for (int i = 1; i < n; ++i)
// {
// int m_min = INT_MAX;
// for (int j = 1; j <= k; ++j)
// {
// if (i - j < 0) break;
// int m_cur = m[i - j] + abs(heights[i] - heights[i - j]);
// if (m_cur < m_min) m_min = m_cur;
// }
// m[i] = m_min;
// }
//
// cout << m[n - 1];
//}
// C
// int main()
//{
// size_t n;
// cin >> n;
// vector<vector<int>> activities;
//
// int a, b, c;
// for (size_t i = 0; i < n; ++i)
// {
// cin >> a >> b >> c;
// vector<int> acts;
// acts.push_back(a);
// acts.push_back(b);
// acts.push_back(c);
// activities.push_back(acts);
// }
//
// vector<vector<int>> m(n, vector<int>(3, 0));
//
// for (int j = 0; j < 3; ++j)
// {
// m[0][j] = activities[0][j];
// }
//
// for (size_t i = 1; i < n; ++i)
// {
// m[i][0] = activities[i][0] + max(m[i - 1][1], m[i - 1][2]);
// m[i][1] = activities[i][1] + max(m[i - 1][0], m[i - 1][2]);
// m[i][2] = activities[i][2] + max(m[i - 1][0], m[i - 1][1]);
// }
//
// cout << *max_element(m[n-1].begin(), m[n-1].end());
//}
// D
// int main()
//{
// int n, W;
// cin >> n >> W;
// vector<int> weights;
// vector<long long> values;
//
// int w, v;
// for (int i = 0; i < n; ++i)
// {
// cin >> w >> v;
// weights.push_back(w);
// values.push_back(v);
// }
//
// vector<vector<long long>> m(n + 1, vector<long long>(W + 1, 0));
//
// for (int j = 0; j <= W; ++j)
// {
// m[0][j] = 0;
// }
//
// for (int i = 1; i <=n; ++i)
// {
// int index = i - 1;
// for (int j = 0; j <= W; ++j)
// {
// if (weights[index] > j)
// {
// m[i][j] = m[i - 1][j];
// }
// else
// {
// m[i][j] = max(m[i - 1][j], m[i - 1][j - weights[index]] +
// values[index]);
// }
// }
// }
//
// cout << m[n][W];
//}
// E
// int main()
//{
// int n;
// long long W;
// cin >> n >> W;
// vector<long long> weights;
// vector<int> values;
//
// long w;
// int v;
// int MAX_V = 0;
// for (int i = 0; i < n; ++i)
// {
// cin >> w >> v;
// weights.push_back(w);
// values.push_back(v);
// MAX_V += v;
// }
//
// //const int MAX_V = 10;
// vector<vector<long long >> m(n + 1, vector<long long>(MAX_V + 1, 0));
// m[0][0] = 0;
// for (int j = 1; j <= MAX_V; ++j)
// {
// m[0][j] = W + 1;
// }
//
//
// for (int i = 1; i <= n; ++i)
// {
// int index = i - 1;
// for (int j = 0; j <= MAX_V; ++j)
// {
// if (values[index] > j)
// {
// m[i][j] = m[i - 1][j];
// }
// else
// {
// m[i][j] = min(m[i - 1][j], m[i - 1][j - values[index]]
//+ weights[index]);
// }
// }
// }
//
// int max_value = -1;
// for (int j = 0; j <= MAX_V; ++j)
// {
// if (m[n][j] != W + 1) max_value = j;
// }
//
// cout << max_value;
//}
// int lcs(const string& x, const string& y, int m, int n)
//{
// if (m == 0 || n == 0) return 0;
// if (x[m - 1] == y[n - 1]) return 1 + lcs(x, y, m - 1, n - 1);
// return max(lcs(x, y, m - 1, n), lcs(x, y, m, n - 1));
//}
// F
// int main()
//{
// string s, t;
// cin >> s >> t;
//
// //int res = lcs(s, t, s.length(), t.length());
//
// vector<vector<int>> m(s.length() + 1, vector<int>(t.length() + 1, 0));
// /*for (size_t i = 0; i <= s.length(); ++i)
// {
// m[i][0] = "";
// }
//
// for (size_t j = 0; j <= t.length(); ++j)
// {
// m[0][j] = "";
// }*/
//
// size_t sl = s.length();
// size_t tl = t.length();
//
// for (size_t i = 1; i <= sl; ++i)
// {
// for (size_t j = 1; j <= tl; ++j)
// {
// if (s[i - 1] == t[j - 1])
// {
// m[i][j] = m[i - 1][j - 1] + 1;
// }
// else
// {
// if (m[i - 1][j] >= m[i][j - 1])
// {
// m[i][j] = m[i - 1][j];
// }
// else
// {
// m[i][j] = m[i][j-1];
// }
// }
// }
// }
//
// string res = "";
// size_t i = s.length();
// size_t j = t.length();
// while (i > 0 && j > 0)
// {
// if (m[i][j] == m[i][j - 1])
// j--;
// else if (m[i][j] == m[i - 1][j])
// i--;
// else
// {
// res = s[i - 1] + res;
// i--;
// j--;
// }
// }
//
// cout << res;
//
//}
// G
// void dfs(int node, const vector<vector<int>>& adj, vector<bool>& vis,
// vector<int>& depths)
//{
// vis[node] = true;
//
// for (int i = 0; i < adj[node].size(); ++i)//children
// {
// const int child_node = adj[node][i];
//
// if (!vis[child_node])
// dfs(child_node, adj, vis, depths);
//
// depths[node] = max(depths[node], 1 + depths[child_node]);
// }
//}
//
//
// int main()
//{
// int n, m;
//
// cin >> n >> m;
//
//
// vector<vector<int>> adj(n, vector<int>());
// int xi, yi;
//
//
// for (int i = 0; i < m; ++i)
// {
// cin >> xi >> yi;
// adj[xi-1].push_back(yi-1);
// }
//
// vector<bool> vis(n, false);
// vector<int> depths(n, 0);
//
// for (int i = 0; i < n; ++i)
// {
// if (vis[i]) continue;
// dfs(i, adj, vis, depths);
// }
//
// cout << *max_element(depths.begin(), depths.end());
//
//}
// H
// int main()
//{
// int H, W;
//
// cin >> H >> W;
//
// vector<string> grid;
// string s;
// for (int i = 0; i < H; ++i)
// {
// cin >> s;
// grid.push_back(s);
// }
//
// vector<vector<int>> dp(H + 1, vector<int>(W + 1));
// for (int i = 0; i <= H; ++i)
// {
// dp[i][0] = 0;
// }
// for (int j = 0; j <= W; ++j)
// {
// dp[0][j] = 0;
// }
//
//
// for (int i = 1; i <= H; ++i)
// {
// for (int j = 1; j <= W; ++j)
// {
// if (i == 1 && j == 1)
// dp[i][j] = 1;
// else if (grid[i-1][j-1] == '#')
// dp[i][j] = 0;
// else
// dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) %
//(1000000007);
// }
// }
//
// cout << dp[H][W];
//
//}
// void get_variants(int size, const vector<int>& cur_var, vector<vector<int>>&
// all_vars)
//{
// if (cur_var.size() == size)
// {
// all_vars.push_back(cur_var);
// return;
// }
//
// //0
// vector<int> new_var = cur_var;
// new_var.push_back(0);
// get_variants(size, new_var, all_vars);
//
// //1
// new_var = cur_var;
// new_var.push_back(1);
// get_variants(size, new_var, all_vars);
//}
// I
// int main()
//{
//
//
// int n;
// cin >> n;
//
// vector<double> p(n);
// double pi;
//
// for (int i = 0; i < n; ++i)
// {
// cin >> pi;
// p[i] = pi;
// }
//
//
// //pd[i][j] - вероятность получить j heads в i монетах
//
// vector<vector<double>> dp(n + 1, vector<double>(n + 1));
// dp[0][0] = 1.0;
//
// // Iterating for every coin
// for (int i = 1; i <= n; ++i)
// {
// const auto prob = p[i - 1];
// // j represents the numbers of heads
// for (int j = 0; j <= i; ++j)
// {
// // If number of heads is equal to zero
// // there there is only one possiblity
// if (j == 0)
// {
// dp[i][j] = dp[i - 1][j] * (1 - prob);
// }
// else
// {
// dp[i][j] = dp[i - 1][j] * (1 - prob) + dp[i - 1][j -
//1] * prob;
// }
// }
// }
//
// double res = 0.0;
// // When the number of heads is greater than (n+1)/2
// // it means that heads are greater than tails as
// // no of tails + no of heads is equal to n for
// // any permuation of heads and tails
//
// for (int j = (n + 1) / 2; j <= n; ++j)
// res += dp[n][j];
//
// cout.precision(10);
// cout << res;
//
//}
// J
// int main()
//{
// const int SIZE = 310;
// double dp[SIZE][SIZE][SIZE];
//
// int n;
// cin >> n;
//
// vector<int> a(n);
// double ai;
//
// int c1 = 0, c2 = 0, c3 = 0;
//
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// if (ai == 1) c1++;
// else if (ai == 2) c2++;
// else c3++;
// }
//
//
// //pd[i][j][k] - ожидаемое число ходов до конца, если осталось
// //i размера 1
// //j размера 2
// //k размера 3
//
//
// dp[0][0][0] = 0;
//
// for (int k = 0; k < SIZE; ++k)
// {
// for (int j = 0; j + k < SIZE; ++j)
// {
// for (int i = 0; i + j + k < SIZE; ++i)
// {
// if (i == 0 && j == 0 && k == 0) continue;
// double pi = 1.0 * i / (i + j + k);
// double pj = 1.0 * j / (i + j + k);
// double pk = 1.0 * k / (i + j + k);
//
// if (i)
// dp[i][j][k] += pi * dp[i - 1][j][k];
// if (j)
// dp[i][j][k] += pj * dp[i + 1][j - 1][k];
// if (k)
// dp[i][j][k] += pk * dp[i][j + 1][k - 1];
//
// dp[i][j][k] += 1.0 * n / (i + j + k);//выкинули номер с пустой
// тарелкой
// }
// }
// }
//
// cout.precision(10);
// cout << dp[c1][c2][c3];
//
//}
// K
// int main()
//{
// int n, k;
// cin >> n >> k;
// vector<int> a(n);
// int ai;
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// }
//
// //dp[i] - TRUE if first player wins if there are i stones remaining
//
// vector<bool> dp(k + 1, false);
// for (int stones = 0; stones <=k; ++stones)
// {
// for (int x :a)
// {
// if (stones >= x && !dp[stones-x])
// {
// dp[stones] = true;
// }
// }
// }
//
// cout << (dp[k] ? "First" : "Second");
//
// return 0;
//}
// L
// int main()
//{
// int n;
// cin >> n;
//
// vector<int> a(n);
// int ai;
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// }
//
// //dp[i][j] - выигрыш текущего игрока при положении левого указателя - i
//и правого - j
//
// const int nax = 3005;
// long long dp[nax][nax];
//
// for (int l = n - 1; l >= 0; --l)
// {
// for (int r = l; r < n; ++r)
// {
// if (l == r)
// dp[l][r] = a[l];
// else
// dp[l][r] = max(a[l] - dp[l + 1][r], a[r] - dp[l][r -
//1]);
// }
// }
//
//
// cout << dp[0][n - 1];
//
// return 0;
//}
// M
// const int n_max = 105;
// const int k_max = 100005;
// const int MOD = 1e9 + 7;
//
// inline int add(int a, int b)
//{
// a += b;
// if (a >= MOD) a -= MOD;
// return a;
//}
//
// inline int sub(int a, int b)
//{
// a -= b;
// if (a < 0) a += MOD;
// return a;
//}
//
// int main()
//{
// int n, k;
// cin >> n >> k;
//
// vector<int> a(n);
// int ai;
// for (int i = 0; i < n; ++i)
// {
// cin >> ai;
// a[i] = ai;
// }
//
// //dp[i][j] - число способов поделить j конфет между i детьми
//
// int dp[n_max][k_max];
// int prefix[n_max][k_max];
//
// for (int i =0; i<=n; ++i)
// {
// dp[i][0] = 1;
// prefix[i][0] = 1;
// }
// for (int j = 0; j<=k; ++j)
// {
// prefix[0][j] = 1;
// }
//
//
// for (int i = 1; i <= n; ++i)
// {
// for (int j = 1; j <= k; ++j)
// {
// // coefficient of x^j is prefix[i - 1][j - a[i] : j];
// int first = (j - a[i-1] - 1 >= 0) ? prefix[i - 1][j - a[i-1]
//- 1] : 0; int last = prefix[i - 1][j]; dp[i][j] = sub(last, first);
// prefix[i][j] = add(prefix[i][j - 1], dp[i][j]);
//
//
// /*int sum = 0;
// for (int l = 0; l <= a[i-1]; ++l)
// {
// if (j - l >= 0)
// sum += dp[i - 1][j - l];
// }
// dp[i][j] = sum % 1000000007;*/
// }
// }
//
// cout << dp[n][k];
//}
inline long long sum(const int *a, int l, int r) {
long long s = 0;
for (int i = l; i <= r; ++i)
s += a[i];
return s;
}
// N
int main() {
int n, ai;
cin >> n;
const int N_MAX = 405;
int a[N_MAX];
for (int i = 0; i < n; ++i) {
cin >> ai;
a[i] = ai;
}
const int nax = 405;
long long dp[nax][nax];
// dp[i][j] - the minimum total cost of combining interval [i,j] into one
// vertex
for (int L = n - 1; L >= 0; --L) {
for (int R = L; R < n; ++R) {
if (L == R) {
dp[L][R] = 0;
} else {
dp[L][R] = LONG_MAX;
long long s = sum(a, L, R);
for (int i = L; i < R; ++i) {
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i + 1][R] + s);
}
}
}
}
cout << dp[0][n - 1];
;
} | [
"assignment.value.change",
"identifier.change"
] | 981,586 | 981,587 | u052234601 | cpp |
p03173 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <vector>
#define ll long long
#define pi pair<ll, ll>
#define mp(a, b) make_pair(a, b)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define N 404
#define INF 1e9 + 7
using namespace std;
ll n, ar[N];
ll dp[N][N];
ll pre[N];
ll get_sum(ll i, ll j) {
if (i == 0)
return pre[j];
return pre[j] - pre[i - 1];
}
ll solve(ll i, ll j) {
if (i >= j)
return 0;
if (dp[i][j])
return dp[i][j];
ll res = INF;
ll suma = get_sum(i, j);
rep(k, i, j) { res = min(res, solve(i, k) + solve(k + 1, j) + suma); }
return dp[i][j] = res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
rep(i, 0, n) {
cin >> ar[i];
if (i == 0)
pre[i] = ar[i];
else
pre[i] = pre[i - 1] + ar[i];
}
cout << solve(0, n - 1);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <vector>
#define ll long long
#define pi pair<ll, ll>
#define mp(a, b) make_pair(a, b)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define N 404
#define INF 1e15
using namespace std;
ll n, ar[N];
ll dp[N][N];
ll pre[N];
ll get_sum(ll i, ll j) {
if (i == 0)
return pre[j];
return pre[j] - pre[i - 1];
}
ll solve(ll i, ll j) {
if (i >= j)
return 0;
if (dp[i][j])
return dp[i][j];
ll res = INF;
ll suma = get_sum(i, j);
rep(k, i, j) { res = min(res, solve(i, k) + solve(k + 1, j) + suma); }
return dp[i][j] = res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
rep(i, 0, n) {
cin >> ar[i];
if (i == 0)
pre[i] = ar[i];
else
pre[i] = pre[i - 1] + ar[i];
}
cout << solve(0, n - 1);
return 0;
}
| [
"preprocessor.define.value.change",
"literal.float.change"
] | 981,588 | 981,589 | u751243213 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long
const int MAX_N = 500;
const int inf = 2e9;
int a[MAX_N];
int dp[MAX_N][MAX_N];
signed main(void) {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
for (int i = 1; i < N; i++) { //幅を先に決める
for (int j = 0; j < N; j++) { //左端を決める
if (i + j >= N) {
continue;
} //今[j,j+i]を考えている
int res = inf;
int sum = 0;
for (int k = j; k < j + i; k++) {
// [j,k]と[k+1,j+i]に分けて考える
sum += a[k];
res = min(res, dp[j][k] + dp[k + 1][j + i]);
}
sum += a[i + j];
dp[j][j + i] = res + sum;
}
}
cout << dp[0][N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long
const int MAX_N = 500;
const int inf = 1LL << 60;
int a[MAX_N];
int dp[MAX_N][MAX_N];
signed main(void) {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
for (int i = 1; i < N; i++) { //幅を先に決める
for (int j = 0; j < N; j++) { //左端を決める
if (i + j >= N) {
continue;
} //今[j,j+i]を考えている
int res = inf;
int sum = 0;
for (int k = j; k < j + i; k++) {
// [j,k]と[k+1,j+i]に分けて考える
sum += a[k];
res = min(res, dp[j][k] + dp[k + 1][j + i]);
}
sum += a[i + j];
dp[j][j + i] = res + sum;
}
}
cout << dp[0][N - 1] << endl;
return 0;
} | [
"literal.number.change"
] | 981,600 | 981,601 | u904123392 | cpp |
p03173 | // She is Pretty pretty!
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
const int N = 1100;
ll n, a[N], f[N][N], sum[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
memset(f, 0x3f, sizeof f);
for (int i = 1; i <= n; i++) {
f[i][i] = 0;
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int len = 2; len <= n; len++) {
for (int l = 1; l + len <= n; l++) {
int r = l + len;
for (int k = l; k < r; k++) {
f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
}
f[l][r] += sum[r] - sum[l - 1];
}
}
cout << f[1][n] << endl;
return 0;
} | // She is Pretty pretty!
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
const int N = 1100;
ll n, a[N], f[N][N], sum[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
memset(f, 0x3f, sizeof f);
for (int i = 1; i <= n; i++) {
f[i][i] = 0;
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int len = 1; len < n; len++) {
for (int l = 1; l + len <= n; l++) {
int r = l + len;
for (int k = l; k < r; k++) {
f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
}
f[l][r] += sum[r] - sum[l - 1];
}
}
cout << f[1][n] << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 981,602 | 981,603 | u862413182 | cpp |
p03173 | /*
DATE: 2020-03-12 13:02:27
NAME:
PROBLEM: ATDPN
*/
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400;
const long long LLINF = 1e15;
int a[MAXN + 7];
long long pre[MAXN + 7];
long long sum(int l, int r) { return pre[r] - pre[l - 1]; }
long long dp[MAXN + 7][MAXN + 7];
long long dpf(int l, int r) {
if (l > r) {
return 0;
}
long long &d = dp[l][r];
if (d != -1) {
return d;
}
if (l == r) {
return d = a[l];
}
if (l == r - 1) {
return d = a[l] + a[r];
}
d = LLINF;
for (int i = l; i <= r - 1; i++) {
long long temp = dpf(l, i) + dpf(i + 1, r) + sum(l, r);
if (i == l) {
temp -= a[l];
}
if (i == r) {
temp -= a[r];
}
d = min(d, temp);
}
return d;
}
int main() {
memset(dp, -1, sizeof dp);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = pre[i - 1] + a[i];
}
cout << dpf(1, n) << "\n";
return 0;
} | /*
DATE: 2020-03-12 13:02:27
NAME:
PROBLEM: ATDPN
*/
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400;
const long long LLINF = 1e15;
int a[MAXN + 7];
long long pre[MAXN + 7];
long long sum(int l, int r) { return pre[r] - pre[l - 1]; }
long long dp[MAXN + 7][MAXN + 7];
long long dpf(int l, int r) {
if (l > r) {
return 0;
}
long long &d = dp[l][r];
if (d != -1) {
return d;
}
if (l == r) {
return d = a[l];
}
if (l == r - 1) {
return d = a[l] + a[r];
}
d = LLINF;
for (int i = l; i <= r - 1; i++) {
long long temp = dpf(l, i) + dpf(i + 1, r) + sum(l, r);
if (i == l) {
temp -= a[l];
}
if (i == r - 1) {
temp -= a[r];
}
d = min(d, temp);
}
return d;
}
int main() {
memset(dp, -1, sizeof dp);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = pre[i - 1] + a[i];
}
cout << dpf(1, n) << "\n";
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 981,604 | 981,605 | u242454152 | cpp |
p03173 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = 1e+14;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(), c.end()
#define pb push_back
void Yes() {
cout << "Yes" << endl;
exit(0);
}
void No() {
cout << "No" << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
ll a[440];
rep(i, N) cin >> a[i];
ll b[440];
b[0] = 0;
rep(i, N) b[i + 1] = b[i] + a[i];
ll dp[440][440];
rep(i, N) dp[i][i] = 0;
rep(i, N - 1) { dp[i][i + 1] = a[i] + a[i + 1]; }
Rep(len, 2, N) {
rep(i, N - len) {
dp[i][i + len] = INF;
Rep(k, i, i + len - 1) {
dp[i][i + len] = min(dp[i][i + len], dp[i][k] + dp[k + 1][i + len] +
b[i + len + 1] - b[i]);
}
}
}
cout << dp[0][N - 1] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = 1e+14;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(), c.end()
#define pb push_back
void Yes() {
cout << "Yes" << endl;
exit(0);
}
void No() {
cout << "No" << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
ll a[440];
rep(i, N) cin >> a[i];
ll b[440];
b[0] = 0;
rep(i, N) b[i + 1] = b[i] + a[i];
ll dp[440][440];
rep(i, N) dp[i][i] = 0;
rep(i, N - 1) { dp[i][i + 1] = a[i] + a[i + 1]; }
Rep(len, 2, N) {
rep(i, N - len) {
dp[i][i + len] = INF;
Rep(k, i, i + len) {
dp[i][i + len] = min(dp[i][i + len], dp[i][k] + dp[k + 1][i + len] +
b[i + len + 1] - b[i]);
}
}
}
cout << dp[0][N - 1] << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 981,606 | 981,607 | u508571192 | cpp |
p03173 | #include <bits/stdc++.h>
#define int long long int
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define inf 10000000000001
#define all(x) (x).begin(), (x).end()
#define size(x) (int)(x).size()
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define popb() pop_back()
#define popf() pop_front()
#define mp(x, y) make_pair((x), (y))
#define vv(dt) vector<vector<dt>>
#define fastio(x) \
ios_base::sync_with_stdio(x); \
cin.tie(NULL)
#define init(v, s) memset(v, s, sizeof(v))
#define bug(x) \
cerr << "LINE: " << __LINE__ << " || " << #x << " = " << x << endl
#define loop(i, s, n) for (auto i = s; i < n; i++)
#define rloop(i, n, b) for (auto i = n - 1; i >= b; i--)
using namespace std;
signed main() {
fastio(0);
int n;
cin >> n;
int a[n];
loop(i, 0, n) cin >> a[i];
int dp[n][n], prefix[n + 1];
init(dp, 0);
init(prefix, 0);
prefix[1] = a[0];
loop(i, 2, n + 1) prefix[i] = prefix[i - 1] + a[i - 1];
// dp[i][j] = min cost for piling up slimes of range [i,j] = min m (dp[i][m] +
// dp[m+1][j] + prefix[i][j]) , m E [i,j-1].
for (int j = 0; j < n; j++) {
for (int i = j - 1; i >= 0; i--) {
int mn = INT_MAX;
for (int m = i; m < j; m++)
mn = min(mn, dp[i][m] + dp[m + 1][j] + prefix[j + 1] - prefix[i]);
dp[i][j] = mn;
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long int
#define pll pair<int, int>
#define dbl long double
#define ff first
#define ss second
#define endl "\n"
#define mod 1000000007
#define eps 0.00000001
#define inf 10000000000001
#define all(x) (x).begin(), (x).end()
#define size(x) (int)(x).size()
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define popb() pop_back()
#define popf() pop_front()
#define mp(x, y) make_pair((x), (y))
#define vv(dt) vector<vector<dt>>
#define fastio(x) \
ios_base::sync_with_stdio(x); \
cin.tie(NULL)
#define init(v, s) memset(v, s, sizeof(v))
#define bug(x) \
cerr << "LINE: " << __LINE__ << " || " << #x << " = " << x << endl
#define loop(i, s, n) for (auto i = s; i < n; i++)
#define rloop(i, n, b) for (auto i = n - 1; i >= b; i--)
using namespace std;
signed main() {
fastio(0);
int n;
cin >> n;
int a[n];
loop(i, 0, n) cin >> a[i];
int dp[n][n], prefix[n + 1];
init(dp, 0);
init(prefix, 0);
prefix[1] = a[0];
loop(i, 2, n + 1) prefix[i] = prefix[i - 1] + a[i - 1];
// dp[i][j] = min cost for piling up slimes of range [i,j] = min m (dp[i][m] +
// dp[m+1][j] + prefix[i][j]) , m E [i,j-1].
for (int j = 0; j < n; j++) {
for (int i = j - 1; i >= 0; i--) {
int mn = inf;
for (int m = i; m < j; m++)
mn = min(mn, dp[i][m] + dp[m + 1][j] + prefix[j + 1] - prefix[i]);
dp[i][j] = mn;
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.change"
] | 981,610 | 981,611 | u443507760 | cpp |
p03173 | #pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...) 1
#endif
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define TC \
int t; \
cin >> t; \
while (t--)
#define forn(i, n) for (int i = 0; i < n; i++)
#define ALL(x) x.begin(), x.end()
#define LL long long int
#define PB push_back
#define EB emplace_back
#define F first
#define S second
#define endl "\n"
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VL;
typedef vector<VL> VLL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
int mod = pow(10, 9) + 7;
const int inf = 2e9;
const LL linf = 2e18;
const double eps = 1e-9;
template <typename T, typename U> void add_mod(T &a, U b) {
a = (LL)a + b;
a = a % mod;
}
template <typename T, typename U> void mul_mod(T &a, U b) {
a = ((LL)a * b) % mod;
}
template <typename T> T add_mod(vector<T> v) {
LL sum = 0;
for (T x : v)
sum = (sum + x) % mod;
return (T)sum;
}
template <typename T> T mul_mod(vector<T> v) {
LL sum = 1LL;
for (T x : v)
sum = (sum * x) % mod;
return (T)sum;
}
template <typename T> string to_bin(T num) {
string binary = "";
while (num) {
binary += (num % 2 == 1 ? "1" : "0");
num >>= 1;
}
reverse(binary.begin(), binary.end());
return binary;
}
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int powm(int a, int b, int m = mod) {
int res = 1;
while (b) {
if (b & 1)
res = ((LL)res * a) % m;
a = ((LL)a * a) % m;
b >>= 1;
}
return res;
}
/////////////////////////////////////////////
const int N = 500;
LL arr[N];
LL dp[N][N];
LL pref[N];
LL sum(LL i, LL j) { return pref[++j] - pref[++i - 1]; }
LL solve(LL i, LL j) {
if (dp[i][j] != -1)
return dp[i][j];
if (i == j)
return 0;
if (j - i == 1) {
return arr[i] + arr[j];
}
dp[i][j] = INT_MAX;
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], sum(i, j) + solve(i, k) + solve(k + 1, j));
}
return dp[i][j];
}
int main() {
int n;
cin >> n;
forn(i, 500) forn(j, 500) dp[i][j] = -1;
forn(i, n) cin >> arr[i];
forn(i, n) pref[i + 1] = pref[i] + arr[i];
cout << solve(0, n - 1) << endl;
} | #pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...) 1
#endif
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define TC \
int t; \
cin >> t; \
while (t--)
#define forn(i, n) for (int i = 0; i < n; i++)
#define ALL(x) x.begin(), x.end()
#define LL long long int
#define PB push_back
#define EB emplace_back
#define F first
#define S second
#define endl "\n"
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VL;
typedef vector<VL> VLL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
int mod = pow(10, 9) + 7;
const int inf = 2e9;
const LL linf = 2e18;
const double eps = 1e-9;
template <typename T, typename U> void add_mod(T &a, U b) {
a = (LL)a + b;
a = a % mod;
}
template <typename T, typename U> void mul_mod(T &a, U b) {
a = ((LL)a * b) % mod;
}
template <typename T> T add_mod(vector<T> v) {
LL sum = 0;
for (T x : v)
sum = (sum + x) % mod;
return (T)sum;
}
template <typename T> T mul_mod(vector<T> v) {
LL sum = 1LL;
for (T x : v)
sum = (sum * x) % mod;
return (T)sum;
}
template <typename T> string to_bin(T num) {
string binary = "";
while (num) {
binary += (num % 2 == 1 ? "1" : "0");
num >>= 1;
}
reverse(binary.begin(), binary.end());
return binary;
}
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int powm(int a, int b, int m = mod) {
int res = 1;
while (b) {
if (b & 1)
res = ((LL)res * a) % m;
a = ((LL)a * a) % m;
b >>= 1;
}
return res;
}
/////////////////////////////////////////////
const int N = 500;
LL arr[N];
LL dp[N][N];
LL pref[N];
LL sum(LL i, LL j) { return pref[++j] - pref[++i - 1]; }
LL solve(LL i, LL j) {
if (dp[i][j] != -1)
return dp[i][j];
if (i == j)
return 0;
if (j - i == 1) {
return arr[i] + arr[j];
}
dp[i][j] = 1e18;
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], sum(i, j) + solve(i, k) + solve(k + 1, j));
}
return dp[i][j];
}
int main() {
int n;
cin >> n;
forn(i, 500) forn(j, 500) dp[i][j] = -1;
forn(i, n) cin >> arr[i];
forn(i, n) pref[i + 1] = pref[i] + arr[i];
cout << solve(0, n - 1) << endl;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,612 | 981,613 | u385780408 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int SIZE = 404;
const int INF = 1e18 + 3000;
int dp[SIZE][SIZE];
int tab[SIZE];
int pre[SIZE];
int n, p = 0;
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tab[i];
p += tab[i];
pre[i] = p;
}
}
void infinity() {
for (int i = 0; i < SIZE; i++)
for (int k = 0; k < SIZE; k++)
dp[i][k] = INF;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
infinity();
for (int i = n - 1; i >= 0; i--) {
for (int k = i; k < n; k++) {
if (i == k)
dp[i][k] = INF;
else
for (int j = i; j < k; j++)
dp[i][k] =
min(dp[i][k], dp[i][j] + dp[j + 1][k] + pre[k] - pre[i - 1]);
}
}
cout << dp[0][n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int SIZE = 404;
const int INF = 1e18 + 3000;
int dp[SIZE][SIZE];
int tab[SIZE];
int pre[SIZE];
int n, p = 0;
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tab[i];
p += tab[i];
pre[i] = p;
}
}
void infinity() {
for (int i = 0; i < SIZE; i++)
for (int k = 0; k < SIZE; k++)
dp[i][k] = INF;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
infinity();
for (int i = n - 1; i >= 0; i--) {
for (int k = i; k < n; k++) {
if (i == k)
dp[i][k] = 0;
else
for (int j = i; j < k; j++)
dp[i][k] =
min(dp[i][k], dp[i][j] + dp[j + 1][k] + pre[k] - pre[i - 1]);
}
}
cout << dp[0][n - 1];
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,614 | 981,615 | u662817252 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int SIZE = 404;
const int INF = 1000;
int dp[SIZE][SIZE];
int tab[SIZE];
int pre[SIZE];
int n, p = 0;
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tab[i];
p += tab[i];
pre[i] = p;
}
}
void infinity() {
for (int i = 0; i < SIZE; i++)
for (int k = 0; k < SIZE; k++)
dp[i][k] = INF;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
infinity();
for (int i = n - 1; i >= 0; i--) {
for (int k = i; k < n; k++) {
if (i == k)
dp[i][k] = 0;
else
for (int j = i; j < k; j++)
dp[i][k] =
min(dp[i][k], dp[i][j] + dp[j + 1][k] + pre[k] - pre[i - 1]);
}
}
cout << dp[0][n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int SIZE = 404;
const int INF = 1e18 + 3000;
int dp[SIZE][SIZE];
int tab[SIZE];
int pre[SIZE];
int n, p = 0;
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tab[i];
p += tab[i];
pre[i] = p;
}
}
void infinity() {
for (int i = 0; i < SIZE; i++)
for (int k = 0; k < SIZE; k++)
dp[i][k] = INF;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
infinity();
for (int i = n - 1; i >= 0; i--) {
for (int k = i; k < n; k++) {
if (i == k)
dp[i][k] = 0;
else
for (int j = i; j < k; j++)
dp[i][k] =
min(dp[i][k], dp[i][j] + dp[j + 1][k] + pre[k] - pre[i - 1]);
}
}
cout << dp[0][n - 1];
return 0;
} | [
"literal.number.change"
] | 981,616 | 981,615 | u662817252 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int MAX_N = 575;
const long long INF = numeric_limits<long long>::max() / 2;
int main() {
int n;
cin >> n;
vector<long long> a(n), s(n, 0);
auto sum = [&](int l, int r) { return s[r] - s[l]; };
for (int i = 0; i < n; i++) {
cin >> a[i];
s[i + 1] = s[i] + a[i];
}
long long dp[MAX_N][MAX_N];
for (int i = 0; i < MAX_N; i++) {
for (int j = 0; j < MAX_N; j++)
dp[i][j] = INF;
dp[i][i] = dp[i][i + 1] = 0;
}
for (int s = 2; s <= n; s++) {
for (int l = 0; l < n; l++) {
int r = l + s;
if (n < r)
continue;
for (int m = l; m <= r; m++) {
long long cost = sum(l, m) + sum(m, r);
chmin(dp[l][r], dp[l][m] + dp[m][r] + cost);
}
}
}
cout << dp[0][n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int MAX_N = 575;
const long long INF = numeric_limits<long long>::max() / 2;
int main() {
int n;
cin >> n;
vector<long long> a(n), s(n + 1, 0);
auto sum = [&](int l, int r) { return s[r] - s[l]; };
for (int i = 0; i < n; i++) {
cin >> a[i];
s[i + 1] = s[i] + a[i];
}
long long dp[MAX_N][MAX_N];
for (int i = 0; i < MAX_N - 1; i++) {
for (int j = 0; j < MAX_N; j++)
dp[i][j] = INF;
dp[i][i] = dp[i][i + 1] = 0;
}
for (int s = 2; s <= n; s++) {
for (int l = 0; l < n; l++) {
int r = l + s;
if (n < r)
continue;
for (int m = l; m <= r; m++) {
long long cost = sum(l, m) + sum(m, r);
chmin(dp[l][r], dp[l][m] + dp[m][r] + cost);
}
}
}
cout << dp[0][n] << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 981,628 | 981,629 | u615258936 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = (ll)(1e9 + 7);
ll run();
int main() {
#ifdef home
freopen("i", "r", stdin);
freopen("d", "w", stderr);
#endif
cout.precision(15);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
run();
return 0;
}
const ll inf = (1e9 + 5);
void max_self(ll &a, ll b) { a = max(a, b); }
void min_self(ll &a, ll b) { a = min(a, b); }
void mul(ll &a, ll b) { a = (a * b) % mod; }
void add_self(ll &a, ll b) {
a += b;
if (a >= mod)
a -= mod;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
vector<ll> a(405);
vector<ll> ps(405);
int dp[405][405];
ll solve(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll s = ps[j] - ps[i - 1];
ll ans = LLONG_MAX;
for (int k = i; k < j; k++) {
ans = min(ans, solve(i, k) + solve(k + 1, j) + s);
}
return dp[i][j] = ans;
}
ll run() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
ll s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
ps[i] = s;
}
ll ans = solve(1, n);
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = (ll)(1e9 + 7);
ll run();
int main() {
#ifdef home
freopen("i", "r", stdin);
freopen("d", "w", stderr);
#endif
cout.precision(15);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
run();
return 0;
}
const ll inf = (1e9 + 5);
void max_self(ll &a, ll b) { a = max(a, b); }
void min_self(ll &a, ll b) { a = min(a, b); }
void mul(ll &a, ll b) { a = (a * b) % mod; }
void add_self(ll &a, ll b) {
a += b;
if (a >= mod)
a -= mod;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
vector<ll> a(405);
vector<ll> ps(405);
ll dp[405][405];
ll solve(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
ll s = ps[j] - ps[i - 1];
ll ans = LLONG_MAX;
for (int k = i; k < j; k++) {
ans = min(ans, solve(i, k) + solve(k + 1, j) + s);
}
return dp[i][j] = ans;
}
ll run() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
ll s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
ps[i] = s;
}
ll ans = solve(1, n);
cout << ans;
return 0;
}
| [
"variable_declaration.type.change"
] | 981,634 | 981,635 | u244818078 | cpp |
p03173 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = (0); i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define show(x) cout << #x << " = " << (x) << endl
#define show2(x, y) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << endl
#define show3(x, y, z) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << endl
#define showv(v) \
rep(i, v.size()) printf("%d%c", v[i], i == v.size() - 1 ? '\n' : ' ')
#define showv2(v) rep(j, v.size()) showv(v[j])
#define showt(t, n) rep(i, n) printf("%d%c", t[i], i == n - 1 ? '\n' : ' ')
#define showt2(t, r, c) rep(j, r) showt(t[j], c)
#define showvp(p) rep(i, p.size()) printf("%d %d\n", p[i].first, p[i].second);
#define printv(v) rep(i, v.size()) printf("%d\n", v[i])
#define printt(t, n) rep(i, n) printf("%d\n", t[i])
#define incl(v, x) find(rng(v), x) != v.end()
#define incls(s, c) s.find(c) != string::npos
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define uni(x) x.erase(unique(rng(x)), x.end())
#define SP << " " <<
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vs = vector<string>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
typedef vector<pii> vp;
typedef vector<tiii> vt;
const int mod = 1000000007;
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const ll INFLL = (1LL << 62) - 1;
#define dame \
{ \
puts("No"); \
return 0; \
}
#define yn \
{ puts("Yes"); } \
else { \
puts("No"); \
}
inline int in() {
int x;
scanf("%d", &x);
return x;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int n;
vll a;
vll csum;
// dp[l][r]:
// 区間[l,r]に相当するスライムが一匹にまとまっているとき、それを分解するために必要な最小コスト
ll dp[410][410];
ll rec(int l, int r) {
if (dp[l][r] != INFLL)
return dp[l][r];
if (l == r)
return 0;
// どこで切るか全通り試す
ll res = INFLL;
for (int i = l; i < r; ++i)
chmin(res, rec(l, i) + rec(i + 1, r));
return dp[l][r] = res + (csum[r + 1] - csum[l]);
}
int main() {
cin >> n;
a = vll(n);
rep(i, n) cin >> a[i];
csum = vll(n + 1);
rep(i, n) csum[i + 1] = csum[i] + a[i];
showv(csum);
rep(i, n + 1) rep(j, n + 1) dp[i][j] = INFLL;
ll ans = rec(0, n - 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = (0); i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define show(x) cout << #x << " = " << (x) << endl
#define show2(x, y) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << endl
#define show3(x, y, z) \
cout << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << endl
#define showv(v) \
rep(i, v.size()) printf("%d%c", v[i], i == v.size() - 1 ? '\n' : ' ')
#define showv2(v) rep(j, v.size()) showv(v[j])
#define showt(t, n) rep(i, n) printf("%d%c", t[i], i == n - 1 ? '\n' : ' ')
#define showt2(t, r, c) rep(j, r) showt(t[j], c)
#define showvp(p) rep(i, p.size()) printf("%d %d\n", p[i].first, p[i].second);
#define printv(v) rep(i, v.size()) printf("%d\n", v[i])
#define printt(t, n) rep(i, n) printf("%d\n", t[i])
#define incl(v, x) find(rng(v), x) != v.end()
#define incls(s, c) s.find(c) != string::npos
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define uni(x) x.erase(unique(rng(x)), x.end())
#define SP << " " <<
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vs = vector<string>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
typedef vector<pii> vp;
typedef vector<tiii> vt;
const int mod = 1000000007;
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const ll INFLL = (1LL << 62) - 1;
#define dame \
{ \
puts("No"); \
return 0; \
}
#define yn \
{ puts("Yes"); } \
else { \
puts("No"); \
}
inline int in() {
int x;
scanf("%d", &x);
return x;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int n;
vll a;
vll csum;
// dp[l][r]:
// 区間[l,r]に相当するスライムが一匹にまとまっているとき、それを分解するために必要な最小コスト
ll dp[410][410];
ll rec(int l, int r) {
if (dp[l][r] != INFLL)
return dp[l][r];
if (l == r)
return 0;
// どこで切るか全通り試す
ll res = INFLL;
for (int i = l; i < r; ++i)
chmin(res, rec(l, i) + rec(i + 1, r));
return dp[l][r] = res + (csum[r + 1] - csum[l]);
}
int main() {
cin >> n;
a = vll(n);
rep(i, n) cin >> a[i];
csum = vll(n + 1);
rep(i, n) csum[i + 1] = csum[i] + a[i];
rep(i, n + 1) rep(j, n + 1) dp[i][j] = INFLL;
ll ans = rec(0, n - 1);
cout << ans << endl;
return 0;
} | [
"call.remove"
] | 981,644 | 981,645 | u850516963 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> pre, v;
vector<vector<ll>> dp;
int n;
int main() {
cin >> n;
v.resize(n);
pre.resize(n, 0);
dp.resize(n);
for (auto &i : v)
cin >> i;
// for(auto x: v) cout << x << " ";
pre[0] = v[0];
for (int i = 1; i < n; i++) {
pre[i] = pre[i - 1] + v[i];
}
/*for(auto x:pre) cout << x << " ";
cout << endl;*/
for (int i = 0; i < n; i++)
dp[i].resize(n);
for (int i = 0; i < n; i++)
dp[i][i] = 0LL;
for (int length = 2; length <= n; length++) {
for (int i = 0; i < n - length + 1; i++) {
int j = i + length - 1;
dp[i][j] = INT_MAX;
ll sum = 0LL;
for (int s = i; s < j; s++) {
if (i == 0)
sum = pre[j];
else
sum = pre[j] - pre[i - 1];
dp[i][j] = min(dp[i][j], dp[i][s] + dp[s + 1][j] + sum);
}
}
}
/*for(int i=0; i<n; i++){
for(int j=0; j<n; j++) cout << dp[i][j] << " ";
cout << endl;
}*/
cout << dp[0][n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> pre, v;
vector<vector<ll>> dp;
int n;
int main() {
cin >> n;
v.resize(n);
pre.resize(n, 0);
dp.resize(n);
for (auto &i : v)
cin >> i;
// for(auto x: v) cout << x << " ";
pre[0] = v[0];
for (int i = 1; i < n; i++) {
pre[i] = pre[i - 1] + v[i];
}
/*for(auto x:pre) cout << x << " ";
cout << endl;*/
for (int i = 0; i < n; i++)
dp[i].resize(n);
for (int i = 0; i < n; i++)
dp[i][i] = 0LL;
for (int length = 2; length <= n; length++) {
for (int i = 0; i < n - length + 1; i++) {
int j = i + length - 1;
dp[i][j] = 1e14 + 1;
ll sum = 0LL;
for (int s = i; s < j; s++) {
if (i == 0)
sum = pre[j];
else
sum = pre[j] - pre[i - 1];
// cout << sum << " ";
dp[i][j] = min(dp[i][j], dp[i][s] + dp[s + 1][j] + sum);
}
}
}
/*for(int i=0; i<n; i++){
for(int j=0; j<n; j++) cout << dp[i][j] << " ";
cout << endl;
}*/
cout << dp[0][n - 1] << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"assignment.change"
] | 981,668 | 981,669 | u495742512 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
vector<ll> arr, ps;
vector<vector<int>> dp;
ll solve(int x, int y) {
if (x == y)
return 0;
if (dp[x][y] != -1)
return dp[x][y];
// if(x > y) return 0;
ll mn = LONG_LONG_MAX;
for (int p = x + 1; p <= y; p++) {
ll l = solve(x, p - 1);
ll r = solve(p, y);
if (x == 0) {
l += ps[y];
} else {
l += ps[y] - ps[x - 1];
}
mn = min(mn, l + r);
}
return dp[x][y] = mn;
}
int main() {
cin >> n;
arr.resize(n);
ps.resize(n, 0);
dp.resize(405, vector<int>(405, -1));
ll cur = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
cur += arr[i];
ps[i] = cur;
}
ll res = solve(0, n - 1);
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
vector<ll> arr, ps;
vector<vector<ll>> dp;
ll solve(int x, int y) {
if (x == y)
return 0;
if (dp[x][y] != -1)
return dp[x][y];
// if(x > y) return 0;
ll mn = LONG_LONG_MAX;
for (int p = x + 1; p <= y; p++) {
ll l = solve(x, p - 1);
ll r = solve(p, y);
if (x == 0) {
l += ps[y];
} else {
l += ps[y] - ps[x - 1];
}
mn = min(mn, l + r);
}
return dp[x][y] = mn;
}
int main() {
cin >> n;
arr.resize(n);
ps.resize(n, 0);
dp.resize(405, vector<ll>(405, -1));
ll cur = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
cur += arr[i];
ps[i] = cur;
}
ll res = solve(0, n - 1);
cout << res << endl;
return 0;
} | [
"call.arguments.change"
] | 981,674 | 981,675 | u556467689 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define mp make_pair
#define f(i, a, n) for (int i = a; i < n; i++)
#define all(c) (c).begin(), (c).end()
#define F first
#define S second
#define fast ios::sync_with_stdio(false), cin.tie(nullptr);
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef vector<pii> vpi;
const int inf = 1e9;
const int inf64 = 1e18;
const int MOD = inf + 7;
const ld PI = acos(-1.0);
const int N = 405;
int dp[N][N];
int n, a[N], p[N];
int solve(int l, int r) {
if (l > r)
return inf;
if (l == r)
return 0;
if (dp[l][r] != -1)
return dp[l][r];
int res = inf;
for (int i = l; i < r; i++) {
res = min(res, solve(l, i) + solve(i + 1, r) + p[r] - p[l - 1]);
}
return dp[l][r] = res;
}
int32_t main() {
fast;
cin >> n;
f(i, 1, n + 1) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
memset(dp, -1, sizeof(dp));
cout << solve(1, n);
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define mp make_pair
#define f(i, a, n) for (int i = a; i < n; i++)
#define all(c) (c).begin(), (c).end()
#define F first
#define S second
#define fast ios::sync_with_stdio(false), cin.tie(nullptr);
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef vector<pii> vpi;
const int inf = 1e9;
const int inf64 = 1e18;
const int MOD = inf + 7;
const ld PI = acos(-1.0);
const int N = 405;
int dp[N][N];
int n, a[N], p[N];
int solve(int l, int r) {
if (l > r)
return inf64;
if (l == r)
return 0;
if (dp[l][r] != -1)
return dp[l][r];
int res = inf64;
for (int i = l; i < r; i++) {
res = min(res, solve(l, i) + solve(i + 1, r) + p[r] - p[l - 1]);
}
return dp[l][r] = res;
}
int32_t main() {
fast;
cin >> n;
f(i, 1, n + 1) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
memset(dp, -1, sizeof(dp));
cout << solve(1, n);
}
| [
"identifier.change",
"function.return_value.change",
"variable_declaration.value.change"
] | 981,680 | 981,681 | u670919462 | cpp |
p03173 | #include <bits/stdc++.h>
typedef long long int ll;
#define vaibhavv06 \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define endl '\n'
#define int long long
#define MM(a, b) memset(a, b, sizeof(a))
const ll MOD = 1000000007;
using namespace std;
// int arr[405];
int32_t main() {
vaibhavv06;
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int pre[n + 1];
pre[0] = 0;
for (int i = 1; i <= n; i++)
pre[i] = pre[i - 1] + arr[i - 1];
int dp[n][n] = {0};
for (int i = n - 1; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (i == j)
dp[i][j] = 0;
else {
dp[i][j] = INT_MAX;
for (int k = i; k <= j; k++) {
dp[i][j] =
min(dp[i][j], dp[i][k] + dp[k + 1][j] + pre[j + 1] - pre[i]);
}
}
}
}
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++){
// cout<<dp[i][j]<<" ";
// }
// cout<<endl;
// }
cout << dp[0][n - 1] << endl;
} | #include <bits/stdc++.h>
typedef long long int ll;
#define vaibhavv06 \
ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define endl '\n'
#define int long long
#define MM(a, b) memset(a, b, sizeof(a))
const ll MOD = 1000000007;
using namespace std;
int32_t main() {
vaibhavv06;
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int pre[n + 1];
pre[0] = 0;
for (int i = 1; i <= n; i++)
pre[i] = pre[i - 1] + arr[i - 1];
int dp[n][n] = {0};
for (int i = n - 1; i >= 0; i--) {
for (int j = i; j < n; j++) {
if (i == j)
dp[i][j] = 0;
else {
dp[i][j] = INT64_MAX;
for (int k = i; k <= j; k++) {
dp[i][j] =
min(dp[i][j], dp[i][k] + dp[k + 1][j] + pre[j + 1] - pre[i]);
}
}
}
}
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++){
// cout<<dp[i][j]<<" ";
// }
// cout<<endl;
// }
cout << dp[0][n - 1] << endl;
} | [
"assignment.value.change",
"identifier.change"
] | 981,693 | 981,694 | u699580536 | cpp |
p03173 | #include <iostream>
#include <vector>
using namespace std;
const int MAX = 10000000000006;
int main() {
int n;
cin >> n;
vector<long long> a(n + 1, 0);
vector<vector<long long>> dp(1005, vector<long long>(1005, MAX));
vector<long long> s(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
dp[i][i] = 0;
}
// infoarena parantezare optima a matricii
for (int i = 1; i + 1 <= n; i++)
for (int j = 1; j <= n - i; j++) {
for (int k = j; k < j + i; k++) {
dp[j][i + j] = min(dp[j][i + j],
dp[j][k] + dp[k + 1][i + j] + s[i + j] - s[j - 1]);
}
}
cout << dp[1][n];
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
const long long MAX = 10000000000006;
int main() {
int n;
cin >> n;
vector<long long> a(n + 9, 0);
vector<vector<long long>> dp(1005, vector<long long>(1005, MAX));
vector<long long> s(n + 9, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
dp[i][i] = 0;
}
// infoarena parantezare optima a matricii
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i; j++) {
for (int k = j; k < j + i; k++) {
dp[j][i + j] = min(dp[j][i + j],
dp[j][k] + dp[k + 1][i + j] + s[i + j] - s[j - 1]);
}
}
cout << dp[1][n];
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 981,697 | 981,698 | u189233751 | cpp |
p03173 | #include <iostream>
#include <vector>
using namespace std;
const int MAX = 10000000000006;
int main() {
int n;
cin >> n;
vector<long long> a(n + 1, 0);
vector<vector<long long>> dp(1005, vector<long long>(1005, MAX));
vector<long long> s(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
dp[i][i] = 0;
}
// infoarena parantezare optima a matricii
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i; j++) {
for (int k = j; k < j + i; k++) {
dp[j][i + j] = min(dp[j][i + j],
dp[j][k] + dp[k + 1][i + j] + s[i + j] - s[j - 1]);
}
}
cout << dp[1][n];
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
const long long MAX = 10000000000006;
int main() {
int n;
cin >> n;
vector<long long> a(n + 9, 0);
vector<vector<long long>> dp(1005, vector<long long>(1005, MAX));
vector<long long> s(n + 9, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
dp[i][i] = 0;
}
// infoarena parantezare optima a matricii
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i; j++) {
for (int k = j; k < j + i; k++) {
dp[j][i + j] = min(dp[j][i + j],
dp[j][k] + dp[k + 1][i + j] + s[i + j] - s[j - 1]);
}
}
cout << dp[1][n];
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 981,699 | 981,698 | u189233751 | cpp |
p03173 | #include <fstream>
#include <iostream>
using namespace std;
int n;
long long dp[1005][1005];
long long slimes[100005];
long long p[100005];
void init() {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = 10000006;
// for(int i = 0; i <= n; i++)
// slimes[i] = 0;
}
void prelucrare();
void read() {
cin >> n;
init();
for (int i = 1; i <= n; i++) {
dp[i][i] = 0;
cin >> slimes[i];
p[i] = p[i - 1] + slimes[i];
}
prelucrare();
}
void prelucrare() {
for (int i = 1; i + 1 <= n; i++)
for (int j = 1; i + j <= n; j++) {
int x = i + j;
for (int k = j; k < x; k++) {
if (dp[j][x] > dp[j][k] + dp[k + 1][x] + p[x] - p[j - 1])
dp[j][x] = dp[j][k] + dp[k + 1][x] + p[x] - p[j - 1];
}
}
}
void show() { cout << dp[1][n]; }
int main() {
read();
show();
} | #include <fstream>
#include <iostream>
using namespace std;
int n;
long long dp[1005][1005];
long long slimes[100005];
long long p[100005];
void init() {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = 10000000000006;
// for(int i = 0; i <= n; i++)
// slimes[i] = 0;
}
void prelucrare();
void read() {
cin >> n;
init();
for (int i = 1; i <= n; i++) {
dp[i][i] = 0;
cin >> slimes[i];
p[i] = p[i - 1] + slimes[i];
}
prelucrare();
}
void prelucrare() {
for (int i = 1; i + 1 <= n; i++)
for (int j = 1; i + j <= n; j++) {
int x = i + j;
for (int k = j; k < x; k++) {
if (dp[j][x] > dp[j][k] + dp[k + 1][x] + p[x] - p[j - 1])
dp[j][x] = dp[j][k] + dp[k + 1][x] + p[x] - p[j - 1];
}
}
}
void show() { cout << dp[1][n]; }
int main() {
read();
show();
} | [
"literal.number.change",
"assignment.value.change"
] | 981,704 | 981,703 | u389347166 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define rep1(i, n) for (int i = 1; i < (int)n; i++)
#define endl '\n'
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define int long long
using ll = long long;
const int maxn = 405;
ll arr[maxn];
ll dp[maxn][maxn];
ll sum[maxn];
int32_t main() {
IOS;
int n;
cin >> n;
rep1(i, n) cin >> arr[i];
memset(sum, 0, sizeof(sum));
rep(i, n) dp[i][i] = 0;
rep1(i, n + 1) sum[i] = sum[i - 1] + arr[i - 1];
for (int i = 1; i < n; i++) {
for (int j = i - 1; j >= 0; j--) {
dp[j][i] = 1e18;
for (int k = j; k < i; k++) {
dp[j][i] = min(dp[j][i], dp[j][k] + dp[k + 1][i]);
}
dp[j][i] += (sum[i + 1] - sum[j]);
}
}
cout << dp[0][n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define rep1(i, n) for (int i = 1; i < (int)n; i++)
#define endl '\n'
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define int long long
using ll = long long;
const int maxn = 405;
ll arr[maxn];
ll dp[maxn][maxn];
ll sum[maxn];
int32_t main() {
IOS;
int n;
cin >> n;
rep(i, n) cin >> arr[i];
memset(sum, 0, sizeof(sum));
rep(i, n) dp[i][i] = 0;
rep1(i, n + 1) sum[i] = sum[i - 1] + arr[i - 1];
for (int i = 1; i < n; i++) {
for (int j = i - 1; j >= 0; j--) {
dp[j][i] = 1e18;
for (int k = j; k < i; k++) {
dp[j][i] = min(dp[j][i], dp[j][k] + dp[k + 1][i]);
}
dp[j][i] += (sum[i + 1] - sum[j]);
}
}
cout << dp[0][n - 1] << endl;
return 0;
} | [
"identifier.change",
"call.function.change"
] | 981,711 | 981,712 | u651954565 | cpp |
p03173 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
long long dp[410][410];
vector<long long> v;
cin >> n;
v.resize(n + 1, 0);
for (int i = 1; i <= n; i++)
cin >> v[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = 1e9;
for (int i = 1; i <= n; i++)
dp[i][i] = 0, v[i] += v[i - 1];
for (int i = 1; i < n; i++)
for (int j = 1; j + i <= n; j++)
for (int u = 0; u < i; u++)
dp[j][j + i] = min(dp[j][j + i], dp[j][j + u] + dp[j + u + 1][j + i] +
v[j + i] - v[j - 1]);
/*
for(int i=0;i<n;i++)
for(int j=1;j+i<=n;j++)
cout<<dp[j][j+i]<<" \n"[j+i == n];
*/
cout << dp[1][n] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
long long dp[410][410];
vector<long long> v;
cin >> n;
v.resize(n + 1, 0);
for (int i = 1; i <= n; i++)
cin >> v[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = 1e17;
for (int i = 1; i <= n; i++)
dp[i][i] = 0, v[i] += v[i - 1];
for (int i = 1; i < n; i++)
for (int j = 1; j + i <= n; j++)
for (int u = 0; u < i; u++)
dp[j][j + i] = min(dp[j][j + i], dp[j][j + u] + dp[j + u + 1][j + i] +
v[j + i] - v[j - 1]);
/*
for(int i=0;i<n;i++)
for(int j=1;j+i<=n;j++)
cout<<dp[j][j+i]<<" \n"[j+i == n];
*/
cout << dp[1][n] << endl;
}
| [
"literal.number.change",
"assignment.value.change"
] | 981,716 | 981,717 | u771099984 | cpp |
p03173 | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long long int ar[n + 1];
long long int cum[n + 1];
ar[0] = cum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
cum[i] = cum[i - 1] + ar[i];
}
long long int dp[n + 1][n + 1];
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int i = 1; i < n; i++) {
dp[i][i + 1] = ar[i] + ar[i + 1];
}
// cout<<dp[1][2]<<endl;
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= n - i + 1; j++) {
int y = j + i - 1;
long long int m = INT_MAX;
for (int k = j; k < y; k++) {
m = min(m, dp[j][k] + dp[k + 1][y] + cum[y] - cum[j - 1]);
}
dp[j][y] = m;
// cout<<j<<" "<<y<<" "<<m<<endl;
}
}
cout << dp[1][n];
// for(int i=1;i<=n;i++){
// for(int j=1;j<=n;j++){
// // cout<<dp[i][j]<<" ";
// }
// cout<<endl;
// }
} | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long long int ar[n + 1];
long long int cum[n + 1];
ar[0] = cum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
cum[i] = cum[i - 1] + ar[i];
}
long long int dp[n + 1][n + 1];
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int i = 1; i < n; i++) {
dp[i][i + 1] = ar[i] + ar[i + 1];
}
// cout<<dp[1][2]<<endl;
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= n - i + 1; j++) {
int y = j + i - 1;
long long int m = LLONG_MAX;
for (int k = j; k < y; k++) {
m = min(m, dp[j][k] + dp[k + 1][y] + cum[y] - cum[j - 1]);
}
dp[j][y] = m;
// cout<<j<<" "<<y<<" "<<m<<endl;
}
}
cout << dp[1][n];
// for(int i=1;i<=n;i++){
// for(int j=1;j<=n;j++){
// // cout<<dp[i][j]<<" ";
// }
// cout<<endl;
//
} | [
"variable_declaration.value.change",
"identifier.change"
] | 981,720 | 981,721 | u764355221 | cpp |
p03173 | #pragma GCC optimize("03")
#include <bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define mod 1000000007
using namespace std;
ll n, a[410], dp[410][410], sum[410];
int main() {
// ifstream cin("tst.in");
// ofstream cout("tst.out");
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], sum[i] = a[i] + sum[i - 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = LLONG_MAX;
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int st = i;
int dr = i + len - 1;
for (int k = 1; k < dr; k++) {
dp[st][dr] =
min(dp[st][dr], dp[st][k] + dp[k + 1][dr] + sum[dr] - sum[st - 1]);
}
}
}
cout << dp[1][n];
return 0;
} | #pragma GCC optimize("03")
#include <bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define mod 1000000007
using namespace std;
ll n, a[410], dp[410][410], sum[410];
int main() {
// ifstream cin("tst.in");
// ofstream cout("tst.out");
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], sum[i] = a[i] + sum[i - 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = LLONG_MAX;
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int st = i;
int dr = i + len - 1;
for (int k = st; k < dr; k++) {
dp[st][dr] =
min(dp[st][dr], dp[st][k] + dp[k + 1][dr] + sum[dr] - sum[st - 1]);
}
}
}
cout << dp[1][n];
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 981,722 | 981,723 | u093252820 | cpp |
p03173 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define INF (1 << 30)
#define INFLL (1ll << 60)
typedef pair<int, int> P;
typedef pair<int, P> E;
#define MOD (1000000007ll)
#define l_ength size
void mul_mod(ll &a, ll b) {
a *= b;
a %= MOD;
}
void add_mod(ll &a, ll b) {
b += MOD;
a += b;
a %= MOD;
}
ll memo[444][444], a[444];
bool done[444][444];
ll solve(int i, int j) {
int k;
if (done[i][j]) {
return memo[i][j];
}
done[i][j] = true;
if (j - i < 2) {
memo[i][j] = 0ll;
return memo[i][j];
}
memo[i][j] = INFLL;
for (k = i + 1; k < j; ++k) {
memo[i][j] = min(memo[i][j], solve(i, k) + solve(k + 1, j));
}
for (k = i; k < j; ++k) {
memo[i][j] += a[k];
}
return memo[i][j];
}
int main(void) {
int n, i;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> a[i];
}
cout << solve(0, n) << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define INF (1 << 30)
#define INFLL (1ll << 60)
typedef pair<int, int> P;
typedef pair<int, P> E;
#define MOD (1000000007ll)
#define l_ength size
void mul_mod(ll &a, ll b) {
a *= b;
a %= MOD;
}
void add_mod(ll &a, ll b) {
b += MOD;
a += b;
a %= MOD;
}
ll memo[444][444], a[444];
bool done[444][444];
ll solve(int i, int j) {
int k;
if (done[i][j]) {
return memo[i][j];
}
done[i][j] = true;
if (j - i < 2) {
memo[i][j] = 0ll;
return memo[i][j];
}
memo[i][j] = INFLL;
for (k = i + 1; k < j; ++k) {
memo[i][j] = min(memo[i][j], solve(i, k) + solve(k, j));
}
for (k = i; k < j; ++k) {
memo[i][j] += a[k];
}
return memo[i][j];
}
int main(void) {
int n, i;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> a[i];
}
cout << solve(0, n) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 981,726 | 981,727 | u548624367 | cpp |
p03173 | /// i thought of single state not possible because
/*#include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
ll a[505];
ll s[505];
ll dp[505];
int main(){
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
if(i==1) s[i] = a[i];
else{
s[i] = s[i-1]+a[i];
}
}
for(int i=1;i<=n;i++){
dp[i] = 1000000000;
}
dp[0] = 0;
for(int i=1;i<=n;i++){
for(int j=0;j<=i;j++){
ll sum = 0;
for(int k=j;k<=i;k++){
sum+=s[k]-s[max(0,j-1)];
}
dp[i] = min(sum+dp[j],dp[i]);
}
}
cout<<dp[1]<<" "<<dp[2]<<" "<<dp[3]<<endl;
ll sum = 0;
for(int i=1;i<=n;i++)
sum+=dp[i];
cout<<sum<<endl;
}
*/
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
ll dp[405][405];
ll sum[405];
ll a[405];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i == 1)
sum[i] = a[i];
else
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = 1000000000;
}
}
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1, j = i + len - 1; j <= n; i++, j++) {
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1]);
}
}
}
cout << dp[1][n] << endl;
}
| /// i thought of single state not possible because
/*#include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
ll a[505];
ll s[505];
ll dp[505];
int main(){
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
if(i==1) s[i] = a[i];
else{
s[i] = s[i-1]+a[i];
}
}
for(int i=1;i<=n;i++){
dp[i] = 1000000000;
}
dp[0] = 0;
for(int i=1;i<=n;i++){
for(int j=0;j<=i;j++){
ll sum = 0;
for(int k=j;k<=i;k++){
sum+=s[k]-s[max(0,j-1)];
}
dp[i] = min(sum+dp[j],dp[i]);
}
}
cout<<dp[1]<<" "<<dp[2]<<" "<<dp[3]<<endl;
ll sum = 0;
for(int i=1;i<=n;i++)
sum+=dp[i];
cout<<sum<<endl;
}
*/
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
typedef long long ll;
ll dp[405][405];
ll sum[405];
ll a[405];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i == 1)
sum[i] = a[i];
else
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = 1000000000000000000;
}
}
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int i = 1, j = i + len - 1; j <= n; i++, j++) {
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1]);
}
}
}
cout << dp[1][n] << endl;
}
| [
"literal.number.change",
"assignment.value.change"
] | 981,732 | 981,733 | u090794688 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
long long dp[1000][1000], p[1005], n, a[1005];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
p[0] = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = 1e9;
for (int i = 0; i < n; i++) {
p[i + 1] = (p[i] + a[i]);
dp[i][i + 1] = 0;
}
for (int j = 1; j <= n; j++) {
for (int i = j - 2; i >= 0; i--) {
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + p[j] - p[i]);
}
}
}
cout << dp[0][n];
} | #include <bits/stdc++.h>
using namespace std;
long long dp[1000][1000], p[1005], n, a[1005];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
p[0] = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = 1e18;
for (int i = 0; i < n; i++) {
p[i + 1] = (p[i] + a[i]);
dp[i][i + 1] = 0;
}
for (int j = 1; j <= n; j++) {
for (int i = j - 2; i >= 0; i--) {
for (int k = i; k < j; k++) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + p[j] - p[i]);
}
}
}
cout << dp[0][n];
} | [
"literal.number.change",
"assignment.value.change"
] | 981,745 | 981,746 | u072293533 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int solve(vector<vector<int>> &dp, int i, int j, vector<int> s) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int mn = INT_MAX;
for (int k = i; k < j; k++) {
mn = min(mn, solve(dp, i, k, s) + solve(dp, k + 1, j, s));
}
int cost = s[j];
if (i > 0)
cost -= s[i - 1];
return dp[i][j] = (mn + cost);
}
int32_t main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> dp(n, vector<int>(n, 0));
vector<int> s(n);
s[0] = a[0];
for (int i = 1; i < n; i++)
s[i] = s[i - 1] + a[i];
for (int t = 2; t <= n; t++) {
for (int i = 0; i <= (n - t); i++) {
int j = i + t - 1;
int mn = (1 << 63);
for (int k = i; k < j; k++) {
mn = min(mn, dp[i][k] + dp[k + 1][j]);
}
int cost = s[j];
if (i > 0)
cost -= s[i - 1];
dp[i][j] = mn + cost;
}
}
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++){
// cout<<dp[i][j]<<" ";
// }
// cout<<"\n";
// }
// cout<<solve(dp,0,n-1,s);
cout << dp[0][n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int solve(vector<vector<int>> &dp, int i, int j, vector<int> s) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int mn = INT_MAX;
for (int k = i; k < j; k++) {
mn = min(mn, solve(dp, i, k, s) + solve(dp, k + 1, j, s));
}
int cost = s[j];
if (i > 0)
cost -= s[i - 1];
return dp[i][j] = (mn + cost);
}
int32_t main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> dp(n, vector<int>(n, 0));
vector<int> s(n);
s[0] = a[0];
for (int i = 1; i < n; i++)
s[i] = s[i - 1] + a[i];
for (int t = 2; t <= n; t++) {
for (int i = 0; i <= (n - t); i++) {
int j = i + t - 1;
int mn = LLONG_MAX;
for (int k = i; k < j; k++) {
mn = min(mn, dp[i][k] + dp[k + 1][j]);
}
int cost = s[j];
if (i > 0)
cost -= s[i - 1];
dp[i][j] = mn + cost;
}
}
// for(int i=0;i<n;i++){
// for(int j=0;j<n;j++){
// cout<<dp[i][j]<<" ";
// }
// cout<<"\n";
// }
// cout<<solve(dp,0,n-1,s);
cout << dp[0][n - 1];
}
| [
"variable_declaration.value.change"
] | 981,761 | 981,762 | u207955315 | cpp |
p03173 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
vector<vector<ll>> dp(n, vector<ll>(n, INT_MAX));
vector<vector<ll>> pre(n, vector<ll>(n, 0));
for (int i = 0; i < n; i++) {
ll sum = 0;
for (int j = i; j < n; j++) {
sum += v[j];
pre[i][j] = sum;
}
}
for (int i = 0; i < n; i++) {
dp[i][i] = 0;
}
for (int l = 2; l <= n; l++) {
for (int i = 0; i + l - 1 < n; i++) {
int j = i + l - 1;
for (int k = i; k < j; k++) {
dp[i][j] =
min(dp[i][j], dp[i][k] + dp[k + 1][j] + pre[i][k] + pre[k + 1][j]);
}
}
}
cout << dp[0][n - 1] << endl;
/*for(int i = 0 ; i<n ; i++ )
{for(int j = 0 ; j<n ; j++ )
{
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
vector<vector<ll>> dp(n, vector<ll>(n, 9999999999999999));
vector<vector<ll>> pre(n, vector<ll>(n, 0));
for (int i = 0; i < n; i++) {
ll sum = 0;
for (int j = i; j < n; j++) {
sum += v[j];
pre[i][j] = sum;
}
}
for (int i = 0; i < n; i++) {
dp[i][i] = 0;
}
for (int l = 2; l <= n; l++) {
for (int i = 0; i + l - 1 < n; i++) {
int j = i + l - 1;
for (int k = i; k < j; k++) {
dp[i][j] =
min(dp[i][j], dp[i][k] + dp[k + 1][j] + pre[i][k] + pre[k + 1][j]);
}
}
}
cout << dp[0][n - 1] << endl;
/*for(int i = 0 ; i<n ; i++ )
{for(int j = 0 ; j<n ; j++ )
{
cout<<dp[i][j]<<" ";
}
cout<<endl;
}*/
return 0;
} | [] | 981,766 | 981,767 | u645622153 | cpp |
p03173 | #pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#if __cplusplus >= 201103L
#include <chrono>
using namespace std::chrono;
#endif
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#ifdef LOCAL
#define prln(x) (cout << #x << ' ' << x << endl)
#define pr(x) (cout << #x << ' ' << x << ' ')
#define prv(x) (cout << x << ' ')
#else
#define prln(x)
#define pr(x)
#define prv(x)
#endif
#define clr(x) memset((x), 0, sizeof((x)))
#define clr1(x) memset((x), -1, sizeof((x)))
#define endl "\n"
#define pi acos(-1)
#define rep(i, st, ed) for (int i = (st); i <= (ed); ++i)
#define rep0(i, st, ed) for (int i = (st); i < (ed); ++i)
#define per0(i, st, ed) for (int i = (st); i > ed; --i)
#define per(i, st, ed) for (int i = (st); i >= ed; --i)
#define chmin(a, b) (a = a > b ? b : a)
#define chmax(a, b) (a = a < b ? b : a)
template <class T> void _sf(T &x) { cin >> x; }
void _sf(int &x) { scanf("%d", &x); }
void _sf(ll &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U> void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 405;
int dp[maxn][maxn];
int a[maxn];
int s[maxn];
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#if __cplusplus >= 201103L
auto start = steady_clock::now();
#endif
#endif
int n = read();
memset(dp, 0x3f, sizeof(dp));
rep(i, 1, n) {
a[i] = read();
s[i] = a[i] + s[i - 1];
dp[i][i] = 0;
}
for (int len = 2; len <= n; ++len) {
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
for (int k = i; k < j; ++k) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s[j] - s[i - 1]);
}
}
}
cout << dp[1][n] << endl;
#ifdef LOCAL
#if __cplusplus >= 201103L
auto end = steady_clock::now();
duration<double> time_span = duration_cast<duration<double>>(end - start);
;
printf("Total time: %.6fs\n", time_span.count());
#endif
#endif
return 0;
} | #pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
#if __cplusplus >= 201103L
#include <chrono>
using namespace std::chrono;
#endif
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#ifdef LOCAL
#define prln(x) (cout << #x << ' ' << x << endl)
#define pr(x) (cout << #x << ' ' << x << ' ')
#define prv(x) (cout << x << ' ')
#else
#define prln(x)
#define pr(x)
#define prv(x)
#endif
#define clr(x) memset((x), 0, sizeof((x)))
#define clr1(x) memset((x), -1, sizeof((x)))
#define endl "\n"
#define pi acos(-1)
#define rep(i, st, ed) for (int i = (st); i <= (ed); ++i)
#define rep0(i, st, ed) for (int i = (st); i < (ed); ++i)
#define per0(i, st, ed) for (int i = (st); i > ed; --i)
#define per(i, st, ed) for (int i = (st); i >= ed; --i)
#define chmin(a, b) (a = a > b ? b : a)
#define chmax(a, b) (a = a < b ? b : a)
template <class T> void _sf(T &x) { cin >> x; }
void _sf(int &x) { scanf("%d", &x); }
void _sf(ll &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U> void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
#define int long long
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 405;
int dp[maxn][maxn];
int a[maxn];
int s[maxn];
signed main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#if __cplusplus >= 201103L
auto start = steady_clock::now();
#endif
#endif
int n = read();
memset(dp, 0x3f, sizeof(dp));
rep(i, 1, n) {
a[i] = read();
s[i] = a[i] + s[i - 1];
dp[i][i] = 0;
}
for (int len = 2; len <= n; ++len) {
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
for (int k = i; k < j; ++k) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + s[j] - s[i - 1]);
}
}
}
cout << dp[1][n] << endl;
#ifdef LOCAL
#if __cplusplus >= 201103L
auto end = steady_clock::now();
duration<double> time_span = duration_cast<duration<double>>(end - start);
;
printf("Total time: %.6fs\n", time_span.count());
#endif
#endif
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 981,768 | 981,769 | u625893557 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ff first
#define ss second
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<db, db> pdd;
typedef vector<int> vi;
#define m1 make_pair
#define in insert
#define pb push_back
#define IOS \
std::ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl "\n"
inline ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
inline ll power(ll a, ll n, ll m) {
if (n == 0)
return 1;
ll p = power(a, n / 2, m);
p = (p * p) % m;
if (n % 2)
return (p * a) % m;
else
return p;
}
const ll MOD = 1e9 + 7;
const int N = int(3e5) + 999;
#define int long long int
#define inf 1e18
int dp[405][405];
int ans = 0;
int arr[405];
int sum(int l, int r) {
int x = 0;
l--, r--;
while (l <= r) {
x += arr[l];
l++;
}
return x;
}
int32_t main() {
IOS;
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> arr[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
dp[i][j] = arr[i - 1];
else
dp[i][j] = inf;
}
}
for (int len = 2; len <= n; len++) {
for (int start = 1; start + len - 1 <= n; start++) {
int end = start + len - 1;
int s = sum(start, end);
for (int i = start; i <= end - 1; i++) {
dp[start][end] = min(dp[start][end], dp[start][i] + s + dp[i + 1][end]);
}
}
}
cout << dp[1][n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define ff first
#define ss second
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<db, db> pdd;
typedef vector<int> vi;
#define m1 make_pair
#define in insert
#define pb push_back
#define IOS \
std::ios::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl "\n"
inline ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
inline ll power(ll a, ll n, ll m) {
if (n == 0)
return 1;
ll p = power(a, n / 2, m);
p = (p * p) % m;
if (n % 2)
return (p * a) % m;
else
return p;
}
const ll MOD = 1e9 + 7;
const int N = int(3e5) + 999;
#define int long long int
#define inf 1e18
int dp[405][405];
int ans = 0;
int arr[405];
int sum(int l, int r) {
int x = 0;
l--, r--;
while (l <= r) {
x += arr[l];
l++;
}
return x;
}
int32_t main() {
IOS;
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> arr[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
dp[i][j] = 0;
else
dp[i][j] = inf;
}
}
for (int len = 2; len <= n; len++) {
for (int start = 1; start + len - 1 <= n; start++) {
int end = start + len - 1;
int s = sum(start, end);
for (int i = start; i <= end - 1; i++) {
dp[start][end] = min(dp[start][end], dp[start][i] + s + dp[i + 1][end]);
}
}
}
cout << dp[1][n];
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,776 | 981,777 | u692657943 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 403;
int n;
int a[N], pref[N];
int dp[N][N];
int recur(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int ans = INT_MAX;
for (int k = i; k <= j - 1; k++)
ans = min(ans, recur(i, k) + recur(k + 1, j) + pref[j] - pref[i - 1]);
return dp[i][j] = ans;
}
int32_t main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
memset(dp, -1, sizeof(dp));
cout << recur(1, n);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 403;
int n;
int a[N], pref[N];
int dp[N][N];
int recur(int i, int j) {
if (i == j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
int ans = 1e18;
for (int k = i; k <= j - 1; k++)
ans = min(ans, recur(i, k) + recur(k + 1, j) + pref[j] - pref[i - 1]);
return dp[i][j] = ans;
}
int32_t main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
memset(dp, -1, sizeof(dp));
cout << recur(1, n);
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 981,788 | 981,789 | u231045825 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
int dp[401][401];
int A[401];
int sm(int l, int r) {
int q = 0;
for (int i = 0; i <= r; i++)
q = q + A[i];
return q;
}
signed main() {
int n, k;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
else {
dp[l][r] = LLONG_MAX;
for (int i = l; i <= r; i++) {
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + sm(l, r));
}
}
}
}
cout << dp[0][n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long int
int dp[401][401];
int A[401];
int sm(int l, int r) {
int q = 0;
for (int i = l; i <= r; i++)
q = q + A[i];
return q;
}
signed main() {
int n, k;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
for (int l = n - 1; l >= 0; l--) {
for (int r = l; r < n; r++) {
if (l == r)
dp[l][r] = 0;
else {
dp[l][r] = LLONG_MAX;
for (int i = l; i <= r; i++) {
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i + 1][r] + sm(l, r));
}
}
}
}
cout << dp[0][n - 1];
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 981,794 | 981,795 | u463305326 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll mod = 1e9 + 7;
int main(void) {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1));
vector<ll> pref(k + 1);
pref[0] = 1;
for (int i = 1; i < k + 1; i++) {
pref[i] += pref[i - 1];
}
/*dp[0][0] = 1;
for(int i = 1; i <= n; i++){
for(int used = 0; used <= k; used++){
for(int upto = 0; upto <= vec[i - 1]; upto++){
if(used - upto >= 0) dp[i][used] += dp[i - 1][used -
upto]; dp[i][used] %= mod;
}
}
}
for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int used = 0; used <= k; used++) {
if (used - vec[i - 1] > 0)
dp[i][used] = (pref[used] - pref[used - vec[i - 1] - 1]);
else
dp[i][used] = (pref[used]);
dp[i][used] %= mod;
}
for (int j = 0; j <= k; j++)
pref[j] = 0;
for (int j = 0; j <= k; j++) {
if (j > 0)
pref[j] += pref[j - 1] + dp[i][j];
else
pref[j] = dp[i][j];
pref[j] %= mod;
}
}
/*for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
cout << dp[n][k];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll mod = 1e9 + 7;
int main(void) {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1));
vector<ll> pref(k + 1);
pref[0] = 1;
for (int i = 1; i < k + 1; i++) {
pref[i] += pref[i - 1];
}
/*dp[0][0] = 1;
for(int i = 1; i <= n; i++){
for(int used = 0; used <= k; used++){
for(int upto = 0; upto <= vec[i - 1]; upto++){
if(used - upto >= 0) dp[i][used] += dp[i - 1][used -
upto]; dp[i][used] %= mod;
}
}
}
for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int used = 0; used <= k; used++) {
if (used - vec[i - 1] > 0)
dp[i][used] = (pref[used] - pref[used - vec[i - 1] - 1] + mod);
else
dp[i][used] = (pref[used]);
dp[i][used] %= mod;
}
for (int j = 0; j <= k; j++)
pref[j] = 0;
for (int j = 0; j <= k; j++) {
if (j > 0)
pref[j] += pref[j - 1] + dp[i][j];
else
pref[j] = dp[i][j];
pref[j] %= mod;
}
}
/*for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
cout << dp[n][k];
} | [
"assignment.change"
] | 981,805 | 981,806 | u150659133 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll mod = 1e9 + 7;
int main(void) {
int n, k;
cin >> n >> k;
vector<ll> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1));
vector<ll> pref(k + 1);
pref[0] = 1;
for (int i = 1; i < k + 1; i++) {
pref[i] += pref[i - 1];
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int used = 0; used <= k; used++) {
// for(int upto = 0; upto <= vec[i - 1]; upto++){
if (used - vec[i - 1] > 0)
dp[i][used] = (pref[used] -
pref[used - vec[i - 1] - 1]); // dp[i - 1][used - upto];
else
dp[i][used] = (pref[used]);
dp[i][used] %= mod;
//}
}
for (int j = 0; j <= k; j++)
pref[j] = 0;
for (int j = 0; j <= k; j++) {
if (j - 1 >= 0)
pref[j] += pref[j - 1] + dp[i][j];
else
pref[j] = dp[i][j];
pref[j] %= mod;
}
}
/*for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
cout << dp[n][k];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll mod = 1e9 + 7;
int main(void) {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
vector<vector<ll>> dp(n + 1, vector<ll>(k + 1));
vector<ll> pref(k + 1);
pref[0] = 1;
for (int i = 1; i < k + 1; i++) {
pref[i] += pref[i - 1];
}
/*dp[0][0] = 1;
for(int i = 1; i <= n; i++){
for(int used = 0; used <= k; used++){
for(int upto = 0; upto <= vec[i - 1]; upto++){
if(used - upto >= 0) dp[i][used] += dp[i - 1][used -
upto]; dp[i][used] %= mod;
}
}
}
for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int used = 0; used <= k; used++) {
if (used - vec[i - 1] > 0)
dp[i][used] = (pref[used] - pref[used - vec[i - 1] - 1] + mod);
else
dp[i][used] = (pref[used]);
dp[i][used] %= mod;
}
for (int j = 0; j <= k; j++)
pref[j] = 0;
for (int j = 0; j <= k; j++) {
if (j > 0)
pref[j] += pref[j - 1] + dp[i][j];
else
pref[j] = dp[i][j];
pref[j] %= mod;
}
}
/*for(int i = 0; i <= n; i++){
for(int j = 0; j <= k; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}*/
cout << dp[n][k];
} | [
"assignment.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 981,807 | 981,806 | u150659133 | cpp |
p03172 | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <iomanip>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// setbase - cout << setbase (16); cout << 100 << endl; Prints 64
// setfill - cout << setfill ('x') << setw (5); cout << 77 << endl; prints
// xxx77 setprecision - cout << setprecision (14) << f << endl; Prints x.xxxx
// cout.precision(x) cout<<fixed<<val; // prints x digits after decimal in val
using namespace std;
using namespace __gnu_pbds;
#define mod 1000000007
#define PI 3.14159265358979323
#define ss second
#define ff first
#define pb push_back
#define mp make_pair
#define sz(a) a.size()
#define pqueue priority_queue<ll>
//#define pdqueue priority_queue< ll,vector<ll> ,greater< ll > >
#define debug(x) cout << "Case " << x << ": "
#define rep(i, n) for (long long i = 0; i < n; i++)
#define f(i, a, b) for (long long i = a; i < b; i++)
#define fd(i, a, b) for (long long i = a; i >= b; i--)
#define sync \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef long long int ll;
typedef long double ld;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<string> vs;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// Handle:cyber_rajat
int main(int argc, char const *argv[]) {
sync;
/*#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif*/
// Did not understood this much
ll n, k;
cin >> n >> k;
ll a[n + 5] = {0};
ll dp[k + 5] = {0};
dp[0] = 1;
// dp[i] - the numbert of ways such that we have used i candies so far
rep(i, n) cin >> a[i];
rep(child, n) {
vll fake(k + 1);
fd(used, k, 0) {
ll temp = dp[used];
ll L = used + 1;
ll R = used + min(a[child], k - used);
if (L <= R) {
fake[L] = (fake[L] + temp) % mod;
if (R + 1 <= k)
fake[R + 1] = (fake[R + 1] - temp) % mod;
}
}
ll prefixSum = 0;
rep(i, k + 1) {
prefixSum = (prefixSum + fake[i]) % mod;
dp[i] = (dp[i] + prefixSum) % mod;
}
}
cout << dp[k] << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <iomanip>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// setbase - cout << setbase (16); cout << 100 << endl; Prints 64
// setfill - cout << setfill ('x') << setw (5); cout << 77 << endl; prints
// xxx77 setprecision - cout << setprecision (14) << f << endl; Prints x.xxxx
// cout.precision(x) cout<<fixed<<val; // prints x digits after decimal in val
using namespace std;
using namespace __gnu_pbds;
#define mod 1000000007
#define PI 3.14159265358979323
#define ss second
#define ff first
#define pb push_back
#define mp make_pair
#define sz(a) a.size()
#define pqueue priority_queue<ll>
//#define pdqueue priority_queue< ll,vector<ll> ,greater< ll > >
#define debug(x) cout << "Case " << x << ": "
#define rep(i, n) for (long long i = 0; i < n; i++)
#define f(i, a, b) for (long long i = a; i < b; i++)
#define fd(i, a, b) for (long long i = a; i >= b; i--)
#define sync \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef long long int ll;
typedef long double ld;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<string> vs;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// Handle:cyber_rajat
int main(int argc, char const *argv[]) {
sync;
/*#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif*/
// Did not understood this much
ll n, k;
cin >> n >> k;
ll a[n + 5] = {0};
ll dp[k + 5] = {0};
dp[0] = 1;
// dp[i] - the numbert of ways such that we have used i candies so far
rep(i, n) cin >> a[i];
rep(child, n) {
vll fake(k + 1);
fd(used, k, 0) {
ll temp = dp[used];
ll L = used + 1;
ll R = used + min(a[child], k - used);
if (L <= R) {
fake[L] = (fake[L] + temp) % mod;
if (R + 1 <= k)
fake[R + 1] = (fake[R + 1] - temp + mod) % mod;
}
}
ll prefixSum = 0;
rep(i, k + 1) {
prefixSum = (prefixSum + fake[i]) % mod;
dp[i] = (dp[i] + prefixSum) % mod;
}
}
cout << dp[k] << endl;
}
| [
"assignment.change"
] | 981,812 | 981,813 | u431173823 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int, int>
#define vi vector<int>
#define pb emplace_back
#define sz(x) (int)x.size()
#define all(v) v.begin(), v.end()
#define x first
#define y second
#define rep(i, j, k) for (i = j; i < k; i++)
#define sep(i, j, k) for (i = j; i > k; i--)
const int N = 2e5 + 5, inf = 1e9 + 7;
int n, k, i, j;
int A[N];
inline void add(int &a, int b) {
a += b;
if (a < 0)
a += inf;
if (a >= inf)
a -= inf;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int i, j, a, b, ans = 0;
cin >> n >> k;
vi dp(k + 1, 0), temp(k + 1, 0);
dp[0] = 1;
rep(i, 1, n + 1) {
cin >> A[i];
rep(j, 0, k + 1) {
if (j < k)
add(temp[j + 1], dp[j]);
if (j + A[i] < k)
add(temp[j + A[i] + 1], dp[j]);
if (j < k)
add(temp[j + 1], temp[j]);
add(dp[j], temp[j]);
temp[j] = 0;
}
}
cout << dp[k];
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int, int>
#define vi vector<int>
#define pb emplace_back
#define sz(x) (int)x.size()
#define all(v) v.begin(), v.end()
#define x first
#define y second
#define rep(i, j, k) for (i = j; i < k; i++)
#define sep(i, j, k) for (i = j; i > k; i--)
const int N = 2e5 + 5, inf = 1e9 + 7;
int n, k, i, j;
int A[N];
inline void add(int &a, int b) {
a += b;
if (a < 0)
a += inf;
if (a >= inf)
a -= inf;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int i, j, a, b, ans = 0;
cin >> n >> k;
vi dp(k + 1, 0), temp(k + 1, 0);
dp[0] = 1;
rep(i, 1, n + 1) {
cin >> A[i];
rep(j, 0, k + 1) {
if (j < k)
add(temp[j + 1], dp[j]);
if (j + A[i] < k)
add(temp[j + A[i] + 1], -dp[j]);
if (j < k)
add(temp[j + 1], temp[j]);
add(dp[j], temp[j]);
temp[j] = 0;
}
}
cout << dp[k];
} | [
"expression.operation.unary.add",
"call.arguments.change"
] | 981,840 | 981,841 | u761472821 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
const int mod = 1e9 + 7;
inline void add_self(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
if (x < 0)
x += mod;
}
inline void add_range(vector<int> &v, int x, int l, int r) {
add_self(v[l], x);
add_self(v[r + 1], -x);
}
void Main() {
int N, K;
cin >> N >> K;
vector<int> a(N);
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
vector<int> curr(K + 1, 0);
curr[K] = 1;
for (int i = 0; i < N; ++i) {
// make difference array for easy range updates
vector<int> diff(K + 1, 0);
add_range(diff, curr[0], 0, 0);
for (int rem = 1; rem <= K; ++rem) {
add_range(diff, curr[rem], rem - min(rem, a[i]), rem);
}
// make real array from difference array
// this would be the "next" array, and i would set curr = next later,
// but i can just set it directly
curr[0] = diff[0];
for (int rem = 1; rem <= K; ++rem) {
curr[rem] = curr[rem - 1];
add_self(curr[rem], diff[rem]);
}
}
// O(N*K^2)
// for (int i = 0; i < N; ++i) {
// vector<int> next(K+1, 0);
// add_self(next[0], curr[0]);
// for (int rem = 1; rem <= K; ++rem) {
// for (int give = 0; give <= min(rem, a[i]); ++give) {
// add_self(next[rem - give], curr[rem]);
// }
// }
// curr = next;
// }
cout << curr[0] << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Main();
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
const int mod = 1e9 + 7;
inline void add_self(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
if (x < 0)
x += mod;
}
inline void add_range(vector<int> &v, int x, int l, int r) {
add_self(v[l], x);
add_self(v[r + 1], -x);
}
void Main() {
int N, K;
cin >> N >> K;
vector<int> a(N);
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
vector<int> curr(K + 2, 0);
curr[K] = 1;
for (int i = 0; i < N; ++i) {
// make difference array for easy range updates
vector<int> diff(K + 2, 0);
add_range(diff, curr[0], 0, 0);
for (int rem = 1; rem <= K; ++rem) {
add_range(diff, curr[rem], rem - min(rem, a[i]), rem);
}
// make real array from difference array
// this would be the "next" array, and i would set curr = next later,
// but i can just set it directly
curr[0] = diff[0];
for (int rem = 1; rem <= K; ++rem) {
curr[rem] = curr[rem - 1];
add_self(curr[rem], diff[rem]);
}
}
// O(N*K^2)
// for (int i = 0; i < N; ++i) {
// vector<int> next(K+1, 0);
// add_self(next[0], curr[0]);
// for (int rem = 1; rem <= K; ++rem) {
// for (int give = 0; give <= min(rem, a[i]); ++give) {
// add_self(next[rem - give], curr[rem]);
// }
// }
// curr = next;
// }
cout << curr[0] << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Main();
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 981,848 | 981,849 | u711859557 | cpp |
p03172 | #include <bits/stdc++.h>
#define int long long
#define mod ((int)1e9 + 7)
using namespace std;
int a, dp[10000007];
void solve() {
int n, k;
cin >> n >> k;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> a;
for (int j = 1; j <= k; j++)
dp[j] = (dp[j - 1] % mod + dp[j] % mod) % mod;
for (int j = k; j >= a + 1; j--)
dp[j] = (dp[j] % mod - dp[j - a - 1] % mod) % mod;
}
cout << dp[k] << endl;
}
main() { solve(); }
| #include <bits/stdc++.h>
#define int long long
#define mod ((int)1e9 + 7)
using namespace std;
int a, dp[10000007];
void solve() {
int n, k;
cin >> n >> k;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> a;
for (int j = 1; j <= k; j++)
dp[j] = (dp[j - 1] % mod + dp[j] % mod) % mod;
for (int j = k; j >= a + 1; j--)
dp[j] = (dp[j] - dp[j - a - 1] + mod) % mod;
}
cout << dp[k] << endl;
}
main() { solve(); }
| [
"expression.operation.binary.remove",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 981,854 | 981,855 | u361596783 | cpp |
p03172 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
int main() {
ll N, K;
cin >> N >> K;
vector<ll> a(N);
vector<vector<ll>> dp(N, vector<ll>(K + 1));
REP(i, N) cin >> a[i];
REP(i, min(a[0], K) + 1) dp[0][i] = 1;
FOR(i, 1, N) {
REP(j, K) dp[i - 1][j + 1] = (dp[i - 1][j + 1] + dp[i - 1][j]) % MOD;
REP(j, K + 1)
dp[i][j] =
(dp[i - 1][j] - (j - a[i] - 1 >= 0 ? dp[i - 1][j - a[i] - 1] : 0)) %
MOD;
}
cout << dp.back().back() << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
int main() {
ll N, K;
cin >> N >> K;
vector<ll> a(N);
vector<vector<ll>> dp(N, vector<ll>(K + 1));
REP(i, N) cin >> a[i];
REP(i, min(a[0], K) + 1) dp[0][i] = 1;
FOR(i, 1, N) {
REP(j, K) dp[i - 1][j + 1] = (dp[i - 1][j + 1] + dp[i - 1][j]) % MOD;
REP(j, K + 1)
dp[i][j] = (MOD + dp[i - 1][j] -
(j - a[i] - 1 >= 0 ? dp[i - 1][j - a[i] - 1] : 0)) %
MOD;
}
cout << dp.back().back() << endl;
return 0;
}
| [
"assignment.change"
] | 981,856 | 981,857 | u692632484 | cpp |
p03172 | #include <bits/stdc++.h>
#define Nmax 3005
using namespace std;
const long long INF = 1e18l;
ifstream f("1.in");
ofstream g("1.out");
const int mod = 1e9 + 7;
void add_self(int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
void sub_self(int &a, int b) {
a -= b;
if (a < 0)
a += mod;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<int> dp(k + 1);
dp[0] = 1;
for (int child = 0; child < n; child++) {
int up_to;
scanf("%d", &up_to);
vector<int> fake(k + 1);
for (int used = k; used >= 0; used--) {
int tmp = dp[used];
int L = used + 1;
int R = used + min(up_to, k - used);
if (L <= R) {
add_self(fake[L], tmp);
if (R + 1 <= k)
sub_self(fake[R + 1], tmp);
}
}
int ps = 0;
for (int i = 0; i <= k; i++) {
add_self(ps, fake[i]);
add_self(dp[i], ps);
}
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
#define Nmax 3005
using namespace std;
const long long INF = 1e18l;
ifstream f("1.in");
ofstream g("1.out");
const int mod = 1e9 + 7;
void add_self(int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
void sub_self(int &a, int b) {
a -= b;
if (a < 0)
a += mod;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<int> dp(k + 1);
dp[0] = 1;
for (int child = 0; child < n; child++) {
int up_to;
scanf("%d", &up_to);
vector<int> fake(k + 1);
for (int used = k; used >= 0; used--) {
int tmp = dp[used];
int L = used + 1;
int R = used + min(up_to, k - used);
if (L <= R) {
add_self(fake[L], tmp);
if (R + 1 <= k)
sub_self(fake[R + 1], tmp);
}
}
int ps = 0;
for (int i = 0; i <= k; i++) {
add_self(ps, fake[i]);
add_self(dp[i], ps);
}
}
cout << dp[k];
return 0;
}
| [
"variable_access.subscript.index.change",
"io.output.change",
"expression.operation.binary.remove"
] | 981,869 | 981,870 | u275238097 | cpp |
p03172 | #define ONLINE_JUDGE
#include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#ifndef ONLINE_JUDGE
#include <prettyprint/prettyprint.hpp>
#endif
#define FOR(i, n) for (int i = 0; i < n; ++i)
#define TEST \
int T; \
std::cin >> T; \
while (T--)
#define ALL(v) v.begin(), v.end()
using ll = long long;
using ull = unsigned long long;
using vi = std::vector<int>;
using vll = std::vector<ll>;
using vull = std::vector<ull>;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using namespace std;
const int mod = 1e9 + 7;
void add_self(int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
void sub_self(int &a, int b) {
a -= b;
if (a < 0)
a += mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#ifndef ONLINE_JUDGE
ifstream fin("in.txt");
ofstream fout("out.txt");
auto cinbuf = cin.rdbuf(fin.rdbuf()); // save and redirect
auto coutbuf = cout.rdbuf(fout.rdbuf()); // save and redirect
#endif
int n, k;
cin >> n >> k;
// We need to choose k things for n buckets, but at max ai for each bucket.
vector<int> dp(k + 1);
dp[0] = 1;
while (n--) {
int limit;
cin >> limit;
// prefix trick.
vector<int> cur(k + 1, 0);
for (int used = k; used >= 0; --used) {
int L = used + 1;
int R = used + min(limit, k - used);
if (R < L)
continue;
add_self(cur[L], dp[used]);
if (R + 1 <= k)
sub_self(dp[R + 1], dp[used]);
}
int pre = 0;
for (int i = 0; i <= k; ++i) {
add_self(pre, cur[i]);
add_self(dp[i], pre);
}
}
cout << dp[k] << endl;
#ifndef ONLINE_JUDGE
cin.rdbuf(cinbuf); // restore
cout.rdbuf(coutbuf); // restore
#endif
}
| #define ONLINE_JUDGE
#include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#ifndef ONLINE_JUDGE
#include <prettyprint/prettyprint.hpp>
#endif
#define FOR(i, n) for (int i = 0; i < n; ++i)
#define TEST \
int T; \
std::cin >> T; \
while (T--)
#define ALL(v) v.begin(), v.end()
using ll = long long;
using ull = unsigned long long;
using vi = std::vector<int>;
using vll = std::vector<ll>;
using vull = std::vector<ull>;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using namespace std;
const int mod = 1e9 + 7;
void add_self(int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
}
void sub_self(int &a, int b) {
a -= b;
if (a < 0)
a += mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#ifndef ONLINE_JUDGE
ifstream fin("in.txt");
ofstream fout("out.txt");
auto cinbuf = cin.rdbuf(fin.rdbuf()); // save and redirect
auto coutbuf = cout.rdbuf(fout.rdbuf()); // save and redirect
#endif
int n, k;
cin >> n >> k;
// We need to choose k things for n buckets, but at max ai for each bucket.
vector<int> dp(k + 1);
dp[0] = 1;
while (n--) {
int limit;
cin >> limit;
// prefix trick.
vector<int> cur(k + 1, 0);
for (int used = k; used >= 0; --used) {
int L = used + 1;
int R = used + min(limit, k - used);
if (R < L)
continue;
add_self(cur[L], dp[used]);
if (R + 1 <= k)
sub_self(cur[R + 1], dp[used]);
}
int pre = 0;
for (int i = 0; i <= k; ++i) {
add_self(pre, cur[i]);
add_self(dp[i], pre);
}
}
cout << dp[k] << endl;
#ifndef ONLINE_JUDGE
cin.rdbuf(cinbuf); // restore
cout.rdbuf(coutbuf); // restore
#endif
}
| [
"identifier.change",
"call.arguments.change"
] | 981,873 | 981,874 | u702346849 | cpp |
p03172 | #include <functional>
#include <iostream>
#include <vector>
using namespace std;
const int MD = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n, 0);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
function<long long(int, int)> solve = [&](int i, int k) -> long long {
if (i == n && k == 0) {
return 1;
} else if (i == n && k) {
return 0;
}
if (dp[i][k] != -1) {
return dp[i][k];
}
long long nways = 0;
for (int bal = 0; bal <= a[i]; bal++) {
if (k - bal < 0) {
break;
}
nways = (nways + solve(i + 1, k - bal)) % MD;
}
// cout << i << " " << k << " " << nways << endl;
return dp[i][k] = nways;
};
// dp[i][j] = num ways to distribute j candies among first i people
// dp[i][j] = Sigma{bal = 0; bal <= a[i]}(dp[i-1][j-bal])
dp[0][0] = 1;
vector<vector<int>> prefix(n + 1, vector<int>(k + 1, 0));
prefix[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = 1;
prefix[i][0] = 1;
}
for (int i = 1; i <= k; i++) {
prefix[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
int right = prefix[i - 1][j];
int left = 0;
if (j - a[i - 1] - 1 >= 0)
left = prefix[i - 1][j - a[i - 1] - 1];
dp[i][j] = (dp[i][j] % MD + ((right - left) % MD)) % MD;
prefix[i][j] = (prefix[i][j - 1] % MD + dp[i][j] % MD) % MD;
// for (int bal = 0; bal <= a[i-1]; bal++) {
// if (j - bal < 0) break;
// dp[i][j] = (dp[i][j] + dp[i-1][j - bal])%MD;
// }
}
}
cout << dp[n][k] << endl;
// cout << "solve ?" << endl;
// long long ans = solve(0, k);
// cout << ans << endl;
return 0;
} | #include <functional>
#include <iostream>
#include <vector>
using namespace std;
const int MD = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n, 0);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
function<long long(int, int)> solve = [&](int i, int k) -> long long {
if (i == n && k == 0) {
return 1;
} else if (i == n && k) {
return 0;
}
if (dp[i][k] != -1) {
return dp[i][k];
}
long long nways = 0;
for (int bal = 0; bal <= a[i]; bal++) {
if (k - bal < 0) {
break;
}
nways = (nways + solve(i + 1, k - bal)) % MD;
}
// cout << i << " " << k << " " << nways << endl;
return dp[i][k] = nways;
};
// dp[i][j] = num ways to distribute j candies among first i people
// dp[i][j] = Sigma{bal = 0; bal <= a[i]}(dp[i-1][j-bal])
dp[0][0] = 1;
vector<vector<int>> prefix(n + 1, vector<int>(k + 1, 0));
prefix[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = 1;
prefix[i][0] = 1;
}
for (int i = 1; i <= k; i++) {
prefix[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
int right = prefix[i - 1][j];
int left = 0;
if (j - a[i - 1] - 1 >= 0)
left = prefix[i - 1][j - a[i - 1] - 1];
dp[i][j] = (dp[i][j] % MD + ((right - left + MD) % MD)) % MD;
prefix[i][j] = (prefix[i][j - 1] % MD + dp[i][j] % MD) % MD;
// for (int bal = 0; bal <= a[i-1]; bal++) {
// if (j - bal < 0) break;
// dp[i][j] = (dp[i][j] + dp[i-1][j - bal])%MD;
// }
}
}
cout << dp[n][k] << endl;
// cout << "solve ?" << endl;
// long long ans = solve(0, k);
// cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 981,883 | 981,884 | u467133453 | cpp |
p03172 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
ll mod = 1e9 + 7;
int main() {
/*
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif*/
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll dp[n][k + 1];
for (int j = 0; j <= k; j++) {
if (j <= a[0])
dp[0][j] = 1;
else
dp[0][j] = 0;
}
for (int i = 1; i < n; i++) {
ll pre[k + 1];
for (int j = 0; j <= k; j++) {
pre[j] = dp[i - 1][j];
if (j > 0)
pre[j] = (pre[j] + pre[j - 1]) % mod;
}
for (int j = 0; j <= k; j++) {
int st = j - min(a[i], j);
int end = j;
ll x = 0;
if (st > 0)
x = pre[st - 1];
dp[i][j] = pre[end] - x;
}
}
cout << dp[n - 1][k];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
ll mod = 1e9 + 7;
int main() {
/*
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif*/
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll dp[n][k + 1];
for (int j = 0; j <= k; j++) {
if (j <= a[0])
dp[0][j] = 1;
else
dp[0][j] = 0;
}
for (int i = 1; i < n; i++) {
ll pre[k + 1];
for (int j = 0; j <= k; j++) {
pre[j] = dp[i - 1][j];
if (j > 0)
pre[j] = (pre[j] + pre[j - 1]) % mod;
}
for (int j = 0; j <= k; j++) {
int st = j - min(a[i], j);
int end = j;
ll x = 0;
if (st > 0)
x = pre[st - 1];
dp[i][j] = (pre[end] - x + mod) % mod;
}
}
cout << dp[n - 1][k];
} | [
"assignment.change"
] | 981,889 | 981,890 | u825143564 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.