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 |
|---|---|---|---|---|---|---|---|
p03147 | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> H(N);
for (int i = 0; i < N; i++) {
std::cin >> H[i];
}
int ans = 0;
bool shower;
do {
shower = false;
for (int i = 0; i < N; i++) {
if (H[i] == 0)
continue;
int j;
for (j = i + 1; j < N; j++) {
if (H[j] == 0)
break;
}
int n = 1000;
for (int k = i; k < j; k++) {
n = std::min(n, H[k]);
}
for (int k = i; k < j; k++) {
H[k] -= n;
}
ans += n;
shower = true;
}
} while (shower == true);
std::cout << ans << std::endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> H(N);
for (int i = 0; i < N; i++) {
std::cin >> H[i];
}
int ans = 0;
bool shower;
do {
shower = false;
for (int i = 0; i < N; i++) {
if (H[i] == 0)
continue;
int j;
for (j = i + 1; j < N; j++) {
if (H[j] == 0)
break;
}
int n = 1000;
for (int k = i; k < j; k++) {
n = std::min(n, H[k]);
}
for (int k = i; k < j; k++) {
H[k] -= n;
}
ans += n;
shower = true;
break;
}
} while (shower == true);
std::cout << ans << std::endl;
return 0;
} | [
"control_flow.break.add"
] | 945,696 | 945,697 | u922974720 | cpp |
p03147 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int ans = 0;
while (*max_element(h.begin(), h.end()) > 0) {
ans++;
bool first = false, end = false;
for (int i = 1; i < n; i++) {
if (h[i] <= 0 && h[i - 1] > 0)
first = true;
if (h[i] <= 0 && h[i + 1] > 0)
end = true;
if (first && end) {
ans++;
first = false;
end = false;
}
}
rep(i, n) h[i]--;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int ans = 0;
while (*max_element(h.begin(), h.end()) > 0) {
ans++;
bool first = false, end = false;
for (int i = 1; i < n - 1; i++) {
if (h[i] <= 0 && h[i - 1] > 0)
first = true;
if (h[i] <= 0 && h[i + 1] > 0 && first)
end = true;
if (first && end) {
ans++;
first = false;
end = false;
}
}
rep(i, n) h[i]--;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"control_flow.branch.if.condition.change"
] | 945,698 | 945,699 | u835561357 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
std::vector<int> h(N);
std::for_each(h.begin(), h.end(), [](auto &x) { cin >> x; });
const auto max_height_it = std::max_element(h.crbegin(), h.crend());
ll ans = 0;
auto l = h.begin();
while (*max_height_it > 0) {
const auto r = std::find_if(l, h.end(), [](auto &x) { return x == 0; });
if (r >= l) {
std::for_each(l, r, [](auto &x) { --x; });
++ans;
}
l = r;
while (*max_height_it > 0) {
if (l == h.end()) {
l = h.begin();
}
if (*l != 0) {
break;
}
++l;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
std::vector<int> h(N);
std::for_each(h.begin(), h.end(), [](auto &x) { cin >> x; });
const auto max_height_it = std::max_element(h.crbegin(), h.crend());
ll ans = 0;
auto l = h.begin();
while (*max_height_it > 0) {
const auto r = std::find_if(l, h.end(), [](auto &x) { return x == 0; });
if (r > l) {
std::for_each(l, r, [](auto &x) { --x; });
++ans;
}
l = r;
while (*max_height_it > 0) {
if (l == h.end()) {
l = h.begin();
}
if (*l != 0) {
break;
}
++l;
}
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 945,700 | 945,701 | u279109548 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int &hi : h)
cin >> hi;
int ans = h.front();
for (int i = 0; i + 1 < n; i++) {
int diff = h[i] - h[i + 1];
if (diff > 0)
ans += diff;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int &hi : h)
cin >> hi;
int ans = h.front();
for (int i = 0; i + 1 < n; i++) {
int diff = h[i + 1] - h[i];
if (diff > 0)
ans += diff;
}
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 945,706 | 945,707 | u624475441 | cpp |
p03147 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
int h;
int max_h = 0;
vector<int> hs;
int ans;
cin >> N;
hs.push_back(0);
for (int ni = 0; ni < N; ni++) {
cin >> h;
hs.push_back(h);
if (h > max_h)
max_h = h;
}
hs.push_back(0);
ans = 1;
int flag;
for (int hi = 2; hi <= max_h; hi++) {
flag = 0;
for (int ni = 1; ni < N + 1; ni++) {
if (flag == 0 && hs[ni] >= hi) {
flag = 1;
}
if (flag == 1 && hs[ni] < hi) {
ans++;
flag = 0;
}
}
}
printf("%d", ans);
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
int h;
int max_h = 0;
vector<int> hs;
int ans;
cin >> N;
hs.push_back(0);
for (int ni = 0; ni < N; ni++) {
cin >> h;
hs.push_back(h);
if (h > max_h)
max_h = h;
}
hs.push_back(0);
ans = 0;
int flag;
for (int hi = 1; hi <= max_h; hi++) {
flag = 0;
for (int ni = 1; ni < N + 2; ni++) {
if (flag == 0 && hs[ni] >= hi) {
flag = 1;
}
if (flag == 1 && hs[ni] < hi) {
ans++;
flag = 0;
}
}
}
printf("%d", ans);
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 945,708 | 945,709 | u388763757 | cpp |
p03147 | #include "bits/stdc++.h"
using namespace std;
#define LL long long
#define VLL vector<long long>
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define rep(i, n) for (int i = 0; i < n; i++)
#define COUT(x) cout << x << endl
double pai = 3.1415926535;
string atc = "atcoder";
typedef pair<long long, long long> data_t;
string strnum = "0123456789";
string alpS = "abcdefghijklmnopqrstuvwxyz";
string alpL = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int sizealp = (int)(alpS.size());
int mod = 1e9 + 7;
bool test = false;
void Test(char a) {
if (test) {
printf("%c", a);
}
}
int main() {
int N;
cin >> N;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> HighLow;
int ans = 0;
do {
for (int i = 1; i < h.size();) { // remove flat
if (h[i - 1] == h[i])
h.erase(h.begin() + i);
else
i++;
// cout << 'a';
}
if (h.size() < 3)
break;
for (int i = 0; i < h.size() && h.size() > 2; i++) { // make HighLow
if (i == 0) {
if (h[i] > h[i + 1]) {
HighLow.push_back(h[i]);
}
} else if (i == h.size() - 1) {
if (h[i] > h[i - 1])
HighLow.push_back(h[i]);
} else {
if ((h[i - 1] < h[i] && h[i] > h[i + 1]) ||
(h[i - 1] > h[i] && h[i] < h[i + 1]))
HighLow.push_back(h[i]);
}
// cout << 'b';
}
for (int i = 0; i < HighLow.size() && HighLow.size() > 2;
i++) { // change convex into flat
if (i % 2 == 0) {
if (i == 0) {
ans += HighLow[i] - HighLow[i + 1];
HighLow[i] = HighLow[i + 1];
} else if (i == HighLow.size() - 1) {
ans += HighLow[i] - HighLow[i - 1];
HighLow[i] = HighLow[i - 1];
} else {
ans += HighLow[i] - min(HighLow[i - 1], HighLow[i + 1]);
HighLow[i] = min(HighLow[i - 1], HighLow[i + 1]);
}
}
// cout << 'c';
}
h = HighLow;
HighLow = vector<int>(0);
} while (h.size() >= 3);
if (h.size() == 2)
ans += max(h[0], h[1]);
else
ans += h[0];
COUT(ans);
} | #include "bits/stdc++.h"
using namespace std;
#define LL long long
#define VLL vector<long long>
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define rep(i, n) for (int i = 0; i < n; i++)
#define COUT(x) cout << x << endl
double pai = 3.1415926535;
string atc = "atcoder";
typedef pair<long long, long long> data_t;
string strnum = "0123456789";
string alpS = "abcdefghijklmnopqrstuvwxyz";
string alpL = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int sizealp = (int)(alpS.size());
int mod = 1e9 + 7;
bool test = false;
void Test(char a) {
if (test) {
printf("%c", a);
}
}
int main() {
int N;
cin >> N;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> HighLow;
int ans = 0;
do {
for (int i = 1; i < h.size();) { // remove flat
if (h[i - 1] == h[i])
h.erase(h.begin() + i);
else
i++;
// cout << 'a';
}
if (h.size() < 3)
break;
for (int i = 0; i < h.size() && h.size() > 2; i++) { // make HighLow
if (i == 0) {
if (h[i] > h[i + 1]) {
HighLow.push_back(h[i]);
}
} else if (i == h.size() - 1) {
if (h[i] > h[i - 1])
HighLow.push_back(h[i]);
} else {
if ((h[i - 1] < h[i] && h[i] > h[i + 1]) ||
(h[i - 1] > h[i] && h[i] < h[i + 1]))
HighLow.push_back(h[i]);
}
// cout << 'b';
}
// rep(i,HighLow.size())cout<<HighLow[i]<<' ';
// cout<<endl;
for (int i = 0; i < HighLow.size() && HighLow.size() > 2;
i++) { // change convex into flat
if (i % 2 == 0) {
if (i == 0) {
ans += HighLow[i] - HighLow[i + 1];
HighLow[i] = HighLow[i + 1];
} else if (i == HighLow.size() - 1) {
ans += HighLow[i] - HighLow[i - 1];
HighLow[i] = HighLow[i - 1];
} else {
ans += HighLow[i] - max(HighLow[i - 1], HighLow[i + 1]);
HighLow[i] = max(HighLow[i - 1], HighLow[i + 1]);
}
}
// cout << 'c';
}
h = HighLow;
HighLow = vector<int>(0);
} while (h.size() >= 3);
if (h.size() == 2)
ans += max(h[0], h[1]);
else
ans += h[0];
COUT(ans);
} | [
"misc.opposites",
"assignment.value.change",
"expression.operation.binary.change",
"identifier.change",
"call.function.change"
] | 945,741 | 945,742 | u196798307 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
int h[N + 2];
h[0] = 0;
h[N + 1] = 0;
for (int i = 0; i < N; i++)
cin >> h[i + 1];
int result = 0;
for (int i = 0; i < N; i++) {
if (h[i] < h[i + 1] and h[i + 1] >= h[i + 2])
result += h[i + 1];
if (h[i] > h[i + 1] and h[i + 1] <= h[i + 2])
result -= h[i + 1];
}
cout << result << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
int h[N + 2];
h[0] = 0;
h[N + 1] = 0;
for (int i = 0; i < N; i++)
cin >> h[i + 1];
int result = 0;
for (int i = 0; i < N; i++) {
if (h[i] < h[i + 1] and h[i + 1] >= h[i + 2])
result += h[i + 1];
if (h[i] >= h[i + 1] and h[i + 1] < h[i + 2])
result -= h[i + 1];
}
cout << result << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 945,751 | 945,752 | u680707192 | cpp |
p03147 | #include <stdio.h>
int main(void) {
int n;
int i;
int h[100];
int x = 0, y = 0;
int ans = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
while (true) {
if (x == n)
break;
if (h[x] == 0)
x++;
if (h[x] > 0) {
y = x;
while (h[y] > 0 && y < n) {
h[y]--;
y++;
}
ans++;
}
}
printf("%d\n", ans);
return 0;
} | #include <stdio.h>
int main(void) {
int n;
int i;
int h[100];
int x = 0, y = 0;
int ans = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
while (true) {
if (x == n)
break;
if (h[x] == 0) {
x++;
continue;
}
if (h[x] > 0) {
y = x;
while (h[y] > 0 && y < n) {
h[y]--;
y++;
}
ans++;
}
}
printf("%d\n", ans);
return 0;
} | [] | 945,753 | 945,754 | u932138415 | cpp |
p03147 | #include <algorithm>
#include <math.h>
#include <stdio.h>
using namespace std;
int main() {
int a[105], n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int k = 0;
for (int i = 1;; i++) {
for (int j = 0; j < n; j++) {
if (a[j] != 0) {
k = 1;
}
if (k == 1) {
if (a[j] != 0) {
a[j]--;
} else {
break;
}
}
}
if (k == 0) {
printf("%d\n", i);
break;
}
k = 0;
}
} | #include <algorithm>
#include <math.h>
#include <stdio.h>
using namespace std;
int main() {
int a[105], n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int k = 0;
for (int i = 0;; i++) {
for (int j = 0; j < n; j++) {
if (k == 0 && a[j] != 0) {
k = 1;
}
if (k == 1) {
if (a[j] != 0) {
a[j]--;
} else {
break;
}
}
}
if (k == 0) {
printf("%d\n", i);
break;
}
k = 0;
}
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 945,761 | 945,762 | u379288456 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long long int llint;
typedef pair<ll, ll> pa;
#define MM 1e9
#define MOD MM + 7
#define MAX 101000
#define MAP 110
#define initial_value -1
#define Pair pair<int, int>
#define chmax(a, b) (a < b ? a = b : 0)
#define chmin(a, b) (a > b ? a = b : 0)
#define INF (1 << 29) // 536870912
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int N;
int h[101];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int ans = 0;
for (int i = 1; i < N; i++) {
if (h[i] > h[i - 1])
ans += (h[i] - h[i - 1]);
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long long int llint;
typedef pair<ll, ll> pa;
#define MM 1e9
#define MOD MM + 7
#define MAX 101000
#define MAP 110
#define initial_value -1
#define Pair pair<int, int>
#define chmax(a, b) (a < b ? a = b : 0)
#define chmin(a, b) (a > b ? a = b : 0)
#define INF (1 << 29) // 536870912
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int N;
int h[101];
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int ans = h[0];
for (int i = 1; i < N; i++) {
if (h[i] >= h[i - 1])
ans += (h[i] - h[i - 1]);
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 945,763 | 945,764 | u342051078 | cpp |
p03147 | #include <iostream>
#include <vector>
using namespace std;
int main() {
//入力
int n;
cin >> n;
vector<int> flower(n);
int smallest;
for (int i = 0; i < n; i++) {
cin >> flower[i];
if (i == 0) {
smallest = flower[i];
} else if (smallest > flower[i]) {
smallest = flower[i];
}
}
//処理
int ans = smallest;
for (int i = 0; i < n - 1; i++) {
if (flower[i + 1] - flower[i] > 0) {
ans += flower[i + 1] - flower[i];
}
}
//出力
cout << ans << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
//入力
int n;
cin >> n;
vector<int> flower(n);
int smallest;
for (int i = 0; i < n; i++) {
cin >> flower[i];
if (i == 0) {
smallest = flower[i];
} else if (smallest > flower[i]) {
smallest = flower[i];
}
}
//処理
int ans = flower[0];
for (int i = 0; i < n - 1; i++) {
if (flower[i + 1] - flower[i] > 0) {
ans += flower[i + 1] - flower[i];
}
}
//出力
cout << ans << endl;
}
| [] | 945,765 | 945,766 | u775507068 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
int a[n + 1];
a[0] = 0;
for (int i = 1; i <= n + 1; i++) {
cin >> a[i];
if (a[i] > a[i - 1]) {
ans += a[i] - a[i - 1];
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
int a[n + 1];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > a[i - 1]) {
ans += a[i] - a[i - 1];
}
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 945,767 | 945,768 | u401900157 | cpp |
p03147 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int temp = 0;
int ans = 0;
while (n--) {
int x;
cin >> x;
if (x - temp > 0)
ans += (x - temp);
x = temp;
}
cout << ans;
// your code goes here
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int temp = 0;
int ans = 0;
while (n--) {
int x;
cin >> x;
if (x - temp > 0)
ans += (x - temp);
temp = x;
}
cout << ans;
// your code goes here
return 0;
} | [
"assignment.change"
] | 945,778 | 945,779 | u629333789 | cpp |
p03147 | /*
#問題：
#分析：
#オブジェクト：
#条件：
#要求：
#解法：
*/
#include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int(i) = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int(i) = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int(i) = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define uLL unsigned LL
#define LD long double
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod = 1000000007;
using namespace std;
int main(void) {
int N;
cin >> N;
vector<int> h(N + 2);
FORQ(i, 1, N) { cin >> h[i]; }
h[0] = 0;
h[N + 1] = 0;
// for(auto x:h) cerr<<x<<" ";
// cerr<<endl;
//
int ope_cnt = 0; //
int id_nowlooking;
int id_left = 0, id_right = 0; //
int minx; // 「今見ている「部分数列の範囲」」での「値」の最小値
bool flag_thereIsNonZeroNumber = false;
// for(auto x: h) cerr<<x<<" ";
// cerr<<endl;
while (1) {
FORQ(id_nowlooking, 0, N)
if (h[id_nowlooking] == 0 && h[id_nowlooking + 1] != 0)
id_left = id_nowlooking + 1;
FORQ(id_nowlooking, 0, N) {
if (h[id_nowlooking] != 0 && h[id_nowlooking + 1] == 0) {
id_right = id_nowlooking;
flag_thereIsNonZeroNumber = true;
}
}
// cerr<<" id_left : "<<id_left<<" id_right : "<<id_right<<endl;
// for(auto x: h) cerr<<x<<" ";
// cerr<<endl;
if (flag_thereIsNonZeroNumber == false)
break;
minx = *min_element(h.begin() + id_left, h.begin() + id_right);
FORQ(i, id_left, id_right) { h[i] -= minx; }
ope_cnt += minx;
// cerr<<"minus operation conducted :";;
// for(auto x: h) cerr<<x<<" ";
// cerr<<endl;
flag_thereIsNonZeroNumber = false;
}
cout << ope_cnt << endl;
return 0;
}
| /*
#問題：
#分析：
#オブジェクト：
#条件：
#要求：
#解法：
*/
#include <algorithm>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip> //do setprecision
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, b, e) for (int(i) = (b); i < (e); ++i)
#define FORQ(i, b, e) for (int(i) = (b); i <= (e); ++i)
#define FORD(i, b, e) for (int(i) = (b)-1; i >= (e); --i)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define uLL unsigned LL
#define LD long double
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int mod = 1000000007;
using namespace std;
int main(void) {
int N;
cin >> N;
vector<int> h(N + 2);
FORQ(i, 1, N) { cin >> h[i]; }
h[0] = 0;
h[N + 1] = 0;
// for(auto x:h) cerr<<x<<" ";
// cerr<<endl;
//
int ope_cnt = 0; //
int id_nowlooking;
int id_left = 0, id_right = 0; //
int minx; // 「今見ている「部分数列の範囲」」での「値」の最小値
bool flag_thereIsNonZeroNumber = false;
// for(auto x: h) cerr<<x<<" ";
// cerr<<endl;
while (1) {
FORQ(id_nowlooking, 0, N)
if (h[id_nowlooking] == 0 && h[id_nowlooking + 1] != 0)
id_left = id_nowlooking + 1;
FORQ(id_nowlooking, 0, N) {
if (h[id_nowlooking] != 0 && h[id_nowlooking + 1] == 0) {
id_right = id_nowlooking;
flag_thereIsNonZeroNumber = true;
}
}
// cerr<<" id_left : "<<id_left<<" id_right : "<<id_right<<endl;
if (flag_thereIsNonZeroNumber == false)
break;
minx = *min_element(h.begin() + id_left, h.begin() + id_right + 1);
FORQ(i, id_left, id_right) { h[i] -= minx; }
ope_cnt += minx;
// cerr<<" ope_cnt : "<<ope_cnt<<endl;
// cerr<<"minus operation conducted :";
// for(auto x: h) cerr<<x<<" ";
// cerr<<endl;
flag_thereIsNonZeroNumber = false;
}
cout << ope_cnt << endl;
return 0;
}
| [
"assignment.change"
] | 945,782 | 945,783 | u185249212 | cpp |
p03147 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int h[105];
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> h[i];
int cnt = 0;
int indexS, indexE;
// int count = 3;
bool isZero = true;
for (int i = 1; i <= N; i++) {
if (h[i] != 0)
isZero = false;
if (isZero) {
cout << 0 << endl;
return 0;
}
}
while (1) {
for (int i = 0; i <= N; i++) {
if (h[i] != 0) {
indexS = i;
break;
}
}
for (int i = indexS; i <= N + 1; i++) {
if (h[i] == 0) {
indexE = i - 1;
break;
}
}
if (indexS == indexE) {
h[indexS]--;
cnt++;
} else {
cnt++;
for (int i = indexS; i <= indexE; i++) {
h[i]--;
}
}
// for ( int i = 1; i <= N; i++ ) cout << h[i] << " ";
// cout << endl;
bool f = true;
for (int i = 1; i <= N; i++) {
if (h[i] != 0)
f = false;
}
if (f)
break;
// count--;
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int h[105];
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> h[i];
int cnt = 0;
int indexS, indexE;
// int count = 3;
bool isZero = true;
for (int i = 1; i <= N; i++) {
if (h[i] != 0)
isZero = false;
}
if (isZero) {
cout << 0 << endl;
return 0;
}
while (1) {
for (int i = 0; i <= N; i++) {
if (h[i] != 0) {
indexS = i;
break;
}
}
for (int i = indexS; i <= N + 1; i++) {
if (h[i] == 0) {
indexE = i - 1;
break;
}
}
if (indexS == indexE) {
h[indexS]--;
cnt++;
} else {
cnt++;
for (int i = indexS; i <= indexE; i++) {
h[i]--;
}
}
// for ( int i = 1; i <= N; i++ ) cout << h[i] << " ";
// cout << endl;
bool f = true;
for (int i = 1; i <= N; i++) {
if (h[i] != 0)
f = false;
}
if (f)
break;
// count--;
}
cout << cnt << endl;
return 0;
}
| [] | 945,784 | 945,785 | u806800460 | cpp |
p03147 | #include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
int h[n];
for (int i = 0; i < n; ++i) {
std::cin >> h[i];
}
int sum = 0;
for (int i = 1; i < n; ++i) {
if (h[i - 1] - h[i] > 0) {
sum += h[i - 1] - h[i];
}
}
sum += h[n];
std::cout << sum << std::endl;
return 0;
}
| #include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
std::cin >> h[i];
}
int sum = 0;
for (int i = 1; i < n; i++) {
if (h[i - 1] - h[i] > 0) {
sum += h[i - 1] - h[i];
}
}
sum += h[n - 1];
std::cout << sum << std::endl;
return 0;
}
| [
"assignment.change"
] | 945,790 | 945,791 | u540971283 | cpp |
p03147 | #include <algorithm>
#include <iostream>
using namespace std;
#define ENDL "\n"
int N, h, hh;
int ans = 0;
void f() {
if (h > hh) {
ans += hh - h;
}
h = hh;
}
int main() {
cin >> N;
h = 0;
for (int i = 0; i < N; i++) {
cin >> hh;
f();
}
hh = 0;
f();
cout << ans << ENDL;
//
return 0;
}
| #include <algorithm>
#include <iostream>
using namespace std;
#define ENDL "\n"
int N, h, hh;
int ans = 0;
void f() {
if (h > hh) {
ans += h - hh;
}
h = hh;
}
int main() {
cin >> N;
h = 0;
for (int i = 0; i < N; i++) {
cin >> hh;
f();
}
hh = 0;
f();
cout << ans << ENDL;
//
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 945,798 | 945,799 | u402629484 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for ((i) = 0; (i) < (int)(n); (i)++)
bool check(vector<int> &h) {
int i;
REP(i, h.size()) if (h[i] != 0) return true;
return false;
}
int main() {
int i, N;
vector<int> h;
cin >> N;
REP(i, N) {
int x;
cin >> x;
h.emplace_back(x);
}
int res = 0;
while (check(h)) {
REP(i, N) if (h[i] != 0) {
int mn = (1 << 29);
for (int j = i; j < N && h[j] > 0; j++)
mn = min(mn, h[j]);
for (int j = i; j < N && h[j] > 0; j++)
h[j] -= mn;
res += mn;
}
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for ((i) = 0; (i) < (int)(n); (i)++)
bool check(vector<int> &h) {
int i;
REP(i, h.size()) if (h[i] != 0) return true;
return false;
}
int main() {
int i, N;
vector<int> h;
cin >> N;
REP(i, N) {
int x;
cin >> x;
h.emplace_back(x);
}
int res = 0;
while (check(h)) {
REP(i, N) {
if (h[i] != 0) {
int mn = (1 << 29);
for (int j = i; j < N && h[j] > 0; j++)
mn = min(mn, h[j]);
for (int j = i; j < N && h[j] > 0; j++)
h[j] -= mn;
res += mn;
break;
}
}
}
cout << res << endl;
return 0;
}
| [
"control_flow.break.add"
] | 945,802 | 945,803 | u968790411 | cpp |
p03147 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, flag;
int hmax = 0;
int hsum = 0;
int rdc = 0;
vector<int> h;
cin >> n;
h.resize(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
hsum += h[i];
if (hmax < h[i])
hmax = h[i];
}
for (int i = 0; i < hmax; i++) {
flag = 0;
for (int j = 0; j < n; j++) {
if (i <= h[j]) {
if (flag == 1) {
rdc++;
} else {
flag = 1;
}
} else {
flag = 0;
}
}
}
cout << hsum - rdc << "\n";
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, flag;
int hmax = 0;
int hsum = 0;
int rdc = 0;
vector<int> h;
cin >> n;
h.resize(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
hsum += h[i];
if (hmax < h[i])
hmax = h[i];
}
//
// cout<< hsum << " " << hmax << "\n";
//
for (int i = 0; i < hmax; i++) {
flag = 0;
for (int j = 0; j < n; j++) {
if (i + 1 <= h[j]) {
if (flag == 1) {
rdc++;
// cout<< "rdc";//
} else {
flag = 1;
}
} else {
flag = 0;
}
// cout<< "\n";//
}
// cout<< "\n";//
}
cout << hsum - rdc << "\n";
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 945,809 | 945,810 | u672995180 | cpp |
p03147 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
int n, l;
int i = 0;
cin >> n;
vector<int> table(n + 1);
for (int i = 0; i < n; i++) {
cin >> table[i];
}
table[n + 1] = 0;
int max = 0, count = 0;
for (i = 0; i < n; ++i) {
if (max < table[i])
max = table[i];
}
while (max != 0) {
for (i = 0; i < n; ++i) {
if (max == table[i]) {
if (table[i] == table[i + 1])
table[i]--;
else {
table[i]--;
count++;
}
}
}
max--;
}
cout << count << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
int n, l;
int i = 0;
cin >> n;
int table[n + 1];
for (int i = 0; i < n; i++) {
cin >> table[i];
}
table[n + 1] = 0;
int max = 0, count = 0;
for (i = 0; i < n; ++i) {
if (max < table[i])
max = table[i];
}
while (max != 0) {
for (i = 0; i < n; ++i) {
if (max == table[i]) {
if (table[i] == table[i + 1])
table[i]--;
else {
table[i]--;
count++;
}
}
}
max--;
}
cout << count << endl;
return 0;
} | [
"call.arguments.change"
] | 945,811 | 945,812 | u419307948 | cpp |
p03147 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string>
using namespace std;
int main() {
int N;
int h[120] = {};
int flag = 0, ans = 0;
int fzero, lzero;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
if (h[i] != 0) {
flag = 1; //ぜんぶぜろじゃない
}
}
if (flag == 0) {
cout << "0" << endl;
return 0;
}
while (flag == 0) {
int kukan = 1;
for (fzero = 0; fzero < N; fzero++) {
if (h[fzero] != 0) {
break;
}
}
for (lzero = N - 1; lzero >= 0; lzero--) {
if (h[lzero] != 0) {
break;
}
}
for (int i = fzero; i <= lzero; i++) {
if (h[i] == 0) {
if (h[i + 1] != 0) {
kukan++;
}
}
}
for (int i = 0; i < N; i++) {
if (h[i] != 0) {
h[i]--;
}
}
ans += kukan;
//全部ゼロ？
flag = 1;
for (int i = 0; i < N; i++) {
if (h[i] != 0) {
flag = 0;
}
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string>
using namespace std;
int main() {
int N;
int h[120] = {};
int flag = 0, ans = 0;
int fzero, lzero;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
if (h[i] != 0) {
flag = 1; //ぜんぶぜろじゃない
}
}
if (flag == 0) {
cout << "0" << endl;
return 0;
}
flag = 0;
while (flag == 0) {
int kukan = 1;
for (fzero = 0; fzero < N; fzero++) {
if (h[fzero] != 0) {
break;
}
}
for (lzero = N - 1; lzero >= 0; lzero--) {
if (h[lzero] != 0) {
break;
}
}
for (int i = fzero; i <= lzero; i++) {
if (h[i] == 0) {
if (h[i + 1] != 0) {
kukan++;
}
}
}
for (int i = 0; i < N; i++) {
if (h[i] != 0) {
h[i]--;
}
}
ans += kukan;
//全部ゼロ？
flag = 1;
for (int i = 0; i < N; i++) {
if (h[i] != 0) {
flag = 0;
}
}
}
cout << ans << endl;
} | [
"assignment.add"
] | 945,813 | 945,814 | u371535422 | cpp |
p03147 | //#include <bits/stdc++.h>
//#include <stdio.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 // 2000000000
#define LLINF 1000000000000000000 // 9000000000000000000
#define PI 3.14159265358979
#define MAXI 7500000
using namespace std;
typedef long long int ll;
typedef pair<long long int, long long int> P;
int dy[5] = {0, 0, 1, -1, 0};
int dx[5] = {1, -1, 0, 0, 0};
int main(void) {
int n;
int h[102];
int count = 0;
int total = 0;
cin >> n;
FOR(i, 1, n) {
cin >> h[i];
total += h[i];
}
h[n + 1] = 0;
while (total > 0) {
FOR(i, 1, n) {
if (h[i] != 0) {
FOR(j, i + 1, n + 1) {
if (h[j] != 0) {
continue;
} else {
FOR(k, i, j - 1) {
h[k]--;
total--;
}
count++;
break;
}
}
}
}
}
cout << count << endl;
return 0;
} | //#include <bits/stdc++.h>
//#include <stdio.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 // 2000000000
#define LLINF 1000000000000000000 // 9000000000000000000
#define PI 3.14159265358979
#define MAXI 7500000
using namespace std;
typedef long long int ll;
typedef pair<long long int, long long int> P;
int dy[5] = {0, 0, 1, -1, 0};
int dx[5] = {1, -1, 0, 0, 0};
int main(void) {
int n;
int h[102];
int count = 0;
int total = 0;
cin >> n;
FOR(i, 1, n) {
cin >> h[i];
total += h[i];
}
h[n + 1] = 0;
while (total > 0) {
FOR(i, 1, n) {
if (h[i] != 0) {
FOR(j, i + 1, n + 1) {
if (h[j] != 0) {
continue;
} else {
FOR(k, i, j - 1) {
h[k]--;
total--;
}
count++;
break;
}
}
break;
}
}
}
cout << count << endl;
return 0;
} | [
"control_flow.break.add"
] | 945,819 | 945,820 | u057611820 | cpp |
p03147 | //#include <bits/stdc++.h>
//#include <stdio.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 // 2000000000
#define LLINF 1000000000000000000 // 9000000000000000000
#define PI 3.14159265358979
#define MAXI 7500000
using namespace std;
typedef long long int ll;
typedef pair<long long int, long long int> P;
int dy[5] = {0, 0, 1, -1, 0};
int dx[5] = {1, -1, 0, 0, 0};
int main(void) {
int n;
int h[102];
int count = 0;
int total = 0;
cin >> n;
FOR(i, 1, n) {
cin >> h[i];
total += h[i];
}
h[n + 1] = 0;
while (total > 0) {
FOR(i, 1, n) {
if (h[i] != 0) {
FOR(j, i + 1, n + 1) {
if (h[j] != 0) {
continue;
} else {
FOR(k, i, j - 1) {
h[k]--;
total--;
}
count++;
}
}
}
}
}
cout << count << endl;
return 0;
} | //#include <bits/stdc++.h>
//#include <stdio.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (int i = (a); i >= (b); i--)
#define LFOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define LRFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define INF 1000000000 // 2000000000
#define LLINF 1000000000000000000 // 9000000000000000000
#define PI 3.14159265358979
#define MAXI 7500000
using namespace std;
typedef long long int ll;
typedef pair<long long int, long long int> P;
int dy[5] = {0, 0, 1, -1, 0};
int dx[5] = {1, -1, 0, 0, 0};
int main(void) {
int n;
int h[102];
int count = 0;
int total = 0;
cin >> n;
FOR(i, 1, n) {
cin >> h[i];
total += h[i];
}
h[n + 1] = 0;
while (total > 0) {
FOR(i, 1, n) {
if (h[i] != 0) {
FOR(j, i + 1, n + 1) {
if (h[j] != 0) {
continue;
} else {
FOR(k, i, j - 1) {
h[k]--;
total--;
}
count++;
break;
}
}
break;
}
}
}
cout << count << endl;
return 0;
} | [
"control_flow.break.add"
] | 945,821 | 945,820 | u057611820 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
#define lint long long
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; ++i) {
cin >> h[i];
}
int cnt = 0;
while (true) {
for (int i = 0; i < N; ++i) {
if (h[i] > 0) {
int m = h[i];
int j = i + 1;
while (j < N && h[j] > 0) {
m = min(m, h[j]);
++j;
}
for (int k = i; k < j; ++k) {
h[k] -= m;
}
cnt += m;
}
}
int sum = 0;
for (int i = 0; i < N; ++i) {
sum += h[i];
}
if (sum == 0) {
cout << cnt << endl;
return 0;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define lint long long
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; ++i) {
cin >> h[i];
}
int cnt = 0;
while (true) {
for (int i = 0; i < N; ++i) {
if (h[i] > 0) {
int m = h[i];
int j = i + 1;
while (j < N && h[j] > 0) {
m = min(m, h[j]);
++j;
}
for (int k = i; k < j; ++k) {
h[k] -= m;
}
cnt += m;
i = j;
}
}
int sum = 0;
for (int i = 0; i < N; ++i) {
sum += h[i];
}
if (sum == 0) {
cout << cnt << endl;
return 0;
}
}
}
| [
"assignment.add"
] | 945,851 | 945,852 | u432456012 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in(x) cin >> x
#define out(str) cout << str << endl
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int N, ans = 0;
int main() {
cin >> N;
int h[N + 1];
rep(i, N) { cin >> h[i]; }
h[N] = 0;
int now = h[0];
rep(i, N + 1) {
if (h[i + 1] >= now) {
now = h[i + 1];
} else {
ans += now - h[i + 1];
now = h[i + 1];
}
}
out(ans);
}
| #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define in(x) cin >> x
#define out(str) cout << str << endl
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
ll N, ans = 0;
int main() {
cin >> N;
ll h[N + 1];
rep(i, N) { cin >> h[i]; }
h[N] = 0;
ll now = h[0];
rep(i, N + 1) {
if (h[i + 1] >= now) {
now = h[i + 1];
} else {
ans += now - h[i + 1];
now = h[i + 1];
}
}
out(ans);
}
| [
"variable_declaration.type.change"
] | 945,857 | 945,858 | u190907730 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
int ans = 0;
while (true) {
bool flag = true;
for (int i = 0; i < N; i++) {
if (h[i] == 0)
continue;
flag = false;
int minh = 1000;
int lft = N;
for (int j = i; j < N; j++) {
if (h[j] == 0) {
lft = j;
break;
}
minh = min(minh, h[j]);
}
for (int j = i; j < lft; j++) {
h[j] -= minh;
}
ans += minh;
}
if (flag)
break;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
int ans = 0;
while (true) {
bool flag = true;
for (int i = 0; i < N; i++) {
if (h[i] == 0)
continue;
flag = false;
int minh = 1000;
int lft = N;
for (int j = i; j < N; j++) {
if (h[j] == 0) {
lft = j;
break;
}
minh = min(minh, h[j]);
}
for (int j = i; j < lft; j++) {
h[j] -= minh;
}
ans += minh;
break;
}
if (flag)
break;
}
cout << ans << endl;
}
| [
"control_flow.break.add"
] | 945,885 | 945,886 | u636387751 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n;
vector<int> v;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> h;
v.push_back(h);
}
for (int i = 0; i < n; i++) {
while (v[i] > 0) {
for (int j = i; j < n; j++) {
if (v[j] > 0)
v[j]--;
else
break;
}
}
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n;
vector<int> v;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> h;
v.push_back(h);
}
for (int i = 0; i < n; i++) {
while (v[i] > 0) {
for (int j = i; j < n; j++) {
if (v[j] > 0)
v[j]--;
else
break;
}
ans++;
}
}
cout << ans << endl;
} | [] | 945,895 | 945,896 | u673058289 | cpp |
p03147 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n;
vector<int> v;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> h;
v.push_back(h);
}
for (int i = 0; i < n; i++) {
while (v[i] != 0) {
for (int j = i; j < n; j++) {
if (v[i] > 0)
v[i]--;
else
break;
}
}
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n;
vector<int> v;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> h;
v.push_back(h);
}
for (int i = 0; i < n; i++) {
while (v[i] > 0) {
for (int j = i; j < n; j++) {
if (v[j] > 0)
v[j]--;
else
break;
}
ans++;
}
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 945,897 | 945,896 | u673058289 | cpp |
p03147 | #include <iostream>
using namespace std;
int main() {
int N, count = 0, flag, end, m;
cin >> N;
int i = 0, h[N];
while (i < N) {
cin >> h[i];
i++;
}
while (true) {
flag = 0;
end = 0;
for (i = 0; i < N; i++) {
if (h[i] > 0) {
end = 1;
h[i]--;
if (flag == 0) {
count++;
}
flag = 1;
}
if (h[i] == 0) {
flag = 0;
}
}
if (end == 0) {
cout << count << endl;
break;
}
}
}
| #include <iostream>
using namespace std;
int main() {
int N, count = 0, flag, end, m;
cin >> N;
int i = 0, h[N];
while (i < N) {
cin >> h[i];
i++;
}
while (true) {
flag = 0;
end = 0;
for (i = 0; i < N; i++) {
if (h[i] > 0) {
end = 1;
h[i]--;
if (flag == 0) {
count++;
}
flag = 1;
} else if (h[i] == 0) {
flag = 0;
}
}
if (end == 0) {
cout << count << endl;
break;
}
}
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 945,900 | 945,901 | u889812821 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> hs;
int n;
int main() {
cin >> n;
hs.resize(n, 0);
for (int i = 0; i < n; i++)
cin >> hs[i];
if (n == 1) {
cout << hs[0] << endl;
return 0;
}
if (n == 2) {
cout << max(hs[0], hs[1]) << endl;
return 0;
}
vector<int> minPos;
for (int i = 1; i < n - 1; i++) {
if (hs[i] < hs[i + 1] && hs[i] < hs[i - 1])
minPos.push_back(i);
}
if (minPos.size() == 0) {
cout << (*max_element(hs.begin(), hs.end())) << endl;
return 0;
}
int ans = 0;
ans += (*max_element(hs.begin(), hs.begin() + 1 + minPos[0]));
ans += (*max_element(hs.begin() + minPos[minPos.size() - 1], hs.end()));
for (int i = 1; i < minPos.size(); i++) {
ans +=
(*max_element(hs.begin() + minPos[i - 1], hs.begin() + minPos[i] + 1));
ans -= hs[minPos[i - 1]];
}
ans -= hs[minPos[minPos.size() - 1]];
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> hs;
int n;
int main() {
cin >> n;
hs.resize(n, 0);
for (int i = 0; i < n; i++)
cin >> hs[i];
if (n == 1) {
cout << hs[0] << endl;
return 0;
}
if (n == 2) {
cout << max(hs[0], hs[1]) << endl;
return 0;
}
vector<int> minPos;
for (int i = 1; i < n - 1; i++) {
if (hs[i] <= hs[i + 1] && hs[i] <= hs[i - 1])
minPos.push_back(i);
}
if (minPos.size() == 0) {
cout << (*max_element(hs.begin(), hs.end())) << endl;
return 0;
}
int ans = 0;
ans += (*max_element(hs.begin(), hs.begin() + 1 + minPos[0]));
ans += (*max_element(hs.begin() + minPos[minPos.size() - 1], hs.end()));
for (int i = 1; i < minPos.size(); i++) {
ans +=
(*max_element(hs.begin() + minPos[i - 1], hs.begin() + minPos[i] + 1));
ans -= hs[minPos[i - 1]];
}
ans -= hs[minPos[minPos.size() - 1]];
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 945,902 | 945,903 | u656732735 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> hs;
int n;
int main() {
cin >> n;
hs.resize(n, 0);
for (int i = 0; i < n; i++)
cin >> hs[i];
if (n == 1) {
cout << hs[0] << endl;
return 0;
}
if (n == 2) {
cout << max(hs[0], hs[1]) << endl;
}
vector<int> minPos;
for (int i = 1; i < n - 1; i++) {
if (hs[i] < hs[i + 1] && hs[i] < hs[i - 1])
minPos.push_back(i);
}
if (minPos.size() == 0) {
cout << (*max_element(hs.begin(), hs.end())) << endl;
return 0;
}
int ans = 0;
ans += (*max_element(hs.begin(), hs.begin() + 1 + minPos[0]));
ans += (*max_element(hs.begin() + minPos[minPos.size() - 1], hs.end()));
for (int i = 1; i < minPos.size(); i++) {
ans +=
(*max_element(hs.begin() + minPos[i - 1], hs.begin() + minPos[i] + 1));
ans -= hs[minPos[i - 1]];
}
ans -= hs[minPos[minPos.size() - 1]];
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> hs;
int n;
int main() {
cin >> n;
hs.resize(n, 0);
for (int i = 0; i < n; i++)
cin >> hs[i];
if (n == 1) {
cout << hs[0] << endl;
return 0;
}
if (n == 2) {
cout << max(hs[0], hs[1]) << endl;
return 0;
}
vector<int> minPos;
for (int i = 1; i < n - 1; i++) {
if (hs[i] <= hs[i + 1] && hs[i] <= hs[i - 1])
minPos.push_back(i);
}
if (minPos.size() == 0) {
cout << (*max_element(hs.begin(), hs.end())) << endl;
return 0;
}
int ans = 0;
ans += (*max_element(hs.begin(), hs.begin() + 1 + minPos[0]));
ans += (*max_element(hs.begin() + minPos[minPos.size() - 1], hs.end()));
for (int i = 1; i < minPos.size(); i++) {
ans +=
(*max_element(hs.begin() + minPos[i - 1], hs.begin() + minPos[i] + 1));
ans -= hs[minPos[i - 1]];
}
ans -= hs[minPos[minPos.size() - 1]];
cout << ans << endl;
} | [
"control_flow.return.add",
"control_flow.return.0.add",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 945,904 | 945,903 | u656732735 | cpp |
p03147 | // 解説記事を読んで書いたもの
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int h[N + 1];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int ans = 0;
// i : h[i]>0となる最小の添字
for (int i = 0; i < N; i++) {
while (h[i] > 0) {
// h[i] から h[j] までが一回の操作で同時に高さを減らせるかたまり
for (int j = i; j < N; j++) {
if (h[i] > 0) {
h[i]--;
} else {
break;
}
}
ans++;
}
}
cout << ans << endl;
return 0;
} | // 解説記事を読んで書いたもの
// 参考: http://kazune-lab.net/contest/2019/01/20/abc116/
// 参考: https://atcoder.jp/contests/abc116/submissions/4053275
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
int h[N + 1];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int ans = 0;
// i : h[i]>0となる最小の添字
for (int i = 0; i < N; i++) {
while (h[i] > 0) {
// h[i] から h[j] までが一回の操作で同時に高さを減らせるかたまり
for (int j = i; j < N; j++) {
if (h[j] > 0) {
h[j]--;
} else {
break;
}
}
ans++;
}
}
cout << ans << endl;
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 945,905 | 945,906 | u341347211 | cpp |
p03147 | #include <iostream>
using namespace std;
int main() {
int n;
int h[105];
int ans = 0;
cin >> n;
h[0] = 0;
for (int i = 1; i < n; i++) {
cin >> h[i];
if (h[i] > h[i - 1]) {
ans += h[i] - h[i - 1];
}
}
cout << ans << endl;
return (0);
}
| #include <iostream>
using namespace std;
int main() {
int n;
int h[105];
int ans = 0;
cin >> n;
h[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> h[i];
if (h[i] > h[i - 1]) {
ans += h[i] - h[i - 1];
}
}
cout << ans << endl;
return (0);
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 945,911 | 945,912 | u074924050 | cpp |
p03147 | #include <iostream>
#define fori(x, y) for (int i = x; i < y; i++)
typedef long long ll;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N, op = 0;
cin >> N;
int arr[107];
fori(0, N) cin >> arr[i];
bool iswatering = 1;
while (iswatering) {
int m = 1000, numzeros = 0;
fori(0, N) {
while (i < N && arr[i] == 0) {
i++;
numzeros++;
}
int l = i;
while (i < N && arr[i] != 0) {
if (m > arr[i])
m = arr[i];
i++;
}
int r = i;
if (m < 1000)
op += m;
fori(l, r) arr[i] -= m;
}
if (numzeros == N)
iswatering = 0;
}
cout << op << "\n";
return 0;
} | #include <iostream>
#define fori(x, y) for (int i = x; i < y; i++)
typedef long long ll;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N, op = 0;
cin >> N;
int arr[107];
fori(0, N) cin >> arr[i];
bool iswatering = 1;
while (iswatering) {
int m = 1000, numzeros = 0;
fori(0, N) {
while (i < N && arr[i] == 0) {
i++;
numzeros++;
}
int l = i;
while (i < N && arr[i] != 0) {
if (m > arr[i])
m = arr[i];
i++;
}
int r = i;
// fori(0, N) cout << arr[i] << " ";
// cout << endl << m << " " << op << endl;
if (m < 1000)
op += m;
fori(l, r) arr[i] -= m;
i = N;
}
if (numzeros == N)
iswatering = 0;
}
cout << op << "\n";
return 0;
} | [
"assignment.add"
] | 945,915 | 945,916 | u229349441 | cpp |
p03147 | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
ll ans = 0;
while (true) {
if (*max_element(h.begin(), h.end()) == 0)
break;
REP(i, n) {
if (h[i] == 0)
continue;
for (int j = i; j < n; ++j) {
if (h[j] == 0)
break;
h[j]--;
}
ans++;
}
}
cout << ans << std::endl;
return 0;
} | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
ll ans = 0;
while (true) {
if (*max_element(h.begin(), h.end()) == 0)
break;
REP(i, n) {
if (h[i] == 0)
continue;
for (int j = i; j < n; ++j) {
if (h[j] == 0)
break;
h[j]--;
}
break;
}
ans++;
}
cout << ans << std::endl;
return 0;
} | [
"control_flow.break.add"
] | 945,917 | 945,918 | u102602414 | cpp |
p03147 | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
ll ans = 0;
while (true) {
if (*max_element(h.begin(), h.end()) == 0)
break;
REP(i, n) {
if (h[i] == 0)
continue;
for (int j = i; j < n; ++i) {
if (h[j] == 0)
break;
h[j]--;
}
ans++;
}
}
cout << ans << std::endl;
return 0;
} | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOREACH(x, a) for (auto &(x) : (a))
typedef long long ll;
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
ll ans = 0;
while (true) {
if (*max_element(h.begin(), h.end()) == 0)
break;
REP(i, n) {
if (h[i] == 0)
continue;
for (int j = i; j < n; ++j) {
if (h[j] == 0)
break;
h[j]--;
}
break;
}
ans++;
}
cout << ans << std::endl;
return 0;
} | [
"identifier.change"
] | 945,919 | 945,918 | u102602414 | cpp |
p03147 | /**
* File : c.cpp
* Author : recurze
* Date : 00:17 21.01.2019
* Last Modified Date: 00:22 21.01.2019
*/
#include <algorithm>
#include <cstdio>
void readInput();
void solve();
void printAns();
int main() {
int t = 1;
//(void)scanf("%d", &t);
for (int tc = 1; tc <= t; ++tc) {
readInput();
solve();
printAns();
}
}
const int N = 1010101;
int n = 0;
int a[N];
void readInput() {
(void)scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
}
void printA() {
for (int i = 0; i < n; ++i) {
printf("%d ", *(a + i));
}
printf("\n");
}
int ans = 0;
void solve() {
int last = 0;
while (1) {
int i = (int)(std::max_element(a, a + n) - a);
if (a[i] == 0) {
break;
}
last = a[i];
ans += last;
for (int j = i + 1; j < n; ++j) {
last = std::min(last, a[j]);
a[j] -= last;
}
last = a[i];
for (int j = i - 1; j > -1; --j) {
last = std::min(last, a[j]);
a[j] -= last;
}
a[i] = 0;
printA();
}
}
void printAns() { printf("%d\n", ans); }
| /**
* File : c.cpp
* Author : recurze
* Date : 00:17 21.01.2019
* Last Modified Date: 00:23 21.01.2019
*/
#include <algorithm>
#include <cstdio>
void readInput();
void solve();
void printAns();
int main() {
int t = 1;
//(void)scanf("%d", &t);
for (int tc = 1; tc <= t; ++tc) {
readInput();
solve();
printAns();
}
}
const int N = 1010101;
int n = 0;
int a[N];
void readInput() {
(void)scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
}
void printA() {
for (int i = 0; i < n; ++i) {
printf("%d ", *(a + i));
}
printf("\n");
}
int ans = 0;
void solve() {
int last = 0;
while (1) {
int i = (int)(std::max_element(a, a + n) - a);
if (a[i] == 0) {
break;
}
last = a[i];
ans += last;
for (int j = i + 1; j < n; ++j) {
last = std::min(last, a[j]);
a[j] -= last;
}
last = a[i];
for (int j = i - 1; j > -1; --j) {
last = std::min(last, a[j]);
a[j] -= last;
}
a[i] = 0;
}
}
void printAns() { printf("%d\n", ans); }
| [
"call.remove"
] | 945,931 | 945,932 | u811925505 | cpp |
p03147 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll mizu(vector<ll> &h, ll l, ll r, ll n) {
if (l == r)
return h[l] - n;
ll mizuyari;
ll min = *min_element(h.begin() + l, h.begin() + r);
mizuyari = min - n;
ll beg = -1;
while (1) {
if (l > r)
break;
if (h[l] != min) {
if (beg == -1)
beg = l;
} else {
if (beg != -1) {
mizuyari += mizu(h, beg, l - 1, min);
beg = -1;
}
}
l++;
}
if (beg != -1)
mizuyari += mizu(h, beg, r, min);
return mizuyari;
}
int main() {
ll N;
cin >> N;
vector<ll> h;
for (int i = 0; i < N; ++i) {
ll tmp;
cin >> tmp;
h.push_back(tmp);
}
cout << mizu(h, 0, h.size() - 1, 0) << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
ll mizu(vector<ll> &h, ll l, ll r, ll n) {
// cout<<l<<"-"<<r<<endl;
if (l == r)
return h[l] - n;
ll mizuyari;
ll min = *min_element(h.begin() + l, h.begin() + r + 1);
mizuyari = min - n;
ll beg = -1;
while (1) {
if (l > r)
break;
if (h[l] != min) {
if (beg == -1)
beg = l;
} else {
if (beg != -1) {
mizuyari += mizu(h, beg, l - 1, min);
beg = -1;
}
}
l++;
}
if (beg != -1)
mizuyari += mizu(h, beg, r, min);
return mizuyari;
}
int main() {
ll N;
cin >> N;
vector<ll> h;
for (int i = 0; i < N; ++i) {
ll tmp;
cin >> tmp;
h.push_back(tmp);
}
cout << mizu(h, 0, h.size() - 1, 0) << endl;
return 0;
} | [
"assignment.change"
] | 945,935 | 945,936 | u373586461 | cpp |
p03147 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define DEBUG
#ifdef DEBUG
#define debug printf
#else
#define debug(...)
#endif
const ll maxn = 105;
ll h[maxn];
ll n;
ll check() {
for (ll i = 0; i < n; ++i) {
if (h[i]) {
return 1;
}
}
return 0;
}
int main(int argc, char const *argv[]) {
cin >> n;
for (ll i = 0; i < n; ++i) {
scanf("%lld", &h[i]);
}
ll ans = 0;
while (check()) {
for (ll i = 0; i < n; ++i) {
if (h[i]) {
for (ll j = i; j < n; ++j) {
if (h[j]) {
h[j]--;
} else {
break;
}
}
ans++;
}
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define DEBUG
#ifdef DEBUG
#define debug printf
#else
#define debug(...)
#endif
const ll maxn = 105;
ll h[maxn];
ll n;
ll check() {
for (ll i = 0; i < n; ++i) {
if (h[i]) {
return 1;
}
}
return 0;
}
int main(int argc, char const *argv[]) {
cin >> n;
for (ll i = 0; i < n; ++i) {
scanf("%lld", &h[i]);
}
ll ans = 0;
while (check()) {
for (ll i = 0; i < n; ++i) {
if (h[i]) {
for (ll j = i; j < n; ++j) {
if (h[j]) {
h[j]--;
} else {
break;
}
}
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.break.add"
] | 945,946 | 945,947 | u320267258 | cpp |
p03147 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 999999999
/*Solve*/
int main() {
ll n;
cin >> n;
ll h[n];
rep(i, n) { cin >> h[i]; }
ll tmp;
rep(i, n) {
if (i > 0 && h[i - 1] <= h[i]) {
tmp += h[i] - h[i - 1];
}
}
tmp += h[0];
cout << tmp << endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 999999999
/*Solve*/
int main() {
ll n;
cin >> n;
ll h[n];
rep(i, n) { cin >> h[i]; }
ll tmp = 0;
rep(i, n) {
if (i > 0 && h[i - 1] <= h[i]) {
tmp += h[i] - h[i - 1];
}
}
tmp += h[0];
cout << tmp << endl;
} | [
"variable_declaration.value.change"
] | 945,948 | 945,949 | u123896133 | cpp |
p03147 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int N, K, i, j, a;
cin >> N;
int h[N];
for (i = 0; i < N; i++) {
cin >> h[i];
}
a = h[0];
for (i = 0; i < N - 1; i++) {
if (h[i + 1] > h[i]) {
a = h[i + 1] - h[i];
}
}
cout << a;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int N, K, i, j, a;
cin >> N;
int h[N];
for (i = 0; i < N; i++) {
cin >> h[i];
}
a = h[0];
for (i = 0; i < N - 1; i++) {
if (h[i + 1] > h[i]) {
a += h[i + 1] - h[i];
}
}
cout << a;
return 0;
}
| [
"assignment.value.change"
] | 945,957 | 945,958 | u809278162 | cpp |
p03146 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int s, result, flag;
vector<int> data;
cin >> s;
data.push_back(s);
flag = 0;
int i = 0;
while (flag == 0) {
if (data[i] % 2 == 0) {
data.push_back(data[i] / 2);
} else {
data.push_back(data[i] * 3 + 1);
}
for (int j = 0; j < i; j++) {
if (data[i] == data[j]) {
flag = 1;
result = data[i];
}
}
i++;
}
cout << result;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int s, result, flag;
vector<int> data;
cin >> s;
data.push_back(s);
flag = 0;
int i = 0;
while (flag == 0) {
if (data[i] % 2 == 0) {
data.push_back(data[i] / 2);
} else {
data.push_back(data[i] * 3 + 1);
}
for (int j = 0; j < i; j++) {
if (data[i] == data[j]) {
flag = 1;
result = data[i];
}
}
i++;
}
cout << i;
} | [
"identifier.change",
"io.output.change"
] | 945,988 | 945,989 | u842388336 | cpp |
p03146 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int s, result, flag;
vector<int> data;
cin >> s;
data.push_back(8);
flag = 0;
int i = 0;
while (flag == 0) {
if (data[i] % 2 == 0) {
data.push_back(data[i] / 2);
} else {
data.push_back(data[i] * 3 + 1);
}
for (int j = 0; j < i; j++) {
if (data[i] == data[j]) {
flag = 1;
result = data[i];
}
}
i++;
}
cout << result;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int s, result, flag;
vector<int> data;
cin >> s;
data.push_back(s);
flag = 0;
int i = 0;
while (flag == 0) {
if (data[i] % 2 == 0) {
data.push_back(data[i] / 2);
} else {
data.push_back(data[i] * 3 + 1);
}
for (int j = 0; j < i; j++) {
if (data[i] == data[j]) {
flag = 1;
result = data[i];
}
}
i++;
}
cout << i;
} | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"identifier.change",
"io.output.change"
] | 945,990 | 945,989 | u842388336 | cpp |
p03146 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int x = 1;
int a[500000] = {0};
a[n] = 1;
while (a[n] != 2) {
x++;
if (n % 2 == 0) {
n = n / 2;
a[n]++;
} else {
n = n * 3 + 1;
a[n]++;
}
cout << n;
}
cout << x;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int x = 1;
int a[500000] = {0};
a[n] = 1;
while (a[n] != 2) {
x++;
if (n % 2 == 0) {
n = n / 2;
a[n]++;
} else {
n = n * 3 + 1;
a[n]++;
}
// cout<<n;
}
cout << x;
} | [] | 945,997 | 945,998 | u191117799 | cpp |
p03146 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int s;
cin >> s;
if (s == 1) {
cout << 4 << endl;
} else {
int count4 = 0, count = 0;
while (count4 != 2) {
if (s == 4) {
count4++;
}
if (s % 2 == 0) {
s /= 2;
count++;
} else {
s = (s * 3) + 1;
count++;
}
}
cout << count << endl;
}
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int s;
cin >> s;
if (s == 1 || s == 2) {
cout << 4 << endl;
} else {
int count4 = 0, count = 0;
while (count4 != 2) {
if (s == 4) {
count4++;
}
if (s % 2 == 0) {
s /= 2;
count++;
} else {
s = (s * 3) + 1;
count++;
}
}
cout << count << endl;
}
} | [
"control_flow.branch.if.condition.change"
] | 946,003 | 946,004 | u999803454 | cpp |
p03146 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define all(x) (x).begin(), (x).end()
#define MAX 1000000
using namespace std;
typedef long long ll;
int main() {
vector<int> a;
int s;
cin >> s;
a.push_back(s);
for (int i = 1; i <= MAX; i++) {
if (a[i - 1] % 2 == 0) {
a.push_back(a[i - 1] / 2);
} else {
a.push_back(a[i - 1] * 3 + 1);
}
}
bool isFind = false;
for (int i = 1; i <= MAX; i++) {
for (int j = i + 1; j <= MAX; j++) {
if (a[i] == a[j]) {
isFind = true;
cout << (j + 1) << endl;
break;
}
}
if (isFind) {
break;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define all(x) (x).begin(), (x).end()
#define MAX 1000000
using namespace std;
typedef long long ll;
int main() {
vector<int> a;
int s;
cin >> s;
a.push_back(s);
for (int i = 1; i <= MAX; i++) {
if (a[i - 1] % 2 == 0) {
a.push_back(a[i - 1] / 2);
} else {
a.push_back(a[i - 1] * 3 + 1);
}
}
bool isFind = false;
for (int i = 0; i <= MAX; i++) {
for (int j = i + 1; j <= MAX; j++) {
if (a[i] == a[j]) {
isFind = true;
cout << (j + 1) << endl;
break;
}
}
if (isFind) {
break;
}
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 946,007 | 946,008 | u148555958 | cpp |
p03146 | #include <iostream>
int main() {
int s;
std::cin >> s;
int list[1000000];
int index = 0;
int a_i;
int a_pre = s;
list[0] = s;
index = index + 1;
bool search_flag = false;
while (true) {
if (a_pre % 2 == 0) {
a_i = a_pre / 2;
} else {
a_i = 3 * a_pre + 1;
}
list[index] = a_i;
index = index + 1;
for (int i = 0; i < index - 1; ++i) {
if (list[i] == a_i) {
search_flag = false;
break;
}
}
if (search_flag == true) {
break;
}
a_pre = a_i;
}
std::cout << index << std::endl;
return 0;
}
| #include <iostream>
int main() {
int s;
std::cin >> s;
int list[1000000];
int index = 0;
int a_i;
int a_pre = s;
list[0] = s;
index = index + 1;
bool search_flag = false;
while (true) {
if (a_pre % 2 == 0) {
a_i = a_pre / 2;
} else {
a_i = 3 * a_pre + 1;
}
list[index] = a_i;
index = index + 1;
for (int i = 0; i < index - 1; ++i) {
if (list[i] == a_i) {
search_flag = true;
break;
}
}
if (search_flag == true) {
break;
}
a_pre = a_i;
}
std::cout << index << std::endl;
return 0;
}
| [
"misc.opposites",
"assignment.value.change"
] | 946,009 | 946,010 | u976439457 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int c(int n) {
int x = 1;
while (n != 1) {
if (n & 1)
n = 3 * n + 1;
else
n = n / 2;
x++;
}
return x;
}
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 5 << endl;
return 0;
} else if (n == 2) {
cout << 6 << endl;
return 0;
}
cout << c(n) + 1;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int c(int n) {
int x = 1;
while (n != 1) {
if (n & 1)
n = 3 * n + 1;
else
n = n / 2;
x++;
}
return x;
}
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 4 << endl;
return 0;
} else if (n == 2) {
cout << 4 << endl;
return 0;
}
cout << c(n) + 1;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 946,013 | 946,014 | u673058289 | cpp |
p03146 | #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define Yes(hoge) cout << ((hoge) ? "Yes" : "No") << endl;
#define YES(hoge) cout << ((hoge) ? "YES" : "NO") << endl;
using namespace std;
struct Grid {
int x, y, t;
};
struct Edge {
int to, cost;
};
struct Graph {
vector<vector<Edge>> E;
int V;
const ll Inf = llINF;
const int MAX_V = 1010;
vector<ll> d;
Graph(int n) : E(n) {
d.resize(MAX_V);
E.resize(n);
V = n;
}
void init() {
for (int i = 0; i < MAX_V; i++)
d[i] = Inf;
}
void add_edge(int from, int to, int cost) { E[from - 1].pb({to - 1, cost}); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d, e;
string s, ss;
cin >> a;
bool used[1000100] = {};
used[a] = true;
for (int i = 1; i <= 1000000; i++) {
if (a % 2) {
a = 3 * a + 1;
} else {
a /= 2;
}
if (used[a]) {
cout << i << endl;
break;
}
used[a] = true;
}
return 0;
}
| #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define Yes(hoge) cout << ((hoge) ? "Yes" : "No") << endl;
#define YES(hoge) cout << ((hoge) ? "YES" : "NO") << endl;
using namespace std;
struct Grid {
int x, y, t;
};
struct Edge {
int to, cost;
};
struct Graph {
vector<vector<Edge>> E;
int V;
const ll Inf = llINF;
const int MAX_V = 1010;
vector<ll> d;
Graph(int n) : E(n) {
d.resize(MAX_V);
E.resize(n);
V = n;
}
void init() {
for (int i = 0; i < MAX_V; i++)
d[i] = Inf;
}
void add_edge(int from, int to, int cost) { E[from - 1].pb({to - 1, cost}); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d, e;
string s, ss;
cin >> a;
bool used[1000100] = {};
used[a] = true;
for (int i = 1; i <= 1000000; i++) {
if (a % 2) {
a = 3 * a + 1;
} else {
a /= 2;
}
if (used[a]) {
cout << i + 1 << endl;
break;
}
used[a] = true;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 946,016 | 946,017 | u905715926 | cpp |
p03146 | #include <iostream>
using namespace std;
int main() {
int s, cnt = 2;
cin >> s;
if (s == 1)
cnt = 4;
else {
while (s != 1) {
if (s % 2)
s = 3 * s + 1;
else
s /= 2;
cnt++;
}
}
cout << cnt << "\n";
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int s, cnt = 2;
cin >> s;
if (s == 1 || s == 2)
cnt = 4;
else {
while (s != 1) {
if (s % 2)
s = 3 * s + 1;
else
s /= 2;
cnt++;
}
}
cout << cnt << "\n";
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 946,031 | 946,032 | u053360288 | cpp |
p03146 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MAXN = 1e5 + 200;
int main() {
ll n;
cin >> n;
ll i = 0;
if (n == 1) {
cout << 4 << endl;
return 0;
}
while (n > 1) {
if (n % 2 == 0) {
n /= 2;
} else {
n = n * 3 + 1;
}
i++;
}
cout << i + 2 << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MAXN = 1e5 + 200;
int main() {
ll n;
cin >> n;
ll i = 0;
if (n <= 2) {
cout << 4 << endl;
return 0;
}
while (n > 1) {
if (n % 2 == 0) {
n /= 2;
} else {
n = n * 3 + 1;
}
i++;
}
cout << i + 2 << endl;
return 0;
}
| [] | 946,042 | 946,043 | u624688258 | cpp |
p03146 | //テンプレ
#include <bits/stdc++.h>
//#define int long long
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
// constexpr int MOD = 10e9+7;
// constexpr int INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
//
int f(int n) {
if (n % 2 == 0) {
return n / 2;
} else {
return 3 * n + 1;
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int s;
cin >> s;
int a = s;
int n = 1;
int ans;
while (true) {
if (a == 1 || a == 2 || a == 4) {
cout << n + 2 << endl;
return 0;
}
a = f(a);
n++;
}
} | //テンプレ
#include <bits/stdc++.h>
//#define int long long
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
// constexpr int MOD = 10e9+7;
// constexpr int INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
//
int f(int n) {
if (n % 2 == 0) {
return n / 2;
} else {
return 3 * n + 1;
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int s;
cin >> s;
int a = s;
int n = 1;
while (true) {
if (a == 1 || a == 2 || a == 4) {
cout << n + 3 << endl;
return 0;
}
a = f(a);
n++;
}
} | [
"variable_declaration.remove",
"literal.number.change",
"io.output.change"
] | 946,044 | 946,045 | u904833081 | cpp |
p03146 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int nx[] = {0, 1, 0, -1};
int ny[] = {0, 1, 0, -1};
//*****************************************
int main(void) {
int s;
int m = 0;
scanf("%d", &s);
vector<int> index(1000100, 0);
index[0] = s;
for (int i = 1; i < 1000100; i++) {
if (index[i - 1] % 2 == 0) {
index[i] = index[i - 1] / 2;
} else {
index[i] = 3 * index[i - 1] + 1;
}
for (int j = 1; j < i; j++) {
if (index[i] == index[j]) {
m = i + 1;
break;
}
}
// cout<<index[i]<<"\n";
if (m != 0) {
break;
}
}
cout << m << "\n";
return 0;
}
| #include <algorithm>
#include <complex>
#include <cstdio>
#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int nx[] = {0, 1, 0, -1};
int ny[] = {0, 1, 0, -1};
//*****************************************
int main(void) {
int s;
int m = 0;
scanf("%d", &s);
vector<int> index(1000100, 0);
index[0] = s;
for (int i = 1; i < 1000100; i++) {
if (index[i - 1] % 2 == 0) {
index[i] = index[i - 1] / 2;
} else {
index[i] = 3 * index[i - 1] + 1;
}
for (int j = 0; j < i; j++) {
if (index[i] == index[j]) {
m = i + 1;
break;
}
}
// cout<<index[i]<<"\n";
if (m != 0) {
break;
}
}
cout << m << "\n";
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 946,056 | 946,057 | u113497060 | cpp |
p03146 | #include <bits/stdc++.h>
#define inf 10000000
using namespace std;
typedef long long int ll;
int main() {
int s, i, j, ans = 0;
cin >> s;
int a[inf];
a[0] = s;
for (i = 1; ans == 0; i++) {
if (s % 2 == 0) {
a[i] = s / 2;
s = a[i];
} else {
a[i] = 3 * s + 1;
s = a[i];
}
for (j = i - 1; j > 0; j--) {
if (a[i] == a[j]) {
ans = i + 1;
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define inf 10000000
using namespace std;
typedef long long int ll;
int main() {
int s, i, j, ans = 0;
cin >> s;
int a[1000000];
a[0] = s;
for (i = 1; ans == 0; i++) {
if (s % 2 == 0) {
a[i] = s / 2;
s = a[i];
} else {
a[i] = 3 * s + 1;
s = a[i];
}
for (j = i - 1; j >= 0; j--) {
if (a[i] == a[j]) {
ans = i + 1;
}
}
}
cout << ans << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 946,058 | 946,059 | u654998183 | cpp |
p03146 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int s, m, i, j, k;
cin >> s;
int a[1000000];
a[0] = s;
m = 0;
for (i = 1; i < 1000000; i++) {
if (a[i - 1] % 2 == 0)
a[i] = a[i - 1] / 2;
else
a[i] = 3 * a[i - 1] + 1;
for (j = 0; j < i; j++) {
if (a[i] == a[j]) {
m = i + 1;
break;
}
}
if (m == i)
break;
}
cout << m;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int s, m, i, j, k;
cin >> s;
int a[1000000];
a[0] = s;
m = 0;
for (i = 1; i < 1000000; i++) {
if (a[i - 1] % 2 == 0)
a[i] = a[i - 1] / 2;
else
a[i] = 3 * a[i - 1] + 1;
for (j = 0; j < i; j++) {
if (a[i] == a[j]) {
m = i;
break;
}
}
if (m == i)
break;
}
cout << m + 1;
return 0;
}
| [
"expression.operation.binary.remove"
] | 946,062 | 946,063 | u809278162 | cpp |
p03146 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int s, m, i, j, k;
cin >> s;
int a[1000000];
a[0] = s;
m = 0;
for (i = 1; i < 1000000; i++) {
if (a[i - 1] % 2 == 0)
a[i] = a[i - 1] / 2;
else
a[i] = 3 * a[i - 1] + 1;
for (j = 0; j < i; j++) {
if (a[i] == a[j]) {
m = i;
break;
}
}
if (m == i)
break;
}
cout << m;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <string>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
int s, m, i, j, k;
cin >> s;
int a[1000000];
a[0] = s;
m = 0;
for (i = 1; i < 1000000; i++) {
if (a[i - 1] % 2 == 0)
a[i] = a[i - 1] / 2;
else
a[i] = 3 * a[i - 1] + 1;
for (j = 0; j < i; j++) {
if (a[i] == a[j]) {
m = i;
break;
}
}
if (m == i)
break;
}
cout << m + 1;
return 0;
}
| [
"expression.operation.binary.add"
] | 946,064 | 946,063 | u809278162 | cpp |
p03146 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v;
v.push_back(n);
long long cnt = 1;
while (1) {
if (n & 1) {
if (find(v.begin(), v.end(), 3 * n + 1) != v.end())
break;
cnt++;
v.push_back(3 * n + 1);
n = 3 * n + 1;
} else {
if (find(v.begin(), v.end(), n / 2) != v.end())
break;
cnt++;
v.push_back(n / 2);
n /= 2;
}
}
cout << cnt << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v;
v.push_back(n);
long long cnt = 1;
while (1) {
if (n & 1) {
if (find(v.begin(), v.end(), 3 * n + 1) != v.end())
break;
cnt++;
v.push_back(3 * n + 1);
n = 3 * n + 1;
} else {
if (find(v.begin(), v.end(), n / 2) != v.end())
break;
cnt++;
v.push_back(n / 2);
n /= 2;
}
}
cout << cnt + 1 << "\n";
return 0;
}
| [
"expression.operation.binary.add"
] | 946,065 | 946,066 | u324004208 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9 + 7)
int main() {
ll n, k;
cin >> n >> k;
vector<pll> dt(n);
for (int i = 0; i < n; i++) {
cin >> dt[i].second >> dt[i].first;
}
sort(dt.begin(), dt.end());
reverse(dt.begin(), dt.end());
//寿司は価値，種類の順に管理
map<ll, ll> eat;
ll val = 0; //食べた寿司の価値
//価値の高い順にk個食べるとする，種類と食べた数をmapで管理
for (int i = 0; i < k; i++) {
eat[dt[i].second]++;
val += dt[i].first;
}
ll pd = k;
ll pu = k - 1;
ll diverse = ll(eat.size()); //現在の種類数
ll ans = val + diverse * diverse;
while (pu != -1 && pd != n) {
while (eat[dt[pd].second] >
0) { //食べてない種類の寿司で価値の高いものを食べる
pd++;
if (pd == n)
break;
}
while (eat[dt[pu].second] ==
1) { // 2個以上食べた種類で価値の低いものを捨てる
pu--;
if (pu == -1)
break;
}
if (pu == -1 || pd == n) {
break;
}
val += dt[pd].first;
eat[dt[pd].second]++;
val -= dt[pu].first;
eat[dt[pu].second]--;
diverse++;
ans = max(ans, val + diverse * diverse);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9 + 7)
int main() {
ll n, k;
cin >> n >> k;
vector<pll> dt(n);
for (int i = 0; i < n; i++) {
cin >> dt[i].second >> dt[i].first;
}
sort(dt.begin(), dt.end());
reverse(dt.begin(), dt.end());
//寿司は価値，種類の順に管理
map<ll, ll> eat;
ll val = 0; //食べた寿司の価値
//価値の高い順にk個食べるとする，種類と食べた数をmapで管理
for (int i = 0; i < k; i++) {
eat[dt[i].second]++;
val += dt[i].first;
}
ll pd = k;
ll pu = k - 1;
ll diverse = ll(eat.size()); //現在の種類数
ll ans = val + diverse * diverse;
while (pu != -1 && pd != n) {
while (eat[dt[pd].second] >
0) { //食べてない種類の寿司で価値の高いものを食べる
pd++;
if (pd == n)
break;
}
while (eat[dt[pu].second] ==
1) { // 2個以上食べた種類で価値の低いものを捨てる
pu--;
if (pu == -1)
break;
}
if (pu == -1 || pd == n) {
break;
}
val += dt[pd].first;
eat[dt[pd].second]++;
val -= dt[pu].first;
eat[dt[pu].second]--;
diverse++;
ans = max(ans, val + diverse * diverse);
pu--;
}
cout << ans << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 946,080 | 946,081 | u777468981 | cpp |
p03148 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
ll N, K, t, d;
vector<pair<ll, int>> v;
int main() {
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> t >> d;
v.push_back({d, t});
}
map<int, ll> m;
sort(v.begin(), v.end());
ll ans = 0, sum = 0, cnt = 0, r = 0;
for (int i = N - 1; i >= 0; i--) {
if (i >= N - K) {
m[v[i].second]++;
sum += v[i].first;
if (i == N - K) {
ll s = m.size();
ans = sum + s * s;
r = N - K;
}
} else {
if (!m.count(v[i].second)) {
m[v[i].second]++;
while (r <= N - 1 && m[v[r].second] == 1)
r++;
if (r == N)
break;
sum += v[i].first - v[r].first;
m[v[r].second]--;
ll s = m.size();
ans = max(ans, sum + s * s);
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
ll N, K, t, d;
vector<pair<ll, int>> v;
int main() {
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> t >> d;
v.push_back({d, t});
}
map<int, ll> m;
sort(v.begin(), v.end());
ll ans = 0, sum = 0, cnt = 0, r = 0;
for (int i = N - 1; i >= 0; i--) {
if (i >= N - K) {
m[v[i].second]++;
sum += v[i].first;
if (i == N - K) {
ll s = m.size();
ans = sum + s * s;
r = N - K;
}
} else {
if (!m.count(v[i].second)) {
m[v[i].second]++;
while (r <= N - 1 && m[v[r].second] == 1)
r++;
if (r == N)
break;
sum += v[i].first - v[r].first;
m[v[r].second]--;
r++;
ll s = m.size();
ans = max(ans, sum + s * s);
}
}
}
cout << ans << endl;
} | [
"expression.unary.arithmetic.add"
] | 946,114 | 946,115 | u623954643 | cpp |
p03148 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
using namespace std;
struct food {
int t;
int d;
bool operator<(const food b) const { return d > b.d; }
} a[100000 + 5];
int n, k;
queue<int> q;
set<int> s;
long long sum = 0, sum1;
int main(int argc, char *argv[]) {
cin >> n >> k;
for (int i = 0; i < n; i++)
scanf("%d %d", &a[i].t, &a[i].d);
sort(a, a + n);
for (int i = 0; i < k; i++) {
sum += a[i].d;
if (s.count(a[i].t))
q.push(a[i].d);
s.insert(a[i].t);
}
sum += s.size() * s.size();
sum1 = sum;
int i = k;
while (i < n && !q.empty()) {
if (!s.count(a[i].t)) {
sum1 = sum1 - q.front() + a[i].d - s.size() * s.size() +
(s.size() + 1) * (s.size() + 1);
q.pop();
s.insert(a[i].t);
sum = max(sum1, sum);
// sum1=sum;
}
i++;
}
cout << sum << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
#include <set>
#include <stack>
using namespace std;
struct food {
int t;
int d;
bool operator<(const food b) const { return d > b.d; }
} a[100000 + 5];
int n, k;
stack<int> q;
set<int> s;
long long sum = 0, sum1;
int main(int argc, char *argv[]) {
cin >> n >> k;
for (int i = 0; i < n; i++)
scanf("%d %d", &a[i].t, &a[i].d);
sort(a, a + n);
for (int i = 0; i < k; i++) {
sum += a[i].d;
if (s.count(a[i].t))
q.push(a[i].d);
s.insert(a[i].t);
}
sum += s.size() * s.size();
sum1 = sum;
int i = k;
while (i < n && !q.empty()) {
if (!s.count(a[i].t)) {
sum1 = sum1 - q.top() + a[i].d - s.size() * s.size() +
(s.size() + 1) * (s.size() + 1);
q.pop();
s.insert(a[i].t);
sum = max(sum1, sum);
// sum1=sum;
}
i++;
}
cout << sum << '\n';
return 0;
} | [
"import.add",
"variable_declaration.type.change",
"assignment.value.change",
"call.function.change",
"expression.operation.binary.change"
] | 946,124 | 946,125 | u601344838 | cpp |
p03148 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
pair<ll, int> a[n] = {};
for (int i = 0; i < n; i++) {
cin >> a[i].second >> a[i].first;
}
sort(a, a + n);
reverse(a, a + n);
priority_queue<ll, vector<ll>, greater<ll>> dupq;
int kinds = 0;
set<int> s;
ll sum = 0;
ll cnt = 0;
for (int i = 0; i < k; i++) {
if (s.count(a[i].second) == 0) {
s.insert(a[i].second);
cnt++;
} else {
dupq.push(a[i].first);
}
sum += a[i].first;
}
ll ans = sum + cnt * cnt;
for (int i = k; i < n; i++) {
if (cnt > k)
break;
if (s.count(a[i].second) == 1)
continue;
cnt++;
s.insert(a[i].second);
sum -= dupq.top();
dupq.pop();
sum += a[i].first;
ans = max(ans, sum + cnt * cnt);
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
pair<ll, int> a[n] = {};
for (int i = 0; i < n; i++) {
cin >> a[i].second >> a[i].first;
}
sort(a, a + n);
reverse(a, a + n);
priority_queue<ll, vector<ll>, greater<ll>> dupq;
int kinds = 0;
set<int> s;
ll sum = 0;
ll cnt = 0;
for (int i = 0; i < k; i++) {
if (s.count(a[i].second) == 0) {
s.insert(a[i].second);
cnt++;
} else {
dupq.push(a[i].first);
}
sum += a[i].first;
}
ll ans = sum + cnt * cnt;
for (int i = k; i < n; i++) {
if (cnt >= k)
break;
if (s.count(a[i].second) == 1)
continue;
cnt++;
s.insert(a[i].second);
sum -= dupq.top();
dupq.pop();
sum += a[i].first;
ans = max(ans, sum + cnt * cnt);
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 946,150 | 946,151 | u411418267 | cpp |
p03148 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
ll f[100001];
int main() {
int n, K;
cin >> n >> K;
vector<pii> v(n);
for (int i = 0; i < n; ++i) {
ll t, d;
cin >> t >> d;
v[i] = {d, t};
}
sort(v.begin(), v.end(), greater<pii>());
ll kind = 0;
ll st = 0;
for (int i = 0; i < K; ++i) {
if (f[v[i].second] == 0) {
kind++;
}
f[v[i].second]++;
st += v[i].first;
}
queue<ll> yobi;
for (int i = K; i < n; ++i) {
if (f[v[i].second] == 0) {
yobi.push(v[i].first);
}
f[v[i].second]++;
}
ll ans = st + (ll)kind * kind;
for (int i = n - 1; i >= 0; --i) {
if (yobi.empty())
break;
if (f[v[i].second] > 1) {
kind++;
st -= v[i].first;
st += yobi.front();
yobi.pop();
ans = max(ans, st + (ll)kind * kind);
f[v[i].second]--;
}
}
cout << ans << endl;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
ll f[100001];
int main() {
int n, K;
cin >> n >> K;
vector<pii> v(n);
for (int i = 0; i < n; ++i) {
ll t, d;
cin >> t >> d;
v[i] = {d, t};
}
sort(v.begin(), v.end(), greater<pii>());
ll kind = 0;
ll st = 0;
for (int i = 0; i < K; ++i) {
if (f[v[i].second] == 0) {
kind++;
}
f[v[i].second]++;
st += v[i].first;
}
queue<ll> yobi;
for (int i = K; i < n; ++i) {
if (f[v[i].second] == 0) {
yobi.push(v[i].first);
f[v[i].second]++;
}
}
ll ans = st + (ll)kind * kind;
for (int i = K - 1; i >= 0; --i) {
if (yobi.empty())
break;
if (f[v[i].second] > 1) {
kind++;
st -= v[i].first;
st += yobi.front();
yobi.pop();
ans = max(ans, st + (ll)kind * kind);
f[v[i].second]--;
}
}
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.change"
] | 946,160 | 946,159 | u402472923 | cpp |
p03148 | #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
int K, N;
int t[100005];
long long int d[100005];
int C[100005];
vector<pair<long long int, int>> V;
multiset<pair<long long int, int>> S;
int main(void) {
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> t[i] >> d[i];
}
for (int i = 1; i <= N; i++) {
V.push_back(pair<long long int, int>(d[i], t[i]));
}
sort(V.rbegin(), V.rend());
/*for (int i = 0; i < N; i++) {
cout << "d= " << V[i].first << " t= " << V[i].second << endl;
}*/
long long int num = 0;
long long int sum = 0;
for (int i = 0; i < K; i++) {
long long int D = V[i].first;
int K = V[i].second;
sum += D;
if (C[K] == 0) {
num++;
C[K]++;
} else {
C[K]++;
S.insert(V[i]);
}
}
long long int ans = 0;
ans = sum + num * num;
// cout << "sum= " << sum << " num= " << num << " ans= " << ans << endl;
for (int i = K; i < N; i++) {
// cout << "size= " << S.size() << endl;
if (S.size() == 0) {
break;
}
auto it = S.end();
it--;
long long int D = (*it).first;
int K = (*it).second;
// cout << "D= " << D << " K= " << K << endl;
sum -= D;
C[K]--;
if (C[K] == 0) {
num--;
}
S.erase(it);
D = V[i].first;
K = V[i].second;
// cout << "D= " << D << " K= " << K << endl;
sum += D;
if (C[K] == 0) {
num++;
C[K]++;
} else {
C[K]++;
S.insert(V[i]);
}
// cout << "sum= " << sum << " num= " << num << " ans= " << ans << endl;
ans = max(ans, sum + num * num);
}
cout << ans << endl;
// system("pause");
return 0;
} | #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
int K, N;
int t[100005];
long long int d[100005];
int C[100005];
vector<pair<long long int, int>> V;
multiset<pair<long long int, int>> S;
int main(void) {
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> t[i] >> d[i];
}
for (int i = 1; i <= N; i++) {
V.push_back(pair<long long int, int>(d[i], t[i]));
}
sort(V.rbegin(), V.rend());
/*for (int i = 0; i < N; i++) {
cout << "d= " << V[i].first << " t= " << V[i].second << endl;
}*/
long long int num = 0;
long long int sum = 0;
for (int i = 0; i < K; i++) {
long long int D = V[i].first;
int K = V[i].second;
sum += D;
if (C[K] == 0) {
num++;
C[K]++;
} else {
C[K]++;
S.insert(V[i]);
}
}
long long int ans = 0;
ans = sum + num * num;
// cout << "sum= " << sum << " num= " << num << " ans= " << ans << endl;
for (int i = K; i < N; i++) {
// cout << "size= " << S.size() << endl;
if (S.size() == 0) {
break;
}
auto it = S.begin();
// it++;
long long int D = (*it).first;
int K = (*it).second;
// cout << "D= " << D << " K= " << K << endl;
sum -= D;
C[K]--;
if (C[K] == 0) {
num--;
}
S.erase(it);
D = V[i].first;
K = V[i].second;
// cout << "D= " << D << " K= " << K << endl;
sum += D;
if (C[K] == 0) {
num++;
C[K]++;
} else {
C[K]++;
S.insert(V[i]);
}
// cout << "sum= " << sum << " num= " << num << " ans= " << ans << endl;
ans = max(ans, sum + num * num);
}
cout << ans << endl;
// system("pause");
return 0;
} | [
"call.function.change",
"expression.unary.arithmetic.remove"
] | 946,166 | 946,167 | u835297884 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
#define int long long
//#define uint __int128_t
#define pb push_back
#define fi first
#define se second
#define rep(i, s, n) for (int i = s; i < n; i++)
#define repe(i, s, n) for (int i = s; i <= n; i++)
#define rrep(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define all(v) (v).begin(), (v).end()
#define chmin(a, b) a = min((a), (b))
#define chmax(a, b) a = max((a), (b))
#define low(a, b) lower_bound(all(a), (b)) - (a).begin()
#define upp(a, b) upper_bound(all(a), (b)) - (a).begin()
#define endl '\n'
#define IOS() \
ios_base::sync_with_stdio(0); \
cin.tie(0)
typedef long long ll;
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<pint> vpint;
typedef pair<pint, int> P1;
typedef pair<int, pint> P2;
typedef pair<pint, pint> PP;
static const ll maxLL = (ll)1 << 62;
const ll MOD = 1000000007;
const ll INF = 1e18;
int N, K;
vpint v;
int ans1 = 0, ans2 = 0;
int cntcnt[100010];
int cntcntcnt = 0;
int memo[100010];
signed main() {
IOS();
//(1ll<<N)シフト演算のオーバーフローに気をつける
// MOD同士の引き算に注意
cin >> N >> K;
v.resize(N);
rep(i, 0, N) {
int a, b;
cin >> a >> b;
v[i] = pint(b, a);
}
sort(all(v));
reverse(all(v));
vint used(100010, 0);
int x = 0;
rep(i, 0, K) {
x += v[i].fi;
if (used[v[i].se] == 0) {
used[v[i].se] = 1;
cntcntcnt++;
}
}
x += cntcntcnt * cntcntcnt;
int tasu = 0;
ans1 = 0;
vint used1(100010, 0);
int cnt = 0;
rep(i, 0, N) {
if (!cntcnt[v[i].se]) {
used1[i] = 1;
cntcnt[v[i].se] = 1;
ans1 += v[i].fi;
memo[cnt] = v[i].fi;
cnt++;
tasu++;
}
if (cnt == K) {
break;
}
}
sort(memo, memo + cnt);
int memocnt = 0;
rep(i, 0, N) {
if (tasu == K)
break;
if (!used1[i]) {
ans1 += v[i].fi;
used1[i] = true;
}
}
rep(i, 0, N) {
if (used1[i])
continue;
if (ans1 + cnt * cnt <=
ans1 - memo[memocnt] + (cnt - 1) * (cnt - 1) + v[i].fi) {
ans1 -= memo[memocnt];
ans1 += v[i].fi;
memocnt++;
cnt--;
}
if (cnt == 1)
break;
}
cout << max(x, cnt * cnt + ans1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
//#define uint __int128_t
#define pb push_back
#define fi first
#define se second
#define rep(i, s, n) for (int i = s; i < n; i++)
#define repe(i, s, n) for (int i = s; i <= n; i++)
#define rrep(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define all(v) (v).begin(), (v).end()
#define chmin(a, b) a = min((a), (b))
#define chmax(a, b) a = max((a), (b))
#define low(a, b) lower_bound(all(a), (b)) - (a).begin()
#define upp(a, b) upper_bound(all(a), (b)) - (a).begin()
#define endl '\n'
#define IOS() \
ios_base::sync_with_stdio(0); \
cin.tie(0)
typedef long long ll;
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<pint> vpint;
typedef pair<pint, int> P1;
typedef pair<int, pint> P2;
typedef pair<pint, pint> PP;
static const ll maxLL = (ll)1 << 62;
const ll MOD = 1000000007;
const ll INF = 1e18;
int N, K;
vpint v;
int ans1 = 0, ans2 = 0;
int cntcnt[100010];
int cntcntcnt = 0;
int memo[100010];
signed main() {
IOS();
//(1ll<<N)シフト演算のオーバーフローに気をつける
// MOD同士の引き算に注意
cin >> N >> K;
v.resize(N);
rep(i, 0, N) {
int a, b;
cin >> a >> b;
v[i] = pint(b, a);
}
sort(all(v));
reverse(all(v));
vint used(100010, 0);
int x = 0;
rep(i, 0, K) {
x += v[i].fi;
if (used[v[i].se] == 0) {
used[v[i].se] = 1;
cntcntcnt++;
}
}
x += cntcntcnt * cntcntcnt;
int tasu = 0;
ans1 = 0;
vint used1(100010, 0);
int cnt = 0;
rep(i, 0, N) {
if (!cntcnt[v[i].se]) {
used1[i] = 1;
cntcnt[v[i].se] = 1;
ans1 += v[i].fi;
memo[cnt] = v[i].fi;
cnt++;
tasu++;
}
if (cnt == K) {
break;
}
}
sort(memo, memo + cnt);
int memocnt = 0;
rep(i, 0, N) {
if (tasu == K)
break;
if (!used1[i]) {
ans1 += v[i].fi;
used1[i] = true;
tasu++;
}
}
rep(i, 0, N) {
if (used1[i])
continue;
if (ans1 + cnt * cnt <=
ans1 - memo[memocnt] + (cnt - 1) * (cnt - 1) + v[i].fi) {
ans1 -= memo[memocnt];
ans1 += v[i].fi;
memocnt++;
cnt--;
}
if (cnt == 1)
break;
}
cout << max(x, cnt * cnt + ans1) << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 946,170 | 946,171 | u693027786 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long K, std::vector<long long> t,
std::vector<long long> d) {
vector<pair<long long, long long>> vs;
for (int i = 0; i < K; i++) {
vs.push_back({d[i], t[i]});
}
sort(vs.rbegin(), vs.rend());
for (int i = 0; i < vs.size(); i++)
swap(vs[i].first, vs[i].second);
long long tot = 0;
set<long long> ts;
vector<long long> remCand;
for (int i = 0; i < K; i++) {
if (!ts.count(vs[i].first)) {
ts.insert(vs[i].first);
} else {
remCand.push_back(vs[i].second);
}
tot += vs[i].second;
}
sort(remCand.rbegin(), remCand.rend());
long long ans = tot + 1ll * ts.size() * ts.size();
for (int i = K; i < N; i++) {
if (!ts.count(vs[i].first) && remCand.size() > 0) {
tot += vs[i].second;
tot -= remCand.back();
remCand.pop_back();
ts.insert(vs[i].first);
ans = max<long long>(tot + 1ll * ts.size() * ts.size(), ans);
}
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
std::vector<long long> t(N);
std::vector<long long> d(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &t[i]);
scanf("%lld", &d[i]);
}
solve(N, K, std::move(t), std::move(d));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long K, std::vector<long long> t,
std::vector<long long> d) {
vector<pair<long long, long long>> vs;
for (int i = 0; i < N; i++) {
vs.push_back({d[i], t[i]});
}
sort(vs.rbegin(), vs.rend());
for (int i = 0; i < vs.size(); i++)
swap(vs[i].first, vs[i].second);
long long tot = 0;
set<long long> ts;
vector<long long> remCand;
for (int i = 0; i < K; i++) {
if (!ts.count(vs[i].first)) {
ts.insert(vs[i].first);
} else {
remCand.push_back(vs[i].second);
}
tot += vs[i].second;
}
sort(remCand.rbegin(), remCand.rend());
long long ans = tot + 1ll * ts.size() * ts.size();
for (int i = K; i < N; i++) {
if (!ts.count(vs[i].first) && remCand.size() > 0) {
tot += vs[i].second;
tot -= remCand.back();
remCand.pop_back();
ts.insert(vs[i].first);
ans = max<long long>(tot + 1ll * ts.size() * ts.size(), ans);
}
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
std::vector<long long> t(N);
std::vector<long long> d(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &t[i]);
scanf("%lld", &d[i]);
}
solve(N, K, std::move(t), std::move(d));
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 946,172 | 946,173 | u372633838 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(10);
}
} fast;
/* define */
#define FOR(I, X, Y) for (long long(I) = (X); (I) < (Y); (I)++)
#define REP(I, X, Y) for (long long(I) = (Y)-1; (I) >= (X); (I)--)
#define ALL(X) (X).begin(), (X).end()
#define pb push_back
#define COUNT(V, X) \
(upper_bound((V).begin(), (V).end(), X) - \
lower_bound((V).begin(), (V).end(), X))
#define debug(x) cerr << #x << ':' << x << endl;
#define DEBUG(v) \
cerr << #v << ':'; \
for (auto xXx : v) \
cerr << xXx << ' '; \
cerr << endl;
#define Yes(X) \
if (X) { \
cout << "Yes" << endl; \
} else { \
cout << "No" << endl; \
}
#define YES(X) \
if (X) { \
cout << "YES" << endl; \
} else { \
cout << "NO" << endl; \
}
#define ctoi(C) (C - '0')
/* alias */
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vii = vector<vector<int>>;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using pi = pair<int, int>;
using pl = pair<long long, long long>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const long long dx[] = {1, 0, -1, 0};
const long long dy[] = {0, 1, 0, -1};
const long long dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long dx9[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
const int INF = 1000000007;
const long long LINF = 1000000000000000007;
/* func */
template <typename T> inline bool chmin(T &a, const T &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b)
a = b;
return a < b;
}
long long max(long long x, int y) { return max(x, (long long)y); }
long long max(int x, long long y) { return max((long long)x, y); }
long long min(long long x, int y) { return min(x, (long long)y); }
long long min(int x, long long y) { return min((long long)x, y); }
/* liblary */
/* main */
signed main() {
ll N, K;
cin >> N >> K;
vector<pair<ll, ll>> v;
FOR(i, 0, N) {
ll t, d;
cin >> t >> d;
t--;
v.pb(make_pair(t, d));
}
sort(ALL(v), greater<pair<ll, ll>>());
FOR(i, 0, N) { cerr << v[i].first << ' ' << v[i].second << endl; }
bool used[N] = {0};
vl yay;
vl yay2;
ll pre = -1;
FOR(i, 0, N) {
if (pre != v[i].first) {
yay.pb(v[i].second);
used[i] = 1;
}
pre = v[i].first;
}
FOR(i, 0, N) {
if (!used[i]) {
yay2.pb(v[i].second);
}
}
ll ans = 0;
sort(ALL(yay), greater<ll>());
sort(ALL(yay2), greater<ll>());
DEBUG(yay)
DEBUG(yay2)
FOR(i, 1, yay.size()) yay[i] += yay[i - 1];
FOR(i, 1, yay2.size()) yay2[i] += yay2[i - 1];
FOR(i, max(K - yay2.size(), 0), min(K, yay.size()) + 1) {
ll answer = yay[i - 1] + i * i;
ll counter = K - i;
if (counter == 0)
chmax(ans, answer);
else if (counter - 1 < yay2.size()) {
answer += yay2[counter - 1];
chmax(ans, answer);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(10);
}
} fast;
/* define */
#define FOR(I, X, Y) for (long long(I) = (X); (I) < (Y); (I)++)
#define REP(I, X, Y) for (long long(I) = (Y)-1; (I) >= (X); (I)--)
#define ALL(X) (X).begin(), (X).end()
#define pb push_back
#define COUNT(V, X) \
(upper_bound((V).begin(), (V).end(), X) - \
lower_bound((V).begin(), (V).end(), X))
#define debug(x) cerr << #x << ':' << x << endl;
#define DEBUG(v) \
cerr << #v << ':'; \
for (auto xXx : v) \
cerr << xXx << ' '; \
cerr << endl;
#define Yes(X) \
if (X) { \
cout << "Yes" << endl; \
} else { \
cout << "No" << endl; \
}
#define YES(X) \
if (X) { \
cout << "YES" << endl; \
} else { \
cout << "NO" << endl; \
}
#define ctoi(C) (C - '0')
/* alias */
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vii = vector<vector<int>>;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using pi = pair<int, int>;
using pl = pair<long long, long long>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const long long dx[] = {1, 0, -1, 0};
const long long dy[] = {0, 1, 0, -1};
const long long dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long dx9[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
const int INF = 1000000007;
const long long LINF = 1000000000000000007;
/* func */
template <typename T> inline bool chmin(T &a, const T &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T> inline bool chmax(T &a, const T &b) {
if (a < b)
a = b;
return a < b;
}
long long max(long long x, int y) { return max(x, (long long)y); }
long long max(int x, long long y) { return max((long long)x, y); }
long long min(long long x, int y) { return min(x, (long long)y); }
long long min(int x, long long y) { return min((long long)x, y); }
/* liblary */
/* main */
signed main() {
ll N, K;
cin >> N >> K;
vector<pair<ll, ll>> v;
FOR(i, 0, N) {
ll t, d;
cin >> t >> d;
t--;
v.pb(make_pair(t, d));
}
sort(ALL(v), greater<pair<ll, ll>>());
FOR(i, 0, N) { cerr << v[i].first << ' ' << v[i].second << endl; }
bool used[N] = {0};
vl yay;
vl yay2;
ll pre = -1;
FOR(i, 0, N) {
if (pre != v[i].first) {
yay.pb(v[i].second);
used[i] = 1;
}
pre = v[i].first;
}
FOR(i, 0, N) {
if (!used[i]) {
yay2.pb(v[i].second);
}
}
ll ans = 0;
sort(ALL(yay), greater<ll>());
sort(ALL(yay2), greater<ll>());
DEBUG(yay)
DEBUG(yay2)
FOR(i, 1, yay.size()) yay[i] += yay[i - 1];
FOR(i, 1, yay2.size()) yay2[i] += yay2[i - 1];
FOR(i, max(K - yay2.size(), 1), min(K, yay.size()) + 1) {
ll answer = yay[i - 1] + i * i;
ll counter = K - i;
if (counter == 0)
chmax(ans, answer);
else if (counter - 1 < yay2.size()) {
answer += yay2[counter - 1];
chmax(ans, answer);
}
}
cout << ans << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 946,184 | 946,185 | u205561862 | cpp |
p03148 | #include <bits/stdc++.h>
#define pb push_back
#define REP(i, n) for (signed long long i = 0; i < (n); i++)
#define MOD 1000000007
#define INF 98765431219876543
#define bitcnt(a) (ll) __builtin_popcount((a))
#define lb(a, b) lower_bound((a).begin(), (a).end(), (b))
#define ub(a, b) upper_bound((a).begin(), (a).end(), (b))
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<string, string> PS;
ll n, k;
bool vis[114514], fir[114514];
vector<ll> alr;
vector<P> v;
int main() {
cin >> n >> k;
REP(i, n) {
ll a, b;
cin >> a >> b;
v.pb(P(b, a));
}
sort(v.begin(), v.end(), greater<P>());
REP(i, v.size()) {
if (vis[v[i].second] == true) {
alr.pb(v[i].first);
} else {
vis[v[i].second] = true;
fir[i] = true;
}
}
ll sum = 0, ans = 0, spe = 0;
REP(i, k) {
sum = ans = sum + v[i].first;
if (fir[i]) {
spe++;
}
}
ans += spe * spe;
sum += spe * spe;
for (ll i = k; i < n; i++) {
if (fir[i] == 1 && alr.size()) {
spe++;
sum -= alr.back();
alr.pop_back();
sum += v[i].first;
sum += spe * spe - (spe - 1) * (spe - 1);
// cout << i << " " << sum << endl;
ans = max(ans, sum);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define pb push_back
#define REP(i, n) for (signed long long i = 0; i < (n); i++)
#define MOD 1000000007
#define INF 98765431219876543
#define bitcnt(a) (ll) __builtin_popcount((a))
#define lb(a, b) lower_bound((a).begin(), (a).end(), (b))
#define ub(a, b) upper_bound((a).begin(), (a).end(), (b))
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<string, string> PS;
ll n, k;
bool vis[114514], fir[114514];
vector<ll> alr;
vector<P> v;
int main() {
cin >> n >> k;
REP(i, n) {
ll a, b;
cin >> a >> b;
v.pb(P(b, a));
}
sort(v.begin(), v.end(), greater<P>());
REP(i, v.size()) {
if (vis[v[i].second] == true) {
if (i < k)
alr.pb(v[i].first);
} else {
vis[v[i].second] = true;
fir[i] = true;
}
}
ll sum = 0, ans = 0, spe = 0;
REP(i, k) {
sum = ans = sum + v[i].first;
if (fir[i]) {
spe++;
}
}
ans += spe * spe;
sum += spe * spe;
for (ll i = k; i < n; i++) {
if (fir[i] == 1 && alr.size()) {
spe++;
sum -= alr.back();
alr.pop_back();
sum += v[i].first;
sum += spe * spe - (spe - 1) * (spe - 1);
// cout << spe * spe - (spe - 1) * (spe - 1) << endl;
ans = max(ans, sum);
}
}
cout << ans << endl;
} | [
"control_flow.branch.if.add"
] | 946,188 | 946,189 | u451610133 | cpp |
p03148 | // https://atcoder.jp/contests/abc116/tasks/abc116_d
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#ifdef BTK
#define DEBUG if (1)
#else
#define CIN_ONLY if (1)
struct cww {
cww() {
CIN_ONLY {
ios::sync_with_stdio(false);
cin.tie(0);
}
}
} star;
#define DEBUG if (0)
#endif
#define ALL(v) (v).begin(), (v).end()
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
template <typename T> inline bool chmin(T &l, T r) {
bool a = l > r;
if (a)
l = r;
return a;
}
template <typename T> inline bool chmax(T &l, T r) {
bool a = l < r;
if (a)
l = r;
return a;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I &lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
reverse_range(int n) : i({0}), n({n}) {}
reverse_range(int i, int n) : i({i}), n({n}) {}
I &begin() { return n; }
I &end() { return i; }
};
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
I &begin() { return i; }
I &end() { return n; }
reverse_range operator!() { return reverse_range(*i, *n); }
};
int N, K;
int t[112345];
LL d[112345];
int o[112345];
int used[112345];
int main() {
cin >> N >> K;
for (int i : range(N)) {
cin >> t[i] >> d[i];
t[i]--;
}
iota(o, o + N, 0);
sort(o, o + N, [&](int l, int r) { return d[l] < d[r]; });
reverse(o, o + N);
LL use = 0;
LL sum = 0;
stack<LL> x;
for (int _i : range(K)) {
int i = o[_i];
if (used[t[i]])
x.push(d[i]);
else {
used[t[i]] = 1;
use++;
}
sum += d[i];
}
LL ret = use * use + sum;
for (int _i : range(K, N)) {
if (x.empty())
break;
int i = o[_i];
if (used[t[i]])
continue;
used[t[i]] = 1;
use++;
sum += t[i];
sum -= x.top();
x.pop();
chmax(ret, use * use + sum);
}
cout << ret << endl;
return 0;
} | // https://atcoder.jp/contests/abc116/tasks/abc116_d
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#ifdef BTK
#define DEBUG if (1)
#else
#define CIN_ONLY if (1)
struct cww {
cww() {
CIN_ONLY {
ios::sync_with_stdio(false);
cin.tie(0);
}
}
} star;
#define DEBUG if (0)
#endif
#define ALL(v) (v).begin(), (v).end()
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
template <typename T> inline bool chmin(T &l, T r) {
bool a = l > r;
if (a)
l = r;
return a;
}
template <typename T> inline bool chmax(T &l, T r) {
bool a = l < r;
if (a)
l = r;
return a;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I &lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
reverse_range(int n) : i({0}), n({n}) {}
reverse_range(int i, int n) : i({i}), n({n}) {}
I &begin() { return n; }
I &end() { return i; }
};
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
I &begin() { return i; }
I &end() { return n; }
reverse_range operator!() { return reverse_range(*i, *n); }
};
int N, K;
int t[112345];
LL d[112345];
int o[112345];
int used[112345];
int main() {
cin >> N >> K;
for (int i : range(N)) {
cin >> t[i] >> d[i];
t[i]--;
}
iota(o, o + N, 0);
sort(o, o + N, [&](int l, int r) { return d[l] < d[r]; });
reverse(o, o + N);
LL use = 0;
LL sum = 0;
stack<LL> x;
for (int _i : range(K)) {
int i = o[_i];
if (used[t[i]])
x.push(d[i]);
else {
used[t[i]] = 1;
use++;
}
sum += d[i];
}
LL ret = use * use + sum;
for (int _i : range(K, N)) {
if (x.empty())
break;
int i = o[_i];
if (used[t[i]])
continue;
used[t[i]] = 1;
use++;
sum += d[i];
sum -= x.top();
x.pop();
chmax(ret, use * use + sum);
}
cout << ret << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 946,213 | 946,214 | u613658617 | cpp |
p03148 | #include <algorithm>
#include <cstdio>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int n, k;
map<int, vector<int>> m;
vector<vector<int> *> v;
priority_queue<int> p;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int t, d;
scanf("%d %d", &t, &d);
m[t].push_back(d);
}
for (map<int, vector<int>>::iterator i = m.begin(), e = m.end(); i != e;
i++) {
sort(i->second.begin(), i->second.end());
v.push_back(&i->second);
}
sort(v.begin(), v.end(),
[](const vector<int> *v1, const vector<int> *v2) -> bool {
return v1->back() > v2->back();
});
int vs = (k <= v.size()) ? k : v.size();
int ans[k];
for (int i = 0; i < vs; i++) {
ans[i] = v[i]->back();
v[i]->pop_back();
}
for (int i = 0; i < vs; i++) {
for (vector<int>::iterator j = v[i]->begin(), e = v[i]->end(); j != e;
j++) {
p.emplace(*j);
}
}
for (int i = vs; i < k; i++) {
ans[i] = p.top();
p.pop();
}
int x = vs;
while (true) {
if (ans[x - 1] + 2 * x - 1 >= p.top())
break;
ans[--x] = p.top();
p.pop();
}
long sum = 0;
for (int i = 0; i < k; i++)
sum += ans[i];
sum += static_cast<long>(x) * x;
printf("%ld\n", sum);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int n, k;
map<int, vector<int>> m;
vector<vector<int> *> v;
priority_queue<int> p;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int t, d;
scanf("%d %d", &t, &d);
m[t].push_back(d);
}
for (map<int, vector<int>>::iterator i = m.begin(), e = m.end(); i != e;
i++) {
sort(i->second.begin(), i->second.end());
v.push_back(&i->second);
}
sort(v.begin(), v.end(),
[](const vector<int> *v1, const vector<int> *v2) -> bool {
return v1->back() > v2->back();
});
int vs = (k <= v.size()) ? k : v.size();
int ans[k];
for (int i = 0; i < vs; i++) {
ans[i] = v[i]->back();
v[i]->pop_back();
}
for (int i = 0; i < vs; i++) {
for (vector<int>::iterator j = v[i]->begin(), e = v[i]->end(); j != e;
j++) {
p.emplace(*j);
}
}
for (int i = vs; i < k; i++) {
ans[i] = p.top();
p.pop();
}
int x = vs;
while (true) {
if (p.empty() || ans[x - 1] + 2 * x - 1 >= p.top())
break;
ans[--x] = p.top();
p.pop();
}
long sum = 0;
for (int i = 0; i < k; i++)
sum += ans[i];
sum += static_cast<long>(x) * x;
printf("%ld\n", sum);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 946,253 | 946,254 | u675757825 | cpp |
p03148 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define loop(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define debug(x) cout << #x << " = " << (x) << endl;
using namespace std;
using LL = long long;
using ULL = unsigned long long;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, LL>> sushi(n); // (t, d)
rep(i, n) {
int t;
LL d;
cin >> t >> d;
sushi[i] = make_pair(t - 1, d);
}
sort(sushi.begin(), sushi.end(),
[](const auto &a, const auto &b) { return a.second > b.second; });
map<int, LL> kinds;
LL sum = 0;
rep(i, k) {
auto td = sushi[i];
sum += td.second;
kinds[td.first]++;
}
LL ans = sum + kinds.size() * kinds.size();
int index = k - 1;
for (int i = k; i < n; i++) {
auto td = sushi[i];
if (kinds[td.first] != 0) {
continue;
} else {
kinds[td.first]++;
while (index > 0 and kinds[sushi[index].first] == 1) {
index--;
}
if (index == -1)
break;
sum += td.second - sushi[index].second;
kinds[sushi[index].first]--;
index--;
ans = max((LL)ans, sum + (LL)kinds.size() * (LL)kinds.size());
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define loop(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define debug(x) cout << #x << " = " << (x) << endl;
using namespace std;
using LL = long long;
using ULL = unsigned long long;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, LL>> sushi(n); // (t, d)
rep(i, n) {
int t;
LL d;
cin >> t >> d;
sushi[i] = make_pair(t - 1, d);
}
sort(sushi.begin(), sushi.end(),
[](const auto &a, const auto &b) { return a.second > b.second; });
map<int, LL> kinds;
LL sum = 0;
rep(i, k) {
auto td = sushi[i];
sum += td.second;
kinds[td.first]++;
}
LL ans = sum + kinds.size() * kinds.size();
int index = k - 1;
for (int i = k; i < n; i++) {
auto td = sushi[i];
if (kinds[td.first] != 0) {
continue;
} else {
kinds[td.first]++;
while (index >= 0 and kinds[sushi[index].first] == 1) {
index--;
}
if (index == -1)
break;
sum += td.second - sushi[index].second;
kinds[sushi[index].first]--;
index--;
ans = max(ans, sum + (LL)kinds.size() * (LL)kinds.size());
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 946,257 | 946,258 | u614063956 | cpp |
p03148 | #include <bits/stdc++.h>
#define ll long long
#define rep(X, N) for (ll X = 0; X < (N); X++)
#define bitrep(X, N) for (ll X = 0; X < (1 << (N)); X++)
#define PI (acos(-1.0))
#define sorta(V) sort(V.begin(), V.end())
#define pback push_back
#define mpair make_pair
#define MODN 1000000007
#define ALL(V) (V).begin(), (V).end()
using namespace std;
int main() {
//種類を考えずにk個分基礎ポイントが高いものをvectorに入れる
//その時の各種類の個数をカウントする残りのn-k個分についてそれが
//新しい種類のものなら上位k個のうちの基礎ポイントが低いほうから
//その種類のものが1個しか入っていないものと取り換えて総合ポイントを比較していく
int n, k;
cin >> n >> k;
vector<pair<ll, int>> v;
rep(i, n) {
int t;
ll d;
cin >> t >> d;
v.pback(mpair(d, t));
}
sort(ALL(v));
reverse(ALL(v));
//種類とその個数をいれるmap
map<int, int> m;
ll kind = 0;
ll basicp = 0;
rep(i, k) {
ll tmpd = v[i].first;
int tmpt = v[i].second;
if (m.find(tmpt) == m.end()) {
kind++;
}
m[tmpt] = m[tmpt]++;
basicp = basicp + tmpd;
}
vector<ll> point;
point.pback(basicp + kind * kind);
// cerr << basicp << " " << kind << endl;
int checkindex = k - 1;
for (int i = k; i < n; i++) {
ll tmpd = v[i].first;
int tmpt = v[i].second;
if (m[tmpt] == 0) {
while (checkindex >= 0 && m[v[checkindex].second] == 1) {
checkindex--;
}
if (checkindex >= 0) {
assert(m[v[checkindex].second] >= 2);
basicp = basicp - v[checkindex].first + tmpd;
kind++;
m[v[checkindex].second]--;
m[tmpt]++;
point.pback(basicp + kind * kind);
// cerr << basicp << " " << kind << endl;
checkindex--;
} else {
break;
}
}
}
sort(ALL(point));
cout << point[point.size() - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define rep(X, N) for (ll X = 0; X < (N); X++)
#define bitrep(X, N) for (ll X = 0; X < (1 << (N)); X++)
#define PI (acos(-1.0))
#define sorta(V) sort(V.begin(), V.end())
#define pback push_back
#define mpair make_pair
#define MODN 1000000007
#define ALL(V) (V).begin(), (V).end()
using namespace std;
int main() {
//種類を考えずにk個分基礎ポイントが高いものをvectorに入れる
//その時の各種類の個数をカウントする残りのn-k個分についてそれが
//新しい種類のものなら上位k個のうちの基礎ポイントが低いほうから
//その種類のものが1個しか入っていないものと取り換えて総合ポイントを比較していく
int n, k;
cin >> n >> k;
vector<pair<ll, int>> v;
rep(i, n) {
int t;
ll d;
cin >> t >> d;
v.pback(mpair(d, t));
}
sort(ALL(v));
reverse(ALL(v));
//種類とその個数をいれるmap
map<int, int> m;
ll kind = 0;
ll basicp = 0;
rep(i, k) {
ll tmpd = v[i].first;
int tmpt = v[i].second;
if (m.find(tmpt) == m.end()) {
kind++;
}
m[tmpt]++;
basicp = basicp + tmpd;
}
vector<ll> point;
point.pback(basicp + kind * kind);
// cerr << basicp << " " << kind << endl;
int checkindex = k - 1;
for (int i = k; i < n; i++) {
ll tmpd = v[i].first;
int tmpt = v[i].second;
if (m[tmpt] == 0) {
while (checkindex >= 0 && m[v[checkindex].second] == 1) {
checkindex--;
}
if (checkindex >= 0) {
// cerr << checkindex << " " << v[checkindex].second << " " <<
// m[v[checkindex].second] << endl;
assert(m[v[checkindex].second] >= 2);
basicp = basicp - v[checkindex].first + tmpd;
kind++;
m[v[checkindex].second]--;
m[tmpt]++;
point.pback(basicp + kind * kind);
// cerr << basicp << " " << kind << endl;
checkindex--;
} else {
break;
}
}
}
sort(ALL(point));
cout << point[point.size() - 1] << endl;
return 0;
} | [
"assignment.change"
] | 946,266 | 946,267 | u145078501 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> sushi(N);
map<ll, ll> type;
for (int i = 0; i < N; i++) {
int t, d;
cin >> t >> d;
sushi[i] = {d, t};
}
sort(sushi.begin(), sushi.end(), greater<pair<ll, ll>>());
ll ans = 0LL;
ll dsum = 0LL;
ll tsum = 0LL;
for (int i = 0; i < K; i++) {
dsum += sushi[i].first;
type[sushi[i].second]++;
}
tsum = type.size();
ans += dsum + tsum * tsum;
// cout << ans << endl;
int pre = K - 1, nxt = K;
while (true) {
while (pre >= 0 && type[sushi[pre].second] == 1)
pre--;
if (pre == -1)
break;
while (nxt < N && type[sushi[nxt].second] != 0)
nxt++;
if (nxt == N)
break;
dsum -= sushi[pre].first;
dsum += sushi[nxt].first;
tsum++;
ans = max(ans, dsum + tsum * tsum);
// if(ans == 27){
// cout << pre << nxt << type.size()<<endl;
// for(auto i=type.begin(); i!=type.end(); i++){
// cout << i->first << i->second << endl;
// }
// }
type[sushi[pre].second]--;
type[sushi[nxt].second]++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> sushi(N);
map<ll, ll> type;
for (int i = 0; i < N; i++) {
int t, d;
cin >> t >> d;
sushi[i] = {d, t};
}
sort(sushi.begin(), sushi.end(), greater<pair<ll, ll>>());
ll ans = 0LL;
ll dsum = 0LL;
ll tsum = 0LL;
for (int i = 0; i < K; i++) {
dsum += sushi[i].first;
type[sushi[i].second]++;
}
tsum = type.size();
ans += dsum + tsum * tsum;
int pre = K - 1, nxt = K;
while (true) {
while (pre >= 0 && type[sushi[pre].second] == 1)
pre--;
if (pre == -1)
break;
while (nxt < N && type[sushi[nxt].second] != 0)
nxt++;
if (nxt == N)
break;
dsum -= sushi[pre].first;
dsum += sushi[nxt].first;
tsum++;
ans = max(ans, dsum + tsum * tsum);
type[sushi[pre].second]--;
type[sushi[nxt].second]++;
pre--;
}
cout << ans << endl;
} | [
"expression.unary.arithmetic.add"
] | 946,268 | 946,269 | u052332717 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 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; }
// long longのシフト演算には気をつけよう
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> A(N);
for (int i = 0; i < N; i++) {
ll t;
cin >> t;
ll d;
cin >> d;
A[i] = {d, t};
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll dsum = 0;
map<ll, ll> ma;
for (int i = 0; i < K; i++) {
dsum += A[i].first;
ma[A[i].second]++;
}
ll ans = dsum + ma.size() * ma.size();
int r = K - 1;
for (int i = K; i < N; i++) {
if (ma[A[i].second] != 0)
continue;
while (ma[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
ma[A[r].second]--;
ma[A[i].second]++;
dsum = dsum + A[i].first - A[r].first;
ll tmp = dsum + ma.size() * ma.size();
ans = max(ans, tmp);
// r--;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 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; }
// long longのシフト演算には気をつけよう
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> A(N);
for (int i = 0; i < N; i++) {
ll t;
cin >> t;
ll d;
cin >> d;
A[i] = {d, t};
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll dsum = 0;
map<ll, ll> ma;
for (int i = 0; i < K; i++) {
dsum += A[i].first;
ma[A[i].second]++;
}
ll ans = dsum + ma.size() * ma.size();
int r = K - 1;
for (int i = K; i < N; i++) {
if (ma[A[i].second] != 0)
continue;
while (ma[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
ma[A[r].second]--;
ma[A[i].second]++;
dsum = dsum + A[i].first - A[r].first;
ll tmp = dsum + ma.size() * ma.size();
ans = max(ans, tmp);
r--; // <-これをしないとだめ。例えばma[A[r].second]=3とかだった時に次のループでまたrを抜くことになっちゃうけどもうそれは存在していないので
}
cout << ans << endl;
} | [
"expression.unary.arithmetic.add"
] | 946,270 | 946,271 | u052332717 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 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; }
// long longのシフト演算には気をつけよう
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> A(N);
for (int i = 0; i < N; i++) {
ll t;
cin >> t;
ll d;
cin >> d;
A[i] = {d, t};
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll dsum = 0;
map<ll, ll> ma;
for (int i = 0; i < K; i++) {
dsum += A[i].first;
ma[A[i].second]++;
}
ll ans = dsum + ma.size() * ma.size();
int r = K - 1;
for (int i = K; i < N; i++) {
if (ma[A[i].second] != 0)
continue;
while (ma[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
ma[A[r].second]--;
ma[A[i].second]++;
dsum = dsum + A[i].first - A[r].first;
ll tmp = dsum + ma.size() * ma.size();
ans = max(ans, tmp);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 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; }
// long longのシフト演算には気をつけよう
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> A(N);
for (int i = 0; i < N; i++) {
ll t;
cin >> t;
ll d;
cin >> d;
A[i] = {d, t};
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll dsum = 0;
map<ll, ll> ma;
for (int i = 0; i < K; i++) {
dsum += A[i].first;
ma[A[i].second]++;
}
ll ans = dsum + ma.size() * ma.size();
int r = K - 1;
for (int i = K; i < N; i++) {
if (ma[A[i].second] != 0)
continue;
while (ma[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
ma[A[r].second]--;
ma[A[i].second]++;
dsum = dsum + A[i].first - A[r].first;
ll tmp = dsum + ma.size() * ma.size();
ans = max(ans, tmp);
r--; // <-これをしないとだめ。例えばma[A[r].second]=3とかだった時に次のループでまたrを抜くことになっちゃうけどもうそれは存在していないので
}
cout << ans << endl;
} | [
"expression.unary.arithmetic.add"
] | 946,272 | 946,271 | u052332717 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 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; }
// long longのシフト演算には気をつけよう
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> A(N);
for (int i = 0; i < N; i++) {
ll t;
cin >> t;
ll d;
cin >> d;
A[i] = {d, t};
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll dsum = 0;
map<ll, ll> ma;
for (int i = 0; i < K; i++) {
dsum += A[i].first;
ma[A[i].second]++;
}
ll ans = dsum + ma.size() * ma.size();
int r = K - 1;
for (int i = K; i < N; i++) {
if (ma[A[i].second] != 0)
continue;
while (ma[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
ma[A[r].second]--;
ma[A[i].second]++;
dsum = dsum + A[i].first - A[r].first;
ll tmp = dsum + ma.size() * ma.size();
ans = max(ans, tmp);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// 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; }
// long longのシフト演算には気をつけよう
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, ll>> A(N);
for (int i = 0; i < N; i++) {
ll t;
cin >> t;
ll d;
cin >> d;
A[i] = {d, t};
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll dsum = 0;
map<ll, ll> ma;
for (int i = 0; i < K; i++) {
dsum += A[i].first;
ma[A[i].second]++;
}
ll ans = dsum + ma.size() * ma.size();
int r = K - 1;
for (int i = K; i < N; i++) {
if (ma[A[i].second] != 0)
continue;
while (ma[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
ma[A[r].second]--;
ma[A[i].second]++;
dsum = dsum + A[i].first - A[r].first;
ll tmp = dsum + ma.size() * ma.size();
ans = max(ans, tmp);
r--;
}
cout << ans << endl;
} | [
"expression.unary.arithmetic.add"
] | 946,272 | 946,273 | u052332717 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N, K;
cin >> N >> K;
pair<ll, int> A[N];
for (int i = 0; i < N; i++) {
ll t, d;
cin >> t >> d;
A[i] = {d, t};
}
sort(A, A + N);
reverse(A, A + N);
ll ans = 0, sum = 0;
map<int, ll> mp; // map<寿司の種類番号、その数>
for (int i = 0; i < K; i++) {
sum += A[i].first;
mp[A[i].second]++;
}
int s = mp.size();
ans = sum + s * s;
int r = K - 1; //集合から追い出す要素を指すインデックス
for (int i = K; i < N; i++) {
if (mp[A[i].second] == 0) {
while (mp[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
mp[A[i].second]++;
sum += A[i].first - A[r].first;
mp[A[r].second]--;
s = mp.size();
ans = max(ans, sum + s * s);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N, K;
cin >> N >> K;
pair<ll, int> A[N];
for (int i = 0; i < N; i++) {
ll t, d;
cin >> t >> d;
A[i] = {d, t};
}
sort(A, A + N);
reverse(A, A + N);
ll ans = 0, sum = 0;
map<int, ll> mp; // map<寿司の種類番号、その数>
for (int i = 0; i < K; i++) {
sum += A[i].first;
mp[A[i].second]++;
}
ll s = mp.size();
ans = sum + s * s;
int r = K - 1; //集合から追い出す要素を指すインデックス
for (int i = K; i < N; i++) {
if (mp[A[i].second] == 0) {
while (mp[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
mp[A[i].second]++;
sum += A[i].first - A[r].first;
mp[A[r].second]--;
r--;
s = mp.size();
ans = max(ans, sum + s * s);
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change",
"expression.unary.arithmetic.add"
] | 946,276 | 946,275 | u052332717 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N, K;
cin >> N >> K;
pair<ll, int> A[N];
for (int i = 0; i < N; i++) {
ll t, d;
cin >> t >> d;
A[i] = {d, t};
}
sort(A, A + N);
reverse(A, A + N);
ll ans = 0, sum = 0;
map<int, int> mp; // map<寿司の種類番号、その数>
for (int i = 0; i < K; i++) {
sum += A[i].first;
mp[A[i].second]++;
}
int s = mp.size();
ans = sum + s * s;
int r = K - 1; //集合から追い出す要素を指すインデックス
for (int i = K; i < N; i++) {
if (mp[A[i].second] == 0) {
while (mp[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
mp[A[i].second]++;
sum += A[i].first - A[r].first;
mp[A[r].second]--;
s = mp.size();
ans = max(ans, sum + s * s);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N, K;
cin >> N >> K;
pair<ll, int> A[N];
for (int i = 0; i < N; i++) {
ll t, d;
cin >> t >> d;
A[i] = {d, t};
}
sort(A, A + N);
reverse(A, A + N);
ll ans = 0, sum = 0;
map<int, ll> mp; // map<寿司の種類番号、その数>
for (int i = 0; i < K; i++) {
sum += A[i].first;
mp[A[i].second]++;
}
ll s = mp.size();
ans = sum + s * s;
int r = K - 1; //集合から追い出す要素を指すインデックス
for (int i = K; i < N; i++) {
if (mp[A[i].second] == 0) {
while (mp[A[r].second] == 1 && r >= 0)
r--;
if (r == -1)
break;
mp[A[i].second]++;
sum += A[i].first - A[r].first;
mp[A[r].second]--;
r--;
s = mp.size();
ans = max(ans, sum + s * s);
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change",
"expression.unary.arithmetic.add"
] | 946,277 | 946,275 | u052332717 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N, K;
cin >> N >> K;
priority_queue<pair<ll, int>> que;
for (int i = 0; i < N; i++) {
int t;
ll d;
cin >> t >> d;
t--;
que.push(make_pair(d, t));
}
map<int, int> mp;
int types = 0;
vector<pair<ll, int>> order;
ll ans = 0;
for (int i = 0; i < K; i++) {
auto q = que.top();
que.pop();
ll d = q.first;
int t = q.second;
ans += d;
if (mp[t] == 0)
types++;
mp[t]++;
order.push_back(make_pair(d, t));
}
// cout << types << endl;
ans += types * types;
sort(order.begin(), order.end());
// cout << ans << endl;
ll tmpans = ans;
for (int i = 0; i < K; i++) {
ll def_d = order[i].first;
int def_t = order[i].second;
if (mp[def_t] == 1)
continue;
// order[i]は2個以上ある
while (que.size()) {
auto q = que.top();
que.pop();
ll d = q.first;
int t = q.second;
if (mp[t] >= 1)
continue;
// pair<q, t>は初めての種類t
tmpans -= types * types;
tmpans -= def_d;
tmpans += d;
tmpans += (types + 1) * (types + 1);
types++;
order[i] = q;
mp[def_t]--;
mp[t]++;
ans = max(ans, tmpans);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N, K;
cin >> N >> K;
priority_queue<pair<ll, int>> que;
for (int i = 0; i < N; i++) {
int t;
ll d;
cin >> t >> d;
t--;
que.push(make_pair(d, t));
}
map<int, int> mp;
ll types = 0;
vector<pair<ll, int>> order;
ll ans = 0;
for (int i = 0; i < K; i++) {
auto q = que.top();
que.pop();
ll d = q.first;
int t = q.second;
ans += d;
if (mp[t] == 0)
types++;
mp[t]++;
order.push_back(make_pair(d, t));
}
// cout << types << endl;
ans += types * types;
sort(order.begin(), order.end());
// cout << ans << endl;
ll tmpans = ans;
for (int i = 0; i < K; i++) {
ll def_d = order[i].first;
int def_t = order[i].second;
if (mp[def_t] == 1)
continue;
// order[i]は2個以上ある
while (que.size()) {
auto q = que.top();
que.pop();
ll d = q.first;
int t = q.second;
if (mp[t] >= 1)
continue;
// pair<q, t>は初めての種類t
tmpans -= types * types;
tmpans -= def_d;
tmpans += d;
tmpans += (types + 1) * (types + 1);
types++;
order[i] = q;
mp[def_t]--;
mp[t]++;
break;
}
ans = max(ans, tmpans);
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 946,290 | 946,291 | u998251394 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N, M;
cin >> N >> M;
int tmpt;
long long tmpd;
priority_queue<pair<long long, int>> que;
vector<pair<long long, int>> vec;
for (int cnt0 = 0; cnt0 < M; cnt0++) {
cin >> tmpt >> tmpd;
que.push(make_pair(tmpd, tmpt));
}
long long ans = 0;
map<int, int> mp;
for (int cnt0 = 0; cnt0 < M; cnt0++) {
ans += que.top().first;
mp[que.top().second]++;
vec.push_back(que.top());
que.pop();
}
int sz = mp.size();
ans += sz * sz;
sort(vec.begin(), vec.end());
long long tmpans = ans;
for (int cnt0 = 0; cnt0 < M; cnt0++) {
if (mp[vec[cnt0].second] == 1)
continue;
while (que.size()) {
pair<long long, int> q = que.top();
que.pop();
if (mp[q.second] == 0) {
tmpans =
tmpans - vec[cnt0].first + q.first - sz * sz + (sz + 1) * (sz + 1);
sz++;
ans = max(ans, tmpans);
mp[vec[cnt0].second]--;
mp[q.second]++;
vec[cnt0] = q;
break;
}
}
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N, M;
cin >> N >> M;
int tmpt;
long long tmpd;
priority_queue<pair<long long, int>> que;
vector<pair<long long, int>> vec;
for (int cnt0 = 0; cnt0 < N; cnt0++) {
cin >> tmpt >> tmpd;
que.push(make_pair(tmpd, tmpt));
}
long long ans = 0;
map<int, int> mp;
for (int cnt0 = 0; cnt0 < M; cnt0++) {
ans += que.top().first;
mp[que.top().second]++;
vec.push_back(que.top());
que.pop();
}
long long sz = mp.size();
ans += sz * sz;
sort(vec.begin(), vec.end());
long long tmpans = ans;
for (int cnt0 = 0; cnt0 < M; cnt0++) {
if (mp[vec[cnt0].second] == 1)
continue;
while (que.size()) {
pair<long long, int> q = que.top();
que.pop();
if (mp[q.second] == 0) {
tmpans =
tmpans - vec[cnt0].first + q.first - sz * sz + (sz + 1) * (sz + 1);
sz++;
ans = max(ans, tmpans);
mp[vec[cnt0].second]--;
mp[q.second]++;
vec[cnt0] = q;
break;
}
}
}
printf("%lld\n", ans);
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 946,295 | 946,293 | u998251394 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N, K;
cin >> N >> K;
priority_queue<pair<long long, int>> menu;
int tmp1;
long long tmp2;
for (int cnt0 = 0; cnt0 < N; cnt0++) {
cin >> tmp1 >> tmp2;
menu.push(make_pair(tmp2, tmp1));
}
// cout << "1" << endl;
map<int, int> used;
pair<long long, int> order[K];
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
order[K - 1 - cnt0] = menu.top();
menu.pop();
used[order[K - 1 - cnt0].second]++;
}
// cout << "2" << endl;
long long size = used.size();
// cout << size << endl;
long long ans = 0;
for (int cnt0 = 0; cnt0 < K; cnt0++) {
ans += order[cnt0].first;
}
ans += size * size;
long long ans_tmp = ans;
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
if (used[order[cnt0].second] == 1)
continue;
while (menu.size()) {
auto qtmp = menu.top();
menu.pop();
if (used[qtmp.second] != 0)
continue;
ans_tmp = ans_tmp - order[cnt0].first + qtmp.first - size * size +
(size + 1) * (size + 1);
used[qtmp.second]++;
used[order[cnt0].second]--;
ans = max(ans, ans_tmp);
size++;
}
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N, K;
cin >> N >> K;
priority_queue<pair<long long, int>> menu;
int tmp1;
long long tmp2;
for (int cnt0 = 0; cnt0 < N; cnt0++) {
cin >> tmp1 >> tmp2;
menu.push(make_pair(tmp2, tmp1));
}
// cout << "1" << endl;
map<int, int> used;
pair<long long, int> order[K];
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
order[K - 1 - cnt0] = menu.top();
menu.pop();
used[order[K - 1 - cnt0].second]++;
}
// cout << "2" << endl;
long long size = used.size();
// cout << size << endl;
long long ans = 0;
for (int cnt0 = 0; cnt0 < K; cnt0++) {
ans += order[cnt0].first;
}
ans += size * size;
long long ans_tmp = ans;
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
if (used[order[cnt0].second] == 1)
continue;
while (menu.size()) {
auto qtmp = menu.top();
menu.pop();
if (used[qtmp.second] != 0)
continue;
ans_tmp = ans_tmp - order[cnt0].first + qtmp.first - size * size +
(size + 1) * (size + 1);
used[qtmp.second]++;
used[order[cnt0].second]--;
ans = max(ans, ans_tmp);
size++;
break;
}
}
printf("%lld\n", ans);
return 0;
}
| [
"control_flow.break.add"
] | 946,296 | 946,297 | u998251394 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N, K;
cin >> N >> K;
priority_queue<pair<long long, int>> menu;
int tmp1;
long long tmp2;
for (int cnt0 = 0; cnt0 < N; cnt0++) {
cin >> tmp1 >> tmp2;
menu.push(make_pair(tmp2, tmp1));
}
// cout << "1" << endl;
map<int, int> used;
pair<long long, int> order[K];
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
order[K - 1 - cnt0] = menu.top();
menu.pop();
used[order[K - 1 - cnt0].second]++;
}
// cout << "2" << endl;
long long size = used.size();
// cout << size << endl;
long long ans = 0;
for (int cnt0 = 0; cnt0 < K; cnt0++) {
ans += order[cnt0].first;
}
ans += size * size;
long long ans_tmp = ans;
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
if (used[order[cnt0].second] == 1)
continue;
while (menu.size()) {
auto qtmp = menu.top();
menu.pop();
if (used[qtmp.second] != 0)
continue;
ans_tmp = ans_tmp - order[cnt0].first + qtmp.first - size * size +
(size + 1) * (size + 1);
used[qtmp.second]++;
used[order[cnt0].second]++;
ans = max(ans, ans_tmp);
size++;
}
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N, K;
cin >> N >> K;
priority_queue<pair<long long, int>> menu;
int tmp1;
long long tmp2;
for (int cnt0 = 0; cnt0 < N; cnt0++) {
cin >> tmp1 >> tmp2;
menu.push(make_pair(tmp2, tmp1));
}
// cout << "1" << endl;
map<int, int> used;
pair<long long, int> order[K];
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
order[K - 1 - cnt0] = menu.top();
menu.pop();
used[order[K - 1 - cnt0].second]++;
}
// cout << "2" << endl;
long long size = used.size();
// cout << size << endl;
long long ans = 0;
for (int cnt0 = 0; cnt0 < K; cnt0++) {
ans += order[cnt0].first;
}
ans += size * size;
long long ans_tmp = ans;
for (int cnt0 = K - 1; cnt0 >= 0; cnt0--) {
if (used[order[cnt0].second] == 1)
continue;
while (menu.size()) {
auto qtmp = menu.top();
menu.pop();
if (used[qtmp.second] != 0)
continue;
ans_tmp = ans_tmp - order[cnt0].first + qtmp.first - size * size +
(size + 1) * (size + 1);
used[qtmp.second]++;
used[order[cnt0].second]--;
ans = max(ans, ans_tmp);
size++;
break;
}
}
printf("%lld\n", ans);
return 0;
}
| [
"control_flow.break.add"
] | 946,298 | 946,297 | u998251394 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
priority_queue<ll> MinusPQ;
priority_queue<pair<ll, ll>> PlusPQ;
set<int> S;
int n, k, t, d;
vector<pair<ll, ll>> sushi;
cin >> n >> k;
ll sum = 0;
for (int i = 0; i < n; i++) {
cin >> t >> d;
sushi.push_back(make_pair(d, t));
}
sort(sushi.rbegin(), sushi.rend());
for (int i = 0; i < n; i++) {
if (i < k) {
if (S.count(sushi[i].second)) {
MinusPQ.push(-sushi[i].first);
} else {
S.insert(sushi[i].second);
}
sum += sushi[i].first;
} else {
PlusPQ.push(sushi[i]);
}
}
sum += pow(S.size(), 2);
ll mx = sum;
while (MinusPQ.size() > 0 && PlusPQ.size() > 0) {
if (S.count(PlusPQ.top().second) == 0) {
long long diff = pow(S.size() + 1, 2) - pow(S.size(), 2) +
PlusPQ.top().first + MinusPQ.top();
S.insert(PlusPQ.top().second);
sum += diff;
mx = max(sum, mx);
}
MinusPQ.pop();
PlusPQ.pop();
}
cout << mx << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
priority_queue<ll> MinusPQ;
priority_queue<pair<ll, ll>> PlusPQ;
set<int> S;
int n, k, t, d;
vector<pair<ll, ll>> sushi;
cin >> n >> k;
ll sum = 0;
for (int i = 0; i < n; i++) {
cin >> t >> d;
sushi.push_back(make_pair(d, t));
}
sort(sushi.rbegin(), sushi.rend());
for (int i = 0; i < n; i++) {
if (i < k) {
if (S.count(sushi[i].second)) {
MinusPQ.push(-sushi[i].first);
} else {
S.insert(sushi[i].second);
}
sum += sushi[i].first;
} else {
PlusPQ.push(sushi[i]);
}
}
sum += pow(S.size(), 2);
ll mx = sum;
while (MinusPQ.size() > 0 && PlusPQ.size() > 0) {
if (S.count(PlusPQ.top().second) == 0) {
long long diff = pow(S.size() + 1, 2) - pow(S.size(), 2) +
PlusPQ.top().first + MinusPQ.top();
S.insert(PlusPQ.top().second);
sum += diff;
mx = max(sum, mx);
MinusPQ.pop();
}
PlusPQ.pop();
}
cout << mx << endl;
} | [] | 946,299 | 946,300 | u709304134 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
const long long INF = 1e18;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
long long fast_exp(long long base, long long exp, long long mod = MOD) {
long long tot = 1;
for (; exp > 0; exp >>= 1) {
if ((exp & 1) == 1)
tot = tot * base % mod;
base = base * base % mod;
}
return tot;
}
long long slow_mult(long long base, long long exp, long long mod = MOD) {
long long tot = 0;
for (; exp > 0; exp >>= 1) {
if ((exp & 1) == 1)
tot = (tot + base) % mod;
base = base * 2 % mod;
}
return tot;
}
pair<long long, long long> arr[100005];
int used[100005];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
long long k;
int n;
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> arr[i].second >> arr[i].first;
sort(arr, arr + n);
reverse(arr, arr + n);
priority_queue<pair<long long, int>> pq;
long long best = 0, cur = 0, dup = 0;
for (int i = 0; i < k; ++i) {
if (used[arr[i].second] == 0)
++dup;
else
pq.push(make_pair(-arr[i].first, i));
cur += arr[i].first;
++used[arr[i].second];
}
best = max(best, cur + dup * dup);
// cout << cur << endl;
for (int i = k; i < n; ++i) {
if (used[arr[i].second] > 0)
continue;
if (pq.empty())
break;
cur += pq.top().first + arr[i].first;
++used[arr[i].second];
++dup;
best = max(best, dup * dup + cur);
}
cout << best << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
const long long INF = 1e18;
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
long long fast_exp(long long base, long long exp, long long mod = MOD) {
long long tot = 1;
for (; exp > 0; exp >>= 1) {
if ((exp & 1) == 1)
tot = tot * base % mod;
base = base * base % mod;
}
return tot;
}
long long slow_mult(long long base, long long exp, long long mod = MOD) {
long long tot = 0;
for (; exp > 0; exp >>= 1) {
if ((exp & 1) == 1)
tot = (tot + base) % mod;
base = base * 2 % mod;
}
return tot;
}
pair<long long, long long> arr[100005];
int used[100005];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
long long k;
int n;
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> arr[i].second >> arr[i].first;
sort(arr, arr + n);
reverse(arr, arr + n);
priority_queue<pair<long long, int>> pq;
long long best = 0, cur = 0, dup = 0;
for (int i = 0; i < k; ++i) {
if (used[arr[i].second] == 0)
++dup;
else
pq.push(make_pair(-arr[i].first, i));
cur += arr[i].first;
++used[arr[i].second];
}
best = max(best, cur + dup * dup);
// cout << cur << endl;
for (int i = k; i < n; ++i) {
if (used[arr[i].second] > 0)
continue;
if (pq.empty())
break;
cur += pq.top().first + arr[i].first;
pq.pop();
++used[arr[i].second];
++dup;
best = max(best, dup * dup + cur);
}
cout << best << "\n";
return 0;
}
| [
"call.add"
] | 946,328 | 946,329 | u276568758 | cpp |
p03148 | // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
using P = pair<ll, ll>;
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<P> S;
rep(i, N) {
ll t, d;
cin >> t >> d;
S.pb({d, t});
}
sort(rall(S));
priority_queue<P, vector<P>, less<P>> Q1;
set<ll> T;
ll base = 0;
rep(i, K) {
base += S[i].fst;
if (!T.count(S[i].snd)) {
T.ist(S[i].snd);
} else {
Q1.push(S[i]);
}
}
priority_queue<P, vector<P>, greater<P>> Q2;
for (ll i = K; i < N; ++i) {
Q2.push(S[i]);
}
ll ans = base + T.size() * T.size();
while (!Q1.empty() && !Q2.empty()) {
P p2 = Q2.top();
Q2.pop();
if (T.count(p2.snd))
continue;
T.ist(p2.snd);
P p1 = Q1.top();
Q1.pop();
base -= p1.fst;
base += p2.fst;
ans = max(ans, (ll)(base + T.size() * T.size()));
}
cout << ans << endl;
}
| // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
using P = pair<ll, ll>;
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, K;
cin >> N >> K;
vector<P> S;
rep(i, N) {
ll t, d;
cin >> t >> d;
S.pb({d, t});
}
sort(rall(S));
priority_queue<P, vector<P>, greater<P>> Q1;
set<ll> T;
ll base = 0;
rep(i, K) {
base += S[i].fst;
if (!T.count(S[i].snd)) {
T.ist(S[i].snd);
} else {
Q1.push(S[i]);
}
}
priority_queue<P, vector<P>, less<P>> Q2;
for (ll i = K; i < N; ++i) {
Q2.push(S[i]);
}
ll ans = base + T.size() * T.size();
while (!Q1.empty() && !Q2.empty()) {
P p2 = Q2.top();
Q2.pop();
if (T.count(p2.snd))
continue;
T.ist(p2.snd);
P p1 = Q1.top();
Q1.pop();
base -= p1.fst;
base += p2.fst;
ans = max(ans, (ll)(base + T.size() * T.size()));
}
cout << ans << endl;
}
| [] | 946,340 | 946,341 | u186294233 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define ll long long
typedef pair<ll, ll> P;
vector<P> vec;
vector<P> v;
bool f[100009], g[100009];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t, d;
cin >> t >> d;
vec.push_back(P(d, t));
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
ll p = 0, sum = 0;
for (int i = 0; i < k; i++) {
ll d = vec[i].fi;
ll t = vec[i].se;
if (!f[t]) {
g[i] = true;
f[t] = true;
p++;
}
sum += d;
}
for (int i = k; i < n; i++) {
ll d = vec[i].fi;
ll t = vec[i].se;
if (!f[t]) {
v.push_back(vec[i]);
f[t] = true;
}
}
ll cnt = 0, ans = sum + p * p;
for (int i = k - 1; i >= 0; i--) {
ll d = vec[i].fi;
ll t = vec[i].se;
if (g[i] || cnt >= v.size())
continue;
sum = sum - d + v[cnt].fi;
p++;
ans = max(ans, sum + p * p);
}
cout << ans << endl;
return (0);
}
| #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define ll long long
typedef pair<ll, ll> P;
vector<P> vec;
vector<P> v;
bool f[100009], g[100009];
int main() {
ll n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
ll t, d;
cin >> t >> d;
vec.push_back(P(d, t));
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
ll p = 0, sum = 0;
for (int i = 0; i < k; i++) {
ll d = vec[i].fi;
ll t = vec[i].se;
if (!f[t]) {
g[i] = true;
f[t] = true;
p++;
}
sum += d;
}
for (int i = k; i < n; i++) {
ll d = vec[i].fi;
ll t = vec[i].se;
if (!f[t]) {
v.push_back(vec[i]);
f[t] = true;
}
}
ll cnt = 0, ans = sum + p * p;
for (int i = k - 1; i >= 0; i--) {
ll d = vec[i].fi;
ll t = vec[i].se;
if (g[i] || cnt >= v.size())
continue;
sum = sum - d + v[cnt].fi;
p++;
ans = max(ans, sum + p * p);
cnt++;
}
cout << ans << endl;
return (0);
}
| [
"variable_declaration.type.change",
"expression.unary.arithmetic.add"
] | 946,368 | 946,369 | u912752743 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(ALL(x)), (x).end())
#define SORT(x) sort(ALL(x))
#define REV(x) reverse(ALL(x))
#define foreach(it, x) \
for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define debug(x) cerr << #x << "=" << (x) << endl
#define gett() cerr << "Time:" << clock() << "ms." << endl
vector<pair<long long, int>> deli, tp;
vector<pair<long long, int>> s[100100];
int n, k;
bool vis[100100];
int daihao[100100];
pair<long long, int> sushi[100100];
#define sqr(x) ((x) * (x))
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> sushi[i].second >> sushi[i].first;
}
sort(sushi + 1, sushi + n + 1);
for (int i = 1; i <= n; i++) {
if (!vis[sushi[i].second]) {
vis[sushi[i].second] = true;
daihao[sushi[i].second] = cnt;
cnt++;
}
s[daihao[sushi[i].second]].push_back(make_pair(sushi[i].first, i));
}
long long num = 0;
long long sum = 0;
for (int i = 0; i < cnt; i++) {
sort(s[i].begin(), s[i].end());
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j].second > n - k && j != s[i].size() - 1)
tp.push_back(s[i][j]);
if (s[i][j].second <= n - k && j == s[i].size() - 1)
deli.push_back(s[i][j]);
if (s[i][j].second > n - k && j == s[i].size() - 1)
num++;
if (s[i][j].second > n - k)
sum += s[i][j].first;
}
}
sort(tp.begin(), tp.end());
sort(deli.begin(), deli.end());
long long ans = sum + sqr(num);
for (int i = deli.size() - 1, j = 0; i >= 0, j < tp.size(); i--, j++) {
sum += deli[i].first - tp[j].first;
num--;
ans = max(ans, sum + sqr(num));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(ALL(x)), (x).end())
#define SORT(x) sort(ALL(x))
#define REV(x) reverse(ALL(x))
#define foreach(it, x) \
for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define debug(x) cerr << #x << "=" << (x) << endl
#define gett() cerr << "Time:" << clock() << "ms." << endl
vector<pair<long long, int>> deli, tp;
vector<pair<long long, int>> s[100100];
int n, k;
bool vis[100100];
int daihao[100100];
pair<long long, int> sushi[100100];
#define sqr(x) ((x) * (x))
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> sushi[i].second >> sushi[i].first;
}
sort(sushi + 1, sushi + n + 1);
for (int i = 1; i <= n; i++) {
if (!vis[sushi[i].second]) {
vis[sushi[i].second] = true;
daihao[sushi[i].second] = cnt;
cnt++;
}
s[daihao[sushi[i].second]].push_back(make_pair(sushi[i].first, i));
}
long long num = 0;
long long sum = 0;
for (int i = 0; i < cnt; i++) {
sort(s[i].begin(), s[i].end());
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j].second > n - k && j != s[i].size() - 1)
tp.push_back(s[i][j]);
if (s[i][j].second <= n - k && j == s[i].size() - 1)
deli.push_back(s[i][j]);
if (s[i][j].second > n - k && j == s[i].size() - 1)
num++;
if (s[i][j].second > n - k)
sum += s[i][j].first;
}
}
sort(tp.begin(), tp.end());
sort(deli.begin(), deli.end());
long long ans = sum + sqr(num);
for (int i = deli.size() - 1, j = 0; i >= 0 && j < tp.size(); i--, j++) {
sum += deli[i].first - tp[j].first;
num++;
ans = max(ans, sum + sqr(num));
}
cout << ans << endl;
return 0;
}
| [] | 946,370 | 946,371 | u313427116 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define pll pair<long long, long long>
#define ll long long
#define mp make_pair
ll n, k, a, b, ans, res;
long long sz;
priority_queue<pll> q;
ll num[100003];
vector<pll> v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a >> b, q.push(mp(b, --a));
for (int i = 0; i < k; i++) {
pll now = q.top();
q.pop();
num[now.y]++;
res += now.x;
v.push_back(mp(now.x, now.y));
sz += (num[now.y] == 1);
}
ans = res + sz * sz;
while (k--) {
if (num[v[k].y] > 1)
while (q.size()) {
pll now = q.top();
q.pop();
if (!num[now.y]) {
num[now.y]++, num[v[k].y]--, res = res + now.x - v[k].x, sz++;
break;
if (ans < res + sz * sz)
ans = res + sz * sz;
}
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define pll pair<long long, long long>
#define ll long long
#define mp make_pair
ll n, k, a, b, ans, res;
long long sz;
priority_queue<pll> q;
ll num[100003];
vector<pll> v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a >> b, q.push(mp(b, --a));
for (int i = 0; i < k; i++) {
pll now = q.top();
q.pop();
num[now.y]++;
res += now.x;
v.push_back(mp(now.x, now.y));
sz += (num[now.y] == 1);
}
ans = res + sz * sz;
while (k--) {
if (num[v[k].y] > 1)
while (q.size()) {
pll now = q.top();
q.pop();
if (!num[now.y]) {
num[now.y]++, num[v[k].y]--, res = res + now.x - v[k].x, sz++;
if (ans < res + sz * sz)
ans = res + sz * sz;
break;
}
}
}
cout << ans;
}
| [
"control_flow.break.add"
] | 946,372 | 946,373 | u515315348 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define pll pair<long long, long long>
#define ll long long
#define mp make_pair
ll n, k, a, b, ans, res;
long long sz;
priority_queue<pll> q;
ll num[100003];
vector<pll> v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a >> b, q.push(mp(b, --a));
for (int i = 0; i < k; i++) {
pll now = q.top();
q.pop();
num[now.y]++;
res += now.x;
v.push_back(mp(now.x, now.y));
sz += (num[now.y] == 1);
}
ans = res + sz * sz;
while (k--) {
if (num[v[k].y] > 1)
while (q.size()) {
pll now = q.top();
q.pop();
if (!num[now.y]) {
num[now.y]++, num[v[k].y]--, res = res + now.x - v[k].x, sz++;
if (ans < res + sz * sz)
ans = res + sz * sz;
}
}
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define pll pair<long long, long long>
#define ll long long
#define mp make_pair
ll n, k, a, b, ans, res;
long long sz;
priority_queue<pll> q;
ll num[100003];
vector<pll> v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a >> b, q.push(mp(b, --a));
for (int i = 0; i < k; i++) {
pll now = q.top();
q.pop();
num[now.y]++;
res += now.x;
v.push_back(mp(now.x, now.y));
sz += (num[now.y] == 1);
}
ans = res + sz * sz;
while (k--) {
if (num[v[k].y] > 1)
while (q.size()) {
pll now = q.top();
q.pop();
if (!num[now.y]) {
num[now.y]++, num[v[k].y]--, res = res + now.x - v[k].x, sz++;
if (ans < res + sz * sz)
ans = res + sz * sz;
break;
}
}
}
cout << ans;
}
| [
"control_flow.break.add"
] | 946,374 | 946,373 | u515315348 | cpp |
p03148 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, m, n) for (long long i = (m); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
template <class T> using V = vector<T>;
template <class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll HINF = (ll)1e18;
const ll LINF = (ll)1e9;
const long double PI = 3.1415926535897932384626433;
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
template <template <class tmp> class T, class U>
ostream &operator<<(ostream &o, const T<U> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max<T>(a, b); }
template <class T> void chmin(T &a, const T b) { a = min<T>(a, b); }
void YN(bool flg) { cout << ((flg) ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << ((flg) ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << ((flg) ? "yes" : "no") << endl; }
int main() {
ll N, K;
cin >> N >> K;
V<P<ll, ll>> dt;
REP(i, N) {
ll t, d;
cin >> t >> d;
dt.push_back({d, t});
}
sort(ALL(dt), greater<P<ll, ll>>());
ll ans = 0, sum = 0;
priority_queue<ll, V<ll>, greater<ll>> pq;
map<ll, ll> mp;
REP(i, K) {
if (mp[dt[i].second] == 0) {
mp[dt[i].second]++;
sum += dt[i].first;
} else {
pq.push(dt[i].first);
sum += dt[i].first;
}
}
chmax(ans, sum + (ll)mp.size() * (ll)mp.size());
FOR(i, K, N) {
if (mp[dt[i].second] == 0) {
mp[dt[i].second]++;
sum += dt[i].first;
sum -= pq.top();
pq.pop();
}
chmax(ans, sum + (ll)mp.size() * (ll)mp.size());
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, m, n) for (long long i = (m); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
template <class T> using V = vector<T>;
template <class T, class U> using P = pair<T, U>;
const ll MOD = (ll)1e9 + 7;
const ll HINF = (ll)1e18;
const ll LINF = (ll)1e9;
const long double PI = 3.1415926535897932384626433;
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
exit(0);
}
}
template <class T, class U>
ostream &operator<<(ostream &o, const map<T, U> &obj) {
o << "{";
for (auto &x : obj)
o << " {" << x.first << " : " << x.second << "}"
<< ",";
o << " }";
return o;
}
template <class T> ostream &operator<<(ostream &o, const set<T> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &obj) {
o << "{";
for (int i = 0; i < (int)obj.size(); ++i)
o << (i > 0 ? ", " : "") << obj[i];
o << "}";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &obj) {
o << "{" << obj.first << ", " << obj.second << "}";
return o;
}
template <template <class tmp> class T, class U>
ostream &operator<<(ostream &o, const T<U> &obj) {
o << "{";
for (auto itr = obj.begin(); itr != obj.end(); ++itr)
o << (itr != obj.begin() ? ", " : "") << *itr;
o << "}";
return o;
}
void print(void) { cout << endl; }
template <class Head> void print(Head &&head) {
cout << head;
print();
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head << " ";
print(forward<Tail>(tail)...);
}
template <class T> void chmax(T &a, const T b) { a = max<T>(a, b); }
template <class T> void chmin(T &a, const T b) { a = min<T>(a, b); }
void YN(bool flg) { cout << ((flg) ? "YES" : "NO") << endl; }
void Yn(bool flg) { cout << ((flg) ? "Yes" : "No") << endl; }
void yn(bool flg) { cout << ((flg) ? "yes" : "no") << endl; }
int main() {
ll N, K;
cin >> N >> K;
V<P<ll, ll>> dt;
REP(i, N) {
ll t, d;
cin >> t >> d;
dt.push_back({d, t});
}
sort(ALL(dt), greater<P<ll, ll>>());
ll ans = 0, sum = 0;
priority_queue<ll, V<ll>, greater<ll>> pq;
map<ll, ll> mp;
REP(i, K) {
if (mp[dt[i].second] == 0) {
mp[dt[i].second]++;
sum += dt[i].first;
} else {
pq.push(dt[i].first);
sum += dt[i].first;
}
}
chmax(ans, sum + (ll)mp.size() * (ll)mp.size());
FOR(i, K, N) {
if (pq.size() && mp[dt[i].second] == 0) {
mp[dt[i].second]++;
sum += dt[i].first;
sum -= pq.top();
pq.pop();
}
chmax(ans, sum + (ll)mp.size() * (ll)mp.size());
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 946,395 | 946,396 | u898651494 | cpp |
p03148 | #include <algorithm>
#include <cstring>
#include <iterator>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define MOD 1000000007
using namespace std;
int main(int argc, char *argv[]) {
long n, kk;
scanf("%ld %ld", &n, &kk);
vector<pair<long, long>> a(n);
long i;
for (i = 0; i < n; i++) {
scanf("%ld %ld", &(a[i].second), &(a[i].first));
}
sort(a.rbegin(), a.rend());
ll sum = 0;
set<long> setUsedT;
vector<long> DforUsedT;
ll nUsedT = 0;
for (i = 0; i < kk; i++) {
sum += a[i].first;
if (setUsedT.insert(a[i].second).second) {
nUsedT++;
} else {
DforUsedT.push_back(a[i].first);
}
}
ll ans = sum + nUsedT * nUsedT;
long id_rmv = (long)DforUsedT.size() - 1;
for (i = kk; i < n; i++) {
if (setUsedT.insert(a[i].second).second) {
nUsedT++;
if (id_rmv >= 0) {
sum = sum + (a[i].first) - DforUsedT[id_rmv];
ans = MAX(ans, sum + nUsedT * nUsedT);
} else {
break;
}
}
}
printf("%lld\n", ans);
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iterator>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define MOD 1000000007
using namespace std;
int main(int argc, char *argv[]) {
long n, kk;
scanf("%ld %ld", &n, &kk);
vector<pair<long, long>> a(n);
long i;
for (i = 0; i < n; i++) {
scanf("%ld %ld", &(a[i].second), &(a[i].first));
}
sort(a.rbegin(), a.rend());
ll sum = 0;
set<long> setUsedT;
vector<long> DforUsedT;
ll nUsedT = 0;
for (i = 0; i < kk; i++) {
sum += a[i].first;
if (setUsedT.insert(a[i].second).second) {
nUsedT++;
} else {
DforUsedT.push_back(a[i].first);
}
}
ll ans = sum + nUsedT * nUsedT;
long id_rmv = (long)DforUsedT.size() - 1;
for (i = kk; i < n; i++) {
if (setUsedT.insert(a[i].second).second) {
nUsedT++;
if (id_rmv >= 0) {
sum = sum + (a[i].first) - DforUsedT[id_rmv];
ans = MAX(ans, sum + nUsedT * nUsedT);
id_rmv--;
} else {
break;
}
}
}
printf("%lld\n", ans);
return 0;
}
| [
"expression.unary.arithmetic.add"
] | 946,401 | 946,402 | u209713918 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int main() {
int n, k, t, d;
priority_queue<pair<int, int>> pq;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d %d", &t, &d);
pq.push(make_pair(d, t));
}
priority_queue<pair<int, int>> eat;
int neta[100001] = {0};
lli oishisa = 0, x = 0;
for (int i = 0; i < k; i++) {
auto s = pq.top();
pq.pop();
if (neta[s.second] == 0)
x++;
neta[s.second]++;
oishisa += s.first;
eat.push(make_pair(-s.first, s.second));
}
lli ans = oishisa + x * x;
while (!pq.empty() && !eat.empty()) {
/*
cout << oishisa << " " << x << " " << ans << endl;
for (int i=0; i<10; i++) cout << neta[i] << " ";
cout << endl;
*/
auto s = pq.top();
pq.pop();
if (neta[s.second])
continue;
auto out = eat.top();
while (!eat.empty()) {
eat.pop();
if (neta[out.second] >= 2) {
neta[out.second]--;
oishisa += out.first;
break;
}
out = eat.top();
}
oishisa += s.first;
neta[s.second]++;
x++;
ans = max(ans, oishisa + x * x);
}
/*
cout << oishisa << " " << x << " " << ans << endl;
for (int i=0; i<10; i++) cout << neta[i] << " ";
cout << endl;
*/
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int main() {
int n, k, t, d;
priority_queue<pair<int, int>> pq;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d %d", &t, &d);
pq.push(make_pair(d, t));
}
priority_queue<pair<int, int>> eat;
int neta[100001] = {0};
lli oishisa = 0, x = 0;
for (int i = 0; i < k; i++) {
auto s = pq.top();
pq.pop();
if (neta[s.second] == 0)
x++;
neta[s.second]++;
oishisa += s.first;
eat.push(make_pair(-s.first, s.second));
}
lli ans = oishisa + x * x;
while (!pq.empty() && x < k) {
/*
cout << oishisa << " " << x << " " << ans << endl;
for (int i=0; i<10; i++) cout << neta[i] << " ";
cout << endl;
*/
auto s = pq.top();
pq.pop();
if (neta[s.second])
continue;
auto out = eat.top();
while (!eat.empty()) {
eat.pop();
if (neta[out.second] >= 2) {
neta[out.second]--;
oishisa += out.first;
break;
}
out = eat.top();
}
oishisa += s.first;
neta[s.second]++;
x++;
ans = max(ans, oishisa + x * x);
}
/*
cout << oishisa << " " << x << " " << ans << endl;
for (int i=0; i<10; i++) cout << neta[i] << " ";
cout << endl;
*/
cout << ans << endl;
return 0;
}
| [
"call.remove"
] | 946,405 | 946,406 | u905270643 | cpp |
p03148 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
const int INF = (1 << 30);
const ll INFLL = (1ll << 60);
const ll MOD = (ll)(1e9 + 7);
#define l_ength size
void mul_mod(ll &a, ll b) {
a *= b;
a %= MOD;
}
void add_mod(ll &a, ll b) {
a = (a < MOD) ? a : (a - MOD);
b = (b < MOD) ? b : (b - MOD);
a += b;
a = (a < MOD) ? a : (a - MOD);
}
vector<P> v;
bool used[100100];
ll f[100100];
priority_queue<ll, vector<ll>, greater<ll>> pq;
int main(void) {
int k, n, t, l = 0, r, i;
ll d, tmp, ans = -INFLL;
cin >> n >> k;
for (i = 0; i < n; ++i) {
cin >> t >> d;
--t;
v.push_back(P(d, t));
}
sort(v.begin(), v.end(), greater<P>());
for (i = 0; i < k; ++i) {
t = v[i].second;
d = v[i].first;
tmp += d;
if (used[t]) {
pq.push(d);
} else {
++l;
used[t] = true;
}
}
r = l;
f[r] = tmp;
for (i = k; i < n; ++i) {
if (pq.empty()) {
break;
}
t = v[i].second;
d = v[i].first;
if (used[t]) {
continue;
}
used[t] = true;
tmp -= pq.top();
pq.pop();
tmp += d;
++r;
f[r] = tmp;
}
for (i = l; i <= r; ++i) {
ans = max(ans, f[i] + 1ll * i * i);
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
const int INF = (1 << 30);
const ll INFLL = (1ll << 60);
const ll MOD = (ll)(1e9 + 7);
#define l_ength size
void mul_mod(ll &a, ll b) {
a *= b;
a %= MOD;
}
void add_mod(ll &a, ll b) {
a = (a < MOD) ? a : (a - MOD);
b = (b < MOD) ? b : (b - MOD);
a += b;
a = (a < MOD) ? a : (a - MOD);
}
vector<P> v;
bool used[100100];
ll f[100100];
priority_queue<ll, vector<ll>, greater<ll>> pq;
int main(void) {
int k, n, t, l = 0, r, i;
ll d, tmp = 0ll, ans = -INFLL;
cin >> n >> k;
for (i = 0; i < n; ++i) {
cin >> t >> d;
--t;
v.push_back(P(d, t));
}
sort(v.begin(), v.end(), greater<P>());
for (i = 0; i < k; ++i) {
t = v[i].second;
d = v[i].first;
tmp += d;
if (used[t]) {
pq.push(d);
} else {
++l;
used[t] = true;
}
}
r = l;
f[r] = tmp;
for (i = k; i < n; ++i) {
if (pq.empty()) {
break;
}
t = v[i].second;
d = v[i].first;
if (used[t]) {
continue;
}
used[t] = true;
tmp -= pq.top();
pq.pop();
tmp += d;
++r;
f[r] = tmp;
}
for (i = l; i <= r; ++i) {
ans = max(ans, f[i] + 1ll * i * i);
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.value.change"
] | 946,415 | 946,416 | u548624367 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
#define mp make_pair
#define fi first
#define se second
ll f[200000], n, k, var, idx;
priority_queue<pair<ll, ll>> q;
ll sum, mx;
vector<pair<ll, ll>> v;
void shift() {
if (f[v[idx].se] > 1) {
} else {
while (f[v[idx].se] <= 1 && idx > 0) {
idx--;
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
ll t, d;
cin >> t >> d;
q.push(mp(d, t));
}
for (int i = 1; i <= k; i++) {
sum += q.top().fi;
if (f[q.top().se] == 0) {
var++;
}
v.push_back(mp(q.top().fi, q.top().se));
f[q.top().se]++;
q.pop();
}
sum += (ll)var * var;
mx = sum;
idx = v.size() - 1;
while (idx > 0 && !q.empty()) {
ll t, d;
d = q.top().fi;
t = q.top().se;
if (f[t] == 0) {
f[t]++;
sum -= v[idx].fi;
sum -= (ll)var * var;
sum += d;
var++;
sum += (ll)var * var;
f[v[idx].se]--;
idx--;
mx = max(mx, sum);
}
q.pop();
shift();
}
cout << mx << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
#define mp make_pair
#define fi first
#define se second
ll f[200000], n, k, var, idx;
priority_queue<pair<ll, ll>> q;
ll sum, mx;
vector<pair<ll, ll>> v;
void shift() {
if (f[v[idx].se] > 1) {
} else {
while (f[v[idx].se] <= 1 && idx > 0) {
idx--;
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
ll t, d;
cin >> t >> d;
q.push(mp(d, t));
}
for (int i = 1; i <= k; i++) {
sum += q.top().fi;
if (f[q.top().se] == 0) {
var++;
}
v.push_back(mp(q.top().fi, q.top().se));
f[q.top().se]++;
q.pop();
}
sum += (ll)var * var;
mx = sum;
idx = v.size() - 1;
shift();
while (idx > 0 && !q.empty()) {
ll t, d;
d = q.top().fi;
t = q.top().se;
if (f[t] == 0) {
f[t]++;
sum -= v[idx].fi;
sum -= (ll)var * var;
sum += d;
var++;
sum += (ll)var * var;
f[v[idx].se]--;
idx--;
mx = max(mx, sum);
}
q.pop();
shift();
}
cout << mx << endl;
}
| [
"call.add"
] | 946,419 | 946,420 | u337775536 | cpp |
p03148 | #include <bits/stdc++.h>
#define int long long int
#define mod(x) ((x % MOD) + MOD) % MOD
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define RFORE(i, a, b) for (int i = (b); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SZ(c) (int)((c).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define LB(c, x) (int)(lower_bound(ALL(c), x) - (c).begin())
#define UB(c, x) (int)(upper_bound(ALL(c), x) - (c).begin())
#define COUNT(c, x) (UB(c, x) - LB(c, x))
#define UNIQUE(c) \
SORT(c); \
(c).erase(unique(ALL(c)), (c).end());
#define COPY(c1, c2) copy(ALL(c1), (c2).begin())
#define EXIST(s, e) (bool)((s).find(e) != (s).end())
#define PB push_back
#define MP make_pair
#define DEL(v) decltype(v)().swap(v)
#define DUMP(x) cerr << #x << " = " << (x) << endl;
#define NL cerr << endl;
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define F first
#define S second
using namespace std;
template <typename T1, typename T2> using P = pair<T1, T2>;
template <typename T> using V = vector<T>;
struct edge {
int from, to;
int cost;
};
bool operator<(const edge &edge1, const edge &edge2) {
return edge1.cost < edge2.cost;
};
const int INF = 1e18;
const int MOD = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &s, const V<T> &v) {
s << "[";
for (int i = 0; i < v.size(); i++) {
s << v[i];
if (i < v.size() - 1)
s << " ";
}
s << "]";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const P<T1, T2> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &st) {
s << "{";
for (auto i = st.begin(); i != st.end(); ++i) {
s << *i;
if (next(i) != st.end())
s << ", ";
}
s << "}";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{";
for (auto i = m.begin(); i != m.end(); ++i) {
s << i->first << ":" << i->second;
if (next(i) != m.end())
s << ", ";
}
s << "}";
return s;
}
signed main() {
int N, K;
cin >> N >> K;
V<int> t(N), d(N);
REP(i, N) { cin >> t[i] >> d[i]; }
V<P<int, int>> p(N);
REP(i, N) { p[i] = MP(d[i], t[i]); }
RSORT(p);
// eat delicious sushi first
map<int, V<int>> sushi1, sushi2;
// sushi1: sushi to be eaten first
// sushi2: sushi not to be eaten first
int sum = 0;
FOR(i, 0, K) {
int t_ = p[i].S, d_ = p[i].F;
sushi1[t_].PB(d_);
sum += d_;
}
int sz = sushi1.size();
FOR(i, K, N) {
int t_ = p[i].S, d_ = p[i].F;
sushi2[t_].PB(d_);
}
V<int> sushi3;
// sushi3: sushi whose type is already eaten
EACH(i, sushi1) {
RSORT(i->S);
EACH(j, i->S) {
if (j == i->S.begin())
continue;
sushi3.PB(*j);
}
}
V<int> sushi4;
// sushi4: sushi whose type is not eaten yet
EACH(i, sushi2) {
if (sushi1[i->F].size() != 0)
continue;
SORT(i->S);
sushi4.PB(i->S[0]);
}
SORT(sushi3);
RSORT(sushi4);
DUMP(sushi3)
DUMP(sushi4)
int ans = sum + sz * sz;
REP(i, min(sushi3.size(), sushi4.size())) {
sum = sum - sushi3[i] + sushi4[i];
sz++;
chmax(ans, sum + sz * sz);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long int
#define mod(x) ((x % MOD) + MOD) % MOD
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define RFORE(i, a, b) for (int i = (b); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SZ(c) (int)((c).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define LB(c, x) (int)(lower_bound(ALL(c), x) - (c).begin())
#define UB(c, x) (int)(upper_bound(ALL(c), x) - (c).begin())
#define COUNT(c, x) (UB(c, x) - LB(c, x))
#define UNIQUE(c) \
SORT(c); \
(c).erase(unique(ALL(c)), (c).end());
#define COPY(c1, c2) copy(ALL(c1), (c2).begin())
#define EXIST(s, e) (bool)((s).find(e) != (s).end())
#define PB push_back
#define MP make_pair
#define DEL(v) decltype(v)().swap(v)
#define DUMP(x) cerr << #x << " = " << (x) << endl;
#define NL cerr << endl;
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define F first
#define S second
using namespace std;
template <typename T1, typename T2> using P = pair<T1, T2>;
template <typename T> using V = vector<T>;
struct edge {
int from, to;
int cost;
};
bool operator<(const edge &edge1, const edge &edge2) {
return edge1.cost < edge2.cost;
};
const int INF = 1e18;
const int MOD = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &s, const V<T> &v) {
s << "[";
for (int i = 0; i < v.size(); i++) {
s << v[i];
if (i < v.size() - 1)
s << " ";
}
s << "]";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const P<T1, T2> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &st) {
s << "{";
for (auto i = st.begin(); i != st.end(); ++i) {
s << *i;
if (next(i) != st.end())
s << ", ";
}
s << "}";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{";
for (auto i = m.begin(); i != m.end(); ++i) {
s << i->first << ":" << i->second;
if (next(i) != m.end())
s << ", ";
}
s << "}";
return s;
}
signed main() {
int N, K;
cin >> N >> K;
V<int> t(N), d(N);
REP(i, N) { cin >> t[i] >> d[i]; }
V<P<int, int>> p(N);
REP(i, N) { p[i] = MP(d[i], t[i]); }
RSORT(p);
// eat delicious sushi first
map<int, V<int>> sushi1, sushi2;
// sushi1: sushi to be eaten first
// sushi2: sushi not to be eaten first
int sum = 0;
FOR(i, 0, K) {
int t_ = p[i].S, d_ = p[i].F;
sushi1[t_].PB(d_);
sum += d_;
}
int sz = sushi1.size();
FOR(i, K, N) {
int t_ = p[i].S, d_ = p[i].F;
sushi2[t_].PB(d_);
}
V<int> sushi3;
// sushi3: sushi whose type is already eaten
EACH(i, sushi1) {
RSORT(i->S);
EACH(j, i->S) {
if (j == i->S.begin())
continue;
sushi3.PB(*j);
}
}
V<int> sushi4;
// sushi4: sushi whose type is not eaten yet
EACH(i, sushi2) {
if (sushi1[i->F].size() != 0)
continue;
RSORT(i->S);
sushi4.PB(i->S[0]);
}
SORT(sushi3);
RSORT(sushi4);
DUMP(sushi3)
DUMP(sushi4)
int ans = sum + sz * sz;
REP(i, min(sushi3.size(), sushi4.size())) {
sum = sum - sushi3[i] + sushi4[i];
sz++;
chmax(ans, sum + sz * sz);
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.function.change"
] | 946,423 | 946,424 | u960524878 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long> vl;
ll solve(int N, int K, vi &t, vi &d) {
map<int, vi> sushi_list;
for (int i = 0; i < N; i++) {
sushi_list[t[i]].push_back(d[i]);
}
vi winner, looser;
for (auto p : sushi_list) {
vi q = p.second;
sort(q.begin(), q.end());
int w = q.back();
winner.push_back(w);
q.pop_back();
looser.insert(looser.begin(), q.begin(), q.end());
}
sort(winner.begin(), winner.end(), greater<int>());
sort(looser.begin(), looser.end(), greater<int>());
int W = winner.size();
int L = looser.size();
vl winner_cumsum(W + 1);
vl looser_cumsum(L + 1);
winner_cumsum[0] = 0;
looser_cumsum[0] = 0;
for (int i = 0; i < W; ++i) {
winner_cumsum[i + 1] = winner_cumsum[i] + winner[i];
}
for (int i = 0; i < L; ++i) {
looser_cumsum[i + 1] = looser_cumsum[i] + looser[i];
}
ll best = 0;
for (int n_unique = 1; n_unique <= W; ++n_unique) {
if (n_unique <= K && (K - n_unique <= L)) {
ll tmp = winner_cumsum[n_unique] + looser[K - n_unique] +
(ll)n_unique * n_unique;
best = max(best, tmp);
}
}
return best;
}
int main() {
int N, K;
cin >> N >> K;
vi t, d;
for (int i = 0; i < N; i++) {
int t_, d_;
cin >> t_ >> d_;
t.push_back(t_);
d.push_back(d_);
}
ll ans = solve(N, K, t, d);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long> vl;
ll solve(int N, int K, vi &t, vi &d) {
map<int, vi> sushi_list;
for (int i = 0; i < N; i++) {
sushi_list[t[i]].push_back(d[i]);
}
vi winner, looser;
for (auto p : sushi_list) {
vi q = p.second;
sort(q.begin(), q.end());
int w = q.back();
winner.push_back(w);
q.pop_back();
looser.insert(looser.begin(), q.begin(), q.end());
}
sort(winner.begin(), winner.end(), greater<int>());
sort(looser.begin(), looser.end(), greater<int>());
int W = winner.size();
int L = looser.size();
vl winner_cumsum(W + 1);
vl looser_cumsum(L + 1);
winner_cumsum[0] = 0;
looser_cumsum[0] = 0;
for (int i = 0; i < W; ++i) {
winner_cumsum[i + 1] = winner_cumsum[i] + winner[i];
}
for (int i = 0; i < L; ++i) {
looser_cumsum[i + 1] = looser_cumsum[i] + looser[i];
}
ll best = 0;
for (int n_unique = 1; n_unique <= W; ++n_unique) {
if (n_unique <= K && (K - n_unique <= L)) {
ll tmp = winner_cumsum[n_unique] + looser_cumsum[K - n_unique] +
(ll)n_unique * n_unique;
best = max(best, tmp);
}
}
return best;
}
int main() {
int N, K;
cin >> N >> K;
vi t, d;
for (int i = 0; i < N; i++) {
int t_, d_;
cin >> t_ >> d_;
t.push_back(t_);
d.push_back(d_);
}
ll ans = solve(N, K, t, d);
cout << ans << endl;
return 0;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 946,431 | 946,432 | u826487371 | cpp |
p03148 | #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i, a, b) for (signed i = a; i < (b); ++i)
#define erep(i, a, b) for (signed i = a; i <= (b); ++i)
#define per(i, a, b) for (signed i = (a); i > (b); --i)
#define eper(i, a, b) for (signed i = (a); i >= b; --i)
#define fore(i, x, a) for (auto &&x : a)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define pb push_back
#define mp make_pair
#define ALL(x) begin(x), end(x)
#define F first
#define S second
#define debug(x) cout << #x << ": " << (x) << '\n';
const long long INF = 1001001001001001001;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
using namespace std;
using Pii = pair<int, int>;
using vii = vector<int>;
template <class T> using PS_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vv = vector<T>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
ITR(i, begin(v), end(v)) os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
ITR(i, begin(v), end(v)) is >> *i;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct edge {
int from, to, cost;
};
int dy[] = {0, 1, -1, 0};
int dx[] = {1, 0, 0, -1};
// cout << fixed;
// cout << setprecision(10) << val;
int n, k;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
vv<Pii> sushi;
PS_queue<int> que;
priority_queue<int> dup;
set<int> S;
rep(i, 0, n) {
int t, d;
cin >> t >> d;
sushi.pb({d, t});
}
sort(ALL(sushi), greater<Pii>());
int ans = 0, sum = 0, kind = 0;
rep(i, 0, k) {
sum += sushi[i].F;
if (S.count(sushi[i].S)) {
dup.push(sushi[i].F);
} else {
kind++;
S.insert(sushi[i].S);
}
}
ans = sum + kind * kind;
rep(i, k, n) {
if (dup.empty()) {
break;
}
if (S.count(sushi[i].S) == 0) {
sum -= dup.top();
dup.pop();
kind++;
sum += sushi[i].F;
S.insert(sushi[i].S);
chmax(ans, sum + kind * kind);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i, a, b) for (signed i = a; i < (b); ++i)
#define erep(i, a, b) for (signed i = a; i <= (b); ++i)
#define per(i, a, b) for (signed i = (a); i > (b); --i)
#define eper(i, a, b) for (signed i = (a); i >= b; --i)
#define fore(i, x, a) for (auto &&x : a)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define pb push_back
#define mp make_pair
#define ALL(x) begin(x), end(x)
#define F first
#define S second
#define debug(x) cout << #x << ": " << (x) << '\n';
const long long INF = 1001001001001001001;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
using namespace std;
using Pii = pair<int, int>;
using vii = vector<int>;
template <class T> using PS_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vv = vector<T>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
ITR(i, begin(v), end(v)) os << *i << (i == end(v) - 1 ? "" : " ");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
ITR(i, begin(v), end(v)) is >> *i;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct edge {
int from, to, cost;
};
int dy[] = {0, 1, -1, 0};
int dx[] = {1, 0, 0, -1};
// cout << fixed;
// cout << setprecision(10) << val;
int n, k;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k;
vv<Pii> sushi;
PS_queue<int> que;
stack<int> dup;
set<int> S;
rep(i, 0, n) {
int t, d;
cin >> t >> d;
sushi.pb({d, t});
}
sort(ALL(sushi), greater<Pii>());
int ans = 0, sum = 0, kind = 0;
rep(i, 0, k) {
sum += sushi[i].F;
if (S.count(sushi[i].S)) {
dup.push(sushi[i].F);
} else {
kind++;
S.insert(sushi[i].S);
}
}
ans = sum + kind * kind;
rep(i, k, n) {
if (dup.empty()) {
break;
}
if (S.count(sushi[i].S) == 0) {
sum -= dup.top();
dup.pop();
kind++;
sum += sushi[i].F;
S.insert(sushi[i].S);
chmax(ans, sum + kind * kind);
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 946,435 | 946,436 | u394919721 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define tr(container, it) \
for (auto it = container.begin(); it != container.end(); it++)
#define scontains(c, x) ((c).find(x) != (c).end()) // O(log n)
#define contains(c, x) (find((c).begin(), (c).end(), x) != (c).end()) // O(n)
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mll map<ll, ll>
#define in(x, a, b) ((x) >= a && (x) <= b)
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define _for(i, end) for (__typeof(end) i = 0; i < (end); i += 1)
#define all(x) (x).begin(), (x).end()
//#define len(array) (sizeof(array)/sizeof((array)[0]))
#define endl '\n'
#define what_is(x) cerr << #x << " is " << x << endl;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
#define mod(x, m) ((((x) % (m)) + (m)) % (m))
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...);
}
const double PI = 2 * acos(.0);
const int INF = 0x3f3f3f3f;
const ll LLINF = 1000000000000000005LL;
;
const ll MOD = (ll)(1e9) + 7;
// const ll MOD = (ll) 998244353 ;
const double EPS = 1e-10;
int readint() {
int x;
cin >> x;
return x;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto a : v)
os << a << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto a : v)
os << a << " ";
return os;
}
int power_mod(int x, int y, int p) {
if (y < 0)
return 0;
int res = 1;
x = x % p;
while (y) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int power(ll x, ll y) {
if (y < 0)
return 0;
ll res = 1;
while (y) {
if (y & 1)
res = (res * x);
y = y >> 1;
x *= x;
}
return res;
}
int fac[7777777];
void init(int MX) {
fac[0] = 1;
for (int i = 1; i <= MX; i++)
fac[i] = fac[i - 1] * i % MOD;
}
// Returns n^(-1) mod p
int modInverse(int n, int p) { return power_mod(n, p - 2, p); }
int comb_mod(int n, int r, int p) {
if (r == 0)
return 1;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
int comb(int a, int b) {
int res = 1;
rep(i, a + 1, a - b + 1) res *= i, res /= a - i + 1;
// rep(i,1,b+1)res /= i;
return res;
}
bool equal(double a, double b) {
return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
}
struct UnionFind {
// par[i]：データiが属する木の親の番号。i ==
// par[i]のとき、データiは木の根ノードである
vector<int> par;
// sizes[i]：根ノードiの木に含まれるデータの数。iが根ノードでない場合は無意味な値となる
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
// 最初は全てのデータiがグループiに存在するものとして初期化
rep(i, 0, n) par[i] = i;
}
// データxが属する木の根を得る
int find(int x) {
if (x == par[x])
return x;
return par[x] = find(par[x]); // 根を張り替えながら再帰的に根ノードを探す
}
// 2つのデータx, yが属する木をマージする
void unite(int x, int y) {
// データの根ノードを得る
x = find(x);
y = find(y);
// 既に同じ木に属しているならマージしない
if (x == y)
return;
// xの木がyの木より大きくなるようにする
if (sizes[x] < sizes[y])
swap(x, y);
// xがyの親になるように連結する
par[y] = x;
sizes[x] += sizes[y];
// sizes[y] = 0; // sizes[y]は無意味な値となるので0を入れておいてもよい
}
// 2つのデータx, yが属する木が同じならtrueを返す
bool same(int x, int y) { return find(x) == find(y); }
// データxが含まれる木の大きさを返す
int size(int x) { return sizes[find(x)]; }
};
// fastest
struct cpmFunctor {
inline bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) {
return p1.first < p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
bool isPrime(int n) {
// Corner case
if (n <= 1)
return false;
if (n == 2 || n == 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
// Check from 2 to n-1
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0)
return false;
for (int i = 7; i * i <= n; i += 6)
if (n % i == 0)
return false;
return true;
}
int lcm(int a, int b) { return a / __gcd(a, b) * b; }
// class Graph{
// int V;
// vector<int>* adj;
//
// public:
// Graph(int V){
// this->V = V;
// adj = new vector<int>[V];
//
// }
//
// void addEdge(int from, int to){
// adj[from].push_back(to);
// }
//
//
// bool isCyclicUtil(int v, bool visited[], bool *recStack)
// {
// if(visited[v] == false)
// {
// // Mark the current node as visited and part of recursion stack
// visited[v] = true;
// recStack[v] = true;
//
// // Recur for all the vertices adjacent to this vertex
// for(auto i = adj[v].begin(); i != adj[v].end(); ++i)
// {
// if ( !visited[*i] && isCyclicUtil(*i, visited, recStack) )
// return true;
// else if (recStack[*i])
// return true;
// }
//
// }
// recStack[v] = false; // remove the vertex from recursion stack
// return false;
// }
//
//// Returns true if the graph contains a cycle, else false.
//// This function is a variation of DFS() in
///https://www.geeksforgeeks.org/archives/18212
// bool isCyclic()
// {
// // Mark all the vertices as not visited and not part of recursion
// // stack
// bool *visited = new bool[V];
// bool *recStack = new bool[V];
// for(int i = 0; i < V; i++)
// {
// visited[i] = false;
// recStack[i] = false;
// }
//
// // Call the recursive helper function to detect cycle in different
// // DFS trees
// for(int i = 0; i < V; i++)
// if (isCyclicUtil(i, visited, recStack))
// return true;
//
// return false;
// }
//
//
//};
struct edge {
int to;
int cost;
};
class wGraph {
int V;
vector<edge> *adj;
public:
wGraph(int V) {
this->V = V;
adj = new vector<edge>[V];
}
void addEdge(int from, int to, int cost) { adj[from].push_back({to, cost}); }
};
//#define int ll
int N, K;
map<int, int> M;
priority_queue<pii, vector<pii>, greater<pii>> pq;
pii Sushi[101010];
void solve() {
ll mx = -1;
cin >> N >> K;
_for(i, N) {
int t, d;
cin >> t >> d;
Sushi[i] = {d, t};
}
ll sum = 0;
sort(Sushi, Sushi + N, greater<pair<int, int>>());
_for(i, K) {
M[Sushi[i].second]++, sum += Sushi[i].first;
if (M[Sushi[i].second] > 1)
pq.push(Sushi[i]);
}
sum += M.size() * M.size();
mx = max(mx, sum);
rep(i, K, N) {
if (pq.empty())
break;
if (!M.count(Sushi[i].second)) {
int t = pq.top().second, d = pq.top().first;
sum -= d, sum += 2 * M.size() + 1 + Sushi[i].first;
M[Sushi[i].second]++;
mx = max(mx, sum);
}
}
cout << mx << endl;
}
#undef int
int main() {
#if __MINGW32__
freopen("../Input.txt", "r", stdin);
freopen("../Output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define tr(container, it) \
for (auto it = container.begin(); it != container.end(); it++)
#define scontains(c, x) ((c).find(x) != (c).end()) // O(log n)
#define contains(c, x) (find((c).begin(), (c).end(), x) != (c).end()) // O(n)
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mll map<ll, ll>
#define in(x, a, b) ((x) >= a && (x) <= b)
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define _for(i, end) for (__typeof(end) i = 0; i < (end); i += 1)
#define all(x) (x).begin(), (x).end()
//#define len(array) (sizeof(array)/sizeof((array)[0]))
#define endl '\n'
#define what_is(x) cerr << #x << " is " << x << endl;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
#define mod(x, m) ((((x) % (m)) + (m)) % (m))
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...);
}
const double PI = 2 * acos(.0);
const int INF = 0x3f3f3f3f;
const ll LLINF = 1000000000000000005LL;
;
const ll MOD = (ll)(1e9) + 7;
// const ll MOD = (ll) 998244353 ;
const double EPS = 1e-10;
int readint() {
int x;
cin >> x;
return x;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto a : v)
os << a << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto a : v)
os << a << " ";
return os;
}
int power_mod(int x, int y, int p) {
if (y < 0)
return 0;
int res = 1;
x = x % p;
while (y) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int power(ll x, ll y) {
if (y < 0)
return 0;
ll res = 1;
while (y) {
if (y & 1)
res = (res * x);
y = y >> 1;
x *= x;
}
return res;
}
int fac[7777777];
void init(int MX) {
fac[0] = 1;
for (int i = 1; i <= MX; i++)
fac[i] = fac[i - 1] * i % MOD;
}
// Returns n^(-1) mod p
int modInverse(int n, int p) { return power_mod(n, p - 2, p); }
int comb_mod(int n, int r, int p) {
if (r == 0)
return 1;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
int comb(int a, int b) {
int res = 1;
rep(i, a + 1, a - b + 1) res *= i, res /= a - i + 1;
// rep(i,1,b+1)res /= i;
return res;
}
bool equal(double a, double b) {
return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
}
struct UnionFind {
// par[i]：データiが属する木の親の番号。i ==
// par[i]のとき、データiは木の根ノードである
vector<int> par;
// sizes[i]：根ノードiの木に含まれるデータの数。iが根ノードでない場合は無意味な値となる
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
// 最初は全てのデータiがグループiに存在するものとして初期化
rep(i, 0, n) par[i] = i;
}
// データxが属する木の根を得る
int find(int x) {
if (x == par[x])
return x;
return par[x] = find(par[x]); // 根を張り替えながら再帰的に根ノードを探す
}
// 2つのデータx, yが属する木をマージする
void unite(int x, int y) {
// データの根ノードを得る
x = find(x);
y = find(y);
// 既に同じ木に属しているならマージしない
if (x == y)
return;
// xの木がyの木より大きくなるようにする
if (sizes[x] < sizes[y])
swap(x, y);
// xがyの親になるように連結する
par[y] = x;
sizes[x] += sizes[y];
// sizes[y] = 0; // sizes[y]は無意味な値となるので0を入れておいてもよい
}
// 2つのデータx, yが属する木が同じならtrueを返す
bool same(int x, int y) { return find(x) == find(y); }
// データxが含まれる木の大きさを返す
int size(int x) { return sizes[find(x)]; }
};
// fastest
struct cpmFunctor {
inline bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) {
return p1.first < p2.first ||
(p1.first == p2.first && p1.second < p2.second);
}
};
bool isPrime(int n) {
// Corner case
if (n <= 1)
return false;
if (n == 2 || n == 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
// Check from 2 to n-1
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0)
return false;
for (int i = 7; i * i <= n; i += 6)
if (n % i == 0)
return false;
return true;
}
int lcm(int a, int b) { return a / __gcd(a, b) * b; }
// class Graph{
// int V;
// vector<int>* adj;
//
// public:
// Graph(int V){
// this->V = V;
// adj = new vector<int>[V];
//
// }
//
// void addEdge(int from, int to){
// adj[from].push_back(to);
// }
//
//
// bool isCyclicUtil(int v, bool visited[], bool *recStack)
// {
// if(visited[v] == false)
// {
// // Mark the current node as visited and part of recursion stack
// visited[v] = true;
// recStack[v] = true;
//
// // Recur for all the vertices adjacent to this vertex
// for(auto i = adj[v].begin(); i != adj[v].end(); ++i)
// {
// if ( !visited[*i] && isCyclicUtil(*i, visited, recStack) )
// return true;
// else if (recStack[*i])
// return true;
// }
//
// }
// recStack[v] = false; // remove the vertex from recursion stack
// return false;
// }
//
//// Returns true if the graph contains a cycle, else false.
//// This function is a variation of DFS() in
///https://www.geeksforgeeks.org/archives/18212
// bool isCyclic()
// {
// // Mark all the vertices as not visited and not part of recursion
// // stack
// bool *visited = new bool[V];
// bool *recStack = new bool[V];
// for(int i = 0; i < V; i++)
// {
// visited[i] = false;
// recStack[i] = false;
// }
//
// // Call the recursive helper function to detect cycle in different
// // DFS trees
// for(int i = 0; i < V; i++)
// if (isCyclicUtil(i, visited, recStack))
// return true;
//
// return false;
// }
//
//
//};
struct edge {
int to;
int cost;
};
class wGraph {
int V;
vector<edge> *adj;
public:
wGraph(int V) {
this->V = V;
adj = new vector<edge>[V];
}
void addEdge(int from, int to, int cost) { adj[from].push_back({to, cost}); }
};
//#define int ll
int N, K;
map<int, int> M;
priority_queue<pii, vector<pii>, greater<pii>> pq;
pii Sushi[101010];
void solve() {
ll mx = -1;
cin >> N >> K;
_for(i, N) {
int t, d;
cin >> t >> d;
Sushi[i] = {d, t};
}
ll sum = 0;
sort(Sushi, Sushi + N, greater<pair<int, int>>());
_for(i, K) {
M[Sushi[i].second]++, sum += Sushi[i].first;
if (M[Sushi[i].second] > 1)
pq.push(Sushi[i]);
}
sum += M.size() * M.size();
mx = max(mx, sum);
rep(i, K, N) {
if (pq.empty())
break;
if (!M.count(Sushi[i].second)) {
int t = pq.top().second, d = pq.top().first;
sum -= d, sum += 2 * M.size() + 1 + Sushi[i].first;
M[Sushi[i].second]++;
mx = max(mx, sum);
pq.pop();
}
}
cout << mx << endl;
}
#undef int
int main() {
#if __MINGW32__
freopen("../Input.txt", "r", stdin);
freopen("../Output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| [
"call.add"
] | 946,454 | 946,455 | u093219895 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
// --
#define HOGE \
std::cin.tie(0); \
std::ios::sync_with_stdio(false);
template <typename T> void CIN_VAR(T &t) { cin >> t; }
template <typename A, typename... R> void CIN_VAR(A &car, R &...cdr) {
std::cin >> car;
CIN_VAR(cdr...);
}
#define VAR(type, ...) \
type __VA_ARGS__; \
CIN_VAR(__VA_ARGS__);
#define VEC(t, c, n) \
std::vector<t> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(t, c, m, n) \
std::vector<std::vector<t>> c(m, std::vector<t>(n)); \
for (auto &row : c) \
for (auto &w : row) \
std::cin >> w;
#define ALL(c) (c).begin(), (c).end()
#define CALL(c) (c).cbegin(), (c).cend()
#define RALL(c) (c).rbegin(), (c).rend()
#define CRALL(c) (c).crbegin(), (c).crend()
#define REP(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define FOR(i, s, n) for (int i = s; i < static_cast<int>(n); i++)
#define PSORT(s, p, e) partial_sort((s), next((s), (p)), (e))
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &x, const T y) {
return x = (x < y) ? y : x;
}
template <class T> inline T CHMIN(T &x, const T y) {
return x = (x > y) ? y : x;
}
#define SDESC(t) [](t &x, t &y) { return x > y; }
#define VIEW(v, t) \
for_each((v).begin(), (v).end(), [](t &a) { cout << a << " "; }); \
cout << "\n";
#define COUT(dist) std::cout << (dist);
#define WS std::cout << " ";
#define NL std::cout << "\n";
// --
// --
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using LL = long long;
using ULL = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using V2 = vector<vector<T>>;
template <class T, int W = 255> using A = array<T, W>;
template <class T, int W = 255, int H = 255> using A2 = array<array<T, W>, W>;
constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};
// --
LL n, k;
V<LL> t, d;
V<PLL> pv;
std::set<int> s;
std::stack<int> st;
int main() {
HOGE;
cin >> n;
cin >> k;
t.resize(n);
d.resize(n);
pv.resize(n);
REP(i, n) {
cin >> t[i];
cin >> d[i];
}
{
REP(i, n) pv[i] = PLL(d[i], t[i]);
std::sort(ALL(pv), SDESC(PLL));
REP(i, n) std::tie(d[i], t[i]) = pv[i];
}
LL ans = 0;
REP(i, k) {
if (s.count(t[i]))
st.push(d[i]);
s.insert(t[i]);
ans += d[i];
}
LL sum = ans;
ans += (LL)((LL)s.size() * (LL)s.size());
FOR(i, k, n) {
if (s.empty())
break;
if (s.count(t[i]))
continue;
s.insert(t[i]);
sum -= st.top();
st.pop();
sum += d[i];
CHMAX<LL>(ans, sum + (LL)(s.size() * s.size()));
}
COUT(ans) NL;
}
| #include <bits/stdc++.h>
using namespace std;
// --
#define HOGE \
std::cin.tie(0); \
std::ios::sync_with_stdio(false);
template <typename T> void CIN_VAR(T &t) { cin >> t; }
template <typename A, typename... R> void CIN_VAR(A &car, R &...cdr) {
std::cin >> car;
CIN_VAR(cdr...);
}
#define VAR(type, ...) \
type __VA_ARGS__; \
CIN_VAR(__VA_ARGS__);
#define VEC(t, c, n) \
std::vector<t> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(t, c, m, n) \
std::vector<std::vector<t>> c(m, std::vector<t>(n)); \
for (auto &row : c) \
for (auto &w : row) \
std::cin >> w;
#define ALL(c) (c).begin(), (c).end()
#define CALL(c) (c).cbegin(), (c).cend()
#define RALL(c) (c).rbegin(), (c).rend()
#define CRALL(c) (c).crbegin(), (c).crend()
#define REP(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define FOR(i, s, n) for (int i = s; i < static_cast<int>(n); i++)
#define PSORT(s, p, e) partial_sort((s), next((s), (p)), (e))
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &x, const T y) {
return x = (x < y) ? y : x;
}
template <class T> inline T CHMIN(T &x, const T y) {
return x = (x > y) ? y : x;
}
#define SDESC(t) [](t &x, t &y) { return x > y; }
#define VIEW(v, t) \
for_each((v).begin(), (v).end(), [](t &a) { cout << a << " "; }); \
cout << "\n";
#define COUT(dist) std::cout << (dist);
#define WS std::cout << " ";
#define NL std::cout << "\n";
// --
// --
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using LL = long long;
using ULL = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using V2 = vector<vector<T>>;
template <class T, int W = 255> using A = array<T, W>;
template <class T, int W = 255, int H = 255> using A2 = array<array<T, W>, W>;
constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};
// --
LL n, k;
V<LL> t, d;
V<PLL> pv;
std::set<int> s;
std::stack<int> st;
int main() {
HOGE;
cin >> n;
cin >> k;
t.resize(n);
d.resize(n);
pv.resize(n);
REP(i, n) {
cin >> t[i];
cin >> d[i];
}
{
REP(i, n) pv[i] = PLL(d[i], t[i]);
std::sort(ALL(pv), SDESC(PLL));
REP(i, n) std::tie(d[i], t[i]) = pv[i];
}
LL ans = 0;
REP(i, k) {
if (s.count(t[i]))
st.push(d[i]);
s.insert(t[i]);
ans += d[i];
}
LL sum = ans;
ans += (LL)((LL)s.size() * (LL)s.size());
FOR(i, k, n) {
if (st.empty())
break;
if (s.count(t[i]))
continue;
s.insert(t[i]);
sum -= st.top();
st.pop();
sum += d[i];
CHMAX<LL>(ans, sum + (LL)(s.size() * s.size()));
}
COUT(ans) NL;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 946,456 | 946,457 | u685774550 | cpp |
p03148 | #include <bits/stdc++.h>
using namespace std;
// --
#define HOGE \
std::cin.tie(0); \
std::ios::sync_with_stdio(false);
template <typename T> void CIN_VAR(T &t) { cin >> t; }
template <typename A, typename... R> void CIN_VAR(A &car, R &...cdr) {
std::cin >> car;
CIN_VAR(cdr...);
}
#define VAR(type, ...) \
type __VA_ARGS__; \
CIN_VAR(__VA_ARGS__);
#define VEC(t, c, n) \
std::vector<t> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(t, c, m, n) \
std::vector<std::vector<t>> c(m, std::vector<t>(n)); \
for (auto &row : c) \
for (auto &w : row) \
std::cin >> w;
#define ALL(c) (c).begin(), (c).end()
#define CALL(c) (c).cbegin(), (c).cend()
#define RALL(c) (c).rbegin(), (c).rend()
#define CRALL(c) (c).crbegin(), (c).crend()
#define REP(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define FOR(i, s, n) for (int i = s; i < static_cast<int>(n); i++)
#define PSORT(s, p, e) partial_sort((s), next((s), (p)), (e))
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &x, const T y) {
return x = (x < y) ? y : x;
}
template <class T> inline T CHMIN(T &x, const T y) {
return x = (x > y) ? y : x;
}
#define SDESC(t) [](t &x, t &y) { return x > y; }
#define VIEW(v, t) \
for_each((v).begin(), (v).end(), [](t &a) { cout << a << " "; }); \
cout << "\n";
#define COUT(dist) std::cout << (dist);
#define WS std::cout << " ";
#define NL std::cout << "\n";
// --
// --
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using LL = long long;
using ULL = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using V2 = vector<vector<T>>;
template <class T, int W = 255> using A = array<T, W>;
template <class T, int W = 255, int H = 255> using A2 = array<array<T, W>, W>;
constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};
// --
LL n, k;
V<LL> t, d;
V<PLL> pv;
std::set<LL> s;
std::stack<LL> st;
int main() {
HOGE;
cin >> n;
cin >> k;
t.resize(n);
d.resize(n);
pv.resize(n);
REP(i, n) {
cin >> t[i];
cin >> d[i];
}
{
REP(i, n) pv[i] = PII(d[i], t[i]);
std::sort(ALL(pv), SDESC(PLL));
REP(i, n) std::tie(d[i], t[i]) = pv[i];
}
LL ans = 0;
REP(i, k) {
if (s.count(t[i]))
st.push(d[i]);
s.insert(t[i]);
ans += d[i];
}
LL sum = ans;
ans += (LL)((LL)s.size() * (LL)s.size());
FOR(i, k, n) {
if (s.empty())
break;
if (s.count(t[i]))
continue;
s.insert(t[i]);
sum -= st.top();
st.pop();
sum += d[i];
CHMAX<LL>(ans, sum + (LL)(s.size() * s.size()));
}
COUT(ans) NL;
}
| #include <bits/stdc++.h>
using namespace std;
// --
#define HOGE \
std::cin.tie(0); \
std::ios::sync_with_stdio(false);
template <typename T> void CIN_VAR(T &t) { cin >> t; }
template <typename A, typename... R> void CIN_VAR(A &car, R &...cdr) {
std::cin >> car;
CIN_VAR(cdr...);
}
#define VAR(type, ...) \
type __VA_ARGS__; \
CIN_VAR(__VA_ARGS__);
#define VEC(t, c, n) \
std::vector<t> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(t, c, m, n) \
std::vector<std::vector<t>> c(m, std::vector<t>(n)); \
for (auto &row : c) \
for (auto &w : row) \
std::cin >> w;
#define ALL(c) (c).begin(), (c).end()
#define CALL(c) (c).cbegin(), (c).cend()
#define RALL(c) (c).rbegin(), (c).rend()
#define CRALL(c) (c).crbegin(), (c).crend()
#define REP(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define FOR(i, s, n) for (int i = s; i < static_cast<int>(n); i++)
#define PSORT(s, p, e) partial_sort((s), next((s), (p)), (e))
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &x, const T y) {
return x = (x < y) ? y : x;
}
template <class T> inline T CHMIN(T &x, const T y) {
return x = (x > y) ? y : x;
}
#define SDESC(t) [](t &x, t &y) { return x > y; }
#define VIEW(v, t) \
for_each((v).begin(), (v).end(), [](t &a) { cout << a << " "; }); \
cout << "\n";
#define COUT(dist) std::cout << (dist);
#define WS std::cout << " ";
#define NL std::cout << "\n";
// --
// --
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using LL = long long;
using ULL = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using V2 = vector<vector<T>>;
template <class T, int W = 255> using A = array<T, W>;
template <class T, int W = 255, int H = 255> using A2 = array<array<T, W>, W>;
constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};
// --
LL n, k;
V<LL> t, d;
V<PLL> pv;
std::set<int> s;
std::stack<int> st;
int main() {
HOGE;
cin >> n;
cin >> k;
t.resize(n);
d.resize(n);
pv.resize(n);
REP(i, n) {
cin >> t[i];
cin >> d[i];
}
{
REP(i, n) pv[i] = PLL(d[i], t[i]);
std::sort(ALL(pv), SDESC(PLL));
REP(i, n) std::tie(d[i], t[i]) = pv[i];
}
LL ans = 0;
REP(i, k) {
if (s.count(t[i]))
st.push(d[i]);
s.insert(t[i]);
ans += d[i];
}
LL sum = ans;
ans += (LL)((LL)s.size() * (LL)s.size());
FOR(i, k, n) {
if (st.empty())
break;
if (s.count(t[i]))
continue;
s.insert(t[i]);
sum -= st.top();
st.pop();
sum += d[i];
CHMAX<LL>(ans, sum + (LL)(s.size() * s.size()));
}
COUT(ans) NL;
}
| [
"assignment.value.change",
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 946,458 | 946,457 | u685774550 | cpp |
p03148 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int N, K;
cin >> N >> K;
vector<pair<ll, int>> p;
int t;
bool kind[100000];
ll d;
rep(i, N) {
cin >> t >> d;
t--;
kind[t] = true;
p.push_back(make_pair(d, t));
}
sort(p.begin(), p.end());
ll ans = 0;
ll s[100000], ss[100000];
int use_num = 0, num = 0;
rep(i, K) {
ans += p[N - 1 - i].first;
if (kind[p[N - 1 - i].second]) {
use_num++;
kind[p[N - 1 - i].second] = false;
} else {
num++;
s[num - 1] = p[N - 1 - i].first;
}
}
ss[0] = s[num - 1];
rep(i, num - 1) ss[i + 1] = ss[i] + s[num - 2 - i];
rep(i, K) p.pop_back();
vector<ll> vec;
while (!p.empty()) {
if (kind[p.back().second]) {
vec.push_back(p.back().first);
kind[p.back().second] = false;
}
p.pop_back();
}
sort(vec.begin(), vec.end());
ll S[100000];
int ind = -1;
while (!vec.empty()) {
ind++;
if (ind == 0)
S[ind] = vec.back();
else
S[ind] = S[ind - 1] + vec.back();
vec.pop_back();
}
d = 0;
rep(i, min(ind + 1, num)) {
d = max(d, S[i] + 2 * (i + 1) * use_num + (i + 1) * (i + 1) - ss[i]);
}
cout << ans + d + use_num * use_num << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (ll i = 0; i < n; i++)
int main() {
ll N, K;
cin >> N >> K;
vector<pair<ll, ll>> p;
ll t;
bool kind[100000];
ll d;
rep(i, N) {
cin >> t >> d;
t--;
kind[t] = true;
p.push_back(make_pair(d, t));
}
sort(p.begin(), p.end());
ll ans = 0;
ll s[100000], ss[100000];
ll use_num = 0, num = 0;
rep(i, K) {
ans += p[N - 1 - i].first;
if (kind[p[N - 1 - i].second]) {
use_num++;
kind[p[N - 1 - i].second] = false;
} else {
num++;
s[num - 1] = p[N - 1 - i].first;
}
}
ss[0] = s[num - 1];
rep(i, num - 1) ss[i + 1] = ss[i] + s[num - 2 - i];
rep(i, K) p.pop_back();
vector<ll> vec;
while (!p.empty()) {
if (kind[p.back().second]) {
vec.push_back(p.back().first);
kind[p.back().second] = false;
}
p.pop_back();
}
sort(vec.begin(), vec.end());
ll S[100000];
ll ind = -1;
while (!vec.empty()) {
ind++;
if (ind == 0)
S[ind] = vec.back();
else
S[ind] = S[ind - 1] + vec.back();
vec.pop_back();
}
d = 0;
rep(i, min(ind + 1, num)) {
d = max(d, S[i] + 2 * (i + 1) * use_num + (i + 1) * (i + 1) - ss[i]);
}
cout << ans + d + use_num * use_num << endl;
return 0;
} | [
"preprocessor.define.value.change",
"variable_declaration.type.change"
] | 946,459 | 946,460 | u563710899 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.