solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b) {
long long r = 1;
while (b > 0) {
if (b & 1) r = (r * a);
a = (a * a);
b >>= 1;
}
return r;
}
long long moduloMultiplication(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first)
return (a.second < b.second);
else
return (a.first < b.first);
}
const int mxn = 1e5 + 5;
long long ans = 1e9;
long long b[mxn];
long long check(long long f, long long s, long long a[], long long n) {
long long ct = 0;
long long d = s - f;
b[0] = f;
b[1] = s;
for (int i = 2; i < n; i++) b[i] = a[i];
for (int i = 2; i < n; i++) {
s += d;
if (b[i] - b[i - 1] == d - 1) {
ct++;
b[i]++;
} else if (b[i] - b[i - 1] == d + 1) {
ct++;
b[i]--;
} else if (b[i] - b[i - 1] == d) {
} else
return 1e9;
}
return ct;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
ans = min(check(a[0] - 1, a[1] - 1, a, n) + 2, ans);
ans = min(check(a[0] - 1, a[1] + 1, a, n) + 2, ans);
ans = min(check(a[0] - 1, a[1], a, n) + 1, ans);
ans = min(check(a[0] + 1, a[1] - 1, a, n) + 2, ans);
ans = min(check(a[0] + 1, a[1] + 1, a, n) + 2, ans);
ans = min(check(a[0] + 1, a[1], a, n) + 1, ans);
ans = min(check(a[0], a[1] + 1, a, n) + 1, ans);
ans = min(check(a[0], a[1] - 1, a, n) + 1, ans);
ans = min(check(a[0], a[1], a, n), ans);
if (ans != 1e9)
cout << ans << endl;
else
cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
cin >> n >> m;
vector<long long int> v;
vector<long long int> v1;
map<int, int> g1;
long long int c1 = 0;
long long int c2 = 0;
for (long long int i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
}
for (long long int i = 0; i < n; i++) {
long long int f = 0;
if (g1.find(v[i]) != g1.end()) {
int lo = 1;
} else {
f = 1;
v1.push_back(v[i]);
c2 += 1;
g1.insert(make_pair(v[i], 1));
}
if (c2 - c1 > m) {
long long int p = v1[c1];
c1 += 1;
if (g1.find(p) != g1.end()) {
auto itr = g1.find(p);
g1.erase(p);
}
}
}
cout << c2 - c1 << endl;
for (int i = c2 - 1; i >= c1; i--) {
cout << v1[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 2e5 + 10;
vector<int> adj[NN];
int sum, cnt;
int dfs(int u, int fa = 0) {
int son = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
if (!dfs(v, u)) son++;
;
}
if (son && u != 1) {
sum += son;
cnt++;
}
return son;
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
cnt = 0, sum = 0;
int root = dfs(1);
int ans = 0;
if (root) {
ans += root;
if (cnt) ans--;
}
ans += sum;
if (cnt) ans -= cnt - 1;
printf("%d\n", ans);
for (int i = 1; i <= n; i++) adj[i].clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Range = 10000001;
bool Primes[Range] = {false};
void IsPrime() {
Primes[0] = true;
Primes[1] = true;
for (int i = 2; i <= Range; i++) {
if (!Primes[i]) {
for (int j = i; (long long)j * i <= Range; j++) {
Primes[j * i] = true;
}
}
}
}
bool IsPrimeDIV(long long p) {
bool check = false;
for (int i = 2; i < sqrt(p); i++)
if (p % i == 0) {
check = true;
break;
}
if (check == true) {
return false;
} else if (check == false) {
return true;
}
}
int main() {
string sample;
bool precheck = true;
cin >> sample;
for (int i = 0; i < sample.size(); i++) {
if (sample[i] == 'B') {
precheck = false;
} else if (sample[i] == 'C') {
precheck = false;
} else if (sample[i] == 'D') {
precheck = false;
} else if (sample[i] == 'E') {
precheck = false;
} else if (sample[i] == 'F') {
precheck = false;
} else if (sample[i] == 'G') {
precheck = false;
} else if (sample[i] == 'J') {
precheck = false;
} else if (sample[i] == 'K') {
precheck = false;
} else if (sample[i] == 'L') {
precheck = false;
} else if (sample[i] == 'N') {
precheck = false;
} else if (sample[i] == 'P') {
precheck = false;
} else if (sample[i] == 'Q') {
precheck = false;
} else if (sample[i] == 'R') {
precheck = false;
} else if (sample[i] == 'S') {
precheck = false;
} else if (sample[i] == 'Z') {
precheck = false;
}
}
bool seccheck = true;
for (int i = 0; i < sample.size(); i++) {
if (sample[i] == sample[sample.size() - 1 - i]) {
continue;
} else {
seccheck = false;
}
}
if (precheck == true && seccheck == true) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 100;
const long long INF = 1e18;
int n;
long long a[MAXN];
long long dp[MAXN][3][2];
long long go(int pos, int open, int len) {
if (pos == n) {
if (open == 1 && len == 0) return -INF;
return 0;
}
if (dp[pos][open][len] != -1) return dp[pos][open][len];
int nlen = 0;
if (open == 1) nlen = 1 - len;
long long op1 = go(pos + 1, open, nlen);
if ((open == 0 || open == 2) && pos % 2 == 0) op1 += a[pos];
if (open == 1 && pos % 2 == 1) op1 += a[pos];
int nopen = -1;
long long op2 = 0;
if (open == 0) nopen = 1;
if (open == 1 && len == 1) {
nopen = 2;
nlen = 0;
}
if (nopen != -1) {
op2 = go(pos + 1, nopen, nlen);
if ((nopen == 0 || nopen == 2) && pos % 2 == 0) op2 += a[pos];
if (nopen == 1 && pos % 2 == 1) op2 += a[pos];
}
return dp[pos][open][len] = max(op1, op2);
}
long long solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = -1;
}
}
}
long long res = go(0, 0, 0);
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
cout << solve() << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool f) {
if (f)
return "True";
else
return "False";
}
string to_string(const char *s) { return to_string((string)s); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = false;
string r = "{";
for (auto x : v) {
if (f) r += ", ";
r += to_string(x);
f = true;
}
return r += "}";
}
template <typename A>
string to_string(vector<vector<A>> v) {
string r;
for (auto x : v) r += "\n" + to_string(x);
return r;
}
int Nerr;
template <typename A>
string to_string(A *p) {
return to_string(vector<A>(p, p + Nerr));
}
void err(istream_iterator<string>) { cerr << '\n'; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << to_string(a) << "; ";
err(++it, args...);
}
template <typename T>
void kek(T ans) {
cout << ans << '\n';
exit(0);
}
int power(int x, unsigned int y, unsigned int m) {
if (y == 0) return 1;
int p = power(x, y / 2, m) % m;
p = (p * 1ll * p) % m;
return (y % 2 == 0) ? p : (x * 1ll * p) % m;
}
template <long long p, long long w>
struct Field {
using T = Field;
long long x;
Field(long long x = 0) : x{x} {}
T operator+(T r) const { return {(x + r.x) % p}; }
void operator+=(T r) { x = (x + r.x) % p; }
T operator-(T r) const { return {(x - r.x + p) % p}; }
void operator-=(T r) { x = (x - r.x + p) % p; }
T operator*(T r) const { return {(x * r.x) % p}; }
void operator*=(T r) { x = (x * r.x) % p; }
T operator/(T r) const { return (*this) * r.inv(); }
void operator/=(T r) { x = (x * r.inv()) % p; }
T inv() const { return {power(x, p - 2, p)}; }
static T root(long long k) {
auto r = power(w, (p - 1) / abs(k), p);
return k >= 0 ? T{r} : T{r}.inv();
}
bool zero() const { return x == 0LL; }
};
using F = Field<2, 0>;
constexpr double pi = 3.1415926535897932384626433;
struct Complex {
using T = Complex;
double u, v;
Complex(double u = 0, double v = 0) : u{u}, v{v} {}
T operator+(T r) const { return {u + r.u, v + r.v}; }
T operator-(T r) const { return {u - r.u, v - r.v}; }
T operator*(T r) const { return {u * r.u - v * r.v, u * r.v + v * r.u}; }
T operator/(T r) const {
auto norm = r.u * r.u + r.v * r.v;
return {(u * r.u + v * r.v) / norm, (v * r.u - u * r.v) / norm};
}
T operator*(double r) const { return T{u * r, v * r}; }
T operator/(double r) const { return T{u / r, v / r}; }
T inv() const { return T{1, 0} / *this; }
T conj() const { return T{u, -v}; }
static T root(long long k) { return {cos(2 * pi / k), sin(2 * pi / k)}; }
bool zero() const { return max(abs(u), abs(v)) < 1e-6; }
};
void brinc(int &x, int k) {
int i = k - 1, s = 1 << i;
x ^= s;
if ((x & s) != s) {
--i;
s >>= 1;
while (i >= 0 && ((x & s) == s)) x = x & ~s, --i, s >>= 1;
if (i >= 0) x |= s;
}
}
using T = Complex;
vector<T> roots;
void fft(vector<T> &A, int p, bool inv = false) {
int N = 1 << p;
for (int i = 0, r = 0; i < N; ++i, brinc(r, p))
if (i < r) swap(A[i], A[r]);
for (int m = 2; m <= N; m <<= 1) {
T w, w_m = T::root(inv ? -m : m);
for (int k = 0; k < N; k += m) {
w = T{1};
for (int j = 0; j < m / 2; ++j) {
T t = w * A[k + j + m / 2];
A[k + j + m / 2] = A[k + j] - t;
A[k + j] = A[k + j] + t;
w = w * w_m;
}
}
}
if (inv) {
T inverse = T(N).inv();
for (auto &x : A) x = x * inverse;
}
}
void convolution(vector<T> A, vector<T> B, vector<T> &C) {
int s = A.size() + B.size() - 1;
int q = 32 - __builtin_clz(s - 1), N = 1 << q;
A.resize(N, {});
B.resize(N, {});
C.resize(N, {});
fft(A, q, false);
fft(B, q, false);
for (int i = 0; i < N; ++i) C[i] = A[i] * B[i];
fft(C, q, true);
C.resize(s);
}
void square_inplace(vector<T> &A) {
int s = 2 * A.size() - 1, q = 32 - __builtin_clz(s - 1), N = 1 << q;
A.resize(N, {});
fft(A, q, false);
for (auto &x : A) x = x * x;
fft(A, q, true);
A.resize(s);
}
int parent[6];
void make_set(int v) { parent[v] = v; }
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) parent[b] = a;
}
signed main() {
ios_base::sync_with_stdio(0);
int TESTS = 1;
while (TESTS--) {
string s, t;
cin >> s >> t;
vector<T> a[6], b[6];
int n = (int)s.size();
int m = (int)t.size();
for (int i = 0; i < 6; i++) {
vector<T> temp(n);
for (int j = 0; j < n; j++)
if (s[j] == 'a' + i) temp[j].u = 1;
a[i] = temp;
}
reverse((t).begin(), (t).end());
for (int i = 0; i < 6; i++) {
vector<T> temp(m);
for (int j = m - 1; j >= 0; j--)
if (t[j] == 'a' + i) temp[j].u = 1;
b[i] = temp;
}
vector<int> ans(n);
vector<T> c[6][6];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
if (i == j) continue;
vector<T> temp;
convolution(a[i], b[j], c[i][j]);
}
}
for (int p = 0; p < n; p++) {
int sum = 0;
for (int i = 0; i < 6; i++) parent[i] = i;
for (int i = 0; i < 6; i++) {
for (int j = i + 1; j < 6; j++) {
bool ans = 0;
ans = (!c[i][j][p].zero()) | (!c[j][i][p].zero());
if (ans) union_sets(i, j);
}
}
unordered_set<int> s;
for (int i = 0; i < 6; i++) s.insert(find_set(i));
ans[p] = 6 - (int)s.size();
}
for (int i = m - 1; i < n; i++) cout << ans[i] << " ";
cout << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long nop = 100;
vector<int> primes(nop, 1);
long long cnt = 0;
void sieve() {
primes[1] = primes[0] = 0;
for (long long i = 2; i * i <= nop; i++) {
if (primes[i]) {
for (long long j = i * i; j <= nop; j += i) {
primes[j] = 0;
}
}
}
}
bool isVowel(char ch) {
ch = tolower(ch);
return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u');
}
long long gcd(long long a, long long b) {
if (b > a) swap(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
void extgcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = a;
y = b;
return;
}
extgcd(b % a, a, x, y);
long long y1 = y, x1 = x;
x = y1 - (b / a) * x1;
y = x1;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long bexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans *= num;
}
num *= num;
e >>= 1;
}
return ans;
}
long long mexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans = (ans * num) % mod;
}
num = (num * num) % mod;
e >>= 1;
}
return ans % mod;
}
long long modinv(long long a) { return bexp(a, mod - 2); }
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
string s, t;
cin >> s >> t;
long long ans = 0;
for (long long i = 0; i < s.length(); i++) {
for (long long l = 1; l <= s.length() - i; l++) {
long long j = i + l - 1;
long long ti = 0;
for (long long k = 0; k < s.length(); k++) {
if (k == i) {
k = j;
continue;
}
if (s[k] == t[ti]) {
ti++;
}
if (ti == t.length()) break;
}
if (ti == t.length()) ans = max(ans, l);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int> > a(2, vector<int>(n + 1, 0));
for (int i = 0; i < 2; i++)
for (int j = 1; j <= n - 1; j++) cin >> a[i][j];
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 1; i <= n - 1; i++) a[0][i] += a[0][i - 1];
for (int i = n - 2; i >= 1; i--) a[1][i] += a[1][i + 1];
vector<int> ans;
for (int i = 0; i < n; i++) {
int temp = 0;
temp += b[i];
temp += a[0][i];
temp += a[1][i + 1];
ans.push_back(temp);
}
sort(ans.begin(), ans.end());
cout << ans[0] + ans[1] << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int t;
cin>>t;
while(t--) {
int n;
cin>>n;
vector<int> a(n),b(n),ord(n);
for(int i=0;i<n;++i) cin>>a[i];
for(int i=0;i<n;++i) cin>>b[i];
iota(ord.begin(),ord.end(),0);
sort(ord.begin(),ord.end(),[&](int i,int j){return a[i]<a[j];});
int ans=0,x=1,y=1;
for(int i:ord) {
int nx=a[i],ny=b[i];
if(x==nx && ny==y);
else {
assert(nx>x); assert(nx-x>=ny-y);
int cnt1 = (nx-x)-(ny-y), cnt2 = nx-x-cnt1;
if(cnt1) {
if((x+y)%2) --cnt1,++ans;
ans+=cnt1/2;
} else {
if((x+y)%2==0) ans+=cnt2;
}
}
x=nx,y=ny;
}
cout<<ans<<endl;
}
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
const int MAXM = 210;
long long n;
int x[MAXN], y[MAXN];
int cnt[MAXM][MAXM];
long long tot;
int cnt_get(int &p, int &q) { return cnt[p + 100][q + 100]; }
void cnt_add(int &p, int &q) { cnt[p + 100][q + 100]++; }
bool inRange(int a, int b) {
return (-100 <= a && a <= 100 && -100 <= b && b <= 100);
}
int gcd(int a, int b) {
while (b != 0) {
int t = a;
a = b;
b = t % a;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
cnt_add(a, b);
x[i] = a;
y[i] = b;
}
tot = n * (n - 1) * (n - 2);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (i == j) continue;
int dx, dy, sx = x[i], sy = y[i];
dy = y[j] - y[i];
dx = x[j] - x[i];
int t = gcd(dy, dx);
dy /= t;
dx /= t;
long long t_tot = -1;
for (int sx = x[i] + dx, sy = y[i] + dy; inRange(sx, sy);
sx += dx, sy += dy)
if (cnt_get(sx, sy)) t_tot += cnt_get(sx, sy);
for (int sx = x[i] - dx, sy = y[i] - dy; inRange(sx, sy);
sx -= dx, sy -= dy)
if (cnt_get(sx, sy)) t_tot += cnt_get(sx, sy);
tot -= t_tot;
}
cout << tot / 6 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 7;
long long quickmi(long long a, long long b);
int main(void) {
long long i, j, k, p, q;
cin >> p >> q >> k;
int flag = 0;
for (i = 0; i <= 10000; i++) {
for (j = 0; j <= 10000; j++) {
if (i * p + q * j == k) {
flag = 1;
break;
}
if (i * p > k) {
break;
}
}
if (flag || i * p > k) {
break;
}
}
if (flag) {
printf("Yes\n");
} else
printf("No\n");
return 0;
}
long long quickmi(long long a, long long b) {
long long sum = 1;
while (b) {
if (b & 1) sum = (sum * a) % (N);
a = (a * a) % N;
b /= 2;
}
return sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> sal;
vector<int> pos;
int main() {
long long a, b, x, temp;
cin >> a >> b;
x = 0;
temp = 10000000;
string s, t, tsub;
cin >> s >> t;
for (int i = 0; i <= b - a; i++) {
x = 0;
tsub = t.substr(i, a);
for (int j = 0; j < a; j++) {
if (tsub[j] != s[j]) {
x++;
sal.push_back(j + 1);
}
}
if (x < temp) {
temp = x;
pos.clear();
for (int k = 0; k < sal.size(); k++) {
pos.push_back(sal[k]);
}
}
tsub.clear();
sal.clear();
}
cout << temp << '\n';
for (int k = 0; k < pos.size(); k++) {
cout << pos[k] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long bigmod(long long a, long long b) {
if (b == 0) return 1;
long long x = bigmod(a, b / 2);
x = (x * x) % MOD;
if (b % 2 == 1) x *= a;
return x % MOD;
}
int t;
int n;
int ans[10005];
bool vis[10005];
vector<int> kh(vector<int> v) {
for (int i = 0; i <= v.size(); i++) vis[i] = 0;
for (int i = 0; i < v.size(); i += 2) {
if (i + 1 >= v.size()) break;
int x = v[i];
int y = v[i + 1];
cout << "? " << x << " " << y << endl;
int rem1;
cin >> rem1;
cout << "? " << y << " " << x << endl;
int rem2;
cin >> rem2;
if (rem1 > rem2) {
ans[x] = rem1;
vis[i] = 1;
} else {
ans[y] = rem2;
vis[i + 1] = 1;
}
}
vector<int> ret;
for (int i = 0; i < v.size(); i++) {
if (!vis[i]) ret.push_back(v[i]);
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
vector<int> v;
for (int i = 1; i <= n; i++) v.push_back(i);
while (v.size() > 1) {
v = kh(v);
}
ans[v[0]] = n;
cout << "! ";
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, seq[250000], x, cnt;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &seq[i]);
sort(seq, seq + n);
if (k == 0)
x = seq[0] - 1;
else
x = seq[k - 1];
for (int i = 0; i < n; i++) {
if (x >= seq[i]) cnt++;
}
if (cnt == k && x > 0 && x <= 1000000000)
printf("%d\n", x);
else
printf("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<ld, ld>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<ld>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
str Tout[2] = {"NO", "YES"};
str tout[2] = {"No", "Yes"};
const int MOD = 1e9 + 7;
const ll MAX = 1e18;
const ll MIN = -1e18;
int main() {
str f;
ll ans = 0;
int m[256] = {};
cin >> f;
for (int i = (0); i < (int((f).size())); i++) m[f[i]]++;
for (int i = (0); i < (256); i++) ans += (ll)m[i] * m[i];
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k;
int a[1 << 22];
int cnt[22], last[22], t[22], c[22][22], T;
char s[200001];
int mask[550001], l[550001], r[550001];
int get(int i, int j, int id) {
if (i > j) return 0;
if (i < l[id]) i = l[id];
if (j > r[id]) j = r[id];
if (i == l[id] && j == r[id]) {
return mask[id];
}
return get(i, j, 2 * id) | get(i, j, 2 * id + 1);
}
int main() {
scanf("%d%d%d\n", &n, &m, &T);
gets(s);
for (i = 1; i < (1 << m); i++)
for (j = 0; j < m; j++)
if ((1 << j) & i) break;
int N = 1;
while (N <= n) N *= 2;
for (i = 2 * N - 1; i >= 1; i--) {
if (i >= N + n - 1) {
mask[i] = 0;
l[i] = r[i] = i - N;
} else if (i >= N) {
mask[i] = (1 << (s[i - N] - 'A'));
l[i] = r[i] = i - N;
} else {
l[i] = l[2 * i];
r[i] = r[2 * i + 1];
mask[i] = mask[2 * i] | mask[2 * i + 1];
}
}
for (i = 0; i < m; i++) scanf("%d", &t[i]);
for (i = 0; i < m; i++)
for (j = 0; j < m; j++) scanf("%d", &c[i][j]);
for (i = 0; i < m; i++) last[i] = -1;
for (i = 0; i < n; i++) {
k = s[i] - 'A';
cnt[k]++;
for (j = 0; j < m; j++)
if (last[j] != -1 && (last[k] == -1 || last[k] <= last[j])) {
int x = get(last[j] + 1, i - 1, 1);
a[x] += c[j][k];
a[x | (1 << j)] -= c[j][k];
a[x | (1 << k)] -= c[j][k];
a[x | (1 << j) | (1 << k)] += c[j][k];
}
last[k] = i;
}
for (i = 0; i < m; i++)
if (cnt[i] > 0) a[1 << i] += t[i];
for (j = 0; j < m; j++)
for (i = 0; i < (1 << m); i++)
if ((1 << j) & i)
;
else
a[(1 << j) | i] += a[i];
int ans = 0;
for (i = 0; i < (1 << m); i++) {
for (j = 0; j < m; j++)
if (((1 << j) & i) && !cnt[j]) {
break;
}
if (a[i] <= T && j == m) {
ans++;
}
}
if (a[(1 << m) - 1] <= T) ans--;
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
vector<string> split(string s, string sep) {
string act = "";
vector<string> res;
for (int c = 0; c < s.size(); c++) {
bool split = false;
for (int c2 = 0; c2 < sep.size(); c2++) {
if (sep[c2] == s[c]) {
split = true;
break;
}
}
if (split) {
res.push_back(act);
act = "";
} else {
act = act + s[c];
}
}
res.push_back(act);
return res;
}
string removeChars(string s, string filters) {
string res = "";
for (int c = 0; c < s.size(); c++) {
bool fine = true;
for (int c2 = 0; c2 < filters.size(); c2++) {
if (filters[c2] == s[c]) {
fine = false;
break;
}
}
if (fine) res = res + s[c];
}
return res;
}
string replaceChars(string s, string from, string to) {
for (int c = 0; c < s.size(); c++) {
for (int c2 = 0; c2 < from.size(); c2++) {
if (from[c2] == s[c]) {
s[c] = to[c2 % to.size()];
break;
}
}
}
return s;
}
struct MaximumFlow {
static const int InfCapacity = INF;
struct Edge {
int to;
int capacity;
int rev;
};
vector<vector<Edge> > g;
void init(int n) { g.assign(n, vector<Edge>()); }
void add(int i, int j, int capacity) {
Edge e, f;
e.to = j, f.to = i;
e.capacity = capacity, f.capacity = 0;
g[i].push_back(e);
g[j].push_back(f);
g[i].back().rev = (int)g[j].size() - 1;
g[j].back().rev = (int)g[i].size() - 1;
}
void addB(int i, int j, int capacity) {
Edge e, f;
e.to = j, f.to = i;
e.capacity = capacity, f.capacity = capacity;
g[i].push_back(e);
g[j].push_back(f);
g[i].back().rev = (int)g[j].size() - 1;
g[j].back().rev = (int)g[i].size() - 1;
}
int maximumFlow(int s, int t) {
int n = g.size();
vector<int> level(n);
int total = 0;
bool update;
do {
update = false;
fill(level.begin(), level.end(), -1);
level[s] = 0;
queue<int> q;
q.push(s);
for (int d = n; !q.empty() && level[q.front()] < d;) {
int u = q.front();
q.pop();
if (u == t) d = level[u];
for (auto e = (g[u]).begin(); e != (g[u]).end(); ++e)
if (e->capacity > 0 && level[e->to] == -1)
q.push(e->to), level[e->to] = level[u] + 1;
}
vector<int> iter(n);
for (int i = 0; i < n; i++) iter[i] = (int)g[i].size() - 1;
while (1) {
int f = augment(level, iter, s, t, InfCapacity);
if (f == 0) break;
total += f;
update = true;
}
} while (update);
return total;
}
int augment(vector<int> &level, vector<int> &iter, int u, int t, int f) {
if (u == t || f == 0) return f;
int lv = level[u];
if (lv == -1) return 0;
level[u] = -1;
for (; iter[u] >= 0; --iter[u]) {
Edge &e = g[u][iter[u]];
if (level[e.to] <= lv) continue;
int l = augment(level, iter, e.to, t, min(f, e.capacity));
if (l == 0) continue;
e.capacity -= l;
g[e.to][e.rev].capacity += l;
level[u] = lv;
return l;
}
return 0;
}
};
int main() {
vector<int> sizes(6);
for (int c = 0; c < sizes.size(); c++) cin >> sizes[c];
int n;
cin >> n;
MaximumFlow m;
m.init(n + 6 + 2);
for (int c = 0; c < 6; c++) {
m.add(c + 2, 1, sizes[c]);
}
string poss[6] = {"S", "M", "L", "XL", "XXL", "XXXL"};
for (int c = 0; c < n; c++) {
m.add(0, 8 + c, 1);
string line;
cin >> line;
vector<string> possibilities = split(line, ",");
for (int c2 = 0; c2 < possibilities.size(); c2++) {
for (int c3 = 0; c3 < 6; c3++) {
if (poss[c3] == possibilities[c2]) {
m.add(8 + c, c3 + 2, 1);
}
}
}
}
int res = m.maximumFlow(0, 1);
if (res != n) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int c = 0; c < n; c++) {
for (int c2 = 0; c2 < m.g[8 + c].size(); c2++) {
if (m.g[8 + c][c2].capacity == 0) {
cout << poss[m.g[8 + c][c2].to - 2] << endl;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[1000005], init[1000005], val[1000005], cnt[1000005];
long long fen[1000005];
void add(long long x, long long val) {
for (long long i = x + 1; i < 1000005; i += i & (-i)) fen[i] += val;
}
long long get(long long x) {
long long ans = 0;
for (long long i = x; i > 0; i -= i & (-i)) ans += fen[i];
return ans;
}
long long sum(long long x, long long y) { return get(y) - get(x); }
void solve() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i], init[i] = a[i];
sort(init, init + n);
long long m = unique(init, init + n) - init;
for (long long i = 0; i < n; i++)
a[i] = lower_bound(init, init + m, a[i]) - init;
for (long long i = n - 1; i >= 0; i--) {
cnt[a[i]]++;
add(cnt[a[i]], 1);
val[i] = cnt[a[i]];
}
long long ans = 0;
memset(cnt, 0, sizeof(cnt));
for (long long i = 0; i < n; i++) {
add(val[i], -1);
cnt[a[i]]++;
ans += sum(1, cnt[a[i]]);
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int maxm = maxn * 50;
int dfn[maxn], top[maxn], siz[maxn], son[maxn], dtot(0);
int fdfn[maxn], n;
struct Seg_ment {
int t[maxm], lson[maxm], rson[maxm], s[maxm];
int tot;
Seg_ment(void) { tot = 0; }
void pushup(int p) { s[p] = s[lson[p]] + s[rson[p]]; }
int merge(int u, int v) {
if (!u || !v) return u + v;
int now = ++tot;
lson[now] = merge(lson[u], lson[v]);
rson[now] = merge(rson[u], rson[v]);
pushup(now);
return now;
}
void Insert(int &p, int l, int r, int pos) {
int now = ++tot;
lson[now] = lson[p], rson[now] = rson[p], p = now;
if (l == r) return s[p] = 1, void();
if (pos <= ((l + r) >> 1))
Insert(lson[p], l, ((l + r) >> 1), pos);
else
Insert(rson[p], ((l + r) >> 1) + 1, r, pos);
pushup(p);
}
int Ask(int p, int l, int r, int ll, int rr) {
if (!p || ll > rr) return 0;
if (ll <= l && r <= rr) return s[p];
int res(0);
if (ll <= ((l + r) >> 1)) res += Ask(lson[p], l, ((l + r) >> 1), ll, rr);
if (((l + r) >> 1) < rr) res += Ask(rson[p], ((l + r) >> 1) + 1, r, ll, rr);
return res;
}
} T;
int pS[maxn], Sp[maxn << 1];
struct SAM {
int rt[maxn << 1];
vector<int> vc[maxn << 1];
struct Node {
int len, fa, c[26];
} d[maxn << 1];
int tot;
SAM(void) { tot = pS[1] = 1; }
void Insert(int c, int las, int id) {
int p = las, np = ++tot;
d[np].len = d[p].len + 1;
for (; p && !d[p].c[c]; p = d[p].fa) d[p].c[c] = np;
if (!p)
d[np].fa = 1;
else {
int q = d[p].c[c];
if (d[q].len == d[p].len + 1)
d[np].fa = q;
else {
int nq = ++tot;
d[nq] = d[q];
d[nq].len = d[p].len + 1;
d[np].fa = d[q].fa = nq;
for (; p && d[p].c[c] == q; p = d[p].fa) d[p].c[c] = nq;
}
}
pS[id] = np, Sp[np] = id;
}
void dfs(int p, int pre) {
for (int i = 0; i < vc[p].size(); ++i) {
int u = vc[p][i];
if (u == pre) continue;
dfs(u, p);
rt[p] = T.merge(rt[p], rt[u]);
}
if (Sp[p]) T.Insert(rt[p], 1, n, dfn[Sp[p]]);
}
void build() {
for (int i = 1; i <= tot; ++i) vc[i].clear();
for (int i = 1; i <= tot; ++i) vc[d[i].fa].push_back(i);
dfs(1, 0);
}
} sa;
struct Edge {
int to, next, w;
} edg[maxn << 1];
int head[maxn], cnt(0);
vector<Edge> vc[maxn];
void add(int u, int v, int w) { vc[u].push_back((Edge){v, 0, w}); }
int dep[maxn], fa[maxn], a[maxn];
void dfs1(int p, int pre) {
siz[p] = 1;
fa[p] = pre;
dep[p] = dep[pre] + 1;
for (int i = 0; i < vc[p].size(); ++i) {
int to = vc[p][i].to, w = vc[p][i].w;
if (to == pre) continue;
sa.Insert(a[to] = w, pS[p], to);
dfs1(to, p);
siz[p] += siz[to];
if (siz[son[p]] < siz[to]) son[p] = to;
}
}
void dfs2(int p, int pre, int topf) {
top[p] = topf;
dfn[p] = ++dtot;
fdfn[dtot] = p;
if (son[p]) dfs2(son[p], p, topf);
for (int i = 0; i < vc[p].size(); ++i) {
int to = vc[p][i].to;
if (to == son[p] || to == pre) continue;
dfs2(to, p, to);
}
}
int Lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
int Ask(int u, int ed, int d) {
if (dep[u] - dep[ed] + 1 <= d) return -1;
while (top[u] != top[ed]) {
if (dep[top[u]] <= d + dep[ed]) break;
u = fa[top[u]];
}
return fdfn[dfn[top[u]] + (d - dep[top[u]] + dep[ed])];
}
int Solve(int u, int ed, int p) {
if (ed == -1) return 0;
int ans(0);
while (top[u] != top[ed]) {
ans += T.Ask(p, 1, n, dfn[top[u]], dfn[u]);
u = fa[top[u]];
}
ans += T.Ask(p, 1, n, dfn[ed], dfn[u]);
return ans;
}
char s[maxn];
int nxt[maxn];
signed main() {
int i, j;
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (i = 1; i < n; ++i) {
int u, v;
char c;
cin >> u >> v >> c;
add(u, v, c - 'a'), add(v, u, c - 'a');
}
dfs1(1, 0);
dfs2(1, 0, 1);
sa.build();
int Q;
cin >> Q;
while (Q--) {
int u, v;
cin >> u >> v >> (s + 1);
int ln = strlen(s + 1);
int edu, edv, lca = Lca(u, v);
edu = Ask(u, lca, ln), edv = Ask(v, lca, ln);
int posu(1), posv(1);
for (i = ln; i >= 1; --i) posu = sa.d[posu].c[s[i] - 'a'];
for (i = 1; i <= ln; ++i) posv = sa.d[posv].c[s[i] - 'a'];
int ans(0);
ans = Solve(u, edu, sa.rt[posu]) + Solve(v, edv, sa.rt[posv]);
u = (edu == -1 ? u : fa[edu]), v = (edv == -1 ? v : fa[edv]);
string s1 = "", s2 = "";
for (; u != lca; u = fa[u]) s1 += (char)(a[u] + 'a');
for (; v != lca; v = fa[v]) s2 += (char)(a[v] + 'a');
reverse(s2.begin(), s2.end());
string S = " " + s1 + s2;
int ln1 = S.size() - 1;
j = 0;
nxt[1] = 0;
for (i = 2; i <= ln; ++i) {
while (j && s[j + 1] != s[i]) j = nxt[j];
if (s[j + 1] == s[i]) ++j;
nxt[i] = j;
}
j = 0;
for (i = 1; i <= ln1; ++i) {
while (j && s[j + 1] != S[i]) j = nxt[j];
if (s[j + 1] == S[i]) ++j;
if (j == ln) ++ans, j = nxt[j];
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[1005], b[1005];
bool cmp(const int x, const int y) { return x > y; }
bool check(int n) {
for (int i = 1; i <= n - 1; i++) {
if (a[i] >= a[i + 1]) return true;
}
return false;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(b + 1, b + 1 + k, cmp);
int t = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) a[i] = b[++t];
}
if (check(n))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int maxn = 1e5 + 10;
struct p {
int l, r, mn, lazy;
} c[maxn * 8];
void build(int l, int r, int k) {
c[k].l = l;
c[k].r = r;
if (l == r) {
scanf("%d", &c[k].mn);
return;
}
int mid = (l + r) / 2;
build(l, mid, k * 2);
build(mid + 1, r, k * 2 + 1);
c[k].mn = min(c[k * 2].mn, c[k * 2 + 1].mn);
}
void down(int k) {
if (c[k].lazy) {
c[k * 2].lazy = max(c[k].lazy, c[k * 2].lazy);
c[k * 2 + 1].lazy = max(c[k].lazy, c[k * 2 + 1].lazy);
c[k * 2].mn = max(c[k * 2].mn, c[k].lazy);
c[k * 2 + 1].mn = max(c[k * 2 + 1].mn, c[k].lazy);
c[k].lazy = 0;
}
}
void update(int p, int x, int k) {
if (c[k].l == c[k].r) {
c[k].mn = x;
return;
}
down(k);
int mid = (c[k].l + c[k].r) / 2;
if (p <= mid)
update(p, x, k * 2);
else
update(p, x, k * 2 + 1);
c[k].mn = min(c[k * 2].mn, c[k * 2 + 1].mn);
}
void update(int x, int k) {
if (c[k].mn >= x) return;
c[k].mn = x;
c[k].lazy = max(c[k].lazy, x);
}
int query(int x, int k) {
if (c[k].l == c[k].r) return c[k].mn;
down(k);
int mid = (c[k].l + c[k].r) / 2;
if (x <= mid) return query(x, k * 2);
return query(x, k * 2 + 1);
}
int main() {
scanf("%d", &n);
build(1, n, 1);
scanf("%d", &q);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int a, b;
scanf("%d %d", &a, &b);
update(a, b, 1);
} else if (op == 2) {
int a;
scanf("%d", &a);
update(a, 1);
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", query(i, 1));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename L>
bool smax(T &x, L y) {
return x < y ? (x = y, true) : false;
}
template <typename T, typename L>
bool smin(T &x, L y) {
return y < x ? (x = y, true) : false;
}
void insert_hash(long long);
long long pw(long long, long long);
void solve();
const long long MAXN = 1e6 + 15;
vector<long long> adj[MAXN];
long long v, e;
pair<long long, long long> rel[MAXN];
long long h[MAXN];
long long val[MAXN];
unordered_map<long long, long long> cnt;
long long ans;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cerr << "HELLO WORLD :)\n";
srand(time(NULL));
cin >> v >> e;
h[0] = 999999990641ll;
for (long long i = 1; i < MAXN; i++) h[i] = (h[i - 1] * 999999990641ll);
for (long long i = 0; i < e; i++) {
long long f, t;
cin >> f >> t;
adj[f].push_back(t);
adj[t].push_back(f);
rel[i] = {f, t};
}
for (long long i = 1; i <= v; i++) {
sort(adj[i].begin(), adj[i].end());
insert_hash(i);
}
for (auto i : cnt) ans += i.second * (i.second - 1) / 2ll;
solve();
return cout << ans << '\n', false;
}
long long pw(long long p, long long v) {
long long ret = 1;
for (; v; v >>= 1, p = p * p % 999999990641ll)
if (v & 1) ret = (ret * p) % 999999990641ll;
return ret;
}
void insert_hash(long long p) {
long long &k = val[p];
for (auto u : adj[p]) k += h[u];
cnt[k]++;
}
void solve() {
for (long long i = 0; i < e; i++) {
long long f = rel[i].first, t = rel[i].second;
if (val[f] - h[t] == val[t] - h[f]) ans++;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[305];
int to[305];
bool used[305];
bool root[305];
int dp[305][100010];
int main(int argc, const char *argv[]) {
int n, q, t;
cin >> n >> q >> t;
vector<int> V;
for (int i = 0; i < n; i++) {
cin >> arr[i];
root[i] = true;
to[i] = -1;
}
for (int i = 0; i < q; i++) {
int bi, ci;
cin >> bi >> ci;
bi--;
ci--;
root[ci] = false;
to[bi] = ci;
}
long long sum = 0;
for (int i = 0; i < n; i++) {
if (root[i]) {
long long tmp1 = 0;
for (int j = i; j != -1; j = to[j]) {
used[j] = true;
tmp1 += arr[j];
V.push_back(tmp1);
if (to[j] != -1) sum += tmp1;
}
}
}
for (int i = 0; i < n; i++)
if (!used[i]) {
cout << 0 << '\n';
return 0;
}
if (sum > t) {
cout << 0 << '\n';
return 0;
}
t -= sum;
dp[0][0] = 1;
for (int i = 0; i < V.size(); i++)
for (int j = 0; j <= t; j++) {
dp[i + 1][j] = dp[i][j];
if (V[i] <= j) {
dp[i + 1][j] += dp[i + 1][j - V[i]];
if (dp[i + 1][j] > 1000000007) dp[i + 1][j] -= 1000000007;
}
}
cout << dp[V.size()][t];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> P[100005];
int num[100005];
vector<pair<int, int> > ko;
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
P[i] = make_pair(num[i], i);
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
for (int i = 0; i < n; i++) {
while (!que.empty() && que.top().first < num[i]) {
ko.push_back(make_pair(que.top().second, i));
que.pop();
}
que.push(P[i]);
}
while (que.size()) que.pop();
for (int i = n - 1; i >= 0; i--) {
while (!que.empty() && que.top().first < num[i]) {
ko.push_back(make_pair(que.top().second, i));
que.pop();
}
que.push(P[i]);
}
int ans = 0;
for (int i = 0; i < ko.size(); i++) {
ans = max(ans, num[ko[i].first] ^ num[ko[i].second]);
}
return !printf("%d%c", ans, 10);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<long long int> a(N, -1);
vector<int> adj[N];
vector<long long int> h(N, -1);
vector<bool> visited(N, false);
vector<long long int> ans(N, 0);
vector<long long int> sum(N, 0);
long long int ful = 0;
long long int dfs(int v, int d = 0) {
visited[v] = true;
sum[v] += a[v];
h[v] = d;
for (int i = 0; i < adj[v].size(); i++) {
if (visited[adj[v][i]] == false) sum[v] += dfs(adj[v][i], d + 1);
}
return sum[v];
}
void dfs2(int v, int par = -1) {
visited[v] = true;
if (par != -1) {
ans[v] = ans[par] + ful - 2 * sum[v];
}
for (int i = 0; i < adj[v].size(); i++) {
if (visited[adj[v][i]] == false) dfs2(adj[v][i], v);
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i + 1];
for (int i = 1; i <= n; i++) {
ful += a[i];
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1);
long long int xd = 0;
for (int i = 2; i <= n; i++) {
xd += a[i] * h[i];
}
ans[1] = xd;
for (int i = 1; i <= n; i++) visited[i] = false;
dfs2(1);
long long int wyn = 0;
for (int i = 1; i <= n; i++) wyn = max(wyn, ans[i]);
cout << wyn;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18;
const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
long long cl(long long a, long long b) { return (a / b) + (a % b != 0); }
long long cnt[N];
void solve() {
int n, k;
cin >> n >> k;
vector<long long> V(n);
for (int i = 0; i < n; i++) {
cin >> V[i];
}
if (n == 1) {
cout << V[0];
return;
}
long long ans = V[n - 1];
for (int i = 0; i < n - k; i++) {
ans = max(ans, V[i] + V[(n - k) * 2 - i - 1]);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
T = 1;
while (T--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
bool comp(long long a, long long b) { return a > b; }
int main() {
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof(a));
int ta;
long long tb;
scanf("%d %lld", &ta, &tb);
for (int i = 1; i <= ta; i++) {
scanf("%lld", &a[i]);
a[i] -= tb;
}
sort(a + 1, a + ta + 1, comp);
long long k = 0;
for (int i = 1; i <= ta; i++) {
a[i] += a[i - 1];
if (a[i] >= 0) k = i;
}
cout << k << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const double mathpi = 3.14159265358979323846264338327950;
const int mod = 1e9 + 7;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(unordered_map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
bool tc = 0;
void masley() {
string a, b;
cin >> a >> b;
string ans;
int dist = 0;
for (int i = 0; i < a.size(); ++i) {
if (a[i] != b[i]) dist++;
}
if (dist & 1) {
cout << "impossible"
<< "\n";
return;
}
int ops = 0;
for (int i = 0; i < a.size(); ++i) {
if (ops == dist / 2) break;
if (a[i] != b[i]) {
ops++;
if (a[i] == '0') {
a[i] = '1';
} else
a[i] = '0';
}
}
cout << a << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
if (tc) cin >> T;
while (T--) {
masley();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
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...);
}
int lcp[5005][5005];
int dp[5005];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
for (int i = n - 1; i >= 0; i--) {
for (int j = n - 1; j > i; j--) {
if (s[i] == s[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
}
for (int i = 0; i < (n); ++i) dp[i] = 1e9;
dp[0] = a;
for (int i = 1; i < (n); ++i) {
dp[i] = min(dp[i], dp[i - 1] + a);
int mx = 0;
for (int j = i - 1; j >= 0; j--) {
mx = max(mx, min(lcp[j][i], i - j));
}
for (int j = 0; j < (mx); ++j) {
dp[i + j] = min(dp[i + j], dp[i - 1] + b);
}
}
cout << dp[n - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T>
using pqrev = priority_queue<T, vector<T>, greater<T>>;
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
constexpr ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
constexpr ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
template <typename S, typename T>
constexpr bool chmax(S &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename S, typename T>
constexpr bool chmin(S &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T>
T max(const vector<T> &x) {
return *max_element((x).begin(), (x).end());
}
template <typename T>
T min(const vector<T> &x) {
return *min_element((x).begin(), (x).end());
}
template <typename T>
pair<T, int> argmax(const vector<T> &x) {
int idx = 0;
T m = x[0];
for (ll i = (1), i_end = (((ll)(x).size())); i < i_end; i++) {
if (chmax(m, x[i])) idx = i;
}
return {m, idx};
}
template <typename T>
pair<T, int> argmin(const vector<T> &x) {
int idx = 0;
T m = x[0];
for (ll i = (1), i_end = (((ll)(x).size())); i < i_end; i++) {
if (chmin(m, x[i])) idx = i;
}
return {m, idx};
}
template <typename T>
T sum(const vector<T> &x) {
return accumulate((x).begin(), (x).end(), T(0));
}
template <typename T>
bool print_(const T &a) {
cout << a;
return true;
}
template <typename T>
bool print_(const vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) cout << " ";
}
return false;
}
template <typename T>
bool print_(const vector<vector<T>> &vv) {
for (auto &v : vv) {
for (auto &a : v) {
cout << a;
if (&a != &v.back()) cout << " ";
}
if (&v != &vv.back()) cout << "\n";
}
return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&...tail) {
bool f = print_(head);
if (sizeof...(tail) != 0) cout << (f ? " " : "\n");
print(forward<Tail>(tail)...);
}
constexpr ll MOD = 1e9 + 7;
void solve() {
ll n;
cin >> n;
string s;
cin >> s;
bool f = 1;
if (n & 1) {
f = 0;
for (int i = 0; i < n; i += 2) {
if ((s[i] - '0') % 2) f = 1;
}
} else {
f = 1;
for (int i = 1; i < n; i += 2) {
if ((s[i] - '0') % 2 == 0) f = 0;
}
}
{
cout << ((f) ? "1" : "2") << "\n";
return;
};
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll _cases;
cin >> _cases;
while (_cases--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
using namespace std;
priority_queue<long long> q;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
long long i, a, ay, x1, y1, c, cy, x2, y2, b, x, y, add = 0, j, k, p, r, R, d,
e, f;
long long l, m, n;
map<string, int> mp;
long long mul = 0, h, g, sum = 0, cnt = 0, ss = 0;
bool ok = true;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
q.push(x);
if (q.top() > x) {
cnt += (q.top() - x);
q.pop();
q.push(x);
}
}
cout << cnt << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<char, int> pr[500100];
int arr[11];
map<vector<int>, int> mp;
vector<int> ans;
int main() {
int n;
cin >> n;
bool flag = 0;
int an = 1023, o = 0, xo = 0;
for (int i = 1; i <= n; ++i) {
char c;
int x;
cin >> c;
scanf("%d", &x);
for (int j = 0; j < 10; ++j) {
if (c == '&' && ((1 << j) & x) == 0)
an &= ~(1 << j), o &= ~(1 << j), xo &= ~(1 << j);
else if (c == '|' && ((1 << j) & x))
an |= (1 << j), o |= (1 << j), xo &= ~(1 << j);
else if (c == '^' && ((1 << j) & x))
xo ^= (1 << j);
}
}
printf("3\n& %d\n| %d\n^ %d\n", an, o, xo);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mini = -1e15;
vector<int> l[100009];
long long int tree[4 * 100009], best[4 * 100009];
int n, p[20][100009], lvl[100009], sub[100009], tin[100009], tout[100009],
lazy[4 * 100009];
int baseArray[100009], ptr;
int chainInd[100009], posInBase[100009], chainHead[100009], chainNo;
void build(int node, int start, int end) {
if (start == end) {
tree[node] = best[node] = -1;
return;
}
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = tree[2 * node] + tree[2 * node + 1];
best[node] = max(best[2 * node + 1], best[2 * node] + tree[2 * node + 1]);
return;
}
void range_update(int node, int start, int end, int l, int r) {
if (lazy[node]) {
tree[node] = -1 * (end - start + 1);
best[node] = -1;
if (start != end) {
lazy[2 * node] = lazy[2 * node + 1] = 1;
}
lazy[node] = 0;
}
if (start > end || start > r || end < l) {
return;
}
if (start >= l && end <= r) {
tree[node] = -1 * (end - start + 1);
best[node] = -1;
if (start != end) {
lazy[2 * node] = lazy[2 * node + 1] = 1;
}
lazy[node] = 0;
return;
}
int mid = (start + end) / 2;
range_update(2 * node, start, mid, l, r);
range_update(2 * node + 1, mid + 1, end, l, r);
tree[node] = tree[2 * node] + tree[2 * node + 1];
best[node] = max(best[2 * node + 1], best[2 * node] + tree[2 * node + 1]);
return;
}
void point_update(int node, int start, int end, int idx, long long int val) {
if (lazy[node]) {
tree[node] = -1 * (end - start + 1);
best[node] = -1;
if (start != end) {
lazy[2 * node] = lazy[2 * node + 1] = 1;
}
lazy[node] = 0;
}
if (start > end || start > idx || end < idx) {
return;
}
if (start == end) {
tree[node] += val;
best[node] += val;
return;
}
int mid = (start + end) / 2;
point_update(2 * node, start, mid, idx, val);
point_update(2 * node + 1, mid + 1, end, idx, val);
tree[node] = tree[2 * node] + tree[2 * node + 1];
best[node] = max(best[2 * node + 1], best[2 * node] + tree[2 * node + 1]);
return;
}
pair<long long int, long long int> query_tree(int node, int start, int end,
int l, int r) {
if (r < start || end < l) {
return make_pair(mini, mini);
}
if (lazy[node]) {
tree[node] = -1 * (end - start + 1);
best[node] = -1;
if (start != end) {
lazy[2 * node] = lazy[2 * node + 1] = 1;
}
lazy[node] = 0;
}
if (l <= start && end <= r) {
return make_pair(best[node], tree[node]);
}
int mid = (start + end) / 2;
auto p1 = query_tree(2 * node, start, mid, l, r);
auto p2 = query_tree(2 * node + 1, mid + 1, end, l, r);
if (p1 == make_pair(mini, mini)) {
return p2;
} else if (p2 == make_pair(mini, mini)) {
return p1;
}
pair<long long int, long long int> final;
final.second = p1.second + p2.second;
final.first = max(p2.first, p1.first + p2.second);
return final;
}
void dfs(int ver, int par) {
int i, j, t1, t2, t3, t4;
sub[ver] = 1;
for (i = 0; i < (int)l[ver].size(); i++) {
t1 = l[ver][i];
if (t1 == par) {
continue;
}
lvl[t1] = lvl[ver] + 1;
p[0][t1] = ver;
dfs(t1, ver);
sub[ver] += sub[t1];
}
return;
}
void preprocess() {
int i, j, t1, t2, t3, t4;
p[0][1] = -1;
lvl[1] = 0;
dfs(1, -1);
}
int query_up(int u, int v) {
int i, j, t1, t2, t3, t4, temp, uchain, vchain = chainInd[v];
long long int buf1, buf2, buf3, buf4, tempans, sum;
t1 = ptr;
sum = 0;
tempans = mini;
while (1) {
uchain = chainInd[u];
if (uchain == vchain) {
auto it = query_tree(1, 1, t1, posInBase[v], posInBase[u]);
tempans = max(tempans, it.first + sum);
sum += it.second;
break;
}
auto it = query_tree(1, 1, t1, posInBase[chainHead[uchain]], posInBase[u]);
tempans = max(tempans, it.first + sum);
sum += it.second;
u = chainHead[uchain];
u = p[0][u];
}
return tempans;
}
void HLD(int ver, int par) {
int newCost, specialChild = -1, i, j, t1, t2, t3, t4;
if (chainHead[chainNo] == -1) {
chainHead[chainNo] = ver;
}
chainInd[ver] = chainNo;
tin[ver] = ++ptr;
posInBase[ver] = ptr;
baseArray[ptr] = ver;
for (i = 0; i < (int)l[ver].size(); i++) {
t1 = l[ver][i];
if (t1 == par) {
continue;
}
if (specialChild == -1 || sub[specialChild] < sub[t1]) {
specialChild = t1;
}
}
if (specialChild != -1) {
HLD(specialChild, ver);
}
for (i = 0; i < (int)l[ver].size(); i++) {
t1 = l[ver][i];
if (t1 == par || t1 == specialChild) {
continue;
}
chainNo++;
HLD(t1, ver);
}
tout[ver] = ptr;
return;
}
int main() {
int i, j, t1, t2, t3, t4, q;
long long int buf1, buf2, buf3, buf4, ans;
scanf("%d %d", &n, &q);
for (i = 2; i <= n; i++) {
scanf("%d", &t1);
l[t1].push_back(i);
l[i].push_back(t1);
}
for (i = 0; i <= n; i++) {
chainHead[i] = -1;
}
ptr = 0;
chainNo = 1;
preprocess();
HLD(1, -1);
build(1, 1, n);
for (i = 0; i < q; i++) {
scanf("%d %d", &t1, &t2);
if (t1 == 1) {
point_update(1, 1, n, tin[t2], 1);
} else if (t1 == 2) {
range_update(1, 1, n, tin[t2], tout[t2]);
buf1 = query_up(t2, 1);
if (buf1 >= 0) {
point_update(1, 1, n, tin[t2], -(buf1 + 1));
}
} else {
ans = query_up(t2, 1);
if (ans >= 0) {
printf("black\n");
} else {
printf("white\n");
}
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m;
int a[maxn], b[maxn];
bool ck() {
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > 1 && a[i - 1] > 1) return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; ++i) {
scanf("%d", &a[i]);
}
if (ck()) {
puts("perfect");
} else {
puts("ambiguous");
int tmp = 0;
bool flag = 0;
for (int i = 0; i <= n; i++) {
if (flag == 0 && a[i] > 1 && a[i - 1] > 1) {
flag = 1;
cout << tmp - 1 << " ";
for (int j = 2; j <= a[i]; j++) {
cout << tmp << " ";
}
} else {
for (int j = 1; j <= a[i]; j++) {
cout << tmp << " ";
}
}
tmp += a[i];
}
cout << endl;
tmp = 0;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= a[i]; j++) {
cout << tmp << " ";
}
tmp += a[i];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, sum = 0;
cin >> m;
int arr[m];
for (int i = 0; i < m; ++i) {
cin >> arr[i];
sum += arr[i];
}
int x, y, a = 0;
cin >> x >> y;
for (int i = 0; i < m; ++i) {
a += arr[i];
if (a >= x && a <= y && sum - a >= x && sum - a <= y) {
cout << i + 2 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cond = 1;
bool e[705][705];
long long path3[705][705];
int n, m;
long long res;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
e[a][b] = e[b][a] = true;
}
for (__typeof(1) i = (1); i <= (n); ++i)
for (__typeof(i + 1) k = (i + 1); k <= (n); ++k) {
if (k == i) continue;
for (__typeof(1) j = (1); j <= (n); ++j)
if (e[i][j] && e[j][k]) ++path3[i][k];
path3[k][i] = path3[i][k];
}
for (__typeof(1) i = (1); i <= (n); ++i)
for (__typeof(i + 1) j = (i + 1); j <= (n); ++j) {
long long p4 = 0;
for (__typeof(1) k = (1); k <= (n); ++k) {
if (k != i && e[k][j]) {
p4 += path3[i][k] - e[i][j];
}
}
for (__typeof(1) k = (1); k <= (n); ++k) {
if (e[i][k] && e[j][k]) {
res += p4 - path3[i][k] - path3[j][k];
if (e[i][j]) res += 2;
}
}
}
cout << res / 5 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - 48;
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
const int maxn = 1e5 + 10;
const long long mod = 1e9 + 7;
int T, n, m, k;
int a[10][10];
int main() {
scanf("%d", &k);
if (k == 0) {
printf("1 1\n1\n");
return 0;
}
int tmp = k;
int p = 0;
while (tmp) {
tmp >>= 1;
p++;
}
printf("3 3\n");
a[1][1] = k | 1 << p;
a[1][2] = k;
a[2][1] = 0 | 1 << p;
a[2][2] = k;
a[3][1] = 0 | 1 << p;
a[3][2] = k | 1 << p;
a[3][3] = k;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 9;
const long long mod = 1e9 + 7;
const long long base = 37, base2 = 41;
vector<long long> vec;
long long hsh[maxn], hsh2[maxn], pw[maxn], pw2[maxn];
void calhash(string s) {
pw[0] = 1;
for (int i = 1; i < maxn; i++) pw[i] = pw[i - 1] * base % mod;
hsh[0] = s[0] - 'a' + 1;
for (int i = 1; i < s.length(); i++)
hsh[i] = (hsh[i - 1] * base % mod + s[i] - 'a' + 1) % mod;
}
void calhash2(string s) {
pw2[0] = 1;
for (int i = 1; i < maxn; i++) pw2[i] = pw2[i - 1] * base2 % mod;
hsh2[0] = s[0] - 'a' + 1;
for (int i = 1; i < s.length(); i++)
hsh2[i] = (hsh2[i - 1] * base2 % mod + s[i] - 'a' + 1) % mod;
}
long long cal(string s) {
long long ans = s[0] - 'a' + 1;
for (int i = 1; i < s.length(); i++)
ans = (ans * base % mod + s[i] - 'a' + 1) % mod;
return ans;
}
long long cal2(string s) {
long long ans = s[0] - 'a' + 1;
for (int i = 1; i < s.length(); i++)
ans = (ans * base2 % mod + s[i] - 'a' + 1) % mod;
return ans;
}
long long gethash(int l, int r) {
long long ans = hsh[r - 1] - ((l == 0) ? 0 : hsh[l - 1]) * pw[r - l] % mod;
ans %= mod;
ans = (ans + mod) % mod;
return ans;
}
long long gethash2(int l, int r) {
long long ans = hsh2[r - 1] - ((l == 0) ? 0 : hsh2[l - 1]) * pw2[r - l] % mod;
ans %= mod;
ans = (ans + mod) % mod;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, s1, s2;
cin >> s >> s1 >> s2;
calhash(s);
calhash2(s);
long long f1 = cal(s1);
long long ff1 = cal2(s1);
long long f2 = cal(s2);
long long ff2 = cal2(s2);
for (int i = 0; i < s.length(); i++)
for (int t = i + max(s1.length(), s2.length()) - 1; t < s.length(); t++)
if (gethash(i, i + s1.length()) == f1 &&
gethash2(i, i + s1.length()) == ff1 &&
gethash(t - s2.length() + 1, t + 1) == f2 &&
gethash2(t - s2.length() + 1, t + 1) == ff2) {
vec.push_back(gethash(i, t) * gethash2(i, t));
}
sort(vec.begin(), vec.end());
int res = 0;
for (int i = 0; i < vec.size(); i++) {
res++;
while (i < vec.size() - 1 && vec[i] == vec[i + 1]) i++;
}
cout << res << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.length() < 2) {
cout << 0;
return 0;
}
vector<pair<char, int> > a(1, {s[0], 1});
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1])
a.back().second++;
else
a.push_back({s[i], 1});
}
string h;
h += s[0];
for (int i = 1; i < s.length(); i++) {
if (s[i] != s[i - 1]) h += s[i];
}
string k = h;
reverse(k.begin(), k.end());
if (k != h) {
cout << 0;
return 0;
}
for (int i = 0, j = int(a.size()) - 1; i < int(a.size()) / 2; i++, j--) {
if (a[i].second + a[j].second < 3) {
cout << 0;
return 0;
}
}
cout << (a[int(a.size()) / 2].second < 2 ? 0
: a[int(a.size()) / 2].second + 1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
struct Trie {
int ch[maxn][26];
int sz;
Trie() {
sz = 1;
memset(ch[0], 0, sizeof(ch[0]));
}
int idx(char c) { return c - 'a'; }
void insert(char *s) {
int u = 0, len = strlen(s);
for (int i = 0; i < len; i++) {
int c = idx(s[i]);
if (!ch[u][c]) {
memset(ch[sz], 0, sizeof(ch[sz]));
ch[u][c] = sz++;
}
u = ch[u][c];
}
}
int dfs(int u) {
bool flag = 0;
int ret = 0;
for (int i = 0; i < 26; i++) {
if (ch[u][i]) {
flag = 1;
ret |= dfs(ch[u][i]);
}
}
if (!flag)
ret = 2;
else
ret = 3 - ret;
return ret;
}
} tire;
char s[100010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%s", s);
tire.insert(s);
}
int ans = 3 - tire.dfs(0);
if (ans == 3) {
printf("First\n");
} else if (ans == 2) {
if (k & 1)
printf("First\n");
else
printf("Second\n");
} else
printf("Second\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int N = 1e6 + 2;
int n, m, p, b[N + 5];
long long tree[N << 2], lazy[N << 2];
struct node {
int at, de;
int w;
} a[maxn], c[maxn];
bool cmp1(node a, node b) { return a.at < b.at; }
bool cmp2(node a, node b) { return a.de < b.de; }
void build(int l, int r, int rt) {
if (l == r) {
if (b[l] == 0)
tree[rt] = -1e18;
else
tree[rt] = -1ll * b[l];
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
tree[rt] = max(tree[rt << 1], tree[rt << 1 | 1]);
}
void pushdown(int l, int r, int rt) {
if (lazy[rt] != 0) {
tree[rt] += lazy[rt];
if (l != r) {
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
}
lazy[rt] = 0;
}
}
void update(int l, int r, int rt, int L, int R, int c) {
if (l > r) return;
pushdown(l, r, rt);
if (L <= l && r <= R) {
lazy[rt] += c;
pushdown(l, r, rt);
return;
}
int mid = l + r >> 1;
if (L <= mid) update(l, mid, rt << 1, L, R, c);
if (mid < R) update(mid + 1, r, rt << 1 | 1, L, R, c);
if (l != r) {
pushdown(l, mid, rt << 1);
pushdown(mid + 1, r, rt << 1 | 1);
tree[rt] = max(tree[rt << 1], tree[rt << 1 | 1]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].at, &a[i].w);
}
int de, w;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &de, &w);
if (b[de] == 0)
b[de] = w;
else
b[de] = min(b[de], w);
}
for (int i = 1; i <= p; ++i) {
scanf("%d%d%d", &c[i].de, &c[i].at, &c[i].w);
}
build(1, N, 1);
sort(a + 1, a + 1 + n, cmp1);
sort(c + 1, c + 1 + p, cmp2);
long long ans = -2e18;
int now = 1;
for (int i = 1; i <= n; ++i) {
while (now <= p && a[i].at > c[now].de) {
update(1, N, 1, c[now].at + 1, N, c[now].w);
now++;
}
pushdown(1, N, 1);
ans = max(ans, -a[i].w + tree[1]);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 300005;
int A[M], F[M], FF[M], pre[M], st[M], ed[M];
void add(int &x) {
if (x >= 1000000009) x -= 1000000009;
if (x < 0) x += 1000000009;
}
void calc() {
F[1] = F[2] = 1;
FF[1] = 1, FF[2] = 2;
for (int i = 3; i < M; i++) {
F[i] = F[i - 1] + F[i - 2];
add(F[i]);
FF[i] = FF[i - 1] + F[i];
add(FF[i]);
}
}
int main() {
calc();
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
pre[i] = pre[i - 1] + x;
add(pre[i]);
}
vector<pair<int, int> > q;
int srt = ceil(sqrt(m));
while (m--) {
int t, L, R;
scanf("%d %d %d", &t, &L, &R);
if (t == 1) {
q.push_back(make_pair(L, R));
st[L]++;
ed[R] += F[R - L + 2];
ed[R + 1] += F[R - L + 1];
add(ed[R]);
add(ed[R + 1]);
} else {
int ans = pre[R] - pre[L - 1];
add(ans);
for (int i = 0; i < q.size(); i++) {
int l = q[i].first, r = q[i].second;
if (L > r || R < l) continue;
r = min(r, R) + 1;
ans += FF[r - l] - FF[max(l, L) - l];
add(ans);
}
printf("%d\n", ans);
}
if (q.size() == srt) {
int sum = 0;
for (int i = 1; i <= n; i++) {
A[i] = A[i - 1] + A[i - 2];
add(A[i]);
A[i] += st[i] - ed[i - 1];
add(A[i]);
sum += A[i];
add(sum);
pre[i] += sum;
add(pre[i]);
}
memset(A, 0, sizeof A);
memset(st, 0, sizeof st);
memset(ed, 0, sizeof ed);
q.clear();
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 9;
const long long inf = 1e18 + 18;
const int max6 = 1e6 + 6;
const int modx = 1e9 + 123;
const int mody = 997;
const int base = 137;
int f[1001];
const int mod = 1e9 + 7;
int main() {
string a, b;
cin >> a >> b;
int k;
cin >> k;
if (a.size() != b.size()) {
cout << 0;
return 0;
}
int n = a.size();
f[0] = 1;
for (int i = 1; i <= k; ++i) {
int psum = 0;
for (int j = 0; j < n; ++j) psum = (psum + f[j]) % mod;
for (int j = 0; j < n; ++j) f[j] = (psum - f[j] + mod) % mod;
}
int res = 0;
for (int i = 0; i < n; ++i) {
string tmp = b.substr(i, n - i) + b.substr(0, i);
if (tmp == a) res = (res + f[i]) % mod;
}
cout << res;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int ,int>
const ll mod=1e9+7;
const ll N=1e6+5;
ll t,n,m,k;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>t;
while(t--)
{
cin>>n;
int cnt=0;
for(ll i=3; ; i+=2){
if((i*i+1)/2 >n || (i*i-1)/2 >n )
break;
cnt++;
}
cout <<cnt<<"\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void myfunc() { return; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
set<int> s;
vector<int> ans(n + 1, 0);
int i, l, r, x, y, j;
for (i = 1; i <= n; i++) {
s.insert(i);
}
for (j = 0; j < m; j++) {
cin >> l >> r >> x;
set<int>::iterator st = s.lower_bound(l);
set<int>::iterator end = s.upper_bound(r);
vector<int> tbd;
for (set<int>::iterator it = st; it != end; it++) {
y = *it;
if (x != y) {
ans[y] = x;
}
}
s.erase(st, end);
s.insert(x);
}
for (i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, t, l, r, d, j = 0;
cin >> t;
do {
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
} else {
k = r % d;
k = r + d - k;
cout << k << endl;
}
j++;
} while (j < t);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300005;
int a[MAX_N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
long long sum = 0;
for (int i = 1; i < n; i++) sum += (long long)a[i] - (long long)a[0];
long long ans = sum;
int p = a[0];
long long cnt_left = 0;
long long cnt_right = n;
for (int i = 1; i < n; i++) {
cnt_left++;
cnt_right--;
long long x = (long long)a[i] - (long long)a[i - 1];
sum += cnt_left * x - cnt_right * x;
if (sum < ans) {
ans = sum;
p = a[i];
}
}
cout << p;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int MAXN = 1e5 + 5;
const int MAXM = 2e6 + 5;
const int MOD = 1e9 + 7;
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
long long pw(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void inc(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
void dec(long long &a, long long b) {
a -= b;
if (a < 0) a += MOD;
}
int mul(int a, int b) {
long long c = 1ll * a * b;
return c - c / MOD * MOD;
}
int n, m;
bitset<2005> b[2005];
char s[2005][2005];
struct E {
int u, v, w;
} e[MAXM];
bool cmp(E a, E b) { return a.w > b.w; }
int fa[2005];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool in[2005];
vector<int> G[2005];
int has;
void dfs(int u) {
in[u] = 0;
has++;
for (auto v : G[u])
if (in[v]) {
dfs(v);
}
}
bool ok() {
for (int i = 1; i < m + 1; i++) {
int st, cnt = 0;
for (int j = 1; j < n + 1; j++) {
in[j] = (s[i][j] == '1' ? 1 : 0);
cnt += in[j];
if (in[j]) st = j;
}
if (cnt > 0) {
has = 0;
dfs(st);
if (has != cnt) return false;
}
}
return true;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++) b[i].reset(), fa[i] = i, G[i].clear();
for (int i = 1; i < m + 1; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j < n + 1; j++)
if (s[i][j] == '1') {
b[j].set(i);
}
}
int tot = 0;
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++)
if (i < j) {
bitset<2005> t = b[i] & b[j];
e[tot++] = E{i, j, (int)t.count()};
}
sort(e, e + tot, cmp);
int cnt = 0;
for (int i = 0; i < tot; i++) {
int u = find(e[i].u), v = find(e[i].v);
if (u != v) {
fa[u] = v;
G[e[i].u].push_back(e[i].v);
G[e[i].v].push_back(e[i].u);
e[cnt++] = E{e[i].u, e[i].v, 0};
}
}
if (ok()) {
puts("YES");
for (int i = 0; i < n - 1; i++) printf("%d %d\n", e[i].u, e[i].v);
} else
puts("NO");
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[4000];
vector<int> ans;
int in[4007] = {0}, out[4007] = {0}, exist[4007], hue[4007] = {0},
zz[4007] = {0};
void dfs(int xx) {
zz[xx] = 1;
while (hue[xx] < graph[xx].size()) {
hue[xx]++;
dfs(graph[xx][hue[xx] - 1]);
}
ans.push_back(xx);
}
int val(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'z') return c - 'a' + 10;
if (c >= 'A' && c <= 'Z') return c - 'A' + 36;
}
char symb(int x) {
if (x < 10) return x + '0';
if (x < 36) return x + 'a' - 10;
return x + 'A' - 36;
}
int toi(char c1, char c2) { return val(c1) * 62 + val(c2); }
string tos(int x) {
string res = "";
res += symb(x / 62);
res += symb(x % 62);
return res;
}
string s;
int main() {
int n, count1 = 0, count2 = 0, xx = -1;
scanf("%d", &n);
while (n--) {
cin >> s;
int a = toi(s[0], s[1]);
int b = toi(s[1], s[2]);
graph[a].push_back(b);
exist[a] = exist[b] = 1;
out[a]++;
in[b]++;
}
for (int i = 0; i <= 4002; i++) {
if (exist[i]) {
if (in[i] == out[i] + 1)
count1++;
else if (out[i] == in[i] + 1) {
count2++;
xx = i;
} else {
if (in[i] != out[i]) {
printf("NO\n");
return 0;
}
}
}
}
if (!((count1 == 1 && count2 == 1) || (count1 == 0 && count2 == 0))) {
printf("NO\n");
return 0;
}
if (xx == -1) {
for (int i = 0; i <= 4002; i++) {
if (exist[i]) {
xx = i;
break;
}
}
}
dfs(xx);
for (int i = 0; i <= 4002; i++) {
if (exist[i] != zz[i]) {
printf("NO\n");
return 0;
}
}
reverse(ans.begin(), ans.end());
cout << "YES\n";
cout << tos(ans[0])[0];
for (int i = 1; i < (int)ans.size() - 1; ++i) cout << tos(ans[i])[0];
cout << tos(ans.back());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string words[305];
int match[305][305];
int dp[305][305];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
int sz = n - 1;
for (int i = 0; i < n; ++i) {
cin >> words[i];
sz += words[i].size();
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
match[i][j] = words[i] == words[j];
}
}
int sol = sz;
for (int i = n - 1; i >= 0; --i) {
for (int j = i + 1; j < n; ++j) {
int sum = 0;
for (int k = 0; i + k < j && j + k < n; ++k) {
if (!match[i + k][j + k]) break;
sum += words[i + k].size();
dp[i][k] = max({dp[i][k], sum - 1 + dp[j][k], 2 * (sum - 1)});
sol = min(sol, sz - dp[i][k]);
}
}
}
cout << sol << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4;
int i, n, m, s1 = 0, s2 = 0, x;
cin >> c1 >> c2 >> c3 >> c4;
cin >> n >> m;
for (i = 0; i < n; ++i) {
cin >> x;
s1 += min(c2, x * c1);
}
s1 = min(s1, c3);
for (i = 0; i < m; ++i) {
cin >> x;
s2 += min(x * c1, c2);
}
s2 = min(s2, c3);
cout << min(s1 + s2, c4);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n;
cin >> n;
unsigned long long k = 1;
while (n % k == 0) k *= 3;
cout << n / k + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 1000000007;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<int> gr[1000001];
pair<long long, long long> data[1000001];
bool used1[1000001];
bool used2[1000001];
int dfs(int v) {
vector<int> ch, ch2;
used2[v] = true;
for (int i = 0; i < gr[v].size(); ++i) {
int m = gr[v][i];
if (used1[m]) continue;
used1[m] = true;
int fr = data[m].first;
int to = data[m].second;
if (to == v) swap(fr, to);
ch2.push_back(to);
}
for (int i = 0; i < ch2.size(); ++i) {
if (!used2[ch2[i]]) {
int ret = dfs(ch2[i]);
if (ret) {
printf("%d %d %d\n", ret, ch2[i], v);
} else {
ch.push_back(ch2[i]);
}
} else
ch.push_back(ch2[i]);
}
for (int i = 0; i + 1 < ch.size(); i += 2) {
printf("%d %d %d\n", ch[i], v, ch[i + 1]);
}
if (ch.size() & 1) return ch.back();
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (m & 1) {
printf("No solution");
return 0;
}
for (int i = 0; i < m; ++i) {
scanf("%d%d", &data[i].first, &data[i].second);
gr[data[i].first].push_back(i);
gr[data[i].second].push_back(i);
}
dfs(1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool checkMax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T, typename... Args>
inline void checkMax(T &a, const Args... arg) {
checkMax(a, max(arg...));
}
template <class T>
inline bool checkMin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename... Args>
inline void checkMin(T &a, const Args... arg) {
checkMin(a, min(arg...));
}
const int INF = 0x3f3f3f3f;
const long long llINF = 4e18;
const int MAXN = 1e5 + 5;
int T, n;
long long ansX, ansY, ansZ;
long long x[MAXN], y[MAXN], z[MAXN];
long long getl(long long x, int i) { return x + ((x & 1) ^ i); }
long long getr(long long x, int i) { return x - ((x & 1) ^ i); }
bool check(long long d) {
static long long l[5], r[5];
for (int i = 1; i <= 4; i++) l[i] = -llINF, r[i] = llINF;
for (int i = 1; i <= n; i++) {
checkMin(r[1], d + x[i] + y[i] + z[i]);
checkMin(r[2], d - x[i] + y[i] + z[i]);
checkMin(r[3], d + x[i] - y[i] + z[i]);
checkMin(r[4], d + x[i] + y[i] - z[i]);
checkMax(l[1], -d + x[i] + y[i] + z[i]);
checkMax(l[2], -d - x[i] + y[i] + z[i]);
checkMax(l[3], -d + x[i] - y[i] + z[i]);
checkMax(l[4], -d + x[i] + y[i] - z[i]);
}
for (int i = 0; i < 2; i++) {
long long l1 = getl(l[1], i), r1 = getr(r[1], i);
long long l2 = getl(l[2], i), r2 = getr(r[2], i);
long long l3 = getl(l[3], i), r3 = getr(r[3], i);
long long l4 = getl(l[4], i), r4 = getr(r[4], i);
if (l1 > r1 || l2 > r2 || l3 > r3 || l4 > r4) continue;
long long a = l2, b = l3, c = l4;
if (a + b + c > r1) continue;
if (a + b + c < l1) a = min(r2, l1 - b - c);
if (a + b + c < l1) b = min(r3, l1 - a - c);
if (a + b + c < l1) c = min(r4, l1 - a - b);
if (a + b + c < l1) continue;
ansX = (b + c) >> 1;
ansY = (a + c) >> 1;
ansZ = (a + b) >> 1;
return true;
}
return false;
}
void Solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &x[i], &y[i], &z[i]);
long long l = 0, r = llINF, res = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
res = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%lld %lld %lld\n", ansX, ansY, ansZ);
}
int main() {
scanf("%d", &T);
while (T--) Solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, sa = 0, sg = 0, i, cnt = 0;
cin >> n;
long long int a, g;
for (i = 0; i < n; ++i) {
scanf("%lld %lld", &a, &g);
if (abs(sa + a - sg) <= 500) {
sa += a;
printf("A");
} else {
sg += g;
printf("G");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const long long mod = 1000000007;
int n, k;
vector<int> G[105];
long long dp[105][45], tmp[45];
void dfs(int cur, int pre) {
dp[cur][0] = dp[cur][k + 1] = 1;
for (int i = 0; i < (int)G[cur].size(); i++) {
int nxt = G[cur][i];
if (nxt == pre) continue;
dfs(nxt, cur);
memset(tmp, 0, sizeof(tmp));
for (int l = 0; l <= 2 * k; l++) {
for (int r = 0; r <= 2 * k; r++) {
if (l + r <= 2 * k)
tmp[min(l, r + 1)] =
(tmp[min(l, r + 1)] + (dp[cur][l] * dp[nxt][r]) % mod) % mod;
else
tmp[max(l, r + 1)] =
(tmp[max(l, r + 1)] + (dp[cur][l] * dp[nxt][r]) % mod) % mod;
}
}
for (int j = 0; j <= 2 * k; j++) dp[cur][j] = tmp[j];
}
}
int main(int argc, char** argv) {
scanf("%d %d", &n, &k);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
long long ans = 0;
for (int i = 0; i <= k; i++) ans = (ans + dp[1][i]) % mod;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long ans[200010], L[200010], R[200010];
vector<pair<pair<long long, long long>, long long> > v;
set<pair<long long, long long> > S;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> L[i] >> R[i];
for (int i = 0; i < m; i++) {
long long l;
cin >> l;
S.insert(make_pair(l, i));
}
for (int i = 1; i < n; i++)
v.push_back(make_pair(make_pair(L[i] - R[i - 1], R[i] - L[i - 1]), i - 1));
sort(v.begin(), v.end());
for (int i = n - 2; i >= 0; i--) {
set<pair<long long, long long> >::iterator it;
long long idx, l, r;
idx = v[i].second;
l = v[i].first.first;
r = v[i].first.second;
it = S.upper_bound(make_pair(r, m));
if (it == S.begin() || (--it)->first < l) {
cout << "No\n";
return 0;
}
ans[idx] = it->second;
S.erase(it);
}
cout << "Yes\n";
for (int i = 0; i < n - 1; i++) cout << ans[i] + 1 << " ";
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, i, cnt = 0, k, m, r;
cin >> n >> t;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
i = 0;
int *mn = min_element(a, a + n);
while (t >= *mn) {
k = t;
m = 0;
for (i = 0; i < n; i++) {
if (a[i] <= k) {
m += 1;
k -= a[i];
}
}
r = t / (t - k);
cnt += r * m;
t -= (t - k) * r;
}
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const int INF = 2e9 + 10;
const long long LONGINF = 4e18;
const long long INF2 = 1e17 + 10;
const long long mod = 998244353;
void solve() {
int n;
cin >> n;
vector<long long> v(n), t(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
cin >> t[i];
}
multiset<long long> cur;
long long sum = 0;
for (int i = 0; i < n; ++i) {
cur.insert(v[i] + sum);
long long today = 0;
long long sumold = sum;
sum += t[i];
while (!cur.empty() && *(cur.begin()) <= sum) {
today += *cur.begin() - sumold;
cur.erase(cur.begin());
}
today += t[i] * cur.size();
cout << today << ' ';
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
struct MI {
private:
char bb[4096];
FILE* f;
char *bs, *be;
char e;
bool o, l;
public:
MI() : f(stdin) {}
MI(FILE* f) : f(f), bs(0), be(0) {}
MI(const char* s) : f(fmemopen(const_cast<char*>(s), strlen(s), "r")) {}
inline operator bool() { return !l; }
inline char get() {
if (o) {
o = 0;
return e;
}
if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
if (bs == be) {
l = 1;
return -1;
};
return *bs++;
}
inline void unget(char c) {
o = 1;
e = c;
}
template <typename T>
inline T read() {
T r;
*this > r;
return r;
}
template <typename T>
inline MI& operator>(T&);
};
template <typename T>
struct Q {
const static bool U = T(-1) >= T(0);
inline void operator()(MI& t, T& r) const {
r = 0;
char c;
bool y = 0;
if (U)
for (;;) {
c = t.get();
if (c == -1) goto E;
if (isdigit(c)) break;
}
else
for (;;) {
c = t.get();
if (c == -1) goto E;
if (c == '-') {
c = t.get();
if (isdigit(c)) {
y = 1;
break;
};
} else if (isdigit(c))
break;
;
};
for (;;) {
if (c == -1) goto E;
if (isdigit(c))
r = r * 10 + (c ^ 48);
else
break;
c = t.get();
}
t.unget(c);
E:;
if (y) r = -r;
}
};
template <>
struct Q<char> {
inline void operator()(MI& t, char& r) {
int c;
for (;;) {
c = t.get();
if (c == -1) return void(r = -1);
if (!isspace(c)) return void(r = c);
}
}
};
template <typename T>
inline MI& MI::operator>(T& t) {
Q<T>()(*this, t);
return *this;
}
template <typename T>
std::ostream& operator<(std::ostream& out, const T& t) {
return out << t;
}
MI in;
const int lmax = 1002;
const long long lp = 1000000007;
using std::cout;
int n, k;
int a[lmax];
long long magic[lmax][lmax][2];
long long dfs(int x, int si, bool ok, bool top) {
if (!x) return ok;
int i;
long long& ret = magic[x][si][ok];
if ((!top) && ~ret) return ret;
const int lim = top ? a[x] : 9;
const int sub = si ? (si - 1) : 0;
long long rr = 0;
for (i = 0; i <= lim; i++) {
if (i == 4 || i == 7)
rr += dfs(x - 1, k, ok || si, top && i == lim);
else
rr += dfs(x - 1, sub, ok, top && i == lim);
}
rr %= lp;
if (!top) ret = rr;
return rr;
}
inline long long solve() { return dfs(n, 0, 0, 1); }
int main() {
memset(magic, -1, sizeof(magic));
int i, T;
char c;
in > T > k;
while (T--) {
while (!isdigit(c = in.get()))
;
for (n = 1;; n++) {
a[n] = c - '0';
if (!isdigit(c = in.get())) break;
}
std::reverse(a + 1, a + n + 1);
for (i = 1; i <= n && !a[i]; i++) a[i] = 9;
--a[i];
n -= !a[n];
long long ans = lp - solve();
while (!isdigit(c = in.get()))
;
for (n = 1;; n++) {
a[n] = c - '0';
if (!isdigit(c = in.get())) break;
}
std::reverse(a + 1, a + n + 1);
(ans += solve()) %= lp;
cout < ans < ('\n');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const ll mod = 1e9 + 7;
const int maxn = 80;
int n;
ll f[maxn][2];
int M[maxn];
ll dp[1 << 20][2];
vector<int> primes;
void add(ll& x, ll y) {
if (x >= mod) x %= mod;
if (y >= mod) y %= mod;
x += y;
if (x >= mod) x %= mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 2; i <= 70; i++) {
bool ok = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
ok = false;
break;
}
}
if (ok) {
primes.push_back(i);
}
}
assert(int(primes.size()) <= 20);
auto count = [&](int x, int p) {
int res = 0;
while (x % p == 0) {
x /= p;
res++;
}
return res;
};
for (int i = 1; i <= 70; i++) {
int& cur = M[i];
for (int j = 0; j < int(primes.size()); j++) {
if (count(i, primes[j]) & 1) {
cur = cur | (1 << j);
}
}
}
cin >> n;
for (int i = 1; i <= 70; i++) {
f[i][0] = 1;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ll ways = (f[x][0] + f[x][1]) % mod;
f[x][0] = f[x][1] = ways;
}
dp[0][0] = 1;
for (int i = 1; i <= 70; i++) {
int to = i & 1;
int at = 1 ^ to;
for (int mask = 0; mask < (1 << 20); mask++) {
dp[mask][to] = 0;
}
for (int mask = 0; mask < (1 << 20); mask++) {
add(dp[mask ^ M[i]][to], dp[mask][at] * f[i][1] % mod);
add(dp[mask][to], dp[mask][at] * f[i][0] % mod);
}
}
ll res = dp[0][0] - 1;
res %= mod;
res += mod;
res %= mod;
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf(
"%"
"d",
&n);
int l[10005], r[10005];
int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
for (int i = 0; i < n; i++) {
scanf(
"%"
"d",
&l[i]),
scanf(
"%"
"d",
&r[i]);
if (l[i] == 1)
c1++;
else if (l[i] == 0)
c2++;
if (r[i] == 1)
c3++;
else if (r[i] == 0)
c4++;
}
int min1 = min(c1, c2), min2 = min(c3, c4);
cout << min1 + min2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
vector<int> a[MaxN];
int p[MaxN];
int main() {
clock_t start_time = clock();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) a[i].clear();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 1; i <= n; i++) p[i] = i;
p[n + 1] = 0;
while (((float)(clock() - start_time)) / CLOCKS_PER_SEC < 2.7) {
random_shuffle(p + 1, p + n + 1);
int good = true;
for (int i = 1; i <= m; i++)
for (__typeof((a[p[i]]).begin()) pp = (a[p[i]]).begin();
pp != (a[p[i]]).end(); pp++)
if (*pp == p[i + 1]) good = false;
if (n == m)
for (__typeof((a[p[n]]).begin()) pp = (a[p[n]]).begin();
pp != (a[p[n]]).end(); pp++)
if (*pp == p[1]) good = false;
if (good) {
for (int i = 1; i <= m; i++)
if (i != n) printf("%d %d\n", p[i], p[i + 1]);
if (n == m) printf("%d %d\n", p[1], p[n]);
return 0;
}
}
printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n), c(n);
multiset<int> b;
const int q = 2e5 + 7;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int x;
cin >> x;
b.insert(x);
}
for (int i = 0; i < n; i++) {
int mn = (n - a[i]) % n;
auto it = b.equal_range(mn).first;
if (it != b.end()) {
c[i] = (a[i] + *it) % n;
b.erase(it);
} else {
it = b.equal_range(*b.begin()).first;
c[i] = (a[i] + *it) % n;
b.erase(it);
}
}
for (int i = 0; i < n; i++) cout << c[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const double esp = 1e-6;
char mp[105][105];
int n, m;
int f(int n1, int m1, int k) {
if (k < 0) return 0;
int min = 0, max = n1 * m1 / 2;
if (k >= min && k <= max && k % 2 == 0) return 1;
return 0;
}
void draw(int x, int y, int k) {
int i, j, c = 0, d = 0;
for (i = x; i < n; i += 2) {
c = 0;
if (k > 0) {
for (j = 0; j < y; j += 2) {
if (k > 0) {
mp[i][j] = mp[i][j + 1] = (char)('a' + c);
mp[i + 1][j] = mp[i + 1][j + 1] = (char)('a' + (c + 1) % 2);
c = (c + 1) % 2;
k -= 2;
} else
break;
}
if (k == 0) {
for (; j < y; j++) {
mp[i][j] = mp[i + 1][j] = (char)('c' + (d + j) % 2);
}
d++;
}
} else if (k == 0) {
for (j = 0; j < y; j++) {
mp[i][j] = mp[i + 1][j] = (char)('c' + (d + j) % 2);
}
d++;
}
}
}
int main() {
int t, k;
cin >> t;
while (t--) {
cin >> n >> m >> k;
int min = 0, max, flag;
if (n % 2 == 1 && m % 2 == 0) {
flag = f(n - 1, m, k - m / 2);
if (flag == 1) {
for (int j = 0; j < m; j += 2) {
mp[0][j] = mp[0][j + 1] = (char)('m' + j / 2 % 2);
}
draw(1, m, k - m / 2);
}
}
if (n % 2 == 0 && m % 2 == 1) {
flag = f(n, m - 1, k);
if (flag == 1) {
for (int j = 0; j < n; j += 2) {
mp[j][m - 1] = mp[j + 1][m - 1] = (char)('x' + j / 2 % 2);
}
draw(0, m - 1, k);
}
}
if (n % 2 == 0 && m % 2 == 0) {
flag = f(n, m, k);
if (flag == 1) {
draw(0, m, k);
}
}
if (flag == 1) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << mp[i][j];
}
cout << endl;
}
} else
cout << "NO" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
void solve() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
return;
}
if (a.size() == 1) {
cout << 1 << " " << 1 << endl;
return;
}
vector<int> ans;
int cnt = 0;
while (a != b && cnt <= 3 * n) {
if (a[0] == b[n - cnt - 1]) {
ans.push_back(1);
if (a[0] == '1')
a[0] = '0';
else
a[0] = '1';
ans.push_back(n - cnt);
for (int i = 0; i < n - cnt; i++) {
if (a[i] == '1')
a[i] = '0';
else
a[i] = '1';
}
reverse(a.begin(), a.end() - cnt);
} else {
ans.push_back(n - cnt);
for (int i = 0; i < n - cnt; i++) {
if (a[i] == '1')
a[i] = '0';
else
a[i] = '1';
}
reverse(a.begin(), a.end() - cnt);
}
cnt++;
}
cout << ans.size() << " ";
for (int i : ans) cout << i << " ";
cout << endl;
return;
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 5;
const int mod = 1000000007;
int mat[10][10][10];
int vis[4][4] = {0};
long long a[10];
long long b[10];
int main() {
long long n;
int x, y, prex = 0, prey = 0;
scanf("%lld", &n);
scanf("%d", &x);
scanf("%d", &y);
for (int k = 1; k <= 2; k++)
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) scanf("%d", &mat[k][i][j]);
long long cnt = 0;
while (n && !vis[x][y]) {
cnt++;
vis[x][y] = cnt;
prex = x;
prey = y;
a[cnt] = a[cnt - 1];
b[cnt] = b[cnt - 1];
if ((prex - prey == 1) || (prex - prey == -2)) a[cnt]++;
if ((prey - prex == 1) || (prey - prex == -2)) b[cnt]++;
x = mat[1][prex][prey];
y = mat[2][prex][prey];
n--;
}
a[0] = a[vis[x][y] - 1];
b[0] = b[vis[x][y] - 1];
int exa = a[cnt] - a[vis[x][y] - 1];
int exb = b[cnt] - b[vis[x][y] - 1];
(cnt) -= vis[x][y] - 1;
long long p = n / cnt;
a[0] += (p + 1) * (exa);
b[0] += (p + 1) * (exb);
n -= (p)*cnt;
while (n) {
prex = x;
prey = y;
if ((prex - prey == 1) || (prex - prey == -2)) a[0]++;
if ((prey - prex == 1) || (prey - prex == -2)) b[0]++;
x = mat[1][prex][prey];
y = mat[2][prex][prey];
n--;
}
printf("%lld ", a[0]);
printf("%lld ", b[0]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const facesCount = 4;
void rotateHoriz(string& colors) {
reverse(colors.begin() + 1, colors.begin() + facesCount);
reverse(colors.begin(), colors.begin() + facesCount);
}
void rotateLeft(string& colors) {
char const left = colors[(int)colors.size() - 1];
char const right = colors[(int)colors.size() - 2];
colors[(int)colors.size() - 1] = colors[3];
colors[(int)colors.size() - 2] = colors[1];
colors[1] = left;
colors[3] = right;
}
void rotateUp(string& colors) {
char const up = colors[0];
char const bottom = colors[2];
colors[0] = colors[(int)colors.size() - 2];
colors[2] = colors[(int)colors.size() - 1];
colors[(int)colors.size() - 1] = up;
colors[(int)colors.size() - 2] = bottom;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
string line;
cin >> line;
set<string> states;
int res = 0;
sort(line.begin(), line.end());
do {
string next(line);
bool exists = false;
for (int horizRot = (0); horizRot < ((4)); ++horizRot) {
for (int leftRot = (0); leftRot < ((4)); ++leftRot) {
for (int rightRot = (0); rightRot < ((4)); ++rightRot) {
if (states.count(next)) exists = true;
rotateUp(next);
}
rotateLeft(next);
}
rotateHoriz(next);
}
states.insert(line);
if (!exists) {
++res;
}
} while (next_permutation(line.begin(), line.end()));
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> p, sz, path;
int find(int x) {
if (p.find(x) == p.end()) {
p[x] = x, sz[x] = 1, path[x] = 0;
}
if (p[x] == x) return x;
int fa = p[x];
p[x] = find(fa);
path[x] ^= path[fa];
return p[x];
}
void Union(int x, int y, int k) {
int a = find(x), b = find(y);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a, sz[a] += sz[b];
path[b] = k ^ path[x] ^ path[y];
}
int ans;
void ch(int& x) {
if (ans == -1)
x ^= 1;
else
x ^= ans;
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
int op, l, r;
scanf("%d%d%d", &op, &l, &r);
ch(l), ch(r);
if (l > r) swap(l, r);
r++;
if (op == 1) {
int x;
scanf("%d", &x);
ch(x);
Union(l, r, x);
} else {
if (find(l) != find(r))
ans = -1;
else
ans = path[l] ^ path[r];
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
map<string, int> mp;
int main() {
int n;
gn(n);
char s[11];
for (int i = 0; i < n; i++) scanf("%s", s), mp[s]++;
for (int i = 0; i < n; i++) scanf("%s", s), mp[s]--;
int ans = 0;
for (map<string, int>::iterator it = mp.begin(); it != mp.end(); it++)
ans += abs(it->second);
println(ans >> 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i;
int main() {
cin >> n;
i = 1;
while (i * (i + 1) / 2 <= n) i++;
i--;
cout << i << endl;
if (i == 1) {
cout << n;
return 0;
}
n = n % (i * (i + 1) / 2);
for (k = 1; k < i; k++) cout << k << " ";
cout << i + n;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long N, A[100005], R[100005];
int main() {
scanf("%lld", &N);
for (int i = 1; i <= N; ++i) scanf("%lld", &A[i]);
if (N == 1) {
printf("1 1\n0\n1 1\n0\n1 1\n%lld\n", -A[1]);
return 0;
}
printf("%d %d\n%lld\n", 1, 1, N - A[1]);
A[1] = N;
printf("%d %d\n", 2, N);
long long L = N - 1;
for (long long i = 1; i <= N; ++i) {
long long r = (L * i) % N;
R[r] = L * i;
}
for (int i = 0; i < N; ++i) assert(R[i] > 0);
for (int i = 2; i <= N; ++i) {
long long t = (1000000007 + L) / L * L;
assert(A[i] + t >= 0);
long long rem = (A[i] + t) % N;
printf("%lld ", t - R[rem]);
A[i] += t - R[rem];
}
printf("\n");
printf("%d %d\n", 1, N);
for (int i = 1; i <= N; ++i) {
assert(A[i] % N == 0);
printf("%lld ", -A[i]);
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t;
scanf("%d", &t);
while (t--) {
ll n, g, b;
scanf("%lld%lld%lld", &n, &g, &b);
ll half = (n + 1) / 2;
if (g >= n) {
printf("%lld\n", n);
continue;
}
ll x = half / g + (half % g != 0);
printf("%lld\n", max(n, (x - 1) * 1LL * b + half));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int put[10005], work[10004];
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = k;
for (int i = 1; i <= n; i++) work[i] += k;
put[1] = k;
for (int i = n; i <= n + m; i++) {
if (work[i] < k) {
put[i] += k - work[i];
ans += k - work[i];
for (int j = i; j < n + i; j++) work[j] += (k - work[j]);
} else {
if (work[i + 1] == 0) {
for (int j = i; j < n + i; j++) work[j]++;
put[i]++;
ans++;
}
}
}
cout << ans << endl;
for (int i = 1; i <= n + m; i++)
for (int j = 0; j < put[i]; j++) cout << i << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k;
cin >> k;
string str;
cin >> str;
vector<int> res(n);
for (int i = 1; i < n; i++) {
int j = res[i - 1];
while (j > 0 && str[i] != str[j]) j = res[j - 1];
if (str[i] == str[j]) j++;
res[i] = j;
}
int po = n - res[n - 1];
for (int i = 0; i < k - 1; i++) {
cout << str.substr(0, po);
}
cout << str;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r = 1;
while (r != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
bool cprime(int n) {
int flag = 0;
int i;
int sq = sqrt(n);
for (i = 2; i <= sq; i++) {
if (n % i == 0) {
int is = gcd(i, n / i);
if (is == 1) {
flag = 1;
break;
}
}
}
if (flag == 0)
return false;
else
return true;
}
int main() {
int n, i;
cin >> n;
int ar[n + 1];
ar[1] = 1;
int cnt = 1;
for (i = 2; i <= n; i++) {
if (!cprime(i)) {
ar[cnt++] = i;
}
}
if (n == 1)
cout << 0 << endl;
else {
cout << cnt - 1 << endl;
for (i = 1; i < cnt; i++) cout << ar[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int N;
int H[5005];
int dp[5005][5005 / 2], f[5005][5005 / 2];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
memset(dp, 0, sizeof dp);
std::cin >> N;
for (int i = 0; i < N; i++) std::cin >> H[i];
for (int k = 1; k <= (N + 1) / 2; k++) {
for (int i = 2 * k - 2; i < N; i++) {
if (k > 1) {
dp[i][k] = dp[i - 2][k - 1] +
std::max(0, H[i - 1] - std::min(H[i - 2], H[i]) + 1);
if (i >= 3 && i >= 2 * k - 1)
dp[i][k] = std::min(
dp[i][k], f[i - 3][k - 1] + std::max(0, H[i - 1] - H[i] + 1));
} else if (i > 0)
dp[i][k] = std::max(0, H[i - 1] - H[i] + 1);
int tmp = 0;
if (i < N - 1) tmp = std::max(0, H[i + 1] - H[i] + 1);
f[i][k] = dp[i][k] + tmp;
if (i > 2 * k - 2) f[i][k] = std::min(f[i][k], f[i - 1][k]);
}
std::cout << f[N - 1][k] << " ";
}
std::cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class _Tp>
_Tp gcd(_Tp a, _Tp b) {
return (b == 0) ? (a) : (gcd(b, a % b));
}
const int inf = 1000000000;
const long long Inf = 1000000000000000000ll;
int read() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1005;
int fa[N], tot;
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
void merge(int x, int y) {
x = getfa(x);
y = getfa(y);
if (x != y) fa[x] = y, --tot;
}
int n;
map<int, vector<int> > lx, ly;
struct node {
int x, y;
} p[N];
vector<pair<int, int> > opsx, opsy;
bool check(int m) {
tot = n;
for (int i = 1; i <= n; ++i) fa[i] = i;
for (map<int, vector<int> >::iterator it = lx.begin(); it != lx.end(); ++it) {
vector<int>& t = it->second;
for (int i = 1; i < t.size(); ++i)
if (abs(p[t[i]].y - p[t[i - 1]].y) <= m) merge(t[i], t[i - 1]);
}
for (map<int, vector<int> >::iterator it = ly.begin(); it != ly.end(); ++it) {
vector<int>& t = it->second;
for (int i = 1; i < t.size(); ++i)
if (abs(p[t[i]].x - p[t[i - 1]].x) <= m) merge(t[i], t[i - 1]);
}
if (tot > 4) return 0;
if (tot == 4) {
opsx.clear();
opsy.clear();
for (map<int, vector<int> >::iterator it = lx.begin(); it != lx.end();
++it) {
vector<int>& t = it->second;
for (int i = 1; i < t.size(); ++i)
if (getfa(t[i]) != getfa(t[i - 1]))
opsx.push_back(make_pair(t[i], t[i - 1]));
}
for (map<int, vector<int> >::iterator it = ly.begin(); it != ly.end();
++it) {
vector<int>& t = it->second;
for (int i = 1; i < t.size(); ++i)
if (getfa(t[i]) != getfa(t[i - 1]))
opsy.push_back(make_pair(t[i], t[i - 1]));
}
for (vector<pair<int, int> >::iterator it1 = opsx.begin();
it1 != opsx.end(); ++it1) {
for (vector<pair<int, int> >::iterator it2 = opsy.begin();
it2 != opsy.end(); ++it2) {
int a = it1->first, b = it1->second;
int u = it2->first, v = it2->second;
if (getfa(a) == getfa(u) || getfa(a) == getfa(v) ||
getfa(b) == getfa(u) || getfa(b) == getfa(v))
continue;
if (abs(p[a].x - p[u].x) <= m && abs(p[a].x - p[v].x) <= m &&
abs(p[b].x - p[u].x) <= m && abs(p[b].x - p[v].x) <= m &&
abs(p[a].y - p[u].y) <= m && abs(p[a].y - p[v].y) <= m &&
abs(p[b].y - p[u].y) <= m && abs(p[b].y - p[v].y) <= m) {
return 1;
}
}
}
return 0;
}
if (tot == 3) {
opsx.clear();
for (map<int, vector<int> >::iterator it = lx.begin(); it != lx.end();
++it) {
vector<int>& t = it->second;
for (int i = 1; i < t.size(); ++i)
if (getfa(t[i]) != getfa(t[i - 1]))
opsx.push_back(make_pair(t[i], t[i - 1]));
}
for (map<int, vector<int> >::iterator it = ly.begin(); it != ly.end();
++it) {
vector<int>& t = it->second;
for (int i = 1; i < t.size(); ++i)
if (getfa(t[i]) != getfa(t[i - 1]))
opsx.push_back(make_pair(t[i], t[i - 1]));
}
for (int i = 0; i < opsx.size(); ++i) {
int p1 = opsx[i].first, p2 = opsx[i].second;
for (int j = 1; j <= n; ++j) {
if (fa[j] == fa[p1] || fa[j] == fa[p2]) continue;
if (abs(p[j].x - p[p1].x) <= m && abs(p[j].y - p[p1].y) <= m &&
abs(p[j].x - p[p2].x) <= m && abs(p[j].y - p[p2].y) <= m) {
return 1;
}
}
}
return 0;
}
if (tot == 2) {
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
if (getfa(i) == getfa(j)) continue;
if ((p[i].x == p[j].x && abs(1ll * p[i].y - 1ll * p[j].y) <= 2ll * m) ||
(p[i].y == p[j].y && abs(1ll * p[i].x - 1ll * p[j].x) <= 2ll * m) ||
(abs(p[i].x - p[j].x) <= m && abs(p[i].y - p[j].y) <= m)) {
return 1;
}
}
}
return 0;
}
if (tot == 1) {
return 1;
}
}
bool cmpx(int x, int y) { return p[x].x < p[y].x; }
bool cmpy(int x, int y) { return p[x].y < p[y].y; }
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
p[i].x = read();
p[i].y = read();
lx[p[i].x].push_back(i);
ly[p[i].y].push_back(i);
}
for (map<int, vector<int> >::iterator it = lx.begin(); it != lx.end(); ++it) {
vector<int>& t = it->second;
sort(t.begin(), t.end(), cmpy);
}
for (map<int, vector<int> >::iterator it = ly.begin(); it != ly.end(); ++it) {
vector<int>& t = it->second;
sort(t.begin(), t.end(), cmpx);
}
long long l = 0, r = 2000000000ll;
int ans = -1, mid;
while (l <= r) {
mid = (int)(l + r >> 1ll);
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n, t, r;
std::cin >> n >> t;
r = 2 * (n - 1);
t -= 10 * (n - 1);
do {
int e;
std::cin >> e;
t -= e;
} while (--n);
std::cout << (t < 0 ? -1 : r + t / 5);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long fast_exp(long long a, long long b) {
if (b <= 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
const long long N = 1e5 + 10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
multiset<long long> option;
long long ans = 0, cur;
for (long long i = 0; i < n; i++) {
cin >> cur;
if (option.empty())
option.insert(cur);
else {
auto itr = option.begin();
long long minim = *itr;
if (minim < cur) {
option.erase(itr);
ans += cur - minim;
option.insert(cur);
}
option.insert(cur);
}
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, i, j, n, m, k;
void brute() {
int mas[4][4];
vector<int> num;
memset((mas), 0, sizeof(mas));
for (int _n((n * n) - 1), i(0); i <= _n; i++) {
scanf("%d", &a);
num.push_back(a);
}
sort((num).begin(), (num).end());
do {
a = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
for (int _n((n)-1), j(0); j <= _n; j++) {
mas[i][j] = num[a++];
}
}
int s = -1000000000;
bool ok = 1;
for (int _n((n)-1), i(0); i <= _n; i++) {
int sum = 0;
for (int _n((n)-1), j(0); j <= _n; j++) sum += mas[i][j];
if (s == -1000000000)
s = sum;
else if (sum != s) {
ok = 0;
break;
}
sum = 0;
for (int _n((n)-1), j(0); j <= _n; j++) sum += mas[j][i];
if (sum != s) {
ok = 0;
break;
}
}
int sum = 0;
for (int _n((n)-1), i(0); i <= _n; i++) sum += mas[i][i];
if (sum != s) ok = 0;
sum = 0;
for (int _n((n)-1), i(0); i <= _n; i++) sum += mas[n - i - 1][i];
if (sum != s) ok = 0;
if (ok == 1) {
printf("%d\n", s);
for (int _n((n)-1), i(0); i <= _n; i++) {
for (int _n((n)-1), j(0); j <= _n; j++) {
if (j) printf(" ");
printf("%d", mas[i][j]);
}
printf("\n");
}
exit(0);
}
} while (next_permutation((num).begin(), (num).end()));
}
int mas[16];
int sum[2001], num[1 << 16], inv[2001];
vector<int> perm[2001][24];
unordered_map<unsigned long long, unsigned long long> q;
void die(unsigned long long rh, int n1, int n2, int cp1, int cp2, int sum) {
int p2 = rh % 24;
rh /= 24;
int p1 = rh % 24;
rh /= 24;
int v2 = rh % k;
rh /= k;
int v1 = rh;
printf("%d\n", sum);
for (int _n((4) - 1), i(0); i <= _n; i++) {
vector<int> cur;
if (!i)
cur = perm[n1][cp1];
else if (i == 1)
cur = perm[n2][cp2];
else if (i == 2)
cur = perm[v2][p2];
else
cur = perm[v1][p1];
for (int _n((4) - 1), j(0); j <= _n; j++) {
if (j) printf(" ");
printf("%d", cur[j]);
}
printf("\n");
}
exit(0);
}
int main() {
srand(25091992);
scanf("%d", &n);
if (n <= 3) brute();
for (int _n((n * n) - 1), i(0); i <= _n; i++) {
scanf("%d", &mas[i]);
}
random_shuffle(mas, mas + n * n);
for (int _n((1 << (n * n)) - 1), mask(0); mask <= _n; mask++) {
c = 0;
d = 0;
for (int _n((n * n) - 1), i(0); i <= _n; i++)
if (mask & 1 << i) {
c += mas[i];
++d;
}
if (d != 4) continue;
sum[k] = c;
inv[k] = mask;
num[mask] = ++k;
vector<int> cur;
for (int _n((n * n) - 1), i(0); i <= _n; i++)
if (mask & 1 << i) cur.push_back(mas[i]);
sort((cur).begin(), (cur).end());
a = 0;
do {
perm[k - 1][a++] = cur;
} while (next_permutation((cur).begin(), (cur).end()));
}
int ts = 0;
for (int _n((n * n) - 1), i(0); i <= _n; i++) ts += mas[i];
for (int _n((k)-1), i(0); i <= _n; i++) {
if (ts != sum[i] * 4) continue;
for (int _n((k)-1), j(0); j <= _n; j++) {
if (inv[i] & inv[j]) continue;
if (sum[i] != sum[j]) continue;
int s = sum[i];
for (int _n((24) - 1), p1(0); p1 <= _n; p1++) {
if ((int)((perm[i][p1]).size()) == 0) break;
const vector<int> &cp1 = perm[i][p1];
for (int _n((24) - 1), p2(0); p2 <= _n; p2++) {
if (perm[j][p2].empty()) break;
const vector<int> &cp2 = perm[j][p2];
unsigned long long h = 1, rh = 1;
for (int _n((4) - 1), z(0); z <= _n; z++) {
h = h * 1234567891 + cp1[z] + cp2[z];
rh = rh * 1234567891 + s - cp1[z] - cp2[z];
}
h = h * 1234567891 + cp1[0] + cp2[1];
rh = rh * 1234567891 + s - (cp1[3] + cp2[2]);
h = h * 1234567891 + cp1[3] + cp2[2];
rh = rh * 1234567891 + s - (cp1[0] + cp2[1]);
h = h * 1234567891 * (inv[i] | inv[j]);
rh = rh * 1234567891 * ((~(inv[i] | inv[j])) & ((1 << (n * n)) - 1));
if (q.count(rh)) {
die(q[rh], i, j, p1, p2, s);
}
unsigned long long val = (long long)k * 24 * 24 * i +
(long long)24 * 24 * j + (long long)24 * p1 +
p2;
q[h] = val;
}
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2>& p) {
out << p.first << ' ' << p.second;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) in >> x;
return in;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto x : v) out << x << ' ';
return out;
}
long long int n, m;
long long int a[1000005], b[1000005];
long long int pwr[31];
int main() {
iostream::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m;
for (long long i = (0); i < (n); ++i) cin >> a[i];
for (long long i = (0); i < (m); ++i) cin >> b[i];
long long int mm[40], m1[40];
memset(mm, 0, sizeof(mm));
;
memset(m1, 0, sizeof(m1));
;
pwr[0] = 1;
for (long long i = (1); i < (31); ++i) pwr[i] = pwr[i - 1] * 2;
for (long long i = (0); i < (m); ++i) m1[b[i]]++;
for (long long i = (0); i < (n); ++i) {
long long int j = 0, nn1 = 1;
while ((nn1) <= a[i]) {
if (nn1 & a[i]) mm[j]++;
j++;
nn1 <<= 1;
}
}
long long int cnt = 0;
long long int mxm = 0, ind = 0, cc, cc1;
for (long long i = (0); i < (31); ++i) {
cc = pwr[i] * mm[i];
mxm = 0, ind = 0;
for (long long int k = 0; k <= i; k++) {
if (cc == 0 || pwr[k] > cc) break;
long long int xx = min((cc / pwr[k]) * pwr[k], pwr[k] * m1[k]);
cc1 = xx / pwr[k];
m1[k] -= cc1;
cnt += cc1;
cc -= xx;
}
}
cout << cnt;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
char A[1000000];
bool B[1000000];
set<char> Vis;
set<char> lle;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i];
for (int i = N - 1; i >= 0; i--)
if (Vis.count(A[i]) == 0) {
B[i] = true;
Vis.insert(A[i]);
}
for (int i = 0; i < N; i++) {
if (lle.count(A[i]) == 0) {
lle.insert(A[i]);
K--;
if (K == -1) {
cout << "YES";
return 0;
}
if (B[i]) K++;
} else {
if (B[i]) K++;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
using namespace std;
long long n = read();
long long s[103], a[103], f[103][103][103];
long long dfs(long long l, long long r, long long x) {
if (l > r) return 0;
if (f[l][r][x] != -1) return f[l][r][x];
if (l == r) return f[l][r][x] = a[x];
long long ans = a[x] + dfs(l + 1, r, 1);
for (long long j = l + 1; j <= r; j++)
if (s[j] == s[l]) ans = max(ans, dfs(l + 1, j - 1, 1) + dfs(j, r, x + 1));
return f[l][r][x] = ans;
}
signed main() {
memset(f, -1, sizeof(f));
for (long long i = 1; i <= n; i++)
while (!isdigit(s[i])) s[i] = getchar();
for (long long i = 1; i <= n; i++) a[i] = read();
printf("%lld", dfs(1, n, 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, t1, t2, ans = 0;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) {
if (arr[i] == 1) {
t1 = i;
break;
}
}
for (int i = n; i >= 1; i--) {
if (arr[i] == 1) {
t2 = i;
break;
}
}
for (int i = min(t1, t2); i <= max(t1, t2); i++) {
if (arr[i] == 0) ans++;
}
cout << ans << endl;
}
void kick_ass() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
int main() { kick_ass(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, mx;
int a[1005];
map<int, int> mp;
vector<int> q;
void solve(int x, int y) {
int ans = 2;
if (x == 0 && y == 0) return;
mp[x]--;
mp[y]--;
q.push_back(x);
q.push_back(y);
while (1) {
int z = x + y;
if (mp[z]) {
ans++;
mp[z]--;
q.push_back(z);
} else
break;
x = y;
y = z;
}
mx = max(mx, ans);
for (int i = 0; i < q.size(); i++) mp[q[i]]++;
q.clear();
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) mp[a[i]]++;
mx = mp[0];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) solve(a[i], a[j]);
printf("%d\n", mx);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve()
{
int m, k;
cin >> m >> k;
vector<pair<int, int>> a;
vector<int> b;
for (int i = 1; i <= k; i++)
{
int num;
cin >> num;
if (num)
a.push_back({num, i});
}
sort(a.begin(), a.end(), greater<pair<int, int>>());
for (auto [num, i] : a)
{
for (int j = 0; j < num; j++)
b.push_back(i);
}
int MAX = sqrt(3 * m);
vector<vector<int>> res(MAX + 2, vector<int>(MAX + 2));
auto check = [&](int x) {
int cnt = 0;
int j = 0;
auto insert = [&](int x, int y) {
if (j < m)
res[x][y] = b[j++];
};
auto P = [&](int x1, int y1, int x2, int y2) {
if (res[x1][y1] == 0 || res[x2][y2] == 0)
return true;
return res[x1][y1] != res[x2][y2];
};
for (int i = 1; i <= x + 1; i++)
for (int j = 1; j <= x + 1; j++)
res[i][j] = 0;
for (int i = 1; i <= x; i++)
{
for (int j = 1; j <= x; j++)
{
if ((i + j) & 1)
{
if (j & 1)
insert(i, j);
}
else
{
;
}
}
}
for (int i = 1; i <= x; i++)
{
for (int j = 1; j <= x; j++)
{
if ((i + j) & 1)
{
if (i & 1)
;
}
else
{
if ((i & 1) && (j & 1))
insert(i, j);
}
}
}
for (int i = 1; i <= x; i++)
{
for (int j = 1; j <= x; j++)
{
if ((i + j) & 1)
{
if (i & 1)
insert(i, j);
}
else
{
;
}
}
}
if (j < m)
return false;
for (int i = 1; i <= x; i++)
{
for (int j = 1; j <= x; j++)
{
if (!P(i, j, i - 1, j - 1))
return false;
if (!P(i, j, i + 1, j - 1))
return false;
}
}
return true;
};
int l = 1, r = MAX;
int ans = 0;
while (l <= r)
{
int mid = (l + r) >> 1;
//cout << l << " " << r << endl;
if (check(mid))
{
r = mid - 1;
ans = mid;
}
else
l = mid + 1;
}
// //cout << check(2) << endl;
// ans = 6;
// cout << check(ans) << endl;
check(ans);
cout << ans << endl;
for (int i = 1; i <= ans; i++)
{
for (int j = 1; j <= ans; j++)
{
cout << res[i][j] << " ";
}
cout << endl;
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
cin >> T;
while (T--)
{
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i, j, k, l, m;
long long int sum = 0, sum1 = 0;
long long int c = 0, c1 = 0, c2 = 0, c3 = 0;
vector<long long int> v;
vector<long long int> v1;
vector<long long int> v2;
vector<pair<long long int, long long int> > v3;
set<long long int> se;
string s;
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= k)
sum = sum + 1;
else {
sum = sum + 2;
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
int a[101] = {0}, k, n;
scanf("%d%d", &n, &k);
int temp = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (k % a[i] == 0) {
if (a[i] > temp) temp = a[i];
}
}
int ans;
ans = k / temp;
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const long long N = 5e5 + 7;
long long t[11];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long k;
cin >> k;
while (1) {
long long res = 1;
for (long long i = 1; i <= 10; i++) res *= t[i];
if (res >= k) break;
long long mn = 1000;
for (long long i = 1; i <= 10; i++) mn = min(mn, t[i]);
for (long long i = 1; i <= 10; i++)
if (mn == t[i]) {
t[i]++;
break;
}
}
string s = ".codeforces";
for (long long i = 1; i <= 10; i++)
for (long long j = 1; j <= t[i]; j++) cout << s[i];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vis[30][30];
vector<int> v[30];
int main() {
int val, p, ts;
cin >> ts;
while (ts--) {
cin >> val >> p;
for (int i = 1; i <= val; i++) {
for (int j = i + 1; j <= val; j++) {
v[i].push_back(j);
}
}
int sum = 0, extra = 0;
while (1) {
sum = 0;
priority_queue<pair<int, int> > pq;
for (int i = 1; i <= val; i++) {
pq.push(make_pair(v[i].size(), i));
sum += v[i].size();
}
if (sum == 2 * val + p) break;
int u = pq.top().second;
v[u].pop_back();
}
for (int i = 1; i <= val; i++) {
for (int j = 0; j < v[i].size(); j++) cout << i << " " << v[i][j] << endl;
v[i].clear();
}
}
}
| 3 |
#include <bits/stdc++.h>
long long int factorial(int n) {
long long int a[n + 1];
a[0] = 1;
int i;
for (i = 1; i <= n; i++) {
a[i] = a[i - 1] * i;
}
return a[n];
}
int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int cmpi(const void *a, const void *b) {
return ((const int *)a)[0] - ((const int *)b)[0];
}
int min(int a, int b) { return (a > b ? b : a); }
int max(int a, int b) { return (a < b ? b : a); }
int main() {
int n, t, m, k, i, j, a[107], s[1007], d[1007];
long long int sum = 0;
char str[2001], strf[2001];
scanf("%d", &n);
scanf("%s", str);
for (i = n - 2; i >= 0; i -= 2) printf("%c", str[i]);
if (n % 2 == 0)
i = 1;
else
i = 0;
for (i; i < n; i += 2) printf("%c", str[i]);
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000 + 7;
int a[MAXN], dp[MAXN][MAXN];
int main() {
int n, T, l, r;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) dp[i][i] = a[i];
for (int j = 1; j < n; j++) {
for (int i = 1; i + j <= n; i++) {
dp[i][i + j] = dp[i][i + j - 1] ^ dp[i + 1][i + j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
dp[i][j] = max(dp[i][j], dp[i][j - 1]);
}
}
for (int j = n; j >= 1; j--) {
for (int i = j - 1; i >= 1; i--) {
dp[i][j] = max(dp[i][j], dp[i + 1][j]);
}
}
cin >> T;
while (T--) {
scanf("%d%d", &l, &r);
printf("%d\n", dp[l][r]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
template <typename... Args>
void read(Args &...args) {
((cin >> args), ...);
}
template <typename... Args>
void write(Args... args) {
((cout << args << " "), ...);
}
template <typename... Args>
void writeln(Args... args) {
((cout << args << " "), ...);
cout << "\n";
}
template <typename T>
void read(vector<T> &a) {
for (auto &ele : a) cin >> ele;
}
template <typename T>
void writeln(vector<T> &a) {
for (auto &ele : a) cout << ele << ' ';
cout << "\n";
}
const pair<int, int> dxy[] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
const pair<int, int> fxy[] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{1, 1}, {-1, -1}, {-1, 1}, {1, -1}};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n;
read(n);
vector<int> a(n + 1);
int tmp;
for (int i = 1; i <= n; ++i) {
read(tmp);
a[i] = a[i - 1] + tmp;
}
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= n; ++j) {
int sum = a[j] - a[i];
if (sum > (j - i) * 100) {
res = max(res, j - i);
}
}
}
writeln(res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
int arr[N];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
if (arr[0] + 2 != arr[n - 1]) {
cout << n << '\n';
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << '\n';
} else {
int a = 0, b = 0, c = 0;
for (int i = 0; i < n; i++)
if (arr[i] == arr[0])
a++;
else if (arr[i] == arr[0] + 1)
b++;
else
c++;
int ch1 = b / 2 * 2;
int ch2 = min(a, c) * 2;
if (ch1 > ch2) {
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1] && arr[i] == arr[0] + 1)
arr[i] = arr[0], arr[i + 1] = arr[0] + 2;
}
} else {
int mn = arr[0];
for (int i = 0; i < n / 2; i++)
if (arr[i] == arr[n - i - 1] - 2 && arr[i] == mn)
arr[i] = arr[n - i - 1] = mn + 1;
}
cout << n - max(ch1, ch2) << '\n';
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct re {
int x, y;
};
const int inf = 1e9 + 10;
const int N = 5000 + 10;
const double pi = 3.14;
int n, m, x, y, dodai[N];
vector<int> a[N];
int dist(int x, int y) {
if (x <= y) return y - x;
return (n - x + y);
}
void cal(int x) {
int kq = 0;
for (int i = 1; i <= n; ++i)
if (a[i].size()) kq = max(kq, dist(x, i) + dodai[i]);
cout << kq << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
a[x].push_back(y);
}
for (int i = 1; i <= n; ++i)
if (a[i].size()) {
dodai[i] = inf;
for (auto j : a[i]) dodai[i] = min(dodai[i], dist(i, j));
dodai[i] += (a[i].size() - 1) * n;
}
for (int i = 1; i <= n; ++i) cal(i);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, x;
cin >> t;
while (t--) {
cin >> x;
long long a = 1, b = 1, c = 1;
while (a <= x) {
b += pow(2, c);
a += (b * b) - ((b * (b - 1)) / 2);
c++;
}
cout << c - 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pii {
char C;
int fi;
int se;
};
char A[1000][1000];
void p(int L) {
cout << L << endl;
for (int i = 1; i <= L; ++i) {
for (int j = 1; j <= L; ++j) {
cout << A[i][j];
}
cout << endl;
}
}
void prin1(pii a, pii b, pii c) {
int L = a.se;
for (int i = 1; i <= L; ++i) {
for (int j = 1; j <= a.fi; ++j) {
A[i][j] = a.C;
}
}
for (int i = 1; i <= L; ++i) {
for (int j = a.fi + 1; j <= a.fi + b.fi; ++j) {
A[i][j] = b.C;
}
}
for (int i = 1; i <= L; ++i) {
for (int j = a.fi + b.fi + 1; j <= L; ++j) {
A[i][j] = c.C;
}
}
p(L);
}
void prin2(pii a, pii b, pii c) {
int L = a.fi;
for (int i = 1; i <= L; ++i) {
for (int j = 1; j <= a.se; ++j) {
A[j][i] = a.C;
}
}
for (int i = 1; i <= L; ++i) {
for (int j = a.se + 1; j <= a.se + b.se; ++j) {
A[j][i] = b.C;
}
}
for (int i = 1; i <= L; ++i) {
for (int j = a.se + b.se + 1; j <= L; ++j) {
A[j][i] = c.C;
}
}
p(L);
}
void prin3(pii a, pii b, pii c) {
int L = c.se;
for (int i = 1; i <= a.fi; ++i) {
for (int j = 1; j <= a.se; ++j) {
A[i][j] = a.C;
}
}
for (int i = 1; i <= b.fi; ++i) {
for (int j = a.se + 1; j <= L; ++j) {
A[i][j] = b.C;
}
}
for (int i = a.fi + 1; i <= L; ++i) {
for (int j = 1; j <= L; ++j) {
A[i][j] = c.C;
}
}
p(L);
}
void prin4(pii a, pii b, pii c) {
int L = a.fi;
for (int i = 1; i <= b.fi; ++i) {
for (int j = a.se + 1; j <= L; ++j) {
A[i][j] = b.C;
}
}
for (int i = b.fi + 1; i <= L; ++i) {
for (int j = a.se + 1; j <= L; ++j) {
A[i][j] = c.C;
}
}
for (int i = 1; i <= L; ++i) {
for (int j = 1; j <= a.se; ++j) {
A[i][j] = a.C;
}
}
p(L);
}
bool check(pii a, pii b, pii c) {
if (a.fi + b.fi + c.fi == a.se and a.se == b.se and b.se == c.se) {
prin1(a, b, c);
return 1;
}
if (a.fi == b.fi and b.fi == c.fi and a.fi == a.se + b.se + c.se) {
prin2(a, b, c);
return 1;
}
if (a.fi == b.fi + c.fi and a.fi == a.se + b.se and b.se == c.se) {
prin4(a, b, c);
return 1;
}
if (a.se + b.se == c.se and c.se == a.fi + c.fi and a.fi == b.fi) {
prin3(a, b, c);
return 1;
}
return 0;
}
int main() {
vector<pii> temp;
pii a, b, c;
cin >> a.fi >> a.se;
cin >> b.fi >> b.se;
cin >> c.fi >> c.se;
a.C = 'A';
b.C = 'B';
c.C = 'C';
vector<int> g;
g.push_back(0);
g.push_back(1);
g.push_back(2);
for (int mask = 0; mask < 8; ++mask) {
if (mask & (1 << 0)) swap(a.fi, a.se);
if (mask & (1 << 1)) swap(b.fi, b.se);
if (mask & (1 << 2)) swap(c.fi, c.se);
temp.clear();
sort(g.begin(), g.end());
temp.push_back(a);
temp.push_back(b);
temp.push_back(c);
do {
if (check(temp[g[0]], temp[g[1]], temp[g[2]])) return 0;
} while (next_permutation(g.begin(), g.end()));
if (mask & (1 << 0)) swap(a.fi, a.se);
if (mask & (1 << 1)) swap(b.fi, b.se);
if (mask & (1 << 2)) swap(c.fi, c.se);
}
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int num = 0; num < q; num++) {
int n;
cin >> n;
map<int, map<int, int>> nxtX;
vector<int> a(n);
vector<int> nxt(n + 1, -1), dp(n + 1, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i > -1; i--) {
if (nxtX[i + 1].find(a[i]) != nxtX[i + 1].end()) {
int pos = nxtX[i + 1][a[i]];
nxt[i] = pos;
swap(nxtX[i], nxtX[pos + 1]);
if (pos < n - 1) nxtX[i][a[pos + 1]] = pos + 1;
}
nxtX[i][a[i]] = i;
}
long long res = 0;
for (int i = n - 1; i > -1; i--) {
if (nxt[i] != -1) {
dp[i] = 1 + dp[nxt[i] + 1];
res += dp[i];
}
}
cout << res << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int gg[4][7] = {1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0,
0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1};
int h[4][4], a, b, c, d, e, f, g, sum, x[7];
bool ok;
bool check(int k) {
int t = sum - 3 * k;
a = h[0][1] + h[0][2] + h[0][3] - k - t;
if (a < 0 || a % 2 == 1) return false;
a /= 2;
b = h[0][1] + h[1][2] + h[1][3] - k - t;
if (b < 0 || b % 2 == 1) return false;
b /= 2;
c = h[0][2] + h[1][2] + h[2][3] - k - t;
if (c < 0 || c % 2 == 1) return false;
c /= 2;
d = h[0][3] + h[1][3] + h[2][3] - k - t;
if (d < 0 || d % 2 == 1) return false;
d /= 2;
e = t - (h[0][1] - a - b);
f = t - (h[0][2] - a - c);
g = t - (h[0][3] - a - d);
if (e < 0 || f < 0 || g < 0) return false;
ok = true;
return true;
}
int main() {
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++) {
scanf("%d", &h[i][j]);
sum += h[i][j];
}
ok = false;
for (int k = 1; k * 3 <= sum; k++)
if (check(k)) break;
if (!ok)
printf("%d\n", -1);
else {
printf("%d\n", a + b + c + d + e + f + g);
x[0] = a;
x[1] = b;
x[2] = c;
x[3] = d;
x[4] = e;
x[5] = f;
x[6] = g;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 7; j++)
for (int k = 0; k < x[j]; k++) printf("%c", gg[i][j] + 'a');
printf("\n");
}
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.