solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int *a, *b;
int calc(int q) {
int lo = 0, hi = n - 1;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (a[mid] > q)
hi = mid - 1;
else
lo = mid;
}
if (a[lo] <= q) return lo + 1;
return lo;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
a = new int[n];
b = new int[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
for (int i = 0; i < m; i++) {
cout << calc(b[i]) << " ";
}
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cctype>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll)INF*INF
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define loop(i,a,n) for(int i=a;i<(n);i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
typedef vector<pii> vp;
int gcd(int a, int b){
if(b==0) return a;
return gcd(b,a%b);
}
int lcm(int a, int b){
return a/gcd(a,b)*b;
}
signed main(void) {
string s;
while(cin >> s, s != "0"){
int n = s.size();
int t = 0;
int ans = 0;
vi cnt(11);
cnt[0]++;
rep(i,n){
int a = s[i]-'0';
if(i%2)a = 11 - a;
t = t + a;
t %= 11;
ans += cnt[t] - (s[i]=='0');
if(s[i] > '0')cnt[t]++;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
int arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
int temp = 0;
for (int j = 0; j < m; j++) {
if (arr[i][j] == 1) {
ans += (j - temp);
temp = j + 1;
}
}
}
for (int i = 0; i < n; i++) {
int temp = m - 1;
for (int j = m - 1; j >= 0; j--) {
if (arr[i][j] == 1) {
ans += (temp - j);
temp = j - 1;
}
}
}
for (int j = 0; j < m; j++) {
int temp = 0;
for (int i = 0; i < n; i++) {
if (arr[i][j] == 1) {
ans += (i - temp);
temp = i + 1;
}
}
}
for (int j = 0; j < m; j++) {
int temp = n - 1;
for (int i = n - 1; i >= 0; i--) {
if (arr[i][j] == 1) {
ans += (temp - i);
temp = i - 1;
}
}
}
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[65];
int main() {
int n, t, k, o;
cin >> t;
while (t--) {
cin >> n >> k;
memset(arr, 0, sizeof(arr));
o = 1;
for (long long i = 1, temp, cnt; i <= n; i++) {
cin >> temp;
cnt = 0;
while (temp) {
arr[cnt] += temp % k;
temp /= k;
if (arr[cnt] >= 2) o = 0;
cnt++;
}
}
if (o)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
if (n / (2 * (k + 1)) > 0) {
long long res = n / (2 * (k + 1));
cout << res << " " << res * k << " " << n - (res + res * k);
} else
cout << "0 0 " << n;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 998244353;
const ll INF = 1001001001;
const int MAX = 510000;
int main() {
int n, m;
cin >> n >> m;
vector<int> want(n);
for (int i = 0; i < n; i++) cin >> want[i];
vector<pair<int, int>> sale(m);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
sale[i] = {a, b};
}
ll ok = 0, ng = 0;
for (int i = 0; i < n; i++) {
ok += want[i] * 2;
}
while (ok - ng > 1) {
ll mid = (ok + ng) / 2;
auto f = [&]() {
vector<int> lst(n, -1);
for (int i = 0; i < m; i++) {
if (sale[i].first < mid)
lst[sale[i].second] = max(sale[i].first, lst[sale[i].second]);
}
vector<vector<int>> off(200001);
for (int i = 0; i < n; i++) {
if (lst[i] != -1) {
off[lst[i]].push_back(i);
}
}
vector<int> need = want;
int mny = 0;
for (int i = 0; i < mid; i++) {
mny++;
if (i > 200000) continue;
for (int v : off[i]) {
if (mny >= need[v]) {
mny -= need[v];
need[v] = 0;
} else {
need[v] -= mny;
mny = 0;
break;
}
}
}
return accumulate(need.begin(), need.end(), 0) * 2 <= mny;
};
if (f())
ok = mid;
else
ng = mid;
}
cout << ok << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[10000];
int f(int s) {
if (s < 0) {
return -1000000000;
}
if (s == 0) return 1;
if (dp[s]) return dp[s];
dp[s] = max(f(s - a), max(f(s - b), f(s - c))) + 1;
return dp[s];
}
int main() {
cin >> n >> a >> b >> c;
cout << f(n) - 1;
}
| 1 |
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[200010];
long long inv[200010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1) % mod;
}
}
long long ko[11] = {};
vector<long long> p[11][11], q[11][11];
long long ju[40];
long long solve(pair<string, long long> X) {
string s = X.first;
reverse(s.begin(), s.end());
long long l = X.second;
long long ans = 0;
for (long long i = 1; i <= 10; i++) {
long long e = 0;
for (long long j = 0; j < l; j++) {
e += ju[q[i][l][j]] * (s[j] - '0') % mod;
e += ju[p[l][i][j]] * (s[j] - '0') % mod;
e %= mod;
}
e *= ko[i];
e %= mod;
ans += e;
ans %= mod;
}
return ans;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
cin >> n;
mod = 998244353;
vector<pair<string, long long>> ve;
ju[0] = 1;
for (long long i = 1; i < 40; i++) {
ju[i] = ju[i - 1] * 10 % mod;
}
for (long long l1 = 1; l1 <= 10; l1++)
for (long long r1 = 1; r1 <= 10; r1++) {
long long f = 0;
for (long long i = 0;; i++) {
if (i >= l1 && i >= r1) break;
if (i < l1) {
p[l1][r1].push_back(f);
f++;
}
if (i < r1) {
q[l1][r1].push_back(f);
f++;
}
}
}
for (long long i = 0; i < n; i++) {
long long y;
cin >> y;
string s = itos(y);
ve.push_back(make_pair(s, s.length()));
ko[s.length()]++;
}
long long ans = 0;
for (auto v : ve) {
long long r = solve(v);
ans += r;
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first > b.first;
else
return (a.second > b.second);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, x, ma;
cin >> n >> m;
if (m == 0) {
cout << n << ' ' << n << endl;
return 0;
}
long long int l = (n * (n - 1)) / 2;
for (long long int i = 0; i <= n; i++) {
x = n - i;
ma = x * (x - 1) / 2;
if (ma < m) {
ma = i - 1;
break;
}
}
long long int mi = n - (m * 2);
cout << max(0ll, mi) << ' ' << ma << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long n, k, a, b, c, deg[20000], temp;
vector<long> ans1, ans2, ans3;
vector<pair<long, long> > g[20000];
long lst;
long dfs(long v) {
lst = v;
if (g[v].size() == 0) return 1e9;
return min(g[v][0].second, dfs(g[v][0].first));
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cin >> a >> b >> c;
g[a].push_back(make_pair(b, c));
deg[b]++;
}
for (int i = 1; i <= n; i++) {
if (deg[i]) continue;
if (g[i].size() == 0) continue;
temp = dfs(i);
ans1.push_back(i);
ans2.push_back(lst);
ans3.push_back(temp);
}
cout << ans1.size() << endl;
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << " " << ans2[i] << " " << ans3[i] << endl;
}
cin.get();
cin.get();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n == 5)
printf("1");
else
printf("%d", n % 3 + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x;
cin >> n >> m;
int a[101] = {0};
for (int i = 0; i < m; i++) {
cin >> x;
a[x]++;
}
sort(a, a + 101);
int mx = 0;
for (int i = 1; i <= 100; i++) {
int cnt = 0;
for (int j = 1; j <= 100; j++) {
cnt += a[j] / i;
}
if (cnt >= n) mx = i;
}
cout << mx << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bitset<520> f[62][2][520], tmp, g;
long long ans = 0;
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
f[0][c][a][b] = 1;
}
for (int i = 1; i <= 60; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) {
if (f[i - 1][0][j][k]) f[i][0][j] |= f[i - 1][1][k];
if (f[i - 1][1][j][k]) f[i][1][j] |= f[i - 1][0][k];
}
for (int i = 1; i <= n; i++)
if (f[60][0][1][i]) {
printf("-1");
return 0;
}
int tag = 0;
g[1] = 1;
ans = 0;
for (int len = 59; len >= 0; len--) {
tmp = 0;
for (int i = 1; i <= n; i++)
if (g[i]) tmp |= f[len][tag][i];
if (tmp.count()) {
g = tmp;
ans += (1ll << len);
tag ^= 1;
}
}
if (ans > (long long)(1e18))
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int P[100009][21], ans[100009], n, k;
string s;
void build_suf() {
for (int i = 0; i < n; i++) P[i][0] = s[i] - 'a';
for (int i = 1; i <= k; i++) {
vector<pair<pair<int, int>, int> > v;
for (int j = 0; j < n; j++) {
int left = P[j][i - 1], rigt;
if (j + (1 << (i - 1)) >= n)
rigt = -1;
else
rigt = P[j + (1 << (i - 1))][i - 1];
v.push_back(make_pair(make_pair(left, rigt), j));
}
sort(v.begin(), v.end());
P[v[0].second][i] = 0;
int c = 0;
for (int j = 1; j < v.size(); j++) {
if (v[j].first.first != v[j - 1].first.first or
v[j].first.second != v[j - 1].first.second)
++c;
P[v[j].second][i] = c;
}
}
vector<pair<int, int> > g;
for (int i = 0; i < n; i++) g.push_back(make_pair(P[i][k], i));
sort(g.begin(), g.end());
for (int i = 0; i < g.size(); i++) ans[i] = g[i].second;
}
int lcp[100009], arr[100009], l[100009], r[100009];
void build_lcp() {
for (int i = 0; i < n - 1; i++) {
int a = ans[i], b = ans[i + 1], res = 0;
for (int j = k; j >= 0; j--) {
if (a < n and b < n and P[a][j] == P[b][j]) {
a += (1 << j);
b += (1 << j);
res += (1 << j);
}
}
lcp[i] = res;
}
}
int main() {
cin >> s;
n = s.size();
k = log2(n);
build_suf();
build_lcp();
stack<int> s;
int a = n - 1;
for (int i = 1; i <= a; i++) arr[i] = lcp[i - 1];
arr[0] = -1000000007;
s.push(0);
for (int i = 1; i <= a; i++) {
while (!s.empty() and arr[s.top()] >= arr[i]) {
r[s.top()] = i - 1;
s.pop();
}
l[i] = s.top() + 1;
s.push(i);
r[i] = a;
}
long long ans = 0;
for (int i = 1; i <= a; i++) {
long long k1 = (r[i] - i + 1LL);
long long k2 = (i - l[i] + 1LL);
ans += k1 * k2 * arr[i] * 1LL;
}
cout << ans + (n * (n + 1LL) / 2) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 9 + (3e5);
int a[N], b[N];
int cnt[N << 1];
pair<int, int> p[N << 1];
vector<pair<int, int> > vec;
int main() {
int n, w;
scanf("%d%d", &n, &w);
for (int i = 0; i < n; ++i) {
scanf("%d%d", a + i, b + i);
a[i] <<= 1;
b[i] <<= 1;
if (a[i] <= b[i] >> 1) {
p[i << 1].first = a[i];
p[i << 1 | 1].first = b[i] - a[i];
} else {
p[i << 1].first = p[i << 1 | 1].first = b[i] >> 1;
}
p[i << 1].second = i << 1;
p[i << 1 | 1].second = i << 1 | 1;
}
sort(p, p + (n << 1));
long long ans = 0, tmp, mi;
for (int i = 0; i < w; ++i) ans += p[i].first, cnt[p[i].second] = 1;
if ((p[w - 1].second & 1) == 0 && a[p[w - 1].second >> 1] != p[w - 1].first) {
ans = ans - p[w - 1].first + a[p[w - 1].second >> 1];
mi = ans;
vec.clear();
for (int i = 0; i < n; ++i)
if (i != p[w - 1].second >> 1) {
if (!cnt[i << 1]) {
tmp = ans - a[p[w - 1].second >> 1] + a[i];
if (tmp < mi) {
mi = tmp;
vec.clear();
vec.push_back(make_pair(p[w - 1].second, 0));
vec.push_back(make_pair(i << 1, 1));
}
} else if (!cnt[i << 1 | 1]) {
tmp = ans - a[p[w - 1].second >> 1] + b[i] - a[i];
if (tmp < mi) {
mi = tmp;
vec.clear();
vec.push_back(make_pair(p[w - 1].second, 0));
vec.push_back(make_pair(i << 1 | 1, 1));
}
tmp = ans - a[i] + b[p[w - 1].second >> 1] - a[p[w - 1].second >> 1];
if (tmp < mi) {
mi = tmp;
vec.clear();
vec.push_back(make_pair(i << 1, 0));
vec.push_back(make_pair(p[w - 1].second | 1, 1));
}
} else {
tmp = ans + a[i] - b[i] + b[p[w - 1].second >> 1] -
a[p[w - 1].second >> 1];
if (tmp < mi) {
mi = tmp;
vec.clear();
vec.push_back(make_pair(i << 1 | 1, 0));
vec.push_back(make_pair(p[w - 1].second | 1, 1));
}
}
}
ans = mi;
for (int i = 0; i < (int)vec.size(); ++i) cnt[vec[i].first] = vec[i].second;
}
printf("%I64d\n", ans >> 1);
for (int i = 0; i < n; ++i) printf("%d", cnt[i << 1] + cnt[i << 1 | 1]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
map<int, int> nxt[N];
int link[N], len[N], cnt = 1, las = 1, n, id[N], f[N][19], ll[N];
int s[N];
void insert(int c) {
int cur = ++cnt, p = las;
len[cur] = len[las] + 1;
las = cur;
for (; p && nxt[p].count(c) == 0; p = link[p]) nxt[p][c] = cur;
if (!p)
link[cur] = 1;
else {
int q = nxt[p][c];
if (len[q] == len[p] + 1)
link[cur] = q;
else {
int clone = ++cnt;
len[clone] = len[p] + 1;
link[clone] = link[q];
link[q] = link[cur] = clone;
nxt[clone] = nxt[q];
for (; nxt[p][c] == q; p = link[p]) nxt[p][c] = clone;
}
}
}
struct segNode {
int l, r, v = 0;
} t[N * 30];
int root[N], sc;
vector<int> a[N];
void update(int &now, int l, int r, int pos) {
if (!now) now = ++sc;
t[now].v++;
if (l == r) return;
if (pos <= (l + r) / 2)
update(t[now].l, l, (l + r) / 2, pos);
else
update(t[now].r, (l + r) / 2 + 1, r, pos);
t[now].v = t[t[now].l].v + t[t[now].r].v;
}
int merge(int x, int y, int l, int r) {
if (x == 0 || y == 0) {
return x + y;
}
int now = ++sc;
t[now].v = t[x].v + t[y].v;
if (l == r) return now;
t[now].l = merge(t[x].l, t[y].l, l, (l + r) / 2);
t[now].r = merge(t[x].r, t[y].r, (l + r) / 2 + 1, r);
return now;
}
int query(int now, int l, int r, int x, int y) {
if (x <= l && r <= y) return t[now].v;
int ans = 0;
if (x <= (l + r) / 2) ans += query(t[now].l, l, (l + r) / 2, x, y);
if (y > (l + r) / 2) ans += query(t[now].r, (l + r) / 2 + 1, r, x, y);
return ans;
}
void make_st() {
for (int i = 2; i <= cnt; i++) f[i][0] = link[i], a[link[i]].push_back(i);
int range = log2(cnt);
for (int i = 1; i <= range; i++)
for (int j = 2; j <= cnt; j++) f[j][i] = f[f[j][i - 1]][i - 1];
}
void dfs_for_merge(int now) {
for (auto to : a[now]) {
dfs_for_merge(to);
root[now] = merge(root[now], root[to], 1, n);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", s + i);
for (int i = 1; i < n; i++) {
int c = s[i + 1] - s[i];
insert(c);
update(root[las], 1, n, i + 1);
}
make_st();
dfs_for_merge(1);
int now = 1, nowl = 0;
for (int i = 1; i < n; i++) {
if (nxt[now].count(s[i] - s[i + 1]) == 0) {
while (now && nxt[now].count(s[i] - s[i + 1]) == 0) {
now = link[now];
}
if (!now)
now = 1, nowl = 0;
else
nowl = len[now] + 1, now = nxt[now][s[i] - s[i + 1]];
} else
now = nxt[now][s[i] - s[i + 1]], nowl++;
id[i + 1] = now;
ll[i + 1] = nowl;
}
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
int l = y - x + 1;
if (l == 1)
printf("%d\n", n - 1);
else {
int p = id[y];
if (l > ll[y] + 1) {
printf("0\n");
continue;
}
for (int i = 18; i >= 0; i--) {
if (len[f[p][i]] >= l - 1) p = f[p][i];
}
int ans = 0;
if (l <= x - 1) ans += query(root[p], 1, n, l, x - 1);
if (y + l <= n) ans += query(root[p], 1, n, y + l, n);
printf("%d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 9;
long long MOD, T;
long long p10[N], inv[N], sz[N], mrk[N], ans = 0;
vector<pair<long long, long long> > adj[N];
map<long long, long long> mp;
long long TOTIENT(long long x) {
long long ans = x;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
while (x % i == 0) x /= i;
ans -= (ans / i);
}
}
if (x > 1) ans -= (ans / x);
return ans;
}
long long POW(long long a, long long b) {
if (b == 0) return 1;
long long ans = POW(a, b / 2);
ans = (ans * ans) % MOD;
if (b % 2) ans = (ans * a) % MOD;
return ans;
}
void DFSSZ(long long u, long long par) {
sz[u] = 1;
for (pair<long long, long long> v : adj[u])
if (!mrk[v.first] && v.first != par)
DFSSZ(v.first, u), sz[u] += sz[v.first];
}
long long CENT(long long u, long long par, long long num) {
for (pair<long long, long long> v : adj[u])
if (!mrk[v.first] && v.first != par && sz[v.first] * 2 > num)
return CENT(v.first, u, num);
return u;
}
void DFS1(long long u, long long par, long long x, long long dis, long long t) {
if (t)
mp[x]++;
else
mp[x]--;
if (!t && x == 0) ans++;
for (pair<long long, long long> v : adj[u])
if (!mrk[v.first] && v.first != par)
DFS1(v.first, u, (x + v.second * p10[dis]) % MOD, dis + 1, t);
}
void DFS2(long long u, long long par, long long x, long long dis) {
ans += mp[((MOD - x) * inv[dis]) % MOD];
for (pair<long long, long long> v : adj[u])
if (!mrk[v.first] && v.first != par)
DFS2(v.first, u, (x * 10 + v.second) % MOD, dis + 1);
}
void DECOMPOSE(long long u) {
DFSSZ(u, u);
long long root = CENT(u, u, sz[u]);
mrk[root] = 1;
for (pair<long long, long long> v : adj[root])
if (!mrk[v.first]) DECOMPOSE(v.first);
mp.clear();
mp[0]++;
for (pair<long long, long long> v : adj[root])
if (!mrk[v.first]) DFS1(v.first, root, v.second % MOD, 1, 1);
for (pair<long long, long long> v : adj[root])
if (!mrk[v.first])
DFS1(v.first, root, v.second % MOD, 1, 0),
DFS2(v.first, root, v.second % MOD, 1),
DFS1(v.first, root, v.second % MOD, 1, 1);
mrk[root] = 0;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n >> MOD;
T = TOTIENT(MOD);
p10[0] = 1;
for (long long i = 1; i < N; i++) p10[i] = (p10[i - 1] * 10) % MOD;
for (long long i = 0; i < N; i++) inv[i] = POW(p10[i], T - 1);
for (long long i = 1; i < n; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
if (MOD == 1) return cout << n * n - n, 0;
DECOMPOSE(0);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Edge {
long long from, to;
T cost;
Edge(long long to, T cost) : from(-1), to(to), cost(cost) {}
Edge(long long from, long long to, T cost) : from(from), to(to), cost(cost) {}
bool operator<(const Edge &e) const { return cost < e.cost; }
bool operator>(const Edge &e) const { return cost > e.cost; }
};
template <typename T>
using Edges = vector<Edge<T> >;
template <typename T>
struct Dinic {
T INF = 1 << 28;
struct FlowEdge {
long long to, rev;
T cap;
FlowEdge() {}
FlowEdge(long long to, T cap, long long rev) : to(to), cap(cap), rev(rev) {}
};
long long n;
vector<vector<FlowEdge> > G;
vector<long long> level;
vector<long long> iter;
Dinic() {}
Dinic(long long sz) : n(sz), G(n), level(n), iter(n) {}
void add_edge(long long from, long long to, T cap) {
G[from].push_back(FlowEdge(to, cap, G[to].size()));
G[to].push_back(FlowEdge(from, cap, G[from].size() - 1));
}
void bfs(long long s) {
fill(level.begin(), level.end(), -1);
queue<long long> Q;
level[s] = 0;
Q.push(s);
while (!Q.empty()) {
long long v = Q.front();
Q.pop();
for (long long i = 0; i < (long long)G[v].size(); i++) {
FlowEdge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
Q.push(e.to);
}
}
}
}
T dfs(long long v, long long t, T f) {
if (v == t) return f;
for (long long &i = iter[v]; i < (long long)G[v].size(); i++) {
FlowEdge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
T d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
T max_flow(long long s, long long t, long long lim) {
T flow = 0;
while (1) {
bfs(s);
if (level[t] < 0 || lim == 0) return flow;
fill(iter.begin(), iter.end(), 0);
T f;
while ((f = dfs(s, t, lim)) > 0) {
flow += f;
lim -= f;
}
}
}
T max_flow(long long s, long long t) { return max_flow(s, t, INF); }
vector<bool> get_cut() {
vector<bool> res(n);
for (long long i = 0; i < n; i++) {
res[i] = (level[i] == -1);
}
return res;
}
};
template <typename T>
struct GomoryHu {
long long n;
Dinic<T> dinic;
Edges<T> GH;
GomoryHu() {}
GomoryHu(long long sz) : n(sz), dinic(n) {}
void add_edge(long long from, long long to, T cap) {
dinic.add_edge(from, to, cap);
}
Edges<T> build() {
Edges<T> ret;
vector<long long> pr(n, 0);
Dinic<T> tmp = dinic;
for (long long i = 1; i < n; i++) {
dinic = tmp;
T flow = dinic.max_flow(i, pr[i]);
vector<bool> cut = dinic.get_cut();
for (long long j = i + 1; j < n; j++) {
if (cut[j] == cut[i] && pr[j] == pr[i]) {
pr[j] = i;
}
}
ret.emplace_back(Edge<T>(i, pr[i], flow));
}
return GH = ret;
}
};
struct UnionFind {
long long n;
vector<long long> r, p;
UnionFind() {}
UnionFind(long long sz) : n(sz), r(sz, 1), p(sz, 0) {
iota(p.begin(), p.end(), 0);
}
long long find(long long x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(long long x, long long y) { return find(x) == find(y); }
void unite(long long x, long long y) {
x = find(x);
y = find(y);
if (x == y) return;
r[x] += r[y];
p[y] = x;
}
};
signed main() {
long long n, m;
cin >> n >> m;
GomoryHu<long long> gh(n);
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
gh.add_edge(a, b, c);
}
Edges<long long> tree = gh.build();
long long sum = 0;
for (Edge<long long> e : tree) {
sum += e.cost;
}
cout << sum << endl;
vector<pair<long long, long long> > edges;
for (long long i = 0; i < n - 1; i++) {
edges.emplace_back(tree[i].cost, i);
}
sort(edges.begin(), edges.end(), greater<pair<long long, long long> >());
UnionFind uf(n);
vector<vector<long long> > seq(n);
for (long long i = 0; i < n; i++) seq[i].emplace_back(i);
for (long long i = 0; i < n - 1; i++) {
Edge<long long> e = tree[edges[i].second];
long long x = uf.find(e.from), y = uf.find(e.to);
uf.unite(x, y);
seq[x].insert(seq[x].end(), seq[y].begin(), seq[y].end());
}
vector<long long> ans = seq[uf.find(0)];
for (long long i = 0; i < n; i++) {
if (i) cout << " ";
cout << ans[i] + 1;
}
cout << endl;
return 0;
}
| 5 |
#include <iostream>
using namespace std;
using ll = long long;
int main() {
int n; ll t;
cin >> n >> t;
ll a = 0, b = 0;
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
b = max(x, b);
a += x;
if (t < a) {
cout << 1 << endl;
} else {
cout << (t - a) / b + 2 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{
long long int n;
cin >> n;
long long int a[n], i, k = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n - 1; i++) {
if (a[i - 1] == 1 && a[i] == 0 && a[i + 1] == 1) {
a[i + 1] = 0;
k = k + 1;
}
}
cout << k << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int n, pos;
bool flag;
} num;
int main() {
int n;
num arr[3030];
bool ppflag[3030];
int pp[3030];
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
arr[i].n = a;
arr[i].flag = false;
arr[i].pos = i;
pp[i] = i;
ppflag[i] = false;
}
for (int i = 0; i < n - 1; ++i) {
for (int j = i + 1; j < n; ++j) {
if (arr[i].n > arr[j].n) {
pp[arr[i].pos] = j;
pp[arr[j].pos] = i;
num tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
vector<pair<int, int> > op;
printf("%d\n", n);
for (int i = 0; i < n; ++i) {
int p = pp[i];
if (ppflag[i]) continue;
while (true) {
if (ppflag[p]) break;
ppflag[p] = true;
printf("%d %d\n", i, p);
p = pp[p];
}
}
}
| 1 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int f(string s, string t) {
int j = 0;
for (int i = 0; i < s.size() && j < t.size(); i++) {
if (s[i] == t[j]) j++;
}
return (s.size() - j) + (t.size() - j);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s = to_string(n);
int ans = 2e9;
for (int i = 0; i < 60; i++) {
ans = min(ans, f(s, to_string((ll)1 << i)));
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, r, l, cek1, k;
bool cek;
int main() {
scanf("%d", &n);
n = n * 2 + 1;
r = n;
l = n;
cek1 = 1;
int x = n + n - 1;
for (int i = 1; i <= n; i++) {
k = 0;
cek = true;
for (int j = 1; j <= r; j++) {
if (j >= l && cek) {
printf("%d", k);
j <= x / 2 ? k++ : k--;
} else
printf(" ");
if (j >= l) {
if (!cek)
cek = true;
else
cek = false;
}
}
printf("\n");
if (i > n / 2) cek1 = 0;
if (cek1) {
l -= 2;
r += 2;
}
if (!cek1) {
l += 2;
r -= 2;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, c[6][223456], child[223456];
double ans[223456], res = 0.0;
vector<pair<int, double> > ke[223456];
pair<pair<int, int>, double> way[223456];
int dad[223456];
void dfs1(int u, int par) {
child[u] = 1;
dad[u] = par;
for (int i = 0; i < ke[u].size(); i++) {
int v = ke[u][i].first;
if (v == par) continue;
dfs1(v, u);
child[u] += child[v];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int u, v;
double w;
for (int i = 1; i < n; i++) {
cin >> u >> v >> w;
ke[u].push_back(make_pair(v, w));
ke[v].push_back(make_pair(u, w));
way[i] = make_pair(make_pair(u, v), w);
}
dfs1(1, 0);
res = 0;
for (int i = 1; i < n; i++) {
int u1 = way[i].first.first;
int u2 = way[i].first.second;
if (dad[u2] == u1) swap(u1, u2);
double we = way[i].second;
res += we * (child[u1] * (n - child[u1]));
}
int q;
cin >> q;
while (q--) {
cin >> u >> w;
int u1 = way[u].first.first;
int u2 = way[u].first.second;
if (dad[u2] == u1) swap(u1, u2);
double we = way[u].second;
res -= (we - w) * double(child[u1] * (n - child[u1]));
way[u].second = w;
cout << fixed << setprecision(8) << res / double(n * (n - 1) / 6.0) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
vector<pair<long long, long long>> v[300005];
vector<long long> l(300005, 0), a(300005);
long long ans = LLONG_MIN;
void traverse(int x, int parent) {
l[x] = a[x];
vector<long long> d;
d.push_back(0);
d.push_back(0);
for (int i = 0; i < v[x].size(); ++i) {
if (v[x][i].first == parent) continue;
traverse(v[x][i].first, x);
l[x] = max(l[x], a[x] + l[v[x][i].first] - v[x][i].second);
d.push_back(l[v[x][i].first] - v[x][i].second);
}
sort(d.rbegin(), d.rend());
ans = max(ans, d[0] + d[1] + a[x]);
}
int main() {
fast();
long long n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) {
long long x, y, c;
cin >> x >> y >> c;
v[x].push_back({y, c});
v[y].push_back({x, c});
}
traverse(1, 0);
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[3333];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (a[i] < a[j]) {
ans++;
}
}
}
if (ans & 1)
ans = (ans << 1) - 1;
else
ans <<= 1;
printf("%.6f\n", (double)ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int t[5555], a[5555], st[33];
char c[5555];
int main() {
#pragma comment(linker, "/STACK:268435456")
#pragma warning(disable : 4996)
int i, j, n, x;
bool k;
gets(c);
n = strlen(c);
for (i = 0; i < 33; i++) {
st[i] = 0;
}
for (i = 0; i < n; i++) {
st[(int)(c[i] - 'a')]++;
}
gets(c);
for (i = 0; i < strlen(c); i++) {
t[i] = (int)(c[i] - 'a');
a[i] = -1;
}
for (i = strlen(c); i < n; i++) {
t[i] = -1;
a[i] = -1;
}
k = true;
for (i = 0; i < n && k; i++) {
if (st[t[i]] > 0) {
a[i] = t[i];
st[t[i]]--;
} else {
x = i;
k = false;
}
}
if (k) {
x = n - 1;
}
k = true;
while (k && x >= 0) {
if (a[x] != -1) {
st[a[x]]++;
}
for (j = t[x] + 1; j < 33 && k; j++) {
if (st[j] > 0) {
k = false;
a[x] = j;
st[j]--;
}
}
x--;
}
if (k) {
printf("-1");
} else {
for (i = x + 2; i < n; i++) {
k = true;
for (j = 0; j < 33 && k; j++) {
if (st[j] > 0) {
a[i] = j;
st[j]--;
k = false;
}
}
}
for (i = 0; i < n; i++) {
printf("%c", (char)(a[i] + 'a'));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
x = 0;
char c = getchar();
for (; c < 48; c = getchar())
;
for (; c > 47; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
}
void read(long long &x) {
x = 0;
char c = getchar();
for (; c < 48; c = getchar())
;
for (; c > 47; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
}
long long a[20], b[20];
int c[20], d[20], n;
int chk(long long x) {
int res = 0;
long long i;
for (i = 2; i * i <= x; i++) {
for (; x % i == 0; res++, x /= i)
;
}
return res + (x > 1);
}
int res, fa[20], sum;
void dfs(int x, int sum) {
if (sum > res) return;
if (x > n) {
int i, cnt = 0;
for (i = 1; i <= n; i++) {
if (!fa[i]) cnt++;
}
if (cnt >= 2) sum++;
if (res > sum) res = sum;
return;
}
if (c[x] == 1) {
sum++;
} else {
if (d[x] == 0)
sum++;
else
sum++, sum += d[x];
}
dfs(x + 1, sum);
for (int i = x + 1; i <= n; i++)
if (b[i] % a[x] == 0) {
fa[x] = i;
b[i] /= a[x];
d[i] -= c[x];
dfs(x + 1, sum);
b[i] *= a[x];
d[i] += c[x];
}
fa[x] = 0;
}
int main() {
read(n);
int i;
for (i = 1; i <= n; i++) {
read(a[i]);
}
res++;
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
b[i] = a[i];
res += (d[i] = c[i] = chk(a[i])) + 1;
}
dfs(1, 0);
printf("%d\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long answer = 0, i;
for (i = 1; i <= k && i <= n / 2; i++) {
answer += (2 * (n - 2 * i) + 1);
}
cout << answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int solve() {
int x;
cin >> x;
if (x < 9) return 0;
while (x % 10 != 9) x--;
return x / 10 + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) cout << solve() << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int n,m,c,d;
int le=0;;
int l[33];
int main()
{
cin>>n>>m;
for(int i=0;i<n;i++)
{
cin>>c;
for(int i=0;i<c;i++)
{
cin>>d;
l[d]++;
}
}
for(int i=1;i<=m;i++)
if(l[i]==n)
le++;
cout<<le;
return 0;
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, k;
string str;
while(cin >> n, n) {
string key = "I";
for(int i=0; i<n; i++) key += "OI";
cin >> k >> str;
int cnt = 0;
for(int i=0; i<k-key.size(); i++) {
if(str.substr(i,key.size()) == key) cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, A = 0, B = 0;
bool ok = false;
cin >> n;
while (n--) {
cin >> a >> b;
A += a;
B += b;
if ((a & 1) != (b & 1)) ok = true;
}
if (!(A & 1) && !(B & 1))
cout << 0;
else if ((A & 1) != (B & 1))
cout << -1;
else if (ok)
cout << 1;
else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long int
#define pll pair<ll, ll>
#define pii pair<int, int>
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
using namespace std;
ll MOD = 998244353;
ll pwr(ll x, ll y) {
ll res = 1;
x = x%MOD;
while (y > 0) {
if (y&1) res = (res*x)%MOD;
y = y>>1;
x = (x*x)%MOD;
}
return res;
}
inline ll addmod(ll a, ll b){
return ((a+b)%MOD);
}
inline ll mulmod(ll a, ll b){
return ((a*b)%MOD);
}
class BIT {
int *bit;
int N;
public:
void update(int x, int val) {
int ind = x;
while (ind <= N) {
bit[ind] += val;
ind += (ind & (-ind));
}
}
BIT(int ar[], int n) {
bit = new int[n+1];
N = n+1;
for (int i = 1; i < N; i++) bit[i] = 0;
for (int i = 1; i < N; i++) update(i, ar[i-1]);
}
int getSum(int x) {
if (x < 0) return 0;
int ind = x+1;
int sum = 0;
while (ind > 0) {
sum += bit[ind];
ind = (ind & (ind-1));
}
return sum;
}
int getValue(int x) {
return getSum(x) - getSum(x-1);
}
void changeElem(int x, int val) {
update(x+1, val-getValue(x));
}
};
int bsh(int val, int ar[], int n) { // return ind such that val >= ar[ind] and val < ar[ind+1]
int a = 0, b = n - 1, c = (a+b)/2;
if (val < ar[0]) return -1;
if (val >= ar[b]) return b;
while (!(val >= ar[c] && val < ar[c+1])) {
if (val < ar[c]) b = c;
else {
if (b-a == 1 && c == a) a = b;
else a = c;
}
c = (a+b)/2;
}
return c;
}
int main () {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int t; cin >> t;
while (t--) {
int x, y;
cin >> x >> y;
cout << x-1 << ' ' << y << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << "\n";
err(++it, args...);
}
const long long MOD = 1e9 + 7, N = 1e3 + 5, inf = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
{
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
;
multiset<int> s;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
}
vector<int> v(n, 0), ans(n, 0);
while (k--) {
int x, y;
cin >> x >> y;
x--;
y--;
if (a[x] > a[y]) {
v[x]--;
} else if (a[x] < a[y]) {
v[y]--;
}
}
map<int, int> m;
int cnt = 0, cf = 0, lst = -1;
for (auto &x : s) {
if (lst != x) {
cnt++;
cnt += cf;
cf = 0;
} else {
cf++;
}
m[x] = cnt - 1;
lst = x;
}
for (int i = 0; i < n; i++) {
int val = m[a[i]];
ans[i] = max(0, val + v[i]);
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, len;
while (cin >> n >> len) {
int ans = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
int vol;
cin >> vol;
if (len % vol == 0) ans = min(ans, len / vol);
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
int len = t.length();
long long last = 1;
long long sum = 0;
int mod = 1e6 + 3;
int a[8] = {8, 9, 10, 11, 12, 13, 14, 15};
string s = "><+-.,[]";
for (int i = len - 1; i >= 0; i--) {
int R;
for (int j = 0; j < 8; j++) {
if (s[j] == t[i]) R = j;
}
sum += (last * a[R]);
sum = sum % mod;
last = last * 16;
last = last % mod;
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, siz[200002], is[200002];
vector<int> e[200002];
int dfs(int u, int p) {
int big = 0;
for (int v : e[u])
if (v != p) {
int t = dfs(v, u);
if (t > 0) return t;
siz[u] += siz[v];
big = max(big, siz[v]);
}
big = max(big, 2 * k - siz[u]);
return big <= (2 * k) / 2 ? u : 0;
}
void dfs2(int u, int p, vector<int> &c) {
for (int v : e[u])
if (v != p) dfs2(v, u, c);
if (is[u]) c.push_back(u);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0, u, v; i < n - 1; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 0, c; i < 2 * k; i++) {
scanf("%d", &c);
siz[c] = is[c] = 1;
}
int cen = dfs(1, -1);
vector<vector<int>> c;
for (int u : e[cen]) {
c.push_back({});
dfs2(u, cen, c.back());
if (c.back().size() == 0) c.pop_back();
}
if (is[cen]) c.push_back({cen});
priority_queue<pair<int, int>> pq;
for (int i = 0; i < c.size(); i++) pq.push({c[i].size(), i});
printf("%d\n%d\n", 1, cen);
while (pq.size() > 0) {
auto pa = pq.top();
pq.pop();
while (c[pa.second].size() > 0) {
auto pa2 = pq.top();
pq.pop();
printf("%d %d %d\n", c[pa.second].back(), c[pa2.second].back(), cen);
c[pa.second].pop_back();
c[pa2.second].pop_back();
if (pa2.first - 1 > 0) pq.push({pa2.first - 1, pa2.second});
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 * 1000 + 5;
int n;
vector<int> arr[Maxn];
int main() {
scanf("%d", &n);
int x, k;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &k);
arr[k - 1].push_back(x);
}
for (int i = 0; i < Maxn; i++) {
int num = -1;
for (int j = 0; j < (int)arr[i].size(); j++) {
if (arr[i][j] > num + 1) {
printf("NO\n");
return 0;
}
if (arr[i][j] == num + 1) num++;
}
}
printf("YES\n");
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
const double EPS = 1e-9;
typedef pair<int, int> P;
typedef unsigned int ui;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
const ld eps=1e-8;
int daytable[1440];
void init() {
rep(i, 1440) {
daytable[i] = 0;
}
}
struct day { int time; char io; int num; };
int trans(string x) {
string s1 = x.substr(0, 2);
string s2 = x.substr(3, 2);
int res; res = stoi(s1) * 60 + stoi(s2);
return res;
}
bool comp(day x, day y) {
if (x.num != y.num) {
return x.num < y.num;
}
return x.time < y.time;
}
int main() {
int n;
while (cin >> n, n) {
string s, t, u; char v;
vector<day> a[365]; int cnt = 0; string memo;
cin >> s >> t >> v >> u;
memo = s;
a[0].push_back({ trans(t),v,stoi(u) });
rep(i, n-1) {
cin >> s >> t >> v >> u;
if (s != memo) {
cnt++; memo = s;
}
a[cnt].push_back({ trans(t),v,stoi(u) });
}
int out[1000] = {};
rep(i, cnt + 1) {
init();
sort(a[i].begin(), a[i].end(), comp);
int len = a[i].size();
for (int j = 0; j < len; j += 2) {
if (a[i][j].num == 0) {
Rep(k, a[i][j].time, a[i][j + 1].time) {
daytable[k] = 1;
}
}
else {
Rep(k, a[i][j].time, a[i][j + 1].time) {
if (daytable[k]) {
out[a[i][j].num]++;
}
}
}
}
}
int ma = 0;
rep(i, 1000) {
ma = max(ma, out[i]);
}
cout << ma << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - 48;
s = getchar();
}
return f * x;
}
const int MN = 105;
int p, n, m;
char s[MN][MN];
int fa[MN * MN];
inline int id(int i, int j) { return (i - 1) * (m + 1) + j; }
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void merge(int x, int y) {
int u = getfa(x), v = getfa(y);
fa[u] = v;
}
inline int ksm(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % p)
if (b & 1) ans = 1ll * ans * a % p;
return ans;
}
int idx[MN * MN];
struct Matrix {
int a[MN * 5][MN * 5], N;
void add(int x, int y) {
if (x == y) return;
a[x][x]++, a[y][y]++;
a[x][y]--, a[y][x]--;
}
int solve() {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) a[i][j] = (a[i][j] + p) % p;
int res = 1;
for (int i = 1; i < N; i++) {
int pos = i;
while (pos < N && !a[pos][i]) pos++;
if (pos >= N) continue;
if (pos != i) res = p - res, swap(a[pos], a[i]);
int inv = ksm(a[i][i], p - 2);
for (int j = i + 1; j < N; j++) {
int tmp = 1ll * inv * a[j][i] % p;
for (int k = i; k < N; k++)
a[j][k] = (a[j][k] - 1ll * a[i][k] * tmp % p + p) % p;
}
}
for (int i = 1; i < N; i++) res = 1ll * res * a[i][i] % p;
return res;
}
} G[2];
int main() {
n = read(), m = read(), p = read();
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= (n + 1) * (m + 1); i++) fa[i] = i;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == '/')
merge(id(i + 1, j), id(i, j + 1));
else if (s[i][j] != '*')
merge(id(i, j), id(i + 1, j + 1));
}
}
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++)
if (getfa(id(i, j)) == id(i, j))
G[(i + j) & 1].N++, idx[id(i, j)] = G[(i + j) & 1].N;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '*') {
G[(i + j) & 1].add(idx[getfa(id(i, j))], idx[getfa(id(i + 1, j + 1))]);
G[(i + j + 1) & 1].add(idx[getfa(id(i + 1, j))],
idx[getfa(id(i, j + 1))]);
}
int ans = (G[0].solve() + G[1].solve()) % p;
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int i, s = 0, x[n], y[n];
double a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
x[i] = floor(a[i]);
s += x[i];
}
i = 0;
while (s != 0) {
y[i] = ceil(a[i]);
s = s - x[i] + y[i];
x[i] = y[i];
i++;
}
for (i = 0; i < n; i++) cout << x[i] << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef complex<double> P;
typedef pair<P,P> L;
const double INF = 1e+9;
const double EPS = 1e-8;
struct Circle{
P c;
double r;
Circle(P c=P(0,0), double r=0):c(c),r(r){}
double get_r(double h){
h = max(r - h, 0.0);
return sqrt(r*r - h*h);
}
};
struct rect{
P p[4];
double h;
rect(double minx, double miny, double maxx, double maxy, double h):h(h){
p[0] = P(minx, miny);
p[1] = P(maxx, miny);
p[2] = P(maxx, maxy);
p[3] = P(minx, maxy);
}
};
struct state{
P p;
int pos;
state(P p, int pos):p(p),pos(pos){}
};
double dot(P a, P b){ return real(conj(a)*b); }
double cross(P a, P b){ return imag(conj(a)*b); }
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return 1;
if(cross(b,c) < -EPS) return -1;
if(dot(b,c) < -EPS) return 2;
if(norm(b) < norm(c)) return -2;
return 0;
}
P proj(P p, L l){
return l.first + dot(p - l.first, l.second - l.first) / norm(l.second - l.first) * (l.second - l.first);
}
bool isIntersectSP(L s, P p){
return abs(s.first-p) + abs(s.second-p) - abs(s.second-s.first) < EPS;
}
bool isIntersect(L s1, L s2){
//ccw ??????????????????????????¨, ????????????????????´?????????????????¨??????????????????????????????
if(max(real(s1.first), real(s1.second)) + EPS < min(real(s2.first), real(s2.second)) ||
max(imag(s1.first), imag(s1.second)) + EPS < min(imag(s2.first), imag(s2.second)) ||
max(real(s2.first), real(s2.second)) + EPS < min(real(s1.first), real(s1.second)) ||
max(imag(s2.first), imag(s2.second)) + EPS < min(imag(s1.first), imag(s1.second))) return false;
return ( ccw(s1.first,s1.second,s2.first) * ccw(s1.first,s1.second,s2.second) <= 0 &&
ccw(s2.first,s2.second,s1.first) * ccw(s2.first,s2.second,s1.second) <= 0 );
}
enum {OUT, BORDER, IN};
int convex_contains(P v[], int n, P p){
P g = (v[0] + v[n/3] + v[2*n/3]) / 3.0;
int a = 0, b = n;
while(a + 1 < b){
int c = (a + b) / 2;
if(cross(v[a] - g, v[c] - g) > EPS){
if(cross(v[a]-g, p-g) > EPS && cross(v[c]-g, p-g) < -EPS) b = c;
else a = c;
} else {
if(cross(v[a]-g, p-g) < EPS && cross(v[c]-g, p-g) > -EPS) a = c;
else b = c;
}
}
b %= n;
if(cross(v[a] - p, v[b] - p) < -EPS) return 0;
if(cross(v[a] - p, v[b] - p) > EPS) return 2;
return 1;
}
vector<P> getIntersectCS(Circle c, L s){
vector<P> res;
P h = proj(c.c, s);
double d = abs(c.c - h);
if(d > c.r + EPS);
else if(d > c.r - EPS){
if(isIntersectSP(s,h)) res.push_back(h);
}
else {
P v = s.second - s.first;
v = (sqrt(c.r*c.r - d*d) / abs(v)) * v;
if(isIntersectSP(s, h+v)) res.push_back(h+v);
if(isIntersectSP(s, h-v)) res.push_back(h-v);
}
return res;
}
int n;
P st, go;
vector<rect> v;
vector<state> pv;
void make_pv(){
L l = L(st, go);
pv.clear();
for(int i=0;i<v.size();i++){
P ce = v[i].p[0];
for(int j=0;j<4;j++){
P res = proj(v[i].p[j], l);
if(isIntersectSP(l, res)) pv.push_back(state(res, i));
if(j > 0) ce += v[i].p[j];
}
ce /= 4.0;
P res = proj(ce, l);
if(isIntersectSP(l, res)) {
pv.push_back(state(res, i));
}
pv.push_back(state(st, i));
pv.push_back(state(go, i));
}
}
bool isok(double mid){
for(int i=0;i<pv.size();i++){
Circle c = Circle(pv[i].p, mid);
const rect &rec = v[pv[i].pos];
Circle hc = Circle(c.c, c.get_r(rec.h));
for(int j=0;j<4;j++){
L lp = L(rec.p[j], rec.p[(j+1)%4]);
if(getIntersectCS(hc, lp).size() >= 1 || abs(hc.c - rec.p[j]) < hc.r + EPS){
return false;
}
}
}
return true;
}
double solve(){
double le = 0.0, ri = INF, mid;
for(int i=0;i<n;i++){
if(convex_contains(v[i].p, 4, st) != OUT || convex_contains(v[i].p, 4, go) != OUT){
return 0.0;
}
for(int j=0;j<4;j++){
if(isIntersect(L(st, go), L(v[i].p[j], v[i].p[(j+1)%4]))){
return 0.0;
}
}
}
make_pv();
while(ri - le > EPS){
mid = (le + ri) / 2.0;
if(isok(mid)) le = mid;
else ri = mid;
}
return (le + ri) / 2.0;
}
int main(){
double x1, y1, x2, y2, h;
while(cin >> n && n){
v.clear();
cin >> x1 >> y1 >> x2 >> y2;
st = P(x1, y1);
go = P(x2, y2);
for(int i=0;i<n;i++){
cin >> x1 >> y1 >> x2 >> y2 >> h;
v.push_back(rect(x1, y1, x2, y2, h));
}
printf("%.7f\n", solve());
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 5;
int read() {
int s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * f;
}
char s[N];
set<int> L, R;
int n, Ans, lst, SumL, SumR, a[N], b[N];
void Solve(int flag) {
L.clear();
R.clear();
for (int i = 1; i <= n; i++) {
if (s[i] == 'L') L.insert(i);
if (s[i] == 'R') R.insert(i);
}
L.insert(inf);
R.insert(inf);
int sum = 0, nxt = (flag ? (*R.begin()) : (*L.begin()));
for (int num = 1; num <= n; num++) {
int Lfst = (*L.begin()), Lnxt = (*L.lower_bound(nxt));
int Rfst = (*R.begin()), Rnxt = (*R.lower_bound(nxt));
if (flag == 0) {
if (nxt == inf || (Rnxt == inf && Lfst < Rfst)) nxt = Lfst;
int pos = nxt;
L.erase(pos);
nxt = (*R.lower_bound(pos));
b[num] = pos;
}
if (flag == 1) {
if (nxt == inf || (Lnxt == inf && Rfst < Lfst)) nxt = Rfst;
int pos = nxt;
R.erase(pos);
nxt = (*L.lower_bound(pos));
b[num] = pos;
}
sum += (b[num] < b[num - 1]);
flag ^= 1;
}
if (sum < Ans) {
Ans = sum;
for (int i = 1; i <= n; i++) a[i] = b[i];
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
Ans = inf;
for (int i = 1; i <= n; i++) SumL += (s[i] == 'L');
for (int i = 1; i <= n; i++) SumR += (s[i] == 'R');
if (SumL >= SumR) Solve(0);
if (SumR >= SumL) Solve(1);
printf("%d\n", Ans);
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 5 |
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int main(void)
{
int i,j,n,m,n1,a,b,c,d,x[100],t[100];
cin>>n;
for(i=0;i<n;i++){
x[i]=0;
t[i]=1;
}
n1=n*(n-1)/2;
for(i=0;i<n1;i++){
cin>>a>>b>>c>>d;
if(c>d) x[a-1]=x[a-1]+3;
if(c<d) x[b-1]=x[b-1]+3;
if(c==d){
x[a-1]=x[a-1]+1;
x[b-1]=x[b-1]+1;
}
// cout<<'1'<<'2'<<'3'<<'4'<<endl;
// cout<<x[0]<<x[1]<<x[2]<<x[3]<<endl;
}
/* for(i=0;i<n;i++) cout<<x[i];
cout<<endl;*/
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(x[i]<x[j]){
t[i]=t[i]+1;
}
}
}
for(i=0;i<n;i++){
cout<<t[i]<<endl;
}
return 0;
}
| 0 |
/** In the name of Allah (SWT).
*
* author: Asif
* created: 00.00.2021 00:00:00
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<string, string> pss;
typedef map<int, int> mii;
typedef unordered_map<int, int> umap_ii;
typedef unordered_map<string, int> umap_si;
#define FOR(i, j, k, in) for (int i = j; i < k; i += in)
#define RFOR(i, j, k, in) for (int i = j; i >= k; i -= in)
#define REP(i, j) FOR(i, 0, j, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define INF (int)1e9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define pb push_back
#define imax INT_MAX
#define imin INT_MIN
#define VSORT sort(v.begin(), v.end())
#define VRSORT sort(v.rbegin(), v.rend())
#define V1SORT sort(v1.begin(), v1.end())
#define V1RSORT sort(v1.rbegin(), v1.rend())
/**
* Limits in C++ for reference
* _____________________________________________________________________________________
* |Sr| Macro Name | Description | Value
* |No|____________|_________________________________|__________________________________
* |1.| ULLONG_MAX | Maximum value unsigned long long| 18,446,744,073,709,551,615 (10^20)
* |2.| LLONG_MAX | Maximum value long long | 9,223,372,036,854,775,807 (10^19)
* |3.| LLONG_MIN | Minimum value long long |-9,223,372,036,854,775,808 -1*(10^19)
* |4.| INT_MAX | Maximum value int | 2,147,483,647 (10^10)
* |5.| INT_MIN | Minimum value int |-2,147,483,648 (10^10)
*/
void busted()
{
ll n, a, b; cin >> n >> a >> b;
if(a == 1){
if((n - 1) % b == 0){
cout << "Yes\n";
}
else{
cout <<"No\n";
}
return;
}
ll sum = 1;
while(sum <= n){
if((n - sum) % b == 0){
cout << "Yes\n";
return;
}
sum *= a;
}
cout << "No\n";
return;
}
int32_t main()
{
ll tc;
cin >> tc;
while (tc--)
busted();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define inf 1000000000 //1E+9
using namespace std;
int main(){
int n,m,k;cin>>n>>m>>k;
for(int i=0;i<=n;i++){
for(int j=0;j<=m;j++){
if(m*i+n*j-i*j*2 == k){
cout<<"Yes"<<endl;
return 0;
}
}
}
cout<<"No"<<endl;
return 0;
}
| 0 |
/*********************
* Author: xuziyuan *
*********************/
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define LL long long
#define pii pair <int,int>
#define fi first
#define se second
#define pb push_back
#define mpr make_pair
using namespace std;
const LL MOD=1e9+7;
int n,lb,ub,mid;
string s,ans="",lst,fis;
vector <int> r,b;
bool check()
{
cout.flush();
cout<<"? ";
for(int i=mid;i<=mid+n-1;i++) cout<<i<<' ';
cout<<endl;
cin>>s;
if(s=="-1") exit(0);
return s!=fis;
}
int main()
{
cin>>n;
cout.flush();
cout<<"? ";
repn(i,n) cout<<i<<' ';
cout<<endl;
cin>>s;
fis=s;
rep(i,n*2) ans.pb('a');
lb=1;
ub=n+1;
while(lb<ub)
{
mid=(lb+ub)/2;
if(check()) ub=mid;
else lb=mid+1;
}
ub=lb+n-2;
repn(i,n*2)
{
if(lb<=i&&i<=ub) continue;
cout.flush();
cout<<"? ";
cout<<i<<' ';
for(int j=lb;j<=ub;j++) cout<<j<<' ';
cout<<endl;
cin>>s;
if(s=="-1") return 0;
if(s[0]=='R') ans[i-1]='R';
else ans[i-1]='B';
}
repn(i,n*2)
{
if(ans[i-1]=='R'&&r.size()<n/2) r.pb(i);
if(ans[i-1]=='B'&&b.size()<n/2) b.pb(i);
}
//cout<<r.size()<<' '<<b.size()<<endl;
for(int i=lb;i<=ub;i++)
{
cout.flush();
cout<<"? ";
cout<<i<<' ';
rep(j,r.size()) cout<<r[j]<<' ';
rep(j,b.size()) cout<<b[j]<<' ';
cout<<endl;
cin>>s;
if(s=="-1") return 0;
if(s[0]=='R') ans[i-1]='R';
else ans[i-1]='B';
}
cout<<"! "<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, z;
vector<int> x;
bool done(vector<int> a) {
for (int i = 0; i < a.size(); i++) {
if (a[i] != i) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &z);
x.push_back(z);
}
for (int i = 0; i < 10000; i++) {
for (int j = 0; j < n; j++) {
if (j % 2 == 0)
x[j] = (x[j] + 1) % n;
else
x[j] = (x[j] + n - 1) % n;
}
if (done(x)) {
printf("Yes\n");
return 0;
}
}
printf("No\n");
return 0;
}
| 2 |
#include <iostream>
#include <vector>
#include <float.h>
int main() {
int n;
std::cin >> n;
std::vector<double> p(n, 0);
std::vector<double> q(n + 1, 0);
std::vector<std::vector<double>> CostMat(n, std::vector<double>(n, 0));
for (int i = 0; i < n; i++) {
std::cin >> p[i];
}
for (int i = 0; i < n + 1; i++) {
std::cin >> q[i];
}
// 対角成分
for (int i = 0; i < n; i++) {
CostMat[i][i] = p[i] + 2.0 * q[i] + 2.0 * q[i + 1];
}
// 動的計画法により最小コストを求める
for (int i = 1; i < n; i++) {
for (int j = 0; j < n - i; j++) {
double min = DBL_MAX;
for (int l = 0; l <= i; l++) {
double tmp = 0;
if (l != i) {
tmp += CostMat[j + l + 1][i + j];
}
if (l != 0) {
tmp += CostMat[j][j + l - 1];
}
if (l == 0) {
tmp += q[j];
}
if (l == i) {
tmp += q[j + i + 1];
}
if (tmp < min) {
min = tmp;
}
}
//std::cout << min << std::endl;
CostMat[j][i + j] = min;
for (int k = j; k <= j + i; k++) {
CostMat[j][i + j] += p[k] + q[k];
}
CostMat[j][i + j] += q[j + i + 1];
}
}
std::cout << CostMat[0][n - 1] << std::endl;
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <bitset>
using namespace std;
bool solve(vector<int> a, int x) {
bitset<8080> dp;
dp[0] = 1;
int sum = 0;
for (int e : a) {
dp |= dp << e;
sum += e;
}
for (int i = 0; i < 8080; i++) {
if (dp[i] && i - (sum - i) == x) return true;
}
return false;
}
int main() {
string s;
cin >> s;
int x, y;
cin >> x >> y;
int i = 0;
while (i < s.size() && s[i] == 'F') {
x--;
i++;
}
i++;
vector<int> xs, ys;
int d = 1;
while (i < s.size()) {
int t = 0;
while (i < s.size() && s[i] == 'F') {
i++;
t++;
}
i++;
if (d % 2 == 0) {
xs.push_back(t);
} else {
ys.push_back(t);
}
d ^= 1;
}
if (solve(xs, x) && solve(ys, y)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dump_char;
long long n, m;
void cal(long long a[2][2], long long b[2][2]) {
long long c[2][2];
c[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0];
c[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1];
c[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0];
c[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1];
a[0][0] = c[0][0];
a[0][1] = c[0][1];
a[1][0] = c[1][0];
a[1][1] = c[1][1];
}
void cal_exp(long long e) {
long long b[2][2] = {1, 1, 1, 0}, p[2][2] = {1, 0, 0, 1};
while (e) {
if (e % 2) {
cal(p, b);
}
cal(b, b);
e = e / 2;
}
n = p[0][0] + p[0][1];
m = p[1][0] + p[1][1];
}
long long maxl(long long a, long long b) {
if (a > b) return a;
return b;
}
long long minl(long long a, long long b) {
if (a > b) return b;
return a;
}
int main() {
long long count = 0;
long long x, y, z, k;
long long i, ans;
cin >> x;
cin >> y;
cin >> k;
z = maxl(x, y);
y = minl(x, y);
x = z;
if (x < k && x <= 0) {
cout << "-1" << endl;
return 0;
}
if (x >= k) {
cout << count << endl;
return 0;
}
if (x > 0 && y < 0) {
z = (-1ll * y) / x;
z++;
count = z;
y = y + z * x;
z = maxl(x, y);
y = minl(x, y);
x = z;
}
for (i = 0; i < 1000; i++) {
count++;
cal_exp(i);
ans = n * x + m * y;
if (ans >= k) break;
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long pow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x);
x = (x * x);
n >>= 1;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
long long mx = *max_element(a.begin(), a.end());
bool done = 1;
for (long long i = 0; i < n; ++i) {
if (abs(mx - a[i]) % 2) {
done = 0;
break;
}
}
if (done)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 201;
const ll MAX = (1LL<<29);
ll w[N][N];
int main () {
ios_base::sync_with_stdio(false); cin.tie(NULL);
int n, m, R; cin >> n >> m >> R;
int rn[R];
for (int i = 0; i < R; i++)
cin >> rn[i];
sort(rn, rn+R);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
w[i][j] = (i == j ? 0 : MAX);
for (int i = 0; i < m; i++) {
int u, v, wg; cin >> u >> v >> wg;
w[u][v] = w[v][u] = wg;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
w[i][j] = min(w[i][j], w[i][k]+w[k][j]);
ll ans = MAX;
do {
ll temp = 0;
for (int i = 1; i < R; i++)
temp += w[rn[i-1]][rn[i]];
ans = min(ans, temp);
} while (next_permutation(rn, rn+R));
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main( void )
{
while( 1 ){
int n,p,d[55],b,i;
cin >> n >> p;
if( n == 0 ) break;
for( i=0; i<n; i++ ){
d[i] = 0;
}
b = p;
i = 0;
while( 1 ){
if( b > 0 ){
d[i]++;
b--;
if( d[i] == p ){
cout << i << endl;
break;
}
} else if( d[i] > 0 ) {
b = d[i];
d[i] = 0;
}
i = (i+1) % n;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m;
cin >> m >> n;
vector<pair<int, int> > pp;
int x, y;
for (i = 0; i < n; i++) {
cin >> x >> y;
pp.push_back({x, y});
}
set<int> st;
vector<int> v;
for (i = 1; i <= 100; i++) {
for (j = 0; j < n; j++) {
if ((pp[j].first + i - 1) / i != pp[j].second) break;
}
if (j == n) st.insert((m + i - 1) / i);
}
if (st.size() != 1)
cout << -1;
else {
cout << *(st.begin());
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
string str = "";
string str1 = "";
for (int i = 0; i < b; i++) {
str = str + "#";
}
for (int i = 0; i < b - 1; i++) {
str1 = str1 + ".";
}
int f = 0;
while (a--) {
if (a % 2 == 1 && f == 1) {
f = 0;
cout << "#" + str1 << endl;
} else if (a % 2 == 1 && f == 0) {
f = 1;
cout << str1 + "#" << endl;
} else {
cout << str << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
int grid[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) grid[i][j] = 0;
vector<vector<int>> instr(q);
for (int i = 0; i < q; i++) {
int t;
cin >> t;
instr[q - 1 - i].push_back(t);
int u = 1;
if (t == 3) u = 3;
for (int j = 0; j < u; j++) {
int x;
cin >> x;
instr[q - 1 - i].push_back(x);
}
}
for (int i = 0; i < q; i++) {
auto cur = instr[i];
if (cur[0] == 1) {
int r = cur[1] - 1;
vector<int> v(m);
for (int j = 0; j < m; j++) v[j] = grid[r][(j + m - 1) % m];
for (int j = 0; j < m; j++) grid[r][j] = v[j];
} else if (cur[0] == 2) {
int c = cur[1] - 1;
vector<int> v(n);
for (int j = 0; j < n; j++) v[j] = grid[(j + n - 1) % n][c];
for (int j = 0; j < n; j++) grid[j][c] = v[j];
} else
grid[cur[1] - 1][cur[2] - 1] = cur[3];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j) cout << " ";
cout << grid[i][j];
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, po[22][3], l, r;
double dp[1 << 20];
const double pi = acos(-1);
const double eps = 1e-7;
double cal(double l, double x, double y, double a) {
double afa = a * 1.0 / 180 * pi;
if (abs(a - 90) < eps && x <= l) return r;
if (l - x > eps) {
double theta = atan((l - x) / y);
if ((theta + afa - pi / 2) > eps) return r;
double res = y * tan(theta + afa) + x;
if (res - r > eps)
return r;
else
return res;
} else {
double theta = atan((x - l) / y);
double res = x + y * tan(afa - theta);
if (res - r > eps)
return r;
else
return res;
}
}
int main() {
cin >> n >> l >> r;
for (int i = 0; i < n; i++) cin >> po[i][0] >> po[i][1] >> po[i][2];
dp[0] = l;
double ans = l;
int lim = 1 << n;
for (int i = 1; i < lim; i++) {
dp[i] = l;
for (int j = 0; j < n; j++)
if (i & (1 << j)) {
double rr = cal(dp[i ^ (1 << j)], po[j][0], po[j][1], po[j][2]);
if (dp[i] <= rr) dp[i] = rr;
}
if (ans < dp[i]) ans = dp[i];
}
printf("%.8lf\n", ans - l);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-5;
const int p = 131;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int N = 1e6 + 10;
long long Hash[N], fac[N];
char s[N], ss[N];
long long get(int l, int r) {
return (Hash[r] - Hash[l - 1] * fac[r - l + 1] % mod + mod) % mod;
}
void run() {
scanf("%s %s", s + 1, ss + 1);
int len1 = strlen(s + 1);
int len2 = strlen(ss + 1);
fac[0] = 1;
int n0 = 0, n1 = 0;
for (int i = 1; i <= len1; i++) {
n0 += (s[i] == '0');
n1 += (s[i] == '1');
}
for (int i = 1; i <= len2; i++) {
Hash[i] = (Hash[i - 1] * p % mod + ss[i] - 'a' + 1) % mod;
fac[i] = fac[i - 1] * p % mod;
}
int res = 0;
for (int l0 = 1, l1; l0 < len2; l0++) {
if (l0 * n0 >= len2) break;
if ((len2 - l0 * n0) % n1) continue;
l1 = (len2 - l0 * n0) / n1;
long long hash0 = -1, hash1 = -1;
int idx = 1;
int flag = 1;
for (int j = 1; j <= len1; j++) {
if (s[j] == '1') {
if (hash1 == -1) {
hash1 = get(idx, idx + l1 - 1);
} else if (hash1 != get(idx, idx + l1 - 1)) {
flag = 0;
break;
}
idx += l1;
} else {
if (hash0 == -1) {
hash0 = get(idx, idx + l0 - 1);
} else if (hash0 != get(idx, idx + l0 - 1)) {
flag = 0;
break;
}
idx += l0;
}
if (~hash0 && ~hash1 && hash0 == hash1) {
flag = 0;
break;
}
}
if (flag) res++;
}
printf("%d\n", res);
}
int main() {
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double f[400][3100], p[400][3100], ans;
int n, m, up[400];
void dp(int i) {
int j;
long double pre, nw;
pre = f[i][0];
f[i][0] = 0;
for (j = 1; j <= n; j++) {
nw = f[i][j];
f[i][j] = pre * p[i][j] + f[i][j - 1] * (1 - p[i][j]);
pre = nw;
}
up[i]++;
}
int main() {
int i, j, k, x, to;
long double mx;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &x);
p[j][i] = (long double)x / (long double)1000;
}
for (i = 1; i <= m; i++)
for (j = 0; j <= n; j++) f[i][j] = 1;
for (i = 1; i <= m; i++) up[i] = 0;
for (i = 1; i <= m; i++) dp(i);
ans = 0;
for (i = 1; i <= n; i++) {
mx = -1;
for (j = 1; j <= m; j++)
if (f[j][n] > mx) mx = f[j][n], to = j;
ans += mx;
dp(to);
}
double out = ans;
printf("%.11f\n", out);
return 0;
}
| 4 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info{
char map[10][10];
};
struct Data{
Data(int arg_row,int arg_col){
row = arg_row;
col = arg_col;
}
int row,col;
};
int H,W;
int diff_row[4] = {-1,0,0,1},diff_col[4] = {0,-1,1,0};
char base_map[10][10];
bool FLG;
char to_color[3] = {'R','G','B'};
bool rangeCheck(int row,int col){
if(row >= 0 && row <= H-1 && col >= 0 && col <= W-1)return true;
else{
return false;
}
}
void back_track(Info info,int depth,int max_depth){
if(FLG)return;
bool is_cleared = true;
for(int row = 0; row < H; row++){
for(int col = 0; col < W; col++){
if(info.map[row][col] != info.map[0][0]){
is_cleared = false;
break;
}
}
if(!is_cleared)break;
}
if(is_cleared){
FLG = true;
return;
}
char pre_color = info.map[0][0];
queue<Data> Q;
int adj_row,adj_col;
for(int loop = 0; loop < 3; loop++){
if(to_color[loop] == pre_color)continue;
Info next_info;
for(int row = 0;row < H; row++){
for(int col = 0; col < W; col++){
next_info.map[row][col] = info.map[row][col];
}
}
next_info.map[0][0] = to_color[loop];
Q.push(Data(0,0));
while(!Q.empty()){
for(int i = 0; i < 4; i++){
adj_row = Q.front().row + diff_row[i];
adj_col = Q.front().col + diff_col[i];
if(!rangeCheck(adj_row,adj_col))continue;
if(next_info.map[adj_row][adj_col] == pre_color){
next_info.map[adj_row][adj_col] = to_color[loop];
Q.push(Data(adj_row,adj_col));
}
}
Q.pop();
}
if(depth < max_depth){
back_track(next_info,depth+1,max_depth);
}
}
}
void func(){
char buf[2];
for(int row = 0; row < H; row++){
for(int col = 0; col < W; col++){
scanf("%s",buf);
base_map[row][col] = buf[0];
}
}
FLG = false;
int ans = 0;
for(int i = 0; ; i++){
Info info;
for(int row = 0; row < H; row++){
for(int col = 0; col < W; col++){
info.map[row][col] = base_map[row][col];
}
}
back_track(info,0,i);
if(FLG){
ans = i;
break;
}
}
printf("%d\n",ans);
}
int main(){
while(true){
scanf("%d %d",&W,&H);
if(W == 0 && H == 0)break;
func();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const long long LINF = (long long)1e18 + 5;
const int INF = (int)1e9 + 5;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
long long round(T x) {
return x < 0 ? x - 0.5 : x + 0.5;
}
template <class T>
bool chmin(T& x, const T& y) {
if (y < x) {
x = y;
return true;
}
return false;
}
template <class T>
bool chmax(T& x, const T& y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class P, class Q>
ostream& operator<<(ostream& os, const pair<P, Q>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
bool was = false;
for (const T& x : v) {
if (was) {
os << ", ";
}
was = true;
os << x;
}
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "{";
bool was = false;
for (const T& x : v) {
if (was) {
os << ", ";
}
was = true;
os << x;
}
os << "}";
return os;
}
template <class P, class Q>
ostream& operator<<(ostream& os, const map<P, Q>& m) {
os << "{";
bool was = false;
for (const auto& x : m) {
if (was) {
os << ", ";
}
was = true;
os << x;
}
os << "}";
return os;
}
const int N = 55;
int n;
char s[N][N];
int sum[5][N][N];
void calcSum(int val) {
auto cur = sum[val];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cur[i][j] = cur[i - 1][j] + cur[i][j - 1] - cur[i - 1][j - 1] +
(s[i][j] == (val + '0') ? 1 : 0);
}
}
}
bool ok(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= n; }
int getSum(int val, int x, int y, int xx, int yy) {
if (x > xx || y > yy || !ok(x, y) || !ok(xx, yy)) return 0;
auto cur = sum[val];
return cur[xx][yy] - cur[x - 1][yy] - cur[xx][y - 1] + cur[x - 1][y - 1];
}
bool fullOf(int val, int x, int y, int xx, int yy, int& s) {
if (x > xx || y > yy || !ok(x, y) || !ok(xx, yy)) return true;
auto cur = sum[val];
int tmp = cur[xx][yy] - cur[x - 1][yy] - cur[xx][y - 1] + cur[x - 1][y - 1];
if ((xx - x + 1) * (yy - y + 1) != tmp) return false;
s -= tmp;
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int val = 0; val <= 4; val++) {
calcSum(val);
}
int total1 = getSum(1, 1, 1, n, n);
int total2 = getSum(2, 1, 1, n, n);
int total3 = getSum(3, 1, 1, n, n);
int total4 = getSum(4, 1, 1, n, n);
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
for (int xx = x; xx <= n; xx++) {
for (int yy = y; yy <= n; yy++) {
int tmp = total4;
if (!fullOf(4, x, y, xx, yy, tmp)) continue;
if (tmp != 0) continue;
tmp = total1;
if (!fullOf(1, x - 1, y - 1, x - 1, y - 1, tmp) ||
!fullOf(1, xx + 1, yy + 1, xx + 1, yy + 1, tmp) ||
!fullOf(1, x - 1, yy + 1, x - 1, yy + 1, tmp) ||
!fullOf(1, xx + 1, y - 1, xx + 1, y - 1, tmp))
continue;
if (tmp != 0) continue;
tmp = total2;
if (!fullOf(2, x, y - 1, xx, y - 1, tmp) ||
!fullOf(2, x, yy + 1, xx, yy + 1, tmp) ||
!fullOf(2, x - 1, y, x - 1, yy, tmp) ||
!fullOf(2, xx + 1, y, xx + 1, yy, tmp))
continue;
if (tmp != 0) continue;
if (total3 != 0) continue;
puts("Yes");
exit(0);
}
}
}
}
puts("No");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 * 2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> a >> b;
if (a == 0 && b == 0)
cout << "NO\n";
else if (abs(a - b) <= 1)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sx, sy;
cin >> n >> sx >> sy;
vector<pair<int, int> > coordinates;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
coordinates.push_back({x, y});
}
vector<pair<int, int> > possible_ans{
{sx + 1, sy}, {sx - 1, sy}, {sx, sy + 1}, {sx, sy - 1},
{sx + 1, sy + 1}, {sx + 1, sy - 1}, {sx - 1, sy + 1}, {sx - 1, sy - 1}};
int maxm = 0, posx = -1, posy = -1;
for (auto x : possible_ans) {
int xx = x.first;
int yy = x.second;
int count = 0;
for (auto coord : coordinates) {
int coordx = coord.first;
int coordy = coord.second;
int minx = min(sx, coordx);
int maxx = max(sx, coordx);
int miny = min(sy, coordy);
int maxy = max(sy, coordy);
if (xx >= minx && xx <= maxx) {
if (yy >= miny && yy <= maxy) {
count++;
}
}
}
if (count > maxm) {
maxm = count;
posx = xx;
posy = yy;
}
}
cout << maxm << '\n';
cout << posx << " " << posy;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 100003;
const double EPSILON = 1e-10;
const int NMAX = 2e5 + 5;
const int MMAX = 4e5 + 5;
char x[NMAX];
int n, k;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
cin.get();
cin.getline(x, 2e5 + 2);
if (n == 1) {
if (k == 0)
cout << x;
else
cout << 0;
return 0;
}
if (k > 0 && x[0] != '1') {
x[0] = '1';
--k;
}
int i = 1;
while (k && i < n) {
if (x[i] != '0') {
x[i] = '0';
--k;
}
++i;
}
cout << x;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, i, j, ii, jj, zx, xc, p[10009], ji;
pair<int, int> k[109];
int ask(int q, int w) {
int qw = 0;
cout << "? " << q << " " << w << endl;
cin >> qw;
return qw;
}
int fun(int q) {
int qw = 0;
if (q != k[0].first) {
qw = ask(q, k[0].first);
} else {
qw = ask(q, k[0].second);
}
for (j = 1; j <= ji; j++) {
if (q != k[j].first) {
e = ask(q, k[j].first);
} else {
e = ask(q, k[j].second);
}
qw &= e;
}
return qw;
}
void answer() {
cout << "!";
for (j = 1; j <= a; j++) {
cout << " " << p[j];
}
exit(0);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin >> a;
for (j = 0;; j++) {
if ((1 << j) >= a) break;
ji = j;
}
while (1) {
for (j = 0; j <= ji; j++) {
if (k[j].first == 0) break;
}
if (j == ji + 1) break;
c = rand() % a + 1;
d = rand() % a + 1;
if (c == d) continue;
e = ask(c, d);
for (jj = 0; jj <= ji; jj++) {
if ((e & (1 << jj)) == 0) {
k[jj].first = c;
k[jj].second = d;
}
}
}
p[1] = fun(1);
c = 1;
for (i = 2; i <= a; i++) {
e = ask(c, i);
if (p[c] == e) {
c = i;
p[c] = fun(c);
}
}
p[c] = 0;
for (i = 1; i <= a; i++) {
if (i == c) continue;
p[i] = ask(i, c);
}
answer();
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const int maxn = (1 << 17) + 20;
int a[maxn] , b[maxn];
void solve(int n , int x)
{
if(n == 1)
{
assert(x == 1);
a[0] = 0 , a[1] = 1;
return;
}
if(x & 1)
solve(n - 1 , (x / 2) ^ 1);
else
solve(n - 1 , x >> 1);
for(int i = 0; i < (1 << (n - 1)); i += 2)
{
b[i * 2] = a[i] * 2;
b[i * 2 + 1] = a[i] * 2 + 1;
b[i * 2 + 2] = a[i + 1] * 2 + 1;
b[i * 2 + 3] = a[i + 1] * 2;
}
memcpy(a , b , sizeof b);
if(x & 1)
{
for(int i = 0; i < (1 << n); i += 4)
{
assert(a[i] != x && a[i + 2] != x && a[i + 3] != x);
if(a[i + 1] == x)
{
a[i + 1] = a[i + 3];
for(int j = i + 3; j + 1 < (1 << n); j++)
a[j] = a[j + 1]^1;
a[(1 << n) - 1] = x;
break;
}
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n , x , y;
cin >> n >> x >> y;
if(__builtin_popcount(x ^ y) % 2 == 0)
return cout << "NO" << endl , 0;
cout << "YES" << endl;
solve(n , x ^ y);
for(int i = 0; i < (1 << n); i++)
cout << (a[i] ^ x) << " ";
cout << endl;
for(int i = 0; i + 1 < (1 << n); i++)
assert(__builtin_popcount(a[i] ^ a[i + 1]) == 1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, r;
scanf("%d%d%d", &n, &m, &r);
int MINP = 0x7fffffff;
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
MINP = min(MINP, t);
}
int MAXP = 0;
for (int i = 0; i < m; ++i) {
int t;
scanf("%d", &t);
MAXP = max(MAXP, t);
}
if (MAXP >= MINP)
printf("%d", (MAXP - MINP) * int(r / MINP) + r);
else
printf("%d", r);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{ int a,b,i=1;
scanf("%d %d",&a,&b);
while(pow(b,i)<=a)i++;
printf("%d",i);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
struct debug {
~debug() { cout << endl; }
template <class T>
debug& operator<<(T x) {
cout << boolalpha << x;
return *this;
}
template <class B, class C>
debug& operator<<(pair<B, C> x) {
return *this << "(" << x.first << ", " << x.second << ")";
}
template <class T>
debug& operator<<(rge<T> x) {
*this << "[";
for (auto it = x.b; it != x.e; it++) {
*this << ", " + 2 * (it == x.b) << *it;
}
return *this << "]";
}
template <class T>
debug& operator<<(vector<T> x) {
return *this << range(x.begin(), x.end());
}
};
vector<int> adj[2222];
int smaller[2222], val[2222];
int get(set<int>& keys, int k) {
auto it = keys.begin();
for (int cnt = 0; cnt < k; cnt++, it++) {
}
int ans = *it;
keys.erase(it);
return ans;
}
bool dfs(set<int>& keys, int u) {
int k = smaller[u];
if (k >= (int)keys.size())
return false;
else
val[u] = get(keys, k);
for (int v : adj[u])
if (!dfs(keys, v)) return false;
return true;
}
int getLess(int u, int k) {
int less = val[u] < k;
for (int v : adj[u]) less += getLess(v, k);
return less;
}
bool check(int u) {
int s = 0;
for (int v : adj[u]) s += getLess(v, val[u]);
if (s != smaller[u])
return false;
else
for (int v : adj[u])
if (!check(v)) return false;
return true;
}
bool solve(void) {
int n, root = 0;
scanf("%d", &n);
set<int> keys;
for (int i = 1; i <= n; i++) {
int p;
scanf("%d%d", &p, &smaller[i]);
if (p == 0)
root = i;
else
adj[p].emplace_back(i);
}
for (int i = 1; i <= n; i++) keys.insert(i);
if (dfs(keys, root) && check(root)) {
puts("YES");
for (int i = 1; i <= n; i++) cout << " " + (i == 1) << val[i];
puts("");
} else {
puts("NO");
}
return true;
}
int main(int argc, char* argv[]) {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2020202020;
int N;
int X[1010];
int Y[1010];
vector<pair<int, int> > V[1010];
vector<pair<int, int> > H[1010];
vector<int> xs, ys;
bool chk[1010];
struct DSU {
int p[1010];
int n, com;
void init(int _n) {
n = com = _n;
for (int i = 1; i <= n; i++) p[i] = i;
}
int par(int x) {
if (x == p[x]) return x;
return p[x] = par(p[x]);
}
void unite(int a, int b) {
a = par(a);
b = par(b);
if (a == b) return;
p[a] = b;
com--;
}
int count() { return com; }
} uf;
void comv(vector<int>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int get_idx(vector<int>& v, int x) {
return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
bool solve(int dst) {
uf.init(N);
for (int i = 1; i <= N; i++) {
for (int j = 1; j < H[i].size(); j++) {
if (H[i][j].first - H[i][j - 1].first <= dst)
uf.unite(H[i][j - 1].second, H[i][j].second);
}
for (int j = 1; j < V[i].size(); j++) {
if (V[i][j].first - V[i][j - 1].first <= dst)
uf.unite(V[i][j - 1].second, V[i][j].second);
}
}
int c = uf.count();
if (c > 4) return false;
if (c == 1) return true;
auto f = [&](int x, int y) {
int u = 0, d = 0, l = 0, r = 0;
auto it = lower_bound(xs.begin(), xs.end(), x);
if (*it == x) {
int xi = it - xs.begin() + 1;
auto it2 = lower_bound(V[xi].begin(), V[xi].end(), pair<int, int>(y, 0));
if (it2 != V[xi].end()) u = it2->second;
if (it2 != V[xi].begin()) d = (--it2)->second;
}
it = lower_bound(ys.begin(), ys.end(), y);
if (*it == y) {
int yi = it - ys.begin() + 1;
auto it2 = lower_bound(H[yi].begin(), H[yi].end(), pair<int, int>(x, 0));
if (it2 != H[yi].end()) r = it2->second;
if (it2 != H[yi].begin()) l = (--it2)->second;
}
if (u && Y[u] - y > dst) u = 0;
if (d && y - Y[d] > dst) d = 0;
if (r && X[r] - x > dst) r = 0;
if (l && x - X[l] > dst) l = 0;
if (u) u = uf.par(u);
if (d) d = uf.par(d);
if (r) r = uf.par(r);
if (l) l = uf.par(l);
set<int> S;
for (int i : {u, d, r, l}) {
if (i) S.insert(i);
}
if (S.size() >= c) return true;
return false;
};
for (int i = 0; i < xs.size(); i++) {
for (int j = 0; j < ys.size(); j++) {
if (f(xs[i], ys[j])) return true;
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j < H[i].size(); j++) {
int x1 = H[i][j - 1].first, x2 = H[i][j].first;
if (x2 - x1 <= dst || x2 - x1 > 2 * dst) continue;
int y = ys[i - 1], x = (x1 + x2) / 2;
if (f(x, y)) return true;
}
for (int j = 1; j < V[i].size(); j++) {
int y1 = V[i][j - 1].first, y2 = V[i][j].first;
if (y2 - y1 <= dst || y2 - y1 > 2 * dst) continue;
int x = xs[i - 1], y = (y1 + y2) / 2;
if (f(x, y)) return true;
}
}
return false;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d%d", &X[i], &Y[i]);
xs.push_back(X[i]);
ys.push_back(Y[i]);
}
comv(xs);
comv(ys);
for (int i = 1; i <= N; i++) {
H[get_idx(ys, Y[i])].emplace_back(X[i], i);
V[get_idx(xs, X[i])].emplace_back(Y[i], i);
}
for (int i = 1; i <= N; i++) {
sort(H[i].begin(), H[i].end());
sort(V[i].begin(), V[i].end());
}
int l = 1, r = INF;
while (l <= r) {
long long m = (long long)l + r >> 1;
if (solve(m))
r = m - 1;
else
l = m + 1;
}
printf("%d\n", l > INF ? -1 : l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll,ll>
#define FOR(I,A,B) for(ll I = ll(A); I < ll(B); ++I)
#define FORR(I,A,B) for(ll I = ll((B)-1); I >= ll(A); --I)
#define TO(x,t,f) ((x)?(t):(f))
#define SORT(x) (sort(x.begin(),x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin()) //xi>=v x is sorted
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin()) //xi>v x is sorted
#define NUM(x,v) (POSU(x,v)-POSL(x,v)) //x is sorted
#define REV(x) (reverse(x.begin(),x.end())) //reverse
ll gcd(ll a,ll b){if(a%b==0)return b;return gcd(b,a%b);}
ll lcm(ll a,ll b){ll c=gcd(a,b);return ((a/c)*(b/c)*c);}
#define NEXTP(x) next_permutation(x.begin(),x.end())
const ll INF=ll(1e18)+ll(7);
const ll MOD=1000000007LL;
#define out(a) cout<<fixed<<setprecision((a))
#define YesNo(a) cout<<((a)?"Yes":"No")<<endl;
#define YESNO(a) cout<<((a)?"YES":"NO")<<endl;
int main(){
ll ans=0,N,K,L,R;
cin >> N >> K >> L >> R;
ll x = N/2;
ll y = N-x;
vector<ll> S1(x),S2(y),A[x+1],B[y+1];
FOR(i,0,x) cin >> S1[i];
FOR(i,0,y) cin >> S2[i];
A[0].push_back(0);
B[0].push_back(0);
FOR(i,0,x){
FORR(j,0,x){
for(auto a:A[j]){
A[j+1].push_back(S1[i]+a);
}
}
}
FOR(i,0,y){
FORR(j,0,y){
for(auto b:B[j]){
B[j+1].push_back(S2[i]+b);
}
}
}
FOR(i,1,x+1)SORT(A[i]);
FOR(i,1,y+1)SORT(B[i]);
FOR(i,0,min(x,K)+1){
if( K-i > y )continue;
for(auto a:A[i]){
ll l = POSL(B[K-i],L-a);
ll r = POSU(B[K-i],R-a) - 1;
ans += r-l+1;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
bool is_prime(ll n){
if(n==1)return false;
for(ll i=2;i*i<=n;i++){
if(n%i==0)return false;
}
return true;
}
vector<ll>divsor(ll n){
vector<ll>res;
for(ll i=1;i*i<=n;i++){
if(n%i==0){
res.push_back(i);
if(i!=n/i)res.push_back(i);
}
}
return res;
}
map<ll,int>prime_factor(ll n){
map<ll,int>res;
for(ll i=2;i*i<=n;i++){
while(n%i==0){
res[i]++;
n/=i;
}
}
if(n!=1)res[n]++;
return res;
}
ll dp[200000][50];
signed main(){
int n,m;cin>>n>>m;
dp[0][0]=1;
rep(i,n)rep(j,40){
for(int k=0;j+k<40;k++){
(dp[i+1][j+k]+=dp[i][j])%=MOD;
}
}
auto mp=prime_factor(m);
ll ans=1;
for(auto&p:mp){
(ans*=dp[n][p.second])%=MOD;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long pow10(long long k) {
long long ans = 1;
for (long long i = 0; i < k; i++) {
ans *= 10;
}
return ans;
}
long long sum(long long num) {
long long ans = 0;
while (num != 0) {
ans += num % 10;
num = num / 10;
}
return ans;
}
signed main(void) {
long long n;
cin >> n;
long long digits = log10(n) + 1;
long long f = (n / pow10(digits - 1)) * pow10(digits - 1);
long long a = f - 1;
long long b = n - a;
cout << sum(a) + sum(b);
return 0;
}
| 2 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 450
typedef pair<int,int> P; //firstは最短距離、secondは頂点の番号
//辺を表す構造体{行先、容量、コスト、逆辺のインデックス}
struct Edge{
Edge(int arg_to,int arg_capacity,int arg_cost,int arg_rev_index){
to = arg_to;
capacity = arg_capacity;
cost = arg_cost;
rev_index = arg_rev_index;
}
int to,capacity,cost,rev_index;
};
int V; //頂点数
vector<Edge> G[NUM]; //グラフの隣接リスト表現
int h[NUM]; //ポテンシャル
int dist[NUM]; //最短距離
int pre_node[NUM],pre_edge[NUM]; //直前の頂点と辺
int num_day,num_item,num_limit;
int num_problem,num_student,num_bag;
int POW[9];
int price[8][8],problem[200][8],bag[200][8];
int dp[9][6561][9];
int min_cost[6561];
int bag_index[200],problem_index[200];
//fromからtoへ向かう容量capacity,コストcostの辺をグラフに追加する
void add_edge(int from,int to,int capacity,int cost){
G[from].push_back(Edge(to,capacity,cost,G[to].size()));
G[to].push_back(Edge(from,0,-cost,G[from].size()-1));
}
//sourceからsinkへの、流量flowの最小費用流を求める
//流せない場合は-1を返す
int min_cost_flow(int source,int sink,int flow){
int ret = 0;
for(int i = 0; i < V; i++)h[i] = 0; //ポテンシャルを0にする
while(flow > 0){
//ダイクストラ法を用いてhを更新する
priority_queue<P,vector<P>,greater<P>> Q;
for(int i = 0; i < V; i++)dist[i] = BIG_NUM;
dist[source] = 0;
Q.push(P(0,source));
while(!Q.empty()){
P p = Q.top();
Q.pop();
int node_id = p.second;
if(dist[node_id] < p.first)continue; //最短でなければSKIP
for(int i = 0; i < G[node_id].size(); i++){
Edge &e = G[node_id][i];
if(e.capacity > 0 && dist[e.to] > dist[node_id]+e.cost+h[node_id]-h[e.to]){
dist[e.to] = dist[node_id]+e.cost+h[node_id]-h[e.to];
pre_node[e.to] = node_id;
pre_edge[e.to] = i;
Q.push(P(dist[e.to],e.to));
}
}
}
if(dist[sink] == BIG_NUM){
//これ以上流せない
return -1;
}
for(int node_id = 0; node_id < V; node_id++)h[node_id] += dist[node_id];
//source-sink間最短路に沿って目いっぱい流す
int tmp_flow = flow;
for(int node_id = sink; node_id != source; node_id = pre_node[node_id]){
tmp_flow = min(tmp_flow,G[pre_node[node_id]][pre_edge[node_id]].capacity);
}
flow -= tmp_flow;
ret += tmp_flow*h[sink];
for(int node_id = sink; node_id != source; node_id = pre_node[node_id]){
Edge &e = G[pre_node[node_id]][pre_edge[node_id]];
e.capacity -= tmp_flow;
G[node_id][e.rev_index].capacity += tmp_flow;
}
}
return ret;
}
void func(){
//商品情報を取得
for(int i = 0; i < num_day; i++){
for(int k = 0; k < num_item; k++)scanf("%d",&price[i][k]);
}
scanf("%d %d %d",&num_problem,&num_student,&num_bag);
for(int i = 0; i < num_problem; i++){
for(int k = 0; k < num_item; k++)scanf("%d",&problem[i][k]);
}
for(int i = 0; i < num_bag; i++){
for(int k = 0; k < num_item; k++)scanf("%d",&bag[i][k]);
}
for(int state = 0; state < POW[num_item]; state++)min_cost[state] = BIG_NUM; //部品をstateの組合せで買う時の最小コスト
for(int day = 0; day <= num_day; day++){
for(int state = 0; state < POW[num_item]; state++){
for(int i = 0; i <= num_limit; i++)dp[day][state][i] = BIG_NUM;
}
}
dp[0][0][0] = 0;
min_cost[0] = 0;
int next_state,next_cost,tmp;
int work[num_item];
stack<int> S;
//stateの組合せの部品を揃える際の最小コストを求める
for(int day = 0; day <= num_day-1; day++){
for(int state = 0; state < POW[num_item]; state++){
for(int bought_num = 0; bought_num <= num_limit; bought_num++){
if(dp[day][state][bought_num] == BIG_NUM)continue;
dp[day+1][state][0] = min(dp[day+1][state][0],dp[day][state][bought_num]);
if(bought_num == num_limit)continue; //もう買えないので、dp値を伝播させたらSKIP
//何をいくつ買ったかを計算
tmp = state;
for(int i = num_item-1; i >= 0; i--){
S.push(tmp/POW[i]);
tmp %= POW[i];
}
for(int i = 0; i < num_item; i++){
work[i] = S.top();
S.pop();
}
for(int i = 0; i < num_item; i++){
if(work[i] == 2)continue;
next_state = state+POW[i];
next_cost = dp[day][state][bought_num]+price[day][i];
dp[day][next_state][bought_num+1] = min(dp[day][next_state][bought_num+1],next_cost);
min_cost[next_state] = min(min_cost[next_state],next_cost);
}
}
}
}
for(int i = 0; i < NUM; i++)G[i].clear();
int source = 0, sink = 1, empty_bag = 2, index = 3;
//袋の採番
for(int i = 0; i < num_bag; i++)bag_index[i] = index++;
//課題の採番
for(int i = 0; i < num_problem; i++)problem_index[i] = index++;
//sourceから袋への辺張り
add_edge(source,empty_bag,num_student,0); //★★空袋はいくつ割り当てても良い★★
for(int i = 0; i < num_bag; i++){
add_edge(source,bag_index[i],1,0);
}
//課題からsinkへの辺張り
for(int i = 0; i < num_problem; i++){
add_edge(problem_index[i],sink,1,0);
}
//袋と課題のマッチング
int tmp_code;
//空袋と全ての課題を繋ぐ
for(int i = 0; i < num_problem; i++){
tmp_code = 0;
for(int k = 0; k < num_item; k++){
tmp_code += problem[i][k]*POW[k];
}
if(min_cost[tmp_code] != BIG_NUM){
add_edge(empty_bag,problem_index[i],1,min_cost[tmp_code]);
}
}
//その他の袋と課題を繋ぐ
bool FLG;
for(int i = 0; i < num_bag; i++){
for(int k = 0; k < num_problem; k++){
FLG = true;
for(int a = 0; a < num_item; a++){
if(bag[i][a] > problem[k][a]){ //部品の超過は不可
FLG = false;
break;
}
}
if(!FLG)continue;
tmp_code = 0;
for(int a = 0; a < num_item; a++){
tmp_code += (problem[k][a]-bag[i][a])*POW[a];
}
if(min_cost[tmp_code] != BIG_NUM){
add_edge(bag_index[i],problem_index[k],1,min_cost[tmp_code]);
}
}
}
V = index;
printf("%d\n",min_cost_flow(source,sink,num_student));
}
int main(){
for(int i = 0; i < 9; i++)POW[i] = pow(3,i);
while(true){
scanf("%d %d %d",&num_day,&num_item,&num_limit);
if(num_day == 0 && num_item == 0 && num_limit == 0)break;
func();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e5 + 9, MX = 1e18 + 9;
long long val[inf], color[inf], dp[inf], mxc[inf], n, q;
int main() {
scanf("%d%d", &n, &q);
for (long long i = 1; i <= n; ++i) scanf("%I64d", &val[i]);
for (long long i = 1; i <= n; i++) scanf("%d", &color[i]);
while (q--) {
for (long long i = 1; i <= n; i++) mxc[i] = -MX;
long long x, y, mx = 0, ans = 0;
scanf("%I64d%I64d", &x, &y);
pair<long long, long long> mx1 = make_pair(0, 0), mx2 = make_pair(0, 0);
for (long long i = 1; i <= n; i++) {
if (mx1.second != color[i])
dp[i] = mx1.first + val[i] * y;
else
dp[i] = mx2.first + val[i] * y;
dp[i] = max(dp[i], mxc[color[i]] + val[i] * x);
mxc[color[i]] = max(mxc[color[i]], dp[i]);
pair<long long, long long> te = make_pair(dp[i], color[i]);
if (mx1.second == color[i])
mx1.first = max(mx1.first, dp[i]);
else if (mx2.second == color[i])
mx2.first = max(mx2.first, dp[i]);
else {
if (te > mx1)
mx2 = mx1, mx1 = te;
else if (te > mx2)
mx2 = te;
}
if (mx1 < mx2) swap(mx1, mx2);
ans = max(ans, dp[i]);
}
printf("%I64d\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, t1, t2, t3, a = 0, b = 0, c = 0, d = 0;
cin >> x >> y >> z >> t1 >> t2 >> t3;
a = y - x;
b = z - x;
if (a < 0) {
a = -a;
}
if (b < 0) {
b = -b;
}
c = a * t2 + b * t2 + 3 * t3;
d = a * t1;
if (c <= d) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 1 |
#pragma comment (linker, "/STACK:256000000")
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include<map>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include<fstream>
#include <unordered_map>
#include <cstdlib>
#include <complex>
#include <cctype>
#include <bitset>
using namespace std;
typedef string::const_iterator State;
#define Ma_PI 3.141592653589793
#define eps 1e-5
#define LONG_INF 2000000000000000000LL
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144
#define pb push_back
#define mp make_pair
typedef long long ll;
#define REP(a,b) for(long long a = 0;a < b;++a)
#define ALL(x) (x).begin(),(x).end()
void init() {
iostream::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
void solve() {
int n, m;
cin >> n >> m;
cout << n * m << endl;
}
int main() {
init();
solve();
}
| 0 |
#include<algorithm>
#include<climits>
#include<cmath>
#include<iomanip>
#include<iostream>
#include<list>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<utility>
#include<vector>
#define lint long long
#define REP(i, x, n) for(int i = x ; i < n ; i++)
#define rep(i, n) REP(i, 0, n)
#define repr(i, n) for(int i = n - 1 ; i >= 0 ; i--)
#define SORT(c) sort((c).begin(), (c).end())
#define SORT_INV(c) sort((c).begin(), (c).end(), greater<int>())
#define IINF INT_MAX
#define LLINF LLONG_MAX
using namespace std;
int main(){
int n;
cin >> n;
int field[1010][1010] = {{0}};
rep(i, n){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
REP(j, y1, y2){
field[j][x1]++;
field[j][x2]--;
}
}
rep(j, 1002){
rep(i, 1002){
field[j][i+1] += field[j][i];
}
}
int ans = 0;
rep(j, 1002){
rep(i, 1002){
ans = max(ans, field[j][i]);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
#include <sstream>
#include <fstream>
#include <complex>
#include <stack>
#include <queue>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
static const double EPS = 1e-5;
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
int n,s,a[20];
int dfs(int i, int sum){
if(i==n) return abs(s-sum*2);
if((sum+a[i])*2>s) return dfs(i+1,sum);
return min( dfs(i+1,sum+a[i]), dfs(i+1,sum));
}
int main(void){
while(cin>>n){
if(n==0) break;
REP(i,n) cin>>a[i];
s = accumulate(a,a+n,0);
cout<<dfs(0,0)<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int q;
cin >> q;
for (long long int j = 0; j < q; j++) {
long long int n;
cin >> n;
long long int ones = 0;
while (n > 0) {
long long int x = n & 1;
ones = ones + x;
n = n >> 1;
}
cout << (1 << ones) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
scanf("%d %d", &n, &d);
string s;
int ans = 0, cnt = 0;
bool flag;
for (int i = 0; i < d; i++) {
cin >> s;
flag = false;
for (int j = 0; j < n; j++) {
if (s[j] == '0') {
flag = true;
break;
}
}
if (flag) {
cnt += 1;
ans = max(ans, cnt);
} else {
cnt = 0;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(4), t(4);
for(int i = 0; i < 4; i++) {
cin >> p[i];
}
for(int i = 0; i < 4; i++) {
cin >> t[i];
}
int ans = 10000000;
for(int i = 0; i <= (n + t[0] - 1) / t[0]; i++) {
for(int j = 0; j <= (n + t[1] - 1) / t[1]; j++) {
for(int k = 0; k <= (n + t[2] - 1) / t[2]; k++) {
for(int l = 0; l <= (n + t[3] - 1) / t[3]; l++) {
int cnt = t[0] * i + t[1] * j + t[2] * k + t[3] * l;
int cost = p[0] * i + p[1] * j + p[2] * k + p[3] * l;
if(cnt >= n) {
ans = min(ans, cost);
}
}
}
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct edge {
int nxt, to, id;
} e[N * 3];
int fir[N];
int n, m, a[N], tab[19][N], key[N << 2];
int ans[N * 3];
inline void addedge(int x, int y, int id) {
static int cnt = 0;
e[++cnt] = (edge){fir[x], y, id};
fir[x] = cnt;
}
inline void Build(int D = 0, int L = 1, int R = n) {
if (L == R) {
tab[D][L] = a[L];
return;
}
Build(D + 1, L, ((L + R) >> 1));
Build(D + 1, ((L + R) >> 1) + 1, R);
int l = L, r = ((L + R) >> 1) + 1;
for (int i = L; i <= R; i++) {
if (r > R || (l <= ((L + R) >> 1) && tab[D + 1][l] < tab[D + 1][r]))
tab[D][i] = tab[D + 1][l++];
else
tab[D][i] = tab[D + 1][r++];
}
}
inline void Upd(int r, int &val, int x = 1, int L = 1, int R = n, int D = 0) {
if (L >= r) return;
if (R < r) {
int t = 1e9;
int p = lower_bound(tab[D] + L, tab[D] + R + 1, a[r]) - tab[D];
if (p <= R) t = min(t, tab[D][p] - a[r]);
if (L < p) t = min(t, a[r] - tab[D][p - 1]);
if (t >= val) return;
if (L == R) {
key[x] = min(key[x], t);
val = min(val, key[x]);
return;
}
}
Upd(r, val, x << 1 | 1, ((L + R) >> 1) + 1, R, D + 1);
Upd(r, val, x << 1, L, ((L + R) >> 1), D + 1);
key[x] = min(key[x << 1], key[x << 1 | 1]);
val = min(val, key[x]);
}
inline int Que(int l, int r, int x = 1, int L = 1, int R = n) {
if (l <= L && R <= r) return key[x];
int res = 1e9;
if (l <= ((L + R) >> 1)) res = Que(l, r, x << 1, L, ((L + R) >> 1));
if (((L + R) >> 1) < r)
res = min(res, Que(l, r, x << 1 | 1, ((L + R) >> 1) + 1, R));
return res;
}
int main() {
memset(key, 63, sizeof key);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 1, l, r; i <= m; i++) {
scanf("%d%d", &l, &r);
addedge(r, l, i);
}
Build();
for (int i = 2, t; i <= n; i++) {
t = 1e9;
Upd(i, t);
for (int j = fir[i]; j; j = e[j].nxt) ans[e[j].id] = Que(e[j].to, i);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long f = 1, x = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ '0');
c = getchar();
}
return x * f;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int b[1008], cnt[1008], t;
vector<int> ans;
int main() {
scanf("%d", &t);
while (t--) {
int n, flag = 0;
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++) cnt[i] = 0;
ans.clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
cnt[b[i]]++;
}
for (int i = 1; i <= n; i++) {
flag = 0;
ans.push_back(b[i]);
for (int j = b[i] + 1; j <= 2 * n; j++) {
if (!cnt[j]) {
cnt[j]++;
ans.push_back(j);
flag = 1;
break;
}
}
if (!flag) {
printf("-1\n");
break;
}
}
if (!flag) continue;
for (int j = 0; j < ans.size(); j++) printf("%d ", ans[j]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
long long int a[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
bool pani = 0;
long long int shakti = 0;
long long int ghaas = 0;
long long int waqt = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> s;
int i = 1;
for (auto j : s) {
if (j == 'L') {
waqt += a[i];
if (shakti - a[i] < 0) {
if (pani)
waqt += (a[i] - shakti) * 3;
else
waqt += (a[i] - shakti) * 5;
}
shakti -= a[i];
shakti = max(shakti, 0ll);
} else if (j == 'W') {
pani = 1;
shakti += a[i];
waqt += a[i] * 3;
} else {
ghaas += 2 * a[i];
shakti += a[i];
waqt += a[i] * 5;
}
ghaas = min(ghaas, shakti);
i++;
}
if (shakti) {
waqt -= 4 * ghaas / 2;
waqt -= 2 * (shakti - ghaas) / 2;
}
cout << waqt << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int fpow(int x, int y) {
if (y == 0) return 1;
if (y == 1) return x;
long long res = fpow(x, y / 2);
(res *= res) %= mod;
return y % 2 == 0 ? int(res) : int((res * x) % mod);
}
int num[15], len[15];
inline pair<int, int> getInt(const string& s) {
long long res = 0, clen = 0;
clen = 0;
for (size_t i = 0; i < s.size(); i++) {
int digit = s[i] - '0';
clen += len[digit];
clen %= mod - 1;
res *= fpow(10, len[digit]);
res %= mod;
res += num[digit];
res %= mod;
}
return make_pair(int(res), int(clen));
}
int n, q[100005];
string s, qs[100005];
int main() {
ios::sync_with_stdio(false);
cin >> s >> n;
for (int i = 0; i < n; i++) {
cin >> q[i] >> qs[i];
qs[i] = qs[i].substr(2);
}
for (int i = 0; i < 10; i++) {
num[i] = i;
len[i] = 1;
}
for (int i = n - 1; i >= 0; i--) {
pair<int, int> p = getInt(qs[i]);
num[q[i]] = p.first;
len[q[i]] = p.second;
}
cout << getInt(s).first << endl;
return 0;
}
| 3 |
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;
int main()
{
int h, w;
cin >> h >> w;
vector<vector<bool> > check(h+2, vector<bool>(w+2, true));
for(int y=1; y<=h; ++y){
for(int x=1; x<=w; ++x){
char c;
cin >> c;
if(c == 'o'){
for(int i=0; i<3; ++i)
check[y][x-1+i] = false;
}
else if(c == 'x'){
for(int i=0; i<9; ++i)
check[y-1+i/3][x-1+i%3] = false;
}
}
}
int ans = 0;
for(int y=2; y<=h; ++y){
for(int x=1; x<=w; ++x){
if(check[y][x])
++ ans;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int inf = 2e7 + 10;
using namespace std;
struct node {
long long l, r;
int id;
friend bool operator<(const node& aa, const node& bb) { return aa.r > bb.r; }
} ils[maxn], brs[maxn];
struct Node {
long long l;
int id;
} a[maxn];
priority_queue<node> q;
int b[maxn];
bool cmp(node aa, node bb) { return aa.l < bb.l; }
bool cmp1(Node aa, Node bb) { return aa.l < bb.l; }
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%lld%lld", &ils[i].l, &ils[i].r);
for (int i = 0; i < m; i++) {
scanf("%lld", &a[i].l);
a[i].id = i + 1;
}
if (n - 1 > m) {
printf("No\n");
return 0;
}
for (int i = 1; i < n; i++) {
brs[i - 1].l = ils[i].l - ils[i - 1].r;
brs[i - 1].r = ils[i].r - ils[i - 1].l;
brs[i - 1].id = i - 1;
}
sort(brs, brs + n - 1, cmp);
sort(a, a + m, cmp1);
int num = 0, cnt = 0;
for (int i = 0; i < m; i++) {
while (cnt < n - 1 && brs[cnt].l <= a[i].l) {
q.push(brs[cnt]);
cnt++;
}
if (q.empty()) continue;
node t = q.top();
q.pop();
if (t.r < a[i].l) break;
b[t.id] = a[i].id;
num++;
}
if (num == n - 1) {
printf("Yes\n");
for (int i = 0; i < n - 1; i++)
printf("%d%c", b[i], i == n - 2 ? '\n' : ' ');
printf("\n");
} else
printf("No\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2105;
int n;
int bit[N];
map<pair<int, int>, int> cache;
int query_made = 0;
int ask(int i, int j) {
if (i > j) swap(i, j);
if (cache.find({i, j}) != cache.end()) return cache[{i, j}];
++query_made;
printf("? %d %d\n", i + 1, j + 1);
fflush(stdout);
int ret;
scanf("%d", &ret);
if (ret == -1) assert(0);
return cache[{i, j}] = ret;
}
int ans[N];
int solve() {
scanf("%d", &n);
vector<int> idxs(n);
iota(idxs.begin(), idxs.end(), 0);
int i = idxs[0], j = idxs[1], OR = ask(0, 1);
for (int k = 2; k < n; ++k) {
int tmp = ask(j, idxs[k]);
if (OR < tmp)
;
else if (OR > tmp) {
i = idxs[k];
OR = tmp;
} else {
j = idxs[k];
OR = ask(i, j);
}
}
int zero = -1;
while (zero == -1) {
int r = rand() % n;
if (r == i || r == j) continue;
if (ask(r, i) < ask(r, j)) {
zero = i;
} else if (ask(r, i) > ask(r, j)) {
zero = j;
}
}
for (int i = 0; i < n; ++i) {
if (zero == i) {
ans[i] = 0;
} else {
ans[i] = ask(zero, i);
}
}
printf("!");
for (int i = 0; i < n; ++i) printf(" %d", ans[i]);
printf("\n");
fflush(stdout);
return 0;
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int t, i, j, k, n, temp, flag;
int main() {
fast();
cin >> t;
while (t--) {
cin >> n;
map<pair<int, int>, int> ans;
vector<pair<int, int> > v(n), u(n);
int c[3] = {0};
for (i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
u[i].first = v[i].first;
u[i].second = v[i].second;
}
sort(v.begin(), v.end());
ans[v[0]] = 1;
int r = v[0].second;
int ca = 1;
c[ca]++;
for (i = 1; i < n;) {
if (v[i].first <= r) {
while (v[i].first <= r && i < n) {
ans[v[i]] = ca;
r = max(r, v[i].second);
c[ca]++;
i++;
}
} else {
if (c[1] == 0) {
ca = 1;
ans[v[i]] = ca;
c[ca]++;
} else {
ca = 2;
ans[v[i]] = ca;
c[ca]++;
}
i++;
r = v[i].second;
}
}
if (c[1] == 0 || c[2] == 0) {
cout << -1 << '\n';
} else {
for (i = 0; i < n; i++) {
cout << ans[u[i]] << ' ';
}
cout << '\n';
;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100000], b[100000];
int ans[200][200];
int main() {
int n, a, b;
cin >> n >> a >> b;
int c = 2;
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++) {
if (c > n) break;
if ((i + j) % 2) {
ans[i][j] = c;
c += 2;
}
}
if (c <= n) {
cout << -1;
return 0;
}
c = 1;
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++) {
if (c > n) break;
if ((i + j + 1) % 2) {
ans[i][j] = c;
c += 2;
}
}
if (c <= n) {
cout << -1;
return 0;
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1001], b[26];
set<pair<int, int> > s1;
set<pair<int, int> >::iterator it;
void soe() {
int i, j;
for (i = 2; i <= 32; i++) {
if (a[i] == 1) {
for (j = i * i; j <= 1000; j += i) a[j] = 0;
}
}
}
int main() {
string s;
int i, j, val, val1, x, cnt, flag = 1, flag1;
for (i = 2; i <= 1000; i++) a[i] = 1;
soe();
cin >> s;
for (i = 0; i < s.length(); i++) {
b[s[i] - 97]++;
}
for (i = 0; i < 26; i++) {
if (b[i] > 0) s1.insert({b[i], i});
}
for (i = 0; i < s.length(); i++) s[i] = '0';
for (i = 2; i <= s.length(); i++) {
if (a[i] == 0) continue;
flag1 = 0;
x = -1;
cnt = 0;
for (j = i; j <= s.length(); j += i) {
if (s[j - 1] != '0') {
if (flag1 == 0) {
x = s[j - 1] - 97;
cnt++;
flag1 = 1;
} else if (flag1 == 1) {
if (x == s[j - 1] - 97)
cnt++;
else {
flag1 = 2;
break;
}
}
}
}
if (flag1 == 0) {
it = s1.end();
it--;
if ((*it).first >= s.length() / i) {
val = (*it).first;
val1 = (*it).second;
for (j = i; j <= s.length(); j += i) s[j - 1] = (*it).second + 97;
s1.erase({val, val1});
if (val - s.length() / i > 0) s1.insert({val - s.length() / i, val1});
} else {
flag = 0;
break;
}
} else if (flag1 == 1) {
for (it = s1.begin(); it != s1.end(); it++) {
if ((*it).second == x && (*it).first >= s.length() / i - cnt) {
for (j = i; j <= s.length(); j += i) s[j - 1] = x + 97;
val = (*it).first;
val1 = (*it).second;
s1.erase({val, val1});
if (val - s.length() / i + cnt > 0)
s1.insert({val - (s.length() / i) + cnt, val1});
break;
}
}
if (s[i - 1] == '0') {
flag = 0;
break;
}
} else {
flag = 0;
break;
}
}
if (flag == 1) {
for (i = 0; i < s.length(); i++) {
if (s[i] == '0') {
it = s1.end();
it--;
val = (*it).first;
val1 = (*it).second;
s[i] = (*it).second + 97;
s1.erase({val, val1});
if (val > 1) s1.insert({val - 1, val1});
}
}
}
if (flag == 1) {
cout << "YES\n";
cout << s;
} else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char S[200000];
long long get(long long x) {
long long cnt = 0;
while (x % 2 == 0) {
cnt++;
x >>= 1;
}
return cnt;
}
int main() {
long long n, q;
cin >> n >> q;
long long H = get(n + 1);
for (int i = 0; i < (q); i++) {
long long u;
scanf("%lld%s", &u, S);
string s = S;
long long h = get(u);
for (char c : s) {
if (h) {
long long d = 1LL << (h - 1);
if (c == 'L') {
u -= d;
} else if (c == 'R') {
u += d;
}
}
if (c == 'U' && h + 1 < H) {
long long d = 1LL << (h + 1);
if ((u / d) % 2 == 0) {
u += (1LL << h);
} else
u -= (1LL << h);
}
h = get(u);
}
printf("%lld\n", u);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, t;
const string A = "Alice";
const string B = "Bob";
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> k;
if (k % 3 == 0) {
int mod = n % (k + 1);
if (mod % 3 == 0 && mod != k) {
cout << B << "\n";
continue;
}
} else {
int mod = n % 3;
if (mod == 0) {
cout << B << "\n";
continue;
}
}
cout << A << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long k, long long p) {
int r = 1;
while (k) {
if (k & 1) r = ((long long)r * x) % p;
k >>= 1;
x = ((long long)x * x) % p;
}
return r;
}
const int MOD = 1000000007;
int n, t[110000], cnt[110000];
vector<int> d[110000];
int f(vector<int> &x) {
int ans = 1;
for (int i = 1; i <= x.size(); i++) {
int left = cnt[x[i - 1]] - (i == x.size() ? cnt[110000 - 1] : cnt[x[i]]);
ans = (long long)ans * power(i, left, MOD) % MOD;
}
return ans;
}
int main() {
for (int i = 1; i < 110000; i++)
for (int j = i; j < 110000; j += i) d[j].push_back(i);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &t[i]);
for (int i = 0; i < n; i++) ++cnt[t[i]];
for (int i = 110000 - 1; i; i--) cnt[i - 1] += cnt[i];
int ans = 1;
for (int m = 2; m < 110000; m++) {
ans = (ans + f(d[m])) % MOD;
d[m].pop_back();
ans = (ans + MOD - f(d[m])) % MOD;
}
printf("%d\n", ans);
}
| 3 |
#include <iostream>
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <math.h>
using namespace std;
int main(){
int a,b,c,d,x,y,n;
while(cin>>a>>b>>c,a){
x=a*a+b*b;
if(b*b+c*c<x)x=b*b+c*c;
if(c*c+a*a<x)x=c*c+a*a;
cin>>n;
for(int i=0;i<n;i++){
cin>>y;
if(x<y*y*4)cout<<"OK"<<endl;
else cout<<"NA"<<endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2050;
const int M = 1e6 + 500;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int LOG = 20;
const int ALP = 30;
const int BASE = 31337;
const double EPS = 1e-9;
const double PI = 3.1415926535;
int a[20][N], n, m;
int dp[20][5000], mx[20][5000], naj[N], P[N];
bool cmp(int i, int j) { return naj[i] > naj[j]; }
void calc_mx(int i, int ii) {
for (int j = 0; j < (1 << n); j++) {
mx[ii][j] = 0;
for (int sh = 0; sh < n; sh++) {
int cur = 0;
for (int k = 0; k < n; k++)
if (j & (1 << k)) cur += a[(sh + k) % n][i];
mx[ii][j] = max(mx[ii][j], cur);
}
}
}
int f(int x, int msk) {
if (x == m || x == 12) return 0;
if (dp[x][msk] != -1) return dp[x][msk];
int ret = f(x + 1, msk);
int nmsk = (1 << n) - 1 - msk;
for (int msk2 = nmsk; msk2 > 0; msk2 = (msk2 - 1) & nmsk) {
ret = max(ret, f(x + 1, msk | msk2) + mx[x][msk2]);
}
return dp[x][msk] = ret;
}
void solve() {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) P[i] = i, naj[i] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &a[i][j]), naj[j] = max(naj[j], a[i][j]);
sort(P, P + m, cmp);
for (int i = 0; i < m && i < 12; i++) calc_mx(P[i], i);
printf("%d\n", f(0, 0));
}
int main() {
int T;
scanf("%d", &T);
for (; T--;) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int c[2000];
bool used[2000];
bool e[1002][1002];
long long ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
e[a][b] = e[b][a] = 1;
}
for (int i = 0; i < n; i++) {
m = 0;
for (int j = 1; j <= n; j++) {
if (!used[j] && c[j] > c[m]) m = j;
}
used[m] = 1;
for (int j = 1; j <= n; j++) {
if (!used[j]) ans += c[j] * e[m][j];
}
}
cout << ans << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.