solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int r;
int a[100000];
int z = 0;
int k = 0;
int c = 0;
int d = 0;
cin >> r;
for (int i = 0; i < r; i++) {
cin >> a[i];
}
for (int i = 0; i < r; i++) {
if (a[i] == 3) c++;
}
for (int i = 0; i < r; i++) {
if (a[i] == 1) d++;
}
for (int i = 0; i < r; i++) {
if (a[i] != 3 && a[i] != 1) z = z + a[i];
}
if (d > 0) {
if (c >= d && d > 0) {
if (z % 4 == 0)
cout << (z / 4) + c << endl;
else
cout << (z / 4) + (c + 1) << endl;
} else if (c < d) {
if (z + d - c <= 4)
cout << c + 1 << endl;
else {
if ((z + d - c) % 4 == 0)
cout << ((z + d - c) / 4) + c << endl;
else
cout << ((z + d - c) / 4) + (c + 1) << endl;
}
}
} else {
if (z == 0 && c == 1)
cout << c << endl;
else {
if (z < 4 && z > 0)
cout << (c + 1) << endl;
else {
if (z % 4 == 0)
cout << (z / 4) + c << endl;
else
cout << (z / 4) + (c + 1) << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[500005];
int parent[500005];
int dp[500005][2][2], dp2[500005][2][2];
int tdp[500005][2][2], ldp[500005][2][2], rdp[500005][2][2];
int& get(int u, int v, int i, int j) {
if (parent[u] == v) return dp2[u][i][j];
return dp[v][i][j];
}
void dfs(int v, int p) {
parent[v] = p;
for (auto u : G[v]) {
if (u == p) continue;
dfs(u, v);
}
int d = G[v].size();
for (long long(i) = (0); (i) <= (d); (i)++)
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) tdp[i][j][k] = 0;
tdp[0][0][0] = 1;
for (long long(i) = (0); (i) <= (d - 1); (i)++) {
int u = G[v][i];
if (u == p) {
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++)
tdp[i + 1][j][k] = tdp[i][j][k];
continue;
}
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) {
for (long long(l) = (0); (l) <= (1); (l)++)
for (long long(m) = (0); (m) <= (1); (m)++) {
if (j + l <= 1 && k + m <= 1) {
tdp[i + 1][j + l][k + m] += tdp[i][j][k] * get(v, u, l, m);
}
}
}
}
for (long long(i) = (0); (i) <= (1); (i)++)
for (long long(j) = (0); (j) <= (1); (j)++)
get(p, v, i, j) = tdp[d][1 - i][j];
get(p, v, 0, 1) += tdp[d][0][0];
}
void dfs2(int v, int p) {
int d = G[v].size();
for (long long(i) = (0); (i) <= (d); (i)++)
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) ldp[i][j][k] = 0;
ldp[0][0][0] = 1;
for (long long(i) = (0); (i) <= (d - 1); (i)++) {
int u = G[v][i];
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) {
for (long long(l) = (0); (l) <= (1); (l)++)
for (long long(m) = (0); (m) <= (1); (m)++) {
if (j + l <= 1 && k + m <= 1) {
ldp[i + 1][j + l][k + m] += ldp[i][j][k] * get(v, u, l, m);
}
}
}
}
for (long long(i) = (0); (i) <= (d); (i)++)
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) rdp[i][j][k] = 0;
rdp[d][0][0] = 1;
for (int i = d; i >= 1; i--) {
int u = G[v][i - 1];
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) {
for (long long(l) = (0); (l) <= (1); (l)++)
for (long long(m) = (0); (m) <= (1); (m)++) {
if (j + l <= 1 && k + m <= 1) {
rdp[i - 1][j + l][k + m] += rdp[i][j][k] * get(v, u, l, m);
}
}
}
}
for (long long(i) = (0); (i) <= (d - 1); (i)++) {
int u = G[v][i];
if (u == p) continue;
for (long long(j) = (0); (j) <= (1); (j)++)
for (long long(k) = (0); (k) <= (1); (k)++) {
for (long long(l) = (0); (l) <= (1); (l)++)
for (long long(m) = (0); (m) <= (1); (m)++) {
if (j + l >= 2 || k + m >= 2) continue;
long long lval = ldp[i][j][k];
long long rval = rdp[i + 1][l][m];
get(u, v, 1 - (j + l), k + m) += lval * rval;
}
}
get(u, v, 0, 1) += get(u, v, 1, 0);
}
for (auto u : G[v]) {
if (u == p) continue;
dfs2(u, v);
}
}
long long ans = 0;
long long calcdfs(int v, int p) {
long long ret = 1;
for (auto u : G[v]) {
if (u == p) continue;
long long res = calcdfs(u, v);
ans += (long long)get(u, v, 0, 1) * (long long)get(v, u, 0, 1);
if (get(u, v, 0, 0) * get(v, u, 0, 0)) ans += res * (n - res);
ret += res;
}
return ret;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int u, v;
for (long long(i) = (1); (i) <= (n - 1); (i)++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
dfs2(1, 0);
calcdfs(1, -1);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
vector<long long int> v;
long long int ar[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, k;
cin >> n >> m;
multiset<long long int> st;
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
long long int ans2 = ar[n - 1] + m;
for (int i = 0; i < n; i++) st.insert(ar[i]);
while (m > 0) {
auto it = st.begin();
st.insert(*it + 1);
st.erase(it);
m--;
}
auto it = st.end();
it--;
cout << *it << " " << ans2 << endl;
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int s=0,n,a[222];
cin>>n;
for(int i=0;i<n*2;i++)cin>>a[i];
sort(a,a+n*2);
for(int i=0;i<n;i++)
{
s+=min(a[i*2],a[i*2+1]);
}
cout<<s<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, v, c, x, z, a[1000001], s, d, f, g, h, j, k, b[100001], i, p, y,
p1, q;
int main() {
long long t;
cin >> t;
while (t--) {
cin >> n;
s = 0;
k = 8;
for (long long i = 1; i <= n / 2; i++) {
s += k * i * i;
}
cout << s << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int arr[N];
class Bit {
int tree[N];
public:
Bit() { memset(tree, 0, sizeof tree); }
int query(int idx) {
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
while (idx <= N) {
tree[idx] += val;
idx += (idx & -idx);
}
}
int findFirstIdx(int sum) {
int k = 0;
while ((1 << (k + 1)) <= N) {
k++;
}
int idx = 0;
while (k >= 0) {
int nxtIdx = idx + (1 << k);
if (nxtIdx <= N && tree[nxtIdx] < sum) {
idx = nxtIdx;
sum -= tree[idx];
}
k--;
}
return idx + 1;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
Bit bit;
for (int i = 0; i < n; i++) {
cin >> arr[i];
bit.update(arr[i], 1);
}
int removed = 0;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x < 0) {
int idx = bit.findFirstIdx(-x);
bit.update(idx, -1);
removed++;
} else {
bit.update(x, 1);
removed--;
}
}
if (removed == n) {
cout << 0;
} else {
cout << bit.findFirstIdx(1);
}
}
| 4 |
#include <iostream>
using namespace std;
int p;
int a[3000], s[3000], t[3000], b[3000];
int main()
{
cin >> p;
for (int i = 0; i < p; i++)
cin >> a[i];
for (int i = 0; i < p; i++)
b[i] = 0;
s[0] = 1;
t[0] = 1;
for (int i = 1; i < p; i++) {
s[i] = s[i - 1] * i % p;
int j = s[i], k = 1;
while (k < (p - 2) / 2) {
j = j * j % p;
k *= 2;
}
while (k < p - 2) {
j = j * s[i] % p;
k++;
}
t[i] = j;
}
for (int i = 0; i < p; i++) {
if (a[i] == 1) {
b[p - 1] = (b[p - 1] - 1 + p) % p;
if (i == 0)
b[0] = (b[0] + 1) % p;
else {
int u = i, v = 1;
while (v < (p - 2) / 2) {
u = u * u % p;
v *= 2;
}
while (v < p - 2) {
u = u * i % p;
v++;
}
int w = u;
for (int j = 1; j < p - 1; j++) {
if (j % 2 == 0)
b[j] = (b[j] - s[p - 1] * t[j] % p * t[p - 1 - j] % p * w + p) % p;
else
b[j] = (b[j] + s[p - 1] * t[j] % p * t[p - 1 - j] % p * w) % p;
w = w * u % p;
}
}
}
}
for (int i = 0; i < p - 1; i++)
cout << b[i] << " ";
cout << b[p - 1] << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
int s=k;
for(int i=2;i<=n;i++){
s*=k-1;
}
cout<<s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x;
long long w = 0, b = 0;
for (int i = 0; i < n; ++i) {
cin >> x;
if (x % 2 == 0) {
w += x / 2;
b += x / 2;
} else if (i % 2) {
w += x / 2;
b += x / 2 + 1;
} else {
w += x / 2 + 1;
b += x / 2;
}
}
cout << min(w, b) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, sm = 0, SM = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sm += x;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
SM += x;
}
if (sm < SM)
cout << "No";
else
cout << "Yes";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const int INF = 100000000;
int main(void) {
int m;
cin >> m;
for(int i=0; i<m; i++){
string s;
cin >> s;
set<string> sset;
string sr = s;
reverse(s.begin(), s.end());
for(int i=0; i<s.size() - 1; i++){
string s1 = s.substr(0, i+1);
string s2 = s.substr(i+1);
string s1r = sr.substr(sr.size() - (i+1));
string s2r = sr.substr(0, sr.size() - (i+1));
sset.insert(s1 + s2);
sset.insert(s1r + s2);
sset.insert(s1 + s2r);
sset.insert(s1r + s2r);
sset.insert(s2 + s1);
sset.insert(s2r + s1);
sset.insert(s2 + s1r);
sset.insert(s2r + s1r);
}
cout << sset.size() << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long modulo(long long base, long long exp, long long m);
long long powerr(long long base, long long exp, long long m);
long long inverse(long long a, long long m);
const long long nax = 1e5 + 10;
vector<long long> tree(4 * nax);
void update(long long node, long long start, long long end, long long ind,
long long val) {
if (start == end) {
tree[node] = val;
return;
}
long long mid = (start + end) / 2;
if (start <= ind && ind <= mid)
update(2 * node + 1, start, mid, ind, val);
else
update(2 * node + 2, mid + 1, end, ind, val);
tree[node] = tree[2 * node + 1] + tree[2 * node + 2];
}
long long query(long long node, long long start, long long end, long long l,
long long r) {
if (l > end || r < start) return 0;
if (l <= start && r >= end) return tree[node];
long long mid = (start + end) / 2;
long long p1 = query(2 * node + 1, start, mid, l, r);
long long p2 = query(2 * node + 2, mid + 1, end, l, r);
return p1 + p2;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
if (n == 1)
cout << -1 << endl;
else {
vector<long long> mind(n + 1, -1);
long long ans = INT_MAX;
for (long long i = 0; i < n; i++) {
if (mind[v[i]] != -1) ans = min(ans, i - mind[v[i]] + 1);
mind[v[i]] = i;
}
if (ans == INT_MAX) ans = -1;
cout << ans << endl;
}
}
return 0;
}
long long modulo(long long base, long long exp, long long m) {
long long answer = 1;
while (exp > 0) {
if (exp % 2 == 1) answer = (answer * base) % m;
exp = exp / 2;
base = (base * base) % m;
}
return answer;
}
long long powerr(long long base, long long exp, long long m) {
base = base % m;
if (exp == 0)
return 1;
else {
if (exp % 2 == 0) {
long long x = powerr(base, exp / 2, m);
return (x * x) % m;
} else {
long long x = powerr(base, (exp - 1) / 2, m);
return ((base % m) * ((x * x) % m)) % m;
}
}
}
void EE(long long a, long long b, long long &co1, long long &co2) {
if (a % b == 0) {
co1 = 0;
co2 = 1;
return;
}
EE(b, a % b, co1, co2);
long long temp = co1;
co1 = co2;
co2 = temp - co2 * (a / b);
}
long long inverse(long long a, long long m) {
long long x, y;
EE(a, m, x, y);
if (x < 0) x += m;
return x;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int64_t mod=1000000007;
int64_t powermod(int k,int d){
int64_t m=1;
for(int i=0;i<k;i++){
m=m*d%mod;
}
return m;
}
int main(){
int n;
cin >> n;
int64_t ans=powermod(n,10)-powermod(n,9)-powermod(n,9)+powermod(n,8);
ans%=mod;
ans=(ans+mod)%mod;
cout << ans << endl;
} | 0 |
// ???
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
int m, n;
cin >> m >> n;
int a[n];
for(int i = 0; i < n; i++) cin >> a[i];
if(m == 2){
int ret = 1<<30;
for(int i = 1; i <= 2; i++){
int x = i;
int tmp = 0;
for(int j = 0; j < n; j++){
tmp += a[j]!=x;
x = 3-x;
}
ret = min(ret, tmp);
}
cout << ret << endl;
return 0;
}
int ret = 0;
for(int i = 1; i < n; i++){
if(a[i]==a[i-1]){
a[i] = -1;
ret++;
}
}
cout << ret << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dir[] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
int ex[15];
int ans[15];
int gr[1009][1009];
queue<pair<pair<int, int>, int>> q[15];
int cnt;
int main() {
int n, m, p;
cin >> n >> m >> p;
for (int i = 1; i <= p; ++i) cin >> ex[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
if (c == '.')
gr[i][j] = 0;
else if (c == '#')
gr[i][j] = -1;
else {
gr[i][j] = c - '0';
q[c - '0'].push({{i, j}, 0});
++ans[c - '0'];
}
}
cnt = -1;
for (int loop = 0;; ++loop) {
if (cnt == 0) break;
cnt = 0;
for (int i = 1; i <= p; ++i) {
while (!q[i].empty()) {
pair<pair<int, int>, int> tmp = q[i].front();
if (tmp.second - loop * ex[i] >= ex[i]) {
break;
}
q[i].pop();
pair<int, int> cord = tmp.first;
for (int j = 0; j < 4; ++j) {
if (dir[j].first + cord.first >= 0 && dir[j].first + cord.first < n &&
dir[j].second + cord.second >= 0 &&
dir[j].second + cord.second < m &&
gr[dir[j].first + cord.first][dir[j].second + cord.second] == 0) {
++cnt;
gr[dir[j].first + cord.first][dir[j].second + cord.second] = i;
q[i].push({{dir[j].first + cord.first, dir[j].second + cord.second},
tmp.second + 1});
++ans[i];
}
}
}
}
}
for (int i = 1; i <= p; ++i) cout << ans[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 88;
char str[N];
int vis[33];
int main() {
int T;
char op[5];
for (int i = 0; i < 26; ++i) vis[i] = 3;
int remain = 26, ans = 0;
scanf("%d", &T);
for (int tt = 1; tt < T; ++tt) {
scanf("%s %s", op, str);
if (remain == 1) {
if (op[0] == '!' || op[0] == '?') ++ans;
continue;
}
if (op[0] == '!') {
int vt[28];
memset(vt, 0, sizeof(vt));
for (int i = 0; str[i]; ++i) vt[str[i] - 'a'] = 1;
for (int i = 0; i < 26; ++i)
if (!vt[i] && vis[i]) vis[i] = 0, --remain;
} else if (op[0] == '.') {
int vt[28];
memset(vt, 0, sizeof(vt));
for (int i = 0; str[i]; ++i) vt[str[i] - 'a'] = 1;
for (int i = 0; i < 26; ++i)
if (vt[i] && vis[i]) vis[i] = 0, --remain;
} else if (op[0] == '?') {
if (vis[str[0] - 'a']) vis[str[0] - 'a'] = 0, --remain;
}
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 114;
long long n, k, w, f;
inline long long read() {
long long num = 0;
char g = getchar();
while (g < 48 || 57 < g) g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
return num;
}
inline long long getsum(long long l, long long r) {
return (r - l + 1) * (l + r) / 2;
}
inline void solve(long long d) {
if (d == 1) {
w = k * (k + 1) / 2;
return;
}
solve((d - 1) / k + 1);
long long a = (d - 1) / k + 1, b = (d - 1) % k,
l = b * k + (a - 1) * (k * k + 1) + 1,
r = (b + 1) * k + (a - 1) * (k * k + 1),
v = (l + r) * (r - l + 1) / 2;
f = w;
if (r < w)
w = v;
else if (l >= w)
w = v + (r - l + 1);
else
w = v + (r - w + 1);
}
inline long long getans(long long v, long long w) {
if (v > w)
return ((v - 1) / (k * k + 1)) * (k * k + k) +
((v - 2) % (k * k + 1)) / k * (k + 1) + (v - 2) % (k * k + 1) % k +
1;
else if (v < w)
return ((v - 1) / (k * k + 1)) * (k * k + k) +
((v - 1) % (k * k + 1)) / k * (k + 1) + (v - 1) % (k * k + 1) % k +
1;
else {
long long v = (f - 1) / (k * k + 1), l = 0, r = k - 1, pos = 0;
while (l <= r) {
long long d = (l + r) >> 1;
if (w - getsum(v * (k * k + 1) + d * k + 1,
v * (k * k + 1) + (d + 1) * k) >=
0)
pos = d, l = d + 1;
else
r = d - 1;
}
return getans(v * (k * k + 1) + (pos + 1) * k +
(v * (k * k + 1) + (pos + 1) * k >= f),
f) +
1;
}
}
int main() {
int t = read();
while (t--) {
n = read(), k = read(), w = 0, f = 0,
solve(n / (k * k + 1) + (n % (k * k + 1) > 0)),
printf("%lld\n", getans(n, w));
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
int n;
while(cin>>s){
for(int i=0; i<(int)s.size(); i++){
if(s[i]!='@')cout << s[i];
else{
i++;
n = s[i]-'0';
i++;
for(int j=0; j<n; j++)cout<<s[i];
}
}
cout << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
auto s = 0LL;
for (int i = 0; i < n && s < 3 * k; ++i) s += 1LL << (2 * i);
if (k > s || (n < 3 && k == 3)) {
cout << "NO" << endl;
continue;
}
while (k > 0) {
k /= 4;
n--;
}
cout << "YES " << n << endl;
}
}
| 4 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const double PI = 3.141592653589793238;
const double EPS = 1e-10;
typedef pair<int, int> P;
struct BIT {
vector<ll> bit;
int n;
BIT(int n) :n(n) {
bit = vector<ll>(n + 1, 0);
}
ll sum(int i) {
i++;
ll s = 0;
while (i > 0) {
(s += bit[i]) %= MOD;
i -= i & -i;
}
return s;
}
ll get(int i) {
ll ret = sum(i);
if (i > 0) (ret += MOD - sum(i - 1)) %= MOD;
return ret;
}
void add(int i, ll x) {
i++;
while (i <= n) {
(bit[i] += x) %= MOD;
i += i & -i;
}
}
};
int main() {
int N, M;
cin >> N >> M;
vector<int> x(N);
vector<int> y(M);
for (int i = 0; i < N; i++) cin >> x[i];
for (int i = 0; i < M; i++) cin >> y[i];
vector<P> v;
for (int i = 0; i < N; i++) {
if (x[i] < y[0] || y[M - 1] < x[i]) continue;
int l = x[i] - *(lower_bound(y.begin(), y.end(), x[i]) - 1);
int r = *(upper_bound(y.begin(), y.end(), x[i])) - x[i];
v.emplace_back(l, -r);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
vector<int> a, b;
b.push_back(0);
for (int i = 0; i < v.size(); i++) {
a.push_back(-v[i].second);
b.push_back(-v[i].second);
}
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
for (int i = 0; i < a.size(); i++) {
a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
}
BIT dp(b.size() + 1);
dp.add(0, 1);
for (int i = 0; i < a.size(); i++) {
ll s = dp.sum(a[i] - 1);
dp.add(a[i], s);
}
cout << dp.sum(b.size()) << endl;
} | 0 |
#include <cassert>
#include <iostream>
#include <limits>
#include <vector>
using VI = std::vector<int>;
using VVI = std::vector<VI>;
using uint = unsigned;
struct Sparse {
VVI arr;
VI src;
// does not initialize, just sets src.size()
Sparse(int n)
:arr {},
src { VI(n) }
{}
int best(int p, int q) const {
return src[p] >= src[q] ? p : q;
}
static constexpr uint bitFloor(int x) {
return ((-1u >> __builtin_clz(x)) + 1u) >> 1;
}
// index query
int iquery(int L, int R) const {
assert(L < R);
uint p2 = bitFloor(R - L);
int k = __builtin_ctz(p2);
return best(arr[k][L], arr[k][R-p2]);
}
// value query
int vquery(int L, int R) const {
return L >= R ? std::numeric_limits<int>::min() : src[iquery(L, R)];
}
void initialize() {
arr.clear();
arr.reserve(__builtin_ctz(bitFloor(int(src.size()))) + 1);
arr.emplace_back(VI(src.size()));
for (int i = 0; i < int(src.size()); ++i)
arr[0][i] = i;
for (int step = 1;; step <<= 1) {
VI& prev = arr.back();
int maxi = int(prev.size()) - step;
if (maxi < 0)
break;
arr.emplace_back(maxi);
VI& curr = arr.back();
for (int i = 0; i < maxi; ++i)
curr[i] = best(prev[i], prev[i+step]);
}
//verify();
}
void verify() const {
int n = int(src.size());
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) {
int ans = std::numeric_limits<int>::min();
for (int k = i; k < j; ++k)
ans = std::max(ans, src[k]);
assert(ans == vquery(i, j));
if (i < j) {
int r = iquery(i, j);
assert(0 <= r);
assert(r < n);
assert(src[r] == ans);
for (int k = i; k < r; ++k)
assert(src[k] < ans);
}
}
return;
}
};
struct SegTree {
int n;
VI arr;
SegTree(const VI& v)
:n { int(v.size()) },
arr { VI(2*v.size()) }
{
for (int i = 0; i < n; ++i)
arr[n+i] = v[i];
for (int i = n-1; i >= 0; --i)
arr[i] = std::max(arr[2*i], arr[2*i+1]);
}
int query(int L, int R) const {
L += n;
R += n;
int ans = std::numeric_limits<int>::min();
while (L < R) {
ans = std::max(ans, std::max(arr[L], arr[R-1]));
L = (L + 1) >> 1;
R >>= 1;
}
return ans;
}
void set(int ix, int val) {
ix += n;
arr[ix] = val;
while (ix >>= 1)
arr[ix] = std::max(arr[2*ix], arr[2*ix+1]);
return;
}
};
int main() {
using namespace std;
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
VI p = VI(n);
for (int& pi : p)
cin >> pi;
Sparse direct { n };
for (int i = 0; i < n; ++i)
direct.src[i] = min(n, i + p[i] + 1);
direct.initialize();
Sparse indirect { n };
{
SegTree indirectSegTree { direct.src };
for (int i = n-1; i >= 0; --i) {
int indOpts = indirectSegTree.query(i+1, direct.src[i]);
indirectSegTree.set(i, max(direct.src[i], indOpts));
}
for(int i = 0; i < n; ++i)
indirect.src[i] = indirectSegTree.query(i, i+1);
indirect.initialize();
}
Sparse negLeftReach { n };
for (int i = 0; i < n; ++i)
negLeftReach.src[i] = p[i] - i;
negLeftReach.initialize();
struct DP_Entry {
int nextLeftFacing;
int reaches;
};
vector<DP_Entry> dpL = vector<DP_Entry>(n+1, DP_Entry { -1, -1 });
vector<DP_Entry> dpR = vector<DP_Entry>(n+1, DP_Entry { -1, -1 });
dpL[n] = dpR[n] = DP_Entry { n, -1 };
// Can lanterns [i, n) light themselves if lamp i points in direction X?
// If no: dpX[i] is DP_Entry { -1, -1 }.
// If yes: dpX[i] has the leftmost lamp in pointed left in some
// valid configuration on [i+1, n), and the next dp entry to consult
for (int i = n-1; i >= 0; --i) {
int nextStart = i+1;
// (nextStart - i) must at least double every 3 iterations, so this
// while loop runs O(log n) times for each value of i
while (negLeftReach.vquery(nextStart, n) >= -i) {
// while(some j in [nextStart, n) can reach i by pointing left)
int j = nextStart;
{ int jR = n-1; // binary search, find leftmost such j
while (j < jR) {
int M = (j + jR) >> 1;
int w = negLeftReach.iquery(nextStart, M+1);
if (negLeftReach.src[w] >= -i)
jR = w; // w <= M
else
j = M + 1;
}
}
assert(j < n);
int kL = direct.vquery(i+1, j);
if (j == i+1)
kL = j;
else {
assert(kL >= j);
assert(kL <= n);
if (kL > j + 1)
kL = indirect.vquery(j+1, kL);
assert(kL >= j);
assert(kL <= n);
}
bool okL = ((kL == j) ? dpL[kL] : dpR[kL]).nextLeftFacing >= 0;
if (okL) {
// dpR[i] == dpL[i] if the latter is OK; this is used later
dpL[i] = dpR[i] = DP_Entry { j, kL };
break;
}
if (kL > j && direct.iquery(i+1, kL) != j)
nextStart = kL;
else
nextStart = j+1;
int kR = direct.vquery(i, j); // i vs i+1: Is i facing right?
assert(kR >= j);
assert(kR <= n);
if (kR > j + 1)
kR = indirect.vquery(j+1, kR);
assert(kR >= j);
assert(kR <= n);
bool okR = ((kR == j) ? dpL[kR] : dpR[kR]).nextLeftFacing >= 0;
if (okR)
dpR[i] = DP_Entry { j, kR };
}
} // dpL and dpR calculated
if (dpR[0].nextLeftFacing < 0)
cout << "NO\n";
else {
string out = string(n, 'R');
// since dpR[i] = dpL[i] if the latter is an
// OK state, only use the former to step
for (int currStop = 0; currStop < n; currStop = dpR[currStop].reaches)
out[dpR[currStop].nextLeftFacing] = 'L';
cout << "YES\n" << out << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int s = 0, bj = 0;
char ch = getchar();
while (ch < '0' || ch > '9') bj |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9')
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return bj ? -s : s;
}
void printnum(int x) {
if (x > 9) printnum(x / 10);
putchar(x % 10 ^ 48);
}
void print(int x, char ch) {
if (x < 0) {
putchar('-');
x = -x;
}
printnum(x);
putchar(ch);
}
int n, m;
int a[1000005], bj[1000005], c[1000005], s[1000005], ans[1000005], aa[1000005];
struct node {
int x, id;
} b[1000005];
int xx;
bool cmp(node x, node y) { return x.x < y.x; }
struct que {
int l, r, num;
} q[1000005];
bool cmp1(que x, que y) { return x.r < y.r; }
int lowbit(int x) { return x & -x; }
void Add(int x, int d) {
for (int i = x; i <= n; i += lowbit(i)) c[i] ^= d;
}
int sum(int x) {
int ans = 0;
for (int i = x; i; i -= lowbit(i)) ans ^= c[i];
return ans;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
aa[i] = b[i].x = read();
s[i] = s[i - 1] ^ b[i].x;
b[i].id = i;
}
sort(b + 1, b + n + 1, cmp);
for (int i = 1; i <= n; i++)
if (b[i].x ^ b[i - 1].x)
a[b[i].id] = ++xx;
else
a[b[i].id] = xx;
m = read();
for (int i = 1; i <= m; i++) {
q[i].l = read();
q[i].r = read();
q[i].num = i;
}
sort(q + 1, q + m + 1, cmp1);
int nx = 1;
for (int i = 1; i <= m; i++) {
for (int j = nx; j <= q[i].r; j++) {
if (bj[a[j]]) Add(bj[a[j]], aa[j]);
bj[a[j]] = j;
Add(j, aa[j]);
}
ans[q[i].num] = s[q[i].r] ^ s[q[i].l - 1] ^ sum(q[i].r) ^ sum(q[i].l - 1);
nx = q[i].r + 1;
}
for (int i = 1; i <= m; i++) print(ans[i], '\n');
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, i;
int a[100];
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
if (n == 2) {
printf("3\n");
return 0;
}
if (n == 3) {
printf("5\n");
return 0;
}
a[1] = 1;
a[2] = 5;
a[3] = 13;
for (i = 4; a[i] <= 100; i++) a[i] = 2 * i - 1 + 2 * i - 3 + a[i - 1];
for (i = 1;; i++)
if (a[i] >= n) break;
printf("%d\n", 2 * i - 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846264338327950288419716939937510582;
int t;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
cout << fixed << setprecision(20) << cos(PI / (4 * n)) / sin(PI / (2 * n))
<< "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long MOD;
struct mat {
long long ma[2][2];
mat() { ma[0][0] = ma[0][1] = ma[1][0] = ma[1][1] = 0; }
};
mat MatMul(mat m1, mat m2) {
mat res;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
res.ma[i][k] = (res.ma[i][k] + m1.ma[i][j] * m2.ma[j][k]) % MOD;
return res;
}
mat MatExp(mat base, long long exp) {
if (exp == 1) return base;
mat x = MatExp(base, exp >> 1);
mat res = MatMul(x, x);
if (exp & 1) res = MatMul(res, base);
return res;
}
long long fibonacci(long long n) {
mat x;
x.ma[0][0] = x.ma[0][1] = x.ma[1][0] = 1LL;
mat res = MatExp(x, n);
return res.ma[0][0];
}
long long power(long long base, long long exp) {
if (exp == 0) return 1LL;
long long x = power(base, exp >> 1L);
x = (x * x) % MOD;
if (exp & 1) x = (x * base) % MOD;
return x;
}
int main() {
std::ios::sync_with_stdio(false);
long long n, k, l, m;
cin >> n >> k >> l >> m;
MOD = m;
if (m == 1 || (l < 63 && (1LL << l) <= k)) {
cout << 0 << endl;
return 0;
}
if (l == 0) {
if (k == 0)
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
long long pow = power(2, n);
long long fib = fibonacci(n + 1);
long long res = 1LL;
for (int i = 0; i < l; ++i) {
if ((k >> i) & 1)
res = (res * (pow - fib)) % m;
else
res = (res * fib) % m;
}
if (res < 0) res += m;
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int f[100][3][2];
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
int x;
scanf("%d", &x);
if (x == 0) {
f[i][1][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][1][1] = -1000000007;
f[i][2][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][2][1] = -1000000007;
}
if (x == 1) {
f[i][1][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][1][1] = max(max(f[i - 1][1][0], f[i - 1][2][0]), f[i - 1][2][1]) + 1;
f[i][2][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][2][1] = -1000000007;
}
if (x == 2) {
f[i][2][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][2][1] = max(max(f[i - 1][2][0], f[i - 1][1][0]), f[i - 1][1][1]) + 1;
f[i][1][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][1][1] = -1000000007;
}
if (x == 3) {
f[i][1][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][1][1] = max(max(f[i - 1][1][0], f[i - 1][2][0]), f[i - 1][2][1]) + 1;
f[i][2][0] = max(max(max(f[i - 1][1][1], f[i - 1][1][0]), f[i - 1][2][0]),
f[i - 1][2][1]);
f[i][2][1] = max(max(f[i - 1][2][0], f[i - 1][1][0]), f[i - 1][1][1]) + 1;
}
}
printf("%d",
n - max(max(max(f[n][1][0], f[n][1][1]), f[n][2][0]), f[n][2][1]));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
ll mod_pow(ll a, ll b, ll m) {
ll res = 1;
while (b) {
if (b & 1) {
res = (res * a) % m;
}
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll mod_inverse(long long int a, long long int m) {
return mod_pow(a, m - 2, m);
}
const long long int maxn = 1e5 + 5;
long long int spf[maxn];
void calc() {
for (long long int i = 2; i < maxn; ++i) {
if (spf[i] == 0) {
spf[i] = i;
for (long long int j = i; j < maxn; j += i) {
if (spf[j] == 0) spf[j] = i;
}
}
}
}
long long int getnum(long long int n, long long int k) {
long long int x = n;
long long int t1 = 1;
while (x > 1) {
long long int y = spf[x];
long long int cu = 0;
while (x % y == 0) {
x /= y;
cu++;
}
t1 *= pow(y, (k - cu) % k);
}
return t1;
}
void solve() {
calc();
long long int n, k;
cin >> n >> k;
long long int a[n];
long long int tot = 0;
map<long long int, long long int> f;
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 1) {
tot++;
}
long long int x = a[i];
long long int t1 = 1;
while (x > 1) {
long long int y = spf[x];
long long int cu = 0;
while (x % y == 0) {
x /= y;
cu++;
}
if (cu % k) {
t1 *= pow(y, cu % k);
}
}
f[t1]++;
}
long long int res = 0;
for (auto u : f) {
long long int v = getnum(u.first, k);
if (f.find(v) == f.end()) {
continue;
}
long long int t2 = 0;
if (v == u.first) {
t2 = (u.second * (u.second - 1)) / 2;
} else {
t2 = f[v] * u.second;
f[v] = 0;
}
res += t2;
}
cout << res << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define popb pop_back
#define all(A) A.begin(),A.end()
#define mod 1000000007
using namespace std;
int main() {
int n;
ll a=0,b=0,k;
cin>>n>>k;
vector<int> arr(n);
for(int i=0;i<n;i++) cin>>arr[i];
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(arr[i]<arr[j]) a++;
if(arr[i]>arr[j]) b++;
}
}
ll ans=(k*(k-1))/2;
ans%=mod;
ans*=a+b;
ans%=mod;
ans+=(k*b)%mod;
ans%=mod;
cout<<ans<<"\n";
return 0;
} | 0 |
// O(nlogn) - O(1) LCA
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int,int>;
#define mp make_pair
const int maxn = 200200;
vector <int> e[maxn];
int dep[maxn], dfs_seq[maxn * 2], idx, L[maxn], Log[maxn * 2], st[20][maxn * 2];
struct node {
int x, y, id;
bool operator < (const node & a) const {
return x < a.x || (x == a.x && y < a.y) || (x == a.x && y == a.y && id < a.id);
}
};
struct diam {
int d, u, v;
bool operator < (const diam & a) const {
return d < a.d || (d == a.d && u < a.u) || (d == a.d && u == a.u && v < a.v);
}
} d[maxn * 4];
vector <pii> tr[maxn * 4];
int Q[maxn], D[maxn];
bool has_query[maxn * 4];
void dfs(int u, int p) {
dfs_seq[++idx] = u;
L[u] = idx;
for (int i=0; i<e[u].size(); i++) {
int v = e[u][i];
if (v == p) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
dfs_seq[++idx] = u;
}
}
void init_lca() {
Log[0] = -1; for (int i=1; i<=idx; i++) Log[i] = Log[i/2] + 1;
for (int i=1; i<=idx; i++) st[0][i] = dfs_seq[i];
for (int i=1; i<20; i++) {
for (int j=1; j+(1<<i)-1<=idx; j++) {
if (dep[st[i-1][j]] <= dep[st[i-1][j+(1<<i-1)]]) st[i][j] = st[i-1][j];
else st[i][j] = st[i-1][j+(1<<i-1)];
}
}
}
int lca(int u, int v) {
if (L[v] < L[u]) swap(u, v);
int l = Log[L[v] - L[u] + 1];
if (dep[st[l][L[u]]] <= dep[st[l][L[v]-(1<<l)+1]]) {
return st[l][L[u]];
}
return st[l][L[v]-(1<<l)+1];
}
int dis(int u, int v) {
return dep[u] + dep[v] - 2 * dep[lca(u, v)];
}
// closest node from x to (u, v) -> (id, dis)
pii closest_pt(int x, int u, int v) {
int lu = lca(x, u), lv = lca(x, v);
if (lu == lv) {
int l = lca(u, v);
return mp(l, dis(l, x));
}
if (dep[lu] < dep[lv]) swap(lu, lv);
return mp(lu, dis(lu, x));
}
void add(int L, int R, pii path, int l, int r, int rt) {
if (L <= l && r <= R) {
tr[rt].push_back(path);
return ;
}
int mid = (l + r) / 2;
if (L <= mid) add(L, R, path, l, mid, rt<<1);
if (mid < R) add(L, R, path, mid+1, r, rt<<1|1);
}
void add_query(int p, int l, int r, int rt) {
has_query[rt] = true;
if (l == r) return ;
int mid = (l + r) / 2;
if (p <= mid) add_query(p, l, mid, rt<<1);
else add_query(p, mid+1, r, rt<<1|1);
}
void solve(int l, int r, int rt) {
// printf("%d : [%d, %d] : ", rt, l, r);
// for (int i=0; i<tr[rt].size(); i++) printf("(%d, %d) ", tr[rt][i].first, tr[rt][i].second); puts("");
// solve it
if (!has_query[rt]) return ;
if (rt == 1) d[rt] = (diam){-1, -1, -1};
else d[rt] = d[rt/2];
for (int i=0; i<tr[rt].size(); i++) {
// printf(" now d = %d, (%d, %d), add (%d, %d)\n", d[rt].d, d[rt].u, d[rt].v, tr[rt][i].first, tr[rt][i].second);
if (d[rt].d == -1) {
// no path
d[rt] = (diam){0, tr[rt][i].first, tr[rt][i].second};
} else if (d[rt].d == 0) {
// (u, v) is intersection
pii x = closest_pt(tr[rt][i].first, d[rt].u, d[rt].v);
pii y = closest_pt(tr[rt][i].second, d[rt].u, d[rt].v);
// printf(" x id %d, dis %d\n", x.first, x.second);
// printf(" y id %d, dis %d\n", y.first, y.second);
if (x.first != y.first) {
d[rt] = (diam){0, x.first, y.first};
} else {
pii U = closest_pt(x.first, tr[rt][i].first, tr[rt][i].second);
d[rt] = (diam){U.second, x.first, U.first};
}
} else {
// no intersection, (u, v) is diameter
pii x = closest_pt(tr[rt][i].first, d[rt].u, d[rt].v);
pii y = closest_pt(tr[rt][i].second, d[rt].u, d[rt].v);
if (x.first != y.first) continue;
pii U = closest_pt(x.first, tr[rt][i].first, tr[rt][i].second);
int d1 = dis(U.first, d[rt].u), d2 = dis(U.first, d[rt].v);
if (d[rt].d >= d1 && d[rt].d >= d2) ; // empty
else if (d1 > d2) d[rt] = (diam){d1, U.first, d[rt].u};
else d[rt] = (diam){d2, U.first, d[rt].v};
}
}
// printf("d[%d] = %d, (%d, %d)\n", rt, d[rt].d, d[rt].u, d[rt].v);
if (l == r) {
D[l] = d[rt].d;
return ;
}
int mid = (l + r) / 2;
solve(l, mid, rt<<1);
solve(mid+1, r, rt<<1|1);
}
int main(void) {
//freopen("f.in", "r", stdin);
int n, q; scanf("%d%d", &n, &q);
for (int i=1; i<n; i++) {
int u, v; scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
set <node> Set;
for (int i=1; i<=q; i++) {
int op, x, y; scanf("%d", &op);
if (op == 1 || op == 2) {
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
if (op == 1) {
Set.insert((node){x, y, i});
} else {
set <node>::iterator it = Set.lower_bound((node){x, y, 0});
add(it->id, i-1, mp(it->x, it->y), 1, q, 1);
Set.erase(it);
}
Q[i] = -1;
} else {
scanf("%d", &x);
Q[i] = x;
add_query(i, 1, q, 1);
}
}
for (set<node>::iterator it=Set.begin(); it != Set.end(); ++it) {
add(it->id, q, mp(it->x, it->y), 1, q, 1);
}
dfs(1, 0);
init_lca();
// for (int i=0; i<4; i++) {
// printf("st[%d] : ", i);
// for (int j=1; j<=idx; j++) printf("%d ", st[i][j]); puts("");
// }
solve(1, q, 1);
for (int i=1; i<=q; i++) if (~Q[i]) {
puts((2 * Q[i] >= D[i]) ? "Yes" : "No");
}
return 0;
}
| 6 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string str;
while (cin >> str) {
int J = 0, I = 0;
for (int i = 1; i < str.size() - 1; i++) {
if (str[i] == 'O' && str[i + 1] == 'I') {
if (str[i - 1] == 'J') J++;
if (str[i - 1] == 'I') I++;
}
}
cout << J << endl;
cout << I << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-7;
int main() {
int n;
scanf("%d", &n);
double ans = 0.0;
double e = 1.0;
while (n--) {
double p;
scanf("%lf", &p);
ans += e * p;
e = 1.0 + (e + 1.0) * p;
}
printf("%.6lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k;
for (cin >> t; t-- > 0; cout << n - max(0, n % k - k / 2) << '\n')
cin >> n >> k;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int b, g, n;
cin >> b >> g >> n;
if (b >= n && g >= n) {
cout << n + 1 << endl;
} else if (b < n && g >= n) {
cout << b + 1 << endl;
} else if (b >= n && g < n) {
cout << g + 1 << endl;
} else {
cout << max(b + g - n + 1, 0) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, k, p, q;
bool ok;
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'G') p = i;
if (s[i] == 'T') q = i;
}
if (p > q) {
if ((p - q) % k == 0) {
ok = 0;
while (p != q) {
if (s[p] == '#') ok = 1;
p = p - k;
}
if (ok == 1) {
cout << "NO";
return 0;
} else {
cout << "YES";
return 0;
}
} else {
cout << "NO";
return 0;
}
} else {
if ((q - p) % k == 0) {
ok = 0;
while (p != q) {
if (s[p] == '#') ok = 1;
p = p + k;
}
if (ok == 1) {
cout << "NO";
return 0;
} else {
cout << "YES";
return 0;
}
} else {
cout << "NO";
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string x;
cin >> x;
int len = x.size();
int cnt = 0, ok = 0;
for (int i = 0; i < len - 1; i++) {
if (x[i] == x[i + 1] && x[i] != '?' && x[i + 1] != '?') {
cout << "No" << endl;
return 0;
}
if (x[i] == '?') cnt++;
}
if (x[len - 1] == '?') cnt++;
if (cnt == 0) {
cout << "No" << endl;
return 0;
}
for (int i = 1; i < len - 1; i++) {
set<char> s;
if (x[i] == '?') {
if (x[i - 1] != '?' && x[i + 1] != '?') {
s.insert(x[i - 1]);
s.insert(x[i + 1]);
}
if (s.size() == 2) {
ok++;
}
}
}
if (ok == cnt)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
| 1 |
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm> // require sort next_permutation count __gcd reverse etc.
#include <cstdlib> // require abs exit atof atoi
#include <cstdio> // require scanf printf
#include <functional>
#include <numeric> // require accumulate
#include <cmath> // require fabs
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip> // require setw
#include <sstream> // require stringstream
#include <cstring> // require memset
#include <cctype> // require tolower, toupper
#include <fstream> // require freopen
#include <ctime> // require srand
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main()
{
ios_base::sync_with_stdio(0);
string a = "", b = ""; cin >> a >> b;
bool res = false;
rep (i, a.length() ){
bool match = (i <= a.length() - b.length() );
for (int j = i; j < i+b.length() && j < a.length(); j++ ){
if (a[j] != b[j-i] && b[j-i] != '_' ){
match = false;
break;
} // end if
} // end for
res |= match;
} // end rep
cout << (res ? "Yes" : "No" ) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long n = 0;
const long long mod = 1e9 + 7;
long long tt = 0;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long m) {
if (y == 0) return 1;
if (y == 1) return x;
long long cur = power(x, y / 2, m);
cur = (cur % m * cur % m);
if ((y & 1)) cur = (cur % m * x % m) % m;
return cur;
}
long long modinv(long long x, long long m) { return power(x, m - 2, m) % m; }
void pre_solve() {}
void sol(long long tc) {
cin >> n;
long long arr[n], temp[n];
for (long long i = 0; i < n; i++) cin >> arr[i], temp[i] = arr[i];
sort(temp, temp + n);
long long gcdd = temp[0];
for (long long i = 0; i < n; i++) {
if (temp[i] == arr[i]) continue;
gcdd = gcd(temp[i], gcdd);
}
if (gcdd == temp[0])
cout << "YES\n";
else
cout << "NO\n";
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long tc = 1;
cin >> tc;
while (tc--) {
tt++;
sol(tc);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int flag = 1;
int mx = INT_MIN;
long long index = 0;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
vec[i] = temp;
if (temp > mx) {
mx = temp;
}
}
for (int i = 0; i < n - 1; i++) {
if (vec[i] < mx && vec[i + 1] == mx) {
index = i + 2;
break;
}
}
for (int i = 1; i < n; i++) {
if (vec[i] < mx && vec[i - 1] == mx) {
index = i;
break;
}
}
for (int i = 0; i < n - 1; i++) {
if (vec[i] != vec[i + 1]) {
flag = 0;
break;
}
}
if (flag) {
cout << -1 << endl;
continue;
}
cout << index << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
int n, i;
string a[300], mx1, mx2, pr;
int num = 0;
scanf("%d", &n);
for (i = 0; i < 2 * n - 2; i++) {
cin >> a[i];
if (a[i].size() == n - 1) {
if (mx1.size() == 0)
mx1 = a[i];
else
mx2 = a[i];
}
}
for (i = 0; i < 2 * n - 2; i++) {
if (mx1.substr(0, a[i].size()) == a[i]) num++;
}
if (num >= (2 * n - 2) / 2 && mx1.substr(1, n - 2) == mx2.substr(0, n - 2))
pr = mx1;
else
pr = mx2;
for (i = 0; i < 2 * n - 2; i++) {
if (a[i] == pr.substr(0, a[i].size()) && mp[a[i].size()] == 0) {
printf("P");
mp[a[i].size()] = 1;
} else {
printf("S");
}
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[2510];
long long n, m, k, r, a[2510][2510], u[2510][2510];
long long ss(long long x1, long long x2, long long y1, long long y2) {
return a[x2][y2] - a[x1][y2] - a[x2][y1] + a[x1][y1];
}
void dfs(long long x1, long long x2, long long y1, long long y2, long long t) {
if (x1 == x2 || y1 == y2) return;
if (x1 + 1 == x2 && y1 + 1 == y2) {
if (ss(x1, x2, y1, y2) == k) r++;
return;
}
if (t) {
long long md = (x1 + x2) / 2;
dfs(x1, md, y1, y2, 0);
dfs(md, x2, y1, y2, 0);
for (long long i = y1; i < y2; i++) {
u[0][0] = u[1][0] = md;
for (long long j = 1; j <= k + 1; j++) u[0][j] = x1, u[1][j] = x2;
for (long long j = i + 1; j <= y2; j++) {
for (long long l = 1; l <= k + 1; l++) {
while (ss(u[0][l], md, i, j) >= l) u[0][l]++;
while (ss(md, u[1][l], i, j) >= l) u[1][l]--;
}
for (long long l = 0; l <= k; l++)
r += (u[0][l] - u[0][l + 1]) * (u[1][k - l + 1] - u[1][k - l]);
}
}
} else {
long long md = (y1 + y2) / 2;
dfs(x1, x2, y1, md, 1);
dfs(x1, x2, md, y2, 1);
for (long long i = x1; i < x2; i++) {
u[0][0] = u[1][0] = md;
for (long long j = 1; j <= k + 1; j++) u[0][j] = y1, u[1][j] = y2;
for (long long j = i + 1; j <= x2; j++) {
for (long long l = 1; l <= k + 1; l++) {
while (ss(i, j, u[0][l], md) >= l) u[0][l]++;
while (ss(i, j, md, u[1][l]) >= l) u[1][l]--;
}
for (long long l = 0; l <= k; l++)
r += (u[0][l] - u[0][l + 1]) * (u[1][k - l + 1] - u[1][k - l]);
}
}
}
}
signed main() {
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
cin >> s + 1;
for (long long j = 1; j <= m; j++) {
a[i][j] = s[j] - '0';
a[i][j] = a[i][j] + a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
}
}
dfs(0, n, 0, m, 0);
cout << r;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
;
struct _dbg {
template <class T>
_dbg& operator,(const T& v) {
cerr << v << " ";
return *this;
};
};
_dbg _d;
int a[1000], N, Q;
string r;
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 0, _i = (N); i < _i; ++i)
for (int j = 0, _j = (N); j < _j; ++j) {
int x;
cin >> x;
if (i == j) a[i] = x;
};
auto s = 0;
for (int i = 0, _i = (N); i < _i; ++i) s ^= a[i];
cin >> Q;
for (int i = 0, _i = (Q); i < _i; ++i) {
int t;
cin >> t;
if (t < 3)
cin >> t, s ^= 1;
else if (t == 3)
r += s + '0';
};
cout << r << '\n';
};
| 1 |
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
struct data{
int bit,x,y;
data(){}
data(int bb,int yy,int xx){
bit=bb;
x=xx;
y=yy;
}
bool operator<(const data &d)const{
return bit<d.bit;
}
};
int h,w;
string str[20];
int fie[19][15];
map<data,int> mp;
int bsize=0;
P black[20];
int sx,sy;
int bfs(){
queue<data> que;
que.push(data((1<<bsize)-1,sy,sx));
mp[data((1<<bsize)-1,sy,sx)]=0;
while(que.size()){
data d=que.front();
que.pop();
for(int i=-1;i<=1;i++){
for(int j=-1;j<=1;j++){
if(i==0 && j==0)continue;
for(int k=0;k<bsize;k++){
if(d.bit>>k & 1){
fie[black[k].first][black[k].second]=k+1;
}else{
fie[black[k].first][black[k].second]=0;
}
}
int cnt=0;
int nx=d.x;
int ny=d.y;
int nbit=d.bit;
if(nx+j>=0 && nx+j<w && ny+i>=0 && ny+i<h){
if(fie[ny+i][nx+j]==0)continue;
nx+=j;
ny+=i;
while(nx>=0 && nx<w && ny>=0 && ny<h){
if(fie[ny][nx]==0)break;
nbit-=1<<(fie[ny][nx]-1);
nx+=j;
ny+=i;
}
if(ny>=h || (ny==h-1 && nx>=0 && nx<=w-1)){
return mp[data(d.bit,d.y,d.x)]+1;
}else if(nx>=0 && nx<w && ny>=0 && ny<h){
if(mp.find(data(nbit,ny,nx))==mp.end()){
mp[data(nbit,ny,nx)]=mp[data(d.bit,d.y,d.x)]+1;
que.push(data(nbit,ny,nx));
}
}
}
}
}
}
return -1;
}
int main(void){
h=19;
w=15;
for(int i=0;i<h;i++){
cin >> str[i];
for(int j=0;j<w;j++){
if(str[i][j]=='X'){
black[bsize++]=P(i,j);
}
if(str[i][j]=='O'){
sy=i;
sx=j;
}
}
}
printf("%d\n",bfs());
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
int n;
cin >> s >> n;
map<string, int> M;
for (int i = 0; i < n; ++i) {
string a, b, c, aux;
cin >> a >> b;
if (b == "posted") {
cin >> aux >> c >> aux;
c = c.substr(0, c.size() - 2);
if (c == s) swap(a, c);
if (a == s)
M[c] += 15;
else {
M[a], M[c];
}
} else if (b == "commented") {
cin >> aux >> c >> aux;
c = c.substr(0, c.size() - 2);
if (c == s) swap(a, c);
if (a == s)
M[c] += 10;
else {
M[a], M[c];
}
} else {
cin >> c >> aux;
c = c.substr(0, c.size() - 2);
if (c == s) swap(a, c);
if (a == s)
M[c] += 5;
else {
M[a], M[c];
}
}
}
vector<string> ans;
for (auto v : M) ans.push_back(v.first);
sort(ans.begin(), ans.end(), [&](string a, string b) {
if (M[a] > M[b])
return true;
else if (M[a] < M[b])
return false;
else
return a < b;
});
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
int gi() {
int x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * flag;
}
int a[N], b[N], n, dif[N], tong[N], hh[N], tong2[N], p[N];
bool check() {
for (int i = 1; i <= n; i++) tong2[i] = 0;
for (int i = 1; i <= n; i++) tong2[p[i]]++;
for (int i = 1; i <= n; i++)
if (tong2[p[i]] > 1) return 0;
return 1;
}
int main() {
n = gi();
int cnt = 0, tot = 0;
for (int i = 1; i <= n; i++) {
a[i] = gi();
if (tong[a[i]] == 0) tong[a[i]]++;
}
for (int i = 1; i <= n; i++) {
b[i] = gi();
if (tong[b[i]] == 0) tong[b[i]]++;
}
for (int i = 1; i <= n; i++)
if (a[i] != b[i]) {
dif[++cnt] = i;
}
for (int i = 1; i <= n; i++)
if (tong[i] == 0) hh[++tot] = i;
if (cnt == 1) {
for (int i = 1; i <= n; i++) {
if (i == dif[1])
cout << hh[1] << ' ';
else
cout << a[i] << ' ';
}
}
if (cnt == 2) {
for (int i = 1; i <= n; i++) {
if (i == dif[1])
p[i] = a[i];
else if (i == dif[2])
p[i] = b[i];
else
p[i] = a[i];
}
if (check()) {
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
return 0;
}
for (int i = 1; i <= n; i++) {
if (i == dif[1])
p[i] = b[i];
else if (i == dif[2])
p[i] = a[i];
else
p[i] = a[i];
}
if (check()) {
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1.1e6 + 5;
const int inv2 = 499122177;
int wn[MAXN], wnn[MAXN], fac[MAXN], facn[MAXN], f[MAXN], g[MAXN];
int n, m, k, Inv[MAXN], rev[MAXN], a[MAXN], b[MAXN], e[MAXN], d[MAXN], c[MAXN],
A[MAXN], B[MAXN], D[MAXN], G[MAXN], AA[MAXN], BB[MAXN], AAA[MAXN],
BBB[MAXN], X[MAXN];
const int mod = 998244353;
long long Sc() {
long long ret = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
for (; isdigit(ch); ch = getchar())
ret = ret * 10 + ch - 48, ret = ret >= mod ? ret % mod : ret;
return ret * f;
}
char buf[121], *p1 = buf, *p2 = buf;
inline int getc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 121, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int ret = 0, f = 0;
char ch = getc();
while (!isdigit(ch)) {
if (ch == '-') f = 1;
ch = getc();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - 48;
ch = getc();
}
return f ? -ret : ret;
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
int mul(int a, int b) { return 1ll * a * b % mod; }
int dec(int a, int b) { return a >= b ? a - b : a + mod - b; }
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
long long qkpow(long long a, long long b, long long mod) {
long long ans = 1, base = a;
while (b) {
if (b & 1) ans = mul(ans, base);
base = mul(base, base);
b >>= 1;
}
return ans;
}
void init() {
Inv[1] = 1;
for (int i = 2; i < MAXN; i++)
Inv[i] = 1ll * (mod - mod / i) * Inv[mod % i] % mod;
for (int i = 1; i < MAXN; i <<= 1)
wn[i] = qkpow(3ll, (mod - 1) / (i << 1), mod),
wnn[i] = qkpow(wn[i], mod - 2, mod);
}
void NTT(int *a, int type, int n) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int mid = 1; mid < n; mid <<= 1) {
int Wn = wn[mid];
if (type == -1) Wn = wnn[mid];
for (int R = mid << 1, j = 0; j < n; j += R) {
int w = 1;
for (int k = 0; k < mid; k++, w = mul(w, Wn)) {
int x = a[j + k], y = mul(w, a[j + mid + k]);
a[j + k] = add(x, y);
a[j + mid + k] = dec(x, y);
}
}
}
if (type == -1)
for (int i = 0; i < n; i++) a[i] = mul(a[i], Inv[n]);
}
void Polyinv(int *a, int *b, int len) {
if (len == 1) {
b[0] = qkpow(a[0], mod - 2, mod);
return;
}
Polyinv(a, b, (len + 1) >> 1);
int l = 0, m = (len << 1), n = 1;
for (; n <= m; n <<= 1, l++)
;
for (int i = 0; i < n; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
for (int i = 0; i < len; i++) c[i] = a[i];
for (int i = len; i < n; i++) c[i] = 0;
NTT(c, 1, n), NTT(b, 1, n);
for (int i = 0; i < n; i++) b[i] = mul(dec(2, mul(c[i], b[i])), b[i]);
NTT(b, -1, n);
for (int i = len; i < n; i++) b[i] = 0;
}
void Polydao(int *Aa, int *Bb, int len) {
Bb[len - 1] = 0;
for (int i = 1; i < len; i++) Bb[i - 1] = mul(i, Aa[i]);
}
void Polyjifen(int *Aa, int *Bb, int len) {
Bb[0] = 0;
for (int i = 1; i < len; i++) Bb[i] = mul(Inv[i], Aa[i - 1]);
}
void PolyIn(int *f, int *g, int n) {
static int A[MAXN], B[MAXN];
int l = 0, M = 2 * n, N = 1;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < N; i++) A[i] = B[i] = 0;
Polydao(f, A, n);
Polyinv(f, B, n);
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(A, 1, N), NTT(B, 1, N);
for (int i = 0; i < N; i++) A[i] = mul(A[i], B[i]);
NTT(A, -1, N);
Polyjifen(A, g, n);
}
void PolyExp(int *f, int *g, int n) {
if (n == 1) {
g[0] = 1;
return;
}
PolyExp(f, g, (n + 1) >> 1);
PolyIn(g, d, n);
int M = (n << 1), N = 1, l = 0;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
for (int i = 0; i < n; i++) d[i] = dec(f[i], d[i]);
for (int i = n; i < N; i++) d[i] = g[i] = 0;
d[0]++;
NTT(d, 1, N), NTT(g, 1, N);
for (int i = 0; i < N; i++) g[i] = mul(g[i], d[i]);
NTT(g, -1, N);
for (int i = n; i < N; i++) g[i] = 0;
}
void Polyqkpow(int *F, int *G, int k, int n) {
for (int i = 0; i < n; i++) D[i] = G[i] = 0;
PolyIn(F, D, n);
for (int i = 0; i < n; i++) D[i] = mul(D[i], k);
PolyExp(D, G, n);
}
void Polysqrt(int *f, int *g, int n) {
if (n == 1) {
g[0] = qkpow(f[0], mod - 2, mod);
return;
}
Polysqrt(f, g, (n + 1) >> 1);
int M = 2 * n, N = 1, l = 0;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
for (int i = 0; i < n; i++) A[i] = f[i], B[i] = 0;
for (int i = n; i < N; i++) A[i] = 0, B[i] = 0;
Polyinv(g, B, n);
NTT(A, 1, N), NTT(B, 1, N);
for (int i = 0; i < N; i++) A[i] = mul(A[i], B[i]);
NTT(A, -1, N);
for (int i = 0; i < n; i++) g[i] = mul(add(g[i], A[i]), inv2);
}
void Polysin(int *f, int *g, int n) {
int ecsy = 86583718, fuecsy = 911660635, iinv = qkpow(ecsy, mod - 2, mod);
for (int i = 0; i < n; i++) A[i] = mul(f[i], ecsy), B[i] = mul(f[i], fuecsy);
PolyExp(A, AAA, n), PolyExp(B, BBB, n);
for (int i = 0; i < n; i++) g[i] = mul(mul(dec(AAA[i], BBB[i]), inv2), iinv);
}
void Polycos(int *f, int *g, int n) {
int ecsy = 86583718, fuecsy = 911660635;
for (int i = 0; i < n; i++) A[i] = mul(f[i], ecsy), B[i] = mul(f[i], fuecsy);
PolyExp(A, AAA, n), PolyExp(B, BBB, n);
for (int i = 0; i < n; i++) g[i] = mul(add(AAA[i], BBB[i]), inv2);
}
void Polyasin(int *f, int *g, int n) {
static int fbie[MAXN], FF[MAXN], A[MAXN], B[MAXN], Fs[MAXN], Finv[MAXN];
for (int i = 0; i < (n << 1); i++)
fbie[i] = FF[i] = A[i] = B[i] = Fs[i] = Finv[i] = 0;
Polydao(f, fbie, n);
int M = (n << 1), N = 1, l = 0;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < n; i++) A[i] = B[i] = f[i];
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(A, 1, N), NTT(B, 1, N);
for (int i = 0; i < N; i++) FF[i] = mul(A[i], B[i]);
NTT(FF, -1, N);
for (int i = 0; i < n; i++) FF[i] = dec(i == 0 ? 1 : 0, FF[i]);
for (int i = n; i < N; i++) FF[i] = 0;
Polysqrt(FF, Fs, n);
Polyinv(Fs, Finv, n);
M = (n << 1), N = 1, l = 0;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(fbie, 1, N), NTT(Finv, 1, N);
for (int i = 0; i < N; i++) fbie[i] = mul(fbie[i], Finv[i]);
NTT(fbie, -1, N);
Polyjifen(fbie, g, n);
}
void Polyatan(int *f, int *g, int n) {
static int fbie[MAXN], FF[MAXN], A[MAXN], B[MAXN], Finv[MAXN];
for (int i = 0; i < (n << 1); i++)
fbie[i] = FF[i] = A[i] = B[i] = Finv[i] = 0;
Polydao(f, fbie, n);
int M = (n << 1), N = 1, l = 0;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < n; i++) A[i] = B[i] = f[i];
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(A, 1, N), NTT(B, 1, N);
for (int i = 0; i < N; i++) FF[i] = mul(A[i], B[i]);
NTT(FF, -1, N);
for (int i = 0; i < n; i++) FF[i] = add(i == 0 ? 1 : 0, FF[i]);
for (int i = n; i < N; i++) FF[i] = 0;
Polyinv(FF, Finv, n);
M = (n << 1), N = 1, l = 0;
for (; N <= M; N <<= 1, l++)
;
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(fbie, 1, N), NTT(Finv, 1, N);
for (int i = 0; i < N; i++) fbie[i] = mul(fbie[i], Finv[i]);
NTT(fbie, -1, N);
Polyjifen(fbie, g, n);
}
void mul(int *s, int *a, int len) {
static int t[MAXN];
__builtin_memcpy(t, a, sizeof(int) * len);
NTT(s, 1, len), NTT(t, 1, len);
for (int i = 0; i < len; i++) s[i] = mul(s[i], t[i]);
NTT(s, -1, len);
for (int i = 0; i < len; i++) s[i] = !!s[i];
}
int main() {
init();
scanf("%d %d %d", &n, &m, &k);
fac[0] = facn[0] = 1;
for (int i = 1; i < k + 1; i++)
fac[i] = mul(fac[i - 1], i), facn[i] = qkpow(fac[i], mod - 2, mod);
for (int i = 0; i < k + 1; i++)
f[i] = mul(qkpow(mod - 1, i, mod), facn[i]),
g[i] = mul(qkpow(i, k, mod), facn[i]);
int l = 0, M, N = 1;
for (M = 2 * (k + 1); N <= M; N <<= 1, l++)
;
for (int i = 0; i < N; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
NTT(f, 1, N), NTT(g, 1, N);
for (int i = 0; i < N; i++) f[i] = mul(f[i], g[i]);
NTT(f, -1, N);
long long now = 1, ans = 0;
for (int j = 0; j <= min(k, n); j++) {
ans = add(ans, mul(mul(mul(f[j], fac[j]), now), qkpow(m, n - j, mod)));
now = mul(now, n - j), now = mul(now, qkpow(j + 1, mod - 2, mod));
}
printf("%d", mul(ans, qkpow(qkpow(m, n, mod), mod - 2, mod)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[1005][1005], s1[1005][1005], s2[1005][1005], s3[1005][1005],
s4[1005][1005];
vector<pair<long long, pair<long long, long long> > > res;
bool fre[1005][1005];
void trace(long long u, long long v, long long k) {
fre[u][v] = true;
for (int i = 1; i <= k; i++) fre[u - i][v] = true;
for (int i = 1; i <= k; i++) fre[u + i][v] = true;
for (int i = 1; i <= k; i++) fre[u][v - i] = true;
for (int i = 1; i <= k; i++) fre[u][v + i] = true;
}
void check(long long u, long long v) {
long long U = min(s1[u][v], s2[u][v]);
long long V = min(s3[u][v], s4[u][v]);
long long k = min(U, V) - 1;
if (k == 0) return;
k = min(k, min(n, m));
res.push_back(pair<long long, pair<long long, long long> >(
k, pair<long long, long long>(u, v)));
trace(u, v, k);
}
int main() {
memset(s1, 0, sizeof s1);
memset(s2, 0, sizeof s2);
memset(s3, 0, sizeof s3);
memset(s4, 0, sizeof s4);
bool bo = false;
memset(fre, false, sizeof fre);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
char c;
for (int j = 1; j <= m; j++) {
cin >> c;
if (c == '.')
a[i][j] = 0, fre[i][j] = true;
else
a[i][j] = 1, bo = true;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] == 0)
s1[i][j] = 0;
else
s1[i][j] = s1[i][j - 1] + 1;
for (int i = 1; i <= n; i++)
for (int j = m; j >= 1; j--)
if (a[i][j] == 0)
s2[i][j] = 0;
else
s2[i][j] = s2[i][j + 1] + 1;
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++)
if (a[i][j] == 0)
s3[i][j] = 0;
else
s3[i][j] = s3[i - 1][j] + 1;
for (int j = 1; j <= m; j++)
for (int i = n; i >= 1; i--)
if (a[i][j] == 0)
s4[i][j] = 0;
else
s4[i][j] = s4[i + 1][j] + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] == 1) check(i, j);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (fre[i][j] == false && a[i][j] != 0) {
cout << "-1";
return 0;
}
cout << res.size() << "\n";
for (int i = 0; i < res.size(); i++) {
cout << res[i].second.first << " " << res[i].second.second << " "
<< res[i].first << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
void init() {}
void input() { cin >> s; }
void solve() {
long long res = 1;
int use = 10;
bool used[10];
for (int i = (0); i < (10); i++) used[i] = false;
int zero = 0;
if (s[0] == '?') res *= 9;
if ('A' <= s[0] && s[0] <= 'J') res *= 9, use--, used[s[0] - 'A'] = true;
for (int i = (1); i < (((int)s.size())); i++) {
if (s[i] == '?') zero++;
if ('A' <= s[i] && s[i] <= 'J') {
if (!used[s[i] - 'A']) {
res *= use--;
used[s[i] - 'A'] = true;
}
}
}
cout << res;
for (int i = (0); i < (zero); i++) cout << '0';
cout << endl;
}
int main() {
init();
input();
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
vector<int> g[1111];
int dp[1111], o, p, a[1111], cn;
bool w[1111], ok;
vector<int> q;
void dfs(int v) {
w[v] = 1;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int to = g[v][i];
if (!w[to]) dfs(to);
}
q.push_back(v);
}
void dfs2(int v) {
w[v] = 1;
p++;
if (v == k) cn = p, ok = 1;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int to = g[v][i];
if (!w[to]) dfs2(to);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x) g[x].push_back(i);
}
for (int i = 1; i <= n; i++)
if (!w[i]) {
dfs(i);
}
memset(w, 0, sizeof(w));
for (int i = n - 1; i >= 0; i--) {
if (!w[q[i]]) {
ok = p = 0;
dfs2(q[i]);
if (!ok) a[++o] = p;
}
}
dp[0] = 1;
for (int i = 1; i <= o; i++)
for (int j = 1000; j >= a[i]; j--) dp[j] |= dp[j - a[i]];
for (int i = 0; i <= 1000; i++)
if (dp[i]) cout << i + cn << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int faces[1+6];
for(int i = 1; i <= 6; i++){
cin >> faces[i];
}
int f, tmp;
char direction;
while(cin >> direction){
switch(direction){
case 'N':
f = 5;
break;
case 'E':
f = 3;
break;
case 'S':
f = 2;
break;
case 'W':
f = 4;
break;
}
tmp = faces[f];
faces[f] = faces[1];
faces[1] = faces[7-f];
faces[7-f] = faces[6];
faces[6] = tmp;
}
cout << faces[1] << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> s;
string o = "halfplus";
int n, p;
cin >> n >> p;
for (int i = 0; i < n; i++) {
string y;
cin >> y;
s.push_back(y);
}
reverse(s.begin(), s.end());
long long ans = 0, r = 0;
for (int i = 0; i < s.size(); i++) {
ans *= 2LL;
if (s[i] == o) ans++, r++;
}
cout << 1LL * ans * p - 1LL * r * (p / 2LL) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const int MAX_N = 100011;
const long long INF = (1 << 29) + 123;
const long long MOD = 998244353;
const long double PI = 4 * atan((long double)1);
template <typename T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << H << " ";
dbg_out(T...);
}
template <typename T>
class SafeVector : public vector<T> {
public:
using vector<T>::vector;
typename vector<T>::reference operator[](size_t n) {
return vector<T>::at(n);
}
typename vector<T>::const_reference operator[](size_t n) const {
return vector<T>::at(n);
}
};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MX = 2e5 + 5;
long long a[MX][3];
vector<long long> x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) cin >> a[i][j];
for (int i = 0; i < n; i++) x.push_back(a[i][0]);
long long dp[n];
for (int i = 0; i < n; i++) dp[i] = 0;
long long pref[n + 1];
for (int i = 0; i < n + 1; i++) pref[i] = 0;
dp[0] = a[0][0] - a[0][1];
pref[1] = dp[0];
for (int i = 1; i <= n - 1; i++) {
int idx = lower_bound(x.begin(), x.end(), a[i][1]) - x.begin();
dp[i] = ((pref[i] - pref[idx]) % MOD + MOD + a[i][0] - a[i][1]) % MOD;
pref[i + 1] = (pref[i] + dp[i]) % MOD;
}
long long ans = 0;
for (int i = 0; i < n; i++) ans = ((a[i][2] * dp[i]) % MOD + ans) % MOD;
cout << (ans + x[n - 1] + 1) % MOD << nl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
while ((a = a % b) != 0) {
swap(a, b);
}
return b;
}
long long modpow(long long x, int y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x % 1000000007;
y = y >> 1;
x = x * x % 1000000007;
}
return res;
}
long long ncr(int n, int r) {
long long f1 = 1, f2 = 1;
for (int i = (n - r + 1); i < (n + 1); i++) f1 = f1 * i % 998244353;
for (int i = (1); i < (r + 1); i++) f2 = f2 * i % 998244353;
return f1 * modpow(f2, 998244353 - 2) % 998244353;
}
int *sieve(int n) {
int *lpf = new int[n + 1];
for (int i = 1; i <= n; i++) lpf[i] = i;
int rt = (int)floor(sqrt(n)) + 1;
for (int i = (2); i < (rt); i++) {
if (lpf[i] != i) continue;
for (int j = i * i; j <= n; j += i) {
if (lpf[j] == j) lpf[j] = i;
}
}
return lpf;
}
void solve() {
int n, m;
cin >> n >> m;
char a[n][m];
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) cin >> a[i][j];
}
pair<int, int> cord[26][2];
for (int i = (0); i < (26); i++) cord[i][0] = cord[i][1] = make_pair(-1, -1);
int cnt = 0;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (a[i][j] == '.') continue;
cnt = max(cnt, a[i][j] - 'a' + 1);
if (cord[a[i][j] - 'a'][0] == make_pair(-1, -1))
cord[a[i][j] - 'a'][0] = make_pair(i, j);
cord[a[i][j] - 'a'][1] = make_pair(i, j);
}
}
char test[n][m];
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) test[i][j] = '.';
}
for (int i = (0); i < (cnt); i++) {
if (cord[i][0] == make_pair(-1, -1)) {
cord[i][0] = cord[i][1] = cord[cnt - 1][0];
continue;
}
if (cord[i][0].first == cord[i][1].first) {
for (int j = (cord[i][0].second); j < (cord[i][1].second + 1); j++)
test[cord[i][0].first][j] = 'a' + i;
} else if (cord[i][0].second == cord[i][1].second) {
for (int j = (cord[i][0].first); j < (cord[i][1].first + 1); j++)
test[j][cord[i][0].second] = 'a' + i;
} else {
cout << "NO\n";
return;
}
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (a[i][j] != test[i][j]) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n" << cnt << "\n";
for (int i = (0); i < (cnt); i++)
cout << cord[i][0].first + 1 << " " << cord[i][0].second + 1 << " "
<< cord[i][1].first + 1 << " " << cord[i][1].second + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
for (int i = (1); i < (t + 1); i++) {
solve();
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;
#define eps (1e-10)
struct Point{
double x,y;
Point(){}
Point(double x,double y):x(x),y(y){}
Point operator+(Point p) {return Point(x+p.x,y+p.y);}
Point operator-(Point p) {return Point(x-p.x,y-p.y);}
Point operator*(double k){return Point(x*k,y*k);}
double norm(){return x*x+y*y;}
double abs(){return sqrt(norm());}
bool operator == (const Point &p) const{
return fabs(x-p.x)<eps && fabs(y-p.y)<eps;
}
double dot(Point p){return x*p.x+y*p.y;}
double det(Point p){return x*p.y-y*p.x;}
};
int ccw(Point a,Point b,Point c){
Point t1=b-a,t2=c-a;
if(t1.det(t2)> eps) return 1;//counter clockwise
if(t1.det(t2)< -eps) return -1;//clockwise
if(t1.dot(t2)< -eps) return 2;//c-a-b online
if(t1.norm()<t2.norm()) return -2;//a-b-c online
return 0;//a-c-b online
}
Point a[101];
int main(){
int n;
cin>>n;
double x,y;
rep(i,n){
cin>>x>>y;
a[i]=Point(x,y);
}
bool flag=true;
rep(i,n){
if(ccw(a[(i+1)%n],a[i],a[(i+2)%n])==1) flag=false;
}
cout<<flag<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-8;
int main() {
istream &fin = cin;
ostream &fout = cout;
FILE *fpin = stdin;
FILE *fpout = stdout;
int N, K;
fin >> N >> K;
string P, occ;
fin >> P >> occ;
bool ok = true;
string res(N, ' ');
for (int i = 0; i < (int)occ.size(); i++) {
if (occ[i] == '0') continue;
for (int j = 0; j < (int)P.size(); j++) {
if (res[i + j] != ' ' && res[i + j] != P[j]) {
ok = false;
break;
}
res[i + j] = P[j];
}
if (!ok) break;
}
set<char> stc;
for (int i = 0; i < (int)P.size(); i++) {
stc.insert(P[i]);
}
char fill;
if ((int)stc.size() > 1)
fill = P[0];
else {
if (*stc.begin() == 'a')
fill = 'b';
else
fill = 'a';
}
for (int i = 0; i < N; i++) {
if (res[i] == ' ') res[i] = fill;
}
for (int i = 0; i < (int)occ.size(); i++) {
if (occ[i] == '1') continue;
if (res.substr(i, P.size()) == P) {
ok = false;
break;
}
}
if (!ok)
fout << "No solution\n";
else
fout << res << "\n";
}
| 4 |
#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<complex>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
typedef pair<double,ll> pdl;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;
int main(){
ll n;
cin>>n;
vector<ll> A(n);
for(auto &i:A){cin>>i;}
vector<ll> dp(n,0);
stack<pll> S;
for(int i=1;i<n;i++){
dp[i]=dp[i-1];
ll k=A[i-1];
while(k<A[i]){
k*=4;
if(S.empty()){
dp[i]+=i*2;
}
else{
pll w=S.top(); S.pop();
dp[i]+=(i-w.F)*2;
w.S--;
if(w.S>0){S.push(w);}
}
}
ll count=0;
ll b=A[i];
while(k>=b){count++; b*=4;}
if(count>1){S.push({i,count-1});}
}
reverse(A.begin(),A.end());
while(!S.empty()){S.pop();}
vector<ll> dp2(n,0);
for(int i=1;i<n;i++){
dp2[i]=dp2[i-1];
ll k=A[i-1];
while(k<A[i]){
k*=4;
if(S.empty()){
dp2[i]+=i*2;
}
else{
pll w=S.top(); S.pop();
dp2[i]+=(i-w.F)*2;
w.S--;
if(w.S>0){S.push(w);}
}
}
ll count=0;
ll b=A[i];
while(k>=b){count++; b*=4;}
if(count>1){S.push({i,count-1});}
}
reverse(dp2.begin(),dp2.end());
ll ans=E;
for(int i=0;i+1<n;i++){
ans=min(ans,dp[i]+dp2[i+1]+i+1);
}
ans=min(ans,dp2[0]);
ans=min(ans,dp[n-1]+n);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long DP[11][65][1 << 10][2];
int a[65], len;
long long getdp(int base, int i, int mask, int zero, int eq) {
if (i == 0) return !mask && !zero;
if (!eq && ~DP[base][i][mask][zero]) return DP[base][i][mask][zero];
long long ret = 0;
int up = (eq ? a[i] : base - 1);
for (int d = 0; d <= up; ++d) {
if (zero && d == 0) {
ret += getdp(base, i - 1, mask, 1, eq && d == up);
} else {
ret += getdp(base, i - 1, mask ^ (1 << d), 0, eq && d == up);
}
}
if (!eq) DP[base][i][mask][zero] = ret;
return ret;
}
long long solve(long long num, int base) {
len = 0;
while (num) {
a[++len] = num % base;
num /= base;
}
return getdp(base, len, 0, 1, 1);
}
int main() {
int Q;
scanf("%d", &Q);
memset(DP, -1, sizeof(DP));
while (Q--) {
int b;
long long l, r;
scanf("%d %lld %lld", &b, &l, &r);
printf("%lld\n", solve(r, b) - solve(l - 1, b));
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int delta = (int)1e9 + 7;
int x, y, z, ans;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lca(int a, int b) { return (a * b) / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> x >> y >> z;
x = lca(x, y);
for (int i = 1; i <= z; ++i)
if (i % x == 0) ++ans;
cout << ans;
return cout << endl, 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long n;
long long t1(0), t2(0);
long long mn = 0, mx = 0;
cin >> n;
vector<long> vec(n, 0);
for (long i = 0; i < n; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
mn = vec[0];
mx = vec[n - 1];
for (long i = 0; i < vec.size(); i++) {
t1 += (vec[i] == mn);
t2 += (vec[i] == mx);
}
cout << mx - mn << " ";
if (mx - mn == 0)
cout << n * (n - 1) / 2 << endl;
else
cout << t1 * t2 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<int> arr(2 * n + 1);
int cur = 1;
for (int i = 1; i < n; i += 2, cur++) {
int pos = n - i + cur;
arr[cur] = arr[pos] = i;
}
cur = n + 1;
for (int i = 2; i < n; i += 2, cur++) {
int pos = n - i + cur;
arr[cur] = arr[pos] = i;
}
for (int i = 1; i < arr.size(); ++i) {
if (arr[i] == 0) arr[i] = n;
}
for (int i = 1; i < arr.size(); ++i) {
cout << arr[i] << ' ';
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll a, b, c;
vector<pair<double, double>> gen(ll x, ll y) {
vector<pair<double, double>> p;
p.push_back({x, double(-c - a * x) / b});
p.push_back({double(-c - b * y) / a, y});
return p;
}
double dst(double xa, double ya, double xb, double yb) {
double dx = xa - xb;
double dy = ya - yb;
return sqrt(dx * dx + dy * dy);
}
int main() {
ios::sync_with_stdio(false);
ll x1, y1, x2, y2;
cin >> a >> b >> c >> x1 >> y1 >> x2 >> y2;
double ans = llabs(x1 - x2) + llabs(y1 - y2);
for (auto pa : gen(x1, y1)) {
for (auto pb : gen(x2, y2)) {
double sub = dst(x1, y1, pa.first, pa.second) +
dst(pa.first, pa.second, pb.first, pb.second) +
dst(pb.first, pb.second, x2, y2);
ans = min(ans, sub);
}
}
cout << fixed << setprecision(10) << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool vis[10][10][10];
char grid[10][10][10];
struct Point {
int x, y, step;
friend bool operator<(const Point a, const Point b) {
return a.step > b.step;
}
} p, newp, sta, des;
priority_queue<Point> q;
int dx[8] = {0, 0, 1, -1, 1, -1, -1, 1};
int dy[8] = {1, -1, 0, 0, 1, 1, -1, -1};
bool can_move(Point p) {
return p.x >= 1 && p.x <= 8 && p.y >= 1 && p.y <= 8 &&
grid[p.x][p.y][min(p.step, 8)] != 'S' &&
grid[p.x][p.y][min(p.step + 1, 8)] != 'S';
}
bool bfs() {
sta.step = 0;
q.push(sta);
while (!q.empty()) {
p = q.top();
q.pop();
if (p.x == des.x && p.y == des.y) return true;
if (vis[p.x][p.y][min(p.step, 8)]) continue;
vis[p.x][p.y][min(p.step, 8)] = true;
for (int i = 0; i < 8; i++) {
newp = p;
newp.x += dx[i];
newp.y += dy[i];
if (can_move(newp)) {
newp.step += 1;
if (!vis[newp.x][newp.y][min(newp.step, 8)]) {
q.push(newp);
}
}
}
newp = p;
if (can_move(newp)) {
newp.step += 1;
if (!vis[newp.x][newp.y][newp.step]) {
q.push(newp);
}
}
}
return false;
}
int main() {
for (int i = 1; i <= 8; i++) {
for (int j = 1; j <= 8; j++) {
scanf(" %c", &grid[i][j][0]);
if (grid[i][j][0] == 'M')
sta.x = i, sta.y = j;
else if (grid[i][j][0] == 'A')
des.x = i, des.y = j;
}
}
for (int k = 1; k <= 8; k++) {
for (int i = 8; i >= 1; i--) {
for (int j = 1; j <= 8; j++) {
grid[i][j][k] = grid[i][j][k - 1];
}
}
for (int i = 8; i >= 1; i--) {
for (int j = 1; j <= 8; j++) {
if (grid[i][j][k] == 'S') grid[i][j][k] = '.';
if (i != 1 && grid[i - 1][j][k] == 'S') grid[i][j][k] = 'S';
}
}
}
if (bfs())
printf("WIN\n");
else
printf("LOSE\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int overall = 0, n, m, visited[300009];
vector<int> adj[300009];
set<pair<int, int> > s;
int c[4];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
s.insert({u, v});
s.insert({v, u});
adj[u].push_back(v);
adj[v].push_back(u);
}
visited[1] = 1;
int flag = 0;
for (int i = 2; i <= n; i++) {
if (s.find({1, i}) == s.end()) {
visited[i] = 1;
} else if (!flag) {
flag = i;
visited[i] = 2;
}
}
int flag2 = 0;
for (int j = 1; j <= n; j++) {
if (j == flag) continue;
if (s.find({flag, j}) == s.end()) {
if (visited[j] == 1) {
cout << "-1";
return 0;
}
visited[j] = 2;
} else if (visited[j] != 1 && !flag2) {
flag2 = j;
visited[j] = 3;
}
}
if (!flag2) {
cout << "-1";
return 0;
}
for (int j = 1; j <= n; j++) {
if (j == flag2) continue;
if (s.find({flag2, j}) == s.end()) {
if (visited[j] == 1 || visited[j] == 2) {
cout << "-1";
return 0;
}
visited[j] = 3;
} else {
if (!visited[j]) {
cout << "-1";
return 0;
}
}
}
for (int i = 1; i <= n; i++) {
if (visited[i] == 1)
c[1]++;
else if (visited[i] == 2)
c[2]++;
else
c[3]++;
}
for (int i = 1; i <= n; i++) {
int cc[4] = {0};
for (int j = 0; j < adj[i].size(); j++) {
cc[visited[adj[i][j]]]++;
}
if (cc[visited[i]]) {
cout << "-1";
return 0;
}
for (int j = 1; j <= 3; j++) {
if (j != visited[i]) {
if (cc[j] != c[j]) {
cout << "-1";
return 0;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << visited[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int M = 25;
const int N = 1e5 + 20;
int n, q, tot, cnt;
int a[N], lg[N], ans[N];
struct node {
int l, x, id;
bool operator<(const node& a) const {
if (l != a.l) return l < a.l;
return x < a.x;
}
} b[N];
int xxj[M + 5];
void getxxj(int x) {
for (int i = M; i >= 0; i--) {
if (x & (1 << i)) {
if (xxj[i])
x ^= xxj[i];
else {
xxj[i] = x;
tot++;
break;
}
}
}
}
bool check(int x) {
for (int i = M; i >= 0; i--) {
if (x & (1 << i)) {
if (xxj[i])
x ^= xxj[i];
else
return 0;
}
}
return 1;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &b[i].l, &b[i].x);
b[i].id = i;
}
lg[0] = 1;
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] * 2 % mod;
sort(b + 1, b + q + 1);
for (int i = 1; i <= q; i++) {
while (cnt < b[i].l) getxxj(a[++cnt]);
if (check(b[i].x)) ans[b[i].id] = lg[cnt - tot];
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
void solve() {
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A[i];
cin >> M;
vector<int> B(M);
for (int i = 0; i < M; i++) cin >> B[i];
sort(A.begin(), A.end());
sort(B.begin(), B.end());
int sA = N * 3;
int sB = M * 3;
int maxdiff = sA - sB;
int maxA = sA;
int maxB = sB;
for (int i = 0; i < M; i++) {
int sz = upper_bound(A.begin(), A.end(), B[i]) - A.begin();
int scA = sz * 2 + (A.size() - sz) * 3;
int scB = (i + 1) * 2 + (M - i - 1) * 3;
if (scA - scB > maxdiff) {
maxdiff = scA - scB;
maxA = scA, maxB = scB;
} else if (scA - scB == maxdiff) {
if (scA > maxA) maxA = scA, maxB = scB;
}
}
cout << maxA << ":" << maxB << endl;
return;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MODULO = 1000000007;
void ftime() {}
void print_arr(int n, bool arr[]) {
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
void print_arr(int n, int arr[]) {
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
void print_vec(vector<int> &vec) {
for (auto e : vec) {
cout << e << " ";
}
cout << "\n";
}
void print_vec(vector<long long> &vec) {
for (auto e : vec) {
cout << e << " ";
}
cout << "\n";
}
void print_vec(vector<bool> &vec) {
for (auto e : vec) {
cout << e << " ";
}
cout << "\n";
}
static int speed_increase = []() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
return 0;
}();
void print_map(unordered_map<long long, long long> &comp) {
for (auto e : comp) {
cout << e.first << " : " << e.second << "\n";
}
cout << "\n";
}
vector<long long> fdp(1000, -1);
long long fact(long long val) {
if (fdp[val] > 0) {
return fdp[val];
}
if (val < 2) return 1;
fdp[val] = (val * fact(val - 1)) % MODULO;
return fdp[val];
}
long long modexp(long long base, long long exponent) {
long long res = 1;
base = (base % MODULO + MODULO) % MODULO;
while (exponent) {
if (exponent & 1) res = (res * base) % MODULO;
exponent >>= 1;
base = (base * base) % MODULO;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<long long> vals(m + 1, 0);
vector<long long> lights(m, 0);
for (auto &x : lights) {
cin >> x;
}
sort(lights.begin(), lights.end());
int last = 0;
int curr;
for (int i = 0; i < m; i++) {
curr = lights[i];
vals[i] = curr - last - 1;
last = curr;
}
vals[m] = n - last;
long long sum = accumulate(vals.begin(), vals.end(), 0ll);
long long ans = fact(sum) % MODULO;
for (int i = 0; i < m + 1; i++) {
if (vals[i] > 1) {
ans *= modexp(fact(vals[i]), MODULO - 2);
ans %= MODULO;
}
if (i != 0 && i != m && vals[i] > 1) {
ans *= modexp(2, vals[i] - 1);
ans %= MODULO;
}
}
cout << ans;
ftime();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, f = 0;
cin >> n;
for (int i = 0; i < n; i++) {
f = 0;
string s, t;
cin >> s >> t;
for (int j = 0; j < s.size(); j++)
for (int h = 0; h < s.size(); h++)
if (s[h] == t[j]) f = 99;
if (f == 99)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <queue>
#include <set>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
template<typename V> class segtree{
private:
int n,sz; vector<V> node, lazy;
public:
segtree(vector<V>& v){
sz = (int)v.size(); n = 1;
while(n < sz) n *= 2;
node.resize(2*n-1); lazy.resize(2*n-1, 0);
rep(i,sz) node[i+n-1] = v[i];
for(int i=n-2; i>=0; i--) node[i] = min(node[i*2+1],node[i*2+2]);
}
void eval(int k, int l, int r){
if(lazy[k] != 0) {
node[k] += lazy[k];
if(r - l > 1) {
lazy[2*k+1] += lazy[k]; lazy[2*k+2] += lazy[k];
}
lazy[k] = 0;
}
}
void range(int a, int b, V x, int k=0, int l=0, int r=-1){
if(r < 0) r = n;
eval(k, l, r);
if(b <= l || r <= a) return;
if(a <= l && r <= b){
lazy[k] += x; eval(k, l, r);
}else{
range(a, b, x, 2*k+1, l, (l+r)/2); range(a, b, x, 2*k+2, (l+r)/2, r);
node[k] = min(node[2*k+1],node[2*k+2]);
}
}
V query(int a, int b, int k=0, int l=0, int r=-1){
if(r < 0) r = n;
eval(k, l, r);
if(b <= l || r <= a) return numeric_limits<V>::max();
if(a <= l && r <= b) return node[k];
V vl = query(a, b, 2*k+1, l, (l+r)/2), vr = query(a, b, 2*k+2, (l+r)/2, r);
return min(vl,vr);
}
void print(){rep(i,sz)cout<<query(i,i+1)<< " ";cout<<endl;}
};
int main(){
int n,m;
cin >> n >> m;
string s;
cin >> s;
vector<int> v(n);
set<int>st;
for(int i=0;i<n;i++){
if(s[i]=='('){
v[i]=1;
}else{
v[i] = -1;
st.insert(i);
}
}
for(int i=1;i<n;i++){
v[i] += v[i-1];
}
segtree<int> sg(v);
for(int i=0;i<m;i++){
int a;
cin >> a;
a--;
if(s[a]=='('){
s[a] = ')';
sg.range(a,n,-2);
st.insert(a);
int x = *st.begin();
cout << x+1 << endl;
s[x] = '(';
sg.range(x,n,2);
st.erase(st.begin());
}else{
s[a] = '(';
st.erase(a);
sg.range(a,n,2);
int ok = n-1,ng =-1;
while(abs(ok-ng)!=1){
int mid = (ok+ng)/2;
if(sg.query(mid,n)>=2){
ok = mid;
}else{
ng = mid;
}
}
sg.range(ok,n,-2);
s[ok] = ')';
st.insert(ok);
cout << ok+1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[50000];
long long cnt = 0;
long long how(int ind, int level) {
if (level > n) return 0;
long long ch1 = how(2 * ind, level + 1);
long long ch2 = how(2 * ind + 1, level + 1);
cnt += abs(ch1 - ch2);
a[ind] += max(ch1, ch2);
return a[ind];
}
int main() {
cin >> n;
int lengt = 1;
for (int i = 0; i <= n; i++) lengt *= 2;
for (int i = 2; i <= lengt - 2 + 1; i++) cin >> a[i];
how(1, 0);
cout << cnt;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define INF (1<<29)
int N,M;
int bfs(int s,int g){
queue<int> Q;
Q.push(s);
int d[1<<N];
fill(d,d+(1<<N),INF);
d[s] = 0;
while(!Q.empty()){
int S = Q.front(); Q.pop();
if(S == g) return d[S];
for(int i = 0 ; i < N-1 ; i++){
int nS = S;
if(((S >> i) & 1) ^ ((S >> (i+1)) & 1)){
nS ^= 1<<i; nS ^= 1<<(i+1);
if(d[S] + 1 < d[nS]){
d[nS] = d[S] + 1;
Q.push(nS);
}
}
}
}
return INF;
}
int main(){
int in,s,g1,g2,sum;
s = g1 = g2 = sum = 0;
cin >> N >> M;
for(int i = 0 ; i < N ; i++){
cin >> in;
s += (in ? (1<<i) : 0);
}
for(int i = 0 ; i < M ; i++){
cin >> in;
for(int j = 0 ; j < in ; j++){
g1 += (i % 2 ? 1<<(sum+j) : 0);
}
for(int j = 0 ; j < in ; j++){
g2 += (i % 2 ? 0 : 1<<(sum+j));
}
sum += in;
}
cout << min(bfs(s,g1),bfs(s,g2)) << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int k;
cin>>k;
int N=50;
cout<<N<<endl;
int a[N];
for(int i=0;i<N;i++) a[i]=N-1;
int p=k/50;
for(int i=0;i<N;i++) a[i]+=p;
int q=k%50;
for(int i=0;i<q;i++) a[i]+=N-(q-1);
for(int i=q;i<N;i++) a[i]-=q;
for(int i=0;i<N;i++){
if(i) cout<<" ";
cout<<a[i];
}
cout<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int q = 0; q < t; q++) {
int n;
cin >> n;
long long fs[n];
for (int i = 0; i < n; i++) {
cin >> fs[i];
}
sort(fs, fs + n);
long long maybe = fs[n - 1] * fs[0];
vector<int> facts;
for (int i = 2; i <= sqrt(maybe); i++) {
if (maybe % i == 0) {
facts.push_back(i);
if (i != sqrt(maybe)) {
facts.push_back(maybe / i);
}
}
}
sort(facts.begin(), facts.end());
if (facts.size() != n) {
cout << -1 << endl;
continue;
}
for (int i = 0; i < n; i++) {
if (maybe % fs[i] != 0 or fs[i] != facts[i]) {
cout << -1 << endl;
break;
}
if (i == n - 1) {
cout << maybe << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100002];
pair<int, int> nxt[20][100002];
vector<pair<int, int>> st;
void prec() {
int nxt[2] = {-1, -1};
for (int i = n - 1; i >= 0; --i)
::nxt[0][i].first = nxt[0], ::nxt[0][i].second = nxt[1], nxt[a[i]] = i;
for (int d = 1; d < 20; ++d)
for (int i = 0; i < n; ++i) {
if (::nxt[d - 1][i].first != -1)
::nxt[d][i].first = ::nxt[d - 1][::nxt[d - 1][i].first].first;
else
::nxt[d][i].first = -1;
if (::nxt[d - 1][i].second != -1)
::nxt[d][i].second = ::nxt[d - 1][::nxt[d - 1][i].second].second;
else
::nxt[d][i].second = -1;
}
}
int getnextf(int c, int second) {
if (!a[c]) second--;
for (int d = 0; second >= (1 << d); ++d) {
if (second & (1 << d)) {
c = nxt[d][c].first;
if (c == -1) break;
}
}
return c;
}
int getnexts(int c, int second) {
if (a[c]) second--;
for (int d = 0; second >= (1 << d); ++d) {
if (second & (1 << d)) {
c = nxt[d][c].second;
if (c == -1) break;
}
}
return c;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) (cin >> a[i]), --a[i];
int w = a[n - 1];
prec();
for (int second = 1; second <= n; ++second) {
int cp = 0, np = 1, t[2] = {0, 0};
while (np && cp != n) {
np = getnextf(cp, second) + 1;
if (!np || np - cp >= 2 * second) {
np = getnexts(cp, second) + 1;
if (np && np - cp < 2 * second) ++t[1];
} else
++t[0];
cp = np;
}
if (cp == n && t[w] > t[!w]) st.push_back(make_pair(t[w], second));
}
sort(st.begin(), st.end());
cout << st.size();
for (auto i : st) cout << '\n' << i.first << ' ' << i.second;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
const long long Base = 127;
const long long Mod1 = 1000000007;
const long long Mod2 = 1000000009;
long long power_base1[MaxN], power_base2[MaxN];
struct Hash {
int len;
vector<long long> Val1, Val2;
void init(string &s) {
len = s.length();
s = '0' + s;
Val1.assign(len + 1, 0);
Val2.assign(len + 1, 0);
for (int i = 1; i <= len; i++) {
Val1[i] = (Val1[i - 1] * Base + (s[i] - 'a')) % Mod1;
Val2[i] = (Val2[i - 1] * Base + (s[i] - 'a')) % Mod2;
}
}
pair<long long, long long> Get(int Left, int Right) {
return make_pair(
(Val1[Right] - Val1[Left - 1] * power_base1[Right - Left + 1] +
Mod1 * Mod1) %
Mod1,
(Val2[Right] - Val2[Left - 1] * power_base2[Right - Left + 1] +
Mod2 * Mod2) %
Mod2);
}
};
void prep() {
power_base1[0] = 1;
power_base2[0] = 1;
for (int i = 1; i < MaxN; i++) {
power_base1[i] = power_base1[i - 1] * Base % Mod1;
power_base2[i] = power_base2[i - 1] * Base % Mod2;
}
}
int n;
string a, b;
Hash aHash, bHash;
int cnta[MaxN][26], cntb[MaxN][26];
map<tuple<int, int, int, int>, bool> mp;
int getMap(const map<tuple<int, int, int, int>, bool> &mp,
tuple<int, int, int, int> val) {
auto it = mp.find(val);
return (it == mp.end() ? -1 : it->second);
}
bool Check(int x, int y, int u, int v) {
int tg = getMap(mp, make_tuple(x, y, u, v));
if (tg != -1) {
return tg;
}
bool &res = mp[make_tuple(x, y, u, v)] = true;
if (aHash.Get(x, y) == bHash.Get(u, v)) {
return res = true;
}
for (int i = 0; i < 26; i++) {
if (cnta[y][i] - cnta[x - 1][i] != cntb[v][i] - cntb[u - 1][i]) {
return res = false;
}
}
if ((y - x + 1) % 2 != 0) {
return res = false;
}
int Mida = (x + y) / 2, Midb = (u + v) / 2;
return res = ((Check(x, Mida, u, Midb) && Check(Mida + 1, y, Midb + 1, v)) ||
(Check(Mida + 1, y, u, Midb) && Check(x, Mida, Midb + 1, v)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
prep();
cin >> a >> b;
n = a.size();
aHash.init(a);
bHash.init(b);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
cnta[i][j] = cnta[i - 1][j];
cntb[i][j] = cntb[i - 1][j];
}
cnta[i][a[i] - 'a']++;
cntb[i][b[i] - 'a']++;
}
cout << (Check(1, n, 1, n) ? "YES\n" : "NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 200020;
struct edge {
long long t, nxt;
};
edge road[500005];
long long cnt;
long long head[Maxn];
void add(long long u, long long v) {
cnt++;
road[cnt].t = v;
road[cnt].nxt = head[u];
head[u] = cnt;
return;
}
long long s[Maxn], d[Maxn];
long long n, number, ans;
void dfs(long long x, long long fa) {
s[x] = 1, d[x] = d[fa] + 1;
for (long long i = head[x]; i; i = road[i].nxt) {
long long y = road[i].t;
if (y == fa) continue;
dfs(y, x);
s[x] += s[y];
}
}
signed main() {
cin >> n;
for (long long i = 1; i < n; ++i) {
long long x, y;
cin >> x >> y;
add(x, y);
add(y, x);
}
dfs(1, 0);
for (long long i = 1; i <= n; ++i) {
ans += (s[i] * (n - s[i]));
if (d[i] % 2) number++;
}
ans += (number * (n - number));
ans /= 2;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int nod(int x, int y) {
int i, j, m, t;
t = 0;
if (x < y) i = x + 1;
if (x >= y) i = y + 1;
while (t == 0) {
i = i - 1;
if (((x % i) == 0) && ((y % i) == 0)) t = 1;
}
return i;
}
int main(void) {
int x, y, s, t, l1, k;
long int a, b;
scanf("%d", &x);
scanf("%d", &y);
scanf("%ld", &a);
scanf("%ld", &b);
s = 0;
k = nod(x, y);
t = y * (x / k);
s = s + (b / t) - (a / t);
if ((a % t) == 0) s = s + 1;
printf("%d", s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265359;
int counter[100001];
int main() {
int t, n, most_freq, num_or_most_freq, x;
cin >> t;
while (t--) {
cin >> n;
most_freq = 0;
memset(counter, 0, sizeof(counter));
for (int i = 0; i < (int)(n); ++i) {
cin >> x;
counter[x]++;
most_freq = max(most_freq, counter[x]);
}
num_or_most_freq = -1;
for (int i = 0; i < (int)(100001); ++i)
if (counter[i] == most_freq) num_or_most_freq++;
if (most_freq == 1)
cout << n << endl;
else {
n -= num_or_most_freq;
int ans = (n - 1) / (most_freq - 1) + 1 - 2;
if (ans <= 0)
cout << 0 << endl;
else
cout << ans << endl;
}
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
cout << ((s[0] != s[1] && s[1] != s[2] && s[2] != s[0])? "Yes" : "No") << endl;
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <stdio.h>
#include <tuple>
#include <bitset>
#include <cfloat>
#include <fstream>
#include <limits.h>
#include <list>
#include <math.h>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <numeric>
#include <utility>
#include <sstream>
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using namespace std;
#define int long long
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define FORR(i,a,b)for(ll i=(a);i<=(b);i++)
#define repr(i,n) for(ll i=n;i>=0;i--)
#define P pair<ll, ll>
#define sz(x) (ll)x.size()
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define VE vector<ll>
#define COUT(x) cout<<(x)<<endl
#define MA map<ll,ll>
#define SE set<ll>
#define PQ priority_queue<ll>
#define PQR priority_queue<ll,VE,greater<ll>>
#define COUT(x) cout<<(x)<<endl
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define EPS (1e-10)
ll gcd(ll a, ll b) {
if (a < b)swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
bool prime(ll n) {
for (ll i = 2; i <= sqrt(n); i++) {
if (n%i == 0)return false;
}
return n != 1;
}
const long long MOD = 1000000007;
const long long INF = 1LL << 60;
const int MAX_N = 100010;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n; cin >> n;
int k = 0;
for (int i = 1; i < n; i += 2) {
k++;
}
for (int i = 1; i < n; i += 3) {
if (i % 2 == 1) {
for (int j = 2; j < n; j += 2) {
k++;
}
}
else {
for (int j = 1; j < n; j += 2) {
k++;
}
}
}
if (n % 3 == 1) {
if (n % 6 == 1) {
for (int j = 1; j < n; j += 2) {
k++;
}
}
else {
for (int j = 2; j < n; j += 2) {
k++;
}
}
}
cout << k << endl;
for (int i = 1; i < n; i += 2) {
cout << 0 << " " << i << endl;
}
for (int i = 1; i < n; i += 3) {
if (i % 2 == 1) {
for (int j = 2; j < n; j += 2) {
cout << j << " " << i << endl;
}
}
else {
for (int j = 1; j < n; j += 2) {
cout << j << " " << i << endl;
}
}
}
if (n % 3 == 1) {
if (n % 6 == 1) {
for (int j = 1; j < n; j += 2) {
cout << j << " " << n - 1 << endl;
}
}
else {
for (int j = 2; j < n; j += 2) {
cout << j << " " << n - 1 << endl;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1e6+10,mod=1e9+7,inf=0x3f3f3f3f3f3f3f3f;
struct sc
{
ll id,dis;
bool operator<(const sc &a)const
{
return a.dis<dis;
}
}p[N];
vector<sc>link1[N],link2[N];
ll n,m,val1[N],val2[N],dis1[N],dis2[N],vis[N],a[N],b[N],c[N];
void dij(ll s,vector<sc>link[],ll dis[],ll val[])
{
priority_queue<sc>q;
for(ll i=1;i<=n;i++)dis[i]=inf,vis[i]=0,val[i]=0;
dis[s]=0;
val[s]=1;
vis[s]=1;
q.push({s,0});
while(!q.empty())
{
sc tep=q.top();q.pop();
//if(tep.dis>dis[tep.id])continue;
vis[tep.id]++;
for(sc p:link[tep.id])
{
if(tep.dis+p.dis==dis[p.id])
{
val[p.id]=(val[p.id]+val[tep.id])%mod;
}
if(!vis[p.id]&&tep.dis+p.dis<dis[p.id])
{
dis[p.id]=tep.dis+p.dis;
q.push({p.id,tep.dis+p.dis});
val[p.id]=val[tep.id];
}
}
}
}
int main()
{
//freopen("i.txt","r",stdin);
scanf("%lld %lld",&n,&m);
for(ll i=0;i<m;i++)
{
scanf("%lld %lld %lld",&a[i],&b[i],&c[i]);
link1[a[i]].push_back({b[i],c[i]});
link2[b[i]].push_back({a[i],c[i]});
}
dij(1,link1,dis1,val1);
dij(2,link2,dis2,val2);
for(ll i=0;i<m;i++)
{
if(dis1[b[i]]+dis2[a[i]]+c[i]<dis1[2])puts("HAPPY");
else if(dis1[a[i]]+dis2[b[i]]+c[i]==dis1[2]&&val1[a[i]]*val2[b[i]]%mod==val1[2])puts("SAD");
else puts("SOSO");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m, q;
int f[N * 2];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d%d%d", &n, &m, &q);
iota(f + 1, f + n + m + 1, 1);
int cnt = n + m - 1;
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
b += n;
a = find(a);
b = find(b);
if (a != b) {
f[a] = b;
--cnt;
}
}
printf("%d\n", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, alice = 0, bob = 0, i, j, bar[100005];
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &bar[i]);
for (i = 0, j = n - 1; i < j;) {
if (alice == bob)
alice += bar[i++], bob += bar[j--];
else if (alice > bob)
bob += bar[j--];
else
alice += bar[i++];
}
if (alice <= bob && i == j)
i++;
else if (j == i)
j--;
printf("%d %d\n", i, n - j - 1);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+7;
long long dp[N], x[N], premin[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, T;
cin>>n>>m>>T;
premin[0] = 1e18;
for (int i=1; i<=n; i++) {
cin>>x[i];
premin[i] = min(dp[i-1]-2*x[i], premin[i-1]);
int idx = upper_bound(x+1, x+i, x[i]-(T+1)/2)-x-1;
dp[i] = min(premin[idx]+2*x[i], dp[idx]+T);
// cout<<i<<" "<<x[i]<<" --> "<<dp[i-1]-2*x[i]<<" "<<premin[i]<<" \t "<<x[i]-T/2<<" "<<idx<<" \t= "<<dp[i]<<endl;
}
cout<<dp[n]+m<<endl;
}
| 0 |
#include <iostream>
using namespace std;
int N,a[100010];
int main(){
cin >> N;
int i;
for (i=1; i<=N; i++) cin >> a[i];
int ans=0;
for (i=1; i<=N; i++)
if (a[a[i]]==i) ans++;
cout << ans/2 << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 200005;
const int mod = 998244353;
int n, m, a;
int b[maxn];
int quickpow(int x, int pow) {
int res = 1;
for (; pow; pow >>= 1) {
if (pow & 1) res = 1LL * res * x % mod;
x = 1LL * x * x % mod;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &a);
for (int(i) = 1; (i) <= m; i++) scanf("%d", &b[i]);
int ans = quickpow(a, n), cnt = 1;
for (int(i) = 1; (i) <= m; i++) {
int tmp = quickpow(a, b[i] - b[i - 1]);
ans = (ans + 1LL * ans * quickpow(tmp, mod - 2) % mod) % mod;
cnt = 2LL * cnt % mod;
}
printf("%d\n", 1LL * ans * quickpow(cnt, mod - 2) % mod);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long bin = 2, cur, f = 4, s = 0;
while (n -= 2) {
(bin <<= 1) %= 1000000009;
cur = (bin + 1000000009 - 3) % 1000000009;
(f *= cur) %= 1000000009;
(s += f) %= 1000000009;
}
long long ans = (s * s * 2 + 8 * s + 10) % 1000000009;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int k, n, c = 0, f = 0;
string str;
cin >> str >> k;
n = str.size();
for (int i = n - 1; i >= 0 && k != 0; i--) {
if (str[i] == '0') {
k--;
f = 1;
continue;
}
c++;
}
if (k) c = n - f;
cout << c << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, nxt[200005], at, to;
long long k, p;
long long x[200005], y[200005];
long long ans;
int main() {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", x + i);
y[i + 1] = y[i] + x[i];
}
nxt[n] = n;
for (int i = n - 1; i >= 0; i--)
if (x[i] == 1)
nxt[i] = nxt[i + 1];
else
nxt[i] = i;
for (int i = 0; i < n; i++) {
p = 1;
at = i;
while (at < n)
if (x[at] == 1) {
to = nxt[at];
if (p % k == 0 && binary_search(y + at + 1, y + to + 1, p / k + y[i]))
ans++;
at = to;
} else {
if (p > LLONG_MAX / x[at]) break;
p *= x[at];
at++;
if (p == (y[at] - y[i]) * k) ans++;
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
void no() {
printf("NO");
exit(0);
}
void yes() {
printf("YES");
exit(0);
}
int main(int argc, char *argv[]) {
int aa = 0, ba = 0, ca = 0;
char str[5015];
for (int i = 0; i < 5015; i++) str[i] = '\0';
scanf("%s", str);
for (int i = 0; str[i] != '\0'; i++) {
if (aa == 0 && str[i] == 'b') no();
if (ba == 0 && str[i] == 'c') no();
if (aa == 0 && str[i] == 'c') no();
if (str[i] == 'b' && str[i + 1] == 'a') no();
if (str[i] == 'c' && str[i + 1] == 'a') no();
if (str[i] == 'c' && str[i + 1] == 'b') no();
if (str[i] == 'a') aa++;
if (str[i] == 'b') ba++;
if (str[i] == 'c') ca++;
}
if ((ca == ba || ca == aa) && aa > 0 && ba > 0 && ca > 0)
yes();
else
no();
return 0;
}
| 1 |
#include <iostream>
#include <memory>
#include <memory.h>
#include <cmath>
#include <fstream>
#include <cmath>
#include <numeric>
#include <vector>
#include <stack>
#include <string>
#include <queue>
#include <sstream>
#include <cstdlib>
#include <cassert>
#include <cstdio>
#include <map>
#include <iomanip>
#include <list>
#include <cctype>
#include <algorithm>
#include <complex>
#define USE_MATH_DEFINES
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, m, n) for(int i = m; i < n; i++)
using namespace std;
typedef complex<double> xy_t;
typedef pair<xy_t, xy_t> line;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<int, PP> PPP;
const int INF = 1 << 29;
const double EPS = 1E-10;
int dp[300];
P ma[300];
int main(){
int n, m;
while(cin >> n && n){
memset(dp, 0, sizeof(dp));
rep(i, n) cin>> ma[i].first >> ma[i].second;
cin >> m;
rep(i, m) cin >> ma[n+i].first >> ma[n+i].second;
sort(ma, ma + n + m);
int res = 0;
rep(i, n + m){
int best = 0;
rep(j, i){
if(ma[i].first > ma[j].first && ma[i].second > ma[j].second) best = max(best, dp[j]);
}
dp[i] = best + 1;
res = max(res, dp[i]);
}
cout << res << endl;
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
using namespace std;
inline int read_char() {
static char buf[1 << 16], *ptr = buf, *end_ptr = buf;
if (ptr == end_ptr) {
int len = fread(buf, 1, sizeof(buf), stdin);
if (len <= 0) return EOF;
ptr = buf;
end_ptr = buf + len;
}
return *ptr++;
}
inline int read_int() {
int sg = +1, ch;
do {
ch = read_char();
if (ch == '-') sg = -1;
} while (ch < '0' || ch > '9');
int x = ch - '0';
while (true) {
ch = read_char();
if (ch < '0' || ch > '9') break;
x = x * 10 + ch - '0';
}
return sg * x;
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int N = 1e5 + 10;
int n, m;
float __attribute__((aligned(32))) a[N];
int main() {
n = read_int();
m = read_int();
for (int i = 1; i <= n; i++) a[i] = read_int();
while (m--) {
int op, l, r, x;
op = read_int();
l = read_int();
r = read_int();
x = read_int();
if (op == 1) {
for (int i = l; i <= r; i++)
if (a[i] > x) a[i] -= x;
} else {
int ans = 0;
for (int i = l; i <= r; i++)
if (a[i] == x) ans++;
W(ans);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int num[33], p, n, cnt = 0, a[33], ans[33];
unsigned short dp[33][33][50000 + 5], pre[33][33][50000 + 5];
int w(int x) { return x >= 10 ? 100 : 10; }
void update(int x, int y, int z, int k, bool flag) {
if (!dp[x][y][z]) dp[x][y][z] = flag ? 2 : 1, pre[x][y][z] = k;
}
void getAns(int i, int j, int k) {
if (i == 0) return;
int x = i - 1, y = dp[i][j][k] == 2 ? (a[i] ^ j) : j, z = pre[i][j][k];
if (dp[i][j][k] == 2) ans[++ans[0]] = i;
getAns(x, y, z);
}
int main() {
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x <= 31) a[++cnt] = x, num[cnt] = i;
}
n = cnt;
for (int i = 1; i < n; i++) {
update(i, a[i], a[i] % p, 0, 1);
for (int j = 0; j <= n; j++)
for (int k = 0; k < p; k++)
if (dp[i][j][k]) {
update(i + 1, j, k, k, 0);
update(i + 1, j ^ a[i + 1], (k * w(a[i + 1]) + a[i + 1]) % p, k, 1);
}
}
if (dp[n][0][0]) {
puts("Yes");
getAns(n, 0, 0);
printf("%d\n", ans[0]);
for (int i = ans[0]; i; i--) printf("%d ", num[ans[i]]);
puts("");
} else
puts("No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const int MAXN = 1005;
int N, K;
int dp[5][MAXN];
int in[5][MAXN];
int ind[5][MAXN];
int main() {
scanf("%d %d", &N, &K);
for (int i = 0; (i) < (K); ++(i)) {
for (int j = 0; (j) < (N); ++(j)) {
scanf("%d", &in[i][j]);
dp[i][j] = 1;
ind[i][in[i][j]] = j;
}
}
for (int i = 1; i < N; i++) {
for (int j = 0; j < i; j++) {
int temp = dp[0][j] + 1;
int a = in[0][j];
int b = in[0][i];
for (int k = 1; k < K; k++) {
int from = ind[k][a];
int to = ind[k][b];
if (from < to) {
mina(temp, dp[k][from] + 1);
} else {
temp = 1;
}
}
for (int k = 0; (k) < (K); ++(k)) {
maxa(dp[k][ind[k][b]], temp);
}
}
}
int ans = 1;
for (int i = 0; (i) < (N); ++(i)) {
maxa(ans, dp[0][i]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
long long n, ans[40], Ans, nn;
int K, h2[40];
struct O {
long long a[40][40];
} E, A[40], B[70], C;
O operator*(const O &A, const O &B) {
for (int i = 0; i <= K; ++i)
for (int j = 0; j <= K; ++j) {
C.a[i][j] = 0;
for (int k = 0; k <= K; ++k) (C.a[i][j] += A.a[i][k] * B.a[k][j]) %= mo;
}
return C;
}
int main() {
scanf("%lld%d", &n, &K);
if (n <= K) {
printf("%lld\n", (1ll << n) % mo);
return 0;
}
for (int t = 0; t < K; ++t) {
for (int i = 0; i < K; ++i) h2[i] = (i + t) % K;
for (int j = 0; j < K; ++j) {
for (int k = 0; k < j; ++k)
for (int i = 0; i <= K; ++i) (A[t].a[i][j] += A[t].a[i][k]) %= mo;
for (int i = K - 1; ~i; --i) {
++A[t].a[i][j];
if (i == h2[j]) break;
}
}
for (int j = 0; j <= K; ++j) A[t].a[j][K] = 1;
}
nn = n / K;
B[0] = A[1];
for (int j = 0; j <= K; ++j) E.a[j][j] = 1;
for (int j = 1; j < K; ++j) E = B[0] * E;
for (long long NN = nn / K, i = 1; NN; NN /= K, ++i) {
B[i] = E * A[(i + 1) % K];
for (int j = 1; j < K; ++j) E = B[i] * E;
}
memset(E.a, 0, sizeof E.a);
for (int j = 0; j <= K; ++j) E.a[j][j] = 1;
for (int i = 0; nn; nn /= K, ++i)
for (int j = nn % K; j; --j) E = B[i] * E;
for (int i = 0; i < K; ++i)
for (int j = 0; j <= K; ++j) (ans[j] += (1ll << i) * E.a[i][j]) %= mo;
Ans = 1 + ans[K];
for (int j = 0; j < n % K; ++j) (Ans += ans[j]) %= mo;
printf("%lld\n", (Ans % mo + mo) % mo);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
char c = getchar();
T p = 1, n = 0;
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = n * 10 + c - '0';
c = getchar();
}
x = p * n;
}
template <class T, class U>
void read(T& x, U& y) {
read(x), read(y);
}
template <class T, class U, class V>
void read(T& x, U& y, V& z) {
read(x), read(y), read(z);
}
const int maxn = 200 + 5, maxm = 1000 + 5, INF = 0x3f3f3f3f;
namespace FLOW {
struct E {
int v, n, f;
} e[maxm << 1];
int h[maxn], ec = 2;
inline void add_edge(int u, int v, int c) {
e[ec] = (E){v, h[u], c}, h[u] = ec++, e[ec] = (E){u, h[v], c}, h[v] = ec++;
}
queue<int> Q;
int d[maxn], s, t;
bool bfs() {
memset(d, INF, sizeof d);
d[s] = 0;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = h[u], v = e[i].v; i; i = e[i].n, v = e[i].v)
if (e[i].f && d[v] == INF) d[v] = d[u] + 1, Q.push(v);
}
return d[t] != INF;
}
int cur[maxn];
int dfs(int u = s, int a = INF) {
if (u == t || !a) return a;
int flow = 0, f;
for (int &i = cur[u], v = e[i].v; i; i = e[i].n, v = e[i].v)
if (d[v] == d[u] + 1 && (f = dfs(v, min(a, e[i].f)))) {
e[i].f -= f, e[i ^ 1].f += f, a -= f, flow += f;
if (!a) break;
}
return flow;
}
} // namespace FLOW
namespace TREE {
struct E {
int v, n, w, f;
} e[maxn << 1];
int h[maxn], ec = 2;
inline void add_edge(int u, int v, int w) {
e[ec] = (E){v, h[u], w, 0}, h[u] = ec++, e[ec] = (E){u, h[v], w, 0},
h[v] = ec++;
}
int ti, w;
void dfs(int u, int f = 0) {
for (int i = h[u], v = e[i].v; i; i = e[i].n, v = e[i].v)
if (!e[i].f && v != f) {
dfs(v, u);
if (e[i].w < w) w = e[i].w, ti = i;
}
}
void dc(int u = 1) {
ti = INF, w = INF;
dfs(u);
int i = ti;
if (i == INF) {
printf("%d ", u);
return;
}
e[i].f = e[i ^ 1].f = true;
dc(e[i].v);
dc(e[i ^ 1].v);
}
} // namespace TREE
bool f[maxn];
void go(int u) {
f[u] = true;
using namespace FLOW;
for (int i = h[u], v = e[i].v; i; i = e[i].n, v = e[i].v)
if (!f[v] && e[i].f) go(v);
}
int a[maxn], b[maxn], ret = 0;
void dc(int l, int r) {
if (l == r) return;
using namespace FLOW;
for (int i = 2; i < ec; i += 2)
e[i].f = e[i ^ 1].f = (e[i].f + e[i ^ 1].f) >> 1;
s = a[l], t = a[r];
int w = 0;
while (bfs()) memcpy(cur, h, sizeof h), w += dfs();
TREE::add_edge(s, t, w);
ret += w;
memset(f, false, sizeof f);
go(s);
int _l = l, _r = r;
for (int i = l; i <= r; ++i)
if (f[a[i]])
b[_l++] = a[i];
else
b[_r--] = a[i];
for (int i = l; i <= r; ++i) a[i] = b[i];
dc(l, _l - 1), dc(_r + 1, r);
}
int main() {
int n, m;
read(n, m);
int u, v, c;
while (m--) read(u, v, c), FLOW::add_edge(u, v, c);
for (int i = 1; i <= n; ++i) a[i] = i;
dc(1, n);
printf("%d\n", ret);
TREE::dc();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 100;
inline int read() {
int X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
char s[N];
int main() {
int _;
cin >> _;
while (_--) {
cin >> (s + 1);
int n = strlen(s + 1);
int ans = 0, f = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '0' && s[i - 1] != '0') ans++;
}
if (ans > 2) ans = 2;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int INF = 0x3f3f3f3f, N = 2e6 + 5, MOD = 1e9 + 7;
long long qpow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % MOD)
if (b & 1) res = res * a % MOD;
return res;
}
class Tree {
public:
int n, siz[N], bits[N];
vector<int> g[N], st[N];
void read() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
}
void dfs(int x, int _fa) {
st[x].clear();
st[x].push_back(0);
siz[x] = 0;
bits[x] = 0;
for (auto v : g[x])
if (v != _fa) {
dfs(v, x);
st[x].push_back(v);
siz[x]++;
bits[x] |= 1 << (v - 1);
}
}
} s, t;
int vis[1005][(1 << 12) + 5], dp[1005][(1 << 12) + 5];
int dfs(int x, int th, int sta) {
if (!th) return !sta;
int son = s.st[x][th], &res = dp[son][sta];
if (vis[son][sta]) return dp[son][sta];
vis[son][sta] = 1;
res = dfs(x, th - 1, sta);
for (int i = 1; i <= t.n; i++)
if (sta & (1 << (i - 1))) {
res = (res + 1ll * dfs(x, th - 1, sta ^ (1 << (i - 1))) *
dfs(son, s.siz[son], t.bits[i])) %
MOD;
}
return res;
}
int Solve(int cas = 0) {
s.read();
t.read();
s.dfs(1, 0);
long long ans = 0, ans2 = 0;
for (int i = 1; i <= t.n; i++) {
memset(dp, 0, sizeof dp);
memset(vis, 0, sizeof vis);
t.dfs(i, 0);
for (int j = 1; j <= s.n; j++)
ans = (0ll + ans + dfs(j, s.siz[j], t.bits[i])) % MOD;
}
s = t;
s.dfs(1, 0);
for (int i = 1; i <= t.n; i++) {
memset(dp, 0, sizeof dp);
memset(vis, 0, sizeof vis);
t.dfs(i, 0);
ans2 = (ans2 + dfs(1, s.siz[1], t.bits[i])) % MOD;
}
cout << ans * qpow(ans2, MOD - 2) % MOD << endl;
return 0;
}
void Pre() {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
Pre();
while (Solve())
;
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int n,a,b,f[5005];
long long dp[5005][5005];
int main()
{
scanf("%d%d%d",&n,&a,&b);
for(int i=1;i<=n;i++)
{
int x;
scanf("%d",&x);
f[x]=i;
}
for(int i=1;i<=n;i++)
{
int pos=f[i];
long long t=1e18;
for(int j=1;j<=n;j++)
{
t=min(t,dp[i-1][j]);
if(pos==j) dp[i][j]=t;
else if(pos>j) dp[i][j]=t+b;
else dp[i][j]=t+a;
}
}
long long ans=1e18;
for(int i=1;i<=n;i++)
ans=min(ans,dp[n][i]);
printf("%lld\n",ans);
}
/*dp[i][j]表示将第i个数搬移到前j个位置的最小价值*/
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
const long long big = 1000000007ll;
const long long big2 = 1000000009ll;
long long n, m, k, q, w, h;
string vows = "aeiou";
string s;
bool vow[30] = {0};
int main() {
long long a, b, c, d, e;
for (long long c1 = 0; c1 < 5; c1++) {
vow[vows[c1] - 'a'] = 1;
}
cin >> s;
string ans = "";
n = s.length();
long long cns = 0;
bool same = 0;
long long prev = -1;
for (long long c1 = 0; c1 < n; c1++) {
a = s[c1] - 'a';
if (!vow[a]) {
if (cns == 0) {
same = 1;
cns++;
} else {
if ((!same) || (cns >= 2 && a != prev)) {
ans += " ";
same = 1;
cns = 1;
} else {
if (a != prev) same = 0;
cns++;
}
}
} else {
cns = 0;
same = 0;
}
prev = s[c1] - 'a';
ans += s[c1];
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct item {
int u, w;
} a[100005];
vector<int> vc[100005];
int f[100005], n, m;
double sum[100005];
bool vis[100005];
int find(int u) {
if (f[u] == u)
return f[u];
else
return f[u] = find(f[u]);
}
int cmp(item a, item b) { return a.w > b.w; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].w);
a[i].u = i;
}
sort(a + 1, a + n + 1, cmp);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
vc[u].push_back(v);
vc[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
f[i] = i;
sum[i] = 1;
}
double ans = 0;
for (int i = 1; i <= n; i++) {
int u = a[i].u;
vis[u] = 1;
for (int j = 0; j < vc[u].size(); j++) {
int v = vc[u][j];
if (!vis[v]) continue;
int fu = find(u), fv = find(v);
if (fu != fv) {
ans += sum[fu] * sum[fv] * a[i].w * 2;
f[fu] = fv;
sum[fv] += sum[fu];
}
}
}
printf("%.8lf\n", ans / n / (n - 1));
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.