solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
inline long long pow_mod(long long X, long long N, long long mod) {
long long res = 1;
while (N > 0) {
if (N & 1) res = res * X % mod;
X = X * X % mod;
N >>= 1;
}
return res;
}
const long long SI = 1e6 + 100;
const long long mod = 1e9 + 7;
struct node {
int k, a1, x, y, m;
vector<int> A;
} P[5005];
int n;
int sumk;
int bad;
queue<int> q[5005];
set<pair<int, int> > dif;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d%d", &P[i].k, &P[i].a1, &P[i].x, &P[i].y, &P[i].m);
sumk += P[i].k;
}
for (int j = 1; j <= n; j++) {
int temp = 0;
P[j].A.push_back(P[j].a1);
for (int i = 1; i < P[j].k; i++) {
P[j].A.push_back(int((1ll * P[j].A[i - 1] * P[j].x + (long long)P[j].y) %
(long long)P[j].m));
if (P[j].A[i] < P[j].A[i - 1]) temp++;
}
bad = max(bad, temp);
}
printf("%d\n", bad);
if (sumk > 200000) return 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < P[i].k; j++) q[i].push(P[i].A[j]);
dif.insert(pair<int, int>(P[i].a1, i));
}
int last = 0;
set<pair<int, int> >::iterator it;
while (sumk--) {
it = dif.lower_bound(pair<int, int>(last, 0));
if (it == dif.end()) it = dif.begin();
int x = it->first;
int y = it->second;
dif.erase(it);
printf("%d %d\n", x, y);
last = x;
if (q[y].empty() == false) {
dif.insert(pair<int, int>(q[y].front(), y));
q[y].pop();
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
int n, m, q, v[maxn], lp[maxn];
vector<int> e[maxn], t[maxn];
vector<long long> ps[maxn];
int mx, argmx;
void dfs(int id, int p, int d, int cpn) {
if (cpn) v[id] = cpn;
lp[id] = max(lp[id], d);
if (d > mx) {
mx = d;
argmx = id;
}
if (cpn) t[cpn].push_back(lp[id]);
for (int i = 0; i < e[id].size(); i++)
if (e[id][i] != p) dfs(e[id][i], id, d + 1, cpn);
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
int cpn = 0;
for (int i = 1; i <= n; i++)
if (!v[i]) {
mx = -1;
dfs(i, 0, 0, 0);
mx = -1;
dfs(argmx, 0, 0, 0);
mx = -1;
dfs(argmx, 0, 0, ++cpn);
sort(t[cpn].begin(), t[cpn].end());
ps[cpn].push_back(0);
for (int j = 0; j < t[cpn].size(); j++)
ps[cpn].push_back(ps[cpn].back() + t[cpn][j]);
}
map<pair<int, int>, double> res;
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d %d", &x, &y);
x = v[x];
y = v[y];
if (x == y)
printf("-1\n");
else {
if (t[x].size() > t[y].size()) swap(x, y);
if (!res.count({x, y})) {
auto ans = 0LL;
int mxd = max(t[x].back(), t[y].back());
for (int j = 0; j < t[x].size(); j++) {
int l = lower_bound(t[y].begin(), t[y].end(), mxd - 1 - t[x][j]) -
t[y].begin();
ans += 1LL * l * mxd + 1LL * (t[y].size() - l) * (t[x][j] + 1) +
ps[y].back() - ps[y][l];
}
res.insert({{x, y}, ans * 1.0 / t[x].size() / t[y].size()});
}
printf("%.10lf\n", res[{x, y}]);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long minn = INT_MAX;
long long maxx = INT_MIN;
bool ispalin(string str) {
long long l = 0;
long long h = str.size() - 1;
while (h > l) {
if (str[l++] != str[h--]) return 0;
}
return 1;
}
void isprime() {
long long n = 10000;
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true)
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
long long numberOfDigits(long long n) {
if (n == 1) return 1;
long double d = (n * log10(1.6180339887498948)) - ((log10(5)) / 2);
return ceil(d);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
long long t = 1;
while (t--) {
long long n;
cin >> n;
long long qx, qy, kx, ky, tx, ty;
cin >> qx >> qy >> kx >> ky >> tx >> ty;
if (kx < qx && ky < qy && tx < qx && ty < qy)
cout << "YES";
else if (kx > qx && ky < qy && tx > qx && ty < qy)
cout << "YES";
else if (kx < qx && ky > qy && tx < qx && ty > qy)
cout << "YES";
else if (kx > qx && ky > qy && tx > qx && ty > qy)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 0x3f3f3f3f;
struct NODE {
int id, val;
} f[maxn];
struct node {
int l, r;
int minn;
} tree[maxn << 2];
int a[maxn], b[maxn], rt[maxn], ans[maxn];
bool cmp(NODE lft, NODE rt) {
if (lft.val == rt.val) return lft.id > rt.id;
return lft.val > rt.val;
}
void push_up(int i) {
tree[i].minn = min(tree[i << 1].minn, tree[i << 1 | 1].minn);
}
void build(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
if (l == r) {
tree[i].minn = a[l] * 2;
return;
}
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
push_up(i);
}
int query(int i, int x, int y, int k) {
if (tree[i].l >= x && tree[i].r <= y) {
if (tree[i].l == tree[i].r) {
if (tree[i].minn >= k) return inf;
return tree[i].l;
}
if (tree[i].minn >= k)
return inf;
else if (tree[i << 1].minn < k)
return query(i << 1, x, y, k);
else if (tree[i << 1 | 1].minn < k)
return query(i << 1 | 1, x, y, k);
return inf;
}
int mid = (tree[i].l + tree[i].r) >> 1;
if (y <= mid)
return query(i << 1, x, y, k);
else if (x > mid)
return query(i << 1 | 1, x, y, k);
else
return min(query(i << 1, x, mid, k), query(i << 1 | 1, mid + 1, y, k));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i].val = a[i];
f[i].id = i;
}
for (int i = n + 1; i <= 2 * n; i++) a[i] = a[i % n];
a[2 * n] = a[n];
sort(f + 1, f + 1 + n, cmp);
int m = 2 * n;
stack<int> s;
for (int i = m; i >= 1; i--) {
while (!s.empty() && a[s.top()] <= a[i]) s.pop();
if (!s.empty())
rt[i] = s.top();
else
rt[i] = 0;
s.push(i);
}
build(1, 1, m);
memset(ans, inf, sizeof(ans));
for (int i = 1; i <= n; i++) {
int val = f[i].val;
int l = f[i].id, r = rt[l];
if (!r) r = l + n;
int k = query(1, l, r, val);
if (k == inf) {
if (ans[r] == inf)
ans[f[i].id] = ans[f[i].id + n] = -1;
else if (ans[r] == -1)
ans[f[i].id] = ans[f[i].id + n] = -1;
else
ans[f[i].id] = ans[f[i].id + n] = ans[r] + r - l;
} else {
ans[f[i].id] = ans[f[i].id + n] = k - l;
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 5;
int n;
int a[N][4];
string name[N];
int mx[4];
string p[] = {
"If you want to call a taxi, you should call: ",
"If you want to order a pizza, you should call: ",
"If you want to go to a cafe with a wonderful girl, you should call: "};
bool taxi(string s) {
for (int i = 0; s[i]; i++)
if (s[i] != '-' && s[i] != s[0]) return false;
return true;
}
bool pizza(string s) {
int last = 10;
for (int i = 0; s[i]; i++)
if (s[i] != '-') {
if (int(s[i] - '0') >= last) return false;
last = int(s[i] - '0');
}
return true;
}
int get(string s) { return taxi(s) ? 0 : pizza(s) ? 1 : 2; }
void solve(int testCase) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int s;
scanf("%d", &s);
cin >> name[i];
while (s--) {
string st;
cin >> st;
a[i][get(st)]++;
}
for (int f : {0, 1, 2}) mx[f] = max(mx[f], a[i][f]);
}
for (int f : {0, 1, 2}) {
printf("%s", p[f].c_str());
vector<string> ans;
for (int i = 0; i < n; i++) {
if (a[i][f] == mx[f]) ans.push_back(name[i]);
}
for (int i = 0; i < ans.size(); i++) {
printf("%s%s", ans[i].c_str(), i == ans.size() - 1 ? "." : ", ");
}
printf("\n");
}
}
int main() {
int t = 1;
for (int testCase = 1; testCase <= t; testCase++) {
solve(testCase);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MOD = 1000000007;
const int N = 100005;
int now;
int id = 0;
string in;
struct ct {
int id;
int layer;
string s;
vector<int> next;
int cnt;
};
vector<ct> vvv;
ct rt;
vector<int> fr;
int dr = 0;
void cons(int layer) {
string s;
while (in[now] != ',') s += in[now++];
now++;
int tmp = 0;
while (in[now] != ',') {
tmp *= 10;
tmp += in[now++] - '0';
}
now++;
ct c;
c.layer = layer;
c.cnt = tmp;
c.s = s;
c.id = ++id;
vvv.push_back(c);
}
void dfs(int rt) {
dr = max(dr, vvv[rt].layer);
for (int i = 0; i < vvv[rt].cnt; i++) {
cons(vvv[rt].layer + 1);
vvv[rt].next.push_back(id);
dfs(id);
}
}
queue<int> fq;
void bfs() {
int now_layer = 1;
while (!fq.empty()) {
int tmp = fq.front();
fq.pop();
if (now_layer != vvv[tmp].layer) {
now_layer = vvv[tmp].layer;
cout << endl;
}
cout << vvv[tmp].s << ' ';
for (int i = 0; i < vvv[tmp].next.size(); i++) {
fq.push(vvv[tmp].next[i]);
}
}
}
int main() {
cin >> in;
in += ',';
string s;
ct ttt;
vvv.push_back(ttt);
while (now < in.length()) {
cons(1);
fq.push(id);
dfs(id);
}
printf("%d\n", dr);
bfs();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string wire;
cin >> wire;
wire += ".";
char now = 'A';
int begin = 0;
bool flag = true;
std::string::size_type p;
int len = wire.length();
while (flag) {
for (int i = 0; i < wire.length(); i++) {
flag = false;
if (wire[i] != now) {
if (i - begin > 1) {
i = ((i - begin) % 2 == 0) ? (i) : (i - 1);
wire.erase(wire.begin() + begin, wire.begin() + i);
i = begin - 1;
flag = true;
}
begin = i;
now = wire[i];
}
}
}
if (wire[0] != '.')
cout << "No";
else
cout << "Yes";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 1;
const int mod = 1e9 + 7;
void slv() {
int64_t n;
cin >> n;
map<int64_t, int64_t> a;
long double ans = 0, sum = 0;
for (int64_t i = 0; i < n; i++) {
int64_t t;
cin >> t;
sum += t;
++a[t];
ans += (i - a[t] - a[t - 1] - a[t + 1] + 1) * t -
(sum - a[t] * t - a[t - 1] * (t - 1) - a[t + 1] * (t + 1));
}
cout << fixed << setprecision(0) << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
slv();
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[300300];
const int MOD = 1000000007;
int pwr(int base, int pw) {
int res = 1;
while (pw) {
if (pw & 1) res = (res * 1LL * base) % MOD;
base = (base * 1LL * base) % MOD;
pw >>= 1;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
sort(arr, arr + n);
int out = 0;
for (int i = 0; i < n; ++i) {
out -= (arr[i] * 1LL * (pwr(2, n - 1 - i) - 1)) % MOD;
if (out < 0) out += MOD;
out += (arr[i] * 1LL * (pwr(2, i) - 1)) % MOD;
if (out >= MOD) out -= MOD;
}
printf("%d\n", out);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, ans;
int main() {
cin >> n;
x = n * 6;
ans = (x / 2) * (n + 1);
cout << ans + 1 << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
int t,n,q,l,r;
cin>>t;
while(t--)
{
cin>>n>>q;
cin>>s;
for(int i=0;i<q;i++)
{
cin>>l>>r;
l--;r--;
int flag=0;
for(int j=0;j<l;j++)
{
if(s[j]==s[l])
flag=1;
}
for(int j=n-1;j>r;j--)
{
if(s[j]==s[r]) flag=1;
}
if(flag) cout<<"YES\n";
else cout<<"NO\n";
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int main() {
int n;
scanf("%d", &n);
long long l, r, d;
for (int i = 1; i <= n; i++) {
cin >> l >> r >> d;
if (d < l)
printf("%I64d\n", d);
else if (r / d * d > r)
printf("%I64d\n", r / d * d);
else
printf("%I64d\n", (r / d + 1) * d);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int s, n;
cin >> s >> n;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
for (auto u : v) {
if (s > u.first) {
s += u.second;
} else {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long t;
long long n;
long long a[100001];
signed main() {
cin >> t;
for (long long i = 1; i <= t; i++) {
cin >> n;
for (long long j = 1; j <= n; j++) {
cin >> a[j];
}
sort(a + 1, a + 1 + n);
long long ok = 1;
for (long long j = n; j >= 1; j--) {
if (j >= a[j]) {
cout << j + 1 << endl;
ok = 0;
break;
}
}
if (ok == 1) {
cout << 1 << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, r;
while (cin >> k >> r) {
if (k < 0 || r <= 0) continue;
for (int n = 1;; n++) {
if (k * n % 10 == 0) {
cout << n << endl;
break;
}
if ((k * n - r) % 10 == 0) {
cout << n << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
int ar[1000010];
int main() {
long long int n = lxt();
for (long long int i = 1; i; i++) {
long long int sum = 1LL << i;
if (sum > n) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string reversed(string s) {
string res = "";
for (auto it = s.end() - 1; it >= s.begin(); it--) {
res += *it;
if (it == s.begin()) break;
}
return res;
}
bool isPal(string s) {
auto l = s.begin(), r = s.end() - 1;
while (*l == *r && l < r) {
l++;
r--;
}
if (l < r)
return false;
else
return true;
}
int main() {
int n, m;
cin >> n >> m;
vector<string> v(n);
vector<bool> used(n, false);
vector<int> pairs(n);
string maxPL = "";
vector<int> st;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
string s = v[i];
if (used[i]) continue;
auto revit = find(v.begin() + i + 1, v.end(), reversed(s));
if (revit != v.end() && revit != v.begin() + i) {
pairs[i] = revit - v.begin();
st.push_back(i);
used[i] = true;
used[pairs[i]] = true;
} else {
if (isPal(s)) maxPL = s;
}
}
string res = "";
for (int i = 0; i < st.size(); i++) {
res += v[st[i]];
st[i] = pairs[st[i]];
}
res += maxPL;
for (int i = st.size() - 1; i >= 0; i--) {
res += v[st[i]];
}
cout << res.length() << endl;
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int f[N * 2 + 10];
void init(int n) {
for (int i = 1; i <= n; i++) f[i] = i;
}
int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
init(n + m);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
f[getf(y + n)] = getf(x);
}
int ans = -1;
for (int i = 1; i <= n + m; i++) ans += f[i] == i;
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool p[400400];
vector<int> v;
int main() {
for (long long int i = 2; i <= 400000; i++) {
if (p[i] == 0)
for (long long int j = i; j * i <= 400000; j++) p[i * j] = 1;
}
for (int i = 2; i <= 400000; i++) {
if (p[i] == 0) v.push_back(i);
}
int n;
scanf("%d", &n);
int one = 0, two = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 1)
one++;
else
two++;
}
int sum = 0;
for (int i = 0; i < v.size(); i++) {
int bb = v[i] - sum;
if (two * 2 + one < bb) {
break;
}
int mn = bb / 2;
mn = min(mn, two);
bb -= mn * 2;
two -= mn;
for (int j = 1; j <= mn; j++) cout << 2 << " ";
int mm = min(bb, one);
one -= mm;
bb -= mm;
for (int j = 1; j <= mm; j++) cout << 1 << " ";
sum = v[i];
}
for (int i = 1; i <= one; i++) cout << "1 ";
for (int i = 1; i <= two; i++) cout << "2 ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000];
bool flag = true;
void makeearliest(int &n, int &early) {
char a[4], b[4];
b[3] = n % 10;
b[2] = (n / 10) % 10;
b[1] = (n / 100) % 10;
b[0] = (n / 1000) % 10;
for (int i = early; i <= 2011; i++) {
a[3] = i % 10;
a[2] = (i / 10) % 10;
a[1] = (i / 100) % 10;
a[0] = (i / 1000) % 10;
int cnt = 0;
for (int j = 0; j < 4; j++)
if (a[j] != b[j]) cnt++;
if (cnt < 2) {
n = early = i;
return;
}
}
flag = false;
}
int main() {
int N;
scanf("%d", &N);
int earliest = 1000;
for (int i = 0; i < N; i++) {
scanf("%d", arr + i);
if (flag) makeearliest(arr[i], earliest);
}
if (flag)
for (int i = 0; i < N; i++) printf("%d\n", arr[i]);
else
printf("No solution\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
vector<int> pool, ans;
for (int i = 0; i < n; i++) {
if ((1 << i) == (x & (-x)) && (1 << n) > x) continue;
pool.push_back(1 << i);
}
for (int i = 0; i < (int)pool.size(); i++) {
vector<int> tmp = ans;
ans.push_back(pool[i]);
for (auto &v : tmp) ans.push_back(v);
}
cout << ans.size() << '\n';
for (int i = 0; i < (int)ans.size(); i++)
cout << ans[i] << " \n"[i == (int)ans.size() - 1];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
std::vector<long long> v(1e5 + 7);
for (long long i = 0; i < 1e5 + 7; i++) {
v[i] = (i + 1) * (i + 2) / 2;
}
int flag = 0;
for (long long i = 0; i < 1e5 + 7; i++) {
if (binary_search(v.begin(), v.end(), n - v[i])) {
flag = 1;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000 * 5 + 10, D = 1000 * 1000 * 1000 + 7;
int n, m, mark[MAX], d[MAX][MAX];
vector<pair<int, int> > a;
long long dis(long long x, long long y) {
return abs(a[x].first - a[y].first) + abs(a[x].second - a[y].second);
}
bool dfs(int v, int color) {
if (mark[v] != -1) return !(color == mark[v]);
mark[v] = color;
for (long long i = (int)0; i < (int)n; i++)
if (d[v][i] > m and dfs(i, (color + 1) % 2)) return true;
return false;
}
long long BS(long long s, long long e) {
if (s + 1 == e) return e;
m = (s + e) / 2;
fill(mark, mark + n, -1);
for (long long i = (int)0; i < (int)n; i++)
if (mark[i] == -1)
if (dfs(i, 0)) return BS(m, e);
return BS(s, m);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
int maxi = 0;
for (long long i = (int)0; i < (int)n; i++) {
int x, y;
cin >> x >> y;
a.push_back(make_pair(x, y));
for (long long j = (int)0; j < (int)i + 1; j++) {
d[j][i] = d[i][j] = dis(i, j);
maxi = max(maxi, d[i][j]);
}
}
int ans = BS(-1, maxi + 1);
cout << ans << endl;
long long com = 1;
m = ans;
fill(mark, mark + n, -1);
for (long long i = (int)0; i < (int)n; i++) {
if (mark[i] == -1) {
dfs(i, 0);
com = (com * 2) % D;
}
}
cout << com << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200110;
int cnt[maxn];
int n, k, a, b, q;
int suma[maxn];
int sumb[maxn];
int lowbit(int x) { return x & (-x); }
void init() {
memset(suma, 0, sizeof(suma));
memset(sumb, 0, sizeof(sumb));
memset(cnt, 0, sizeof(cnt));
}
int sum(int i, int bit[]) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= lowbit(i);
}
return s;
}
void add(int i, int x, int bit[]) {
while (i <= n) {
bit[i] += x;
i += lowbit(i);
}
}
int main() {
init();
int t, y, z;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; ++i) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &y, &z);
add(y, -min(cnt[y], a), suma);
add(y, -min(cnt[y], b), sumb);
cnt[y] += z;
add(y, min(cnt[y], a), suma);
add(y, min(cnt[y], b), sumb);
} else {
scanf("%d", &y);
printf("%d\n", sum(y - 1, sumb) + sum(n, suma) - sum(y + k - 1, suma));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int x[26] = {0};
getline(cin, s);
for (int i = 1; i < s.length() - 1; i++) {
if (s[i] - 97 >= 0 && s[i] - 97 < 26) x[s[i] - 97]++;
}
int ans = 0;
for (int i = 0; i < 26; i++)
if (x[i] > 0) ans++;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, x, a, b;
cin >> n >> x >> a >> b;
cout << min(n - 1, abs(a - b) + x) << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[110];
int main() {
int n, num = 0;
cin >> n >> s;
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'U' && s[i + 1] == 'R' || s[i] == 'R' && s[i + 1] == 'U') {
s[i] = 'X', s[i + 1] = 'X';
num++;
}
}
cout << n - num << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 28;
const long long LINF = 1ll << 61;
long long n, m, k, x, y, cnt[111][111];
int main() {
cin >> n >> m >> k >> x >> y;
if (n == 1) {
if (k % m == 0)
cout << k / m << " " << k / m << " " << k / m << endl;
else
cout << k / m + 1 << " " << k / m << " " << k / m + (y <= (k - 1) % m + 1)
<< endl;
} else {
long long times = k / ((2 * n - 2) * m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i == 1 || i == n)
cnt[i][j] = times;
else
cnt[i][j] = times * 2;
}
long long tx = 1, ty = 1;
k -= times * (2 * n - 2) * m;
int dir = 1;
while (k--) {
cnt[tx][ty]++;
if (ty < m)
ty++;
else if (ty == m) {
ty = 1;
if (tx == 1)
tx++, dir = 1;
else if (tx == n)
tx--, dir = -1;
else
tx += dir;
}
}
long long mn = cnt[1][1], mx = mn;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
mn = min(mn, cnt[i][j]);
mx = max(mx, cnt[i][j]);
}
cout << mx << " " << mn << " " << cnt[x][y] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 110000;
int n, k, p;
vector<int> g[maxN];
bool used[maxN];
vector<int> d;
long long s[maxN];
void dfs(int v, int depth = 0) {
used[v] = true;
if (depth > 0) {
d.push_back(depth);
}
for (int i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i]]) {
dfs(g[v][i], depth + 1);
}
}
}
bool check(int cnt) {
for (int i = cnt - 1; i < d.size(); ++i) {
long long total = s[i] - ((i - cnt) < 0 ? 0 : s[i - cnt]);
long long needed = (long long)(cnt) * (long long)(d[i]) - total;
if (needed <= (long long)(p)) {
return true;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
sort(d.begin(), d.end());
s[0] = d[0];
for (int i = 1; i < d.size(); ++i) {
s[i] = d[i];
s[i] += s[i - 1];
}
int l = 0, r = min(n - 1, k);
while (r - l > 1) {
int m = (l + r) / 2;
if (check(m)) {
l = m;
} else {
r = m;
}
}
int res = l;
if (check(r)) {
res = r;
}
printf("%d\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s[300005];
long long v[300004][2];
bool isregular(string a, int x, int y) {
int p = 0;
for (int i = x; i < y; i++) {
if (a[i] == '(')
p++;
else if (a[i] == ')' && p > 0)
p--;
else
return false;
}
if (p == 0)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
long long r = 0, f = 0, d = 0;
for (int i = 0; i < n; i++) {
if (isregular(s[i], 0, s[i].size()))
r++;
else {
long long p = 0, q = 0;
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] == '(')
p++;
else
q++;
}
if (p > q) {
int op = 0;
int flag = 0;
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] == '(')
op++;
else if (s[i][j] == ')' && op > 0) {
op--;
} else {
flag = 1;
break;
}
}
if (flag == 0) v[op][0]++;
} else if (p < q) {
int op2 = 0;
int op = 0;
int flag = 0;
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] == '(')
op++;
else if (s[i][j] == ')' && op > 0) {
op--;
} else if (s[i][j] == ')') {
op2++;
}
}
if (flag == 0 && op == 0) v[op2][1]++;
}
}
}
long long ans = 0;
for (int i = 0; i < 300001; i++) {
ans += v[i][0] * v[i][1];
}
ans += r * r;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n, m, k;
cin>>n>>m>>k;
vector<vector<int>> edges;
for(int i=0; i<n; i++) {
for(int j=0; j<m-1; j++) {
int x;
cin>>x;
edges.push_back({x, i, j, i, j+1});
}
}
for(int i=0; i<n-1; i++) {
for(int j=0; j<m; j++) {
int x;
cin>>x;
edges.push_back({x, i, j, i+1, j});
}
}
if(k&1) {
for(int i=0; i<n; i++) {
for(int j=0; j<m; j++) {
cout<<-1<<" ";
}
cout<<endl;
}
return;
}
sort(edges.begin(), edges.end());
vector<vector<int>> ans(n, vector<int> (m));
k/=2;
while(k--) {
vector<vector<int>> update(n, vector<int> (m, 1e9));
for(auto e : edges) {
int w=e[0], x1=e[1], y1=e[2], x2=e[3], y2=e[4];
update[x1][y1]=min(update[x1][y1], ans[x1][y1]+2*w);
update[x1][y1]=min(update[x1][y1], ans[x2][y2]+2*w);
update[x2][y2]=min(update[x2][y2], ans[x1][y1]+2*w);
update[x2][y2]=min(update[x2][y2], ans[x2][y2]+2*w);
}
ans=update;
}
for(auto &i : ans) {
for(auto &j : i) {
cout<<j<<" ";
}
cout<<endl;
}
return;
}
int main() {
#ifdef bipinpathak
(void)!freopen("input.txt", "r", stdin);
(void)!freopen("output.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
auto start=clock();
int t = 1;
for(int i=0; i<t; i++) {
//cout<<"Case #"<<i+1<<": ";
solve();
}
double used= (double) (clock()-start);
used=(used*1000)/CLOCKS_PER_SEC;
cerr<<fixed<<setprecision(2)<<used<<" ms"<<endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void resize(int n, vector<T> &u) {
u.resize(n);
}
template <typename Head, typename... Tail>
void resize(int n, Head &H, Tail &...T) {
resize(n, H);
resize(n, T...);
}
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> &u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> &t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << ", ";
}
}
template <typename T>
void debug_out(vector<vector<T>> &t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << endl;
}
}
vector<char> lowchar = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
vector<char> hichar = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
vector<char> base_10 = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
template <typename T>
string to_string(T t) {
string res;
while (t) {
res += base_10[t % 10];
t /= 10;
}
return res;
}
long long to_num(string t) {
long long res = 0;
for (int i = 0; i < (int)t.length(); i++) {
res *= 10;
res += t[i] - '0';
}
return res;
}
int n;
vector<char> al;
char A = 'A';
int power[5];
string ord[1000005];
string adv(string s) {
int m = s.length();
for (int i = m - 1; ~i; i--) {
if (s[i] == 'Z') continue;
int cur = s[i] - '0' - 17;
cur++;
s[i] = al[cur];
for (int j = i + 1; j < m; j++) s[j] = 'A';
return s;
}
char a = 'A';
s.clear();
for (int i = 0; i <= m; i++) s += a;
return s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
power[0] = 1;
for (int i = 1; i < 5; i++) power[i] = power[i - 1] * 26;
for (int i = 0; i < 26; i++) al.push_back(A++);
ord[1] = "A";
for (int i = 2; i <= 1e6 + 4; i++) ord[i] = adv(ord[i - 1]);
cin >> n;
while (n--) {
string s;
cin >> s;
bool type = false, num = false;
string fir, sec;
string row, col;
for (int i = 0; i < s.length(); i++) {
if ('A' <= s[i] && s[i] <= 'Z') {
if (num) {
type = true;
sec += s[i];
} else
fir += s[i];
} else {
num = true;
if (sec.length())
col += s[i];
else
row += s[i];
}
}
if (!type) {
int res = 0;
reverse(fir.begin(), fir.end());
while (fir.length()) {
res *= 26;
res += fir.back() - '0' - 16;
fir.pop_back();
}
string ans = "R";
ans += row;
ans += 'C';
ans += to_string(res);
cout << ans << endl;
;
} else {
int cur = to_num(col);
string res = ord[cur];
res += row;
cout << res << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
char s[5000];
char s1[5] = "bear";
int b[5000] = {0};
int i, j, k, len, t, n = 0;
long long int sum = 0;
scanf("%s", s);
len = strlen(s);
for (i = 0; i < len - 3; i++) {
if (s[i] == 'b') {
bool t = true;
for (j = 1; j < 4; j++)
if (s[i + j] != s1[j]) t = false;
if (t) {
b[n] = i;
n++;
}
}
}
sum = (b[0] + 1) * (len - b[0] - 3);
for (i = 1; i < n; i++) {
sum += (b[i] - b[i - 1]) * (len - b[i] - 3);
}
if (n == 0) sum = 0;
printf("%I64d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int N = 200010;
int n, m, p, x;
int a[N];
map<int, int> mp_b, mp_q[N];
set<int> st[N];
vector<int> ans;
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) {
scanf("%d", &x);
mp_b[x]++;
}
for (int i = 0; i < p && i + 1LL * (m - 1) * p < 1LL * n; ++i) {
for (int j = 0; j < m; ++j) {
int pos = i + j * p;
mp_q[i][a[pos]]++;
}
bool flag = true;
for (map<int, int>::iterator it = mp_q[i].begin(); it != mp_q[i].end();
++it) {
if (mp_b.find((*it).first) == mp_b.end() ||
mp_b[(*it).first] != (*it).second) {
flag = false;
st[i].insert((*it).first);
}
}
if (flag) ans.push_back(i);
}
for (int i = p; i + 1LL * (m - 1) * p < 1LL * n; ++i) {
int pos = i - p;
if (mp_q[i % p][a[pos]] == 1) {
mp_q[i % p].erase(a[pos]);
if (mp_b.find(a[pos]) != mp_b.end())
st[i % p].insert(a[pos]);
else
st[i % p].erase(a[pos]);
} else {
mp_q[i % p][a[pos]]--;
if (mp_b.find(a[pos]) != mp_b.end()) {
if (mp_q[i % p][a[pos]] != mp_b[a[pos]]) st[i % p].insert(a[pos]);
if (mp_q[i % p][a[pos]] == mp_b[a[pos]]) st[i % p].erase(a[pos]);
}
}
pos = i + (m - 1) * p;
mp_q[i % p][a[pos]]++;
if (mp_b.find(a[pos]) == mp_b.end() ||
mp_b[a[pos]] != mp_q[i % p][a[pos]]) {
st[i % p].insert(a[pos]);
}
if (mp_b.find(a[pos]) != mp_b.end() &&
mp_b[a[pos]] == mp_q[i % p][a[pos]]) {
st[i % p].erase(a[pos]);
}
if (st[i % p].empty()) ans.push_back(i);
}
printf("%d\n", (int)(ans).size());
for (int i = 0; i < (int)(ans).size(); ++i) printf("%d ", ans[i] + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;
int a[maxn];
int b[maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
b[x]++;
}
int ans = m;
for (int j = 1; j <= n; j++) {
ans = min(ans, b[j]);
}
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
int brojZaPal[512][512];
int sol[512][512];
int prev[512][512];
bool postoji[512][512];
char s[512];
int o;
int res, solK;
char solution[1024];
int starting;
int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%s", &s);
scanf("%d", &starting);
for (int i = 0; i < strlen(s); i++) {
for (int j = i; j < strlen(s); j++) {
o = 0;
for (int k = i; k <= (i + j) / 2; k++) {
if (s[k] != s[j + i - k]) {
o++;
}
}
brojZaPal[i][j] = o;
}
}
for (int i = 0; i < strlen(s); i++) {
sol[1][i] = brojZaPal[0][i];
postoji[1][i] = true;
prev[1][i] = -1;
for (int j = 1; j <= i; j++) {
for (int k = 2; k <= 500; k++) {
if (postoji[k - 1][j - 1]) {
if (postoji[k][i]) {
sol[k][i] = min(brojZaPal[j][i] + sol[k - 1][j - 1], sol[k][i]);
if (sol[k][i] == brojZaPal[j][i] + sol[k - 1][j - 1]) {
prev[k][i] = j - 1;
}
} else {
sol[k][i] = brojZaPal[j][i] + sol[k - 1][j - 1];
postoji[k][i] = true;
prev[k][i] = j - 1;
}
}
}
}
}
res = strlen(s);
solK = res;
for (int i = 1; i <= starting; i++) {
if (postoji[i][strlen(s) - 1]) {
if (sol[i][strlen(s) - 1] < res) {
res = sol[i][strlen(s) - 1];
solK = i;
}
}
}
printf("%d\n", res);
int position = strlen(s) - 1;
int place = 0;
int mem;
int currNum = solK;
int previous;
while (position >= 0) {
mem = prev[currNum][position];
previous = position;
while (position > mem) {
if (position > (previous + mem) / 2) {
solution[place] = s[mem + 1 + (previous - position)];
} else {
solution[place] = s[position];
}
position--;
place++;
}
currNum--;
position = mem;
solution[place] = '+';
place++;
}
for (int i = place - 2; i >= 0; i--) {
printf("%c", solution[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
int n, a, b, k;
scanf("%d%d%d%d", &n, &a, &b, &k);
int tot = 0;
cin >> s;
int prev = -1;
for (int i = 0; i < n; i++)
if (s[i] == '1') {
tot += (i - prev - 1) / b;
prev = i;
}
tot += (n - prev - 1) / b;
int ans = tot - a + 1;
printf("%d\n", ans);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
cnt = 0;
} else {
cnt++;
}
if (cnt == b && ans) {
ans--;
printf("%d ", i + 1);
cnt = 0;
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[71][71][36][71];
long long n, m, k;
long long tocal(long long num) {
if (num % k != 0)
return -1e9;
else
return 0;
}
long long vals[71][71];
long long calc(long long i, long long j, long long take, long long has) {
if (i >= n) {
return tocal(has);
}
if (j == m || take >= m / 2) {
long long num = -1e9;
if (has == 0) num = 0;
return max(calc(i + 1, 0, 0, has), num);
}
if (dp[i][j][take][has] != -1) {
return dp[i][j][take][has];
}
long long ret = -1e9;
if (has == 0) ret = 0;
if (take < m / 2)
ret =
max(ret, calc(i, j + 1, take + 1, (has + vals[i][j]) % k) + vals[i][j]);
ret = max(calc(i, j + 1, take, has), ret);
return dp[i][j][take][has] = ret;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> vals[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << calc(0, 0, 0, 0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
struct edge {
int v, nxt;
edge(int v_ = 0, int nxt_ = 0) {
v = v_;
nxt = nxt_;
}
} e[MAXN * 2];
int f[MAXN][2], num, head[MAXN], pos[MAXN], ans, d;
void add_edge(int u, int v) {
e[++num] = edge(v, head[u]);
head[u] = num;
e[++num] = edge(u, head[v]);
head[v] = num;
}
void dfs(int u, int fa) {
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
if (f[u][0] <= f[v][0] + 1) {
f[u][1] = f[u][0];
f[u][0] = f[v][0] + 1;
pos[u] = v;
} else if (f[u][1] <= f[v][0] + 1)
f[u][1] = f[v][0] + 1;
}
}
void redfs(int u, int fa, int up) {
if (f[u][0] <= d && up <= d) ans++;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (v == pos[u])
redfs(v, u, max(f[u][1] + 1, up + 1));
else
redfs(v, u, max(f[u][0] + 1, up + 1));
}
}
int main() {
memset(head, -1, sizeof(head));
int n, m;
scanf("%d%d%d", &n, &m, &d);
for (int i = 1; i <= n; i++) {
f[i][0] = -0x7f7f7f7f;
f[i][1] = -0x7f7f7f7f;
}
for (int i = 1; i <= m; i++) {
int id;
scanf("%d", &id);
f[id][0] = 0;
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
}
dfs(1, -1);
redfs(1, -1, -0x7f7f7f7f);
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 0, ch = getchar();
while ('0' > ch || ch > '9') f ^= ch == '-', ch = getchar();
while ('0' <= ch && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ '0'), ch = getchar();
return f ? -x : x;
}
int n, a[1010];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
for (int i = 1; i <= (n >> 1); i++) printf("%d %d ", a[i], a[n - i + 1]);
n & 1 ? printf("%d\n", a[n / 2 + 1]) : puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100000 + 5];
int main() {
int n, k;
cin >> n >> k;
int m = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x != 0) a[++m] = x;
}
sort(a + 1, a + m + 1);
int s = 0;
for (int i = 1; i <= m; i++) {
a[i] -= s;
if (k == 0) break;
if (a[i] != 0) {
cout << a[i] << "\n";
s += a[i];
k--;
}
}
for (int i = 1; i <= k; i++) cout << 0 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int done[1001][1001];
int color[1001][1001];
int qu[1000000][2];
using namespace std;
int main() {
int k;
int pos[8][2] = {{1, 2}, {-1, 2}, {1, -2}, {-1, -2},
{2, 1}, {2, -1}, {-2, 1}, {-2, -1}};
int front, rear;
int x, y;
int i, j;
int n, m;
int z, o;
int test;
int ans = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) done[i][j] = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (done[i][j] == 0) {
done[i][j] = 1;
color[i][j] = 0;
front = 0;
rear = 0;
qu[rear][0] = i;
qu[rear][1] = j;
z = 1;
o = 0;
while (front <= rear) {
x = qu[front][0];
y = qu[front][1];
front++;
for (k = 0; k < 8; k++) {
if (x + pos[k][0] >= 1 && x + pos[k][0] <= n &&
y + pos[k][1] >= 1 && y + pos[k][1] <= m) {
if (done[x + pos[k][0]][y + pos[k][1]] == 0) {
rear++;
done[x + pos[k][0]][y + pos[k][1]] = 1;
color[x + pos[k][0]][y + pos[k][1]] = 1 - color[x][y];
qu[rear][0] = x + pos[k][0];
qu[rear][1] = y + pos[k][1];
if (color[x][y] == 0)
o++;
else
z++;
} else if (color[x][y] == color[x + pos[k][0]][y + pos[k][1]]) {
cout << "wrong" << endl;
exit(0);
}
}
}
}
ans = ans + max(o, z);
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, t;
cin >> n >> t;
vector<pair<int, pair<int, int>>> a(n);
bool run = false;
for (long long i = 0; i < (long long)n; i++) {
cin >> a[i].second.first >> a[i].first;
if (a[i].first <= t) {
run = true;
}
a[i].second.second = i;
}
if (!run) {
cout << 0 << endl << 0;
return 0;
}
int l = 1;
int r = n + 1;
while (r - l > 1) {
int mid = (r + l) / 2;
multiset<pair<int, pair<int, int>>> q;
for (long long i = 0; i < (long long)a.size(); i++) {
q.insert(a[i]);
}
int k = 0;
int time = 0;
bool b = true;
while (!q.empty() && k < mid) {
if (q.begin()->second.first >= mid) {
time += q.begin()->first;
k++;
if (time > t) {
b = false;
break;
}
}
if (k == mid) {
break;
}
q.erase(q.begin());
}
if (k == mid && b) {
l = mid;
} else {
r = mid;
}
}
cout << l << endl << l << endl;
multiset<pair<int, pair<int, int>>> q;
for (long long i = 0; i < (long long)a.size(); i++) {
q.insert(a[i]);
}
int k = 0;
int mid = l;
while (!q.empty() && k < mid) {
if (q.begin()->second.first >= mid) {
cout << q.begin()->second.second + 1 << " ";
k++;
}
if (k == mid) {
break;
}
q.erase(q.begin());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const int N = 500000;
int E[N], X[N], R[N], D[N];
int u[N], v[N];
bool b[N];
int i, m, n, t, w, x, y, S_E;
inline void A_E(int x, int y) {
S_E++, E[S_E] = y, X[S_E] = R[x], R[x] = S_E, D[x]++;
return;
}
inline int O_E(int x) { return ((x - 1) ^ 1) + 1; }
inline void dfs(int x) {
for (int i = R[x]; R[x] = X[i], i != 0; i = R[x])
if (!b[i]) {
b[i] = true, b[O_E(i)] = true;
dfs(E[i]);
w++, u[w] = x, v[w] = E[i];
}
return;
}
int main() {
n = read(), m = read();
for (i = 1; i <= m; i++) {
x = read(), y = read();
A_E(x, y), A_E(y, x);
}
for (i = 1; i <= n; i++)
if (D[i] & 1)
if (t)
m++, A_E(i, t), A_E(t, i), t = 0;
else
t = i;
if (m & 1) m++, A_E(1, 1), A_E(1, 1);
writeln(m);
dfs(1);
for (i = w; i > 0; i--)
if (!(i & 1))
printf("%d %d\n", u[i], v[i]);
else
printf("%d %d\n", v[i], u[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char s[40][40];
char r[40], h[40];
int cnt[40];
int n, m, ans;
void reset() {
memset(s, 0, sizeof s);
memset(h, 0, sizeof h);
memset(r, 0, sizeof r);
memset(cnt, 0, sizeof cnt);
}
void permutation(int j) {
int i, c, ans, sum = 0, k;
sort(r, r + n);
do {
for (i = 0; i < n; i++) {
if (r[i] == '1') {
h[i] = s[j][i];
} else {
if (s[j][i] == '1') {
h[i] = '0';
} else
h[i] = '1';
}
}
ans = 1;
for (i = 0; i < m; i++) {
c = 0;
if (i == j) continue;
for (k = 0; k < n; k++) {
if (s[i][k] == h[k]) c++;
}
if (c != cnt[i]) {
ans = 0;
break;
}
}
sum += ans;
} while (next_permutation(r, r + n));
printf("%d\n", sum);
}
int main() {
int i, j = 0;
scanf("%d%d", &n, &m);
reset();
for (i = 0; i < m; i++) {
cin >> s[i] >> cnt[i];
if (j < cnt[i]) j = i;
}
for (i = 0; i < cnt[j]; i++) {
r[i] = '1';
}
while (i < n) {
r[i] = '0';
i++;
}
permutation(j);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int a, i;
int m[10];
scanf("%d %d %d %d %d", &m[0], &m[1], &m[2], &m[3], &m[4]);
i = m[0] + m[1] + m[2] + m[3] + m[4];
if (i == 0)
printf("%d", -1);
else if (i % 5 == 0)
printf("%d", i / 5);
else
printf("%d", -1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m;
char str[(21)][(21)];
int a[(21)][(21)], dp[1 << (21)], logdown[1 << ((21) + 1)];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", str[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
for (int i = 2; i < 1 << ((21) + 1); ++i) {
logdown[i] = logdown[i >> 1] + 1;
}
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int mask = 0; mask < (1 << n) - 1; ++mask) {
int sit = logdown[((~mask) & (-(~mask)))];
for (int j = 0; j < m; ++j) {
if (sit < n) {
dp[mask ^ (1 << sit)] =
std::min(dp[mask ^ (1 << sit)], dp[mask] + a[sit][j]);
}
int sum = 0, mxx = INT_MIN, _mask = mask;
for (int i = 0; i < n; ++i) {
if (str[i][j] == str[sit][j]) {
sum += a[i][j];
mxx = std::max(mxx, a[i][j]);
_mask |= 1 << i;
}
}
dp[_mask] = std::min(dp[_mask], dp[mask] + sum - mxx);
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
const int maxm = 1010;
double dp[2][maxn * maxm];
double sum[2][maxn * maxm];
int x[maxn];
int n, m;
int main() {
scanf("%d%d", &n, &m);
int tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
tot += x[i];
}
if (m == 1) {
printf("1.000000000000\n");
return 0;
}
double p = 1 / ((m - 1) * 1.0);
for (int i = 1; i <= m; i++) {
if (i == x[1])
dp[1][i] = 0;
else
dp[1][i] = p;
}
sum[1][0] = 0;
for (int j = 1; j <= 2 * m; j++) sum[1][j] = sum[1][j - 1] + dp[1][j];
for (int i = 2; i <= n; i++) {
int now = i & 1;
int last = now ^ 1;
memset(dp[now], 0, sizeof(dp[now]));
for (int j = i; j <= i * m; j++) {
dp[now][j] = sum[last][j - 1] - sum[last][max(j - m - 1, 0)];
if (j - x[i] >= 0) dp[now][j] -= dp[last][j - x[i]];
dp[now][j] *= p;
}
sum[now][0] = 0;
for (int j = 1; j <= (i + 1) * m; j++)
sum[now][j] = sum[now][j - 1] + dp[now][j];
}
double ans = 0;
for (int i = n; i < tot; i++) {
ans += dp[n & 1][i];
}
ans = ans * (m - 1) + 1;
printf("%.12lf\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-11;
int n, m, s;
int first, second;
signed long long ans = 0;
signed long long f(int first, int second, int s) {
if (first * second == s)
return 2 * (first / 2 + 1) * (second / 2 + 1) - 1;
else if (first * second < s)
return 0;
int ss = (first * second - s) / 4;
signed long long ans = 0;
for (int i = 1; i <= first / 2; i++)
if ((ss % i == 0) && (ss / i > 0) && (ss / i <= second / 2) &&
(ss * 4 + s == first * second)) {
ans += 2;
}
return ans;
}
int main() {
cin >> n >> m >> s;
if (s % 2 == 0) {
cout << 0;
return 0;
}
for (int first = 1; first <= n; first += 2)
for (int second = 1; second <= m; second += 2) {
ans += f(first, second, s) * (n - first + 1) * (m - second + 1);
}
cout << ans;
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long int ull;
#define pii pair<ll,ll>
#define vi vector<ll>
#define vii vector<pii>
#define endl "\n"
#define pb push_back
#define sq(a) ((a)*(a))
#define sz(x) (ll)(x).size()
#define all(x) (x).begin(), (x).end()
#define rall(a) (a).rbegin(),(a).rend()
#define x first
#define y second
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugv(v) cerr<<#v<<" : "; for(auto x:v) cerr<<x<<' '; cerr<<endl;
#define output(x) cout<<(x ? "YES" : "NO")<<endl;
#define Output(x) cout<<(x ? "Yes" : "No")<<endl;
#define MOD (1000000007)
#define MOD2 (998244353)
#define PI acos(-1)
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll exp(ll x,ll n,ll mod)
{
ll result=1;
while(n)
{
if(n & 1)
result=(result * x)%mod;
x=(x*x)%mod;
n>>=1;
}
return result;
}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
ll w[n],ans=0;
for(int i=0;i<n;i++)
{
cin>>w[i];
ans+=w[i];
}
vector<int> v[n];
for(int i=0;i<n-1;i++)
{
int x,y;
cin>>x>>y;
x--;y--;
v[x].pb(y);
v[y].pb(x);
}
priority_queue<pair<ll,int>> pq;
for(int i=0;i<n;i++)
{
if(sz(v[i])>1)
pq.push({w[i],sz(v[i])-1});
}
cout<<ans<<" ";
int pos=n-2;
while(pos && sz(pq))
{
ll x=pq.top().first;
int y=pq.top().second;
pq.pop();
while(pos && y)
{
ans+=x;
y--;
pos--;
cout<<ans<<" ";
}
}
while(pos)
{
cout<<ans<<" ";
pos--;
}
cout<<endl;
}
return 0;
} | 3 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
int main(){
int TC;
cin >> TC;
while(TC--){
int N, le, ri, now;
cin >> N;
pair< pair<int, int> , int> rec[N];
for(int i=0; i<N; i++){
cin >> le >> ri;
if(le<ri)
swap(le, ri);
rec[i]=mp(mp(le, ri), i);
}
sort(rec, rec+N);
int H[N], ans[N];
pair<int, int> W[N];
H[0]=rec[0].fi.fi; W[0]=mp(rec[0].fi.se, 0);
for(int i=1; i<N; i++){
H[i]=rec[i].fi.fi;
if(rec[i].fi.se<W[i-1].fi)
W[i]=mp(rec[i].fi.se, i);
else
W[i]=W[i-1];
}
for(int i=0; i<N; i++){
now=-1;
le=lower_bound(H, H+N, H[i])-H-1;
if(le>=0 && H[W[le].se]<H[i] && W[le].fi<rec[i].fi.se)
now=rec[W[le].se].se+1;
ans[rec[i].se]=now;
}
for(int i=0; i<N; i++)
cout << ans[i] << ' ';
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
int comparetor(const void* a, const void* b) { return (*(int*)a - *(int*)b); }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int arr[200005], index[200005];
;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
index[arr[i]] = i;
}
int ans[200005] = {0};
int mn = 1000000000, mx = -1;
for (int i = 1; i <= n; i++) {
mn = min(index[i], mn);
mx = max(index[i], mx);
if (mx - mn + 1 == i) ans[i] = 1;
}
for (int i = 1; i <= n; i++) printf("%d", ans[i]);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int abs(int a) { return a < 0 ? -a : a; }
int max(int a, int b) { return a > b ? a : b; }
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int quick_power(int a, int b, int Mod) {
int ans = 1;
while (b) {
if (b & 1) {
ans = 1ll * ans * a % Mod;
}
b >>= 1;
a = 1ll * a * a % Mod;
}
return ans;
}
const int Mod = 1000000007;
const int Maxn = 1000000;
int n;
int len_a, len_b;
char a[Maxn + 5], b[Maxn + 5];
int frac[Maxn << 1 | 5], inv_f[Maxn << 1 | 5];
bool np[Maxn + 5];
int p[Maxn + 5], p_len, mu[Maxn + 5];
int pow_2[Maxn + 5];
int f[Maxn + 5];
void init() {
frac[0] = 1;
for (int i = 1; i <= (Maxn << 1); i++) {
frac[i] = 1ll * frac[i - 1] * i % Mod;
}
inv_f[Maxn << 1] = quick_power(frac[Maxn << 1], Mod - 2, Mod);
for (int i = (Maxn << 1) - 1; i >= 0; i--) {
inv_f[i] = 1ll * inv_f[i + 1] * (i + 1) % Mod;
}
np[0] = np[1] = 1;
mu[1] = 1;
for (int i = 2; i <= Maxn; i++) {
if (!np[i]) {
p[++p_len] = i;
mu[i] = Mod - 1;
}
for (int j = 1, x; (x = i * p[j]) <= Maxn; j++) {
np[x] = 1;
if (i % p[j] == 0) {
mu[x] = 0;
break;
}
mu[x] = Mod - mu[i];
}
}
pow_2[0] = 1;
for (int i = 1; i <= Maxn + 1; i++) {
pow_2[i] = (pow_2[i - 1] << 1) % Mod;
}
for (int i = 1; i <= Maxn; i++) {
for (int j = i; j <= Maxn; j += i) {
f[j] = (f[j] + 1ll * pow_2[i] * mu[j / i]) % Mod;
}
}
for (int i = 1; i <= n; i++) {
int now = (n / i);
now = 1ll * now * now % Mod * f[i] % Mod;
f[i] = (f[i - 1] + now) % Mod;
}
}
int C(int n, int m) {
if (n < m || m < 0) {
return 0;
}
return 1ll * frac[n] * inv_f[m] % Mod * inv_f[n - m] % Mod;
}
int calc(int n_a, int n_b) {
if (n_a == 0 && n_b == 0) {
return f[n];
}
if (n_a >= 0 && n_b >= 0) {
return 0;
}
if (n_a <= 0 && n_b <= 0) {
return 0;
}
n_a = abs(n_a), n_b = abs(n_b);
if (n_a == n_b) {
return pow_2[n + 1] - 2;
}
int g = gcd(n_a, n_b);
return pow_2[n / max(n_a / g, n_b / g) + 1] - 2;
}
int main() {
scanf("%s", a + 1);
scanf("%s", b + 1);
scanf("%d", &n);
init();
while (a[++len_a] != '\0')
;
while (b[++len_b] != '\0')
;
len_a--;
len_b--;
int num_a = 0, num_b = 0;
int q_a = 0, q_b = 0;
for (int i = 1; i <= len_a; i++) {
if (a[i] == '?') {
q_a++;
} else if (a[i] == 'A') {
num_a++;
} else {
num_b++;
}
}
for (int i = 1; i <= len_b; i++) {
if (b[i] == '?') {
q_b++;
} else if (b[i] == 'A') {
num_a--;
} else {
num_b--;
}
}
int ans = 0;
for (int i = -max(q_a, q_b); i <= max(q_a, q_b); i++) {
if (C(q_a + q_b, q_a - i) == 0) {
continue;
}
ans = (ans + 1ll * C(q_a + q_b, q_a - i) *
calc(num_a + i, num_b + q_a - q_b - i)) %
Mod;
}
if (len_a == len_b) {
bool flag = 1;
for (int i = 1; i <= len_a; i++) {
if (a[i] != b[i] && a[i] != '?' && b[i] != '?') {
flag = 0;
break;
}
}
if (flag) {
int tmp = 1;
for (int i = 1; i <= len_a; i++) {
if (a[i] == '?' && b[i] == '?') {
tmp = (tmp << 1) % Mod;
}
}
ans = (ans - 1ll * f[n] * tmp % Mod + Mod) % Mod;
ans = (ans + 1ll * (pow_2[n + 1] - 2) * (pow_2[n + 1] - 2) % Mod * tmp) %
Mod;
}
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
int main() {
int n, p, q, i, j, k, flag = 0, m = 0, k1;
scanf("%d %d %d ", &n, &p, &q);
char a[n + 1];
scanf("%s", a);
for (i = 0; i <= n / p; i++) {
for (j = 0; j <= n / q; j++) {
if (((p * i) + (q * j)) == n) {
flag = 1;
break;
} else if ((p * i) + (q * j) > n)
break;
}
if (flag) break;
}
if (flag) {
printf("%d\n", i + j);
for (k = 0; k < i; k++) {
for (k1 = 0; k1 < p; k1++) {
printf("%c", a[m]);
m++;
}
printf("\n");
}
for (k = 0; k < j; k++) {
for (k1 = 0; k1 < q; k1++) {
printf("%c", a[m]);
m++;
}
printf("\n");
}
} else
printf("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int T, n, m, a, buc[63], con, sum, e;
bool z;
void pot(long int p) {
if (p > 60) {
z = true;
return;
}
if (buc[p] == 0) {
con++;
pot(p + 1);
buc[p]++;
return;
}
buc[p]--;
return;
}
int main() {
cin >> T;
for (int t = 0; t < T; t++) {
cin >> n >> m;
con = 0;
z = false;
for (int i = 0; i < m; i++) {
cin >> a;
e = -1;
while (a != 0) {
a /= 2;
e++;
}
buc[e]++;
}
for (int i = 0; i <= 60; i++) {
if ((n & (1ULL << i)) != 0) {
n -= (1ULL << i);
pot(i);
}
buc[i + 1] += buc[i] / 2;
buc[i] = 0;
}
if (!z)
cout << con << "\n";
else
cout << "-1"
<< "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
vector<int> pos[26];
char s[MAXN + 10];
int l[MAXN + 10], r[MAXN + 10];
int main() {
int n, m;
scanf("%d%s", &m, s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) l[i] = i - 1, r[i] = i + 1;
r[0] = 1;
for (int i = 1; i <= n; i++) pos[s[i] - 'a'].push_back(i);
for (int i = 25; i >= 0; i--) {
int sz = pos[i].size();
int cnt = 0;
for (int j = 0; j < sz; j++) {
int del_len = r[pos[i][j]] - l[pos[i][j]];
if (del_len > m) continue;
r[l[pos[i][j]]] = r[pos[i][j]];
l[r[pos[i][j]]] = l[pos[i][j]];
cnt++;
}
if (cnt != sz) break;
}
int u = 0;
vector<char> vec;
while (u <= n) {
if (u != 0) vec.push_back(s[u]);
u = r[u];
}
sort(vec.begin(), vec.end());
int vsz = vec.size();
for (int i = 0; i < vsz; i++) printf("%c", vec[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
int main() {
long long n, r, avg;
while (cin >> n >> r >> avg) {
vector<pair<long long, long long> > v(n);
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
sum += v[i].first;
swap(v[i].first, v[i].second);
}
sort(v.begin(), v.end());
long long left = avg * n - sum;
long long ans = 0;
if (left > 0) {
for (int i = 0; i < n; i++) {
long long temp = (r - v[i].second);
if (temp >= left) {
ans += left * v[i].first;
break;
} else {
ans += temp * v[i].first;
left -= temp;
}
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, id, ans, tr[N][26];
bool b[N];
char s[N];
std::priority_queue<int> q[N];
void dfs(int x, int d) {
for (int y, i = 0; i < 26; ++i)
if (y = tr[x][i]) {
dfs(y, d + 1);
while (q[y].size()) {
q[x].push(q[y].top());
q[y].pop();
}
}
if (x && !b[x]) {
ans -= q[x].top() - d;
q[x].pop();
q[x].push(d);
}
}
int main() {
scanf("%d", &n);
for (int x, i = 1; i <= n; ++i) {
x = 0;
scanf("%s", s + 1);
m = strlen(s + 1);
for (int j = 1; j <= m; ++j) {
if (!tr[x][s[j] - 97]) tr[x][s[j] - 97] = ++id;
x = tr[x][s[j] - 97];
}
b[x] = true;
q[x].push(m);
ans += m;
}
dfs(0, 0);
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int d[] = {1, 2, 3, 5};
void solve() {
int n, k;
scanf("%d%d", &n, &k);
printf("%d\n", (6 * (n - 1) + 5) * k);
for (int i(0), _l((int)(n)-1); i <= _l; ++i) {
for (int j(0), _l((int)(4) - 1); j <= _l; ++j)
printf("%d%c", (6 * i + d[j]) * k, j == 3 ? '\n' : ' ');
}
}
int main() {
clock_t tm = clock();
solve();
cerr << setprecision(3);
cerr << (clock() - tm) / 1000000. << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1.1e5;
const int MAXM = 1.1e5;
int N, M;
struct edge_t {
int c[2];
int other(int a) {
assert(a == c[0] || a == c[1]);
return a ^ c[0] ^ c[1];
}
} E[MAXM];
int last[MAXN];
int pred[MAXM * 2];
int ind[MAXM * 2];
int tot = 0;
void addEdge(int a, int e) {
pred[tot] = last[a];
ind[tot] = e;
last[a] = tot;
tot++;
}
int disc[MAXN];
int lowVal[MAXN];
int curInd = 0;
vector<int> st;
bool vis[MAXN];
vector<int> ans;
void process(vector<int> bcc) {
int cnt = 0;
for (int e : bcc) {
for (int i = 0; i < 2; i++) {
if (!vis[E[e].c[i]]) {
vis[E[e].c[i]] = true;
cnt++;
}
}
}
if (cnt == int(bcc.size())) {
for (int e : bcc) {
ans.push_back(e + 1);
}
}
for (int e : bcc) {
for (int i = 0; i < 2; i++) {
vis[E[e].c[i]] = false;
cnt++;
}
}
}
void dfs(int cur, int prvE) {
assert(!disc[cur]);
curInd++;
disc[cur] = curInd;
lowVal[cur] = disc[cur];
int children = 0;
for (int z = last[cur]; z != -1; z = pred[z]) {
int e = ind[z];
if (e == prvE) continue;
int nxt = E[e].other(cur);
if (!disc[nxt]) {
st.push_back(e);
children++;
dfs(nxt, e);
lowVal[cur] = min(lowVal[cur], lowVal[nxt]);
if ((disc[cur] == 1 && children > 1) ||
(disc[cur] != 1 && disc[cur] <= lowVal[nxt])) {
vector<int> bcc;
int lastE;
do {
lastE = st.back();
st.pop_back();
bcc.push_back(lastE);
} while (lastE != e);
process(bcc);
}
} else if (disc[nxt] < disc[cur]) {
st.push_back(e);
lowVal[cur] = min(lowVal[cur], disc[nxt]);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> N >> M;
for (int i = 1; i <= N; i++) {
last[i] = -1;
}
for (int e = 0; e < M; e++) {
cin >> E[e].c[0] >> E[e].c[1];
addEdge(E[e].c[0], e);
addEdge(E[e].c[1], e);
}
for (int i = 1; i <= N; i++) {
if (!disc[i]) {
dfs(i, -1);
}
}
if (!st.empty()) {
process(st);
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int e : ans) {
cout << e << ' ';
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<long long int> s, r;
int main() {
long long int k, b, n, t, z = 1;
cin >> k >> b >> n >> t;
while (k * z + b <= t) {
z = z * k + b;
n--;
}
cout << (n > 0 ? n : 0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e2 + 5;
int n, grid[N][N];
bool col[N], row[N];
vector<pair<int, int> > ans;
int main() {
std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
memset(col, false, sizeof(col));
memset(row, false, sizeof(row));
cin >> n;
for (long long int i = (1); i <= (n); i++) {
for (long long int j = (1); j <= (n); j++) {
char tempc;
cin >> tempc;
grid[i][j] = (tempc == '.' ? 0 : 1);
if (tempc == '.') {
row[i] = col[j] = true;
}
}
}
bool isRow = false, isCol = false;
for (long long int i = (1); i <= (n); i++) {
if (!row[i]) isRow = true;
if (!col[i]) isCol = true;
}
if (!isRow) {
for (long long int i = (1); i <= (n); i++) {
for (long long int j = (1); j <= (n); j++) {
if (!grid[i][j]) {
cout << i << " " << j << endl;
break;
}
}
}
} else if (!isCol) {
for (long long int j = (1); j <= (n); j++) {
for (long long int i = (1); i <= (n); i++) {
if (!grid[i][j]) {
cout << i << " " << j << endl;
break;
}
}
}
} else
cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e6 + 1;
int n, k, deg[N];
set<int> adj[N];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
set<int> s;
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
s.insert(i);
}
}
int ans = -1;
while (!s.empty()) {
ans++;
map<int, int> nex;
for (auto v : s) {
for (auto u : adj[v]) {
nex[u]++;
adj[u].erase(v);
}
}
if (s.size() > 1 && nex.size() == 0) {
return cout << "No", 0;
}
s.clear();
for (auto cnex : nex) {
int v = cnex.first, c = cnex.second;
if (c < 3) {
return cout << "No", 0;
}
s.insert(v);
}
}
if (ans != k) {
return cout << "No", 0;
}
cout << "Yes";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long flag = 0, n, k;
cin >> n >> k;
string s1;
cin >> s1;
long long l = s1.length();
string s2 = s1.substr(0, k);
for (long long i = k; i < l; i = i + 1) {
if (s1[i] > s1[i - k])
flag = 1;
else if (s1[i] < s1[i - k])
flag = 2;
if (flag != 0) break;
}
if (flag == 1) {
long long flag2 = 0, d;
for (long long j = k - 1; j >= 0; j--) {
if (s1[j] != '9') {
int temp = (int)s1[j];
temp++;
s1[j] = (char)temp;
d = j;
break;
}
}
for (long long k = d + 1; k < l; k++) {
if (s1[k] == '9') {
s1[k] = '0';
}
}
for (long long j = k; j < l; j++) {
s1[j] = s1[j - k];
}
cout << l << endl;
cout << s1 << endl;
} else if (flag == 2) {
for (long long j = k; j < l; j++) {
s1[j] = s1[j - k];
}
cout << l << endl;
cout << s1 << endl;
} else {
cout << l << endl;
cout << s1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1011110;
int n, nSwap;
int A[N];
void qSort(int l, int r) {
if (l >= r) return;
int key = A[rand() % (r - l) + l];
int i = l, k = r;
while (i <= k) {
while (A[i] < key) i++;
while (A[k] > key) k--;
if (i <= k) {
if (i < k) {
nSwap++;
swap(A[i], A[k]);
}
i++;
k--;
}
}
qSort(l, k);
qSort(i, r);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]);
nSwap = 0;
qSort(1, n);
if ((3 * n - nSwap) % 2 == 0)
puts("Petr");
else
puts("Um_nik");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int N, M, Q, to[maxn], w[maxn], delta[maxn];
long long dis[maxn];
vector<int> g[maxn];
queue<int> q[maxn];
inline void init() {
memset(dis, 0x3f, sizeof dis);
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
q.push(make_pair(0, 1));
dis[1] = 0;
while (q.size()) {
long long d = q.top().first;
int node = q.top().second;
q.pop();
if (dis[node] < d) continue;
for (int ck : g[node]) {
int nxt = to[ck], cost = w[ck];
if (dis[nxt] > d + cost) {
dis[nxt] = d + cost;
q.push(make_pair(dis[nxt], nxt));
}
}
}
}
inline void recompute(int lim) {
memset(delta, 0x3f, sizeof delta);
delta[1] = 0, q[0].push(1);
for (int i = 0; i <= lim; i++) {
while (q[i].size()) {
int node = q[i].front();
q[i].pop();
if (delta[node] < i) continue;
for (int ck : g[node]) {
int nxt = to[ck], n_d = dis[node] + delta[node] + w[ck] - dis[nxt];
if (n_d < delta[nxt] && n_d <= lim) {
delta[nxt] = n_d;
q[n_d].push(nxt);
}
}
}
}
for (int i = 1; i <= N; i++) {
if (delta[i] == 0x3f3f3f3f) continue;
dis[i] += delta[i];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M >> Q;
for (int i = 1; i <= M; i++) {
int a;
cin >> a >> to[i] >> w[i];
g[a].push_back(i);
}
init();
while (Q--) {
int op, v;
cin >> op >> v;
if (op == 1)
cout << (dis[v] == 0x3f3f3f3f3f3f3f3fLL ? -1 : dis[v]) << '\n';
else {
for (int i = 1; i <= v; i++) {
int a;
cin >> a;
w[a]++;
}
recompute(v);
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], tmp[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0) {
tmp[i] = a[i];
} else {
tmp[i] = tmp[i - 1] + a[i];
}
}
if (tmp[n - 1] % k != 0) {
cout << "No";
return 0;
}
vector<int> v;
int sum = 0, fn = -1;
for (int i = 0; i < n; i++) {
if (tmp[i] == sum + tmp[n - 1] / k) {
sum += tmp[n - 1] / k;
v.push_back(i - fn);
fn = i;
} else if (tmp[i] > sum + tmp[n - 1] / k) {
cout << "No";
return 0;
}
}
cout << "Yes\n";
for (auto c : v) {
cout << c << ' ';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
// #pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define fi first
#define se second
#define pb push_back
#define sz(v) (int)v.size()
#define all(v) v.begin(),v.end()
#define dbg(x) cerr << #x << " is " << x << "\n";
#define cum cerr << "came\n";
using ll = long long;
using ii = pair<ll,ll>;
bool ok(int n, int ex, int need) {
return ex + n >= need && ex <= need;
}
int main() {
int T; scanf("%d", &T);
while(T--) {
int n, u, d, r, l;
scanf("%d %d %d %d %d", &n, &u, &r, &d, &l);
bool flag = false;
for(int mask = 0; mask < (1 << 4); mask++) {
bitset<4> t(mask);
if(ok(n - 2, t[0] + t[1], u) && ok(n - 2, t[1] + t[2], r) && ok(n - 2, t[2] + t[3], d) && ok(n - 2, t[3] + t[0], l))
{ flag = true; break; }
}
if(flag) puts("YES");
else puts("NO");
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
bool greatfunc(long long int a, long long int b) { return (a > b); }
bool checkPrime(long long int N) {
if (N < 2) return false;
if (N == 2 || N == 3) return true;
if (N % 2 == 0) return false;
for (long long int i = 3; i <= sqrt(N); i++)
if (N % i == 0) return false;
return true;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= 1000; i++) {
if (!checkPrime(n * i + 1)) {
printf("%d", i);
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int P = 998244353;
const int N = 200050;
int h[N], ne[N << 1], to[N << 1], tot, n, k, lim;
inline void add(int x, int y) { ne[++tot] = h[x], to[h[x] = tot] = y; }
long long dp[N], inv[N], fac, ans;
int siz[N], L[N], R[N], H[N], F[N], tp;
namespace NTT {
const int P = 998244353;
int A[N << 2], B[N << 2], C[N << 2], D[N << 2];
long long E[N];
int r[N], lim = 1;
inline int add(int x, int y) { return x + y >= P ? x + y - P : x + y; }
void dft(int *A) {
for (int i = 1; i < lim; i++)
if (r[i] > i) swap(A[i], A[r[i]]);
for (int i = 1; i < lim; i <<= 1) {
for (int j = 0; j < lim; j += (i << 1)) {
int *f = A + j, *g = f + i;
long long *e = E + i;
for (int k = 0; k < i; k++) {
int x = f[k], y = e[k] * g[k] % P;
f[k] = add(x, y), g[k] = add(x, P - y);
}
}
}
}
long long fpw(long long x, long long mi) {
long long res = 1;
for (; mi; mi >>= 1, x = x * x % P)
if (mi & 1) res = res * x % P;
return res;
}
void idft(int *A) {
dft(A), reverse(A + 1, A + lim);
long long inv = fpw(lim, P - 2);
for (int i = 0; i < lim; i++) A[i] = inv * A[i] % P;
}
void init(void) {
while (lim <= 2 * n) lim <<= 1;
int len = lim >> 1;
for (int i = 1; i < lim; i++) r[i] = r[i >> 1] >> 1 | ((i & 1) ? len : 0);
E[1] = 1;
for (int i = 2; i < lim; i <<= 1) {
long long *e0 = E + i / 2, *e1 = E + i;
long long w = fpw(3, (P - 1) / (i << 1));
for (int j = 0; j < i; j += 2)
e1[j] = e0[j >> 1], e1[j + 1] = e1[j] * w % P;
}
}
void Mul(int x, int y) {
int n = R[x] - L[x], m = R[y] - L[y];
for (int i = 0; i <= n; i++) A[i] = H[L[x] + i], B[i] = F[L[x] + i];
for (int i = 0; i <= m; i++) C[i] = H[L[y] + i], D[i] = F[L[y] + i];
lim = 1;
while (lim <= (n + m)) lim <<= 1;
int len = lim >> 1;
for (int i = 1; i < lim; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) ? len : 0);
for (int i = n + 1; i <= lim; i++) A[i] = B[i] = 0;
for (int i = m + 1; i <= lim; i++) C[i] = D[i] = 0;
dft(A), dft(B), dft(C), dft(D);
for (int i = 0; i < lim; i++) {
int a = A[i], b = B[i], c = C[i], d = D[i];
A[i] = 1ll * a * c % P, B[i] = 1ll * b * c % P, D[i] = 1ll * d * a % P;
}
idft(A), idft(B), idft(D);
for (int i = 0; i <= n + m; i++) H[L[x] + i] = A[i];
for (int i = 0; i <= n + m; i++) F[L[x] + i] = add(B[i], D[i]);
L[++tp] = L[x], R[tp] = L[x] + n + m;
}
} // namespace NTT
using NTT::dft;
using NTT::idft;
using NTT::init;
using NTT::Mul;
void dfs1(int x, int fa) {
siz[x] = 1;
long long Mul = 0;
int t = -1, deg = 0;
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
if (y == fa) continue;
dfs1(y, x), siz[x] += siz[y];
ans = (ans + dp[y] * Mul) % P, Mul = (Mul + dp[y]) % P;
}
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
if (y == fa) continue;
deg++;
H[++t] = 1, L[deg] = t, F[t] = dp[y], H[++t] = siz[y], R[deg] = t, F[t] = 0;
}
if (!deg) return dp[x] = 1, void();
t = deg;
while (t > 1) {
tp = 0;
for (int i = 1; i < t; i += 2) NTT::Mul(i, i + 1);
if (t & 1) L[++tp] = L[t], R[tp] = R[t];
t = tp;
}
dp[x] = Mul;
for (int j = 0; j <= min(deg, k); j++)
dp[x] = (dp[x] + fac * inv[k - j] % P * H[j]) % P;
long long res = n - siz[x];
for (int j = min(k, deg); j >= 1; j--) F[j] = (F[j] + res * F[j - 1]) % P;
for (int j = 0; j <= min(k, deg); j++)
ans = (ans + fac * inv[k - j] % P * F[j]) % P;
}
int main() {
read(n), read(k);
for (int i = 1, x, y; i < n; i++) read(x), read(y), add(x, y), add(y, x);
if (k == 1) return write((long long)n * (n - 1) / 2 % P), 0;
init(), inv[0] = inv[1] = fac = 1;
for (int i = 2; i <= max(n, k); i++) inv[i] = inv[P % i] * (P - P / i) % P;
for (int i = 1; i <= max(n, k); i++) inv[i] = inv[i - 1] * inv[i] % P;
for (int i = 1; i <= k; i++) fac = fac * i % P;
dfs1(1, 0), write(ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, a[100005], lnc[100005], rec[100005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (a[i - 1] >= a[i])
lnc[i] = 1 + lnc[i - 1];
else
lnc[i] = 1;
}
for (int i = n; i >= 1; i--) {
if (a[i] <= a[i + 1])
rec[i] = rec[i + 1] + 1;
else
rec[i] = 1;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
if (lnc[r] + rec[l] > r - l + 1)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
os << "{" << p.first << ", " << p.second << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[";
int i = 0;
for (typename vector<T>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[";
int i = 0;
for (typename set<T>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class K, class V>
ostream& operator<<(ostream& os, const map<K, V>& p) {
os << "[";
int i = 0;
for (typename map<K, V>::const_iterator it = p.begin(); it != p.end(); ++it) {
os << (i == 0 ? "" : ", ") << *it;
i++;
}
os << "]";
return os;
}
template <class T>
string toString(const T& o) {
stringstream ss;
ss << o;
string ret;
getline(ss, ret);
return ret;
}
ostream& operator<<(ostream& os, const string& o) {
os << "\"" << o.c_str() << "\"";
return os;
}
int a[420][420];
int x[20], y[20];
int n, d;
int solve(int first, int second) {
if ((first - 210) * (first - 210) + (second - 210) * (second - 210) > d * d)
return 2;
if (a[first][second]) return a[first][second];
a[first][second] = 1;
for (int i = 0; i < n; ++i)
if (solve(first + x[i], second + y[i]) == 1) {
a[first][second] = 2;
break;
}
return a[first][second];
}
int main() {
int first, second;
cin >> first >> second >> n >> d;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
cout << (solve(first + 210, second + 210) == 2 ? "Anton" : "Dasha") << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using piii = pair<pair<int, int>, int>;
using vi = vector<int>;
using vl = vector<long long>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
bool check(vi a, vi &b, int x, int m) {
for (int i = (0); i < (a.size()); i++) {
a[i] = (a[i] + x) % m;
}
sort((a).begin(), (a).end());
for (int i = (0); i < (a.size()); i++) {
if (a[i] != b[i]) return false;
}
return true;
}
void solve() {
int n, m;
cin >> n >> m;
vi a(n), b(n);
for (int i = (0); i < (n); i++) {
cin >> a[i];
}
for (int i = (0); i < (n); i++) {
cin >> b[i];
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
set<int> s;
for (int j = (0); j < (n); j++) {
int y = b[0] - a[j];
if (y >= 0)
y = y % m;
else
y = m - abs(y);
s.insert(y);
}
int x;
for (auto i : s) {
if (check(a, b, i, m)) {
x = i;
break;
}
}
cout << x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2000001;
int n, v[N];
map<int, int> f;
int main() {
scanf("%d", &n);
long long sm = 0, fs = 0, need = 0;
multiset<int> sf, pf;
for (int i = 0; i < n; ++i) {
scanf("%d", v + i);
sm += v[i];
sf.insert(v[i]);
}
if (sm & 1) {
return puts("NO"), 0;
}
need = sm / 2;
bool ok = false;
for (int i = 0; i < n; ++i) {
sm -= v[i];
fs += v[i];
sf.erase(sf.find(v[i]));
pf.insert(v[i]);
if (sm == fs && sm == need) {
ok = true;
break;
}
if (fs < need) {
int w = need - fs;
auto it = sf.lower_bound(w);
if (it != sf.end() && *it == w && sm - w == need) {
ok = true;
break;
}
}
if (sm < need) {
int w = need - sm;
auto it = pf.lower_bound(w);
if (it != pf.end() && *it == w && fs - w == need) {
ok = true;
break;
}
}
}
if (ok)
puts("YES");
else
puts("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, maxh, currd, newd, currh, newh;
bool error;
cin >> n >> m;
cin >> currd >> currh;
error = false;
maxh = currh;
maxh = (maxh > currd + currh - 1 ? maxh : currd + currh - 1);
for (i = 1; i < m; ++i) {
cin >> newd >> newh;
if (abs(newh - currh) > (newd - currd)) {
error = true;
}
maxh = (maxh > (currh + newh) / 2 + (newd - currd) / 2
? maxh
: (currh + newh) / 2 + (newd - currd) / 2);
maxh = (maxh > currh ? maxh : currh);
currd = newd;
currh = newh;
}
maxh = (maxh > n - currd + currh ? maxh : n - currd + currh);
if (!error)
cout << maxh << endl;
else
cout << "IMPOSSIBLE" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long int r = 1;
cin >> n;
for (int i = 0; i < n; i++) {
r = r * 2;
if (r == 8192) {
r = r - 100;
}
}
cout << r;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int64_t k, b, n, t;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
cin >> k >> b >> n >> t;
int64_t z = 1;
int i;
for (i = 0; i < n; i++) {
if (k * z + b > t) break;
z = k * z + b;
}
cout << n - i << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
char grid[110][110];
set<char> have;
int n, m;
pair<int, int> chk(char c) {
int minn1, minn2, maxx1, maxx2;
minn1 = minn2 = 1000;
maxx1 = maxx2 = -1;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) {
if (grid[i][j] == c) {
minn1 = min(minn1, i);
minn2 = min(minn2, j);
maxx1 = max(maxx1, i);
maxx2 = max(maxx2, j);
}
}
for (int i = minn1; i <= maxx1; i++)
for (int j = minn2; j <= maxx2; j++)
if (grid[i][j] != c) {
cout << "NO";
exit(0);
}
return pair<int, int>(maxx1 - minn1, maxx2 - minn2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++) {
cin >> grid[i][j];
have.insert(grid[i][j]);
}
if (have.size() != 3) {
cout << "NO";
return 0;
}
set<pair<int, int> > ans;
ans.insert(chk('R'));
ans.insert(chk('G'));
ans.insert(chk('B'));
if (ans.size() == 1) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define maxn 300010
using namespace std;
int p[maxn], num[3], r, ans[maxn], st[maxn], tmp[maxn];
char dir[maxn];
struct pos
{
int po, d, orp;
bool operator < (const pos &a) const
{
return po < a.po;
}
}p1[maxn], p2[maxn];
void solve(pos *t, int n)
{
sort(t + 1, t + n + 1);
int cnt = 0, i;
num[1] = num[2] = 0;
for(i = 1; i <= n; i++) num[t[i].d]++;
for(i = 1; i <= n; i++)
{
if(t[i].d == 2) st[++cnt] = i;
else if(cnt)
{
ans[t[st[cnt]].orp] = ans[t[i].orp] = (t[i].po - t[st[cnt]].po) / 2;
cnt--;
num[1]--; num[2]--;
}
}
cnt = 0;
for(i = 1; i <= n; i++) if(!ans[t[i].orp]) tmp[++cnt] = i;
int now1 = 1, now2 = cnt;
while(num[1] > 1)
{
ans[t[tmp[now1]].orp] = ans[t[tmp[now1 + 1]].orp] = t[tmp[now1]].po + (t[tmp[now1 + 1]].po - t[tmp[now1]].po) / 2;
num[1] -= 2;
now1 += 2;
}
while(num[2] > 1)
{
ans[t[tmp[now2]].orp] = ans[t[tmp[now2 - 1]].orp] = r - t[tmp[now2]].po + (t[tmp[now2]].po - t[tmp[now2 - 1]].po) / 2;
num[2] -= 2;
now2 -= 2;
}
if(num[1] && num[2])
ans[t[tmp[now1]].orp] = ans[t[tmp[now2]].orp] = r - (t[tmp[now2]].po - t[tmp[now1]].po) / 2;
}
int main()
{
int t, n, n1, n2, i;
cin >> t;
while(t--)
{
scanf("%d%d", &n, &r); n1 = n2 = 0;
memset(ans, 0, sizeof(ans));
for(i = 1; i <= n; i++)
scanf("%d", &p[i]);
getchar();
for(i = 1; i <= n; i++)
{
scanf("%c", &dir[i]);
getchar();
}
for(i = 1; i <= n; i++)
{
if(p[i] & 1)
{
p1[++n1].po = p[i];
p1[n1].orp = i;
p1[n1].d = (dir[i] == 'L' ? 1 : 2);
}
else
{
p2[++n2].po = p[i];
p2[n2].orp = i;
p2[n2].d = (dir[i] == 'L' ? 1 : 2);
}
}
solve(p1, n1); solve(p2, n2);
for(i = 1; i <= n; i++)
{
if(ans[i]) printf("%d ", ans[i]);
else printf("-1 ");
}
puts("");
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int num_conduct[100005];
int num_blocked[100005];
int conductionCost(int magnetPos, int ironPos) {
int x;
int y;
x = min(magnetPos, ironPos);
y = max(magnetPos, ironPos);
return num_conduct[y - 1] - num_conduct[x];
}
bool isBlocked(int magnetPos, int ironPos) {
int x;
int y;
x = min(magnetPos, ironPos);
y = max(magnetPos, ironPos);
return (num_blocked[y - 1] - num_blocked[x] > 0);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << "1 ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str[2];
ios_base::sync_with_stdio(false);
cin.tie(NULL);
getline(cin, str[0]);
getline(cin, str[1]);
long long i = 0, j = 0;
while (str[0][i] == '0') {
i++;
}
while (str[1][j] == '0') {
j++;
}
if (str[1].length() - j > str[0].length() - i) {
cout << "<" << endl;
} else if (str[1].length() - j < str[0].length() - i) {
cout << ">" << endl;
} else {
while (str[0][i] == str[1][j]) {
if (i == str[0].length()) {
cout << "=" << endl;
return 0;
}
i++;
j++;
}
if (str[0][i] > str[1][j]) {
cout << ">" << endl;
} else {
cout << "<" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
const int base = 29;
unordered_map<unsigned long long, int> mmap;
unsigned long long p[maxn], h[maxn];
string s;
int n;
unsigned long long gethash(int l, int r) {
return h[r] - h[l - 1] * p[r - l + 1];
}
int last(int l, int len) {
int ans = 0;
unsigned long long tmp = gethash(l, l + len - 2);
if (mmap.count(tmp)) ans = max(ans, mmap[tmp]);
tmp = gethash(l + 1, l + len - 1);
if (mmap.count(tmp)) ans = max(ans, mmap[tmp]);
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("A"
".INP",
"r")) {
freopen(
"A"
".INP",
"r", stdin);
freopen(
"A"
".OUT",
"w", stdout);
}
cin >> n >> s;
s = " " + s;
int cur = 0, ans = 1;
p[0] = 1;
for (int i = 1; i <= n; ++i) {
p[i] = p[i - 1] * base;
h[i] = h[i - 1] * base + s[i] - 'a' + 1;
}
for (int i = n; i >= 1; --i) {
++cur;
while (cur > 1 && last(i, cur) < i + cur) --cur;
ans = max(ans, cur);
for (int j = cur; j > 0 && !mmap.count(gethash(i, i + j - 1)); --j) {
mmap[gethash(i, i + j - 1)] = i;
}
}
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modi(long long a, long long m) { return power(a, m - 2, m); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
vector<long long> v;
long long temp = 0;
for (long long i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'a') {
if (temp >= 1) v.push_back(temp);
temp = 2 * temp;
temp %= 1000000007;
} else
temp++;
}
long long ans = 0;
for (long long i = 0; i < v.size(); i++) {
ans = (ans + v[i]) % 1000000007;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long bit[2][N], pos[N];
int n;
void updatebit(int x, int i, long long v) {
for (; i <= n; i += i & -i) bit[x][i] += v;
}
long long querybit(int x, int i) {
long long sum = 0;
for (; i > 0; i -= i & -i) sum += bit[x][i];
return sum;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
pos[temp] = i + 1;
}
long long inv = 0;
for (int k = 1; k <= n; k++) {
inv += k - 1 - querybit(0, pos[k]);
updatebit(0, pos[k], 1);
updatebit(1, pos[k], pos[k]);
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (querybit(0, mid) <= k / 2)
l = mid + 1;
else
r = mid - 1;
}
long long a = querybit(0, l), b = querybit(1, l);
long long cost = a * l - a * (a - 1) / 2 - b + querybit(1, n) - b -
(k - a) * (l + 1) - (k - a) * (k - a - 1) / 2;
cout << cost + inv << " ";
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
bool is[1002];
int n, k, dp[1002], minii, maxii;
int viz[1000002];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
int dist = 0;
vector<int> di;
for (int i = 1; i <= k; ++i) {
int nr;
cin >> nr;
if (i == 1)
minii = maxii = nr;
else {
minii = min(minii, nr);
maxii = max(maxii, nr);
}
if (!is[nr]) ++dist, di.push_back(nr);
is[nr] = 1;
dp[nr] = 1;
}
if (n > maxii || n < minii) {
cout << -1;
return 0;
}
deque<pair<int, int> > d;
d.push_back({0, 0});
int ct = 0;
while (!d.empty()) {
pair<int, int> x = d[0];
d.pop_front();
for (int j = 0; j < dist; ++j) {
int ne_pos = x.first + di[j];
if (viz[ne_pos] < x.second + 1) {
if (ne_pos + 2000 >= (x.second + 1) * n &&
ne_pos - 2000 <= (x.second + 1) * n) {
viz[ne_pos] = x.second + 1;
d.push_back({ne_pos, x.second + 1});
if (ne_pos == n * (x.second + 1)) {
cout << x.second + 1;
return 0;
}
}
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> res;
long long* p = new long long[2000001];
void SNT() {
for (long long i = 2; i * i < 2000001; i++) p[i] = 0;
for (long long i = 2; i * i < 2000001; i++)
if (!p[i])
for (long long j = i * i; j < 2000001; j += i) p[j] = 1;
}
int main() {
SNT();
long long n;
long long a[10001];
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n > 1 && a[1] == 1) {
long long i;
for (i = 0; i < n && a[i] == 1; i++) res.push_back(1);
for (i; i < n; i++) {
if (!p[a[i] + 1]) break;
}
if (i < n) res.push_back(a[i]);
} else {
for (long long i = 0; i < n && res.empty(); i++) {
for (long long j = i + 1; j < n && res.empty(); j++) {
if (!p[a[i] + a[j]]) res.push_back(a[i]), res.push_back(a[j]);
}
}
if (res.empty()) res.push_back(a[0]);
}
cout << (long long)res.size() << endl;
for (long long i = 0; i < res.size(); i++) {
cout << res.at(i) << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long n, k;
long long ans1, ans2, x, MAX = -1;
cin >> n >> k;
for (long long i = 1; i <= k; i++) {
cin >> x;
long long t = (n / x);
if (t * x > MAX) {
MAX = t * x;
ans1 = i;
ans2 = t;
}
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((a + b) % 2 == 0) {
if (b + c > 0 and a + d > 0) {
cout << "Tidak Tidak Ya Ya"
<< "\n";
} else if (b + c > 0 and a + d == 0) {
cout << "Tidak Tidak Ya Tidak"
<< "\n";
} else if (b + c == 0 and a + d > 0) {
cout << "Tidak Tidak Tidak Ya"
<< "\n";
} else {
cout << "Tidak Tidak Tidak Tidak"
<< "\n";
}
} else {
if (b + c > 0 and a + d > 0) {
cout << "Ya Ya Tidak Tidak"
<< "\n";
} else if (b + c > 0 and a + d == 0) {
cout << "Tidak Ya Tidak Tidak"
<< "\n";
} else if (b + c == 0 and a + d > 0) {
cout << "Ya Tidak Tidak Tidak"
<< "\n";
} else {
cout << "Tidak Tidak Tidak Tidak"
<< "\n";
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void d_s_a() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
d_s_a();
long long t;
cin >> t;
while (t--) {
long long n;
long long counter = 0;
cin >> n;
bool x = true;
while (1) {
if (n == 1) break;
if (n == 2 || n == 4 || n == 5 || n % 5 == 0) {
x = false;
break;
}
if (n % 6 == 0) {
n = n / 6;
counter++;
} else {
n = n * 2;
counter++;
}
}
if (!x) {
cout << -1 << endl;
} else
cout << counter << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001];
int b[10000000][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, edges = 0;
cin >> n;
a[1] = 0;
for (int i = 2; i <= 10000; i++) {
a[i] = -1;
}
for (int i = 2; i <= 10000; i++) {
if (a[i] == 0)
continue;
else {
for (int j = i * i; j <= 10000; j += i) a[j] = 0;
}
}
vector<int> z(n + 1);
for (int i = 0; i < n - 1; i++) {
b[i][0] = i + 1;
b[i][1] = i + 2;
z[i + 1]++;
z[i + 2]++;
edges++;
}
b[n - 1][0] = n;
b[n - 1][1] = 1;
z[1]++;
z[n]++;
edges++;
while (a[edges] != -1) {
for (int i = 1; i <= n; i++) {
if (a[edges] == -1) break;
if (a[z[i] + 1] == -1) {
b[edges][0] = i;
b[edges][1] = i + 2;
z[i]++;
z[i + 2]++;
edges++;
}
}
}
cout << edges << "\n";
for (int i = 0; i < edges; i++) {
cout << b[i][0] << " " << b[i][1] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, mx = 0, ans = 0, a[200010], cnt[200010], b[400010];
void sol1(int x, int y) {
for (int i = 0; i <= 2 * n; i++) b[i] = -1;
b[n] = 0;
int cur = 0;
bool flag = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == x)
cur++, flag = 1;
else if (a[i] == mx)
cur--, flag = 1;
if (!flag) continue;
if (b[cur + n] == -1)
b[cur + n] = i;
else
ans = max(ans, i - b[cur + n]);
}
}
void sol2(int x) {
for (int i = 1; i <= n; i++) b[i] = 0;
int tot = 0;
for (int l = 1, r = 1; r <= n; r++) {
b[a[r]]++;
if (b[a[r]] == x)
tot++;
else
while (b[a[r]] > x) {
b[a[l]]--;
if (b[a[l]] == x - 1) tot--;
l++;
}
if (tot >= 2) ans = max(ans, r - l + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 1; i <= n; i++)
if (cnt[mx] < cnt[a[i]]) mx = a[i];
for (int i = 1; i <= n; i++)
if (i != mx && cnt[i] >= sqrt(n)) sol1(i, mx);
for (int i = 1; i < sqrt(n); i++) sol2(i);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sum = 0, nega = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') nega = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum * nega;
}
long long n, k, m, a[5009], b[5009], c[5009], cnt[100009], ans, dp[5009];
signed main() {
n = read(), k = read();
m = n * k;
for (long long i = 1; i <= m; i++) a[i] = read(), cnt[a[i]]++;
for (long long i = 1; i <= n; i++) b[i] = read();
for (long long i = 1; i <= k; i++) c[i] = read();
sort(b + 1, b + n + 1);
long long l = 1, r = 1;
while (l <= n) {
while (b[r + 1] == b[l]) r++;
long long qwq = cnt[b[l]], len = (r - l + 1);
for (long long i = 0; i <= n * k; i++) dp[i] = 0;
for (long long i = 1; i <= len; i++) {
for (long long j = qwq; j >= 0; j--)
for (long long p = min(j, k); p >= 1; p--)
dp[j] = max(dp[j], dp[j - p] + c[p]);
}
long long res = 0;
for (long long i = 1; i <= qwq; i++) res = max(res, dp[i]);
ans += res;
l = r + 1;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const double eps = 1e-9;
int n, cnt;
long long sum[200005];
struct node {
int a, t, bel;
} s[200005];
inline bool cmp(node p, node q) {
long long l = 1ll * p.t * q.a, r = 1ll * q.t * p.a;
return l == r ? p.a < q.a : l < r;
}
bool check(double c) {
static double b[200005];
long long T = sum[cnt];
double mx = 0;
for (int i = 1, p = 0; i <= n; ++i) {
while (p < i && s[p + 1].a < s[i].a) ++p, mx = max(mx, b[p]);
b[i] = s[i].a * (1.0 - c * sum[s[i].bel] / T);
if (b[i] - mx > eps)
;
else
return 0;
long long t = sum[s[i].bel - 1] + s[i].t;
b[i] = s[i].a * (1.0 - c * t / T);
}
return 1;
}
int main() {
n = read();
for (int i = (1), _ed = (n); i <= _ed; ++i) s[i].a = read();
for (int i = (1), _ed = (n); i <= _ed; ++i) s[i].t = read();
sort(s + 1, s + n + 1, cmp);
for (int l = 1, r; l <= n; l = r + 1) {
r = l;
while (r < n && 1ll * s[r].a * s[r + 1].t == 1ll * s[r + 1].a * s[r].t) ++r;
++cnt;
sum[cnt] = sum[cnt - 1];
for (int i = (l), _ed = (r); i <= _ed; ++i)
s[i].bel = cnt, sum[cnt] += s[i].t;
}
sort(s + 1, s + n + 1, [&](node p, node q) { return p.a < q.a; });
double l = 0, r = 1, ans = 0;
while (r - l > eps) {
double mid = (l + r) / 2;
if (check(mid))
ans = mid, l = mid + eps;
else
r = mid - eps;
}
printf("%.9f\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
int dir[8][2] = {-1, 0, 1, 0, 0, -1, 0, 1, -1, -1, -1, 1, 1, -1, 1, 1};
template <typename S, typename T>
inline bool Min(S &a, const T &b) {
return a > b ? a = b, true : false;
}
template <typename S, typename T>
inline bool Max(S &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename S, typename T>
inline void Adm(S &a, const T &b) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
template <typename T>
inline bool IsPri(T x) {
if (x < 2) return false;
for (T i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
template <typename T>
inline T _Gcd(T a, T b) {
while (b) {
T t = b;
b = a % b;
a = t;
}
return a;
}
template <typename T>
inline int _BitCnt(T x) {
int cnt = 0;
while (x) ++cnt, x &= x - 1;
return cnt;
}
inline long long Pow(long long a, long long n) {
long long t = 1;
a %= MOD;
while (n > 0) {
if (n & 1) t = t * a % MOD;
a = a * a % MOD, n >>= 1;
}
return t % MOD;
}
inline int read() {
static char buf[1000000], *p1 = buf, *p2 = buf;
register int x = false;
register char ch =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
register bool sgn = false;
while (ch != '-' && (ch < '0' || ch > '9'))
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
if (ch == '-')
sgn = true,
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48),
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
return sgn ? -x : x;
}
const int N = 1e3 + 100;
int n, m;
char s[N][N];
int r[N], c[N];
bool vis[N][N];
void DFS(int x, int y) {
vis[x][y] = 1;
for (int d = 0; d < 4; ++d) {
int xx = x + dir[d][0], yy = y + dir[d][1];
if (xx >= 1 && xx <= n && yy >= 1 && yy <= m && !vis[xx][yy] &&
s[xx][yy] == '#')
DFS(xx, yy);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
int cnt = 0;
for (int j = 1; j <= m; ++j) {
if (s[i][j - 1] != '#' && s[i][j] == '#') ++cnt;
if (s[i][j] == '#') r[i] = 1, c[j] = 1;
}
if (cnt > 1) puts("-1"), exit(0);
}
for (int i = 1; i <= m; ++i) {
int cnt = 0;
for (int j = 1; j <= n; ++j)
if (s[j - 1][i] != '#' && s[j][i] == '#') ++cnt;
if (cnt > 1) puts("-1"), exit(0);
}
for (int i = 1; i <= n; ++i)
if (r[i] == 0) {
for (int j = 1; j <= m; ++j)
if (c[j] != 1) r[i] = 2, c[j] = 2;
if (r[i] == 0) puts("-1"), exit(0);
}
for (int i = 1; i <= m; ++i)
if (c[i] == 0) {
for (int j = 1; j <= n; ++j)
if (r[j] != 1) c[i] = 2, r[j] = 2;
if (c[i] == 0) puts("-1"), exit(0);
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (s[i][j] == '#' && !vis[i][j]) ++ans, DFS(i, j);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int fa[1000005][21];
int st[1000005], en[1000005], Last[1000005];
char str[10 * 1000005];
int get(int L, int R, int len) {
int res = L;
while (L <= R) {
int mid = (L + R) >> 1;
if (en[mid] <= len) {
res = mid;
L = mid + 1;
} else
R = mid - 1;
}
return res;
}
void solve(int v, int step, int &res) {
int i;
res = v;
for (i = 21 - 1; i >= 0; i--)
if (step >= (1 << i)) {
if (fa[v][i] != -1) {
res = fa[v][i];
v = fa[v][i];
step -= 1 << i;
}
}
}
int main() {
int n, R, C, i, j, k;
while (scanf("%d %d %d", &n, &R, &C) != EOF) {
gets(str);
gets(str);
int len = strlen(str);
k = 1;
for (i = 0; i < len; i++) {
st[k] = i;
j = i;
while (j < len && str[j] != ' ') j++;
en[k++] = j - 1;
i = j;
}
memset(fa, -1, sizeof(fa));
for (i = 1; i <= n; i++) {
if (en[i] - st[i] + 1 <= C) {
fa[i][0] = get(i, n, st[i] + C - 1) + 1;
} else
fa[i][0] = -1;
}
for (i = n; i >= 1; i--) {
if (fa[i][0] == -1) continue;
for (j = 1; j < 21; j++) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
if (fa[i][j] == -1) break;
}
}
int ans = 0, x = 0;
for (i = 1; i <= n; i++) {
if (fa[i][0] == -1) continue;
solve(i, R, Last[i]);
if (Last[i] - i > ans) {
ans = Last[i] - i;
x = i;
}
}
for (i = 0; i < R; i++) {
if (x != -1 && fa[x][0] != -1) {
for (j = st[x]; j <= en[fa[x][0] - 1]; j++) printf("%c", str[j]);
}
puts("");
x = fa[x][0];
if (x == -1) break;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum;
scanf("%d", &sum);
while (sum--) {
int a, b;
scanf("%d %d", &a, &b);
if (a >= b) {
printf("YES\n");
} else if (a == 1 && b != 1) {
printf("NO\n");
} else if (a <= 3 && b > 3) {
printf("NO\n");
} else {
printf("YES\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
scanf("%d", &x);
printf("%d 2\n1 2\n", 2 * x - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 5000005, N = 1000005;
int n, i, w, h, pe, k, j, L, st, erk, b, res, rx, a[N], t[N], d[N];
int as, p[N][23], qa, in, q[N][23];
char c[M];
vector<char> s[N];
vector<int> ma[N];
int main() {
scanf("%d%d%d", &n, &h, &w);
w++;
for (i = 1; i <= n; ++i) {
c[0] = '\0';
scanf("%s", c);
pe = strlen(c);
for (j = 0; j < pe; ++j) {
s[i].push_back(c[j]);
}
a[i] = pe + 1;
}
for (i = 1; i <= n; ++i) {
d[i] = a[i] + d[i - 1];
}
st = 0;
for (i = 1; i <= n; ++i) {
while (d[i] - d[st] > w) {
st++;
}
t[i] = st;
}
as = 1;
while (as < n) {
as = as * 2;
L++;
}
for (i = 1; i <= n; ++i) {
p[i][0] = t[i];
q[i][0] = 1;
if (i == t[i]) q[i][0] = 0;
for (j = 1; j <= L; ++j) {
p[i][j] = p[p[i][j - 1]][j - 1];
q[i][j] = q[i][j - 1] + q[p[i][j - 1]][j - 1];
}
}
res = 0;
rx = 0;
for (i = 1; i <= n; ++i) {
b = i;
erk = 0;
for (j = L; j >= 0; --j) {
if (erk + q[b][j] <= h) {
erk = erk + q[b][j];
b = p[b][j];
}
}
if (i - b > res) {
res = i - b;
rx = i;
}
}
if (rx != 0) {
qa = 0;
for (i = rx;; i = t[i]) {
if (i == t[i] || qa == h) break;
qa++;
for (j = t[i] + 1; j <= i; ++j) {
ma[qa].push_back(j);
}
}
}
for (i = qa; i >= 1; --i) {
in = ma[i][0];
for (k = 0; k < s[in].size(); ++k) {
printf("%c", s[in][k]);
}
for (j = 1; j < ma[i].size(); ++j) {
in = ma[i][j];
printf(" ");
for (k = 0; k < s[in].size(); ++k) {
printf("%c", s[in][k]);
}
}
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
string t, hh, a, h, s, aa;
cin >> t;
for (int i = 0; i < t.size(); i++) {
if (t[i] != 'a') a.push_back(t[i]);
}
for (int i = 0; i < a.size() / 2; i++) {
h.push_back(a[i]);
}
for (int i = a.size() / 2; i < a.size(); i++) hh.push_back(a[i]);
if (string(h) != string(hh)) {
cout << ":(" << endl;
} else {
for (int i = 0; i < t.size() - h.size(); i++) s.push_back(t[i]);
for (int i = t.size() - h.size(); i < t.size(); i++) {
aa.push_back(t[i]);
}
if (aa.find("a") != std::string::npos) {
cout << ":(";
} else
cout << s << endl;
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.