solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int N = 1e4 + 11;
char a[N], b[N];
int m, L, R, k;
int main() {
scanf("%s", a + 1);
a[0] = 'p';
int len = strlen(a);
scanf("%d", &m);
while (m--) {
scanf("%d%d%d", &L, &R, &k);
k = k % (R - L + 1);
for (int i = L; i <= R; i++) {
if (i + k <= R)
b[i + k] = a[i];
else
b[L + k - (R - i) - 1] = a[i];
}
for (int i = L; i <= R; i++) {
a[i] = b[i];
}
}
for (int i = 1; i <= len; i++) {
b[i - 1] = a[i];
}
b[len] = '\0';
cout << b << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int mm = 100005;
char s1[mm], s2[mm];
int check(char *sa, int a, char *sb, int b, int l) {
for (int i = 0; i < l; i++)
if (sa[a + i] != sb[b + i]) return 0;
return 1;
}
int main() {
int n;
while (cin >> n) {
int ans = 0;
cin >> s1 >> s2;
int l = 0, r = strlen(s1) - 1;
while (s1[l] == s2[l] && l <= r) l++;
while (s1[r] == s2[r] && r >= l) r--;
ans = check(s1, l + 1, s2, l, r - l) + check(s1, l, s2, l + 1, r - l);
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
for (int n = (1); n <= (2000); ++n)
if (n * 999999 > k) {
printf("%d\n-1", n + 1);
for (int i = (1); i <= (n); ++i)
printf(" %d", i < n ? 1000000 : (n + k) % 1000000 + 1);
printf("\n");
return 0;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.14159265358979323843;
void Time() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void print(int n) {
if (n == 0) {
return;
}
print(n - 1);
cout << "Hello world" << endl;
}
long long arr[100000];
int main() {
Time();
string s;
int A = 0, B = 0, C = 0;
for (int i = 0; i < 3; i++) {
cin >> s;
if (s[0] == 'A' && s[1] == '>' || s[2] == 'A' && s[1] == '<') {
A++;
} else if (s[0] == 'B' && s[1] == '>' || s[2] == 'B' && s[1] == '<') {
B++;
} else if (s[0] == 'C' && s[1] == '>' || s[2] == 'C' && s[1] == '<') {
C++;
}
}
if (A == B && A == C) {
cout << "Impossible" << endl;
} else if (A > B && A > C && B > C) {
cout << "CBA" << endl;
} else if (A > B && A > C && C > B) {
cout << "BCA" << endl;
} else if (B > A && B > C && A > C) {
cout << "CAB" << endl;
} else if (B > A && B > C && C > A) {
cout << "ACB" << endl;
} else if (C > A && C > B && A > B) {
cout << "BAC" << endl;
} else if (C > A && C > B && B > A) {
cout << "ABC" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1.0);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
const long long INF = 1000000000000LL;
long long minN = INF;
long long maxN = -INF;
void update(int a, int b, int c) {
minN = min(minN, (long long)(a + 1) * (b + 2) * (c + 2));
minN = min(minN, (long long)(b + 1) * (a + 2) * (c + 2));
minN = min(minN, (long long)(c + 1) * (b + 2) * (a + 2));
maxN = max(maxN, (long long)(a + 1) * (b + 2) * (c + 2));
maxN = max(maxN, (long long)(b + 1) * (a + 2) * (c + 2));
maxN = max(maxN, (long long)(c + 1) * (b + 2) * (a + 2));
}
void solve() {
int n;
cin >> n;
for (int i = 1; i * i <= n; i++) {
if (n % i != 0) continue;
vector<int> v;
for (int j = 1; j * j <= (n / i); j++) {
if ((n / i) % j != 0) continue;
int a, b, c;
a = i;
b = j;
c = (n / i) / j;
update(a, b, c);
}
for (int j = 1; j * j <= i; j++) {
if ((i) % j != 0) continue;
int a, b, c;
a = n / i;
b = j;
c = (i) / j;
update(a, b, c);
}
}
cout << minN - n << " " << maxN - n << endl;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int tam = n.size();
for (int i = 0; i < tam; i++) {
if (n[i] == '1' || (n[i] == '4' && (n[i - 1] == '1' || n[i - 2] == '1'))) {
} else {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
struct matrix {
long long m[6][6];
void init() {
m[0][0] = m[1][1] = 1;
m[1][0] = m[0][1] = 0;
}
};
matrix data[maxn << 2], lazy[maxn << 2];
matrix operator*(matrix a, matrix b) {
matrix t;
memset(t.m, 0, sizeof(t.m));
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
t.m[i][j] = (t.m[i][j] + a.m[i][k] * b.m[k][j]) % mod;
}
}
}
return t;
}
matrix pow_mul(long long m) {
matrix res, aa;
res.init();
aa.m[0][0] = aa.m[0][1] = aa.m[1][0] = 1;
aa.m[1][1] = 0;
while (m) {
if (m & 1) res = res * aa;
aa = aa * aa;
m >>= 1;
}
return res;
}
matrix operator+(matrix a, matrix b) {
matrix c;
memset(c.m, 0, sizeof(c.m));
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
c.m[i][j] = (a.m[i][j] + b.m[i][j]) % mod;
}
}
return c;
}
void pushup(int x) { data[x] = data[x * 2] + data[x * 2 + 1]; }
void Creat(int l, int r, int k) {
lazy[k].init();
data[k].init();
if (l == r) {
long long f;
cin >> f;
data[k] = pow_mul(f - 1);
return;
}
int mid = (l + r) >> 1;
Creat(l, mid, k * 2);
Creat(mid + 1, r, k * 2 + 1);
pushup(k);
}
void pushdown(int k) {
data[k * 2] = data[k * 2] * lazy[k];
data[k * 2 + 1] = data[k * 2 + 1] * lazy[k];
lazy[k * 2] = lazy[k * 2] * lazy[k];
lazy[k * 2 + 1] = lazy[k * 2 + 1] * lazy[k];
lazy[k].init();
}
void updata(int l, int r, int L, int R, int k, matrix v) {
if (l <= L && r >= R) {
data[k] = data[k] * v;
lazy[k] = lazy[k] * v;
return;
}
pushdown(k);
int mid = (L + R) / 2;
if (l <= mid) updata(l, r, L, mid, k * 2, v);
if (r >= mid + 1) updata(l, r, mid + 1, R, k * 2 + 1, v);
pushup(k);
}
long long query(int l, int r, int L, int R, int k) {
if (L >= l && R <= r) return data[k].m[0][0];
pushdown(k);
int mid = (L + R) / 2;
long long ans = 0;
if (l <= mid) ans = (ans + query(l, r, L, mid, k * 2)) % mod;
if (r >= mid + 1) ans = (ans + query(l, r, mid + 1, R, k * 2 + 1)) % mod;
return ans;
}
void middleshow(int l, int r, int x) {
if (l == r) {
cout << data[x].m[0][0] << endl;
return;
}
int mid = (l + r) / 2;
middleshow(l, mid, x * 2);
middleshow(mid + 1, r, x * 2 + 1);
}
int main() {
int n, m;
cin >> n >> m;
Creat(1, n, 1);
while (m--) {
int flag;
int l, r;
cin >> flag >> l >> r;
if (flag == 1) {
long long v;
cin >> v;
matrix t = pow_mul(v);
updata(l, r, 1, n, 1, t);
} else {
cout << query(l, r, 1, n, 1) << endl;
}
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
#define M 1000000007
#define ll long long
#define pb push_back
#define pi pair<int,int>
#define mp make_pair
#define vi vector<int>
#define vb vector<bool>
#define vll vector <long long>
#define tests int tc; cin>>tc; while(tc--)
#define defsort(arr) sort(arr.begin(), arr.end());
#define csort(arr, cmp) sort(arr.begin(), arr.end(), cmp);
#define printArray(a) for(auto num : a){cout<<num<<" ";}cout<<"\n";
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
using namespace std;
template<typename T>
class custom_priority_queue : public std::priority_queue<T, std::vector<T>, greater <T>>
{
public:
bool remove(const T& value) {
auto it = std::find(this->c.begin(), this->c.end(), value);
if (it != this->c.end()) {
this->c.erase(it);
std::make_heap(this->c.begin(), this->c.end(), this->comp);
return true;
}
else {
return false;
}
}
};
int main(){
fastio;
int i, j;
vi n(4);
for(i=0;i<n.size();i++){
cin>>n[i];
}
vector <vll> cost(n.size());
for(i=0;i<cost.size();i++){
cost[i] = vll (n[i]);
for(j=0;j<cost[i].size();j++){
cin>>cost[i][j];
}
}
vi m(3);
vector <vector<vi>> adj(3);
for(i=0;i<m.size();i++){
cin>>m[i];
adj[i] = vector <vi> (n[i]);
while(m[i]--){
int x,y;
cin>>x>>y;
x--; y--;
adj[i][x].push_back(y);
}
}
vector <vll> dp = cost;
for(i=2;i>=0;i--){
// make pq ready
multiset <ll> pq;
for(auto c : dp[i+1]){
pq.insert(c);
}
pq.insert(INT_MAX);
for(j=0;j<cost[i].size();j++){
for(auto v : adj[i][j]){
pq.erase(pq.find(dp[i+1][v]));
}
dp[i][j] = min((ll)INT_MAX, cost[i][j] + *pq.begin());
for(auto v : adj[i][j]){
pq.insert(dp[i+1][v]);
}
}
}
ll minCost = LLONG_MAX;
// printf("each level cost\n");
// for(i=0;i<dp.size();i++){
// printArray(dp[i]);
// }
for(auto c : dp[0]){
minCost = min(minCost, c);
}
if(minCost >= INT_MAX){
minCost = -1;
}
cout<<minCost<<"\n";
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = INT_MAX;
const long long MOD = 998244353;
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long g = a;
x = 1;
y = 0;
if (b != 0) g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
long long invMod(long long a, long long m) {
long long x, y;
if (extgcd(a, m, x, y) == 1)
return (x + m) % m;
else
return 0;
}
long long N, M;
bool a[60];
long long w[60];
long long inc, decr;
map<tuple<long long, long long, long long, long long>, long long> mp;
long long dfs(long long i, long long j, long long k, long long in,
long long de) {
if (mp.count(make_tuple(j, k, in, de))) return mp[make_tuple(j, k, in, de)];
if (j == M) {
return k;
}
long long ret = 0;
if (k > 0)
ret = (ret + k * dfs(i, j + 1, k + 2 * a[i] - 1, in, de) % MOD) % MOD;
ret = (ret + in * dfs(i, j + 1, k, in + 1, de) % MOD) % MOD;
if (de > 0) ret = (ret + de * dfs(i, j + 1, k, in, de - 1) % MOD) % MOD;
ret = ret * invMod(k + in + de, MOD) % MOD;
return mp[make_tuple(j, k, in, de)] = ret;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for (long long i = 0; i < N; i++) cin >> a[i];
for (long long i = 0; i < N; i++) cin >> w[i];
for (long long i = 0; i < N; i++) {
if (a[i])
inc += w[i];
else
decr += w[i];
}
for (long long i = 0; i < N; i++) {
if (a[i])
inc -= w[i];
else
decr -= w[i];
long long ans = dfs(i, 0, w[i], inc, decr);
cout << ans << endl;
if (a[i])
inc += w[i];
else
decr += w[i];
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
while (k--) {
int x, y, a, b, tg;
cin >> x >> y >> a >> b;
tg = (y - x) % (a + b);
if (tg == 0)
cout << (y - x) / (a + b) << endl;
else
cout << "-1" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int xx[] = {0, 1, 0, -1, -1, -1, 1, 1, -1};
int yy[] = {1, 0, -1, 0, 1, 1, -1, -1};
void vin(vector<int> &v, int n) {
int temp;
while (n--) {
cin >> temp;
v.push_back(temp);
}
}
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int d, n;
cin >> d >> n;
int temp;
int ans = 0;
n--;
while (n--) {
cin >> temp;
ans += (d - temp);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ip, m;
char cp;
string s;
cin >> s;
ip = s[1] - 48;
cp = s[0];
if ((ip == 1 || ip == 8) && (cp == 'a' || cp == 'h'))
m = 3;
else if ((ip == 1 || ip == 8) && (cp >= 'b' || cp <= 'g'))
m = 5;
else if ((ip >= 2 || ip >= 7) && (cp == 'a' || cp == 'h'))
m = 5;
else
m = 8;
cout << m << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int mo = 1051131, ni2 = (mo + 1) / 2;
int a[((1 << 25) + 10)], ans[((1 << 25) + 10)], m, s;
long long t;
int Pow(int x, long long y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % mo;
x = 1ll * x * x % mo;
y /= 2;
}
return res;
}
void work(int m, int p, int q) {
if (p < 0) p += mo;
if (q < 0) q += mo;
if (m == -1) {
ans[0] = 1ll * a[0] * Pow(p + q, t) % mo;
return;
}
int s = 1 << m;
for (int i = 0; i <= s - 1; ++i) {
a[i] += a[i + s];
if (a[i] >= mo) a[i] -= mo;
}
work(m - 1, 2 * p % mo, (1ll * p * s - p + q) % mo);
long long tmp = (Pow((-1ll * p * s + p + q) % mo, t) + mo) % mo;
for (int i = 0; i <= s - 1; ++i) {
a[i] -= a[i + s];
if (a[i] < 0) a[i] += mo;
int d = a[i] - a[i + s];
if (d < 0) d += mo;
d = tmp * d % mo;
ans[i + s] = ans[i] - d;
if (ans[i + s] < 0) ans[i + s] += mo;
ans[i] += d;
if (ans[i] >= mo) ans[i] -= mo;
}
for (int i = 0; i <= s * 2 - 1; ++i) ans[i] = 1ll * ans[i] * ni2 % mo;
}
int main() {
scanf("%d%I64d%d", &m, &t, &s);
for (int i = 0; i <= s - 1; ++i) scanf("%d", &a[i]);
for (int i = s; i <= (1 << m) - 1; ++i) a[i] = (101 * a[i - s] + 10007) % mo;
work(m - 1, 1, 0);
int fans = 0;
for (int i = 0; i <= (1 << m) - 1; ++i) fans ^= ans[i];
printf("%d\n", fans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c, d;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", max(a + b, c + d));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55, D = 51;
int i, j, k, n, nn;
double p1, p2, t, sum, ans;
double a[N][N], b[N][N], f[N][N];
struct matrix {
double a[N][N];
matrix operator*(const matrix &n) const {
matrix t;
int i, j, k;
for (i = 1; i <= D; i++)
for (j = 1; j <= D; j++) t.a[i][j] = 0.0;
for (k = 1; k <= D; k++)
for (i = 1; i <= D; i++)
for (j = 1; j <= D; j++) t.a[i][j] += a[i][k] * n.a[k][j];
return t;
}
} A, B;
int main() {
scanf("%d%d", &n, &k);
p1 = k;
p1 /= 1e9;
p2 = 1.0 - p1;
for (i = 1; i < D; i++)
for (j = 1; j < D; j++) {
if (j == 1) a[i][j] = p1;
if (j == 2) a[i][j] = b[i][j] = p2;
a[i][j] += a[i][j - 1] * a[i - 1][j - 1];
b[i][j] += b[i][j - 1] * a[i - 1][j - 1];
}
nn = n;
if (n > 50) n = 50;
for (i = 1; i <= n + 1; i++) f[n][i] = 1.0 * i;
for (i = n - 1; i; i--) {
sum = 0.0;
for (k = 2; k <= n + 1; k++) {
t = b[n - i][k] * (1 - a[n - i - 1][k]);
f[i][1] += f[i + 1][k] * t;
sum += t;
}
f[i][1] = f[i][1] / sum + 1.0;
for (j = 2; j <= n - i + 2; j++) {
sum = 0.0;
for (k = 1; k < j; k++) {
t = a[n - i][k] * (1 - a[n - i - 1][k]);
f[i][j] += f[i + 1][k] * t;
sum += t;
}
f[i][j] = f[i][j] / sum + 1.0 * j;
}
}
if (nn <= 50) {
for (i = 1; i <= n + 1; i++) ans += f[1][i] * a[n][i] * (1 - a[n - 1][i]);
printf("%.9lf\n", ans);
return 0;
}
sum = 0.0;
for (k = 2; k < D; k++) sum += b[D - 1][k] * (1.0 - a[D - 1][k]);
for (k = 2; k < D; k++) B.a[k][1] = b[D - 1][k] * (1.0 - a[D - 1][k]) / sum;
B.a[D][1] = 1.0;
for (j = 2; j < D; j++) {
sum = 0.0;
for (k = 1; k < j; k++) sum += a[D - 1][k] * (1.0 - a[D - 1][k]);
for (k = 1; k < j; k++) B.a[k][j] = a[D - 1][k] * (1.0 - a[D - 1][k]) / sum;
B.a[D][j] = 1.0 * j;
}
B.a[D][D] = 1.0;
for (i = 1; i <= D; i++) A.a[i][i] = 1.0;
for (nn = nn - 50; nn; nn >>= 1, B = B * B)
if (nn & 1) A = A * B;
for (j = 1; j < D; j++) {
sum = 0.0;
for (k = 1; k < D; k++) sum += f[1][k] * A.a[k][j];
sum += A.a[D][j];
ans += sum * a[D - 1][j] * (1 - a[D - 1][j]);
}
printf("%.9lf\n", ans);
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
int n, m, u, v, x, y, z;
vector<int> arr[5001];
bool a[5001];
bool vis[5001]{0};
void reset() {
for (int i = 0; i <= n; i++) {
arr[i].clear();
}
}
void ff() {
for (int i = 0; i <= n; i++) vis[i] = 0;
}
set<int> val[2];
bool bfs(int to) {
val[1].clear();
val[0].clear();
queue<pair<int, int>> q;
q.push({to, 0});
ff();
vis[to] = 1;
int ret = 0;
while (q.size() > 0) {
auto i = q.front();
q.pop();
a[i.first] = i.second % 2;
val[i.second % 2].insert(i.first);
for (auto j : arr[i.first]) {
if (!vis[j]) {
q.push({j, i.second + 1});
vis[j] = 1;
} else {
if ((i.second + 1) % 2 != a[j]) {
return 0;
}
}
}
}
return 1;
}
bool dp[5001][5001]{0};
bool inv[5001][5001]{0};
void pre() {}
void solve() {
long long n, m, n1, n2, n3;
cin >> n >> m >> n1 >> n2 >> n3;
for (int i = 0; i < m; i++) {
cin >> u >> v;
arr[u].push_back(v);
arr[v].push_back(u);
}
vector<pair<set<int>, set<int>>> v;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (!bfs(i)) {
cout << "NO"
<< "\n";
return;
}
v.push_back({val[0], val[1]});
}
}
dp[0][0] = 1;
for (int i = 1; i <= v.size(); i++) {
for (int j = 0; j <= n; j++) {
if (dp[i - 1][j]) {
dp[i][j + v[i - 1].first.size()] = 1;
inv[i][j + v[i - 1].first.size()] = 0;
dp[i][j + v[i - 1].second.size()] = 1;
inv[i][j + v[i - 1].second.size()] = 1;
}
}
}
if (!dp[v.size()][n2]) {
cout << "NO"
<< "\n";
return;
}
cout << "YES"
<< "\n";
pair<set<int>, set<int>> p;
long long curr = n2;
for (int i = v.size(); i >= 1; i--) {
if (inv[i][curr]) {
p = v[i - 1];
v[i - 1].first = p.second;
v[i - 1].second = p.first;
}
curr -= v[i - 1].first.size();
}
int ans[n + 1];
for (int i = 0; i < v.size(); i++) {
for (int j : v[i].first) {
ans[j] = 2;
}
for (int j : v[i].second) {
if (n1 > 0) {
ans[j] = 1;
n1--;
} else {
ans[j] = 3;
}
}
}
for (int i = 0; i < n; i++) {
cout << ans[i + 1];
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
pre();
long long int num = 1;
for (long long int i = 0; i < num; i++) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T, class S>
inline void add(T& a, S b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T, class S>
inline void sub(T& a, S b) {
a -= b;
if (a < 0) a += mod;
}
template <class T, class S>
inline bool chkmax(T& a, S b) {
return a < b ? a = b, true : false;
}
template <class T, class S>
inline bool chkmin(T& a, S b) {
return a > b ? a = b, true : false;
}
const int B = 200001;
int n;
vector<pair<int, int> > v[2];
int upL[N], dnL[N];
int upR[N], dnR[N];
long long solve(vector<pair<int, int> >& v) {
memset(upL, 0xc0, sizeof(upL));
memset(dnL, 0x3f, sizeof(dnL));
memset(upR, 0xc0, sizeof(upR));
memset(dnR, 0x3f, sizeof(dnR));
for (auto& t : v) {
chkmax(upL[t.first], t.second);
chkmin(dnL[t.first], t.second);
chkmax(upR[t.first], t.second);
chkmin(dnR[t.first], t.second);
}
for (int i = 1; i < N; i++) {
chkmax(upL[i], upL[i - 1]);
chkmin(dnL[i], dnL[i - 1]);
}
for (int i = N - 2; i >= 1; i--) {
chkmax(upR[i], upR[i + 1]);
chkmin(dnR[i], dnR[i + 1]);
}
long long ans = 0;
for (int i = 1; i < N - 1; i += 2) {
int up = min(upL[i], upR[i]);
int dn = max(dnL[i], dnR[i]);
if (up > dn) ans += (up - dn) / 2;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
int z = (x + y + B) & 1;
v[z].push_back(make_pair(x + y + B + z, x - y + B + z));
}
long long ans = 0;
ans += solve(v[0]);
ans += solve(v[1]);
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double a[1002], b[1002];
int main() {
int n;
double m, cm;
cin >> n >> m;
cm = m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] <= 1.0 + 1e-9) {
cout << "-1";
return 0;
}
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] <= 1.0 + 1e-9) {
cout << "-1";
return 0;
}
}
m = m / (b[1] - 1.0) + m;
for (int i = n; i > 1; i--) {
m = m / (b[i] - 1.0) + m;
m = m / (a[i] - 1.0) + m;
}
m = m / (a[1] - 1.0) + m;
printf("%.10lf", m - cm);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, l, r;
cin >> t;
while (t--) {
cin >> l >> r;
if (l * 2 <= r)
cout << l << " " << l * 2 << endl;
else
cout << "-1 -1" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int m;
int ans = 0;
int cnt = 0;
int Z = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &m);
for (int j = 0; j < m; j++) scanf("%d", &a[j]);
if (a[0] == 1) {
cnt = 0;
int z = 1;
while (z < m && a[z] == a[z - 1] + 1) {
z++;
cnt++;
}
if (cnt == 0) {
ans += (m - 1);
Z += (m);
} else if (cnt != m - 1) {
ans += (m - (cnt + 1));
Z += (m - cnt);
} else {
Z += 1;
}
} else {
ans += (m - 1);
Z += (m);
}
}
ans += (Z - 1);
printf("%d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-15;
const long double INF = 1e18;
inline long double fix(long double tar) { return fabs(tar) <= EPS ? 0 : tar; }
struct Point {
long double x, y;
Point() {}
Point(long double x_, long double y_) { x = x_, y = y_; }
Point operator+(const Point &b) { return Point(x + b.x, y + b.y); }
Point operator-(const Point &b) { return Point(x - b.x, y - b.y); }
long double arctan() { return atan2(y, x); }
} A, B, C, plist[16];
long double dist(const Point &a, const Point &b) {
return sqrt((b.y - a.y) * (b.y - a.y) + (b.x - a.x) * (b.x - a.x));
}
struct Circle {
Point p;
long double r;
Circle() {}
Circle(Point p_, long double r_) { p = p_, r = r_; }
Circle(long double x, long double y, long double r_) {
p.x = x, p.y = y, r = r_;
}
bool in_circle(const Point &b) { return fix(dist(p, b) - r) <= 0; }
bool tot_in_circle(const Circle &b) {
return (fix(dist(p, b.p) + r - b.r) <= 0);
}
} clist[8];
long double ta, tb;
inline bool circle_cross(Circle a, Circle b, Point &c, Point &d) {
Point ab = b.p - a.p;
long double tria = a.r, tric = b.r;
long double trib = dist(a.p, b.p);
if (not(fix(tria + tric - trib) >= 0 and fix(trib + tric - tria) >= 0 and
fix(tria + trib - tric) >= 0)) {
if (a.tot_in_circle(b) or b.tot_in_circle(a)) return true;
return false;
}
long double alpha = ab.arctan();
long double tmp = (tria * tria + trib * trib - tric * tric) /
((long double)2.0 * tria * trib);
long double delta;
if (fix(tmp - 1.0) == 0)
delta = 0;
else
delta = acos((tria * tria + trib * trib - tric * tric) /
((long double)2.0 * tria * trib));
c = a.p + Point(tria * cos(alpha + delta), tria * sin(alpha + delta));
d = a.p + Point(tria * cos(alpha - delta), tria * sin(alpha - delta));
return true;
}
inline bool cross(int ccnt) {
int pcnt = 0;
for (int i = 1; i <= ccnt; i++) {
for (int j = i + 1; j <= ccnt; j++) {
if (not circle_cross(clist[i], clist[j], plist[++pcnt], plist[++pcnt]))
return false;
}
}
for (int i = 1; i <= ccnt; i++) {
for (int j = i + 1; j <= ccnt; j++) {
if (clist[i].tot_in_circle(clist[j])) return true;
}
}
for (int i = 1; i <= pcnt; i++) {
bool in_all = true;
for (int j = 1; j <= ccnt; j++) {
if (not clist[j].in_circle(plist[i])) in_all = false;
}
if (in_all) return true;
}
return false;
}
inline bool judge(long double s) {
clist[1] = Circle(A, s);
clist[2] = Circle(B, tb - s);
clist[3] = Circle(C, ta - dist(C, B) - s);
if (cross(3))
return true;
else
return false;
}
inline void binary_search() {
long double le, ri, mid;
le = 0, ri = (long double)min(tb, ta - dist(C, B));
while (le + EPS < ri) {
mid = (le + ri) / 2.0;
if (judge(mid))
le = mid;
else
ri = mid;
}
cout << fixed << setprecision(10) << (le + ri) / 2.0;
}
inline void read() {
cin >> ta >> tb >> A.x >> A.y >> B.x >> B.y >> C.x >> C.y;
}
inline void solve() {
ta += dist(A, C) + dist(C, B);
tb += dist(A, B);
if (fix(dist(A, C) + dist(C, B) - tb) <= 0)
cout << fixed << setprecision(10) << min(ta, tb) << endl;
else
binary_search();
}
int main() {
read();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int s[100005];
int book[4];
int main() {
int n, i;
memset(book, 0, sizeof(book));
memset(s, 0, sizeof(s));
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
for (i = 0; i < n; i++) {
book[s[i]]++;
}
int count = 0;
count += book[4] + book[3];
book[1] -= book[3];
if (book[2] % 2 == 0)
count += book[2] / 2;
else {
count += (book[2] + 1) / 2;
book[1] -= 2;
}
if (book[1] > 0) {
if (book[1] % 4 == 0)
count += book[1] / 4;
else
count += book[1] / 4 + 1;
}
printf("%d", count);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int c;
map<int, int> mp;
map<int, int>::iterator it;
struct I {
int f, x;
} ins[maxn];
long long s[maxn << 2][5];
int rev[maxn << 2];
void dorot(int rt, int v) {
long long tmp[5];
for (int i = 0; i < 5; i++) tmp[i] = s[rt][i];
if (v > 0) {
for (int i = 0; i < 5; i++) s[rt][i] = tmp[(i - (v % 5) + 50) % 5];
} else if (v < 0) {
for (int i = 0; i < 5; i++) s[rt][i] = tmp[(i - (v % 5) + 50) % 5];
}
}
void push_down(int rt) {
if (rev[rt]) {
dorot(rt << 1, rev[rt]);
dorot(rt << 1 | 1, rev[rt]);
rev[rt << 1] += rev[rt];
rev[rt << 1 | 1] += rev[rt];
rev[rt] = 0;
}
}
void rot(int x, int y, int v, int l, int r, int rt) {
if (l != r) push_down(rt);
if (x <= l && y >= r) {
rev[rt] += v;
dorot(rt, v);
} else {
int m = (l + r) >> 1;
if (x <= m) rot(x, y, v, l, m, rt << 1);
if (y > m) rot(x, y, v, m + 1, r, rt << 1 | 1);
for (int i = 0; i < 5; i++) s[rt][i] = s[rt << 1][i] + s[rt << 1 | 1][i];
}
}
void add(int x, int v, int p, int l, int r, int rt) {
if (l == r)
s[rt][p] += v;
else {
push_down(rt);
int m = (l + r) >> 1;
if (x <= m)
add(x, v, p, l, m, rt << 1);
else
add(x, v, p, m + 1, r, rt << 1 | 1);
for (int i = 0; i < 5; i++) s[rt][i] = s[rt << 1][i] + s[rt << 1 | 1][i];
}
}
int main() {
scanf("%d", &c);
char str[10];
for (int i = 0; i < c; i++) {
scanf("%s", str);
if (str[0] == 's')
ins[i].f = 3;
else {
scanf("%d", &ins[i].x);
ins[i].f = str[0] == 'a' ? 1 : 2;
mp[ins[i].x] = 1;
}
}
int n = 1;
for (it = mp.begin(); it != mp.end(); it++) it->second = n++;
vector<int> v;
for (int i = 0; i < c; i++) {
if (ins[i].f == 1) {
int p = lower_bound(v.begin(), v.end(), ins[i].x) - v.begin() + 1;
rot(mp[ins[i].x] + 1, n, 1, 1, n, 1);
add(mp[ins[i].x], ins[i].x, p % 5, 1, n, 1);
v.insert(v.begin() + p - 1, ins[i].x);
} else if (ins[i].f == 2) {
int p = lower_bound(v.begin(), v.end(), ins[i].x) - v.begin() + 1;
rot(mp[ins[i].x] + 1, n, -1, 1, n, 1);
add(mp[ins[i].x], -ins[i].x, p % 5, 1, n, 1);
v.erase(v.begin() + p - 1);
} else
printf("%I64d\n", s[1][3]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int ok(double x, double a[]) {
double z1 = 0, z2 = 0;
for (int i = 0; i < n; i++) {
if (x - a[i] > 0) {
z1 += x - a[i];
}
if (x - a[i] < 0) {
double ans = 1 - (k * (double)1) / 100;
z2 += (a[i] - x) * ans;
}
}
if (z1 <= z2) {
return 1;
}
return 0;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
double a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
double ans = 0, low = 0, high = 10000;
int z = 0;
while (low < high) {
z++;
double mid = (low + high) / 2;
if (ok(mid, a) == 1) {
low = mid;
ans = mid;
} else {
high = mid;
}
if (z == 999) {
break;
}
}
cout << setprecision(12) << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long gcd(long long a, long long b) {
long long c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long L[2];
long long R[2];
long long T[2];
cin >> L[0] >> R[0] >> T[0];
cin >> L[1] >> R[1] >> T[1];
long long k = gcd(T[0], T[1]);
long long x = (L[1] - L[0]) / k;
long long l = L[0] + (x - 3) * k;
long long r = L[0] + (x + 3) * k;
long long res = 0;
for (long long ll = l; ll <= r; ll += k) {
res = max(res, min(R[1], ll + R[0] - L[0]) - max(L[1], ll) + 1);
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void initMain() {}
int main() {
initMain();
long long N;
cin >> N;
vector<long long> rVec(N);
for (int i = 0; i < N; i++) scanf("%I64d", &rVec[i]);
long long minPos = N;
int ans = 0;
for (int i = N - 1; i >= 0; i--) {
if (i < minPos) ans++;
minPos = min(minPos, i - rVec[i]);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long lb(vector<long long> v, long long lo, long long hi, long long ele) {
long long ans = -1;
while (lo <= hi) {
long long md = (lo + hi) / 2;
if (v[md] <= ele) {
ans = md;
lo = md + 1;
} else
hi = md - 1;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, q;
cin >> n >> q;
vector<long long> v(n);
map<long long, long long> cnt;
for (long long i = 0; i < n; i++) {
cin >> v[i];
cnt[v[i]]++;
}
while (q--) {
long long k, ans = 0;
cin >> k;
for (long long i = 30; i >= 0; i--) {
long long zz = pow(2, i);
if (cnt[zz] > 0) {
long long ts = min(cnt[zz], k / zz);
ans += ts;
k -= zz * ts;
}
}
if (k > 0) ans = -1;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
template <class Info = int, class T = int>
class ColorUpdate {
public:
struct Range {
Range(T _l = 0) : l(_l) {}
Range(T _l, T _r, Info _v) : l(_l), r(_r), v(_v) {}
T l, r;
Info v;
bool operator<(const Range &b) const { return l < b.l; }
};
std::vector<Range> erase(T l, T r) {
std::vector<Range> ans;
if (l >= r) return ans;
auto it = ranges.lower_bound(l);
if (it != ranges.begin()) {
it--;
if (it->r > l) {
auto cur = *it;
ranges.erase(it);
ranges.insert(Range(cur.l, l, cur.v));
ranges.insert(Range(l, cur.r, cur.v));
}
}
it = ranges.lower_bound(r);
if (it != ranges.begin()) {
it--;
if (it->r > r) {
auto cur = *it;
ranges.erase(it);
ranges.insert(Range(cur.l, r, cur.v));
ranges.insert(Range(r, cur.r, cur.v));
}
}
for (it = ranges.lower_bound(l); it != ranges.end() && it->l < r; it++) {
ans.push_back(*it);
}
ranges.erase(ranges.lower_bound(l), ranges.lower_bound(r));
return ans;
}
std::vector<Range> upd(T l, T r, Info v) {
auto ans = erase(l, r);
ranges.insert(Range(l, r, v));
return ans;
}
bool exists(T x) {
auto it = ranges.upper_bound(x);
if (it == ranges.begin()) return false;
it--;
return it->l <= x && x < it->r;
}
std::set<Range> ranges;
};
struct CrazySet {
ColorUpdate<bool, long long> ranges;
bool inverted = false;
long long lazy = 0;
void addLazy(long long x) { lazy += x; }
void invert() {
lazy = -lazy;
inverted = !inverted;
}
void addRange(long long l, long long r) {
if (!inverted) {
ranges.upd(l - lazy, r - lazy, true);
} else {
ranges.upd(-r + 1 + lazy, -l + 1 + lazy, true);
}
}
void removeRange(long long l, long long r) {
if (!inverted) {
ranges.erase(l - lazy, r - lazy);
} else {
ranges.erase(-r + 1 + lazy, -l + 1 + lazy);
}
}
bool exists(long long x) {
if (!inverted) {
return ranges.exists(x - lazy);
} else {
return ranges.exists(-x + lazy);
}
}
bool empty() { return ranges.ranges.empty(); }
void debug() {
return;
std::cout << "starting debug!\n";
for (auto it : ranges.ranges) {
std::cout << "[" << it.l << ", " << it.r << ") or ";
if (!inverted) {
std::cout << "[" << it.l + lazy << ", " << it.r + lazy << ")\n";
} else {
std::cout << "[" << -it.r + 1 + lazy << ", " << -it.l + 1 + lazy
<< ")\n";
}
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int t;
std::cin >> t;
const int INF = 1e9;
while (t--) {
int n;
std::cin >> n;
CrazySet wtf;
int ans = 0;
while (n--) {
int x;
std::cin >> x;
wtf.debug();
wtf.removeRange(x, INF);
if (wtf.empty()) {
wtf.addRange(1, x);
ans++;
}
wtf.debug();
wtf.invert();
wtf.addLazy(x);
wtf.debug();
if (x % 2 == 0) {
if (wtf.exists(x / 2)) {
wtf.removeRange(1, INF);
wtf.addRange(x / 2, x / 2 + 1);
} else {
ans++;
wtf.addRange(x / 2, x / 2 + 1);
}
} else {
ans++;
}
wtf.debug();
}
std::cout << ans << '\n';
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 23;
int n, m;
char s[maxn];
int a[maxn];
class SegTree {
private:
vector<int> tag, mn, mx;
vector<unsigned long long> st;
int n;
public:
void pushup(int o) {
st[o] = st[o << 1] + st[o << 1 | 1];
mx[o] = max(mx[o << 1], mx[o << 1 | 1]);
mn[o] = min(mn[o << 1], mn[o << 1 | 1]);
}
void pushdown(int o, int l, int r) {
if (!tag[o]) return;
int mid = (l + r) >> 1;
mn[o << 1] = mx[o << 1] = tag[o];
st[o << 1] = 1ll * (mid - l + 1) * tag[o];
tag[o << 1] = tag[o];
mn[o << 1 | 1] = mx[o << 1 | 1] = tag[o];
st[o << 1 | 1] = 1ll * (r - mid) * tag[o];
tag[o << 1 | 1] = tag[o];
tag[o] = 0;
}
void modify(int o, int l, int r, int ql, int qr, int v) {
if (mn[o] >= v) return;
if (ql <= l && qr >= r) {
if (mx[o] <= v) {
mx[o] = mn[o] = tag[o] = v;
st[o] = 1ll * (r - l + 1) * v;
return;
}
}
int mid = (l + r) >> 1;
pushdown(o, l, r);
if (ql <= mid) modify(o << 1, l, mid, ql, qr, v);
if (qr > mid) modify(o << 1 | 1, mid + 1, r, ql, qr, v);
pushup(o);
}
unsigned long long query(int o, int l, int r, int ql, int qr) {
if (ql <= l && qr >= r) return st[o];
unsigned long long ans = 0;
int mid = (l + r) >> 1;
pushdown(o, l, r);
if (ql <= mid) ans += query(o << 1, l, mid, ql, qr);
if (qr > mid) ans += query(o << 1 | 1, mid + 1, r, ql, qr);
return ans;
}
SegTree(int size) {
this->n = size;
st.resize(size * 4 + 10);
tag.resize(size * 4 + 10);
mn.resize(size * 4 + 10);
mx.resize(size * 4 + 10);
}
};
int main() {
cin >> n;
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) a[i] = s[i] == '1';
SegTree st(n);
unsigned long long ans = 0;
for (int i = 1, l = 0; i <= n; i++) {
if (a[i] != 1) {
ans += st.query(1, 1, n, 1, i);
continue;
}
if (a[i] == 1 && a[i - 1] != 1) {
l = i;
}
if (l > 1) st.modify(1, 1, n, 1, l - 1, i - l + 1);
ans += 1ll * (i - l + 1) * (i - l + 2) / 2;
if (l > 1) ans += st.query(1, 1, n, 1, l - 1);
if (a[i + 1] != 1) {
for (int j = l; j <= i; j++) st.modify(1, 1, n, j, j, j - l + 1);
}
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int n, k, a[maxn], d[maxn * 2];
int main() {
cin >> n >> k;
for (int i = 0; i < k; ++i) {
int t;
scanf("%d", &t);
a[t] = 1;
}
memset(d, -1, sizeof(d));
queue<int> que;
for (int i = 0; i < maxn; ++i) {
if (a[i]) {
d[i - n + maxn] = 1;
que.push(i - n);
}
}
while (!que.empty()) {
int now = que.front();
que.pop();
if (now == 0) break;
for (int i = 0; i < maxn; ++i) {
if (a[i] && abs(now + i - n) < maxn && d[now + i - n + maxn] == -1) {
d[now + i - n + maxn] = d[now + maxn] + 1;
que.push(now + i - n);
}
}
}
cout << d[maxn] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, c[1000010], prime[1000010], a[30], len, tot;
bool check[1000010];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 2; i <= k; i++) {
if (!check[i]) prime[++tot] = i;
for (int j = 1; j <= tot; j++) {
if ((long long)prime[j] * i > k) break;
check[prime[j] * i] = 1;
if (!(i % prime[j])) break;
}
}
for (int i = 1; i <= tot; i++) {
int mul = 1;
for (; !(k % prime[i]);) {
mul *= prime[i];
k /= prime[i];
}
a[++len] = mul;
}
for (int i = 1; i <= len; i++) {
bool bo = 0;
for (int j = 1; j <= n; j++)
if (!(c[j] % a[i])) {
bo = 1;
break;
}
if (!bo) {
printf("No");
return 0;
}
}
printf("Yes");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, mini = 1000000005, sum = 0;
cin >> n >> k;
long long A[n];
for (int i = 0; i < n; ++i) {
cin >> A[i];
mini = min(A[i], mini);
}
for (int i = 0; i < n; ++i) {
A[i] = A[i] - mini;
if (A[i] % k == 0) {
if (A[i] != 0) sum += A[i] / k;
} else {
sum = -1;
break;
}
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m;
struct edge {
int ver, nxt;
} e[N << 1];
int head[N << 1], tot;
void add(int u, int v) {
e[++tot] = (edge){v, head[u]};
head[u] = tot;
e[++tot] = (edge){u, head[v]};
head[v] = tot;
}
int a[N], b[N];
queue<int> que;
int ans[N], cnt;
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u, v;
u = read(), v = read();
add(u, v);
}
for (int i = 1; i <= n; i++) {
a[i] = read();
if (!a[i]) que.push(i);
}
while (!que.empty()) {
int u = que.front();
que.pop();
ans[++cnt] = u;
b[u]++;
for (int i = head[u]; i; i = e[i].nxt) {
b[e[i].ver]++;
if (b[e[i].ver] == a[e[i].ver]) que.push(e[i].ver);
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
struct node {
int nxt, to;
} e[N << 1];
int head[N], cnt = 0, siz[N], son[N], fa[N], max_son, col[N], a[N], maxx, n, x,
y, Son;
long long sum, ans[N];
void add(int u, int v) {
e[++cnt].nxt = head[u];
head[u] = cnt;
e[cnt].to = v;
}
void dfs(int u, int f, int d) {
fa[u] = f, siz[u] = 1;
int max_son = 0;
for (int i = head[u]; i; i = e[i].nxt) {
if (e[i].to == f) continue;
dfs(e[i].to, u, d + 1);
siz[u] += siz[e[i].to];
if (siz[e[i].to] > max_son) max_son = siz[e[i].to], son[u] = e[i].to;
}
}
void calc(int u, int val) {
col[a[u]] += val;
if (col[a[u]] > maxx)
maxx = col[a[u]], sum = a[u];
else if (col[a[u]] == maxx)
sum += (long long)a[u];
for (int i = head[u]; i; i = e[i].nxt) {
if (e[i].to == fa[u] || e[i].to == Son) continue;
calc(e[i].to, val);
}
}
void dfs2(int u, int opt) {
for (int i = head[u]; i; i = e[i].nxt) {
if (e[i].to == son[u] || e[i].to == fa[u]) continue;
dfs2(e[i].to, 0);
}
if (son[u]) dfs2(son[u], 1), Son = son[u];
calc(u, 1);
ans[u] = sum;
Son = 0;
if (!opt) calc(u, -1), sum = maxx = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
dfs(1, 0, 1);
dfs2(1, 0);
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, need, visit[1001][1001], a[1001][1001], size[1001][1001],
came[1001][1001];
vector<pair<long long int, pair<long long int, long long int> > > v;
pair<long long int, long long int> par[1001][1001];
int valid(long long int x, long long int y) {
return x >= 1 && x <= n && y >= 1 && y <= m;
}
pair<long long int, long long int> find(long long int x, long long int y) {
if (par[x][y] == make_pair(x, y)) return make_pair(x, y);
return par[x][y] = find(par[x][y].first, par[x][y].second);
}
void dfs(long long int x, long long int y) {
if (need <= 0) return;
visit[x][y] = 1;
need--;
if (valid(x + 1, y) && !visit[x + 1][y] && came[x + 1][y]) dfs(x + 1, y);
if (valid(x - 1, y) && !visit[x - 1][y] && came[x - 1][y]) dfs(x - 1, y);
if (valid(x, y + 1) && !visit[x][y + 1] && came[x][y + 1]) dfs(x, y + 1);
if (valid(x, y - 1) && !visit[x][y - 1] && came[x][y - 1]) dfs(x, y - 1);
}
int main() {
ios::sync_with_stdio(false);
;
long long int i, j, k, x, y, xp, yp, xp1, yp1, f, val;
cin >> n >> m >> k;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> a[i][j];
v.push_back(make_pair(a[i][j], make_pair(i, j)));
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
par[i][j] = make_pair(i, j);
size[i][j] = 1;
}
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
f = 0;
for (i = 0; i < v.size(); i++) {
x = v[i].second.first;
y = v[i].second.second;
val = v[i].first;
if (came[x + 1][y] && valid(x + 1, y)) {
xp = find(x, y).first;
yp = find(x, y).second;
xp1 = find(x + 1, y).first;
yp1 = find(x + 1, y).second;
if (make_pair(xp, yp) != make_pair(xp1, yp1)) {
par[xp][yp].first = xp1;
par[xp][yp].second = yp1;
size[xp1][yp1] += size[xp][yp];
}
}
if (came[x - 1][y] && valid(x - 1, y)) {
xp = find(x, y).first;
yp = find(x, y).second;
xp1 = find(x - 1, y).first;
yp1 = find(x - 1, y).second;
if (make_pair(xp, yp) != make_pair(xp1, yp1)) {
par[xp][yp].first = xp1;
par[xp][yp].second = yp1;
size[xp1][yp1] += size[xp][yp];
}
}
if (came[x][y + 1] && valid(x, y + 1)) {
xp = find(x, y).first;
yp = find(x, y).second;
xp1 = find(x, y + 1).first;
yp1 = find(x, y + 1).second;
if (make_pair(xp, yp) != make_pair(xp1, yp1)) {
par[xp][yp].first = xp1;
par[xp][yp].second = yp1;
size[xp1][yp1] += size[xp][yp];
}
}
if (came[x][y - 1] && valid(x, y - 1)) {
xp = find(x, y).first;
yp = find(x, y).second;
xp1 = find(x, y - 1).first;
yp1 = find(x, y - 1).second;
if (make_pair(xp, yp) != make_pair(xp1, yp1)) {
par[xp][yp].first = xp1;
par[xp][yp].second = yp1;
size[xp1][yp1] += size[xp][yp];
}
}
came[x][y] = 1;
xp = find(x, y).first;
yp = find(x, y).second;
if (size[xp][yp] >= k / val && k % val == 0) {
cout << "YES"
<< "\n";
need = k / val;
dfs(x, y);
f = 1;
break;
}
}
if (!f) {
cout << "NO"
<< "\n";
return 0;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (visit[i][j])
cout << val << " ";
else
cout << "0"
<< " ";
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long x[1003], y[1003];
long long dist[1003][1003];
vector<int> g[1003];
int vis[1003];
bool dfs(int u, int k) {
if (u == n) return true;
if (vis[u]) return dfs(u + 1, k);
for (int i = 0; i < g[u].size(); i++) k -= (!vis[g[u][i]]++);
if (k >= 0 && dfs(u + 1, k)) return true;
vis[u] = 1;
int q = k;
for (int i = 0; i < g[u].size(); i++) k += (!--vis[g[u][i]]);
if (--k >= 0 && k > q && dfs(u + 1, k)) return true;
vis[u] = 0;
return false;
}
bool check(long long h) {
for (int i = 0; i < n; i++) vis[i] = 0;
for (int i = 0; i < n; i++) g[i].clear();
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if (dist[i][j] > h) {
g[i].push_back(j);
g[j].push_back(i);
}
return dfs(0, k);
}
int main() {
cin >> n >> k;
vector<int> d;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
long long nah =
(x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
dist[i][j] = nah;
dist[j][i] = nah;
d.push_back(nah);
}
sort(d.begin(), d.end());
vector<int> fs;
fs = d;
d.clear();
for (int i = 0; i < fs.size(); i++)
if (i == 0 || fs[i] != fs[i - 1]) d.push_back(fs[i]);
int l, r, mid;
l = -1, r = d.size();
while (l + 1 < r) {
mid = (r + l) / 2;
if (check(d[mid]))
r = mid;
else
l = mid;
}
check(d[r]);
for (int i = 0; i < n && k; i++)
if (vis[i]) {
cout << i + 1 << " ";
k--;
}
for (int i = 0; i < n && k; i++)
if (!vis[i]) {
cout << i + 1 << " ";
k--;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int n, m;
long long f[2000006], ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
f[x]++;
f[y]++;
}
for (int i = 1; i <= n; i++) {
ans += (n - f[i] - 1) * f[i];
}
ans /= 2;
printf("%I64d\n", 1LL * n * (n - 1) * (n - 2) / 6 - ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N;
char s[100010];
int sum[26];
int main() {
scanf("%d", &N);
scanf("%s", s);
for (int i = 0; i < N; i++) sum[s[i] - 'a']++;
if (N == 1) return 0 * puts("Yes");
bool ok = false;
for (int i = 0; i < 26; i++) {
if (sum[i] > 1) ok = true;
}
puts(ok ? "Yes" : "No");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long expo(long long a, long long b, long long m) {
long long result = 1;
while (b) {
if (b & 1) {
result = (result * a) % m;
}
b = (b >> 1) % m;
a = (a * a) % m;
}
return result;
}
bool comp(pair<int, int> a, pair<int, int> b) { return a.second <= b.second; }
int main() {
long long m, n;
cin >> n >> m;
if (n == 1) {
cout << 1 << endl;
} else if (n - m > m - 1) {
cout << m + 1 << endl;
} else if (n - m == m - 1) {
cout << m - 1 << endl;
} else if (n - m < m - 1)
cout << m - 1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long base, long long exp) {
if (exp == 0) return 1;
long long r = power(base, exp / 2);
r = (r * r) % 1000000007;
if (exp & 1) r = (r * base) % 1000000007;
return r;
}
int main() {
int i, j, t;
long long a, b, c, n;
long long x, y, z;
x = 1234567;
y = 123456;
z = 1234;
cin >> n;
a = b = c = 0;
for (i = 0; i <= n / x; i++) {
for (j = 0; j <= n / y; j++) {
a = i;
b = j;
if ((n - a * x - b * y) % z == 0 && (n - a * x - b * y) >= 0) {
printf("YES\n");
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int lim = 2000000007;
vector <int> seq;
int T;
int n;
int main()
{
for (ll i = 3; i * i <= lim; i += 2)
seq.push_back((i * i + 1) / 2);
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
int ind = upper_bound(seq.begin(), seq.end(), n) - seq.begin();
printf("%d\n", ind);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1004];
int size;
int n, m;
int main(void) {
while (scanf("%d %d", &n, &m) != EOF) {
size = 0;
int i;
for (i = 0; i < n; i++) {
int p;
scanf("%d", &p);
if (p < 0) a[size++] = p;
}
sort(a, a + size);
int sum = 0;
for (i = 0; i < m && i < size; i++) {
sum += a[i];
}
printf("%d\n", -sum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int maxn = 2e5 + 3;
int n, m;
int a[maxn];
void read() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
}
int actual[maxn];
int ans = 0;
void assign(int idx, int val) {
if (idx != 1 && actual[a[idx]] != actual[a[idx - 1]]) ans--;
if (idx != n && actual[a[idx]] != actual[a[idx + 1]]) ans--;
a[idx] = val;
if (idx != 1 && actual[a[idx]] != actual[a[idx - 1]]) ans++;
if (idx != n && actual[a[idx]] != actual[a[idx + 1]]) ans++;
}
vector<int> v[maxn];
void solve() {
for (int i = 1; i <= m; i++) actual[i] = i;
for (int i = 1; i <= n; i++) v[a[i]].push_back(i);
for (int i = 1; i <= n - 1; i++)
if (a[i] != a[i + 1]) ans++;
cout << ans << '\n';
for (int i = 1; i <= m - 1; i++) {
int first, second;
cin >> first >> second;
bool is = false;
if ((int)v[first].size() < (int)v[second].size()) {
is = true;
swap(first, second);
}
for (auto j : v[second]) {
v[first].push_back(j);
assign(j, first);
}
v[second].clear();
if (is) swap(v[first], v[second]);
actual[second] = actual[first];
cout << ans << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int inf = 1e9;
const int N = 1e5 + 3;
int a[N];
multiset<pair<int, int>> al, mnset;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i > 1) al.insert({a[i], i});
}
mnset.insert({a[1], 1});
for (int i = 2; i < n; i++) {
pair<int, int> k = {a[i], i};
al.erase({a[i], i});
auto it = al.begin();
if ((it->first < a[i]) && (mnset.begin()->first < a[i])) {
cout << "3\n"
<< (mnset.begin()->second) << " " << i << " " << (it->second);
return 0;
}
auto tt = --mnset.end();
auto tal = --al.end();
if ((tt->first) > a[i] && tal->first > a[i]) {
cout << "3\n" << (tt->second) << " " << i << " " << (tal->second);
return 0;
}
mnset.insert({a[i], i});
}
cout << "0";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 0;
void solve() {
long long n;
string s, t;
cin >> n >> s >> t;
long long a = 0, b = 0, sca = 0, scb = 0;
for (long long i = 0; i < 2 * n; i++) {
if (s[i] == '1' && t[i] == '1') a++;
if (s[i] == '0' && t[i] == '1') b++;
if (s[i] == '1' && t[i] == '0') b++;
if (s[i] == '1') sca++;
if (t[i] == '1') scb++;
}
sca += (a + 1) / 2 * 2;
scb += (a / 2) * 2;
if (a & 1) {
scb += (b + 1) / 2;
sca += (b / 2);
} else {
scb += (b / 2);
sca += (b + 1) / 2;
}
if (sca == scb)
cout << "Draw";
else if (sca > scb)
cout << "First";
else
cout << "Second";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double PI = 3.14159265359;
long long twoPow(int val) {
if (!val) return 1;
if (val % 2) return (2 * twoPow(val / 2) * twoPow(val / 2)) % MOD;
return (twoPow(val / 2) * twoPow(val / 2)) % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
vector<vector<int>> ncr(1000030, vector<int>(21, 0));
ncr[0][0] = 1;
for (int n = 1; n < 1000030; n++) {
ncr[n][0] = 1;
for (int r = 1; r <= 20; r++) {
ncr[n][r] = ncr[n - 1][r - 1] + ncr[n - 1][r];
ncr[n][r] %= MOD;
}
}
vector<int> psj;
for (int i = 2; i < 1000; i++) {
bool isP = true;
for (int j = 2; j < i; j++) {
if (!(i % j)) {
isP = false;
break;
}
}
if (isP) psj.push_back(i);
}
vector<int> lp(1000001);
for (int i = 1; i <= 1000000; i++) {
lp[i] = i;
}
for (int i : psj) {
for (int j = 1; i * j <= 1000000; j++) {
lp[i * j] = min(lp[i * j], i);
}
}
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
vector<pair<int, int>> cts;
while (x > 1) {
int num = lp[x];
x /= num;
if (!cts.size() || cts.back().first != num) {
cts.push_back({num, 1});
} else {
cts.back().second++;
}
}
long long ans = 1;
for (auto p : cts) {
ans *= ncr[y + p.second - 1][p.second];
ans %= MOD;
}
ans *= twoPow(y - 1);
ans %= MOD;
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int n, SQR, q;
long long freq[N], a[N];
long long Ans[N], res;
struct Query {
long long L, R, Index, Bucket_index;
} Range[N];
inline bool comp(Query x, Query y) {
if (x.Bucket_index != y.Bucket_index) return x.Bucket_index < y.Bucket_index;
if (x.Bucket_index & 1) return x.R < y.R;
return x.R > y.R;
}
void Add(int i) {
res -= freq[a[i]] * freq[a[i]] * a[i];
freq[a[i]]++;
res += freq[a[i]] * freq[a[i]] * a[i];
}
void Remove(int i) {
res -= freq[a[i]] * freq[a[i]] * a[i];
freq[a[i]]--;
res += freq[a[i]] * freq[a[i]] * a[i];
}
void solve() {
sort(Range + 1, Range + q + 1, comp);
int CL = 2, CR = 1;
for (int i = 1; i <= q; ++i) {
while (CL < Range[i].L) Remove(CL++);
while (CL > Range[i].L) Add(--CL);
while (CR < Range[i].R) Add(++CR);
while (CR > Range[i].R) Remove(CR--);
Ans[Range[i].Index] = res;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
scanf("%d %d", &n, &q);
SQR = sqrt(n) + 1;
for (int i = 1; i <= n; ++i) scanf("%lld", a + i);
for (int i = 1; i <= q; i++) {
long long L, R;
scanf("%lld %lld", &L, &R);
Range[i].Index = i;
Range[i].Bucket_index = L / SQR;
Range[i].L = L;
Range[i].R = R;
}
solve();
for (int i = 1; i <= q; i++) printf("%lld \n", Ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> data;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
data.push_back(temp);
}
int a = 0, b = 0;
for (int i = m; i < n; i++) {
if (data[i] != 0 && data[i] <= k) {
a = i - m + 1;
break;
}
}
for (int i = m - 1; i >= 0; i--) {
if (data[i] != 0 && data[i] <= k) {
b = m - i - 1;
break;
}
}
if (a == 0) a = n;
if (b == 0) b = n;
cout << min(a, b) * 10 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 211111;
const long long base = 33ll;
int dl, dr, n;
set<pair<int, int> > cars;
vector<pair<int, int> > stay;
int main() {
cin >> n >> dl >> dr;
cars.insert(make_pair(-N, 0 - dl));
cars.insert(make_pair(n + dr, N));
int T;
cin >> T;
while (T--) {
int type;
cin >> type;
if (type - 1) {
int pos;
cin >> pos;
cars.erase(stay[pos - 1]);
} else {
int len;
cin >> len;
for (set<pair<int, int> >::iterator it = cars.begin();;) {
if (it == cars.end()) break;
pair<int, int> left = *it;
++it;
pair<int, int> right = *it;
if (left.second + dl + len + dr <= right.first) {
pair<int, int> ans =
make_pair(left.second + dl, left.second + dl + len);
stay.push_back(ans);
cars.insert(ans);
cout << left.second + dl << '\n';
goto next;
}
}
puts("-1");
}
stay.push_back(make_pair(N, N));
next:;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
const long long inf = 1e18 + 1;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const int MOD3 = 31607;
template <class T>
T _ceil(T a, T b) {
return (a + b - 1) / b;
}
template <class T>
T _min(T a, T b) {
return a > b ? b : a;
};
template <class T>
T _max(T a, T b) {
return a > b ? a : b;
};
template <class T>
T _abs(T a) {
return a > 0 ? a : -a;
};
template <class T>
T _gcd(T a, T b) {
return a ? _gcd(b % a, a) : b;
};
const double PI = 3.1415926535;
double sq(double x) { return x * x; }
double func(double p, double q, double m, double t) {
return sq(p - m * cos(t)) + sq(q - m * sin(t)) - sq(m);
}
int solve() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x == 0 and y == 0) {
k--;
continue;
}
vec.push_back({x, y});
}
int N = (int)vec.size();
if (N == 0) {
cout << 0.0 << "\n";
return 0;
}
double l = 0, r = 2e5 + 1.000001;
while (_abs(l - r) >= 1e-5) {
double m = (l + r) / 2;
vector<pair<double, int>> temp;
for (int i = 0; i < N; i++) {
double p = (double)vec[i].first, q = (double)vec[i].second;
double s = sqrt(p * p + q * q);
if (s > 2 * m) continue;
double a = _abs(acos(p / s));
if (q / s > 0) a *= -1;
double t1 = acos(s / (2 * m)) - a;
while (t1 > 2 * PI) t1 -= 2 * PI;
while (t1 < 0) t1 += 2 * PI;
double t2 = -acos(s / (2 * m)) - a;
while (t2 < 0) t2 += 2 * PI;
while (t2 > 2 * PI) t2 -= 2 * PI;
assert(t1 < 2 * PI and t2 < 2 * PI);
if (t1 > t2) {
double t = t1;
t1 = t2;
t2 = t;
}
if ((p - m) * (p - m) + q * q < m * m) {
temp.push_back({0, 1});
temp.push_back({t1, -1});
temp.push_back({t2, 1});
temp.push_back({2 * PI, -1});
} else {
temp.push_back({t1, 1});
temp.push_back({t2, -1});
}
}
sort(temp.begin(), temp.end());
int count = 0;
bool canDone = false;
for (auto u : temp) {
count += u.second;
if (count >= k) {
canDone = true;
break;
}
}
if (canDone)
r = m;
else
l = m;
}
cout << (l + r) / 2 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 3000;
int n, m;
int a[maxn], l[maxn], r[maxn], pos[maxn];
struct Segtree {
int l, r;
int val;
} node[maxn << 3];
inline int read() {
int x;
scanf("%d", &x);
return x;
}
inline void build(int p, int l, int r) {
node[p].l = l, node[p].r = r;
node[p].val = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
inline void update(int p) {
node[p].val = node[p << 1].val + node[p << 1 | 1].val;
}
inline void change(int p, int vl, int vr, int c) {
if (node[p].l == vl && node[p].r == vr) {
node[p].val += c;
return;
}
int mid = (node[p].l + node[p].r) >> 1;
if (vr <= mid)
change(p << 1, vl, vr, c);
else
change(p << 1 | 1, vl, vr, c);
update(p);
}
inline int query(int p, int vl, int vr) {
if (node[p].l == vl && node[p].r == vr) return node[p].val;
int mid = (node[p].l + node[p].r) >> 1;
if (vr <= mid)
return query(p << 1, vl, vr);
else if (vl > mid)
return query(p << 1 | 1, vl, vr);
else
return query(p << 1, vl, mid) + query(p << 1 | 1, mid + 1, vr);
}
int main() {
n = read(), m = read();
build(1, 1, n + m);
for (int i = 1; i <= n; ++i)
change(1, m + i, m + i, 1), pos[i] = m + i, l[i] = r[i] = i;
for (int i = 1; i <= m; ++i) {
scanf("%d", &a[i]);
l[a[i]] = min(1, l[a[i]]);
r[a[i]] = max(r[a[i]], query(1, 1, pos[a[i]]));
change(1, pos[a[i]], pos[a[i]], -1);
pos[a[i]] = m - i + 1;
change(1, pos[a[i]], pos[a[i]], 1);
}
for (int i = 1; i <= n; ++i) {
r[i] = max(r[i], query(1, 1, pos[i]));
printf("%d %d\n", l[i], r[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 * 2 + 7;
int a[maxn], b[maxn], t[4 * maxn], n, W, H;
void build(int v, int l, int r) {
if (r - l == 1) {
t[v] = a[l];
return;
}
build(2 * v + 1, l, (l + r) / 2);
build(2 * v + 2, (l + r) / 2, r);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
int get(int v, int l, int r, int ql, int qr) {
if (ql <= l && qr >= r) return t[v];
if (ql >= r || qr <= l) return 0;
return max(get(2 * v + 1, l, (l + r) / 2, ql, qr),
get(2 * v + 2, (l + r) / 2, r, ql, qr));
}
void upd(int v, int l, int r, int pos, int x) {
if (r - l == 1) {
t[v] = x;
return;
}
if (pos < (l + r) / 2) {
upd(2 * v + 1, l, (l + r) / 2, pos, x);
} else {
upd(2 * v + 2, (l + r) / 2, r, pos, x);
}
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int ww, hh;
scanf("%d %d", &ww, &hh);
a[i] = hh;
b[i] = ww;
W += ww;
}
build(0, 0, n);
for (int i = 0; i < n; i++) {
W -= b[i];
upd(0, 0, n, i, -10000);
H = get(0, 0, n, 0, n);
printf("%d ", H * W);
W += b[i];
upd(0, 0, n, i, a[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
char s[maxn];
long long num[maxn];
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k, cnt = 0;
scanf("%lld%lld", &n, &k);
scanf("%s", s + 1);
for (long long i = 1; i <= n; i++) {
if (s[i] == '1')
cnt++;
else
num[i] = cnt;
}
long long st = 0, j = 1, res = k;
while (s[j] == '0') j++, st++;
for (long long i = 1; i <= n; i++) {
if (num[i]) {
if (res >= (num[i])) {
res = res - (num[i]);
swap(s[st + 1], s[i]);
st++;
} else {
swap(s[i], s[i - res]);
break;
}
}
}
for (long long i = 1; i <= n; i++) {
printf("%c", s[i]);
num[i] = 0;
}
printf("\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c[1005], used[1005] = {0}, i, j;
cin >> a >> b;
for (i = 1; i <= b; i++) {
int x, y, z, kol = 0;
cin >> x >> y >> z;
for (j = 1; j <= a; j++) {
if (used[j] <= x) kol++;
}
if (kol >= y) {
int ans = 0;
for (j = 1; j <= a; j++) {
if (y == 0)
break;
else if (used[j] <= x) {
ans += j;
used[j] = x + z;
y--;
}
}
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
if (abs(a[i] - a[i - 1]) >= 2) {
cout << "YES" << endl;
cout << i << " " << i + 1 << endl;
return;
}
}
cout << "NO" << endl;
}
int32_t main() {
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int w, h, n;
priority_queue<pair<int, int> > seq[2];
set<int> cuts[2];
int main() {
scanf("%d %d %d ", &w, &h, &n);
seq[0].push(make_pair(h, 0));
seq[1].push(make_pair(w, 0));
for (int i = 0; i < (n); i++) {
char c;
int cut;
scanf("%c %d ", &c, &cut);
int k = 1;
if (c == 'H') {
k = 0;
}
cuts[k].insert(cut);
while (true) {
pair<int, int> t = seq[k].top();
auto it = cuts[k].lower_bound(t.second);
if (it == cuts[k].end() || (*it) > t.second + t.first) {
break;
}
int len1 = (*it) - t.second;
int len2 = t.second + t.first - (*it);
int start1 = t.second;
int start2 = (*it);
cuts[k].erase(it);
seq[k].pop();
seq[k].push(make_pair(len1, start1));
seq[k].push(make_pair(len2, start2));
}
printf("%I64d\n",
(long long)seq[0].top().first * (long long)seq[1].top().first);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k, d, ans, count;
cin >> t;
vector<int> v(101);
vector<bool> taken(101, false);
while (t--) {
cin >> n >> k >> d;
ans = INT_MAX;
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i + d <= n; i++) {
count = 0;
fill(taken.begin(), taken.end(), 0);
for (int j = i; j < i + d; j++) {
if (taken[v[j]] == false) count++;
taken[v[j]] = true;
}
ans = min(ans, count);
}
cout << ans << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
long long int d, low, high, prevv, stay, hp[2 * Maxn5], fnd;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, q;
cin >> n >> q;
for (long long int i = 0; i < n; i++) {
cin >> d;
hp[i] = d + prevv;
prevv = hp[i];
}
while (q--) {
cin >> d;
fnd = stay + d;
high = n, low = 0;
while (high - low > 1) {
long long int mid = (low + high) / 2;
if (hp[mid] < fnd)
low = mid;
else if (fnd <= hp[mid])
high = mid;
}
if (fnd < hp[low])
d = low;
else
d = high;
if (hp[d] == fnd) d++;
if (n == d)
cout << n << '\n';
else
cout << n - d << '\n';
if (d == n)
stay = 0;
else
stay = fnd;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int c0 = 0;
int c1 = 0;
int cq = 0;
for (int i = 0; i < k; i++) {
int f0 = 0;
int f1 = 0;
for (int j = i; j < n; j += k) {
if (s[j] == '0') f0 = 1;
if (s[j] == '1') f1 = 1;
}
if (f0 && f1) {
cout << "NO" << '\n';
return;
} else if (f0) {
c0++;
} else if (f1) {
c1++;
} else {
cq++;
}
}
if (c0 + cq < c1 || c1 + cq < c0) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
while (T--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[20][131073];
map<string, int> atom;
int sum[131073];
int main() {
atom["H"] = 1;
atom["He"] = 2;
atom["Li"] = 3;
atom["Be"] = 4;
atom["B"] = 5;
atom["C"] = 6;
atom["N"] = 7;
atom["O"] = 8;
atom["F"] = 9;
atom["Ne"] = 10;
atom["Na"] = 11;
atom["Mg"] = 12;
atom["Al"] = 13;
atom["Si"] = 14;
atom["P"] = 15;
atom["S"] = 16;
atom["Cl"] = 17;
atom["Ar"] = 18;
atom["K"] = 19;
atom["Ca"] = 20;
atom["Sc"] = 21;
atom["Ti"] = 22;
atom["V"] = 23;
atom["Cr"] = 24;
atom["Mn"] = 25;
atom["Fe"] = 26;
atom["Co"] = 27;
atom["Ni"] = 28;
atom["Cu"] = 29;
atom["Zn"] = 30;
atom["Ga"] = 31;
atom["Ge"] = 32;
atom["As"] = 33;
atom["Se"] = 34;
atom["Br"] = 35;
atom["Kr"] = 36;
atom["Rb"] = 37;
atom["Sr"] = 38;
atom["Y"] = 39;
atom["Zr"] = 40;
atom["Nb"] = 41;
atom["Mo"] = 42;
atom["Tc"] = 43;
atom["Ru"] = 44;
atom["Rh"] = 45;
atom["Pd"] = 46;
atom["Ag"] = 47;
atom["Cd"] = 48;
atom["In"] = 49;
atom["Sn"] = 50;
atom["Sb"] = 51;
atom["Te"] = 52;
atom["I"] = 53;
atom["Xe"] = 54;
atom["Cs"] = 55;
atom["Ba"] = 56;
atom["Lu"] = 71;
atom["Hf"] = 72;
atom["Ta"] = 73;
atom["W"] = 74;
atom["Re"] = 75;
atom["Os"] = 76;
atom["Ir"] = 77;
atom["Pt"] = 78;
atom["Au"] = 79;
atom["Hg"] = 80;
atom["Tl"] = 81;
atom["Pb"] = 82;
atom["Bi"] = 83;
atom["Po"] = 84;
atom["At"] = 85;
atom["Rn"] = 86;
atom["Fr"] = 87;
atom["Ra"] = 88;
atom["Lr"] = 103;
atom["Rf"] = 104;
atom["Db"] = 105;
atom["Sg"] = 106;
atom["Bh"] = 107;
atom["Hs"] = 108;
atom["Mt"] = 109;
atom["Ds"] = 110;
atom["Rg"] = 111;
atom["Cn"] = 112;
atom["Uut"] = 113;
atom["Uuq"] = 114;
atom["Uup"] = 115;
atom["Uuh"] = 116;
atom["Uus"] = 117;
atom["Uuo"] = 118;
atom["La"] = 57;
atom["Ce"] = 58;
atom["Pr"] = 59;
atom["Nd"] = 60;
atom["Pm"] = 61;
atom["Sm"] = 62;
atom["Eu"] = 63;
atom["Gd"] = 64;
atom["Tb"] = 65;
atom["Dy"] = 66;
atom["Ho"] = 67;
atom["Er"] = 68;
atom["Tm"] = 69;
atom["Yb"] = 70;
atom["Ac"] = 89;
atom["Th"] = 90;
atom["Pa"] = 91;
atom["U"] = 92;
atom["Np"] = 93;
atom["Pu"] = 94;
atom["Am"] = 95;
atom["Cm"] = 96;
atom["Bk"] = 97;
atom["Cf"] = 98;
atom["Es"] = 99;
atom["Fm"] = 100;
atom["Md"] = 101;
atom["No"] = 102;
int out, left;
int i, j, n, m;
int s, a[20];
string readin;
string b[20], c[20];
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
cin >> readin;
b[i] = readin;
a[i] = atom[readin];
}
sum[0] = 0;
for (i = 0; i < n; i++) {
s = (1 << i);
for (j = 0; j < s; j++) sum[s + j] = sum[j] + a[i];
}
memset(dp, 0, sizeof(dp));
dp[m][0] = make_pair(1, 0);
for (i = 0; i < m; i++) {
cin >> readin;
c[i] = readin;
a[i] = atom[readin];
}
while (m--)
for (i = (1 << n) - 1; i >= 0; i--)
if (dp[m + 1][i].first == 1) {
s = (1 << n) - 1 - i;
for (j = s; j > 0; j = (j - 1) & s)
if (sum[j] == a[m]) dp[m][i + j] = make_pair(1, j);
}
m = 0;
if (dp[0][(1 << n) - 1].first == 1) {
printf("YES\n");
left = (1 << n) - 1;
while (left) {
out = dp[m][left].second;
for (i = 0; i < n; i++)
if (out & (1 << i)) {
printf("%s", b[i].c_str());
out -= (1 << i);
if (out) printf("+");
}
printf("->%s\n", c[m].c_str());
left -= dp[m][left].second;
m++;
}
} else
printf("NO\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const long double eps = 1e-7;
struct PT {
long double x, y;
int freq;
PT(long double xx = 0, long double yy = 0) : x(xx), y(yy) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(long double c) const { return PT(x * c, y * c); }
PT operator/(long double c) const { return PT(x / c, y / c); }
long double operator*(const PT &p) const { return x * p.x + y * p.y; }
long double operator%(const PT &p) const { return x * p.y - y * p.x; }
long double operator!() const { return sqrtl(x * x + y * y); }
};
struct Segment {
PT p1, p2;
long double a, b, c;
Segment() {}
Segment(PT st, PT en) {
p1 = st, p2 = en;
a = -(st.y - en.y);
b = st.x - en.x;
c = a * en.x + b * en.y;
}
long double plug(long double x, long double y) { return a * x + b * y - c; }
long double plug(PT p) { return plug(p.x, p.y); }
bool inLine(PT p) { return (p - p1) % (p2 - p1) == 0; }
bool inSegment(PT p) {
return inLine(p) && (p1 - p2) * (p - p2) >= 0 && (p2 - p1) * (p - p1) >= 0;
}
PT lineIntersection(Segment s) {
long double A = a, B = b, C = c;
long double D = s.a, E = s.b, F = s.c;
long double x = (long double)C * E - (long double)B * F;
long double y = (long double)A * F - (long double)C * D;
long double tmp = (long double)A * E - (long double)B * D;
x /= tmp;
y /= tmp;
return PT(x, y);
}
};
int w, h;
bool flag;
std::vector<PT> cutPolygon(std::vector<PT> poly, Segment seg) {
int n = (int)poly.size();
std::vector<PT> ans;
flag = false;
for (int i = 0; i < n; i++) {
long double z = seg.plug(poly[i]);
if (z > -eps) {
ans.push_back(poly[i]);
}
long double z2 = seg.plug(poly[(i + 1) % n]);
if ((z > eps && z2 < -eps) || (z < -eps && z2 > eps)) {
ans.push_back(seg.lineIntersection(Segment(poly[i], poly[(i + 1) % n])));
flag = true;
}
}
return ans;
}
Segment getBisector(PT a, PT b) {
Segment ans(a, b);
std::swap(ans.a, ans.b);
ans.b *= -1;
ans.c = ans.a * (a.x + b.x) * 0.5 + ans.b * (a.y + b.y) * 0.5;
return ans;
}
std::vector<std::vector<PT>> getVoronoi(std::vector<PT> pts) {
int n = (int)pts.size();
std::vector<int> p(n, 0);
for (int i = 0; i < n; i++) {
p[i] = i;
}
shuffle(p.begin(), p.end(), rng);
std::vector<std::vector<PT>> ans(n);
ans[0].emplace_back(0, 0);
ans[0].emplace_back(w, 0);
ans[0].emplace_back(w, h);
ans[0].emplace_back(0, h);
for (int i = 1; i < n; i++) {
ans[i] = ans[0];
}
for (auto i : p) {
for (auto j : p) {
if (j == i) continue;
ans[j] = cutPolygon(ans[j], getBisector(pts[j], pts[i]));
if (flag) {
}
}
}
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> w >> h >> n;
std::vector<PT> pts;
for (int i = 0; i < n; i++) {
int x, y;
std::cin >> x >> y;
int id = -1;
for (int j = 0; j < (int)pts.size(); j++) {
if (int(pts[j].x + 0.5) == x && int(pts[j].y + 0.5) == y) {
pts[j].freq++;
id = j;
break;
}
}
if (id == -1) {
PT cur(x, y);
cur.freq = 1;
pts.push_back(cur);
}
}
long double ans = 0;
n = (int)pts.size();
auto voronoi = getVoronoi(pts);
for (int i = 0; i < n; i++) {
auto cell = voronoi[i];
if (pts[i].freq > 1) {
for (auto end : cell) {
ans = std::max(ans, !(end - pts[i]));
}
continue;
}
std::vector<PT> close;
std::vector<bool> got(n, false);
for (int k = 0; k < (int)cell.size(); k++) {
PT curPT = (cell[k] + cell[(k + 1) % (int)cell.size()]) / 2;
long double cur = 1e9;
int id = -1;
for (int j = 0; j < n; j++) {
if (j == i) continue;
long double curDist = !(pts[j] - curPT);
if (curDist < cur) {
cur = curDist;
id = j;
}
}
if (got[id]) continue;
got[id] = true;
close.push_back(pts[id]);
}
for (int k = 0; k < (int)close.size(); k++) {
auto curPoly = cell;
for (int kk = 0; kk < (int)close.size(); kk++) {
if (kk == k) continue;
curPoly = cutPolygon(curPoly, getBisector(close[k], close[kk]));
}
for (auto end : curPoly) {
ans = std::max(ans, !(close[k] - end));
}
}
}
std::cout << std::fixed << std::setprecision(15) << ans << std::endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct hero {
int p, e;
hero() {}
hero(int _p, int _e) : p(_p), e(_e) {}
bool operator<(const hero& other) const {
if (p == other.p) {
return e < other.e;
}
return p < other.p;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tn;
cin >> tn;
while (tn--) {
int n_monster;
cin >> n_monster;
vector<int> p_monster(n_monster);
for (int i = 0; i < n_monster; i++) {
cin >> p_monster[i];
}
int n_hero;
cin >> n_hero;
vector<hero> heros(n_hero);
for (int i = 0; i < n_hero; i++) {
cin >> heros[i].p >> heros[i].e;
}
sort(heros.begin(), heros.end());
vector<int> e_suffix(n_hero);
for (int i = n_hero - 1; i >= 0; i--) {
if (i == n_hero - 1) {
e_suffix[i] = heros[i].e;
} else {
e_suffix[i] = max(heros[i].e, e_suffix[i + 1]);
}
}
auto hero_exists = [&](int max_p_monster, int length) {
int low = 0, high = n_hero, mid;
while (low < high) {
mid = (low + high) >> 1;
if (heros[mid].p >= max_p_monster) {
high = mid;
} else {
low = mid + 1;
}
}
if (low == n_hero) {
return false;
}
return e_suffix[low] >= length;
};
int ans = 0;
for (int monster = 0; monster < n_monster;) {
ans++;
int j = monster;
int max_p_monster = 0;
int length = 0;
while (j < n_monster) {
length++;
max_p_monster = max(max_p_monster, p_monster[j]);
bool exists = hero_exists(max_p_monster, length);
if (!exists) {
break;
}
j++;
}
if (monster == j) {
ans = -1;
break;
}
monster = j;
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int n, m;
long long k, f[N], d[N], h[N], qy[2][2];
string p[2], s[2], str[17], suf[N * 10], ans;
inline bool cmp(string a, string b) {
for (int i = 0; i < min(a.length(), b.length()); i++) {
if (a[i] == b[i]) continue;
if (a[i] < b[i])
return 1;
else
return 0;
}
return a.length() < b.length();
}
int Try(string a) {
int res = 0;
for (int i = 0; i < a.length(); i++) {
if (i + ans.length() - 1 >= a.length()) break;
bool flag = 1;
for (int j = 0; j < ans.length(); j++)
if (a[i + j] != ans[j]) flag = 0;
res += flag;
}
return res;
}
long long solve() {
int len = ans.length();
memset(d, 0, sizeof(d));
memset(h, 0, sizeof(h));
memset(qy, 0, sizeof(qy));
p[0].clear();
p[1].clear();
s[0].clear();
s[1].clear();
d[14] = h[14] = 0;
d[15] = h[15] = 1;
for (int i = 0; i < len - 1; i++)
p[0].push_back(str[14][i]), p[1].push_back(str[15][i]);
for (int i = 1; i <= len - 1; i++)
s[0].push_back(str[14][str[14].length() - len + i]);
for (int i = 1; i <= len - 1; i++)
s[1].push_back(str[15][str[15].length() - len + i]);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) qy[i][j] = Try(p[i] + s[j]);
f[14] = Try(str[14]);
f[15] = Try(str[15]);
for (int i = 16; i <= n; i++) {
h[i] = h[i - 1];
d[i] = d[i - 2];
f[i] = f[i - 1] + f[i - 2];
f[i] += qy[d[i]][h[i]];
if (f[i] > 1e18) return f[i];
}
return f[n];
}
int main() {
scanf("%d%lld%d", &n, &k, &m);
str[0] = "0";
str[1] = "1";
for (int i = 2; i <= 15; i++) str[i] = str[i - 2] + str[i - 1];
if (n <= 15) {
for (int i = 0; i < str[n].length(); i++)
for (int j = i; j < str[n].length(); j++) suf[i + 1].push_back(str[n][j]);
sort(suf + 1, suf + str[n].length() + 1, cmp);
for (int i = 0; i < min(m, (int)suf[k].length()); i++)
printf("%c", suf[k][i]);
return 0;
}
for (int i = 1; i <= m; i++) {
ans.push_back('0');
long long z = solve();
if (z < k) {
k -= z;
ans.pop_back();
ans.push_back('1');
}
int flag = 1;
for (int i = suf[n].length() - ans.length(), j = 0; j < suf[n].length();
i++) {
if (ans[j] != suf[n][i]) flag = false;
j++;
}
k -= flag;
if (k == 0) {
for (int i = 0; i < ans.length(); i++) printf("%c", ans[i]);
return 0;
}
}
for (int i = 0; i < ans.length(); i++) printf("%c", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 400000 + 10;
int lnk[maxn], nxt[maxn], son[maxn], n, m, now, c1, c2, dnt[maxn], mk;
vector<int> nvis[maxn], rt, rv;
vector<vector<int> > res;
bool flag[maxn];
pair<int, int> cnt[maxn];
bool cmp(const int a, const int b) __attribute__((always_inline));
void dfs(int u) {
flag[u] = 1;
for (int v = son[u]; v; v = nxt[v])
if (lnk[v] > 0) {
lnk[v ^ 1] *= -1;
if (!flag[lnk[v]])
dfs(lnk[v]), c2++;
else
lnk[v] = lnk[v ^ 1] = 0, nvis[u].push_back(v / 2),
rt[rt.size() - 1] = u, c1++;
}
}
void efs(int u) {
dnt[u] = 1;
for (int v = son[u]; v; v = nxt[v])
if (lnk[v] > 0) {
efs(lnk[v]);
dnt[u] += dnt[lnk[v]];
if (dnt[lnk[v]] == 1) mk = u;
}
}
void go(int u) {
for (int v = son[u]; v; v = nxt[v])
if (lnk[v]) {
if (lnk[v] < 0) lnk[v] *= -1;
lnk[v ^ 1] = 0;
rv.push_back(lnk[v]);
go(lnk[v]);
rv.push_back(u);
if (now < rt.size()) {
res.push_back(rv);
rv.resize(3);
rv[0] = v / 2;
rv[1] = u;
rv[2] = rt[now++];
res.push_back(rv);
rv.resize(1);
rv[0] = rt[now - 1];
go(rt[now - 1]);
rv.push_back(u);
}
}
for (int i = 0; i < nvis[u].size(); i++)
if (now < rt.size()) {
res.push_back(rv);
rv.resize(3);
rv[0] = nvis[u][i];
rv[1] = u;
rv[2] = rt[now++];
res.push_back(rv);
rv.resize(1);
rv[0] = rt[now - 1];
go(rt[now - 1]);
rv.push_back(u);
} else
break;
}
bool cmp(const int a, const int b) {
return (a == 1 || (b != 1 && cnt[a] > cnt[b]));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, j = 1, u, v; i < m; i++) {
scanf("%d%d", &u, &v);
lnk[++j] = v;
nxt[j] = son[u];
son[u] = j;
lnk[++j] = u;
nxt[j] = son[v];
son[v] = j;
}
for (int i = 1; i <= n; i++)
if (!flag[i]) {
c1 = c2 = 0;
rt.push_back(i);
dfs(i);
cnt[rt[rt.size() - 1]] = make_pair(c1, c2);
}
rt[0] = 1;
sort(rt.begin(), rt.end(), cmp);
for (int i = 1; i < rt.size(); i++) {
mk = rt[i];
efs(rt[i]);
if (!nvis[rt[i]].size()) rt[i] = mk;
}
while (now < rt.size()) {
if (now) {
int k = -1;
if (nvis[rt[now]].size()) {
k = nvis[rt[now]][nvis[rt[now]].size() - 1];
nvis[rt[now]].pop_back();
} else {
for (int i = son[rt[now]]; i; i = nxt[i])
if (lnk[i] > 0 && dnt[lnk[i]] == 1) {
k = i / 2;
rt.push_back(abs(lnk[i]));
lnk[i] = lnk[i ^ 1] = 0;
break;
}
}
if (k == -1) break;
rv.resize(3);
rv[0] = k;
rv[1] = 1;
rv[2] = rt[now];
res.push_back(rv);
rv.clear();
}
rv.push_back(rt[now++]);
go(rt[now - 1]);
if (rv[rv.size() - 1] != 1) rv.push_back(1);
res.push_back(rv);
}
if (now < rt.size()) {
printf("NO\n");
return 0;
}
printf("YES\n");
printf("%d\n", res.size() / 2);
for (int i = 0; i < res.size(); i++)
if (!(i & 1)) {
printf("%d", res[i].size());
for (int j = 0; j < res[i].size(); j++) printf(" %d", res[i][j]);
printf("\n");
} else
printf("%d %d %d\n", res[i][0], res[i][1], res[i][2]);
}
| 10 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int v1 = 1e5 + 5;
const int N = 3e5 + 5;
using namespace std;
vector<vector<long long>> adj(500);
vector<bool> visited(500);
long long m = 0;
void dfs(long long v) {
visited[v] = true;
for (auto i : adj[v])
if (!visited[i]) dfs(i);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n = 0;
long long x, y;
bool flag = true;
long long ans = 0;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> x;
if (x == 0) ans++;
for (long long j = 0; j < x; j++) {
flag = false;
cin >> y;
adj[y].push_back(i + m + 1);
adj[i + m + 1].push_back(y);
}
}
if (flag) ans++;
for (long long i = 1; i <= n + m; i++) {
if (!visited[i] && adj[i].size() != 0) {
dfs(i);
ans++;
}
}
cout << ans - 1 << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
int a[200][200];
cin >> m >> n;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
int r[200], c[200];
for (int i = 0; i < m; i++) r[i] = -1;
for (int i = 0; i < n; i++) c[i] = -1;
int val = a[0][0];
for (int j = 0; j < n; j++)
if (a[0][j] < val) val = a[0][j];
r[0] = val;
for (int j = 0; j < n; j++) c[j] = a[0][j] - r[0];
for (int i = 1; i < m; i++) {
int val = a[i][0];
for (int j = 0; j < n; j++)
if (a[i][j] < val) val = a[i][j];
r[i] = val;
for (int j = 0; j < n; j++) {
if (r[i] + c[j] != a[i][j]) {
cout << -1;
return 0;
}
}
}
if (m < n) {
int allc = c[0];
for (int j = 0; j < n; j++)
if (c[j] < allc) allc = c[j];
for (int j = 0; j < n; j++) c[j] -= allc;
for (int i = 0; i < m; i++) r[i] += allc;
} else {
int allr = r[0];
for (int i = 0; i < m; i++)
if (r[i] < allr) allr = r[i];
for (int i = 0; i < m; i++) r[i] -= allr;
for (int j = 0; j < n; j++) c[j] += allr;
}
int total = 0;
for (int i = 0; i < m; i++) total += r[i];
for (int j = 0; j < n; j++) total += c[j];
cout << total << endl;
for (int i = 0; i < m; i++) {
for (int j = 0; j < r[i]; j++) cout << "row " << i + 1 << endl;
}
for (int j = 0; j < n; j++) {
for (int i = 0; i < c[j]; i++) cout << "col " << j + 1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class Array {
public:
long long total;
long long left;
long long right;
long long mmax;
Array() {
this->total = 0;
this->left = -(1 << 30);
this->mmax = -(1 << 30);
this->right = 0;
}
};
vector<Array> v;
vector<int> sequence;
void init(int m, int n) {
v.resize(m, Array());
for (int i = 0; i < m; i++) {
int len;
cin >> len;
int sum = 0;
int mmax = -(1 << 30);
int number;
for (int j = 0; j < len; j++) {
cin >> number;
sum += number;
v[i].total += number;
v[i].left = max(v[i].left, v[i].total);
v[i].right = min(v[i].right, v[i].total);
mmax = max(mmax, sum);
if (sum < 0) sum = 0;
}
v[i].mmax = mmax;
v[i].right = v[i].total - v[i].right;
}
sequence.resize(n, 0);
for (int i = 0; i < n; i++) {
cin >> sequence[i];
sequence[i]--;
}
}
long long solve(int m, int n) {
long long ret = (long long)(-1e18);
long long sum = 0;
for (int i = 0; i < n; i++) {
ret = max(ret, v[sequence[i]].mmax);
ret = max(ret, sum + v[sequence[i]].left);
sum = max(sum + v[sequence[i]].total, v[sequence[i]].right);
if (sum < 0) sum = 0;
}
return ret;
}
int main(int argc, char* argv[]) {
int m, n;
cin >> m >> n;
init(m, n);
cout << solve(m, n) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
short Print_Array[20];
template <typename T>
inline void print(T x, char tm = '\n') {
if (x < 0) putchar('-'), x = -x;
short sz = 0;
while (x) Print_Array[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + Print_Array[i]);
putchar(tm);
}
template <typename T>
void cma(T &a, T b) {
if (b > a) a = b;
}
template <typename T>
void cmi(T &a, T b) {
if (b < a) a = b;
}
const double eps = 1e-9;
const int oo = 0x3f3f3f3f;
const long long OO = 0x3f3f3f3f3f3f3f3f, mod = 1e9 + 7;
using namespace std;
const int modo = 1000000007;
struct matrix {
int a[101][101];
matrix(int t = 1) {
int i, j;
for (i = 0; i < 101; i++) {
for (j = 0; j < 101; j++) {
if (i == j) {
a[i][j] = t;
} else {
a[i][j] = 0;
}
}
}
}
friend matrix operator*(const matrix &a, const matrix &b) {
matrix c(0);
int i, j, k;
for (i = 0; i < 101; i++) {
for (j = 0; j < 101; j++) {
for (k = 0; k < 101; k++) {
c.a[i][k] = (c.a[i][k] + (long long)a.a[i][j] * b.a[j][k]) % modo;
}
}
}
return c;
}
};
matrix a[105];
matrix init;
char b[105];
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", b);
int i;
for (i = 0; i < n; i++) {
if (b[i] == '0') {
a[0].a[i][i + 1]++;
if (i == n - 1) {
int j;
for (j = i - 1; j >= 0; j--) {
int k;
for (k = 0; k <= j; k++) {
if (b[k] != b[i - j + k]) break;
}
if (k > j) break;
}
a[0].a[i][j + 1]++;
}
int j;
for (j = i - 1; j >= 0; j--) {
if (b[j] != '1') continue;
int k;
for (k = 0; k < j; k++) {
if (b[k] != b[i - j + k]) break;
}
if (k == j) break;
}
a[1].a[i][j + 1]++;
} else {
a[1].a[i][i + 1]++;
if (i == n - 1) {
int j;
for (j = i - 1; j >= 0; j--) {
int k;
for (k = 0; k <= j; k++) {
if (b[k] != b[i - j + k]) break;
}
if (k > j) break;
}
a[1].a[i][j + 1]++;
}
int j;
for (j = i - 1; j >= 0; j--) {
if (b[j] != '0') continue;
int k;
for (k = 0; k < j; k++) {
if (b[k] != b[i - j + k]) break;
}
if (k == j) break;
}
a[0].a[i][j + 1]++;
}
}
a[0].a[n][n]++;
a[1].a[n][n]++;
for (i = 2; i <= k; i++) {
a[i] = a[i - 1] * a[i - 2];
}
printf("%d\n", a[k].a[0][n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
map<int, int> ma;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
ma[val] = i + 1;
}
string s = "";
if (n == 1)
cout << 1 << endl;
else {
int m = n;
int M = 1;
for (int i = 1; i < n; i++) {
m = min(m, ma[i]);
M = max(M, ma[i]);
if (abs(m - M) == i - 1)
s += '1';
else
s += '0';
}
cout << s + "1" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N];
int main() {
int t, n, c;
cin >> t;
while (t--) {
int a0 = 0, a1 = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c;
a[i] = c & 1;
if (a[i])
a1++;
else
a0++;
}
if (abs(a1 - a0) > 1) {
cout << "-1" << endl;
} else {
int cnt, tp, s;
if (a1 - a0 == 0) {
int cnt1 = 0, cnt2 = 0;
tp = 1;
s = a[1];
for (int i = 1; i <= n; i++) {
if (a[i] == s) {
cnt1 += abs(tp - i);
tp += 2;
}
}
tp = 1;
s = !a[1];
for (int i = 1; i <= n; i++) {
if (a[i] == s) {
cnt2 += abs(tp - i);
tp += 2;
}
}
cnt = min(cnt1, cnt2);
} else {
cnt = 0, s;
if (a1 > a0) {
s = 1;
} else
s = 0;
if (a[1] != s)
tp = 1;
else
tp = 3;
for (int i = 2; i <= n; i++) {
if (a[i] == s) {
cnt += abs(tp - i);
tp += 2;
}
}
}
cout << cnt << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
#pragma optimize("Ofast")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
unordered_map<string, int> um;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
string t = "";
int n = s.length();
int cnt_k = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'k') {
int j = i;
while (j < n && s[j] == 'k') {
j++;
}
if (j < n && s[j] == 'h') {
t += 'h';
i = j;
} else {
t += 'k';
}
} else if (s[i] == 'o' || s[i] == 'u') {
int cnt_o = 0, j = i;
while (j < n && (s[j] == 'o' || s[j] == 'u')) {
if (s[j] == 'o') {
cnt_o++;
} else if (s[j] == 'u') {
t += 'u';
}
j++;
}
int x = cnt_o / 2;
for (int k = 1; k <= x; k++) {
t += 'u';
}
if (cnt_o & 1) {
t += 'o';
}
i = j - 1;
} else {
t += s[i];
}
}
um[t]++;
}
cout << um.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tmp = 0, r, s, d;
cin >> n;
long long day;
for (int i = 0; i < n; i++) {
cin >> s >> d;
while (s <= tmp) s += d;
tmp = s;
}
cout << tmp << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct people {
int a, d, id;
bool operator<(people other) const {
if (a != other.a) return a > other.a;
return id < other.id;
}
};
people s[111];
int n;
int main() {
int i, j, ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d", &s[i].a, &s[i].d);
s[i].id = i;
}
sort(s + 1, s + 1 + n);
vector<int> ret;
for (i = 1; i <= n; ++i) {
if (s[i].d < 0) {
ret.push_back(s[i].id);
}
}
for (auto v : ret) {
for (i = 1; i <= n; ++i) {
if (s[i].id == v) {
j = i;
while (j < n &&
(s[j].a + s[j].d < s[j + 1].a ||
(s[j].a + s[j].d == s[j + 1].a && s[j].id > s[j + 1].id))) {
swap(s[j], s[j + 1]);
ans++;
j++;
}
s[j].a = s[j].a + s[j].d;
break;
}
}
}
ret.clear();
for (i = n; i >= 1; --i) {
if (s[i].d > 0) {
ret.push_back(s[i].id);
}
}
for (auto v : ret) {
for (i = n; i >= 1; --i) {
if (s[i].id == v) {
j = i;
while (j > 1 &&
(s[j].a + s[j].d > s[j - 1].a ||
(s[j].a + s[j].d == s[j - 1].a && s[j].id < s[j - 1].id))) {
swap(s[j], s[j - 1]);
ans++;
j--;
}
s[j].a = s[j].a + s[j].d;
break;
}
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, l = 0, r = 2e+5 + 1;
vector<long long> mas;
bool check(long long num) {
long long kc = k, mc = m;
for (long long i = num; i < n; i++) {
if (mc == 0 || k < 0) {
return 0;
}
if (mas[i] <= kc) {
kc -= mas[i];
} else {
kc = k;
kc -= mas[i];
mc--;
}
}
if (mc == 0 || k < 0) {
return 0;
}
return 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
r = n - 1;
mas.resize(n);
for (long long i = 0; i < n; i++) {
cin >> mas[i];
}
while (r - l > 1) {
long long mid = (r + l) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (check(l)) {
cout << n - l;
} else if (check(r)) {
cout << n - r;
} else {
cout << 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, maxx = -1, a, b, prev, curr, counter, i, x;
cin >> n >> k;
deque<int> dq;
for (i = 0; i < n; i++) {
cin >> x;
maxx = max(x, maxx);
dq.push_back(x);
}
if (k > n)
cout << maxx << endl;
else {
counter = 1;
a = dq.front();
dq.pop_front();
b = dq.front();
dq.pop_front();
prev = max(a, b);
dq.push_back(min(a, b));
dq.push_front(max(a, b));
while (counter != k) {
a = dq.front();
dq.pop_front();
b = dq.front();
dq.pop_front();
curr = max(a, b);
if (curr == prev)
counter++;
else
counter = 1;
dq.push_back(min(a, b));
dq.push_front(max(a, b));
prev = curr;
}
cout << curr << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[300005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
sort(arr, arr + n);
if (arr[0] <= k + 1)
printf("%d\n", arr[0]);
else {
bool ok = false;
int d = arr[0];
while (1) {
bool update = false;
for (int i = 0; i < n; ++i) {
while ((arr[i] % d) > k) {
d--;
update = true;
}
}
if (!update) break;
}
printf("%d\n", d);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
ostream &operator<<(ostream &out, vector<long long> &a) {
for (auto i : a) out << i << " ";
return out;
}
istream &operator>>(istream &in, vector<long long> &a) {
for (auto &i : a) in >> i;
return in;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long q;
cin >> q;
while (q--) {
string a, b, c;
cin >> a >> b >> c;
bool boo = 0;
for (long long i = 0; i < a.size(); ++i) {
if (c[i] != b[i] && c[i] != a[i]) {
cout << "NO"
<< "\n";
boo = 1;
break;
}
}
if (!boo)
cout << "YES"
<< "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
bool prime;
long long n, k;
cin >> n;
while (n--) {
cin >> k;
long long s = floor(sqrt(k));
if (s * s != k || k == 1) {
cout << "NO" << endl;
continue;
} else if (s == 2) {
cout << "YES" << endl;
continue;
} else if (k % 2 == 0) {
cout << "NO" << endl;
continue;
}
prime = true;
for (long long i = 3; i * i <= s; i += 2)
if (s % i == 0) {
prime = false;
break;
}
if (prime)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, m, k, g[11][11], f[11][11], cnt[11], lg[1 << 11];
int Dfs(int x, int y) {
if (y > m) x++, y = 1;
if (x > n) return 1;
int res = 0;
for (int tmp = -1, pre = f[x - 1][y] & f[x][y - 1], con = pre, col; con > 0;
con -= ((con) & -(con))) {
col = lg[((con) & -(con))];
f[x][y] = pre ^ ((con) & -(con));
if (g[x][y] == 0 || g[x][y] == col) {
if (cnt[col] == 0) {
cnt[col]++;
res += tmp == -1 ? tmp = Dfs(x, y + 1) : tmp;
cnt[col]--;
} else
res += Dfs(x, y + 1);
res = ((res) % 1000000007);
}
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (n + m > k + 1) {
printf("0\n");
return 0;
}
for (int i = 1; i <= k; i++) lg[1 << i - 1] = i;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) f[i][j] = (1 << k) - 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &g[i][j]);
if (g[i][j] != 0) cnt[g[i][j]]++;
}
printf("%d\n", Dfs(1, 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double eps = 1e-12;
const double PI = acos(-1.0);
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const long long nax = 5e5 + 5;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
void solve() {
long long int i, n, ans, k, m, j;
cin >> n;
if (n % 10 == 9) {
ans = 1;
n /= 10;
n += 1;
cout << n << "\n";
} else {
cout << n / 10 << "\n";
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t = 1, i;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> fact(k, -1);
for (int i = 0; i < k; i++) {
for (int j = i; j < n; j += k) {
if (s[j] == '0' && fact[i] == -1) {
fact[i] = 0;
}
if (s[j] == '1' && fact[i] == -1) {
fact[i] = 1;
}
if (s[j] == '1' && fact[i] == 0) {
fact[i] = -2;
}
if (s[j] == '0' && fact[i] == 1) {
fact[i] = -2;
}
}
}
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < k; i++) {
if (fact[i] == -2) return 0;
if (fact[i] == 0) {
cnt1++;
}
if (fact[i] == 1) {
cnt2++;
}
}
return (cnt1 <= k / 2 && cnt2 <= k / 2);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
if (solve()) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
map<int, int> mp;
int a[n], temp, ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
if (mp.find(a[i]) == mp.end()) {
mp[a[i]] = i;
}
}
for (int i = 0; i < n; i++) {
temp = mp[a[i]];
map<int, int> cnt;
int max = 0;
for (int j = i; j <= temp; j++) {
if (cnt.find(a[j]) == cnt.end())
cnt[a[j]] = 1;
else {
cnt[a[j]]++;
}
if (cnt[a[j]] > max) {
max = cnt[a[j]];
}
if (temp < mp[a[j]]) {
temp = mp[a[j]];
}
}
ans = ans + temp - i + 1 - max;
i = temp;
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, k, a[1003], dp[1003][1003], l[1003], res, pre[1003][1003];
int cal(int val) {
for (int i = 0; i <= k; i++)
for (int j = 0; j <= n; j++) dp[i][j] = 0;
l[0] = 0;
for (int i = 1; i <= n; i++) {
l[i] = l[i - 1];
while (a[i] - a[l[i] + 1] >= val) l[i]++;
}
dp[0][0] = 1;
for (int i = 0; i < k; i++) {
pre[i][0] = dp[i][0];
for (int j = 1; j <= n; j++) {
pre[i][j] = (pre[i][j - 1] + dp[i][j]) % mod;
dp[i + 1][j] = pre[i][l[j]];
}
}
int res = 0;
for (int i = 1; i <= n; i++) res = (res + dp[k][i]) % mod;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i * (k - 1) <= 100010; i++) res = (res + cal(i)) % mod;
cout << res;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
set<char> a;
int i, n;
getline(cin, s);
n = s.length();
for (i = 0; i < n; i++) {
a.insert(s[i]);
}
if (a.size() > 3)
cout << a.size() - 4;
else
cout << a.size() - 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long m = 1e9 + 7;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long 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 << '\"'; }
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) {
int 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...);
}
void solve() {
string a, s;
cin >> a >> s;
string b;
bool flag = true;
int i = a.length(), j = s.length();
while (i > 0 && j > 0) {
if (s.back() >= a.back()) {
b = to_string(s.back() - a.back()) + b;
s.pop_back();
a.pop_back();
i--, j--;
} else {
b = to_string(10 + s.back() - a.back()) + b;
s.pop_back();
a.pop_back();
i--, j--;
if (s.empty() || s.back() != '1') {
b = "-1";
flag = false;
break;
}
s.pop_back();
j--;
}
}
if (i > 0 && j == 0) {
b = "-1";
}
if (j > 0 && flag) {
b = s + b;
}
while (b[0] == '0') {
b = b.substr(1);
}
cout << b << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 998244353;
const long long int INF = 1e18;
int main() {
vector<long long int> a(6);
for (int i = 0; i < 6; i++) cin >> a[i];
int n;
cin >> n;
vector<long long int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
vector<pair<long long int, long long int> > c;
for (int i = 0; i < n; i++)
for (int j = 0; j < 6; j++) {
if (b[i] - a[j] >= 0) {
c.push_back({b[i] - a[j], i});
}
}
sort(c.begin(), c.end());
int m = c.size();
int p = 0, l = 0;
long long int ans = INF;
vector<long long int> f(n, 0);
for (int i = 0; i < m; i++) {
if (f[c[i].second] == 0) p++;
f[c[i].second]++;
if (p == n) {
ans = min(ans, c[i].first - c[l].first);
for (int j = l; 1; j++) {
if (f[c[j].second]-- == 1) {
l = j + 1;
p--;
break;
} else {
ans = min(ans, c[i].first - c[j + 1].first);
}
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)4e5 + 7;
const int M = 20;
int n, a[N];
vector<int> u[M];
set<int> s;
int t[M];
long long dp[(1 << M)];
int bits[M], top;
bool act[M];
long long score[M][M];
int cnt(int col, int p) {
int l = 0, r = (int)u[col].size() - 1, ans = 0;
while (l <= r) {
int m = (l + r) / 2;
if (u[col][m] <= p) {
ans = m + 1;
l = m + 1;
} else {
r = m - 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]--;
s.insert(a[i]);
}
int all = 0;
for (auto &x : s) {
t[x] = all++;
}
for (int i = 1; i <= n; i++) {
a[i] = t[a[i]];
u[a[i]].push_back(i);
}
for (int i = 0; i < all; i++) {
for (int j = 0; j < all; j++) {
if (i != j) {
for (auto &it : u[i]) {
score[i][j] += cnt(j, it);
}
}
}
}
for (int mask = 1; mask < (1 << all); mask++) {
top = 0;
for (int bit = 0; (1 << bit) <= mask; bit++) {
if (mask & (1 << bit)) {
bits[top++] = bit;
act[bit] = 1;
}
}
dp[mask] = (1LL << 60);
for (int i = 0; i < top; i++) {
int x = bits[i];
long long now = dp[mask - (1 << x)];
for (int y = 0; y < all; y++) {
if (act[y] == 0) {
now += score[x][y];
}
}
dp[mask] = min(dp[mask], now);
}
for (int i = 0; i < top; i++) {
act[bits[i]] = 0;
}
}
cout << dp[(1 << all) - 1] << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> A, B;
bool check(int val, int c, int n) {
long long int sum = 0;
for (int i = 1, j = n - val + 1; i <= val; i++, j++) {
if (B[i] > A[j]) sum += (B[i] - A[j]);
}
return c >= sum;
}
int main() {
int n, m, c;
cin >> n >> m >> c;
A.resize(n + 1);
B.resize(m + 1);
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= m; i++) cin >> B[i];
sort(A.begin() + 1, A.end());
sort(B.begin() + 1, B.end());
int L = 0, R = min(n, m), M;
while (L <= R) {
M = (L + R) / 2;
bool f1 = check(M, c, n);
bool f2 = check(M + 1, c, n);
if (f1 && f2 == 0)
break;
else if (f1)
L = M + 1;
else
R = M - 1;
}
cout << M << " ";
long long int ans = 0;
while (M) {
if (A[n] <= B[M])
ans += A[n], c -= (B[M] - A[n]);
else
ans += B[M];
M--;
n--;
}
ans -= c;
ans = max(ans, 0LL);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e6 + 10;
int cnt[maxn];
int n, u;
int ch[maxn][2], node_cnt = 0, siz[maxn];
void ins(int x) {
int now = 0;
siz[now]++;
for (int i = 31; i >= 0; i--) {
int idx = (x >> i) & 1;
if (!ch[now][idx]) {
ch[now][idx] = ++node_cnt;
}
now = ch[now][idx];
siz[now]++;
}
}
int ans = 2e5;
void dfs(int now, int temp) {
if (!ch[now][0] && !ch[now][1]) {
ans = min(temp, ans);
return;
} else if (ch[now][0] && !ch[now][1])
dfs(ch[now][0], temp);
else if (!ch[now][0] && ch[now][1])
dfs(ch[now][1], temp);
else {
dfs(ch[now][1], temp + siz[ch[now][0]] - 1);
dfs(ch[now][0], temp + siz[ch[now][1]] - 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &u);
ins(u);
}
dfs(0, 0);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
struct Op {
int x, y, z;
Op(int x, int y, int z) : x(x), y(y), z(z) {}
};
vector<int> adj[200016];
int deg[200016];
int n, half;
vector<Op> ans;
vector<int> cids;
int get_cids(int u, int p = 0) {
int s = 1;
bool f = true;
for (int v : adj[u]) {
if (v == p) continue;
int t = get_cids(v, u);
s += t;
if (t > half) f = false;
}
if (f && n - s <= half) cids.push_back(u);
return s;
}
bool onp[200016];
vector<int> path;
int branch = 0;
void op(int x, int y, int z) { ans.emplace_back(x, y, z); }
void add(int v) {
path.push_back(v);
onp[v] = true;
}
void dfs(int u, int p) {
if (deg[u] == 1) {
if (!onp[p]) {
int x = path.back();
int y = branch;
op(x, y, u);
++deg[u];
--deg[y];
branch = 0;
}
add(u);
} else if (onp[p]) {
if (deg[u] == 2)
add(u);
else
branch = u;
}
for (int v : adj[u]) {
if (v == p) continue;
dfs(v, u);
if (onp[u] || !onp[v]) continue;
if (deg[u] == 2)
add(u);
else
branch = u;
}
}
void solve(int c) {
for (int v : adj[c]) {
path.clear();
add(c);
dfs(v, c);
int sz = (int)path.size();
int mid = path[sz - 2];
for (int i = sz - 3; i > 0; --i) op(path[i - 1], path[i], mid);
}
}
int main() {
canhazfast();
cin >> n;
half = n / 2;
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
++deg[a];
++deg[b];
}
get_cids(1);
if (cids.size() == 2) {
int a = cids[0], b = cids[1];
adj[a].erase(find((adj[a]).begin(), (adj[a]).end(), b));
adj[b].erase(find((adj[b]).begin(), (adj[b]).end(), a));
}
for (int c : cids) solve(c);
cout << ans.size() << '\n';
for (Op o : ans) cout << o.x << ' ' << o.y << ' ' << o.z << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r, l, maxN;
int a[1000010], cnt[10000010];
vector<int> p, q;
bool check[10000010];
void init() {
memset(check, false, sizeof check);
check[0] = check[1] = true;
p.push_back(0);
q.push_back(0);
for (int i = 2; i <= maxN; i++) {
if (check[i]) continue;
int j = 2;
int res = cnt[i];
while (i * j <= maxN) {
check[i * j] = true;
res += cnt[i * j];
j++;
}
p.push_back(i);
q.push_back(res);
}
for (int i = 1; i < (int)p.size(); i++) q[i] = q[i - 1] + q[i];
}
int binSearch(int x, int l, int r, bool small) {
while (l <= r) {
int mid = (l + r) / 2;
if (p[mid] < x)
l = mid + 1;
else if (p[mid] > x)
r = mid - 1;
else
return mid;
}
if (small && p[r] < x) r++;
if (!small && p[r] > x) r--;
return r;
}
void solve() {
int u = binSearch(l, 1, (int)p.size() - 1, true);
int v = binSearch(r, 1, (int)p.size() - 1, false);
cout << q[v] - q[u - 1] << endl;
}
void input() {
cin >> n;
maxN = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
maxN = max(maxN, a[i]);
}
init();
cin >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r;
solve();
}
}
int main() {
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
};
input();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int block[5], dat[20000];
inline int mi(int a, int b) { return a < b ? a : b; }
int main(void) {
int n, k;
int x;
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
scanf("%d", &x);
dat[x]++;
}
block[2] = n << 1, block[4] = n;
for (int i = 10000; i >= 1; i--) {
int j;
while (dat[i]--) {
for (j = 4; j > 0; j--) {
if (block[j]) {
block[j]--;
if (i < 4 && j == 4) {
if (i == 1) block[2]++;
if (i == 2) block[1]++;
}
if (i - j > 0) dat[i - j]++;
break;
}
}
if (!j) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005] = {0};
long long sum[100005] = {0};
long long n, t, mx = 0;
long long sumc(int l, int r) { return (r < l ? 0 : sum[r] - sum[l - 1]); }
bool isgood(long long x) {
for (int l = 0, r = x - 1; r < n; ++l, ++r)
if (sumc(l, r) <= t) return true;
return false;
}
long long check(int low, int high) {
if (low == high) {
return low;
}
int mid = (low + high + 1) / 2;
if (low == high - 1) {
if (isgood(high)) {
return high;
}
return low;
} else {
if (isgood(mid))
check(mid, high);
else
check(low, mid - 1);
}
}
int main() {
cin >> n >> t;
sum[-1] = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum[i] = a[i] + sum[i - 1];
}
mx = check(0, n);
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1003];
int used[1003];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool toR = true;
multiset<int> l, r;
for (int i = 0; i < n; i++) r.insert(a[i]);
int cur = 0, ans = 0;
int i = 0;
while (true) {
if (toR) {
if (i == -1) i++;
for (; i < n; i++) {
if (!r.empty() && *r.begin() > cur) break;
if (!used[i]) {
if (a[i] <= cur) {
cur++;
used[i] = true;
} else {
r.erase(r.find(a[i]));
l.insert(a[i]);
}
}
}
} else {
if (i == n) i -= 1;
for (; i > -1; i--) {
if (!l.empty() && *l.begin() > cur) break;
if (!used[i]) {
if (a[i] <= cur) {
cur++;
used[i] = true;
} else {
l.erase(l.find(a[i]));
r.insert(a[i]);
}
}
}
}
if (cur == n) {
cout << ans << endl;
return 0;
}
toR = !toR;
ans++;
}
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <algorithm>
#include <ctime>
using namespace std;
void solve(int tcase) {
int n;
cin >> n;
vector<long long> d(n);
for (int i = 0; i < n; ++i) {
cin >> d[i];
}
sort(d.begin(), d.end());
long long res = d.back();
long long csum = 0;
for (int i = 1; i < n; ++i) {
res -= d[i] * i;
res += csum;
csum += d[i];
}
cout << res << "\n";
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
//t = 1;
for (int tt = 0; tt < t; ++tt) {
solve(tt + 1);
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, m, cntdep[N], type[N];
vector<int> rdep[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> type[i];
for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v;
++cntdep[u];
rdep[v].emplace_back(u);
}
int ans = 0, cnt = 0;
queue<int> ma, co;
for (int i = 0; i < n; ++i) {
if (cntdep[i] == 0) {
if (type[i])
co.emplace(i);
else
ma.emplace(i);
}
}
while (cnt < n) {
while (!ma.empty()) {
int u = ma.front();
ma.pop();
++cnt;
for (int v : rdep[u]) {
if (--cntdep[v] == 0) {
if (type[v])
co.emplace(v);
else
ma.emplace(v);
}
}
}
if (!co.empty()) ++ans;
while (!co.empty()) {
int u = co.front();
co.pop();
++cnt;
for (int v : rdep[u]) {
if (--cntdep[v] == 0) {
if (type[v])
co.emplace(v);
else
ma.emplace(v);
}
}
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long a[52000];
void init() {
int i = 0;
int k;
k = 1;
while (1) {
i++;
if ((i + 1) * i >= 2100000000) break;
k = i * (i + 1);
a[i] = k / 2;
}
}
int got(int x) {
int l, r, m;
l = 1;
r = 45825;
m = (l + r) >> 1;
while (1) {
if (x == 997146153) {
l = l;
r = r;
}
if (a[m] == x || a[r] == x || a[l] == x) return 1;
if (x > a[m])
l = m;
else
r = m;
m = (l + r) >> 1;
if (a[l] != x && a[r] != x && (r - l <= 1)) return 0;
}
}
int main() {
int t, l, r, m, i, n, flag = 0;
init();
scanf("%d", &n);
l = 1;
r = 45825;
for (i = 1; i <= 45825; i++) {
m = n - a[i];
if (a[i] > n) break;
if (got(m)) {
flag = 1;
break;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 35;
int d[2 * N][N][4 * N * N];
tuple<int, int, int> pr[2 * N][N][4 * N * N];
int a[N];
int n;
int res[2 * N][2 * N];
bool is[2 * N][2 * N];
bool use[2 * N];
int need[2 * N];
void rest(vector<int> ans) {
memset(is, 0, sizeof(is));
for (int i = int(0); i < int(((int)(ans).size())); ++i) {
need[i] = ans[i];
ans[i] = ((int)(ans).size()) - 1 - ans[i];
}
for (int i = int(0); i < int(((int)(ans).size())); ++i) {
int minn = 1e9, mini = -1;
for (int j = int(0); j < int(((int)(ans).size())); ++j) {
if (use[j]) continue;
if (umn(minn, ans[j])) {
mini = j;
}
}
use[mini] = 1;
vector<pair<int, int> > help;
int cnt = need[mini];
for (int j = int(0); j < int(((int)(ans).size())); ++j) {
if (!cnt) break;
if (j == mini) continue;
if (use[j]) {
if (!is[mini][j]) {
cnt--;
is[mini][j] = is[j][mini] = 1;
res[mini][j] = 1;
res[j][mini] = 0;
}
} else {
help.push_back(make_pair(ans[j], j));
}
}
sort((help).begin(), (help).end());
reverse((help).begin(), (help).end());
for (int j = int(0); j < int(cnt); ++j) {
int idx = help[j].second;
ans[idx]--;
is[mini][idx] = is[idx][mini] = 1;
res[mini][idx] = 1;
res[idx][mini] = 0;
}
}
}
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
cin >> n;
for (int i = int(0); i < int(n); ++i) cin >> a[i];
sort(a, a + n);
d[0][0][0] = true;
pr[0][0][0] = make_tuple(-1, -1, -1);
vector<int> ans;
for (int i = int(0); i < int(2 * N); ++i) {
for (int j = 0; j <= n; ++j) {
for (int sum = 0; sum < 4 * N * N; ++sum) {
if (!d[i][j][sum]) {
pr[i][j][sum] = make_tuple(-1, -1, -1);
continue;
}
if (i + 1 == 2 * N) continue;
if (j < n) {
int res = sum + a[j] - i;
if (res >= 0 && res < 4 * N * N) {
d[i + 1][j + 1][res] = 1;
pr[i + 1][j + 1][res] = make_tuple(i, j, sum);
}
}
if (j) {
int res = sum + a[j - 1] - i;
if (res < 0 || res >= 4 * N * N) continue;
d[i + 1][j][res] = 1;
pr[i + 1][j][res] = make_tuple(i, j, sum);
}
}
}
if (i > 0 && d[i][n][0]) {
tuple<int, int, int> cur = make_tuple(i, n, 0);
while (1) {
;
tuple<int, int, int> nxt = pr[get<0>(cur)][get<1>(cur)][get<2>(cur)];
if (get<0>(nxt) < 0) {
break;
}
if (get<0>(nxt) != get<0>(cur)) {
ans.push_back(a[get<1>(cur) - 1]);
}
cur = nxt;
};
rest(ans);
printf("%d\n", ((int)(ans).size()));
for (int i1 = int(0); i1 < int(((int)(ans).size())); ++i1) {
for (int j1 = int(0); j1 < int(((int)(ans).size())); ++j1) {
printf("%d", res[i1][j1]);
}
puts("");
}
return 0;
}
}
puts("=(");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const long long maxn = 2e5 + 10, maxm = 1e3 + 10, lg = 21, mod = 1e9 + 7,
inf = 1e18;
long long n, ans;
pair<pair<long long, long long>, long long> a[maxn];
set<pair<long long, long long> > ss[3];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
ans = n;
for (int i = 0; i < n; i++)
cin >> a[i].first.second >> a[i].first.first >> a[i].second;
sort(a, a + n);
for (int i = 0; i < n; i++) {
long long l = a[i].first.second, r = a[i].first.first, c = a[i].second;
long long cc = (c == 1 ? 2 : 1);
auto it = ss[cc].lower_bound({l, -1});
if (it == ss[cc].end())
ss[c].insert({r, i});
else
ans--, ss[cc].erase(it);
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long Choose(long long n, long long k) {
long long res = 1;
for (long long i = 0; i < k; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
int main() {
long long n;
cin >> n;
cout << Choose(n, 7) + Choose(n, 6) + Choose(n, 5);
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.