solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long a[100005], n;
queue<long long> q;
long long f(long long x) {
long long j = 0;
for (int i = 1; i <= n; i++) j += min(a[i], x);
return j;
}
int main() {
long long m, i, j, k, l, r, mid, ans;
scanf("%lld", &n);
scanf("%lld", &m);
j = 0;
k = 0;
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
k = max(k, a[i]);
j += a[i];
}
if (j < m) {
printf("-1\n");
return 0;
}
l = 0;
r = k;
ans = 0;
while (l <= r) {
mid = (l + r) / 2;
j = f(mid);
if (j == m) {
ans = mid;
break;
}
if (j < m) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
for (i = 1; i <= n; i++) {
if (a[i] > ans) q.push(i);
}
j = f(ans);
j = m - j;
for (i = 0; i < j; i++) {
k = q.front();
q.pop();
if (a[k] > ans + 1) q.push(k);
}
while (!q.empty()) {
j = q.front();
q.pop();
printf("%lld ", j);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k, l;
cin >> n >> m >> k >> l;
long long int x = n - k;
if (n < m || x < l) {
cout << -1;
return 0;
}
if ((l + k) <= m) {
cout << 1;
return 0;
} else {
x = (l + k) / m + ((l + k) % m != 0);
if (x * m > n) {
cout << -1;
} else {
cout << x;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<char>> vec(2001, vector<char>(2001));
queue<pair<int, int>> q;
int valid(int x, int y) {
if (x >= n || y >= m || x < 0 || y < 0 || vec[x][y] != '.') return 0;
return 1;
}
void func(int x, int y) {
if (valid(x + 1, y) + valid(x - 1, y) + valid(x, y + 1) + valid(x, y - 1) ==
1) {
q.push({x, y});
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int count = 0;
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j <= m - 1; j++) {
cin >> vec[i][j];
if (vec[i][j] == '.') {
count++;
}
}
}
if (count % 2) {
cout << "Not unique";
return 0;
}
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j <= m - 1; j++) {
func(i, j);
}
}
while (q.empty() == false) {
pair<int, int> t = q.front();
q.pop();
int x = t.first;
int y = t.second;
if (valid(x, y)) {
if (valid(x + 1, y)) {
vec[x][y] = '^';
vec[x + 1][y] = 'v';
func(x + 2, y);
func(x + 1, y - 1);
func(x + 1, y + 1);
} else if (valid(x - 1, y)) {
vec[x][y] = 'v';
vec[x - 1][y] = '^';
func(x - 2, y);
func(x - 1, y - 1);
func(x - 1, y + 1);
} else if (valid(x, y + 1)) {
vec[x][y] = '<';
vec[x][y + 1] = '>';
func(x + 1, y + 1);
func(x, y + 2);
func(x - 1, y + 1);
} else if (valid(x, y - 1)) {
vec[x][y] = '>';
vec[x][y - 1] = '<';
func(x + 1, y - 1);
func(x, y - 2);
func(x - 1, y - 1);
} else {
cout << "Not unique" << endl;
return 0;
}
}
}
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j <= m - 1; j++) {
if (vec[i][j] == '.') {
cout << "Not unique";
return 0;
}
}
}
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j <= m - 1; j++) {
cout << vec[i][j];
}
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long res;
while (cin >> n) {
res = 1.5 * n;
cout << res << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::sort;
const int fin = 0, maxn = 100010;
int n;
struct rec {
int x, y;
} a[maxn];
int f[maxn];
inline bool cmp(const rec &a, const rec &b) {
return (a.x == b.x) ? (a.y > b.y) : (a.x > b.x);
}
int main() {
if (fin) {
freopen("t.in", "r", stdin);
freopen("t.out", "w", stdout);
}
int ans, tans, i, x, y, l, r, m, V, w;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i].x, &a[i].y);
scanf("%d", &V);
for (i = 1; i <= n; ++i) {
x = a[i].x, y = a[i].y;
a[i].x = V * y + x, a[i].y = V * y - x;
}
sort(a + 1, a + n + 1, cmp);
ans = 0;
for (i = 1; i <= n; ++i) {
w = a[i].y;
for (l = 1, r = ans; l <= r;)
if (m = l + r >> 1, f[m] >= w)
l = m + 1;
else
r = m - 1;
f[l] = w;
if (l > ans) ans = l;
}
tans = ans, ans = 0;
a[n + 1].x = a[n + 1].y = 0;
sort(a + 1, a + n + 2, cmp);
for (i = 1; i <= n + 1; ++i) {
w = a[i].y;
for (l = 1, r = ans; l <= r;)
if (m = l + r >> 1, f[m] >= w)
l = m + 1;
else
r = m - 1;
f[l] = w;
if (l > ans) ans = l;
if (a[i].x == 0 && a[i].y == 0) break;
}
printf("%d %d", l - 1, tans);
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pb push_back
#define mp make_pair
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define FORR(i,a,b) for(int i=a;i>=b;i--)
#define FORP(i,x) for(int i=2;i*i<=x;i++)
#define ff first
#define ss second
#define endl "\n"
#define vi vector<ll>
#define vpl vector<pair<ll,ll>>
#define all(x) x.begin(),x.end()
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cout.setf(ios::fixed); cout.setf(ios::showpoint);
#define test ll t; cin>>t; while(t--)
void solve()
{
ll n,k;
cin>>n>>k;
ll x=0,r;
FOR(i,0,n)
{
ll d=i^x;
cout<<d<<endl;
cout.flush();
x=x^d;
cin>>r;
if(r)
return;
}
return;
}
int main()
{
fast;
test
{
solve();
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> de;
string s;
bool can(int a[], int i1, int j1) {
int i = i1, j = j1;
for (int k = 0; k < s.size(); k++) {
int idx = s[k] - '0';
if (a[idx] == 1)
i--;
else if (a[idx] == 2)
j++;
else if (a[idx] == 3)
i++;
else if (a[idx] == 4)
j--;
if (i >= n || j >= m || i < 0 || j < 0) return 0;
if (de[i][j] == '#') return 0;
if (de[i][j] == 'E') return 1;
}
return 0;
}
int main() {
cin >> n >> m;
de.resize(n);
for (int i = 0; i < n; i++) cin >> de[i];
cin >> s;
int x, y;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (de[i][j] == 'S') x = i, y = j;
}
int a[4] = {1, 2, 3, 4}, ans = 0;
do {
if (can(a, x, y)) ans++;
} while (next_permutation(a, a + 4));
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, k;
long long d[400100];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long busca(long long v1, long long v2) {
for (int i = 0; i < v1; i++) d[i] = -1;
queue<long long> f;
d[v1] = 0;
f.push(v1);
while (f.size()) {
long long v = f.front();
f.pop();
if (v == v2) return d[v];
for (int i = 2; i < k + 1; i++) {
long long w = v - v % i;
if (d[w] == -1) {
d[w] = d[v] + 1LL;
f.push(w);
}
}
if (d[v - 1] == -1) {
d[v - 1] = d[v] + 1LL;
f.push(v - 1);
}
}
}
int main() {
cin >> b >> a >> k;
long long mmc = 1LL;
for (int i = 2; i < k + 1; i++) mmc = mmc * i / gcd(mmc, i);
if (b / mmc == a / mmc)
cout << busca(b % mmc, a % mmc) << endl;
else {
long long rsp = busca(b % mmc, 0) + busca(mmc - 1, a % mmc) + 1LL;
long long qtd = b / mmc - a / mmc - 1LL;
rsp += qtd * (busca(mmc - 1, 0) + 1LL);
cout << rsp << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
int m = y * n;
if (m % 100 > 0)
m = (m / 100) + 1;
else
m = m / 100;
int left = m - x;
if (left < 0)
cout << 0;
else
cout << left;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], cnt[100005];
int L, R;
int LL, RR;
map<int, int> mp_part, mp_LR;
map<int, int>::iterator it;
long long int ans = 0, n;
bool check_segment(int m, bool left) {
if (left && m < LL || !left && m >= RR) return false;
mp_part.clear();
int len1 = m - L + 1;
int len2 = R - m;
if (len1 < len2) {
for (int i = L; i <= m; ++i) ++mp_part[a[i]];
for (it = mp_part.begin(); it != mp_part.end(); ++it) {
if (it->second > (mp_LR[it->first] >> 1)) return false;
}
} else {
for (int i = m + 1; i <= R; ++i) ++mp_part[a[i]];
for (it = mp_part.begin(); it != mp_part.end(); ++it) {
if (it->second > (mp_LR[it->first] >> 1)) return false;
}
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
++cnt[a[i]];
}
int odd_num = 0;
for (int i = 1; i <= n; ++i) {
if (cnt[i] & 1) ++odd_num;
if (odd_num >= 2) {
printf("0\n");
return 0;
}
}
L = 1, R = n;
while (a[L] == a[R] && L < R) {
++L;
--R;
}
if (L - R == 0 || L - R == 1) {
printf("%I64d\n", ((n * (n + 1)) >> 1));
return 0;
}
if ((R - L + 1) & 1)
LL = RR = (R + L) >> 1;
else {
LL = (R + L) >> 1;
RR = LL + 1;
}
while (a[LL] == a[RR]) {
--LL;
++RR;
}
for (int i = L; i <= R; ++i) ++mp_LR[a[i]];
int l = L, r = R;
int m = l + (r - l) >> 1;
while (r - l > 4) {
if (check_segment(m, true)) {
r = m;
m = (r + l) >> 1;
} else {
l = m;
m = (r + l) >> 1;
}
}
while (check_segment(r, true)) --r;
ans -= r - L + 2;
l = L, r = R, m = l + (r - l) / 2;
while (r - l > 4) {
if (check_segment(m, false)) {
l = m;
m = (r + l) >> 1;
} else {
r = m;
m = (r + l) >> 1;
}
}
while (check_segment(l, false)) ++l;
ans -= R - l + 1;
ans = (ans + (n + 3 * (R - L + 1)) / 2 + 1) * ((n - (R - L + 1)) / 2 + 1);
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2009;
int n, m, q, ans = 0;
int lm[M][M], rm[M][M], ql[M], qr[M];
char s[M][M];
vector<pair<int, int> > op;
vector<int> sum;
void change(int x) {
rm[x][m + 1] = m + 1;
for (int i = 1; i <= m; ++i) lm[x][i] = s[x][i] == 'X' ? i : lm[x][i - 1];
for (int i = m; i >= 1; --i) rm[x][i] = s[x][i] == 'X' ? i : rm[x][i + 1];
}
bool ask(int x, int li) {
int lb = 1, le = 0, rb = 1, re = 0;
for (int i = 1; i <= n; ++i) {
while (le >= lb && i - ql[lb] + 1 > li) lb++;
while (re >= rb && i - qr[rb] + 1 > li) rb++;
while (le >= lb && lm[i][x] > lm[ql[le]][x]) le--;
while (re >= rb && rm[i][x] < rm[qr[re]][x]) re--;
ql[++le] = i;
qr[++re] = i;
if (i >= li && rm[qr[rb]][x] - lm[ql[lb]][x] - 1 >= li) return 1;
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
for (int i = 1, x, y; i <= q; ++i) {
scanf("%d%d", &x, &y);
s[x][y] = 'X';
op.push_back({x, y});
}
for (int i = 1; i <= n; ++i) change(i);
for (int i = 1; i <= m; ++i)
while (ask(i, ans + 1)) ans++;
reverse(op.begin(), op.end());
for (auto o : op) {
sum.push_back(ans);
int x = o.first, y = o.second;
s[x][y] = '.';
change(x);
while (ask(y, ans + 1)) ans++;
}
reverse(sum.begin(), sum.end());
for (auto o : sum) printf("%d\n", o);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 1000 * 100 + 10;
vector<int> g[maxn];
set<pair<int, int> > s;
int deg[maxn];
bool ans[maxn];
int n, m;
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++)
deg[i] = g[i].size(), s.insert(make_pair(deg[i], i));
}
int main() {
input();
while (true) {
auto it = s.end();
it--;
if (it->first < 2) break;
int u = it->second, t = it->first;
s.erase(it);
ans[u] = !ans[u];
deg[u] = g[u].size() - t;
for (auto &v : g[u])
if (ans[u] == ans[v])
s.erase(make_pair(deg[v], v)), deg[v]++, s.insert(make_pair(deg[v], v));
else
s.erase(make_pair(deg[v], v)), deg[v]--, s.insert(make_pair(deg[v], v));
s.insert(make_pair(deg[u], u));
}
for (int i = 0; i < n; i++) cout << ans[i];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long zr, one, two, tr;
cin >> zr >> one >> two >> tr;
if ((zr > one + 1) || (zr > one and (two != 0 || tr != 0)) ||
(tr > two + 1) || (tr > two and (zr != 0 || one != 0))) {
cout << "NO"
<< "\n";
return;
}
if (zr == one + 1 and two == 0 and tr == 0) {
cout << "YES"
<< "\n";
for (long long i = 0; i < (zr + one); i++) {
if (i % 2 == 0)
cout << 0 << " ";
else
cout << 1 << " ";
}
return;
}
if (tr == two + 1 and zr == 0 and one == 0) {
cout << "YES"
<< "\n";
for (long long i = 0; i < (tr + two); i++) {
if (i % 2 == 0)
cout << 3 << "\n";
else
cout << 2 << "\n";
}
return;
}
long long One = one - zr;
long long Two = two - tr;
if (abs(One - Two) > 1) {
cout << "NO"
<< "\n";
return;
}
if (One == Two) {
cout << "YES"
<< "\n";
for (long long i = 0; i < zr; i++) cout << 0 << " " << 1 << " ";
for (long long i = 0; i < One; i++) cout << 2 << " " << 1 << " ";
for (long long i = 0; i < tr; i++) cout << 2 << " " << 3 << " ";
cout << "\n";
return;
}
if (One > Two) {
cout << "YES"
<< "\n";
cout << 1 << " ";
for (long long i = 0; i < zr; i++) cout << 0 << " " << 1 << " ";
for (long long i = 0; i < Two; i++) cout << 2 << " " << 1 << " ";
for (long long i = 0; i < tr; i++) cout << 2 << " " << 3 << " ";
cout << "\n";
return;
}
if (Two > One) {
cout << "YES"
<< "\n";
for (long long i = 0; i < zr; i++) cout << 0 << " " << 1 << " ";
for (long long i = 0; i < One; i++) cout << 2 << " " << 1 << " ";
for (long long i = 0; i < tr; i++) cout << 2 << " " << 3 << " ";
cout << 2 << " ";
cout << "\n";
return;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200010];
int pre[2000100];
bool f[2000100];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 1, a + 1 + n);
int maxv = a[n];
int len = unique(a + 1, a + 1 + n) - a - 1;
memset(pre, 0, sizeof(pre));
memset(f, 0, sizeof(f));
for (int i = 1; i <= len; i++) f[a[i]] = 1;
for (int i = 1; i <= 2000000; i++) {
if (f[i])
pre[i] = i;
else
pre[i] = pre[i - 1];
}
int ans = 0;
for (int i = 1; i <= len; i++) {
for (int j = a[i] + a[i]; j < maxv * 2; j += a[i]) {
ans = max(ans, pre[j - 1] % a[i]);
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k, d;
cin >> n >> k >> d;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int res = INT_MAX;
for (int i = 0; i < n - (d - 1); i++) {
set<int> r;
for (int x = i; x < i + d; x++) {
r.insert(arr[x]);
}
res = min(res, (int)r.size());
}
cout << res << endl;
}
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int pos = 0;
long long sum = 0;
bool f;
while (k && pos < n) {
f = 0;
arr[pos] -= sum;
while (arr[pos] > 0) {
cout << arr[pos] << endl;
sum += arr[pos];
arr[pos] = 0;
k--;
f = 1;
}
pos++;
}
while (k--) {
cout << 0 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
stack<int> s;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (s.empty()) {
s.push(a[i]);
continue;
}
if (s.top() == a[i])
s.pop();
else if (abs(s.top() - a[i]) % 2 == 0)
s.pop();
else
s.push(a[i]);
}
if (!s.empty()) s.pop();
if (s.empty())
cout << "YES";
else
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, c0, c1, h;
cin >> n >> c0 >> c1 >> h;
int one = 0;
char c;
for (int i = 0; i < n; i++) {
cin >> c;
if (c - '0') one++;
}
int zero = n - one;
if (c0 > c1) {
swap(c0, c1);
swap(zero, one);
}
int diff = c1 - c0;
long long cost = c0 * zero;
if (h < diff) {
cost += (c0 * one + one * h);
} else {
cost += (c1 * one);
}
cout << cost << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
cin >> tc;
while (tc--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
vector<string> levels[N];
int dist[N][N], put[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k, w;
cin >> n >> m >> k >> w;
auto calculate_diff = [&](int x, int y) {
int ret = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (levels[x][i][j] != levels[y][i][j]) ret++;
}
}
return ret;
};
for (int i = 0; i < k; i++) {
vector<string> now(n);
for (int j = 0; j < n; j++) cin >> now[j];
levels[i] = now;
}
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
int df = w * calculate_diff(i, j);
dist[i][j] = dist[j][i] = min(n * m, df);
}
}
priority_queue<pair<int, int>> pq;
pq.push(make_pair(0, 0));
int sum = n * m;
vector<int> d(k, 1e8);
d[0] = 0;
vector<int> ans;
while (!pq.empty()) {
auto now = pq.top();
pq.pop();
if (put[now.second]) continue;
put[now.second] = 1;
ans.push_back(now.second);
sum += -now.first;
for (int i = 0; i < k; i++) {
if (d[i] > dist[now.second][i]) {
d[i] = dist[now.second][i];
pq.push(make_pair(-d[i], i));
}
}
}
cout << sum << "\n";
assert(ans.size() == k);
for (int i = 0; i < k; i++) {
int mn = n * m, ind = -1;
for (int j = 0; j < i; j++) {
int df = w * calculate_diff(ans[i], ans[j]);
if (df < mn) {
mn = df;
ind = ans[j];
}
}
cout << ans[i] + 1 << " ";
if (ind != -1)
cout << ind + 1 << "\n";
else
cout << 0 << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void set_program() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int MAXN = 7;
const int INF = 1e9;
int n, m;
int gr[MAXN][MAXN];
int col[6];
int res[6][6];
int ans;
void set_var() {
ans = 0;
for (int i = 0; i < MAXN; ++i) {
for (int j = 0; j < MAXN; ++j) {
gr[i][j] = 0;
}
}
for (int i = 0; i < 6; ++i) {
col[i] = -1;
}
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 6; ++j) {
res[i][j] = 0;
}
}
}
void relax() {
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 6; ++j) {
res[i][j] = 0;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (gr[i][j]) {
res[col[i]][col[j]] = res[col[j]][col[i]] = 1;
}
}
}
int sum_double = 0, sum = 0;
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 6; ++j) {
if (i == j) {
sum += res[i][j];
} else {
sum_double += res[i][j];
}
}
}
int result = sum + sum_double / 2;
ans = max(ans, result);
}
void gen(int len) {
if (len == n) {
relax();
return;
}
for (int i = 0; i < 6; ++i) {
col[len] = i;
gen(len + 1);
}
}
int main() {
set_program();
set_var();
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
gr[a][b] = gr[b][a] = 1;
}
gen(0);
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
int sum, i, a, b;
while (scanf("%d", &n) != EOF) {
sum = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
if (sum + a > 500)
printf("G"), sum -= b;
else
printf("A"), sum += a;
}
puts("");
}
}
| 3 |
#include <bits/stdc++.h>
inline void read(int &a) {
register char ch;
a = 0;
int sign = 1;
do {
ch = getchar();
} while (!isdigit(ch) && ch != '-');
if (ch == '-') {
sign = -1;
ch = getchar();
}
do {
a = a * 10 + ch - '0';
ch = getchar();
} while (isdigit(ch));
a *= sign;
}
inline void write(int a) {
char s[20];
int i = 0;
int sign = 1;
if (a < 0) sign = -1, a = -a;
do {
s[i++] = a % 10 + '0';
a /= 10;
} while (a);
i--;
if (sign == -1) putchar('-');
while (i >= 0) putchar(s[i--]);
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dl[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int dc[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const int INF = 2e9;
const double EPS = 1e-9;
const int Nmax = 1e3 + 5;
const int LgMax = log2(Nmax) + 1;
using namespace std;
int A[Nmax][Nmax];
int D[Nmax][Nmax];
int vis[Nmax][Nmax];
int N, M, alterate;
int X, Y;
void DFS(int x, int y) {
vis[x][y] = 0;
alterate++;
for (int k = 0; k < 4; ++k)
if (vis[x + dx[k]][y + dy[k]]) DFS(x + dx[k], y + dy[k]);
}
void gen() {
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
D[i][j] = D[i - 1][j] + D[i][j - 1] + A[i][j] - D[i - 1][j - 1];
}
int suma(int x1, int y1, int x2, int y2) {
return D[x2][y2] + D[x1 - 1][y1 - 1] - D[x1 - 1][y2] - D[x2][y1 - 1];
}
int valid(int x, int y) { return ((1 <= x && x <= N) && (1 <= y && y <= M)); }
int pot(int posX, int posY, int x, int y) {
if (valid(posX + x - 1, posY + y - 1) == 0) return 0;
if (suma(posX, posY, posX + x - 1, posY + y - 1) != x * y) return 0;
return 1;
}
int solve(int x, int y) {
int posX = X;
int posY = Y;
if (pot(posX, posY, x, y) == 0) return 0;
int c = x * y;
while (1) {
if (pot(posX + 1, posY, x, y) && pot(posX, posY + 1, x, y)) return 0;
if (!(pot(posX + 1, posY, x, y) || pot(posX, posY + 1, x, y))) break;
if (pot(posX + 1, posY, x, y)) {
c += y;
posX = posX + 1;
} else {
c += x;
posY = posY + 1;
}
}
return c == alterate;
}
int main() {
cin >> N >> M;
for (int i = 1; i <= N; ++i) {
string a;
cin >> a;
for (int j = 0; j < M; ++j)
if (a[j] == 'X')
A[i][j + 1] = 1;
else
A[i][j + 1] = 0;
}
gen();
memcpy(vis, A, sizeof(A));
int c = 0;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
if (vis[i][j]) {
X = i;
Y = j;
c++;
DFS(i, j);
}
if (c > 1) {
cout << "-1\n";
return 0;
}
int best = -1;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
if (best == -1 || (i * j < best)) {
if (solve(i, j)) best = i * j;
}
}
cout << best << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 100007;
const int MAXK = 207;
const int MOD = static_cast<int>(1e9 + 7);
const unsigned long long MDIV = static_cast<unsigned long long>(1.7e19);
int add(int x, int y) { return ((x += y) < MOD) ? x : (x - MOD); }
void addv(int &x, int y) { ((x += y) < MOD) ? x : (x -= MOD); }
int sub(int x, int y) { return ((x -= y) >= 0) ? x : (x + MOD); }
void subv(int &x, int y) { ((x -= y) >= 0) ? x : (x += MOD); }
int qpow(int a, int b) {
long long base = a, ans = 1;
while (b) {
if (b & 1) (ans *= base) %= MOD;
(base *= base) %= MOD;
b >>= 1;
}
return static_cast<int>(ans);
}
struct eT {
void setd(int _u, int _v, int _l) { u = _u, v = _v, last = _l; }
int u, v, last;
} edge[MAXN * 2];
int n, m;
int allans;
int ke, la[MAXN];
int dp[MAXN][MAXK];
int frac[MAXK], rf[MAXK], rev[MAXK];
int ta[MAXK], tb[MAXK], tans[MAXK];
void init();
void input();
void work();
void dfs(int now, int fa);
void mul(int a[], int b[], int ans[], int n);
int main() {
init();
input();
work();
}
void init() {
ios::sync_with_stdio(false);
frac[0] = 1;
for (int i = 1; i < MAXK; ++i)
frac[i] = static_cast<long long>(frac[i - 1]) * i % MOD;
rf[MAXK - 1] = qpow(frac[MAXK - 1], MOD - 2);
for (int i = MAXK - 2; i >= 0; --i)
rf[i] = static_cast<long long>(rf[i + 1]) * (i + 1) % MOD;
for (int i = 1; i < MAXK; ++i)
rev[i] = static_cast<long long>(rf[i]) * frac[i - 1] % MOD;
}
void input() {
scanf("%d%d", &n, &m);
int u, v;
memset(la, -1, sizeof(la));
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
edge[ke].setd(u, v, la[u]);
la[u] = ke++;
edge[ke].setd(v, u, la[v]);
la[v] = ke++;
}
}
void work() {
dfs(1, -1);
cout << allans << endl;
}
void dfs(int now, int fa) {
bool havechild = false;
int v;
for (int i = la[now]; ~i; i = edge[i].last) {
if ((v = edge[i].v) ^ fa) {
dfs(v, now);
if (!havechild) {
for (int j = 0; j <= m; ++j) dp[now][j] = dp[v][j];
havechild = true;
} else {
for (int j = 0; j <= m; ++j) {
ta[j] = static_cast<long long>(dp[now][j]) * rf[j] % MOD;
tb[j] = static_cast<long long>(dp[v][j]) * rf[j] % MOD;
}
mul(ta, tb, tans, m);
for (int j = 0; j <= m; ++j)
dp[now][j] = static_cast<long long>(tans[j]) * frac[j] % MOD;
}
}
}
if (!havechild) {
for (int i = 0; i <= m; ++i) dp[now][i] = 1;
} else {
int tdm = 0;
for (int i = la[now]; ~i; i = edge[i].last)
if (edge[i].v ^ fa) addv(tdm, dp[edge[i].v][m]);
for (int j = 0; j <= m; ++j) dp[now][j] = add(dp[now][j], dp[now][j]);
subv(dp[now][0], 1);
addv(allans, sub(dp[now][m], tdm));
for (int j = 0; j <= m; ++j) {
ta[j] = static_cast<long long>(dp[now][j]) * rf[j] % MOD;
tb[j] = rf[j];
}
mul(ta, tb, tans, m);
for (int j = 0; j <= m; ++j)
dp[now][j] = static_cast<long long>(tans[j]) * frac[j] % MOD;
}
addv(dp[now][0], 1);
}
void mul(int a[], int b[], int ans[], int n) {
unsigned long long tans;
for (int i = 0; i <= n; ++i) {
tans = 0;
for (int j = 0; j <= i; ++j) {
tans += static_cast<long long>(a[j]) * b[i - j];
if (tans > MDIV) tans %= MOD;
}
ans[i] = tans % MOD;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
const int Mod = 1e9 + 7;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
}
void solve() {
int N, M, A, B, C, sum = 0;
cin >> N >> M;
vector<int> ve(N + 2, 0);
for (int i = 0; i < M; i++) cin >> A >> B >> C, ve[A] -= C, ve[B] += C;
for (int i = 1; i <= N; i++) {
if (ve[i] > 0) sum += ve[i];
}
cout << sum;
}
int main() {
fast();
int T = 1;
while (T--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, q, cnt;
vector<int> a[100020];
int f[100020][17];
int dfn[100020];
int low[100020];
int d[100020];
int c[100020];
void mk(int x) {
c[x] += c[f[x][0]];
for (__typeof(a[x].begin()) i = a[x].begin(); i != a[x].end(); i++)
if (f[*i][0] == x) mk(*i);
}
void dfs(int x, int y) {
d[x] = d[y] + 1;
f[x][0] = y;
dfn[x] = low[x] = ++cnt;
for (int i = 1; i < 17; i++) f[x][i] = f[f[x][i - 1]][i - 1];
for (__typeof(a[x].begin()) i = a[x].begin(); i != a[x].end(); i++)
if (*i != y) {
if (dfn[*i])
low[x] = min(low[x], dfn[*i]);
else
dfs(*i, x), low[x] = min(low[x], low[*i]);
}
if (low[x] == dfn[x]) c[x] = 1;
}
int lca(int x, int y) {
if (d[x] < d[y]) swap(x, y);
int w = d[x] - d[y];
for (int i = 17; i--;)
if (w >> i & 1) x = f[x][i];
if (x == y) return x;
for (int i = 17; i--;)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d %d", &x, &y), a[x].push_back(y), a[y].push_back(x);
dfs(1, 0);
mk(1);
for (scanf("%d", &q); q--;) {
scanf("%d %d", &x, &y);
printf("%d\n", c[x] + c[y] - 2 * c[lca(x, y)]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAX = 1e5 + 11;
using namespace std;
const int MOD = (const int)(1e9 + 7);
const int INF = (const int)1e9;
template <typename T>
struct Matrix {
static Matrix Identity(std::size_t N, std::size_t M,
const std::size_t mod = (const size_t)(1e9 + 7)) {
auto result = Matrix(N, M, mod);
for (std::int32_t i = 0; i < N; ++i) {
result.data_[i * (M + 1)] = 1;
}
return result;
}
Matrix(std::size_t N, std::size_t M,
const std::size_t mod = (const size_t)(1e9 + 7)) {
assert(mod != 0);
N_ = N;
M_ = M;
mod_ = mod;
data_ = static_cast<T *>(calloc(N_ * M_, sizeof(T)));
}
Matrix(const Matrix &rhs) {
N_ = rhs.N_;
M_ = rhs.M_;
mod_ = rhs.mod_;
data_ = static_cast<T *>(malloc(N_ * M_ * sizeof(T)));
memmove(data_, rhs.data_, N_ * M_ * sizeof(T));
}
Matrix &operator=(const Matrix &rhs) {
assert(N_ == rhs.N_ && M_ == rhs.M_);
N_ = rhs.N_;
M_ = rhs.M_;
mod_ = rhs.mod_;
data_ = static_cast<T *>(malloc(N_ * M_ * sizeof(T)));
memmove(data_, rhs.data_, N_ * M_ * sizeof(T));
return *this;
}
virtual ~Matrix() { free(data_); }
void Power(const std::int32_t power) {
assert(N_ == M_);
Matrix res = Matrix::Identity(N_, M_, mod_);
;
Matrix q = *this;
std::int32_t x = power;
while (x > 0) {
if (x & 1) {
res *= q;
}
q *= q;
x >>= 1;
}
*this = res;
}
void Multiply(const Matrix &rhs) {
assert(M_ == rhs.N_);
Matrix result(N_, rhs.M_, mod_);
for (std::int32_t i = 0; i < N_; ++i) {
for (std::int32_t j = 0; j < M_; ++j) {
for (std::int32_t k = 0; k < M_; ++k) {
result.data_[i * M_ + j] +=
data_[i * M_ + k] * rhs.data_[k * rhs.M_ + j];
result.data_[i * M_ + j] %= mod_;
}
}
}
*this = result;
}
void Add(const Matrix &rhs) {
assert(N_ == rhs.N_ && M_ == rhs.M_);
for (std::int32_t i = 0; i < N_; ++i) {
for (std::int32_t j = 0; j < M_; ++j) {
data_[i * M_ + j] += rhs.data_[i * M_ + j];
data_[i * M_ + j] %= mod_;
}
}
}
void Subtract(const Matrix &rhs) {
assert(N_ == rhs.N_ && M_ == rhs.M_);
for (std::int32_t i = 0; i < N_; ++i) {
for (std::int32_t j = 0; j < M_; ++j) {
data_[i * M_ + j] += mod_;
data_[i * M_ + j] -= rhs.data_[i * M_ + j];
data_[i * M_ + j] %= mod_;
}
}
}
Matrix operator*(const Matrix &rhs) const {
Matrix result = *this;
result.Multiply(rhs);
return result;
}
Matrix operator+(const Matrix &rhs) const {
Matrix result = *this;
result.Add(rhs);
return result;
}
Matrix operator-(const Matrix &rhs) const {
Matrix result = *this;
result.Subtract(rhs);
return result;
}
Matrix &operator*=(const Matrix &rhs) {
Multiply(rhs);
return *this;
}
Matrix &operator+=(const Matrix &rhs) {
Add(rhs);
return *this;
}
Matrix &operator-=(const Matrix &rhs) {
Subtract(rhs);
return *this;
}
class Proxy {
public:
Proxy(T *array) : sub_data(array) {}
T &operator[](std::int32_t index) { return sub_data[index]; }
private:
T *sub_data;
};
Proxy operator[](std::int32_t index) const {
return Proxy(&data_[index * M_]);
}
void Print() const {
for (std::int32_t i = 0; i < N_; ++i) {
for (std::int32_t j = 0; j < M_; ++j) {
std::cout << this->operator[](i)[j] << " ";
}
std::cout << "\n";
}
}
private:
T *data_;
std::size_t N_, M_, mod_;
};
int N, b, k, x;
int A[MAX];
static void solve(int test) {
cin >> N >> b >> k >> x;
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
Matrix<std::int64_t> w(x, x), e(x, x);
for (int i = 0; i < x; ++i) {
w[i][(i * 10) % x] = 1;
}
for (int i = 0; i < x; ++i) {
for (int j = 0; j < N; ++j) {
e[i][(i + A[j]) % x]++;
}
}
auto m = (w * e);
m.Power(b);
cout << m[0][k];
}
int main() {
ios_base::sync_with_stdio(0);
solve(0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int inf = 1e9 / 2;
const int inf1 = 1e9;
const int simple = 1e9 + 7;
int32_t main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int a[n];
int k = 0, k1 = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] % 2 != 0) k1++;
}
if (k1 != 0) {
if (x == n && k1 % 2 == 0)
cout << "No" << '\n';
else if (k1 == n && x % 2 == 0)
cout << "No" << '\n';
else
cout << "Yes" << '\n';
} else
cout << "No" << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const double PI = acos(-1);
const long long MOD = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n, m;
long long valor[223455], resp[223455];
vector<int> vnext;
__int128 aget, aget2;
__int128 get(long long num1, long long num2) {
assert(num1 >= num2);
aget = num1 - num2 * num2;
aget2 = num2;
aget *= aget2;
return aget;
}
long long f(__int128 numero) {
memset(resp, 0, sizeof resp);
vnext.clear();
long long iz, der, midd;
__int128 res, res2;
long long tot = 0;
for (long long i = 0; i < n; i++) {
iz = 0, der = valor[i], midd;
while (iz + 1 < der) {
midd = (iz + der) / 2;
res = get(valor[i], midd + 1);
res2 = get(valor[i], midd);
if (res - res2 >= numero)
iz = midd;
else
der = midd;
}
res = get(valor[i], iz + 1);
res2 = get(valor[i], iz);
res -= res2;
if (res < numero) {
res++;
if (res == numero) vnext.push_back(i);
continue;
}
resp[i] = der;
tot += der;
if (der < valor[i]) {
res = get(valor[i], der + 1);
res -= get(valor[i], der);
res++;
if (res == numero) vnext.push_back(i);
}
}
return tot;
}
int main() {
cin >> n >> m;
long long maxx = 0;
for (long long i = 0; i < n; i++) {
cin >> valor[i];
maxx = max(maxx, valor[i]);
}
__int128 iz, der, mid;
mid = maxx;
der = (maxx - maxx * maxx);
der *= mid;
der--;
iz = maxx;
while (der + 1 < iz) {
mid = (iz + der) / 2;
if (f(mid) >= m)
der = mid;
else
iz = mid;
}
assert(f(der) >= m);
long long answer = m - f(iz);
for (long long i = 0; i < vnext.size(); i++) {
if (answer > 0) {
resp[vnext[i]]++;
answer--;
}
}
for (long long i = 0; i < n; i++) cout << resp[i] << " ";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int MAXN = (int)1e5 + 5;
const int MOD = (int)1e9 + 7;
const int L = 17;
int n, q;
vector<int> c[MAXN];
int timer;
int in[MAXN], out[MAXN], lv[MAXN];
int p[MAXN];
int up[MAXN][L];
void init_lca() {
in[0] = 0;
out[0] = MAXN;
timer = 0;
}
void dfs(int u) {
in[u] = ++timer;
lv[u] = lv[p[u]] + 1;
up[u][0] = p[u];
for (int i = 1; i < L; ++i) up[u][i] = up[up[u][i - 1]][i - 1];
for (int v : c[u]) dfs(v);
out[u] = timer;
}
bool is_ancestor(int u, int v) { return (in[v] >= in[u] && in[v] <= out[u]); }
int lca(int u, int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int i = L - 1; i >= 0; --i)
if (!is_ancestor(up[u][i], v)) u = up[u][i];
return up[u][0];
}
int max_in[4 * MAXN], min_in[4 * MAXN], mx_nd;
void build(int node, int start, int end) {
if (start == end) {
max_in[node] = start;
min_in[node] = start;
} else {
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
max_in[node] = (in[max_in[2 * node]] > in[max_in[2 * node + 1]])
? max_in[2 * node]
: max_in[2 * node + 1];
min_in[node] = (in[min_in[2 * node]] < in[min_in[2 * node + 1]])
? min_in[2 * node]
: min_in[2 * node + 1];
}
}
pair<int, int> query(int node, int start, int end, int l, int r) {
if (r < start or end < l) return {1, mx_nd};
if (l <= start and end <= r) return {max_in[node], min_in[node]};
int mid = (start + end) / 2;
pair<int, int> p1 = query(2 * node, start, mid, l, r);
pair<int, int> p2 = query(2 * node + 1, mid + 1, end, l, r);
pair<int, int> ret;
ret.first = (in[p1.first] > in[p2.first]) ? p1.first : p2.first;
ret.second = (in[p1.second] < in[p2.second]) ? p1.second : p2.second;
return ret;
}
int get_depth(int coord, int l, int r) {
int lcca = 0;
if (coord > l) {
pair<int, int> z = query(1, 1, n, l, coord - 1);
lcca = lca(z.first, z.second);
}
if (coord < r) {
pair<int, int> z = query(1, 1, n, coord + 1, r);
if (lcca == 0)
lcca = lca(z.first, z.second);
else
lcca = lca(lcca, lca(z.first, z.second));
}
return lv[lcca];
}
int main() {
cin >> n >> q;
init_lca();
for (int i = 2; i <= n; ++i) {
scanf("%d", &p[i]);
c[p[i]].push_back(i);
}
dfs(1);
int mx_in = 0;
for (int i = 1; i <= n; ++i)
if (in[i] > mx_in) {
mx_in = in[i];
mx_nd = i;
}
build(1, 1, n);
int l, r;
for (int i = 0; i < q; ++i) {
scanf("%d%d", &l, &r);
pair<int, int> bounds = query(1, 1, n, l, r);
int dl, dr;
if ((dl = get_depth(bounds.first, l, r)) >
(dr = get_depth(bounds.second, l, r))) {
cout << bounds.first << " " << dl - 1 << endl;
} else {
cout << bounds.second << " " << dr - 1 << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
scanf("%lld", &N);
long long ans = 1;
while (2 * ans - 1 < N) {
ans++;
}
printf("%lld\n", ans);
long long cnt = 0;
for (long long i = 1; i <= ans; i++) {
cout << "1"
<< " " << i << endl;
cnt++;
if (cnt == N) {
return 0;
}
}
if (cnt == N) return 0;
for (long long i = 2; i <= ans; i++) {
cout << ans << " " << i << endl;
cnt++;
if (cnt == N) {
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> v;
long long x, z, m = 0, n = 0, y, sum = 0;
string s, a, b;
long long arr[N];
int vis[300];
int main() {
int t;
cin >> t;
while (t--) {
cin >> x >> y;
v.resize(x);
for (int i = 0; i < x; i++) v[i] = i;
memset(vis, 0, sizeof vis);
sum = 0;
for (int i = 0; i < y; i++) {
cin >> n;
vis[n - 1] = 1;
sum++;
}
n = 1;
while (sum != x) {
n++;
for (int j = 0; j < x; j++) {
if (vis[v[j]] != 0 && vis[v[j]] != n) {
if (j - 1 >= 0 && vis[v[j - 1]] == 0) {
sum++;
vis[v[j - 1]] = n;
}
if (j + 1 < x && vis[v[j + 1]] == 0) {
sum++;
vis[v[j + 1]] = n;
}
}
}
}
cout << n << endl;
v.clear();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool dp[(1 << 22) + 2][22], pres[(1 << 22) + 2] = {0};
int a[(1 << 22) + 2 / 4];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (1 << 22) + 2; ++i) pres[i] = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
pres[a[i]] = true;
}
for (int i = 0; i < (1 << 22); ++i) {
if ((i & 1) > 0)
dp[i][0] = pres[i ^ 1];
else
dp[i][0] = (pres[i] || pres[i ^ 1]);
}
for (int j = 1; j < 22; ++j) {
for (int i = 0; i < (1 << 22); ++i) {
if (i & (1 << j))
dp[i][j] = dp[i ^ (1 << j)][j - 1];
else
dp[i][j] = (dp[i][j - 1] || dp[i ^ (1 << j)][j - 1]);
}
}
for (int i = 0; i < n; ++i) {
int num = a[i];
if (dp[a[i]][21] == 0) {
printf("-1 ");
continue;
}
for (int j = 21; j >= 0; --j) {
if (a[i] & (1 << j))
num ^= (1 << j);
else if (j == 0) {
if (pres[num ^ (1 << j)]) num ^= (1 << j);
} else if (dp[num ^ (1 << j)][j - 1])
num ^= (1 << j);
}
printf("%d ", num);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, k, t, count, ans, x, mn;
cin >> t;
while (t--) {
cin >> k;
int a[7];
for (i = 0, count = 0; i < 7; i++) {
cin >> a[i];
if (a[i] == 1) count++;
}
x = k / count;
if (k % count == 0) x--;
ans = x;
for (i = 0, mn = 1e9; i < 7; i++) {
j = i;
x = 0;
while (ans * count + x < k) {
if (a[j % 7] == 1) x++;
j++;
}
mn = fmin(mn, j - i);
}
cout << ans * 7 + mn << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
static int w[100010];
static int sum1i[100010], sumin[100010];
int main() {
int n, l, r, ql, qr;
cin >> n >> l >> r >> ql >> qr;
int sum = 0;
for (int i = 0; i < n; ++i) {
cin >> w[i];
sum1i[i] = sum;
sum += w[i];
}
sum = 0;
for (int i = n - 1; i >= 0; --i) {
sumin[i] = sum;
sum += w[i];
}
int T = INT_MAX;
for (int i = 0; i < n; i++) {
int cost = sum1i[i] * l + sumin[i] * r + w[i] * r;
int nl = i, nr = n - i;
if (nl > nr)
cost += (nl - nr - 1) * ql;
else if (nl < nr)
cost += (nr - nl - 1) * qr;
T = min(T, cost);
}
int costAllL = (sum1i[n - 1] + w[n - 1]) * l + (n - 1) * ql;
T = min(T, costAllL);
cout << T << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 200005;
const double PI = 4 * atan(1);
const long long MAX = 9223372036854775807;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
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)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod, long long MOD) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long n, m, x, y, t, k, z, w, l, r, ans;
long long ax, bx, ay, by, cx, cy;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
cin >> bx >> by;
cin >> ax >> ay;
cin >> cx >> cy;
x = max(ax, cx);
y = min(ax, cx);
if (bx > y && bx < x) {
cout << "NO";
return 0;
}
x = max(ay, cy);
y = min(ay, cy);
if (by > y && by < x) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s = to_string(n);
reverse(s.begin(), s.end());
n = stoi(s);
s = to_string(n);
reverse(s.begin(), s.end());
if (stoi(s) == n)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
mx = max(mx, v[i]);
}
int k = v.back();
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (v[i] > k) {
ans++;
k = v[i];
}
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1 << 14][1 << 6][14], N, ans[1 << 13], sum[2][1 << 6],
tmp[1 << 14][1 << 6][2];
char str[18][18];
long long rev[1 << 6];
long long reverse(long long id, long long len) {
long long sum = 0;
for (long long t = 0; t < len; ++t, id >>= 1)
sum |= (id & 1) << (len - t - 1);
return sum;
}
signed main() {
scanf("%lld", &N);
for (long long i = 0; i < N; ++i) scanf("%s", str[i]);
for (long long i = 0; i < N; ++i) dp[1 << i][0][i] = 1;
for (long long i = 0; i < 1 << (N - (N + 1) / 2 - 1); ++i)
rev[i] = reverse(i, (N - (N + 1) / 2 - 1));
for (long long i = 1; i < 1 << N; ++i)
if (__builtin_popcount(i) < (N + 1) / 2)
for (long long j = 0; j < 1 << 6; ++j)
for (long long k = 0; k < N; ++k)
if (dp[i][j][k])
for (long long p = 0; p < N; ++p)
if (!(i >> p & 1))
dp[i | (1 << p)]
[j | (str[k][p] - '0') << (__builtin_popcount(i) - 1)][p] +=
dp[i][j][k];
for (long long k = 0; k < N; ++k) {
memset(tmp, 0, sizeof(tmp));
for (long long i = 0; i < 1 << N; ++i)
if (__builtin_popcount(i) == N - (N + 1) / 2) {
for (long long p = 0; p < 1 << (N - (N + 1) / 2 - 1); ++p)
for (long long q = 0; q < N; ++q)
if (dp[i][p][q]) tmp[i][p][str[k][q] - '0'] += dp[i][p][q];
}
for (long long i = 0; i < 1 << N; ++i)
if (__builtin_popcount(i) == (N + 1) / 2)
for (long long j = 0; j < 1 << ((N + 1) / 2 - 1); ++j)
if (dp[i][j][k]) {
for (long long p = 0; p < 1 << (N - (N + 1) / 2 - 1); ++p)
for (long long q = 0; q < 2; ++q)
ans[j | q << ((N + 1) / 2 - 1) | rev[p] << ((N + 1) / 2)] +=
dp[i][j][k] * tmp[(1 << N) - i - 1][p][q];
}
}
for (long long i = 0; i < 1 << (N - 1); ++i) cout << ans[i] << ' ';
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main(void) {
int n, m, a, b, i;
int c[1000];
scanf("%d%d", &n, &m);
a = n % m;
b = n / m;
for (i = 1; i <= m; i++) c[i] = b;
for (i = m - a; i < m; i++) c[i] += 1;
for (i = 1; i <= m; i++) printf("%d ", c[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int oriArr[2000001] = {0};
int arr[2000001];
int main() {
int oriCnt;
cin >> oriCnt;
int maxOri = 0;
for (int i = 0; i < oriCnt; i++) {
int tmp;
cin >> tmp;
oriArr[tmp] = 1;
if (maxOri < tmp) maxOri = tmp;
}
arr[0] = 0;
int cnt = 0;
for (int i = 1; i <= maxOri; i++) {
if (oriArr[i] == 0) {
arr[i] = arr[i - 1];
} else {
arr[i] = i;
cnt++;
}
}
if (cnt == 1) {
cout << "0" << endl;
return 0;
}
int max = 0;
for (int i = maxOri - 1; i >= 0; i--) {
if (arr[i] < max) break;
if (oriArr[i] == 0) continue;
for (int j = 2; arr[i] * (j - 1) <= maxOri; j++) {
int tmp = j * arr[i] - 1;
if (tmp > maxOri) tmp = maxOri;
if (arr[tmp] % arr[i] > max) max = arr[tmp] % arr[i];
}
}
cout << max << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
if (i == 1)
cout << 2 << '\n';
else
cout << i * (i + 1) * (i + 1) - (i - 1) << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l1, l2, r1, r2;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l1 >> r1 >> l2 >> r2;
cout << l1 << " ";
if (l2 != l1)
cout << l2 << endl;
else
cout << r2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
while (n--) {
int a, b;
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
} else {
int tt = abs(a - b);
if (a < b && tt % 2 != 0) {
cout << 1 << endl;
} else if (a > b && tt % 2 == 0) {
cout << 1 << endl;
} else {
cout << 2 << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename H, typename... T>
void debug_out(H h, T... t) {
cerr << " " << (h);
debug_out(t...);
}
void read() {}
template <typename H, typename... T>
void read(H &h, T &...t) {
cin >> h;
read(t...);
}
double INF = 1e100;
const double EPS = 1e-9;
int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
bool operator<(const PT &o) const {
if (cmp(x, o.x) == 0) return cmp(y, o.y) == -1;
return cmp(x, o.x) == -1;
}
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
os << "(" << p.x << "," << p.y << ")";
}
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
vector<PT> CircleCircleIntersection(PT a, PT b, double r, double R) {
vector<PT> ret;
double d = sqrt(dist2(a, b));
if (d > r + R || d + min(r, R) < max(r, R)) return ret;
double x = (d * d - R * R + r * r) / (2 * d);
double y = sqrt(r * r - x * x);
PT v = (b - a) / d;
ret.push_back(a + v * x + RotateCCW90(v) * y);
if (y > 0) ret.push_back(a + v * x - RotateCCW90(v) * y);
return ret;
}
void solve() {
int n;
cin >> n;
vector<PT> c(n);
vector<double> r(n);
for (int i = 0; i < n; i++) {
cin >> c[i].x >> c[i].y >> r[i];
}
if (n == 1) {
cout << 2 << '\n';
}
if (n == 2) {
int inter = CircleCircleIntersection(c[0], c[1], r[0], r[1]).size();
if (inter > 1) {
cout << 4 << '\n';
} else {
cout << 3 << '\n';
}
}
if (n == 3) {
set<PT> inter;
set<PT> mine[3];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
auto tmp = CircleCircleIntersection(c[i], c[j], r[i], r[j]);
for (auto it : tmp) {
inter.insert(it);
mine[i].insert(it);
mine[j].insert(it);
}
}
}
int c = 1;
int edges = 3;
int v = inter.size();
for (int i = 0; i < 3; i++) {
if (mine[i].size() == 0) {
c++;
v++;
} else {
edges += mine[i].size() - 1;
}
}
c = min(c, 3);
cout << edges + c + 1 - v << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a1, b1, c1, a2, b2, c2;
void input() { cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2; }
void solve() {
if (a1 == 0 && b1 == 0) {
if (c1) {
puts("0");
return;
}
}
if (a2 == 0 && b2 == 0) {
if (c2) {
puts("0");
return;
}
}
if (a1 == 0 && b1 == 0) {
if (!c1) {
puts("-1");
return;
}
}
if (a2 == 0 && b2 == 0) {
if (!c2) {
puts("-1");
return;
}
}
if (a1 * b2 == b1 * a2) {
if (a1 * c2 == a2 * c1 && b1 * c2 == b2 * c1)
puts("-1");
else
puts("0");
} else
puts("1");
}
int main() {
input();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 10;
int n, r, buck[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &r);
for (int j = 1; j <= r; j++) {
int tmp;
scanf("%d", &tmp);
buck[tmp]++;
}
}
for (int i = 1; i <= 100; i++)
if (buck[i] == n) printf("%d ", i);
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n, k;
int g;
cin >> g;
for (int j = 0; j < g; j++) {
cin >> n >> k;
cout << 2 * k << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int x = a[0];
int c = 0;
for (int i = 1; i < n; i++) {
if (x >= a[i]) {
int y = x - a[i];
int z = y / k;
z++;
c += z;
x = z * k + a[i];
} else
x = a[i];
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int ar[1002], k;
long long int solvel(long long int s) {
long long int mid, l = 1, r = s, ans = 0;
while (l <= r) {
mid = (l + r) / 2;
if (s - mid == ar[s] - ar[mid])
r = mid - 1;
else
l = mid + 1;
}
ans = ar[l] - 1;
if (ans > 0) return ans;
return -10000000001;
}
long long int solver(long long int s, long long int n) {
long long int mid, ans = 0, l = s, r = k;
while (l <= r) {
mid = (l + r) / 2;
if (mid - s == ar[mid] - ar[s])
l = mid + 1;
else
r = mid - 1;
}
ans = ar[r] + 1;
if (ans <= n) return ans;
return 10000000001;
}
int main() {
long long int t, n, s, l, r, i;
cin >> t;
while (t--) {
long long int check = 0;
cin >> n >> s >> k;
for (i = 1; i <= k; i++) {
cin >> ar[i];
}
sort(ar + 1, ar + k + 1);
check = find(ar + 1, ar + 1 + k, s) - ar;
if (check > k)
cout << 0 << endl;
else {
l = solvel(check);
r = solver(check, n);
cout << min(s - l, r - s) << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 5e3 + 5;
int n, m;
char a[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int ans = 0, t = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') continue;
int lstR[m + 5], lstC[n + 5];
int nxt[n + 5][m + 5][4];
memset(lstR, -1, sizeof lstR);
memset(lstC, -1, sizeof lstC);
memset(nxt, -1, sizeof nxt);
for (int p1 = 0; p1 < n; p1++)
for (int p2 = 0; p2 < m; p2++) {
if (a[p1][p2] == '.') continue;
if (~lstR[p2]) {
nxt[p1][p2][0] = lstR[p2];
nxt[lstR[p2]][p2][1] = p1;
}
if (~lstC[p1]) {
nxt[p1][p2][2] = lstC[p1];
nxt[p1][lstC[p1]][3] = p2;
}
lstR[p2] = p1, lstC[p1] = p2;
}
int curi = i, curj = j, cnt = 0;
while (1) {
cnt++;
if (~nxt[curi][curj][1])
nxt[nxt[curi][curj][1]][curj][0] = nxt[curi][curj][0];
if (~nxt[curi][curj][0])
nxt[nxt[curi][curj][0]][curj][1] = nxt[curi][curj][1];
if (~nxt[curi][curj][2])
nxt[curi][nxt[curi][curj][2]][3] = nxt[curi][curj][3];
if (~nxt[curi][curj][3])
nxt[curi][nxt[curi][curj][3]][2] = nxt[curi][curj][2];
if (a[curi][curj] == 'U') {
if (nxt[curi][curj][0] == -1) break;
curi = nxt[curi][curj][0];
} else if (a[curi][curj] == 'D') {
if (nxt[curi][curj][1] == -1) break;
curi = nxt[curi][curj][1];
} else if (a[curi][curj] == 'L') {
if (nxt[curi][curj][2] == -1) break;
curj = nxt[curi][curj][2];
} else {
if (nxt[curi][curj][3] == -1) break;
curj = nxt[curi][curj][3];
}
}
if (ans < cnt)
ans = cnt, t = 1;
else if (ans == cnt)
t++;
}
cout << ans << " " << t;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char com[10];
char now[50000];
char cd[250];
int main() {
int n;
memset(now, 0, sizeof(now));
now[0] = '/';
int cnt = 1;
scanf("%d", &n);
while (n--) {
scanf("%s", com);
if (com[0] == 'p') {
puts(now);
}
if (com[0] == 'c') {
scanf("%s", cd);
int len = strlen(cd);
if (cd[0] == '/') {
cnt = 1;
for (int i = 1; i < len;) {
if (cd[i] != '.')
now[cnt++] = cd[i], ++i;
else {
i += 2;
cnt -= 2;
for (; now[cnt] != '/' && cnt > 0; cnt--)
;
}
}
now[cnt++] = '/';
now[cnt] = 0;
} else {
for (int i = 0; i < len;) {
if (cd[i] != '.')
now[cnt++] = cd[i], ++i;
else {
i += 2;
cnt -= 2;
for (; now[cnt] != '/' && cnt > 0; cnt--)
;
}
}
now[cnt++] = '/';
now[cnt] = 0;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[200001];
long long n, k, l = 0, r = 2000000000001, it, pv;
vector<pair<long long, long long> > v[200001] = {};
bool ispos(long long c) {
int it = 0;
for (int i = 0; i < k; i++) {
v[i].clear();
}
for (int i = 0; i < n; i++) {
if (a[i].first / a[i].second < k) {
v[a[i].first / a[i].second].push_back(a[i]);
}
}
for (int i = 0; i < k; i++) {
while (v[it].empty() && it < k) {
it++;
}
if (it < i) {
return false;
}
if (it >= k) {
return true;
}
pair<long long, long long> tp = v[it].back();
v[it].pop_back();
if ((tp.first + c) / tp.second < k) {
v[(tp.first + c) / tp.second].push_back(
make_pair(tp.first + c, tp.second));
}
}
return true;
}
int main() {
scanf("%lld %lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i].first);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i].second);
}
while (l < r) {
pv = l + ((r - l) >> 1);
if (ispos(pv)) {
r = pv;
} else {
l = pv + 1;
}
}
if (l == 2000000000001) {
printf("-1\n");
} else {
printf("%lld\n", l);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long double pi = acos(-1.0);
const double eps = 1e-9;
using namespace std;
const int N = 1e3 + 1;
int n, m;
int dp[N][N];
vector<pair<int, int>> a[N];
int rec(int l, int r) {
if (l > r) return 0;
if (dp[l][r] != -1) return dp[l][r];
for (int i = l; i <= r; i++) {
int kol = 0;
for (auto x : a[i])
if (l <= x.first && x.second <= r && i >= x.first && i <= x.second) kol++;
dp[l][r] = max(dp[l][r], rec(l, i - 1) + rec(i + 1, r) + kol * kol);
}
return dp[l][r];
}
void solve() {
cin >> n >> m;
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) dp[i][j] = -1;
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
for (int j = 1; j <= k; j++) {
int l, r;
cin >> l >> r;
for (int q = l; q <= r; q++) a[q].push_back({l, r});
}
}
rec(1, m);
cout << dp[1][m] << endl;
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(1);
int step;
step = 1;
for (int i = 1; i <= step; i++) {
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, r;
scanf("%lld", &a);
scanf("%lld", &b);
scanf("%lld", &r);
long long area = a * b;
long long areaP = (2 * r) * (2 * r);
if (2 * r <= min(a, b))
cout << "First";
else
cout << "Second";
}
int main() {
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int bufSize = 1e6;
inline char nc() {
static char buf[bufSize], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, bufSize, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
inline T read(T &r) {
static char c;
static int flag;
flag = 1, r = 0;
for (c = nc(); !isdigit(c); c = nc())
if (c == '-') flag = -1;
for (; isdigit(c); c = nc()) r = r * 10 + c - 48;
return r *= flag;
}
const int maxn = 1e6 + 100;
int k, q;
long long f[7], ww[7][10], w[maxn];
long long dp[maxn];
int bit[maxn];
int pw[7] = {0, 1, 10, 100, 1000, 10000, 100000};
inline void work(int weight, long long value) {
for (int i = 999999; i >= weight; --i)
dp[i] = std::max(dp[i], dp[i - weight] + value);
}
int main() {
read(k);
for (int i = 1; i <= 6; ++i)
read(f[i]), ww[i][3] = f[i], ww[i][6] = 2 * f[i], ww[i][9] = 3 * f[i];
pw[0] = 1;
for (int i = 1; i <= 999999; ++i) {
bit[i] = bit[i / 10] + 1;
dp[i] = dp[i % pw[bit[i]]] + ww[bit[i]][(i / pw[bit[i]])];
}
for (int i = 1; i <= 6; ++i) {
int num = std::min(3 * (k - 1), 333333 / pw[i]);
for (int j = 1; j <= num; num -= j, j <<= 1) work(3 * pw[i] * j, f[i] * j);
if (num) work(3 * pw[i] * num, f[i] * num);
}
read(q);
for (int i = 1, x; i <= q; ++i) read(x), printf("%lld\n", dp[x]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int data[100005 * 3];
long long total[3 * 100005];
map<int, int> pos;
set<int> anss;
int main() {
int n;
cin >> n;
data[0] = total[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &data[i]);
total[i] = max(0, data[i]);
}
for (int i = 2; i <= n; i++) total[i] += total[i - 1];
for (int i = 1; i <= n; i++)
if (pos[data[i]] == 0) pos[data[i]] = i;
long long ans = -(1LL << 60);
int l, r;
for (int i = n; i >= 1; i--)
if (pos[data[i]] > 0 && i - pos[data[i]] > 0 &&
(total[i - 1] - total[pos[data[i]]] + (2LL * (long long)(data[i]))) >
ans)
ans = (total[i - 1] - total[pos[data[i]]] + (2LL * (long long)(data[i]))),
l = pos[data[i]] - 1, r = i + 1;
for (int i = 1; i <= l; i++) anss.insert(i);
for (int i = r; i <= n; i++) anss.insert(i);
for (int i = l + 2; i < r - 1; i++)
if (data[i] < 0) anss.insert(i);
printf("%I64d %d", ans, anss.size());
puts("");
for (set<int>::iterator it = anss.begin(); it != anss.end(); it++)
printf("%d ", *it);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct chil {
long long int v;
long long int d;
long long int p;
int nu;
};
list<chil> line;
int main() {
ios::sync_with_stdio(false);
long long int n;
cin >> n;
for (int i = 0; i < n; ++i) {
chil var;
cin >> var.v >> var.d >> var.p;
var.nu = i + 1;
line.push_back(var);
}
int ans = 0;
list<chil>::iterator it;
list<chil>::iterator it1;
long long int v1, d1 = 0;
vector<int> as;
while (!line.empty()) {
ans++;
d1 = 0;
it = line.begin();
as.push_back(it->nu);
v1 = it->v;
it = line.erase(it);
while ((v1 > 0 || d1 != 0) && it != line.end()) {
if ((it->p) < (v1 + d1)) {
d1 += (it->d);
it = line.erase(it);
} else {
it->p -= (v1 + d1);
it++;
}
if (v1 > 0) {
v1--;
}
}
}
cout << ans << '\n';
for (int i = 0; i < ans; ++i) {
cout << as[i] << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
long long int n;
cin >> n;
map<long long int, long long int> m;
vector<long long int> ans;
int c = 0;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (!m[x]) {
m[x] = c + 1;
c++;
ans.push_back(1);
} else {
ans[m[x] - 1]++;
}
}
sort(ans.begin(), ans.end());
long long int count = ans[c - 1];
long long int present = ans[c - 1] - 1;
c = c - 2;
while (c >= 0 && present > 0) {
count += min(present, ans[c]);
present = min(present, ans[c]) - 1;
c--;
}
cout << count << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 5;
const int inf = (int)1e9 + 7;
string s;
int SZ, SHIFT;
int dp[N][2][2], ans[N];
pair<int, int> pr[N][2][2];
int solve(int p, int lc, int rc) {
if (dp[p][lc][rc] != -1) {
return dp[p][lc][rc];
}
dp[p][lc][rc] = 0;
int l = p + SHIFT;
int r = SZ - p - 1;
if (l == r || l == r - 1) {
if (l == r) {
for (int d = !p ? 1 : 0; d <= 9; ++d) {
int c = (d + d + rc) % 10;
int f = (d + d + rc) / 10;
if (c == s[l] - '0' && f == lc) {
pr[p][lc][rc].first = d;
return dp[p][lc][rc] = 1;
}
}
return 0;
} else {
for (int sum = !p ? 1 : 0; sum <= 18; ++sum) {
int good = ((sum + rc) % 10) == (s[r] - '0') &&
((sum + (sum + rc) / 10) % 10) == (s[l] - '0') &&
((sum + (sum + rc) / 10) / 10) == lc;
if (good) {
pr[p][lc][rc].first = sum;
return dp[p][lc][rc] = 1;
}
}
return 0;
}
} else {
for (int sum = !p ? 1 : 0; sum <= 18; ++sum) {
for (int nc : {0, 1}) {
int good = ((sum + nc) % 10) == (s[l] - '0') &&
((sum + rc) % 10) == (s[r] - '0') && ((sum + nc) / 10) == lc;
if (good) {
pr[p][lc][rc] = make_pair(sum, nc);
int nr = (sum + rc) / 10;
dp[p][lc][rc] |= solve(p + 1, nc, nr);
}
}
}
}
return dp[p][lc][rc];
}
void clr() {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 2; ++j) {
for (int k = 0; k < 2; ++k) {
dp[i][j][k] = -1;
pr[i][j][k] = make_pair(-1, -1);
}
}
}
}
void restore(int p, int lc, int rc) {
int l = p + SHIFT;
int r = SZ - p - 1;
if (l == r) {
ans[l] = pr[p][lc][rc].first;
return;
}
int sum = pr[p][lc][rc].first;
if (sum > 9) {
ans[l] = 9;
ans[r] = sum - 9;
} else {
ans[l] = sum;
ans[r] = 0;
}
if (l == r - 1) {
return;
}
int nc = pr[p][lc][rc].second;
int nr = (sum + rc) / 10;
restore(p + 1, nc, nr);
}
int main() {
cin >> s;
clr();
SZ = (int)((s).size());
int e = solve(0, 0, 0);
if (e) {
restore(0, 0, 0);
for (int i = 0; i < SZ; ++i) {
cout << ans[i];
}
} else {
clr();
SHIFT = 1;
int e = solve(0, 1, 0) && s[0] == '1';
if (e) {
restore(0, 1, 0);
for (int i = 1; i < SZ; ++i) {
cout << ans[i];
}
} else {
cout << 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int l = 0; l < q; ++l) {
string a;
cin >> a;
deque<char> c, n;
int i;
for (i = 0; i < a.size(); ++i)
if ((a[i] - 'a') % 2 == 0)
c.push_back(a[i]);
else
n.push_back(a[i]);
string ot;
while (!c.empty() || !n.empty()) {
if (c.empty()) {
ot += n.front();
n.pop_front();
} else if (n.empty()) {
ot += c.front();
c.pop_front();
} else {
if (c.front() < n.front()) {
ot += c.front();
c.pop_front();
} else {
ot += n.front();
n.pop_front();
}
}
}
cout << ot << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s, ans;
int a, b, n;
cin >> n >> a >> b;
for (int i = 0; i <= a - b; ++i) {
s += 'a';
}
for (int i = 0; i < b - 1; ++i) {
s += 'a' + i + 1;
}
for (int i = 0; i < n; ++i) {
ans += s[i % a];
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, i, j, k, d;
cin >> n >> m;
vector<int> arr(101, 0);
for (i = 0; i < m; i++) {
int no;
cin >> no;
arr[no]++;
}
for (d = m; d >= 1; d--) {
vector<int> cc(arr);
int k = 0;
for (i = 0; i < cc.size(); i++) {
if (cc[i] >= d) {
k += (floor(cc[i] / d));
}
}
if (k >= n) {
cout << d << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int n, Q, f[maxn], ru[maxn];
long long t[maxn], ads[maxn];
set<pair<long long, int> > q[maxn], result;
inline long long contribution(int x) { return t[x] / (ru[x] + 2); }
inline long long self_contribution(int x) {
return t[x] - (ru[x] + 1) * contribution(x);
}
inline long long calc(int x) { return ads[x] + contribution(f[x]); }
void add(int x) { q[f[x]].insert(make_pair(ads[x], x)); }
void update(int x) {
while (!q[x].empty() &&
((*q[x].begin()).first != ads[(*q[x].begin()).second] ||
f[(*q[x].begin()).second] != x)) {
q[x].erase(*q[x].begin());
}
while (!q[x].empty() &&
((*q[x].rbegin()).first != ads[(*q[x].rbegin()).second] ||
f[(*q[x].rbegin()).second] != x)) {
q[x].erase(*q[x].rbegin());
}
if (!q[x].empty()) {
result.insert(
make_pair(calc((*q[x].begin()).second), (*q[x].begin()).second));
}
if (!q[x].empty()) {
result.insert(
make_pair(calc((*q[x].rbegin()).second), (*q[x].rbegin()).second));
}
}
void update_(int x, int k) {
ads[f[x]] -= contribution(x);
ads[x] -= self_contribution(x);
ru[x] += k;
ads[f[x]] += contribution(x);
ads[x] += self_contribution(x);
add(f[x]);
add(x);
update(x);
update(f[x]);
update(f[f[x]]);
}
int main() {
int n, Q;
cin >> n >> Q;
for (int i = 1; i <= n; i++) scanf("%lld", t + i);
for (int i = 1; i <= n; i++) {
scanf("%d", f + i);
ru[f[i]]++;
}
for (int i = 1; i <= n; i++) {
ads[f[i]] += contribution(i);
ads[i] += self_contribution(i);
}
for (int i = 1; i <= n; i++) add(i);
for (int i = 1; i <= n; i++) update(i);
int x, y, ty;
while (Q--) {
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &x, &y);
int z = f[x];
ads[z] -= contribution(x);
ads[y] += contribution(x);
f[x] = y;
add(x);
update_(z, -1);
update_(y, 1);
} else if (ty == 2) {
scanf("%d", &x);
printf("%lld\n", calc(x));
} else {
while ((*result.begin()).first != calc((*result.begin()).second)) {
result.erase(*result.begin());
}
while ((*result.rbegin()).first != calc((*result.rbegin()).second)) {
result.erase(*result.rbegin());
}
printf("%lld %lld\n", (*result.begin()).first, (*result.rbegin()).first);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct pkt {
int x, y;
};
struct pol {
int op, k;
char dir;
};
bool porownanie(pkt a, pkt b) {
if (abs(a.x) < abs(b.x)) return true;
if (abs(a.x) > abs(b.x)) return false;
if (a.x < b.x) return true;
if (a.x > b.x) return false;
if (a.y < 0 && b.y < 0) {
if (a.y > b.y) return true;
return false;
}
if (a.y >= 0 && b.y >= 0) {
if (a.y < b.y) return true;
return false;
}
if (a.y < 0 && b.y >= 0) return true;
return false;
}
int main() {
int n;
scanf("%d", &n);
vector<pkt> p(n);
for (int i = 0; i < n; ++i) scanf("%d %d", &p[i].x, &p[i].y);
sort(p.begin(), p.end(), porownanie);
vector<pol> odp;
for (int i = 0; i < n; ++i) {
if (p[i].y > 0) odp.push_back({1, p[i].y, 'U'});
if (p[i].y < 0) odp.push_back({1, -p[i].y, 'D'});
if (p[i].x > 0) odp.push_back({1, p[i].x, 'R'});
if (p[i].x < 0) odp.push_back({1, -p[i].x, 'L'});
odp.push_back({2, -1, 'X'});
if (p[i].x > 0) odp.push_back({1, p[i].x, 'L'});
if (p[i].x < 0) odp.push_back({1, -p[i].x, 'R'});
if (p[i].y > 0) odp.push_back({1, p[i].y, 'D'});
if (p[i].y < 0) odp.push_back({1, -p[i].y, 'U'});
odp.push_back({3, -1, 'X'});
}
printf("%d\n", odp.size());
for (int i = 0; i < odp.size(); ++i) {
if (odp[i].op == 1)
printf("%d %d %c\n", odp[i].op, odp[i].k, odp[i].dir);
else
printf("%d\n", odp[i].op);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100007, dx[8] = {1, 1, 1, 0, 0, -1, -1, -1},
dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int xs, ys, xt, yt, n, r[maxn], a[maxn], b[maxn], d[maxn] = {}, cnt = 0;
bool vis[maxn] = {};
vector<int> row, col[maxn];
vector<pair<int, int> > seg[maxn], cells[maxn];
int dist(int x, int y) {
x = lower_bound(row.begin(), row.end(), x) - row.begin() + 1;
y = lower_bound(cells[x].begin(), cells[x].end(), make_pair(y, 0)) -
cells[x].begin();
return d[cells[x][y].second];
}
void set_dist(int x, int y, int val) {
x = lower_bound(row.begin(), row.end(), x) - row.begin() + 1;
y = lower_bound(cells[x].begin(), cells[x].end(), make_pair(y, 0)) -
cells[x].begin();
d[cells[x][y].second] = val;
}
bool valid(int x, int y) {
if (!binary_search(row.begin(), row.end(), x)) return 0;
x = lower_bound(row.begin(), row.end(), x) - row.begin() + 1;
if (!binary_search(col[x].begin(), col[x].end(), y)) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> xs >> ys >> xt >> yt >> n;
for (int i = 1; i <= n; ++i) {
cin >> r[i] >> a[i] >> b[i];
row.push_back(r[i]);
}
sort(row.begin(), row.end());
for (int i = 1; i <= n; ++i)
r[i] = lower_bound(row.begin(), row.end(), r[i]) - row.begin() + 1;
for (int i = 1; i <= n; ++i) seg[r[i]].push_back({a[i], b[i]});
for (int i = 1; i <= n; ++i) {
if (vis[r[i]]) continue;
sort(seg[r[i]].begin(), seg[r[i]].end());
int cur = 1;
for (auto it : seg[r[i]]) {
cur = max(it.first, cur);
for (int j = cur; j <= it.second; ++j)
cells[r[i]].push_back({j, ++cnt}), col[r[i]].push_back(j);
}
vis[r[i]] = 1;
}
queue<pair<int, int> > q;
q.push({xs, ys});
set_dist(xs, ys, 1);
while (q.size()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 8; ++i) {
int xx = dx[i] + x, yy = dy[i] + y;
if (valid(xx, yy) && dist(xx, yy) == 0)
set_dist(xx, yy, dist(x, y) + 1), q.push({xx, yy});
}
}
cout << dist(xt, yt) - 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> cur_inv(30, 0);
vector<long long> fut_inv(30, 0);
function<void(vector<long long>, long long)> go = [&](vector<long long> xx,
long long idx) {
if (xx.empty() || idx < 0) return;
long long o = 0;
long long z = 0;
vector<long long> x1, x2;
for (auto i : xx) {
if ((i >> idx) & 1) {
x1.push_back(i);
o++;
fut_inv[idx] += z;
} else {
x2.push_back(i);
z++;
cur_inv[idx] += o;
}
}
go(x1, idx - 1);
go(x2, idx - 1);
};
go(a, 29);
long long res = 0;
long long x = 0;
for (long long bit = 29; bit >= 0; bit--) {
if (cur_inv[bit] > fut_inv[bit]) {
x |= (1 << bit);
}
res += min(cur_inv[bit], fut_inv[bit]);
}
cout << res << " " << x << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct poll {
int my_votes, his_votes, id;
bool operator<(const poll &other) const {
int d1 = his_votes - my_votes;
int d2 = other.his_votes - other.my_votes;
return d1 > d2;
}
};
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<vector<int>> votes(m);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int x;
cin >> x;
votes[i].push_back(x);
}
}
int ans = 1e9;
vector<int> ans_ids;
for (int candidate = 0; candidate < n - 1; candidate++) {
vector<poll> polls;
int remove = 0;
int my_votes = 0, his_votes = 0;
for (int i = 0; i < m; i++) {
polls.push_back({votes[i][candidate], votes[i][n - 1], i});
my_votes += votes[i][candidate];
his_votes += votes[i][n - 1];
}
sort(polls.begin(), polls.end());
int it = 0;
vector<int> ids;
while (my_votes < his_votes) {
my_votes -= polls[it].my_votes;
his_votes -= polls[it].his_votes;
ids.push_back(polls[it].id);
it++;
}
if (it < ans) {
ans = it;
ans_ids = ids;
}
}
cout << ans << "\n";
if (ans) {
for (auto x : ans_ids) cout << x + 1 << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, x, y, du[N];
vector<long long> g[N];
void dfs(long long u, long long fa) {
long long size = 0;
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (v == fa) continue;
dfs(v, u);
size++;
}
if (size == 1) {
puts("NO");
exit(0);
}
}
signed main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
du[x]++;
du[y]++;
}
for (long long i = 1; i <= n; i++)
if (du[i] == 2) {
puts("NO");
return 0;
}
puts("YES");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10, mod = 1e9 + 7, inf = 1e18;
int gcd(int t1, int t2) {
while (t2) {
int r = t1 % t2;
t1 = t2;
t2 = r;
}
return t1;
}
void compress(vector<pair<int, int>> &vt) {
sort(vt.begin(), vt.end());
auto it = unique(vt.begin(), vt.end());
vt.resize(it - vt.begin());
}
vector<pair<int, int>> candi;
int q, sl = 1, cnt[N];
struct ds {
int t, x, y;
};
struct ds2 {
vector<pair<int, int>> poi;
vector<int> on;
vector<vector<int>> vt;
void build() {
compress(poi);
on.resize(poi.size(), 0);
vt.resize(poi.size());
for (int i = 0; i < (int)poi.size(); i++) vt[i].resize(poi.size(), -1);
for (int i = 0; i < (int)poi.size(); i++)
for (int j = 0; j < (int)poi.size(); j++) {
pair<int, int> np = make_pair(poi[i].first + poi[j].first,
poi[i].second + poi[j].second);
int tmp = gcd(np.first, np.second);
np.first /= tmp;
np.second /= tmp;
tmp = lower_bound(candi.begin(), candi.end(), np) - candi.begin();
if (tmp < (int)candi.size() && candi[tmp] == np) vt[i][j] = tmp;
}
}
void add(pair<int, int> p) {
int t = lower_bound(poi.begin(), poi.end(), p) - poi.begin();
on[t] = 1;
for (int i = 0; i < (int)poi.size(); i++)
if (on[i]) {
int val = 1 + (i != t);
if (vt[t][i] != -1) cnt[vt[t][i]] += val;
}
}
void del(pair<int, int> p) {
int t = lower_bound(poi.begin(), poi.end(), p) - poi.begin();
for (int i = 0; i < (int)poi.size(); i++)
if (on[i]) {
int val = 1 + (i != t);
if (vt[t][i] != -1) cnt[vt[t][i]] -= val;
}
on[t] = 0;
}
};
ds query[N];
ds2 group[N];
void read() {
cin >> q;
for (int i = 1, t, x, y; i <= q; i++) {
cin >> t >> x >> y;
if (t == 3) {
int tmp = gcd(x, y);
x /= tmp;
y /= tmp;
}
query[i] = {t, x, y};
}
}
map<long long, int> id;
void process() {
for (int i = 1; i <= q; i++)
if (query[i].t == 3)
candi.push_back(make_pair(query[i].x, query[i].y));
else if (query[i].t == 1) {
int x = query[i].x, y = query[i].y, vt = id[x * x + y * y];
if (!vt) id[x * x + y * y] = sl++, vt = sl - 1;
group[vt].poi.push_back(make_pair(x, y));
}
compress(candi);
sl--;
for (int i = 1; i <= sl; i++) group[i].build();
int siz = 0;
for (int i = 1; i <= q; i++) {
int t = query[i].t, x = query[i].x, y = query[i].y;
if (t == 1) group[id[x * x + y * y]].add(make_pair(x, y)), siz++;
if (t == 2) group[id[x * x + y * y]].del(make_pair(x, y)), siz--;
if (t == 3) {
int tmp = lower_bound(candi.begin(), candi.end(), make_pair(x, y)) -
candi.begin();
cout << siz - cnt[tmp] << "\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read();
process();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s, u;
cin >> s >> u;
a = s.size();
b = u.size();
string tmp = "";
int i;
for (i = 0; i < u.size(); i++) {
tmp += '.';
}
tmp += s;
for (i = 0; i < u.size(); i++) {
tmp += '.';
}
tmp += "......";
int best = u.size(), j;
for (i = 0; i + u.size() < tmp.size(); i++) {
int c = 0;
for (j = 0; j < u.size(); j++) {
if (u[j] != tmp[i + j]) {
c++;
}
}
best = min(best, c);
}
cout << best << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167177216")
using namespace std;
struct otr {
int a, b, c;
};
bool cmp(otr &a, otr &b) {
if (a.a != b.a) return a.a < b.a;
if (a.b != b.b) return a.b > b.b;
return a.c < b.c;
}
int main() {
int n, m;
scanf("%d%d", &m, &n);
vector<otr> v(n);
for (int i = 0; i < int(n); ++i) {
scanf("%d%d", &v[i].a, &v[i].b);
v[i].b += v[i].a - 1;
v[i].c = i;
}
sort(v.begin(), v.end(), cmp);
vector<int> ans;
int maxr = -1, l = 0, r = 0;
int pos = 0, last = 0;
while (l < n) {
if (v[l].a > maxr) {
last = l;
maxr = v[l].b;
}
int nmaxr = maxr;
while (r < n && v[r].a <= maxr + 1) {
if (v[r].b > nmaxr) {
nmaxr = v[r].b;
pos = r;
}
r++;
}
while (l < r) {
if (pos != l && last != l) ans.push_back(v[l].c);
l++;
}
maxr = nmaxr;
}
cout << ans.size() << endl;
for (int i = 0; i < int(ans.size()); ++i) cout << ans[i] + 1 << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m, s, e;
int a[maxn], b[maxn], dp[305];
vector<int> bv[maxn];
int main() {
scanf("%d%d%d%d", &n, &m, &s, &e);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
bv[b[i]].push_back(i);
}
int ans = 0;
int len = s / e;
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = min(i, len); j >= 1; j--) {
vector<int>::iterator small_num;
small_num = upper_bound(bv[a[i]].begin(), bv[a[i]].end(), dp[j - 1]);
if (small_num == bv[a[i]].end()) continue;
dp[j] = min(dp[j], *small_num);
if (i + dp[j] + j * e <= s) {
ans = max(j, ans);
}
}
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int mx = 1e3;
string s;
cin >> s;
int i, j;
int a[n], b[n];
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
int ans_ = INT_MIN;
for (i = 1; i < mx; i++) {
int ans = 0;
for (j = 0; j < n; j++) {
if (i - 1 < b[j]) {
if (s[j] == '1') {
ans++;
}
} else {
int div = (i - 1 - b[j]) / a[j];
if (s[j] == '1') {
if (div & 1) {
ans++;
}
} else {
if (!(div & 1)) {
ans++;
}
}
}
}
ans_ = max(ans, ans_);
}
cout << ans_ << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long inf = 0x3f3f3f3f;
long long n, m, k, q;
long long a[N], b[N];
long long c[N];
long long lowbit(long long x) { return x & (-x); }
void add(long long i, long long k) {
while (i <= n) {
c[i] += k;
i += lowbit(i);
}
}
long long getsum(long long i) {
long long res = 0;
while (i > 0) {
res += c[i];
i -= lowbit(i);
}
return res;
}
signed main() {
long long T, l, r, x;
cin >> n;
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 2; i <= n; i++) {
if (a[i] > a[i - 1]) add(i, a[i] - a[i - 1]);
b[i] = a[i] - a[i - 1];
}
long long t = getsum(n) + a[1];
if (t >= 0)
printf("%lld\n", (t + 1) / 2);
else
printf("%lld\n", t / 2);
cin >> q;
while (q--) {
scanf("%lld%lld%lld", &l, &r, &x);
if (l == 1) a[1] += x;
if (l > 1) {
if (b[l] > 0) add(l, -b[l]);
b[l] += x;
if (b[l] > 0) add(l, b[l]);
}
if (r < n) {
if (b[r + 1] > 0) add(r + 1, -b[r + 1]);
b[r + 1] -= x;
if (b[r + 1] > 0) add(r + 1, b[r + 1]);
}
long long t = getsum(n) + a[1];
if (t >= 0)
printf("%lld\n", (t + 1) / 2);
else
printf("%lld\n", t / 2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10, MA = 27, MN = 55;
string S, P;
bool can[2][MA][MN][MN];
vector<pair<int, int> > rule[MA];
int q, n;
int dp[MN][MN];
void solve(int id, string s) {
n = ((int)(s).size());
for (int sz = 0; sz < n; ++sz)
for (int l = 0; l + sz < n; ++l) {
int r = l + sz;
if (l == r) {
can[id][s[l] - 'a'][l][r] = true;
continue;
}
for (int d = 0; d < 26; ++d) {
for (int i = l; i < r && !can[id][d][l][r]; ++i)
for (auto x : rule[d]) {
if (can[id][x.first][l][i] && can[id][x.second][i + 1][r]) {
can[id][d][l][r] = true;
break;
}
}
}
}
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> S >> P;
cin >> q;
for (int i = 0; i < q; ++i) {
string str;
cin >> str;
rule[str[0] - 'a'].push_back({str[3] - 'a', str[4] - 'a'});
}
solve(0, S);
solve(1, P);
for (int i = 0; i < MN; ++i) fill(dp[i], dp[i] + MN, INF);
dp[0][0] = 0;
for (int i = 0; i < ((int)(S).size()); ++i)
for (int j = 0; j < ((int)(P).size()); ++j) {
for (int l1 = 0; l1 <= i; ++l1)
for (int l2 = 0; l2 <= j; ++l2)
for (int d = 0; d < 26; ++d) {
if (can[0][d][l1][i] && can[1][d][l2][j]) {
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], 1 + dp[l1][l2]);
}
}
}
int ans = dp[((int)(S).size())][((int)(P).size())];
cout << (ans >= INF ? -1 : ans) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 0, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n, k;
double dis, v1, v2;
bool check(double limit) {
int top = n / k + (n % k > 0);
double nowt = 0;
double nowd = 0;
for (int i = 1; i <= top; ++i) {
double dd = dis - nowd;
double tt = limit - nowt;
double go = tt * v1;
if (go >= dd) return 1;
double more = dd - go;
double dri = more / (v2 - v1);
nowt += dri;
nowd += dri * v1;
if (i < top) {
double d = dri * (v2 - v1);
double t = d / (v2 + v1);
nowt += t;
nowd += t * v1;
}
if (nowt > limit) return 0;
}
return 1;
}
void O1() {
double x = n / k + (n % k > 0);
double y = (x - 1) * (v2 - v1) / (v1 + v2);
double t2 = dis / v2 / (x - y);
double t1 = (dis - t2 * v2) / v1;
printf("%.10f\n", t1 + t2);
}
int main() {
while (~scanf("%d%lf%lf%lf%d", &n, &dis, &v1, &v2, &k)) {
O1();
continue;
double l = dis / v2;
double r = dis / v1;
for (int tim = 1; tim <= 200; ++tim) {
double mid = (l + r) / 2;
check(mid) ? r = mid : l = mid;
}
printf("%.10f\n", l);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long hsh1 = 1610612741;
const long long p1 = 37;
const long long hsh2 = 805306457;
const long long p2 = 31;
const int mxN = 10010;
long long p[mxN];
long long s[mxN];
long long c;
int N;
long long dp[2][mxN];
long long solve() {
dp[0][0] = p[0];
dp[0][1] = s[0];
for (int i = 1; i < N; i++) {
int d = i & 1;
int o = !d;
dp[d][0] = p[i] + dp[o][0];
for (int j = 1; j <= i; j++) {
dp[d][j] = min(dp[o][j - 1] + s[i], dp[o][j] + p[i] + j * c);
}
dp[d][i + 1] = dp[o][i] + s[i];
}
long long res = LLONG_MAX;
for (int i = 0; i <= N; i++) res = min(res, dp[!(N & 1)][i]);
return res;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> c;
for (int i = 0; i < N; i++) cin >> p[i];
for (int i = 0; i < N; i++) cin >> s[i];
cout << solve() << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ans;
string s;
void calc(string t, int c, int sum) {
if ((int)((t).size()) == 1) {
if (t[0] != char(c + 'a')) sum++;
ans = min(ans, sum);
return;
}
int x = 0, y = 0;
string a = "", b = "";
for (int i = 0; i < (int)((t).size()) / 2; i++) {
x += t[i] == char(c + 'a');
a += t[i];
}
for (int i = (int)((t).size()) / 2; i < (int)((t).size()); ++i) {
y += t[i] == char(c + 'a');
b += t[i];
}
x = (int)((t).size()) / 2 - x;
y = (int)((t).size()) / 2 - y;
calc(b, c + 1, sum + x);
calc(a, c + 1, sum + y);
}
void solve() {
cin >> n >> s;
ans = 1e9;
calc(s, 0, 0);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
vector<int> A(10001, 0);
vector<int> B(10001, 0);
int x;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
A[x]++;
}
for (int i = 0; i < m; i++) {
scanf("%d", &x);
B[x]++;
}
int flag = 1;
for (int i = 0; i < 10001; i++)
if (A[i] && B[i]) {
printf("YES\n1 %d\n", i);
flag = 0;
break;
}
if (flag) printf("NO\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, b;
cin >> n >> b;
long long int a[n], i, j, k, l, t1, t2, sum = 0, ad[n];
for (i = 0; i < n; i++) {
cin >> a[i];
ad[i] = a[i];
}
vector<pair<long long int, long long int>> v;
map<long long int, long long int> mp;
for (i = 0; i < b; i++) {
cin >> t1 >> t2;
v.push_back(make_pair(t1, t2));
}
sort(v.begin(), v.end());
sort(a, a + n);
i = j = sum = 0;
for (i = 0; i < n; i++) {
while (a[i] >= v[j].first && j < b) {
sum = sum + v[j].second;
j++;
}
mp[a[i]] = sum;
}
for (i = 0; i < n; i++) {
cout << mp[ad[i]] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
int res[3], a, b;
int main() {
res[0] = res[1] = res[2] = 0;
scanf("%ld%ld", &a, &b);
for (int i = 1; i <= 6; i++)
res[1 + (abs(a - i) > abs(b - i)) - (abs(a - i) < abs(b - i))]++;
for (int i = 0; i < 3; i++) printf("%ld ", res[i]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<string, int> mapping;
int mappingNumber = 1;
vector<vector<int> > adj;
int popularity[300], res;
string to_lower(string x) {
for (int i = 0; i < x.size(); i++) x[i] = tolower(x[i]);
return x;
}
void bfs() {
queue<int> q;
q.push(1);
for (int sz = q.size(), dist = 1; !q.empty(); sz = q.size(), dist++) {
while (sz--) {
int node = q.front();
q.pop();
popularity[node] = dist;
for (int i = 0; i < (int)adj[node].size(); i++) q.push(adj[node][i]);
}
}
for (int i = 1; i < mappingNumber; i++) res = max(res, popularity[i]);
}
int main() {
int n;
cin >> n;
mapping["polycarp"] = mappingNumber++;
adj = vector<vector<int> >(300 + 1);
for (int i = 0; i < n; i++) {
string a, temp, b;
cin >> a >> temp >> b;
a = to_lower(a);
b = to_lower(b);
if (!mapping[a]) mapping[a] = mappingNumber++;
if (!mapping[b]) mapping[b] = mappingNumber++;
adj[mapping[b]].push_back(mapping[a]);
}
bfs();
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 100001;
int main() {
int x, y, z, mm;
scanf("%d%d%d", &x, &y, &z);
map<string, int> pm;
string str1[100001], b;
int a[nn], lk;
int ss[nn];
memset(ss, 0x7f, sizeof(ss));
int num;
for (int i = 1; i <= x; i++) {
cin >> str1[i];
}
for (int i = 1; i <= x; i++) {
scanf("%d", &a[i]);
}
for (int j = 1; j <= y; j++) {
scanf("%d", &mm);
while (mm--) {
scanf("%d", &lk);
pm.insert(make_pair(str1[lk], j));
ss[j] = min(a[lk], ss[j]);
}
}
long long sum = 0;
map<string, int>::iterator iter;
for (int j = 1; j <= z; j++) {
cin >> b;
iter = pm.find(b);
sum += ss[iter->second];
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mat[6][7] = {
{0, 0, 0, 1, 1, 1, 1}, {0, 1, 1, 0, 0, 1, 1}, {1, 0, 1, 0, 1, 0, 1},
{0, 1, 1, 1, 1, 0, 0}, {1, 0, 1, 1, 0, 1, 0}, {1, 1, 0, 0, 1, 1, 0},
};
int aux[6][7];
int res[7];
bool solve() {
int p, div;
for (int i = 0; i < 6; ++i) {
p = i;
for (int j = i + 1; j < 6; ++j)
if (abs(aux[j][i]) > abs(aux[p][i])) p = j;
for (int j = 0; j <= 6; ++j) swap(aux[i][j], aux[p][j]);
div = aux[i][i];
for (int k = i; k <= 6; ++k) {
if (aux[i][k] % div != 0) return 0;
aux[i][k] /= div;
}
for (int j = i + 1; j < 6; ++j) {
div = aux[j][i];
for (int k = i; k <= 6; ++k) aux[j][k] -= div * aux[i][k];
}
}
for (int i = 6 - 1; i >= 0; --i) {
res[i] = aux[i][6];
for (int k = 6 - 1; k > i; --k) res[i] -= res[k] * aux[i][k];
}
return 1;
}
int main() {
int big = 0;
for (int i = 0; i < 6; ++i)
scanf("%d", &mat[i][6]), big = max(big, mat[i][6]);
bool g = 0;
for (int i = 0; i <= big && !g; ++i) {
memcpy(aux, mat, sizeof aux);
for (int j = 0; j < 3; ++j) aux[j][6] -= i;
g = solve();
for (int j = 0; j < 6 && g; ++j)
if (res[j] < 0) g = 0;
res[6] = i;
int a = 0;
for (int i = 0; i < 7; ++i) a += res[i];
if (!g) continue;
printf("%d\n", a);
for (int j = 3; j >= 0; --j) {
for (int i = 0; i < 7; ++i) {
char b = 'a';
if ((i + 1) & 1 << j) b = 'b';
for (int k = 0; k < res[i]; ++k) printf("%c", b);
}
printf("\n");
}
}
if (!g) printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, a, b, x;
cin >> n >> m >> k;
vector<pair<int, int> > r(n, {0, -1}), c(m, {0, -1});
for (int i = 0; i < k; i++) {
cin >> a >> b >> x;
if (a == 1) r[b - 1] = {x, i};
if (a == 2) c[b - 1] = {x, i};
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j) cout << " ";
if (r[i].second < c[j].second)
cout << c[j].first;
else
cout << r[i].first;
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
int n, q, bit[30][N];
char s[N];
void update(int j, int x, int val) {
for (int i = x; i <= n; i += (i & -i)) bit[j][i] += val;
}
int get(int j, int x) {
int res = 0;
if (x == 0) return 0;
for (int i = x; i > 0; i -= (i & -i)) res += bit[j][i];
return res;
}
void Update(int x, char t, int val) {
int j = t - 'a' + 1;
update(j, x, val);
}
int cal(int l, int r) {
int ans = 0;
for (int j = 1; j <= 26; j++) {
if (get(j, r) - get(j, l - 1) > 0) ans++;
}
return ans;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) Update(i, s[i], 1);
cin >> q;
while (q--) {
int type;
scanf("%d", &type);
if (type == 2) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d\n", cal(u, v));
} else {
int pos;
scanf("%d", &pos);
pos--;
char t;
cin >> t;
Update(pos + 1, s[pos + 1], -1);
Update(pos + 1, t, 1);
s[pos + 1] = t;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
void solve() {
int n, b, d;
cin >> n >> b >> d;
int res = 0;
int currMass = 0;
for (int i = 0; i < n; i++) {
int got;
cin >> got;
if (got > b) continue;
currMass += got;
if (currMass > d) {
currMass = 0;
res++;
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool two[10005] = {0};
bool three[10005] = {0};
int main() {
string s;
cin >> s;
set<string> ans;
two[s.size()] = three[s.size()] = 1;
for (int i = s.size() - 2; i >= 5; i--) {
string p = string(1, s[i]) + string(1, s[i + 1]);
if (three[i + 2]) {
ans.insert(p);
two[i] = 1;
} else if (two[i + 2] && p != string(1, s[i + 2]) + string(1, s[i + 3])) {
ans.insert(p);
two[i] = 1;
}
p = string(1, s[i]) + string(1, s[i + 1]) + string(1, s[i + 2]);
if (two[i + 3]) {
ans.insert(p);
three[i] = 1;
} else if (three[i + 3] && p != string(1, s[i + 3]) + string(1, s[i + 4]) +
string(1, s[i + 5])) {
three[i] = 1;
ans.insert(p);
}
}
cout << ans.size() << '\n';
for (string s : ans) cout << s << '\n';
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
void FASTIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
string s;
void solve() {
cin >> s;
string output = "";
long long n = s.length();
output += s[n - 1];
char c = s[n - 1];
for (long long i = n - 1 - 1; i >= 0; i--) {
if (s[i] >= c) {
c = s[i];
output += c;
}
}
reverse(output.begin(), output.end());
cout << output;
}
int32_t main() {
FASTIO();
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << endl;
return os;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
;
string t;
cin >> t;
;
int n = s.length();
int m = t.length();
vector<int> before(n);
for (int i = 1; i < n; ++i) {
before[i] = before[i - 1];
if (before[i] < m && s[i - 1] == t[before[i]]) before[i]++;
}
vector<int> after(n);
for (int i = n - 1; i >= 0; --i) {
if (i < n - 1) after[i] = after[i + 1];
if (after[i] < m && s[i] == t[m - 1 - after[i]]) after[i]++;
}
int charPointer[m][200];
for (char c = 'a'; c <= 'z'; c++) charPointer[m - 1][c] = -1;
charPointer[m - 1][t.back()] = m - 1;
for (int i = m - 2; i >= 0; --i) {
for (char c = 'a'; c <= 'z'; c++) charPointer[i][c] = charPointer[i + 1][c];
charPointer[i][t[i]] = i;
}
for (int i = 0; i < n; ++i) {
if (after[i] == 0) {
cout << "No";
return 0;
}
int mn = m - after[i];
mn = charPointer[mn][s[i]];
if (mn == -1) {
cout << "No";
return 0;
}
if (before[i] < mn) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T > 0) {
int x, y, n;
cin >> x >> y >> n;
int rem = n % x;
if (rem > y)
cout << n - (rem - y) << endl;
else if (rem < y)
cout << n - rem - (x - y) << endl;
else
cout << n << endl;
T--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long arr[(1 << 21) + 20];
vector<long long> tree[4 * (1 << 21)];
long long normal[25];
long long rev[25];
bool check[25];
void merge_sort(long long node, long long a, long long b, long long lev) {
if (a == b) {
tree[node].push_back(arr[a]);
return;
}
long long mid = (a + b) / 2, left, right;
left = node * 2;
right = left + 1;
merge_sort(left, a, mid, lev + 1);
merge_sort(right, mid + 1, b, lev + 1);
long long i = 0, j = 0;
while (1) {
if (i == tree[left].size()) {
for (long long ind = j; ind < tree[right].size(); ind++) {
tree[node].push_back(tree[right][ind]);
}
break;
}
if (j == tree[right].size()) {
for (long long ind = i; ind < tree[left].size(); ind++) {
tree[node].push_back(tree[left][ind]);
}
break;
}
if (tree[left][i] > tree[right][j]) {
normal[lev] += tree[left].size() - i;
tree[node].push_back(tree[right][j]);
j++;
} else {
tree[node].push_back(tree[left][i]);
i++;
}
}
i = j = 0;
while (1) {
if (i == tree[left].size()) break;
if (j == tree[right].size()) break;
if (tree[left][i] < tree[right][j]) {
rev[lev] += tree[right].size() - j;
i++;
} else {
j++;
}
}
}
int main() {
long long i, j, k, l, m, n, o;
long long testcase;
long long input, flag, tag, ans;
scanf("%lld", &n);
long long sz = (1 << n);
for (i = 1; i <= sz; i++) scanf("%lld", &arr[i]);
merge_sort(1, 1, sz, 0);
scanf("%lld", &m);
for (i = 0; i < 24; i++) check[i] = 1;
long long x;
for (long long y = 1; y <= m; y++) {
scanf("%lld", &x);
long long lev = n - x;
for (i = lev; i <= n; i++) {
if (check[i])
check[i] = 0;
else
check[i] = 1;
}
ans = 0;
for (i = 0; i <= n; i++) {
if (check[i])
ans += normal[i];
else
ans += rev[i];
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct team {
int id1;
int id2;
int strength;
} data[1000000];
bool comp(const team &a, const team &b) { return a.strength < b.strength; }
int main() {
int n;
scanf("%d", &n);
int people = 2 * n;
int count = 0;
for (int i = 2; i <= people; i++) {
for (int j = 0; j < i - 1; j++) {
int temp;
scanf("%d", &temp);
data[count].id1 = i;
data[count].id2 = j + 1;
data[count].strength = temp;
count++;
}
}
sort(data, data + count, comp);
int teams[1000];
for (int y = 0; y <= 990; y++) {
teams[y] = 0;
}
int track = 0;
int curr = count - 1;
while (track != n) {
if (teams[data[curr].id1] == 0 && teams[data[curr].id2] == 0) {
teams[data[curr].id1] = data[curr].id2;
teams[data[curr].id2] = data[curr].id1;
track++;
}
curr--;
}
for (int i = 1; i <= 2 * n; i++) {
printf("%d ", teams[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> M;
multiset<int>::iterator it;
int m[3];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < 3; i++) scanf("%d", m + i);
sort(m, m + 3);
int a = m[0], b = m[1], c = m[2];
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
if (t > a + b + c) {
puts("-1");
return 0;
}
M.insert(t);
}
int ans = 0;
while (!M.empty()) {
it = M.lower_bound(b + c + 1);
if (it == M.end()) break;
M.erase(it);
ans++;
}
while (!M.empty()) {
it = M.lower_bound(a + c + 1);
if (it == M.end()) break;
M.erase(it);
ans++;
if (M.empty()) break;
it = M.lower_bound(a + 1);
if (it != M.begin()) M.erase(--it);
}
while (!M.empty()) {
it = M.lower_bound(max(c, a + b) + 1);
if (it == M.end()) break;
M.erase(it);
ans++;
if (M.empty()) break;
it = M.lower_bound(b + 1);
if (it != M.begin()) M.erase(--it);
}
int x = 0, y = 0, k = 0;
for (it = M.begin(); it != M.end(); it++) {
if (*it <= a + b) x++;
if (*it <= c) y++;
}
int s = max((max(x, y) + 1) / 2, max(x - y, y - x));
while (!M.empty() && y) {
it = M.lower_bound(c + 1);
if (it != M.begin()) {
--it;
if (*it <= a + b) x--;
if (*it <= c) y--;
M.erase(it);
}
it = M.lower_bound(b + 1);
if (it != M.begin()) {
--it;
if (*it <= a + b) x--;
if (*it <= c) y--;
M.erase(it);
}
it = M.lower_bound(a + 1);
if (it != M.begin()) {
--it;
if (*it <= a + b) x--;
if (*it <= c) y--;
M.erase(it);
}
s = min(s, ++k + max((max(x, y) + 1) / 2, max(x - y, y - x)));
}
printf("%d\n", ans + s);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int N = 2e4 + 10;
int a[N], b[N];
vector<int> v[N], v1[N];
int ans[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
v[a[i]].push_back(b[i]);
if (b[i] > a[i]) {
v1[a[i]].push_back(b[i] - a[i]);
} else {
v1[a[i]].push_back(b[i] - a[i] + n);
}
}
for (int i = 1; i <= n; i++) {
sort(v1[i].begin(), v1[i].end());
}
for (int i = 1; i <= n; i++) {
if (v1[i].size() == 0) continue;
ans[i] = ((int)v1[i].size() - 1) * n + v1[i][0];
}
for (int i = 1; i <= n; i++) {
int res = 0;
for (int j = 1; j <= n; j++) {
if (ans[j] == 0) continue;
if (j >= i) {
res = max(res, j - i + ans[j]);
} else {
res = max(res, n + j - i + ans[j]);
}
}
cout << res << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double a[2000002], b[2000002];
map<long long, long long> mp;
int main() {
int n;
cin >> n;
long double sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = b[i - 1] + a[i];
mp[a[i]]++;
long double x = a[i] - 1;
int y = a[i];
int z = a[i] + 1;
if (i != 1)
sum = sum + y * (i - mp[x] - mp[y] - mp[z]) -
(b[i - 1] - x * mp[x] - y * (mp[y] - 1) - z * mp[z]);
}
cout << fixed << setprecision(0) << sum << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[5005];
struct node {
int cost, w;
node(int co, int w) : cost(co), w(w){};
};
vector<node> p;
vector<node>::iterator it;
bool cmp(node a, node b) {
if (a.cost == b.cost) return a.w < b.w;
return a.cost < b.cost;
}
int main() {
int n, k;
p.push_back(node(0, 0));
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 1; j <= k; j++) {
p.push_back(node(a[i] * j, j));
}
}
sort(p.begin(), p.end(), cmp);
int q, m;
cin >> q;
int ans;
for (int t = 1; t <= q; t++) {
cin >> m;
ans = k + 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (m < a[i] * j) continue;
int re = m - a[i] * j;
it = lower_bound(p.begin(), p.end(), node(re, 0), cmp);
if (it != p.end() && it->cost == re) ans = min(ans, it->w + j);
}
}
if (ans > k)
cout << -1 << endl;
else
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > p;
long long int fact[1000005];
long long int dp[1000005] = {0};
long long int ifact[1000005];
long long int be(long long int x, long long int n, long long int m) {
long long int r = 1;
x = x % m;
while (n > 0) {
if (n % 2 == 1) r = r * x % m;
x = x * x % m;
n = n / 2;
}
return r;
}
void pre() {
fact[0] = 1;
fact[1] = 1;
for (long long int i = 2; i < 1000005; i++)
fact[i] = (fact[i - 1] * i) % 1000000007;
ifact[1000005 - 1] = be(fact[1000005 - 1], 1000000007 - 2, 1000000007);
for (long long int i = 1000005 - 2; i >= 0; i--)
ifact[i] = (ifact[i + 1] * (i + 1)) % 1000000007;
}
long long int ncr(long long int n, long long int r) {
if (n < r) return 0;
return ((fact[n] * ifact[n - r]) % 1000000007 * ifact[r]) % 1000000007;
}
int main() {
pre();
long long int h, w, n;
scanf("%lld%lld%lld", &h, &w, &n);
p.push_back({h, w});
p.push_back({1, 1});
for (long long int i = 0; i < n; i++) {
scanf("%lld%lld", &h, &w);
p.push_back({h, w});
}
sort(p.begin(), p.end());
for (long long int i = 0; i < p.size(); i++) {
dp[i] = ncr(p[i].first + p[i].second - 2, p[i].first - 1);
}
for (long long int i = 1; i < p.size(); i++) {
for (long long int j = 1; j < i; j++) {
if (p[j].second <= p[i].second && p[i].first <= p[i].first) {
long long int x = p[i].second - p[j].second;
long long int y = p[i].first - p[j].first;
long long int val = ncr(x + y, x);
dp[i] = (dp[i] - (dp[j] * val) % 1000000007 + 1000000007) % 1000000007;
}
}
}
printf("%lld\n", dp[p.size() - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int form[9], piece[9][2];
map<int, int> res;
string result[] = {
"illegal", "the first player won", "the second player won", "draw", "first",
"second"};
void pre() {
form[0] = 3;
piece[0][0] = 1;
piece[0][1] = 1 << 1;
for (int i = 1; i < 9; i++) {
form[i] = form[i - 1] << 2;
piece[i][0] = piece[i - 1][0] << 2;
piece[i][1] = piece[i - 1][1] << 2;
}
}
int add(int now, int p, int who, bool end) {
int px = p / 3 * 3, py = p % 3;
if ((piece[px][who] & now) && (piece[px + 1][who] & now) &&
(piece[px + 2][who] & now))
return who + 1;
if ((piece[py][who] & now) && (piece[py + 3][who] & now) &&
(piece[py + 6][who] & now))
return who + 1;
if ((p == 0 || p == 4 || p == 8) && (piece[0][who] & now) &&
(piece[4][who] & now) && (piece[8][who] & now))
return who + 1;
if ((p == 2 || p == 4 || p == 6) && (piece[2][who] & now) &&
(piece[4][who] & now) && (piece[6][who] & now))
return who + 1;
return end ? 3 : 5 - who;
}
void enumeration(int now, int who, int round) {
for (int p = 0; p < 9; p++) {
if (now & form[p]) continue;
now ^= piece[p][who];
if (!res[now]) {
res[now] = add(now, p, who, round == 9);
if (res[now] > 3) enumeration(now, who ^ 1, round + 1);
}
now ^= piece[p][who];
}
}
int main() {
int now = 0;
char ch;
pre();
enumeration(now, 0, 1);
for (int p = 0; p < 9; p++) {
cin >> ch;
if (ch == 'X')
now ^= piece[p][0];
else if (ch == '0')
now ^= piece[p][1];
}
cout << result[res[now]] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2;
int ql[N], qr[N], w[N], l[N], r[N], p[N];
long long ans[N];
vector<int> st[4 * N];
long long sr[N], sl[N];
namespace seg {
inline long long get(long long a[], int x, int y) {
if (x > y) return 0;
if (x == 0) return a[y];
return a[y] - a[x - 1];
}
void build(int cur, int b, int e) {
if (b + 1 < e) {
int m = (b + e) >> 1;
build(cur << 1, b, m);
build(cur << 1 | 1, m, e);
}
int sz = e - b;
sort(r + b, r + e);
sort(l + b, l + e);
for (int i = 0; i < sz; ++i) {
sr[i] = r[b + i], sl[i] = l[b + i];
if (i > 0) sr[i] += sr[i - 1], sl[i] += sl[i - 1];
}
for (auto i : st[cur]) {
int x = ql[i], y = qr[i];
int p1 = upper_bound(r + b, r + e, y) - r - b;
int p2 = lower_bound(l + b, l + e, x) - l - b;
ans[i] += get(sr, 0, p1 - 1) + ((long long)sz - p1) * y -
(get(sl, p2, sz - 1) + (long long)p2 * x);
}
}
void query(int cur, int b, int e, int x, int y, int i) {
if (x <= b && e <= y) {
st[cur].push_back(i);
return;
}
int m = (b + e) >> 1;
if (x < m) query(cur << 1, b, m, x, y, i);
if (m < y) query(cur << 1 | 1, m, e, x, y, i);
}
}; // namespace seg
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> p[i], w[p[i]] = i;
for (int i = 0; i < q; ++i) cin >> ql[i];
for (int i = 0; i < q; ++i) cin >> qr[i];
vector<int> cur;
for (int i = 0; i < n; ++i) {
auto it = upper_bound(cur.rbegin(), cur.rend(), p[i]);
l[i] = (it == cur.rend()) ? 0 : (w[*it] + 1);
while (!cur.empty() && cur.back() < p[i]) cur.pop_back();
cur.push_back(p[i]);
}
cur.clear();
for (int i = n - 1; i >= 0; --i) {
auto it = upper_bound(cur.rbegin(), cur.rend(), p[i]);
r[i] = (it == cur.rend()) ? n : (w[*it]);
while (!cur.empty() && cur.back() < p[i]) cur.pop_back();
cur.push_back(p[i]);
}
for (int i = 0; i < q; ++i) seg::query(1, 0, n, --ql[i], qr[i], i);
seg::build(1, 0, n);
for (int i = 0; i < q; ++i) cout << ans[i] << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 200010;
char s[N];
int main() {
int n, k;
scanf("%d%d%s", &n, &k, s);
int max = 0;
for (int i = 0; i < 26; ++i) {
int pre = 0;
int cnt = 0;
for (int j = 0; j <= n; ++j) {
if (s[j] != i + 'a') {
cnt += (j - pre) / k;
pre = j + 1;
}
}
max = std::max(max, cnt);
}
printf("%d\n", max);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.