solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long a, long long n) {
long long r = 1;
for (; n; n >>= 1, a *= a)
if (n & 1) r *= a;
return r;
}
int main() {
int T, n;
long long k;
scanf("%d", &T);
while (T--) {
scanf("%d%lld", &n, &k);
if (n <= 30 && k > (qpow(4, n) - 1) / 3 || n == 2 && k == 3) {
printf("NO\n");
} else {
int x = 0;
long long pow2 = 1;
long long sum = 0;
while (x < n && sum < k) {
if (sum + 2 * pow2 - 1 > k) break;
pow2 *= 2;
sum += pow2 - 1;
x++;
}
printf("YES %d\n", n - x);
}
}
return 0;
}
| 6 |
#include<iostream>
#include<string>
#include<cstring>
#include<stack>
#include<queue>
#include<map>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<set>
#include<cstdio>
using namespace std;
#define goup(i,a,b) for(int i=a;b;i++)
#define Goup(i,a,b) for(int i=a;i<=b;i++)
#define godown(i,a,b) for(int i=a;b;i--)
#define Godown(i,a,b) for(int i=a;i>=b;i--)
#define Gohead(i,a) for(int i=head[a];i;i=nxt[i])
#define memsetfa(n) for(int i=0;i<=n;i++)fa[i]=i
#define memsetmin(i) memset(i,0,sizeof(i))
#define memsetmax(i) memset(i,0x3f3f3f,sizeof(i))
typedef long long ll;
typedef long double ld;
//const int dir[9][2] = { {0,0},{1,0},{0,1},{-1,0},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1} };
const int MaxDegree = 0x3f3f3f;
const int Mod = 1e8;
const int N = 1e6 + 5;
const double PI = acos(-1);
#define FAST_IO ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
int n, mx, mp[100005], book_l[100005], book_r[100005];
void init()
{
book_l[1] = book_r[n] = mx = 1;
Goup(i, 2, n)
{
if (mp[i] > mp[i - 1])
{
book_l[i] = book_l[i - 1] + 1;
}
else
{
book_l[i] = 1;
}
mx = max(mx, book_l[i]);
}
Godown(i, n - 1, 1)
{
if (mp[i] > mp[i + 1])
{
book_r[i] = book_r[i + 1] + 1;
}
else
{
book_r[i] = 1;
}
mx = max(mx, book_r[i]);
}
}
int getans()
{
int flag = 0, ans = 0;
Goup(i, 1, n)
{
if (book_l[i] == mx || book_r[i] == mx)
{
if (flag)
{
return 0;
}
flag = 1;
}
}
Goup(i, 1, n)
{
if (book_l[i] == book_r[i] && book_l[i] == mx && mx % 2 == 1)
{
ans++;
}
}
return ans;
}
int main()
{
while (cin >> n)
{
Goup(i, 1, n)
{
scanf("%d", &mp[i]);
}
init();
/*Goup(i, 1, n)
{
cout << book_l[i] << " ";
}
cout << endl;
Goup(i, 1, n)
{
cout << book_r[i] << " ";
}
cout << endl;*/
cout << getans() << endl;
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[105];
int main() {
int s = 0, t = 0;
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (s >= m)
break;
else {
s += a[n - i - 1];
t++;
}
}
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
int mx = 10000;
auto mex = [&](int a, int b, int c) {
int res = 0;
while (res == a || res == b || res == c) {
res++;
}
return res;
};
while (tt--) {
int n, x, y, z;
cin >> n >> x >> y >> z;
vector<vector<int>> gn(mx, vector<int>(3));
for (int i = 1; i < mx; i++) {
gn[i][0] =
mex(gn[max(0, i - x)][0], gn[max(0, i - y)][1], gn[max(0, i - z)][2]);
gn[i][1] = mex(gn[max(0, i - x)][0], gn[max(0, i - z)][2], -1);
gn[i][2] = mex(gn[max(0, i - x)][0], gn[max(0, i - y)][1], -1);
}
ll r = 1;
while (true) {
bool ok = true;
for (int i = 1; i < 10; i++) {
for (int j = 0; j < r; j++) {
if (gn[100 + j] != gn[100 + j + r * i]) {
ok = false;
break;
}
}
}
if (ok) {
break;
}
r++;
}
auto calc = [&](ll s, int t) {
if (s < 100) {
return gn[s][t];
}
s %= r;
for (int i = 0; i < r; i++) {
if (s == (101 + i) % r) {
return gn[101 + i][t];
}
}
return -1;
};
int gall = 0;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
gall ^= calc(a[i], 0);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int g = gall ^ calc(a[i], 0);
if (g == calc(max(a[i] - x, 0LL), 0)) {
ans++;
}
if (g == calc(max(a[i] - y, 0LL), 1)) {
ans++;
}
if (g == calc(max(a[i] - z, 0LL), 2)) {
ans++;
}
}
cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
int n, m;
char a[MAXN][MAXN];
int r[MAXN][MAXN];
int cnt[MAXN];
void makedp() {
for (int i = 0; i < n; ++i) {
bool flag = false;
int st;
for (int j = m - 1; j >= 0; --j) {
if (a[i][j] == '1' && !flag) {
flag = true;
st = j;
}
if (flag) {
if (a[i][j] == '1') {
r[i][j] = st - j + 1;
} else {
flag = false;
}
}
}
}
}
void debug1() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << r[i][j] << " ";
}
cout << endl;
}
}
void debug2() {
for (int i = 0; i <= m; ++i) {
cout << cnt[i] << " ";
}
cout << endl;
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", a[i]);
}
makedp();
int ans = 0;
int idx = 0;
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) {
++cnt[r[i][j]];
}
idx = 0;
for (int i = 0; i <= m; ++i) {
if (cnt[i] > 0) {
ans = max(ans, i * (n - idx));
idx += cnt[i];
cnt[i] = 0;
}
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MAX_N = 1e5 + 10;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char name[1000];
scanf("%s", name);
return name;
}
long long a[] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
int32_t main() {
long long n = in();
cout << a[n] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans;
if (n % 2 == 0) {
ans = ((n / 2) - 1);
} else {
ans = (n / 2);
}
cout << ans << endl;
sort(a, a + n);
for (long long i = 0; i < (n - 1); i += 2) {
swap(a[i], a[i + 1]);
}
for (long long i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 10000020;
const int mod = 1000000007;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
long long readint() {
long long val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
char bf[1 << 25], st[20], *w = bf;
void flush() {
fwrite(bf, 1, w - bf, stdout);
w = bf;
}
inline void pc(register char c) { *w++ = c; }
void print(register int n) {
register char* t = st;
do {
*t++ = n % 10 + 48;
} while (n /= 10);
while (t-- > st) pc(*t);
}
using namespace std;
const int M = 1e9 + 7;
int T, g[3], tp, h;
long long n, f[3], c[4][4];
int main() {
init();
for (int i = 0; i < 4; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
for (T = readint(); T--;) {
n = readint();
f[0] = 1, f[1] = f[2] = 0;
for (int i = 0; 1ll << i <= n; i++) {
for (int j = 0; j < 3; j++) g[j] = (f[j] %= M), f[j] = 0;
for (int j = 0; j < 3; j++) {
tp = min(i + 1, 3), h = g[j];
for (int k = (j + 1 & 1) == (n >> i & 1); k <= tp; k += 2)
f[j + k >> 1] += c[tp][k] * g[j];
}
}
print(f[0] % M), pc('\n');
}
flush();
}
| 8 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
int arr[n + 1], indxm;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
if (x == m) {
arr[i] = 0;
indxm = i;
} else if (x < m)
arr[i] = -1;
else
arr[i] = 1;
}
long long int ans = 0, currSum = 0;
map<int, int> cnt;
for (int i = indxm; i <= n; ++i) {
currSum += arr[i];
cnt[currSum]++;
}
currSum = 0;
for (int i = indxm; i >= 1; --i) {
currSum += arr[i];
if (cnt.count(-currSum)) ans = ans + cnt[-currSum];
if (cnt.count(-currSum + 1)) ans = ans + cnt[-currSum + 1];
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int freq[N];
int A[N];
int prefix[N];
int main() {
int n, s, ans = INT_MAX - 5, max_val = 0;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
cin >> A[i];
if (i != s) {
freq[A[i]]++;
max_val = max(max_val, A[i]);
}
}
if (n == 1) {
if (A[1] != 0)
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
int current = freq[0];
prefix[0] = 0;
for (int i = 1; i <= max_val; i++) {
prefix[i] = prefix[i - 1];
if (freq[i] == 0) prefix[i]++;
}
for (int i = max_val; i >= 0; i--) {
ans = min(ans, max(prefix[i], current));
current += freq[i];
}
if (A[s] != 0) ans++;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
class CerrDummy {
} cerrDummy;
template <class T>
CerrDummy& operator<<(CerrDummy& cd, const T&) {
return cd;
}
using charTDummy = char;
using traitsDummy = char_traits<charTDummy>;
CerrDummy& operator<<(CerrDummy& cd,
basic_ostream<charTDummy, traitsDummy>&(
basic_ostream<charTDummy, traitsDummy>&)) {
return cd;
}
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (int i = int(0); i < int((int)v.size()); i++) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1) printEoln();
if (suc == 2) printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char* readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char* ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U>
void chmax(T& a, U b) {
if (a < b) a = b;
}
template <class T, class U>
void chmin(T& a, U b) {
if (b < a) a = b;
}
template <class T>
T Sq(const T& t) {
return t * t;
}
void Yes(bool ex = true) {
cout << "YES" << endl;
if (ex) exit(0);
}
void No(bool ex = true) {
cout << "NO" << endl;
if (ex) exit(0);
}
const ll infLL = LLONG_MAX / 3;
const int inf = INT_MAX / 2 - 100;
namespace MaxFlow {
using CapType = int;
struct Edge {
int to, rev;
CapType cap;
};
vector<vector<Edge>> g;
vi itr, level;
void Init(int n) {
g.assign(n, vector<Edge>());
itr.assign(n, 0);
level.assign(n, 0);
}
void AddEdge(int from, int to, CapType cap) {
g[from].push_back({to, (int)g[to].size(), cap});
g[to].push_back({from, (int)g[from].size() - 1, 0});
}
void bfs(int s) {
fill(level.begin(), level.end(), -1);
level[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto e : g[v])
if (e.cap > 0 && level[e.to] == -1) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
CapType dfs(int v, int t, CapType f) {
if (v == t) return f;
CapType res = 0;
for (int& i = itr[v]; i < (int)g[v].size(); i++) {
Edge& e = g[v][i];
if (e.cap > 0 && level[e.to] == level[v] + 1) {
CapType d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
res += d;
f -= d;
if (f <= 0) break;
}
}
}
return res;
}
CapType Calc(int s, int t) {
CapType flow = 0;
while (1) {
bfs(s);
if (level[t] == -1) return flow;
fill(itr.begin(), itr.end(), 0);
flow += dfs(s, t, inf);
}
}
} // namespace MaxFlow
const int Vmax = 610;
struct Edge {
int to, cost;
};
vector<Edge> g[Vmax];
vi waf(int n, int root) {
vi dist(n, inf);
priority_queue<pi, vector<pi>, greater<pi>> pq;
const auto Reach = [&](int v, int cost) {
if (dist[v] > cost) {
dist[v] = cost;
pq.push(pi(cost, v));
}
};
Reach(root, 0);
while (!pq.empty()) {
int c = pq.top().first;
int v = pq.top().second;
pq.pop();
for (auto e : g[v]) Reach(e.to, c + e.cost);
}
return dist;
}
signed main() {
int v = read(), e = read(), n = read(), k = read();
vi st(n);
for (int i = int(0); i < int(n); i++) st[i] = read() - 1;
for (int _ = int(0); _ < int(e); _++) {
int a = read() - 1, b = read() - 1, c = read();
g[a].push_back(Edge{b, c});
g[b].push_back(Edge{a, c});
}
vector<vi> dss(n);
for (int i = int(0); i < int(n); i++) dss[i] = waf(v, st[i]);
int low = -1, up = 1731311 + 1;
while (up - low > 1) {
const int mid = (low + up) / 2;
MaxFlow::Init(1 + n + v + 1);
for (int i = int(0); i < int(n); i++) {
MaxFlow::AddEdge(0, 1 + i, 1);
}
for (int i = int(0); i < int(v); i++) {
MaxFlow::AddEdge(1 + n + i, 1 + n + v, 1);
}
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(v); j++)
if (dss[i][j] <= mid) {
MaxFlow::AddEdge(1 + i, 1 + n + j, 1);
}
if (MaxFlow::Calc(0, 1 + n + v) >= k)
up = mid;
else
low = mid;
}
if (up <= 1731311) {
print(up);
} else
print(-1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e10;
const int N = 3e5 + 77;
int n, m, k, a, b;
char adj[1001][1001];
int main() {
cin >> n >> a >> b;
if (a > 1 and b > 1) {
puts("NO");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) adj[i][j] = '0';
if (a == 1 and b == 1) {
if (n == 2 or n == 3) {
puts("NO");
return 0;
}
for (int i = 1; i < n; i++) adj[i - 1][i] = adj[i][i - 1] = '1';
} else if (a > 1) {
a = n - a + 1;
for (int i = 1; i < a; i++) adj[i - 1][i] = adj[i][i - 1] = '1';
} else {
b = n - b + 1;
for (int i = 1; i < b; i++) adj[i - 1][i] = adj[i][i - 1] = '1';
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (adj[i][j] == '0')
adj[i][j] = '1';
else
adj[i][j] = '0';
}
}
for (int i = 0; i < n; i++) adj[i][i] = '0';
puts("YES");
for (int i = 0; i < n; i++) cout << adj[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
vector<int> graph[100000 + 7], ans;
int ini[100000 + 7], target[100000 + 7];
void dfs(int form, int cur, int dep, int even, int odd) {
if (dep & 1) {
int temp = (ini[cur] + odd) % 2;
if (temp != target[cur]) {
ans.push_back(cur);
odd = (odd + 1) % 2;
}
} else {
int temp = (ini[cur] + even) % 2;
if (temp != target[cur]) {
ans.push_back(cur);
even = (even + 1) % 2;
}
}
for (int i = 0; i < graph[cur].size(); i++) {
int v = graph[cur][i];
if (v == form) continue;
dfs(cur, v, dep + 1, even, odd);
}
}
int main() {
int n, v, u;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++) scanf("%d", &ini[i]);
for (int i = 1; i <= n; i++) scanf("%d", &target[i]);
dfs(-1, 1, 1, 0, 0);
u = ans.size();
deb(u);
for (int i = 0; i < u; i++) deb(ans[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > son[200005];
long long valid = 0, One, Zero, OneZero, ZeroOne;
int mark[200005];
int sub[200005];
void fillsub(int u, int p) {
sub[u] = 1;
for (auto e : son[u]) {
if (e.first == p) continue;
if (mark[e.first]) continue;
fillsub(e.first, u);
sub[u] += sub[e.first];
}
}
int FindCentroid(int u, int rootsub, int par) {
int heavy = -1;
for (auto e : son[u]) {
if (e.first == par || mark[e.first]) continue;
if (heavy == -1 || (sub[heavy] < sub[e.first])) {
if (sub[e.first] > rootsub / 2) heavy = e.first;
}
}
if (heavy == -1) {
return u;
} else {
return FindCentroid(heavy, rootsub, u);
}
}
void dfszero(int u, int p, int lc, int add) {
if (lc == 0)
Zero += add;
else
OneZero += add;
for (auto e : son[u]) {
int v = e.first, c = e.second;
if (v == p || mark[v]) continue;
if (c < lc) continue;
dfszero(v, u, c, add);
}
}
void dfsone(int u, int p, int lc, int add) {
if (lc == 1)
One += add;
else
ZeroOne += add;
for (auto e : son[u]) {
int v = e.first, c = e.second;
if (v == p || mark[v]) continue;
if (c > lc) continue;
dfsone(v, u, c, add);
}
}
void queryzero(int u, int p, int lc) {
if (lc == 0)
valid += Zero + Zero + One + OneZero;
else
valid += Zero;
for (auto e : son[u]) {
int v = e.first, c = e.second;
if (v == p || mark[v]) continue;
if (c < lc) continue;
queryzero(v, u, c);
}
}
void queryone(int u, int p, int lc) {
if (lc == 1)
valid += One + One + Zero + ZeroOne;
else
valid += One;
for (auto e : son[u]) {
int v = e.first, c = e.second;
if (v == p || mark[v]) continue;
if (c > lc) continue;
queryone(v, u, c);
}
}
void solve(int u) {
One = Zero = OneZero = ZeroOne = 0;
for (int i = 0; i < son[u].size(); i++) {
int v = son[u][i].first, c = son[u][i].second;
if (mark[v]) continue;
if (c == 0)
queryzero(v, u, 0);
else
queryone(v, u, 1);
if (c == 0)
dfszero(v, u, 0, 1);
else
dfsone(v, u, 1, 1);
}
valid += (One * 2) + (Zero * 2) + OneZero + ZeroOne;
}
int Universe(int root) {
fillsub(root, -1);
int cent = FindCentroid(root, sub[root], -1);
solve(cent);
mark[cent] = true;
for (auto e : son[cent]) {
if (mark[e.first]) continue;
int child = Universe(e.first);
}
return cent;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
son[u].push_back(make_pair(v, c));
son[v].push_back(make_pair(u, c));
}
int cent = Universe(1);
printf("%lld\n", valid);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n;
char a[N], b[N];
set<int> l, r;
int ans;
int main() {
ios::sync_with_stdio(false);
cin >> n >> a + 1 >> b + 1;
for (int i = 1; i <= n; i++) {
if (a[i] != b[i]) {
if (a[i] == '0')
l.insert(i);
else
r.insert(i);
}
}
if (!l.size() && !r.size()) return cout << 0, 0;
while (1) {
if (!l.size() && !r.size()) break;
if (l.size() == 0) {
return cout << -1, 0;
}
if (r.size() == 0) {
return cout << -1, 0;
break;
}
auto L = l.begin();
int dx = *L;
auto R = r.begin();
int dy = *R;
int last;
if (dx < dy) {
l.erase(L);
r.erase(R);
int st = 1;
while (1) {
if (st) {
auto x = l.lower_bound(dy);
if (x == l.end()) break;
dx = *x;
last = *x;
l.erase(x);
} else {
auto x = r.lower_bound(dx);
if (x == r.end()) break;
dy = *x;
r.erase(x);
}
st ^= 1;
}
if (!st) l.insert(last);
} else {
l.erase(L);
r.erase(R);
int st = 0;
while (1) {
if (st) {
auto x = l.lower_bound(dy);
if (x == l.end()) break;
dx = *x;
l.erase(x);
} else {
auto x = r.lower_bound(dx);
if (x == r.end()) break;
dy = *x;
last = *x;
r.erase(x);
}
st ^= 1;
}
if (st) r.insert(last);
}
ans++;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int pre[3000000];
char a[3000000];
int find(int x) {
if (x != pre[x]) pre[x] = find(pre[x]);
return pre[x];
}
void combine(int a, int b) {
int fx = find(a);
int fy = find(b);
if (fx > fy)
pre[fy] = fx;
else
pre[fx] = fy;
}
int main() {
char ans[3000000];
int n;
while (scanf("%d", &n) != EOF) {
memset(ans, ' ', sizeof(ans));
int end = 0;
for (int i = 1; i <= 3000000 - 80; i++) pre[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%s", a);
int len = strlen(a);
int ki;
scanf("%d", &ki);
while (ki--) {
int x;
scanf("%d", &x);
int tmpx = x;
end = max(end, len + x - 1);
while (x <= tmpx + len - 1) {
ans[x] = a[x - tmpx];
x = find(x);
if (x <= tmpx + len - 1) combine(x, x + 1);
}
}
}
for (int i = 1; i <= end; i++) {
if (ans[i] == ' ') ans[i] = 'a';
printf("%c", ans[i]);
}
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> a, b, last;
const long long INF = 4e18;
long long cal(long long A, long long B) { return B * (A - B * B); }
long long calUp(long long A, long long B) { return -A + 3 * B * B + 3 * B + 1; }
long long calDown(long long A, long long B) {
return A - 3 * B * B + 3 * B - 1;
}
void solveSmall(long long need) {
auto count2 = [&](long long p, long long loss) {
long long l = b[p];
long long r = a[p];
while (l != r) {
long long mid = (l + r + 1) / 2;
if (calUp(a[p], mid) <= loss)
l = mid;
else
r = mid - 1;
}
last[p] = l;
return l - b[p];
};
auto count = [&](long long loss) {
long long ret = 0;
for (long long i = (long long)0; i <= (long long)n - 1; i++) {
ret += count2(i, loss);
}
return ret;
};
long long l = 0, r = INF;
while (l != r) {
long long mid = (l + r + 1) / 2;
if (count(mid) > need)
r = mid - 1;
else
l = mid;
}
count(l);
long long curs = accumulate(last.begin(), last.end(), 0LL);
vector<pair<long long, long long> > tmp;
for (long long i = (long long)0; i <= (long long)n - 1; i++) {
if (last[i] < a[i]) tmp.push_back({calUp(a[i], last[i]), i});
}
sort(tmp.begin(), tmp.end());
for (long long i = (long long)0; i <= (long long)m - curs - 1; i++)
last[tmp[i].second]++;
}
void solveLarge(long long need) {
auto count2 = [&](long long p, long long loss) {
long long l = 0;
long long r = b[p];
while (l != r) {
long long mid = (l + r) / 2;
if (calDown(a[p], mid) <= loss)
r = mid;
else
l = mid + 1;
}
last[p] = l;
return b[p] - l;
};
auto count = [&](long long loss) {
long long ret = 0;
for (long long i = (long long)0; i <= (long long)n - 1; i++) {
ret += count2(i, loss);
}
return ret;
};
long long l = 0, r = INF;
while (l != r) {
long long mid = (l + r + 1) / 2;
if (count(mid) > need)
r = mid - 1;
else
l = mid;
}
count(l);
long long curs = accumulate(last.begin(), last.end(), 0LL);
vector<pair<long long, long long> > tmp;
for (long long i = (long long)0; i <= (long long)n - 1; i++) {
if (last[i] > 0) tmp.push_back({calDown(a[i], last[i]), i});
}
sort(tmp.begin(), tmp.end());
for (long long i = (long long)0; i <= (long long)curs - m - 1; i++)
last[tmp[i].second]--;
}
long long sqrt128(long long t) {
long long l = 0, r = 1e9;
while (l != r) {
long long mid = (l + r + 1) / 2;
if (mid * mid <= t)
l = mid;
else
r = mid - 1;
}
return l;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = (long long)1; i <= (long long)n; i++) {
long long t;
cin >> t;
a.push_back(t);
}
for (auto it : a) {
auto t = sqrt128(it / 3);
auto l1 = cal(it, t);
auto l2 = cal(it, t + 1);
if (l1 < l2)
b.push_back(t + 1);
else
b.push_back(t);
}
last = b;
long long sum = accumulate(last.begin(), last.end(), 0LL);
if (sum < m)
solveSmall(m - sum);
else if (sum > m)
solveLarge(sum - m);
for (auto it : last) cout << it << ' ';
cout << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string Compare(string s, int n) {
if (n & 1 == 1) return s;
string temp1 = s.substr(0, n / 2);
string temp2 = s.substr(n / 2);
string s1 = Compare(temp1, n / 2);
string s2 = Compare(temp2, n / 2);
if (s1 < s2) return s1 + s2;
return s2 + s1;
}
int main() {
string s1, s2;
cin >> s1 >> s2;
int n = s1.length();
if (Compare(s1, n) == Compare(s2, n))
cout << "Yes";
else
cout << "No";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int x) {
if (x < 2) return false;
for (int i = 2; i <= sqrt(x); i++) {
if ((x % i) == 0) return false;
}
return true;
}
int main() {
int d, n, x;
scanf("%d", &d);
scanf("%d", &n);
long long int res = 0;
for (int i = 0; i < n - 1; ++i) {
scanf("%d", &x);
if (d > x) res += d - x;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int M = 1e9;
const int inf = 1e9 + 7;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-9;
int n, k, m = 0;
int a[N];
long long S;
vector<pair<long long, int> > lef;
map<pair<long long, int>, int> rig;
long long f[20], lt3[30];
int main() {
cin >> n >> k >> S;
f[0] = 1;
lt3[0] = 1;
for (int i = (int)1; i < (int)20; i++) f[i] = f[i - 1] * i;
for (int i = (int)1; i < (int)30; i++) lt3[i] = lt3[i - 1] * 3;
for (int i = (int)0; i < (int)n; i++) {
scanf("%d", &a[i]);
}
if (n == 1) {
long long res = 0;
if (k > 0 && a[0] <= 18 && f[a[0]] == S) res++;
if (a[0] == S) res++;
cout << res;
return 0;
}
m = n;
n = m / 2;
for (int st = (int)0; st < (int)lt3[n]; st++) {
int num = 0;
long long tol = 0;
bool kt = 0;
int tmp = st;
for (int i = (int)0; i < (int)n; i++) {
int mod = tmp % 3;
tmp /= 3;
if (mod == 1) {
if (a[i] > 18) {
kt = 1;
break;
}
tol += f[a[i]];
num++;
} else if (mod == 2)
tol += a[i];
}
if (kt == 1) continue;
if (tol > 0) lef.push_back(make_pair(tol, num));
}
lef.push_back(make_pair(0LL, 0));
n = m - n;
for (int st = (int)0; st < (int)lt3[n]; st++) {
int num = 0;
long long tol = 0;
bool kt = 0;
int tmp = st;
for (int i = (int)0; i < (int)n; i++) {
int mod = tmp % 3;
tmp /= 3;
if (mod == 1) {
if (a[i + m / 2] > 18) {
kt = 1;
break;
}
tol += f[a[i + m / 2]];
num++;
} else if (mod == 2)
tol += a[i + m / 2];
}
if (kt == 1) continue;
if (tol != 0) rig[make_pair(tol, num)]++;
}
long long res = 0;
for (int i = (int)0; i < (int)lef.size(); i++) {
if (lef[i].first == S && lef[i].second <= k) res++;
for (int t = (int)lef[i].second; t < (int)k + 1; t++) {
pair<long long, int> tmp = make_pair(S - lef[i].first, t - lef[i].second);
if (rig.count(tmp) != 0) res += rig[tmp];
}
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 + 10;
int kry[maxn][maxn];
int stal[maxn][maxn];
int main() {
int a;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
scanf("%d", &a);
kry[i][j] = a % 2;
stal[i][j] = 1;
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (kry[i][j]) {
if (i > 0) stal[i - 1][j] = !stal[i - 1][j];
if (j > 0) stal[i][j - 1] = !stal[i][j - 1];
if (i < 2) stal[i + 1][j] = !stal[i + 1][j];
if (j < 2) stal[i][j + 1] = !stal[i][j + 1];
stal[i][j] = !stal[i][j];
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) printf("%d", stal[i][j]);
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[200005];
int main() {
int n, i, w, x, s = 0, l = -(1 << 31);
cin >> n;
for (i = 0; i < n; i++) cin >> x >> w, p[i] = make_pair(x + w, x - w);
sort(p, p + n);
for (i = 0; i < n; i++)
if (p[i].second >= l) l = p[i].first, s++;
cout << s;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
void myshuffle(vc<t>& first) {
for (ll i = ll(0); i < ll(ll(first.size())); i++)
swap(first[i], first[rand_int(0, i)]);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
struct modinfo {
uint mod, root;
};
template <modinfo const& ref>
struct modular {
static constexpr uint const& mod = ref.mod;
static modular root() { return modular(ref.root); }
uint v;
modular(ll vv = 0) { s(vv % mod + mod); }
modular& s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
modular operator-() const { return modular() - *this; }
modular& operator+=(const modular& rhs) { return s(v + rhs.v); }
modular& operator-=(const modular& rhs) { return s(v + mod - rhs.v); }
modular& operator*=(const modular& rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
modular& operator/=(const modular& rhs) { return *this *= rhs.inv(); }
modular operator+(const modular& rhs) const { return modular(*this) += rhs; }
modular operator-(const modular& rhs) const { return modular(*this) -= rhs; }
modular operator*(const modular& rhs) const { return modular(*this) *= rhs; }
modular operator/(const modular& rhs) const { return modular(*this) /= rhs; }
modular pow(ll n) const {
modular res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
modular inv() const { return pow(mod - 2); }
friend modular operator+(ll x, const modular& y) { return modular(x) + y; }
friend modular operator-(ll x, const modular& y) { return modular(x) - y; }
friend modular operator*(ll x, const modular& y) { return modular(x) * y; }
friend modular operator/(ll x, const modular& y) { return modular(x) / y; }
friend ostream& operator<<(ostream& os, const modular& m) {
return os << m.v;
}
friend istream& operator>>(istream& is, modular& m) {
ll x;
is >> x;
m = modular(x);
return is;
}
bool operator<(const modular& r) const { return v < r.v; }
bool operator==(const modular& r) const { return v == r.v; }
bool operator!=(const modular& r) const { return v != r.v; }
explicit operator bool() const { return v; }
};
extern constexpr modinfo base{1000000007, 0};
using mint = modular<base>;
const ll vmax = (1 << 21) + 10;
mint fact[vmax], finv[vmax], invs[vmax];
void initfact() {
fact[0] = 1;
for (ll i = ll(1); i < ll(vmax); i++) {
fact[i] = fact[i - 1] * i;
}
finv[vmax - 1] = fact[vmax - 1].inv();
for (ll i = vmax - 2; i >= 0; i--) {
finv[i] = finv[i + 1] * (i + 1);
}
for (ll i = vmax - 1; i >= 1; i--) {
invs[i] = finv[i] * fact[i - 1];
}
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
string s;
cin >> s;
ll n = ll(s.size());
if (s == string(n, '0')) {
cout << n << endl;
return 0;
}
ll waf = 0;
while (s.back() == '0') {
waf++;
s.pop_back();
n--;
}
vi z;
for (ll i = 0; i < n;) {
if (s[i] == '0') {
ll j = i;
while (j < n && s[i] == s[j]) j++;
z.push_back(j - i);
i = j;
} else {
z.push_back(-1);
i++;
}
}
void(0);
vi h;
vc<mint> w;
mint last = 1;
ll cnt = 0;
mint ans = 0;
bool fs = true;
for (auto v : z) {
if (v == -1) {
ans += last;
cnt++;
} else {
mint nx = last;
if (fs) nx += last * v;
w.push_back(last * cnt);
h.push_back(0);
mint sum = 0;
while (ll(h.size()) && h.back() <= v) {
ll t = h.back();
h.pop_back();
mint q = w.back();
w.pop_back();
void(0);
nx += q * (v - t);
sum += q;
}
void(0);
w.push_back(sum);
h.push_back(v);
last = nx;
cnt = 0;
}
void(0);
void(0);
void(0);
fs = false;
}
cout << ans * (waf + 1) << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3;
const int score_max = 5e3;
int num[maxn + 10];
long long count_winscore[score_max + 10], A_score[score_max << 1 + 10];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
sort(num, num + n);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) count_winscore[num[i] - num[j]]++;
for (int i = 1; i <= 5000; i++)
for (int j = 1; j <= 5000; j++)
A_score[i + j] += count_winscore[i] * count_winscore[j];
for (int j = 1; j <= 10000; j++) A_score[j] += A_score[j - 1];
long long ans = 0;
for (int i = 1; i <= 5000; i++) ans += count_winscore[i] * A_score[i - 1];
long long k = n * (n - 1) / 2;
double possibility = (double)ans / k / k / k;
printf("%.10f\n", possibility);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d ", &n);
int r = 0x7FFFFFFF;
vector<int> sz(n);
for (int i = 0; i < (int)(n); i++) scanf("%d ", &sz[i]);
for (int i = 0; i < (int)(n); i++) {
int s = 0;
for (int j = 0; j < (int)(sz[i]); j++) {
int a;
scanf("%d ", &a);
s += 5 * a;
}
s += 15 * sz[i];
r = min(r, s);
}
printf("%d\n", r);
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int inf = 0x3f3f3f3f;
int main() {
int n;
scanf("%d", &n);
if (n % 2 == 0) {
printf("NO\n");
} else {
printf("YES\n");
if (n == 1)
printf("1 2\n");
else {
printf("1 ");
int j = 4;
while (1) {
printf("%d %d ", j, j + 1);
if (j + 4 > 2 * n) {
break;
} else {
j += 4;
}
}
printf("2 ");
int k = 3;
while (1) {
printf("%d %d ", k, k + 3);
if (k + 4 > 2 * n) {
break;
} else {
k += 4;
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e2 + 5;
int C[maxn];
bool dp[maxn][2 * maxn][maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, p;
cin >> n >> p;
for (int i = 1; i <= n; i++) cin >> C[i];
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int k = 0; k <= p; k++) {
dp[i][k][0] = dp[i - 1][k][0];
if (k >= C[i]) dp[i][k][0] |= dp[i - 1][k - C[i]][0];
}
for (int i = 1; i <= n; i++)
for (int k = 1; k <= p; k++)
for (int j = 1; j <= p; j++) {
dp[i][k][j] = dp[i - 1][k][j];
if (k >= C[i]) {
dp[i][k][j] |= dp[i - 1][k - C[i]][j];
if (j >= C[i]) dp[i][k][j] |= dp[i - 1][k - C[i]][j - C[i]];
}
}
int ans = 0;
for (int j = 0; j <= p; j++) ans += dp[n][p][j];
cout << ans << endl;
for (int j = 0; j <= p; j++)
if (dp[n][p][j]) cout << j << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline int read() {
int s = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
;
do {
s = s * 10 + c - '0';
} while ((c = getchar()) >= '0' && c <= '9');
return s;
}
const int N = 21, INF = 0x7f7f7f7f;
int n, n2, w1[N][N], w2[N][N], w[N][N], ans, tans, lx[N], ly[N], sl[N], lk[N],
pat[N];
bool by[N];
void dfs(int nn, int d1, int d2) {
if (nn > n) {
if (ly[0] > ans) ans = ly[0];
return;
}
int _lx[N], _ly[N], _lk[N], _a, i, cy, cx, ny;
for (int ch = 0; ch < 2; ch++) {
if (d1 == n2 && ch == 1) continue;
if (d2 == n2 && ch == 0) continue;
memcpy(_lx, lx, (n << 2) + 4), memcpy(_ly, ly, (n << 2) + 4),
memcpy(_lk, lk, (n << 2) + 4);
if (ch)
memcpy(w[nn], w1[nn], (n << 2) + 4);
else
memcpy(w[nn], w2[nn], (n << 2) + 4);
memset(sl, 0x7f, (n << 2) + 4), memset(by, 0, n + 1);
cy = 0;
lk[0] = nn;
while (lk[cy]) {
by[cy] = 1;
cx = lk[cy];
int tmp = INF;
for (i = 1; i <= n; i++)
if (!by[i]) {
int t = -lx[cx] - ly[i] - w[cx][i];
if (t < sl[i]) sl[i] = t, pat[i] = cy;
if (sl[i] < tmp) tmp = sl[i], ny = i;
}
for (i = 0; i <= n; i++) {
if (by[i])
lx[lk[i]] += tmp, ly[i] -= tmp;
else
sl[i] -= tmp;
}
cy = ny;
}
while (cy) lk[cy] = lk[pat[cy]], cy = pat[cy];
dfs(nn + 1, d1 + (ch), d2 + (ch ^ 1));
memcpy(lx, _lx, (n << 2) + 4), memcpy(ly, _ly, (n << 2) + 4),
memcpy(lk, _lk, (n << 2) + 4);
}
}
int main() {
int i, j;
n2 = (n = read()) >> 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) w1[i][j] = read();
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) w2[i][j] = read();
dfs(1, 0, 0);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(1000005);
int a[MAXN];
int main() {
int n, q;
scanf("%d%d", &n, &q);
int pos[2] = {0, 1};
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
for (int i = 0; i < 2; i++) pos[i] = (pos[i] + x + n) % n;
} else {
for (int i = 0; i < 2; i++) {
if (pos[i] & 1)
pos[i] = (pos[i] - 1 + n) % n;
else
pos[i] = (pos[i] + 1) % n;
}
}
}
for (int k = 0; k < n / 2; k++) {
for (int i = 0; i < 2; i++) {
a[pos[i]] = 2 * k + 1 + i;
pos[i] = (pos[i] + 2) % n;
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x[5005], y[5005], p[5005], ta;
bool u[5005], o;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
printf("? %d 0\n", i);
fflush(stdout);
scanf("%d", x + i);
}
y[0] = x[0];
for (int i = 1; i < n; i++) {
printf("? 0 %d\n", i);
fflush(stdout);
scanf("%d", y + i);
}
for (int i = 0; i < n; i++) {
if (x[i] ^ i) continue;
memset(u, 0, n);
o = 1;
for (int j = 0; j < n && o; j++) {
p[j] = x[j] ^ i;
if (p[j] >= n || u[p[j]])
o = 0;
else
u[p[j]] = 1;
}
if (o)
for (int j = 0; j < n && o; j++)
if ((y[j] ^ p[0]) >= n || j != p[y[j] ^ p[0]]) o = 0;
if (o) ta++;
}
printf("!\n%d\n", ta);
for (int i = 0; i < n; i++) {
if (x[i] ^ i) continue;
memset(u, 0, n);
o = 1;
for (int j = 0; j < n && o; j++) {
p[j] = x[j] ^ i;
if (p[j] >= n || u[p[j]])
o = 0;
else
u[p[j]] = 1;
}
if (o)
for (int j = 0; j < n && o; j++)
if ((y[j] ^ p[0]) >= n || j != p[y[j] ^ p[0]]) o = 0;
if (o) break;
}
for (int i = 0; i < n; i++) printf("%d%c", p[i], i == n - 1 ? '\n' : ' ');
fflush(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int _SZIE = (1 << 21) + 1;
char ibuf[_SZIE], *iS, *iT, c, stk[46];
int tot;
template <class I>
inline void read(I &_x) {
I fl = 1;
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, _SZIE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, _SZIE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') fl = -1;
for (_x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, _SZIE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
_x = _x * 10 + (c & 15);
_x *= fl;
}
template <class I>
inline void prt(I _x, char ch = '\0') {
tot = 0;
if (_x < 0) putchar('-'), _x *= -1;
do {
stk[tot++] = _x % 10 | 48;
_x /= 10;
} while (_x);
do {
putchar(stk[--tot]);
} while (tot);
if (ch) putchar(ch);
}
} // namespace io
using io::prt;
using io::read;
const int N = 3005;
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
int c, r, fa[N * N * 3], n;
bool de[N][2 * N];
inline int hash2(int _x, int _y) { return (_x - 1) * c * 2 + _y; }
int find(int _x) { return fa[_x] == _x ? _x : fa[_x] = find(fa[_x]); }
inline bool check(int _x, int _y) {
for (int i = 0; i < 8; i++) {
int xx = _x + dx[i], yy = _y + dy[i];
if (yy == 0) yy = c * 2;
if (yy == c * 2 + 1) yy = 1;
if (xx > 0 && xx <= r && de[xx][yy]) {
for (int j = 0; j < 8; j++) {
int _xx = _x + dx[j], _yy = _y + dy[j] + c;
if (_yy == 0) _yy = c * 2;
if (_yy == c * 2 + 1) _yy = 1;
if (_xx > 0 && _xx <= r && de[_xx][_yy]) {
if (find(hash2(_xx, _yy)) == find(hash2(xx, yy))) return false;
}
}
}
}
return true;
}
inline void solve() {
int _x, _y, ans = 0;
read(r), read(c), read(n);
if (c == 1) {
puts("0");
return;
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c * 2; j++) {
fa[hash2(i, j)] = hash2(i, j);
de[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
read(_x);
read(_y);
if (check(_x, _y)) {
for (int j = 0; j < 8; j++) {
int _xx = _x + dx[j], _yy = _y + dy[j], _yy1 = _yy + c;
if (_yy == 0) _yy = c * 2;
if (_yy == c * 2 + 1) _yy = 1;
if (_yy1 == 0) _yy1 = c * 2;
if (_yy1 == c * 2 + 1) _yy1 = 1;
if (de[_xx][_yy] && _xx > 0 && _xx <= r) {
int u = find(hash2(_xx, _yy)), v = find(hash2(_x, _y));
fa[u] = v;
}
if (de[_xx][_yy1] && _xx > 0 && _xx <= r) {
int u = find(hash2(_xx, _yy1)), v = find(hash2(_x, _y + c));
fa[u] = v;
}
}
de[_x][_y] = true;
de[_x][_y + c] = true;
ans++;
} else {
}
}
prt(ans, '\n');
}
int main() {
int T;
T = 1;
while (T--) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
char a[100000 + 2];
void solve(int n, int k) {
for (int i = 0; i < n - 1 && k; i++) {
if (a[i] == '4' && a[i + 1] == '7') {
if (i > 0 && a[i - 1] == '4' && i % 2) k = k % 2;
if (k == 0) break;
if (i % 2 == 0)
a[i + 1] = '4';
else
a[i] = '7';
--k;
}
}
printf("%s\n", a);
}
int main() {
int n, k;
while (scanf("%d%d", &n, &k) != EOF) {
getchar();
gets(a);
solve(n, k);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (n - 1) / 2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count = 0;
int T;
cin >> T;
while (count++ < T) {
int a, b, low = 0, high = 0, n;
int nbOperations = 0;
cin >> a >> b >> n;
int pol = 1;
if (a > n || b > n) {
cout << "0" << endl;
continue;
}
if (a < b) {
low = a;
high = b;
} else {
low = b;
high = a;
}
while (low <= n && high <= n) {
if (pol == 1) {
pol = 2;
low += high;
} else {
pol = 1;
high += low;
}
nbOperations++;
}
cout << nbOperations << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int T, k, p;
long long l, r;
int pw(int base, long long n, int mod) {
if (!n) return 1;
int ret = pw(base, n / 2, mod);
ret = 1LL * ret * ret % mod;
if (n & 1) ret = 1LL * ret * base % mod;
return ret;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%lld%lld%d", &k, &l, &r, &p);
if (p == 2) {
if (k & 1)
puts("0");
else
puts("1");
continue;
}
int n = pw(2, l, p - 1);
if (!n) n = p - 1;
int m = (pw(k, n, p) + p - 1) % p;
int x = pw(2, r - l, p);
if (m == 0) {
if (k & 1)
puts("2");
else
printf("%d\n", x * 2 % p);
continue;
}
int a = pw(2, r + 1, p - 1);
if (!a) a = p - 1;
int b = (pw(k, a, p) + p - 1) % p;
int y = pw(x, p - 2, p);
int z = pw(m, p - 2, p);
if (k & 1)
printf("%d\n", 1LL * b * y % p * z % p);
else
printf("%d\n", 1LL * b * z % p);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int data[(int)2e5];
int dp[5001][5001];
int used[5001][5001];
string s;
int magic(int l, int r) {
if (l > r) return 1;
if (used[l][r] != -1) return used[l][r];
if (l == r) {
data[1]++;
return used[l][r] = 1;
}
int lk, rk, k, flag = 1, middle = (l + r) / 2;
lk = magic(l, (r - l) % 2 == 0 ? (middle - 1) : middle);
rk = magic(middle + 1, r);
k = min(lk, rk) + 1;
if (s[l] == s[r] and magic(l + 1, r - 1)) {
for (int i = 1; i <= k; i++) data[i]++;
return used[l][r] = k;
}
return used[l][r] = 0;
}
int main() {
memset(used, -1, sizeof(used));
cin >> s;
int n = s.size() - 1;
for (int i = 0; i <= n; i++) {
for (int j = i; j <= n; j++) magic(i, j);
}
for (int i = 1; i <= s.size(); i++) cout << data[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace wode {
template <typename T>
inline void read(T &x) {
static char ch;
bool f = 1;
for (x = 0, ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = 0;
for (; isdigit(ch); x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar())
;
x = f ? x : -x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void print(T x, char ap) {
print(x);
if (ap) putchar(ap);
}
template <typename T>
inline T max(const T &x, const T &y) {
return x < y ? y : x;
}
template <typename T>
inline T min(const T &x, const T &y) {
return x < y ? x : y;
}
template <typename T>
inline void chkmax(T &x, const T &y) {
x = x < y ? y : x;
}
template <typename T>
inline void chkmin(T &x, const T &y) {
x = x < y ? x : y;
}
} // namespace wode
using wode::chkmax;
using wode::chkmin;
using wode::print;
using wode::read;
vector<int> v;
multiset<pair<int, int> > se;
int n, m, ver[200010], nxt[200010], head[200010], edge[200010], ans,
ver1[200010], edge1[200010], nxt1[200010], head1[200010], ans1, x, y, k;
inline void add(int x, int y, int z) {
ver[++ans] = y, edge[ans] = z, nxt[ans] = head[x], head[x] = ans;
}
inline void add1(int x, int y, int z) {
ver1[++ans1] = y, edge1[ans1] = z, nxt1[ans1] = head1[x], head1[x] = ans1;
}
int main() {
read(n), read(k);
for (register int i = 1; i <= n; ++i)
read(x), read(y), chkmax(m, y), add(x, y, i), add1(y + 1, y, i);
for (register int i = 1; i <= m; ++i) {
for (register int j = head[i]; j; j = nxt[j])
se.insert(make_pair(ver[j], edge[j]));
for (register int j = head1[i]; j; j = nxt1[j])
se.erase(make_pair(ver1[j], edge1[j]));
while (se.size() > k) {
pair<int, int> now = *(--se.end());
v.push_back(now.second), se.erase(--se.end());
}
}
print(v.size(), '\n');
for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
print(*it, ' ');
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265359;
inline long long add(long long a, long long b, long long m) {
if ((a + b) >= m) return (a + b) % m;
return a + b;
}
inline long long mul(long long a, long long b, long long m) {
if ((a * b) < m) return a * b;
return (a * b) % m;
}
long long power(long long x, long long y, long long m) {
long long res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1, n, m;
cin >> t;
while (t--) {
cin >> n >> m;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
if (m < n || n == 2) {
cout << -1 << endl;
continue;
}
vector<pair<int, int>> ans;
long long s = 0;
for (int i = 0; i < n; i++) {
if (i == n - 1) {
ans.push_back({i + 1, 1});
s += v[i] + v[0];
} else {
ans.push_back({i + 1, i + 2});
s += v[i] + v[i + 1];
}
}
int f1 = INT_MAX, f2 = INT_MAX;
int p1 = -1, p2 = -1;
for (int i = 0; i < n; i++) {
if (f1 == INT_MAX) {
f1 = v[i];
p1 = i;
} else if (f2 == INT_MAX) {
if (v[i] < f1) {
f2 = f1;
p2 = p1;
f1 = v[i];
p1 = i;
} else {
f2 = v[i];
p2 = i;
}
} else if (v[i] < f1) {
f2 = f1;
p2 = p1;
f1 = v[i];
p1 = i;
} else if (v[i] < f2) {
f2 = v[i];
p2 = i;
}
}
for (int i = 0; i < m - n; i++) {
s += v[p1] + v[p2];
ans.push_back({p1 + 1, p2 + 1});
}
cout << s << endl;
for (auto u : ans) {
cout << u.first << " " << u.second << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int matrix[1005][1005];
int n;
int rowSum[1005];
int restot;
struct {
int c;
int a;
int b;
} rc[100005];
void printM() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
printf("\n");
}
int findMinRow(int k, int s) {
int st = n - k + 1;
int minp = -1;
for (int i = 0; i < k; i++) {
if ((minp == -1 || rowSum[minp + st] > rowSum[i + st]) &&
rowSum[i + st] != 0) {
minp = i + 1;
}
}
return minp;
}
int calcUse(int k, int s, int tot) {
int st = n - k + 1;
int res = 0;
int r = st + tot;
int c = st;
for (int i = 0; i < k - tot; i++) {
for (int j = 0; j < tot; j++) {
res += matrix[r + i][c + j];
rowSum[r + i] -= matrix[r + i][c + j];
}
}
return res;
}
void swapRow(int r1, int r2, int k) {
int st = n - k + 1;
r1 += st - 1;
r2 += st - 1;
rc[restot].c = 1;
rc[restot].a = r1;
rc[restot].b = r2;
restot++;
for (int i = 0; i < k; i++) {
swap(matrix[r1][st + i], matrix[r2][st + i]);
}
swap(rowSum[r1], rowSum[r2]);
}
void swapCol(int c1, int c2, int k) {
int st = n - k + 1;
c1 += st - 1;
c2 += st - 1;
rc[restot].c = 2;
rc[restot].a = c1;
rc[restot].b = c2;
restot++;
for (int i = 0; i < k; i++) {
swap(matrix[st + i][c1], matrix[st + i][c2]);
}
}
void moveE(int k, int s, int tot, int row) {
int st = n - k + 1;
if (row != tot + 1) {
swapRow(row, tot + 1, k);
}
int use = 0;
for (int i = 0; i < k; i++) {
if (matrix[st + tot][st + i] == 1) {
use++;
if (use != i + 1) {
swapCol(use, i + 1, k);
}
}
}
int u = 0;
for (int i = 0; i < k; i++) {
if (rowSum[st + i] == 0) {
u++;
if (i + 1 != u) {
swapRow(i + 1, u, k);
}
if (u == tot) {
break;
}
}
}
}
void work(int k, int s) {
if (s == 0) {
return;
}
int st = n - k + 1;
int row = findMinRow(k, s);
int tot = rowSum[st + row - 1];
moveE(k, s, tot, row);
int use = calcUse(k, s, tot);
work(k - tot, s - use);
}
int main() {
memset(matrix, 0, sizeof(matrix));
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
matrix[x][y] = 1;
rowSum[x]++;
}
work(n, n - 1);
printf("%d\n", restot);
for (int i = 0; i < restot; i++) {
printf("%d %d %d\n", rc[i].c, rc[i].a, rc[i].b);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void init() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
long long dx[4] = {0, 1, -1, 0};
long long dy[4] = {1, 0, 0, -1};
vector<long long> adj[100005];
void read(vector<long long> &v) {
for (auto &x : v) cin >> x;
}
void show(vector<long long> &v) {
for (auto x : v) cout << x << " ";
}
void init_graph(long long e) {
while (e--) {
long long u, v;
cin >> u >> v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
read(v);
vector<long long> b(n);
sort((v).begin(), (v).end());
long long k = 0;
long long i = 0, j = n - 1;
while (i <= j) {
b[i] = v[k++];
if (k == n) break;
b[j] = v[k++];
if (k == n) break;
i++;
j--;
}
show(b);
}
void test() {
long long t;
cin >> t;
while (t--) {
solve();
}
}
int main() {
init();
solve();
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10240000,10240000")
using namespace std;
const double R = 0.5772156649015328606065120900;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
int n;
long long a[N], ini, M;
long long judge() {
long long tm = mod + 10;
long long ans = 1;
for (int i = 0; i < n; i++) {
if (ans > tm / a[i]) return 0;
ans *= a[i];
}
return ans;
}
long long Pow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
void solve(long long mo, long long tag) {
long long ans = 1;
for (int i = 0; i < n; i++) {
a[i] %= mo;
ans = ans * a[i] % mo;
}
ans--;
ans = (ans % mo + mo) % mo;
if (ans == 0) ans += mo;
long long down = Pow(2, ans);
long long up = down + tag;
up = up * ini % mod;
cout << up << '/' << down << endl;
}
long long phi(long long x) {
long long ans = x;
long long up = sqrt(x);
for (int i = 2; i <= up; i++)
if (x % i == 0) {
ans = ans / i * (i - 1);
while (x % i == 0) x /= i;
}
if (x >= 1) {
ans = ans / x * (x - 1);
}
return ans;
}
int main() {
ini = 333333336, M = 1000000006;
while (cin >> n) {
int tag = -1;
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
if (a[i] % 2 == 0) tag = 1;
}
long long all = judge();
if (all == 0) {
solve(M, tag);
continue;
}
if (all == 1) {
cout << "0/1" << endl;
continue;
}
long long down = Pow(2, all - 1);
long long up = (down + tag) * ini % mod;
cout << up << '/' << down << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int id[MAXN];
set<int> se[MAXN];
struct Data {
char op;
int x, y;
} d[MAXN];
struct node {
int l, r, mx;
inline int mid() { return (l + r) >> 1; }
} tree[MAXN << 2];
void build(int l, int r, int rt) {
tree[rt].l = l;
tree[rt].r = r;
tree[rt].mx = -1;
if (l == r) {
se[l].clear();
return;
}
int mid = tree[rt].mid();
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
}
void update(int x, int rt) {
if (tree[rt].l == tree[rt].r) {
if (se[x].size() == 0)
tree[rt].mx = -1;
else {
set<int>::iterator it = se[x].end();
tree[rt].mx = *--it;
}
return;
}
int mid = tree[rt].mid();
if (x <= mid)
update(x, rt << 1);
else
update(x, rt << 1 | 1);
tree[rt].mx = max(tree[rt << 1].mx, tree[rt << 1 | 1].mx);
}
int ask(int x, int y, int rt) {
if (tree[rt].l == tree[rt].r) return tree[rt].l;
if (tree[rt << 1].r > x && tree[rt << 1].mx > y) {
int t = ask(x, y, rt << 1);
if (t != -1) return t;
}
if (tree[rt << 1 | 1].mx > y) return ask(x, y, rt << 1 | 1);
return -1;
}
int main() {
int n;
int ncase = 0;
while (cin >> n) {
ncase ? puts("----------------") : ncase = 1;
char op[10];
vector<int> vec;
for (int i = 1; i <= n; i++) {
scanf("%s%d%d", op, &d[i].x, &d[i].y);
d[i].op = op[0];
vec.push_back(d[i].x);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
for (unsigned i = 0; i < vec.size(); i++) id[i] = vec[i];
int len = vec.size();
build(0, len + 10, 1);
for (int i = 1; i <= n; i++) {
int x = lower_bound(id, id + len, d[i].x) - id + 1;
int y = d[i].y;
if (d[i].op == 'a') {
se[x].insert(y);
update(x, 1);
} else if (d[i].op == 'r') {
se[x].erase(y);
update(x, 1);
} else {
int t = ask(x, y, 1);
if (t == -1)
puts("-1");
else
printf("%d %d\n", id[t - 1], *se[t].upper_bound(y));
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool arr[1001];
vector<int> vec;
void sieve() {
arr[0] = arr[1] = 1;
for (int i = 2; i <= 1000; i++) {
if (arr[i] == 0) {
vec.push_back(i);
for (int j = i * i; j <= 1000; j += i) arr[j] = 1;
}
}
}
int main() {
int n, m;
sieve();
while (cin >> n >> m) {
bool k = 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] == n) {
if (vec[i + 1] == m) k = 1;
break;
}
}
if (k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long r, m, n, a[500005], b[500005], c[500005], d[500005], mod = 998244353;
vector<long long> v[500005];
long long dfs(long long x, long long pr) {
if (v[x].size() == 1 && v[x][0] == pr) {
r++;
return 1;
}
long long i, j, k = 1e9, l = 0;
for (i = 0; i < v[x].size(); i++) {
j = v[x][i];
if (j == pr) continue;
if (a[x])
k = min(k, dfs(j, x));
else
l = l + dfs(j, x);
}
if (a[x]) return k;
return l;
}
int main() {
ios_base::sync_with_stdio(0);
long long k = 0, t = 0, x, sum = 0, y = 0, l = 0, z, q, i, j;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n - 1; i++) {
cin >> x;
v[x].push_back(i + 1);
v[i + 1].push_back(x);
}
k = dfs(1, 1);
cout << r - k + 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans[501][501];
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, m, x;
cin >> n >> m;
map<int, vector<int> > q;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> x, q[x].push_back(j);
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) cin >> x, q[x].push_back(j);
for (auto& e : q) ans[e.second[1]][e.second[0]] = e.first;
for (int i = 0; i < n; ++i, cout << "\n")
for (int j = 0; j < m; ++j) cout << ans[i][j] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f[100005];
int x[100005], y[100005], t[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int r, n;
cin >> r >> n;
for (int i = 1; i <= n; i++) {
cin >> t[i] >> x[i] >> y[i];
f[i] = -1e9;
}
x[0] = 1;
y[0] = 1;
t[0] = 0;
f[0] = 0;
int best = -1e9;
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = max(0, i - 2 * r); j < i; j++) {
if (abs(x[i] - x[j]) + abs(y[i] - y[j]) <= t[i] - t[j])
f[i] = max(f[i], f[j] + 1);
ans = max(ans, f[i]);
}
if (i >= 2 * r) best = max(best, f[i - 2 * r]);
f[i] = max(f[i], best + 1);
ans = max(ans, f[i]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const double EPS = 1e-13;
double pre[100005], suf[100005];
pair<double, double> ans[100005];
pair<double, double> getsol(double xy, double rxy) {
double a = -1.0, b = xy + 1.0 - rxy, c = -xy;
double d = sqrt(b * b - a * c * 4.0 + EPS);
return make_pair((-b - d) / (a + a), (-b + d) / (a + a));
}
int main() {
int n;
scanf("%d", &n);
for (int k = 0; k < (n); k++) scanf("%lf", &pre[k]);
for (int k = 1; k < n; k++) pre[k] += pre[k - 1];
for (int k = 0; k < (n); k++) scanf("%lf", &suf[k]);
for (int k = n - 2; k >= 0; k--) suf[k] += suf[k + 1];
for (int k = 0; k < (n - 1); k++) ans[k] = getsol(pre[k], suf[k + 1]);
ans[n - 1].first = 1.0;
ans[n - 1].second = 1.0;
for (int k = n - 2; k >= 0; k--) {
ans[k + 1].first -= ans[k].first;
ans[k + 1].second -= ans[k].second;
}
for (int k = 0; k < (n); k++)
printf("%.7lf%c", ans[k].second, k == n - 1 ? '\n' : ' ');
for (int k = 0; k < (n); k++)
printf("%.7lf%c", ans[k].first, k == n - 1 ? '\n' : ' ');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> lps(string& str) {
int n = str.size();
vector<int> ans(n + 1);
int i = 1;
int l = 0;
while (i < n) {
if (str[i] == str[l]) {
ans[++i] = ++l;
continue;
}
if (l > 0) {
l = ans[l];
continue;
}
ans[++i] = 0;
}
return ans;
}
vector<int> z_alg(string& s) {
int n = s.size();
int l = 0;
int r = 0;
vector<int> z(n);
for (int i = 1; i < n; i++) {
if (i < r) z[i] = min(r - i, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] > r) {
r = i + z[i];
l = i;
}
}
return z;
}
vector<int> sub_counter(string& s, string& t) {
int nt = t.size();
int ns = s.size();
vector<int> match(nt);
vector<int> psv = lps(t);
int j = 0;
for (int i = 1; i < ns; i++) {
if (j == nt - 1) j = psv[j];
while (j > 0 && s[i] != t[j]) j = psv[j];
if (s[i] == t[j]) j++;
match[j]++;
}
for (int i = nt - 1; i > 0; i--) match[psv[i]] += match[i];
return match;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
vector<int> lps_t = lps(t);
vector<int> match = sub_counter(s, t);
long long acc = 0;
for (int i = 1; i <= (int)t.size(); i++) {
acc += s.size();
if (lps_t[i] > 0 && i - lps_t[i] < (int)s.size()) {
acc -= match[i - lps_t[i]];
}
}
cout << acc << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int N = rand() % 1141;
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n << "\n";
for (int i = 1; i <= n; i++) cout << i << " ";
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, x1, y1, r;
cin >> r >> x >> y >> x1 >> y1;
int d = 2 * r;
if (x == x1 && y == y1) {
cout << "0\n";
return 0;
}
float a = x1 - x;
float b = y1 - y;
float p = sqrt(a * a + b * b);
int m = sqrt(a * a + b * b);
if (p < d) {
cout << "1";
return 0;
} else {
if (p > m) {
cout << m / d + 1;
} else {
if (m % d == 0) {
cout << m / d;
} else {
cout << m / d + 1;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 100;
const long long int mod = 1e9 + 7;
long long int dx[] = {1, -1, 0, 0};
long long int dy[] = {0, 0, 1, -1};
long long int a[N];
long long int n, x, k;
long long int func(long long int val) {
long long int low = 1;
long long int high = n;
long long int ans = n + 1;
while (low <= high) {
long long int mid = (low + high) >> 1;
if (a[mid] >= val) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
long long int func2(long long int ind) {
long long int low = ind;
long long int high = n;
long long int upper = -1, lower;
while (low <= high) {
long long int mid = (low + high) >> 1;
long long int u = a[mid] / x;
long long int v = (a[ind] - 1) / x;
long long int y = u - v;
if (y > k) {
high = mid - 1;
} else {
if (y == k) {
upper = mid;
}
low = mid + 1;
}
}
low = ind;
high = n;
while (low <= high) {
long long int mid = (low + high) >> 1;
long long int u = a[mid] / x;
long long int v = (a[ind] - 1) / x;
long long int y = u - v;
if (y < k) {
low = mid + 1;
} else {
if (y == k) {
lower = mid;
}
high = mid - 1;
}
}
if (upper == -1) return 0;
return upper - lower + 1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> x >> k;
for (long long int i = 1; i < n + 1; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long int ans = 0;
for (long long int i = 1; i < n + 1; i++) {
long long int index = func(a[i]);
long long int range = func2(index);
ans += range;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long int n, s;
scanf("%I64d", &n);
if (n < 3)
printf("%I64d", n);
else {
if (n % 2 == 0) {
if (n % 3 != 0)
printf("%I64d", n * (n - 1) * (n - 3));
else
printf("%I64d", (n - 1) * (n - 2) * (n - 3));
} else
printf("%I64d", n * (n - 1) * (n - 2));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long my_pow(long long x) { return x * x * x; }
long long steps(long long m) {
if (m <= 7) return m;
long long x = 1;
while (my_pow(x + 1) <= m) ++x;
return 1 + steps(max(m - my_pow(x), my_pow(x) - 1 - my_pow(x - 1)));
}
int main() {
long long m;
scanf("%lld", &m);
long long subtracted = 0, steps_so_far = 0;
while (m) {
++steps_so_far;
long long x = 1;
while (my_pow(x + 1) <= m) ++x;
if (steps(m) == 1 + steps(m - my_pow(x))) {
m -= my_pow(x);
subtracted += my_pow(x);
} else {
m = my_pow(x) - 1 - my_pow(x - 1);
subtracted += my_pow(x - 1);
}
}
printf("%lld %lld\n", steps_so_far, subtracted);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, ans, n;
n = 3;
int ar[n];
for (i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
if (ar[0] + ar[1] > ar[2]) {
cout << 0 << "\n";
} else {
ans = ar[2] - (ar[0] + ar[1]);
cout << ans + 1 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int tc, cs = 1;
int n, Max, r;
int p[100005], s[100005], d[100005], l[100005];
int e[100005][2];
bool col[100005];
vector<int> V[100005];
void bfs(int st) {}
int main() {
int u, v;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
d[u]++;
d[v]++;
Max = max(Max, d[u]);
Max = max(Max, d[v]);
V[u].push_back(v);
V[v].push_back(u);
e[i][0] = u;
e[i][1] = v;
}
for (int i = 1; i <= n; i++)
if (d[i] == Max) {
r = i;
break;
}
col[r] = true;
p[r] = r;
l[r] = 0;
for (int i = 1; i <= Max; i++) {
int cn = V[r][i - 1];
int cp = r, ad;
while (1) {
col[cn] = true;
s[cn] = i;
p[cn] = r;
l[cn] = l[cp] + 1;
cp = cn;
if (d[cn] == 1) break;
for (int j = V[cn].size() - 1; j >= 0; j--)
if (!col[V[cn][j]]) ad = V[cn][j];
cn = ad;
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int t, en;
scanf("%d", &t);
if (t == 3) {
scanf("%d%d", &u, &v);
if (p[u] != p[v])
printf("-1\n");
else if (r == u)
printf("%d\n", l[v]);
else if (v == r)
printf("%d\n", l[u]);
else if (s[u] == s[v])
printf("%d\n", abs(l[u] - l[v]));
else
printf("%d\n", l[u] + l[v]);
} else if (t == 2) {
scanf("%d", &en);
u = e[en][0];
v = e[en][1];
if (l[u] > l[v]) {
int cn = u;
int rp = p[cn];
while (p[cn] == rp) {
p[cn] = u;
if (d[cn] == 1) break;
for (int j = V[cn].size() - 1; j >= 0; j--)
if (l[V[cn][j]] > l[cn]) {
cn = V[cn][j];
break;
}
}
} else {
int cn = v;
int rp = p[cn];
while (p[cn] == rp) {
p[cn] = v;
if (d[cn] == 1) break;
for (int j = V[cn].size() - 1; j >= 0; j--)
if (l[V[cn][j]] > l[cn]) {
cn = V[cn][j];
break;
}
}
}
} else {
scanf("%d", &en);
u = e[en][0];
v = e[en][1];
if (l[u] > l[v]) {
int cn = u;
int rp = p[cn];
while (p[cn] == rp) {
p[cn] = p[v];
if (d[cn] == 1) break;
for (int j = V[cn].size() - 1; j >= 0; j--)
if (l[V[cn][j]] > l[cn]) {
cn = V[cn][j];
break;
}
}
} else {
int cn = v;
int rp = p[cn];
while (rp == p[cn]) {
p[cn] = p[u];
if (d[cn] == 1) break;
for (int j = V[cn].size() - 1; j >= 0; j--)
if (l[V[cn][j]] > l[cn]) {
cn = V[cn][j];
break;
}
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 1 || n == 2) {
cout << 1 << endl;
} else {
cout << (n - 1) / 2 + 1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, c = 0, d, g = 0;
cin >> n;
vector<int> v;
d = n;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j < v.size(); j++) {
if (v[i] == v[j]) {
c++;
v.erase(v.begin() + j);
j--;
}
}
if (c > g) g = c;
c = 0;
}
cout << g + 1 << " " << v.size() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T Pow(T a, T b, T p) {
T ret = 1;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) (ret *= a) %= p;
return ret;
}
template <class T>
inline void read(T &ret) {
T x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
ret = x * f;
}
const int N = 1010, M = 502 * 500 * 2 * 2 + 10;
struct edge {
int v, nxt;
long long w, cap;
} g[M];
int head[N], sz = 1;
void __add(int u, int v, long long w, long long cap) {
g[++sz] = {v, head[u], w, cap};
head[u] = sz;
}
void add(int u, int v, long long w, long long cap) {
__add(u, v, w, cap);
__add(v, u, -w, 0);
}
namespace flow {
int q[N], pre[N];
long long d[N];
bool inq[N];
bool spfa(int s, int dest) {
fill(d, d + dest + 1, (long long)0x3f3f3f3f);
fill(pre, pre + dest + 1, 0);
q[0] = s;
d[s] = 0;
inq[s] = 1;
for (int h = 0, t = 1, u, v; h != t; h = (h + 1) % N, inq[u] = 0)
for (int i = head[u = q[h]]; i; i = g[i].nxt)
if (g[i].cap && d[v = g[i].v] > d[u] + g[i].w) {
d[v] = d[u] + g[i].w;
pre[v] = i;
if (!inq[v]) inq[v] = 1, q[t++] = v, t %= N;
}
return d[dest] != (long long)0x3f3f3f3f;
}
long long mf(int s, int t) {
long long ret = 0, max_s = 0;
while (spfa(s, t)) {
long long tmp = (long long)0x3f3f3f3f, sum = 0;
for (int i = pre[t]; i; i = pre[g[i ^ 1].v])
tmp = min(tmp, g[i].cap), sum += g[i].w;
ret += tmp * sum;
max_s = min(ret, max_s);
for (int i = pre[t]; i; i = pre[g[i ^ 1].v])
g[i].cap -= tmp, g[i ^ 1].cap += tmp;
}
return max_s;
}
} // namespace flow
int n;
long long a[N], b[N], k[N];
long long mat[N][N];
namespace km {
bool vis_x[N], vis_y[N];
long long lx[N], ly[N], slack[N];
int match[N];
bool dfs(int u) {
vis_x[u] = 1;
for (int v = (1); v <= (n); v++) {
if (vis_y[v]) continue;
long long tmp = lx[u] + ly[v] - mat[u][v];
if (tmp == 0) {
vis_y[v] = 1;
if (match[v] == -1 || dfs(match[v])) {
match[v] = u;
return true;
}
} else
slack[v] = min(slack[v], tmp);
}
return false;
}
long long solv() {
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) lx[i] = max(lx[i], mat[i][j]);
fill(ly + 1, ly + n + 1, 0);
fill(match + 1, match + n + 1, -1);
for (int u = (1); u <= (n); u++) {
fill(slack, slack + n + 1, (long long)0x3f3f3f3f);
for (;;) {
fill(vis_x, vis_x + n + 1, 0);
fill(vis_y, vis_y + n + 1, 0);
if (dfs(u)) break;
long long delta = (long long)0x3f3f3f3f;
for (int v = (1); v <= (n); v++)
if (!vis_y[v]) delta = min(delta, slack[v]);
for (int i = (1); i <= (n); i++)
if (vis_x[i]) lx[i] -= delta;
for (int i = (1); i <= (n); i++)
if (vis_y[i])
ly[i] += delta;
else
slack[i] += delta;
}
}
long long ret = 0;
for (int v = (1); v <= (n); v++) ret += mat[match[v]][v];
return ret;
}
} // namespace km
namespace other {
const int maxn = N;
long long match[maxn], lx[maxn], ly[maxn], slack[maxn];
long long G[maxn][maxn];
bool visx[maxn], visy[maxn];
long long nx, ny, ans;
bool findpath(int x) {
int tempDelta;
visx[x] = true;
for (int y = 0; y < ny; ++y) {
if (visy[y]) continue;
tempDelta = lx[x] + ly[y] - G[x][y];
if (tempDelta == 0) {
visy[y] = true;
if (match[y] == -1 || findpath(match[y])) {
match[y] = x;
return true;
}
} else if (slack[y] > tempDelta)
slack[y] = tempDelta;
}
return false;
}
void KM() {
for (int x = 0; x < nx; ++x) {
for (int j = 0; j < ny; ++j) slack[j] = (long long)0x3f3f3f3f;
while (true) {
memset(visx, false, sizeof(visx));
memset(visy, false, sizeof(visy));
if (findpath(x))
break;
else {
long long delta = (long long)0x3f3f3f3f;
for (int j = 0; j < ny; ++j)
if (!visy[j] && delta > slack[j]) delta = slack[j];
for (int i = 0; i < nx; ++i)
if (visx[i]) lx[i] -= delta;
for (int j = 0; j < ny; ++j) {
if (visy[j])
ly[j] += delta;
else
slack[j] -= delta;
}
}
}
}
}
long long solve() {
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) G[i - 1][j - 1] = mat[i][j];
nx = ny = n;
memset(match, -1, sizeof(match));
memset(ly, 0, sizeof(ly));
for (int i = 0; i < nx; ++i) {
lx[i] = -(long long)0x3f3f3f3f;
for (int j = 0; j < ny; ++j)
if (lx[i] < G[i][j]) lx[i] = G[i][j];
}
KM();
long long ret = 0;
for (int i = (0); i <= (n - 1); i++) ret += G[match[i]][i];
return ret;
}
} // namespace other
int main() {
read(n);
for (int i = (1); i <= (n); i++) read(a[i]), read(b[i]), read(k[i]);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
mat[i][j] = max((long long)0, a[i] - min((long long)j - 1, k[i]) * b[i]);
printf("%lld\n", km::solv());
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, d;
cin >> a >> b >> c >> d;
double p = 1.0;
p = p * a / b;
double q = 1.0;
q = q * (1 - (c / d)) * (1 - (a / b));
long double ans = (p / (1 - q));
cout << fixed << setprecision(15) << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int mid = (n + 1) / 2;
int po = 0, ne = 0;
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
if (t > 0)
po++;
else if (t < 0)
ne++;
}
if (po >= mid)
printf("1\n");
else if (ne >= mid)
printf("-1\n");
else
printf("0\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool ok(long long F, long long N) { return (3ll * F * (F + 1) / 2 - F <= N); }
int main() {
long long N, l, r;
scanf("%I64d", &N);
l = 1;
r = 1e6;
while (l <= r - 1) {
if (l == r - 1) {
if (ok(r, N)) {
break;
} else {
r = l;
break;
}
}
long long mid = (l + r) / 2;
if (ok(mid, N)) {
l = mid;
} else {
r = mid;
}
}
long long nb = r;
for (long long i = 1; i <= r; i++) {
if ((N + i) % 3 != 0) nb--;
}
printf("%I64d\n", nb);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > co[55];
vector<long long int> s;
long long int n, x[55], y[55], a[55], b[55];
long long int distance(pair<long long int, long long int> firstone,
pair<long long int, long long int> secondone) {
return (firstone.first - secondone.first) *
(firstone.first - secondone.first) +
(firstone.second - secondone.second) *
(firstone.second - secondone.second);
}
bool check(long long int i, long long int j, long long int k, long long int l) {
long long int d1, d2, d3;
s.clear();
d1 = distance(co[0][i], co[1][j]);
d2 = distance(co[0][i], co[2][k]);
d3 = distance(co[0][i], co[3][l]);
s.push_back(d1);
s.push_back(d2);
s.push_back(d3);
d1 = distance(co[3][l], co[1][j]);
d2 = distance(co[3][l], co[2][k]);
d3 = distance(co[1][j], co[2][k]);
s.push_back(d1);
s.push_back(d2);
s.push_back(d3);
sort(s.begin(), s.end());
if ((s[0] == s[1] && s[0] == s[2] && s[0] == s[3]) && (s[4] == s[5]) &&
(2 * s[0] == s[4]) && s[0] != 0)
return true;
return false;
}
void solve() {
long long int i, j, k, l, m, ans = 9223372036854775807;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++) {
for (l = 0; l < 4; l++) {
if (check(i, j, k, l)) {
ans = min(ans, i + j + k + l);
}
}
}
}
}
if (ans == 9223372036854775807)
cout << -1 << '\n';
else
cout << ans << '\n';
return;
}
int main() {
long long int i, j, tempx, tempy;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
while (n--) {
for (i = 0; i < 4; i++) {
cin >> x[i] >> y[i] >> a[i] >> b[i];
co[i].clear();
co[i].push_back(make_pair(x[i], y[i]));
}
for (i = 0; i < 4; i++) {
tempx = x[i] - a[i];
tempy = y[i] - b[i];
while (co[i].size() < 4) {
x[i] = -tempy;
y[i] = tempx;
co[i].push_back(make_pair(x[i] + a[i], y[i] + b[i]));
tempx = x[i];
tempy = y[i];
}
}
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = (int)1e5 + 100;
const int MAX = (int)1e5 + 1;
int l[maxN], d[maxN], cnt[maxN], q[maxN];
vector<int> pool[maxN];
multiset<int> p;
void solveTask() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> l[i];
for (int i = 1; i <= n; ++i) cin >> d[i];
for (int i = 1; i <= n; ++i)
q[l[i]] += d[i], cnt[l[i]] += 1, pool[l[i]].push_back(d[i]);
int answer = 0;
int all_sum = 0;
for (int i = 1; i <= MAX; ++i) {
if (cnt[i] == 0) continue;
int possibleCnt = cnt[i] - 1;
int cur_sum = 0;
for (set<int>::iterator it = p.begin(); it != p.end(); ++it) {
if (possibleCnt == 0) break;
cur_sum -= *it;
--possibleCnt;
}
answer = max(answer, cur_sum + q[i]);
all_sum += q[i];
for (int j = 0; j < pool[i].size(); ++j) {
p.insert(-pool[i][j]);
}
}
cout << all_sum - answer << endl;
}
int main() {
solveTask();
ios_base::sync_with_stdio(false);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sz[200005];
int bd[200005];
int mn, res;
int n, k;
int a[200005];
vector<int> v[200005];
void dfs(int x, int y) {
sz[x] = 1;
bd[x] = (a[x] < mn ? 1 : 0);
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i];
if (to == y) continue;
dfs(to, x);
sz[x] += sz[to];
bd[x] += bd[to];
}
}
int solve(int x, int y) {
int kolgood = 0;
int mx1 = 0, mx2 = 0;
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i];
if (to == y) continue;
int q = solve(to, x);
if (bd[to] == 0)
kolgood += q;
else {
if (q > mx2) {
mx2 = q;
if (mx2 > mx1) swap(mx1, mx2);
}
}
}
if (a[x] < mn) return 0;
int res2 = 1 + kolgood + mx1 + mx2 + (bd[1] - bd[x] == 0 ? sz[1] - sz[x] : 0);
res = max(res, res2);
return kolgood + mx1 + 1;
}
inline bool f(int mid) {
mn = mid;
dfs(1, -1);
res = 0;
solve(1, -1);
return (res >= k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int l = 0;
int r = 1e9;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (f(mid))
l = mid;
else
r = mid - 1;
}
cout << l;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d", &n);
int ar[n + 2];
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
sort(ar + 1, ar + n + 1);
int cnt = 0;
for (int i = n; i >= 1; i--) {
if (i >= ar[i]) {
cnt = i;
break;
}
}
cout << cnt + 1 << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char rs[20];
int main() {
int a, b, k, m, f = 0, ans = 1;
cin >> a >> b >> k;
m = 1000000000 % k;
if (b + 1 >= k || m == 0 || a == 0)
cout << "2";
else {
while (ans <= min(a, k)) {
if ((long long)ans * m % k < k - b &&
(long long)ans * 1000000000 % k != 0) {
f = 1;
break;
}
ans++;
}
if (f) {
cout << "1" << ' ';
sprintf(rs, "%d", ans);
k = strlen(rs);
for (int i = 0; i < 9 - k; i++) cout << "0";
cout << rs;
} else
cout << "2";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<long long int> s[100005];
long long int d[100005];
vector<char> prime(100000 + 1, true);
void sieve(long long int n) {
prime[0] = prime[1] = false;
for (long long int i = 2; i <= n; ++i) {
if (prime[i]) {
s[i].insert(i);
for (long long int j = 2 * i; j <= n; j += i) {
prime[j] = false;
s[j].insert(i);
}
}
}
}
void init(long long int ar[], long long int n, long long int val) {
long long int i;
for (i = 0; i < n; i++) {
ar[i] = val;
}
}
long long int search1(vector<long long int> &v, long long int f) {
long long int left = 0;
long long int right = v.size() - 1;
while (left < right) {
long long int mid = left + (right - left + 1) / 2;
if (v[mid] <= f) {
left = mid;
} else
right = mid - 1;
}
return left;
}
int main() {
long long int n, k, i, j;
cin >> n;
long long int dp[n + 1][10];
for (i = 0; i <= n; i++) {
for (j = 0; j < 10; j++) {
dp[i][j] = -1000000000000000000;
}
}
dp[0][0] = 0;
long long int t = n;
for (i = 1; i <= n; i++) {
cin >> k;
long long int c1, d;
long long int a1 = 0, a2 = 0, a3 = 0, b = 0, c = 0;
for (j = 0; j < k; j++) {
cin >> c1 >> d;
if (c1 == 2) {
b = max(b, d);
} else if (c1 == 3) {
c = max(c, d);
} else {
if (d >= a1) {
a3 = a2;
a2 = a1;
a1 = d;
} else if (d >= a2) {
a3 = a2;
a2 = d;
} else if (d >= a3) {
a3 = d;
}
}
}
long long int maxs = max(a1, b);
long long int mins = min(a1, b);
if (i == 1) {
dp[1][0] = 0;
if (c != 0) {
dp[1][1] = max(c, dp[1][1]);
}
if (a1 != 0) {
dp[1][1] = max(dp[1][1], a1);
}
if (b != 0) {
dp[1][1] = max(dp[1][1], b);
}
if (a1 != 0 && b != 0) {
dp[1][2] = max(dp[1][2], maxs + mins);
}
if (a2 != 0) {
dp[1][2] = max(a1 + a2, dp[1][2]);
}
if (a3 != 0) {
dp[1][3] = a1 + a2 + a3;
}
continue;
}
for (j = 0; j < 10; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
long long int val = c;
if (j == 0) val += c;
if (c != 0) dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
if (a3 != 0) {
val = a1 + a2 + a3;
if (j < 3) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 3 + 10) % 10]);
}
if (a2 != 0) {
val = a1 + a2;
if (j < 2) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 2 + 10) % 10]);
}
if (a1 != 0) {
val = a1;
if (j < 1) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
}
if (b != 0) {
val = b;
if (j < 1) val += b;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
}
if (maxs != 0 && mins != 0) {
val = maxs + mins;
if (j < 2) val += maxs;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 2 + 10) % 10]);
}
}
}
cout << *max_element(dp[n], dp[n] + 10) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[2000000], s1[2000000];
int t[2000000], t1[2000000];
int n, m, T;
int f[2000000 * 2], g[2000000 * 2];
void build(char* S, int* f, int* t, int l, int r, int s) {
if (l == r) {
f[s] = (S[l] == 'B' || S[l] == 'C');
if (!f[s]) t[s] = 1;
return;
}
build(S, f, t, l, (l + r) / 2, s + s),
build(S, f, t, (l + r) / 2 + 1, r, s + s + 1);
f[s] = (f[s + s] + f[s + s + 1]);
if (t[s + s + 1] == r - (l + r) / 2)
t[s] = t[s + s + 1] + t[s + s];
else
t[s] = t[s + s + 1];
}
int get(int* f, int* t, int l, int r, int s, int ll, int rr, int& v) {
if (r < ll || rr < l) return 0;
if (ll <= l && r <= rr) {
if (v == rr - r) v += t[s];
return f[s];
}
int s1 = get(f, t, (l + r) / 2 + 1, r, s + s + 1, ll, rr, v);
return s1 + get(f, t, l, (l + r) / 2, s + s, ll, rr, v);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%s", s1 + 1);
m = strlen(s1 + 1);
build(s, f, t, 1, n, 1);
build(s1, g, t1, 1, m, 1);
scanf("%d", &T);
while (T--) {
int l, r, l1, r1;
scanf("%d %d %d %d", &l, &r, &l1, &r1);
int u1 = 0, u2 = 0;
int v1 = get(f, t, 1, n, 1, l, r, u1), v2 = get(g, t1, 1, m, 1, l1, r1, u2);
if (u2 > u1) {
printf("0");
continue;
}
if (!v1 && v2 && u1 == u2) {
printf("0");
continue;
}
u1 = (u1 - u2) % 3 + u2;
if (u1 - u2) {
v1 += 2;
u1 = u2;
}
u1 %= 3, u2 %= 3;
while (u1 != u2) (u1 += 1) %= 3, v1 += 2;
v1 <= v2 && (v1 & 1) == (v2 & 1) ? printf("1") : printf("0");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int solve(long long int a, long long int b, long long int x) {
if (a <= 0 || b <= 0) return x;
if (a >= b)
return solve(a % b, b, x + (a / b));
else
return solve(a, b % a, x + (b / a));
}
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
cout << solve(a, b, 0) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << -1 << endl;
return 0;
}
if (n == 2 && a[0] == a[1]) {
cout << -1 << endl;
return 0;
}
int ans = 10000000;
int ind = 0;
for (int i = 0; i < n; i++) {
if (a[i] < ans) {
ans = a[i];
ind = i + 1;
}
}
cout << 1 << endl;
cout << ind << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int z = 200100;
int arr[2 * z];
int get(int x, int y) {
if (x > y) return 0;
if (x == y) return arr[x];
if (x % 2 == 1) return arr[x] + get(x + 1, y);
if (y % 2 == 0) return arr[y] + get(x, y - 1);
return get(x / 2, y / 2);
}
void inc(int x) {
while (x) {
arr[x]++;
x /= 2;
}
}
void init() {
for (int i = 0; i < 2 * z; i++) arr[i] = 0;
}
int main() {
init();
int n;
scanf("%d", &n);
int *b = new int[n];
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
inc(z + b[i]);
b[i] -= get(z, z + b[i] - 1);
}
init();
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
inc(z + x);
x -= get(z, z + x - 1);
b[i] += x;
}
for (int i = n - 1; i > 0; i--)
if (b[i] >= n - i) {
b[i] -= n - i;
b[i - 1]++;
}
b[0] %= n;
init();
for (int i = 0; i < n; i++) {
int l = b[i] - 1;
int r = n - 1;
while (r - l > 1) {
int c = (l + r) / 2;
if (c - get(z, z + c) >= b[i])
r = c;
else
l = c;
}
inc(z + r);
printf("%d ", r);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> tab[2001];
int ai[2001];
long long int p = 1000000007;
long long int f(int nr, int max, int min, int rodzic, int i) {
long long int wynik = 1;
set<int>::iterator it;
for (it = tab[nr].begin(); it != tab[nr].end(); ++it) {
if (rodzic != *it && ai[*it] <= max && ai[*it] > min)
wynik = (wynik * (1ll + f(*it, max, min, nr, i))) % p;
if (rodzic != *it && ai[*it] == min && i < *it)
wynik = (wynik * (1ll + f(*it, max, min, nr, i))) % p;
}
return wynik;
}
int main() {
int d, n;
scanf("%d%d", &d, &n);
for (int i = 1; i <= n; i++) scanf("%d", &ai[i]);
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
tab[a].insert(b);
tab[b].insert(a);
}
long long int suma = 0;
for (int i = 1; i <= n; i++) {
suma = (p + suma + f(i, ai[i] + d, ai[i], -1, i)) % p;
}
cout << suma;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<pair<pair<long long, long long>, long long> > se;
set<pair<pair<long long, long long>, long long> >::iterator it;
int main() {
long long a, b, c, n, num = 0, cost = 0;
cin >> a >> b >> c;
cin >> n;
for (int i = 1; i <= n; i++) {
long long val;
char cc[10];
scanf("%lld", &val);
scanf("%s", cc);
if (cc[0] == 'U')
se.insert(pair<pair<long long, long long>, long long>(
pair<long long, long long>(val, 0), i));
else
se.insert(pair<pair<long long, long long>, long long>(
pair<long long, long long>(val, 1), i));
}
while ((int)se.size() != 0) {
it = se.begin();
pair<pair<long long, long long>, long long> front = *it;
se.erase(*it);
if (front.first.second == (long long)0) {
if (a > (long long)0) {
a--;
cost += front.first.first;
num++;
} else {
if (c > (long long)0) {
c--;
cost += front.first.first;
num++;
}
}
} else {
if (b > (long long)0) {
b--;
cost += front.first.first;
num++;
} else {
if (c > (long long)0) {
c--;
cost += front.first.first;
num++;
}
}
}
}
cout << num << " " << cost;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 123;
int test;
string s;
int n;
const int md = 1e9 + 7;
void ReadData() {
cin >> test;
cin >> s;
}
int pwr(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1LL * res * a % md;
a = 1LL * a * a % md;
n >>= 1;
}
return res;
}
int inv(int x) { return pwr(x, md - 2); }
int frac[maxn];
map<int, vector<pair<int, int> > > query;
int m;
int res[maxn];
int dp[maxn];
int pw25[maxn];
int invFrac[maxn];
void Init() {
frac[0] = 1;
for (int i = 1; i <= 100000; i++) frac[i] = 1LL * frac[i - 1] * i % md;
for (int i = 0; i <= 100000; i++) invFrac[i] = inv(frac[i]);
pw25[0] = 1;
for (int i = 1; i <= 100000; i++) pw25[i] = 1LL * pw25[i - 1] * 25 % md;
}
int Com(int n, int k) {
return 1LL * frac[n] * invFrac[k] % md * invFrac[n - k] % md;
}
void do_add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
void Solve(int len) {
vector<pair<int, int> > &a = query[len];
memset(dp, 0, sizeof(dp));
dp[len] = 1;
int mx = 0;
for (int i = 0; i < a.size(); i++) mx = max(mx, a[i].first);
for (int i = len + 1; i <= mx; i++) {
dp[i] = 1LL * dp[i - 1] * 26 % md;
int cur = 1LL * Com(i - 1, len - 1) * pw25[i - len] % md;
do_add(dp[i], cur);
}
for (int i = 0; i < a.size(); i++) res[a[i].second] = dp[a[i].first];
}
void Process() {
Init();
while (test--) {
int type;
cin >> type;
if (type == 1) {
cin >> s;
}
if (type == 2) {
int n;
cin >> n;
query[((int)s.size())].push_back(make_pair(n, ++m));
}
}
for (map<int, vector<pair<int, int> > >::iterator it = query.begin();
it != query.end(); ++it) {
Solve(it->first);
}
for (int i = 1; i <= m; i++) cout << res[i] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ReadData();
Process();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long m, k, n, s;
long long ar[500005], br[500005];
long long need[500005];
long long cur[500005], diff;
int main() {
cin >> m >> k >> n >> s;
for (int i = 1; i < m + 1; i++) cin >> ar[i];
for (int i = 0; i < s; i++) {
long long x;
cin >> x;
need[x]++;
}
for (int i = 0; i < 500005; i++) {
if (need[i]) diff++;
}
long long l = 1, r = 0;
while (l <= m) {
while (diff && r < m) {
r++;
long long ele = ar[r];
cur[ele]++;
if (need[ele] && cur[ele] == need[ele]) diff--;
}
if ((l - 1) % k == 0 && !diff && 1 + (l - 1) / k + (m - r) / k >= n) {
long long tot = r - l + 1 - k;
if (tot < 0) {
printf("0");
return 0;
} else {
printf("%lld\n", tot);
for (int i = l; i < r + 1; i++) {
long long ele = ar[i];
if (cur[ele] > need[ele] && tot) {
tot--;
cur[ele]--;
printf("%d ", i);
}
}
return 0;
}
}
long long ele = ar[l];
cur[ele]--;
if (need[ele] && cur[ele] == need[ele] - 1) diff++;
l++;
}
printf("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x(0), f(1);
char c(getchar());
while (c < '0' || '9' < c) {
if (c == '-') {
f = -1;
}
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return f * x;
}
void Write(int x) {
if (x < 0) {
printf("-");
x = -x;
}
if (9 < x) {
Write(x / 10);
}
putchar(x % 10 + '0');
}
inline void Writeln(int x) {
Write(x);
puts("");
}
const int MAXN = 5e5 + 5;
const int MAXM = MAXN << 1;
int n, m;
char val[MAXN];
int sum[MAXN];
struct Query {
int deep, id;
Query(int deep, int id) : deep(deep), id(id) {}
};
vector<Query> query[MAXN];
struct Edge {
int to, next;
} edge[MAXM];
int edge_head[MAXN];
int edge_cnt = 0;
void AddEdge(int form, int to) {
edge[++edge_cnt].to = to;
edge[edge_cnt].next = edge_head[form];
edge_head[form] = edge_cnt;
}
int son[MAXN];
int size[MAXN];
int deep[MAXN];
bool Check(int a) { return a == (a & -a); }
void DFS_1(int now = 1, int father = 0) {
deep[now] = deep[father] + 1;
size[now] = 1;
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ father) {
DFS_1(edge[edge_i].to, now);
size[now] += size[edge[edge_i].to];
if (size[son[now]] < size[edge[edge_i].to]) {
son[now] = edge[edge_i].to;
}
}
}
}
int im_son;
int answer[MAXN];
void Add(int now, int father) {
sum[deep[now]] ^= 2 << (val[now] - 'a');
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ father && edge[edge_i].to ^ im_son) {
Add(edge[edge_i].to, now);
}
}
}
void Delete(int now, int father, bool flag = 1) {
sum[deep[now]] ^= 2 << (val[now] - 'a');
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ father && edge[edge_i].to ^ im_son) {
Delete(edge[edge_i].to, now, 0);
}
}
}
void DFS_2(int now = 1, int father = 0, int opt = 0) {
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ father && edge[edge_i].to ^ son[now]) {
DFS_2(edge[edge_i].to, now, 1);
}
}
if (son[now]) {
DFS_2(son[now], now, 0);
}
im_son = son[now];
Add(now, father);
if (query[now].size()) {
for (int i = 0; i <= query[now].size() - 1; ++i) {
answer[query[now][i].id] = Check(sum[query[now][i].deep]);
}
}
im_son = 0;
if (opt) {
Delete(now, father);
}
}
int main() {
scanf("%d%d", &n, &m);
int father;
for (int i = 2; i <= n; ++i) {
scanf("%d", &father);
AddEdge(father, i);
}
scanf("%s", val + 1);
int u, deep;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &deep);
query[u].push_back(Query{deep, i});
}
DFS_1();
DFS_2();
for (int i = 1; i <= m; ++i) {
if (answer[i]) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 100005;
std::map<int, int> rec[N];
std::set<int> adj[N];
int n, m, c, q, f[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void _union(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (adj[x].size() > adj[y].size()) std::swap(x, y);
f[x] = y;
for (int p : adj[x]) adj[y].insert(p);
}
void link(int x, int y, int c) {
if (rec[x].count(c))
_union(rec[x][c], y);
else
rec[x][c] = y;
if (rec[y].count(c))
_union(rec[y][c], x);
else
rec[y][c] = x;
adj[find(x)].insert(y);
adj[find(y)].insert(x);
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m >> c >> q;
for (int i = 1; i <= n; ++i) f[i] = i, adj[i].insert(i);
for (int i = 0, x, y, c; i < m; ++i) std::cin >> x >> y >> c, link(x, y, c);
while (q--) {
char opt;
int x, y, c;
std::cin >> opt >> x >> y;
if (opt == '?')
std::cout << (adj[find(x)].count(y) ? "Yes" : "No") << '\n';
else
std::cin >> c, link(x, y, c);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> v(n);
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> v[i];
mp[v[i] % m]++;
}
long long f = 0;
if (n > m) f = 1;
for (auto i : mp) {
if (i.second > 1) {
f = 1;
break;
}
}
if (f) {
cout << 0;
return 0;
}
long long ans = 1;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) ans *= abs(v[i] - v[j]), ans %= m;
}
cout << (ans % m + m) % m;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool cus(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return true;
if (a.first > b.first) return false;
return a.second < b.second;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n, m, A;
long long cpow(long long a, long long b) {
long long rslt = 1;
while (b > 0) {
if (b & 1) rslt = (rslt * a % 998244353) % 998244353;
b = b >> 1;
a = (a % 998244353 * a % 998244353) % 998244353;
}
return rslt % 998244353;
}
long long cnti(long long l) {
return ((cpow(A, 2 * l) + cpow(A, l)) % 998244353 * (cpow(2, 998244353 - 2)) %
998244353) %
998244353;
}
void solve() {
cin >> n >> m >> A;
vector<long long> b(m);
for (long long i = 0, _n = (m); i < _n; i++) cin >> b[i];
long long ans = cpow(A, n - 2 * b[m - 1]);
ans = (ans * cnti(b[0])) % 998244353;
for (long long i = (1), _b = (m - 1); i <= _b; i++) {
ans = (ans * cnti(b[i] - b[i - 1])) % 998244353;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(11);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
set<pair<long long, int> > num;
int ans[maxn];
typedef struct node {
long long l, r;
int pos;
} Node;
Node p[maxn];
bool cmp(Node a, Node b) {
if (a.r == b.r)
return a.l < b.l;
else
return a.r < b.r;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &p[i].l, &p[i].r);
}
for (int i = 1; i < n; i++) {
long long tl = p[i].l, tr = p[i].r;
p[i].r = p[i + 1].r - tl;
p[i].l = p[i + 1].l - tr;
p[i].pos = i;
}
sort(p + 1, p + n, cmp);
for (int i = 1; i <= m; i++) {
long long tem;
scanf("%lld", &tem);
num.insert(make_pair(tem, i));
}
int flag = 0;
for (int i = 1; i < n; i++) {
set<pair<long long, int> >::iterator it;
it = num.lower_bound(make_pair(p[i].l, 0));
if (it == num.end() || (it->first) > p[i].r) {
flag = 1;
break;
}
ans[p[i].pos] = (it->second);
num.erase(it);
}
if (flag)
puts("No");
else {
puts("Yes");
for (int i = 1; i < n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
using namespace std;
void solve();
signed main() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
const long long MOD = 998244353, MAXN = 3e6 + 10, INF = 1e9 + 10, BASE = 37;
void solve() {
long long n;
cin >> n;
vector<long long> a(n + 1);
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
a[i] = a[i - 1] + a[i];
}
map<long long, vector<long long>> mp;
for (long long i = 0; i <= n; ++i) {
mp[a[i]].push_back(i);
}
long long ans = 0;
vector<vector<long long>> h(n + 1);
for (auto it : mp) {
long long cur = (long long)((it.second).size());
for (long long i = 0; i < cur - 1; ++i) {
long long l = it.second[i] + 1, r = it.second[i + 1];
h[r].push_back(l);
}
}
long long L = 0;
for (long long i = 1; i <= n; ++i) {
for (auto it : h[i]) {
L = max(L, it);
}
ans += (i - L);
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr auto max_n = 305;
int n, m;
struct Edge {
int u, v, cap, flow;
};
struct Dinic {
vector<Edge> edges;
vector<vector<int>> graph;
vector<int> ptr;
vector<int> level;
int nodes_count, source, sink;
Dinic(int n, int s, int t) : nodes_count(n), source(s), sink(t) {
level.assign(n, -1);
graph.assign(n, vector<int>());
ptr.assign(n, 0);
}
void add_edge(int a, int b, int c) {
int last_edge = edges.size();
edges.push_back({a, b, c, 0});
edges.push_back({b, a, c, c});
graph[a].push_back(last_edge);
graph[b].push_back(last_edge + 1);
}
bool bfs() {
fill(level.begin(), level.end(), -1);
level[source] = 0;
queue<int> nodes_queue;
nodes_queue.push(source);
while (!nodes_queue.empty()) {
auto crt_node = nodes_queue.front();
nodes_queue.pop();
for (auto neigh : graph[crt_node]) {
if (level[edges[neigh].v] == -1 &&
edges[neigh].flow < edges[neigh].cap) {
level[edges[neigh].v] = level[crt_node] + 1;
nodes_queue.push(edges[neigh].v);
}
}
}
return level[sink] != -1;
}
int dfs(int x, int pushed) {
if (x == sink) return pushed;
for (int& id = ptr[x]; id < (int)graph[x].size(); id++) {
int i = graph[x][id];
if (level[edges[i].v] == level[x] + 1 && edges[i].flow < edges[i].cap) {
int f = dfs(edges[i].v, min(pushed, edges[i].cap - edges[i].flow));
if (f > 0) {
edges[i].flow += f;
edges[i ^ 1].flow -= f;
return f;
}
}
}
return 0;
}
int calc() {
int answer = 0;
while (bfs()) {
fill(ptr.begin(), ptr.end(), 0);
while (true) {
int f = dfs(source, INT_MAX);
if (f == 0) break;
answer += f;
}
}
return answer;
}
};
string lines[max_n];
int horizontal_node_index(int row, int column) { return m * row + column + 1; }
int vertical_node_index(int row, int column) {
return (n - 1) * m + n * column + row + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
int answer = 0;
int source_node = 0;
int sink_node = ((n - 1) * m + n * (m - 1) + 1);
Dinic dinic(sink_node + 1, source_node, sink_node);
for (auto i = 0; i < n; i++) {
cin >> lines[i];
for (auto j = 0; j < m; j++) {
if (lines[i][j] == '#') {
answer++;
if (i > 0 && lines[i - 1][j] == '#') {
dinic.add_edge(source_node, horizontal_node_index(i - 1, j), 1);
answer--;
}
if (j > 0 && lines[i][j - 1] == '#') {
dinic.add_edge(vertical_node_index(i, j - 1), sink_node, 1);
answer--;
}
}
}
}
for (auto i = 0; i < n; i++) {
for (auto j = 0; j < m; j++) {
if (lines[i][j] == '#') {
if (i < n - 1 && j < m - 1 && lines[i + 1][j] == '#' &&
lines[i][j + 1] == '#') {
dinic.add_edge(horizontal_node_index(i, j), vertical_node_index(i, j),
1);
}
if (i > 0 && j < m - 1 && lines[i - 1][j] == '#' &&
lines[i][j + 1] == '#') {
dinic.add_edge(horizontal_node_index(i - 1, j),
vertical_node_index(i, j), 1);
}
if (i < n - 1 && j > 0 && lines[i + 1][j] == '#' &&
lines[i][j - 1] == '#') {
dinic.add_edge(horizontal_node_index(i, j),
vertical_node_index(i, j - 1), 1);
}
if (i > 0 && j > 0 && lines[i - 1][j] == '#' &&
lines[i][j - 1] == '#') {
dinic.add_edge(horizontal_node_index(i - 1, j),
vertical_node_index(i, j - 1), 1);
}
}
}
}
answer += dinic.calc();
cout << answer << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s[22];
int id[22][22];
vector<pair<int, int> > v[44];
map<int, int> r[44];
int go(int pos, int mask) {
if (pos == n + n - 2) return 0;
if (r[pos].count(mask)) return r[pos][mask];
vector<int> t;
for (int i = (0); i < (20); i++)
if (mask & (1 << i)) t.push_back(i);
int m[26];
memset(m, 0, sizeof m);
for (int i = (0); i < (t.size()); i++) {
int px = v[pos][t[i]].first;
int py = v[pos][t[i]].second;
if (px + 1 < n) m[s[px + 1][py] - 'a'] |= (1 << id[px + 1][py]);
if (py + 1 < n) m[s[px][py + 1] - 'a'] |= (1 << id[px][py + 1]);
}
int best = (pos % 2 == 0 ? 100 : -100);
for (int i = (0); i < (26); i++)
if (m[i]) {
int diff = go(pos + 1, m[i]);
if (i == 0) diff++;
if (i == 1) diff--;
if (pos % 2 == 0)
best = min(best, diff);
else
best = max(best, diff);
}
return r[pos][mask] = best;
}
int main() {
cin >> n;
for (int i = (0); i < (n); i++) cin >> s[i];
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++) {
id[i][j] = v[i + j].size();
v[i + j].push_back(pair<int, int>(i, j));
}
int d = go(0, 1) + (s[0][0] == 'a' ? 1 : (s[0][0] == 'b' ? -1 : 0));
if (d == 0)
puts("DRAW");
else if (d > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
void process(const string& x) {
set<char> for_sure;
char last_char = '!';
int cnt = 0;
for (int i = 0; i < x.size(); i++) {
if (x[i] != last_char) {
if (cnt % 2 != 0) {
for_sure.insert(last_char);
}
last_char = x[i];
cnt = 1;
} else {
++cnt;
}
}
if (cnt % 2 != 0) {
for_sure.insert(last_char);
}
for (auto i = for_sure.begin(); i != for_sure.end(); ++i) {
cout << *i;
}
cout << endl;
}
int main() {
string s;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> s;
process(s);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline long long inl() {
long long x;
scanf("%I64d", &x);
return x;
}
inline double ind() {
double x;
scanf("%lf", &x);
return x;
}
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int power(int x, int n) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
int y = power(x, n / 2);
return y * y;
} else
return x * power(x, n - 1);
}
vector<int> g[100010];
int cnt[100010][2], a[100010], bit;
long long ans = 0;
void dfs(int x, int pa) {
int val = (a[x] >> bit) & 1, y;
cnt[x][val] = 1;
cnt[x][1 - val] = 0;
for (int i = 0; i < g[x].size(); i++) {
y = g[x][i];
if (y == pa) continue;
dfs(y, x);
ans += (((long long)cnt[x][0] * (long long)cnt[y][1] +
(long long)cnt[x][1] * (long long)cnt[y][0])
<< bit);
cnt[x][val ^ 1] += cnt[y][1];
cnt[x][val ^ 0] += cnt[y][0];
}
}
int main() {
int n = in(), x, y;
for (int i = 1; i <= n; i++) {
a[i] = in();
ans += a[i];
}
for (int i = 0; i < n - 1; i++) {
x = in();
y = in();
g[x].push_back(y);
g[y].push_back(x);
}
for (bit = 0; bit <= 22; bit++) {
dfs(1, 0);
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a;
if (360 % (180 - a) == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 300005, K = 20;
int m, maxd, dep[N], fa[N][K], s1[N], s2[N], top1, top2;
void add(int u, int v) {
dep[u] = dep[v] + 1, fa[u][0] = v;
for (int i = 1; i < K; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
int lca(int u, int v) {
if (dep[u] < dep[v]) u ^= v ^= u ^= v;
int ret = dep[u] - dep[v];
for (int i = K - 1; i >= 0; --i)
if (ret >> i & 1) u = fa[u][i];
if (u == v) return u;
for (int i = K - 1; i >= 0; --i)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
int main() {
add(1, 0);
s1[top1 = 1] = 1;
scanf("%d", &m);
for (int i = 2; i <= m + 1; ++i) {
int u;
scanf("%d", &u), add(i, u);
int d1 = top1 ? dist(i, s1[1]) : 0, d2 = top2 ? dist(i, s2[1]) : 0,
d3 = d1 < d2 ? d2 : d1;
if (d3 > maxd) {
maxd = d3;
if (d1 == d3) {
for (int j = 1; j <= top2; ++j)
if (dist(s2[j], i) == maxd) s1[++top1] = s2[j];
top2 = 0;
} else {
for (int j = 1; j <= top1; ++j)
if (dist(s1[j], i) == maxd) s2[++top2] = s1[j];
top1 = 0;
}
}
if (d3 == maxd) {
if (d1 == d3)
s2[++top2] = i;
else
s1[++top1] = i;
}
printf("%d\n", top1 + top2);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
string s = "", t = "";
cin >> s;
for (int i = 0; i < s.length(); i++) t += "0";
stack<int> st;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0' && !st.empty()) {
t[st.top()] = '1';
st.pop();
} else if (s[i] == '1')
st.push(i);
}
cout << t << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 2009;
vector<long long> g[MAX_N];
vector<long long> rg[MAX_N];
string s[MAX_N];
long long n, m;
bool used[MAX_N];
long long ts[MAX_N];
long long cnt;
long long c[MAX_N];
vector<long long> g1[MAX_N];
long long h[MAX_N];
void dfs(long long v) {
used[v] = true;
for (long long to : g[v]) {
if (!used[to]) dfs(to);
}
ts[cnt] = v;
cnt++;
}
void find_comp(long long v) {
used[v] = true;
c[v] = cnt;
for (long long to : rg[v]) {
if (!used[to]) find_comp(to);
}
}
void find_ans(long long v) {
h[v] = 1;
used[v] = true;
for (long long to : g1[v]) {
if (!used[to]) find_ans(to);
h[v] = max(h[v], h[to] + 1);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> s[i];
for (long long e = 0; e < m; e++) {
if (s[i][e] == '<') {
g[i].push_back(e + n);
rg[e + n].push_back(i);
} else if (s[i][e] == '>') {
g[e + n].push_back(i);
rg[i].push_back(e + n);
} else {
g[i].push_back(e + n);
g[e + n].push_back(i);
rg[i].push_back(e + n);
rg[e + n].push_back(i);
}
}
}
for (long long i = 0; i < n + m; i++) {
if (!used[i]) dfs(i);
}
cnt = 0;
for (long long i = 0; i < n + m; i++) used[i] = false;
for (long long i = m + n - 1; i >= 0; i--) {
long long v = ts[i];
if (!used[v]) {
find_comp(v);
cnt++;
}
}
for (long long i = 0; i < n + m; i++) {
for (long long to : rg[i]) {
if (c[i] != c[to] && c[i] > c[to]) g1[c[i]].push_back(c[to]);
}
used[i] = false;
}
for (long long i = 0; i < cnt; i++) {
if (!used[i]) find_ans(i);
}
for (long long i = 0; i < n + m; i++) c[i] = h[c[i]];
for (long long i = 0; i < n; i++) {
for (long long e = 0; e < m; e++) {
if ((s[i][e] == '=' && c[i] == c[e + n]) ||
(s[i][e] == '>' && c[i] > c[e + n]) ||
(s[i][e] == '<' && c[i] < c[e + n]))
continue;
else {
cout << "No";
return 0;
}
}
}
cout << "Yes\n";
for (long long i = 0; i < n; i++) cout << c[i] << " ";
cout << "\n";
for (long long i = 0; i < m; i++) cout << c[i + n] << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int v[4];
bool ok() {
for (int i = 0; i < 4; ++i)
if (v[i] != 1) return 0;
return 1;
}
inline int next(int p) { return (++p == 4) ? (0) : (p); }
int main() {
for (int i = 0; i < 4; ++i) scanf("%d", &v[i]);
while (!ok()) {
bool done = 0;
for (int i = 0; i < 4; ++i) {
if ((v[i] & 1) == 0 && (v[next(i)] & 1) == 0) {
printf("/%d\n", i + 1);
v[i] >>= 1;
v[next(i)] >>= 1;
done = 1;
break;
}
if ((v[i] & 1) == 1 && (v[next(i)] & 1) == 1 &&
(v[i] != 1 || v[next(i)] != 1)) {
printf("+%d\n", i + 1);
printf("/%d\n", i + 1);
v[i] = (v[i] + 1) >> 1;
v[next(i)] = (v[(next(i))] + 1) >> 1;
done = 1;
break;
}
}
if (!done) {
for (int i = 0; i < 4; ++i)
if ((v[i] & 1) == 0) {
printf("+%d\n", i + 1);
++v[i];
++v[next(i)];
break;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100050;
int f[maxn];
int main() {
int m, n;
scanf("%d%d", &m, &n);
for (int i = 0; i <= 100; ++i) f[i] = 1;
int l = 1, r = m;
for (int i = 1; i <= 60; ++i) {
int y;
if (i <= n) {
printf("%d\n", m);
fflush(stdout);
scanf("%d", &y);
if (y > 0)
f[i] = -1;
else if (y == 0)
return 0;
} else {
int mid = (l + r) >> 1;
printf("%d\n", mid);
fflush(stdout);
scanf("%d", &y);
int j = i % n;
if (j == 0) j = n;
y *= f[j];
if (y == 0) {
return 0;
}
if (y > 0)
l = mid + 1;
else
r = mid - 1;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t, n, i, j, k;
cin >> t;
string s;
bool hi;
while (t--) {
cin >> s;
n = s.size();
map<char, long long> m;
for (i = 0; i < n; i++) m[s[i]]++;
map<char, long long>::iterator it = m.begin();
hi = true;
char ch = (it->first);
if ((it->second) > 1) hi = false;
it++;
for (; it != m.end(); it++) {
j = (it->second);
char ch1 = (it->first);
if (j > 1) {
hi = false;
break;
}
if ((ch1 - 97) == (ch - 97) + 1)
ch = ch1;
else {
hi = false;
break;
}
}
if (hi)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 100050;
vector<int> vec[mx];
int dp[mx][2];
bool func(int idx, int pl) {
if (dp[idx][pl] != -1) {
return dp[idx][pl];
}
int i, j, k, l = vec[idx].size();
if (l == 0) {
dp[idx][pl] = 0;
return dp[idx][pl];
}
bool ret = 0;
for (i = 0; i < l; i++) {
k = vec[idx][i];
ret = ret | (!func(k, pl ^ 1));
}
dp[idx][pl] = ret;
return dp[idx][pl];
}
int main() {
int n;
scanf("%d", &n);
int i, j, k, p;
int arr[n + 5];
for (i = 1; i <= n; i++) {
scanf("%d", arr + i);
}
for (i = 1; i <= n; i++) {
p = arr[i];
for (j = i + p; j <= n; j += p) {
if (arr[j] > arr[i]) {
vec[i].push_back(j);
}
}
for (j = i - p; j >= 1; j -= p) {
if (arr[j] > arr[i]) {
vec[i].push_back(j);
}
}
}
memset(dp, -1, sizeof(dp));
for (i = 1; i <= n; i++) {
if (dp[i][0] == -1) {
dp[i][0] = func(i, 0);
}
if (dp[i][1] == -1) {
dp[i][1] = func(i, 1);
}
}
for (i = 1; i <= n; i++) {
if (dp[i][0] == 0)
printf("B");
else
printf("A");
}
printf("\n");
return 0;
}
| 4 |
#include "bits/stdc++.h"
#define int long long
#define forn(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef unsigned long long ull;
int mod = 998244353;
int r = 0;
vector<vector<int>> a;
vector<vector<int>> b;
bool cmp(int i, int j) {
return a[i][r] < a[j][r];
}
int32_t main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
a.resize(n, vector<int>(m));
b.resize(n, vector<int>(m));
forn (i, n) {
forn (j, m) {
cin >> a[i][j];
}
}
forn (i, n) {
forn (j, m) {
cin >> b[i][j];
}
}
ull one = 1;
vector<vector<ull>> w(m, vector<ull>((n - 2) / 64 + 1));
vector<vector<ull>> nw(m, vector<ull>((n - 2) / 64 + 1));
forn (j, m) {
for (int i = 0; i < n - 1; i++) {
if (b[i + 1][j] > b[i][j]) {
nw[j][i >> 6] |= one << (i & 63);
} else if (b[i + 1][j] < b[i][j]) {
w[j][i >> 6] |= one << (i & 63);
}
}
}
vector<ull> mask((n - 2) / 64 + 1);
vector<bool> used(m);
vector<int> rows;
while (true) {
bool was = false;
forn (j, m) {
if (used[j]) {
continue;
}
bool ok = true;
for (int i = 0; i < w[j].size(); i++) {
if ((w[j][i] | mask[i]) != mask[i]) {
ok = false;
break;
}
}
if (!ok) {
continue;
}
used[j] = true;
was = true;
rows.push_back(j);
for (int i = 0; i < nw[j].size(); i++) {
mask[i] |= nw[j][i];
}
}
if (!was) {
break;
}
}
vector<int> inds(n);
forn (i, n) {
inds[i] = i;
}
reverse(rows.begin(), rows.end());
for (int row: rows) {
r = row;
stable_sort(inds.begin(), inds.end(), cmp);
}
forn (i, n) {
forn (j, m) {
if (b[i][j] != a[inds[i]][j]) {
cout << -1 << endl;
return 0;
}
}
}
cout << rows.size() << endl;
for (int row: rows) {
cout << row + 1 << ' ';
}
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int MAX = 1e9 + 7;
const int MIN = -1e9 + 7;
using namespace std;
int a, b, n;
long long power(long long x, long long y) {
if (y == 0) return 1;
long long s = power(x, y / 2);
s *= s;
if (y % 2 == 1) s *= x;
return s;
}
int dp[100005][35][2];
bool solve(int asas, int as, int flag) {
if (power(asas, as) >= n && flag == 1) return 0;
if (power(asas, as) >= n && flag == 0) return 1;
if (dp[asas][as][flag] + 1) return dp[asas][as][flag];
if (flag && asas <= 100000)
dp[asas][as][flag] =
solve(asas + 1, as, flag ^ 1) & solve(asas, as + 1, flag ^ 1);
else if (flag)
dp[asas][as][flag] = solve(asas, as + 1, flag ^ 1);
if (!flag && asas <= 100000)
dp[asas][as][flag] =
solve(asas + 1, as, flag ^ 1) | solve(asas, as + 1, flag ^ 1);
else if (!flag)
dp[asas][as][flag] = solve(asas, as + 1, flag ^ 1);
return dp[asas][as][flag];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> n;
memset(dp, -1, sizeof dp);
if (a == 1)
if (power(a + 1, b) >= n) {
cout << "Missing";
return 0;
}
if (solve(a, b, 0))
cout << "Masha";
else
cout << "Stas";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, x, f[5];
int main() {
scanf("%d", &n);
for (register int(i) = (1); (i) <= (n); (i)++)
scanf("%d", &x), f[1] += (x == 1), f[2] = max(f[1], f[2] + (x == 2)),
f[3] = max(f[2], f[3] + (x == 1)),
f[4] = max(f[3], f[4] + (x == 2));
cout << f[4];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 6;
using hash_t = unsigned long long;
const unsigned long long MOD = 1000000000000000000ll + 3;
const __int128_t ONE = 1;
string s;
hash_t mul(hash_t a, hash_t b) { return ONE * a * b % MOD; }
hash_t mod_pow(hash_t a, hash_t k) {
hash_t res = 1;
while (k) {
if (k & 1) res = mul(res, a);
a = mul(a, a);
k /= 2;
}
return res;
}
const hash_t x = 1e9 + 7;
const hash_t inv_x1 = mod_pow(x - 1, MOD - 2);
hash_t xn[N];
const hash_t F[10] = {0x1234567812345678 % MOD, 0x3f3f991999999999 % MOD,
0x23ffffef1234e212 % MOD, 0x457788888342ffff % MOD,
0x23feabcd23333233 % MOD, 0x2312312999950004 % MOD,
0x99931feaaaaaaaaa % MOD, 0x9930495ff031ab03 % MOD,
0x132130043aa34bbb % MOD, 0x8888819fffffffff % MOD};
struct Tree {
hash_t h[N << 2];
int setv[N << 2];
void build(int o, int L, int R) {
setv[o] = -1;
if (L == R) {
h[o] = mul(F[s[L] - '0'], xn[L]);
return;
}
int M = (L + R) / 2, lc = o << 1, rc = lc | 1;
build(lc, L, M);
build(rc, M + 1, R);
h[o] = (h[lc] + h[rc]) % MOD;
}
void push_down(int o, int L, int R) {
if (L == R) return;
if (setv[o] >= 0) {
int M = (L + R) / 2, lc = o << 1, rc = lc | 1;
h[lc] = mul(mul(F[setv[o]], xn[L]),
mul(inv_x1, (xn[M - L + 1] - 1 + MOD) % MOD));
h[rc] = mul(mul(F[setv[o]], xn[M + 1]),
mul(inv_x1, (xn[R - M] - 1 + MOD) % MOD));
setv[lc] = setv[rc] = setv[o];
setv[o] = -1;
}
}
void update(int o, int L, int R, int qL, int qR, int v) {
push_down(o, L, R);
if (qR < L || R < qL) return;
if (qL <= L && R <= qR) {
setv[o] = v;
h[o] = mul(mul(F[setv[o]], xn[L]),
mul(inv_x1, (xn[R - L + 1] - 1 + MOD) % MOD));
return;
}
int M = (L + R) / 2, lc = o << 1, rc = lc | 1;
update(lc, L, M, qL, qR, v);
update(rc, M + 1, R, qL, qR, v);
h[o] = (h[lc] + h[rc]) % MOD;
}
hash_t query(int o, int L, int R, int qL, int qR) {
push_down(o, L, R);
if (qR < L || R < qL) return 0;
if (qL <= L && R <= qR) return h[o];
int M = (L + R) / 2, lc = o << 1, rc = lc | 1;
return (query(lc, L, M, qL, qR) + query(rc, M + 1, R, qL, qR)) % MOD;
}
} t;
int main() {
ios::sync_with_stdio(0);
xn[0] = 1;
for (int i = 1; i < N; i++) xn[i] = mul(xn[i - 1], x);
int n, m, k;
cin >> n >> m >> k;
m += k;
cin >> s;
s = string(" ") + s;
t.build(1, 1, n);
while (m--) {
int o, l, r, d;
cin >> o >> l >> r >> d;
if (o == 1) {
t.update(1, 1, n, l, r, d);
} else {
bool ok = r - l + 1 == d || mul(xn[d], t.query(1, 1, n, l, r - d)) ==
t.query(1, 1, n, l + d, r);
puts(ok ? "YES" : "NO");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
long long MOD = 1000000009;
long long int n, m, k;
long long int mat[110][110];
long long int dp[110][110][15];
long long int f;
long long int go(long long int row, long long int col, long long int rem) {
if (col < 0 || col >= m) return -1e15;
if (row >= n) {
if (rem == 0) return 0;
return -1e15;
}
long long int ret = dp[row][col][rem];
if (ret != -1) return ret;
long long int ans = 0;
{
long long int p1 = go(row + 1, col + 1, (rem + mat[row][col]) % (k + 1));
long long int p2 = go(row + 1, col - 1, (rem + mat[row][col]) % (k + 1));
ans = mat[row][col] + max(p1, p2);
}
return dp[row][col][rem] = ans;
}
void path(long long int row, long long int col, long long int rem) {
if (row == n - 1) return;
long long int ans = dp[row][col][rem];
long long int i = row;
long long int j = col;
if (col == 0) {
if (ans ==
(mat[row][col] + go(i + 1, j + 1, (mat[row][col] + rem) % (k + 1)))) {
cout << "R";
path(i + 1, j + 1, (mat[row][col] + rem) % (k + 1));
}
} else if (col == m - 1) {
if (ans ==
(mat[row][col] + go(i + 1, j - 1, (mat[row][col] + rem) % (k + 1)))) {
cout << "L";
path(i + 1, j - 1, (mat[row][col] + rem) % (k + 1));
}
} else {
if (ans ==
(mat[row][col] + go(i + 1, j - 1, (mat[row][col] + rem) % (k + 1)))) {
cout << "L";
path(i + 1, j - 1, (mat[row][col] + rem) % (k + 1));
} else {
cout << "R";
path(i + 1, j + 1, (mat[row][col] + rem) % (k + 1));
}
}
}
void solve() {
cin >> n >> m >> k;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
char ch;
cin >> ch;
mat[n - 1 - i][j] = ch - '0';
}
}
long long int ans = -1, ind = 0;
memset(dp, -1, sizeof(dp));
f = 0;
for (long long int i = 0; i < m; i++) {
long long int p = go(0, i, 0);
if (p >= ans) ind = i;
ans = max(p, ans);
}
if (ans < 0)
cout << -1 << '\n';
else {
f = 1;
cout << ans << '\n';
cout << ind + 1 << '\n';
path(0, ind, 0);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int first, second;
Point(){};
Point(int a, int b) { first = a, second = b; }
friend bool operator<(Point a, Point b) {
return a.first == b.first ? a.second < b.second : a.first < b.first;
}
};
char a[110][110];
char ctrl[1010];
Point p[1010], s, t;
Point pre[27][110][110];
int dist[27][110][110];
int n, m, k;
priority_queue<pair<int, Point>, vector<pair<int, Point> >,
greater<pair<int, Point> > >
seq;
const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};
void run(int c, Point s) {
for (int i = s.first + 1; i <= n; i++)
dist[c][i][s.second] = dist[c][i - 1][s.second] + a[i - 1][s.second],
pre[c][i][s.second] = Point(i - 1, s.second);
for (int i = s.first - 1; i >= 1; i--)
dist[c][i][s.second] = dist[c][i + 1][s.second] + a[i + 1][s.second],
pre[c][i][s.second] = Point(i + 1, s.second);
for (int j = s.second + 1; j <= m; j++)
dist[c][s.first][j] = dist[c][s.first][j - 1] + a[s.first][j - 1],
pre[c][s.first][j] = Point(s.first, j - 1);
for (int j = s.second - 1; j >= 1; j--)
dist[c][s.first][j] = dist[c][s.first][j + 1] + a[s.first][j + 1],
pre[c][s.first][j] = Point(s.first, j + 1);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j] <= 'z' && a[i][j] >= 'a') {
p[a[i][j] - 'a'] = Point(i, j);
a[i][j] = 1;
} else if (a[i][j] != '#')
a[i][j] -= '0';
}
memset(dist, 127, sizeof dist);
for (int i = 0; i < 26; i++)
if (p[i].first > 0) {
dist[i][p[i].first][p[i].second] = 0;
run(i, p[i]);
}
scanf("%d%d%s%d%d", &s.first, &s.second, ctrl + 1, &t.first, &t.second);
dist[26][s.first][s.second] = 0, run(26, s);
ctrl[0] = 26;
int len = strlen(ctrl);
for (int i = 0; i < len - 1; i++) {
ctrl[i + 1] -= 'a';
if (k <= dist[ctrl[i]][p[ctrl[i + 1]].first][p[ctrl[i + 1]].second]) {
Point now = p[ctrl[i + 1]];
while (dist[ctrl[i]][now.first][now.second] > k)
now = pre[ctrl[i]][now.first][now.second];
printf("%d %d\n", now.first, now.second);
return 0;
} else
k -= dist[ctrl[i]][p[ctrl[i + 1]].first][p[ctrl[i + 1]].second];
}
if (k <= dist[ctrl[len - 1]][t.first][t.second]) {
Point now = t;
while (dist[ctrl[len - 1]][now.first][now.second] > k)
now = pre[ctrl[len - 1]][now.first][now.second];
printf("%d %d\n", now.first, now.second);
return 0;
}
printf("%d %d\n", t.first, t.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
char s[MaxN];
int dp[MaxN][5];
void edit(int pos, char x) {
if (x == '*') {
dp[pos][0] = (((dp[pos][0] + dp[pos - 1][3]) % mod + dp[pos - 1][4]) % mod +
dp[pos - 1][0]) %
mod;
}
if (x == '0') {
dp[pos][1] = ((dp[pos][1] + dp[pos - 1][1]) % mod + dp[pos - 1][2]) % mod;
}
if (x == '1') {
dp[pos][2] = (dp[pos][2] + dp[pos - 1][0]) % mod;
dp[pos][3] = ((dp[pos][3] + dp[pos - 1][1]) % mod + dp[pos - 1][2]) % mod;
}
if (x == '2') {
dp[pos][4] = (dp[pos][4] + dp[pos - 1][0]) % mod;
}
}
int main() {
scanf("%s", s);
int n = strlen(s);
if (s[0] == '?') {
dp[0][0] = 1;
dp[0][1] = 1;
dp[0][3] = 1;
}
if (s[0] == '*') dp[0][0] = 1;
if (s[0] == '0') dp[0][1] = 1;
if (s[0] == '1') dp[0][3] = 1;
for (int i = 1; i < n; i++) {
if (s[i] != '?')
edit(i, s[i]);
else {
edit(i, '*');
edit(i, '0');
edit(i, '1');
edit(i, '2');
}
}
printf("%d", ((dp[n - 1][0] + dp[n - 1][1]) % mod + dp[n - 1][2]) % mod);
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.