solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string a, b, c;
long long ca[26];
long long cb[26];
long long cc[26];
int main() {
ios::sync_with_stdio(0);
getline(cin, a);
getline(cin, b);
getline(cin, c);
for (int i = 0; i < (int)a.size(); ++i) ca[a[i] - 'a']++;
for (int i = 0; i < (int)b.size(); ++i) cb[b[i] - 'a']++;
for (int i = 0; i < (int)c.size(); ++i) cc[c[i] - 'a']++;
int ansb = 0;
int ansc = 0;
for (int i = 0; i < (int)a.size(); ++i) {
bool can = 1;
for (int j = 0; j < 26; ++j) {
ca[j] -= i * cb[j];
if (ca[j] < 0) can = 0;
}
if (can) {
long long cnt = 1e9;
for (int j = 0; j < 26; ++j)
if (cc[j]) cnt = min(cnt, ca[j] / cc[j]);
if (i + cnt > ansc + ansb) {
ansb = i;
ansc = cnt;
}
}
for (int j = 0; j < 26; ++j) ca[j] += i * cb[j];
}
for (int j = 0; j < 26; ++j) {
ca[j] -= ansb * cb[j];
ca[j] -= ansc * cc[j];
}
for (int i = 0; i < ansc; ++i) printf("%s", c.c_str());
for (int i = 0; i < ansb; ++i) printf("%s", b.c_str());
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < ca[i]; ++j) printf("%c", (char)('a' + i));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int res;
cin >> res;
if (res % 2 == 0) {
cout << "Mahmoud";
} else {
cout << "Ehab";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sum(1), tmp[26], last[26];
void add(int c) {
sum = (sum + tmp[c]);
while (sum >= 1000000007LL) sum -= 1000000007LL;
}
void inc(int a, int b) {
tmp[a] += tmp[b];
if (tmp[a] >= 1000000007LL) tmp[a] -= 1000000007LL;
}
bool comp(int a, int b) { return last[a] < last[b]; }
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i(0); i < k; ++i) {
tmp[i] = 1;
last[i] = -1;
}
string s;
cin >> s;
int mx(0), now;
for (int i(0); i < s.size(); ++i) {
now = s[i] - 'a';
last[now] = i;
add(now);
for (int j(0); j < k; ++j)
if (j != now) {
inc(j, now);
if (comp(j, mx) || mx == now) mx = j;
}
}
for (int i(0); i < n; ++i) {
now = mx;
last[now] = i + s.size();
add(now);
for (int j(0); j < k; ++j)
if (j != now) {
inc(j, now);
if (comp(j, mx) || mx == now) mx = j;
}
}
cout << sum;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[1005][6];
int cnt[1005];
int n, k, v[6][1005];
;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n; ++j) {
scanf("%d", &v[i][j]);
dp[v[i][j]][i] = j;
}
}
int tmax = 0, flag, a, b;
for (int i = 1; i <= n; ++i) {
a = v[1][i];
cnt[a] = 1;
for (int j = 1; j < i; ++j) {
b = v[1][j];
flag = 1;
if (cnt[b] + 1 <= cnt[a]) continue;
for (int p = 2; p <= k; ++p)
if (dp[a][p] < dp[b][p]) flag = 0;
if (flag) cnt[a] = cnt[b] + 1;
}
tmax = cnt[a] > tmax ? cnt[a] : tmax;
}
printf("%d\n", tmax);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long xor64() {
static unsigned long long x = 23811192380192ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
unsigned long long H[1010], b[30];
map<unsigned long long, int> bf, bs;
unsigned long long geth() {
unsigned long long r = 0;
int l;
scanf("%d", &l);
while (l--) {
int x;
scanf("%d", &x);
--x;
r ^= H[x];
}
return r;
}
int main() {
int n, s, d;
scanf("%d%d%d", &n, &s, &d);
for (int i = 0; i < n; i++) {
H[i] = xor64();
}
for (int i = 0; i < s; i++) {
b[i] = geth();
}
int h = s / 2;
for (int i = 0; i < 1 << h; i++) {
unsigned long long x = 0;
int c = 0;
for (int j = 0; j < h; j++) {
if (i >> j & 1) x ^= b[j], c++;
}
if (bf.count(x)) {
bf[x] = min(bf[x], c);
} else {
bf[x] = c;
}
}
int rh = s - h;
for (int i = 0; i < 1 << rh; i++) {
unsigned long long x = 0;
int c = 0;
for (int j = 0; j < rh; j++) {
if (i >> j & 1) x ^= b[j + h], c++;
}
if (bs.count(x)) {
bs[x] = min(bs[x], c);
} else {
bs[x] = c;
}
}
vector<pair<unsigned long long, int> > v(bf.begin(), bf.end());
while (d--) {
unsigned long long x = geth();
int ans = s + 1;
for (int i = 0; i < v.size(); i++) {
unsigned long long y = v[i].first ^ x;
if (bs.count(y)) {
ans = min(ans, bs[y] + v[i].second);
}
}
if (ans > s) ans = -1;
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
reverse(arr, arr + n);
for (int i = 0; i < n; i++) {
cout << arr[i] << ' ';
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
template <class T>
inline void gmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void gmin(T &a, T b) {
if (b < a) a = b;
}
using namespace std;
const int N = 1e5 + 10, M = 2e6 + 10, Z = 1e9 + 7, maxint = 2147483647,
ms1 = 16843009, ms31 = 522133279, ms63 = 1061109567,
ms127 = 2139062143;
const double PI = acos(-1.0), eps = 1e-8;
void fre() {
freopen("/Users/luras/Desktop/in.txt", "r", stdin);
freopen("/Users/luras/Desktop/out.txt", "w", stdout);
}
const int INF = 1e9;
int casenum, casei;
int n, k, typ, p, l, r, t, a[N], f[N];
int st, ed;
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; i++) a[i] = 1, f[i] = f[i - 1] + a[i];
int pre = 0;
st = 1;
ed = n;
while (k--) {
scanf("%d", &typ);
if (typ == 1) {
scanf("%d", &p);
if (p <= (ed - st + 1) / 2) {
for (int i = st + p, t = st + p - 1; i <= ed && t >= st; i++, t--)
a[i] += a[t];
st = st + p;
} else {
for (int i = st + p - 1, t = st + p; i >= st && t <= ed; i--, t++)
a[i] += a[t];
ed = p + st - 1;
for (int i = st, j = ed; i <= st + (ed - st + 1) / 2; i++, j--)
swap(a[i], a[j]);
}
pre = 1;
} else {
if (pre == 1) {
f[st - 1] = 0;
for (int i = st; i <= ed; i++) f[i] = f[i - 1] + a[i];
}
scanf("%d%d", &l, &r);
printf("%d\n", f[r + st - 1] - f[l + st - 1]);
pre = 2;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a;
cin >> a;
if (a.size() == 1) {
return cout << 1, 0;
}
char f = a[0], s = !(a[0] - '0') + '0';
bool b = true, find = false;
int c = 1;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) c++;
}
cout << min(c + 2, n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char ch[5];
int query(int l, int r) {
if (l > r) return -1;
if (l == r) return l;
int mid = (l + r) / 2;
printf("1 %d %d\n", mid, mid + 1);
fflush(stdout);
scanf("%s", ch);
if (strcmp(ch, "TAK") == 0) {
return query(l, mid);
} else {
return query(mid + 1, r);
}
}
int main() {
{
scanf("%d%d", &n, &k);
int ans1 = query(1, n);
int ans2 = query(1, ans1 - 1);
int ans3 = query(ans1 + 1, n);
if (ans2 != -1) {
printf("1 %d %d\n", ans2, ans1);
fflush(stdout);
scanf("%s", ch);
if (strcmp(ch, "TAK") == 0) {
printf("2 %d %d\n", ans1, ans2);
} else {
printf("2 %d %d\n", ans1, ans3);
}
} else {
printf("2 %d %d\n", ans1, ans3);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int smallestDivisor(long long int n) {
if (n % 2 == 0) return 2;
for (long long int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
long long int max(long long int a, long long int b) { return a > b ? a : b; }
long long int min(long long int a, long long int b) { return a < b ? a : b; }
long long int gcd(long long int a, long long int b) {
while (b) {
long long int t = a;
a = b;
b = t % b;
}
return a;
}
long long int lcm(long long int a, long long int b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
int cnt[200005] = {0};
vector<int> adj[200005];
map<int, int, greater<int> > factorize(int n) {
int count = 0;
map<int, int, greater<int> > fact;
while (!(n % 2)) {
n /= 2;
count++;
}
if (count) fact[2] += count;
for (int i = 3; i <= sqrt(n); i += 2) {
count = 0;
while ((n % i) == 0) {
count++;
n /= i;
}
if (count) fact[i] += count;
}
if (n > 2) fact[n]++;
for (auto it : fact) {
cnt[it.first]++;
adj[it.first].push_back(it.second);
}
return fact;
}
long long int power(long long int x, int p) {
if (p == 0) return 1;
long long int ans = power(x, p / 2);
ans = ans * ans;
if (p % 2 == 1) ans = ans * x;
return ans;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> countDivisors(long long int n) {
long long int cnt = 0;
std::vector<long long int> v;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
v.push_back(i);
if (n / i == i)
cnt++;
else {
cnt = cnt + 2;
v.push_back(n / i);
}
}
}
return v;
}
bool isPowerOfTwo(long long int x) { return (x && !(x & (x - 1))); }
map<long long int, long long int> factors(long long int n) {
vector<long long int> f;
map<long long int, long long int> m;
for (long long int x = 2; x * x <= n; x++) {
while (n % x == 0) {
f.push_back(x);
m[x]++;
n /= x;
}
}
if (n > 1) {
f.push_back(n);
m[n]++;
}
return m;
}
bool cmp(pair<long long int, long long int> v1,
pair<long long int, long long int> v2) {
if (v1.first > v2.first) {
return true;
} else if (v1.first < v2.first) {
return false;
} else {
return v1.second < v2.second;
}
}
long long int binarySearch(long long int arr[], long long int l,
long long int r, long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
int rub[2000001];
bool ispali(int n) {
int no = n;
int rev = 0;
while (no > 0) {
int ld = no % 10;
no /= 10;
rev = rev * 10 + ld;
}
if (n == rev)
return true;
else
return false;
}
void np() {
for (int i = 1; i <= 2000000; i++) {
if (ispali(i))
rub[i] = rub[i - 1] + 1;
else
rub[i] = rub[i - 1];
}
}
int pi[20000001];
bool isprime[20000001];
void seive() {
for (int i = 4; i <= 20000000; i += 2) isprime[i] = 1;
for (int i = 3; i * i <= 20000000; i += 2) {
if (!isprime[i]) {
for (int j = i * i; j <= 20000000; j += i) isprime[j] = 1;
}
}
for (int i = 2; i <= 20000000; i++) {
if (!isprime[i])
pi[i] = pi[i - 1] + 1;
else
pi[i] = pi[i - 1];
}
}
int g1;
void bfs(vector<vector<int> > &g, int pos, vector<int> visited) {
queue<int> q;
q.push(pos);
while (q.size() > 0) {
if (q.front() == g1) {
cout << "yes";
return;
}
int i = q.front();
q.pop();
visited[i] = 1;
for (int j = 0; j < g[i].size(); j++) {
if (visited[g[i][j]] == 0) {
q.push(g[i][j]);
visited[g[i][j]] = 1;
}
}
}
return;
}
void pairsort(long long int a[], long long int b[], long long int n) {
pair<long long int, long long int> pairt[n];
for (long long int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long int modpower(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modsum(long long int a, long long int b, long long int m) {
return ((a % m) + (b % m)) % m;
}
long long int modmul(long long int a, long long int b, long long int m) {
return ((a % m) * (b % m)) % m;
}
long long int modInverse(long long int a, long long int m) {
return modpower(a, m - 2, m);
}
vector<long long int> factorial() {
int i;
vector<long long int> fact(200002 + 1, 0);
fact[0] = 1;
for (i = 1; i <= 200002; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
return fact;
}
long long int highestPowerof2(long long int n) {
long long int p = (long long int)log2(n);
return (long long int)pow(2, p);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t1 = 1;
while (t1--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (long long int i = 0; i < n - 1; i++) {
if (a[i + 1] - a[i] > 1) {
cout << "NO";
return 0;
}
}
map<int, int> cnt;
for (long long int i = 0; i < n; i++) cnt[a[i]]++;
map<int, int>::iterator it = cnt.begin();
int cur = (*it).first, ct = 2 * (*it).second;
it++;
bool f = 1;
while (it != cnt.end()) {
if ((*it).first - cur > 1) {
f = 0;
break;
}
if (ct == 0) {
f = 0;
break;
}
ct = 2 * (*it).second - ct;
if (ct < 0) {
f = 0;
break;
}
cur = (*it).first;
it++;
}
if (ct || !f)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int a, b;
cin >> a >> b;
if (a % b == 0) {
cout << "0\n";
} else
cout << b - (a % b) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, s, t, p[100001], ans = 0;
scanf("%d%d%d", &n, &s, &t);
for (i = 1; i <= n; i++) scanf("%d", &p[i]);
for (i = 1; i <= n; i++) {
if (s == t) break;
s = p[s];
ans++;
}
if (i == n + 1) ans = -1;
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2e5 + 6;
long long pre[maxx];
long long a[maxx];
void add(int l, int r, long long w) {
pre[l] += w;
pre[r + 1] -= w;
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= m; i++) {
scanf("%lld", &a[i]);
}
memset(pre, 0, sizeof(pre));
for (int i = 1; i < m; i++) {
long long l = a[i];
long long r = a[i + 1];
if (l > r) swap(l, r);
if (l == r) continue;
add(1, l - 1, r - l);
add(l, l, r - 1);
add(l + 1, r - 1, r - l - 1);
add(r, r, l);
add(r + 1, n, r - l);
}
for (int i = 1; i <= n; i++) {
pre[i] += pre[i - 1];
}
for (int i = 1; i <= n; i++) {
if (i - 1)
printf(" %lld", pre[i]);
else
printf("%lld", pre[i]);
}
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll modinv(ll a, ll m) {
assert(m > 0);
if (m == 1) return 0;
a %= m;
if (a < 0) a += m;
assert(a != 0);
if (a == 1) return 1;
return m - modinv(m, a) * m / a;
}
template <int MOD_>
struct modnum {
private:
int v;
public:
static const int MOD = MOD_;
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0) v += MOD;
}
explicit operator int() const { return v; }
friend bool operator==(const modnum& a, const modnum& b) {
return a.v == b.v;
}
friend bool operator!=(const modnum& a, const modnum& b) {
return a.v != b.v;
}
modnum operator~() const {
modnum res;
res.v = modinv(v, MOD);
return res;
}
modnum& operator+=(const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator-=(const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator*=(const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator/=(const modnum& o) { return *this *= (~o); }
friend modnum operator+(const modnum& a, const modnum& b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum& a, const modnum& b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum& a, const modnum& b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum& a, const modnum& b) {
return modnum(a) /= b;
}
};
template <typename T>
T pow(T a, long long b) {
assert(b >= 0);
T r = 1;
while (b) {
if (b & 1) r *= a;
b >>= 1;
a *= a;
}
return r;
}
using num = modnum<int(1e9) + 7>;
int MAX = 1000001;
const int MOD = 1e9 + 7;
ll sum(ll a, ll b) {
a += b;
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
ll mul(ll a, ll b) { return a * 1ll * b % MOD; }
ll sub(ll a, ll b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
void solve() {
int t;
cin >> t;
while (t--) {
int x;
cin >> x;
string str;
cin >> str;
num len = str.size();
for (int i = 0; i < x; i++) {
if (str.size() < x) {
string g = str.substr(i + 1);
for (int j = 0; j < str[i] - '1'; j++) str += g;
}
len = (i + 1) + (len - (i + 1)) * (str[i] - '0');
}
cout << (int)len << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
const double PI = 3.1415926535897932384626433832795;
template <class T>
T min(T &a, T &b) {
return (a < b) ? a : b;
}
template <class T>
T max(T &a, T &b) {
return (a > b) ? a : b;
}
template <class T>
T sqr(T &a) {
return a * a;
}
template <class T>
T abs(T &a) {
return (a < 0) ? (-a) : a;
}
inline void read(int &x) { scanf("%d", &x); }
inline void readln(int &x) { scanf("%d\n", &x); }
inline void write(int x) { printf("%d", x); }
inline void writeln(int x) { printf("%d\n", x); }
inline void read(long long &x) { scanf("%lld", &x); }
inline void readln(long long &x) { scanf("%lld\n", &x); }
inline void write(long long x) { printf("%lld", x); }
inline void writeln(long long x) { printf("%lld\n", x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void readln(double &x) { scanf("%lf\n", &x); }
inline void write(double x) { printf("%.15lf", x); }
inline void writeln(double x) { printf("%.15lf\n", x); }
inline void read(char *s) { scanf("%s", s); }
inline void readln(char *s) { scanf("%s\n", s); }
inline void write(char *s) { printf("%s", s); }
inline void writeln(char *s) { printf("%s\n", s); }
inline int readInt() {
int x;
read(x);
return x;
}
inline long long readLong() {
long long x;
read(x);
return x;
}
inline double readDouble() {
double x;
read(x);
return x;
}
void showTime() {}
void prepareInputOutput() {}
bool a[100][100];
void solve() {
int n, p;
cin >> n >> p;
memset((a), 0, sizeof(a));
vector<int> deg(n);
for (int i = 0; i < ((int)(2 * n + p)); i++) {
int minV = -1;
for (int i = 0; i < ((int)(n)); i++) {
if (minV == -1 || deg[i] < deg[minV]) {
minV = i;
}
}
int minU = -1;
for (int i = 0; i < ((int)(n)); i++) {
if (i != minV && !a[i][minV] && (minU == -1 || deg[i] < deg[minU])) {
minU = i;
}
}
a[minV][minU] = true;
a[minU][minV] = true;
deg[minU]++;
deg[minV]++;
cout << minU + 1 << " " << minV + 1 << "\n";
}
}
int main() {
prepareInputOutput();
int T;
cin >> T;
for (int _ = 0; _ < ((int)(T)); _++) solve();
showTime();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ris = 0;
bool isPower(long long x, long long y) {
double res1 = log(y) / log(x);
double e = ceil(res1);
return (res1 / e == 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
map<long long, long long> prefix;
vector<long long> multi;
vector<long long> val(n);
for (int i = 0; i < n; i++) cin >> val[i];
long long scorso = 1;
while (abs(scorso) <= 1e16) {
multi.push_back(scorso);
scorso *= k;
if (scorso == 1) break;
}
long long sum = 0;
prefix[0]++;
for (int i = 0; i < n; i++) {
sum += val[i];
for (auto x : multi) {
ris += prefix[sum - x];
}
prefix[sum]++;
}
cout << ris << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> cnt[100005];
int hats[100005];
int main() {
int N;
scanf("%d", &N);
for (int n = 0; n < N; n++) {
int differ;
scanf("%d", &differ);
int same = N - differ;
cnt[same].push_back(n);
}
bool possible = true;
for (int n = 1; n <= N; n++) {
if (cnt[n].size() && cnt[n].size() % n != 0) {
possible = false;
break;
}
}
printf("%s\n", possible ? "Possible" : "Impossible");
if (possible) {
int hat = 1;
for (int n = 1; n <= N; n++) {
if (!cnt[n].size()) continue;
for (int i = 0; i < cnt[n].size() / n; i++) {
for (int j = 0; j < n; j++) {
int index = cnt[n][i * n + j];
hats[index] = hat;
}
hat++;
}
}
for (int n = 0; n < N; n++) {
printf("%d ", hats[n]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream &operator<<(ostream &s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, vector<T> t) {
for (int(i) = 0; (i) < (((int)(t.size()))); ++(i)) s << t[i] << " ";
return s;
}
set<int> wolne[200007];
int posInCycle[200007], whichCycle[200007];
int main() {
int(h), (m);
scanf("%d %d", &(h), &(m));
int ktorycykl = 0, rozmiarCykli;
vector<bool> vis(h + 5, 0);
for (int(i) = 0; (i) < (h); ++(i)) {
if (vis[i]) continue;
int v = i;
vector<int> cykl;
do {
cykl.push_back(v);
v = (m + v) % h;
vis[v] = 1;
} while (v != i);
for (int(u) = 0; (u) < (((int)(cykl.size()))); ++(u)) {
whichCycle[cykl[u]] = ktorycykl;
posInCycle[cykl[u]] = u;
wolne[ktorycykl].insert(u);
}
++ktorycykl;
rozmiarCykli = ((int)(cykl.size()));
}
map<int, pair<int, int> > position;
long long res = 0;
int(testow);
scanf("%d", &(testow));
while (testow--) {
char c;
scanf(" %c", &c);
if (c == '+') {
int(id), (hash);
scanf("%d %d", &(id), &(hash));
int desiredPosInCycle = posInCycle[hash], ktorycykl = whichCycle[hash];
set<int> &wol = wolne[ktorycykl];
set<int>::iterator it = wol.lower_bound(desiredPosInCycle);
bool obrot = 0;
if (it == wol.end()) {
it = wol.begin();
obrot = 1;
}
int posWCyklu = *it;
wol.erase(it);
position[id] = make_pair(ktorycykl, posWCyklu);
res += (obrot ? rozmiarCykli - desiredPosInCycle + posWCyklu
: posWCyklu - desiredPosInCycle);
} else {
int(id);
scanf("%d", &(id));
pair<int, int> pos = position[id];
wolne[pos.first].insert(pos.second);
}
}
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int b) {
bool isprime = true;
for (int i = 2; i <= b / 2; i++) {
if (b % i == 0) {
isprime = false;
break;
}
}
return isprime;
}
int main() {
int a, b;
cin >> a >> b;
if (prime(b) == false || b <= a) {
cout << "NO";
return 0;
}
for (int i = a + 1; i <= b; i++) {
if (prime(i) == true) {
if (i == b) {
cout << "YES";
} else {
cout << "NO";
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int f[1000001][21], d[1000001];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int LCA(int u, int v) {
if (d[u] > d[v]) swap(u, v);
int h = d[v] - d[u];
for (int i = 20; i >= 0; i--) {
if (h & (1 << i)) v = f[v][i];
}
if (u == v) return u;
for (int i = 20; i >= 0; i--) {
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
}
return f[u][0];
}
signed main() {
int n = 4, len, a, b;
f[2][0] = f[3][0] = f[4][0] = 1;
d[1] = 0;
d[2] = d[3] = d[4] = 1;
len = a = 2;
b = 3;
int q = read();
for (int i = 1; i <= q; i++) {
int u = n + 1;
int v = n + 2;
n += 2;
int x = read();
d[u] = d[v] = d[x] + 1;
f[u][0] = f[v][0] = x;
for (int j = 1; (1 << j) <= n; j++) {
f[u][j] = f[f[u][j - 1]][j - 1];
f[v][j] = f[f[v][j - 1]][j - 1];
}
int lca = LCA(a, u);
if (d[u] + d[a] - d[lca] - d[lca] > len) {
b = u;
len++;
} else {
int lca = LCA(b, u);
if (d[u] + d[b] - d[lca] - d[lca] > len) {
a = u;
len++;
}
}
printf("%d\n", len);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long x;
cin >> x;
long long ans = 0;
for (long long i = 2; i <= x * 2LL; i *= 2) {
long long cell = i * (i - 1) / 2;
if (cell > x) break;
ans++;
x -= cell;
}
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long binexp(long long a, long long b, long long m) {
long long res = 1;
a = a % m;
while (b) {
if (b & 1) res = (a * 1ll * res) % m;
a = (a * 1ll * a) % m;
b >>= 1;
}
return res;
}
struct point {
long double x, y;
point(long double x, long double y) { this->x = x, this->y = y; }
};
bool operator<(point a, point b) { return a.x < b.x; }
struct Line {
long long m, c;
Line() {}
Line(long long m, long long c) { this->m = m, this->c = c; }
long long val(long long x) { return m * x + c; }
long double val(long double x) { return m * x + c; }
};
point INS(Line a, Line b) {
long double x = -(long double)(a.c - b.c) / (a.m - b.m);
long double y = a.m * x + a.c;
return point(x, y);
}
struct CHT {
vector<Line> ln;
vector<point> p;
CHT() {}
void insert_line(long long m, long long c) {
Line L(m, c);
while (p.size() > 0 and L.val(p.back().x) <= p.back().y) {
p.pop_back();
ln.pop_back();
}
if (ln.size() != 0) p.push_back(INS(ln.back(), L));
ln.push_back(L);
}
long long get(long long x) {
return ln[lower_bound(p.begin(), p.end(), point(x, -1000000000000000000)) -
p.begin()]
.val(x);
}
};
CHT cht;
const long long N = 1e5 + 5;
long long dp[N], a[N], b[N], sum[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> b[i];
cht.insert_line(b[1], 0);
for (long long i = 2; i <= n; i++) {
dp[i] = cht.get(a[i]);
cht.insert_line(b[i], dp[i]);
}
cout << dp[n];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, now[maxn], cnt, st[maxn], nt[maxn], to[maxn], topt, dfn[maxn], dfn_num,
ans = 100;
long long v[maxn];
bool f[maxn];
set<pair<int, int> > ss;
void add(int x, int y) {
to[++topt] = y;
nt[topt] = st[x];
st[x] = topt;
}
void dfs(int x, int d, int s) {
f[x] = 1;
int p = st[x];
if (d + 1 <= ans) {
while (p) {
if (!f[to[p]])
dfs(to[p], d + 1, s);
else if (to[p] == s && d > 1)
ans = min(ans, d + 1);
p = nt[p];
}
}
f[x] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &v[i]);
for (int j = 0; j <= 60; j++) {
cnt = 0;
for (int i = 1; i <= n; i++)
if ((v[i] >> j) & 1) now[++cnt] = i;
if (cnt >= 3) ans = 3;
if (cnt <= 1) continue;
ss.insert(make_pair(now[1], now[2]));
ss.insert(make_pair(now[2], now[1]));
}
for (auto i : ss) add(i.first, i.second);
for (int i = 1; i <= n; i++) {
if (ans == 3) break;
dfs(i, 0, i);
}
if (ans <= 2) assert(0);
printf("%d\n", (ans == 100 ? -1 : ans));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3002;
const long long int M = 998244353;
int n, m;
string S, T;
bool vis[MAXN][MAXN];
long long int memo[MAXN][MAXN];
long long int dp(int i, int frontOp) {
if (i < 0) return 1;
if (!vis[i][frontOp]) {
vis[i][frontOp] = true;
int pos = i + frontOp;
if (pos >= m || S[i] == T[pos]) {
memo[i][frontOp] += dp(i - 1, frontOp);
}
pos = frontOp;
if (pos >= m || S[i] == T[pos]) {
memo[i][frontOp] += dp(i - 1, frontOp + 1);
}
memo[i][frontOp] %= M;
}
return memo[i][frontOp];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> S >> T;
n = S.size(), m = T.size();
long long int ans = 0;
for (int i = m - 1; i < n; ++i) {
ans += dp(i, 0);
ans %= M;
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int ax, ay, bx, by, cx, cy;
cin >> ax >> ay;
cin >> bx >> by;
cin >> cx >> cy;
pair<int, int> ab = make_pair(bx - ax, by - ay);
pair<int, int> bc = make_pair(cx - bx, cy - by);
long long ans = ab.first * 1LL * bc.second - ab.second * 1LL * bc.first;
if (ans > 0LL)
cout << "LEFT" << endl;
else if (ans == 0)
cout << "TOWARDS" << endl;
else
cout << "RIGHT" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int t, n, k, ans = 0, v[3][maxn];
char s[3][maxn];
struct node {
int x, y;
} a[3 * maxn];
bool judge(char x) {
if (isalpha(x)) return false;
return true;
}
int bfs(node tmp) {
queue<node> q;
q.push(tmp);
while (!q.empty()) {
node nod = q.front();
int x = nod.x, y = nod.y;
q.pop();
if (y > n - 1) {
return 1;
}
if (isalpha(s[x][++y])) continue;
for (int i = -1; i <= 1; i++) {
int tempx = x + i;
if (tempx < 0 || tempx > 2) continue;
if (isalpha(s[tempx][y]) || isalpha(s[tempx][y + 1]) ||
isalpha(s[tempx][y + 2]) || v[tempx][y + 2] == 1)
continue;
v[tempx][y + 2] = 1;
if (y + 2 >= n - 1) return 1;
node tp;
tp.x = tempx;
tp.y = y + 2;
q.push(tp);
}
}
return 0;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &k);
scanf("%s%s%s", s[0], s[1], s[2]);
node tmp;
memset(v, 0, sizeof v);
for (int i = 0; i < 3; i++) {
if (s[i][0] == 's') tmp.x = i, tmp.y = 0;
}
if (bfs(tmp))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x[101], y[101], z[101], cost[101];
int ans = -1;
int main(void) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i] >> z[i] >> cost[i];
for (int i = 1; i <= n; i++) {
bool bad = false;
for (int j = 1; j <= n; j++)
if (x[i] < x[j] && y[i] < y[j] && z[i] < z[j]) bad = true;
if (!bad)
if (ans == -1 || cost[i] < cost[ans]) ans = i;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int num;
int a[1 << 12], b[1 << 12], k[1 << 16];
vector<pair<int, int> > sol;
vector<int> tree[1 << 13];
map<pair<int, int>, int> M[1 << 13];
int build(int s, int e, int i) {
if (s == e) {
tree[i].push_back(b[s]);
M[i][make_pair(0, 0)] = b[s];
return 0;
}
int mid = (s + e) / 2;
build(s, mid, 2 * i + 1), build(mid + 1, e, 2 * i + 2);
tree[i].resize(e - s + 1);
merge(tree[2 * i + 1].begin(), tree[2 * i + 1].end(), tree[2 * i + 2].begin(),
tree[2 * i + 2].end(), tree[i].begin());
return 0;
}
int query(int s, int e, int l, int r, int i) {
l = lower_bound(tree[i].begin(), tree[i].end(), l) - tree[i].begin();
r = upper_bound(tree[i].begin(), tree[i].end(), r) - tree[i].begin() - 1;
if (l > r)
return -1;
else if (M[i].count(make_pair(l, r)))
return M[i][make_pair(l, r)];
int mid = (s + e) / 2;
int a = query(s, mid, tree[i][l], tree[i][r], 2 * i + 1),
b = query(mid + 1, e, tree[i][l], tree[i][r], 2 * i + 2);
if (a == -1)
M[i][make_pair(l, r)] = b;
else if (b == -1)
M[i][make_pair(l, r)] = a;
else {
sol.push_back(make_pair(a, b));
M[i][make_pair(l, r)] = num++;
}
return M[i][make_pair(l, r)];
}
int main() {
int i;
int n, q, l, r;
scanf("%d %d", &n, &q), num = n;
for (i = 0; i < n; i++) scanf("%d", &a[i]), b[--a[i]] = i;
build(0, n - 1, 0);
for (i = 0; i < q; i++) {
scanf("%d %d", &l, &r);
l--, r--;
k[i] = query(0, n - 1, l, r, 0);
}
printf("%d\n", num);
for (i = 0; i < sol.size(); i++)
printf("%d %d\n", sol[i].first + 1, sol[i].second + 1);
for (i = 0; i < q; i++) printf("%d ", k[i] + 1);
printf("\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(long long a, long long b) { return a > b; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string str;
long long num, ans = 0;
vector<long long> a, b, n;
int N, qt = 0;
cin >> N;
while (N--) {
cin >> str >> num;
if (str == "11")
qt++, ans += num;
else if (str == "10")
a.push_back(num);
else if (str == "01")
b.push_back(num);
else
n.push_back(num);
}
sort(a.begin(), a.end(), cmp);
sort(b.begin(), b.end(), cmp);
int i;
for (i = 0; i < a.size() && i < b.size(); i++) {
ans += a[i] + b[i];
}
while (i < a.size()) n.push_back(a[i++]);
while (i < b.size()) n.push_back(b[i++]);
sort(n.begin(), n.end(), cmp);
for (i = 0; i < qt && i < n.size(); i++) ans += n[i];
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
cout << ((3 + 2 * n) -
(int)sqrt((3 + 2 * n) * (3 + 2 * n) - 4 * (n * n + n - 2 * k))) /
2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int T, n, ans[300005];
pair<int, int> a[300005];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = (1), _ = (n); i <= _; i++)
scanf("%d", &a[i].first), a[i].second = i;
sort(a + 1, a + n + 1);
for (int i = (1), _ = (n); i <= _; i++) ans[i] = 1e9;
for (int i = 1, j; i <= n; i = j + 1) {
j = i;
while (j < n && a[i].first == a[j + 1].first) j++;
int w = a[i].second - 0;
for (int k = (i), _ = (j - 1); k <= _; k++)
w = max(w, a[k + 1].second - a[k].second);
w = max(w, n + 1 - a[j].second);
ans[w] = min(ans[w], a[i].first);
}
int val = 1e9;
for (int i = (1), _ = (n); i <= _; i++) {
val = min(val, ans[i]);
printf("%d ", val == (int)1e9 ? -1 : val);
}
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
long long n, a[4];
long long pow(long long a, long long b) {
return b ? (pow((a * a) % md, b / 2) * (b % 2 ? a : 1)) % md : 1;
}
int main() {
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a[0]++;
else if (s[i] == 'C')
a[1]++;
else if (s[i] == 'G')
a[2]++;
else if (s[i] == 'T')
a[3]++;
}
sort(a, a + 4);
swap(a[0], a[3]);
swap(a[1], a[2]);
if (a[0] > a[1]) {
cout << "1" << endl;
} else if (a[1] > a[2]) {
cout << pow(2, n) << endl;
} else if (a[2] > a[3]) {
cout << pow(3, n) << endl;
} else {
cout << pow(4, n) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-12;
const int inf = 2000000000;
const long long int infLL = (long long int)1e18;
long long int MOD = 1000000007;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
bool comp(const pair<long long int, pair<long long int, long long int> > &p1,
const pair<long long int, pair<long long int, long long int> > &p2) {
return p1.first > p2.first;
}
bool comp1(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) {
if (p1.first == p2.first) {
return p1.second > p2.second;
}
return p1.first < p2.first;
}
long long int converter(string a) {
long long int i, mul = 1LL, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
int msb(unsigned x) {
union {
double a;
int b[2];
};
a = x;
return (b[1] >> 20) - 1023;
}
const int MAX = 100005;
int main() {
ios::sync_with_stdio(false);
int n;
scanf("%d", &n);
while (n--) {
int t, key1 = 0, key2 = 0, key3 = 0;
int a[100005], b[100005], c[100005];
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
for (int i = 0; i < t; i++) {
scanf("%d", &c[i]);
}
for (int i = 0; i < t; i++) {
if (c[i] == 1)
key1 = 1;
else
key2 = 1;
}
if (key1 == 1 & key2 == 1)
printf("Yes\n");
else {
sort(a, a + t);
for (int i = 0; i < t; i++) {
if (b[i] == a[i]) key3++;
}
if (key3 == t)
printf("Yes\n");
else
printf("No\n");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tot, a, b;
scanf("%d%d%d", &tot, &a, &b);
int cnt = 0;
int flag = 0;
while (cnt * a <= tot) {
if ((tot - cnt * a) % b == 0) {
printf("YES\n%d %d\n", cnt, (tot - cnt * a) / b);
flag = 1;
break;
}
cnt++;
}
if (!flag) printf("NO\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x, y, z;
cin >> x >> y >> z;
if (fabs(x - y) <= z && z != 0) {
cout << "?";
} else if (x > y) {
cout << "+";
} else if (y > x) {
cout << "-";
} else {
cout << 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, T;
int a[110];
bool b[110] = {0};
pair<int, int> p[110];
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
p[i] = make_pair(a[i], i);
}
for (i = 0; i < m; i++) {
int l, r;
scanf("%d %d", &l, &r);
}
sort(p, p + n);
for (i = 0; i < n; i++) {
b[p[i].second] = i % 2;
}
for (i = 0; i < n; i++) {
cout << b[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
int bid[maxn], org[maxn], id[maxn], a[maxn], b[maxn];
void add(int x, int num) {
while (x < maxn) a[x] += num, x += x & -x;
}
int sum(int s) {
int rt = 0;
while (s > 0) rt += a[s], s -= s & -s;
return rt;
}
int fnd(int nw) {
int tmp = sum(nw + 1), l = 1, r = nw + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (sum(mid - 1) == tmp)
r = mid;
else if (sum(mid - 1) < tmp - 1)
l = mid + 1;
else if (sum(mid) < tmp)
l = mid + 1;
else
return mid;
}
return l;
}
vector<int> his[maxn];
void solve(int p1, int his_bid) {
int l = 0, r = his[p1].size();
while (l < r) {
int m = (l + r) >> 1;
if (bid[his[p1][m]] < his_bid)
l = m + 1;
else if (m == 0 || bid[his[p1][m - 1]] < his_bid) {
printf("%d %d\n", p1, bid[his[p1][m]]);
break;
} else
r = m;
}
}
int le[maxn];
int main(int argc, char const *argv[]) {
int n, q, nw = 0;
scanf("%d", &n);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(id, 0, sizeof(id));
memset(org, 0, sizeof(org));
for (int i = 1; i <= n; i++) {
int p;
scanf("%d%d", &p, bid + i);
his[p].push_back(i);
b[p] = bid[i];
if (id[p]) org[id[p]] = 0;
id[p] = i;
org[i] = p;
}
for (int i = 1; i <= n; i++)
if (org[i]) {
id[org[i]] = ++nw;
org[nw] = org[i];
add(nw, 1);
}
scanf("%d", &q);
while (q--) {
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%d", le + i);
if (id[le[i]]) add(id[le[i]], -1);
}
if (sum(nw + 1) == 0)
puts("0 0");
else {
int tp1 = fnd(nw), p1 = org[tp1];
add(tp1, -1);
if (sum(nw + 1) != 0)
solve(p1, b[org[fnd(nw)]]);
else
solve(p1, 0);
add(tp1, +1);
}
for (int i = 0; i < k; i++)
if (id[le[i]]) add(id[le[i]], 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3fll;
const int LGN = 25;
const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
long long f(int i, int j, int k) {
if (i == 0) return (k & (1 << j)) != 0;
static long long dp[16][16][1 << 16];
static bool mark[16][16][1 << 16];
auto& ans = dp[i][j][k];
if (mark[i][j][k]) return ans;
mark[i][j][k] = true;
;
for (long long d = 0, __R = 15; d <= __R; d++)
ans += f(i - 1, (max((int)j, (int)d)),
k | ((i - 1) <= 3 ? (((d) << ((i - 1) << 2)) & 0xffff) : 0));
return ans;
}
long long g(long long x) {
if (x <= 0) return 0;
vector<int> s;
for (long long xx = x; xx; xx >>= 4) s.push_back(xx & 0xf);
reverse((s).begin(), (s).end());
int len = s.size();
long long ans = 0;
for (long long l = 1, __R = len - 1; l <= __R; l++)
for (long long d = 1, __R = 15; d <= __R; d++)
ans +=
f(l - 1, d, ((l - 1) <= 3 ? (((d) << ((l - 1) << 2)) & 0xffff) : 0));
int i = 0, j = 0, k = 0;
for (; i < len; i++) {
for (long long d = (i == 0), __R = s[i] - 1; d <= __R; d++)
ans +=
f(len - 1 - i, (max((int)j, (int)d)),
k | ((len - 1 - i) <= 3 ? (((d) << ((len - 1 - i) << 2)) & 0xffff)
: 0));
j = (max((int)j, (int)s[i]));
k |= ((len - 1 - i) <= 3 ? (((s[i]) << ((len - 1 - i) << 2)) & 0xffff) : 0);
}
ans += f(0, j, k);
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
int q;
scanf("%d", &(q));
for (long long i = 1, __R = q; i <= __R; i++) {
long long l, r;
scanf("%llx%llx", &l, &r);
printf("%lld\n", g(r) - g(l - 1));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 18;
int a[MAXN];
long long s[MAXN << 2];
int h[MAXN << 2];
void build(int id, int l, int r) {
if (l == r) {
s[id] = a[l];
h[id] = 0;
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
s[id] = s[id << 1] + s[id << 1 | 1];
h[id] = h[id << 1] + 1;
}
long long query(int id, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return s[id];
int mid = (l + r) >> 1;
long long ret = 0;
if (ll <= mid) ret += query(id << 1, l, mid, ll, rr);
if (rr > mid) ret += query(id << 1 | 1, mid + 1, r, ll, rr);
return ret;
}
void modify(int id, int l, int r, int pos, int v) {
if (l == r) {
s[id] = v;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
modify(id << 1, l, mid, pos, v);
else
modify(id << 1 | 1, mid + 1, r, pos, v);
s[id] = s[id << 1] + s[id << 1 | 1];
}
int S;
int v = 0;
long long query1(int id, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
int LLL = ((v & (S - (1 << h[id]))) ^ l),
RRR = ((v & (S - (1 << h[id]))) ^ r);
if (LLL > RRR) swap(LLL, RRR);
return query(1, 0, S - 1, LLL, RRR);
}
int mid = (l + r) >> 1;
long long ret = 0;
if (ll <= mid) ret += query1(id << 1, l, mid, ll, rr);
if (rr > mid) ret += query1(id << 1 | 1, mid + 1, r, ll, rr);
return ret;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < (1 << n); ++i) scanf("%d", &a[i]);
build(1, 0, (1 << n) - 1);
S = (1 << n);
for (int i = 1; i <= q; ++i) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int x, k;
scanf("%d%d", &x, &k);
x--;
x ^= v;
modify(1, 0, (1 << n) - 1, x, k);
} else if (tp == 2) {
int k;
scanf("%d", &k);
v ^= (1 << k) - 1;
} else if (tp == 3) {
int k;
scanf("%d", &k);
v ^= (1 << k);
} else {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
printf("%lld\n", query1(1, 0, (1 << n) - 1, l, r));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const int LEFT = 0;
const int RIGHT = 1;
int n, x, y;
int a[MAXN + 5];
long long res[MAXN + 5][2];
int vis[MAXN + 5][2];
long long dfs(int x, int direction, int state);
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= n; ++i) {
if (!vis[i][LEFT]) {
res[i][LEFT] = dfs(i, LEFT, i);
}
}
for (int i = 1; i < n; ++i) {
if (res[i + 1][LEFT] == -1)
printf("-1\n");
else
printf("%I64d\n", (long long)i + res[i + 1][LEFT]);
}
return 0;
}
long long dfs(int x, int direction, int state) {
if (x <= 0 || x > n) return 0;
if (x == 1) return -1;
if (vis[x][direction] == state)
return -1;
else if (vis[x][direction])
return res[x][direction];
vis[x][direction] = state;
long long act;
if (direction == LEFT)
act = dfs(x - a[x], !direction, state);
else
act = dfs(x + a[x], !direction, state);
if (act == -1)
return res[x][direction] = -1;
else
return res[x][direction] = act + (long long)a[x];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005, MAXL = 10;
int n;
char s[MAXN][MAXL];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
int ans = 6;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int diff = 0;
for (int k = 0; k < 6; ++k) {
diff += (s[i][k] != s[j][k]);
}
ans = min(ans, (diff - 1) / 2);
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n1, n2, n3, t1, t2, t3;
cin >> k >> n1 >> n2 >> n3 >> t1 >> t2 >> t3;
priority_queue<int> wash;
priority_queue<int> dry;
priority_queue<int> fold;
for (int i = 0; i < n1; i++) wash.push(0);
for (int i = 0; i < n2; i++) dry.push(0);
for (int i = 0; i < n3; i++) fold.push(0);
int curTime = 0;
for (int i = 0; i < k; i++) {
int a1 = -wash.top();
wash.pop();
int a2 = -dry.top();
dry.pop();
int a3 = -fold.top();
fold.pop();
curTime = ((a1) > (a2 - t1) ? (a1) : (a2 - t1)) > (a3 - t1 - t2)
? ((a1) > (a2 - t1) ? (a1) : (a2 - t1))
: (a3 - t1 - t2);
wash.push(-(curTime + t1));
dry.push(-(curTime + t1 + t2));
fold.push(-(curTime + t1 + t2 + t3));
}
cout << curTime + t1 + t2 + t3 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> noprimes(1000001);
void seive(vector<int> &primes, int n) {
vector<bool> ntprimes(n + 1, false);
ntprimes[0] = ntprimes[1] = true;
for (int i = 2; i * i <= n; i++) {
if (!ntprimes[i]) {
for (int j = i * i; j <= n; j += i) {
ntprimes[j] = true;
}
}
}
int x = 0;
for (int i = 2; i <= n; i++) {
if (!ntprimes[i]) {
primes.push_back(i);
x++;
noprimes[i] = x;
} else
noprimes[i] = x;
}
}
long long pow(long long x, long long n) {
long long res = 1;
while (n) {
if (n % 2 == 0) {
n = n / 2;
x = x * x;
} else {
res *= x;
n--;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int change = 1;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
if (i > 0) {
if (A[i] != A[i - 1]) change++;
}
}
int m = 0;
if (k >= change) {
cout << 1 << endl;
} else {
change = change - k;
m++;
if ((k - 1) > 0) {
m += ceil((float)change / (k - 1));
cout << m << endl;
} else
cout << -1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long int INF = 1e12;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, l, c, d, p, nl, np;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
cout << min((k * l) / nl, min(c * d, p / np)) / n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[256];
int str[256];
int last[256];
const int mod = 1e9 + 7;
bool cmp(int a, int b) { return last[a] < last[b]; }
int main(void) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int ans = 0;
int cnt = 0;
for (auto it : s) {
ans = (ans + mod - dp[it - 'a' + 1]) % mod;
dp[it - 'a' + 1] = (dp[it - 'a' + 1] + ans + 1) % mod;
ans = (ans + dp[it - 'a' + 1]) % mod;
last[it - 'a' + 1] = ++cnt;
}
for (int i = 1; i <= k; ++i) str[i] = i;
sort(str + 1, str + 1 + k, cmp);
for (int i = 1; i <= n; ++i) {
char it = !(i % k) ? str[k] : str[i % k];
ans = (ans + mod - dp[it]) % mod;
dp[it] = (dp[it] + ans + 1) % mod;
ans = (ans + dp[it]) % mod;
}
return cout << (ans + 1) % mod << '\n', 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int cys = 998244353;
int n;
long long fac[1000005], inv[1000005], a1[1000005], a2[1000005], lc[1000005],
rc[1000005];
char s[1000005];
long long mod(long long x) { return x >= cys ? x - cys : x; }
long long qpow(long long x, long long p) {
long long ret = 1;
for (; p; p >>= 1, x = x * x % cys)
if (p & 1) ret = ret * x % cys;
return ret;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
fac[0] = inv[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % cys;
inv[n] = qpow(fac[n], cys - 2);
for (int i = n - 1; i >= 1; i--) inv[i] = inv[i + 1] * (i + 1) % cys;
long long cnt = 0;
for (int i = 1; i <= n; i++)
if (s[i] == '?') cnt++;
for (int i = 0; i <= cnt; i++)
a1[i] = fac[cnt] * inv[i] % cys * inv[cnt - i] % cys;
for (int i = 1; i <= cnt; i++) a1[i] = mod(a1[i] + a1[i - 1]);
for (int i = 0; i < cnt; i++)
a2[i] = fac[cnt - 1] * inv[i] % cys * inv[cnt - 1 - i] % cys;
for (int i = 1; i < cnt; i++) a2[i] = mod(a2[i] + a2[i - 1]);
for (int i = 1; i <= n; i++) lc[i] = lc[i - 1] + (s[i] == '(');
for (int i = n; i >= 1; i--) rc[i] = rc[i + 1] + (s[i] == ')');
long long lcnt = 0, ans = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '?') {
if (lc[i - 1] - rc[i + 1] + lcnt < 0)
ans = mod(ans + a2[cnt - 1]);
else
ans = (ans + a2[cnt - 1] + cys -
a2[min(cnt - 1, lc[i - 1] - rc[i + 1] + lcnt)]) %
cys;
} else if (s[i] == '(') {
if (lc[i - 1] - rc[i + 1] + lcnt < 0)
ans = mod(ans + a1[cnt]);
else
ans =
(ans + a1[cnt] + cys - a1[min(cnt, lc[i - 1] - rc[i + 1] + lcnt)]) %
cys;
}
if (s[i] == '?') lcnt++;
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int n = 1e5 + 10;
int check(char temp, char str[], int len, int lim);
int max(int a, int b);
int main() {
char str[n];
int len, lim;
scanf("%d %d", &len, &lim);
scanf("%s", str);
printf("%d\n", max(check('a', str, len, lim), check('b', str, len, lim)));
return 0;
}
int check(char temp, char str[], int len, int lim) {
int low = 0;
int high = 0;
int count = 0;
int mx = 0;
while (high < len) {
if (str[high] != temp) {
count++;
}
high++;
while (count > lim && low <= high) {
if (str[low] != temp) {
count--;
}
low++;
}
while (high < len && str[high] == temp) {
high++;
}
mx = max(high - low, mx);
}
return mx;
}
int max(int a, int b) { return (a > b) ? a : b; }
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = (int)2e6 + 1, inf = (int)2e9 + 1, mod = (int)1e9 + 7;
long long sz;
double n, h, ans;
map<int, int> keys;
bool used[maxn];
string t;
int main() {
string second;
cin >> n >> h;
for (int i = 1; i <= n - 1; i++) {
ans = sqrt(i * h * h / n);
cout.precision(6);
cout << fixed << ans << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') t = -1;
c = getchar();
}
while (isdigit(c)) s = s * 10 + c - 48, c = getchar();
return s * t;
}
const int N = 505;
struct edge {
int to, nxt, v;
} e[N * N];
int head[N], cnt = 0;
inline void add(int x, int y, int v) {
e[++cnt].to = y, e[cnt].v = v, e[cnt].nxt = head[x], head[x] = cnt;
e[++cnt].to = x, e[cnt].v = v, e[cnt].nxt = head[y], head[y] = cnt;
}
bool f[N][N];
int g[N];
inline void dfs(int x, int f) {
g[x] = f;
for (register int i = head[x]; i; i = e[i].nxt)
if (g[e[i].to] == -1)
dfs(e[i].to, f ^ e[i].v);
else if (g[e[i].to] != (f ^ e[i].v))
puts("No"), exit(0);
}
char ans[N];
int main() {
int n = read(), m = read(), x, y;
for (register int i = 1; i <= m; i++) {
x = read(), y = read();
f[x][y] = f[y][x] = 1;
}
for (register int i = 1; i <= n; i++) {
bool flag = 1;
for (register int j = 1; j <= n; j++)
if (i != j && !f[i][j]) {
flag = 0;
break;
}
if (flag)
ans[i] = 'b';
else
for (register int j = 1; j <= i - 1; j++) {
if (ans[j] == 'b') continue;
if (!f[i][j])
add(i, j, 1);
else
add(i, j, 0);
}
}
memset(g, -1, sizeof(g));
for (register int i = 1; i <= n; i++)
if (ans[i] != 'b' && g[i] == -1) dfs(i, 0);
for (register int i = 1; i <= n; i++)
if (ans[i] != 'b') ans[i] = g[i] == 0 ? 'a' : 'c';
puts("Yes");
printf("%s\n", ans + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const double PI = acos(-1.0);
const double eps = 1e-12;
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const long long mod = (long long)1e9 + 9;
int m, n, K, len;
char a[105][105], route[1005];
pair<int, int> s, t, pos[1005], where[35];
pair<int, int> doit() {
for (int i = (0); i <= (len); ++i) {
int r1 = pos[i].first, c1 = pos[i].second;
int r2 = pos[i + 1].first, c2 = pos[i + 1].second;
while (r1 != r2 || c1 != c2) {
if (K == 0) return pair<int, int>(r1, c1);
int curdist = abs(r1 - r2) + abs(c1 - c2);
for (int dir = 0; dir < (4); ++dir) {
int rx = r1 + dr[dir];
int cx = c1 + dc[dir];
if (0 <= rx && rx < m && 0 <= cx && cx < n) {
int nextdist = abs(rx - r2) + abs(cx - c2);
if (nextdist == curdist - 1) {
int cost =
('a' <= a[r1][c1] && a[r1][c1] <= 'z') ? 1 : a[r1][c1] - '0';
if (K < cost) return pair<int, int>(r1, c1);
K -= cost;
r1 = rx;
c1 = cx;
break;
}
}
}
}
if (K == 0) return pair<int, int>(r2, c2);
}
return pos[len + 1];
}
int main() {
scanf("%d %d %d", &m, &n, &K);
for (int i = 0; i < (m); ++i) {
scanf("%s", a[i]);
for (int j = 0; j < (n); ++j)
if ('a' <= a[i][j] && a[i][j] <= 'z') {
where[a[i][j] - 'a'] = pair<int, int>(i, j);
}
}
scanf("%d %d %s %d %d", &s.first, &s.second, route, &t.first, &t.second);
len = strlen(route);
pos[0] = pair<int, int>(s.first - 1, s.second - 1);
for (int i = (1); i <= (len); ++i) pos[i] = where[route[i - 1] - 'a'];
pos[len + 1] = pair<int, int>(t.first - 1, t.second - 1);
pair<int, int> res = doit();
printf("%d %d\n", res.first + 1, res.second + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int po;
while (~scanf("%d%d", &n, &m)) {
char s[111111], t[111111];
int flag[111111];
int flag1[111111];
po = 99999;
scanf("%s", s);
scanf("%s", t);
int l1 = strlen(s);
int l2 = strlen(t);
for (int i = 0; i < l1; i++) {
for (int j = i; j <= (l2 - (l1 - i)); j++) {
if (s[i] == t[j]) {
int k = 0;
for (int i1 = 0, j1 = j - i; i1 < i; i1++, j1++) {
if (s[i1] != t[j1]) {
flag1[k] = i1;
k = k + 1;
}
}
for (int i1 = i + 1, j1 = j + 1; i1 < l1; i1++, j1++) {
if (s[i1] != t[j1]) {
flag1[k] = i1;
k = k + 1;
}
}
if (po > k) {
po = k;
for (int v = 0; v < k; v++) {
flag[v] = flag1[v];
}
}
}
}
}
if (po == 99999) {
printf("%d\n1", n);
for (int i = 2; i <= n; i++) {
printf(" %d", i);
}
printf("\n");
} else {
printf("%d\n", po);
for (int i = 0; i < po; i++) {
if (i == 0) {
printf("%d", flag[i] + 1);
} else {
printf(" %d", flag[i] + 1);
}
}
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long x[2000000], p[2000000], s[2000000], y;
int war(const void* a, const void* b) {
if (*(long long*)a > *(long long*)b) return (1);
return (-1);
}
int main() {
long long n, m, a, b, i, j, q, c, d, w;
scanf("%lld", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &x[i]);
}
p[0] = x[0];
s[n - 1] = x[n - 1];
for (i = 1; i < n; i++) {
p[i] = x[i] | p[i - 1];
s[n - i - 1] = x[n - i - 1] | s[n - i];
}
w = (x[0] | s[1]) - s[1];
a = 0;
if ((x[n - 1] | p[n - 2]) - p[n - 2] > w) {
w = (x[n - 1] | p[n - 2]) - p[n - 2];
a = n - 1;
}
for (i = 1; i < n - 1; i++) {
b = (p[i - 1] | s[i + 1]);
if ((x[i] | b) - b > w) {
w = (x[i] | b) - b;
a = i;
}
}
printf("%lld", x[a]);
for (i = 0; i < n; i++) {
if (i != a) printf(" %lld", x[i]);
}
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int k, a, b, c, s = 0;
cin >> k >> a >> b;
if (a >= k && b >= k) {
cout << (a / k) + (b / k) << endl;
} else if (a % k == 0 && a != 0) {
cout << a / k << endl;
} else if (b % k == 0 && b != 0) {
cout << b / k << endl;
} else {
cout << "-1" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)(3 * 1e5);
const int MAXM = 1500;
struct Line {
int a, b, c;
};
struct Point {
int x, y;
};
struct Circle {
int x, y, r;
};
int n, m;
vector<Point> rightEnds[MAXN];
vector<Point> leftEnds[MAXN];
Circle circles[MAXM];
bool operator<(const Line& l1, const Line& l2) {
if (l1.a != l2.a) return l1.a < l2.a;
if (l1.b != l2.b) return l1.b < l2.b;
return l1.c < l2.c;
}
bool operator<(const Point& p1, const Point& p2) {
if (p1.x != p2.x) return p1.x < p2.x;
return p1.y < p2.y;
}
int gcd(int a, int b) {
a = abs(a);
b = abs(b);
while (b) {
int c = a;
a = b;
b = c % b;
}
return a;
}
Line getLine(Point p1, Point p2) {
int a = p1.y - p2.y;
int b = p2.x - p1.x;
int c = p1.x * (p2.y - p1.y) - p1.y * (p2.x - p1.x);
int sgn = (a < 0 || (a == 0 && b < 0)) ? -1 : 1;
int f = gcd(a, gcd(b, c)) * sgn;
a /= f;
b /= f;
c /= f;
return {a, b, c};
}
inline int pow2(int x) { return x * x; }
inline int sqr_dist(Circle& c1, Circle& c2) {
return pow2(c1.x - c2.x) + pow2(c1.y - c2.y);
}
int main() {
scanf("%d%d", &n, &m);
map<Line, int> toId;
int trc = 0;
for (int i = 1; i <= n; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
Point p1 = {2 * x1, 2 * y1};
Point p2 = {2 * x2, 2 * y2};
if (p2 < p1) swap(p1, p2);
Line line = getLine(p1, p2);
auto ans = toId.insert({line, trc});
int idx = ans.first->second;
if (ans.second) trc++;
leftEnds[idx].push_back(p1);
rightEnds[idx].push_back(p2);
}
for (int i = 0; i <= trc - 1; ++i) {
sort(leftEnds[i].begin(), leftEnds[i].end());
sort(rightEnds[i].begin(), rightEnds[i].end());
}
for (int i = 0; i <= m - 1; ++i) {
Circle* c = &circles[i];
scanf("%d%d%d", &c->x, &c->y, &c->r);
}
int ans = 0;
Circle c1, c2;
for (int i = 0; i <= m - 2; ++i) {
c1 = circles[i];
for (int j = i + 1; j <= m - 1; ++j) {
c2 = circles[j];
if (c1.r != c2.r) continue;
if (sqr_dist(c1, c2) <= pow2(c1.r + c2.r)) continue;
Point pmid = {c1.x + c2.x, c1.y + c2.y};
Point pend = {c1.x + c2.x + 2 * (c1.y - c2.y),
c1.y + c2.y + 2 * (c2.x - c1.x)};
Line line = getLine(pmid, pend);
auto it = toId.find(line);
if (it == toId.end()) continue;
int idx = it->second;
ans += leftEnds[idx].size();
ans -= lower_bound(rightEnds[idx].begin(), rightEnds[idx].end(), pmid) -
rightEnds[idx].begin();
ans -= leftEnds[idx].end() -
upper_bound(leftEnds[idx].begin(), leftEnds[idx].end(), pmid);
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = (1 << 30);
long long primeCheck(long long x) {
if (x % 2 == 0) x -= 1;
for (long long i = x; i >= 2; i -= 2) {
bool b = true;
for (long long j = 3; j * j <= i; j += 2) {
if (i % j == 0) {
b = false;
break;
}
}
if (b) return i;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long p, y;
cin >> p >> y;
if (p >= y) {
cout << "-1\n";
return 0;
}
if (p * p >= y) {
long long prime = primeCheck(y);
if (prime > p)
cout << prime << '\n';
else
cout << "-1\n";
} else {
while (y > 0) {
int f = 0;
for (long long i = 2; i < p + 1; i++)
if (y % i == 0) {
f = 1;
break;
}
if (f)
y--;
else {
cout << y << '\n';
return 0;
}
}
cout << "-1\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<bool> alive(n, true);
vector<int> sz(n);
vector<int> pv(n);
vector<pair<int, int>> ret;
vector<int> all;
vector<int> tin(n);
vector<int> tout(n);
int T = -1;
function<void(int)> Dfs = [&](int v) {
all.push_back(v);
tin[v] = ++T;
sz[v] = 1;
for (int u : g[v]) {
if (alive[u] && u != pv[v]) {
pv[u] = v;
Dfs(u);
sz[v] += sz[u];
}
}
tout[v] = ++T;
};
function<void(int)> Solve = [&](int v) {
all.clear();
pv[v] = -1;
Dfs(v);
int total = sz[v];
while (true) {
bool found = false;
for (int u : g[v]) {
if (alive[u] && pv[u] == v && 2 * sz[u] >= total) {
v = u;
found = true;
break;
}
}
if (!found) {
break;
}
}
alive[v] = false;
set<int> best;
for (int u : g[v]) {
if (alive[u]) {
all.clear();
pv[u] = -1;
Dfs(u);
set<int> cur;
for (int w : g[u]) {
if (alive[w]) {
cur.insert(w);
}
}
if (cur.size() > best.size()) {
best = cur;
}
}
}
all.clear();
pv[v] = -1;
Dfs(v);
for (int u : all) {
if (u != v && pv[u] != v && best.find(u) == best.end()) {
ret.emplace_back(u, v);
}
}
vector<int> children;
for (int u : g[v]) {
if (alive[u]) {
children.push_back(u);
}
}
for (int u : children) {
Solve(u);
}
};
Solve(0);
assert((int)ret.size() <= 10 * n);
cout << ret.size() << '\n';
for (auto& p : ret) {
cout << p.first + 1 << " " << p.second + 1 << '\n';
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int cur, hasans, ptr;
vector<int> adj[500004];
vector<int> ans(500004);
void dfs(int now) {
cur--;
for (auto u : adj[now]) {
if (u == cur) {
dfs(u);
} else {
hasans = 0;
}
}
ans[ptr++] = now;
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n + 1; i++) {
adj[i].clear();
ans[i] = 0;
}
cur = n + 1, hasans = 1, ptr = 1;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == -1) a[i] = i + 1;
}
for (int i = 1; i <= n; i++) {
adj[a[i]].push_back(i);
}
for (int i = 1; i <= n + 1; i++) {
sort(adj[i].begin(), adj[i].end(), greater<int>());
}
dfs(n + 1);
if (!hasans) {
cout << "-1\n";
} else {
vector<int> res(n + 1);
for (int i = 1; i <= n; i++) {
res[ans[i]] = i;
}
for (int i = 1; i <= n; i++) {
cout << res[i] << ' ';
}
cout << '\n';
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct custom {
int time, l, r;
} a[200];
bool cmp(custom a, custom b) {
if (a.time != b.time) return a.time < b.time;
return a.l > b.l && a.r < b.r;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, cur, time = 0;
int low = 0, high = 0;
scanf("%d %d", &n, &cur);
low = cur, high = cur;
for (int i = 0; i < n; i++) scanf("%d %d %d", &a[i].time, &a[i].l, &a[i].r);
sort(a, a + n, cmp);
for (int i = 0; i < n; i++) {
low = low - (a[i].time - time);
high = high + (a[i].time - time);
time = a[i].time;
if (a[i].l > high || a[i].r < low) {
printf("NO\n");
break;
} else if (i == n - 1) {
printf("YES\n");
break;
} else {
if (a[i].l > low) low = a[i].l;
if (a[i].r < high) high = a[i].r;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (n + m - 2 < k) {
printf("-1");
return 0;
}
if (n < m) swap(n, m);
if (k <= m - 1)
cout << max(m / (k + 1) * n, n / (k + 1) * m);
else if (k <= n - 1)
cout << n / (k + 1) * m;
else
cout << max(m / (k - n + 2), n / (k - m + 2));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long modpow(long long a, long long n) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % 1000000007ll;
b = (b * b) % 1000000007ll;
n >>= 1;
}
return (long long)ret;
}
long long arr[1000006];
int main() {
arr[0] = 1;
for (int i = 1; i < 1000005; i++) {
arr[i] = arr[i - 1] * 2;
arr[i] %= 1000000007ll;
}
long long cnt = 0;
string s;
cin >> s;
long long ans = 0;
for (auto c : s) {
if (c == 'a')
++cnt;
else {
ans = (ans + arr[cnt] - 1) % 1000000007ll;
}
}
cout << ans % 1000000007ll;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l;
cin >> n >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (i == j)
cout << k << " ";
else
cout << 0 << " ";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<int> pos[200005];
int a[200005], b[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
pos[a[i]].push_back(i);
}
cin >> q;
while (q--) {
vector<int> c;
int cc;
cin >> cc;
c.resize(cc);
for (int& x : c) {
cin >> x;
}
int o = n + 1;
{
int l = 1, r = n;
while (l <= r) {
int m = (l + r) >> 1;
int br = 0;
for (int x : c) {
br += pos[x].end() - lower_bound(pos[x].begin(), pos[x].end(), m);
}
if (br == n - m + 1) {
o = m;
r = m - 1;
} else {
l = m + 1;
}
}
}
o--;
if (o == 0) {
cout << "0 0\n";
continue;
}
int aoo = a[o];
c.push_back(aoo);
{
int l = 1, r = o;
while (l <= r) {
int m = (l + r) >> 1;
int br = 0;
for (int x : c) {
br += pos[x].end() - lower_bound(pos[x].begin(), pos[x].end(), m);
}
if (br == n - m + 1) {
o = m;
r = m - 1;
} else {
l = m + 1;
}
}
}
o = *lower_bound(pos[aoo].begin(), pos[aoo].end(), o);
cout << a[o] << ' ' << b[o] << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 5;
using namespace std;
int n, q;
struct node {
int x, y, z;
} a[maxn], b[maxn], c[maxn];
int tot = 1, ans[maxn];
bool tmp(const node &u, const node &v) {
if (u.x != v.x) return u.x > v.x;
return u.y < v.y;
}
bool cc(const node &u, const node &v) {
if (u.x != v.x) return u.x < v.x;
return u.y < v.y;
}
bool cmp(const node &u, const node &v) { return u.y < v.y; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x), a[i].y = i;
sort(a + 1, a + n + 1, tmp);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d %d", &b[i].x, &b[i].y), b[i].z = i;
sort(b + 1, b + q + 1, cc);
for (int i = 1; i <= q;) {
int m = b[i].x;
for (; tot <= m; tot++) c[tot].x = a[tot].x, c[tot].y = a[tot].y;
sort(c + 1, c + tot, cmp);
for (; b[i].x == m; i++) ans[b[i].z] = c[b[i].y].x;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 10e10;
long long vis[50][50];
char b[50][50];
void dfs(long long i, long long j, long long n, long long m) {
vis[i][j] = 1;
if (i + 1 < n && i + 1 >= 0 && j < m && j >= 0) {
if (!vis[i + 1][j] && b[i + 1][j] == '.') {
dfs(i + 1, j, n, m);
}
}
if (i - 1 < n && i - 1 >= 0 && j < m && j >= 0) {
if (!vis[i - 1][j] && b[i - 1][j] == '.') {
dfs(i - 1, j, n, m);
}
}
if (i < n && i >= 0 && j + 1 < m && j + 1 >= 0) {
if (!vis[i][j + 1] && b[i][j + 1] == '.') {
dfs(i, j + 1, n, m);
}
}
if (i < n && i >= 0 && j - 1 < m && j - 1 >= 0) {
if (!vis[i][j - 1] && b[i][j - 1] == '.') {
dfs(i, j - 1, n, m);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
for (long long i = 0; i < 50; i++) {
for (long long j = 0; j < 50; j++) {
vis[i][j] = 0;
}
}
long long n, m;
cin >> n >> m;
long long g_cnt = 0;
char a[n][m];
long long cnt_g = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
b[i][j] = a[i][j];
if (b[i][j] == 'B' || b[i][j] == 'G') {
b[i][j] = '.';
}
if (a[i][j] == 'G') {
g_cnt++;
}
}
}
bool poss = true;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (a[i][j] == 'B') {
b[i][j] = '#';
if (i + 1 < n && i + 1 >= 0 && j < m && j >= 0) {
b[i + 1][j] = '#';
}
if (i - 1 < n && i - 1 >= 0 && j < m && j >= 0) {
b[i - 1][j] = '#';
}
if (i < n && i >= 0 && j + 1 < m && j + 1 >= 0) {
b[i][j + 1] = '#';
}
if (i < n && i >= 0 && j - 1 < m && j - 1 >= 0) {
b[i][j - 1] = '#';
}
}
}
}
dfs(n - 1, m - 1, n, m);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (a[i][j] == 'G') {
if (vis[i][j] != 1) {
poss = false;
}
}
}
}
if (b[n - 1][m - 1] == '#' && g_cnt > 0) {
poss = false;
}
if (poss) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int fscn() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = fscn(), n, mi, count;
while (t--) {
n = fscn();
int arr[n];
for (long long i = 0; i < n; i++) {
arr[i] = fscn();
}
mi = arr[n - 1];
count = 0;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] > mi) count++;
mi = min(arr[i], mi);
}
printf("%d\n", count);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1, mod = 1000000007;
const int N = 1000006;
const int C = 62 * 62;
char s[3], e[C], ans[N];
int id[3], n, in[C], out[C], cc, t;
int g[C][C];
vector<int> a;
void add(int p) { ans[t++] = e[p]; }
void show(int v) { printf("%c%c\n", e[v / cc], e[v % cc]); }
void endBad() {
puts("NO");
exit(0);
}
void findPath(int v) {
for (int i = 0; i < C; i++)
while (g[v][i] > 0) {
g[v][i]--;
findPath(i);
}
a.push_back(v);
}
int main() {
for (int i = 0; i < 26; i++) {
if (i < 10) e[cc++] = '0' + i;
e[cc++] = 'a' + i;
e[cc++] = 'A' + i;
}
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < 3; j++)
for (int k = 0; k < cc; k++)
if (s[j] == e[k]) {
id[j] = k;
break;
}
int v1 = id[0] * cc + id[1];
int v2 = id[1] * cc + id[2];
g[v1][v2]++;
out[v1]++;
in[v2]++;
}
int start = -1, end = -1;
for (int i = 0; i < C; i++) {
if (out[i] != in[i]) {
if (out[i] - in[i] == 1) {
if (start == -1)
start = i;
else
endBad();
} else if (in[i] - out[i] == 1) {
if (end == -1)
end = i;
else
endBad();
} else
endBad();
}
}
bool no = (start != -1) ^ (end != -1);
if (no) endBad();
if (start != -1) g[end][start]++, out[end]++, in[start]++;
int v = 0;
while (out[v] == 0) v++;
findPath(v);
reverse(a.begin(), a.end());
if (start != -1) a.pop_back();
int len = a.size();
if (start == -1 || (a[0] == start && a[len - 1] == end)) {
add(a[0] / cc);
for (int i = 0; i < len; i++) add(a[i] % cc);
} else {
for (int i = 1; i < len; i++)
if (a[i - 1] == end && a[i] == start) {
add(start / cc);
add(start % cc);
for (int j = (i + 1) % len; j != i; j = (j + 1) % len) add(a[j] % cc);
break;
}
}
if (t < n + 2) endBad();
puts("YES");
puts(ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int computeLCD(long long int a, long long int b) {
if (a < b) {
long long int tmp = a;
a = b;
b = tmp;
}
long long int tmpA = a;
long long int tmpB = b;
while (1) {
if ((a % b) == 0) break;
if (b == 1) break;
long long int tmp = a;
a = b;
b = tmp - (tmp / b) * b;
}
return (tmpA * tmpB) / b;
}
int main() {
long long int totalW;
long long int Ha;
long long int Hb;
long long int Wa;
long long int Wb;
long long int res = 0;
cin >> totalW >> Ha >> Hb >> Wa >> Wb;
long long int diff = Ha * Wb - Hb * Wa;
if (diff < 0 || (diff == 0 && Wa < Wb)) {
long long int tmp;
tmp = Wa;
Wa = Wb;
Wb = tmp;
tmp = Ha;
Ha = Hb;
Hb = tmp;
}
long long int changeMax = computeLCD(Wa, Wb) / Wa;
long long int MaxA = totalW / Wa;
long long int MaxB = totalW / Wb;
long long int remainW = totalW - MaxA * Wa;
long long int result1 = MaxA * Ha;
long long int result2 = 0;
long long int result3 = MaxB * Hb;
long long int tmpResult;
long long int remainStart;
remainStart = (Wb - (totalW - MaxA * Wa)) / Wa;
for (long long int i = remainStart; i <= MaxA && i <= changeMax; i++) {
long long int remain = remainW + i * Wa;
if (remain % Wb <= remainW) {
tmpResult = (remain / Wb) * Hb + (MaxA - i) * Ha;
if (result2 < tmpResult) result2 = tmpResult;
}
}
if (result1 >= result2 && result1 >= result3)
cout << result1 << endl;
else if (result2 >= result1 && result2 >= result3)
cout << result2 << endl;
else
cout << result3 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long Fac[(220005)], ReN[(220005)], ReFac[(220005)];
long long D[(220005)], Shit[(220005)];
int A[(220005)];
int N;
long long Ans;
inline long long C(const int& n, const int& r) {
return Fac[n] * ReFac[r] % (1000000007) * ReFac[n - r] % (1000000007);
}
int main() {
Fac[0] = 1;
for (int i = 1; i < (220005); i++) Fac[i] = Fac[i - 1] * i % (1000000007);
ReN[1] = 1;
for (int i = 2; i < (220005); i++)
ReN[i] = (ReN[(1000000007) % i] * ((1000000007) / i) % (1000000007) * (-1) +
(1000000007)) %
(1000000007);
ReFac[0] = 1;
for (int i = 1; i < (220005); i++)
ReFac[i] = ReFac[i - 1] * ReN[i] % (1000000007);
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
if (0 == N % 4) {
for (int i = 0; i < N; i++) {
if (i & 1)
D[i] = -C(N / 2 - 1, i / 2);
else
D[i] = C(N / 2 - 1, i / 2);
}
} else if (2 == N % 4) {
for (int i = 0; i < N; i++) D[i] = C(N / 2 - 1, i / 2);
} else if (1 == N % 4) {
for (int i = 0; i < N; i += 2) D[i] = C(N / 2, i / 2);
} else {
N -= 2;
for (int i = 0; i < N; i += 2) Shit[i] = C(N / 2, i / 2);
N += 2;
D[0] = 1;
for (int i = 1; i <= (N / 2); i += 2) D[i] = Shit[i - 1] * 2 % (1000000007);
for (int i = 2; i <= (N / 2); i += 2)
D[i] = (D[i + 1] - D[i - 1] + (1000000007)) % (1000000007) * ReN[2] %
(1000000007);
for (int i = N / 2 + 1; i < N; i++) {
if (i & 1)
D[i] = D[N - i - 1];
else
D[i] = -D[N - i - 1];
}
}
for (int i = 0; i < N; i++) {
Ans = ((Ans + (((long long)A[i] * D[i] % (1000000007) + (1000000007)) %
(1000000007))) %
(1000000007) +
(1000000007)) %
(1000000007);
}
printf("%lld\n", Ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int rooms;
scanf("%d", &rooms);
int ans = 0;
while (rooms--) {
int p, q;
scanf("%d%d", &p, &q);
int available = q - p;
if (available >= 2) {
ans++;
}
}
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 20;
const int sq = 500;
vector<int> a[maxn];
vector<pair<int, int> > adj[maxn];
int pos[maxn];
void solve() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) adj[i].clear();
for (int i = 0; i < q; i++) {
int k;
cin >> k;
a[i].clear();
while (k--) {
int x;
cin >> x;
x--;
a[i].push_back(x);
}
}
for (int i = 0; i < q; i++)
if ((int)a[i].size() >= sq) {
memset(pos, -1, sizeof pos);
for (int j = 0; j < (int)a[i].size(); j++) pos[a[i][j]] = j;
for (int j = 0; j < q; j++)
if (j > i || (int)a[j].size() < sq) {
int mx = -1;
for (int ind = (int)a[j].size() - 1; ind >= 0; ind--) {
int k = a[j][ind];
if (pos[k] != -1 && mx > pos[k] &&
a[j][ind + 1] != a[i][pos[k] + 1]) {
cout << "Human" << endl;
return;
}
mx = max(mx, pos[k]);
}
}
}
for (int i = 0; i < q; i++)
if ((int)a[i].size() < sq)
for (int j = 0; j < (int)a[i].size(); j++)
for (int k = j + 1; k < (int)a[i].size(); k++) {
int x = a[i][j], y = a[i][k];
adj[x].push_back({y, a[i][j + 1]});
}
memset(pos, -1, sizeof pos);
for (int i = 0; i < n; i++) {
for (auto x : adj[i]) {
if (pos[x.first] != -1 && pos[x.first] != x.second) {
cout << "Human" << endl;
return;
}
pos[x.first] = x.second;
}
for (auto x : adj[i]) pos[x.first] = -1;
}
cout << "Robot" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i(0); i <= (8); ++i) printf("%d\?\?<>%d\n", i, i + 1);
printf("%d\?\?>>\?\?0\n", 9);
puts("\?\?<>1");
for (int i(0); i <= (9); ++i) printf("\?%d>>%d\?\n", i, i);
for (int i(0); i <= (9); ++i) printf("%d\?>>%d\?\?\n", i, i);
puts(">>\?");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
};
int n;
cin >> n;
vector<int> v;
vector<int> a(1e6 + 10), b(1e6 + 10);
set<int> s;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
s.insert(x);
a[x]++;
}
for (auto x : s) v.push_back(x);
int sofar = -1;
for (int i = 0; i < 1e6 + 5; i++) {
b[i] = sofar;
if (a[i]) sofar = i;
}
int max1 = 0;
for (int i = 0; i < v.size(); i++) {
int x = v[i];
for (int j = 2 * x; j < 1e6 + 5; j += x) {
int y = b[j];
max1 = max(max1, y % x);
}
int y = b[1e6 + 2];
max1 = max(max1, y % x);
}
cout << max1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (auto& x : a) cin >> x;
int ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
while (j + 1 < n && a[j] != a[j + 1]) ++j;
++j;
if ((i ^ j) & 1) {
for (auto k = (i); k < (j); ++k) a[k] = a[i];
} else {
for (auto k = (i); k < ((i + j) / 2); ++k) a[k] = a[i];
for (auto k = ((i + j) / 2); k < (j); ++k) a[k] = a[j - 1];
}
ckmax(ans, (j - i - 1) / 2);
}
cout << ans << '\n';
for (auto x : a) cout << x << ' ';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string A, B, C;
cin >> A;
cin >> B;
for (int i = A.size() - 1; i >= 0; i--) {
C.push_back(A[i]);
}
if (B == C) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, x, t, y, z, w, ans = 1, l, md[1002], a[1002];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> x, md[x % m]++, a[x % m] = x;
for (int i = 0; i < m; ++i) {
if (md[i] > 1) {
cout << 0;
return 0;
}
}
for (int i = 0; i < m; ++i) {
if (!md[i]) continue;
for (int j = i + 1; j < m; ++j)
if (md[j]) ans = (ans * (max(a[i], a[j]) - min(a[i], a[j]))) % m;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int MOD = 1000000007;
const int INV2 = (MOD + 1) >> 1;
const int N = 17;
template <class type>
void FWT(vector<type> &a, int n, int r) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0; k < i; k++) {
int x = a[j + k];
int y = a[j + k + i];
if (r) {
a[j + k] = (x + y) % MOD;
a[j + k + i] = (x - y + MOD) % MOD;
} else {
a[j + k] = 1LL * (x + y) * INV2 % MOD;
a[j + k + i] = 1LL * (x - y + MOD) * INV2 % MOD;
}
}
}
}
}
pair<int, int> father[maxn];
int flag[maxn];
vector<pair<int, int> > E[maxn];
set<tuple<int, int, int> > non_tree_edges;
bool used[maxn];
void dfs(int u, int fa, int w) {
father[u] = make_pair(fa, w);
used[u] = 1;
for (auto edge : E[u]) {
int v, w;
tie(v, w) = edge;
if (v == fa) continue;
if (!used[v])
dfs(v, u, w);
else
non_tree_edges.insert(make_tuple(min(u, v), max(u, v), w));
}
}
vector<int> get_vec(int u, int v, int w) {
memset(flag, 0, sizeof flag);
int now = u;
while (now) {
flag[now] |= 1;
now = father[now].first;
}
now = v;
while (now) {
flag[now] |= 2;
now = father[now].first;
}
vector<int> vec(1 << N, 0);
vec[w]++;
now = u;
while (flag[now] != 3) {
vec[father[now].second]++;
now = father[now].first;
}
now = v;
while (flag[now] != 3) {
vec[father[now].second]++;
now = father[now].first;
}
return vec;
}
bool check(vector<int> &a, int prefix, int low) {
for (int mask = 0; mask < (1 << low); mask++) {
if (a[prefix + mask]) return true;
}
return false;
}
int main() {
int n, m;
cin >> n >> m;
int sum = 0;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
E[u].push_back(make_pair(v, w));
E[v].push_back(make_pair(u, w));
sum ^= w;
}
dfs(1, 0, 0);
vector<int> a(1 << N, 0);
vector<int> b(1 << N, 0);
a[0] = 1;
b[0] = 1;
FWT(a, 1 << N, 1);
for (auto edge : non_tree_edges) {
int u, v, w;
tie(u, v, w) = edge;
vector<int> vec = get_vec(u, v, w);
FWT(vec, 1 << N, 1);
for (int i = 0; i < (1 << N); i++) {
a[i] = 1ll * a[i] * vec[i] % MOD;
}
FWT(b, 1 << N, 1);
for (int i = 0; i < (1 << N); i++) {
b[i] = 1ll * b[i] * vec[i] % MOD;
}
FWT(b, 1 << N, 0);
for (int i = 0; i < (1 << N); i++) {
b[i] = b[i] != 0;
}
}
FWT(a, 1 << N, 0);
int ans = 0;
for (int i = N - 1; i >= 0; i--) {
int bit = sum & (1 << i);
if (check(b, ans + bit, i)) {
ans += bit;
} else {
ans += (bit ^ (1 << i));
}
}
cout << (ans ^ sum) << " " << a[ans] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
const long long mod = 1e9 + 9;
map<pair<int, int>, int> S;
map<pair<int, int>, int>::iterator p;
set<int> f;
set<int>::iterator q;
vector<int> G[MAX], Gr[MAX];
vector<int>::iterator r;
int n, x, y, id;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> n;
pair<int, int> aux;
for (int i = 0; i < n; i++) {
cin >> aux.first >> aux.second;
S[aux] = i;
}
for (p = S.begin(); p != S.end(); ++p) {
x = p->first.first;
y = p->first.second;
id = p->second;
if (S.find(make_pair(x, y - 1)) != S.end()) {
G[id].push_back(S[make_pair(x, y - 1)]);
Gr[S[make_pair(x, y - 1)]].push_back(id);
}
if (S.find(make_pair(x - 1, y - 1)) != S.end()) {
G[id].push_back(S[make_pair(x - 1, y - 1)]);
Gr[S[make_pair(x - 1, y - 1)]].push_back(id);
}
if (S.find(make_pair(x + 1, y - 1)) != S.end()) {
G[id].push_back(S[make_pair(x + 1, y - 1)]);
Gr[S[make_pair(x + 1, y - 1)]].push_back(id);
}
}
bool yes;
for (int i = 0; i < n; i++) {
yes = true;
for (int j = 0; j < Gr[i].size(); j++) {
if (G[Gr[i][j]].size() < 2) yes = false;
}
if (yes == true) f.insert(i);
}
long long sol = 0;
int IN;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
IN = *f.rbegin();
f.erase(IN);
sol *= (long long)n;
sol += (long long)IN;
sol %= mod;
} else {
IN = *f.begin();
f.erase(IN);
sol *= (long long)n;
sol += (long long)IN;
sol %= mod;
}
for (int j = 0; j < Gr[IN].size(); j++) {
for (r = G[Gr[IN][j]].begin(); r != G[Gr[IN][j]].end(); ++r) {
if (*r == IN) {
G[Gr[IN][j]].erase(r);
break;
}
}
if (G[Gr[IN][j]].size() < 2) {
if (f.find(G[Gr[IN][j]][0]) != f.end()) {
f.erase(*f.find(G[Gr[IN][j]][0]));
}
}
}
for (int j = 0; j < G[IN].size(); j++) {
for (r = Gr[G[IN][j]].begin(); r != Gr[G[IN][j]].end(); ++r) {
if (*r == IN) {
Gr[G[IN][j]].erase(r);
break;
}
}
yes = true;
for (int k = 0; k < Gr[G[IN][j]].size(); k++)
if (G[Gr[G[IN][j]][k]].size() < 2) yes = false;
if (yes == true) f.insert(G[IN][j]);
}
G[IN].clear();
Gr[IN].clear();
}
cout << sol << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> like[2000 + 1];
vector<int> dislike[2000 + 1];
int main() {
int n, m1, m2;
cin >> n >> m1;
for (int i = 0; i < m1; i++) {
int a, b;
cin >> a >> b;
like[a].push_back(b);
like[b].push_back(a);
}
cin >> m2;
for (int i = 0; i < m2; i++) {
int a, b;
cin >> a >> b;
dislike[a].push_back(b);
dislike[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int ans1 = 0;
bool vis[2000 + 1];
memset(vis, false, sizeof vis);
vis[i] = true;
queue<int> q;
queue<int> q1;
q.push(i);
q1.push(i);
while (!q.empty()) {
int cur = q.front();
ans1++;
q1.push(cur);
q.pop();
for (int j = 0; j < int(like[cur].size()); j++) {
if (!vis[like[cur][j]]) {
vis[like[cur][j]] = true;
q.push(like[cur][j]);
}
}
}
bool sw1 = true;
while (!q1.empty()) {
bool sw = true;
int cur = q1.front();
q1.pop();
for (int j = 0; j < int(dislike[cur].size()); j++)
if (vis[dislike[cur][j]]) {
sw = false;
break;
}
if (!sw) {
sw1 = false;
break;
}
}
if (!sw1) continue;
ans = max(ans, ans1);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class segm_tree {
vector<pair<int, int> > tr;
int off;
public:
segm_tree(const vector<int> &as) {
off = 1;
while (off < ((int)(as).size())) off <<= 1;
tr = vector<pair<int, int> >(2 * off, make_pair(-1, -1));
for (int i = 0; i < ((int)(as).size()); i++)
tr[off + i] = make_pair(as[i], i);
for (int i = off - 1; i >= 1; i--) tr[i] = max(tr[2 * i], tr[2 * i + 1]);
}
pair<int, int> get(int l, int r) {
l += off;
r += off;
pair<int, int> res(-1, -1);
while (l <= r) {
if (l & 1) res = max(res, tr[l++]);
if (!(r & 1)) res = max(res, tr[r--]);
l >>= 1;
r >>= 1;
}
return res;
}
};
const int K = 18;
int main() {
int n;
while (scanf("%d", &n) >= 1) {
vector<int> as(n);
for (int i = 0; i < n; i++) scanf("%d", &as[i]);
reverse(as.begin(), as.end());
for (int i = 0; i < n; i++) as.push_back(as[i]);
vector<int> maxr(((int)(as).size()));
for (int i = 0; i < ((int)(as).size()); i++)
maxr[i] = min(i + as[i], ((int)(as).size()) - 1);
segm_tree tr(maxr);
vector<vector<pair<int, int> > > ne(
((int)(as).size()), vector<pair<int, int> >(K, make_pair(-1, -1)));
for (int i = ((int)(as).size()) - 1; i >= 0; i--) {
ne[i][0] = make_pair(
i + 1 == ((int)(as).size()) ? i : tr.get(i + 1, maxr[i]).second, i);
for (int i2 = 1; i2 < K; i2++)
ne[i][i2] = ne[ne[i][i2 - 1].first][i2 - 1];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int clen = 0, goal = n + i - 1;
pair<int, int> cv(i, -1);
for (int i2 = K - 1; i2 >= 0; i2--)
if (ne[cv.first][i2].first < goal) {
cv = ne[cv.first][i2];
assert(cv.second >= 0);
clen += 1 << i2;
}
assert(cv.first < goal);
assert(ne[cv.first][0].first >= goal);
if (cv.second >= 0 && maxr[cv.second] >= goal) {
} else {
clen++;
}
ans += clen;
}
printf("%I64d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> d;
int main() {
int n;
scanf("%d", &n);
d.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
}
sort(d.begin(), d.end());
d.resize(unique(d.begin(), d.end()) - d.begin());
int a, b;
scanf("%d%d", &a, &b);
int c = 0;
while (a != b) {
int e = 1;
for (int i = d.size() - 1; i >= 0; i--)
if (a % d[i] > a - b)
d.erase(d.begin() + i, d.begin() + i + 1);
else
e = max(e, a % d[i]);
a -= e;
c++;
}
printf("%d\n", c);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
long long int power(long long int x, long long int y) {
long long int ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
const long long int N = 1e6;
long long int f[N], inf[N];
void pre() {
f[0] = f[1] = 1;
for (long long int i = 1; i < N; i++) f[i] = (f[i - 1] * i) % mod;
inf[N - 1] = power(f[N - 1], mod - 2);
for (long long int i = N - 1; i >= 1; i--) inf[i - 1] = inf[i] * i % mod;
}
long long int ncr(long long int n, long long int r) {
return ((f[n] * (inf[n - r]) % mod) * inf[r]) % mod;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tt = 1;
long long int ii = 0;
while (tt-- && ++ii) {
long long int n, k;
cin >> n >> k;
if (n < k) return cout << 0, 0;
pre();
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
long long int val = n / i - 1;
if (val >= k - 1)
ans = (ans + ncr(val, k - 1)) % mod;
else
break;
}
cout << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310, M = 210 * 210;
int res[N][N];
int a[N], b[N];
int edgeCnt, visId;
int vis[N], head[N], nxt[M], to[M], weight[M];
void addEdge(int u, int v, int w) {
nxt[edgeCnt] = head[u];
to[edgeCnt] = v;
weight[edgeCnt] = w;
head[u] = edgeCnt++;
}
void addBi(int u, int v, int w) {
addEdge(u, v, w);
addEdge(v, u, 0);
}
bool getPath(int u, int snk, int flow) {
if (u == snk) return 1;
if (vis[u] == visId) return 0;
vis[u] = visId;
for (int i = head[u]; i != -1; i = nxt[i]) {
if (weight[i] >= flow && getPath(to[i], snk, flow)) {
weight[i] -= flow;
weight[i ^ 1] += flow;
return 1;
}
}
return 0;
}
int maxFlow(int src, int snk) {
int res = 0;
for (int flow = 1 << 20; flow; flow >>= 1) {
visId++;
while (getPath(src, snk, flow)) {
res += flow;
visId++;
}
}
return res;
}
int main() {
int s1 = 0, s2 = 0;
int n, m;
scanf("%d %d\n", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), s1 += a[i];
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), s2 += b[i];
memset(head, -1, sizeof head);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
addBi(u, v + n, a[u]);
addBi(v, u + n, a[v]);
}
for (int i = 1; i <= n; ++i) {
addBi(0, i, a[i]);
addBi(i, n + i, a[i]);
addBi(n + i, 2 * n + 1, b[i]);
}
int mx = maxFlow(0, 2 * n + 1);
if (mx != s1 || mx != s2)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = head[i]; j != -1; j = nxt[j]) {
res[i][to[j] - n] = weight[j ^ 1];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
printf("%d ", res[i][j]);
}
puts("");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
int n, m, sx, sy, tx, ty;
char s[N][N];
int dr[] = {0, 0, 1, -1};
int dc[] = {1, -1, 0, 0};
int cost[N][N];
bool vis[N][N];
struct node {
int x, y, t, d;
node(int X = 0, int Y = 0, int T = 0, int D = 0) {
x = X, y = Y, t = T, d = D;
}
bool operator<(const node &o) const { return t > o.t; }
};
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'S')
sx = i, sy = j;
else if (s[i][j] == 'T')
tx = i, ty = j;
cost[i][j] = 1e9;
}
}
priority_queue<node> q;
q.push(node(sx, sy, -1, -1));
cost[sx][sy] = -1;
int x, y, t, nx, ny, nt, d, nd;
while (!q.empty()) {
x = q.top().x;
y = q.top().y;
t = q.top().t;
d = q.top().d;
q.pop();
if (vis[x][y]) continue;
vis[x][y] = true;
for (int k = 0; k < 4; ++k) {
nx = x + dr[k], ny = y + dc[k];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny] ||
s[nx][ny] == '*')
continue;
nd = k;
nt = cost[x][y] + (d != nd);
if (cost[nx][ny] < nt) continue;
cost[nx][ny] = nt;
q.push(node(nx, ny, nt, nd));
}
}
puts(cost[tx][ty] <= 2 ? "YES" : "NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1000005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
cin >> n >> m;
char s[n + 2][m + 2];
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) cin >> s[i][j];
}
long long int f = 0, k;
long long int st = 0, en;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (s[i][j] == 'B') {
f = i;
k = j;
break;
}
}
if (f) break;
}
for (long long int j = k; j <= m; j++) {
if (s[f][j] == 'W') {
en = j - 1;
break;
} else if (j == m) {
en = j;
break;
}
}
long long int y = (k + en) / 2;
for (long long int i = f; i <= n; i++) {
if (s[i][k] == 'W') {
cout << (f + i - 1) / 2 << ' ' << y;
break;
} else if (i == n) {
cout << (f + i) / 2 << ' ' << y;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[100][100], b[100], mn = 1000;
int calc(int row) {
int c1 = 0, c2 = 0, tot = 0;
for (int i = 0; i < n; i++) {
c1 = c2 = 0;
for (int j = 0; j < m; j++) {
if (a[row][j] == a[i][j])
c1++;
else
c2++;
}
tot += m - max(c1, c2);
}
return tot;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
if (n > k) {
for (int i = 0; i < n; i++) {
mn = min(mn, calc(i));
}
} else {
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if ((i & (1 << j)) > 0) {
b[j] = 1;
} else {
b[j] = 0;
}
}
int tot = 0;
for (int j = 0; j < m; j++) {
int c1 = 0, c2 = 0;
for (int k = 0; k < n; k++) {
if (b[k] == a[k][j])
c1++;
else
c2++;
}
tot += n - max(c1, c2);
}
mn = min(mn, tot);
}
}
if (mn <= k)
cout << mn << "\n";
else
cout << -1 << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(default : 4996)
using namespace std;
int vis[200005], a[200005], c0[200005], c1[200005];
int i, n;
int cnt0, cnt1;
long long ans = 0;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 0) {
cnt0++;
c0[cnt0] = cnt1;
}
if (a[i] == 1) {
cnt1++;
c1[cnt1] = cnt0;
}
}
if (cnt0 < cnt1) {
for (i = cnt0; i >= 1; i--) {
ans += c0[i] + 0ll;
}
} else {
for (i = 1; i <= cnt1; i++) {
ans += (cnt0 - c1[i]) + 0ll;
}
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double num[100010];
int main() {
int n;
scanf("%d", &n);
double k, b;
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", &k, &b);
if (k != 0) num[++cnt] = -(long double)b / (long double)k;
}
sort(num + 1, num + cnt + 1);
int ans = 1;
for (int i = 2; i <= cnt; i++) {
if (fabs(num[i] - num[i - 1]) > 1e-20) ans++;
}
if (cnt != 0)
printf("%d\n", ans);
else
printf("%d\n", 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long first, long long second) {
return !second ? first : gcd(second, first % second);
}
long long x, y, z;
deque<long long> q, p;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> x;
for (int i = 1; i <= x; i++) {
if (i % 2 == 0) {
z += i;
q.push_back(i);
} else {
y += i;
p.push_back(i);
}
}
if (gcd(y, z) > 1) {
cout << "Yes" << endl;
cout << q.size() << " ";
while (!q.empty()) {
cout << q.front() << " ";
q.pop_front();
}
cout << endl;
cout << p.size() << " ";
while (!p.empty()) {
cout << p.front() << " ";
p.pop_front();
}
cout << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
bool ok = true;
for (int i = 0; i < n - 1; i++) {
if (h[i] < h[i + 1] - k) {
int d = h[i + 1] - k - h[i];
if (d > m) {
ok = false;
break;
} else {
m -= d;
}
} else {
m += h[i] - max(0, (h[i + 1] - k));
}
}
if (ok) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adjList[150000], adjList2[150000];
int parent[150000], size[150000], disc[150000], fin[150000], num = 0;
int doDFS(int u, int p) {
int i;
parent[u] = p, size[u] = 1;
disc[u] = num++;
for (i = 0; i < adjList[u].size(); i++) {
int v = adjList[u][i];
if (v != p) size[u] += doDFS(v, u), adjList2[u].push_back(v);
}
fin[u] = num;
return size[u];
}
int bit[150001], all = 0;
int update(int i, int num, int n) {
if (i == 0) {
all += num;
if (all >= 998244353) all -= 998244353;
return 0;
}
for (i++; i <= n; i += i & (-i)) {
bit[i] += num;
if (bit[i] >= 998244353) bit[i] -= 998244353;
}
return 0;
}
int query(int i) {
int sum = all;
for (i++; i > 0; i -= i & (-i)) {
sum += bit[i];
if (sum >= 998244353) sum -= 998244353;
}
return sum;
}
int inv(long long int n) {
int e = 998244353 - 2;
long long int r = 1;
while (e > 0) {
if (e & 1) r *= n, r %= 998244353;
e >>= 1;
n *= n, n %= 998244353;
}
return r;
}
vector<int> big;
int bigSum[150000];
int main() {
int i, j;
int n, q;
int t, u, v, d;
scanf("%d %d", &n, &q);
for (i = 0; i < n - 1; i++) {
scanf("%d %d", &u, &v);
u--, v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
int B = sqrt(n);
doDFS(0, -1);
for (i = 0; i < n; i++) {
if (adjList[i].size() > B) big.push_back(i);
}
int invn = inv(n);
for (i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d %d", &u, &d), u--;
if (adjList[u].size() > B)
bigSum[u] += d, bigSum[u] %= 998244353;
else {
update(0, d, n);
for (j = 0; j < adjList[u].size(); j++) {
int v = adjList[u][j];
if (v != parent[u]) {
int x = ((long long int)size[v] * d) % 998244353;
update(0, x, n), update(disc[v], 998244353 - x, n),
update(fin[v], x, n);
} else {
int x = ((long long int)(n - size[u]) * d) % 998244353;
update(disc[u], x, n), update(fin[u], 998244353 - x, n);
}
}
}
} else {
scanf("%d", &u), u--;
int ans = query(disc[u]);
for (j = 0; j < big.size(); j++) {
v = big[j];
if (u == v)
ans += ((long long int)bigSum[v] * n) % 998244353;
else if ((disc[u] >= disc[v]) && (disc[u] < fin[v])) {
int l = 0, r = adjList2[v].size() - 1;
while (l < r) {
int m = (l + r + 1) / 2;
if (disc[u] >= disc[adjList2[v][m]])
l = m;
else
r = m - 1;
}
ans += ((long long int)(n - size[adjList2[v][l]]) * bigSum[v]) %
998244353;
} else
ans += ((long long int)size[v] * bigSum[v]) % 998244353;
if (ans >= 998244353) ans -= 998244353;
}
printf("%I64d\n", ((long long int)ans * invn) % 998244353);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h;
scanf("%d", &h);
while (h--) {
int t;
long long a, b;
scanf("%lld%lld", &a, &b);
if (a > b) {
t = a;
a = b;
b = t;
}
if (a <= 2) {
if (b == a * 2)
printf("YES\n");
else
printf("NO\n");
} else if (a == 3) {
if (b == 3 || b == 6)
printf("YES\n");
else
printf("NO\n");
} else if (a > 3) {
if (a % 3 == 1) {
if (b == a + 1 || (b - a - 1) % 3 == 0) {
if (b <= 2 * a)
printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
}
if (a % 3 == 2) {
if (b == a + 2 || (b - a - 2) % 3 == 0) {
if (b <= 2 * a)
printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
}
if (a % 3 == 0) {
if (b == a || (b - a) % 3 == 0) {
if (b <= 2 * a)
printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int main() {
int n, q;
int a[N];
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int s = sqrt(n);
deque<int> v[s + 2];
int qtd[s + 2][n + 1];
memset(qtd, 0, sizeof qtd);
for (int i = 0; i < n; i++) {
v[i / s].push_back(a[i]);
qtd[i / s][a[i]]++;
}
int last = 0;
scanf("%d", &q);
while (q--) {
int op, l, r, k;
scanf("%d %d %d", &op, &l, &r);
l = (l + last - 1) % n;
r = (r + last - 1) % n;
if (l > r) swap(l, r);
vector<int> auxl, auxr;
int ls = l / s;
int rs = r / s;
if (op == 1) {
int ant = v[ls].back();
for (int i = ls + 1; i < rs; i++) {
qtd[i][ant]++;
v[i].push_front(ant);
ant = v[i].back();
qtd[i][ant]--;
v[i].pop_back();
}
if (rs != ls) {
while (l / s == ls) {
auxl.push_back(v[ls].back());
v[ls].pop_back();
l++;
}
reverse(auxl.begin(), auxl.end());
while (r / s == rs) {
auxr.push_back(v[rs].front());
v[rs].pop_front();
r--;
}
qtd[ls][*auxr.rbegin()]++;
v[ls].push_back(*auxr.rbegin());
qtd[ls][*auxl.rbegin()]--;
for (int i = 0; i < auxl.size() - 1; i++) v[ls].push_back(auxl[i]);
qtd[rs][*auxr.rbegin()]--;
for (int i = auxr.size() - 2; i >= 0; i--) v[rs].push_front(auxr[i]);
v[rs].push_front(ant);
qtd[rs][ant]++;
} else {
while (v[ls].size()) {
auxl.push_back(v[ls].front());
v[ls].pop_front();
}
int ini = ls * s;
l -= ini;
r -= ini;
ant = auxl[l];
auxl[l] = auxl[r];
for (int i = l + 1; i <= r; i++) swap(auxl[i], ant);
for (int i = 0; i < auxl.size(); i++) v[ls].push_back(auxl[i]);
}
} else {
int k;
int ans = 0;
scanf("%d", &k);
k = ((k + last - 1) % n) + 1;
for (int i = ls + 1; i < rs; i++) ans += qtd[i][k];
if (ls != rs) {
while (l / s == ls && l <= r) {
if (v[ls].back() == k) ans++;
auxl.push_back(v[ls].back());
v[ls].pop_back();
l++;
}
for (int i = auxl.size() - 1; i >= 0; i--) v[ls].push_back(auxl[i]);
while (r / s == rs && r >= l) {
if (v[rs].front() == k) ans++;
auxr.push_back(v[rs].front());
v[rs].pop_front();
r--;
}
for (int i = auxr.size() - 1; i >= 0; i--) v[rs].push_front(auxr[i]);
} else {
while (v[ls].size()) {
auxl.push_back(v[ls].front());
v[ls].pop_front();
}
int ini = ls * s;
l -= ini;
r -= ini;
for (int i = l; i <= r; i++) ans += auxl[i] == k;
for (int i = 0; i < auxl.size(); i++) v[ls].push_back(auxl[i]);
}
last = ans;
printf("%d\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, seed, vmax;
long long rnd() {
long long ret = seed;
seed = (seed * 7 + 13) % 1000000007;
return ret;
}
long long exp(long long x, long long y, long long m) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return exp(x * x % m, y / 2, m);
else
return x * exp(x, y - 1, m) % m;
}
void solve() {
cin >> n >> m >> seed >> vmax;
map<int, long long> A;
vector<int> a(n + 1);
for (int i = 1; i <= (n); ++i) {
a[i] = (rnd() % vmax) + 1;
A.insert({i, a[i]});
}
A[n + 1] = 0;
while (m--) {
int op = (rnd() % 4) + 1;
int l = (rnd() % n) + 1;
int r = (rnd() % n) + 1;
int x, y;
if (l > r) swap(l, r);
if (op == 3)
x = (rnd() % (r - l + 1)) + 1;
else
x = (rnd() % vmax) + 1;
if (op == 4) y = (rnd() % vmax) + 1;
auto it_l = A.upper_bound(l);
it_l--;
if (it_l->first != l) {
A[l] = it_l->second;
it_l++;
}
auto it_r = A.upper_bound(r + 1);
it_r--;
if (it_r->first != r + 1) {
A[r + 1] = it_r->second;
it_r++;
}
switch (op) {
case 1:
while (it_l != it_r) {
it_l->second += x;
it_l++;
}
break;
case 2:
it_l->second = x;
it_l++;
while (it_l != it_r) {
A.erase(it_l++);
}
break;
case 3: {
vector<pair<long long, int>> v;
int prev = l;
long long val = it_l->second;
it_l++;
while (it_l != it_r) {
v.push_back({val, it_l->first - prev});
val = it_l->second;
prev = it_l->first;
it_l++;
}
v.push_back({val, it_l->first - prev});
sort(v.begin(), v.end());
int cnt = 0;
for (int i = 0; i <= ((int)(v).size() - 1); ++i) {
cnt += v[i].second;
if (cnt >= x) {
cout << v[i].first << endl;
break;
}
}
} break;
case 4: {
vector<tuple<long long, int>> v;
int prev = l;
long long val = it_l->second;
it_l++;
while (it_l != it_r) {
v.push_back({val, it_l->first - prev});
val = it_l->second;
prev = it_l->first;
it_l++;
}
v.push_back({val, it_l->first - prev});
long long ans = 0;
for (int i = 0; i <= ((int)(v).size() - 1); ++i) {
ans += ((long long)exp(get<0>(v[i]) % y, x, y) * get<1>(v[i]) % y);
ans %= y;
}
cout << ans << endl;
break;
}
}
}
}
int main() {
clock_t beg = clock();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
clock_t end = clock();
fprintf(stderr, "%lf\n", (double)(end - beg) / CLOCKS_PER_SEC);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const int N = 2e5;
long long gi() {
long long w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
int main() {
long long n = gi(), m = gi(), a = gi(), d = gi(), last = 0, k, x, y, ans = 0,
u = d / a + 1;
while (m--) {
k = gi();
x = max(last / a + 1, 1LL);
y = min(k / a, n);
if (x <= y) {
ans += (y - x) / u + 1;
last = (x + (y - x) / u * u) * a + d;
}
if (last < k) last = k + d, ans++;
}
x = max(last / a + 1, 1LL);
if (x <= n) ans += (n - x) / u + 1;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX, N = 50 + 7;
queue<long long> q;
int main() {
long long n, b, last = 0, t, d;
scanf("%lld %lld", &n, &b);
b++;
while (n--) {
scanf("%lld %lld", &t, &d);
last = max(last, 1ll * t);
while (!q.empty() && q.front() <= t) {
q.pop();
}
if (q.size() == b) {
printf("-1 ");
} else {
last += d;
printf("%lld ", last);
q.push(last);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace WorkSpace {
const int Mod = 1e9 + 7;
long long F[110][110 * 110];
long long C[110][110];
long long P[110][110 * 110][2];
long long Pow(long long A, long long B) {
long long ret = 1;
while (B) {
if ((B % 2)) ret = ((ret % Mod) * (A % Mod)) % Mod;
A = ((A % Mod) * (A % Mod)) % Mod;
B = B >> 1;
}
return ret;
}
void Main() {
int N, K;
long long M;
scanf("%d%lld%d", &N, &M, &K);
C[0][0] = 1;
for (int i = 1; i <= 100; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % Mod;
}
}
int tmp = M % N;
for (int i = 1; i <= N; ++i) {
for (int s = 0; s <= K; ++s) {
if (i <= tmp)
P[i][s][0] = Pow(C[N][s], M / N + 1);
else
P[i][s][1] = Pow(C[N][s], M / N);
}
}
for (int i = 0; i <= N; ++i) F[i][0] = 1;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= K; ++j) {
for (int k = 0; k <= min(j, N); ++k) {
if (i <= tmp) {
F[i][j] = (F[i][j] + F[i - 1][j - k] * P[i][k][0] % Mod) % Mod;
} else {
F[i][j] = (F[i][j] + F[i - 1][j - k] * P[i][k][1]) % Mod;
}
}
}
}
printf("%lld\n", F[N][K]);
}
} // namespace WorkSpace
int main() {
WorkSpace ::Main();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smax(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void smin(T &x, T y) {
x = min((x), (y));
}
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const int MN = 300;
string s;
bool vis[SIZE];
int cmpnum;
pair<int, int> cmp[SIZE];
int n;
int dp[SIZE][2];
vector<int> grp[SIZE];
int speced;
int mo(int x) {
x %= n;
while (x < 0) x += n;
return x;
}
bool within(int x, int lef, int rig) { return x >= lef && x <= rig; }
int go(int x, int ed) {
if (x > ed) return 0;
int b = 0;
if (ed == speced) b = 1;
if (dp[x][b] >= 0) return dp[x][b];
int &ret = dp[x][b] = 0;
bool specialcase = false;
int specialend = -1;
int nxst = -1;
for (int i = 0; i < (((int)(grp[x]).size())); ++i) {
int c = grp[x][i];
if (cmp[c].first > cmp[c].second) {
specialcase = true;
specialend = cmp[c].first - 1;
}
smax(nxst, cmp[c].second + 1);
}
if (specialcase) {
if (x > specialend)
ret = 1;
else {
ret = max(1 + go(nxst, specialend), go(x + 1, ed));
}
} else {
ret = max(1 + go(nxst, ed), go(x + 1, ed));
}
return ret;
}
int main() {
if (0) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
while (cin >> s) {
n = ((int)(s).size());
cmpnum = 0;
memset((vis), 0, sizeof((vis)));
memset((dp), -1, sizeof((dp)));
speced = -1;
if (!vis[n - 1]) {
char x = s[n - 1];
int st = n - 1, ed = n - 1;
vis[n - 1] = 1;
while (s[mo(st - 1)] == x) st = mo(st - 1), vis[st] = 1;
while (s[mo(ed + 1)] == x) ed = mo(ed + 1), vis[ed] = 1;
ed = mo(ed + 1);
cmp[cmpnum++] = make_pair(st, ed);
if (st > ed) speced = st - 1;
}
for (int i = 0; i < (n); ++i)
if (!vis[i]) {
char x = s[i];
int st = i, ed = i;
vis[i] = 1;
while (s[mo(st - 1)] == x) st = mo(st - 1), vis[st] = 1;
while (s[mo(ed + 1)] == x) ed = mo(ed + 1), vis[ed] = 1;
ed = mo(ed + 1);
cmp[cmpnum++] = make_pair(st, ed);
if (st > ed) speced = st - 1;
}
for (int i = 0; i < (cmpnum); ++i) {
int j = cmp[i].first;
if (j <= cmp[i].second)
while (j <= cmp[i].second) {
grp[j].push_back(i);
j++;
}
else {
while (j <= n - 1) {
grp[j].push_back(i);
j++;
}
j = 0;
while (j <= cmp[i].second) {
grp[j].push_back(i);
j++;
}
}
}
printf("%d\n", go(0, n - 1));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int kasus;
bool prima[4000000LL + 5];
long long angka;
int main() {
cin >> angka;
memset(prima, 0, sizeof(prima));
for (long long i = 2; i <= 4000000LL / i; ++i) {
if (!prima[i]) {
for (long long j = i; j <= 4000000LL / i; ++j) prima[i * j] = true;
}
}
long long faktor2, faktor1;
long long temp = angka;
int total = 0;
for (long long i = 2; i <= temp / i; ++i) {
if (prima[i]) continue;
while (temp % i == 0) {
temp /= i;
++total;
faktor2 = faktor1;
faktor1 = i;
}
}
if (angka == 1) total = 1;
if (temp != 1) {
faktor2 = faktor1;
faktor1 = temp;
++total;
}
if (total == 2)
printf("2\n");
else {
printf("1\n");
if (angka == temp)
printf("0\n");
else {
cout << faktor2 * faktor1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int N = 100010;
const int mod = 998244353;
const double PI = 3.1415926535898;
int n;
long long a, r, m;
long long h[N];
inline long long calc(long long x) {
long long p = 0, q = 0;
for (int i = 1; i <= n; ++i) {
if (h[i] <= x)
p += x - h[i];
else
q += h[i] - x;
}
return min(p * a + q * r,
min(p, q) * m + (p - min(p, q)) * a + (q - min(p, q)) * r);
}
int main() {
scanf("%d %lld %lld %lld", &n, &a, &r, &m);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &h[i]);
}
long long l = 0, r = 2000000000, mid, ret = 0;
for (int t = 1; t <= 233; ++t) {
mid = (l + r) >> 1;
if (calc(mid) < calc((mid + r) >> 1))
r = (mid + r) >> 1;
else
l = mid;
}
printf("%lld\n", calc(l));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
int dat[105][105];
bool vis[105];
void dfs(int x) {
vis[x] = true;
cnt++;
for (int i = 1; i <= n; i++)
if (!vis[i] && dat[x][i] == 1) dfs(i);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
dat[x][y] = 1;
dat[y][x] = 1;
}
dfs(1);
if (cnt == n && m == n)
cout << "FHTAGN!"
<< "\n";
else
cout << "NO\n";
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.