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>
using namespace std;
#define ll long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (ll)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 200005
int n;
ll a[405], p[405];
ll dp[405][405];
ll doit(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], doit(i, k) + doit(k + 1, j) + p[j] - p[i - 1]);
return dp[i][j];
}
int main() {
sp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[i] = a[i];
p[i] += p[i - 1];
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dp[i][j] = -1;
cout << doit(1, n);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (ll)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 200005
int n;
ll a[405], p[405];
ll dp[405][405];
ll doit(int i, int j) {
if (i >= j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = LLONG_MAX;
for (int k = i; k < j; ++k)
dp[i][j] = min(dp[i][j], doit(i, k) + doit(k + 1, j) + p[j] - p[i - 1]);
return dp[i][j];
}
int main() {
sp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[i] = a[i];
p[i] += p[i - 1];
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dp[i][j] = -1;
cout << doit(1, n);
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 982,576 | 982,577 | u450036612 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (ll)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 200005
int n;
ll a[405], p[405];
ll dp[405][405];
ll doit(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], doit(i, k) + doit(k + 1, j) + p[j] - p[i - 1]);
return dp[i][j];
}
int main() {
sp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[i] = a[i];
p[i] += p[i - 1];
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dp[i][j] = -1;
cout << doit(1, n);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (ll)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 200005
int n;
ll a[405], p[405];
ll dp[405][405];
ll doit(int i, int j) {
if (i >= j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = LLONG_MAX;
for (int k = i; k < j; ++k)
dp[i][j] = min(dp[i][j], doit(i, k) + doit(k + 1, j) + p[j] - p[i - 1]);
return dp[i][j];
}
int main() {
sp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[i] = a[i];
p[i] += p[i - 1];
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dp[i][j] = -1;
cout << doit(1, n);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 982,578 | 982,577 | u450036612 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (ll)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 200005
int n;
int a[405], p[405];
ll dp[405][405];
ll doit(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], doit(i, k) + doit(k + 1, j) + p[j] - p[i - 1]);
return dp[i][j];
}
int main() {
sp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[i] = a[i];
p[i] += p[i - 1];
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dp[i][j] = -1;
cout << doit(1, n);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (ll)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 200005
int n;
ll a[405], p[405];
ll dp[405][405];
ll doit(int i, int j) {
if (i >= j)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
dp[i][j] = LLONG_MAX;
for (int k = i; k < j; ++k)
dp[i][j] = min(dp[i][j], doit(i, k) + doit(k + 1, j) + p[j] - p[i - 1]);
return dp[i][j];
}
int main() {
sp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[i] = a[i];
p[i] += p[i - 1];
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dp[i][j] = -1;
cout << doit(1, n);
return 0;
}
| [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 982,579 | 982,577 | u450036612 | cpp |
p03173 | #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define reps(i, N) for (int i = 1; i <= (N); i++)
#define repr(i, N) for (int i = (N)-1; i >= 0; i--)
#define pub push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const ll LINF = 10000000000000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
int N;
ll a[400];
ll dp[400][400];
ll d[401];
void solve() {
rep(i, N) { d[i + 1] = d[i] + a[i]; }
rep(i, N) {
rep(j, N) {
if (i != j)
dp[i][j] = INF;
}
}
reps(w, N - 1) {
for (int i = 0; i + w < N; i++) {
for (int j = i; j < i + w; j++) {
chmin(dp[i][i + w], dp[i][j] + dp[j + 1][i + w] + d[i + w + 1] - d[i]);
}
}
}
// da2(dp, N, N);
cout << dp[0][N - 1] << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) { cin >> a[i]; }
solve();
return 0;
}
| #include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define reps(i, N) for (int i = 1; i <= (N); i++)
#define repr(i, N) for (int i = (N)-1; i >= 0; i--)
#define pub push_back
template <typename T> void chmax(T &a, T b) { a = max(a, b); };
template <typename T> void chmin(T &a, T b) { a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const ll LINF = 10000000000000000;
const int MOD = 1000000007;
const int dx[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
int N;
ll a[400];
ll dp[400][400];
ll d[401];
void solve() {
rep(i, N) { d[i + 1] = d[i] + a[i]; }
rep(i, N) {
rep(j, N) {
if (i != j)
dp[i][j] = LINF;
}
}
reps(w, N - 1) {
for (int i = 0; i + w < N; i++) {
for (int j = i; j < i + w; j++) {
chmin(dp[i][i + w], dp[i][j] + dp[j + 1][i + w] + d[i + w + 1] - d[i]);
}
}
}
// da2(dp, N, N);
cout << dp[0][N - 1] << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) { cin >> a[i]; }
solve();
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 982,580 | 982,581 | u073946233 | cpp |
p03173 | #include <bits/stdc++.h>
#define Nmax 405
using namespace std;
const long long INF = 1e18l + 2;
ifstream f("1.in");
int n;
int v[Nmax], sp[Nmax];
long long dp[Nmax][Nmax]; // dp[i][j]=minimum sum combining slimes from i to j
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
sp[i] = sp[i - 1] + v[i];
}
for (int i = 2; i <= n; i++)
dp[i - 1][i] = v[i] + v[i - 1];
for (int len = 2; len < n; len++) {
for (int i = 1; i + len <= n; i++) {
dp[i][i + len] = INF;
for (int mij = i; mij <= i + len; mij++) {
dp[i][i + len] = min(dp[i][i + len], dp[i][mij] + dp[mij + 1][i + len] +
sp[i + len] - sp[i - 1]);
}
}
}
cout << dp[1][n];
return 0;
}
| #include <bits/stdc++.h>
#define Nmax 405
using namespace std;
const long long INF = 1e18l + 2;
ifstream f("1.in");
int n;
int v[Nmax];
long long sp[Nmax];
long long dp[Nmax][Nmax]; // dp[i][j]=minimum sum combining slimes from i to j
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
sp[i] = sp[i - 1] + v[i];
}
for (int i = 2; i <= n; i++)
dp[i - 1][i] = v[i] + v[i - 1];
for (int len = 2; len < n; len++) {
for (int i = 1; i + len <= n; i++) {
dp[i][i + len] = INF;
for (int mij = i; mij <= i + len; mij++) {
dp[i][i + len] = min(dp[i][i + len], dp[i][mij] + dp[mij + 1][i + len] +
sp[i + len] - sp[i - 1]);
}
}
}
cout << dp[1][n];
return 0;
}
| [
"variable_declaration.type.widen.change"
] | 982,582 | 982,583 | u275238097 | cpp |
p03173 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define F first
#define S second
#define PB push_back
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define REPI(i, a, b) for (int i = a; i >= b; i--)
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int OO = 1e18 + 7;
const int MOD = 1e9 + 7;
const int N = 4e2 + 7;
int n;
int a[N];
ll pref[N];
ll mem[N][N];
ll dp(int l, int r) {
ll &ret = mem[l][r];
if (ret != -1)
return ret;
if (l == r)
return 0;
ret = OO;
REP(i, l, r - 1) {
ret = min(ret, dp(l, i) + dp(i + 1, r) - pref[l - 1] + pref[r]);
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("teleport.in","r",stdin);
// freopen("teleport.out","w",stdout);
memset(mem, -1, sizeof mem);
cin >> n;
REP(i, 1, n) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
cout << dp(1, n) << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define F first
#define S second
#define PB push_back
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define REPI(i, a, b) for (int i = a; i >= b; i--)
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const ll OO = 1e18 + 7;
const int MOD = 1e9 + 7;
const int N = 4e2 + 7;
int n;
int a[N];
ll pref[N];
ll mem[N][N];
ll dp(int l, int r) {
ll &ret = mem[l][r];
if (ret != -1)
return ret;
if (l == r)
return 0;
ret = OO;
REP(i, l, r - 1) {
ret = min(ret, dp(l, i) + dp(i + 1, r) - pref[l - 1] + pref[r]);
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("teleport.in","r",stdin);
// freopen("teleport.out","w",stdout);
memset(mem, -1, sizeof mem);
cin >> n;
REP(i, 1, n) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
cout << dp(1, n) << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 982,588 | 982,589 | u216673135 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll arr[100005];
ll memo[4005][4005];
ll prefix[100005];
ll getcost(int left, int right) { return prefix[right + 1] - prefix[left]; }
ll solve(int left, int right) {
if (left >= right)
return 0;
if (memo[left][right] != -1)
return memo[left][right];
ll ret = 1e9;
for (int i = left; i < right; i++) {
ret = min(solve(left, i) + solve(i + 1, right) + getcost(left, i) +
getcost(i + 1, right),
ret);
}
return memo[left][right] = ret;
}
int main() {
memset(memo, -1, sizeof(memo));
int n;
cin >> n;
prefix[0] = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
prefix[i + 1] = prefix[i] + arr[i];
}
ll ans = solve(0, n - 1);
printf("%lld\n", ans);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll arr[100005];
ll memo[4005][4005];
ll prefix[100005];
ll getcost(int left, int right) { return prefix[right + 1] - prefix[left]; }
ll solve(int left, int right) {
if (left >= right)
return 0;
if (memo[left][right] != -1)
return memo[left][right];
ll ret = 1e18;
for (int i = left; i < right; i++) {
ret = min(solve(left, i) + solve(i + 1, right) + getcost(left, i) +
getcost(i + 1, right),
ret);
}
return memo[left][right] = ret;
}
int main() {
memset(memo, -1, sizeof(memo));
int n;
cin >> n;
prefix[0] = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
prefix[i + 1] = prefix[i] + arr[i];
}
ll ans = solve(0, n - 1);
printf("%lld\n", ans);
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 982,595 | 982,596 | u202601655 | cpp |
p03173 | #include <algorithm>
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
int n;
ll a[401], dp[401][402];
ll dfs(int left, int right) {
if (left + 1 == right)
return 0LL;
if (dp[left][right] != INF)
return dp[left][right];
for (int k = left + 1; k < right; ++k) {
dp[left][right] = min(dp[left][right], dfs(left, k) + dfs(k, right));
}
dp[left][right] += a[right - 1] - a[left - 1];
return dp[left][right];
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i <= n; ++i)
a[i] += a[i - 1];
fill(dp[0], dp[400] + 402, INF);
cerr << dfs(1, n + 1) << endl;
}
| #include <algorithm>
#include <iostream>
#include <set>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
int n;
ll a[401], dp[401][402];
ll dfs(int left, int right) {
if (left + 1 == right)
return 0LL;
if (dp[left][right] != INF)
return dp[left][right];
for (int k = left + 1; k < right; ++k) {
dp[left][right] = min(dp[left][right], dfs(left, k) + dfs(k, right));
}
dp[left][right] += a[right - 1] - a[left - 1];
return dp[left][right];
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i <= n; ++i)
a[i] += a[i - 1];
fill(dp[0], dp[400] + 402, INF);
cout << dfs(1, n + 1) << endl;
}
| [
"identifier.change",
"io.output.change"
] | 982,599 | 982,600 | u986399983 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define pb push_back
#define mp make_pair
#define MAX 1000000
#define mod 1000000007
#define all(_) _.begin(), _.end()
#define F first
#define S second
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
ll n, i, j, k;
cin >> n;
ll dp[n][n];
vll psum(n + 1, 0);
for (i = 0; i < n; i++) {
cin >> j;
psum[i + 1] = psum[i] + j;
}
memset(dp, 0, sizeof dp);
for (i = 1; i < n; i++) {
for (j = 0; i + j < n; j++) {
dp[j][i + j] = INT_MAX;
for (k = j; k < i + j; k++)
dp[j][i + j] = min(dp[j][i + j], dp[j][k] + dp[k + 1][i + j] +
psum[i + j + 1] - psum[j]);
}
}
cout << dp[0][n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define pb push_back
#define mp make_pair
#define MAX 1000000
#define mod 1000000007
#define all(_) _.begin(), _.end()
#define F first
#define S second
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
ll n, i, j, k;
cin >> n;
ll dp[n][n];
vll psum(n + 1, 0);
for (i = 0; i < n; i++) {
cin >> j;
psum[i + 1] = psum[i] + j;
}
memset(dp, 0, sizeof dp);
for (i = 1; i < n; i++) {
for (j = 0; i + j < n; j++) {
dp[j][i + j] = LLONG_MAX;
for (k = j; k < i + j; k++)
dp[j][i + j] = min(dp[j][i + j], dp[j][k] + dp[k + 1][i + j] +
psum[i + j + 1] - psum[j]);
}
}
cout << dp[0][n - 1] << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 982,612 | 982,613 | u924895886 | cpp |
p03173 | #include <cstdio>
#include <cstring>
const int MAXN = 410;
int n, a[MAXN];
long long f[MAXN][MAXN];
inline long long min(long long x, long long y) { return x < y ? x : y; }
int main() {
memset(f, 0x3f, sizeof(f));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] += a[i - 1];
f[i][i] = 0;
}
for (int len = 2; len <= n; len++)
for (int r = 1; r <= n; r++) {
int l = r - len + 1;
if (l < 1)
continue;
for (int k = l; k < r; k++)
f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
f[l][r] += a[r] - a[l - 1];
// printf("%d %d %lld\n",l,r,f[l][r]);
}
printf("%lld\n", f[1][n]);
return 0;
} | #include <cstdio>
#include <cstring>
const int MAXN = 410;
int n;
long long a[MAXN];
long long f[MAXN][MAXN];
inline long long min(long long x, long long y) { return x < y ? x : y; }
int main() {
memset(f, 0x3f, sizeof(f));
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
a[i] += a[i - 1];
f[i][i] = 0;
}
for (int len = 2; len <= n; len++)
for (int r = 1; r <= n; r++) {
int l = r - len + 1;
if (l < 1)
continue;
for (int k = l; k < r; k++)
f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r]);
f[l][r] += a[r] - a[l - 1];
// printf("%d %d %lld\n",l,r,f[l][r]);
}
printf("%lld\n", f[1][n]);
return 0;
} | [
"literal.string.change",
"call.arguments.change"
] | 982,616 | 982,617 | u828727453 | cpp |
p03173 | // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int maxn = 405, INF = 1e9;
int N, a[maxn];
long long s[maxn], dp[maxn][maxn];
int main() {
#ifdef LOCAL
freopen("./input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (i == 0)
s[i] = a[i];
else
s[i] = s[i - 1] + a[i];
fill(dp[i], dp[i] + N, INF);
dp[i][i] = 0;
}
for (int l = 2; l <= N; l++) {
for (int i = 0, j = l - 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]);
}
dp[i][j] += s[j] - (i > 0 ? s[i - 1] : 0);
}
}
cout << dp[0][N - 1] << endl;
return 0;
}
| // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int maxn = 405;
const long long INF = 1e18;
int N, a[maxn];
long long s[maxn], dp[maxn][maxn];
int main() {
#ifdef LOCAL
freopen("./input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
if (i == 0)
s[i] = a[i];
else
s[i] = s[i - 1] + a[i];
fill(dp[i], dp[i] + N, INF);
dp[i][i] = 0;
}
for (int l = 2; l <= N; l++) {
for (int i = 0, j = l - 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]);
}
dp[i][j] += s[j] - (i > 0 ? s[i - 1] : 0);
}
}
cout << dp[0][N - 1] << endl;
return 0;
}
| [
"variable_declaration.add",
"literal.number.change",
"variable_declaration.value.change"
] | 982,620 | 982,619 | u041075929 | cpp |
p03173 | #include <bits/stdc++.h>
using namespace std;
long long dp[405][405];
int a[405];
int n;
long long MAX = 1e18 + 5;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int l = 2; l <= n; l++) {
for (int i = 1; i + l - 1 <= n; i++) {
int j = i + l - 1;
dp[i][j] = MAX;
for (int k = i; k < j && k < n; k++)
dp[i][j] = min(dp[i][j], (dp[i][k] + dp[k + 1][j]) + a[j] - a[i - 1]);
}
}
cout << dp[1][n];
}
| #include <bits/stdc++.h>
using namespace std;
long long dp[405][405];
long long a[405];
int n;
long long MAX = 1e18 + 5;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++)
dp[i][i] = 0;
for (int l = 2; l <= n; l++) {
for (int i = 1; i + l - 1 <= n; i++) {
int j = i + l - 1;
dp[i][j] = MAX;
for (int k = i; k < j && k < n; k++)
dp[i][j] = min(dp[i][j], (dp[i][k] + dp[k + 1][j]) + a[j] - a[i - 1]);
}
}
cout << dp[1][n];
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 982,625 | 982,626 | u573738515 | cpp |
p03173 | #include <iostream>
using namespace std;
#include <bits/stdc++.h>
#define MOD 1000000007
typedef long long ll;
vector<vector<ll>> dp_arr;
int main() {
int n;
cin >> n;
vector<ll> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<ll> cum_sum(n + 1, 0);
for (int i = 1; i <= n; i++) {
cum_sum[i] = arr[i - 1] + cum_sum[i - 1];
}
dp_arr.resize(n + 1, vector<ll>(n + 1, 0));
// for(int i = 1; i <= n; i++)
// {
// dp_arr[i][i] = arr[i-1];
// }
for (int l = 2; l <= n; l++) {
for (int i = 1; i + l - 1 <= n; i++) {
ll min_ = INT_MAX;
for (int j = i; j < i + l - 1; j++) {
// if(l == 2)
// {
// min_ = min(min_, dp_arr[i][j] + dp_arr[j+1][i+l-1] +
// cum_sum[i+l-1] - cum_sum[i-1]);
// }
min_ = min(min_, dp_arr[i][j] + dp_arr[j + 1][i + l - 1] +
cum_sum[i + l - 1] - cum_sum[i - 1]);
}
dp_arr[i][i + l - 1] = min_;
// cout << "i: " << i << " j: " << i+l-1 << " dp: " << dp_arr[i][i+l-1] <<
// endl;
}
}
cout << dp_arr[1][n] << endl;
return 0;
}
| #include <iostream>
using namespace std;
#include <bits/stdc++.h>
#define MOD 1000000007
typedef long long ll;
vector<vector<ll>> dp_arr;
int main() {
int n;
cin >> n;
vector<ll> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<ll> cum_sum(n + 1, 0);
for (int i = 1; i <= n; i++) {
cum_sum[i] = arr[i - 1] + cum_sum[i - 1];
}
dp_arr.resize(n + 1, vector<ll>(n + 1, 0));
// for(int i = 1; i <= n; i++)
// {
// dp_arr[i][i] = arr[i-1];
// }
for (int l = 2; l <= n; l++) {
for (int i = 1; i + l - 1 <= n; i++) {
ll min_ = LONG_MAX;
for (int j = i; j < i + l - 1; j++) {
// if(l == 2)
// {
// min_ = min(min_, dp_arr[i][j] + dp_arr[j+1][i+l-1] +
// cum_sum[i+l-1] - cum_sum[i-1]);
// }
min_ = min(min_, dp_arr[i][j] + dp_arr[j + 1][i + l - 1] +
cum_sum[i + l - 1] - cum_sum[i - 1]);
}
dp_arr[i][i + l - 1] = min_;
// cout << "i: " << i << " j: " << i+l-1 << " dp: " << dp_arr[i][i+l-1] <<
// endl;
}
}
cout << dp_arr[1][n] << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.change"
] | 982,627 | 982,628 | u032940964 | cpp |
p03173 | #include <iostream>
#define int long long
using namespace std;
const int inf = 1e18 + 1;
int dp[405][405], ar[405], sum[405];
signed main() {
int n, i, j, k;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> ar[i];
sum[i] = sum[i - 1] + ar[i];
dp[i][i] = 0;
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
dp[i][j] = inf;
}
}
for (i = 1; i < n; i++) {
for (j = 1; j <= n - i; j++) {
for (k = i; k < i + j; k++) {
dp[j][i + j] = min(dp[j][j + i], dp[j][k] + dp[k + 1][i + j] +
sum[i + j] - sum[j - 1]);
}
}
}
cout << dp[1][n];
} | #include <iostream>
#define int long long
using namespace std;
const int inf = 1e18 + 1;
int dp[405][405], ar[405], sum[405];
signed main() {
int n, i, j, k;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> ar[i];
sum[i] = sum[i - 1] + ar[i];
dp[i][i] = 0;
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
dp[i][j] = inf;
}
}
for (i = 1; i < n; i++) {
for (j = 1; j <= n - i; j++) {
for (k = j; k < i + j; k++) {
dp[j][i + j] = min(dp[j][j + i], dp[j][k] + dp[k + 1][i + j] +
sum[i + j] - sum[j - 1]);
}
}
}
cout << dp[1][n];
} | [
"assignment.value.change",
"identifier.change",
"control_flow.loop.for.initializer.change"
] | 982,637 | 982,638 | u639335047 | cpp |
p03174 | #include <bits/stdc++.h>
typedef long long ll;
const int MN = 24, MOD = 1e9 + 7;
int N, A[MN][MN], dp[MN][1 << MN];
inline int cb(int msk, int b) { return msk & ~(1 << b); }
inline int sb(int msk, int b) { return msk | (1 << b); }
inline int tb(int msk, int b) { return msk ^ (1 << b); }
inline bool ib(int msk, int b) { return msk & (1 << b); }
int solve(int n, int msk) {
if (n < 0)
return 1;
if (~dp[n][msk])
return dp[n][msk];
dp[n][msk] = 0;
for (int i = 0; i < N; ++i)
if (A[n][i] && !ib(msk, i))
dp[n][msk] = (dp[n][msk] + solve(n - 1, sb(msk, i))) % MOD;
return dp[n][msk];
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
scanf("%d", &A[i][j]);
memset(dp, -1, sizeof dp);
printf("%d\n", solve(N - 1, 0));
}
| #include <bits/stdc++.h>
typedef long long ll;
const int MN = 21, MOD = 1e9 + 7;
int N, A[MN][MN], dp[MN][1 << MN];
inline int cb(int msk, int b) { return msk & ~(1 << b); }
inline int sb(int msk, int b) { return msk | (1 << b); }
inline int tb(int msk, int b) { return msk ^ (1 << b); }
inline bool ib(int msk, int b) { return msk & (1 << b); }
int solve(int n, int msk) {
if (n < 0)
return 1;
if (~dp[n][msk])
return dp[n][msk];
dp[n][msk] = 0;
for (int i = 0; i < N; ++i)
if (A[n][i] && !ib(msk, i))
dp[n][msk] = (dp[n][msk] + solve(n - 1, sb(msk, i))) % MOD;
return dp[n][msk];
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
scanf("%d", &A[i][j]);
memset(dp, -1, sizeof dp);
printf("%d\n", solve(N - 1, 0));
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 982,644 | 982,645 | u596743351 | cpp |
p03174 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define mkp make_pair
#define pr(num) cout << num << "\n"
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define INF 1000000000000000000
#define MOD 1000000007LL
#define MAX 100010
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef map<ll, ll> Map;
ll dp[22][2100000];
int main(void) {
ll N;
cin >> N;
ll a[22][22];
ll i, j, k;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
cin >> a[i][j];
}
}
dp[0][0] = 1;
for (i = 1; i < N; i++) {
for (j = 0; j < 1 << N; j++) {
for (k = 0; k < N; k++) {
if (dp[i][j] == 0 || a[i][k] == 0 || j >> k & 1)
continue;
dp[i + 1][j | 1 << k] = (dp[i + 1][j | 1 << k] + dp[i][j]) % MOD;
}
}
}
pr(dp[N][(1 << N) - 1]);
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define mkp make_pair
#define pr(num) cout << num << "\n"
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define INF 1000000000000000000
#define MOD 1000000007LL
#define MAX 100010
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef map<ll, ll> Map;
ll dp[22][2100000];
int main(void) {
ll N;
cin >> N;
ll a[22][22];
ll i, j, k;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
cin >> a[i][j];
}
}
dp[0][0] = 1;
for (i = 0; i < N; i++) {
for (j = 0; j < 1 << N; j++) {
for (k = 0; k < N; k++) {
if (dp[i][j] == 0 || a[i][k] == 0 || j >> k & 1)
continue;
dp[i + 1][j | 1 << k] = (dp[i + 1][j | 1 << k] + dp[i][j]) % MOD;
}
}
}
pr(dp[N][(1 << N) - 1]);
}
| [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 982,648 | 982,649 | u768152935 | cpp |
p03174 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define int long long int
#define endl "\n"
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
const int mod = 1e9 + 7;
const int N = 21;
int cache[(1 << N) + 5];
int n;
int a[22][22];
int dp(int mask) {
if (mask == 0)
return 1;
int &ans = cache[mask];
if (ans != -1)
return ans;
ans = 0;
int pos = n - (__builtin_popcount(mask));
for (int i = 0; i < n; i++) {
if (mask & (1 << i) && a[pos][i + 1])
ans = (ans + dp(mask & (~(1 << i)))) % mod;
}
return ans;
}
int32_t main() {
memset(cache, -1, sizeof cache);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
cin >> a[i][j];
}
cout << dp((1 << n) - 1);
}
| #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define int long long int
#define endl "\n"
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
const int mod = 1e9 + 7;
const int N = 21;
int cache[(1 << N) + 5];
int n;
int a[22][22];
int dp(int mask) {
if (mask == 0)
return 1;
int &ans = cache[mask];
if (ans != -1)
return ans;
ans = 0;
int pos = n - (__builtin_popcount(mask)) + 1;
for (int i = 0; i < n; i++) {
if (mask & (1 << i) && a[pos][i + 1])
ans = (ans + dp(mask & (~(1 << i)))) % mod;
}
return ans;
}
int32_t main() {
memset(cache, -1, sizeof cache);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
cin >> a[i][j];
}
cout << dp((1 << n) - 1);
}
| [
"assignment.change"
] | 982,650 | 982,651 | u791542693 | cpp |
p03174 | #include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
#define debug(x) cerr << #x << " = " << (x) << endl;
template <typename T> ostream &operator<<(ostream &o, vector<T> &v) {
for (auto &x : v)
o << x << ' ';
return o;
}
const int MOD = 1e9 + 7;
void add(int res, int x) {
res += x;
if (res >= MOD)
res -= MOD;
}
int n;
int adj[22][22];
int memo[22][1 << 21];
int dp(int i, int mask) {
int &res = memo[i][mask];
if (res != -1)
return res;
if (i == n)
return res = 1;
res = 0;
for (int j = 0; j < n; j++) {
if (adj[i][j] && ((1 << j) & mask)) {
add(res, dp(i + 1, mask ^ (1 << j)));
}
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> adj[i][j];
memset(memo, -1, sizeof memo);
cout << dp(0, (1 << n) - 1) << endl;
;
}
| #include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
#define debug(x) cerr << #x << " = " << (x) << endl;
template <typename T> ostream &operator<<(ostream &o, vector<T> &v) {
for (auto &x : v)
o << x << ' ';
return o;
}
const int MOD = 1e9 + 7;
void add(int &res, int x) {
res += x;
if (res >= MOD)
res -= MOD;
}
int n;
int adj[22][22];
int memo[22][1 << 21];
int dp(int i, int mask) {
int &res = memo[i][mask];
if (res != -1)
return res;
if (i == n)
return res = 1;
res = 0;
for (int j = 0; j < n; j++) {
if (adj[i][j] && ((1 << j) & mask)) {
add(res, dp(i + 1, mask ^ (1 << j)));
}
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> adj[i][j];
memset(memo, -1, sizeof memo);
cout << dp(0, (1 << n) - 1) << endl;
;
}
| [] | 982,652 | 982,653 | u115464345 | cpp |
p03174 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define MAXN 2097153
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define FAIL0 \
{ \
printf("0\n"); \
return 0; \
}
#define FAIL_1 \
{ \
printf("-1\n"); \
return 0; \
}
int N;
int A[22][22];
LL dp[MAXN];
void add(LL &a, LL b) { a = (a + b) % MOD; }
int nbit(int n) {
int r = 0;
while (n) {
r += n % 2;
n /= 2;
}
return r;
}
int main(int argc, char **argv) {
#ifdef OJ
freopen("input.txt", "rt", stdin);
// freopen("output.txt", "wt", stdout);
#endif
scanf("%d", &N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
scanf("%d", &A[i][j]);
LL ans = 0;
for (int i = 1; i < (1 << N); i++) {
int nb = nbit(i) - 1;
if (!nb) {
for (int b = 0; b < N; b++)
if (A[0][b] && (i & (1 << b))) {
dp[i] = 1;
}
} else {
for (int b = 0; b < N; b++) {
if (i & (1 << b) && A[nb][b]) {
add(dp[i], dp[i ^ (1 << b)]);
}
}
if (nb + 1 == N)
add(ans, dp[i]);
}
// printf("%d %lld\n", i, dp[i]);
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
#define MAXN 2097154
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define FAIL0 \
{ \
printf("0\n"); \
return 0; \
}
#define FAIL_1 \
{ \
printf("-1\n"); \
return 0; \
}
int N;
int A[22][22];
LL dp[MAXN];
void add(LL &a, LL b) { a = (a + b) % MOD; }
int nbit(int n) {
int r = 0;
while (n) {
r += n % 2;
n /= 2;
}
return r;
}
int main(int argc, char **argv) {
#ifdef OJ
freopen("input.txt", "rt", stdin);
// freopen("output.txt", "wt", stdout);
#endif
scanf("%d", &N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
scanf("%d", &A[i][j]);
LL ans = 0;
for (int i = 1; i < (1 << N); i++) {
int nb = nbit(i) - 1;
if (!nb) {
for (int b = 0; b < N; b++)
if (A[0][b] && (i & (1 << b))) {
dp[i] = 1;
}
} else {
for (int b = 0; b < N; b++) {
if ((i & (1 << b)) && A[nb][b]) {
add(dp[i], dp[i ^ (1 << b)]);
}
}
}
if (nb + 1 == N)
add(ans, dp[i]);
// printf("%d %lld\n", i, dp[i]);
}
printf("%lld\n", ans);
return 0;
}
| [
"preprocessor.define.value.change",
"literal.integer.change",
"control_flow.branch.if.condition.change"
] | 982,660 | 982,659 | u066478371 | cpp |
p03174 | #include <bits/stdc++.h>
using namespace std;
// using lint = long long;
struct P {
int x, y;
bool operator<(const P &a) const {
if (x != a.x)
return x > a.x;
return y > a.y;
}
};
vector<int> v[1], v1;
// bitset<4001000> b;
int i, n, d, m, k, a, b, c, h;
int o[1111][33];
long long l[33][4000511];
int j[1];
int e;
// int dx[10]={2,2,-2,-2,1,1,-1,-1},dy[10]={1,-1,1,-1,2,-2,2,-2};
int dx[10] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[10] = {1, 0, -1, 0, 1, -1, 1, -1},
dz[10] = {0, 0, 0, 0, 1, -1};
long long mod = 1000000007, mod2 = 1000000009, mod3 = 2017;
long long x, z, y;
double pi = 3.14159265;
P u[1];
stack<int> s;
// set<int> s[222][22];
priority_queue<long long, vector<long long>, greater<long long>> q;
// queue<int> q;
// 2147483647
//'1'==49;
//'A'==65;
//'a'==97;
// unordered_
// map<int,int> p;
/*
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count(); return splitmix64(x +
FIXED_RANDOM);
}
};
unordered_map<long long, int, custom_hash> safe_map;
*/
// list<int> l;
// string r,r1;
// char r[2];
// deque<int> de;
// srand((int)time(NULL));
/*bool as(P a,P b)
{
if(a.x!=b.x)
return a.x<b.x;
return a.y<b.y;
}*/
bool as(P a, P b) {
if (a.x != b.x)
return a.x < b.x;
return a.y < b.y;
}
long long f(int n, int m) {
if (n >= a)
return 1;
if (l[n][m] >= 0)
return l[n][m];
long long x = 0;
for (int h = 0, i = 1; h < a; i *= 2, h++)
if (o[n][h] && (m & i) == 0)
x += f(n + 1, m + i), x %= mod;
return l[n][m] = x;
}
int main() {
memset(l, -1, sizeof(l));
scanf("%d", &a);
for (int t = 0; t < a; t++)
for (int w = 0; w < a; w++)
scanf("%d", &o[t][w]);
printf("%lld", f(0, 0));
}
| #include <bits/stdc++.h>
using namespace std;
// using lint = long long;
struct P {
int x, y;
bool operator<(const P &a) const {
if (x != a.x)
return x > a.x;
return y > a.y;
}
};
vector<int> v[1], v1;
// bitset<4001000> b;
int i, n, d, m, k, a, b, c, h;
int o[1111][33];
long long l[23][2500511];
int j[1];
int e;
// int dx[10]={2,2,-2,-2,1,1,-1,-1},dy[10]={1,-1,1,-1,2,-2,2,-2};
int dx[10] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[10] = {1, 0, -1, 0, 1, -1, 1, -1},
dz[10] = {0, 0, 0, 0, 1, -1};
long long mod = 1000000007, mod2 = 1000000009, mod3 = 2017;
long long x, z, y;
double pi = 3.14159265;
P u[1];
stack<int> s;
// set<int> s[222][22];
priority_queue<long long, vector<long long>, greater<long long>> q;
// queue<int> q;
// 2147483647
//'1'==49;
//'A'==65;
//'a'==97;
// unordered_
// map<int,int> p;
/*
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count(); return splitmix64(x +
FIXED_RANDOM);
}
};
unordered_map<long long, int, custom_hash> safe_map;
*/
// list<int> l;
// string r,r1;
// char r[2];
// deque<int> de;
// srand((int)time(NULL));
/*bool as(P a,P b)
{
if(a.x!=b.x)
return a.x<b.x;
return a.y<b.y;
}*/
bool as(P a, P b) {
if (a.x != b.x)
return a.x < b.x;
return a.y < b.y;
}
long long f(int n, int m) {
if (n >= a)
return 1;
if (l[n][m] >= 0)
return l[n][m];
long long x = 0;
for (int h = 0, i = 1; h < a; i *= 2, h++)
if (o[n][h] && (m & i) == 0)
x += f(n + 1, m + i), x %= mod;
return l[n][m] = x;
}
int main() {
memset(l, -1, sizeof(l));
scanf("%d", &a);
for (int t = 0; t < a; t++)
for (int w = 0; w < a; w++)
scanf("%d", &o[t][w]);
printf("%lld", f(0, 0));
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 982,663 | 982,664 | u428070871 | cpp |
p03174 | #include <bits/stdc++.h>
using vll = std::vector<long long>;
constexpr long long mod{1000000007};
int n;
bool edge[21][21]{};
std::vector<vll> mf;
long long rc(int, int);
int main() {
scanf("%d", &n);
for (int i{}; i < n; i++)
for (int j{}; j < n; j++) {
int a;
scanf("%d", &a);
edge[i][j] = a == 1;
}
mf.resize(n + 1, vll(1 << n, -1));
mf[n][(1 << n) - 1] = 1;
for (int i{}; i + 1 < 1 << n; i++)
mf[n][i - 1] = 0;
printf("%lld\n", rc(0, 0));
return 0;
}
long long rc(int male, int set) {
long long &combi{mf[male][set]};
if (combi >= 0)
return combi;
combi = 0;
for (int female{}; female < n; female++) {
if (!edge[male][female] || ((1 << female) & set))
continue;
combi += rc(male + 1, set | (1 << female));
combi %= mod;
}
return combi;
} | #include <bits/stdc++.h>
using vll = std::vector<long long>;
constexpr long long mod{1000000007};
int n;
bool edge[21][21]{};
std::vector<vll> mf;
long long rc(int, int);
int main() {
scanf("%d", &n);
for (int i{}; i < n; i++)
for (int j{}; j < n; j++) {
int a;
scanf("%d", &a);
edge[i][j] = a == 1;
}
mf.resize(n + 1, vll(1 << n, -1));
mf[n][(1 << n) - 1] = 1;
for (int i{}; i + 1 < 1 << n; i++)
mf[n][i] = 0;
printf("%lld\n", rc(0, 0));
return 0;
}
long long rc(int male, int set) {
long long &combi{mf[male][set]};
if (combi >= 0)
return combi;
combi = 0;
for (int female{}; female < n; female++) {
if (!edge[male][female] || ((1 << female) & set))
continue;
combi += rc(male + 1, set | (1 << female));
combi %= mod;
}
return combi;
} | [
"expression.operation.binary.remove"
] | 982,689 | 982,690 | u086849314 | cpp |
p03175 | #include <cstring>
#include <iostream>
#include <vector>
#define ll long long int
#define MOD 1000000007
using namespace std;
vector<int> tree[100001];
ll dp[100001][2];
ll independentSets(int u, bool constraint, int pr) {
if (dp[u][constraint] != -1)
return dp[u][constraint]; // Look Up
ll ans = 0;
ll w1 = 0;
for (int child : tree[u]) {
if (child != pr) {
w1 = ((w1 * independentSets(child, 0, u)) % MOD);
}
}
ans = ((ans + w1) % MOD);
if (!constraint) {
ll w2 = 1;
for (int child : tree[u]) {
if (child != pr) {
w2 = ((w2 * independentSets(child, 1, u)) % MOD);
}
}
ans = ((ans + w2) % MOD);
}
return (dp[u][constraint] = ans);
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < (n - 1); i++) {
int u, v;
cin >> u >> v;
tree[u].push_back(v);
tree[v].push_back(u);
}
cout << independentSets(1, 0, -1) << endl;
return 0;
} | #include <cstring>
#include <iostream>
#include <vector>
#define ll long long int
#define MOD 1000000007
using namespace std;
vector<int> tree[100001];
ll dp[100001][2];
ll independentSets(int u, bool constraint, int pr) {
if (dp[u][constraint] != -1)
return dp[u][constraint]; // Look Up
ll ans = 0;
ll w1 = 1;
for (int child : tree[u]) {
if (child != pr) {
w1 = ((w1 * independentSets(child, 0, u)) % MOD);
}
}
ans = ((ans + w1) % MOD);
if (!constraint) {
ll w2 = 1;
for (int child : tree[u]) {
if (child != pr) {
w2 = ((w2 * independentSets(child, 1, u)) % MOD);
}
}
ans = ((ans + w2) % MOD);
}
return (dp[u][constraint] = ans);
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < (n - 1); i++) {
int u, v;
cin >> u >> v;
tree[u].push_back(v);
tree[v].push_back(u);
}
cout << independentSets(1, 0, -1) << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 982,829 | 982,830 | u148301183 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define _GLIBCXX_DEBUG
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vd = vector<double>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vvd = vector<vd>;
using vvvi = vector<vvi>;
using vvvll = vector<vvll>;
using vvvd = vector<vvd>;
const double pi = 3.141592653589793;
const ll MOD = 1e9 + 7;
int n;
ll dp[100010][2]; // 0が黒1が白
int flag[100010][2];
vvi l(100010, vi(0));
ll ddpp(int now, int frm, int col) {
if (flag[now][col]) {
return dp[now][col];
} else {
flag[now][col] = 1;
if (l[now].size() == 1) {
dp[now][col] = 1;
return 1;
} else {
ll ans1 = 1;
for (int x : l[now]) {
if (x == frm) {
continue;
} else {
if (col == 0) {
ans1 *= ddpp(x, now, 1);
ans1 %= MOD;
} else {
ans1 *= ddpp(x, now, 1) + ddpp(x, now, 0);
ans1 %= MOD;
}
}
}
dp[now][col] = ans1;
}
return dp[now][col];
}
}
int main() {
cin >> n;
rep(i, n - 1) {
int a, b;
cin >> a >> b;
l[a].push_back(b);
l[b].push_back(a);
}
ddpp(1, 0, 0);
ll ans1 = dp[1][0];
// cout<<flag[1][0]<<endl;
memset(flag, 0, sizeof(flag));
// cout<<flag[1][0]<<endl;
ddpp(1, 0, 1);
ll ans2 = dp[1][1];
cout << (ans1 + ans2) % MOD << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define _GLIBCXX_DEBUG
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vd = vector<double>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vvd = vector<vd>;
using vvvi = vector<vvi>;
using vvvll = vector<vvll>;
using vvvd = vector<vvd>;
const double pi = 3.141592653589793;
const ll MOD = 1e9 + 7;
int n;
ll dp[100010][2]; // 0が黒1が白
int flag[100010][2];
vvi l(100010, vi(0));
ll ddpp(int now, int frm, int col) {
if (flag[now][col]) {
return dp[now][col];
} else {
flag[now][col] = 1;
if (l[now].size() == 1 && frm != 0) {
dp[now][col] = 1;
return 1;
} else {
ll ans1 = 1;
for (int x : l[now]) {
if (x == frm) {
continue;
} else {
if (col == 0) {
ans1 *= ddpp(x, now, 1);
ans1 %= MOD;
} else {
ans1 *= ddpp(x, now, 1) + ddpp(x, now, 0);
ans1 %= MOD;
}
}
}
dp[now][col] = ans1;
}
return dp[now][col];
}
}
int main() {
cin >> n;
rep(i, n - 1) {
int a, b;
cin >> a >> b;
l[a].push_back(b);
l[b].push_back(a);
}
ddpp(1, 0, 0);
ll ans1 = dp[1][0];
// cout<<flag[1][0]<<endl;
memset(flag, 0, sizeof(flag));
// cout<<flag[1][0]<<endl;
ddpp(1, 0, 1);
ll ans2 = dp[1][1];
cout << (ans1 + ans2) % MOD << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 982,928 | 982,929 | u518042385 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, greater<Q_type>>;
const int MOD_TYPE = 1;
const ll MOD = (MOD_TYPE == 1 ? (ll)(1e9 + 7) : 998244353);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const ld PI = acos(-1.0);
const ld EPS = 1e-11;
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define possible(n) cout << ((n) ? "possible" : "impossible") << endl
#define Yay(n) cout << ((n) ? "Yay!" : ":(") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
};
Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
using mint = Fp<MOD>;
int n;
vector<int> E[100010];
int par[100010];
bool used[100010][2] = {};
mint dp[100010][2];
mint f(int v, int color) {
if (E[v].size() == 1)
return color == 0 ? 2 : 1;
if (used[v][color])
return dp[v][color];
mint white = 1, black = (color == 0);
//白
for (auto c : E[v]) {
if (c == par[v])
continue;
par[c] = v;
white *= f(c, 0);
}
//黒
if (color == 0) {
for (auto c : E[v]) {
if (c == par[v])
continue;
black *= f(c, 1);
}
}
used[v][color] = true;
return dp[v][color] = white + black;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(30) << setiosflags(ios::fixed);
cin >> n;
if (n == 1) {
cout << 2 << endl;
return 0;
}
rep(i, n - 1) {
int x, y;
cin >> x >> y;
x--, y--;
E[x].push_back(y);
E[y].push_back(x);
}
fill(par, par + n, -1);
cout << f(0, 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, greater<Q_type>>;
const int MOD_TYPE = 1;
const ll MOD = (MOD_TYPE == 1 ? (ll)(1e9 + 7) : 998244353);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const ld PI = acos(-1.0);
const ld EPS = 1e-11;
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define possible(n) cout << ((n) ? "possible" : "impossible") << endl
#define Yay(n) cout << ((n) ? "Yay!" : ":(") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
};
Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
using mint = Fp<MOD>;
int n;
vector<int> E[100010];
int par[100010];
bool used[100010][2] = {};
mint dp[100010][2];
mint f(int v, int color) {
if (E[v].size() == 1 && v != 0)
return color == 0 ? 2 : 1;
if (used[v][color])
return dp[v][color];
mint white = 1, black = (color == 0);
//白
for (auto c : E[v]) {
if (c == par[v])
continue;
par[c] = v;
white *= f(c, 0);
}
//黒
if (color == 0) {
for (auto c : E[v]) {
if (c == par[v])
continue;
black *= f(c, 1);
}
}
used[v][color] = true;
return dp[v][color] = white + black;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(30) << setiosflags(ios::fixed);
cin >> n;
if (n == 1) {
cout << 2 << endl;
return 0;
}
rep(i, n - 1) {
int x, y;
cin >> x >> y;
x--, y--;
E[x].push_back(y);
E[y].push_back(x);
}
fill(par, par + n, -1);
cout << f(0, 0) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 982,953 | 982,954 | u878615689 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PI 3.14159265358979323846
const ll MAX = 1e5 + 10;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
vector<ll> a[MAX];
ll dp[MAX][2];
ll visited[MAX];
void dfs(int node) {
visited[node] = 1;
for (int i = 0; i < a[node].size(); i++) {
if (visited[a[node][i]] == 1)
continue;
dfs(a[node][i]);
ll k = a[node][i];
ll w = dp[k][0] + dp[k][1];
ll b = dp[k][0];
dp[node][0] = (dp[node][0] * w) % MOD;
dp[node][1] = (dp[node][1] * b) % MOD;
}
}
int main() {
ll n, i, j, k, l, p, q, x, y;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (i = 0; i < MAX; i++) {
dp[i][0] = 1;
dp[i][1] = 1;
}
dfs(n);
p = dp[1][0] + dp[1][1];
p = p % MOD;
cout << p;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PI 3.14159265358979323846
const ll MAX = 1e5 + 10;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
vector<ll> a[MAX];
ll dp[MAX][2];
ll visited[MAX];
void dfs(int node) {
visited[node] = 1;
for (int i = 0; i < a[node].size(); i++) {
if (visited[a[node][i]] == 1)
continue;
dfs(a[node][i]);
ll k = a[node][i];
ll w = dp[k][0] + dp[k][1];
ll b = dp[k][0];
dp[node][0] = (dp[node][0] * w) % MOD;
dp[node][1] = (dp[node][1] * b) % MOD;
}
}
int main() {
ll n, i, j, k, l, p, q, x, y;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (i = 0; i < MAX; i++) {
dp[i][0] = 1;
dp[i][1] = 1;
}
dfs(1);
p = dp[1][0] + dp[1][1];
p = p % MOD;
cout << p;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 983,139 | 983,140 | u184898414 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define ld long double
#define pb push_back
const ll mod = 1e9 + 7;
template <typename T> T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1)
ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
const ll N = 1e6 + 8;
const ll INF = 1e18;
ll add(ll a, ll b) {
a += b;
if (a >= mod)
return a - mod;
return a;
}
ll mul(ll a, ll b) {
a *= b;
if (a >= mod)
return a % mod;
return a;
}
vector<ll> v[N];
ll dp[N][2];
ll my_name(ll x, ll y, ll p) {
if (dp[x][p] != -1)
return dp[x][p];
ll res = 1;
if (p == 1) {
for (auto it : v[x]) {
if (it == y)
continue;
res = mul(res, my_name(it, x, 0));
}
} else {
ll res1 = 1, res2 = 1;
for (auto it : v[x]) {
if (it == y)
continue;
res1 = mul(res, my_name(it, x, 1));
res2 = mul(res, my_name(it, x, 0));
}
res = add(res1, res2);
}
return dp[x][p] = res;
}
int main() {
IOS;
ll n;
cin >> n;
ll a, b;
for (ll i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].pb(b);
v[b].pb(a);
}
memset(dp, -1, sizeof(dp));
cout << my_name(1, 0, 0);
} | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define ld long double
#define pb push_back
const ll mod = 1e9 + 7;
template <typename T> T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1)
ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
const ll N = 1e6 + 8;
const ll INF = 1e18;
ll add(ll a, ll b) {
a += b;
if (a >= mod)
return a - mod;
return a;
}
ll mul(ll a, ll b) {
a *= b;
if (a >= mod)
return a % mod;
return a;
}
vector<ll> v[N];
ll dp[N][2];
ll my_name(ll x, ll y, ll p) {
if (dp[x][p] != -1)
return dp[x][p];
ll res = 1;
if (p == 1) {
for (auto it : v[x]) {
if (it == y)
continue;
res = mul(res, my_name(it, x, 0));
}
} else {
ll res1 = 1, res2 = 1;
for (auto it : v[x]) {
if (it == y)
continue;
res1 = mul(res1, my_name(it, x, 1));
res2 = mul(res2, my_name(it, x, 0));
}
res = add(res1, res2);
}
return dp[x][p] = res;
}
int main() {
IOS;
ll n;
cin >> n;
ll a, b;
for (ll i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].pb(b);
v[b].pb(a);
}
memset(dp, -1, sizeof(dp));
cout << my_name(1, 0, 0);
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 983,165 | 983,166 | u408028331 | cpp |
p03175 | #include <bits/stdc++.h>
#define ll long long
#define pb emplace_back
using namespace std;
const int MAXN = 1e5 + 10, MD = 1e9 + 7;
int n;
ll dp[MAXN][2];
vector<int> g[MAXN];
void Dfs(int v = 1, int p = -1) {
dp[v][0] = 1;
dp[v][1] = 1;
for (auto i : g[v]) {
if (p == i)
continue;
Dfs(i, v);
dp[v][0] = dp[v][0] * (dp[i][0] + dp[i][1]) % MD;
dp[v][1] = dp[v][1] * dp[i][0] % MD;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
g[a].pb(b);
g[b].pb(a);
}
Dfs();
ll ans = dp[1][0] + dp[1][1];
cout << (ans + MD) % MD << '\n';
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb emplace_back
using namespace std;
const int MAXN = 1e5 + 10, MD = 1e9 + 7;
int n;
ll dp[MAXN][2];
vector<int> g[MAXN];
void Dfs(int v = 1, int p = -1) {
dp[v][0] = 1;
dp[v][1] = 1;
for (auto i : g[v]) {
if (p == i)
continue;
Dfs(i, v);
dp[v][0] = dp[v][0] * (dp[i][0] + dp[i][1]) % MD;
dp[v][1] = dp[v][1] * dp[i][0] % MD;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
g[a].pb(b);
g[b].pb(a);
}
Dfs();
ll ans = dp[1][0] + dp[1][1];
cout << (ans + MD) % MD << '\n';
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 983,194 | 983,195 | u857968161 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
#include <unordered_map>
#define inputarr(a, n) \
for (ll i = 0; i < n; i++) \
cin >> a[i];
#define prllarr(a, n) \
for (ll i = 0; i < n; i++) \
cout << a[i] << " ";
#define pb push_back
#define ll long long
#define mod 1000000007
#define foi \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define in(n) scanf("%lld", &n);
#define in2(x, y) scanf("%lld %lld", &(x), &(y));
#define in3(x, y, z) scanf("%lld %lld %lld", &(x), &(y), &(z));
#define out(n) printf("%lld\n", n);
#define out2(x, y) printf("%lld %lld\n", x, y);
#define test(t) \
ll t; \
in(t); \
while (t--)
#define set(arr, n, s) \
for (ll i = 0; i < n; i++) { \
arr[i] = s; \
}
ll power(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modInverse(ll a, ll p) {
return power(a, p - 2, p);
} // used with feemat little
ll gcd(ll x, ll y) {
if (x == 0 || y == 0) {
return max(y, x);
}
return gcd(y % x, x);
}
ll gcdExtended(ll a, ll b, ll &x, ll &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
} // o(log(b))
;
void prac() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
vector<ll> adj[100004];
pair<ll, ll> dfs(ll cur, ll par) {
if ((adj[cur].size() == 1LL && adj[cur][0] == par) || adj[cur].size() == 0) {
return {1LL, 1LL};
}
ll first = 1LL;
ll second = 1LL;
for (ll son : adj[cur]) {
if (son != par) {
auto f = dfs(son, cur);
first *= (f.first + f.second);
first %= mod;
second *= f.first;
second %= mod;
}
}
return {first, second};
}
int main() {
prac();
ll n;
in(n) for (ll i = 0; i < n - 1; i++) {
ll x, y;
in2(x, y) adj[x].pb(y);
adj[y].pb(x);
}
auto f = dfs(1, 0);
out((f.first + f.second) % mod);
}
/*error-----
convert every int to long long eg-1LL
create array with proper analysis of problem constrain
check mod also
*/
| #include <bits/stdc++.h>
using namespace std;
#include <unordered_map>
#define inputarr(a, n) \
for (ll i = 0; i < n; i++) \
cin >> a[i];
#define prllarr(a, n) \
for (ll i = 0; i < n; i++) \
cout << a[i] << " ";
#define pb push_back
#define ll long long
#define mod 1000000007
#define foi \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define in(n) scanf("%lld", &n);
#define in2(x, y) scanf("%lld %lld", &(x), &(y));
#define in3(x, y, z) scanf("%lld %lld %lld", &(x), &(y), &(z));
#define out(n) printf("%lld\n", n);
#define out2(x, y) printf("%lld %lld\n", x, y);
#define test(t) \
ll t; \
in(t); \
while (t--)
#define set(arr, n, s) \
for (ll i = 0; i < n; i++) { \
arr[i] = s; \
}
ll power(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modInverse(ll a, ll p) {
return power(a, p - 2, p);
} // used with feemat little
ll gcd(ll x, ll y) {
if (x == 0 || y == 0) {
return max(y, x);
}
return gcd(y % x, x);
}
ll gcdExtended(ll a, ll b, ll &x, ll &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
} // o(log(b))
;
void prac() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
vector<ll> adj[100004];
pair<ll, ll> dfs(ll cur, ll par) {
if ((adj[cur].size() == 1LL && adj[cur][0] == par) || adj[cur].size() == 0) {
return {1LL, 1LL};
}
ll first = 1LL;
ll second = 1LL;
for (ll son : adj[cur]) {
if (son != par) {
auto f = dfs(son, cur);
first *= (f.first + f.second);
first %= mod;
second *= f.first;
second %= mod;
}
}
return {first, second};
}
int main() {
// prac();
ll n;
in(n) for (ll i = 0; i < n - 1; i++) {
ll x, y;
in2(x, y) adj[x].pb(y);
adj[y].pb(x);
}
auto f = dfs(1, 0);
out((f.first + f.second) % mod);
}
/*error-----
convert every int to long long eg-1LL
create array with proper analysis of problem constrain
check mod also
*/
| [
"call.remove"
] | 983,211 | 983,212 | u818356308 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
long long DP[100100];
vector<int> G[100100];
const long long Mod = 1000000007;
long long DFS(int X, int L) {
if (DP[X] != -1)
return DP[X];
long long ret1 = 1, ret2 = 1;
for (int i = 0; i < G[X].size(); i++)
if (G[X][i] != L)
ret1 = ret1 * DFS(G[X][i], X) % Mod;
for (int i = 0; i < G[X].size(); i++)
if (G[X][i] != L) {
int x = G[X][i];
for (int i = 0; i < G[x].size(); i++)
if (G[x][i] != X)
ret2 = ret2 * DFS(G[x][i], x) % Mod;
}
return DP[X] = (ret1 + ret2) % Mod;
}
int main() {
int N;
cin >> N;
for (int i = 1; i < N; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
cout << DFS(0, -1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long DP[100100];
vector<int> G[100100];
const long long Mod = 1000000007;
long long DFS(int X, int L) {
if (DP[X])
return DP[X];
long long ret1 = 1, ret2 = 1;
for (int i = 0; i < G[X].size(); i++)
if (G[X][i] != L)
ret1 = ret1 * DFS(G[X][i], X) % Mod;
for (int i = 0; i < G[X].size(); i++)
if (G[X][i] != L) {
int x = G[X][i];
for (int i = 0; i < G[x].size(); i++)
if (G[x][i] != X)
ret2 = ret2 * DFS(G[x][i], x) % Mod;
}
return DP[X] = (ret1 + ret2) % Mod;
}
int main() {
int N;
cin >> N;
for (int i = 1; i < N; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
cout << DFS(0, -1) << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 983,303 | 983,304 | u538921909 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
ll num = pow(10, 9) + 7;
ll n, dp[2][100010];
vector<int> g[100010];
void dfs(int node, int p = 0) {
dp[0][node] = dp[1][node] = 1;
rep(i, g[node].size()) {
if (g[node][i] == p)
continue;
dfs(g[node][i], node);
dp[0][node] = (dp[0][node] * (dp[0][g[node][i]] + dp[1][g[node][i]])) % num;
dp[1][node] = (dp[1][node] * dp[0][g[node][i]]) % num;
}
}
int main() {
int n;
cin >> n;
int x, y;
rep(i, n - 1) {
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
cout << (dp[0][1] + dp[1][1]) % num << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
ll num = pow(10, 9) + 7;
ll n, dp[2][100010];
vector<int> g[100010];
void dfs(int node, int p = -1) {
dp[0][node] = dp[1][node] = 1;
rep(i, g[node].size()) {
if (g[node][i] == p)
continue;
dfs(g[node][i], node);
dp[0][node] = (dp[0][node] * (dp[0][g[node][i]] + dp[1][g[node][i]])) % num;
dp[1][node] = (dp[1][node] * dp[0][g[node][i]]) % num;
}
}
int main() {
int n;
cin >> n;
int x, y;
rep(i, n - 1) {
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
cout << (dp[0][0] + dp[1][0]) % num << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 983,385 | 983,386 | u244832678 | cpp |
p03175 | // KiSmAt
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int mod = 1e9 + 7;
const int N = 2 * 1e5 + 10;
ll res;
ll a[N], dp[N][2];
vector<ll> v[N];
inline ll add(ll x, ll y) { return (x % mod + y % mod) % mod; }
inline ll sub(ll x, ll y) { return (x % mod - y % mod + mod) % mod; }
inline ll mul(ll x, ll y) {
x %= mod;
y %= mod;
return 1LL * x * y % mod;
}
void dfs(ll u, ll par) {
dp[u][0] = dp[u][1] = 1;
for (auto i : v[u]) {
if (i != par) {
dfs(i, par);
dp[u][0] = mul(dp[u][0], dp[i][1]);
dp[u][1] = mul(dp[u][1], add(dp[i][0], dp[i][1]));
}
}
}
void solve() {
ll n, x, y;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 1);
cout << add(dp[1][0], dp[1][1]);
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin >> t;
while (t--) {
solve();
}
}
// nEro | // KiSmAt
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
const ll inf = 1e18;
const int mod = 1e9 + 7;
const int N = 2 * 1e5 + 10;
ll res;
ll a[N], dp[N][2];
vector<ll> v[N];
inline ll add(ll x, ll y) { return (x % mod + y % mod) % mod; }
inline ll sub(ll x, ll y) { return (x % mod - y % mod + mod) % mod; }
inline ll mul(ll x, ll y) {
x %= mod;
y %= mod;
return 1LL * x * y % mod;
}
void dfs(ll u, ll par) {
dp[u][0] = dp[u][1] = 1;
for (auto i : v[u]) {
if (i != par) {
dfs(i, u);
dp[u][0] = mul(dp[u][0], dp[i][1]);
dp[u][1] = mul(dp[u][1], add(dp[i][0], dp[i][1]));
}
}
}
void solve() {
ll n, x, y;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 1);
cout << add(dp[1][0], dp[1][1]);
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin >> t;
while (t--) {
solve();
}
}
// nEro | [
"identifier.change",
"call.arguments.change"
] | 983,509 | 983,510 | u353940238 | cpp |
p03175 | /************************Code by Hardik
* Aggarwal!!!!***********************************/
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define mp make_pair
#define pu push
#define pp pop_back
#define in insert
#define ld long double
#define endl '\n'
#define debug cout << "Hold right there sparky.....\n";
#define forn(low, high, i) for (i = low; i < high; i++)
#define forrev(high, low, i) for (i = high; i >= low; i--)
#define trace(x) cerr << #x << ": " << x << " " << endl;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
const ll mod = 1e9 + 7;
ll dp[100001][2];
vl g[100001];
bool visited[100001];
void dfs(ll u) {
visited[u] = true;
dp[u][0] = dp[u][1] = 1;
for (auto v : g[u]) {
if (!visited[v]) {
dfs(v);
dp[u][0] *= dp[v][0];
dp[u][1] *= (dp[v][1] + dp[v][0]);
dp[u][0] %= mod;
dp[u][1] %= mod;
}
}
}
int main() {
IOS ll n;
cin >> n;
memset(visited, 0, sizeof(visited));
for (ll i = 0; i < n - 1; i++) {
ll u, v;
cin >> u >> v;
u--;
v--;
g[u].pb(v);
g[v].pb(u);
}
dfs(0);
ll ans = dp[0][0] + dp[0][1];
cout << ans << endl;
}
| /************************Code by Hardik
* Aggarwal!!!!***********************************/
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define mp make_pair
#define pu push
#define pp pop_back
#define in insert
#define ld long double
#define endl '\n'
#define debug cout << "Hold right there sparky.....\n";
#define forn(low, high, i) for (i = low; i < high; i++)
#define forrev(high, low, i) for (i = high; i >= low; i--)
#define trace(x) cerr << #x << ": " << x << " " << endl;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
const ll mod = 1e9 + 7;
ll dp[100001][2];
vl g[100001];
bool visited[100001];
void dfs(ll u) {
visited[u] = true;
dp[u][0] = dp[u][1] = 1;
for (auto v : g[u]) {
if (!visited[v]) {
dfs(v);
dp[u][0] *= dp[v][1];
dp[u][1] *= (dp[v][1] + dp[v][0]);
dp[u][0] %= mod;
dp[u][1] %= mod;
}
}
}
int main() {
IOS ll n;
cin >> n;
memset(visited, 0, sizeof(visited));
for (ll i = 0; i < n - 1; i++) {
ll u, v;
cin >> u >> v;
u--;
v--;
g[u].pb(v);
g[v].pb(u);
}
dfs(0);
ll ans = (dp[0][0] + dp[0][1]) % mod;
cout << ans << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 983,536 | 983,535 | u859541564 | cpp |
p03175 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define DIM (long long)1000007
#define INF (long long)100000007
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pairll;
ll n, m, i, j, sum, f1, f2, v1, v2, k, x, y, l, nn, z, kek;
vector<ll> a[DIM];
ll mod = (ll)1e9 + 7;
ll b[DIM];
ll w[DIM];
void dfs(ll v, ll par) {
if (a[v].size() == 1 && a[v][0] == par) {
b[v] = 1;
w[v] = 1;
return;
}
ll kek = 1;
ll lol = 1;
for (auto to : a[v]) {
if (to != par)
dfs(to, v);
if (kek == 0)
kek = 1;
kek *= w[to];
if (kek >= mod)
kek %= mod;
if (lol == 0)
lol = 1;
lol *= (w[to] + b[to]);
if (lol >= mod)
lol %= mod;
}
b[v] = kek;
w[v] = lol;
// cout << b[v] << " " << w[v] << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i < n; i++) {
cin >> v1 >> v2;
a[v1].push_back(v2);
a[v2].push_back(v1);
}
dfs(1, -1);
cout << (b[1] + w[1]) % mod << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define DIM (long long)1000007
#define INF (long long)100000007
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pairll;
ll n, m, i, j, sum, f1, f2, v1, v2, k, x, y, l, nn, z, kek;
vector<ll> a[DIM];
ll mod = (ll)1e9 + 7;
ll b[DIM];
ll w[DIM];
void dfs(ll v, ll par) {
if (a[v].size() == 1 && a[v][0] == par) {
b[v] = 1;
w[v] = 1;
return;
}
ll kek = 1;
ll lol = 1;
for (auto to : a[v]) {
if (to != par)
dfs(to, v);
else
continue;
if (kek == 0)
kek = 1;
kek *= w[to];
if (kek >= mod)
kek %= mod;
if (lol == 0)
lol = 1;
lol *= (w[to] + b[to]);
if (lol >= mod)
lol %= mod;
}
b[v] = kek;
w[v] = lol;
// cout << b[v] << " " << w[v] << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i < n; i++) {
cin >> v1 >> v2;
a[v1].push_back(v2);
a[v2].push_back(v1);
}
dfs(1, -1);
cout << (b[1] + w[1]) % mod << endl;
return 0;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 983,584 | 983,585 | u576645478 | cpp |
p03175 | #include <bits/stdc++.h>
#define rb(a, b, c) for (int a = b; a <= c; a++)
#define rl(a, b, c) for (int a = b; a >= c; a--)
#define niv vector<int>
#define LL long long
#define IT iterator
#define PB(a) push_back(a)
#define II(a, b) make_pair(a, b)
#define FIR first
#define SEC second
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
const int MOD = 1e9 + 7;
typedef pair<int, int> mp;
typedef pair<mp, mp> superpair;
LL dp[MAXN][2];
struct node {
vector<int> son;
// vector<int> grand;
} each_node[MAXN];
int v[MAXN];
LL res(int flag, int now) {
if (dp[flag][now])
return dp[flag][now];
LL tmpres = 1;
if (v[now])
return 0;
v[now] = true;
int sz1 = each_node[now].son.size();
rb(i, 0, sz1 - 1) {
if (v[each_node[now].son[i]])
continue;
LL chenshu = res(0, each_node[now].son[i]);
if (flag != 1) {
chenshu += res(1, each_node[now].son[i]);
}
if (chenshu)
tmpres *= chenshu;
tmpres %= MOD;
if (tmpres == 0)
tmpres += MOD;
}
v[now] = false;
dp[flag][now] = tmpres;
return tmpres;
}
int main() {
ios::sync_with_stdio(false);
int n; // n<=1e5
cin >> n;
rb(i, 1, n - 1) {
int xi, yi;
cin >> xi >> yi;
each_node[xi].son.PB(yi);
each_node[yi].son.PB(xi);
}
cout << (res(1, 1) + res(0, 1)) % MOD;
return 0;
} | #include <bits/stdc++.h>
#define rb(a, b, c) for (int a = b; a <= c; a++)
#define rl(a, b, c) for (int a = b; a >= c; a--)
#define niv vector<int>
#define LL long long
#define IT iterator
#define PB(a) push_back(a)
#define II(a, b) make_pair(a, b)
#define FIR first
#define SEC second
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
const int MOD = 1e9 + 7;
typedef pair<int, int> mp;
typedef pair<mp, mp> superpair;
LL dp[MAXN][2];
struct node {
vector<int> son;
// vector<int> grand;
} each_node[MAXN];
int v[MAXN];
LL res(int flag, int now) {
if (dp[now][flag])
return dp[now][flag];
LL tmpres = 1;
if (v[now])
return 0;
v[now] = true;
int sz1 = each_node[now].son.size();
rb(i, 0, sz1 - 1) {
if (v[each_node[now].son[i]])
continue;
LL chenshu = res(0, each_node[now].son[i]);
if (flag != 1) {
chenshu += res(1, each_node[now].son[i]);
}
if (chenshu)
tmpres *= chenshu;
tmpres %= MOD;
if (tmpres == 0)
tmpres += MOD;
}
v[now] = false;
dp[now][flag] = tmpres;
return tmpres;
}
int main() {
ios::sync_with_stdio(false);
int n; // n<=1e5
cin >> n;
rb(i, 1, n - 1) {
int xi, yi;
cin >> xi >> yi;
each_node[xi].son.PB(yi);
each_node[yi].son.PB(xi);
}
cout << (res(1, 1) + res(0, 1)) % MOD;
return 0;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"function.return_value.change",
"assignment.variable.change"
] | 983,590 | 983,591 | u751730221 | cpp |
p03175 | #include <bits/stdc++.h>
#define N_MAX 100002
#define ll long long
using namespace std;
const ll MOD = 1e9 + 7;
int n;
vector<int> edges[N_MAX];
ll dp[N_MAX][2];
bool visited[N_MAX];
void dfs(int node) {
visited[node] = true;
dp[node][0] = dp[node][1] = 1;
for (int u : edges[node])
if (visited[u] == false) {
dfs(u);
dp[node][0] = dp[node][0] * (dp[u][1] + dp[u][0]) % MOD;
dp[node][1] = dp[node][1] * dp[u][0] % MOD;
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(i);
}
dfs(1);
cout << (dp[1][0] + dp[1][1]) % MOD;
return 0;
}
| #include <bits/stdc++.h>
#define N_MAX 100002
#define ll long long
using namespace std;
const ll MOD = 1e9 + 7;
int n;
vector<int> edges[N_MAX];
ll dp[N_MAX][2];
bool visited[N_MAX];
void dfs(int node) {
visited[node] = true;
dp[node][0] = dp[node][1] = 1;
for (int u : edges[node])
if (visited[u] == false) {
dfs(u);
dp[node][0] = dp[node][0] * (dp[u][1] + dp[u][0]) % MOD;
dp[node][1] = dp[node][1] * dp[u][0] % MOD;
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
dfs(1);
cout << (dp[1][0] + dp[1][1]) % MOD;
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 983,605 | 983,606 | u138301572 | cpp |
p03175 | #include <bits/stdc++.h>
#define N_MAX 100002
#define ll long long
using namespace std;
const ll MOD = 1e9 + 1;
int n;
vector<int> edges[N_MAX];
ll dp[N_MAX][2];
bool visited[N_MAX];
void dfs(int node) {
visited[node] = true;
dp[node][0] = dp[node][1] = 1;
for (int u : edges[node])
if (visited[u] == false) {
dfs(u);
dp[node][0] = dp[node][0] * (dp[u][1] + dp[u][0]) % MOD;
dp[node][1] = dp[node][1] * dp[u][0] % MOD;
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(i);
}
dfs(1);
cout << (dp[1][0] + dp[1][1]) % MOD;
return 0;
}
| #include <bits/stdc++.h>
#define N_MAX 100002
#define ll long long
using namespace std;
const ll MOD = 1e9 + 7;
int n;
vector<int> edges[N_MAX];
ll dp[N_MAX][2];
bool visited[N_MAX];
void dfs(int node) {
visited[node] = true;
dp[node][0] = dp[node][1] = 1;
for (int u : edges[node])
if (visited[u] == false) {
dfs(u);
dp[node][0] = dp[node][0] * (dp[u][1] + dp[u][0]) % MOD;
dp[node][1] = dp[node][1] * dp[u][0] % MOD;
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
dfs(1);
cout << (dp[1][0] + dp[1][1]) % MOD;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"identifier.change",
"call.arguments.change"
] | 983,607 | 983,606 | u138301572 | cpp |
p03175 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
vector<ll> adj[100005];
ll visited[100005];
pair<ll, ll> dfs(ll pa) {
visited[pa] = 1;
ll i, w, b;
w = 1;
b = 1;
for (i = 0; i < adj[pa].size(); i++) {
if (!visited[adj[pa][i]]) {
pair<ll, ll> p = dfs(adj[pa][i]);
w = (w * ((p.first + p.second) % 1000000007)) % 1000000007;
b = (b * p.first) % 1000000007;
}
}
return make_pair(w, b);
}
int main() {
ll n, i, x, y;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
// 0 white & 1 black
pair<ll, ll> p = dfs(1);
cout << (p.first + p.second) % 1000000007 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
vector<ll> adj[100005];
ll visited[100005];
pair<ll, ll> dfs(ll pa) {
visited[pa] = 1;
ll i, w, b;
w = 1;
b = 1;
for (i = 0; i < adj[pa].size(); i++) {
if (!visited[adj[pa][i]]) {
pair<ll, ll> p = dfs(adj[pa][i]);
w = (w * ((p.first + p.second) % 1000000007)) % 1000000007;
b = (b * p.first) % 1000000007;
}
}
return make_pair(w, b);
}
int main() {
ll n, i, x, y;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
pair<ll, ll> p = dfs(1);
cout << (p.first + p.second) % 1000000007 << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 983,667 | 983,668 | u388528458 | cpp |
p03175 | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007, dp[100010][2] = {};
vector<int> G[100010];
void dfs(int s, int p) {
ll x = 1, y = 1;
for (int v : G[s]) {
if (v != p) {
dfs(v, s);
(x *= dp[v][0]) %= mod;
(y *= (dp[v][0] + dp[v][1]) % mod) %= mod;
}
dp[s][0] = y;
dp[s][1] = x;
}
}
int main() {
int i, n;
cin >> n;
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, -1);
cout << (dp[0][0] + dp[0][1]) % mod << endl;
} | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007, dp[100010][2] = {};
vector<int> G[100010];
void dfs(int s, int p) {
ll x = 1, y = 1;
for (int v : G[s]) {
if (v != p) {
dfs(v, s);
(x *= dp[v][0]) %= mod;
(y *= (dp[v][0] + dp[v][1]) % mod) %= mod;
}
}
dp[s][0] = y;
dp[s][1] = x;
}
int main() {
int i, n;
cin >> n;
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, -1);
cout << (dp[0][0] + dp[0][1]) % mod << endl;
} | [] | 983,690 | 983,691 | u621509943 | cpp |
p03175 | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007, dp[100010][2] = {};
vector<int> G[100010];
void dfs(int s, int p) {
ll x = 1, y = 1;
for (int v : G[s]) {
if (v != p) {
dfs(v, s);
(x *= dp[v][0]) %= mod;
(y *= dp[v][0] + dp[v][1]) %= mod;
}
dp[s][0] = y;
dp[s][1] = x;
}
}
int main() {
int i, n;
cin >> n;
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, -1);
cout << (dp[0][0] + dp[0][1]) % mod << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007, dp[100010][2] = {};
vector<int> G[100010];
void dfs(int s, int p) {
ll x = 1, y = 1;
for (int v : G[s]) {
if (v != p) {
dfs(v, s);
(x *= dp[v][0]) %= mod;
(y *= (dp[v][0] + dp[v][1]) % mod) %= mod;
}
}
dp[s][0] = y;
dp[s][1] = x;
}
int main() {
int i, n;
cin >> n;
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, -1);
cout << (dp[0][0] + dp[0][1]) % mod << endl;
} | [] | 983,692 | 983,691 | u621509943 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
struct flower {
long long int hi, bty;
};
long long int solve(vector<flower> &v, long long int n) {
vector<long long int> dp(n + 1);
dp[1] = v[1].bty;
map<long long int, long long int> meaningfull;
meaningfull[v[1].hi] = v[1].bty;
long long int ans = dp[0];
for (int i = 2; i <= n; i++) {
dp[i] = v[i].bty;
auto it = meaningfull.lower_bound(v[i].hi);
if (it != meaningfull.begin()) {
it--;
dp[i] += it->second;
}
meaningfull[v[i].hi] = dp[i];
it = meaningfull.upper_bound(v[i].hi);
while (it != meaningfull.end() && it->second <= dp[i]) {
auto temp = it;
temp++;
meaningfull.erase(it);
it = temp;
}
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
long long int n;
cin >> n;
vector<flower> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i].hi;
}
for (int i = 1; i <= n; i++) {
cin >> v[i].bty;
}
long long int ans = solve(v, n);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct flower {
long long int hi, bty;
};
long long int solve(vector<flower> &v, long long int n) {
vector<long long int> dp(n + 1);
dp[1] = v[1].bty;
map<long long int, long long int> meaningfull;
meaningfull[v[1].hi] = v[1].bty;
long long int ans = dp[1];
for (int i = 2; i <= n; i++) {
dp[i] = v[i].bty;
auto it = meaningfull.lower_bound(v[i].hi);
if (it != meaningfull.begin()) {
it--;
dp[i] += it->second;
}
meaningfull[v[i].hi] = dp[i];
it = meaningfull.upper_bound(v[i].hi);
while (it != meaningfull.end() && it->second <= dp[i]) {
auto temp = it;
temp++;
meaningfull.erase(it);
it = temp;
}
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
long long int n;
cin >> n;
vector<flower> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i].hi;
}
for (int i = 1; i <= n; i++) {
cin >> v[i].bty;
}
long long int ans = solve(v, n);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change"
] | 983,742 | 983,743 | u003189384 | cpp |
p03176 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define size 200010
ll dp[4 * size];
ll query(int s, int e, int qs, int qe, int idx) {
if (qs > e || qe < s)
return 0;
if (qs <= s && qe >= e)
return dp[idx];
int mid = (s + e) / 2;
ll a = query(s, mid, qs, qe, 2 * idx);
ll b = query(mid + 1, e, qs, qe, 2 * idx + 1);
return max(a, b);
}
void update(int s, int e, int value, int height, int idx) {
if (s > height || e < height)
return;
if (s == e) {
dp[idx] = value;
// cout<<dp[idx]<<" "<<idx<<" ";
return;
}
int mid = (s + e) / 2;
update(s, mid, value, height, 2 * idx);
update(mid + 1, e, value, height, 2 * idx + 1);
dp[idx] = max(dp[2 * idx], dp[2 * idx + 1]);
// return ;
}
int main() {
int n;
cin >> n;
int i;
vector<int> height(n, 0), beauty(n, 0);
for (i = 0; i < n; i++)
cin >> height[i];
for (i = 0; i < n; i++)
cin >> beauty[i];
memset(dp, 0, sizeof(dp));
ll x = INT_MIN, a;
for (i = 0; i < n; i++) {
a = query(0, n, 0, height[i] - 1, 1);
// x = max(x,a+beauty[i]);
// cout<<a<<endl;
update(0, n, beauty[i] + a, height[i], 1);
}
// for(i=1;i<4*n;i++)
// cout<<dp[i]<<" ";
cout << dp[1] << endl;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define size 200010
ll dp[4 * size];
ll query(int s, int e, int qs, int qe, int idx) {
if (qs > e || qe < s)
return 0;
if (qs <= s && qe >= e)
return dp[idx];
int mid = (s + e) / 2;
ll a = query(s, mid, qs, qe, 2 * idx);
ll b = query(mid + 1, e, qs, qe, 2 * idx + 1);
return max(a, b);
}
void update(int s, int e, ll value, int height, int idx) {
if (s > height || e < height)
return;
if (s == e) {
dp[idx] = value;
// cout<<dp[idx]<<" "<<idx<<" ";
return;
}
int mid = (s + e) / 2;
update(s, mid, value, height, 2 * idx);
update(mid + 1, e, value, height, 2 * idx + 1);
dp[idx] = max(dp[2 * idx], dp[2 * idx + 1]);
// return ;
}
int main() {
int n;
cin >> n;
int i;
vector<int> height(n, 0), beauty(n, 0);
for (i = 0; i < n; i++)
cin >> height[i];
for (i = 0; i < n; i++)
cin >> beauty[i];
memset(dp, 0, sizeof(dp));
ll x = INT_MIN, a = 0;
for (i = 0; i < n; i++) {
a = query(0, n, 0, height[i] - 1, 1);
// x = max(x,a+beauty[i]);
// cout<<a<<endl;
update(0, n, beauty[i] + a, height[i], 1);
}
// for(i=1;i<4*n;i++)
// cout<<dp[i]<<" ";
cout << dp[1] << endl;
} | [
"variable_declaration.value.change"
] | 983,762 | 983,763 | u411269021 | cpp |
p03176 | #include <bits/stdc++.h>
//#define int long long
//#pragma GCC optimize("Ofast")
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#define file(s) \
freopen(s ".in", "r", stdin); \
freopen(s ".out", "w", stdout);
#define forev(i, b, a) for (int i = (b); i >= (a); --i)
#define forn(i, a, b) for (int i = (a); i <= (b); ++i)
#define all(x) x.begin(), x.end()
#define sz(s) (int)s.size()
#define pb push_back
#define ppb pop_back
#define s second
#define f first
using namespace std;
typedef pair<long long, long long> pll;
typedef pair<int, int> pii;
typedef unsigned long long ull;
typedef vector<pii> vpii;
typedef vector<int> vi;
typedef long double ldb;
typedef long long ll;
typedef double db;
const int inf = 1e9, maxn = 4e5 + 148, mod = 1e9 + 7, N = 2e5 + 11;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}, block = 555;
const pii base = {1171, 3307}, Mod = {1e9 + 7, 1e9 + 9};
const db eps = 1e-12, pi = 3.14159265359;
const ll INF = 1e18;
int n, h[N], a[N], dp[N], t[N];
void inc(int pos, int x) {
while (pos < N) {
t[pos] = max(t[pos], x);
pos |= pos + 1;
}
}
int get(int r) {
int res = 0;
while (r >= 0) {
res = max(res, t[r]);
r = (r & (r + 1)) - 1;
}
return res;
}
main() {
cin >> n;
forn(i, 1, n) cin >> h[i];
forn(i, 1, n) cin >> a[i];
forn(i, 1, n) {
dp[i] = get(h[i]) + a[i];
inc(h[i], dp[i]);
}
cout << *max_element(dp + 1, dp + 1 + n);
}
| #include <bits/stdc++.h>
#define int long long
//#pragma GCC optimize("Ofast")
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#define file(s) \
freopen(s ".in", "r", stdin); \
freopen(s ".out", "w", stdout);
#define forev(i, b, a) for (int i = (b); i >= (a); --i)
#define forn(i, a, b) for (int i = (a); i <= (b); ++i)
#define all(x) x.begin(), x.end()
#define sz(s) (int)s.size()
#define pb push_back
#define ppb pop_back
#define s second
#define f first
using namespace std;
typedef pair<long long, long long> pll;
typedef pair<int, int> pii;
typedef unsigned long long ull;
typedef vector<pii> vpii;
typedef vector<int> vi;
typedef long double ldb;
typedef long long ll;
typedef double db;
const int inf = 1e9, maxn = 4e5 + 148, mod = 1e9 + 7, N = 2e5 + 11;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}, block = 555;
const pii base = {1171, 3307}, Mod = {1e9 + 7, 1e9 + 9};
const db eps = 1e-12, pi = 3.14159265359;
const ll INF = 1e18;
int n, h[N], a[N], dp[N], t[N];
void inc(int pos, int x) {
while (pos < N) {
t[pos] = max(t[pos], x);
pos |= pos + 1;
}
}
int get(int r) {
int res = 0;
while (r >= 0) {
res = max(res, t[r]);
r = (r & (r + 1)) - 1;
}
return res;
}
main() {
cin >> n;
forn(i, 1, n) cin >> h[i];
forn(i, 1, n) cin >> a[i];
forn(i, 1, n) {
dp[i] = get(h[i]) + a[i];
inc(h[i], dp[i]);
}
cout << *max_element(dp + 1, dp + 1 + n);
}
| [] | 983,764 | 983,765 | u089230684 | cpp |
p03176 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <utility>
#include <vector>
using namespace std;
int N;
vector<int> h;
vector<int> a;
vector<size_t> dp;
void update_max(int i, size_t val) {
for (; i < N; i = (i | (i + 1)))
dp[i] = max(dp[i], val);
}
size_t get_max(int r) {
size_t res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1)
res = max(res, dp[r]);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
h.resize(N);
a.resize(N);
dp = vector<size_t>(N, 0);
for (int i = 0; i < N; ++i) {
cin >> h[i];
}
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
size_t res = 0;
for (int i = 0; i < N; ++i) {
size_t cur_max = get_max(h[i]);
update_max(h[i], a[i] + cur_max);
res = max(res, a[i] + cur_max);
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <utility>
#include <vector>
using namespace std;
int N;
vector<int> h;
vector<int> a;
vector<size_t> dp;
void update_max(int i, size_t val) {
for (; i < N; i = (i | (i + 1)))
dp[i] = max(dp[i], val);
}
size_t get_max(int r) {
size_t res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1)
res = max(res, dp[r]);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
h.resize(N);
a.resize(N);
dp = vector<size_t>(N + 1, 0);
for (int i = 0; i < N; ++i) {
cin >> h[i];
}
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
size_t res = 0;
for (int i = 0; i < N; ++i) {
size_t cur_max = get_max(h[i] - 1);
update_max(h[i], a[i] + cur_max);
res = max(res, a[i] + cur_max);
}
cout << res << endl;
return 0;
} | [
"assignment.change"
] | 983,768 | 983,769 | u395287489 | cpp |
p03176 | #pragma comment(linker, "/stack:16777216")
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
//#include"functions.h"
//#include"highprecision.h"
#define pb push_back
#define pf push_front
#define ppb pop_back
#define mp make_pair
#define np next_permutation
#define fi first
#define sc second
#define vi vector<int>
#define vll vector<long long>
#define vvi vector<vector<int>>
#define vpi vector<pair<int, int>>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pff pair<float, float>
#define pdd pair<double, double>
#define psi pair<string, int>
#define pis pair<int, string>
#define ppi pair<pii, int>
#define pdi pair<pii, pii>
#define LN 84757
#define INF 1e9
#define LLINF 1e18
#define MAXINT 0x7fffffff
#define MAXLL 0x7fffffffffffffff
#define EPS 1e-5
#define DEPS 1e-9
#define LDEPS 1e-13
#define MOD 1000000007
#define E 2.7182818284
#define PI 3.1415926535
#define rep(a, b) for (int a = 0; a < b; a++)
#define rep(a, b) for (int a = 0; a < b; a++)
#define forn(a, n) for (int a = 1; a <= n; a++)
#define forr(a, n) for (int a = n; a >= 1; a--)
#define repn(a, n, p) for (int a = 0; a < n; a += p)
#define repr(a, n) for (int a = n - 1; a >= 0; a--)
#define foreach(a, b) for (__typeof(b.begin()) a = b.begin(); a != b.end(); a++)
#define fillemp(a) memset(a, 0, sizeof(a))
#define fillinf(a) memset(a, 0x3f, sizeof(a))
#define frestream \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define stdf(a, b) \
freopen(a, "r", stdin); \
freopen(b, "w", stdout);
#define inputf(a) freopen(a, "r", stdin);
#define outputf(a) freopen(a, "w", stdout);
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
using namespace std;
int n;
ll a[200010], h[200010], dp[200010], bit[200010];
inline int lowbit(int x) { return x & (-x); }
void upd(int x, ll d) {
while (x <= n) {
bit[x] = max(bit[x], d);
x += lowbit(x);
}
}
ll getmax(int x) {
ll ans = 0;
while (x > 0) {
ans = max(ans, bit[x]);
x -= lowbit(x);
}
return ans;
}
int main(int argc, char **argv) {
cin >> n;
forn(i, n) { cin >> h[i]; }
forn(i, n) { cin >> a[i]; }
forn(i, n) {
dp[i] = getmax(h[i] - 1) + a[i];
upd(h[i], dp[i]);
}
cout << dp[n] << endl;
return 0;
} | #pragma comment(linker, "/stack:16777216")
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
//#include"functions.h"
//#include"highprecision.h"
#define pb push_back
#define pf push_front
#define ppb pop_back
#define mp make_pair
#define np next_permutation
#define fi first
#define sc second
#define vi vector<int>
#define vll vector<long long>
#define vvi vector<vector<int>>
#define vpi vector<pair<int, int>>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pff pair<float, float>
#define pdd pair<double, double>
#define psi pair<string, int>
#define pis pair<int, string>
#define ppi pair<pii, int>
#define pdi pair<pii, pii>
#define LN 84757
#define INF 1e9
#define LLINF 1e18
#define MAXINT 0x7fffffff
#define MAXLL 0x7fffffffffffffff
#define EPS 1e-5
#define DEPS 1e-9
#define LDEPS 1e-13
#define MOD 1000000007
#define E 2.7182818284
#define PI 3.1415926535
#define rep(a, b) for (int a = 0; a < b; a++)
#define rep(a, b) for (int a = 0; a < b; a++)
#define forn(a, n) for (int a = 1; a <= n; a++)
#define forr(a, n) for (int a = n; a >= 1; a--)
#define repn(a, n, p) for (int a = 0; a < n; a += p)
#define repr(a, n) for (int a = n - 1; a >= 0; a--)
#define foreach(a, b) for (__typeof(b.begin()) a = b.begin(); a != b.end(); a++)
#define fillemp(a) memset(a, 0, sizeof(a))
#define fillinf(a) memset(a, 0x3f, sizeof(a))
#define frestream \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define stdf(a, b) \
freopen(a, "r", stdin); \
freopen(b, "w", stdout);
#define inputf(a) freopen(a, "r", stdin);
#define outputf(a) freopen(a, "w", stdout);
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
using namespace std;
int n;
ll a[200010], h[200010], dp[200010], bit[200010];
inline int lowbit(int x) { return x & (-x); }
void upd(int x, ll d) {
while (x <= n) {
bit[x] = max(bit[x], d);
x += lowbit(x);
}
}
ll getmax(int x) {
ll ans = 0;
while (x > 0) {
ans = max(ans, bit[x]);
x -= lowbit(x);
}
return ans;
}
int main(int argc, char **argv) {
cin >> n;
forn(i, n) { cin >> h[i]; }
forn(i, n) { cin >> a[i]; }
forn(i, n) {
dp[i] = getmax(h[i] - 1) + a[i];
upd(h[i], dp[i]);
}
cout << getmax(n) << endl;
return 0;
} | [
"io.output.change"
] | 983,770 | 983,771 | u963646695 | cpp |
p03176 | #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<ll, null_type, less_equal<ll>, rb_tree_tag, \
tree_order_statistics_node_update>
#define PI 3.14159265
#define ll long long
#define ld long double
#define vi vector<int>
#define pb push_back
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 300000000000000001
#define infx 9223372036854775806
#define all(c) c.begin(), c.end()
#define mk(x, yy) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define ff first
#define ss second
#define re return
// #define endl "\n"
#define max2(x, y) (x > y) ? x : y
#define min2(x, y) (x < y) ? x : y
#define mid(s, e) (s + (e - s) / 2)
#define mini INT_MIN
#define maxo INT_MAX
#define rep(i, a, b) for (int i = a; i < (int)(b); ++i)
#define read(a, n) \
for (int i = 0; i < n; i++) \
cin >> a[i]
#define show(a, n) \
for (int i = 0; i < n; i++) \
cout << a[i] << ' '; \
cout << endl
#define ene cout << "\n";
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll power(ll x, ll y, ll p) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
bool compr(std::vector<ll> a, std::vector<ll> b) {
if (a[0] == b[0])
return a[1] < b[1];
else
return a[0] < b[0];
}
bool comp(std::vector<ll> a, std::vector<ll> b) {
if (a[1] == b[1] && a[2] == b[2])
return a[0] < b[0];
else if (a[1] == b[1])
return a[2] > b[2];
else
return a[1] < b[1];
}
ll bit[400005];
void update(ll x, ll val, ll n) {
for (; x <= n; x += x & -x)
bit[x] = max(bit[x], val);
}
ll query(ll x, ll n) {
ll tmp = 0;
for (; x > 0; x -= x & -x)
tmp = max(tmp, bit[x]);
return tmp;
}
int main() {
#ifdef SHIVANSH
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll h[n];
ll a[n];
for (ll i = 0; i < n; i++)
cin >> h[i];
for (ll i = 0; i < n; i++)
cin >> a[i];
for (ll i = 1; i <= n; i++) {
update(i, 0, n);
}
ll ans = 0;
for (ll i = 0; i < n; i++) {
ll lmx = query(h[i], n);
lmx = a[i] + lmx;
ans = max(lmx, ans);
update(h[i], a[i], n);
}
cout << ans << endl;
;
} | #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<ll, null_type, less_equal<ll>, rb_tree_tag, \
tree_order_statistics_node_update>
#define PI 3.14159265
#define ll long long
#define ld long double
#define vi vector<int>
#define pb push_back
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 300000000000000001
#define infx 9223372036854775806
#define all(c) c.begin(), c.end()
#define mk(x, yy) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define ff first
#define ss second
#define re return
// #define endl "\n"
#define max2(x, y) (x > y) ? x : y
#define min2(x, y) (x < y) ? x : y
#define mid(s, e) (s + (e - s) / 2)
#define mini INT_MIN
#define maxo INT_MAX
#define rep(i, a, b) for (int i = a; i < (int)(b); ++i)
#define read(a, n) \
for (int i = 0; i < n; i++) \
cin >> a[i]
#define show(a, n) \
for (int i = 0; i < n; i++) \
cout << a[i] << ' '; \
cout << endl
#define ene cout << "\n";
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll power(ll x, ll y, ll p) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
bool compr(std::vector<ll> a, std::vector<ll> b) {
if (a[0] == b[0])
return a[1] < b[1];
else
return a[0] < b[0];
}
bool comp(std::vector<ll> a, std::vector<ll> b) {
if (a[1] == b[1] && a[2] == b[2])
return a[0] < b[0];
else if (a[1] == b[1])
return a[2] > b[2];
else
return a[1] < b[1];
}
ll bit[400005];
void update(ll x, ll val, ll n) {
for (; x <= n; x += x & -x)
bit[x] = max(bit[x], val);
}
ll query(ll x, ll n) {
ll tmp = 0;
for (; x > 0; x -= x & -x)
tmp = max(tmp, bit[x]);
return tmp;
}
int main() {
#ifdef SHIVANSH
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll h[n];
ll a[n];
for (ll i = 0; i < n; i++)
cin >> h[i];
for (ll i = 0; i < n; i++)
cin >> a[i];
for (ll i = 1; i <= n; i++) {
update(i, 0, n);
}
ll ans = 0;
for (ll i = 0; i < n; i++) {
ll lmx = query(h[i], n);
lmx = a[i] + lmx;
ans = max(lmx, ans);
update(h[i], lmx, n);
}
cout << ans << endl;
;
} | [
"call.arguments.change"
] | 983,779 | 983,780 | u206663422 | cpp |
p03176 | // #pragma GCC optimize "trapv"
#include <bits/stdc++.h>
using namespace std;
#define vi vector<int>
#define vll vector<ll>
#define vpll vector<pair<ll, ll>>
#define vvi vector<vector<int>>
#define vvll vector<vector<ll>>
#define MAP map<ll, ll>
#define UMAP unordered_map<ll, ll>
#define endl "\n"
#define SET set<ll>
#define SETC set<char>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0);
#define fastcout \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define testcases \
int tt = 1; \
cin >> tt; \
for (int i = 1; i <= tt; ++i)
#define codejam cout << "Case #" << i << ": ";
#define FOR(i, a, n) for (int i = a; i <= n; ++i)
#define FORback(i, a, n) for (int i = n; i >= a; --i)
#define time \
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC \
<< "ms\n";
#define ll long long int
const ll INF = 1e13 + 7;
const ll mod = 1e9 + 7;
void solv() {
ll n;
cin >> n;
vll a(n), b(n);
FOR(i, 0, n - 1)
cin >> a[i];
FOR(i, 0, n - 1)
cin >> b[i];
vll dp(n + 1);
dp[1] = b[0];
map<ll, ll> mp;
mp[a[0]] = dp[1];
// 3 1 4 2
ll ans = 0;
FOR(i, 2, n) {
dp[i] = b[i - 1];
auto it = mp.lower_bound(a[i - 1] + 1);
if (it != mp.begin()) {
it--;
dp[i] += it->second;
}
mp[a[i - 1]] = dp[i];
auto it2 = mp.upper_bound(a[i - 1]);
while (it2 != mp.end() and it2->second <= dp[i]) {
auto temp = it2;
++temp;
mp.erase(it2);
it2 = temp;
}
ans = max(ans, dp[i]);
}
// return ans;
cout << ans << endl;
}
int main() {
fast;
// testcases{
// codejam ;
solv();
// }
}
| // #pragma GCC optimize "trapv"
#include <bits/stdc++.h>
using namespace std;
#define vi vector<int>
#define vll vector<ll>
#define vpll vector<pair<ll, ll>>
#define vvi vector<vector<int>>
#define vvll vector<vector<ll>>
#define MAP map<ll, ll>
#define UMAP unordered_map<ll, ll>
#define endl "\n"
#define SET set<ll>
#define SETC set<char>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0);
#define fastcout \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define testcases \
int tt = 1; \
cin >> tt; \
for (int i = 1; i <= tt; ++i)
#define codejam cout << "Case #" << i << ": ";
#define FOR(i, a, n) for (int i = a; i <= n; ++i)
#define FORback(i, a, n) for (int i = n; i >= a; --i)
#define time \
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC \
<< "ms\n";
#define ll long long int
const ll INF = 1e13 + 7;
const ll mod = 1e9 + 7;
void solv() {
ll n;
cin >> n;
vll a(n), b(n);
FOR(i, 0, n - 1)
cin >> a[i];
FOR(i, 0, n - 1)
cin >> b[i];
vll dp(n + 1);
dp[1] = b[0];
map<ll, ll> mp;
mp[a[0]] = dp[1];
// 3 1 4 2
ll ans = dp[1];
FOR(i, 2, n) {
dp[i] = b[i - 1];
auto it = mp.lower_bound(a[i - 1] + 1);
if (it != mp.begin()) {
it--;
dp[i] += it->second;
}
mp[a[i - 1]] = dp[i];
auto it2 = mp.upper_bound(a[i - 1]);
while (it2 != mp.end() and it2->second <= dp[i]) {
auto temp = it2;
++temp;
mp.erase(it2);
it2 = temp;
}
ans = max(ans, dp[i]);
}
// return ans;
cout << ans << endl;
}
int main() {
fast;
// testcases{
// codejam ;
solv();
// }
}
| [
"identifier.replace.add",
"literal.replace.remove"
] | 983,787 | 983,788 | u703699388 | cpp |
p03176 | //#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include <deque>
#include <ext/pb_ds/assoc_container.hpp> //required
#include <ext/pb_ds/tree_policy.hpp> //required
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
using namespace __gnu_pbds; // required
#define ll long long
#define ull unsigned ll
#define ld long double
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define mul(x, y) ((ll)(x) * (y)) % mod
#define tr(c, i) for (auto i = (c).begin(); i != (c).end(); i++)
#define forn(i, n) for (int i = 0; i < n; i++)
#define FOR(i, x, y) for (size_t i = size_t(x); i < size_t(y); i++)
#define ROF(i, x, y) for (size_t i = size_t(x - 1); i >= size_t(y); i--)
#define all(x) (x).begin(), (x).end()
using namespace std;
int clz(unsigned long long N) {
return N ? 64 - __builtin_clzll(N) : -INFINITY;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
unordered_map<long long, int, custom_hash> safe_map;
gp_hash_table<long long, int, custom_hash> safe_hash_table;
template <typename T> ostream &operator<<(ostream &os, const pair<T, T> &p) {
os << "[" << p.first << ", " << p.second << " ]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T> istream &operator>>(istream &os, vector<T> &v) {
// int temp;
for (unsigned int i = 0; i < v.size(); ++i) {
os >> v[i];
}
return os;
}
template <typename T> void o1(vector<T> &v) {
for (auto i : v)
cout << i << " ";
cout << "\n";
}
// template<typename T>
void google(int cas) { cout << "Case #" << cas << ": "; }
#define vi vector<int>
#define vvi vector<vi>
#define ii pair<int, int>
#define vii vector<ii>
#define vll vector<ll>
#define vvl vector<vll>
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
void make_set(ll v, vll &parent, vll &size) {
parent[v] = v;
size[v] = 1;
}
ll find_set(ll v, vll &parent) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v], parent);
}
void union_sets(ll a, ll b, vll &parent, vll &size) {
a = find_set(a, parent);
b = find_set(b, parent);
if (a != b) {
if (size[a] < size[b])
swap(a, b);
parent[b] = a;
size[a] += size[b];
}
}
void dfsvisit(vvl &adj, ll v, vll &visited, vll &order) {
visited[v] = 1;
for (auto i : adj[v]) {
if (!visited[i]) {
dfsvisit(adj, i, visited, order);
}
}
order.pb(v);
}
ll MPOW(ll a, ll b, ll m) {
if (b == 0)
return 1;
ll x = MPOW(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1)
x = (x * a) % m;
return x;
}
ll MINV(ll a, ll m) { return MPOW(a, m - 2, m); }
template <typename T>
using ordered_set = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
template <typename T> inline T ceil(T a, T b) { return ((a + b - 1) / b); }
ll p = (ll)1e9 + 7;
void dfs(vector<vll> &adj, ll u, ll v) {
for (auto i : adj[u]) {
if (i == v)
continue;
dfs(adj, i, u);
}
}
vector<vector<ll>> primes;
vector<vector<ll>> facts;
void init_prime(ll size = 1e6 + 1) {
primes.resize(size);
for (ll i = 2; i < size; i++) {
if (primes[i].size() == 0) {
for (ll j = i; j < size; j += i)
primes[j].push_back(i);
}
}
}
void init_facts(ll size = 2e5 + 1) {
facts.resize(size);
for (ll i = 1; i < size; i++) {
for (ll j = i; j < size; j += i)
facts[j].push_back(i);
}
}
bool isprime(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
const int g = 305;
inline void add_self(ll &a, ll b) {
a += b;
if (a >= p)
a -= p;
}
void sub_self(ll &a, ll b) {
a = a - b + p;
if (a >= p)
a -= p;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(NULL);
cin.tie(NULL);
int q = 1;
// cin>>q;
while (q--) {
ll n;
cin >> n;
vll h(n), a(n);
cin >> h >> a;
vll dp(n + 1, 0);
// dp[i] the max total beauty if the last taken flower has height i
int base = 1;
while (base <= n) {
base *= 2;
}
vector<ll> tree(2 * base, 0);
for (int i = 0; i < n; i++) {
tree[n + i] = dp[i];
}
for (int i = n - 1; i > 0; i--) {
tree[i] = max(tree[i << 1], tree[(i << 1) | 1]);
}
for (int flower = 0; flower < n; flower++) {
ll best = 0;
int l = 0;
int r = h[flower] + 1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
best = max(best, tree[l++]);
if (r & 1)
best = max(best, tree[--r]);
}
// cout<<best<<" ";
dp[h[flower]] = best + a[flower];
int index = h[flower];
tree[index + n] = dp[h[flower]];
index = index + n;
for (int i = index; i > 1; i >>= 1) {
tree[i >> 1] = max(tree[i], tree[i ^ 1]);
}
}
// cout<<"\n";
// cout<<tree;
cout << *max_element(all(dp)) << "\n";
}
return 0;
}
| //#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include <deque>
#include <ext/pb_ds/assoc_container.hpp> //required
#include <ext/pb_ds/tree_policy.hpp> //required
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
using namespace __gnu_pbds; // required
#define ll long long
#define ull unsigned ll
#define ld long double
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define mul(x, y) ((ll)(x) * (y)) % mod
#define tr(c, i) for (auto i = (c).begin(); i != (c).end(); i++)
#define forn(i, n) for (int i = 0; i < n; i++)
#define FOR(i, x, y) for (size_t i = size_t(x); i < size_t(y); i++)
#define ROF(i, x, y) for (size_t i = size_t(x - 1); i >= size_t(y); i--)
#define all(x) (x).begin(), (x).end()
using namespace std;
int clz(unsigned long long N) {
return N ? 64 - __builtin_clzll(N) : -INFINITY;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
unordered_map<long long, int, custom_hash> safe_map;
gp_hash_table<long long, int, custom_hash> safe_hash_table;
template <typename T> ostream &operator<<(ostream &os, const pair<T, T> &p) {
os << "[" << p.first << ", " << p.second << " ]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T> istream &operator>>(istream &os, vector<T> &v) {
// int temp;
for (unsigned int i = 0; i < v.size(); ++i) {
os >> v[i];
}
return os;
}
template <typename T> void o1(vector<T> &v) {
for (auto i : v)
cout << i << " ";
cout << "\n";
}
// template<typename T>
void google(int cas) { cout << "Case #" << cas << ": "; }
#define vi vector<int>
#define vvi vector<vi>
#define ii pair<int, int>
#define vii vector<ii>
#define vll vector<ll>
#define vvl vector<vll>
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
void make_set(ll v, vll &parent, vll &size) {
parent[v] = v;
size[v] = 1;
}
ll find_set(ll v, vll &parent) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v], parent);
}
void union_sets(ll a, ll b, vll &parent, vll &size) {
a = find_set(a, parent);
b = find_set(b, parent);
if (a != b) {
if (size[a] < size[b])
swap(a, b);
parent[b] = a;
size[a] += size[b];
}
}
void dfsvisit(vvl &adj, ll v, vll &visited, vll &order) {
visited[v] = 1;
for (auto i : adj[v]) {
if (!visited[i]) {
dfsvisit(adj, i, visited, order);
}
}
order.pb(v);
}
ll MPOW(ll a, ll b, ll m) {
if (b == 0)
return 1;
ll x = MPOW(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1)
x = (x * a) % m;
return x;
}
ll MINV(ll a, ll m) { return MPOW(a, m - 2, m); }
template <typename T>
using ordered_set = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
template <typename T> inline T ceil(T a, T b) { return ((a + b - 1) / b); }
ll p = (ll)1e9 + 7;
void dfs(vector<vll> &adj, ll u, ll v) {
for (auto i : adj[u]) {
if (i == v)
continue;
dfs(adj, i, u);
}
}
vector<vector<ll>> primes;
vector<vector<ll>> facts;
void init_prime(ll size = 1e6 + 1) {
primes.resize(size);
for (ll i = 2; i < size; i++) {
if (primes[i].size() == 0) {
for (ll j = i; j < size; j += i)
primes[j].push_back(i);
}
}
}
void init_facts(ll size = 2e5 + 1) {
facts.resize(size);
for (ll i = 1; i < size; i++) {
for (ll j = i; j < size; j += i)
facts[j].push_back(i);
}
}
bool isprime(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
const int g = 305;
inline void add_self(ll &a, ll b) {
a += b;
if (a >= p)
a -= p;
}
void sub_self(ll &a, ll b) {
a = a - b + p;
if (a >= p)
a -= p;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(NULL);
cin.tie(NULL);
int q = 1;
// cin>>q;
while (q--) {
ll n;
cin >> n;
vll h(n), a(n);
cin >> h >> a;
vll dp(n + 1, 0);
// dp[i] the max total beauty if the last taken flower has height i
int base = 1;
while (base <= n) {
base *= 2;
}
vector<ll> tree(2 * base, 0);
for (int i = 0; i < n; i++) {
tree[n + i] = dp[i];
}
for (int i = n - 1; i > 0; i--) {
tree[i] = max(tree[i << 1], tree[(i << 1) | 1]);
}
for (int flower = 0; flower < n; flower++) {
ll best = 0;
int l = 1;
int r = h[flower] + 1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1)
best = max(best, tree[l++]);
if (r & 1)
best = max(best, tree[--r]);
}
// cout<<best<<" ";
dp[h[flower]] = best + a[flower];
int index = h[flower];
tree[index + n] = dp[h[flower]];
index = index + n;
for (int i = index; i > 1; i >>= 1) {
tree[i >> 1] = max(tree[i], tree[i ^ 1]);
}
}
// cout<<"\n";
// cout<<tree;
cout << *max_element(all(dp)) << "\n";
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 983,791 | 983,792 | u164083094 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
typedef pair<int, int> pii;
const int MAX = 200005;
int h[MAX];
int n;
long long a[MAX], dp[MAX];
typedef struct item *pitem;
struct item {
int key, prior;
long long val, maximo = 0;
item *l, *r;
item() {}
item(int key, int prior, long long val)
: key(key), prior(prior), l(NULL), r(NULL), val(val) {}
};
typedef item *pitem;
long long maximo(pitem t) { return t ? t->maximo : 0; }
void upd_maximo(pitem t) {
if (t)
t->maximo = max(t->val, max(maximo(t->l), maximo(t->r)));
}
void split(pitem t, int key, pitem &l, pitem &r) {
if (!t)
l = r = NULL;
else if (key <= t->key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
upd_maximo(t);
}
void insert(pitem &t, pitem it) {
if (!t)
t = it;
else if (it->prior > t->prior)
split(t, it->key, it->l, it->r), t = it;
else
insert(it->key < t->key ? t->l : t->r, it);
upd_maximo(t);
}
void merge(pitem &t, pitem l, pitem r) {
if (!l || !r)
t = l ? l : r;
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
upd_maximo(t);
}
void erase(pitem &t, int key) {
if (t->key == key)
merge(t, t->l, t->r);
else
erase(key < t->key ? t->l : t->r, key);
upd_maximo(t);
}
long long query(pitem &t, int h) {
pitem l, r;
split(t, h, l, r);
int ans = maximo(l);
merge(t, l, r);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
srand(time(NULL));
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long val, rta = 0;
pitem treap = NULL;
for (int i = 0; i < n; ++i) {
val = query(treap, h[i]);
// error(val, i);
val += a[i];
pitem p = new item(h[i], rand(), val);
insert(treap, p);
rta = max(rta, val);
}
cout << rta << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
typedef pair<int, int> pii;
const int MAX = 200005;
int h[MAX];
int n;
long long a[MAX], dp[MAX];
typedef struct item *pitem;
struct item {
int key, prior;
long long val, maximo = 0;
item *l, *r;
item() {}
item(int key, int prior, long long val)
: key(key), prior(prior), l(NULL), r(NULL), val(val) {}
};
typedef item *pitem;
long long maximo(pitem t) { return t ? t->maximo : 0; }
void upd_maximo(pitem t) {
if (t)
t->maximo = max(t->val, max(maximo(t->l), maximo(t->r)));
}
void split(pitem t, int key, pitem &l, pitem &r) {
if (!t)
l = r = NULL;
else if (key <= t->key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
upd_maximo(t);
}
void insert(pitem &t, pitem it) {
if (!t)
t = it;
else if (it->prior > t->prior)
split(t, it->key, it->l, it->r), t = it;
else
insert(it->key < t->key ? t->l : t->r, it);
upd_maximo(t);
}
void merge(pitem &t, pitem l, pitem r) {
if (!l || !r)
t = l ? l : r;
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
upd_maximo(t);
}
void erase(pitem &t, int key) {
if (t->key == key)
merge(t, t->l, t->r);
else
erase(key < t->key ? t->l : t->r, key);
upd_maximo(t);
}
long long query(pitem &t, int h) {
pitem l, r;
split(t, h, l, r);
long long ans = maximo(l);
merge(t, l, r);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
srand(time(NULL));
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long val, rta = 0;
pitem treap = NULL;
for (int i = 0; i < n; ++i) {
val = query(treap, h[i]);
// error(val, i);
val += a[i];
pitem p = new item(h[i], rand(), val);
insert(treap, p);
rta = max(rta, val);
}
cout << rta << "\n";
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 983,793 | 983,794 | u143055906 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
vector<long long> tree(1e6, 0);
long long getit(int ss, int se, int p, int l, int r) {
if (ss > se || ss > r || se < l)
return (long long)0;
if (l <= ss && se <= r)
return tree[p];
int mid = (ss + se) / 2;
return max(getit(ss, mid, 2 * p, l, r), getit(mid + 1, se, 2 * p + 1, l, r));
}
void update(int ss, int se, int p, int l, int val) {
if (ss > se)
return;
if (ss == se) {
tree[p] += val;
return;
}
int mid = (ss + se) / 2;
if (l > mid)
update(mid + 1, se, 2 * p + 1, l, val);
else
update(ss, mid, 2 * p, l, val);
tree[p] = max(tree[2 * p], tree[2 * p + 1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
std::vector<int> h(n), bb(n);
for (auto &x : h)
cin >> x;
for (auto &x : bb)
cin >> x;
long long ans = 0;
for (int a = 0; a < n; a++) {
int l = h[a];
long long tt = getit(1, n, 1, 1, l);
// cout<<tt<<" "<<l<<endl;
update(1, n, 1, l, bb[a] + tt);
ans = max(ans, (long long)bb[a] + (long long)tt);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
vector<long long> tree(1e6, 0);
long long getit(int ss, int se, int p, int l, int r) {
if (ss > se || ss > r || se < l)
return (long long)0;
if (l <= ss && se <= r)
return tree[p];
int mid = (ss + se) / 2;
return max(getit(ss, mid, 2 * p, l, r), getit(mid + 1, se, 2 * p + 1, l, r));
}
void update(int ss, int se, int p, int l, long long val) {
if (ss > se)
return;
if (ss == se) {
tree[p] += val;
return;
}
int mid = (ss + se) / 2;
if (l > mid)
update(mid + 1, se, 2 * p + 1, l, val);
else
update(ss, mid, 2 * p, l, val);
tree[p] = max(tree[2 * p], tree[2 * p + 1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
std::vector<int> h(n), bb(n);
for (auto &x : h)
cin >> x;
for (auto &x : bb)
cin >> x;
long long ans = 0;
for (int a = 0; a < n; a++) {
int l = h[a];
long long tt = getit(1, n, 1, 1, l);
// cout<<tt<<" "<<l<<endl;
update(1, n, 1, l, bb[a] + tt);
ans = max(ans, (long long)bb[a] + (long long)tt);
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 983,799 | 983,800 | u501893076 | cpp |
p03176 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const ll mod = 1000000007;
const ll INF = 1001001001;
const ll LINF = 1001001001001001001;
void prvec(vector<ll> vec) { // for debug
ll n = vec.size();
cout << "------------------------------------\n";
rep(i, n) cout << i << " " << vec.at(i) << "\n";
cout << "------------------------------------\n";
}
void pr2d(vector<vector<ll>> vec) { // for debug
ll h = vec.size();
ll w = vec.at(0).size();
cout << "------------------------------------\n";
rep(i, h) {
rep(j, w) { cout << vec.at(i).at(j) << " "; }
cout << "\n";
}
cout << "------------------------------------\n";
}
struct SegmentTree {
private:
ll n;
vector<int> node;
// int nとvector<int> nodeの2つを変数に持つ
public:
//初期化処理
SegmentTree(vector<ll> v) {
ll sz = v.size(); // vは扱う配列の長さ
n = 1;
while (n < sz)
n *= 2; // nはvの配列を入れるために必要なseg treeの葉の数
node.resize(
2 * n - 1,
0); // segtreeでは全部で2n-1の配列が必要 ★演算によって単位元を変える
for (int i = 0; i < sz; i++)
node[i + n - 1] = v[i]; // segtreeの葉の部分に扱う配列を埋め込む
for (int i = n - 2; i >= 0; i--)
node[i] = max(node[2 * i + 1], node[2 * i + 2]); //★演算によって変える場所 segtreeを作る(注目しているnode
//iの子ノードを見て二項演算をして、node
//iの値を決定する)
}
void update(ll x, ll val) {
x +=
(n -
1); //配列のx番目の要素を更新しようとするとき、segtreeで対応する要素はx+n-1番目である
node[x] = val; // segtree上で値を更新
while (x > 0) { //葉から根に向かってsegtreeの要素を更新していく
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]); //★演算によって変える
}
}
ll getmax(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
//求めたいのは区間[a,b)の中で演算しつづけた結果(たとえばこの区間の最小値)
//自分がいるノードのindex(何階にいるか？)
//ノードkは元の配列でいうとどの区間をカバーしているか？
if (r < 0)
r = n; //最初に呼び出す時はノードk=0はsegtreeの根なので区間は[0,n)を指す
if (r <= a || b <= l)
return 0; //今のノードが求める区間と無関係の場合は、最終的な答えに影響しない単位元(最小値を求めたい場合は単位元はINF)を返す
//演算によって変える
if (a <= l && r <= b)
return node
[k]; //今見ている区間[l,r)が答えを求めたい区間[a,b)に完全に含まれるなら、この区間について演算し続けた結果(=node[k];例えば最小値)を返す
//上記に当てはまらない場合
// kの子ノードを見に行って、再帰的に処理を行う k=0の場合はノード1と2を見る
ll vl = getmax(
a, b, 2 * k + 1, l,
(l + r) /
2); // kの子ノード(left)の子孫のうち、求めたい区間に含まれる要素について演算し続けた結果を返す
ll vr = getmax(
a, b, 2 * k + 2, (l + r) / 2,
r); // kの子ノード(right)の子孫のうち、求めたい区間に含まれる要素について演算し続けた結果を返す
return max(vl, vr); //演算によって変える場所
//子ノードの子孫のうち、演算しつづけた結果を返す
}
};
int main() {
ll n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) {
cin >> h.at(i);
h.at(i)--;
}
rep(i, n) cin >> a.at(i);
vector<ll> lst(n, 0);
SegmentTree tree(lst);
rep(i, n) {
ll mxm = tree.getmax(0, h.at(i));
tree.update(h.at(i), mxm + a.at(i));
}
ll ans = 0;
rep(i, n) { ans = max((ans), (tree.getmax(i, i + 1))); }
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const ll mod = 1000000007;
const ll INF = 1001001001;
const ll LINF = 1001001001001001001;
void prvec(vector<ll> vec) { // for debug
ll n = vec.size();
cout << "------------------------------------\n";
rep(i, n) cout << i << " " << vec.at(i) << "\n";
cout << "------------------------------------\n";
}
void pr2d(vector<vector<ll>> vec) { // for debug
ll h = vec.size();
ll w = vec.at(0).size();
cout << "------------------------------------\n";
rep(i, h) {
rep(j, w) { cout << vec.at(i).at(j) << " "; }
cout << "\n";
}
cout << "------------------------------------\n";
}
struct SegmentTree {
private:
ll n;
vector<ll> node;
// int nとvector<int> nodeの2つを変数に持つ
public:
//初期化処理
SegmentTree(vector<ll> v) {
ll sz = v.size(); // vは扱う配列の長さ
n = 1;
while (n < sz)
n *= 2; // nはvの配列を入れるために必要なseg treeの葉の数
node.resize(
2 * n - 1,
0); // segtreeでは全部で2n-1の配列が必要 ★演算によって単位元を変える
for (int i = 0; i < sz; i++)
node[i + n - 1] = v[i]; // segtreeの葉の部分に扱う配列を埋め込む
for (int i = n - 2; i >= 0; i--)
node[i] = max(node[2 * i + 1], node[2 * i + 2]); //★演算によって変える場所 segtreeを作る(注目しているnode
//iの子ノードを見て二項演算をして、node
//iの値を決定する)
}
void update(ll x, ll val) {
x +=
(n -
1); //配列のx番目の要素を更新しようとするとき、segtreeで対応する要素はx+n-1番目である
node[x] = val; // segtree上で値を更新
while (x > 0) { //葉から根に向かってsegtreeの要素を更新していく
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]); //★演算によって変える
}
}
ll getmax(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
//求めたいのは区間[a,b)の中で演算しつづけた結果(たとえばこの区間の最小値)
//自分がいるノードのindex(何階にいるか？)
//ノードkは元の配列でいうとどの区間をカバーしているか？
if (r < 0)
r = n; //最初に呼び出す時はノードk=0はsegtreeの根なので区間は[0,n)を指す
if (r <= a || b <= l)
return 0; //今のノードが求める区間と無関係の場合は、最終的な答えに影響しない単位元(最小値を求めたい場合は単位元はINF)を返す
//演算によって変える
if (a <= l && r <= b)
return node
[k]; //今見ている区間[l,r)が答えを求めたい区間[a,b)に完全に含まれるなら、この区間について演算し続けた結果(=node[k];例えば最小値)を返す
//上記に当てはまらない場合
// kの子ノードを見に行って、再帰的に処理を行う k=0の場合はノード1と2を見る
ll vl = getmax(
a, b, 2 * k + 1, l,
(l + r) /
2); // kの子ノード(left)の子孫のうち、求めたい区間に含まれる要素について演算し続けた結果を返す
ll vr = getmax(
a, b, 2 * k + 2, (l + r) / 2,
r); // kの子ノード(right)の子孫のうち、求めたい区間に含まれる要素について演算し続けた結果を返す
return max(vl, vr); //演算によって変える場所
//子ノードの子孫のうち、演算しつづけた結果を返す
}
};
int main() {
ll n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) {
cin >> h.at(i);
h.at(i)--;
}
rep(i, n) cin >> a.at(i);
vector<ll> lst(n, 0);
SegmentTree tree(lst);
rep(i, n) {
ll mxm = tree.getmax(0, h.at(i));
tree.update(h.at(i), mxm + a.at(i));
}
ll ans = 0;
rep(i, n) { ans = max((ans), (tree.getmax(i, i + 1))); }
cout << ans << endl;
} | [] | 983,808 | 983,809 | u628597699 | cpp |
p03176 | #include <bits/stdc++.h>
#ifdef __LOCAL
#define DBG(X) cout << #X << " = " << (X) << endl;
#define SAY(X) cout << (X) << endl;
#else
#define DBG(X)
#define SAY(X)
#endif
#ifdef __LOCAL
#include <filesystem>
namespace fs = std::filesystem;
#endif
using namespace std;
using ll = long long int;
inline void fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
};
struct flower {
int height;
int index;
ll a;
flower(int h = 0, ll a = 0, int i = 0) : height(h), a(a), index(i) {}
};
int N;
vector<flower> Flowers;
void input() {
fast_io();
#ifdef __LOCAL
fs::path p = __FILE__;
fs::path input, output;
input = output = p.parent_path();
input += string("/input/") + string(p.stem()) + string(".txt");
output += string("/output/") + string(p.stem()) + string(".txt");
freopen(input.c_str(), "r", stdin);
freopen(output.c_str(), "w", stdout);
#endif
cin >> N;
Flowers.resize(N);
for (int i = 0; i < N; i++) {
cin >> Flowers[i].height;
Flowers[i].index = i;
}
for (int i = 0; i < N; i++) {
cin >> Flowers[i].a;
}
}
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C> int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, seg[1])))
return find_subtree(1, check, L, false);
return -1;
}
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt))
return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C> int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(seg[1], R)))
return find_subtree(1, check, R, true);
return -1;
}
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt))
return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
int solve() {
sort(Flowers.begin(), Flowers.end(),
[](flower a, flower b) { return a.height < b.height; });
auto op = [](ll a, ll b) { return max(a, b); };
ll E = 0LL;
SegmentTree<ll> seg(N + 1, op, E);
for (int i = 0; i < N; i++) {
int idx = Flowers[i].index;
ll Beauty = Flowers[i].a;
ll Max = seg.query(0, i + 1);
seg.update(idx, Max + Beauty);
}
cout << seg.query(0, N) << endl;
return 0;
}
int main() {
// maketestcase(400);
input();
solve();
return 0;
}
| #include <bits/stdc++.h>
#ifdef __LOCAL
#define DBG(X) cout << #X << " = " << (X) << endl;
#define SAY(X) cout << (X) << endl;
#else
#define DBG(X)
#define SAY(X)
#endif
#ifdef __LOCAL
#include <filesystem>
namespace fs = std::filesystem;
#endif
using namespace std;
using ll = long long int;
inline void fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
};
struct flower {
int height;
int index;
ll a;
flower(int h = 0, ll a = 0, int i = 0) : height(h), a(a), index(i) {}
};
int N;
vector<flower> Flowers;
void input() {
fast_io();
#ifdef __LOCAL
fs::path p = __FILE__;
fs::path input, output;
input = output = p.parent_path();
input += string("/input/") + string(p.stem()) + string(".txt");
output += string("/output/") + string(p.stem()) + string(".txt");
freopen(input.c_str(), "r", stdin);
freopen(output.c_str(), "w", stdout);
#endif
cin >> N;
Flowers.resize(N);
for (int i = 0; i < N; i++) {
cin >> Flowers[i].height;
Flowers[i].index = i;
}
for (int i = 0; i < N; i++) {
cin >> Flowers[i].a;
}
}
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C> int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, seg[1])))
return find_subtree(1, check, L, false);
return -1;
}
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt))
return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C> int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(seg[1], R)))
return find_subtree(1, check, R, true);
return -1;
}
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt))
return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
int solve() {
sort(Flowers.begin(), Flowers.end(),
[](flower a, flower b) { return a.height < b.height; });
auto op = [](ll a, ll b) { return max(a, b); };
ll E = 0LL;
SegmentTree<ll> seg(N + 1, op, E);
for (int i = 0; i < N; i++) {
int idx = Flowers[i].index;
ll Beauty = Flowers[i].a;
ll Max = seg.query(0, idx);
seg.update(idx, Max + Beauty);
}
cout << seg.query(0, N) << endl;
return 0;
}
int main() {
// maketestcase(400);
input();
solve();
return 0;
}
| [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 983,810 | 983,811 | u858670323 | cpp |
p03176 | #include <bits/stdc++.h>
#define fin \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
#define ll long long
const int N = 200005;
ll dp[N], bit[N];
ll h[N];
ll mx(int i) {
ll ans = 0;
for (int j = i; j > 0; j -= j & (-j))
ans = max(ans, bit[j]);
return ans;
}
void update(int x, ll val) {
for (int i = x; i < N; i += i & (-i))
bit[i] = max(bit[x], val);
}
int main() {
fin;
int n, i;
cin >> n;
memset(bit, 0, sizeof(bit));
memset(dp, 0, sizeof(dp));
for (i = 0; i < n; i++)
cin >> h[i];
ll b[N];
for (i = 0; i < n; i++)
cin >> b[i];
for (i = 0; i < n; i++) {
ll mxi = mx(h[i] - 1);
// cout<<mxi<<" ";
dp[h[i]] = max(dp[h[i]], mxi + b[i]);
// cout<<dp[h[i]]<<"\n";
update(h[i], dp[h[i]]);
}
ll ans = 0;
for (i = 0; i < N; i++)
ans = max(ans, dp[i]);
cout << ans;
}
| #include <bits/stdc++.h>
#define fin \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
#define ll long long
const int N = 200005;
ll dp[N], bit[N];
ll h[N];
ll mx(int i) {
ll ans = 0;
for (int j = i; j > 0; j -= j & (-j))
ans = max(ans, bit[j]);
return ans;
}
void update(int x, ll val) {
for (int i = x; i < N; i += i & (-i))
bit[i] = max(bit[i], val);
}
int main() {
fin;
int n, i;
cin >> n;
memset(bit, 0, sizeof(bit));
memset(dp, 0, sizeof(dp));
for (i = 0; i < n; i++)
cin >> h[i];
ll b[N];
for (i = 0; i < n; i++)
cin >> b[i];
for (i = 0; i < n; i++) {
ll mxi = mx(h[i] - 1);
// cout<<mxi<<" ";
dp[h[i]] = max(dp[h[i]], mxi + b[i]);
// cout<<dp[h[i]]<<"\n";
update(h[i], dp[h[i]]);
}
ll ans = 0;
for (i = 0; i < N; i++)
ans = max(ans, dp[i]);
cout << ans;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 983,816 | 983,817 | u559274475 | cpp |
p03176 | /*
author: kartik8800
*/
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define fr(a, b) for (ll i = a; i < b; i++)
#define mod 1000000007
#define inf (1LL << 60)
#define all(x) (x).begin(), (x).end()
#define prDouble(x) cout << fixed << setprecision(10) << x
#define triplet pair<ll, pair<ll, ll>>
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
using namespace std;
struct flower {
int hi;
int bty;
};
ll solve(vector<flower> &v, int n) {
vector<ll> dp(n + 1);
map<int, int> meaningful;
dp[1] = v[1].bty;
meaningful[v[1].hi] = dp[1];
ll ans = dp[1];
for (int i = 2; i <= n; i++) {
dp[i] = v[i].bty;
auto it = meaningful.lower_bound(v[i].hi + 1);
if (it != meaningful.begin()) {
it--;
dp[i] += it->second;
}
meaningful[v[i].hi] = dp[i];
it = meaningful.upper_bound(v[i].hi);
while (it != meaningful.end() && it->second <= dp[i]) {
auto temp = it;
temp++;
meaningful.erase(it);
it = temp;
}
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
int n;
cin >> n;
vector<flower> v(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i].hi;
for (int i = 1; i <= n; i++)
cin >> v[i].bty;
cout << solve(v, n);
return 0;
}
| /*
author: kartik8800
*/
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define fr(a, b) for (ll i = a; i < b; i++)
#define mod 1000000007
#define inf (1LL << 60)
#define all(x) (x).begin(), (x).end()
#define prDouble(x) cout << fixed << setprecision(10) << x
#define triplet pair<ll, pair<ll, ll>>
#define fast_io \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
using namespace std;
struct flower {
ll hi;
ll bty;
};
ll solve(vector<flower> &v, int n) {
vector<ll> dp(n + 1);
map<ll, ll> meaningful;
dp[1] = v[1].bty;
meaningful[v[1].hi] = dp[1];
ll ans = dp[1];
for (int i = 2; i <= n; i++) {
dp[i] = v[i].bty;
auto it = meaningful.lower_bound(v[i].hi + 1);
if (it != meaningful.begin()) {
it--;
dp[i] += it->second;
}
meaningful[v[i].hi] = dp[i];
it = meaningful.upper_bound(v[i].hi);
while (it != meaningful.end() && it->second <= dp[i]) {
auto temp = it;
temp++;
meaningful.erase(it);
it = temp;
}
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
int n;
cin >> n;
vector<flower> v(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i].hi;
for (int i = 1; i <= n; i++)
cin >> v[i].bty;
cout << solve(v, n);
return 0;
}
| [] | 983,822 | 983,823 | u212789054 | cpp |
p03176 | #include "bits/stdc++.h"
// region Template
#include "ext/pb_ds/assoc_container.hpp"
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int MOD2 = 998244353;
const int MOD = 1000000007;
using namespace std;
#define finish(x) \
cout << x; \
exit(0);
#define fastIO \
cin.tie(0); \
cin.sync_with_stdio(false);
#define fi first
#define se second
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
// const string USCAO_TAG = "mountains";
void usaco(const string &USACO_TAG) {
setIn(USACO_TAG + ".in");
setOut(USACO_TAG + ".out");
}
#define is_empty(...) (sizeof((char[]){#__VA_ARGS__}) == 1)
void print() {}
template <typename T, typename... Args> void print(T firstArg, Args... args) {
#ifdef LOCAL
cout << firstArg << endl;
print(args...);
#endif
}
// endregion
/* Notes:
* Fry my kartoshka
*/
const int MAXN = 1e5 + 5;
const int INF = 2e9;
ll dp[MAXN];
ll h[MAXN];
ll a[MAXN];
ll t[4 * MAXN];
ll get(int x, int l, int r, int tl, int tr) {
if (tl > tr) {
return 0;
}
if (l == tl && r == tr) {
return t[x];
}
int mid = (l + r) / 2;
ll res = 0;
res = max(res, get(x * 2, l, mid, tl, min(mid, tr)));
res = max(res, get(x * 2 + 1, mid + 1, r, max(mid + 1, tl), tr));
return res;
}
void update(int x, int l, int r, int pos, int val) {
if (l == r) {
t[x] = val;
return;
}
int mid = (l + r) / 2;
if (mid < pos) {
update(2 * x + 1, mid + 1, r, pos, val);
} else {
update(2 * x, l, mid, pos, val);
}
t[x] = max(t[2 * x], t[2 * x + 1]);
}
int main() {
// usaco("milkvisits");
#ifdef LOCAL
setIn("in.txt");
setOut("out.txt");
#endif
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
ll cur = 0;
cur = get(1, 0, n, 0, h[i] - 1);
dp[h[i]] = max(dp[h[i]], cur + a[i]);
update(1, 0, n, h[i], dp[h[i]]);
}
ll res = 0;
for (int i = 1; i <= n; i++) {
res = max(res, dp[i]);
}
cout << res << "\n";
}
| #include "bits/stdc++.h"
// region Template
#include "ext/pb_ds/assoc_container.hpp"
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int MOD2 = 998244353;
const int MOD = 1000000007;
using namespace std;
#define finish(x) \
cout << x; \
exit(0);
#define fastIO \
cin.tie(0); \
cin.sync_with_stdio(false);
#define fi first
#define se second
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
// const string USCAO_TAG = "mountains";
void usaco(const string &USACO_TAG) {
setIn(USACO_TAG + ".in");
setOut(USACO_TAG + ".out");
}
#define is_empty(...) (sizeof((char[]){#__VA_ARGS__}) == 1)
void print() {}
template <typename T, typename... Args> void print(T firstArg, Args... args) {
#ifdef LOCAL
cout << firstArg << endl;
print(args...);
#endif
}
// endregion
/* Notes:
* Fry my kartoshka
*/
const int MAXN = 2e5 + 5;
const int INF = 2e9;
ll dp[MAXN];
ll h[MAXN];
ll a[MAXN];
ll t[4 * MAXN];
ll get(int x, int l, int r, int tl, int tr) {
if (tl > tr) {
return 0;
}
if (l == tl && r == tr) {
return t[x];
}
int mid = (l + r) / 2;
ll res = 0;
res = max(res, get(x * 2, l, mid, tl, min(mid, tr)));
res = max(res, get(x * 2 + 1, mid + 1, r, max(mid + 1, tl), tr));
return res;
}
void update(int x, int l, int r, int pos, ll val) {
if (l == r) {
t[x] = val;
return;
}
int mid = (l + r) / 2;
if (mid < pos) {
update(2 * x + 1, mid + 1, r, pos, val);
} else {
update(2 * x, l, mid, pos, val);
}
t[x] = max(t[2 * x], t[2 * x + 1]);
}
int main() {
// usaco("milkvisits");
#ifdef LOCAL
setIn("in.txt");
setOut("out.txt");
#endif
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
ll cur = 0;
cur = get(1, 0, n, 0, h[i] - 1);
dp[h[i]] = max(dp[h[i]], cur + a[i]);
update(1, 0, n, h[i], dp[h[i]]);
}
ll res = 0;
for (int i = 1; i <= n; i++) {
res = max(res, dp[i]);
}
cout << res << "\n";
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 983,826 | 983,827 | u557558723 | cpp |
p03176 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
scanf("%d", &N);
vector<int> H(N), A(N);
vector<long long> dp(N, 0);
int base = 1;
while (base <= N) {
base <<= 1;
}
vector<long long> tree(2 * base, 0);
for (int i = 0; i < N; ++i) {
scanf("%d", &H[i]);
}
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i]);
dp[i] = A[i];
}
for (int i = 0; i < N; ++i) {
int x = base + H[i];
long long best = 0;
while (x > 1) {
if (x & 1) {
best = max(best, tree[x - 1]);
}
x >>= 1;
}
dp[H[i]] = best + A[i];
for (int k = base + H[i]; k >= 1; k >>= 1) {
tree[k] = max(tree[k], dp[H[i]]);
}
}
cout << tree[1];
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
scanf("%d", &N);
vector<int> H(N), A(N);
vector<long long> dp(2 * N, 0);
int base = 1;
while (base <= N) {
base <<= 1;
}
vector<long long> tree(2 * base, 0);
for (int i = 0; i < N; ++i) {
scanf("%d", &H[i]);
}
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i]);
dp[i] = A[i];
}
for (int i = 0; i < N; ++i) {
int x = base + H[i];
long long best = 0;
while (x > 1) {
if (x & 1) {
best = max(best, tree[x - 1]);
}
x >>= 1;
}
dp[H[i]] = best + A[i];
for (int k = base + H[i]; k >= 1; k >>= 1) {
tree[k] = max(tree[k], dp[H[i]]);
}
}
cout << tree[1];
} | [
"assignment.change"
] | 983,840 | 983,841 | u645134771 | cpp |
p03176 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
#define ll long long
ll tree[4 * N];
void upd(int in, int l, int r, int idx, ll v) {
if (l > idx || r < idx)
return;
if (l == r) {
tree[in] = v;
return;
}
int m = (l + r) / 2;
upd(2 * in, l, m, idx, v);
upd(2 * in + 1, m + 1, r, idx, v);
tree[in] = max(tree[2 * in], tree[2 * in + 1]);
}
ll get(int in, int l, int r, int s, int e) {
if (l > e || r < s)
return 0;
if (l >= s && r <= e)
return tree[in];
int m = (l + r) / 2;
return max(get(2 * in, l, m, s, e), get(2 * in + 1, m + 1, r, s, e));
}
int main() {
int n;
cin >> n;
int h[n], v[n];
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < n; i++)
cin >> v[i];
ll dp[n];
ll res = 0;
for (int i = 1; i < n; i++) {
dp[i] = get(1, 0, n, 0, h[i] - 1) + v[i];
upd(1, 0, n, h[i], dp[i]);
res = max(res, dp[i]);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
#define ll long long
ll tree[4 * N];
void upd(int in, int l, int r, int idx, ll v) {
if (l > idx || r < idx)
return;
if (l == r) {
tree[in] = v;
return;
}
int m = (l + r) / 2;
upd(2 * in, l, m, idx, v);
upd(2 * in + 1, m + 1, r, idx, v);
tree[in] = max(tree[2 * in], tree[2 * in + 1]);
}
ll get(int in, int l, int r, int s, int e) {
if (l > e || r < s)
return 0;
if (l >= s && r <= e)
return tree[in];
int m = (l + r) / 2;
return max(get(2 * in, l, m, s, e), get(2 * in + 1, m + 1, r, s, e));
}
int main() {
int n;
cin >> n;
int h[n], v[n];
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < n; i++)
cin >> v[i];
ll dp[n];
ll res = 0;
for (int i = 0; i < n; i++) {
dp[i] = get(1, 0, n, 0, h[i] - 1) + v[i];
upd(1, 0, n, h[i], dp[i]);
res = max(res, dp[i]);
}
cout << res;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 983,842 | 983,843 | u945097761 | cpp |
p03176 | #include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using PII = pair<int, int>;
using PIL = pair<int, LL>;
using PLL = pair<LL, LL>;
// const int mod = 1e9 + 7;
// const int mod = 998244353;
inline void quickread() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int tree[200010];
int h[200010], a[200010];
int n;
inline int lowbit(int x) { return x & (-x); }
inline int query(int x) {
int ret = 0;
while (x) {
ret = max(ret, tree[x]);
x -= lowbit(x);
}
return ret;
}
inline void update(int x, int v) {
while (x <= n) {
tree[x] = max(tree[x], v);
x += lowbit(x);
}
}
inline void work() {
cin >> n;
int ans = 0;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
int value = query(h[i]);
ans = max(ans, value + a[i]);
update(h[i], value + a[i]);
}
cout << ans << "\n";
}
int main() {
// freopen("input.txt", "r", stdin);
quickread();
work();
return 0;
} | #include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using PII = pair<int, int>;
using PIL = pair<int, LL>;
using PLL = pair<LL, LL>;
// const int mod = 1e9 + 7;
// const int mod = 998244353;
inline void quickread() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
LL tree[200010];
int h[200010], a[200010];
int n;
inline int lowbit(int x) { return x & (-x); }
inline LL query(int x) {
LL ret = 0;
while (x) {
ret = max(ret, tree[x]);
x -= lowbit(x);
}
return ret;
}
inline void update(int x, LL v) {
while (x <= n) {
tree[x] = max(tree[x], v);
x += lowbit(x);
}
}
inline void work() {
cin >> n;
LL ans = 0;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
LL value = query(h[i]);
ans = max(ans, value + a[i]);
update(h[i], value + a[i]);
}
cout << ans << "\n";
}
int main() {
// freopen("input.txt", "r", stdin);
quickread();
work();
return 0;
} | [
"variable_declaration.type.change"
] | 983,852 | 983,853 | u878735274 | cpp |
p03176 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
struct segtree {
int n;
vector<ll> dat;
segtree(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.resize(2 * n - 1);
for (int i = 0; i < 2 * n - 1; i++)
dat[i] = 0;
}
void update(int k, ll a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
ll get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return -1;
if (a <= l && r <= b)
return dat[k];
else {
ll vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
};
int main() {
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) {
cin >> h[i];
h[i]--;
}
rep(i, n) cin >> a[i];
segtree dp(n);
ll ans = 0;
rep(i, n) {
ll A = dp.get(0, h[i]);
if ((dp.get(h[i], h[i] + 1) < A + a[i])) {
dp.update(h[i], A + a[i]);
chmax(ans, A + a[i]);
}
}
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
struct segtree {
int n;
vector<ll> dat;
segtree(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.resize(2 * n - 1);
for (int i = 0; i < 2 * n - 1; i++)
dat[i] = 0;
}
void update(int k, ll a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
ll get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
ll vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
};
int main() {
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) {
cin >> h[i];
h[i]--;
}
rep(i, n) cin >> a[i];
segtree dp(n);
ll ans = 0;
rep(i, n) {
ll A = dp.get(0, h[i]);
if ((dp.get(h[i], h[i] + 1) < A + a[i])) {
dp.update(h[i], A + a[i]);
chmax(ans, A + a[i]);
}
}
cout << ans << endl;
} | [
"literal.number.change",
"function.return_value.change"
] | 983,873 | 983,874 | u136342563 | cpp |
p03176 | #include <algorithm>
#include <cstdint>
#include <iostream>
int const MAXN = 200000;
int const MAXBIT = 1 << 18;
int N, NN, h[MAXN];
uint64_t a[MAXN];
uint64_t dp[MAXBIT + 1];
int pw2(int n) {
int ret = 1;
while (ret < n)
ret <<= 1;
return ret;
}
uint64_t bit_max(int i) {
++i;
uint64_t ret = 0;
while (i > 0) {
ret = std::max(ret, dp[i]);
i -= i & -i;
}
return ret;
}
void bit_set(int i, uint64_t x) {
++i;
while (i <= NN) {
dp[i] = std::max(dp[i], x);
i += i & -i;
}
}
int main() {
std::cin >> N;
NN = pw2(N);
for (int i = 0; i < N; ++i)
std::cin >> h[i];
for (int i = 0; i < N; ++i)
std::cin >> a[i];
for (int i = 0; i <= NN; ++i)
dp[i] = 0;
for (int i = 0; i < N; ++i) {
uint64_t tmp = bit_max(h[i]) + a[i];
bit_set(h[i] + 1, tmp);
}
std::cout << dp[NN] << std::endl;
return 0;
}
| #include <algorithm>
#include <cstdint>
#include <iostream>
int const MAXN = 200000;
int const MAXBIT = 1 << 18;
int N, NN, h[MAXN];
uint64_t a[MAXN];
uint64_t dp[MAXBIT + 1];
inline int pw2(int n) {
int ret = 1;
while (ret < n)
ret <<= 1;
return ret;
}
uint64_t bit_max(int i) {
++i;
uint64_t ret = 0;
while (i > 0) {
ret = std::max(ret, dp[i]);
i -= i & -i;
}
return ret;
}
void bit_set(int i, uint64_t x) {
++i;
while (i <= NN) {
dp[i] = std::max(dp[i], x);
i += i & -i;
}
}
int main() {
std::cin >> N;
NN = pw2(N + 2);
for (int i = 0; i < N; ++i)
std::cin >> h[i];
for (int i = 0; i < N; ++i)
std::cin >> a[i];
for (int i = 0; i <= NN; ++i)
dp[i] = 0;
for (int i = 0; i < N; ++i) {
uint64_t tmp = bit_max(h[i]) + a[i];
bit_set(h[i] + 1, tmp);
}
std::cout << dp[NN] << std::endl;
return 0;
}
| [
"assignment.change"
] | 983,879 | 983,880 | u294638337 | cpp |
p03176 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define ALL(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800 / 2
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy8[8] = {0, 1, 0, -1, 1, 1, -1, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
bool issame(int x, int y) { return root(x) == root(y); }
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<ll> enum_div(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
// グラフセット
struct Edge {
ll to; // 辺の行き先
ll weight; // 辺の重み
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<ll>>;
#define def 0
template <class V, int NV> struct SegTree { //[l,r)
V comp(V &l, V &r) { return max(l, r); };
vector<V> val;
SegTree() { val = vector<V>(NV * 2, def); }
V get(int x, int y, int l = 0, int r = NV, int k = 1) {
if (r <= x || y <= l)
return def;
if (x <= l && r <= y)
return val[k];
auto a = get(x, y, l, (l + r) / 2, k * 2);
auto b = get(x, y, (l + r) / 2, r, k * 2 + 1);
return comp(a, b);
}
void update(int i, V v) {
i += NV;
val[i] = v;
while (i > 1)
i >>= 1, val[i] = comp(val[i * 2], val[i * 2 + 1]);
}
void add(int i, V v) { update(i, val[i + NV] + v); }
V operator[](int x) { return get(x, x + 1); }
};
// std::setprecision(30)<<ans<<endl;
int main() {
ll N, K, L;
cin >> N;
SegTree<ll, 1 << 18> dp;
ll a[N];
ll h[N];
FOR(i, 0, N) { cin >> h[i]; }
FOR(i, 0, N - 1) { cin >> a[i]; }
FOR(i, 0, N - 1) {
ll opt = dp.get(0, h[i]) + a[i];
dp.update(h[i], max(dp[h[i]], opt));
}
cout << dp.get(0, 1 << 18) << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
#define ALL(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800 / 2
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define ALL(a) (a).begin(), (a).end()
#include <cmath>
#include <iostream>
using namespace std;
bool isPrimeNum(ll x) { // 素数である場合 true を返す
if (x <= 1) { // 1以下である場合は素数でないことがすぐにわかる
return false;
}
// sqrt( double型 ) は引数の平方根を double型で返すので、int型でキャスト
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++) {
if (x % i == 0) { // 割り切る整数がある場合、即判定終了
return false;
}
}
return true; // 割り切る整数がない場合、素数である
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b) {
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b) {
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b) {
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy8[8] = {0, 1, 0, -1, 1, 1, -1, -1};
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい]
}
bool issame(int x, int y) { return root(x) == root(y); }
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
void yn(bool flag) {
if (flag) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return;
}
void YN(bool flag) {
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return;
}
std::vector<ll> enum_div(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
// グラフセット
struct Edge {
ll to; // 辺の行き先
ll weight; // 辺の重み
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<ll>>;
#define def 0
template <class V, int NV> struct SegTree { //[l,r)
V comp(V &l, V &r) { return max(l, r); };
vector<V> val;
SegTree() { val = vector<V>(NV * 2, def); }
V get(int x, int y, int l = 0, int r = NV, int k = 1) {
if (r <= x || y <= l)
return def;
if (x <= l && r <= y)
return val[k];
auto a = get(x, y, l, (l + r) / 2, k * 2);
auto b = get(x, y, (l + r) / 2, r, k * 2 + 1);
return comp(a, b);
}
void update(int i, V v) {
i += NV;
val[i] = v;
while (i > 1)
i >>= 1, val[i] = comp(val[i * 2], val[i * 2 + 1]);
}
void add(int i, V v) { update(i, val[i + NV] + v); }
V operator[](int x) { return get(x, x + 1); }
};
// std::setprecision(30)<<ans<<endl;
int main() {
ll N, K, L;
cin >> N;
SegTree<ll, 1 << 18> dp;
ll a[N];
ll h[N];
FOR(i, 0, N - 1) { cin >> h[i]; }
FOR(i, 0, N - 1) { cin >> a[i]; }
FOR(i, 0, N - 1) {
ll opt = dp.get(0, h[i]) + a[i];
dp.update(h[i], max(dp[h[i]], opt));
}
cout << dp.get(0, 1 << 18) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 983,883 | 983,884 | u043443359 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
// MAX_Nはn2以上
const int MAX_N = 1 << 18; // 1<<18 = 262144, 1<<17 = 131072
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change"
] | 983,893 | 983,888 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
// MAX_Nはn2以上
const int MAX_N = 1 << 20; // 1<<18 = 262144, 1<<17 = 131072
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change"
] | 983,893 | 983,895 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
// MAX_Nはn2以上
const int MAX_N = 1 << 18; // = 262144
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change"
] | 983,893 | 983,896 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 262144;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 983,893 | 983,897 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(200005);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 262144;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 983,898 | 983,897 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 263005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 983,893 | 983,899 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(200005);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 263005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 983,898 | 983,899 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 300005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 983,893 | 983,900 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(200005);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 300005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 983,898 | 983,900 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200000;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 300001;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 983,893 | 983,901 | u850516963 | cpp |
p03176 | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 200005;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(200005);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#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 bit(n, k) ((n >> k) & 1) // nのk bit目
#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;
}
const int MAX_N = 300001;
// セグメント木を持つグローバル配列(n2は要素数を2のべき乗にするから)
int n2, dat[2 * MAX_N - 1];
void init(int n_) {
n2 = 1;
while (n2 < n_)
n2 *= 2;
for (int i = 0; i < 2 * n2 - 1; i++)
dat[i] = -INFLL;
}
// k番目の値(0-indexed)をaに変更
void update(int k, int a) {
// 葉の節点
k += n2 - 1;
dat[k] = a;
// 登りながら更新
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
// 区間max: [a,b)の最大値を求める(k:
// 節点の番号、l、rはその節点が[l,r)に対応づいていることを表す
// query(a,b,0,0,n2)と呼ぶ
int query(int a, int b, int k = 0, int l = 0, int r = n2) {
if (r <= a || b <= l)
return -INFLL;
if (a <= l && r <= b)
return dat[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
/*
int main () {
int n;
n = 6;
vi a = {1,3,6,6,4,2};
n2 = n;
init(n2);
rep(i,n2) update(i,a[i]);
showt(dat,6);
show(query(0,1));
return 0;
}
*/
signed main() {
int n;
cin >> n;
vi h(n);
rep(i, n) cin >> h[i];
vi a(n);
rep(i, n) cin >> a[i];
init(n + 1);
update(0, 0);
rep(i, n) {
int temp = query(0, h[i]);
update(h[i], temp + a[i]);
}
// show2(n,n2);
// show2(MAX_N,2*MAX_N - 1);
int ans = query(0, n + 1);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 983,898 | 983,901 | u850516963 | cpp |
p03176 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<int, pii> pipii;
typedef vector<vector<int>> mati;
typedef vector<vector<double>> matd;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
#define FOR(i, x, y) for (ll i = (ll)x; i < (ll)y; ++i)
#define REP(i, y) FOR(i, 0, y)
template <typename T> void vec_print(vector<T> VEC) {
REP(i, VEC.size()) { cout << VEC[i] << " "; }
cout << "\n";
};
template <typename T>
void mat_print(vector<vector<T>> MAT){
REP(i, MAT.size()){REP(j, MAT[i].size()){cout << MAT[i][j] << " ";
}
cout << "\n";
}
}
;
template <typename CLASS1, typename CLASS2> class HOGE {
public:
CLASS1 key;
CLASS2 value;
HOGE(void) { return; };
HOGE(CLASS1 key, CLASS2 value) {
this->key = key;
this->value = value;
};
~HOGE(void) { return; };
void print(void) {
cout << "key : " << key << ", value : " << value << "\n";
return;
};
bool operator==(const HOGE &obj) { return (this->value == obj.value); };
bool operator<(const HOGE &obj) { return (this->value < obj.value); };
bool operator>(const HOGE &obj) { return (this->value > obj.value); };
};
template <typename CLASS1> class Binary_Index_Tree {
private:
CLASS1 n;
// [1, n]
vector<CLASS1> bit;
public:
Binary_Index_Tree(CLASS1 n_) {
bit.resize(n_ + 1, 0);
n = n_ + 1;
return;
};
~Binary_Index_Tree(void) { return; };
CLASS1 submax(CLASS1 i) {
if (i < -1 || n <= i) {
fprintf(stderr, "Binary_Index_Tree Sum Position Error\n");
exit(0);
}
CLASS1 s = 0;
i += 1;
while (i > 0) {
s = max(s, bit[i]);
i -= i & (-i);
}
return s;
};
void update(CLASS1 i, CLASS1 x) {
if (i < 0 || n <= i) {
fprintf(stderr, "Binary_Index_Tree Update Position Error\n");
exit(0);
}
i += 1;
while (i <= n) {
bit[i] = max(bit[i], x);
i += i & (-i);
}
return;
};
};
constexpr int INF = (1 << 30);
constexpr ll INFLL = 1LL << 62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9) + 7);
int main() {
cin.tie(0); // cut the cin and cout (default, std::flush is performed after
// std::cin)
ios::sync_with_stdio(
false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N;
cin >> N;
Binary_Index_Tree<ll> que(N);
vll dp(N + 1, 0), h(N), a(N);
REP(i, N) cin >> h[i];
REP(i, N) cin >> a[i];
REP(i, N) {
dp[i] = que.submax(h[i] - 1) + a[i];
que.update(h[i], dp[i]);
}
ll ans = 0;
REP(i, N + 1) { ans = max(ans, dp[i]); }
cout << ans << "\n";
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<int, pii> pipii;
typedef vector<vector<int>> mati;
typedef vector<vector<double>> matd;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
#define FOR(i, x, y) for (ll i = (ll)x; i < (ll)y; ++i)
#define REP(i, y) FOR(i, 0, y)
template <typename T> void vec_print(vector<T> VEC) {
REP(i, VEC.size()) { cout << VEC[i] << " "; }
cout << "\n";
};
template <typename T>
void mat_print(vector<vector<T>> MAT){
REP(i, MAT.size()){REP(j, MAT[i].size()){cout << MAT[i][j] << " ";
}
cout << "\n";
}
}
;
template <typename CLASS1, typename CLASS2> class HOGE {
public:
CLASS1 key;
CLASS2 value;
HOGE(void) { return; };
HOGE(CLASS1 key, CLASS2 value) {
this->key = key;
this->value = value;
};
~HOGE(void) { return; };
void print(void) {
cout << "key : " << key << ", value : " << value << "\n";
return;
};
bool operator==(const HOGE &obj) { return (this->value == obj.value); };
bool operator<(const HOGE &obj) { return (this->value < obj.value); };
bool operator>(const HOGE &obj) { return (this->value > obj.value); };
};
template <typename CLASS1> class Binary_Index_Tree {
private:
CLASS1 n;
// [1, n]
vector<CLASS1> bit;
public:
Binary_Index_Tree(CLASS1 n_) {
bit.resize(n_ + 1, 0);
n = n_ + 1;
return;
};
~Binary_Index_Tree(void) { return; };
CLASS1 submax(CLASS1 i) {
if (i < -1 || n <= i) {
fprintf(stderr, "Binary_Index_Tree Sum Position Error\n");
exit(0);
}
CLASS1 s = 0;
i += 1;
while (i > 0) {
s = max(s, bit[i]);
i -= i & (-i);
}
return s;
};
void update(CLASS1 i, CLASS1 x) {
if (i < 0 || n <= i) {
fprintf(stderr, "Binary_Index_Tree Update Position Error\n");
exit(0);
}
i += 1;
while (i <= n) {
bit[i] = max(bit[i], x);
i += i & (-i);
}
return;
};
};
constexpr int INF = (1 << 30);
constexpr ll INFLL = 1LL << 62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9) + 7);
int main() {
cin.tie(0); // cut the cin and cout (default, std::flush is performed after
// std::cin)
ios::sync_with_stdio(
false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N;
cin >> N;
Binary_Index_Tree<ll> que(N + 1);
vll dp(N + 1, 0), h(N), a(N);
REP(i, N) cin >> h[i];
REP(i, N) cin >> a[i];
REP(i, N) {
dp[i] = que.submax(h[i] - 1) + a[i];
que.update(h[i], dp[i]);
}
ll ans = 0;
REP(i, N + 1) { ans = max(ans, dp[i]); }
cout << ans << "\n";
return 0;
}
| [
"assignment.change"
] | 983,905 | 983,906 | u355335354 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)((x).size())
#define int long long
#define M 1000000007
#define MM 998244353
#define fr first
#define sc second
#define pii pair<int, int>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define mem1(a) memset(a, -1, sizeof(a))
#define mem0(a) memset(a, 0, sizeof(a))
#define ppc __builtin_popcount
template <typename T1, typename T2>
std::istream &operator>>(std::istream &in, pair<T1, T2> &a) {
in >> a.fr >> a.sc;
return in;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &out, pair<T1, T2> &a) {
out << a.fr << " " << a.sc;
return out;
}
int n, a[200005], h[200005], dp[200005];
#define SIZE 200005
#define LSB(i) \
((i) & -(i)) // zeroes all the bits except the least significant one
int A[SIZE];
int query(int i) // Returns the sum from index 1 to i
{
int sum = 0;
while (i > 0)
sum = max(sum, A[i]), i -= LSB(i);
return sum;
}
void update(int i, int k) // Adds k to element with index i
{
while (i < SIZE)
A[i] = max(A[i], k), i += LSB(i);
}
void solve() {
cin >> n;
rep(i, 1, n + 1) cin >> h[i];
rep(i, 1, n + 1) cin >> a[i];
dp[1] = a[1];
update(h[1], dp[1]);
rep(i, 2, n + 1) {
dp[i] = a[i] + query(h[i]);
update(h[i], dp[i]);
}
cout << dp[n];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#ifdef SEIVE
seive();
#endif
#ifdef NCR
init();
#endif
#ifdef DSU
cleardsu(MAXDSUSIZE);
#endif
int t = 1;
// cin>>t;
while (t--)
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)((x).size())
#define int long long
#define M 1000000007
#define MM 998244353
#define fr first
#define sc second
#define pii pair<int, int>
#define rep(i, a, b) for (int i = a; i < b; i++)
#define mem1(a) memset(a, -1, sizeof(a))
#define mem0(a) memset(a, 0, sizeof(a))
#define ppc __builtin_popcount
template <typename T1, typename T2>
std::istream &operator>>(std::istream &in, pair<T1, T2> &a) {
in >> a.fr >> a.sc;
return in;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &out, pair<T1, T2> &a) {
out << a.fr << " " << a.sc;
return out;
}
int n, a[200005], h[200005], dp[200005];
#define SIZE 200005
#define LSB(i) \
((i) & -(i)) // zeroes all the bits except the least significant one
int A[SIZE];
int query(int i) // Returns the sum from index 1 to i
{
int sum = 0;
while (i > 0)
sum = max(sum, A[i]), i -= LSB(i);
return sum;
}
void update(int i, int k) // Adds k to element with index i
{
while (i < SIZE)
A[i] = max(A[i], k), i += LSB(i);
}
void solve() {
cin >> n;
rep(i, 1, n + 1) cin >> h[i];
rep(i, 1, n + 1) cin >> a[i];
dp[1] = a[1];
update(h[1], dp[1]);
rep(i, 2, n + 1) {
dp[i] = a[i] + query(h[i]);
update(h[i], dp[i]);
}
cout << query(n);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#ifdef SEIVE
seive();
#endif
#ifdef NCR
init();
#endif
#ifdef DSU
cleardsu(MAXDSUSIZE);
#endif
int t = 1;
// cin>>t;
while (t--)
solve();
return 0;
}
| [
"io.output.change"
] | 983,911 | 983,912 | u593540285 | cpp |
p03176 | #pragma GCC optimize("O3")
#define _CRT_SECURE_NO_WARNINGS
#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 M 1000000007
#define M2 998244353
#define ll long long
#define pll pair<long, long>
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define REPI(i, a, b) for (ll i = b - 1; i >= a; i--)
#define ff first
#define ss second
#define pb push_back
#define db pop_back
#define mp make_pair
#define mt make_tuple
#define g(a, b) get<a>(b)
#define INF (ll)1e18 + 100
#define vl vector<ll>
#define vi vector<int>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define o_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define o_setll \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
// member functions :
// 1. order_of_key(k) : number of elements strictly lesser than k
// 2. find_by_order(k) : k-th element in the set
/*ll modI(ll a, ll m);
ll gcd(ll a, ll b);
ll powM(ll x, unsigned ll y, unsigned ll m);
void pairsort(int a[], int b[], int n);
void pairsortll(ll a[],ll b[],ll n);
ll logint(ll x,ll y);
ll gcd(ll x,ll y)
{
if(x==0) return y;
return gcd(y%x,x);
}
ll powM(ll x,ll y,ll m)
{
if(y==0) return 1;
ll p=powM(x,y/2,m)%m;
p=(p*p)%m;
return (y%2==0)?p:(x*p)%m;
}
ll modI(ll a, ll m)
{
return powM(a, m-2, m);
}
void pairsort(int a[],int b[],int n)
{
pair<int,int> v[n];
REP(i,0,n)
{
v[i].ff=a[i];
v[i].ss=b[i];
}
sort(v,v+n);
REP(i,0,n)
{
a[i]=v[i].ff;
b[i]=v[i].ss;
}
}
void pairsortll(ll a[],ll b[],ll n)
{
pair<ll,ll> v[n];
REP(i,0,n)
{
v[i].ff=a[i];
v[i].ss=b[i];
}
sort(v,v+n);
REP(i,0,n)
{
a[i]=v[i].ff;
b[i]=v[i].ss;
}
}
ll logint(ll x,ll y)
{
ll ans=0;
ll a=1;
for(ll i=0;i<=x;i++)
{
if(x<a)
{
return ans;
}
ans++;
a*=y;
}
return -1;
}*/
const int N = 2e5 + 5;
ll n;
vl a, h;
ll ans = 0;
ll seg[4 * N];
ll query(ll l, ll r, ll v, ll ql, ll qr) {
if (ql > r || qr < l) {
return 0;
}
if (ql <= l && qr >= r) {
return seg[v];
}
ll mid = (l + r) / 2;
return max(query(l, mid, 2 * v, ql, qr),
query(mid + 1, r, 2 * v + 1, ql, qr));
}
void update(ll l, ll r, ll v, ll pos, ll val) {
if (l == r) {
seg[v] = max(seg[v], val);
return;
}
ll mid = (l + r) / 2;
if (pos <= mid) {
update(l, mid, 2 * v, pos, val);
} else {
update(mid + 1, r, 2 * v + 1, pos, val);
}
seg[v] = max(seg[2 * v], seg[2 * v + 1]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// Hey, You
// Don't practise these
// easy questions.
cin >> n;
REP(i, 1, n + 1) {
ll x;
cin >> x;
h.pb(x);
}
REP(i, 1, n + 1) {
ll x;
cin >> x;
a.pb(x);
}
// build(1,n,1);
// dp.insert({h[0],a[0]});
// ans = max(ans, a[0]);
REP(i, 1, n + 1) {
ll z = query(1, n, 1, 1, h[i] - 1);
ans = max(ans, z + a[i]);
update(1, n, 1, h[i], z + a[i]);
}
cout << ans;
} | #pragma GCC optimize("O3")
#define _CRT_SECURE_NO_WARNINGS
#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 M 1000000007
#define M2 998244353
#define ll long long
#define pll pair<long, long>
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define REPI(i, a, b) for (ll i = b - 1; i >= a; i--)
#define ff first
#define ss second
#define pb push_back
#define db pop_back
#define mp make_pair
#define mt make_tuple
#define g(a, b) get<a>(b)
#define INF (ll)1e18 + 100
#define vl vector<ll>
#define vi vector<int>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define o_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define o_setll \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
// member functions :
// 1. order_of_key(k) : number of elements strictly lesser than k
// 2. find_by_order(k) : k-th element in the set
/*ll modI(ll a, ll m);
ll gcd(ll a, ll b);
ll powM(ll x, unsigned ll y, unsigned ll m);
void pairsort(int a[], int b[], int n);
void pairsortll(ll a[],ll b[],ll n);
ll logint(ll x,ll y);
ll gcd(ll x,ll y)
{
if(x==0) return y;
return gcd(y%x,x);
}
ll powM(ll x,ll y,ll m)
{
if(y==0) return 1;
ll p=powM(x,y/2,m)%m;
p=(p*p)%m;
return (y%2==0)?p:(x*p)%m;
}
ll modI(ll a, ll m)
{
return powM(a, m-2, m);
}
void pairsort(int a[],int b[],int n)
{
pair<int,int> v[n];
REP(i,0,n)
{
v[i].ff=a[i];
v[i].ss=b[i];
}
sort(v,v+n);
REP(i,0,n)
{
a[i]=v[i].ff;
b[i]=v[i].ss;
}
}
void pairsortll(ll a[],ll b[],ll n)
{
pair<ll,ll> v[n];
REP(i,0,n)
{
v[i].ff=a[i];
v[i].ss=b[i];
}
sort(v,v+n);
REP(i,0,n)
{
a[i]=v[i].ff;
b[i]=v[i].ss;
}
}
ll logint(ll x,ll y)
{
ll ans=0;
ll a=1;
for(ll i=0;i<=x;i++)
{
if(x<a)
{
return ans;
}
ans++;
a*=y;
}
return -1;
}*/
const int N = 2e5 + 5;
ll n;
vl a, h;
ll ans = 0;
ll seg[4 * N];
ll query(ll l, ll r, ll v, ll ql, ll qr) {
if (ql > r || qr < l) {
return 0;
}
if (ql <= l && qr >= r) {
return seg[v];
}
ll mid = (l + r) / 2;
return max(query(l, mid, 2 * v, ql, qr),
query(mid + 1, r, 2 * v + 1, ql, qr));
}
void update(ll l, ll r, ll v, ll pos, ll val) {
if (l == r) {
seg[v] = max(seg[v], val);
return;
}
ll mid = (l + r) / 2;
if (pos <= mid) {
update(l, mid, 2 * v, pos, val);
} else {
update(mid + 1, r, 2 * v + 1, pos, val);
}
seg[v] = max(seg[2 * v], seg[2 * v + 1]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// Hey, You
// Don't practise these
// easy questions.
cin >> n;
REP(i, 1, n + 1) {
ll x;
cin >> x;
h.pb(x);
}
REP(i, 1, n + 1) {
ll x;
cin >> x;
a.pb(x);
}
// build(1,n,1);
// dp.insert({h[0],a[0]});
// ans = max(ans, a[0]);
REP(i, 0, n) {
ll z = query(1, n, 1, 1, h[i] - 1);
ans = max(ans, z + a[i]);
update(1, n, 1, h[i], z + a[i]);
}
cout << ans;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.remove"
] | 983,933 | 983,934 | u065898443 | cpp |
p03176 | // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << ends << H;
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 2e5 + 5;
int H[N];
ll FEN[N];
void Add(int p, ll x) {
for (p++; p < N; p += p & -p)
FEN[p] = max(FEN[p], x);
}
ll Get(int p) {
ll res = 0;
for (; p > 0; p -= p & -p)
res = max(res, FEN[p]);
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> H[i], H[i]--;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x += Get(H[i]);
Add(H[i], x);
}
cout << Get(n) << endl;
return 0;
}
| // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << ends << H;
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 2e5 + 5;
int H[N];
ll FEN[N];
void Add(int p, ll x) {
for (p++; p < N; p += p & -p)
FEN[p] = max(FEN[p], x);
}
ll Get(int p) {
ll res = 0;
for (; p > 0; p -= p & -p)
res = max(res, FEN[p]);
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> H[i], H[i]--;
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
x += Get(H[i]);
Add(H[i], x);
}
cout << Get(n) << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 983,948 | 983,949 | u379382721 | cpp |
p03176 | // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << ends << H;
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 2e5 + 5;
int H[N], FEN[N];
void Add(int p, int x) {
for (p++; p < N; p += p & -p)
FEN[p] = max(FEN[p], x);
}
int Get(int p) {
int res = 0;
for (; p > 0; p -= p & -p)
res = max(res, FEN[p]);
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> H[i], H[i]--;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x += Get(H[i]);
Add(H[i], x);
}
cout << Get(n) << endl;
return 0;
}
| // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << ends << H;
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 2e5 + 5;
int H[N];
ll FEN[N];
void Add(int p, ll x) {
for (p++; p < N; p += p & -p)
FEN[p] = max(FEN[p], x);
}
ll Get(int p) {
ll res = 0;
for (; p > 0; p -= p & -p)
res = max(res, FEN[p]);
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> H[i], H[i]--;
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
x += Get(H[i]);
Add(H[i], x);
}
cout << Get(n) << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 983,950 | 983,949 | u379382721 | cpp |
p03176 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int N;
int dat[2000000];
void init(int n) {
N = 1;
while (N < n)
N *= 2;
for (int i = 0; i < 2 * N; i++)
dat[i] = 0;
}
void update(int i, int x) {
i += N - 1;
dat[i] = max(dat[i], x);
while (i > 0) {
i = (i - 1) / 2;
dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
ll query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
ll vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
ll query(int a, int b) { return query(a, b, 0, 0, N); }
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
ll n;
cin >> n;
ll a[n], h[n];
init(n + 1);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
ll ret = query(0, h[i]);
// cerr << i << " " << ret << endl;
update(h[i], ret + a[i]);
}
ll ans = query(0, n + 1);
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int N;
ll dat[2000000];
void init(int n) {
N = 1;
while (N < n)
N *= 2;
for (int i = 0; i < 2 * N; i++)
dat[i] = 0;
}
void update(int i, ll x) {
i += N - 1;
dat[i] = max(dat[i], x);
while (i > 0) {
i = (i - 1) / 2;
dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
ll query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
ll vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
ll query(int a, int b) { return query(a, b, 0, 0, N); }
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
ll n;
cin >> n;
ll a[n], h[n];
init(n + 1);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
ll ret = query(0, h[i]);
// cerr << i << " " << ret << endl;
update(h[i], ret + a[i]);
}
ll ans = query(0, n + 1);
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 983,966 | 983,967 | u676029460 | cpp |
p03176 | //#include <tourist>
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
const int MOD = 1000000007;
typedef long long ll;
typedef pair<ll, ll> p;
const ll INF = (1 << 28);
const ll dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const ll Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
// setprecision(15)有効数字15桁
//-std=c++14
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
struct edge {
ll to, cost;
};
vector<ll> value; // ノードの値を持つ配列
ll N; // 葉の数
void update(ll i, ll x) {
// i 番目の葉の値を x に変える
i += N - 1; // i 番目の葉のノード番号
value[i] = x;
while (i > 0) {
i = (i - 1) / 2; // ノード i の親ノードの番号に変える
value[i] = max(value[i * 2 + 1],
value[i * 2 + 2]); // 左右の子の min を計算しなおす
}
}
ll query(ll a, ll b, ll k, ll l, ll r) {
// [a, b) の区間に対するクエリについて
// ノード k （区間 [l, r) 担当）が答える
if (r <= a || b <= l)
return 0; // 区間が被らない場合は INF を返す
if (a <= l && r <= b)
return value[k]; // ノード k の担当範囲がクエリ区間 [a, b)
// に完全に含まれる
else {
ll c1 = query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子に値を聞く
ll c2 = query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子に値を聞く
return max(c1, c2); // 左右の子の値の min を取る
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll ans = 0;
vector<ll> h, a;
N = 1;
while (N < n)
N *= 2; // 葉の数を計算（n以上の最小の2冪数）
value = vector<ll>(2 * N - 1, 0);
for (ll i = 0; i < n; i++) {
ll s;
cin >> s;
h.push_back(s);
}
for (ll i = 0; i < n; i++) {
ll s;
cin >> s;
a.push_back(s);
}
for (ll i = 0; i < n; i++) {
ll sum = query(0, h[i], 0, 0, N);
// cout<<sum<<"\n";
ans = max(sum + a[i], ans);
update(h[i], sum + a[i]);
}
cout << ans << "\n";
}
| //#include <tourist>
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
const int MOD = 1000000007;
typedef long long ll;
typedef pair<ll, ll> p;
const ll INF = (1 << 28);
const ll dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const ll Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
// setprecision(15)有効数字15桁
//-std=c++14
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
struct edge {
ll to, cost;
};
vector<ll> value; // ノードの値を持つ配列
ll N; // 葉の数
void update(ll i, ll x) {
// i 番目の葉の値を x に変える
i += N - 1; // i 番目の葉のノード番号
value[i] = x;
while (i > 0) {
i = (i - 1) / 2; // ノード i の親ノードの番号に変える
value[i] = max(value[i * 2 + 1],
value[i * 2 + 2]); // 左右の子の min を計算しなおす
}
}
ll query(ll a, ll b, ll k, ll l, ll r) {
// [a, b) の区間に対するクエリについて
// ノード k （区間 [l, r) 担当）が答える
if (r <= a || b <= l)
return 0; // 区間が被らない場合は INF を返す
if (a <= l && r <= b)
return value[k]; // ノード k の担当範囲がクエリ区間 [a, b)
// に完全に含まれる
else {
ll c1 = query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子に値を聞く
ll c2 = query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子に値を聞く
return max(c1, c2); // 左右の子の値の min を取る
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll ans = 0;
vector<ll> h, a;
N = 1;
while (N <= n)
N *= 2; // 葉の数を計算（n以上の最小の2冪数）
value = vector<ll>(2 * N - 1, 0);
for (ll i = 0; i < n; i++) {
ll s;
cin >> s;
h.push_back(s);
}
for (ll i = 0; i < n; i++) {
ll s;
cin >> s;
a.push_back(s);
}
for (ll i = 0; i < n; i++) {
ll sum = query(0, h[i], 0, 0, N);
// cout<<sum<<"\n";
ans = max(sum + a[i], ans);
update(h[i], sum + a[i]);
}
cout << ans << "\n";
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 983,968 | 983,969 | u155416173 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
const ll inf = 1LL << 60;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, int val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
ll getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
ll vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
rep(i, n) {
ll tmp = seg.getmax(0, h[i]);
seg.update(h[i], tmp + a[i]);
}
cout << seg.getmax(0, n + 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
const ll inf = 1LL << 60;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
ll getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
ll vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
rep(i, n) {
ll tmp = seg.getmax(0, h[i]);
seg.update(h[i], tmp + a[i]);
}
cout << seg.getmax(0, n + 1) << endl;
return 0;
}
| [] | 983,984 | 983,985 | u052332717 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
const ll inf = 1LL << 60;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, int val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
ll getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
int vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
rep(i, n) {
ll tmp = seg.getmax(0, h[i]);
seg.update(h[i], tmp + a[i]);
}
cout << seg.getmax(0, n + 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
const ll inf = 1LL << 60;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
ll getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
ll vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
rep(i, n) {
ll tmp = seg.getmax(0, h[i]);
seg.update(h[i], tmp + a[i]);
}
cout << seg.getmax(0, n + 1) << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 983,986 | 983,985 | u052332717 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
const ll inf = 1LL << 60;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, int val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
int getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
int vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
rep(i, n) {
ll tmp = seg.getmax(0, h[i]);
seg.update(h[i], tmp + a[i]);
}
cout << seg.getmax(0, n + 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
const ll inf = 1LL << 60;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
ll getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
ll vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
rep(i, n) {
ll tmp = seg.getmax(0, h[i]);
seg.update(h[i], tmp + a[i]);
}
cout << seg.getmax(0, n + 1) << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 983,987 | 983,985 | u052332717 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
ll power(ll x, ll n) {
if (n == 0)
return 1;
ll res = power(x, n / 2);
if (n % 2 == 0)
return res * res;
else
return res * res * x;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
typedef tuple<ll, ll, ll> T;
const ll inf = 1LL << 59;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, int val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
int getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
int vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
for (int i = 0; i < n; ++i)
cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
for (int i = 0; i < n; ++i) {
ll maxv = seg.getmax(0, h[i]);
seg.update(h[i], maxv + a[i]);
}
ll ans = seg.getmax(0, n + 1);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
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;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
詰まった時に、別の分野の問題として考え直す（これdpでは？、グラフとしてみればいいのでは？）
多くの問題はパターンマッチだが、パターンに落とし込むまでが難しく、そのための訓練としてわからない問題をあれこれ色々な角度から考察してみるのではないか
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
ll power(ll x, ll n) {
if (n == 0)
return 1;
ll res = power(x, n / 2);
if (n % 2 == 0)
return res * res;
else
return res * res * x;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
typedef tuple<ll, ll, ll> T;
const ll inf = 1LL << 59;
struct SegmentTree {
private:
int n; // セグ木の葉の数, つまり２冪になっており, 全体の要素数は2*n-1
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1;
while (n < sz)
n *= 2;
node.resize(2 * n - 1, 0);
for (int i = 0; i < sz; ++i)
node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i)
node[i] = max(node[2 * i + 1], node[2 * i + 2]);
}
// k番目(0-indexed)をvalに変更
void update(int x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = max(node[2 * x + 1], node[2 * x + 2]);
}
}
// [a,b)の最小値を求める
// kは接点の番号、l、rはその接点が[l, r)に対応していることを表す
// 外からはgetmin(a, b, 0, 0, n)と呼ぶ
ll getmax(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
// [a, b)と[l, r)が交差していなければinfを返す
if (r <= a || b <= l)
return 0;
// [a,b) ⊃ [l, r)ならば、この接点の値
if (a <= l && r <= b)
return node[k];
// そうでなければ二つの子の最小値
ll vl = getmax(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = getmax(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> h(n), a(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
for (int i = 0; i < n; ++i)
cin >> a[i];
SegmentTree seg(vector<ll>(n + 1, 0));
for (int i = 0; i < n; ++i) {
ll maxv = seg.getmax(0, h[i]);
seg.update(h[i], maxv + a[i]);
}
ll ans = seg.getmax(0, n + 1);
cout << ans << '\n';
return 0;
} | [
"variable_declaration.type.change"
] | 983,988 | 983,989 | u052332717 | cpp |
p03176 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#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 long long ul;
typedef unsigned int ui;
typedef long double ld;
const int inf = 1e9 + 7;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
#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<int, int> P;
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
#define debug(x) cout << #x << " = " << (x) << endl;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//#define int long long
template <typename T> struct SegmentTree {
private:
int n;
T E;
vector<T> node;
inline void updatef(T &x, T &y) {
x = y;
// x += y;
// x = max(x,y);
// x = min(x,y);
}
inline T queryf(T &x, T &y) {
// return min(x,y);
// return x+y;
return max(x, y);
}
public:
SegmentTree(int sz, T E_) : E(E_) {
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
}
SegmentTree(vector<T> &A, T E_) : E(E_) {
int sz = A.size();
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
rep(i, sz) node[i + n - 1] = A[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int k, T x) {
k += n - 1;
updatef(node[k], x);
while (k > 0) {
k = (k - 1) / 2;
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)での値を返す
T get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return E;
if (a <= l && r <= b)
return node[k];
T xl = get(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
void solve() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
vector<ll> a(n);
rep(i, n) { cin >> a[i]; }
SegmentTree<ll> sg(n + 5, 0);
rep(i, n) {
ll tmp = sg.get(0, h[i]);
sg.update(h[i], tmp + a[i]); //更新は各々1回だけ
}
cout << sg.get(0, n) << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(10);
// init();
solve();
// cout << "finish" << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#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 long long ul;
typedef unsigned int ui;
typedef long double ld;
const int inf = 1e9 + 7;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
#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<int, int> P;
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
#define debug(x) cout << #x << " = " << (x) << endl;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//#define int long long
template <typename T> struct SegmentTree {
private:
int n;
T E;
vector<T> node;
inline void updatef(T &x, T &y) {
x = y;
// x += y;
// x = max(x,y);
// x = min(x,y);
}
inline T queryf(T &x, T &y) {
// return min(x,y);
// return x+y;
return max(x, y);
}
public:
SegmentTree(int sz, T E_) : E(E_) {
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
}
SegmentTree(vector<T> &A, T E_) : E(E_) {
int sz = A.size();
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
rep(i, sz) node[i + n - 1] = A[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int k, T x) {
k += n - 1;
updatef(node[k], x);
while (k > 0) {
k = (k - 1) / 2;
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)での値を返す
T get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return E;
if (a <= l && r <= b)
return node[k];
T xl = get(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
void solve() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
vector<ll> a(n);
rep(i, n) { cin >> a[i]; }
SegmentTree<ll> sg(n + 5, 0);
rep(i, n) {
ll tmp = sg.get(0, h[i]);
sg.update(h[i], tmp + a[i]); //更新は各々1回だけ
}
cout << sg.get(0, n + 1) << endl; //範囲に注意
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(10);
// init();
solve();
// cout << "finish" << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 984,005 | 984,006 | u508571192 | cpp |
p03176 | #include <bits/stdc++.h>
// range maximum query segment tree;
#define ll long long int
using namespace std;
ll tree[800001] = {0};
ll query(int tidx, int lo, int hi, int i, int j) {
if (lo > j || hi < i)
return 0;
if (i <= lo && hi <= j)
return tree[tidx];
int mid = (lo + hi) / 2;
// if(i > mid){
// return query(2*tidx+2,mid+1,hi,i,j);
// }
// else if(j<=mid){
// return query(2*tidx+1,lo,mid,i,j);
// }
return max(query(2 * tidx + 1, lo, mid, i, j),
query(2 * tidx + 2, mid + 1, hi, i, j));
}
void update(int tidx, int lo, int hi, int i, ll val) {
if (lo == hi) {
tree[tidx] = val;
return;
}
int mid = (lo + hi) / 2;
if (i > mid) {
update(2 * tidx + 2, mid + 1, hi, i, val);
} else {
update(2 * tidx + 1, lo, mid, i, val);
}
tree[tidx] = max(tree[2 * tidx + 1], tree[2 * tidx + 2]);
}
int main() {
int n;
cin >> n;
vector<int> arr(n, 0);
vector<ll> beauty(n, 0);
int maximum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
maximum = max(maximum, arr[i]);
}
for (int i = 0; i < n; i++)
cin >> beauty[i];
for (int i = 0; i < n; i++) {
ll temp = beauty[i] + query(0, 0, 800000, 0, arr[i] - 1);
// cout << temp << " ";
update(0, 0, 800000, arr[i], temp);
}
cout << query(0, 0, 800000, 0, maximum) << endl;
return 0;
}
| #include <bits/stdc++.h>
// range maximum query segment tree;
#define ll long long int
using namespace std;
ll tree[800005] = {0};
ll query(int tidx, int lo, int hi, int i, int j) {
if (lo > j || hi < i)
return 0;
if (i <= lo && hi <= j)
return tree[tidx];
int mid = (lo + hi) / 2;
// if(i > mid){
// return query(2*tidx+2,mid+1,hi,i,j);
// }
// else if(j<=mid){
// return query(2*tidx+1,lo,mid,i,j);
// }
return max(query(2 * tidx + 1, lo, mid, i, j),
query(2 * tidx + 2, mid + 1, hi, i, j));
}
void update(int tidx, int lo, int hi, int i, ll val) {
if (lo == hi) {
tree[tidx] = val;
return;
}
int mid = (lo + hi) / 2;
if (i > mid) {
update(2 * tidx + 2, mid + 1, hi, i, val);
} else {
update(2 * tidx + 1, lo, mid, i, val);
}
tree[tidx] = max(tree[2 * tidx + 1], tree[2 * tidx + 2]);
}
int main() {
int n;
cin >> n;
vector<int> arr(n, 0);
vector<ll> beauty(n, 0);
int maximum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
maximum = max(maximum, arr[i]);
}
for (int i = 0; i < n; i++)
cin >> beauty[i];
for (int i = 0; i < n; i++) {
ll temp = beauty[i] + query(0, 0, 200000, 0, arr[i] - 1);
// cout << temp << " ";
update(0, 0, 200000, arr[i], temp);
}
cout << query(0, 0, 200000, 0, maximum) << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 984,024 | 984,025 | u984659580 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
long long t[900000];
long long maxa = 0;
void update(int x, long long val, int tl, int tr, int v) {
if (tl == tr) {
t[v] = max(t[v], val);
return;
}
int g = tl + (tr - tl) / 2;
if (g >= x) {
update(x, val, tl, g, 2 * v);
} else {
update(x, val, g + 1, tr, 2 * v + 1);
}
t[v] = max(t[v * 2], t[2 * v + 1]);
}
long long query(int x, int tl, int tr, int v) {
if (tl > x) {
return 0;
}
if (tl >= 0 && tr <= x) {
return t[v];
}
int g = tl + (tr - tl) / 2;
return max(query(x, tl, g, 2 * v), query(x, g + 1, tr, 2 * v + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long h[n], a[n];
vector<long long> temp;
for (int i = 0; i < n; i++) {
cin >> h[i];
temp.push_back(h[i]);
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(temp.begin(), temp.end());
int idx[n];
for (int i = 0; i < n; i++) {
idx[i] = lower_bound(temp.begin(), temp.end(), h[i]) - temp.begin();
}
memset(t, 0, sizeof(t));
for (int i = 0; i < n; i++) {
int l = idx[i];
if (l == 0) {
maxa = max(maxa, a[i]);
update(l, a[i], 0, n - 1, 1);
} else {
long long f = query(i - 1, 0, n - 1, 1);
maxa = max(maxa, f + a[i]);
update(l, f + a[i], 0, n - 1, 1);
}
}
cout << maxa;
} | #include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
long long t[900000];
long long maxa = 0;
void update(int x, long long val, int tl, int tr, int v) {
if (tl == tr) {
t[v] = max(t[v], val);
return;
}
int g = tl + (tr - tl) / 2;
if (g >= x) {
update(x, val, tl, g, 2 * v);
} else {
update(x, val, g + 1, tr, 2 * v + 1);
}
t[v] = max(t[v * 2], t[2 * v + 1]);
}
long long query(int x, int tl, int tr, int v) {
if (tl > x) {
return 0;
}
if (tl >= 0 && tr <= x) {
return t[v];
}
int g = tl + (tr - tl) / 2;
return max(query(x, tl, g, 2 * v), query(x, g + 1, tr, 2 * v + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long h[n], a[n];
vector<long long> temp;
for (int i = 0; i < n; i++) {
cin >> h[i];
temp.push_back(h[i]);
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(temp.begin(), temp.end());
int idx[n];
for (int i = 0; i < n; i++) {
idx[i] = lower_bound(temp.begin(), temp.end(), h[i]) - temp.begin();
}
memset(t, 0, sizeof(t));
for (int i = 0; i < n; i++) {
int l = idx[i];
// cout<<l<<" ";
if (l == 0) {
maxa = max(maxa, a[i]);
update(l, a[i], 0, n - 1, 1);
} else {
long long f = query(l - 1, 0, n - 1, 1);
maxa = max(maxa, f + a[i]);
update(l, f + a[i], 0, n - 1, 1);
}
}
cout << maxa;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 984,034 | 984,035 | u203719754 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define mod 1000000007
int main() {
int n;
cin >> n;
lli h[n], cost[n];
for (int i = 0; i < n; i++)
cin >> h[i];
for (int j = 0; j < n; j++)
cin >> cost[j];
vector<lli> dp(n + 1);
int base = 1;
while (base <= n)
base *= 2;
lli tree[2 * base];
for (int i = 0; i < n; i++) {
lli mx = 0;
int index = h[i] + base;
while (index > 1) {
if (index % 2 == 1)
mx = max(mx, tree[index - 1]);
index /= 2;
}
dp[h[i]] = cost[i] + mx;
for (int index = h[i] + base; index >= 1; index /= 2) {
tree[index] = max(tree[index], dp[h[i]]);
}
/*for(int j=0;j<h[i];j++)
{
dp[h[i]]=max(dp[h[i]],dp[j]+cost[i]);
}*/
}
lli mx = INT_MIN;
for (int i = 0; i <= n; i++)
mx = max(mx, dp[i]);
cout << mx << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define mod 1000000007
int main() {
int n;
cin >> n;
lli h[n], cost[n];
for (int i = 0; i < n; i++)
cin >> h[i];
for (int j = 0; j < n; j++)
cin >> cost[j];
vector<lli> dp(n + 1);
int base = 1;
while (base <= n)
base *= 2;
vector<lli> tree(2 * base);
for (int i = 0; i < n; i++) {
lli mx = 0;
int index = h[i] + base;
while (index > 1) {
if (index % 2 == 1)
mx = max(mx, tree[index - 1]);
index /= 2;
}
dp[h[i]] = cost[i] + mx;
for (int index = h[i] + base; index >= 1; index /= 2) {
tree[index] = max(tree[index], dp[h[i]]);
}
/*for(int j=0;j<h[i];j++)
{
dp[h[i]]=max(dp[h[i]],dp[j]+cost[i]);
}*/
}
lli mx = INT_MIN;
for (int i = 0; i <= n; i++)
mx = max(mx, dp[i]);
cout << mx << endl;
return 0;
} | [] | 984,046 | 984,047 | u194359166 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
int maximum = 0;
struct flower {
long long int height;
long long int beauty;
int pos;
};
bool compare(flower a, flower b) { return a.height > b.height; }
void update_element(long long int *seg_tree, int start, int end, int node,
int pos, long long int value) {
if (start == end) {
seg_tree[node] = value;
} else {
int mid = (start + end) / 2;
if (pos <= mid)
update_element(seg_tree, start, mid, 2 * node, pos, value);
else
update_element(seg_tree, mid + 1, end, 2 * node + 1, pos, value);
seg_tree[node] = max(seg_tree[2 * node], seg_tree[2 * node + 1]);
}
}
long long int sum(long long int *seg_tree, int start, int end, int node,
int left, int right) {
if (right < start || left > end)
return 0;
else if (left <= start && end <= right)
return seg_tree[node];
else {
int mid = (start + end) / 2;
return max(sum(seg_tree, start, mid, 2 * node, left, right),
sum(seg_tree, mid + 1, end, 2 * node + 1, left, right));
}
}
void do_my_job(long long int *seg_tree, int start, int end, int node) {
if (start == end) {
if (maximum < seg_tree[node]) {
maximum = seg_tree[node];
}
// cout<<seg_tree[node]<<" "<<start<<endl;
} else {
int mid = (start + end) / 2;
do_my_job(seg_tree, start, mid, 2 * node);
do_my_job(seg_tree, mid + 1, end, 2 * node + 1);
}
}
int main(void) {
int n;
cin >> n;
long long int height[n];
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> height[i];
}
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
flower help[n];
for (int i = 0; i < n; i++) {
help[i].beauty = arr[i];
help[i].height = height[i];
help[i].pos = i + 1;
}
sort(help, help + n, compare);
long long int seg_tree[4 * n] = {0};
for (int i = 0; i < n; i++) {
int start = help[i].pos;
int end = n - 1;
long long int value = sum(seg_tree, 0, n - 1, 1, start, end);
value += help[i].beauty;
// cout<<value<<endl;
update_element(seg_tree, 0, n - 1, 1, help[i].pos - 1, value);
}
do_my_job(seg_tree, 0, n - 1, 1);
cout << maximum << endl;
} | #include <bits/stdc++.h>
using namespace std;
long long int maximum = 0;
struct flower {
long long int height;
long long int beauty;
int pos;
};
bool compare(flower a, flower b) { return a.height > b.height; }
void update_element(long long int *seg_tree, int start, int end, int node,
int pos, long long int value) {
if (start == end) {
seg_tree[node] = value;
} else {
int mid = (start + end) / 2;
if (pos <= mid)
update_element(seg_tree, start, mid, 2 * node, pos, value);
else
update_element(seg_tree, mid + 1, end, 2 * node + 1, pos, value);
seg_tree[node] = max(seg_tree[2 * node], seg_tree[2 * node + 1]);
}
}
long long int sum(long long int *seg_tree, int start, int end, int node,
int left, int right) {
if (right < start || left > end)
return 0;
else if (left <= start && end <= right)
return seg_tree[node];
else {
int mid = (start + end) / 2;
return max(sum(seg_tree, start, mid, 2 * node, left, right),
sum(seg_tree, mid + 1, end, 2 * node + 1, left, right));
}
}
void do_my_job(long long int *seg_tree, int start, int end, int node) {
if (start == end) {
if (maximum < seg_tree[node]) {
maximum = seg_tree[node];
}
// cout<<seg_tree[node]<<" "<<start<<endl;
} else {
int mid = (start + end) / 2;
do_my_job(seg_tree, start, mid, 2 * node);
do_my_job(seg_tree, mid + 1, end, 2 * node + 1);
}
}
int main(void) {
int n;
cin >> n;
long long int height[n];
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> height[i];
}
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
flower help[n];
for (int i = 0; i < n; i++) {
help[i].beauty = arr[i];
help[i].height = height[i];
help[i].pos = i + 1;
}
sort(help, help + n, compare);
long long int seg_tree[4 * n] = {0};
for (int i = 0; i < n; i++) {
int start = help[i].pos;
int end = n - 1;
long long int value = sum(seg_tree, 0, n - 1, 1, start, end);
value += help[i].beauty;
// cout<<value<<endl;
update_element(seg_tree, 0, n - 1, 1, help[i].pos - 1, value);
}
do_my_job(seg_tree, 0, n - 1, 1);
cout << maximum << endl;
} | [
"variable_declaration.type.widen.change"
] | 984,048 | 984,049 | u395033868 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
namespace FastRead {
const int Dim(5000);
char ibuf[Dim];
int ipos, ilen;
char nc() {
if (ipos == ilen) {
ipos = 0;
ilen = fread(ibuf, 1, Dim, stdin);
if (!ilen)
return EOF;
}
return ibuf[ipos++];
}
template <class T> void read(T &x) {
char ch;
int sgn = 1;
while (!isdigit(ch = nc()))
if (ch == '-')
sgn = -1;
x = ch - '0';
while (isdigit(ch = nc()))
x = x * 10 + (ch - '0');
x *= sgn;
}
} // namespace FastRead
using namespace FastRead;
vector<long long> aib;
long long Query(int poz) {
long long ans = 0;
while (poz > 0) {
ans = max(ans, aib[poz]);
poz -= poz & (-poz);
}
return ans;
}
void Update(int poz, long long val) {
while (poz < (int)aib.size()) {
aib[poz] = max(aib[poz], val);
poz += poz & (-poz);
}
}
int main() {
int N;
read(N);
vector<int> h(N), a(N);
for (int i = 0; i < N; ++i)
read(h[i]);
for (int i = 0; i < N; ++i)
read(a[i]);
aib.resize(N + 1);
vector<long long> dp(N + 1);
for (int i = 0; i < N; ++i) {
long long best = Query(h[i] + 1) + a[i];
if (best > dp[h[i]]) {
dp[h[i]] = best;
Update(h[i] + 1, dp[h[i]]);
}
}
long long ans = 0;
for (int i = 0; i <= N; ++i)
ans = max(ans, dp[i]);
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
namespace FastRead {
const int Dim(5000);
char ibuf[Dim];
int ipos, ilen;
char nc() {
if (ipos == ilen) {
ipos = 0;
ilen = fread(ibuf, 1, Dim, stdin);
if (!ilen)
return EOF;
}
return ibuf[ipos++];
}
template <class T> void read(T &x) {
char ch;
int sgn = 1;
while (!isdigit(ch = nc()))
if (ch == '-')
sgn = -1;
x = ch - '0';
while (isdigit(ch = nc()))
x = x * 10 + (ch - '0');
x *= sgn;
}
} // namespace FastRead
using namespace FastRead;
vector<long long> aib;
long long Query(int poz) {
long long ans = 0;
while (poz > 0) {
ans = max(ans, aib[poz]);
poz -= poz & (-poz);
}
return ans;
}
void Update(int poz, long long val) {
while (poz < (int)aib.size()) {
aib[poz] = max(aib[poz], val);
poz += poz & (-poz);
}
}
int main() {
int N;
read(N);
vector<int> h(N), a(N);
for (int i = 0; i < N; ++i)
read(h[i]);
for (int i = 0; i < N; ++i)
read(a[i]);
aib.resize(N + 2);
vector<long long> dp(N + 1);
for (int i = 0; i < N; ++i) {
long long best = Query(h[i] + 1) + a[i];
if (best > dp[h[i]]) {
dp[h[i]] = best;
Update(h[i] + 1, dp[h[i]]);
}
}
long long ans = 0;
for (int i = 0; i <= N; ++i)
ans = max(ans, dp[i]);
cout << ans;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 984,055 | 984,056 | u934482833 | cpp |
p03176 | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n;
scanf("%d", &n);
int base = 1;
while (base <= n) {
base *= 2;
}
vector<ll> dp(n + 1), bit(2 * base);
vector<int> h(n), a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &h[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
int tmp = a[i] + h[i];
ll best = 0;
while (tmp > 1) {
if (tmp % 2 == 1) {
if (bit[tmp - 1] > best) {
best = bit[tmp - 1];
}
}
tmp /= 2;
}
dp[h[i]] = best + a[i];
for (int j = base + h[i]; j >= 1; j /= 2) {
if (dp[h[i]] > bit[j]) {
bit[j] = dp[h[i]];
}
}
}
ll ans = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] > ans) {
ans = dp[i];
}
}
printf("%lld\n", ans);
} | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n;
scanf("%d", &n);
int base = 1;
while (base <= n) {
base *= 2;
}
vector<ll> dp(n + 1), bit(2 * base);
vector<int> h(n), a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &h[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
int tmp = base + h[i];
ll best = 0;
while (tmp > 1) {
if (tmp % 2 == 1) {
if (bit[tmp - 1] > best) {
best = bit[tmp - 1];
}
}
tmp /= 2;
}
dp[h[i]] = best + a[i];
for (int j = base + h[i]; j >= 1; j /= 2) {
if (dp[h[i]] > bit[j]) {
bit[j] = dp[h[i]];
}
}
}
ll ans = 0;
for (int i = 0; i <= n; i++) {
if (dp[i] > ans) {
ans = dp[i];
}
}
printf("%lld\n", ans);
} | [
"expression.operation.binary.change"
] | 984,062 | 984,063 | u064438560 | cpp |
p03176 | #include <bits/stdc++.h>
#define ll long long
#define MAX 200005
using namespace std;
int n;
ll dp[MAX * 4];
ll height[MAX];
ll beauty[MAX];
void build(int idx, int left, int right) {
if (left == right) {
dp[idx] = beauty[left];
return;
}
int mid = (left + right) / 2;
build(idx * 2, left, mid);
build(idx * 2 + 1, mid + 1, right);
dp[idx] = max(dp[idx * 2], dp[idx * 2 + 1]);
}
void update(int idx, int left, int right, int a, ll val) {
if (left > a || right < a) {
return;
}
if (left == right) {
dp[idx] = val;
return;
}
int mid = (left + right) / 2;
update(idx * 2, left, mid, a, val);
update(idx * 2 + 1, mid + 1, right, a, val);
dp[idx] = max(dp[idx * 2], dp[idx * 2 + 1]);
}
ll query(int idx, int left, int right, int a, int b) {
if (left >= a && right <= b) {
return dp[idx];
}
if (left > b || right < a) {
return 0;
}
int mid = (left + right) / 2;
return max(query(idx * 2, left, mid, a, b),
query(idx * 2 + 1, mid + 1, right, a, b));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> height[i];
}
for (int i = 0; i < n; i++) {
cin >> beauty[i];
}
for (int i = 0; i < n; i++) {
int mmax = query(1, 0, n - 1, 0, height[i] - 1);
update(1, 0, n - 1, height[i] - 1, mmax + beauty[i]);
}
cout << query(1, 0, n - 1, 0, n - 1) << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define MAX 200005
using namespace std;
int n;
ll dp[MAX * 4];
ll height[MAX];
ll beauty[MAX];
void build(int idx, int left, int right) {
if (left == right) {
dp[idx] = beauty[left];
return;
}
int mid = (left + right) / 2;
build(idx * 2, left, mid);
build(idx * 2 + 1, mid + 1, right);
dp[idx] = max(dp[idx * 2], dp[idx * 2 + 1]);
}
void update(int idx, int left, int right, int a, ll val) {
if (left > a || right < a) {
return;
}
if (left == right) {
dp[idx] = val;
return;
}
int mid = (left + right) / 2;
update(idx * 2, left, mid, a, val);
update(idx * 2 + 1, mid + 1, right, a, val);
dp[idx] = max(dp[idx * 2], dp[idx * 2 + 1]);
}
ll query(int idx, int left, int right, int a, int b) {
if (left >= a && right <= b) {
return dp[idx];
}
if (left > b || right < a) {
return 0;
}
int mid = (left + right) / 2;
return max(query(idx * 2, left, mid, a, b),
query(idx * 2 + 1, mid + 1, right, a, b));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> height[i];
}
for (int i = 0; i < n; i++) {
cin >> beauty[i];
}
for (int i = 0; i < n; i++) {
ll mmax = query(1, 0, n - 1, 0, height[i] - 1);
update(1, 0, n - 1, height[i] - 1, mmax + beauty[i]);
}
cout << query(1, 0, n - 1, 0, n - 1) << endl;
}
| [
"variable_declaration.type.change"
] | 984,066 | 984,067 | u787597250 | cpp |
p03176 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define INF 0x3f3f3f3f
#define pii pair<int, int>
#define mem(x, a) memset(x, a, sizeof(x))
#define AC ios_base::sync_with_stdio(0), cin.tie(0)
using namespace std;
const int maxn = 2e5 + 50;
int n;
int bit[maxn], a[maxn], h[maxn];
int lowbit(int x) { return x & -x; }
void modify(int x, int val) {
for (int i = x; i <= n; i += lowbit(i)) {
bit[i] = max(val, bit[i]);
}
}
int query(int x) {
int ans = -INF;
for (int i = x; i >= 1; i -= lowbit(i)) {
ans = max(ans, bit[i]);
}
return ans;
}
int main() {
AC;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++) {
int val = query(h[i]) + a[i];
modify(h[i], val);
}
cout << query(n) << "\n";
} | #include <bits/stdc++.h>
#define int long long
#define pb push_back
#define INF 0x3f3f3f3f
#define pii pair<int, int>
#define mem(x, a) memset(x, a, sizeof(x))
#define AC ios_base::sync_with_stdio(0), cin.tie(0)
using namespace std;
const int maxn = 2e5 + 50;
int n;
int bit[maxn], a[maxn], h[maxn];
int lowbit(int x) { return x & -x; }
void modify(int x, int val) {
for (int i = x; i <= n; i += lowbit(i)) {
bit[i] = max(val, bit[i]);
}
}
int query(int x) {
int ans = -INF;
for (int i = x; i >= 1; i -= lowbit(i)) {
ans = max(ans, bit[i]);
}
return ans;
}
main() {
AC;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++) {
int val = query(h[i]) + a[i];
modify(h[i], val);
}
cout << query(n) << "\n";
} | [
"identifier.change",
"function.return_value.remove"
] | 984,074 | 984,075 | u091757191 | cpp |
p03176 | /*
minh(v) 表示达到价值 v 的最低高度，则显然 h 单调递增
minh(0) = 0
遍历完第一个元素 a[i], h[i] 后，minh[1] = (h[i], a[i])
依次遍历下一个元素 k，在 minh 中找到小于 h[k] 的最近 minh[j].h，新组成 (h[k],
minh[j].a + a[k]) 已知 h[k] <= minh[j+1].h， 如果 minh[j].a + a[k] >
minh[j+1].a，则删掉 j+1
需要线段树？红黑树就可以搞定，可以尝试 c++
*/
#include <iostream>
#include <set>
using namespace std;
typedef long long int64;
const int N = 2e5 + 5;
int64 a[N];
int h[N];
struct Node {
int h;
int64 v;
bool operator<(const Node &other) const { return h < other.h; }
friend ostream &operator<<(ostream &out, const Node &node) {
out << "{ " << node.h << ", " << node.v << " }";
return out;
}
};
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
set<Node> s;
s.insert(Node{0, 0});
for (int i = 0; i < n; i++) {
auto it = s.lower_bound(Node{h[i], 0});
auto newV = (--it)->v + a[i];
it++;
auto begin = it, end = it;
for (; end != s.end() && it->v <= newV; end++)
;
s.erase(it, end);
s.insert(Node{h[i], newV});
}
cout << s.rbegin()->v << endl;
return 0;
} | /*
minh(v) 表示达到价值 v 的最低高度，则显然 h 单调递增
minh(0) = 0
遍历完第一个元素 a[i], h[i] 后，minh[1] = (h[i], a[i])
依次遍历下一个元素 k，在 minh 中找到小于 h[k] 的最近 minh[j].h，新组成 (h[k],
minh[j].a + a[k]) 已知 h[k] <= minh[j+1].h， 如果 minh[j].a + a[k] >
minh[j+1].a，则删掉 j+1
需要线段树？红黑树就可以搞定，可以尝试 c++
*/
#include <iostream>
#include <set>
using namespace std;
typedef long long int64;
const int N = 2e5 + 5;
int64 a[N];
int h[N];
struct Node {
int h;
int64 v;
bool operator<(const Node &other) const { return h < other.h; }
friend ostream &operator<<(ostream &out, const Node &node) {
out << "{ " << node.h << ", " << node.v << " }";
return out;
}
};
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
set<Node> s;
s.insert(Node{0, 0});
for (int i = 0; i < n; i++) {
auto it = s.lower_bound(Node{h[i], 0});
auto newV = (--it)->v + a[i];
it++;
auto end = it;
for (; end != s.end() && end->v <= newV; end++)
;
s.erase(it, end);
s.insert(Node{h[i], newV});
}
cout << s.rbegin()->v << endl;
return 0;
} | [
"variable_declaration.remove",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 984,076 | 984,077 | u028014484 | cpp |
p03176 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1e18;
vector<ll> value;
ll N;
void update(ll i, ll x) {
// i 番目の葉の値を x に変える
i += N - 1; // i 番目の葉のノード番号
value[i] = x;
while (i > 0) {
i = (i - 1) / 2; // ノード i の親ノードの番号に変える
value[i] = max(value[i * 2 + 1],
value[i * 2 + 2]); // 左右の子の min を計算しなおす
}
}
ll query(ll a, ll b, ll k, ll l, ll r) {
// [a, b) の区間に対するクエリについて
// ノード k （区間 [l, r) 担当）が答える
// cout<<"a"<<a<<"b"<<b<<"k"<<k<<"l"<<l<<"r"<<r<<endl;
if (r <= a || b <= l)
return 0; // 区間が被らない場合は INF を返す
if (a <= l && r <= b) {
// cout<<"k"<<value[k]<<endl;
return value[k]; // ノード k の担当範囲がクエリ区間 [a, b)
// に完全に含まれる
}
else {
ll c1 = query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子に値を聞く
ll c2 = query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子に値を聞く
// cout<<"c1"<<c1<<"c2"<<c2<<endl;
return max(c1, c2); // 左右の子の値の min を取る
}
}
int main() {
ll n;
cin >> n;
vector<ll> h(n);
vector<ll> a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
N = 1;
while (N < n)
N *= 2;
value = vector<ll>(2 * N - 1, 0);
ll dp1[n + 1];
rep(i, n) {
ll now = query(0, h[i] + 1, 0, 0, N);
update(h[i], now + a[i]);
// cout<<h[i]<<"now"<<now<<"na"<<(now+a[i])<<"i"<<i<<endl;
}
ll ans = 0;
ans = query(0, n + 1, 0, 0, N);
cout << ans;
}
/*
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
using ll = long long;
using namespace std;
ll n;
ll h[200200], a[200200], bit[200200];
ll maxi(ll i){
ll res = 0;
while(i>0){
res = max(res,bit[i]);
i -= i & -i;
}
return res;
}
void update(ll i, ll x){
while(i<=n){
bit[i] = max(bit[i],x);
i += i & -i;
}
}
ll main(){
cin >> n;
rep(i,n) cin >> h[i];
rep(i,n) cin >> a[i];
rep(i,n) update(h[i], a[i] + maxi(h[i]));
cout << maxi(n) << endl;
return 0;
}
*/
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1e18;
vector<ll> value;
ll N;
void update(ll i, ll x) {
// i 番目の葉の値を x に変える
i += N - 1; // i 番目の葉のノード番号
value[i] = x;
while (i > 0) {
i = (i - 1) / 2; // ノード i の親ノードの番号に変える
value[i] = max(value[i * 2 + 1],
value[i * 2 + 2]); // 左右の子の min を計算しなおす
}
}
ll query(ll a, ll b, ll k, ll l, ll r) {
// [a, b) の区間に対するクエリについて
// ノード k （区間 [l, r) 担当）が答える
// cout<<"a"<<a<<"b"<<b<<"k"<<k<<"l"<<l<<"r"<<r<<endl;
if (r <= a || b <= l)
return 0; // 区間が被らない場合は INF を返す
if (a <= l && r <= b) {
// cout<<"k"<<value[k]<<endl;
return value[k]; // ノード k の担当範囲がクエリ区間 [a, b)
// に完全に含まれる
}
else {
ll c1 = query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子に値を聞く
ll c2 = query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子に値を聞く
// cout<<"c1"<<c1<<"c2"<<c2<<endl;
return max(c1, c2); // 左右の子の値の min を取る
}
}
int main() {
ll n;
cin >> n;
vector<ll> h(n);
vector<ll> a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
N = 1;
while (N <= n)
N *= 2;
// cout<<N<<endl;
value = vector<ll>(2 * N - 1, 0);
ll dp1[n + 1];
rep(i, n) {
ll now = query(0, h[i], 0, 0, N);
update(h[i], now + a[i]);
// cout<<h[i]<<"now"<<now<<"na"<<(now+a[i])<<"i"<<i<<endl;
}
ll ans = 0;
ans = query(0, n + 1, 0, 0, N);
cout << ans;
}
/*
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
using ll = long long;
using namespace std;
ll n;
ll h[200200], a[200200], bit[200200];
ll maxi(ll i){
ll res = 0;
while(i>0){
res = max(res,bit[i]);
i -= i & -i;
}
return res;
}
void update(ll i, ll x){
while(i<=n){
bit[i] = max(bit[i],x);
i += i & -i;
}
}
ll main(){
cin >> n;
rep(i,n) cin >> h[i];
rep(i,n) cin >> a[i];
rep(i,n) update(h[i], a[i] + maxi(h[i]));
cout << maxi(n) << endl;
return 0;
}
*/
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"expression.operation.binary.remove"
] | 984,082 | 984,083 | u289381123 | cpp |
p03176 | #include <bits/stdc++.h>
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define int long long
#define endl '\n'
#define pb push_back
#define mp make_pair
#define debug(x) cout << #x << " " << x << endl;
const int mod = 1e12 + 7;
const int MAX = 2e5 + 9;
const double pi = 3.141592653589793238460;
using namespace std;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
bool is_pal(string s) {
return equal(s.begin(), s.begin() + s.size() / 2, s.rbegin()) ? 1 : 0;
}
int power(int x, int y, int res = 1) {
for (; y; y >>= 1LL) {
if (y & 1LL) {
res = res * x;
}
x = x * x;
}
return res;
}
int modInv(int x) { return (power(x, mod - 2) + mod) % mod; }
int fact[MAX], inv[MAX];
void compFact(void) {
fact[0] = fact[1] = inv[1] = inv[0] = 1;
for (int i = 1; i < MAX; i++) {
fact[i] = (fact[i - 1] * i % mod + mod) % mod;
}
}
void compInv(void) {
for (int i = 2; i < MAX; ++i) {
inv[i] = (mod - (mod / i) * inv[mod % i] % mod + mod) % mod;
}
}
int nCr(int n, int r) {
if (n < r || n < 0) {
return 0;
}
return ((((fact[n] % mod) * (inv[fact[n - r]] % mod)) % mod) *
(inv[fact[r]] % mod) +
mod) %
mod;
}
int factMod(int n, int res = 1) {
while (n > 1) {
res = (res * ((n / mod) % 2 ? mod - 1 : 1)) % mod;
for (int i = 2; i <= n % mod; ++i)
res = (res * i) % mod;
n /= mod;
}
return res % mod;
}
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
int lcm(int x, int y) { return (x * y) / __gcd(x, y); }
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int N;
bool under_bound(int x, int y) { return x >= 0 && y <= 0 && x < N && y < N; }
bool prime[MAX];
void SieveOfEratosthenes(int n) {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p < n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
}
multiset<int> A;
vector<pair<int, int>> vp;
void primeFact(int n) {
while (n % 2 == 0) {
A.insert(2);
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
A.insert(i);
n = n / i;
}
}
if (n > 2)
A.insert(n);
}
int spf[MAX];
void SieveOfEuler() {
spf[1] = 1;
for (int i = 2; i < MAX; i++)
spf[i] = i;
for (int i = 4; i < MAX; i += 2)
spf[i] = 2;
for (int i = 3; i * i < MAX; i++) {
if (spf[i] == i) {
for (int j = i * i; j < MAX; j += i)
if (spf[j] == j)
spf[j] = i;
}
}
}
map<pair<int, int>, int> factFreq;
void getFactorization(int x) {
while (x > 1) {
int pt = spf[x], f = 0;
while (x % pt == 0) {
x /= pt;
f++;
factFreq[{pt, f}]++;
}
}
}
bool PTwo(int x) { return x && (!((x - 1))); }
int ans;
vector<int> dp;
map<int, int> candidates;
int getBest(int v) {
auto it = candidates.lower_bound(v);
if (it == candidates.begin()) {
return 0;
}
it--;
return it->second;
}
void insertBest(int v, int best) {
if (candidates[v] >= best) {
return;
}
candidates[v] = best;
auto it = candidates.find(v);
it++;
while (it != candidates.end() && it->second <= best) {
auto now = it;
it++;
candidates.erase(now);
}
}
void solve(void) {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
dp.resize(n);
dp[0] = 1;
candidates[a[0]] = b[0];
for (int i = 1; i < n; i++) {
dp[i] = b[i] + getBest(a[i]);
insertBest(a[i], dp[i]);
}
cout << *max_element(dp.begin(), dp.begin() + n);
}
signed main() {
fio;
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | #include <bits/stdc++.h>
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define int long long
#define endl '\n'
#define pb push_back
#define mp make_pair
#define debug(x) cout << #x << " " << x << endl;
const int mod = 1e12 + 7;
const int MAX = 2e5 + 9;
const double pi = 3.141592653589793238460;
using namespace std;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
bool is_pal(string s) {
return equal(s.begin(), s.begin() + s.size() / 2, s.rbegin()) ? 1 : 0;
}
int power(int x, int y, int res = 1) {
for (; y; y >>= 1LL) {
if (y & 1LL) {
res = res * x;
}
x = x * x;
}
return res;
}
int modInv(int x) { return (power(x, mod - 2) + mod) % mod; }
int fact[MAX], inv[MAX];
void compFact(void) {
fact[0] = fact[1] = inv[1] = inv[0] = 1;
for (int i = 1; i < MAX; i++) {
fact[i] = (fact[i - 1] * i % mod + mod) % mod;
}
}
void compInv(void) {
for (int i = 2; i < MAX; ++i) {
inv[i] = (mod - (mod / i) * inv[mod % i] % mod + mod) % mod;
}
}
int nCr(int n, int r) {
if (n < r || n < 0) {
return 0;
}
return ((((fact[n] % mod) * (inv[fact[n - r]] % mod)) % mod) *
(inv[fact[r]] % mod) +
mod) %
mod;
}
int factMod(int n, int res = 1) {
while (n > 1) {
res = (res * ((n / mod) % 2 ? mod - 1 : 1)) % mod;
for (int i = 2; i <= n % mod; ++i)
res = (res * i) % mod;
n /= mod;
}
return res % mod;
}
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
int lcm(int x, int y) { return (x * y) / __gcd(x, y); }
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int N;
bool under_bound(int x, int y) { return x >= 0 && y <= 0 && x < N && y < N; }
bool prime[MAX];
void SieveOfEratosthenes(int n) {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p < n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
}
multiset<int> A;
vector<pair<int, int>> vp;
void primeFact(int n) {
while (n % 2 == 0) {
A.insert(2);
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
A.insert(i);
n = n / i;
}
}
if (n > 2)
A.insert(n);
}
int spf[MAX];
void SieveOfEuler() {
spf[1] = 1;
for (int i = 2; i < MAX; i++)
spf[i] = i;
for (int i = 4; i < MAX; i += 2)
spf[i] = 2;
for (int i = 3; i * i < MAX; i++) {
if (spf[i] == i) {
for (int j = i * i; j < MAX; j += i)
if (spf[j] == j)
spf[j] = i;
}
}
}
map<pair<int, int>, int> factFreq;
void getFactorization(int x) {
while (x > 1) {
int pt = spf[x], f = 0;
while (x % pt == 0) {
x /= pt;
f++;
factFreq[{pt, f}]++;
}
}
}
bool PTwo(int x) { return x && (!((x - 1))); }
int ans;
vector<int> dp;
map<int, int> candidates;
int getBest(int v) {
auto it = candidates.lower_bound(v);
if (it == candidates.begin()) {
return 0;
}
it--;
return it->second;
}
void insertBest(int v, int best) {
if (candidates[v] >= best) {
return;
}
candidates[v] = best;
auto it = candidates.find(v);
it++;
while (it != candidates.end() && it->second <= best) {
auto now = it;
it++;
candidates.erase(now);
}
}
void solve(void) {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
dp.resize(n);
dp[0] = b[0];
candidates[a[0]] = b[0];
for (int i = 1; i < n; i++) {
dp[i] = b[i] + getBest(a[i]);
insertBest(a[i], dp[i]);
}
cout << *max_element(dp.begin(), dp.begin() + n);
}
signed main() {
fio;
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 984,086 | 984,087 | u702037060 | cpp |
p03176 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll int solve(ll int h[], ll int a[], int n) {
ll dp[n];
map<ll, ll> meaningful;
dp[0] = a[0];
meaningful[h[0]] = dp[0];
ll ans = 0;
for (int i = 1; i < n; i++) {
dp[i] = a[i];
auto it = meaningful.lower_bound(h[i] + 1);
if (it != meaningful.begin()) {
it--;
dp[i] += it->second;
}
meaningful[h[i]] = dp[i];
it = meaningful.upper_bound(h[i]);
while (it != meaningful.end() && it->second <= dp[i]) {
auto temp = it;
temp++;
meaningful.erase(it);
it = temp;
}
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
int n;
cin >> n;
ll int h[n], a[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << solve(h, a, n);
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll int solve(ll int h[], ll int a[], int n) {
ll dp[n];
map<ll, ll> meaningful;
dp[0] = a[0];
meaningful[h[0]] = dp[0];
ll ans = a[0];
for (int i = 1; i < n; i++) {
dp[i] = a[i];
auto it = meaningful.lower_bound(h[i] + 1);
if (it != meaningful.begin()) {
it--;
dp[i] += it->second;
}
meaningful[h[i]] = dp[i];
it = meaningful.upper_bound(h[i]);
while (it != meaningful.end() && it->second <= dp[i]) {
auto temp = it;
temp++;
meaningful.erase(it);
it = temp;
}
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
int n;
cin >> n;
ll int h[n], a[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << solve(h, a, n);
}
| [] | 984,096 | 984,097 | u348267046 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll n, h[200005], b[200005], dp[200005];
int main() {
cin >> n;
int base = 1;
while (base <= n)
base *= 2;
vector<ll> tree(n * 2, 0);
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < n; i++)
cin >> b[i];
for (int i = 0; i < n; i++) {
ll query = base + h[i];
ll yet_best = 0;
while (query > 1) {
if (query % 2)
yet_best = max(yet_best, tree[query - 1]);
query /= 2;
}
dp[h[i]] = yet_best + b[i];
for (int j = base + h[i]; j > 0; j /= 2)
tree[j] = max(tree[j], dp[h[i]]);
}
ll ans = 0;
for (int i = 0; i <= n; i++)
ans = max(ans, dp[i]);
cout << ans << endl;
return (0);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll n, h[200005], b[200005], dp[200005];
int main() {
cin >> n;
int base = 1;
while (base <= n)
base *= 2;
vector<ll> tree(base * 2, 0);
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < n; i++)
cin >> b[i];
for (int i = 0; i < n; i++) {
ll query = base + h[i];
ll yet_best = 0;
while (query > 1) {
if (query % 2)
yet_best = max(yet_best, tree[query - 1]);
query /= 2;
}
dp[h[i]] = yet_best + b[i];
for (int j = base + h[i]; j > 0; j /= 2)
tree[j] = max(tree[j], dp[h[i]]);
}
ll ans = 0;
for (int i = 0; i <= n; i++)
ans = max(ans, dp[i]);
cout << ans << endl;
return (0);
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 984,109 | 984,110 | u681396939 | cpp |
p03176 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long lu;
typedef long double ld;
typedef pair<ll, ll> pr;
typedef vector<ll> v;
typedef vector<vector<ll>> vv;
typedef vector<string> vs;
typedef vector<pair<ll, ll>> vp;
#define in(x, n) \
for (ll i = 0; i < n; i++) \
cin >> x[i]
#define mp make_pair
#define mt make_tuple
#define ld long double
#define f(i, n) for (ll i = 0; i < n; i++)
#define ff(i, n) for (ll i = 1; i <= n; i++)
#define pb push_back
#define aa(s) s.begin(), s.end()
#define sz(x) (ll) x.size()
#define fi first
#define se second
#define mx(a) *(max_element(a.begin(), a.end()))
#define mn(a) *(min_element(a.begin(),a.end())
// #define p 908197
#define p 998244353
#define mod 1000000007
//#define mod 998244353
//#define mod 1000000000
#define ti tuple
//#define mod 998000099999
#define sn struct node
#define MAXN 200001
const v dx = {1, -1, 0, 0};
const v dy = {0, 0, 1, -1};
const v dx1 = {0, 1, -1, 0, 1, 1, -1, -1};
const v dy1 = {1, 0, 0, -1, 1, -1, 1, -1};
const ld PI = 2 * acos(0.0);
ll cel(ll x1, ll y1) {
if ((x1 % y1) == 0)
return x1 / y1;
else
return x1 / y1 + 1;
}
ll power(ll x, ll y) {
ll res = 1; // Initialize result
x = x % mod;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % mod;
// n must be even now
y = y >> 1; // y = y/2
x = (x * x) % mod; // Change x to x^2
}
return res % mod;
}
ll power2(ll x, ll y) {
ll res = 1; // Initialize result
x = x;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// n must be even now
y = y >> 1; // y = y/2
x = (x * x); // Change x to x^2
}
return res;
}
ld power1(ld x, ll y) {
ld res = 1; // Initialize result
// x=x%mod;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// n must be even now
y = y >> 1; // y = y/2
x = (x * x); // Change x to x^2
}
return res;
}
void yes() { cout << "YES\n"; }
void no() { cout << "NO\n"; }
template <typename T> void print_queue(T &q) {
while (!q.empty()) {
std::cout << q.top() << " ";
q.pop();
}
std::cout << '\n';
}
// ll dp[][w]={0};
/*vector<pair<ll,pair<ll,ll>>>v;ll len;
ll dp[37][100002];
ll solve(ll n,ll x,ll y,ll z,ll p)
{
if(n==len)
{
return 1;
}
if(dp[p][n]!=-1)
{
return dp[p][n];
}
ll ans=0;
return dp[p][n]=ans;
}
*/
/*
vector<ll> merge(vector<ll> v1,vector<ll> v2)
{
vector<ll> x;
ll i,j,k,l,m,n,o,p,q,r,s,t;
m=v1.size();i=0;
n=v2.size();j=0;
while(i<m&&j<n)
{
if(v1[i]<v2[j])
{
x.push_back(v1[i]);
i++;
}
else
{
x.push_back(v2[j]);
j++;
}
}
while(i<m)
{
x.push_back(v1[i]);
i++;
}
while(j<n)
{
x.push_back(v2[j]);
j++;
}
return x;
}
vector<ll>sa[1000000];
ll a[1000000];
void build(ll s,ll e,ll i)
{
if(s==e)
{
sa[i].push_back(a[s]);
return;
}
ll m=(s+e)/2;
build(s,m,2*i+1);
build(m+1,e,2*i+2);
sa[i]=merge(sa[2*i+1],sa[2*i+2]);
}
ll query(ll s,ll e,ll l,ll r,ll i,ll x1,ll x2)
{
if(e<l || r<s || s>e)
return 0;
if(s>=l && e<=r)
{
ll v1= upper_bound(sa[i].begin(),sa[i].end(),x1)-sa[i].begin();
// ll v2= lower_bound(sa[i].begin(),sa[i].end(),x2-1)-sa[i].begin();
return v1;
}
ll m=(s+e)/2;
ll ls=query(s,m,l,r,2*i+1,x1,x2);
ll rs=query(m+1,e,l,r,2*i+2,x1,x2);
return ls+rs;
}
*/
// Returns n^(-1) mod p
/*
ll modInverse(ll n)
{
return power1(n, p-2);
}
// Returns nCr % p using Fermat's little
// theorem.
ll fac[500001];
ll nCrModPFermat(ll n, ll r)
{
// Base case
if (r==0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
return (fac[n]* modInverse(fac[r]) % p *
modInverse(fac[n-r]) % p) % p;
}
*/
/*
vector<vector<pair<ll,ll>>>a(100003);
ll par[100003];ll size[100003];
ll find(ll x)
{
while(par[x]!=x)
{
par[x]=par[par[x]];
x=par[x];
}
return x;
}
void union1(ll x,ll y)
{
ll xroot=find(x);
ll yroot=find(y);
if(xroot==yroot)
return;
if(size[xroot]>=size[yroot])
{
par[yroot]=xroot;
size[xroot]+=size[yroot];
} else
{ par[xroot]=yroot;
size[yroot]+=size[xroot];}
}
*/
void gv(v a, ll n) {
f(i, n) {
cin >> a[i];
// cout<<a[i]<<" ";
}
// cout<<"\n";
}
void out(v a, ll n) {
f(i, n) cout << a[i] << " ";
cout << "\n";
}
void sor(v &a, v &b, ll n) {
vector<pair<ll, ll>> v;
f(i, n) {
// cout<<b[i]<<" "<<a[i]<<"\n";
v.push_back(mp(a[i], b[i]));
}
sort(aa(v));
f(i, n) {
a[i] = v[i].first;
b[i] = v[i].second;
}
}
/*ll t;cin>>t;
f(wq,t) {
}
*/
/*
vector<vector<ll> > vec(row);
vector<vector<ll> > vec( n , vector<ll> (m,0));
for(auto i:m2)
*/
// ll dp[101][101][27];
// ll dp[101][100001];ll pre[101][100001];
ll sa[4000000];
// ll sa2[1000000];
ll a[1000000];
void build(ll s, ll e, ll i) {
if (s == e) {
sa[i] = a[s];
return;
}
ll m = (s + e) / 2;
build(s, m, 2 * i + 1);
build(m + 1, e, 2 * i + 2);
sa[i] = max(sa[2 * i + 1], sa[2 * i + 2]);
}
void update(ll s, ll e, ll j, ll i, ll v) {
if (s == e) {
a[s] = v;
sa[i] = v;
return;
}
ll m = (s + e) / 2;
if (j <= m) {
update(s, m, j, 2 * i + 1, v);
} else
update(m + 1, e, j, 2 * i + 2, v);
sa[i] = max(sa[2 * i + 1], sa[2 * i + 2]);
}
ll query(ll s, ll e, ll l, ll r, ll i) {
if (s >= l && e <= r) {
return (sa[i]);
}
if (e < l || r < s) {
return -INT_MAX;
}
ll m = (s + e) / 2;
ll ls = query(s, m, l, r, 2 * i + 1);
ll rs = query(m + 1, e, l, r, 2 * i + 2);
return max(ls, rs);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ll n;
cin >> n;
v h(n + 1), co(n + 1);
map<ll, ll> mm;
v temp(n + 1), temp2(n + 1);
f(i, n) {
cin >> h[i];
temp[i] = h[i];
}
in(co, n);
f(i, n) { temp2[i] = co[i]; }
sor(h, co, n);
f(i, n) {
if (mm[h[i]] == 0)
mm[h[i]] = i + 1;
// a[x-1]++;
}
build(0, n - 1, 0);
ll ans = 0;
f(i, n) {
ll pos = mm[temp[i]] - 1;
ll x = 0;
if (pos > 0)
x = query(0, n - 1, 0, pos - 1, 0);
update(0, n - 1, pos, 0, temp2[i] + x);
ans = max(ans, a[i]);
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long lu;
typedef long double ld;
typedef pair<ll, ll> pr;
typedef vector<ll> v;
typedef vector<vector<ll>> vv;
typedef vector<string> vs;
typedef vector<pair<ll, ll>> vp;
#define in(x, n) \
for (ll i = 0; i < n; i++) \
cin >> x[i]
#define mp make_pair
#define mt make_tuple
#define ld long double
#define f(i, n) for (ll i = 0; i < n; i++)
#define ff(i, n) for (ll i = 1; i <= n; i++)
#define pb push_back
#define aa(s) s.begin(), s.end()
#define sz(x) (ll) x.size()
#define fi first
#define se second
#define mx(a) *(max_element(a.begin(), a.end()))
#define mn(a) *(min_element(a.begin(),a.end())
// #define p 908197
#define p 998244353
#define mod 1000000007
//#define mod 998244353
//#define mod 1000000000
#define ti tuple
//#define mod 998000099999
#define sn struct node
#define MAXN 200001
const v dx = {1, -1, 0, 0};
const v dy = {0, 0, 1, -1};
const v dx1 = {0, 1, -1, 0, 1, 1, -1, -1};
const v dy1 = {1, 0, 0, -1, 1, -1, 1, -1};
const ld PI = 2 * acos(0.0);
ll cel(ll x1, ll y1) {
if ((x1 % y1) == 0)
return x1 / y1;
else
return x1 / y1 + 1;
}
ll power(ll x, ll y) {
ll res = 1; // Initialize result
x = x % mod;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % mod;
// n must be even now
y = y >> 1; // y = y/2
x = (x * x) % mod; // Change x to x^2
}
return res % mod;
}
ll power2(ll x, ll y) {
ll res = 1; // Initialize result
x = x;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// n must be even now
y = y >> 1; // y = y/2
x = (x * x); // Change x to x^2
}
return res;
}
ld power1(ld x, ll y) {
ld res = 1; // Initialize result
// x=x%mod;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// n must be even now
y = y >> 1; // y = y/2
x = (x * x); // Change x to x^2
}
return res;
}
void yes() { cout << "YES\n"; }
void no() { cout << "NO\n"; }
template <typename T> void print_queue(T &q) {
while (!q.empty()) {
std::cout << q.top() << " ";
q.pop();
}
std::cout << '\n';
}
// ll dp[][w]={0};
/*vector<pair<ll,pair<ll,ll>>>v;ll len;
ll dp[37][100002];
ll solve(ll n,ll x,ll y,ll z,ll p)
{
if(n==len)
{
return 1;
}
if(dp[p][n]!=-1)
{
return dp[p][n];
}
ll ans=0;
return dp[p][n]=ans;
}
*/
/*
vector<ll> merge(vector<ll> v1,vector<ll> v2)
{
vector<ll> x;
ll i,j,k,l,m,n,o,p,q,r,s,t;
m=v1.size();i=0;
n=v2.size();j=0;
while(i<m&&j<n)
{
if(v1[i]<v2[j])
{
x.push_back(v1[i]);
i++;
}
else
{
x.push_back(v2[j]);
j++;
}
}
while(i<m)
{
x.push_back(v1[i]);
i++;
}
while(j<n)
{
x.push_back(v2[j]);
j++;
}
return x;
}
vector<ll>sa[1000000];
ll a[1000000];
void build(ll s,ll e,ll i)
{
if(s==e)
{
sa[i].push_back(a[s]);
return;
}
ll m=(s+e)/2;
build(s,m,2*i+1);
build(m+1,e,2*i+2);
sa[i]=merge(sa[2*i+1],sa[2*i+2]);
}
ll query(ll s,ll e,ll l,ll r,ll i,ll x1,ll x2)
{
if(e<l || r<s || s>e)
return 0;
if(s>=l && e<=r)
{
ll v1= upper_bound(sa[i].begin(),sa[i].end(),x1)-sa[i].begin();
// ll v2= lower_bound(sa[i].begin(),sa[i].end(),x2-1)-sa[i].begin();
return v1;
}
ll m=(s+e)/2;
ll ls=query(s,m,l,r,2*i+1,x1,x2);
ll rs=query(m+1,e,l,r,2*i+2,x1,x2);
return ls+rs;
}
*/
// Returns n^(-1) mod p
/*
ll modInverse(ll n)
{
return power1(n, p-2);
}
// Returns nCr % p using Fermat's little
// theorem.
ll fac[500001];
ll nCrModPFermat(ll n, ll r)
{
// Base case
if (r==0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
return (fac[n]* modInverse(fac[r]) % p *
modInverse(fac[n-r]) % p) % p;
}
*/
/*
vector<vector<pair<ll,ll>>>a(100003);
ll par[100003];ll size[100003];
ll find(ll x)
{
while(par[x]!=x)
{
par[x]=par[par[x]];
x=par[x];
}
return x;
}
void union1(ll x,ll y)
{
ll xroot=find(x);
ll yroot=find(y);
if(xroot==yroot)
return;
if(size[xroot]>=size[yroot])
{
par[yroot]=xroot;
size[xroot]+=size[yroot];
} else
{ par[xroot]=yroot;
size[yroot]+=size[xroot];}
}
*/
void gv(v a, ll n) {
f(i, n) {
cin >> a[i];
// cout<<a[i]<<" ";
}
// cout<<"\n";
}
void out(v a, ll n) {
f(i, n) cout << a[i] << " ";
cout << "\n";
}
void sor(v &a, v &b, ll n) {
vector<pair<ll, ll>> v;
f(i, n) {
// cout<<b[i]<<" "<<a[i]<<"\n";
v.push_back(mp(a[i], b[i]));
}
sort(aa(v));
f(i, n) {
a[i] = v[i].first;
b[i] = v[i].second;
}
}
/*ll t;cin>>t;
f(wq,t) {
}
*/
/*
vector<vector<ll> > vec(row);
vector<vector<ll> > vec( n , vector<ll> (m,0));
for(auto i:m2)
*/
// ll dp[101][101][27];
// ll dp[101][100001];ll pre[101][100001];
ll sa[4000000];
// ll sa2[1000000];
ll a[1000000];
void build(ll s, ll e, ll i) {
if (s == e) {
sa[i] = a[s];
return;
}
ll m = (s + e) / 2;
build(s, m, 2 * i + 1);
build(m + 1, e, 2 * i + 2);
sa[i] = max(sa[2 * i + 1], sa[2 * i + 2]);
}
void update(ll s, ll e, ll j, ll i, ll v) {
if (s == e) {
a[s] = v;
sa[i] = v;
return;
}
ll m = (s + e) / 2;
if (j <= m) {
update(s, m, j, 2 * i + 1, v);
} else
update(m + 1, e, j, 2 * i + 2, v);
sa[i] = max(sa[2 * i + 1], sa[2 * i + 2]);
}
ll query(ll s, ll e, ll l, ll r, ll i) {
if (s >= l && e <= r) {
return (sa[i]);
}
if (e < l || r < s) {
return -INT_MAX;
}
ll m = (s + e) / 2;
ll ls = query(s, m, l, r, 2 * i + 1);
ll rs = query(m + 1, e, l, r, 2 * i + 2);
return max(ls, rs);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ll n;
cin >> n;
v h(n + 1), co(n + 1);
map<ll, ll> mm;
v temp(n + 1), temp2(n + 1);
f(i, n) {
cin >> h[i];
temp[i] = h[i];
}
in(co, n);
f(i, n) { temp2[i] = co[i]; }
sor(h, co, n);
f(i, n) {
if (mm[h[i]] == 0)
mm[h[i]] = i + 1;
// a[x-1]++;
}
build(0, n - 1, 0);
ll ans = 0;
f(i, n) {
ll pos = mm[temp[i]] - 1;
ll x = 0;
if (pos > 0)
x = query(0, n - 1, 0, pos - 1, 0);
update(0, n - 1, pos, 0, temp2[i] + x);
ans = max(ans, a[pos]);
}
cout << ans;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 984,116 | 984,117 | u332525750 | cpp |
p03176 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define vout(x) rep(i, x.size()) cout << x[i] << " "
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
using namespace std;
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int, int>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 1e5;
template <class T> struct segment_tree {
int n;
vector<T> dat;
segment_tree(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.resize(2 * n - 1);
rep(i, 2 * n - 1) dat[i] = 0;
}
// kをaに変更
void update(int k, T a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
//[a,b)のquery,kは節点番号
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
T get(int a) {
a += n - 1;
return dat[a];
}
void debug(int a, int b) {
a += n - 1;
b += n - 1;
for (int i = a; i <= b; i++) {
cout << dat[i] << " ";
}
cout << endl;
}
};
int main() {
int n;
cin >> n;
vint h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
segment_tree<ll> seg(n + 1);
rep(i, n) {
ll value = seg.query(0, h[i], 0, 0, 16);
if (seg.get(h[i]) < value + a[i])
seg.update(h[i], value + a[i]);
}
cout << seg.query(0, n + 1) << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define vout(x) rep(i, x.size()) cout << x[i] << " "
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
using namespace std;
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int, int>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 1e5;
template <class T> struct segment_tree {
int n;
vector<T> dat;
segment_tree(int n_) { init(n_); }
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.resize(2 * n - 1);
rep(i, 2 * n - 1) dat[i] = 0;
}
// kをaに変更
void update(int k, T a) {
k += n - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
//[a,b)のquery,kは節点番号
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return dat[k];
else {
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
T get(int a) {
a += n - 1;
return dat[a];
}
void debug(int a, int b) {
a += n - 1;
b += n - 1;
for (int i = a; i <= b; i++) {
cout << dat[i] << " ";
}
cout << endl;
}
};
int main() {
int n;
cin >> n;
vint h(n), a(n);
rep(i, n) cin >> h[i];
rep(i, n) cin >> a[i];
segment_tree<ll> seg(n + 1);
rep(i, n) {
ll value = seg.query(0, h[i]);
if (seg.get(h[i]) < value + a[i])
seg.update(h[i], value + a[i]);
}
cout << seg.query(0, n + 1) << endl;
} | [
"call.arguments.change"
] | 984,120 | 984,121 | u697968316 | cpp |
p03176 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define int ll
struct flower {
int h;
int b;
};
signed main(void) {
int n;
cin >> n;
vector<flower> v(n + 1);
vector<int> dp(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i].h;
for (int i = 1; i <= n; i++)
cin >> v[i].b;
map<int, int> mp;
dp[1] = v[1].h;
mp[v[1].h] = dp[1];
int ans = dp[1];
for (int i = 2; i <= n; i++) {
dp[i] = v[i].b;
auto it = mp.lower_bound((v[i].h + 1));
if (it != mp.begin()) {
it--;
dp[i] += (it->second);
}
mp[v[i].h] = dp[i];
it = mp.upper_bound(v[i].h);
while (it != mp.end() && (it->second) <= dp[i]) {
auto temp = it;
temp++;
mp.erase(it);
it = temp;
}
if (ans < dp[i])
ans = dp[i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define int ll
struct flower {
int h;
int b;
};
signed main(void) {
int n;
cin >> n;
vector<flower> v(n + 1);
vector<int> dp(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i].h;
for (int i = 1; i <= n; i++)
cin >> v[i].b;
map<int, int> mp;
dp[1] = v[1].b;
mp[v[1].h] = dp[1];
int ans = dp[1];
for (int i = 2; i <= n; i++) {
dp[i] = v[i].b;
auto it = mp.lower_bound((v[i].h + 1));
if (it != mp.begin()) {
it--;
dp[i] += (it->second);
}
mp[v[i].h] = dp[i];
it = mp.upper_bound(v[i].h);
while (it != mp.end() && (it->second) <= dp[i]) {
auto temp = it;
temp++;
mp.erase(it);
it = temp;
}
if (ans < dp[i])
ans = dp[i];
}
cout << ans << endl;
} | [
"assignment.value.change"
] | 984,124 | 984,125 | u043140820 | cpp |
p03176 | #include <algorithm>
#include <iostream>
#include <vector>
#define pb push_back
#define mp make_pair
using namespace std;
struct T {
vector<long long> t;
void init(int n) { t.resize(4 * n); }
void pull(int v) { t[v] = max(t[2 * v], t[2 * v + 1]); }
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = 0;
} else {
int mid = tl + tr >> 1;
build(2 * v, tl, mid);
build(2 * v + 1, mid + 1, tr);
pull(v);
}
}
void set(int v, int tl, int tr, int i, long long val) {
if (i < tl or i > tr)
return;
else if (i == tl and i == tr) {
t[v] = val;
} else {
int mid = tl + tr >> 1;
set(2 * v, tl, mid, i, val);
set(2 * v + 1, mid + 1, tr, i, val);
pull(v);
}
}
long long get(int v, int tl, int tr, int l, int r) {
if (tl > r or tr < l)
return 0;
else if (tl >= l and tr <= r)
return t[v];
else {
int mid = tl + tr >> 1;
return max(get(2 * v, tl, mid, l, r), get(2 * v + 1, mid + 1, tr, l, r));
}
}
};
void solve() {
int n;
cin >> n;
vector<int> h(n + 1);
vector<int> a(n + 1);
vector<long long> dp(n + 1);
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
T tree;
tree.init(n);
tree.build(1, 1, n);
for (int i = 1; i <= n; i++) {
int mx = tree.get(1, 1, n, 1, h[i]);
dp[i] = mx + a[i];
tree.set(1, 1, n, h[i], dp[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
int main() {
solve();
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define pb push_back
#define mp make_pair
using namespace std;
struct T {
vector<long long> t;
void init(int n) { t.resize(4 * n); }
void pull(int v) { t[v] = max(t[2 * v], t[2 * v + 1]); }
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = 0;
} else {
int mid = tl + tr >> 1;
build(2 * v, tl, mid);
build(2 * v + 1, mid + 1, tr);
pull(v);
}
}
void set(int v, int tl, int tr, int i, long long val) {
if (i < tl or i > tr)
return;
else if (i == tl and i == tr) {
t[v] = val;
} else {
int mid = tl + tr >> 1;
set(2 * v, tl, mid, i, val);
set(2 * v + 1, mid + 1, tr, i, val);
pull(v);
}
}
long long get(int v, int tl, int tr, int l, int r) {
if (tl > r or tr < l)
return 0;
else if (tl >= l and tr <= r)
return t[v];
else {
int mid = tl + tr >> 1;
return max(get(2 * v, tl, mid, l, r), get(2 * v + 1, mid + 1, tr, l, r));
}
}
};
void solve() {
int n;
cin >> n;
vector<int> h(n + 1);
vector<int> a(n + 1);
vector<long long> dp(n + 1);
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
T tree;
tree.init(n);
tree.build(1, 1, n);
for (int i = 1; i <= n; i++) {
long long mx = tree.get(1, 1, n, 1, h[i]);
dp[i] = mx + a[i];
tree.set(1, 1, n, h[i], dp[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
int main() {
solve();
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 984,126 | 984,127 | u183606119 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.