solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
char c;
while (cin >> a >> c) {
if ((a - 1) % 4 > 1) a -= 2;
long long ans = a - 1;
long long b = a / 4;
a -= b * 2;
ans += 6 * (a - 1);
if (c > 'c')
ans += 'f' - c + 1;
else {
ans += 3;
ans += c - 'a' + 1;
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int V;
cin >> V;
vector<vector<int>> d(V, vector<int>(V));
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
cin >> d[i][j];
}
}
long long res = 0;
for (int i = 0; i < V; i++) {
for (int j = 0; j < i; j++) {
res += min(d[i][j], d[j][i]);
}
}
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
const int inf = 1e9;
long long a[100005], f[65][100005], U;
int n, s[100005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
long long M = *std::max_element(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) a[i] = M - a[i];
for (int i = 0; i <= 63; ++i)
for (int j = 0; j <= n; ++j) f[i][j] = inf;
f[0][0] = 0;
for (int i = 0; i <= 62; ++i) {
for (int j = 1; j <= n; ++j) s[j] = s[j - 1] + ((a[n - j + 1] >> i) & 1);
U = (1ll << (i + 1)) - 1;
std::sort(a + 1, a + n + 1,
[](long long a, long long b) { return (a & U) < (b & U); });
int sum = s[n];
for (int j = 0; j <= n; ++j) {
int c11 = s[j];
int c10 = sum - s[j];
int c01 = j - s[j];
int c00 = (n - j) - (sum - s[j]);
f[i + 1][c11] = std::min(f[i + 1][c11], f[i][j] + c10 + c01);
f[i + 1][c11 + c10 + c01] =
std::min(f[i + 1][c11 + c10 + c01], f[i][j] + c11 + c00);
}
}
printf("%lld", f[63][0]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long int add(long long int x, long long int y) {
long long int res = x + y;
return (res >= 1000000007 ? res - 1000000007 : res);
}
long long int mul(long long int x, long long int y) {
long long int res = x * y;
return (res >= 1000000007 ? res % 1000000007 : res);
}
long long int sub(long long int x, long long int y) {
long long int res = x - y;
return (res < 0 ? res + 1000000007 : res);
}
long long int power(long long int x, long long int y) {
long long int res = 1;
x %= 1000000007;
while (y) {
if (y & 1) res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
long long int mod_inv(long long int x) { return power(x, 1000000007 - 2); }
using namespace std;
bool isPrime(long long int n) {
if (n <= 1) return false;
for (long long int i = 2; i < n; i++)
if (n % i == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int i, j;
if (isPrime(n) == true) {
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cout << 1 << " ";
}
cout << "\n";
}
} else {
long long int temp = n;
long long int a = n * (n - 1);
while (isPrime(a) == false || isPrime(a - (n * (n - 1))) == true) {
a++;
}
long long int diff = a - (n * (n - 1));
long long int x = temp - 1;
for (i = 0; i < temp; i++) {
for (j = 1; j <= x; j++) {
cout << temp << " ";
}
cout << diff << " ";
for (j = 1; j <= (temp - (x + 1)); j++) {
cout << temp << " ";
}
x--;
cout << "\n";
}
}
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs"
<< "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool no(int x) {
int a[10];
for (int i = 0; i < 10; i++) a[i] = 0;
for (int i = 0; i < 4; i++) {
a[x % 10]++;
if (a[x % 10] > 1) return 0;
x /= 10;
}
return 1;
}
int main() {
int n, i, k = 0, t, j, a[15], b[15], c[15], l, o, q, w, y[15][15] = {0}, u;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
t = a[i];
for (j = 0; j < 4; j++) {
y[i][t % 10]++;
t /= 10;
}
}
for (i = 0; i <= 9999; i++) {
if (no(i)) {
for (u = 1; u <= n; u++) {
q = w = 0;
l = i;
o = a[u];
for (j = 0; j < 4; j++) {
if (l % 10 == o % 10) {
q++;
} else if (y[u][l % 10])
w++;
l /= 10;
o /= 10;
}
if (q != b[u] || w != c[u]) break;
}
if (u == n + 1) {
k++, t = i;
}
}
}
if (k == 0)
cout << "Incorrect data";
else if (k == 1)
cout << setfill('0') << setw(4) << t;
else
cout << "Need more data";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7;
const int md = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> v;
int x = n;
set<int> st;
for (int i = 1; i <= n; ++i) {
st.insert(i);
}
int s = 1;
bool b = 1;
while (!st.empty()) {
v.push_back(s);
st.erase(s);
if (st.empty()) break;
if (b)
s = *--st.end();
else
s = *st.begin();
b = !b;
}
int ans = 0;
for (int i = 1; i < v.size(); ++i) {
ans += (v[i] + v[i - 1]) % (n + 1);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int n, m, c, p[N * N], comp[N][N], dist[3][N][N];
char g[N][N];
bool vis[N][N];
vector<vector<pair<int, int> > > bord;
set<pair<int, int> > add;
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
bool check(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && g[x][y] != '#';
}
int find(int u) { return p[u] == u ? u : p[u] = find(p[u]); }
void fill(int x, int y) {
queue<pair<int, int> > q;
q.push(make_pair(x, y));
vis[x][y] = 1;
comp[x][y] = c;
bool f;
bord.resize(bord.size() + 1);
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
f = 0;
for (int i = 0; i < 4; i++) {
int nx = u.first + dx[i], ny = u.second + dy[i];
if (!check(nx, ny) || vis[nx][ny]) continue;
if (g[nx][ny] != '.') {
vis[nx][ny] = 1;
comp[nx][ny] = c;
q.push(make_pair(nx, ny));
} else
f = 1;
}
if (f && add.find(u) == add.end()) {
add.insert(u);
bord[c].push_back(u);
}
}
c++;
}
void bfs(int c1) {
deque<pair<int, int> > q;
for (int i = 0; i < bord[c1].size(); i++) {
dist[c1][bord[c1][i].first][bord[c1][i].second] = 0;
q.push_back(make_pair(bord[c1][i].first, bord[c1][i].second));
}
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop_front();
for (int i = 0; i < 4; i++) {
int nx = u.first + dx[i], ny = u.second + dy[i];
if (!check(nx, ny) || dist[c1][nx][ny] != -1 || comp[nx][ny] == c1)
continue;
dist[c1][nx][ny] = dist[c1][u.first][u.second] + (g[nx][ny] == '.');
if (g[nx][ny] == '.')
q.push_back(make_pair(nx, ny));
else
q.push_front(make_pair(nx, ny));
}
}
}
int main() {
std::ios::sync_with_stdio(false);
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", g[i]);
c = 0;
memset(vis, 0, sizeof(vis));
memset(comp, -1, sizeof(comp));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] != '#' && g[i][j] != '.' && !vis[i][j]) fill(i, j);
for (int i = 0; i < c; i++) p[i] = i;
memset(dist, -1, sizeof(dist));
int ans = (int)1e9;
if (c == 1) {
puts("0");
return 0;
} else if (c == 2) {
bfs(0);
bfs(1);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (dist[0][i][j] != -1 && dist[1][i][j] != -1)
ans = min(ans, dist[0][i][j] + dist[1][i][j] - (g[i][j] == '.'));
} else {
bfs(0);
bfs(1);
bfs(2);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (dist[0][i][j] != -1 && dist[1][i][j] != -1 && dist[2][i][j] != -1)
ans = min(ans, dist[0][i][j] + dist[1][i][j] + dist[2][i][j] -
2 * (g[i][j] == '.'));
}
}
if (ans == (int)1e9)
puts("-1");
else
printf("%d\n", ans);
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
const int inf = 1e9;
struct road{
int dist;
int cost;
int to;
road(int d, int c, int t): dist(d), cost(c), to(t){}
bool operator < (const road &a) const{
return (dist==a.dist)? cost > a.cost : dist > a.dist;
}
};
int main(){
while(1){
int n,m;
cin >> n >> m;
if(n==0) break;
vector<vector<road> > adj(n);
for(int i=0; i<m; i++){
int u,v,d,c;
cin >> u >> v >> d >> c;
u--; v--;
adj[u].push_back(road(d, c, v));
adj[v].push_back(road(d, c, u));
}
priority_queue<road> wait;
wait.push(road(0, 0, 0));
vector<int> mindist(n, inf);
vector<bool> used(n, false);
mindist[0] = 0;
int ans=0;
while(!wait.empty()){
int dist = wait.top().dist;
int cost = wait.top().cost;
int pos = wait.top().to;
wait.pop();
if(dist > mindist[pos] || used[pos]) continue;
used[pos] = true;
ans += cost;
for(int i=0; i<(int)adj[pos].size(); i++){
int ndist = dist + adj[pos][i].dist;
int ncost = adj[pos][i].cost;
int to = adj[pos][i].to;
if(ndist <= mindist[to] && !used[to]){
wait.push(road(ndist, ncost, to));
mindist[to] = ndist;
}
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sum[30], res[30], num[30];
map<string, int> ma, ma1;
vector<string> s[1000000], ss[1000000];
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "? 1 1"
<< "\n";
fflush(stdout);
string s3;
cin >> s3;
fflush(stdout);
cout << "! " << s3;
return 0;
}
cout << "? 1 " << n << "\n";
fflush(stdout);
for (int i = (0); i < (n * (n + 1) / 2); i++) {
string sss;
cin >> sss;
for (int j = (0); j < (sss.size()); j++) {
num[sss[j] - 'a']++;
}
string s1 = "";
for (int j = (0); j < (26); j++) {
while (num[j]) {
s1 += (char)(j + 'a');
num[j]--;
}
}
s[s1.size()].push_back(s1);
ma[s1]++;
}
fflush(stdout);
cout << "? 2 " << n << "\n";
fflush(stdout);
for (int i = (0); i < ((n - 1) * (n) / 2); i++) {
string sss;
cin >> sss;
for (int j = (0); j < (sss.size()); j++) {
num[sss[j] - 'a']++;
}
string s1 = "";
for (int j = (0); j < (26); j++) {
while (num[j]) {
s1 += (char)(j + 'a');
num[j]--;
}
}
ss[s1.size()].push_back(s1);
ma1[s1]++;
}
fflush(stdout);
string ans = "";
for (int i = (1); i < (n + 1); i++) {
int len = s[i].size();
for (int j = (0); j < (len); j++) {
if (ma[s[i][j]] != ma1[s[i][j]]) {
memset(res, 0, sizeof(res));
memset(sum, 0, sizeof(sum));
for (int k = (0); k < (i); k++) {
res[s[i][j][k] - 'a']++;
}
for (int k = (0); k < (i - 1); k++) {
sum[ans[k] - 'a']++;
}
for (int k = (0); k < (26); k++) {
if (res[k] != sum[k]) {
ans += (char)('a' + k);
break;
}
}
break;
}
}
}
cout << "! " << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 5, mod = 1e9 + 7;
int n, k;
long long fac[maxn], pre[maxn], suf[maxn], y[maxn], inv[maxn];
long long pow_mod(long long a, long long b) {
a %= mod, b %= mod - 1;
if (!a) return 0;
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
inline long long f(long long x) {
long long ans = 0;
pre[0] = suf[k + 2 + 1] = 1;
for (int i = 1; i <= k + 2; i++) pre[i] = pre[i - 1] * (x - i) % mod;
for (int i = k + 2; i >= 1; i--) suf[i] = suf[i + 1] * (x - i) % mod;
for (int i = 1; i <= k + 2; i++) {
int flag = 1;
if ((k + 2 - i) & 1) flag = -1;
ans = (ans + y[i] * pre[i - 1] % mod * suf[i + 1] % mod * inv[i - 1] % mod *
inv[k + 2 - i] % mod * flag) %
mod;
}
return (ans + mod) % mod;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= k + 2; i++) y[i] = (y[i - 1] + pow_mod(i, k)) % mod;
fac[0] = 1, inv[0] = 1;
for (int i = 1; i <= k + 2; i++)
fac[i] = fac[i - 1] * i % mod, inv[i] = pow_mod(fac[i], mod - 2);
cout << f(n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
struct arr {
long long index, val;
};
struct query {
long long n, ind, index, ans;
};
bool compare(arr a1, arr a2) {
if (a1.val == a2.val) return (a1.index < a2.index);
return (a1.val > a2.val);
}
bool compare2(arr a1, arr a2) { return (a1.index < a2.index); }
bool compare1(query q1, query q2) { return (q1.n < q2.n); }
bool compare3(query q1, query q2) { return (q1.index < q2.index); }
int main() {
long long n, i;
cin >> n;
arr A[n];
for (i = 0; i < n; ++i) {
cin >> A[i].val;
A[i].index = i + 1;
}
sort(A, A + n, compare);
long long m;
cin >> m;
query q[m];
for (i = 0; i < m; ++i) {
cin >> q[i].n >> q[i].ind;
q[i].index = i;
}
sort(q, q + m, compare1);
for (i = 0; i < m; ++i) {
if (i != 0) {
if (q[i].n != q[i - 1].n) {
sort(A, A + q[i - 1].n, compare);
sort(A, A + q[i].n, compare2);
q[i].ans = A[q[i].ind - 1].val;
} else
q[i].ans = A[q[i].ind - 1].val;
} else {
sort(A, A + q[i].n, compare2);
q[i].ans = A[q[i].ind - 1].val;
}
}
sort(q, q + m, compare3);
for (i = 0; i < m; ++i) cout << q[i].ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 3e3 + 7;
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
char s[N], t[N];
long long dp[N][N];
int n, m;
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
int n = strlen(s + 1);
int m = strlen(t + 1);
for (int i = 1; i <= n; i++) {
if (i <= m) {
if (s[1] == t[i]) dp[i][i] = 2;
} else
dp[i][i] = 2;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j + i - 1 <= n; j++) {
int l = j, r = j + i - 1;
if (l <= m && s[i] == t[l])
dp[l][r] = (dp[l + 1][r] + dp[l][r]) % 998244353;
else if (l > m)
dp[l][r] = (dp[l + 1][r] + dp[l][r]) % 998244353;
if (r <= m && s[i] == t[r])
dp[l][r] = (dp[l][r - 1] + dp[l][r]) % 998244353;
else if (r > m)
dp[l][r] = (dp[l][r - 1] + dp[l][r]) % 998244353;
}
}
long long res = 0;
for (int i = m; i <= n; i++) res = (res + dp[1][i]) % 998244353;
cout << res << "\n";
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
using namespace std;
int n;
int a[5005], ans, nxt;
unordered_map<int, int> re;
int cnt[5005];
inline void fix(int &x) {
int fu = 1;
if (x < 0) fu = -1, x = -x;
for (register int i = 2; i * i <= x; i++)
while (x && x % (i * i) == 0) x /= (i * i);
x = x * fu;
}
inline void add(int x) {
if (!cnt[x]) ans++;
cnt[x]++;
}
int ret[5005];
int main() {
scanf("%d", &n);
re[0] = ++nxt;
for (register int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
fix(a[i]);
if (!re[a[i]]) re[a[i]] = ++nxt;
}
for (register int i = 1; i <= n; i++) {
memset(cnt, 0, sizeof(cnt));
ans = 0;
for (register int j = i; j <= n; j++) {
add(re[a[j]]);
if (cnt[re[0]] && ans > 1)
ret[ans - 1]++;
else
ret[ans]++;
}
}
for (register int i = 1; i <= n; i++) printf("%d%c", ret[i], 32);
putchar(10);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int n, a[21], bs, rs;
pair<int, int> b[21], r[1 << 21];
void go(int f, int bf, int t, int o, int p) {
if (!o || b[p].second) {
if (p) go(f, t, bf, 0, p - 1);
for (int i = 0; i < b[p].first; i++) r[rs].first = f, r[rs++].second = t;
b[p].second = 2 - b[p].second;
if (p) go(bf, f, t, 0, p - 1);
return;
}
if (!p) {
for (int i = 1; i < b[p].first; i++) r[rs].first = f, r[rs++].second = bf;
r[rs].first = f;
r[rs++].second = t;
for (int i = 1; i < b[p].first; i++) r[rs].first = bf, r[rs++].second = t;
return;
}
go(f, bf, t, 0, p - 1);
for (int i = 0; i < b[p].first; i++) r[rs].first = f, r[rs++].second = bf;
go(t, bf, f, 0, p - 1);
for (int i = 0; i < b[p].first; i++) r[rs].first = bf, r[rs++].second = t;
go(f, bf, t, 1, p - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0, j; i < n; i = j) {
for (j = i; j < n && a[i] == a[j]; j++)
;
b[bs].second = i == j - 1 ? 1 : 0;
b[bs++].first = j - i;
}
reverse(b, b + bs);
go(1, 2, 3, 1, bs - 1);
printf("%d\n", rs);
for (int i = 0; i < rs; i++) printf("%d %d\n", r[i].first, r[i].second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int y, b, r;
cin >> y >> b >> r;
cout << 3 * min(y + 1, min(b, r - 1)) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200001], c[200001], sum, m, yoy;
struct node {
int x, y;
} b[200001], d[200001];
bool cmp(node x, node y) { return x.x < y.x; }
bool check(int z) {
for (int i = 1; i <= n; i++) c[i] = a[i];
for (int i = 1; i <= n; i++) d[i].x = 0, d[i].y = 0;
for (int i = 1; i <= m; i++) {
if (b[i].x <= z) {
d[b[i].y].x = b[i].x;
d[b[i].y].y = b[i].y;
}
}
sort(d + 1, d + n + 1, cmp);
int p = 0, q = 0;
for (int i = 1; i <= n; i++) {
if (d[i].x) {
p += d[i].x - q;
q = d[i].x;
if (c[d[i].y] <= p) {
p -= c[d[i].y];
c[d[i].y] = 0;
} else {
c[d[i].y] -= p;
p = 0;
}
}
}
p += z - q;
for (int i = 1; i <= n; i++) {
p -= c[i] * 2;
if (p < 0) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 1; i <= m; i++) scanf("%d%d", &b[i].x, &b[i].y);
sort(b + 1, b + m + 1, cmp);
int l = sum - 1, r = sum << 2, mid = (l + r) >> 1, ans;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long n, k;
long long fib[100];
void solve() {
scanf("%I64d%I64d", &n, &k);
fib[0] = fib[1] = 1;
for (int i = 0; i < n; i++) fib[i + 2] = fib[i + 1] + fib[i];
vector<int> ans;
for (int i = n - 1; i >= 1; i--)
if (k > fib[i]) {
ans.push_back(n - i);
k -= fib[i];
i--;
}
int l = 0;
for (int i = 1; i < n + 1; i++) {
if (l < int((ans).size()) && ans[l] == i) {
printf("%d %d ", i + 1, i);
l++;
i++;
} else
printf("%d ", i);
}
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline int popcount(T t) {
if (std::numeric_limits<T>::digits <=
std::numeric_limits<unsigned int>::digits) {
return __builtin_popcount(t);
} else {
return __builtin_popcountll(t);
}
}
const long double EPS = 1e-8;
const long double PI = acosl(0.0) * 2;
void solve() {
const int N = 2000000;
vector<bool> prime(N, true);
vector<int> primes;
for (int p = 2; p < N; ++p) {
if (prime[p]) {
primes.push_back(p);
for (int i = p + p; i < N; i += p) prime[i] = false;
}
}
cerr << primes.size() << endl;
int n;
cin >> n;
for (int i = 0; i < int(n); ++i) {
if (i) cout << " ";
cout << primes[i];
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long b[1000009], c[1000009];
int main() {
unsigned long long n;
cin >> n;
unsigned long long a[n + 1];
unsigned long long sum = 0;
unsigned long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
sum += a[i];
}
for (int i = 1; i <= n; i++) {
b[a[i]]--;
if ((sum - a[i]) % 2 == 0 && (sum - a[i]) / 2 <= 1000000 &&
b[(sum - a[i]) / 2]) {
c[++ans] = i;
}
b[a[i]]++;
}
cout << ans << "\n";
for (int i = 1; i <= ans; i++) {
cout << c[i] << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
int n, dp[1000], sum, len, i, j, ans = 0;
const int mod = 1000000007;
cin >> s1 >> s2 >> n;
memset(dp, 0, sizeof(dp));
dp[0] = 1, len = ((int)s1.size());
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < len; j++) {
sum += dp[j];
if (sum >= mod) sum -= mod;
}
for (j = 0; j < len; j++) {
dp[j] = sum - dp[j];
if (dp[j] < 0) dp[j] += mod;
if (dp[j] >= mod) dp[j] -= mod;
}
}
for (i = 0; i < len; i++) {
if (s1.substr(i) + s1.substr(0, i) == s2) {
ans += dp[i];
if (ans >= mod) ans -= mod;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct triple {
int a, b, c;
bool operator<(const triple &r) const {
return a != r.a ? a < r.a : b != r.b ? b < r.b : c < r.c;
}
};
vector<triple> V;
int main() {
int n, res(0);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int k, c(0), val, x, y, m, nval;
scanf("%d%d%d%d%d", &k, &val, &x, &y, &m);
for (int j = 1; j <= k; ++j) {
V.push_back((triple){c, val, i});
nval = ((long long)val * x + y) % m;
if (nval < val && j != k) ++c;
val = nval;
}
res = max(res, c);
}
printf("%d\n", res);
if (V.size() <= 200000) {
sort(V.begin(), V.end());
for (auto it = V.begin(); it != V.end(); ++it)
printf("%d %d\n", it->b, it->c);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, k;
set<int> st;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
st.insert(k);
}
if (st.size() < 3) {
puts("YES");
return 0;
}
if (st.size() > 3) {
puts("NO");
return 0;
}
auto it = st.begin();
int x, y, z;
x = *it++;
y = *it++;
z = *it;
if (abs(y - x) == abs(z - y))
puts("YES");
else
puts("NO");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
for (long long j = 0; j < t; j++) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (b >= a)
cout << b << "\n";
else {
if (c <= d)
cout << "-1\n";
else {
long long count = 0;
if ((a - b) % (c - d) == 0)
count = (a - b) / (c - d);
else
count = (a - b + c - d - 1) / (c - d);
cout << b + count * c << "\n";
}
}
}
return 0;
}
| 1 |
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
using namespace std;
#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) (EQ((a).real(),(b).real()) && EQ((a).imag(),(b).imag()))
typedef complex<double> P;
typedef pair<P,P> Edge;
typedef long long ll;
// 24ñųÉàÇé
/*
zñÆ_CXÌÊÌÖW
c0ÍRXgN^ÌøÅ^¦çêéxN^Ìvf
0 c4 0 0
c3 c0 c2 c5
0 c1 0 0
*/
class Dice{
private:
int yoko;
int tate;
int round;
private:
int face[3][4];
public:
int getFace(const int idx)const{
if(idx==0)return face[1][1];
else if(idx==1)return face[2][1];
else if(idx==2)return face[1][2];
else if(idx==3)return face[1][0];
else if(idx==4)return face[0][1];
else if(idx==5)return face[1][3];
return -1;
}
Dice(){}
Dice(vector<int> v){
init();
face[1][1]=v[0];
face[2][1]=v[1];
face[1][2]=v[2];
face[1][0]=v[3];
face[0][1]=v[4];
face[1][3]=v[5];
}
private:
// _CXÌú»
void init(){
for(int i=0;i<3;i++)for(int j=0;j<4;j++)face[i][j]=-1;
yoko=0;
tate=0;
round=0;
}
public:
// _CXÌñ]
void rotate(){
if(round<4){
int tmp = face[2][1];
face[2][1]=face[1][2];
face[1][2]=face[0][1];
face[0][1]=face[1][0];
face[1][0]=tmp;
round++;
}
if(round>=4){
round=0;
// àÇÁÄ«½çA¡ÌXbgðñ]³¹é
if(yoko<4){
int tmp = face[1][3];
for(int i = 2; i >= 0; i--)
face[1][i+1]=face[1][i];
face[1][0]=tmp;
yoko++;
}
// àÇÁÄ«½çAcÌXbgðñ]³¹é
if(yoko>=4){
if(tate<4){
int loop=1;
if(tate==1)loop=2;
while(loop--){
tate++;
int tmp = face[1][3];
face[1][3]=face[0][1];
for(int i = 0; i < 2; i++)
face[i][1]=face[i+1][1];
face[2][1]=tmp;
}
}
if(tate>=4){
round=0;
tate=0;
yoko=0;
}
}
}
};
};
vector<int> idxs;
int cnt;
Dice dices[8];
void dfs(int pos){
if(pos==0){
for(int i=0;i<24;i++){
dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==1){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[0]].getFace(2);
int ch2=dices[idxs[pos]].getFace(3);
if(abs(ch1-ch2)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==2){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[1]].getFace(1);
int ch2=dices[idxs[pos]].getFace(4);
if(abs(ch1-ch2)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==3){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[2]].getFace(3);
int ch2=dices[idxs[pos]].getFace(2);
int ch3=dices[idxs[0]].getFace(1);
int ch4=dices[idxs[pos]].getFace(4);
if(abs(ch1-ch2)==32&&abs(ch3-ch4)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==4){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[0]].getFace(5);
int ch2=dices[idxs[pos]].getFace(0);
if(abs(ch1-ch2)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==5){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[4]].getFace(2);
int ch2=dices[idxs[pos]].getFace(3);
int ch3=dices[idxs[1]].getFace(5);
int ch4=dices[idxs[pos]].getFace(0);
if(abs(ch1-ch2)==32&&abs(ch3-ch4)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==6){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[5]].getFace(1);
int ch2=dices[idxs[pos]].getFace(4);
int ch3=dices[idxs[2]].getFace(5);
int ch4=dices[idxs[pos]].getFace(0);
if(abs(ch1-ch2)==32&&abs(ch3-ch4)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else if(pos==7){
for(int i=0;i<24;i++){
// ʪ¤©`FbN
int ch1=dices[idxs[4]].getFace(1);
int ch2=dices[idxs[pos]].getFace(4);
int ch3=dices[idxs[6]].getFace(3);
int ch4=dices[idxs[pos]].getFace(2);
int ch5=dices[idxs[3]].getFace(5);
int ch6=dices[idxs[pos]].getFace(0);
if(abs(ch1-ch2)==32&&abs(ch3-ch4)==32&&abs(ch5-ch6)==32)dfs(pos+1);
if(cnt>0)return;
dices[idxs[pos]].rotate();
}
}
else cnt++;
}
int main(){
string s;
while(getline(cin,s)&&s!="0"){
vector<int> d;
for(int i=0;i<s.size();i++)d.push_back(s[i]);
dices[0]=Dice(d);
for(int i=0;i<7;i++){
d.clear();
getline(cin,s);
for(int j=0;j<s.size();j++)d.push_back(s[j]);
dices[i+1]=Dice(d);
}
cnt=0;
idxs.clear();
for(int i=0;i<8;i++)idxs.push_back(i);
// ·ÅÉTõ³ê½àÌðÂÁ±ñŨ
set<vector<int> > searched;
do{
if(searched.find(idxs)!=searched.end())continue;
dfs(0);
for(int k=0;k<2;k++){
for(int i=0;i<4;i++){
searched.insert(idxs);
for(int base=0;base<2;base++){
int a=base*4;
int tmp=idxs[3+a];
idxs[3+a]=idxs[2+a];
idxs[2+a]=idxs[1+a];
idxs[1+a]=idxs[0+a];
idxs[a]=tmp;
}
}
swap(idxs[0],idxs[5]);
swap(idxs[1],idxs[4]);
swap(idxs[2],idxs[7]);
swap(idxs[3],idxs[6]);
}
if(cnt>0)break;
}while(next_permutation(idxs.begin(),idxs.end()));
if(cnt>0)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const int INF = 1e9;
const long long int LINF = 1e18;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
string s, s1, s2;
getline(cin, s);
getline(cin, s1);
getline(cin, s2);
long long int a = 0, b = 0, c = 0;
for (long long int i = 0; i < s.length(); i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
a++;
}
}
for (long long int i = 0; i < s1.length(); i++) {
if (s1[i] == 'a' || s1[i] == 'e' || s1[i] == 'i' || s1[i] == 'o' ||
s1[i] == 'u') {
b++;
}
}
for (long long int i = 0; i < s2.length(); i++) {
if (s2[i] == 'a' || s2[i] == 'e' || s2[i] == 'i' || s2[i] == 'o' ||
s2[i] == 'u') {
c++;
}
}
if (a == 5 && b == 7 && c == 5)
cout << "YES\n";
else
cout << "NO\n";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
signed long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << max({b * d, a * c, a * d, b * c}) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long k[100005], l[100005], cha[10005];
bool cmp(const long long a, const long long b) { return a > b; }
int main() {
long long n, f;
cin >> n >> f;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
cin >> k[i] >> l[i];
ans += min(k[i], l[i]);
cha[i] = min(2 * k[i], l[i]) - min(k[i], l[i]);
}
sort(cha + 1, cha + n + 1, cmp);
for (long long i = 1; i <= f; i++) {
ans += cha[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long n, flag = 0;
cin >> n;
std::vector<pair<long double, long double> > v(n);
for (int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
std::vector<long long> ans(n);
long double px = v[0].first, py = v[0].second;
ans[0] = 1;
for (int i = 1; i < n; i++) {
long double addx = (px + v[i].first);
long double addy = (py + v[i].second);
long double subx = (px - v[i].first);
long double suby = (py - v[i].second);
if (addx * addx + addy * addy > subx * subx + suby * suby) {
ans[i] = -1;
px -= v[i].first;
py -= v[i].second;
} else {
ans[i] = 1;
px += v[i].first;
py += v[i].second;
}
}
long double c = 1500000;
if (px * px + py * py > c * c) {
ans[0] = -1;
px = -v[0].first;
py = -v[0].second;
for (int i = 1; i < n; i++) {
long double addx = (px + v[i].first);
long double addy = (py + v[i].second);
long double subx = (px - v[i].first);
long double suby = (py - v[i].second);
if (addx * addx + addy * addy > subx * subx + suby * suby) {
ans[i] = -1;
px -= v[i].first;
py -= v[i].second;
} else {
ans[i] = 1;
px += v[i].first;
py += v[i].second;
}
}
}
if (px * px + py * py > c * c) {
ans[n - 1] = 1;
px = -v[n - 1].first;
py = -v[n - 1].second;
for (int i = n - 2; i > -1; i--) {
long double addx = (px + v[i].first);
long double addy = (py + v[i].second);
long double subx = (px - v[i].first);
long double suby = (py - v[i].second);
if (addx * addx + addy * addy > subx * subx + suby * suby) {
ans[i] = 1;
px -= v[i].first;
py -= v[i].second;
} else {
ans[i] = -1;
px += v[i].first;
py += v[i].second;
}
}
}
if (px * px + py * py > c * c) {
ans[n - 1] = -1;
px += v[n - 1].first;
py += v[n - 1].second;
for (int i = n - 2; i > -1; i--) {
long double addx = (px + v[i].first);
long double addy = (py + v[i].second);
long double subx = (px - v[i].first);
long double suby = (py - v[i].second);
if (addx * addx + addy * addy > subx * subx + suby * suby) {
ans[i] = 1;
px -= v[i].first;
py -= v[i].second;
} else {
ans[i] = -1;
px += v[i].first;
py += v[i].second;
}
}
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, c = 0;
cin >> n;
int a[n - 1];
for (int i = 0; i < n - 1; i++) {
cin >> a[i];
}
sort(a, a + n - 1);
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] - a[i] > 1) {
x = i + 1;
break;
}
}
if (a[0] == 1) {
cout << x + 1;
} else {
cout << 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long mini = v[0];
bool flag = 1;
for (long long i = 0; i < n; i++) {
v[i] -= mini;
if (v[i] & 1) {
flag = 0;
break;
}
}
cout << ((flag == 1) ? "YES" : "NO") << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define maxn 1000005
#define ll long long
int fin[maxn],suf[maxn][27],ch[maxn][27],tl=1,n;
ll ans;
std::string s[200005];
int cmp(std::string a,std::string b) { return a.length() < b.length(); }
void insert(std::string s) {
std::reverse(s.begin(),s.end());
int rt = 1, n = s.length();
for (int i = 0; i <= n; ++ i) std::memset(suf[i],0,sizeof(suf[i]));
for (int i = n-1; i >= 0; i--) {
for(int j=0;j<26;++j)suf[i][j]=suf[i+1][j];
suf[i][s[i]-'a']=1;
}
for (int p = 0; p < n; ++ p) {
int d = s[p] - 'a';
// printf("%d ",d);
for (int i = 0; i < 26; ++ i) {
//if (fin[ch[rt][i]]) printf("[%d %d %c]",p,suf[p][i],i+'a');
if (suf[p][i]) ans += fin[ch[rt][i]];
} if (!ch[rt][d]) ch[rt][d] = ++tl;
rt = ch[rt][d];
} fin[rt] ++;// puts("");
}
int main() {
scanf("%d",&n);
for (int i = 1; i <= n; ++ i) std::cin>>s[i];
std::sort(s+1,s+n+1,cmp);
for (int i = 1; i <= n; ++ i) insert(s[i]);
printf("%lld",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int m;
int p = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
int arr[m];
for (int j = 0; j < m; j++) {
cin >> arr[j];
}
if (arr[0] == 1) {
p = p + 1;
}
for (int k = 1; k < m; k++) {
if (k != 0 && arr[k] == 1 && arr[k - 1] == 0) {
p = p + 1;
} else if (arr[k - 1] == 0 && arr[k] == 0 && k != 0) {
p = -1;
break;
} else if (arr[k - 1] == 1 && arr[k] == 1) {
p = p + 5;
}
}
cout << p << endl;
p = 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
int n;
int d[1 << 16], x[1 << 16];
int main() {
scanf("%d", &n);
queue<int> q;
for (int i = 0; i < (n); i++) {
scanf("%d %d", &d[i], &x[i]);
if (d[i] == 1) q.push(i);
}
vector<pair<int, int> > f;
while (!q.empty()) {
int i = q.front();
q.pop();
if (d[i] != 1) continue;
int j = x[i];
f.push_back({i, j});
x[j] ^= i;
d[j]--;
if (d[j] == 1) q.push(j);
}
printf("%d\n", f.size());
for (auto ij : f) {
printf("%d %d\n", ij.first, ij.second);
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int n,W,w[109],v[109],dp[100009],ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dp,0x3f,sizeof(dp));
dp[0]=0;
cin>>n>>W;
for(int i=0;i<n;i++) cin>>w[i]>>v[i];
for(int i=0;i<n;i++)
for(int j=100008;j>=v[i];j--)
dp[j]=min(dp[j],dp[j-v[i]]+w[i]);
for(int i=100008;i>=0;i--)
if(dp[i]<=W) {
cout<<i<<endl;
return 0;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
vector<pair<pair<long long, long long>, long long>> b;
pair<long long, long long> cur = a[0];
long long cnt = 1;
for (long long i = 1; i < n; i++) {
if (a[i] != cur) {
b.push_back({cur, cnt});
cur = a[i];
cnt = 0;
}
cnt++;
}
b.push_back({cur, cnt});
unordered_map<long long, long long> x, y;
long long ans = 0;
for (long long i = 0; i < b.size(); i++) {
ans += x[b[i].first.first] * b[i].second;
ans += y[b[i].first.second] * b[i].second;
ans += b[i].second * (b[i].second - 1) / 2;
x[b[i].first.first] += b[i].second;
y[b[i].first.second] += b[i].second;
}
cout << ans;
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <utility>
#include <algorithm>
#include <cmath>
#include <climits>
#include <iomanip>
#include <queue>
#include <stack>
#include <ctype.h>
using namespace std;
typedef long long ll;
const int INF = (1<<30)-1;
const ll LINF = (1LL<<60)-1;
#define rep(i, n) for (int i = 0; i < n; i++)
template<class T>
bool chmax(T &a, T b) {if (a < b) {a = b;return true;}else return false;}
template<class T>
bool chmin(T &a, T b) {if (a > b) {a = b;return true;}else return false;}
class RAQ {
int n;
ll e;
vector<ll> dat;
public:
RAQ(int m, ll e_){
n = 1; e = e_;
while (n < m) n *= 2;
dat.resize(2*n-1, e);
}
void add(int a, int b, int x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
if (r <= a || b <= l)
return;
else if (a <= l && r <= b)
dat[k] += x;
else {
add(a, b, x, 2*k+1, l, (l+r)/2);
add(a, b, x, 2*k+2, (l+r)/2, r);
}
}
ll get(int k) {
k += n-1;
ll res = dat[k];
while (k > 0) {
k = (k-1) / 2;
res += dat[k];
}
return res;
}
};
//コーナーケースに気をつけろ！
int main() {
int t; cin >> t;
while (t--) {
int n; cin >> n;
vector<ll> s(n);
rep(i, n) cin >> s[i];
RAQ sg(n, 0);
ll ans = 0;
for (int i = 0; i < n; i++) {
ll t = sg.get(i);
if (t >= s[i]-1) {
ll l = i+2, r = i+s[i];
if (l < n && l <= r)
sg.add(l, min(r, (ll)n-1)+1, 1);
sg.add(i+1, i+2, t-(s[i]-1));
}
else {
ll l = i+2, r = i+s[i];
ans += s[i]-1-t;
if (l < n && l <= r)
sg.add(l, min(r, (ll)n-1)+1, 1);
}
}
cout << ans << endl;
}
return 0;
}
//小数点精度
//cout << fixed << std::setprecision(15) << y << endl; | 3 |
#include <bits/stdc++.h>
using namespace std;
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
template <typename... T>
void shit(T&... x) {}
template <typename... T>
void dec(T&... x) {
shit(--x...);
}
template <typename... T>
void inc(T&... x) {
shit(++x...);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) c = getchar();
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 1e9;
const double eps = 1e-9;
const int maxn = 1e6 + 227 + 1, base = 1e9 + 7;
const int sigm = 26;
const long long llinf = 1e18 + 1;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % base;
} else {
return (1LL * binpow(n, second - 1) * n) % base;
}
}
int inpt[55][55];
int good[55][55];
bool have4(int x, int y) {
return good[x + 1][y] == 4 || good[x - 1][y] == 4 || good[x][y + 1] == 4 ||
good[x][y - 1] == 4;
}
int main() {
int n;
read(n);
pair<int, int> left4, right4;
left4 = right4 = make_pair(-1, -1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
char c = '\n';
while (c == '\n') c = getchar();
inpt[i][j] = c - '0';
if (inpt[i][j] == 4) {
if (left4 == make_pair(-1, -1)) left4 = make_pair(i, j);
right4 = make_pair(i, j);
}
}
if (left4 == make_pair(-1, -1)) bad("No");
for (int i = left4.first; i <= right4.first; i++)
for (int j = left4.second; j <= right4.second; j++) good[i][j] = 4;
good[left4.first - 1][left4.second - 1] = 1;
good[left4.first - 1][right4.second + 1] = 1;
good[right4.first + 1][left4.second - 1] = 1;
good[right4.first + 1][right4.second + 1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (good[i][j] == 0 && have4(i, j)) good[i][j] = 2;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (good[i][j] != inpt[i][j]) bad("No");
}
bad("Yes");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int m;
vector<pair<int, int> > g[81];
int minut[81][81];
int dp[81][81][81][81];
long long mini = INT_MAX;
long long rek(int l, int r, int mid, int more) {
if (more == 0) return 0;
if (dp[l][r][mid][more] != 0) return dp[l][r][mid][more];
long long akt = INT_MAX;
for (auto s : g[mid]) {
if (s.first <= l || s.first >= r) continue;
if (s.first > mid)
akt = min(akt, s.second + rek(mid, r, s.first, more - 1));
else
akt = min(akt, s.second + rek(l, mid, s.first, more - 1));
}
dp[l][r][mid][more] = akt;
return akt;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
cin >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) minut[i][j] = INT_MAX;
}
for (int i = 1; i <= m; i++) {
int k, v, c;
cin >> k >> v >> c;
minut[k][v] = min(minut[k][v], c);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (minut[i][j] != INT_MAX) g[i].push_back({j, minut[i][j]});
}
}
for (int i = 1; i <= n; i++) {
mini = min(mini, rek(0, n + 1, i, k - 1));
}
if (mini == INT_MAX)
cout << -1;
else
cout << mini;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
int f[45][45][45],a[45][45];
int dfs(int l,int r,int x){
if(f[l][r][x]!=-1) return f[l][r][x];
if(l==x && r==x) return 1;
f[l][r][x]=0;
for(int j=l;j<x;++j)
for(int k=r;k>x;--k)
if(a[j][k]){
for(int p=j;p<x;++p)
for(int q=k;q>x;--q)
f[l][r][x]+=dfs(l,p,j)*dfs(q,r,k)*dfs(p+1,q-1,x);
}
return f[l][r][x];
}
signed main(){
int n;cin>>n;n<<=1;
char ch;
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j){
cin>>ch;a[i][j]=ch-'0';
}
int ans=0;
memset(f,-1,sizeof(f));
for(int x=2;x<=n;++x)
if(a[1][x]) ans+=dfs(2,n,x);
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
struct node {
int to[26], vis[26], s, siz;
} t[maxn];
vector<pair<int, int> > go[maxn];
vector<pair<int, int> > qr[maxn];
int dfn[maxn], refer[maxn], sig[maxn], len[maxn], dfn_cnt;
int ans[maxn], sav[maxn], siz[maxn], vis[maxn], fa[maxn], dep[maxn], ch[maxn],
tag, n, q, cnt;
void link(int u, int v, int c) { go[u].push_back(pair<int, int>(v, c)); }
void dfs(int now, int pre) {
fa[now] = pre, dep[now] = dep[pre] + 1;
refer[++dfn_cnt] = now;
for (auto p : go[now])
if (p.first != pre) ch[p.first] = p.second, dfs(p.first, now);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i < n; i++) {
int u, v;
char c;
scanf("%d%d%c%c", &u, &v, &c, &c);
link(u, v, c - 'a'), link(v, u, c - 'a');
}
int root = rand() % n + 1;
dfs(root, 0);
for (int i = 1; i <= q; i++) {
int u, v;
scanf("%d%d", &u, &v);
static int lis[maxn], lis1[maxn];
int co = 0, co1 = 0;
for (int p = u, q = v; p != q;)
if (dep[p] > dep[q])
lis[++co] = ch[p], p = fa[p];
else
lis1[++co1] = ch[q], q = fa[q];
for (; co1; co1--) lis[++co] = lis1[co1];
memset(len, 255, sizeof len);
len[u] = 0, sig[u] = 1;
for (int p = u; fa[p]; p = fa[p]) {
len[fa[p]] = len[p] + 1;
if (sig[p] == 1) {
if (len[fa[p]] > co || ch[p] > lis[len[fa[p]]])
sig[fa[p]] = 2;
else
sig[fa[p]] = (ch[p] == lis[len[fa[p]]]);
} else
sig[fa[p]] = sig[p];
}
int ans = 0;
for (int j = 1; j <= n; j++) {
int p = refer[j];
if (len[p] == -1) {
len[p] = len[fa[p]] + 1;
sig[p] = sig[fa[p]];
if (sig[p] == 1) {
if (len[p] > co || ch[p] > lis[len[p]])
sig[p] = 2;
else
sig[p] = (ch[p] == lis[len[p]]);
}
}
if (!sig[p] || sig[p] == 1 && len[p] < co) ++ans;
}
cout << ans - 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[210000];
int cnt[110];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int sum = 0;
for (int i = 1; i <= n; i++) {
if (i > 1) putchar(' ');
sum += a[i];
int now = sum;
int ans = 0;
for (int j = 100; j >= 1; j--) {
if (now - cnt[j] * j > m) {
now -= cnt[j] * j;
ans += cnt[j];
continue;
}
int l = 0;
int r = cnt[j];
while (l < r) {
int mid = (l + r) / 2;
if (now - mid * j <= m)
r = mid;
else
l = mid + 1;
}
ans += l;
break;
}
printf("%d", ans);
cnt[a[i]]++;
}
puts("");
return 0;
}
| 3 |
#include <iostream>
#include <fstream>
#include <cassert>
#include <typeinfo>
#include <vector>
#include <stack>
#include <cmath>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <iomanip>
#include <cctype>
#include <random>
#include <time.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<P,int> pip;
typedef vector<pip> vip;
const int inf=1<<28;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-8;
const ll mod=1e9+7;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
class Graph{
private:
int V;
vvi List;
vi DIJ(int s){
priority_queue<P> que;
vi d(V,inf);
d[s]=0;
que.push({0,s});
while(!que.empty()){
P p=que.top();
que.pop();
int v=p.second;
if(d[v]<-p.first) continue;
for(int i=0;i<List[v].size();i++){
int F=List[v][i];
if(d[F]>d[v]+1){
d[F]=d[v]+1;
que.push({-d[F],F});
}
}
}
return d;
}
public:
Graph(int v){
V=v;
List=vvi(v);
}
void add_edge(int s,int t){
List[s].push_back(t);
List[t].push_back(s);
}
ll solve(int s,int t){
vi ds=DIJ(s),dt=DIJ(t);
sort(dt.begin(),dt.end());
ll res=0,d=ds[t]-2;
for(int i=0;i<V;i++){
res+=upper_bound(dt.begin(),dt.end(),d-ds[i])-lower_bound(dt.begin(),dt.end(),d-ds[i]);
}
return res;
}
};
int n,m,s,t;
int main(){
cin>>n>>m>>s>>t;
Graph g(n);
for(int i=0;i<m;i++){
int u,v;
cin>>u>>v;
g.add_edge(u-1,v-1);
}
cout<<g.solve(s-1,t-1)<<endl;
} | 0 |
#include <iostream>
using namespace std;
int main() {
long long n, ans=1;
cin>>n;
for(int i=1; i<=n; i++)
{
ans *= i;
ans = ans%1000000007;
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++) L[i] = arr[l + i];
for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int d[1000000];
int main() {
long long int toplam = 0;
long long int x;
scanf("%lld", &x);
long long int j = 0;
while (j < x) {
long long int a;
scanf("%lld", &a);
d[j] = a;
j++;
}
mergeSort(d, 0, x - 1);
long long int i = 0;
long long int f = x;
while (i < x / 2) {
long long int s = d[i] + d[f - 1];
toplam = toplam + (s * s);
i++;
f--;
}
printf("%lld", toplam);
}
| 3 |
#include <bits/stdc++.h>
using std::cerr;
using std::cin;
using std::max;
using std::min;
int n, m, stv, atk, inc, Cn, cnt, tot, so[100005 << 2], Sum[100005 << 2];
long long ans;
std::vector<int> S[100005];
struct info1 {
int Max, h, v;
} A[100005];
struct info2 {
int t, id, v;
friend bool operator<(info2 t1, info2 t2) {
return t1.id < t2.id || t1.id == t2.id && t1.t < t2.t;
}
} B[100005];
struct node {
int l, r;
} C[100005 << 1];
void work(int id, int v, int tl, int tr) {
if (tl > tr || v > atk) return;
if (!A[id].v) return void(C[++Cn] = {tl, tr});
C[++Cn] = {tl, min(tr, tl + (atk - v) / A[id].v)};
}
void Solve(int id) {
if (!S[id].size())
return work(id, A[id].h, 0, 1e9);
else
work(id, A[id].h, 0, B[S[id][0]].t - 1);
int tmp;
for (int i = 0; i < S[id].size() - 1; i++)
tmp = S[id][i], work(id, B[tmp].v, B[tmp].t, B[S[id][i + 1]].t - 1);
tmp = S[id][S[id].size() - 1];
work(id, B[tmp].v, B[tmp].t, 1e9);
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &stv, &inc, &atk);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &A[i].Max, &A[i].h, &A[i].v);
if (inc && (A[i].Max <= atk || (A[i].h <= atk && !A[i].v)))
return puts("-1"), 0;
}
for (int i = 1; i <= m; i++) scanf("%d%d%d", &B[i].t, &B[i].id, &B[i].v);
std::sort(B + 1, B + 1 + m);
for (int i = 1; i <= m; i++) S[B[i].id].push_back(i);
for (int i = 1; i <= n; i++) Solve(i);
for (int i = 1; i <= Cn; i++) so[++cnt] = C[i].l, so[++cnt] = C[i].r;
std::sort(so + 1, so + 1 + cnt);
tot = std::unique(so + 1, so + 1 + cnt) - so - 1;
for (int i = 1; i <= Cn; i++)
C[i].l = std::lower_bound(so + 1, so + 1 + tot, C[i].l) - so,
C[i].r = std::lower_bound(so + 1, so + 1 + tot, C[i].r) - so, Sum[C[i].l]++,
Sum[C[i].r + 1]--;
for (int i = 1; i <= tot; i++)
Sum[i] += Sum[i - 1],
ans = max(ans, (long long)Sum[i] * (stv + (long long)so[i] * inc));
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int s[N];
int main() {
int t;
scanf("%d", &t);
for (int i = 1; i < 300010; i++) {
s[i] = s[i - 1] ^ i;
}
while (t--) {
int a, b;
scanf("%d%d", &a, &b);
int ans = a;
int flag = s[a - 1];
if (flag == b) {
cout << a << "\n";
} else if ((flag ^ b) == a) {
cout << a + 2 << '\n';
} else {
cout << a + 1 << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, n, sum = 0;
cin >> n;
x = n;
for (;;) {
sum = 0;
while (n != 0) {
sum = sum + n % 10;
n = n / 10;
}
if (sum % 4 == 0) {
n = x;
break;
} else {
n = x + 1;
x = n;
continue;
}
}
cout << n << endl;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<string>
#include<utility>
#include<vector>
#include<numeric>
#define debug(x) cerr << #x << ": " << x << endl
using namespace std;
int n;
int solve(vector<string> cities){
int merged[n+1][n+1];
fill_n(merged[0], (n+1)*(n+1), 0);
int length[n+1];
fill_n(length, n+1, 0);
for(int i=0;i<n;i++) length[i] = cities[i].length();
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i == j){
merged[i][i] = cities[i].length();
}else{
bool flag = false;
// iの後ろにjをくっつける
int k_max = 0, k_tmp = 0;
while(k_tmp <= min(length[i], length[j])){
flag = true;
for(int k=0;k<k_tmp;k++){
if(cities[i][length[i]-k_tmp+k] != cities[j][k]){
flag = false;
break;
}
}
if(flag) k_max = k_tmp;
k_tmp++;
}
merged[i][j] = k_max;
}
}
}
int dp[1<<n][n];
fill_n(dp[0], (1<<n)*n, accumulate(length, length+n, 0));
dp[0][n] = 0;
for(int c=0;c<n;c++){
dp[1 << c][c] = length[c];
}
for(int i=1;i<(1 << n);i++){
for(int j=0;j<n;j++){
for(int c=0;c<n;c++){
if(i & (1 << c)) continue;
int nxt = i | (1 << c);
dp[nxt][c] = min(dp[nxt][c], dp[i][j] + length[c] - merged[j][c]);
}
}
}
return *min_element(dp[(1<<n)-1], dp[(1<<n)-1]+n);
}
vector<string> preprocess(vector<string> cities){
int length[n];
for(int i=0;i<n;i++) length[i] = cities[i].length();
// 他の都市の部分文字列都市は削除
vector<string> ret;
bool flag;
int m = 0;
for(int i=0;i<n;i++){
flag = false;
for(int j=0;j<n;j++){
if(i == j) continue;
if(length[i] > length[j]) continue;
for(int k=0;k<length[j]-length[i]+1;k++){
if(cities[j].substr(k, length[i]) == cities[i]){
flag = true;
break;
}
}
if(flag) break;
}
if(!flag){
ret.push_back(cities[i]);
m++;
}
}
n = m;
return ret;
}
int main(void){
while(scanf("%d", &n) && n){
vector<string> cities(n);
for(int i=0;i<n;i++) cin >> cities[i];
cout << solve(preprocess(cities)) << endl;
}
}
| 0 |
#include<cstdio>
#include<iostream>
#include<cstring>
#define RG register
#define LL long long
using namespace std;
const int N=2e5+10;
struct dabt{
int next,to; LL dis;
}e[N];
int n,r,c,head[N],k;
bool vis[N];
LL num[N],minr,minc;
template<typename I> inline void read(I &ot){
I ch=getchar(), x=0, f=1;
while(ch<'0' || ch>'9'){if(ch=='-') f=-1; ch=getchar(); }
while(ch>='0' && ch<='9'){x=x*10+ch-'0'; ch=getchar(); }
ot=x*f;}
template<typename I, typename... U> inline void read(I &x,U&... y){read(x); read(y...);}
template<typename I>inline I mi(const I &a,const I &b){return a<b ? a : b;}
inline void add(int from,int to,LL d){e[++k]=(dabt){head[from],to,d}; head[from]=k;}
bool dfs(int st,LL sum)
{
if(vis[st])
{
return num[st]==sum;
}
if(st<=r) minr=mi(minr,sum);
else minc=mi(minc,sum);
vis[st]=1; num[st]=sum;
for(int i=head[st];i;i=e[i].next)
{
int v=e[i].to;
if(!dfs(v,e[i].dis-sum)) return 0;
}
return 1;
}
int main()
{
// freopen("Grid and Integers.in","r",stdin);
//freopen(".out","w",stdout);
read(r,c,n);
for(int i=1,x,y,z;i<=n;i++)
{
read(x,y,z);
add(x,y+r,z); add(y+r,x,z);
}
for(int i=1;i<=r+c;i++)
{
if(!vis[i])
{
minr=3e18, minc=3e18;
if(!dfs(i,0) || minc+minr<0)
{
printf("No\n");
return 0;
}
}
}
printf("Yes\n");
//fclose(stdin); fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.precision(10);
cout << fixed;
int N, M;
cin >> N >> M;
vector<int> state(N);
for (int i = 0; i < N; ++i) {
cin >> state[i];
}
vector<vector<int> > edges(N), invEdges(N);
for (int i = 0; i < M; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
edges[x].push_back(y);
invEdges[y].push_back(x);
}
vector<int> q, invq;
vector<bool> vis(N, false), invVis(N, false);
for (int i = 0; i < N; ++i) {
if (state[i] == 1) {
q.push_back(i);
vis[i] = true;
}
if (state[i] == 2) {
invq.push_back(i);
invVis[i] = true;
}
}
int cur = 0;
while (cur < q.size()) {
int v = q[cur++];
for (size_t i = 0; i < edges[v].size(); ++i) {
int u = edges[v][i];
if (!vis[u]) {
q.push_back(u);
vis[u] = true;
}
}
}
cur = 0;
while (cur < invq.size()) {
int v = invq[cur++];
if (state[v] == 1) {
continue;
}
for (size_t i = 0; i < invEdges[v].size(); ++i) {
int u = invEdges[v][i];
if (!invVis[u]) {
invq.push_back(u);
invVis[u] = true;
}
}
}
for (int i = 0; i < N; ++i) {
if (vis[i] && invVis[i]) {
cout << "1\n";
} else {
cout << "0\n";
}
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int d, g, s, p[15], c[15], dp[1005];
int main() {
int i, j, k;
cin>>d>>g;
for(i=1; i<=d; i++) cin>>p[i]>>c[i];
for(i=1; i<=d; i++) {
s += p[i];
for(j=s; j>0; j--) for(k=1; k<=p[i] && k<=j; k++) {
dp[j] = max(dp[j], dp[j-k] + k*100*i + (k==p[i])*c[i]);
}
}
for(i=1; dp[i]<g; i++);
cout<<i;
return 0;
} | 0 |
#include"iostream"
using namespace std;
int main()
{
int n;
cin >> n;
cout << (n / 2)*(n - n / 2) << endl;
} | 0 |
//....SARANSH GUPTA....\
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fo(p,n) for(int i=p;i<n;i++)
#define FIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define endl "\n"
#define mp make_pair
#define pb push_back
#define mod 1000000007
const int N=2e5+5;
int n;
int a[N];
signed main()
{
FIO
int t;
t=1;
cin>>t;
while(t--)
{
cin>>n;
n*=2;
fo(0,n)
{
cin>>a[i];
}
sort(a,a+n);
int f=0;
fo(0,n-1)
{
int x=a[n-1]+a[i];
int temp=x;
unordered_map<int,int> m;
for(int j=0;j<n;j++)
{
m[a[j]]++;
}
int j=n-1;
int count=0;
while(1)
{
while(!m[a[j]])
{
j--;
}
m[a[j]]--;
if(m[x-a[j]])
{
m[x-a[j]]--;
x=a[j];
j--;
count+=2;
}
else
{
break;
}
if(count==n)
break;
}
if(count==n)
{
f=1;
cout<<"YES\n";
cout<<temp<<endl;
for(int j=0;j<n;j++)
{
m[a[j]]=0;
}
for(int j=0;j<n;j++)
{
m[a[j]]++;
}
int j=n-1;
x=temp;
int count=0;
while(1)
{
while(!m[a[j]])
{
j--;
}
m[a[j]]--;
if(m[x-a[j]])
{
cout<<a[j]<<" "<<x-a[j]<<endl;
m[x-a[j]]--;
x=a[j];
j--;
count+=2;
}
else
{
break;
}
if(count==n)
break;
}
break;
}
}
if(!f)
cout<<"NO\n";
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 2;
int a[maxi], b[maxi];
int res[maxi];
vector<int> v[maxi];
string s;
int n, m, k;
int ok;
int rem[maxi];
int deg[maxi];
map<pair<int, int>, int> mp;
queue<int> q;
void skloni(int poz) {
while (!q.empty()) {
int x = q.front();
deg[x] = 0;
q.pop();
for (int i : v[x]) {
if (!rem[i] && deg[i] == k && !mp[{x, i}]) {
deg[i]--;
res[poz]--;
q.push(i);
rem[i] = 1;
mp[{x, i}] = 1;
mp[{i, x}] = 1;
} else {
if (!mp[{x, i}]) deg[i]--;
mp[{x, i}] = 1;
mp[{i, x}] = 1;
}
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[i] = x;
b[i] = y;
v[x].push_back(y);
v[y].push_back(x);
deg[x]++;
deg[y]++;
}
res[m] = n;
for (int i = 1; i <= n; i++)
if (deg[i] < k) {
q.push(i);
rem[i] = 1;
res[m]--;
}
skloni(m);
for (int i = m; i >= 1; i--) {
res[i - 1] = res[i];
if (!mp[{a[i], b[i]}]) {
deg[a[i]]--;
deg[b[i]]--;
mp[{a[i], b[i]}] = 1;
mp[{b[i], a[i]}] = 1;
if (deg[a[i]] == k - 1 && !rem[a[i]]) {
rem[a[i]] = 1;
res[i - 1]--;
q.push(a[i]);
};
if (deg[b[i]] == k - 1 && !rem[b[i]]) {
rem[b[i]] = 1;
res[i - 1]--;
q.push(b[i]);
};
skloni(i - 1);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", res[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
long long int x;
cin >> n >> x;
int a, h;
int d = 0, e = 0;
for (int i = 0; i < n; ++i) {
cin >> a >> h;
if (a > d) d = a;
if (a - h > e) e = a - h;
}
int ans = 0;
if (e <= 0 and x > d) {
cout << -1 << endl;
continue;
}
if (x <= d) {
cout << 1 << endl;
continue;
} else {
int z = (x - d) % e == 0 ? (x - d) / e : (x - d) / e + 1;
cout << z + 1 << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int co[200000];
int main() {
cin >> s;
for (int i = 0; i < s.length(); i++) co[s[i]]++;
for (int i = 'a'; i <= 'z'; i++)
if (co[i] % 2 == 1) {
int tmp = 0;
for (int j = 'z'; j >= 'a'; j--)
if (i != j and co[j] % 2 == 1) {
tmp = j;
break;
}
if (!tmp) continue;
if (tmp < i)
co[tmp]++, co[i]--;
else
co[i]++, co[tmp]--;
}
for (int i = 'a'; i <= 'z'; i++)
for (int j = 1; j <= co[i] / 2; j++) {
char tmp = i;
cout << tmp;
}
for (int i = 'a'; i <= 'z'; i++)
if (co[i] % 2 == 1) {
char tmp = i;
cout << tmp;
}
for (int i = 'z'; i >= 'a'; i--)
for (int j = 1; j <= co[i] / 2; j++) {
char tmp = i;
cout << tmp;
}
}
| 3 |
#include<cstdio>
#include<algorithm>
using namespace std;
int n,d[100001];
int shortestDistance(int k,int l,int r)
{
if(l>r) return min(abs(d[l]-k),abs(d[r]-k));
int m=(l+r)/2;
if (d[m]<k) return shortestDistance(k,m+1,r);
else if(d[m]>k) return shortestDistance(k,l,m-1);
else return 0;
}
int main()
{
for(int len,m;scanf("%d%d%d",&len,&n,&m),len;){
d[0]=0;
for(int i=1;i<n;i++) scanf("%d",d+i);
d[n++]=len;
sort(d,d+n);
int sum=0;
while(m--){
int k; scanf("%d",&k);
sum+=shortestDistance(k,0,n);
}
printf("%d\n",sum);
}
return 0;
} | 0 |
#include <iostream>
#include <cmath>
using namespace std;
typedef long long int lli;
const double EPS = 1e-10;
int main(){
int w,h,v,t,sx,sy,gx,gy;
cin>>w>>h>>v>>t>>sx>>sy>>gx>>gy;
lli rad = v*t;
long long int ans=0;
double r2 = rad*rad;
double diff = gx;
for(int x=-gx-2*w*(rad/(2*w)+1); x<=sx+rad; x+=2*diff, diff=w-diff){
if(sx-x>rad) continue;
double d = sqrt(r2 -(double)(sx-x)*(sx-x));
double lub[2]={d-sy, d+sy};
for(int i=0; i<2; i++){
if(lub[i]-gy+EPS > 0){
ans += (lli)( (lub[i]-gy+EPS)/(2*h) +1 );
}
if(lub[i]-(2*h-gy)+EPS > 0){
ans += (lli)( (lub[i]-(2*h-gy)+EPS)/(2*h) +1 );
}
}
if(gy<lub[1] && gy<-lub[0]) ans -= 1;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5 + 5, MOD = 1e9 + 7;
int A[N];
int mult(int a, int b){
ll ret = (a * 1LL * b) % MOD;
return ret;
}
int main(){
int n, cntr = 0, ans = 1;
cin>>n;
A[0] = -1;
for(int i = 1; i <= n; i++) cin>>A[i];
for(int i = 1; i <= n; i++){
A[i] = min(A[i - 1] + 2, A[i]);
if(A[i] - A[i - 1] == 1){
A[i]--;
ans = mult(ans, cntr + 1);
}
else{
cntr++;
}
}
while(cntr){
ans = mult(ans, cntr);
cntr--;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long d[5010][5010];
long long sum[300010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int a[300010];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
a[0] = 0;
sum[0] = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + abs(a[i] - a[i - 1]);
int num1 = n % k;
int num2 = k - n % k;
int numL1 = n / k + 1;
int numL2 = n / k;
for (int i = 0; i <= num1; i++) {
for (int j = 0; j <= num2; j++) {
d[i][j] = 1LL << 60;
int len = numL1 * i + numL2 * j;
int len1 = numL1 * (i - 1) + numL2 * j + 1;
int len2 = numL1 * i + numL2 * (j - 1) + 1;
if (i == 0 && j == 0) d[i][j] = 0;
if (i > 0) d[i][j] = min(d[i][j], d[i - 1][j] + sum[len] - sum[len1]);
if (j > 0) d[i][j] = min(d[i][j], d[i][j - 1] + sum[len] - sum[len2]);
}
}
cout << d[num1][num2] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b;
c=b+(b-a);
cout<<c<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long maxi = LLONG_MIN;
long long mini = LLONG_MAX;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
fast();
long long n, i, y = 1, fy = 0, mxd = 1;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
y = n - 1;
for (int i = 0; i < y; i++) {
mxd = max(mxd, abs(v[i + 1] - v[i]));
if ((v[i + 1] == v[i])) {
cout << "NO";
return 0;
}
}
for (int i = 0; i < y; i++) {
if (!((abs(v[i + 1] - v[i]) == 1) || abs(v[i + 1] - v[i]) == mxd)) {
cout << "NO";
return 0;
}
if (mxd == 1) {
cout << "YES\n" << 1000000000 << " " << mxd;
return 0;
} else {
if (v[i] % mxd == 0 && v[i + 1] == v[i] + 1) {
cout << "NO";
return 0;
}
if (v[i] % mxd == 1 && v[i + 1] == v[i] - 1) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << '\n';
cout << 1000000000 << " " << mxd;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int eu[500005], ev[500005], ew[500005];
int n, q, tot, st[500005], ed[500005];
int val[2][500005], dist[2][500005];
int dep[500005];
vector<pair<int, int> > G[500005];
void add_edge(int u, int v, int w) {
G[u].push_back(pair<int, int>(v, w));
G[v].push_back(pair<int, int>(u, w));
}
void dfs(int v, int p, int d, bool flag = false) {
if (flag) st[v] = ++tot;
dep[v] = d;
for (auto e : G[v]) {
int to = e.first;
if (to == p) continue;
dfs(to, v, d + 1, flag);
}
if (flag) ed[v] = tot;
}
void dfs2(int v, int p, int d, int sgn, int id) {
val[id][st[v]] = sgn;
dist[id][st[v]] = d;
for (auto e : G[v]) {
int to = e.first, x = e.second;
if (to == p) continue;
dfs2(to, v, d + 1, sgn ^ x, id);
}
}
struct segtree {
int lazy[4 * 500005];
int maxi[2][4 * 500005];
void pushup(int k) {
for (int i = 0; i < 2; i++)
maxi[i][k] = max(maxi[i][k * 2], maxi[i][k * 2 + 1]);
}
void flip(int k) {
swap(maxi[0][k], maxi[1][k]);
lazy[k] ^= 1;
}
void pushdown(int k) {
if (!lazy[k]) return;
for (int i = k * 2; i <= k * 2 + 1; i++) flip(i);
lazy[k] = 0;
}
void build(int k, int l, int r, int id) {
lazy[k] = 0;
if (l == r) {
if (val[id][l] == 0) {
maxi[0][k] = dist[id][l];
maxi[1][k] = -1000000000;
} else {
maxi[0][k] = -1000000000;
maxi[1][k] = dist[id][l];
}
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid, id);
build(k * 2 + 1, mid + 1, r, id);
pushup(k);
}
void update(int k, int l, int r, int x, int y) {
if (l > y || x > r) return;
if (l >= x && r <= y) {
flip(k);
return;
}
pushdown(k);
int mid = (l + r) / 2;
update(k * 2, l, mid, x, y);
update(k * 2 + 1, mid + 1, r, x, y);
pushup(k);
}
int query() { return maxi[0][1]; }
} seg[2];
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v, w;
scanf("%d%d%d", &eu[i], &ev[i], &ew[i]);
add_edge(eu[i], ev[i], ew[i]);
}
dfs(1, 0, 0, true);
int maxd = -1000000000, u = -1, v = -1;
for (int i = 1; i <= n; i++) {
if (dep[i] > maxd) {
maxd = dep[i];
u = i;
}
}
dfs(u, 0, 0);
maxd = -1000000000;
for (int i = 1; i <= n; i++) {
if (dep[i] > maxd) {
maxd = dep[i];
v = i;
}
}
dfs(1, 0, 0);
dfs2(u, 0, 0, 0, 0);
dfs2(v, 0, 0, 0, 1);
seg[0].build(1, 1, n, 0);
seg[1].build(1, 1, n, 1);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int id;
scanf("%d", &id);
id--;
int uu = eu[id], vv = ev[id];
if (dep[uu] > dep[vv]) swap(uu, vv);
int l = st[vv], r = ed[vv];
if (st[u] >= l && st[u] <= r) {
seg[0].update(1, 1, n, 1, l - 1);
seg[0].update(1, 1, n, r + 1, n);
} else {
seg[0].update(1, 1, n, l, r);
}
if (st[v] >= l && st[v] <= r) {
seg[1].update(1, 1, n, 1, l - 1);
seg[1].update(1, 1, n, r + 1, n);
} else {
seg[1].update(1, 1, n, l, r);
}
printf("%d\n", max(seg[0].query(), seg[1].query()));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, i, j, c = 0, p, q, f = 0;
scanf("%d", &n);
scanf("%d", &p);
int a[p];
for (i = 0; i < p; i++) scanf("%d", &a[i]);
scanf("%d", &q);
int b[q];
for (i = 0; i < q; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) {
f = 0;
for (j = 0; j < p; j++) {
if (a[j] == i) {
c++;
f++;
}
}
if (f == 0) {
for (j = 0; j < q; j++) {
if (b[j] == i) {
c++;
}
}
}
}
if (n == c)
printf("I become the guy.\n");
else
printf("Oh, my keyboard!\n");
return 0;
}
| 1 |
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef long long int Int;
typedef pair<Int, Int> P;
typedef pair<P, Int> PP;
Int H, W, L;
int my[] = {-1, 0, 1, 0};
int mx[] = {0, 1, 0, -1};
void turn(PP &now, vector< vector<bool> > &v){
Int y = now.first.first, x = now.first.second, d = now.second;
while(!(y + my[d] >= 0 && x + mx[d] >= 0 && y + my[d] < H && x + mx[d] < W && v[y + my[d]][x + mx[d]] == 0)) d = (d + 1) % 4;
now.second = d;
}
PP solve(vector< vector<bool> > &G, PP &now, Int &L){
vector<PP> v;
map<PP, Int> M;
Int cnt = 0;
turn(now, G);
while(L-- > 0){
turn(now, G);
Int &y = now.first.first, &x = now.first.second, &d = now.second;
y = (y + my[d]); x = (x + mx[d]);
if(L <= 0) return now;
else if(M.find(now) != M.end()) break;
v.push_back(now);
M[now] = cnt++;
}
Int t = L % ((int)v.size() - M[now]);
return v[t + M[now]];
}
int main() {
map<char, Int> D;
D['N'] = 0; D['E'] = 1; D['S'] = 2; D['W'] = 3;
string RD = "NESW";
while(cin >>H >>W >>L && (H || W || L)){
vector< vector<bool> > v(H, vector<bool>(W));
PP now;
REP(i, H){
REP(j, W){
char c; cin >>c;
if(c == '.') v[i][j] = 0;
else if(c == '#') v[i][j] = 1;
else{
v[i][j] = 0;
now.first.second = j; now.first.first = i;
now.second = D[c];
}
}
}
PP ans = solve(v, now, L);
cout <<ans.first.first + 1 <<" " <<ans.first.second + 1 <<" " <<RD[ans.second] <<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long total = n * k;
std::vector<long long> v(total);
for (long long i = 0; i < total; i++) {
cin >> v[i];
}
long long med;
if (n % 2 == 0) {
med = n / 2;
} else {
med = n / 2 + 1;
}
sort(v.begin(), v.end());
long long sum = 0;
if (n == 1) {
for (int i = 0; i < total; i++) {
sum += v[i];
}
} else {
for (long long i = total - n + med - 1; i >= ((med - 1) * k) - 1;
i -= (n - med + 1)) {
sum += v[i];
}
}
cout << sum << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
const int maxn = 100005;
const double eps = 1e-8;
int sign(double x) {
if (fabs(x) < eps) {
return 0;
} else {
if (x > 0.00) {
return 1;
} else {
return -1;
}
}
}
double dist(double x1, double y1, double x2, double y2) {
double dx = x2 - x1, dy = y2 - y1;
return sqrt(dx * dx + dy * dy);
}
double dx, dy, ex;
double modulo(double x, double y) { return sqrt(x * x + y * y); }
double get_p() {
double L = 1, R = 1e7;
while (R - L > eps) {
double M = (L + R) / 2.00;
double nx = dx * M, ny = dy * M;
if (sign(modulo(nx, ny) - ex) == 1) {
R = M;
} else {
L = M;
}
}
return L;
}
int main() {
int _R, _x1, _y1, _x2, _y2;
double R, x1, y1, x2, y2;
scanf("%d%d%d%d%d", &_R, &_x1, &_y1, &_x2, &_y2);
R = _R;
x1 = _x1;
x2 = _x2;
y1 = _y1;
y2 = _y2;
double dis = dist(x1, y1, x2, y2);
if (((int(_x1)) == (int(_x2)) && (int(_y1)) == (int(_y2))) ||
sign(dis - R) >= 0) {
if ((int(_x1)) == (int(_x2)) && (int(_y1)) == (int(_y2))) {
printf("%.8lf %.8lf %.8lf", x1, y1 + R / 2.00, R / 2.00);
} else {
printf("%.8lf %.8lf %.8lf", x1, y1, R);
}
} else {
ex = R + dis;
dx = x1 - x2, dy = y1 - y2;
double t = get_p();
double nx = x2 + dx * t / 2.00, ny = y2 + dy * t / 2.00;
double r = modulo(dx * t, dy * t) / 2.00;
printf("%.8lf %.8lf %.8lf\n", nx, ny, r);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 200010;
vector<vector<long long int> > multiply(vector<vector<long long int> > a,
vector<vector<long long int> > b) {
long long int n = a.size();
long long int m = b[0].size();
long long int o = a[0].size();
if (o != b.size()) {
exit(1);
}
vector<vector<long long int> > c(n, vector<long long int>(m, 0));
for (long long int i = 0; i < n; ++i) {
for (long long int j = 0; j < m; ++j) {
c[i][j] = 0;
for (long long int k = 0; k < o; ++k) {
c[i][j] = (c[i][j] + (a[i][k] * b[k][j]) % 1000000007) % 1000000007;
}
}
}
return c;
}
vector<vector<long long int> > power(vector<vector<long long int> > ar,
long long int n) {
if (n == 1) {
return ar;
}
if (n % 2 == 0) {
return power(multiply(ar, ar), n / 2);
} else {
return multiply(ar, power(ar, n - 1));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, b, k, x;
cin >> n >> b >> k >> x;
long long int ch[10] = {0};
for (long long int i = 0; i < n; ++i) {
long long int a;
cin >> a;
ch[a] += 1;
}
vector<vector<long long int> > ar(x, vector<long long int>(x, 0));
for (long long int i = 0; i < x; ++i) {
for (long long int j = 0; j < 10; ++j) {
ar[i][(10 * i + j) % x] += ch[j];
}
}
ar = power(ar, b);
cout << ar[0][k] << endl;
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const int Inf = 2750131;
const int mod = 1000000007;
const double Pi = acos(-1);
void Fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long n, ans = 0;
void Solve() {
cin >> n;
for (long long i = 2; i <= n; i++) {
ans += i * (n / i - 1);
}
cout << 4 * ans;
}
int main() {
Fastio();
Solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long l, r;
long long s = 0;
cin >> l >> r;
int i = 1;
int j = 1;
while (i <= r) {
j = 1;
while (i * j < l) {
j *= 2;
}
while (i * j <= r) {
s++;
j *= 2;
}
i *= 3;
}
cout << s;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <cassert>
using namespace std;
typedef pair<int, vector<string> > P;
int t;
string s;
P f(string s, vector<bool> cut) {
P ret;
string a;
a += s[0];
for(int i = 0; i < cut.size(); i++) {
if(cut[i]) {
ret.second.push_back(a);
a = s[i + 1];
}
else {
a += s[i + 1];
}
}
ret.second.push_back(a);
for(int i = 0; i < ret.second.size(); i++) {
a = ret.second[i];
while(a.size() > 1 && a.front() == '0') a = a.substr(1, a.size() - 1);
ret.first += atoi(a.c_str());
}
return ret;
}
vector<vector<string> > ans[1000000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(cin >> t >> s, t && s != "0") {
for(int i = 0; i < 1000000; i++) {
ans[i].clear();
}
int n = s.size();
int m = -1;
for(int bit = 0; bit < 1 << (n - 1); bit++) {
vector<bool> cut(n - 1);
for(int i = 0; i < n - 1; i++) {
if(bit >> i & 1) cut[i] = true;
}
P p = f(s, cut);
if(p.first > t) continue;
m = max(m, p.first);
ans[p.first].push_back(p.second);
}
if(m == -1) {
cout << "error" << endl;
}
else if(ans[m].size() >= 2) {
cout << "rejected" << endl;
}
else {
cout << m;
for(string v : ans[m][0]) {
cout << " " << v;
}
cout << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
double a, v, l, d, w;
double t1, t2, t3, s1, s2, s3, ans, rv;
int main() {
scanf("%lf %lf %lf %lf %lf", &a, &v, &l, &d, &w);
t1 = w / a, t2 = v / a, t3 = (v - w) / a;
s1 = t1 * w / 2, s2 = t2 * v / 2, s3 = (v + w) * t3 / 2;
if (v <= w || s1 >= d) {
if (s2 > l)
ans = sqrt(l * 2 / a);
else {
ans += t2;
ans += (l - s2) / v;
}
printf("%.8lf\n", ans);
return 0;
}
if (s2 + s3 <= d) {
ans += (t2 + t3);
ans += (d - s2 - s3) / v;
} else {
rv = sqrt((d - s1) * a + w * w);
ans += (rv / a + (rv - w) / a);
}
if (s3 <= l - d) {
ans += t3;
ans += (l - d - s3) / v;
} else
ans += (sqrt(w * w - 2 * a * (d - l)) - w) / a;
printf("%.8lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long> > g;
vector<long> v, ans;
set<long> used, q;
void bfs() {
long vrt;
while (q.size() == 1) {
vrt = *q.begin();
q.erase(q.begin());
ans.push_back(vrt);
used.insert(vrt);
for (long i = 0; i < g[vrt].size(); ++i) {
--v[g[vrt][i]];
if (v[g[vrt][i]] == 0) q.insert(g[vrt][i]);
}
}
}
int main() {
long n, m;
scanf("%ld %ld", &n, &m);
g.resize(n + 1);
v.resize(n + 1, 0);
for (long i = 1; i <= n; ++i) q.insert(i);
long a, b, isAns = -1;
for (long i = 0; i < m; ++i) {
scanf("%ld %ld", &a, &b);
if (v[b] == 0) {
if (used.find(a) == used.end()) {
q.erase(b);
g[a].push_back(b);
++v[b];
}
if (q.size() == 1) bfs();
} else if (used.find(a) == used.end()) {
g[a].push_back(b);
++v[b];
}
if (ans.size() == n) {
isAns = i + 1;
break;
}
}
printf("%ld\n", isAns);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 998244353;
long long int power(long long int a, long long int b) {
long long int ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
if (ret >= MOD) ret %= MOD;
if (a >= MOD) a %= MOD;
b >>= 1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
map<long long int, long long int> mt, m, k;
long long int n, i, x = 1, c = 1;
cin >> n;
long long int a[n];
for (i = 0; i < n; ++i) {
cin >> a[i];
}
for (i = n - 1; i >= 0; --i) {
++m[a[i]];
if (m[a[i]] == 1) mt[a[i]] = i;
}
c = mt[a[0]];
for (i = 0; i < n; ++i) {
if (i > c) {
++x;
}
++k[a[i]];
if (k[a[i]] == 1) c = max(c, mt[a[i]]);
}
c = power(2, x - 1);
cout << c;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void ckmin(T &a, const T &b) {
a = min(a, b);
}
template <typename T>
void ckmax(T &a, const T &b) {
a = max(a, b);
}
template <typename... Args>
void logger(string vars, Args &&...values) {
cout << vars << " = ";
string delim = "";
(..., (cout << delim << values, delim = ", "));
cout << "\n";
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
long long gcd(unsigned long long a, unsigned long long b) {
return b == 0 ? a : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long int power(long long int x, long long int y,
long long int m = 1000000007) {
long long int ans = 1;
x %= m;
while (y) {
if (y & 1) ans = (x * ans) % m;
x = (x * x) % m;
y >>= 1;
}
return ans;
}
long long int power_nm(long long int x, long long int y) {
long long int ans = 1;
while (y) {
if (y & 1) ans = (x * ans);
x = (x * x);
y >>= 1;
}
return ans;
}
long long int ncr(vector<long long int> &fact, int n, int r) {
return (n >= r) ? ((fact[n] * ((power(fact[r], 1000000007 - 2) *
power(fact[n - r], 1000000007 - 2)) %
1000000007)) %
1000000007)
: 0;
}
int mul(int x, int y) { return (x * 1ll * y) % 1000000007; }
int divide(int x, int y) { return mul(x, power(y, 1000000007 - 2)); }
int add(int x, int y) {
x += y;
while (x >= 1000000007) x -= 1000000007;
while (x < 0) x += 1000000007;
return x;
}
int sub(int x, int y) { return (x - y + 1000000007) % 1000000007; }
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = (0); i < (n); i++) cin >> arr[i];
bool isinc = true;
for (int i = (1); i < (n); i++) {
if (arr[i] <= arr[i - 1]) {
isinc = false;
break;
}
}
if ((n & 1) == 1 && isinc)
cout << "NO\n";
else {
cout << "YES\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int z = 1;
cin >> z;
while (z--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 210, MaxM = 2010, inf = 1e9;
int N, M;
int S, T;
int Node[MaxN], Ecnt = 1;
struct Edges {
int t, next, f;
} e[MaxM * 2];
void Add(int u, int v, int c) {
e[++Ecnt] = (Edges){v, Node[u], c}, Node[u] = Ecnt;
e[++Ecnt] = (Edges){u, Node[v], 0}, Node[v] = Ecnt;
}
int q[MaxN], head, tail;
int Dis[MaxN];
bool Bfs() {
for (register int i = 1; i <= N; i++) Dis[i] = N;
q[head = tail = 1] = T;
Dis[T] = 0;
while (head <= tail) {
int x = q[head++];
for (int i = Node[x]; i; i = e[i].next) {
int t = e[i].t;
if (Dis[t] > Dis[x] + 1 && e[i ^ 1].f) {
Dis[t] = Dis[x] + 1;
q[++tail] = t;
}
}
}
return Dis[S] < N;
}
int nlast[MaxN];
int Dinic(int x, int f) {
if (x == T) return f;
int now = f;
for (int &i = nlast[x]; i; i = e[i].next) {
int t = e[i].t;
if (Dis[x] == Dis[t] + 1 && e[i].f) {
int aa = Dinic(t, e[i].f < now ? e[i].f : now);
e[i].f -= aa;
e[i ^ 1].f += aa;
now -= aa;
if (!now) return f;
}
}
return f - now;
}
int MaxFlow() {
int Ans = 0;
while (Bfs()) {
for (register int i = 1; i <= N; i++) nlast[i] = Node[i];
Ans += Dinic(S, inf);
}
return Ans;
}
bool Vis[MaxN];
void Dfs(int x) {
Vis[x] = 1;
for (int i = Node[x]; i; i = e[i].next)
if (e[i].f && !Vis[e[i].t]) Dfs(e[i].t);
}
int Node2[MaxN], Ecnt2 = 1;
struct Edges2 {
int t, next, c;
} e2[MaxN * 2];
void Add2(int u, int v, int c) {
e2[++Ecnt2] = (Edges2){v, Node2[u], c}, Node2[u] = Ecnt2;
e2[++Ecnt2] = (Edges2){u, Node2[v], c}, Node2[v] = Ecnt2;
}
int que[MaxN], Ans;
bool VisE[MaxN * 2];
void Solve(int l, int r) {
if (l == r) return;
S = que[l], T = que[r];
for (int i = 2; i <= Ecnt; i += 2) e[i].f += e[i ^ 1].f, e[i ^ 1].f = 0;
int Tmp = MaxFlow();
Add2(que[l], que[r], Tmp);
Ans += Tmp;
for (register int i = 1; i <= N; i++) Vis[i] = 0;
Dfs(S);
int mid = l - 1;
for (register int i = l; i <= r; i++)
if (Vis[que[i]]) {
int o = que[i];
que[i] = que[++mid];
que[mid] = o;
}
Solve(l, mid);
Solve(mid + 1, r);
}
int mn;
void GetMin(int x, int fa) {
for (int i = Node2[x]; i; i = e2[i].next) {
if (e2[i].t == fa || VisE[i]) continue;
if (e2[i].c < e2[mn].c) mn = i;
GetMin(e2[i].t, x);
}
}
int GetAns(int x) {
e2[mn = 0].c = inf;
GetMin(x, 0);
if (!mn) return x;
int Now = mn;
VisE[Now] = VisE[Now ^ 1] = 1;
printf("%d ", GetAns(e2[Now].t));
return GetAns(e2[Now ^ 1].t);
}
int main() {
scanf("%d %d", &N, &M);
for (register int i = 1; i <= M; i++) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
Add(u, v, c);
Add(v, u, c);
}
for (register int i = 1; i <= N; i++) que[i] = i;
Solve(1, N);
printf("%d\n", Ans);
printf("%d\n", GetAns(1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[300003];
int pref[300003][3], pE;
int query(int kir, int kan, int tipe) {
if (kan < kir)
return 0;
else
return (kir != 0) ? pref[kan][tipe] - pref[kir - 1][tipe] : pref[kan][tipe];
}
int main() {
scanf("%d", &n);
pref[0][0] = 1;
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
while (x) {
arr[i] += (x & 1LL);
x /= 2;
}
pref[i][2] = arr[i] + pref[i - 1][2];
pref[i][1] = (pref[i][2] & 1) + pref[i - 1][1];
pref[i][0] = (1 - pref[i][2] & 1) + pref[i - 1][0];
}
long long res = 0;
for (int i = 2; i <= n; i++) res += 1LL * query(0, i - 2, pref[i][2] & 1);
for (int len = 2; len <= 65; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int mx = 0;
int sum = 0;
for (int j = i; j <= i + len - 1; j++) {
mx = max(arr[j], mx);
sum += arr[j];
}
if (mx * 2 > sum && (1 - sum & 1)) res--;
}
}
printf("%lld\n", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f;
using namespace std;
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long Pow(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P & 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
long long GCD(long long a, long long b) {
while (b) {
b ^= a ^= b ^= a %= b;
}
return a;
}
long long LCM(long long a, long long b) { return (a / GCD(a, b) * b); }
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P & 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (long long)R;
}
bool stable[500005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> nms(n);
for (long long i = 0; i < n; ++i) cin >> nms[i];
int ans = 0;
stable[0] = 1;
stable[n - 1] = 1;
for (long long i = 1; i < n; ++i)
if (nms[i] == nms[i - 1]) stable[i] = stable[i - 1] = 1;
int l = 1, r = 1;
while (l < n) {
if (stable[l]) {
++l;
r = l;
} else {
r = l;
while (!stable[r + 1]) ++r;
ans = max(ans, (r - l + 2) / 2);
if (nms[l - 1] == nms[r + 1]) {
for (long long i = l; i < r + 1; ++i) nms[i] = nms[l - 1];
} else {
for (long long i = l; i < (r + l) / 2 + 1; ++i) nms[i] = nms[l - 1];
for (long long i = (r + l) / 2 + 1; i < r + 1; ++i) nms[i] = nms[r + 1];
}
l = r + 1;
}
}
cout << ans << "\n";
for (long long i = 0; i < n; ++i) cout << nms[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int clients, maxByte;
cin >> clients >> maxByte;
int lowByte, highByte;
cin >> lowByte >> highByte;
vector<pair<int, int> > clientByte;
for (int i = 0; i < clients; i++) {
int lowPic, highPic;
cin >> lowPic >> highPic;
int byteUsage = lowPic * lowByte + highPic * highByte;
int index = i + 1;
clientByte.push_back(make_pair(byteUsage, index));
}
sort(clientByte.begin(), clientByte.end());
long long int currentByte = 0;
vector<int> choosen;
int index = 0;
while (currentByte < maxByte) {
currentByte += clientByte.at(index).first;
if (currentByte > maxByte) break;
choosen.push_back(clientByte.at(index).second);
index++;
if (index == clients) break;
}
cout << choosen.size() << endl;
for (int i = 0; i < choosen.size(); i++) cout << choosen.at(i) << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str[1000010];
int main(int argc, const char* argv[]) {
scanf("%s", str);
int i = 0;
for (; str[i]; i++)
if (str[i] == 'r') printf("%d\n", i + 1);
i--;
for (; i >= 0; i--)
if (str[i] == 'l') printf("%d\n", i + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long INFLL = 1001001001001001001LL;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
double fin() {
double x;
scanf("%lf", &x);
return x;
}
long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const long long MO = 1000000007;
vector<long long> prs;
int pr[1 << 20];
void er() {
for (int i = 2; i < (1 << 20); ++i) {
pr[i] = 1;
}
for (int i = 2; i < (1 << 20); ++i) {
if (pr[i]) {
for (int j = i + i; j < (1 << 20); j += i) {
pr[j] = 0;
}
}
}
for (int i = 2; i < (1 << 20); ++i) {
if (pr[i]) {
prs.push_back(i);
}
}
}
long long totient(long long n) {
long long v = n;
for (int i = 0; prs[i] * prs[i] <= n; ++i) {
if (n % prs[i] == 0) {
v -= v / prs[i];
while (n % prs[i] == 0) {
n /= prs[i];
}
}
}
if (n > 1) {
v -= v / n;
}
return v;
}
int main() {
er();
long long n = lin();
long long k = lin();
for (long long i = 0; i < (k + 1) / 2; ++i) {
n = totient(n);
if (n == 1) {
break;
}
}
printf("%lld\n", n % MO);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
int SolveCase() {
int n;
cin >> n;
vector<int> xs(n);
int equal_count = 0;
for (int i = 0; i < n; i++) {
cin >> xs[i];
xs[i]--;
if (i == xs[i]) equal_count++;
}
if (equal_count == n) {
return 0;
} else if (equal_count == 0) {
return 1;
}
int remove_equal_count = 0;
for (int i = 0; i < n; i++) {
if (i == xs[i])
remove_equal_count++;
else
break;
}
for (int i = n - 1; i >= 0; i--) {
if (i == xs[i])
remove_equal_count++;
else
break;
}
if (equal_count == remove_equal_count) {
return 1;
}
return 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int num_cases;
cin >> num_cases;
for (int case_id = 0; case_id < num_cases; case_id++) {
cout << SolveCase() << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void init() {}
const int N = 1e6 + 34;
bool u, d, l, r;
int ans = 1;
int main() {
init();
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if ((s[i] == 'R' && l) || (s[i] == 'L' && r) || (s[i] == 'D' && u) ||
(s[i] == 'U' && d)) {
ans++;
l = r = u = d = false;
}
if (s[i] == 'R') r = true;
if (s[i] == 'L') l = true;
if (s[i] == 'U') u = true;
if (s[i] == 'D') d = true;
}
cout << ans;
return 0;
}
| 3 |
// g++ -std=c++11 a.cpp
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<unordered_map>
#include<utility>
#include<cmath>
#include<random>
#include<cstring>
#include<queue>
#include<stack>
#include<bitset>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#include<typeinfo>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define FOR(i,a) for(auto i:a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define show1d(v) rep(i,v.size())cout<<" "<<v[i];cout<<endl<<endl;
#define show2d(v) rep(i,v.size()){rep(j,v[i].size())cout<<" "<<v[i][j];cout<<endl;}cout<<endl;
using namespace std;
//kaewasuretyuui
typedef long long ll;
//#define int ll
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
#define mt make_tuple
typedef tuple<int,int,int> tp;
typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
const double PI=acos(-1);
const double EPS=1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9+10;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int main(){
int n,m;
cin>>n>>m;
vvi in(n,vi(3));
rep(i,n)rep(j,3)cin>>in[i][j];
vd data(m+2);
data[1]=1;
rep(i,m)for(int j=m;j>=0;j--){
data[j+1]+=data[j]/3;
data[j]*=2./3;
}
rep(i,m+1)data[i+1]+=data[i];
vvd dp(3,vd(m+1));
int w[]={5,3,2};
rep(i,3)rep(j,m+1){
int t=in[0][i]*j;
vd d={1,0,0,0};
double q=1;
loop(k,1,n){
vd nd(4);
int co=(t+in[k][i]-1)/in[k][i];
double a=data[min(m+1,co)];//t以下になる確率
rep(l,3){
nd[l]+=d[l]*a;
nd[l+1]+=d[l]*(1-a);
}
q*=1-a;
d=nd;
}
dp[i][j]=w[i]*(d[0]+d[1]+d[2])-q;
}
double out=-3;
rep(i,m+1)rep(j,m+1)if(i+j<=m){
out=max(out,dp[0][i]+dp[1][j]+dp[2][m-i-j]);
}
cout<<shosu(9)<<out<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> a[900000];
long long int s4(long long int x) {
long long int lo = 1, hi = 1000;
while (lo < hi) {
long long int mi = (lo + hi) / 2;
if (mi * mi * mi * mi >= x)
hi = mi;
else
lo = mi + 1;
}
return lo;
}
long long int s2(long long int x) {
long long int lo = 1, hi = 1000000;
while (lo < hi) {
long long int mi = (lo + hi + 1) / 2;
if (mi * mi <= x)
lo = mi;
else
hi = mi - 1;
}
return lo;
}
int calc(long long int x) {
long long int u = s4(x), v = min(s2(x), x - 1);
if (u > v) return 0;
for (int w = 0;; w++) {
vector<long long int>::iterator it =
lower_bound(a[w].begin(), a[w].end(), u);
if (it == a[w].end() || *it > v) return w;
}
}
int main() {
int n;
for (long long int i = 1; i < 900001; i++) {
int x = calc(i);
a[x].push_back(i);
}
scanf("%d", &n);
int res = 0;
for (int i = 0; i < n; i++) {
long long int x;
scanf("%I64d", &x);
res ^= calc(x);
}
puts(res ? "Furlo" : "Rublo");
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define rep(i, n) for(ll i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using Graph =vector<int>;
typedef pair<ll,int> P;
const ll MAX_N=131072;
int bit[MAX_N*2-1];
ll n;
void add(ll a,ll w){
ll x=a;
while(x<=n){
bit[x]+=w;
x+=x&(-x);
}
}
ll sum(int a){
ll ret=0;
while(a>0){
ret+=bit[a];
a-=a&(-a);
}
return ret;
}
int main(){
cin>>n;
ll a[n];
rep(i,n) cin >>a[i];
ll b[n];
rep(i,n) b[i]=a[i];
sort(b,b+n);
map<ll,int> m;
rep(i,n) m[b[i]]=i+1;
ll ans=0;
rep(i,n){
ans+=i-sum(m[a[i]]);
add(m[a[i]],1);
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = int(2e5) + 256;
string s, t;
multiset<char> M;
int ura, opa;
bool u[MaxN];
int main() {
cin >> s >> t;
for (int i = 0; i < t.size(); ++i) M.insert(t[i]);
for (int i = 0; i < s.size(); ++i) {
if (M.find(s[i]) != M.end()) {
M.erase(M.find(s[i]));
ura++;
u[i] = 1;
}
}
for (int i = 0; i < s.size(); ++i) {
if (M.find(toupper(s[i])) != M.end() && !u[i]) {
M.erase(M.find(toupper(s[i])));
u[i] = 1;
opa++;
continue;
}
if (M.find(tolower(s[i])) != M.end() && !u[i]) {
M.erase(M.find(tolower(s[i])));
u[i] = 1;
opa++;
}
}
cout << ura << " " << opa;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define FOR for(int k = 0; k < si2; k++)
#define M(a) ('0'<=a&&a<='9')?(a-'0'+1)%10+'0':a
#define P(a) ('0'<=a&&a<='9')?(a-'0'-1+10)%10+'0':a
int main(){
int n, si, si2;
string str, str2, temp;
cin>>n;
for(int i = 0; i < n; i++){
cin>>str>>str2;
si = str.size(); si2 = str2.size();
for(int j = si-1; j >= 0; j--, str2 = temp){
temp.clear();
switch(str[j]){
case 'C':FOR temp += str2[(k+1)%si2]; break;
case 'J':FOR temp += str2[(k-1+si2)%si2]; break;
case 'E':if(si2%2){str2+=str2[si2/2];
FOR temp += str2[(k+(si2+1)/2)%(si2+1)];}
else FOR temp += str2[(k+si2/2)%si2]; break;
case 'A':FOR temp += str2[si2-k-1];break;
case 'M':FOR temp += M(str2[k]); break;
case 'P':FOR temp += P(str2[k]); break;
}
}
cout<<str2<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ar[105], s[105], a, b;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
s[0] = 0;
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + ar[i];
scanf("%d%d", &a, &b);
printf("%d\n",
min(abs(s[b - 1] - s[a - 1]), s[n] - abs(s[b - 1] - s[a - 1])));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q, n, l, r;
cin >> q;
pair<int, int> p[200005];
while (q--) {
cin >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
cin >> l >> r;
p[i] = make_pair(l, r);
v.push_back(make_pair(l, 1));
v.push_back(make_pair(r + 1, -1));
}
sort(v.begin(), v.end());
int sum = 0, cut = -1;
for (int i = 0; i < v.size(); i++) {
sum += v[i].second;
if (sum == 0) {
cut = v[i].first;
break;
}
}
if (cut == v.back().first) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
if (p[i].second < cut)
cout << "1 ";
else
cout << "2 ";
}
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, mod = 1e9 + 7;
const long long inf = 1e18 + 1;
bool inp[600][600];
set<int> x[600];
set<int> y[600];
vector<char> ans;
int n;
bool check[600][600];
void dfs(int i, int j) {
check[i][j] = 1;
if (!inp[i][j]) {
ans.push_back('1');
x[i].insert(j);
y[j].insert(i);
inp[i][j] = 1;
}
if (i != 1) {
if (!check[i - 1][j] && *y[j].lower_bound(0) < i &&
y[j].lower_bound(0) != y[j].end()) {
ans.push_back('U');
dfs(i - 1, j);
ans.push_back('D');
}
}
if (i != n) {
if (!check[i + 1][j] && *y[j].lower_bound(i + 1) > i &&
y[j].lower_bound(i + 1) != y[j].end()) {
ans.push_back('D');
dfs(i + 1, j);
ans.push_back('U');
}
}
if (j != 1) {
if (!check[i][j - 1] && *x[i].lower_bound(0) < j &&
x[i].lower_bound(0) != x[i].end()) {
ans.push_back('L');
dfs(i, j - 1);
ans.push_back('R');
}
}
if (j != n) {
if (!check[i][j + 1] && x[i].lower_bound(j + 1) != x[i].end() &&
*x[i].lower_bound(j + 1) > j) {
ans.push_back('R');
dfs(i, j + 1);
ans.push_back('L');
}
}
x[i].erase(j);
y[j].erase(i);
inp[i][j] = 0;
ans.push_back('2');
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
int x1, y1;
cin >> y1 >> x1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> inp[i][j];
if (inp[i][j]) {
x[i].insert(j);
y[j].insert(i);
}
}
}
dfs(y1, x1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (!check[i][j] && inp[i][j]) {
cout << "NO";
return 0;
}
}
}
cout << "YES"
<< "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
std::mt19937_64 rng(
std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
long long mex[10005];
vector<long long> v;
long long y;
long long n;
long long get_mex() {
y++;
for (long long i = 0; i < v.size(); i++) mex[v[i]] = y;
for (long long i = 0; i <= n; i++)
if (mex[i] != y) return i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
y = 0;
cin >> t;
while (t--) {
cin >> n;
v.clear();
long long x;
long long bb[n + 5][n + 5];
memset(bb, 0, sizeof(bb));
for (long long i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
bb[x][i] = 1;
}
vector<long long> temp;
vector<long long> ans;
long long w;
for (long long i = 0; i < n; i++) {
while (v[i] != i) {
x = get_mex();
if (x == n) {
v[i] = n;
ans.push_back(i);
} else {
v[x] = x;
ans.push_back(x);
}
if (x == i) break;
}
}
cout << ans.size() << '\n';
for (long long i = 0; i < ans.size(); i++) cout << ans[i] + 1 << " ";
cout << '\n';
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int n,ans=0,maxn=0;
string s;
int main() {
cin>>n>>s;
for(int i=0;i<n;i++) {
if(s[i]=='I') ans++;
if(s[i]=='D') ans--;
if(maxn<ans) maxn=ans;
}
cout<<maxn<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n % 10 == 0)
printf("%d", n);
else if ((n % 10) >= 5) {
printf("%d", n + (10 - (n % 10)));
} else
printf("%d", n - (n % 10));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, a[100001];
int h, pc, q, juc[100001];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
h = 1;
while (pc < m) {
pc++;
if (pc == a[h])
h++;
else {
m -= pc;
juc[++q] = pc;
}
}
cout << q << '\n';
for (i = 1; i <= q; i++) cout << juc[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, ai[101], bi[101], c[6], aes;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i += 1) cin >> ai[i], c[ai[i]]++;
for (int i = 1; i <= n; i += 1) cin >> bi[i], c[bi[i]]++;
for (int i = 1; i <= 5; i += 1) {
if (c[i] % 2 != 0) {
cout << -1;
return 0;
}
int c0 = 0;
for (int j = 1; j <= n; j += 1)
if (ai[j] == i) c0++;
if (c0 > c[i] / 2) aes += c0 - c[i] / 2;
}
cout << aes;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15 + 7;
long long res = 0;
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
struct seg {
long long ax, ay, cx, cy, k;
seg() {}
};
set<pair<long long, long long> > used;
bool check(seg a, seg b) {
bool rev = false;
if (a.cx == 0) {
swap(a.cx, a.cy);
swap(a.ax, a.ay);
swap(b.cx, b.cy);
swap(b.ax, b.ay);
rev = true;
}
long long num1 = (a.ay - b.ay) * a.cx + a.cy * (b.ax - a.ax);
long long num2 = b.cy * a.cx - b.cx * a.cy;
if (num2 == 0 || num1 % num2 != 0) return false;
long long k2 = num1 / num2;
long long num3 = (b.ax + k2 * b.cx - a.ax);
if (num3 % a.cx != 0) return false;
long long k1 = num3 / a.cx;
if (k1 * a.k < 0 || k2 * b.k < 0) return false;
if (abs(k1) > abs(a.k) || abs(k2) > abs(b.k)) return false;
long long x = k1 * a.cx + a.ax, y = k1 * a.cy + a.ay;
if (rev) swap(x, y);
if (used.count(make_pair(x, y))) {
return false;
}
used.emplace(x, y);
return true;
}
void solve() {
long long n;
cin >> n;
vector<seg> a(n);
long long res = 0;
for (long long i = 0; i < n; i++) {
long long ax, ay, bx, by;
cin >> ax >> ay >> bx >> by;
a[i].k = abs(gcd(bx - ax, by - ay));
a[i].ax = ax, a[i].ay = ay;
a[i].cx = (bx - ax) / a[i].k, a[i].cy = (by - ay) / a[i].k;
res += a[i].k + 1;
for (long long j = 0; j < i; j++) {
if (check(a[i], a[j])) res--;
}
used.clear();
}
cout << res;
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fact(long long s, long long n) {
long long res = 1;
for (int i = 0; i < n; i++) res = res * (s - i + 1000000009) % 1000000009;
return res;
}
long long bin[100009];
int main() {
int n, m, i;
bin[0] = 1;
for (i = 1; i <= 100000; i++) bin[i] = 2 * bin[i - 1] % 1000000009;
scanf("%d%d", &n, &m);
long long k = bin[m] - 1;
cout << fact(k, n);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int n;
cin >> n;
if (n == 1)
cout << "1";
else if (n == 2)
cout << "2";
else if (n & 1)
cout << n * (n - 1) * (n - 2);
else {
if (n % 3 == 0)
cout << (n - 1) * (n - 2) * (n - 3);
else
cout << n * (n - 1) * (n - 3);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long hg[1000010], sg[1000010], h[1010], s[1010];
priority_queue<long long> qq;
int main() {
int m, n, k, p;
cin >> n >> m >> k >> p;
int i, j;
memset(h, 0, sizeof(h));
memset(s, 0, sizeof(s));
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
int x;
scanf("%d", &x);
h[i] += x;
s[j] += x;
}
for (i = 0; i < n; ++i) qq.push(h[i]);
long long sum = 0;
for (i = 0; i < k; ++i) {
long long x = qq.top();
qq.pop();
sum += x;
qq.push(x - m * p);
hg[i + 1] = sum;
}
sum = 0;
while (!qq.empty()) qq.pop();
for (i = 0; i < m; ++i) qq.push(s[i]);
hg[0] = sg[0] = 0;
for (i = 0; i < k; ++i) {
long long x = qq.top();
qq.pop();
sum += x;
qq.push(x - n * p);
sg[i + 1] = sum;
}
sum = -100000000000000000;
for (i = 0; i <= k; ++i) {
if (sum < hg[i] + sg[k - i] - (long long)i * (k - i) * p)
sum = hg[i] + sg[k - i] - (long long)i * (k - i) * p;
}
printf("%I64d\n", sum);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.