solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9) + 7;
int n, k, d;
int dp[102][2];
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
cin >> n >> k >> d;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j < 0) break;
if (j < d) {
add(dp[i][0], dp[i - j][0]);
add(dp[i][1], dp[i - j][1]);
} else {
add(dp[i][1], dp[i - j][1]);
add(dp[i][1], dp[i - j][0]);
}
}
}
cout << dp[n][1];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, j, a, b;
cin >> n;
j = 1;
while (j <= n) {
cin >> a >> b;
cout << b + (9 * (a - 1)) << endl;
j++;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
char s[maxn];
int vis[maxn];
queue<int> q;
int main() {
int n, k;
scanf("%d%d%s", &n, &k, s);
memset(vis, -1, sizeof(vis));
for (int i = 0; i < n; i++) {
if (s[i] != s[(i - 1 + n) % n] && s[i] != s[(i + 1) % n])
;
else
q.push(i), vis[i] = 0;
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (vis[(u - 1 + n) % n] == -1) {
vis[(u - 1 + n) % n] = vis[u] + 1;
q.push((u - 1 + n) % n);
}
if (vis[(u + 1) % n] == -1) {
vis[(u + 1) % n] = vis[u] + 1;
q.push((u + 1) % n);
}
}
for (int i = 0; i < n; i++) {
if (vis[i] == -1 || vis[i] > k) {
if (k % 2 == 1)
printf("%c", s[i] == 'B' ? 'W' : 'B');
else
printf("%c", s[i]);
} else {
if (vis[i] % 2 == 1)
printf("%c", s[i] == 'B' ? 'W' : 'B');
else
printf("%c", s[i]);
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, d, mod, ans, tr[15];
int f[1005], inv[15];
int g[15][1005];
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1) return puts("1"), 0;
for (int i = (int)(0); i <= (int)(d); i++) g[i][i] = 1;
f[1] = inv[0] = inv[1] = 1;
for (int i = (int)(2); i <= (int)(d); i++)
inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
for (int i = (int)(2); i <= (int)(n / 2); i++) {
f[i] = g[d - 1][i - 1];
tr[0] = 1;
for (int j = (int)(1); j <= (int)(d); j++)
tr[j] = 1ll * tr[j - 1] * inv[j] % mod * (f[i] + j - 1) % mod;
for (int j = (int)(d); j >= (int)(0); j--)
for (int k = (int)(1); k <= (int)(d - j); k++)
for (int l = (int)(0); l <= (int)(n - k * i); l++)
g[j + k][l + k * i] =
(g[j + k][l + k * i] + 1ll * g[j][l] * tr[k]) % mod;
if (i == (n - 1) / 2) ans = g[d][n - 1];
}
if (n % 2 == 0) ans = (ans + 1ll * f[n / 2] * (f[n / 2] + 1) / 2) % mod;
printf("%d\n", ans);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
void run() {
int n;
cin >> n;
string s;
cin >> s;
int a(0), d(0), x((n + 1) / 2);
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A')
a++;
else
d++;
if (a > x || d > x) {
if (a > d)
cout << "Anton" << endl;
else
cout << "Danik" << endl;
return;
}
}
if (a > d)
cout << "Anton" << endl;
else if (d > a)
cout << "Danik" << endl;
else
cout << "Friendship" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
run();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool d = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') d = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return d ? x : -x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void writep(long long x) {
write(x);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 1e5 + 5, M = 2e5 + 5, mo = 1e9 + 7;
int p[M], opt, mn[M];
bool used[M];
vector<long long> v;
void init(int n) {
for (int i = (int)(2); i <= (int)(n); i++) {
if (!used[i]) p[++opt] = mn[i] = i;
for (int j = 1; j <= opt && p[j] * i <= n; j++) {
used[i * p[j]] = 1;
mn[i * p[j]] = p[j];
if (i % p[j] == 0) break;
}
}
for (int i = (int)(2); i <= (int)(n); i++)
if (!used[i] && i <= 447) v.push_back(i);
}
struct tree {
int mx[N << 2], a[N];
void buildtree(int k, int l, int r) {
if (l == r) {
mx[k] = a[l];
return;
}
int mid = l + r >> 1;
buildtree(k << 1, l, mid);
buildtree(k << 1 | 1, mid + 1, r);
mx[k] = max(mx[k << 1], mx[k << 1 | 1]);
}
int find(int k, int l, int r, int L, int R) {
if (l >= L && r <= R) return mx[k];
int mid = l + r >> 1;
if (R <= mid) return find(k << 1, l, mid, L, R);
if (L > mid) return find(k << 1 | 1, mid + 1, r, L, R);
return max(find(k << 1, l, mid, L, R), find(k << 1 | 1, mid + 1, r, L, R));
}
} T[86];
int b[N], pos[M], fac[N], inv[N];
int ksm(int x, int p) {
int res = 1;
for (; p; p >>= 1, x = (long long)x * x % mo) {
if (p & 1) res = (long long)res * x % mo;
}
return res;
}
int tot, root[N], las[M], lson[N * 40], rson[N * 40], zyk[N * 40], myh[N * 40];
void ins(int &k, int pre, int l, int r, int pos, int x, int y) {
k = ++tot;
lson[k] = lson[pre];
rson[k] = rson[pre];
zyk[k] = (long long)zyk[pre] * x % mo;
myh[k] = (long long)myh[pre] * y % mo;
if (l == r) return;
int mid = l + r >> 1;
if (pos <= mid)
ins(lson[k], lson[pre], l, mid, pos, x, y);
else
ins(rson[k], rson[pre], mid + 1, r, pos, x, y);
}
int query(int k, int pre, int l, int r, int L, int R) {
if (!k) return 1;
if (l >= L && r <= R) return (long long)myh[k] * zyk[pre] % mo;
int mid = l + r >> 1;
if (R <= mid) return query(lson[k], lson[pre], l, mid, L, R);
if (L > mid) return query(rson[k], rson[pre], mid + 1, r, L, R);
int ssw = query(lson[k], lson[pre], l, mid, L, R);
int ksg = query(rson[k], rson[pre], mid + 1, r, L, R);
return (long long)ssw * ksg % mo;
}
int main() {
init(M - 1);
int n = read();
for (int i = (int)(1); i <= (int)(n); i++) b[i] = read();
for (int i = (int)(0); i <= (int)((int)v.size() - 1); i++) pos[v[i]] = i;
for (int i = (int)(1); i <= (int)(n); i++) {
int x = b[i];
b[i] = 1;
while (x != 1) {
if (mn[x] > 447)
b[i] = mn[x];
else
T[pos[mn[x]]].a[i]++;
x /= mn[x];
}
}
zyk[0] = myh[0] = 1;
for (int i = (int)(fac[0] = inv[0] = 1); i <= (int)(n); i++) {
fac[i] = (long long)fac[i - 1] * b[i] % mo;
int INV = ksm(b[i], mo - 2);
inv[i] = (long long)inv[i - 1] * INV % mo;
if (las[b[i]])
ins(root[i], root[i - 1], 1, n, las[b[i]], b[i], INV);
else
root[i] = root[i - 1];
las[b[i]] = i;
}
for (int i = (int)(0); i <= (int)((int)v.size() - 1); i++)
T[i].buildtree(1, 1, n);
int Q = read(), la = 0;
while (Q--) {
int l = (read() + la) % n + 1, r = (read() + la) % n + 1;
if (l > r) swap(l, r);
int ans = (long long)fac[r] * inv[l - 1] % mo;
int jb = query(root[r], root[l - 1], 1, n, l, r);
ans = (long long)ans * jb % mo;
for (int i = (int)(0); i <= (int)((int)v.size() - 1); i++) {
int ssw = T[i].find(1, 1, n, l, r);
ans = (long long)ans * ksm(v[i], ssw) % mo;
}
writeln(la = ans);
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r = 0;
char s[200000];
cin >> n >> s;
int a = 0, f = 0, i = 0;
for (int j = 0; j < n; ++j) {
if (s[j] == 'A')
++a;
else if (s[j] == 'F')
++f;
else if (s[j] == 'I')
++i;
}
if (i > 0) {
cout << (i == 1 ? 1 : 0) << endl;
} else {
cout << (n - f) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a[4];
int sum = 0;
for (int i = 0; i < 4; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % 2) {
cout << "NO";
return 0;
} else {
sort(a, a + 4);
if (a[0] + a[3] == a[1] + a[2]) {
cout << "YES";
return 0;
}
if (a[3] == a[1] + a[2] + a[0]) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 32768, N = 109;
char ch;
string s[N], t;
int ans, v, f[MOD + 9], num, p, pos;
int ex();
int gt() {
int ret = 0;
if (t[pos] == 'n') return pos++, v;
if (t[pos] == 'f') return pos += 2, ret = f[ex()], pos++, ret;
while (t[pos] >= '0' && t[pos] <= '9') ret = ret * 10 + (t[pos] - '0'), pos++;
return ret;
}
int nex() {
int ret = gt();
while (t[pos] == '*' || t[pos] == '/') {
char tp = t[pos];
pos++;
int t1 = gt();
if (tp == '*')
ret = (int)((1ll * ret * t1) % MOD);
else
ret = (ret / t1) % MOD;
}
return ret;
}
int ex() {
int ret = nex();
while (t[pos] == '+' || t[pos] == '-') {
char tp = t[pos];
pos++;
int t1 = nex();
if (tp == '+')
ret = (ret + t1) % MOD;
else
ret = (ret + MOD - t1) % MOD;
}
return ret;
}
bool iex() {
int p1, p2, tp;
p1 = ex();
if (t[pos] == '=')
tp = 0, pos += 2;
else if (t[pos] == '<')
tp = -1, pos++;
else
tp = 1, pos++;
p2 = ex();
if (tp == 0) return p1 == p2;
if (tp == -1) return p1 < p2;
if (tp == 1) return p1 > p2;
return 0;
}
int getans() {
for (int i = 0; i < num; i++) {
t = s[i];
if (t[0] == 'i') {
pos = 3;
if (iex()) return pos += 7, ex();
} else
return pos = 6, ex();
}
return -1;
}
int main() {
cin >> ans >> ch;
while (ch != '{') cin >> ch;
num = 0;
while (true) {
cin >> ch;
if (ch == '}') break;
if (ch == ';')
num++;
else
s[num] += ch;
}
int anst = -1;
for (int i = 0; i < MOD; i++) {
v = i, f[i] = getans();
if (f[i] == ans) anst = i;
}
cout << anst;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int ind = n;
for (int i = 1; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j + i == n) {
ind = i;
break;
}
if (s[j] != s[i + j]) {
break;
}
}
if (ind != n) {
break;
}
}
string t = s.substr(0, ind);
for (int i = 0; i < k - 1; i++) cout << t;
cout << s << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rem 1000000007
#define rem1 998244353
int main()
{
ll t;
cin>>t;
while(t--)
{
ll i,j,k,n,m;
string str;
cin>>str;
cout<<str.length()<<"\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char str[300005];
vector<int> G[300005];
int color[300005], dp[300005][26];
deque<int> order;
bool dfs_visit(int v) {
color[v] = 1;
bool f = true;
for (int i = 0; i < G[v].size(); i++) {
int to = G[v][i];
if (color[to] == 1) return false;
if (color[to] == 0) {
if (!dfs_visit(to)) f = false;
}
}
color[v] = 2;
order.push_front(v);
return f;
}
bool toposort() {
memset(color, 0, sizeof(color));
for (int i = 0; i < n; i++)
if (color[i] == 0)
if (!dfs_visit(i)) return false;
return true;
}
void find_ans(int v) {
int res = -1;
for (int i = 0; i < 26; i++) res = max(res, dp[v][i]);
if (res != -1) return;
memset(dp[v], 0, sizeof(dp[v]));
dp[v][str[v] - 'a'] = 1;
for (int i = 0; i < G[v].size(); i++) {
find_ans(G[v][i]);
for (int j = 0; j < 26; j++)
if (str[v] - 'a' == j)
dp[v][j] = max(dp[v][j], dp[G[v][i]][j] + 1);
else
dp[v][j] = max(dp[v][j], dp[G[v][i]][j]);
}
return;
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", str);
bool f = true;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x - 1].push_back(y - 1);
if (x == y) f = false;
}
order.clear();
if (!f || !toposort()) {
printf("-1\n");
return 0;
}
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 0; i < n; i++) {
find_ans(order[i]);
for (int j = 0; j < 26; j++) ans = max(ans, dp[order[i]][j]);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int caseno = 1;
using namespace std;
typedef unsigned long long ULL;
typedef unsigned long long uint64;
typedef long long LL;
typedef long long int64;
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline T MAX(T a, T b) {
return (a > b) ? a : b;
}
template <class T>
inline T MIN(T a, T b) {
return (a < b) ? a : b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T fABS(T a) {
return a < 0 ? a * (-1) : a;
}
template <class T>
inline void SWAP(T &a, T &b) {
T t = a;
a = b;
b = t;
}
inline LL POW(LL base, LL power) {
LL I, res = base;
if (power == 0) return 1;
for (I = 0; I < power - 1; I++) res *= base;
return res;
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isVowel(char c) {
return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U');
}
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
string toString(int n) {
string s;
stringstream convert;
convert << n;
s = convert.str();
return s;
}
const double PI = 2 * acos(0.0);
const double EPS = 1e-11;
const int SIZE = 1e6;
string S;
int f[30];
int main() {
std::ios_base::sync_with_stdio(0);
int tcases, I, J, K, N, n, m, cnt = 0, len;
cin >> len >> S;
for (I = 0; I < len; I++) {
S[I] = toLowerCase(S[I]);
f[S[I] - 'a']++;
}
for (I = 0; I < 26; I++)
if (f[I] == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int rev(int k, int siz) {
int sol = 0, log = log2(siz) - 1;
while (k) {
if (k & 1) sol += 1 << log;
k >>= 1;
log--;
}
return sol;
}
long long pow_mod(long long a, long long b) {
long long ret = 1;
a %= 7340033;
for (; b > 0; b >>= 1) {
if (b % 2) ret = (ret * a) % 7340033;
a = (a * a) % 7340033;
}
return ret;
}
void FFT(vector<long long> &a, bool inverse) {
int n = a.size();
if (n == 1) return;
for (int i = 0; i < n; i++)
if (i < rev(i, n)) swap(a[i], a[rev(i, n)]);
for (int len = 2; len <= n; len <<= 1) {
long long wlen = inverse ? 4404020 : 5;
for (int i = len; i < (1 << 20); i <<= 1) {
wlen = (wlen * wlen) % 7340033;
}
for (int i = 0; i < n; i += len) {
long long w = 1;
for (int j = 0; j < len / 2; ++j) {
long long u = a[i + j], v = (a[i + j + len / 2] * w) % 7340033;
a[i + j] = (u + v) % 7340033;
a[i + j + len / 2] = (u - v + 7340033) % 7340033;
w = (w * wlen) % 7340033;
}
}
}
if (inverse) {
long long revn = pow_mod(n, 7340033 - 2);
for (int i = 0; i < n; ++i) a[i] = (a[i] * revn) % 7340033;
}
}
vector<long long> multiply(vector<long long> &a, vector<long long> &b) {
vector<long long> fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < max(a.size(), b.size())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
FFT(fa, false);
FFT(fb, false);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
FFT(fa, true);
vector<long long> res(min(n, 1000));
for (int i = 0; i < min(n, 1000); i++) res[i] = fa[i] % 7340033;
return res;
}
vector<long long> dp[33];
int t, N, k;
vector<long long> solve(int n) {
vector<long long> ret;
if (n == 0) {
ret.push_back(1);
return dp[n] = ret;
}
ret = solve(n - 1);
ret = multiply(ret, ret);
ret = multiply(ret, ret);
ret.insert(ret.begin(), 1);
return dp[n] = ret;
}
int SHAZAM(int n) {
int ans = 0;
while (n != 1 && n % 2 > 0) {
ans++;
n /= 2;
}
return ans;
}
int main() {
scanf("%d", &t);
solve(32);
while (t--) {
scanf("%d %d", &N, &k);
int idx = SHAZAM(N);
printf("%lld\n", (k < dp[idx].size()) ? dp[idx][k] : 0);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int divid(long n) {
long maxn = -1, a;
while (n) {
a = n % 10;
n /= 10;
maxn = maxn > a ? maxn : a;
}
return maxn;
}
int main() {
long n;
int T = 0;
scanf("%d", &n);
while (n != 0) {
n -= divid(n);
T++;
}
printf("%d\n", T);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll power(ll n, ll p) {
ll ans = 1;
for (ll i = 0; i < p; i++) {
ans *= n;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
ll n;
cin >> n;
ll arr[n + 1];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
vector<vector<ll>> dp(n + 1, vector<ll>(2 * n, 100000));
dp[0][0] = 0;
for (int i = 0; i <= n; i++)
for (ll j = i; j < 2 * n - 1; j++) {
if (dp[i][j] == 100000) continue;
if (i < n)
dp[i + 1][j + 1] =
min((dp[i][j] + abs(arr[i] - j - 1)), dp[i + 1][j + 1]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j]);
}
cout << dp[n][2 * n - 1] << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3009;
inline long long read() {
long long res = 0, w = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') w = -1;
c = getchar();
}
while (isdigit(c)) {
res = res * 10 + c - 48;
c = getchar();
}
return res * w;
}
int T, n, a[N], f[N][N];
vector<int> p[N];
int main() {
T = read();
while (T--) {
n = read();
for (int i = (1); i <= (n); i++)
for (int j = (i); j <= (n); j++) f[i][j] = j - i + 1;
for (int i = (1); i <= (n); i++) p[i].clear();
for (int i = (1); i <= (n); i++) a[i] = read(), p[a[i]].push_back(i);
for (int l = (n); l >= (1); l--)
for (int r = (l); r <= (n); r++) {
if (l == r)
f[l][r] = 0;
else {
f[l][r] = f[l + 1][r] + 1;
for (int k : p[a[l]])
if (l <= k && k <= r) f[l][r] = min(f[l][r], f[l][k - 1] + f[k][r]);
}
}
printf("%d\n", f[1][n]);
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
vector<pair<int, long long>> best(n);
int ind = n - k;
long long cur = 0;
while (ind < n) cur += v[ind++];
best[n - k] = {n - k, cur};
ind = n - 1;
for (int i = n - k - 1; i >= 0; --i, --ind) {
long long sum = cur - v[ind] + v[i];
if (sum >= best[i + 1].second) {
best[i] = {i, sum};
} else {
best[i] = best[i + 1];
}
cur = sum;
}
ind = 0;
cur = 0;
while (ind < k) cur += v[ind++];
long long mx = cur + best[k].second;
int a = 0;
int b = best[k].first;
ind = 0;
for (int i = k; i + k < n; ++i, ++ind) {
long long sum = cur - v[ind] + v[i];
if (sum + best[i + 1].second > mx) {
a = i - k + 1;
b = best[i + 1].first;
mx = sum + best[i + 1].second;
}
cur = sum;
}
cout << a + 1 << " " << b + 1 << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[10000];
int main() {
cin.tie(NULL);
cout.tie(NULL);
scanf("%d", &n);
int cnt, now;
for (int i = 0; i < n; i++) s[i] = '0';
printf("? %s\n", s);
fflush(stdout);
scanf("%d", &cnt);
s[0] = '1';
printf("? %s\n", s);
fflush(stdout);
scanf("%d", &now);
if (now < cnt) {
int pos1 = 1;
cnt = now;
int l = 2;
int r = n;
while (l < r) {
int m = (l + r) >> 1;
if ((m - l) % 2) m--;
for (int i = l; i <= m; i++) s[i - 1] = '1';
printf("? %s\n", s);
fflush(stdout);
scanf("%d", &now);
if (now != cnt - (m - l + 1)) {
for (int i = l; i <= m; i++) s[i - 1] = '0';
r = m;
} else {
cnt = now;
l = m + 1;
}
}
printf("! %d %d", l, pos1);
fflush(stdout);
} else {
s[0] = '0';
int pos0 = 1;
int l = 2;
int r = n;
while (l < r) {
int m = (l + r) >> 1;
if ((m - l) % 2) m--;
for (int i = l; i <= m; i++) s[i - 1] = '1';
printf("? %s\n", s);
fflush(stdout);
scanf("%d", &now);
if (now != cnt + (m - l + 1)) {
for (int i = l; i <= m; i++) s[i - 1] = '0';
r = m;
} else {
cnt = now;
l = m + 1;
}
}
printf("! %d %d", pos0, l);
fflush(stdout);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int fact(int N) {
int res = 1;
for (int i = 2; i <= N; i++) {
res = ((long long)res * i) % 1000000007;
}
return res;
}
int mmul(int x, int y) { return ((long long)x * y) % 1000000007; }
int memo[1000][1000];
int solve(int X, int Y) {
if (X == 0) return fact(Y);
int& ret = memo[X][Y];
if (ret != -1) return ret;
ret = 0;
int c = 1;
for (int i = 0; i <= Y; i++) {
ret = (ret + mmul(c, solve(X - 1, Y - i))) % 1000000007;
if (X > 1) {
ret = (ret + mmul(mmul(X - 1, i + 1), mmul(c, solve(X - 2, Y - i)))) %
1000000007;
}
c = mmul(c, Y - i);
}
return ret;
}
int main() {
int N;
cin >> N;
int ones = 0;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
ones += x == 1;
}
memset(memo, -1, sizeof(memo));
cout << solve(ones, N - ones) << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int a[1001][1001], l[1001][1001], r[1001][1001], t[1001][1001], b[1001][1001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0) {
t[i][j] = a[i][j];
} else {
if (a[i][j] == 1) {
t[i][j] = t[i - 1][j] + 1;
} else {
t[i][j] = t[i - 1][j];
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j == 0) {
l[i][j] = a[i][j];
} else {
if (a[i][j] == 1) {
l[i][j] = l[i][j - 1] + 1;
} else {
l[i][j] = l[i][j - 1];
}
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (i == n - 1) {
b[i][j] = a[i][j];
} else {
if (a[i][j] == 1) {
b[i][j] = b[i + 1][j] + 1;
} else {
b[i][j] = b[i + 1][j];
}
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (j == m - 1) {
r[i][j] = a[i][j];
} else {
if (a[i][j] == 1) {
r[i][j] = r[i][j + 1] + 1;
} else {
r[i][j] = r[i][j + 1];
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) continue;
if (l[i][j] > 0) ans++;
if (r[i][j] > 0) ans++;
if (t[i][j] > 0) ans++;
if (b[i][j] > 0) ans++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<int, vector<int> > x;
vector<int> un;
vector<vector<pair<int, int> > > I;
int getFir(const vector<pair<int, int> > &V, int from) {
int l = 0, r = int(V.size()) - 1;
int res = -1;
while (l <= r) {
int m = l + r >> 1;
if (from <= V[m].second) {
res = m;
r = m - 1;
} else
l = m + 1;
}
if (res == -1) return n + 1;
return max(from, V[res].first);
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
int r, c;
scanf("%d %d", &r, &c);
x[r].push_back(c);
un.push_back(r);
if (r < n) un.push_back(r + 1);
}
for (map<int, vector<int> >::iterator it = x.begin(); it != x.end(); it++)
sort(it->second.begin(), it->second.end());
un.push_back(1);
un.push_back(n);
sort(un.begin(), un.end());
un.erase(unique(un.begin(), un.end()), un.end());
I.resize(un.size());
if (x.find(1) == x.end())
I[0].push_back(pair<int, int>(1, n));
else
I[0].push_back(pair<int, int>(1, x[1][0] - 1));
for (int i = 1; i < un.size(); i++) {
int r = un[i];
map<int, vector<int> >::iterator it = x.find(r);
if (it == x.end()) {
if (!I[i - 1].empty())
I[i].push_back(pair<int, int>(I[i - 1][0].first, n));
} else {
int st = 1;
for (int j = 0; j < it->second.size(); j++) {
int p = it->second[j];
if (st < p) {
int fir = getFir(I[i - 1], st);
if (fir < p) I[i].push_back(pair<int, int>(fir, p - 1));
}
st = p + 1;
}
if (st < n + 1) {
int fir = getFir(I[i - 1], st);
if (fir < n + 1) I[i].push_back(pair<int, int>(fir, n));
}
}
}
if (!I.back().empty() && I.back().back().second == n)
printf("%d\n", 2 * n - 2);
else
printf("-1\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int mat[510][510], sum[510][510];
int n, m;
bool ok(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &mat[i][j]);
memset(sum, 0, sizeof(sum));
for (int i = n - 1; i >= 0; i--) {
int t = 0;
for (int j = m - 1; j >= 0; j--) {
t += mat[i][j];
sum[i][j] = sum[i + 1][j] + t;
}
}
int ans = -1000000000;
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
int x = i, y = j;
int t = mat[i][j];
int l = 1;
while (true) {
x--, y--;
l += 2;
if (ok(x, y) && (x + l - 1) < n && (y + l - 1) < m) {
t += mat[x + 1][y];
int s = sum[x][y] - sum[x + l][y] - sum[x][y + l] + sum[x + l][y + l];
t = s - t;
ans = max(ans, t);
} else
break;
}
}
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n, c;
bool t = false;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (b != a)
return cout << "rated", 0;
else {
if (i != 0) {
if (a > c) t = true;
c = a;
} else {
c = a;
}
}
}
(t) ? cout << "unrated" : cout << "maybe";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, temp, count = 0, flag;
cin >> n >> x;
if (n >= x) {
temp = x;
flag = 0;
} else {
temp = n;
flag = 1;
}
while (temp > flag) {
if ((x % temp) == 0 && (temp * n) >= x) {
count++;
}
temp--;
}
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r;
cin >> n >> r;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
int cnt = 0;
vector<bool> used(n, false);
while (true) {
int max_i = -1;
int max_b = -500;
for (int i = 0; i < n; i++) {
if (used[i]) continue;
if (a[i] > r) continue;
if (r + b[i] < 0) continue;
if (max_b < b[i]) {
max_i = i;
max_b = b[i];
}
}
if (max_b < 0) break;
cnt++;
used[max_i] = true;
r += b[max_i];
}
while (true) {
int max_i = -1;
int max_d = -500;
for (int i = 0; i < n; i++) {
if (used[i]) continue;
if (a[i] > r) continue;
if (r + b[i] < 0) continue;
if (max_d < a[i] + b[i]) {
max_i = i;
max_d = a[i] + b[i];
}
}
if (max_i == -1) break;
cnt++;
used[max_i] = true;
r += b[max_i];
}
cout << ((cnt == n) ? "YES" : "NO") << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
long double dist1(long double x1, long double y1, long double x2,
long double y2) {
return (long double)sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
long double dist2(long double x1, long double y1, long double x2,
long double y2, long double x, long double y) {
long double num = (y2 - y1) * x - (x2 - x1) * y + x2 * y1 - y2 * x1;
long double den = dist1(x1, y1, x2, y2);
num = abs(num);
return (long double)num / den;
}
typedef struct node {
long double x, y;
} nd;
bool func(long double x1, long double y1, long double x2, long double y2,
long double x3, long double y3) {
if (x3 > x1 && x3 > x2 || y3 > y1 && y3 > y2 || y3 < y1 && y3 < y2 ||
x3 < x1 && x3 < x2)
return false;
return true;
}
long double k(long double x1, long double y1, long double x2, long double y2,
long double x3, long double y3) {
long double ans = (y2 - y1) * (x3 - x1) - (x2 - x1) * (y3 - y1);
long double den = (y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1);
ans /= den;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, x, y;
cin >> n >> x >> y;
vector<nd> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i].x >> v[i].y;
}
long double min1 = LLONG_MAX;
long double max1 = 0;
for (long long i = 0; i < n; i++) {
long double dist = dist1(x, y, v[i].x, v[i].y);
min1 = min(min1, dist);
max1 = max(max1, dist);
long double x1 = v[i].x;
long double y1 = v[i].y;
long double x2 = v[(i + 1) % n].x;
long double y2 = v[(i + 1) % n].y;
long double st = k(x1, y1, x2, y2, x, y);
long double x4 = x - st * (y2 - y1);
long double y4 = y + st * (x2 - x1);
bool check = func(x1, y1, x2, y2, x4, y4);
if (check)
min1 = min(min1, dist2(v[i].x, v[i].y, v[(i + 1) % n].x, v[(i + 1) % n].y,
x, y));
}
cerr << "max1"
<< ": " << max1 << " | "
<< "min1"
<< ": " << min1 << "\n";
long double ans = 3.141592653589793 * (max1 * max1 - min1 * min1);
cout << fixed << setprecision(12) << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
set<vector<int>> cnt;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int dn = 0, dm = 0, cn = n, cm = m;
--cn, --cm;
while (cn) cn /= 7, ++dn;
dn = max(1, dn);
while (cm) cm /= 7, ++dm;
dm = max(1, dm);
if (dn + dm > 7) return cout << 0, 0;
int i, j, ans = 0;
vector<int> v;
for (i = 0; i < 7; ++i) v.push_back(i);
do {
cn = 0, cm = 0;
vector<int> temp;
for (i = 0; i < dn + dm; ++i) temp.push_back(v[i]);
for (i = dn + dm - 1, j = 1; i >= dn; --i, j *= 7) cm += j * temp[i];
for (j = 1; i >= 0; --i, j *= 7) cn += j * temp[i];
if (cn < n and cm < m) cnt.insert(temp);
} while (next_permutation(v.begin(), v.end()));
cout << cnt.size();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve(int test) {
long long x, y, a, b;
cin >> x >> y >> a >> b;
long long d = a * (y - x);
if (d % (a + b) != 0)
cout << "-1\n";
else {
d /= (a + b);
if (d % a == 0 && (y - x - d) % b == 0 && d / a == (y - x - d) / b)
cout << d / a << "\n";
else
cout << "-1\n";
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(10);
int t = 1;
cin >> t;
for (int test = 1; test <= t; test++) {
solve(test);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5), mod = int(1e9) + 7;
int a, h, w;
long long phi(int n) {
long long m = n;
for (int i = 2; 1ll * i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
m -= m / i;
}
}
if (n > 1) m -= m / n;
return m;
}
long long modpow(long long a, long long b, long long c) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % c;
a = a * a % c;
b >>= 1;
}
return res % c;
}
int main() {
cin >> a >> h >> w;
int mx = int(1e9);
int res = h - w;
int A = w + a;
res = (res + 1ll * A * mx) % A;
int B = (a + h) % A;
mx = w / a;
int ans = -1;
if (a == 1) {
cout << 0;
return 0;
}
for (int i = 1; i <= mx; i++) {
res += B;
if (res >= A) {
res -= A;
}
if (res == 0) ans = i;
}
if (ans == -1)
puts("-1");
else
printf("%.12lf", (w - ans * a + 0.0) / (ans + 1));
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int a[110][310];
int b[110][110];
int c[10010];
int reach[110];
bool used[100010];
int getPos(int t, int i) {
int j = a[i][0] - 1;
int pos = 0;
if (t >= a[i][2 + 3 * j]) return a[i][3 + 3 * j];
while (t < a[i][2 + 3 * j]) j--;
if (j < 0)
pos = a[i][1] * t;
else
pos = a[i][3 + 3 * j] + a[i][1 + 3 * (j + 1)] * (t - a[i][2 + 3 * j]);
return pos;
}
int cmp(const void *p, const void *q) { return *(int *)p - *(int *)q; }
int main() {
int n, s;
cin >> n >> s;
queue<int> q;
int m = 0;
for (int i = 0; i < n; i++) {
cin >> a[i][0];
int t = 0;
int p = 0;
for (int j = 0; j < a[i][0]; j++) {
int l, v;
cin >> v >> l;
t += l;
p += v * l;
a[i][1 + 3 * j] = v;
a[i][2 + 3 * j] = t;
a[i][3 + 3 * j] = p;
if (!used[t]) {
c[m++] = t;
used[t] = true;
}
}
}
qsort(c, m, sizeof(int), cmp);
int res = 0;
for (int k = 0; k < m; k++) {
int t = c[k];
for (int i = 0; i < n; i++) {
if (reach[i] && reach[i] < t) continue;
int pi = getPos(t, i);
if (pi == s) reach[i] = t;
for (int j = i + 1; j < n; j++) {
if (reach[j] && reach[j] < t) continue;
int pj = getPos(t, j);
if (pj == s) reach[j] = t;
if (pi < pj) {
if (b[i][j] >= 1) res++;
b[i][j] = -2;
b[j][i] = 2;
} else if (pi > pj) {
if (b[i][j] <= -1) res++;
b[i][j] = 2;
b[j][i] = -2;
} else {
if (b[i][j] > 1 || b[i][j] < -1) {
b[i][j] /= 2;
b[j][i] /= 2;
}
}
}
}
}
cout << res << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
long long a[100001];
int main() {
int n, k, ans = 1, l = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int pd = 0;
for (int i = 1; i < n; i++) {
if (a[i] != a[i + 1])
pd++;
else
ans = max(pd + 1, ans), pd = 0, l = 1;
}
ans = max(pd + 1, ans);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, id;
bool operator<(const node &a) const { return x < a.x; }
};
set<node> v;
int a[400005];
bool b[400005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
{
int cnt = 0;
int l, r, rr;
scanf("%d%d", &l, &r);
rr = r;
a[++cnt] = r - l;
b[cnt] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d%d", &l, &r);
a[++cnt] = l - rr;
b[cnt] = 0;
rr = r;
a[++cnt] = r - l;
b[cnt] = 1;
}
a[++cnt] = m;
b[cnt] = 0;
l = 1;
r = 1;
int h = m;
int maxx = 0;
int ans = 0;
while (l <= cnt && r <= cnt) {
while (h > 0) {
maxx = max(maxx, ans);
ans += a[r];
if (b[r] == 0) h -= a[r];
r++;
}
while (h <= 0) {
maxx = max(maxx, ans + h);
ans -= a[l];
if (b[l] == 0) h += a[l];
l++;
}
}
printf("%d\n", maxx);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string name[24] = {"C", "C#", "D", "D#", "E", "F", "F#", "G",
"G#", "A", "B", "H", "C", "C#", "D", "D#",
"E", "F", "F#", "G", "G#", "A", "B", "H"};
string inp[3];
int dist[2];
int getDist(string a, string b) {
int i, j;
for (i = 0; i < 12; i++) {
if (name[i] == a) {
break;
}
}
for (j = i; j < 24; j++) {
if (name[j] == b) {
break;
}
}
return j - i;
}
bool isMajor() {
int a[3] = {0, 1, 2};
do {
dist[0] = getDist(inp[a[0]], inp[a[1]]);
dist[1] = getDist(inp[a[1]], inp[a[2]]);
if (dist[0] == 4 && dist[1] == 3) {
return true;
}
} while (next_permutation(a, a + 3));
return false;
}
bool isMinor() {
int a[3] = {0, 1, 2};
do {
dist[0] = getDist(inp[a[0]], inp[a[1]]);
dist[1] = getDist(inp[a[1]], inp[a[2]]);
if (dist[0] == 3 && dist[1] == 4) {
return true;
}
} while (next_permutation(a, a + 3));
return false;
}
int main() {
for (int i = 0; i < 3; i++) {
cin >> inp[i];
}
if (isMajor()) {
puts("major");
} else if (isMinor()) {
puts("minor");
} else {
puts("strange");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int num(string s) {
if (s == "S") return 0;
if (s == "M") return 1;
if (s == "L") return 2;
if (s == "XL") return 3;
if (s == "XXL") return 4;
if (s == "XXXL") return 5;
return -1;
}
string st(int nv) {
if (nv == 0) return "S";
if (nv == 1) return "M";
if (nv == 2) return "L";
if (nv == 3) return "XL";
if (nv == 4) return "XXL";
if (nv == 5) return "XXXL";
return "";
}
struct FlowEdge {
int v, u;
long long cap, flow = 0;
FlowEdge(int v, int u, long long cap) : v(v), u(u), cap(cap) {}
};
struct Dinic {
const long long flow_inf = 1e18;
vector<FlowEdge> edges;
vector<vector<int>> adj;
int n, m = 0;
int s, t;
vector<int> level, ptr;
queue<int> q;
Dinic(int n, int s, int t) : n(n), s(s), t(t) {
adj.resize(n);
level.resize(n);
ptr.resize(n);
}
void add_edge(int v, int u, long long cap) {
edges.emplace_back(v, u, cap);
edges.emplace_back(u, v, 0);
adj[v].push_back(m);
adj[u].push_back(m + 1);
m += 2;
}
bool bfs() {
while (!q.empty()) {
int v = q.front();
q.pop();
for (int id : adj[v]) {
if (edges[id].cap - edges[id].flow < 1) continue;
if (level[edges[id].u] != -1) continue;
level[edges[id].u] = level[v] + 1;
q.push(edges[id].u);
}
}
return level[t] != -1;
}
long long dfs(int v, long long pushed) {
if (pushed == 0) return 0;
if (v == t) return pushed;
for (int &cid = ptr[v]; cid < (int)adj[v].size(); cid++) {
int id = adj[v][cid];
int u = edges[id].u;
if (level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1)
continue;
long long tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow));
if (tr == 0) continue;
edges[id].flow += tr;
edges[id ^ 1].flow -= tr;
return tr;
}
return 0;
}
long long flow() {
long long f = 0;
while (true) {
fill(level.begin(), level.end(), -1);
level[s] = 0;
q.push(s);
if (!bfs()) break;
fill(ptr.begin(), ptr.end(), 0);
while (long long pushed = dfs(s, flow_inf)) {
f += pushed;
}
}
return f;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<int> cnt(6, 0);
for (int i = 0; i < 6; i++) {
cin >> cnt[i];
}
int nn;
cin >> nn;
vector<vector<string>> vv;
for (int i = 0; i < nn; i++) {
string k;
cin >> k;
vector<string> v;
string t = "";
for (int j = 0; j < k.length(); j++) {
if (k[j] == ',') {
v.push_back(t);
t = "";
} else {
t += k[j];
}
}
v.push_back(t);
vv.push_back(v);
}
vector<string> ans(nn, "");
Dinic d(10 * nn, 10 * nn - 2, 10 * nn - 1);
for (int i = 0; i < nn; i++) {
d.add_edge(10 * nn - 2, i, 1);
for (auto &x : vv[i]) {
d.add_edge(i, nn + num(x), 1);
}
}
for (int i = nn; i < nn + 6; i++) {
d.add_edge(i, 10 * nn - 1, cnt[i - nn]);
}
int x = d.flow();
if (x != nn) {
cout << "NO\n";
exit(0);
}
for (auto &e : d.edges) {
if (e.v < nn && e.flow == 1) {
ans[e.v] = st(e.u - nn);
}
}
cout << "YES\n";
for (auto &s : ans) {
cout << s << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
a %= m;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
vector<long long> prefix_function(vector<long long> s) {
long long n = (long long)s.size();
vector<long long> pi(n);
for (long long i = 1; i < n; i++) {
long long j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) j++;
pi[i] = j;
}
return pi;
}
int32_t main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
long long n, m;
cin >> n >> m;
set<long long> arr[n + 1];
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
if (u > v) swap(u, v);
arr[u].insert(v - u);
arr[v].insert(u - v + n);
}
vector<long long> str;
for (long long i = 1; i <= n; i++) {
for (auto x : arr[i]) {
str.push_back(x);
}
str.push_back((long long)9e18);
}
long long N = (long long)str.size();
long long len = prefix_function(str).back();
if (len > 0 and N % (N - len) == 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, t, i, a[200000], m, k;
vector<long long> v;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
};
m = a[0];
for (i = 0; i < n; i++) {
if (i) {
if (a[i] > m) {
m = a[i];
}
}
}
for (i = 0; i < n; i++) {
a[i] = m - a[i];
}
m = a[0];
for (i = 0; i < n; i++) {
if (i) {
if (a[i] > m) {
m = a[i];
}
}
}
if (k % 2 == 0) {
for (i = 0; i < n; i++) {
a[i] = m - a[i];
}
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string getStr() {
char ch[1000000];
scanf("%s", ch);
return ch;
}
inline char getCh() {
char ch;
scanf(" %c", &ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const int MOD = 1e9 + 7;
const int MAX_N = 3e3 + 10;
const int MAX_LG = 21;
const int base = 29;
const int MAX_DIF = 5005;
int inp[MAX_N][MAX_N];
int dp[MAX_N][MAX_N][3];
vector<pair<int, int> > hit[MAX_N];
long long fen[2 * MAX_N][MAX_N];
inline void add(int sum, int p, int val) {
for (; p < MAX_N; p |= (p + 1)) fen[sum][p] += val;
}
inline int get(int sum, int p) {
int ret = 0;
for (; p >= 0; p = (p & (p + 1)) - 1) ret += fen[sum][p];
return ret;
}
long long res;
int32_t main() {
int n = in(), m = in();
for (int i = 0; i < n; i++) {
cin.ignore();
for (int j = 0; j < m; j++) {
char ch = getchar();
inp[i][j] = ch == 'z';
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (!inp[i][j]) continue;
dp[i][j][0] = 1 + (j < m - 1 ? dp[i][j + 1][0] : 0);
dp[i][j][1] = 1 + (j > 0 && i < n - 1 ? dp[i + 1][j - 1][1] : 0);
hit[j + dp[i][j][0] - 1].push_back(make_pair(i, j));
}
for (int j = 0; j < m; j++) {
if (!inp[i][j]) continue;
dp[i][j][2] = 1 + (j ? dp[i][j - 1][2] : 0);
}
}
for (int j = m - 1; j >= 0; j--) {
for (int pt = 0; pt < hit[j].size(); pt++) {
int x = hit[j][pt].first;
int y = hit[j][pt].second;
add(x + y, y, 1);
}
for (int i = 0; i < n; i++) {
int mini = min(dp[i][j][2], dp[i][j][1]);
res += get(i + j, j) - get(i + j, j - mini);
}
}
cout << res << "\n";
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
transform(s2.begin(), s2.end(), s2.begin(), ::tolower);
if (s1 == s2)
cout << "0";
else if (s1 > s2)
cout << "1";
else
cout << "-1";
}
| 0 |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
using namespace std;
int a[105];
int main() {
ios::sync_with_stdio(false);
int n;
while (cin >> n) {
memset(a, 0, sizeof a);
int ans = 0;
for (int i = 0; i < n; i++) {
int cur;
cin >> cur;
a[cur]++;
if (a[cur] >= 4) {
a[cur] -= 4;
ans++;
}
}
for (int i = 1; i <= 100; i++) {
for (int j = i + 1; j <= 100; j++) {
if (a[i] >= 2 && a[j] >= 2) {
a[i] -= 2;
a[j] -= 2;
ans++;
}
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Position {
int p;
int cost;
} pos, pre, now;
int cnt[200005];
int cost[200005];
int father[200005];
int n, m;
int x, y;
int k;
int path[200005];
vector<vector<int>> edge;
int s, e;
queue<Position> q;
int len;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n + 1; i++) {
edge.push_back(vector<int>());
}
for (int i = 0; i < m; i++) {
cin >> x >> y;
edge[y].push_back(x);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> path[i];
}
for (int i = 1; i <= n; i++) {
cost[i] = INT_MAX;
cnt[i] = 0;
father[i] = i;
}
s = path[k - 1];
e = path[0];
cost[s] = 0;
pos.p = s;
pos.cost = 0;
q.push(pos);
while (!q.empty()) {
pre = q.front();
q.pop();
len = edge[pre.p].size();
now.cost = pre.cost + 1;
for (int i = 0; i < len; i++) {
now.p = edge[pre.p][i];
if (now.cost > cost[now.p])
continue;
else if (now.cost == cost[now.p]) {
cnt[now.p]++;
} else if (now.cost < cost[now.p]) {
cost[now.p] = now.cost;
cnt[now.p] = 1;
father[now.p] = pre.p;
q.push(now);
}
}
}
int minans = 0;
int maxans = 0;
for (int i = 0; i < k - 1; i++) {
if (cost[path[i]] < k - i - 1) {
if (cost[path[i + 1]] == cost[path[i]] - 1) {
if (cnt[path[i]] > 1) maxans++;
} else {
maxans++;
minans++;
}
} else if (cnt[path[i]] > 1)
maxans++;
}
cout << minans << " " << maxans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
long long int power(long long int a, long long int b) {
long long int r = 1;
for (; b; b >>= 1) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
}
return r;
}
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int m1 = *min_element(a, a + n), m2 = *min_element(b, b + n);
long long int ans = 0;
for (int i = 0; i < n; i++) ans += max(abs(a[i] - m1), abs(b[i] - m2));
cout << ans << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
char s[N];
int dp[N][2][2];
void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
dp[0][0][0] = 1;
dp[0][0][1] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '0' || s[i] == '?') {
add(dp[i][0][0], dp[i - 1][0][0]);
}
if (s[i] == '1' || s[i] == '?') {
add(dp[i][0][1], dp[i - 1][0][0]);
add(dp[i][0][0], dp[i - 1][1][0]);
}
if (s[i] == '2' || s[i] == '?') {
add(dp[i][0][1], dp[i - 1][1][0]);
}
if (s[i] == '*' || s[i] == '?') {
add(dp[i][1][0], dp[i - 1][0][1]);
add(dp[i][1][0], dp[i - 1][1][1]);
add(dp[i][1][1], dp[i - 1][0][1]);
add(dp[i][1][1], dp[i - 1][1][1]);
}
}
int ans = 0;
add(ans, dp[n][0][0]);
add(ans, dp[n][1][0]);
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long ma = 10000000;
bool a[10000001];
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
c_p_c();
long long k;
cin >> k;
vector<pair<long, pair<long, long> > > a;
for (long t = 0; t < k; t++) {
long long n;
cin >> n;
vector<long> v;
for (long i = 1; i <= n; i++) {
long x;
cin >> x;
v.push_back(x);
}
long long sum = accumulate(v.begin(), v.end(), 0);
for (long i = 0; i < (long)v.size(); i++) {
a.push_back(make_pair(sum - v[i], make_pair(t, i)));
}
}
sort(a.begin(), a.end());
for (long i = 0; i < (long)a.size() - 1; i++) {
if (a[i].first == a[i + 1].first &&
(a[i].second.first != a[i + 1].second.first)) {
cout << "YES" << endl;
cout << a[i].second.first + 1 << " " << a[i].second.second + 1 << endl;
cout << a[i + 1].second.first + 1 << " " << a[i + 1].second.second + 1
<< endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a, x, y, m;
int k[5005];
int ind[5005];
vector<int> problems[5005];
pair<int, int> ans[200001];
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%I64d%I64d%I64d%I64d", &k[i], &a, &x, &y, &m);
problems[i].push_back(a);
for (j = 1; j < k[i]; j++) {
a = (a * x + y) % m;
problems[i].push_back(a);
}
ind[i] = 0;
}
int bef = 0;
int last = 0;
int bad = 0;
int best, idx;
while (true) {
best = 1000000001;
for (i = 0; i < n; i++) {
if (ind[i] < k[i] && problems[i][ind[i]] < best &&
problems[i][ind[i]] >= bef) {
best = problems[i][ind[i]];
idx = i;
}
}
if (best == 1000000001) {
for (i = 0; i < n; i++) {
if (ind[i] < k[i] && problems[i][ind[i]] < best) {
best = problems[i][ind[i]];
idx = i;
}
}
bad++;
}
if (best == 1000000001) break;
bef = problems[idx][ind[idx]];
ind[idx]++;
if (last <= 200000) ans[last++] = make_pair(bef, idx);
}
printf("%d\n", --bad);
if (last <= 200000) {
for (i = 0; i < last; i++)
printf("%d %d\n", ans[i].first, ans[i].second + 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
const int x = 1000;
int a[x], b[x], e = 0;
string h, r, m;
cin >> h >> r >> m;
for (int i = 0; i < x; i++) {
a[i] = 0;
b[i] = 0;
}
for (int i = 0; i < h.size(); i++) {
a[h[i]]++;
}
for (int i = 0; i < r.size(); i++) {
a[r[i]]++;
}
for (int i = 0; i < m.size(); i++) {
b[m[i]]++;
}
for (int i = 'A'; i <= 'Z'; i++) {
if (a[i] != b[i]) {
e++;
break;
}
}
if (e == 0) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t, c;
cin >> t;
string n;
vector<pair<string, int>> events;
vector<string> names;
map<string, int> points;
for (int i = 0; i < t; i++) {
cin >> n >> c;
events.push_back({n, c});
if (points[n] == 0) names.push_back(n);
points[n] += c;
}
int maximoPoints = -1, cont = 0;
string ans = "";
for (auto x : names) {
maximoPoints = max(maximoPoints, points[x]);
ans = x;
}
for (auto x : names)
if (points[x] == maximoPoints) cont++;
map<string, int> contador;
for (auto j : events) {
contador[j.first] += j.second;
if (contador[j.first] >= maximoPoints && points[j.first] == maximoPoints) {
cout << j.first << '\n';
break;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
ostream &operator<<(ostream &out, string str) {
for (char c : str) out << c;
return out;
}
template <class L, class R>
ostream &operator<<(ostream &out, pair<L, R> p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <class T>
auto operator<<(ostream &out, T a) -> decltype(a.begin(), out) {
out << "{";
for (auto it = a.begin(); it != a.end(); it = next(it))
out << (it != a.begin() ? ", " : "") << *it;
return out << "}";
}
void dump() { cerr << "\n"; }
template <class T, class... Ts>
void dump(T a, Ts... x) {
cerr << a << ", ";
dump(x...);
}
template <class T>
int size(T &&a) {
return a.size();
}
using LL = long long;
using PII = pair<int, int>;
vector<int> sort_shifts(string &str) {
int n = size(str), alf = 256;
vector<int> p(n), c(n), cnt(max(alf, n));
for (int i = 0; i < n; i++) cnt[str[i]]++;
for (int i = 1; i <= alf - 1; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; i++) p[--cnt[str[i]]] = i;
for (int i = 1; i <= n - 1; i++) {
c[p[i]] = c[p[i - 1]];
if (str[p[i - 1]] != str[p[i]]) c[p[i]]++;
}
vector<int> pn(n), cn(n);
for (int k = 0; (1 << k) < n; ++k) {
auto mod = [&](int a, int b) { return (a + b + n) % n; };
for (int i = 0; i < n; i++) pn[i] = mod(p[i], -(1 << k));
fill(cnt.begin(), cnt.end(), 0);
for (int i = 0; i < n; i++) cnt[c[pn[i]]]++;
for (int i = 1; i <= size(cnt) - 1; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) p[--cnt[c[pn[i]]]] = pn[i];
for (int i = 1; i <= n - 1; i++) {
cn[p[i]] = cn[p[i - 1]];
PII prev = {c[p[i - 1]], c[mod(p[i - 1], 1 << k)]};
PII curr = {c[p[i]], c[mod(p[i], 1 << k)]};
if (prev != curr) cn[p[i]]++;
}
swap(cn, c);
}
return p;
}
vector<int> suffix_array(string str) {
str += "$";
auto ret = sort_shifts(str);
ret.erase(ret.begin());
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string str;
cin >> str;
int n = size(str), q;
cin >> q;
vector<string> t(q);
for (int i = 0; i < q; i++) cin >> t[i];
auto get_beg = [&]() {
auto sa = suffix_array(str);
auto compare = [&](int i, int j, bool ret_equal) {
for (int len = 0; len < size(t[j]); len++) {
if (i + len == n) return false;
if (str[i + len] > t[j][len]) return true;
if (str[i + len] < t[j][len]) return false;
}
return ret_equal;
};
auto binsearch = [&](int i, bool ret_equal) {
int l = 0, r = n;
while (l < r) {
int m = (l + r) / 2;
if (compare(sa[m], i, ret_equal))
r = m;
else
l = m + 1;
}
return l;
};
vector<int> pref(n + 1);
for (int i = 0; i < q; i++) {
pref[binsearch(i, true)]++;
pref[binsearch(i, false)]--;
}
for (int i = 1; i <= n; i++) pref[i] += pref[i - 1];
vector<int> ret(n);
for (int i = 0; i < n; i++) ret[sa[i]] = pref[i];
return ret;
};
auto beg1 = get_beg();
reverse(str.begin(), str.end());
for (int i = 0; i < q; i++) reverse(t[i].begin(), t[i].end());
auto beg2 = get_beg();
LL ans = 0;
for (int i = 1; i <= n - 1; i++) ans += (LL)beg1[i] * beg2[n - i];
cout << ans << "\n";
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int T, n;
cin >> T;
while (T--) {
cin >> n;
int count = 0;
int sum = 0;
for (int i = 0; i < n; i++) {
int cur;
cin >> cur;
sum += cur;
if (cur == 0) {
count++;
sum++;
}
}
if (sum == 0) count++;
cout << count << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long result[1000001][21], t[2][21], d[1000001], done[1000001],
tsnt[1000001], mod = 1e9 + 7;
vector<long long> prime;
void dp() {
t[0][0] = result[0][0] = 1;
for (long long i = 1; i <= 20; i++)
t[0][i] = t[0][i - 1] + 2, result[0][i] = 2;
for (long long i = 1; i <= 1000000; i++)
for (long long e = 0; e <= 20; e++) {
result[i][e] = t[(i + 1) % 2][e];
t[i % 2][e] = result[i][e];
if (e != 0) t[i % 2][e] += t[i % 2][e - 1];
t[i % 2][e] %= mod;
}
}
void era() {
for (long long i = 2; i <= 1000000; i++) {
if (d[i] == 0) {
for (long long e = 2; e <= 1000000; e++) {
if (e * i > 1000000) break;
d[i * e] = i;
}
d[i] = i;
}
}
}
void ptich(long long g, long long t) {
long long u = g;
prime.clear();
while (u != 1) {
if (done[d[u]] != t)
done[d[u]] = t, tsnt[d[u]] = 1, prime.push_back(d[u]);
else
tsnt[d[u]]++;
u /= d[u];
}
}
long long get(long long g, long long level) {
long long kq = 1;
for (auto v : prime) kq *= result[level][tsnt[v]], kq %= mod;
return kq;
}
void do_it() {
dp();
era();
long long q, u, v, d = 0;
cin >> q;
while (q--) {
d++;
cin >> u >> v;
ptich(v, d);
cout << get(v, u) << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
do_it();
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, c, ans;
scanf("%I64d%I64d%I64d", &a, &b, &c);
ans = a + b + c - 1;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100006];
vector<int> located[100006];
int parent[100006], level[100006], visited[100006];
int ancestor[100006][18];
vector<int> st[100006][18];
void dfs(int u) {
visited[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (visited[v] == 0) {
parent[v] = u;
level[v] = level[u] + 1;
dfs(v);
}
}
}
void merge(vector<int>& a, vector<int>& b) {
vector<int> tmp;
int cnt = 0;
int l1 = a.size(), l2 = b.size();
int i = 0, j = 0;
while (i < l1 && j < l2 && cnt < 10) {
if (a[i] < b[j])
tmp.push_back(a[i++]);
else
tmp.push_back(b[j++]);
cnt++;
}
while (i < l1 && cnt < 10) {
tmp.push_back(a[i++]);
cnt++;
}
while (j < l2 && cnt < 10) {
tmp.push_back(b[j++]);
cnt++;
}
a.clear();
for (i = 0; i < cnt; i++) a.push_back(tmp[i]);
}
int main() {
int tc = 1;
for (int t = 1; t <= tc; t++) {
int n, m, q;
scanf("%d", &(n));
scanf("%d", &(m));
scanf("%d", &(q));
for (int j = 1; j < 18; j++) {
for (int i = 1; i <= n; i++) {
ancestor[i][j] = -1;
}
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &(u));
scanf("%d", &(v));
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= m; i++) {
int tmp;
scanf("%d", &(tmp));
located[tmp].push_back(i);
}
for (int i = 1; i <= n; i++) sort(located[i].begin(), located[i].end());
parent[1] = -1;
level[1] = 1;
dfs(1);
for (int i = 1; i <= n; i++) ancestor[i][0] = parent[i];
for (int j = 1; j < 18; j++) {
for (int i = 1; i <= n; i++) {
if (ancestor[i][j - 1] != -1)
ancestor[i][j] = ancestor[ancestor[i][j - 1]][j - 1];
}
}
for (int i = 1; i <= n; i++) {
st[i][0] = located[i];
vector<int> vi;
merge(st[i][0], vi);
}
for (int j = 1; j < 18; j++) {
for (int i = 1; i <= n; i++) {
st[i][j] = st[i][j - 1];
if (ancestor[i][j - 1] == -1) continue;
merge(st[i][j], st[ancestor[i][j - 1]][j - 1]);
}
}
while (q--) {
int u, v, a;
scanf("%d", &(u));
scanf("%d", &(v));
scanf("%d", &(a));
if (level[u] < level[v]) {
int tmp = u;
u = v;
v = tmp;
}
vector<int> tmp;
for (int j = 17; j >= 0; j--) {
if (ancestor[u][j] != -1 && level[ancestor[u][j]] >= level[v]) {
merge(tmp, st[u][j]);
u = ancestor[u][j];
}
}
if (u != v) {
for (int j = 17; j >= 0; j--) {
if (ancestor[u][j] != -1 && ancestor[u][j] != ancestor[v][j]) {
merge(tmp, st[u][j]);
merge(tmp, st[v][j]);
u = ancestor[u][j];
v = ancestor[v][j];
}
}
merge(tmp, st[u][0]);
merge(tmp, st[v][0]);
u = parent[u];
v = parent[v];
}
merge(tmp, st[u][0]);
int cnt = 0;
int len = tmp.size();
cout << min(a, len);
for (int it = 0; it < tmp.size() && cnt < a; it++, cnt++) {
printf(" ");
printf("%d", (tmp[it]));
}
printf("\n");
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long MOD = 1e9 + 7;
const long long EPS = 1e-9;
const long long N = 1005;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
if (k > (n - k + 1)) {
k = n - k + 1;
}
long long ans = 0;
ans += 2;
ans += (1 + 1 + 1 + 1);
ans += (k - 2) * (3);
if (k < n) {
ans += (k - 1);
}
ans += (n - k) * (3);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int n, target[N], pre[N], last[N], tot = 0;
void add(int u, int v) {
target[++tot] = v;
pre[tot] = last[u];
last[u] = tot;
}
int dep[N];
void dfs(int u, int fa) {
for (int ptr = last[u]; ptr; ptr = pre[ptr]) {
if (target[ptr] == fa) continue;
dep[target[ptr]] = dep[u] + 1;
dfs(target[ptr], u);
}
}
bool vis[N];
int ans = 0;
priority_queue<pair<int, int> > pq;
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n - 1); ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
for (int i = (1); i <= (n); ++i) {
if (dep[i] > 2) pq.push(make_pair(dep[i], i));
}
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int ptr = last[u]; ptr; ptr = pre[ptr]) {
vis[target[ptr]] = 1;
for (int ptt = last[target[ptr]]; ptt; ptt = pre[ptt]) {
vis[target[ptt]] = 1;
}
}
++ans;
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q;
cin >> q;
while (q--) {
long long int n;
cin >> n;
long long int i;
long long int a[n];
long double sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
long double z;
z = sum / (long double)n;
long long int k;
k = ceil(z);
cout << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sum[100][100];
int g[100][100];
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> g[i][j];
sum[i][j] = g[i][j] + sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
}
cin >> a >> b;
int mn = 50000;
for (int i = a; i <= n; i++) {
for (int j = b; j <= m; j++)
mn = min(mn,
sum[i][j] + sum[i - a][j - b] - sum[i][j - b] - sum[i - a][j]);
}
for (int i = b; i <= n; i++) {
for (int j = a; j <= m; j++)
mn = min(mn,
sum[i][j] + sum[i - b][j - a] - sum[i][j - a] - sum[i - b][j]);
}
cout << mn << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int qr() {
int ret = 0, f = 0, c = getchar();
while (!isdigit(c)) f |= c == 45, c = getchar();
while (isdigit(c)) ret = ret * 10 + c - 48, c = getchar();
return f ? -ret : ret;
}
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
int r[maxn], siz[maxn], stk[maxn], top, n, m, cnt_odd;
int Find(int x) { return x == r[x] ? x : Find(r[x]); }
int Merge(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return 0;
if (siz[x] > siz[y]) swap(x, y);
cnt_odd -= siz[x] & 1;
cnt_odd -= siz[y] & 1;
r[x] = y;
siz[y] += siz[x];
stk[++top] = x;
cnt_odd += siz[y] & 1;
return 1;
}
void Undo(int x = 1e8) {
while (x--) {
int u = stk[top], v = r[u];
cnt_odd -= siz[v] & 1;
siz[v] -= siz[u];
cnt_odd += siz[v] & 1;
cnt_odd += siz[u] & 1;
r[u] = u;
top--;
}
}
int ans[maxn * 3];
struct E {
int u, v, w;
} e[maxn * 3];
map<int, vector<int>> C;
void solve(int l, int r, int L, int R) {
if (L > R) return;
int base = 0, sav = 0, sav1 = 0, ret = R;
for (int t = l; t <= ((l + r) >> 1); ++t)
if (e[t].w < L) base += Merge(e[t].u, e[t].v);
for (auto it = C.lower_bound(L), ed = C.upper_bound(R); it != ed; ++it)
for (auto t : it->second)
if (t <= ((l + r) >> 1)) {
if (cnt_odd) sav += Merge(e[t].u, e[t].v);
if (!cnt_odd) {
ret = e[t].w;
goto nxt;
}
}
nxt:;
ans[((l + r) >> 1)] = ret;
Undo(sav);
if (((l + r) >> 1) < r) solve(((l + r) >> 1) + 1, r, L, ret);
Undo(base);
for (auto it = C.lower_bound(L), ed = C.lower_bound(ret); it != ed; ++it)
for (auto t : it->second)
if (t < l) sav1 += Merge(e[t].u, e[t].v);
if (l < ((l + r) >> 1)) solve(l, ((l + r) >> 1) - 1, ret, R);
Undo(sav1);
}
int main() {
memset(ans, 0x3f, sizeof ans);
n = qr(), m = qr();
for (int t = 1; t <= n; ++t) r[t] = t, siz[t] = 1;
cnt_odd = n;
for (int t = 1; t <= m; ++t)
e[t].u = qr(), e[t].v = qr(), e[t].w = qr(), C[e[t].w].push_back(t);
solve(1, m, 1, inf);
for (int t = 1; t <= m; ++t) printf("%d\n", ans[t] == inf ? -1 : ans[t]);
return 0;
}
| 22 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for(int i=(a); i<(n); ++i)
#define per(i, a, n) for(int i=(a); i>(n); --i)
#define pb emplace_back
#define mp make_pair
#define clr(a, b) memset(a, b, sizeof(a))
#define all(x) (x).begin(),(x).end()
#define lowbit(x) (x & -x)
#define fi first
#define se second
#define lson o<<1
#define rson o<<1|1
#define gmid l[o]+r[o]>>1
using LL = long long;
using ULL = unsigned long long;
using pii = pair<int,int>;
using PLL = pair<LL, LL>;
using UI = unsigned int;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int N = 5010;
int T, n, a[N], b[N];
LL dp[2][N], mx[N], g[N];
int main(){
LL ans, cur;
scanf("%d", &T);
while(T--){
scanf("%d", &n);
rep(i, 1, n+1) scanf("%d", a+i);
rep(i, 1, n+1) scanf("%d", b+i);
if(n == 1){
puts("0");
continue;
}
rep(i, 0, n+1){
dp[0][i] = dp[1][i] = -1;
g[i] = -1;
}
ans = 0;
rep(i, 1, n+1){
rep(j, 1, n+1) dp[1][j] = -1;
dp[1][i] = 0;
mx[i] = 0;
if(i == 1){
swap(dp[0], dp[1]);
continue;
}
per(j, i-1, 0){
if(a[i] != a[j]){
dp[1][j] = max(dp[1][j], mx[j] + abs(b[j] - b[i]));
if(j < i - 1) dp[1][j] = max(dp[1][j], g[j] + abs(b[j] - b[i]));
}
}
swap(dp[0], dp[1]);
rep(j, 1, i) mx[i] = max(mx[i], dp[0][j]);
ans = max(ans, mx[i]);
cur = dp[0][i];
per(j, i-1, 0){
if(a[i] != a[j]){
g[j] = max(g[j], cur + abs(b[i] - b[j]));
ans = max(ans, g[j]);
}
cur = max(cur, dp[0][j]);
}
}
printf("%lld\n", ans);
}
return 0;
} | 17 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int mod(long long int x) { return (x % MOD + MOD) % MOD; }
long long int pow1(long long int x, long long int y) {
if (y == 0) {
return 1;
}
long long int t = pow1(x, y / 2);
if (y % 2 == 0) {
return mod(t * t);
} else {
return mod(x * mod(t * t));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int x, n;
cin >> x >> n;
vector<long long int> primes;
long long int tt = x;
for (long long int i = 2; i * i <= x; i++) {
if (tt % i == 0) {
primes.push_back(i);
while (tt > 1 && tt % i == 0) {
tt /= i;
}
}
if (tt == 1) {
break;
}
}
if (tt > 1) {
primes.push_back(tt);
}
long long int ans = 1;
for (long long int i = 0; i < primes.size(); i++) {
long long int p = primes[i];
long long int z = 0;
while (p <= n) {
z += n / p;
if (p > n / primes[i]) {
break;
}
p *= primes[i];
}
long long int x = pow1(primes[i], z);
ans = mod(ans * x);
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265358979323846264338327950288419716939937510;
int n, x;
vector<long double> r;
long double res;
double sq(long double r) { return Pi * r * r; }
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> x;
r.push_back(x);
}
r.push_back(0);
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
for (int i = 0; i < r.size(); i += 2) {
res += sq(r[i]) - sq(r[i + 1]);
}
cout.precision(24);
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long Com(long long n, long long r) {
if (r < 0 || r > n) return 0;
long long res = 1, i = 0;
while (i < r) ++i, res *= n - i + 1, res /= i;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, t, f, s;
long long ans = 0;
cin >> n >> m >> t;
f = t - 1;
s = 1;
while (f >= 4 && s <= m) {
ans += Com(n, f) * Com(m, s);
f--;
s++;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
unsigned long long ans = 1, sum = 0, num = 0;
cin >> num;
for (long long i = 2; i <= num; i++) {
ans *= i;
}
sum = (num * (num / 2));
cout << ans / sum << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct event {
int y, i, type;
event() {}
event(int y, int i, int type) : y(y), i(i), type(type) {}
bool operator<(const event &e) const {
if (y != e.y) return y > e.y;
return type < e.type;
}
};
struct seg {
int mx, l, r, f;
seg() {}
seg(int mx, int l, int r, int f) : mx(mx), l(l), r(r), f(f) {}
};
int n, h[100010], m;
int ql[100010], qr[100010], qw[100010];
int lo[100010], hi[100010];
vector<event> e;
seg s[4 * 100010];
seg merge(seg &l, seg &r) {
int mx = max(max(l.mx, r.mx), l.r + r.l);
int ll = l.l + (l.f ? r.l : 0);
int rr = r.r + (r.f ? l.r : 0);
int ff = l.f && r.f;
return seg(mx, ll, rr, ff);
}
void update(int i, int l, int r, int pos) {
if (l > pos || r < pos) return;
if (l == r) {
s[i].mx = s[i].l = s[i].r = s[i].f = 1;
return;
}
int mid = (l + r) / 2;
update(2 * i, l, mid, pos);
update(2 * i + 1, mid + 1, r, pos);
s[i] = merge(s[2 * i], s[2 * i + 1]);
}
seg query(int i, int l, int r, int ll, int rr) {
if (l > rr || r < ll) return seg();
if (l >= ll && r <= rr) return s[i];
int mid = (l + r) / 2;
seg sl = query(2 * i, l, mid, ll, rr);
seg sr = query(2 * i + 1, mid + 1, r, ll, rr);
if (mid < ll) return sr;
if (mid >= rr) return sl;
return merge(sl, sr);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", h + i);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", ql + i, qr + i, qw + i);
hi[i] = 1000000005;
}
while (1) {
e.clear();
for (int i = 1; i <= n; i++) e.push_back(event(h[i], i, 0));
bool done = 1;
for (int i = 1; i <= m; i++) {
if (hi[i] - lo[i] > 1) {
done = 0;
e.push_back(event((lo[i] + hi[i]) / 2, i, 1));
}
}
if (done) break;
sort(e.begin(), e.end());
memset(s, 0, sizeof(s));
for (int i = 0; i < e.size(); i++) {
if (e[i].type == 0) {
update(1, 1, n, e[i].i);
} else {
int l = ql[e[i].i];
int r = qr[e[i].i];
if (query(1, 1, n, l, r).mx >= qw[e[i].i])
lo[e[i].i] = e[i].y;
else
hi[e[i].i] = e[i].y;
}
}
}
for (int i = 1; i <= m; i++) printf("%d\n", lo[i]);
}
| 17 |
#include<bits/stdc++.h>
using namespace std;
int read(){
int a = 0; char c = getchar(); bool f = 0; while(!isdigit(c)){f = c == '-'; c = getchar();}
while(isdigit(c)){a = a * 10 + c - 48; c = getchar();} return f ? -a : a;
}
int cnt[23] , l[23] , r[23] , T , N , A , B , pos[23];
string s , alphabet = "acdefhijklmnopqsvwxz" , str , ans;
int f[1 << 20] , g[1 << 20];
int qf(int); int qg(int);
int qg(int x){
if(~g[x]) return g[x];
if(!x) return 1;
int pre = 0 , suf = x;
for(int i = 0 ; i < str.size() ; ++i)
if(x >> i & 1){pre |= 1 << i; suf ^= 1 << i; if(qf(pre) && qg(suf)) return g[x] = 1;}
return g[x] = 0;
}
int qf(int x){
if(~f[x]) return f[x];
if(!x) return 1;
int l = 1e9 , r = 0 , c = 0;
for(int i = 0 ; i < str.size() ; ++i)
if(x >> i & 1){l = min(l , ::l[pos[i]]); r = max(r , ::r[pos[i]]); c += cnt[pos[i]];}
if(1ll * c * B < 1ll * (r - l + 1) * A) return f[x] = 0;
for(int i = 0 ; i < str.size() ; ++i) if((x >> i & 1) && qg(x ^ (1 << i))) return f[x] = 1;
return f[x] = 0;
}
int main(){
cin >> N >> A >> B >> s; memset(l , -1 , sizeof(l)); memset(f , -1 , sizeof(f)); memset(g , -1 , sizeof(g));
for(int i = 0 ; i < s.size() ; ++i){
int pos = 0; while(alphabet[pos] != s[i]){++pos;}
if(!(cnt[pos]++)){::pos[str.size()] = pos; l[pos] = i; str.push_back(s[i]);} r[pos] = i;
}
for(int i = 0 ; i < str.size() ; ++i)
if(qg((1 << str.size()) - 1 - (1 << i))) ans.push_back(str[i]);
sort(ans.begin() , ans.end()); cout << ans.size(); for(auto t : ans){cout << ' ' << t;} return 0;
} | 27 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const int DIRX[] = {-1, 0, 0, 1, -1, -1, 1, 1},
DIRY[] = {0, -1, 1, 0, -1, 1, -1, 1};
const double ERR = 1e-9, PI = (2 * acos(0.0));
template <class T>
inline int size(T& t) {
return (int)t.size();
}
template <class T>
inline T MIN(T a, T b) {
return ((a < b) ? a : b);
}
template <class T>
inline T MAX(T a, T b) {
return ((b < a) ? a : b);
}
template <class T>
inline void checkMIN(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMAX(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline T sqr(T x) {
return (x * x);
}
int compareDouble(double x, double y) {
double d = x - y;
if (d > ERR) return 1;
if (d < -ERR) return -1;
return 0;
}
int compareDouble(double x, double y, double err) {
double d = x - y;
if (d > err) return 1;
if (d < -err) return -1;
return 0;
}
int main() {
int i, n, C, x;
double L = 1, H = INF, tem;
cin >> n;
C = 0;
for (i = 0; i < (int)(n); i++) {
cin >> x;
C++;
tem = (double)x / C;
if (compareDouble(L, tem) < 0) L = tem;
tem = (double)(x + 1) / C;
if (compareDouble(H, tem) > 0) H = tem;
}
long long lo = (long long)floor(L * (C + 1));
long long hi = (long long)ceil(H * (C + 1)) - 1;
if (lo == hi) {
cout << "unique" << endl;
printf("%I64d", lo);
} else {
cout << "not unique";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using ll = long long;
int main() {
int n;
std::cin >> n;
std::vector<int> v{
0b1, 0b110, 0b11100, 0b1111000,
0b111110000, 0b11111100000, 0b1111111000000, 0b111111110000000,
};
for (size_t i{v.size()}; 0 < i--;) {
if (n % v[i] == 0) {
std::cout << v[i] << std::endl;
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, apple, money, i;
string s[51];
int main() {
cin >> n >> m;
m /= 2;
for (i = 1; i <= n; i++) cin >> s[i];
for (i = n; i >= 1; i--) {
apple *= 2;
if (s[i] == "halfplus") apple++;
money += apple;
}
money *= m;
cout << money;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int p[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
int factormask[59], dp[101][66000], b[101][66000];
vector<int> b_out;
int N;
int a[101];
void factor() {
memset(dp, -1, sizeof dp);
for (int j = 2; j < 59; j++) {
int mask = 0;
for (int i = 0; i < 16; i++)
if (j % p[i] == 0) mask += (1 << i);
factormask[j] = mask;
}
}
int calc(int i, int mask) {
if (i == -1) return 0;
if (dp[i][mask] != -1) return dp[i][mask];
int res = abs(a[i] - 1) + calc(i - 1, mask);
b[i][mask] = 1;
for (int j = 2; j < 59; j++) {
if ((mask & factormask[j]) != factormask[j]) continue;
int cur = abs(a[i] - j) + calc(i - 1, mask ^ factormask[j]);
if (cur < res) {
res = cur;
b[i][mask] = j;
}
}
return dp[i][mask] = res;
}
void build_out() {
factor();
calc(N - 1, (1 << 16) - 1);
int mask = (1 << 16) - 1;
for (int j = N - 1; j >= 0; j--) {
b_out.push_back(b[j][mask]);
mask ^= factormask[b[j][mask]];
}
for (int j = N - 1; j >= 0; j--) cout << b_out[j] << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N;
for (int j = 0; j < N; j++) cin >> a[j];
build_out();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int p[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int c[n];
for (int i = 0; i < n; i++) {
cin >> c[i];
}
if (k == 0) {
for (int i = 0; i < n; i++) {
cout << c[i] << " ";
}
return (0);
}
vector<pair<int, int> > v;
vector<pair<int, int> > w;
for (int i = 0; i < n; i++) {
v.push_back(make_pair(p[i], c[i]));
w.push_back(make_pair(p[i], i));
}
sort(v.begin(), v.end());
sort(w.begin(), w.end());
priority_queue<long long, vector<long long>, greater<long long> > pq;
long long ans[n];
ans[w[0].second] = v[0].second;
pq.push(v[0].second);
long long sum = v[0].second;
for (int i = 1; i < n; i++) {
if (pq.size() < k) {
ans[w[i].second] = sum + v[i].second;
pq.push(v[i].second);
sum += v[i].second;
} else {
ans[w[i].second] = sum + v[i].second;
long long x = pq.top();
if (v[i].second > x) {
pq.pop();
pq.push(v[i].second);
sum += (v[i].second - x);
}
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void wait(double seconds) {
double endtime = clock() + (seconds * CLOCKS_PER_SEC);
while (clock() < endtime) {
;
}
}
template <class T>
inline T fastIn() {
register char c = 0;
register T a = 0;
bool neg = false;
while (c < 33) c = getchar();
while (c > 33) {
if (c == '-') {
neg = true;
} else {
a = (a * 10) + (c - '0');
}
c = getchar();
}
return neg ? -a : a;
}
string s1, s2;
string s3;
int l1, l2, l3;
inline void read() {
cin >> s1 >> s2;
cin >> s3;
l1 = (int)(s1).length(), l2 = (int)(s2).length(), l3 = (int)(s3).length();
}
int const mxn = 200;
int pi[mxn];
inline void prefix_function(string const s) {
int n = (int)(s).length();
memset(pi, 0, sizeof(pi));
for (int i = 1; i < n; ++i) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) {
j = pi[j - 1];
}
if (s[i] == s[j]) {
++j;
}
pi[i] = j;
}
return;
}
int aut[mxn][30];
inline void kmp_autometa(string const s) {
memset(aut, 0, sizeof(aut));
prefix_function(s + "[");
int n = (int)(s).length();
for (int i = 0; i < n; ++i) {
for (char c = 'A'; c <= '['; ++c) {
if (i > 0 && c != s[i]) {
aut[i][c - 'A'] = aut[pi[i - 1]][c - 'A'];
} else {
aut[i][c - 'A'] = i + (c == s[i]);
}
}
}
}
int dp[mxn][mxn][mxn];
bool seen[mxn][mxn][mxn];
int const inf = 1023456789;
int go(int a, int b, int c) {
if (c >= l3) return -inf;
if (a >= l1 || b >= l2) {
return 0;
}
int bst = 0;
if (seen[a][b][c]) return dp[a][b][c];
seen[a][b][c] = true;
int v1 = go(a + 1, b, c);
bst = max(bst, v1);
int v2 = go(a, b + 1, c);
bst = max(bst, v2);
if (s1[a] == s2[b]) {
int const nxt_c = aut[c][s1[a] - 'A'];
int const v3 = go(a + 1, b + 1, nxt_c) + 1;
bst = max(bst, v3);
}
return dp[a][b][c] = bst;
}
void bk(int a, int b, int c, int retval) {
if (c >= l3) return;
if (a >= l1 || b >= l2) return;
int v1 = go(a + 1, b, c);
if (v1 == retval) {
bk(a + 1, b, c, retval);
return;
}
int v2 = go(a, b + 1, c);
if (v2 == retval) {
bk(a, b + 1, c, retval);
return;
}
if (s1[a] == s2[b]) {
int const nxt_c = aut[c][s1[a] - 'A'];
int const v3 = go(a + 1, b + 1, nxt_c) + 1;
if (v3 == retval) {
cout << s1[a];
bk(a + 1, b + 1, nxt_c, retval - 1);
return;
}
}
return;
}
inline void proc() {
memset(seen, false, sizeof(seen));
kmp_autometa(s3);
int retval = go(0, 0, 0);
retval = max(retval, 0);
if (!retval) {
cout << 0 << "\n";
return;
}
bk(0, 0, 0, retval);
puts("");
}
int main() {
int kase = 1;
for (int i = 0, j1 = kase; i < j1; ++i) {
read();
proc();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char s[1000000];
int main() {
int N;
scanf("%d%s", &N, &s);
int a = 0;
int f = 0;
int i = 0;
for (int j = 0; j < N; j++) {
if (s[j] == 'A') a++;
if (s[j] == 'I') i++;
if (s[j] == 'F') f++;
}
int res = 0;
for (int j = 0; j < N; j++)
if ((s[j] == 'A' && i == 0) || (i == 1 && s[j] == 'I')) res++;
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char i = getchar();
long long f = 1, res = 0;
while (i < '0' || i > '9') {
if (i == '-') f = -1;
i = getchar();
}
while (i >= '0' && i <= '9') {
res = res * 10 + i - '0';
i = getchar();
}
return res * f;
}
const int N = 2e5 + 50;
int n, m, cnt, head[N], f[N][21], vis[N], c[N], dep[N], S;
vector<int> path;
struct zk {
int next, v;
} ed[N << 1];
inline void adde(int u, int v) {
ed[++cnt].v = v;
ed[cnt].next = head[u];
head[u] = cnt;
}
inline void rebuild(int u, int fa) {
vis[u] = 1;
for (int i = head[u]; ~i; i = ed[i].next) {
int v = ed[i].v;
if (v == f[u][0]) continue;
if (!vis[v]) {
dep[v] = dep[u] + 1;
f[v][0] = u;
rebuild(v, u);
} else if (dep[v] < dep[u]) {
c[v]--;
c[u]++;
}
}
c[f[u][0]] += c[u];
}
int l1, l2, r1, r2;
inline void dfs(int u) {
for (int i = head[u]; ~i; i = ed[i].next) {
int v = ed[i].v;
if (v == f[u][0]) continue;
if (dep[v] == dep[u] + 1) {
dfs(v);
if (l2) return;
} else if (dep[v] < dep[S]) {
if (l1)
r2 = u, l2 = v;
else
r1 = u, l1 = v;
if (l2) return;
}
}
}
inline int LCA(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
int h = dep[b] - dep[a];
for (int i = 20; i >= 0; --i) {
if (h & (1 << i)) b = f[b][i];
}
if (a == b) return a;
for (int i = 20; i >= 0; --i) {
if (f[a][i] == f[b][i]) continue;
a = f[a][i];
b = f[b][i];
}
return f[a][0];
}
int main() {
memset(head, -1, sizeof head);
n = read();
m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
adde(u, v);
adde(v, u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) rebuild(i, 0);
}
S = 0;
for (int i = 1; i <= n; ++i) {
if (c[i] > 1) {
S = i;
break;
}
}
if (!S) {
puts("NO");
return 0;
}
puts("YES");
dfs(S);
for (int j = 1; j < 21; ++j) {
for (int i = 1; i <= n; ++i) f[i][j] = f[f[i][j - 1]][j - 1];
}
int T = LCA(r1, r2);
if (dep[l1] < dep[l2]) swap(l1, l2), swap(r1, r2);
S = l1;
int now = T;
while (1) {
path.push_back(now);
if (now == S) break;
now = f[now][0];
}
int sz = path.size();
printf("%d ", sz);
for (int i = 0; i < sz; ++i) printf("%d ", path[i]);
puts("");
path.clear();
path.push_back(S);
now = r1;
while (1) {
path.push_back(now);
if (now == T) break;
now = f[now][0];
}
sz = path.size();
printf("%d ", sz);
for (int i = sz - 1; i >= 0; --i) printf("%d ", path[i]);
puts("");
path.clear();
if (S == l2) {
path.push_back(S);
now = r2;
while (1) {
path.push_back(now);
if (now == T) break;
now = f[now][0];
}
} else {
now = S;
while (1) {
path.push_back(now);
if (now == l2) break;
now = f[now][0];
}
now = r2;
while (1) {
path.push_back(now);
if (now == T) break;
now = f[now][0];
}
}
sz = path.size();
printf("%d ", sz);
for (int i = sz - 1; i >= 0; --i) printf("%d ", path[i]);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
cin >> n;
int a[10005][2];
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
}
for (int i = 0; i < n; i++) {
for (int j = (i + 1); j < n; j++) {
for (int k = (j + 1); k < n; k++) {
int total =
(a[i][0] * (a[j][1] - a[k][1]) - a[i][1] * (a[j][0] - a[k][0]) +
(a[j][0] * a[k][1] - a[j][1] * a[k][0]));
if (abs(total) > 0) count++;
}
}
}
printf("%d", count);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> a >> b;
string prawdopodobienstwo[7] = {"0/0", "1/1", "5/6", "2/3",
"1/2", "1/3", "1/6"};
cout << prawdopodobienstwo[max(a, b)];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
ll n, m, x, y, cost = 0;
cin >> n >> m >> x >> y;
char ar[n][m];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) cin >> ar[i][j];
}
if (m == 1) {
for (ll i = 0; i < n; i++) {
if (ar[i][0] == '.') cost += x;
}
} else {
if (2 * x > y) {
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
if (ar[i][j] == '.') {
if (j + 1 < m && ar[i][j + 1] == '.')
cost += y;
else
cost += x;
j++;
}
}
}
} else {
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
if (ar[i][j] == '.') cost += x;
}
}
}
}
cout << cost << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
int win[2][7000];
int lose[2][7000];
int main() {
const int n = getInt();
vector<vector<int> > v(2);
for (int i = 0; i < (int)(2); i++) {
const int k = getInt();
v[i] = vector<int>(k);
for (int j = 0; j < (int)(k); j++) v[i][j] = getInt();
}
queue<pair<int, int> > winQ;
queue<pair<int, int> > loseQ;
const auto addWin = [&](int p, int pos) {
if (pos == 0) return;
if (win[p][pos] == 0) {
win[p][pos] = 1;
winQ.push(make_pair(p, pos));
}
};
const auto addLose = [&](int p, int pos) {
if (pos == 0) return;
if (++lose[p][pos] == (int)v[p].size()) {
loseQ.push(make_pair(p, pos));
}
};
for (int i = 0; i < (int)(2); i++) {
for (int j = 0; j < (int)(v[i].size()); j++) {
addWin(i, n - v[i][j]);
}
}
while (winQ.size()) {
while (winQ.size()) {
const auto d = winQ.front();
winQ.pop();
const int p = d.first;
const int pos = d.second;
for (int t : v[!p]) addLose(!p, (pos - t + n) % n);
}
while (loseQ.size()) {
const auto d = loseQ.front();
loseQ.pop();
const int p = d.first;
const int pos = d.second;
for (int t : v[!p]) addWin(!p, (pos - t + n) % n);
}
}
for (int i = 0; i < (int)(2); i++) {
for (int j = 0; j < (int)(n - 1); j++) {
if (win[i][j + 1])
printf("Win");
else if (lose[i][j + 1] == (int)v[i].size())
printf("Lose");
else
printf("Loop");
if (j == n - 2)
puts("");
else
printf(" ");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 10005;
const double EPS = 1e-8;
struct Point {
double x, y;
};
Point operator+(Point a, Point b) {
a.x += b.x;
a.y += b.y;
return a;
}
Point operator*(Point a, double k) {
a.x *= k;
a.y *= k;
return a;
}
Point operator-(Point a, Point b) {
a.x -= b.x;
a.y -= b.y;
return a;
}
void Read(Point& p) {
int x, y;
ignore = scanf("%d %d", &x, &y);
p.x = x;
p.y = y;
}
double cp(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double dist(Point p, Point v, Point q) { return (cp(p, v) - cp(q, v)); }
Point intersect(Point p, Point v, Point q, Point u) {
double T = (cp(p, v) - cp(q, v)) / cp(u, v);
return q + u * T;
}
Point p[2 * MX];
int n;
double S[2 * MX];
double Calc(Point q, double alpha) {
Point v = {cos(alpha), sin(alpha)};
int low, high;
{
if (dist(q, v, p[0]) >= dist(q, v, p[n - 1])) {
high = 0;
} else {
high = n - 1;
}
int L = 0, R = n - 2;
while (L <= R) {
int M = (L + R) / 2;
bool good;
if (dist(q, v, p[0]) >= dist(q, v, p[n - 1])) {
good = (dist(q, v, p[M + 1]) >= dist(q, v, p[M]) &&
dist(q, v, p[M + 1]) >= dist(q, v, p[0]));
} else {
good = (dist(q, v, p[M + 1]) >= dist(q, v, p[M]) ||
dist(q, v, p[M + 1]) <= dist(q, v, p[0]));
}
if (good) {
L = M + 1;
high = M + 1;
} else {
R = M - 1;
}
}
}
{
if (dist(q, v, p[0]) <= dist(q, v, p[n - 1])) {
low = 0;
} else {
low = n - 1;
}
int L = 0, R = n - 2;
while (L <= R) {
int M = (L + R) / 2;
bool good;
if (dist(q, v, p[0]) <= dist(q, v, p[n - 1])) {
good = (dist(q, v, p[M + 1]) <= dist(q, v, p[M]) &&
dist(q, v, p[M + 1]) <= dist(q, v, p[0]));
} else {
good = (dist(q, v, p[M + 1]) <= dist(q, v, p[M]) ||
dist(q, v, p[M + 1]) >= dist(q, v, p[0]));
}
if (good) {
L = M + 1;
low = M + 1;
} else {
R = M - 1;
}
}
}
int left, right;
{
int L = low, R = high;
if (R < L) R += n;
left = L;
while (L <= R) {
int M = (L + R) / 2;
if (dist(q, v, p[M]) <= 0) {
left = M;
L = M + 1;
} else {
R = M - 1;
}
}
}
{
int L = high, R = low;
if (R < L) R += n;
right = L;
while (L <= R) {
int M = (L + R) / 2;
if (dist(q, v, p[M]) >= 0) {
right = M;
L = M + 1;
} else {
R = M - 1;
}
}
}
if (left >= n) left -= n;
if (right >= n) right -= n;
if (right < left) right += n;
double res = S[right] - S[left + 1];
Point p0 = intersect(q, v, p[left], p[left + 1] - p[left]);
Point p1 = intersect(q, v, p[right], p[right + 1] - p[right]);
res += cp(p[right], p1);
res += cp(p1, p0);
res += cp(p0, p[left + 1]);
return res;
}
int main() {
int q;
ignore = scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) Read(p[i]);
reverse(p, p + n);
for (int i = 0; i < n; i++) {
p[i + n] = p[i];
}
for (int i = 1; i < 2 * n; i++) {
S[i] = S[i - 1] + cp(p[i - 1], p[i]);
}
double total = S[n];
while (q--) {
Point P;
Read(P);
double L = 0, R = acos(-1);
double tmp = Calc(P, 0);
if (abs(total - 2 * tmp) < EPS) {
printf("%.15lf\n", 0.0);
continue;
}
bool left_above = (total - 2 * tmp > 0);
for (int rep = 0; rep < 60; rep++) {
double M = (L + R) / 2;
tmp = Calc(P, M);
if (abs(total - 2 * tmp) < EPS) break;
bool above = (total - 2 * tmp > 0);
if (above == left_above) {
L = M;
} else {
R = M;
}
}
printf("%.15lf\n", (L + R) / 2);
}
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 11;
int dp[maxn];
int n, ans;
string a, b;
bool yes(int i, int j) {
bool ok = 1;
ok &= a[i] != b[i];
ok &= a[j] != b[j];
ok &= a[i] != a[j];
return ok;
}
void go() {
for (int i = 0; i < n; i++) {
ans++;
if (i and yes(i - 1, i))
swap(a[i - 1], a[i]);
else if (i < n - 1 and yes(i, i + 1))
swap(a[i], a[i + 1]);
else
ans--;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> a >> b;
for (int i = 0; i < 10; i++) go();
for (int i = 0; i < n; i++) ans += a[i] != b[i];
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
inline long long int add(long long int p, long long int q) {
return p + q >= mod ? p + q - mod : p + q;
}
inline long long int sub(long long int p, long long int q) {
return p - q < 0 ? p - q + mod : p - q;
}
inline long long int mul(long long int p, long long int q) {
return p * q % mod;
}
string s, p;
int sl, pl;
int f[(int)1e5 + 5];
bool ok[(int)1e5 + 5];
void fail() {
f[0] = -1;
int k = -1;
for (int i = 1; i < pl; i++) {
while (k >= 0 && p[k + 1] != p[i]) k = f[k];
if (p[k + 1] == p[i]) k++;
f[i] = k;
}
}
void kmp() {
fail();
int k = -1;
for (int i = 0; i < sl; i++) {
while (k >= 0 && p[k + 1] != s[i]) k = f[k];
if (p[k + 1] == s[i]) k++;
if (k == pl - 1) {
ok[(i - pl + 1)] = true;
k = f[k];
}
}
}
long long int fromThis[112345];
long long int thisAndRest[112345];
long long int sumThisAndRest[112345];
int main() {
cin >> s >> p;
sl = s.length();
pl = p.length();
kmp();
int i = sl;
while (i >= 0 && ok[i] == false) {
fromThis[i] = 0;
thisAndRest[i] = 1;
sumThisAndRest[i] = add(sumThisAndRest[i + 1], thisAndRest[i]);
i--;
}
long long int neu = 0, last = sl + 1;
for (; i >= 0; i--) {
if (ok[i]) {
fromThis[i] = sumThisAndRest[i + pl];
} else {
fromThis[i] = neu;
}
thisAndRest[i] = add(thisAndRest[i + 1], fromThis[i]);
sumThisAndRest[i] = add(sumThisAndRest[i + 1], thisAndRest[i]);
if (ok[i]) {
neu = add(neu, sub(fromThis[i], sumThisAndRest[last]));
last = i + pl;
}
}
long long int ans = sub(thisAndRest[0], 1);
cout << ans << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
unsigned long long g = 1;
for (int a = 0; a < (3 * n); a++) {
g = (g * 3) % 1000000007;
}
unsigned long long k = 1;
for (int e = 0; e < n; e++) k = (k * 7) % 1000000007;
g = (g - k + 1000000007) % 1000000007;
cout << g % 1000000007;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
long double a[100005];
int N, U;
int search(long double x) {
int l = 0, r = N;
int m = 0;
while (l < r) {
m = (l + r) / 2;
if (x >= a[m]) {
l = m + 1;
} else
r = m;
}
if (N == l) return N - 1;
return l - 1;
}
int main() {
scanf("%d%d", &N, &U);
for (int i = 0; i < N; i++) cin >> a[i];
long double maxx = -100;
for (int i = 0; i < N - 2; i++) {
int j = search(a[i] + U);
if (j - i < 2) continue;
maxx = max(maxx, (a[j] - a[i + 1] * 1.0) / (a[j] * 1.0 - a[i]));
}
if (maxx == -100)
cout << -1 << endl;
else
printf("%.15Lf", maxx);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int i, j, k;
int n, m, q;
vector<int> v;
cin >> n >> k;
m = n / k;
bool used[100] = {};
int a[100];
for (i = (int)(0); i < (int)(n); i++) cin >> a[i];
cin >> q;
for (i = (int)(0); i < (int)(q); i++) {
bool b = false;
int ys[100], t = 0;
for (j = (int)(0); j < (int)(m); j++) cin >> ys[j], ys[j]--;
for (j = (int)(0); j < (int)(m); j++) {
b = used[ys[j]];
used[ys[j]] = true;
t += a[ys[j]];
}
if (!b) v.push_back(t);
}
if (v.size() < k) {
vector<int> ys;
for (i = (int)(0); i < (int)(n); i++)
if (!used[i]) ys.push_back(a[i]);
sort(ys.begin(), ys.end());
int s = 0, t = 0;
for (i = (int)(0); i < (int)(m); i++)
s += ys[i], t += ys[ys.size() - 1 - i];
v.push_back(s);
v.push_back(t);
}
sort(v.begin(), v.end());
double dv = m;
printf("%.10f %.10f\n", v[0] / dv, v[v.size() - 1] / dv);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int* dp1 = new int[n];
for (int i = 1; i < n; i++) dp1[i] = abs(arr[i - 1] - arr[i]);
long long* dp2 = new long long[n];
dp2[0] = 0;
for (int i = 1; i < n; i++) {
if (i % 2 == 1)
dp2[i] = dp2[i - 1] + dp1[i];
else
dp2[i] = dp2[i - 1] - dp1[i];
}
long long min = 0, max = -1;
for (int i = 1; i < n; i++) {
if (min > dp2[i]) min = dp2[i];
if (max < dp2[i]) max = dp2[i];
}
cout << abs(max - min);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2>& p) {
out << p.first << ' ' << p.second;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) in >> x;
return in;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto x : v) out << x << ' ';
return out;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
set<int> s;
cin >> n;
for (register int i = 0; i < n; i++) {
cin >> x;
if (x) s.insert(x);
}
cout << s.size();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, dis[110];
struct mat {
long long _[110][110];
int r, c;
} M, A, B, C, I;
mat operator*(mat &A, mat &B) {
memset(C._, 0, sizeof C._);
for (int i = 0; i <= 101; i++)
for (int j = 0; j <= 101; j++)
for (int k = 0; k <= 101; k++) {
long long tmp = A._[i][k] * B._[k][j];
if (tmp > 1000000007) tmp %= 1000000007;
C._[i][j] += tmp;
if (C._[i][j] > 1000000007) C._[i][j] %= 1000000007;
}
return C;
}
mat operator^(mat &A, int p) {
memset(I._, 0, sizeof I._);
for (int i = 0; i <= 101; i++) I._[i][i] = 1;
while (p) {
if (p & 1) I = I * A;
A = A * A;
p = p >> 1;
}
return I;
}
int val;
int main() {
scanf("%d %d", &n, &x);
for (int i = 1; i <= n; i++) scanf("%d", &val), dis[val]++;
for (int i = 0; i <= 98; i++) M._[i + 1][i] = 1;
for (int i = 0; i <= 99; i++) M._[i][99] = dis[100 - i];
M._[99][100] = 1;
M._[100][100] = 1;
M = M ^ (x + 1);
printf("%I64d\n", M._[99][100] % 1000000007);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string name1, name2, names[10001][2];
cin >> name1;
cin >> name2;
int n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
cin >> names[i][j];
}
}
cout << name1 << " " << name2 << "\n";
for (i = 0; i < n; i++) {
if (names[i][0] == name1) {
name1 = names[i][1];
cout << name1 << " " << name2 << "\n";
}
if (names[i][0] == name2) {
name2 = names[i][1];
cout << name1 << " " << name2 << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[101];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int p, y, n, i, j;
cin >> p >> y;
while (y > p) {
n = sqrt(y);
for (i = 2; i <= n; i++)
if (y % i == 0) break;
if (i == n + 1) {
cout << y;
return 0;
} else if (i > p) {
cout << y;
return 0;
}
y--;
}
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> KMP(string S, string K) {
vector<int> T(K.size() + 1, -1);
for (int i = 1; i <= K.size(); i++) {
int pos = T[i - 1];
while (pos != -1 && K[pos] != K[i - 1]) pos = T[pos];
T[i] = pos + 1;
}
vector<int> matches;
for (int sp = 0, kp = 0; sp < S.size(); sp++) {
while (kp != -1 && (kp == K.size() || K[kp] != S[sp])) kp = T[kp];
kp++;
if (kp == K.size()) matches.push_back(sp + 1 - K.size());
}
return matches;
}
string s, p, q;
pair<long long, long long> P[2000][2000];
int main() {
while (cin >> s >> p >> q) {
int n = s.size();
int A = p.size();
int B = q.size();
for (int i = 0; i < n; ++i) {
long long hash1 = 0, hash2 = 0;
for (int j = i; j < n; ++j) {
hash1 = (hash1 * 27 + s[j] - 'a' + 1) % 1000000007LL;
hash2 = (hash2 * 27 + s[j] - 'a' + 1) % 1000000009LL;
P[i][j] = make_pair(hash1, hash2);
}
}
vector<int> kmp1 = KMP(s, p);
vector<int> kmp2 = KMP(s, q);
vector<pair<long long, long long> > v;
int a = kmp1.size();
int b = kmp2.size();
for (int i = 0; i < a; ++i)
for (int j = 0; j < b; ++j)
if (kmp2[j] >= kmp1[i] && kmp2[j] + B >= kmp1[i] + A)
v.push_back(P[kmp1[i]][kmp2[j]]);
sort(v.begin(), v.end());
cout << (unique(v.begin(), v.end()) - v.begin()) << endl;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g1[3010], g2[3010];
struct query {
int st, k, id;
query(int _st = 0, int _k = 0, int _id = 0) : st(_st), k(_k), id(_id) {}
};
vector<query> op[3010];
int n, m, q;
bool vis[3010];
int nex[3010][13];
int ans[500100];
void dfs1(int u) {
vis[u] = true;
for (auto v : g2[u])
if (!vis[v]) dfs1(v);
}
int go(int st, int k) {
if (nex[st][12] || !vis[st]) return -1;
for (int i = 12; i >= 0; --i)
if (k >> i & 1) st = nex[st][i];
return st ? st : -1;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g1[u].push_back(v);
g2[v].push_back(u);
}
for (int i = 1; i <= q; ++i) {
int s, t, k;
scanf("%d%d%d", &s, &t, &k);
op[t].push_back(query(s, k - 1, i));
}
for (int i = 1; i <= n; ++i) {
sort(g1[i].begin(), g1[i].end());
sort(g2[i].begin(), g2[i].end());
}
for (int i = 1; i <= n; ++i) {
if (op[i].empty()) continue;
for (int j = 1; j <= n; ++j) vis[j] = false;
dfs1(i);
for (int j = 1; j <= n; ++j) {
if (i == j)
nex[j][0] = 0;
else {
nex[j][0] = 0;
for (auto v : g1[j])
if (vis[v]) {
nex[j][0] = v;
break;
}
}
}
for (int k = 1; k < 13; ++k)
for (int j = 1; j <= n; ++j) nex[j][k] = nex[nex[j][k - 1]][k - 1];
for (auto v : op[i]) ans[v.id] = go(v.st, v.k);
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
template <typename T, typename T2>
inline void _max(T &a, T2 b) {
a = max((T)a, (T)b);
}
template <typename T, typename T2>
inline void _min(T &a, T2 b) {
a = min((T)a, (T)b);
}
const int MAX = 3e5 + 10;
int n, m;
string s[MAX];
void clear() {}
void read() {
for (int i = 0; i < n; i++) cin >> s[i];
}
void solve() {
vector<char> v = {'A', 'C', 'T', 'G'};
sort(v.begin(), v.end());
int res = INF;
vector<char> best;
bool isHor = false;
do {
int tres = 0;
for (int i = 0; i < n; i++) {
vector<char> line = {v[i % 2], v[i % 2 + 2]};
int ts1 = 0, ts2 = 0;
for (int j = 0; j < m; j++) ts1 += line[j & 1] != s[i][j];
swap(line[0], line[1]);
for (int j = 0; j < m; j++) ts2 += line[j & 1] != s[i][j];
tres += min(ts1, ts2);
}
if (tres < res) {
res = tres;
best = v;
isHor = 1;
}
tres = 0;
for (int j = 0; j < m; j++) {
vector<char> line = {v[j % 2], v[j % 2 + 2]};
int ts1 = 0, ts2 = 0;
for (int i = 0; i < n; i++) ts1 += line[i & 1] != s[i][j];
swap(line[0], line[1]);
for (int i = 0; i < n; i++) ts2 += line[i & 1] != s[i][j];
tres += min(ts1, ts2);
}
if (tres < res) {
res = tres;
best = v;
isHor = 0;
}
} while (next_permutation(v.begin(), v.end()));
v = best;
vector<string> rs(n, string(m, '0'));
if (isHor) {
for (int i = 0; i < n; i++) {
vector<char> line = {v[i % 2], v[i % 2 + 2]};
int ts1 = 0, ts2 = 0;
for (int j = 0; j < m; j++) ts1 += line[j & 1] != s[i][j];
swap(line[0], line[1]);
for (int j = 0; j < m; j++) ts2 += line[j & 1] != s[i][j];
if (ts1 < ts2) swap(line[0], line[1]);
for (int j = 0; j < m; j++) rs[i][j] = line[j & 1];
}
} else {
for (int j = 0; j < m; j++) {
vector<char> line = {v[j % 2], v[j % 2 + 2]};
int ts1 = 0, ts2 = 0;
for (int i = 0; i < n; i++) ts1 += line[i & 1] != s[i][j];
swap(line[0], line[1]);
for (int i = 0; i < n; i++) ts2 += line[i & 1] != s[i][j];
if (ts1 < ts2) swap(line[0], line[1]);
for (int i = 0; i < n; i++) rs[i][j] = line[i & 1];
}
}
for (int i = 0; i < n; i++) cout << rs[i] << "\n";
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
clear();
read();
solve();
return 0;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int INF = 1e9 + 10;
int a[N][N], x[N * N], y[N * N], t[N * N];
int main() {
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < q; i++) scanf("%d%d%d", &x[i], &y[i], &t[i]);
int l = 0, r = INF, ret = INF;
while (l <= r) {
int ans = INF;
memset(a, 0, sizeof(a));
int mid = (l + r) >> 1;
for (int i = 0; i < q; i++)
if (t[i] <= mid) a[x[i]][y[i]] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
a[i][j] += (a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1]);
for (int i = k; i <= n; i++)
for (int j = k; j <= m; j++) {
int cnt = a[i][j] + a[i - k][j - k] - a[i][j - k] - a[i - k][j];
if (cnt == k * k) ans = mid;
}
ret = min(ans, ret);
if (ans == INF)
l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", ret == INF ? -1 : ret);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.14159265358979323846;
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first) return (a.second < b.second);
return (a.first < b.first);
}
long long int fpower(long long int x, long long int y) {
long long int ans = 1;
while (y) {
if (y & 1)
ans = ans * x, y--;
else
x *= x, y /= 2;
}
return ans;
}
long long int myXOR(long long int x, long long int y) {
return (x | y) & (~x | ~y);
}
bool prime(long long int x) {
if (x == 1) return 0;
for (long long int i = 2; i * i <= x; i++) {
if (x % i == 0) return 0;
}
return 1;
}
long long int gcd(long long int x, long long int y) {
if (x == 0) return y;
return gcd(y % x, x);
}
void primefactor(set<long long int> &s, long long int x) {
for (long long int i = 2; i * i <= x; i++) {
if (x % i == 0) {
s.insert({i, x / i});
}
}
}
int count(string s, string s1, int n, int m, int sum) {
if (n == 0 || m == 0) return 0;
if (s[n - 1] == s1[m - 1])
sum = max(sum + 1, count(s, s1, n - 1, m - 1, sum + 1));
else
sum = max(sum, max(count(s, s1, n - 1, m, 0), count(s, s1, n, m - 1, 0)));
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int k;
cin >> k;
while (k--) {
int n, x;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
int flag = 0;
int l = 0, r, i = n - 1;
for (r = 1; r < i; r++) {
if (v[i] >= v[l] + v[r]) {
flag = 1;
break;
}
}
if (flag) {
cout << l + 1 << " ";
cout << r + 1 << " ";
cout << i + 1 << "\n";
} else
cout << -1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
long long n, k, a[N], ans = 0;
map<long long, vector<long long> > mp;
vector<long long> dota(N, 0);
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]].push_back(i);
}
for (long long i = n - 2; i >= 0; i--) {
if (mp.find(a[i] * k) == mp.end()) {
continue;
}
dota[i] = (long long)(mp[a[i] * k].size()) -
(upper_bound(mp[a[i] * k].begin(), mp[a[i] * k].end(), i) -
mp[a[i] * k].begin());
}
for (auto &el : mp) {
for (long long i = (long long)(el.second.size()) - 2; i >= 0; i--) {
dota[el.second[i]] += dota[el.second[i + 1]];
}
}
for (long long i = 0; i < n; i++) {
if (mp.find(a[i] * k) == mp.end()) {
continue;
}
long long ind = upper_bound(mp[a[i] * k].begin(), mp[a[i] * k].end(), i) -
mp[a[i] * k].begin();
if (ind == (long long)(mp[a[i] * k].size())) {
continue;
}
ans += dota[mp[a[i] * k][ind]];
}
cout << ans << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5, Mod1 = 1e9 + 7, Mod2 = 998244353;
char buf[1 << 12], *pp1 = buf, *pp2 = buf, nc;
int ny;
inline char gc() { return getchar(); }
inline int read() {
int x = 0;
for (ny = 1; nc = gc(), (nc < 48 || nc > 57) && nc != EOF;)
if (nc == 45) ny = -1;
if (nc < 0) return nc;
for (x = nc - 48; nc = gc(), 47 < nc && nc < 58 && nc != EOF;
x = (x << 3) + (x << 1) + (nc ^ 48))
;
return x * ny;
}
struct HASH {
int a, b;
HASH(int a = 0, int b = 0) : a(a), b(b) {}
inline friend HASH operator+(HASH a, HASH b) {
return HASH((a.a + b.a) % Mod1, (a.b + b.b) % Mod2);
}
inline friend HASH operator-(HASH a, HASH b) {
return HASH((a.a - b.a + Mod1) % Mod1, (a.b - b.b + Mod2) % Mod2);
}
inline friend HASH operator*(HASH a, HASH b) {
return HASH(1ll * a.a * b.a % Mod1, 1ll * a.b * b.b % Mod2);
}
inline friend bool operator==(HASH a, HASH b) {
return (a.a == b.a) && (a.b == b.b);
}
} Hash1[MAXN], Hash2[MAXN], Fpow[MAXN], iFpow[MAXN];
inline int Fp(int x, int k, int Mod) {
int ans = 1;
for (; k; k >>= 1, x = 1ll * x * x % Mod)
if (k & 1) ans = 1ll * ans * x % Mod;
return ans;
}
int n, m, tim, fa[MAXN], dep[MAXN], sz[MAXN], w[MAXN], dfn[MAXN], tr[MAXN],
top[MAXN];
char s[MAXN];
vector<int> G[MAXN];
void dfs(int x, int f) {
fa[x] = f, dep[x] = dep[f] + 1, sz[x] = 1,
Hash1[x] = Hash1[fa[x]] + Fpow[dep[x] - 1] * HASH(s[x], s[x]),
Hash2[x] = Hash2[fa[x]] * HASH(131, 131) + HASH(s[x], s[x]);
for (auto y : G[x])
if (y != f) dfs(y, x), sz[x] += sz[y], sz[y] > sz[w[x]] ? w[x] = y : 0;
}
void dfs1(int x, int tp) {
top[x] = tp, tr[dfn[x] = ++tim] = x;
if (w[x]) dfs1(w[x], tp);
for (auto y : G[x])
if (y != fa[x] && y != w[x]) dfs1(y, y);
}
inline int lca(int x, int y) {
for (; top[x] != top[y]; x = fa[top[x]])
if (dep[top[x]] < dep[top[y]]) swap(x, y);
return dep[x] < dep[y] ? x : y;
}
inline int kth(int x, int k) {
for (; k > dep[x] - dep[top[x]];
k -= dep[x] - dep[top[x]] + 1, x = fa[top[x]])
;
return tr[dfn[x] - k];
}
inline HASH Get(int x, int y, int z, int k) {
if (!k) return HASH(0, 0);
if (k <= dep[x] - dep[z] + 1) {
int t = kth(x, k);
return (Hash1[x] - Hash1[t]) * iFpow[dep[t]];
} else {
k -= dep[x] - dep[z] + 1;
int t = kth(y, dep[y] - (dep[z] + k));
HASH p1 = (Hash1[x] - Hash1[fa[z]]) * iFpow[dep[fa[z]]],
p2 = (Hash2[t] - Hash2[z] * Fpow[k]);
return p1 * Fpow[k] + p2;
}
}
int main() {
n = read(), Fpow[0] = iFpow[0] = HASH(1, 1), scanf("%s", s + 1);
for (int i = (1); i <= (n); i++) {
int a = 131, b = Fp(131, Mod1 - 2, Mod1), c = Fp(131, Mod2 - 2, Mod2);
Fpow[i] = Fpow[i - 1] * HASH(a, a), iFpow[i] = iFpow[i - 1] * HASH(b, c);
}
for (int i = (1); i <= (n - 1); i++) {
int x = read(), y = read();
G[x].push_back(y), G[y].push_back(x);
}
dfs(1, 0), dfs1(1, 0);
for (int m = read(); m--;) {
int a = read(), b = read(), c = read(), d = read(), x = lca(a, b),
y = lca(c, d), l = 0,
r = min(dep[a] + dep[b] - 2 * dep[x] + 1,
dep[c] + dep[d] - 2 * dep[y] + 1),
ans = 0;
while (l <= r) {
int mid = l + r >> 1;
HASH t1 = Get(a, b, x, mid), t2 = Get(c, d, y, mid);
if (t1 == t2)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans << "\n";
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e6 + 10;
const int inf = (int)2e9;
char str[N];
long long rev, altr;
int main() {
int n;
scanf("%d %lld %lld", &n, &rev, &altr);
scanf("%s", &str);
long long seg = 0;
char last = '1';
for (int i = 0; i < n; i++) {
if (str[i] == '0' && last == '1') seg += 1;
last = str[i];
}
if (seg == 0) {
printf("0\n");
return 0;
}
long long ans = (seg - 1) * rev + altr;
ans = min(ans, altr * seg);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int pre[2010];
int find(int x) {
if (pre[x] == -1) {
return x;
}
return pre[x] = find(pre[x]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
int n, m, k, i, j;
memset(pre, -1, sizeof(pre));
scanf("%d%d%d", &n, &m, &k);
int x, y;
for (i = 1; i + k - 1 <= n; i++) {
int lt = i, rt = i + k - 1;
while (lt <= rt) {
x = find(lt);
y = find(rt);
if (x != y) {
pre[x] = y;
}
++lt;
--rt;
}
}
long long ans = 1;
long long mod = 1000000007;
for (i = 1; i <= n; i++) {
if (pre[i] == -1) {
ans = ans * (long long)m % mod;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1LL << 31) - 1;
using namespace std;
int i, j, k, l, n, m, q, d;
int ar[105];
int dp[10001][101], dpn[10001][101];
int rec(int tar, int num) {
int a, b;
if (tar > 10000) return 0;
if (num == n - 1) {
if (tar >= 1 && tar <= l) {
ar[num] = tar;
return 1;
}
return 0;
}
for (a = l; a >= 1; a--) {
if (fabs(a - tar) <= 10000) {
if (a >= tar && dp[a - tar][num + 1] == -1) {
b = rec(a - tar, num + 1);
if (b == 1) {
ar[num] = a;
return 1;
} else
dp[a - tar][num] = 0;
} else if (a < tar && dpn[tar - a][num + 1] == -1) {
b = rec(a - tar, num + 1);
if (b == 1) {
ar[num] = a;
return 1;
} else
dpn[tar - a][num] = 0;
}
}
}
if (tar >= 0)
dp[tar][num] = 0;
else
dpn[-tar][num] = 0;
return 0;
}
int main() {
scanf("%d%d%d", &n, &d, &l);
memset(dp, -1, sizeof(dp));
memset(dpn, -1, sizeof(dpn));
j = rec(d, 0);
if (j == 0)
printf("-1\n");
else {
for (i = 0; i < n; i++) {
if (i > 0) printf(" ");
printf("%d", ar[i]);
}
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, k, a, b, q, t, A, B, BITA[MAXN], BITB[MAXN], tot[MAXN];
int query1(int index) {
if (index >= MAXN) index = MAXN - 1;
int sum = 0;
for (; index > 0; index -= index & -index) sum += BITA[index];
return sum;
}
void set1(int index, int value) {
int val = -(query1(index) - query1(index - 1)) + value;
for (; index < MAXN; index += index & -index) BITA[index] += val;
}
int query2(int index) {
int sum = 0;
for (; index > 0; index -= index & -index) sum += BITB[index];
return sum;
}
void set2(int index, int value) {
int val = -(query2(index) - query2(index - 1)) + value;
for (; index < MAXN; index += index & -index) BITB[index] += val;
}
int main() {
scanf("%i%i%i%i%i", &n, &k, &a, &b, &q);
while (q--) {
scanf("%i", &t);
if (t == 1) {
scanf("%i%i", &A, &B);
tot[A] += B;
set1(A, min(tot[A], a));
set2(A, min(tot[A], b));
} else {
scanf("%i", &A);
printf("%i\n", query1(MAXN - 1) - query1(A + k - 1) + query2(A - 1));
}
}
}
| 9 |
#include <bits/stdc++.h>
inline long long rd() {
long long _x = 0;
int _ch = getchar(), _f = 1;
for (; !isdigit(_ch) && (_ch != '-') && (_ch != EOF); _ch = getchar())
;
if (_ch == '-') {
_f = 0;
_ch = getchar();
}
for (; isdigit(_ch); _ch = getchar()) _x = _x * 10 + _ch - '0';
return _f ? _x : -_x;
}
void write(long long _x) {
if (_x >= 10)
write(_x / 10), putchar(_x % 10 + '0');
else
putchar(_x + '0');
}
inline void wrt(long long _x, char _p) {
if (_x < 0) putchar('-'), _x = -_x;
write(_x);
if (_p) putchar(_p);
}
int dp[2][105][105][105], g[105][105];
int n, m, k;
int main() {
n = rd() + 1, m = rd(), k = rd();
g[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int p = 0; p <= j; p++) {
g[i][j] = (g[i - 1][p] + g[i][j]) % 1000000007;
}
}
}
for (int i = 2; i <= n; i++) {
dp[1][i][i - 1][1] = 1;
}
int ans = 0;
for (int i = 1, now = 1; i <= m; i++, now ^= 1) {
memset(dp[now ^ 1], 0, sizeof dp[now ^ 1]);
for (int j = 1; j <= n; j++) {
for (int p = 0; p <= n; p++) {
for (int q = 1; q <= k; q++)
if (dp[now][j][p][q]) {
int *w = &dp[now][j][p][q];
if (p == 0) {
ans = (ans + 1ll * (*w) * (m - i + 1)) % 1000000007;
continue;
}
for (int t = 0; t <= n - j - p; t++)
if (1ll * q * g[p][t] <= k) {
int *pos = &dp[now ^ 1][j + t + p][t][q * g[p][t]];
*pos = (*pos + (*w)) % 1000000007;
}
}
}
}
}
wrt(ans, '\n');
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int a;
a = str.length();
str[0] = toupper(str[0]);
cout << str;
}
| 0 |
Subsets and Splits