solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int na, ma, nb, mb;
string A[51], B[51];
cin >> ma >> na;
for (int i = 1; i <= ma; ++i) {
cin >> A[i];
A[i] = " " + A[i];
}
cin >> mb >> nb;
for (int i = 1; i <= mb; ++i) {
cin >> B[i];
B[i] = " " + B[i];
}
int r1, r2, m = 0;
for (int x = -50; x <= 50; ++x) {
for (int y = -50; y <= 50; ++y) {
int S = 0;
for (int i = 1; i <= ma; ++i)
if (i + y > 0 && i + y <= mb) {
for (int j = 1; j <= na; ++j)
if (j + x > 0 && j + x <= nb) {
S += (A[i][j] - 48) * (B[i + y][j + x] - 48);
}
}
if (S > m) {
m = S;
r1 = x;
r2 = y;
}
}
}
cout << r2 << " " << r1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mult(long long a, long long b, long long p = (int)(1e9 + 7)) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = (int)(1e9 + 7)) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = (int)(1e9 + 7)) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = (int)(1e9 + 7)) {
return fpow(a, p - 2, p);
}
long long getsum(long long sum) {
long long ans = 0;
while (sum > 0) {
ans += sum % 10;
sum = sum / 10;
}
return ans;
}
int main() {
string s;
cin >> s;
long long sum = 0;
if (s.length() == 1) {
cout << 0;
return 0;
}
for (int i = 0; i < s.length(); i++) {
sum = sum + (s.at(i) - 48);
}
long long c = 1;
while (sum > 9) {
c++;
sum = getsum(sum);
}
cout << c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = (1e-11);
const double PI = acos(-1.0);
const int INF = 9999999;
const int MOD = (1e9 + 7);
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int main(void) {
ios_base::sync_with_stdio(false);
int n, days, x, curr = 0;
vector<int> res;
vector<pair<int, int> > a;
cin >> n >> days;
for (int i = 1; i <= n; i++) {
cin >> x;
a.push_back(make_pair(x, i));
}
sort(a.begin(), a.end(), cmp);
for (int i = 0; i < a.size(); i++) {
if (curr + a[i].first <= days) {
curr += a[i].first;
res.push_back(a[i].second);
}
}
if (!res.size())
cout << 0;
else {
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
}
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int Set(int N, int pos) { return N = N | (1 << pos); }
inline int Reset(int N, int pos) { return N = N & ~(1 << pos); }
inline bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T>
T gcd(T a, T b) {
return (!b) ? a : gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
map<pair<long long, long long>, vector<pair<long long, int> > > M;
vector<int> ans, cur;
long long x[10];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) cin >> x[j];
int idx = 0;
for (int a = 0; a < 3; a++) {
for (int j = 0; j < 3; j++) {
if (a != j) {
int k;
for (int l = 0; l < 3; l++) {
if (l != a && l != j) k = l;
}
M[make_pair(x[a], x[j])].push_back(make_pair(x[k], i));
idx++;
}
}
}
}
long long best = 0;
for (map<pair<long long, long long>, vector<pair<long long, int> > >::iterator
it = M.begin();
it != M.end(); it++) {
sort((M[it->first]).begin(), (M[it->first]).end(),
greater<pair<long long, int> >());
long long c = 0;
int p = -1;
for (int j = 0; j < M[it->first].size(); j++) {
if (p == M[it->first][j].second) continue;
c += M[it->first][j].first;
cur.push_back(M[it->first][j].second);
p = M[it->first][j].second;
if (cur.size() == 2) break;
}
c = min(c, min(it->first.first, it->first.second));
if (c == best && cur.size() < ans.size()) {
ans.resize(cur.size());
ans[0] = cur[0];
} else if (c > best) {
ans.resize(cur.size());
for (int k = 0; k < cur.size(); k++) ans[k] = cur[k];
best = c;
}
cur.clear();
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] + 1 << ' ';
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int t;
std::cin >> t;
while (t--) {
int n;
std::string a, b;
std::cin >> n >> a >> b;
int l = 0, r = n - 1;
int got = 0;
std::vector<int> ans;
for (int i = 0; i < n; i++) {
int pos;
if (i % 2 == 0)
pos = l++;
else
pos = r--;
int ch = a[pos] - '0';
if ((ch + got) % 2 == b[n - i - 1] - '0') {
ans.push_back(1);
}
ans.push_back(n - i);
got ^= 1;
}
assert((int)ans.size() <= 2 * n);
std::cout << ans.size() << '\n';
for (int i = 0; i < (int)ans.size(); i++) {
std::cout << ans[i] << (i + 1 == (int)ans.size() ? '\n' : ' ');
}
continue;
for (auto x : ans) {
for (int i = 0; i < x; i++) {
a[i] = a[i] == '0' ? '1' : '0';
}
std::reverse(a.begin(), a.begin() + x);
}
std::cout << a << " should be " << b << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
for (int i = 1; i < k; i++) {
for (int j = 1; j < k; j++) {
if (j != k - 1) {
if (j != 1)
printf("%2d ", i * j / k * 10 + (i * j) % k);
else
printf("%d ", i * j);
} else {
if (j != 1)
printf("%2d", i * j / k * 10 + (i * j) % k);
else
printf("%d", i * j);
}
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int maxn = 2005;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int t;
int n, m, k;
int cnt[26];
bool vis[maxn];
char s[maxn];
int main() {
scanf("%d", &t);
while (t--) {
memset(cnt, 0, sizeof cnt);
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i) {
cnt[s[i] - 'a']++;
}
for (int m = n; m >= 1; --m) {
memset(vis, 0, sizeof vis);
priority_queue<int> q;
while (!q.empty()) q.pop();
for (int i = 0; i < 26; ++i) {
q.push(cnt[i]);
}
priority_queue<int> v;
while (!v.empty()) v.pop();
for (int i = 0; i < m; ++i) {
if (vis[i]) continue;
vis[i] = 1;
int j = (i + k) % m;
int tmp = 1;
while (!vis[j]) {
++tmp;
vis[j] = 1;
j = (j + k) % m;
}
v.push(tmp);
}
bool ok = 1;
while (!v.empty()) {
int p1 = v.top(), p2 = q.top();
v.pop();
q.pop();
if (p1 > p2) {
ok = 0;
break;
} else {
p2 -= p1;
q.push(p2);
}
}
if (ok) {
printf("%d\n", m);
break;
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long b[100061];
long long n, s = 0, k, m;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> k;
s += k;
}
for (int i = 1; i <= n; i++) cin >> b[i];
sort(b + 1, b + n + 1);
n = b[n - 1] + b[n];
if (n >= s)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct island {
long long u, v;
};
struct bg {
long long u, v;
int cs;
};
const int nm = 200002;
int n, m;
island a[nm];
bg c[nm];
int kq[nm];
set<pair<long long, int> > b;
bool cmp2(bg a, bg b) {
if (a.v != b.v) return a.v < b.v;
return a.u < b.u;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%I64d%I64d", &a[i].u, &a[i].v);
for (int i = 1; i <= m; ++i) {
long long x;
scanf("%I64d", &x);
b.insert(make_pair(x, i));
}
for (int i = 1; i < n; ++i) {
c[i].u = a[i + 1].u - a[i].v;
c[i].v = a[i + 1].v - a[i].u;
c[i].cs = i;
}
sort(c + 1, c + n, cmp2);
for (int i = 1; i < n; ++i) {
set<pair<long long, int> >::iterator it =
b.lower_bound(make_pair(c[i].u, -1));
if (it == b.end() || it->first > c[i].v) {
printf("No\n");
return 0;
}
kq[c[i].cs] = it->second;
b.erase(it);
}
printf("Yes\n");
for (int i = 1; i < n; ++i) printf("%d ", kq[i]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, W;
char S[1002][12][12];
int D[1002][1002];
int dist[1002];
int Res[1002][2];
bool used[1002];
int bef[1002];
int cost;
int main() {
scanf("%d%d%d%d", &N, &M, &K, &W);
for (int k = 1; k <= K; k++) {
for (int i = 0; i < N; i++) scanf("%s", S[k][i]);
D[0][k] = D[k][0] = N * M;
}
for (int k = 1; k <= K; k++)
for (int l = 1; l <= K; l++) {
int &d = D[k][l];
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (S[k][i][j] != S[l][i][j]) d += W;
}
for (int i = 1; i <= K; i++) dist[i] = (int)1e9;
for (int i = 0; i <= K; i++) {
int v = -1;
for (int j = 0; j <= K; j++)
if (!used[j] && (v < 0 || dist[j] < dist[v])) v = j;
used[v] = true;
if (i > 0) {
Res[i][0] = v;
Res[i][1] = bef[v];
}
cost += dist[v];
for (int j = 0; j <= K; j++)
if (dist[j] > D[v][j]) dist[j] = D[v][j], bef[j] = v;
}
printf("%d\n", cost);
for (int i = 1; i <= K; i++) printf("%d %d\n", Res[i][0], Res[i][1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x;
cin >> a >> b >> x;
int turn = 0, y;
while (x >= 0) {
y = 1;
if (turn == 0) {
for (int i = 1; i <= max(a, x); i++) {
if (a % i == 0 && x % i == 0) y = max(y, i);
}
if (y <= x) {
x -= y;
turn = 1;
} else {
cout << 1;
return 0;
}
} else if (turn == 1) {
for (int i = 1; i <= max(b, x); i++) {
if (b % i == 0 && x % i == 0) y = max(y, i);
}
if (y <= x) {
x -= y;
turn = 0;
} else {
cout << "0";
return 0;
}
}
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define cl CLOCKS_PER_SEC
#define pi acos(-1.0)
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define flw freopen ("0output.txt","w",stdout)
#define flr freopen ("0input.txt","r",stdin)
#define no1s(x) __builtin_popcount(x)
#define parity(x) __builtin_parity(x)
#define leadingZeros(x) __builtin_clz(x)
#define trailingZeros(x) __builtin_ctz(x)
#define mx 100005
///mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); /// RANDOM SHUFFLE
int main()
{
int t,cs=1;
cin>>t;
while(t--)
{
int n;
cin>>n;
string s[n+1];
for(int i=0; i<n; i++)
{
cin>>s[i];
}
vector<int>col(3);
for(int i=0; i<n; i++)
{
for(int j=0; j<n; j++)
{
if(s[i][j]=='X')
{
col[(i+j)%3]++;
}
}
}
int f;
if(col[0]<=col[1] and col[0]<=col[2]) f=0;
if(col[1]<=col[0] and col[1]<=col[2]) f=1;
if(col[2]<=col[1] and col[2]<=col[0]) f=2;
for(int i=0; i<n; i++)
{
for(int j=0; j<n; j++)
{
if(s[i][j]=='X')
{
if((i+j)%3==f) s[i][j]='O';
}
}
}
for(int i=0; i<n; i++)
{
cout<<s[i]<<endl;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, S = 0, ans = 0;
cin >> n;
string s;
cin >> s;
map<long long, long long> mp;
mp[0]++;
for (long long i = 0; i < s.size(); i++) {
S += s[i] - '0';
ans += mp[S - (i + 1)];
mp[S - (i + 1)]++;
}
cout << ans << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-12;
const int inf = 2000000000;
long long int MOD = 1000000007;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
bool comp(const pair<long long int, pair<long long int, long long int> > &p1,
const pair<long long int, pair<long long int, long long int> > &p2) {
return p1.first > p2.first;
}
bool comp1(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) {
if (p1.first == p2.first) {
return p1.second > p2.second;
}
return p1.first < p2.first;
}
long long int converter(string a) {
long long int i, mul = 1, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
int msb(unsigned x) {
union {
double a;
int b[2];
};
a = x;
return (b[1] >> 20) - 1023;
}
map<char, int> mp;
int main() {
string s;
int n;
cin >> n;
cin >> s;
char lst;
int i;
mp['a'] = 1;
mp['e'] = 1;
mp['i'] = 1;
mp['o'] = 1;
mp['u'] = 1;
mp['y'] = 1;
for (i = 0; i < s.size(); ++i) {
if (i == 0) {
lst = s[i];
continue;
} else {
if (mp[lst] == 1 && mp[s[i]] == 1)
s[i] = '#';
else {
lst = s[i];
}
}
}
for (i = 0; i < s.size(); ++i) {
if (s[i] != '#') cout << s[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q, l, r, k;
vector<int> x[10];
long long calc(int n) {
long long sum = 1;
while (n != 0) {
if (n % 10) sum *= n % 10;
n /= 10;
}
return sum;
}
void init() {
for (int i = 1; i <= 1000000; i++) {
int ret = i;
while (ret > 9) ret = calc(ret);
if (ret <= 9) x[(int)ret].push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
init();
for (int i = 1; i <= 9; i++) sort(x[i].begin(), x[i].end());
cin >> q;
while (q--) {
cin >> l >> r >> k;
int ans = 0;
int pos = lower_bound(x[k].begin(), x[k].end(), l) - x[k].begin();
int pos1 = upper_bound(x[k].begin(), x[k].end(), r) - x[k].begin();
cout << max(0, pos1 - pos) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int xx = 0;
int t;
cin >> t;
while (t--) {
long long n, k, i;
string s;
cin >> n >> k >> s;
long long num = 0, d = k;
for (i = 0; i < n; i++) {
if (s[i] == '1') {
if (d < k) num--;
d = 0;
}
if (s[i] == '0') {
d++;
if (d == k + 1) {
d = 0;
num++;
}
}
}
cout << num;
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct city {
city *before = nullptr, *after = nullptr;
ll id;
};
unordered_map<ll, city> cities;
unordered_map<ll, vector<ll>> rule_map;
int main() {
ll n;
cin >> n;
for (ll i = 0; i < n; i++) {
pair<ll, ll> rule;
cin >> rule.first >> rule.second;
rule_map[rule.first].push_back(rule.second);
rule_map[rule.second].push_back(rule.first);
if (n == 1) {
cout << rule.first << " " << rule.second << endl;
return 0;
}
}
auto ptr = rule_map.begin();
while (ptr->second.size() < 2) ptr++;
city *current = &cities[ptr->first];
current->before = &cities[ptr->second.front()];
current->before->id = ptr->second.front();
current->id = ptr->first;
for (ll i : {1, -1}) {
city *ptr = current;
while (rule_map[ptr->id].size() > 1) {
city *&next = i == 1 ? ptr->after : ptr->before;
city *&prev = i == 1 ? ptr->before : ptr->after;
ll nextID = -1;
if (prev->id == rule_map[ptr->id].front())
nextID = rule_map[ptr->id].back();
else
nextID = rule_map[ptr->id].front();
next = &cities[nextID];
next->id = nextID;
if (i == 1)
next->before = ptr;
else
next->after = ptr;
ptr = next;
}
}
city *start = &cities.begin()->second;
while (start->before) start = start->before;
while (start) {
cout << start->id << " ";
start = start->after;
}
cout << endl;
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
int n;
bool check(int a[2222])
{
bool f=true;
for(int i=1;i<n*2;i++)
{
if(a[i+1]<a[i])
{
f=false;
break;
}
}
return f;
}
int main()
{
int a[2222];
cin>>n;
for(int i=1;i<=n*2;i++) cin>>a[i];
if(check(a))
{
cout<<0;
return 0;
}
if(n%2==0)//n��ż��
{
for(int i=1;i<=4;i++)
{
if(i%2==1)
{
for(int j=1;j<=n*2;j+=2) swap(a[j],a[j+1]);
}
else
{
for(int j=1;j<=n;j++) swap(a[j],a[j+n]);
}
if(check(a))
{
cout<<min(i,4-i);
return 0;
}
}
}
else//n������
{
for(int i=1;i<=n*2;i++)
{
if(i%2==1)
{
for(int j=1;j<=n*2;j+=2) swap(a[j],a[j+1]);
}
else
{
for(int j=1;j<=n;j++) swap(a[j],a[j+n]);
}
if(check(a))
{
cout<<min(i,n*2-i);
return 0;
}
}
}
cout<<-1;
return 0;
}
/*
3
6 3 2 5 4 1
2
3 4 2 1
4
1 2 3 4 5 6 7 8
5
7 6 9 8 1 10 3 2 5 4
5
10 3 2 5 4 7 6 9 8 1
6
7 8 9 10 11 12 1 2 3 4 5 6
*/
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, p, m, k, k1, k2, y, x, xs, ys, zs, xf, yf, zf,
fldgjdflgjhrthrl, fldggfhfghjdflgjl, fldgjdflgrtyrtyjl, ffgfldgjdflgjl, x3,
y3, kk, l, r, a[1005][1005];
string s;
vector<string> f;
vector<long long> edges;
vector<pair<long long, long long> > ans;
int main() {
cin >> n;
if (n % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (i = 2; i < 2 + n - 1; i++)
for (j = 2 + n - 1; j < 2 + n - 1 + n - 1; j++)
ans.push_back(make_pair(i, j));
for (j = 2 + n - 1; j < 2 + n - 1 + n - 1 - 1; j += 2)
ans.push_back(make_pair(j, j + 1));
for (i = 2; i < 2 + n - 1; i++) ans.push_back(make_pair(1, i));
for (i = 2 * n + 1; i < 2 * n + 1 + n - 1; i++)
for (j = 2 * n + 1 + n - 1; j < 2 * n + 1 + n - 1 + n - 1; j++)
ans.push_back(make_pair(i, j));
for (j = 2 * n + 1 + n - 1; j < 2 * n + 1 + n - 1 + n - 1 - 1; j += 2)
ans.push_back(make_pair(j, j + 1));
for (i = 2 * n + 1; i < 2 * n + 1 + n - 1; i++)
ans.push_back(make_pair(2 * n, i));
ans.push_back(make_pair(1, 2 * n));
cout << 2 * n + 1 + n - 1 + n - 1 - 1 << " " << ans.size() << endl;
for (i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 3e5 + 1;
int n, m, tree[mn * 4], k, d[mn];
struct query {
int l, r, x;
};
query queries[mn];
void update(int id, int l, int r, int x, int y, int val) {
if (y < l || x > r) {
return;
}
if (x <= l && y >= r) {
tree[id] = val;
return;
}
int mid = (l + r) / 2;
update(id * 2, l, mid, x, y, val);
update(id * 2 + 1, mid + 1, r, x, y, val);
}
void get(int id, int l, int r, int x) {
if (x < l || x > r) {
return;
}
if (x >= l && x <= r) {
k = max(k, tree[id]);
}
if (l == r) {
return;
}
int mid = (l + r) / 2;
get(id * 2, l, mid, x);
get(id * 2 + 1, mid + 1, r, x);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> queries[i].l >> queries[i].r >> queries[i].x;
d[m - i + 1] = queries[i].x;
}
for (int i = m; i >= 1; i--) {
if (queries[i].l <= queries[i].x - 1) {
update(1, 1, n, queries[i].l, queries[i].x - 1, m - i + 1);
}
if (queries[i].r >= queries[i].x + 1) {
update(1, 1, n, queries[i].x + 1, queries[i].r, m - i + 1);
}
}
for (int i = 1; i <= n; i++) {
k = 0;
get(1, 1, n, i);
cout << d[k] << ' ';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
double p1[N], p2[N], f[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
double p;
scanf("%lf", &p);
p1[i] = p * (p1[i - 1] + 1);
f[i] = f[i - 1] + p * (1 + 2 * p1[i - 1]);
}
printf("%.10lf\n", f[n]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin.exceptions(cin.failbit);
if (s.size()) {
setIn(s + ".inp");
setOut(s + ".out");
} else {
}
}
} // namespace IO
using namespace IO;
namespace Function {
template <typename T1, typename T2>
void amax(T1 &a, T2 b) {
assert(!(typeid(a).name() == typeid(int).name() &&
typeid(b).name() == typeid(long long).name()));
if (a < b) a = b;
}
template <typename T1, typename T2>
void amin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T>
void compress(T &a) {
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
template <typename T>
long long sqr(T x) {
return 1LL * x * x;
}
template <typename T1, typename T2>
long long gcd(T1 a, T2 b) {
return (b == 0 ? a : gcd(b, a % b));
}
template <typename T1, typename T2>
long long lcm(T1 a, T2 b) {
return 1LL * a / gcd(a, b) * b;
}
} // namespace Function
using namespace Function;
namespace Output {
void print(int x) { cout << x << "\n"; }
void print(unsigned int x) { cout << x << "\n"; }
void print(long unsigned int x) { cout << x << "\n"; }
void print(long long x) { cout << x << "\n"; }
void print(unsigned long long x) { cout << x << "\n"; }
void print(float x) { cout << x << "\n"; }
void print(double x) { cout << x << "\n"; }
void print(long double x) { cout << x << "\n"; }
void print(char x) { cout << x << "\n"; }
void print(const char *x) { cout << x << "\n"; }
void print(string x) { cout << x << "\n"; }
void print(bool x) { cout << x << "\n"; }
template <class T, class... Ts>
void print(T t, Ts... ts) {
cout << t << " ";
print(ts...);
}
template <typename T1, typename T2>
void print(pair<T1, T2> a) {
print(a.first, a.second);
}
template <typename T>
void print(T a) {
for (auto it : a) {
print(it);
}
}
template <class T, class... Ts>
void prine(T t, Ts... ts) {
print(t, ts...);
exit(0);
}
} // namespace Output
using namespace Output;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int INF = 1e9;
const long long INFL = 1e18;
const int MOD = 1e9 + 7;
const int N = 1e2 + 10;
long long a[N][N];
int main() {
setIO();
int T;
cin >> T;
while (T--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
long long base = a[0][0];
long long res = INFL;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] - i - j > base) {
continue;
}
vector<vector<long long>> dp(n, vector<long long>(m, INFL));
dp[0][0] = base - (a[i][j] - i - j);
a[0][0] = a[i][j] - i - j;
for (int x = 0; x < n; x++) {
for (int y = 0; y < m; y++) {
if (a[0][0] + x + y > a[x][y]) {
continue;
}
if (x > 0) {
amin(dp[x][y], dp[x - 1][y] + a[x][y] - (a[0][0] + x + y));
}
if (y > 0) {
amin(dp[x][y], dp[x][y - 1] + a[x][y] - (a[0][0] + x + y));
}
}
}
amin(res, dp[n - 1][m - 1]);
}
}
print(res);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long int fac[200005], finv[200005], inv[200005];
long long int dp[2005][32];
pair<int, int> pos[2005];
void make() {
inv[1] = 1;
fac[0] = fac[1] = finv[0] = finv[1] = 1;
for (int i = 2; i < 200005; i++) {
inv[i] = 1000000007 - inv[1000000007 % i] * (1000000007 / i) % 1000000007;
fac[i] = fac[i - 1] * (long long int)i % 1000000007;
finv[i] = finv[i - 1] * inv[i] % 1000000007;
}
}
long long int C(int a, int b) {
if (a < b) return 0;
return fac[a] * (finv[b] * finv[a - b] % 1000000007) % 1000000007;
}
long long int invC(int a, int b) {
if (a < b) return 0;
return finv[a] * (fac[b] * fac[a - b] % 1000000007) % 1000000007;
}
int main() {
make();
int n, m, k, S;
scanf("%d %d %d %d", &n, &m, &k, &S);
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
pos[i] = pair<int, int>(a, b);
}
pos[k++] = pair<int, int>(n - 1, m - 1);
sort(pos, pos + k);
for (int i = 0; i < k; i++) {
int x = pos[i].first, y = pos[i].second;
for (int j = 1; j < 32; j++) {
dp[i][j] = C(x + y, y);
for (int p = 0; p < i; p++) {
int a = pos[p].first, b = pos[p].second;
if (a <= x && b <= y) {
dp[i][j] -= dp[p][j] * C((x - a) + (y - b), x - a) % 1000000007;
if (dp[i][j] < 0) dp[i][j] += 1000000007;
}
}
}
for (int j = 32 - 1; j >= 1; j--) {
dp[i][j] -= dp[i][j - 1];
if (dp[i][j] < 0) dp[i][j] += 1000000007;
}
}
long long int ret = C(n + m - 2, n - 1);
for (int j = 1; j < 32; j++) {
ret += dp[k - 1][j] * (long long int)(S - 1) % 1000000007;
if (ret >= 1000000007) ret -= 1000000007;
S = (S + 1) / 2;
}
ret = ret * invC(n + m - 2, n - 1) % 1000000007;
printf("%lld\n", ret);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int n;
double x[100], y[100], z[100];
int main() {
scanf("%d", &n);
for (int i = 0; i < (n); i++) scanf("%lf%lf%lf", x + i, y + i, z + i);
double x0 = 0, y0 = 0, z0 = 0, lambda = 1;
for (int _ = 0; _ < (100000); _++) {
int i_opt;
double d_opt = -1;
for (int i = 0; i < (n); i++) {
double d = ((x[i] - x0) * (x[i] - x0) + (y[i] - y0) * (y[i] - y0) +
(z[i] - z0) * (z[i] - z0));
if (d_opt < d) d_opt = d, i_opt = i;
}
x0 += lambda * (x[i_opt] - x0);
y0 += lambda * (y[i_opt] - y0);
z0 += lambda * (z[i_opt] - z0);
lambda *= 0.999;
}
printf("%.9f %.9f %.9f\n", x0, y0, z0);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, m, k, a[600086];
int tsum[5005][5005], dp[5005][5005];
int bound[5005], ans;
int add(int x, int y) {
int sum = x + y;
if (sum >= mod) sum -= mod;
return sum;
}
int solve1(int x) {
tsum[1][0] = 0;
for (int i = 1; i <= k; i++) {
for (int j = i; j <= n; j++) {
if (i == 1) {
dp[i][j] = 1;
tsum[i][j] = (tsum[i][j - 1] + dp[i][j]) % mod;
continue;
}
dp[i][j] = tsum[i - 1][bound[j]];
tsum[i][j] = add(tsum[i][j - 1], dp[i][j]);
}
}
return tsum[k][n];
}
int solve(int x) {
bound[0] = 0;
for (int i = 1; i <= n; i++) {
bound[i] = bound[i - 1];
while (a[i] - a[bound[i] + 1] >= x) bound[i]++;
}
tsum[1][0] = 0;
for (int i = 1; i <= k; i++) {
for (int j = i; j <= n; j++) {
if (i == 1) {
dp[i][j] = 1;
tsum[i][j] = (tsum[i][j - 1] + dp[i][j]);
continue;
}
dp[i][j] = tsum[i - 1][bound[j]];
tsum[i][j] = add(tsum[i][j - 1], dp[i][j]);
}
}
return tsum[k][n];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
int ans = 0;
int maxn = (a[n] - a[1]) / (k - 1);
for (int c = 1; c <= maxn; c++) {
ans = add(ans, solve(c));
}
cout << ans << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.2")
using namespace std;
inline void opting() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
}
long long inp() {
long long x;
cin >> x;
return x;
}
void make_unique(vector<long long> &vec, bool sorted = false) {
if (!sorted) sort((vec).begin(), (vec).end());
vec.resize(unique((vec).begin(), (vec).end()) - vec.begin());
}
void file_edit(bool reader = true, bool writer = false) {
if (reader) freopen("Test_input.txt", "r", stdin);
if (writer) freopen("Test_output.txt", "w", stdout);
}
const long long SQRT = 350 + 10, lg = 18 + 2, inlim = 2147483647;
const long long maxn = 4e5 + 69, delta = 998244353, inf = 1e9 + 420;
vector<long long> maper;
struct seg_data {
long long cnt = 0, L = 0;
long long sum = 0;
long long l_dist, r_dist;
} seg[4 * maxn], null_data;
void show_data(seg_data &A) {
cout << "cnt: " << A.cnt << '\n';
cout << "length: " << A.L << '\n';
cout << "sum: " << A.sum << '\n';
cout << "l_dist & r_dist: " << A.l_dist << ' ' << A.r_dist << '\n';
}
void base_seting(seg_data &d) {
d.sum = 0;
d.l_dist = 0;
d.cnt = 1 - d.cnt;
d.r_dist = d.cnt * d.L;
}
void sag(seg_data &d, const seg_data &A, const seg_data &B,
const long long &xt) {
d.L = A.L + B.L;
d.cnt = A.cnt + B.cnt;
d.l_dist = A.l_dist + B.l_dist + (A.L * B.cnt);
d.r_dist = B.r_dist + A.r_dist + (B.L * A.cnt);
d.sum = A.sum + B.sum + A.cnt * B.l_dist + B.cnt * A.r_dist;
}
long long n, q;
bool FRD = false;
void update(const long long &idx, const long long &L = 0,
const long long &R = n, const long long &id = 1) {
seg[id].L = maper[R] - maper[L];
if (R <= idx or idx < L) return;
if (R - L == 1)
base_seting(seg[id]);
else {
long long mid = (L + R) >> 1;
update(idx, L, mid, id * 2);
update(idx, mid, R, id * 2 + 1);
sag(seg[id], seg[id * 2], seg[id * 2 + 1], maper[mid] - maper[mid - 1]);
}
if (FRD) {
cout << "just set " << L << " to " << R << ":\n";
show_data(seg[id]);
cout << endl;
}
return;
}
seg_data get_dists(const long long &l, const long long &r,
const long long &L = 0, const long long &R = n,
const long long &id = 1) {
seg[id].L = maper[R] - maper[L];
if (r <= L or R <= l) return null_data;
if (l <= L and R <= r) {
return seg[id];
}
long long mid = (L + R) >> 1;
seg_data A = get_dists(l, r, L, mid, id * 2);
seg_data B = get_dists(l, r, mid, R, id * 2 + 1);
seg_data C = null_data;
sag(C, A, B, maper[mid] - maper[mid - 1]);
return C;
}
struct query {
bool type;
long long F, S;
} q_tmp;
vector<query> Q;
vector<long long> initial;
long long find_maped(const long long &key) {
return (lower_bound((maper).begin(), (maper).end(), key) - maper.begin());
}
vector<long long> SUCK;
void input() {
n = inp();
for (long long i = 0; i < n; i++) {
initial.push_back(inp());
maper.push_back(initial[i]);
SUCK.push_back(initial[i]);
}
q = inp();
for (long long i = 0; i < q; i++) {
q_tmp.type = inp() - 1;
q_tmp.F = inp();
q_tmp.S = inp();
if (!q_tmp.type) {
long long id = q_tmp.F - 1;
q_tmp.F = SUCK[id];
q_tmp.S += q_tmp.F;
SUCK[id] = q_tmp.S;
}
Q.push_back(q_tmp);
maper.push_back(q_tmp.F);
maper.push_back(q_tmp.S);
}
make_unique(maper);
n = maper.size();
}
void predo() {
null_data.cnt = null_data.L = null_data.l_dist = null_data.sum =
null_data.r_dist = 0;
}
void solve() {
for (auto A : initial) {
update(find_maped(A));
}
for (auto quer : Q) {
if (quer.type) {
cout << get_dists(find_maped(quer.F), find_maped(quer.S) + 1).sum << '\n';
} else {
update(find_maped(quer.F));
update(find_maped(quer.S));
}
}
}
int main() {
opting();
input();
predo();
solve();
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int maxn, n, t, a;
int main() {
cin >> n;
int x, y;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
a = a - x + t;
if (a < 0) {
a = 0;
}
a = a + y;
maxn = max(maxn, a);
t = x;
}
cout << t + a << " " << maxn << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[5000002], a[1000002];
int main() {
int n;
scanf("%d", &n);
int i, j;
int tmp = (1 << 22) - 1;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
dp[a[i]] = a[i];
}
for (i = 1; i <= tmp; i++) {
for (j = 0; j < 22; j++) {
if (i & (1 << j)) {
if (dp[i ^ (1 << j)]) dp[i] = dp[i ^ (1 << j)];
}
}
}
for (i = 0; i < n; i++) {
if (i) printf(" ");
if (dp[a[i] ^ tmp])
printf("%d", dp[a[i] ^ tmp]);
else
printf("-1");
}
printf("\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
set<int> a[100100];
void check(vector<int> &group0, vector<int> &group1) {
for (int x : group0)
for (int y : group1)
if (!a[x].count(y)) {
cout << -1 << endl;
exit(0);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
a[--x].insert(--y);
a[y].insert(x);
}
vector<int> ans(n, -1), groups[3];
for (int c = 0; c < 3; c++) {
int found = 0;
for (int x = 0; x < n; x++)
if (ans[x] < 0) {
ans[x] = c;
groups[c].push_back(x);
for (int y = 0; y < n; y++)
if (!a[x].count(y)) {
if (ans[y] < 0) {
ans[y] = c;
groups[c].push_back(y);
} else if (ans[y] != c) {
cout << -1 << endl;
return 0;
}
}
found = 1;
break;
}
if (!found) {
cout << -1 << endl;
return 0;
}
}
for (int i = 0; i < n; i++)
if (ans[i] < 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < 3; i++)
for (int x : groups[i])
if (a[x].size() != n - groups[i].size()) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < 3; i++)
for (int j = i + 1; j < 3; j++) check(groups[i], groups[j]);
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " \n"[i == n - 1];
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9) + 7;
const int maxn = 20;
int n, m, color;
long long ans;
int a[maxn][maxn], sett[maxn][maxn];
int used[maxn * maxn];
int Lg[10000];
void init() {
scanf("%d%d%d", &n, &m, &color);
if (n + m - 1 > color) {
printf("0\n");
exit(0);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
scanf("%d", &a[i][j]);
used[a[i][j]]++;
}
for (int i = 0; i <= 10; ++i) Lg[1 << i] = i;
}
int dfs(int x, int y) {
if (x > n) return 1;
if (y > m) return dfs(x + 1, 1);
int s = -1;
int tmp = (sett[x - 1][y] | sett[x][y - 1]);
int ans = 0;
for (int i = (~tmp) & ((1 << color) - 1); i > 0; i -= (-i) & i) {
int nid = Lg[(-i) & i] + 1;
if (a[x][y] == 0 || a[x][y] == nid) {
used[nid]++;
sett[x][y] = tmp | (1 << (nid - 1));
if (used[nid] == 1) {
if (s == -1) s = dfs(x, y + 1);
ans += s;
} else if (used[nid])
ans += dfs(x, y + 1);
ans %= mod;
used[nid]--;
}
}
return ans;
}
int main() {
init();
printf("%d\n", dfs(1, 1));
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int r = 1, c = 1;
for (int i = 1; i <= 2 * (k - 1); i++) {
if (i % 2) cout << "2 ";
if (r % 2) {
cout << r << " " << c << " ";
c++;
if (c > m) {
r++;
c = m;
}
} else {
cout << r << " " << c << " ";
c--;
if (c <= 0) {
r++;
c = 1;
}
}
if (i % 2 == 0) cout << endl;
}
cout << (n * m) - (2 * (k - 1)) << " ";
for (int i = 0; i < (n * m) - (2 * (k - 1)); i++) {
if (r % 2) {
cout << r << " " << c << " ";
c++;
if (c > m) {
r++;
c = m;
}
} else {
cout << r << " " << c << " ";
c--;
if (c <= 0) {
r++;
c = 1;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v[100005] = {0};
int n, k;
cin >> n >> k;
cout << "1 ";
int i = 1;
v[1] = 1;
bool ok = true;
while (k) {
if (ok) {
cout << i + k << " ", v[i + k] = 1, i = i + k;
} else {
cout << i - k << " ", v[i - k] = 1, i -= k;
}
k--;
ok = !ok;
}
for (int j = 2; j <= n; j++) {
if (!v[j]) cout << j << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
std::vector<long int> indices;
std::vector<long int> t;
long int l = s.length();
for (long int i = 0; i < l; i++) {
if (s[i] == 'F') indices.push_back(i);
}
long int siz = indices.size();
long int temp;
for (long int i = 0; i < siz; i++) {
if (indices[i] == i)
t.push_back(0);
else if (i == 0 || (indices[i] - i) > t[i - 1])
t.push_back((indices[i] - i));
else {
temp = t[i - 1];
t.push_back(temp + 1);
}
}
if (siz == 0)
cout << "0";
else
cout << t[siz - 1];
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
if (m == 3) {
if (n == 4) {
printf("0 0\n3 0\n0 3\n1 1\n");
return 0;
}
if (n >= 5) {
printf("-1\n");
return 0;
}
}
for (int i = 0; i < m; i++) printf("%d %d\n", i, 100000 + i * i);
for (int i = 0; i < n - m; i++) printf("%d %d\n", i, -100000 - i * i);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int a[505][505];
int dp[4][505][505];
string ss = "RGYB";
const int N = 510, M = 301000;
int n, m, q, cnt[6][N][N], ans[M];
int r1[M], c1[M], r2[M], c2[M];
char s[N];
vector<pair<int, int> > len[505];
vector<pair<int, int> > len1[505];
int find(int col, int l, int x1, int y1) {
int ans = dp[col][x1][y1] - dp[col][x1][y1 - l] - dp[col][x1 - l][y1] +
dp[col][x1 - l][y1 - l];
return ans;
}
int get(int col, int l, int x, int y) {
int x1 = x + l - 1;
int y1 = y + l - 1;
if (x1 > n || y1 > m) return 0;
int req = l * l;
int p = find(col, l, x1, y1);
if (p == req) return 1;
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i < n + 1; i++) {
scanf("%s", s + 1);
for (int j = 1; j < m + 1; j++) {
char c = s[j];
if (c == 'R') a[i][j] = 0;
if (c == 'G') a[i][j] = 1;
if (c == 'Y') a[i][j] = 2;
if (c == 'B') a[i][j] = 3;
for (int k = 0; k < 4; k++)
if (ss[k] == s[j]) cnt[k][i][j] = 1;
}
}
for (int col = 0; col < 4; col++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[col][i][j] =
dp[col][i][j - 1] + dp[col][i - 1][j] - dp[col][i - 1][j - 1];
if (a[i][j] == col) dp[col][i][j]++;
}
}
}
vector<pair<int, pair<int, int> > > arr;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int l = 1; l <= n; l++) {
if (get(0, l, i, j) && get(1, l, i, j + l) && get(2, l, i + l, j) &&
get(3, l, i + l, j + l)) {
len[l].push_back({i, j});
len1[l].push_back({j, i});
if (l > 50) arr.push_back({l, {i, j}});
}
}
}
}
if (arr.size() > 200) {
cout << arr.size() << endl;
}
for (int k = 0; k < 4; k++) {
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) cnt[k][i][j] += cnt[k][i - 1][j];
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) cnt[k][i][j] += cnt[k][i][j - 1];
}
for (int i = 0; i < q; i++)
scanf("%d%d%d%d", r1 + i, c1 + i, r2 + i, c2 + i);
auto query = [&](int k, int r1, int c1, int r2, int c2) {
return cnt[k][r2][c2] - cnt[k][r1 - 1][c2] - cnt[k][r2][c1 - 1] +
cnt[k][r1 - 1][c1 - 1];
};
for (int l = 1; l < 251; l++) {
if (n < 2 * l || m < 2 * l) break;
for (int x = 1; x <= n + 1 - 2 * l; x++)
for (int y = 1; y <= m + 1 - 2 * l; y++) cnt[4][x][y] = 0;
for (int x = l; x <= n - l; x++)
for (int y = l; y <= m - l; y++) {
if (query(0, x - l + 1, y - l + 1, x, y) == l * l &&
query(1, x - l + 1, y + 1, x, y + l) == l * l &&
query(2, x + 1, y - l + 1, x + l, y) == l * l &&
query(3, x + 1, y + 1, x + l, y + l) == l * l) {
cnt[4][x - l + 1][y - l + 1] = 1;
}
}
for (int x = 1; x <= n + 1 - 2 * l; x++)
for (int y = 1; y <= m + 1 - 2 * l; y++)
cnt[4][x][y] += cnt[4][x - 1][y];
for (int x = 1; x <= n + 1 - 2 * l; x++)
for (int y = 1; y <= m + 1 - 2 * l; y++)
cnt[4][x][y] += cnt[4][x][y - 1];
for (int i = 0; i < q; i++) {
if (r2[i] - r1[i] + 1 >= 2 * l && c2[i] - c1[i] + 1 >= 2 * l &&
query(4, r1[i], c1[i], r2[i] - 2 * l + 1, c2[i] - 2 * l + 1))
ans[i] = l;
}
}
for (int i = 0; i < q; i++) printf("%d\n", 4 * ans[i] * ans[i]);
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000;
struct revenge {
int a, b, count;
} shagun[MAX];
int n, p, k, i, position = -1;
long long int sum = 0;
multiset<int> s;
long long int priority[MAX];
bool compare1(const revenge &x, const revenge &y) {
return x.b < y.b || (x.b == y.b && x.a > y.a);
}
bool compare2(const revenge &x, const revenge &y) { return x.a > y.a; }
int main() {
scanf("%d %d %d", &n, &p, &k);
for (i = 0; i < n; ++i) {
scanf("%d %d", &shagun[i].a, &shagun[i].b);
shagun[i].count = i + 1;
}
sort(shagun, shagun + n, compare1);
priority[0] = shagun[0].b;
for (i = 1; i < n; ++i) priority[i] = priority[i - 1] + shagun[i].b;
for (i = n - 1; i > n - k; --i) {
sum += shagun[i].a;
s.insert(shagun[i].a);
}
pair<long long int, long long int> prev = make_pair(-1, -1);
for (int i = n - k; i >= p - k; --i) {
long long int temp = 0;
if (p != k)
temp = (i == p - k) ? priority[i - 1]
: priority[i - 1] - priority[i - p + k - 1];
pair<long long int, long long int> current =
make_pair(sum + shagun[i].a, temp);
if (current > prev) {
position = i;
prev = current;
}
sum += shagun[i].a;
s.insert(shagun[i].a);
long long int lol = *s.begin();
s.erase(s.begin());
sum -= lol;
}
sort(shagun + position + 1, shagun + n, compare2);
for (i = position - p + k; i <= position + k - 1; ++i)
printf("%d ", shagun[i].count);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long k;
cin >> n >> k;
if (n % 2 == 0) {
if (k <= (n / 2)) {
cout << 2 * k - 1;
} else {
cout << 2 * (k - n / 2);
}
} else {
if (k <= (n + 1) / 2) {
cout << 2 * k - 1;
} else {
cout << 2 * (k - (n + 1) / 2);
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
const int mod = 1e9+7;
int main()
{
int t;
cin>>t;
while(t--)
{
string s;
cin>>s;
bool flag=0;
for(auto x:s)
{
if(x!='a'){
flag=1;
break;
}
}
if(flag==0) cout<<"NO\n";
else{
cout<<"YES\n";
int j=s.size()-1;
int i=0;
while(s[j]=='a'){
j--;
i++;
}
cout<<s.substr(0,i) + "a" + s.substr(i)<<endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 0;
int n, hh, mm, hunger, inc, cost, decr;
int main() {
cin >> hh >> mm;
cin >> hunger >> inc >> cost >> decr;
double one = 0.0, two = 0.0;
if (hh < 20) {
int buy = ceil((double)hunger / (double)decr);
one = buy * cost;
double newcost = cost * 0.8;
double t = 1200 - (hh * 60 + mm);
double newhunger = hunger + (t * inc);
buy = ceil((double)newhunger / (double)decr);
two = buy * newcost;
printf("%.4lf", min(one, two));
} else {
double newcost = cost * 0.8;
int buy = ceil((double)hunger / (double)decr);
one = buy * newcost;
printf("%.4lf", one);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int xx, yy, x2, y2, v, t, vx, vy, wx, wy;
bool check(double max) {
double bx = x2, by = y2;
if (t > max) {
bx += (0 - vx) * max;
by += (0 - vy) * max;
} else {
bx += (0 - vx) * t + (0 - wx) * (max - t);
by += (0 - vy) * t + (0 - wy) * (max - t);
}
if ((bx - xx) * (bx - xx) + (by - yy) * (by - yy) < (v * max) * (v * max))
return true;
else
return false;
}
int main() {
scanf("%d%d%d%d%d%d%d%d%d%d", &xx, &yy, &x2, &y2, &v, &t, &vx, &vy, &wx, &wy);
double l = 0, r = 1e10;
while (r - l > 1e-6) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%lf\n", (r + l) / 2);
return 0;
}
| 13 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &x) {
x = 0;
register char c = getchar();
register bool f = 0;
while (!isdigit(c)) f ^= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
}
template <class T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 2e5 + 10;
int n, a[N];
std::vector<int> f[N];
void split(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
int cnt = 0;
while (n % i == 0) cnt++, n /= i;
f[i].push_back(cnt);
}
if (n != 1) f[n].push_back(1);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
split(a[i]);
}
long long ans = 1;
for (int i = 1; i <= 200000; i++)
if (f[i].size() >= n - 2) {
while (f[i].size() < n) f[i].push_back(0);
std::sort(f[i].begin(), f[i].end());
int x = f[i][1];
while (x--) {
ans = ans * i;
}
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int MAX = 1e7 + 1;
long long int mod = 1e9 + 7;
void solve() {
long long int n, m;
m = 6;
vector<long long int> a(m);
for (long long int i = 0; i < m; i++) cin >> a[i];
cin >> n;
vector<long long int> b(n);
for (long long int i = 0; i < n; i++) cin >> b[i];
vector<vector<long long int>> v(n, vector<long long int>(m));
set<long long int> tot;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
v[i][j] = b[i] - a[j];
tot.insert(v[i][j]);
}
sort(v[i].begin(), v[i].end());
}
set<pair<long long int, pair<long long int, long long int>>> s;
for (long long int i = 0; i < n; i++) {
s.insert({v[i][0], {i, 0}});
}
long long int ans = 1e15;
for (auto &x : tot) {
long long int mini = x;
bool poss = true;
while (s.begin()->first < mini) {
pair<long long int, pair<long long int, long long int>> temp;
temp = *s.begin();
s.erase(s.begin());
long long int i = temp.second.first;
long long int str = temp.second.second;
long long int fin = m;
for (long long int j = str + 1; j < m; j++) {
if (v[i][j] >= mini) {
fin = j;
break;
}
}
if (fin == m) {
poss = false;
break;
}
temp = {v[i][fin], {i, fin}};
s.insert(temp);
}
if (!poss) break;
long long int maxi = s.rbegin()->first;
ans = min(ans, maxi - mini);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
}
| 11 |
#include <bits/stdc++.h>
int main() {
int n, sum = 0, f = 0, x = 0, y = 0, i;
int a[1000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum % n != 0) {
puts("Unrecoverable configuration.");
return 0;
}
for (i = 0; i < n; i++) {
if (a[i] != sum / n) {
f++;
if (f >= 3) {
puts("Unrecoverable configuration.");
return 0;
}
if (f == 1) {
x = i;
} else {
y = i;
}
}
}
if (f == 0) {
puts("Exemplary pages.");
return 0;
}
if (f != 2) {
puts("Unrecoverable configuration.");
return 0;
}
if (sum / n * 2 == a[x] + a[y]) {
if (a[x] > a[y]) {
printf("%d ml. from cup #%d to cup #%d.\n", a[x] - sum / n, y + 1, x + 1);
} else {
printf("%d ml. from cup #%d to cup #%d.\n", a[y] - sum / n, x + 1, y + 1);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAX_LEN = 1010;
using namespace std;
template <typename U, typename V>
string to_string(pair<U, V>);
string to_string(const string& e_) { return "\"" + e_ + "\""; }
string to_string(char e_) { return "\'" + string(1, e_) + "\'"; }
string to_string(bool e_) { return e_ ? "true" : "false"; }
template <typename T>
string to_string(T e_) {
string s_ = "[ ";
for (const auto& x_ : e_) s_ += to_string(x_) + " ";
return s_ + "]";
}
template <typename U, typename V>
string to_string(pair<U, V> e_) {
return "(" + to_string(e_.first) + ", " + to_string(e_.second) + ")";
}
void dbg_str() { ; }
template <typename U, typename... V>
void dbg_str(U u, V... v) {
;
dbg_str(v...);
}
int n, e, y;
char s[23];
char ans[23];
int main() {
scanf("%d", &n);
scanf("%s", ans);
e = strlen(ans);
for (int i = 1; i < n; i++) {
scanf("%s", s);
y = 0;
while (ans[y] == s[y]) y++;
;
e = min(e, y);
}
printf("%d", e);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
class problem {
int n;
string u[N][2];
int p[N];
bool haveSolution() {
int h[N];
for (int i = (0); i <= (int)((n)-1); ++i) {
if (u[p[i]][0] < u[p[i]][1])
h[p[i]] = 0;
else
h[p[i]] = 1;
}
for (int i = (1); i <= (int)(n - 1); ++i) {
if (u[p[i - 1]][h[p[i - 1]]] > u[p[i]][h[p[i]]]) {
h[p[i]] = h[p[i]] ^ 1;
if (u[p[i - 1]][h[p[i - 1]]] > u[p[i]][h[p[i]]]) return false;
}
}
return true;
}
public:
problem() { ios_base::sync_with_stdio(false); }
void solve() {
cin >> n;
for (int i = (0); i <= (int)((n)-1); ++i) {
cin >> u[i][0] >> u[i][1];
}
for (int i = (0); i <= (int)((n)-1); ++i) {
cin >> p[i];
p[i]--;
}
if (haveSolution())
cout << "YES";
else
cout << "NO";
}
};
int main() {
problem *p = new problem();
p->solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 13;
int n;
long long T;
int a[N];
int f[N];
void upd(int x) {
for (int i = x; i < N; i |= i + 1) ++f[i];
}
int get(int x) {
int res = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) res += f[i];
return res;
}
int main() {
scanf("%d%lld", &n, &T);
for (int i = 0; i < int(n); i++) scanf("%d", &a[i]);
vector<long long> sums(1, 0ll);
long long pr = 0;
for (int i = 0; i < int(n); i++) {
pr += a[i];
sums.push_back(pr);
}
sort(sums.begin(), sums.end()),
sums.erase(unique(sums.begin(), sums.end()), sums.end());
long long ans = 0;
pr = 0;
upd(lower_bound(sums.begin(), sums.end(), 0ll) - sums.begin());
for (int i = 0; i < int(n); i++) {
pr += a[i];
int npos = upper_bound(sums.begin(), sums.end(), pr - T) - sums.begin();
ans += (i + 1 - get(npos - 1));
int k = lower_bound(sums.begin(), sums.end(), pr) - sums.begin();
upd(k);
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a1, a2, a3, b1, b2, b3, cups(0), medals(0), cu(0), sh(0);
cin >> a1 >> a2 >> a3 >> b1 >> b2 >> b3 >> n;
cups = a1 + a2 + a3;
medals = b1 + b2 + b3;
if (cups <= 5 && cups > 0)
n--;
else
while (cups > 5) {
n--;
cups -= 5;
if (cups <= 5) n--;
}
if (medals <= 10 && medals > 0)
n--;
else
while (medals > 10) {
n--;
medals -= 10;
if (medals <= 10) n--;
}
if (n >= 0)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int f, n;
cin >> f;
n = 0;
cout << n << " " << n << " " << f << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
const int mod = 1e9;
int a[200105];
long long f[200105], sf[200105];
long long s[1 << 20], s1[1 << 20], T[1 << 20];
long long gett(long long f1, long long f2, int cnt) {
if (cnt == 1) return f1;
if (cnt == 2) return f2;
return (f2 * f[cnt - 1] % mod + f1 * f[cnt - 2] % mod) % mod;
}
void up(int rt, int l, int r) {
int mid = (l + r) / 2;
int lcnt = mid - l;
(s[rt] = s[rt << 1] + gett(s[rt << 1 | 1], s1[rt << 1 | 1], lcnt + 1)) %= mod;
(s1[rt] = s1[rt << 1] + gett(s[rt << 1 | 1], s1[rt << 1 | 1], lcnt + 2)) %=
mod;
}
void build(int rt, int l, int r) {
if (l >= r) return;
if (l + 1 == r) {
s[rt] = a[r];
s1[rt] = a[r];
return;
}
int mid = (l + r) / 2;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid, r);
up(rt, l, r);
}
void pdown(int rt, int l, int r) {
if (T[rt] == 0) return;
(s[rt] += sf[r - l] * T[rt] % mod) %= mod;
(s1[rt] += (sf[r - l + 1] - 1 + mod) % mod * T[rt] % mod) %= mod;
(T[rt << 1] += T[rt]) %= mod;
(T[rt << 1 | 1] += T[rt]) %= mod;
T[rt] = 0;
}
void update(int rt, int l, int r, int R) {
pdown(rt, l, r);
if (r < R || R <= l) return;
if (l + 1 == r) {
s[rt] = a[R];
s1[rt] = a[R];
return;
}
int mid = (l + r) / 2;
update(rt << 1, l, mid, R);
update(rt << 1 | 1, mid, r, R);
up(rt, l, r);
}
long long query(int rt, int l, int r, int L, int R) {
pdown(rt, l, r);
if (r <= L || R <= l) return 0;
if (L <= l && r <= R) {
return gett(s[rt], s1[rt], l - L + 1);
}
int mid = (l + r) / 2;
long long x = query(rt << 1, l, mid, L, R);
long long y = query(rt << 1 | 1, mid, r, L, R);
up(rt, l, r);
return (x + y) % mod;
}
void init() {
f[1] = 1;
f[2] = 1;
for (int i = 3; i <= n + 5; i++) f[i] = (f[i - 1] + f[i - 2]) % mod;
for (int(i) = 1; (i) <= (int)(n); (i)++) sf[i] = (sf[i - 1] + f[i]) % mod;
build(1, 0, n);
}
void upt(int rt, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) {
(T[rt] += v) %= mod;
pdown(rt, l, r);
return;
}
int mid = (l + r) / 2;
pdown(rt, l, r);
if (r <= L || R <= l) return;
upt(rt << 1, l, mid, L, R, v);
upt(rt << 1 | 1, mid, r, L, R, v);
up(rt, l, r);
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", a + i);
}
init();
int t, x, y, d;
for (int(i) = 0; (i) < (int)(m); (i)++) {
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
a[x] = y;
update(1, 0, n, x);
} else if (t == 2) {
printf("%lld\n", query(1, 0, n, x - 1, y));
} else {
scanf("%d", &d);
upt(1, 0, n, x - 1, y, d);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string a, b;
cin >> a >> b;
int cum = 0, cnt = 0, d = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '1') cum++;
if (a[i] == '0' && b[i] == '1') d++;
}
long long int sum = 0;
for (int i = 0; i < n; i++) {
if (b[i] == '0' && a[i] == '0') sum += cum;
if (b[i] == '0' && a[i] == '1') sum += d;
}
cout << sum;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
using namespace std;
int t = 0;
vector<int> tin, tout, p, d;
vector<vector<int> > graph;
void mkgph(int n) {
while (--n) {
int v, u;
cin >> v >> u;
graph[u].push_back(v);
graph[v].push_back(u);
}
}
void dfs(int v, int par, int dep) {
p[v] = par;
d[v] = dep;
tin[v] = t++;
for (auto a : graph[v]) {
if (a != par) {
dfs(a, v, dep + 1);
}
}
tout[v] = t++;
}
bool isanc(int v, int u) { return tin[v] <= tin[u] && tout[v] >= tout[u]; }
void queries(int m) {
while (m--) {
int k;
cin >> k;
vector<int> v(k);
for (int i = 0; i < k; i++) cin >> v[i];
int u = v[0];
for (auto a : v)
if (d[a] > d[u]) u = a;
for (auto &a : v)
if (p[a] != -1) a = p[a];
bool flg = true;
for (auto a : v) flg &= isanc(a, u);
if (flg) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
void solve() {
int n, m;
cin >> n >> m;
graph = vector<vector<int> >(n + 1);
tin = tout = p = d = vector<int>(n + 1);
p[0] = d[0] = -1;
mkgph(n);
dfs(1, -1, 0);
queries(m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<string> token(string a) {
vector<string> w;
a.push_back(' ');
while (!a.empty()) {
w.push_back(a.substr(0, a.find(" ")));
a = a.substr(a.find(" ") + 1, a.size() - 1);
}
return w;
}
map<string, int> mapik;
vector<string> amapik;
int dodaj(string a) {
if (mapik.count(a) == 0) {
mapik[a] = mapik.size() - 1;
amapik.push_back(a);
}
return mapik[a];
}
char tmp_str[1000];
string scanf_string() {
scanf("%s", tmp_str);
return tmp_str;
}
const int N = 1000;
int n, m, t;
long long po(int n, int m) {
if (m > n) return 0;
long long res = 1;
for (int i = 1; i <= m; i++) {
res *= n - m + i;
res /= i;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &t);
long long res = 0;
for (int i = 4; i <= t - 1; i++) {
res += po(n, i) * po(m, t - i);
}
printf("%I64d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int const Max = 250000;
char a[Max], b[Max];
bool isequal(char *a, char *b, int length) {
if (!strncmp(a, b, length)) return true;
if (length % 2) return false;
int mid = length / 2;
if (isequal(a, b + mid, mid) && isequal(a + mid, b, mid)) return true;
if (isequal(a, b, mid) && isequal(a + mid, b + mid, mid)) return true;
return false;
}
int main() {
scanf("%s%s", a, b);
printf("%s\n", isequal(a, b, strlen(a)) ? "YES" : "NO");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int res = 0;
set<int> second;
void dfs(long long v, int x, int y) {
if (v <= n) {
second.insert((int)v);
if (!(v == 0 && x == 0)) {
dfs(v * 10 + x, x, y);
}
if (!(v == 0 && y == 0)) {
dfs(v * 10 + y, x, y);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int x = 0; x <= 9; x++) {
for (int y = 0; y <= 9; y++) {
if (x != y) {
dfs(0, x, y);
}
}
}
cout << (int)(second).size() - 1 << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
double eps = 1e-9;
using namespace std;
int arr[1000001];
int high(int n) {
int last = 0;
while (n != 0) {
last++;
n /= 2;
}
return (1 << (last - 1));
}
void func(int n) {
if (n < 0) {
return;
}
if (n == 0) {
arr[0] = 0;
return;
}
int last = high(n);
int k = last - 1;
for (int i = last; i <= n; i++) {
arr[i] = k;
arr[k] = i;
k--;
}
func(k);
}
int main() {
std::ios::sync_with_stdio(false);
memset(arr, -1, sizeof(arr));
long long n;
cin >> n;
func(n);
cout << (n * (n + 1)) << endl;
for (int i = 0; i <= n; i++) {
cout << arr[i] << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void p(vector<long long int> x, int n) {
int i;
for (i = 0; i < n; i++) cout << x[i] << " ";
cout << "\n";
}
void rev(char &a) {
if (a == '1')
a = '0';
else {
a = '1';
}
}
void solve() {
long long int M, K, k, i, j, tot = 0, ro = 0, re = 0, bo = 0, be = 0;
long long int N, f = 0, mx;
cin >> N >> K;
string second[N];
for (i = 0; i < N; i++) cin >> second[i];
vector<vector<long long int>> ans;
for (i = 0; i < N - 1; i++) {
for (j = 0; j < K; j++) {
if (second[i][j] == '1' && j != K - 1) {
vector<long long int> x;
rev(second[i][j]);
rev(second[i][j + 1]);
rev(second[i + 1][j]);
x.push_back(i + 1);
x.push_back(j + 1);
x.push_back(i + 1);
x.push_back(j + 2);
x.push_back(i + 2);
x.push_back(j + 1);
ans.push_back(x);
} else if (second[i][j] == '1') {
vector<long long int> x;
rev(second[i][j]);
rev(second[i + 1][j]);
rev(second[i + 1][j - 1]);
x.push_back(i + 1);
x.push_back(j + 1);
x.push_back(i + 2);
x.push_back(j + 1);
x.push_back(i + 2);
x.push_back(j);
ans.push_back(x);
}
}
}
for (j = 0; j < K - 1; j++) {
if (second[N - 1][j] == '1' && second[N - 1][j + 1] == '1') {
vector<long long int> x, y;
rev(second[N - 1][j]);
rev(second[N - 2][j]);
rev(second[N - 2][j + 1]);
x.push_back(N);
x.push_back(j + 1);
x.push_back(N - 1);
x.push_back(j + 1);
x.push_back(N - 1);
x.push_back(j + 2);
ans.push_back(x);
rev(second[N - 1][j + 1]);
rev(second[N - 2][j]);
rev(second[N - 2][j + 1]);
y.push_back(N);
y.push_back(j + 2);
y.push_back(N - 1);
y.push_back(j + 1);
y.push_back(N - 1);
y.push_back(j + 2);
ans.push_back(y);
} else if ((second[N - 1][j] == '1') && (second[N - 1][j + 1] != '1')) {
vector<long long int> x, y, z;
rev(second[N - 1][j]);
rev(second[N - 2][j]);
rev(second[N - 2][j + 1]);
x.push_back(N);
x.push_back(j + 1);
x.push_back(N - 1);
x.push_back(j + 1);
x.push_back(N - 1);
x.push_back(j + 2);
ans.push_back(x);
rev(second[N - 2][j + 1]);
rev(second[N - 1][j]);
rev(second[N - 1][j + 1]);
y.push_back(N - 1);
y.push_back(j + 2);
y.push_back(N);
y.push_back(j + 1);
y.push_back(N);
y.push_back(j + 2);
ans.push_back(y);
rev(second[N - 2][j]);
rev(second[N - 1][j]);
rev(second[N - 1][j + 1]);
z.push_back(N - 1);
z.push_back(j + 1);
z.push_back(N);
z.push_back(j + 1);
z.push_back(N);
z.push_back(j + 2);
ans.push_back(z);
}
}
if (second[N - 1][K - 1] == '1') {
vector<long long int> x, y, z;
rev(second[N - 1][K - 1]);
rev(second[N - 2][K - 1]);
rev(second[N - 2][K - 2]);
x.push_back(N);
x.push_back(K);
x.push_back(N - 1);
x.push_back(K);
x.push_back(N - 1);
x.push_back(K - 1);
ans.push_back(x);
rev(second[N - 2][K - 2]);
rev(second[N - 1][K - 2]);
rev(second[N - 1][K - 1]);
y.push_back(N - 1);
y.push_back(K - 1);
y.push_back(N);
y.push_back(K - 1);
y.push_back(N);
y.push_back(K);
ans.push_back(y);
rev(second[N - 1][K - 1]);
rev(second[N - 1][K - 2]);
rev(second[N - 2][K - 1]);
z.push_back(N);
z.push_back(K);
z.push_back(N);
z.push_back(K - 1);
z.push_back(N - 1);
z.push_back(K);
ans.push_back(z);
}
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); i++) {
p(ans[i], 6);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1, c = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s;
int ct1[10], ct2[10];
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) ct1[s[i] - '0']++;
for (int i = 0; i < 10; i++) ct2[i] = ct1[i];
int changed = 0, zero, start;
int best = ct1[0];
string b1 = s, b2 = s;
sort(b1.rbegin(), b1.rend());
sort(b2.rbegin(), b2.rend());
for (int z = 0; z <= ct1[0]; z++)
for (int i = 1; i < 10; i++)
if (ct1[i] > 0 && ct2[10 - i] > 0) {
ct1[0] -= z;
ct2[0] -= z;
ct1[i]--;
ct2[10 - i]--;
int get = z + 1;
for (int j = 0; j < 10; j++) get += min(ct1[j], ct2[9 - j]);
if (get > best) {
best = get;
changed = 1;
zero = z;
start = i;
}
ct1[0] += z;
ct2[0] += z;
ct1[i]++;
ct2[10 - i]++;
}
if (changed) {
string c1, c2;
for (int i = 0; i < zero; i++) c1 += "0", c2 += "0";
ct1[0] -= zero;
ct2[0] -= zero;
c1.push_back(start + '0');
c2.push_back(10 - start + '0');
ct1[start]--;
ct2[10 - start]--;
for (int j = 0; j < 10; j++) {
int mn = min(ct1[j], ct2[9 - j]);
for (int k = 0; k < mn; k++) {
c1.push_back(j + '0');
c2.push_back(9 - j + '0');
ct1[j]--;
ct2[9 - j]--;
}
}
for (int i = 0; i < 10; i++)
for (int j = 0; j < ct1[i]; j++) c1.push_back(i + '0');
for (int i = 0; i < 10; i++)
for (int j = 0; j < ct2[i]; j++) c2.push_back(i + '0');
reverse(c1.begin(), c1.end());
reverse(c2.begin(), c2.end());
b1 = c1;
b2 = c2;
}
cout << b1 << endl;
cout << b2 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, sx, sy, ex, ey, dx, dy, time = 0;
string s;
char x, y;
cin >> t >> sx >> sy >> ex >> ey;
cin >> s;
for (auto ch : s) {
if (sx == ex and sy == ey) break;
if (ch == 'N' and sy < ey) {
sy++;
} else if (ch == 'S' and sy > ey) {
sy--;
} else if (ch == 'E' and sx < ex) {
sx++;
} else if (ch == 'W' and sx > ex) {
sx--;
}
time++;
}
cout << (sx == ex and sy == ey ? time : -1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[505][505], f[505][505], g[505][505];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++) f[i][i] = g[i][i] = 1;
for (int l = 2; l <= n; l++)
for (int i = 0; i < n; i++) {
int j = (i + l - 1) % n;
if (a[i][j])
for (int k = i; k != j; k = (k + 1) % n)
g[i][j] = (g[i][j] + 1ll * f[i][k] * f[(k + 1) % n][j]) % 1000000007;
for (int k = i; k != j; k = (k + 1) % n)
f[i][j] = (f[i][j] + 1ll * f[i][k] * g[k][j]) % 1000000007;
}
printf("%d\n", f[0][n - 1]);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
bool pal(string s) {
int i = 0, j = s.size() - 1;
while (i <= j) {
if (s[i] != s[j]) return false;
i++;
j--;
}
return true;
}
int main() {
vector<int> v;
string s, k;
int i = 0, j = 0, l, p = 0;
cin >> s >> k;
int sz = s.size();
while (i < sz && j < k.size()) {
if (s[i] == k[j]) {
i++;
j++;
} else if (p == 0) {
p = i + 1;
i++;
} else {
p = -1;
break;
}
}
if (p == 0)
p = s.size();
else if (p == -1) {
cout << 0;
return 0;
}
for (i = p - 1; i >= 0; i--) {
if (s[i] == s[p - 1])
v.push_back(i);
else
break;
}
for (i = p - 1 + 1; i < s.size(); i++) {
if (s[i] == s[p - 1])
v.push_back(i);
else
break;
}
cout << v.size() << endl;
sort(v.begin(), v.end());
for (auto g : v) cout << g + 1 << " ";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int sum[1 << 18], mx[1 << 18], e[1 << 18];
const int off = 1 << 17;
vector<int> ans;
void stUpdate(int pos, int val, int ee) {
pos += off;
sum[pos] = mx[pos] = val;
e[pos] = ee;
for (pos >>= 1; pos >= 1; pos >>= 1) {
int le = 2 * pos;
int ri = le + 1;
sum[pos] = sum[le] + sum[ri];
mx[pos] = max(mx[le], sum[le] + mx[ri]);
}
}
int stFind(int v, int L, int R, int val) {
if (L == R) {
assert(mx[v] == val);
assert(e[v] != -1);
return e[v];
}
assert(mx[v] >= val);
int mid = (L + R) >> 1;
if (mx[2 * v] >= val) {
return stFind(2 * v, L, mid, val);
}
return stFind(2 * v + 1, mid + 1, R, val - sum[2 * v]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) {
int pos, qt;
scanf("%d%d", &pos, &qt);
pos = n - pos;
if (qt == 0) {
stUpdate(pos, -1, -1);
} else {
int x;
scanf("%d", &x);
stUpdate(pos, 1, x);
}
if (mx[1] < 1) {
ans.push_back(-1);
} else {
ans.push_back(stFind(1, 0, off - 1, 1));
}
}
for (int x : ans) {
printf("%d\n", x);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
long long dp[maxn][maxn][3];
int a[maxn];
long long pre[maxn], suf[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + (a[i] == 1);
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + (a[i] == 2);
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
dp[i][j][0] = dp[i][j - 1][0] + (a[j] == 2);
dp[i][j][1] = max(dp[i][j - 1][0], dp[i][j - 1][1]) + (a[j] == 1);
}
}
for (int i = 1; i <= n; i++) {
for (int j = i - 1; j <= n; j++) {
ans = max(ans, pre[i - 1] + dp[i][j][1] + suf[j + 1]);
}
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
bool si = false;
int main() {
scanf("%d", &n);
scanf("%d", &p);
while (p > 0) {
if (si) printf("RL");
si = true;
printf("P");
p--;
}
si = false;
for (int i = 1; i < n; i++) {
printf("R");
scanf("%d", &p);
while (p > 0) {
if (si) printf("LR");
si = true;
printf("P");
p--;
}
si = false;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int prime = 9241;
long long modulo = (long long)1e13;
long long multiply(long long a, long long b) {
long long res = 0, v = a;
while (b) {
if (b & 1ll) res = res + v;
if (res >= modulo) res -= modulo;
v = v + v;
if (v >= modulo) v -= modulo;
b >>= 1;
}
return res % modulo;
}
struct matr2 {
long long a, b, c, d;
matr2() {}
matr2(long long A, long long B, long long C, long long D)
: a(A % modulo), b(B % modulo), c(C % modulo), d(D % modulo) {}
};
inline matr2 operator*(const matr2 &A, const matr2 &B) {
return matr2(multiply(B.a, A.a) + multiply(A.b, B.c),
multiply(B.b, A.a) + multiply(A.b, B.d),
multiply(A.c, B.a) + multiply(A.d, B.c),
multiply(A.c, B.b) + multiply(A.d, B.d));
}
inline matr2 pow(const matr2 &a, long long p) {
matr2 z = a;
matr2 res = matr2(1ll, 0ll, 0ll, 1ll);
while (p) {
if (p & 1ll) res = res * z;
z = z * z;
p >>= 1;
}
return res;
}
int m1 = 1953125, m2 = 8192;
long long t1, t2;
int fibsm1[8000005];
int fibsm2[200005];
matr2 mm;
int pos1[10], pos2[10];
int cnt1, cnt2;
long long gcd(long long a, long long b) {
while (a > 0ll && b > 0ll)
if (a > b)
a %= b;
else
b %= a;
return a + b;
}
int main() {
long long f;
cin >> f;
int fm1 = (int)(f % (long long)m1), fm2 = (int)(f % (long long)m2);
fibsm1[0] = 0ll, fibsm2[0] = 0ll, fibsm1[1] = 1ll, fibsm2[1] = 1ll;
for (int i = 2;; i++) {
fibsm1[i] = fibsm1[i - 1] + fibsm1[i - 2];
if (fibsm1[i] >= m1) fibsm1[i] -= m1;
if (fibsm1[i - 1] == 0ll && fibsm1[i] == 1ll) {
t1 = i - 1;
break;
}
}
for (int i = 2;; i++) {
fibsm2[i] = fibsm2[i - 1] + fibsm2[i - 2];
if (fibsm2[i] >= m2) fibsm2[i] -= m2;
if (fibsm2[i - 1] == 0ll && fibsm2[i] == 1ll) {
t2 = i - 1;
break;
}
}
cnt1 = cnt2 = 0;
for (int i = 0; i < t1; i++)
if (fm1 == fibsm1[i]) pos1[cnt1++] = i;
for (int i = 0; i < t2; i++)
if (fm2 == fibsm2[i]) pos2[cnt2++] = i;
matr2 zm;
long long ans = (long long)1e18, t12 = t1 * t2;
long long diff = t1 * t2 / gcd(t1, t2);
mm = pow(matr2(0ll, 1ll, 1ll, 1ll), diff);
for (int i = 0; i < cnt1; i++)
for (int j = 0; j < cnt2; j++) {
long long s = -1ll;
for (long long x = 0; x * t1 <= diff; x++)
if ((t1 * x + pos1[i] - pos2[j]) % t2 == 0ll) {
s = x * t1 + pos1[i];
zm = pow(matr2(0ll, 1ll, 1ll, 1ll), s + 1);
for (long long it = s; it <= (long long)1.5e13; it += diff) {
if (zm.a == f) {
ans = min(ans, it);
break;
}
zm = zm * mm;
}
}
}
if (ans >= (long long)1e18)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
string arr;
int n, sum = 0;
void print(int n1 = -1, int n2 = -1) {
if (sum == 0) {
cout << 0;
return;
}
for (int i = 0; i < n; i++) {
if (arr[i] - 48 == n1) {
n1 = -1;
continue;
} else if (arr[i] - 48 == n2) {
n2 = -1;
continue;
}
cout << arr[i];
}
}
int main() {
char ch;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ch;
arr += ch;
sum += (ch - 48);
}
sort(arr.rbegin(), arr.rend());
if (arr[n - 1] == '0') {
if (sum % 3 == 0) {
print();
} else {
int a1 = -1, b1 = -1, c2 = -1, d2 = -1;
for (int i = n - 1; i >= 0; i--) {
if ((arr[i] - 48) % 3 == 1) {
if (a1 == -1)
a1 = arr[i] - 48;
else if (b1 == -1)
b1 = arr[i] - 48;
} else if ((arr[i] - 48) % 3 == 2) {
if (c2 == -1)
c2 = arr[i] - 48;
else if (d2 == -1)
d2 = arr[i] - 48;
}
if (a1 != -1 && b1 != -1 && c2 != -1 && d2 != -1) break;
}
if (sum % 3 == 1 && a1 != -1) {
sum -= a1;
print(a1);
} else if (sum % 3 == 1 && c2 != -1 && d2 != -1) {
sum -= c2;
sum -= d2;
print(c2, d2);
} else if (sum % 3 == 2 && c2 != -1) {
sum -= c2;
print(c2);
} else if (sum % 3 == 2 && a1 != -1 && b1 != -1) {
sum -= a1;
sum -= b1;
print(a1, b1);
} else {
cout << -1;
}
}
} else {
cout << -1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100, C = 26, base = 987, MOD = 99999199999;
long long val[C], num[C], valT[C], numT[C], p[N];
queue<long long> pos[C];
map<long long, long long> mp;
vector<long long> ans;
bool mark[C];
string s, t;
long long n, m, cnt, hT;
inline long long Hash(string str, long long l, long long r, long long (&val)[C],
long long (&num)[C]) {
memset(mark, 0, sizeof mark);
memset(num, 0, sizeof num);
memset(val, 0, sizeof val);
cnt = 0;
long long res = 0;
for (long long i = l; i < r; i++) {
long long x = str[i] - 'a';
if (!mark[x]) {
num[x] = ++cnt;
mark[x] = true;
}
val[x] = (val[x] + p[r - 1 - i]) % MOD;
}
for (long long i = 0; i < C; i++)
res = (res + ((val[i] * num[i]) % MOD)) % MOD;
return res;
}
inline void update(long long i) {
long long tmp = s[i - 1] - 'a';
pos[tmp].pop();
val[tmp] = (MOD + val[tmp] - p[m - 1]) % MOD;
for (long long j = 0; j < C; j++)
if (pos[j].front() < i + m - 1) {
val[j] = (val[j] * base) % MOD;
}
tmp = s[i + m - 1] - 'a';
val[tmp] = (val[tmp] + p[0]) % MOD;
tmp = s[i - 1] - 'a';
num[tmp] = 1;
long long hlp = 1;
for (long long j = 0; j < C; j++) {
if (pos[j].front() < pos[tmp].front()) {
num[j]--;
num[tmp]++;
}
if (pos[j].front() < i + m - 1) hlp++;
}
tmp = s[i + m - 1] - 'a';
if (pos[tmp].front() == i + m - 1) num[tmp] = hlp;
}
inline bool check(long long i) {
mp.clear();
bool ok = true;
for (long long j = 0; j < C && ok; j++)
for (long long k = 0; k < C && ok; k++) {
if (pos[j].front() < i + m && num[j] == numT[k]) {
if ((mp.find(j) != mp.end() && mp[j] != k) ||
(mp.find(k) != mp.end() && mp[k] != j)) {
ok = false;
}
mp[j] = k;
mp[k] = j;
}
}
return ok;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> s >> t;
p[0] = 1;
for (long long i = 1; i < N; i++) p[i] = (p[i - 1] * base) % MOD;
hT = Hash(t, 0, m, valT, numT);
for (long long i = 0; i < n; i++) {
long long x = s[i] - 'a';
pos[x].push(i);
}
for (long long i = 0; i < C; i++) pos[i].push(N);
if (Hash(s, 0, m, val, num) == hT && check(0)) ans.push_back(0);
for (long long i = 1; i + m <= n; i++) {
update(i);
long long res = 0;
for (long long i = 0; i < C; i++)
res = (res + ((val[i] * num[i]) % MOD)) % MOD;
if (res == hT && check(i)) ans.push_back(i);
}
cout << (long long)ans.size() << '\n';
for (auto x : ans) cout << x + 1 << " ";
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int digits(int n) {
int a, b, c, d;
a = n % 10;
b = (n / 10) % 10;
c = (n / 100) % 10;
d = (n / 1000) % 10;
if (a != b && a != c && a != d && b != c && b != d && c != d) return 1;
return 0;
}
int main() {
int n, x;
cin >> n;
for (int i = n + 1; i < 9100; i++) {
x = digits(i);
if (x == 1) {
cout << i;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n;
int main() {
scanf("%d", &n);
puts("YES");
for (int i = 0, x, y, _, __; i < n; ++i) {
scanf("%d%d%d%d", &x, &y, &_, &__);
printf("%d\n", (((x & 1) << 1) | (y & 1)) + 1);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long int huge = 1e17;
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int abbs(long long int a, long long int b) {
if (a - b < 0) return b - a;
return a - b;
}
void solve() {
long long int n;
cin >> n;
long long int s = (n) * (n + 1) / 2;
long long int pow = 1;
long long int pows = 0;
while (pow <= n) {
pows += pow;
pow *= 2;
}
cout << s - 2 * pows << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 5;
const long long int M = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long int n, k;
cin >> n >> k;
long long int low = 1, high = (1e18) + 1;
long long int ans = -1;
while (low <= high) {
long long int mid = (low + high) / 2;
if (mid % 2 == 0) mid--;
long long int temp = mid, cnt = 0, mul = 1;
while (temp <= n) {
if (n - temp + 1 >= mul)
cnt += mul;
else {
cnt += n - temp + 1;
break;
}
mul = mul * 2;
temp = temp * 2;
}
if (cnt >= k) {
low = mid + 2;
ans = max(ans, mid);
} else
high = mid - 2;
}
low = 2, high = 1e18;
while (low <= high) {
long long int mid = (low + high) / 2;
if (mid % 2 == 1) mid--;
long long int temp = mid, cnt = 0, mul = 2;
while (temp <= n) {
if (n - temp + 1 >= mul)
cnt += mul;
else {
cnt += n - temp + 1;
break;
}
mul = mul * 2;
temp = temp * 2;
}
if (cnt >= k) {
low = mid + 2;
ans = max(ans, mid);
} else
high = mid - 2;
}
cout << ans;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int a[10000005];
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), ans += a[i];
sort(a + 1, a + 1 + n, cmp);
int temp = 1e9;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= a[i] / 2; j++) {
if (a[i] % j == 0) {
temp = min(temp, ans - (a[i] - a[i] / j) + (a[n] * j - a[n]));
}
}
}
cout << min(temp, ans) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> ans;
int power = 1;
while (n > 0) {
if (n % 10 > 0) {
ans.push_back((n % 10) * power);
}
n /= 10;
power *= 10;
}
cout << ans.size() << endl;
for (auto number : ans) cout << number << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
int a[200005];
int d[200005];
int main() {
int n;
scanf("%d", &n);
int minim = 2000000000;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (minim > a[i]) minim = a[i];
}
int maxim = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == minim) {
d[i] = 0;
} else {
d[i] = d[i - 1] + 1;
}
if (d[i] > maxim) maxim = d[i];
}
d[0] = d[n];
for (int i = 1; i <= n; ++i) {
if (a[i] == minim) {
d[i] = 0;
} else {
d[i] = d[i - 1] + 1;
}
if (d[i] > maxim) maxim = d[i];
}
printf("%I64d", 1LL * maxim + 1LL * n * minim);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t, x;
cin >> s >> t >> x;
map<char, char> m;
for (int i = 0; i < 26; i++) {
m[s[i]] = t[i];
m[toupper(s[i])] = toupper(t[i]);
}
for (int i = 0; i < x.size(); i++) {
if (isdigit(x[i]))
cout << x[i];
else
cout << m[x[i]];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, a[100001];
cin >> n;
if (n == 1) {
cout << -1 << endl;
} else {
for (long long i = 0; i < n; i++) {
if (i != n - 1) {
cout << 9;
} else {
cout << 8 << endl;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ma = 360;
cin >> n;
int arr[n];
int s = 0;
int g = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
s = 0;
if (i == n - 1) break;
for (int j = i; j < n + i; j++) {
s += arr[j % n];
g = 360 - s;
ma = min(ma, abs(g - s));
}
}
cout << ma << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dirK[8][2] = {{-2, 1}, {-1, 2}, {1, 2}, {2, 1},
{2, -1}, {-1, -2}, {1, -2}, {-2, -1}};
int dir8[8][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, -1}, {1, 1}, {1, -1}, {-1, 1}};
int dir4[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool row[100005];
bool col[100005];
vector<long long> pos;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, i, j, k, l, n, m, p, q, u, v, a, b, c, num, sum, counter, length, high,
low;
scanf("%d %d", &n, &m);
int numRow = n, numCol = n;
for (i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
if (!row[a]) {
row[a] = true;
numRow--;
}
if (!col[b]) {
col[b] = true;
numCol--;
}
pos.push_back((long long)numRow * numCol);
}
for (i = 0; i < pos.size(); i++) {
if (i != 0) {
cout << " ";
}
cout << pos[i];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, a[100001], b[100001], k, x, y, p, mid, sz;
vector<int> g[100001];
map<int, int> st;
set<int> q;
string s, s2;
char c;
int main() {
cin >> n >> k >> p >> x >> y;
for (int i = 1; i <= k; i++) {
cin >> a[i];
mid += a[i];
b[i] = a[i];
sz++;
}
sort(a + 1, a + k + 1);
int ss = k;
while (n - k) {
sort(a + 1, a + k + 1);
if (n < k * 2) {
if (a[k - (n + 1) / 2 + 1] >= y) {
if (mid + n - k <= x) {
for (int i = ss + 1; i <= sz; i++) cout << b[i] << ' ';
for (int i = 1; i <= n - k; i++) {
cout << 1 << ' ';
}
} else
cout << -1;
return 0;
}
}
bool ok = 1;
for (int i = y; i <= p; i++) {
if (mid + i <= x) {
a[++sz] = i;
b[sz] = i;
mid += i;
ok = 0;
break;
}
}
if (ok) {
cout << -1;
return 0;
}
k++;
}
sort(a + 1, a + k + 1);
if (a[k / 2 + 1] >= y && mid <= x) {
for (int i = ss + 1; i <= sz; i++) cout << b[i] << ' ';
return 0;
}
cout << -1;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int sg[100005];
int ans[100005];
int getSG(int n) {
if (sg[n] != -1) {
return sg[n];
}
bool vis[100] = {false};
int y = n + n;
for (int k = 2; k < y; k++) {
if (y % k == 0) {
int a = y / k - k + 1;
if (a > 0 && a % 2 == 0) {
a >>= 1;
int b = a + k - 1;
int tmp = 0;
for (int i = a; i <= b; i++) {
tmp ^= getSG(i);
}
vis[tmp] = true;
if (tmp == 0) {
ans[n] = min(ans[n], k);
}
}
}
}
for (int i = 0; i < 100; i++) {
if (vis[i] == false) {
return sg[n] = i;
}
}
}
int main() {
int n;
memset(sg, -1, sizeof(sg));
for (int i = 0; i < 100005; i++) {
ans[i] = 999999999;
}
while (scanf("%d", &n) != EOF) {
if (getSG(n) == 0) {
puts("-1");
} else {
printf("%d\n", ans[n]);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v, v1;
const long long MAX = 1e18;
void pre() {
for (long long i = 2; i < 1000000; i++) {
long long p = i * i * i;
long long sq = sqrt(i);
if (sq * sq == i) continue;
while (p > 0 and p < MAX and p % i == 0) {
long long x = sqrt(p);
if (x * x != p) v.push_back(p);
p *= i;
}
}
sort(v.begin(), v.end());
v1.push_back(v[0]);
for (long long i = 1; i < v.size(); i++)
if (v[i] != v[i - 1]) v1.push_back(v[i]);
}
int main() {
pre();
long long l, r;
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld %lld", &l, &r);
long long ans = upper_bound(v1.begin(), v1.end(), r) -
upper_bound(v1.begin(), v1.end(), l - 1LL);
long long x = sqrt(l - 1LL + 1e-9);
long long y = sqrt(r + 1e-9);
ans += (y - x);
printf("%lld\n", ans);
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double eps = 1e-15;
int vis[1001010];
void ex_gcd(int a, int b, int &x, int &y) {
if (!b) {
x = 1;
y = 0;
} else {
ex_gcd(b, a % b, y, x);
y -= x * (a / b);
}
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int m;
while (~scanf("%d", &m)) {
int h1, a1, x1, y1;
int h2, a2, x2, y2;
scanf("%d%d%d%d", &h1, &a1, &x1, &y1);
scanf("%d%d%d%d", &h2, &a2, &x2, &y2);
for (int i = 0; i <= m; ++i) {
vis[i] = -1;
}
int s1 = -1;
vis[h1] = 0;
long long cur = h1;
int len1 = 0;
for (int i = 1; i <= m; ++i) {
cur = (cur * x1 + y1) % m;
if (vis[cur] == -1) {
vis[cur] = i;
if (cur == a1) {
s1 = i;
}
} else {
len1 = i - vis[cur];
break;
}
}
if (s1 == -1) {
printf("-1\n");
continue;
}
cur = a1;
bool flag1 = 0;
for (int i = s1 + 1; i <= len1 + s1; ++i) {
cur = (cur * x1 + y1) % m;
}
if (cur == a1) {
flag1 = 1;
}
cur = h2;
int len2 = 0;
int s2 = -1;
for (int i = 0; i <= m; ++i) {
vis[i] = -1;
}
vis[h2] = 0;
for (int i = 1; i <= m; ++i) {
cur = (cur * x2 + y2) % m;
if (vis[cur] == -1) {
vis[cur] = i;
if (cur == a2) {
s2 = i;
}
} else {
len2 = i - vis[cur];
break;
}
}
if (s2 == -1) {
printf("-1\n");
continue;
}
bool flag2 = 0;
cur = a2;
for (int i = s2 + 1; i <= s2 + len2; ++i) {
cur = (cur * x2 + y2) % m;
}
if (cur == a2) {
flag2 = 1;
}
if (!flag1 && !flag2) {
if (s1 == s2) {
printf("%d\n", s1);
} else {
printf("-1\n");
}
continue;
}
if (!flag1 && flag2) {
if (s1 < s2) {
printf("-1\n");
} else {
if ((s1 - s2) % len2) {
printf("-1\n");
} else {
printf("%d\n", s1);
}
}
continue;
}
if (flag1 && !flag2) {
if (s1 > s2) {
printf("-1\n");
} else {
if ((s2 - s1) % len1) {
printf("-1\n");
} else {
printf("%d\n", s2);
}
}
continue;
}
int GCD = gcd(len1, len2);
if ((s2 - s1) % GCD) {
printf("-1\n");
continue;
}
int x0, y0;
ex_gcd(len1, len2, x0, y0);
x0 = x0 * (s2 - s1) / GCD;
y0 *= -1;
y0 = y0 * (s2 - s1) / GCD;
int b = len2 / GCD;
int a = len1 / GCD;
if (x0 < 0) {
long long k = ceil(-1.0 * x0 / b);
x0 += k * b;
y0 += k * a;
}
if (y0 < 0) {
long long k = ceil(-1.0 * y0 / a);
x0 += k * b;
y0 += k * a;
}
long long ans = (long long)y0 * len2 + s2;
while (1) {
if (y0 - a >= 0) {
y0 -= a;
x0 -= b;
ans = (long long)y0 * len2 + s2;
} else {
break;
}
}
cout << ans << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
vector<char> v;
getline(cin, str);
for (int i = 0; i < str.size(); i++) {
if (v.empty() || v.back() != str[i])
v.push_back(str[i]);
else
v.pop_back();
}
vector<char>::iterator it;
for (it = v.begin(); it != v.end(); it++) cout << *it;
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.size();
long long two = -1, five = -1, seven = -1, zero1 = -1, zero2 = -1;
for (long long i = 0; i < n; ++i) {
if (s[i] == '2') {
two = i;
} else if (s[i] == '5') {
five = i;
} else if (s[i] == '7') {
seven = i;
} else if (s[i] == '0') {
if (zero1 == -1) {
zero1 = i;
} else {
zero2 = zero1;
zero1 = i;
}
}
}
long long ans = 1e9;
if (two != -1 && five != -1) {
string temp = s;
long long cur = 0;
for (long long i = five + 1; i < n; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
for (long long i = 0; i < n - 1; ++i) {
if (s[i] == '2') {
two = i;
}
}
for (long long i = two + 1; i < n - 1; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
if (s[0] == '0') {
for (long long i = 1; i < n; ++i) {
if (s[i] != '0') {
for (long long j = i; j > 0; --j) {
swap(s[j], s[j - 1]);
cur++;
}
break;
}
}
}
if (s[0] != '0' && s[n - 2] == '2' && s[n - 1] == '5') ans = min(ans, cur);
s = temp;
}
if (seven != -1 && five != -1) {
string temp = s;
long long cur = 0;
for (long long i = five + 1; i < n; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
for (long long i = 0; i < n - 1; ++i) {
if (s[i] == '7') {
seven = i;
}
}
for (long long i = seven + 1; i < n - 1; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
if (s[0] == '0') {
for (long long i = 1; i < n - 2; ++i) {
if (s[i] != '0') {
for (long long j = i; j > 0; --j) {
swap(s[j], s[j - 1]);
cur++;
}
break;
}
}
}
if (s[0] != '0' && s[n - 2] == '7' && s[n - 1] == '5') ans = min(ans, cur);
s = temp;
}
if (five != -1 && zero1 != -1) {
string temp = s;
long long cur = 0;
for (long long i = zero1 + 1; i < n; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
for (long long i = 0; i < n - 1; ++i) {
if (s[i] == '5') {
five = i;
}
}
for (long long i = five + 1; i < n - 1; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
if (s[0] == '0') {
for (long long i = 1; i < n - 2; ++i) {
if (s[i] != '0') {
for (long long j = i; j > 0; --j) {
swap(s[j], s[j - 1]);
cur++;
}
break;
}
}
}
if (s[0] != '0' && s[n - 2] == '5' && s[n - 1] == '0') ans = min(ans, cur);
s = temp;
}
if (zero2 != -1 && zero1 != -1) {
string temp = s;
long long cur = 0;
for (long long i = zero1 + 1; i < n; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
for (long long i = 0; i < n - 1; ++i) {
if (s[i] == '0') {
zero2 = i;
}
}
for (long long i = zero2 + 1; i < n - 1; ++i) {
swap(s[i - 1], s[i]);
cur++;
}
if (s[0] == '0') {
for (long long i = 1; i < n - 2; ++i) {
if (s[i] != '0') {
for (long long j = i; j > 0; --j) {
swap(s[j], s[j - 1]);
cur++;
}
break;
}
}
}
if (s[0] != '0' && s[n - 2] == '0' && s[n - 1] == '0') ans = min(ans, cur);
s = temp;
}
if (ans == 1e9) ans = -1;
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int MOD = 1e9 + 7;
const int N = 5e5;
vector<int> g[N];
int pres[N], p[N], sub[N];
int root(int u) {
while (u != p[u]) {
p[u] = p[p[u]];
u = p[u];
}
return u;
}
void merge(int uu, int vv) {
int u = root(uu), v = root(vv);
if (u == v) return;
if (sub[u] < sub[v]) swap(u, v);
p[v] = u;
sub[u] += sub[v];
}
void solve() {
int n, m, i;
cin >> n >> m;
for (i = 1; i <= n; i++) {
g[i].clear();
pres[i] = 0;
p[i] = i;
sub[i] = 0;
}
for (i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
int j = 1, sz = g[1].size();
for (i = 2; i <= n; i++) {
int now = g[i].size();
if (sz > now) {
sz = now;
j = i;
}
}
vector<int> cand;
cand.push_back(j);
for (auto it : g[j]) cand.push_back(it);
for (auto it : cand) {
for (auto jt : g[it]) pres[jt] = 1;
for (i = 1; i <= n; i++)
if (!pres[i]) merge(i, it);
for (auto jt : g[it]) pres[jt] = 0;
}
int ans = 0;
for (i = 1; i <= n; i++)
if (p[i] == i) ans++;
cout << ans - 1 << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void Read(T &x) {
char ch;
bool neg = 0;
x = 0;
while (!isdigit(ch = getchar()) && ch != '-')
;
if (ch == '-') {
neg = 1;
ch = getchar();
}
do {
x = x * 10 + ch - 48;
} while (isdigit(ch = getchar()));
if (neg) x = -x;
return;
}
template <typename T>
void Write(T x) {
char ch[32];
int cnt = 0;
bool neg = 0;
if (x < 0) {
neg = 1;
x = -x;
}
do {
ch[++cnt] = x % 10 + 48;
x /= 10;
} while (x);
if (neg) putchar('-');
for (int i = (cnt); i >= (1); --i) putchar(ch[i]);
}
template <typename T>
void Writeln(T x) {
Write(x);
putchar('\n');
}
template <typename T>
void Writesp(T x) {
Write(x);
putchar(' ');
}
const int MAX = 1e5 + 5;
const int INF = 0x3f3f3f3f;
struct SegmentMin {
pair<int, int> Tree[MAX << 2];
void Init(int n) {
for (int i = (1); i <= (n << 2); ++i) Tree[i] = pair<int, int>(INF, 1);
}
void Update(int id, int l, int r, int u, int val) {
if (l > u || r < u) return;
if (l == r) {
Tree[id] = pair<int, int>(val, 1);
return;
}
int mid = (l + r) >> 1;
Update(2 * id, l, mid, u, val);
Update(2 * id + 1, mid + 1, r, u, val);
if (Tree[2 * id].first < Tree[2 * id + 1].first)
Tree[id] = Tree[2 * id];
else if (Tree[2 * id].first > Tree[2 * id + 1].first)
Tree[id] = Tree[2 * id + 1];
else
Tree[id] = pair<int, int>(Tree[2 * id].first,
Tree[2 * id].second + Tree[2 * id + 1].second);
}
pair<int, int> Query(int id, int l, int r, int u, int v) {
if (l > v || r < u) return pair<int, int>(INF, 1);
if (l >= u && r <= v) return Tree[id];
int mid = (l + r) >> 1;
pair<int, int> L = Query(2 * id, l, mid, u, v);
pair<int, int> R = Query(2 * id + 1, mid + 1, r, u, v);
if (L.first < R.first)
return L;
else if (L.first > R.first)
return R;
else
return pair<int, int>(L.first, L.second + R.second);
}
} IT0;
struct SegmentGCD {
int Tree[MAX << 2];
void Init(int n) {
for (int i = (1); i <= (n << 2); ++i) Tree[i] = 1;
}
int GCD(int x, int y) {
if (!y) return x;
return GCD(y, x % y);
}
void Update(int id, int l, int r, int u, int val) {
if (l > u || r < u) return;
if (l == r) {
Tree[id] = val;
return;
}
int mid = (l + r) >> 1;
Update(2 * id, l, mid, u, val);
Update(2 * id + 1, mid + 1, r, u, val);
Tree[id] = GCD(Tree[2 * id], Tree[2 * id + 1]);
}
int Query(int id, int l, int r, int u, int v) {
if (l > v || r < u) return 0;
if (l >= u && r <= v) return Tree[id];
int mid = (l + r) >> 1;
int L = Query(2 * id, l, mid, u, v);
int R = Query(2 * id + 1, mid + 1, r, u, v);
if (L == 0) return R;
if (R == 0) return L;
return GCD(L, R);
}
} IT1;
int main(int argc, char const *argv[]) {
int n, q;
int u, v;
Read(n);
IT0.Init(n);
IT1.Init(n);
for (int i = (1); i <= (n); ++i) {
Read(u);
IT0.Update(1, 1, n, i, u);
IT1.Update(1, 1, n, i, u);
}
Read(q);
for (int i = (1); i <= (q); ++i) {
Read(u);
Read(v);
pair<int, int> Min = IT0.Query(1, 1, n, u, v);
int Gcd = IT1.Query(1, 1, n, u, v);
if (Min.first != Gcd)
Writeln(v - u + 1);
else
Writeln(v - u - Min.second + 1);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
int arr[20];
using namespace std;
int main() {
int n, l, r, x;
scanf("%d", &n);
;
scanf("%d", &l);
;
scanf("%d", &r);
;
scanf("%d", &x);
;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
;
}
int ans = 0;
for (int i = 0; i < (1 << n); i++) {
int minv = INT_MAX;
int maxv = INT_MIN;
int sum = 0;
int count = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
count++;
sum = sum + arr[j];
if (arr[j] > maxv) {
maxv = arr[j];
}
if (arr[j] < minv) {
minv = arr[j];
}
}
}
if (count >= 2 && maxv - minv >= x && sum >= l && sum <= r) ans++;
}
printf("%d\n", ans);
;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a[55];
pair<int, int> dp[55][2];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
dp[n - 1][0] = make_pair(0, a[n - 1]);
dp[n - 1][1] = make_pair(a[n - 1], 0);
for (int i = n - 2; i >= 0; i--) {
if (a[i] + dp[i + 1][1].second > dp[i + 1][0].second) {
dp[i][0] = make_pair(dp[i + 1][1].first, a[i] + dp[i + 1][1].second);
} else {
dp[i][0] = make_pair(a[i] + dp[i + 1][0].first, dp[i + 1][0].second);
}
if (a[i] + dp[i + 1][0].first > dp[i + 1][1].first) {
dp[i][1] = make_pair(a[i] + dp[i + 1][0].first, dp[i + 1][0].second);
} else {
dp[i][1] = make_pair(dp[i + 1][1].first, a[i] + dp[i + 1][1].second);
}
}
printf("%d %d", dp[0][0].first, dp[0][0].second);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, i;
char str[1009];
scanf("%d", &a);
cin >> str;
if (str[0] == '0' && a > 1) {
cout << "No solution" << endl;
return 0;
}
for (i = 1; i < a; i++) {
str[i] = '0';
}
str[i] = '\0';
cout << str << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 2e5 + 5;
const int mod = 1e9 + 7;
int n, q;
int a[mn];
bool is_cycle[mn];
int cycc[mn];
vector<int> cycle[mn];
int cycnt;
int cyid[mn];
int to[mn];
int dist[mn];
vector<int> rg[mn];
int vis[mn];
vector<int> st;
void dfs(int x) {
if (vis[x] == -1) {
int u = ((int)st.size()) - 1;
++cycnt;
while (st[u] != x) {
is_cycle[st[u]] = 1;
cycc[st[u]] = cycnt;
cyid[st[u]] = cycle[cycnt].size();
cycle[cycnt].push_back(st[u]);
u--;
}
is_cycle[st[u]] = 1;
cycc[st[u]] = cycnt;
cyid[st[u]] = cycle[cycnt].size();
cycle[cycnt].push_back(st[u]);
return;
}
vis[x] = -1;
st.push_back(x);
if (vis[a[x]] != 1) {
dfs(a[x]);
}
if (vis[a[x]] == 1 && cycc[a[x]] && !cycc[x]) {
cycc[x] = cycc[a[x]];
}
vis[x] = 1;
st.pop_back();
}
struct node {
int id, dist, from;
};
vector<int> vv[mn];
void bfs() {
queue<node> q;
for (int i = 1; i <= n; i++) {
if (is_cycle[i]) q.push({i, 0, i});
}
while (!q.empty()) {
node u = q.front();
q.pop();
for (auto &p : rg[u.id]) {
if (is_cycle[p]) continue;
q.push({p, u.dist + 1, u.from});
to[p] = u.from;
dist[p] = u.dist + 1;
vv[u.from].push_back(u.dist + 1);
}
}
}
struct query {
long long m;
int y, id, cyclecnt;
bool operator<(const query &p) const { return cyclecnt < p.cyclecnt; }
} Q[mn];
int ans[mn];
vector<int> cyclemod[mn];
int dfsc;
int pc[mn], pe[mn];
int dep[mn];
int maxid;
vector<int> v[mn];
void dfs2(int x, int banned, int depth, int cyclesize) {
pc[x] = ++dfsc;
dep[x] = depth;
maxid = max(depth, maxid);
v[depth].push_back(pc[x]);
if (!is_cycle[x]) cyclemod[depth % cyclesize].push_back(depth - dep[to[x]]);
for (auto &i : rg[x]) {
if (i != banned) {
dfs2(i, banned, depth + 1, cyclesize);
}
}
pe[x] = dfsc;
}
void build(int cnt) {
int cysize = cycle[cnt].size();
for (int i = 0; i < ((int)cycle[cnt].size()); i++) {
cyclemod[i].clear();
}
for (int i = 0; i <= maxid; i++) v[i].clear();
maxid = 0;
for (auto &i : cycle[cnt]) {
if (is_cycle[i]) {
dfs2(i, i, 0, ((int)cycle[cnt].size()));
break;
}
}
for (int j = 0; j < ((int)cycle[cnt].size()); j++) {
sort(cyclemod[j].begin(), cyclemod[j].end());
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
rg[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
bfs();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%lld%d", &Q[i].m, &Q[i].y);
Q[i].id = i;
Q[i].cyclecnt = cycc[Q[i].y];
}
sort(Q + 1, Q + q + 1);
int lastqcy = 0;
for (int i = 1; i <= q; i++) {
if (lastqcy != Q[i].cyclecnt) {
build(Q[i].cyclecnt);
lastqcy = Q[i].cyclecnt;
}
if (!is_cycle[Q[i].y]) {
Q[i].m = min(Q[i].m, (long long)1e6);
int di = dep[Q[i].y] + Q[i].m;
ans[Q[i].id] = upper_bound(v[di].begin(), v[di].end(), pe[Q[i].y]) -
lower_bound(v[di].begin(), v[di].end(), pc[Q[i].y]);
} else {
int idx = (cyid[Q[i].y] + Q[i].m) % ((int)cycle[lastqcy].size());
ans[Q[i].id] =
upper_bound(cyclemod[idx].begin(), cyclemod[idx].end(), Q[i].m) -
begin(cyclemod[idx]) + 1;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
bool solve(string s) {
int n = s.size();
if (n < 5) return 0;
bool search = 0;
for (int i = 0; i < n; ++i)
if (isdigit(s[i])) search = 1;
if (!search) return 0;
search = 0;
for (int i = 0; i < n; ++i)
if (islower(s[i])) search = 1;
if (!search) return 0;
search = 0;
for (int i = 0; i < n; ++i)
if (isupper(s[i])) search = 1;
if (!search) return 0;
return 1;
}
int main() {
ios_base ::sync_with_stdio(0);
string s;
while (getline(cin, s)) {
cout << (solve(s) ? "Correct" : "Too weak") << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
void clock_out() {
cerr << "\nTime Elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " s\n";
}
void fileio() {
freopen("/home/dwai/Desktop/cp/input.txt", "r", stdin);
freopen("/home/dwai/Desktop/cp/output.txt", "w", stdout);
freopen("/home/dwai/Desktop/cp/debug.txt", "w", stderr);
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
int IT_MAX = 1 << 20;
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
int main() {
42;
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
long long n, m, k;
cin >> n >> m >> k;
long long arr[n], i;
for (i = 0; i < n; i++) cin >> arr[i];
long long arr2[n];
copy(arr, arr + n, arr2);
sort(arr2, arr2 + n, greater<long long>());
long long sum = 0;
map<long long, long long> store;
for (i = 0; i < m * k; i++) sum += arr2[i], store[arr2[i]]++;
vector<long long> v;
long long cnt = 0;
for (i = 0; i < n; i++) {
if (store[arr[i]]) {
store[arr[i]]--;
cnt++;
if (cnt == m) {
v.emplace_back(i + 1);
cnt = 0;
}
}
}
cnt = 0;
cout << sum << "\n";
auto itr = v.begin();
while (itr != v.end() && cnt < k - 1) {
cnt++;
cout << *itr << " ";
itr++;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, q, l, r;
scanf("%d%d%d%d", &p, &q, &l, &r);
int mark[1111];
memset(mark, 0, sizeof(mark));
int a, b;
for (int i = 0; i < p; i++) {
scanf("%d%d", &a, &b);
for (int j = a; j <= b; j++) mark[j] = 1;
}
int c[55], d[55];
for (int i = 0; i < q; i++) {
scanf("%d%d", &c[i], &d[i]);
}
int ans = 0;
for (int i = l; i <= r; i++) {
for (int j = 0; j < q; j++) {
int flag = 0;
for (int k = c[j] + i; k <= d[j] + i; k++) {
if (k <= 1000 && mark[k]) {
ans++;
flag = 1;
break;
}
}
if (flag) break;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, i, d[101], a, mlad, prod, x, y;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a);
d[i] = d[i - 1] + a;
}
scanf("%d %d", &x, &y);
for (i = 1; i <= n; i++) {
prod = d[n] - d[i - 1];
mlad = d[i - 1];
if (x <= mlad && mlad <= y && x <= prod && prod <= y) {
printf("%d", i);
return 0;
}
}
printf("0");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int n, m;
char G[2000][2000];
deque<pair<pii, int>> deq;
int dist[2000][2000];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
void bfs(int s, int t) {
deq.emplace_front(make_pair(make_pair(s, t), 0));
while (!deq.empty()) {
pair<pii, int> p = deq.front();
deq.pop_front();
int x = p.first.first, y = p.first.second;
int d = p.second;
if (dist[x][y] != -1) continue;
dist[x][y] = d;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || G[nx][ny] == '*') continue;
if (dx[i] == 0)
deq.emplace_back(make_pair(make_pair(nx, ny), d + 1));
else
deq.emplace_front(make_pair(make_pair(nx, ny), d));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, r, c, x, y;
cin >> n >> m >> r >> c >> x >> y;
r--;
c--;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> G[i][j];
dist[i][j] = -1;
}
}
bfs(r, c);
int cnt = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
int u = (j - c + dist[i][j]) / 2;
int v = dist[i][j] - u;
if (u <= y && u >= 0 && v <= x && v >= 0 && dist[i][j] != -1) cnt++;
}
}
cout << cnt << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
char b = 'a';
long long int g = n / k;
long long int sex = n % k;
long long int j;
long long int i = 1;
while (i <= k) {
j = 1;
while (j <= g) {
cout << b;
j++;
}
b++;
i++;
}
b--;
i = 1;
while (i <= sex) {
cout << b;
i++;
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mdl;
vector<long long> vis;
void gen(long long& f, long long& p, long long h, long long a, long long x,
long long y) {
vis = vector<long long>(1000009, -1);
long long ct = 0;
while (vis[h] == -1) {
vis[h] = ct;
h = (x * h + y) % mdl;
++ct;
}
if (vis[a] == -1) {
cout << -1 << endl;
exit(0);
}
f = vis[a];
p = ct - vis[h];
if (vis[a] < vis[h]) p = -1;
}
long long f1, p1, f2, p2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> mdl;
long long h1, a1, x1, y1;
cin >> h1 >> a1 >> x1 >> y1;
gen(f1, p1, h1, a1, x1, y1);
cin >> h1 >> a1 >> x1 >> y1;
gen(f2, p2, h1, a1, x1, y1);
long long c1 = f1;
long long rth = f1 % p2;
long long trs = 0;
long long r2 = f2 % p2;
long long radd = p1 % p2;
if (p2 == -1) {
swap(f1, f2);
swap(p1, p2);
}
if (p1 == -1) {
if (p2 == -1) {
if (f1 == f2)
cout << f1 << endl;
else
cout << -1 << endl;
return 0;
}
if (f1 >= f2 && (f1 - f2) % p2 == f2 % p2)
cout << f1 << endl;
else
cout << -1 << endl;
return 0;
}
while (trs < 2000009 && (c1 < f2 || rth != r2)) {
++trs;
c1 += p1;
rth += radd;
if (rth >= p2) rth -= p2;
}
if (c1 >= f2 && rth == r2)
cout << c1 << endl;
else
cout << -1 << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(const T& a) {
return a * a;
}
template <typename T>
inline int sign(const T& a) {
return a < 0 ? -1 : a > 0;
}
void task();
int main() {
ios_base::sync_with_stdio(0);
task();
return 0;
}
struct SparseTable {
int t[int(3e5) + 10][20];
int pos[int(3e5) + 10][20];
void init(int* a, int n) {
for (int i = 0; i < n; ++i) t[i][0] = a[i], pos[i][0] = i;
for (int j = 1; j < 20; ++j)
for (int i = 0; i < n; ++i) {
int next = min(i + (1 << (j - 1)), 300010 - (1 << (j - 1)));
t[i][j] = t[i][j - 1];
pos[i][j] = pos[i][j - 1];
if (t[next][j - 1] > t[i][j])
t[i][j] = t[next][j - 1], pos[i][j] = pos[next][j - 1];
}
}
int clz(int x) { return 32 - __builtin_clz(x); }
int get_max(int l, int r) {
int next = r - (1 << (clz(r - l + 1) - 1)) + 1;
return max(t[l][clz(r - l + 1) - 1], t[next][clz(r - l + 1) - 1]);
}
int get_max_pos(int l, int r) {
int next = r - (1 << (clz(r - l + 1) - 1)) + 1;
if (t[l][clz(r - l + 1) - 1] > t[next][clz(r - l + 1) - 1])
return pos[l][clz(r - l + 1) - 1];
return pos[next][clz(r - l + 1) - 1];
}
} st;
int n, k;
int a[int(3e5) + 10];
int sum[int(3e5) + 10];
vector<int> cnt[int(1e6) + 10];
vector<int> cnt2[int(1e6) + 10];
int sum2[int(3e5) + 10];
int get_sum(int l, int r) {
if (l > r) return 0;
return (sum[r] - sum[l - 1] + k) % k;
}
long long int calc(int l, int r) {
if (l >= r) return 0;
int m = st.get_max_pos(l, r);
long long int result = 0;
if (m - l < r - m) {
for (int i = l; i <= m; ++i) {
int val = (2 * k - get_sum(i, m - 1) + get_sum(1, m)) % k;
result += upper_bound((cnt[val].begin()), (cnt[val].end()), r) -
upper_bound((cnt[val].begin()), (cnt[val].end()), m);
if (i != m && get_sum(i, m - 1) == 0) ++result;
}
} else {
for (int i = m; i <= r; ++i) {
int val = (2 * k - get_sum(m + 1, i) + get_sum(m, n)) % k;
result += upper_bound((cnt2[val].begin()), (cnt2[val].end()), m - 1) -
upper_bound((cnt2[val].begin()), (cnt2[val].end()), l - 1);
if (i != m && get_sum(m + 1, i) == 0) ++result;
}
}
return result + calc(l, m - 1) + calc(m + 1, r);
}
void task() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
st.init(a, n + 1);
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + a[i], sum[i] %= k;
cnt[sum[i]].push_back(i);
}
for (int i = n; i >= 1; --i) {
sum2[i] = sum2[i + 1] + a[i];
sum2[i] %= k;
}
for (int i = 1; i <= n; ++i) cnt2[sum2[i]].push_back(i);
cout << calc(1, n);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long n;
string s1, s2;
long long precom[26][200005];
long long present[26][200005];
long long tree[26][200005];
long long sum(long long i, long long ch) {
long long sum = 0;
while (i > 0) {
sum += tree[ch][i];
i -= i & (-i);
}
return sum;
}
void update(long long i, long long val, long long ch) {
while (i < 200005) {
tree[ch][i] += val;
i += i & (-i);
}
}
void calc() {
memset(precom, 0, sizeof(precom));
memset(present, 0, sizeof(present));
for (long long i = n; i >= 1; i--)
for (long long j = 0; j < 26; j++)
precom[j][i] += precom[j][i + 1] + (s2[i] - 'A' == j ? n - i + 1 : 0);
for (long long i = 1; i <= n; i++)
for (long long j = 0; j < 26; j++)
present[j][i] = present[j][i - 1] + (s2[i] - 'A' == j);
for (long long i = 1; i <= n; i++)
for (long long j = 0; j < 26; j++) update(i, present[j][i], j);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> s1 >> s2;
s1 = '$' + s1;
s2 = "$" + s2;
long double val = 0;
long double den = n * (n + 1) * (2 * n + 1) / 6.0;
calc();
for (long long i = 1; i <= n; i++) {
long double curr = 0.0;
curr += (precom[s1[i] - 'A'][i + 1]) * i / den;
curr += (present[s1[i] - 'A'][i]) / den * i * (n - i + 1);
curr -= sum(i - 1, s1[i] - 'A') / den * (n - i + 1);
val += curr;
}
cout << fixed << setprecision(12) << val;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 11;
const long long maxn = 2e3 + 9;
const double esp = 1e-6;
long long dp[maxn][maxn];
void solve() {
long long n, h, l, r;
cin >> n >> h >> l >> r;
vector<long long> v(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> v[i];
}
fill(dp[0], dp[0] + maxn * maxn, -1);
dp[0][0] = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= h - 1; j++) {
if (dp[i - 1][j] != -1) {
long long k = (j + v[i]) % h;
if (k >= l && k <= r) {
dp[i][k] = max(dp[i][k], dp[i - 1][j] + 1);
} else {
dp[i][k] = max(dp[i][k], dp[i - 1][j]);
}
k = (j + v[i] - 1) % h;
if (k >= l && k <= r) {
dp[i][k] = max(dp[i][k], dp[i - 1][j] + 1);
} else {
dp[i][k] = max(dp[i][k], dp[i - 1][j]);
}
}
}
}
long long ans = -1;
for (long long i = 0; i <= h - 1; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
long long int res = 0, k;
cin >> n;
vector<long long int> t;
for (int i = 0; i < n; i++) {
cin >> k;
t.push_back(k);
}
for (int i = 0; i < n; i++) {
if (i - 1 >= 0) {
if (t[i - 1] * t[i] > res) {
res = t[i - 1] * t[i];
}
}
if (i + 1 < n) {
if (t[i + 1] * t[i] > res) {
res = t[i + 1] * t[i];
}
}
}
cout << res;
}
int main() {
int t, cont = 0;
cin >> t;
while (t--) {
solve();
cout << endl;
;
}
}
| 0 |
Subsets and Splits