solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
struct DOM {
int id;
int x;
int h;
} dom[100010];
int n;
int i, j;
int ans[100010];
bool cmpx(const DOM& A, const DOM& B) { return A.x > B.x; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) ans[dom[i].id = i] = 1;
for (i = 1; i <= n; i++) scanf("%d%d", &dom[i].x, &dom[i].h);
std::sort(dom + 1, dom + 1 + n, cmpx);
for (i = 1; i <= n; i++)
for (j = i - 1; j && dom[i].x + dom[i].h > dom[j].x; j -= ans[dom[j].id])
ans[dom[i].id] += ans[dom[j].id];
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 5 |
#include <stdio.h>
int main(void){
int n,b,f,r,v,i;
int p[4][3][10] = {};
scanf ("%d",&n);
for (i = 0; i < n; i++){
scanf("%d %d %d %d",&b,&f,&r,&v);
p[b - 1][f - 1][r - 1] += v;
}
for (b = 0; b < 4; b++){
if (b != 0){printf("####################\n");}
for (f = 0; f < 3; f++){
for (r = 0; r < 10; r++){
printf(" %d",p[b][f][r]);
}
printf("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n = -1;
cin >> n;
long long int a = min((long long int)2, n);
vector<array<long long int, 3>> t;
int x, h;
for (int i = 0; i < n; i++) {
cin >> x >> h;
t.push_back({x, h, 1});
}
sort(t.begin(), t.end());
for (int i = 1; i < n - 1; i++) {
if (t.at(i).at(2) && t.at(i).at(0) - t.at(i).at(1) > t.at(i - 1).at(0)) {
a++;
} else if (t.at(i).at(0) + t.at(i).at(1) < t.at(i + 1).at(0)) {
a++;
if (t.at(i).at(0) + t.at(i).at(1) >=
t.at(i + 1).at(0) - t.at(i + 1).at(1)) {
t.at(i + 1).at(2) = 0;
}
}
}
cout << a << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 100000 + 117;
const int MM = 10000 + 117;
int read() {
int fl = 1, x;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
fl = -1;
c = getchar();
}
for (x = 0; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + c - '0';
return x * fl;
}
void open() { freopen("a.in", "r", stdin); }
void close() {
fclose(stdin);
fclose(stdout);
}
int m, n;
struct edge {
int to, len;
edge(int t = 0, int l = 0) { to = t, len = l; }
};
vector<edge> p[NN] = {};
long long dep[NN] = {};
long long v[NN] = {};
int f[NN] = {};
void dfs(int x, int fa) {
f[x] = fa;
for (int i = 0; i < p[x].size(); ++i) {
int cur = p[x][i].to;
if (cur != fa) {
dep[cur] = dep[x] + p[x][i].len;
dfs(cur, x);
}
}
}
long long lim;
int ord[NN] = {};
int fa[NN] = {};
int siz[NN] = {};
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
bool link(int x, int y) {
if (getfa(x) == getfa(y)) return false;
siz[fa[y]] += siz[fa[x]];
fa[fa[x]] = fa[y];
return true;
}
bool cmp(int a, int b) { return v[a] > v[b]; }
int main() {
n = read();
for (int i = 1; i < n; ++i) {
int x = read(), y = read(), v = read();
p[x].push_back(edge(y, v));
p[y].push_back(edge(x, v));
}
int rt = 1;
for (int ti = 1; ti <= 3; ++ti) {
dep[rt] = 0;
dfs(rt, 0);
for (int i = 1; i <= n; ++i) {
if (dep[i] > dep[rt]) rt = i;
v[i] = max(v[i], dep[i]);
}
}
for (int i = 1; i <= n; ++i) {
if (v[rt] > v[i]) rt = i;
}
dfs(rt, 0);
int q = read();
for (int i = 1; i <= n; ++i) ord[i] = i;
sort(ord + 1, ord + 1 + n, cmp);
for (int ti = 1; ti <= q; ++ti) {
scanf("%I64d", &lim);
for (int i = 1; i <= n; ++i) fa[i] = i, siz[i] = 1;
int pos = 1;
int ans = 0;
for (int i = 1; i <= n; ++i) {
int x = ord[i];
for (int j = 0; j < p[x].size(); ++j) {
int cur = p[x][j].to;
if (cur != f[x]) {
link(x, cur);
}
}
while (v[ord[pos]] > v[x] + lim) {
getfa(ord[pos]);
siz[fa[ord[pos]]]--;
pos++;
}
ans = max(ans, siz[getfa(x)]);
}
printf("%d\n", ans);
}
close();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
if (x > a[n - 1]) {
cout << n + 1;
return 0;
}
if (x < a[0]) {
cout << n;
return 0;
}
int med, c, ind, ind2;
bool d = 0;
if (n % 2)
med = (n + 1) / 2 - 1;
else {
med = (n / 2 - 1);
}
for (int i = 0; i < n; i++) {
if (a[i] == x) {
if (d == 0) {
d = 1;
ind = i;
c = abs(med - i);
} else {
if (abs(med - i) < c) {
ind = i;
c = abs(med - i);
}
}
}
}
int coun = 0;
if (!d) {
n++;
a.push_back(x);
sort(a.begin(), a.end());
if (n % 2)
med = (n + 1) / 2 - 1;
else {
med = (n / 2 - 1);
}
for (int i = 0; i < a.size(); i++) {
if (a[i] == x) {
ind = i;
break;
}
}
coun++;
}
if (ind > med) {
if (n % 2)
coun += 2 * abs(med - ind);
else {
coun += 2 * abs(med - ind) - 1;
}
} else if (ind < med) {
if (n % 2)
coun += 2 * abs(med - ind) - 1;
else {
coun += 2 * abs(med - ind);
}
}
cout << coun;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long seive() {
vector<set<long long> > v(n + 1);
vector<long long> primes;
for (long long i = 2; i <= n; i++) {
if (v[i].size() == 0) {
primes.push_back(i);
for (long long j = i; j <= n; j += i) {
v[j].insert(i);
}
}
}
long long cnt = 0;
for (long long i = 2; i <= n; i++) {
if (v[i].size() == 2) cnt++;
}
return cnt;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cout << seive();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
vector<int> a(n);
vector<pair<int, int> > d;
for (int i = 0; i < n; i++) {
cin >> a[i];
d.push_back(make_pair(a[i], 0));
}
cin >> m;
vector<int> b(m);
vector<pair<int, int> > c(n + m);
vector<pair<int, int> > sum(n + m, make_pair(0, 0));
for (int i = 0; i < m; i++) {
cin >> b[i];
d.push_back(make_pair(b[i], 1));
}
sort(d.begin(), d.end());
int tog = 0;
if (d[0].second)
sum[0].second = 1;
else
sum[0].first = 1;
for (int i = 0; i < n + m; i++) {
if (i > 0) {
sum[i].first = sum[i - 1].first;
sum[i].second = sum[i - 1].second;
}
if (!d[i].second) {
tog++;
if (i > 0) sum[i].first++;
} else {
tog--;
if (i > 0) sum[i].second++;
}
c[i].first = tog;
c[i].second = i;
}
sort(c.begin(), c.end());
if (c[0].first < 0)
cout << 3 * n - sum[c[0].second].first << ":"
<< 3 * m - sum[c[0].second].second << endl;
else
cout << 3 * n << ":" << 3 * m;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[3005], m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
sort(a + 1, a + m + 1);
if (a[1] == 1 || a[m] == n) {
printf("NO");
return 0;
}
for (int i = 1; i <= m - 2; i++)
if (a[i] == a[i + 1] - 1 && a[i + 1] == a[i + 2] - 1) {
printf("NO");
return 0;
}
printf("YES");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
int n, m, l, left, right, ans;
cin >> n >> m;
string s;
cin >> s;
string a[6] = {"abc", "bca", "cab", "acb", "bac", "cba"};
for (int i = 0; i < 6; i++) {
for (int j = 3; j < n; j++) {
a[i].append(1, a[i][j - 3]);
}
}
int b[6][n + 1];
for (int i = 0; i < 6; i++) {
for (int j = 0; j <= n; j++) {
if (j == 0) {
b[i][j] = 0;
} else if (s[j - 1] == a[i][j - 1]) {
b[i][j] = b[i][j - 1];
} else {
b[i][j] = b[i][j - 1] + 1;
}
}
}
while (m--) {
cin >> left >> right;
ans = 1000000;
for (int i = 0; i < 6; i++) {
ans = min(ans, b[i][right] - b[i][left - 1]);
}
cout << ans << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long f[100007], ans[100007];
struct tak {
long long s;
long long d;
long long p;
long long id;
};
long long cmp(tak x, tak y) { return x.s < y.s; }
tak a[100007];
int main() {
long long n, m, i, j, sum, c;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a[i].s >> a[i].p >> a[i].d;
a[i].id = i;
}
for (i = 1; i <= n; i++) f[i] = 0;
for (i = 0; i < m; i++) {
c = 0;
sum = 0;
for (j = 1; j <= n; j++) {
if (f[j] <= a[i].s) c++;
}
if (c < a[i].p)
ans[a[i].id] = -1;
else {
c = 0;
for (j = 1; j <= n; j++) {
if (a[i].p == c) break;
if (f[j] <= a[i].s) {
f[j] = a[i].s + a[i].d;
sum += j;
c++;
}
}
ans[a[i].id] = sum;
}
}
for (i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 5;
long long w[MAXN];
vector<long long> path[MAXN];
long long dp[MAXN], sdp[MAXN];
vector<long long> nd[MAXN];
long long n, l, s;
long long ver[MAXN], tin[MAXN], tout[MAXN];
pair<long long, long long> dfahdasfdashsdf[MAXN << 2];
long long fasjkfhdksjafhasdfadfs[MAXN << 2];
void push_weight(long long id, long long l, long long r) {
dfahdasfdashsdf[id].first += fasjkfhdksjafhasdfadfs[id];
if (l != r) {
fasjkfhdksjafhasdfadfs[id << 1] += fasjkfhdksjafhasdfadfs[id];
fasjkfhdksjafhasdfadfs[id << 1 | 1] += fasjkfhdksjafhasdfadfs[id];
}
fasjkfhdksjafhasdfadfs[id] = 0;
}
void build_weight(long long id = 1, long long l = 1, long long r = n) {
if (l == r) {
dfahdasfdashsdf[id].second = ver[l];
return;
}
long long mid = l + r >> 1;
build_weight(id << 1, l, mid);
build_weight(id << 1 | 1, mid + 1, r);
dfahdasfdashsdf[id] =
max(dfahdasfdashsdf[id << 1], dfahdasfdashsdf[id << 1 | 1]);
}
void upd_weight(long long u, long long v, long long val, long long id = 1,
long long l = 1, long long r = n) {
push_weight(id, l, r);
if (r < u || l > v) return;
if (l >= u && r <= v) {
fasjkfhdksjafhasdfadfs[id] = val;
push_weight(id, l, r);
return;
}
long long mid = l + r >> 1;
upd_weight(u, v, val, id << 1, l, mid);
upd_weight(u, v, val, id << 1 | 1, mid + 1, r);
dfahdasfdashsdf[id] =
max(dfahdasfdashsdf[id << 1], dfahdasfdashsdf[id << 1 | 1]);
}
pair<long long, long long> max_weight(long long u, long long v,
long long id = 1, long long l = 1,
long long r = n) {
push_weight(id, l, r);
if (r < u || l > v) return {0, 0};
if (l >= u && r <= v) return dfahdasfdashsdf[id];
long long mid = l + r >> 1;
return max(max_weight(u, v, id << 1, l, mid),
max_weight(u, v, id << 1 | 1, mid + 1, r));
}
long long st[MAXN << 2], lz[MAXN << 2];
void push(long long id, long long l, long long r) {
st[id] += lz[id];
if (st[id] > 1e18) st[id] = 1e18;
if (l != r) {
lz[id << 1] += lz[id];
lz[id << 1 | 1] += lz[id];
if (lz[id << 1] > 1e18) lz[id << 1] = 1e18;
if (lz[id << 1 | 1] > 1e18) lz[id << 1 | 1] = 1e18;
}
lz[id] = 0;
}
void upd(long long u, long long v, long long val, long long id = 1,
long long l = 1, long long r = n) {
push(id, l, r);
if (r < u || l > v) return;
if (l >= u && r <= v) {
lz[id] = val;
push(id, l, r);
return;
}
long long mid = l + r >> 1;
upd(u, v, val, id << 1, l, mid);
upd(u, v, val, id << 1 | 1, mid + 1, r);
st[id] = min(st[id << 1], st[id << 1 | 1]);
}
long long gmin(long long u, long long v, long long id = 1, long long l = 1,
long long r = n) {
push(id, l, r);
if (r < u || l > v) return 1e18;
if (l >= u && r <= v) return st[id];
long long mid = l + r >> 1;
return min(gmin(u, v, id << 1, l, mid), gmin(u, v, id << 1 | 1, mid + 1, r));
}
long long mx_dep = 0;
void dfs(long long u, long long dep = 0) {
static long long timer = 0;
tin[u] = ++timer;
ver[timer] = u;
nd[dep].push_back(u);
mx_dep = max(mx_dep, dep);
for (long long v : path[u]) dfs(v, dep + 1);
tout[u] = timer;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> l >> s;
for (long long i = 1; i <= n; i++) {
cin >> w[i];
if (w[i] > s) return cout << -1, 0;
}
for (long long i = 2, p; i <= n; i++) cin >> p, path[p].push_back(i);
dfs(1);
build_weight();
for (long long i = mx_dep; i >= 0; i--)
for (long long u : nd[i]) {
if (i + l <= n)
for (long long v : nd[i + l]) upd(tin[v], tin[v], 1e18);
upd_weight(tin[u], tout[u], w[u]);
for (long long v : path[u]) sdp[u] += dp[v];
while (true) {
auto vv = max_weight(tin[u], tout[u]);
if (vv.first <= s) break;
upd(tin[vv.second], tin[vv.second], 1e18);
upd_weight(tin[vv.second], tin[vv.second], -1e18);
}
dp[u] = min(sdp[u] + 1, sdp[u] + 1 + gmin(tin[u] + 1, tout[u]));
upd(tin[u], tin[u], sdp[u] - dp[u]);
}
cout << dp[1] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> arr(n);
for (auto& x : arr) cin >> x;
vector<int> p(m);
for (int i = 0; i < m; i++) p[i] = i;
vector<vector<int>> mp(m);
int ans = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && arr[i - 1] != arr[i]) ans++;
mp[arr[i] - 1].push_back(i);
}
cout << ans << endl;
for (int i = 0; i < m - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
while (p[u] != u) {
u = p[u];
}
while (p[v] != v) {
v = p[v];
}
if (mp[v].size() > mp[u].size()) swap(u, v);
for (int x : mp[v]) {
if (x + 1 < n && arr[x + 1] == u + 1) ans--;
if (x > 0 && arr[x - 1] == u + 1) ans--;
}
for (int x : mp[v]) {
arr[x] = u + 1;
mp[u].push_back(x);
}
mp[v].clear();
p[v] = u;
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, x, y;
cin >> n >> m >> x >> y;
x--, y--;
vector<vector<bool> > v(n, vector<bool>(m, true));
vector<pair<int32_t, int32_t> > ans;
int x1 = x, y1 = y;
for (int i = y; i >= 0; --i) {
ans.push_back({x, i});
v[x][i] = false;
}
for (int i = y + 1; i < m; ++i) {
ans.push_back({x, i});
v[x][i] = false;
}
y = m - 1;
x = x1 - 1;
if (v[x][y]) {
ans.push_back({x, y});
v[x][y] = false;
}
bool flag = true;
while (flag) {
v[x][y] = false;
flag = false;
while (x > 0 && v[x - 1][y]) {
x--;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
while (y > 0 && v[x][y - 1]) {
y--;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
while (x < n - 1 && v[x + 1][y]) {
x++;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
while (y < m - 1 && v[x][y + 1]) {
y++;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
}
x = n - 1;
if (y != m - 1) {
for (int i = y; i >= 0; --i) {
ans.push_back({x, i});
v[x][i] = false;
}
for (int i = y + 1; i < m; ++i) {
ans.push_back({x, i});
v[x][i] = false;
}
y = m - 1;
}
flag = true;
while (flag) {
v[x][y] = false;
flag = false;
while (x > 0 && v[x - 1][y]) {
x--;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
while (y > 0 && v[x][y - 1]) {
y--;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
while (x < n - 1 && v[x + 1][y]) {
x++;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
while (y < m - 1 && v[x][y + 1]) {
y++;
v[x][y] = false;
ans.push_back({x, y});
flag = true;
}
}
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
const int N = 1e5 + 5;
vector<int> adj[N];
int n, k, a[N], ans;
int dfs(int u) {
int ret = 0;
for(int v : adj[u]) {
int x = dfs(v);
if(x == k - 1 && u != 1) ++ans;
else ret = max(ret, 1 + x);
}
return ret;
}
int main() {
scanf("%d %d %d", &n, &k, &a[1]);
for(int i = 2; i <= n; ++i) {
scanf("%d", &a[i]);
adj[a[i]].push_back(i);
}
ans = a[1] != 1;
dfs(1);
printf("%d\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long tc;
cin >> tc;
while (tc--) {
long long n, m;
cin >> n >> m;
string s;
cin >> s;
long long arr[m];
for (long long i = 0; i < m; i++) cin >> arr[i];
long long MM = 97;
long long dp[n + 1][26];
unordered_map<long long, long long, custom_hash> mp;
for (auto ch : s) mp[ch % MM]++;
for (long long i = 0; i < 26; i++) {
dp[n][i] = mp[i];
}
for (long long i = n - 1; i >= 1; i--) {
long long target = s[i] % MM;
for (long long j = 0; j < 26; j++) {
if (target == j) {
dp[i][j] = dp[i + 1][j] - 1;
} else {
dp[i][j] = dp[i + 1][j];
}
}
}
long long res[26];
for (long long i = 0; i < 26; i++) {
res[i] = dp[n][i];
}
for (long long i = 0; i < m; i++) {
long long l = arr[i];
for (long long j = 0; j < 26; j++) res[j] += dp[l][j];
}
for (long long i = 0; i < 26; i++) cout << res[i] << " ";
}
return 0;
}
| 3 |
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cctype>
#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
typedef pair<int ,int> P;
class Coordinates
{
public:
int x;
int y;
//Coordinates(int a, int b) { x=a; y=b; }
Coordinates operator+(Coordinates p)
{
Coordinates tmp;
tmp.x = x + p.x;
tmp.y = y + p.y;
return tmp;
}
Coordinates(){ x = 0; y = 0;};
//Coordinates(int a, int b);
Coordinates(int a, int b) { x = a; y = b;}
friend bool operator==(const Coordinates a, const Coordinates b)
{
return (a.x == b.x && a.y == b.y);
}
friend bool operator<(const Coordinates a, const Coordinates b)
{
//同じときはfalseの仕様
int da = a.x*a.x + a.y*a.y;
int db = b.x*b.x + b.y*b.y;
if ( da < db ) { return true; }
else if ( da == db )
{
if ( a.x < b.x ) { return true; }
else { return false; }
}
else { return false; }
}
};
typedef Coordinates Coo;
int main()
{
int n;
cin >> n;
//各caveに対して
rep( i, n)
{
Coo sum;
Coo tmp;
Coo max = Coo(0,0);
//各移動情報に関して
while ( cin >> tmp.x >> tmp.y )
{
if ( tmp.x == 0 && tmp.y == 0) { break; }
sum = sum + tmp;
if( max < sum ) { max = sum; }
}
cout << max.x << " " << max.y << endl;
}
} | 0 |
#include<stdio.h>
int A[20],n;
int solve(int i,int m)
{
if (m == 0)
return 1;
else if (i >= n)
return 0;
return solve(i + 1, m) || solve(i+1,m-A[i]);
}
int main()
{
int p, key;
scanf("%d", &n);
for (int i = 0; i < n; i++)
{
scanf("%d", &A[0] + i);
}
scanf("%d", &p);
for (int i = 0; i < p; i++)
{
scanf("%d", &key);
if (solve(0, key))
printf("yes\n");
else
printf("no\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
int g[60][60][60];
int memo[1001][60][60];
int main() {
int n = getInt();
int m = getInt();
int r = getInt();
for (int c = 0; c < (int)(m); c++) {
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) g[c][i][j] = getInt();
for (int k = 0; k < (int)(n); k++)
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
g[c][i][j] = min(g[c][i][j], g[c][i][k] + g[c][k][j]);
}
for (int c = 0; c < (int)(1001); c++)
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) memo[c][i][j] = 10000000;
for (int c = 0; c < (int)(m); c++)
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
memo[0][i][j] = min(memo[0][i][j], g[c][i][j]);
for (int c = 0; c < (int)(1000); c++) {
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
for (int k = 0; k < (int)(n); k++)
memo[c + 1][i][j] =
min(memo[c + 1][i][j], memo[c][i][k] + memo[0][k][j]);
}
for (int rr = 0; rr < (int)(r); rr++) {
int s = getInt() - 1;
int e = getInt() - 1;
int k = getInt();
printf("%d\n", memo[k][s][e]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, x, mn = 51, c = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
if (x < mn) mn = x, c = 0;
if (x == mn) ++c;
}
puts(c > n / 2 ? "Bob" : "Alice");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int hash_mod = 1000037;
const double eps = 1e-10;
const double pi = acos(-1);
const int maxn = 1000000 + 5;
int n;
char s[maxn];
int cnt[10];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) ++cnt[s[i] - '0'];
--cnt[1];
--cnt[6];
--cnt[8];
--cnt[9];
if (cnt[0] == n - 4) {
printf("1869");
while (cnt[0]--) printf("0");
puts("");
} else {
int p = 0;
for (int i = 9; i >= 0; --i)
while (cnt[i]--) {
p = (p * 10 + i) % 7;
printf("%d", i);
}
int a[] = {1, 6, 8, 9};
do {
int t = 0;
for (int i = 0; i < 4; ++i) t = t * 10 + a[i];
if ((p * 10000 + t) % 7 == 0) {
printf("%d\n", t);
break;
}
} while (next_permutation(a, a + 4));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
int k = *min_element(a, a + n);
bool bl = true;
for (int i = 0; i < n; i++) {
if (a[i] != b[i] && a[i] % k) {
bl = false;
break;
}
}
if (bl)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
long long sum,n,q,tong[233333];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
cin>>n;
for(long long i=1,x;i<=n;i++)cin>>x,tong[x]++,sum+=x;
cin>>q;
while(q--){
long long b,c;
cin>>b>>c;
sum=sum-b*tong[b]+c*tong[b];
tong[c]+=tong[b];
tong[b]=0;
cout<<sum<<endl;
}
}
| 0 |
#include <stdio.h>
int main(){
int x=0;
char buf[5];
scanf("%s", buf);
for (int i = 0; buf[i]; ++i){
if (buf[i] == '+')
++x;
else
--x;
}
printf("%d\n", x);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int maxlen = 1;
for (int i = 1; i < n; ++i) {
if (s[0] == s[i]) {
long long int a = 0, b = i;
while (a < i && b < n && s[a] == s[b]) {
a++;
b++;
}
if (a == i) maxlen = max(maxlen, (long long int)i);
}
}
cout << n - maxlen + 1 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rnd(time(nullptr));
long long mod;
int ppow(int first, int second) {
int res = 1;
while (second) {
if (second & 1) res = res * 1LL * first % mod;
first = first * 1LL * first % mod;
second >>= 1LL;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string b, n;
cin >> b >> n >> mod;
long long d = 1, val = 0, ans = 1;
for (int i = b.size() - 1; ~i; --i) {
val += int(b[i] - '0') * d, val %= mod;
d *= 10, d %= mod;
}
for (int i = n.size() - 1; ~i; --i) {
if (n[i] == '0') continue;
n[i]--;
for (int j = i + 1; j < n.size(); ++j) n[j] = '9';
break;
}
long long cur;
d = val;
for (int i = n.size() - 1; ~i; --i) {
cur = 1;
for (int j = 0; j < n[i] - '0'; ++j) cur *= d, cur %= mod;
ans *= cur, ans %= mod;
cur = d;
for (int j = 1; j < 10; ++j) d *= cur, d %= mod;
}
ans *= (val - 1 + mod), ans %= mod;
cout << (ans ? ans : mod);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double h, m, s, t1, t2;
cin >> h >> m >> s >> t1 >> t2;
if (h == 12) h = 0;
s = s * 6;
m = m * 6 + s / 60;
h = h * 30 + m / 12;
int flag = 0;
t1 *= 30, t2 *= 30;
if (t1 > t2) swap(t1, t2);
if (s <= t2 && s >= t1) flag++;
if (h <= t2 && h >= t1) flag++;
if (m <= t2 && m >= t1) flag++;
if (flag == 3 || flag == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mx1 = 1e6 + 20, mx2 = 1e7 + 2;
const long long mod = 1e9 + 7;
const int imf1 = 1 << 31, inf1 = ~imf1;
const long long imf2 = 1LL << 63, inf2 = ~imf2;
int main() {
long long a, b, c = 0;
cin >> a >> b;
while (b) {
c = c * 10 + b % 10;
b /= 10;
}
cout << a + c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1111][1111];
int a[1111][1111];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int fa[1111111];
int getfa(int x) {
if (fa[x] == x)
return x;
else
return fa[x] = getfa(fa[x]);
}
void Union(int x, int y) {
int fx = getfa(x);
int fy = getfa(y);
fa[fx] = fy;
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
}
for (int i = 0; i <= n * m; ++i) fa[i] = i;
int odd = 0;
int bx, by;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 0) continue;
bx = i;
by = j;
int cnt = 0, sta = 0;
for (int k = 0; k < 4; ++k) {
int x = i + dx[k];
int y = j + dy[k];
if (x < 0 || y < 0 || x >= n || y >= m || a[x][y] == 0) continue;
Union(i * m + j, x * m + y);
cnt++;
sta |= (1 << k);
}
if (cnt & 1) odd++;
if (sta != 5 && sta != 10) vis[i][j] = true;
}
}
int flag = 1;
int anc = getfa(bx * m + by);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 0) continue;
int f1 = getfa(i * m + j);
if (f1 != anc) flag = 0;
}
}
if (odd != 0 && odd != 2) flag = 0;
if (flag == 0) {
printf("-1\n");
return 0;
}
int ans = 0;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
if (!vis[i][j]) continue;
for (int k = 0; k < 4; ++k) {
int x = i + dx[k];
int y = j + dy[k];
if (x < 0 || y < 0 || x >= n || y >= m || a[x][y] == 0) continue;
int now = 0;
while (x >= 0 && x < n && y >= 0 && y < m && a[x][y] == 1) {
now++;
if (vis[x][y]) break;
x += dx[k];
y += dy[k];
}
ans = gcd(ans, now);
}
}
}
if (ans == 1 || ans == 0)
printf("-1\n");
else {
for (int i = 2; i < ans; ++i)
if (ans % i == 0) printf("%d ", i);
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e9 + 1;
const long long INF = (long long)5e18;
const long long MOD = 998244353;
long long _abs(long long x) { return x < 0 ? -x : x; }
long long add(long long x, long long y) {
x += y;
return x >= MOD ? x - MOD : x;
}
long long sub(long long x, long long y) {
x -= y;
return x < 0 ? x + MOD : x;
}
void Add(long long &x, long long y) {
x += y;
if (x >= MOD) x -= MOD;
}
void Sub(long long &x, long long y) {
x -= y;
if (x < 0) x += MOD;
}
void Mul(long long &x, long long y) { x = (long long)(x) * (y) % MOD; }
long long qpow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = (long long)(ret) * (x) % MOD;
x = (long long)(x) * (x) % MOD;
y >>= 1;
}
return ret;
}
void checkmin(long long &x, long long y) {
if (x > y) x = y;
}
void checkmax(long long &x, long long y) {
if (x < y) x = y;
}
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
const long long N = 500005;
long long T, n, a[N];
set<pair<long long, long long> > st;
long long zero, two, flag = 1, tag = 0;
void insert(long long l, long long r) {
if (l > r) return;
if (flag == 1)
st.insert(make_pair(l - tag, r - tag));
else
st.insert(make_pair(tag - r, tag - l));
}
vector<pair<long long, long long> > used;
void solve() {
st.clear();
two = -1;
zero = 0;
flag = 1;
tag = 0;
for (long long i = 1; i <= n; i++) {
if (two != -1) {
st.clear(), zero += 2;
flag = 1;
tag = 0;
if (a[i - 1] - two < a[i])
st.insert(make_pair(a[i - 1] - two, a[i - 1] - two));
two = -1;
} else {
if (!st.empty()) {
flag *= -1;
tag = a[i - 1] - tag;
zero++;
if (flag == 1) {
auto it = st.upper_bound(make_pair(a[i] - 1 - tag, inf)), it2 = it;
used.clear();
while (it2 != st.end()) used.push_back(*it2), it2++;
if (it != st.begin()) {
it--;
if (it->second + tag > a[i] - 1) {
long long tmp1 = it->first;
st.erase(it);
insert(tmp1 + tag, a[i] - 1);
}
}
for (auto &u : used) st.erase(u);
} else {
auto it = st.upper_bound(make_pair(tag + 1 - a[i], inf));
if (it != st.begin()) {
used.clear();
it--;
auto it2 = it;
it2--;
if (it != st.begin())
while (true) {
used.push_back(*it2);
if (it2 == st.begin()) break;
it2--;
}
if (it != st.end() && -it->second + tag <= a[i] - 1) {
long long tmp2 = it->second;
st.erase(it);
insert(-tmp2 + tag, a[i] - 1);
}
if (it != st.end() && -it->second + tag > a[i] - 1) st.erase(it);
for (auto &u : used) st.erase(u);
}
}
} else {
if (i != 1) insert(1, min(a[i - 1], a[i]) - 1);
}
}
if (a[i] % 2 == 0 && !st.empty()) {
if (flag == 1) {
auto it = st.upper_bound(make_pair(a[i] / 2 - tag, inf));
if (it != st.begin()) {
it--;
if (it->second + tag >= a[i] / 2) {
two = a[i] / 2;
long long tmp1 = it->first, tmp2 = it->second;
st.erase(it);
insert(tmp1 + tag, a[i] / 2 - 1);
insert(a[i] / 2 + 1, tmp2 + tag);
}
}
} else {
auto it = st.upper_bound(make_pair(tag - a[i] / 2, inf));
if (it != st.begin()) {
it--;
if (-it->second + tag <= a[i] / 2) {
two = a[i] / 2;
long long tmp1 = it->first, tmp2 = it->second;
st.erase(it);
insert(-tmp2 + tag, a[i] / 2 - 1);
insert(a[i] / 2 + 1, -tmp1 + tag);
}
}
}
}
if (two == -1 && a[i] % 2 == 0) insert(a[i] / 2, a[i] / 2);
}
long long ans = zero;
if (two != -1)
ans += 2;
else if (!st.empty())
ans++;
cout << n * 2 - ans << endl;
}
signed main() {
T = read();
while (T--) {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC target("sse4.2")
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const int M = (int)1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= M) return a - M;
if (a < 0) return a + M;
return a;
}
int mul(int a, int b) { return a * (long long)b % M; }
int pw(int a, int b) {
int r = 1;
while (b) {
if (b & 1) r = mul(r, a);
a = mul(a, a);
b /= 2;
}
return r;
}
int dv(int a, int b) { return mul(a, pw(b, M - 2)); }
const int N = (int)1e5 + 7;
const int T = 3;
int q, n, fact[N], ifact[N], memo[T][N], p25[N], p26[N], now[N];
string s;
int comb(int n, int k) { return mul(fact[n], mul(ifact[k], ifact[n - k])); }
void job() {
for (int len = 1; len < N; len++) {
if (len - n < 0)
now[len] = 0;
else
now[len] =
add(mul(26, now[len - 1]), mul(comb(len - 1, n - 1), p25[len - n]));
}
}
signed realMain() {
p25[0] = 1;
p26[0] = 1;
for (int i = 1; i < N; i++) p25[i] = mul(p25[i - 1], 25);
for (int i = 1; i < N; i++) p26[i] = mul(p26[i - 1], 26);
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = mul(fact[i - 1], i);
ifact[N - 1] = dv(1, fact[N - 1]);
for (int i = N - 2; i >= 0; i--) ifact[i] = mul(ifact[i + 1], i + 1);
for (n = 1; n < T; n++) {
job();
for (int j = 0; j < N; j++) {
memo[n][j] = now[j];
}
}
cin >> q >> s;
n = (int)s.size();
job();
while (q--) {
int t;
cin >> t;
if (t == 1) {
cin >> s;
n = (int)s.size();
job();
} else {
int len;
cin >> len;
cout << now[len] << "\n";
if (n < T) {
assert(now[len] == memo[n][len]);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int t;
cin >> t;
while(t--) {
ll n, res = 0;
cin >> n;
vector <ll> v(n + 1);
for(int i = 1; i <= n; i++)
cin >> v[i];
for(int i = 1; i < n; i++) {
ll mod = v[i] - i, st;
if(mod <= 0)
st = v[i] - (abs(mod) % v[i]);
else
st = mod;
if(st <= i) {
ll a = st % v[i], b = i % v[i];
if(a == b)
st = i + v[i];
else if(a < b)
st = i + (v[i] - b + a);
else
st = i + (a - b);
}
for(int j = st; j <= n; j += v[i]) {
if(v[i] * v[j] == i + j)
res++;
}
}
cout << res << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, j = 1;
string x;
cin >> n >> x;
for (int i = 1; i <= n; i += j) {
cout << x[i - 1];
j++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
long long a[1500];
long long b[1500];
long long ai[1500];
long long bi[1500];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
long long maxx = 0;
for (int x = 0; x < n; ++x) {
for (int y = 0; y < n; ++y) {
long long c1 = 0, c2 = 0;
for (int k = x; k <= y; ++k) {
c1 |= a[k];
c2 |= b[k];
}
maxx = max(c1 + c2, maxx);
}
}
cout << maxx << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k, i;
cin >> n >> k;
vector<int> v(n);
for (i = 0; i < n; i++) {
v[i] = i + 1;
}
if (k == 0) {
for (i = 0; i < n; i++) {
cout << v[i] << " ";
}
return;
}
if (k == n - 1) {
reverse(v.begin(), v.end());
for (i = 0; i < n; i++) {
cout << v[i] << " ";
}
return;
}
reverse(v.begin(), v.begin() + k + 1);
for (i = 0; i < n; i++) {
cout << v[i] << " ";
}
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
using namespace std;
const int Max = 10055;
int gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
bool com(string x, string y) { return x + y < y + x; }
int main() {
int n;
cin >> n;
set<string> a;
string m[200000];
for (int i = 0; i < n; i++) {
cin >> m[i];
a.insert(m[i]);
}
for (int i = n - 1; i >= 0; i--) {
if (a.find(m[i]) != a.end()) {
cout << m[i] << endl;
a.erase(m[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, u, v, a[120000];
int main() {
scanf("%d%d%d", &n, &u, &v);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 2, a + n + 1);
long long sum = a[1];
for (int i = 2; i <= n; i++) {
sum += a[i];
if (sum * v > (long long)a[1] * u) {
printf("%d\n", n - i + 1);
return 0;
}
}
puts("0");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 1000111;
const int maxm = 1000111;
struct max_flow {
struct edge {
int to, cap;
};
int head[maxn], nxt[maxm << 1], iter[maxn], tot;
edge e[maxm << 1];
void clear() {
memset(head, 0, sizeof(head));
tot = 1;
}
max_flow() { clear(); }
void addedge(int u, int v, int cap) {
nxt[++tot] = head[u];
head[u] = tot;
e[tot] = edge{v, cap};
nxt[++tot] = head[v];
head[v] = tot;
e[tot] = edge{u, 0};
}
int lvl[maxn], q[maxn];
bool bfs(int s, int t) {
memset(lvl, -1, sizeof(lvl));
lvl[s] = 0;
int rr = 0;
q[rr++] = s;
for (int fr = 0; fr < rr; fr++) {
int x = q[fr];
if (x == t) return true;
for (int i = head[x]; i; i = nxt[i])
if (e[i].cap && lvl[e[i].to] == -1) {
lvl[e[i].to] = lvl[x] + 1;
q[rr++] = e[i].to;
}
}
return false;
}
int dfs(int x, int t, int f) {
if (x == t || f == 0) return f;
int ret = 0;
for (int &i = iter[x]; i; i = nxt[i])
if (e[i].cap && lvl[e[i].to] == lvl[x] + 1) {
int d = dfs(e[i].to, t, min(f, e[i].cap));
e[i].cap -= d;
e[i ^ 1].cap += d;
f -= d;
ret += d;
if (!f) break;
}
return ret;
}
int maxflow(int s, int t) {
int flow = 0;
while (bfs(s, t)) {
memcpy(iter, head, sizeof(head));
flow += dfs(s, t, inf);
}
return flow;
}
} thor;
vector<int> g[20111], ie[20111];
int f[15][20111], id[15][20111], fid[20111], dep[20111], tot, n, m;
void dfs(int x) {
for (int i = 1; i < 15; i++) f[i][x] = f[i - 1][f[i - 1][x]];
for (int i = 0; i < 15; i++)
if (f[i][x]) id[i][x] = ++tot;
for (int i = 0; i < (int)g[x].size(); i++)
if (g[x][i] != f[0][x]) {
f[0][g[x][i]] = x;
fid[g[x][i]] = ie[x][i];
dep[g[x][i]] = dep[x] + 1;
dfs(g[x][i]);
}
}
int main() {
(get_int(n) && get_int(m));
for (int i = 1, u, v; i < n; i++) {
(get_int(u) && get_int(v));
g[u].push_back(v);
g[v].push_back(u);
ie[u].push_back(i);
ie[v].push_back(i);
}
dfs(1);
int S = tot + m + 1, T = S + 1;
for (int i = 2; i <= n; i++) {
thor.addedge(id[0][i], T, 1);
for (int j = 1; j < 15; j++)
if (f[j][i]) {
thor.addedge(id[j][i], id[j - 1][i], 100000);
thor.addedge(id[j][i], id[j - 1][f[j - 1][i]], 100000);
}
}
for (int i = 1, u, v; i <= m; i++) {
(get_int(u) && get_int(v));
thor.addedge(S, tot + i, 1);
if (dep[u] < dep[v]) swap(u, v);
for (int j = 14; j >= 0; j--)
if (dep[u] - dep[v] >> j) {
thor.addedge(tot + i, id[j][u], 1);
u = f[j][u];
}
if (u == v) continue;
for (int j = 14; j >= 0; j--)
if (f[j][u] != f[j][v]) {
thor.addedge(tot + i, id[j][u], 1);
thor.addedge(tot + i, id[j][v], 1);
u = f[j][u];
v = f[j][v];
}
thor.addedge(tot + i, id[0][u], 1);
thor.addedge(tot + i, id[0][v], 1);
}
printf("%d\n", thor.maxflow(S, T));
vector<int> v1, v2;
for (int i = 1; i <= m; i++)
if (thor.lvl[tot + i] == -1) v1.push_back(i);
for (int i = 2; i <= n; i++)
if (thor.lvl[id[0][i]] != -1) v2.push_back(fid[i]);
printf("%d ", (int)v1.size());
for (auto v : v1) printf("%d ", v);
puts("");
printf("%d ", (int)v2.size());
for (auto v : v2) printf("%d ", v);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[27];
int ans[27];
int main() {
memset(cnt, 0, sizeof(cnt));
memset(ans, 0, sizeof(ans));
string s, p;
cin >> s >> p;
if (p.size() > s.size()) {
cout << 0 << endl;
return 0;
}
int sum = 0;
for (int i = 0; i < p.size(); i++) {
if (s[i] != '?') cnt[s[i] - 'a']++;
ans[p[i] - 'a']++;
}
bool flag = 0;
for (int i = 0; i < 26; i++) {
if (cnt[i] > ans[i]) flag = 1;
}
if (!flag) sum++;
for (int i = 0; i < s.size() - p.size(); i++) {
flag = 0;
if (s[i] != '?') cnt[s[i] - 'a']--;
if (s[i + p.size()] != '?') cnt[s[i + p.size()] - 'a']++;
for (int j = 0; j < 26; j++) {
if (cnt[j] > ans[j]) flag = 1;
}
if (!flag) sum++;
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9, maxn = (int)1e5 + 5;
const double eps = (double)1e-8;
const int mod = (int)1000000007;
int a[maxn], b[maxn];
int fa(int l, int r) {
int ans = a[l];
for (int i = (l + 1); i < (r); i++) ans = ans | a[i];
return ans;
}
int fb(int l, int r) {
int ans = b[l];
for (int i = (l + 1); i < (r); i++) ans = ans | b[i];
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = (0); i < (n); i++) cin >> a[i];
for (int i = (0); i < (n); i++) cin >> b[i];
int ans = -inf;
cout << fa(0, n) + fb(0, n);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p1, p2, p3, p4, a, b, i, c = 0;
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
for (i = a; i <= b; i++) {
if (i == ((((i % p1) % p2) % p3) % p4)) c++;
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void _() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
void __() {}
inline void ___(char *i, char *j) {
freopen(i, "r", stdin);
freopen(j, "w", stdout);
}
template <class T1>
bool tk(T1 &e1) {
if (cin >> e1) return true;
return false;
}
template <class T1, class T2>
bool tk(T1 &e1, T2 &e2) {
if (cin >> e1 >> e2) return true;
return false;
}
template <class T1, class T2, class T3>
bool tk(T1 &e1, T2 &e2, T3 &e3) {
if (cin >> e1 >> e2 >> e3) return true;
return false;
}
template <class T1, class T2, class T3, class T4>
bool tk(T1 &e1, T2 &e2, T3 &e3, T4 &e4) {
if (cin >> e1 >> e2 >> e3 >> e4) return true;
return false;
}
template <class T1, class T2, class T3, class T4, class T5>
bool tk(T1 &e1, T2 &e2, T3 &e3, T4 &e4, T5 &e5) {
if (cin >> e1 >> e2 >> e3 >> e4 >> e5) return true;
return false;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
bool tk(T1 &e1, T2 &e2, T3 &e3, T4 &e4, T5 &e5, T6 &e6) {
if (cin >> e1 >> e2 >> e3 >> e4 >> e5 >> e6) return true;
return false;
}
template <class T1>
void put(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void put(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void put(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void put(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void put(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void put(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
template <class T1>
void putVec(vector<T1> e1) {
for (int i = 0; i < (e1).size(); i++)
(!i ? cout << e1[i] : cout << " " << e1[i]);
cout << endl;
}
template <class T1>
void putArr(T1 arr[], int l) {
for (int i = 0; i < l; i++) (!i ? cout << arr[i] : cout << " " << arr[i]);
cout << endl;
}
template <class T1>
void bug(T1 e) {}
template <class T1, class T2>
void bug(T1 e1, T2 e2) {}
template <class T1, class T2, class T3>
void bug(T1 e1, T2 e2, T3 e3) {}
template <class T1, class T2, class T3, class T4>
void bug(T1 e1, T2 e2, T3 e3, T4 e4) {}
template <class T1, class T2, class T3, class T4, class T5>
void bug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void bug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {}
template <class T1>
void bugVec(vector<T1> e1) {}
template <class T1>
void bugArr(T1 arr[], int l) {}
template <typename T>
inline bool isOn(T &mask, int pos) {
return ((mask) & (1 << pos));
}
template <typename T>
inline void setOff(T &mask, int pos) {
mask = ((mask) & (~(1 << pos)));
}
template <typename T>
inline void setOn(T &mask, int pos) {
mask = ((mask)(1 << pos));
}
namespace gv {};
long long absolute(long long a) {
if (a < 0) return -a;
return a;
}
int main() {
_();
vector<pair<int, pair<int, int> > > ans(2);
ans[0] = {
2 * (long long int)1000000000,
{2 * (long long int)1000000000 + 1, 2 * (long long int)1000000000 + 1}};
int n, m, c;
vector<int> a, b;
tk(n);
for (int i = 0; i < n; i++) tk(c), a.push_back(c);
sort(a.begin(), a.end());
tk(m);
for (int i = 0; i < m; i++) tk(c), b.push_back(c);
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
for (int j = -1; j < 1; j++) {
int lo = max(a[i] + j, 0);
int binaryLo = 0, binaryHi = a.size();
while (binaryLo < binaryHi) {
int mid = binaryLo + (binaryHi - binaryLo) / 2;
if (a[mid] <= lo)
binaryLo = mid + 1;
else
binaryHi = mid;
}
long long A = binaryLo * 2 + ((int)a.size() - binaryLo) * 3;
binaryLo = 0, binaryHi = b.size();
while (binaryLo < binaryHi) {
int mid = binaryLo + (binaryHi - binaryLo) / 2;
if (b[mid] <= lo)
binaryLo = mid + 1;
else
binaryHi = mid;
}
long long B = binaryLo * 2 + ((int)b.size() - binaryLo) * 3;
bug(A, B, lo, binaryLo);
ans[1] = {-1 * A + B, {-1 * A, B}};
sort(ans.begin(), ans.end());
}
}
for (int i = 0; i < m; i++) {
for (int j = -1; j < 1; j++) {
int lo = max(b[i] + j, 0);
int binaryLo = 0, binaryHi = a.size();
while (binaryLo < binaryHi) {
int mid = binaryLo + (binaryHi - binaryLo) / 2;
if (a[mid] <= lo)
binaryLo = mid + 1;
else
binaryHi = mid;
}
long long A = binaryLo * 2 + ((int)a.size() - binaryLo) * 3;
binaryLo = 0, binaryHi = b.size();
while (binaryLo < binaryHi) {
int mid = binaryLo + (binaryHi - binaryLo) / 2;
if (b[mid] <= lo)
binaryLo = mid + 1;
else
binaryHi = mid;
}
long long B = binaryLo * 2 + ((int)b.size() - binaryLo) * 3;
bug(A, B, lo, binaryLo);
ans[1] = {-1 * A + B, {-1 * A, B}};
sort(ans.begin(), ans.end());
}
}
cout << (-1 * (ans[0].second.first)) << ":" << ans[0].second.second << endl;
__();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef pair<pii, int> piipi;
typedef pair<int, pii> pipii;
typedef pair<pii, pii> piipii;
typedef pair<ll, pii> plpii;
typedef pair<db, db> pdd;
typedef pair<ld, ld> pldd;
#define mp make_pair
#define fi first
#define se second
#define sz(x) (int)x.size()
#define all(x) (x).begin(), (x).end()
#define eb emplace_back
#define pf push_front
#define pb push_back
// const int mod = 998244353;
const int P1 = 999983, P2 = 999979;
const ld PI = acos((ld)-1);
const int mod = 998244353;
const int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const ll INF = 1e18;
const int N = 1e6+5;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
char c[300005];
vector<char> s[300005];
vector<int> sumR[300005], sumL[300005], sumU[300005], sumD[300005];
ll dp1[300005], dp2[300005];
ll pw[300005];
int main(){
int n, m;
scanf("%d%d", &n, &m);
pw[0] = 1;
for(int i=1;i<=n*m;i++) pw[i] = pw[i-1]*2%mod;
for(int i=0;i<=n+2;i++){
s[i].resize(m+2);
sumR[i].resize(m+2);
sumL[i].resize(m+2);
sumU[i].resize(m+2);
sumD[i].resize(m+2);
}
int sum = 0;
for(int i=1;i<=n;i++){
scanf("%s", c+1);
for(int j=1;j<=m;j++){
s[i][j] = c[j];
if(s[i][j] == 'o'){
sum++;
sumL[i][j] = sumL[i][j-1] + 1;
sumU[i][j] = sumU[i-1][j] + 1;
}
}
}
for(int i=1;i<=n*m;i++){
if(sum-i-2 >= 0){
dp1[i] += (i/2)*1ll*pw[sum-i-2]%mod;
dp1[i] += dp1[i-1];
dp1[i] %= mod;
}
if(sum-i-1 >= 0){
dp2[i] += (i/2)*1ll*pw[sum-i-1]%mod;
dp2[i] += dp2[i-1];
dp2[i] %= mod;
}
}
for(int i=n;i>=1;i--){
for(int j=m;j>=1;j--){
if(s[i][j] == 'o'){
sumR[i][j] = sumR[i][j+1] + 1;
sumD[i][j] = sumD[i+1][j] + 1;
}
}
}
ll ans = 0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(s[i][j] == 'o'){
int cnt = sumL[i][j];
if(j == m || s[i][j+1] != 'o'){
ans += dp2[cnt-1];
ans %= mod;
if(sum-cnt >= 0){
ans += (cnt/2)*1ll*pw[sum-cnt]%mod;
ans %= mod;
}
}
else{
ans += dp1[cnt-1];
ans %= mod;
if(sum-cnt-1 >= 0){
ans += (cnt/2)*1ll*pw[sum-cnt-1]%mod;
ans %= mod;
}
}
cnt = sumU[i][j];
if(i == n || s[i+1][j] != 'o'){
ans += dp2[cnt-1];
ans %= mod;
if(sum-cnt >= 0){
ans += (cnt/2)*1ll*pw[sum-cnt]%mod;
ans %= mod;
}
}
else{
ans += dp1[cnt-1];
ans %= mod;
if(sum-cnt-1 >= 0){
ans += (cnt/2)*1ll*pw[sum-cnt-1]%mod;
ans %= mod;
}
}
ans %= mod;
}
}
}
printf("%lld\n", ans);
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
vector<int> s[8];
int n;
int tar[N], chk[N];
inline int read() {
int x = 0;
for (int i = 0; i < 3; i++) {
int s = 0;
scanf("%d", &s);
x = x * 2 + s;
}
return x;
}
vector<int> t8;
vector<pair<int, int> > mp;
bool B[N];
int cur[N];
int g[8];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
tar[i] = read();
if (i > 1) {
s[tar[i]].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
chk[i] = read();
}
if (s[7].size()) {
B[1] = 0;
cur[1] = 7;
for (size_t i = 0; i < s[7].size(); i++) {
mp.push_back(pair<int, int>(1, s[7][i]));
B[s[7][i]] = 1;
g[chk[s[7][i]]] = s[7][i];
cur[s[7][i]] = 7;
}
} else {
B[1] = 1;
cur[1] = 7;
g[chk[1]] = 1;
}
for (int i = 7; i; i--)
if (__builtin_popcount(i) == 2) {
if (g[i]) {
for (size_t j = 0; j < s[i].size(); j++) {
cur[s[i][j]] = i;
mp.push_back(pair<int, int>(g[i], s[i][j]));
B[s[i][j]] = 1;
if (!g[chk[s[i][j]] & i]) {
g[chk[s[i][j]] & i] = s[i][j];
}
}
}
}
for (int i = 1; i <= n; i++) {
if (cur[i] != tar[i]) {
if (g[tar[i]]) {
mp.push_back(pair<int, int>(g[tar[i]], i));
cur[i] = tar[i];
} else {
for (int j = 0; j < 3; j++) {
if ((1 << j) & tar[i]) {
if (g[1 << j]) {
mp.push_back(pair<int, int>(g[1 << j], i));
cur[i] |= 1 << j;
}
}
}
if (cur[i] != tar[i]) {
puts("Impossible");
return 0;
}
B[i] = 0;
g[tar[i]] = i;
}
}
}
for (int i = 1; i <= n; i++) {
if (cur[i] != tar[i]) {
puts("Impossible");
return 0;
}
}
puts("Possible");
for (int i = 1; i <= n; i++) printf("%d ", B[i]);
puts("");
cout << mp.size() << endl;
for (size_t i = 0; i < mp.size(); i++) {
printf("%d %d\n", mp[i].first, mp[i].second);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, l, r, ql, qr;
int w[100010], an;
int main() {
scanf("%d%d%d%d%d", &n, &l, &r, &ql, &qr);
for (i = 1; i <= n; i++) scanf("%d", &w[i]), w[i] += w[i - 1];
an = 2147483647;
for (i = 0; i <= n / 2; i++) {
int A = w[i] * l + (w[n] - w[n - i]) * r;
an = min(an, A + (w[n - i] - w[i]) * l + max(0, n - i - i - 1) * ql);
an = min(an, A + (w[n - i] - w[i]) * r + max(0, n - i - i - 1) * qr);
}
printf("%d\n", an);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long i,j,k,n,c=0;
cin>>n;
long long a[n];
for(i=0;i<n;i++){
cin>>a[i];
}
for(i=1;i<n;i++){
if(a[i]<a[i-1]){
c += a[i-1]-a[i];
a[i] = a[i-1];
}
}
cout<<c;
} | 0 |
#include <bits/stdc++.h>
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
int n, a, b, c, x, y[110];
int main() {
while (cin >> n >> a >> b >> c >> x, n) {
rep (i, n) cin >> y[i];
int cnt = 0, index = 0;
while (cnt < 10001) {
if (x == y[index]) index++;
if (index == n) {
cout << cnt << endl;
goto end;
}
x = (a * x + b) % c;
cnt ++;
}
cout << -1 << endl;
end:;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#include<vector>
#include<deque>
#include<list>
#define rep(i,n) for(ll i=0;i<n;++i)
#define rrep(i,n) for(int i=n-1;i>=0;--i)
#define yesno(flg) if(flg){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;}
#define MAX_N 1002
#define i197 1000000007
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P1;
typedef pair<int,int> Pi;
typedef pair<double,Pi> Pdi;
typedef pair<ll,int>Pli;
typedef pair<P1,ll> P2;
const ll INF=100000000000000001;
struct edge{int to,cost;};
struct pos{
int x,y,cost;
double ma=0;
};
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
struct Road{double cost;int a,b;};
int main() {
int f;
cin>>f;
cout<<(f-30)/2<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N,K;
int dx[2] = {1,-1};
const int INF = 2000000000;
int main(){
cin >> N >> K;
int x[N];
int d[N];
for(int i=0;i<N;i++){
cin >> x[i];
d[i] = abs(x[i]);
}
int ans=INF;
for(int i=0;i<N-K+1;i++){
int mid = abs(x[i] - x[i+K-1]);
ans = min(min(d[i],d[i+K-1]) + mid, ans);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int i, j, k, n, a, b, u;
scanf("%d", &n);
scanf("%d", &u);
u = 7 - u;
k = 1;
scanf("%d%d", &a, &b);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
if (u == a || u == b) k = 0;
a = 7 - a;
b = 7 - b;
if (u == a || u == b) k = 0;
u = 7 - u;
}
if (k)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC target("sse3", "sse2", "sse")
#pragma GCC target("avx", "sse4", "sse4.1", "sse4.2", "ssse3")
#pragma GCC target("f16c")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
const int MAXN = (int)5e5 + 5;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const int MAXS = 32 * 1024 * 1024;
char buf[MAXS], *ch;
void read(int &x) {
while (*ch <= 32) ++ch;
for (x = 0; *ch >= '0'; ++ch) x = x * 10 + *ch - '0';
}
void std_init() {
ch = buf - 1;
fread(buf, 1, MAXS, stdin);
}
int a[MAXN], cnt[1 << 12][105], _cnt[1 << 12], add[2][12], k[MAXN];
vector<int> num[12];
int lz[1 << 12];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n, m, q, w[33], x;
string s;
cin >> n >> m >> q;
for (unsigned int i = 0; i < n; i++) {
cin >> w[i];
}
for (unsigned int i = 0; i < m; i++) {
cin >> s;
for (int j = 0; j < s.size(); ++j) {
a[i] <<= 1;
a[i] |= s[j] - '0';
}
++_cnt[a[i]];
}
for (unsigned int i = 0; i < 1 << n; i++) {
for (unsigned int j = 0; j < n; j++) {
if (!(i >> j & 1)) {
lz[i] += w[n - j - 1];
}
}
}
for (unsigned int i = 0; i < 1 << n; i++) {
for (unsigned int j = 0; j < 1 << n; j++) {
if (lz[i ^ j] <= 100) cnt[i][lz[i ^ j]] += _cnt[j];
}
}
for (unsigned int i = 0; i < 1 << n; i++) {
for (unsigned int j = 1; j < 101; j++) {
cnt[i][j] += cnt[i][j - 1];
}
}
for (unsigned int i = 0; i < q; i++) {
cin >> s >> x;
int aa = 0;
for (int j = 0; j < s.size(); ++j) {
aa <<= 1;
aa |= s[j] - '0';
}
cout << cnt[aa][x] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define lscan(x) scanf("%I64d", &x)
#define lprint(x) printf("%I64d", x)
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, n) for (ll i = (ll)n - 1; i >= 0; i--)
#define REP(i, l, r) for (ll i = l; i < (r); i++)
#define REP2(i, l, r) for (ll i = (ll)r - 1; i >= (l); i--)
#define siz(x) (ll)x.size()
template <class T>
using rque = priority_queue<T, vector<T>, greater<T>>;
const ll mod = (int)1e9 + 7;
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmax(T &a, const T &b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b)
{
if(a == 0)
return b;
if(b == 0)
return a;
ll c = a % b;
while (c != 0)
{
a = b;
b = c;
c = a % b;
}
return b;
}
long long extGCD(long long a, long long b, long long &x, long long &y)
{
if (b == 0)
{
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
struct UnionFind
{
vector<ll> data;
int num;
UnionFind(int sz)
{
data.assign(sz, -1);
num = sz;
}
bool unite(int x, int y)
{
x = find(x), y = find(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
num--;
return (true);
}
int find(int k)
{
if (data[k] < 0)
return (k);
return (data[k] = find(data[k]));
}
ll size(int k)
{
return (-data[find(k)]);
}
};
ll M = 1000000007;
template <int mod>
struct ModInt
{
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p)
{
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p)
{
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p)
{
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p)
{
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const
{
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0)
{
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const
{
ModInt ret(1), mul(x);
while (n > 0)
{
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p)
{
return os << p.x;
}
friend istream &operator>>(istream &is, ModInt &a)
{
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using mint = ModInt<mod>;
mint mpow(mint x, ll n)
{
mint ans = 1;
while (n != 0)
{
if (n & 1)
ans *= x;
x *= x;
n = n >> 1;
}
return ans;
}
ll mpow2(ll x, ll n, ll mod)
{
ll ans = 1;
while (n != 0)
{
if (n & 1)
ans = ans * x % mod;
x = x * x % mod;
n = n >> 1;
}
return ans;
}
vector<mint> fac;
vector<mint> ifac;
void setcomb(int sz = 2000010)
{
fac.assign(sz + 1, 0);
ifac.assign(sz + 1, 0);
fac[0] = 1;
for (ll i = 0; i < sz; i++)
{
fac[i + 1] = fac[i] * (i + 1); // n!(mod M)
}
ifac[sz] = fac[sz].inverse();
for (ll i = sz; i > 0; i--)
{
ifac[i - 1] = ifac[i] * i;
}
}
mint comb(ll a, ll b)
{
if(fac.size() == 0)
setcomb();
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0 || b < 0)
return 0;
return ifac[a - b] * ifac[b] * fac[a];
}
mint perm(ll a, ll b)
{
if(fac.size() == 0)
setcomb();
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
return fac[a] * ifac[a - b];
}
long long modinv(long long a)
{
long long b = M, u = 1, v = 0;
while (b)
{
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= M;
if (u < 0)
u += M;
return u;
}
ll modinv2(ll a, ll mod)
{
ll b = mod, u = 1, v = 0;
while (b)
{
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
int main(){
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
ll n, k;
cin >> n >> k;
if(n%2 && !(k%2)){
cout << -1 << endl;
return 0;
}
ll t[n], sum = n;
rep(i, n) t[i] = 1;
ll idx = 0, ma = 1;
while(sum % k != 0 || ma > sum / k){
t[idx] += 2;
chmax(ma, t[idx]);
sum += 2;
idx++;
idx %= n;
}
priority_queue<pair<ll, ll>> que;
rep(i, n) que.push({t[i], i});
ll ans = 0;
queue<pair<ll, ll>> que2;
rep(i,sum/k){
cout << "?";
rep(j,k){
auto q = que.top();
que.pop();
ll now = q.second, nt = q.first;
que2.push({nt - 1, now});
cout << " " << now + 1;
}
cout << endl;
ll res;
cin >> res;
ans ^= res;
rep(j,k){
que.push(que2.front());
que2.pop();
}
}
cout << "! " << ans << endl;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt(time(0));
const int MAXN = 5e5 + 10;
struct Item {
bool head;
int len = 0;
int8_t type[2] = {};
int in = 0;
int cnt[2] = {};
Item() = default;
Item(int h) {
head = h;
len = 1;
type[1 - h] = 1;
cnt[1 - h] = 1;
}
};
string s;
Item tree[MAXN << 2][2];
int idx[MAXN << 2], info[MAXN << 2];
Item merge(const Item& x, const Item& y) {
if (x.len == 0) return y;
if (y.len == 0) return x;
Item ret;
ret.head = x.head;
ret.len = x.len + y.len;
if ((x.head + x.len - 1) % 2 == y.head) ret.len--;
ret.in = max(x.in, y.in);
if (x.type[0] == 0 && x.type[1] == 1) {
if (y.type[0] == 0 && y.type[1] == 1) {
ret.type[1] = 1;
ret.cnt[1] = x.cnt[1] + y.cnt[1];
} else if (y.type[1] == 0) {
ret.type[0] = 2;
ret.cnt[0] = x.cnt[1] + y.cnt[0];
} else {
ret.type[0] = 2;
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[1] + y.cnt[0];
ret.cnt[1] = y.cnt[1];
}
return ret;
}
if (x.type[0] == 1 && x.type[1] == 0) {
if (y.type[0] == 0 || y.type[0] == 1) {
ret.type[0] = 1;
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[0] + y.cnt[0];
ret.cnt[1] = y.cnt[1];
} else if (y.type[1] == 0) {
ret.type[0] = 1;
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[0];
} else {
ret.type[0] = 1;
ret.type[1] = y.type[1];
ret.in = max(ret.in, y.cnt[0]);
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[1];
}
return ret;
}
if (x.type[0] == 2 && x.type[1] == 0 && y.type[0] == 2 && y.type[1] == 0) {
ret.type[0] = 2;
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[0];
return ret;
}
if (x.type[0] == 2 && x.type[1] == 0 && y.type[0] == 1) {
ret.type[0] = 2;
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[0] + y.cnt[0];
ret.cnt[1] = y.cnt[1];
return ret;
}
if (y.type[0] == 0 && x.type[1] == 1) {
ret.type[0] = x.type[0];
ret.type[1] = 1;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = x.cnt[1] + y.cnt[1];
return ret;
}
if (y.type[0] == 1 && y.type[1] == 0) {
ret.type[0] = x.type[0];
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = x.cnt[1] + y.cnt[0];
return ret;
}
if (y.type[0] == 2 && y.type[1] == 0) {
if (x.type[1] == 1) {
ret.type[0] = x.type[0];
ret.type[1] = 2;
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = x.cnt[1] + y.cnt[0];
} else {
ret.type[0] = x.type[0];
ret.type[1] = 2;
ret.in = max(ret.in, x.cnt[1]);
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[0];
}
return ret;
}
ret.type[0] = x.type[0];
ret.type[1] = y.type[1];
ret.cnt[0] = x.cnt[0];
ret.cnt[1] = y.cnt[1];
if (x.type[1] == 2 && y.type[0] == 2) {
ret.in = max(ret.in, x.cnt[1]);
ret.in = max(ret.in, y.cnt[0]);
} else
ret.in = max(ret.in, x.cnt[1] + y.cnt[0]);
return ret;
}
void build(int node, int left, int right) {
if (left == right) {
if (s[left - 1] == '>') {
tree[node][0] = Item(0);
tree[node][1] = Item(1);
} else {
tree[node][0] = Item(1);
tree[node][1] = Item(0);
}
return;
}
int mid = ((left + right) >> 1);
build((node << 1), left, mid);
build(((node << 1) | 1), mid + 1, right);
tree[node][0] = merge(tree[(node << 1)][0], tree[((node << 1) | 1)][0]);
tree[node][1] = merge(tree[(node << 1)][1], tree[((node << 1) | 1)][1]);
}
void push_down(int node, int left, int right) {
if (left == right || info[node] == 0) return;
idx[(node << 1)] ^= 1;
idx[((node << 1) | 1)] ^= 1;
info[(node << 1)] ^= 1;
info[((node << 1) | 1)] ^= 1;
info[node] = 0;
}
void update(int node, int left, int right, int i, int j) {
if (right < i || j < left) return;
if (i <= left && right <= j) {
info[node] ^= 1;
idx[node] ^= 1;
return;
}
push_down(node, left, right);
int mid = ((left + right) >> 1);
update((node << 1), left, mid, i, j);
update(((node << 1) | 1), mid + 1, right, i, j);
tree[node][idx[node]] =
merge(tree[(node << 1)][idx[(node << 1)]],
tree[((node << 1) | 1)][idx[((node << 1) | 1)]]);
tree[node][idx[node] ^ 1] =
merge(tree[(node << 1)][idx[(node << 1)] ^ 1],
tree[((node << 1) | 1)][idx[((node << 1) | 1)] ^ 1]);
}
Item query(int node, int left, int right, int i, int j) {
if (right < i || j < left) return Item();
if (i <= left && right <= j) {
return tree[node][idx[node]];
}
push_down(node, left, right);
int mid = ((left + right) >> 1);
Item a = query((node << 1), left, mid, i, j);
Item b = query(((node << 1) | 1), mid + 1, right, i, j);
return merge(a, b);
}
void dfs() {
if (s.size() > 5) return;
if (!s.empty()) {
build(1, 1, s.size());
auto item = query(1, 1, s.size(), 1, s.size());
cout << s << endl;
cout << "head: " << item.head << ' ' << "len: " << item.len << ' '
<< "in: " << item.in << endl;
cout << "type: " << (int)item.type[0] << ' ' << (int)item.type[1] << endl;
cout << "cnt: " << item.cnt[0] << ' ' << item.cnt[1] << endl;
}
s.push_back('>');
dfs();
s.pop_back();
s.push_back('<');
dfs();
s.pop_back();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int n, q;
cin >> n >> q;
cin >> s;
build(1, 1, n);
while (q--) {
int a, b;
cin >> a >> b;
update(1, 1, n, a, b);
Item tmp = query(1, 1, n, a, b);
int ret = max(tmp.cnt[0], tmp.cnt[1]);
ret = max(ret, tmp.in);
cout << ret << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define modulo 998244353
#define mod(mod_x) ((((long long)mod_x+modulo))%modulo)
#define Inf 1000000000
int main(){
int H,W;
cin>>H>>W;
vector<string> grid(H);
for(int i=0;i<H;i++)cin>>grid[i];
vector<string> R(H,string(W,'.')),B(H,string(W,'.'));
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
if(j==0||j==W-1){
if(j==0)R[i][j]='#';
if(j==W-1)B[i][j]='#';
}
else{
if(i%2==0||grid[i][j]=='#')R[i][j]='#';
if(i%2==1||grid[i][j]=='#') B[i][j]='#';
}
}
}
for(int i=0;i<H;i++){
cout<<R[i]<<endl;
}
cout<<endl;
for(int i=0;i<H;i++){
cout<<B[i]<<endl;
}
return 0;
} | 0 |
#include <map>
#include <iostream>
#include <string>
using namespace std;
int main()
{
map<char, char> mp;
char a,b,c;
string x;
int n;
cin >> n;
do{
mp.clear();
x.clear();
do{
cin >> a >> b;
mp[a] = b;
} while (--n);
cin >> n;
do{
cin >> c;
if (mp[c] != NULL) {
x += mp[c];
}
else {
x += c;
}
} while (--n);
cout << x << endl;
} while (cin >> n, n != 0);
return 0;
} | 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=2005;
int n,m,Q,i,j,a[N][N],f1[N][N],f2[N][N];
char s[N][N];
int read(){
char c=getchar();int k=0;for (;c<48||c>57;c=getchar());
for (;c>47&&c<58;c=getchar()) k=(k<<3)+(k<<1)+c-48;return k;
}
void write(int x){if (x>9) write(x/10);putchar(x%10+48);}
int ask(int a[N][N],int xa,int ya,int xb,int yb){
return a[xb][yb]-a[xa-1][yb]-a[xb][ya-1]+a[xa-1][ya-1];
}
int main(){
n=read();m=read();Q=read();
for (i=1;i<=n;i++) scanf("%s",s[i]+1);
for (i=1;i<=n;i++) for (j=1;j<=m;j++)
a[i][j]=a[i][j-1]+a[i-1][j]-a[i-1][j-1]+(s[i][j]-=48);
for (i=1;i<n;i++) for (j=1;j<=m;j++)
f1[i][j]=f1[i][j-1]+f1[i-1][j]-
f1[i-1][j-1]+(s[i][j]&&s[i+1][j]);
for (i=1;i<=n;i++) for (j=1;j<m;j++)
f2[i][j]=f2[i][j-1]+f2[i-1][j]-
f2[i-1][j-1]+(s[i][j]&&s[i][j+1]);
for (;Q--;){
int xa=read(),ya=read(),xb=read(),yb=read();
int ans=ask(a,xa,ya,xb,yb)-
ask(f1,xa,ya,xb-1,yb)-ask(f2,xa,ya,xb,yb-1);
write(ans);putchar('\n');
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n == 1) {
cin >> n;
cout << (n ? "YES" : "NO");
} else {
bool zero = 0;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
if (!a && !zero)
zero = 1;
else if (!a && zero) {
cout << "NO";
return 0;
}
}
cout << (zero ? "YES" : "NO");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m,k,ans=0;
cin>>n>>m;
for(int i=0;i<n;i++){
cin>>k;ans+=(k>=m);
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long B = 100000007;
const double pi = acos(-1.0);
deque<int> dq1, dq2, dq3;
int main() {
int k, n1, n2, n3, t1, t2, t3;
cin >> k >> n1 >> n2 >> n3 >> t1 >> t2 >> t3;
int cur_t = 0;
while (k--) {
if (dq1.size() < n1 && dq2.size() < n2 && dq3.size() < n3) {
dq1.push_back(cur_t);
dq2.push_back(cur_t + t1);
dq3.push_back(cur_t + t1 + t2);
} else {
int d1 = 0, d2 = 0, d3 = 0;
int maxd = 0;
if (dq1.size() >= n1) {
d1 = dq1.front() + t1;
}
if (dq2.size() >= n2) {
d2 = dq2.front() + t2;
}
if (dq3.size() >= n3) {
d3 = dq3.front() + t3;
}
maxd = max(d1, d2 - t1);
maxd = max(maxd, d3 - t1 - t2);
cur_t = maxd;
dq1.push_back(cur_t);
dq2.push_back(cur_t + t1);
dq3.push_back(cur_t + t1 + t2);
while (dq1.front() + t1 <= cur_t) dq1.pop_front();
while (dq2.front() + t2 <= cur_t + t1) dq2.pop_front();
while (dq3.front() + t3 <= cur_t + t1 + t2) dq3.pop_front();
}
}
cout << cur_t + t1 + t2 + t3 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, p[200005], anw = 0, mul = 1, hd[200005];
const long long mod = 998244353;
long long pw(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a, ret = ret % mod;
b >>= 1, a = a * a, a = a % mod;
}
ret = ret % mod;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
hd[0] = 1;
for (int i = 1; i <= n; i++) cin >> p[i], hd[i] = (hd[i - 1] * 100) % mod;
anw = hd[n];
for (int i = 1; i < n; i++)
mul *= p[i], mul %= mod, anw += (mul * hd[n - i]) % mod, anw %= mod;
mul = mul * p[n], mul %= mod;
anw *= pw(mul, mod - 2), anw = anw % mod;
cout << anw;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int a[2000003], b[2000003];
int main() {
long long n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]] = 1;
}
for (i = 0; i < n; i++) {
cin >> b[i];
m[b[i]] = 1;
}
int cnt = 0;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (m.find(a[i] ^ b[j]) != m.end()) cnt++;
if (cnt % 2 == 1)
cout << "Koyomi";
else
cout << "Karen";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 9;
const int maxm = 2e5 + 9;
const long long inf = 1e18;
const int mod = 1e6;
int n, m;
int id[maxn];
namespace IO {
inline int read() {
int a = 1, b = 0;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') a = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
b = (b << 3) + (b << 1) + c - '0';
c = getchar();
}
return a * b;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
} // namespace IO
using namespace IO;
void One() {
cout << "First" << endl;
for (register int i = 1; i <= 2 * n; ++i) cout << i % n + 1 << ' ';
}
vector<int> G[maxn];
bool vis[maxn], col[maxn];
int sum = 0;
void dfs(int now, int Col) {
vis[now] = 1;
col[now] = Col;
if (Col == 1) sum = (sum + now) % m;
int sze = G[now].size();
for (register int i = 0; i <= sze - 1; ++i) {
int to = G[now][i];
if (!vis[to]) dfs(to, Col ^ 1);
}
}
void Two() {
int A;
m = n << 1;
cout << "Second" << endl;
for (register int i = 1; i <= m; ++i) {
A = read();
if (!id[A])
id[A] = i;
else
G[i].push_back(id[A]), G[id[A]].push_back(i);
}
for (register int i = 1; i <= n; ++i)
G[i].push_back(i + n), G[i + n].push_back(i);
for (register int i = 1; i <= m; ++i)
if (!vis[i]) dfs(i, 1);
if (sum)
for (register int i = 1; i <= m; ++i) col[i] ^= 1;
for (register int i = 1; i <= m; ++i) {
if (col[i]) cout << i << ' ';
}
}
int main() {
int A, B;
n = read();
if (n % 2 == 0)
One();
else
Two();
return 0;
}
| 4 |
#include <bits/stdc++.h>
void swap(int *x, int *y);
int main() {
int a[100], b[100], i, j, n, k, max_sum, s, l, r, bools_max_ind, max_ind;
scanf("%d", &n);
for (i = 0; i < 100; ++i) a[i] = b[i] = 0;
max_ind = -1;
bools_max_ind = 0;
for (i = 0; i < n; ++i) {
scanf("%d %d", a + i, b + i);
if (*(a + i) == 0) {
max_ind = i;
bools_max_ind = 1;
}
}
for (i = 0; i < n - 1; ++i)
for (j = 0; j < n - 1; ++j)
if (a[j] > a[j + 1]) {
swap(a + j, a + j + 1);
swap(b + j, b + j + 1);
}
max_sum = (bools_max_ind == 1) ? b[max_ind] : 0;
k = 0;
while (0 > a[k]) ++k;
if (bools_max_ind == 1) {
l = max_ind - 1;
r = max_ind + 1;
} else {
r = k;
l = --k;
}
s = (n - 1 - r > l) ? 1 : 0;
while (1) {
if (s == 1 && r >= n || s == 0 && l < 0) break;
max_sum += (s == 1) ? b[r] : b[l];
(s == 1) ? ++r : --l;
s = 1 - s;
}
printf("%d", max_sum);
return 0;
}
void swap(int *x, int *y) {
int z;
z = *x;
*x = *y;
*y = z;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5050;
long long f[20];
int ans[20] = {0, 1, 0, 18, 0, 1800,
0, 670320, 0, 734832000, 0, 890786230,
0, 695720788, 0, 150347555, 0};
const long long mod = 1000000007;
int n, m, num;
void dfs(int pos, int B, int C) {
if (pos > m) {
num++;
if (num >= mod) num -= mod;
return;
}
for (int i = 1; i <= m; i++) {
if (!((1 << i) & B)) {
int j = (i - 1 + pos - 1) % m + 1;
if (!((1 << j) & C)) dfs(pos + 1, B ^ (1 << i), C ^ (1 << j));
}
}
}
void init() {
f[0] = 1;
for (int i = 1; i <= 16; i++) f[i] = f[i - 1] * i % mod;
for (int i = 1; i <= 16; i++) {
m = i;
num = 0;
dfs(1, 0, 0);
printf("%d,", f[i] * (long long)num % mod);
}
}
int main() {
int n;
scanf("%d", &n);
printf("%d\n", ans[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238;
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vector) {
for (size_t i = 0; i < vector.size(); ++i) {
os << vector[i] << " ";
}
return os;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const set<T>& st) {
for (typename set<T>::iterator it = st.begin(); it != st.end(); ++it) {
os << (*it) << " ";
}
return os;
}
int GetNumBinaryDigits(int x) {
if (x == 0) {
return 1;
}
int res = 0;
while (x > 0) {
x >>= 1;
++res;
}
return res;
}
int GetBeauty(int x) {
if (x == 0) {
return -1;
}
int otv = 0;
while ((x & 1) == 0) {
++otv;
x >>= 1;
}
return otv;
}
bool IsContain(int x, int k) { return GetNumBinaryDigits(x) >= k + 1; }
int n;
int main() {
std::ios_base::sync_with_stdio(false);
cin >> n;
vector<int> v(n);
for (int i = 0; i < (int)(n); ++i) {
cin >> v[i];
}
int k_res = -1;
int size_res = -1;
for (int k = 29; k >= 0; --k) {
int res = (1 << 30) - 1;
int size = 0;
for (int i = 0; i < (int)(n); ++i) {
if (v[i] & (1 << k)) {
res = (res & v[i]);
++size;
}
}
if (res % (1 << k) == 0) {
k_res = k;
size_res = size;
break;
}
}
cout << size_res << "\n";
for (int i = 0; i < (int)(n); ++i) {
if (v[i] & (1 << k_res)) {
cout << v[i] << " ";
}
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a) for(int i=0;i<(a);i++)
const ll MOD=1000000007;
int main(){
int N; cin>>N;
int sum=0;
set<int> s;
rep(i,N){
int a; cin>>a;
sum^=a;
// a^(a-1)=111・・・111
s.insert(__builtin_popcount(a^(a-1)));
}
int cnt=0;
while(sum){
// __builtin_clz：2進で表した場合いくつ０を埋めるか
int x=32-__builtin_clz(sum);
if(!s.count(x)){
cout<<-1<<endl;
return 0;
}
cnt++;
sum^=(1LL<<x)-1;
}
cout<<cnt<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
set<int> s;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a;
if (a != 0) s.insert(a);
}
cout << s.size() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int maxn = 112345;
pair<int, int> arr[maxn];
int n;
int preMin[maxn], preMax[maxn], sufMin[maxn], sufMax[maxn];
int passed(double mid) {
int j = 1;
for (int i = 1; i <= n; i++) {
while (j <= n && 1.0 * (arr[j].first - arr[i].first) <= 2.0 * mid) j++;
if (i == 1 && j == n + 1) return 1;
int maxx = -INF, minn = INF;
if (i > 1) {
maxx = max(maxx, preMax[i - 1]);
minn = min(minn, preMin[i - 1]);
}
if (j <= n) {
maxx = max(maxx, sufMax[j]);
minn = min(minn, sufMin[j]);
}
if (1.0 * (maxx - minn) <= 2.0 * mid) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
int i, x, y;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
arr[i] = make_pair(x - y, x + y);
}
sort(arr + 1, arr + n + 1);
preMin[1] = arr[1].second;
preMax[1] = arr[1].second;
for (int i = 2; i <= n; i++) {
preMin[i] = min(preMin[i - 1], arr[i].second);
preMax[i] = max(preMax[i - 1], arr[i].second);
}
sufMin[n] = arr[n].second;
sufMax[n] = arr[n].second;
for (int i = n - 1; i >= 1; i--) {
sufMin[i] = min(sufMin[i + 1], arr[i].second);
sufMax[i] = max(sufMax[i + 1], arr[i].second);
}
double low = 0.0;
double high = INF;
int cnt = 100;
while (cnt--) {
double mid = (low + high) / 2.0;
if (passed(mid))
high = mid;
else
low = mid;
}
printf("%.15f\n", high);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
vector<int> g[500];
int n, m, k, ans, l, r, e[10000];
bool b[10000];
void dfs(int x) {
b[x] = true;
for (int i = 0; i < g[x].size(); i++) {
if (l <= g[x][i] and r >= g[x][i]) continue;
int y = e[g[x][i]] ^ x;
if (!b[y]) dfs(y);
}
}
int main() {
n = read(), m = read();
for (int i = 0; i < m; i++) {
int x = read() - 1, y = read() - 1;
g[x].push_back(i);
g[y].push_back(i);
e[i] = x ^ y;
}
k = read();
for (int i = 0; i < k; i++) {
l = read() - 1, r = read() - 1, ans = 0;
memset(b, 0, sizeof(b));
for (int j = 0; j < n; j++)
if (!b[j]) ans++, dfs(j);
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long list[100];
long long del[100];
char s[5][10] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
int main() {
long long now = 5;
int ptr = 1;
list[0] = 1;
while (now <= 1000000000) {
list[ptr] = list[ptr - 1] + now;
++ptr;
now *= 2;
}
long long n;
scanf("%I64d", &n);
int i;
for (i = 0; n >= list[i]; ++i)
;
--i;
n -= list[i];
++n;
int tmp = n / (1 << i);
if (n % (1 << i)) ++tmp;
--tmp;
printf("%s\n", s[tmp]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 15;
int n, m, p[N];
struct po {
int x, y;
} a[N], b[N];
bool g[N * N][N * N];
double mult(po a, po b, po c) {
return (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y);
}
bool inters(po aa, po bb, po cc, po dd) {
if (max(aa.x, bb.x) < min(cc.x, dd.x)) return false;
if (max(cc.x, dd.x) < min(aa.x, bb.x)) return false;
if (max(aa.y, bb.y) < min(cc.y, dd.y)) return false;
if (max(cc.y, dd.y) < min(aa.y, bb.y)) return false;
if (mult(cc, bb, aa) * mult(dd, bb, aa) <= 0 &&
mult(aa, dd, cc) * mult(bb, dd, cc) <= 0)
return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
if (n != m) {
puts("No");
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= m; ++i) scanf("%d%d", &b[i].x, &b[i].y);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k)
if (i != k) {
for (int l = 1; l <= n; ++l)
if (j != l) {
if (inters(a[i], b[j], a[k], b[l]))
g[i * (n + 1) + j][k * (n + 1) + l] = 1;
}
}
}
}
for (int i = 1; i <= n; ++i) p[i] = i;
bool ok;
for (;;) {
ok = 1;
for (int i = 1, j; i <= n && ok; ++i) {
j = p[i];
for (int k = 1, l; k <= n && ok; ++k)
if (k != i) {
l = p[k];
if (g[i * (n + 1) + j][k * (n + 1) + l]) ok = 0;
}
}
if (ok) {
puts("Yes");
return 0;
}
if (!next_permutation(p + 1, p + 1 + n)) break;
}
puts("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string ITS(long long x) {
string s = "";
while (x > 0) {
s += (char)(x % 10 + '0');
x /= 10;
}
string t = "";
for (int i = s.size() - 1; i > -1; i--) t += s[i];
return t;
}
long long inf = 1e18;
long long mod = 1e9 + 7;
const long long M = 2e5;
long long p[M];
int main() {
std::ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> p[i];
}
sort(p, p + n);
long long r = 0, j = 0;
string s = "";
for (long long i = 1; 1; i++) {
if (i > m) {
cout << r << '\n' << s;
return 0;
}
if (p[j] == i) {
j++;
} else {
s += ITS(i) + ' ';
m -= i;
r++;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-6;
const long long mod = 1000000007;
namespace fastio {
char in[100000];
long long itr = 0, llen = 0;
char get() {
if (itr == llen) llen = fread(in, 1, 100000, stdin), itr = 0;
if (llen == 0) return EOF;
return in[itr++];
}
char out[100000];
long long itr2 = 0;
void put(char c) {
out[itr2++] = c;
if (itr2 == 100000) {
fwrite(out, 1, 100000, stdout);
itr2 = 0;
}
}
long long clear() {
fwrite(out, 1, itr2, stdout);
itr2 = 0;
return 0;
}
long long getint() {
long long r = 0;
bool ng = 0;
char c;
c = get();
while (c != '-' && (c < '0' || c > '9')) c = get();
if (c == '-') ng = 1, c = get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = get();
return ng ? -r : r;
}
string getstr() {
string ret = "";
char ch = get();
while (ch == ' ' || ch == '\n') ch = get();
while (ch != ' ' && ch != '\n') ret.push_back(ch), ch = get();
return ret;
}
void putstr(string s) {
for (long long i = 0; i < s.size(); i++) put(s[i]);
}
void putint(long long x) {
if (x == 0) {
put('0');
return;
}
char c[40];
long long pos = 0;
while (x) {
c[pos++] = '0' + x % 10;
x /= 10;
}
for (long long i = pos - 1; i >= 0; i--) put(c[i]);
}
} // namespace fastio
using namespace fastio;
long long n, m;
vector<pair<long long, long long> > g[1000005];
long long dfn[1000005], lowlink[1000005], cnt = 1;
vector<pair<long long, long long> > ng[1000005];
long long sccval[1000005], mem[1000005], vis[1000005];
vector<long long> all;
void dfs(long long x) {
lowlink[x] = dfn[x] = cnt++;
vis[x] = 1;
all.push_back(x);
for (long long i = 0; i < g[x].size(); i++) {
long long to = g[x][i].first;
if (!dfn[to])
dfs(to), lowlink[x] = min(lowlink[x], lowlink[to]);
else if (vis[to])
lowlink[x] = min(lowlink[x], lowlink[to]);
}
if (dfn[x] == lowlink[x]) {
while (1) {
long long T = all.back();
all.pop_back();
lowlink[T] = dfn[x];
vis[T] = 0;
if (T == x) break;
}
}
}
long long dfs2(long long x) {
if (mem[x] != -1) return mem[x];
long long ret = sccval[x];
for (long long i = 0; i < ng[x].size(); i++) {
ret = max(ret, ng[x][i].second + dfs2(ng[x][i].first) + sccval[x]);
}
return mem[x] = ret;
}
long long memory[1000005], ini1[1000005], ini[1000005];
long long Get(long long x) {
if (memory[x] != 0 || x == 0) memory[x];
long long ret = 0;
for (long long i = 1; i <= x; i++) {
ret += i * (i + 1);
memory[i] = ret;
}
return ret;
}
long long calc(long long w) {
long long l = 0, r = 20000, ans = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (ini1[mid] > w)
r = mid - 1;
else
l = mid + 1;
}
return 1ll * w * (r + 1) - ini[r];
}
signed main() {
for (long long i = 1; i <= 1000005; i++) {
ini1[i] = ini1[i - 1] + i;
}
for (long long i = 1; i <= 1000005; i++) {
ini[i] = ini[i - 1] + ini1[i];
}
n = getint();
m = getint();
for (long long i = 0; i < m; i++) {
long long x = getint(), y = getint(), z = getint();
g[x].push_back(make_pair(y, z));
}
long long s = getint();
dfs(s);
for (long long i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < g[i].size(); j++) {
long long to = g[i][j].first, val = g[i][j].second;
if (lowlink[to] == lowlink[i]) {
sccval[lowlink[to]] += calc(val);
} else {
ng[lowlink[i]].push_back(make_pair(lowlink[to], val));
}
}
}
memset(mem, -1, sizeof(mem));
long long ans = dfs2(1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char pk[1000002];
int main() {
while (~scanf("%s", pk)) {
int slen = strlen(pk);
int mnum = 0, ans = 0, pos = 0;
while (pos < slen && pk[pos] == 'F') ++pos;
for (int i = pos; i < slen; ++i) {
if (pk[i] == 'M')
++mnum;
else
ans = max(ans + 1, mnum);
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct rebro {
int l, r;
int x, y;
int prop;
};
rebro a[3003];
rebro b[3003];
int n, m;
void mergesort(rebro *a, rebro *b, int n) {
int i, i0, i1, iRight, iEnd, width, j;
for (width = 1; width < n; width *= 2)
for (i = 0; i < n; i += width * 2) {
i0 = i;
i1 = iRight = min(i + width, n);
iEnd = min(i + width * 2, n);
for (j = i; j < iEnd; j++)
if (i0 < iRight && (i1 == iEnd || a[i0].prop > a[i1].prop))
b[j] = a[i0++];
else
b[j] = a[i1++];
for (j = i; j < iEnd; j++) a[j] = b[j];
}
}
int pred[1003];
int size[1003];
void build() {
int i;
for (i = 0; i < n; i++) {
pred[i] = i;
size[i] = 1;
}
}
int findset(int v) {
if (pred[v] == v) return v;
return pred[v] = findset(pred[v]);
}
struct rebro2 {
int prop;
int v;
};
vector<rebro2> g[1003];
void uniset(rebro i) {
int x = findset(i.x);
int y = findset(i.y);
rebro2 k;
if (x != y) {
k.v = i.y;
k.prop = i.prop;
g[i.x].push_back(k);
k.v = i.x;
g[i.y].push_back(k);
if (size[x] > size[y]) {
size[x] += size[y];
pred[y] = x;
} else {
size[y] += size[x];
pred[x] = y;
}
}
}
int rec;
bool flag[1003];
void dfs(int x, int res) {
flag[x] = true;
if (x == n - 1) {
rec = res;
return;
}
for (size_t i = 0; i < g[x].size(); i++) {
if (!flag[g[x][i].v]) dfs(g[x][i].v, min(res, g[x][i].prop));
}
}
int main() {
scanf("%d %d", &n, &m);
int i, j;
for (i = 0; i < m; i++) {
scanf("%d %d %d %d", &a[i].x, &a[i].y, &a[i].l, &a[i].r);
a[i].x--;
a[i].y--;
}
int maxi = 0;
int ok;
int c[3003];
for (i = 0; i < m; i++) c[i] = a[i].l;
for (i = 0; i < m; i++) {
ok = c[i];
for (j = 0; j < m; j++) {
if (a[j].r >= ok && a[j].l <= ok)
a[j].prop = a[j].r - ok + 1;
else
a[j].prop = 0;
}
for (j = 0; j < n; j++) {
g[j].resize(0);
flag[j] = false;
}
mergesort(a, b, m);
build();
for (j = 0; j < m; j++)
if (a[j].prop > 0) uniset(a[j]);
rec = 0;
dfs(0, 1000000);
maxi = max(maxi, rec);
}
if (maxi == 0)
printf("Nice work, Dima!\n");
else
printf("%d\n", maxi);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long f[20], jv, n;
inline long long pow(long long, long long), take(long long);
int main() {
long long s, ans(0);
int i, j, li;
scanf("%lld%lld", &n, &s), li = (1 << n) - 1;
for (i = 0; i < n; ++i) scanf("%lld", &f[i]);
for (i = jv = 1; i < n; ++i) (jv *= i) %= 1000000007;
jv = pow(jv, 1000000007 - 2);
for (i = 0; i <= li; ++i) {
long long lsy(n + s - 1), xs(1);
for (j = n - 1; j >= 0; --j)
if (i >> j & 1) lsy -= f[j] + 1, xs *= -1;
(ans += xs * take(lsy)) %= 1000000007;
}
printf("%lld", (ans + 1000000007) % 1000000007);
return 0;
}
inline long long take(long long x) {
if (x < n - 1) return 0;
long long ans(1);
x %= 1000000007;
for (long long i(x - n + 2); i <= x; ++i) (ans *= i) %= 1000000007;
return ans * jv % 1000000007;
}
inline long long pow(long long x, long long y) {
long long ans(1);
while (y) {
if (y & 1) (ans *= x) %= 1000000007;
(x *= x) %= 1000000007, y >>= 1;
}
return ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const int MAX = 3e5 + 5;
const int MAXN = 1000000;
const int MAX_N = MAX;
const long long MOD = 1e9 + 7;
const long double pi = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline void read(T& num) {
bool start = false, neg = false;
char c;
num = 0;
while ((c = getchar()) != EOF) {
if (c == '-')
start = neg = true;
else if (c >= '0' && c <= '9') {
start = true;
num = num * 10 + c - '0';
} else if (start)
break;
}
if (neg) num = -num;
}
inline long long powMM(long long a, long long b, long long M) {
long long ret = 1;
a %= M;
while (b) {
if (b & 1) ret = ret * a % M;
b >>= 1;
a = a * a % M;
}
return ret;
}
void open() {
freopen("1009.in", "r", stdin);
freopen("out.txt", "w", stdout);
}
int n, dp[2][31], tem, now, pre, an = INF;
int main() {
scanf("%d", &n);
memset(dp, 0x3f, sizeof(dp));
now = 1;
dp[pre][0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &tem);
;
for (int j = 0; j <= 30; j++) {
dp[now][min(30, j + tem / 1000)] =
min(dp[now][min(30, j + tem / 1000)], dp[pre][j] + tem);
dp[now][j - min(j, tem / 100)] =
min(dp[now][j - min(j, tem / 100)],
dp[pre][j] + tem - min(j, tem / 100) * 100);
}
swap(now, pre);
memset(dp[now], 0x3f, sizeof(dp[now]));
}
for (int j = 0; j <= 30; j++) an = min(an, dp[pre][j]);
printf("%d\n", an);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int Rselect(vector<int>&, int, int, int);
int partition(vector<int>&, int, int);
template <typename T>
ostream& operator<<(ostream& stream, const vector<T>& vec) {
for (auto& i : vec) {
stream << i << ' ';
}
stream << '\n';
return stream;
}
template <class T>
istream& operator>>(istream& stream, vector<T>& vec) {
for (auto& i : vec) {
stream >> i;
}
return stream;
}
void solve();
void scanN(vector<long long>& v, long long n) {
for (long long i = 0; i < n; i++) {
int num;
cin >> num;
v.push_back(num);
}
}
void scans(vector<string>& v, long long n) {
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long modfactorial(long long n, long long p) {
if (n >= p) return 0;
long long result = 1;
for (long long i = 1; i < n + 1; i++) {
result = result * i;
result = result % p;
}
return result;
}
long long MI(long long a, long long b, long long s0, long long s1) {
long long k = b;
if (b == 0)
return s0;
else {
return MI(b, a % b, s1, s0 - s1 * (a / b));
}
}
long long choose(long long a, long long b, long long c) {
if (a < b) return 0;
long long x = modfactorial(a, c);
long long y = modfactorial(b, c);
long long z = modfactorial(a - b, c);
long long y_ = MI(y, c, 1, 0);
if (y_ < 0) y_ = y_ + c;
long long z_ = MI(z, c, 1, 0);
if (z_ < 0) z_ = z_ + c;
long long mul = (x * y_) % c;
mul = (mul * z_) % c;
return mul;
}
long long pow2(long long n) {
if (n == 0) return 1;
long long result = 1;
long long i = 1;
while (i <= n) {
result = result * 2;
i++;
}
return result;
}
long long pow1(long long n, long long p) {
long long N = 1000000007;
if (p == 0) return 1;
long long result = 1;
long long i = 1;
while (i <= p) {
result = result * n;
result = result % N;
}
return result;
}
int main() {
FAST();
int test;
cin >> test;
while (test--) {
solve();
}
return 0;
}
void solve() {
long long n;
cin >> n;
vector<long long> t;
scanN(t, n);
long long k = 1;
vector<int> occ(1024, 0);
bool done1 = false;
long long ans = 0;
for (long long i = 0; i < n; i++) {
occ[t[i]]++;
}
while (k < 1024) {
bool done2 = true;
vector<int> temp = occ;
for (long long j = 0; j < n; j++) {
long long num = t[j];
num = num ^ k;
if (temp[num] == 0) {
done2 = false;
break;
} else {
temp[num]--;
}
}
if (done2 == true) {
done1 = true;
ans = k;
break;
}
k++;
}
if (done1 == true) {
cout << ans << endl;
} else
cout << "-1" << endl;
}
int Rselect(vector<int>& v, int i, int l, int r) {
if (l == r) return v[l];
int pivot = partition(v, l, r);
if (pivot == i)
return v[pivot - 1];
else if (pivot < i) {
return Rselect(v, i, pivot, r);
} else {
return Rselect(v, i, l, pivot - 2);
}
}
int partition(vector<int>& v, int l, int r) {
int pivot_index = rand() % (r - l + 1) + l;
swap(v[pivot_index], v[l]);
int i = l + 1, j = l + 1;
while (j <= r) {
if (v[j] < v[l]) {
swap(v[j], v[i]);
i++;
}
j++;
}
swap(v[l], v[i - 1]);
return i;
}
| 2 |
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
using namespace std;
typedef long long int ll;
const ll mod = 1000000007;
const ll lim = 100000 + 1;
ll solve(void);
int main(void) {
cout << solve() << endl;
return 0;
}
ll solve(void) {
ll N, T;
cin >> N >> T;
vector<ll> count(lim, 0);
vector<ll> v(lim,0);
vector<ll> w(lim, 0);
vector<ll> num;
for (int i = 0; i < N; i++) {
int j;
cin >> j;
count[j] ++;
}
for (int i = 0; i + 1 < lim; i++) {
v[i + 1] += v[i] + count[i+1];
}
for (int i = T+1; i < lim; i++) {
w[i] = v[i-T-1];
}
for (int i = 0; i < lim; i++)
for( int j = 0; j < count[i]; j++)
num.push_back(i);
ll ans = 1;
for (ll i = 1; i < num.size(); i++) {
ll j = i + 1;
ans = (ans * (j - w[num[i]])) % mod;
}
return ans;
} | 0 |
#include <bits/stdc++.h>
int n, m, a, b, v[1111], d[1111];
int min(int a, int b) {
if (a <= b)
return a;
else
return b;
}
int main() {
int i;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) scanf("%d", &v[i]);
int ans = 0;
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
ans += min(v[a], v[b]);
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main(void){
string s;
cin>>s;
int w;
cin>>w;
for(int i=0;i<s.size();i+=w){
cout<<s[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 4e18;
const int inf = 2e9;
const int N = 1e5 + 5;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int n, k, h, m[N], v[N], ans[N], pos[N];
bool by(int lef, int rig) {
if (m[lef] != m[rig]) return m[lef] < m[rig];
return v[lef] < v[rig];
}
bool solve(double t) {
int x = 0, i;
for (i = 0; i < n; ++i)
if (v[pos[i]] * t >= (double)(x + 1) * h) ans[x++] = pos[i];
return x >= k;
}
int main(void) {
ios_base::sync_with_stdio(false);
int i;
scanf("%d %d %d", &n, &k, &h);
for (i = 0; i < n; ++i) scanf("%d", m + i);
for (i = 0; i < n; ++i) scanf("%d", v + i);
for (i = 0; i < n; ++i) pos[i] = i;
sort(pos, pos + n, by);
double l = 0.0, r = 1.0 * k * h;
for (i = 0; i < 100; ++i) {
double mid = (l + r) / 2;
if (solve(mid))
r = mid;
else
l = mid;
}
assert(solve(r));
for (i = 0; i < k; ++i) printf("%d ", ans[i] + 1);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int INF = int(1e9), mod = 10056, N = int(1e6) + 5;
int second, b;
pair<int, int> a[N];
pair<int, int> c[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> second >> b;
for (int i = 0; i < second; i++) {
int x;
cin >> x;
a[i] = make_pair(x, i);
}
for (int i = 0; i < b; i++) {
cin >> c[i].first >> c[i].second;
}
sort(c, c + b);
for (int i = 1; i < b; i++) {
c[i].second += c[i - 1].second;
}
for (int i = 0; i < second; i++) {
int x = a[i].first;
int l = 0;
int r = b - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (c[mid].first <= x) {
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << c[r].second << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void test_case() {
int n, m;
cin >> n >> m;
vector<unsigned long long> v1(n), v2(m);
for (auto &x : v1) cin >> x;
for (auto &x : v2) cin >> x;
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
unsigned long long best = numeric_limits<unsigned long long>::max();
unsigned long long sum = 0, pref = 0;
for (auto &x : v1) sum += x;
for (unsigned long long i = 0; i < m; i++) {
best = min(best, sum * (m - i) + pref);
pref += v2[i];
}
sum = pref;
pref = 0;
for (unsigned long long i = 0; i < n; i++) {
best = min(best, sum * (n - i) + pref);
pref += v1[i];
}
cout << best << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
test_case();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#define range(x) x.begin(), x.end()
#define pb push_back
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef unsigned long long ull;
void print(vector<int> &a)
{
for (int i = 0; i < a.size(); i++)
{
cout << a[i] << " ";
}
}
void ans()
{
int n,k;
cin>>n>>k;
string s="";
for(int i=0;i<k;i++){
s+='a';
}
int a=0;
int b=1;
int c=0;
for(int i=0;i<(n-k);i++){
if(b==1){
s+='b';
b=0;
c=1;
}
else if(c==1){
s+='c';
c=0;
a=1;
}
else if(a==1){
s+='a';
a=0;
b=1;
}
}
cout << s << "\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--)
{
ans();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[300005];
long long b[300005];
long long alla[300005];
long long allb[300005];
long long suma1[300005];
long long suma2[300005];
long long sumb1[300005];
long long sumb2[300005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
for (int i = 1; i <= n; i++) {
suma1[i] = suma1[i - 1] + a[i] * (i - 1);
sumb2[i] = sumb2[i - 1] + b[i] * (i);
}
for (int i = n; i >= 1; i--) {
alla[i] = alla[i + 1] + a[i];
allb[i] = allb[i + 1] + b[i];
if (i != 1)
suma2[i] = suma2[i + 1] + a[i] * (2 * n - i + 1);
else
suma2[i] = suma2[i + 1];
sumb1[i] = sumb1[i + 1] + b[i] * (2 * n - i);
}
long long ans = max(suma1[n] + sumb1[1], suma2[1] + sumb2[n]);
int k = 1;
int cnt = 0;
long long now = 0;
for (int i = 1; i <= n; i += 2) {
now += b[i] * k;
k++;
now += b[i + 1] * k;
k++;
now += a[i + 1] * k;
k++;
now += a[i + 2] * k;
k++;
cnt++;
ans = max(ans,
max(now + 2 * cnt * (alla[i + 3] + allb[i + 2]) + suma1[n] -
suma1[i + 2 > n ? n : i + 2] + sumb1[i + 2],
now + 2 * cnt * (alla[i + 3] + allb[i + 2]) + suma2[i + 3] +
sumb2[n] - sumb2[i + 1 > n ? n : i + 1]));
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
const int NMax = 100005;
vector<pair<int, int> > G[NMax];
bool Use[NMax];
void Read() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(make_pair(y, i));
G[y].push_back(make_pair(x, i));
}
}
int Solve(int node) {
vector<int> V, A;
V.clear();
A.clear();
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i].first, edge = G[node][i].second;
if (Use[edge] == 1) continue;
Use[edge] = 1;
A.push_back(neighb);
}
for (int i = 0; i < A.size(); i++) {
int neighb = A[i];
int u = Solve(neighb);
if (u == 0)
V.push_back(neighb);
else {
printf("%d %d %d\n", node, neighb, u);
}
}
if (V.size() == 0) return 0;
for (int i = 0; i < V.size() - 1; i += 2) {
printf("%d %d %d\n", V[i], node, V[i + 1]);
}
if (V.size() % 2 == 0) return 0;
return V[V.size() - 1];
}
int main() {
Read();
if (M % 2 == 1) {
printf("No solution\n");
return 0;
}
Solve(1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int C[205][205], f[2][55][55][102];
int n, m, K, k, mx, i, j, r, prv, nxt, ans, mod = 1000000007;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
scanf("%d%d%d", &n, &m, &K);
C[0][0] = 1;
for (i = 0; i <= n; i++)
for (j = 0; j <= i; j++) {
if (C[i][j] > K) C[i][j] = K + 1;
C[i + 1][j + 1] += C[i][j];
C[i + 1][j] += C[i][j];
}
n >>= 1;
prv = 0, nxt = 1;
for (i = 1; i <= n; i++) f[prv][i][i][1] = 1;
for (mx = 1; mx < m; mx++) {
memset(f[nxt], 0, sizeof f[nxt]);
for (i = 1; i <= n; i++)
for (j = 1; j <= i; j++)
for (k = 1; k <= K; k++)
if (f[prv][i][j][k]) {
ans = (ans + 1ll * (m - mx) * f[prv][i][j][k]) % mod;
for (r = 1; r <= n - i; r++) {
int tmp = k * C[r + j - 1][j - 1];
if (tmp > K) break;
add(f[nxt][i + r][r][tmp], f[prv][i][j][k]);
}
}
swap(prv, nxt);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool read(T& x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c) && (c != '-') && (c != EOF)) c = getchar();
if (c == EOF) return 0;
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) {
x = x * 10 + (c & 15);
c = getchar();
}
x *= f;
return 1;
}
template <typename T, typename... Args>
inline bool read(T& x, Args&... args) {
bool res = 1;
res &= read(x);
res &= read(args...);
return res;
}
const int M = 1000000007, INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int N = 1000009;
inline long long mul(long long a, long long b, long long p) {
const long long res = a * b - ((long long)((long double)a * b / p) * p);
return res < 0 ? res + p : (res < p ? res : res - p);
}
inline long long fp(long long a, long long b, long long Mod) {
long long res = (Mod != 1);
for (; b; b >>= 1, a = a * a % Mod)
if (b & 1) res = res * a % Mod;
return res;
}
inline long long fpl(long long a, long long b, long long Mod) {
long long res = (Mod != 1);
for (; b; b >>= 1, a = mul(a, a, Mod))
if (b & 1) res = mul(res, a, Mod);
return res;
}
template <typename T>
inline T gcd(T a, T b) {
while (b) {
T t = b;
b = a % b;
a = t;
}
return a;
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
inline T exgcd(T a, T b, T& x, T& y) {
T m = 0, n = 1, t;
x = 1, y = 0;
while (b) {
t = m, m = x - a / b * m, x = t;
t = n, n = y - a / b * n, y = t;
t = b, b = a % b, a = t;
}
return a;
}
inline long long Crt(long long a1, long long a2, long long mod1,
long long mod2) {
long long u, v;
const long long g = exgcd(mod1, mod2, u, v);
if ((a2 - a1) % g) return -1;
const long long m12 = abs(lcm(mod1, mod2)),
res =
(mul(mod1, mul(u, ((a2 - a1) / g), m12), m12) + a1) % m12;
return res <= 0 ? res + m12 : res;
}
template <unsigned T, long long P>
class CbmP {
long long p[T + 1], q[T + 1];
public:
CbmP() {
q[0] = p[0] = 1;
for (long long i = 1; i <= T; ++i) p[i] = p[i - 1] * i % P;
{
long long a = p[T], b = P, x = 1, y = 0, m = 0, n = 1, t;
while (b) {
t = m, m = x - a / b * m, x = t;
t = n, n = y - a / b * n, y = t;
t = b, b = a % b, a = t;
}
q[T] = (x % P + P) % P;
}
for (long long i = T - 1; i; --i) q[i] = q[i + 1] * (i + 1) % P;
}
long long operator()(long long n, long long m) const {
if (m < 0 || m > n) return 0;
return p[n] * q[m] % P * q[n - m] % P;
}
};
CbmP<6005009, M> C;
int n, q;
struct dat {
int k, id;
bool operator<(const dat& x) const { return k < x.k; }
} ask[N];
int ans[N];
int f[6000009], now = 2;
long long i2, i3, n3;
inline void init() {
read(n, q);
n3 = 3 * n + 3;
f[0] = n;
f[1] = (1ll * n * (n + 1) / 2) % M * 3ll % M;
i2 = fp(2ll, M - 2, M);
i3 = fp(3ll, M - 2, M);
f[2] = f[1] * 1ll * n % M;
for (int i = 3; i <= 3 * n; ++i)
f[i] = (C(n3, i + 1) - C(3, i + 1) - 3ll * f[i - 1] - 1ll * f[i - 2]) % M *
i3 % M,
f[i] = ((long long)f[i] + M) % M;
for (int i = (1), (ii) = (q); i <= (ii); ++i) {
int x;
read(x);
printf("%d\n", f[x]);
}
}
inline void solve() {}
signed main() {
init();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long int n, k;
cin >> n >> k;
long long int rem = max(n - (2ll * k), 0ll);
cout << ((n * (n - 1ll)) / 2ll) - ((rem * (rem - 1ll)) / 2ll) << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int mat[2][4] = {{-1, 0, 0, 1}, {0, -1, 1, 0}};
long long x[33], y[33];
vector<vector<int> > v;
void dfs(int topi, int prev, int dir, long long dist) {
if (v[topi].size() > 4) {
cout << "NO" << endl;
exit(0);
}
for (int i = 0, j = 0; i < v[topi].size(); i++)
if (v[topi][i] != prev) {
if (dir == 3 - j) j = (j + 1) % 4;
x[v[topi][i]] = x[topi] + dist * mat[0][j];
y[v[topi][i]] = y[topi] + dist * mat[1][j];
dfs(v[topi][i], topi, j, dist / 2);
j = (j + 1) % 4;
}
}
int main() {
cin >> n;
vector<int> vec;
v.insert(v.begin(), n + 1, vec);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int maxi = 0;
for (int i = 1; i <= n; i++) {
if (v[i].size() > v[maxi].size()) {
maxi = i;
}
}
dfs(maxi, maxi, -1, 1ll << 30);
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << x[i] << " " << y[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 901;
int n, r;
int s;
vector<pair<int, int> > p;
vector<int> candidate;
int res = 0;
vector<int> ret;
int getDist(int x1, int x2, int y1, int y2) {
return ((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2));
}
void backtrack(int start, int len, int dist) {
if (len >= n) {
if (res < dist) {
res = dist;
ret = candidate;
}
return;
}
for (int i = start; i < s; ++i) {
int t = dist;
for (int j = 0; j < (int)candidate.size(); ++j)
t += getDist(p[i].first, p[candidate[j]].first, p[i].second,
p[candidate[j]].second);
candidate.push_back(i);
backtrack(i, len + 1, t);
candidate.pop_back();
}
}
bool cmp(pair<int, int> A, pair<int, int> B) {
return ((A.first) * (A.first)) + ((A.second) * (A.second)) >
((B.first) * (B.first)) + ((B.second) * (B.second));
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(0);
cin >> n >> r;
for (int i = 0; i <= r; ++i) {
for (int j = 0; j <= r; ++j) {
if (((i) * (i)) + ((j) * (j)) <= ((r) * (r))) {
p.push_back(pair<int, int>(i, j));
if (i) p.push_back(pair<int, int>(-i, j));
if (j) p.push_back(pair<int, int>(i, -j));
if (i && j) p.push_back(pair<int, int>(-i, -j));
}
}
}
sort(p.begin(), p.end(), cmp);
p.resize(min((int)p.size(), 20));
s = p.size();
backtrack(0, 0, 0);
cout << res << "\n";
for (int i = 0; i < n; ++i)
cout << p[ret[i]].first << " " << p[ret[i]].second << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline long long power(int a, int b) {
if (b == 0) return 1LL;
if (b == 1) return 1LL * a;
long long tmp = power(a, b / 2);
tmp = tmp * tmp % mod;
if (b & 1) tmp = tmp * a % mod;
return tmp;
}
int main() {
int n;
long long ans = 1LL;
cin >> n;
for (int i = n + 1; i <= 2 * n - 1; i++) ans = ans * i % mod;
for (int i = 1; i <= n - 1; i++) ans = ans * power(i, mod - 2) % mod;
ans = (2 * ans + mod - n) % mod;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m, a;
char c;
cin >> h >> c >> m >> a;
int hh = a / 60, mm = a % 60;
while (mm--) {
m++;
if (m == 60) m = 0, hh++;
}
while (hh--) {
h++;
if (h == 24) h = 0;
}
printf("%.2d:%.2d", h, m);
}
| 2 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <stack>
#include <queue>
#include <numeric>
#include <cstring>
using namespace std;
#define REP(i, a, b) for(i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1<<29;
vector<vector<int> > warshall_floyd(vector<vector<int> > g){
int i, j, k;
rep(k, g.size()) rep(i, g.size()) rep(j, g.size()){
g[i][j] = min(g[i][j], g[k][j] + g[i][k]);
}
return g;
}
int main(){
int i, j, k;
int n, m;
while(1){
cin >> n >> m;
if(n == 0 && m == 0) break;
int res = 0;
int cost, delay;
string s, p, g;
vector<string> sta;
vector<vector<int> > graf(n, vector<int>(n, INF));
cin >> s >> p >> g;
rep(i, m){
string tmp1, tmp2;
cin >> tmp1 >> tmp2;
rep(j, sta.size()) if(sta[j] == tmp1) break;
if(j == sta.size()){ sta.push_back(tmp1); j = sta.size()-1;}
rep(k, sta.size()) if(sta[k] == tmp2) break;
if(k == sta.size()){ sta.push_back(tmp2); k = sta.size()-1;}
cin >> cost >> delay;
cost /= 40; cost += delay;
graf[j][k] = cost;
graf[k][j] = cost;
}
int scor, pcor, gcor;
rep(i, sta.size()){
if(sta[i] == s) scor = i;
if(sta[i] == p) pcor = i;
if(sta[i] == g) gcor = i;
}
vector<vector<int> > d = warshall_floyd(graf);
res += d[scor][pcor];
res += d[pcor][gcor];
cout << res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::string;
bool isZeroString(string Str) {
for (int i = 0; i < Str.length(); i++)
if (Str[i] == '1') return false;
return true;
}
bool isChangable(string A, string B) {
if (A == B) return true;
if (A.length() != 1 && (A.length() == B.length()))
if (isZeroString(A) || isZeroString(B))
return false;
else
return true;
else
return false;
}
int main() {
string A, B;
getline(cin, A);
getline(cin, B);
if (isChangable(A, B))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500000;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n), left(n), right(n);
for (long long i = 0; i < n; i++) cin >> v[i];
long long f = 0;
left[0] = v[0];
long long diff = 0;
for (long long i = 1; i < n; i++) {
diff += max((long long)0, v[i] - v[i - 1]);
left[i] = v[i] - diff;
}
right[n - 1] = v[n - 1];
diff = 0;
for (long long i = n - 2; i >= 0; i--) {
diff += max((long long)0, v[i] - v[i + 1]);
right[i] = v[i] - diff;
}
if (left[n - 1] >= 0 || right[0] >= 0) f = 1;
for (long long i = 0; i < n - 1; i++) {
long long l = v[i] - left[i];
long long r = v[i + 1] - right[i];
if (right[i + 1] >= l && left[i] >= r) f = 1;
}
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 1 |
#include <bits/stdc++.h>
const int N = 2005;
using namespace std;
bitset<N> f[N];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int t;
scanf("%d", &t);
if (t > 0) f[i][j] = 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (f[i][j]) {
f[i] |= f[j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (f[i][j]) {
f[i] |= f[j];
}
}
for (int i = 1; i <= n; i++) {
if (f[i].count() != n) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned int nextPowerOf2(unsigned int n) {
unsigned int p = 1;
if (n && !(n & (n - 1))) return n;
while (p < n) p <<= 1;
return p;
}
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
std::vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
long long currhead = v[0];
long long currdiff;
long long maxdiff = -1;
for (long long i = 1; i < n; i++) {
if (v[i] < currhead) {
currdiff = currhead - v[i];
maxdiff = max(maxdiff, currdiff);
}
if (v[i] > currhead) currhead = v[i];
}
if (maxdiff == -1)
cout << "0" << endl;
else {
long long result = floor(log2(maxdiff));
cout << result + 1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e14;
long long int mod = 1e9 + 7;
char en = '\n';
long long int arr[5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int a;
cin >> a;
long long int cnt1 = 0;
for (long long int i = 0; i <= 32; i++) {
if (a & (1ll << i)) cnt1++;
}
cout << (1ll << cnt1) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<string> s;
string str;
void init() { s.clear(); }
int main() {
int n;
while (~scanf("%d", &n)) {
init();
for (int i = 0; i < n; i++) {
cin >> str;
string tp = "";
int len = str.size();
for (int j = 0; j < len; j++) {
if (str[j] == 'u') {
tp += "oo";
} else if (str[j] == 'k') {
bool flag = false;
for (int k = j + 1; k < len; k++) {
if (str[k] == 'k')
continue;
else if (str[k] == 'h') {
tp += "h";
j = k;
flag = true;
break;
} else {
break;
}
}
if (!flag) {
tp += str[j];
}
} else {
tp += str[j];
}
}
s.insert(tp);
}
printf("%d\n", s.size());
}
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.