solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
string str[10005];
int n, q, top;
map<string, int> s;
int tot[500005];
int begi[500005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int k = 0; k < n; k++) {
cin >> str[k];
set<string> temps;
for (int i = 1; i <= str[k].length(); i++) {
for (int j = 0; i + j <= str[k].length(); j++) {
temps.insert(str[k].substr(j, i));
}
}
for (auto temp : temps) {
if (s.find(temp) != s.end()) {
tot[s[temp]]++;
} else {
s[temp] = ++top;
begi[top] = k;
tot[top] = 1;
}
}
}
cin >> q;
for (int i = 1; i <= q; i++) {
string temps;
cin >> temps;
if (s.find(temps) == s.end()) {
cout << 0 << ' ' << '-' << endl;
} else {
cout << tot[s[temps]] << ' ' << str[begi[s[temps]]] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
typedef struct {
int r, c;
} unit;
void eliminate(char M[100][100], int r_c_index, char r_c, char character, int n,
int m) {
if (r_c == 'r') {
for (int j = 0; j < m; j++)
if (M[r_c_index][j] == character) M[r_c_index][j] = ' ';
} else if (r_c == 'c') {
for (int i = 0; i < n; i++)
if (M[i][r_c_index] == character) M[i][r_c_index] = ' ';
}
}
void print_special(unit Special[100][100], int max) {
for (int i = 0; i < max; i++) {
for (int j = 0; j < 26; j++)
printf("(%d,%d) ", Special[i][j].r, Special[i][j].c);
printf("\n");
}
}
void print_m(char M[100][100], int n, int m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (M[i][j] == ' ')
printf(".");
else
printf("%c", M[i][j]);
printf("\n");
}
}
int main() {
char M[100][100] = {};
unit Special[100][26] = {};
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %[^\n]", M[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
Special[i][M[i][j] - 'a'].r++;
Special[j][M[i][j] - 'a'].c++;
}
}
int max = 0;
(m > n) ? (max = m) : (max = n);
for (int i = 0; i < max; i++) {
for (int j = 0; j < 26; j++) {
if (Special[i][j].r >= 2) eliminate(M, i, 'r', j + 'a', n, m);
if (Special[i][j].c >= 2) eliminate(M, i, 'c', j + 'a', n, m);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (M[i][j] != ' ') printf("%c", M[i][j]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b;
int flag = 0;
scanf("%c %c", &a, &b);
char res[100], ans[100];
for (int i = 0; i < 5; ++i) {
cin >> res[i] >> ans[i];
if (res[i] == a)
flag = 1;
else if (ans[i] == b)
flag = 1;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
bool done[200010];
int first[200010], e;
int n, m, s, len, sum;
int dist[200010];
int eee[200010][3];
struct node {
int dist, u;
friend bool operator<(node a, node b) { return a.dist > b.dist; }
};
priority_queue<node> q;
struct EDGE {
int v, w, next;
} edge[200010];
void add(int u, int v, int w) {
edge[e].next = first[u];
edge[e].v = v;
edge[e].w = w;
first[u] = e++;
}
void Dijkstra(int x) {
int e;
node u, v;
for (int i = 0; i < 200010; i++) dist[i] = (i == x ? 0 : 1000000010);
if (n == 0) return;
memset(done, 0, sizeof(done));
u.dist = 0;
u.u = x;
q.push(u);
while (!q.empty()) {
u = q.top();
q.pop();
if (done[u.u]) continue;
done[u.u] = 1;
for (e = first[u.u]; e != -1; e = edge[e].next) {
if (dist[edge[e].v] > (dist[u.u] + edge[e].w)) {
v.u = edge[e].v;
v.dist = dist[edge[e].v] = dist[u.u] + edge[e].w;
q.push(v);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &s);
memset(first, -1, sizeof(first));
e = 0;
sum = 0;
int u, v, w, i, j;
for (i = 0; i < m; i++) {
scanf("%d%d%d", &u, &v, &w);
eee[i][0] = u;
eee[i][1] = v;
eee[i][2] = w;
add(u, v, w);
add(v, u, w);
}
scanf("%d", &len);
Dijkstra(s);
for (i = 1; i <= n; i++)
if (dist[i] == len) sum++;
for (i = 0; i < m; i++) {
if (dist[eee[i][0]] < len && dist[eee[i][1]] < len) {
if (dist[eee[i][0]] + dist[eee[i][1]] + eee[i][2] == len * 2) sum++;
if (dist[eee[i][0]] + dist[eee[i][1]] + eee[i][2] > len * 2)
sum = sum + 2;
}
if (dist[eee[i][0]] < len && dist[eee[i][1]] > len) sum++;
if (dist[eee[i][0]] > len && dist[eee[i][1]] < len) sum++;
if (dist[eee[i][0]] == len && dist[eee[i][1]] < len &&
dist[eee[i][1]] + eee[i][2] > dist[eee[i][0]])
sum++;
if (dist[eee[i][1]] == len && dist[eee[i][0]] < len &&
dist[eee[i][0]] + eee[i][2] > dist[eee[i][1]])
sum++;
}
printf("%d\n", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> read(long long int n) {
vector<long long int> a;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
a.push_back(x);
}
return a;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> a = read(n);
reverse(a.begin(), a.end());
for (auto x : a) {
cout << x << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10;
int n, k, d, dv, mx, cent;
bool mark[M];
vector<int> g[M], lst;
void door(int v, int dr, int f) {
mark[v] = true;
lst.push_back(v);
for (int i = 0; i < g[v].size(); i++)
if (!mark[g[v][i]]) door(g[v][i], dr + 1, f);
if (mx < dr) dv = v, mx = dr;
if (v == f) cent = lst[lst.size() / 2];
mark[v] = false;
lst.pop_back();
}
int dfs(int v, int r) {
mark[v] = true;
set<int> neg;
for (int i = 0; i < g[v].size(); i++)
if (!mark[g[v][i]]) neg.insert(dfs(g[v][i], r));
if (neg.size() == 0) return 1;
if (*neg.begin() == -1) return -1;
if (neg.size() == 2 && v == r) return *neg.begin() + *neg.rbegin();
if (neg.size() > 1) return -1;
if (v == r) return *neg.begin();
return *neg.begin() + 1;
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &v, &u);
g[u].push_back(v);
g[v].push_back(u);
}
door(1, 0, 0);
mx = 0;
int f = dv;
door(dv, 0, 0);
door(dv, 0, f);
k = dfs(cent, cent);
while (k % 2 == 0) k /= 2;
cout << k << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> g[100000];
bool vis[100000];
vector<string> v;
map<string, long long int> mp;
vector<long long int> uniquee;
long long int cou = 0, cou1 = 0;
void dfs(long long int y) {
long long int t, i;
if (vis[y]) {
return;
}
vis[y] = 1;
cou++;
t = g[y].size();
if (t == 0) {
cou1++;
}
for (i = 0; i < t; i++) {
dfs(g[y][i]);
}
}
void separate(string s) {
string t;
long long int tt, i;
tt = s.size();
for (i = 0; i < tt; i++) {
if (s[i] == '\\') {
t = t + s[i];
v.push_back(t);
t.clear();
continue;
}
t = t + s[i];
}
v.push_back(t);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s, p;
long long int u, x = 1, l, i, t, ans = 0, ans1 = 0;
while (cin >> s) {
separate(s);
u = v.size();
p = p + v[0];
p = p + v[1];
if (mp[p] == 0) {
mp[p] = x;
l = mp[p];
uniquee.push_back(l);
x++;
} else {
l = mp[p];
}
for (i = 2; i < u; i++) {
p = p + v[i];
if (mp[p] == 0) {
mp[p] = x;
t = mp[p];
g[l].push_back(t);
x++;
} else {
t = mp[p];
}
l = t;
}
v.clear();
p.clear();
}
u = uniquee.size();
for (i = 0; i < u; i++) {
dfs(uniquee[i]);
ans = max(ans, cou - cou1 - 1);
ans1 = max(ans1, cou1);
cou = 0;
cou1 = 0;
}
cout << ans << " " << ans1 << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
map<int, vector<int>> make_pair;
int n, i, mn = INT_MAX;
cin >> n;
int a[n];
for (i = 0; i < n; ++i) {
cin >> a[i];
make_pair[a[i]].push_back(i);
}
for (i = 0; i < make_pair.size(); ++i) {
for (int j = 1; j < make_pair[i].size(); ++j) {
mn = min(make_pair[i][j] - make_pair[i][j - 1] + 1, mn);
}
}
if (mn == INT_MAX) mn = -1;
cout << mn;
}
int main() {
ios::sync_with_stdio(0);
;
int t;
cin >> t;
while (t--) {
solve();
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
const int M = 1e6;
const long long INF = (long long)(1e18);
const int inf = 1e9;
const long long MOD = 1000000007LL;
void solve() {
long long a, b, c;
cin >> a >> b >> c;
long long ans = INF;
for (long long i = a - 1; i <= a + 1; i++) {
for (long long j = b - 1; j <= b + 1; j++) {
for (long long k = c - 1; k <= c + 1; k++) {
long long tmp = abs(i - j) + abs(j - k) + abs(i - k);
ans = min(ans, tmp);
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 110;
int n, a[maxn];
long long dp[maxn][2], ans;
char s[maxn];
int main() {
scanf("%s", s);
n = strlen(s);
s[n] = s[0];
for (int start = 0; start < 2; start++) {
memset(dp, 0, sizeof(dp));
dp[0][start] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == 'B')
dp[i][1] += dp[i - 1][1];
else if (s[i - 1] == 'B')
dp[i][1] += dp[i - 1][0];
if (s[i - 1] == 'A') dp[i][0] += dp[i - 1][0];
dp[i][0] += dp[i - 1][1];
}
ans += dp[n][start];
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int n = s.size();
vector<int> count;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
cnt++;
else {
if (cnt > 0) {
count.push_back(cnt);
cnt = 0;
}
}
}
if (cnt > 0) {
count.push_back(cnt);
}
sort(count.begin(), count.end(), greater<int>());
int ans = 0;
for (int i = 0; i < count.size(); i += 2) {
ans = ans + count[i];
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int freq;
vector<int> v;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
freq += (a & 1);
}
if (freq & 1) return puts("First"), 0;
if (!freq) return puts("Second"), 0;
return puts("First"), 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, a, c = 1, b;
cin >> n;
cin >> a >> b;
p = a;
q = b;
int num = n;
n--;
int max = 1;
while (n--) {
cin >> a >> b;
if (p == a && q == b) {
c++;
} else if (c > 1) {
if (max < c) max = c;
c = 1;
}
p = a;
q = b;
}
if (c > max) max = c;
cout << max;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 2147483640;
long long a[N];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long zheng = 0;
long long fu = 0;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] < 0) {
if (-a[i] > zheng) {
ans += -a[i] - zheng;
zheng = 0;
} else
zheng -= (-a[i]);
} else {
zheng += a[i];
}
}
long long ans2 = 0;
for (int i = n; i >= 1; --i) {
if (a[i] > 0) {
if (a[i] > fu) {
ans2 += a[i] - fu;
fu = 0;
} else
fu -= a[i];
} else {
fu += -a[i];
}
}
cout << max(ans, ans2) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[400100], b[400100], c[400100];
int i, n;
bool cmp(int i, int j) { return (a[i] < a[j]); }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
c[i] = i;
}
sort(c + 1, c + n + 1, cmp);
b[c[1]] = a[c[1]];
for (int i = 2; i <= n; i++) {
b[c[i]] = max(a[c[i]], b[c[i - 1]] + 1);
}
for (int i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int k, tot, n, u, ans;
char a[100005];
int main() {
scanf("%d%s", &k, a + 1);
n = strlen(a + 1);
for (int i = 1; i <= n; i++) tot += a[i] - '0';
if (tot >= k)
printf("0");
else {
u = k - tot;
sort(a + 1, a + n + 1);
for (int i = 1; u > 0 && i <= n; i++)
if (a[i] < '9') {
u -= '9' - a[i];
++ans;
}
printf("%d", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int Comb(long long int n, long long int k) {
long double res = 1;
for (long long int i = 1; i <= k; ++i) res = res * (n - k + i) / i;
return (long long int)(res + 0.01);
}
long long int Abs(long long int x) {
if (x >= 0) return x;
return (-1) * x;
}
long double Absd(long double x) {
if (x >= 0) return x;
return (-1) * x;
}
long long int Pow(long long int n, long long int k) {
if (k == 1) return (n % mod);
if (k == 0) return 1;
long long int x = Pow(n, k / 2);
if (k % 2) return (((x * x) % mod) * n) % mod;
return ((x * x) % mod);
}
int Max(int a, int b) { return (a > b) ? a : b; }
int Min(int a, int b) { return (a < b) ? a : b; }
struct Node {
int parent;
char c;
int child[2];
Node() {
parent = -1;
child[0] = -1;
child[1] = -1;
}
};
int lowerIndex(int arr[], int l, int h, int x) {
while (l <= h) {
int mid = (l + h) / 2;
if (arr[mid] >= x)
h = mid - 1;
else
l = mid + 1;
}
return l;
}
int upperIndex(int arr[], int l, int h, int y) {
while (l <= h) {
int mid = (l + h) / 2;
if (arr[mid] <= y)
l = mid + 1;
else
h = mid - 1;
}
return h;
}
int countInRange(int arr[], int l, int h, int x, int y) {
int count = 0;
count = upperIndex(arr, l, h, y) - lowerIndex(arr, l, h, x) + 1;
return count;
}
int printPrimeFactors(int n) {
int k = 0;
while (n % 2 == 0) {
k++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
k++;
n = n / i;
}
}
if (n > 2) k++;
return k;
}
bool ispalindrome(string s) {
string s1 = s;
reverse(s1.begin(), s1.end());
if (s == s1) return 1;
return 0;
}
void dfs(vector<vector<int> > &graph, vector<bool> &visited, int i) {
visited[i] = 1;
for (auto j : graph[i]) {
if (visited[j]) return;
dfs(graph, visited, j);
}
return;
}
bool cust(long double a, long double b) { return (Absd(a) < Absd(b)); }
string make_string(string s, int n, int k) {
string s1(k, ' ');
for (int i = 0; i < k; i++) {
s1[i] = s[i % n];
}
return s1;
}
bool isprime(long long int n) {
if ((n == 2) || (n == 3)) return 1;
for (long long int i = 2; (i * i) <= n; i++) {
if ((n % i) == 0) {
return 0;
}
}
return 1;
}
long long int find_sqrt(long long int k, long long int d) {
long long int low = 0, high = (d / k) + 1, sq = (d * d), ans;
long long int mid;
while (low <= high) {
mid = (low + high) / 2;
long long int x = k * mid;
if ((2 * x * x) == sq) return mid;
if ((2 * x * x) < sq) {
low = (mid + 1);
ans = mid;
} else
high = (mid - 1);
}
return mid;
}
long long int floorSqrt(long long int x) {
if (x == 0 || x == 1) return x;
long long int start = 1, end = x, ans;
while (start <= end) {
long long int mid = (start + end) / 2;
if (mid * mid == x) return mid;
if (mid <= x / mid) {
start = mid + 1;
ans = mid;
} else
end = mid - 1;
}
return ans;
}
long long int findp(long long int r, long long int s, long long int p,
long long int q) {
long long int x = 1;
while (r % q == 0) r /= s;
x = max(x, r);
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
long long int p, q;
cin >> p >> q;
long long int x = -1;
if (q > p)
x = p;
else if (p % q)
x = p;
else {
long long int r = p, s = q;
x = 1;
for (long long int i = 2; i <= floorSqrt(s); i++) {
while (s % i == 0) {
s /= i;
x = max(x, findp(r, i, p, q));
}
}
if (s > 1) x = max(x, findp(r, s, p, q));
}
cout << x << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, y = 0, ats = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
x += arr[i];
}
sort(arr, arr + n, greater<int>());
for (int i = 0; i < n; i++) {
y += arr[i];
ats++;
if (y > x / 2) {
break;
}
}
cout << ats;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool compare(int a, int b) { return a > b; }
class Compare {
public:
bool operator()(int a, int b) { return a > b; }
};
int mod(int a, int b) { return ((a % b) + b) % b; }
bool prime[5000];
vector<int> primes, ans;
int n, m;
void build_primes() {
primes = vector<int>();
for (int i = 0; i < 2000; i++) prime[i] = true;
prime[0] = prime[1] = false;
for (int i = 2; i <= 100; i++)
if (prime[i]) {
for (int j = i * i; j <= 1010; j += i) prime[j] = false;
}
for (int i = 0; i < 1000; i++)
if (prime[i]) primes.push_back(i);
}
int main() {
build_primes();
scanf("%d", &n);
ans = vector<int>();
for (int i = 0; i < primes.size(); i++) {
m = primes[i];
if (m > n) break;
for (int j = 0; j < 10; j++) {
for (int k = 2; k <= n; k++)
if (k % m == 0) {
ans.push_back(m);
break;
}
m *= primes[i];
}
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 50;
int n, m;
int a[maxn][maxn];
int b[maxn][maxn];
int t[maxn];
int mark[maxn][maxn];
bool check() {
memset(mark, 0, sizeof mark);
for (int i = 0, _n = (int)(n); i < _n; i++) {
for (int j = 0, _n = (int)(t[i]); j < _n; j++)
for (int k = (int)(j + 1), _n = (int)(t[i]); k < _n; k++) {
if (mark[b[i][j]][b[i][k]]) return true;
mark[b[i][j]][b[i][k]] = 1;
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++) scanf("%d", &a[i][j]);
int lo = 0, hi = 1e9 + 5;
while (hi - lo > 1) {
int md = (lo + hi) / 2;
for (int i = 0, _n = (int)(n); i < _n; i++) {
t[i] = 0;
for (int j = 0, _n = (int)(m); j < _n; j++)
if (a[i][j] >= md) b[i][t[i]++] = j;
}
if (check())
lo = md;
else
hi = md;
}
printf("%d\n", lo);
{
int _;
cin >> _;
return 0;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
bool f = 0;
char c = getchar();
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 1e6 + 5, mod = 998244353;
int ans, fac[N], inv[N], n, a[N], b[N];
char s[N];
int fpow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) res = 1ll * res * x % mod;
return res;
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = fpow(fac[n], mod - 2);
for (int i = n - 1; ~i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int C(int n, int m) {
if (n < m || m < 0) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
signed main() {
scanf("%s", s + 1);
n = strlen(s + 1);
init(n);
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1];
b[i] = b[i - 1];
a[i] += s[i] == '(';
b[i] += s[i] == '?';
}
for (int i = n, x = 0, y = 0; i; i--) {
x += s[i] == ')';
y += s[i] == '?';
ans = (ans + 1ll * a[i - 1] * C(b[i - 1] + y, a[i - 1] - x + b[i - 1]) +
1ll * b[i - 1] * C(b[i - 1] + y - 1, a[i - 1] - x + b[i - 1])) %
mod;
}
write(ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> factor(int number) {
map<int, int> fc;
for (int i = 2; i * i <= number; ++i) {
while (number % i == 0) {
fc[i]++;
number = number / i;
}
}
if (number != 1) {
fc[number]++;
}
return fc;
}
bool isDevider(int n) { return n == 2 || n == 3 || n == 5; }
int spow(int n, int p) {
int res = 1;
for (int i = 0; i < p; ++i) {
res *= n;
}
return res;
}
int bpow(int a, int b) {
if (b == 0) return 1;
int t = bpow(a, b / 2);
if (b & 1) return t * t * a;
return t * t;
}
int toNumber(const map<int, int>& factors) {
int res = 1;
for (const auto& f : factors) {
res *= spow(f.first, f.second);
}
return res;
}
int calc(int a, int b) {
if (a == b) {
return 0;
}
int res = 0;
auto factorA = factor(a);
auto factorB = factor(b);
for (int i : vector<int>{2, 3, 5}) {
res += abs(factorA[i] - factorB[i]);
while (a % i == 0) a /= i;
while (b % i == 0) b /= i;
}
return a == b ? res : -1;
}
int main() {
int a, b;
cin >> a >> b;
cout << calc(a, b) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class task {
vector<int> *g;
vector<int> cycle;
bool **visited;
bool *visited_bfs;
int *color;
int *p;
int N, start, end;
void get_data() {
int a, b;
scanf("%d", &N);
g = new vector<int>[N];
color = new int[N];
p = new int[N];
visited = new bool *[N];
for (int i = 0; i < (N); i++) {
color[i] = 0;
visited[i] = new bool[N];
for (int j = 0; j < (N); j++) visited[i][j] = false;
p[i] = -1;
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
}
bool dfs(const int &v) {
color[v] = 1;
const int len = g[v].size();
for (int i = 0; i < (len); i++) {
int to = g[v][i];
if (!visited[v][to]) {
if (color[to] == 0) {
p[to] = v;
visited[v][to] = true;
visited[to][v] = true;
if (dfs(to)) return true;
} else if (color[to] == 1) {
start = to;
end = v;
visited[v][to] = true;
visited[to][v] = true;
return true;
}
}
}
color[v] = 2;
return false;
}
void find_cycle() {
for (int i = 0; i < (N); i++) color[i] = -1;
for (int v = end; v != start; v = p[v]) {
color[v] = 0;
}
color[start] = 0;
}
void bfs() {
visited_bfs = new bool[N];
for (int i = 0; i < (N); i++) visited_bfs[i] = false;
queue<int> q;
q.push(start);
visited_bfs[start] = true;
int v, len, to, step;
while (!q.empty()) {
v = q.front();
q.pop();
len = g[v].size();
step = color[v];
step++;
for (int i = 0; i < (len); i++) {
to = g[v][i];
if (!visited_bfs[to]) {
if (color[to] == -1) color[to] = step;
visited_bfs[to] = true;
q.push(to);
}
}
}
}
public:
void decide_task() {
get_data();
for (int i = 0; i < (N); i++)
if (dfs(i)) break;
for (int i = 0; i < (N); i++) delete visited[i];
delete[] visited;
find_cycle();
delete[] p;
bfs();
delete[] g;
delete[] visited_bfs;
for (int i = 0; i < (N); i++) printf("%d ", color[i]);
delete[] color;
}
};
int main() {
task t;
t.decide_task();
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define int ll
#define M 1000000007
#define hell 998244353
#define inf 1e18
#define pb push_back
#define pi 3.1415926536
#define mp make_pair
#define ub upper_bound
#define lb lower_bound
#define all(a) a.begin(),a.end()
#define ll long long
#define vec vector <int>
#define pii pair<int,int>
#define endl "\n"
#define gcd __gcd
using namespace std;
int power(int x, unsigned int y, unsigned int m)
{
if (y == 0)
return 1;
int p = power(x, y/2, m) % m;
p = (p * p) % m;
return (y%2 == 0)? p : (x * p) % m;
}
int modInverse(int a, int m)
{
return power(a, m-2, m);
}
int nCrModPFermat(int n, int r, int p)
{
if (r==0)
return 1;
int fac[n+1];
fac[0] = 1;
for (int i=1 ; i<=n; i++)
fac[i] = fac[i-1]*i%p;
return (fac[n]* modInverse(fac[r], p) % p *
modInverse(fac[n-r], p) % p) % p;
}
signed main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll tt=1;
cin >> tt;
/*SAARE INPUTS LENA*/
/*VARIABLES KI RANGE DEKHLENA*/
/*EXPONENT RANGE OF OUTPUT KA DHYAN RAKHNA*/
while(tt-->0)
{
ll n=0;
cin>>n;
vector <int> v(n);
for (int i = 0; i < n; ++i)
{
cin>>v[i];
}
sort(all(v));
int ans=0;
for (int i = 0; i < n-2; ++i)
{
int it=ub(all(v),v[i]+2)-v.begin();
if((it)>=(n))
{
// cout<<"hi "<<i<<endl;
ans+=((n-1-i)*(n-2-i))/2;
}
else
{
int x=0;
x=max(i-i,it-i-1);
if(x>=2)
ans+=(x*(x-1))/2;
}
}
cout<<ans<<endl;
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000;
int main() {
int n, i, j, tot = 0, tmp;
scanf("%d", &n);
int arr[n + 10];
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
printf("%d\n", n + 1);
for (i = 0; i < n; i++) {
if (arr[n - 1 - i] + tot < mod - i - 1)
tmp = mod - i - 1 - arr[n - 1 - i] - tot;
else
tmp = mod - i - 1 - arr[n - 1 - i] - tot + mod;
printf("%d %d %d\n", 1, n - i, tmp);
tot = (tmp + tot) % mod;
}
printf("%d %d %d\n", 2, n, mod);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
const int INF = 0x3f3f3f3f;
const int LG = 19;
const int MOD = 1000000007;
int n;
int q;
int m;
int bio[N];
int cycle[N];
int depth[N];
bool is[N];
int pot2[N];
vector<int> graf[N], veze[N];
int dp[LG][N];
int sum[N];
vector<int> V;
int which_cycle;
inline void load() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
--x;
--y;
veze[x].push_back(y);
veze[y].push_back(x);
}
}
void find(int node, int par = -1) {
if (bio[node] == 1) return;
if (bio[node] == 2) {
for (int i = (int)V.size() - 1; i >= 0; i--) {
cycle[V[i]] = which_cycle;
if (V[i] == node) break;
}
which_cycle++;
return;
}
bio[node] = 2;
V.push_back(node);
for (int i = 0; i < veze[node].size(); i++) {
if (veze[node][i] != par) find(veze[node][i], node);
}
V.pop_back();
bio[node] = 1;
}
inline void DEBUG1() {
printf("CIKLUSI\n");
for (int i = 0; i < n; i++) {
printf("node == %d -> %d\n", i + 1, cycle[i]);
}
}
inline void find_cycles() {
which_cycle = n;
memset(cycle, -1, sizeof(cycle));
find(0);
}
inline void rebuild_graph() {
for (int i = 0; i < n; i++) {
if (cycle[i] == -1) cycle[i] = i, is[i] = true;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < veze[i].size(); j++) {
int x = cycle[i];
int y = cycle[veze[i][j]];
if (x == y) continue;
graf[x].push_back(y);
graf[y].push_back(x);
}
}
}
void dfs(int node, int par = -1, int dub = 0) {
depth[node] = dub;
if (!is[node]) sum[node]++;
if (par != -1) sum[node] += sum[par];
dp[0][node] = par;
bio[node] = 1;
for (int i = 0; i < graf[node].size(); i++) {
if (bio[graf[node][i]]) continue;
dfs(graf[node][i], node, dub + 1);
}
}
inline void precomputation_lca() {
memset(bio, 0, sizeof(bio));
memset(dp, -1, sizeof(dp));
dfs(cycle[0]);
for (int j = 1; j < LG; j++) {
for (int i = 0; i < n; i++) {
if (dp[j - 1][i] == -1) continue;
dp[j][i] = dp[j - 1][dp[j - 1][i]];
}
}
}
inline int lca(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
for (int i = LG - 1; i >= 0; i--) {
if (depth[x] - (1 << i) >= depth[y]) x = dp[i][x];
}
if (x == y) return x;
for (int i = LG - 1; i >= 0; i--) {
if (dp[i][x] != dp[i][y]) {
x = dp[i][x];
y = dp[i][y];
}
}
return dp[0][x];
}
inline void precompute_pot2() {
pot2[0] = 1;
for (int i = 1; i <= n; i++) {
pot2[i] = pot2[i - 1] * 2 % MOD;
}
}
inline void get_ansewer(int x, int y) {
int LCA = lca(x, y);
int ans = sum[x] + sum[y] - 2 * sum[LCA] + (is[LCA] == 0);
printf("%d\n", pot2[ans]);
}
inline void solve() {
find_cycles();
rebuild_graph();
n *= 2;
precomputation_lca();
precompute_pot2();
scanf("%d", &q);
for (; q; q--) {
int x, y;
scanf("%d %d", &x, &y);
--x;
--y;
x = cycle[x];
y = cycle[y];
get_ansewer(x, y);
}
}
int main(void) {
load();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = 45;
struct Node {
int x, y;
Node(int x, int y) : x(x), y(y) {}
};
int n, m, k, q, g[N][N], d[N][N][M];
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
bool vis[M];
vector<Node> c[N];
void bfs(int k) {
queue<Node> q;
memset(vis, false, sizeof(vis));
for (int i = 0; i < c[k].size(); i++) {
int x = c[k][i].x, y = c[k][i].y;
q.push(Node(x, y));
d[x][y][k] = 0;
}
vis[k] = true;
while (!q.empty()) {
Node t = q.front();
q.pop();
int dd = d[t.x][t.y][k];
int tc = g[t.x][t.y];
if (!vis[tc]) {
vis[tc] = true;
for (int i = 0; i < c[tc].size(); i++) {
int x = c[tc][i].x, y = c[tc][i].y;
if (d[x][y][k] == -1) {
d[x][y][k] = dd + 1;
q.push(Node(x, y));
}
}
}
for (int i = 0; i < 4; i++) {
int x = t.x + dx[i];
int y = t.y + dy[i];
if (x > 0 && y > 0 && x <= n && y <= m && d[x][y][k] == -1) {
d[x][y][k] = dd + 1;
q.push(Node(x, y));
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &g[i][j]);
c[g[i][j]].push_back(Node(i, j));
}
}
memset(d, -1, sizeof(d));
for (int i = 1; i <= k; i++) bfs(i);
scanf("%d", &q);
while (q--) {
int x1, x2, y1, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int ans = abs(x2 - x1) + abs(y2 - y1);
for (int i = 1; i <= k; i++)
ans = min(ans, d[x1][y1][i] + d[x2][y2][i] + 1);
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T a) {
return a >= 0 ? a : -a;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
T ret = a % b;
if (ret < 0) ret += b;
return ret;
}
long long mulmod(long long a, long long b, long long c) {
if (b == 0LL) return 0LL;
long long ret = mulmod(a, b >> 1, c);
ret = (ret + ret) % c;
if (b & 1LL) ret = (ret + a) % c;
return ret;
}
long long powmod(long long a, long long b, long long c) {
if (b == 0LL) return 1LL;
long long ret = powmod(a, b >> 1, c);
ret = ret * ret % c;
if (b & 1LL) ret = ret * a % c;
return ret;
}
template <class T>
inline T& rd(T& x) {
char c;
while (!isdigit((c = getchar())))
;
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
return x;
}
template <class T>
inline T& rdd(T& x) {
char c;
while ((c = getchar()), c != '-' && !isdigit(c))
;
if (c == '-') {
x = '0' - (c = getchar());
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
}
return x;
}
inline double& rf(double& x) {
char c;
while ((c = getchar()), c != '-' && c != '.' && !isdigit(c))
;
if (c == '-')
if ((c = getchar()) == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
} else {
x = '0' - c;
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
}
}
else if (c == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
}
}
return x;
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + '0');
else
write(x / 10), putchar(x % 10 + '0');
}
int tt;
int a, b, c, x, y, z;
int main() {
rd(a), rd(b), rd(c);
rd(x), rd(y), rd(z);
int sum = 0;
sum += (a >= x ? (a - x) / 2 : a - x);
sum += (b >= y ? (b - y) / 2 : b - y);
sum += (c >= z ? (c - z) / 2 : c - z);
puts(sum >= 0 ? "Yes" : "No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f[2100];
double l[1010], r[1010];
int main() {
int n, t;
scanf("%d%d", &n, &t);
int x, len;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &len);
l[i] = x - len * 1.0 / 2;
r[i] = x + len * 1.0 / 2;
}
for (int i = 1; i < n; i++)
for (int j = i + 1; j <= n; j++)
if (l[i] > l[j]) {
swap(l[i], l[j]);
swap(r[i], r[j]);
}
int ans = 2;
for (int i = 2; i <= n; i++) {
if (l[i] - r[i - 1] > t * 1.0)
ans += 2;
else if (l[i] - r[i - 1] == t * 1.0)
ans += 1;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char str[100003];
int x[100000], y[100000], z[100000];
int main() {
scanf("%s", str);
int len = strlen(str);
for (int i = 0; i < len; i++)
if (str[i] == 'x')
x[i] = 1;
else if (str[i] == 'y')
y[i] = 1;
else
z[i] = 1;
for (int i = 1; i < len; i++)
x[i] += x[i - 1], y[i] += y[i - 1], z[i] += z[i - 1];
int q, l, r;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
l--, r--;
if (r - l < 2) {
printf("YES\n");
continue;
}
int cx = x[r] - (l > 0 ? x[l - 1] : 0), cy = y[r] - (l > 0 ? y[l - 1] : 0),
cz = z[r] - (l > 0 ? z[l - 1] : 0);
if (cx == cy && abs(cz - cx) <= 1 || cy == cz && abs(cx - cy) <= 1 ||
cx == cz && abs(cy - cx) <= 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 105;
const int mod = 1e9 + 7;
int n, l, m;
struct Mat {
int a[M][M];
} p, one;
Mat Mul(Mat p1, Mat p2) {
Mat res;
int i, j, k;
for (i = 0; i < m; i = i + 1)
for (j = 0; j < m; j = j + 1) {
res.a[i][j] = 0;
for (k = 0; k < m; k = k + 1)
res.a[i][j] =
(res.a[i][j] + ((long long)p1.a[i][k] * p2.a[k][j]) % mod) % mod;
}
return res;
}
Mat fpow(Mat p1, int x) {
if (x == 0) return one;
if (x == 1) return p1;
Mat res;
res = fpow(p1, x / 2);
res = Mul(res, res);
if (x & 1) res = Mul(res, p1);
return res;
}
int t[1111111];
int b[M], c[M];
int main() {
int i, j, x;
long long ans;
scanf("%d%d%d", &n, &l, &m);
for (i = 1; i <= n; i = i + 1) {
scanf("%d", &x);
b[x % m]++;
}
for (i = 1; i <= n; i = i + 1) {
scanf("%d", t + i);
p.a[0][t[i] % m]++;
}
for (i = 1; i <= n; i = i + 1) {
scanf("%d", &x);
x += t[i];
c[x % m]++;
}
one.a[0][0] = 1;
for (i = 1; i < m; i = i + 1) {
one.a[i][i] = 1;
for (j = 0; j < m; j = j + 1) p.a[i][j] = p.a[0][(j - i + m) % m];
}
p = fpow(p, l - 2);
ans = 0;
for (i = 0; i < m; i = i + 1)
for (j = 0; j < m; j = j + 1)
ans =
(ans + ((long long)b[i] * c[j] % mod) * (p.a[(i + j) % m][0]) % mod) %
mod;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int stair[t + 5];
for (int i = 1; i <= t; i++) cin >> stair[i];
int step = 0;
int Count = 0;
vector<int> store;
for (int i = 1; i <= t; i++) {
step++;
if (stair[i] >= stair[i + 1] && i != t) {
store.push_back(step);
step = 0;
}
}
store.push_back(step);
cout << store.size() << endl;
for (int i = 0; i < store.size(); i++) cout << store[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int speed, ram, hdd, cost;
};
int main() {
int n, mincost = 1 << 30, ans;
node laptop[100] = {};
bool outdated;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> laptop[i].speed >> laptop[i].ram >> laptop[i].hdd >> laptop[i].cost;
}
for (int i = 0; i < n; ++i) {
outdated = false;
for (int j = 0; j < n && !outdated; ++j) {
if (laptop[i].speed < laptop[j].speed && laptop[i].ram < laptop[j].ram &&
laptop[i].hdd < laptop[j].hdd) {
outdated = true;
}
}
if (!outdated && laptop[i].cost < mincost) {
mincost = laptop[i].cost;
ans = i;
}
}
cout << ans + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long res = 0;
int mx, prmx;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
if (a > mx) {
prmx = mx;
mx = a;
} else {
prmx = max(prmx, a);
}
}
k++;
cout << 1ll * (m / k) * prmx + 1ll * (m - m / k) * mx;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
inline long long GCD(long long x, long long y) {
long long r = x % y;
while (r) {
x = y;
y = r;
r = x % y;
}
return y;
}
const long long N = 1e6 + 69;
bool is_prime[1000001];
void sieve() {
long long maxN = 1000000;
for (long long i = 1; i <= maxN; i++) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (long long i = 2; i * i <= maxN; i++) {
if (is_prime[i]) {
for (long long j = i * i; j <= maxN; j += i) {
is_prime[j] = false;
}
}
}
}
long long a[N], p[N];
vector<pair<long long, long long> > ans;
void sp(long long i, long long j) {
long long x = a[i], y = a[j];
a[j] = x, p[x] = j;
a[i] = y, p[y] = i;
ans.push_back({i, j});
}
signed main() {
sieve();
vector<long long> v;
for (long long i = 1; i < 1e6 - 2; i++) {
if (is_prime[i]) v.push_back(i);
}
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = i;
}
for (long long i = 1; i <= n; i++) {
long long pos = p[i];
;
while (pos - i > 0) {
auto it = upper_bound(v.begin(), v.end(), pos - i + 1);
it--;
long long j = *it;
;
sp(pos - j + 1, pos);
pos = pos - j + 1;
}
}
cout << (long long)ans.size() << '\n';
for (pair<long long, long long> op : ans)
cout << op.first << " " << op.second << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
cout << s;
for (register int i = s.length() - 1; i >= 0; i--) putchar(s[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
map<int, int> mp;
const int N = 2005;
int sum[N];
int main() {
int n, k;
int x;
sum[0] = 0;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
sum[i] = sum[i - 1] + x;
}
sort(sum + 1, sum + 1 + n);
int len = unique(sum + 1, sum + 1 + n) - (sum + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
for (int j = 1; j <= len; j++) {
int temp = x - sum[j];
vec.push_back(temp);
}
}
sort(vec.begin(), vec.end());
int num = 0;
for (int i = 0; i < vec.size(); i++) {
mp[vec[i]]++;
}
for (int i = 0; i < vec.size(); i++) {
if (mp[vec[i]] >= k) {
num++;
mp[vec[i]] = 0;
}
}
printf("%d\n", num);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
namespace fastio {
char rbuf[1 << 23], *p1 = rbuf, *p2 = rbuf, wbuf[1 << 23], *p3 = wbuf;
inline char getc() {
return p1 == p2 &&
(p2 = (p1 = rbuf) + fread(rbuf, 1, 1 << 23, stdin), p1 == p2)
? -1
: *p1++;
}
inline void putc(char x) { (*p3++ = x); }
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T neg = 0;
while (!isdigit(c)) neg |= !(c ^ '-'), c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (neg) x = (~x) + 1;
}
template <typename T>
void recursive_print(T x) {
return (!x) ? void() : (recursive_print(x / 10), putc(x % 10 ^ 48), void());
}
template <typename T>
void print(T x) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
}
template <typename T>
void print(T x, char c) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
putc(c);
}
void print_final() { fwrite(wbuf, 1, p3 - wbuf, stdout); }
} // namespace fastio
const int MAXN = 2e5;
const int MAXM = 5;
int n, m, qu;
long long a[MAXN + 5];
struct data {
int a[MAXM + 3];
data() { memset(a, 0, sizeof(a)); }
friend data operator+(data x, data y) {
data res;
for (int i = 1; i <= m + 1; i++) res.a[i] = y.a[x.a[i]];
return res;
}
};
struct node {
int l, r, rev;
data v[2];
} s[MAXN * 4 + 5];
void pushup(int k) {
s[k].v[0] = s[k << 1 | 1].v[0] + s[k << 1].v[0];
s[k].v[1] = s[k << 1 | 1].v[1] + s[k << 1].v[1];
}
void build(int k, int l, int r) {
s[k].l = l;
s[k].r = r;
if (l == r) {
for (int i = 1; i <= m; i++) {
s[k].v[a[l]].a[i] = s[k].v[a[l] ^ 1].a[i] = i + 1;
}
s[k].v[a[l]].a[m + 1] = 1;
s[k].v[a[l] ^ 1].a[m + 1] = m + 1;
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
pushup(k);
}
void pushdown(int k) {
if (s[k].rev) {
swap(s[k << 1].v[0], s[k << 1].v[1]);
s[k << 1].rev ^= 1;
swap(s[k << 1 | 1].v[0], s[k << 1 | 1].v[1]);
s[k << 1 | 1].rev ^= 1;
s[k].rev = 0;
}
}
void flip(int k, int l, int r) {
if (l <= s[k].l && s[k].r <= r)
return swap(s[k].v[0], s[k].v[1]), s[k].rev ^= 1, void();
int mid = (pushdown(k), s[k].l + s[k].r >> 1);
if (r <= mid)
flip(k << 1, l, r);
else if (l > mid)
flip(k << 1 | 1, l, r);
else
flip(k << 1, l, mid), flip(k << 1 | 1, mid + 1, r);
pushup(k);
}
data query(int k, int l, int r) {
if (l <= s[k].l && s[k].r <= r) return s[k].v[0];
int mid = (pushdown(k), s[k].l + s[k].r >> 1);
if (r <= mid)
return query(k << 1, l, r);
else if (l > mid)
return query(k << 1 | 1, l, r);
else
return query(k << 1 | 1, mid + 1, r) + query(k << 1, l, mid);
}
int main() {
scanf("%d%d%d", &n, &m, &qu);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), a[i] = (~a[i]) & 1;
build(1, 1, n);
while (qu--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int l, r;
long long x;
scanf("%d%d%lld", &l, &r, &x);
if (x & 1) flip(1, l, r);
} else {
int l, r;
scanf("%d%d", &l, &r);
data t = query(1, l, r);
printf("%d\n", 1 + (t.a[m + 1] == 1));
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
int root, parent[100100], val[100100], L[100100], R[100100];
int MIN[100100], MAX[100100];
int min_val(int i) {
if (MIN[i] > 0)
return MIN[i];
else if (L[i] == 0)
return MIN[i] = val[i];
else
return MIN[i] = min_val(L[i]);
}
int max_val(int i) {
if (MAX[i] > 0)
return MAX[i];
else if (R[i] == 0)
return MAX[i] = val[i];
else
return MAX[i] = max_val(R[i]);
}
pair<long long, int> memo[100100];
pair<long long, int> calc(int i) {
if (i == root) return {0, 0};
if (memo[i].first > 0) return memo[i];
int p = parent[i];
if (L[p] == i) {
auto y = calc(p);
y.first += min_val(R[p]);
y.second++;
return memo[i] = y;
} else {
auto y = calc(p);
y.first += max_val(L[p]);
y.second++;
return memo[i] = y;
}
}
map<int, int> min_key;
int goal(int k) {
auto it = min_key.upper_bound(k);
if (it == min_key.begin())
return it->second;
else
return prev(it)->second;
}
void calc_min_key(int i, int lb) {
if (L[i] == 0)
min_key[lb] = i;
else {
calc_min_key(L[i], lb);
calc_min_key(R[i], val[i]);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> parent[i] >> val[i];
for (int i = 1; i <= n; i++) {
if (parent[i] == -1)
root = i;
else if (val[parent[i]] > val[i])
L[parent[i]] = i;
else
R[parent[i]] = i;
}
calc_min_key(root, 0);
int k;
cin >> k;
while (k--) {
int q;
cin >> q;
int g = goal(q);
auto x = calc(g);
printf("%.10f\n", (double)x.first / x.second);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[3000][3000] = {0};
long long b[3000][3000] = {0};
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0, input; j < n; j++) {
scanf("%d", &input);
a[i][j] = input;
}
}
for (int i = 0; i < n; i++) {
long long oni = 0;
for (int j = 0; j < i + 1; j++) {
oni += a[i - j][j];
}
for (int j = 0; j < i + 1; j++) {
b[i - j][j] += oni;
}
}
for (int i = n - 1; i >= 1; i--) {
long long oni = 0;
for (int j = 0; j < n - i; j++) {
oni += a[i + j][n - j - 1];
}
for (int j = 0; j < n - i; j++) {
b[i + j][n - j - 1] += oni;
}
}
for (int i = n - 1; i >= 0; i--) {
long long oni = 0;
for (int j = 0; j < n - i; j++) {
oni += a[i + j][j];
}
for (int j = 0; j < n - i; j++) {
b[i + j][j] += oni;
}
}
for (int i = 0; i < n - 1; i++) {
long long oni = 0;
for (int j = 0; j <= i; j++) {
oni += a[i - j][n - j - 1];
}
for (int j = 0; j <= i; j++) {
b[i - j][n - j - 1] += oni;
}
}
long long max1 = -1;
int x1 = -1, y1 = -1;
long long max2 = -1;
int x2 = -1, y2 = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
b[i][j] -= a[i][j];
if ((i + j) & 1) {
if (max1 < b[i][j]) {
max1 = b[i][j];
x1 = i;
y1 = j;
}
} else {
if (max2 < b[i][j]) {
max2 = b[i][j];
x2 = i;
y2 = j;
}
}
}
}
cout << max1 + max2 << endl;
cout << x1 + 1 << " " << y1 + 1 << " " << x2 + 1 << " " << y2 + 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
const int MAXN = 1e5 + 10;
const int MAXP = 1e6 + 10;
const int MAXV = 1e7 + 10;
struct edge {
int to, nxt;
} e[MAXN << 1];
struct info {
int value, home;
bool type;
};
int tot, n, t;
int a[MAXN], depth[MAXN], prime[MAXP], head[MAXN], ans[MAXN], f[MAXV];
int cnt[MAXP][30], anc[MAXN][30];
vector<info> q[MAXN];
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline void addedge(int u, int v) {
t++;
e[t] = (edge){v, head[u]};
head[u] = t;
}
inline int power(int a, int n) {
int res = 1, b = a;
while (n > 0) {
if (n & 1) res = 1ll * res * b % P;
b = 1ll * b * b % P;
n >>= 1;
}
return res;
}
inline int inv(int x) { return power(x, P - 2); }
inline void dfs(int u, int fa) {
depth[u] = depth[fa] + 1;
for (int i = 1; i < 30; i++) {
if (depth[u] <= (1 << i)) break;
anc[u][i] = anc[anc[u][i - 1]][i - 1];
}
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
anc[v][0] = u;
depth[v] = depth[u] + 1;
dfs(v, u);
}
}
inline int lca(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
for (int i = 30 - 1; i >= 0; i--) {
if (depth[anc[v][i]] >= depth[u]) v = anc[v][i];
}
if (u == v) return u;
for (int i = 30 - 1; i >= 0; i--) {
if (anc[u][i] != anc[v][i]) u = anc[u][i], v = anc[v][i];
}
return anc[u][0];
}
inline void modify(int x, int delta) {
for (int i = 1; 1ll * prime[i] * prime[i] <= x; i++) {
if (x % prime[i] == 0) {
int p = 0;
while (x % prime[i] == 0) {
x /= prime[i];
p++;
}
cnt[i][p] += delta;
}
}
if (x != 1) {
int pos = lower_bound(prime + 1, prime + tot + 1, x) - prime;
cnt[pos][1] += delta;
}
}
inline int query(int x) {
int ret = 1;
for (int i = 1; 1ll * prime[i] * prime[i] <= x; i++) {
if (x % prime[i] == 0) {
int p = 0;
while (x % prime[i] == 0) {
p++;
x /= prime[i];
}
int s = 0;
for (int j = 1; j <= p; j++) s += cnt[i][j] * j;
for (int j = p + 1; j < 30; j++) s += cnt[i][j] * p;
ret = 1ll * ret * power(prime[i], s) % P;
}
}
if (x != 1) {
int pos = lower_bound(prime + 1, prime + tot + 1, x) - prime;
int s = 0;
for (int i = 1; i < 30; i++) s += cnt[pos][i];
ret = 1ll * ret * power(x, s) % P;
}
return ret;
}
inline void solve(int u, int fa) {
modify(a[u], 1);
for (unsigned i = 0; i < q[u].size(); i++) {
if (q[u][i].type)
ans[q[u][i].home] = 1ll * ans[q[u][i].home] * query(q[u][i].value) % P;
else
ans[q[u][i].home] =
1ll * ans[q[u][i].home] * inv(query(q[u][i].value)) % P;
}
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
solve(v, u);
}
modify(a[u], -1);
}
int main() {
read(n);
for (int i = 2; i < MAXV; i++) {
if (!f[i]) {
f[i] = i;
prime[++tot] = i;
}
for (int j = 1; j <= tot; j++) {
int tmp = i * prime[j];
if (tmp >= MAXV) break;
f[tmp] = prime[j];
if (prime[j] == f[i]) break;
}
}
for (int i = 1; i < n; i++) {
int u, v;
read(u);
read(v);
addedge(u, v);
addedge(v, u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) read(a[i]);
int Q;
read(Q);
for (int i = 1; i <= Q; i++) {
int u, v, x;
read(u);
read(v);
read(x);
int Lca = lca(u, v);
q[u].push_back((info){x, i, true});
q[v].push_back((info){x, i, true});
q[Lca].push_back((info){x, i, false});
if (Lca != 1) q[anc[Lca][0]].push_back((info){x, i, false});
ans[i] = 1;
}
solve(1, 0);
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5) + 10;
int n, a[N], b[N], sub[N], prv[N];
bool was[N], has[N];
vector<int> ans;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
has[a[i]] = 1;
b[a[i]]++;
if (b[a[i]] == 2) sub[a[i]] = i - prv[a[i]];
if (b[a[i]] > 2 && sub[a[i]] != i - prv[a[i]]) was[a[i]] = 1;
prv[a[i]] = i;
}
for (int i = 1; i <= 100000; ++i)
if (has[i] && !was[i]) ans.push_back(i);
cout << ans.size() << '\n';
for (int i = 0; i < ((int)ans.size()); ++i)
cout << ans[i] << ' ' << sub[ans[i]] << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
vector<long long int> v(n + 1);
map<long long int, long long int> pre, pre1;
for (long long int i = 1; i <= n; i++) {
cin >> v[i];
}
long long int ans = 0;
for (long long int i = n; i >= 1; i--) {
if (pre1[v[i]] == 0)
pre1[v[i]] = i;
else if (ans == 0)
ans = i;
}
long long int en = ans;
for (long long int i = 1; i <= n; i++) {
if (pre[v[i]] == 0) {
en = max(en, pre1[v[i]]);
pre[v[i]] = i;
ans = min(ans, en - i);
} else
break;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int blocked1[100010], blocked2[100010];
int main() {
long long n, q, a, b, lastblock1 = 0, lastblock2 = 0, block = 0;
cin >> n >> q;
for (int j = 0; j < q; j++) {
cin >> a >> b;
if (a == 1) {
if (blocked1[b] == 1) {
if (blocked2[b]) block--;
if (blocked2[b - 1]) block--;
if (blocked2[b + 1]) block--;
blocked1[b] = 0;
} else {
if (blocked2[b]) block++;
if (blocked2[b - 1]) block++;
if (blocked2[b + 1]) block++;
blocked1[b] = 1;
}
} else {
if (blocked2[b]) {
if (blocked1[b]) block--;
if (blocked1[b - 1]) block--;
if (blocked1[b + 1]) block--;
blocked2[b] = 0;
} else {
if (blocked1[b]) block++;
if (blocked1[b - 1]) block++;
if (blocked1[b + 1]) block++;
blocked2[b] = 1;
}
}
int lst;
if (block == 0)
cout << "YES" << endl;
else if (block > 0)
cout << "NO" << endl;
else
lst = 1 / 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int vis[109];
int len[109];
int main() {
int n;
cin >> n;
string w;
for (int i = 0; i < n; ++i) {
cin >> w;
for (int j = 0; j < w.length(); ++j) vis[i] |= 1 << (w[j] - 'a');
len[i] = w.length();
}
int mx = 0, sel;
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j) {
sel = 0;
int k = (1 << i) | (1 << j);
for (int u = 0; u < n; ++u)
if ((k & vis[u]) == vis[u]) sel += len[u];
mx = max(mx, sel);
}
cout << mx << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10, inf = 1e9 + 10;
int n, m, mc[maxn], mat[maxn], cen, ans = inf;
vector<int> adj[maxn];
bitset<maxn> mark, fmat;
bool dfs(int v) {
if (mark[v] || v == cen) return false;
mark[v] = true;
for (auto u : adj[v])
if (u != cen && (mat[u] == -1 || dfs(mat[u]))) {
mat[u] = v;
return true;
}
return false;
}
int matching(int cnt = 0) {
fmat.reset();
memset(mat, -1, sizeof(mat));
bool find = true;
while (find) {
find = false;
mark.reset();
for (int i = 0; i < n; i++)
if (!fmat[i] && dfs(i)) {
fmat[i] = find = true;
cnt++;
}
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0, v, u; i < m; i++) {
cin >> v >> u;
v--, u--;
mc[v]++;
if (v != u) mc[u]++;
adj[v].push_back(u);
}
for (cen = 0; cen < n; cen++) {
int len = matching();
ans = min(ans, (m - mc[cen] - len) + (n - 1 - len) + (2 * n - 1 - mc[cen]));
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long double PI = acos(-1);
const long double eps = 0.0000000001;
const long long INF = 0x3fffffffffffffff;
long long n, lim, x[100005], y[100005], rkx[100005], rky[100005], ans = INF;
long long pulled[100005];
struct cmpx {
bool operator()(const long long &A, const long long &B) {
return x[A] < x[B];
}
};
struct cmpy {
bool operator()(const long long &A, const long long &B) {
return y[A] < y[B];
}
};
std::map<long long, std::vector<long long>> X;
std::map<long long, std::vector<long long>> Y;
std::multiset<long long> ax, ay;
signed main() {
std::ios::sync_with_stdio(false);
std::cin >> n >> lim;
for (long long i = 1; i <= n; ++i) {
static long long sx, sy, ex, ey;
std::cin >> sx >> sy >> ex >> ey;
x[i] = sx + ex;
y[i] = sy + ey;
X[x[i]].push_back(i);
Y[y[i]].push_back(i);
ax.insert(x[i]);
ay.insert(y[i]);
}
long long used = 0;
for (auto i = X.begin(); true; ++i) {
for (auto j = Y.begin(); true; ++j) {
for (auto k = X.rbegin(); true; ++k) {
for (auto l = Y.rbegin(); true; ++l) {
ans = std::min(
ans, std::max(1ll, (*ax.rbegin() - *ax.begin() + 1) / 2) *
std::max(1ll, (*ay.rbegin() - *ay.begin() + 1) / 2));
for (auto o : l->second) {
if (!pulled[o]) {
++used;
pulled[o] = 4;
ax.erase(ax.find(x[o]));
ay.erase(ay.find(y[o]));
}
if (used > lim) break;
}
if (used > lim) {
while (true) {
for (auto o : l->second) {
if (pulled[o] == 4) {
--used;
pulled[o] = 0;
ax.insert(x[o]);
ay.insert(y[o]);
}
}
if (l == Y.rbegin())
break;
else
--l;
}
break;
}
}
for (auto o : k->second) {
if (!pulled[o]) {
++used;
pulled[o] = 3;
ax.erase(ax.find(x[o]));
ay.erase(ay.find(y[o]));
}
if (used > lim) break;
}
if (used > lim) {
while (true) {
for (auto o : k->second) {
if (pulled[o] == 3) {
--used;
pulled[o] = 0;
ax.insert(x[o]);
ay.insert(y[o]);
}
}
if (k == X.rbegin())
break;
else
--k;
}
break;
}
}
for (auto o : j->second) {
if (!pulled[o]) {
++used;
pulled[o] = 2;
ax.erase(ax.find(x[o]));
ay.erase(ay.find(y[o]));
}
if (used > lim) break;
}
if (used > lim) {
while (true) {
for (auto o : j->second) {
if (pulled[o] == 2) {
--used;
pulled[o] = 0;
ax.insert(x[o]);
ay.insert(y[o]);
}
}
if (j == Y.begin())
break;
else
--j;
}
break;
}
}
for (auto o : i->second) {
if (!pulled[o]) {
++used;
pulled[o] = 1;
ax.erase(ax.find(x[o]));
ay.erase(ay.find(y[o]));
}
if (used > lim) break;
}
if (used > lim) {
while (true) {
for (auto o : i->second) {
if (pulled[o] == 1) {
--used;
pulled[o] = 0;
ax.insert(x[o]);
ay.insert(y[o]);
}
}
if (i == X.begin())
break;
else
--i;
}
break;
}
}
std::cout << ans << std::endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long s, x;
scanf("%lld%lld", &s, &x);
if ((s - x) & 1ll) {
puts("0");
return 0;
}
long long a = (s - x) / 2;
long long ans = 0;
int b = 0;
long long i = 40;
for (; i >= 0; i--) {
if (x & (1ll << i)) {
if (a & (1ll << i)) {
puts("0");
return 0;
} else
ans++;
} else if (a & (1ll << i))
b++;
}
printf("%lld\n", (1ll << ans) - (b == 0 && ans > 0 ? 2 : 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long v[100003], st[100003], dr[100003], unu[100003];
int main() {
long long n, i, dr_max = 0, st_max = 0, ans = 0;
cin >> n;
for (i = 1; i < n; i++) cin >> v[i];
for (i = 2; i <= n; i++)
if (v[i - 1] > 1) st[i] = st[i - 1] + (v[i - 1] / 2) * 2;
for (i = n - 1; i >= 1; i--)
if (v[i] > 1) dr[i] = dr[i + 1] + (v[i] / 2) * 2;
for (i = 2; i <= n; i++) unu[i] = unu[i - 1] + ((v[i - 1] + 1) / 2) * 2 - 1;
for (i = 1; i <= n; i++) {
dr_max = dr[i] + unu[i];
st_max = max(st_max, st[i] - unu[i]);
ans = max(ans, st_max + dr_max);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b != 0) {
d = exgcd(b, a % b, y, x);
y -= (a / b) * x;
} else
x = 1, y = 0;
return d;
}
inline long long get_inverse(long long a, long long mod) {
long long x, y;
exgcd(a, mod, x, y);
return (mod + x % mod) % mod;
}
const int Maxn = 100005;
int n;
long long mod, inv10;
long long ans;
long long fact[Maxn] = {1}, invf[Maxn] = {1};
struct Edge {
int to;
Edge *nxt;
long long w;
} e[Maxn << 1];
Edge *head[Maxn];
Edge *edge_cur;
inline void add_edge(int u, int v, long long w) {
*edge_cur = (Edge){v, head[u], w};
head[u] = edge_cur++;
}
int sz[Maxn];
bool vis[Maxn];
int root, mnson, tot;
void get_root(int u, int par) {
sz[u] = 1;
int mxson = 0;
for (Edge *i = head[u]; i; i = i->nxt) {
if ((i->to) == par || vis[(i->to)]) continue;
get_root((i->to), u), sz[u] += sz[(i->to)];
mxson = max(mxson, sz[(i->to)]);
}
mxson = max(mxson, tot - sz[u]);
if (mnson > mxson) {
mnson = mxson;
root = u;
}
}
map<long long, long long> mp;
void dfs1(int u, int par, long long d, long long base) {
mp[d]++;
for (Edge *i = head[u]; i; i = i->nxt) {
if ((i->to) == par || vis[(i->to)]) continue;
dfs1((i->to), u, (d + (i->w) * base) % mod, base * 10 % mod);
}
}
long long dfs2(int u, int par, long long d, long long dep) {
long long res = mp[(mod - d * invf[dep] % mod) % mod];
for (Edge *i = head[u]; i; i = i->nxt) {
if ((i->to) == par || vis[(i->to)]) continue;
res += dfs2((i->to), u, (d * 10 + (i->w)) % mod, dep + 1);
}
return res;
}
long long solve(int u, long long dis) {
mp.clear();
dfs1(u, -1, dis % mod, dis ? 10 : 1);
return dfs2(u, -1, dis % mod, dis ? 1 : 0) - (dis == 0);
}
void divide_tree(int u) {
vis[u] = true;
ans += solve(u, 0);
for (Edge *i = head[u]; i; i = i->nxt) {
if (vis[(i->to)]) continue;
ans -= solve((i->to), (i->w));
mnson = 0x3f3f3f3f;
tot = sz[(i->to)], root = -1;
get_root((i->to), u);
divide_tree(root);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cout << fixed << setprecision(12);
cin >> n >> mod;
inv10 = get_inverse(10, mod);
for (int i = 1; i <= n; ++i) {
fact[i] = fact[i - 1] * 10 % mod;
invf[i] = invf[i - 1] * inv10 % mod;
}
edge_cur = e;
for (int i = 1; i < n; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
++u, ++v;
add_edge(u, v, w);
add_edge(v, u, w);
}
mnson = 0x3f3f3f3f;
tot = n, root = -1;
get_root(1, -1);
divide_tree(root);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (a[0] > 1) a[0] = 1;
for (long long i = 1; i < n; i++) {
if (a[i] >= a[i - 1] + 1) a[i] = a[i - 1] + 1;
}
cout << a[n - 1] + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
string word;
vector<string> words;
vector<vector<long long> > hshs;
map<long long, int> gd;
map<long long, pair<long long, int> > hashes;
bool bad(char c) {
if (c == '.' || c == ',' || c == ' ' || c == '?' || c == '!' || c == 39 ||
c == '-')
return true;
return false;
}
vector<long long> getHash(string second) {
vector<long long> ans;
long long hsh = 0, c = 31, cc = 1;
for (int i = 0; i < second.size(); i++) {
second[i] -= 'a';
second[i]++;
hsh += cc * second[i];
ans.push_back(hsh);
cc *= c;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
int sum = 0;
string second;
while (getline(cin, second)) {
sum++;
string curWord;
for (int i = 0; i < second.size(); i++) {
if (bad(second[i])) {
sum++;
if (curWord.size()) {
words.push_back(curWord);
curWord.clear();
}
} else {
curWord += second[i];
}
}
if (curWord.size()) {
words.push_back(curWord);
}
}
for (int i = 0; i < words.size(); i++) {
hshs.push_back(getHash(words[i]));
}
for (int i = 0; i < words.size(); i++) {
sum++;
int ptr = 1;
while (ptr < words[i].size()) {
long long curHash = hshs[i][ptr - 1];
if (gd[curHash] == 1 &&
hshs[i][hashes[curHash].second - 1] == hashes[curHash].first &&
hashes[curHash].second != ptr) {
ptr = hashes[curHash].second;
sum++;
} else {
ptr++;
sum++;
}
}
for (int j = 0; j < words[i].size(); j++) {
gd[hshs[i][j]]++;
if (hashes[hshs[i][j]] ==
make_pair(hshs[i].back(), (int)words[i].size())) {
gd[hshs[i][j]]--;
}
hashes[hshs[i][j]] = {hshs[i].back(), words[i].size()};
}
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long pow(long long c, long long d) { return d == 0 ?: c * pow(c, d - 1); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (k >= n) {
cout << 1 << endl;
continue;
}
if (n % k == 0) {
cout << n / k << endl;
continue;
}
vector<long long> v;
v.push_back(1);
v.push_back(n);
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
if (i == n / i)
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
sort(v.begin(), v.end());
long long x = lower_bound(v.begin(), v.end(), k) - v.begin();
long long val = v[x];
if (val == k) {
cout << n / val << endl;
continue;
} else {
val = v[x - 1];
cout << n / val << endl;
continue;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, c;
char S[105];
char str[20][101] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE",
"GIN", "RUM", "SAKE", "TEQUILA",
"VODKA", "WHISKEY", "WINE"};
while (scanf("%d", &n) == 1) {
k = 0;
for (i = 0; i < n; i++) {
scanf("%s", S);
c = 0;
if (isdigit(S[0])) {
if (atoi(S) <= 17) k++;
} else {
for (j = 0; j < 11; j++)
if (!strcmp(S, str[j])) {
c = 1;
break;
}
if (c) k++;
}
}
printf("%d\n", k);
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
int t;
cin>>t;
while(t--){
long long n,k,i;
cin>>n>>k;
vector<long long> arrindex(k);
vector<long long > arrtemp(k);
for(i=0; i<k; i++)cin>>arrindex[i];
for(i=0; i<k; i++)cin>>arrtemp[i];
// long long val,minval;
// for(long long j = 1; j<=n; j++ ){
// minval = INT_MAX;
// for(i=0; i<k; i++){
// val = arrtemp[i] + abs(arrindex[i]-j);
// minval = min(val,minval);
// }
// cout<<minval<<" ";
// }
vector<long long>arrac(n+1,INT_MAX);
vector<bool>arrpos(n+1,false);
for(i=0; i<k; i++){
arrpos[arrindex[i]]=true;
arrac[arrindex[i]] = arrtemp[i];
}
long long minval = INT_MAX;
for(i=1; i<=n; i++){
if(arrpos[i]){
minval = min(minval,arrac[i]);
}
arrac[i] = minval;
minval++;
}
// for(i=1; i<=n; i++){
// cout<<i<<" "<<arrac[i]<<" "<<arrpos[i]<<endl;
// }
minval = arrac[n];
for(i=n; i>0; i--){
if(arrpos[i]){
minval = min(minval,arrac[i]);
}
arrac[i] = min(minval,arrac[i]);
minval++;
}
//cout<<endl;
// for(i=1; i<=n; i++){
// cout<<i<<" "<<arrac[i]<<" "<<arrpos[i]<<endl;
// }
for(i=1; i<=n; i++){
cout<<arrac[i]<<" ";
}
cout<<endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization
int main() {
long long n, k, i = 0;
string s;
cin >> n >> k;
cin >> s;
if (s.length() == 1) {
if (k == 0) return cout << s, 0;
cout << 0;
return 0;
}
while (i < n && k != 0) {
if (i == 0) {
if (s[i] > '1') {
k--;
s[i] = '1';
}
} else {
if (s[i] != '0') {
k--;
s[i] = '0';
}
}
i++;
}
cout << s << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long t[200005], d[200005], n, ans[200005], b, head, tail;
int main() {
cin >> n >> b;
for (int i = 1; i <= n; i++) cin >> t[i] >> d[i];
for (int i = 1; i <= n; i++) {
while (ans[head] <= t[i] && head < tail) head++;
if (head == tail) {
ans[tail] = t[i] + d[i];
cout << ans[tail] << " ";
tail++;
} else {
if (tail - head > b)
cout << "-1 ";
else {
ans[tail] = ans[tail - 1] + d[i];
cout << ans[tail] << " ";
tail++;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
long long a, m;
cin >> a >> m;
long long g = gcd(a, m);
long long temp_m = m / g;
vector<long long> primes;
for (long long i = 2; i * i <= temp_m; i++) {
if (temp_m % i == 0) {
primes.push_back(i);
}
while (temp_m % i == 0) {
temp_m /= i;
}
}
if (temp_m > 1) {
primes.push_back(temp_m);
}
int n = primes.size();
long long start = a / g;
long long end = a / g + m / g - 1;
long long solution = end - start + 1;
for (int i = 1; i < (1 << n); i++) {
bitset<10> bit_set(i);
long long num = 1;
int parity = 0;
for (int j = 0; j < n; j++) {
if (bit_set[j] == 1) {
num *= primes[j];
parity++;
}
}
long long ans = end / num - start / num;
if (parity % 2 == 0) {
solution += ans;
} else {
solution -= ans;
}
}
cout << solution << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
int n;
vector<int> ask(const vector<int> &v) {
if (v.empty()) {
return vector<int>(n, INT_MAX);
}
cout << v.size() << "\n";
for (auto i : v) {
cout << i + 1 << " ";
}
cout << "\n";
cout.flush();
vector<int> ans(n);
for (int i = (0); i < (n); ++i) {
cin >> ans[i];
}
return ans;
}
vector<int> ans[10][2];
vector<int> gen(int bit, int j, int n) {
vector<int> query;
for (int i = (0); i < (n); ++i) {
if (!!(i & (1 << bit)) == j) {
query.push_back(i);
}
}
return query;
}
int main() {
cin >> n;
for (int i = (0); i < (10); ++i) {
for (int j = (0); j < (2); ++j) {
ans[i][j] = ask(gen(i, j, n));
}
}
cout << -1 << "\n";
for (int i = (0); i < (n); ++i) {
int minc = INT_MAX;
for (int j = (0); j < (10); ++j) {
if (i & (1 << j)) {
minc = min(minc, ans[j][0][i]);
} else {
minc = min(minc, ans[j][1][i]);
}
}
cout << minc << " ";
}
cout << "\n";
cout.flush();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int64_t M1 = 998244353;
const int64_t M2 = 1000000007;
void solve() {
int64_t n, k, ans = 0;
cin >> n >> k;
int64_t l[2], r[2];
for (int64_t i : {0, 1}) cin >> l[i] >> r[i];
int64_t x = max(int64_t(0), min(r[0], r[1]) - max(l[0], l[1]));
k -= min(k, x * n);
for (int64_t i = 1; i <= n && k; i++) {
int64_t y = min(k, max(r[0], r[1]) - min(l[0], l[1]) - x);
int64_t cost = y + max((int64_t)0, max(l[1], l[0]) - min(r[0], r[1]));
if (i >= 2) cost = min(cost, y * 2);
ans += cost;
k -= y;
}
if (k) ans += k * 2;
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int64_t t;
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
const int N = 100010;
int a[N], cnt[N];
long long dp[N][2];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
dp[1][1] = cnt[1];
for (int i = 2; i <= 100000; i++) {
dp[i][1] = std::max(dp[i][1], dp[i - 1][0] + 1LL * cnt[i] * i);
dp[i][0] = std::max(dp[i][0], dp[i - 1][1]);
dp[i][0] = std::max(dp[i][0], dp[i - 1][0]);
}
printf("%I64d\n", std::max(dp[100000][0], dp[100000][1]));
return 0;
}
| 3 |
//��CF1450G
#include<iostream>
#include<cstdio>
#include<fstream>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<bitset>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;
typedef double DB;
const int N = 33;
const int W = 1<<20;
const int M = 5555;
int n,w,m,a,b,l[N],r[N],c[N],d[N],g[N],h[N];
bool f[W];
char s[M];
pair<pair<int,int>,pair<int,int> > p[N];
vector<int> v;
int main()
{
int i,j,x,y,z;
scanf("%d%d%d%s",&m,&a,&b,s+1);
for(i=0;i<26;i=i+1)
l[i]=m+1,r[i]=0;
for(i=1;i<=m;i=i+1){
x=s[i]-'a';
l[x]=min(l[x],i);
r[x]=max(r[x],i);
c[x]++;
}
for(i=0;i<26;i=i+1)
p[i]=make_pair(make_pair(l[i],r[i]),make_pair(c[i],i));
sort(p,p+26);
for(i=0;i<26;i=i+1)
if(l[i]<=m)
n++;
w=1<<n;
for(i=0;i<n;i=i+1){
l[i]=p[i].first.first;
r[i]=p[i].first.second;
c[i]=p[i].second.first;
d[i]=p[i].second.second;
g[i]=(1<<i)-1;
h[i]=w-(1<<i);
}
f[0]=1;
for(i=1;i<w;i=i+1){
for(j=1;j<n;j=j+1)
f[i]|=f[i&g[j]]&f[i&h[j]];
x=m+1,y=0,z=0;
for(j=0;j<n;j=j+1){
if(i&(1<<j)){
x=min(x,l[j]);
y=max(y,r[j]);
z+=c[j];
}
}
if((y-x+1)*a>z*b)
continue;
for(j=0;j<n;j=j+1)
if(i&(1<<j))
f[i]|=f[i^(1<<j)];
}
for(i=0;i<n;i=i+1)
if(f[(w-1)^(1<<i)])
v.push_back(d[i]);
sort(v.begin(),v.end());
printf("%d",v.size());
for(i=0;i<v.size();i=i+1)
printf(" %c",v[i]+'a');
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2010;
const int MAX_M = 201;
const long long INF = 1000000000000000000;
const long long P = 998244353;
const int SIGMA = 28;
int n, h, l, r;
int A[MAX_N];
int memo[MAX_N][MAX_N];
int pd(int i, int hi) {
if (i == n) return 0;
if (memo[i][hi] != -1) return memo[i][hi];
int st1 = (h + hi + A[i] - 1) % h;
int st2 = (h + hi + A[i]) % h;
return memo[i][hi] =
max(pd(i + 1, (h + hi + A[i] - 1) % h) + (l <= st1 && st1 <= r),
pd(i + 1, (h + hi + A[i]) % h) + (l <= st2 && st2 <= r));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> h >> l >> r;
for (int i = 0; i < n; i++) cin >> A[i];
memset(memo, -1, sizeof(memo));
cout << pd(0, 0) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> store;
vector<vector<long long>> dp;
long long solve(long long index, long long depth) {
if (index == store.size() - 1) return 0;
if (dp[index][depth] != -1) return dp[index][depth];
long long ans;
if (store[index] > store[depth]) {
ans = 1 + solve(index + 1, depth);
ans = min(ans, solve(index + 1, index) + store[index] - store[depth]);
} else
ans = solve(index + 1, index);
dp[index][depth] = ans;
return ans;
}
int32_t main() {
long long n;
cin >> n;
store.resize(n + 1);
dp.resize(n);
for (long long i = 0; i < n; ++i) {
cin >> store[i];
dp[i].resize(n + 1, -1);
}
cout << solve(0, n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
double a[N], f[N], ans;
vector<int> G[N];
int fa[N];
void dfs(int F, int u) {
fa[u] = F;
for (int v : G[u]) {
if (v != F) {
f[u] += a[v];
dfs(u, v);
}
}
ans -= f[u] * a[u];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = 1 - a[i];
ans += a[i];
}
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(n, 0);
cin >> q;
while (q--) {
int u;
double x;
cin >> u >> x;
x = 1 - x;
ans = ans - a[u] + x;
ans = ans + f[u] * (a[u] - x);
if (u) {
ans = ans + f[fa[u]] * a[fa[u]];
f[fa[u]] = f[fa[u]] - a[u] + x;
ans = ans - f[fa[u]] * a[fa[u]];
}
a[u] = x;
printf("%.10f\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxx = 3e5 + 10;
int n;
int l[maxn];
int r[maxn];
int v[maxn];
int lazy[4 * maxx];
pair<int, int> seg[4 * maxx];
pair<int, pair<int, int>> ans;
vector<pair<pair<pair<int, int>, int>, int>> Q;
void in();
void solve();
void doit();
void make(int id, int l, int r);
pair<int, int> get(int id, int l, int r, int L, int R);
void upd(int id, int l, int r, int L, int R, int val);
void push(int id);
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i] >> v[i] >> r[i];
r[i]++;
}
}
bool cmp(pair<pair<pair<int, int>, int>, int> a,
pair<pair<pair<int, int>, int>, int> b) {
if (a.first.first.first == b.first.first.first) return a.second > b.second;
return a.first.first.first < b.first.first.first;
}
void solve() {
make(1, 0, maxx);
for (int i = 0; i < n; i++) {
Q.push_back({{{l[i], l[i]}, r[i]}, 1});
Q.push_back({{{l[i], l[i]}, v[i]}, -1});
Q.push_back({{{v[i] + 1, v[i] + 1}, r[i]}, -1});
Q.push_back({{{r[i], l[i]}, r[i]}, -1});
Q.push_back({{{v[i], l[i]}, v[i]}, 1});
Q.push_back({{{r[i], v[i] + 1}, r[i]}, 1});
}
sort(Q.begin(), Q.end(), cmp);
doit();
}
void make(int id, int l, int r) {
seg[id] = {0, l};
if (r - l == 1) return;
int mid = (l + r) >> 1;
make(id << 1, l, mid);
make(id << 1 | 1, mid, r);
}
void doit() {
for (int i = 0; i < Q.size(); i++) {
auto x = Q[i];
upd(1, 0, maxx, x.first.first.second, x.first.second, x.second);
if (i == Q.size() - 1 ||
x.first.first.first != Q[i + 1].first.first.first) {
auto oof = get(1, 0, maxx, x.first.first.first, maxx);
if (oof.first > ans.first)
ans = {oof.first, {x.first.first.first, oof.second}};
}
}
}
pair<int, int> get(int id, int l, int r, int L, int R) {
if (r <= L || R <= l) return {0, l};
if (L <= l && r <= R) {
return seg[id];
}
push(id);
int mid = (l + r) >> 1;
return max(get(id << 1, l, mid, L, R), get(id << 1 | 1, mid, r, L, R));
}
void upd(int id, int l, int r, int L, int R, int val) {
if (r <= L || R <= l) return;
if (L <= l && r <= R) {
seg[id].first += val;
lazy[id] += val;
return;
}
push(id);
int mid = (l + r) >> 1;
upd(id << 1, l, mid, L, R, val);
upd(id << 1 | 1, mid, r, L, R, val);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
void push(int id) {
seg[id << 1].first += lazy[id];
seg[id << 1 | 1].first += lazy[id];
lazy[id << 1] += lazy[id];
lazy[id << 1 | 1] += lazy[id];
lazy[id] = 0;
}
void out() {
cout << ans.first << '\n';
for (int i = 0; i < n; i++)
if (l[i] <= ans.second.first && ans.second.second < r[i] &&
ans.second.first <= v[i] && v[i] <= ans.second.second)
cout << i + 1 << ' ';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long pow2(long long x, long long y) {
if (y == 0) return 1;
long long tmp = pow2(x, y / 2);
tmp = (tmp * tmp) % 1000000009;
if (y & 1) tmp = (tmp * x) % 1000000009;
return tmp;
}
long long inv(long long x) { return pow2(x, 1000000009 - 2); }
long long n, a, b, k;
string s;
void code() {
cin >> n >> a >> b >> k >> s;
long long ans = 0;
for (int i = 0; i < k; i++) {
long long tmp = pow2(a, n - i) * pow2(b, i);
tmp %= 1000000009;
if (s[i] == '+')
ans += tmp;
else
ans -= tmp;
ans %= 1000000009;
}
long long x = (n + 1) / k;
long long bak = (b * inv(a)) % 1000000009;
bak = pow2(bak, k);
if (bak != 1) {
long long tmp = (pow2(bak, x) - 1) % 1000000009;
tmp = (tmp * inv(bak - 1)) % 1000000009;
ans *= tmp;
} else {
ans *= x;
}
ans %= 1000000009;
if (ans < 0) ans = (ans + 1000000009) % 1000000009;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
code();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x = (1 << 26) - 1;
int ans = 0;
while (--n) {
char c;
cin >> c;
string s;
cin >> s;
long long y = 0;
for (int i = 0; s[i]; ++i) {
y |= 1 << (s[i] - 'a');
}
if (c == '!') {
ans += (__builtin_popcount(x) == 1);
x &= y;
} else if (c == '.') {
x &= y ^ ((1 << 26) - 1);
} else {
ans += (__builtin_popcount(x) == 1);
x &= ~(1 << (s[0] - 'a'));
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
const int INF = 100000000;
int n, k;
char s1[maxn], s2[maxn];
int dp[2][maxn];
struct Node {
int pos, t, side;
Node() {}
Node(int a, int b, int c) { pos = a, t = b, side = c; }
} q[2 * maxn];
bool find1;
void bfs() {
int head = 0, rear = 0;
Node cur, next;
cur.pos = 0, cur.t = 0, cur.side = 0;
q[rear++] = cur;
dp[0][0] = 0;
while (head < rear) {
next = q[head++];
if (next.side == 0) {
if (next.pos == n - 1) {
find1 = 1;
break;
}
if (s1[next.pos + 1] != 'X' && next.pos + 1 >= next.t + 1 &&
dp[0][next.pos + 1] > next.t + 1) {
dp[0][next.pos + 1] = next.t + 1;
q[rear++] = Node(next.pos + 1, next.t + 1, 0);
}
if (s1[next.pos - 1] != 'X' && next.pos - 1 >= next.t + 1 &&
dp[0][next.pos - 1] > next.t + 1) {
dp[0][next.pos - 1] = next.t + 1;
q[rear++] = Node(next.pos - 1, next.t + 1, 0);
}
if (next.pos + k >= n) {
find1 = 1;
break;
}
if (s2[next.pos + k] != 'X' && next.pos + k >= next.t + 1 &&
dp[1][next.pos + k] > next.t + 1) {
dp[1][next.pos + k] = next.t + 1;
q[rear++] = Node(next.pos + k, next.t + 1, 1);
}
} else {
if (next.pos == n - 1) {
find1 = 1;
break;
}
if (s2[next.pos + 1] != 'X' && next.pos + 1 >= next.t + 1 &&
dp[1][next.pos + 1] > next.t + 1) {
dp[1][next.pos + 1] = next.t + 1;
q[rear++] = Node(next.pos + 1, next.t + 1, 1);
}
if (s2[next.pos - 1] != 'X' && next.pos - 1 >= next.t + 1 &&
dp[1][next.pos - 1] > next.t + 1) {
dp[1][next.pos - 1] = next.t + 1;
q[rear++] = Node(next.pos - 1, next.t + 1, 1);
}
if (next.pos + k >= n) {
find1 = 1;
break;
}
if (s1[next.pos + k] != 'X' && next.pos + k >= next.t + 1 &&
dp[0][next.pos + k] > next.t + 1) {
dp[0][next.pos + k] = next.t + 1;
q[rear++] = Node(next.pos + k, next.t + 1, 0);
}
}
}
}
int main() {
while (scanf("%d%d", &n, &k) == 2) {
scanf("%s%s", s1, s2);
for (int i = 0; i <= n; i++) dp[0][i] = dp[1][i] = INF;
find1 = 0;
bfs();
puts(find1 ? "YES" : "NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 805;
const int type = 0;
int n, p[N], times;
int m3[N], m5[N], m7[N];
int m2[N], m4[N], m8[N];
int ans[N], pos[N];
void init() {
srand(time(NULL));
for (int i = (int)(1); i <= (int)(n); i++) p[i] = i;
random_shuffle(p + 1, p + n + 1);
if (p[1] > n / 2)
for (int i = (int)(1); i <= (int)(n); i++) p[i] = n - p[i] + 1;
}
int query(vector<int> a) {
++times;
if (type == 0) {
printf("? %d ", a.size());
for (auto i : a) printf("%d ", i);
puts("");
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
} else {
int sum = 0;
for (auto i : a) sum += p[i];
return sum % a.size() == 0;
}
}
void find1n() {
int cnt = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
vector<int> tmp;
for (int j = (int)(1); j <= (int)(n); j++)
if (j != i) tmp.push_back(j);
if (query(tmp)) {
if (!cnt)
ans[i] = 1, pos[1] = i;
else
ans[i] = n, pos[n] = i;
if (++cnt == 2) break;
}
}
}
void findodd() {
for (int i = (int)(1); i <= (int)(n); i++)
if (!ans[i]) {
vector<int> tmp;
tmp.push_back(i);
tmp.push_back(pos[1]);
m2[i] = query(tmp);
}
}
void findbf(int times) {
for (int R = (int)(1); R <= (int)(times); R++) {
int cnt = 0;
static int q[N];
q[0] = 0;
for (int i = (int)(1); i <= (int)(n); i++)
if (!ans[i]) q[++*q] = i;
for (int i = (int)(1); i <= (int)(*q); i++) {
vector<int> tmp;
for (int j = (int)(1); j <= (int)(*q); j++)
if (j != i) tmp.push_back(q[j]);
if (query(tmp)) {
int x = q[i];
ans[x] = R + 1;
if ((ans[x] + m2[x]) & 1) ans[x] = n - ans[x] + 1;
pos[ans[x]] = x;
}
}
}
}
vector<int> op[10];
void solve(int *m, int v) {
int p = -1;
for (int i = (int)(0); i <= (int)(v - 1); i++)
if (!op[i].size()) p = i;
assert(p != -1);
for (int i = (int)(1); i <= (int)(n); i++)
if (!ans[i]) {
m[i] = -1;
for (int j = (int)(0); j <= (int)(v - 1); j++)
if (op[j].size()) {
vector<int> tmp = op[j];
tmp.push_back(i);
if (query(tmp)) {
m[i] = j;
break;
}
}
if (m[i] == -1) m[i] = p;
}
}
void find3() {
op[0].push_back(pos[1]);
op[0].push_back(pos[2]);
op[1].push_back(pos[1]);
op[1].push_back(pos[4]);
op[2].resize(0);
solve(m3, 3);
}
void find5() {
int v = (1 + 2 + 3 + (n - 3)) % 5;
for (int i = (int)(0); i <= (int)(4); i++) op[i].resize(0);
for (int i = (int)(0); i <= (int)(3); i++) {
int vv = (10 - (v + 3 - i)) % 5;
for (int j = (int)(1); j <= (int)(3); j++) op[vv].push_back(pos[j]);
op[vv].push_back(pos[n - i]);
}
solve(m5, 5);
}
void find7() {
for (int i = (int)(0); i <= (int)(6); i++) op[i].resize(0);
for (int i = (int)(1); i <= (int)(4); i++) {
int v = (7 - (1 + 2 + 3 + 4 - i + (n - 3) + (n - 2) + (n - 1)) % 7) % 7;
for (int j = (int)(1); j <= (int)(4); j++)
if (j != i) op[v].push_back(pos[j]);
for (int j = (int)(1); j <= (int)(3); j++) op[v].push_back(pos[n - j]);
}
for (int i = (int)(1); i <= (int)(2); i++) {
int v = (7 - (2 + 3 + 4 + n + n + n - 3 - 2 - 1 + i) % 7) % 7;
for (int j = (int)(2); j <= (int)(4); j++) op[v].push_back(pos[j]);
for (int j = (int)(0); j <= (int)(3); j++)
if (j != i) op[v].push_back(pos[n - j]);
}
solve(m7, 7);
}
void find4() {
for (int i = (int)(1); i <= (int)(n); i++)
if (!ans[i]) {
vector<int> tmp;
tmp.push_back(pos[1]);
tmp.push_back(pos[2]);
tmp.push_back(pos[m2[i] + 3]);
tmp.push_back(i);
m4[i] = (m2[i] + (query(tmp) ^ m2[i] ? 2 : 0));
}
}
void find8() {
for (int i = (int)(1); i <= (int)(n); i++)
if (!ans[i]) {
vector<int> tmp;
for (int j = (int)(1); j <= (int)(4); j++)
if (j % 4 != m4[i]) tmp.push_back(pos[j]);
for (int j = (int)(0); j <= (int)(3); j++) tmp.push_back(pos[n - j]);
tmp.push_back(i);
m8[i] = (m4[i] + (query(tmp) ^ (m4[i] == 0) ? 4 : 0));
}
}
void output() {
if (ans[1] > n / 2)
for (int i = (int)(1); i <= (int)(n); i++) ans[i] = n + 1 - ans[i];
if (type == 0) {
printf("!");
for (int i = (int)(1); i <= (int)(n); i++) printf(" %d", ans[i]);
fflush(stdout);
} else {
cout << times << ' ' << 18 * n << endl;
for (int i = (int)(1); i <= (int)(n); i++)
if (ans[i] != p[i]) printf("GG %d %d %d\n", i, ans[i], p[i]);
}
}
int main() {
scanf("%d", &n);
if (type == 1) init();
if (n == 2) {
printf("! 1 2\n");
fflush(stdout);
return 0;
}
find1n();
findodd();
if (n <= 40)
findbf(n / 2 - 1);
else {
findbf(3);
find3();
find5();
find7();
find4();
find8();
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++)
if (j % 3 == m3[i] && j % 5 == m5[i] && j % 7 == m7[i] &&
j % 8 == m8[i])
ans[i] = j;
}
output();
}
| 13 |
#include <bits/stdc++.h>
const int N = (5e5);
const long long INF = (long long)(2e9) + 7;
using namespace std;
int n, k, a[N], mx;
string s, ans;
map<string, int> M;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s;
for (int i = 0; i <= (int)(s.size()) - 2; ++i) {
M[s.substr(i, 2)]++;
}
for (auto it : M) {
if (it.second > mx) {
mx = it.second;
ans = it.first;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1000000007;
const long long INF = 1e18;
const int MX = 200005;
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long powmod(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long modinv(long long n, long long p) { return powmod(n, MOD - 2, MOD); }
void max_self(long long &a, long long b) { a = max(a, b); }
long long getAdd(long long x) {
long long m1 = 10, m2 = 0;
while (x > 0) {
long long y = x % 10;
x /= 10;
m1 = min(m1, y);
m2 = max(m2, y);
}
return m1 * m2;
}
int main(int argc, char const *argv[]) {
cin.tie(0);
int n, a[MX];
cin >> n;
map<int, int> make_pair;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) ++make_pair[a[i] + a[j]];
int mx = 0;
for (auto x : make_pair) {
mx = max(mx, x.second);
}
cout << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
int mx = -1000000000;
for (int i = 0; i < n; i++) {
int x, y;
cin >> y >> x;
if (x > k) {
mx = max(mx, y - (x - k));
} else
mx = max(mx, y);
}
cout << mx;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 0;
cin >> t;
while (t--) {
int n = 0;
cin >> n;
for (int i = 0; i < n; ++i) cout << i + 1 << ' ';
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1000555], Stack[1000555];
int top, Ans;
int main() {
fgets(s, 1000005, stdin);
top = 0;
Ans = 0;
for (int i = 0; s[i] != '\n'; i++) {
if (s[i] == '{')
Stack[++top] = '{';
else if (s[i] == '[')
Stack[++top] = '[';
else if (s[i] == '<')
Stack[++top] = '<';
else if (s[i] == '(')
Stack[++top] = '(';
else {
if (top == 0) {
puts("Impossible");
return 0;
}
if (s[i] == '}') {
if (Stack[top] != '{') Ans++;
} else if (s[i] == ']') {
if (Stack[top] != '[') Ans++;
} else if (s[i] == ')') {
if (Stack[top] != '(') Ans++;
} else if (s[i] == '>') {
if (Stack[top] != '<') Ans++;
}
top--;
}
}
if (top > 0) {
puts("Impossible");
return 0;
}
printf("%d\n", Ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
const int maxn = 500000 + 7;
const int maxp = 107;
int n, k, p;
int Data[maxn];
int room[maxp][maxn];
int least[maxp];
void update(int *room, int x, int value) {
x++;
while (x <= p) {
room[x] = min(room[x], value);
x += x & -x;
}
}
int query(int *room, int x) {
x++;
int rt = inf;
while (x) {
rt = min(rt, room[x]);
x -= x & -x;
}
return rt;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 1; i <= n; i++) scanf("%d", &Data[i]);
for (int i = 1; i <= n; i++) Data[i] = (Data[i - 1] + Data[i]) % p;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= p; j++) {
room[i][j] = inf;
}
for (int i = 0; i <= k; i++) least[i] = inf;
update(room[0], 0, 0);
least[0] = min(least[0], 0);
for (int i = 1; i < n; i++) {
for (int j = k - 1; j >= 0; j--) {
int u = query(room[j], Data[i]);
if (u != inf) {
update(room[j + 1], Data[i], u);
least[j + 1] = min(least[j + 1], u);
}
u = least[j];
if (u != inf) {
update(room[j + 1], Data[i], u + 1);
least[j + 1] = min(least[j + 1], u + 1);
}
}
}
int ans = inf;
int u = query(room[k - 1], Data[n]);
if (u != inf) {
ans = min(ans, u * p + Data[n]);
}
u = least[k - 1];
if (u != inf) {
ans = min(ans, u * p + p + Data[n]);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
int sum = 0, cnt = 0;
while (sum <= n) {
sum += 3;
std::cout << 3;
++cnt;
}
std::cout << "\n";
for (int i = 0; i < cnt - 1; ++i) {
std::cout << "6";
}
std::cout << 7;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename F>
double ternary_search(double lb, double ub, double prec, F fun) {
for (;;) {
if (ub - lb < prec) return (ub + lb) / 2;
double lmid = (2 * lb + ub) / 3, umid = (lb + 2 * ub) / 3;
if (fun(lmid) > fun(umid))
lb = lmid;
else
ub = umid;
}
}
struct dist {
double l, a, b;
dist(double l, double a, double b) : l(l), a(a), b(b) {}
double operator()(double x) {
double h = sqrt(l * l - x * x);
return (h * a + b * x - x * h) / l;
}
};
int main() {
int a, b, l;
cin >> a >> b >> l;
if (a > b) swap(a, b);
double ret;
if (l <= a)
ret = l;
else if (l <= b)
ret = a;
else {
dist fun(l, a, b);
double x0 = ternary_search(0, l, 1e-8, fun);
ret = fun(x0);
}
if (ret < 1e-8)
puts("My poor head =(");
else
printf("%.7f\n", ret);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
double pi = 3.141592653589793238;
const int MM = 1000000007;
const int Nmax = 5005;
const int M = 1000000007;
const int N = 3050;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int T = 1;
cin >> T;
while (T--) {
long long int m;
cin >> m;
if (m < 2) {
cout << "1\n";
} else if (m % 4 > 1) {
cout << (((((((m + 2) / 4 + 1) % M) * (((m + 2) / 4 + 1) % M) -
(m + 2) / 4 - 1) %
M) +
M) %
M)
<< "\n";
} else {
cout << (((((m + 2) / 4 + 1) % M) * (((m + 2) / 4 + 1) % M)) % M) << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<bool> > vused, hused;
int n, m;
void vertical(int y) {
for (int i = 0; i < n; ++i) {
vused[i][y] = true;
}
}
void horizontal(int x) {
for (int i = 0; i < n; ++i) {
hused[x][i] = true;
}
}
void process(int x, int y) {
if (!vused[x][y]) vertical(y);
if (!hused[x][y]) horizontal(x);
}
int test(int y) {
int ans = 0;
if (!vused[0][y]) ++ans;
if (!hused[y][0]) ++ans;
if (!hused[n - y - 1][0]) ++ans;
if (!vused[0][n - y - 1]) ++ans;
return ans;
}
int main() {
scanf("%d%d", &n, &m);
vused.resize(n);
hused.resize(n);
for (int i = 0; i < n; ++i) {
vused[i].resize(n);
hused[i].resize(n);
}
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
process(x, y);
}
int ans = 0;
for (int i = 1; i < n / 2; ++i) {
ans += test(i);
}
if (n % 2 == 1 && (!vused[0][n / 2] || !hused[n / 2][0])) ++ans;
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int fast(long long int n, long long int a, long long int m) {
if (n == 0)
return 1;
else if (n == 1)
return a;
else {
long long int r = fast(n / 2, a, m);
if (n % 2 == 0) {
return (((r % m) * (r % m)) % m);
} else {
return (((((r % m) * a) % m) * r) % m);
}
}
}
int main() {
string s;
cin >> s;
int n = s.length();
bool dp[n + 1][n + 1];
int p[n + 1][n + 1];
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
dp[i][j] = false;
if (i == j) {
dp[i][j] = true;
}
p[i][j] = 0;
}
}
for (i = 1; i <= n; i++) {
for (j = i - 1; j >= 1; j--) {
if (i == j + 1) {
if (s[i - 1] == s[j - 1]) dp[j][i] = true;
} else {
if (s[i - 1] == s[j - 1]) dp[j][i] |= dp[j + 1][i - 1];
}
}
}
for (j = 1; j <= n; j++) {
for (i = j; i >= 1; i--) {
if (i == j)
p[i][j] = 1;
else {
p[i][j] = p[i + 1][j] + p[i][j - 1] - p[i + 1][j - 1] +
(dp[i][j] == true ? 1 : 0);
}
}
}
int Q;
cin >> Q;
int L, R;
while (Q--) {
scanf("%d%d", &L, &R);
long long int ans = p[L][R];
printf("%lld\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long l = -1, r = n + 1;
while (r - l > 1) {
long long m = (l + r) / 2;
if ((n - m) * (n - m + 1) / 2 - m > k)
l = m;
else
r = m;
}
cout << r;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int g;
cin >> n;
int* a = new int[n];
int* b = new int[n];
int x0;
int x1;
int d0;
int d1;
int m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
b[0] = 0;
b[1] = 0;
d0 = a[1] - a[0];
x0 = a[1];
m = 2;
while ((m < n) && ((a[m] - x0) == d0)) {
x0 = a[m];
b[m] = 0;
++m;
}
if (m == n) {
cout << a[0] << "\n" << a[1];
for (int i = 2; i < n; ++i) cout << " " << a[i];
cout << "\n";
return 0;
}
b[m] = 1;
x1 = a[m];
g = 0;
int tmp;
g = 2;
for (int j = -1; j < 2; ++j) {
if (g == 2) {
int i;
if (j > -1) {
d0 = a[2] - a[j];
x1 = a[1 - j];
x0 = a[2];
b[0] = j;
b[1] = 1 - j;
b[2] = 0;
i = 3;
} else {
i = m + 1;
}
g = 0;
for (; i < n; ++i) {
if ((a[i] - x0) == d0) {
if (g == 0) {
tmp = x1;
d1 = a[i] - x1;
x1 = a[i];
b[i] = 1;
for (int k = i + 1; k < n; ++k) {
if ((a[k] - x1) == d1) {
x1 = a[k];
b[k] = 1;
} else {
g = 2;
break;
}
}
if (g == 2) {
x1 = tmp;
g = 0;
} else
break;
}
if (g && ((a[i] - x1) == d1)) {
tmp = x0;
x0 = a[i];
b[i] = 0;
for (int k = i + 1; k < n; ++k) {
if ((a[k] - x0) == d0) {
x0 = a[k];
b[k] = 0;
} else {
g = 2;
break;
}
}
if (g == 2) {
g = 0;
x0 = tmp;
x1 = a[i];
b[i] = 1;
for (int k = i + 1; k < n; ++k) {
if ((a[k] - x1) == d1) {
x1 = a[k];
b[k] = 1;
} else {
g = 2;
break;
}
}
}
break;
} else {
b[i] = 0;
x0 = a[i];
}
} else if (g) {
if ((a[i] - x1) == d1) {
b[i] = 1;
x1 = a[i];
} else {
g = 2;
break;
}
} else {
g = 1;
b[i] = 1;
d1 = a[i] - x1;
x1 = a[i];
}
}
}
}
if (g == 2)
cout << "No solution\n";
else {
for (int i = 0; i < n; ++i) {
if (b[i] == 0) {
if (a[i] == x0)
cout << x0;
else
cout << a[i] << " ";
}
}
cout << "\n";
for (int i = 0; i < n; ++i) {
if (b[i] == 1) {
if (a[i] == x1)
cout << x1;
else
cout << a[i] << " ";
}
}
cout << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using ll = long long int;
using namespace std;
ll power(ll n, ll k) {
ll res = 1;
while (k) {
if (k & 1) {
res *= n;
k--;
} else {
n *= n;
k /= 2;
}
}
return res;
}
void solve() {
ll n;
cin >> n;
vector<ll> a(n), b(n);
for (auto &it : a) cin >> it;
for (auto &it : b) cin >> it;
vector<pair<ll, ll> > vp;
for (ll i = 0; i < n; i++) {
vp.push_back({a[i], b[i]});
}
sort(vp.begin(), vp.end());
ll mx = vp[n - 1].first;
ll sum = 0;
ll k = 0;
for (ll i = n - 2; i >= 0; i--) {
sum += vp[i + 1].second;
k = max(sum, vp[i].first);
mx = min(mx, k);
}
sum += vp[0].second;
mx = min(mx, sum);
cout << mx << endl;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(NULL);
int tc;
cin >> tc;
for (; tc--;) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int total = 0;
int arr[105][210];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * m; j++) {
scanf("%d", &arr[i][j]);
if (j % 2 != 0) {
if (arr[i][j] == 1 || arr[i][j - 1] == 1) {
total++;
}
}
}
}
printf("%d\n", total);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long num, bigcity, b, sum, sum2, bsum;
int arr[100005];
int big[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> num >> bigcity;
for (int i = 1; i <= num; i++) {
cin >> arr[i];
sum += arr[i];
}
for (int i = 1; i <= bigcity; i++) {
cin >> big[i];
}
for (int i = 1; i <= bigcity; i++) {
sum2 += (sum - arr[big[i]]) * arr[big[i]];
}
for (int i = 1; i <= bigcity; i++) {
bsum += arr[big[i]];
}
for (int i = 1; i <= bigcity; i++) {
sum2 -= (bsum - arr[big[i]]) * arr[big[i]];
bsum -= arr[big[i]];
}
for (int i = 1; i <= bigcity; i++) {
arr[big[i]] = 0;
}
for (int i = 1; i <= num - 1; i++) {
sum2 += arr[i] * arr[i + 1];
}
sum2 += arr[1] * arr[num];
cout << sum2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5 + 5;
int n, q;
int l[mxn], r[mxn], fa[mxn];
struct comp {
bool operator()(int a, int b) { return l[a] < l[b]; }
};
set<int, comp> top, son[mxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (son[y].size() < son[x].size()) son[x].swap(son[y]);
for (int s : son[x]) son[y].insert(s);
fa[x] = y;
l[y] = min(l[y], l[x]);
r[y] = max(r[y], r[x]);
}
void chkson(int i, int x) {
set<int, comp>::iterator it;
l[n] = x;
it = son[i].lower_bound(n);
if (it != son[i].begin()) {
--it;
if (r[*it] > x) {
int j = *it;
chkson(j, x);
son[i].erase(j);
merge(j, i);
}
}
}
int main() {
scanf("%d", &q);
while (q--) {
int t, x, y;
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
int i = n++;
fa[i] = i;
int Left = -1, Right = -1;
set<int, comp>::iterator it;
l[i] = x;
it = top.lower_bound(i);
if (it != top.begin()) {
--it;
if (r[*it] > x) Left = *it;
}
l[i] = y;
it = top.lower_bound(i);
if (it != top.begin()) {
--it;
if (r[*it] > y) Right = *it;
}
l[i] = x;
r[i] = y;
if (Left != -1) {
merge(Left, i);
top.erase(Left);
}
if (Right != -1) {
merge(Right, i);
top.erase(Right);
}
l[n] = x;
it = top.lower_bound(n);
while (it != top.end() && r[*it] <= r[i]) {
son[i].insert(*it);
it = top.erase(it);
}
chkson(i, x);
chkson(i, y);
top.insert(i);
} else {
--x;
--y;
x = find(x);
y = find(y);
if (l[y] <= l[x] && r[x] <= r[y])
puts("YES");
else
puts("NO");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++i)
#define per(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; --i)
#define REP(i, a) rep(i, 0, a)
#define PER(i, a) per(i, a, 0)
const int MAXN = 1e6 + 10;
const int P = 1e9 + 7;
int N, prod[MAXN], inv[MAXN];
int combine(int n, int m) { // \binom{n}{m}
if (n < m) return 0;
return 1ll * prod[n] * inv[m] % P * inv[n - m] % P;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
#endif
scanf("%d", &N);
prod[0] = 1;
rep(i, 1, MAXN) prod[i] = 1ll * prod[i - 1] * i % P;
inv[1] = inv[0] = 1;
rep(i, 2, MAXN) inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
rep(i, 1, MAXN) inv[i] = 1ll * inv[i] * inv[i - 1] % P;
int ans = 0;
rep(x, 1, N + 1) if (~x & 1) {
(ans += 2ll * ((combine(x - 1, N - 1 - x) + combine(x, N - x)) % P) % P * prod[x] % P) %= P;
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 111;
vector<vector<int>> adj;
bool c[MAX][MAX];
vector<int> m1, m2, seen;
vector<int> d[2], id[2];
int n, m;
void build(int x, int j, int t) {
int k = sqrt(x) + 1;
for (int i = 2; i <= k; ++i) {
while (x % i == 0) {
d[t].push_back(i);
id[t].push_back(j);
x /= i;
}
}
if (x > 1) {
d[t].push_back(x);
id[t].push_back(j);
}
}
int t;
bool dfs(int v) {
for (int u : adj[v]) {
if (seen[u] == t) continue;
seen[u] = t;
if (m2[u] == -1 || dfs(m2[u])) {
m1[v] = u;
m2[u] = v;
return true;
}
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
build(x, i, i % 2 == 1);
}
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
c[x][y] = c[y][x] = true;
}
int sz = max(d[0].size(), d[1].size());
adj.assign(sz, vector<int>());
for (int i = 0; i < d[0].size(); ++i) {
for (int j = 0; j < d[1].size(); ++j) {
if (d[0][i] == d[1][j] && c[id[0][i]][id[1][j]]) {
adj[i].push_back(j);
}
}
}
m1.resize(sz, -1);
m2.resize(sz, -1);
seen.resize(sz);
int res = 0;
for (int i = 0; i < d[0].size(); ++i) {
t++;
res += dfs(i);
}
cout << res << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int boss;
vector<int> adrel;
vector<int> rmrel;
vector<pair<int, int>> qry;
vector<node*> child;
void set(int x) {
boss = x;
adrel.clear();
rmrel.clear();
child.clear();
qry.clear();
}
} man[111111];
vector<int> store[111111];
bool ans[111111], qryon[111111];
int GetBoss(int x) {
if (man[x].boss == x) {
return x;
}
return man[x].boss = GetBoss(man[x].boss);
}
void VisitTree(const node& root) {
for (int i = 0; i < root.adrel.size(); ++i) {
qryon[root.adrel[i]] = true;
}
for (int i = 0; i < root.qry.size(); ++i) {
int x = root.qry[i].first;
int y = root.qry[i].second;
if (qryon[x]) {
store[x].push_back(y);
}
}
for (int i = 0; i < root.rmrel.size(); ++i) {
int x = root.rmrel[i];
if (qryon[x]) {
for (int j = 0; j < store[x].size(); ++j) {
ans[store[x][j]] = true;
}
}
}
for (int i = 0; i < root.child.size(); ++i) {
VisitTree(*(root.child[i]));
}
for (int i = 0; i < root.qry.size(); ++i) {
int x = root.qry[i].first;
if (qryon[x]) {
store[x].pop_back();
}
}
for (int i = 0; i < root.adrel.size(); ++i) {
qryon[root.adrel[i]] = false;
}
}
int main() {
int n, m, docct, qryct;
while (scanf("%d%d", &n, &m) != EOF) {
docct = qryct = 0;
for (int i = 1; i <= n; ++i) {
man[i].set(i);
store[i].clear();
}
int t;
for (int i = 1; i <= m; ++i) {
scanf("%d", &t);
if (t == 1) {
int x, y;
scanf("%d%d", &x, &y);
man[x].boss = y;
man[y].child.push_back(&man[x]);
} else if (t == 2) {
int x, y;
++docct;
scanf("%d", &x);
y = GetBoss(x);
man[y].adrel.push_back(docct);
man[x].rmrel.push_back(docct);
} else {
int x, y;
++qryct;
scanf("%d%d", &x, &y);
man[x].qry.push_back(make_pair(y, qryct));
}
}
for (int i = 1; i <= qryct; ++i) {
qryon[i] = false;
}
for (int i = 1; i <= n; ++i) {
if (man[i].boss == i) {
VisitTree(man[i]);
}
}
for (int i = 1; i <= qryct; ++i) {
if (ans[i]) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
long long int dy[] = {0, -1, -1, -1, 0, 1, 1, 1};
long long int dxx[] = {1, -1, 0, 0};
long long int dyy[] = {0, 0, -1, 1};
long long int modexpo(long long int x, long long int y) {
if (y == 0) return 1;
if (y % 2) {
long long int viky = modexpo(x, y / 2);
return (((x * viky) % 998244353) * viky) % 998244353;
} else {
long long int viky = modexpo(x, y / 2);
return (viky * viky) % 998244353;
}
}
bool isvalid(long long int x, long long int y, long long int n,
long long int m) {
return (x >= 0 && x < n && y >= 0 && y < m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, q;
cin >> n >> q;
long long int ap[n + 11];
for (long long int i = 0; i < n; i++) {
cin >> ap[i];
}
map<long long int, long long int> mp, mp_left, mp_right;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
mp[ap[i]]++;
if (mp_left.find(ap[i]) != mp_left.end()) {
mp_right[ap[i]] = i;
} else {
mp_left[ap[i]] = i;
mp_right[ap[i]] = i;
}
}
long long int cnt = mp_right[ap[0]];
long long int maxi = mp[ap[0]];
long long int left_val = 0;
for (long long int i = 0; i < n; i++) {
if (i <= cnt) {
cnt = max(cnt, mp_right[ap[i]]);
maxi = max(maxi, mp[ap[i]]);
} else {
long long int val = i - left_val;
ans += (val - maxi);
left_val = i;
cnt = mp_right[ap[i]];
maxi = mp[ap[i]];
}
}
long long int val = n - left_val;
ans += (val - maxi);
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110, K = 100010, INF = 1234567890;
int n, m, i, j, a[N], mx, id, ans;
int main() {
scanf("%d", &n);
scanf("%d", &m);
n--;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
while (1) {
mx = 0;
for (i = 0; i < n; i++) {
if (a[i] > mx) {
mx = a[i];
id = i;
}
}
if (mx < m) {
printf("%d\n", ans);
return 0;
}
a[id]--;
m++;
ans++;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[303][303];
int pos[303];
int main() {
cin >> n;
for (int i = (0), _b(n + 1); i < _b; i++)
for (int j = (0), _b(n); j < _b; j++) {
cin >> a[i][j];
a[i][j]--;
}
for (int i = (0), _b(n); i < _b; i++) pos[a[n][i]] = i;
int res[303];
for (int i = (0), _b(n); i < _b; i++) {
for (int j = (0), _b(n); j < _b; j++) {
if (a[i][j] == i) continue;
bool fl = true;
for (int t = (0), _b(a[i][j]); t < _b; t++)
if (pos[t] < pos[a[i][j]] && t != i) {
fl = false;
break;
}
if (fl) {
res[i] = a[i][j] + 1;
break;
}
}
}
for (int i = (0), _b(n); i < _b; i++) cout << res[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long A, B;
long long res = 0;
char buf[20];
long long rev(long long x) {
sprintf(buf, "%I64d", x);
int len = strlen(buf);
long long y = 0;
int i;
for (i = 0; i < len; i++) y = y * 10 + (9 - (buf[i] - '0'));
return y;
}
void check(long long tmp) {
long long z = rev(tmp);
long long x = tmp * z;
if (x > res) res = x;
}
int main() {
scanf("%I64d %I64d", &A, &B);
long long x = 10;
int i;
check(A);
check(B);
for (i = 0; i < 10; i++) {
long long target = x / 2;
if (A <= target && target <= B) check(target);
target--;
if (A <= target && target <= B) check(target);
x *= 10;
}
printf("%I64d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int B[n][m];
for (int _n(n), i(0); i < _n; i++)
for (int _n(m), j(0); j < _n; j++) cin >> B[i][j];
int a, b;
cin >> a >> b;
int ans = 1000000001;
for (int _n(2), it(0); it < _n; it++) {
for (int i = 0; i + a <= n; ++i)
for (int j = 0; j + b <= m; ++j) {
int s = 0;
for (int _n(a), ii(0); ii < _n; ii++)
for (int _n(b), jj(0); jj < _n; jj++) s += B[ii + i][jj + j];
ans = min(s, ans);
}
swap(a, b);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s[100010];
int ans[100010];
set<char> se;
map<char, int> mp;
char mpi[26];
int sz;
int main() {
cin >> n >> k;
cin >> s;
for (int i = 0; i < n; i++) se.insert(s[i]);
for (auto c : se) {
mpi[sz] = c;
mp[c] = sz++;
}
for (int i = 0; i < n; i++) {
ans[i] = mp[s[i]];
}
if (n == k) {
ans[n - 1]++;
for (int i = n - 1; i; i--) {
ans[i - 1] += ans[i] / sz;
ans[i] %= sz;
}
} else if (n < k)
;
else {
ans[k - 1]++;
for (int i = k - 1; i; i--) ans[i - 1] += ans[i] / sz, ans[i] %= sz;
}
for (int i = 0; i < k; i++) {
cout << mpi[ans[i]];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201;
int a[maxn];
char t[maxn], s[maxn];
char c[30] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D'};
int main() {
int n;
scanf("%d", &n);
int cnt = 0;
a[cnt++] = n;
while (n != 1 && n != 0) {
if (n % 2 == 0) {
n /= 2;
a[cnt++] = --n;
} else {
n--;
n /= 2;
a[cnt++] = n;
}
}
for (int i = 0; i < cnt; i++) {
}
memset(t, '\0', sizeof(t));
memset(s, '\0', sizeof(s));
int p, q, r, i;
if (a[cnt - 1] == 1) {
t[0] = s[0] = 'a';
r = 1;
p = q = 1;
i = cnt - 2;
} else if (a[cnt - 1] == 0) {
t[0] = 'a';
t[1] = t[2] = 'b';
s[0] = 'a';
s[1] = 'b';
r = 2;
p = 3;
q = 2;
i = cnt - 3;
}
for (; i >= 0; i--, r++) {
if (a[i] == a[i + 1] * 2 + 2) {
int l = strlen(t);
l += 4;
t[l - 1] = t[l - 2] = c[r];
for (int k = l - 3; k >= r + 2; k--) {
t[k] = t[k - 2];
}
t[r] = t[r + 1] = c[r];
p = l;
} else if (a[i] == a[i + 1] * 2 + 1) {
int l = strlen(t);
l += 3;
t[l - 1] = t[l - 2] = c[r];
for (int k = l - 3; k >= r + 1; k--) {
t[k] = t[k - 1];
}
t[r] = c[r];
p = l;
}
s[q++] = c[r];
}
printf("%s %s\n", t, s);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long f[40][20][20], mul[20];
string s, t = "";
int main() {
int i, j, l, n, m, k, ti, tj, sum;
cin >> n >> s;
memset(f, 0, sizeof(f));
mul[0] = 1;
for (i = 1; i <= 18; i++) {
mul[i] = mul[i - 1] * 10;
}
s = " " + s;
for (i = 1; i <= 2 * n; i++) {
if (i == min(i, n)) {
for (j = 1; j < i; j++) {
f[i][j][i - j] =
max(f[i - 1][j - 1][i - j] + ((long long)(s[i] - '0')) * mul[n - j],
f[i - 1][j][i - j - 1] +
((long long)(s[i] - '0')) * mul[n - i + j]);
}
} else {
for (j = 1; j <= n; j++) {
f[i][j][i - j] =
max(f[i - 1][j - 1][i - j] + ((long long)(s[i] - '0')) * mul[n - j],
f[i - 1][j][i - j - 1] +
((long long)(s[i] - '0')) * mul[n - i + j]);
}
}
if (i <= n) {
f[i][i][0] = f[i - 1][i - 1][0] + ((long long)(s[i] - '0')) * mul[n - i];
f[i][0][i] = f[i - 1][0][i - 1] + ((long long)(s[i] - '0')) * mul[n - i];
}
}
ti = n;
tj = n;
sum = 2 * n;
while (ti != 0 && tj != 0 && sum != 0) {
if (f[sum][ti][tj] ==
f[sum - 1][ti - 1][tj] + (long long)(s[sum] - '0') * mul[n - ti]) {
t += 'M';
ti--;
sum--;
} else {
t += 'H';
tj--;
sum--;
}
}
if (ti > 0) {
for (i = 1; i <= sum; i++) {
t += 'M';
}
}
if (tj > 0) {
for (i = 1; i <= sum; i++) {
t += 'H';
}
}
reverse(t.begin(), t.end());
cout << t;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int thieve10;
bool thieve3[1100003];
bool thieve2[1100003];
long long int thieve4[1100003];
void thieving() {
long long int thieve = 2, thieve1;
thieve3[0] = thieve3[1] = true;
while (thieve < 1100003) {
thieve4[thieve10] = thieve;
thieve10++;
for (thieve1 = thieve * 2; thieve1 < 1100003; thieve1 += thieve) {
thieve3[thieve1] = true;
}
thieve++;
while (thieve < 1100003 && thieve3[thieve]) thieve++;
}
}
bool binarySearch(long long int array[97000], long int lowerbound,
long int upperbound, long long int key) {
int position;
position = (lowerbound + upperbound) / 2;
while ((array[position] != key) && (lowerbound <= upperbound)) {
if (array[position] > key) {
upperbound = position - 1;
} else {
lowerbound = position + 1;
}
position = (lowerbound + upperbound) / 2;
}
if (lowerbound <= upperbound) {
return true;
} else
return false;
}
int main() {
thieving();
long long int n, ni;
cin >> ni;
while (ni) {
cin >> n;
long int pol = int(sqrt(n));
if (int(sqrt(n)) == sqrt(n) && (!thieve3[pol]))
cout << "YES" << endl;
else
cout << "NO" << endl;
ni--;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n;
int A[505][505];
int pos[505];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&A[i][i]);
pos[i]=i;
}
bool f=1;
for(int i=n;i>=1&&f;i--){
int c=A[i][i]-1;
int x=i,y=i;
while(c&&f){
if(x+1<=n){
if(!A[x+1][y]){
A[x+1][y]=A[i][i];
x++;
if(x>n)f=0;
c--;
continue;
}
}
A[x][y-1]=A[i][i];
y--;
c--;
if(y==0)f=0;
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++){
printf("%d%c",A[i][j],j==i?'\n':' ');
}
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.