solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
long long n, m, k;
struct node {
int s, t, d;
long long w;
} a[100005];
const int N = 100005;
vector<pair<int, int>> add[N], sub[N];
pair<long long, long long> val[N];
long long dp[N][202];
long long getans(long long pos, long long m) {
if (pos == n + 1) return 0;
if (dp[pos][m] != -1) return dp[pos][m];
long long ans = 2000000000000000000;
if (m > 0) {
amin(ans, getans(val[pos].second + 1, m) + val[pos].first);
amin(ans, getans(pos + 1, m - 1));
} else {
amin(ans, getans(val[pos].second + 1, 0) + val[pos].first);
}
return dp[pos][m] = ans;
}
int _runtimeTerror_() {
memset(dp, -1, sizeof(dp));
cin >> n >> m >> k;
long long i, j;
for (i = 0; i < k; ++i) {
cin >> a[i].s >> a[i].t >> a[i].d >> a[i].w;
add[a[i].s].push_back({a[i].w, a[i].d});
sub[a[i].t + 1].push_back({a[i].w, a[i].d});
}
multiset<pair<int, int>> s;
for (i = 1; i <= n; ++i) {
for (auto j : add[i]) s.insert(j);
for (auto j : sub[i]) s.erase(s.find(j));
if (s.empty())
val[i].first = 0, val[i].second = i;
else {
val[i] = *s.rbegin();
}
}
cout << getans(1, m);
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
cerr << "\n" << 1.0 * clock() / CLOCKS_PER_SEC;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[]{1, -1, 0, 0, 1, -1, 1, -1};
int dy[]{0, 0, 1, -1, 1, -1, -1, 1};
const int size = 10000007;
int ar[size], A[size], B[size], inA[size], inB[size];
void cal() {
for (long long i = 2; i < size; i++) {
if (ar[i] == 0) {
for (int j = i; j < size; j += i) ar[j] = i;
}
}
}
int main() {
int n, m, t;
cal();
while (cin >> n >> m) {
for (int i = 0; i < n; i++) {
scanf("%d", &t);
inA[i] = t;
while (t > 1) A[ar[t]]++, t /= ar[t];
}
for (int i = 0; i < m; i++) {
scanf("%d", &t);
inB[i] = t;
while (t > 1) B[ar[t]]++, t /= ar[t];
}
vector<long long> Aa, Ba, AA, BB;
for (int i = 2; i < size; i++) {
int dif = abs(A[i] - B[i]);
if (A[i] > B[i]) {
A[i] = dif;
B[i] = 0;
} else if (A[i] < B[i]) {
B[i] = dif;
A[i] = 0;
} else
A[i] = B[i] = 0;
}
for (int i = 0; i < n; i++) {
long long tmp = 1;
while (inA[i] > 1) {
if (A[ar[inA[i]]] > 0) A[ar[inA[i]]]--, tmp *= ar[inA[i]];
inA[i] /= ar[inA[i]];
}
inA[i] = tmp;
}
for (int i = 0; i < m; i++) {
long long tmp = 1;
while (inB[i] > 1) {
if (B[ar[inB[i]]] > 0) B[ar[inB[i]]]--, tmp *= ar[inB[i]];
inB[i] /= ar[inB[i]];
}
inB[i] = tmp;
}
cout << n << " " << m << endl;
for (int i = 0; i < n; i++) cout << inA[i] << " ";
cout << endl;
for (int i = 0; i < m; i++) cout << inB[i] << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
int main() {
int y, b, r;
int arr[3];
cin >> y >> b >> r;
for (int i = y; i >= 1; i--) {
if (b >= i + 1 && r >= i + 2) {
cout << 3 * i + 3 << endl;
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long n, k, p1, p2, x, q, ans1, ans2, y, l, m, temp, ans;
long long minn = INT_MAX, temp1, temp2, maxx = INT_MIN, num1, num2, num, sum;
int main() {
q = 1;
while (q--) {
cin >> n;
string s[n];
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> s[i];
}
int a1 = INT_MAX;
int b1 = INT_MAX;
int c1 = INT_MAX;
int abc = INT_MAX;
int last = INT_MAX;
int fir = 0, sec = 0, thi = 0;
for (int i = 0; i < n; i++) {
fir = 0, sec = 0, thi = 0;
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] == 'A')
fir = 1;
else if (s[i][j] == 'B')
sec = 1;
else
thi = 1;
}
if (fir == 1 && sec == 0 && thi == 0) {
if (a[i] < a1) {
a1 = a[i];
}
}
if (fir == 0 && sec == 1 && thi == 0) {
if (a[i] < b1) {
b1 = a[i];
}
}
if (fir == 0 && sec == 0 && thi == 1) {
if (a[i] < c1) {
c1 = a[i];
}
}
if (fir == 1 && sec == 1 && thi == 1) {
if (a[i] < abc) abc = a[i];
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
fir = 0, sec = 0, thi = 0;
for (int k = 0; k < s[i].size(); k++) {
if (s[i][k] == 'A')
fir = 1;
else if (s[i][k] == 'B')
sec = 1;
else
thi = 1;
}
for (int k = 0; k < s[j].size(); k++) {
if (s[j][k] == 'A')
fir = 1;
else if (s[j][k] == 'B')
sec = 1;
else
thi = 1;
}
if (fir == 1 && sec == 1 && thi == 1) {
if (a[i] + a[j] < last) {
last = a[i] + a[j];
}
}
}
}
if (a1 != INT_MAX && b1 != INT_MAX && c1 != INT_MAX)
ans1 = a1 + b1 + c1;
else
ans1 = INT_MAX;
ans = fmin(fmin(ans1, abc), last);
if (ans > 500000)
cout << -1;
else
cout << ans;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 20;
const int mod = 1e9 + 7;
int dp[1 << 24], sum;
int p[2], a[25], k;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &p[i]);
dp[0] = 1;
for (int mask = 1; mask < (1 << n); mask++) {
sum = 0;
for (int i = 0; i < n; i++) {
if ((mask >> i) & 1) {
dp[mask] += dp[(mask ^ (1 << i))];
if (dp[mask] >= mod) dp[mask] -= mod;
sum += a[i];
}
}
for (int i = 0; i < k; i++)
if (sum == p[i]) dp[mask] = 0;
}
printf("%d", dp[(1 << n) - 1]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 207;
double dp[N][N][N * 2];
int n, l, k, a[N];
double p[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> l >> k;
for (int i = 1, tp; i <= n; i++) cin >> tp, p[i] = 1.0 * tp / 100;
for (int i = 1; i <= n; i++) cin >> a[i];
dp[0][0][k + 200] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int o = 0; o <= 400; o++) {
dp[i][j][o] += dp[i - 1][j][o] * (1 - p[i]);
if (j) dp[i][j][min(o + a[i], 400)] += dp[i - 1][j - 1][o] * p[i];
}
}
}
double res = 0;
for (int i = l; i <= n; i++)
for (int j = 200; j <= 400; j++) {
res += dp[n][i][j];
}
cout << fixed << setprecision(10) << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
int cnt[N];
int a[N][2];
int main() {
int n, k, x;
scanf("%d %d %d", &n, &k, &x);
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < n; ++i) {
int foo;
scanf("%d", &foo);
++cnt[foo];
}
while (k--) {
for (int i = 0, j = 0; i < N; ++i) {
a[i][j] = cnt[i] / 2;
a[i][1 - j] = (cnt[i] + 1) / 2;
j = (j + cnt[i]) % 2;
}
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < N; ++i) {
cnt[i] += a[i][0];
cnt[i ^ x] += a[i][1];
}
}
int mx = -1, mn = N;
for (int i = 0; i < N; ++i) {
if (cnt[i]) mx = i;
if (cnt[N - 1 - i]) mn = N - 1 - i;
}
printf("%d %d", mx, mn);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
int n, m, a[maxn], sum[maxn], pre[maxn];
long long ans;
inline int getsum(int l, int r) { return sum[min(r, m)] - sum[l ? l - 1 : 0]; }
inline void upd(long long x, long long y) {
if (x >= 2 && y >= 2) ans = max(ans, x * y);
}
inline pair<int, int> merge(const pair<int, int> &a, const int &b) {
return pair<int, int>(max(a.first, b), max(a.second, min(a.first, b)));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), sum[a[i]]++, m = max(m, a[i]);
for (int i = 1; i <= m; i++)
sum[i] += sum[i - 1], pre[i] = (sum[i] > sum[i - 1]) ? i : pre[i - 1];
for (int y = 2; y <= m; y++) {
pair<int, int> p = pair<int, int>(-1, -1);
long long sumy = 0;
for (int i = 0, j = 0; i <= m; i += y, j++)
sumy += (long long)getsum(i, i + y - 1) * j;
for (int l = (m / y) * y, r = m + 1; l >= 0; r = l, l -= y) {
int tmp = (p.first >= 0) + (p.second >= 0), v = pre[r - 1];
if (v >= l) {
p = merge(p, v % y);
if (getsum(v, v) == 1) {
v = pre[v - 1];
if (v >= l) p = merge(p, v % y);
} else
p = merge(p, v % y);
}
v = pre[r - 1];
if (v >= l && p.first == v % y) tmp++;
if (p.first >= 0) {
long long x = (l + p.first) / 2, remy = sumy - (l / y);
upd(min(x, remy), y);
}
if (p.second >= 0) {
long long x = l + p.second, remy = sumy - (l / y) * 2;
upd(min(x, remy), y);
if (tmp >= 2) {
x = l + p.first, remy--;
upd(min(x, remy), y);
}
}
}
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, d, m, a[200005], ans[200005];
set<pair<int, int> > s;
int main() {
cin >> n >> m >> d;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
s.insert({a[i], i});
}
int day = 0;
while (!s.empty()) {
day++;
int p = s.begin()->second;
ans[p] = day;
s.erase(s.begin());
while (true) {
auto j = s.lower_bound({a[p] + 1 + d, 0});
if (j == s.end()) break;
p = j->second;
ans[p] = day;
s.erase(j);
}
}
cout << day << '\n';
for (i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int nxt[1000010][26];
int query[1000010];
int ans[1000010];
char buf[10];
bitset<1000010> eowf;
int nowrk = 0;
void dfs(int n, int scst, int scrk, int leowst, int typst) {
if (eowf[n]) {
ans[n] = min(scst + nowrk + 1 - scrk, leowst + typst);
leowst = ans[n];
typst = 0;
if (ans[n] - nowrk < scst - scrk) {
scst = ans[n];
scrk = nowrk;
}
++nowrk;
} else {
if (leowst + typst - nowrk < scst - scrk) {
scst = leowst + typst;
scrk = nowrk;
}
}
for (int i = 0; i < 26; i++) {
if (nxt[n][i]) {
dfs(nxt[n][i], scst, scrk, leowst, typst + 1);
}
}
}
int main() {
int n, m, t;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%s", &t, buf);
nxt[t][buf[0] - 97] = i;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
eowf[t] = 1;
query[i] = t;
}
dfs(0, 0, 0, 0, 0);
for (int i = 0; i < m; i++) {
printf("%d%c", ans[query[i]], i == m - 1 ? '\n' : ' ');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
template <class T>
inline T bigMod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T modInv(T a, T M) {
return bigMod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T>
inline T egcd(T a, T b, T &x, T &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
T d = egcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
template <class T>
inline T eModInv(T a, T m) {
T x, y;
exgcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
template <class T>
inline string int2String(T a) {
ostringstream str;
str << a;
return str.str();
}
template <class T>
inline T string2int(string a) {
stringstream str(a);
T b;
str >> b;
return b;
}
template <class T>
inline void read(T &r) {
r = 0;
int f = 1;
char ch = getchar();
while (ch < '0' or ch > '9') {
f = (ch == '-' ? -1 : 1), ch = getchar();
}
while (ch >= '0' and ch <= '9') {
r = r * 10 + ch - '0', ch = getchar();
}
r *= f;
}
const int dr[] = {0, 1, 0, -1, -1, 1, 1, -1, -2, -2, 2, 2, -1, -1, 1, 1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1, -1, 1, -1, 1, -2, 2, -2, 2};
int sSz;
vector<int> G[10004];
unordered_map<string, int> mp;
int res[10004];
bool ar[10004][10004];
int main() {
int n;
scanf("%d", &n);
while (n--) {
char second[25], tt[25];
int id1, id2;
scanf("%s %s", second, tt);
if (!mp[second])
id1 = mp[second] = ++sSz;
else
id1 = mp[second];
if (!mp[tt])
id2 = mp[tt] = ++sSz;
else
id2 = mp[tt];
ar[id1][id2] = ar[id2][id1] = 1;
G[id1].push_back(id2);
G[id2].push_back(id1);
}
for (int i = 1; i <= sSz; i++) {
int tmp[10004] = {0};
int ans = 0;
int mx = 0;
for (auto &u : G[i]) {
for (auto &v : G[u]) {
if (v != i and ar[v][i] == 0) tmp[v]++, mx = max(tmp[v], mx);
}
}
for (int j = 1; j <= sSz; j++) {
if (i != j and ar[i][j] == 0 and mx == tmp[j]) ans++;
}
res[i] = ans;
}
printf("%d\n", sSz);
for (auto &par : mp) {
printf("%s %d\n", par.first.c_str(), res[par.second]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
long long n, i, sum = 1, k = 100, m;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
sum = sum * 2;
}
if (n >= 13) {
m = n - 13;
for (i = 1; i <= m; i++) {
k = k * 2;
}
sum = sum - k;
}
printf("%I64d", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int mx = max(a, b);
int d = 1 + (6 - mx);
int d1, k;
k = 6;
d1 = d;
while (1) {
b = k;
k = d1 % k;
d1 = b;
if (k == 0) break;
}
cout << (d / d1) << "/" << (6 / d1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int k, r;
cin >> k >> r;
for (int i = 1; i <= 10; i++) {
if (((k * i) - r) % 10 == 0 || (k * i) % 10 == 0) {
cout << i;
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long int INFF = 1e17;
const double EPS = 1e-9;
const long long int MOD = 1e9 + 7;
const int MAXN = 1e5 + 10;
long long int a, b, h, w, n, x[MAXN];
map<pair<long long int, long long int>, int> dp[MAXN];
int f(int index, long long int currh, long long int currw) {
if (dp[index].find(make_pair(currh, currw)) != dp[index].end())
return dp[index][make_pair(currh, currw)];
long long int nh = currh * h, nw = currw * w;
if (nh >= a && nw >= b) return dp[index][make_pair(currh, currw)] = 0;
if (index >= n) return dp[index][make_pair(currh, currw)] = INF;
int ans = INF;
if (nh < a) ans = min(ans, 1 + f(index + 1, currh * x[index], currw));
if (nw < b) ans = min(ans, 1 + f(index + 1, currh, currw * x[index]));
return dp[index][make_pair(currh, currw)] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b >> h >> w >> n;
for (int i = 0; i < n; i++) cin >> x[i];
sort(x, x + n);
reverse(x, x + n);
n = min(n, (long long int)40);
int ans = INF;
ans = min(ans, f(0, 1, 1));
for (int i = 0; i < n; i++) dp[i].clear();
swap(a, b);
ans = min(ans, f(0, 1, 1));
ans == INF ? cout << -1 << endl : cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long t = 1;
while (t--) solve();
}
void solve() {
int n, k;
cin >> n >> k;
int ar[n];
for (long i = 0; i < n; i++) cin >> ar[i];
long count = 0;
int mx = -1;
for (long i = 0; i < n; i++) {
if (ar[i] > k) break;
count++;
mx = i;
}
for (long i = n - 1; i >= 0; i--) {
if (ar[i] > k || i == mx) break;
count++;
}
cout << count << endl;
;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast")
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int inf = 2e9 + 7;
const long long INF = INT64_MAX;
double eps = 1e-6;
const int mod = 1e9 + 7;
const int N = 1e3 + 10;
const double pi = acos(-1.0);
int s[N][N];
int main() {
int _;
scanf("%d", &_);
while (_--) {
int n, m, res = 0;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%d", &s[i][j]);
}
if ((n + m) % 2) {
int d = (n + m) / 2;
int now = 1;
int yi, ling;
vector<pair<int, int> > g;
g.clear();
for (int i = 1; i <= m; i++) {
yi = ling = 0;
int x = 1, y = i;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d - 1)].first += yi,
g[d - 1 - (now - d - 1)].second += ling;
now++;
}
for (int j = 2; j <= n; j++) {
yi = ling = 0;
int x = j, y = m;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d - 1)].first += yi,
g[d - 1 - (now - d - 1)].second += ling;
now++;
}
for (int i = 0; i <= d - 1; i++) res += min(g[i].first, g[i].second);
} else {
int d = (n + m) / 2;
int now = 1;
int yi, ling;
vector<pair<int, int> > g;
g.clear();
for (int i = 1; i <= m; i++) {
yi = ling = 0;
int x = 1, y = i;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d)].first += yi, g[d - 1 - (now - d)].second += ling;
now++;
}
for (int j = 2; j <= n; j++) {
yi = ling = 0;
int x = j, y = m;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d)].first += yi, g[d - 1 - (now - d)].second += ling;
now++;
}
for (int i = 0; i <= d - 2; i++) res += min(g[i].first, g[i].second);
}
cout << res << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 5;
string s;
vector<int> dp(nax);
void fun(int n) {
if (n == 0) return;
if (s[n] == s[n - 1]) {
dp[n - 1] = dp[n] + 1;
} else {
dp[n - 1] = dp[n];
}
fun(n - 1);
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
int n = s.length();
fun(n);
int m;
cin >> m;
while (m--) {
int x, y;
cin >> x >> y;
x--, y--;
int ans = abs(dp[y] - dp[x]);
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, i, j, k, x, y, z, n;
cin >> t;
while (t--) {
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
if (arr[n - 1] > arr[0]) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
printf("%d ", n);
int i;
for (i = 1; i <= n - 1; i++) printf("%d ", i);
}
| 1 |
#include <bits/stdc++.h>
long long a, b, c, i, j, k, p, q, x[100000], y[100000];
int main() {
scanf("%lld%lld", &a, &b);
c = a + b;
for (k = 0; k <= 100000; k++) {
if (k * (k + 1) / 2 > c) break;
}
k--;
for (i = k; i >= 1; i--) {
if (a > b) {
a -= i;
x[p++] = i;
} else {
b -= i;
y[q++] = i;
}
}
printf("%lld\n", p);
for (i = 0; i < p; i++) printf("%lld ", x[i]);
printf("\n%lld\n", q);
for (i = 0; i < q; i++) printf("%lld ", y[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1000 + 7;
const double pi = acos(-1.0);
const double eps = 0.0000000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline void pr2(T x, int k = 64) {
int i;
for (i = k - 1; i >= 0; i--) fprintf(stderr, "%d", (x >> i) & 1);
putchar(' ');
}
template <typename T>
inline void add_(T &A, int B) {
A += B;
(A >= M) && (A -= M);
}
template <typename T>
inline void mul_(T &A, long long B) {
(A *= B) %= M;
}
template <typename T>
inline void mod_(T &A, long long B = M) {
A %= M;
}
template <typename T>
inline void max_(T &A, T B) {
(A < B) && (A = B);
}
template <typename T>
inline void min_(T &A, T B) {
(A > B) && (A = B);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
int n, m;
char str[maxn];
int TaskA();
void Task_one() { TaskA(); }
void Task_T() {
int T;
scanf("%d", &T);
while (T--) TaskA();
}
void Task_more_n() {
while (~scanf("%d", &n)) TaskA();
}
void Task_more_n_m() {
while (~scanf("%d%d", &n, &m)) TaskA();
}
void Task_more_string() {
while (~scanf("%s", str)) TaskA();
}
struct tree {
vector<int> edge[maxn];
int subtree[maxn], fa[maxn], n;
void read() {
scanf("%d", &n);
int i, u, v;
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
}
void dfs_fa(int x, int father) {
fa[x] = father;
for (int v : edge[x])
if (v != fa[x]) dfs_fa(v, x);
}
void dfs_subtree(int x, int fa) {
subtree[x] = 0;
for (int v : edge[x])
if (v != fa) dfs_subtree(v, x), subtree[x] |= 1 << (v - 1);
}
} S, T;
int val[1007][1 << 12 | 7];
int dfs(int x, int pos, int status) {
if (pos == (int)S.edge[x].size()) return !status;
if (S.edge[x][pos] == S.fa[x]) return dfs(x, pos + 1, status);
int y = S.edge[x][pos];
if (val[y][status] != -1) return val[y][status];
int &ret = val[y][status];
ret = 0;
int i;
add_(ret, dfs(x, pos + 1, status));
for (i = 0; i < T.n; i++)
if ((status >> i) & 1) {
add_(ret, (long long)dfs(x, pos + 1, status ^ (1 << i)) *
dfs(y, 0, T.subtree[i + 1]) % M);
}
return ret;
}
int TaskA() {
S.read();
T.read();
int i, j, ans = 0, inv = 0;
S.dfs_fa(1, 0);
for (i = 1; i <= T.n; i++) {
T.dfs_subtree(i, 0);
memset(val, 0xff, sizeof(val));
for (j = 1; j <= S.n; j++) add_(ans, dfs(j, 0, T.subtree[i]));
}
S = T;
S.dfs_fa(1, 0);
for (i = 1; i <= T.n; i++) {
T.dfs_subtree(i, 0);
memset(val, 0xff, sizeof(val));
for (j = 1; j <= S.n; j++) add_(inv, dfs(j, 0, T.subtree[i]));
}
printf("%I64d\n", ans * powMM((long long)inv, M - 2) % M);
return 0;
}
void initialize() {}
int main() {
int startTime = clock();
initialize();
fprintf(stderr, "/--- initializeTime: %ld milliseconds ---/\n",
clock() - startTime);
Task_one();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct Point {
T x, y;
int id;
explicit Point(T x = 0, T y = 0, int id = 0) : x(x), y(y), id(id) {}
bool operator<(Point p) const { return tie(x, y) < tie(p.x, p.y); }
bool operator==(Point p) const { return tie(x, y) == tie(p.x, p.y); }
Point operator+(Point p) const { return Point(x + p.x, y + p.y); }
Point operator-(Point p) const { return Point(x - p.x, y - p.y); }
Point operator*(T d) const { return Point(x * d, y * d); }
Point operator/(T d) const { return Point(x / d, y / d); }
T dot(Point p) const { return x * p.x + y * p.y; }
T cross(Point p) const { return x * p.y - y * p.x; }
T cross(Point a, Point b) const { return (a - *this).cross(b - *this); }
T dist2() const { return x * x + y * y; }
double dist() const { return sqrt((double)dist2()); }
friend ostream& operator<<(ostream& os, Point p) {
return os << "(" << p.x << "," << p.y << ")";
}
};
void sol() {
int N;
cin >> N;
vector<Point<long long int> > pts;
for (int i = 0; i < N; i++) {
int x, y;
cin >> x >> y;
pts.push_back(Point<long long int>(x, y, i));
}
string dirs;
cin >> dirs;
sort(pts.begin(), pts.end());
vector<bool> dead(N);
auto convexHull = [&]() {
if ((int)pts.size() <= 1) return pts;
vector<Point<long long int> > h((int)pts.size() + 1);
int s = 0, t = 0;
for (int it = 2; it--; s = --t, reverse(pts.begin(), pts.end()))
for (int i = 0; i < (int)pts.size(); i++)
if (!dead[pts[i].id]) {
Point<long long int> p = pts[i];
while (t >= s + 2 && h[t - 2].cross(h[t - 1], p) <= 0) t--;
h[t++] = p;
}
vector<Point<long long int> > res(h.begin(),
h.begin() + t - (t == 2 && h[0] == h[1]));
return res;
};
auto hull = convexHull();
auto curP = hull[0];
vector<Point<long long int> > line;
line.push_back(curP);
dead[curP.id] = true;
int idx = 0;
while ((int)line.size() < N - 1) {
int pos = -1;
int M = (int)hull.size();
for (int i = 0; i < (int)hull.size(); i++)
if (hull[i] == curP) pos = i;
auto V1 = hull[(pos + 1) % M], V2 = hull[(pos - 1 + M) % M];
auto v1 = V1 - curP;
auto v2 = V2 - curP;
if (v1.cross(v2) > 0) {
if (dirs[idx] == 'L')
curP = V1;
else
curP = V2;
} else {
if (dirs[idx] == 'L')
curP = V2;
else
curP = V1;
}
hull = convexHull();
line.push_back(curP);
dead[curP.id] = true;
idx++;
}
for (int i = 0; i < N; i++)
if (!dead[pts[i].id]) line.push_back(pts[i]);
for (int i = 0; i < N; i++) {
cout << line[i].id + 1 << " ";
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sol();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 1004;
int n, l, k, cnt[26];
char a[N][N];
string s, ans[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> l >> k >> s;
sort((s).begin(), (s).end());
s = '0' + s;
int mnc = k, st = 1;
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (l); ++j) a[i][j] = 'X';
for (int pos = (1); pos <= (l); ++pos) {
{
cerr << "mnc"
<< " = " << (mnc) << '\n';
};
cnt[s[st + mnc - 1] - 'a'] = 0;
for (int j = (k - mnc + 1); j <= (k); ++j)
a[j][pos] = s[st + j - (k - mnc + 1)],
cnt[s[st + j - (k - mnc + 1)] - 'a']++;
st += mnc;
mnc = cnt[a[k][pos] - 'a'];
}
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (l); ++j) {
if (a[i][j] == 'X') a[i][j] = s[st++];
ans[i] += a[i][j];
}
for (int i = (1); i <= (n); ++i) cout << ans[i] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 1e+7;
using namespace std;
char s[100];
int p[100];
int t, a, b, m, n, x, sign, ans;
char c;
int main() {
scanf("%d", &t);
while (t--) {
memset(s, 0, sizeof s);
memset(p, 0, sizeof p);
sign = 0;
scanf("%d", &m);
scanf("%s", s + 1);
for (int i = 1; i <= m; i++) {
p[i] = s[i] - '0';
if (p[i] == 1 || p[i] == 4 || p[i] == 6 || p[i] == 8 || p[i] == 9) {
sign = 1;
printf("1\n%d\n", p[i]);
break;
}
}
if (sign == 1) {
continue;
}
sign = 0;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
ans = p[i] * 10 + p[j];
if (ans != 23 && ans != 37 && ans != 53 && ans != 73) {
printf("2\n%d\n", ans);
sign = 1;
break;
}
}
if (sign == 1) break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char a[5000];
int x[5000], len;
long long an;
int main() {
scanf("%s", a + 1);
len = strlen(a + 1);
for (int i = 1; i <= len; i++) {
if (a[i] >= '0' && a[i] <= '9') {
int temp = 0, s = 0;
for (; (a[i] >= '0' && a[i] <= '9') || a[i] == '.'; i++) {
if (a[i] == '.')
s = i;
else
temp = temp * 10 + a[i] - '0';
}
i--;
if (s != 0 && i - s == 2)
an += temp;
else
an += (temp * 100);
}
}
for (; an; an /= 10) {
x[++x[0]] = an % 10;
}
for (int i = x[0]; i > 3; i--) {
if (i % 3 == 0)
printf("%d.", x[i]);
else
printf("%d", x[i]);
}
printf("%d", x[3]);
if (x[1] || x[2])
printf(".%d%d", x[2], x[1]);
else
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int modPow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
b /= 2;
y = (y * y) % MOD;
}
return x;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
using namespace std;
const int N = 1e3 + 3;
string n;
int k;
long long int steps[N];
long long int C[N][N];
long long int MOD = 1e9 + 7;
long long int nCr(long long int n, long long int r) {
if (r < 0 || r > n) return 0;
if (r == 0 || r == n) return 1;
if (C[n][r] == -1) C[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1)) % MOD;
return C[n][r];
}
long long int solve(int numset, int currBit) {
if (numset < 0) return 0;
if (currBit == n.size()) return ((numset == 0) ? 1 : 0);
long long int res = 0;
if (n[currBit] == '1') res += nCr(n.size() - currBit - 1, numset);
res += solve(numset - ((n[currBit] == '1') ? 1 : 0), currBit + 1);
res %= MOD;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
memset(C, -1, sizeof(C));
if (k == 0) {
cout << 1;
return 0;
}
steps[1] = 0;
for (auto i = (2); i <= (N - 3); i++)
steps[i] = 1 + steps[__builtin_popcount(i)];
long long int res = 0;
for (auto i = (1); i <= (N - 3); i++) {
if (steps[i] == k - 1) {
res += solve(i, 0);
res %= MOD;
}
}
if (k == 1) res = (res + MOD - 1) % MOD;
cout << res;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define pp pop_back
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define f0(i,a,n) for(i=a;i<n;i++)
#define f1(i,a,b) for(i=a;i<=b;i++)
#define all(v) sort(v.begin(),v.end());
#define stp setprecision
#define nl endl
#define I insert
#define ipt(a,n) for(i=0;i<n;i++)cin>>a[i];
#define pll pair<ll,ll>
#define pii pair<int,int>
#define vl vector<ll>
#define mp map<ll,ll>
#define sr(a,n) sort(a,a+n);
#define cx(x) cout<<x<<"\n";
#define cy(x) cout<<x<<" ";
#define cn cout<<"No\n";
#define cw cout<<"Yes\n";
#define bs binary_search
#define S second
#define F first
#define pi 3.141592653589793238
#define ct cout<<"\n"
ll sieve[1000001];
void prime()
{
ll i,j;
sieve[0]=0,sieve[1]=0;
for(i=2;i<=1e6;i++)
sieve[i]=1;
for(i=2;i<=1e6;i++)
{
if(sieve[i]==1)
{
for(j=2*i;j<=1e6;j+=i)
sieve[j]=0;
}
}
}
ll be(ll a,ll b,ll m)
{
ll r=1;
while(b!=0)
{
if(b&1)
r=(r*a)%m;
a=(a*a)%m;
b=b/2;
}
return r;
}
void solve()
{
ll n,i;
cin>>n;
ll x[n],y[n],j;
for(i=0;i<n;i++)
{
cin>>x[i]>>y[i];
}
sr(x,n);
sr(y,n);
if(n&1)
cx(1)
else
{
ll ans=(x[n/2]-x[n/2-1]+1)*(y[n/2]-y[n/2-1]+1);
cx(ans)
}
}
int main()
{
fast;
//prime();
ll t=1;
cin>>t;
while(t--)
{
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int d, n, ans, a[2005], dp[2005];
vector<vector<int> > adj;
unordered_set<int> explored;
void dfs(int u, int root) {
explored.insert(u);
dp[u] = 1;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (explored.count(v)) continue;
if (a[v] < a[root] || a[v] > a[root] + d) continue;
if (a[v] == a[root] && v < root) continue;
dfs(v, root);
dp[u] = (int)((long long)dp[u] * (dp[v] + 1) % MOD);
}
}
int main() {
cin >> d >> n;
adj.resize(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int u = 1; u <= n; ++u) {
explored.clear();
memset(dp, 0, sizeof(dp));
dfs(u, u);
ans = (ans + dp[u]) % MOD;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000009;
const double pi = acos(-1.0);
const int N = 300009;
int a[N + 9], s[N + 9];
inline void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
int mode[N + 9], l[N + 9], r[N + 9];
int fibb[N + 9], sf[N + 9];
inline int get(int l, int r) {
int t = fibb[r + 2];
sub(t, fibb[l + 1]);
return t;
}
const int MAGIC = 444;
int addit[N + 9], subtr[N + 9];
int main() {
fibb[1] = fibb[2] = 1;
sf[1] = 1;
sf[2] = 2;
for (int i = (3); i <= (300002); ++i) {
fibb[i] = fibb[i - 2];
add(fibb[i], fibb[i - 1]);
sf[i] = sf[i - 1];
add(sf[i], fibb[i]);
}
int n, q;
cin >> n >> q;
for (int i = (1); i <= (n); ++i) {
scanf("%d", &a[i]);
s[i] = s[i - 1];
add(s[i], a[i]);
}
int have1 = 0;
vector<int> g;
for (int it = (1); it <= (q); ++it) {
scanf("%d %d %d", &mode[it], &l[it], &r[it]);
if (mode[it] == 1) {
++have1;
g.push_back(it);
add(addit[l[it]], 1);
int temp = 0;
sub(temp, fibb[r[it] - l[it] + 2]);
add(subtr[r[it] + 1], temp);
temp = 0;
sub(temp, fibb[r[it] - l[it] + 1]);
add(subtr[r[it] + 2], temp);
} else {
int have = s[r[it]];
sub(have, s[l[it] - 1]);
for (int i = (0); i <= ((int)((g).size()) - 1); ++i) {
int ll = l[g[i]], rr = r[g[i]];
ll = max(ll, l[it]);
rr = min(rr, r[it]);
if (ll > rr) continue;
add(have, get(ll - l[g[i]] + 1, rr - l[g[i]] + 1));
}
printf("%d\n", have);
}
if (have1 == MAGIC) {
for (int i = (1); i <= (n); ++i) {
if (i - 2 >= 0) add(addit[i], addit[i - 2]);
add(addit[i], addit[i - 1]);
add(addit[i], subtr[i]);
}
int tt = 0;
for (int i = (1); i <= (n); ++i) {
add(tt, addit[i]);
add(s[i], tt);
}
memset(addit, 0, sizeof(addit));
memset(subtr, 0, sizeof(subtr));
have1 = 0;
g.clear();
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int toInt(string s) {
istringstream sin(s);
int t;
sin >> t;
return t;
}
template <class T>
string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
struct ksum {
int k;
multiset<int> topk;
multiset<int> rest;
long long sum;
ksum(int _k) : k(_k), sum(0) {}
void insert(int x) {
sum += x;
topk.insert(x);
if (topk.size() > k) {
multiset<int>::iterator it = topk.end();
it--;
sum -= *it;
rest.insert(*it);
topk.erase(it);
}
}
void erase(int x) {
if (topk.find(x) != topk.end()) {
sum -= x;
topk.erase(topk.find(x));
if (rest.size()) {
sum += *rest.begin();
topk.insert(*rest.begin());
rest.erase(rest.begin());
}
} else
rest.erase(rest.find(x));
}
};
int a[100010];
int main() {
int n, len, k;
int i;
long long ans = 0, sum = 0;
cin >> n >> len;
for (i = (0); i < (n); i++) cin >> a[i];
cin >> k;
ksum positive(k), negative(k);
for (i = (0); i < (len); i++) {
sum += a[i];
if (a[i] > 0) positive.insert(-a[i]);
if (a[i] < 0) negative.insert(a[i]);
}
for (i = (len); i < (n + 1); i++) {
chmax(ans, abs(sum + positive.sum * 2));
chmax(ans, abs(sum - negative.sum * 2));
sum += a[i];
sum -= a[i - len];
if (a[i] > 0) positive.insert(-a[i]);
if (a[i] < 0) negative.insert(a[i]);
if (a[i - len] > 0) positive.erase(-a[i - len]);
if (a[i - len] < 0) negative.erase(a[i - len]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
long long ans, x, t;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i - 1 >= a[i]) {
ans = i;
break;
} else {
x = (a[i] - (i - 1)) % n ? ((a[i] - (i - 1)) / n) + 1
: ((a[i] - (i - 1)) / n);
t = x * n + i;
}
ans = ans < t ? ans : t;
}
ans %= n;
if (ans == 0) ans = n;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, m;
scanf("%d %d", &n, &m);
int sum = n * (1 + n) / 2;
m %= sum;
for (int i = 1; i <= n; i++) {
if (m - i >= 0)
m -= i;
else
break;
}
printf("%d\n", m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300100;
int a[N], sum[N];
char s[N];
int main() {
int T;
cin >> T;
while (T--) {
int n, q;
cin >> n >> q >> s + 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '+')
a[i] = 1;
else
a[i] = -1;
if (i % 2 == 0) a[i] = -1 * a[i];
}
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
while (q--) {
int l, r;
cin >> l >> r;
int res = sum[r] - sum[l - 1];
if (res == 0)
cout << 0 << endl;
else if (res % 2 == 0)
cout << 2 << endl;
else
cout << 1 << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, ans[N], t[N], x[N], op[N], p[N], tmp[N];
map<int, int> num;
int read() {
int x = 0, f = 1;
char s;
while ((s = getchar()) < '0' || s > '9')
if (s == '-') f = -1;
while (s >= '0' && s <= '9') {
x = (x << 1) + (x << 3) + (s ^ 48);
s = getchar();
}
return x * f;
}
bool cmp(const int a, const int b) {
return (t[a] ^ t[b]) ? t[a] < t[b]
: ((x[a] ^ x[b]) ? x[a] < x[b] : op[a] < op[b]);
}
void cdq(const int L, const int R) {
if (L >= R) return;
int mid = L + R >> 1;
cdq(L, mid);
cdq(mid + 1, R);
int i = L, j = mid + 1;
for (int k = L; k <= R; ++k) {
int p1 = p[i], p2 = p[j];
if ((i <= mid && cmp(p1, p2)) || j > R) {
if (op[p1] == 1) ++num[x[p1]];
if (op[p1] == 2) --num[x[p1]];
tmp[k] = p[i++];
} else {
if (op[p2] == 3) ans[p2] += num[x[p2]];
tmp[k] = p[j++];
}
}
for (i = L; i <= R; ++i) num[x[p[i]]] = 0, p[i] = tmp[i];
}
int main() {
n = read();
for (int i = 1; i <= n; ++i)
p[i] = i, op[i] = read(), t[i] = read(), x[i] = read();
cdq(1, n);
for (int i = 1; i <= n; ++i)
if (op[i] == 3) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, h;
cin >> n >> m >> h;
int fro[m];
for (int i = 0; i < m; i++) cin >> fro[i];
int left[n];
for (int i = 0; i < n; i++) cin >> left[i];
int a[n][m], ans[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) {
ans[i][j] = min(fro[j], left[i]);
} else
ans[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, a[1000], b[1000], c[1001] = {0};
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
c[b[i]] += 1;
}
int count = 0;
for (int i = 0; i < n; ++i) {
c[b[i]] -= 1;
if (c[a[i]] == 0) {
count += 1;
}
c[b[i]] += 1;
}
printf("%d\n", count);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char ch = getchar();
bool f = false;
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = f ? -x : x;
return;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 ^ 48);
return;
}
const long long MOD = 1e9 + 7, N = 2e5 + 3;
long long T;
long long f[N];
signed main() {
read(T);
while (T--) {
long long n;
read(n);
long long ans = 1;
for (register long long i = 1; i <= (n * 2); ++i) {
if (i == 2) continue;
ans = (ans * i) % MOD;
}
print(ans), putchar('\n');
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, edg;
vector<int> g[1010101];
long long deg[1010101], loop, lv[1010101];
bool vis[1010101];
void DFS(int n) {
vis[n] = true;
if (lv[n]) edg++;
for (int next : g[n]) {
if (vis[next]) continue;
edg++;
DFS(next);
}
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= M; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (a == b) {
loop++;
lv[a]++;
continue;
}
g[a].push_back(b);
g[b].push_back(a);
deg[a]++;
deg[b]++;
}
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (vis[i]) continue;
edg = 0;
DFS(i);
if (edg) cnt++;
}
if (cnt > 1) return !printf("0");
long long res = 0;
res += loop * (loop - 1) / 2;
res += loop * (M - loop);
for (int i = 1; i <= N; i++) res += deg[i] * (deg[i] - 1) / 2;
printf("%lld", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s, z;
int t;
void F() {
if (cin >> s) {
z += s;
if (s == "pair") z += "<", F(), z += ",", F(), z += ">";
} else
t = 1;
}
int main() {
cin >> s;
F();
if (t || cin >> s)
puts("Error occurred");
else
puts(z.c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[3000][3000], p[3000][3000];
int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
struct node {
int x, y;
};
queue<node> q;
int main() {
int n, t;
scanf("%d%d", &n, &t);
a[1500][1500] = n;
if (n >= 4) {
q.push((node){1500, 1500});
p[1500][1500] = 1;
}
while (!q.empty()) {
int x = (q.front()).x, y = (q.front()).y;
a[x][y] -= 4;
if (a[x][y] < 4) {
q.pop();
p[x][y] = 0;
}
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if ((++a[tx][ty]) >= 4 && !p[tx][ty]) {
q.push((node){tx, ty});
p[tx][ty] = 1;
}
}
}
while (t--) {
int t1, t2;
scanf("%d%d", &t1, &t2);
if (t1 < -1400 || t1 > 1400 || t2 < -1400 || t2 > 1400)
printf("%d\n", 0);
else
printf("%d\n", a[1500 + t1][1500 + t2]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod(long long a, long long b) { return ((a % b) + b) % b; }
int gcd(int a, int b) {
int tmp;
while (b) {
a %= b;
tmp = a;
a = b;
b = tmp;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long extended_euclid(long long a, long long b, long long &x,
long long &y) {
long long xx = y = 0;
long long yy = x = 1;
while (b) {
long long q = a / b;
long long t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
pair<long long, long long> chinese_remainder_theorem(long long x, long long a,
long long y, long long b) {
long long s, t;
long long d = extended_euclid(x, y, s, t);
if (a % d != b % d) return make_pair(0, -1);
return make_pair(mod(s * b * x + t * a * y, x * y) / d, x * y / d);
}
pair<long long, long long> chinese_remainder_theorem(const vector<int> &x,
const vector<int> &a) {
pair<long long, long long> ret = make_pair(a[0], x[0]);
for (int i = 1; i < x.size(); i++) {
ret = chinese_remainder_theorem(ret.second, ret.first, x[i], a[i]);
if (ret.second == -1) break;
}
return ret;
}
char b[1000005];
char n[1000005];
int c;
int pw(int a, int p, int mod) {
if (p == 0) return 1;
long long r = pw(a, p / 2, mod);
r *= r;
r %= mod;
if (p % 2) r *= a;
return r % mod;
}
int main() {
scanf("%s", b);
scanf("%s", n);
scanf("%d", &c);
long long base = 0;
for (int i = 0; b[i] != '\0'; i++) {
base *= 10;
base += b[i] - '0';
base %= c;
}
int len = strlen(n);
if (len < 10) {
long long power = 0;
for (int i = 0; i < len; i++) {
power *= 10;
power += n[i] - '0';
}
long long res = base - 1;
while (res < 0) res += c;
res *= pw(base, power - 1, c);
res %= c;
int ans = res;
if (ans == 0) ans = c;
printf("%d\n", ans);
return 0;
}
int x = c;
vector<int> pws;
vector<int> prs;
for (int i = 2; i * i <= x; i++) {
int cnt = 0;
int pw = 1;
while (x % i == 0) {
cnt++;
x /= i;
pw *= i;
}
if (cnt) {
pws.push_back(pw);
prs.push_back(i);
}
}
if (x > 1) {
pws.push_back(x);
prs.push_back(x);
}
vector<int> a(pws.size());
for (int j = 0; j < pws.size(); j++) {
long long power = 0;
long long r = 0;
long long r2 = 0;
for (int i = 0; b[i] != '\0'; i++) {
r *= 10;
r += b[i] - '0';
r %= pws[j];
r2 *= 10;
r2 += b[i] - '0';
r2 %= prs[j];
}
int modp = (pws[j] - pws[j] / prs[j]);
for (int i = 0; n[i] != '\0'; i++) {
power *= 10;
power += n[i] - '0';
power %= modp;
}
if (r2 == 0) {
a[j] = 0;
} else {
power = (power + modp - 1) % modp;
a[j] = pw(r, power, pws[j]);
}
}
pair<long long, long long> res = chinese_remainder_theorem(pws, a);
int ans = res.first;
ans %= c;
base--;
while (base < 0) base += c;
ans = (ans * 1ll * base) % c;
if (ans == 0) ans = c;
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
const int N = 2e5 + 5;
const long long int mod = 1e9 + 7;
const long long int Mod = 998244353;
const long double Pi = acos(-1);
const long long int Inf = 4e18;
using namespace std;
bool isPrime(int k) {
for (int i = 2; i <= sqrt(k); i++) {
if (k % i == 0) return false;
}
return true;
}
void TestCase() {
int n, c1 = 0;
cin >> n;
set<int> eve, odd;
for (int i = 1, x; i <= n; i++) {
cin >> x;
if (x == 1)
c1++;
else
(x % 2 ? odd.insert(x) : eve.insert(x));
}
if (c1) {
int ele = 0;
for (auto &o : eve) {
if (isPrime(o + 1)) {
ele = o;
break;
}
}
if (ele != 0) {
cout << c1 + 1 << "\n" << ele << " ";
for (int i = 1; i <= c1; i++) cout << 1 << " ";
} else {
int a = 0, b = 0;
for (auto &o : eve) {
for (auto &t : odd) {
if (isPrime(o + t)) {
a = o;
b = t;
break;
}
}
}
if (c1 < 2 && a != 0)
cout << 2 << "\n" << a << " " << b;
else {
cout << c1 << "\n";
for (int i = 1; i <= c1; i++) cout << 1 << " ";
}
}
} else {
int a = 0, b = 0;
for (auto &o : eve) {
for (auto &t : odd) {
if (isPrime(o + t)) {
a = o;
b = t;
break;
}
}
}
if (a != 0)
cout << 2 << "\n" << a << " " << b;
else {
cout << 1 << "\n";
if ((int)eve.size() > 0)
cout << *eve.begin();
else
cout << *odd.begin();
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int T = 1;
while (T--) {
TestCase();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char b[2005][2005];
int a[2005][2005];
int qian[2005][2005] = {0};
int pre[2005][2005];
int main() {
int n, len;
scanf("%d%d", &n, &len);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> b[i][j];
if (b[i][j] == 'W')
a[i][j] = 0;
else
a[i][j] = 1;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int l = n + 1;
int r = 0;
for (int j = 1; j <= n; j++) {
if (a[i][j] == 1) {
l = min(l, j);
r = max(r, j);
}
}
if (r == 0) {
ans++;
continue;
}
if (r - l + 1 > len) continue;
int x, y;
x = max(1, i - len + 1);
y = max(1, r - len + 1);
qian[i][l]++;
qian[i][y - 1]--;
qian[x - 1][l]--;
qian[x - 1][y - 1]++;
}
for (int i = 1; i <= n; i++) {
int l = n + 1;
int r = 0;
for (int j = 1; j <= n; j++) {
if (a[j][i]) {
l = min(l, j);
r = max(r, j);
}
}
if (r == 0) {
ans++;
continue;
}
if (r - l + 1 > len) continue;
int x1 = max(1, r - len + 1);
int y1 = max(1, i - len + 1);
qian[l][i]++;
qian[l][y1 - 1]--;
qian[x1 - 1][i]--;
qian[x1 - 1][y1 - 1]++;
}
for (int i = n; i >= 1; i--) {
for (int j = n; j >= 1; j--) {
pre[i][j] =
-pre[i + 1][j + 1] + pre[i][j + 1] + pre[i + 1][j] + qian[i][j];
}
}
int maxn = -1e9;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) maxn = max(maxn, pre[i][j]);
}
printf("%d\n", ans + maxn);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int t;
long long powmod(long long x, long long y, long long m) {
long long res = 1LL;
while (y) {
if (y & 1) res = (res * x) % m;
x = (x * x) % m;
y /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
long long int ans = ((n) / 2) * m;
if (n % 2 == 1) {
ans += m / 2 + (m % 2);
}
long long int ans1 = (m / 2) * n;
if (m % 2 == 1) {
ans1 += (n / 2) + (n % 2);
}
cout << min(ans, ans1) << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 4e5 + 5, inf = 0x3f3f3f3f;
map<int, int> tipo;
map<int, int> pos;
int inicioIdx[ms], sz[ms];
int seg[2 * ms], lazy[2 * ms];
int ciclo[ms], posicaoNoCiclo[ms];
int n;
int h;
int *t, *d;
void calc(int p, int k) {
if (d[p] == -1)
t[p] = max(t[p << 1], t[p << 1 | 1]);
else
t[p] = d[p];
}
void apply(int p, int value, int k) {
t[p] = value;
if (p < n) d[p] = value;
}
void build(int l, int r) {
int k = 2;
for (l += n, r += n - 1; l > 1; k <<= 1) {
l >>= 1, r >>= 1;
for (int i = r; i >= l; --i) calc(i, k);
}
}
void push(int l, int r) {
int s = h, k = 1 << (h - 1);
for (l += n, r += n - 1; s > 0; --s, k >>= 1)
for (int i = l >> s; i <= r >> s; ++i)
if (d[i] != -1) {
apply(i << 1, d[i], k);
apply(i << 1 | 1, d[i], k);
d[i] = -1;
}
}
void modify(int l, int r, int value) {
if (value == -1) return;
r++;
push(l, l + 1);
push(r - 1, r);
bool cl = false, cr = false;
int k = 1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1, k <<= 1) {
if (cl) calc(l - 1, k);
if (cr) calc(r, k);
if (l & 1) apply(l++, value, k), cl = true;
if (r & 1) apply(--r, value, k), cr = true;
}
for (--l; r > 0; l >>= 1, r >>= 1, k <<= 1) {
if (cl) calc(l, k);
if (cr && (!cl || l != r)) calc(r, k);
}
}
int query(int l) {
push(l, l + 1);
return t[n + l];
}
void updateGlobal(int i) {
d = lazy + inicioIdx[i];
t = seg + inicioIdx[i];
n = sz[i];
h = sizeof(int) * 8 - __builtin_clz(n);
}
int buscaBinaria(int t, int p) {
int n = sz[t];
updateGlobal(t);
int l = p + 1, r = p + n;
while (r - l > 1) {
int m = (l + r) / 2;
int check = (m < n) ? query(m) : query(m - n);
if (check == p)
r = m;
else
l = m;
}
int check = query(l % n);
if (check == p) {
return l % n;
} else {
return r % n;
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
int h, m, n, ans = 0;
cin >> h >> m >> n;
int zzz = 0;
int ciclosAteAgora = 0;
int cnt = 0;
for (int i = 0; i < h; i++) {
int pos = i;
if (!ciclo[pos]) ++ciclosAteAgora;
for (int j = 0; ciclo[pos] == 0; j++) {
ciclo[pos] = ciclosAteAgora;
posicaoNoCiclo[pos] = j;
sz[ciclosAteAgora]++;
cnt++;
pos = (pos + m) % h;
}
}
for (int i = 1; i <= ciclosAteAgora; i++) {
int qnt = sz[i];
inicioIdx[i] = zzz;
updateGlobal(i);
for (int j = 0; j < qnt; j++) d[j] = -1;
for (int j = 0; j < qnt; j++) modify(j, j, j);
zzz += 2 * qnt;
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "+") {
int hash, id;
cin >> id >> hash;
int t = ciclo[hash], p = posicaoNoCiclo[hash];
updateGlobal(t);
int posicaoInserir = query(p);
pos[id] = posicaoInserir;
tipo[id] = t;
ans += (posicaoInserir + sz[t] - p) % sz[t];
int apos = query((posicaoInserir + 1) % sz[t]);
if (apos == posicaoInserir) {
modify(0, sz[t] - 1, inf);
continue;
}
int inicioUpdate = buscaBinaria(t, posicaoInserir);
if (inicioUpdate > posicaoInserir) {
modify(inicioUpdate, sz[t] - 1, apos);
modify(0, posicaoInserir, apos);
} else {
modify(inicioUpdate, posicaoInserir, apos);
}
} else {
int id;
cin >> id;
int t = tipo[id], p = pos[id];
updateGlobal(t);
int posicaoApos = query(p);
if (posicaoApos == inf) {
modify(0, sz[t] - 1, p);
continue;
}
int inicioUpdate = buscaBinaria(t, posicaoApos);
if (inicioUpdate > p) {
modify(inicioUpdate, sz[t] - 1, p);
modify(0, p, p);
} else {
modify(inicioUpdate, p, p);
}
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fr() {
freopen("test_input.txt", "r", stdin);
freopen("a.out", "w", stdout);
}
const int N = 5e5 + 5;
const int MAX = 205 * 26;
const int INF = 2e9;
const int mod = 1e9 + 7;
const double pi = 3.1415926536;
double eps = 1e-10;
bool used[N][2];
vector<vector<int> > graf(N), farg(N);
int color[N], c[N];
vector<int> cur;
int s;
void dfs(int v, int p) {
if (used[v][p]) {
return;
}
used[v][p] = 1;
cur.push_back(v);
if (v == s and p) {
printf("Win\n");
while (!cur.empty()) {
printf("%d ", cur.back());
cur.pop_back();
}
exit(0);
}
for (auto from : farg[v]) {
dfs(from, p ^ 1);
}
cur.pop_back();
}
void find_cycle(int v) {
color[v] = 1;
for (auto to : graf[v]) {
if (color[to] == 1) {
printf("Draw");
exit(0);
} else if (color[to] == 0) {
color[to] = 1;
find_cycle(to);
}
}
color[v] = 2;
}
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int u = 1; u <= n; u++) {
scanf("%d", &c[u]);
for (int i = 1; i <= c[u]; i++) {
int v;
scanf("%d", &v);
graf[u].push_back(v);
farg[v].push_back(u);
}
}
scanf("%d", &s);
for (int i = 1; i <= n; i++) {
if (c[i] == 0) {
dfs(i, 0);
}
}
find_cycle(s);
printf("Lose");
}
int t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
t = 1;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const MAX = 1e5 + 41;
void bad() {
printf("-1\n");
exit(0);
}
int n, m;
vector<int> e[MAX];
int u[MAX];
vector<int> st;
vector<int> c;
bool dfs(int x, int z = -1) {
st.push_back(x);
u[x] = 1;
for (int y : e[x]) {
if (y == z) continue;
if (u[y] == 2) continue;
if (u[y] == 1) {
for (int j = (int)st.size() - 1; j >= 0; j--) {
c.push_back(st[j]);
if (st[j] == y) {
reverse(c.begin(), c.end());
return 1;
}
}
} else {
if (dfs(y, z)) return 1;
}
}
u[x] = 2;
st.pop_back();
return 0;
}
bool f[MAX];
int p[MAX];
set<int> t;
int b[MAX];
int getdist(int x, int y) {
if (x == y) return (int)c.size();
if (p[x] < p[y]) {
return p[y] - p[x];
} else {
return (int)c.size() - p[x] + p[y];
}
}
int dfs1(int x, int ver) {
u[x] = 1;
int res = -1;
for (int y : e[x]) {
if (f[y]) {
if (f[x]) {
int nxt = c[(p[x] + 1) % (int)c.size()];
if (nxt == y) continue;
}
if (res == -1 || getdist(ver, res) < getdist(ver, y)) {
res = y;
}
} else {
if (!u[y]) {
dfs1(y, ver);
}
if (b[y] == -1) continue;
if (res == -1 || getdist(ver, res) < getdist(ver, b[y])) {
res = b[y];
}
}
}
b[x] = res;
return res;
}
void removeline(int a, int b) {
if (a > b) {
removeline(a, (int)c.size());
removeline(-1, b);
return;
}
while (1) {
auto it = t.upper_bound(a);
if (it == t.end()) break;
if ((*it) < b) {
t.erase(it);
} else {
break;
}
}
}
void solve() {
for (int i = 1; i <= n; i++) {
if (u[i]) continue;
if (dfs(i)) {
break;
}
}
for (int x : c) {
while (false) {
};
}
while (false) {
};
assert((int)c.size());
for (int i = 0; i <= (int)c.size() - 1; i++) {
f[c[i]] = 1;
p[c[i]] = i;
t.insert(i);
}
memset(u, 0, sizeof(u));
for (int i = 0; i <= (int)c.size() - 1; i++) {
int best = dfs1(c[i], c[i]);
while (false) {
};
if (best == -1) continue;
int l = i;
int r = p[best];
while (false) {
};
if (l == r) {
t.clear();
t.insert(l);
break;
}
removeline(l, r);
}
if (!(int)t.size()) bad();
st.clear();
memset(u, 0, sizeof(u));
int k = c[(*t.begin())];
for (int i = 1; i <= n; i++) {
if (u[i]) continue;
if (dfs(i, k)) bad();
}
printf("%d\n", k);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
e[x].push_back(y);
}
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a[500010], f[500010], res, p, q;
int main() {
ios::sync_with_stdio(0);
scanf("%d", &n);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &a[i]);
f[1] = 1;
for (int i = (2), _b = (n); i <= _b; i++) {
if (a[i] != a[i - 1])
f[i] = f[i - 1] + 1;
else
f[i] = 1;
res = max(res, f[i]);
}
if (res % 2 == 0)
res = (res - 1) / 2;
else
res = res / 2;
cout << res << endl;
for (int i = (1), _b = (n); i <= _b; i++)
if (f[i + 1] < f[i] && f[i] % 2 == 1) {
p = a[i];
for (int j = (i), _b = (i - f[i] + 1); j >= _b; j--) a[j] = p;
} else if (f[i + 1] < f[i] && f[i] % 2 == 0) {
p = a[i];
q = a[i - f[i] + 1];
for (int j = (i), _b = (i - f[i] / 2 + 1); j >= _b; j--) a[j] = p;
for (int j = (i - f[i] / 2), _b = (i - f[i] + 1); j >= _b; j--) a[j] = q;
}
for (int i = (1), _b = (n); i <= _b; i++) cout << a[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, b;
int a[16], amt[16];
bitset<2001> dp[1 << 16];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[0][0] = 1;
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 2000; i >= 1; i--) {
if (dp[mask][i] && (i % k == 0)) {
dp[mask][i / k] = 1;
}
}
for (int i = 0; i < n; i++) {
if (!((mask >> i) & 1)) {
dp[mask | (1 << i)] |= dp[mask] << a[i];
}
}
}
if (dp[(1 << n) - 1][1]) {
cout << "YES" << endl;
int curr = 0;
int mask = (1 << n) - 1;
int v = 1;
while (mask) {
while (v * k <= 2000 && dp[mask][v * k]) {
v *= k;
curr++;
}
for (int i = 0; i < n; i++) {
if (((mask >> i) & 1) && v >= a[i] && (dp[mask ^ (1 << i)][v - a[i]])) {
mask ^= (1 << i);
v -= a[i];
amt[i] = curr;
break;
}
}
}
priority_queue<pair<int, int>> pq;
for (int i = 0; i < n; i++) {
pq.push(make_pair(amt[i], a[i]));
}
while (pq.size() > 1) {
pair<int, int> a = pq.top();
pq.pop();
pair<int, int> b = pq.top();
pq.pop();
cout << a.second << " " << b.second << "\n";
pair<int, int> c = make_pair(a.first, a.second + b.second);
while (c.second % k == 0) {
c.second /= k;
c.first -= 1;
}
pq.push(c);
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int mul_mod(int a, int b, int p) {
return (long long)a * b >= p ? (long long)a * b % p + p : a * b;
}
int power_mod(int a, int n, int p) {
int ret = 1;
while (n) {
if (n & 1) ret = mul_mod(ret, a, p);
a = mul_mod(a, a, p);
n >>= 1;
}
return ret;
}
map<int, int> phi;
int euler(int n) {
if (phi.count(n)) return phi[n];
int ret = n;
for (int x = 2; x * x <= n; x++) {
if (n % x == 0) {
ret = ret / x * (x - 1);
while (n % x == 0) n /= x;
}
}
if (n > 1) ret = ret / n * (n - 1);
return phi[n] = ret;
}
int w[MAXN];
int calc(int l, int r, int p) {
if (p == 1 || l == r) return power_mod(w[l], 1, p);
int e = calc(l + 1, r, euler(p));
return power_mod(w[l], e, p);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", calc(l, r, m) % m);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, d, a, b, y, i;
cin >> n;
y = 0, a = 1e9, b = -100000000;
for (i = 0; i < n; i++) {
cin >> c >> d;
if (d == 1)
b = max(1900 - y, b);
else if (d == 2)
a = min(1900 - y, a);
y += c;
}
if (a == 1e9)
cout << "Infinity" << endl;
else if (a <= b)
cout << "Impossible" << endl;
else
cout << a - 1 + y << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dirx[] = {1, -1, 0, 0};
int diry[] = {0, 0, 1, -1};
struct point {
int x;
int y;
};
bool isprime(long long n) {
if (n < 2) return 0;
if (n == 2) return 1;
if (!(n & 1)) return 0;
long long sq = sqrt(n);
for (long long i = 3; i <= sq; i += 2) {
if (n % i == 0) return 0;
}
return 1;
}
map<int, int> mp;
bool cmp(pair<int, int> a, pair<int, int> b) {
return (a.first < b.first && a.second > b.second);
}
bool pow_of_two(int n) { return !(n & (n - 1)); }
bool cmp1(int a, int b) { return mp[a] > mp[b]; }
void solve() {
int n, ans = 0;
cin >> n;
bool ara[1009][10];
map<int, int> mp;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 5; j++) cin >> ara[i][j];
for (int i = 1; i <= 5; i++) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
if (ara[j][i] == 1) cnt++;
}
if (cnt >= (n / 2)) mp[i] = 1;
}
for (int i = 1; i <= 5; i++) {
for (int j = i + 1; j <= 5; j++) {
bool ok = true;
for (int k = 1; k <= n; k++) {
if (ara[k][i] == 0 && ara[k][j] == 0) {
ok = false;
break;
}
}
if (ok && mp[i] && mp[j]) {
cout << "YES" << endl;
return;
}
}
}
cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int N;
int d[maxn];
char s[maxn][maxn];
vector<int> ans;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= N; i++) scanf("%d", &d[i]);
for (;;) {
int now = -1;
for (int i = 1; i <= N; i++)
if (d[i] == 0) now = i;
if (now == -1) break;
for (int i = 1; i <= N; i++)
if (s[now][i] == '1') d[i]--;
ans.push_back(now);
}
cout << (int)ans.size() << endl;
for (int i : ans) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll LINF = 1001002003004005006ll;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
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;
}
vector<vector<int>> fillnxt(string s) {
int n = (int)s.size();
vector<vector<int>> ret(n + 1, vector<int>(26, 1000000000));
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < (26); j++) ret[i][j] = ret[i + 1][j];
ret[i][s[i] - 'a'] = i;
}
return ret;
}
void solve() {
string s, t;
cin >> s >> t;
int n = (int)s.size(), m = (int)t.size();
auto nxt = fillnxt(s);
for (int cut = 1; cut <= m; cut++) {
string p1 = t.substr(0, cut), p2 = t.substr(cut, m - cut);
vector<vector<int>> dp(p1.size() + 1,
vector<int>(p2.size() + 1, 1000000000));
dp[0][0] = 0;
for (int i = 0; i < (p1.size() + 1); i++) {
for (int j = 0; j < (p2.size() + 1); j++) {
if (dp[i][j] >= 1000000000) continue;
if (i < p1.size()) chmin(dp[i + 1][j], nxt[dp[i][j]][p1[i] - 'a'] + 1);
if (j < p2.size()) chmin(dp[i][j + 1], nxt[dp[i][j]][p2[j] - 'a'] + 1);
}
}
if (dp[p1.size()][p2.size()] < 1000000000) {
cout << "YES" << endl;
return;
}
}
cout << "NO" << endl;
return;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
int q;
cin >> q;
while (q--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mas[6], m, n, l[6];
string st[6], per[6];
string str;
string arr[100];
string ans[100];
int an;
int main() {
arr[0] = "";
for (int i = 0; i < 100; ++i) arr[0] += ".";
for (int i = 1; i < 100; ++i) arr[i] = arr[0];
for (int i = 0; i < 6; ++i) cin >> st[i];
for (int i = 0; i < 6; ++i) mas[i] = i;
for (int f = 0; f < 720; ++f) {
for (int i = 0; i < 6; ++i) per[i] = st[mas[i]];
for (int i = 0; i < 6; ++i) l[i] = per[i].length();
if (0) {
cout << "per"
<< ": ";
for (int innercounter = 0; innercounter < 6; ++innercounter)
cout << per[innercounter] << " ";
cout << endl;
};
if (l[2] == l[0] + l[1] - 1 && l[5] == l[3] + l[4] - 1) {
if (per[0][0] == per[3][0] && per[1][l[1] - 1] == per[4][l[4] - 1] &&
per[0][l[0] - 1] == per[5][0] && per[1][0] == per[5][l[5] - 1] &&
per[3][l[3] - 1] == per[2][0] && per[4][0] == per[2][l[2] - 1]) {
if (per[5][l[3] - 1] == per[2][l[0] - 1]) {
int n = l[5];
int m = l[2];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) arr[i][j] = '.';
for (int i = 0; i < l[0]; ++i) arr[0][i] = per[0][i];
for (int i = 0; i < l[1]; ++i) arr[n - 1][l[0] - 1 + i] = per[1][i];
for (int i = 0; i < l[2]; ++i) arr[l[3] - 1][i] = per[2][i];
for (int i = 0; i < l[3]; ++i) arr[i][0] = per[3][i];
for (int i = 0; i < l[4]; ++i) arr[l[3] - 1 + i][m - 1] = per[4][i];
for (int i = 0; i < l[5]; ++i) arr[i][l[0] - 1] = per[5][i];
str = "";
bool p = true;
for (int i = 0; i < n; ++i)
if (arr[i].substr(0, m) < ans[i])
break;
else if (arr[i].substr(0, m) > ans[i]) {
p = false;
break;
}
if (p || an <= 0) {
an = n;
for (int i = 0; i < n; ++i) ans[i] = arr[i].substr(0, m);
}
}
}
}
next_permutation(mas, mas + 6);
}
if (an == 0)
puts("Impossible");
else
for (int i = 0; i < an; ++i) cout << ans[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 6e4 + 10;
const long long inf = 1e9 + 3;
long long n, k;
long long t;
int main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld", &n, &k);
if (n == 2 && k == 3) {
puts("NO");
continue;
}
bool f = 0;
long long tot = 0;
long long base = 1;
for (long long i = 1; i <= n; ++i) {
tot += base;
base *= 1LL * 4;
if (tot >= k) {
f = 1;
break;
}
}
if (f == 0) {
puts("NO");
continue;
}
k--;
base = 1;
long long ans = 0;
for (long long i = 1; i < n; ++i) {
long long nxt = 4LL * base - 1;
k -= nxt;
base *= 2;
if (k == 0) {
ans = n - i - 1;
break;
} else if (k < 0) {
ans = n - i;
break;
}
}
printf("YES %lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int N = 2000 + 5;
int n;
struct Point {
int x, y, id;
inline long long operator*(const Point &rhs) const {
return (long long)x * rhs.y - (long long)y * rhs.x;
}
inline bool operator<(const Point &rhs) const { return x < rhs.x; }
};
Point a[N];
char str[N];
bool vis[N];
inline long long cross(Point *base, Point *now, Point *alter) {
return (Point){now->x - base->x, now->y - base->y, 0} *
(Point){alter->x - base->x, alter->y - base->y, 0};
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(a[i].x), read(a[i].y);
a[i].id = i;
}
Point *last = min_element(a + 1, a + n + 1), *now;
vis[last->id] = true;
scanf("%s", str + 1);
printf("%d ", last->id);
for (int i = 1; i <= n - 2; ++i) {
now = nullptr;
for (int j = 1; j <= n; ++j) {
if (!vis[a[j].id]) {
if (now == nullptr) {
now = &a[j];
} else {
if (str[i] == 'L') {
if (cross(last, now, &a[j]) < 0) {
now = &a[j];
}
} else {
if (cross(last, now, &a[j]) > 0) {
now = &a[j];
}
}
}
}
}
vis[now->id] = true;
printf("%d ", now->id);
last = now;
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
printf("%d ", i);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, cnt, a[1005];
double solve(int x, int y, int r) {
double ret = 1;
while (r--) {
ret *= (x-- * 1.0 / y--);
}
return ret;
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= m; ++i) {
cin >> a[i];
cnt += a[i];
}
if (cnt < n) {
return cout << -1, 0;
}
printf("%.09lf", 1 - solve(cnt - n, cnt - 1, a[h] - 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct total {
long long c[2][2];
total() {
long long i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
c[i][j] = 0;
}
}
}
};
total aa[123456], bb[123456];
long long a[123456], b[123456], c[12][12], d[12][12];
long long n, m;
long long check1() {
long long i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
if (aa[0].c[i][j] != c[i][j]) return 0;
}
}
return 1;
}
long long check2() {
long long i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
if (bb[0].c[i][j] != c[i][j]) return 0;
}
}
return 1;
}
long long fact[212345], invfact[212345], inv[123456];
long long precomp() {
long long i;
fact[0] = 1;
for (i = 1; i < 123456; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= (1000 * 1000 * 1000 + 7);
}
inv[1] = 1;
long long p = (1000 * 1000 * 1000 + 7);
for (i = 2; i < 123456; i++) {
inv[i] = (p - p / i) * inv[p % i];
inv[i] %= (1000 * 1000 * 1000 + 7);
}
invfact[0] = 1;
invfact[1] = 1;
for (i = 2; i < 123456; i++) {
invfact[i] = invfact[i - 1] * inv[i];
invfact[i] %= (1000 * 1000 * 1000 + 7);
}
return 0;
}
long long nCr(long long n, long long r) {
if (n < r) return 0;
if (r < 0) return 0;
long long ans = fact[n];
ans *= invfact[r];
ans %= (1000 * 1000 * 1000 + 7);
ans *= invfact[n - r];
ans %= (1000 * 1000 * 1000 + 7);
return ans;
}
long long computeans1(long long pos) {
long long i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
d[i][j] = c[i][j] - aa[pos + 1].c[i][j];
}
}
if (pos != n - 1) {
d[a[pos + 1]][a[pos] ^ 1]--;
}
long long cur = a[pos] ^ 1;
long long ans = 1;
if (d[cur][cur ^ 1] == d[cur ^ 1][cur]) {
ans = nCr(d[cur][cur] + d[cur][cur ^ 1], d[cur][cur ^ 1]);
if (d[cur][cur ^ 1] >= 1)
ans *=
nCr(d[cur ^ 1][cur ^ 1] + d[cur][cur ^ 1] - 1, d[cur][cur ^ 1] - 1);
else if (d[cur ^ 1][cur ^ 1] != 0)
ans = 0;
} else if (d[cur][cur ^ 1] == d[cur ^ 1][cur] + 1) {
ans = nCr(d[0][0] + d[cur][cur ^ 1] - 1, d[cur][cur ^ 1] - 1);
ans *= nCr(d[1][1] + d[cur][cur ^ 1] - 1, d[cur][cur ^ 1] - 1);
} else {
ans = 0;
}
ans %= (1000 * 1000 * 1000 + 7);
return ans;
}
long long computeans2(long long pos) {
long long i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
d[i][j] = c[i][j] - bb[pos + 1].c[i][j];
}
}
if (pos != m - 1) {
d[b[pos + 1]][b[pos] ^ 1]--;
}
long long cur = b[pos] ^ 1;
long long ans = 1;
if (d[cur][cur ^ 1] == d[cur ^ 1][cur]) {
ans = nCr(d[cur][cur] + d[cur][cur ^ 1], d[cur][cur ^ 1]);
if (d[cur][cur ^ 1] >= 1)
ans *=
nCr(d[cur ^ 1][cur ^ 1] + d[cur][cur ^ 1] - 1, d[cur][cur ^ 1] - 1);
else if (d[cur ^ 1][cur ^ 1] != 0)
ans = 0;
} else if (d[cur][cur ^ 1] == d[cur ^ 1][cur] + 1) {
ans = nCr(d[0][0] + d[cur][cur ^ 1] - 1, d[cur][cur ^ 1] - 1);
ans *= nCr(d[1][1] + d[cur][cur ^ 1] - 1, d[cur][cur ^ 1] - 1);
} else {
ans = 0;
}
ans %= (1000 * 1000 * 1000 + 7);
return ans;
}
long long visit[123456][2][2], dp[123456][2][2];
long long compute(long long pos, long long f1, long long f2) {
if (pos == -1) {
if (f1) {
return check1();
} else {
return check2();
}
}
if (visit[pos][f1][f2] == 1) {
return dp[pos][f1][f2];
}
visit[pos][f1][f2] = 1;
long long ans = 0;
long long nodo = 0;
long long newf1, newf2;
if (f1) {
if (a[pos] == 1) {
nodo = 1;
} else {
newf1 = 1;
}
} else {
newf1 = 0;
}
if (f2) {
if (b[pos] == 1) {
newf2 = 0;
} else {
newf2 = 1;
}
} else {
newf2 = 0;
}
if (!nodo && pos != m - 1) {
if (newf1 + newf2) {
ans += compute(pos - 1, newf1, newf2);
} else {
if (f1) {
ans += computeans1(pos);
} else {
ans += computeans2(pos);
}
}
}
nodo = 0;
if (f1) {
if (a[pos] == 1) {
newf1 = 1;
} else {
newf1 = 0;
}
} else {
newf1 = 0;
}
if (f2) {
if (b[pos] == 1) {
newf2 = 1;
} else {
nodo = 1;
}
} else {
newf2 = 0;
}
if (!nodo) {
if (newf1 + newf2) {
ans += compute(pos - 1, newf1, newf2);
} else {
if (f1) {
ans += computeans1(pos);
} else {
ans += computeans2(pos);
}
}
}
ans %= (1000 * 1000 * 1000 + 7);
dp[pos][f1][f2] = ans;
return ans;
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long i, j;
string s, t;
long long sumi = 0;
cin >> s >> t;
precomp();
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
cin >> c[i][j];
sumi += c[i][j];
}
}
sumi++;
for (i = 0; i < s.length(); i++) {
a[s.length() - 1 - i] = s[i] - '0';
}
for (i = 0; i < t.length(); i++) {
b[t.length() - 1 - i] = t[i] - '0';
}
n = s.length();
m = t.length();
if (sumi < n || m < sumi) {
cout << 0 << endl;
return 0;
}
if (m > sumi) {
for (i = 0; i < sumi; i++) {
b[i] = 1;
}
for (i = sumi; i < m; i++) {
b[i] = 0;
}
m = sumi;
}
for (i = 0; i < m + 10; i++) {
aa[i] = total();
bb[i] = total();
}
for (i = n - 2; i >= 0; i--) {
aa[i] = aa[i + 1];
aa[i].c[a[i + 1]][a[i]]++;
}
for (i = m - 2; i >= 0; i--) {
bb[i] = bb[i + 1];
bb[i].c[b[i + 1]][b[i]]++;
}
cout << compute(sumi - 1, 1, 1) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
int dif = n - k;
if (!dif) {
for (int i = 0; i < (int)(n); i++) cout << '1';
cout << endl;
return 0;
}
if (k == 1) {
cout << '0';
for (int i = 0; i < (int)(n - 1); i++) cout << '1';
cout << endl;
return 0;
}
k -= 2;
dif += 2;
dif /= 2;
for (int i = 0; i < (int)(dif - 1); i++) cout << '1';
cout << '0';
for (int i = 0; i < (int)(dif - 1); i++) cout << '1';
cout << '0';
int cnt = 0;
for (int i = 0; i < (int)(k); i++) {
cnt++;
if (cnt == dif)
cout << '0', cnt = 0;
else
cout << '1';
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, M, H, S, T;
inline long double Calc(int N, int M) {
long double Ret = 1;
for (int i = 1; i <= M; i++) {
Ret *= N + 1 - i;
Ret /= 1.0 * i;
}
return Ret;
}
int main() {
cin >> N >> M >> H;
for (int i = 1, k; i <= M; i++) {
cin >> k;
S += k;
if (i == H) T = k;
}
if (S < N) {
printf("-1.00000\n");
return 0;
}
N--;
S--;
T--;
long double TOT = Calc(S, N);
long double SUM = 0;
for (int i = 1; i <= N && i <= T; i++) {
SUM += Calc(T, i) * Calc(S - T, N - i);
}
cout << SUM / TOT << endl;
double Ans = SUM / TOT;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void bug() { cout << " " << endl; }
template <class T>
void bug(T a) {
cout << a << " ";
}
template <class T>
void bug(T* a, int n) {
for (int i = 0; i < (n); i++) bug(a[i]);
}
int n;
char s[333333], t[333333];
vector<int> si[26], ti[26];
double calc(vector<int> i, vector<int> j) {
long long sum_j = 0;
int b = 0;
double ret = 0;
for (int a = 0; a < (i.size()); a++) {
while (b < j.size() && j[b] < i[a]) {
sum_j += j[b];
b++;
}
ret += sum_j * 1. * (n + 1 - i[a]);
}
return ret;
}
double calc2(vector<int> i, vector<int> j) {
int b = 0;
double ret = 0;
for (int a = 0; a < (i.size()); a++) {
while (b < j.size() && j[b] < i[a]) b++;
if (b < j.size() && j[b] == i[a]) ret += i[a] * 1.0 * (n + 1 - i[a]);
}
return ret;
}
int main() {
cin >> n;
cin >> s >> t;
for (int i = 0; i < (n); i++) {
si[s[i] - 'A'].push_back(i + 1);
ti[t[i] - 'A'].push_back(i + 1);
}
double sum = 0;
for (int i = 0; i < (26); i++) {
sum += calc(si[i], ti[i]);
sum += calc(ti[i], si[i]);
sum += calc2(ti[i], si[i]);
}
long long fac = 0;
for (int i = 0; i < (n + 1); i++) fac += i * 1LL * i;
cout << fixed << setprecision(16);
cout << 1.0 * sum / fac << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
bool ma[1010][1010];
bool used[1010][1010][4];
struct node {
int x, d[4];
} dp[1010][1010];
int main() {
int n, m, k;
scanf("%d %d %d\n", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c = getchar();
ma[i][j] = (c == '.');
}
getchar();
}
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
x1--;
y1--;
x2--;
y2--;
memset(used, false, sizeof(used));
queue<pair<int, int> > que;
que.push(make_pair(x1, y1));
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dp[i][j].x = -1;
dp[x1][y1].x = 0;
for (int i = 0; i < 4; i++) used[x1][y1][i] = true;
while (!que.empty()) {
int x = que.front().first, y = que.front().second;
que.pop();
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (tx >= 0 && tx < n && ty >= 0 && ty < m && ma[tx][ty]) {
if (dp[tx][ty].x < 0 ||
(dp[tx][ty].x >= dp[x][y].x + (dp[x][y].d[i] == 0 ? 1 : 0))) {
dp[tx][ty].x = dp[x][y].x + (dp[x][y].d[i] == 0 ? 1 : 0);
dp[tx][ty].d[i] = (dp[x][y].d[i] + 1) % k;
if (!used[tx][ty][i]) {
que.push(make_pair(tx, ty));
used[tx][ty][i] = true;
}
}
}
}
}
printf("%d\n", dp[x2][y2].x == 22465 ? 22466 : dp[x2][y2].x);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int A[] = {1, 10, 100, 1000, 10000,
100000, 1000000, 10000000, 100000000, 1000000000};
long long int S[] = {4, 44, 444, 4444, 44444,
444444, 4444444, 44444444, 444444444};
long long int dec(int i) {
long long int ans = 0;
for (int k = 0; k < 9; k++) {
ans += A[k] * ((i & (1 << k)) != 0);
}
return ans;
}
int main() {
long long int n, x = 0, y = 0, zz = 0;
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) {
y = y * 10 + (int)(str[i] - '0');
}
for (int i = 0; i < str.size(); i++) {
if (str[i] == '4') str[i] = '0';
if (str[i] == '7') str[i] = '1';
}
for (int i = 0; i < str.size(); i++) {
x = x * 10 + (int)(str[i] - '0');
}
bool mark = 0;
int len = str.length();
for (int i = 0; i < 9; i++) {
if (S[i] == y) {
zz++;
break;
}
if (S[i] < y && !(len == i + 1)) {
zz += pow(2, i + 1);
} else if (S[i] < y && len == i + 1) {
for (int j = 0; j < pow(2, i + 1); j++) {
zz++;
if (dec(j) == x) {
mark = 1;
break;
}
}
}
if (mark) break;
}
cout << zz << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int cases = 0; cases < t; ++cases) {
int n;
cin >> n;
int maxmonster = -1;
vector<int> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
maxmonster = max(maxmonster, A[i]);
}
int m;
cin >> m;
vector<int> V(n + 2, -1);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
if (x >= maxmonster) maxmonster = -1;
V[y] = max(V[y], x);
}
if (maxmonster > -1)
cout << -1 << endl;
else {
vector<int> maximum(n + 2, -1);
for (int i = n; i > 0; --i) maximum[i] = max(maximum[i + 1], V[i]);
int total = 0;
int pos = 0;
while (pos < n) {
++total;
int maxpower = A[pos];
int hero = 1;
while (pos + hero < n and
maximum[hero + 1] >= max(maxpower, A[pos + hero])) {
maxpower = max(maxpower, A[pos + hero]);
++hero;
}
pos += hero;
}
cout << total << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0u >> 2;
int n, m, maxn;
int p[2][2];
long long ans, sub, S;
int gcd[4010][4010];
int main() {
scanf("%d%d", &n, &m);
++n, ++m;
maxn = max(n, m);
for (int i = 0; i < maxn; ++i) gcd[i][0] = gcd[0][i] = i;
for (int i = 0; i < maxn; ++i)
for (int j = 0; j < maxn; ++j)
if (i < j)
gcd[i][j] = gcd[i][j - i];
else
gcd[i][j] = gcd[j][i - j];
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
p[i][j] = ((n + 1 - i) >> 1) * ((m + 1 - j) >> 1);
for (int a = 0; a < 2; ++a)
for (int b = 0; b < 2; ++b)
for (int c = 0; c < 2; ++c)
for (int d = 0; d < 2; ++d)
for (int e = 0; e < 2; ++e)
for (int f = 0; f < 2; ++f) {
int x1 = c - a, y1 = d - b, x2 = e - a, y2 = f - b;
if (!((x1 * y2 - x2 * y1) & 1))
ans += (long long)p[a][b] * p[c][d] % 1000000007 * p[e][f] %
1000000007,
ans %= 1000000007;
}
S = n * m;
sub += S, sub %= 1000000007;
sub += S * (S - 1) % 1000000007 * 3 % 1000000007, sub %= 1000000007;
sub += S % 1000000007 * (m - 1) % 1000000007 * (m - 2) % 1000000007,
sub %= 1000000007;
sub += S % 1000000007 * (n - 1) % 1000000007 * (n - 2) % 1000000007,
sub %= 1000000007;
for (int i = 1; i < n; ++i)
for (int j = 1; j < m; ++j)
if (gcd[i][j] >= 2) {
long long tmp = (long long)(gcd[i][j] - 1) * (n - i) % 1000000007 *
(m - j) % 1000000007 * 12 % 1000000007;
sub += tmp, sub %= 1000000007;
}
printf("%I64d\n", (ans - sub + 1000000007) % 1000000007);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 10;
const int MAXM = 10000 + 10;
const int INF = 1000 * 1000 * 1000;
int n, m, a[MAXM], b[MAXM], c[MAXM], q[MAXN], d[MAXN][MAXN], s, minimum[MAXN];
int main() {
int check = 0;
int sum = 0;
int pt = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
minimum[i] = INF;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
d[a[i]][b[i]] = c[i];
minimum[b[i]] = min(c[i], minimum[b[i]]);
}
for (int i = 1; i <= n; i++) {
if (minimum[i] != INF) {
sum += minimum[i];
check++;
}
}
if (check == n - 1)
cout << sum;
else
cout << -1;
cin >> s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, ans = 0;
void gcd(long long a, long long b) {
if (b == 0)
return;
else {
ans += a / b;
gcd(b, a % b);
}
}
int main() {
scanf("%I64d %I64d", &a, &b);
gcd(a, b);
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O1")
#pragma GCC optimize("O2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const long long INF = LLONG_MAX / 2;
const int mod = (1000 * 1000 * 1000 + 7);
const int inf = INT_MAX / 2;
const int N = 300001;
const int M = 1000001;
const long long H = 31;
const double Pi = acos((-1));
const double EPS = 1.0 / (9999999.9 * (double)inf);
const string io = "";
int n, m, i, j, ans, c[6];
char a[55][55];
void solve() {
cin >> c[0] >> c[1] >> c[2] >> c[3];
if (c[0]) c[0]--;
if (c[1]) c[1]--;
cout << "50 50\n";
for (i = 1; i <= 50; i++)
for (j = 1; j <= 50; j++) a[i][j] = '^';
for (i = 1; i < 25; i += 2) {
for (j = 1; j <= 50; j += 2) {
if (c[1] > 0) {
a[i][j] = 'B';
c[1]--;
} else if (c[2] > 0) {
a[i][j] = 'C';
c[2]--;
}
}
}
i += 2;
for (; i <= 50; i += 2)
for (j = 1; j <= 50; j += 2) {
if (c[3] > 0) {
a[i][j] = 'D';
c[3]--;
} else if (c[0] > 0) {
a[i][j] = 'A';
c[0]--;
}
}
for (i = 1; i <= 50; i++)
for (j = 1; j <= 50; j++) {
if (a[i][j] == '^') {
if (i <= 25)
cout << 'A';
else
cout << 'B';
} else
cout << a[i][j];
if (j == 50) cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> par;
void bryceorz(int v, int p, const vector<vector<int>> &graph) {
par[v] = p;
for (int nxt : graph[v]) {
if (nxt == p) continue;
bryceorz(nxt, v, graph);
}
}
int main() {
int n;
scanf("%d", &n);
vector<double> fail(n);
for (int i = 0; i < n; ++i) scanf("%lf", &fail[i]);
vector<vector<int>> tree(n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
tree[a].push_back(b);
tree[b].push_back(a);
}
par.assign(n, -1);
bryceorz(0, -1, tree);
par.push_back(-1);
fail.push_back(1.0);
par[0] = n;
vector<double> childrenSums(n + 1);
vector<int> childCount(n + 1);
for (int i = 0; i < n; ++i) childrenSums[par[i]] += fail[i];
for (int i = 0; i <= n; ++i)
if (par[i] != -1) ++childCount[par[i]];
double allSum = 0;
for (int i = 0; i < n; ++i) allSum += fail[i];
auto getAns = [&]() {
double ans = 0;
for (int i = 0; i < n; ++i) {
ans += (1 - fail[i]) * fail[par[i]];
}
return ans;
};
double currentAns = getAns();
int q;
scanf("%d", &q);
while (q--) {
int v;
double new_f;
scanf("%d %lf", &v, &new_f);
double d = new_f - fail[v];
double answerChange =
d * childCount[v] - (fail[par[v]] + childrenSums[v]) * d;
currentAns += answerChange;
fail[v] += d;
childrenSums[par[v]] += d;
printf("%.6lf\n", currentAns);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool checkBit(long long int n, long long int i) { return (n & (1LL << i)); }
long long int setBit(long long int n, long long int i) {
return (n | (1LL << i));
}
long long int resetBit(long long int n, long long int i) {
return (n & (~(1LL << i)));
}
const long long int MX = 1e18;
const long long int mod = 1e9 + 7;
map<int, int> m;
void solve() {
string a, b;
cin >> a >> b;
set<int> s;
for (auto x : a) {
m[x - '0']++;
s.insert(x - '0');
}
vector<int> ans;
int n = a.size();
int np = b.size();
if (np > n) {
for (int i = 9; i >= 0; i--) {
while (m[i]--) {
cout << i;
}
}
return;
}
for (int i = n; i >= 0; i--) {
int vis[11] = {0};
for (int j = 0; j < 10; j++) vis[j] = m[j];
set<int> sp = s;
ans.clear();
int flag = 0;
for (int j = 0; j < i; j++) {
int crt = b[j] - '0';
if (vis[crt] <= 0) {
flag = 1;
break;
}
vis[crt]--;
ans.push_back(crt);
if (vis[crt] == 0) {
sp.erase(crt);
}
}
if (flag) continue;
if (i == n and flag == 0) {
break;
}
int crt = b[i] - '0';
for (int j = crt - 1; j >= 0; j--) {
if (vis[j] > 0) {
ans.push_back(j);
vis[j]--;
for (int j = 9; j >= 0; j--) {
while (vis[j]--) {
ans.push_back(j);
}
}
flag = 1;
break;
}
}
if (flag == 1) break;
}
for (auto x : ans) {
cout << x;
}
cout << "\n";
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, t, i, j, g[80][4][4], k, l;
long long f[80], a, b, p[80][4];
int w(int a, int b, int n) {
if (n == -1 || p[n][a] == p[n][b]) return 0;
if (g[n][a][b]) return g[n][a][b];
int ans;
if (p[n][a] > f[n - 1])
ans = w(a, b, n - 2);
else if (p[n][a] <= f[n - 1] && p[n][b] > f[n - 1])
ans = min(w(0, a, n - 1), w(a, 3, n - 1)) + 1 + w(0, b, n - 2);
else
ans = min(w(a, b, n - 1), min(w(0, a, n - 1) + w(b, 3, n - 1) + 2,
w(0, b, n - 1) + w(a, 3, n - 1) + 2));
g[n][a][b] = ans;
return ans;
}
int main() {
scanf("%d%d", &t, &i);
f[0] = 1;
f[1] = 2;
for (n = 2;; ++n) {
f[n] = f[n - 1] + f[n - 2];
if (f[n] > 1e16) break;
}
n = min(n, i);
for (i = 1; i <= t; ++i) {
scanf("%I64d%I64d", &a, &b);
if (a > b) swap(a, b);
for (j = n; j >= 0; --j) {
p[j][0] = 1;
p[j][1] = a;
p[j][2] = b;
p[j][3] = f[j];
if (a > f[j - 1]) a -= f[j - 1];
if (b > f[j - 1]) b -= f[j - 1];
for (k = 0; k < 3; ++k)
for (l = 1; l < 4; ++l) g[j][k][l] = 0;
g[j][0][3] = (j + 1) / 2;
}
printf("%d\n", w(1, 2, n));
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long INF = 1e6;
const int MOD = 1e9 + 7;
vector<pair<int, int> > v;
long long lgpow(long long x, long long put) {
long long rasp = 1;
while (put != 0) {
if (put % 2 == 1) rasp = (1LL * rasp * x) % MOD;
x = (1LL * x * x) % MOD;
put /= 2;
}
return rasp;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
long long x = 0;
int T;
cin >> T;
while (T--) {
int n, p;
cin >> n >> p;
for (int j = 1; j <= n; j++) {
int x;
cin >> x;
v.push_back(make_pair(x, 1));
}
if (p == 1) {
cout << n % 2 << '\n';
v.clear();
continue;
}
sort(v.begin(), v.end());
int pos = 0;
for (int i = 1; i < n; i++) {
if (v[i].first != v[i - 1].first) {
v[++pos] = v[i];
} else
v[pos].second++;
}
n = pos + 1;
long long x, y, sum = 0, rasp, aux = v[n - 1].first + 1, i;
for (i = n - 1; i >= 0; i--) {
x = v[i].first;
y = v[i].second;
if (sum == 0) aux = x;
while (sum < INF && aux > x) {
aux--;
sum = 1LL * sum * p;
}
if (sum >= INF)
break;
else {
if (sum > y)
sum -= y;
else if ((y - sum) % 2 == 0)
sum = 0;
else
sum = 1;
}
}
sum %= MOD;
rasp = lgpow(p, aux);
rasp = (1LL * rasp * sum) % MOD;
while (i >= 0) {
rasp = (rasp - (v[i].second * (lgpow(p, v[i].first))) % MOD) % MOD;
i--;
}
if (rasp < 0) rasp += MOD;
cout << rasp << '\n';
v.clear();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Line {
int x, y;
} l[101000], r[101000];
int n, m, a[101000], x, y, seg[401000], rev[401000];
bool cmpx(Line a, Line b) { return a.x < b.x; }
bool cmpy(Line a, Line b) { return a.y < b.y; }
void Pushdown(int rt, int l, int r) {
if (rev[rt]) {
rev[rt] = 0;
rev[rt << 1] ^= 1;
rev[rt << 1 | 1] ^= 1;
int mid = (l + r) >> 1;
seg[rt << 1] = (mid - l + 1) - seg[rt << 1];
seg[rt << 1 | 1] = (r - mid) - seg[rt << 1 | 1];
}
}
void Update(int l, int r, int rt, int x, int y) {
if (x <= l && r <= y) {
seg[rt] = (r - l + 1) - seg[rt];
rev[rt] ^= 1;
return;
}
Pushdown(rt, l, r);
int mid = (l + r) >> 1;
if (x <= mid) Update(l, mid, rt << 1, x, y);
if (mid < y) Update(mid + 1, r, rt << 1 | 1, x, y);
seg[rt] = seg[rt << 1] + seg[rt << 1 | 1];
}
int Query(int l, int r, int rt, int x, int y) {
if (x > y) return 0;
if (x <= l && r <= y) return seg[rt];
Pushdown(rt, l, r);
int mid = (l + r) >> 1, ans = 0;
if (x <= mid) ans += Query(l, mid, rt << 1, x, y);
if (mid < y) ans += Query(mid + 1, r, rt << 1 | 1, x, y);
return ans;
}
int main(void) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
l[i].x = lower_bound(a + 1, a + n + 1, x) - a;
l[i].y = upper_bound(a + 1, a + n + 1, y) - a - 1;
if (l[i].x >= l[i].y) i--, m--;
r[i] = l[i];
}
sort(l + 1, l + m + 1, cmpy);
sort(r + 1, r + m + 1, cmpx);
long long ans = 1LL * n * (n - 1) * (n - 2) / 6;
for (int i = 1, li = 1, ri = 1; i <= n; i++) {
while (r[ri].x == i) {
Update(1, n, 1, r[ri].x, r[ri].y);
++ri;
}
while (l[li].y == i - 1) {
Update(1, n, 1, l[li].x, l[li].y);
++li;
}
long long w = i - 1 - Query(1, n, 1, 1, i - 1) + Query(1, n, 1, i + 1, n);
ans -= w * (w - 1) / 2;
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100005], *p1 = buf + 100005, *pend = buf + 100005;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100005, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
}
inline void read(long long &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
}
inline void read(double &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (ch == '.') {
double tmp = 1;
ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc())
tmp /= 10.0, x += tmp * (ch - '0');
}
if (sign) x = -x;
}
inline void read(char *s) {
char ch = nc();
for (; blank(ch); ch = nc())
;
if (IOerror) return;
for (; !blank(ch) && !IOerror; ch = nc()) *s++ = ch;
*s = 0;
}
inline void read(char &c) {
for (c = nc(); blank(c); c = nc())
;
if (IOerror) {
c = -1;
return;
}
}
inline void read1(int &x) {
char ch;
int bo = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline void read1(long long &x) {
char ch;
int bo = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline void read1(double &x) {
char ch;
int bo = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar())
;
if (ch == '.') {
double tmp = 1;
for (ch = getchar(); ch >= '0' && ch <= '9';
tmp /= 10.0, x += tmp * (ch - '0'), ch = getchar())
;
}
if (bo) x = -x;
}
inline void read1(char *s) {
char ch = getchar();
for (; blank(ch); ch = getchar())
;
for (; !blank(ch); ch = getchar()) *s++ = ch;
*s = 0;
}
inline void read1(char &c) {
for (c = getchar(); blank(c); c = getchar())
;
}
inline void read2(int &x) { scanf("%d", &x); }
inline void read2(long long &x) { scanf("%lld", &x); }
inline void read2(double &x) { scanf("%lf", &x); }
inline void read2(char *s) { scanf("%s", s); }
inline void read2(char &c) { scanf(" %c", &c); }
inline void readln2(char *s) { gets(s); }
struct Ostream_fwrite {
char *buf, *p1, *pend;
Ostream_fwrite() {
buf = new char[100005];
p1 = buf;
pend = buf + 100005;
}
void out(char ch) {
if (p1 == pend) {
fwrite(buf, 1, 100005, stdout);
p1 = buf;
}
*p1++ = ch;
}
void print(int x) {
static char s[15], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
void println(int x) {
static char s[15], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
out('\n');
}
void print(long long x) {
static char s[25], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
void println(long long x) {
static char s[25], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
out('\n');
}
void print(double x, int y) {
static long long mul[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000LL,
100000000000LL,
1000000000000LL,
10000000000000LL,
100000000000000LL,
1000000000000000LL,
10000000000000000LL,
100000000000000000LL};
if (x < -1e-12) out('-'), x = -x;
x *= mul[y];
long long x1 = (long long)floor(x);
if (x - floor(x) >= 0.5) ++x1;
long long x2 = x1 / mul[y], x3 = x1 - x2 * mul[y];
print(x2);
if (y > 0) {
out('.');
for (size_t i = 1; i < y && x3 * mul[i] < mul[y]; out('0'), ++i)
;
print(x3);
}
}
void println(double x, int y) {
print(x, y);
out('\n');
}
void print(char *s) {
while (*s) out(*s++);
}
void println(char *s) {
while (*s) out(*s++);
out('\n');
}
void flush() {
if (p1 != buf) {
fwrite(buf, 1, p1 - buf, stdout);
p1 = buf;
}
}
~Ostream_fwrite() { flush(); }
} Ostream;
inline void print(int x) { Ostream.print(x); }
inline void println(int x) { Ostream.println(x); }
inline void print(char x) { Ostream.out(x); }
inline void println(char x) {
Ostream.out(x);
Ostream.out('\n');
}
inline void print(long long x) { Ostream.print(x); }
inline void println(long long x) { Ostream.println(x); }
inline void print(double x, int y) { Ostream.print(x, y); }
inline void println(double x, int y) { Ostream.println(x, y); }
inline void print(char *s) { Ostream.print(s); }
inline void println(char *s) { Ostream.println(s); }
inline void println() { Ostream.out('\n'); }
inline void flush() { Ostream.flush(); }
char Out[100005], *o = Out;
inline void print1(int x) {
static char buf[15];
char *p1 = buf;
if (!x) *p1++ = '0';
if (x < 0) *o++ = '-', x = -x;
while (x) *p1++ = x % 10 + '0', x /= 10;
while (p1-- != buf) *o++ = *p1;
}
inline void println1(int x) {
print1(x);
*o++ = '\n';
}
inline void print1(long long x) {
static char buf[25];
char *p1 = buf;
if (!x) *p1++ = '0';
if (x < 0) *o++ = '-', x = -x;
while (x) *p1++ = x % 10 + '0', x /= 10;
while (p1-- != buf) *o++ = *p1;
}
inline void println1(long long x) {
print1(x);
*o++ = '\n';
}
inline void print1(char c) { *o++ = c; }
inline void println1(char c) {
*o++ = c;
*o++ = '\n';
}
inline void print1(char *s) {
while (*s) *o++ = *s++;
}
inline void println1(char *s) {
print1(s);
*o++ = '\n';
}
inline void println1() { *o++ = '\n'; }
inline void flush1() {
if (o != Out) {
if (*(o - 1) == '\n') *--o = 0;
puts(Out);
}
}
struct puts_write {
~puts_write() { flush1(); }
} _puts;
inline void print2(int x) { printf("%d", x); }
inline void println2(int x) { printf("%d\n", x); }
inline void print2(char x) { printf("%c", x); }
inline void println2(char x) { printf("%c\n", x); }
inline void print2(long long x) { printf("%lld", x); }
inline void println2(long long x) {
print2(x);
printf("\n");
}
inline void println2() { printf("\n"); }
}; // namespace fastIO
using namespace fastIO;
vector<int> r[101000];
int n, m;
vector<int> c[101000];
int fa[101000], fl[101000], ans = 1, pre[101000], used[101000];
int GF(int x) { return x == fa[x] ? x : fa[x] = GF(fa[x]); }
void dfs(int x, int fff) {
int y;
for (int i = 0; i < (int)r[x].size(); i++) {
y = r[x][i];
if (y == fff) continue;
if (!used[y]) {
pre[y] = x;
used[y] = used[x] + 1;
dfs(y, x);
} else if (used[y] < used[x]) {
for (int t = x; t != y; t = pre[t]) {
fl[GF(y)] = 1;
fa[GF(t)] = GF(y);
}
}
}
}
void doit(vector<int> &the) {
int tot = 0, d = 0, t = 0, els = 0, x, y;
for (int nnd = 0; nnd < (int)the.size(); nnd++) {
x = the[nnd];
t = 0;
for (int i = 0; i < (int)r[x].size(); i++) {
y = r[x][i];
if (fa[x] != fa[y]) {
t++;
break;
}
}
d += !!t;
}
if (d < 2) ans++;
}
int main() {
read(n);
read(m);
int x, y;
for (int i = 1; i <= m; i++) {
read(x);
read(y);
r[x].push_back(y);
r[y].push_back(x);
}
for (int i = 1; i <= n; i++) fa[i] = i, ans += r[i].size() % 2;
used[1] = 1;
dfs(1, 0);
for (int i = 1; i <= n; i++) c[GF(i)].push_back(i);
ans /= 2;
for (int i = 1; i <= n; i++)
if (fa[i] == i)
if (fl[i]) doit(c[i]);
print(ans);
print(' ');
print(m);
}
| 9 |
#include <bits/stdc++.h>
#define mod 1000000007
using namespace std;
int main()
{
long long int test;
cin >> test;
while(test--)
{
long long int x, y;
cin >> x >> y;
long long int res = 0;
long long int i = 2;
while((min(x, (i-1)*(y+1)) - (i*i - 1)) >= 0)
{
//cout << " : " << i << " : " << (min(x, (i-1)*(y+1)) - (i*i - 1)) / (i-1) + 1<< endl;
res += (min(x, (i-1)*(y+1)) - (i*i - 1)) / (i-1) +1;
i++;
}
cout << res << endl;
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first - a.second < b.first - b.second == 0) return a.first < b.first;
return a.first - a.second < b.first - b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
unsigned long long L = 1;
for (unsigned long long T = 1; T <= L; T++) {
long long n;
cin >> n;
vector<long long> v;
set<long long> P;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
P.insert(x);
}
if (P.size() > 3) {
cout << -1 << "\n";
return 0;
}
sort(v.begin(), v.end());
set<long long> dif;
for (long long i = 1; i < n; i++) {
dif.insert(abs(v[i] - v[i - 1]));
}
if (dif.size() > 2)
cout << -1 << "\n";
else {
if (dif.size() == 2 && dif.find(0) == dif.end()) {
cout << -1 << "\n";
} else {
vector<long long> B;
for (auto i : P) {
B.push_back(i);
}
if (B.size() == 1) {
cout << 0 << "\n";
} else if (B.size() == 3)
cout << B[2] - B[1] << "\n";
else {
if ((B[1] - B[0]) % 2 == 0)
cout << (B[1] - B[0]) / 2;
else
cout << B[1] - B[0] << "\n";
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
while (1) {
long long n, k;
cin >> n >> k;
long long s = int(sqrt(k));
long long low = -1, high = n + 1;
while (high - low > 1) {
long long m = (low + high) / 2;
if ((n - m) * (n - m + 1) / 2 - m > k)
low = m;
else
high = m;
}
cout << high << endl;
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z;
string st;
int main() {
scanf("%d%d", &n, &m);
x = 1;
y = n;
for (int i = 0; i < m; i++) {
cin >> st;
cin >> st;
cin >> st;
if (st[0] == 'l') {
cin >> st;
scanf("%d", &z);
if (z <= y) y = z - 1;
} else {
cin >> st;
scanf("%d", &z);
if (z >= x) x = z + 1;
}
}
if (y - x + 1 <= 0)
printf("-1\n");
else
printf("%d\n", y - x + 1);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300100;
set<int> S[N];
set<pair<int, int> > vec[N];
vector<int> g[N];
int fa[N], fat[N], tag[N], sz[N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void dfs(int x) {
for (int i : g[x])
if (i != fat[x]) {
fat[i] = x;
sz[x]++;
dfs(i);
}
}
int n, m;
void U(int x, int y) {
fa[y] = x;
if (vec[x].size() < vec[y].size()) {
swap(vec[x], vec[y]);
swap(tag[x], tag[y]);
}
--sz[x];
sz[x] += sz[y];
for (auto i : vec[y]) {
i.first += tag[y] - tag[x];
vec[x].insert(i);
}
vec[y].clear();
}
int q[N], cnt;
long long ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
if (x == y) continue;
vec[x].emplace(z, y);
}
for (int i = 2; i <= n; i++)
if (!sz[i]) q[++cnt] = i;
for (; cnt;) {
int u = find(q[cnt--]);
if (!vec[u].size()) {
cout << -1 << endl;
return 0;
}
int v = vec[u].begin()->second, w = vec[u].begin()->first + tag[u];
ans += w;
vec[u].erase(vec[u].begin());
tag[u] -= w;
v = find(v);
while (u != v) {
int t = find(fat[u]);
U(t, u);
u = find(u);
}
if (u != 1 && !sz[u]) q[++cnt] = u;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, all, flag;
int main() {
cin >> l >> r >> all;
if (l < r) {
while (l < r && all) {
l++;
all--;
}
if (all == 0) flag = 1;
} else if (l > r) {
while (l > r && all) {
r++;
all--;
}
if (all == 0) flag = 1;
}
if (l == r && all > 0) {
if (all % 2) {
l += (all - 1) / 2;
r += (all - 1) / 2;
} else {
l += all / 2;
r += all / 2;
}
}
if (l < r) {
r = l;
} else {
l = r;
}
cout << l + r << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 51, MOD = 1e9 + 7;
int x, y, res;
int dp[MAXN][MAXN];
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline int qpow(int base, int exponent) {
long long int res = 1;
while (exponent) {
if (exponent & 1) {
res = 1ll * res * base % MOD;
}
base = 1ll * base * base % MOD, exponent >>= 1;
}
return res;
}
int main() {
x = read(), y = read();
for (register int i = 1; i <= x; i++) {
dp[1][i] = 1;
}
for (register int i = 2; i <= y; i++) {
for (register int j = 1; j <= x; j++) {
for (register int k = 1; k <= j; k++) {
dp[i][j] = (dp[i][j] + dp[i - 1][k]) % MOD;
}
}
}
for (register int i = 1; i <= x; i++) {
for (register int j = i; j <= x; j++) {
res = (res + (long long int)dp[y][i] * dp[y][x - j + 1] % MOD) % MOD;
}
}
printf("%d\n", res);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long k[100000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
if (!m)
cout << 1 << endl;
else if (m <= n / 2)
cout << m << endl;
else
cout << n - m << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3003;
double dp[100005][112];
int n, a[100005], now[100005 * 2], q;
double C(int n, int m) {
double ans = 1.0;
for (int i = 1; i <= m; ++i) ans *= (n - i + 1) * 1.0 / i;
return ans;
}
int main() {
double ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), now[i] = a[i], dp[i][a[i]] = 1, ans += dp[i][0];
scanf("%d", &q);
while (q--) {
int u, v, k;
scanf("%d %d %d", &u, &v, &k);
ans -= dp[u][0];
for (int i = 0; i <= a[u]; ++i) {
double tmp = 0, zo = C(now[u], k);
for (int j = 0; j <= k; ++j)
tmp += dp[u][i + j] * C(i + j, j) * C(now[u] - i - j, k - j) / zo;
dp[u][i] = tmp;
}
now[u] -= k;
now[v] += k;
ans += dp[u][0];
printf("%.10f\n", ans);
}
return 0;
}
| 9 |
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
#define endl "\n"
#define ll long long
const int MAX=1e6+7;
const int MOD=1e9+7;
const ll inf=0x3f3f3f3f;
const double pi=3.1415926535;
int main()
{
IOS;
int n;
int t;
cin>>t;
while(t--)
{
cin>>n;
vector<ll>a(n+1,0);
int f=1;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<n;i++)
{
if(a[i]<i)
{
f=0;
break;
}
a[i+1]+=a[i]-i;
}
if(f==0) cout<<"NO"<<endl;
else cout<<"YES"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d1, d2, d3, dis1, dis2, dis3, dis4;
scanf("%d%d%d", &d1, &d2, &d3);
dis1 = d1 + d2 + d3;
dis2 = 2 * (d1 + d2);
dis3 = d1 + d3 + d3 + d1;
dis4 = d2 + d3 + d3 + d2;
printf("%d\n", min(dis1, min(dis2, min(dis3, dis4))));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 3;
const int MAXT = 1000000000;
int n, m, k, q;
int y[MAXN * MAXN], x[MAXN * MAXN], t[MAXN * MAXN];
int vis[MAXN][MAXN];
bool judge(int mid) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < q; ++i)
if (t[i] <= mid) vis[x[i]][y[i]] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
vis[i][j] += vis[i - 1][j] + vis[i][j - 1] - vis[i - 1][j - 1];
if (i >= k && j >= k &&
vis[i][j] - vis[i - k][j] - vis[i][j - k] + vis[i - k][j - k] ==
k * k)
return true;
}
return false;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
int Max = 0;
for (int i = 0; i < q; ++i) {
scanf("%d%d%d", &x[i], &y[i], &t[i]);
Max = max(Max, t[i]);
}
int l = -1, r = Max + 1;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (judge(mid))
r = mid;
else
l = mid;
}
printf("%d\n", r == Max + 1 ? -1 : r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
int c, h;
int x, y;
int d1, d2, d3, d4;
int idx;
int aux;
int best;
scanf(" %d %d", &n, &m);
d1 = d2 = d3 = d4 = -(n + m + 1);
best = n + m + 1;
idx = 0;
scanf(" %d", &c);
for (int i = 0; i < c; i++) {
scanf(" %d %d", &x, &y);
d1 = max(d1, x + y);
d2 = max(d2, x - y);
d3 = max(d3, -x + y);
d4 = max(d4, -x - y);
}
scanf(" %d", &h);
for (int i = 0; i < h; i++) {
scanf(" %d %d", &x, &y);
aux = 0;
aux = max(aux, d1 - x - y);
aux = max(aux, d2 - x + y);
aux = max(aux, d3 + x - y);
aux = max(aux, d4 + x + y);
if (aux < best) {
idx = i + 1;
best = aux;
}
}
printf("%d\n", best);
printf("%d\n", idx);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int maxm = 2e6 + 5;
const int maxl = 22;
const int INF = 0x3f3f3f3f;
int fa[maxl][maxn], dep[maxn], dis[maxl][maxn];
int head[maxn], point[maxm], nxt[maxm], val[maxm], size;
int vis[maxn];
int n, q, tmp = INF;
void init() {
size = 0;
memset(head, -1, sizeof(head));
memset(vis, 0, sizeof(vis));
}
void add(int a, int b) {
point[size] = b;
nxt[size] = head[a];
head[a] = size++;
point[size] = a;
nxt[size] = head[b];
head[b] = size++;
}
void Dfs(int s, int pre, int d) {
fa[0][s] = pre;
dis[0][s] = s;
dep[s] = d;
for (int i = head[s]; ~i; i = nxt[i]) {
int j = point[i];
if (j == pre) continue;
Dfs(j, s, d + 1);
}
}
void Pre() {
Dfs(1, -1, 0);
for (int k = 0; k + 1 < maxl; ++k) {
for (int v = 1; v <= n; ++v) {
if (fa[k][v] < 0)
fa[k + 1][v] = -1;
else
fa[k + 1][v] = fa[k][fa[k][v]];
if (fa[k][v] < 0)
dis[k + 1][v] = dis[k][v];
else
dis[k + 1][v] = min(dis[k][v], dis[k][fa[k][v]]);
}
}
}
int Lca(int u, int v) {
tmp = min(u, v);
if (dep[u] > dep[v]) swap(u, v);
for (int k = maxl - 1; k >= 0; --k) {
if ((dep[v] - dep[u]) & (1 << k)) {
tmp = min(tmp, dis[k][v]);
v = fa[k][v];
}
}
tmp = min(tmp, v);
if (u == v) return u;
for (int k = maxl - 1; k >= 0; --k) {
if (fa[k][u] != fa[k][v]) {
tmp = min(tmp, dis[k][u]);
tmp = min(tmp, dis[k][v]);
u = fa[k][u];
v = fa[k][v];
}
}
tmp = min(tmp, min(u, v));
tmp = min(tmp, fa[0][u]);
return fa[0][u];
}
int main() {
scanf("%d%d", &n, &q);
init();
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
Pre();
int last = 0, rt = 0, Min = INF;
for (int tt = 1; tt <= q; ++tt) {
int type, x;
scanf("%d%d", &type, &x);
x = (x + last) % n + 1;
if (type == 1) {
if (tt == 1) {
vis[rt = x] = 1;
Min = min(Min, x);
} else {
int lca = Lca(x, rt);
int f = x;
while (f != lca && !vis[f]) {
vis[f] = 1;
Min = min(Min, f);
f = fa[0][f];
}
f = rt;
while (f != lca && !vis[f]) {
vis[f] = 1;
Min = min(Min, f);
f = fa[0][f];
}
vis[lca] = 1;
Min = min(Min, lca);
if (rt != lca) rt = lca;
}
} else {
int ans = Min;
tmp = INF;
int lca = Lca(x, rt);
ans = min(ans, tmp);
last = ans;
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e18;
const int N = 2e6 + 10;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
template <typename T>
bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
};
template <typename T>
bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
};
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
void inc(int &a, int b) { a = (a + b >= mod ? a + b - mod : a + b); }
void dec(int &a, int b) { a = (a - b < 0 ? a - b + mod : a - b); }
int n, p[N], a[N], pw[N], cnt[N];
int pri[N], tot = 0, d[N];
bool vis[N];
void init() {
const int n = 2e6;
for (int i = 2; i <= n; i++) {
if (!vis[i]) pri[++tot] = i, d[i] = i;
for (int j = 1; j <= tot && i * pri[j] <= n; j++) {
vis[i * pri[j]] = 1;
d[i * pri[j]] = pri[j];
if (i % pri[j] == 0) break;
}
}
}
int qpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return ret;
}
int main() {
init();
cin >> n;
for (int i = 1; i <= n; i++) p[i] = gi();
sort(p + 1, p + n + 1);
for (int i = n; i; i--) {
if (!pw[p[i]])
pw[p[i]] = cnt[p[i]] = 1, a[i] = p[i];
else {
int x = p[i] - 1;
a[i] = p[i] - 1;
while (x > 1) {
int y = d[x], sum = 0;
while (x % y == 0) x /= y, sum++;
if (pw[y] < sum)
pw[y] = sum, cnt[y] = 1;
else if (pw[y] == sum)
cnt[y]++;
}
}
}
int tag = 0;
for (int i = n; i; i--) {
int x = a[i], fl = 1;
while (x > 1) {
int y = d[x], sum = 0;
while (x % y == 0) x /= y, sum++;
if (sum == pw[y] && cnt[y] == 1) fl = 0;
}
tag |= fl;
}
int ans = 1;
for (int i = 2; i <= 2000000; i++) ans = 1ll * ans * qpow(i, pw[i]) % mod;
printf("%d\n", add(ans, tag));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int readInt() {
int n = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) n = n * 10 + ch - '0', ch = getchar();
return n;
}
const int MAX_N = 200000 + 3, MOD = 1000000007;
int n, a[MAX_N], c[MAX_N], res[4][MAX_N];
long long inv[MAX_N];
void calc(int cnt) {
int len = cnt * 2 + 1;
c[0] = 1;
for (int i = 0; i < cnt; ++i)
c[i + 1] = (long long)c[i] * (cnt - i) % MOD * inv[i + 1] % MOD;
for (int i = 0; i <= cnt; ++i) res[0][i * 2] = c[i];
for (int i = 0; i <= len; ++i)
(res[1][i] = (i - 1 >= 0 ? res[0][i - 1] : 0) + res[0][i]) %= MOD;
for (int i = 0; i <= len + 1; ++i)
(res[2][i] = ((i & 1) ? 1 : -1) * (i - 1 >= 0 ? res[1][i - 1] : 0) +
res[1][i]) %= MOD;
for (int i = 0; i <= len + 2; ++i)
(res[3][i] = (i - 1 >= 0 ? res[2][i - 1] : 0) +
((i & 1) ? -1 : 1) * res[2][i]) %= MOD;
}
int main() {
inv[1] = 1;
for (int i = 2; i < MAX_N; ++i)
inv[i] = ((-(MOD / i) * inv[MOD % i] % MOD) + MOD) % MOD;
n = readInt();
for (int i = 0; i < n; ++i) a[i] = readInt();
int cnt = (n - 1) / 4 * 2, t = (n % 4 + 3) % 4, ans = 0;
calc(cnt);
for (int i = 0; i < n; ++i) (ans += (long long)res[t][i] * a[i] % MOD) %= MOD;
printf("%d\n", (ans + MOD) % MOD);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, now, d, w[2], a[110][10032];
long long ans = 0;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (j == 0) getchar();
switch (getchar()) {
case '.':
break;
case '+':
a[i][j] = 1;
break;
case '#':
a[i][j] = 2;
break;
}
}
d = 1, now = 0;
x = y = w[0] = w[1] = 0;
for (int T = 10000000; T; T--) {
if (x == n - 1) {
printf("%I64d\n", ans);
return 0;
}
if (!a[x + 1][y])
x++, w[0] = w[1] = y;
else if (y == w[now])
if ((y + d >= 0) && (y + d < m) && (a[x][y + d] < 2)) {
w[now] += d;
if (!a[x][y + d])
y += d;
else
now ^= 1, d *= -1;
} else
now ^= 1, d *= -1;
else {
ans += (long long)abs(w[now] - y) - 1;
y = w[now];
}
ans++;
}
printf("Never\n");
scanf("%d", &n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int inp[n][2];
int ans[n - 1][2];
int *jump = (int *)malloc(sizeof(int) * n);
int k = 0;
for (int i = 0; i < n; i++) {
cin >> inp[i][0] >> inp[i][1];
if (inp[i][0] == 1) jump[k++] = i;
}
int count = 0;
int t = k;
while (k != 0) {
int i = 0;
k = 0;
for (int h = 0; h < t; h++) {
i = jump[h];
if (inp[i][0] == 1) {
ans[count][0] = i;
ans[count][1] = inp[i][1];
inp[inp[i][1]][0]--;
inp[inp[i][1]][1] ^= i;
inp[i][0] = -1;
if (inp[inp[i][1]][0] == 1) jump[k++] = inp[i][1];
count++;
}
}
t = k;
}
cout << count << endl;
for (int i = 0; i < count; i++) {
cout << ans[i][0] << " " << ans[i][1] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
using namespace std;
int n;
struct Node {
int v, w, id;
Node(int v_, int w_, int idd) {
v = v_, w = w_;
id = idd;
}
};
vector<Node> g[100002];
int father[100002];
int dis[100002];
int dep[100002];
int d[100002], u[100002], inn[100002], ot[100002];
int id;
void dfs(int x, int fa, int deep) {
father[x] = fa;
dep[x] = deep;
for (int i = 0; i < g[x].size(); ++i) {
int v = g[x][i].v;
if (v == fa) continue;
dis[v] = dis[x] + g[x][i].w;
u[g[x][i].id] = id;
id++;
if (ot[x] == -1) ot[x] = g[x][i].id;
inn[v] = g[x][i].id;
dfs(v, x, deep + 1);
d[g[x][i].id] = id;
id++;
}
}
int p[100002][30];
void Init_LCA() {
int i, j;
for (j = 0; (1 << j) <= n; ++j)
for (i = 1; i <= n; ++i) p[i][j] = -1;
for (i = 1; i <= n; ++i) p[i][0] = father[i];
for (j = 1; (1 << j) <= n; ++j)
for (int i = 1; i <= n; ++i)
if (p[i][j - 1] != -1) p[i][j] = p[p[i][j - 1]][j - 1];
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int i, lg;
for (lg = 0; (1 << lg) <= dep[x]; ++lg)
;
--lg;
for (i = lg; i >= 0; --i)
if (dep[x] - (1 << i) >= dep[y]) x = p[x][i];
if (x == y) return x;
for (i = lg; i >= 0; --i)
if (p[x][i] != -1 && p[x][i] != p[y][i]) x = p[x][i], y = p[y][i];
return father[x];
}
int num[200002 * 4], col[200002 * 4];
void pushdown(int t) {
if (col[t]) {
num[(t << 1)] += col[t];
num[(t << 1 | 1)] += col[t];
col[(t << 1)] += col[t];
col[(t << 1 | 1)] += col[t];
col[t] = 0;
}
}
void update(int ll, int rr, int t, int l, int r, int z) {
if (l != r) pushdown(t);
if (ll <= l && r <= rr) {
col[t] += z;
num[t] += z;
return;
}
int m = (l + r) / 2;
if (ll <= m) update(ll, rr, (t << 1), l, m, z);
if (rr > m) update(ll, rr, (t << 1 | 1), m + 1, r, z);
}
int query(int p, int t, int l, int r) {
if (l != r) pushdown(t);
if (p == l && p == r) {
return num[t];
}
int m = (l + r) / 2;
if (p <= m) return query(p, (t << 1), l, m);
if (p > m) return query(p, (t << 1 | 1), m + 1, r);
}
int main() {
while (scanf("%d", &n) != EOF) {
int i;
for (i = 1; i <= n; i++) g[i].clear();
for (i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(Node(b, 1, i));
g[b].push_back(Node(a, 1, i));
}
memset(num, 0, sizeof(num));
memset(col, 0, sizeof(col));
memset(inn, -1, sizeof(inn));
memset(ot, -1, sizeof(ot));
id = 1;
dis[1] = 0;
dfs(1, -1, 0);
Init_LCA();
int k;
scanf("%d", &k);
while (k--) {
int a, b;
scanf("%d%d", &a, &b);
if (a == b) continue;
int lca = LCA(a, b);
if (inn[a] != -1) update(u[ot[lca]], u[inn[a]], 1, 1, id - 1, 1);
if (inn[b] != -1) update(u[ot[lca]], u[inn[b]], 1, 1, id - 1, 1);
}
for (i = 1; i < n; i++) {
int s1 = query(u[i], 1, 1, id - 1);
int s2 = query(d[i], 1, 1, id - 1);
if (i != 1) printf(" ");
printf("%d", s1 - s2);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n + 1], mx = 0, in;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (mx < a[i]) {
in = i;
mx = a[i];
}
}
sort(a + 1, a + n + 1);
cout << in << " " << a[n - 1];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1000 * 10 + 100;
const int INF = 1000 * 1000 * 10;
string q[110];
int r[110][MAXM];
int l[110][MAXM];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> q[i];
for (int i = 0; i < n; i++) {
r[i][m - 1] = l[i][0] = INF;
if (q[i][m - 1] == '1')
r[i][m - 1] = 0;
else
for (int j = 0; j < m; j++)
if (q[i][j] == '1') {
r[i][m - 1] = j + 1;
break;
}
if (q[i][0] == '1')
l[i][0] = 0;
else
for (int j = m - 1; j >= 0; j--)
if (q[i][j] == '1') {
l[i][0] = (m - j);
break;
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j < m; j++)
if (q[i][j] == '1')
l[i][j] = 0;
else
l[i][j] = l[i][j - 1] + 1;
for (int j = m - 2; j >= 0; j--)
if (q[i][j] == '1')
r[i][j] = 0;
else
r[i][j] = r[i][j + 1] + 1;
}
long long ans = INF;
long long sum = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
sum = 0;
for (int a = 0; a < n; a++) sum += min(r[a][j], l[a][j]);
ans = min(ans, sum);
}
bool ok = true;
for (int i = 0; i < n; i++) {
bool c = false;
for (int j = 0; j < m; j++)
if (q[i][j] == '1') c = true;
ok = c;
if (!ok) break;
}
if (ok)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k = 0, l = 0, r = 0, m = 0, n, x, y, z, a, b, p = 0,
cnt = 0, cnt1 = 0, low, mid, high, ans = 0, c = 0,
maxi = -1, mini = INF, t, q, ind;
string s, s1;
cin >> n;
vector<pair<long long int, long long int> > A;
for (i = 0; i < n; i++) {
cin >> x;
A.push_back({x, i});
}
sort(A.begin(), A.end());
long long int L[n];
long long int R[n];
for (i = 0; i < n; i++) {
L[i] = -1;
R[i] = -1;
}
for (i = 0; i < n; i++) {
k = A[i].second;
l = k;
r = k;
if (k != 0 && L[k - 1] != -1) {
c--;
l = L[k - 1];
}
if (R[k + 1] != -1 && k != n - 1) {
c--;
r = R[k + 1];
}
c++;
L[r] = l;
R[l] = r;
if (r - l + 1 > maxi) {
maxi = r - l + 1;
cnt1 = 0;
}
if (r - l + 1 == maxi) cnt1++;
if (c == cnt1 && c > m) {
m = c;
ans = A[i].first + 1;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long int> v;
long long int n, k, s, pos, i;
cin >> n >> k >> s;
if (s < k) {
cout << "NO" << endl;
return 0;
}
pos = 1;
while (k > 0) {
if (s - k + 1 >= n - 1) {
if (pos == 1) {
pos = n;
v.push_back(pos);
k--;
s -= n - 1;
} else {
pos = 1;
v.push_back(pos);
k--;
s -= (n - 1);
}
} else {
if (pos == 1) {
pos = 1 + s - k + 1;
v.push_back(pos);
s -= (s - k + 1);
k--;
} else {
pos = n - (s - k + 1);
v.push_back(pos);
s -= (s - k + 1);
k--;
}
break;
}
}
if (s == k) {
while (k > 0) {
if (pos == 1) {
s--;
pos++;
v.push_back(pos);
} else {
s--;
pos--;
v.push_back(pos);
}
k--;
}
}
if (s != 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, d, m, sum = 0;
cin >> n >> d;
long long int ara[n];
for (i = 0; i < n; i++) {
cin >> ara[i];
sum = sum + ara[i];
}
cin >> m;
if (m == n) {
cout << sum << endl;
} else if (m > n) {
sum = sum - (m - n) * d;
cout << sum << endl;
} else {
sort(ara, ara + n);
sum = 0;
for (i = 0; i <= (m - 1); i++) {
sum = sum + ara[i];
}
cout << sum << endl;
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.