solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string k;
for (int i = 0; i < n; i++) {
if (i % 2 == 1) k = "love";
if (i % 2 == 0) k = "hate";
if (i == n - 1) cout << "I " << k << " it";
if (i < n - 1) cout << "I " << k << " that ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[30];
int col[30];
vector<char> ans;
stack<char> st;
bool vis[30];
bool check(int u) {
col[u] = 1;
for (int x : adj[u]) {
if (col[x] == 0) {
if (check(x)) {
return true;
}
} else if (col[x] == 1) {
return true;
}
}
col[u] = 2;
return false;
}
void dfs(int u) {
vis[u] = true;
for (int x : adj[u]) {
if (!vis[x]) {
dfs(x);
}
}
st.push(u + 'a');
}
int main() {
memset(col, 0, sizeof(col));
memset(vis, false, sizeof(vis));
int n;
cin >> n;
string s[n];
int ma = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
ma = max(ma, (int)s[i].size());
}
int f = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int flag = 0;
for (int k = 0; k < min((int)s[i].size(), (int)s[j].size()); k++) {
if (s[i][k] != s[j][k]) {
adj[s[i][k] - 'a'].push_back(s[j][k] - 'a');
flag = 1;
break;
}
}
if (!flag && s[j].size() < s[i].size()) {
f = 0;
break;
}
}
if (f == 0) {
break;
}
}
if (f) {
for (int i = 0; i < 26; i++) {
if (col[i] == 0) {
if (check(i)) {
f = 0;
break;
}
}
}
}
if (!f) {
cout << "Impossible" << endl;
} else {
for (int i = 0; i < 26; i++) {
if (!vis[i]) dfs(i);
}
while (!st.empty()) {
cout << st.top();
st.pop();
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dist[2][1000][1000];
int dx[8] = {1, 1, 2, 2, -1, -1, -2, -2};
int dy[8] = {2, -2, 1, -1, 2, -2, 1, -1};
int w, h;
void bfs(int sx, int sy, int dist[][1000]) {
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) dist[i][j] = 1e9;
dist[sy][sx] = 0;
queue<pair<int, int>> q;
q.push({sx, sy});
while (q.size()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
int d = dist[y][x] + 1;
for (int i = 0; i < 8; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < w && ny >= 0 && ny < h && d < dist[ny][nx]) {
dist[ny][nx] = d;
q.push({nx, ny});
}
}
}
}
void go(int x, int y, int dist[][1000]) {
while (1) {
int d = dist[y][x];
if (d == 0) return;
for (int i = 0; i < 8; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < w && ny >= 0 && ny < h && d > dist[ny][nx]) {
x = nx;
y = ny;
cout << ny + 1 << ' ' << nx + 1 << endl;
break;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> h >> w;
int y1, x1, y2, x2;
cin >> y1 >> x1 >> y2 >> x2;
x1--, y1--, x2--, y2--;
bfs(w / 2 - 1, h / 2 - 1, dist[0]);
bfs(w / 2 - 1, h / 2, dist[1]);
double white_goal = dist[0][y1][x1];
double black_goal = dist[1][y2][x2] + 0.5;
double white_block = dist[1][y1][x1];
double black_block = dist[0][y2][x2] + 0.5;
if ((x1 + y1) % 2 == (x2 + y2) % 2) {
if (black_goal < white_goal) {
cout << "BLACK" << endl;
go(x2, y2, dist[1]);
} else if (black_block < white_goal + 1) {
cout << "BLACK" << endl;
go(x2, y2, dist[0]);
go(w / 2 - 1, h / 2 - 1, dist[1]);
} else {
cout << "WHITE" << endl;
go(x1, y1, dist[0]);
}
} else {
if (white_goal < black_goal) {
cout << "WHITE" << endl;
go(x1, y1, dist[0]);
} else if (white_block < black_goal + 1) {
cout << "WHITE" << endl;
go(x1, y1, dist[1]);
go(w / 2 - 1, h / 2, dist[0]);
} else {
cout << "BLACK" << endl;
go(x2, y2, dist[1]);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graph(1000008);
vector<pair<long long, long long>> f, s;
long long Hash = 0;
long long Hash2 = 0;
long long Hash3, Hash4;
const int base = 7;
const int base2 = 11;
const int MOD = 1e9 + 7;
const int Mod2 = 1e9 + 9;
long long check(vector<pair<long long, long long>> &vc) {
long long res = 0;
int sz = (int)vc.size();
int l = 0;
for (int i = 0; i < sz; i++) {
while (l < sz - 1 && vc[l + 1] == vc[i]) l++;
res += 1LL * (l - i) * (l - i + 1) / 2;
i = l;
}
return res;
}
int main() {
int n, m, u, v;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
graph[i].push_back(i);
sort(graph[i].begin(), graph[i].end());
Hash = Hash2 = Hash3 = Hash4 = 0;
for (int j = 0; j < graph[i].size(); j++) {
if (graph[i][j] != i) {
Hash = 1LL * Hash * base + graph[i][j] % MOD;
Hash2 = 1LL * Hash2 * base2 + graph[i][j] % Mod2;
}
Hash3 = 1LL * Hash3 * base + graph[i][j] % MOD;
Hash4 = 1LL * Hash4 * base2 + graph[i][j] % Mod2;
}
f.push_back(make_pair(Hash, Hash2));
s.push_back(make_pair(Hash3, Hash4));
}
sort(s.begin(), s.end()), sort(f.begin(), f.end());
long long ans = 1LL * check(f) + 1LL * check(s);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int maxm = 1E6 + 10;
int a[maxn];
int ans;
bitset<maxm> num;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int test;
cin >> test;
while (test--) {
int n, val = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) num[a[j] - a[i]] = 1;
for (int i = 1; i < 1000000; i++) {
int j = 1;
for (; j < n; j++)
if (num[j * i]) break;
if (j == n) {
val = i;
break;
}
}
if (val == 0) {
cout << "NO\n";
} else {
cout << "YES\n";
int ans = 1;
cout << ans;
for (int i = 1; i < n; i++) {
ans += val;
cout << " " << ans;
}
cout << endl;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) num[a[j] - a[i]] = 0;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int tab[6][6];
int main() {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
char d;
cin >> d;
if (d == '#') tab[i][j] = 1;
if (d == '.') tab[i][j] = 0;
}
}
bool t = false;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
int sum = tab[i][j] + tab[i][j + 1] + tab[i + 1][j] + tab[i + 1][j + 1];
if (sum >= 3 || sum <= 1) {
t = true;
break;
}
}
}
if (t == true)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
// my code goes here
// HITESH VISHNOI MANIT SE HU
// <only constrains are imaginary but, I AM REAL.........>
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define f(a,b,n) for(ll a=b;a<n;a++)
#define readarr(arr,n) f(i,0,n) cin>>arr[i];
#define ll long long
#define pb push_back
#define go ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
#define ms(a,i) memset(a,i,sizeof(a))
#define mod 1000000007 //1e9+7 ans%mod
#define w(t) int t; cin>>t; while(t--)
#define MOD 1e9+7
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define vi vector<int>
#define mp map<int,int>
#define pi pair<int,int>
#define inf 1e18
#define ff first
#define ss second
#define ps(x,y) fixed <<setprecision(y)<<x
#define yes cout <<"YES" << endl
#define no cout <<"NO" << endl
void pseudo()
{ go;
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
}
long long hcf(long long a,long long b){
long long greater=a>b?a:b;
long long lesser=a<b?a:b;
return hcf(greater,lesser);
}
long long lcm(long long a,long long b){
return a*b/hcf(a,b);
}
int32_t main ()
{
pseudo() ;
w(t)
{
string s ;
cin >> s ;
int q =0;
int open=0,close=0 ;
bool flag = false ;
int n= s.size() ;
if (s[0]==')' or s[n-1] =='(')
flag=1 ;
else
{
f(i,0,n)
{
if(s[i]=='?') q++;
if(s[i]=='(') open++;
if(s[i]==')') close++;
}
int d = abs(open- close) ;
if (d==0 and q%2!=0)
flag=1 ;
else if (d!=0 and d!=q)
{
flag = 1;
}
}
if(flag) no ; else yes ;
}
return 0 ;
} | 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 1e9 + 7;
const int N = (1 << 22) | 7;
const int M = 5e6 + 7;
int f[N], pre[N], key[N];
int a[30], ans[30];
int n, m, cnt;
void bfs() {
queue<int> q;
memset(key, -1, sizeof(key));
memset(pre, -1, sizeof(pre));
for (int i = 0; i < n; i++) {
q.push(a[i]);
f[a[i]] = 1;
key[a[i]] = i;
}
while (q.size()) {
int now = q.front();
q.pop();
for (int i = 0; i < n; i++)
if (now & (1 << i)) {
int temp = now | a[i];
if (!f[temp]) {
f[temp] = f[now] + 1;
key[temp] = i;
pre[temp] = now;
q.push(temp);
if (temp + 1 == (1 << n)) return;
}
}
}
}
signed main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < n; i++) a[i] = 1 << i;
for (int i = 1, u, v; i <= m; i++) {
scanf("%d", &u);
scanf("%d", &v);
u--;
v--;
a[u] |= 1 << v;
a[v] |= 1 << u;
}
if (m == n * (n - 1) >> 1)
puts("0");
else {
bfs();
cnt = 0;
int now = (1 << n) - 1;
printf("%d\n", f[now]);
while (~now) {
printf("%d ", key[now] + 1);
now = pre[now];
}
puts("");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
static char c;
static int f;
for (c = getchar(), f = 1; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -f;
for (x = 0; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + (c & 15);
x *= f;
}
template <typename T>
void write(T x) {
static char q[65];
int cnt = 0;
if (x < 0) putchar('-'), x = -x;
q[++cnt] = x % 10, x /= 10;
while (x) q[++cnt] = x % 10, x /= 10;
while (cnt) putchar(q[cnt--] + '0');
}
const int maxn = 100005;
struct Edge {
int v, nt;
Edge(int v = 0, int nt = 0) : v(v), nt(nt) {}
} e[maxn * 2];
int hd[maxn], num;
void qwq(int u, int v) { e[++num] = Edge(v, hd[u]), hd[u] = num; }
int dp[maxn], pa[maxn][18], cnt, dfn[maxn];
bool cmp(int x, int y) { return dfn[x] < dfn[y]; }
void dfs(int u, int fa) {
dfn[u] = ++cnt;
for (int i = 1; (1 << i) <= dp[u]; ++i) pa[u][i] = pa[pa[u][i - 1]][i - 1];
for (int i = hd[u]; i; i = e[i].nt) {
int v = e[i].v;
if (v == fa) continue;
pa[v][0] = u;
dp[v] = dp[u] + 1;
dfs(v, u);
}
}
int lca(int x, int y) {
if (dp[x] < dp[y]) x ^= y ^= x ^= y;
for (int t = dp[x] - dp[y], cn = 0; t; t >>= 1, ++cn)
if (t & 1) x = pa[x][cn];
if (x == y) return x;
for (int i = 17; i >= 0; --i)
if (pa[x][i] != pa[y][i]) x = pa[x][i], y = pa[y][i];
return pa[x][0];
}
int son[maxn], bro[maxn];
void addson(int u, int v) { bro[v] = son[u], son[u] = v; }
int MIN(int x, int y, int z) { return x < y ? x < z ? x : z : y < z ? y : z; }
int vis[maxn], f[maxn][3];
void solve(int u) {
if (vis[u])
f[u][0] = f[u][1] = 0x3f3f3f3f, f[u][2] = 0;
else
f[u][0] = 1, f[u][1] = 0, f[u][2] = 0x3f3f3f3f;
for (int v = son[u], sv = 0; v; sv = v, v = bro[v], bro[sv] = 0) {
solve(v);
int tmp =
MIN(f[v][0], f[v][1], dp[v] == dp[u] + 1 ? 0x3f3f3f3f : f[v][2] + 1);
f[u][2] = MIN(0x3f3f3f3f, f[u][1] + f[v][2], f[u][2] + tmp);
f[u][0] = min(0x3f3f3f3f, f[u][0] + MIN(f[v][0], f[v][1], f[v][2]));
f[u][1] = min(0x3f3f3f3f, f[u][1] + tmp);
}
son[u] = vis[u] = 0;
}
int a[maxn];
int st[maxn], tp;
int main() {
int n;
read(n);
for (int i = 1; i < n; ++i) {
int u, v;
read(u), read(v);
qwq(u, v);
qwq(v, u);
}
dfs(1, 0);
int m;
read(m);
while (m--) {
int k;
read(k);
for (int i = 1; i <= k; ++i) read(a[i]), vis[a[i]] = true;
sort(a + 1, a + k + 1, cmp);
tp = 0;
st[++tp] = a[1];
for (int i = 2; i <= k; ++i) {
int u = a[i], x = lca(u, st[tp]);
while (tp > 1 && !cmp(st[tp - 1], x)) {
addson(st[tp - 1], st[tp]);
--tp;
}
if (st[tp] != x) {
addson(x, st[tp]);
st[tp] = x;
}
st[++tp] = u;
}
while (tp > 1) {
addson(st[tp - 1], st[tp]);
--tp;
}
solve(st[1]);
int ans = MIN(f[st[1]][0], f[st[1]][1], f[st[1]][2]);
write(ans >= 0x3f3f3f3f ? -1 : ans), putchar('\n');
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > Generate_odd(int n) {
vector<vector<int> > answer(n);
for (int i = 0; i < n; i++) answer[i].resize(n);
for (int i = 0; i < n; i++) answer[i][i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int k = (i - j + n) % n;
if (k != j) answer[j][k] = i + 1;
}
}
return answer;
}
vector<vector<int> > Merge_odd(vector<vector<int> > &odd) {
int n = odd.size() * 2;
vector<vector<int> > answer(n);
for (int i = 0; i < n; i++) answer[i].resize(n);
for (int i = 0; i < n / 2; i++)
for (int j = 0; j < n / 2; j++) {
answer[i][j] = odd[i][j];
answer[i + n / 2][j + n / 2] = odd[i][j];
}
for (int i = 0; i < n / 2; i++) {
vector<bool> can_be(n / 2 + 1);
for (int j = 0; j < can_be.size(); j++) can_be[j] = true;
for (int j = 0; j < n / 2; j++) can_be[odd[i][j]] = false;
for (int j = 0; j < can_be.size(); j++)
if (can_be[j]) {
answer[i][i + n / 2] = j;
answer[i + n / 2][i] = j;
break;
}
}
for (int i = n / 2 + 1; i < n; i++)
for (int j = 0; j < n / 2; j++) {
int k = (i + j) % (n / 2) + n / 2;
answer[j][k] = i;
answer[k][j] = i;
}
return answer;
}
vector<vector<int> > Merge_even(vector<vector<int> > &even) {
int n = even.size() * 2;
vector<vector<int> > answer(n);
for (int i = 0; i < n; i++) answer[i].resize(n);
for (int i = 0; i < n / 2; i++)
for (int j = 0; j < n / 2; j++) {
answer[i][j] = even[i][j];
answer[i + n / 2][j + n / 2] = even[i][j];
}
for (int i = n / 2; i < n; i++)
for (int j = 0; j < n / 2; j++) {
int k = (i + j) % (n / 2) + n / 2;
answer[j][k] = i;
answer[k][j] = i;
}
return answer;
}
vector<vector<int> > Solve(int n) {
int power_of_2 = 0, odd_part;
while (n % 2 == 0) {
power_of_2++;
n /= 2;
}
odd_part = n;
vector<vector<int> > odd = Generate_odd(odd_part);
vector<vector<int> > even = Merge_odd(odd);
power_of_2--;
for (int i = 0; i < power_of_2; i++) even = Merge_even(even);
return even;
}
int main() {
int n;
cin >> n;
vector<vector<int> > answer = Solve(n);
for (int i = 0; i < answer.size(); i++) {
for (int j = 0; j < answer[i].size(); j++) cout << answer[i][j] << ' ';
cout << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[12];
int dp[1009][11][11];
vector<int> ans;
bool dfs(int p, int ca, int la) {
int &d = dp[p][ca][la];
if (d + 1) return d;
if (p == n + 1) {
return d = 1;
}
for (int i = 1; i < 11; i++)
if (s[i] == '1' && i != la && i > ca) {
if (dfs(p + 1, i - ca, i)) {
ans.push_back(i);
return d = 1;
}
}
return d = 0;
}
int main() {
scanf("%s%d", s + 1, &n);
memset(dp, -1, sizeof(dp));
if (dfs(1, 0, 0)) {
puts("YES");
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
} else
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
long long n, k, a[N], b[N], ans;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
long long l = 0, r = 2e9;
while (l < r) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
long long mid = l + r >> 1, num = 0, sum = 0;
for (int i = 1; i <= n; i++) {
q.push({a[i] - mid, 0});
pair<long long, long long> t = q.top();
if (t.first + b[i] <= 0)
num += !t.second, sum += t.first + b[i], q.pop(), q.push({-b[i], 1});
}
if (num >= k)
r = mid, ans = sum + k * mid;
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 50005;
const int MAXM = 256;
int n, Q, a[MAXN], par[MAXN], anc[MAXN], dep[MAXN], f[MAXN][MAXM];
vector<int> adj[MAXN];
inline void Dfs(int x) {
for (auto y : adj[x])
if (y ^ par[x]) dep[y] = dep[x] + 1, par[y] = x, Dfs(y);
if (dep[x] >= MAXM) {
int cur = x;
for (int i = 0, v; i < MAXM; i++)
v = (i ^ a[cur]) >> 8,
f[x][v ^ 255] = max(f[x][v ^ 255], 255 << 8 | (i ^ a[cur])),
cur = par[cur];
anc[x] = cur;
for (int j = 0; j < 8; j++)
for (int i = 0; i < MAXM; i++)
if (!~f[x][i])
if (~f[x][i ^ 1 << j]) f[x][i] = f[x][i ^ 1 << j] ^ MAXM << j;
}
}
int main() {
memset(f, -1, sizeof f);
n = Read();
Q = Read();
for (int i = 1; i <= n; i++) a[i] = Read();
for (int i = 1, x, y; i < n; i++)
x = Read(), y = Read(), adj[x].push_back(y), adj[y].push_back(x);
dep[1] = 1;
Dfs(1);
while (Q--) {
int u = Read(), v = Read(), ret = 0, l = dep[v] - dep[u] + 1, cur = v;
for (int i = 0; i < l / MAXM; i++)
ret = max(ret, f[cur][i]), cur = anc[cur];
for (int i = l / MAXM * MAXM; i < l; i++)
ret = max(ret, a[cur] ^ i), cur = par[cur];
printf("%d\n", ret);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, mod = 19260817;
char str[MAXN];
int n, m;
int chl[26][MAXN], chr[26][MAXN];
int T[26];
struct node {
long long to;
int key;
int next;
} edge[MAXN * 50];
int head[mod], top = 0;
inline long long encode(int L, int R) { return (long long)L * 233333 + R; }
void modify(int L, int R, int dt) {
long long num = encode(L, R);
++top, edge[top] = (node){num, dt, head[num % mod]}, head[num % mod] = top;
}
inline int query(int L, int R) {
long long num = encode(L, R);
for (int i = head[num % mod]; i; i = edge[i].next) {
if (edge[i].to == num) return edge[i].key;
}
return -1;
}
int block[26][MAXN];
short lg[1048577];
inline short lowbit(long long x) {
short cnt = 0;
if ((x & (1048575)) == 1048575) cnt += 20, x >>= 20;
if ((x & (1048575)) == 1048575) cnt += 20, x >>= 20;
return cnt + lg[x];
}
int dfs(int L, int R, int flag = 0) {
if (L > R) return 0;
int t;
if ((t = query(L, R)) != -1) return t;
long long bit = 0;
if (!flag) {
for (int i = 0; i < 26; i++) {
int cur = L, sg = 0;
if (chl[i][cur] > R) continue;
while (cur <= R) {
int nxt = chl[i][cur];
if (nxt <= R) {
sg ^= dfs(cur, nxt - 1, flag);
cur = nxt + 1;
} else {
sg ^= dfs(cur, R, flag);
break;
}
}
bit |= 1ll << sg;
}
} else {
for (register int i = 0; i < 26; i++) {
if (chl[i][L] > R) continue;
register int opl = chl[i][L], opr = chr[i][R];
register int sg = block[i][opr] ^ block[i][opl] ^ dfs(L, opl - 1, flag) ^
dfs(opr + 1, R, flag);
bit |= 1ll << sg;
}
}
for (int j = 0;; j++)
if (!(bit >> j & 1)) {
modify(L, R, j);
return j;
}
}
inline int read() {
int a = 0, c;
do c = getchar();
while (!isdigit(c));
while (isdigit(c)) {
a = a * 10 + c - '0';
c = getchar();
}
return a;
}
void init() {
lg[0] = 0;
for (int i = 1; i < 1048576; i++) lg[i] = (!(i & 1)) ? 0 : lg[i >> 1] + 1;
memset(T, 127 / 3, sizeof T);
scanf("%s", str + 1), n = strlen(str + 1);
for (int i = n; i >= 1; i--) {
T[str[i] - 'a'] = i;
for (int j = 0; j < 26; j++) chl[j][i] = T[j];
}
memset(T, 127 / 3, sizeof T);
for (int i = 1; i <= n; i++) {
T[str[i] - 'a'] = i;
for (int j = 0; j < 26; j++) chr[j][i] = T[j];
}
dfs(1, n);
for (int i = 0; i < 26; i++) {
int pre = 0;
for (int j = 1; j <= n; j++)
if (str[j] - 'a' == i) {
block[i][j] = dfs(pre + 1, j - 1) ^ block[i][pre];
pre = j;
}
}
}
void work() {
int m, l, r;
m = read();
while (m--) {
l = read(), r = read();
int flag = dfs(l, r, 1);
if (flag)
puts("Alice");
else
puts("Bob");
}
}
int main() {
init();
work();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
int i, x = 0, y = 0, k = 0;
float a[t];
for (i = 0; i < t; i++) {
cin >> a[i];
if (a[i] <= 0)
x = x + (int)a[i];
else
y = y + (int)a[i];
}
int sum = x + y;
if (sum < 0) {
while (sum) {
if (a[k] > 0) {
if (a[k] < (int)(a[k] + 0.99999)) {
a[k] = a[k] + 0.99999;
sum = sum + 1;
}
}
k++;
}
} else if (sum > 0) {
while (sum) {
if (a[k] < 0) {
if (a[k] > (int)(a[k] - 0.99999)) {
a[k] = a[k] - 0.99999;
sum = sum - 1;
}
}
k++;
}
}
for (i = 0; i < t; i++) {
cout << (int)a[i] << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define int long long int
#define double long double
#define endl '\n'
const int mod = 1000000007;
using namespace std;
int modExpo(int x , int n)
{
int ans = 1;
while (n > 0) {
if ( n & 1 == 1 ) ans = ( ans * x ) % mod;
x = ( x * x ) % mod; n = n / 2;
}
return ans;
}
void solve()
{
vector<int> v(4);
for(int i=0;i<4;i++)
cin>>v[i];
int x = max(v[0] , v[1]);
int y = max(v[2] , v[3]);
if(x < v[2] && x < v[3])
{
cout<<"NO\n";
return;
}
if(y < v[0] && y < v[1])
{
cout<<"NO\n";
return;
}
cout<<"YES\n";
// cout<<x<<y;
}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fast;
int tt;
cin >> tt;
while (tt--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int rdi() {
int d;
scanf("%d", &d);
return d;
}
inline char rdc() {
scanf(" ");
return getchar();
}
inline string rds() {
string s;
cin >> s;
return s;
}
inline double rddb() {
double d;
scanf("%lf", &d);
return d;
}
template <class T>
inline bool setmin(T& a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool setmax(T& a, T b) {
return a < b ? a = b, true : false;
}
struct debugger {
template <typename T>
debugger& operator,(const T& x) {
cerr << x << ",";
return *this;
}
} dbgr;
const int N = 20;
struct Graph {
int v;
bool ma[N], mb[N];
bool operator<(const Graph& r) const { return v < r.v; }
} g;
int n, k, t;
vector<Graph> vg;
int main() {
vg.push_back(g), n = rdi(), k = rdi(), t = rdi();
for (int repp = 0; repp < (k); ++repp) {
int u = rdi() - 1, v = rdi() - 1, w = rdi();
for (int i_b = (((int)(vg).size())), i = (0); i < i_b; ++i)
if (!vg[i].ma[u] && !vg[i].mb[v]) {
vg[i].ma[u] = vg[i].mb[v] = true, vg[i].v += w;
vg.push_back(vg[i]);
vg[i].ma[u] = vg[i].mb[v] = false, vg[i].v -= w;
}
if (((int)(vg).size()) > t) {
nth_element(vg.begin(), vg.begin() + t - 1, vg.end());
vg.erase(vg.begin() + t, vg.end());
}
}
nth_element(vg.begin(), vg.begin() + t - 1, vg.end());
cout << vg[t - 1].v << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> MAP;
long long n, m, k, a[33];
long long dp[(1 << 18) + 5][19];
long long solve(long long mask, long long x) {
long long val = 0, maxval = 0;
if (__builtin_popcount(mask) == m) return 0;
if (dp[mask][x] != -1) return dp[mask][x];
for (long long i = 0; i < n; i++) {
if ((mask & (1 << i)) == 0) {
val = a[i] + MAP[{x + 1, i + 1}] + solve(mask | (1 << i), i);
if (val > maxval) maxval = val;
}
}
return dp[mask][x] = maxval;
}
int main() {
cin >> n >> m >> k;
memset(dp, -1, sizeof dp);
for (long long i = 0; i < n; i++) cin >> a[i];
while (k--) {
long long x, y, z;
cin >> x >> y >> z;
MAP[{x, y}] = z;
}
long long mask = 0, ans = 0;
for (long long i = 0; i < n; i++) {
long long res = solve((mask | 1 << i), i) + a[i];
if (res > ans) ans = res;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
vector<int> g[N], gt[N];
stack<int> st;
bool done[N];
int dist[N];
vector<vector<int>> comp;
int myComp[N];
void scc1(int a) {
done[a] = true;
for (auto x : g[a]) {
if (!done[x]) scc1(x);
}
st.push(a);
}
void scc2(int a) {
done[a] = true;
comp.back().push_back(a);
myComp[a] = comp.size() - 1;
for (auto x : gt[a]) {
if (!done[x]) scc2(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
gt[b].push_back(a);
}
for (int i = 0; i < (n); i++) {
if (!done[i]) {
scc1(i);
}
}
memset(done, 0, sizeof(done));
while (!st.empty()) {
int i = st.top();
st.pop();
if (done[i]) continue;
comp.push_back(vector<int>());
scc2(i);
}
memset(done, 0, sizeof(done));
int res = n;
for (int i = 0; i < (comp.size()); i++) {
if (comp[i].size() == 1) continue;
bool easy = false;
for (auto x : comp[i]) {
assert(myComp[x] == myComp[comp[i][0]]);
for (auto y : g[x]) {
if (myComp[y] != myComp[x]) {
easy = true;
break;
}
}
if (easy) break;
}
if (easy) continue;
int bestcyc = N;
for (auto fst : comp[i]) {
memset(dist, -1, sizeof(dist));
queue<int> q;
q.push(fst);
dist[fst] = 0;
int cyclen = -1;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (auto x : g[cur]) {
if (x == fst) {
cyclen = dist[cur] + 1;
break;
}
if (dist[x] != -1) continue;
dist[x] = dist[cur] + 1;
q.push(x);
}
if (cyclen != -1) break;
}
assert(cyclen != -1);
bestcyc = min(bestcyc, cyclen);
}
res += 998 * bestcyc + 1;
}
cout << res << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct Trie {
int sum, cnt;
Trie* f[2];
Trie() {
sum = 0;
cnt = 0;
memset(f, 0, sizeof(f));
}
};
Trie* root = new Trie();
const int MAX = 5005;
int dp[MAX][MAX], k, n;
char s[MAX];
void add(Trie* nod, int i, int j) {
if (j == n + 1) return;
int lit = s[j] - 'a';
if (nod->f[lit] == NULL) nod->f[lit] = new Trie;
if (dp[i][j]) nod->f[lit]->cnt++;
add(nod->f[lit], i, j + 1);
}
void dfs(Trie* nod) {
nod->sum += nod->cnt;
for (int i = 0; i <= 1; i++)
if (nod->f[i] != NULL) {
dfs(nod->f[i]);
nod->sum += nod->f[i]->sum;
}
}
void mia(Trie* nod, int k) {
if (nod->cnt >= k) return;
k -= nod->cnt;
if (nod->f[0] != NULL && nod->f[0]->sum >= k) {
cout << 'a';
mia(nod->f[0], k);
} else {
cout << 'b';
if (nod->f[0] != NULL) k -= nod->f[0]->sum;
mia(nod->f[1], k);
}
}
int main() {
cin >> (s + 1) >> k;
n = strlen(s + 1);
for (int l = 1; l <= n; l++)
for (int i = 1, j = i + l - 1; j <= n; i++, j++)
if (s[i] == s[j])
if (i + 2 >= j - 2)
dp[i][j] = 1;
else
dp[i][j] = dp[i + 2][j - 2];
for (int i = 1; i <= n; i++) add(root, i, i);
dfs(root);
mia(root, k);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, u[maxn], v[maxn], w[maxn];
int ind[maxn];
int main(void) {
scanf("%d", &n);
for (int i = 1; i < n; i++)
scanf("%d%d", u + i, v + i), ind[u[i]]++, ind[v[i]]++, w[i] = -1;
int m = 0;
for (int i = 1; i <= n; i++)
if (ind[i] >= 3) {
for (int j = 1; j < n; j++)
if (u[j] == i || v[j] == i) {
w[j] = m++;
if (m == 3) break;
}
break;
}
for (int i = 1; i < n; i++)
if (w[i] == -1) w[i] = m++;
for (int i = 1; i < n; i++) printf("%d\n", w[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 200333;
using namespace std;
int n, m, fa[N], ans;
map<int, vector<pair<int, int> > > M;
int find(int u) {
if (fa[u] == u) return u;
return fa[u] = find(fa[u]);
}
void merge(int u, int v) {
int tx = find(u), ty = find(v);
if (tx != ty) fa[tx] = ty;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int u, v, w, i = 1; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &w);
M[w].push_back({u, v});
}
for (auto A : M) {
int tmp = 0;
for (auto B : A.second) {
if (find(B.first) != find(B.second)) ++tmp;
}
for (auto B : A.second) {
if (find(B.first) != find(B.second)) merge(B.first, B.second), --tmp;
}
ans += tmp;
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i <= n; i++) {
for (int x = 0; x < n; x++) {
if (s[x] == '.') continue;
int j = x;
int num = 1;
while (j < n) {
j += i;
if (j < n && s[j] == '*')
num++;
else
break;
}
if (num >= 5) {
cout << "yes" << endl;
return 0;
}
}
}
cout << "no" << endl;
}
| 2 |
#include <bits/stdc++.h>
using std::bitset;
using std::pair;
using std::swap;
int read() {
int x;
scanf("%d", &x);
return x;
}
bitset<4007> a[2007];
pair<int, int> e[500007];
int main() {
int n = read(), m = read();
for (int i = 1, u, v; i <= m; ++i)
e[i] = {u = read(), v = read()}, a[u][v] = 1;
for (int i = 1; i <= n; ++i) a[i][i + n] = 1;
for (int i = 1; i <= n; ++i) {
if (!a[i][i])
for (int j = i + 1; j <= n; ++j)
if (a[j][i]) {
swap(a[j], a[i]);
break;
}
for (int j = 1; j <= n; ++j)
if (j ^ i && a[j][i]) a[j] ^= a[i];
}
for (int i = 1; i <= m; ++i)
puts(a[e[i].second][e[i].first + n] ? "NO" : "YES");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long int modadd(long long int n, long long int m) {
long long int sum = ((n + m) % 1000000007 + 1000000007) % 1000000007;
return sum;
}
inline long long int modsub(long long int n, long long int m) {
long long int diff =
((n - m + 1000000007) % 1000000007 + 1000000007) % 1000000007;
return diff;
}
inline long long int modpro(long long int n, long long int m) {
long long int pro = ((n * m) % 1000000007 + 1000000007) % 1000000007;
return pro;
}
inline long long int pow(int x, int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
inline long long int powmod(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = modpro(res, x);
y = y >> 1;
x = modpro(x, x);
}
return res;
}
class pr {
public:
long long int parent;
long long int rank;
};
long long int find(pr subs[], long long int i) {
if (subs[i].parent != i) subs[i].parent = find(subs, subs[i].parent);
return subs[i].parent;
}
void Union(pr subs[], long long int x, long long int y) {
long long int xroot = find(subs, x);
long long int yroot = find(subs, y);
if (subs[xroot].rank < subs[yroot].rank) {
subs[xroot].parent = yroot;
} else if (subs[xroot].rank > subs[yroot].rank) {
subs[yroot].parent = xroot;
} else {
subs[yroot].parent = xroot;
subs[xroot].rank++;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int a, b;
cin >> a >> b;
if ((a + b) % 3 != 0) {
cout << "NO\n";
continue;
}
long long int c = (a + b) / 3;
if (a < c || b < c) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> pi;
vector<pair<int, int> > v;
map<int, int> mp;
int main() {
int n, i, x;
scanf("%d", &n);
pi.first = 1;
for (i = 1; i <= n; i++) {
scanf("%d", &x);
if (mp.count(x) == NULL)
mp[x] = 1;
else {
pi.second = i;
v.push_back(pi);
mp.clear();
pi.first = i + 1;
}
}
if (v.size() == 0)
printf("-1");
else {
x = v.size();
printf("%d\n", x);
for (i = 0; i < (x - 1); i++) {
pi = v[i];
printf("%d %d\n", pi.first, pi.second);
}
pi = v[x - 1];
printf("%d %d\n", pi.first, n);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int mod = 1000000007;
long long len, n, dp[maxn][2], num;
char s[maxn], t[maxn];
int read();
int Search() {
int ret = 0, flg = 0;
for (int i = 0; i < len; ++i) {
flg = 0;
for (int j = 0; j < len; ++j) {
if (s[(i + j) % len] != t[j]) {
flg = 1;
break;
}
}
if (!flg) ret++;
}
return ret;
}
int main() {
scanf("%s%s%I64d", s, t, &n);
len = strlen(s);
int flg = 0;
for (int i = 0; i < len; ++i)
if (s[i] != t[i]) {
flg = 1;
break;
}
if (flg)
dp[0][1] = 1;
else
dp[0][0] = 1;
num = Search();
for (int i = 1; i <= n; ++i) {
dp[i][1] =
dp[i - 1][0] * (len - num) % mod + (len - num - 1) * dp[i - 1][1] % mod;
dp[i][0] = dp[i - 1][1] * num % mod + dp[i - 1][0] * (num - 1) % mod;
dp[i][1] %= mod;
dp[i][1] += mod;
dp[i][1] %= mod;
dp[i][0] %= mod;
dp[i][0] += mod;
dp[i][0] %= mod;
}
printf("%I64d\n", dp[n][0]);
return 0;
}
int read() {
int ret = 0, sig = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') sig = 1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
ret = (ret << 3) + (ret << 1) + ch - 48;
ch = getchar();
}
if (sig) return -ret;
return ret;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long m;
long long solve(long long l, long long n, long long x) {
if (x & 1) return l - 1 + x;
if (n & 1) {
if (x == 2) return solve(l + n + 1, n / 2, n / 2);
return solve(l + n + 1, n / 2, x / 2 - 1);
} else {
return solve(l + n, n / 2, x / 2);
}
}
int main() {
long long n, x;
int Q;
scanf("%I64d%d", &n, &Q);
while (Q--) {
scanf("%I64d", &x);
printf("%I64d\n", solve(1, n, x) / 2 + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int cnt[26], cnt2[26];
int main() {
int n;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cnt[a[i] - 'a']++;
cnt2[b[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (cnt[i] != cnt2[i]) {
puts("-1");
return 0;
}
}
int en = n - 1;
vector<int> op;
for (int i = 0; i < n; i++) {
int j;
for (j = en--; j >= 0 && b[i] != a[j]; j--)
;
op.push_back(n - j - 1);
op.push_back(1);
op.push_back(n - 1);
for (int k = j; k <= en; k++) swap(a[k], a[k + 1]);
reverse(a.begin(), a.begin() + j);
}
printf("%d\n", (int)op.size());
for (int x = 0; x < op.size(); x++) printf("%d ", op[x]);
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[400005], freq[1000005];
vector<int> v;
int main() {
int t;
scanf("%d", &t);
while (t--) {
v.clear();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v.push_back(a[i]);
freq[a[i]]++;
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
reverse(v.begin(), v.end());
int g = 0, s = 0, b = 0;
int j = 0;
for (int i = j; i < v.size(); i++) {
int x = v[i];
g += freq[x];
j = i + 1;
break;
}
for (int i = j; i < v.size(); i++) {
int x = v[i];
s += freq[x];
j = i + 1;
if (s > g) break;
}
for (int i = j; i < v.size(); i++) {
int x = v[i];
if ((g + s + b + freq[x]) * 2 > n) break;
b += freq[x];
j = i + 1;
}
if (g == 0 || s == 0 || b == 0 || (g + s + b) * 2 > n || g >= s || g >= b)
printf("0 0 0 \n");
else
printf("%d %d %d\n", g, s, b);
for (int i = 1; i <= n; i++) freq[a[i]] = 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1005];
int arr[1005];
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
vis[arr[i]] = 1;
}
int ans = -1;
int b;
for (int i = 0; i < m; i++) {
cin >> b;
if (vis[b]) ans = b;
}
memset(vis, 0, sizeof(vis));
if (ans == -1)
cout << "NO" << endl;
else
cout << "YES\n1 " << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
;
int x = ch - '0';
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
x = x * 10 + ch - '0';
return x;
}
const int N = 1e5 + 5;
int n, m, k, p, cnt[N];
long long l[N], h[N], a[N];
bool check(long long x) {
long long tot = 0;
for (int i = 1; i <= n; i++)
l[i] = h[i] + a[i] * m, tot += max(0ll, (l[i] - x + p - 1) / p);
if (tot > m * k) return 0;
for (int i = 0; i <= m; i++) cnt[i] = 0;
for (int i = 1; i <= n; i++)
if (l[i] > x)
for (long long tmp = (l[i] - x - 1) % p + 1; tmp <= l[i] - x; tmp += p)
if (tmp <= h[i])
cnt[0]++;
else if (tmp > h[i] + a[i] * (m - 1))
return 0;
else
cnt[(tmp - h[i] + a[i] - 1) / a[i]]++;
int ret = 0;
for (int i = 0; i <= m - 1; i++) {
ret += cnt[i];
ret = max(0, ret - k);
}
return !ret;
}
int main() {
n = read();
m = read();
k = read();
p = read();
for (int i = 1; i <= n; i++) h[i] = read(), a[i] = read();
long long l = 0, r = 1e15, ans = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct St {
int h, sx, nom, type;
};
bool operator<(St a, St b) { return a.sx > b.sx; }
St st[200000];
int k[100000];
int i, n, n2;
long long s, npart, npica, a, b, c, d, fc, fd;
int cnt[100001];
long long sum(long long npi_1) {
long long npart_1 = npi_1 * npart;
long long npi_2 = npica - npi_1;
long long npart_2 = npi_2 * npart;
long long count, ans = 0;
for (int i = 0; i < 100000; i++) cnt[i] = k[i];
for (int i = 0; i < 200000; i++) {
if (cnt[st[i].nom] == 0) continue;
if (st[i].type == 1) {
if (npart_1 == 0) continue;
count = npart_1;
if (count > cnt[st[i].nom]) count = cnt[st[i].nom];
ans = ans + count * st[i].h;
cnt[st[i].nom] -= count;
npart_1 -= count;
} else {
if (npart_2 == 0) continue;
count = npart_2;
if (count > cnt[st[i].nom]) count = cnt[st[i].nom];
ans = ans + count * st[i].h;
cnt[st[i].nom] -= count;
npart_2 -= count;
}
}
return ans;
}
int main() {
int n, ha, hb;
cin >> n >> npart;
for (int i = 0; i < n; i++) {
cin >> k[i] >> ha >> hb;
st[n2].h = ha;
st[n2].sx = ha - hb;
st[n2].nom = i;
st[n2++].type = 1;
st[n2].h = hb;
st[n2].sx = hb - ha;
st[n2].nom = i;
st[n2++].type = 2;
s += k[i];
}
sort(st, st + n2);
npica = s / npart;
if (npica * npart < s) npica++;
a = 0;
b = npica;
while (a < b) {
c = a + (b - a) / 3;
d = b - (b - a) / 3;
fc = sum(c);
fd = sum(d);
if (fc == fd) {
a = c + 1;
b = d;
} else {
if (fc > fd)
b = d - 1;
else
a = c + 1;
}
}
cout << sum(a) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int bin1(long long int x) {
int r = 0;
while (x) {
r++;
x &= x - 1;
}
return r;
}
long long int exgcd(long long int a, long long int b, long long int &x,
long long int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1, __gcd = exgcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return __gcd;
}
long long int modpow(long long int b, long long int e, long long int m) {
long long int r = 1;
b = b % m;
while (e > 0) {
if (e % 2 == 1) r = (r * b) % m;
e /= 2;
b = (b * b) % m;
}
return r;
}
long long int modinverse(long long int a, long long int mod) {
return modpow(a, mod - 2, mod);
}
long long int modinverse2(long long int a, long long int m) {
long long int x, y;
exgcd(a, m, x, y);
while (x < 0) x += m;
return x;
}
long long int nCrmod(long long int n, long long int r, long long int m) {
if (r > n) r = n - r;
long long int res = 1;
for (long long int i = r; i >= 1; i--) {
res = (res * (n - i + 1)) % m;
res = (res * modinverse(i, m));
}
return res;
}
long long int power(long long int b, long long int e) {
if (e == 0) return 1;
if (e % 2 == 0) return power(b * b, e / 2);
return b * power(b * b, e / 2);
}
double powerf(double b, int e) {
if (e == 0) return 1;
if (e % 2 == 0)
return powerf(b * b, e / 2);
else {
if (e > 0)
return b * powerf(b * b, e / 2);
else
return powerf(b * b, e / 2) / b;
}
}
long long int totient(long long int n) {
long long int res = n, p;
for (p = 2; p * p <= n; p++) {
if (n % p == 0) {
while (n % p == 0) n /= p;
res -= res / p;
}
}
if (n > 1) res -= res / n;
return res;
}
bool isprime(long long int x) {
if (x == 1) return false;
for (long long int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
bool prime[1010 + 1];
void sieve() {
long long int x, y;
prime[0] = prime[1] = true;
for (x = 2; x * x <= 1010; x++) {
if (!prime[x])
for (y = x * x; y <= 1010; y += x) prime[y] = true;
}
}
long long int lpf(long long int x) {
while (x % 2 == 0) x /= 2;
if (x < 2) return 2;
long long int i = 3;
while (x > i) {
if (x % i)
i += 2;
else
while (x % i == 0) x /= i;
}
return i;
}
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
using namespace std;
void gcj() {
long long int t;
cin >> t;
for (long long int c = 1; c <= t; c++) {
cout << "Case #" << c << ": ";
cout << endl;
}
}
void judge() {
long long int n, m, q, a, b, c, ans = 0;
cin >> n;
for (long long int i = 0; i < n; i++) cin >> q;
vector<long long int> parent(n, 0);
vector<long long int> cost(n, INT_MAX);
cin >> m;
while (m--) {
cin >> a >> b >> c;
if (parent[b - 1] == 0) parent[b - 1] = 1;
cost[b - 1] = min(cost[b - 1], c);
}
if (count(parent.begin(), parent.end(), 0) != 1) {
cout << -1;
return;
}
for (long long int i = 0; i < n; i++)
if (parent[i]) ans += cost[i];
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int t = 1;
while (t--) {
judge();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
struct DominatorTree {
static const int MAXN = 200010;
int n, s;
vector<int> g[MAXN], pred[MAXN];
vector<int> cov[MAXN];
int dfn[MAXN], nfd[MAXN], ts;
int par[MAXN];
int sdom[MAXN], idom[MAXN];
int mom[MAXN], mn[MAXN], sz[MAXN];
long long val[MAXN];
inline bool cmp(int u, int v) { return dfn[u] < dfn[v]; }
int eval(int u) {
if (mom[u] == u) return u;
int res = eval(mom[u]);
if (cmp(sdom[mn[mom[u]]], sdom[mn[u]])) mn[u] = mn[mom[u]];
return mom[u] = res;
}
void init(int _n, int _s) {
n = _n;
s = _s;
}
void add_edge(int u, int v) {
g[u].push_back(v);
pred[v].push_back(u);
}
void DFS(int u) {
ts++;
dfn[u] = ts;
nfd[ts] = u;
for (int i = 0, v; i < g[u].size(); i++)
if (dfn[v = g[u][i]] == 0) {
par[v] = u;
DFS(v);
}
}
void build() {
ts = 0;
for (int i = 1; i <= n; i++) {
dfn[i] = nfd[i] = 0;
cov[i].clear();
mom[i] = mn[i] = sdom[i] = i;
}
DFS(s);
for (int i = ts; i >= 2; i--) {
int u = nfd[i];
if (u == 0) continue;
for (int i = 0, v; i < pred[u].size(); i++)
if (dfn[v = pred[u][i]]) {
eval(v);
if (cmp(sdom[mn[v]], sdom[u])) sdom[u] = sdom[mn[v]];
}
cov[sdom[u]].push_back(u);
mom[u] = par[u];
for (int i = 0, w; i < cov[par[u]].size(); i++) {
eval(w = cov[par[u]][i]);
if (cmp(sdom[mn[w]], par[u]))
idom[w] = mn[w];
else
idom[w] = par[u];
}
cov[par[u]].clear();
}
for (int i = 2; i <= ts; i++) {
int u = nfd[i];
if (u == 0) continue;
if (idom[u] != sdom[u]) idom[u] = idom[idom[u]];
}
for (int i = ts; i >= 2; i--) {
int u = nfd[i];
if (u == 0) continue;
sz[u]++;
sz[idom[u]] += sz[u];
}
}
} dom;
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
vector<pair<long long, int> > adj[200200];
long long dis[200200];
void dijkstra(int n, int u) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
for (int i = 1; i <= n; i++) dis[i] = inf;
q.push(pair<long long, int>(dis[u] = 0, u));
while (!q.empty()) {
auto p = q.top();
q.pop();
if (p.first > dis[u = p.second]) continue;
for (pair<long long, int> e : adj[u]) {
int v = e.second;
if (dis[v] > dis[u] + e.first) {
dis[v] = dis[u] + e.first;
q.push(pair<long long, int>(dis[v], v));
}
}
}
}
int main() {
int n, m, s;
cin >> n >> m >> s;
for (int i = 0; i < m; i++) {
int u, v, w;
gn(u, v), gn(w);
adj[u].push_back(pair<long long, int>(w, v));
adj[v].push_back(pair<long long, int>(w, u));
}
dijkstra(n, s);
dom.init(n, s);
for (int i = 1; i <= n; i++)
for (pair<long long, int> e : adj[i]) {
if (dis[e.second] == dis[i] + e.first) dom.add_edge(i, e.second);
}
dom.build();
int ans = 0;
for (int i = 1; i <= n; i++)
if (i != s) smax(ans, dom.sz[i]);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string s[60];
int vis[60][60], n, m, suma;
vector<pair<int, int> > V;
bool puede(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m && vis[x][y] == 0) return true;
return false;
}
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << vis[i][j];
}
cout << endl;
}
}
void solve(int x, int y) {
memset(vis, 0, sizeof(vis));
queue<pair<int, int> > q;
q.push(make_pair(x, y));
vis[x][y] = 1;
while (!q.empty()) {
pair<int, int> p = q.front();
x = p.first;
y = p.second;
suma++;
q.pop();
if (puede(x - 1, y) && s[x - 1][y] == '#') {
q.push(make_pair(x - 1, y));
vis[x - 1][y] = 1;
}
if (puede(x + 1, y) && s[x + 1][y] == '#') {
q.push(make_pair(x + 1, y));
vis[x + 1][y] = 1;
}
if (puede(x, y + 1) && s[x][y + 1] == '#') {
q.push(make_pair(x, y + 1));
vis[x][y + 1] = 1;
}
if (puede(x, y - 1) && s[x][y - 1] == '#') {
q.push(make_pair(x, y - 1));
vis[x][y - 1] = 1;
}
}
}
int main() {
int x, y, cont = 0;
bool flag = true;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') {
cont++;
if (flag) {
flag = false;
x = i;
y = j;
}
V.push_back(make_pair(i, j));
}
}
}
if (cont <= 2) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < V.size(); i++) {
suma = 0;
s[V[i].first][V[i].second] = '.';
if (i == 0) {
solve(V[1].first, V[1].second);
} else {
solve(V[0].first, V[0].second);
}
if (suma != cont - 1) {
cout << "1" << endl;
return 0;
}
s[V[i].first][V[i].second] = '#';
}
cout << "2" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int je = 998244353;
set<pair<int, int> > blk[200001];
struct node {
struct node *l;
struct node *r;
int s, e;
long long val;
long long la1, la2;
};
void upd(node *me, int l, int r, int x, int y) {
if (me->s == l && me->e == r) {
me->la1 = (me->la1 + x) % je;
me->la2 = (me->la2 * y) % je;
me->la1 = (me->la1 * y) % je;
} else {
me->l->la1 = (me->l->la1 * me->la2) % je;
me->l->la2 = (me->l->la2 * me->la2) % je;
me->l->la1 = (me->l->la1 + me->la1) % je;
me->r->la1 = (me->r->la1 * me->la2) % je;
me->r->la2 = (me->r->la2 * me->la2) % je;
me->r->la1 = (me->r->la1 + me->la1) % je;
me->la1 = 0;
me->la2 = 1;
int mid = (me->s + me->e) / 2;
if (r <= mid) {
upd(me->l, l, r, x, y);
} else if (l > mid) {
upd(me->r, l, r, x, y);
} else {
upd(me->l, l, mid, x, y);
upd(me->r, mid + 1, r, x, y);
}
long long lcal = (((me->l->val * me->l->la2) % je) +
((me->l->la1 * (me->l->e - me->l->s + 1)) % je)) %
je;
long long rcal = (((me->r->val * me->r->la2) % je) +
((me->r->la1 * (me->r->e - me->r->s + 1)) % je)) %
je;
me->val = (lcal + rcal) % je;
}
}
long long gett(node *me, int l, int r) {
if (me->s == l && me->e == r) {
return (((me->val * me->la2) % je) +
((me->la1 * (me->e - me->s + 1)) % je)) %
je;
} else {
me->l->la1 = (me->l->la1 * me->la2) % je;
me->l->la2 = (me->l->la2 * me->la2) % je;
me->l->la1 = (me->l->la1 + me->la1) % je;
me->r->la1 = (me->r->la1 * me->la2) % je;
me->r->la2 = (me->r->la2 * me->la2) % je;
me->r->la1 = (me->r->la1 + me->la1) % je;
me->la1 = 0;
me->la2 = 1;
int mid = (me->s + me->e) / 2;
long long cal = 0;
if (r <= mid) {
cal = gett(me->l, l, r);
} else if (l > mid) {
cal = gett(me->r, l, r);
} else {
cal = (gett(me->l, l, mid) + gett(me->r, mid + 1, r)) % je;
}
long long lcal = (((me->l->val * me->l->la2) % je) +
((me->l->la1 * (me->l->e - me->l->s + 1)) % je)) %
je;
long long rcal = (((me->r->val * me->r->la2) % je) +
((me->r->la1 * (me->r->e - me->r->s + 1)) % je)) %
je;
me->val = (lcal + rcal) % je;
return cal;
}
}
node *root = new node();
void maketree(node *me) {
if (me->s == me->e)
return;
else {
node *ll = new node();
node *rr = new node();
*ll = {NULL, NULL, me->s, (me->s + me->e) / 2, 0, 0, 1};
*rr = {NULL, NULL, (me->s + me->e) / 2 + 1, me->e, 0, 0, 1};
me->l = ll;
me->r = rr;
maketree(ll);
maketree(rr);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
*root = {NULL, NULL, 1, n, 0, 0, 1};
maketree(root);
for (int i = 0; i < m; i++) {
int mode;
int l, r, x;
scanf("%d", &mode);
if (mode == 1) {
scanf("%d%d%d", &l, &r, &x);
auto sit = blk[x].lower_bound({l - 1, -1});
auto eit = blk[x].upper_bound({r + 1, n + 2});
if (sit != blk[x].begin()) sit--;
while (sit != eit && (*sit).second < l - 1) {
sit++;
}
upd(root, l, r, 1, 1);
if (sit == eit) {
blk[x].insert({l, r});
} else {
int newl = min((*sit).first, l);
auto rsit = eit;
rsit--;
int newr = max((*rsit).second, r);
while (sit != eit) {
auto nxt = sit;
nxt++;
int pl = max((*sit).first, l);
int pr = min((*sit).second, r);
if (pl <= pr) {
upd(root, pl, pr, -1, 2);
}
blk[x].erase(sit);
sit = nxt;
}
blk[x].insert({newl, newr});
}
} else {
scanf("%d%d", &l, &r);
printf("%lld\n", gett(root, l, r));
}
}
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
const int MOD = 1e9 + 7;
inline int addmod(int a, int b) { return (a + b) % MOD; }
inline int mulmod(long long a, int b) { return (a * b) % MOD; }
int f[MAXN][4];
int get(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 0;
}
int res = 0;
for (int j = 0; j < 4; j++) {
res = addmod(res, f[n - 2][j]);
}
return addmod(res, MOD - 2);
}
int main() {
f[0][0] = 1;
f[0][1] = 1;
f[0][2] = 1;
f[0][3] = 1;
for (int i = 1; i < MAXN; i++) {
f[i][0] = f[i - 1][2];
f[i][3] = f[i - 1][1];
f[i][1] = addmod(f[i - 1][2], f[i - 1][0]);
f[i][2] = addmod(f[i - 1][3], f[i - 1][1]);
}
int n, m;
scanf("%d%d", &n, &m);
printf("%d\n", addmod(2, addmod(get(n), get(m))));
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 5 * 1e5 + 1;
const int MOD = 1000003;
int n, m;
char *g[MAXN];
bool H[MAXN][5];
bool V[MAXN][5];
long long memof[MAXN][5];
long long memoh[MAXN][5];
long long f(int i, int prev) {
if (i == m) return 1;
long long &res = memof[i][prev];
if (res != -1) return res;
res = 0;
if (prev == 1 || prev == 2) {
if (H[i][3]) res += f(i + 1, 3);
res %= MOD;
if (H[i][4]) res += f(i + 1, 4);
res %= MOD;
} else {
if (H[i][1]) res += f(i + 1, 1);
res %= MOD;
if (H[i][2]) res += f(i + 1, 2);
res %= MOD;
}
return res;
}
long long h(int i, int prev) {
if (i == n) return 1;
long long &res = memoh[i][prev];
if (res != -1) return res;
res = 0;
if (prev == 2 || prev == 3) {
if (V[i][1]) res += h(i + 1, 1);
res %= MOD;
if (V[i][4]) res += h(i + 1, 4);
res %= MOD;
} else {
if (V[i][2]) res += h(i + 1, 2);
res %= MOD;
if (V[i][3]) res += h(i + 1, 3);
res %= MOD;
}
return res;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
g[i] = new char[m + 1];
scanf("%s", g[i]);
}
for (int i = 0; i < m; i++) {
for (int k = 1; k <= 5; k++) memof[i][k] = -1;
if (g[0][i] == '.') {
for (int j = 1; j <= 4; j++) H[i][j] = true;
} else {
for (int j = 1; j <= 4; j++) H[i][j] = false;
H[i][g[0][i] - '0'] = true;
}
}
for (int i = 0; i < n; i++) {
for (int k = 1; k <= 5; k++) memoh[i][k] = -1;
if (g[i][0] == '.') {
for (int j = 1; j <= 4; j++) V[i][j] = true;
} else {
for (int j = 1; j <= 4; j++) V[i][j] = false;
V[i][g[i][0] - '0'] = true;
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (g[i][j] == '.') continue;
g[i][j] -= '0';
if (i % 2 == 0) {
if (g[i][j] == 2 || g[i][j] == 3) {
H[j][1] = H[j][4] = false;
} else {
H[j][2] = H[j][3] = false;
}
} else {
if (g[i][j] == 2 || g[i][j] == 3) {
H[j][2] = H[j][3] = false;
} else {
H[j][1] = H[j][4] = false;
}
}
if (j % 2 == 0) {
if (g[i][j] == 1 || g[i][j] == 2) {
V[i][3] = V[i][4] = false;
} else {
V[i][1] = V[i][2] = false;
}
} else {
if (g[i][j] == 1 || g[i][j] == 2) {
V[i][1] = V[i][2] = false;
} else {
V[i][3] = V[i][4] = false;
}
}
}
}
long long res = 0;
for (int i = 1; i <= 4; i++) {
if (!V[0][i] || !H[0][i]) continue;
res = res + f(1, i) * h(1, i);
res %= MOD;
}
printf("%d\n", int(res));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 100;
vector<long long> ver[MAXN], com[MAXN], ps[MAXN];
long long vis[MAXN], dis[MAXN];
long long mxr, mxid;
void dfs(long long v, long long col = -1, long long h = 0, long long par = -1) {
vis[v] = max(vis[v], col);
if (mxr < h) mxid = v, mxr = h;
dis[v] = max(h, dis[v]);
if (col > 0) com[col].push_back(dis[v]);
for (auto u : ver[v]) {
if (u == par) continue;
dfs(u, col, h + 1, v);
}
}
map<pair<long long, long long>, long long> check;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
x--, y--;
ver[x].push_back(y);
ver[y].push_back(x);
}
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (vis[i]) continue;
mxr = 0, mxid = i;
dfs(i);
mxr = 0;
dfs(mxid);
dfs(mxid, ++cnt);
sort(com[cnt].begin(), com[cnt].end());
ps[cnt].push_back(0);
for (auto v : com[cnt]) ps[cnt].push_back(ps[cnt].back() + v);
}
cout << fixed << setprecision(10);
while (q--) {
long long x, y;
cin >> x >> y;
x--, y--;
x = vis[x];
y = vis[y];
if (com[x].size() > com[y].size()) swap(x, y);
if (x == y) {
cout << -1 << '\n';
continue;
}
if (check[{x, y}] > 0) {
cout << double(check[{x, y}]) / (1ll * com[x].size() * com[y].size())
<< '\n';
continue;
}
long long ans = 0, mxd = max(com[x].back(), com[y].back());
for (auto v : com[x]) {
long long num = lower_bound(com[y].begin(), com[y].end(), mxd - v - 1) -
com[y].begin();
ans += num * mxd + (com[y].size() - num) * (v + 1) + ps[y].back() -
ps[y][num];
}
check[{x, y}] = ans;
cout << double(check[{x, y}]) / (1ll * com[x].size() * com[y].size())
<< '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, q;
cin >> q;
while (q--) {
vector<long long> a;
cin >> n;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
a.push_back(k);
}
long long k = 1000000001;
long long ans = 0;
for (long long i = n - 1; i >= 0; i--) {
if (a[i] <= k) {
k = a[i];
} else
ans++;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <cstdio>
#include <vector>
#include <algorithm>
const int BLK=500;
const int MAXN=100005;
int as[MAXN];
int N;
std::vector<int> st[MAXN*4];
std::vector<int> st2[MAXN*4];
void build(int w,int L,int R,int a,int b){
if(a>=R||b<=L) return;
st[w].clear();
if(R-L==1){
st[w].push_back(as[L]);
}else{
int M=(L+R)/2;
build(w*2+1,L,M,a,b);
build(w*2+2,M,R,a,b);
if(R-L<=BLK){
int shift=0;
int i=0,j=0;
const auto& lchd=st[w*2+1];
const auto& rchd=st[w*2+2];
while(i<lchd.size()||j<rchd.size()){
if(j==rchd.size()||(i<lchd.size()&&lchd[i]+shift<rchd[j])){
st[w].push_back(lchd[i++]+shift);
}else{
st[w].push_back(rchd[j++]);
shift++;
}
}
/*
fprintf(stderr,"[%d,%d]:",L,R);
for(int x:st[w]){
fprintf(stderr," %d",x);
}
fprintf(stderr,"\n");
*/
}
}
st2[w].clear();
for(int i=0;i<st[w].size();i++){
st2[w].push_back(st[w][i]-i);
}
}
int query(int w,int L,int R,int a,int b,int v){
int v0=v;
if(a>=R||b<=L){
//do nothing
}else if(a<=L&&b>=R&&R-L<=BLK){
v+=(std::upper_bound(st2[w].begin(),st2[w].end(),v)-st2[w].begin());
}else{
int M=(L+R)/2;
v=query(w*2+1,L,M,a,b,v);
v=query(w*2+2,M,R,a,b,v);
}
//printf("query[%d,%d](%d,%d,%d)=%d\n",L,R,a,b,v0,v);
return v;
}
int main(){
scanf("%d",&N);
for(int i=0;i<N;i++){
int B;
scanf("%d",&B);
as[i]=i-B;
}
build(0,0,N,0,N);
int Q;
scanf("%d",&Q);
while(Q--){
/*
printf("A: ");
for(int i=0;i<N;i++){
printf(" %d",as[i]);
}printf("\n");
*//*printf("Recover:");
for(int i=0;i<N;i++){
printf(" %d",query(0,0,N,i+1,N,as[i])+1);
}
printf("\n");*/
int T;
scanf("%d",&T);
if(T==1){
int I,X;
scanf("%d %d",&I,&X);
I--;
as[I]=I-X;
build(0,0,N,I,I+1);
}else{
int I;
scanf("%d",&I);
I--;
printf("%d\n",query(0,0,N,I+1,N,as[I])+1);
}
}
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (1 << 29) + 5;
const long long int LLINF = (1ll << 59) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 300 * 1000 + 5;
const int MAX_Q = 300 * 1000 + 5;
int n, q;
vector<int> graph[MAX_N];
int size_of[MAX_N];
int prev_of[MAX_N];
int big_subtree[MAX_N];
int ans[MAX_N];
bool is_centroid_of_subtree(int v, int c) {
return ((size_of[v] - size_of[c]) * 2 <= size_of[v] &&
big_subtree[c] * 2 <= size_of[v]);
}
void dfs_calc(int v, int p) {
big_subtree[v] = 0;
size_of[v] = 1;
prev_of[v] = p;
for (int i = 0; i < graph[v].size(); ++i) {
dfs_calc(graph[v][i], v);
size_of[v] += size_of[graph[v][i]];
big_subtree[v] = max(big_subtree[v], size_of[graph[v][i]]);
}
}
void dfs_centroid(int v) {
if (size_of[v] == 1) {
ans[v] = v;
} else {
int ptr = 0;
for (int i = 0; i < graph[v].size(); ++i) {
dfs_centroid(graph[v][i]);
if (size_of[graph[v][ptr]] < size_of[graph[v][i]]) {
ptr = i;
}
}
int c = ans[graph[v][ptr]];
while (!is_centroid_of_subtree(v, c)) {
c = prev_of[c];
}
ans[v] = c;
}
}
int main() {
scanf("%d %d", &n, &q);
int v;
for (int i = 0; i < n - 1; ++i) {
scanf("%d", &v);
graph[v - 1].push_back(i + 1);
}
dfs_calc(0, 0);
dfs_centroid(0);
for (int i = 0; i < q; ++i) {
scanf("%d", &v);
printf("%d\n", ans[v - 1] + 1);
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 105;
int n, m, x, y, k, l, i, j, a[Nmax][Nmax][3][3];
bool used[Nmax][Nmax];
int grundy(int l1, int l2, int r1, int r2);
int go(int l1, int l2, int r1, int r2, int x, int y) {
int ans = 0;
if (x == l1)
ans ^= 0;
else if (x == l1 + 1) {
if (r1 == y + 1)
ans ^= 0;
else
ans ^= grundy(l1, l1, (y ^ 1) + 1, (y ^ 1) + 1);
} else
ans ^= grundy(l1, x - 1, r1, (y ^ 1) + 1);
if (x == l2)
ans ^= 0;
else if (x == l2 - 1) {
if (r2 == y + 1)
ans ^= 0;
else
ans ^= grundy(l2, l2, (y ^ 1) + 1, (y ^ 1) + 1);
} else
ans ^= grundy(x + 1, l2, (y ^ 1) + 1, r2);
return ans;
}
int grundy(int l1, int l2, int r1, int r2) {
if (a[l1][l2][r1][r2] != -1) return a[l1][l2][r1][r2];
int i, ap[505];
memset(ap, 0, sizeof(ap));
for (i = l1; i <= l2; ++i) {
if (!used[i][0] && !(i == l1 && r1 == 1) && !(i == l2 && r2 == 1))
ap[go(l1, l2, r1, r2, i, 0)] = 1;
if (!used[i][1] && !(i == l1 && r1 == 2) && !(i == l2 && r2 == 2))
ap[go(l1, l2, r1, r2, i, 1)] = 1;
}
for (i = 0;; ++i)
if (!ap[i]) return a[l1][l2][r1][r2] = i;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &x, &y);
--x;
--y;
used[x][y] = used[x][y ^ 1] = 1;
if (x - 1 >= 0) used[x - 1][y ^ 1] = 1;
if (x + 1 < n) used[x + 1][y ^ 1] = 1;
}
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j)
for (k = 0; k < 3; ++k)
for (l = 0; l < 3; ++l) a[i][j][k][l] = -1;
printf("%s\n", grundy(0, n - 1, 0, 0) == 0 ? "LOSE" : "WIN");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b;
cin >> a >> b;
a = abs(a - b);
int ans = 0;
int x = a / 5;
ans += x;
a -= x * 5;
if (a == 4 || a == 3)
ans += 2;
else if (a == 2 || a == 1)
ans += 1;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
int num;
scanf("%d", &num);
if (num == 2)
printf("2");
else if (num % 2 == 0)
printf("0");
else
printf("1");
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma optimize("-O3")
using namespace std;
const long long mod = 998244353;
int n, m, a, b, e, p[100005];
pair<int, pair<int, int> > edges[10 * 100005];
int fra, frb;
int fin(int i) {
if (p[i] != i) {
p[i] = fin(p[i]);
}
return p[i];
}
void solve() {
cin >> n >> m;
iota(p, p + n, 0);
cin >> fra >> frb >> e;
fra--;
frb--;
for (long long i = (long long)1; i != (long long)m; i = i + 1) {
cin >> a >> b >> e;
a--;
b--;
edges[i - 1] = make_pair(e, make_pair(a, b));
}
sort(edges, edges + m - 1);
for (long long i = (long long)0; i != (long long)m - 1; i = i + 1) {
a = edges[i].second.first;
b = edges[i].second.second;
a = fin(a);
b = fin(b);
if (a != b) {
p[a] = b;
if (fin(fra) == fin(frb)) {
cout << edges[i].first << '\n';
return;
}
}
}
cout << (int)1e9 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238L;
int fac[2000005] = {0};
void factorial() {
fac[0] = 1;
fac[1] = 1;
for (int i = 2; i < 200005; i++)
fac[i] = ((i % 1000000007) * (fac[i - 1] % 1000000007)) % 1000000007;
}
int power(int n, int m) {
int p = 1;
if (m == 0) return 1;
p = (power(n, m / 2) % 1000000007);
p = (p % 1000000007 * p % 1000000007) % 1000000007;
return (m & 1 ? ((p % 1000000007 * n % 1000000007) % 1000000007)
: (p % 1000000007));
}
int ncr(int n, int r) {
return ((fac[n] * power(fac[r], 1000000007 - 2)) % 1000000007 *
power(fac[n - r], 1000000007 - 2)) %
1000000007;
}
vector<pair<int, string>> v[100010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int r, x, y, x1, y1;
cin >> r >> x >> y >> x1 >> y1;
int step = 0;
int ans = ceil(hypot(x - x1, y - y1) / (r * 2));
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a, b;
int main() {
cin >> n;
a++;
int x = 1;
for (int i = 0; i < n; i++) {
int y;
cin >> y;
if (y < 0) x *= -1;
if (x == 1)
a++;
else
b++;
}
cout << a * b << " " << n * (n + 1) / 2 - a * b << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, t, p, a, b;
cin >> n >> a >> b;
if (b <= 0) {
b = -b;
b = b % n;
a = a - b;
if (a < 1) {
a = n + a;
}
cout << a << endl;
} else {
b = b % n;
a = a + b;
if (a > n) {
a = a - n;
}
cout << a << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 0, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
char s[105][3];
int o[128];
int n;
bool check(int i) {
for (int j = 1; j <= n; ++j) {
for (int k = j + 1; k <= n; ++k) {
if (s[j][0] != s[k][0] &&
((i >> o[s[j][0]] & 1) || (i >> o[s[k][0]] & 1)) ||
s[j][1] != s[k][1] &&
((i >> o[s[j][1]] & 1) || (i >> o[s[k][1]] & 1)))
;
else if (strcmp(s[j], s[k]))
return 0;
}
}
return 1;
}
int main() {
o['R'] = 0;
o['G'] = 1;
o['B'] = 2;
o['Y'] = 3;
o['W'] = 4;
o['1'] = 5;
o['2'] = 6;
o['3'] = 7;
o['4'] = 8;
o['5'] = 9;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; ++i) scanf("%s", s[i]);
int top = 1 << 10;
int ans = 1e9;
for (int i = 0; i < top; ++i) {
if (check(i)) {
int num = 0;
for (int j = i; j; j >>= 1) num += j & 1;
gmin(ans, num);
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
string s, home;
cin >> n;
cin >> home;
for (int i = 0; i < n; i++) {
cin >> s;
if (s[0] == home[0] && s[1] == home[1] && s[2] == home[2]) count++;
if (s[5] == home[0] && s[6] == home[1] && s[7] == home[2]) count--;
}
cout << (count == 0 ? "home" : "contest");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, i, j, x, ans;
cin >> t;
while (t--) {
cin >> n >> m;
vector<int> dp[n + m - 1];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> x;
int a = i + j;
int b = (n - i - 1) + (m - j - 1);
if (a != b) dp[min(a, b)].push_back(x);
}
}
ans = 0;
for (i = 0; i < n + m - 1; i++) {
int a = 0;
int b = 0;
for (j = 0; j < dp[i].size(); j++) {
if (dp[i][j] == 1)
a++;
else
b++;
}
ans += min(a, b);
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <typename Y>
inline bool updmin(Y &a, Y b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline bool updmax(Y &a, Y b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline Y abs(Y a) {
if (a < 0) a = -a;
return a;
}
template <typename Y>
inline Y sqr(Y a) {
return a * a;
}
int read() {
int w = 1, q = 0, ch = ' ';
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') w = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) q = q * 10 + ch - 48;
return q * w;
}
inline void FileIO() {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
const int N = 2000020;
int n;
std::vector<int> G[N];
char s[N];
inline void Main() {
n = read();
for (int i = 1; i <= n * 4; i++) {
G[i].clear();
}
for (int i = 1; i < n; i++) {
int x = read(), y = read();
{
G[x].push_back(y);
G[y].push_back(x);
};
}
scanf("%s", s + 1);
for (int i = 1, iend = n; i <= iend; i++) {
if (s[i] == 'W') {
{
G[i].push_back(n + 1);
G[n + 1].push_back(i);
};
{
G[n + 1].push_back(n + 2);
G[n + 2].push_back(n + 1);
};
{
G[n + 1].push_back(n + 3);
G[n + 3].push_back(n + 1);
};
n += 3;
}
}
int t3 = 0, x = 0, y = 0;
for (int i = 1; i <= n; i++) {
if (G[i].size() > 3) {
puts("White");
return;
};
if (G[i].size() == 3) {
int c = 0;
for (auto j : G[i]) {
c += G[j].size() >= 2;
}
if (c >= 2) {
puts("White");
return;
};
t3++;
(x ? y : x) = i;
}
}
int cx = 0, cy = 0;
for (auto i : G[x]) {
cx += G[i].size() == 1;
}
for (auto i : G[y]) {
cy += G[i].size() == 1;
}
if (cx == 2 && cy == 2 && (n & 1)) {
puts("White");
return;
};
{
puts("Draw");
return;
};
}
int main() {
int T = read();
while (T--) {
Main();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> c(n + 1);
vector<int> r(n + 1);
for (int i = 0; i < (int)(n); ++i) {
cin >> c[i + 1];
}
for (int i = 0; i < (int)(n); ++i) {
cin >> r[i + 1];
}
vector<pair<int, pair<int, int> > > a;
for (int i = 1; i <= n; i++) {
int C, R;
for (int j = 1; j <= n; j++) {
if (c[j] == i) {
C = j;
}
}
for (int j = 1; j <= n; j++) {
if (r[j] == i) {
R = j;
}
}
if (C == i && R == i) continue;
a.push_back(make_pair(i, make_pair(C, R)));
swap(c[C], c[i]);
swap(r[i], r[R]);
}
cout << a.size() << endl;
for (auto x : a) {
cout << x.second.first << " " << x.first << " " << x.first << " "
<< x.second.second << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, dx, dy;
cin >> n >> m >> dx >> dy;
vector<pair<long long, long long>> vp(m), vp2(n, {-1, -1});
for (auto& p : vp) {
long long x, y;
cin >> x >> y;
p = {x, y};
}
for (int i = 0; i < n; i++) {
if (vp2[i].first == -1) {
long long ct = 0;
long long cur = i;
while (vp2[cur].first == -1) {
vp2[cur].first = i;
vp2[cur].second = ct;
ct++;
cur += dx;
cur %= n;
}
}
}
map<pair<long long, long long>, int> mp;
for (auto p : vp) {
long long x1 = p.first, y1 = p.second;
long long x = vp2[x1].first, y = y1 - vp2[x1].second * dy;
y %= n;
if (y < 0) y += n;
pair<long long, long long> p2 = {x, y};
mp[p2]++;
}
int ans = -1;
pair<long long, long long> bp = {-1, -1};
for (auto p : mp) {
if (p.second > ans) {
ans = p.second;
bp = p.first;
}
}
cout << bp.first << ' ' << bp.second;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int flags[26] = {0};
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j <= s.size(); j++) {
char ch = s[j];
int c = (int)ch - 97;
flags[c]++;
}
}
bool check = true;
for (int i = 0; i < 26; i++) {
check = flags[i] % n == 0;
if (!check) {
break;
}
}
if (check) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1e9 + 1;
const long double EPS = 1e-9;
void precalc() {}
const int maxn = 20;
char table[maxn][maxn + 1];
int n;
bool read() {
if (scanf("%d", &n) < 1) {
return 0;
}
assert(n <= maxn);
for (int i = 0; i < n; ++i) {
scanf("%s", table[i]);
}
return 1;
}
int dp[2 * maxn][1 << maxn];
const int maxc = 26;
int solve(int sum, int mask) {
assert(mask);
if (sum == 2 * n - 2) {
return 0;
}
if (dp[sum][mask] != -INF) {
return dp[sum][mask];
}
int go[maxc];
for (int c = 0; c < maxc; ++c) {
go[c] = 0;
}
int maxpos = n - abs(n - 1 - sum);
int maxnpos = n - abs(n - 1 - (sum + 1));
int nx0 = min(n - 1, sum + 1), ny0 = sum + 1 - nx0;
for (int i = 0; i < maxpos; ++i) {
if (!((mask >> i) & 1)) {
continue;
}
for (int g = 0; g < 2; ++g) {
int npos = (i + g);
if (sum >= n - 1) {
--npos;
}
if (npos < 0 || npos >= maxnpos) {
continue;
}
go[table[nx0 - npos][ny0 + npos] - 'a'] |= (1 << npos);
}
}
int res = -INF;
for (int c = 0; c < maxc; ++c) {
int nmask = go[c];
if (nmask == 0) {
continue;
}
int value = solve(sum + 1, nmask) + (!c ? 1 : c == 1 ? -1 : 0);
if (res == -INF || ((sum & 1) ? (res < value) : (res > value))) {
res = value;
}
}
assert(res != -INF);
return dp[sum][mask] = res;
}
void solve() {
for (int sum = 0; sum <= 2 * n - 2; ++sum) {
for (int mask = 0; mask < (1 << (n - abs(n - 1 - sum))); ++mask) {
dp[sum][mask] = -INF;
}
}
int res = solve(0, 1) + (table[0][0] == 'a' ? 1
: table[0][0] == 'b' ? -1
: 0);
if (res > 0) {
printf("FIRST\n");
} else {
if (res < 0) {
printf("SECOND\n");
} else {
printf("DRAW\n");
}
}
}
int main() {
srand(rdtsc());
precalc();
while (1) {
if (!read()) {
break;
}
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Vec {
T x, y;
template <typename U>
Vec(Vec<U> v) : x((T)v.x), y((T)v.y) {}
Vec(T x, T y) : x(x), y(y) {}
Vec() : x(T()), y(T()) {}
inline T len_sqr() { return x * x + y * y; }
inline long double len() { return sqrt(x * x + y * y); }
inline Vec<long double> normal() {
if (len_sqr() == 0) return *this;
long double inv = 1 / len();
return Vec(x * inv, y * inv);
}
inline Vec<T> rot90() { return Vec(-y, x); }
inline Vec<long double> rot(long double angle) {
long double sn = sin(angle);
long double cs = cos(angle);
return Vec(x * cs - y * sn, x * sn + y * cs);
}
friend T operator^(const Vec& a, const Vec& b) {
return a.x * b.y - a.y * b.x;
}
friend T operator*(const Vec& a, const Vec& b) {
return a.x * b.x + a.y * b.y;
}
friend Vec operator+(const Vec& a, const Vec& b) {
return Vec(a.x + b.x, a.y + b.y);
;
}
friend Vec operator-(const Vec& a, const Vec& b) {
return Vec(a.x - b.x, a.y - b.y);
;
}
friend Vec operator*(const Vec& a, T k) { return Vec(a.x * k, a.y * k); }
friend Vec operator*(T k, const Vec& a) { return Vec(a.x * k, a.y * k); }
friend Vec operator/(const Vec& a, T k) { return Vec(a.x / k, a.y / k); }
friend istream& operator>>(istream& is, Vec& pt) {
is >> pt.x >> pt.y;
return is;
}
friend ostream& operator<<(ostream& os, Vec pt) {
os << pt.x << ' ' << pt.y;
return os;
}
const bool operator==(const Vec& v) { return v.x == x && v.y == y; }
const Vec& operator+=(const Vec& v) {
x += v.x;
y += v.y;
return *this;
}
const Vec& operator-=(const Vec& v) {
x -= v.x;
y -= v.y;
return *this;
}
const Vec& operator*=(const T k) {
x *= k;
y *= k;
return *this;
}
const Vec& operator/=(const T k) {
x /= k;
y /= k;
return *this;
}
Vec operator-() { return Vec(-x, -y); }
};
int main() {
long double R;
Vec<long double> cent, fif;
cin >> R;
cin >> cent.x >> cent.y;
cin >> fif.x >> fif.y;
Vec<long double> direction = cent - fif;
cout << fixed << setprecision(10);
if (fif == cent) {
Vec<long double> centd = cent;
long double Rd = R;
centd.y -= Rd / 2;
cout << centd << ' ' << Rd / 2;
} else if (direction.len_sqr() > R * R) {
cout << cent << ' ' << R;
} else {
direction = direction.normal() * (R + direction.len());
Vec<long double> res = fif + direction / 2;
cout << res << ' ' << direction.len() / 2 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long add = 1, t, h, n, i, j, mn = 100003LL * 100003LL, k, mx = 0, rz = 0,
tot, m, obj, st, cnt = 0, cnti = 0, s = 0, nri = 0, a[4], b = 0,
c = 0, a2, b2, a3, b3;
n = 500;
m = 1000000;
cout << n << '\n';
int r = m, x = m / 2;
cout << x << ' ' << r << '\n';
for (i = 1; i < n - 1; ++i) {
x += 2 * (n - i) + 1;
r = n - i;
cout << x << ' ' << r << '\n';
}
cout << m << ' ' << m << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 1e6 + 10;
const int INF = 0x3f3f3f3f;
int nxt[MAXN][26], fail[MAXN], R[MAXN], tot, lst;
char buf[MAXN];
int L;
int find(int x) {
while (buf[L] != buf[L - 1 - R[x]]) x = fail[x];
return x;
}
int diff[MAXN], slink[MAXN];
int at[MAXN];
void extend(int x) {
buf[++L] = x - 'a';
int now = find(lst), &nt = nxt[now][x];
if (!nt) {
int fx = nxt[find(fail[now])][x];
R[nt = ++tot] = R[now] + 2;
fail[nt] = fx;
diff[nt] = R[nt] - R[fx];
slink[nt] = diff[nt] == diff[fx] ? slink[fx] : nt;
}
at[L] = lst = nt;
}
int f[MAXN], frm[MAXN];
std::pair<int, int> g[MAXN];
void gmi(std::pair<int, int>& x, std::pair<int, int> y) {
if (x > y) x = y;
}
int main() {
static char S[MAXN], T[MAXN];
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> S >> T;
int _L = strlen(S);
*buf = 255, R[1] = -1, fail[0] = 1;
diff[0] = -12243;
tot = lst = 1;
for (int i = 0; i < _L; ++i) extend(S[i]), extend(T[i]);
for (int i = 1; i <= L; ++i) {
int p = at[i];
std::pair<int, int> cur(INF, -1);
while (p) {
std::pair<int, int> dp =
slink[p] == p ? std::pair<int, int>(INF, -1) : g[fail[p]];
int S = slink[p], at = i - R[S];
std::pair<int, int> tar(f[at] + 1, at);
if (at & 1) tar.first = INF;
gmi(g[p] = dp, tar);
if (i % 2 == 0) gmi(cur, g[p]);
p = fail[slink[p]];
}
if (i % 2 == 0) {
if (buf[i] == buf[i - 1]) gmi(cur, std::pair<int, int>(f[i - 2], i - 2));
std::tie(f[i], frm[i]) = cur;
}
}
if (f[L] > L) {
std::cout << -1 << std::endl;
exit(0);
}
std::cout << f[L] << '\n';
int now = L;
while (now) {
int l = now - frm[now];
if (l != 2) {
std::cout << (frm[now] + 2 >> 1) << ' ' << (now >> 1) << '\n';
}
assert(l % 2 == 0);
now = frm[now];
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.);
string rotate(string& a) {
char b[] = {a[0], a[4], a[1], a[2], a[3], a[5]};
return string(b);
}
string turn(string& a) {
char b[] = {a[2], a[1], a[5], a[3], a[0], a[4]};
return string(b);
}
int main() {
const int n = 6, m = 4;
string color;
cin >> color;
sort(color.begin(), color.end());
set<string> seen;
string a;
int ct = 0;
do {
a = color;
set<string> cur;
bool found = false;
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
if (seen.find(a) != seen.end()) {
found = true;
goto skip;
} else
cur.insert(a);
a = rotate(a);
}
a = turn(a);
}
a = rotate(a);
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
if (seen.find(a) != seen.end()) {
found = true;
goto skip;
} else
cur.insert(a);
a = rotate(a);
}
a = turn(a);
}
skip:
if (!found) {
ct++;
for (set<string>::iterator it = cur.begin(); it != cur.end(); it++)
seen.insert(*it);
}
} while (next_permutation(color.begin(), color.end()));
cout << ct << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, s;
cin >> n >> s;
--s;
vector<int> a(n), b(n);
for (auto &i : a) cin >> i;
for (auto &i : b) cin >> i;
if (a[0] == 0 || (a[s] == 0 && b[s] == 0))
cout << "NO\n";
else if (a[s] == 1)
cout << "YES\n";
else {
bool ok = false;
for (int i = s + 1; i < n; i++) ok |= (a[i] == 1 & b[i] == 1);
cout << (ok ? "YES\n" : "NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int mod;
if (s.size() == 1) {
mod = (s[0] - '0') % 4;
} else {
mod = ((s[s.size() - 1] - '0') + 10 * (s[s.size() - 2] - '0')) % 4;
}
vector<int> a = {1, 1, 1, 1};
vector<int> b = {1, 2, 4, 3};
vector<int> c = {1, 3, 4, 2};
vector<int> d = {1, 4, 1, 4};
cout << (a[mod] + b[mod] + c[mod] + d[mod]) % 5 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int arr[5][5];
int i, j, n = 5, r, c;
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
scanf("%d", &arr[i][j]);
if (arr[i][j] == 1) {
r = abs(i - 2);
c = abs(j - 2);
}
}
}
printf("%d", r + c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct node {
int l, r;
};
struct segtree {
node seg[maxn << 2];
int lsum[maxn << 2], rsum[maxn << 2], sum[maxn << 2];
void pushup(int o) {
int len = seg[o].r - seg[o].l + 1;
lsum[o] = lsum[o << 1];
rsum[o] = rsum[o << 1 | 1];
if (lsum[o] == len - (len >> 1)) lsum[o] += lsum[o << 1 | 1];
if (rsum[o] == len >> 1) rsum[o] += rsum[o << 1];
sum[o] =
max(lsum[o << 1 | 1] + rsum[o << 1], max(sum[o << 1], sum[o << 1 | 1]));
}
void build(int o, int l, int r) {
seg[o].l = l, seg[o].r = r;
lsum[o] = rsum[o] = sum[o] = r - l + 1;
if (l == r) return;
int m = (l + r) >> 1;
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
}
void update(int o, int v) {
if (seg[o].l == seg[o].r) {
if (v < 0)
sum[o] = lsum[o] = rsum[o] = 1;
else
sum[o] = lsum[o] = rsum[o] = 0;
return;
}
int m = (seg[o].l + seg[o].r) >> 1;
if (abs(v) <= m)
update(o << 1, v);
else
update(o << 1 | 1, v);
pushup(o);
}
int query(int o, int v) {
if (seg[o].l == 1 && lsum[o] >= v) return 1;
if (seg[o].l == seg[o].r) return seg[o].l;
int m = (seg[o].l + seg[o].r) >> 1;
if (sum[o << 1] + 1 >= 2 * v)
return query(o << 1, v);
else if (rsum[o << 1] + lsum[o << 1 | 1] + 1 >= 2 * v)
return m + v - rsum[o << 1];
else
return query(o << 1 | 1, v);
}
} tree;
int ps[maxn * 5];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
tree.build(1, 1, n);
for (int i = 1; i <= m; i++) {
int op, x, pos = -1;
scanf("%d%d", &op, &x);
if (op == 1) {
int t = (tree.sum[1] + 1) / 2;
t = max(t, tree.lsum[1]);
t = max(t, tree.rsum[1]);
ps[x] = tree.query(1, t);
tree.update(1, ps[x]);
printf("%d\n", ps[x]);
} else {
tree.update(1, -ps[x]);
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, m, n, x;
while (scanf("%lld%lld", &m, &n) == 2) {
if ((n * 2) >= m)
printf("%lld\n", m - n);
else if (n == 0)
printf("1\n");
else
printf("%lld\n", n);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long Gcd(long long v, long long b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return Gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return Gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long pr[10];
long long inv[10];
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
void solve() {
long long n, p;
cin >> n >> p;
vector<long long> ve(n + 2);
for (long long i = 1; i <= n; i++) cin >> ve[i];
ve[0] = -1000000007 * 10000ll;
ve[n + 1] = -ve[0];
sort(ve.begin(), ve.end());
long long a = ve[0], b = ve[n + 1];
for (long long i = 0; i <= n + 10; i++) ve.push_back(ve.back());
for (long long i = 0; i < n; i++) {
a = max(a, ve[i + 1] - i);
b = min(b, ve[i + p] - i);
}
cout << max(0ll, b - a) << endl;
for (long long i = a; i < b; i++) cout << i << " ";
cout << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
n = 1;
for (long long i = 0; i < n; i++) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000000;
int n, m, ans, a[maxn + 5], b[maxn + 5], pos[maxn + 5];
int c[maxn + 5], nxt[maxn + 5];
int ch[(maxn << 2) + 5][2], siz[(maxn << 2) + 5], rt[maxn + 5], cnt;
int lb(int x) { return x & (-x); }
void add(int x, int d) {
for (int i = x; i <= n; i += lb(i)) c[i] += d;
}
int sum(int x) {
int ret = 0;
for (int i = x; i; i -= lb(i)) ret += c[i];
return ret;
}
void insert(int pr, int nw, int l, int r, int v) {
siz[nw] = siz[pr] + 1;
if (l == r) return;
int mid = (l + r) >> 1;
if (v <= mid) {
ch[nw][1] = ch[pr][1];
ch[nw][0] = ++cnt;
insert(ch[pr][0], ch[nw][0], l, mid, v);
} else {
ch[nw][0] = ch[pr][0];
ch[nw][1] = ++cnt;
insert(ch[pr][1], ch[nw][1], mid + 1, r, v);
}
}
int query(int pr, int nw, int l, int r, int v) {
if (l == r) return siz[nw] - siz[pr];
int mid = (l + r) >> 1;
if (v <= mid)
return query(ch[pr][0], ch[nw][0], l, mid, v);
else
return siz[ch[nw][0]] - siz[ch[pr][0]] +
query(ch[pr][1], ch[nw][1], mid + 1, r, v);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
a[t] = i;
}
for (int i = 1; i <= m; i++) {
int t;
scanf("%d", &t);
b[t] = i;
}
int p = 0;
rt[0] = ++cnt;
for (int i = 1; i <= n; i++) {
insert(rt[i - 1], rt[i] = ++cnt, 1, n, a[i]);
}
pos[1] = 1;
add(a[1], 1);
for (int i = 2; i <= n; i++) {
add(a[i], 1);
pos[i] = sum(a[i]);
while (p && pos[p + 1] != query(rt[i - p - 1], rt[i], 1, n, a[i]))
p = nxt[p];
if (pos[p + 1] == query(rt[i - p - 1], rt[i], 1, n, a[i])) p++;
nxt[i] = p;
}
cnt = 0;
memset(ch, 0, sizeof(ch));
memset(siz, 0, sizeof(siz));
memset(rt, 0, sizeof(rt));
p = 0;
rt[0] = ++cnt;
for (int i = 1; i <= m; i++) {
insert(rt[i - 1], rt[i] = ++cnt, 1, m, b[i]);
}
for (int i = 1; i <= m; i++) {
while (p && pos[p + 1] != query(rt[i - p - 1], rt[i], 1, m, b[i]))
p = nxt[p];
if (pos[p + 1] == query(rt[i - p - 1], rt[i], 1, m, b[i])) p = p + 1;
if (p == n) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
template <class T>
inline void rd(T &x) {
char c = getchar(), f = 0;
x = 0;
while (!isdigit(c)) f = (c == '-'), c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x = f ? -x : x;
}
int main() {
int t;
rd(t);
while (t--) {
long long n, r;
rd(n), rd(r);
printf("%lld\n", n > r ? (r + 1) * r / 2 : (n - 1) * n / 2ll + 1ll);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[102], b[102];
long long cn[103];
int main() {
long long n, m;
cin >> n >> m;
long long k;
memset(a, -1, sizeof(a));
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= n; j++) {
cin >> k;
if (k > a[i]) {
a[i] = k;
b[i] = j;
}
}
for (long long i = 1; i <= m; i++) {
cn[b[i]]++;
}
long long mx = 0, win = 1;
for (long long i = 1; i <= n; i++) {
if (cn[i] > mx) {
mx = cn[i];
win = i;
}
}
cout << win << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m, k, s;
int a;
int b[100005];
inline int f(int x) { return x > 0 ? x : -x; }
int Map[2002][2002];
int l[2002][11], r[2002][11];
int mx[11], mi[11];
int main() {
ios::sync_with_stdio(false);
int i, j, u, v;
cin >> n >> m >> k >> s;
memset(l, inf, sizeof(l));
memset(r, -1, sizeof(r));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a;
a--;
l[i][a] = min(l[i][a], j);
r[i][a] = max(r[i][a], j);
}
}
memset(mx, -1, sizeof(mx));
memset(mi, inf, sizeof(mi));
for (i = 0; i < n; i++) {
for (j = 0; j < k; j++) {
mx[j] = max(mx[j], -i + r[i][j]);
mi[j] = min(mi[j], i + l[i][j]);
}
for (j = 0; j < k; j++)
for (u = 0; u < k; u++) {
Map[j][u] = Map[u][j] = max(Map[j][u], i - l[i][j] + mx[u]);
Map[j][u] = Map[u][j] = max(Map[j][u], i + r[i][j] - mi[u]);
}
}
for (i = 0; i < s; i++) cin >> b[i], b[i]--;
int ans = 0;
for (i = 1; i < s; i++) ans = max(ans, Map[b[i - 1]][b[i]]);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
int n;
void bfs(int s) {
vector<bool> vis(n, false);
vis[s] = true;
queue<int> q;
q.push(s);
while (!q.empty()) {
int top = q.front();
q.pop();
for (auto i : g[top])
if (vis[i] == false) {
vis[i] = true;
q.push(i);
cout << top + 1 << " " << i + 1 << endl;
}
}
}
void solve() {
int m;
cin >> n >> m;
g = vector<vector<int> >(n);
vector<int> deg(n, 0);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
++deg[u], ++deg[v];
g[u].push_back(v);
g[v].push_back(u);
}
int s = max_element(deg.begin(), deg.end()) - deg.begin();
bfs(s);
}
int main() {
int t;
t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 10005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int d1[N], d2[N], ans[N], n, x, y, u, v, w, num;
bool vis1[N], vis2[N];
vector<int> V1[N], V2[N];
bitset<N> a[N];
struct Btype {
int x, y;
} E[N];
struct Stype {
int d, id;
long long r;
} s1[N], s2[N];
set<Stype> S;
inline long long myrand() {
return ((long long)(rand() & 65535) << 32) + ((long long)rand() << 16) +
rand();
}
inline bool operator<(const Stype p, const Stype q) {
return p.d < q.d || p.d == q.d && p.r < q.r ||
p.d == q.d && p.r == q.r && p.id < q.id;
}
inline bool operator>(const Stype p, const Stype q) {
return p.d > q.d || p.d == q.d && p.r > q.r ||
p.d == q.d && p.r == q.r && p.id > q.id;
}
inline void print() {
printf("Yes\n");
for (int i = (1); i <= (n); ++i) printf("%d ", ans[i] + n);
printf("\n");
}
inline void D(int x) {
vis1[x] = 1, num++;
S.erase(s1[x]);
for (auto y : V1[x])
if (!vis1[y]) S.erase(s1[y]), s1[y].d++, S.insert(s1[y]);
}
inline bool _work() {
for (int i = (1); i <= (n); ++i) ans[i] = i;
random_shuffle(ans + 1, ans + n + 1);
for (int i = (1); i <= (n - 1); ++i)
if (a[ans[E[i].x]][ans[E[i].y]]) return 0;
print();
return 1;
}
inline bool work() {
memset(vis1, 0, sizeof(vis1)), memset(vis2, 0, sizeof(vis2)),
memset(ans, 0, sizeof(ans)), num = 0;
S.clear();
for (int i = (1); i <= (n); ++i)
S.insert(s1[i] = Stype{d1[i], i, myrand()}),
s2[i] = Stype{d2[i], i, myrand()};
priority_queue<Stype, vector<Stype>, greater<Stype> > Q;
Stype s = s2[1];
for (int i = (2); i <= (n); ++i) s = ((s) < (s2[i]) ? (s) : (s2[i]));
Q.push(s), ans[s.id] = S.begin()->id, vis2[s.id] = 1, D(S.begin()->id);
while (!Q.empty()) {
Stype s = Q.top();
Q.pop();
u = ans[x = s.id];
for (auto y : V2[x])
if (!vis2[y]) {
s2[y].d--;
auto it = S.lower_bound(Stype{s2[y].d + num, -1, -1});
for (; it != S.end(); it++)
if (!a[u][v = it->id]) {
ans[y] = v;
break;
}
if (!ans[y]) return 0;
D(v), vis2[y] = 1, Q.push(s2[y]);
}
}
print();
return 1;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n - 1); ++i) {
scanf("%d%d", &x, &y), d2[x]++, d2[y]++;
V2[x].push_back(y), V2[y].push_back(x);
E[i] = Btype{x, y};
}
for (int i = (1); i <= (n - 1); ++i) {
scanf("%d%d", &x, &y), x -= n, y -= n, d1[x]--, d1[y]--;
V1[x].push_back(y), V1[y].push_back(x);
a[x][y] = a[y][x] = 1;
}
for (int i = (1); i <= (n); ++i) d1[i] += n - 1;
for (int i = (1); i <= (n); ++i)
if (!d1[i] || d2[i] == n - 1) return 0 * printf("No\n");
for (; !_work() && !work();)
;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int Mod = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double e = 2.718281828459045235360287471352662;
const double PI = acos(-1);
const double ERR = 1e-10;
char str[maxn];
int n, a, b;
int main() {
ios::sync_with_stdio(false);
int ans = 0;
cin >> n >> a >> b;
cin >> str;
for (int i = 0; i < n; i++) {
if (str[i] == '.') {
if (i == 0 || str[i - 1] == '*' || str[i - 1] == '.') {
if (a > b) {
a--;
ans++;
str[i] = 'a';
} else {
b--;
ans++;
str[i] = 'b';
}
} else {
if (str[i - 1] == 'a') {
if (b == 0)
continue;
else {
b--;
str[i] = 'b';
ans++;
}
} else {
if (a == 0) {
continue;
} else {
a--;
ans++;
str[i] = 'a';
}
}
}
}
if (a == 0 && b == 0) break;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, it, r, x[55], y[55], a[9], was[7][7];
void rec(int l) {
if (l > n) {
++it;
int cnt = 0;
for (int i = 0; i < m; i++) {
int le = min(a[x[i]], a[y[i]]);
int ri = max(a[x[i]], a[y[i]]);
if (was[le][ri] != it) {
was[le][ri] = it;
cnt++;
}
}
r = max(r, cnt);
return;
}
for (int i = 1; i <= 6; i++) {
a[l] = i;
rec(l + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) scanf("%d%d", &x[i], &y[i]);
rec(1);
printf("%d\n", r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T> p) {
out << "(" << p.first << "," << p.second << ")";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
for (auto a : v) out << a << " ";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const set<T>& S) {
for (auto a : S) cout << a << " ";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const multiset<T>& S) {
for (auto a : S) cout << a << " ";
return out;
}
template <typename S, typename T>
ostream& operator<<(ostream& out, const map<S, T>& M) {
for (auto m : M) cout << "(" << m.first << "->" << m.second << ") ";
return out;
}
template <typename S, typename T>
pair<S, T> operator+(pair<S, T> a, pair<S, T> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
template <typename S, typename T>
pair<S, T> operator-(pair<S, T> a, pair<S, T> b) {
return make_pair(a.first - b.first, a.second - b.second);
}
template <typename T>
struct GridGraph {
int n;
int m;
vector<vector<T>> W;
vector<vector<int>> vis;
vector<vector<int>> dist;
int group_size;
vector<pair<int, int>> topo_sort;
vector<vector<int>> dp;
vector<pair<int, int>> movs;
vector<pair<int, int>> movs4 = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
vector<pair<int, int>> movs8 = {{0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
{0, -1}, {1, -1}, {1, 0}, {1, 1}};
vector<pair<int, int>> movs9 = {{-1, 2}, {-2, 1}, {-2, -1}, {-1, -2},
{1, -2}, {2, -1}, {2, 1}, {1, 2}};
void init(int n, int m) {
this->n = n;
this->m = m;
movs = movs4;
}
void init(vector<vector<T>>& A) {
int n = A.size();
int m = A[0].size();
init(n, m);
W = A;
}
void init(vector<string>& A) {
int n = A.size();
int m = A[0].size();
init(n, m);
W.resize(n);
for (int i = 0; i < n; i++) {
W[i].resize(m);
for (int j = 0; j < m; j++) {
W[i][j] = A[i][j];
}
}
}
bool is_edge_allowed(pair<int, int> s, pair<int, int> t) { return true; }
bool is_node_allowed(pair<int, int> s) {
T val = W[s.first][s.second];
return val == 'B';
}
void dfs(pair<int, int> s) {
int x = s.first;
int y = s.second;
vis[x][y] = 1;
for (auto mov : movs) {
auto t = s + mov;
int nx = t.first;
int ny = t.second;
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (is_node_allowed(t)) {
if (is_edge_allowed(s, t)) {
if (vis[nx][ny] == 0) {
dfs(t);
}
}
}
}
}
vis[x][y] = 2;
topo_sort.push_back(s);
}
void source_dfs(vector<pair<int, int>>& A) {
vis.resize(n);
for (int i = 0; i < n; i++) vis[i].assign(m, 0);
topo_sort.clear();
group_size = 0;
for (auto s : A) {
int x = s.first;
int y = s.second;
if (is_node_allowed(s)) {
if (vis[x][y] == 0) {
dfs(s);
group_size++;
}
}
}
reverse(topo_sort.begin(), topo_sort.end());
}
void source_dfs(pair<int, int> s) {
vector<pair<int, int>> A;
A.push_back(s);
source_dfs(A);
}
void source_dfs() {
vector<pair<int, int>> A;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
A.emplace_back(i, j);
}
}
source_dfs(A);
}
void source_dynamic_porgramming() {
dp.resize(n);
for (int i = 0; i < n; i++) dp[i].assign(m, 1);
for (int i = topo_sort.size() - 1; i >= 0; i--) {
auto s = topo_sort[i];
int x = s.first;
int y = s.second;
for (auto mov : movs) {
auto t = s + mov;
int nx = t.first;
int ny = t.second;
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (is_node_allowed(t)) {
if (is_edge_allowed(s, t)) {
dp[x][y] = max(dp[x][y], dp[nx][ny] + 1);
}
}
}
}
}
}
void source_bfs(vector<pair<int, int>>& src, pair<int, int> dst = {-1, -1}) {
vis.resize(n);
for (int i = 0; i < n; i++) vis[i].assign(m, 0);
dist.resize(n);
for (int i = 0; i < n; i++) dist[i].assign(m, 1e9);
queue<pair<int, int>> q;
for (auto s : src) {
int x = s.first;
int y = s.second;
vis[x][y] = 1;
dist[x][y] = 0;
q.push(s);
}
while (!q.empty()) {
auto s = q.front();
q.pop();
int x = s.first;
int y = s.second;
vis[x][y] = 2;
if (s == dst) break;
for (auto mov : movs) {
auto t = s + mov;
int nx = t.first;
int ny = t.second;
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (is_node_allowed(t)) {
if (is_edge_allowed(s, t)) {
if (vis[nx][ny] == 0) {
vis[nx][ny] = 1;
dist[nx][ny] = dist[x][y] + 1;
q.push({nx, ny});
}
}
}
}
}
}
}
void source_bfs(pair<int, int> src, pair<int, int> dst = {1, -1}) {
vector<pair<int, int>> A;
A.push_back(src);
source_bfs(A, dst);
}
void dump_grid() {
for (int i = 0; i < n; i++) cout << "W[" << i << "]: " << W[i] << endl;
}
void dump() {
for (int i = 0; i < vis.size(); i++)
cout << "vis[" << i << "]; " << vis[i] << endl;
for (int i = 0; i < dist.size(); i++)
cout << "dist[" << i << "]: " << dist[i] << endl;
for (int i = 0; i < dp.size(); i++)
cout << "dp[" << i << "]: " << dp[i] << endl;
}
};
GridGraph<char> graph;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
vector<string> A;
cin >> n >> m;
A.resize(n);
for (int i = 0; i < n; i++) cin >> A[i];
graph.init(A);
graph.source_dfs();
cout << graph.group_size << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
void faster() {
if (0) {
freopen(
"taskA"
".in",
"r", stdin);
freopen(
"taskA"
".out",
"w", stdout);
}
if (1) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
}
const int MAXN = (int)2e5 + 123;
const int MOD = (int)1e9 + 7;
const long double EPS = 3E-16;
namespace MATH_CAL {
const int mod = (int)1e9 + 7;
inline long long add(long long a, long long b) {
return a + b >= mod ? a + b - mod : a + b;
}
inline int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
inline long long mul(long long a, long long b) {
return (long long)a * b % mod;
}
inline void Add(int &a, int b) { (a += b) >= mod ? a -= mod : 0; }
inline void Sub(int &a, int b) { (a -= b) < 0 ? a += mod : 0; }
inline long long qpow(long long x, long long n) {
long long r = 1;
for (; n; n /= 2, x = mul(x, x))
if (n & 1) r = mul(r, x);
return r;
}
inline long long mod_inv(long long x) { return qpow(x, mod - 2); }
} // namespace MATH_CAL
using namespace MATH_CAL;
vector<long long> g[MAXN];
bool used[MAXN];
long long da[MAXN];
long long db[MAXN];
void dfs1(int V, int pr = -1) {
if (used[V]) return;
used[V] = 1;
if (pr != -1) {
da[V] = da[pr] + 1;
}
for (auto to : g[V]) {
if (!used[to]) {
dfs1(to, V);
}
}
}
void dfs2(int V, int pr = -1) {
if (used[V]) return;
used[V] = 1;
if (pr != -1) {
db[V] = db[pr] + 1;
}
for (auto to : g[V]) {
if (!used[to]) {
dfs2(to, V);
}
}
}
void solve() {
int n, x;
cin >> n >> x;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1);
for (int i = 1; i <= n; i++) {
used[i] = false;
}
dfs2(x);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (db[i] < da[i]) {
ans = max(ans, da[i] * 2ll);
}
}
cout << ans << endl;
}
int main() {
faster();
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
int sum1 = 0, sum2 = 0;
int i, temp;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
scanf("%d", &temp);
if (temp == 1) sum1++;
if (temp == 2) sum2++;
}
if (sum1 <= m && sum2 <= k)
printf("0\n");
else if (sum1 > m && sum2 > k)
printf("%d\n", sum1 - m + sum2 - k);
else if (sum1 <= m && sum2 > k) {
if (sum2 - k - m + sum1 >= 0)
printf("%d\n", sum2 - k - m + sum1);
else
printf("0\n");
} else if (sum1 > m && sum2 <= k)
printf("%d\n", sum1 - m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = (1 << (20));
const int mxl = 20;
int n, stp, mv, suffix[mxn], tmp[mxn];
int sum[mxn], cnt[mxn], rnk[mxl][mxn];
char str[mxn];
int ara[mxn];
inline bool eql(const int &u, const int &v) {
if (!stp) return (ara[u] == ara[v]);
if (rnk[stp - 1][u] != rnk[stp - 1][v]) return false;
int a = u + mv < n ? rnk[stp - 1][u + mv] : -1;
int b = v + mv < n ? rnk[stp - 1][v + mv] : -1;
return a == b;
}
void update() {
for (int i = 0; i < n; i++) sum[i] = 0;
for (int i = 0, r = 0; i < n; i++) {
suffix[i] = tmp[i];
if (i && !eql(suffix[i], suffix[i - 1])) {
rnk[stp][suffix[i]] = ++r;
sum[r + 1] = sum[r];
} else
rnk[stp][suffix[i]] = r;
sum[r + 1]++;
}
}
void Sort() {
for (int i = 0; i < n; i++) cnt[i] = 0;
memset(tmp, -1, sizeof tmp);
for (int i = 0; i < mv; i++) {
int idx = rnk[stp - 1][n - i - 1];
int x = sum[idx];
tmp[x + cnt[idx]] = n - i - 1;
cnt[idx]++;
}
for (int i = 0; i < n; i++) {
int idx = suffix[i] - mv;
if (idx < 0) continue;
idx = rnk[stp - 1][idx];
int x = sum[idx];
tmp[x + cnt[idx]] = suffix[i] - mv;
cnt[idx]++;
}
update();
return;
}
inline bool cmp(const int &a, const int &b) {
if (ara[a] != ara[b]) return ara[a] < ara[b];
return false;
}
void SortSuffix() {
for (int i = 0; i < n; i++) tmp[i] = i;
sort(tmp, tmp + n, cmp);
stp = 0;
update();
++stp;
for (mv = 1; mv < n; mv <<= 1) Sort(), stp++;
stp--;
for (int i = 0; i <= stp; i++) rnk[i][n] = -1;
}
inline int lcp(int u, int v) {
if (u == v) return n - u;
int ret = 0;
for (int i = stp; i >= 0; i--)
if (rnk[i][u] == rnk[i][v]) {
ret += 1 << i;
u += 1 << i;
v += 1 << i;
}
return ret;
}
int ind[mxn];
long long res[mxn];
int freq[mxn];
int seg[4 * mxn];
void update(int N, int s, int e, int l, int r, int val) {
if (s >= l && e <= r) {
seg[N] = max(seg[N], val);
return;
}
if (s > r || e < l) return;
int mid = (s + e) >> 1;
update(N * 2, s, mid, l, r, val);
update(N * 2 + 1, mid + 1, e, l, r, val);
return;
}
int query(int N, int s, int e, int indx, int c) {
if (s == indx && e == indx) return max(seg[N], c);
if (s > indx || e < indx) return 0;
int mid = (s + e) >> 1;
return max(query(N * 2, s, mid, indx, max(c, seg[N])),
query(N * 2 + 1, mid + 1, e, indx, max(c, seg[N])));
}
int main() {
int m, k, cnt = 30;
scanf("%d %d", &m, &k);
n = 0;
for (int i = 0; i < m; i++) {
if (i) ara[n] = ++cnt, ind[n++] = -1;
scanf("%s", str);
if (k == 1) res[i] = (1LL * (strlen(str)) * (strlen(str) + 1)) >> 1;
for (int j = 0; str[j]; j++) ara[n] = (str[j] - 'a' + 1), ind[n++] = i;
}
if (k == 1) {
for (int i = 0; i < m; i++) printf("%lld ", res[i]);
return 0;
}
SortSuffix();
int l = 0, f = 0, lst = -1;
for (int i = 0; i < n && ind[suffix[i]] != -1; i++) {
freq[ind[suffix[i]]]++;
if (freq[ind[suffix[i]]] == 1) f++;
if (f >= k) {
while (f >= k) {
update(1, 1, n + 1, l + 1, i + 1, lcp(suffix[l], suffix[i]));
freq[ind[suffix[l]]]--;
if (!freq[ind[suffix[l]]]) f--;
l++;
}
f++, l--, freq[ind[suffix[l]]]++;
}
}
for (int i = 0; i < n; i++)
if (ind[suffix[i]] != -1)
res[ind[suffix[i]]] += query(1, 1, n + 1, i + 1, 0);
for (int i = 0; i < m; i++) printf("%lld ", res[i]);
puts("");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int i, ans, k, n, m, a, x;
int main() {
cin >> n >> m >> x;
for (i = 0; i < n; i++) {
cin >> a;
if (a <= m)
k++;
else
k = 0;
if (k >= x) ans++;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
int ia(int x) {
if (x < 0) return -x;
return x;
}
int x1, x2, a, b, mid, mxd;
int main() {
int d;
scanf("%d %d %d %d", &x1, &x2, &a, &b);
if ((x1 + a <= x2) && (x2 <= x1 + b)) {
printf("FIRST\n");
printf("%d\n", x2);
return 0;
}
if ((a <= 0) && (x1 <= x2)) {
printf("DRAW\n");
return 0;
}
if ((b >= 0) && (x1 >= x2)) {
printf("DRAW\n");
return 0;
}
if ((x1 <= x2) && (x1 + a > x2) && (x1 + b > x2)) {
printf("DRAW\n");
return 0;
}
if ((x1 >= x2) && (x1 + a < x2) && (x1 + b < x2)) {
printf("DRAW\n");
return 0;
}
if (x1 <= x2) {
mid = a;
mxd = b;
d = x2 - x1;
} else if (x1 >= x2) {
mid = -b;
mxd = -a;
d = x1 - x2;
}
d = d % (mxd + mid);
if (d == 0) {
printf("SECOND\n");
} else if (d <= mid - 1) {
printf("DRAW\n");
} else if (d <= mxd) {
printf("FIRST\n");
if (x1 <= x2)
printf("%d\n", x1 + d);
else
printf("%d\n", x1 - d);
} else if (d <= mid + mxd - 1) {
printf("DRAW\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
double sum[N << 2], lazy[N << 2], lazy2[N << 2];
int n, m;
void pushdown(int l, int r, int rt) {
lazy[rt << 1] *= lazy[rt];
lazy2[rt << 1] *= lazy[rt];
lazy2[rt << 1] += lazy2[rt];
lazy[rt << 1 | 1] *= lazy[rt];
lazy2[rt << 1 | 1] *= lazy[rt];
lazy2[rt << 1 | 1] += lazy2[rt];
sum[rt << 1] *= lazy[rt];
sum[rt << 1] += lazy2[rt] * l;
sum[rt << 1 | 1] *= lazy[rt];
sum[rt << 1 | 1] += lazy2[rt] * r;
lazy[rt] = 1;
lazy2[rt] = 0;
}
void pushup(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void build(int l, int r, int rt) {
lazy[rt] = 1.0;
lazy2[rt] = 0;
if (l == r) {
scanf("%lf", &sum[rt]);
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
double query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) {
return sum[rt];
}
double ret = 0;
int mid = r + l >> 1;
pushdown(mid - l + 1, r - mid, rt);
if (mid >= L) ret += query(L, R, l, mid, rt << 1);
if (mid < R) ret += query(L, R, mid + 1, r, rt << 1 | 1);
pushup(rt);
return ret;
}
void update(int L, int R, double x, double y, int l, int r, int rt) {
if (L <= l && R >= r) {
lazy[rt] *= x;
lazy2[rt] *= x;
lazy2[rt] += y;
sum[rt] = sum[rt] * x + y * (r - l + 1);
return;
}
int mid = r + l >> 1;
pushdown(l - mid + 1, r - mid, rt);
if (mid >= L) update(L, R, x, y, l, mid, rt << 1);
if (mid < R) update(L, R, x, y, mid + 1, r, rt << 1 | 1);
pushup(rt);
}
int main() {
cin >> n >> m;
build(1, n, 1);
for (int i = 1; i <= m; i++) {
int op, l, r, l2, r2;
scanf("%d", &op);
if (op == 1) {
scanf("%d %d %d %d", &l, &r, &l2, &r2);
double sum1 = query(l, r, 1, n, 1);
double sum2 = query(l2, r2, 1, n, 1);
int x = (r - l + 1), y = (r2 - l2 + 1);
update(l, r, (x - 1) * 1.0 / x, sum2 / x / y, 1, n, 1);
update(l2, r2, (y - 1) * 1.0 / y, sum1 / x / y, 1, n, 1);
} else {
scanf("%d %d", &l, &r);
printf("%lf\n", query(l, r, 1, n, 1));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "-1" << '\n';
} else {
for (int i = 0; i < n; i++) {
cout << i << " ";
}
cout << '\n';
for (int i = 1; i < n; i++) {
cout << i << " ";
}
cout << 0 << '\n';
for (int i = 1, j = 0; j < n; i += 2, j++) {
cout << i % n << " ";
}
}
}
int main() {
int t = 1;
for (int tc = 1; tc <= t; tc++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N;
string S;
int main() {
cin >> N >> S;
int ans = 0;
for (int i = N; i < int(S.size()); i += N) {
int t = 0;
for (int j = i - 3; j < i; j++) t += (S[j] == 'a' ? 1 : -1);
if (abs(t) == 3) ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#include <utility>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <math.h>
#include <string>
#define ll long long
#define ull unsigned long long
#define make(type,x) type x; cin>>x
#define make2(type,x,y) type x,y; cin>>x>>y
#define fr(x,y) for(long long x=0;x<y;x++)
#define makevec(x,y,n) vector <x> y(n); for(ll i=0;i<n;i++) cin>>y[i]
#define M (ll)1000000007
#define MM 1e8
#define INF (ll) 1e18
# define IOS ios_base::sync_with_stdio(false); cin.tie(NULL)
using namespace std;
template <typename T>
T modpow(T base, T exp, T modulus) {
base %= modulus;
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
bool sortbysec(const pair <ll,ll> &a,const pair <ll,ll> &b){
return a.second<b.second;
}
struct c_h {
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
x ^= FIXED_RANDOM;
return x ^ (x >> 16);
}
};
template <typename T>
T calcpow(T x, T y)
{
T temp;
if(y == 0)
return 1;
temp = calcpow(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
{
if(y > 0)
return x * temp * temp;
else
return (temp * temp) / x;
}
}
ll gcd(ll a, ll b){
if(b==0) return a;
return gcd(b,a%b);
}
ll egcd(ll a, ll b, ll &x,ll &y){
if(b==0){
x=1;
y=0;
return a;
}
ll x1;
ll y1;
ll g=egcd(b,a%b,x1,y1);
x=y1;
y=x1-y1*(a/b);
return g;
}
bool isprime(ll a){
bool flag=1;
for(ll i=2;i*i<=a;i++){
if(a%i==0) {flag=0; break;}
}
return flag;
}
ll dx[4]={1,-1,0,0};
ll dy[4]={0,0,1,-1};
ll N=2e5+5;
int main()
{
make(ll,t);
while(t--){
make(ll,n);
makevec(ll,a,n);
sort(a.begin(),a.end());
vector <ll> pre(n+2),suf(n+2);
for(ll i=0;i<n;i++) pre[i+1]=pre[i]+a[i];
ll ans=0;
for(ll i=1;i<n;i++){
ans+=(a[i]*i)-pre[i];
//cout<<pre[i]<<" "<<suf[i+2]<<endl;
}
cout<<a[n-1]-ans<<endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int H = 600000;
char s0[H], *s1 = s0, *s2 = s1;
inline int read() {
register int x = 0, c, f = 0;
while (isspace(
c = (s1 == s2 && (s2 = (s1 = s0) + fread(s0, 1, H, stdin), s1 == s2)
? 32
: *s1++)))
;
if (c == '-')
f = 1;
else
x = x * 10 + c - 48;
while (isdigit(
c = (s1 == s2 && (s2 = (s1 = s0) + fread(s0, 1, H, stdin), s1 == s2)
? 32
: *s1++)))
x = x * 10 + c - 48;
return (f ? -x : x);
}
using namespace std;
int n;
struct node {
int x, y, t, i;
} L[20010];
node O;
int ansi[20010];
int ci[20010];
int compc(int a, int b) {
return ((L[a].x - O.x) * (L[b].y - O.y) - (L[b].x - O.x) * (L[a].y - O.y)) <
0;
}
int comp(node a, node b) {
return ((a.x - O.x) * (b.y - O.y) - (b.x - O.x) * (a.y - O.y)) < 0;
}
void solve(int l, int r) {
if (l > r) return;
for (int i = l + 1; i <= r; ++i)
if (L[ci[i]].y < L[ci[l]].y) swap(ci[i], ci[l]);
O = L[ci[l]];
sort(ci + l + 1, ci + r + 1, compc);
int np = l + 1;
for (int i = l + 1, k = 0; i < r; ++i) {
k += L[ci[i]].t;
if (k == 0) {
solve(np, i);
np = i + 1;
}
}
if (L[ci[l]].t > 0)
ansi[L[ci[l]].i] = L[ci[np]].i;
else
ansi[L[ci[np]].i] = L[ci[l]].i;
solve(np + 1, r);
}
int compi(node a, node b) {
if (a.t != b.t)
return a.t > b.t;
else
return a.i < b.i;
}
int checker() {
sort(L + 1, L + n * 2 + 1, compi);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) {
O = L[i];
int a =
comp(L[ansi[i] + n], L[j]) ^ comp(L[ansi[i] + n], L[ansi[j] + n]);
O = L[j];
int b =
comp(L[ansi[j] + n], L[i]) ^ comp(L[ansi[j] + n], L[ansi[i] + n]);
if (a && b) return 1;
}
return 0;
}
int main() {
n = read();
for (int i = 1; i <= 2 * n; ++i) ci[i] = i;
for (int i = 1; i <= n; ++i) {
L[i].x = read();
L[i].y = read();
L[i].t = 1;
L[i].i = i;
}
for (int i = 1; i <= n; ++i) {
L[i + n].x = read();
L[i + n].y = read();
L[i + n].t = -1;
L[i + n].i = i;
}
solve(1, n * 2);
for (int i = 1; i <= n; ++i) printf("%d\n", ansi[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, in1[100005];
int tot = 0, Next[100005 * 2], to[100005 * 2], head[100005 * 2], id[100005 * 2];
queue<int> q;
inline void add(int x, int y, int z) {
Next[++tot] = head[x];
id[tot] = z;
to[tot] = y;
head[x] = tot;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
int i, x, y, re = 0, bo = 0;
memset(head, 0, sizeof head);
memset(in1, 0, sizeof in1);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y, i);
in1[y]++;
}
for (i = 1; i <= n; i++)
if (!in1[i]) q.push(i);
if (q.size() > 1) {
printf("-1\n");
continue;
}
while (!q.empty()) {
if (q.size() > 1) {
bo = 1;
break;
}
int x = q.front();
q.pop();
for (i = head[x]; i; i = Next[i]) {
int V = to[i];
in1[V]--;
if (!in1[V]) {
re = max(re, id[i]);
q.push(V);
}
}
}
if (bo)
printf("-1\n");
else
printf("%d\n", re);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int t, n, p, a, b, i, j, curr;
cin >> n;
long long int arr[n], front[n], rear[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
curr = mod;
for (long long int i = 0; i < n; i++) {
if (arr[i] == 0)
curr = 0;
else
curr++;
front[i] = curr;
}
curr = mod;
for (i = n - 1; i >= 0; i--) {
if (arr[i] == 0)
curr = 0;
else
curr++;
rear[i] = curr;
}
for (long long int i = 0; i < n; i++) cout << min(front[i], rear[i]) << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
string s;
void input() { cin >> s; }
void solve() {
cout << s.substr(0, 2);
for (int i = 3; i < (int)s.size(); i += 2) cout << s[i];
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(16);
cout << fixed;
int t = 1;
cin >> t;
while (t--) {
input();
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50008;
char S[maxn], T[maxn];
int n;
int main() {
scanf("%s", S);
n = strlen(S);
for (int i = 1; i + i <= n; i++) {
int cur = 0, m = i;
for (int j = i; j < n; j++) {
S[m++] = S[j];
if (S[m - 1] == S[m - i - 1]) {
if (++cur == i) cur = 0, m -= i;
} else
cur = 0;
}
n = m;
}
for (int i = 0; i < n; i++) printf("%c", S[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r = 1;
scanf("%d", &n);
string s[] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
while (r * 5 < n) {
n -= r * 5;
r *= 2;
}
n = n - 1;
n = n / r;
cout << s[n] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int ta[200007];
vector<int> G[200007];
int roz[200007];
int ile[200007];
int dp[200007];
int ww[200007];
int ss;
int ileok;
bool chres;
void dfs1(int v, int p) {
roz[v] = 1;
ile[v] = 0;
if (ta[v] >= ss) ile[v] = 1;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
dfs1(G[v][i], v);
roz[v] += roz[G[v][i]];
ile[v] += ile[G[v][i]];
}
}
}
void dfs2(int v, int p) {
dp[v] = 1;
int maxi = 0;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
dfs2(G[v][i], v);
if (roz[G[v][i]] == ile[G[v][i]])
dp[v] += roz[G[v][i]];
else
maxi = max(maxi, dp[G[v][i]]);
}
}
dp[v] += maxi;
if (ta[v] < ss) dp[v] = 0;
}
void dfs3(int v, int p, int ndp = 0) {
int summ = 0;
int maxi = 0;
int gd = -1;
int dmaxi = 0;
if (n - roz[v] == ileok - ile[v])
summ += n - roz[v];
else {
maxi = ndp;
}
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
if (roz[G[v][i]] == ile[G[v][i]])
summ += roz[G[v][i]];
else {
if (dp[G[v][i]] > maxi) {
dmaxi = maxi;
maxi = dp[G[v][i]];
gd = i;
} else if (dp[G[v][i]] > dmaxi)
dmaxi = dp[G[v][i]];
}
}
}
ww[v] = summ + maxi + 1;
if (ta[v] >= ss && ww[v] >= k) chres = 1;
for (int i = 0; i < G[v].size(); ++i) {
if (G[v][i] != p) {
int np = summ + 1;
if (roz[G[v][i]] == ile[G[v][i]]) np -= roz[G[v][i]];
if (i == gd)
np += dmaxi;
else
np += maxi;
if (ta[v] < ss) np = 0;
dfs3(G[v][i], v, np);
}
}
}
bool check() {
chres = 0;
ileok = 0;
for (int i = 1; i <= n; ++i)
if (ta[i] >= ss) ileok++;
dfs1(1, 0);
dfs2(1, 0);
dfs3(1, 0);
return chres;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> ta[i];
for (int i = 1; i < n; ++i) {
int c, d;
cin >> c >> d;
G[c].push_back(d);
G[d].push_back(c);
}
int pp = 0;
int kk = 1000007;
int wynik = 0;
while (pp <= kk) {
ss = (pp + kk) / 2;
if (check()) {
pp = ss + 1;
wynik = ss;
} else
kk = ss - 1;
}
cout << wynik << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int n, m, ans;
string s;
vector<int> G[maxn];
int vis[maxn];
int dp[maxn][30];
void dfs(int u) {
vis[u] = 1;
dp[u][s[u - 1] - 'a'] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v] == 1) {
cout << "-1" << endl;
exit(0);
} else {
if (!vis[v]) dfs(v);
for (int j = 0; j < 26; j++) {
dp[u][j] = max(dp[u][j], dp[v][j] + (s[u - 1] - 'a' == j));
}
}
}
vis[u] = 2;
}
int main() {
cin >> n >> m;
cin >> s;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
memset(vis, false, sizeof(vis));
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
for (int j = 0; j < 26; j++) {
ans = max(ans, dp[i][j]);
}
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int maxc = maxn * maxn;
const int MOD = 998244353;
long long mod(long long x) {
x %= MOD;
if (x < 0) x += MOD;
return x;
}
long long modReverse(long long b, long long p) {
if (1 == b) return 1;
return modReverse(p % b, p) * (p - p / b) % p;
}
struct cell {
long long x, y, c;
bool operator<(const cell& A) const {
if (c != A.c) return c < A.c;
if (x != A.x) return x < A.x;
if (y != A.y) return y < A.y;
}
cell() {}
cell(long long xx, long long yy, long long cc) : x(xx), y(yy), c(cc) {}
};
int n, m;
cell b[maxc];
long long dp[maxc], s[maxc], ssqx[maxc], sx[maxc], ssqy[maxc], sy[maxc];
int r, c;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int tp;
scanf("%d", &tp);
b[i * m + j + 1] = cell(i + 1, j + 1, tp);
}
scanf("%d%d", &r, &c);
sort(b + 1, b + n * m + 1);
dp[0] = s[0] = sx[0] = sy[0] = ssqx[0] = ssqy[0] = 0;
long long ans = -1;
int k;
for (k = 1; k <= n * m; k++) {
int x = b[k].x, y = b[k].y;
if (k > 1 && b[k].c > b[k - 1].c) break;
if (x == r && y == c) {
ans = 0;
break;
}
dp[k] = 0;
s[k] = mod(s[k - 1] + dp[k]);
sx[k] = mod(sx[k - 1] + x);
sy[k] = mod(sy[k - 1] + y);
ssqx[k] = mod(ssqx[k - 1] + mod(x * x));
ssqy[k] = mod(ssqy[k - 1] + mod(y * y));
}
k--;
if (ans == -1)
for (int i = k + 1; i <= n * m; i++) {
if (b[i].c != b[i - 1].c) k = i - 1;
int x = b[i].x, y = b[i].y;
dp[i] = mod(s[k] + mod(k * mod(x * x)) + ssqx[k] - mod(2 * x * sx[k]) +
mod(k * mod(y * y)) + ssqy[k] - mod(2 * y * sy[k]));
dp[i] = mod(dp[i] * modReverse(k, MOD));
if (x == r && y == c) {
ans = dp[i];
break;
}
s[i] = mod(s[i - 1] + dp[i]);
sx[i] = mod(sx[i - 1] + x);
sy[i] = mod(sy[i - 1] + y);
ssqx[i] = mod(ssqx[i - 1] + mod(x * x));
ssqy[i] = mod(ssqy[i - 1] + mod(y * y));
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using ll = long long;
const int N = 1000010;
using pii = std::pair <ll, ll>;
struct State{
ll l, r;
int type;
State (ll l = 0, ll r = 0, int type = 0):l(l), r(r), type(type){}
};
using rb_type = std::tuple <int, int, State>;
std::vector <rb_type> rollback[N][2];
std::vector <rb_type> *rb;
struct stack_wrapper{
std::deque<State> deque;
ll offset;
bool reverse;
stack_wrapper():deque(std::deque<State>()), offset(0), reverse(false){}
size_t size()const{
return deque.size();
}
bool empty()const{
return deque.empty();
}
void emplace_back(ll l, ll r, int type){
if (reverse){
deque.emplace_front(offset - r, offset - l, type);
rb -> push_back({0, 0, {0, 0, 0}});
}
else{
deque.emplace_back(l - offset, r - offset, type);
rb -> push_back({1, 0, {0, 0, 0}});
}
}
pii back()const{
if (reverse){
return {offset - deque.front().r, offset - deque.front().l};
}
else{
return {offset + deque.back().l, offset + deque.back().r};
}
}
State operator [](const int &n)const{
if (reverse){
int sz = deque.size();
return {offset - deque[sz - 1 - n].r, offset - deque[sz - 1 - n].l, deque[sz - 1 - n].type};
}
else{
return {offset + deque[n].l, offset + deque[n].r, deque[n].type};
}
}
State get(const int &n)const{
if (reverse){
return {offset - deque[n].r, offset - deque[n].l, deque[n].type};
}
else{
return {offset + deque[n].l, offset + deque[n].r, deque[n].type};
}
}
void pop_back(){
if (reverse){
rb -> push_back({0, 1, deque.front()});
deque.pop_front();
}
else{
rb -> push_back({1, 1, deque.back()});
deque.pop_back();
}
}
void revert(ll x){
rb -> push_back({2, 0, {offset, reverse, 0}});
offset = x - offset;
reverse = !reverse;
}
};
ll w[N];
ll ans[N];
bool reverse[N];
int main(){
int n;
ll c;
scanf("%d%lld", &n, &c);
for (int i = 1; i <= n - 2; ++ i){
scanf("%lld", &w[i]);
}
stack_wrapper stack;
rb = rollback[0] + 0;
stack.emplace_back(0, c, -1);
for (int i = 1; i <= n - 2; ++ i){
rb = rollback[i] + 0;
while (!stack.empty()){
pii p = stack.back();
if (p.first > w[i]){
stack.pop_back();
continue;
}
if (p.second > w[i]){
stack.pop_back();
stack.emplace_back(p.first, w[i], 0);
}
break;
}
if (stack.empty()){
puts("NO");
return 0;
}
rb = rollback[i] + 1;
pii p = stack.back();
stack.pop_back();
stack.emplace_back(p.first, p.second, 0);
p = stack.back();
if (p.second == w[i]){
while (!stack.empty()){
stack.pop_back();
}
stack.emplace_back(0, w[i], 1);
continue;
}
stack.revert(w[i]);
if (stack.back().second < w[i]){
stack.emplace_back(w[i], w[i], 2);
}
}
int pos = 0;
ans[n - 1] = stack.get(pos).l;
for (int i = n - 2; i >= 1; -- i){
auto operate = [&](std::vector <rb_type> &x){
while (!x.empty()){
auto [fl1, fl2, state] = x.back();
x.pop_back();
if (fl1 == 2){
stack.offset = state.l;
stack.reverse = state.r;
}
else if (fl1 == 0){
if (fl2 == 0){
stack.deque.pop_front();
-- pos;
}
else{
stack.deque.push_front(state);
++ pos;
}
}
else{
if (fl2 == 0){
stack.deque.pop_back();
}
else{
stack.deque.emplace_back(state);
}
}
}
};
State s = stack.get(pos);
operate(rollback[i][1]);
if (s.type == 0){
ans[i] = w[i] - ans[i + 1];
}
else if (s.type == 1){
pos = stack.reverse ? 0 : int(stack.size()) - 1;
ans[i] = w[i];
reverse[i] = true;
}
else if (s.type == 2){
ans[i] = stack.get(0).l;
pos = 0;
reverse[i] = true;
}
operate(rollback[i][0]);
}
int rev = 0;
for (int i = n - 2; i >= 1; -- i){
rev ^= int(reverse[i]);
if (rev){
ans[i] = -ans[i];
}
}
for (int i = 1; i <= n - 1; ++ i){
ans[i] += ans[i - 1];
}
ll min = *std::min_element(ans, ans + n);
puts("YES");
for (int i = 0; i < n; ++ i){
ans[i] -= min;
printf("%lld%c", ans[i], " \n"[i == n - 1]);
}
for (int i = 1; i < n - 2; ++ i){
ll x[3] = {ans[i - 1], ans[i], ans[i + 1]};
std::sort(x, x + 3);
assert(x[2] - x[0] == w[i]);
}
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long a[maxn];
long long n, k, m;
int main() {
cin >> n >> m >> k;
long long ans = 0;
long long s = 0;
long long kk = k;
long long sum = 0;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
if (a[i] <= k + sum)
s++;
else {
if (s > 0) {
sum += s;
i--;
ans++, s = 0;
} else if ((a[i] - k - sum) / kk > 10)
k = (a[i] - kk) / kk * kk, i--;
else
k += kk, i--;
}
}
if (s > 0) ans++;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000 * 1000 * 1000 + 1;
int c, d, n, m, k;
int ans;
int main() {
cin >> c >> d >> n >> m >> k;
ans = oo;
int cnt = n * m - k, cst = 0;
while (cnt >= 0) {
ans = min(ans, cst + cnt * d);
cst += c;
cnt -= n;
}
ans = min(ans, cst);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
struct Fenwick {
vector<int> t;
Fenwick() {}
Fenwick(int n) { t.assign(n, 0); }
void change(int pos, int x) {
for (; pos < (int)t.size(); pos |= pos + 1) {
t[pos] += x;
}
}
int go(int pos) {
int ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ans += t[pos];
}
return ans;
}
int go(int l, int r) { return go(r) - go(l - 1); }
};
const int maxn = (int)2e5 + 10, maxlog = 19;
mt19937 rr;
struct vt {
int x;
int v;
int y;
int sz;
int l;
int r;
vt() {}
vt(int x, int v) : x(x), v(v), y(rr()), sz(1), l(-1), r(-1) {}
};
vt mas[maxn * 40];
int posit = 0;
int my_new(int x, int v) {
mas[posit] = vt(x, v);
return posit++;
}
int sz(int t) { return (t == -1 ? 0 : mas[t].sz); }
void recalc(int t) { mas[t].sz = 1 + sz(mas[t].l) + sz(mas[t].r); }
int merge(int l, int r) {
if (l == -1) {
return r;
}
if (r == -1) {
return l;
}
if (mas[l].y > mas[r].y) {
mas[l].r = merge(mas[l].r, r);
recalc(l);
return l;
}
mas[r].l = merge(l, mas[r].l);
recalc(r);
return r;
}
void split(int t, int x, int &l, int &r) {
if (t == -1) {
l = -1;
r = -1;
return;
}
if (mas[t].x < x) {
split(mas[t].r, x, mas[t].r, r);
l = t;
recalc(l);
} else {
split(mas[t].l, x, l, mas[t].l);
r = t;
recalc(r);
}
}
int par[maxlog][maxn];
vector<int> ed[maxn];
vector<int> vert;
int pos[maxn];
int h[maxn];
int tin[maxn], tout[maxn];
int tt = -1;
void dfs(int v, int p, int hh) {
tt++;
tin[v] = tt;
pos[v] = (int)vert.size();
vert.push_back(v);
h[v] = hh;
par[0][v] = p;
for (int i = 1; i < maxlog; i++) {
par[i][v] = par[i - 1][par[i - 1][v]];
}
for (int u : ed[v]) {
if (u != p) {
dfs(u, v, hh + 1);
vert.push_back(v);
}
}
tout[v] = tt;
}
pair<int, int> tab[maxlog][2 * maxn];
int st[2 * maxn];
int lca(int a, int b) {
int l = pos[a];
int r = pos[b];
if (l > r) {
swap(l, r);
}
int it = st[r - l + 1];
return min(tab[it][l], tab[it][r - (1 << it) + 1]).second;
}
int up(int v, int d) {
int ans = v;
for (int i = 0; d; d >>= 1, i++) {
if (d & 1) {
ans = par[i][ans];
}
}
return ans;
}
int a[maxn], b[maxn], lc[maxn];
int k;
vector<int> e[maxn];
vector<int> z[maxn];
long long ans;
int calc(int t, int r) {
if (t == -1) {
return 0;
}
if (mas[t].x <= r) {
return sz(mas[t].l) + 1 + calc(mas[t].r, r);
} else {
return calc(mas[t].l, r);
}
}
int calc(int t, int l, int r) { return calc(t, r) - calc(t, l - 1); }
void add_ans(int t, int v, int root, int d) {
if (d > 0 && d < k) {
int ds = h[v] - h[root];
if (d <= ds) {
int u = up(v, ds - d);
ans += calc(t, tin[u], tout[u]);
}
if (k <= ds) {
int u = up(v, ds - k);
ans -= calc(t, tin[u], tout[u]);
}
}
if (d <= 0) {
int ds = h[v] - h[root];
if (k <= ds) {
int u = up(v, ds - k);
ans -= calc(t, tin[u], tout[u]);
}
}
}
void add_ans_tr(int t, int nt, int root, int d) {
if (nt == -1) {
return;
}
add_ans_tr(t, mas[nt].l, root, d);
add_ans_tr(t, mas[nt].r, root, d);
add_ans(t, mas[nt].v, root, d);
}
void add(int &t, int v) {
int l, r;
split(t, tin[v], l, r);
t = merge(merge(l, my_new(tin[v], v)), r);
}
void add_tr(int &t, int nt) {
if (nt == -1) {
return;
}
add_tr(t, mas[nt].l);
add_tr(t, mas[nt].r);
add(t, mas[nt].v);
}
int build(int v, int root) {
int t = -1;
int ds = h[v] - h[root];
ds = k - ds;
for (int u : z[v]) {
add_ans(t, u, root, ds);
add(t, u);
}
for (int u : e[v]) {
int nt = build(u, root);
if (sz(nt) > sz(t)) {
swap(t, nt);
}
add_ans_tr(t, nt, root, ds);
add_tr(t, nt);
}
return t;
}
int main() {
int curv = -1;
for (int i = 1; i < 2 * maxn; i++) {
if ((i & (i - 1)) == 0) {
curv++;
}
st[i] = curv;
}
int n, m;
cin >> n >> m >> k;
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
ed[x].push_back(y);
ed[y].push_back(x);
}
dfs(0, 0, 0);
for (int i = 0; i < (int)vert.size(); i++) {
tab[0][i] = make_pair(h[vert[i]], vert[i]);
}
for (int i = 1; i < maxlog; i++) {
for (int j = 0; j <= (int)vert.size() - (1 << i); j++) {
tab[i][j] = min(tab[i - 1][j], tab[i - 1][j + (1 << (i - 1))]);
}
}
vector<pair<int, int> > g;
for (int i = 0; i < m; i++) {
scanf("%d %d", &a[i], &b[i]);
a[i]--;
b[i]--;
int l = lca(a[i], b[i]);
lc[i] = l;
if (h[a[i]] + h[b[i]] - 2 * h[l] < k) {
m--;
i--;
continue;
}
if (h[a[i]] - h[l] >= k) {
g.push_back(make_pair(h[l], a[i]));
}
if (h[b[i]] - h[l] >= k) {
g.push_back(make_pair(h[l], b[i]));
}
}
sort((g).begin(), (g).end());
reverse((g).begin(), (g).end());
Fenwick tr(n);
for (int i = 0; i < (int)g.size(); i++) {
tr.change(tin[g[i].second], 1);
}
for (int i = 0; i < (int)g.size(); i++) {
tr.change(tin[g[i].second], -1);
int v = g[i].second;
int d = h[v] - g[i].first;
v = up(v, d - k);
ans += tr.go(tin[v], tout[v]);
}
vector<pair<pair<int, int>, pair<int, int> > > f;
for (int i = 0; i < m; i++) {
int x = a[i];
int y = b[i];
int l = lc[i];
if (x == l || y == l) {
continue;
}
int px = up(x, h[x] - h[l] - 1);
int py = up(y, h[y] - h[l] - 1);
if (px > py) {
swap(px, py);
swap(x, y);
}
f.push_back(make_pair(make_pair(px, py), make_pair(x, y)));
}
sort((f).begin(), (f).end());
int l = 0;
while (l < (int)f.size()) {
int r = l;
while (r < (int)f.size() && f[r].first == f[l].first) {
r++;
}
vector<int> ver;
for (int i = l; i < r; i++) {
ver.push_back(f[i].second.second);
}
sort((ver).begin(), (ver).end(),
[&](int a, int b) { return tin[a] < tin[b]; });
for (int i = 0; i < r - l - 1; i++) {
int l = lca(ver[i], ver[i + 1]);
ver.push_back(l);
}
sort((ver).begin(), (ver).end());
ver.resize(unique((ver).begin(), (ver).end()) - ver.begin());
sort((ver).begin(), (ver).end(),
[&](int a, int b) { return tin[a] < tin[b]; });
vector<int> st;
st.push_back(ver[0]);
for (int i = 1; i < (int)ver.size(); i++) {
int v = ver[i];
int l = lca(st.back(), v);
while (st.back() != l) {
st.pop_back();
}
e[l].push_back(v);
st.push_back(v);
}
for (int i = l; i < r; i++) {
z[f[i].second.second].push_back(f[i].second.first);
}
posit = 0;
build(ver[0], par[0][f[l].first.second]);
for (int v : ver) {
e[v].clear();
z[v].clear();
}
l = r;
}
cout << ans << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int l[maxn];
int r[maxn];
int main() {
int n, p1, p2, p3, t1, t2;
scanf("%d %d %d %d %d %d", &n, &p1, &p2, &p3, &t1, &t2);
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &l[i], &r[i]);
ans += (r[i] - l[i]) * p1;
if (i > 1 && i <= n) {
int cnt = l[i] - r[i - 1];
if (cnt <= t1)
ans += cnt * p1;
else if (cnt > t1 && cnt <= (t1 + t2))
ans += t1 * p1 + (cnt - t1) * p2;
else if (cnt > (t1 + t2))
ans += t1 * p1 + t2 * p2 + (cnt - t1 - t2) * p3;
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.