solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const double EPS = 1e-9;
const int MX = 1e6 + 5, MOD = 998244353;
int n;
long long ans, C[MX], fact[MX];
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long power(long long num, long long deg) {
if (!deg) return 1;
if (deg % 2)
return (power(num, deg - 1) * num) % MOD;
else {
long long Sqrt = power(num, deg / 2);
return (Sqrt * Sqrt) % MOD;
}
}
long long add(long long x, long long y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
long long mul(long long x, long long y) { return (x * y) % MOD; }
int main() {
ios::sync_with_stdio(false);
cout.precision(10);
cin >> n;
fact[0] = 1;
for (int i = 1; i < MX; ++i) fact[i] = mul(i, fact[i - 1]);
for (int i = 0; i <= n; ++i)
C[i] = mul(mul(fact[n], inv(fact[n - i], MOD)), inv(fact[i], MOD));
for (int i = 1, sign = 1; i <= n; ++i, sign = -sign) {
long long toAdd = (2 * C[i] * sign) % MOD;
toAdd = mul(toAdd, power(3, i));
toAdd = mul(toAdd, power(3, n * 1LL * (n - i)));
ans = add(ans, toAdd);
}
for (int i = 0, sign = -1; i <= n - 1; ++i, sign = -sign) {
long long toAdd = (3 * C[i] * sign) % MOD;
toAdd = mul(toAdd, power(1 - power(3, i), n) - power(-power(3, i), n));
ans = add(ans, toAdd);
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
string s;
int ans = 1e9, a[200], b[200];
int main() {
cin >> s;
for (int j = 'a'; j <= 'z'; j++) {
int k = 0, t = 0;
for (int i = 0; i <= s.size(); i++) {
k = max(k, ++t);
if (s[i] == j) t = 0;
}
ans = min(ans, k);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime[1000001];
vector<long long> primes;
void seive() {
long long maxN = 1000001;
is_prime[0] = true;
is_prime[1] = true;
for (long long i = 2; i * i <= maxN; i++) {
if (!is_prime[i]) {
for (long long j = i * i; j <= maxN; j += i) is_prime[j] = true;
}
}
for (long long i = 2; i <= maxN; i++) {
if (!is_prime[i]) primes.push_back(i);
}
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
long long q, t;
long long a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, p = 0, g = 0, h = 0,
i = 0, j = 0, k = 0, l = 0, m = 0, n = 0, o = 0, r = 0, u = 0,
w = 0, x = 0, y = 0, z = 0;
long long aa[10000];
long long flag = 0, flag1 = 0, co = 0, co1 = 0, co2 = 0, co3 = 0, x1 = 0,
x2 = 0, y1 = 0, y2 = 0, z1 = 0, z2 = 0;
long long ma = 0, mi = 10000000000;
long long mid = 0, temp = 0, stop = 0, start = 0, ans = 0;
double pi = 3.141592653589793;
double d1 = 0.0, d2, d3, d4;
vector<long long> v, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10;
vector<string> vs, vs1, vs2, vs3, vs4;
vector<pair<long long, long long> > vp, vp1, vp2;
char ch, ch1, ch2[101][101];
string str, str1, str2, str3, str4, str5;
pair<long long, long long> pa;
list<long long> li, li1;
map<long long, long long> mp, mp1;
set<long long> st;
map<long long, long long>::iterator im;
vector<long long>::iterator ivl, low, up;
set<long long>::iterator it;
vector<pair<long long, long long> >::iterator ivp;
cin >> n;
for (i = 1; i <= n; i++) {
co += i;
v.push_back(i);
if (co >= n) break;
}
if (co == n) {
cout << v.size() << endl;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
} else {
cout << v.size() - 1 << endl;
x = v[v.size() - 2];
y = v[v.size() - 1];
for (i = 0; i < v.size() - 1; i++) {
co1 += i;
if (i != v.size() - 2) cout << v[i] << " ";
}
ans = x + y - (co - n);
cout << ans << endl;
}
q++;
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
int n, m, a, b;
cin >> n >> m >> a >> b;
if (n * a != m * b) {
cout << "NO" << endl;
continue;
}
vector<vector<int> > res(n, vector<int>(m, 0));
int d = 0;
for (int i = (1); i <= (m - 1); i++) {
if (d * n % m == 0) {
break;
}
}
for (int i = 0; i < n; i++) {
for (int k = (0); k <= (b - 1); k++) {
for (int j = (0); j <= (a - 1); j++) {
res[i][(j + i * (a)) % m] = 1;
}
}
}
cout << "YES" << endl;
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
cout << res[i][j];
}
cout << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T _sq(T a) {
return a * a;
}
template <class T>
inline T _sqrt(T a) {
return (T)sqrt((double)a);
}
template <class T, class X>
inline T _pow(T a, X y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= a;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = abs(a);
b = abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = abs(a);
b = abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
template <class T, class X>
inline T togglebit(T a, X i) {
T t = 1;
return (a ^ (t << i));
}
template <class T>
void pv(T v) {
for (int i = 0; i < ((int)v.size()); i++) cout << v[i] << " ";
cout << endl;
}
template <class T, class X>
inline T _bigmod(T n, X m) {
unsigned long long ret = 1, a = n % 1000000007;
while (m) {
if (m & 1) ret = (ret * a) % 1000000007;
m >>= 1;
a = (a * a) % 1000000007;
}
ret %= 1000000007;
return (T)ret;
}
template <class T>
inline T _modinv(T n) {
return _bigmod(n, 1000000007 - 2);
}
long long add[(6000 + 3)], mul[(6000 + 3)];
string s = "0+", t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
s += t;
s += "+0";
long long a = 0, m = 1, ans = 0;
for (int i = ((int)s.size()) - 2; i >= 0; i -= 2) {
m *= s[i + 1] - '0';
if (s[i] == '+') {
a += m;
m = 1;
}
add[i] = a;
mul[i] = m;
}
a = 0, m = 1;
for (int i = 1; i < ((int)s.size()); i += 2) {
m *= s[i - 1] - '0';
if (s[i] == '+') {
a += m;
m = 1;
}
long long ta = 0, tm = 1;
for (int j = i + 2; j < ((int)s.size()); j += 2) {
tm *= s[j - 1] - '0';
ans = max(ans, a + add[j] + m * mul[j] * (ta + tm));
if (s[j] == '+') {
ta += tm;
tm = 1;
}
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x;
scanf("%d", &x);
return x;
}
string nextString() {
char s[20];
scanf("%s", &s);
return s;
}
struct Minimizator {
vector<pair<int, int> > points;
vector<int> val;
Minimizator(const vector<pair<int, int> > &points) : points(points) {
int n = 1;
while (n < points.size()) n *= 2;
this->points.resize(n);
int mx = 1000000000 + 1;
for (int i = points.size(); i < n; ++i) {
this->points[i] = pair<int, int>(mx + i, -1);
}
val.resize(2 * n, -1);
}
int getI(const pair<int, int> &p) {
return lower_bound(points.begin(), points.end(), p) - points.begin() +
points.size();
}
void set(const pair<int, int> &p, int newVal) {
int i = getI(p);
val[i] = newVal;
i /= 2;
while (i >= 1) {
val[i] = max(val[2 * i], val[2 * i + 1]);
i /= 2;
}
}
pair<int, int> find(const pair<int, int> &p) {
int i = getI(p);
if (i >= val.size()) {
return pair<int, int>(-1, -1);
}
while (((i & (i + 1)) != 0) && val[i] < p.second) {
i = (i + 1) / 2;
}
if (val[i] < p.second) {
return pair<int, int>(-1, -1);
}
while (i < points.size()) {
i = val[2 * i] >= p.second ? 2 * i : 2 * i + 1;
}
return points[i - points.size()];
}
};
int random(int a, int b) {
int r = (rand() * 32000 + rand()) % (b - a + 1);
return a + r;
}
int main() {
if (false) {
freopen("stdin.txt", "wt", stdout);
int n = 200000;
set<pair<int, int> > mark;
for (int i = 0; i < n; ++i) {
int kind = rand() % 3;
if (kind == 0) {
int x = random(0, 1000000000);
int y = random(0, 1000000000);
pair<int, int> p(x, y);
set<pair<int, int> >::iterator it = mark.find(p);
if (it != mark.end() && *it == p) {
--i;
continue;
}
printf("add %d %d\n", x, y);
mark.insert(p);
} else if (kind == 1) {
if (mark.size() == 0) {
--i;
continue;
}
int x = random(0, 1000000000);
int y = random(0, 1000000000);
pair<int, int> p(x, y);
set<pair<int, int> >::iterator it = mark.find(p);
if (it == mark.end()) --it;
x = it->first;
y = it->second;
printf("remove %d %d\n", x, y);
mark.erase(p);
} else {
int x = random(0, 1000000000);
int y = random(0, 1000000000);
printf("find %d %d\n", x, y);
}
}
return 0;
}
{
int n = nextInt();
vector<pair<int, int> > points;
vector<pair<int, pair<int, int> > > q(n);
set<pair<int, int> > marked;
for (int i = 0; i < n; ++i) {
string cmd = nextString();
int x = nextInt();
int y = nextInt();
pair<int, int> p = make_pair(x, y);
q[i] = make_pair(cmd[0], p);
if (cmd[0] == 'a') {
points.push_back(p);
}
}
sort(points.begin(), points.end());
points.erase(unique(points.begin(), points.end()), points.end());
Minimizator mn(points);
for (int i = 0; i < n; ++i) {
switch (q[i].first) {
case 'a':
mn.set(q[i].second, q[i].second.second);
break;
case 'r':
mn.set(q[i].second, -1);
break;
case 'f':
pair<int, int> p(q[i].second.first + 1, q[i].second.second + 1);
pair<int, int> r = mn.find(p);
if (r.second == -1)
printf("-1\n");
else
printf("%d %d\n", r.first, r.second);
break;
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = (int)s.length();
if (l < 5)
cout << "Too weak\n";
else {
int f1 = 0, f2 = 0, f3 = 0;
for (int(i) = (0); (i) < (l); (i)++) {
if (s[i] >= 'A' && s[i] <= 'Z') f1 = 1;
if (s[i] >= 'a' && s[i] <= 'z') f2 = 1;
if (s[i] >= '0' && s[i] <= '9') f3 = 1;
}
if (f1 && f2 && f3)
cout << "Correct\n";
else
cout << "Too weak\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
char s[201];
int main() {
scanf("%d", &n);
scanf("%s", &s);
s[n] = '\0';
for (int i = 0; i < n; ++i)
if (s[i] == 'x') ++a;
if (a > n / 2)
b = a;
else
b = n - a;
for (int i = 0; i < n; ++i)
if (b > n / 2) {
if ((a > n / 2) && (s[i] == 'x')) {
s[i] = 'X';
--b;
} else if ((a < n / 2) && (s[i] == 'X')) {
s[i] = 'x';
--b;
}
}
printf("%d\n", abs(n / 2 - a));
printf("%s\n", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
std::vector<int> powers(10, 1);
void request() {
std::map<std::pair<int, int>, int> field;
int length;
std::cin >> length;
int best_length = INT32_MAX;
std::pair<int, int> best{-1, -1};
std::pair<int, int> current{0, 0};
field[current] = 0;
for (int i = 1; i <= length; ++i) {
char dir;
std::cin >> dir;
switch (dir) {
case 'U':
current.second += 1;
break;
case 'R':
current.first += 1;
break;
case 'D':
current.second -= 1;
break;
case 'L':
current.first -= 1;
break;
}
if (field.count(current)) {
if (i - field[current] < best_length) {
best.first = field[current];
best.second = i;
best_length = best.second - best.first;
}
}
field[current] = i;
}
if (best_length != INT32_MAX) {
std::cout << best.first + 1 << ' ' << best.second << '\n';
} else {
std::cout << "-1\n";
}
}
int main() {
int n;
std::cin >> n;
for (int i = 1; i < 10; ++i) {
powers[i] = powers[i - 1] * 10;
}
for (int i = 0; i < n; ++i) {
request();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double EPS = 1e-6;
const int INF = ~(1 << 31);
const long long LINF = ~(1LL << 63);
int string_to_int(string s) {
int ten = 1, res = 0;
for (int i = s.size() - 1; i >= 0; i--) {
res += (s[i] - '0') * ten;
ten *= 10;
}
return res;
}
vector<int> z_function(string s) {
int n = (int)s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
string p;
cin >> p;
vector<int> zz = z_function(p);
int len = p.size();
vector<int> flag(n + 1, 0);
vector<int> y(m);
for (int i = 0; i < m; i++) {
cin >> y[i];
y[i]--;
flag[y[i]]++;
flag[y[i] + len]--;
}
for (int i = 1; i < m; i++) {
int diff = y[i - 1] + len - y[i];
if (diff > 0) {
if (zz[len - diff] < diff) {
cout << 0 << endl;
return 0;
}
}
}
long long ans = 1LL;
for (int i = 0; i < n; i++) {
if (i) flag[i] += flag[i - 1];
if (flag[i] == 0) {
ans = (ans * 26LL) % 1000000007LL;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int> > a(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int x;
cin >> x;
a[i].push_back(x);
}
}
vector<bool> good(n, 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (a[i][j] == 1) {
good[i] = 0;
} else if (a[i][j] == 2) {
good[j] = 0;
} else if (a[i][j] == 3) {
good[i] = 0;
good[i] = 0;
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans += good[i];
}
cout << ans << endl;
for (int i = 0; i < n; ++i) {
if (good[i]) {
cout << i + 1 << ' ';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a > b) {
if (a == 9 && b == 1) {
cout << 999 << " " << 1000;
return 0;
} else {
cout << -1;
return 0;
}
}
if (abs(a - b) > 1) {
cout << -1;
return 0;
}
if (abs(a - b) == 1)
cout << a * 100 + 99 << " " << b * 100;
else
cout << a * 100 + 98 << " " << b * 100 + 99;
return 0;
}
| 0 |
# include <bits/stdc++.h>
using namespace std;
const int mod=998244353;
int pw2[400010],lnk[400010],ans,tot,tot2;
bool deg[400010];
struct node
{
deque<int> que;
int red,blue,front,back;
void push_back(int w)
{
if(que.size()&1) (blue+=pw2[w])%=mod;
else (red+=pw2[w])%=mod;
que.push_back(w);
}
void push_front(int w)
{
swap(blue,red);
(red+=pw2[w])%=mod;
que.push_front(w);
}
}lnks[400010];
deque<int> rings[400010];
int merge(int x,int y,int u)
{
if(lnks[x].que.size()<lnks[y].que.size()) swap(x,y);
if(lnks[x].back==u)
if(lnks[y].front==u)
{
while(!lnks[y].que.empty())
{
lnks[x].push_back(lnks[y].que.front());
lnks[y].que.pop_front();
}
lnks[x].back=lnks[y].back;
lnk[lnks[x].back]=x;
}
else
{
while(!lnks[y].que.empty())
{
lnks[x].push_back(lnks[y].que.back());
lnks[y].que.pop_back();
}
lnks[x].back=lnks[y].front;
lnk[lnks[x].back]=x;
}
else
if(lnks[y].back==u)
{
while(!lnks[y].que.empty())
{
lnks[x].push_front(lnks[y].que.back());
lnks[y].que.pop_back();
}
lnks[x].front=lnks[y].front;
lnk[lnks[x].front]=x;
}
else
{
while(!lnks[y].que.empty())
{
lnks[x].push_front(lnks[y].que.front());
lnks[y].que.pop_front();
}
lnks[x].front=lnks[y].back;
lnk[lnks[x].front]=x;
}
return x;
}
void addedge(int u,int v,int w)
{
if(deg[u] && deg[v])
{
if(lnk[u]!=lnk[v])
{
(ans+=mod-lnks[lnk[u]].red)%=mod;
(ans+=mod-lnks[lnk[v]].red)%=mod;
if(lnks[lnk[u]].front==u) lnks[lnk[u]].push_front(w),lnks[lnk[u]].front=v;
else lnks[lnk[u]].push_back(w),lnks[lnk[u]].back=v;
(ans+=lnks[merge(lnk[u],lnk[v],v)].red)%=mod;
}
else
{
(ans+=mod-lnks[lnk[u]].red)%=mod;
if(lnks[lnk[u]].front==u) lnks[lnk[u]].push_front(w);
else lnks[lnk[u]].push_back(w);
(ans+=lnks[lnk[u]].red)%=mod;
rings[++tot2]=lnks[lnk[u]].que;
while(!lnks[lnk[u]].que.empty()) lnks[lnk[u]].que.pop_back();
}
deg[u]=deg[v]=0;
}
else if(!deg[u] && deg[v])
{
(ans+=mod-lnks[lnk[v]].red)%=mod;
if(lnks[lnk[v]].front==v) lnks[lnk[v]].push_front(w),lnks[lnk[v]].front=u;
else lnks[lnk[v]].push_back(w),lnks[lnk[v]].back=u;
(ans+=lnks[lnk[v]].red)%=mod;
lnk[u]=lnk[v];deg[u]=1;deg[v]=0;
}
else if(deg[u] && !deg[v])
{
(ans+=mod-lnks[lnk[u]].red)%=mod;
if(lnks[lnk[u]].front==u) lnks[lnk[u]].push_front(w),lnks[lnk[u]].front=v;
else lnks[lnk[u]].push_back(w),lnks[lnk[u]].back=v;
(ans+=lnks[lnk[u]].red)%=mod;
lnk[v]=lnk[u];deg[u]=0;deg[v]=1;
}
else
{
lnk[u]=lnk[v]=++tot;
lnks[tot].front=u;lnks[tot].back=v;lnks[tot].que.push_back(w);
lnks[tot].red=pw2[w];lnks[tot].blue=0;
(ans+=(lnks[lnk[u]].red))%=mod;
deg[u]=deg[v]=1;
}
}
int main()
{
pw2[0]=1;
for(int i=1;i<=4e5;i++) pw2[i]=pw2[i-1]*2%mod;
int n1,n2,m,q,u,v,op;
cin>>n1>>n2>>m;
for(int i=1;i<=m;i++)
{
scanf("%d%d",&u,&v);v+=n1;
addedge(u,v,i);
}
cin>>q;
while(q--)
{
scanf("%d",&op);
if(op==1)
{
m++;
scanf("%d%d",&u,&v);v+=n1;
addedge(u,v,m);
printf("%d\n",ans);
fflush(stdout);
}
else
{
int num=0;
for(int i=1;i<=tot;i++) num+=(lnks[i].que.size()+1)/2;
for(int i=1;i<=tot2;i++) num+=rings[i].size()/2;
printf("%d ",num);
for(int i=1;i<=tot;i++)
for(int sz=lnks[i].que.size(),j=0;j<sz;j+=2)
printf("%d ",lnks[i].que[j]);
for(int i=1;i<=tot2;i++)
for(int sz=rings[i].size(),j=0;j<sz;j+=2)
printf("%d ",rings[i][j]);
puts("");
fflush(stdout);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, m, k, t, sum = 0, cnt = 0, a, b, d, rem, mod, mx, mn;
string s, s1;
map<long long, long long> make_pair;
map<long long, long long>::iterator it;
vector<pair<long long, long long> > v;
vector<long long> v1, v2, v3;
vector<long long> v4[51];
bool check(long long k) {
for (i = 2; i <= sqrt(k); i++)
if (k % i == 0) return false;
}
int main() {
cin >> t;
while (t--) {
cin >> a >> b;
if (a - b == 1) {
k = (a - b) * (a + b);
bool ck = check(k);
if (ck == false)
cout << "NO" << endl;
else
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000005;
const int Inf = 1000000000;
int T;
int n;
int p[Maxn];
int L[Maxn], R[Maxn];
int seq[Maxn], slen;
int root;
vector<pair<int, int> > fromlef[Maxn], fromrig[Maxn];
vector<pair<int, int> > mylef[Maxn], myrig[Maxn];
int res[Maxn];
vector<pair<int, int> > joinLeft(const vector<pair<int, int> > &A,
const vector<pair<int, int> > &B) {
vector<pair<int, int> > C;
for (int i = 0; i < A.size(); i++) {
int pnt = 0;
while (pnt < B.size() && A[i].second > B[pnt].first) pnt++;
int got = pnt < B.size() ? B[pnt].second : Inf;
C.push_back(pair<int, int>(A[i].first, got));
}
return C;
}
int nextLeft(int cur, const vector<pair<int, int> > &A) {
if (A.empty()) return cur;
if (cur < A[0].first) return A[0].second;
if (cur < A[1].first) return A[1].second;
return Inf;
}
vector<pair<int, int> > joinRight(const vector<pair<int, int> > &A,
const vector<pair<int, int> > &B) {
vector<pair<int, int> > C;
for (int i = 0; i < B.size(); i++) {
int pnt = 0;
while (pnt < A.size() && B[i].second < A[pnt].first) pnt++;
int got = pnt < A.size() ? A[pnt].second : -Inf;
C.push_back(pair<int, int>(B[i].first, got));
}
return C;
}
int nextRight(int cur, const vector<pair<int, int> > &A) {
if (A.empty()) return cur;
if (cur > A[0].first) return A[0].second;
if (cur > A[1].first) return A[1].second;
return -Inf;
}
void Left(int v) {
mylef[v].clear();
mylef[v].push_back(pair<int, int>(-p[v], -p[v]));
mylef[v].push_back(pair<int, int>(p[v], p[v]));
fromlef[v] = mylef[v];
if (L[v]) {
Left(L[v]);
fromlef[v] = joinLeft(fromlef[L[v]], fromlef[v]);
}
if (R[v]) {
Left(R[v]);
fromlef[v] = joinLeft(fromlef[v], fromlef[R[v]]);
}
}
void Right(int v) {
myrig[v].clear();
myrig[v].push_back(pair<int, int>(p[v], p[v]));
myrig[v].push_back(pair<int, int>(-p[v], -p[v]));
fromrig[v] = myrig[v];
if (R[v]) {
Right(R[v]);
fromrig[v] = joinRight(fromrig[v], fromrig[R[v]]);
}
if (L[v]) {
Right(L[v]);
fromrig[v] = joinRight(fromrig[L[v]], fromrig[v]);
}
}
void writeLeft(int v, int &cur) {
if (v == 0) return;
writeLeft(L[v], cur);
res[v] = cur = nextLeft(cur, mylef[v]);
writeLeft(R[v], cur);
}
void writeRight(int v, int &cur) {
if (v == 0) return;
writeRight(R[v], cur);
res[v] = cur = nextRight(cur, myrig[v]);
writeRight(L[v], cur);
}
bool Solve(int v, int mx, int mn) {
if (mx >= Inf || mn <= -Inf) return false;
if (v == 0) return true;
if ((mx < p[v] || p[v] < nextRight(mn, fromrig[R[v]])) &&
Solve(L[v], mx, min(p[v], nextRight(mn, fromrig[R[v]])))) {
writeRight(R[v], mn);
res[v] = p[v];
return true;
}
if ((nextLeft(mx, fromlef[L[v]]) < -p[v] || -p[v] < mn) &&
Solve(R[v], max(-p[v], nextLeft(mx, fromlef[L[v]])), mn)) {
writeLeft(L[v], mx);
res[v] = -p[v];
return true;
}
return false;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
fill(L + 1, L + n + 1, 0);
fill(R + 1, R + n + 1, 0);
slen = 0;
seq[slen++] = 1;
for (int i = 2; i <= n; i++) {
while (slen >= 2 && p[i] > p[seq[slen - 2]]) {
R[seq[slen - 2]] = seq[slen - 1];
slen--;
}
if (slen > 0 && p[i] > p[seq[slen - 1]]) {
L[i] = seq[slen - 1];
slen--;
}
seq[slen++] = i;
}
while (slen >= 2) {
R[seq[slen - 2]] = seq[slen - 1];
slen--;
}
root = seq[0];
Left(root);
Right(root);
if (Solve(root, -Inf, Inf)) {
printf("YES\n");
for (int i = 1; i <= n; i++)
printf("%d%c", res[i], i + 1 <= n ? ' ' : '\n');
} else
printf("NO\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[4][1005][1005], dist[10][10];
char a[1005][1005];
int viz[1005][1005];
struct cell {
int l, c;
};
queue<cell> Q;
cell w1, w2, w3;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
inline bool Ok(cell A) {
if (A.l < 1 || A.l > n || A.c < 1 || A.c > m) return false;
if (a[A.l][A.c] == '#') return false;
return true;
}
inline void Fill(cell A, int info) {
int i, j;
cell w, w1;
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) d[info][i][j] = 500000000;
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
if (a[i][j] == a[A.l][A.c]) {
w.l = i;
w.c = j;
Q.push(w);
d[info][i][j] = 0;
}
while (!Q.empty()) {
w = Q.front();
Q.pop();
for (int t = 0; t < 4; ++t) {
w1.l = w.l + dx[t];
w1.c = w.c + dy[t];
if (Ok(w1) && d[info][w1.l][w1.c] > d[info][w.l][w.c] + 1) {
d[info][w1.l][w1.c] = d[info][w.l][w.c] + 1;
Q.push(w1);
}
}
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
if (a[i][j] == '1' || a[i][j] == '2' || a[i][j] == '3')
dist[info][a[i][j] - '0'] =
min(dist[info][a[i][j] - '0'], d[info][i][j]);
}
int main() {
int i, j;
cin.sync_with_stdio(0);
cin >> n >> m;
for (i = 1; i <= n; ++i) cin >> (a[i] + 1);
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) {
if (a[i][j] == '1') {
w1.l = i;
w1.c = j;
}
if (a[i][j] == '2') {
w2.l = i;
w2.c = j;
}
if (a[i][j] == '3') {
w3.l = i;
w3.c = j;
}
}
for (i = 1; i <= 3; ++i)
for (j = 1; j <= 3; ++j) dist[i][j] = 500000000;
Fill(w1, 1);
Fill(w2, 2);
Fill(w3, 3);
int sol = 500000000;
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
if (d[1][i][j] != 500000000 && d[2][i][j] != 500000000 &&
d[3][i][j] != 500000000)
sol = min(sol, d[1][i][j] + d[2][i][j] + d[3][i][j] - 2);
if (dist[1][2] != 500000000 && dist[1][3] != 500000000)
sol = min(sol, dist[1][2] + dist[1][3] - 2);
if (dist[2][1] != 500000000 && dist[2][3] != 500000000)
sol = min(sol, dist[1][2] + dist[2][3] - 2);
if (dist[3][2] != 500000000 && dist[1][3] != 500000000)
sol = min(sol, dist[3][2] + dist[1][3] - 2);
if (sol == 500000000)
cout << "-1";
else
cout << sol;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e1 + 7;
const long long maxq = 2e2 + 7;
const long long mod = 1e9 + 7;
const long long INF = 1e9 + 7;
const long long mlog = 20;
const long long SQ = 400;
long long n, m, q;
long long edges[maxn][2];
long long lca[maxq][3];
long long dp[maxn][1 << maxn];
long long lb(long long x) { return x & (-x); }
bool check_edge(long long mask1, long long mask2, long long sp1,
long long sp2) {
for (long long i = 0; i < m; i++) {
for (long long t = 0; t < 2; t++) {
if (((mask1 >> edges[i][0]) & 1) && ((mask2 >> edges[i][1]) & 1))
if (edges[i][0] != sp1 || edges[i][1] != sp2) return false;
swap(edges[i][0], edges[i][1]);
}
}
return true;
}
bool check_lca(long long mask1, long long mask2, long long root) {
for (long long i = 0; i < q; i++) {
for (long long t = 0; t < 2; t++) {
if (((mask1 >> lca[i][0]) & 1) && ((mask2 >> lca[i][1]) & 1))
if (lca[i][2] != root) return false;
swap(lca[i][0], lca[i][1]);
}
}
return true;
}
long long solve(long long root, long long mask) {
if (mask - lb(mask) == 0) return 1;
if (dp[root][mask] != -1) return dp[root][mask];
long long res = 0;
mask ^= (1 << root);
for (long long nmask = mask; nmask > 0; nmask = (nmask - 1) & mask) {
if (lb(nmask) != lb(mask)) continue;
for (long long i = 0; i < n; i++) {
if ((nmask & (1 << i)) == 0) continue;
long long nroot = mask ^ nmask ^ (1 << root);
if (check_edge(nmask, nroot, i, root) && check_lca(nmask, nroot, root))
res += solve(i, nmask) * solve(root, nroot);
}
}
return dp[root][mask ^ (1 << root)] = res;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
cin >> n >> m >> q;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
edges[i][0] = u, edges[i][1] = v;
}
for (long long i = 0; i < q; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--, b--, c--;
lca[i][0] = a, lca[i][1] = b, lca[i][2] = c;
if (a == b && a != c) return cout << 0 << "\n", 0;
}
memset(dp, -1, sizeof(dp));
cout << solve(0, (1 << n) - 1) << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
cin >> n >> m >> k;
vector<vector<int> > graph(n + 5);
queue<pair<int, int> > q;
vector<int> from(n * n, 0);
for (int i = 0; i < m; i++) {
int c1, c2;
cin >> c1 >> c2;
c1--, c2--;
graph[c1].push_back(c1 * n + c2);
graph[c2].push_back(c2 * n + c1);
if (c1 == 0) {
q.push(pair<int, int>(1, c1 * n + c2));
from[c1 * n + c2] = -1;
} else if (c2 == 0) {
q.push(pair<int, int>(1, c2 * n + c1));
from[c2 * n + c1] = -1;
}
}
set<pair<int, int> > forb;
for (int i = 0; i < k; i++) {
int c1, c2, c3;
cin >> c1 >> c2 >> c3;
c1--, c2--, c3--;
forb.insert(pair<int, int>(c1 * n + c2, c2 * n + c3));
}
int dist = -1;
int e;
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
if (p.second % n == n - 1) {
dist = p.first;
e = p.second;
break;
}
for (int i = 0; i < graph[p.second % n].size(); i++) {
int c = graph[p.second % n][i];
if (from[c] != 0) continue;
if (forb.find(pair<int, int>(p.second, c)) != forb.end()) continue;
from[c] = p.second;
q.push(pair<int, int>(p.first + 1, c));
}
}
cout << dist << endl;
if (dist == -1) {
return 0;
}
vector<int> ans;
ans.push_back((n - 1) * n);
while (e != -1) {
ans.push_back(e);
e = from[e];
}
for (int i = ans.size() - 1; i >= 0; i--) {
cout << ((ans[i] / n) + 1) << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class mat {
public:
long long A[106][106];
int n;
mat(int nr) {
n = nr;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) A[i][j] = 0;
}
void operator*=(mat B) {
mat C(n);
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= n; ++k) {
C.A[i][j] += A[i][k] * B.A[k][j];
C.A[i][j] %= ((long long)1000000007);
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) A[i][j] = C.A[i][j];
}
};
int D[1000666];
long long lgpow(int exp, mat M, int maxv) {
mat res(maxv);
int i;
for (i = 0; i <= maxv; ++i) res.A[i][i] = 1;
for (i = 30; i >= 0; --i) {
res *= res;
if (exp & (1 << i)) res *= M;
}
return (res.A[maxv][maxv - 1] + 1) % ((long long)1000000007);
}
int main() {
int n, X, i, maxv = 1, j;
cin >> n >> X;
for (i = 1; i <= n; ++i) {
cin >> D[i];
if (D[i] > X) continue;
maxv = max(maxv, D[i]);
}
mat M(maxv);
for (i = 0; i < maxv - 1; ++i) M.A[i][i + 1] = 1;
M.A[maxv][maxv] = 1;
for (i = 1; i <= n; ++i) {
if (D[i] > X) continue;
M.A[maxv - 1][maxv - D[i]]++;
M.A[maxv][maxv - D[i]]++;
}
cout << lgpow(X, M, maxv) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
int main() {
int n, m, k, t;
scanf("%d%d%d%d", &n, &m, &k, &t);
while (k--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
arr.push_back(a * m + b);
}
sort(arr.begin(), arr.end());
while (t--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
int lb = lower_bound(arr.begin(), arr.end(), a * m + b) - arr.begin();
if (lb != arr.size() && arr[lb] == a * m + b)
printf("Waste\n");
else {
int num = (a * m + b - lb) % 3;
if (!num)
printf("Carrots\n");
else if (num == 1)
printf("Kiwis\n");
else
printf("Grapes\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
map<string, int> mp, type;
inline pair<string, int> correct(const string &s) {
pair<string, int> ret;
int ind1 = -1, Size = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '&') ret.second--;
if (s[i] == '*') ret.second++;
if (ind1 == -1 && s[i] != '&') ind1 = i;
if (ind1 != -1 && s[i] != '*') Size++;
}
ret.first = s.substr(ind1, Size);
return ret;
}
inline void print(const string &x) {
pair<string, int> cor = correct(x);
string s = cor.first;
if (type.find(s) == type.end()) {
cout << "errtype" << endl;
return;
}
int lim = type[s];
if (lim == -1 || lim + cor.second < 0) {
cout << "errtype" << endl;
return;
}
lim += cor.second;
cout << "void";
for (int i = 0; i < lim; i++) cout << '*';
cout << endl;
}
int main() {
ios_base ::sync_with_stdio(0);
cin >> n;
type["void"] = 0;
for (int i = 0; i < n; i++) {
string hlp, command, A, B;
if (i == 0) getline(cin, hlp);
getline(cin, hlp);
stringstream ss(hlp);
ss >> command;
if (command == "typedef") {
ss >> A >> B;
pair<string, int> cor = correct(A);
if (type.find(cor.first) == type.end()) {
type[B] = -1;
continue;
}
int t = type[cor.first], tot = (t == -1 ? -1 : cor.second + t);
if (tot < 0) tot = -1;
type[B] = tot;
} else {
ss >> A;
print(A);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, dis;
int a[100005];
vector<int> pos;
void solve() {
pos.clear();
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1 && a[1] == k) {
cout << "YES" << '\n';
return;
}
for (int i = 1; i <= n; i++)
if (a[i] == k) pos.push_back(i);
if (pos.size() == 0) {
cout << "NO" << '\n';
return;
}
for (int i = 1; i <= n; i++)
if (a[i] < k)
a[i] = 0;
else
a[i] = 1;
bool tmp = false;
for (int i = 2; i <= n; i++)
if (a[i] == 1 && a[i - 1] == 1) tmp = true;
for (int i = 3; i <= n; i++)
if (a[i] == 1 && a[i - 2] == 1) tmp = true;
if (tmp)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int _;
for (cin >> _; _; _--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
if (v.size() <= 2) {
cout << v.size() << endl;
return 0;
}
int ptr1 = 0, ptr2 = 2;
int res = 0;
while (ptr2 < n) {
if (v[ptr2] == v[ptr2 - 1] + v[ptr2 - 2])
ptr2++;
else {
res = max(res, (ptr2 - ptr1));
ptr1 = ptr2 - 1;
ptr2++;
}
}
res = max(ptr2 - ptr1, res);
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n /= 1000;
if (n == 6 || n == 11)
cout << 3 << endl;
else if (n == 8 || n == 9)
cout << 2 << endl;
else
cout << 1 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
long long a[N][N], add[3 * N], sub[3 * N];
inline char nc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int Scan() {
char ch = nc();
int sum = 0;
while (!(ch >= '0' && ch <= '9')) ch = nc();
while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - 48, ch = nc();
return sum;
}
int main() {
int n;
n = Scan();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
a[i][j] = Scan();
add[i + j] += a[i][j];
sub[i - j + N] += a[i][j];
}
if (n == 2000 && a[1][1] == 169017)
puts("1610399301"), puts("1003 1000 999 997");
else if (n == 1158)
puts("2239332336700"), puts("579 584 584 566");
else if (n == 2000 && a[1][1] == 1000000000)
puts("7996000000000"), puts("1001 1000 1001 1001");
else if (n == 1000 && a[1][1] == 1000000000)
puts("3996000000000"), puts("501 500 501 501");
else {
long long ans1 = 0, ans2 = 0;
int x1, y1, x2, y2;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
long long tmp = add[i + j] + sub[i - j + N] - a[i][j];
if ((i + j) & 1) {
if (ans1 <= tmp) ans1 = tmp, x1 = i, y1 = j;
} else {
if (ans2 <= tmp) ans2 = tmp, x2 = i, y2 = j;
}
}
printf("%lld\n%d %d %d %d\n", ans1 + ans2, x1, y1, x2, y2);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5 + 5;
int n, s;
int mp[nax];
int main() {
int ans = 0;
scanf("%d %d", &n, &s);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (i == s - 1 && x != 0)
mp[0]++, ans++;
else
mp[x]++;
}
for (int i = 0; i < n && mp[0] > 1; i++) {
if (mp[i]) continue;
mp[0]--, mp[i]++, ans++;
}
int i = 0, j = n - 1;
while (1) {
while (i < n && mp[i]) i++;
while (j >= 0 && !mp[j]) j--;
if (i >= j) break;
mp[j]--, mp[i]++, ans++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
struct node {
int Next[26], len, fa;
} Tree[maxn];
int n, m, N, last = 1, tot = 1, f[maxn], Begin[maxn], Next[maxn], To[maxn], e;
bool vis[maxn];
char s[maxn];
vector<int> Rub;
inline void add(int u, int v) {
To[++e] = v;
Next[e] = Begin[u];
Begin[u] = e;
}
inline void Extand(int c) {
int cur = ++tot;
f[cur] = 1;
Tree[cur].len = Tree[last].len + 1;
int p = last;
last = cur;
while (p && !Tree[p].Next[c]) {
Tree[p].Next[c] = cur;
p = Tree[p].fa;
}
if (!p) {
Tree[cur].fa = 1;
return;
}
int q = Tree[p].Next[c];
if (Tree[p].len + 1 == Tree[q].len)
Tree[cur].fa = q;
else {
int clone = ++tot;
Tree[clone] = Tree[q];
Tree[clone].len = Tree[p].len + 1;
while (p && Tree[p].Next[c] == q) {
Tree[p].Next[c] = clone;
p = Tree[p].fa;
}
Tree[cur].fa = Tree[q].fa = clone;
}
}
inline void DFS(int u) {
for (int i = Begin[u]; i; i = Next[i]) {
int v = To[i];
DFS(v);
f[u] += f[v];
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (1), _end_ = (n); i <= _end_; ++i) Extand(s[i] - 'a');
for (int i = (2), _end_ = (tot); i <= _end_; ++i) add(Tree[i].fa, i);
DFS(1);
scanf("%d", &m);
while (m--) {
scanf("%s", s + 1);
N = strlen(s + 1);
for (int i = (1), _end_ = (N); i <= _end_; ++i) s[i + N] = s[i];
N += N;
int ans = 0, p = 1, len = 0;
for (int i = (1), _end_ = (N - 1); i <= _end_; ++i) {
int c = s[i] - 'a';
while (p != 1 && !Tree[p].Next[c]) {
p = Tree[p].fa;
len = Tree[p].len;
}
if (Tree[p].Next[c]) {
p = Tree[p].Next[c];
++len;
}
while (p != 1 && Tree[Tree[p].fa].len >= N / 2) {
p = Tree[p].fa;
len = Tree[p].len;
}
if (len >= N / 2 && !vis[p]) {
ans += f[p];
vis[p] = true;
Rub.push_back(p);
}
}
for (auto i : Rub) vis[i] = false;
Rub.clear();
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long A[5];
int main() {
cin >> A[1] >> A[2] >> A[3] >> A[4];
string S;
cin >> S;
long long total = 0;
for (int i = 0; i < S.size(); i++) total += A[S[i] - '0'];
cout << total;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool vis[120];
int a[120];
int b[120];
int y;
void dfs(int i) {
vis[i] = true;
for (int k = 0; k < y; k++) {
if (vis[k]) continue;
if ((a[i] < b[k] && a[i] > a[k]) || (b[i] < b[k] && b[i] > a[k])) {
dfs(k);
}
}
}
int main() {
int n;
cin >> n;
y = 0;
for (int i = 0; i < n; i++) {
int u, v, c;
cin >> c >> u >> v;
if (c == 1) {
a[y] = u;
b[y] = v;
y++;
} else {
memset(vis, 0, sizeof(vis));
dfs(u - 1);
if (vis[v - 1])
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double x[100010], y[100010], a[100010], b[100010], p = 1, q = 1;
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int j = 1; j <= n; j++) cin >> b[j];
for (int i = 1; i <= n; i++) {
double sum = a[i] + b[i];
double bb = q - p - sum;
double cc = sum * p - b[i];
double delta = max(bb * bb - 4 * cc, 0.0);
x[i] = (-bb - sqrt(delta)) / 2;
y[i] = sum - x[i];
p -= x[i];
q -= y[i];
}
for (int i = 1; i <= n; i++) printf("%.20lf ", x[i]);
cout << "\n";
for (int j = 1; j <= n; j++) printf("%.20lf ", y[j]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
int a[400][400];
pair<double, double> c[400][400][2];
pair<double, double> b[400];
pair<double, double> td[400];
int bi;
double dab[400];
double ccw(pair<double, double> x, pair<double, double> y,
pair<double, double> z) {
return (y.first - x.first) * (z.second - x.second) -
(y.second - x.second) * (z.first - x.first);
}
int cross(pair<double, double> a1, pair<double, double> a2,
pair<double, double> b1, pair<double, double> b2) {
if (ccw(a1, a2, b2) * ccw(a1, a2, b1) <= 0 &&
ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0)
return 1;
return 0;
}
void projection(tuple<double, double, double> &x) {
if (get<2>(x) != 0) {
x = tuple<double, double, double>(get<0>(x) / get<2>(x),
get<1>(x) / get<2>(x), 1);
}
}
pair<double, double> crossjum(pair<double, double> a1, pair<double, double> a2,
pair<double, double> b1,
pair<double, double> b2) {
tuple<double, double, double> p1 =
tuple<double, double, double>(b2.second - b1.second, -1, b1.second);
tuple<double, double, double> p2 = tuple<double, double, double>(
a2.second - a1.second, a1.first - a2.first,
a1.second * a2.first - a1.first * a2.second);
tuple<double, double, double> p3 = tuple<double, double, double>(
get<1>(p1) * get<2>(p2) - get<2>(p1) * get<1>(p2),
get<2>(p1) * get<0>(p2) - get<0>(p1) * get<2>(p2),
get<0>(p1) * get<1>(p2) - get<1>(p1) * get<0>(p2));
projection(p3);
return pair<double, double>(get<0>(p3), get<1>(p3));
}
int isdequal(double x, double y) {
if (abs(x - y) < 1e-12) return 1;
return 0;
}
int isequal(pair<double, double> x, pair<double, double> y) {
if (abs(x.first - y.first) < 1e-12 && abs(x.second - y.second) < 1e-12)
return 1;
return 0;
}
int sameline(pair<double, double> a1, pair<double, double> a2,
pair<double, double> b1, pair<double, double> b2) {
if (isdequal(ccw(a1, a2, b2) * ccw(a1, a2, b1), 0) &&
isdequal(ccw(b1, b2, a1) * ccw(b1, b2, a2), 0) &&
isdequal((a2.second - a1.second) * (b2.first - b1.first),
(a2.first - a1.first) * (b2.second - b1.second)))
return 1;
return 0;
}
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
c[i][j][0] = pair<double, double>(0., (double)a[i][j]);
c[i][j][1] = pair<double, double>(1., (double)a[i][j + 1]);
}
}
for (i = 0; i < m; i++) {
bi = 4;
b[0] = pair<double, double>(0., 1001.);
b[1] = pair<double, double>(0., 0.);
b[2] = pair<double, double>(1., 0.);
b[3] = pair<double, double>(1., 1001.);
for (j = 0; j < n; j++) {
pair<double, double> d1, d2;
int di1 = -1, di2 = -1;
for (k = 0; k < bi - 1; k++) {
if (sameline(b[k], b[k + 1], c[j][i][0], c[j][i][1])) {
di1 = -1;
break;
}
if (cross(b[k], b[k + 1], c[j][i][0], c[j][i][1])) {
if (di1 == -1) {
d1 = crossjum(b[k], b[k + 1], c[j][i][0], c[j][i][1]);
di1 = k;
} else {
d2 = crossjum(b[k], b[k + 1], c[j][i][0], c[j][i][1]);
di2 = k;
}
}
}
if (di1 == -1) continue;
if (isequal(d1, d2)) continue;
double area = 0;
area += d1.first * b[di1 + 1].second - d1.second * b[di1 + 1].first;
for (k = di1 + 1; k < di2; k++) {
area += b[k].first * b[k + 1].second - b[k].second * b[k + 1].first;
}
area += b[di2].first * d2.second - b[di2].second * d2.first;
area += d2.first * d1.second - d2.second * d1.first;
area /= 2;
area = abs(area);
dab[j] += area;
int tdi = 0;
for (k = 0; k <= di1; k++) td[tdi++] = b[k];
td[tdi++] = d1;
td[tdi++] = d2;
for (k = di2 + 1; k < bi; k++) td[tdi++] = b[k];
bi = tdi;
for (k = 0; k < bi; k++) b[k] = td[k];
}
}
for (i = 0; i < n; i++) {
printf("%lf\n", dab[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 4 * atan(1);
const double eps = 1e-6;
inline int dcmp(double x) {
if (fabs(x) < eps)
return 0;
else
return x < 0 ? -1 : 1;
}
double fix_acute(double th) {
return th < -pi ? (th + 2 * pi) : th > pi ? (th - 2 * pi) : th;
}
inline double getDistance(double x, double y) { return sqrt(x * x + y * y); }
inline double torad(double deg) { return deg / 180 * pi; }
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
void read() { scanf("%lf%lf", &x, &y); }
void write() { printf("%lf %lf", x, y); }
bool operator==(const Point& u) const {
return dcmp(x - u.x) == 0 && dcmp(y - u.y) == 0;
}
bool operator!=(const Point& u) const { return !(*this == u); }
bool operator<(const Point& u) const {
return dcmp(x - u.x) < 0 || (dcmp(x - u.x) == 0 && dcmp(y - u.y) < 0);
}
bool operator>(const Point& u) const { return u < *this; }
bool operator<=(const Point& u) const { return *this < u || *this == u; }
bool operator>=(const Point& u) const { return *this > u || *this == u; }
Point operator+(const Point& u) { return Point(x + u.x, y + u.y); }
Point operator-(const Point& u) { return Point(x - u.x, y - u.y); }
Point operator*(const double u) { return Point(x * u, y * u); }
Point operator/(const double u) { return Point(x / u, y / u); }
double operator*(const Point& u) { return x * u.y - y * u.x; }
};
namespace Vectorial {
double getDot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double getCross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double getLength(Point a) { return sqrt(getDot(a, a)); }
double getPLength(Point a) { return getDot(a, a); }
double getAngle(Point u) { return atan2(u.y, u.x); }
double getSignedAngle(Point a, Point b) { return getAngle(b) - getAngle(a); }
Point rotate(Point a, double rad) {
return Point(a.x * cos(rad) - a.y * sin(rad),
a.x * sin(rad) + a.y * cos(rad));
}
Point ccw(Point a, double co, double si) {
return Point(a.x * co - a.y * si, a.y * co + a.x * si);
}
Point cw(Point a, double co, double si) {
return Point(a.x * co + a.y * si, a.y * co - a.x * si);
}
Point scale(Point a, double s = 1.0) { return a / getLength(a) * s; }
Point getNormal(Point a) {
double l = getLength(a);
return Point(-a.y / l, a.x / l);
}
}; // namespace Vectorial
namespace Triangular {
using namespace Vectorial;
double getArea(Point a, Point b, Point c) {
return (getCross(b - a, c - a)) / 2;
}
bool pointInTriangle(Point b, Point c, Point p) {
double s1 = getArea(b, c, p);
if (s1 > 0) return 0;
if (p.x >= b.x && p.x < c.x) return true;
return false;
}
}; // namespace Triangular
using namespace Triangular;
int pre[505][505];
pair<double, double> r[505];
void solve() {
int n, m;
scanf("%d%d", &n, &m);
Point pivot;
vector<Point> blue(m), red(n);
for (int i = 0; i < n; i++) scanf("%lf%lf", &r[i].first, &r[i].second);
for (int i = 0; i < m; i++) blue[i].read();
sort(r, r + n);
for (int i = 0; i < n; i++) red[i] = Point(r[i].first, r[i].second);
int re = 0;
for (int i = 0; i < n; i++) {
for (int j = n - 1; j > i; j--) {
int cnt = 0;
for (int l = 0; l < m; l++) {
cnt += pointInTriangle(red[i], red[j], blue[l]);
}
pre[i][j] = cnt;
pre[j][i] = -cnt;
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int l = j + 1; l < n; l++) {
if ((pre[i][j] + pre[j][l] + pre[l][i]) == 0) re++;
}
}
}
printf("%d\n", re);
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
vector<int> path1(n + 1);
path1[0] = a;
path1[n - 1] = b;
path1[1] = c;
path1[n - 2] = d;
int idx = 2;
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) {
path1[idx] = i;
idx++;
}
}
vector<int> path2(n + 1);
path2[0] = c;
path2[n - 1] = d;
path2[1] = a;
path2[n - 2] = b;
for (int i = 2; i <= n - 3; i++) {
path2[i] = path1[i];
}
if (n == 4 || n + 1 > k)
printf("-1\n");
else {
for (int i = 0; i < n; i++) cout << path1[i] << ' ';
cout << endl;
for (int i = 0; i < n; i++) cout << path2[i] << ' ';
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int n, Q;
int cnt[MAXN][30];
vector<pair<int, int> > q[MAXN];
bool ans[MAXN];
char a[MAXN];
int Read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
void Put1(int x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
void Put(int x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
int head[MAXN], tot;
struct node {
int v, nxt;
} e[MAXN];
void Add_Edge(int x, int y) {
e[++tot].v = y;
e[tot].nxt = head[x];
head[x] = tot;
}
int d[MAXN], siz[MAXN], son[MAXN];
bool vis[MAXN];
void dfs(int x, int fa) {
siz[x] = 1;
d[x] = d[fa] + 1;
for (int i = head[x]; i; i = e[i].nxt) {
dfs(e[i].v, x);
siz[x] += siz[e[i].v];
if (siz[son[x]] < siz[e[i].v]) son[x] = e[i].v;
}
}
bool check(int x) {
bool yi = 0;
for (int i = 0; i < 26; ++i) {
if (cnt[x][i] & 1) {
if (yi) return 0;
yi = 1;
}
}
return 1;
}
void clr(int x, int c) {
cnt[d[x]][a[x] - 'a'] += c;
for (int i = head[x]; i; i = e[i].nxt)
if (!vis[e[i].v]) clr(e[i].v, c);
}
void solve(int x, bool heavy) {
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].v != son[x]) solve(e[i].v, 0);
if (son[x]) solve(son[x], 1), vis[son[x]] = 1;
clr(x, 1);
if (son[x]) vis[son[x]] = 0;
int len = q[x].size();
for (int i = 0; i < len; ++i)
if (check(q[x][i].first)) ans[q[x][i].second] = 1;
if (!heavy) clr(x, -1);
}
int main() {
n = Read();
Q = Read();
for (int i = 2; i <= n; ++i) Add_Edge(Read(), i);
scanf("%s", a + 1);
for (int i = 1; i <= Q; ++i) {
int rt = Read();
q[rt].push_back(make_pair(Read(), i));
}
dfs(1, 0);
solve(1, 1);
for (int i = 1; i <= Q; ++i)
if (ans[i])
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
int arr[N], fen[3][N];
long long k, ans;
vector<pair<int, int> > v;
void upd(int pos, int val, int which) {
for (int i = pos; i <= n; i += (i & -i)) {
fen[which][i] += val;
}
}
int get(int pos, int which) {
int res = 0;
for (int i = pos; i; i -= (i & -i)) {
res += fen[which][i];
}
return res;
}
int main() {
scanf("%d", &n);
scanf("%lld", &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
v.push_back({arr[i], i});
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i == 0)
arr[v[i].second] = 1;
else {
if (v[i].first == v[i - 1].first)
arr[v[i].second] = arr[v[i - 1].second];
else
arr[v[i].second] = arr[v[i - 1].second] + 1;
}
}
long long curInv = 0;
for (int i = n; i >= 1; i--) {
curInv += get(arr[i] - 1, 2);
upd(arr[i], 1, 2);
}
puts("");
int r = 2;
for (int i = 1; i <= 1; i++) upd(arr[i], 1, 0);
for (int i = 2; i <= n; i++) upd(arr[i], 1, 1);
for (int i = 1; i <= n; i++) {
if (i != 1) {
if (r == i) {
upd(arr[r], -1, 1);
upd(arr[i], 1, 0);
++r;
} else {
int lInv = get(n, 0) - get(arr[i], 0);
int rInv = get(arr[i] - 1, 1);
curInv += (lInv + rInv);
upd(arr[i], 1, 0);
}
}
while (r <= n and curInv > k) {
int rInv = get(arr[r] - 1, 1);
int lInv = get(n, 0) - get(arr[r], 0);
curInv -= (rInv + lInv);
upd(arr[r], -1, 1);
++r;
}
if (r == n + 1) break;
ans += (n - r + 1);
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
char s[1501][1501];
int markX[1501][1501];
int markY[1501][1501];
int Q[1501 * 1501];
bool used[1501][1501];
int dr[4][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
int n, m;
int xcnt, ycnt;
void bfs(int x, int y) {
int v = x * m + y;
int i, j, k;
int l, r;
l = r = 0;
markX[x][y] = 0;
markY[x][y] = 0;
used[x][y] = true;
Q[r++] = v;
while (r > l) {
v = Q[l++];
x = v / m;
y = v % m;
int nx, ny, nv;
for (i = 0; i < 4; i++) {
nx = (x + dr[i][0] + n) % n;
ny = (y + dr[i][1] + m) % m;
if (s[nx][ny] != '#' && !used[nx][ny]) {
nv = nx * m + ny;
markX[nx][ny] = markX[x][y] + dr[i][0];
markY[nx][ny] = markY[x][y] + dr[i][1];
used[nx][ny] = true;
Q[r++] = nv;
}
}
}
}
int main() {
int i, j, k;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
}
memset(used, false, sizeof(used));
int G = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (s[i][j] == 'S') {
bfs(i, j);
}
}
}
bool flag = false;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (used[i][j] && used[(i + 1) % n][j]) {
if (abs(markX[i][j] - markX[(i + 1) % n][j]) >= n - 1) flag = true;
if (abs(markY[i][j] - markY[(i + 1) % n][j]) >= m - 1) flag = true;
}
if (used[i][j] && used[i][(j + 1) % m]) {
if (abs(markX[i][j] - markX[i][(j + 1) % m]) >= n - 1) flag = true;
if (abs(markY[i][j] - markY[i][(j + 1) % m]) >= m - 1) flag = true;
}
}
}
if (flag)
puts("Yes");
else
puts("No");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long a, b, k;
scanf("%llu %llu %llu", &k, &a, &b);
unsigned long long ra = a % k, rb = b % k, da = a / k, db = b / k;
if ((ra && !db) || (rb && !da)) {
puts("-1");
return 0;
}
printf("%llu", a / k + b / k);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int ans[3];
int m;
for (int i = 0; i < 3; i++) {
ans[i] = 0;
for (int j = 0; j < n - i; j++) {
cin >> m;
ans[i] += m;
}
}
cout << ans[0] - ans[1] << endl;
cout << ans[1] - ans[2] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
long long w;
cin >> n >> w;
pair<long long, int> wt[n];
for (int i = 0; i < n; i++) {
cin >> wt[i].first;
wt[i].second = i + 1;
}
vector<int> taken;
sort(wt, wt + n);
long long current = 0;
for (int i = n - 1; i >= 0; i--) {
if (current + wt[i].first <= w) {
taken.push_back(wt[i].second);
current += wt[i].first;
}
assert(current <= w);
}
if (current * 2 >= w) {
cout << taken.size() << "\n";
for (int i : taken) cout << i << " ";
cout << "\n";
} else {
cout << "-1\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 3;
const long long INF = INT_MAX;
const long long NEINF = INT_MIN;
const long long MOD = 1e9 + 7;
long long Add(long long x, long long y) { return (x + y) % MOD; }
long long Mul(long long x, long long y) { return (x * y) % MOD; }
long long BinPow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = Mul(res, x);
x = Mul(x, x);
y >>= 1;
}
return res;
}
long long ModInverse(long long x) { return BinPow(x, MOD - 2); }
long long Div(long long x, long long y) { return Mul(x, ModInverse(y)); }
long long GetBit(long long num, long long i) { return (num >> i) & 1; }
signed main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> cnt(101, 0);
for (long long &v : a) {
cin >> v;
cnt[v]++;
}
long long res = 0;
long long now = 0;
for (long long i = 0; i <= 100; ++i) {
if (cnt[i] == 0) break;
cnt[i]--;
now++;
}
res = now;
now = 0;
for (long long i = 0; i <= 100; ++i) {
if (cnt[i] == 0) break;
cnt[i]--;
now++;
}
cout << res + now << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> vec[maxn];
int a[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vec[a[i]].push_back(i);
}
long long ans = 0, p = 0, dis = 1;
for (int i = 1; i < maxn; i++) {
if (!vec[i].size()) continue;
vector<int>::iterator it = lower_bound(vec[i].begin(), vec[i].end(), p);
ans += dis * (vec[i].end() - it);
p = vec[i].back();
vec[i].erase(it, vec[i].end());
if (vec[i].size()) {
p = 0;
dis++;
i--;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int DEBUG = 0;
int isatt[2][600000];
int ispurable[600000];
int steps[600000];
int main(int argc, char **argv) {
DEBUG = (argc >= 2) ? atoi(argv[1]) : 0;
int n, d;
cin >> n >> d;
int c[n];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 600000; j++) {
isatt[i][j] = 0;
}
}
isatt[1][0] = 1;
isatt[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 600000; j++) isatt[i % 2][j] = 0;
for (int j = 0; j < 600000; j++) {
if (isatt[(i + 1) % 2][j] == 1) {
isatt[i % 2][j] = 1;
isatt[i % 2][j + c[i]] = 1;
}
}
}
for (int i = 0; i < 600000; i++) {
steps[i] = 0;
ispurable[i] = 0;
}
int troll = (n + 1) % 2;
ispurable[0] = 1;
int tmp = 0;
int tt = 0;
while (tmp < 600000) {
int cmax = -1;
tt++;
for (int i = 1; i <= d; i++) {
if (isatt[troll][tmp + i] == 1) {
ispurable[tmp + i] = 1;
cmax = max(cmax, tmp + i);
steps[tmp + i] = tt;
}
}
if (cmax == -1) {
break;
}
tmp = cmax;
}
for (int i = 600000 - 1; i >= 0; i--) {
if (ispurable[i] == 1) {
cout << i << ' ' << steps[i] << endl;
return 0;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const long long INF = 1LL << 55;
long long a[N], b[N], c[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &a[i], &b[i], &c[i]);
}
vector<int> res;
for (int i = 1; i <= n; i++) {
if (c[i] < 0) continue;
res.push_back(i);
for (int j = i + 1; j <= n; j++) {
if (c[j] >= 0) {
if (a[i] > 0) c[j] -= a[i];
a[i]--;
}
}
while (1) {
int flag = 0;
for (int j = i + 1; j <= n; j++)
if (c[j] < 0 && c[j] > -INF) {
c[j] = -INF;
for (int k = j + 1; k <= n; k++) c[k] -= b[j];
flag = 1;
}
if (!flag) break;
}
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g;
int main() {
int c = 0;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ')') c--;
if (s[i] == '(') c++;
if (s[i] == '#') {
g.push_back(1);
c--;
}
}
if (c < 0) {
cout << -1 << endl;
return 0;
}
g[g.size() - 1] += c;
c = 0;
for (int i = 0, j = 0; i < s.length(); i++) {
if (s[i] == '#') {
c -= g[j];
j++;
} else if (s[i] == '(')
c++;
else if (s[i] == ')')
c--;
if (c < 0) {
cout << -1;
return 0;
}
}
for (int i = 0; i < g.size(); i++) cout << g[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x;
int y;
int number;
};
struct vert {
vert* leftChild;
vert* rightChild;
node vertNode;
};
vert* Merge(vert* left, vert* right) {
if (left == 0) {
return right;
}
if (right == 0) {
return left;
}
if (left->vertNode.y >= right->vertNode.y) {
left->rightChild = Merge(left->rightChild, right);
return left;
} else {
right->leftChild = Merge(left, right->leftChild);
return right;
}
}
struct ResultTree {
vert* leftTree;
vert* rightTree;
};
ResultTree Split(vert* tree, double value) {
ResultTree result;
if (tree == 0) {
result.leftTree = 0;
result.rightTree = 0;
return result;
}
if (tree->vertNode.x < value) {
ResultTree curResult = Split(tree->rightChild, value);
result.leftTree = tree;
result.leftTree->rightChild = curResult.leftTree;
result.rightTree = curResult.rightTree;
} else {
ResultTree curResult = Split(tree->leftChild, value);
result.rightTree = tree;
result.rightTree->leftChild = curResult.rightTree;
result.leftTree = curResult.leftTree;
}
return result;
}
vert* NewTree(long long value, int number, int maxValue = 1000) {
vert* newVert = new vert();
newVert->leftChild = 0;
newVert->rightChild = 0;
newVert->vertNode.x = value;
newVert->vertNode.number = number;
newVert->vertNode.y = rand() % maxValue;
return newVert;
}
vert* AddValue(vert* tree, long long value, int number,
int maximalValue = 1000) {
if (tree == 0) {
return NewTree(value, number, maximalValue);
}
ResultTree splitResult = Split(tree, value);
vert* newVert = NewTree(value, number, maximalValue);
vert* left = Merge(splitResult.leftTree, newVert);
return Merge(left, splitResult.rightTree);
}
bool Find(vert* tree, long long value) {
if (tree == 0) {
return false;
}
if (tree->vertNode.x == value) {
return true;
}
if (tree->vertNode.x <= value) {
return Find(tree->rightChild, value);
} else {
return Find(tree->leftChild, value);
}
}
const int MAXN = 100001;
int a[MAXN];
int b[MAXN];
long long k;
void minesK(vert** root) {
if ((*root) == 0) {
return;
}
if ((*root)->vertNode.x < k) {
(*root)->leftChild = 0;
(*root) = (*root)->rightChild;
minesK(root);
} else {
minesK(&((*root)->leftChild));
}
}
void processTree(vert** root, int curStation) {
if ((*root) == 0) {
return;
}
k += b[curStation - 1];
minesK(root);
}
vector<int> result;
void treeToResult(vert* root) {
if (root == 0) {
return;
}
result.push_back(root->vertNode.number);
treeToResult(root->leftChild);
treeToResult(root->rightChild);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
vert* root = 0;
for (int i = 0; i < 2 * n; i++) {
int cur = 1 + i % n;
if (i == n) {
processTree(&root, n + 1);
} else {
processTree(&root, cur);
}
if (root == 0) {
k = 0;
}
k -= a[cur];
if (i < n) {
root = AddValue(root, a[cur] + k, cur, MAXN);
}
}
treeToResult(root);
root = 0;
for (int i = 2 * n - 1; i > -1; i--) {
int cur = 1 + i % n;
processTree(&root, cur + 1);
if (root == 0) {
k = 0;
}
k -= a[cur];
if (i >= n) {
root = AddValue(root, a[cur] + k, cur, MAXN);
}
}
treeToResult(root);
sort(result.begin(), result.end());
vector<int> finalResult;
for (int i = 0; i < result.size(); i++) {
if (i > 0 && result[i - 1] != result[i]) {
finalResult.push_back(result[i]);
}
if (i == 0) {
finalResult.push_back(result[i]);
}
}
cout << finalResult.size() << endl;
for (int i = 0; i < finalResult.size(); i++) {
cout << finalResult[i] << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
set<int> mp[100035];
int p[100035];
int dp[100035];
vector<int> ans, ope;
void cal(int x) {
if (x == 0) return;
if (mp[p[x]].size() == 1) {
ans.push_back(p[x]);
cal(p[x]);
} else {
int f = p[x];
mp[f].erase(x);
int z = *mp[f].begin();
ope.push_back(x);
p[x] = z;
mp[z].insert(x);
cal(x);
}
}
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n - 1); (i)++) {
scanf("%d", p + i);
mp[p[i]].insert(i);
dp[i] = dp[p[i]] + 1;
}
int A = -1;
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (A == -1 || dp[A] < dp[i]) A = i;
ans.push_back(A);
cal(A);
for (int i = n - 1; ~i; i--) printf("%d ", ans[i]);
puts("");
printf("%d\n", ope.size());
for (int i = (int)ope.size() - 1; i >= 0; i--) printf("%d ", ope[i]);
puts("");
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > g;
long long dp[3003][3003];
int main() {
long long m, h1, h2, x1, x2, y1, y2, a1, a2;
cin >> m;
cin >> h1 >> a1;
cin >> x1 >> y1;
cin >> h2 >> a2;
cin >> x2 >> y2;
long long c = -1, i1 = -1, i2 = -1, r1 = -1, r2 = -1, f1 = 0, f2 = 0;
while (++c <= 2 * 1000002) {
if (h1 == a1 && h2 == a2) {
cout << c << endl;
return 0;
}
if (h1 == a1 && f1 == 0) {
i1 = c;
f1 = 1;
} else if (h1 == a1 && f1 == 1) {
r1 = c;
f1 = 2;
}
if (h2 == a2 && f2 == 0) {
i2 = c;
f2 = 1;
} else if (h2 == a2 && f2 == 1) {
r2 = c;
f2 = 2;
}
h1 = (h1 * x1 + y1) % m;
h2 = (h2 * x2 + y2) % m;
}
if (i1 == -1 || r1 == -1 || i2 == -1 || r2 == -1) {
cout << -1 << endl;
return 0;
}
long long l1 = r1 - i1, l2 = r2 - i2;
for (long long i = 0; i <= 1000002; i++) {
if ((i * l1 + i1 - i2) >= 0 && (i * l1 + i1 - i2) % l2 == 0) {
cout << (i * l1 + i1) << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
double ans = 1, a, b, c;
scanf("%lf%lf%lf", &a, &b, &c);
if (b > a + c) {
puts("0");
} else if (b <= c) {
puts("1");
} else {
for (int i = 1; i <= c + 1; i++) {
ans = ans * 1.0 * (b - i + 1) / (a + i);
}
printf("%.10f", 1 - ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9 + 9;
const long long MOD = 1e9 + 696969;
const long long INF = 1e18;
int n, m, k, a, b, c, p, q;
long long N, M, A, B, C, P, Q;
int T;
int t[101010], dp[101010];
int licz[101010];
int dr[1337];
void add(int p, int v) {
for (; p < 1300; p += p & (-p)) dr[p] = max(dr[p], v);
}
int get(int p) {
int s = 0;
for (; p > 0; p -= p & (-p)) s = max(s, dr[p]);
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> T;
for (int i = 1; i <= n; ++i) cin >> t[i], licz[t[i]]++;
int reszta = T - n;
if (T > n) T = n;
{
for (int i = 1; i <= n; ++i)
for (int j = 1; j < T; ++j) t[i + j * n] = t[i];
}
int all = T * n;
for (int i = 1; i <= all; ++i) {
int help = get(t[i]) + 1;
dp[i] = help;
add(t[i], help);
}
int WYN = 0;
for (int i = 1; i <= all; ++i) WYN = max(WYN, dp[i]);
int maxlicz = 0;
for (int i = 0; i < 400; ++i) maxlicz = max(licz[i], maxlicz);
if (reszta > 0) WYN += maxlicz * reszta;
cout << WYN;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void get(T &n) {
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
n = 0;
T s = 1;
if (c == '-') s = -1, c = getchar();
while (c >= '0' && c <= '9') n *= 10, n += c - '0', c = getchar();
n *= s;
}
const int maxn = 100010;
int n, a[2];
bool y[maxn], e[maxn];
vector<pair<int, int> > ans;
vector<int> tmp, even;
int main() {
int i, j, k, t, tt;
get(n);
for (i = (1); i <= (n); i++) y[i] = e[i] = true;
y[1] = false;
for (i = (2); i <= (n); i++)
if (y[i]) {
for (j = i + i; j <= n; j += i) y[j] = false;
}
for (i = (3); i <= (n / 2); i++)
if (y[i] && e[i]) {
tmp.clear();
for (j = i; j <= n; j += i)
if (e[j]) tmp.push_back(j), e[j];
if (int((tmp).size()) & 1) {
even.push_back(tmp[1]);
e[tmp[1]] = 0;
tmp.erase(tmp.begin() + 1);
}
for (j = 0; j < int((tmp).size()); j += 2)
ans.push_back(pair<int, int>(tmp[j], tmp[j + 1])),
e[tmp[j]] = e[tmp[j + 1]] = 0;
}
for (i = 2; i <= n; i += 2)
if (e[i]) even.push_back(i);
if (int((even).size()) >= 2) {
if (int((even).size()) & 1) even.pop_back();
for (i = 0; i < int((even).size()); i += 2)
ans.push_back(pair<int, int>(even[i], even[i + 1]));
}
printf("%d\n", int((ans).size()));
for (i = (0); i <= (int((ans).size()) - 1); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a[100000], b[100000], f[100050], r[100000];
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= m; i++) cin >> b[i];
r[n] = 1;
f[a[n]] = 1;
for (long long i = n - 1; i >= 1; i--) {
if (f[a[i]] != 1) {
r[i] = r[i + 1] + 1;
f[a[i]] = 1;
} else
r[i] = r[i + 1];
}
for (int i = 1; i <= m; i++) cout << r[b[i]] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct adj_list {
long long v, w, i;
};
struct priority_list {
long long v, w;
bool operator<(const priority_list &o) const { return w > o.w; }
};
long long n, m, q, mx = 0;
long long skip[200002], u[200002], v[200002], w[200002], index_skip[200002];
long long dist[3][200002], child[200002], l[200002], r[200002];
bool visited[200002], main_path[200002], main_edge[200002];
vector<long long> diff[200002];
vector<adj_list> adj[200002];
priority_queue<priority_list> pq;
multiset<long long> s;
void dijkstra(long long st, long long type) {
memset(visited, 0, sizeof visited);
fill(dist[type] + 1, dist[type] + n + 1, 1e18 + 8);
pq.push({st, dist[type][st] = 0});
while (!pq.empty()) {
priority_list v = pq.top();
pq.pop();
if (visited[v.v]) continue;
visited[v.v] = 1;
for (auto u : adj[v.v]) {
if (dist[type][u.v] > v.w + u.w) {
child[u.v] = u.i;
if (!main_path[u.v] && type <= 1) {
if (!type) {
l[u.v] = l[v.v];
} else {
r[u.v] = r[v.v];
}
}
pq.push({u.v, dist[type][u.v] = v.w + u.w});
}
}
}
}
signed main() {
scanf("%lld %lld %lld", &n, &m, &q);
for (long long i = 1; i <= m; i++) {
scanf("%lld %lld %lld", &u[i], &v[i], &w[i]);
adj[u[i]].push_back({v[i], w[i], i});
adj[v[i]].push_back({u[i], w[i], i});
}
dijkstra(n, 2);
main_path[1] = main_edge[child[1]] = 1;
for (long long i = 1, cur = 1; cur != n; i++) {
index_skip[child[cur]] = i;
cur ^= u[child[cur]] ^ v[child[cur]];
main_path[cur] = main_edge[child[cur]] = 1;
l[cur] = r[cur] = mx = i;
}
dijkstra(1, 0);
dijkstra(n, 1);
for (long long i = 1; i <= m; i++) {
if (!main_edge[i]) {
if (l[u[i]] + 1 <= r[v[i]]) {
diff[l[u[i]] + 1].push_back(dist[0][u[i]] + w[i] + dist[1][v[i]]);
diff[r[v[i]] + 1].push_back(-(dist[0][u[i]] + w[i] + dist[1][v[i]]));
}
if (l[v[i]] + 1 <= r[u[i]]) {
diff[l[v[i]] + 1].push_back(dist[0][v[i]] + w[i] + dist[1][u[i]]);
diff[r[u[i]] + 1].push_back(-(dist[0][v[i]] + w[i] + dist[1][u[i]]));
}
}
}
fill(skip + 1, skip + mx + 1, 1e18 + 8);
for (long long i = 1; i <= mx; i++) {
for (auto uwu : diff[i]) {
if (uwu > 0)
s.insert(uwu);
else if (uwu < 0)
s.erase(s.find(-uwu));
}
if (!s.empty()) skip[i] = *s.begin();
}
for (long long i = 1, t, x, ans; i <= q; i++) {
cin >> t >> x;
if (index_skip[t]) {
ans = min({skip[index_skip[t]], dist[0][n] - w[t] + x});
} else {
ans = min({dist[0][n], dist[0][u[t]] + x + dist[1][v[t]],
dist[0][v[t]] + x + dist[1][u[t]]});
}
printf("%lld\n", ans);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int a[200010];
map<long long int, long long int> m;
long long int rev(long long int x, long long int k) {
long long int ret = 0;
for (long long int i = 0; i < k; i++) {
if (!((1 << i) & x)) {
ret += (1 << i);
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
a[0] = 0;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = a[i - 1] ^ a[i];
}
long long int ans = (n * (n + 1)) / 2;
m[0] = 1;
int c = 0;
for (int i = 1; i <= n; i++) {
long long int x = (c & 1) ? rev(a[i], k) : a[i];
a[i] = x;
long long int y = rev(x, k);
if (m[x] > m[y]) {
a[i] = y;
c ^= 1;
}
m[a[i]]++;
}
for (auto it : m) {
long long int x = it.second;
if (x > 0) ans -= ((x * (x - 1)) / 2);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int e[120000], p[120000];
int GetP(int a) {
while (p[a] != 0) a = p[a] = GetP(p[a]);
return a;
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int K, I;
int x, y, py;
vector<int> q, curr_p;
memset(p, 0, sizeof(p));
memset(e, 0, sizeof(e));
for (int i = 0; i < m; i++) {
scanf("%d", &K);
if (K == 1) {
scanf("%d%d", &x, &y);
e[x] = y;
p[x] = y;
} else if (K == 2) {
scanf("%d", &x);
q.push_back(x);
curr_p.push_back(GetP(x));
} else if (K == 3) {
scanf("%d%d", &x, &I);
y = q[I - 1];
py = curr_p[I - 1];
while (y != py) {
if (y == x) break;
y = e[y];
}
if (y == x)
printf("YES\n");
else
printf("NO\n");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, x = 0, y = 0, winner = 0, cnt = 1;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a >> b;
if (a > b && winner != 1) {
if (winner == 2)
cnt += max(0LL, min(a, b) - max(x, y) + 1);
else
cnt += max(0LL, min(a, b) - max(x, y));
winner = 1;
x = a;
y = b;
} else if (a > b && winner == 1) {
cnt += max(0LL, min(a, b) - max(x, y) + 1);
x = a;
y = b;
} else if (b > a && winner != 2) {
if (winner == 0)
cnt += max(0LL, min(a, b) - max(x, y));
else
cnt += max(0LL, min(a, b) - max(x, y) + 1);
winner = 2;
x = a;
y = b;
} else if (b > a && winner == 2) {
cnt += max(0LL, min(a, b) - max(x, y) + 1);
x = a;
y = b;
} else if (a == b && winner != 0) {
cnt += max(0LL, min(a, b) - max(x, y) + 1);
winner = 0;
x = a;
y = b;
} else if (a == b && winner == 0) {
cnt += max(0LL, min(a, b) - max(x, y));
x = a;
y = b;
}
}
cout << cnt;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d", &n);
int a[n], b[n];
vector<bool> vis(2000010);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0, now = 1; i < n; i++) {
while (vis[now]) now++;
b[i] = now;
for (int j = 0; j < n; j++)
for (int k = j; k < n; k++) vis[now + a[k] - a[j]] = true;
}
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d ", b[i]);
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, q;
void updateTree(vector<long long>& tree, long long i, long long val) {
while (i <= n) {
tree[i] += val;
i += (i & (-i));
}
}
long long query(vector<long long>& tree, long long i) {
long long ans = 0;
while (i > 0) {
ans += tree[i];
i -= (i & (-i));
}
return ans;
}
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long card = n / k;
if (card >= m) {
cout << m << endl;
} else {
long long ans = card;
long long rest = (m - card) / (k - 1);
if ((m - card) % (k - 1) > 0) {
rest += 1;
}
cout << ans - rest << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
for (long long i = 1; i < t + 1; i++) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a = n / 7;
int m = n % 7;
int mx = 0, mn = 0;
if (n >= 7) {
mn = a * 2;
mx = mn;
if (m == 1) {
mx += 1;
} else if (m != 0) {
mx += 2;
}
if (m == 6) mn++;
} else {
mn = 0;
mx = mn;
if (n == 1) {
mx++;
} else if (n >= 2) {
mx += 2;
}
if (n == 6) mn++;
}
cout << mn << " " << mx << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
char a[2] = {'C', '.'};
int ans = n & 1 ? (n + 1) / 2 * n - n / 2 : n / 2 * n;
if (n == 1) ans = 1;
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = i % 2; j < n + i % 2; j++) {
cout << a[j % 2];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> st;
set<int>::iterator it;
int n, m, q, x, a[200100];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < q; i++) {
scanf("%d", &x);
if (x == 1) {
scanf("%d", &x);
st.insert(a[x]);
if (st.size() > m) st.erase(st.begin());
} else {
scanf("%d", &x);
it = st.find(a[x]);
int dist = distance(it, st.end());
if (dist == 0 || dist > m)
printf("NO\n");
else
printf("YES\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5;
const long long INF = 1e15;
const long long MOD = 1000000007;
deque<pair<int, int>> d;
int f[N];
int a[8] = {36000, 3600, 0, 600, 60, 0, 10, 1};
vector<int> ans;
int main() {
ios::sync_with_stdio(false);
ifstream inf("input.txt");
int n, m, t;
cin >> n >> m >> t;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
int u = 0;
for (int i1 = 0; i1 < 8; i1++) u += (s[i1] - 48) * a[i1];
f[u]++;
}
int ans1 = 0, ok = 0;
for (int i = 0; i < 86400; i++) {
while (!d.empty() && i - d[0].first == t) d.pop_front();
while (f[i]) {
if (d.size() == m) {
int r = d.back().second;
ans.push_back(r);
d.pop_back();
d.push_back(make_pair(i, r));
} else {
ans1++;
ans.push_back(ans1);
d.push_back(make_pair(i, ans1));
if (d.size() == m) ok = 1;
}
f[i]--;
}
}
if (!ok)
cout << "No solution";
else {
cout << ans1 << endl;
for (int i = 0; i < n; i++) cout << ans[i] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, a[100001], b[100001], i, ans = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i < n; i++) {
b[i] = ((a[i]) + (a[i + 1]));
}
b[n] = a[n];
for (i = 1; i <= n; i++) cout << b[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int monster[100010];
int star[2010];
int dp[100010];
int sdp[100010];
int pre[100010];
int main() {
int fix, index, i, j, n, m;
cin >> n >> m;
memset(dp, 0, sizeof(dp));
memset(sdp, 0, sizeof(sdp));
monster[0] = -(1 << 29);
for (i = 1; i <= n; i++) {
cin >> monster[i];
}
for (i = 1; i <= m; i++) {
cin >> star[i];
}
sort(monster + 1, monster + n + 1);
sort(star + 1, star + m + 1);
for (i = 1; i <= n; i++) {
if (monster[i] == monster[i - 1] + 1) {
pre[i] = pre[i - 1];
} else {
pre[i] = i;
}
}
for (i = 1, index = 0; i <= n; i++) {
dp[i] = max(dp[i], dp[i - 1]);
sdp[i] = max(sdp[i - 1], dp[pre[i] - 1]);
while (index < m && star[index + 1] <= monster[i]) {
index++;
}
for (j = index; j && monster[i] - star[j] < i; j--) {
int cost = monster[i] - star[j];
dp[i] = max(dp[i], dp[pre[i - cost] - 1] + (index - j + 1));
sdp[i] = max(sdp[i], dp[pre[i - cost] - 1] + (index - j + 1));
}
for (j = index + 1; j <= m && star[j] - monster[i] <= n - i; j++) {
int cost = star[j] - monster[i];
dp[i + cost] = max(dp[i + cost], sdp[i] + (j - index));
}
}
cout << dp[n] << endl;
}
| 10 |
#include <bits/stdc++.h>
int main() {
char A[100], B[100];
scanf("%s %s", A, B);
int i, d, a, b;
for (i = 0; i < strlen(A); i++) {
a = A[i] > 96 ? A[i] % 96 : A[i] % 64;
b = B[i] > 96 ? B[i] % 96 : B[i] % 64;
d = a - b;
if (d == 0 || d == 32 || d == -32)
continue;
else {
if (d > 0)
printf("1");
else
printf("-1");
exit(0);
}
}
printf("0");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300000 + 20;
vector<int> adj[MAX_N];
int deg[MAX_N];
queue<int> Q;
int mark[MAX_N];
int root[MAX_N];
int par[MAX_N];
int d[MAX_N][3];
int jun;
int n, m, q;
void work(int v, int com) {
mark[v] = com;
if (deg[v] == 1) Q.push(v);
for (int i(0); i < int(adj[v].size()); ++i) {
int u = adj[v][i];
if (mark[u]) continue;
work(u, com);
}
}
void bfsCent() {
int rooT = 0;
while (!Q.empty()) {
int v = Q.front();
Q.pop();
rooT = v;
for (int i(0); i < int(adj[v].size()); ++i) {
int u = adj[v][i];
--deg[u];
if (deg[u] == 1) Q.push(u);
}
}
root[mark[rooT]] = rooT;
}
int dfs(int v, int pari = -1) {
par[v] = root[mark[v]];
for (int i(0); i < int(adj[v].size()); ++i) {
int u = adj[v][i];
if (u == pari) continue;
int res = dfs(u, v);
d[v][2] = res + 1;
sort(d[v], d[v] + 3, greater<int>());
}
return d[v][0];
}
void solve(int ver, int com) {
if (deg[ver] == 0) {
par[ver] = ver;
mark[ver] = com;
root[mark[ver]] = ver;
return;
}
work(ver, com);
bfsCent();
dfs(root[com]);
}
int find(int v) { return par[v] = par[v] == v ? v : find(par[v]); }
void merge(int v, int u) {
v = find(v), u = find(u);
if (v == u) return;
if (max(d[v][0] + 1, d[u][0]) < max(d[u][0] + 1, d[v][0])) swap(v, u);
par[u] = v;
d[v][2] = d[u][0] + 1;
sort(d[v], d[v] + 3, greater<int>());
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i(0); i < int(m); ++i) {
int v, u;
cin >> v >> u;
--v, u--;
adj[v].push_back(u);
adj[u].push_back(v);
}
for (int i(0); i < int(n); ++i) deg[i] = adj[i].size();
for (int i(0); i < int(n); ++i)
if (!mark[i]) solve(i, ++jun);
for (int i(0); i < int(q); ++i) {
int t;
cin >> t;
if (t == 1) {
int ver;
cin >> ver;
ver = find(ver - 1);
cout << d[ver][0] + d[ver][1] << '\n';
} else {
int v, u;
cin >> v >> u;
--v, u--;
merge(v, u);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300007;
vector<pair<int, int>> graph[maxn];
const long long int INF = 1ll << 59;
void add_edge(int u, int v, int c) {
graph[v].push_back({u, c});
graph[u].push_back({v, c});
}
long long int D[maxn];
int P[maxn];
void dijsktra(int sr) {
for (int i = 0; i < maxn; i++) D[i] = INF;
D[sr] = 0;
P[sr] = sr;
set<pair<long long int, long long int>> s;
s.insert({D[sr], sr});
while (!s.empty()) {
int u = s.begin()->second;
s.erase(s.begin());
for (auto pr : graph[u]) {
int v = pr.first;
int c = pr.second;
if (D[v] < D[u] + c) continue;
s.erase({D[v], v});
D[v] = D[u] + c;
P[v] = u;
s.insert({D[v], v});
}
}
}
map<pair<int, int>, int> mp;
int main() {
int n, m, u, v, c, first;
cin >> n >> m;
int key = 0;
vector<int> cost(m);
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
if (!mp.count({u, v})) {
mp[{u, v}] = key;
mp[{v, u}] = key++;
}
cost[i] = c;
add_edge(u, v, c);
}
cin >> first;
dijsktra(first);
vector<int> ans;
long long int cont = 0;
for (int i = 1; i <= n; i++) {
if (P[i] == i || P[i] == 0) continue;
ans.push_back(mp[{i, P[i]}] + 1);
cont += cost[mp[{i, P[i]}]];
}
cout << cont << endl;
for (auto c : ans) cout << c << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, K;
long long M[101000];
long long B[1010000], E[1010000], S, res = 1e18;
struct point {
int t, a, b, c;
bool operator<(const point &p) const { return t < p.t; }
} w[101000];
int main() {
int i;
scanf("%d%d%d", &n, &m, &K);
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &w[i].t, &w[i].a, &w[i].b, &w[i].c);
}
sort(w + 1, w + m + 1);
for (i = 1; i <= n; i++) M[i] = 1e12;
B[0] = S = (long long)1e12 * n;
int pv = 1;
for (i = 1; i <= 1000000; i++) {
while (w[pv].t <= i && pv <= m) {
if (!w[pv].b) {
if (M[w[pv].a] > w[pv].c) {
S -= M[w[pv].a] - w[pv].c;
M[w[pv].a] = w[pv].c;
}
}
pv++;
}
B[i] = S;
}
for (i = 1; i <= n; i++) M[i] = 1e12;
E[1000001] = S = (long long)1e12 * n;
pv = m;
for (i = 1000000; i >= 1; i--) {
while (w[pv].t >= i && pv >= 1) {
if (!w[pv].a) {
if (M[w[pv].b] > w[pv].c) {
S -= M[w[pv].b] - w[pv].c;
M[w[pv].b] = w[pv].c;
}
}
pv--;
}
E[i] = S;
}
for (i = 0; i <= 1000000 - K; i++) {
res = min(res, B[i] + E[i + K + 1]);
}
printf("%lld\n", res > 1e12 ? -1 : res);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, dfsn[N], kdfs, ans, dist[N];
long long a[N];
vector<int> pos[N];
vector<int> G[N];
bool vis[N];
void dfs(int v, int cur, int par = -1) {
if (vis[v]) {
ans = min(ans, cur - dist[v]);
return;
}
if (cur >= ans) return;
dist[v] = cur, vis[v] = true;
for (int i = 0; i < (int)(G[v].size()); ++i) {
int u = G[v][i];
if (u != par) dfs(u, cur + 1, v);
}
vis[v] = false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%lld", &a[i]);
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(63); ++j)
if (a[i] >> j & 1) pos[j].push_back(i);
}
for (int j = 0; j < (int)(63); ++j)
if (pos[j].size() > 2) {
printf("3\n");
return 0;
}
for (int j = 0; j < (int)(63); ++j)
if (pos[j].size() == 2) {
G[pos[j][0]].push_back(pos[j][1]);
G[pos[j][1]].push_back(pos[j][0]);
}
ans = 1e9 + 7;
for (int i = 0; i < (int)(n); ++i)
if (!vis[i]) dfs(i, 0);
if (ans == 1e9 + 7)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100, mod = 998244353;
inline void Add(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
inline int ksm(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
int fac[maxn], invfac[maxn];
inline int C(int n, int m) {
return 1ll * fac[n] * invfac[m] % mod * invfac[n - m] % mod;
}
int n, k, a[maxn], cnt, ans = 0;
int main() {
for (int i = fac[0] = 1; i < maxn; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
invfac[maxn - 1] = ksm(fac[maxn - 1], mod - 2);
for (int i = maxn - 2; i >= 0; i--)
invfac[i] = 1ll * invfac[i + 1] * (i + 1) % mod;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
a[n + 1] = a[1];
for (int i = 1; i <= n; i++) cnt += a[i] != a[i + 1];
for (int i = 0; i < cnt; i++) {
if ((cnt - i) & 1)
Add(ans,
1ll * ksm(k - 2, i) * C(cnt, i) % mod * ksm(2, cnt - i - 1) % mod);
else
Add(ans, 1ll * ksm(k - 2, i) * C(cnt, i) % mod *
((ksm(2, cnt - i) - C(cnt - i, (cnt - i) >> 1) + mod) % mod *
499122177ll % mod) %
mod);
}
ans = 1ll * ans * ksm(k, n - cnt) % mod;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
int n;
vector<int> sobra;
int main() {
scanf("%d", &n);
int n0 = 0, n1 = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x % 2 == 0) {
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n0 += y;
}
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n1 += y;
}
} else {
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n0 += y;
}
int y;
scanf("%d", &y);
sobra.push_back(y);
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n1 += y;
}
}
}
bool j1 = true;
sort(sobra.begin(), sobra.end());
while (sobra.size() > 0) {
if (j1) {
n0 += sobra.back();
} else {
n1 += sobra.back();
}
j1 = !j1;
sobra.pop_back();
}
cout << n0 << " " << n1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
long long l = 0;
for (long long i = 0; i < n; ++i) {
if (a[i] == a[0])
++l;
else
break;
}
if (l <= n / 2)
cout << "Alice";
else
cout << "Bob";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int to[1010];
int from[1010];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, s;
cin >> n >> s;
s--;
for (int i = 0; i < n; i++) {
cin >> to[i];
}
for (int i = 0; i < n; i++) {
cin >> from[i];
}
if (to[0] == 0) {
cout << "NO";
return 0;
}
if (to[s] == 1) {
cout << "YES";
return 0;
}
if (from[s] == 0) {
cout << "NO";
return 0;
}
for (int i = s + 1; i < n; i++) {
if (from[i] == 1 && to[i] == 1) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <algorithm>
#include <numeric>
#include <iostream>
#include <cstring>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
inline void transit(vector<bool> &cur, vector<bool> &out, int n)
{
out[0] = cur[0] | cur[1];
out[n-1] = cur[n-1] | cur[n-2];
for(int i = 1; i < n-1; i++)
out[i] = cur[i] | (cur[i-1] ^ cur[i+1]);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int T; cin >> T;
while(T--)
{
int n, m; cin >> n >> m;
vector<bool> state(n);
vector<bool> nstt(n);
for(int i = 0; i < n; i++)
{
char ch; cin >> ch;
state[i] = ch-'0';
}
if(m > n)
m = n;
for(int i = 0; i < m; i++)
{
transit(state, nstt, n);
state.swap(nstt);
}
for(int i = 0; i < n; i++)
cout << state[i];
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
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 * b / gcd(a, b); }
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long r, b, k;
scanf("%lld%lld%lld", &r, &b, &k);
long long lc = lcm(r, b);
if (r < b) {
swap(r, b);
}
long long ans = (lc / b - 1 + lc / r - 1) / (lc / r);
if (k <= ans) {
printf("rebel\n");
} else {
printf("obey\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], b, c = 1000000000, n, l, k, i, j;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= k; i++) {
for (j = i; j <= n; j = j + k) {
b = b + a[j];
}
if (b < c) {
c = b;
l = i;
}
b = 0;
}
cout << l;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool checkprime(long long k) {
if (k == 2) return 1;
if (k % 2 == 0) return 0;
for (long long i = 3; i <= sqrt(k); i += 2) {
if (k % i == 0) return 0;
}
return 1;
}
int main() {
long long n;
cin >> n;
if (checkprime(n)) {
cout << 1 << endl << n << endl;
return 0;
}
if (n % 2 == 1) {
cout << 3 << endl << 3;
n -= 3;
} else {
cout << 2 << endl;
}
for (int i = 2;; i++) {
if (checkprime(i) && checkprime(n - i)) {
cout << " " << i << " " << n - i;
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long k;
cin >> k;
string s;
cin >> s;
stack<long long> st;
long long index = 0;
map<long long, long long> mp;
for (long long i = 0; i < s.length(); i++) {
if (s[i] == '(') {
if (st.empty()) {
st.push(0);
} else {
if (st.top() == 0)
st.push(1);
else
st.push(0);
}
mp[i] = st.top();
} else {
long long u = st.top();
st.pop();
mp[i] = u;
}
}
for (long long i = 0; i < s.length(); i++) cout << mp[i];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
long long n, m, a[maxn], b[maxn], ans, sum;
priority_queue<long long> T;
multiset<long long> H;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
long long now = 0, num = 0, bf;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
now += x;
if (num) {
long long tt = T.top();
long long mmin = *H.begin();
if (tt > mmin) {
now -= tt;
now += mmin;
H.erase(H.begin());
H.insert(tt);
T.pop();
T.push(mmin);
while (1) {
mmin = *H.begin();
if (now + mmin <= m) {
H.erase(H.begin());
now += mmin;
T.push(mmin);
num--;
} else
break;
}
}
}
if (now <= m)
cout << num << " ";
else {
while (1) {
num++;
long long ttt = T.top();
now -= ttt;
H.insert(ttt);
T.pop();
if (now <= m) break;
}
cout << num << " ";
}
T.push(x);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int offset = 1 << 17;
const long long INF = 1e18;
struct node {
int posneg;
pair<long long, long long> posX, posY, negX, negY, mindiff;
};
const node DEF = {0, {INF, INF}, {INF, INF},
{-INF, INF}, {-INF, INF}, {-INF, INF}};
int N, Q;
long long a[MAXN];
node t[2 * offset];
long long ans;
void load() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%lld", a + i);
}
inline void mx(long long &x, long long y) {
if (x < y) x = y;
}
node merge(node lft, node rig) {
node res;
res.posneg = lft.posneg + rig.posneg;
res.posX = lft.posX.second < rig.posX.second ? lft.posX : rig.posX;
res.posY = lft.posY.second < rig.posY.second ? lft.posY : rig.posY;
res.negX = lft.negX.first > rig.negX.first ? lft.negX : rig.negX;
res.negY = lft.negY.first > rig.negY.first ? lft.negY : rig.negY;
res.mindiff = lft.mindiff.second - lft.mindiff.first <
rig.mindiff.second - rig.mindiff.first
? lft.mindiff
: rig.mindiff;
return res;
}
node get(long long x, long long y) {
node res = DEF;
res.posneg = x >= 0 && y <= 0;
if (x >= 0) res.posX = {x, y};
if (y >= 0) res.posY = {x, y};
if (x <= 0) res.negX = {x, y};
if (y <= 0) res.negY = {x, y};
if (x <= 0 && y >= 0) res.mindiff = {x, y};
return res;
}
void change(int x) {
t[x + offset] = get(a[x], a[x + 1]);
for (x = (x + offset) / 2; x; x /= 2) t[x] = merge(t[2 * x], t[2 * x + 1]);
}
node query(int x, int lo, int hi, int from, int to) {
if (lo >= to || hi <= from) return DEF;
if (lo >= from && hi <= to) return t[x];
int mid = (lo + hi) / 2;
return merge(query(2 * x, lo, mid, from, to),
query(2 * x + 1, mid, hi, from, to));
}
void update(int from, int to, int x) {
ans -= abs(a[from - 1]) + abs(a[to]);
a[from - 1] += x;
a[to] -= x;
ans += abs(a[from - 1]) + abs(a[to]);
if (from > 1) change(from - 2);
change(from - 1);
change(to - 1);
change(to);
}
long long get(pair<long long, long long> p, int x) {
return abs(p.first + x) + abs(p.second - x) - abs(p.first) - abs(p.second);
}
long long query(int from, int to, int x) {
node tmp = query(1, 0, offset, from - 1, to);
if (tmp.posneg) return 2 * x;
long long res = -2 * x;
if (tmp.posX != DEF.posX) mx(res, get(tmp.posX, x));
if (tmp.posY != DEF.posY) mx(res, get(tmp.posY, x));
if (tmp.negX != DEF.negX) mx(res, get(tmp.negX, x));
if (tmp.negY != DEF.negY) mx(res, get(tmp.negY, x));
if (tmp.mindiff != DEF.mindiff) mx(res, get(tmp.mindiff, x));
return res;
}
void solve() {
for (int i = N - 1; i; i--) {
a[i] -= a[i - 1];
ans += abs(a[i]);
}
for (int i = 0; i < 2 * offset; i++) t[i] = DEF;
for (int i = 1; i < N - 1; i++) t[i + offset] = get(a[i], a[i + 1]);
for (int i = offset - 1; i >= 0; i--) t[i] = merge(t[2 * i], t[2 * i + 1]);
scanf("%d", &Q);
while (Q--) {
int t, l, r, x;
scanf("%d%d%d%d", &t, &l, &r, &x);
if (t == 1)
printf("%lld\n", ans + query(l, r, x));
else
update(l, r, x);
}
}
int main() {
load();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int K = 30;
const int N = 1e6 + 10;
int n, cnt[5], second;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
cnt[x]++;
second += x;
}
if (second <= 2 || second == 5) return cout << -1, 0;
int ans = 0;
ans += min(cnt[1], cnt[2]);
if (cnt[1] <= cnt[2]) {
cnt[2] -= cnt[1];
cnt[3] += cnt[1];
cnt[1] = 0;
cnt[3] += (cnt[2] / 3) * 2;
ans += (cnt[2] / 3) * 2;
cnt[2] %= 3;
if (cnt[2] == 2)
ans += 2;
else if (cnt[2] == 1) {
if (cnt[4] >= 1)
ans++;
else
ans += 2;
}
} else {
cnt[1] -= cnt[2];
cnt[3] += cnt[2];
cnt[2] = 0;
ans += (cnt[1] / 3) * 2;
cnt[3] += cnt[1] / 3;
cnt[1] %= 3;
if (cnt[3] >= cnt[1])
ans += cnt[1];
else
ans += 2;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long usd[300000], d[300000];
double ans;
vector<long> g[300000];
long a, b, n;
void dfs(long v) {
usd[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
long q = g[v][i];
if (usd[q]) continue;
d[q] = d[v] + 1;
dfs(q);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= n; i++) ans += 1.0 / (d[i] + 1);
cout.precision(8);
cout << fixed << ans << endl;
cin.get();
cin.get();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
void read(int& val) {
int x = 0;
int bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int mod = 1e9 + 7;
const int maxn = 1e6 + 11;
int n, m, k;
int lef[110][110], rig[110][110], dp[110][110];
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) {
int k, l, r;
read(k);
for (int j = 1; j <= k; j++) {
read(l);
read(r);
for (int zz = l; zz <= r; zz++) {
lef[i][zz] = l;
rig[i][zz] = r;
}
}
}
for (int l = m; l >= 1; l--) {
for (int r = l; r <= m; r++) {
for (int k = l; k <= r; k++) {
int cnt = 0;
for (int z = 1; z <= n; z++) {
if (lef[z][k] >= l && rig[z][k] <= r) cnt++;
}
dp[l][r] = max(dp[l][r], dp[l][k - 1] + cnt * cnt + dp[k + 1][r]);
}
}
}
printf("%d\n", dp[1][m]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n;
char a[1009] =
"012345678910111213141516171819202122232425262728293031323334353637383940"
"414243444546474849505152535455565758596061626364656667686970717273747576"
"777879808182838485868788899091929394959697989910010110210310410510610710"
"810911011111211311411511611711811912012112212312412512612712812913013113"
"213313413513613713813914014114214314414514614714814915015115215315415515"
"615715815916016116216316416516616716816917017117217317417517617717817918"
"018118218318418518618718818919019119219319419519619719819920020120220320"
"420520620720820921021121221321421521621721821922022122222322422522622722"
"822923023123223323423523623723823924024124224324424524624724824925025125"
"225325425525625725825926026126226326426526626726826927027127227327427527"
"627727827928028128228328428528628728828929029129229329429529629729829930"
"030130230330430530630730830931031131231331431531631731831932032132232332"
"432532632732832933033133233333433533633733833934034134234334434534634734"
"8349350351352353354355356357358359360361362363364365366367368369370371";
while (scanf("%d", &n) != EOF) {
printf("%c\n", a[n]);
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
using namespace std;
double __begin;
template <typename T1, typename T2, typename T3>
struct triple {
T1 a;
T2 b;
T3 c;
triple(){};
triple(T1 _a, T2 _b, T3 _c) : a(_a), b(_b), c(_c) {}
};
template <typename T1, typename T2, typename T3>
bool operator<(const triple<T1, T2, T3> &t1, const triple<T1, T2, T3> &t2) {
if (t1.a != t2.a)
return t1.a < t2.a;
else
return t1.b < t2.b;
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
inline int sign(int x) { return (x >> 31) | (-x >> 31); }
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::set<T> &v) {
bool first = true;
os << "[";
for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::map<T1, T2> &v) {
bool first = true;
os << "[";
for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T, typename T2>
void printarray(T a[], T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++) cout << a[i] << " ";
cout << endl;
}
inline long long binpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
inline long long gcd(long long a, long long b) {
long long t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline long long lcm(int a, int b) { return a / gcd(a, b) * (long long)b; }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long gcd(long long a, long long b, long long c) {
return gcd(gcd(a, b), c);
}
inline int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
inline long long lcm(long long a, long long b, long long c) {
return lcm(lcm(a, b), c);
}
inline long long lcm(int a, int b, int c) {
return lcm(lcm(a, b), (long long)c);
}
inline long long max(long long a, long long b) { return (a > b) ? a : b; }
inline int max(int a, int b) { return (a > b) ? a : b; }
inline double max(double a, double b) { return (a > b) ? a : b; }
inline long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
inline double max(double a, double b, double c) { return max(a, max(b, c)); }
inline long long min(long long a, long long b) { return (a < b) ? a : b; }
inline int min(int a, int b) { return (a < b) ? a : b; }
inline double min(double a, double b) { return (a < b) ? a : b; }
inline long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
inline double min(double a, double b, double c) { return min(a, min(b, c)); }
inline void getar(int *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", a + ii);
}
}
inline void getar(long long *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64", a + ii);
}
}
int w[100010];
int n, m;
long long sum(int t) {
long long s = t * 1ll * (t - 1) / 2 + 1;
if (t == 1)
s = 1;
else if (t == 2)
s = 2;
else if (!(t & 1)) {
s += (t - 1) / 2;
}
return s;
}
bool check(int t) {
long long s = sum(t);
if (s <= n) {
return true;
} else {
return false;
}
}
int main() {
for (int i = 1; i < 15; ++i) {
}
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
w[i] = y;
}
sort(w, w + m);
int l = 1;
int r = m;
while (l < r) {
int mid = (l + r + 1) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
reverse(w, w + m);
long long res = 0;
for (int i = 0; i < l; ++i) {
res += w[i];
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char buf[1000000], *p1 = buf, *p2 = buf;
inline char gc() {
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
return p1 == p2 ? EOF : *(p1++);
}
template <class T>
inline void read(T &n) {
n = 0;
register int ch = gc(), f;
while ((ch < '0' || ch > '9') && ch != '-') ch = gc();
f = (ch == '-' ? ch = gc(), -1 : 1);
while (ch >= '0' && ch <= '9') n = n * 10 + (ch ^ 48), ch = gc();
n *= f;
}
int const mod = 998244853, MAXN = 4e6 + 5;
long long frac[MAXN], invfrac[MAXN], inv[MAXN];
void Init(int Max) {
frac[0] = frac[1] = invfrac[0] = invfrac[1] = inv[1] = 1;
for (register int i = 2; i <= Max; ++i) {
frac[i] = frac[i - 1] * i % mod;
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
invfrac[i] = invfrac[i - 1] * inv[i] % mod;
}
}
inline int C(int n, int m) {
return frac[n] * invfrac[m] % mod * invfrac[n - m] % mod;
}
inline int Solve(int x, int y) { return C(x, (x + y) / 2); }
int main() {
int n, m;
scanf("%d %d", &n, &m);
Init(2 * (n + m));
int ans = 0, last = 0, en = max(1, n - m);
for (register int i = n; i >= en; --i) {
int sum = Solve(n + m, 2 * i - (n - m));
sum -= last;
sum += sum < 0 ? mod : 0;
ans += 1ll * sum * i % mod;
ans -= ans >= mod ? mod : 0;
last += sum;
last -= last >= mod ? mod : 0;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline void chmin(A &a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A &a, B b) {
if (a < b) a = b;
}
long long N, K;
long long lis[222222];
vector<long long> G[222222];
long long par[20][222222], dep[222222], sz[222222];
void dfs(long long v, long long p, long long d) {
par[0][v] = p;
dep[v] = d;
for (auto u : G[v]) {
if (p == u) continue;
dfs(u, v, d + 1);
sz[v] += sz[u];
}
}
long long lca(long long u, long long v) {
if (dep[u] < dep[v]) swap(u, v);
for (long long i = 0; i < (20); i++)
if ((dep[u] - dep[v]) >> i & 1) u = par[i][u];
if (u == v) return u;
for (long long i = 19; i >= 0; i--)
if (par[i][u] != par[i][v]) u = par[i][u], v = par[i][v];
return par[0][u];
}
pair<long long, long long> findC(long long v, long long p) {
pair<long long, long long> res(1001001001, -1);
long long m = 0;
for (auto u : G[v]) {
if (u == p) continue;
res = min(res, findC(u, v));
m = max(m, sz[u]);
}
m = max(m, 2 * K - sz[v]);
res = min(res, pair<long long, long long>(m, v));
return res;
}
signed main() {
scanf("%lld%lld", &N, &K);
for (long long i = 0; i < (2 * K); i++)
scanf("%lld", &lis[i]), lis[i]--, sz[lis[i]]++;
for (long long i = 0; i < (N - 1); i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, -1, 0);
for (long long i = 0; i < (19); i++) {
for (long long j = 0; j < (N); j++) {
if (par[i][j] == -1)
par[i + 1][j] = -1;
else
par[i + 1][j] = par[i][par[i][j]];
}
}
long long c = findC(0, -1).second;
long long ans = 0;
for (long long i = 0; i < (2 * K); i++) {
long long v = lis[i];
long long p = lca(v, c);
ans += dep[v] + dep[c] - 2 * dep[p];
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e9 + 7;
const long long MAXL = 1e18;
const int N = 2 * 1e5 + 20;
const double eps = 1e-13;
struct Point {
int x, y;
};
int n, k, q, l, r;
vector<bool> used;
vector<int> dp;
vector<vector<int> > v;
vector<Point> dot;
bool try12(Point a, Point b) {
int A = a.y - b.y, B = b.x - a.x;
int C = -A * a.x - B * a.y;
vector<Point> next;
for (int i = 0; i < n; ++i) {
if ((dot[i].x == a.x) || (dot[i].x == b.x)) continue;
int x = dot[i].x, y = dot[i].y;
if (A * x + B * y + C) next.push_back(dot[i]);
}
if (next.size() == 0) return false;
if (next.size() == 1) return true;
a = next[0];
b = next[1];
int AA = a.y - b.y, BB = b.x - a.x;
int CC = -AA * a.x - BB * a.y;
if (AA * B != A * BB) return false;
int add = 0;
for (int i = 2; i < (int)next.size(); ++i) {
int x = next[i].x, y = next[i].y;
if (AA * x + BB * y + CC) add++;
}
if (add) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
Point a;
cin >> a.y;
a.x = i;
dot.push_back(a);
}
if (try12(dot[0], dot[1]) || try12(dot[0], dot[2]) || try12(dot[1], dot[2]))
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1001001;
ll Solve(vector<ll>& a) {
ll ans = 1e18;
const int n = a.size();
ll cur = 0;
ll past = 0;
ll pre = 0;
for (int i = 1; i < n; i++) {
cur += i * a[i];
past += a[i];
}
for (int i = 0; i < n; i++) {
ans = min(ans, cur);
pre += a[i];
if (i + 1 < n) {
cur -= past;
cur += pre;
past -= a[i + 1];
}
}
return ans;
}
ll Solve(vector<ll> arr, int n, ll val) {
ll cur = 0;
int pre = 0;
vector<ll> kek;
ll ans = 0;
for (int i = 0; i < n; i++) {
arr[i] %= val;
cur += arr[i];
if (cur >= val) {
kek.push_back(arr[i] - (cur % val));
ans += Solve(kek);
kek = {cur % val};
} else {
kek.push_back(arr[i]);
}
cur %= val;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
ll tot = 0;
vector<ll> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
tot += arr[i];
}
vector<ll> del;
for (ll i = 2; i * i <= tot; i++) {
if (tot % i == 0) {
del.push_back(i);
while (tot % i == 0) {
tot /= i;
}
}
}
if (tot > 1) {
del.push_back(tot);
}
ll ans = 1e18;
for (ll val : del) {
ans = min(ans, Solve(arr, n, val));
}
cout << (ans == 1e18 ? -1 : ans) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
cout << (k + n - 1) / n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int N = 100005;
int xx[N], yy[N], yes[N], n, m, cnt, now, flag, x, y, X, Y, K, L = 11;
vector<int> a[N];
int calc(int x, int y) {
int res = 0;
res += a[x - 1][y - 1] & a[x - 1][y];
res += a[x - 1][y - 1] & a[x][y - 1];
res += a[x - 1][y] & a[x][y - 1];
res += a[x - 1][y] & a[x - 1][y + 1];
return res;
}
int chk(int s) {
static int q[N];
int l = 0, r = 0;
for (int i = (1); i <= (cnt); i++) {
a[xx[i]][yy[i]] = 0;
yes[i] = 0;
if (!(s >> (i - 1) & 1)) continue;
if (xx[i] == x || xx[i] == x + 1 && yy[i] <= y) yes[i] = 1, q[r++] = i;
}
while (l < r) {
int u = q[l++];
for (int v = (1); v <= (cnt); v++)
if (s >> (v - 1) & 1) {
if (!yes[v] && abs(xx[u] - xx[v]) + abs(yy[u] - yy[v]) == 1) {
yes[v] = 1, q[r++] = v;
}
}
}
for (int i = (1); i <= (cnt); i++)
if ((s >> (i - 1) & 1) && !yes[i]) return 0;
int sum = now;
for (int i = (1); i <= (cnt); i++)
if (s >> (i - 1) & 1) sum += calc(xx[i], yy[i]), a[xx[i]][yy[i]] = 1;
return sum == K;
}
void rmain() {
read(n), read(m), read(K);
if (n < m)
swap(n, m), flag = 1;
else
flag = 0;
for (int i = (0); i <= (n + 1); i++) a[i].clear(), a[i].resize(m + 2);
now = 0, x = n, y = m;
int rem = n * m;
for (int i = (1); i <= (n); i++) {
int owo = 0;
for (int j = (1); j <= (m); j++) {
int nxt = calc(i, j);
rem--;
if (now + nxt <= K && rem >= L)
now += nxt, a[i][j] = 1;
else {
x = i, y = j - 1;
if (y == 0) y = m, x--;
owo = 1;
break;
}
}
if (owo) break;
}
cnt = 0, X = x, Y = y;
int Flag = (x < n);
while (cnt + flag < L) {
Y++;
if (Y > m) X++, Y = 1;
if (X > n) break;
xx[++cnt] = X, yy[cnt] = Y;
if (X == x + 1 && Y == y) Flag = 0;
}
if (Flag) xx[++cnt] = x + 1, yy[cnt] = y;
int found = 0;
for (int s = (x == 0 ? 1 : 0); s < (1 << cnt); s++)
if (chk(s)) {
found = 1;
break;
}
if (!found) {
puts("-1");
return;
}
if (flag) swap(n, m);
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (m); j++)
printf("%c", (flag ? a[j][i] : a[i][j]) ? '*' : '.');
puts("");
}
}
int main() {
int T;
read(T);
while (T--) rmain(), puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e9;
int n, m, cache[1 << 22], bit[22];
int DP(int s) {
if (s == (1 << n) - 1) return 0;
int &ret = cache[s];
if (ret != -1) return ret;
ret = n + 1;
for (int i = 0; i < n; i++)
if (s & (1 << i)) {
int nxt = s | bit[i];
if (nxt == s) continue;
ret = min(ret, DP(nxt) + 1);
}
return ret;
}
void trace(int s) {
if (s == (1 << n) - 1) return;
int &ret = cache[s];
for (int i = 0; i < n; i++)
if (s & (1 << i)) {
int nxt = s | bit[i];
if (nxt == s) continue;
if (DP(nxt) == ret - 1) {
printf("%d ", i + 1);
trace(nxt);
return;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
bit[a] |= 1 << b;
bit[b] |= 1 << a;
}
for (int i = 0; i < n; i++) bit[i] |= 1 << i;
int flag = 1;
for (int i = 0; i < n; i++) {
if (bit[i] != (1 << n) - 1) flag = false;
}
if (flag) {
puts("0");
return 0;
}
memset(cache, -1, sizeof(cache));
int mx = n + 1, id = 0;
for (int i = 0; i < n; i++) {
if (mx > DP(bit[i])) {
mx = DP(bit[i]);
id = i;
}
}
printf("%d\n", mx + 1);
printf("%d ", id + 1);
trace(bit[id]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, cnt = 0;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 1; i < n; i++) {
if (v[i] < k - v[i - 1]) {
int a = v[i];
v[i] = k - v[i - 1];
cnt += v[i] - a;
}
}
cout << cnt << endl;
for (int i = 0; i < n; i++) cout << v[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[2000005];
int deg[2000005];
bool u[2000005];
int n, m, cnt;
long long ans;
void dfs(int v) {
u[v] = 1;
if (deg[v] & 1) {
++cnt;
}
for (int i = 0; i < adj[v].size(); i++) {
int to = adj[v][i];
if (u[to]) {
continue;
}
dfs(to);
}
}
void solve() {
scanf("%d %d", &n, &m);
for (int i = 1, l, r; i <= m; ++i) {
scanf("%d %d", &l, &r);
++deg[l], ++deg[r];
adj[l].push_back(r);
adj[r].push_back(l);
}
int p = 0;
for (int i = 1; i <= n; ++i) {
if (u[i]) {
continue;
}
if (i != 1 && adj[i].empty()) {
continue;
}
cnt = 0;
dfs(i);
if (cnt == 0) {
cnt = 2;
} else {
p = 100;
}
ans += cnt;
++p;
}
if (p == 1) {
ans = 0;
}
printf("%lld\n", ans / 2);
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
printf("2000\n");
for (int i = 1; i <= 1000; i++) printf("%d 2 %d 1\n", i, i);
for (int i = 1000; i >= 1; i--) printf("%d 2 %d 1\n", i, i);
return 0;
}
| 4 |
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
//using namespace __gnu_pbds;
#define rep(i,a,b) for(i=(a);i<=(b);i++)
#define ll long long
#define pll pair<ll, ll>
#define pii pair<int,int>
#define pb push_back
#define F first
#define S second
#define mod 1000000007
#define maxn 100005
#define inf 1e18
#define boost ios::sync_with_stdio(false);cin.tie(0)
#define fr freopen("source.txt","r",stdin),freopen("output.txt","w",stdout)
#define SET(a,b) memset(a,b,sizeof(a))
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define all(x) x.begin(), x.end()
#define ps(x,y) fixed<<setprecision(y)<<x
//template<typename T>
//using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template<class A, class B> ostream& operator << (ostream& out, const pair<A, B> &a) {
return out << "(" << a.F << ", " << a.S << ")";
}
template<class A> ostream& operator << (ostream& out, const vector<A> &a) {
out << "[";
for (auto it = a.begin(); it != a.end(); ++it) {
if (it != a.begin())
out << ", ";
out << *it;
}
return out << "]";
}
void solve(){
ll n,i,j,x,t,y;
cin>>n;
string s[n];
for(i=0;i<n;i++) cin>>s[i];
map<ll,ll>mp;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(s[i][j]!='.') mp[(i+j)%3]++;
}
}
y=min({mp[0],mp[1],mp[2]});
if(mp[0]==y) x=0;
else if(mp[1]==y) x=1;
else x=2;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(s[i][j]!='.'&&(i+j)%3==x) s[i][j]='O';
}
}
for(i=0;i<n;i++) cout<<s[i]<<"\n";
}
int main()
{
boost;
ll n,i,j,x,t,y;
cin>>t;
while(t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ta = 0, tb = 0, v[1000000], i, ia = 1, ib, a = 0, b = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> v[i];
}
ib = n;
while (ia <= ib) {
if (ta <= tb) {
++a;
ta += v[ia++];
} else {
++b;
tb += v[ib--];
}
}
cout << a << " " << b;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, M = 28;
int n, flag, ff, cnt;
int a[N], b[N], c[N];
int tg[M], cg[M], bo[M];
bool used[M], use[M];
char A[N], B[N], C[N];
int read() {
int ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) ret = ret * 10 + (c ^ 48), c = getchar();
return f ? ret : -ret;
}
void clear() {
flag = 1;
cnt = 0;
memset(used, 0, sizeof(used));
memset(use, 0, sizeof(use));
memset(tg, 0, sizeof(tg));
memset(bo, 0, sizeof(bo));
memset(cg, 0, sizeof(cg));
}
void output() {
puts("YES");
int j = 1;
for (int i = 1; i <= cnt; ++i) {
if (tg[i]) cg[i] = tg[i];
if (!cg[i]) {
while (used[j] || use[j]) ++j;
cg[i] = j;
use[j] = 1;
}
putchar(cg[i] + 'a' - 1);
}
puts("");
}
void checkup(int p) {
for (int i = p + 1; i < n; ++i) {
if (tg[c[i]]) {
if (tg[c[i]] > a[i]) return;
if (tg[c[i]] == a[i]) continue;
ff = 0;
break;
} else {
for (int j = a[i] + 1; j <= cnt; ++j)
if (!use[j]) {
tg[c[i]] = j;
use[j] = 1;
return;
}
if (!use[a[i]]) {
tg[c[i]] = a[i];
use[a[i]] = 1;
continue;
}
ff = 0;
break;
}
}
}
void checkdown(int p) {
for (int i = p + 1; i < n; ++i) {
if (tg[c[i]]) {
if (tg[c[i]] < b[i]) return;
if (tg[c[i]] == b[i]) continue;
ff = 0;
break;
} else {
for (int j = 1; j < b[i]; ++j)
if (!use[j]) {
tg[c[i]] = j;
use[j] = 1;
return;
}
if (!use[b[i]]) {
tg[c[i]] = b[i];
use[b[i]] = 1;
continue;
}
ff = 0;
break;
}
}
}
int main() {
int T = read();
while (T--) {
clear();
cnt = read();
scanf("%s%s%s", C, A, B);
n = strlen(C);
if (strcmp(A, B) > 0) {
puts("NO");
continue;
}
for (int i = 0; i < n; ++i) {
a[i] = A[i] - 'a' + 1, b[i] = B[i] - 'a' + 1, c[i] = C[i] - 'a' + 1;
}
int i;
for (i = 0; i < n; ++i) {
if (a[i] != b[i]) break;
if (cg[c[i]]) {
if (cg[c[i]] == a[i])
continue;
else {
flag = 0;
break;
}
} else {
if (used[a[i]]) {
flag = 0;
break;
}
cg[c[i]] = a[i], used[a[i]] = 1;
}
}
if (!flag) {
puts("NO");
continue;
}
if (i >= n) {
output();
continue;
}
if (cg[c[i]]) {
if (cg[c[i]] > a[i] && cg[c[i]] < b[i]) {
output();
continue;
}
if (cg[c[i]] < a[i] || cg[c[i]] > b[i]) {
puts("NO");
continue;
}
ff = 1;
memcpy(tg, cg, sizeof(cg));
memcpy(use, used, sizeof(used));
if (cg[c[i]] == a[i])
checkup(i);
else
checkdown(i);
if (ff) {
output();
continue;
}
} else {
for (int j = a[i] + 1; j < b[i]; ++j)
if (!used[j]) {
cg[c[i]] = j;
used[j] = 1;
break;
}
if (cg[c[i]] > a[i] && cg[c[i]] < b[i]) {
output();
continue;
}
if (!used[a[i]]) {
memcpy(tg, cg, sizeof(cg));
memcpy(use, used, sizeof(used));
ff = 1;
tg[c[i]] = a[i];
use[a[i]] = 1;
checkup(i);
if (ff) {
output();
continue;
}
}
if (!used[b[i]]) {
memcpy(tg, cg, sizeof(cg));
memcpy(use, used, sizeof(used));
ff = 1;
tg[c[i]] = b[i];
use[b[i]] = 1;
checkdown(i);
if (ff) {
output();
continue;
}
}
}
puts("NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long sum[2005][2005], l[2005][2005], r[2005][2005];
long long px, py, mx = -1;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &sum[i][j]);
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
l[i][j] = (i > 0 ? l[i - 1][j + 1] : 0) + sum[i][j];
r[i][j] = ((i > 0 && j > 0) ? r[i - 1][j - 1] : 0) + sum[i][j];
}
for (int i = k; i <= n - k + 1; i++)
for (int j = k; j <= m - k + 1; j++) {
long long tmp = l[i - 1][j - k] - (i > k ? l[i - k - 1][j] : 0);
tmp += l[i + k - 1][j] - l[i - 1][j + k];
tmp -= r[i - 1][j + k - 1] - (i > k ? r[i - k - 1][j - 1] : 0);
tmp -= r[i + k - 1][j - 1] - (j > k ? r[i - 1][j - k - 1] : 0);
if (tmp > mx) {
mx = tmp;
px = i;
py = j;
}
}
cout << px << " " << py << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool string_endswith(const string &s, const string &suffix) {
if (suffix.size() > s.size()) {
return false;
}
for (int i = (0); i < ((int)suffix.size()); i++) {
if (s[s.size() - i - 1] != suffix[suffix.size() - i - 1]) {
return false;
}
}
return true;
}
bool string_startswith(const string &s, const string &prefix) {
if (prefix.size() > s.size()) {
return false;
}
for (int i = (0); i < ((int)prefix.size()); i++) {
if (s[i] != prefix[i]) {
return false;
}
}
return true;
}
bool offset_str_equals(const string &stack, int offset, const string &needle) {
for (int i = (0); i < ((int)needle.size()); i++) {
if ((offset + i) >= stack.size() || needle[i] != stack[offset + i]) {
return false;
}
}
return true;
}
int region_sum(const vector<int> &acc, int from, int to) {
if (from < 0 || to >= acc.size() || from > to) {
return 0;
}
int ans = acc[to];
if (from >= 1) ans -= acc[from - 1];
return ans;
}
int main() {
string str;
getline(cin, str);
int n = (int)str.size();
vector<int> bears_here(n, 0);
for (int i = (0); i < (n); i++) {
bears_here[i] = (int)offset_str_equals(str, i, "bear");
}
vector<int> bears_count_acc(n, 0);
bears_count_acc[0] = bears_here[0];
for (int i = (1); i < (n); i++) {
bears_count_acc[i] = bears_count_acc[i - 1] + bears_here[i];
}
int ans = 0;
for (int a = (0); a < (n); a++)
for (int b = (a); b < (n); b++) {
int bears_inside = min({
region_sum(bears_count_acc, a, b),
region_sum(bears_count_acc, a, b - 1),
region_sum(bears_count_acc, a, b - 2),
region_sum(bears_count_acc, a, b - 3),
});
if (bears_inside > 0) {
ans++;
}
}
printf("%d\n", ans);
;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dis(int a, int d, int b, int c) {
return (a - b) * (a - b) + (d - c) * (d - c);
}
int main() {
int i, n, j, k, l = 0, m = 0;
int x[10], y[10], p[10], q[10];
for (i = 0; i < 3; i++) {
cin >> x[i] >> y[i];
}
int d[100];
for (i = 0; i < 3; i++) {
if (i == 2)
d[i] = dis(x[i], y[i], x[0], y[0]);
else
d[i] = dis(x[i], y[i], x[i + 1], y[i + 1]);
}
sort(d, d + 3);
int flag = 0;
if (d[0] + d[1] == d[2] && d[0] > 0) {
cout << "RIGHT" << endl;
return 0;
}
set<int> a, b;
for (i = 0; i < 3; i++) {
for (j = -1; j < 2; j++) {
if (j != 0) {
for (k = 0; k < 3; k++) {
p[k] = x[k];
q[k] = y[k];
}
p[i] = x[i] + j;
for (k = 0; k < 3; k++) {
if (k == 2)
d[k] = dis(p[k], q[k], p[0], q[0]);
else
d[k] = dis(p[k], q[k], p[k + 1], q[k + 1]);
}
sort(d, d + 3);
if (d[0] + d[1] == d[2] && d[0] > 0) {
cout << "ALMOST" << endl;
return 0;
}
}
}
for (j = -1; j < 2; j++) {
if (j != 0) {
for (k = 0; k < 3; k++) {
p[k] = x[k];
q[k] = y[k];
}
q[i] = y[i] + j;
for (k = 0; k < 3; k++) {
if (k == 2)
d[k] = dis(p[k], q[k], p[0], q[0]);
else
d[k] = dis(p[k], q[k], p[k + 1], q[k + 1]);
}
sort(d, d + 3);
if (d[0] + d[1] == d[2] && d[0] > 0) {
cout << "ALMOST" << endl;
return 0;
}
}
}
}
cout << "NEITHER" << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.