problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define N 1010
#define ll long long
const ll mod = 1e9 + 7;
int n, m, s1, s2, cnt;
int a[N], b[N], h[N], l[N];
ll ans = 1;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (h[a[i]])
return puts("0"), 0;
h[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
if (l[b[i]])
return puts("0"), 0;
l[b[i]] = i;
}
for (int i = n * m; i; i--) {
if (h[i] && l[i])
s1++, s2++;
else if (h[i] || l[i]) {
if (h[i])
ans = ans * s2 % mod, s1++;
else
ans = ans * s1 % mod, s2++;
} else
ans = ans * (s1 * s2 - (n * m - i)) % mod, cnt++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define N 1010
#define ll long long
const ll mod = 1e9 + 7;
int n, m, s1, s2, cnt;
int a[N], b[N], h[N * N], l[N * N];
ll ans = 1;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (h[a[i]])
return puts("0"), 0;
h[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
if (l[b[i]])
return puts("0"), 0;
l[b[i]] = i;
}
for (int i = n * m; i; i--) {
if (h[i] && l[i])
s1++, s2++;
else if (h[i] || l[i]) {
if (h[i])
ans = ans * s2 % mod, s1++;
else
ans = ans * s1 % mod, s2++;
} else
ans = ans * (s1 * s2 - (n * m - i)) % mod, cnt++;
}
printf("%lld\n", ans);
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1005, mod = 1e9 + 7;
ll r[N], c[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
for (ll i = 1; i <= n; i++) {
ll x;
cin >> x;
if (r[x])
return cout << "0", 0;
r[x] = i;
}
for (ll i = 1; i <= m; i++) {
ll x;
cin >> x;
if (c[x])
return cout << "0", 0;
c[x] = i;
}
ll ans = 1, x = 0, y = 0;
for (ll val = n * m; val >= 1; val--) {
if (r[val] || c[val]) {
if (r[val] && c[val])
x++, y++;
else if (r[val]) {
ans *= y;
ans %= mod;
x++;
} else {
ans *= x;
ans %= mod;
y++;
}
} else {
ll tmp = x * y - (n * m - val);
ans *= tmp;
ans %= mod;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1e6 + 5, mod = 1e9 + 7;
int r[N], c[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
for (ll i = 1; i <= n; i++) {
ll x;
cin >> x;
if (r[x])
return cout << "0", 0;
r[x] = i;
}
for (ll i = 1; i <= m; i++) {
ll x;
cin >> x;
if (c[x])
return cout << "0", 0;
c[x] = i;
}
ll ans = 1, x = 0, y = 0;
for (ll val = n * m; val >= 1; val--) {
if (r[val] || c[val]) {
if (r[val] && c[val])
x++, y++;
else if (r[val]) {
ans *= y;
ans %= mod;
x++;
} else {
ans *= x;
ans %= mod;
y++;
}
} else {
ll tmp = x * y - (n * m - val);
ans *= tmp;
ans %= mod;
}
}
cout << ans;
}
|
replace
| 3 | 5 | 3 | 5 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int a[2003], b[2003];
int kn[2003], km[2003];
long long mod = 1000000007;
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
if (kn[a[i]]) {
puts("0");
return 0;
}
kn[a[i]] = 1;
}
for (int i = 1; i <= m; ++i) {
b[i] = read();
if (km[b[i]]) {
puts("0");
return 0;
}
km[b[i]] = 1;
}
int xn = 0, xm = 0;
int c = 0;
long long res = 1;
for (int i = n * m; i >= 1; --i) {
if (km[i] && kn[i]) {
c += xn + xm;
xn++, xm++;
} else if (kn[i]) {
if (!xm) {
puts("0");
return 0;
}
(res *= (long long)xm) %= mod;
c += xm - 1;
xn++;
} else if (km[i]) {
if (!xn) {
puts("0");
return 0;
}
(res *= (long long)xn) %= mod;
c += xn - 1;
xm++;
} else {
if (!c) {
puts("0");
return 0;
}
(res *= (long long)c) %= mod;
c--;
}
}
printf("%lld\n", res);
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int a[2003], b[2003];
int kn[2000006], km[2000006];
long long mod = 1000000007;
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
if (kn[a[i]]) {
puts("0");
return 0;
}
kn[a[i]] = 1;
}
for (int i = 1; i <= m; ++i) {
b[i] = read();
if (km[b[i]]) {
puts("0");
return 0;
}
km[b[i]] = 1;
}
int xn = 0, xm = 0;
int c = 0;
long long res = 1;
for (int i = n * m; i >= 1; --i) {
if (km[i] && kn[i]) {
c += xn + xm;
xn++, xm++;
} else if (kn[i]) {
if (!xm) {
puts("0");
return 0;
}
(res *= (long long)xm) %= mod;
c += xm - 1;
xn++;
} else if (km[i]) {
if (!xn) {
puts("0");
return 0;
}
(res *= (long long)xn) %= mod;
c += xn - 1;
xm++;
} else {
if (!c) {
puts("0");
return 0;
}
(res *= (long long)c) %= mod;
c--;
}
}
printf("%lld\n", res);
return 0;
}
|
replace
| 21 | 22 | 21 | 22 |
0
| |
p03152
|
C++
|
Runtime Error
|
// :)
// "Khodaya, be man "Tagwaye setiz" biamooz ta
// dar anbuh masuliat nalaghzam ..." -Shariati
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define F first
#define S second
#define MP make_pair
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
typedef long long int64;
typedef pair<int, int> pii;
typedef pair<int64, int64> pii64;
const int maxn = 1e3 + 9;
const int64 M = 1e9 + 7;
const int64 I = 1e9;
pii p[maxn];
int a[maxn], b[maxn], mx1[maxn], mx2[maxn];
bool vis1[maxn], vis2[maxn];
int n, m, ans = 1;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]].F = i;
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
p[b[i]].S = i;
}
int c1 = 0, c2 = 0, num = 0;
for (int i = n * m; i >= 1; i--) {
if (p[i].F && p[i].S) {
if (vis1[p[i].F]) {
ans = 0;
continue;
}
if (vis2[p[i].S]) {
ans = 0;
continue;
}
vis1[p[i].F] = vis2[p[i].S] = true;
c1++;
c2++;
continue;
}
if (p[i].F) {
if (vis1[p[i].F]) {
ans = 0;
continue;
}
vis1[p[i].F] = true;
ans = 1LL * ans * c2 % M;
c1++;
continue;
}
if (p[i].S) {
if (vis2[p[i].S]) {
ans = 0;
continue;
}
vis2[p[i].S] = true;
ans = 1LL * ans * c1 % M;
c2++;
continue;
}
ans = 1LL * ans * (c1 * c2 - (n * m - i)) % M;
}
cout << ans << "\n";
}
|
// :)
// "Khodaya, be man "Tagwaye setiz" biamooz ta
// dar anbuh masuliat nalaghzam ..." -Shariati
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define F first
#define S second
#define MP make_pair
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
typedef long long int64;
typedef pair<int, int> pii;
typedef pair<int64, int64> pii64;
const int maxn = 1e3 + 9;
const int64 M = 1e9 + 7;
const int64 I = 1e9;
pii p[maxn * maxn];
int a[maxn], b[maxn], mx1[maxn], mx2[maxn];
bool vis1[maxn], vis2[maxn];
int n, m, ans = 1;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]].F = i;
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
p[b[i]].S = i;
}
int c1 = 0, c2 = 0, num = 0;
for (int i = n * m; i >= 1; i--) {
if (p[i].F && p[i].S) {
if (vis1[p[i].F]) {
ans = 0;
continue;
}
if (vis2[p[i].S]) {
ans = 0;
continue;
}
vis1[p[i].F] = vis2[p[i].S] = true;
c1++;
c2++;
continue;
}
if (p[i].F) {
if (vis1[p[i].F]) {
ans = 0;
continue;
}
vis1[p[i].F] = true;
ans = 1LL * ans * c2 % M;
c1++;
continue;
}
if (p[i].S) {
if (vis2[p[i].S]) {
ans = 0;
continue;
}
vis2[p[i].S] = true;
ans = 1LL * ans * c1 % M;
c2++;
continue;
}
ans = 1LL * ans * (c1 * c2 - (n * m - i)) % M;
}
cout << ans << "\n";
}
|
replace
| 24 | 25 | 24 | 25 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define MAX_N 200010
long long inv[MAX_N];
long long factorial[MAX_N];
long long inv_factorial[MAX_N];
void getInv() {
for (int i = 1; i < MAX_N; i++) {
if (i == 1)
inv[i] = 1;
else {
inv[i] = (mod - (mod / i) * inv[mod % i]) % mod;
if (inv[i] < 0)
inv[i] += mod;
}
}
}
void getFactorial() {
factorial[0] = 1;
inv_factorial[0] = 1;
for (int i = 1; i < MAX_N; i++) {
factorial[i] = factorial[i - 1] * i;
factorial[i] %= mod;
inv_factorial[i] = inv_factorial[i - 1] * inv[i];
inv_factorial[i] %= mod;
}
}
long long cal(int n, int r) {
long long ret = factorial[n] * inv_factorial[n - r];
return ret % mod;
}
int main() {
int n, m;
cin >> n >> m;
long long ans = 1;
getInv();
getFactorial();
vector<int> a(n), b(m);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++)
cin >> b[i];
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
cout << 0 << endl;
return 0;
}
}
for (int i = 0; i < m - 1; i++) {
if (b[i] == b[i + 1]) {
cout << 0 << endl;
return 0;
}
}
/*
vector< vector<int> > v(n, vector<int>(m, 0));
int p = 0; int q = 0;
while (p < n && q < m) {
if (a[p] == b[q]) v[p][q] = a[p];
if (a[p] > b[q]) p++;
if (a[p] < b[q]) q++;
}
*/
map<int, int> used;
vector<pair<int, int>> u = {{0, 0}};
map<int, int> ma;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
used[a[i]]++;
continue;
}
ma[min(a[i], b[j])]++;
}
}
for (auto it = ma.begin(); it != ma.end(); it++) {
u.push_back({it->first, it->second});
}
sort(u.rbegin(), u.rend());
int mm = n * m;
int rest = 0;
int count = 0;
for (int i = 0; i < u.size() - 1; i++) {
int p = u[i].first;
int q = u[i].second;
int np = u[i + 1].first;
for (int k = mm; k > p; k--) {
if (used[k] == 0) {
cout << 0 << endl;
return 0;
}
}
mm = p;
rest += q;
int count = 0;
for (int k = mm; k > np; k--) {
if (used[k] == 0) {
count++;
}
}
if (used[p] == 1) {
ans = ans * cal(rest, count) % mod;
} else {
ans = (ans * cal(rest - 1, count - 1) % mod) * q % mod;
}
rest -= count;
mm = np;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define MAX_N 1000010
long long inv[MAX_N];
long long factorial[MAX_N];
long long inv_factorial[MAX_N];
void getInv() {
for (int i = 1; i < MAX_N; i++) {
if (i == 1)
inv[i] = 1;
else {
inv[i] = (mod - (mod / i) * inv[mod % i]) % mod;
if (inv[i] < 0)
inv[i] += mod;
}
}
}
void getFactorial() {
factorial[0] = 1;
inv_factorial[0] = 1;
for (int i = 1; i < MAX_N; i++) {
factorial[i] = factorial[i - 1] * i;
factorial[i] %= mod;
inv_factorial[i] = inv_factorial[i - 1] * inv[i];
inv_factorial[i] %= mod;
}
}
long long cal(int n, int r) {
long long ret = factorial[n] * inv_factorial[n - r];
return ret % mod;
}
int main() {
int n, m;
cin >> n >> m;
long long ans = 1;
getInv();
getFactorial();
vector<int> a(n), b(m);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++)
cin >> b[i];
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
cout << 0 << endl;
return 0;
}
}
for (int i = 0; i < m - 1; i++) {
if (b[i] == b[i + 1]) {
cout << 0 << endl;
return 0;
}
}
/*
vector< vector<int> > v(n, vector<int>(m, 0));
int p = 0; int q = 0;
while (p < n && q < m) {
if (a[p] == b[q]) v[p][q] = a[p];
if (a[p] > b[q]) p++;
if (a[p] < b[q]) q++;
}
*/
map<int, int> used;
vector<pair<int, int>> u = {{0, 0}};
map<int, int> ma;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
used[a[i]]++;
continue;
}
ma[min(a[i], b[j])]++;
}
}
for (auto it = ma.begin(); it != ma.end(); it++) {
u.push_back({it->first, it->second});
}
sort(u.rbegin(), u.rend());
int mm = n * m;
int rest = 0;
int count = 0;
for (int i = 0; i < u.size() - 1; i++) {
int p = u[i].first;
int q = u[i].second;
int np = u[i + 1].first;
for (int k = mm; k > p; k--) {
if (used[k] == 0) {
cout << 0 << endl;
return 0;
}
}
mm = p;
rest += q;
int count = 0;
for (int k = mm; k > np; k--) {
if (used[k] == 0) {
count++;
}
}
if (used[p] == 1) {
ans = ans * cal(rest, count) % mod;
} else {
ans = (ans * cal(rest - 1, count - 1) % mod) * q % mod;
}
rest -= count;
mm = np;
}
cout << ans << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (i = 0; i < n; ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
int main() {
ll i, j;
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (i = 0; i < n; ++i) {
cin >> a.at(i);
}
vector<ll> b(m);
for (i = 0; i < m; ++i) {
cin >> b.at(i);
}
const ll MOD = 1e9 + 7;
sort(all(a));
sort(all(b));
for (i = 0; i < n - 1; ++i) {
if (a.at(i) == a.at(i + 1)) {
cout << 0 << endl;
return 0;
}
}
for (i = 0; i < m - 1; ++i) {
if (b.at(i) == b.at(i + 1)) {
cout << 0 << endl;
return 0;
}
}
ll ans = 1;
for (i = n * m; i >= 1; --i) {
ll indh = lower_bound(all(a), i) - a.begin();
ll indw = lower_bound(all(b), i) - b.begin();
if (i == a.at(indh) && i == b.at(indw))
continue;
else if (i == a.at(indh)) {
ll tmp = m - indw;
ans *= tmp;
ans %= MOD;
} else if (i == b.at(indw)) {
ll tmp = n - indh;
ans *= tmp;
ans %= MOD;
} else {
ll tmp = (m - indw) * (n - indh);
tmp -= n * m - i;
if (tmp <= 0) {
cout << 0 << endl;
return 0;
}
ans *= tmp;
ans %= MOD;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (i = 0; i < n; ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
int main() {
ll i, j;
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (i = 0; i < n; ++i) {
cin >> a.at(i);
}
vector<ll> b(m);
for (i = 0; i < m; ++i) {
cin >> b.at(i);
}
const ll MOD = 1e9 + 7;
sort(all(a));
sort(all(b));
for (i = 0; i < n - 1; ++i) {
if (a.at(i) == a.at(i + 1)) {
cout << 0 << endl;
return 0;
}
}
for (i = 0; i < m - 1; ++i) {
if (b.at(i) == b.at(i + 1)) {
cout << 0 << endl;
return 0;
}
}
ll ans = 1;
for (i = n * m; i >= 1; --i) {
ll indh = lower_bound(all(a), i) - a.begin();
ll indw = lower_bound(all(b), i) - b.begin();
if (indh == n || indw == m) {
cout << 0 << endl;
return 0;
}
if (i == a.at(indh) && i == b.at(indw))
continue;
else if (i == a.at(indh)) {
ll tmp = m - indw;
ans *= tmp;
ans %= MOD;
} else if (i == b.at(indw)) {
ll tmp = n - indh;
ans *= tmp;
ans %= MOD;
} else {
ll tmp = (m - indw) * (n - indh);
tmp -= n * m - i;
if (tmp <= 0) {
cout << 0 << endl;
return 0;
}
ans *= tmp;
ans %= MOD;
}
}
cout << ans << endl;
return 0;
}
|
insert
| 38 | 38 | 38 | 42 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
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;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e15;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(n), b(n);
set<int> flag1, flag2;
rep(i, n) {
cin >> a[i];
flag1.insert(a[i]);
}
rep(i, m) {
cin >> b[i];
flag2.insert(b[i]);
}
if (flag1.size() != n || flag2.size() != m) {
cout << 0 << endl;
return 0;
}
sort(begin(a), end(a));
sort(begin(b), end(b));
mint ans = 1;
for (int i = n * m; i >= 1; i--) {
bool f1 = flag1.count(i), f2 = flag2.count(i);
if (f1 && f2)
continue;
else if (f1 && !f2) {
ans *= end(b) - upper_bound(begin(b), end(b), i);
} else if (!f1 && f2) {
ans *= end(a) - upper_bound(begin(a), end(a), i);
} else {
ans *= (end(b) - upper_bound(begin(b), end(b), i)) *
(end(a) - upper_bound(begin(a), end(a), i)) -
(n * m - i);
}
}
cout << ans.x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
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;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e15;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(n), b(m);
set<int> flag1, flag2;
rep(i, n) {
cin >> a[i];
flag1.insert(a[i]);
}
rep(i, m) {
cin >> b[i];
flag2.insert(b[i]);
}
if (flag1.size() != n || flag2.size() != m) {
cout << 0 << endl;
return 0;
}
sort(begin(a), end(a));
sort(begin(b), end(b));
mint ans = 1;
for (int i = n * m; i >= 1; i--) {
bool f1 = flag1.count(i), f2 = flag2.count(i);
if (f1 && f2)
continue;
else if (f1 && !f2) {
ans *= end(b) - upper_bound(begin(b), end(b), i);
} else if (!f1 && f2) {
ans *= end(a) - upper_bound(begin(a), end(a), i);
} else {
ans *= (end(b) - upper_bound(begin(b), end(b), i)) *
(end(a) - upper_bound(begin(a), end(a), i)) -
(n * m - i);
}
}
cout << ans.x << endl;
}
|
replace
| 144 | 145 | 144 | 145 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <vector>
long long mod = 1e9 + 7;
class Mint {
public:
long long x;
Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
Mint(long long a) {
x = a % mod;
while (x < 0) {
x += mod;
}
};
Mint &operator+=(const Mint &a) {
x += a.x;
x %= mod;
return *this;
}
Mint &operator-=(const Mint &a) {
x += (mod - a.x);
x %= mod;
return *this;
}
Mint &operator*=(const Mint &a) {
x *= a.x;
x %= mod;
return *this;
}
// a^n mod を計算する
// Useaeg: Mint z = y.pow(y, n);
Mint pow(Mint a, long long n) const {
Mint y(1);
Mint b(a);
while (n > 0) {
if (n & 1)
y *= b;
b *= b;
n >>= 1;
}
return y;
}
// a^{-1} mod を計算する
Mint modinv(const Mint &a) const { return pow(a, mod - 2); }
Mint &operator/=(const Mint &a) {
x *= modinv(a).x;
x %= mod;
return *this;
}
Mint operator+(Mint &a) const {
Mint y(*this);
y += a;
return y;
}
Mint operator-(Mint &a) const {
Mint y(*this);
y -= a;
return y;
}
Mint operator*(Mint &a) const {
Mint y(*this);
y *= a;
return y;
}
Mint operator/(Mint &a) const {
Mint y(*this);
y /= a;
return y.x;
}
// nCk @mod を計算する
Mint nCk(Mint &n, const long long k) const {
Mint y = Mint(1);
for (Mint i(0); (i.x) < k; i.x++) {
y *= (n - i);
y /= i;
}
return y;
}
// nPk @mod を計算する
Mint nPk(Mint &n, long long k) const {
Mint y(1);
for (Mint i(0); (i.x) < k; i.x++) {
y *= (n - i);
}
return y;
}
};
int main() {
int N, M;
std::cin >> N >> M;
std::vector<int> A(N), B(M);
std::vector<bool> existA(N + 4, false);
std::vector<bool> existB(M + 4, false);
bool ok = true;
for (int i = 0; i < N; i++) {
std::cin >> A[i];
if (existA[A[i]]) {
ok = false;
}
existA[A[i]] = true;
}
for (int i = 0; i < M; i++) {
std::cin >> B[i];
if (existB[B[i]]) {
ok = false;
}
existB[B[i]] = true;
}
if (!ok) {
printf("0\n");
return 0;
}
int afound = 0, bfound = 0;
Mint ans(1);
for (int i = N * M; i > 0; i--) {
// printf("i=%d\n", i);
if (existA[i] && existB[i]) {
afound++;
bfound++;
} else if (existA[i]) {
afound++;
ans *= Mint(bfound);
} else if (existB[i]) {
bfound++;
ans *= Mint(afound);
} else {
int amari = afound * bfound - (N * M - i);
if (amari <= 0) {
printf("0\n");
return 0;
}
ans *= Mint(amari);
}
// printf("ans=%lld\n", ans.x);
}
std::cout << ans.x << std::endl;
return 0;
}
|
#include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <vector>
long long mod = 1e9 + 7;
class Mint {
public:
long long x;
Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
Mint(long long a) {
x = a % mod;
while (x < 0) {
x += mod;
}
};
Mint &operator+=(const Mint &a) {
x += a.x;
x %= mod;
return *this;
}
Mint &operator-=(const Mint &a) {
x += (mod - a.x);
x %= mod;
return *this;
}
Mint &operator*=(const Mint &a) {
x *= a.x;
x %= mod;
return *this;
}
// a^n mod を計算する
// Useaeg: Mint z = y.pow(y, n);
Mint pow(Mint a, long long n) const {
Mint y(1);
Mint b(a);
while (n > 0) {
if (n & 1)
y *= b;
b *= b;
n >>= 1;
}
return y;
}
// a^{-1} mod を計算する
Mint modinv(const Mint &a) const { return pow(a, mod - 2); }
Mint &operator/=(const Mint &a) {
x *= modinv(a).x;
x %= mod;
return *this;
}
Mint operator+(Mint &a) const {
Mint y(*this);
y += a;
return y;
}
Mint operator-(Mint &a) const {
Mint y(*this);
y -= a;
return y;
}
Mint operator*(Mint &a) const {
Mint y(*this);
y *= a;
return y;
}
Mint operator/(Mint &a) const {
Mint y(*this);
y /= a;
return y.x;
}
// nCk @mod を計算する
Mint nCk(Mint &n, const long long k) const {
Mint y = Mint(1);
for (Mint i(0); (i.x) < k; i.x++) {
y *= (n - i);
y /= i;
}
return y;
}
// nPk @mod を計算する
Mint nPk(Mint &n, long long k) const {
Mint y(1);
for (Mint i(0); (i.x) < k; i.x++) {
y *= (n - i);
}
return y;
}
};
int main() {
int N, M;
std::cin >> N >> M;
std::vector<int> A(N), B(M);
std::vector<bool> existA(N * M + 4, false);
std::vector<bool> existB(N * M + 4, false);
bool ok = true;
for (int i = 0; i < N; i++) {
std::cin >> A[i];
if (existA[A[i]]) {
ok = false;
}
existA[A[i]] = true;
}
for (int i = 0; i < M; i++) {
std::cin >> B[i];
if (existB[B[i]]) {
ok = false;
}
existB[B[i]] = true;
}
if (!ok) {
printf("0\n");
return 0;
}
int afound = 0, bfound = 0;
Mint ans(1);
for (int i = N * M; i > 0; i--) {
// printf("i=%d\n", i);
if (existA[i] && existB[i]) {
afound++;
bfound++;
} else if (existA[i]) {
afound++;
ans *= Mint(bfound);
} else if (existB[i]) {
bfound++;
ans *= Mint(afound);
} else {
int amari = afound * bfound - (N * M - i);
if (amari <= 0) {
printf("0\n");
return 0;
}
ans *= Mint(amari);
}
// printf("ans=%lld\n", ans.x);
}
std::cout << ans.x << std::endl;
return 0;
}
|
replace
| 113 | 115 | 113 | 115 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 10, mod = 1e9 + 7;
int r[N], c[N];
long long ans = 1, sr, sc, cnt;
int main() {
int n, m;
cin >> n >> m;
memset(r, -1, sizeof(r));
memset(c, -1, sizeof(c));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
if (r[x] != -1) {
cout << 0;
return 0;
}
r[x] = i;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
x--;
if (c[x] != -1) {
cout << 0;
return 0;
}
c[x] = i;
}
for (int i = n * m - 1; i >= 0; i--) {
if (r[i] >= 0 && c[i] >= 0) {
cnt++, sr++, sc++;
continue;
}
if (r[i] == -1 && c[i] == -1) {
// cout << "rc : i = " << i<< " : " << ans << " : :
//";
if (sr * sc - cnt <= 0) {
cout << 0;
return 0;
}
ans = (ans * (sr * sc - cnt)) % mod;
// cout << ans << endl;
cnt++;
continue;
}
if (r[i] == -1) {
if (!sc) {
cout << 0;
return 0;
}
// cout << "r : i = " << i << " : " << ans << " : :
//";
ans = ans * sc % mod;
// cout << ans << endl;
cnt++, sr++;
continue;
}
if (c[i] == -1) {
if (!sr) {
cout << 0;
return 0;
}
// cout << "c : i = " << i << " : " << ans << " : :
//";
ans = ans * sr % mod;
// cout << ans << endl;
cnt++, sc++;
continue;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 10, mod = 1e9 + 7;
int r[N], c[N];
long long ans = 1, sr, sc, cnt;
int main() {
int n, m;
cin >> n >> m;
memset(r, -1, sizeof(r));
memset(c, -1, sizeof(c));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
if (r[x] != -1) {
cout << 0;
return 0;
}
r[x] = i;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
x--;
if (c[x] != -1) {
cout << 0;
return 0;
}
c[x] = i;
}
for (int i = n * m - 1; i >= 0; i--) {
if (r[i] >= 0 && c[i] >= 0) {
cnt++, sr++, sc++;
continue;
}
if (r[i] == -1 && c[i] == -1) {
// cout << "rc : i = " << i<< " : " << ans << " : :
//";
if (sr * sc - cnt <= 0) {
cout << 0;
return 0;
}
ans = (ans * (sr * sc - cnt)) % mod;
// cout << ans << endl;
cnt++;
continue;
}
if (r[i] == -1) {
if (!sc) {
cout << 0;
return 0;
}
// cout << "r : i = " << i << " : " << ans << " : :
//";
ans = ans * sc % mod;
// cout << ans << endl;
cnt++, sr++;
continue;
}
if (c[i] == -1) {
if (!sr) {
cout << 0;
return 0;
}
// cout << "c : i = " << i << " : " << ans << " : :
//";
ans = ans * sr % mod;
// cout << ans << endl;
cnt++, sc++;
continue;
}
}
cout << ans;
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <math.h>
#include <algorithm>
#include <vector>
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
using namespace std;
#define MOD 1000000007
int main(int argc, char *argv[]) {
long n, m;
scanf("%ld %ld", &n, &m);
vector<long> a(n);
vector<long> b(n);
vector<ll> d(n);
long i;
for (i = 0; i < n; i++) {
scanf("%ld", &(a[i]));
}
for (i = 0; i < m; i++) {
scanf("%ld", &(b[i]));
}
sort(a.begin(), a.end());
for (i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
printf("0\n");
return 0;
}
}
sort(b.begin(), b.end());
for (i = 0; i < m - 1; i++) {
if (b[i] == b[i + 1]) {
printf("0\n");
return 0;
}
}
ll ans = 1;
for (i = n * m; i >= 1; i--) {
auto ita = lower_bound(a.begin(), a.end(), i);
auto itb = lower_bound(b.begin(), b.end(), i);
if ((*ita) == i && (*itb) == i) {
;
} else if ((*ita) == i) {
ans = ans * (b.end() - itb) % MOD;
} else if ((*itb) == i) {
ans = ans * (a.end() - ita) % MOD;
} else {
ans = ans * ((a.end() - ita) * (b.end() - itb) - (n * m - i)) % MOD;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <math.h>
#include <algorithm>
#include <vector>
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
using namespace std;
#define MOD 1000000007
int main(int argc, char *argv[]) {
long n, m;
scanf("%ld %ld", &n, &m);
vector<long> a(n);
vector<long> b(m);
long i;
for (i = 0; i < n; i++) {
scanf("%ld", &(a[i]));
}
for (i = 0; i < m; i++) {
scanf("%ld", &(b[i]));
}
sort(a.begin(), a.end());
for (i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
printf("0\n");
return 0;
}
}
sort(b.begin(), b.end());
for (i = 0; i < m - 1; i++) {
if (b[i] == b[i + 1]) {
printf("0\n");
return 0;
}
}
ll ans = 1;
for (i = n * m; i >= 1; i--) {
auto ita = lower_bound(a.begin(), a.end(), i);
auto itb = lower_bound(b.begin(), b.end(), i);
if ((*ita) == i && (*itb) == i) {
;
} else if ((*ita) == i) {
ans = ans * (b.end() - itb) % MOD;
} else if ((*itb) == i) {
ans = ans * (a.end() - ita) % MOD;
} else {
ans = ans * ((a.end() - ita) * (b.end() - itb) - (n * m - i)) % MOD;
}
}
printf("%lld\n", ans);
return 0;
}
|
replace
| 20 | 22 | 20 | 21 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int main() {
const Int MOD = 1e9 + 7;
int N, M;
cin >> N >> M;
vector<int> a(N), b(M);
vector<Int> cnt_a(100010, 0), cnt_b(100010, 0);
bool ok = true;
for (int i = 0; i < N; ++i) {
cin >> a[i];
++cnt_a[a[i]];
if (cnt_a[a[i]] > 1) {
ok = false;
}
}
for (int i = 0; i < M; ++i) {
cin >> b[i];
++cnt_b[b[i]];
if (cnt_b[b[i]] > 1) {
ok = false;
}
}
if (!ok) {
cout << 0 << endl;
return 0;
}
Int ans = 1;
for (int i = N * M; i > 0; --i) {
if (cnt_a[i] == 0 && cnt_b[i] == 0) {
Int tmp = cnt_a[i + 1] * cnt_b[i + 1] % MOD;
tmp = (tmp + MOD - (N * M - i)) % MOD;
(ans *= tmp) %= MOD;
} else if (cnt_a[i] != 1 || cnt_b[i] != 1) {
if (cnt_a[i] > 0) {
(ans *= cnt_b[i + 1]) %= MOD;
} else {
(ans *= cnt_a[i + 1]) %= MOD;
}
}
cnt_a[i] += cnt_a[i + 1];
cnt_b[i] += cnt_b[i + 1];
}
cout << ans % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int main() {
const Int MOD = 1e9 + 7;
int N, M;
cin >> N >> M;
vector<int> a(N), b(M);
vector<Int> cnt_a(1000010, 0), cnt_b(1000010, 0);
bool ok = true;
for (int i = 0; i < N; ++i) {
cin >> a[i];
++cnt_a[a[i]];
if (cnt_a[a[i]] > 1) {
ok = false;
}
}
for (int i = 0; i < M; ++i) {
cin >> b[i];
++cnt_b[b[i]];
if (cnt_b[b[i]] > 1) {
ok = false;
}
}
if (!ok) {
cout << 0 << endl;
return 0;
}
Int ans = 1;
for (int i = N * M; i > 0; --i) {
if (cnt_a[i] == 0 && cnt_b[i] == 0) {
Int tmp = cnt_a[i + 1] * cnt_b[i + 1] % MOD;
tmp = (tmp + MOD - (N * M - i)) % MOD;
(ans *= tmp) %= MOD;
} else if (cnt_a[i] != 1 || cnt_b[i] != 1) {
if (cnt_a[i] > 0) {
(ans *= cnt_b[i + 1]) %= MOD;
} else {
(ans *= cnt_a[i + 1]) %= MOD;
}
}
cnt_a[i] += cnt_a[i + 1];
cnt_b[i] += cnt_b[i + 1];
}
cout << ans % MOD << endl;
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p03152
|
C++
|
Runtime Error
|
#ifdef __LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define itn int
#define fi first
#define se second
#define intmax numeric_limits<int>::max()
#define llmax numeric_limits<ll>::max()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; i--)
#define all(vec) vec.begin(), vec.end()
#define sortt(vec) sort((vec).begin(), (vec).end())
#define rsort(vec) sort((vec).rbegin(), (vec).rend())
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef tuple<ll, ll, ll> tlll;
typedef tuple<int, int, int> tiii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
const ll lnf = 1ll << 60;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint cani[1010];
mint canj[1010];
mint scan[1000010];
int main() {
itn n, m;
cin >> n >> m;
rep(i, n) {
itn a;
cin >> a;
a--;
cani[a] += 1;
if (cani[a].x > 1) {
cout << 0 << endl;
return 0;
}
}
rep(i, m) {
itn b;
cin >> b;
b--;
canj[b] += 1;
if (canj[b].x > 1) {
cout << 0 << endl;
return 0;
}
}
vector<mint> scani(n * m);
scani[n * m - 1] = cani[n * m - 1];
for (int i = n * m - 1; i > 0; i--)
scani[i - 1] = scani[i] + cani[i - 1];
vector<mint> scanj(n * m);
scanj[n * m - 1] = canj[n * m - 1];
for (int i = n * m - 1; i > 0; i--)
scanj[i - 1] = scanj[i] + canj[i - 1];
mint ans = 1;
rrep(i, n * m) {
if (cani[i].x > 0 && canj[i].x > 0)
scan[i] = cani[i] * canj[i];
else if (cani[i].x > 0)
scan[i] = cani[i] * scanj[i];
else if (canj[i].x > 0)
scan[i] = scani[i] * canj[i];
else
scan[i] = scani[i] * scanj[i] - (n * m - 1 - i);
}
rrep(i, n * m) ans = ans * scan[i];
cout << ans << endl;
}
|
#ifdef __LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#define itn int
#define fi first
#define se second
#define intmax numeric_limits<int>::max()
#define llmax numeric_limits<ll>::max()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; i--)
#define all(vec) vec.begin(), vec.end()
#define sortt(vec) sort((vec).begin(), (vec).end())
#define rsort(vec) sort((vec).rbegin(), (vec).rend())
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef tuple<ll, ll, ll> tlll;
typedef tuple<int, int, int> tiii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
const ll lnf = 1ll << 60;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint cani[1000010];
mint canj[1000010];
mint scan[1000010];
int main() {
itn n, m;
cin >> n >> m;
rep(i, n) {
itn a;
cin >> a;
a--;
cani[a] += 1;
if (cani[a].x > 1) {
cout << 0 << endl;
return 0;
}
}
rep(i, m) {
itn b;
cin >> b;
b--;
canj[b] += 1;
if (canj[b].x > 1) {
cout << 0 << endl;
return 0;
}
}
vector<mint> scani(n * m);
scani[n * m - 1] = cani[n * m - 1];
for (int i = n * m - 1; i > 0; i--)
scani[i - 1] = scani[i] + cani[i - 1];
vector<mint> scanj(n * m);
scanj[n * m - 1] = canj[n * m - 1];
for (int i = n * m - 1; i > 0; i--)
scanj[i - 1] = scanj[i] + canj[i - 1];
mint ans = 1;
rrep(i, n * m) {
if (cani[i].x > 0 && canj[i].x > 0)
scan[i] = cani[i] * canj[i];
else if (cani[i].x > 0)
scan[i] = cani[i] * scanj[i];
else if (canj[i].x > 0)
scan[i] = scani[i] * canj[i];
else
scan[i] = scani[i] * scanj[i] - (n * m - 1 - i);
}
rrep(i, n * m) ans = ans * scan[i];
cout << ans << endl;
}
|
replace
| 80 | 82 | 80 | 82 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++)
cin >> B[i];
sort(A.begin(), A.end());
sort(B.begin(), B.end());
for (int i = 1; i < N; i++)
if (A[i] == A[i - 1]) {
puts("0");
return 0;
}
for (int i = 1; i < M; i++)
if (B[i] == B[i - 1]) {
puts("0");
return 0;
}
int mod = 1e9 + 7;
ll ans = 1;
for (int i = N * M; i >= 1; i--) {
if (binary_search(A.begin(), A.end(), i) &&
binary_search(B.begin(), B.end(), i))
continue;
else if (binary_search(A.begin(), A.end(), i)) {
ans = (ans * (B.end() - lower_bound(B.begin(), B.end(), i))) % mod;
} else if (binary_search(B.begin(), B.end(), i)) {
ans = (ans * (A.end() - lower_bound(A.begin(), A.end(), i))) % mod;
} else {
int h = A.end() - lower_bound(A.begin(), A.end(), i);
int w = B.end() - lower_bound(B.begin(), B.end(), i);
ans = (ans * (h * w - (N * M - i))) % mod;
}
if (ans == 0)
break;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++)
cin >> B[i];
sort(A.begin(), A.end());
sort(B.begin(), B.end());
for (int i = 1; i < N; i++)
if (A[i] == A[i - 1]) {
puts("0");
return 0;
}
for (int i = 1; i < M; i++)
if (B[i] == B[i - 1]) {
puts("0");
return 0;
}
int mod = 1e9 + 7;
ll ans = 1;
for (int i = N * M; i >= 1; i--) {
if (binary_search(A.begin(), A.end(), i) &&
binary_search(B.begin(), B.end(), i))
continue;
else if (binary_search(A.begin(), A.end(), i)) {
ans = (ans * (B.end() - lower_bound(B.begin(), B.end(), i))) % mod;
} else if (binary_search(B.begin(), B.end(), i)) {
ans = (ans * (A.end() - lower_bound(A.begin(), A.end(), i))) % mod;
} else {
int h = A.end() - lower_bound(A.begin(), A.end(), i);
int w = B.end() - lower_bound(B.begin(), B.end(), i);
ans = (ans * (h * w - (N * M - i))) % mod;
}
if (ans == 0)
break;
}
cout << ans << endl;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char> T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1)
cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
#define ALL(qpqpq) (qpqpq).begin(), (qpqpq).end()
#define UNIQUE(wpwpw) \
sort(ALL((wpwpw))); \
(wpwpw).erase(unique(ALL((wpwpw))), (wpwpw).end())
#define LOWER(epepe) transform(ALL((epepe)), (epepe).begin(), TL<char>)
#define UPPER(rprpr) transform(ALL((rprpr)), (rprpr).begin(), TU<char>)
#define FOR(i, tptpt, ypypy) for (LL i = (tptpt); i < (ypypy); i++)
#define REP(i, upupu) FOR(i, 0, upupu)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
int n, m;
bool a[1010], b[1010];
int aa, bb;
const int mod = 1e9 + 7;
int pa, pb;
int main() {
INIT;
cin >> n >> m;
REP(i, n) {
cin >> aa;
a[aa] = 1;
}
REP(i, m) {
cin >> bb;
b[bb] = 1;
}
LL ans = 1;
for (int i = n * m; i >= 1; i--) {
if (!a[i] && !b[i]) {
(ans *= pa * pb - (n * m - i)) %= mod;
} else {
if (a[i])
pa++;
if (b[i])
pb++;
if (a[i] && b[i])
continue;
else if (a[i])
(ans *= pb) %= mod;
else if (b[i])
(ans *= pa) %= mod;
}
}
cout << ans << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char> T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1)
cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
#define ALL(qpqpq) (qpqpq).begin(), (qpqpq).end()
#define UNIQUE(wpwpw) \
sort(ALL((wpwpw))); \
(wpwpw).erase(unique(ALL((wpwpw))), (wpwpw).end())
#define LOWER(epepe) transform(ALL((epepe)), (epepe).begin(), TL<char>)
#define UPPER(rprpr) transform(ALL((rprpr)), (rprpr).begin(), TU<char>)
#define FOR(i, tptpt, ypypy) for (LL i = (tptpt); i < (ypypy); i++)
#define REP(i, upupu) FOR(i, 0, upupu)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
int n, m;
bool a[1010101], b[1010101];
int aa, bb;
const int mod = 1e9 + 7;
int pa, pb;
int main() {
INIT;
cin >> n >> m;
REP(i, n) {
cin >> aa;
a[aa] = 1;
}
REP(i, m) {
cin >> bb;
b[bb] = 1;
}
LL ans = 1;
for (int i = n * m; i >= 1; i--) {
if (!a[i] && !b[i]) {
(ans *= pa * pb - (n * m - i)) %= mod;
} else {
if (a[i])
pa++;
if (b[i])
pb++;
if (a[i] && b[i])
continue;
else if (a[i])
(ans *= pb) %= mod;
else if (b[i])
(ans *= pa) %= mod;
}
}
cout << ans << endl;
}
|
replace
| 58 | 59 | 58 | 59 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(a, n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<vector<ll>> Graph;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1e9;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
// combination mod prime
// mintが必要
// https://www.youtube.com/watch?v=8uowVvQ_-Mo&feature=youtu.be&t=1619
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
bool a[1010];
bool b[1010];
int main() {
int n, m;
cin >> n >> m;
rep(i, n) {
int A;
cin >> A;
a[A] = true;
}
rep(i, m) {
int B;
cin >> B;
b[B] = true;
}
int v_cnt = 0;
int p_cnt = 0;
mint ans = 1;
int M = n * m;
for (int i = M; i >= 1; i--) {
int u = M - i;
if (a[i] && b[i]) {
v_cnt++;
p_cnt++;
} else if (a[i]) {
ans *= p_cnt;
v_cnt++;
} else if (b[i]) {
ans *= v_cnt;
p_cnt++;
} else {
ans *= (v_cnt * p_cnt - u);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(a, n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<vector<ll>> Graph;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1e9;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
// combination mod prime
// mintが必要
// https://www.youtube.com/watch?v=8uowVvQ_-Mo&feature=youtu.be&t=1619
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
bool a[1000010];
bool b[1000010];
int main() {
int n, m;
cin >> n >> m;
rep(i, n) {
int A;
cin >> A;
a[A] = true;
}
rep(i, m) {
int B;
cin >> B;
b[B] = true;
}
int v_cnt = 0;
int p_cnt = 0;
mint ans = 1;
int M = n * m;
for (int i = M; i >= 1; i--) {
int u = M - i;
if (a[i] && b[i]) {
v_cnt++;
p_cnt++;
} else if (a[i]) {
ans *= p_cnt;
v_cnt++;
} else if (b[i]) {
ans *= v_cnt;
p_cnt++;
} else {
ans *= (v_cnt * p_cnt - u);
}
}
cout << ans << endl;
return 0;
}
|
replace
| 88 | 90 | 88 | 90 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, sa[1010], sb[1010];
long long ans = 1;
bool a[1000010], b[1000010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (a[x]) {
puts("0");
return 0;
}
a[x] = 1;
}
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
if (b[x]) {
puts("0");
return 0;
}
b[x] = 1;
}
for (int i = n * m; i > 0; i--) {
sa[i] = sa[i + 1] + a[i];
sb[i] = sb[i + 1] + b[i];
}
for (int i = 1; i <= n * m; i++) {
if (a[i] && b[i])
continue;
else if (a[i]) {
ans = ans * sb[i] % mod;
} else if (b[i]) {
ans = ans * sa[i] % mod;
} else {
ans = ans * ((sa[i] * sb[i] - n * m + i) % mod) % mod;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, sa[1000010], sb[1000010];
long long ans = 1;
bool a[1000010], b[1000010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (a[x]) {
puts("0");
return 0;
}
a[x] = 1;
}
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
if (b[x]) {
puts("0");
return 0;
}
b[x] = 1;
}
for (int i = n * m; i > 0; i--) {
sa[i] = sa[i + 1] + a[i];
sb[i] = sb[i + 1] + b[i];
}
for (int i = 1; i <= n * m; i++) {
if (a[i] && b[i])
continue;
else if (a[i]) {
ans = ans * sb[i] % mod;
} else if (b[i]) {
ans = ans * sa[i] % mod;
} else {
ans = ans * ((sa[i] * sb[i] - n * m + i) % mod) % mod;
}
}
printf("%lld\n", ans);
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p03152
|
Python
|
Runtime Error
|
import bisect
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
A.sort()
B.sort()
if len(set(A)) != N or len(set(B)) != M:
print(0)
quit()
ans = 1
mod = 10**9 + 7
for i in reversed(range(1, N * M + 1)):
ai = bisect.bisect_left(A, i)
bi = bisect.bisect_left(B, i)
a_flag = A[ai] == i
b_flag = B[bi] == i
if a_flag and b_flag:
pass
elif a_flag:
cand = M - bi
ans = (ans * cand) % mod
elif b_flag:
cand = N - ai
ans = (ans * cand) % mod
else:
cand = (N - ai) * (M - bi) - (N * M - i)
if cand <= 0:
print(0)
quit()
ans = (ans * cand) % mod
print(ans)
|
import bisect
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
A.sort()
B.sort()
if len(set(A)) != N or len(set(B)) != M:
print(0)
quit()
if A[-1] != N * M or B[-1] != N * M:
print(0)
quit()
ans = 1
mod = 10**9 + 7
for i in reversed(range(1, N * M + 1)):
ai = bisect.bisect_left(A, i)
bi = bisect.bisect_left(B, i)
a_flag = A[ai] == i
b_flag = B[bi] == i
if a_flag and b_flag:
pass
elif a_flag:
cand = M - bi
ans = (ans * cand) % mod
elif b_flag:
cand = N - ai
ans = (ans * cand) % mod
else:
cand = (N - ai) * (M - bi) - (N * M - i)
if cand <= 0:
print(0)
quit()
ans = (ans * cand) % mod
print(ans)
|
insert
| 8 | 8 | 8 | 11 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e3 + 10;
const LL MOD = 1e9 + 7;
int n, m, px[N], py[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (px[x]) {
puts("0");
return 0;
}
px[x] = 1;
}
for (int j = 1; j <= m; j++) {
int y;
scanf("%d", &y);
if (py[y]) {
puts("0");
return 0;
}
py[y] = 1;
}
LL ans = 1, usedN = 0, usedM = 0;
for (LL i = n * m; i; i--) {
if (px[i] && py[i]) {
usedN++;
usedM++;
continue;
}
if (px[i]) {
usedN++;
ans = (ans * usedM) % MOD;
}
if (py[i]) {
usedM++;
ans = (ans * usedN) % MOD;
}
if (!px[i] && !py[i])
ans = (ans * (usedN * usedM - (n * m - i))) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e3 + 10;
const LL MOD = 1e9 + 7;
int n, m, px[N * N], py[N * N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (px[x]) {
puts("0");
return 0;
}
px[x] = 1;
}
for (int j = 1; j <= m; j++) {
int y;
scanf("%d", &y);
if (py[y]) {
puts("0");
return 0;
}
py[y] = 1;
}
LL ans = 1, usedN = 0, usedM = 0;
for (LL i = n * m; i; i--) {
if (px[i] && py[i]) {
usedN++;
usedM++;
continue;
}
if (px[i]) {
usedN++;
ans = (ans * usedM) % MOD;
}
if (py[i]) {
usedM++;
ans = (ans * usedN) % MOD;
}
if (!px[i] && !py[i])
ans = (ans * (usedN * usedM - (n * m - i))) % MOD;
}
cout << ans;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
using lint = long long;
constexpr int MOD = 1000000007, INF = 1010101010;
constexpr lint LINF = 1LL << 60;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (const auto &e : vec)
os << e << (&e == &vec.back() ? "\n" : " ");
return os;
}
#ifdef _DEBUG
template <class T> void dump(const char *str, T &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + (*(str + 1) == ' ' ? 2 : 1), t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <int Modulo = MOD> struct Mint {
lint val;
constexpr Mint(lint v = 0) noexcept : val(v % Modulo) {
if (val < 0)
val += Modulo;
}
constexpr Mint &operator+=(const Mint &r) noexcept {
val += r.val;
if (val >= Modulo)
val -= Modulo;
return *this;
}
constexpr Mint &operator-=(const Mint &r) noexcept {
val -= r.val;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint &operator*=(const Mint &r) noexcept {
val = val * r.val % Modulo;
return *this;
}
constexpr Mint &operator/=(const Mint &r) noexcept {
lint a = r.val, b = Modulo, u = 1, v = 0;
while (b) {
lint t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % Modulo;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint operator+(const Mint &r) const noexcept {
return Mint(*this) += r;
}
constexpr Mint operator-(const Mint &r) const noexcept {
return Mint(*this) -= r;
}
constexpr Mint operator*(const Mint &r) const noexcept {
return Mint(*this) *= r;
}
constexpr Mint operator/(const Mint &r) const noexcept {
return Mint(*this) /= r;
}
constexpr int getmod() { return Modulo; }
constexpr Mint operator-() const noexcept { return val ? Modulo - val : 0; }
constexpr bool operator==(const Mint &r) const noexcept {
return val == r.val;
}
constexpr bool operator!=(const Mint &r) const noexcept {
return val != r.val;
}
friend ostream &operator<<(ostream &os, const Mint<Modulo> &x) noexcept {
return os << x.val;
}
friend istream &operator>>(istream &is, Mint<Modulo> &x) noexcept {
lint tmp;
is >> tmp;
x = Mint<Modulo>(tmp);
return is;
}
friend constexpr Mint<Modulo> modpow(const Mint<Modulo> &a, lint n) noexcept {
Mint res(1), tmp = a;
while (n > 0) {
if (n & 1)
res *= tmp;
tmp *= tmp;
n >>= 1;
}
return res;
}
};
using mint = Mint<>;
class Factorial {
private:
vector<lint> fac, inv, finv;
void build(int N) {
fac[0] = fac[1] = 1;
inv[1] = 1;
finv[0] = finv[1] = 1;
for (int i = 2; i < N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
public:
Factorial(int N = 110000) : fac(N + 1), inv(N + 1), finv(N + 1) {
build(N + 1);
}
lint operator()(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint Pmod(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * finv[n - k] % MOD;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> A(N), B(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++)
cin >> B[i];
sort(A.begin(), A.end());
sort(B.begin(), B.end());
mint ans = 1;
for (int i = 0; i < N - 1; i++)
if (A[i + 1] == A[i])
ans = 0;
for (int i = 0; i < M - 1; i++)
if (B[i + 1] == B[i])
ans = 0;
Factorial Fac(100000);
int row = 0, col = 0;
int cnt = 0, prev = 0;
while (row < N && col < M) {
if (A[row] < B[col]) {
cnt += A[row] - prev - 1;
prev = A[row];
ans *= M - col;
ans *= Fac.Pmod(cnt, M - col - 1);
cnt -= M - col - 1;
row++;
} else if (A[row] > B[col]) {
cnt += B[col] - prev - 1;
prev = B[col];
ans *= N - row;
ans *= Fac.Pmod(cnt, N - row - 1);
cnt -= N - row - 1;
col++;
} else {
cnt += A[row] - prev - 1;
prev = A[row];
ans *= Fac.Pmod(cnt, N + M - (row + col) - 2);
cnt -= N + M - (row + col) - 2;
row++, col++;
}
}
cout << ans << "\n";
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
using lint = long long;
constexpr int MOD = 1000000007, INF = 1010101010;
constexpr lint LINF = 1LL << 60;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (const auto &e : vec)
os << e << (&e == &vec.back() ? "\n" : " ");
return os;
}
#ifdef _DEBUG
template <class T> void dump(const char *str, T &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + (*(str + 1) == ' ' ? 2 : 1), t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <int Modulo = MOD> struct Mint {
lint val;
constexpr Mint(lint v = 0) noexcept : val(v % Modulo) {
if (val < 0)
val += Modulo;
}
constexpr Mint &operator+=(const Mint &r) noexcept {
val += r.val;
if (val >= Modulo)
val -= Modulo;
return *this;
}
constexpr Mint &operator-=(const Mint &r) noexcept {
val -= r.val;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint &operator*=(const Mint &r) noexcept {
val = val * r.val % Modulo;
return *this;
}
constexpr Mint &operator/=(const Mint &r) noexcept {
lint a = r.val, b = Modulo, u = 1, v = 0;
while (b) {
lint t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % Modulo;
if (val < 0)
val += Modulo;
return *this;
}
constexpr Mint operator+(const Mint &r) const noexcept {
return Mint(*this) += r;
}
constexpr Mint operator-(const Mint &r) const noexcept {
return Mint(*this) -= r;
}
constexpr Mint operator*(const Mint &r) const noexcept {
return Mint(*this) *= r;
}
constexpr Mint operator/(const Mint &r) const noexcept {
return Mint(*this) /= r;
}
constexpr int getmod() { return Modulo; }
constexpr Mint operator-() const noexcept { return val ? Modulo - val : 0; }
constexpr bool operator==(const Mint &r) const noexcept {
return val == r.val;
}
constexpr bool operator!=(const Mint &r) const noexcept {
return val != r.val;
}
friend ostream &operator<<(ostream &os, const Mint<Modulo> &x) noexcept {
return os << x.val;
}
friend istream &operator>>(istream &is, Mint<Modulo> &x) noexcept {
lint tmp;
is >> tmp;
x = Mint<Modulo>(tmp);
return is;
}
friend constexpr Mint<Modulo> modpow(const Mint<Modulo> &a, lint n) noexcept {
Mint res(1), tmp = a;
while (n > 0) {
if (n & 1)
res *= tmp;
tmp *= tmp;
n >>= 1;
}
return res;
}
};
using mint = Mint<>;
class Factorial {
private:
vector<lint> fac, inv, finv;
void build(int N) {
fac[0] = fac[1] = 1;
inv[1] = 1;
finv[0] = finv[1] = 1;
for (int i = 2; i < N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
public:
Factorial(int N = 110000) : fac(N + 1), inv(N + 1), finv(N + 1) {
build(N + 1);
}
lint operator()(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint Pmod(int n, int k) {
if (n < k || k < 0)
return 0LL;
return fac[n] * finv[n - k] % MOD;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> A(N), B(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++)
cin >> B[i];
sort(A.begin(), A.end());
sort(B.begin(), B.end());
mint ans = 1;
for (int i = 0; i < N - 1; i++)
if (A[i + 1] == A[i])
ans = 0;
for (int i = 0; i < M - 1; i++)
if (B[i + 1] == B[i])
ans = 0;
Factorial Fac(1000000);
int row = 0, col = 0;
int cnt = 0, prev = 0;
while (row < N && col < M) {
if (A[row] < B[col]) {
cnt += A[row] - prev - 1;
prev = A[row];
ans *= M - col;
ans *= Fac.Pmod(cnt, M - col - 1);
cnt -= M - col - 1;
row++;
} else if (A[row] > B[col]) {
cnt += B[col] - prev - 1;
prev = B[col];
ans *= N - row;
ans *= Fac.Pmod(cnt, N - row - 1);
cnt -= N - row - 1;
col++;
} else {
cnt += A[row] - prev - 1;
prev = A[row];
ans *= Fac.Pmod(cnt, N + M - (row + col) - 2);
cnt -= N + M - (row + col) - 2;
row++, col++;
}
}
cout << ans << "\n";
return 0;
}
|
replace
| 182 | 183 | 182 | 183 |
0
| |
p03152
|
Python
|
Runtime Error
|
from bisect import bisect_left
MOD = 10**9 + 7
N, M = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
la = len(a)
sa = set(a)
lsa = len(sa)
if la != lsa:
print(0)
exit()
b = list(map(int, input().split()))
b = sorted(b)
lb = len(b)
sb = set(b)
lsb = len(sb)
if lb != lsb:
print(0)
exit()
ans = 1
ai = 0
bi = 0
k = N * M
d = 0
while k > 0:
ai = bisect_left(a, k)
bi = bisect_left(b, k)
if a[ai] == k:
ta = 1
if b[bi] == k:
tb = 1
t = ta * tb
else:
tb = lb - bi
t = ta * tb
else:
ta = la - ai
if b[bi] == k:
tb = 1
t = ta * tb
else:
tb = lb - bi
t = ta * tb - d
# print(ta, tb)
ans *= t
ans %= MOD
# print(ans)
k -= 1
d += 1
print(ans)
|
from bisect import bisect_left
MOD = 10**9 + 7
N, M = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
la = len(a)
sa = set(a)
lsa = len(sa)
if la != lsa:
print(0)
exit()
b = list(map(int, input().split()))
b = sorted(b)
lb = len(b)
sb = set(b)
lsb = len(sb)
if lb != lsb:
print(0)
exit()
ans = 1
ai = 0
bi = 0
k = N * M
d = 0
while k > 0:
ai = bisect_left(a, k)
bi = bisect_left(b, k)
if ai == la or bi == lb:
print(0)
exit()
if a[ai] == k:
ta = 1
if b[bi] == k:
tb = 1
t = ta * tb
else:
tb = lb - bi
t = ta * tb
else:
ta = la - ai
if b[bi] == k:
tb = 1
t = ta * tb
else:
tb = lb - bi
t = ta * tb - d
# print(ta, tb)
ans *= t
ans %= MOD
# print(ans)
k -= 1
d += 1
print(ans)
|
insert
| 33 | 33 | 33 | 37 |
0
| |
p03152
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int M = 1e3 + 4;
const int MD = 1e9 + 7;
int a[M], b[M], c[M], d[M], cnt = 0, cnt1 = 0;
ll ans = 1;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[i] = x;
c[x]++;
if (c[x] > 1) {
cout << "0";
return 0;
}
}
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
b[i] = x;
d[x]++;
if (d[x] > 1) {
cout << "0";
return 0;
}
}
for (int i = n * m; i >= 1; i--) {
if (c[i] && d[i])
continue;
else if (c[i]) {
cnt = 0;
for (int j = 1; j <= m; j++) {
if (b[j] > i)
cnt++;
}
ans = (ans * cnt) % MD;
} else if (d[i]) {
cnt = 0;
for (int j = 1; j <= n; j++) {
if (a[j] > i)
cnt++;
}
ans = (ans * cnt) % MD;
} else {
cnt = cnt1 = 0;
for (int j = 1; j <= n; j++) {
if (a[j] > i)
cnt++;
}
for (int j = 1; j <= m; j++) {
if (b[j] > i)
cnt1++;
}
ll tp = cnt * cnt1 - (n * m - i);
ans = (ans * tp) % MD;
}
// cout<<ans<<" ";
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int M = 1e3 + 4;
const int MD = 1e9 + 7;
int a[M], b[M], c[M * M], d[M * M], cnt = 0, cnt1 = 0;
ll ans = 1;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[i] = x;
c[x]++;
if (c[x] > 1) {
cout << "0";
return 0;
}
}
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
b[i] = x;
d[x]++;
if (d[x] > 1) {
cout << "0";
return 0;
}
}
for (int i = n * m; i >= 1; i--) {
if (c[i] && d[i])
continue;
else if (c[i]) {
cnt = 0;
for (int j = 1; j <= m; j++) {
if (b[j] > i)
cnt++;
}
ans = (ans * cnt) % MD;
} else if (d[i]) {
cnt = 0;
for (int j = 1; j <= n; j++) {
if (a[j] > i)
cnt++;
}
ans = (ans * cnt) % MD;
} else {
cnt = cnt1 = 0;
for (int j = 1; j <= n; j++) {
if (a[j] > i)
cnt++;
}
for (int j = 1; j <= m; j++) {
if (b[j] > i)
cnt1++;
}
ll tp = cnt * cnt1 - (n * m - i);
ans = (ans * tp) % MD;
}
// cout<<ans<<" ";
}
cout << ans;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p03152
|
Python
|
Runtime Error
|
from collections import Counter
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
A_cnt = Counter(A)
B_cnt = Counter(B)
if len(A) > 0:
if max(A_cnt.values()) > 1:
print(0)
exit()
if len(B) > 0:
if max(B_cnt.values()) > 1:
print(0)
exit()
if A[N - 1] != N * M and B[M - 1] != N * M:
print(0)
exit()
a = 0
b = 0
i = 1
C = [0] * (N * M)
while i <= N * M:
if i == A[a] and i == B[b]:
C[i - 1] = 1
a += 1
b += 1
elif i == A[a] and i != B[b]:
C[i - 1] = M - b
a += 1
elif i != A[a] and i == B[b]:
C[i - 1] = N - a
b += 1
else:
C[i - 1] = (N - a) * (M - b) - (N * M - i)
i += 1
ans = 1
mod = 10**9 + 7
for c in C:
ans = (ans * c) % mod
print(ans)
|
from collections import Counter
N, M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
A_cnt = Counter(A)
B_cnt = Counter(B)
if len(A) > 0:
if max(A_cnt.values()) > 1:
print(0)
exit()
if len(B) > 0:
if max(B_cnt.values()) > 1:
print(0)
exit()
if A[N - 1] != N * M or B[M - 1] != N * M:
print(0)
exit()
a = 0
b = 0
i = 1
C = [0] * (N * M)
while i <= N * M:
if i == A[a] and i == B[b]:
C[i - 1] = 1
a += 1
b += 1
elif i == A[a] and i != B[b]:
C[i - 1] = M - b
a += 1
elif i != A[a] and i == B[b]:
C[i - 1] = N - a
b += 1
else:
C[i - 1] = (N - a) * (M - b) - (N * M - i)
i += 1
ans = 1
mod = 10**9 + 7
for c in C:
ans = (ans * c) % mod
print(ans)
|
replace
| 20 | 21 | 20 | 21 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
#define F first
#define S second
#define RE register
#define random(x) (rand() % x)
#define LOG(a, b) (log(a) / log(b))
#define N 100005
#define mod 998244353
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3fll
int n;
ll d, a[N], ans = 0, dpl[N], dpr[N];
int main() {
scanf("%d%lld", &n, &d);
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
ans += a[i];
}
ans += d * (n - 1);
dpl[1] = a[1];
for (int i = 2; i <= n; ++i)
dpl[i] = min(dpl[i - 1] + d, a[i]);
dpr[n] = a[n];
for (int i = n - 1; i; --i)
dpr[i] = min(dpr[i + 1] + d, a[i]);
for (int i = 2; i < n; ++i)
ans += min(dpl[i], dpr[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;
#define F first
#define S second
#define RE register
#define random(x) (rand() % x)
#define LOG(a, b) (log(a) / log(b))
#define N 200005
#define mod 998244353
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3fll
int n;
ll d, a[N], ans = 0, dpl[N], dpr[N];
int main() {
scanf("%d%lld", &n, &d);
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
ans += a[i];
}
ans += d * (n - 1);
dpl[1] = a[1];
for (int i = 2; i <= n; ++i)
dpl[i] = min(dpl[i - 1] + d, a[i]);
dpr[n] = a[n];
for (int i = n - 1; i; --i)
dpr[i] = min(dpr[i + 1] + d, a[i]);
for (int i = 2; i < n; ++i)
ans += min(dpl[i], dpr[i]);
printf("%lld\n", ans);
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
int n, tot, d, a[N], f[N];
struct node {
int u, v;
node(int u = 0, int v = 0, ll w = 0) : u(u), v(v), w(w) {}
ll w;
bool operator<(const node &o) const { return w < o.w; }
} e[N * 10];
void solve(int l, int r) {
if (l == r)
return;
int m = l + r >> 1;
ll p1 = l, p2 = m + 1, s = 1e18;
for (ll i = l; i <= m; i++)
if (-i * d + a[i] < s)
s = -i * d + a[i], p1 = i;
s = 1e18;
for (ll i = m + 1; i <= r; i++)
if (i * d + a[i] < s)
s = i * d + a[i], p2 = i;
for (ll i = l; i <= m; i++) {
tot++;
e[tot] = node(i, p2, -i * d + a[i] + p2 * d + a[p2]);
}
for (ll i = m + 1; i <= r; i++) {
tot++;
e[tot] = node(p1, i, -p1 * d + a[p1] + i * d + a[i]);
}
solve(l, m);
solve(m + 1, r);
}
int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
solve(1, n);
sort(e + 1, e + 1 + tot);
for (int i = 1; i <= n; i++)
f[i] = i;
ll ans = 0;
for (int i = 1; i <= tot; i++) {
int fu = getf(e[i].u), fv = getf(e[i].v);
if (fu == fv)
continue;
ans += e[i].w;
f[fu] = fv;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
int n, tot, d, a[N], f[N];
struct node {
int u, v;
node(int u = 0, int v = 0, ll w = 0) : u(u), v(v), w(w) {}
ll w;
bool operator<(const node &o) const { return w < o.w; }
} e[N * 20];
void solve(int l, int r) {
if (l == r)
return;
int m = l + r >> 1;
ll p1 = l, p2 = m + 1, s = 1e18;
for (ll i = l; i <= m; i++)
if (-i * d + a[i] < s)
s = -i * d + a[i], p1 = i;
s = 1e18;
for (ll i = m + 1; i <= r; i++)
if (i * d + a[i] < s)
s = i * d + a[i], p2 = i;
for (ll i = l; i <= m; i++) {
tot++;
e[tot] = node(i, p2, -i * d + a[i] + p2 * d + a[p2]);
}
for (ll i = m + 1; i <= r; i++) {
tot++;
e[tot] = node(p1, i, -p1 * d + a[p1] + i * d + a[i]);
}
solve(l, m);
solve(m + 1, r);
}
int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
solve(1, n);
sort(e + 1, e + 1 + tot);
for (int i = 1; i <= n; i++)
f[i] = i;
ll ans = 0;
for (int i = 1; i <= tot; i++) {
int fu = getf(e[i].u), fv = getf(e[i].v);
if (fu == fv)
continue;
ans += e[i].w;
f[fu] = fv;
}
printf("%lld\n", ans);
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define MP make_pair
#define PB push_back
#define PH push
#define fst first
#define snd second
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;
const int maxn = 1e5 + 5;
const ll INF = 1e18;
int n;
ll d, ans;
ll a[maxn], tmp[maxn];
vector<int> vs[maxn];
class SegmentTree {
private:
static const int siz = 262144;
pair<ll, int> dat[siz << 1];
public:
inline int size() { return siz; }
inline void build(int x, int l, int r) {
if (l == r) {
if (l < n)
dat[x] = MP(tmp[l], l);
else
dat[x] = MP(INF, -1);
return;
}
int md = l + r >> 1;
build(x << 1, l, md);
build(x << 1 | 1, md + 1, r);
dat[x] = min(dat[x << 1], dat[x << 1 | 1]);
return;
}
inline void update(int x, int l, int r, int y, ll k) {
if (l == r) {
dat[x].fst = k;
return;
}
int md = l + r >> 1;
if (y <= md)
update(x << 1, l, md, y, k);
else
update(x << 1 | 1, md + 1, r, y, k);
dat[x] = min(dat[x << 1], dat[x << 1 | 1]);
}
inline pair<ll, int> query(int x, int l, int r, int s, int t) {
if (l >= s && r <= t) {
return dat[x];
}
int md = l + r >> 1;
if (s > md)
return query(x << 1 | 1, md + 1, r, s, t);
if (t <= md)
return query(x << 1, l, md, s, t);
return min(query(x << 1, l, md, s, t), query(x << 1 | 1, md + 1, r, s, t));
}
} seg1, seg2;
class Dsu {
private:
int fa[maxn], sz[maxn];
public:
inline void init() {
FOR(i, 0, n) {
fa[i] = i;
sz[i] = 1;
}
return;
}
inline int find(int x) { return (x == fa[x] ? x : fa[x] = find(fa[x])); }
inline int size(int x) { return sz[find(x)]; }
inline bool combine(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (sz[x] < sz[y])
swap(x, y);
FOR(i, 0, vs[y].size())
vs[x].PB(vs[y][i]);
sz[x] += sz[y];
fa[y] = x;
return true;
}
} dsu;
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) { scanf("%lld", a + i); }
FOR(i, 0, n)
tmp[i] = -i * d + a[i];
seg1.build(1, 0, seg1.size() - 1);
FOR(i, 0, n)
tmp[i] = i * d + a[i];
seg2.build(1, 0, seg2.size() - 1);
dsu.init();
FOR(i, 0, n)
vs[i].PB(i);
while (dsu.size(0) != n) {
vector<pair<pii, ll>> ed;
FOR(u, 0, n) if (dsu.find(u) == u) {
pii e;
ll mn = INF;
FOR(i, 0, vs[u].size()) {
int v = vs[u][i];
seg1.update(1, 0, seg1.size() - 1, v, INF);
seg2.update(1, 0, seg2.size() - 1, v, INF);
}
FOR(i, 0, vs[u].size()) {
int v = vs[u][i];
pair<ll, int> res1 = seg1.query(1, 0, seg1.size() - 1, 0, v);
pair<ll, int> res2 = seg2.query(1, 0, seg2.size() - 1, v, n - 1);
if (res1.fst + v * d + a[v] < mn) {
e = MP(v, res1.snd);
mn = res1.fst + v * d + a[v];
}
if (res2.fst - v * d + a[v] < mn) {
e = MP(v, res2.snd);
mn = res2.fst - v * d + a[v];
}
}
if (mn != INF) {
ed.PB(MP(e, mn));
}
FOR(i, 0, vs[u].size()) {
int v = vs[u][i];
seg1.update(1, 0, seg1.size() - 1, v, -v * d + a[v]);
seg2.update(1, 0, seg2.size() - 1, v, v * d + a[v]);
}
}
FOR(i, 0, ed.size())
ans += (dsu.combine(ed[i].fst.fst, ed[i].fst.snd)) * ed[i].snd;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define MP make_pair
#define PB push_back
#define PH push
#define fst first
#define snd second
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;
const int maxn = 2e5 + 5;
const ll INF = 1e18;
int n;
ll d, ans;
ll a[maxn], tmp[maxn];
vector<int> vs[maxn];
class SegmentTree {
private:
static const int siz = 262144;
pair<ll, int> dat[siz << 1];
public:
inline int size() { return siz; }
inline void build(int x, int l, int r) {
if (l == r) {
if (l < n)
dat[x] = MP(tmp[l], l);
else
dat[x] = MP(INF, -1);
return;
}
int md = l + r >> 1;
build(x << 1, l, md);
build(x << 1 | 1, md + 1, r);
dat[x] = min(dat[x << 1], dat[x << 1 | 1]);
return;
}
inline void update(int x, int l, int r, int y, ll k) {
if (l == r) {
dat[x].fst = k;
return;
}
int md = l + r >> 1;
if (y <= md)
update(x << 1, l, md, y, k);
else
update(x << 1 | 1, md + 1, r, y, k);
dat[x] = min(dat[x << 1], dat[x << 1 | 1]);
}
inline pair<ll, int> query(int x, int l, int r, int s, int t) {
if (l >= s && r <= t) {
return dat[x];
}
int md = l + r >> 1;
if (s > md)
return query(x << 1 | 1, md + 1, r, s, t);
if (t <= md)
return query(x << 1, l, md, s, t);
return min(query(x << 1, l, md, s, t), query(x << 1 | 1, md + 1, r, s, t));
}
} seg1, seg2;
class Dsu {
private:
int fa[maxn], sz[maxn];
public:
inline void init() {
FOR(i, 0, n) {
fa[i] = i;
sz[i] = 1;
}
return;
}
inline int find(int x) { return (x == fa[x] ? x : fa[x] = find(fa[x])); }
inline int size(int x) { return sz[find(x)]; }
inline bool combine(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (sz[x] < sz[y])
swap(x, y);
FOR(i, 0, vs[y].size())
vs[x].PB(vs[y][i]);
sz[x] += sz[y];
fa[y] = x;
return true;
}
} dsu;
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) { scanf("%lld", a + i); }
FOR(i, 0, n)
tmp[i] = -i * d + a[i];
seg1.build(1, 0, seg1.size() - 1);
FOR(i, 0, n)
tmp[i] = i * d + a[i];
seg2.build(1, 0, seg2.size() - 1);
dsu.init();
FOR(i, 0, n)
vs[i].PB(i);
while (dsu.size(0) != n) {
vector<pair<pii, ll>> ed;
FOR(u, 0, n) if (dsu.find(u) == u) {
pii e;
ll mn = INF;
FOR(i, 0, vs[u].size()) {
int v = vs[u][i];
seg1.update(1, 0, seg1.size() - 1, v, INF);
seg2.update(1, 0, seg2.size() - 1, v, INF);
}
FOR(i, 0, vs[u].size()) {
int v = vs[u][i];
pair<ll, int> res1 = seg1.query(1, 0, seg1.size() - 1, 0, v);
pair<ll, int> res2 = seg2.query(1, 0, seg2.size() - 1, v, n - 1);
if (res1.fst + v * d + a[v] < mn) {
e = MP(v, res1.snd);
mn = res1.fst + v * d + a[v];
}
if (res2.fst - v * d + a[v] < mn) {
e = MP(v, res2.snd);
mn = res2.fst - v * d + a[v];
}
}
if (mn != INF) {
ed.PB(MP(e, mn));
}
FOR(i, 0, vs[u].size()) {
int v = vs[u][i];
seg1.update(1, 0, seg1.size() - 1, v, -v * d + a[v]);
seg2.update(1, 0, seg2.size() - 1, v, v * d + a[v]);
}
}
FOR(i, 0, ed.size())
ans += (dsu.combine(ed[i].fst.fst, ed[i].fst.snd)) * ed[i].snd;
}
printf("%lld\n", ans);
return 0;
}
|
replace
| 17 | 18 | 17 | 18 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
typedef long long llong;
constexpr int kMaxN = 1e5 + 10;
struct Edge {
int n1, n2;
llong cost;
};
int costa[kMaxN];
std::vector<Edge> edges;
Edge NewEdge(int n1, int n2, llong costd) {
Edge e;
e.n1 = n1;
e.n2 = n2;
e.cost = costd * std::abs(n1 - n2) + costa[n1] + costa[n2];
return e;
}
void MakeEdge(int low, int upp, llong costd) {
if (upp - low <= 1) {
return;
}
int mid = (low + upp) / 2;
MakeEdge(low, mid, costd);
MakeEdge(mid, upp, costd);
int min1i = -1;
llong min1 = 0;
for (int i = low; i < mid; ++i) {
llong v = costa[i] - i * (costd);
if (min1i == -1 || v < min1) {
min1 = v;
min1i = i;
}
}
int min2i = -1;
llong min2 = 0;
for (int i = mid; i < upp; ++i) {
llong v = costa[i] + i * (costd);
if (min2i == -1 || v < min2) {
min2 = v;
min2i = i;
}
}
for (int i = low; i < mid; ++i) {
edges.push_back(NewEdge(i, min2i, costd));
}
for (int i = mid; i < upp; ++i) {
edges.push_back(NewEdge(min1i, i, costd));
}
}
int union_set_id[kMaxN];
int UnionSetGetRoot(int i) {
if (i != union_set_id[i]) {
union_set_id[i] = UnionSetGetRoot(union_set_id[i]);
}
return union_set_id[i];
}
void UnionSetUnion(int a, int b) {
a = UnionSetGetRoot(a);
b = UnionSetGetRoot(b);
if (a != b) {
union_set_id[a] = b;
}
}
bool CompareEdge(Edge const &e1, Edge const &e2) { return e1.cost < e2.cost; }
int main() {
int n, d;
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++i) {
scanf("%d", costa + i);
union_set_id[i] = i;
}
MakeEdge(0, n, d);
// printf("edge count %zd\n", edges.size());
// for (auto const &edge : edges) {
// printf("edge(n1,n2,cost): %d %d %lld\n", edge.n1, edge.n2, edge.cost);
// }
std::sort(edges.begin(), edges.end(), CompareEdge);
llong total = 0;
int edge_count = 0;
for (auto const &edge : edges) {
if (UnionSetGetRoot(edge.n1) != UnionSetGetRoot(edge.n2)) {
total += edge.cost;
UnionSetUnion(edge.n1, edge.n2);
edge_count += 1;
}
if (edge_count == n - 1) {
break;
}
}
printf("%lld\n", total);
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
typedef long long llong;
constexpr int kMaxN = 2e5 + 10;
struct Edge {
int n1, n2;
llong cost;
};
int costa[kMaxN];
std::vector<Edge> edges;
Edge NewEdge(int n1, int n2, llong costd) {
Edge e;
e.n1 = n1;
e.n2 = n2;
e.cost = costd * std::abs(n1 - n2) + costa[n1] + costa[n2];
return e;
}
void MakeEdge(int low, int upp, llong costd) {
if (upp - low <= 1) {
return;
}
int mid = (low + upp) / 2;
MakeEdge(low, mid, costd);
MakeEdge(mid, upp, costd);
int min1i = -1;
llong min1 = 0;
for (int i = low; i < mid; ++i) {
llong v = costa[i] - i * (costd);
if (min1i == -1 || v < min1) {
min1 = v;
min1i = i;
}
}
int min2i = -1;
llong min2 = 0;
for (int i = mid; i < upp; ++i) {
llong v = costa[i] + i * (costd);
if (min2i == -1 || v < min2) {
min2 = v;
min2i = i;
}
}
for (int i = low; i < mid; ++i) {
edges.push_back(NewEdge(i, min2i, costd));
}
for (int i = mid; i < upp; ++i) {
edges.push_back(NewEdge(min1i, i, costd));
}
}
int union_set_id[kMaxN];
int UnionSetGetRoot(int i) {
if (i != union_set_id[i]) {
union_set_id[i] = UnionSetGetRoot(union_set_id[i]);
}
return union_set_id[i];
}
void UnionSetUnion(int a, int b) {
a = UnionSetGetRoot(a);
b = UnionSetGetRoot(b);
if (a != b) {
union_set_id[a] = b;
}
}
bool CompareEdge(Edge const &e1, Edge const &e2) { return e1.cost < e2.cost; }
int main() {
int n, d;
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++i) {
scanf("%d", costa + i);
union_set_id[i] = i;
}
MakeEdge(0, n, d);
// printf("edge count %zd\n", edges.size());
// for (auto const &edge : edges) {
// printf("edge(n1,n2,cost): %d %d %lld\n", edge.n1, edge.n2, edge.cost);
// }
std::sort(edges.begin(), edges.end(), CompareEdge);
llong total = 0;
int edge_count = 0;
for (auto const &edge : edges) {
if (UnionSetGetRoot(edge.n1) != UnionSetGetRoot(edge.n2)) {
total += edge.cost;
UnionSetUnion(edge.n1, edge.n2);
edge_count += 1;
}
if (edge_count == n - 1) {
break;
}
}
printf("%lld\n", total);
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define endl "\n"
#define rep(i, a, b) for (auto i = (a); i < (b); ++i)
#define rrep(i, a, b) for (auto i = (a); i > (b); --i)
#define UNIQUE(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef unsigned long long ull;
#ifdef LOCAL_DEFINE
struct InitInput {
InitInput() {
FILE *stream1;
stream1 = freopen("in.txt", "r", stdin);
assert(stream1 != nullptr);
cerr << "This problem is not interactive" << endl;
}
} LOCAL_INPUT;
struct LOCAL_OUTPUT {
LOCAL_OUTPUT() {
FILE *stream2;
const char *outputfile = "out.txt";
stream2 = freopen(outputfile, "w", stdout);
assert(stream2 != nullptr);
cerr << "output [ " << outputfile << " ]" << endl;
}
} /*LOCAL_OUTPUT*/;
#define show(x) \
cerr << #x << " = " << (x) << " (line " << __LINE__ << ")" << endl
#define showA(a, n) \
do { \
for (int i = 0; i < (n); i++) \
cerr << "(" << i << " = " << (a)[i] << ") "; \
cerr << endl; \
} while (0)
#define showA2(a, n, m) \
do { \
for (int i = 0; i < (n); i++) { \
for (int j = 0; j < (m); j++) { \
cerr << "(" << i << ", " << j << " = " << (a)[i][j] << ") "; \
} \
cerr << endl; \
} \
cerr << endl; \
} while (0)
#else
#define show(x)
#define showA(a, n)
#define showA2(a, n, m)
#endif
struct InitAim {
InitAim() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(12);
cout << fixed;
#ifdef LOCAL_DEFINE
cerr << "This problem is not interactive" << endl;
#endif
}
} aim_cpo;
///////////////////////////////////////////////////////////////////////////////////
// TEMPLATE(data structure)
///////////////////////////////////////////////////////////////////////////////////
template <typename T> bool chmin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <typename T> bool chmax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
template <typename T> void ln(T i, T n) { cout << (i == n - 1 ? "\n" : " "); }
template <typename T, typename S>
ostream &operator<<(ostream &out, const pair<T, S> &pair1) {
out << '(' << pair1.fi << ", " << pair1.se << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &vector1) {
out << '[';
for (unsigned int i = 0; i < vector1.size(); i++) {
out << vector1[i];
if (i == vector1.size() - 1)
out << "]";
else
out << ", ";
}
return out;
}
#define GCD(a, b) __gcd(a, b)
template <typename T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
template <typename T> T EXTGCD(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = EXTGCD(b, a % b, y, x);
y -= (a / b) * x;
} else
x = 1, y = 0;
return d;
}
template <typename T> bool is_prime(T a) {
for (int i = 2; i * i <= a; i++)
if (a % i == 0)
return true;
return false;
}
template <typename T, typename S> T Pow(T a, S b) {
T res = 1, now = a;
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
/* MOD */
ll MOD = 1000000000LL + 7LL;
class Mint {
public:
ll x;
Mint() : x(0) {}
Mint(const int x) {
if (x < MOD && x >= 0)
this->x = x;
else
this->x = (MOD + x % MOD) % MOD;
}
Mint(const ll x) {
if (x < MOD && x >= 0)
this->x = x;
else
this->x = (MOD + x % MOD) % MOD;
}
Mint(const Mint &c) { this->x = c.x; }
Mint &operator=(const int c) {
if (c < MOD && c >= 0)
this->x = c;
else
this->x = (MOD + c % MOD) % MOD;
return *this;
}
Mint &operator=(const ll c) {
if (c < MOD && c >= 0)
this->x = c;
else
this->x = (MOD + c % MOD) % MOD;
return *this;
}
Mint &operator=(const Mint c) {
this->x = c.x;
return *this;
}
bool operator==(const Mint &b) { return x == b.x; }
bool operator!=(const Mint &b) { return !(x == b.x); }
bool operator<(const Mint &b) { return x < b.x; }
bool operator>(const Mint &b) { return x > b.x; }
};
ostream &operator<<(ostream &out, const Mint &mint) {
out << mint.x;
return out;
}
istream &operator>>(istream &in, const Mint &mint) {
in >> mint.x;
return in;
}
inline Mint add(const Mint a, const Mint b) {
const ll x = (a.x + b.x) % MOD;
return Mint(x);
}
inline Mint mul(const Mint a, const Mint b) {
ll x = (a.x * b.x) % MOD;
return Mint(x);
}
template <typename T> Mint ModPow(Mint a, T b) {
assert(b >= 0);
Mint res = 1;
while (b) {
if (b & 1)
res = mul(res, a);
b >>= 1;
a = mul(a, a);
}
return res;
}
inline Mint ModInverse(const Mint x) {
ll a = x.x, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
Mint res(u);
return res;
}
inline Mint operator-(const Mint x) { return Mint(-x.x); }
inline Mint operator+(const Mint a, const Mint b) { return add(a, b); }
inline Mint operator*(const Mint a, const Mint b) { return mul(a, b); }
inline Mint operator-(const Mint a, const Mint b) { return add(a, -b); }
template <typename T> inline Mint operator+(const Mint a, const T b) {
return add(a, Mint(b));
}
template <typename T> inline Mint operator*(const Mint a, const T b) {
return mul(a, Mint(b));
}
template <typename T> inline Mint operator-(const Mint a, const T b) {
return add(a, Mint(-b));
}
template <typename T> inline Mint operator/(const Mint a, const T b) {
return mul(a, ModInverse(Mint(b)));
}
template <typename T> inline Mint operator^(const Mint a, const T b) {
return ModPow(a, b);
}
template <typename T> inline Mint operator+=(Mint &a, const T b) {
a = a + b;
return a;
}
template <typename T> inline Mint operator-=(Mint &a, const T b) {
a = a - b;
return a;
}
template <typename T> inline Mint operator*=(Mint &a, const T b) {
a = a * b;
return a;
}
template <typename T> inline Mint operator/=(Mint &a, const T b) {
a = a / b;
return a;
}
template <typename T> T EulerTotient(T a) {
vector<pair<int, int>> v;
for (T i = 2; i * i <= a; i++) {
int cnt = 0;
while (a % i == 0) {
cnt++;
a /= i;
}
if (cnt != 0)
v.emplace_back(i, cnt);
}
if (a != 1)
v.emplace_back(a, 1);
// showV(v, (int) v.size());
T res = 1;
for (int i = 0; i < (int)v.size(); i++) {
if (v[i].se == 1) {
res *= v[i].fi - 1;
} else {
res *= Pow(v[i].fi, v[i].se) - Pow(v[i].fi, v[i].se - 1);
}
}
return res;
}
template <typename T, typename S> Mint comb(T a, S b) {
chmin(b, a - b);
Mint res = 1LL, now = a;
for (ll i = 1; i <= b; i++) {
res *= now;
res /= i;
now -= 1;
}
return res;
}
template <typename T> class BIT {
public:
BIT(int size) { BITTable.assign(++size, 0); }
T sum(int k) {
T res = 0;
for (++k; k > 0; k -= k & -k) {
res += BITTable[k];
}
return res;
}
T sum(int l, int r) {
if (l == 0)
return sum(r);
return sum(r) - sum(l - 1);
}
void update(int k, T x) { // b[k] += x;
for (++k; k < (int)BITTable.size(); k += k & -k)
BITTable[k] += x;
}
private:
vector<T> BITTable;
};
template <typename T> class IntervalTree {
using F = function<T(T, T)>;
public:
IntervalTree(int n, const F func, const T init) : func(func), init(init) {
size = 1;
while ((int)size < n)
size <<= 1;
table.assign(2 * size, init);
}
void set(int k, T &x) { table[size + k] = x; }
void build() {
for (int i = size - 1; i >= 0; --i) {
table[i] = func(table[i * 2], table[i * 2 + 1]);
}
}
void update(int k, const T &x) {
k += size;
table[k] = x;
while (k >>= 1) {
table[k] = func(table[k * 2], table[k * 2 + 1]);
}
}
T query(int a, int b) {
T L = init, R = init;
for (a += size, b += size; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = func(L, table[a++]);
if (b & 1)
R = func(table[--b], R);
}
return func(L, R);
}
T operator[](const int k) const { return table[k + size]; }
private:
unsigned int size;
vector<T> table;
const F func;
const T init;
};
class UnionFind {
public:
explicit UnionFind(int _n) : n(_n) {
par.resize(static_cast<unsigned long>(_n));
rank.resize(static_cast<unsigned long>(_n));
sizes.resize(static_cast<unsigned long>(_n));
for (int i = 0; i < _n; i++) {
par[i] = i;
rank[i] = 0;
sizes[i] = 1;
}
}
int find(int a) {
if (par[a] == a)
return a;
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
void unite(int a, int b) { link(find(a), find(b)); }
int size(int a) { return sizes[find(a)]; }
void view() {
for (int i = 0; i < n; i++) {
cout << " par"
<< "[" << i << "]=" << par[i] << ((i == n - 1) ? "\n" : ",");
}
for (int i = 0; i < n; i++) {
cout << "size"
<< "[" << i << "]=" << sizes[i] << ((i == n - 1) ? "\n" : ",");
}
cout << endl;
}
private:
void link(int a, int b) {
if (same(a, b))
return;
if (rank[a] > rank[b]) {
par[b] = a;
sizes[a] += sizes[b];
sizes[b] = 0;
} else {
par[a] = b;
if (rank[a] == rank[b])
rank[b]++;
sizes[b] += sizes[a];
sizes[a] = 0;
}
}
int n;
vector<int> par;
vector<int> rank;
vector<int> sizes;
};
template <typename T> class Dinic {
public:
Dinic(int SIZE) : SIZE(SIZE) {
v = vector<vector<tuple<int, T, int>>>(SIZE + 10);
}
void AddEdge(int from, int to, T cap) {
v[from].push_back(make_tuple(to, cap, v[to].size()));
v[to].push_back(make_tuple(from, 0, v[from].size() - 1));
}
void bfs(int s) {
level = vector<int>(SIZE + 10, -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < (int)v[now].size(); i++) {
int next, nextrv;
T nextc;
tie(next, nextc, nextrv) = v[now][i];
if (nextc > 0 && level[next] < 0) {
level[next] = level[now] + 1;
q.push(next);
}
}
}
}
T dfs(int now, int t, T f) {
if (now == t)
return f;
for (int &i = iter[now]; i < (int)v[now].size(); i++) {
int next, nextrv;
T nextc;
tie(next, nextc, nextrv) = v[now][i];
if (nextc > 0 && level[now] < level[next]) {
T d = dfs(next, t, min(f, nextc));
if (d > 0) {
get<1>(v[now][i]) -= d;
get<1>(v[next][nextrv]) += d;
return d;
}
}
}
return 0;
}
T max_flow(int s, int t) {
T flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
iter = vector<int>(SIZE + 10, 0);
int f;
while ((f = dfs(s, t, INT_MAX)) > 0) {
flow += f;
}
}
}
private:
int SIZE;
vector<vector<tuple<int, T, int>>> v;
vector<int> level, iter;
};
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(
(edge){to, cap, cost, (int)graph[to].size(), false});
graph[to].emplace_back(
(edge){from, 0, -cost, (int)graph[from].size() - 1, true});
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
template <typename T> using Matrix = vector<vector<T>>;
template <typename T> void init(int h, int w, Matrix<T> &matrix) {
matrix = vector<vector<T>>(h, vector<T>(w));
/*for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> matrix[i][j];
}
}*/
}
template <typename T>
Matrix<T> &operator*(Matrix<T> &matrix, Matrix<T> &matrix1) {
int height = (int)matrix.size();
int width = (int)matrix[0].size();
int height2 = (int)matrix1.size();
int width2 = (int)matrix1[0].size();
assert(width == height2);
Matrix<T> res;
res = vector<vector<T>>(height, vector<T>(width2, 0));
for (int i = 0; i < height; i++) {
for (int j = 0; j < width2; j++) {
for (int k = 0; k < width; k++) {
res[i][j] += matrix[i][k] * matrix1[k][j];
}
}
}
matrix.swap(res);
return matrix;
}
template <typename T> Matrix<T> Pow(Matrix<T> matrix, ll x) {
Matrix<T> res = vector<vector<T>>(matrix.size(), vector<T>(matrix.size(), 0));
for (int i = 0; i < (int)matrix.size(); i++) {
res[i][i] = 1;
}
while (x) {
if (x & 1) {
res = res * matrix;
}
matrix = matrix * matrix;
x >>= 1;
}
return res;
}
///////////////////////////////////////////////////////////////////////////////////
// MAIN
///////////////////////////////////////////////////////////////////////////////////
// 735134400 約数が1344個ある高度合成数(<= 1e9)
// 897612484786617600 約数が103680個ある高度合成数(<= 1e18)
// 苦手分野 重複順列
// LLの数値をつかう時は最後にLLをつける癖をつけよう
// Mintの数値にしたいときは、Mint(i)みたいにキャストしてね
int n;
ll d;
ll a[200001];
vector<tuple<int, int, ll>> v;
int main() {
cin >> n >> d;
rep(i, 0, n) cin >> a[i];
function<void(int, int)> rec = [&](int begin, int end) {
show(begin);
show(end);
if (end - begin <= 1)
return;
int mid = (begin + end) / 2;
ll leftmin = LLONG_MAX;
ll rightmin = LLONG_MAX;
int leftminid = -1, rightminid = -1;
rep(i, begin, mid) {
if (chmin(leftmin, -i * d + a[i]))
leftminid = i;
}
rep(i, mid, end) {
if (chmin(rightmin, i * d + a[i]))
rightminid = i;
}
rep(i, begin, mid) {
ll cost = (rightminid - i) * d + a[i] + a[rightminid];
v.pb(mt(cost, i, rightminid));
}
rep(i, mid, end) {
ll cost = (i - leftminid) * d + a[i] + a[leftminid];
v.pb(mt(cost, i, leftminid));
}
rec(begin, mid);
rec(mid, end);
};
rec(0, n);
UnionFind uf(n);
sort(all(v));
ll ans = 0;
rep(i, 0, (int)v.size()) {
ll cost;
int from, to;
tie(cost, from, to) = v[i];
assert(cost > 0);
if (uf.same(from, to))
continue;
ans += cost;
uf.unite(from, to);
}
cout << ans << endl;
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << "s." << endl;
show(MOD);
#endif
return 0;
}
///////////////////////////////////////////////////////////////////////////////////
// NOTE
///////////////////////////////////////////////////////////////////////////////////
/*
*/
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define endl "\n"
#define rep(i, a, b) for (auto i = (a); i < (b); ++i)
#define rrep(i, a, b) for (auto i = (a); i > (b); --i)
#define UNIQUE(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef unsigned long long ull;
#ifdef LOCAL_DEFINE
struct InitInput {
InitInput() {
FILE *stream1;
stream1 = freopen("in.txt", "r", stdin);
assert(stream1 != nullptr);
cerr << "This problem is not interactive" << endl;
}
} LOCAL_INPUT;
struct LOCAL_OUTPUT {
LOCAL_OUTPUT() {
FILE *stream2;
const char *outputfile = "out.txt";
stream2 = freopen(outputfile, "w", stdout);
assert(stream2 != nullptr);
cerr << "output [ " << outputfile << " ]" << endl;
}
} /*LOCAL_OUTPUT*/;
#define show(x) \
cerr << #x << " = " << (x) << " (line " << __LINE__ << ")" << endl
#define showA(a, n) \
do { \
for (int i = 0; i < (n); i++) \
cerr << "(" << i << " = " << (a)[i] << ") "; \
cerr << endl; \
} while (0)
#define showA2(a, n, m) \
do { \
for (int i = 0; i < (n); i++) { \
for (int j = 0; j < (m); j++) { \
cerr << "(" << i << ", " << j << " = " << (a)[i][j] << ") "; \
} \
cerr << endl; \
} \
cerr << endl; \
} while (0)
#else
#define show(x)
#define showA(a, n)
#define showA2(a, n, m)
#endif
struct InitAim {
InitAim() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(12);
cout << fixed;
#ifdef LOCAL_DEFINE
cerr << "This problem is not interactive" << endl;
#endif
}
} aim_cpo;
///////////////////////////////////////////////////////////////////////////////////
// TEMPLATE(data structure)
///////////////////////////////////////////////////////////////////////////////////
template <typename T> bool chmin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <typename T> bool chmax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
template <typename T> void ln(T i, T n) { cout << (i == n - 1 ? "\n" : " "); }
template <typename T, typename S>
ostream &operator<<(ostream &out, const pair<T, S> &pair1) {
out << '(' << pair1.fi << ", " << pair1.se << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &vector1) {
out << '[';
for (unsigned int i = 0; i < vector1.size(); i++) {
out << vector1[i];
if (i == vector1.size() - 1)
out << "]";
else
out << ", ";
}
return out;
}
#define GCD(a, b) __gcd(a, b)
template <typename T> T LCM(T a, T b) { return a / GCD(a, b) * b; }
template <typename T> T EXTGCD(T a, T b, T &x, T &y) {
T d = a;
if (b != 0) {
d = EXTGCD(b, a % b, y, x);
y -= (a / b) * x;
} else
x = 1, y = 0;
return d;
}
template <typename T> bool is_prime(T a) {
for (int i = 2; i * i <= a; i++)
if (a % i == 0)
return true;
return false;
}
template <typename T, typename S> T Pow(T a, S b) {
T res = 1, now = a;
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
/* MOD */
ll MOD = 1000000000LL + 7LL;
class Mint {
public:
ll x;
Mint() : x(0) {}
Mint(const int x) {
if (x < MOD && x >= 0)
this->x = x;
else
this->x = (MOD + x % MOD) % MOD;
}
Mint(const ll x) {
if (x < MOD && x >= 0)
this->x = x;
else
this->x = (MOD + x % MOD) % MOD;
}
Mint(const Mint &c) { this->x = c.x; }
Mint &operator=(const int c) {
if (c < MOD && c >= 0)
this->x = c;
else
this->x = (MOD + c % MOD) % MOD;
return *this;
}
Mint &operator=(const ll c) {
if (c < MOD && c >= 0)
this->x = c;
else
this->x = (MOD + c % MOD) % MOD;
return *this;
}
Mint &operator=(const Mint c) {
this->x = c.x;
return *this;
}
bool operator==(const Mint &b) { return x == b.x; }
bool operator!=(const Mint &b) { return !(x == b.x); }
bool operator<(const Mint &b) { return x < b.x; }
bool operator>(const Mint &b) { return x > b.x; }
};
ostream &operator<<(ostream &out, const Mint &mint) {
out << mint.x;
return out;
}
istream &operator>>(istream &in, const Mint &mint) {
in >> mint.x;
return in;
}
inline Mint add(const Mint a, const Mint b) {
const ll x = (a.x + b.x) % MOD;
return Mint(x);
}
inline Mint mul(const Mint a, const Mint b) {
ll x = (a.x * b.x) % MOD;
return Mint(x);
}
template <typename T> Mint ModPow(Mint a, T b) {
assert(b >= 0);
Mint res = 1;
while (b) {
if (b & 1)
res = mul(res, a);
b >>= 1;
a = mul(a, a);
}
return res;
}
inline Mint ModInverse(const Mint x) {
ll a = x.x, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
Mint res(u);
return res;
}
inline Mint operator-(const Mint x) { return Mint(-x.x); }
inline Mint operator+(const Mint a, const Mint b) { return add(a, b); }
inline Mint operator*(const Mint a, const Mint b) { return mul(a, b); }
inline Mint operator-(const Mint a, const Mint b) { return add(a, -b); }
template <typename T> inline Mint operator+(const Mint a, const T b) {
return add(a, Mint(b));
}
template <typename T> inline Mint operator*(const Mint a, const T b) {
return mul(a, Mint(b));
}
template <typename T> inline Mint operator-(const Mint a, const T b) {
return add(a, Mint(-b));
}
template <typename T> inline Mint operator/(const Mint a, const T b) {
return mul(a, ModInverse(Mint(b)));
}
template <typename T> inline Mint operator^(const Mint a, const T b) {
return ModPow(a, b);
}
template <typename T> inline Mint operator+=(Mint &a, const T b) {
a = a + b;
return a;
}
template <typename T> inline Mint operator-=(Mint &a, const T b) {
a = a - b;
return a;
}
template <typename T> inline Mint operator*=(Mint &a, const T b) {
a = a * b;
return a;
}
template <typename T> inline Mint operator/=(Mint &a, const T b) {
a = a / b;
return a;
}
template <typename T> T EulerTotient(T a) {
vector<pair<int, int>> v;
for (T i = 2; i * i <= a; i++) {
int cnt = 0;
while (a % i == 0) {
cnt++;
a /= i;
}
if (cnt != 0)
v.emplace_back(i, cnt);
}
if (a != 1)
v.emplace_back(a, 1);
// showV(v, (int) v.size());
T res = 1;
for (int i = 0; i < (int)v.size(); i++) {
if (v[i].se == 1) {
res *= v[i].fi - 1;
} else {
res *= Pow(v[i].fi, v[i].se) - Pow(v[i].fi, v[i].se - 1);
}
}
return res;
}
template <typename T, typename S> Mint comb(T a, S b) {
chmin(b, a - b);
Mint res = 1LL, now = a;
for (ll i = 1; i <= b; i++) {
res *= now;
res /= i;
now -= 1;
}
return res;
}
template <typename T> class BIT {
public:
BIT(int size) { BITTable.assign(++size, 0); }
T sum(int k) {
T res = 0;
for (++k; k > 0; k -= k & -k) {
res += BITTable[k];
}
return res;
}
T sum(int l, int r) {
if (l == 0)
return sum(r);
return sum(r) - sum(l - 1);
}
void update(int k, T x) { // b[k] += x;
for (++k; k < (int)BITTable.size(); k += k & -k)
BITTable[k] += x;
}
private:
vector<T> BITTable;
};
template <typename T> class IntervalTree {
using F = function<T(T, T)>;
public:
IntervalTree(int n, const F func, const T init) : func(func), init(init) {
size = 1;
while ((int)size < n)
size <<= 1;
table.assign(2 * size, init);
}
void set(int k, T &x) { table[size + k] = x; }
void build() {
for (int i = size - 1; i >= 0; --i) {
table[i] = func(table[i * 2], table[i * 2 + 1]);
}
}
void update(int k, const T &x) {
k += size;
table[k] = x;
while (k >>= 1) {
table[k] = func(table[k * 2], table[k * 2 + 1]);
}
}
T query(int a, int b) {
T L = init, R = init;
for (a += size, b += size; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = func(L, table[a++]);
if (b & 1)
R = func(table[--b], R);
}
return func(L, R);
}
T operator[](const int k) const { return table[k + size]; }
private:
unsigned int size;
vector<T> table;
const F func;
const T init;
};
class UnionFind {
public:
explicit UnionFind(int _n) : n(_n) {
par.resize(static_cast<unsigned long>(_n));
rank.resize(static_cast<unsigned long>(_n));
sizes.resize(static_cast<unsigned long>(_n));
for (int i = 0; i < _n; i++) {
par[i] = i;
rank[i] = 0;
sizes[i] = 1;
}
}
int find(int a) {
if (par[a] == a)
return a;
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
void unite(int a, int b) { link(find(a), find(b)); }
int size(int a) { return sizes[find(a)]; }
void view() {
for (int i = 0; i < n; i++) {
cout << " par"
<< "[" << i << "]=" << par[i] << ((i == n - 1) ? "\n" : ",");
}
for (int i = 0; i < n; i++) {
cout << "size"
<< "[" << i << "]=" << sizes[i] << ((i == n - 1) ? "\n" : ",");
}
cout << endl;
}
private:
void link(int a, int b) {
if (same(a, b))
return;
if (rank[a] > rank[b]) {
par[b] = a;
sizes[a] += sizes[b];
sizes[b] = 0;
} else {
par[a] = b;
if (rank[a] == rank[b])
rank[b]++;
sizes[b] += sizes[a];
sizes[a] = 0;
}
}
int n;
vector<int> par;
vector<int> rank;
vector<int> sizes;
};
template <typename T> class Dinic {
public:
Dinic(int SIZE) : SIZE(SIZE) {
v = vector<vector<tuple<int, T, int>>>(SIZE + 10);
}
void AddEdge(int from, int to, T cap) {
v[from].push_back(make_tuple(to, cap, v[to].size()));
v[to].push_back(make_tuple(from, 0, v[from].size() - 1));
}
void bfs(int s) {
level = vector<int>(SIZE + 10, -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < (int)v[now].size(); i++) {
int next, nextrv;
T nextc;
tie(next, nextc, nextrv) = v[now][i];
if (nextc > 0 && level[next] < 0) {
level[next] = level[now] + 1;
q.push(next);
}
}
}
}
T dfs(int now, int t, T f) {
if (now == t)
return f;
for (int &i = iter[now]; i < (int)v[now].size(); i++) {
int next, nextrv;
T nextc;
tie(next, nextc, nextrv) = v[now][i];
if (nextc > 0 && level[now] < level[next]) {
T d = dfs(next, t, min(f, nextc));
if (d > 0) {
get<1>(v[now][i]) -= d;
get<1>(v[next][nextrv]) += d;
return d;
}
}
}
return 0;
}
T max_flow(int s, int t) {
T flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
iter = vector<int>(SIZE + 10, 0);
int f;
while ((f = dfs(s, t, INT_MAX)) > 0) {
flow += f;
}
}
}
private:
int SIZE;
vector<vector<tuple<int, T, int>>> v;
vector<int> level, iter;
};
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(
(edge){to, cap, cost, (int)graph[to].size(), false});
graph[to].emplace_back(
(edge){from, 0, -cost, (int)graph[from].size() - 1, true});
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
template <typename T> using Matrix = vector<vector<T>>;
template <typename T> void init(int h, int w, Matrix<T> &matrix) {
matrix = vector<vector<T>>(h, vector<T>(w));
/*for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> matrix[i][j];
}
}*/
}
template <typename T>
Matrix<T> &operator*(Matrix<T> &matrix, Matrix<T> &matrix1) {
int height = (int)matrix.size();
int width = (int)matrix[0].size();
int height2 = (int)matrix1.size();
int width2 = (int)matrix1[0].size();
assert(width == height2);
Matrix<T> res;
res = vector<vector<T>>(height, vector<T>(width2, 0));
for (int i = 0; i < height; i++) {
for (int j = 0; j < width2; j++) {
for (int k = 0; k < width; k++) {
res[i][j] += matrix[i][k] * matrix1[k][j];
}
}
}
matrix.swap(res);
return matrix;
}
template <typename T> Matrix<T> Pow(Matrix<T> matrix, ll x) {
Matrix<T> res = vector<vector<T>>(matrix.size(), vector<T>(matrix.size(), 0));
for (int i = 0; i < (int)matrix.size(); i++) {
res[i][i] = 1;
}
while (x) {
if (x & 1) {
res = res * matrix;
}
matrix = matrix * matrix;
x >>= 1;
}
return res;
}
///////////////////////////////////////////////////////////////////////////////////
// MAIN
///////////////////////////////////////////////////////////////////////////////////
// 735134400 約数が1344個ある高度合成数(<= 1e9)
// 897612484786617600 約数が103680個ある高度合成数(<= 1e18)
// 苦手分野 重複順列
// LLの数値をつかう時は最後にLLをつける癖をつけよう
// Mintの数値にしたいときは、Mint(i)みたいにキャストしてね
int n;
ll d;
ll a[200001];
vector<tuple<ll, int, int>> v;
int main() {
cin >> n >> d;
rep(i, 0, n) cin >> a[i];
function<void(int, int)> rec = [&](int begin, int end) {
show(begin);
show(end);
if (end - begin <= 1)
return;
int mid = (begin + end) / 2;
ll leftmin = LLONG_MAX;
ll rightmin = LLONG_MAX;
int leftminid = -1, rightminid = -1;
rep(i, begin, mid) {
if (chmin(leftmin, -i * d + a[i]))
leftminid = i;
}
rep(i, mid, end) {
if (chmin(rightmin, i * d + a[i]))
rightminid = i;
}
rep(i, begin, mid) {
ll cost = (rightminid - i) * d + a[i] + a[rightminid];
v.pb(mt(cost, i, rightminid));
}
rep(i, mid, end) {
ll cost = (i - leftminid) * d + a[i] + a[leftminid];
v.pb(mt(cost, i, leftminid));
}
rec(begin, mid);
rec(mid, end);
};
rec(0, n);
UnionFind uf(n);
sort(all(v));
ll ans = 0;
rep(i, 0, (int)v.size()) {
ll cost;
int from, to;
tie(cost, from, to) = v[i];
assert(cost > 0);
if (uf.same(from, to))
continue;
ans += cost;
uf.unite(from, to);
}
cout << ans << endl;
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << "s." << endl;
show(MOD);
#endif
return 0;
}
///////////////////////////////////////////////////////////////////////////////////
// NOTE
///////////////////////////////////////////////////////////////////////////////////
/*
*/
|
replace
| 609 | 610 | 609 | 610 |
0
| |
p03153
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
const int N = 2e5 + 7;
int par[N];
int get(int v) {
if (v == par[v]) {
return v;
} else {
return par[v] = get(par[v]);
}
}
void uni(int u, int v) { par[get(u)] = get(v); }
const ll inf = 1e18 + 7;
int main() {
#ifdef ONPC
freopen("a.in", "r", stdin);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
int n, d;
cin >> n >> d;
vector<int> a(n);
vector<int> ind(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
ind[i] = i;
}
for (int i = 0; i < n; i++) {
par[i] = i;
}
int comp = n;
ll ans = 0;
while (comp > 1) {
vector<ll> best(n, inf);
vector<int> him(n, -1);
auto rlx = [&]() {
vector<pair<ll, int>> arr;
for (int i = 0; i < n; i++) {
int real_ind = ind[i];
ll value = -i * (ll)d + a[real_ind];
int who = get(real_ind);
arr.push_back({value, who});
sort(arr.begin(), arr.end());
vector<pair<ll, int>> now;
for (int i = 0; i < (int)arr.size(); i++) {
if (now.empty() || now.back().second != arr[i].second) {
now.push_back(arr[i]);
}
}
while (now.size() > 2)
now.pop_back();
for (auto c : now) {
if (c.second != who) {
ll relax_cur = i * (ll)d + a[real_ind] + c.first;
int relax_who = c.second;
if (relax_cur < best[who]) {
best[who] = relax_cur;
him[who] = relax_who;
}
}
}
}
};
rlx();
reverse(ind.begin(), ind.end());
rlx();
for (int i = 0; i < n; i++) {
if (get(i) == i) {
if (get(him[i]) != i) {
uni(him[i], i);
ans += best[i];
comp--;
}
}
}
}
cout << ans << '\n';
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
const int N = 2e5 + 7;
int par[N];
int get(int v) {
if (v == par[v]) {
return v;
} else {
return par[v] = get(par[v]);
}
}
void uni(int u, int v) { par[get(u)] = get(v); }
const ll inf = 1e18 + 7;
int main() {
#ifdef ONPC
freopen("a.in", "r", stdin);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
int n, d;
cin >> n >> d;
vector<int> a(n);
vector<int> ind(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
ind[i] = i;
}
for (int i = 0; i < n; i++) {
par[i] = i;
}
int comp = n;
ll ans = 0;
while (comp > 1) {
vector<ll> best(n, inf);
vector<int> him(n, -1);
auto rlx = [&]() {
vector<pair<ll, int>> arr;
for (int i = 0; i < n; i++) {
int real_ind = ind[i];
ll value = -i * (ll)d + a[real_ind];
int who = get(real_ind);
arr.push_back({value, who});
sort(arr.begin(), arr.end());
vector<pair<ll, int>> now;
for (int i = 0; i < (int)arr.size(); i++) {
if (now.empty() || now.back().second != arr[i].second) {
now.push_back(arr[i]);
}
}
while (now.size() > 2)
now.pop_back();
arr = now;
for (auto c : now) {
if (c.second != who) {
ll relax_cur = i * (ll)d + a[real_ind] + c.first;
int relax_who = c.second;
if (relax_cur < best[who]) {
best[who] = relax_cur;
him[who] = relax_who;
}
}
}
}
};
rlx();
reverse(ind.begin(), ind.end());
rlx();
for (int i = 0; i < n; i++) {
if (get(i) == i) {
if (get(him[i]) != i) {
uni(him[i], i);
ans += best[i];
comp--;
}
}
}
}
cout << ans << '\n';
}
|
insert
| 85 | 85 | 85 | 86 |
TLE
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define ref(i, x, y) for (int i = x; i <= y; ++i)
#define mp make_pair
#define fi first
#define se second
typedef long long LL;
typedef pair<LL, int> PII;
const int N = 100010;
const LL inf = 1e18;
int n, D, s[N];
struct node {
int x, y;
PII p;
LL s;
PII s1[2], s2[2];
} a[N * 5];
void pushup(int t) {
int l = t << 1, r = l | 1;
PII pp;
LL ss;
ref(d, 0, 1) a[t].s1[d] = min(a[l].s1[d], a[r].s1[d]);
ref(d, 0, 1) a[t].s2[d] = min(a[l].s2[d], a[r].s2[d]);
if (a[l].s < a[r].s)
a[t].p = a[l].p, a[t].s = a[l].s;
else
a[t].p = a[r].p, a[t].s = a[r].s;
pp = mp(a[l].s2[0].se, a[r].s1[1].se);
ss = a[l].s2[0].fi + a[r].s1[1].fi;
if (ss < a[t].s)
a[t].p = pp, a[t].s = ss;
pp = mp(a[r].s1[0].se, a[l].s2[1].se);
ss = a[l].s2[1].fi + a[r].s1[0].fi;
if (ss < a[t].s)
a[t].p = pp, a[t].s = ss;
}
void build(int x, int y, int t) {
a[t].x = x;
a[t].y = y;
if (x == y) {
a[t].p = mp(0, 0);
a[t].s = inf;
a[t].s1[0] = mp(s[x] + (LL)D * x, x);
a[t].s1[1] = mp(inf, 0);
a[t].s2[0] = mp(s[x] - (LL)D * x, x);
a[t].s2[1] = mp(inf, 0);
return;
}
int m = (x + y) >> 1;
build(x, m, t << 1);
build(m + 1, y, t << 1 | 1);
pushup(t);
}
void update(int x, int y, int t, int p) {
if (x == y) {
swap(a[t].s1[0], a[t].s1[1]);
swap(a[t].s2[0], a[t].s2[1]);
return;
}
int m = (x + y) >> 1;
if (p <= m)
update(x, m, t << 1, p);
else
update(m + 1, y, t << 1 | 1, p);
pushup(t);
}
int main() {
cin >> n >> D;
ref(i, 1, n) cin >> s[i];
build(1, n, 1);
update(1, n, 1, 1);
LL ans = 0;
ref(i, 1, n - 1) {
PII p = a[1].p;
LL s = a[1].s;
update(1, n, 1, p.fi);
ans += s;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ref(i, x, y) for (int i = x; i <= y; ++i)
#define mp make_pair
#define fi first
#define se second
typedef long long LL;
typedef pair<LL, int> PII;
const int N = 200010;
const LL inf = 1e18;
int n, D, s[N];
struct node {
int x, y;
PII p;
LL s;
PII s1[2], s2[2];
} a[N * 5];
void pushup(int t) {
int l = t << 1, r = l | 1;
PII pp;
LL ss;
ref(d, 0, 1) a[t].s1[d] = min(a[l].s1[d], a[r].s1[d]);
ref(d, 0, 1) a[t].s2[d] = min(a[l].s2[d], a[r].s2[d]);
if (a[l].s < a[r].s)
a[t].p = a[l].p, a[t].s = a[l].s;
else
a[t].p = a[r].p, a[t].s = a[r].s;
pp = mp(a[l].s2[0].se, a[r].s1[1].se);
ss = a[l].s2[0].fi + a[r].s1[1].fi;
if (ss < a[t].s)
a[t].p = pp, a[t].s = ss;
pp = mp(a[r].s1[0].se, a[l].s2[1].se);
ss = a[l].s2[1].fi + a[r].s1[0].fi;
if (ss < a[t].s)
a[t].p = pp, a[t].s = ss;
}
void build(int x, int y, int t) {
a[t].x = x;
a[t].y = y;
if (x == y) {
a[t].p = mp(0, 0);
a[t].s = inf;
a[t].s1[0] = mp(s[x] + (LL)D * x, x);
a[t].s1[1] = mp(inf, 0);
a[t].s2[0] = mp(s[x] - (LL)D * x, x);
a[t].s2[1] = mp(inf, 0);
return;
}
int m = (x + y) >> 1;
build(x, m, t << 1);
build(m + 1, y, t << 1 | 1);
pushup(t);
}
void update(int x, int y, int t, int p) {
if (x == y) {
swap(a[t].s1[0], a[t].s1[1]);
swap(a[t].s2[0], a[t].s2[1]);
return;
}
int m = (x + y) >> 1;
if (p <= m)
update(x, m, t << 1, p);
else
update(m + 1, y, t << 1 | 1, p);
pushup(t);
}
int main() {
cin >> n >> D;
ref(i, 1, n) cin >> s[i];
build(1, n, 1);
update(1, n, 1, 1);
LL ans = 0;
ref(i, 1, n - 1) {
PII p = a[1].p;
LL s = a[1].s;
update(1, n, 1, p.fi);
ans += s;
}
cout << ans << endl;
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T> struct Kruskal {
struct edge {
Int from, to;
T cost;
Int used;
edge() {}
edge(Int from, Int to, T cost) : from(from), to(to), cost(cost), used(0) {}
bool operator<(const edge &e) const { return cost < e.cost; }
};
Int n;
vector<Int> p, r;
vector<edge> edges;
Kruskal() {}
Kruskal(Int n) : n(n) {}
void init(Int n) {
r.assign(n, 1);
p.resize(n);
iota(p.begin(), p.end(), 0);
}
Int find(Int x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(Int x, Int y) { return find(x) == find(y); }
void unite(Int x, Int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y])
swap(x, y);
r[x] += r[y];
p[y] = x;
}
void add_edge(Int u, Int v, T c) { edges.emplace_back(u, v, c); }
T build() {
sort(edges.begin(), edges.end());
init(n);
T res = 0;
for (auto &e : edges) {
if (!same(e.from, e.to)) {
res += e.cost;
unite(e.from, e.to);
e.used = 1;
}
}
return res;
}
};
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
// INSERT ABOVE HERE
signed main() {
Int n, d;
cin >> n >> d;
vector<Int> a(n);
for (Int i = 0; i < n; i++)
cin >> a[i];
Kruskal<Int> ks(n);
using P = pair<Int, Int>;
const Int INF = 1e18;
vector<P> ls(n, P(INF, -1)), rs(n, P(INF, -1)), dp(n);
function<void(Int, Int)> dfs = [&](Int l, Int r) -> void {
if (l + 1 == r) {
dp[l] = P(a[l], l);
return;
}
Int m = (l + r) >> 1;
dfs(l, m);
dfs(m, r);
P x(INF, -1), y(INF, -1);
for (Int i = l, j = m; i < m || j < r;) {
if (j == r || dp[i].first <= dp[j].first) {
Int k = dp[i++].second;
chmin(rs[k], y);
chmin(x, P(a[k] - k * d, k));
} else {
Int k = dp[j++].second;
chmin(ls[k], x);
chmin(y, P(a[k] + k * d, k));
}
}
inplace_merge(dp.begin() + l, dp.begin() + m, dp.begin() + r);
};
dfs(0, n);
auto add_edge = [&](Int x, Int y) {
if (x < 0 || y < 0)
return;
Int c = abs(x - y) * d + a[x] + a[y];
ks.add_edge(x, y, c);
};
for (Int i = 0; i < n; i++)
add_edge(ls[i].second, i);
for (Int i = 0; i < n; i++)
add_edge(i, rs[i].second);
cout << ks.build() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T> struct Kruskal {
struct edge {
Int from, to;
T cost;
Int used;
edge() {}
edge(Int from, Int to, T cost) : from(from), to(to), cost(cost), used(0) {}
bool operator<(const edge &e) const { return cost < e.cost; }
};
Int n;
vector<Int> p, r;
vector<edge> edges;
Kruskal() {}
Kruskal(Int n) : n(n) {}
void init(Int n) {
r.assign(n, 1);
p.resize(n);
iota(p.begin(), p.end(), 0);
}
Int find(Int x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(Int x, Int y) { return find(x) == find(y); }
void unite(Int x, Int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y])
swap(x, y);
r[x] += r[y];
p[y] = x;
}
void add_edge(Int u, Int v, T c) { edges.emplace_back(u, v, c); }
T build() {
sort(edges.begin(), edges.end());
init(n);
T res = 0;
for (auto &e : edges) {
if (!same(e.from, e.to)) {
res += e.cost;
unite(e.from, e.to);
e.used = 1;
}
}
return res;
}
};
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
// INSERT ABOVE HERE
signed main() {
Int n, d;
cin >> n >> d;
vector<Int> a(n);
for (Int i = 0; i < n; i++)
cin >> a[i];
Kruskal<Int> ks(n);
using P = pair<Int, Int>;
const Int INF = 1e18;
vector<P> ls(n, P(INF, -1)), rs(n, P(INF, -1)), dp(n);
function<void(Int, Int)> dfs = [&](Int l, Int r) -> void {
if (l + 1 == r) {
dp[l] = P(a[l], l);
return;
}
Int m = (l + r) >> 1;
dfs(l, m);
dfs(m, r);
P x(INF, -1), y(INF, -1);
for (Int i = l, j = m; i < m || j < r;) {
if (i < m && (j == r || dp[i].first <= dp[j].first)) {
Int k = dp[i++].second;
chmin(rs[k], y);
chmin(x, P(a[k] - k * d, k));
} else {
Int k = dp[j++].second;
chmin(ls[k], x);
chmin(y, P(a[k] + k * d, k));
}
}
inplace_merge(dp.begin() + l, dp.begin() + m, dp.begin() + r);
};
dfs(0, n);
auto add_edge = [&](Int x, Int y) {
if (x < 0 || y < 0)
return;
Int c = abs(x - y) * d + a[x] + a[y];
ks.add_edge(x, y, c);
};
for (Int i = 0; i < n; i++)
add_edge(ls[i].second, i);
for (Int i = 0; i < n; i++)
add_edge(i, rs[i].second);
cout << ks.build() << endl;
return 0;
}
|
replace
| 97 | 98 | 97 | 98 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// RMQ
template <class Monoid> struct RMQ {
const Monoid INF;
int SIZE_R;
vector<pair<Monoid, int>> dat;
RMQ(int n, const Monoid &inf) : INF(inf) { init(n); }
void init(int n) {
SIZE_R = 1;
while (SIZE_R < n)
SIZE_R *= 2;
dat.assign(SIZE_R * 2, pair<Monoid, int>(INF, -1));
}
/* set, a is 0-indexed */
void set(int a, const Monoid &v) { dat[a + SIZE_R] = make_pair(v, a); }
void build() {
for (int k = SIZE_R - 1; k > 0; --k) {
dat[k] = min(dat[k * 2], dat[k * 2 + 1]);
}
}
/* update, a is 0-indexed */
void update(int a, const Monoid &v) {
int k = a + SIZE_R;
dat[k] = make_pair(v, a);
while (k >>= 1)
dat[k] = min(dat[k * 2], dat[k * 2 + 1]);
}
/* get {min-value, min-index}, a and b are 0-indexed */
pair<Monoid, int> get(int a, int b) {
pair<Monoid, int> vleft = make_pair(INF, -1), vright = make_pair(INF, -1);
for (int left = a + SIZE_R, right = b + SIZE_R; left < right;
left >>= 1, right >>= 1) {
if (left & 1)
vleft = min(vleft, dat[left++]);
if (right & 1)
vright = min(dat[--right], vright);
}
return min(vleft, vright);
}
inline Monoid operator[](int a) { return dat[a + SIZE_R].first; }
/* debug */
void print() {
for (int i = 0; i < SIZE_R; ++i) {
Monoid val = (*this)[i];
if (val < INF)
cout << val;
else
cout << "INF";
if (i != SIZE_R - 1)
cout << ",";
}
cout << endl;
}
};
// Union-Find
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
using pint = pair<int, int>;
using Edge = pair<long long, pint>;
// 入力
int N;
long long D;
vector<pair<long long, int>> A;
int main() {
cin >> N >> D;
A.resize(N);
RMQ<long long> left(N, 1LL << 60), right(N, 1LL << 60);
for (int i = 0; i < N; ++i) {
long long a;
cin >> a;
A[i] = make_pair(a, i);
left.set(i, A[i].first - D * i);
right.set(i, A[i].first + D * i);
}
left.build(), right.build();
sort(A.begin(), A.end(), greater<pair<long long, int>>());
// A[v] が大きい法から順に
vector<Edge> edges;
for (int i = 0; i < N; ++i) {
int p = A[i].second;
auto le = left.get(0, p);
auto ri = right.get(p + 1, N);
edges.push_back(Edge(A[i].first + D * p + le.first, pint(p, le.second)));
edges.push_back(Edge(A[i].first - D * p + ri.first, pint(p, ri.second)));
left.update(p, 1LL << 60);
right.update(p, 1LL << 60);
}
// Kruskal
UnionFind uf(N);
sort(edges.begin(), edges.end());
long long res = 0;
for (auto e : edges) {
long long w = e.first;
int u = e.second.first, v = e.second.second;
if (uf.issame(u, v))
continue;
res += w;
uf.merge(u, v);
}
cout << res << endl;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// RMQ
template <class Monoid> struct RMQ {
const Monoid INF;
int SIZE_R;
vector<pair<Monoid, int>> dat;
RMQ(int n, const Monoid &inf) : INF(inf) { init(n); }
void init(int n) {
SIZE_R = 1;
while (SIZE_R < n)
SIZE_R *= 2;
dat.assign(SIZE_R * 2, pair<Monoid, int>(INF, -1));
}
/* set, a is 0-indexed */
void set(int a, const Monoid &v) { dat[a + SIZE_R] = make_pair(v, a); }
void build() {
for (int k = SIZE_R - 1; k > 0; --k) {
dat[k] = min(dat[k * 2], dat[k * 2 + 1]);
}
}
/* update, a is 0-indexed */
void update(int a, const Monoid &v) {
int k = a + SIZE_R;
dat[k] = make_pair(v, a);
while (k >>= 1)
dat[k] = min(dat[k * 2], dat[k * 2 + 1]);
}
/* get {min-value, min-index}, a and b are 0-indexed */
pair<Monoid, int> get(int a, int b) {
pair<Monoid, int> vleft = make_pair(INF, -1), vright = make_pair(INF, -1);
for (int left = a + SIZE_R, right = b + SIZE_R; left < right;
left >>= 1, right >>= 1) {
if (left & 1)
vleft = min(vleft, dat[left++]);
if (right & 1)
vright = min(dat[--right], vright);
}
return min(vleft, vright);
}
inline Monoid operator[](int a) { return dat[a + SIZE_R].first; }
/* debug */
void print() {
for (int i = 0; i < SIZE_R; ++i) {
Monoid val = (*this)[i];
if (val < INF)
cout << val;
else
cout << "INF";
if (i != SIZE_R - 1)
cout << ",";
}
cout << endl;
}
};
// Union-Find
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
using pint = pair<int, int>;
using Edge = pair<long long, pint>;
// 入力
int N;
long long D;
vector<pair<long long, int>> A;
int main() {
cin >> N >> D;
A.resize(N);
RMQ<long long> left(N, 1LL << 60), right(N, 1LL << 60);
for (int i = 0; i < N; ++i) {
long long a;
cin >> a;
A[i] = make_pair(a, i);
left.set(i, A[i].first - D * i);
right.set(i, A[i].first + D * i);
}
left.build(), right.build();
sort(A.begin(), A.end(), greater<pair<long long, int>>());
// A[v] が大きい法から順に
vector<Edge> edges;
for (int i = 0; i < N; ++i) {
int p = A[i].second;
auto le = left.get(0, p);
auto ri = right.get(p + 1, N);
if (le.second != -1)
edges.push_back(Edge(A[i].first + D * p + le.first, pint(p, le.second)));
if (ri.second != -1)
edges.push_back(Edge(A[i].first - D * p + ri.first, pint(p, ri.second)));
left.update(p, 1LL << 60);
right.update(p, 1LL << 60);
}
// Kruskal
UnionFind uf(N);
sort(edges.begin(), edges.end());
long long res = 0;
for (auto e : edges) {
long long w = e.first;
int u = e.second.first, v = e.second.second;
if (uf.issame(u, v))
continue;
res += w;
uf.merge(u, v);
}
cout << res << endl;
}
|
replace
| 137 | 139 | 137 | 141 |
-6
|
double free or corruption (out)
|
p03153
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
const i64 MOD = 1e9 + 7;
const i64 INF = 1e18 + 7;
struct UnionFind {
int n;
vector<int> par;
UnionFind(int n) : n(n), par(n, -1) {}
int Find(int x) { return par[x] < 0 ? x : Find(par[x]); }
bool Unite(int x, int y) {
x = Find(x), y = Find(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
};
template <typename T> struct Segtree {
const int n;
const T op;
vector<T> elm;
function<T(T, T)> f;
Segtree(int n, T init, function<T(T, T)> f, T op = T())
: n(n), op(op), f(f), elm(2 * n, init) {}
void set(int x, T val) {
x += n;
elm[x] = val;
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
void update(int x, T val) {
x += n;
elm[x] = f(val, elm[x]);
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
T get(int x, int y) const {
T val = op;
for (x += n, y += n - 1; x <= y; x >>= 1, y >>= 1) {
if (x & 1)
val = f(val, elm[x++]);
if (!(y & 1))
val = f(val, elm[y--]);
}
return val;
}
};
signed main() {
int n, d;
cin >> n >> d;
vector<int> v(n);
for (auto &x : v)
cin >> x;
auto f = [](pair<i64, int> x, pair<i64, int> y) { return min(x, y); };
Segtree<pair<i64, int>> seg_a(n, pair<i64, int>(), f, pair<i64, int>(INF, 0));
Segtree<pair<i64, int>> seg_b(n, pair<i64, int>(), f, pair<i64, int>(INF, 0));
auto s = [&](int i) {
seg_a.set(i, make_pair(v[i] + i64(1) * d * i, i));
seg_b.set(i, make_pair(v[i] + i64(1) * d * (n - i - 1), i));
};
auto t = [&](int i) {
seg_a.set(i, make_pair(INF, i));
seg_b.set(i, make_pair(INF, i));
};
for (int i = 0; i < n; ++i)
s(i);
UnionFind u(n);
i64 ans = 0;
while (u.par[u.Find(0)] != -n) {
// 子ノードの一覧
vector<vector<int>> ch(n);
// 接合するノード
vector<pair<i64, int>> nex(n, make_pair(INF, 0));
for (int i = 0; i < n; ++i)
ch[u.Find(i)].push_back(i);
for (int i = 0; i < n; ++i) {
if (ch[i].empty())
continue;
for (auto &x : ch[i])
t(x);
pair<i64, int> val(INF, 0);
for (auto &x : ch[i]) {
auto p_a = seg_a.get(x + 1, n);
p_a.first -= i64(1) * d * x;
p_a.first += v[x];
val = f(val, p_a);
auto p_b = seg_b.get(0, x);
p_b.first -= i64(1) * d * (n - 1 - x);
p_b.first += v[x];
val = f(val, p_b);
}
for (auto &x : ch[i])
s(x);
nex[i] = val;
}
for (int i = 0; i < n; ++i) {
if (nex[i].first != INF && u.Unite(i, nex[i].second))
ans += nex[i].first;
}
}
cout << ans << endl;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
using i64 = int64_t;
const i64 MOD = 1e9 + 7;
const i64 INF = 1e18 + 7;
struct UnionFind {
int n;
vector<int> par;
UnionFind(int n) : n(n), par(n, -1) {}
int Find(int x) { return par[x] < 0 ? x : Find(par[x]); }
bool Unite(int x, int y) {
x = Find(x), y = Find(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
};
template <typename T> struct Segtree {
const int n;
const T op;
vector<T> elm;
function<T(T, T)> f;
Segtree(int n, T init, function<T(T, T)> f, T op = T())
: n(n), op(op), f(f), elm(2 * n, init) {}
void set(int x, T val) {
x += n;
elm[x] = val;
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
void update(int x, T val) {
x += n;
elm[x] = f(val, elm[x]);
while (x >>= 1)
elm[x] = f(elm[2 * x], elm[2 * x + 1]);
}
T get(int x, int y) const {
T val = op;
for (x += n, y += n - 1; x <= y; x >>= 1, y >>= 1) {
if (x & 1)
val = f(val, elm[x++]);
if (!(y & 1))
val = f(val, elm[y--]);
}
return val;
}
};
signed main() {
int n, d;
cin >> n >> d;
vector<int> v(n);
for (auto &x : v)
cin >> x;
auto f = [](pair<i64, int> x, pair<i64, int> y) { return min(x, y); };
Segtree<pair<i64, int>> seg_a(n, pair<i64, int>(), f, pair<i64, int>(INF, 0));
Segtree<pair<i64, int>> seg_b(n, pair<i64, int>(), f, pair<i64, int>(INF, 0));
auto s = [&](int i) {
seg_a.set(i, make_pair(v[i] + i64(1) * d * i, i));
seg_b.set(i, make_pair(v[i] + i64(1) * d * (n - i - 1), i));
};
auto t = [&](int i) {
seg_a.set(i, make_pair(INF, i));
seg_b.set(i, make_pair(INF, i));
};
for (int i = 0; i < n; ++i)
s(i);
UnionFind u(n);
i64 ans = 0;
while (u.par[u.Find(0)] != -n) {
// 子ノードの一覧
vector<vector<int>> ch(n);
// 接合するノード
vector<pair<i64, int>> nex(n, make_pair(INF, 0));
for (int i = 0; i < n; ++i)
ch[u.Find(i)].push_back(i);
for (int i = 0; i < n; ++i) {
if (ch[i].empty())
continue;
for (auto &x : ch[i])
t(x);
pair<i64, int> val(INF, 0);
for (auto &x : ch[i]) {
auto p_a = seg_a.get(x + 1, n);
p_a.first -= i64(1) * d * x;
p_a.first += v[x];
val = f(val, p_a);
auto p_b = seg_b.get(0, x);
p_b.first -= i64(1) * d * (n - 1 - x);
p_b.first += v[x];
val = f(val, p_b);
}
for (auto &x : ch[i])
s(x);
nex[i] = val;
}
for (int i = 0; i < n; ++i) {
if (nex[i].first != INF && u.Unite(i, nex[i].second))
ans += nex[i].first;
}
}
cout << ans << endl;
}
|
replace
| 0 | 1 | 0 | 4 |
TLE
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAX_N = 100005;
LL A[MAX_N], dp1[MAX_N], dp2[MAX_N];
LL ans, D;
int n;
int main() {
cin >> n >> D;
ans += (n - 1) * D;
for (int i = 0; i < n; i++) {
cin >> A[i];
ans += A[i];
}
dp1[0] = A[0];
dp2[n - 1] = A[n - 1];
for (int i = 1; i < n; i++)
dp1[i] = min(dp1[i - 1] + D, A[i]);
for (int i = n - 2; i >= 0; i--)
dp2[i] = min(dp2[i + 1] + D, A[i]);
for (int i = 1; i < n - 1; i++)
ans += min(dp1[i], dp2[i]);
if (n == 1)
ans = 0;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAX_N = 200005;
LL A[MAX_N], dp1[MAX_N], dp2[MAX_N];
LL ans, D;
int n;
int main() {
cin >> n >> D;
ans += (n - 1) * D;
for (int i = 0; i < n; i++) {
cin >> A[i];
ans += A[i];
}
dp1[0] = A[0];
dp2[n - 1] = A[n - 1];
for (int i = 1; i < n; i++)
dp1[i] = min(dp1[i - 1] + D, A[i]);
for (int i = n - 2; i >= 0; i--)
dp2[i] = min(dp2[i + 1] + D, A[i]);
for (int i = 1; i < n - 1; i++)
ans += min(dp1[i], dp2[i]);
if (n == 1)
ans = 0;
cout << ans << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<long, long> P;
typedef pair<long, P> PP;
vector<PP> edge;
long long N, D;
vector<long long> A;
const long INF = (1L << 50);
class UF {
vector<int> par, rank;
public:
UF(int size) {
par.resize(size);
rank.resize(size);
for (int i = 0; i < size; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
void solve(long l, long r) {
if (l == r)
return;
long m = (l + r) / 2;
long mn = INF;
int pl = -1;
for (long i = l; i <= m; i++) {
long vl = A[i] - D * i;
if (mn > vl) {
mn = vl;
pl = i;
}
}
long pr = -1;
mn = INF;
for (long i = m + 1; i <= r; i++) {
long vr = A[i] + D * i;
if (mn > vr) {
mn = vr;
pr = i;
}
}
for (long i = 0; i <= m; i++) {
edge.push_back(PP(A[i] + A[pr] + D * (pr - i), P(i, pr)));
}
for (long i = m + 1; i < r + 1; i++) {
edge.push_back(PP(A[i] + A[pl] + D * (i - pl), P(pl, i)));
}
solve(l, m);
solve(m + 1, r);
return;
}
int main() {
scanf("%lld", &N);
scanf("%lld", &D);
A.resize(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
solve(0, N - 1);
sort(edge.begin(), edge.end());
UF uf(N);
long ret = 0;
for (auto tmp : edge) {
P p = tmp.second;
if (!uf.same(p.first, p.second)) {
uf.unite(p.first, p.second);
ret += tmp.first;
}
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<long, long> P;
typedef pair<long, P> PP;
vector<PP> edge;
long long N, D;
vector<long long> A;
const long INF = (1L << 50);
class UF {
vector<int> par, rank;
public:
UF(int size) {
par.resize(size);
rank.resize(size);
for (int i = 0; i < size; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
void solve(long l, long r) {
if (l == r)
return;
long m = (l + r) / 2;
long mn = INF;
int pl = -1;
for (long i = l; i <= m; i++) {
long vl = A[i] - D * i;
if (mn > vl) {
mn = vl;
pl = i;
}
}
long pr = -1;
mn = INF;
for (long i = m + 1; i <= r; i++) {
long vr = A[i] + D * i;
if (mn > vr) {
mn = vr;
pr = i;
}
}
for (long i = l; i <= m; i++) {
edge.push_back(PP(A[i] + A[pr] + D * (pr - i), P(i, pr)));
}
for (long i = m + 1; i < r + 1; i++) {
edge.push_back(PP(A[i] + A[pl] + D * (i - pl), P(pl, i)));
}
solve(l, m);
solve(m + 1, r);
return;
}
int main() {
scanf("%lld", &N);
scanf("%lld", &D);
A.resize(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
solve(0, N - 1);
sort(edge.begin(), edge.end());
UF uf(N);
long ret = 0;
for (auto tmp : edge) {
P p = tmp.second;
if (!uf.same(p.first, p.second)) {
uf.unite(p.first, p.second);
ret += tmp.first;
}
}
cout << ret << endl;
return 0;
}
|
replace
| 64 | 65 | 64 | 65 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define rer(i, a, b) for (int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
void Debug() { cout << '\n'; }
template <class FIRST, class... REST> void Debug(FIRST arg, REST... rest) {
cout << arg << " ";
Debug(rest...);
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
if (!v.empty()) {
rep(i, 0, sz(v) - 1) out << v[i] << ", ";
out << v.back();
}
out << "]";
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &v) {
out << "(" << v.first << ", " << v.second << ")";
return out;
}
const int MAX_N = 300010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
///////////////////////////////////////////////////////////////////////////////////////////////////
struct UF {
vector<int> par, ran;
void init(int n) {
par.resize(n);
ran.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
ran[i] = 0;
}
}
UF(int mx = 0) { init(mx); }
int find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (ran[x] < ran[y]) {
par[x] = y;
} else {
par[y] = x;
if (ran[x] == ran[y])
ran[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
//////////////
struct edge {
int u, v;
ll cost;
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
int N, E;
edge es[MAX_N];
ll kruskal() {
sort(es, es + E, comp);
UF uf(N); // init union_find
ll res = 0;
for (int i = 0; i < E; i++) {
edge e = es[i];
if (!uf.same(e.u, e.v)) {
uf.unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
void add_edge(int s, int t, ll cost) {
// debug(s, t, cost);
es[E++] = edge{s, t, cost};
}
struct T {
pl v;
T(pl v = pl(linf, -1)) : v(v) {}
T operator+(const T &t) { return T(min(v, t.v)); }
friend ostream &operator<<(ostream &out, const T &t) {
out << t.v;
return out;
}
};
struct segtree {
int n;
vector<T> seg;
void init(int mx) {
n = 1;
while (n < mx)
n *= 2;
seg = vector<T>(n * 2);
}
segtree(int mx = 0) { init(mx); }
void update(int i, T x) {
i += n - 1;
seg[i] = x;
while (i > 0) {
i = (i - 1) / 2;
seg[i] = seg[i * 2 + 1] + seg[i * 2 + 2];
}
}
T ga(int a, int b, int k, int l, int r) {
if (b <= l || r <= a)
return T();
if (a <= l && r <= b)
return seg[k];
else {
T lv = ga(a, b, k * 2 + 1, l, (l + r) / 2);
T rv = ga(a, b, k * 2 + 2, (l + r) / 2, r);
return lv + rv;
}
}
void show() {
vector<T> tmp;
rep(i, 0, n) tmp.push_back(get(i, i + 1));
debug(tmp);
}
// edit from here
T get(int a, int b) { return ga(a, b, 0, 0, n); } //[a, b)
};
ll D;
ll A[MAX_N];
int idx[MAX_N];
void solve() {
cin >> N >> D;
rep(i, 0, N) cin >> A[i];
rep(i, 0, N) idx[i] = i;
sort(idx, idx + N, [&](int a, int b) { return A[a] < A[b]; });
// debug(vi(idx, idx + N));
segtree seg1(N); // Ai - D * i
segtree seg2(N); // Ai + D * i
rep(j, 0, N) {
int i = idx[j];
pl lp = seg1.get(0, i).v;
pl rp = seg2.get(i + 1, N).v;
if (lp.fst != linf) {
add_edge(i, lp.sec, A[lp.sec] + A[i] + D * (i - lp.sec));
}
if (rp.fst != linf) {
add_edge(i, rp.sec, A[i] + A[rp.sec] + D * (rp.sec - i));
}
seg1.update(i, T(pl(A[i] - D * i, i)));
seg2.update(i, T(pl(A[i] + D * i, i)));
}
cout << kruskal() << "\n";
}
int main() {
#ifndef LOCAL
ios::sync_with_stdio(false);
cin.tie(0);
#endif
cout << fixed;
cout.precision(20);
srand((unsigned int)time(NULL));
#ifdef LOCAL
// freopen("in.txt", "wt", stdout); //for tester
freopen("in.txt", "rt", stdin);
#endif
solve();
#ifdef LOCAL
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
#include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define rer(i, a, b) for (int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
void Debug() { cout << '\n'; }
template <class FIRST, class... REST> void Debug(FIRST arg, REST... rest) {
cout << arg << " ";
Debug(rest...);
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
if (!v.empty()) {
rep(i, 0, sz(v) - 1) out << v[i] << ", ";
out << v.back();
}
out << "]";
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &v) {
out << "(" << v.first << ", " << v.second << ")";
return out;
}
const int MAX_N = 300010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
///////////////////////////////////////////////////////////////////////////////////////////////////
struct UF {
vector<int> par, ran;
void init(int n) {
par.resize(n);
ran.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
ran[i] = 0;
}
}
UF(int mx = 0) { init(mx); }
int find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (ran[x] < ran[y]) {
par[x] = y;
} else {
par[y] = x;
if (ran[x] == ran[y])
ran[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
//////////////
struct edge {
int u, v;
ll cost;
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
int N, E;
edge es[MAX_N * 2];
ll kruskal() {
sort(es, es + E, comp);
UF uf(N); // init union_find
ll res = 0;
for (int i = 0; i < E; i++) {
edge e = es[i];
if (!uf.same(e.u, e.v)) {
uf.unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
void add_edge(int s, int t, ll cost) {
// debug(s, t, cost);
es[E++] = edge{s, t, cost};
}
struct T {
pl v;
T(pl v = pl(linf, -1)) : v(v) {}
T operator+(const T &t) { return T(min(v, t.v)); }
friend ostream &operator<<(ostream &out, const T &t) {
out << t.v;
return out;
}
};
struct segtree {
int n;
vector<T> seg;
void init(int mx) {
n = 1;
while (n < mx)
n *= 2;
seg = vector<T>(n * 2);
}
segtree(int mx = 0) { init(mx); }
void update(int i, T x) {
i += n - 1;
seg[i] = x;
while (i > 0) {
i = (i - 1) / 2;
seg[i] = seg[i * 2 + 1] + seg[i * 2 + 2];
}
}
T ga(int a, int b, int k, int l, int r) {
if (b <= l || r <= a)
return T();
if (a <= l && r <= b)
return seg[k];
else {
T lv = ga(a, b, k * 2 + 1, l, (l + r) / 2);
T rv = ga(a, b, k * 2 + 2, (l + r) / 2, r);
return lv + rv;
}
}
void show() {
vector<T> tmp;
rep(i, 0, n) tmp.push_back(get(i, i + 1));
debug(tmp);
}
// edit from here
T get(int a, int b) { return ga(a, b, 0, 0, n); } //[a, b)
};
ll D;
ll A[MAX_N];
int idx[MAX_N];
void solve() {
cin >> N >> D;
rep(i, 0, N) cin >> A[i];
rep(i, 0, N) idx[i] = i;
sort(idx, idx + N, [&](int a, int b) { return A[a] < A[b]; });
// debug(vi(idx, idx + N));
segtree seg1(N); // Ai - D * i
segtree seg2(N); // Ai + D * i
rep(j, 0, N) {
int i = idx[j];
pl lp = seg1.get(0, i).v;
pl rp = seg2.get(i + 1, N).v;
if (lp.fst != linf) {
add_edge(i, lp.sec, A[lp.sec] + A[i] + D * (i - lp.sec));
}
if (rp.fst != linf) {
add_edge(i, rp.sec, A[i] + A[rp.sec] + D * (rp.sec - i));
}
seg1.update(i, T(pl(A[i] - D * i, i)));
seg2.update(i, T(pl(A[i] + D * i, i)));
}
cout << kruskal() << "\n";
}
int main() {
#ifndef LOCAL
ios::sync_with_stdio(false);
cin.tie(0);
#endif
cout << fixed;
cout.precision(20);
srand((unsigned int)time(NULL));
#ifdef LOCAL
// freopen("in.txt", "wt", stdout); //for tester
freopen("in.txt", "rt", stdin);
#endif
solve();
#ifdef LOCAL
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
replace
| 94 | 95 | 94 | 95 |
0
| |
p03153
|
C++
|
Runtime Error
|
// Code by Denverjin.
#include <bits/stdc++.h>
using namespace std;
using ld = double;
using ll = long long;
using ull = unsigned long long;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int SZ = 1 << 13;
char buff[SZ], *pos = buff + SZ - 1;
#define getchar() \
(++pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos)
inline ll read() {
ll x = 0;
int f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -f;
for (; isdigit(c); c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
return x * f;
}
const int N = 1 << 20;
int n, D;
int a[N];
ll e[N][3];
int m;
int id[N];
void solve(int l, int r) {
if (l + 1 >= r)
return;
int md = (l + r) >> 1;
int mL = l;
for (int i = l; i < md; ++i)
if (-1LL * i * D + a[i] < -1LL * mL * D + a[mL])
mL = i;
int mR = md;
for (int i = md; i < r; ++i)
if (1LL * i * D + a[i] < 1LL * mR * D + a[mR])
mR = i;
for (int i = md; i < r; ++i)
e[m][0] = mL, e[m][1] = i, e[m][2] = 1LL * (i - mL) * D + a[i] + a[mL],
id[m] = m++;
for (int i = l; i < md; ++i)
e[m][0] = i, e[m][1] = mR, e[m][2] = 1LL * (mR - i) * D + a[i] + a[mR],
id[m] = m++;
solve(l, md);
solve(md, r);
}
int par[N];
void init() {
for (int i = 0; i < N; ++i)
par[i] = i;
}
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
par[x] = y;
}
bool same(int x, int y) { return find(x) == find(y); }
int main() {
init();
n = read(), D = read();
for (int i = 0; i < n; ++i)
a[i] = read();
solve(0, n);
sort(id, id + m, [&](int a, int b) { return e[a][2] < e[b][2]; });
ll ans = 0;
for (int ii = 0; ii < m; ++ii) {
int i = id[ii];
if (!same(e[i][0], e[i][1])) {
merge(e[i][0], e[i][1]);
ans += e[i][2];
}
}
printf("%lld\n", ans);
return 0;
}
|
// Code by Denverjin.
#include <bits/stdc++.h>
using namespace std;
using ld = double;
using ll = long long;
using ull = unsigned long long;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int SZ = 1 << 13;
char buff[SZ], *pos = buff + SZ - 1;
#define getchar() \
(++pos == buff + SZ ? fread(pos = buff, 1, SZ, stdin), *pos : *pos)
inline ll read() {
ll x = 0;
int f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -f;
for (; isdigit(c); c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
return x * f;
}
const int N = 1 << 24;
int n, D;
int a[N];
ll e[N][3];
int m;
int id[N];
void solve(int l, int r) {
if (l + 1 >= r)
return;
int md = (l + r) >> 1;
int mL = l;
for (int i = l; i < md; ++i)
if (-1LL * i * D + a[i] < -1LL * mL * D + a[mL])
mL = i;
int mR = md;
for (int i = md; i < r; ++i)
if (1LL * i * D + a[i] < 1LL * mR * D + a[mR])
mR = i;
for (int i = md; i < r; ++i)
e[m][0] = mL, e[m][1] = i, e[m][2] = 1LL * (i - mL) * D + a[i] + a[mL],
id[m] = m++;
for (int i = l; i < md; ++i)
e[m][0] = i, e[m][1] = mR, e[m][2] = 1LL * (mR - i) * D + a[i] + a[mR],
id[m] = m++;
solve(l, md);
solve(md, r);
}
int par[N];
void init() {
for (int i = 0; i < N; ++i)
par[i] = i;
}
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
par[x] = y;
}
bool same(int x, int y) { return find(x) == find(y); }
int main() {
init();
n = read(), D = read();
for (int i = 0; i < n; ++i)
a[i] = read();
solve(0, n);
sort(id, id + m, [&](int a, int b) { return e[a][2] < e[b][2]; });
ll ans = 0;
for (int ii = 0; ii < m; ++ii) {
int i = id[ii];
if (!same(e[i][0], e[i][1])) {
merge(e[i][0], e[i][1]);
ans += e[i][2];
}
}
printf("%lld\n", ans);
return 0;
}
|
replace
| 26 | 27 | 26 | 27 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200010
#define INFLL 0x3f3f3f3f3f3f3f3f
int n, m;
ll d, a[N];
struct Edge {
int u, v;
ll w;
Edge() {}
Edge(int u, int v, ll w) : u(u), v(v), w(w) {}
bool operator<(const Edge &other) const { return w < other.w; }
} edge[N * 15];
void add(int l, int r) {
if (l == r)
return;
int mid = (l + r) >> 1;
ll Min = INFLL;
int pos = -1;
for (int i = l; i <= mid; ++i) {
ll f = a[i] - d * i;
if (f < Min) {
Min = f;
pos = i;
}
}
for (int i = mid + 1; i <= r; ++i)
edge[++m] = Edge(pos, i, a[pos] + a[i] + d * (i - pos));
Min = INFLL;
pos = -1;
for (int i = mid + 1; i <= r; ++i) {
ll f = a[i] + d * i;
if (f < Min) {
Min = f;
pos = i;
}
}
for (int i = l; i <= mid; ++i)
edge[++m] = Edge(pos, i, a[pos] + a[i] + d * (pos - i));
add(l, mid);
add(mid + 1, r);
}
int pre[N];
int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); }
ll Kruskal() {
memset(pre, 0, sizeof pre);
sort(edge + 1, edge + 1 + m);
int cnt = 1;
ll res = 0;
for (int i = 1; i <= m; ++i) {
int u = edge[i].u, v = edge[i].v;
ll w = edge[i].w;
int fu = find(u), fv = find(v);
if (fu == fv)
continue;
pre[fu] = fv;
res += w;
++cnt;
if (cnt == n)
return res;
}
return res;
}
int main() {
while (scanf("%d%lld", &n, &d) != EOF) {
m = 0;
for (int i = 1; i <= n; ++i)
scanf("%lld", a + i);
add(1, n);
printf("%lld\n", Kruskal());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200010
#define INFLL 0x3f3f3f3f3f3f3f3f
int n, m;
ll d, a[N];
struct Edge {
int u, v;
ll w;
Edge() {}
Edge(int u, int v, ll w) : u(u), v(v), w(w) {}
bool operator<(const Edge &other) const { return w < other.w; }
} edge[N * 30];
void add(int l, int r) {
if (l == r)
return;
int mid = (l + r) >> 1;
ll Min = INFLL;
int pos = -1;
for (int i = l; i <= mid; ++i) {
ll f = a[i] - d * i;
if (f < Min) {
Min = f;
pos = i;
}
}
for (int i = mid + 1; i <= r; ++i)
edge[++m] = Edge(pos, i, a[pos] + a[i] + d * (i - pos));
Min = INFLL;
pos = -1;
for (int i = mid + 1; i <= r; ++i) {
ll f = a[i] + d * i;
if (f < Min) {
Min = f;
pos = i;
}
}
for (int i = l; i <= mid; ++i)
edge[++m] = Edge(pos, i, a[pos] + a[i] + d * (pos - i));
add(l, mid);
add(mid + 1, r);
}
int pre[N];
int find(int x) { return pre[x] == 0 ? x : pre[x] = find(pre[x]); }
ll Kruskal() {
memset(pre, 0, sizeof pre);
sort(edge + 1, edge + 1 + m);
int cnt = 1;
ll res = 0;
for (int i = 1; i <= m; ++i) {
int u = edge[i].u, v = edge[i].v;
ll w = edge[i].w;
int fu = find(u), fv = find(v);
if (fu == fv)
continue;
pre[fu] = fv;
res += w;
++cnt;
if (cnt == n)
return res;
}
return res;
}
int main() {
while (scanf("%d%lld", &n, &d) != EOF) {
m = 0;
for (int i = 1; i <= n; ++i)
scanf("%lld", a + i);
add(1, n);
printf("%lld\n", Kruskal());
}
return 0;
}
|
replace
| 14 | 15 | 14 | 15 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
// 標準ライブラリ関数の名前を変える
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF = 1e9 + 7;
const ll LINF = 1LL << 60;
const ll MOD = 1e9 + 7;
const ld PI = acos(-1);
const ld EPS = 1e-9; // 微調整用（EPSより小さいと0と判定など）
#define gcd __gcd // llは受け取ってくれない
int lcm(int a, int b) { return a / gcd(a, b) * b; }
#define ALL(a) a.begin(), a.end() // sort(ALL(vec));
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP(a, b) make_pair(a, b)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define PB push_back
#define SZ(x) ((int)(x).size) // size()がunsignedなのでエラー避けに
// 最大値、最小値を更新する。aよりbのが大きい（小さい）か等しければaを更新してtrueを返す。そうでなければ何もせずfalseを返す
// chmax(nowmax,x);
template <typename T> bool chmax(T &a, T b) { return (a = max(a, b)) == b; }
template <typename T> bool chmin(T &a, T b) { return (a = min(a, b)) == b; }
// ------- template ------ //
// Range Minimum(Maximum) Query (RMQ)
// Big Range Query
// セグメント木 pll(x, y) = pll(値, 要素番号)
// インデックス取得したい場合: get_m**_with_idx()を使う
class SegmentTree {
public:
int n = 1;
vector<pll> seg[2]; // 0:最大 1:最小
void init(int N) { // N要素のセグメントツリー作成
while (n < N)
n *= 2;
rep(i, 2) seg[i].resize(2 * n);
fill(ALL(seg[0]), pll(-LINF, -1));
fill(ALL(seg[1]), pll(LINF, -1));
}
pll cmp_min(pll x, pll y) { // 比較関数
if (x.first == y.first)
return x.second < y.second ? x : y;
return min(x, y);
}
pll cmp_max(pll x, pll y) { // 比較関数
if (x.first == y.first)
return x.second < y.second ? x : y;
return max(x, y);
}
void update(ll k, ll x, bool flag = false) { // idx:k番目の値をxに変更
k += n - 1;
seg[0][k] = seg[1][k] = pll(x, k - (n - 1));
if (flag) {
seg[0][k] = pll(-LINF, -1);
seg[1][k] = pll(LINF, -1);
}
while (k > 0) {
k = (k - 1) / 2;
seg[0][k] = cmp_max(seg[0][k * 2 + 1], seg[0][k * 2 + 2]);
seg[1][k] = cmp_min(seg[1][k * 2 + 1], seg[1][k * 2 + 2]);
}
}
pll calc(ll a, ll b, ll k, ll l, ll r, ll f) {
if (b <= l || r <= a)
return f ? pll(LINF, -1) : pll(-LINF, -1);
if (a <= l && r <= b)
return seg[f][k];
pll vl = calc(a, b, k * 2 + 1, l, (l + r) / 2, f);
pll vr = calc(a, b, k * 2 + 2, (l + r) / 2, r, f);
return f ? cmp_min(vl, vr) : cmp_max(vl, vr);
}
void erase(ll k) {
update(k, -1, true);
} // 要素を削除（実際にはINF, -INFにする）
// 最大値・最小値のみ取得
ll get_max(ll a, ll b) { return calc(a, b, 0, 0, n, 0).first; }
ll get_min(ll a, ll b) { return calc(a, b, 0, 0, n, 1).first; }
// インデックスも取得（pll<最大値, 最大値のidx>）を返す
pll get_max_with_idx(ll a, ll b) { return calc(a, b, 0, 0, n, 0); }
pll get_min_with_idx(ll a, ll b) { return calc(a, b, 0, 0, n, 1); }
};
// Union-Find（素集合データ構造）
struct UnionFind {
vector<int> data;
UnionFind(int sz) { data.assign(sz, -1); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if (data[k] < 0)
return (k);
return (data[k] = find(data[k]));
}
int size(int k) { return (-data[find(k)]); }
};
int main() {
ll N, D;
cin >> N >> D;
// 1. Asに[a:都市の規模, i:idx]を格納
vector<pll> As(N); // (ll 規模, ll idx)
rep(i, N) {
cin >> As.at(i).first;
As.at(i).second = i;
}
// 2. 規模降順にソート
sort(ALL(As), greater<pll>()); // 降順
/* check
for (pll a: As){
cout << a.first << ' ' << a.second << endl;
} */
// 3.
// SegTreeを2つ作り、それぞれにコストを入れる（segtreeのidxがAsにおけるidxとなるようにする）
SegmentTree seg_left;
seg_left.init(N);
SegmentTree seg_right;
seg_right.init(N);
int i = 0;
for (pll a : As) {
seg_left.update(a.second, (N - 1 - a.second) * D + a.first);
seg_right.update(a.second, a.second * D + a.first);
i++;
}
// cout << seg_left.get_min_with_idx(1,3).first << ' ' <<
// seg_left.get_min_with_idx(1,3).second << endl; cout <<
// seg_left.get_max_with_idx(2,6).first << ' ' <<
// seg_left.get_max_with_idx(2,6).second << endl;
// ここからの流れ
// 4. それを使って、規模降順forで左右領域の「[l,
// r)における最もコストの低い接続先都市」をピックアップする
// --> ピックアップしたら、priority_queue(edge_candidates)に[idx,
// adjidx]を入れていく
// edge_candidatesを宣言 最小値を取り出すpriority_queue
priority_queue<tuple<ll, ll, ll>, vector<tuple<ll, ll, ll>>,
greater<tuple<ll, ll, ll>>>
edge_candidates;
ll nowidx, nowcost;
ll leftmin, rightmin, lminidx, rminidx;
for (pll a : As) {
tie(nowcost, nowidx) = a;
// cout << nowcost << ' ' << nowidx << ' ';
if (nowidx == 0) {
tie(rightmin, rminidx) = seg_right.get_min_with_idx(1, N);
if (rightmin !=
INF) { // INFなら、基点となる都市より規模の大きい都市なので、無視
edge_candidates.push(make_tuple(
abs(nowidx - rminidx) * D + nowcost + rightmin - rminidx * D,
nowidx, rminidx)); //(コスト, a_idx, adj_idx)
}
} else if (nowidx == N - 1) {
tie(leftmin, lminidx) = seg_left.get_min_with_idx(0, nowidx);
if (leftmin != LINF) {
edge_candidates.push(make_tuple(abs(nowidx - lminidx) * D + nowcost +
leftmin - (N - 1 - lminidx) * D,
nowidx,
lminidx)); //(コスト, a_idx, adj_idx)
}
} else {
tie(leftmin, lminidx) = seg_left.get_min_with_idx(0, nowidx);
if (leftmin != LINF) {
edge_candidates.push(make_tuple(abs(nowidx - lminidx) * D + nowcost +
leftmin - (N - 1 - lminidx) * D,
nowidx,
lminidx)); //(コスト, a_idx, adj_idx)
}
tie(rightmin, rminidx) = seg_right.get_min_with_idx(nowidx + 1, N);
if (rightmin !=
LINF) { // INFなら、基点となる都市より規模の大きい都市なので、無視
edge_candidates.push(make_tuple(
abs(nowidx - rminidx) * D + nowcost + rightmin - rminidx * D,
nowidx, rminidx)); //(コスト, a_idx, adj_idx)
}
}
// cout << leftmin << ' ' << lminidx << ' ';
// cout << rightmin << ' ' << rminidx << endl;
seg_left.erase(nowidx);
seg_right.erase(nowidx);
}
// 5. 1つずつtop()->pop()して、Uniteする（Uniteできたらans+=コスト,
// できなかったら無視）
// check
/*ll aa, bb, cc;
tie(aa, bb, cc) = edge_candidates.top();
cout << "1ban : " << aa << ' ' << bb << ' ' << cc << endl;
edge_candidates.pop();
tie(aa, bb, cc) = edge_candidates.top();
cout << "2ban : " << aa << ' ' << bb << ' ' << cc << endl; */
UnionFind UF(N);
ll ans = 0;
ll cost, sidx, adjidx;
while (not edge_candidates.empty()) {
// cout << 'a' << endl;
tie(cost, sidx, adjidx) = edge_candidates.top();
// cout << cost << ' ' << sidx << ' ' << adjidx << endl;
edge_candidates.pop();
if (UF.unite(sidx, adjidx)) { // uniteが成功したら=まだ接続されていなかったら
ans += cost;
} // 接続されていたら無視する
}
// cout << "end" << endl;
// 6. できあがり！
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
// 標準ライブラリ関数の名前を変える
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF = 1e9 + 7;
const ll LINF = 1LL << 60;
const ll MOD = 1e9 + 7;
const ld PI = acos(-1);
const ld EPS = 1e-9; // 微調整用（EPSより小さいと0と判定など）
#define gcd __gcd // llは受け取ってくれない
int lcm(int a, int b) { return a / gcd(a, b) * b; }
#define ALL(a) a.begin(), a.end() // sort(ALL(vec));
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP(a, b) make_pair(a, b)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define PB push_back
#define SZ(x) ((int)(x).size) // size()がunsignedなのでエラー避けに
// 最大値、最小値を更新する。aよりbのが大きい（小さい）か等しければaを更新してtrueを返す。そうでなければ何もせずfalseを返す
// chmax(nowmax,x);
template <typename T> bool chmax(T &a, T b) { return (a = max(a, b)) == b; }
template <typename T> bool chmin(T &a, T b) { return (a = min(a, b)) == b; }
// ------- template ------ //
// Range Minimum(Maximum) Query (RMQ)
// Big Range Query
// セグメント木 pll(x, y) = pll(値, 要素番号)
// インデックス取得したい場合: get_m**_with_idx()を使う
class SegmentTree {
public:
int n = 1;
vector<pll> seg[2]; // 0:最大 1:最小
void init(int N) { // N要素のセグメントツリー作成
while (n < N)
n *= 2;
rep(i, 2) seg[i].resize(2 * n);
fill(ALL(seg[0]), pll(-LINF, -1));
fill(ALL(seg[1]), pll(LINF, -1));
}
pll cmp_min(pll x, pll y) { // 比較関数
if (x.first == y.first)
return x.second < y.second ? x : y;
return min(x, y);
}
pll cmp_max(pll x, pll y) { // 比較関数
if (x.first == y.first)
return x.second < y.second ? x : y;
return max(x, y);
}
void update(ll k, ll x, bool flag = false) { // idx:k番目の値をxに変更
k += n - 1;
seg[0][k] = seg[1][k] = pll(x, k - (n - 1));
if (flag) {
seg[0][k] = pll(-LINF, -1);
seg[1][k] = pll(LINF, -1);
}
while (k > 0) {
k = (k - 1) / 2;
seg[0][k] = cmp_max(seg[0][k * 2 + 1], seg[0][k * 2 + 2]);
seg[1][k] = cmp_min(seg[1][k * 2 + 1], seg[1][k * 2 + 2]);
}
}
pll calc(ll a, ll b, ll k, ll l, ll r, ll f) {
if (b <= l || r <= a)
return f ? pll(LINF, -1) : pll(-LINF, -1);
if (a <= l && r <= b)
return seg[f][k];
pll vl = calc(a, b, k * 2 + 1, l, (l + r) / 2, f);
pll vr = calc(a, b, k * 2 + 2, (l + r) / 2, r, f);
return f ? cmp_min(vl, vr) : cmp_max(vl, vr);
}
void erase(ll k) {
update(k, -1, true);
} // 要素を削除（実際にはINF, -INFにする）
// 最大値・最小値のみ取得
ll get_max(ll a, ll b) { return calc(a, b, 0, 0, n, 0).first; }
ll get_min(ll a, ll b) { return calc(a, b, 0, 0, n, 1).first; }
// インデックスも取得（pll<最大値, 最大値のidx>）を返す
pll get_max_with_idx(ll a, ll b) { return calc(a, b, 0, 0, n, 0); }
pll get_min_with_idx(ll a, ll b) { return calc(a, b, 0, 0, n, 1); }
};
// Union-Find（素集合データ構造）
struct UnionFind {
vector<int> data;
UnionFind(int sz) { data.assign(sz, -1); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if (data[k] < 0)
return (k);
return (data[k] = find(data[k]));
}
int size(int k) { return (-data[find(k)]); }
};
int main() {
ll N, D;
cin >> N >> D;
// 1. Asに[a:都市の規模, i:idx]を格納
vector<pll> As(N); // (ll 規模, ll idx)
rep(i, N) {
cin >> As.at(i).first;
As.at(i).second = i;
}
// 2. 規模降順にソート
sort(ALL(As), greater<pll>()); // 降順
/* check
for (pll a: As){
cout << a.first << ' ' << a.second << endl;
} */
// 3.
// SegTreeを2つ作り、それぞれにコストを入れる（segtreeのidxがAsにおけるidxとなるようにする）
SegmentTree seg_left;
seg_left.init(N);
SegmentTree seg_right;
seg_right.init(N);
int i = 0;
for (pll a : As) {
seg_left.update(a.second, (N - 1 - a.second) * D + a.first);
seg_right.update(a.second, a.second * D + a.first);
i++;
}
// cout << seg_left.get_min_with_idx(1,3).first << ' ' <<
// seg_left.get_min_with_idx(1,3).second << endl; cout <<
// seg_left.get_max_with_idx(2,6).first << ' ' <<
// seg_left.get_max_with_idx(2,6).second << endl;
// ここからの流れ
// 4. それを使って、規模降順forで左右領域の「[l,
// r)における最もコストの低い接続先都市」をピックアップする
// --> ピックアップしたら、priority_queue(edge_candidates)に[idx,
// adjidx]を入れていく
// edge_candidatesを宣言 最小値を取り出すpriority_queue
priority_queue<tuple<ll, ll, ll>, vector<tuple<ll, ll, ll>>,
greater<tuple<ll, ll, ll>>>
edge_candidates;
ll nowidx, nowcost;
ll leftmin, rightmin, lminidx, rminidx;
for (pll a : As) {
tie(nowcost, nowidx) = a;
// cout << nowcost << ' ' << nowidx << ' ';
if (nowidx == 0) {
tie(rightmin, rminidx) = seg_right.get_min_with_idx(1, N);
if (rightmin !=
LINF) { // INFなら、基点となる都市より規模の大きい都市なので、無視
edge_candidates.push(make_tuple(
abs(nowidx - rminidx) * D + nowcost + rightmin - rminidx * D,
nowidx, rminidx)); //(コスト, a_idx, adj_idx)
}
} else if (nowidx == N - 1) {
tie(leftmin, lminidx) = seg_left.get_min_with_idx(0, nowidx);
if (leftmin != LINF) {
edge_candidates.push(make_tuple(abs(nowidx - lminidx) * D + nowcost +
leftmin - (N - 1 - lminidx) * D,
nowidx,
lminidx)); //(コスト, a_idx, adj_idx)
}
} else {
tie(leftmin, lminidx) = seg_left.get_min_with_idx(0, nowidx);
if (leftmin != LINF) {
edge_candidates.push(make_tuple(abs(nowidx - lminidx) * D + nowcost +
leftmin - (N - 1 - lminidx) * D,
nowidx,
lminidx)); //(コスト, a_idx, adj_idx)
}
tie(rightmin, rminidx) = seg_right.get_min_with_idx(nowidx + 1, N);
if (rightmin !=
LINF) { // INFなら、基点となる都市より規模の大きい都市なので、無視
edge_candidates.push(make_tuple(
abs(nowidx - rminidx) * D + nowcost + rightmin - rminidx * D,
nowidx, rminidx)); //(コスト, a_idx, adj_idx)
}
}
// cout << leftmin << ' ' << lminidx << ' ';
// cout << rightmin << ' ' << rminidx << endl;
seg_left.erase(nowidx);
seg_right.erase(nowidx);
}
// 5. 1つずつtop()->pop()して、Uniteする（Uniteできたらans+=コスト,
// できなかったら無視）
// check
/*ll aa, bb, cc;
tie(aa, bb, cc) = edge_candidates.top();
cout << "1ban : " << aa << ' ' << bb << ' ' << cc << endl;
edge_candidates.pop();
tie(aa, bb, cc) = edge_candidates.top();
cout << "2ban : " << aa << ' ' << bb << ' ' << cc << endl; */
UnionFind UF(N);
ll ans = 0;
ll cost, sidx, adjidx;
while (not edge_candidates.empty()) {
// cout << 'a' << endl;
tie(cost, sidx, adjidx) = edge_candidates.top();
// cout << cost << ' ' << sidx << ' ' << adjidx << endl;
edge_candidates.pop();
if (UF.unite(sidx, adjidx)) { // uniteが成功したら=まだ接続されていなかったら
ans += cost;
} // 接続されていたら無視する
}
// cout << "end" << endl;
// 6. できあがり！
cout << ans << endl;
}
|
replace
| 180 | 181 | 180 | 181 |
-6
|
double free or corruption (out)
|
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T = int> struct Rmq {
vector<T> raw;
static const int LOG = 17; // 20;
int k;
int n;
vector<int> st[LOG];
Rmq(vector<T> _v) { // pass in vec[0, n)
raw = _v;
n = raw.size();
k = 32 - __builtin_clz(n);
for (int j = 0; j < k; j++) {
st[j].resize(n);
}
build();
}
inline int comp(int x, int y) { // DO! > max
return raw[x] < raw[y] ? x : y;
}
void build() {
for (int i = 0; i < n; i++) {
st[0][i] = i;
}
for (int j = 1; j < k; j++) {
for (int i = 0; i + (1 << j) <= n; i++) {
st[j][i] = comp(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
}
}
}
// [l, r)
inline int query_id(int l, int r) {
assert(0 <= l && l < r && r <= n);
int j = 31 - __builtin_clz(r - l);
return comp(st[j][l], st[j][r - (1 << j)]);
}
inline T query(int l, int r) { return raw[query_id(l, r)]; }
};
struct Dsu {
int n;
vector<int> p;
Dsu(int _n) {
n = _n;
p.resize(n);
init();
}
inline void init() {
for (int i = 0; i < n; i++) {
p[i] = i;
}
}
inline int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
inline bool join(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
p[y] = x;
return true;
}
inline bool check(int x, int y) { return find(x) == find(y); }
};
struct Edge {
int x, y;
ll cost;
Edge() {}
Edge(int _x, int _y, ll _cost) : x(_x), y(_y), cost(_cost) {}
bool operator<(const Edge &_oth) const { return cost < _oth.cost; }
};
void solve() {
int n;
ll D;
cin >> n >> D;
vector<ll> a(n), L(n), R(n);
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
a[i] = x;
L[i] = x - i * D;
R[i] = x + i * D;
}
Rmq<ll> mL(L), mR(R);
vector<Edge> es;
function<void(int, int)> cut = [&](int l, int r) {
if (r - l <= 1)
return;
int m = (r + l) / 2;
int i = mL.query_id(l, m);
for (int k = m; k < r; k++) {
es.emplace_back(i, k, R[k] + L[i]);
}
int j = mR.query_id(m, r);
for (int k = l; k < m; k++) {
es.emplace_back(j, k, L[k] + R[j]);
}
cut(l, m);
cut(m, r);
};
cut(0, n);
sort(es.begin(), es.end());
Dsu d(n);
ll res = 0;
for (auto &e : es) {
if (!d.check(e.x, e.y)) {
res += e.cost;
d.join(e.x, e.y);
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T = int> struct Rmq {
vector<T> raw;
static const int LOG = 19; // 20;
int k;
int n;
vector<int> st[LOG];
Rmq(vector<T> _v) { // pass in vec[0, n)
raw = _v;
n = raw.size();
k = 32 - __builtin_clz(n);
for (int j = 0; j < k; j++) {
st[j].resize(n);
}
build();
}
inline int comp(int x, int y) { // DO! > max
return raw[x] < raw[y] ? x : y;
}
void build() {
for (int i = 0; i < n; i++) {
st[0][i] = i;
}
for (int j = 1; j < k; j++) {
for (int i = 0; i + (1 << j) <= n; i++) {
st[j][i] = comp(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
}
}
}
// [l, r)
inline int query_id(int l, int r) {
assert(0 <= l && l < r && r <= n);
int j = 31 - __builtin_clz(r - l);
return comp(st[j][l], st[j][r - (1 << j)]);
}
inline T query(int l, int r) { return raw[query_id(l, r)]; }
};
struct Dsu {
int n;
vector<int> p;
Dsu(int _n) {
n = _n;
p.resize(n);
init();
}
inline void init() {
for (int i = 0; i < n; i++) {
p[i] = i;
}
}
inline int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
inline bool join(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
p[y] = x;
return true;
}
inline bool check(int x, int y) { return find(x) == find(y); }
};
struct Edge {
int x, y;
ll cost;
Edge() {}
Edge(int _x, int _y, ll _cost) : x(_x), y(_y), cost(_cost) {}
bool operator<(const Edge &_oth) const { return cost < _oth.cost; }
};
void solve() {
int n;
ll D;
cin >> n >> D;
vector<ll> a(n), L(n), R(n);
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
a[i] = x;
L[i] = x - i * D;
R[i] = x + i * D;
}
Rmq<ll> mL(L), mR(R);
vector<Edge> es;
function<void(int, int)> cut = [&](int l, int r) {
if (r - l <= 1)
return;
int m = (r + l) / 2;
int i = mL.query_id(l, m);
for (int k = m; k < r; k++) {
es.emplace_back(i, k, R[k] + L[i]);
}
int j = mR.query_id(m, r);
for (int k = l; k < m; k++) {
es.emplace_back(j, k, L[k] + R[j]);
}
cut(l, m);
cut(m, r);
};
cut(0, n);
sort(es.begin(), es.end());
Dsu d(n);
ll res = 0;
for (auto &e : es) {
if (!d.check(e.x, e.y)) {
res += e.cost;
d.join(e.x, e.y);
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p03153
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
// getintとかいうのそんなに速いのかなテスト
int getint() {
char ch;
while (!isdigit(ch = getchar()))
;
int x = ch - 48;
while (isdigit(ch = getchar()))
x = x * 10 + ch - 48;
return x;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, D;
cin >> N >> D;
ll kotae = (N - 1) * D;
int A[200001];
ll C[200001];
C[0] = 1e18;
rep1(i, N) {
A[i] = getint();
kotae += A[i];
C[i] = min(C[i - 1] + D, (ll)A[i]);
}
ll mae = 1e18;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, (ll)A[i + 1]);
ll kari = min(mae, C[i - 1]) + D;
kotae += min((ll)A[i], kari);
}
co(kotae);
Would you please return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
// getintとかいうのそんなに速いのかなテスト
int getint() {
char ch;
while (!isdigit(ch = getchar()))
;
int x = ch - 48;
while (isdigit(ch = getchar()))
x = x * 10 + ch - 48;
return x;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N = getint();
ll D = getint();
ll kotae = (N - 1) * D;
int A[200001];
ll C[200001];
C[0] = 1e18;
rep1(i, N) {
A[i] = getint();
kotae += A[i];
C[i] = min(C[i - 1] + D, (ll)A[i]);
}
ll mae = 1e18;
for (int i = N - 1; i > 1; i--) {
mae = min(mae + D, (ll)A[i + 1]);
ll kari = min(mae, C[i - 1]) + D;
kotae += min((ll)A[i], kari);
}
co(kotae);
Would you please return 0;
}
|
replace
| 31 | 33 | 31 | 33 |
TLE
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define printvector(v, n) \
for (int i = 1; i <= n; i++) \
cout << v[i] << " "; \
cout << ln;
#define printint(v) copy(begin(v), end(v), ostream_iterator<int>(cout, " "))
#define printintv(s, e) copy(s, e, ostream_iterator<int>(cout, " "))
#define clz(a) __builtin_clz(a) // count leading zeroes
#define ctz(a) __builtin_ctz(a) // count trailing zeroes
#define popc(a) \
__builtin_popcount(a) // count set bits (for ints only diff for int64)
// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html for other in built
#define ln "\n"
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define RFOR(i, b, a) for (int i = b; i >= a; i--)
#define dbg(x) cout << #x << " = " << x << ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define setPresent(x, s) (s.find(x) != s.end())
#define sqr(x) x *x
#define siz(v) int(v.size())
const double pi = 3.14159265358979323846;
typedef long long ll;
typedef pair<int, int> p32;
typedef pair<ll, ll> p64;
typedef pair<double, double> pdd;
typedef pair<char, int> pci;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int>> vv32;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
typedef map<int, int> m32;
typedef map<ll, ll> m64;
#pragma GCC optimize("-O2")
template <class T>
using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
const int LM = 1e5;
ll n, d, a[LM + 2], INF = 1e18;
p64 sg1[4 * LM + 5], sg2[4 * LM + 5];
int sz[LM + 2], p[LM + 2], siz = 1;
vector<pair<ll, p32>> edges;
vp64 v;
// in the segtree also store at what index the minimum
// occurs
int find(int x) {
while (p[x] != x)
x = p[x];
return x;
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (sz[a] < sz[b])
swap(a, b);
p[b] = a;
sz[a] += sz[b];
}
void init(p64 sg[]) {
while (siz < n)
siz *= 2;
FOR(i, 1, 2 * siz - 1) sg[i] = mp(INF, 1);
}
void update(int x, ll val, p64 sg[]) {
sg[x + siz - 1] = mp(val, x);
x += siz - 1;
x /= 2;
while (x != 0) {
sg[x] = min(sg[2 * x], sg[2 * x + 1]);
x /= 2;
}
}
p64 query(int l, int r, p64 sg[]) {
l += siz - 1;
r += siz - 1;
p64 ret = mp(INF, 1);
while (r >= l) {
if (l % 2 == 1) {
ret = min(ret, sg[l++]);
}
if (r % 2 == 0) {
ret = min(ret, sg[r--]);
}
l /= 2;
r /= 2;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> d;
init(sg1);
init(sg2);
FOR(i, 1, n) {
cin >> a[i];
v.pb(mp(a[i], i));
}
sort(v.begin(), v.end());
for (auto u : v) {
auto t1 = query(1, u.se - 1, sg1);
auto t2 = query(u.se + 1, n, sg2);
int i1 = t1.se, i2 = t2.se;
ll w1 = u.fi + d * u.se + t1.fi;
ll w2 = u.fi - d * u.se + t2.fi;
edges.pb(mp(w1, mp(u.se, i1)));
edges.pb(mp(w2, mp(u.se, i2)));
update(u.se, u.fi - d * u.se, sg1);
update(u.se, u.fi + d * u.se, sg2);
}
ll ans = 0;
FOR(i, 1, n) p[i] = i;
FOR(i, 1, n) sz[i] = 1;
sort(edges.begin(), edges.end());
for (auto u : edges) {
if (find(u.se.fi) == find(u.se.se))
continue;
else {
unite(u.se.fi, u.se.se);
ans += u.fi;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define printvector(v, n) \
for (int i = 1; i <= n; i++) \
cout << v[i] << " "; \
cout << ln;
#define printint(v) copy(begin(v), end(v), ostream_iterator<int>(cout, " "))
#define printintv(s, e) copy(s, e, ostream_iterator<int>(cout, " "))
#define clz(a) __builtin_clz(a) // count leading zeroes
#define ctz(a) __builtin_ctz(a) // count trailing zeroes
#define popc(a) \
__builtin_popcount(a) // count set bits (for ints only diff for int64)
// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html for other in built
#define ln "\n"
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define RFOR(i, b, a) for (int i = b; i >= a; i--)
#define dbg(x) cout << #x << " = " << x << ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define setPresent(x, s) (s.find(x) != s.end())
#define sqr(x) x *x
#define siz(v) int(v.size())
const double pi = 3.14159265358979323846;
typedef long long ll;
typedef pair<int, int> p32;
typedef pair<ll, ll> p64;
typedef pair<double, double> pdd;
typedef pair<char, int> pci;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int>> vv32;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
typedef map<int, int> m32;
typedef map<ll, ll> m64;
#pragma GCC optimize("-O2")
template <class T>
using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
const int LM = 2e5;
ll n, d, a[LM + 2], INF = 1e18;
p64 sg1[4 * LM + 5], sg2[4 * LM + 5];
int sz[LM + 2], p[LM + 2], siz = 1;
vector<pair<ll, p32>> edges;
vp64 v;
// in the segtree also store at what index the minimum
// occurs
int find(int x) {
while (p[x] != x)
x = p[x];
return x;
}
void unite(int a, int b) {
a = find(a);
b = find(b);
if (sz[a] < sz[b])
swap(a, b);
p[b] = a;
sz[a] += sz[b];
}
void init(p64 sg[]) {
while (siz < n)
siz *= 2;
FOR(i, 1, 2 * siz - 1) sg[i] = mp(INF, 1);
}
void update(int x, ll val, p64 sg[]) {
sg[x + siz - 1] = mp(val, x);
x += siz - 1;
x /= 2;
while (x != 0) {
sg[x] = min(sg[2 * x], sg[2 * x + 1]);
x /= 2;
}
}
p64 query(int l, int r, p64 sg[]) {
l += siz - 1;
r += siz - 1;
p64 ret = mp(INF, 1);
while (r >= l) {
if (l % 2 == 1) {
ret = min(ret, sg[l++]);
}
if (r % 2 == 0) {
ret = min(ret, sg[r--]);
}
l /= 2;
r /= 2;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> d;
init(sg1);
init(sg2);
FOR(i, 1, n) {
cin >> a[i];
v.pb(mp(a[i], i));
}
sort(v.begin(), v.end());
for (auto u : v) {
auto t1 = query(1, u.se - 1, sg1);
auto t2 = query(u.se + 1, n, sg2);
int i1 = t1.se, i2 = t2.se;
ll w1 = u.fi + d * u.se + t1.fi;
ll w2 = u.fi - d * u.se + t2.fi;
edges.pb(mp(w1, mp(u.se, i1)));
edges.pb(mp(w2, mp(u.se, i2)));
update(u.se, u.fi - d * u.se, sg1);
update(u.se, u.fi + d * u.se, sg2);
}
ll ans = 0;
FOR(i, 1, n) p[i] = i;
FOR(i, 1, n) sz[i] = 1;
sort(edges.begin(), edges.end());
for (auto u : edges) {
if (find(u.se.fi) == find(u.se.se))
continue;
else {
unite(u.se.fi, u.se.se);
ans += u.fi;
}
}
cout << ans << endl;
}
|
replace
| 40 | 41 | 40 | 41 |
0
| |
p03153
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define repf(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define repr(i, a, b) for (ll i = (ll)a; i > (ll)b; i--)
#define repv(x, arr) for (auto &x : arr)
#define all(v) (v).begin(), (v).end()
#define vec(name, num) vector<ll> name((num), 0);
#define mp(a, b) make_pair(a, b)
#define pb(x) push_back(x)
#define F first
#define S second
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<int> vii;
typedef vector<vii> vvii;
const ll mod = 1e9 + 7;
const int infi = 2147483600;
const ll infl = 1e17;
struct SegmentTree {
private:
int N;
vector<ll> node;
ll e;
public:
SegmentTree() {}
SegmentTree(ll e) : e(e) {}
void __init__(int sz) {
N = 1;
while (N < sz)
N *= 2;
node.resize(2 * N - 1, e);
}
void build(vector<ll> &v) {
int sz = (int)(v.size());
__init__(sz);
rep(i, sz) { node[i + N - 1] = v[i]; }
for (int i = N - 2; i >= 0; i--) {
node[i] = min(node[i * 2 + 1], node[i * 2 + 2]);
}
}
void update(int k, ll x) {
k += N - 1;
node[k] = x;
while (k > 0) {
k = (k - 1) / 2;
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
return;
}
ll query(int a, int b) { return query(a, b, 0, 0, N); }
ll query(int a, int b, int k, int l, int r) {
if (b <= l || r <= a)
return e;
if (a <= l && r <= b)
return node[k];
ll vl, vr;
vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
ll show_one(int i) {
if (0 <= i && i < N)
return node[i + N - 1];
return e;
}
int need() {
int k = 0;
while (k < N - 1) {
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
if (node[k] == node[2 * k + 1]) {
k = 2 * k + 1;
}
if (node[k] == node[2 * k + 2]) {
k = 2 * k + 2;
}
}
return k - N + 1;
}
void view() {
repf(k, N - 1, 2 * N - 1) {
if (node[k] == e)
cout << "inf ";
else
cout << node[k] << " ";
}
cout << endl;
return;
}
};
struct UnionFind {
vector<int> root;
int n;
void __init__(int sz) {
n = sz;
root.resize(n, -1);
}
int find(int x) {
if (root[x] >= 0) {
root[x] = find(root[x]);
return root[x];
}
return x;
}
void unit(int a, int b) {
int ra, rb;
ra = find(a);
rb = find(b);
if (ra == rb) {
return;
} else if (root[ra] <= root[rb]) {
root[ra] += root[rb];
root[rb] = ra;
} else {
root[rb] += root[ra];
root[ra] = rb;
}
return;
}
int count() {
set<int> cnt;
rep(i, n) cnt.insert(find(i));
return cnt.size();
}
};
int main() {
ll n, d;
cin >> n >> d;
vll a(n);
rep(i, n) cin >> a[i];
SegmentTree seg(infl);
seg.build(a);
ll ans = 0;
ll cnt = n - 1;
vvll idx(n, vll(2));
rep(i, n) {
idx[i][0] = i;
idx[i][1] = i;
}
while (cnt > 0) {
/*cout << ans;
cout << endl;
seg.view(); */
int k = seg.need();
ll x = seg.show_one(k);
// cout << k << " " << x << " ";
if (k > 0 && seg.show_one(k - 1) < infl) {
ans += seg.show_one(k - 1) + x + d;
seg.update(idx[k - 1][0],
min(x + (k - idx[k - 1][0]) * d, seg.show_one(idx[k - 1][0])));
if (idx[k - 1][0] < k - 1) {
seg.update(k - 1, infl);
}
idx[idx[k][1]][0] = idx[k - 1][0];
idx[k][0] = idx[k - 1][0];
idx[k - 1][1] = idx[k][1];
idx[idx[k - 1][0]][1] = idx[k][1];
cnt--;
}
if (k < n && seg.show_one(k + 1) < infl) {
ans += seg.show_one(k + 1) + x + d;
seg.update(idx[k + 1][1],
min(x + (idx[k + 1][1] - k) * d, seg.show_one(idx[k + 1][1])));
if (idx[k + 1][1] > k + 1) {
seg.update(k + 1, infl);
}
idx[idx[k][0]][1] = idx[k + 1][1];
idx[k][1] = idx[k + 1][1];
idx[idx[k + 1][1]][0] = idx[k][0];
idx[k + 1][0] = idx[k][0];
cnt--;
}
seg.update(k, infl);
}
// rep(i, n) cout << seg.show_one(i) << " ";
// cout << endl;
cout << ans << endl;
// seg.view();
}
|
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define repf(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define repr(i, a, b) for (ll i = (ll)a; i > (ll)b; i--)
#define repv(x, arr) for (auto &x : arr)
#define all(v) (v).begin(), (v).end()
#define vec(name, num) vector<ll> name((num), 0);
#define mp(a, b) make_pair(a, b)
#define pb(x) push_back(x)
#define F first
#define S second
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<int> vii;
typedef vector<vii> vvii;
const ll mod = 1e9 + 7;
const int infi = 2147483600;
const ll infl = 1e17;
struct SegmentTree {
private:
int N;
vector<ll> node;
ll e;
public:
SegmentTree() {}
SegmentTree(ll e) : e(e) {}
void __init__(int sz) {
N = 1;
while (N < sz)
N *= 2;
node.resize(2 * N - 1, e);
}
void build(vector<ll> &v) {
int sz = (int)(v.size());
__init__(sz);
rep(i, sz) { node[i + N - 1] = v[i]; }
for (int i = N - 2; i >= 0; i--) {
node[i] = min(node[i * 2 + 1], node[i * 2 + 2]);
}
}
void update(int k, ll x) {
k += N - 1;
node[k] = x;
while (k > 0) {
k = (k - 1) / 2;
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
return;
}
ll query(int a, int b) { return query(a, b, 0, 0, N); }
ll query(int a, int b, int k, int l, int r) {
if (b <= l || r <= a)
return e;
if (a <= l && r <= b)
return node[k];
ll vl, vr;
vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
ll show_one(int i) {
if (0 <= i && i < N)
return node[i + N - 1];
return e;
}
int need() {
int k = 0;
while (k < N - 1) {
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
if (node[k] == node[2 * k + 1]) {
k = 2 * k + 1;
} else if (node[k] == node[2 * k + 2]) {
k = 2 * k + 2;
}
}
return k - N + 1;
}
void view() {
repf(k, N - 1, 2 * N - 1) {
if (node[k] == e)
cout << "inf ";
else
cout << node[k] << " ";
}
cout << endl;
return;
}
};
struct UnionFind {
vector<int> root;
int n;
void __init__(int sz) {
n = sz;
root.resize(n, -1);
}
int find(int x) {
if (root[x] >= 0) {
root[x] = find(root[x]);
return root[x];
}
return x;
}
void unit(int a, int b) {
int ra, rb;
ra = find(a);
rb = find(b);
if (ra == rb) {
return;
} else if (root[ra] <= root[rb]) {
root[ra] += root[rb];
root[rb] = ra;
} else {
root[rb] += root[ra];
root[ra] = rb;
}
return;
}
int count() {
set<int> cnt;
rep(i, n) cnt.insert(find(i));
return cnt.size();
}
};
int main() {
ll n, d;
cin >> n >> d;
vll a(n);
rep(i, n) cin >> a[i];
SegmentTree seg(infl);
seg.build(a);
ll ans = 0;
ll cnt = n - 1;
vvll idx(n, vll(2));
rep(i, n) {
idx[i][0] = i;
idx[i][1] = i;
}
while (cnt > 0) {
/*cout << ans;
cout << endl;
seg.view(); */
int k = seg.need();
ll x = seg.show_one(k);
// cout << k << " " << x << " ";
if (k > 0 && seg.show_one(k - 1) < infl) {
ans += seg.show_one(k - 1) + x + d;
seg.update(idx[k - 1][0],
min(x + (k - idx[k - 1][0]) * d, seg.show_one(idx[k - 1][0])));
if (idx[k - 1][0] < k - 1) {
seg.update(k - 1, infl);
}
idx[idx[k][1]][0] = idx[k - 1][0];
idx[k][0] = idx[k - 1][0];
idx[k - 1][1] = idx[k][1];
idx[idx[k - 1][0]][1] = idx[k][1];
cnt--;
}
if (k < n && seg.show_one(k + 1) < infl) {
ans += seg.show_one(k + 1) + x + d;
seg.update(idx[k + 1][1],
min(x + (idx[k + 1][1] - k) * d, seg.show_one(idx[k + 1][1])));
if (idx[k + 1][1] > k + 1) {
seg.update(k + 1, infl);
}
idx[idx[k][0]][1] = idx[k + 1][1];
idx[k][1] = idx[k + 1][1];
idx[idx[k + 1][1]][0] = idx[k][0];
idx[k + 1][0] = idx[k][0];
cnt--;
}
seg.update(k, infl);
}
// rep(i, n) cout << seg.show_one(i) << " ";
// cout << endl;
cout << ans << endl;
// seg.view();
}
|
replace
| 92 | 94 | 92 | 93 |
0
| |
p03153
|
C++
|
Time Limit Exceeded
|
// MLEが動かない
// セグフォは関数内で要素のでかい配列を定義しているから
// todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
// 現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define double long double
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
struct Tri {
int f, s, t;
Tri() { f = -1, s = -1, t = -1; }
Tri(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const Tri &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const Tri &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
int operator[](int i) {
assert(i < 3);
switch (i) {
case 0:
return f;
break;
case 1:
return s;
break;
default:
return t;
break;
}
}
};
// 別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vd = vector<double>;
#define vvd(a, b, c) vec<vd> a(b, vd(c))
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
// using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using vt = vector<Tri>;
#define vvt(a, b, c) vec<vt> a(b, vt(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define mmap multimap
#define F first
#define S second
// 定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// 配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
// コンテナ
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
// 繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
// 入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add2(a, b, n) rep(i, n) a.pb(in()), b.pb(in());
#define add2d(a, b, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1);
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define add3d(a, b, c, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addn(a, n) \
a.resize(n); \
na(a, n);
#define addnd(a, n) \
a.resize(n); \
na(a, n); \
rep(i, n) a[i]--;
// 出力
template <class T> void out(vector<T> x) {
for (auto &&v : x)
cout << v << " ";
cout << "" << endl;
}
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
// デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
// よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
// 順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
// 単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
// 便利関数
void OLE() {
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void TLE() {
int a = 1;
while (a)
cout << a << endl;
}
void RE() {
int a = 1 / (x4[0] / MOD);
cout << a << endl;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
OLE();
return -1;
} else
return (a + b - 1) / b;
}
ll sqrt(ll a) {
if (a < 0)
OLE();
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
int keta(int v) {
int cou = 0;
while (v) {
cou++;
v %= 10;
}
return cou;
}
template <class T> void imo(vector<T> &v) {
int n = v.size();
rep(i, n - 1) v[i + 1] += v[i];
}
// 変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(vector<T> a) { return *min_element(all(a)); }
template <class T> T max(vector<T> a) { return *max_element(all(a)); }
template <class T> T min(T a[]) {
T res = a[0];
rep(i, sz(a)) chmin(res, a[i]);
return res;
}
template <class T> T max(T a[]) {
T res = a[0];
rep(i, sz(a)) chmax(res, a[i]);
return res;
}
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
/// 要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; // 最下位の1
ll y = mask + x; // 連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoal(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
int ctoi(char c) { return c - '0'; }
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n, root = -1;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
bool isleaf(int v) {
assert(root != -1);
return g[v].size() == 1 && g[v][0].from != root;
}
vector<edge<T>> operator[](int i) { return g[i]; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
using ve = vector<edge<int>>;
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
if (!(0 <= s && s < g.n))
OLE();
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
// たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
// 機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
template <typename T> void insert(set<T> &v, initializer_list<T> list) {
for (auto &&va : list)
v.insert(va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
// 閉路がなければtrue
bool topo(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.to] == 0) st.push(e.to);
}
return res.size() == n;
}
// 辞書順最小 トポロジカルソート
bool topos(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
set<int> st;
rep(i, n) if (nyu[i] == 0) st.insert(i);
while (st.size()) {
int i = *st.begin();
st.erase(st.begin());
res.pb(i);
fora(e, g[i]) if (--nyu[e.to] == 0) st.insert(e.to);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
int n, k, m, h, w, x, y, q, r;
int res;
vi a, b, c;
int d;
digraph<> g(0);
void rec(int l, int r) {
if (r - l <= 1)
return;
int mid = (l + r) / 2;
int lmin = LINF, rmin = LINF;
int li = 0, ri = 0;
rep(i, mid) {
if (lmin > -d * i + a[i]) {
lmin = -d * i + a[i];
li = i;
}
}
rep(i, mid, r) {
if (rmin > d * i + a[i]) {
rmin = d * i + a[i];
ri = i;
}
}
// 左たちから右の一転へ
rep(i, l, mid) { g.add(i, ri, rmin + a[i] - d * i); }
rep(i, mid, r) { g.add(li, i, lmin + a[i] + d * i); }
rec(l, mid);
rec(mid, r);
}
signed main() {
cin >> n >> d;
addn(a, n);
g.resize(n);
rec(0, n);
UnionFind ut(n);
sort(g.edges);
for (auto &&e : g.edges) {
if (ut.same(e.from, e.to))
continue;
ut.unite(e.from, e.to);
res += e.cost;
}
cout << res << endl;
return 0;
}
|
// MLEが動かない
// セグフォは関数内で要素のでかい配列を定義しているから
// todo idef DEBUGで、境界チェック付きのvectorを作りたい
// http://marycore.jp/prog/cpp/class-extension-methods/
// 現状ifdef DEBUG が何故か動かないので出来ない
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define double long double
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
};
} hoee;
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
struct Tri {
int f, s, t;
Tri() { f = -1, s = -1, t = -1; }
Tri(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const Tri &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const Tri &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
int operator[](int i) {
assert(i < 3);
switch (i) {
case 0:
return f;
break;
case 1:
return s;
break;
default:
return t;
break;
}
}
};
// 別名
#define ull unsigned long long
#define vec vector
#define con continue
#define bre break
#define brk break
#define is ==
#define eq ==
#define no !=
#define ne !=
#define dif !=
#define df !=
#define rs resize
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
using vi = vector<int>;
#define vvi(a, b, c) vec<vi> a(b, vi(c))
using vb = vector<bool>;
#define vvb(a, b, c) vec<vb> a(b, vb(c))
using vs = vector<string>;
#define vvs(a, b, c) vec<vs> a(b, vs(c))
using vl = vector<ll>;
#define vvl(a, b, c) vec<vl> a(b, vl(c))
using vd = vector<double>;
#define vvd(a, b, c) vec<vd> a(b, vd(c))
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
using vc = vector<char>;
#define vvc(a, b, c) vec<vc> a(b, vc(c))
using P = pair<int, int>;
// using T = tuple<int, int, int>;
using vp = vector<P>;
#define vvp(a, b, c) vec<vp> a(b, vp(c))
using vt = vector<Tri>;
#define vvt(a, b, c) vec<vt> a(b, vt(c))
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define mmap multimap
#define F first
#define S second
// 定数
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int INF = (int)1e9 + 100;
const ll LINF = (ll)1e18 + 100;
const double EPS = 1e-9;
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// 配列
#define sz(a) (sizeof(a) / sizeof(a[0]))
// コンテナ
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); };
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
// 繰り返し
#define _overloadrep(_1, _2, _3, name, ...) name
#define _rep(i, n) for (int i = 0; i < n; i++)
#define repi(i, m, n) for (int i = m; i < n; i++)
#define rep(...) _overloadrep(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m; i >= n; i--)
#define rer(...) _overloadrep(__VA_ARGS__, reri, _rer, )(__VA_ARGS__)
#define fora(a, b) for (auto &&a : b)
#define forr(a, b) for_each(map.rbegin(),map.rend(),[](auto&& a)
#define rea(a, b) for (auto &&a : b)
#define repa(a, b) for (auto &&a : b)
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, U v) {
rep(i, a.size()) a[i] = v;
}
template <class T, class U> void fill(vector<vector<T>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) a[i][j] = v;
}
template <class T, class U> void fill(vector<vector<vector<T>>> &a, U v) {
rep(i, a.size()) rep(j, a[0].size()) rep(k, a[0][0].size()) a[i][j][k] = v;
}
#define arcpy(a, b) memcpy(a, b, sizeof(b))
// 入力
template <typename T = int> T in() {
T x;
cin >> x;
return (x);
}
string sin() { return in<string>(); }
double din() { return in<double>(); }
ll lin() { return in<ll>(); }
#define na(a, n) rep(i, n) cin >> a[i];
#define nad(a, n) rep(i, n) cin >> a[i], a[i]--;
#define na3(a, b, c, n) rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define add2(a, b, n) rep(i, n) a.pb(in()), b.pb(in());
#define add2d(a, b, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1);
#define add3(a, b, c, n) rep(i, n) a.pb(in()), b.pb(in()), c.pb(in());
#define add3d(a, b, c, n) rep(i, n) a.pb(in() - 1), b.pb(in() - 1), c.pb(in());
#define na2(a, b, n) rep(i, n) cin >> a[i] >> b[i];
#define nt(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi];
#define ntd(a, h, w) rep(hi, h) rep(wi, w) cin >> a[hi][wi], a[hi][wi]--;
#define ntp(a, h, w) \
fill(a, '#'); \
rep(hi, 1, h + 1) rep(wi, 1, w + 1) cin >> a[hi][wi];
#define addn(a, n) \
a.resize(n); \
na(a, n);
#define addnd(a, n) \
a.resize(n); \
na(a, n); \
rep(i, n) a[i]--;
// 出力
template <class T> void out(vector<T> x) {
for (auto &&v : x)
cout << v << " ";
cout << "" << endl;
}
template <class T> void out(T x) {
if (typeid(x) == typeid(double))
cout << fixed << setprecision(10) << x << endl;
else
cout << x << endl;
}
// デバッグ
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
// 境界チェック付きvector
namespace std_vector_bounds_checking {
using namespace std;
template <class T, class A = std::allocator<T>>
struct vector : std::vector<T, A> {
using std::vector<T, A>::vector;
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
return this->at(n);
}
};
} // namespace std_vector_bounds_checking
// よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
// 順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.F;
res[i].push_back(r);
for (auto &&v : p.S) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
// MOD関連
ll MOD = (int)1e9 + 7;
int mpow(int v, ll a) {
ll x = v, n = a, res = 1;
while (n) {
if (n & 1)
res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
class mint {
private:
ll v;
public:
static ll mod(ll a) { return (a % MOD + MOD) % MOD; }
mint(ll a = 0) { this->v = mod(a); };
mint(const mint &a) { v = a.v; }
mint operator+(const mint &a) { return mint(v + a.v); }
mint operator+(const ll a) { return mint(v + a % MOD); }
mint operator+(const signed a) { return mint(v + a % MOD); }
friend mint operator+(const ll a, const mint &b) {
return mint(a % MOD + b.v);
}
void operator+=(const mint &a) { v = (v + a.v) % MOD; }
void operator+=(const ll a) { v = mod(v + a % MOD); }
void operator+=(const signed a) { v = mod(v + a % MOD); }
friend void operator+=(ll &a, const mint &b) { a = mod(a % MOD + b.v); }
mint operator-(const mint &a) { return mint(v - a.v); }
mint operator-(const ll a) { return mint(v - a % MOD); }
mint operator-(const signed a) { return mint(v - a % MOD); }
friend mint operator-(const ll a, const mint &b) {
return mint(a % MOD - b.v);
}
void operator-=(const mint &a) { v = mod(v - a.v); }
void operator-=(const ll a) { v = mod(v - a % MOD); }
void operator-=(const signed a) { v = mod(v - a % MOD); }
friend void operator-=(ll &a, const mint &b) { a = mod(a % MOD - b.v); }
mint operator*(const mint &a) { return mint(v * a.v); }
mint operator*(const ll a) { return mint(v * (a % MOD)); }
mint operator*(const signed a) { return mint(v * (a % MOD)); }
friend mint operator*(const ll a, const mint &b) {
return mint(a % MOD * b.v);
}
void operator*=(const mint &a) { v = (v * a.v) % MOD; }
void operator*=(const ll a) { v = mod(v * (a % MOD)); }
void operator*=(const signed a) { v = mod(v * (a % MOD)); }
friend void operator*=(ll &a, const mint &b) { a = mod(a % MOD * b.v); }
mint operator/(const mint &a);
mint operator/(const ll a);
mint operator/(const signed a);
friend mint operator/(const ll a, const mint &b);
void operator/=(const mint &a);
void operator/=(const ll a);
void operator/=(const signed a);
friend void operator/=(ll &a, const mint &b);
mint operator^(const mint &a) { return mpow(v, a.v); };
mint operator^(const ll a) { return mpow(v, a); };
mint operator^(const signed a) { return mpow(v, a); };
friend mint operator^(const ll a, const mint &b) { return mpow(a, b.v); };
void operator^=(const mint &a) { v = mpow(v, a.v); }
void operator^=(const ll a) { v = mpow(v, a); }
void operator^=(const signed a) { v = mpow(v, a); }
// 単項演算子
mint operator+() { return *this; }
mint operator++() {
v++;
return *this;
}
mint operator++(signed d) {
mint res = *this;
v++;
return res;
}
mint operator-() { return operator*(-1); }
mint operator--() {
v++;
return *this;
}
void operator--(signed d) {
mint res = *this;
v++;
}
bool operator==(mint &a) { return v == a.v; }
bool operator==(signed a) { return v == a; }
friend bool operator==(signed a, mint &b) { return a == b.v; }
bool operator!=(mint &a) { return v != a.v; }
bool operator!=(signed a) { return v != a; }
friend bool operator!=(signed a, mint &b) { return a != b.v; }
operator int() { return v; }
};
const int setModMax = 510000;
mint fac[setModMax], finv[setModMax], inv[setModMax];
void setMod() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < setModMax; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
mint minv(ll a) {
if (fac[0] == 0)
setMod();
if (a < setModMax)
return inv[a];
a %= MOD;
ll b = MOD, x = 1, y = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
x -= t * y;
swap(x, y);
}
return (x % MOD + MOD) % MOD;
}
mint mint::operator/(const mint &a) { return mint(v * minv(a.v)); }
mint mint::operator/(const ll a) { return mint(v * minv(a)); }
mint mint::operator/(const signed a) { return mint(v * minv(a)); }
mint operator/(const ll a, const mint &b) { return mint(a % MOD * minv(b.v)); }
void mint::operator/=(const mint &a) { v = (v * minv(a.v)) % MOD; }
void mint::operator/=(const ll a) { v = mod(v * minv(a)); }
void mint::operator/=(const signed a) { v = mod(v * minv(a)); }
void operator/=(ll &a, const mint &b) { a = mint::mod(a % MOD * minv(b.v)); }
using vm = vector<mint>;
#define vvm(a, b, c) vec<vm> a(b, vm(c))
bool isPrime[4010101];
vi primes;
void setPrime() {
fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= sqrt(sz(isPrime)) + 5; ++i) {
if (!isPrime[i])
continue;
for (int j = 2; i * j < sz(isPrime); ++j) {
isPrime[i * j] = false;
}
}
rep(i, sz(isPrime)) if (isPrime[i]) primes.pb(i);
}
mint com(ll n, ll r) {
if (n < r || n < 0 || r < 0)
return 0;
if (fac[0] == 0)
setMod();
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
// 便利関数
void OLE() {
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void TLE() {
int a = 1;
while (a)
cout << a << endl;
}
void RE() {
int a = 1 / (x4[0] / MOD);
cout << a << endl;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
bool equal(double a, double b) { return fabs(a - b) < EPS; }
ll reverse(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
OLE();
return -1;
} else
return (a + b - 1) / b;
}
ll sqrt(ll a) {
if (a < 0)
OLE();
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
vi divisors(int v) {
vi res;
for (int i = 1; i <= sqrt(v); ++i) {
if (v % i == 0) {
res.pb(i);
if (i != v / i)
res.pb(v / i);
}
}
return res;
}
vi factorization(int v) {
int tv = v;
vi res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
if (v % p == 0)
res.push_back(p);
while (v % p == 0) {
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.pb(v);
return res;
}
unordered_map<int, int> factorizationMap(int v) {
int tv = v;
unordered_map<int, int> res;
if (!isPrime[2])
setPrime();
for (auto &&p : primes) {
while (v % p == 0) {
res[p]++;
v /= p;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res[v]++;
return res;
}
int get(int a, int keta) {
a /= (int)pow(10, keta);
return a % 10;
}
int keta(int v) {
int cou = 0;
while (v) {
cou++;
v %= 10;
}
return cou;
}
template <class T> void imo(vector<T> &v) {
int n = v.size();
rep(i, n - 1) v[i + 1] += v[i];
}
// 変換系
template <class T, class U> vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.F);
return res;
}
template <class T, class U> vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
template <class T, class U> vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.S);
return res;
}
vi list(int a) {
vi res;
while (a) {
res.insert(res.begin(), a % 10);
a /= 10;
}
return res;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> T min(T a, signed b) { return a < b ? a : b; }
template <class T> T max(T a, signed b) { return a < b ? b : a; }
template <class T> T min(vector<T> a) { return *min_element(all(a)); }
template <class T> T max(vector<T> a) { return *max_element(all(a)); }
template <class T> T min(T a[]) {
T res = a[0];
rep(i, sz(a)) chmin(res, a[i]);
return res;
}
template <class T> T max(T a[]) {
T res = a[0];
rep(i, sz(a)) chmax(res, a[i]);
return res;
}
template <class T> T sum(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 0;
rep(i, min((int)len, (int)v.size())) res += v[i];
return res;
}
/// 要素が0の時、返り値は0か1か
template <class T> T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
rep(i, min((int)len, (int)v.size())) res *= v[i];
return res;
}
void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> vector<T> ruiv(vector<T> &a) {
vector<T> res(a.size() + 1);
rep(i, a.size()) res[i + 1] = res[i] + a[i];
return res;
}
template <class T> void plus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u += v;
}
template <class T> void minu(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
template <class T> void minus(vector<T> &a, T v = 1) {
for (auto &&u : a)
u -= v;
}
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
ll u(ll a) { return a < 0 ? 0 : a; }
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmin(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chmax(res, *max_element(all(a[i])));
return res;
}
bool bget(ll m, int keta) { return (m >> keta) & 1; }
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
inline ll bit(int n) { return (1LL << (n)); }
inline ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int bcou(ll m) {
return __builtin_popcount(m & 0xFFFFFFFF) + __builtin_popcount(m >> 32);
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; // 最下位の1
ll y = mask + x; // 連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoal(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
int ctoi(char c) { return c - '0'; }
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
UNIQUE(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
template <class T> struct edge {
int from, to;
T cost;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: from(f), to(t), cost(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return cost < b.cost; }
bool operator>(const edge &b) const { return cost > b.cost; }
};
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n, root = -1;
graph(int n) : n(n) {
g.resize(n);
_used.resize(n);
}
void clear() {
g.clear();
edges.clear();
}
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
bool isleaf(int v) {
assert(root != -1);
return g[v].size() == 1 && g[v][0].from != root;
}
vector<edge<T>> operator[](int i) { return g[i]; }
virtual void add(int from, int to, T cost, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, id, ty);
g[t].emplace_back(t, f, cost, id + 1, ty);
edges.emplace_back(f, t, cost, id, ty);
edges.emplace_back(t, f, cost, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.from, t = e.to, ty = e.type;
T cost = e.cost;
add(f, t, cost, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T cost = 1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n))
OLE();
int id = edges.size();
g[f].emplace_back(f, t, cost, ty, id);
edges.emplace_back(f, t, cost, ty, id);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
};
using ve = vector<edge<int>>;
template <class T> bool nibu(const graph<T> &g) {
UnionFind uf(g.n * 2);
for (auto &&e : g.edges)
uf.unite(e.f, e.t + g.n), uf.unite(e.f + g.n, e.t);
return !uf.same(0, g.n);
}
template <class T> vector<T> dijkstra(const graph<T> &g, int s) {
if (!(0 <= s && s < g.n))
OLE();
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().F;
int i = q.top().S;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.to;
T cost = nowc + e.cost;
if (dis[to] > cost) {
dis[to] = cost;
q.emplace(dis[to], to);
}
}
}
// たどり着かないなら-1
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
// 機能拡張
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void insert(vector<T> &v, unsigned int i, T t) {
v.insert(v.begin() + i, t);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T>
void insert(vector<T> &v, unsigned int i, initializer_list<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
template <typename T> void insert(set<T> &v, initializer_list<T> list) {
for (auto &&va : list)
v.insert(va);
}
int mod(int a, int m) { return (a % m + m) % m; }
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
// 閉路がなければtrue
bool topo(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.to] == 0) st.push(e.to);
}
return res.size() == n;
}
// 辞書順最小 トポロジカルソート
bool topos(vi &res, digraph<int> g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.to]++;
set<int> st;
rep(i, n) if (nyu[i] == 0) st.insert(i);
while (st.size()) {
int i = *st.begin();
st.erase(st.begin());
res.pb(i);
fora(e, g[i]) if (--nyu[e.to] == 0) st.insert(e.to);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
int n, k, m, h, w, x, y, q, r;
int res;
vi a, b, c;
int d;
digraph<> g(0);
void rec(int l, int r) {
if (r - l <= 1)
return;
int mid = (l + r) / 2;
int lmin = LINF, rmin = LINF;
int li = 0, ri = 0;
rep(i, l, mid) {
if (lmin > -d * i + a[i]) {
lmin = -d * i + a[i];
li = i;
}
}
rep(i, mid, r) {
if (rmin > d * i + a[i]) {
rmin = d * i + a[i];
ri = i;
}
}
// 左たちから右の一転へ
rep(i, l, mid) { g.add(i, ri, rmin + a[i] - d * i); }
rep(i, mid, r) { g.add(li, i, lmin + a[i] + d * i); }
rec(l, mid);
rec(mid, r);
}
signed main() {
cin >> n >> d;
addn(a, n);
g.resize(n);
rec(0, n);
UnionFind ut(n);
sort(g.edges);
for (auto &&e : g.edges) {
if (ut.same(e.from, e.to))
continue;
ut.unite(e.from, e.to);
res += e.cost;
}
cout << res << endl;
return 0;
}
|
replace
| 1,247 | 1,248 | 1,247 | 1,248 |
TLE
| |
p03153
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
struct node {
int u, v;
ll w;
bool operator<(const node &o) const { return w < o.w; }
} e[6000005];
int n, cot = 0, a[200005], fail[200005];
ll d;
void add(int l, int r) {
if (l >= r)
return;
int m = l + r >> 1;
ll mi = 1e18, pos;
for (int i = l; i <= m; i++) {
ll f = a[i] - d * i;
if (f < mi)
mi = f, pos = i;
}
for (int i = m + 1; i <= r; i++)
e[cot].u = pos, e[cot].v = i, e[cot++].w = a[i] + a[pos] + d * (i - pos);
mi = 1e18;
for (int i = m + 1; i <= r; i++) {
ll f = a[i] + d * i;
if (f < mi)
mi = f, pos = i;
}
for (int i = 1; i <= m; i++)
e[cot].u = i, e[cot].v = pos, e[cot++].w = a[i] + a[pos] + d * (pos - i);
add(l, m);
add(m + 1, r);
}
int get_fa(int x) { return fail[x] == x ? x : fail[x] = get_fa(fail[x]); }
ll kruskal() {
sort(e, e + cot);
for (int i = 1; i <= 200000; i++)
fail[i] = i;
ll ans = 0;
for (int i = 0; i < cot; i++) {
int fu = get_fa(e[i].u), fv = get_fa(e[i].v);
if (fu == fv)
continue;
fail[fu] = fv;
ans += e[i].w;
}
return ans;
}
int main() {
scanf("%d%lld", &n, &d);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
add(1, n);
printf("%lld\n", kruskal());
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
struct node {
int u, v;
ll w;
bool operator<(const node &o) const { return w < o.w; }
} e[6000005];
int n, cot = 0, a[200005], fail[200005];
ll d;
void add(int l, int r) {
if (l >= r)
return;
int m = l + r >> 1;
ll mi = 1e18, pos;
for (int i = l; i <= m; i++) {
ll f = a[i] - d * i;
if (f < mi)
mi = f, pos = i;
}
for (int i = m + 1; i <= r; i++)
e[cot].u = pos, e[cot].v = i, e[cot++].w = a[i] + a[pos] + d * (i - pos);
mi = 1e18;
for (int i = m + 1; i <= r; i++) {
ll f = a[i] + d * i;
if (f < mi)
mi = f, pos = i;
}
for (int i = l; i <= m; i++)
e[cot].u = i, e[cot].v = pos, e[cot++].w = a[i] + a[pos] + d * (pos - i);
add(l, m);
add(m + 1, r);
}
int get_fa(int x) { return fail[x] == x ? x : fail[x] = get_fa(fail[x]); }
ll kruskal() {
sort(e, e + cot);
for (int i = 1; i <= 200000; i++)
fail[i] = i;
ll ans = 0;
for (int i = 0; i < cot; i++) {
int fu = get_fa(e[i].u), fv = get_fa(e[i].v);
if (fu == fv)
continue;
fail[fu] = fv;
ans += e[i].w;
}
return ans;
}
int main() {
scanf("%d%lld", &n, &d);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
add(1, n);
printf("%lld\n", kruskal());
}
|
replace
| 28 | 29 | 28 | 29 |
0
| |
p03154
|
C++
|
Runtime Error
|
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
const int maxSize = 2000001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for (int i = 0; i < 2; i++)
inv[i] = fact[i] = factInv[i] = 1;
for (int i = 2; i < maxSize; i++) {
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i - 1] * i % MOD;
factInv[i] = factInv[i - 1] * inv[i] % MOD;
}
auto comb = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD * factInv[r] % MOD;
};
auto perm = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD;
};
int H, W, K;
while (cin >> H >> W >> K) {
long long res = K;
for (int i = 0; i < K; i++) {
long long add = 0;
add += inv[H + W] * (W + H) % MOD;
add +=
2 * inv[H + W] * i % MOD * inv[H + W - 1] % MOD * W % MOD * H % MOD;
add = (add * (K - i)) % MOD;
res = (res + add) % MOD;
}
res = res * perm(H + W, K) % MOD;
cout << res << endl;
}
}
|
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
const int maxSize = 20000001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for (int i = 0; i < 2; i++)
inv[i] = fact[i] = factInv[i] = 1;
for (int i = 2; i < maxSize; i++) {
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i - 1] * i % MOD;
factInv[i] = factInv[i - 1] * inv[i] % MOD;
}
auto comb = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD * factInv[r] % MOD;
};
auto perm = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD;
};
int H, W, K;
while (cin >> H >> W >> K) {
long long res = K;
for (int i = 0; i < K; i++) {
long long add = 0;
add += inv[H + W] * (W + H) % MOD;
add +=
2 * inv[H + W] * i % MOD * inv[H + W - 1] % MOD * W % MOD * H % MOD;
add = (add * (K - i)) % MOD;
res = (res + add) % MOD;
}
res = res * perm(H + W, K) % MOD;
cout << res << endl;
}
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p03154
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mp make_pair
#define si(x) int(x.size())
const int mod = 1000000007, MAX = 2000005, INF = 1 << 30;
ll inv[MAX], fac[MAX], finv[MAX];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fac[i] = fac[i - 1] * (ll)i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll comb(ll a, ll b) {
if (a < b)
return 0;
return fac[a] * (finv[b] * finv[a - b] % mod) % mod;
}
ll perm(ll a, ll b) {
if (a < b)
return 0;
return fac[a] * finv[a - b] % mod;
}
int main() {
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
make();
ll H, W, K;
cin >> H >> W >> K;
ll ans = 0;
ans += perm(H + W, K) * K % mod;
for (int t = 1; t <= K; t++) {
ans += (H + W) * perm(H + W - 1, K - 1) % mod * (K + 1 - t) % mod;
ans %= mod;
}
for (int t = 2; t <= K; t++) {
ans += (H * W * 2) % mod * (t - 1) % mod * perm(H + W - 2, K - 2) % mod *
(K + 1 - t) % mod;
ans %= mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mp make_pair
#define si(x) int(x.size())
const int mod = 1000000007, MAX = 20000005, INF = 1 << 30;
ll inv[MAX], fac[MAX], finv[MAX];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fac[i] = fac[i - 1] * (ll)i % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll comb(ll a, ll b) {
if (a < b)
return 0;
return fac[a] * (finv[b] * finv[a - b] % mod) % mod;
}
ll perm(ll a, ll b) {
if (a < b)
return 0;
return fac[a] * finv[a - b] % mod;
}
int main() {
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
make();
ll H, W, K;
cin >> H >> W >> K;
ll ans = 0;
ans += perm(H + W, K) * K % mod;
for (int t = 1; t <= K; t++) {
ans += (H + W) * perm(H + W - 1, K - 1) % mod * (K + 1 - t) % mod;
ans %= mod;
}
for (int t = 2; t <= K; t++) {
ans += (H * W * 2) % mod * (t - 1) % mod * perm(H + W - 2, K - 2) % mod *
(K + 1 - t) % mod;
ans %= mod;
}
cout << ans << endl;
}
|
replace
| 22 | 23 | 22 | 23 |
0
| |
p03154
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define all(a) a.begin(), a.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pb push_back
#define debug(x) cerr << #x << ':' << x << '\n'
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
typedef complex<ld> com;
constexpr int inf = 1000000010;
constexpr ll INF = 1000000000000000010;
constexpr ld eps = 1e-12;
constexpr ld pi = 3.141592653589793238;
template <class T, class U> inline bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> inline bool chmin(T &a, const U &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr ll mod = 1000000007;
vector<vector<ll>> mat_mul(vector<vector<ll>> a, vector<vector<ll>> b) {
int n = a.size();
vector<vector<ll>> ans(n, vector<ll>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
ans[i][j] += a[i][k] * b[k][j];
ans[i][j] %= mod;
}
}
}
return ans;
}
vector<vector<ll>> mat_pow(vector<vector<ll>> a, ll b) {
int n = a.size();
vector<vector<ll>> ans(n, vector<ll>(n));
for (int i = 0; i < n; i++)
ans[i][i] = 1;
while (b) {
if (b & 1)
ans = mat_mul(ans, a);
a = mat_mul(a, a);
b >>= 1;
}
return ans;
}
vector<ll> fac, inv, facinv;
void modcalc(int modsize) {
fac.resize(modsize);
inv.resize(modsize);
facinv.resize(modsize);
fac[0] = 1;
fac[1] = 1;
inv[1] = 1;
facinv[0] = 1;
facinv[1] = 1;
for (ll i = 2; i < modsize; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
ll modinv(ll a) {
a %= mod;
if (a == 0)
abort();
if (a < (ll)inv.size())
return inv[a];
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
ll modpow(ll a, ll b, ll m = mod) {
ll ans = 1;
a %= m;
while (b) {
if (b & 1)
ans = ans * a % m;
a = a * a % m;
b >>= 1;
}
return ans;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[n - k] % mod;
}
ll modhom(ll n, ll k) {
if (n < 0 || k < 0 || n == 0 && k > 0)
return 0;
if (n == 0 && k == 0)
return 1;
return fac[n + k - 1] * facinv[k] % mod * facinv[n - 1] % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
modcalc(10000010);
ll h, w, k;
cin >> h >> w >> k;
vector<vector<ll>> mat = {
{1, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 1}, {0, 0, 0, 1}};
mat = mat_pow(mat, k);
ll val = (modcomb(h + w, h) + 2 * modcomb(h + w - 2, h - 1)) % mod;
ll ans = 0;
ans += modcomb(h + w, h) * 2 * mat[0][1] % mod;
ans += val * mat[0][2] % mod;
ans += (mod + val - modcomb(h + w, h)) * mat[0][3] % mod;
ans %= mod;
ans *= modinv(modcomb(h + w, h));
ans %= mod;
ans *= modperm(h + w, k);
ans %= mod;
cout << ans << '\n';
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define all(a) a.begin(), a.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pb push_back
#define debug(x) cerr << #x << ':' << x << '\n'
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
typedef complex<ld> com;
constexpr int inf = 1000000010;
constexpr ll INF = 1000000000000000010;
constexpr ld eps = 1e-12;
constexpr ld pi = 3.141592653589793238;
template <class T, class U> inline bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> inline bool chmin(T &a, const U &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr ll mod = 1000000007;
vector<vector<ll>> mat_mul(vector<vector<ll>> a, vector<vector<ll>> b) {
int n = a.size();
vector<vector<ll>> ans(n, vector<ll>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
ans[i][j] += a[i][k] * b[k][j];
ans[i][j] %= mod;
}
}
}
return ans;
}
vector<vector<ll>> mat_pow(vector<vector<ll>> a, ll b) {
int n = a.size();
vector<vector<ll>> ans(n, vector<ll>(n));
for (int i = 0; i < n; i++)
ans[i][i] = 1;
while (b) {
if (b & 1)
ans = mat_mul(ans, a);
a = mat_mul(a, a);
b >>= 1;
}
return ans;
}
vector<ll> fac, inv, facinv;
void modcalc(int modsize) {
fac.resize(modsize);
inv.resize(modsize);
facinv.resize(modsize);
fac[0] = 1;
fac[1] = 1;
inv[1] = 1;
facinv[0] = 1;
facinv[1] = 1;
for (ll i = 2; i < modsize; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
ll modinv(ll a) {
a %= mod;
if (a == 0)
abort();
if (a < (ll)inv.size())
return inv[a];
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
ll modpow(ll a, ll b, ll m = mod) {
ll ans = 1;
a %= m;
while (b) {
if (b & 1)
ans = ans * a % m;
a = a * a % m;
b >>= 1;
}
return ans;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[n - k] % mod;
}
ll modhom(ll n, ll k) {
if (n < 0 || k < 0 || n == 0 && k > 0)
return 0;
if (n == 0 && k == 0)
return 1;
return fac[n + k - 1] * facinv[k] % mod * facinv[n - 1] % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
modcalc(20000010);
ll h, w, k;
cin >> h >> w >> k;
vector<vector<ll>> mat = {
{1, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 1}, {0, 0, 0, 1}};
mat = mat_pow(mat, k);
ll val = (modcomb(h + w, h) + 2 * modcomb(h + w - 2, h - 1)) % mod;
ll ans = 0;
ans += modcomb(h + w, h) * 2 * mat[0][1] % mod;
ans += val * mat[0][2] % mod;
ans += (mod + val - modcomb(h + w, h)) * mat[0][3] % mod;
ans %= mod;
ans *= modinv(modcomb(h + w, h));
ans %= mod;
ans *= modperm(h + w, k);
ans %= mod;
cout << ans << '\n';
}
|
replace
| 157 | 158 | 157 | 158 |
-6
|
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p03154
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define N 2200000
#define LL long long
const LL mod = 1000000007;
LL n, m, k, p, ans, fac[N], ifac[N];
LL inv(LL x) { return x == 1 ? 1 : (mod - mod / x) * inv(mod % x) % mod; }
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
p = n + m;
fac[0] = 1;
for (LL i = 1; i <= p; ++i)
fac[i] = fac[i - 1] * i % mod;
ifac[p] = inv(fac[p]);
for (LL i = p - 1; ~i; --i)
ifac[i] = ifac[i + 1] * (i + 1) % mod;
ans = k * fac[p] % mod * ifac[p - k] % mod;
for (LL i = 1; i <= k; ++i) {
ans = (ans + fac[p] * ifac[p - k] % mod * (k - i + 1)) % mod;
ans = (ans + 2 * n * m % mod * (i - 1) % mod * (k - i + 1) % mod *
fac[p - 2] % mod * ifac[p - k]) %
mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define N 22000000
#define LL long long
const LL mod = 1000000007;
LL n, m, k, p, ans, fac[N], ifac[N];
LL inv(LL x) { return x == 1 ? 1 : (mod - mod / x) * inv(mod % x) % mod; }
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
p = n + m;
fac[0] = 1;
for (LL i = 1; i <= p; ++i)
fac[i] = fac[i - 1] * i % mod;
ifac[p] = inv(fac[p]);
for (LL i = p - 1; ~i; --i)
ifac[i] = ifac[i + 1] * (i + 1) % mod;
ans = k * fac[p] % mod * ifac[p - k] % mod;
for (LL i = 1; i <= k; ++i) {
ans = (ans + fac[p] * ifac[p - k] % mod * (k - i + 1)) % mod;
ans = (ans + 2 * n * m % mod * (i - 1) % mod * (k - i + 1) % mod *
fac[p - 2] % mod * ifac[p - k]) %
mod;
}
printf("%lld\n", ans);
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p03154
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = int, T mod = 1'000'000'007, typename U = long long>
struct umod {
T val;
umod() : val(0) {}
umod(U x) {
x %= mod;
if (x < 0)
x += mod;
val = x;
}
umod &operator+=(umod oth) {
val += oth.val;
if (val >= mod)
val -= mod;
return *this;
}
umod &operator-=(umod oth) {
val -= oth.val;
if (val < 0)
val += mod;
return *this;
}
umod &operator*=(umod oth) {
val = ((U)val) * oth.val % mod;
return *this;
}
umod &operator/=(umod oth) { return *this *= oth.inverse(); }
umod &operator^=(U oth) { return *this = pwr(*this, oth); }
umod operator+(umod oth) const { return umod(*this) += oth; }
umod operator-(umod oth) const { return umod(*this) -= oth; }
umod operator*(umod oth) const { return umod(*this) *= oth; }
umod operator/(umod oth) const { return umod(*this) /= oth; }
umod operator^(long long oth) const { return umod(*this) ^= oth; }
bool operator<(umod oth) const { return val < oth.val; }
bool operator>(umod oth) const { return val > oth.val; }
bool operator<=(umod oth) const { return val <= oth.val; }
bool operator>=(umod oth) const { return val >= oth.val; }
bool operator==(umod oth) const { return val == oth.val; }
bool operator!=(umod oth) const { return val != oth.val; }
umod pwr(umod a, U b) const {
umod r = 1;
for (; b; a *= a, b >>= 1)
if (b & 1)
r *= a;
return r;
}
umod inverse() const {
U a = val, b = mod, u = 1, v = 0;
while (b) {
U t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0)
u += mod;
return u;
}
};
template <typename U> struct NCR {
vector<U> fact, ifact;
NCR(int size) {
fact.resize(size + 1);
ifact.resize(size + 1);
fact[0] = 1;
for (int i = 1; i <= size; i++)
fact[i] = fact[i - 1] * i;
ifact[size] = fact[size].inverse();
for (int i = size - 1; i >= 0; i--)
ifact[i] = ifact[i + 1] * (i + 1);
}
U ncr(int n, int r) {
if (n < r)
return 0;
return fact[n] * ifact[r] * ifact[n - r];
}
};
using U = umod<>;
using N = NCR<U>;
int main() {
int h, w, k;
cin >> h >> w >> k;
U ans = 0;
const int sz = 10'000'005;
N kit(sz);
/* i != 0 & j != 0 */ {
U indep = kit.ncr(k, 2) / kit.ncr(h + w, 2);
U dep = kit.ncr(k, 3) / kit.ncr(h + w, 3);
dep /= 3;
dep *= (h + w - 2);
ans += U(h) * U(w) * (dep + indep);
}
/* i == 0 & j != 0 */ {
U indep = kit.ncr(k, 1) / kit.ncr(h + w, 1);
U dep = kit.ncr(k, 2) / kit.ncr(h + w, 2);
dep /= 2;
dep *= (h + w - 1);
ans += U(h) * (dep + indep);
}
/* i != 0 & j == 0 */ {
U indep = kit.ncr(k, 1) / kit.ncr(h + w, 1);
U dep = kit.ncr(k, 2) / kit.ncr(h + w, 2);
dep /= 2;
dep *= (h + w - 1);
ans += U(w) * (dep + indep);
}
/* i == 0 & j == 0 */ { ans += k; }
for (int i = (h + w); i >= (h + w - k + 1); i--)
ans *= i;
cout << ans.val << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = int, T mod = 1'000'000'007, typename U = long long>
struct umod {
T val;
umod() : val(0) {}
umod(U x) {
x %= mod;
if (x < 0)
x += mod;
val = x;
}
umod &operator+=(umod oth) {
val += oth.val;
if (val >= mod)
val -= mod;
return *this;
}
umod &operator-=(umod oth) {
val -= oth.val;
if (val < 0)
val += mod;
return *this;
}
umod &operator*=(umod oth) {
val = ((U)val) * oth.val % mod;
return *this;
}
umod &operator/=(umod oth) { return *this *= oth.inverse(); }
umod &operator^=(U oth) { return *this = pwr(*this, oth); }
umod operator+(umod oth) const { return umod(*this) += oth; }
umod operator-(umod oth) const { return umod(*this) -= oth; }
umod operator*(umod oth) const { return umod(*this) *= oth; }
umod operator/(umod oth) const { return umod(*this) /= oth; }
umod operator^(long long oth) const { return umod(*this) ^= oth; }
bool operator<(umod oth) const { return val < oth.val; }
bool operator>(umod oth) const { return val > oth.val; }
bool operator<=(umod oth) const { return val <= oth.val; }
bool operator>=(umod oth) const { return val >= oth.val; }
bool operator==(umod oth) const { return val == oth.val; }
bool operator!=(umod oth) const { return val != oth.val; }
umod pwr(umod a, U b) const {
umod r = 1;
for (; b; a *= a, b >>= 1)
if (b & 1)
r *= a;
return r;
}
umod inverse() const {
U a = val, b = mod, u = 1, v = 0;
while (b) {
U t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0)
u += mod;
return u;
}
};
template <typename U> struct NCR {
vector<U> fact, ifact;
NCR(int size) {
fact.resize(size + 1);
ifact.resize(size + 1);
fact[0] = 1;
for (int i = 1; i <= size; i++)
fact[i] = fact[i - 1] * i;
ifact[size] = fact[size].inverse();
for (int i = size - 1; i >= 0; i--)
ifact[i] = ifact[i + 1] * (i + 1);
}
U ncr(int n, int r) {
if (n < r)
return 0;
return fact[n] * ifact[r] * ifact[n - r];
}
};
using U = umod<>;
using N = NCR<U>;
int main() {
int h, w, k;
cin >> h >> w >> k;
U ans = 0;
const int sz = 20'000'005;
N kit(sz);
/* i != 0 & j != 0 */ {
U indep = kit.ncr(k, 2) / kit.ncr(h + w, 2);
U dep = kit.ncr(k, 3) / kit.ncr(h + w, 3);
dep /= 3;
dep *= (h + w - 2);
ans += U(h) * U(w) * (dep + indep);
}
/* i == 0 & j != 0 */ {
U indep = kit.ncr(k, 1) / kit.ncr(h + w, 1);
U dep = kit.ncr(k, 2) / kit.ncr(h + w, 2);
dep /= 2;
dep *= (h + w - 1);
ans += U(h) * (dep + indep);
}
/* i != 0 & j == 0 */ {
U indep = kit.ncr(k, 1) / kit.ncr(h + w, 1);
U dep = kit.ncr(k, 2) / kit.ncr(h + w, 2);
dep /= 2;
dep *= (h + w - 1);
ans += U(w) * (dep + indep);
}
/* i == 0 & j == 0 */ { ans += k; }
for (int i = (h + w); i >= (h + w - k + 1); i--)
ans *= i;
cout << ans.val << endl;
return 0;
}
|
replace
| 87 | 88 | 87 | 88 |
0
| |
p03154
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define maxn 2000050
using namespace std;
typedef long long ll;
const int M = 1000000007;
int f[maxn], nf[maxn], n, m, K;
long long ans;
int C(int x, int y) {
if (y < 0 || y > x)
return 0;
return 1ll * f[x] * nf[y] % M * nf[x - y] % M;
}
int main() {
f[0] = 1;
for (int i = 1; i < maxn; i++)
f[i] = 1ll * f[i - 1] * i % M;
nf[0] = nf[1] = 1;
for (int i = 2; i < maxn; i++)
nf[i] = M - 1ll * (M / i) * nf[M % i] % M;
for (int i = 2; i < maxn; i++)
nf[i] = 1ll * nf[i - 1] * nf[i] % M;
cin >> n >> m >> K;
for (int k = 1; k <= K; k++) {
long long res = (1ll * n * m % M * C(n + m - 2, k - 2) +
1ll * (n + m) * C(n + m - 1, k - 1) + C(n + m, k)) %
M;
(ans += res * f[n + m - k] % M * f[k] % M * nf[n + m - K]) %= M;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define maxn 20000050
using namespace std;
typedef long long ll;
const int M = 1000000007;
int f[maxn], nf[maxn], n, m, K;
long long ans;
int C(int x, int y) {
if (y < 0 || y > x)
return 0;
return 1ll * f[x] * nf[y] % M * nf[x - y] % M;
}
int main() {
f[0] = 1;
for (int i = 1; i < maxn; i++)
f[i] = 1ll * f[i - 1] * i % M;
nf[0] = nf[1] = 1;
for (int i = 2; i < maxn; i++)
nf[i] = M - 1ll * (M / i) * nf[M % i] % M;
for (int i = 2; i < maxn; i++)
nf[i] = 1ll * nf[i - 1] * nf[i] % M;
cin >> n >> m >> K;
for (int k = 1; k <= K; k++) {
long long res = (1ll * n * m % M * C(n + m - 2, k - 2) +
1ll * (n + m) * C(n + m - 1, k - 1) + C(n + m, k)) %
M;
(ans += res * f[n + m - k] % M * f[k] % M * nf[n + m - K]) %= M;
}
cout << ans << endl;
}
|
replace
| 1 | 2 | 1 | 2 |
0
| |
p03154
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
const int N = 2e7 + 7;
const int M = 1e9 + 7;
inline int add(int a, int b) {
a += b;
if (a >= M)
a -= M;
return a;
}
inline int mul(int a, int b) { return (a * (ll)b) % M; }
inline int bin(int a, int n) {
int res = 1;
while (n) {
if (n % 2 == 0) {
a = mul(a, a);
n /= 2;
} else {
res = mul(res, a);
n--;
}
}
return res;
}
inline int inv(int x) { return bin(x, M - 2); }
int dp[N][3];
int s[N][3];
int fact[N];
int rfact[N];
int odp[N][3];
int os[N][3];
int C(int n, int k) {
if (n < k)
return 0;
return mul(fact[n], mul(rfact[k], rfact[n - k]));
}
int main() {
#ifdef ONPC
freopen("a.in", "r", stdin);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mul(fact[i - 1], i);
}
for (int i = 0; i < N; i++) {
rfact[i] = inv(fact[i]);
}
dp[0][0] = 1;
for (int i = 0; i + 1 < N; i++) {
for (int t = 0; t <= 2; t++) {
if (t == 1) {
os[i][t] = add(os[i][t], dp[i][t]);
}
if (t == 2) {
s[i][t] = add(s[i][t], dp[i][t]);
}
for (int nt = t; nt <= 2 && nt <= t + 1; nt++) {
os[i + 1][nt] = add(os[i + 1][nt], os[i][t]);
s[i + 1][nt] = add(s[i + 1][nt], s[i][t]);
dp[i + 1][nt] = add(dp[i + 1][nt], dp[i][t]);
}
}
}
int h, w, k;
cin >> h >> w >> k;
int ans = mul(k, mul(C(h + w, k), fact[k]));
if (k >= 2) {
int cur = mul(C(h + w - 2, k - 2), fact[k - 2]);
cur = mul(cur, (h * (ll)w) % M);
cur = mul(cur, mul(2, s[k][2]));
ans = add(ans, cur);
}
if (k >= 1) {
int cur = mul(C(h + w - 1, k - 1), fact[k - 1]);
cur = mul(cur, h + w);
cur = mul(cur, os[k][1]);
ans = add(ans, cur);
}
cout << ans << '\n';
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif
const int N = 2e7 + 7;
const int M = 1e9 + 7;
inline int add(int a, int b) {
a += b;
if (a >= M)
a -= M;
return a;
}
inline int mul(int a, int b) { return (a * (ll)b) % M; }
inline int bin(int a, int n) {
int res = 1;
while (n) {
if (n % 2 == 0) {
a = mul(a, a);
n /= 2;
} else {
res = mul(res, a);
n--;
}
}
return res;
}
inline int inv(int x) { return bin(x, M - 2); }
int dp[N][3];
int s[N][3];
int fact[N];
int rfact[N];
int odp[N][3];
int os[N][3];
int C(int n, int k) {
if (n < k)
return 0;
return mul(fact[n], mul(rfact[k], rfact[n - k]));
}
int main() {
#ifdef ONPC
freopen("a.in", "r", stdin);
#endif
ios::sync_with_stdio(0);
cin.tie(0);
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mul(fact[i - 1], i);
}
rfact[N - 1] = inv(fact[N - 1]);
for (int i = N - 2; i >= 0; i--) {
rfact[i] = mul(rfact[i + 1], i + 1);
}
dp[0][0] = 1;
for (int i = 0; i + 1 < N; i++) {
for (int t = 0; t <= 2; t++) {
if (t == 1) {
os[i][t] = add(os[i][t], dp[i][t]);
}
if (t == 2) {
s[i][t] = add(s[i][t], dp[i][t]);
}
for (int nt = t; nt <= 2 && nt <= t + 1; nt++) {
os[i + 1][nt] = add(os[i + 1][nt], os[i][t]);
s[i + 1][nt] = add(s[i + 1][nt], s[i][t]);
dp[i + 1][nt] = add(dp[i + 1][nt], dp[i][t]);
}
}
}
int h, w, k;
cin >> h >> w >> k;
int ans = mul(k, mul(C(h + w, k), fact[k]));
if (k >= 2) {
int cur = mul(C(h + w - 2, k - 2), fact[k - 2]);
cur = mul(cur, (h * (ll)w) % M);
cur = mul(cur, mul(2, s[k][2]));
ans = add(ans, cur);
}
if (k >= 1) {
int cur = mul(C(h + w - 1, k - 1), fact[k - 1]);
cur = mul(cur, h + w);
cur = mul(cur, os[k][1]);
ans = add(ans, cur);
}
cout << ans << '\n';
}
|
replace
| 83 | 85 | 83 | 86 |
TLE
| |
p03154
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <chrono>
#include <complex>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, x, y) for (ll i = x; i <= y; i++)
#define SIZE(a) ll(a.size())
#define vll vector<ll>
#define MEMSET(a, n, m) \
for (ll i = 0; i <= n; i++) \
a[i] = m
#define BIT(n) (ll(1) << n)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define UNIQUE_ARRAY(a, x) unique(a + 1, a + x + 1) - a - 1
#define SORT(a, n) sort(a + 1, a + n + 1)
#define SORT_O(a, n, order) sort(a + 1, a + n + 1, order)
#define PER(i, y, x) for (ll i = y; i >= x; i--)
typedef long long ll;
using namespace std;
struct edge {
long long to;
long long len;
bool operator<(const edge &rhs) const { return len > rhs.len; }
};
ll const MOD = 1e9 + 7;
ll mod_p(ll x, ll y) {
x %= MOD;
y %= MOD;
return (x + y + MOD) % MOD;
}
ll mod_m(ll x, ll y) {
x %= MOD;
y %= MOD;
return x * y % MOD;
}
ll mod_pow(ll x, ll t) {
x %= MOD;
if (t == 0) {
return 1;
} else {
ll v = mod_pow(x, t / 2);
if (t % 2 == 0) {
return v * v % MOD;
} else {
return v * v % MOD * x % MOD;
}
}
}
ll mod_inv(ll x) { return mod_pow(x, MOD - 2); }
ll const MAX = 1e7 + 5;
ll fct[MAX];
void init() {
fct[0] = 1;
REP(i, 1, MAX - 1) { fct[i] = mod_m(fct[i - 1], i); }
}
int main() {
init();
ll h, w, k;
cin >> h >> w >> k;
ll a = h + w;
ll x, y, z;
x = mod_m(mod_inv(2), mod_m(k + 1, k));
y = k;
z = 0;
REP(i, 1, k) { z = mod_p(z, mod_m(i, i - 1)); }
z = mod_m(z, mod_m(h, w));
z = mod_m(z, mod_m(mod_inv(a), mod_inv(a - 1)));
ll ans = mod_m(mod_m((x + y + z), fct[a]), mod_inv(fct[a - k]));
cout << ans << endl;
}
|
#include <algorithm>
#include <bitset>
#include <chrono>
#include <complex>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, x, y) for (ll i = x; i <= y; i++)
#define SIZE(a) ll(a.size())
#define vll vector<ll>
#define MEMSET(a, n, m) \
for (ll i = 0; i <= n; i++) \
a[i] = m
#define BIT(n) (ll(1) << n)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define UNIQUE_ARRAY(a, x) unique(a + 1, a + x + 1) - a - 1
#define SORT(a, n) sort(a + 1, a + n + 1)
#define SORT_O(a, n, order) sort(a + 1, a + n + 1, order)
#define PER(i, y, x) for (ll i = y; i >= x; i--)
typedef long long ll;
using namespace std;
struct edge {
long long to;
long long len;
bool operator<(const edge &rhs) const { return len > rhs.len; }
};
ll const MOD = 1e9 + 7;
ll mod_p(ll x, ll y) {
x %= MOD;
y %= MOD;
return (x + y + MOD) % MOD;
}
ll mod_m(ll x, ll y) {
x %= MOD;
y %= MOD;
return x * y % MOD;
}
ll mod_pow(ll x, ll t) {
x %= MOD;
if (t == 0) {
return 1;
} else {
ll v = mod_pow(x, t / 2);
if (t % 2 == 0) {
return v * v % MOD;
} else {
return v * v % MOD * x % MOD;
}
}
}
ll mod_inv(ll x) { return mod_pow(x, MOD - 2); }
ll const MAX = 2e7 + 5;
ll fct[MAX];
void init() {
fct[0] = 1;
REP(i, 1, MAX - 1) { fct[i] = mod_m(fct[i - 1], i); }
}
int main() {
init();
ll h, w, k;
cin >> h >> w >> k;
ll a = h + w;
ll x, y, z;
x = mod_m(mod_inv(2), mod_m(k + 1, k));
y = k;
z = 0;
REP(i, 1, k) { z = mod_p(z, mod_m(i, i - 1)); }
z = mod_m(z, mod_m(h, w));
z = mod_m(z, mod_m(mod_inv(a), mod_inv(a - 1)));
ll ans = mod_m(mod_m((x + y + z), fct[a]), mod_inv(fct[a - k]));
cout << ans << endl;
}
|
replace
| 64 | 65 | 64 | 65 |
0
| |
p03154
|
C++
|
Runtime Error
|
// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chadd(T &a, T b) { a = a + b; }
typedef pair<int, int> pii;
typedef long long ll;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;
const int S = 10000010;
int fact[S + 10], finv[S + 10];
int mod_pow(int n, int k) {
int res = 1;
for (; k > 0; k >>= 1) {
if (k & 1)
(res *= n) %= MOD;
(n *= n) %= MOD;
}
return res;
}
void init() {
fact[0] = 1;
for (int i = 1; i <= S; i++)
fact[i] = (fact[i - 1] * i) % MOD;
finv[S] = mod_pow(fact[S], MOD - 2);
for (int i = S - 1; i >= 0; i--)
finv[i] = (finv[i + 1] * (i + 1)) % MOD;
}
int perm(int n, int r) {
if (r < 0 or n < r)
return 0;
return fact[n] * finv[n - r] % MOD;
}
signed main() {
init();
int H, W, K;
cin >> H >> W >> K;
int N = H + W;
// 2 個切る必要がある、1 個切る必要がある、1 個も切る必要ない
int c1 = 0, c2 = 0, c3 = perm(N, K) * K % MOD;
for (int i = 1; i <= K; i++) {
// i 番目で初めて切れた
if (i >= 2) {
int temp = 2 * (i - 1);
(temp *= perm(N - 2, K - 2)) %= MOD;
(temp *= K - i + 1) %= MOD;
(c1 += temp) %= MOD;
}
if (i >= 1) {
int temp = perm(N - 1, K - 1);
(temp *= K - i + 1) %= MOD;
(c2 += temp) %= MOD;
}
}
// fprintf(stderr, "c1 = %lld, c2 = %lld, c3 = %lld\n", c1, c2, c3);
int h1 = H * W % MOD;
int h2 = (H + W) % MOD;
int h3 = 1;
int ans = 0;
(ans += h1 * c1) %= MOD;
(ans += h2 * c2) %= MOD;
(ans += h3 * c3) %= MOD;
cout << ans << endl;
return 0;
}
|
// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chadd(T &a, T b) { a = a + b; }
typedef pair<int, int> pii;
typedef long long ll;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;
const int S = 20000010;
int fact[S + 10], finv[S + 10];
int mod_pow(int n, int k) {
int res = 1;
for (; k > 0; k >>= 1) {
if (k & 1)
(res *= n) %= MOD;
(n *= n) %= MOD;
}
return res;
}
void init() {
fact[0] = 1;
for (int i = 1; i <= S; i++)
fact[i] = (fact[i - 1] * i) % MOD;
finv[S] = mod_pow(fact[S], MOD - 2);
for (int i = S - 1; i >= 0; i--)
finv[i] = (finv[i + 1] * (i + 1)) % MOD;
}
int perm(int n, int r) {
if (r < 0 or n < r)
return 0;
return fact[n] * finv[n - r] % MOD;
}
signed main() {
init();
int H, W, K;
cin >> H >> W >> K;
int N = H + W;
// 2 個切る必要がある、1 個切る必要がある、1 個も切る必要ない
int c1 = 0, c2 = 0, c3 = perm(N, K) * K % MOD;
for (int i = 1; i <= K; i++) {
// i 番目で初めて切れた
if (i >= 2) {
int temp = 2 * (i - 1);
(temp *= perm(N - 2, K - 2)) %= MOD;
(temp *= K - i + 1) %= MOD;
(c1 += temp) %= MOD;
}
if (i >= 1) {
int temp = perm(N - 1, K - 1);
(temp *= K - i + 1) %= MOD;
(c2 += temp) %= MOD;
}
}
// fprintf(stderr, "c1 = %lld, c2 = %lld, c3 = %lld\n", c1, c2, c3);
int h1 = H * W % MOD;
int h2 = (H + W) % MOD;
int h3 = 1;
int ans = 0;
(ans += h1 * c1) %= MOD;
(ans += h2 * c2) %= MOD;
(ans += h3 * c3) %= MOD;
cout << ans << endl;
return 0;
}
|
replace
| 43 | 44 | 43 | 44 |
-11
| |
p03155
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace std;
using namespace __gnu_pbds;
typedef tree<pair<int, int>, // change type
null_type, less<pair<int, int>>, // change type
rb_tree_tag, tree_order_statistics_node_update>
ordered_set;
typedef long long ll;
#define rep(i, start, end) for (int i = start; i < end; ++i)
#define per(i, start, end) for (int i = (int)start - 1; i >= end; --i)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
// freopen("facebook.txt", "w", stdout);
#endif
int n, w, h;
cin >> n >> w >> h;
cout << (n - w + 1) * (n - h + 1) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace std;
using namespace __gnu_pbds;
typedef tree<pair<int, int>, // change type
null_type, less<pair<int, int>>, // change type
rb_tree_tag, tree_order_statistics_node_update>
ordered_set;
typedef long long ll;
#define rep(i, start, end) for (int i = start; i < end; ++i)
#define per(i, start, end) for (int i = (int)start - 1; i >= end; --i)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
//// freopen("facebook.txt", "w", stdout);
// #endif
int n, w, h;
cin >> n >> w >> h;
cout << (n - w + 1) * (n - h + 1) << '\n';
return 0;
}
|
replace
| 28 | 32 | 28 | 32 |
0
| |
p03155
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i, x, n) for (int i = x; i < (int)(n); ++i)
#define speed \
ios::sync_with_stdio(0); \
cin.tie(0);
int const N = 1e5 + 1;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
speed int n, h, w;
cin >> n >> h >> w;
int ans = (n - h + 1) * (n - w + 1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define f(i, x, n) for (int i = x; i < (int)(n); ++i)
#define speed \
ios::sync_with_stdio(0); \
cin.tie(0);
int const N = 1e5 + 1;
int main() {
speed int n, h, w;
cin >> n >> h >> w;
int ans = (n - h + 1) * (n - w + 1);
cout << ans << endl;
}
|
delete
| 10 | 13 | 10 | 10 |
0
| |
p03155
|
C++
|
Runtime Error
|
// Gaurav Aggarwal
/*
useful stl
array<ll,size> ar; //size(),front(),back(),fill(),empty()
deque<ll> d //push_back(),push_front(),pop_front(),pop_back()
vector<ll> v(size,val);
//push_back(),*max_element(v.begin(),v.end()),accumulate(v.begin(),v.end(),0)
stack<ll> g; //push(),pop(),top(),size(),empty() LIFO
queue<ll> q; //push(),size(),front(),back(),empty() FIFO
priority_queue<ll> pq
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> ipair;
typedef pair<long, long> lpair;
#define scan(x) \
do { \
while ((x = getchar_unlocked()) < '0') \
; \
for (x -= '0'; '0' <= (_ = getchar_unlocked()); \
x = (x << 3) + (x << 1) + _ - '0') \
; \
} while (0)
char _;
#define For(i, a, b) for (__typeof(a) i = a; i <= b; i++)
#define mod 1000000007
#define PI 3.141592653589793238462643383279502884
#define debug1(a) cout << a << "\n";
#define debug2(a, b) cout << a << " " << b << "\n";
#define debug3(a, b, c) cout << a << " " << b << " " << c << "\n";
#define debug_arr(a, n) \
{ \
for (__typeof(n) i = 0; i < n; ++i) { \
cout << a[i] << " "; \
} \
}
#define inp_arr(a, n) \
for (__typeof(n) i = 0; i < n; ++i) { \
cin >> a[i]; \
}
#define beg_arr(a, n) \
for (__typeof(n) i = 0; i < n; ++i) { \
a[i] = 0; \
}
ll power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
int n;
int h, w;
cin >> n >> h >> w;
int a = max(0, n - h + 1);
int b = max(0, n - w + 1);
cout << a * b;
return 0;
}
|
// Gaurav Aggarwal
/*
useful stl
array<ll,size> ar; //size(),front(),back(),fill(),empty()
deque<ll> d //push_back(),push_front(),pop_front(),pop_back()
vector<ll> v(size,val);
//push_back(),*max_element(v.begin(),v.end()),accumulate(v.begin(),v.end(),0)
stack<ll> g; //push(),pop(),top(),size(),empty() LIFO
queue<ll> q; //push(),size(),front(),back(),empty() FIFO
priority_queue<ll> pq
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> ipair;
typedef pair<long, long> lpair;
#define scan(x) \
do { \
while ((x = getchar_unlocked()) < '0') \
; \
for (x -= '0'; '0' <= (_ = getchar_unlocked()); \
x = (x << 3) + (x << 1) + _ - '0') \
; \
} while (0)
char _;
#define For(i, a, b) for (__typeof(a) i = a; i <= b; i++)
#define mod 1000000007
#define PI 3.141592653589793238462643383279502884
#define debug1(a) cout << a << "\n";
#define debug2(a, b) cout << a << " " << b << "\n";
#define debug3(a, b, c) cout << a << " " << b << " " << c << "\n";
#define debug_arr(a, n) \
{ \
for (__typeof(n) i = 0; i < n; ++i) { \
cout << a[i] << " "; \
} \
}
#define inp_arr(a, n) \
for (__typeof(n) i = 0; i < n; ++i) { \
cin >> a[i]; \
}
#define beg_arr(a, n) \
for (__typeof(n) i = 0; i < n; ++i) { \
a[i] = 0; \
}
ll power(ll x, ll y) {
ll res = 1;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
// #endif
int n;
int h, w;
cin >> n >> h >> w;
int a = max(0, n - h + 1);
int b = max(0, n - w + 1);
cout << a * b;
return 0;
}
|
replace
| 65 | 69 | 65 | 69 |
0
| |
p03155
|
Python
|
Runtime Error
|
N, W, H = map(int, input().split())
print((N - W + 1) * (N - H + 1))
|
N = int(input())
W = int(input())
H = int(input())
print((N - W + 1) * (N - H + 1))
|
replace
| 0 | 1 | 0 | 3 |
ValueError: not enough values to unpack (expected 3, got 1)
|
Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p03155/Python/s974033507.py", line 1, in <module>
N, W, H = map(int, input().split())
ValueError: not enough values to unpack (expected 3, got 1)
|
p03156
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, p[21], A, B, i, x = 0, y = 0, z = 0, min;
cin >> N >> A >> B;
for (i = 1; i <= N; i++) {
cin >> p[i];
if (p[i] <= A)
x++;
if (p[i] >= A + 1 && p[i] <= B)
y++;
if (p[i] >= B + 1)
z++;
}
if (x <= y && x <= z)
min = x;
if (y <= x && y <= z)
min = y;
if (z <= x && z <= y)
min = z;
cout << min;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, p[101], A, B, i, x = 0, y = 0, z = 0, min;
cin >> N >> A >> B;
for (i = 1; i <= N; i++) {
cin >> p[i];
if (p[i] <= A)
x++;
if (p[i] >= A + 1 && p[i] <= B)
y++;
if (p[i] >= B + 1)
z++;
}
if (x <= y && x <= z)
min = x;
if (y <= x && y <= z)
min = y;
if (z <= x && z <= y)
min = z;
cout << min;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
using namespace std;
int dy[4] = {0, 0, 1, -1};
int dx[4] = {1, -1, 0, 0};
int dxx[8] = {0, 0, 1, 1, 1, -1, -1, -1};
int dyy[8] = {1, -1, 0, 1, -1, 0, 1, -1};
ll gcd(ll x, ll y) {
ll m = max(x, y), n = min(x, y);
if (m % n == 0)
return n;
else
return gcd(m % n, n);
}
ll X[301][4];
int main() {
int N, A, B;
int P[20];
cin >> N >> A >> B;
REP(i, N) cin >> P[i];
int a = 0, b = 0, c = 0;
REP(i, N) {
if (P[i] <= A)
a++;
else if (A < P[i] && P[i] <= B)
b++;
else
c++;
}
int ans = min(min(a, b), c);
cout << ans << endl;
}
|
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
using namespace std;
int dy[4] = {0, 0, 1, -1};
int dx[4] = {1, -1, 0, 0};
int dxx[8] = {0, 0, 1, 1, 1, -1, -1, -1};
int dyy[8] = {1, -1, 0, 1, -1, 0, 1, -1};
ll gcd(ll x, ll y) {
ll m = max(x, y), n = min(x, y);
if (m % n == 0)
return n;
else
return gcd(m % n, n);
}
ll X[301][4];
int main() {
int N, A, B;
int P[101];
cin >> N >> A >> B;
REP(i, N) cin >> P[i];
int a = 0, b = 0, c = 0;
REP(i, N) {
if (P[i] <= A)
a++;
else if (A < P[i] && P[i] <= B)
b++;
else
c++;
}
int ans = min(min(a, b), c);
cout << ans << endl;
}
|
replace
| 39 | 40 | 39 | 40 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int main(void) {
int N = 0;
int A = 0, B = 0;
int P[20];
int q1 = 0, q2 = 0, q3 = 0;
int ans = 0;
// 入力
cin >> N >> A >> B;
for (int i = 0; i < N; i++) {
cin >> P[i];
}
// 処理
for (int i = 0; i < N; i++) {
if (P[i] <= A) {
q1++;
}
}
for (int i = 0; i < N; i++) {
if (P[i] > A && P[i] <= B) {
q2++;
}
}
for (int i = 0; i < N; i++) {
if (P[i] > B) {
q3++;
}
}
ans = q1;
if (ans > q2) {
ans = q2;
}
if (ans > q3) {
ans = q3;
}
// 出力
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main(void) {
int N = 0;
int A = 0, B = 0;
int P[100];
int q1 = 0, q2 = 0, q3 = 0;
int ans = 0;
// 入力
cin >> N >> A >> B;
for (int i = 0; i < N; i++) {
cin >> P[i];
}
// 処理
for (int i = 0; i < N; i++) {
if (P[i] <= A) {
q1++;
}
}
for (int i = 0; i < N; i++) {
if (P[i] > A && P[i] <= B) {
q2++;
}
}
for (int i = 0; i < N; i++) {
if (P[i] > B) {
q3++;
}
}
ans = q1;
if (ans > q2) {
ans = q2;
}
if (ans > q3) {
ans = q3;
}
// 出力
cout << ans << endl;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define UNTIL(p) while (!(p))
// constant
const double EPS = 1e-5;
const double PI = acos(-1.0);
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define PUTS(x) cout << (x) << endl;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B;
cin >> N >> A >> B;
int p[20] = {0};
REP(i, N) cin >> p[i];
VI x1, x2, x3;
REP(i, N) if (p[i] <= A) x1.PB(p[i]);
REP(i, N) if (A < p[i] && p[i] <= B) x2.PB(p[i]);
REP(i, N) if (B < p[i]) x3.PB(p[i]);
PUTS(min(x1.size(), min(x2.size(), x3.size())));
}
|
#include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define UNTIL(p) while (!(p))
// constant
const double EPS = 1e-5;
const double PI = acos(-1.0);
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define PUTS(x) cout << (x) << endl;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, A, B;
cin >> N >> A >> B;
int p[100] = {0};
REP(i, N) cin >> p[i];
VI x1, x2, x3;
REP(i, N) if (p[i] <= A) x1.PB(p[i]);
REP(i, N) if (A < p[i] && p[i] <= B) x2.PB(p[i]);
REP(i, N) if (B < p[i]) x3.PB(p[i]);
PUTS(min(x1.size(), min(x2.size(), x3.size())));
}
|
replace
| 80 | 81 | 80 | 81 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define LL long long
const LL mod = 998244353;
#define mem(a, b) memset(a, b, sizeof(a))
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, a[50], A, B;
scanf("%d", &n);
scanf("%d%d", &A, &B);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int x1 = 0, x2 = 0, x3 = 0;
for (int i = 1; i <= n; i++) {
if (a[i] <= A)
x1++;
else if (a[i] > B)
x3++;
else
x2++;
}
printf("%d\n", min(x1, min(x2, x3)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define LL long long
const LL mod = 998244353;
#define mem(a, b) memset(a, b, sizeof(a))
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, a[200], A, B;
scanf("%d", &n);
scanf("%d%d", &A, &B);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int x1 = 0, x2 = 0, x3 = 0;
for (int i = 1; i <= n; i++) {
if (a[i] <= A)
x1++;
else if (a[i] > B)
x3++;
else
x2++;
}
printf("%d\n", min(x1, min(x2, x3)));
return 0;
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long unsigned int ll;
int main() {
int n, a, b;
cin >> n >> a >> b;
int x, y, z;
x = 0;
y = 0;
z = 0;
int p[25];
for (int i = 0; i < n; i++) {
cin >> p[i];
if (p[i] <= a) {
x++;
}
if (p[i] > a && p[i] <= b) {
y++;
}
if (p[i] > b) {
z++;
}
}
int ans;
ans = min(x, y);
ans = min(ans, z);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long unsigned int ll;
int main() {
int n, a, b;
cin >> n >> a >> b;
int x, y, z;
x = 0;
y = 0;
z = 0;
int p[10000];
for (int i = 0; i < n; i++) {
cin >> p[i];
if (p[i] <= a) {
x++;
}
if (p[i] > a && p[i] <= b) {
y++;
}
if (p[i] > b) {
z++;
}
}
int ans;
ans = min(x, y);
ans = min(ans, z);
cout << ans << endl;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <algorithm>
#include <complex>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
int N;
int p[30];
int a, b;
cin >> N;
cin >> a >> b;
for (int i = 0; i < N; i++) {
cin >> p[i];
}
int x = 0, y = 0, z = 0;
for (int i = 0; i < N; i++) {
if (p[i] <= a) {
x++;
} else if (p[i] <= b) {
y++;
} else {
z++;
}
}
cout << min(x, min(y, z)) << endl;
return 0;
}
|
#include <algorithm>
#include <complex>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
int N;
int p[110];
int a, b;
cin >> N;
cin >> a >> b;
for (int i = 0; i < N; i++) {
cin >> p[i];
}
int x = 0, y = 0, z = 0;
for (int i = 0; i < N; i++) {
if (p[i] <= a) {
x++;
} else if (p[i] <= b) {
y++;
} else {
z++;
}
}
cout << min(x, min(y, z)) << endl;
return 0;
}
|
replace
| 20 | 21 | 20 | 21 |
0
| |
p03156
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
int a, b;
cin >> a >> b;
int p[20];
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
rep(i, n) { cin >> p[i]; }
rep(i, n) {
if (p[i] <= a) {
cnt1++;
} else if (a + 1 <= p[i] && p[i] <= b) {
cnt2++;
} else if (b + 1 <= p[i]) {
cnt3++;
}
}
int ans = min(min(cnt1, cnt2), cnt3);
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
int a, b;
cin >> a >> b;
int p[100];
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
rep(i, n) { cin >> p[i]; }
rep(i, n) {
if (p[i] <= a) {
cnt1++;
} else if (a + 1 <= p[i] && p[i] <= b) {
cnt2++;
} else if (b + 1 <= p[i]) {
cnt3++;
}
}
int ans = min(min(cnt1, cnt2), cnt3);
cout << ans << endl;
return 0;
}
|
replace
| 13 | 14 | 13 | 14 |
0
| |
p03157
|
Python
|
Runtime Error
|
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
dx = (0, 0, 1, -1)
dy = (1, -1, 0, 0)
seen = [[False] * w for _ in range(h)]
numb = 0
numw = 0
def dfs(x, y):
global numb, numw
seen[x][y] = True
if s[x][y] == "#":
numb += 1
else:
numw += 1
for di in range(4):
nx = x + dx[di]
ny = y + dy[di]
if nx < 0 or nx >= h or ny < 0 or ny >= w:
continue
if s[x][y] == s[nx][ny]:
continue
if seen[nx][ny]:
continue
dfs(nx, ny)
ans = 0
for x in range(h):
for y in range(w):
if seen[x][y]:
continue
if s[x][y] == ".":
continue
numb = 0
numw = 0
dfs(x, y)
ans += numb * numw
print(ans)
|
import sys
sys.setrecursionlimit(10**6)
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
dx = (0, 0, 1, -1)
dy = (1, -1, 0, 0)
seen = [[False] * w for _ in range(h)]
numb = 0
numw = 0
def dfs(x, y):
global numb, numw
seen[x][y] = True
if s[x][y] == "#":
numb += 1
else:
numw += 1
for di in range(4):
nx = x + dx[di]
ny = y + dy[di]
if nx < 0 or nx >= h or ny < 0 or ny >= w:
continue
if s[x][y] == s[nx][ny]:
continue
if seen[nx][ny]:
continue
dfs(nx, ny)
ans = 0
for x in range(h):
for y in range(w):
if seen[x][y]:
continue
if s[x][y] == ".":
continue
numb = 0
numw = 0
dfs(x, y)
ans += numb * numw
print(ans)
|
insert
| 0 | 0 | 0 | 3 |
0
| |
p03157
|
Python
|
Runtime Error
|
def update(M, S, i, j, H, W, cluster):
for i_n in [i - 1, i, i + 1]:
for j_n in [j - 1, j, j + 1]:
if i_n >= H or i_n < 0:
continue
if j_n >= W or j_n < 0:
continue
if i_n == i and j_n == j:
continue
if abs(i - i_n) + abs(j - j_n) == 2:
continue
if S[i][j] != S[i_n][j_n] and M[i_n][j_n] == 0:
# print(M)
M[i_n][j_n] = cluster
update(M, S, i_n, j_n, H, W, cluster)
H, W = list(map(int, input().split()))
S = []
for i in range(H):
S.append(input().strip())
cluster = 1
counts_B = {}
counts_W = {}
M = [[0 for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if M[i][j] == 0:
M[i][j] = cluster
update(M, S, i, j, H, W, cluster)
cluster = cluster + 1
counts_B[M[i][j]] = 0
counts_W[M[i][j]] = 0
for i in range(H):
for j in range(W):
if S[i][j] == "#":
counts_B[M[i][j]] += 1
else:
counts_W[M[i][j]] += 1
# print(M[i][j], end=" ")
# print("")
total = 0
for k in counts_B.keys():
if k in counts_W:
total += counts_B[k] * counts_W[k]
# print(counts[k])
print(total)
|
import sys
sys.setrecursionlimit(2000000)
def update(M, S, i, j, H, W, cluster):
for i_n in [i - 1, i, i + 1]:
for j_n in [j - 1, j, j + 1]:
if i_n >= H or i_n < 0:
continue
if j_n >= W or j_n < 0:
continue
if i_n == i and j_n == j:
continue
if abs(i - i_n) + abs(j - j_n) == 2:
continue
if S[i][j] != S[i_n][j_n] and M[i_n][j_n] == 0:
# print(M)
M[i_n][j_n] = cluster
update(M, S, i_n, j_n, H, W, cluster)
H, W = list(map(int, input().split()))
S = []
for i in range(H):
S.append(input().strip())
cluster = 1
counts_B = {}
counts_W = {}
M = [[0 for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if M[i][j] == 0:
M[i][j] = cluster
update(M, S, i, j, H, W, cluster)
cluster = cluster + 1
counts_B[M[i][j]] = 0
counts_W[M[i][j]] = 0
for i in range(H):
for j in range(W):
if S[i][j] == "#":
counts_B[M[i][j]] += 1
else:
counts_W[M[i][j]] += 1
# print(M[i][j], end=" ")
# print("")
total = 0
for k in counts_B.keys():
if k in counts_W:
total += counts_B[k] * counts_W[k]
# print(counts[k])
print(total)
|
insert
| 0 | 0 | 0 | 5 |
0
| |
p03157
|
Python
|
Runtime Error
|
#!/usr/bin/env python3
from itertools import product
H, W = map(int, input().split())
S = [input() for _ in range(H)]
color = [[None] * W for _ in range(H)]
memo = [[0, 0] for _ in range(H * W + 1)]
cnt = 1
def dfs(p, c):
x, y = p
color[x][y] = c
memo[cnt][c] += 1
for dx, dy in [[1, 0], [0, 1], [-1, 0], [0, -1]]:
nx = x + dx
ny = y + dy
if (
0 <= nx < H
and 0 <= ny < W
and color[nx][ny] is None
and c != (S[nx][ny] == "#")
):
dfs([nx, ny], not c)
for i, j in product(range(H), range(W)):
if color[i][j] is None:
dfs([i, j], S[i][j] == "#")
cnt += 1
ans = 0
for i in range(H * W):
ans += memo[i][0] * memo[i][1]
print(ans)
|
#!/usr/bin/env python3
from itertools import product
import sys
sys.setrecursionlimit(200000)
H, W = map(int, input().split())
S = [input() for _ in range(H)]
color = [[None] * W for _ in range(H)]
memo = [[0, 0] for _ in range(H * W + 1)]
cnt = 1
def dfs(p, c):
x, y = p
color[x][y] = c
memo[cnt][c] += 1
for dx, dy in [[1, 0], [0, 1], [-1, 0], [0, -1]]:
nx = x + dx
ny = y + dy
if (
0 <= nx < H
and 0 <= ny < W
and color[nx][ny] is None
and c != (S[nx][ny] == "#")
):
dfs([nx, ny], not c)
for i, j in product(range(H), range(W)):
if color[i][j] is None:
dfs([i, j], S[i][j] == "#")
cnt += 1
ans = 0
for i in range(H * W):
ans += memo[i][0] * memo[i][1]
print(ans)
|
insert
| 2 | 2 | 2 | 5 |
0
| |
p03157
|
Python
|
Runtime Error
|
h, w = map(int, input().split())
s = [input() for _ in range(h)]
is_used = [[False] * w for _ in range(h)]
di = [+1, 0, -1, 0]
dj = [0, +1, 0, -1]
def dfs(i, j):
if s[i][j] == "#":
cnt_w, cnt_b = 0, 1
else:
cnt_w, cnt_b = 1, 0
for k in range(4):
ni = i + di[k]
nj = j + dj[k]
if ni < 0 or ni >= h or nj < 0 or nj >= w:
continue
if is_used[ni][nj]:
continue
if s[i][j] == s[ni][nj]:
continue
is_used[ni][nj] = True
cw, cb = dfs(ni, nj)
cnt_w += cw
cnt_b += cb
return (cnt_w, cnt_b)
ans = 0
for i in range(h):
for j in range(w):
if not is_used[i][j]:
is_used[i][j] = True
cnt_w, cnt_b = dfs(i, j)
ans += cnt_w * cnt_b
print(ans)
|
import sys
sys.setrecursionlimit(10**6)
h, w = map(int, input().split())
s = [input() for _ in range(h)]
is_used = [[False] * w for _ in range(h)]
di = [+1, 0, -1, 0]
dj = [0, +1, 0, -1]
def dfs(i, j):
if s[i][j] == "#":
cnt_w, cnt_b = 0, 1
else:
cnt_w, cnt_b = 1, 0
for k in range(4):
ni = i + di[k]
nj = j + dj[k]
if ni < 0 or ni >= h or nj < 0 or nj >= w:
continue
if is_used[ni][nj]:
continue
if s[i][j] == s[ni][nj]:
continue
is_used[ni][nj] = True
cw, cb = dfs(ni, nj)
cnt_w += cw
cnt_b += cb
return (cnt_w, cnt_b)
ans = 0
for i in range(h):
for j in range(w):
if not is_used[i][j]:
is_used[i][j] = True
cnt_w, cnt_b = dfs(i, j)
ans += cnt_w * cnt_b
print(ans)
|
insert
| 0 | 0 | 0 | 4 |
0
| |
p03157
|
Python
|
Runtime Error
|
def dfs(x, y, matrix, visited, isWhite):
global black, white
dxy = [[1, 0], [-1, 0], [0, -1], [0, 1]]
visited[y][x] = True
w = len(matrix[0])
h = len(matrix)
for dx, dy in dxy:
nx = x + dx
ny = y + dy
if nx < 0 or w <= nx or ny < 0 or h <= ny:
continue
if visited[ny][nx] is True:
continue
if (matrix[ny][nx] == "#" and isWhite is False) or (
matrix[ny][nx] == "." and isWhite is True
):
continue
if matrix[ny][nx] == "#":
black += 1
else:
white += 1
isWhite = not isWhite
dfs(nx, ny, matrix, visited, isWhite)
isWhite = not isWhite
return
h, w = map(int, input().split())
matrix = [""] * h
for i in range(h):
matrix[i] = input()
ans = 0
visited = [[False] * w for _ in range(h)]
for i in range(h):
for j in range(w):
if matrix[i][j] == "#" and visited[i][j] is False:
black = 1
white = 0
dfs(j, i, matrix, visited, False)
ans += black * white
print(ans)
|
import sys
sys.setrecursionlimit(10**6)
def dfs(x, y, matrix, visited, isWhite):
global black, white
dxy = [[1, 0], [-1, 0], [0, -1], [0, 1]]
visited[y][x] = True
w = len(matrix[0])
h = len(matrix)
for dx, dy in dxy:
nx = x + dx
ny = y + dy
if nx < 0 or w <= nx or ny < 0 or h <= ny:
continue
if visited[ny][nx] is True:
continue
if (matrix[ny][nx] == "#" and isWhite is False) or (
matrix[ny][nx] == "." and isWhite is True
):
continue
if matrix[ny][nx] == "#":
black += 1
else:
white += 1
isWhite = not isWhite
dfs(nx, ny, matrix, visited, isWhite)
isWhite = not isWhite
return
h, w = map(int, input().split())
matrix = [""] * h
for i in range(h):
matrix[i] = input()
ans = 0
visited = [[False] * w for _ in range(h)]
for i in range(h):
for j in range(w):
if matrix[i][j] == "#" and visited[i][j] is False:
black = 1
white = 0
dfs(j, i, matrix, visited, False)
ans += black * white
print(ans)
|
insert
| 0 | 0 | 0 | 5 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define FLASH \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false);
#define pb push_back
#define int long long
#define fr(i, a, b) for (int i = a; i < b; i++)
#define mod 1000000007
#define FILEIO \
freopen("/home/aman/Desktop/Kachda/input.txt", "r", stdin); \
freopen("/home/aman/Desktop/Kachda/output.txt", "w", stdout);
using namespace std;
int n, m, b = 0, w = 0;
char s[401][401];
bool vis[404][401];
void dfs(int i, int j) {
if (vis[i][j])
return;
char clr = s[i][j];
vis[i][j] = 1;
if (clr == '.')
b++;
else
w++;
if (i > 1 and s[i - 1][j] != clr)
dfs(i - 1, j);
if (i < n and s[i + 1][j] != clr)
dfs(i + 1, j);
if (j > 1 and s[i][j - 1] != clr)
dfs(i, j - 1);
if (j < m and s[i][j + 1] != clr)
dfs(i, j + 1);
}
signed main() {
#ifndef ONLINE_JUDGE
FILEIO
#endif
FLASH
cin >> n >> m;
fr(i, 1, n + 1) {
fr(j, 1, m + 1) { cin >> s[i][j]; }
}
int ans = 0;
fr(i, 1, n + 1) {
fr(j, 1, m + 1) {
if (!vis[i][j]) {
dfs(i, j);
ans += b * w;
b = w = 0;
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
#define FLASH \
cin.tie(0); \
cout.tie(0); \
ios_base::sync_with_stdio(false);
#define pb push_back
#define int long long
#define fr(i, a, b) for (int i = a; i < b; i++)
#define mod 1000000007
#define FILEIO \
freopen("/home/aman/Desktop/Kachda/input.txt", "r", stdin); \
freopen("/home/aman/Desktop/Kachda/output.txt", "w", stdout);
using namespace std;
int n, m, b = 0, w = 0;
char s[401][401];
bool vis[404][401];
void dfs(int i, int j) {
if (vis[i][j])
return;
char clr = s[i][j];
vis[i][j] = 1;
if (clr == '.')
b++;
else
w++;
if (i > 1 and s[i - 1][j] != clr)
dfs(i - 1, j);
if (i < n and s[i + 1][j] != clr)
dfs(i + 1, j);
if (j > 1 and s[i][j - 1] != clr)
dfs(i, j - 1);
if (j < m and s[i][j + 1] != clr)
dfs(i, j + 1);
}
signed main() {
FLASH
cin >> n >> m;
fr(i, 1, n + 1) {
fr(j, 1, m + 1) { cin >> s[i][j]; }
}
int ans = 0;
fr(i, 1, n + 1) {
fr(j, 1, m + 1) {
if (!vis[i][j]) {
dfs(i, j);
ans += b * w;
b = w = 0;
}
}
}
cout << ans;
}
|
replace
| 40 | 43 | 40 | 41 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
// #define int long long
pair<int, int> kk(int t[][500], int s[][500], int i, int j, int h, int w) {
pair<int, int> d = make_pair(0, 0);
pair<int, int> addd;
t[i][j] = 0;
if (i > 0 && s[i][j] != s[i - 1][j] && t[i - 1][j] == -1) {
addd = kk(t, s, i - 1, j, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (j > 0 && s[i][j] != s[i][j - 1] && t[i][j - 1] == -1) {
addd = kk(t, s, i, j - 1, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (i < h && s[i][j] != s[i + 1][j] && t[i + 1][j] == -1) {
addd = kk(t, s, i + 1, j, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (j < w && s[i][j] != s[i][j + 1] && t[i][j + 1] == -1) {
addd = kk(t, s, i, j + 1, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (s[i][j] == 1)
d.first++;
else
d.second++;
return d;
}
signed main() {
int h, w;
cin >> h >> w;
int s[h][500];
int t[h][500];
string l;
for (int i = 0; i < h; i++) {
cin >> l;
for (int j = 0; j < w; j++) {
if (l[j] == '#')
s[i][j] = 1;
else
s[i][j] = 0;
t[i][j] = -1;
}
}
pair<int, int> d;
long ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (t[i][j] == -1) {
d = kk(t, s, i, j, h, w);
ans += long(d.first) * long(d.second);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
// #define int long long
pair<int, int> kk(int t[][500], int s[][500], int i, int j, int h, int w) {
pair<int, int> d = make_pair(0, 0);
pair<int, int> addd;
t[i][j] = 0;
if (i > 0 && s[i][j] != s[i - 1][j] && t[i - 1][j] == -1) {
addd = kk(t, s, i - 1, j, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (j > 0 && s[i][j] != s[i][j - 1] && t[i][j - 1] == -1) {
addd = kk(t, s, i, j - 1, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (i < h && s[i][j] != s[i + 1][j] && t[i + 1][j] == -1) {
addd = kk(t, s, i + 1, j, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (j < w && s[i][j] != s[i][j + 1] && t[i][j + 1] == -1) {
addd = kk(t, s, i, j + 1, h, w);
d.first += addd.first;
d.second += addd.second;
}
if (s[i][j] == 1)
d.first++;
else
d.second++;
return d;
}
signed main() {
int h, w;
cin >> h >> w;
int s[h][500];
int t[h][500];
string l;
for (int i = 0; i < h; i++) {
cin >> l;
for (int j = 0; j < w; j++) {
if (l[j] == '#')
s[i][j] = 1;
else
s[i][j] = 0;
t[i][j] = -1;
}
}
pair<int, int> d;
long long ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (t[i][j] == -1) {
d = kk(t, s, i, j, h, w);
ans += long(d.first) * long(d.second);
}
}
}
cout << ans;
return 0;
}
|
replace
| 56 | 57 | 56 | 57 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define COUT(x) cout << (x) << endl
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
struct UnionFind // size-based
{
vector<int> parent, treesize;
UnionFind(int size)
: parent(size), treesize(size, 1) // constructor
{
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (treesize[x] < treesize[y]) {
parent[x] = y;
treesize[y] += treesize[x];
} else {
parent[y] = x;
treesize[x] += treesize[y];
}
}
bool sametree(int x, int y) { return root(x) == root(y); }
int gettreesize(int x) { return treesize[root(x)]; }
};
/*------------------ the end of the template -----------------------*/
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
IOS; /* making cin faster */
int H, W;
CIN2(H, W);
vector<string> S(H);
vector<vector<int>> m(H, vector<int>(W, -1));
deque<pair<int, int>> q;
int color = 1;
REP(i, H) {
CIN(S[i]);
REP(j, W) {
if (S[i][j] == '#') {
q.push_back(make_pair(i, j));
m[i][j] = color;
++color;
}
}
}
while (!q.empty()) {
pair<int, int> r = q.back();
q.pop_back();
REP(k, 4) {
int y = r.first + dy[k];
int x = r.second + dx[k];
if (0 <= y and y < H and 0 <= x and x < W) {
if (S[r.first][r.second] != S[y][x]) {
if (m[y][x] != m[r.first][r.second]) {
m[y][x] = m[r.first][r.second];
q.push_back(make_pair(y, x));
}
}
}
}
}
vector<lli> hb(color, 0LL);
vector<lli> hw(color, 0LL);
REP(k, color) {
REP(i, H) {
REP(j, W) {
if (m[i][j] == k and S[i][j] == '#') {
++hb[k];
} else if (m[i][j] == k) {
++hw[k];
}
}
}
}
lli sm = 0LL;
REP(k, color) { sm += hb[k] * hw[k]; }
PRINTLLD(sm);
}
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define COUT(x) cout << (x) << endl
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
struct UnionFind // size-based
{
vector<int> parent, treesize;
UnionFind(int size)
: parent(size), treesize(size, 1) // constructor
{
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (treesize[x] < treesize[y]) {
parent[x] = y;
treesize[y] += treesize[x];
} else {
parent[y] = x;
treesize[x] += treesize[y];
}
}
bool sametree(int x, int y) { return root(x) == root(y); }
int gettreesize(int x) { return treesize[root(x)]; }
};
/*------------------ the end of the template -----------------------*/
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
IOS; /* making cin faster */
int H, W;
CIN2(H, W);
vector<string> S(H);
vector<vector<int>> m(H, vector<int>(W, -1));
deque<pair<int, int>> q;
int color = 1;
REP(i, H) {
CIN(S[i]);
REP(j, W) {
if (S[i][j] == '#') {
q.push_back(make_pair(i, j));
m[i][j] = color;
++color;
}
}
}
while (!q.empty()) {
pair<int, int> r = q.back();
q.pop_back();
REP(k, 4) {
int y = r.first + dy[k];
int x = r.second + dx[k];
if (0 <= y and y < H and 0 <= x and x < W) {
if (S[r.first][r.second] != S[y][x]) {
if (m[y][x] != m[r.first][r.second]) {
m[y][x] = m[r.first][r.second];
q.push_back(make_pair(y, x));
}
}
}
}
}
vector<lli> hb(color, 0LL);
vector<lli> hw(color, 0LL);
REP(i, H) {
REP(j, W) {
if (m[i][j] != -1 and S[i][j] == '#') {
++hb[m[i][j]];
} else if (m[i][j] != -1) {
++hw[m[i][j]];
}
}
}
lli sm = 0LL;
REP(k, color) { sm += hb[k] * hw[k]; }
PRINTLLD(sm);
}
|
replace
| 312 | 322 | 312 | 319 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
#include <cstdio>
using ll = long long;
int x[4] = {-1, 0, 1, 0};
int y[4] = {0, 1, 0, -1};
int H, W;
bool S[400][400];
bool has_been_discovered[400][400];
int members[400][2];
void DepthFirstSearch(int row, int column, int group_number) {
has_been_discovered[row][column] = true;
members[group_number][S[row][column]]++;
for (int i = 0; i < 4; ++i) {
if (0 <= row + x[i] && row + x[i] < H && 0 <= column + y[i] &&
column + y[i] < W && !has_been_discovered[row + x[i]][column + y[i]] &&
(S[row][column] ^ S[row + x[i]][column + y[i]])) {
DepthFirstSearch(row + x[i], column + y[i], group_number);
}
}
}
int main() {
scanf("%d %d", &H, &W);
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
if (!j)
scanf("\n");
char tmp;
scanf("%c", &tmp);
S[i][j] = tmp == '#';
}
}
int group_number_ = 0;
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j)
if (!has_been_discovered[i][j])
DepthFirstSearch(i, j, group_number_++);
}
ll answer = 0;
for (int i = 0; i < group_number_; ++i)
answer += members[i][0] * members[i][1];
printf("%lld\n", answer);
return 0;
}
|
#include <cstdio>
using ll = long long;
int x[4] = {-1, 0, 1, 0};
int y[4] = {0, 1, 0, -1};
int H, W;
bool S[400][400];
bool has_been_discovered[400][400];
ll members[160000][2];
void DepthFirstSearch(int row, int column, int group_number) {
has_been_discovered[row][column] = true;
members[group_number][S[row][column]]++;
for (int i = 0; i < 4; ++i) {
if (0 <= row + x[i] && row + x[i] < H && 0 <= column + y[i] &&
column + y[i] < W && !has_been_discovered[row + x[i]][column + y[i]] &&
(S[row][column] ^ S[row + x[i]][column + y[i]])) {
DepthFirstSearch(row + x[i], column + y[i], group_number);
}
}
}
int main() {
scanf("%d %d", &H, &W);
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
if (!j)
scanf("\n");
char tmp;
scanf("%c", &tmp);
S[i][j] = tmp == '#';
}
}
int group_number_ = 0;
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j)
if (!has_been_discovered[i][j])
DepthFirstSearch(i, j, group_number_++);
}
ll answer = 0;
for (int i = 0; i < group_number_; ++i)
answer += members[i][0] * members[i][1];
printf("%lld\n", answer);
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll _() {
ll x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-')
f = -f;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = x * 10 + ch - '0';
return x * f;
}
#define _ _()
int n, m;
ll f[405 * 405], w[405 * 405], b[405 * 405];
ll ans;
char s[405][405];
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
inline int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
n = _;
m = _;
for (int i = 1; i <= n * m; i++)
f[i] = i;
for (int i = 1; i <= n; i++)
scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx < 1 || ny < 1 || nx > n || ny > m)
continue;
if (s[nx][ny] != s[i][j]) {
int fx = find((nx - 1) * m + ny), fy = (i - 1) * m + j;
f[fx] = f[fy];
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '#')
b[find((i - 1) * m + j)]++;
else
w[find((i - 1) * m + j)]++;
for (int i = 1; i <= n * m; i++)
ans += b[i] * w[i];
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll _() {
ll x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-')
f = -f;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = x * 10 + ch - '0';
return x * f;
}
#define _ _()
int n, m;
ll f[405 * 405], w[405 * 405], b[405 * 405];
ll ans;
char s[405][405];
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
inline int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
n = _;
m = _;
for (int i = 1; i <= n * m; i++)
f[i] = i;
for (int i = 1; i <= n; i++)
scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (nx < 1 || ny < 1 || nx > n || ny > m)
continue;
if (s[nx][ny] != s[i][j]) {
int fx = find((nx - 1) * m + ny), fy = find((i - 1) * m + j);
f[fx] = f[fy];
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '#')
b[find((i - 1) * m + j)]++;
else
w[find((i - 1) * m + j)]++;
for (int i = 1; i <= n * m; i++)
ans += b[i] * w[i];
printf("%lld\n", ans);
}
|
replace
| 34 | 35 | 34 | 35 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> iint;
typedef pair<ll, ll> llll;
#define ALL(x) (x).begin(), (x).end()
const ll zero = 0;
const ll INF = 3000000000000000000; // 10^18
const int inINF = 1000000000; // 10^9
const ll MOD = 1000000007; // 10^9+7
const ll MOD2 = 998244353;
int black, white;
void dfs(vector<vector<char>> S, vector<vector<int>> &used, int sh, int sw,
int H, int W) {
used[sh][sw] = 1;
if ((sh + sw) % 2 == 1) {
black++;
} else {
white++;
}
if (sh < H - 1 && used[sh + 1][sw] == 0 && S[sh + 1][sw] == S[sh][sw]) {
dfs(S, used, sh + 1, sw, H, W);
}
if (sh > 0 && used[sh - 1][sw] == 0 && S[sh - 1][sw] == S[sh][sw]) {
dfs(S, used, sh - 1, sw, H, W);
}
if (sw < W - 1 && used[sh][sw + 1] == 0 && S[sh][sw + 1] == S[sh][sw]) {
dfs(S, used, sh, sw + 1, H, W);
}
if (sw > 0 && used[sh][sw - 1] == 0 && S[sh][sw - 1] == S[sh][sw]) {
dfs(S, used, sh, sw - 1, H, W);
}
}
int main() {
int H, W;
cin >> H >> W;
vector<vector<char>> S(H, vector<char>(W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> S[i][j];
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if ((i + j) % 2 == 0) {
if (S[i][j] == '.') {
S[i][j] = '#';
} else {
S[i][j] = '.';
}
}
}
}
vector<vector<int>> used(H, vector<int>(W, 0));
bool check = true;
ll ans = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (used[i][j] == 1)
continue;
black = 0;
white = 0;
dfs(S, used, i, j, H, W);
ans += black * white;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> iint;
typedef pair<ll, ll> llll;
#define ALL(x) (x).begin(), (x).end()
const ll zero = 0;
const ll INF = 3000000000000000000; // 10^18
const int inINF = 1000000000; // 10^9
const ll MOD = 1000000007; // 10^9+7
const ll MOD2 = 998244353;
ll black, white;
void dfs(vector<vector<char>> &S, vector<vector<int>> &used, int sh, int sw,
int H, int W) {
used[sh][sw] = 1;
if ((sh + sw) % 2 == 1) {
black++;
} else {
white++;
}
if (sh < H - 1 && used[sh + 1][sw] == 0 && S[sh + 1][sw] == S[sh][sw]) {
dfs(S, used, sh + 1, sw, H, W);
}
if (sh > 0 && used[sh - 1][sw] == 0 && S[sh - 1][sw] == S[sh][sw]) {
dfs(S, used, sh - 1, sw, H, W);
}
if (sw < W - 1 && used[sh][sw + 1] == 0 && S[sh][sw + 1] == S[sh][sw]) {
dfs(S, used, sh, sw + 1, H, W);
}
if (sw > 0 && used[sh][sw - 1] == 0 && S[sh][sw - 1] == S[sh][sw]) {
dfs(S, used, sh, sw - 1, H, W);
}
}
int main() {
int H, W;
cin >> H >> W;
vector<vector<char>> S(H, vector<char>(W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> S[i][j];
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if ((i + j) % 2 == 0) {
if (S[i][j] == '.') {
S[i][j] = '#';
} else {
S[i][j] = '.';
}
}
}
}
vector<vector<int>> used(H, vector<int>(W, 0));
bool check = true;
ll ans = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (used[i][j] == 1)
continue;
black = 0;
white = 0;
dfs(S, used, i, j, H, W);
ans += black * white;
}
}
printf("%lld\n", ans);
}
|
replace
| 12 | 14 | 12 | 14 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll) INF *INF
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (n); i++)
#define loop(i, a, n) for (int i = a; i < (n); i++)
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vp;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
signed main(void) {
int i, j;
int h, w;
cin >> h >> w;
vs s(h);
rep(i, h) cin >> s[i];
vector<vi> g(h * w);
rep(i, h) rep(j, w) {
rep(k, 4) {
int nx = i + dx[k];
int ny = j + dy[k];
if (nx < 0 || nx >= h || ny < 0 || ny >= w)
continue;
if (s[i][j] == s[nx][ny])
continue;
g[i * w + j].push_back(nx * w + ny);
}
}
/*
rep(i,h*w){
cout << i << endl;
rep(j,g[i].size())cout << " " << g[i][j];cout << endl;
}
*/
vi used(h * w);
int ans = 0;
rep(i, h) rep(j, w) if (g[i * w + j].size() && s[i][j] == '#') {
if (used[i * w + j] == 0) {
int white = 0;
int black = 0;
queue<int> q;
q.push(i * w + j);
used[i * w + j]++;
while (q.size()) {
int now = q.front();
q.pop();
int x = now / h;
int y = now % h;
if (s[x][y] == '#')
black++;
else
white++;
rep(p, g[now].size()) {
int ne = g[now][p];
if (used[ne])
continue;
used[ne]++;
q.push(ne);
}
}
// cout << i << " " << j << " " << white << " " << black << endl;
ans += white * black;
}
}
cout << ans << endl;
}
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll) INF *INF
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (n); i++)
#define loop(i, a, n) for (int i = a; i < (n); i++)
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vp;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
signed main(void) {
int i, j;
int h, w;
cin >> h >> w;
vs s(h);
rep(i, h) cin >> s[i];
vector<vi> g(h * w);
rep(i, h) rep(j, w) {
rep(k, 4) {
int nx = i + dx[k];
int ny = j + dy[k];
if (nx < 0 || nx >= h || ny < 0 || ny >= w)
continue;
if (s[i][j] == s[nx][ny])
continue;
g[i * w + j].push_back(nx * w + ny);
}
}
/*
rep(i,h*w){
cout << i << endl;
rep(j,g[i].size())cout << " " << g[i][j];cout << endl;
}
*/
vi used(h * w);
int ans = 0;
rep(i, h) rep(j, w) if (g[i * w + j].size() && s[i][j] == '#') {
if (used[i * w + j] == 0) {
int white = 0;
int black = 0;
queue<int> q;
q.push(i * w + j);
used[i * w + j]++;
while (q.size()) {
int now = q.front();
q.pop();
int x = now / w;
int y = now % w;
if (s[x][y] == '#')
black++;
else
white++;
rep(p, g[now].size()) {
int ne = g[now][p];
if (used[ne])
continue;
used[ne]++;
q.push(ne);
}
}
// cout << i << " " << j << " " << white << " " << black << endl;
ans += white * black;
}
}
cout << ans << endl;
}
|
replace
| 84 | 86 | 84 | 86 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
// type alias
typedef long long LL;
typedef pair<int, int> II;
typedef tuple<int, int, int> III;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<vector<int>> VVI;
typedef unordered_map<int, int> MAPII;
typedef unordered_set<int> SETI;
template <class T> using VV = vector<vector<T>>;
// minmax
template <class T> inline T SMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
template <class T> inline T SMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
// repetition
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define REPE(i, n) for (int i = 0; i <= (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FORR(x, arr) for (auto &x : arr)
#define SZ(a) int((a).size())
// collection
#define ALL(c) (c).begin(), (c).end()
// DP
#define MINUS(dp) memset(dp, -1, sizeof(dp))
#define ZERO(dp) memset(dp, 0, sizeof(dp))
// stdout
#define println(args...) fprintf(stdout, ##args), putchar('\n');
// debug cerr
#define TRACE true
#define dump(x) \
if (TRACE) { \
cerr << #x << " = " << (x) << endl; \
}
#define dump2(x, y) \
if (TRACE) { \
cerr << #x << " = " << (x) << ", " << #y << " = " << (y) << endl; \
}
#define dump3(x, y, z) \
if (TRACE) { \
cerr << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << endl; \
}
#define dump4(x, y, z, a) \
if (TRACE) { \
cerr << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << ", " << #a << " = " << (a) << endl; \
}
#define dumpf(args...) \
if (TRACE) { \
fprintf(stderr, ##args); \
putchar('\n'); \
}
#define dumpAR(ar) \
if (TRACE) { \
FORR(x, (ar)) { cerr << x << ','; } \
cerr << endl; \
}
template <class Iter> void dumpc(Iter begin, Iter end) {
if (TRACE) {
for (; begin != end; ++begin) {
cerr << *begin << ',';
}
cerr << endl;
}
}
// $ cp-batch AlternatingPath | diff AlternatingPath.out -
// $ g++ -std=c++14 -Wall -O2 -D_GLIBCXX_DEBUG -fsanitize=address
// AlternatingPath.cpp && ./a.out
/*
1/17/2019
16:29-
*/
const int MAX_N = 1e2 + 1;
VI G[MAX_N];
int H, W;
string S[401];
int viz[MAX_N];
// grid move (clock wise order)
vector<pair<int, int>> moves = {
{0, 1} /*R*/, {1, 0} /*D*/, {0, -1} /*L*/, {-1, 0} /*U*/};
int cnt[2];
void dfs(int u, int col) {
if (viz[u])
return;
viz[u] = 1;
cnt[col]++;
FORR(v, G[u]) dfs(v, col ^ 1);
}
void solve() {
REP(i, H) REP(j, W) if (S[i][j] == '#') {
// snippet of board move
for (auto m : moves) {
int ii = i + m.first, jj = j + m.second;
if (ii < 0 || ii >= H || jj < 0 || jj >= W)
continue;
if (S[ii][jj] == '.') {
G[i * W + j].push_back(ii * W + jj);
G[ii * W + jj].push_back(i * W + j);
}
}
}
LL res = 0;
REP(i, H) REP(j, W) if (S[i][j] == '#' && !viz[i * W + j]) {
ZERO(cnt);
dfs(i * W + j, 0);
res += cnt[0] * cnt[1];
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(12) << fixed;
cin >> H >> W;
REP(i, H) cin >> S[i];
solve();
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
// type alias
typedef long long LL;
typedef pair<int, int> II;
typedef tuple<int, int, int> III;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<vector<int>> VVI;
typedef unordered_map<int, int> MAPII;
typedef unordered_set<int> SETI;
template <class T> using VV = vector<vector<T>>;
// minmax
template <class T> inline T SMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
template <class T> inline T SMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
// repetition
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define REPE(i, n) for (int i = 0; i <= (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FORR(x, arr) for (auto &x : arr)
#define SZ(a) int((a).size())
// collection
#define ALL(c) (c).begin(), (c).end()
// DP
#define MINUS(dp) memset(dp, -1, sizeof(dp))
#define ZERO(dp) memset(dp, 0, sizeof(dp))
// stdout
#define println(args...) fprintf(stdout, ##args), putchar('\n');
// debug cerr
#define TRACE true
#define dump(x) \
if (TRACE) { \
cerr << #x << " = " << (x) << endl; \
}
#define dump2(x, y) \
if (TRACE) { \
cerr << #x << " = " << (x) << ", " << #y << " = " << (y) << endl; \
}
#define dump3(x, y, z) \
if (TRACE) { \
cerr << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << endl; \
}
#define dump4(x, y, z, a) \
if (TRACE) { \
cerr << #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z \
<< " = " << (z) << ", " << #a << " = " << (a) << endl; \
}
#define dumpf(args...) \
if (TRACE) { \
fprintf(stderr, ##args); \
putchar('\n'); \
}
#define dumpAR(ar) \
if (TRACE) { \
FORR(x, (ar)) { cerr << x << ','; } \
cerr << endl; \
}
template <class Iter> void dumpc(Iter begin, Iter end) {
if (TRACE) {
for (; begin != end; ++begin) {
cerr << *begin << ',';
}
cerr << endl;
}
}
// $ cp-batch AlternatingPath | diff AlternatingPath.out -
// $ g++ -std=c++14 -Wall -O2 -D_GLIBCXX_DEBUG -fsanitize=address
// AlternatingPath.cpp && ./a.out
/*
1/17/2019
16:29-
*/
const int MAX_N = 2e5 + 1;
VI G[MAX_N];
int H, W;
string S[401];
int viz[MAX_N];
// grid move (clock wise order)
vector<pair<int, int>> moves = {
{0, 1} /*R*/, {1, 0} /*D*/, {0, -1} /*L*/, {-1, 0} /*U*/};
int cnt[2];
void dfs(int u, int col) {
if (viz[u])
return;
viz[u] = 1;
cnt[col]++;
FORR(v, G[u]) dfs(v, col ^ 1);
}
void solve() {
REP(i, H) REP(j, W) if (S[i][j] == '#') {
// snippet of board move
for (auto m : moves) {
int ii = i + m.first, jj = j + m.second;
if (ii < 0 || ii >= H || jj < 0 || jj >= W)
continue;
if (S[ii][jj] == '.') {
G[i * W + j].push_back(ii * W + jj);
G[ii * W + jj].push_back(i * W + j);
}
}
}
LL res = 0;
REP(i, H) REP(j, W) if (S[i][j] == '#' && !viz[i * W + j]) {
ZERO(cnt);
dfs(i * W + j, 0);
res += cnt[0] * cnt[1];
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(12) << fixed;
cin >> H >> W;
REP(i, H) cin >> S[i];
solve();
return 0;
}
|
replace
| 107 | 108 | 107 | 108 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int dy[4] = {-1, 0, 1, 0};
int dx[4] = {0, 1, 0, -1};
char board[401][401];
int h, w;
int visited[401][401];
int arr[16005][2];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> board[i][j];
}
}
memset(visited, -1, sizeof(visited));
int cnt = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (visited[i][j] == -1 && board[i][j] == '#') {
queue<pair<int, int>> que;
que.push(make_pair(i, j));
visited[i][j] = cnt;
while (!que.empty()) {
int y = que.front().first;
int x = que.front().second;
que.pop();
for (int k = 0; k < 4; k++) {
int ny = y + dy[k];
int nx = x + dx[k];
if (ny < 0 || ny >= h || nx < 0 || nx >= w) {
continue;
}
if (visited[ny][nx] == -1 && board[ny][nx] != board[y][x]) {
visited[ny][nx] = cnt;
que.push(make_pair(ny, nx));
}
}
}
cnt++;
}
}
}
long long int res = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (visited[i][j] == -1) {
continue;
}
if (board[i][j] == '#') {
arr[visited[i][j]][0]++;
} else {
arr[visited[i][j]][1]++;
}
}
}
for (int i = 0; i < cnt; i++) {
res += (arr[i][0] * arr[i][1]);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dy[4] = {-1, 0, 1, 0};
int dx[4] = {0, 1, 0, -1};
char board[401][401];
int h, w;
int visited[401][401];
long long int arr[160005][2];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> board[i][j];
}
}
memset(visited, -1, sizeof(visited));
int cnt = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (visited[i][j] == -1 && board[i][j] == '#') {
queue<pair<int, int>> que;
que.push(make_pair(i, j));
visited[i][j] = cnt;
while (!que.empty()) {
int y = que.front().first;
int x = que.front().second;
que.pop();
for (int k = 0; k < 4; k++) {
int ny = y + dy[k];
int nx = x + dx[k];
if (ny < 0 || ny >= h || nx < 0 || nx >= w) {
continue;
}
if (visited[ny][nx] == -1 && board[ny][nx] != board[y][x]) {
visited[ny][nx] = cnt;
que.push(make_pair(ny, nx));
}
}
}
cnt++;
}
}
}
long long int res = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (visited[i][j] == -1) {
continue;
}
if (board[i][j] == '#') {
arr[visited[i][j]][0]++;
} else {
arr[visited[i][j]][1]++;
}
}
}
for (int i = 0; i < cnt; i++) {
res += (arr[i][0] * arr[i][1]);
}
cout << res << '\n';
return 0;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define priq priority_queue<int>
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (int)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (int)(key)))
#define tii tuple<int, int, int>
#define Priq priority_queue<int, vi, greater<int>>
#define pb push_back
#define mp make_pair
#define INF (1ll << 60)
signed main() {
int H, W;
cin >> H >> W;
vector<string> S(H);
rep(i, 0, H) cin >> S[i];
vi P = {0, 1, 0, -1}, R = {1, 0, -1, 0};
int ans = 0;
vector<vector<bool>> F(H, vector<bool>(W, 1));
rep(i, 0, H) {
rep(j, 0, W) {
if (F[i][j]) {
queue<pii> Q;
Q.push(mp(i, j));
F[i][j] = 0;
int C = 0, D = 0;
while (Q.size() > 0) {
int X = Q.front().first, Y = Q.front().second;
Q.pop();
C++;
if (S[X][Y] == '.')
D++;
rep(k, 0, 4) {
int A = P[k] + X, B = R[k] + Y;
if (0 <= A && A < H && 0 <= B && B < W && S[X][Y] != S[A][B]) {
Q.push(mp(A, B));
F[A][B] = 0;
}
}
}
ans += (C - D) * D;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define priq priority_queue<int>
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (int)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (int)(key)))
#define tii tuple<int, int, int>
#define Priq priority_queue<int, vi, greater<int>>
#define pb push_back
#define mp make_pair
#define INF (1ll << 60)
signed main() {
int H, W;
cin >> H >> W;
vector<string> S(H);
rep(i, 0, H) cin >> S[i];
vi P = {0, 1, 0, -1}, R = {1, 0, -1, 0};
int ans = 0;
vector<vector<bool>> F(H, vector<bool>(W, 1));
rep(i, 0, H) {
rep(j, 0, W) {
if (F[i][j]) {
queue<pii> Q;
Q.push(mp(i, j));
F[i][j] = 0;
int C = 0, D = 0;
while (Q.size() > 0) {
int X = Q.front().first, Y = Q.front().second;
Q.pop();
C++;
if (S[X][Y] == '.')
D++;
rep(k, 0, 4) {
int A = P[k] + X, B = R[k] + Y;
if (0 <= A && A < H && 0 <= B && B < W && S[X][Y] != S[A][B] &&
F[A][B]) {
Q.push(mp(A, B));
F[A][B] = 0;
}
}
}
ans += (C - D) * D;
}
}
}
cout << ans << endl;
}
|
replace
| 41 | 42 | 41 | 43 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
#include <vector>
#define N 405
using namespace std;
typedef long long ll;
ll n, m, num, cnt[N], s[N], z[N][N];
ll dr[4] = {-1, 0, 0, 1}, dc[4] = {0, -1, 1, 0};
bool v[N][N];
char a[N][N];
// vector<ll> x, y;
void f(ll p, ll q) {
ll i, j, x, y;
if (p < 1 || p > n || q < 1 || q > m || v[p][q] || a[p][q] != '#')
return;
v[p][q] = 1;
s[num]++;
for (i = 0; i < 4; i++) {
x = p + dr[i];
y = q + dc[i];
if (a[x][y] != '.')
continue;
if (z[x][y] != num) {
cnt[num]++;
z[x][y] = num;
for (j = 0; j < 4; j++) {
f(x + dr[j], y + dc[j]);
}
}
}
}
int main() {
ll i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%s", &a[i][1]);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (v[i][j] || a[i][j] != '#')
continue;
num++;
f(i, j);
}
}
ll ans = 0;
for (i = 1; i <= num; i++) {
ans += s[i] * cnt[i];
}
cout << ans;
return 0;
}
|
#include <cstdio>
#include <iostream>
#include <vector>
#define N 405
using namespace std;
typedef long long ll;
ll n, m, num, cnt[160005], s[160005], z[N][N];
ll dr[4] = {-1, 0, 0, 1}, dc[4] = {0, -1, 1, 0};
bool v[N][N];
char a[N][N];
// vector<ll> x, y;
void f(ll p, ll q) {
ll i, j, x, y;
if (p < 1 || p > n || q < 1 || q > m || v[p][q] || a[p][q] != '#')
return;
v[p][q] = 1;
s[num]++;
for (i = 0; i < 4; i++) {
x = p + dr[i];
y = q + dc[i];
if (a[x][y] != '.')
continue;
if (z[x][y] != num) {
cnt[num]++;
z[x][y] = num;
for (j = 0; j < 4; j++) {
f(x + dr[j], y + dc[j]);
}
}
}
}
int main() {
ll i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%s", &a[i][1]);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (v[i][j] || a[i][j] != '#')
continue;
num++;
f(i, j);
}
}
ll ans = 0;
for (i = 1; i <= num; i++) {
ans += s[i] * cnt[i];
}
cout << ans;
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define MAX 1000000
#define ll long long
#define db double
#define pb push_back
#define For(i, s, e) for (ll i = (s); i < (e); i++)
#define Debug_array(a, n) \
for (ll i = (0); i < (n); i++) \
cout << a[i] << " "
#define Foe(i, s, e) for (ll i = (s); i <= (e); i++)
#define Fod(i, s, e) for (ll i = (s)-1; i >= (e); i--)
#define vl vector<ll>
#define vs vector<string>
#define mapll map<ll, ll>
#define mapss map<string, string>
#define mapsl map<string, ll>
#define mapls map<ll, string>
#define pll pair<ll, ll>
#define pss pair<string, string>
#define psl pair<ll, string>
#define pls pair<string, ll>
#define minheap priority_queue<ll>
#define maxheap priority_queue<ll, vector<ll>, greater<ll>>
#define fi first
#define se second
#define endl "\n"
#define mp make_pair
#define big_prime 15486277
#define bigger_prime 179424697
#define biggest_prime 32416188691
const ll mod = 1e9 + 7;
ll takemod(ll a) { return ((a % mod) + mod) % mod; }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll fast_exp(ll base, ll expo) {
ll res = 1;
while (expo > 0) {
if (expo & 1)
res = (res * base) % mod;
base = (base * base) % mod;
expo >>= 1;
}
return res;
}
ll modinv(ll a) { return takemod(fast_exp(takemod(a), mod - 2)); }
ll arr1[400][400];
ll visit[400][400];
ll ans, n, m;
ll val1, val2;
vector<pll> v1;
void dfs(vector<pll> v1, ll index, ll count) {
if (index >= v1.size()) {
return;
}
ll x1 = v1[index].fi;
ll y1 = v1[index].se;
if (x1 > 0 and arr1[x1][y1] != arr1[x1 - 1][y1] and visit[x1 - 1][y1] == 0) {
if (arr1[x1 - 1][y1] == 0)
++val2;
else
++val1;
visit[x1 - 1][y1] = count;
v1.pb(mp(x1 - 1, y1));
}
if (y1 > 0 and arr1[x1][y1] != arr1[x1][y1 - 1] and visit[x1][y1 - 1] == 0) {
if (arr1[x1][y1 - 1] == 0)
++val2;
else
++val1;
visit[x1][y1 - 1] = count;
v1.pb(mp(x1, y1 - 1));
}
if (x1 + 1 < n and arr1[x1][y1] != arr1[x1 + 1][y1] and
visit[x1 + 1][y1] == 0) {
if (arr1[x1 + 1][y1] == 0)
++val2;
else
++val1;
visit[x1 + 1][y1] = count;
v1.pb(mp(x1 + 1, y1));
}
if (y1 + 1 < m and arr1[x1][y1] != arr1[x1][y1 + 1] and
visit[x1][y1 + 1] == 0) {
if (arr1[x1][y1 + 1] == 0)
++val2;
else
++val1;
visit[x1][y1 + 1] = count;
v1.pb(mp(x1, y1 + 1));
}
dfs(v1, index + 1, count);
return;
}
signed main() {
fast_cin();
cin >> n >> m;
ans = 0;
ll count = 1;
For(i, 0, n) {
string s1;
cin >> s1;
For(j, 0, m) {
if (s1[j] == '.')
arr1[i][j] = 0;
else
arr1[i][j] = 1;
visit[i][j] = 0;
}
}
For(i, 0, n) {
For(j, 0, m) {
if (visit[i][j] == 0) {
val1 = 0;
val2 = 0;
v1.clear();
v1.push_back(mp(i, j));
visit[i][j] = count;
if (arr1[i][j] == 1)
++val1;
else
++val2;
dfs(v1, 0, count);
++count;
ans += (val1 * val2);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define MAX 1000000
#define ll long long
#define db double
#define pb push_back
#define For(i, s, e) for (ll i = (s); i < (e); i++)
#define Debug_array(a, n) \
for (ll i = (0); i < (n); i++) \
cout << a[i] << " "
#define Foe(i, s, e) for (ll i = (s); i <= (e); i++)
#define Fod(i, s, e) for (ll i = (s)-1; i >= (e); i--)
#define vl vector<ll>
#define vs vector<string>
#define mapll map<ll, ll>
#define mapss map<string, string>
#define mapsl map<string, ll>
#define mapls map<ll, string>
#define pll pair<ll, ll>
#define pss pair<string, string>
#define psl pair<ll, string>
#define pls pair<string, ll>
#define minheap priority_queue<ll>
#define maxheap priority_queue<ll, vector<ll>, greater<ll>>
#define fi first
#define se second
#define endl "\n"
#define mp make_pair
#define big_prime 15486277
#define bigger_prime 179424697
#define biggest_prime 32416188691
const ll mod = 1e9 + 7;
ll takemod(ll a) { return ((a % mod) + mod) % mod; }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll fast_exp(ll base, ll expo) {
ll res = 1;
while (expo > 0) {
if (expo & 1)
res = (res * base) % mod;
base = (base * base) % mod;
expo >>= 1;
}
return res;
}
ll modinv(ll a) { return takemod(fast_exp(takemod(a), mod - 2)); }
ll arr1[400][400];
ll visit[400][400];
ll ans, n, m;
ll val1, val2;
vector<pll> v1;
void dfs(vector<pll> &v1, ll index, ll count) {
if (index >= v1.size()) {
return;
}
ll x1 = v1[index].fi;
ll y1 = v1[index].se;
if (x1 > 0 and arr1[x1][y1] != arr1[x1 - 1][y1] and visit[x1 - 1][y1] == 0) {
if (arr1[x1 - 1][y1] == 0)
++val2;
else
++val1;
visit[x1 - 1][y1] = count;
v1.pb(mp(x1 - 1, y1));
}
if (y1 > 0 and arr1[x1][y1] != arr1[x1][y1 - 1] and visit[x1][y1 - 1] == 0) {
if (arr1[x1][y1 - 1] == 0)
++val2;
else
++val1;
visit[x1][y1 - 1] = count;
v1.pb(mp(x1, y1 - 1));
}
if (x1 + 1 < n and arr1[x1][y1] != arr1[x1 + 1][y1] and
visit[x1 + 1][y1] == 0) {
if (arr1[x1 + 1][y1] == 0)
++val2;
else
++val1;
visit[x1 + 1][y1] = count;
v1.pb(mp(x1 + 1, y1));
}
if (y1 + 1 < m and arr1[x1][y1] != arr1[x1][y1 + 1] and
visit[x1][y1 + 1] == 0) {
if (arr1[x1][y1 + 1] == 0)
++val2;
else
++val1;
visit[x1][y1 + 1] = count;
v1.pb(mp(x1, y1 + 1));
}
dfs(v1, index + 1, count);
return;
}
signed main() {
fast_cin();
cin >> n >> m;
ans = 0;
ll count = 1;
For(i, 0, n) {
string s1;
cin >> s1;
For(j, 0, m) {
if (s1[j] == '.')
arr1[i][j] = 0;
else
arr1[i][j] = 1;
visit[i][j] = 0;
}
}
For(i, 0, n) {
For(j, 0, m) {
if (visit[i][j] == 0) {
val1 = 0;
val2 = 0;
v1.clear();
v1.push_back(mp(i, j));
visit[i][j] = count;
if (arr1[i][j] == 1)
++val1;
else
++val2;
dfs(v1, 0, count);
++count;
ans += (val1 * val2);
}
}
}
cout << ans << endl;
return 0;
}
|
replace
| 71 | 72 | 71 | 72 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, m, cnt, fa[404 * 404], sh[404], sb[404], id[404][404], vis[404][404];
ll ans;
char mp[404][404];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%s", mp[i] + 1);
for (int j = 1; j <= m; j++)
id[i][j] = ++cnt, fa[cnt] = cnt;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j] == '.')
sb[id[i][j]] = 1;
else
sh[id[i][j]] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i < n && mp[i + 1][j] != mp[i][j]) {
int u = find(id[i][j]), v = find(id[i + 1][j]);
if (u != v) {
fa[u] = v;
sh[v] += sh[u], sb[v] += sb[u];
sh[u] = sb[u] = 0;
}
}
if (j < m && mp[i][j + 1] != mp[i][j]) {
int u = find(id[i][j]), v = find(id[i][j + 1]);
if (u != v) {
fa[u] = v;
sh[v] += sh[u], sb[v] += sb[u];
sh[u] = sb[u] = 0;
}
}
}
for (int i = 1; i <= n * m; i++)
if (sh[i] && sb[i])
ans += 1ll * sh[i] * sb[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, m, cnt, fa[404 * 404], sh[404 * 404], sb[404 * 404], id[404][404],
vis[404][404];
ll ans;
char mp[404][404];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%s", mp[i] + 1);
for (int j = 1; j <= m; j++)
id[i][j] = ++cnt, fa[cnt] = cnt;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j] == '.')
sb[id[i][j]] = 1;
else
sh[id[i][j]] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i < n && mp[i + 1][j] != mp[i][j]) {
int u = find(id[i][j]), v = find(id[i + 1][j]);
if (u != v) {
fa[u] = v;
sh[v] += sh[u], sb[v] += sb[u];
sh[u] = sb[u] = 0;
}
}
if (j < m && mp[i][j + 1] != mp[i][j]) {
int u = find(id[i][j]), v = find(id[i][j + 1]);
if (u != v) {
fa[u] = v;
sh[v] += sh[u], sb[v] += sb[u];
sh[u] = sb[u] = 0;
}
}
}
for (int i = 1; i <= n * m; i++)
if (sh[i] && sb[i])
ans += 1ll * sh[i] * sb[i];
cout << ans << endl;
}
|
replace
| 3 | 4 | 3 | 5 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using plll = pair<ll, pll>;
using graph = vector<vector<int>>;
const ll MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll abs1(ll a) {
if (a >= 0)
return a;
else
return -a;
}
ll pow1(ll a, ll b, ll p = LLONG_MAX) {
ll ret = 1;
while (b != 0) {
if ((b & 1) == 1) {
ret *= a;
}
a *= a;
if (a >= p)
a %= p;
b = b >> 1;
}
return ret;
}
int digit(ll a, ll b) {
int i = 0;
while (a != 0) {
a /= b;
i++;
}
return i;
}
ll gcd1(ll a, ll b) {
if (a == 0 && b == 0)
return 0;
ll n;
while (a % b != 0) {
n = a % b;
a = b;
b = n;
}
return b;
}
ll solveLinear(ll n, ll m, ll c) {
if (n == 0 && m == 0)
return 0;
ll a[100], b[100];
a[0] = n;
b[0] = m;
int i = 1;
while (b[i - 1] != 0) {
a[i] = b[i - 1];
b[i] = a[i - 1] % b[i - 1];
i++;
}
n = i;
if (c % a[n - 1] != 0) {
return 0;
}
ll x = c / a[n - 1], y = 0;
for (i = 1; i < n; i++) {
ll cnt = x;
x = y;
y = cnt - (a[n - i - 1] / b[n - i - 1]) * y;
}
return x;
}
ll modInv(ll a, ll p = MOD) {
a %= p;
ll n = solveLinear(a, p, 1);
n %= p;
if (n < 0)
return n + p;
return n;
}
ll fact(ll n, ll p = MOD) {
if (n < 0)
return 0;
int i;
ll ret = 1;
for (i = 0; i < n; i++) {
ret = ret * (i + 1);
if (ret >= p)
ret %= p;
}
return ret;
}
ll perm(ll n, ll k, ll p = MOD) {
if (n < 0 || k < 0 || n < k)
return 0;
int i;
ll ret = 1;
for (i = 0; i < k; i++) {
ret = ret * (n - i);
if (ret >= p)
ret %= p;
}
return ret;
}
ll binom(ll n, ll k, ll p = MOD) {
if (n < 0 || k < 0 || n < k)
return 0;
int i;
ll ret = 1, fact = 1;
for (i = 0; i < k; i++) {
ret = ret * (n - i);
fact *= i + 1;
if (ret >= p)
ret %= p;
if (fact >= p)
fact %= p;
}
return (ret * modInv(fact)) % p;
}
void pushHeap(vector<int> &h, int n) {
int i = h.size();
h.push_back(n);
while (i != 0 && h[(i - 1) / 2] < h[i]) {
swap(h[i], h[(i - 1) / 2]);
i = (i - 1) / 2;
}
h[i] = n;
}
int popHeap(vector<int> &h) {
int n = h.size() - 1;
if (n == -1)
return 0;
int i, ret = h[0];
swap(h[0], h[n]);
h.pop_back();
for (i = 0; i < n;) {
int j = 2 * i + 1;
if (j >= n)
break;
if (j != n - 1 && h[j] < h[j + 1])
j++;
if (h[i] < h[j]) {
swap(h[i], h[j]);
}
i = j;
}
return ret;
}
int num = 1;
int h, w;
vector<ll> sc, sd;
int c[400][400], ver[400][400];
void dfs(int x, int y, int color) {
ver[x][y] = num;
if (c[x][y] == 0)
sc[num]++;
else
sd[num]++;
for (int i = 0; i < 4; i++) {
int p = x + dx[i];
int q = y + dy[i];
if (p < 0 || h <= p || q < 0 || w <= q)
continue;
if (ver[p][q] != 0)
continue;
if (c[p][q] == color)
continue;
dfs(p, q, c[p][q]);
}
}
int main() {
int i, j, k, cnt = 0;
cin >> h >> w;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
char a;
cin >> a;
if (a == '.')
c[i][j] = 0;
else
c[i][j] = 1;
}
}
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++)
ver[i][j] = 0;
}
sc.assign(h * w, 0);
sd.assign(h * w, 0);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (ver[i][j] != 0)
continue;
dfs(i, j, c[i][j]);
num++;
}
}
ll ans = 0;
for (i = 0; i < num; i++) {
ans += sc[i] * sd[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using plll = pair<ll, pll>;
using graph = vector<vector<int>>;
const ll MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll abs1(ll a) {
if (a >= 0)
return a;
else
return -a;
}
ll pow1(ll a, ll b, ll p = LLONG_MAX) {
ll ret = 1;
while (b != 0) {
if ((b & 1) == 1) {
ret *= a;
}
a *= a;
if (a >= p)
a %= p;
b = b >> 1;
}
return ret;
}
int digit(ll a, ll b) {
int i = 0;
while (a != 0) {
a /= b;
i++;
}
return i;
}
ll gcd1(ll a, ll b) {
if (a == 0 && b == 0)
return 0;
ll n;
while (a % b != 0) {
n = a % b;
a = b;
b = n;
}
return b;
}
ll solveLinear(ll n, ll m, ll c) {
if (n == 0 && m == 0)
return 0;
ll a[100], b[100];
a[0] = n;
b[0] = m;
int i = 1;
while (b[i - 1] != 0) {
a[i] = b[i - 1];
b[i] = a[i - 1] % b[i - 1];
i++;
}
n = i;
if (c % a[n - 1] != 0) {
return 0;
}
ll x = c / a[n - 1], y = 0;
for (i = 1; i < n; i++) {
ll cnt = x;
x = y;
y = cnt - (a[n - i - 1] / b[n - i - 1]) * y;
}
return x;
}
ll modInv(ll a, ll p = MOD) {
a %= p;
ll n = solveLinear(a, p, 1);
n %= p;
if (n < 0)
return n + p;
return n;
}
ll fact(ll n, ll p = MOD) {
if (n < 0)
return 0;
int i;
ll ret = 1;
for (i = 0; i < n; i++) {
ret = ret * (i + 1);
if (ret >= p)
ret %= p;
}
return ret;
}
ll perm(ll n, ll k, ll p = MOD) {
if (n < 0 || k < 0 || n < k)
return 0;
int i;
ll ret = 1;
for (i = 0; i < k; i++) {
ret = ret * (n - i);
if (ret >= p)
ret %= p;
}
return ret;
}
ll binom(ll n, ll k, ll p = MOD) {
if (n < 0 || k < 0 || n < k)
return 0;
int i;
ll ret = 1, fact = 1;
for (i = 0; i < k; i++) {
ret = ret * (n - i);
fact *= i + 1;
if (ret >= p)
ret %= p;
if (fact >= p)
fact %= p;
}
return (ret * modInv(fact)) % p;
}
void pushHeap(vector<int> &h, int n) {
int i = h.size();
h.push_back(n);
while (i != 0 && h[(i - 1) / 2] < h[i]) {
swap(h[i], h[(i - 1) / 2]);
i = (i - 1) / 2;
}
h[i] = n;
}
int popHeap(vector<int> &h) {
int n = h.size() - 1;
if (n == -1)
return 0;
int i, ret = h[0];
swap(h[0], h[n]);
h.pop_back();
for (i = 0; i < n;) {
int j = 2 * i + 1;
if (j >= n)
break;
if (j != n - 1 && h[j] < h[j + 1])
j++;
if (h[i] < h[j]) {
swap(h[i], h[j]);
}
i = j;
}
return ret;
}
int num = 1;
int h, w;
vector<ll> sc, sd;
int c[400][400], ver[400][400];
void dfs(int x, int y, int color) {
ver[x][y] = num;
if (c[x][y] == 0)
sc[num]++;
else
sd[num]++;
for (int i = 0; i < 4; i++) {
int p = x + dx[i];
int q = y + dy[i];
if (p < 0 || h <= p || q < 0 || w <= q)
continue;
if (ver[p][q] != 0)
continue;
if (c[p][q] == color)
continue;
dfs(p, q, c[p][q]);
}
}
int main() {
int i, j, k, cnt = 0;
cin >> h >> w;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
char a;
cin >> a;
if (a == '.')
c[i][j] = 0;
else
c[i][j] = 1;
}
}
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++)
ver[i][j] = 0;
}
sc.assign(2 * h * w, 0);
sd.assign(2 * h * w, 0);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (ver[i][j] != 0)
continue;
dfs(i, j, c[i][j]);
num++;
}
}
ll ans = 0;
for (i = 0; i < num; i++) {
ans += sc[i] * sd[i];
}
cout << ans << endl;
}
|
replace
| 201 | 203 | 201 | 203 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = INF; // disable
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
template <class C> void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c),
std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
struct UnionFind {
vector<int> rank, parent, size;
// +1 for 1-indexed nodes
UnionFind(int n) : rank(n + 1, 0), parent(n + 1), size(n + 1, 1) {
iota(parent.begin(), parent.end(), 0); // parent is itself
}
int root(int x) {
if (x != parent[x]) {
parent[x] = root(parent[x]);
}
return parent[x];
}
bool isSame(int x, int y) { return root(x) == root(y); }
bool unite(int x, int y) { return link(root(x), root(y)); }
bool link(int x, int y) {
if (x == y)
return false;
if (rank[x] > rank[y]) {
parent[y] = x;
size[x] += size[y];
} else {
parent[x] = y;
size[y] += size[x];
if (rank[x] == rank[y]) {
rank[y]++;
}
}
return true;
}
int getSize(int x) { return size[root(x)]; }
};
struct Combination {
vector<ll> fac, finv, inv;
Combination(ll maxN) {
maxN += 100; // for safety
fac.resize(maxN + 1);
finv.resize(maxN + 1);
inv.resize(maxN + 1);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i <= maxN; ++i) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll operator()(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
};
int main() {
int h, w;
cin >> h >> w;
int n = h * w;
vector<string> s(h);
for (int i = 0; i < h; ++i) {
cin >> s[i];
}
auto idx = [&](int y, int x) { return y * w + x; };
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
auto inside = [&](int y, int x) {
return 0 <= y && y < h && 0 <= x && x < w;
};
UnionFind uf(n);
map<int, pii> cnt; // par, bl, wh
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
for (int k = 0; k < 4; ++k) {
int ny = i + dy[k];
int nx = j + dx[k];
if (inside(ny, nx)) {
if (s[i][j] != s[ny][nx]) {
uf.unite(idx(i, j), idx(ny, nx));
}
}
}
}
}
ll ret = 0;
for (int i = 0; i < h * w; ++i) {
int bl = 0;
int wh = 0;
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
if (uf.parent[idx(y, x)] == i) {
if (s[y][x] == '.')
wh++;
else
bl++;
}
}
}
ret += bl * wh;
}
cout << ret << "\n";
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = INF; // disable
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
template <class C> void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c),
std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
struct UnionFind {
vector<int> rank, parent, size;
// +1 for 1-indexed nodes
UnionFind(int n) : rank(n + 1, 0), parent(n + 1), size(n + 1, 1) {
iota(parent.begin(), parent.end(), 0); // parent is itself
}
int root(int x) {
if (x != parent[x]) {
parent[x] = root(parent[x]);
}
return parent[x];
}
bool isSame(int x, int y) { return root(x) == root(y); }
bool unite(int x, int y) { return link(root(x), root(y)); }
bool link(int x, int y) {
if (x == y)
return false;
if (rank[x] > rank[y]) {
parent[y] = x;
size[x] += size[y];
} else {
parent[x] = y;
size[y] += size[x];
if (rank[x] == rank[y]) {
rank[y]++;
}
}
return true;
}
int getSize(int x) { return size[root(x)]; }
};
struct Combination {
vector<ll> fac, finv, inv;
Combination(ll maxN) {
maxN += 100; // for safety
fac.resize(maxN + 1);
finv.resize(maxN + 1);
inv.resize(maxN + 1);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i <= maxN; ++i) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll operator()(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
};
int main() {
int h, w;
cin >> h >> w;
int n = h * w;
vector<string> s(h);
for (int i = 0; i < h; ++i) {
cin >> s[i];
}
auto idx = [&](int y, int x) { return y * w + x; };
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
auto inside = [&](int y, int x) {
return 0 <= y && y < h && 0 <= x && x < w;
};
UnionFind uf(n);
map<int, pii> cnt; // par, bl, wh
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
for (int k = 0; k < 4; ++k) {
int ny = i + dy[k];
int nx = j + dx[k];
if (inside(ny, nx)) {
if (s[i][j] != s[ny][nx]) {
uf.unite(idx(i, j), idx(ny, nx));
}
}
}
}
}
ll ret = 0;
map<int, vector<pii>> roots;
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
roots[uf.root(idx(y, x))].emplace_back(y, x);
}
}
for (auto &p : roots) {
ll bl = 0;
ll wh = 0;
for (auto &yx : p.second) {
int y = yx.first;
int x = yx.second;
if (s[y][x] == '.')
wh++;
else
bl++;
}
ret += bl * wh;
}
cout << ret << "\n";
return 0;
}
|
replace
| 112 | 124 | 112 | 128 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define ll long long
void file() {
#ifndef ONLINE_JUDGE
freopen("a_input.txt", "r", stdin);
freopen("a_output.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
ll gcd(ll a, ll b) { return !b ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
vector<vector<char>> adj;
vector<vector<bool>> mem;
ll sum2 = 0, sum1 = 0;
int n, m;
bool valied(int i, int j) { return i >= 0 && j >= 0 && i < n && j < m; }
void dfs(int i, int j, char c) {
if (adj[i][j] != c)
return;
mem[i][j] = 1;
if (c == '#')
c = '.', sum1++;
else
c = '#', sum2++;
for (int k = 0; k < 4; k++) {
int x = dx[k] + i;
int y = dy[k] + j;
if (valied(x, y) && !mem[x][y])
dfs(x, y, c);
}
}
int main() {
file();
fast();
cin >> n >> m;
adj = vector<vector<char>>(n, vector<char>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> adj[i][j];
long long sum = 0;
mem = vector<vector<bool>>(n, vector<bool>(m, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (adj[i][j] == '#' && !mem[i][j]) {
sum2 = 0;
sum1 = 0;
dfs(i, j, '#');
sum += sum2 * sum1;
}
cout << sum;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define ll long long
void file() {
#ifndef ONLINE_JUDGE
freopen("a_input.txt", "r", stdin);
freopen("a_output.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
ll gcd(ll a, ll b) { return !b ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
vector<vector<char>> adj;
vector<vector<bool>> mem;
ll sum2 = 0, sum1 = 0;
int n, m;
bool valied(int i, int j) { return i >= 0 && j >= 0 && i < n && j < m; }
void dfs(int i, int j, char c) {
if (adj[i][j] != c)
return;
mem[i][j] = 1;
if (c == '#')
c = '.', sum1++;
else
c = '#', sum2++;
for (int k = 0; k < 4; k++) {
int x = dx[k] + i;
int y = dy[k] + j;
if (valied(x, y) && !mem[x][y])
dfs(x, y, c);
}
}
int main() {
// file();
fast();
cin >> n >> m;
adj = vector<vector<char>>(n, vector<char>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> adj[i][j];
long long sum = 0;
mem = vector<vector<bool>>(n, vector<bool>(m, 0));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (adj[i][j] == '#' && !mem[i][j]) {
sum2 = 0;
sum1 = 0;
dfs(i, j, '#');
sum += sum2 * sum1;
}
cout << sum;
}
|
replace
| 40 | 41 | 40 | 41 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
#include <vector>
typedef long long llong;
constexpr int kMaxN = 400;
constexpr int kMaxNN = kMaxN * kMaxN;
char maze[kMaxN + 3][kMaxN + 3];
int union_set_id[kMaxNN + 3];
int union_set_count0[kMaxNN + 3];
int union_set_count1[kMaxNN + 3];
bool tmp[kMaxNN + 3];
int GetRoot(int i) {
if (union_set_id[i] != i) {
return GetRoot(union_set_id[i]);
}
return i;
}
void UnionSetUnion(int i, int j) {
i = GetRoot(i);
j = GetRoot(j);
if (i == j) {
return;
}
union_set_id[i] = j;
union_set_count0[j] += union_set_count0[i];
union_set_count1[j] += union_set_count1[i];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", maze[i]);
for (int j = 0; j < m; ++j) {
union_set_id[i * m + j] = i * m + j;
union_set_count0[i * m + j] = maze[i][j] == '.';
union_set_count1[i * m + j] = maze[i][j] == '#';
}
}
int goi[] = {1, -1, 0, 0};
int goj[] = {0, 0, 1, -1};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c0 = maze[i][j];
for (int k = 0; k < 4; ++k) {
int i1 = i + goi[k];
int j1 = j + goj[k];
if (0 <= i1 && i1 < n && 0 <= j1 && j1 < m) {
char c1 = maze[i1][j1];
if (c0 != c1) {
// printf("union (%d,%d) and (%d,%d)\n", i, j, i1, j1);
UnionSetUnion(i * m + j, i1 * m + j1);
}
}
}
}
}
int nm = n * m;
for (int i = 0; i < nm; ++i) {
tmp[i] = false;
}
llong total = 0;
for (int i = 0; i < nm; ++i) {
int r = GetRoot(i);
if (!tmp[r]) {
tmp[r] = true;
total += llong(union_set_count0[r]) * llong(union_set_count1[r]);
}
}
printf("%lld\n", total);
return 0;
}
|
#include <cstdio>
#include <vector>
typedef long long llong;
constexpr int kMaxN = 400;
constexpr int kMaxNN = kMaxN * kMaxN;
char maze[kMaxN + 3][kMaxN + 3];
int union_set_id[kMaxNN + 3];
int union_set_count0[kMaxNN + 3];
int union_set_count1[kMaxNN + 3];
bool tmp[kMaxNN + 3];
int GetRoot(int i) {
if (union_set_id[i] != i) {
return union_set_id[i] = GetRoot(union_set_id[i]);
}
return i;
}
void UnionSetUnion(int i, int j) {
i = GetRoot(i);
j = GetRoot(j);
if (i == j) {
return;
}
union_set_id[i] = j;
union_set_count0[j] += union_set_count0[i];
union_set_count1[j] += union_set_count1[i];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", maze[i]);
for (int j = 0; j < m; ++j) {
union_set_id[i * m + j] = i * m + j;
union_set_count0[i * m + j] = maze[i][j] == '.';
union_set_count1[i * m + j] = maze[i][j] == '#';
}
}
int goi[] = {1, -1, 0, 0};
int goj[] = {0, 0, 1, -1};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c0 = maze[i][j];
for (int k = 0; k < 4; ++k) {
int i1 = i + goi[k];
int j1 = j + goj[k];
if (0 <= i1 && i1 < n && 0 <= j1 && j1 < m) {
char c1 = maze[i1][j1];
if (c0 != c1) {
// printf("union (%d,%d) and (%d,%d)\n", i, j, i1, j1);
UnionSetUnion(i * m + j, i1 * m + j1);
}
}
}
}
}
int nm = n * m;
for (int i = 0; i < nm; ++i) {
tmp[i] = false;
}
llong total = 0;
for (int i = 0; i < nm; ++i) {
int r = GetRoot(i);
if (!tmp[r]) {
tmp[r] = true;
total += llong(union_set_count0[r]) * llong(union_set_count1[r]);
}
}
printf("%lld\n", total);
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
// Manages Union-Find Forest.
class UnionFindForest {
std::vector<int> parent_;
std::vector<int> rank_;
std::vector<int> size_;
public:
// Initialize forest.
// parent_[i]=i, rank_[i]=0, size_[i]=1.
UnionFindForest(const int &n);
// Get the number of the root of the node q.
int Root(const int &q);
// Return true if the roots of x and y is same.
bool IsSame(const int &x, const int &y);
// Unite the tree x and tree y.
void Unite(int x, int y);
// Get the number of nodes which are the same group as node q.
int Size(const int &q);
};
UnionFindForest::UnionFindForest(const int &n) {
parent_.resize(n);
rank_.resize(n);
size_.resize(n);
for (int i = 0; i < n; i++) {
parent_[i] = i;
rank_[i] = 0;
size_[i] = 1;
}
}
int UnionFindForest::Size(const int &q) { return size_[Root(q)]; }
int UnionFindForest::Root(const int &q) {
if (parent_[q] == q) {
return q;
} else {
return parent_[q] = Root(parent_[q]);
}
}
bool UnionFindForest::IsSame(const int &x, const int &y) {
return Root(x) == Root(y);
}
void UnionFindForest::Unite(int x, int y) {
x = Root(x);
y = Root(y);
if (x == y)
return;
if (rank_[x] < rank_[y]) {
parent_[x] = y;
size_[y] += size_[x];
size_[x] = 0;
} else {
parent_[y] = x;
size_[x] += size_[y];
size_[y] = 0;
if (rank_[x] == rank_[y])
rank_[x]++;
}
}
int main(void) {
cout << std::fixed << std::setprecision(10);
cin.tie(0);
std::ios::sync_with_stdio(false);
int h, w;
cin >> h >> w;
// std::map<std::pair<int,int>,int> node_hash;
// std::map<int,std::pair<int,int>> map_hash;
char map[410][410];
for (int c = 0; c <= w + 1; c++) {
map[0][c] = '@';
map[h + 1][c] = '@';
}
for (int r = 1; r <= h; r++) {
map[r][0] = '@';
std::string s;
cin >> s;
for (int c = 1; c <= w; c++) {
map[r][c] = s[c - 1];
}
map[r][w + 1] = '@';
}
// int node_num=0;
// for(int r=1;r<=h;r++){
// for(int c=1;c<=w;c++){
// node_hash[std::make_pair(r,c)]=node_num;
// map_hash[node_num]=std::make_pair(r,c);
// node_num++;
//
// }
// }
UnionFindForest uf(h * w + 10);
for (int r = 1; r <= h; r++) {
for (int c = 1; c <= w; c++) {
for (int vr = -1; vr <= 1; vr++) {
for (int vc = -1; vc <= 1; vc++) {
if ((vr == 0 && vc != 0) || (vr != 0 && vc == 0)) {
if (map[r + vr][c + vc] != '@' &&
map[r][c] != map[r + vr][c + vc]) {
uf.Unite((r - 1) * w + c - 1, (r + vr - 1) * w + c + vc - 1);
}
}
}
}
}
}
int result = 0;
int w_count[1610] = {}, b_count[1610] = {};
for (int node = 0; node < h * w; node++) {
if (map[node / w + 1][node % w + 1] == '#') {
b_count[uf.Root(node)]++;
} else {
w_count[uf.Root(node)]++;
}
}
for (int i = 0; i < h * w; i++) {
result += b_count[i] * w_count[i];
}
cout << result << endl;
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
// Manages Union-Find Forest.
class UnionFindForest {
std::vector<int> parent_;
std::vector<int> rank_;
std::vector<int> size_;
public:
// Initialize forest.
// parent_[i]=i, rank_[i]=0, size_[i]=1.
UnionFindForest(const int &n);
// Get the number of the root of the node q.
int Root(const int &q);
// Return true if the roots of x and y is same.
bool IsSame(const int &x, const int &y);
// Unite the tree x and tree y.
void Unite(int x, int y);
// Get the number of nodes which are the same group as node q.
int Size(const int &q);
};
UnionFindForest::UnionFindForest(const int &n) {
parent_.resize(n);
rank_.resize(n);
size_.resize(n);
for (int i = 0; i < n; i++) {
parent_[i] = i;
rank_[i] = 0;
size_[i] = 1;
}
}
int UnionFindForest::Size(const int &q) { return size_[Root(q)]; }
int UnionFindForest::Root(const int &q) {
if (parent_[q] == q) {
return q;
} else {
return parent_[q] = Root(parent_[q]);
}
}
bool UnionFindForest::IsSame(const int &x, const int &y) {
return Root(x) == Root(y);
}
void UnionFindForest::Unite(int x, int y) {
x = Root(x);
y = Root(y);
if (x == y)
return;
if (rank_[x] < rank_[y]) {
parent_[x] = y;
size_[y] += size_[x];
size_[x] = 0;
} else {
parent_[y] = x;
size_[x] += size_[y];
size_[y] = 0;
if (rank_[x] == rank_[y])
rank_[x]++;
}
}
int main(void) {
cout << std::fixed << std::setprecision(10);
cin.tie(0);
std::ios::sync_with_stdio(false);
int h, w;
cin >> h >> w;
// std::map<std::pair<int,int>,int> node_hash;
// std::map<int,std::pair<int,int>> map_hash;
char map[410][410];
for (int c = 0; c <= w + 1; c++) {
map[0][c] = '@';
map[h + 1][c] = '@';
}
for (int r = 1; r <= h; r++) {
map[r][0] = '@';
std::string s;
cin >> s;
for (int c = 1; c <= w; c++) {
map[r][c] = s[c - 1];
}
map[r][w + 1] = '@';
}
// int node_num=0;
// for(int r=1;r<=h;r++){
// for(int c=1;c<=w;c++){
// node_hash[std::make_pair(r,c)]=node_num;
// map_hash[node_num]=std::make_pair(r,c);
// node_num++;
//
// }
// }
UnionFindForest uf(h * w + 10);
for (int r = 1; r <= h; r++) {
for (int c = 1; c <= w; c++) {
for (int vr = -1; vr <= 1; vr++) {
for (int vc = -1; vc <= 1; vc++) {
if ((vr == 0 && vc != 0) || (vr != 0 && vc == 0)) {
if (map[r + vr][c + vc] != '@' &&
map[r][c] != map[r + vr][c + vc]) {
uf.Unite((r - 1) * w + c - 1, (r + vr - 1) * w + c + vc - 1);
}
}
}
}
}
}
int64_t result = 0;
int64_t w_count[161000] = {}, b_count[161000] = {};
for (int node = 0; node < h * w; node++) {
if (map[node / w + 1][node % w + 1] == '#') {
b_count[uf.Root(node)]++;
} else {
w_count[uf.Root(node)]++;
}
}
for (int i = 0; i < h * w; i++) {
result += b_count[i] * w_count[i];
}
cout << result << endl;
return 0;
}
|
replace
| 135 | 137 | 135 | 137 |
0
| |
p03157
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
typedef char SINT8;
typedef short SINT16;
typedef int SINT32;
typedef long long SINT64;
typedef double DOUBLE;
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(a) ((a) > (0) ? (a) : -(a))
#define rep(i, a, b) for (SINT64(i) = SINT64(a); (i) < SINT64(b); (i)++)
#define rrep(i, a, b) for (SINT64(i) = SINT64(a); (i) >= SINT64(b); (i)--)
#define put(a) cout << (a) << endl
#define puts(a) cout << (a) << " "
#define INF 1000000001
#define MOD 1000000007
#define INF64 1000000000000000001
#define F first
#define S second
#define Pii pair<SINT32, SINT32>
#define Pll pair<SINT64, SINT64>
#define Piii pair<SINT32, pair<SINT32, SINT32>>
#define Plll pair<SINT64, pair<SINT64, SINT64>>
#define Vll(a, b, c) vector<vector<SINT64>> (a)((b),vector<SINT64>((c))
#define Vlll(a, b, c, d) vector<vector<vector<SINT64>>> (a)((b),vector<vector<SINT64>>((c),vector<SINT64>((d)))
using namespace std;
vector<vector<SINT64>> data(405, vector<SINT64>(405));
SINT64 H;
SINT64 W;
vector<vector<SINT64>> road(405, vector<SINT64>(405));
vector<vector<SINT64>> gg(405, vector<SINT64>(405));
SINT64 cnt = 0;
SINT64 dfs(SINT64 x, SINT64 y) {
SINT64 buf = 0;
SINT64 a;
SINT64 b;
road[x][y] = 1;
a = x;
b = y;
if (a != 0) {
a--;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
a = x;
b = y;
if (b != 0) {
b--;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
a = x;
b = y;
if (a != H - 1) {
a++;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
a = x;
b = y;
if (b != W - 1) {
b++;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
return buf;
}
int main() {
cin >> H;
cin >> W;
vector<Pll> root;
rep(i, 0, H) {
string s;
cin >> s;
rep(j, 0, W) {
if (s[j] == '#') {
data[i][j] = 1;
root.emplace_back(Pll(i, j));
}
}
}
SINT64 ans = 0;
rep(i, 0, root.size()) {
SINT64 x, y;
x = root[i].F;
y = root[i].S;
if (gg[x][y] == 0) {
cnt = 1;
rep(k, 0, H) { fill(road[k].begin(), road[k].end(), 0); }
SINT64 bbb = dfs(x, y);
ans += cnt * bbb;
}
}
put(ans);
return 0;
}
// vector<vector<SINT64>> data(N,vector<SINT32>(3));
////2次元配列 vector<vector<vector<SINT64>>>
//data(N,vector<vector<SINT64>>(3,vector<SINT64>(3))); //3次元配列
// Vll(data,N,N); //2次元配列
// Vlll(data,N,N,N); //3次元配列
// sort(data.begin(),data.end());
// sort(data.begin(),data.end(),std::greater<SINT64>());
// __gcd(A,B);
// 関数へのvectorポインタ渡し
// void dfs(SINT64 poi, SINT64 d, vector<vector<Pll>>& data) {
// }
/* 複数条件ソート
bool sortcompare(Pll A, Pll B) {
if(A.F == B.F){
return A.S > B.S;
} else {
return A.F < B.F;
}
}
sort(data.begin(),data.end(),sortcompare);
*/
// タプル
// vector<tuple<SINT64,SINT64,SINT64>> edges;
// edges.emplace_back(a,b,c);
// cout << get<0>(edges[i]);
// cout << get<1>(edges[i]);
// cout << get<2>(edges[i]);
// sort(begin(edges), end(edges)); //ソート
// data.emplace_back(BUF); //後ろに追加
// data.erase(std::unique(data.begin(), data.end()), data.end());
// //ソート後に使用 同じ値を消す
// data.insert(data.begin() + X, 0); //X番目の要素に0を挿入
// 隣接リスト
// vector<vector<SINT64>> data(N);
// data[ A ].emplace_back( B );
// 両端キュー
// deque<SINT64> data;
// data.emplace_front(buf); //先頭挿入
// lower_boundは値がなければ最大値(.size())を返す
// posi = lower_bound(data.begin(),data.end(), X) - data.begin();
// // X以上を探す posi = lower_bound(data.begin(),data.end(),make_pair(X,0)) -
// data.begin(); //pair
/* 文字列回転
string N;
cin >> N;
N = N[N.length()-1] + N.substr(0,N.length()-1);
s = to_string(i); //ストリング変換
*/
/* 文字列合成
string N,M;
cin >> N >> M;
SINT64 ans = 0;
ans = stoi(N+M);
*/
/* 文字列変更
string s; cin >> s;
rep(i,0,s.length()) {
s[i] = (((s[i]-'A' + N) % 26) + 'A');
}
put(s);
*/
/*
//ワーシャルフロイド
vector<vector<SINT64>> dist(N,vector<SINT64>(N,INF64));
rep(i,0,N) {
dist[i][i] = 0;
}
rep(k,0,N) {
rep(i,0,N) {
rep(j,0,N) {
dist[i][j] = MIN(dist[i][j],
dist[i][k]+dist[k][j]);
}
}
}
*/
/* 優先度付きキュー
priority_queue<SINT64, vector<SINT64>, greater<SINT64>> bufq;
//小さいほうから取り出せる priority_queue<SINT64, vector<SINT64>> bufq;
//大きいほうから取り出せる
bufq.push(X); //X を挿入
bufq.top(); //先頭データ読み
bufq.pop(); //先頭データ削除
*/
/* キュー
queue<SINT64> bufq; //宣言
bufq.push(0); //挿入
bufq.front(); //先頭データ読み
bufq.pop(); //先頭データ削除
*/
/* SET コンテナ
set<SINT64> data;
data.insert(X); //X を挿入
data.erase(data.begin()); //先頭を削除
data.erase(--data.end()); //末尾を削除
*data.begin(); //先頭要素にアクセス
*data.rbegin(); //末尾要素にアクセス
//全表示
set<SINT64>::iterator it; //イテレータを用意
for(it = data.begin(); it != data.end(); it++) {
cout << *it << " ";
}
cout << endl;
//N番目を一部表示
set<SINT64>::iterator it; // イテレータを用意
it = data.begin();
rep (i,0,N) {
it++;
}
cout << *it << endl;
*/
/* map
map<string,SINT32> mp;
SINT32 N = 0;
SINT32 mx = 0;
cin >> N;
for (SINT32 i = 0; i < N; i++) {
string s;
cin >> s;
mp[s]++;
}
for(auto it=mp.begin();it!=mp.end();it++) {
mx=max(mx,it->second);
}
//abc146E
map<SINT64,SINT64> mp;
rep(i,0,N+1) {
ans += mp[rui[i]];
mp[rui[i]]++;
bufq.push(rui[i]);
if (bufq.size() == M) {
mp[bufq.front()]--;
bufq.pop();
}
}
*/
/*
//順列全表示
//sortしてからでないと全列挙にならない
sort(data.begin(),data.end());
do {
cout << buf << endl;
rep(i,0,R) {
cout << data[i] << " ";
}
cout << endl;
} while (next_permutation(data.begin(),data.end()));
*/
/* bit数数え上げ
SINT64 bits64(SINT64 bits)
{
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
}
*/
// bitシフトのLONG対応
// ans += (1L<<50);
// 桁指定表示
// ans = ans * M_PI;
// cout << setprecision(15) << ans << endl;
// 桁数0埋め
// cout << std::setfill('0') << std::right << std::setw(2) << 5; //05
// 逆元 コンビネーション
/*
SINT64 modpow(SINT64 a, SINT64 p) {
if (p == 0) return 1;
if (p % 2 == 0) {
//pが偶数の時
SINT64 halfP = p / 2;
SINT64 half = modpow(a, halfP);
//a^(p/2) をhalfとして、half*halfを計算
return half * half % MOD;
} else {
//pが奇数の時は、偶数にするために1減らす
return a * modpow(a, p - 1) % MOD;
}
}
SINT64 calcComb(SINT64 a, SINT64 b) {
SINT64 Mul = 1;
SINT64 Div = 1;
SINT64 ans = 0;
if (b > a - b) {
return calcComb(a, a - b);
}
rep(i,0,b) {
Mul *= (a - i);
Div *= (i + 1);
Mul %= MOD;
Div %= MOD;
}
ans = Mul * modpow(Div, MOD - 2) % MOD;
return ans;
}
*/
/* UNION FIND
class UnionFind {
public:
vector<SINT64> parent;
UnionFind(SINT64 N) {
parent = vector<SINT64>(N+10, -1); //少し多めに
}
SINT64 root(SINT64 A) {
if (parent[A] < 0) {
return A;
} else {
parent[A] = root(parent[A]);
return parent[A];
}
}
SINT64 size(SINT64 A) {
return parent[root(A)] * (-1);
}
bool judge(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A == B) {
return true; //同じグループ
} else {
return false; //違うグループ
}
}
void connect(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A != B) {
if (size(A) < size(B)) {
swap(A, B);
}
parent[A] += parent[B];
parent[B] = A;
}
}
};
UnionFind uni(N);
*/
/*
class SegTree {
private:
SINT64 size;
vector<SINT64> node;
SINT64 jugdement(SINT64 a, SINT64 b) {
SINT64 ans = 0;
ans = a+b;
return ans;
}
public:
//コンストラクタ
SegTree(vector<SINT64> data) {
SINT64 ori_size;
ori_size = data.size();
size = 1;
while (size < ori_size) {
size *= 2;
}
node.resize(2*size-1, 0);
rep(i,0,ori_size) {
node[size-1+i] = data[i];
}
rrep(i,size-2,0) {
node[i] = jugdement(node[2*i+1], node[2*i+2]);
}
}
//データ更新
void update(SINT64 x, SINT64 val) {
x += (size - 1);
node[x] = val+node[x];
while(x > 0) {
x = (x - 1) / 2;
node[x] = jugdement(node[2*x+1], node[2*x+2]);
}
}
//データ取得 [a,b)
SINT64 getdata(SINT64 a, SINT64 b, SINT64 k = 0, SINT64 l = 0, SINT64 r
= -1) { if (r < 0) { r = size;
}
//要求範囲外
if ((r <= a) || (b <= l)) {
return 0;
}
//完全要求区間内
if ((a <= l) && (r <= b)) {
return node[k];
}
SINT64 vl = getdata(a, b, 2*k+1, l, (l+r)/2);
SINT64 vr = getdata(a, b, 2*k+2, (l+r)/2, r);
return jugdement(vl, vr);
}
//表示
void disp() {
rep(i,0,size) {
puts(node[size-1+i]);
} cout << endl;
}
void alldisp() {
SINT64 cnt = 0;
SINT64 end = 2;
while (1) {
puts(node[cnt]);
if (cnt == end-2) {
end *= 2;
cout << endl;
}
cnt++;
if (cnt == size*2-1) {
break;
}
}
}
};
SegTree seg(N);
*/
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
typedef char SINT8;
typedef short SINT16;
typedef int SINT32;
typedef long long SINT64;
typedef double DOUBLE;
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(a) ((a) > (0) ? (a) : -(a))
#define rep(i, a, b) for (SINT64(i) = SINT64(a); (i) < SINT64(b); (i)++)
#define rrep(i, a, b) for (SINT64(i) = SINT64(a); (i) >= SINT64(b); (i)--)
#define put(a) cout << (a) << endl
#define puts(a) cout << (a) << " "
#define INF 1000000001
#define MOD 1000000007
#define INF64 1000000000000000001
#define F first
#define S second
#define Pii pair<SINT32, SINT32>
#define Pll pair<SINT64, SINT64>
#define Piii pair<SINT32, pair<SINT32, SINT32>>
#define Plll pair<SINT64, pair<SINT64, SINT64>>
#define Vll(a, b, c) vector<vector<SINT64>> (a)((b),vector<SINT64>((c))
#define Vlll(a, b, c, d) vector<vector<vector<SINT64>>> (a)((b),vector<vector<SINT64>>((c),vector<SINT64>((d)))
using namespace std;
vector<vector<SINT64>> data(405, vector<SINT64>(405));
SINT64 H;
SINT64 W;
vector<vector<SINT64>> road(405, vector<SINT64>(405));
vector<vector<SINT64>> gg(405, vector<SINT64>(405));
SINT64 cnt = 0;
SINT64 dfs(SINT64 x, SINT64 y) {
SINT64 buf = 0;
SINT64 a;
SINT64 b;
road[x][y] = 1;
a = x;
b = y;
if (a != 0) {
a--;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
a = x;
b = y;
if (b != 0) {
b--;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
a = x;
b = y;
if (a != H - 1) {
a++;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
a = x;
b = y;
if (b != W - 1) {
b++;
if ((data[a][b] != data[x][y]) && (road[a][b] == 0)) {
if (data[a][b] == 0)
buf++;
if (data[a][b] == 1) {
gg[a][b] = 1;
cnt++;
}
buf += dfs(a, b);
}
}
return buf;
}
int main() {
cin >> H;
cin >> W;
vector<Pll> root;
rep(i, 0, H) {
string s;
cin >> s;
rep(j, 0, W) {
if (s[j] == '#') {
data[i][j] = 1;
root.emplace_back(Pll(i, j));
}
}
}
SINT64 ans = 0;
rep(i, 0, root.size()) {
SINT64 x, y;
x = root[i].F;
y = root[i].S;
if (gg[x][y] == 0) {
cnt = 1;
SINT64 bbb = dfs(x, y);
ans += cnt * bbb;
}
}
put(ans);
return 0;
}
// vector<vector<SINT64>> data(N,vector<SINT32>(3));
////2次元配列 vector<vector<vector<SINT64>>>
//data(N,vector<vector<SINT64>>(3,vector<SINT64>(3))); //3次元配列
// Vll(data,N,N); //2次元配列
// Vlll(data,N,N,N); //3次元配列
// sort(data.begin(),data.end());
// sort(data.begin(),data.end(),std::greater<SINT64>());
// __gcd(A,B);
// 関数へのvectorポインタ渡し
// void dfs(SINT64 poi, SINT64 d, vector<vector<Pll>>& data) {
// }
/* 複数条件ソート
bool sortcompare(Pll A, Pll B) {
if(A.F == B.F){
return A.S > B.S;
} else {
return A.F < B.F;
}
}
sort(data.begin(),data.end(),sortcompare);
*/
// タプル
// vector<tuple<SINT64,SINT64,SINT64>> edges;
// edges.emplace_back(a,b,c);
// cout << get<0>(edges[i]);
// cout << get<1>(edges[i]);
// cout << get<2>(edges[i]);
// sort(begin(edges), end(edges)); //ソート
// data.emplace_back(BUF); //後ろに追加
// data.erase(std::unique(data.begin(), data.end()), data.end());
// //ソート後に使用 同じ値を消す
// data.insert(data.begin() + X, 0); //X番目の要素に0を挿入
// 隣接リスト
// vector<vector<SINT64>> data(N);
// data[ A ].emplace_back( B );
// 両端キュー
// deque<SINT64> data;
// data.emplace_front(buf); //先頭挿入
// lower_boundは値がなければ最大値(.size())を返す
// posi = lower_bound(data.begin(),data.end(), X) - data.begin();
// // X以上を探す posi = lower_bound(data.begin(),data.end(),make_pair(X,0)) -
// data.begin(); //pair
/* 文字列回転
string N;
cin >> N;
N = N[N.length()-1] + N.substr(0,N.length()-1);
s = to_string(i); //ストリング変換
*/
/* 文字列合成
string N,M;
cin >> N >> M;
SINT64 ans = 0;
ans = stoi(N+M);
*/
/* 文字列変更
string s; cin >> s;
rep(i,0,s.length()) {
s[i] = (((s[i]-'A' + N) % 26) + 'A');
}
put(s);
*/
/*
//ワーシャルフロイド
vector<vector<SINT64>> dist(N,vector<SINT64>(N,INF64));
rep(i,0,N) {
dist[i][i] = 0;
}
rep(k,0,N) {
rep(i,0,N) {
rep(j,0,N) {
dist[i][j] = MIN(dist[i][j],
dist[i][k]+dist[k][j]);
}
}
}
*/
/* 優先度付きキュー
priority_queue<SINT64, vector<SINT64>, greater<SINT64>> bufq;
//小さいほうから取り出せる priority_queue<SINT64, vector<SINT64>> bufq;
//大きいほうから取り出せる
bufq.push(X); //X を挿入
bufq.top(); //先頭データ読み
bufq.pop(); //先頭データ削除
*/
/* キュー
queue<SINT64> bufq; //宣言
bufq.push(0); //挿入
bufq.front(); //先頭データ読み
bufq.pop(); //先頭データ削除
*/
/* SET コンテナ
set<SINT64> data;
data.insert(X); //X を挿入
data.erase(data.begin()); //先頭を削除
data.erase(--data.end()); //末尾を削除
*data.begin(); //先頭要素にアクセス
*data.rbegin(); //末尾要素にアクセス
//全表示
set<SINT64>::iterator it; //イテレータを用意
for(it = data.begin(); it != data.end(); it++) {
cout << *it << " ";
}
cout << endl;
//N番目を一部表示
set<SINT64>::iterator it; // イテレータを用意
it = data.begin();
rep (i,0,N) {
it++;
}
cout << *it << endl;
*/
/* map
map<string,SINT32> mp;
SINT32 N = 0;
SINT32 mx = 0;
cin >> N;
for (SINT32 i = 0; i < N; i++) {
string s;
cin >> s;
mp[s]++;
}
for(auto it=mp.begin();it!=mp.end();it++) {
mx=max(mx,it->second);
}
//abc146E
map<SINT64,SINT64> mp;
rep(i,0,N+1) {
ans += mp[rui[i]];
mp[rui[i]]++;
bufq.push(rui[i]);
if (bufq.size() == M) {
mp[bufq.front()]--;
bufq.pop();
}
}
*/
/*
//順列全表示
//sortしてからでないと全列挙にならない
sort(data.begin(),data.end());
do {
cout << buf << endl;
rep(i,0,R) {
cout << data[i] << " ";
}
cout << endl;
} while (next_permutation(data.begin(),data.end()));
*/
/* bit数数え上げ
SINT64 bits64(SINT64 bits)
{
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
}
*/
// bitシフトのLONG対応
// ans += (1L<<50);
// 桁指定表示
// ans = ans * M_PI;
// cout << setprecision(15) << ans << endl;
// 桁数0埋め
// cout << std::setfill('0') << std::right << std::setw(2) << 5; //05
// 逆元 コンビネーション
/*
SINT64 modpow(SINT64 a, SINT64 p) {
if (p == 0) return 1;
if (p % 2 == 0) {
//pが偶数の時
SINT64 halfP = p / 2;
SINT64 half = modpow(a, halfP);
//a^(p/2) をhalfとして、half*halfを計算
return half * half % MOD;
} else {
//pが奇数の時は、偶数にするために1減らす
return a * modpow(a, p - 1) % MOD;
}
}
SINT64 calcComb(SINT64 a, SINT64 b) {
SINT64 Mul = 1;
SINT64 Div = 1;
SINT64 ans = 0;
if (b > a - b) {
return calcComb(a, a - b);
}
rep(i,0,b) {
Mul *= (a - i);
Div *= (i + 1);
Mul %= MOD;
Div %= MOD;
}
ans = Mul * modpow(Div, MOD - 2) % MOD;
return ans;
}
*/
/* UNION FIND
class UnionFind {
public:
vector<SINT64> parent;
UnionFind(SINT64 N) {
parent = vector<SINT64>(N+10, -1); //少し多めに
}
SINT64 root(SINT64 A) {
if (parent[A] < 0) {
return A;
} else {
parent[A] = root(parent[A]);
return parent[A];
}
}
SINT64 size(SINT64 A) {
return parent[root(A)] * (-1);
}
bool judge(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A == B) {
return true; //同じグループ
} else {
return false; //違うグループ
}
}
void connect(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A != B) {
if (size(A) < size(B)) {
swap(A, B);
}
parent[A] += parent[B];
parent[B] = A;
}
}
};
UnionFind uni(N);
*/
/*
class SegTree {
private:
SINT64 size;
vector<SINT64> node;
SINT64 jugdement(SINT64 a, SINT64 b) {
SINT64 ans = 0;
ans = a+b;
return ans;
}
public:
//コンストラクタ
SegTree(vector<SINT64> data) {
SINT64 ori_size;
ori_size = data.size();
size = 1;
while (size < ori_size) {
size *= 2;
}
node.resize(2*size-1, 0);
rep(i,0,ori_size) {
node[size-1+i] = data[i];
}
rrep(i,size-2,0) {
node[i] = jugdement(node[2*i+1], node[2*i+2]);
}
}
//データ更新
void update(SINT64 x, SINT64 val) {
x += (size - 1);
node[x] = val+node[x];
while(x > 0) {
x = (x - 1) / 2;
node[x] = jugdement(node[2*x+1], node[2*x+2]);
}
}
//データ取得 [a,b)
SINT64 getdata(SINT64 a, SINT64 b, SINT64 k = 0, SINT64 l = 0, SINT64 r
= -1) { if (r < 0) { r = size;
}
//要求範囲外
if ((r <= a) || (b <= l)) {
return 0;
}
//完全要求区間内
if ((a <= l) && (r <= b)) {
return node[k];
}
SINT64 vl = getdata(a, b, 2*k+1, l, (l+r)/2);
SINT64 vr = getdata(a, b, 2*k+2, (l+r)/2, r);
return jugdement(vl, vr);
}
//表示
void disp() {
rep(i,0,size) {
puts(node[size-1+i]);
} cout << endl;
}
void alldisp() {
SINT64 cnt = 0;
SINT64 end = 2;
while (1) {
puts(node[cnt]);
if (cnt == end-2) {
end *= 2;
cout << endl;
}
cnt++;
if (cnt == size*2-1) {
break;
}
}
}
};
SegTree seg(N);
*/
|
replace
| 145 | 146 | 145 | 146 |
TLE
| |
p03157
|
C++
|
Runtime Error
|
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
const int INF = 100010001;
const ll LINF = (ll)INF * INF * 10;
struct UnionFind {
vector<int> par; // 親を指すvector,-par[親]は木のサイズ
UnionFind(int n) : par(n, -1) {} // uniteで親を埋め込んでいく必要あり
int root(int x) { // 親をたどる&データの整理
if (par[x] < 0)
return x;
return par[x] = root(par[x]);
}
bool unite(int x, int y) { // データの結合
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
bool same(int x, int y) { return root(x) == root(y); } // 所属判定
int size(int x) { return -par[root(x)]; } // 木のサイズ
} uft(1600);
int main() {
int h, w;
cin >> h >> w;
vs s(h);
rep(i, h) { cin >> s[i]; }
int di[4] = {0, 1, -1, 0};
int dj[4] = {1, 0, 0, -1};
ll ans = 0;
rep(i, h) {
rep(j, w) {
int now = i * w + j;
if (uft.size(now) != 1)
continue;
queue<int> que;
que.push(now);
int cou = 0;
while (!que.empty()) {
int nn = que.front();
que.pop();
if (s[nn / w][nn % w] == '.')
cou++;
rep(k, 4) {
int ni = nn / w + di[k];
int nj = nn % w + dj[k];
if (ni < 0 or nj < 0 or ni > h - 1 or nj > w - 1)
continue;
if (s[ni][nj] == s[ni - di[k]][nj - dj[k]])
continue;
if (uft.same(now, ni * w + nj))
continue;
que.push(ni * w + nj);
uft.unite(now, ni * w + nj);
}
}
ll aa = uft.size(now);
ans += (aa - cou) * cou;
}
}
cout << ans << endl;
}
|
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
const int INF = 100010001;
const ll LINF = (ll)INF * INF * 10;
struct UnionFind {
vector<int> par; // 親を指すvector,-par[親]は木のサイズ
UnionFind(int n) : par(n, -1) {} // uniteで親を埋め込んでいく必要あり
int root(int x) { // 親をたどる&データの整理
if (par[x] < 0)
return x;
return par[x] = root(par[x]);
}
bool unite(int x, int y) { // データの結合
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
bool same(int x, int y) { return root(x) == root(y); } // 所属判定
int size(int x) { return -par[root(x)]; } // 木のサイズ
} uft(160000);
int main() {
int h, w;
cin >> h >> w;
vs s(h);
rep(i, h) { cin >> s[i]; }
int di[4] = {0, 1, -1, 0};
int dj[4] = {1, 0, 0, -1};
ll ans = 0;
rep(i, h) {
rep(j, w) {
int now = i * w + j;
if (uft.size(now) != 1)
continue;
queue<int> que;
que.push(now);
int cou = 0;
while (!que.empty()) {
int nn = que.front();
que.pop();
if (s[nn / w][nn % w] == '.')
cou++;
rep(k, 4) {
int ni = nn / w + di[k];
int nj = nn % w + dj[k];
if (ni < 0 or nj < 0 or ni > h - 1 or nj > w - 1)
continue;
if (s[ni][nj] == s[ni - di[k]][nj - dj[k]])
continue;
if (uft.same(now, ni * w + nj))
continue;
que.push(ni * w + nj);
uft.unite(now, ni * w + nj);
}
}
ll aa = uft.size(now);
ans += (aa - cou) * cou;
}
}
cout << ans << endl;
}
|
replace
| 36 | 37 | 36 | 37 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
const int maxn = 430;
int n, m, col[maxn], vis[maxn], black, white;
char s[maxn][maxn];
inline int code(int x, int y) { return x * m + y + 1; }
vector<int> G[160010];
void dfs(int u) {
if (col[u])
black++;
else
white++;
vis[u] = true;
for (auto v : G[u])
if (!vis[v])
dfs(v);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
scanf("%s", s[i]);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
col[code(i, j)] = s[i][j] == '#';
auto chkLink = [&](int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) {
if (s[x][y] != s[i][j]) {
G[code(i, j)].push_back(code(x, y));
}
}
};
chkLink(i - 1, j);
chkLink(i + 1, j);
chkLink(i, j - 1);
chkLink(i, j + 1);
}
}
int tot = n * m;
ll ans = 0;
for (int i = 1; i <= tot; ++i)
if (!vis[i]) {
black = white = 0;
dfs(i);
ans += 1LL * black * white;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
const int maxn = 430;
int n, m, col[160010], vis[160010], black, white;
char s[maxn][maxn];
inline int code(int x, int y) { return x * m + y + 1; }
vector<int> G[160010];
void dfs(int u) {
if (col[u])
black++;
else
white++;
vis[u] = true;
for (auto v : G[u])
if (!vis[v])
dfs(v);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
scanf("%s", s[i]);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
col[code(i, j)] = s[i][j] == '#';
auto chkLink = [&](int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) {
if (s[x][y] != s[i][j]) {
G[code(i, j)].push_back(code(x, y));
}
}
};
chkLink(i - 1, j);
chkLink(i + 1, j);
chkLink(i, j - 1);
chkLink(i, j + 1);
}
}
int tot = n * m;
ll ans = 0;
for (int i = 1; i <= tot; ++i)
if (!vis[i]) {
black = white = 0;
dfs(i);
ans += 1LL * black * white;
}
printf("%lld\n", ans);
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) for (long long i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
vector<pair<string, P>> vec;
// Union-Find
#define MAX_N 20001
long long par[MAX_N]; // 親
long long rankuf[MAX_N]; // 木の深さ
// n要素で初期化
void init(long long n) {
for (long long i = 0; i < n; i++) {
par[i] = i;
rankuf[i] = 0;
}
}
// 木の根を求める
long long find(long long x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
// xとyの属する集合を併合
void unite(long long x, long long y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rankuf[x] < rankuf[y]) {
par[x] = y;
} else {
par[y] = x;
if (rankuf[x] == rankuf[y])
rankuf[x]++;
}
}
// xとyが同じ集合に属するか否か
bool same(long long x, long long y) { return find(x) == find(y); }
int main() {
long long W;
long long H;
scanf("%lld", &H);
vector<string> S(H - 1 + 1);
scanf("%lld", &W);
for (int i = 0; i <= H - 1; i++) {
cin >> S[i];
}
init(H * W);
rep(i, H) {
rep(j, W) {
if (i - 1 >= 0 && S[i][j] != S[i - 1][j])
unite(i * W + j, (i - 1) * W + j);
if (i + 1 < H && S[i][j] != S[i + 1][j])
unite(i * W + j, (i + 1) * W + j);
if (j - 1 >= 0 && S[i][j] != S[i][j - 1])
unite(i * W + j, i * W + j - 1);
if (j + 1 < W && S[i][j] != S[i][j + 1])
unite(i * W + j, i * W + j + 1);
}
}
vector<ll> b(H * W), w(H * W);
rep(i, H) {
rep(j, W) {
if (S[i][j] == '#')
b[find(i * W + j)]++;
else
w[find(i * W + j)]++;
}
}
ll res = 0;
rep(i, H * W) { res += b[i] * w[i]; }
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) for (long long i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
vector<pair<string, P>> vec;
// Union-Find
#define MAX_N 200001
long long par[MAX_N]; // 親
long long rankuf[MAX_N]; // 木の深さ
// n要素で初期化
void init(long long n) {
for (long long i = 0; i < n; i++) {
par[i] = i;
rankuf[i] = 0;
}
}
// 木の根を求める
long long find(long long x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
// xとyの属する集合を併合
void unite(long long x, long long y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rankuf[x] < rankuf[y]) {
par[x] = y;
} else {
par[y] = x;
if (rankuf[x] == rankuf[y])
rankuf[x]++;
}
}
// xとyが同じ集合に属するか否か
bool same(long long x, long long y) { return find(x) == find(y); }
int main() {
long long W;
long long H;
scanf("%lld", &H);
vector<string> S(H - 1 + 1);
scanf("%lld", &W);
for (int i = 0; i <= H - 1; i++) {
cin >> S[i];
}
init(H * W);
rep(i, H) {
rep(j, W) {
if (i - 1 >= 0 && S[i][j] != S[i - 1][j])
unite(i * W + j, (i - 1) * W + j);
if (i + 1 < H && S[i][j] != S[i + 1][j])
unite(i * W + j, (i + 1) * W + j);
if (j - 1 >= 0 && S[i][j] != S[i][j - 1])
unite(i * W + j, i * W + j - 1);
if (j + 1 < W && S[i][j] != S[i][j + 1])
unite(i * W + j, i * W + j + 1);
}
}
vector<ll> b(H * W), w(H * W);
rep(i, H) {
rep(j, W) {
if (S[i][j] == '#')
b[find(i * W + j)]++;
else
w[find(i * W + j)]++;
}
}
ll res = 0;
rep(i, H * W) { res += b[i] * w[i]; }
cout << res << endl;
return 0;
}
|
replace
| 24 | 25 | 24 | 25 |
0
| |
p03157
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
class unionfind {
vector<int> p;
public:
void init(int n) {
for (int i = 0; i < n; i++) {
p.push_back(i);
}
}
void merge(int m, int n) {
if (find(m) == find(n))
return;
p.at(find(m)) = find(n);
}
int find(int n) {
if (p.at(n) == n)
return n;
return p.at(n) = find(p.at(n));
}
};
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++)
cin >> s.at(i);
unionfind t;
t.init(h * w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (j < w - 1 && s.at(i).at(j) != s.at(i).at(j + 1)) {
t.merge(i * w + j, i * w + j + 1);
}
if (i < h - 1 && s.at(i).at(j) != s.at(i + 1).at(j)) {
t.merge(i * w + j, (i + 1) * w + j);
}
}
}
vector<pair<int, int>> c;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
int root = t.find(i * w + j);
if (s.at(i).at(j) == '#') {
c.at(root).first++;
} else {
c.at(root).second++;
}
}
}
long total = 0;
for (int i = 0; i < h * w; i++) {
total += (long)c.at(i).first * c.at(i).second;
}
cout << total << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
class unionfind {
vector<int> p;
public:
void init(int n) {
for (int i = 0; i < n; i++) {
p.push_back(i);
}
}
void merge(int m, int n) {
if (find(m) == find(n))
return;
p.at(find(m)) = find(n);
}
int find(int n) {
if (p.at(n) == n)
return n;
return p.at(n) = find(p.at(n));
}
};
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++)
cin >> s.at(i);
unionfind t;
t.init(h * w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (j < w - 1 && s.at(i).at(j) != s.at(i).at(j + 1)) {
t.merge(i * w + j, i * w + j + 1);
}
if (i < h - 1 && s.at(i).at(j) != s.at(i + 1).at(j)) {
t.merge(i * w + j, (i + 1) * w + j);
}
}
}
vector<pair<int, int>> c(h * w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
int root = t.find(i * w + j);
if (s.at(i).at(j) == '#') {
c.at(root).first++;
} else {
c.at(root).second++;
}
}
}
long total = 0;
for (int i = 0; i < h * w; i++) {
total += (long)c.at(i).first * c.at(i).second;
}
cout << total << endl;
}
|
replace
| 44 | 45 | 44 | 45 |
-6
|
terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 8) >= this->size() (which is 0)
|
p03158
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iomanip> // << fixed << precision(10)
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, s, t) for (int i = s; i < t; i++)
#define REP(i, n) FOR(i, 0, n)
#define PRINT(s) cout << s << "\n"
#define SORT(A) sort(A.begin(), A.end())
#define EACHPRINT(A, T) \
for_each(begin(A), end(A), [&](T i) { cout << i << " "; }); \
cout << "\n"
typedef long long lint;
typedef pair<lint, lint> P;
bool lessPair(const P &l, const P &r) { return l.second < r.second; }
bool lessindex(const P &l, const P &r) { return l.first < r.first; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
lint N;
cin >> N;
lint Q;
cin >> Q;
vector<lint> A(N);
REP(i, N) {
lint a;
cin >> a;
A[i] = a;
}
vector<P> X(Q);
vector<lint> res(Q);
REP(i, Q) {
lint a;
cin >> a;
X[i] = P(i, a);
}
sort(X.begin(), X.end(), lessPair);
lint tmp = 0;
FOR(i, N / 2, N) { tmp += A[i]; }
lint i1, i2;
if (N % 2 == 1) {
i1 = 0;
i2 = N - 2 - (N - 3) / 2;
} else {
i1 = 1;
i2 = N - 2 - (N - 4) / 2;
}
REP(i, Q) {
lint x = X[i].second;
while (x > (A[i1] + A[i2]) / 2) {
tmp -= A[i2];
tmp += A[i1];
i1 += 2;
i2 += 1;
}
// cout << "x " << x << "\n";
// cout << i1 << " " << i2 << "\n";
res[X[i].first] = tmp;
}
REP(i, Q) { cout << res[i] << "\n"; }
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip> // << fixed << precision(10)
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, s, t) for (int i = s; i < t; i++)
#define REP(i, n) FOR(i, 0, n)
#define PRINT(s) cout << s << "\n"
#define SORT(A) sort(A.begin(), A.end())
#define EACHPRINT(A, T) \
for_each(begin(A), end(A), [&](T i) { cout << i << " "; }); \
cout << "\n"
typedef long long lint;
typedef pair<lint, lint> P;
bool lessPair(const P &l, const P &r) { return l.second < r.second; }
bool lessindex(const P &l, const P &r) { return l.first < r.first; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
lint N;
cin >> N;
lint Q;
cin >> Q;
vector<lint> A(N);
REP(i, N) {
lint a;
cin >> a;
A[i] = a;
}
vector<P> X(Q);
vector<lint> res(Q);
REP(i, Q) {
lint a;
cin >> a;
X[i] = P(i, a);
}
sort(X.begin(), X.end(), lessPair);
lint tmp = 0;
FOR(i, N / 2, N) { tmp += A[i]; }
lint i1, i2;
if (N % 2 == 1) {
i1 = 0;
i2 = N - 2 - (N - 3) / 2;
} else {
i1 = 1;
i2 = N - 2 - (N - 4) / 2;
}
REP(i, Q) {
lint x = X[i].second;
while (x > (A[i1] + A[i2]) / 2 && i1 != i2) {
tmp -= A[i2];
tmp += A[i1];
i1 += 2;
i2 += 1;
}
// cout << "x " << x << "\n";
// cout << i1 << " " << i2 << "\n";
res[X[i].first] = tmp;
}
REP(i, Q) { cout << res[i] << "\n"; }
return 0;
}
|
replace
| 66 | 67 | 66 | 67 |
0
| |
p03158
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
using namespace std;
long long int n, q, m, p[20000] = {}, a[300000] = {}, b, lef[200000], h, w,
tab[500][500] = {}, same = 0, qu[300000],
rui[300000] = {}, giza[300000] = {}, res[300000] = {};
int nibutan(long long int check, int left, int right) {
int nibu = (left + right) / 2;
if (right - left == 1 && check < lef[nibu]) {
return nibu + 1;
}
if (check >= lef[nibu] && check < lef[nibu - 1]) {
return nibu;
} else if (check >= lef[nibu]) {
return nibutan(check, left, nibu);
} else {
return nibutan(check, nibu, right);
}
}
int main() {
string str[600];
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
rui[i] = rui[i - 1] + a[i];
}
for (int i = 1; i <= q; i++) {
cin >> qu[i];
}
giza[1] = a[1];
for (int i = 2; i <= n; i++) {
giza[i] = giza[i - 2] + a[i];
}
res[0] = giza[n];
res[1] = giza[n];
for (int i = 2; i <= n / 2; i++) {
res[i] = rui[n] - rui[n - i] + giza[n - 2 * i];
}
res[n / 2 + 1] = rui[n] - rui[n / 2];
for (int i = 0; i <= n / 2; i++) {
lef[i] = (a[n - i] + a[n - 2 * i]) / 2 + 1;
}
lef[n / 2 + 1] = 0;
for (int i = 1; i <= q; i++) {
cout << res[nibutan(qu[i], 0, n / 2 + 1)] << endl;
}
}
|
#include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
using namespace std;
long long int n, q, m, p[20000] = {}, a[300000] = {}, b, lef[200000], h, w,
tab[500][500] = {}, same = 0, qu[300000],
rui[300000] = {}, giza[300000] = {}, res[300000] = {};
int nibutan(long long int check, int left, int right) {
int nibu = (left + right) / 2;
if (right - left == 1 && check < lef[nibu]) {
return nibu + 1;
}
if (check >= lef[nibu] && check < lef[nibu - 1]) {
return nibu;
} else if (check >= lef[nibu]) {
return nibutan(check, left, nibu);
} else {
return nibutan(check, nibu, right);
}
}
int main() {
string str[600];
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
rui[i] = rui[i - 1] + a[i];
}
for (int i = 1; i <= q; i++) {
cin >> qu[i];
}
giza[1] = a[1];
for (int i = 2; i <= n; i++) {
giza[i] = giza[i - 2] + a[i];
}
res[0] = giza[n];
res[1] = giza[n];
for (int i = 2; i <= n / 2; i++) {
res[i] = rui[n] - rui[n - i] + giza[n - 2 * i];
}
res[n / 2 + 1] = rui[n] - rui[n / 2];
for (int i = 0; i <= n / 2; i++) {
lef[i] = (a[n - i] + a[n - 2 * i]) / 2 + 1;
}
lef[n / 2 + 1] = 0;
for (int i = 1; i <= q; i++) {
if (qu[i] > a[n]) {
cout << res[0] << endl;
} else {
cout << res[nibutan(qu[i], 0, n / 2 + 1)] << endl;
}
}
}
|
replace
| 58 | 60 | 58 | 63 |
TLE
| |
p03158
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define ll long long
#define mod 1000000007
#define maxn 410
inline ll read() {
ll x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-')
f = -1;
for (; '0' <= c && c <= '9'; c = getchar())
x = x * 10 + c - '0';
return x * f;
}
inline void write(ll x) {
static char buff[20], len;
len = 0;
if (x < 0)
putchar('-'), x = -x;
for (; x; x /= 10)
buff[len++] = x % 10;
if (!len)
putchar('0');
else
while (len)
putchar(buff[--len] + '0');
}
inline void writeln(ll x) {
write(x);
putchar('\n');
}
inline void writesp(ll x) {
write(x);
putchar(' ');
}
int a[maxn];
ll sum[maxn], sum0[maxn], sum1[maxn];
int n, q;
int find(int x) {
int l = 1, r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (x > a[mid])
l = mid + 1;
else
r = mid;
}
return l;
}
ll work(int x) {
// printf("%d ***************\n",x);
if (x >= a[n]) {
if (n & 1)
return sum1[n];
else
return sum0[n];
}
int l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) >> 1, pos = find(x * 2 - a[mid - 1]);
if (mid - pos > n - mid + 1)
r = mid - 1;
else
l = mid;
}
int pos = l - (n - l + 1);
// writeln(l);
return (sum[n] - sum[l - 1]) + ((pos & 1) ? sum0[pos - 1] : sum1[pos - 1]);
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++)
a[i] = read();
std::sort(a + 1, a + n + 1);
sum[0] = sum0[0] = sum1[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
sum0[i] = sum0[i - 1] + ((i & 1) ? 0 : a[i]);
sum1[i] = sum1[i - 1] + ((i & 1) ? a[i] : 0);
}
for (int i = 1; i <= q; i++) {
int x = read();
writeln(work(x));
}
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define ll long long
#define mod 1000000007
#define maxn 100010
inline ll read() {
ll x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-')
f = -1;
for (; '0' <= c && c <= '9'; c = getchar())
x = x * 10 + c - '0';
return x * f;
}
inline void write(ll x) {
static char buff[20], len;
len = 0;
if (x < 0)
putchar('-'), x = -x;
for (; x; x /= 10)
buff[len++] = x % 10;
if (!len)
putchar('0');
else
while (len)
putchar(buff[--len] + '0');
}
inline void writeln(ll x) {
write(x);
putchar('\n');
}
inline void writesp(ll x) {
write(x);
putchar(' ');
}
int a[maxn];
ll sum[maxn], sum0[maxn], sum1[maxn];
int n, q;
int find(int x) {
int l = 1, r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (x > a[mid])
l = mid + 1;
else
r = mid;
}
return l;
}
ll work(int x) {
// printf("%d ***************\n",x);
if (x >= a[n]) {
if (n & 1)
return sum1[n];
else
return sum0[n];
}
int l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) >> 1, pos = find(x * 2 - a[mid - 1]);
if (mid - pos > n - mid + 1)
r = mid - 1;
else
l = mid;
}
int pos = l - (n - l + 1);
// writeln(l);
return (sum[n] - sum[l - 1]) + ((pos & 1) ? sum0[pos - 1] : sum1[pos - 1]);
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++)
a[i] = read();
std::sort(a + 1, a + n + 1);
sum[0] = sum0[0] = sum1[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
sum0[i] = sum0[i - 1] + ((i & 1) ? 0 : a[i]);
sum1[i] = sum1[i - 1] + ((i & 1) ? a[i] : 0);
}
for (int i = 1; i <= q; i++) {
int x = read();
writeln(work(x));
}
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p03158
|
C++
|
Time Limit Exceeded
|
/* <ik:include(base.hpp)> */
/* subset of bits/stdc++.h */
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#define int LL
#define times(n, i) uptil(0, n, i)
#define rtimes(n, i) downto((n)-1, 0, i)
#define upto(f, t, i) \
for (auto i##0_to = (t), i = decltype(t)(f); i <= i##0_to; i++)
#define uptil(f, t, i) \
for (auto i##0_to = (t), i = decltype(t)(f); i < i##0_to; i++)
#define downto(f, t, i) \
for (auto i##0_to = decltype(f)(t), i = (f); i >= i##0_to; i--)
#define downtil(f, t, i) \
for (auto i##0_to = decltype(f)(t), i = (f); i > i##0_to; i--)
#define iter(v) begin(v), end(v)
#define citer(v) cbegin(v), cend(v)
#if defined(EBUG) && !defined(ONLINE_JUDGE)
#define debug true
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 2
#define _LIBCPP_DEBUG2 2
#define ln << endl
#define dd(x) cerr << #x << " = " << (x) << ", "
#define ddd(x) cerr << #x << " = " << (x)ln
#else
#define debug false
#define ln << '\n'
#define dd(x) cerr
#define ddd(x) cerr
#endif
#define tb << '\t'
#define sp << ' '
#define db dd
#define dbg ddd
#if __cplusplus >= 201703L
#if debug
#define PARABLE execution::par_unseq,
#else
#define PARABLE execution::seq,
#endif
#else
#define PARABLE /* none */
#endif
#define CS const
#define IL inline
#define RT return
#define TL template
#define lambda [&]
#define foldl accumulate
#define scanl accumulate
typedef struct unit {
} unit;
TL<class T> void amax(T &v, const T &a) { v = max(v, a); }
TL<class T> void amin(T &v, const T &a) { v = min(v, a); }
namespace kpl {
template <class V, class W> static inline void append(V &v, const W &w) {
copy(PARABLE citer(w), back_inserter(v));
}
template <class V>
static inline auto flatten(const V &xss, unsigned reserve_size = 0) {
vector<decltype(*begin(*begin(xss)))> ret;
ret.reserve(reserve_size);
for (const auto &xs : xss)
append(ret, xs);
ret.shrink_to_fit();
return move(ret);
}
template <class I>
static inline bool is_in(I x, I l,
I r) { /* Of course half-open interval [l,r) is used */
return l <= x && x < r;
}
} // namespace kpl
/* <ik:include(util.hpp)> */
#ifndef __cpp_lib_exchange_function
#define __cpp_lib_exchange_function 201304L
TL<class T, class U = T> T exchange(T &t, U &&u) {
T ret = move(t);
t = forward<U>(u);
return ret;
}
#endif
/* </ik:include(util.hpp)> */
/* <ik:include(mod.hpp)> */
#ifndef MOD
#ifdef MOD9
#define MOD 1000000009
#elif defined MOD998244353
#define MOD 998244353
#else
#define MOD 1000000007
#endif
#endif
/* <ik:include(power.hpp)> */
TL<class T> T power(T x, ULL n) {
T rt(1);
while (n) {
if (n % 2)
rt *= x;
x *= x;
n /= 2;
}
RT rt;
}
/* </ik:include(power.hpp)> */
IL int modulo(int a, int m) {
a %= m;
RT a >= 0 ? a : a + m;
}
TL<ULL mod = MOD> class MInt {
/*
int with modulo.
`mod` must be a prime for `log`.
`mod` must be coprime to `val` for `inv` and to `m.val` for `operator/` and
`operator/=`.
*/
/*! https://ei1333.github.io/luzhiled/snippets/other/mod-int.html */
public:
int val;
MInt() : val(0) {}
explicit MInt(int v) : val(modulo(v, mod)) {}
MInt &operator+=(CS MInt &m) {
val += m.val;
if (val >= mod)
val -= mod;
RT *this;
}
MInt &operator-=(CS MInt &m) {
val -= m.val;
if (val < 0)
val += mod;
RT *this;
}
MInt &operator*=(CS MInt &m) {
val = val * m.val % mod;
RT *this;
}
MInt &operator/=(CS MInt &m) {
val = val * m.inv().val % mod;
RT *this;
}
MInt operator+(CS MInt &m) CS { RT MInt(*this) += m; }
MInt operator-(CS MInt &m) CS { RT MInt(*this) -= m; }
MInt operator*(CS MInt &m) CS { RT MInt(*this) *= m; }
MInt operator/(CS MInt &m) CS { RT MInt(*this) /= m; }
MInt operator-() CS {
MInt m;
m.val = val ? mod - val : 0;
RT m;
}
bool operator==(CS MInt &m) CS { RT val == m.val; }
bool operator!=(CS MInt &m) CS { RT val != m.val; }
// MInt pow(int n)CS{MInt x(*this),rt(1);while(n){if(n%2)rt*=x;x*=x;n/=2;}RT
// rt;}
MInt pow(int n) CS { RT power(*this, n); }
MInt inv() CS {
int a = val, b = mod, x = 1, y = 0, t;
while (b) {
t = a / b;
swap(b, a -= t * b);
swap(y, x -= t * y);
}
RT(MInt) x;
}
friend ostream &operator<<(ostream &o, CS MInt<mod> &m) { RT o << m.val; }
friend istream &operator>>(istream &i, MInt<mod> &m) {
int v;
i >> v;
m = MInt<mod>(v);
RT i;
}
};
using mint = MInt<>;
#pragma rab : gsub \b(\d +) m\b mint(\1)
/* </ik:include(mod.hpp)> */
/* <ik:include(vector_usings.hpp)> */
TL<class T> using vec = vector<T>;
TL<class T> using vvec = vec<vec<T>>;
#define VUSE(v, t) \
using P##v = pair<t, t>; \
using V##v = vec<t>; \
using W##v = vvec<t>
VUSE(I, int);
VUSE(M, mint);
VUSE(PI, PI);
VUSE(PM, PM);
/* </ik:include(vector_usings.hpp)> */
/* <ik:include(debug.hpp)> */
TL<class T> IL istream &operator>>(istream &s, vec<T> &v) {
for (auto &&p : v)
s >> p;
RT s;
}
TL<class T, class S> IL ostream &operator<<(ostream &s, CS pair<T, S> &p) {
RT s << "(" << p.first << "," << p.second << ")";
}
TL<class T> IL ostream &operator<<(ostream &, CS vec<T> &);
TL<class T, class S> IL ostream &operator<<(ostream &, CS map<T, S> &);
#define DEFINE_ITER_OUTPUT(s, x, sep) \
{ \
int i = 0; \
for (CS auto &x##0_elem : x) { \
if (i++) \
s << sep; \
s << x##0_elem; \
} \
RT s; \
}
TL<class T> IL ostream &operator<<(ostream &s, CS vec<T> &v)
DEFINE_ITER_OUTPUT(s, v, ' ') TL<class T, class S> IL ostream &
operator<<(ostream &s, CS map<T, S> &m)
DEFINE_ITER_OUTPUT(s, m, ' ') TL<class T> IL ostream &
operator<<(ostream &s, CS vec<vec<T>> &w)
DEFINE_ITER_OUTPUT(s, w, '\n') TL<class T, class S> IL ostream &
operator<<(ostream &s, CS vec<map<T, S>> &v)
DEFINE_ITER_OUTPUT(s, v, '\n')
/* </ik:include(debug.hpp)> */
void solve();
signed main() {
if (debug) {
cerr << "mod = " << MOD ln;
} else {
cin.tie(0);
ios::sync_with_stdio(0);
}
cout << fixed << setprecision(20);
cerr << fixed << setprecision(20);
solve();
return 0;
}
/* </ik:include(base.hpp)> */
void solve() {
// NQN(A)N(X)
/* <foxy.memo-area> */
int N;
int Q;
cin >> N;
cin >> Q;
VI A(N);
times(N, Ri_0) { cin >> A[Ri_0]; }
VI X(Q);
times(Q, Ri_0) { cin >> X[Ri_0]; }
/* </foxy.memo-area> */
VI dp(N + 1), dr(N + 1);
times(N, i) dp[i + 1] = dp[i] + (N % 2 != i % 2) * A[i];
rtimes(N, i) dr[i] = dr[i + 1] + A[i];
if (debug)
cerr << dp ln << dr ln;
times(Q, i) {
int ok = 1, ng = (N + 1) / 2 + 1;
while (abs(ng - ok) > 1) {
int m = (ok + ng) / 2;
if (N - 2 * m + 1 >= 0 && A[N - m] - X[i] >= X[i] - A[N - 2 * m + 1]) {
ok = m;
} else {
ng = m;
}
cerr << m sp << ok sp << ng tb;
}
if (debug)
cerr << ok ln;
cout << dr[N - ok] + (N - ok * 2 >= 0 ? dp[N - ok * 2] : 0) ln;
}
}
|
/* <ik:include(base.hpp)> */
/* subset of bits/stdc++.h */
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#define int LL
#define times(n, i) uptil(0, n, i)
#define rtimes(n, i) downto((n)-1, 0, i)
#define upto(f, t, i) \
for (auto i##0_to = (t), i = decltype(t)(f); i <= i##0_to; i++)
#define uptil(f, t, i) \
for (auto i##0_to = (t), i = decltype(t)(f); i < i##0_to; i++)
#define downto(f, t, i) \
for (auto i##0_to = decltype(f)(t), i = (f); i >= i##0_to; i--)
#define downtil(f, t, i) \
for (auto i##0_to = decltype(f)(t), i = (f); i > i##0_to; i--)
#define iter(v) begin(v), end(v)
#define citer(v) cbegin(v), cend(v)
#if defined(EBUG) && !defined(ONLINE_JUDGE)
#define debug true
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 2
#define _LIBCPP_DEBUG2 2
#define ln << endl
#define dd(x) cerr << #x << " = " << (x) << ", "
#define ddd(x) cerr << #x << " = " << (x)ln
#else
#define debug false
#define ln << '\n'
#define dd(x) cerr
#define ddd(x) cerr
#endif
#define tb << '\t'
#define sp << ' '
#define db dd
#define dbg ddd
#if __cplusplus >= 201703L
#if debug
#define PARABLE execution::par_unseq,
#else
#define PARABLE execution::seq,
#endif
#else
#define PARABLE /* none */
#endif
#define CS const
#define IL inline
#define RT return
#define TL template
#define lambda [&]
#define foldl accumulate
#define scanl accumulate
typedef struct unit {
} unit;
TL<class T> void amax(T &v, const T &a) { v = max(v, a); }
TL<class T> void amin(T &v, const T &a) { v = min(v, a); }
namespace kpl {
template <class V, class W> static inline void append(V &v, const W &w) {
copy(PARABLE citer(w), back_inserter(v));
}
template <class V>
static inline auto flatten(const V &xss, unsigned reserve_size = 0) {
vector<decltype(*begin(*begin(xss)))> ret;
ret.reserve(reserve_size);
for (const auto &xs : xss)
append(ret, xs);
ret.shrink_to_fit();
return move(ret);
}
template <class I>
static inline bool is_in(I x, I l,
I r) { /* Of course half-open interval [l,r) is used */
return l <= x && x < r;
}
} // namespace kpl
/* <ik:include(util.hpp)> */
#ifndef __cpp_lib_exchange_function
#define __cpp_lib_exchange_function 201304L
TL<class T, class U = T> T exchange(T &t, U &&u) {
T ret = move(t);
t = forward<U>(u);
return ret;
}
#endif
/* </ik:include(util.hpp)> */
/* <ik:include(mod.hpp)> */
#ifndef MOD
#ifdef MOD9
#define MOD 1000000009
#elif defined MOD998244353
#define MOD 998244353
#else
#define MOD 1000000007
#endif
#endif
/* <ik:include(power.hpp)> */
TL<class T> T power(T x, ULL n) {
T rt(1);
while (n) {
if (n % 2)
rt *= x;
x *= x;
n /= 2;
}
RT rt;
}
/* </ik:include(power.hpp)> */
IL int modulo(int a, int m) {
a %= m;
RT a >= 0 ? a : a + m;
}
TL<ULL mod = MOD> class MInt {
/*
int with modulo.
`mod` must be a prime for `log`.
`mod` must be coprime to `val` for `inv` and to `m.val` for `operator/` and
`operator/=`.
*/
/*! https://ei1333.github.io/luzhiled/snippets/other/mod-int.html */
public:
int val;
MInt() : val(0) {}
explicit MInt(int v) : val(modulo(v, mod)) {}
MInt &operator+=(CS MInt &m) {
val += m.val;
if (val >= mod)
val -= mod;
RT *this;
}
MInt &operator-=(CS MInt &m) {
val -= m.val;
if (val < 0)
val += mod;
RT *this;
}
MInt &operator*=(CS MInt &m) {
val = val * m.val % mod;
RT *this;
}
MInt &operator/=(CS MInt &m) {
val = val * m.inv().val % mod;
RT *this;
}
MInt operator+(CS MInt &m) CS { RT MInt(*this) += m; }
MInt operator-(CS MInt &m) CS { RT MInt(*this) -= m; }
MInt operator*(CS MInt &m) CS { RT MInt(*this) *= m; }
MInt operator/(CS MInt &m) CS { RT MInt(*this) /= m; }
MInt operator-() CS {
MInt m;
m.val = val ? mod - val : 0;
RT m;
}
bool operator==(CS MInt &m) CS { RT val == m.val; }
bool operator!=(CS MInt &m) CS { RT val != m.val; }
// MInt pow(int n)CS{MInt x(*this),rt(1);while(n){if(n%2)rt*=x;x*=x;n/=2;}RT
// rt;}
MInt pow(int n) CS { RT power(*this, n); }
MInt inv() CS {
int a = val, b = mod, x = 1, y = 0, t;
while (b) {
t = a / b;
swap(b, a -= t * b);
swap(y, x -= t * y);
}
RT(MInt) x;
}
friend ostream &operator<<(ostream &o, CS MInt<mod> &m) { RT o << m.val; }
friend istream &operator>>(istream &i, MInt<mod> &m) {
int v;
i >> v;
m = MInt<mod>(v);
RT i;
}
};
using mint = MInt<>;
#pragma rab : gsub \b(\d +) m\b mint(\1)
/* </ik:include(mod.hpp)> */
/* <ik:include(vector_usings.hpp)> */
TL<class T> using vec = vector<T>;
TL<class T> using vvec = vec<vec<T>>;
#define VUSE(v, t) \
using P##v = pair<t, t>; \
using V##v = vec<t>; \
using W##v = vvec<t>
VUSE(I, int);
VUSE(M, mint);
VUSE(PI, PI);
VUSE(PM, PM);
/* </ik:include(vector_usings.hpp)> */
/* <ik:include(debug.hpp)> */
TL<class T> IL istream &operator>>(istream &s, vec<T> &v) {
for (auto &&p : v)
s >> p;
RT s;
}
TL<class T, class S> IL ostream &operator<<(ostream &s, CS pair<T, S> &p) {
RT s << "(" << p.first << "," << p.second << ")";
}
TL<class T> IL ostream &operator<<(ostream &, CS vec<T> &);
TL<class T, class S> IL ostream &operator<<(ostream &, CS map<T, S> &);
#define DEFINE_ITER_OUTPUT(s, x, sep) \
{ \
int i = 0; \
for (CS auto &x##0_elem : x) { \
if (i++) \
s << sep; \
s << x##0_elem; \
} \
RT s; \
}
TL<class T> IL ostream &operator<<(ostream &s, CS vec<T> &v)
DEFINE_ITER_OUTPUT(s, v, ' ') TL<class T, class S> IL ostream &
operator<<(ostream &s, CS map<T, S> &m)
DEFINE_ITER_OUTPUT(s, m, ' ') TL<class T> IL ostream &
operator<<(ostream &s, CS vec<vec<T>> &w)
DEFINE_ITER_OUTPUT(s, w, '\n') TL<class T, class S> IL ostream &
operator<<(ostream &s, CS vec<map<T, S>> &v)
DEFINE_ITER_OUTPUT(s, v, '\n')
/* </ik:include(debug.hpp)> */
void solve();
signed main() {
if (debug) {
cerr << "mod = " << MOD ln;
} else {
cin.tie(0);
ios::sync_with_stdio(0);
}
cout << fixed << setprecision(20);
cerr << fixed << setprecision(20);
solve();
return 0;
}
/* </ik:include(base.hpp)> */
void solve() {
// NQN(A)N(X)
/* <foxy.memo-area> */
int N;
int Q;
cin >> N;
cin >> Q;
VI A(N);
times(N, Ri_0) { cin >> A[Ri_0]; }
VI X(Q);
times(Q, Ri_0) { cin >> X[Ri_0]; }
/* </foxy.memo-area> */
VI dp(N + 1), dr(N + 1);
times(N, i) dp[i + 1] = dp[i] + (N % 2 != i % 2) * A[i];
rtimes(N, i) dr[i] = dr[i + 1] + A[i];
if (debug)
cerr << dp ln << dr ln;
times(Q, i) {
int ok = 1, ng = (N + 1) / 2 + 1;
while (abs(ng - ok) > 1) {
int m = (ok + ng) / 2;
if (N - 2 * m + 1 >= 0 && A[N - m] - X[i] >= X[i] - A[N - 2 * m + 1]) {
ok = m;
} else {
ng = m;
}
// cerr << m sp << ok sp << ng tb;
}
if (debug)
cerr << ok ln;
cout << dr[N - ok] + (N - ok * 2 >= 0 ? dp[N - ok * 2] : 0) ln;
}
}
|
replace
| 279 | 280 | 279 | 280 |
TLE
| |
p03158
|
C++
|
Runtime Error
|
// #include "bits/stdc++.h"
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
// typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
struct P {
int q, i, ans;
P() : P(0, 0, 0) {}
P(int q, int i, int ans) : q(q), i(i), ans(ans) {}
};
int A[100010];
P Q[100010];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, q;
int s = 0;
cin >> N >> M;
rep(i, 0, N) {
cin >> A[i];
if (N / 2 <= i) {
s += A[i];
}
}
rep(i, 0, M) {
cin >> q;
Q[i] = P(q, i, 0);
}
sort(Q, Q + M, [](const P &a, const P &b) { return a.q < b.q; });
int l, r;
if (N % 2 == 1) {
l = 0;
r = N / 2;
} else {
l = 1;
r = N / 2;
}
int qi = 0;
while (l < r) {
int x = (A[r] + A[l]) / 2;
while (Q[qi].q <= x) {
Q[qi].ans = s;
qi++;
}
s -= A[r] - A[l];
l += 2;
r++;
}
while (qi < M) {
Q[qi].ans = s;
qi++;
}
sort(Q, Q + M, [](const P &a, const P &b) { return a.i < b.i; });
rep(i, 0, M) { cout << Q[i].ans << endl; }
return 0;
}
|
// #include "bits/stdc++.h"
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
// typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
struct P {
int q, i, ans;
P() : P(0, 0, 0) {}
P(int q, int i, int ans) : q(q), i(i), ans(ans) {}
};
int A[100010];
P Q[100010];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, q;
int s = 0;
cin >> N >> M;
rep(i, 0, N) {
cin >> A[i];
if (N / 2 <= i) {
s += A[i];
}
}
rep(i, 0, M) {
cin >> q;
Q[i] = P(q, i, 0);
}
sort(Q, Q + M, [](const P &a, const P &b) { return a.q < b.q; });
int l, r;
if (N % 2 == 1) {
l = 0;
r = N / 2;
} else {
l = 1;
r = N / 2;
}
int qi = 0;
while (l < r) {
int x = (A[r] + A[l]) / 2;
while (qi < M && Q[qi].q <= x) {
Q[qi].ans = s;
qi++;
}
s -= A[r] - A[l];
l += 2;
r++;
}
while (qi < M) {
Q[qi].ans = s;
qi++;
}
sort(Q, Q + M, [](const P &a, const P &b) { return a.i < b.i; });
rep(i, 0, M) { cout << Q[i].ans << endl; }
return 0;
}
|
replace
| 103 | 104 | 103 | 104 |
0
| |
p03158
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<int, ll> pil;
const int INF = 1e9;
const int maxN = 1e3 + 5;
int n, Q;
int a[maxN];
int X[maxN];
bool check(int x, int m) {
int z = a[n - m + 1];
if (z < x)
return false;
int d = z - x;
int y = x - d;
int p = lower_bound(a + 1, a + 1 + n, y) - a;
int q = n - m + 1;
if ((q - p + 1) >= m) {
return true;
} else {
return false;
}
}
ll s[maxN];
ll t[maxN];
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] + (ll)a[i];
}
t[1] = a[1];
t[2] = a[2];
for (int i = 3; i <= n; i++) {
t[i] = t[i - 2] + (ll)a[i];
}
for (int i = 1; i <= Q; i++) {
scanf("%d", &X[i]);
int L = 1, R = n;
int ans = 0;
ll cnt = 0;
while (L <= R) {
int mid = (L + R) / 2;
if (check(X[i], mid)) {
ans = mid;
L = mid + 1;
} else {
R = mid - 1;
}
}
int p = n - ans + 1;
int q = n - 2 * ans + 1;
cnt += (s[n] - s[p - 1]);
cnt += t[q - 1];
cout << cnt << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<int, ll> pil;
const int INF = 1e9;
const int maxN = 1e5 + 5;
int n, Q;
int a[maxN];
int X[maxN];
bool check(int x, int m) {
int z = a[n - m + 1];
if (z < x)
return false;
int d = z - x;
int y = x - d;
int p = lower_bound(a + 1, a + 1 + n, y) - a;
int q = n - m + 1;
if ((q - p + 1) >= m) {
return true;
} else {
return false;
}
}
ll s[maxN];
ll t[maxN];
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] + (ll)a[i];
}
t[1] = a[1];
t[2] = a[2];
for (int i = 3; i <= n; i++) {
t[i] = t[i - 2] + (ll)a[i];
}
for (int i = 1; i <= Q; i++) {
scanf("%d", &X[i]);
int L = 1, R = n;
int ans = 0;
ll cnt = 0;
while (L <= R) {
int mid = (L + R) / 2;
if (check(X[i], mid)) {
ans = mid;
L = mid + 1;
} else {
R = mid - 1;
}
}
int p = n - ans + 1;
int q = n - 2 * ans + 1;
cnt += (s[n] - s[p - 1]);
cnt += t[q - 1];
cout << cnt << endl;
}
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p03158
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
constexpr ll inf = static_cast<ll>(1e17);
constexpr int iinf = static_cast<int>(1e9);
constexpr ll mod = static_cast<ll>(1e9 + 7);
int n, q;
ll a[100005];
ll sum[100005], sum2[100005];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> n >> q;
for (int i = 1; i <= n; ++i) {
std::cin >> a[i];
sum[i] = sum[i - 1] + a[i];
sum2[i] = sum2[i - 1];
if (i % 2 == 1)
sum2[i] += a[i];
}
for (int i = 0; i < q; ++i) {
ll x;
std::cin >> x;
int l = 1, r = n;
while (r - l > 0) {
auto aa = (l + r) / 2;
auto bb = (aa + n) / 2;
auto aval = std::abs(x - a[aa]);
auto bval = std::abs(x - a[bb]);
if (aval < bval) {
r = aa;
} else if (aval > bval) {
l = aa;
} else {
l = r = aa;
}
}
r = l + (n - l + 1) / 2 - 1;
ll ans = sum[n] - sum[r];
if (n - r == r - l + 1) {
if ((l - 1) % 2 == 1)
ans += sum2[l - 1];
else
ans += sum[l - 1] - sum2[l - 1];
} else if (l > 1) {
if ((l - 2) % 2 == 1)
ans += sum2[l - 2];
else
ans += sum[l - 2] - sum2[l - 2];
}
std::cout << ans << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
constexpr ll inf = static_cast<ll>(1e17);
constexpr int iinf = static_cast<int>(1e9);
constexpr ll mod = static_cast<ll>(1e9 + 7);
int n, q;
ll a[100005];
ll sum[100005], sum2[100005];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> n >> q;
for (int i = 1; i <= n; ++i) {
std::cin >> a[i];
sum[i] = sum[i - 1] + a[i];
sum2[i] = sum2[i - 1];
if (i % 2 == 1)
sum2[i] += a[i];
}
for (int i = 0; i < q; ++i) {
ll x;
std::cin >> x;
int l = 1, r = n;
while (r - l > 0) {
auto aa = (l + r) / 2;
auto bb = (aa + n) / 2;
auto aval = std::abs(x - a[aa]);
auto bval = std::abs(x - a[bb]);
if (aval < bval) {
r = aa;
} else if (aval > bval) {
if (l == aa)
l = aa + 1;
else
l = aa;
} else {
l = r = aa;
}
}
r = l + (n - l + 1) / 2 - 1;
ll ans = sum[n] - sum[r];
if (n - r == r - l + 1) {
if ((l - 1) % 2 == 1)
ans += sum2[l - 1];
else
ans += sum[l - 1] - sum2[l - 1];
} else if (l > 1) {
if ((l - 2) % 2 == 1)
ans += sum2[l - 2];
else
ans += sum[l - 2] - sum2[l - 2];
}
std::cout << ans << std::endl;
}
return 0;
}
|
replace
| 39 | 40 | 39 | 43 |
TLE
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.