solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF =
(is_same<long long, long long>::value ? 1e18 + 666 : 1e9 + 666);
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <class t1, class t2>
bool cmin(t1 &a, const t2 &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class t1, class t2>
bool cmax(t1 &a, const t2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
long long bpow(long long a, long long b, long long mod) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
}
return res;
}
void UseFiles(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
void run();
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
run();
}
struct HashStr {
const long long p, mod;
vector<long long> pw, hs;
HashStr(long long _p, long long _mod, const string &s)
: p(_p),
mod(_mod),
pw(((long long)(s).size()) + 1),
hs(((long long)(s).size()) + 1) {
long long n = ((long long)(s).size());
pw[0] = 1;
for (long long i = 0; i < n; ++i) {
pw[i + 1] = pw[i] * p % mod;
}
hs[0] = 0;
for (long long i = 0; i < n; ++i) {
hs[i + 1] = (hs[i] * p + (s[i] - 'a' + 1)) % mod;
}
}
long long get_sub(long long l, long long r) {
long long res = hs[l] * pw[r - l] % mod;
res = hs[r] - res;
if (res < 0) res += mod;
return res;
}
};
const long long p = 29, mod = 1e9 + 9;
struct Fenv {
vector<long long> tree;
static long long f(long long i) { return i & -i; }
Fenv(long long n) : tree(++n, 0) {}
long long get(long long idx) const {
++idx;
long long sm = 0;
for (; idx > 0; idx -= f(idx)) {
sm += tree[idx];
}
return sm;
}
void add(long long idx, long long val) {
++idx;
for (; idx < ((long long)(tree).size()); idx += f(idx)) {
tree[idx] += val;
}
}
};
void run() {
long long n, m;
cin >> n >> m;
string s1, s2, t;
cin >> s1 >> s2 >> t;
vector<long long> comm_pref(n), comm_suff(n);
HashStr S1(p, mod, s1), S2(p, mod, s2), T(p, mod, t);
for (long long i = 0; i < n; ++i) {
long long l = 0, r = min(m, n - i + 1);
while (r - l > 1) {
long long c = (r + l) >> 1;
if (S1.get_sub(i, i + c) == T.get_sub(0, c)) {
l = c;
} else {
r = c;
}
}
comm_pref[i] = l;
l = 0, r = min(i + 2, m);
while (r - l > 1) {
long long c = (r + l) >> 1;
if (S2.get_sub(i + 1 - c, i + 1) == T.get_sub(m - c, m)) {
l = c;
} else {
r = c;
}
}
comm_suff[i] = l;
}
long long ans = 0;
Fenv sm(m), cnt(m);
for (long long i = n - 1; i > -1; --i) {
sm.add(comm_suff[i], comm_suff[i] - m + 1);
cnt.add(comm_suff[i], 1);
ans += sm.get(m - 1) - sm.get(m - comm_pref[i] - 1);
ans += (cnt.get(m - 1) - cnt.get(m - comm_pref[i] - 1)) * comm_pref[i];
if (i + m - 2 < n) {
sm.add(comm_suff[i + m - 2], -(comm_suff[i + m - 2] - m + 1));
cnt.add(comm_suff[i + m - 2], -1);
}
}
cout << ans << endl;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
vector<LL> p;
const LL inf = 2e18;
int main() {
for (LL i = 2; i <= 1000000; i++) {
LL x = i * i * i;
while (x < inf) {
LL sqrtx = sqrt(x);
while (sqrtx * sqrtx < x) sqrtx++;
if (sqrtx * sqrtx != x) p.emplace_back(x);
if (x > inf / i) break;
x *= i;
}
}
sort(begin(p), end(p));
p.erase(unique(begin(p), end(p)), end(p));
int q;
scanf("%d", &q);
while (q--) {
LL L, R;
scanf("%lld %lld", &L, &R);
auto u = upper_bound(begin(p), end(p), R);
auto l = lower_bound(begin(p), end(p), L);
LL res = u - l;
LL z = sqrt(R + 0.5);
while (z * z <= R) z++;
z--;
LL y = sqrt(L);
while (y * y >= L) y--;
res += z - y;
printf("%lld\n", res);
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
queue<long long int> q;
long long int n, b, t[600000], d[600000], f = 0, p = 0, a[600000], k = 0;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> b;
for (int i = 1; i <= n; i++) {
cin >> t[i] >> d[i];
if (f == 1) {
while (!q.empty() && p <= t[i]) {
p = q.front();
q.pop();
}
if (q.size() < b) {
k += d[i];
t[i] += d[i];
k = max(k, t[i]);
a[i] = k;
q.push(k);
} else
a[i] = -1;
} else {
f = 1;
k = 0;
a[i] = t[i] + d[i];
p = a[i];
k = a[i];
}
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 20;
long long n, d[2 * Maxn][Maxn], tvn[Maxn];
bool par[2 * Maxn][Maxn];
string s, ans;
void pp(int i, int j) {
if (i == 0) return;
if (par[i][j]) {
ans += 'H';
pp(i - 1, j - 1);
} else {
ans += 'M';
pp(i - 1, j);
}
}
int main() {
cin >> n >> s;
tvn[0] = 1;
for (int i = 1; i < n; i++) tvn[i] = tvn[i - 1] * 10;
for (int i = 0; i <= 2 * n; i++)
for (int j = 0; j <= n; j++) d[i][j] = -1;
d[1][1] = (s[0] - '0') * tvn[n - 1];
par[1][1] = 1;
for (int i = 2; i <= 2 * n; i++) {
for (int j = 1; j <= min(i, 18); j++) {
if (d[i - 1][j - 1] + (s[i - 1] - '0') * tvn[n - j] != -1 &&
d[i - 1][j - 1] + (s[i - 1] - '0') * tvn[n - j] >
d[i - 1][j] + (s[i - 1] - '0') * tvn[n - (i - j)]) {
d[i][j] = d[i - 1][j - 1] + (s[i - 1] - '0') * tvn[n - j];
par[i][j] = 1;
} else {
d[i][j] = d[i - 1][j] + (s[i - 1] - '0') * tvn[n - (i - j)];
}
}
}
pp(2 * n, n);
reverse(ans.begin(), ans.end());
cout << ans << endl;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long sz = 1e5 + 4;
int n, r, g, b;
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < (int)s.length(); i++) {
if (s[i] == 'R')
r++;
else if (s[i] == 'G')
g++;
else if (s[i] == 'B')
b++;
}
if ((r and g and b) or (r > 1 and g > 1) or (g > 1 and b > 1) or
(r > 1 and b > 1)) {
cout << "BGR" << '\n';
} else if (r == 0) {
if (g > 1 and b == 1) {
cout << "BR";
} else if (g == 1 and b > 1) {
cout << "GR";
} else if (g == 1 and b == 1) {
cout << "R";
} else if (g >= 1 and b == 0) {
cout << "G";
} else if (b >= 1 and g == 0) {
cout << "B";
}
} else if (b == 0) {
if (g > 1 and r == 1) {
cout << "BR";
} else if (g == 1 and r > 1) {
cout << "BG";
} else if (g == 1 and r == 1) {
cout << "B";
} else if (r >= 1 and g == 0) {
cout << "R";
}
} else if (g == 0) {
if (r > 1 and b == 1) {
cout << "BG";
} else if (r == 1 and b > 1) {
cout << "GR";
} else if (r == 1 and b == 1) {
cout << "G";
}
}
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
char s[100001];
int cnt[3][100001], len, m, l, r;
int main() {
while (scanf("%s", s) == 1) {
len = strlen(s);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < len; i++) cnt[s[i] - 'x'][i + 1] = 1;
for (int i = 1; i <= len; i++) {
cnt[0][i] += cnt[0][i - 1];
cnt[1][i] += cnt[1][i - 1];
cnt[2][i] += cnt[2][i - 1];
}
scanf("%d", &m);
while (m--) {
scanf("%d %d", &l, &r);
int x = cnt[0][r] - cnt[0][l - 1], y = cnt[1][r] - cnt[1][l - 1],
z = cnt[2][r] - cnt[2][l - 1];
int MIN = min(x, min(y, z));
x -= MIN, y -= MIN, z -= MIN;
if (r - l < 2)
printf("YES\n");
else {
if (x == y && x == z && y == z)
printf("YES\n");
else if (x > 1 || y > 1 || z > 1)
printf("NO\n");
else
printf("YES\n");
}
}
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long int a, b, m, n, sum = 0, c = 0;
scanf("%lld %lld %lld", &a, &b, &m);
vector<long long int> arr;
if (a == b) {
printf("1 %lld\n", b);
continue;
}
if (a + m >= b) {
printf("2 %lld %lld\n", a, b);
continue;
}
while (b > a) {
arr.push_back(b);
n = b;
if (b % 2) c++;
b = b / 2;
if (c % 2) b += n % 2;
}
if (n - a > m)
printf("-1\n");
else {
arr.push_back(a);
auto it = arr.end() - 1;
sum += (*it);
while (1) {
if (it == arr.begin()) break;
it--;
if ((*it) - sum > m) {
printf("-1");
sum = 0;
break;
}
if ((*it) - sum == 0) {
while (it < arr.end() - 1) {
if ((*(it + 2)) + m >= (*it)) {
sum -= (*(it + 1));
arr.erase(it + 1);
break;
}
it++;
}
if (it == arr.end() - 1) {
printf("-1");
sum = 0;
break;
}
}
sum += (*it);
}
if (sum) {
it = arr.end() - 1;
printf("%lld ", (long long int)arr.size());
while (1) {
printf("%lld ", (*it));
if (it == arr.begin()) break;
it--;
}
}
printf("\n");
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e7 + 5;
long long n, k;
long long a[1000005];
long long cnt[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (long long(i) = (1); (i) <= (n); ++(i)) {
cin >> a[i];
cnt[a[i]]++;
}
long long maxVal = 1e7;
long long ans = n;
while (ans < k && maxVal > 1) {
if (cnt[maxVal]) {
ans += cnt[maxVal];
cnt[maxVal / 2] += cnt[maxVal];
cnt[(maxVal + 1) / 2] += cnt[maxVal];
}
maxVal--;
}
if (ans < k)
cout << -1;
else {
long long minVal = 0;
while (ans >= k) {
if (ans - cnt[minVal] >= k) {
ans -= cnt[minVal++];
} else {
cnt[minVal] -= (ans - k);
break;
}
}
while (maxVal >= 2 * minVal) {
while (!cnt[minVal]) minVal++;
cnt[maxVal / 2] += cnt[maxVal];
cnt[(maxVal + 1) / 2] += cnt[maxVal];
long long delete_num = cnt[maxVal--];
while (cnt[minVal] <= delete_num && delete_num)
delete_num -= cnt[minVal++];
cnt[minVal] -= delete_num;
}
cout << minVal;
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int C = 100001;
vector<vector<int> > tab(C);
vector<vector<long long> > xx(C);
int ij[C], a, b, n, r;
long long f[C], g[C], summ[C];
vector<long long> pom(C);
void Sebasort(vector<long long>& tab, int l, int r) {
if (l > r) return;
int lim = 2, limi = l + 1, limj = l + 2, j = limi, i = l, k = l;
while (lim / 2 <= r - l + 1) {
while (i <= r) {
if (limj > r) limj = r + 1;
if ((tab[j] < tab[i] && j < limj) || i >= limi)
pom[k] = tab[j], j++;
else
pom[k] = tab[i], i++;
k++;
if (i == limi && j == limj) limi += lim, limj += lim, i = j, j = limi;
}
for (i = l; i <= r; i++) tab[i] = pom[i];
lim *= 2, limi = l + lim / 2, limj = l + lim, j = limi, i = k = l;
}
}
int s[C], is = 0, son[C], par[C], ji[C];
void proc_tree(int a, int n) {
s[0] = a, is = 1;
int b;
for (int z = 1; z <= n; z++) ji[z] = ij[z];
while (is > 0) {
a = s[is - 1];
if (ji[a] > 0 && tab[a][ji[a] - 1] == par[a]) ji[a]--;
if (ji[a] > 0)
b = s[is] = tab[a][ji[a] - 1], par[b] = a, is++, ji[a]--;
else {
son[a]++, son[par[a]] += 1;
Sebasort(xx[a], 0, son[a] - 2);
for (int z = son[a] - 2; z >= 0; z--)
if (g[a] > 1 || (g[a] > 0 && a == r)) g[a]--, f[a] += xx[a][z] + 2;
if (summ[a] >= g[a])
f[a] = f[a] + 2 * g[a] - 2, summ[a] = summ[a] - g[a] + 1, g[a] = 1;
else if (summ[a] < g[a])
f[a] = f[a] + 2 * summ[a], g[a] = g[a] - summ[a], summ[a] = 0;
if (a == r && g[a] == 1 && summ[a] > 0) g[a] = 0, f[a] += 2;
xx[par[a]].push_back(f[a]);
summ[par[a]] += g[a] - 1;
is--;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &g[i]);
for (int z = 1; z < n; z++)
scanf("%d %d", &a, &b), tab[a].push_back(b), tab[b].push_back(a), ij[a]++,
ij[b]++;
scanf("%d", &r);
proc_tree(r, n);
printf("%I64d", f[r]);
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int inf = 2e9;
vector<pair<int, int>> mp[maxn];
int Mx[maxn], My[maxn];
int dx[maxn], dy[maxn];
int dis, mid;
int Nx, Ny;
bool vis[maxn];
bool SearchP() {
queue<int> Q;
dis = inf;
memset(dx, -1, sizeof(dx));
memset(dy, -1, sizeof(dy));
for (int i = 1; i <= Nx; i++)
if (Mx[i] == -1) {
Q.push(i);
dx[i] = 0;
}
while (!Q.empty()) {
int x = Q.front();
Q.pop();
if (dx[x] > dis) break;
for (int i = 0; i < mp[x].size(); i++) {
int y = mp[x][i].first;
if (mp[x][i].second > mid) continue;
if (dy[y] == -1) {
dy[y] = dx[x] + 1;
if (My[y] == -1)
dis = dy[y];
else {
dx[My[y]] = dy[y] + 1;
Q.push(My[y]);
}
}
}
}
return dis != inf;
}
bool DFS(int x) {
for (int i = 0; i < mp[x].size(); i++) {
int y = mp[x][i].first;
if (mp[x][i].second > mid) continue;
if (!vis[y] && dy[y] == dx[x] + 1) {
vis[y] = true;
if (My[y] != -1 && dy[y] == dis) continue;
if (My[y] == -1 || DFS(My[y])) {
My[y] = x;
Mx[x] = y;
return true;
}
}
}
return false;
}
int MaxMatch() {
int res = 0;
memset(Mx, -1, sizeof(Mx));
memset(My, -1, sizeof(My));
while (SearchP()) {
memset(vis, false, sizeof(vis));
for (int i = 1; i <= Nx; i++)
if (Mx[i] == -1 && DFS(i)) res++;
}
return res;
}
int main() {
int n, m, Max = 1;
cin >> n >> m;
for (int i = 1, x, y, z; i <= m; i++) {
cin >> x >> y >> z;
mp[x].push_back({y, z});
Max = max(Max, z);
}
Nx = Ny = n;
int l = 1, r = Max, ans = -1;
while (l <= r) {
mid = l + r >> 1;
if (MaxMatch() == n)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<vector<long long>> lb(n, vector<long long>(m)),
rb(n, vector<long long>(m)), dp(m, vector<long long>(m));
for (long long i = 0; i < n; ++i) {
long long k;
cin >> k;
while (k--) {
long long l, r;
cin >> l >> r;
--l, --r;
for (long long j = l; j <= r; ++j) {
lb[i][j] = l;
rb[i][j] = r;
}
}
}
long long t = dp[0][m - 1];
do {
t = dp[0][m - 1];
for (long long i = 0; i < m; ++i) {
for (long long j = i; j < m; ++j) {
for (long long k = i; k <= j; ++k) {
long long cnt = 0;
for (long long it = 0; it < n; ++it) {
if (i <= lb[it][k] && rb[it][k] <= j) ++cnt;
}
dp[i][j] =
max(dp[i][j], (k > 0 ? dp[i][k - 1] : 0) +
(k < m - 1 ? dp[k + 1][j] : 0) + cnt * cnt);
}
}
}
} while (t != dp[0][m - 1]);
cout << dp[0][m - 1];
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int cost[200005], n, nrfii[200005], par[200005], snr[200005], impar[200005],
nivel[200005], poz[200005], prfiu[200005], suma[200005];
struct nr {
int val, p;
};
nr aint1[3 * 200005], aint2[3 * 200005];
bool viz[200005];
vector<int> L[200005];
inline void Dfs(int nod, int niv) {
viz[nod] = true;
nivel[nod] = niv;
if (niv & 1) {
impar[++impar[0]] = nod;
poz[nod] = impar[0];
} else {
par[++par[0]] = nod;
poz[nod] = par[0];
}
vector<int>::iterator it;
for (it = L[nod].begin(); it != L[nod].end(); ++it)
if (!viz[*it]) {
if (!prfiu[nod]) prfiu[nod] = *it;
Dfs(*it, niv + 1);
snr[nod] += nrfii[*it];
nrfii[nod] += L[*it].size() + snr[*it] - 1;
suma[nod] += nrfii[*it];
}
}
inline void Update(nr aint[], int nod, int st, int dr, int x, int y, int val) {
if (st == x && y == dr) {
aint[nod].val += (dr - st + 1) * val;
aint[nod].p += val;
return;
}
int mij = (st + dr) / 2;
aint[2 * nod].val += aint[nod].p * (mij - st + 1);
aint[2 * nod + 1].val += aint[nod].p * (dr - mij);
aint[2 * nod].p += aint[nod].p;
aint[2 * nod + 1].p += aint[nod].p;
aint[nod].p = 0;
if (y <= mij)
Update(aint, 2 * nod, st, mij, x, y, val);
else if (x > mij)
Update(aint, 2 * nod + 1, mij + 1, dr, x, y, val);
else {
Update(aint, 2 * nod, st, mij, x, mij, val);
Update(aint, 2 * nod + 1, mij + 1, dr, mij + 1, y, val);
}
}
inline int Query(nr aint[], int nod, int st, int dr, int poz) {
if (st == dr) return aint[nod].val;
int mij = (st + dr) / 2;
aint[2 * nod].val += aint[nod].p * (mij - st + 1);
aint[2 * nod + 1].val += aint[nod].p * (dr - mij);
aint[2 * nod].p += aint[nod].p;
aint[2 * nod + 1].p += aint[nod].p;
aint[nod].p = 0;
if (poz <= mij)
return Query(aint, 2 * nod, st, mij, poz);
else
return Query(aint, 2 * nod + 1, mij + 1, dr, poz);
}
int main() {
int m, x, y, i, tip, k;
std::ios_base::sync_with_stdio(false);
cin >> n >> m;
for (i = 1; i <= n; ++i) cin >> cost[i];
for (i = 1; i < n; ++i) {
cin >> x >> y;
L[x].push_back(y);
L[y].push_back(x);
}
Dfs(1, 1);
for (i = 1; i <= n; ++i)
if (nivel[i] & 1)
Update(aint1, 1, 1, impar[0], poz[i], poz[i], cost[i]);
else
Update(aint2, 1, 1, par[0], poz[i], poz[i], cost[i]);
while (m--) {
cin >> tip >> x;
if (tip == 1) {
cin >> y;
if (nivel[x] & 1) {
Update(aint1, 1, 1, impar[0], poz[x], poz[x] + nrfii[x], y);
if (prfiu[x]) {
k = poz[prfiu[x]] + L[x].size() + suma[x] - 2;
if (x == 1) ++k;
Update(aint2, 1, 1, par[0], poz[prfiu[x]], k, -y);
}
} else {
Update(aint2, 1, 1, par[0], poz[x], poz[x] + nrfii[x], y);
if (prfiu[x]) {
k = poz[prfiu[x]] + L[x].size() + suma[x] - 2;
if (x == 1) ++k;
Update(aint1, 1, 1, impar[0], poz[prfiu[x]], k, -y);
}
}
} else {
if (nivel[x] & 1)
cout << Query(aint1, 1, 1, impar[0], poz[x]) << "\n";
else
cout << Query(aint2, 1, 1, par[0], poz[x]) << "\n";
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
set<string> s;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string ss;
cin >> ss;
s.insert(ss);
}
int b = 0;
for (int i = 0; i < m; i++) {
string ss;
cin >> ss;
if (s.count(ss)) b++;
}
if (b & 1) n++;
if (n > m)
cout << "YES";
else
cout << "NO";
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long n, L, a, l, t, lbuf, sum;
int main() {
lbuf = 0;
sum = 0;
cin >> n >> L >> a;
for (long i = 0; i < n; i++) {
cin >> t >> l;
l += t;
sum += (t - lbuf) / a;
lbuf = l;
}
sum += (L - l) / a;
cout << sum;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int t;
string S;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
int c0, c1, ans;
while (t--) {
cin >> S;
c0 = c1 = 0;
for (int i = (0); i < (int(S.size())); ++i) {
if (S[i] == '1')
++c1;
else
++c0;
ans = min(c0, c1);
}
if (ans & 1)
cout << "DA" << '\n';
else
cout << "NET" << '\n';
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 0, i, j = 0, s = 0, t = 0, a[200001], b[200001];
double aver;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
s = s + a[i];
}
aver = s * 1.0 / n;
for (i = 0; i < n; i++) {
if (a[i] == aver) {
j = 1;
t++;
b[m++] = i + 1;
}
}
if (j) {
printf("%d\n", t);
for (i = 0; i < t; i++) printf("%d ", b[i]);
printf("\n");
} else
printf("0\n");
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool rd(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void pt(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) pt(x / 10);
putchar(x % 10 + '0');
}
const int N = 100005;
int n, m;
vector<int> X[1005], Y[1005];
bool cho[1005], chy[1005];
int main() {
rd(n);
rd(m);
while (m--) {
int x, y;
rd(x);
rd(y);
X[x].push_back(y);
Y[y].push_back(x);
}
int ans = 0;
for (int x = 2; x < n; x++) {
if (X[x].size()) continue;
ans++;
cho[x] = true;
}
for (int y = 2; y < n; y++) {
if (Y[y].size()) continue;
ans++;
chy[y] = true;
}
if (n & 1 && cho[(n + 1) >> 1] && chy[(n + 1) >> 1]) ans--;
pt(ans);
return 0;
}
| 10
|
#include <bits/stdc++.h>
int main() {
int w, m;
scanf("%d %d", &w, &m);
if (w <= 3) {
printf("YES\n");
} else {
while (m != 0) {
if (m % w != (w - 1) && m % w != 0 && m % w != 1) {
printf("NO\n");
return 0;
}
m = (m + 1) / w;
}
printf("YES\n");
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1, typename... Tail>
T amin(T& a, T1 b, Tail... c) {
if (b < a) a = b;
if constexpr (sizeof...(c) != 0) {
amin(a, c...);
}
return a;
}
template <typename T, typename T1, typename... Tail>
T amax(T& a, T1 b, Tail... c) {
if (b > a) a = b;
if constexpr (sizeof...(c) != 0) {
amax(a, c...);
}
return a;
}
void preSolve(int& testcases) {}
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= i;
b[i] = a[i];
}
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
int m = b.size();
vector<int64_t> dp(m, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[j] += abs(a[i] - b[j]);
if (j > 0) {
amin(dp[j], dp[j - 1]);
}
}
}
cout << *min_element(dp.begin(), dp.end());
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int testcases = 1;
preSolve(testcases);
for (int caseno = 1; caseno <= testcases; ++caseno) {
solve();
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> b >> a;
int k = 0;
c = a + b;
long long d = 0, m;
m = sqrt(c) + 1;
d = b - a;
for (long long i = 2; i <= m; i++) {
if (c % i == 0) {
k = 1;
break;
}
}
if (k == 0 && d <= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
k = 0;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 200005;
const double PI = acos(-1);
int i, n, x, y, pref[N];
vector<long long> a, b, c;
inline int getRev(int x, int lg) {
int ans = 0;
for (int i = 0; i < lg; ++i)
if (x & (1 << i)) ans |= (1 << (lg - i - 1));
return ans;
}
void fft(vector<complex<long double> > &a, bool inv) {
int lg = 1, sz = a.size();
while ((1 << lg) < sz) ++lg;
for (int i = 0; i < sz; ++i)
if (i < getRev(i, lg)) swap(a[i], a[getRev(i, lg)]);
for (int len = 2; len <= sz; len <<= 1) {
double ang = (inv ? -2 : 2) * PI / len;
complex<long double> wlen(cos(ang), sin(ang));
for (int i = 0; i < sz; i += len) {
complex<long double> w(1, 0);
for (int j = 0; j < len / 2; ++j) {
complex<long double> u = a[i + j], v = w * a[i + len / 2 + j];
a[i + j] = u + v;
a[i + len / 2 + j] = u - v;
w *= wlen;
}
}
}
if (inv)
for (int i = 0; i < sz; ++i) a[i] /= sz;
}
void conv(vector<long long> &a, vector<long long> &b, vector<long long> &c) {
vector<complex<long double> > na(a.begin(), a.end());
vector<complex<long double> > nb(b.begin(), b.end());
vector<complex<long double> > nc;
int sz = 2 * max(a.size(), b.size()), lg = 1;
while ((1 << lg) < sz) ++lg;
sz = (1 << lg);
na.resize(sz);
nb.resize(sz);
nc.resize(sz);
fft(na, 0);
fft(nb, 0);
for (int i = 0; i < nc.size(); ++i) nc[i] = na[i] * nb[i];
fft(nc, 1);
c.resize(a.size() + b.size() - 1);
for (int i = 0; i < c.size(); ++i) c[i] = nc[i].real() + 0.5;
}
int main() {
scanf("%d %d", &n, &x);
a.resize(n + 1);
b.resize(n + 1);
for (i = 1; i <= n; ++i) {
scanf("%d", &y);
pref[i] = pref[i - 1] + (y < x);
++a[pref[i]];
++b[n - pref[i]];
}
++a[0];
++b[n];
conv(a, b, c);
for (i = 1; i <= n; ++i) c[i] = c[n + i];
for (i = 1, c[0] = 0; i <= n; ++i) {
if (pref[i] - pref[i - 1]) continue;
int st = 0, dr = i, pz = i - 1;
while (st <= dr) {
int pivot = (st + dr) / 2;
if (pref[pivot] == pref[i])
pz = pivot, dr = pivot - 1;
else
st = pivot + 1;
}
c[0] += i - pz;
}
for (i = 0; i <= n; ++i) printf("%lld%c", c[i], " \n"[i == n]);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int k1, k2, n;
cin >> n >> k1 >> k2;
std::vector<int> v1(k1), v2(k2);
for (int i = 0; i < k1; i++) cin >> v1[i];
for (int i = 0; i < k2; i++) cin >> v2[i];
while (!v1.empty() && !v2.empty()) {
sort(begin(v1), end(v1));
sort(begin(v2), end(v2));
if (v1.back() > v2.back()) {
v1.push_back(v2.back());
v2.pop_back();
} else {
v2.push_back(v1.back());
v1.pop_back();
}
}
if (v1.empty())
cout << "No\n";
else
cout << "Yes\n";
}
int main() {
ios::sync_with_stdio(false);
int q = 1;
cin >> q;
for (long long i = 1; i <= q; i++) {
solve();
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, q = 0, w = 0;
string a, b;
char x, y;
cin >> a >> b;
int k = a.length();
if (a == b) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < k; i++) {
if (a[i] == b[i]) continue;
if (a[i] == '4' && b[i] == '7')
q++;
else if (a[i] == '7' && b[i] == '4')
w++;
}
if (q > w)
n = q;
else if (w > q)
n = w;
else if (w == q)
n = q;
cout << n << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
set<int> st;
int n, x;
bool isPrime[2000010];
int prime[2000010], np;
int main() {
while (scanf("%d%d", &n, &x) != EOF) {
st.clear();
bool flag = false;
for (int i = 0; i < n; i++) {
int val;
scanf("%d", &val);
if (val == 1) flag = true;
st.insert(val);
}
memset(isPrime, 1, sizeof(isPrime));
int cnt = 0;
np = 0;
if (x == 2) {
printf("0\n");
continue;
}
if (flag == true) {
printf("1\n");
continue;
}
if (x > 20 * n && n > 0) {
printf("-1\n");
continue;
}
for (int i = 2; i < x; i++) {
if (isPrime[i]) {
prime[np++] = i;
cnt++;
if (!st.count(i)) {
cnt = -1;
break;
}
}
for (int j = 0; j < np && i * prime[j] < x; j++) {
isPrime[i * prime[j]] = false;
if (i % prime[j] == 0) break;
}
}
printf("%d\n", cnt);
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int n, a[2002][2002], u[2002][2002], cnt1, cnt2, cnt;
pair<int, int> Maxx, Maxy, Minx, Miny;
inline void dfs(int i, int j) {
u[i][j] = true;
Minx = min(Minx, make_pair(i, j));
Maxx = max(Maxx, make_pair(i, j));
Miny = min(Miny, make_pair(j, i));
Maxy = max(Maxy, make_pair(j, i));
if (i > 1 && !u[i - 1][j] && a[i - 1][j]) dfs(i - 1, j);
if (i < n && !u[i + 1][j] && a[i + 1][j]) dfs(i + 1, j);
if (j > 1 && !u[i][j - 1] && a[i][j - 1]) dfs(i, j - 1);
if (j < n && !u[i][j + 1] && a[i][j + 1]) dfs(i, j + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (a[i][j] && !u[i][j]) {
Miny = make_pair(1e9, 1e9);
Minx = Miny;
Maxy = make_pair(0, 0);
Maxx = Maxy;
dfs(i, j);
if (Minx.first == Miny.second && Miny.first == Minx.second &&
Maxx.first == Maxy.second && Maxx.second == Maxy.first)
cnt2++;
else
cnt1++;
}
}
}
printf("%d %d", cnt1, cnt2);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
string dabiao[] = {
"0\n.\n",
"0\n..\n",
"0\n...\n",
"0\n....\n",
"0\n.....\n",
"0\n......\n",
"0\n.......\n",
"0\n........\n",
"0\n.........\n",
"0\n.\n.\n",
"0\n..\n..\n",
"0\n...\n...\n",
"0\n....\n....\n",
"0\n.....\n.....\n",
"0\n......\n......\n",
"0\n.......\n.......\n",
"0\n........\n........\n",
"0\n.........\n.........\n",
"0\n.\n.\n.\n",
"0\n..\n..\n..\n",
"1\nAAA\n.A.\n.A.\n",
"1\nAAA.\n.A..\n.A..\n",
"2\nAAA.B\n.ABBB\n.A..B\n",
"2\nAAABBB\n.A..B.\n.A..B.\n",
"3\nAAACBBB\n.A.C.B.\n.ACCCB.\n",
"3\nAAABBB.C\n.A..BCCC\n.A..B..C\n",
"4\nAAADBBB.C\n.A.D.BCCC\n.ADDDB..C\n",
"0\n.\n.\n.\n.\n",
"0\n..\n..\n..\n..\n",
"1\nAAA\n.A.\n.A.\n...\n",
"2\nAAA.\n.AB.\n.AB.\n.BBB\n",
"2\nAAA..\n.ABBB\n.A.B.\n...B.\n",
"3\nAAABBB\n.AC.B.\n.AC.B.\n.CCC..\n",
"4\nAAABBB.\n.AC.BD.\n.AC.BD.\n.CCCDDD\n",
"4\nAAABBB..\n.AD.BCCC\n.AD.B.C.\n.DDD..C.\n",
"5\nAAABBBCCC\n.AD.BE.C.\n.AD.BE.C.\n.DDDEEE..\n",
"0\n.\n.\n.\n.\n.\n",
"0\n..\n..\n..\n..\n..\n",
"2\nAAA\n.A.\nBA.\nBBB\nB..\n",
"2\nAAA.\n.A..\nBA..\nBBB.\nB...\n",
"4\nAAA.B\n.ABBB\nCA.DB\nCCCD.\nC.DDD\n",
"4\nAAABBB\n.A..B.\nCA.DB.\nCCCDDD\nC..D..\n",
"5\nAAABBB.\n.A..BD.\nCA.EBD.\nCCCEDDD\nC.EEE..\n",
"6\nAAABBB.C\n.A..BCCC\nDA.EB.FC\nDDDEEEF.\nD..E.FFF\n",
"7\nAAA.BBB.D\n.ACCCBDDD\nEA.CFB.GD\nEEECFFFG.\nE...F.GGG\n",
"0\n.\n.\n.\n.\n.\n.\n",
"0\n..\n..\n..\n..\n..\n..\n",
"2\nAAA\n.A.\nBA.\nBBB\nB..\n...\n",
"3\nAAA.\n.A..\nBA..\nBBBC\nBCCC\n...C\n",
"4\nAAA..\n.ABBB\nCA.B.\nCCCBD\nC.DDD\n....D\n",
"5\nAAABBB\n.A..B.\n.AC.B.\n.ECCCD\n.ECDDD\nEEE..D\n",
"6\nAAA.BBB\n.AC..B.\n.ACCCB.\nE.CFDDD\nEEEF.D.\nE.FFFD.\n",
"7\nAAABBB..\n.AD.BCCC\n.AD.B.C.\nEDDDG.CF\nEEE.GFFF\nE..GGG.F\n",
"8\nAAABBBCCC\n.AD.B..C.\n.AD.BE.C.\nFDDDHEEEG\nFFF.HEGGG\nF..HHH..G\n",
"0\n.\n.\n.\n.\n.\n.\n.\n",
"0\n..\n..\n..\n..\n..\n..\n..\n",
"3\nAAA\n.A.\nBA.\nBBB\nB.C\nCCC\n..C\n",
"4\nAAA.\n.AB.\n.AB.\nCBBB\nCCCD\nCDDD\n...D\n",
"5\nAAA..\n.ABBB\nCA.B.\nCCCB.\nCEDDD\n.E.D.\nEEED.\n",
"6\nAAABBB\n.A..B.\nCA.DB.\nCCCDDD\nCE.DF.\n.EEEF.\n.E.FFF\n",
"8\nAAAC..B\n.A.CBBB\nDACCCEB\nDDDEEE.\nDHFFFEG\n.H.FGGG\nHHHF..G\n",
"9\nAAA.BBB.\n.ACCCBE.\n.ADC.BE.\nDDDCFEEE\nG.DIFFFH\nGGGIFHHH\nG.III..H\n",
"10\nAAA.BBB..\n.ACCCBDDD\n.AECFB.D.\nEEECFFFDG\nH.EJFIGGG\nHHHJ.IIIG\nH."
"JJJI...\n",
"0\n.\n.\n.\n.\n.\n.\n.\n.\n",
"0\n..\n..\n..\n..\n..\n..\n..\n..\n",
"3\nAAA\n.A.\nBA.\nBBB\nB..\nCCC\n.C.\n.C.\n",
"4\nAAA.\n.A..\nBA..\nBBB.\nBCCC\n.DC.\n.DC.\nDDD.\n",
"6\nAAA..\n.ABBB\nCA.B.\nCCCBD\nC.DDD\nEEEFD\n.E.F.\n.EFFF\n",
"7\nAAABBB\n.A..B.\nCA.DB.\nCCCDDD\nC.ED..\n.GEEEF\n.GEFFF\nGGG..F\n",
"9\nAAA.BBB\n.ACCCB.\nDA.CEB.\nDDDCEEE\nDFFFE.G\n.IFHGGG\n.IFHHHG\nIIIH..."
"\n",
"10\nAAABBB.C\n.A..BCCC\nDA.EB.FC\nDDDEEEF.\nD..EHFFF\nGGGJHHHI\n.G."
"JHIII\n.GJJJ..I\n",
"12\nAAA.BBB.D\n.ACCCBDDD\nEA.CFB.GD\nEEECFFFG.\nE.."
"HFIGGG\nJHHHLIIIK\nJJJHLIKKK\nJ..LLL..K\n",
"0\n.\n.\n.\n.\n.\n.\n.\n.\n.\n",
"0\n..\n..\n..\n..\n..\n..\n..\n..\n..\n",
"4\nAAA\n.A.\nBA.\nBBB\nB.C\nCCC\nD.C\nDDD\nD..\n",
"5\nAAA.\n.A..\nBA..\nBBBC\nBCCC\nD..C\nDDDE\nDEEE\n...E\n",
"7\nAAA..\n.ABBB\nCA.B.\nCCCBD\nCEDDD\n.EEED\nGEFFF\nGGGF.\nG..F.\n",
"8\nAAABBB\n.A..B.\nCA.DB.\nCCCDDD\nC.ED..\nEEEFFF\nG.EHF.\nGGGHF.\nG.HHH."
"\n",
"10\nAAABBB.\n.A..BD.\nCA.EBD.\nCCCEDDD\nCFEEE.G\n.FFFGGG\nIFHHHJG\nIIIH.J."
"\nI..HJJJ\n",
"12\nAAAC.BBB\n.ADCCCB.\n.ADCE.B.\nFDDDEEEG\nFFFHEGGG\nFHHHIIIG\nJJJHKIL."
"\n.JKKKIL.\n.J..KLLL\n",
"13\nAAABBB..C\n.A..BDCCC\nEA.GBDDDC\nEEEG.DFFF\nEHGGG.IF.\n.HHHIIIF."
"\nKHJJJMI.L\nKKKJ.MLLL\nK..JMMM.L\n"};
int main() {
int n, m;
cin >> n >> m;
cout << dabiao[9 * n + m - 10];
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
char isPrime[1000000];
void init() {
primes.reserve(1000000);
memset(isPrime, -1, sizeof(isPrime));
isPrime[0] = isPrime[1] = 0;
for (int i = 0; i * i < 1000000; i++) {
if (!isPrime[i]) continue;
for (int j = i * i; j < 1000000; j += i) isPrime[j] = 0;
}
for (int i = 0; i < 1000000; i++)
if (isPrime[i]) primes.push_back(i);
}
int backwards(int n) {
int cur = 0;
while (n) {
cur = (cur * 10 + n % 10);
n /= 10;
}
return cur;
}
int main() {
init();
int n;
cin >> n;
int count = 0, cur = 0, bn;
while (count < n) {
bn = backwards(primes[cur]);
if (bn != primes[cur++] && isPrime[bn]) count++;
}
cout << primes[cur - 1] << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[1025][505];
int dizi[505][505] = {0};
int dpf(int cor, int str, vector<int> v) {
int muttin;
if (str == (n - 1)) {
if (cor) {
printf("TAK\n");
for (int i = 0; i < v.size(); i++) {
printf("%d ", v[i] + 1);
}
exit(0);
}
return 0;
}
if (dp[cor][str] != -1) {
return dp[cor][str];
}
for (int i = 0; i < m; i++) {
v.push_back(i);
muttin = dpf((cor xor dizi[str + 1][i]), str + 1, v);
if (muttin != 0) {
dp[cor][str] = 1;
} else if (dp[cor][str] == -1) {
dp[cor][str] = 0;
}
v.pop_back();
}
return dp[cor][str];
}
vector<int> a;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &dizi[i][j]);
}
}
for (int i = 0; i < 1025; i++) {
for (int j = 0; j < 505; j++) {
dp[i][j] = -1;
}
}
for (int i = 0; i < m; i++) {
a.push_back(i);
dpf(dizi[0][i], 0, a);
a.pop_back();
}
printf("NIE\n");
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int T[] = {0, 1, 2, 9, 64, 625, 7776, 117649, 2097152};
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
long long int ans = T[k];
for (int i = (1); i <= (n - k); ++i) ans = (ans * (n - k)) % 1000000007;
cout << ans;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
long long pr = -1, sf = n;
long long count = n - 1;
for (long long i = 0; i < n; i++) {
if (arr[i] < i) break;
pr = i;
}
for (long long i = n - 1; i > -1; i--) {
if (arr[i] < n - 1 - i) break;
sf = i;
}
if (sf <= pr)
cout << "Yes"
<< "\n";
else
cout << "No"
<< "\n";
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
vector<string> answer;
void getStrings(string s, long long d) {
if (d == 0)
answer.push_back(s);
else {
getStrings(s + "4", d - 1);
getStrings(s + "7", d - 1);
}
}
int main() {
string s;
cin >> s;
for (long long i = 1; i <= s.size(); i++) getStrings("", i);
for (long long i = 0; i < answer.size(); i++)
if (s == answer[i]) {
cout << i + 1 << '\n';
return 0;
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, r;
bool b[1000001];
string s[1000001], v[1000001];
long long N;
bool f(int x) {
int I = 0;
while (s[x][I] == ' ' && s[x].size() > I) I++;
if (I >= s[x].size()) return 0;
if (s[x][I] == '#') return 1;
return 0;
}
string sh(int x) {
string S = "";
for (int I = 0; I < s[x].size(); I++)
if (s[x][I] != ' ') S += s[x][I];
return S;
}
int main() {
while (getline(cin, s[n])) {
n++;
}
if (f(0)) {
l = 1;
v[l] = s[0];
b[l] = 1;
} else {
l = 1;
v[l] = sh(i);
}
for (i = 1; i < n; i++) {
if (f(i)) {
l++;
v[l] = s[i];
b[l] = true;
} else {
if (b[l]) {
l++;
v[l] = sh(i);
} else
v[l] += sh(i);
}
}
for (i = 1; i <= l; i++) cout << v[i] << endl;
}
| 9
|
#include <bits/stdc++.h>
int arr[3000000] = {-1};
int main() {
int n, m;
scanf("%d%d", &n, &m);
int k = n + m;
if (n == m) {
for (int i = 0; i < k; i++) {
arr[i] = i % 2;
}
} else if (n > m) {
if (n == m + 1) {
for (int i = 0; i < k; i++) {
arr[i] = i % 2;
}
} else {
printf("-1");
return 0;
}
} else {
if (m <= 2 * n + 2) {
int index = 0;
for (int i = 0; i < m - n; i++) {
arr[index++] = 1;
arr[index++] = 1;
arr[index++] = 0;
}
for (int i = 0; i < 2 * n - m; i++) {
arr[index++] = 1;
arr[index++] = 0;
}
} else {
printf("-1");
return 0;
}
}
for (int i = 0; i < k; i++) {
printf("%d", arr[i]);
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200005];
long long sub[200005];
long long par[200005];
long long ans;
vector<long long> adj[200005];
long long func(long long node, long long parent) {
dp[node] = sub[node];
for (long long i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != parent) dp[node] += func(adj[node][i], node);
}
return dp[node];
}
long long dfs(long long node, long long parent) {
long long ans = 0;
par[node] = parent;
for (long long i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != parent) ans += dfs(adj[node][i], node);
}
return sub[node] = ans + 1;
}
void gg(long long node, long long parent) {
ans = max(ans, dp[node]);
for (auto c : adj[node]) {
if (c == parent) continue;
dp[node] -= dp[c];
dp[node] -= sub[c];
sub[node] -= sub[c];
sub[c] += sub[node];
dp[c] += dp[node];
dp[c] += sub[node];
gg(c, node);
dp[c] -= sub[node];
dp[c] -= dp[node];
sub[c] -= sub[node];
sub[node] += sub[c];
dp[node] += sub[c];
dp[node] += dp[c];
}
}
signed main() {
long long n, root, u, v;
cin >> n;
root = n + 2;
memset(par, -1, sizeof par);
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v;
root = min(root, min(u, v));
adj[u - 1].push_back(v - 1);
adj[v - 1].push_back(u - 1);
}
root--;
memset(dp, -1, sizeof dp);
dfs(root, -1);
func(root, -1);
ans = -1;
gg(root, -1);
cout << ans << endl;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 2e9;
const long long N = 1e6 + 2;
const long long MAX = 2e5 + 2;
const long double EPS = 1e-8;
long long f(long long x) { return x * (x + 1) / 2; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (long long i = 0; i < 4; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (min(a, b) + min(c, d) <= n) {
cout << i + 1 << " " << min(a, b) << " " << n - min(a, b);
return 0;
}
}
cout << -1;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007, mod2 = 998244353, inf = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
int a[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
string ans = "";
int l = 1, r = n, last = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (a[l] > last && a[r] > last) {
if (a[l] < a[r]) {
ans += "L";
last = a[l++];
} else {
ans += "R";
last = a[r--];
}
++cnt;
} else if (a[l] > last) {
ans += "L";
last = a[l++];
++cnt;
} else if (a[r] > last) {
ans += "R";
last = a[r--];
++cnt;
} else
break;
}
cout << cnt << '\n' << ans << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << "1 1\n";
cout << -a[0] << "\n1 1\n0\n1 1\n0\n";
return 0;
}
cout << "1 1\n" << -a[0] << "\n";
cout << "2 " << n << "\n";
for (int i = 0; i < n - 1; i++) {
cout << a[i + 1] * (n - 1);
if (i == n - 2)
cout << "\n";
else
cout << " ";
}
cout << "1 " << n << "\n";
cout << "0";
for (int i = 0; i < n - 1; i++) {
cout << " " << -a[i + 1] * n;
}
cout << "\n";
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const double eps = 1e-12;
const int mod = 1e9 + 7;
const int maxn = 300005;
using namespace std;
struct node {
int a, b, id;
} nd[maxn];
bool cmp(node x, node y) { return x.b < y.b; }
set<pair<int, int> > s;
bool use[maxn];
int vis[maxn];
int main() {
int n, w;
long long ans = 0, tmp;
scanf("%d%d", &n, &w);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &nd[i].a, &nd[i].b);
nd[i].id = i;
}
sort(nd + 1, nd + n + 1, cmp);
int l = min(w, n);
for (int i = l + 1; i <= n; i++) s.insert(make_pair(nd[i].a, i));
for (int i = 1; i <= l; i++) {
s.insert(make_pair(nd[i].b - nd[i].a, i));
ans += nd[i].a;
}
for (int i = w - l; i > 0; i--) {
ans += s.begin()->first;
use[s.begin()->second] = 1;
s.erase(s.begin());
}
tmp = ans;
for (; l >= 1; l--) {
if (2 * (l - 1) + (n - l + 1) < w) break;
tmp -= nd[l].a;
if (!use[l]) {
s.erase(make_pair(nd[l].b - nd[l].a, l));
s.insert(make_pair(nd[l].a, l));
use[s.begin()->second] = 1;
tmp += s.begin()->first;
s.erase(s.begin());
} else {
tmp -= nd[l].b - nd[l].a;
s.insert(make_pair(nd[l].a, l));
use[s.begin()->second] = 1;
tmp += s.begin()->first;
s.erase(s.begin());
use[s.begin()->second] = 1;
tmp += s.begin()->first;
s.erase(s.begin());
}
ans = min(ans, tmp);
}
printf("%I64d\n", ans);
s.clear();
memset(use, 0, sizeof(use));
tmp = 0;
l = min(w, n);
for (int i = l + 1; i <= n; i++) s.insert(make_pair(nd[i].a, i));
for (int i = 1; i <= l; i++) {
s.insert(make_pair(nd[i].b - nd[i].a, i));
tmp += nd[i].a;
vis[nd[i].id]++;
}
for (int i = w - l; i > 0; i--) {
tmp += s.begin()->first;
use[s.begin()->second] = 1;
vis[nd[s.begin()->second].id]++;
s.erase(s.begin());
}
if (tmp != ans) {
for (; l >= 1; l--) {
vis[nd[l].id]--;
tmp -= nd[l].a;
if (!use[l]) {
s.erase(make_pair(nd[l].b - nd[l].a, l));
s.insert(make_pair(nd[l].a, l));
use[s.begin()->second] = 1;
vis[nd[s.begin()->second].id]++;
tmp += s.begin()->first;
s.erase(s.begin());
} else {
vis[nd[l].id]--;
tmp -= nd[l].b - nd[l].a;
s.erase(make_pair(nd[l].b - nd[l].a, l));
s.insert(make_pair(nd[l].a, l));
use[s.begin()->second] = 1;
vis[nd[s.begin()->second].id]++;
tmp += s.begin()->first;
s.erase(s.begin());
use[s.begin()->second] = 1;
vis[nd[s.begin()->second].id]++;
tmp += s.begin()->first;
s.erase(s.begin());
}
if (tmp == ans) break;
}
}
for (int i = 1; i <= n; i++) printf("%d", vis[i]);
puts("");
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2e6 + 9;
const long long INF = 1e12;
multiset<int> st;
multiset<int>::iterator it_1, it_2;
vector<int> vec[MAX];
int N, K, X, Y, res, hei[MAX], arr[MAX];
void dfs(int node, int par) {
arr[node] = -1;
if (vec[node].size() == 1 and vec[node][0] == par) {
arr[node] = hei[node];
return;
}
for (auto A : vec[node]) {
if (A == par) continue;
hei[A] = hei[node] + 1;
dfs(A, node);
}
st.clear();
for (auto A : vec[node]) {
if (A == par) continue;
if (arr[A] != -1) st.insert(arr[A]);
}
while (st.size() > 1) {
it_1 = st.end();
it_1--;
it_2 = st.begin();
if (*it_1 - hei[node] + *it_2 - hei[node] > K)
st.erase(it_1), res++;
else
st.erase(it_2);
}
if (!(st.empty())) arr[node] = *st.begin();
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> N >> K;
for (int A = 1; A < N; A++) {
cin >> X >> Y;
vec[X].push_back(Y);
vec[Y].push_back(X);
}
for (int A = 1; A <= N; A++) {
if (A == N or vec[A].size() > 1) {
dfs(A, 0);
return cout << res + st.size(), 0;
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
char ans[10][1010];
void place(int x1, int y1, int x2, int y2) {
set<char> s;
for (int i(min(x1, x2) - 1); i <= max(x1, x2) + 1; i++)
for (int j(min(y1, y2) - 1); j <= max(y1, y2) + 1; j++) s.insert(ans[i][j]);
for (char i('a');; i++) {
if (s.find(i) == s.end()) {
ans[x1][y1] = ans[x2][y2] = i;
return;
}
}
}
int main() {
int n;
cin >> n;
if (n & 1) {
for (int i(1); i < n; i += 2) {
place(1, i, 1, i + 1);
place(2, i, 2, i + 1);
}
place(1, n, 2, n);
place(3, 1, 4, 1);
for (int i(2); i < n; i += 2) {
place(3, i, 3, i + 1);
place(4, i, 4, i + 1);
}
} else {
place(1, 1, 2, 1);
place(1, n, 2, n);
for (int i(2); i < n; i += 2) {
place(1, i, 1, i + 1);
place(2, i, 2, i + 1);
}
for (int i(1); i < n; i += 2) {
place(3, i, 3, i + 1);
place(4, i, 4, i + 1);
}
}
for (int i(1); i <= 4; i++) {
for (int j(1); j <= n; j++) cout << ans[i][j];
cout << '\n';
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
void solution() {
int t, n;
char c;
std::vector<int> v(262144, 0);
scanf("%d%c", &t, &c);
for (int it = 0; it < t; ++it) {
n = 0;
c = getchar();
switch (c) {
case '+': {
c = getchar();
while ((c = getchar()) != '\n') {
c -= '0';
n <<= 1;
n += c & 1;
}
++v[n];
break;
}
case '-': {
while ((c = getchar()) != '\n') {
c -= '0';
n <<= 1;
n += c & 1;
}
--v[n];
break;
}
case '?': {
while ((c = getchar()) != '\n') {
c -= '0';
n <<= 1;
n += c & 1;
}
printf("%d\n", v[n]);
break;
}
}
}
}
int main() {
solution();
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
const int maxd = 50;
const int inf = 1e9;
char str[maxd + 2];
bool open[maxn][maxd];
vector<int> adj[maxn];
int prv[maxn], low[maxn];
int bel[maxn];
vector<int> s[maxn];
int g[maxn];
bool t[maxn][maxd];
int val[maxn][maxd];
int f[maxn][maxd];
int st[maxn][maxd], en[maxn][maxd];
int n, m, d, cnt;
void scc(int u);
void cal(int c);
void topo_sort();
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
for (int u = 1; u <= n; u++) {
scanf("%s", str + 1);
for (int i = 1; i <= d; i++) {
open[u][i % d] = str[i] == '1';
}
}
for (int i = 1; i <= n; i++) {
if (!prv[i]) scc(i);
}
for (int i = 1; i <= cnt; i++) {
cal(i);
}
topo_sort();
int ans = 0;
for (int u = 1; u <= n; u++) {
for (int i = 0; i < d; i++) {
ans = max(ans, en[u][i]);
}
}
printf("%d", ans);
return 0;
}
int stk[maxn];
bool in_stk[maxn];
int top;
void scc(int u) {
static int t = 0;
low[u] = prv[u] = ++t;
stk[++top] = u;
in_stk[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (!prv[v]) {
scc(v);
low[u] = min(low[u], low[v]);
} else if (in_stk[v])
low[u] = min(low[u], prv[v]);
}
if (low[u] >= prv[u]) {
cnt++;
g[cnt] = u;
while (stk[top] != u) {
in_stk[stk[top]] = 0;
bel[stk[top]] = cnt;
s[cnt].push_back(stk[top]);
top--;
}
in_stk[u] = 0;
bel[u] = cnt;
s[cnt].push_back(u);
top--;
}
}
void dfs(int u, int i) {
t[u][i] = 1;
for (int _ = 0; _ < adj[u].size(); _++) {
int v = adj[u][_];
if (bel[v] != bel[u]) continue;
if (t[v][(i + 1) % d]) continue;
dfs(v, (i + 1) % d);
}
}
void cal(int c) {
dfs(g[c], 0);
for (int i = 0; i < d; i++) {
for (int _ = 0; _ < s[c].size(); _++) {
int u = s[c][_];
bool cur = 0;
for (int j = 0; j < d; j++) {
cur |= t[u][j] & open[u][(i + j) % d];
}
val[c][i] += cur;
}
}
}
void topo_sort() {
static int ind[maxn];
for (int u = 1; u <= n; u++) {
for (int i = 0; i < d; i++) {
st[u][i] = en[u][i] = -inf;
}
}
for (int c = 1; c <= cnt; c++) {
for (int i = 0; i < d; i++) {
f[c][i] = -inf;
}
}
st[1][1 % d] = 0;
for (int u = 1; u <= n; u++) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (bel[u] != bel[v]) ind[bel[v]]++;
}
}
queue<int> q;
for (int i = 1; i <= cnt; i++) {
if (!ind[i]) q.push(i);
}
while (!q.empty()) {
int c = q.front();
q.pop();
for (int i = 0; i < d; i++) {
for (int _ = 0; _ < s[c].size(); _++) {
int u = s[c][_];
for (int j = 0; j < d; j++) {
if (t[u][j]) f[c][i] = max(f[c][i], st[u][(i + j) % d]);
}
}
}
for (int _ = 0; _ < s[c].size(); _++) {
int u = s[c][_];
for (int i = 0; i < d; i++) {
if (!t[u][i]) continue;
for (int j = 0; j < d; j++) {
en[u][(i + j) % d] = max(en[u][(i + j) % d], f[c][j] + val[c][j]);
}
}
for (int __ = 0; __ < adj[u].size(); __++) {
int v = adj[u][__];
if (bel[u] == bel[v]) continue;
ind[bel[v]]--;
if (!ind[bel[v]]) q.push(bel[v]);
for (int i = 0; i < d; i++) {
st[v][(i + 1) % d] = max(st[v][(i + 1) % d], en[u][i]);
}
}
}
}
}
| 17
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int add(int a, int b) {
long long x = a + b;
if (x >= 1000000007) x -= 1000000007;
if (x < 0) x += 1000000007;
return x;
}
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand_seed() {
long long a = rng();
return a;
}
int n, m, v[15], mat[15][15];
void bruteforce() {
for (int i = 1; i <= n * m; ++i) v[i] = i;
do {
int l = 1, c = 1;
for (int i = 1; i <= n * m; ++i) {
mat[l][c] = v[i];
++c;
if (c > m) c = 1, ++l;
}
bool ok = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (i + 1 <= n && (abs(mat[i][j] - mat[i + 1][j]) == 1 ||
abs(mat[i][j] - mat[i + 1][j]) == m))
ok = 0;
if (j + 1 <= m && (abs(mat[i][j] - mat[i][j + 1]) == 1 ||
abs(mat[i][j] - mat[i][j + 1]) == m))
ok = 0;
}
if (ok) {
for (int i = 1; i <= n; cout << '\n', ++i)
for (int j = 1; j <= m; ++j) cout << mat[i][j] << " ";
break;
}
} while (next_permutation(v + 1, v + n * m + 1));
}
void solveone(int linie) {
if (m == 4)
cout << (linie - 1) * m + 2 << " " << (linie - 1) * m + 4 << " "
<< (linie - 1) * m + 1 << " " << (linie - 1) * m + 3 << '\n';
else {
int x = 1;
while (x <= m) cout << (linie - 1) * m + x << " ", x += 2;
x = 2;
while (x <= m) cout << (linie - 1) * m + x << " ", x += 2;
cout << '\n';
}
}
void solvetwo(int liniea, int linieb) {
if (m == 4) {
cout << (liniea - 1) * m + 2 << " " << (liniea - 1) * m + 4 << " "
<< (liniea - 1) * m + 1 << " " << (liniea - 1) * m + 3 << '\n';
cout << (linieb - 1) * m + 3 << " " << (linieb - 1) * m + 1 << " "
<< (linieb - 1) * m + 4 << " " << (linieb - 1) * m + 2 << '\n';
} else {
int nr = 1;
int nr2 = 2;
for (int i = 1; i <= m; ++i) {
if (nr <= m)
cout << (liniea - 1) * m + nr << " ", nr += 2;
else
cout << (liniea - 1) * m + nr2 << " ", nr2 += 2;
}
cout << '\n';
if (m % 2 == 0) {
nr = 1;
nr2 = 2;
for (int i = 1; i <= m; ++i) {
if (nr2 <= m)
cout << (linieb - 1) * m + nr2 << " ", nr2 += 2;
else
cout << (linieb - 1) * m + nr << " ", nr += 2;
}
cout << '\n';
} else {
cout << (linieb - 1) * m + 3 << " ";
nr2 = 5;
while (nr2 <= m) cout << (linieb - 1) * m + nr2 << " ", nr2 += 2;
cout << (linieb - 1) * m + 1 << " ";
cout << (linieb - 1) * m + 4 << " ";
nr = 6;
while (nr <= m) cout << (linieb - 1) * m + nr << " ", nr += 2;
cout << (linieb - 1) * m + 2 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
if (n == 1 && m == 1) {
cout << "YES\n";
cout << 1;
return 0;
}
if (n <= 2 && m <= 3) {
cout << "NO";
return 0;
}
if (n == 3 && m <= 2) {
cout << "NO";
return 0;
}
cout << "YES\n";
if (n <= m) {
if (n == 3 && m == 3) {
cout << "1 3 8\n5 9 4\n7 2 6\n";
return 0;
}
if (n == 2 && m == 4) {
cout << "2 4 1 3\n7 5 8 6\n";
return 0;
}
if (n == 2 && m == 5) {
cout << "1 3 5 2 4\n8 10 7 9 6\n";
return 0;
}
if (n == 2 && m == 6) {
cout << "1 3 5 2 4 6\n8 10 12 7 9 11\n";
return 0;
}
if (n == 2 && m == 7) {
cout << "1 3 5 7 2 4 6\n10 12 14 8 11 13 9\n";
return 0;
}
for (int i = 1; i + 1 <= n; i += 2) solvetwo(i + 1, i);
if (n % 2 == 1) solveone(n);
} else {
if (m >= 4) {
for (int i = 1; i + 1 <= n; i += 2) solvetwo(i + 1, i);
if (n % 2 == 1) solveone(n);
} else {
if (n == 4 && m == 2) {
cout << "1 5\n4 8\n7 2\n3 6\n";
return 0;
}
if (m == 2) {
int p1 = 1;
int p2 = 2;
for (int i = 1; i <= n; ++i) {
cout << p1 * 2 - 1 << " " << p2 * 2 << '\n';
p1 += 2;
p2 += 2;
if (p1 > n) p1 = 2;
if (p2 > n) p2 = 1;
}
return 0;
}
if (n == 4 && m == 3) {
cout << "1 3 5\n6 8 10\n2 4 12\n9 11 7\n";
return 0;
}
if (m == 3) {
int p1 = 1;
int p2 = 2;
int p3 = 1;
for (int i = 1; i <= n; ++i) {
cout << (p1 - 1) * 3 + 1 << " " << (p2 - 1) * 3 + 2 << " " << p3 * 3
<< '\n';
p1 += 2;
p2 += 2;
p3 += 2;
if (p1 > n) p1 = 2;
if (p2 > n) p2 = 1;
if (p3 > n) p3 = 2;
}
return 0;
}
if (m == 1) {
int p1 = 2;
for (int i = 1; i <= n; ++i) {
cout << p1 << '\n';
p1 += 2;
if (p1 > n) p1 = 1;
}
return 0;
}
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T& x) {
stringstream ss;
ss << x;
return ss.str();
}
const long double EPS = 1e-14;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const long double DINF = 1e200;
const long double PI = 3.1415926535897932384626433832795L;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
int n;
vector<pair<int, int> > pos;
const long long mod = INF + 7;
long long powmod(long long a, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % mod;
p >>= 1;
a = a * a % mod;
}
return r;
}
long long C(int n, int k) {
long long r = 1;
for (int i = n - k + 1; i <= n; ++i) {
r = r * i % mod * powmod(n - i + 1, mod - 2) % mod;
}
return r;
}
long long doit(int a, int b, int t) {
long long res = 1;
for (int i = 1; i < ((int)(pos).size()); ++i) {
int p = pos[i].second;
int d = pos[i].first;
int aa, bb;
if (p < a) {
aa = p + 1;
bb = b + ((d - t) - (a - p));
if (bb < b || bb > n) return 0;
} else if (p >= b) {
bb = p;
aa = a - ((d - t) - (p + 1 - b));
if (aa > a || aa < 0) return 0;
} else
return 0;
res = res * C(a - aa + bb - b, a - aa) % mod;
if (p < a)
--aa;
else
++bb;
a = aa;
b = bb;
t = d;
}
if (a < 0 || b > n) return 0;
res = res * C(a + n - b, a) % mod;
return res;
}
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) {
int a;
scanf("%d", &a);
if (a) pos.push_back(make_pair(a, i));
}
sort((pos).begin(), (pos).end());
if (!((int)(pos).size())) {
cout << powmod(2, n - 1);
return 0;
}
long long res;
if (pos[0].first == 1) {
res = doit(pos[0].second, pos[0].second + 1, 1);
} else {
res = (doit(pos[0].second, pos[0].second + pos[0].first, pos[0].first) *
powmod(2, pos[0].first - 2) +
doit(pos[0].second - pos[0].first + 1, pos[0].second + 1,
pos[0].first) *
powmod(2, pos[0].first - 2)) %
mod;
}
cout << res;
return 0;
}
| 17
|
#include <bits/stdc++.h>
int n, x[1003], y[1003];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", x + i, y + i);
double l, r;
if (x[1] > x[2])
l = x[2], r = x[1];
else
r = x[2], l = x[1];
for (int i = 3; i < n; ++i) {
double dx = x[i + 1] - x[i];
double dy = y[i + 1] - y[i];
double d = y[1] - y[i];
double xx;
if (!dy)
xx = 1e10;
else
xx = x[i] + d / dy * dx;
if (d * dx - dy * (r - x[i]) > 0 && r > xx) r = xx;
if (d * dx - dy * (l - x[i]) > 0 && l < xx) l = xx;
}
r = floor(r), l = ceil(l);
if (r >= l)
printf("%.0lf\n", r - l + 1.1);
else
puts("0");
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int ct[10][10];
bool lead[10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<string> in(n);
for (int i = 0; i < n; i++) {
cin >> in[i];
lead[in[i][0] - 'a'] = true;
reverse(in[i].begin(), in[i].end());
for (int j = 0; j < in[i].length(); j++) {
ct[in[i][j] - 'a'][j]++;
}
}
vector<int> v(10);
for (int i = 0; i < 10; i++) v[i] = i;
int minsum = 2 * (int)1e9;
do {
int zloc = find(v.begin(), v.end(), 0) - v.begin();
if (lead[zloc]) continue;
int sum = 0;
for (int i = 0; i < 10; i++) {
int p10 = 1;
for (int j = 0; j < 6; j++) {
sum += p10 * v[i] * ct[i][j];
p10 *= 10;
}
}
minsum = min(sum, minsum);
} while (next_permutation(v.begin(), v.end()));
cout << minsum << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma hdrstop
using namespace std;
inline void sIO() {}
inline void iIO() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
inline void fIO(string fn) {
freopen((fn + ".in").c_str(), "r", stdin);
freopen((fn + ".out").c_str(), "w", stdout);
}
inline void TM() {}
inline void swap(short& a, short& b) { b ^= a ^= b ^= a; }
inline void swap(int& a, int& b) { b ^= a ^= b ^= a; }
inline void swap(char& a, char& b) { b ^= a ^= b ^= a; }
inline void swap(long long& a, long long& b) { b ^= a ^= b ^= a; }
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T min(T& a, T& b) {
return a < b ? a : b;
}
template <class T>
inline T max(T& a, T& b) {
return a > b ? a : b;
}
template <class T>
inline T gcd(T a, T b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline bool isPrime(T n) {
if (n < 2) return false;
T kk = (T)sqrt(n + 0.);
for (T i = 2; i <= kk; ++i)
if (!(n % i)) return false;
return true;
}
template <class T>
inline string toa(T x) {
stringstream ss;
ss << x;
string ret;
ss >> ret;
return ret;
}
template <class T>
inline T ppow(T a, long long b) {
T ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
b >>= 1;
}
return ret;
}
template <class T>
inline T ppow(T a, long long b, long long md) {
T ret = 1;
a %= md;
while (b) {
if (b & 1) ret = ret * a % md;
a = a * a % md;
b >>= 1;
}
return ret % md;
}
inline int toi(string s) {
stringstream ss;
ss << s;
int ret;
ss >> ret;
return ret;
}
inline long long tol(string s) {
stringstream ss;
ss << s;
long long ret;
ss >> ret;
return ret;
}
inline int Random() { return ((rand() << 16) | rand()); }
inline int Random(int l, int r) {
if (l == r) return l;
return Random() % (r - l) + l;
}
inline char upperCase(char ch) {
return (ch >= 'a' && ch <= 'z') ? ch ^ 32 : ch;
}
inline char lowerCase(char ch) {
return (ch >= 'A' && ch <= 'Z') ? ch ^ 32 : ch;
}
inline string upperCase(string s) {
int ls = s.length();
for (int i = 0; i < ls; ++i)
if (s[i] >= 'a' && s[i] <= 'z') s[i] ^= 32;
return s;
}
inline string lowerCase(string s) {
int ls = s.length();
for (int i = 0; i < ls; ++i)
if (s[i] >= 'A' && s[i] <= 'Z') s[i] ^= 32;
return s;
}
inline int dig(char ch) { return ch - 48; }
inline bool isAlpha(char ch) {
return (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z');
}
inline bool isDigit(char ch) { return (ch >= '0' && ch <= '9'); }
inline bool isLowerCase(char ch) { return (ch >= 'a' && ch <= 'z'); }
inline bool isUpperCase(char ch) { return (ch >= 'A' && ch <= 'Z'); }
int __;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const int MD = 1000000007;
long long a, b, ans;
void go(long long a, long long b, int bit) {
if (bit < 0) return;
if (!(a & (1LL << bit)) && (b & (1LL << bit))) {
ans = 0;
for (int i = 0; i <= bit; ++i) ans |= (1LL << i);
return;
}
if (a >= (1LL << bit))
go(a - (1LL << bit), b - (1LL << bit), bit - 1);
else
go(a, b, bit - 1);
}
int main() {
sIO();
scanf(
"%lld"
"%lld",
&a, &b);
ans = a ^ b;
go(a, b, 63);
printf("%lld", ans);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
scanf(" %d", &N);
vector<int> L(N), R(N);
set<int> x_posS;
for (int i = 0; i < N; i++) {
scanf(" %d %d", &L[i], &R[i]);
x_posS.insert(L[i]);
x_posS.insert(R[i]);
}
vector<int> x_pos;
for (auto it = x_posS.begin(); it != x_posS.end(); it++) x_pos.push_back(*it);
vector<vector<long double> > ans(N, vector<long double>(N, 0));
vector<bool> bad(N, false);
for (int x = 1; x < (int)x_pos.size(); x++) {
int st = 0;
for (int i = 0; i < N; i++) {
if (x_pos[x] <= L[i]) continue;
if (x_pos[x - 1] >= R[i]) {
st++;
continue;
}
}
vector<vector<long double> > p_akt(N + 1 - st,
vector<long double>(N + 1 - st, 0));
p_akt[0][0] = 1;
for (int i = 0; i < N; i++) {
if (x_pos[x] <= L[i]) continue;
if (x_pos[x - 1] >= R[i]) continue;
long double p_lt = 1.0 * (x_pos[x - 1] - L[i]) / (R[i] - L[i]);
long double p_eq = 1.0 * (x_pos[x] - x_pos[x - 1]) / (R[i] - L[i]);
long double p3 = 1.0 * (R[i] - x_pos[x]) / (R[i] - L[i]);
for (int j = N - st; j >= 0; j--)
for (int k = N - st - j; k >= 0; k--)
p_akt[j][k] = ((j == 0) ? 0 : p_akt[j - 1][k]) * p_lt +
((k == 0) ? 0 : p_akt[j][k - 1]) * p_eq +
p_akt[j][k] * p3;
}
for (int i = 0; i < N; i++)
if (!bad[i]) {
if (x_pos[x] <= L[i] || x_pos[x - 1] >= R[i]) continue;
long double p_lt = 1.0 * (x_pos[x - 1] - L[i]) / (R[i] - L[i]);
long double p_eq = 1.0 * (x_pos[x] - x_pos[x - 1]) / (R[i] - L[i]);
long double p3 = 1.0 * (R[i] - x_pos[x]) / (R[i] - L[i]);
vector<vector<long double> > akt(N - st,
vector<long double>(N - st, 0));
if (p3 > p_lt && p3 > p_eq) {
for (int j = 0; j < N - st; j++)
for (int k = 0; k < N - st - j; k++)
akt[j][k] = (p_akt[j][k] - ((k == 0) ? 0 : akt[j][k - 1]) * p_eq -
((j == 0) ? 0 : akt[j - 1][k]) * p_lt) /
p3;
} else if (p_eq > p_lt) {
for (int k = N - st - 1; k >= 0; k--)
for (int j = 0; j < N - st - k; j++)
akt[j][k] =
(p_akt[j][k + 1] -
((k == N - 1 - st)
? 0
: (akt[j][k + 1] * p3 +
((j == 0) ? 0 : akt[j - 1][k + 1]) * p_lt))) /
p_eq;
} else {
for (int j = N - st - 1; j >= 0; j--)
for (int k = 0; k < N - st - j; k++)
akt[j][k] =
(p_akt[j + 1][k] -
((j == N - 1 - st)
? 0
: (akt[j + 1][k] * p3 +
((k == 0) ? 0 : akt[j + 1][k - 1]) * p_eq))) /
p_lt;
}
vector<long double> add(N + 1, 0);
for (int j = 0; j < N - st; j++)
for (int k = 0; k < N - st - j; k++) {
if (akt[j][k] > 1.1) bad[i] = true;
add[st + j] += akt[j][k] / (k + 1) * p_eq;
add[st + j + k + 1] -= akt[j][k] / (k + 1) * p_eq;
}
long double s2 = 0;
for (int j = 0; j < N; j++) {
s2 += add[j];
ans[i][j] += s2;
}
}
}
for (int i = 0; i < N; i++) {
long double sump = 0;
for (int j = 0; j < N; j++) sump += ans[i][j];
if (((sump - 1 < 0) ? -(sump - 1) : sump - 1) > 1e-6) bad[i] = true;
}
for (int b = 0; b < N; b++)
if (bad[b]) {
for (int j = 0; j < N; j++) ans[b][j] = 0;
for (int x = 1; x < (int)x_pos.size(); x++)
if (x_pos[x] <= R[b] && x_pos[x - 1] >= L[b]) {
int st = 0;
for (int i = 0; i < N; i++)
if (i != b) {
if (x_pos[x] <= L[i]) continue;
if (x_pos[x - 1] >= R[i]) {
st++;
continue;
}
}
vector<vector<long double> > p_akt(
N + 1 - st, vector<long double>(N + 1 - st, 0));
p_akt[0][0] = 1;
for (int i = 0; i < N; i++)
if (i != b) {
if (x_pos[x] <= L[i]) continue;
if (x_pos[x - 1] >= R[i]) continue;
long double p_lt = 1.0 * (x_pos[x - 1] - L[i]) / (R[i] - L[i]);
long double p_eq =
1.0 * (x_pos[x] - x_pos[x - 1]) / (R[i] - L[i]);
long double p3 = 1.0 * (R[i] - x_pos[x]) / (R[i] - L[i]);
for (int j = N - st; j >= 0; j--)
for (int k = N - st - j; k >= 0; k--)
p_akt[j][k] = ((j == 0) ? 0 : p_akt[j - 1][k]) * p_lt +
((k == 0) ? 0 : p_akt[j][k - 1]) * p_eq +
p_akt[j][k] * p3;
}
long double p_eq = 1.0 * (x_pos[x] - x_pos[x - 1]) / (R[b] - L[b]);
vector<long double> add(N + 1, 0);
for (int j = 0; j < N - st; j++)
for (int k = 0; k < N - st - j; k++) {
add[st + j] += p_akt[j][k] / (k + 1) * p_eq;
add[st + j + k + 1] -= p_akt[j][k] / (k + 1) * p_eq;
}
long double s2 = 0;
for (int j = 0; j < N; j++) {
s2 += add[j];
ans[b][j] += s2;
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (j > 0) printf(" ");
printf("%.12lf", (double)((ans[i][j] < 0) ? -(ans[i][j]) : ans[i][j]));
}
printf("\n");
}
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
const int NM = 2e5 + 10;
int n, m, k;
vector<pair<int, int>> adj[NM];
int zero[NM], dest[NM], last_to_reach[NM];
bool cond[NM];
void bfs() {
vector<int> dist(n + 1, 1e9), used_edge(n + 1, -1);
queue<pair<int, int>> q;
dist[1] = 0;
q.push({1, dist[1]});
while (!q.empty()) {
int u = q.front().first, d = q.front().second;
q.pop();
for (auto e : adj[u]) {
int v = e.first, idx = e.second;
if (dist[v] == 1e9) {
q.push({v, d + 1});
dist[v] = d + 1;
used_edge[v] = idx;
dest[idx] = v;
last_to_reach[v] = max(last_to_reach[v], idx);
} else if (d + 1 == dist[v]) {
assert(used_edge[v] != -1);
dest[idx] = v;
last_to_reach[v] = max(last_to_reach[v], idx);
cond[idx] = true;
cond[used_edge[v]] = true;
} else if (d + 1 > dist[v]) {
zero[idx]++;
} else {
assert(false);
}
}
}
}
bool reached[NM];
char state[NM];
vector<string> ans;
void finish() {
printf("%d\n", ((int)(ans).size()));
for (auto &s : ans) {
printf("%s\n", s.c_str());
}
exit(0);
}
void generate(int idx = 0) {
if (idx == m) {
ans.push_back(state);
if (((int)(ans).size()) == k) finish();
} else {
if (zero[idx] == 2) {
state[idx] = '0';
generate(idx + 1);
} else {
int v = dest[idx];
if (!cond[idx]) {
assert(!reached[v]);
state[idx] = '1';
reached[v] = true;
generate(idx + 1);
reached[v] = false;
} else {
if (!reached[v]) {
state[idx] = '1';
reached[v] = true;
generate(idx + 1);
reached[v] = false;
}
if (reached[v] || last_to_reach[v] > idx) {
state[idx] = '0';
generate(idx + 1);
}
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back({b, i});
adj[b].push_back({a, i});
}
memset(dest, -1, sizeof(dest));
memset(last_to_reach, -1, sizeof(last_to_reach));
bfs();
generate();
finish();
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int n, a[5050], dp[5050][5050];
int calcdown(int l, int r, int val) {
if (l > r) return 0;
int ans = dp[r][val];
if (l) ans -= dp[l - 1][val];
return ans;
}
int calcup(int l, int r, int val) {
if (l > r) return 0;
int sz = r - l + 1;
return sz - calcdown(l, r, val);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
dp[i][a[i] + 1] = 1;
for (int j = 1; j < n; j++) dp[i][j] += dp[i][j - 1];
for (int j = 0; j < n; j++) {
if (i) dp[i][j] += dp[i - 1][j];
}
}
int ans = inf;
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[i] > a[j]) {
int cur = -1 - calcdown(i + 1, j - 1, a[i]) -
calcup(i + 1, j - 1, a[j]) + calcdown(i + 1, j - 1, a[j]) +
calcup(i + 1, j - 1, a[i]);
if (ans > cur) {
ans = cur;
cnt = 1;
} else if (ans == cur)
cnt++;
}
}
}
int old = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) old += a[i] > a[j];
}
cout << old + ans << " " << cnt << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void show(T *a, int size) {
int i;
cout << endl << "The array is ";
for (long long i = 0; i < size; ++i) {
cout << a[i] << " ";
}
cout << endl;
}
template <typename T>
void show_vector(vector<T> v) {
cout << endl << "The vector is ";
int i;
for (long long i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << endl;
}
long long int a[100005], n;
long long int func() {
stack<long long int> s;
s.push(a[0]);
long long int ans = 0;
for (long long i = 1; i < n; ++i) {
while (!s.empty() && a[i] > s.top()) {
ans = max(ans, a[i] ^ s.top());
s.pop();
}
if (!s.empty()) {
ans = max(ans, a[i] ^ s.top());
}
s.push(a[i]);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
cout << func() << endl;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005, MOD = 998244353;
const long long inf = 5e18;
int arr[2 * MAX];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
int q;
cin >> q;
while (q--) {
long long n, m;
long long a = 0;
cin >> n >> m;
long long d = m % 10;
for (int i = 1; i <= 9; i++) a += ((d * i) % 10);
n /= m;
int rem = n % 10;
n /= 10;
a *= n;
if (rem)
for (int i = 1; i <= rem; i++) a += ((d * i) % 10);
cout << a << "\n";
}
}
| 4
|
#include <bits/stdc++.h>
const int N = 1010;
const int MOD = 1000000007;
using namespace std;
int n;
string s;
int dp1[N];
int dp2[N];
int allowed[26];
void solve() {
dp1[0] = 1;
dp2[0] = 1;
bool isPresent[26] = {};
int MAX_LEN = 1;
for (int i = 1; i < n; i++) {
long long res1 = dp1[i - 1];
long long res2 = 1 + dp2[i - 1];
int curr = s[i] - 'a';
for (int k = 0; k < 26; k++) isPresent[k] = 0;
isPresent[curr] = 1;
for (int j = i - 1, len = 2; j >= 0; j--, len++) {
curr = s[j] - 'a';
isPresent[curr] = 1;
bool flag = 0;
for (int k = 0; k < 26 && !flag; k++)
if (isPresent[k] && allowed[k] < len) flag = 1;
if (flag) break;
MAX_LEN = max(MAX_LEN, len);
if (j == 0) {
res1 = (res1 + 1) % MOD;
res2 = 1;
} else {
res1 = (res1 + dp1[j - 1]) % MOD;
res2 = min(res2, 1ll * (1 + dp2[j - 1]));
}
}
dp1[i] = res1;
dp2[i] = res2;
}
cout << dp1[n - 1] << '\n';
cout << MAX_LEN << '\n';
cout << dp2[n - 1] << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cin >> s;
for (int i = 0; i < 26; i++) cin >> allowed[i];
solve();
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
typedef struct {
int x, y, t;
double p;
} T;
typedef struct {
double v;
int num;
} Node;
vector<Node> dp;
T targ[maxn];
bool cmp(const T &t1, const T &t2) { return t1.t < t2.t; }
int main() {
int i, j, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d %d %lf", &targ[i].x, &targ[i].y, &targ[i].t, &targ[i].p);
}
sort(targ + 1, targ + 1 + n, cmp);
Node temp;
dp.clear();
double maxv;
for (i = 1; i <= n; i++) {
maxv = 0;
for (j = 0; j < dp.size(); j++) {
int len =
(targ[i].x - targ[dp[j].num].x) * (targ[i].x - targ[dp[j].num].x) +
(targ[i].y - targ[dp[j].num].y) * (targ[i].y - targ[dp[j].num].y);
double l = sqrt(double(len));
int tim = targ[i].t - targ[dp[j].num].t;
if (tim >= l) {
if (maxv < dp[j].v + targ[i].p) maxv = dp[j].v + targ[i].p;
}
}
if (maxv > 0) {
temp.v = maxv;
temp.num = i;
dp.push_back(temp);
} else {
temp.v = targ[i].p;
temp.num = i;
dp.push_back(temp);
}
}
maxv = 0.0;
for (i = 0; i < dp.size(); i++) {
if (dp[i].v > maxv) maxv = dp[i].v;
}
printf("%.7f\n", maxv);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int arr[200010];
vector<int> hashArr;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
sort(arr, arr + n);
int index = 0, prev = -1, sz = 0;
for (int i = 0; i < n; i++) {
if (arr[i] != prev) {
prev = arr[i];
if (sz != 0) {
hashArr.push_back(sz);
}
sz = 1;
index++;
} else {
sz++;
}
}
hashArr.push_back(sz);
sort(hashArr.begin(), hashArr.end());
int maxx = hashArr[hashArr.size() - 1];
int szz = hashArr.size();
int maxAns = 0;
for (int i = 1; i <= maxx; i++) {
int curAns = 0;
int f = i;
vector<int>::iterator diff = lower_bound(hashArr.begin(), hashArr.end(), f);
while (diff != hashArr.end()) {
curAns += f;
f = f * 2;
diff++;
vector<int>::iterator diff2 = lower_bound(diff, hashArr.end(), f);
diff = diff2;
}
maxAns = max(maxAns, curAns);
}
cout << maxAns << endl;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
struct qry {
int l, r, id;
bool operator<(const qry &a) const {
if (r == a.r) return l < a.l;
return r < a.r;
}
};
struct node {
int l, r;
pair<int, int> p;
};
qry ask[maxn];
node tree[maxn << 2];
int a[maxn];
int pos[maxn];
int re[maxn];
void build(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
}
void update(int i, int t, int p, int n) {
if (tree[i].l == tree[i].r && tree[i].l == t) {
tree[i].p = pair<int, int>(p, n);
return;
}
int mid = (tree[i].l + tree[i].r) >> 1;
if (t <= mid)
update(i << 1, t, p, n);
else
update(i << 1 | 1, t, p, n);
tree[i].p = min(tree[i << 1].p, tree[i << 1 | 1].p);
}
pair<int, int> query(int i, int l, int r) {
if (tree[i].l == l && tree[i].r == r) return tree[i].p;
int mid = (tree[i].l + tree[i].r) >> 1;
if (r <= mid)
return query(i << 1, l, r);
else if (l > mid)
return query(i << 1 | 1, l, r);
else
return min(query(i << 1, l, mid), query(i << 1 | 1, mid + 1, r));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &ask[i].l, &ask[i].r);
ask[i].id = i;
}
sort(ask, ask + m);
build(1, 1, n);
int s = 1;
for (int i = 0; i < m; i++) {
while (s <= ask[i].r) {
if (pos[a[s]]) update(1, pos[a[s]], 0x3f3f3f3f, a[s]);
update(1, s, pos[a[s]], a[s]);
pos[a[s]] = s;
s++;
}
pair<int, int> tp = query(1, ask[i].l, ask[i].r);
if (tp.first < ask[i].l) re[ask[i].id] = tp.second;
}
for (int i = 0; i < m; i++) printf("%d\n", re[i]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
long long RemoveZeros(long long a) {
long long Multplier = 0;
long long i = 10;
while (a > 0) {
if (a % 10 != 0) {
Multplier += (a % 10) * i;
i *= 10;
}
a /= 10;
}
return Multplier / 10;
}
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b;
c = a + b;
long long a1 = RemoveZeros(a);
long long b1 = RemoveZeros(b);
long long c1 = RemoveZeros(c);
if (a1 + b1 == c1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int r[200100];
int l[200100];
int s[200100];
int n, k, a, b, q;
int getsum(int x, int c[]) {
int ret = 0;
while (x) {
ret += c[x];
x -= x & -x;
}
return ret;
}
void update(int x, int c[], int v) {
while (x <= n) {
c[x] += v;
x += x & -x;
}
}
void update(int x, int v) {
int os = s[x];
s[x] += v;
update(x, l, min(s[x], b) - min(os, b));
update(x, r, min(s[x], a) - min(os, a));
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 1; i <= q; ++i) {
int x, y, z;
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
update(y, z);
} else {
scanf("%d", &y);
printf("%d\n", getsum(y - 1, l) + getsum(n, r) - getsum(y + k - 1, r));
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long n;
cin >> n;
string s;
cin >> s;
long long l = 0, r = 0, i;
for (i = 0; i < n; i++) {
if (s[i] == 'L') {
l++;
} else {
r++;
}
}
cout << l + r + 1 << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, max1 = -1, max2 = -1, max, sum = 0, k;
long long n;
cin >> n;
long long a, x[n];
for (int i = 0; i < n; i++) {
cin >> a;
sum += a;
}
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(&x[0], &x[0] + n);
max = x[n - 1] + x[n - 2];
if (max >= sum) {
cout << "YES";
} else
cout << "NO";
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int getans(set<int>& S, priority_queue<pii>& gaps) {
if (gaps.empty()) return 0;
return *S.rbegin() - *S.begin() - gaps.top().first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
set<int> S;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
S.insert(t);
}
priority_queue<pii> gaps;
for (auto it = S.begin(); it != S.end(); it++) {
if (it == S.begin()) continue;
auto last = it;
last--;
gaps.push({*it - *last, *it});
}
cout << getans(S, gaps) << '\n';
for (int qn = 0; qn < q; qn++) {
int cmd, t;
cin >> cmd >> t;
if (cmd == 1) {
S.insert(t);
auto it = S.find(t);
auto next = it;
next++;
if (next != S.end()) {
gaps.push({(*next - *it), *next});
}
if (it != S.begin()) {
auto last = it;
last--;
gaps.push({(*it - *last), *it});
}
} else {
auto it = S.find(t);
auto next = it;
next++;
if (next != S.end() && it != S.begin()) {
auto last = it;
last--;
gaps.push({(*next - *last), *next});
}
S.erase(t);
}
while (1) {
if (gaps.empty()) break;
int p1 = gaps.top().second;
int p2 = gaps.top().second - gaps.top().first;
if (S.find(p1) != S.end() && S.find(p2) != S.end()) {
auto pp1 = S.find(p1);
auto pp2 = S.find(p2);
auto pp3 = pp1;
pp3--;
if (pp2 == pp3) break;
}
gaps.pop();
}
cout << getans(S, gaps) << '\n';
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
long long int calch(long long int h, long long int x, long long int y,
long long int t, long long int m) {
for (long long int i = 1; i <= t; i++) {
h = ((h * x) + y) % m;
}
return h;
}
long long int calct(long long int h, long long int x, long long int y,
long long int a, long long int m) {
for (long long int i = 1; i <= m; i++) {
h = ((h * x) + y) % m;
if (h == a) return i;
}
return -1;
}
int main() {
long long int m, h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
long long int q, c, h2q, d, e;
q = calct(h1, x1, y1, a1, m);
if (q == -1) {
cout << -1 << endl;
return 0;
}
h2q = calch(h2, x2, y2, q, m);
if (h2q == a2) {
cout << q << endl;
return 0;
}
c = calct(a1, x1, y1, a1, m);
if (c == -1) {
cout << -1 << endl;
return 0;
}
d = calct(h2q, x2, y2, a2, m);
e = calct(a2, x2, y2, a2, m);
if (d == -1 || (e == -1 && d % c != 0)) {
cout << -1 << endl;
return 0;
}
for (long long int i = 1; i <= m; ++i) {
long long int t = c * i;
if ((t - d) % e == 0 && (t - d) >= 0) {
cout << q + t << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int n, m;
int dir[3] = {2, 3, 5}, ans;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int l, r;
while (~scanf("%d%d", &n, &m)) {
ans = 0;
int flag = 1;
int temp = gcd(n, m);
n /= temp;
m /= temp;
while (flag) {
flag = 0;
for (int i = 0; i < 3; i++) {
if (n % dir[i] == 0) {
n /= dir[i];
ans++;
flag = 1;
break;
}
}
}
flag = 1;
while (flag) {
flag = 0;
for (int i = 0; i < 3; i++) {
if (m % dir[i] == 0) {
m /= dir[i];
ans++;
flag = 1;
break;
}
}
}
if (m != 1 || n != 1) ans = -1;
printf("%d\n", ans);
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
const int N = 1e5 + 5, M = 3e5 + 5, P = 998244353;
int n, a[N], mW, f[M], inv[M], s = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s += a[i];
inv[1] = 1;
for (int i = 2; i <= s; i++) inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
for (int i = 1; i < s; i++)
f[i + 1] = ((s + i * (n - 2ll)) % P * f[i] -
(i * (n - 1ll) % P * (f[i - 1] + 1)) % P + P) %
P * inv[s - i] % P;
int ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + f[a[i]]) % P;
ans = (ans - f[s] + P) % P;
printf("%d\n", ans);
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
long long b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (long long i = 0; i < n; i++) {
a[i] = (a[i] * (n - i) * (i + 1));
}
sort(a, a + n);
sort(b, b + n);
reverse(b, b + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + ((a[i] % 998244353) * b[i]) % 998244353) % 998244353;
}
cout << ans;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int inf = INT_MAX;
const long long inff = 2e13;
const long long mod = 1e9 + 7;
int t[maxn], h[maxn];
vector<int> G[maxn];
long long dp[maxn][2];
void dfs(int now, int p) {
dp[now][0] = dp[now][1] = inff;
long long sum = 0;
vector<long long> v;
for (int i : G[now])
if (i != p) {
dfs(i, now);
sum += dp[i][1];
v.push_back(dp[i][0] - dp[i][1]);
}
int degsum = -((int)(v).size()), deg = ((int)(v).size()) + 1;
sort((v).begin(), (v).end());
for (int i = 0; i < ((int)(v).size()) + 1; i++) {
if (now == 1)
dp[now][0] =
min(dp[now][0],
sum + (abs(degsum) + ((deg - abs(degsum)) >> 1)) * 1LL * t[now]);
else {
if (h[now] >= h[p])
dp[now][0] = min(dp[now][0], sum + (abs(degsum - 1) +
((deg - abs(degsum - 1)) >> 1)) *
1LL * t[now]);
if (h[now] <= h[p])
dp[now][1] = min(dp[now][1], sum + (abs(degsum + 1) +
((deg - abs(degsum + 1)) >> 1)) *
1LL * t[now]);
}
if (i < ((int)(v).size())) {
sum += v[i];
degsum += 2;
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
dfs(1, 0);
cout << dp[1][0] << '\n';
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int n, h, f[1100][2][31][31][31];
int main(void) {
while (cin >> n >> h) {
memset(f, 0, sizeof f);
f[0][1][0][0][0] = 1;
for (int i = int(0), ni = int(n); i <= ni; i++) {
for (int a = int(0), na = int(h); a <= na; a++)
for (int b = int(0), nb = int(h); b <= nb; b++)
for (int c = int(0), nc = int(h); c <= nc; c++)
for (int k = int(0), nk = int(1); k <= nk; k++) {
int v = f[i][k][a][b][c];
int d = k ? 1 : h;
(f[i + 1][a < h][min(b + 1, h)][min(c + 1, h)][d] += v) %=
1000000009;
(f[i + 1][b < h][min(a + 1, h)][min(c + 1, h)][d] += v) %=
1000000009;
(f[i + 1][c < h][min(a + 1, h)][min(b + 1, h)][d] += v) %=
1000000009;
(f[i + 1][k][min(a + 1, h)][min(b + 1, h)][min(c + 1, h)] += v) %=
1000000009;
}
}
int ans = 0;
for (int a = int(0), na = int(h); a <= na; a++)
for (int b = int(0), nb = int(h); b <= nb; b++)
for (int c = int(0), nc = int(h); c <= nc; c++)
for (int k = int(0), nk = int(1); k <= nk; k++)
if (a < h || b < h || c < h || k)
(ans += f[n][k][a][b][c]) %= 1000000009;
cout << ans << endl;
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
queue<pair<int, int> > bfs;
vector<int> vec[100003], gt[100003], tipe[100003];
bool visited[100003];
;
int main() {
int n, m, k, s;
scanf("%d %d %d %d", &n, &m, &k, &s);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
tipe[x].push_back(i);
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
}
for (int i = 1; i <= k; i++) {
memset(visited, 0, sizeof visited);
for (auto it : tipe[i]) {
bfs.push({it, 0});
visited[it] = 1;
gt[it].push_back(0);
}
while (bfs.size()) {
pair<int, int> curr = bfs.front();
bfs.pop();
int u = curr.first, w = curr.second;
for (int v : vec[u]) {
if (!visited[v]) {
visited[v] = 1;
gt[v].push_back(w + 1);
bfs.push({v, w + 1});
}
}
}
}
for (int i = 1; i <= n; i++) {
sort(gt[i].begin(), gt[i].end());
int sum = 0;
for (int j = 0; j < s; j++) sum += gt[i][j];
printf("%d", sum);
if (i < n) printf(" ");
}
printf("\n");
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 50;
const int MAXN = 10000 + 99;
int m, n;
bool subset(const uint8_t* A, const uint8_t* B) {
for (int i = 0; i < n; i++) {
if (A[i] < B[i]) return false;
}
return true;
}
uint8_t on_L[MAXM][MAXN];
uint8_t on_R[MAXM][MAXN];
int left(int idx) { return 2 * idx; }
int right(int idx) { return 2 * idx + 1; }
vector<int> E[MAXM];
void add_edge(int from, int to) {
;
;
assert(0 <= from && from < m);
assert(0 <= to && to < m);
E[from].push_back(to);
}
int indeg[MAXM];
bool have_cycle() {
for (int i = 0; i < m; i++) indeg[i] = 0;
for (int from = 0; from < m; from++) {
for (auto next : E[from]) indeg[next]++;
}
stack<int> indeg_zero;
for (int i = 0; i < m; i++)
if (indeg[i] == 0) indeg_zero.push(i);
int result = 0;
while (!indeg_zero.empty()) {
int from = indeg_zero.top();
indeg_zero.pop();
result++;
for (auto next : E[from]) {
indeg[next]--;
if (indeg[next] == 0) indeg_zero.push(next);
}
}
return result < m;
}
int main() {
cin >> m >> n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) on_L[i][j] = 0;
int s;
cin >> s;
for (int kk = 0; kk < s; kk++) {
int idx;
cin >> idx;
on_L[i][idx] = 1;
}
for (int j = 0; j < n; j++) on_R[i][j] = 1 ^ on_L[i][j];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
const unsigned char *B = on_R[i], *C = on_L[j];
if (subset(B, C)) {
add_edge(i, j);
}
}
}
cout << (have_cycle() ? "impossible" : "possible");
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > lr;
int n, p1, p2, p3, t1, t2;
int main() {
cin >> n >> p1 >> p2 >> p3 >> t1 >> t2;
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
lr.push_back(make_pair(l, r));
}
int num = 0;
for (int i = 0; i < lr.size(); ++i) {
num += (lr[i].second - lr[i].first) * p1;
if (i != lr.size() - 1) {
int tmp = lr[i + 1].first - lr[i].second;
if (tmp >= t1) {
num += t1 * p1;
tmp -= t1;
} else {
num += tmp * p1;
tmp = 0;
}
if (tmp >= t2) {
num += t2 * p2;
tmp -= t2;
num += tmp * p3;
tmp = 0;
} else {
num += tmp * p2;
tmp = 0;
}
}
}
cout << num << endl;
return 0;
}
| 1
|
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define orz 1000000007
using namespace std;
int T,n,a[2005],b[2005];
int main(){
scanf("%d",&T);
while(T--){
scanf("%d",&n);
for(int i=1;i<=n;++i)b[i]=1;
int k=1;
while(1){
++k;
printf("? %d 1\n",k-1);
for(int i=1;i<k-1;++i)printf("%d ",i);
printf("%d\n",k-1);
printf("%d\n",k);
fflush(stdout);
int x;
scanf("%d",&x);
if(x) break;
}
b[k]=0;
for(int i=k+1;i<=n;++i){
printf("? 1 1\n%d\n%d\n",k,i);
fflush(stdout);
int x;
scanf("%d",&x);
if(x)b[i]=0;
}
int l=1,r=k-1;
int cnt=0;
while(r>l){
int mi=(l+r)/2;
printf("? %d 1\n",mi-l+1);
for(int i=l;i<mi;++i)printf("%d ",i);
printf("%d\n",mi);
printf("%d\n",k);
fflush(stdout);
int x;
scanf("%d",&x);
if(x)r=mi;
else l=mi+1;
++cnt;
}
b[l]=0;
int m=0;
for(int i=1;i<=n;++i)if(b[i])a[++m]=i;
printf("! %d",m);
for(int i=1;i<=m;++i)printf(" %d",a[i]);
printf("\n");
fflush(stdout);
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int n, k, y, x = 0, a;
bool ok = 0;
int main() {
cin >> y >> k >> n;
a = 0;
do {
a++;
x = a * k - y;
if (x > 0 && (x + y) % k == 0 && x + y <= n) {
cout << x << " ";
ok = 1;
}
} while (y + x < n);
if (!ok) cout << "-1" << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
long long fac[N];
int main() {
fac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = fac[i - 1] * 4;
}
int t, i, j;
long long n, k;
cin >> t;
while (t--) {
cin >> n >> k;
int f = 1;
long long x = 1;
long long s;
x = fac[min(n, (long long)31)];
s = (x - 1) / 3;
if (k > s) f = 0;
if (!f || (n == 2 && k == 3)) {
cout << "NO\n";
continue;
}
long long tmp = 2;
for (i = 1; i <= n; i++) {
tmp = tmp * 2;
s = tmp - 2 - i;
if (s > k) break;
}
cout << "YES " << n - i + 1 << endl;
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int n, m, mmax, s[5005], f[1000005], smax;
bool flag[1000005];
int comp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int calcans(void) {
int ans, i, j, same;
for (ans = 1;; ans++) {
for (i = ans, same = 0; i <= smax; i += ans) {
same += f[i];
if (same > mmax) break;
}
if (same > mmax) continue;
for (i = same = 0; i < n; i++) {
if (!flag[s[i] % ans])
flag[s[i] % ans] = true;
else
same++;
if (same > m) break;
}
if (same <= m) return ans;
for (j = 0; j < i; j++) flag[s[j] % ans] = false;
}
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
mmax = (m + 1) * m / 2;
memset(f, 0, sizeof(f));
memset(flag, 0, sizeof(flag));
for (i = 0; i < n; i++) scanf("%d", &s[i]);
qsort(s, n, sizeof(int), comp);
smax = s[n - 1] - s[0];
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) f[s[j] - s[i]]++;
printf("%d\n", calcans());
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20) + 5;
bitset<MAXN> used;
vector<pair<int, int>> adj[MAXN];
int a[MAXN];
int n;
vector<int> ans;
void dfs(int x) {
while (!adj[x].empty()) {
if (used[adj[x].back().second / 2]) {
adj[x].pop_back();
continue;
}
auto p = adj[x].back();
adj[x].pop_back();
used[p.second / 2] = true;
dfs(p.first);
ans.push_back(p.second);
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < 2 * n; i++) cin >> a[i];
for (int k = 20; k >= 0; k--) {
for (int i = 0; i < n; i++) {
used[i] = false;
}
for (int i = 0; i < 2 * n; i++) a[i] = a[i] % (1 << k);
for (int i = 0; i < (1 << k); i++) adj[i].clear();
for (int i = 0; i < n; i++) {
adj[a[2 * i]].push_back(make_pair(a[2 * i + 1], 2 * i));
adj[a[2 * i + 1]].push_back(make_pair(a[2 * i], 2 * i + 1));
}
bool impossible = false;
for (int i = 0; i < (1 << k); i++) {
if (adj[i].size() % 2) {
impossible = true;
}
}
if (impossible) continue;
dfs(a[0]);
if (ans.size() == n) {
cout << k << "\n";
for (int i = n - 1; i >= 0; i--) {
cout << 1 + ans[i] << " " << 1 + (ans[i] ^ 1) << " ";
}
return 0;
}
ans.clear();
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct Dinic {
int n, m, h[10005], l[10005], s, t, w[10005];
struct eg {
int v, c, f, x;
} e[(10005 * 4)];
bool bfs() {
static int q[10005];
for (int i(0); i < n; i++) l[i] = -1;
int B(l[s] = 0), E(1);
q[0] = s;
while (B < E)
for (int k(q[B++]), i(h[k]); ~i; i = e[i].x)
if (e[i].f < e[i].c && !~l[e[i].v])
l[e[i].v] = l[k] + 1, q[E++] = e[i].v;
return ~l[t];
}
int dfs(int u, int f) {
if (u == t) return f;
int mf;
for (int i(w[u]); ~i; i = e[i].x)
if (e[i].f < e[i].c && l[u] + 1 == l[e[i].v])
if ((mf = dfs(e[i].v, min(f, e[i].c - e[i].f))) > 0)
return e[i].f += mf, e[i ^ 1].f -= mf, mf;
return 0;
}
void ini(int N, int f, int d) {
n = N;
s = f;
t = d;
m = 0;
for (int i(0); i < n; i++) h[i] = -1;
}
int ade(int u, int v, int c = 1, int rc = 0) {
e[m] = eg{v, c, 0, h[u]};
h[u] = m++;
e[m] = eg{u, rc, 0, h[v]};
h[v] = m++;
return m - 2;
}
int mf() {
int a(0), d;
while (bfs()) {
memcpy(w, h, sizeof(int) * n);
do a += d = dfs(s, int(1e9 + 1));
while (d);
}
return a;
}
} H;
int N, M, A[10005], B[10005], a, I[10005], f[10005], G[10005], C[10005];
bool ok(int t) {
H.ini(((N + M) + 1) + 1, (N + M), ((N + M) + 1));
for (int i(0); i < M; i++) H.ade((N + M), i);
for (int i(0); i < N; i++) H.ade(M + i, ((N + M) + 1), t);
for (int i(0); i < M; i++) I[i] = H.ade(i, A[i] + M), H.ade(i, B[i] + M);
return H.mf() == M;
}
bool OK(int t) {
memcpy(G, f, sizeof(f)), (memset(C, 0, sizeof(C)));
int F = 0, x, O = 0;
H.ini(((N + M) + 1) + 1, (N + M), ((N + M) + 1));
for (int i(0); i < M; i++) H.ade((N + M), i);
for (int i(0); i < N; i++) H.ade(M + i, ((N + M) + 1), t);
while (666) {
x = 0;
for (int i(0); i < M; i++) {
if (C[i]) continue;
if (G[A[i]] > t && G[B[i]] > t)
;
else
--G[A[i]], --G[B[i]], ++C[i], x = 1;
}
if (!x) break;
}
for (int i(0); i < M; i++)
if (G[A[i]] > t && G[B[i]] > t) H.ade(i, A[i] + M), H.ade(i, B[i] + M), ++F;
for (int i(0); i < N; i++) O += G[i] > t;
if (O * t < F) return 0;
return H.mf() == F;
}
int bs(int B = 0, int E = int(1e9 + 1)) {
int M;
while (B < E)
if (OK(M = (B + E) >> 1))
E = M;
else
B = M + 1;
return B;
}
int hup() {
memcpy(G, f, sizeof(f)), (memset(C, 0, sizeof(C)));
for (int i(0); i < M; i++)
if (G[A[i]] < G[B[i]])
++C[A[i]], --G[B[i]];
else
++C[B[i]], --G[A[i]];
return *max_element(C, C + N);
}
int main(void) {
scanf("%d%d", &N, &M);
for (int i(0); i < M; i++)
scanf("%d%d", A + i, B + i), ++f[--A[i]], ++f[--B[i]];
a = bs(0, hup()), printf("%d\n", a), ok(a);
for (int i(0); i < M; i++)
if (!H.e[I[i]].f)
printf("%d %d\n", B[i] + 1, A[i] + 1);
else
printf("%d %d\n", A[i] + 1, B[i] + 1);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 2e5 + 10;
int a[maxn], add[maxn];
vector<pair<int, int> > g;
int main() {
int n = read(), t = read(), k = read();
for (int i = 1; i <= t; i++) {
a[i] = read();
}
for (int i = t - 1; i >= 1; i--) {
add[i] = max(a[i + 1] - a[i], 0);
}
for (int i = t; i >= 1; i--) {
add[i] += add[i + 1];
}
int cur = 2, last = 1;
vector<int> tmp, last_node;
last_node.push_back(1);
for (int i = 1; i <= t; i++) {
tmp.clear();
for (int j = 1; j <= a[i]; j++, cur++) {
tmp.push_back(cur);
}
last += a[i] - 1;
int siz = last_node.size(), now = 0;
for (int j = 0; j < siz - 1; j++) {
if (last + add[i] > k && now < tmp.size()) {
int u = last_node[j], v = tmp[now];
g.push_back(make_pair(u, v));
last--;
now++;
}
}
while (now < tmp.size()) {
int u = last_node[siz - 1], v = tmp[now];
g.push_back(make_pair(u, v));
now++;
}
last_node.clear();
last_node = tmp;
}
if (last != k) {
cout << -1 << endl;
return 0;
}
cout << g.size() + 1 << endl;
for (auto res : g) {
cout << res.first << ' ' << res.second << endl;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 710, mod = int(1e9) + 7;
int n, f[N][N][10][2];
char s[N];
int main() {
register int i, j, k, o, p;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (i = 1; i <= 9; ++i) f[0][0][i][0] = 1;
for (i = 0; i < n; ++i)
for (j = 0; j <= i; ++j)
for (k = 1; k <= 9; ++k)
for (o = 0; o < 2; ++o)
for (p = 0; p <= (o ? 9 : s[i + 1] - '0'); ++p)
(f[i + 1][j + (p >= k)][k][o | (p < s[i + 1] - '0')] +=
f[i][j][k][o]) %= mod;
long long ans(0);
for (k = 1; k <= 9; ++k) {
long long tmp(1);
for (i = 1; i <= n; ++i, tmp = (tmp * 10 + 1) % mod)
(ans += tmp * (f[n][i][k][0] + f[n][i][k][1])) %= mod;
}
cout << ans << endl;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int size = 11111;
const long long mod = 1e9 + 7;
long long dp[2][size];
long long n, p;
long long a[size], b[size];
int main() {
cin >> n >> p;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < 2; i++)
for (int j = 0; j <= n; j++) dp[i][j] = 1e18;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[1][j + 1] = min(dp[0][j] + b[i], dp[1][j + 1]);
dp[1][j] = min(dp[0][j] + a[i] + j * p, dp[1][j]);
}
for (int j = 0; j <= n; j++) {
dp[0][j] = dp[1][j];
dp[1][j] = 1e18;
}
}
long long ans = dp[0][0];
for (int i = 0; i <= n; i++) ans = min(ans, dp[0][i]);
cout << ans << endl;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return x == 0 ? y : gcd(y % x, x); }
long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
int fx[] = {1, -1, 0, 0};
int fy[] = {0, 0, 1, -1};
int kx[] = {-2, -2, +2, +2, +1, -1, +1, -1};
int ky[] = {+1, -1, +1, -1, -2, -2, +2, +2};
int dx[] = {+0, +0, -1, +1, +1, +1, -1, -1};
int dy[] = {+1, -1, +0, +0, -1, +1, +1, -1};
int X[] = {+1, +1, -1, -1};
int Y[] = {+1, -1, +1, -1};
int cnt = 0;
int dis[20];
bool vis[10001];
vector<int> adj[1000011];
int main() {
int a, b, c, root = 1, n, m;
cin >> n >> m;
vector<pair<int, int> > v;
map<pair<int, int>, int> mp;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
vis[a] = true;
vis[b] = true;
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
root = i;
break;
}
}
for (int i = 1; i <= n; i++) {
if (root == i) continue;
v.push_back(make_pair(root, i));
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, sol, i, fi, se, th, temp;
priority_queue<long long> Q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
sol = 0;
for (i = 0; i < 3; i++) {
Q.push(b);
}
while (true) {
fi = Q.top(), Q.pop();
se = Q.top(), Q.pop();
th = Q.top(), Q.pop();
temp = min(fi + se - 1, a);
if (temp == a) {
sol += 3;
break;
}
sol++;
Q.push(temp), Q.push(fi), Q.push(se);
}
cout << sol << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, l = 0, f = 1, s;
vector<int> a, b, c;
cin >> n >> m;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < 0) l++;
}
if (m < l) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++) {
if (a[i] < 0 && f) {
f = 0;
b.push_back(i);
} else if (a[i] >= 0 && !f) {
f = 1;
b.push_back(i);
}
}
m -= l;
s = b.size();
for (int i = 1; i + 1 < b.size(); i += 2) c.push_back(b[i + 1] - b[i]);
if (c.size()) sort(c.begin(), c.end());
for (int i = 0; i < c.size(); i++)
if (c[i] <= m) {
m -= c[i];
s -= 2;
}
if (b.size() && a[a.size() - 1] >= 0 && m >= n - b[b.size() - 1]) s--;
cout << s;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int dp[5009][5009][2];
int a[5009];
int n;
int func(int i, int k, bool f) {
if (k < 0) {
return 1000000009;
}
if (k == 0) {
return 0;
}
if (i > n) {
return 1000000009;
}
if (a[i] > a[i - 1]) f = false;
if (~dp[i][k][f]) return dp[i][k][f];
int res = func(i + 1, k, true);
if (!f) {
if (a[i] > a[i + 1]) {
res = min(res, func(i + 2, k - 1, true));
} else {
res = min(res, a[i + 1] - a[i] + 1 + func(i + 3, k - 1, true));
if (a[i + 2] >= a[i]) {
res = min(res, a[i + 1] - a[i] + 1 + func(i + 2, k - 1, false));
} else {
res = min(res, a[i + 1] - a[i + 2] + 1 + func(i + 2, k - 1, false));
}
}
} else {
int cl = 0;
if (a[i] <= a[i - 1]) cl = a[i - 1] - a[i] + 1;
if (a[i] > a[i + 1]) {
res = min(res, cl + func(i + 2, k - 1, true));
} else {
res = min(res, cl + a[i + 1] - a[i] + 1 + func(i + 3, k - 1, true));
if (a[i + 2] >= a[i]) {
res = min(res, cl + a[i + 1] - a[i] + 1 + func(i + 2, k - 1, false));
} else {
res =
min(res, cl + a[i + 1] - a[i + 2] + 1 + func(i + 2, k - 1, false));
}
}
}
return dp[i][k][f] = res;
}
int main() {
int k, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(dp, -1, sizeof(dp));
for (k = 1; k <= (n + 1) / 2; k++) {
if (k > 1) printf(" ");
printf("%d", func(1, k, false));
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, m, fa[maxn][30], lg[maxn], dep[maxn], vis[maxn], f[maxn];
long long sum, mcost[maxn][30], ans[maxn];
struct node {
int x, y, z, id;
} p[maxn];
struct NODE {
int y, z;
};
vector<NODE> mp[maxn];
bool cmp(node a, node b) { return a.z < b.z; }
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void dfs(int x, int fd, int val) {
dep[x] = dep[fd] + 1;
mcost[x][0] = val;
fa[x][0] = fd;
for (int i = 1; i <= lg[dep[x]]; i++) {
fa[x][i] = fa[fa[x][i - 1]][i - 1];
mcost[x][i] = max(mcost[x][i - 1], mcost[fa[x][i - 1]][i - 1]);
}
for (int i = 0; i < mp[x].size(); i++) {
if (mp[x][i].y != fd) dfs(mp[x][i].y, x, mp[x][i].z);
}
}
long long lca(int x, int y) {
long long res = 0;
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] != dep[y]) {
int d = lg[dep[x] - dep[y]] - 1;
res = max(res, mcost[x][d]);
x = fa[x][d];
}
if (x == y) return res;
for (int i = lg[dep[x]] - 1; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
res = max(res, max(mcost[x][i], mcost[y][i]));
x = fa[x][i], y = fa[y][i];
}
}
res = max(res, max(mcost[x][0], mcost[y][0]));
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &p[i].x, &p[i].y, &p[i].z);
p[i].id = i;
}
sort(p + 1, p + 1 + m, cmp);
for (int i = 1; i <= m; i++) {
int fx = find(p[i].x), fy = find(p[i].y);
if (fx != fy) {
f[fx] = fy;
sum += 1ll * p[i].z;
mp[p[i].x].push_back({p[i].y, p[i].z});
mp[p[i].y].push_back({p[i].x, p[i].z});
}
}
dfs(1, 0, 0);
for (int i = 1; i <= m; i++) {
ans[p[i].id] = sum - lca(p[i].x, p[i].y) + p[i].z;
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
inline int nextint() {
int x;
scanf("%d", &x);
return x;
}
inline long long nextll() {
long long x;
scanf("%lld", &x);
return x;
}
template <typename T>
void scanint(T &x) {
T c = getchar();
while (((c < 48) || (c > 57)) && (c != '-')) c = getchar();
bool neg = false;
if (c == '-') neg = true;
x = 0;
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x * 10) + (c - 48);
if (neg) x = -x;
}
template <typename T>
T min_(T a, T b) {
return a > b ? b : a;
}
template <typename T, typename... Ts>
T min_(T first, Ts... last) {
return min_(first, min_(last...));
}
template <class T, class S>
std::ostream &operator<<(std::ostream &os, const std::pair<T, S> &t) {
os << "(" << t.first << ", " << t.second << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
size_t last = v.size() - 1;
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
if (i != last) out << ", ";
}
out << "]";
return out;
}
long long pwr(long long base, long long p, long long mod) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
const long double PI = (long double)(3.1415926535897932384626433832795);
const long long mx_ll = numeric_limits<long long>::max();
const int mx_int = numeric_limits<int>::max();
const int mod = 1e9 + 7;
int cnt[1001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<int> inp;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
inp.push_back(x);
cnt[x] += 1;
}
if (n == 1 || (cnt[inp[0]] == n)) {
cout << 0 << "\n";
return 0;
}
sort(inp.begin(), inp.end());
int D1 = inp[n - 1] - inp[0];
bool ok1 = true;
for (int i = 0; i <= n - 2; i++) {
if (inp[i] == inp[n - 1]) continue;
if (inp[i] + D1 != inp[n - 1]) {
ok1 = false;
break;
}
}
int D2 = (D1 % 2 == 0) ? D1 / 2 : -1;
if (D2 == -1) {
if (ok1) {
cout << D1 << "\n";
} else {
cout << -1 << "\n";
}
} else {
if (cnt[inp[0]] + cnt[D2 + inp[0]] + cnt[inp[n - 1]] != n) {
cout << -1 << "\n";
} else {
cout << D2 << "\n";
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int n, m, a, b, p[N], u[N], mx, idx, t, c;
bool tkn[N];
void f() {
for (;;) {
mx = -1;
idx = -1;
for (int i = 1; i <= 2 * n; i++) {
if (tkn[i]) continue;
if (u[i] != -1) {
if (p[i] > p[u[i]])
idx = i;
else
idx = u[i];
break;
}
if (mx < p[i]) {
mx = p[i];
idx = i;
}
}
if (idx == -1) return;
tkn[idx] = 1;
cout << idx << "\n";
cout.flush();
cin >> idx;
if (idx == -1) return;
tkn[idx] = 1;
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= 2 * n; i++) {
cin >> p[i];
u[i] = -1;
tkn[i] = 0;
}
for (int i = 1; i <= m; i++) {
cin >> a >> b;
u[a] = b;
u[b] = a;
}
cin >> t;
if (t == 1) {
f();
} else {
cin >> idx;
if (idx == -1) return;
tkn[idx] = 1;
c = 1;
while (u[idx] != -1) {
idx = u[idx];
tkn[idx] = 1;
c++;
cout << idx << "\n";
cout.flush();
if (c == 2 * n) break;
cin >> idx;
if (idx == -1) return;
tkn[idx] = 1;
c++;
}
if (c == 2 * n) return;
f();
}
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long val[n];
for (long long i = 0; i < n; i++) {
cin >> val[i];
}
for (long long i = 0; i < n; i++) {
for (long long j = n - 1; j > i; j--) {
if (val[j] < val[j - 1]) {
swap(val[j], val[j - 1]);
cout << j << ' ' << j + 1 << '\n';
}
}
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int N, x, k, v[100100];
int main() {
for (int i = 0; i <= 100000; ++i) {
v[i] = -1;
}
cin >> N;
for (int i = 1; i <= N; ++i) {
cin >> x >> k;
if (x > v[k]) {
if (x == v[k] + 1) {
++v[k];
} else {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int a[100111];
int b[100111];
int c[100111];
int p[100111];
int pp[100111];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
c[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
cin >> b[i];
p[i] = c[b[i]];
}
for (int i = 1; i <= n; ++i)
if (i == n)
cout << p[i] << endl;
else
cout << p[i] << " ";
return 0;
}
| 4
|
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int size[100010], head[100010], nxt[200010], end[200010], dfn[100010],
dg[100010], fa[100010];
int idx = 0, cou = 0;
long long f[100010];
void link(int a, int b) {
nxt[++cou] = head[a];
head[a] = cou;
end[cou] = b;
}
void dfs(int cur, int last) {
std::vector<int> vec;
size[cur] = 1;
fa[cur] = last;
int cnt = 0;
long long max = -2147483647, min = 2147483647;
for (int x = head[cur]; x != -1; x = nxt[x]) {
if (end[x] != last) {
dfs(end[x], cur);
vec.push_back(f[end[x]]);
max = std::max(max, f[end[x]]);
min = std::min(min, f[end[x]]);
cnt++;
}
}
if (max == -2147483647) {
f[cur] = dg[cur];
} else if (min == -1 || max != min) {
f[cur] = -1;
} else if (max == min) {
f[cur] = (min * 100010 + dg[cur]) % 19260817;
}
if (f[cur] != -1 && cur == 1) {
printf("1\n");
exit(0);
}
}
void dfs2(int cur, int last, long long pre) {
std::multiset<long long> s;
if (cur != 1) s.insert(pre);
for (int x = head[cur]; x != -1; x = nxt[x])
if (end[x] != last) s.insert(f[end[x]]);
if (cur != 1 && (s.empty() || *s.begin() == *s.rbegin())) {
printf("%d\n", cur);
exit(0);
}
for (int x = head[cur]; x != -1; x = nxt[x]) {
if (end[x] != last) {
s.erase(s.find(f[end[x]]));
if (s.empty())
dfs2(end[x], cur, 1);
else if (*s.begin() != -1 && *s.begin() == *s.rbegin())
dfs2(end[x], cur, (*s.begin() * 100010 + dg[cur]) % 19260817);
s.insert(f[end[x]]);
}
}
}
int main() {
int n = inp();
memset(head, -1, sizeof(head));
for (int i = 1; i < n; i++) {
int u = inp();
int v = inp();
link(u, v);
link(v, u);
dg[u]++;
dg[v]++;
}
dfs(1, 0);
dfs2(1, 0, 0);
printf("-1\n");
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long maxn = 2005;
const long long inf = 1ll << 50;
int mp[10] = {119, 36, 93, 109, 46, 107, 123, 37, 127, 111};
long long disp[maxn], ans[maxn];
long long dp[maxn][maxn];
long long n, k;
bool is_possible(int index, int rem) {
if (rem < 0) {
return false;
}
if (index == n) {
return rem == 0;
}
if (dp[index][rem] != -1) {
return dp[index][rem];
}
bool res = false;
for (int i = 9; i >= 0; i--) {
bool test = ((mp[i] & disp[index]) != disp[index]);
if (test) continue;
auto calculate_loss = [](long long a, long long b) {
return __builtin_popcount(a ^ b);
};
long long loss = calculate_loss(disp[index], mp[i]);
if (is_possible(index + 1, rem - loss)) {
res = true;
break;
}
}
return dp[index][rem] = res;
}
void get_largest_number(int index, int rem) {
if (index == n) {
return;
}
for (int i = 9; i >= 0; i--) {
bool test = ((mp[i] & disp[index]) != disp[index]);
if (test) continue;
auto calculate_loss = [](long long a, long long b) {
return __builtin_popcount(a ^ b);
};
long long loss = calculate_loss(disp[index], mp[i]);
if (is_possible(index + 1, rem - loss)) {
ans[index] = i;
get_largest_number(index + 1, rem - loss);
return;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
reverse(str.begin(), str.end());
disp[i] = bitset<7>(str).to_ullong();
}
if (is_possible(0, k)) {
get_largest_number(0, k);
for (int i = 0; i < n; i++) {
cout << ans[i];
}
} else {
cout << -1 << endl;
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
char s[311];
void input() { scanf("%s", &s); }
void solve() {
int resp = 0, resm = 0, a = 0;
for (int i = 0; i < strlen(s); i++) {
if (s[i] == '+')
a++;
else
a--;
resp = max(resp, a);
resm = max(resm, -a);
}
cout << resp + resm << endl;
}
int main() {
input();
solve();
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int mass[101];
int n;
int i;
cin >> n;
i = 0;
while (i < n) {
cin >> mass[i];
i = i + 1;
}
std::sort(mass, mass + n);
for (i = 0; i < n; ++i) std::cout << mass[i] << ' ';
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, -1, 1};
const int N = 101;
int n, k;
vector<pair<long long, long long> > v;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
v.push_back(make_pair(x, i + 1));
}
sort(v.begin(), v.end());
vector<long long> ans;
for (int i = 0; i < v.size(); ++i) {
if (v[i].first <= k) {
k -= v[i].first;
ans.push_back(v[i].second);
} else
break;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
}
int n, v[100005], dp[100005];
int main() {
read(n);
int sm = n * (n + 1) / 2;
if (sm & 1)
puts("1");
else
puts("0");
printf("%d ", n >> 1);
for (int i = n, c = 1; i > 1; i -= 2) printf("%d ", i - (c ^= 1));
return putchar('\n'), 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, p, q;
} save[10000];
struct node1 {
int x, y;
};
int cnt;
int n;
int g[55][55];
int tmp[55];
int mark[66][66];
void bfs() {
node1 que[20000];
int qf, qd;
qf = 1;
qd = 0;
mark[1][1] = 0;
que[0].x = 1;
que[0].y = 1;
while (qf > qd) {
node1 cur, nwnode;
cur = que[qd++];
for (int i = 0; i < 2; i++) {
int x, y;
if (i == 0) {
x = cur.x + 1;
y = cur.y;
} else {
x = cur.x;
y = cur.y + 1;
}
if (x >= 1 && x <= n && y >= 1 && y <= tmp[x] && mark[x][y] == 0) {
mark[x][y] = 1;
int xi, yi;
int mi = 99999;
for (int i1 = x; i1 <= n; i1++)
for (int j = y; j <= tmp[i1]; j++)
if (g[i1][j] < mi) {
mi = g[i1][j];
xi = i1;
yi = j;
}
if (mi == 99999) continue;
if (xi == x && yi == y) {
;
} else {
save[cnt].x = x;
save[cnt].y = y;
save[cnt].p = xi;
save[cnt].q = yi;
cnt++;
}
g[xi][yi] = 99999;
swap(g[x][y], g[xi][yi]);
nwnode.x = x;
nwnode.y = y;
que[qf++] = nwnode;
}
}
}
}
int main() {
cnt = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &tmp[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= tmp[i]; j++) {
scanf("%d", &g[i][j]);
}
}
int mi = 99999;
int xi, xj;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= tmp[i]; j++) {
if (g[i][j] < mi) {
mi = g[i][j];
xi = i;
xj = j;
}
}
if (xi == 1 && xj == 1) {
;
} else {
save[cnt].x = 1;
save[cnt].y = 1;
save[cnt].p = xi;
save[cnt].q = xj;
cnt++;
}
g[xi][xj] = 99999;
swap(g[1][1], g[xi][xj]);
bfs();
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++)
printf("%d %d %d %d\n", save[i].x, save[i].y, save[i].p, save[i].q);
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
bool tri(int a, int b, int c) { return (a + b > c && b + c > a && c + a > b); }
bool seg(int a, int b, int c) {
return (a + b == c || b + c == a || a + c == b);
}
void solve() {
bool triangle;
bool segment;
int a, b, c, d;
cin >> a >> b >> c >> d;
triangle = tri(a, b, c);
triangle |= tri(a, b, d);
triangle |= tri(c, b, d);
triangle |= tri(a, c, d);
segment = seg(a, b, c);
segment |= seg(a, b, d);
segment |= seg(a, d, c);
segment |= seg(d, b, c);
if (triangle) {
cout << "TRIANGLE";
} else if (segment) {
cout << "SEGMENT";
} else {
cout << "IMPOSSIBLE";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 18 | 1;
inline char nc() {
static char ibuf[RLEN], *ib, *ob;
(ib == ob) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ib == ob) ? -1 : *ib++;
}
inline int rd() {
char ch = nc();
int i = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = nc();
}
while (isdigit(ch)) {
i = (i << 1) + (i << 3) + ch - '0';
ch = nc();
}
return i * f;
}
inline void W(int x) {
static int buf[50];
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
buf[++buf[0]] = x % 10;
x /= 10;
}
while (buf[0]) {
putchar(buf[buf[0]--] + '0');
}
}
const int N = 1e5 + 50, B = 200, L = 18;
int n, w, q, ans[N], nxt[N];
int lg[N], x[N], rmq_mx[N][20], rmq_mn[N][20];
vector<pair<int, int> > det;
vector<pair<int, int> > ask;
struct node {
node *fa, *lc, *rc;
int id, sze;
node() : fa(NULL), lc(NULL), rc(NULL), sze(0) {}
inline void upt() { sze = (lc ? lc->sze : 0) + (rc ? rc->sze : 0) + 1; }
} * pos[N];
inline bool isroot(node *x) {
return (!x->fa) || (x->fa->lc != x && x->fa->rc != x);
}
inline bool which(node *x) { return (x->fa->lc == x); }
inline void rotate(node *x) {
node *y = x->fa, *z = y->fa;
if (!isroot(y)) (z->lc == y ? z->lc : z->rc) = x;
x->fa = z;
y->fa = x;
if (y->lc == x) {
node *b = x->rc;
x->rc = y;
y->lc = b;
if (b) b->fa = y;
} else {
node *b = x->lc;
x->lc = y;
y->rc = b;
if (b) b->fa = y;
}
y->upt();
x->upt();
}
inline void splay(node *x) {
while (!isroot(x)) {
node *y = x->fa;
if (!isroot(y)) {
if (which(y) == which(x))
rotate(y);
else
rotate(x);
}
rotate(x);
}
}
inline void access(node *x) {
for (node *y = NULL; x; y = x, x = x->fa) {
splay(x);
x->rc = y;
x->upt();
}
}
inline void cut(node *x, node *f) {
access(f);
splay(x);
x->fa = NULL;
}
inline void link(node *x, node *f) { x->fa = f; }
inline void modify(int lim) {
static int p = 0;
while (p < det.size() && det[p].first <= lim) {
int u = det[p++].second;
if (nxt[u] + u > n)
continue;
else if ((++nxt[u]) == B) {
cut(pos[u], pos[u + nxt[u]]);
} else {
cut(pos[u], pos[u + nxt[u]]);
link(pos[u], pos[u + nxt[u] + 1]);
}
}
}
inline node *getroot(node *x) {
while (x->lc) x = x->lc;
splay(x);
return x;
}
inline int find_nxt(int now, int lim) {
int mx = x[now], mn = x[now];
for (int i = lg[n - now + 1]; ~i && now <= n; i--) {
if ((now + (1 << i) - 1 <= n) &&
max(mx, rmq_mx[now][i]) - min(mn, rmq_mn[now][i]) <= lim) {
mx = max(mx, rmq_mx[now][i]);
mn = min(mn, rmq_mn[now][i]);
now += (1 << i);
}
}
return now;
}
inline int query(int lim) {
int now = 1, cnt = 0;
while (now <= n) {
access(pos[now]);
splay(pos[now]);
cnt += pos[now]->sze - 1;
now = getroot(pos[now])->id;
if (now != n + 1) ++cnt, now = find_nxt(now, lim);
}
return cnt;
}
int main() {
n = rd(), w = rd(), q = rd();
lg[1] = 0;
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; i++) rmq_mn[i][0] = rmq_mx[i][0] = x[i] = rd();
for (int i = 1; i <= lg[n]; i++)
for (int j = 1; j + (1 << i) - 1 <= n; ++j)
rmq_mn[j][i] = min(rmq_mn[j][i - 1], rmq_mn[j + (1 << (i - 1))][i - 1]),
rmq_mx[j][i] = max(rmq_mx[j][i - 1], rmq_mx[j + (1 << (i - 1))][i - 1]);
pos[n + 1] = new node();
pos[n + 1]->id = n + 1;
for (int i = n; i >= 1; i--) {
pos[i] = new node();
pos[i]->fa = pos[i + 1];
pos[i]->sze = 1;
pos[i]->id = i;
}
for (int i = 1; i <= n; i++) {
int mx = x[i], mn = x[i];
for (int j = 1; j <= B && i + j <= n; j++) {
mx = max(mx, x[i + j]);
mn = min(mn, x[i + j]);
det.push_back(pair<int, int>(mx - mn, i));
}
}
sort(det.begin(), det.end());
for (int i = 1; i <= q; i++) {
int k = w - rd();
ask.push_back(pair<int, int>(k, i));
}
sort(ask.begin(), ask.end());
for (int i = 0; i < ask.size(); ++i) {
modify(ask[i].first);
ans[ask[i].second] = query(ask[i].first) - 1;
}
for (int i = 1; i <= q; i++) W(ans[i]), putchar('\n');
}
| 26
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
int main() {
ios_base::sync_with_stdio(false);
map<char, char> xd;
xd['A'] = 'A';
xd['b'] = 'd';
xd['d'] = 'b';
xd['H'] = 'H';
xd['I'] = 'I';
xd['M'] = 'M';
xd['O'] = 'O';
xd['o'] = 'o';
xd['p'] = 'q';
xd['q'] = 'p';
xd['T'] = 'T';
xd['U'] = 'U';
xd['V'] = 'V';
xd['v'] = 'v';
xd['W'] = 'W';
xd['w'] = 'w';
xd['X'] = 'X';
xd['x'] = 'x';
xd['Y'] = 'Y';
string s;
cin >> s;
for (int i = 0, j = s.size() - 1; i <= j; ++i, --j)
if (xd[s[i]] != s[j]) {
cout << "NIE";
return 0;
}
cout << "TAK";
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
void dfs(int v, vector<int> &col, vector<int> &ts, vector<vector<int> > &g) {
col[v] = 1;
for (auto u : g[v])
if (col[u] == 0) {
dfs(u, col, ts, g);
}
ts.push_back(v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, t;
cin >> n >> m >> t;
vector<vector<int> > g(n);
vector<int> in(n);
vector<vector<int> > con(n, vector<int>(n));
for (int(i) = 0; (i) != (m); (i)++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
con[a][b] = 1;
in[b]++;
}
vector<int> ts, col(n);
for (int(i) = 0; (i) != (n); (i)++) {
if (in[i] == 0 && !col[i]) {
dfs(i, col, ts, g);
}
}
struct edit {
char c;
int fr, to;
};
vector<edit> edits;
int b = min(n, 20);
for (int i = 0; i < b; i++) {
for (int j = i + 1; j < b; j++) {
int fr = ts[j], to = ts[i];
if (!con[fr][to]) {
con[fr][to] = 1;
edits.push_back({'+', fr + 1, to + 1});
}
}
}
for (int i = b; i < n; i++) {
int v = ts[i];
edits.push_back({'+', v + 1, v + 1});
}
vector<int> have(1 << b, -1);
for (int i = b; i < n; i++) {
int v = ts[i];
int mask = 0;
for (int j = 0; j < b; j++) {
if (con[v][ts[j]]) mask += (1 << j);
}
int t = 0;
for (int edit = 0; !t && edit <= b; edit++) {
vector<int> e(b);
for (int j = b - 1; j >= b - edit; j--) e[j] = 1;
while (!t) {
int mask2 = mask;
for (int j = 0; j < b; j++) {
if (e[j]) mask2 ^= (1 << j);
}
if (have[mask2] == -1) {
t = 1;
have[mask2] = v;
for (int j = 0; j < b; j++) {
if (e[j] && (mask & (1 << j))) {
edits.push_back({'-', v + 1, ts[j] + 1});
con[v][ts[j]] = 0;
}
if (e[j] && !(mask & (1 << j))) {
edits.push_back({'+', v + 1, ts[j] + 1});
con[v][ts[j]] = 1;
}
}
}
if (!next_permutation(e.begin(), e.end())) break;
}
}
}
cout << edits.size() << "\n";
for (auto e : edits) {
cout << e.c << " " << e.fr << " " << e.to << "\n";
}
cout << endl;
while (t--) {
vector<string> res(b);
for (int j = 0; j < b; j++) {
cout << "? 1 " << ts[j] + 1 << "\n";
}
cout << endl;
int mask = 0, fail = -1;
for (int j = 0; j < b; j++) {
cin >> res[j];
if (res[j] == "Lose") {
assert(fail == -1);
fail = ts[j];
} else {
if (res[j] == "Win") {
mask += (1 << j);
}
}
}
if (fail != -1) {
cout << "! " << fail + 1 << endl;
string s;
cin >> s;
continue;
}
cout << "! " << have[mask] + 1 << endl;
string s;
cin >> s;
}
}
| 26
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.