solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long int i, max, n, k, d;
cin >> t;
while (t--) {
max = 0;
cin >> n >> k;
if (k >= n) {
cout << "1" << endl;
continue;
}
for (i = 1; i * i <= n; i++) {
if (i > k) break;
if (n % i == 0) {
if (i <= k && max < i) max = i;
long long int d = n / i;
if (d <= k && max < (d)) max = d;
}
}
cout << (n / max) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> prime;
void sieve(long long int n) {
bool bakh[n + 1];
memset(bakh, true, sizeof(bakh));
for (long long int p = 2; p * p <= n; p++) {
if (bakh[p] == true) {
for (long long int i = p * p; i <= n; i += p) bakh[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (bakh[p]) prime.push_back(p);
}
long long int eulertotient(long long int z) {
long long int fac = z;
for (long long int i = 0; prime[i] * prime[i] <= z; i++) {
if (z % prime[i] == 0) {
fac -= (fac / prime[i]);
while (z % prime[i] == 0) z /= prime[i];
}
}
if (z > 1) fac -= (fac / z);
return fac;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
long long int g = gcd(a, b);
long long int ans = (a * b) / g;
return ans;
}
long long int modInverse(long long int a, long long int m) {
long long int hvf = gcd(a, m);
if (hvf == 1) return power(a, m - 2, m);
return -1;
}
void multiply(long long int F[2][2], long long int M[2][2]) {
long long int x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long int y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long int z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long int w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
void powermat(long long int F[2][2], long long int n) {
if (n == 0 || n == 1) return;
long long int M[2][2] = {{1, 1}, {1, 0}};
powermat(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
long long int fib(long long int n) {
long long int F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
powermat(F, n - 1);
return F[0][0];
}
vector<long long int> merge(vector<long long int> v1,
vector<long long int> v2) {
vector<long long int> temp;
long long int i = 0, j = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[j])
temp.push_back(v1[i]), i++;
else
temp.push_back(v2[j]), j++;
}
while (i < v1.size()) temp.push_back(v1[i]), i++;
while (j < v2.size()) temp.push_back(v2[j]), j++;
return temp;
}
long long int lps[1000005];
void kmplps(string st) {
long long int p = st.size();
lps[0] = 0;
long long int i = 1, l = 0;
while (i < p) {
if (st[i] == st[l]) {
l++;
lps[i] = l;
i++;
} else {
if (l != 0)
l = lps[l - 1];
else
lps[i] = 0, i++;
}
}
}
bool kmpsearch(string pat, string st) {
bool ms = 0;
long long int c = 0;
long long int a = pat.size(), b = st.size();
kmplps(pat);
long long int i = 0, j = 0;
while (i < b) {
if (pat[j] == st[i]) j++, i++;
if (j == a) {
c++;
if (i == b && c >= 3) ms = 1;
j = lps[j - 1];
} else if (i < b && pat[j] != st[i]) {
if (j != 0)
j = lps[j - 1];
else
i += 1;
}
}
if (c >= 3 && ms) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string st;
cin >> st;
long long int n = st.size();
kmplps(st);
long long int p = lps[n - 1];
while (p != 0) {
string s(st, 0, p);
if (kmpsearch(s, st)) {
cout << s << endl;
return 0;
}
p = lps[p - 1];
}
cout << "Just a legend" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string suffics(string s, int k) {
const string let("aeiou");
int i = s.size() - 1;
for (; k && i >= 0; i--) {
if (let.find(s[i]) != -1) k--;
}
if (k > 0) return s.substr(s.size());
return s.substr(i + 1);
}
string get_rifm(string prev, string a, string b, string c, string d) {
if (prev == "NO") return "NO";
if (a == "" || b == "" || c == "" || d == "") return "NO";
if (prev == "aaaa") {
if (a == b && b == c && c == d) return "aaaa";
if (a == b && d == c) return "aabb";
if (a == c && b == d) return "abab";
if (a == d && b == c) return "abba";
}
if (prev == "abba") {
if (a == b && b == c && c == d) return "abba";
if (a == d && b == c) return "abba";
}
if (prev == "aabb") {
if (a == b && b == c && c == d) return "aabb";
if (a == b && c == d) return "aabb";
}
if (prev == "abab") {
if (a == b && b == c && c == d) return "abab";
if (a == c && b == d) return "abab";
}
return "NO";
}
int main() {
string rifm("aaaa");
int n, k;
cin >> n >> k;
while (n--) {
string a, b, c, d;
cin >> a >> b >> c >> d;
a = suffics(a, k);
b = suffics(b, k);
c = suffics(c, k);
d = suffics(d, k);
rifm = get_rifm(rifm, a, b, c, d);
}
cout << rifm;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, m = 0;
long long res;
scanf("%d%d", &n, &m);
for (int b = 1; b <= n; ++b) {
long long tmp = (long long)b * b;
if (tmp <= m) {
res += (tmp << 1) - 1;
} else {
res += m << 1;
}
}
for (int u = -n * 2; u < 0; ++u) {
int v = max(-2 * n - u, m / u);
if (u & 1) {
--v;
}
int tmp = -1 - v + 1 >> 1;
if (tmp > 1) {
res -= tmp - 1;
}
}
printf("%I64d", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200003], b[200003], c[200003], d[200003];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[i] = a[i] - a[i - 1];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
d[i] = b[i] - b[i - 1];
}
if (a[1] != b[1] || a[n] != b[n]) {
puts("No");
return 0;
}
sort(c + 1, c + n + 1);
sort(d + 1, d + n + 1);
for (int i = 2; i < n; i++)
if (c[i] != d[i]) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i < n; ++i) {
if (s[i] < s[i - 1]) {
cout << "YES\n" << i << ' ' << i + 1;
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void HoH() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
HoH();
int n;
string s;
cin >> n >> s;
string mini = s;
for (int i = 0; i < 99999; i++) {
while (s[0] != '0') {
for (int i = 0; i < s.size(); i++) {
if (s[i] == '9')
s[i] = '0';
else
s[i]++;
}
}
if (s < mini) mini = s;
char one, two, three, four;
one = s[0];
s[0] = s[s.size() - 1];
int temp = one;
for (int j = 1; j < s.size(); j++) {
int prev = s[j];
s[j] = temp;
temp = prev;
}
}
cout << mini;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> stud(n);
vector<int> sec(n, 0);
vector<int> poss;
int temp, pos, tempPos;
for (int i = 0; i < n; i++) cin >> stud[i];
for (int j = 0; j < m; j++) {
pos = -1;
temp = 0;
for (int i = 0; i < n; i++) {
if (stud[i][j] > temp) {
pos = i;
temp = stud[i][j];
} else if (stud[i][j] == temp) {
if (tempPos != temp) poss.clear();
tempPos = temp;
if (pos >= 0) poss.push_back(pos);
pos = -2;
poss.push_back(i);
temp = stud[i][j];
}
}
if (pos == -2) {
for (int i = 0; i < poss.size(); i++) sec[poss[i]] = 1;
} else if (pos != -1)
sec[pos] = 1;
poss.clear();
}
for (int i = 1; i < n; i++) sec[0] += sec[i];
cout << sec[0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
map<string, string> m_ap;
for (int i = 1; i <= n; i++) {
string s1, s2;
cin >> s1 >> s2;
s2 = s2 + ";";
m_ap[s2] = s1;
}
for (int i = 1; i <= m; i++) {
string s3, s4;
cin >> s3 >> s4;
cout << s3 << " " << s4 << " "
<< "#" << m_ap[s4] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const long double eps = 1e-8;
long long read() {
char ch = getchar();
long long x = 0;
int op = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') op = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * op;
}
void write(long long a) {
if (a < 0) putchar('-'), a = -a;
if (a >= 10) write(a / 10);
putchar(a % 10 + '0');
}
long long ksm(long long x, long long p) {
long long ret = 1;
for (; p; p >>= 1, x = x * x)
if (p & 1) ret = ret * x;
return ret;
}
int n, d[1005], ans;
int main() {
n = read();
for (int i = (1); i <= (n - 1); i++) {
int x = read(), y = read();
d[x]++;
d[y]++;
}
for (int i = (1); i <= (n); i++)
if (d[i] == 1) ans++;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long solve(long long C, long long H_R, long long H_B, long long W_R,
long long W_B) {
long long ret = 0;
if (W_R > (long long)3e4) {
for (long long n = 0; n * W_R <= C; n++) {
ret = max(ret, n * H_R + ((C - n * W_R) / W_B) * H_B);
}
} else {
for (long long m = 0; m < W_R; m++)
if (m * W_B <= C) {
ret = max(ret, m * H_B + ((C - m * W_B) / W_R) * H_R);
}
}
return ret;
}
int main() {
long long C, H_R, H_B, W_R, W_B;
scanf("%I64d%I64d%I64d%I64d%I64d", &C, &H_R, &H_B, &W_R, &W_B);
printf("%I64d\n",
max(solve(C, H_R, H_B, W_R, W_B), solve(C, H_B, H_R, W_B, W_R)));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int N, ans = 1;
cin >> N;
int lastA = 0, lastB = 0;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
if (lastA == lastB)
lastA++, lastB++;
else {
if (lastA < lastB)
lastA = lastB;
else
lastB = lastA;
}
if (lastA <= a && lastB <= b) ans += min(a - lastA + 1, b - lastB + 1);
lastA = a;
lastB = b;
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[100001];
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
long long int mod = 1000000009;
int lcm(int a, int b) { return ((a * b) / gcd(a, b)); }
long long int pw(long long int b, long long int p) {
if (!p) return 1;
long long int sq = pw(b, p / 2);
sq = (sq * sq) % mod;
if (p % 2) sq = (sq * b) % mod;
return sq;
}
long long int num;
long long int cnt;
string a[2], b[2];
map<int, int> mp;
int f(int n) {
long long int cnt = 0;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
if (mp[i])
cnt--;
else
cnt++;
n /= i;
}
}
if (n > 1 && mp[n])
cnt--;
else if (n > 1)
cnt++;
return cnt;
}
int d[100000];
int main() {
long long int a, b, c;
cin >> a >> b >> c;
long long int st = 0, end = 10000000000, mid = 0;
while (st < end) {
mid = st + (end - st) / 2;
if (mid * c > b ||
(a - (mid * c)) / c * (c - 1) + (a - (mid * c)) % c >= b - mid * c) {
end = mid;
} else {
st = mid + 1;
}
}
long long int o = ((pw(2, st + 1) - 2 + mod) * c) % mod;
cout << (o + b - st * c) % mod;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 998244353;
inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline int sub(int a, int b) { return (a - b + mod) % mod; }
inline int mul(int a, int b) { return a * 1ll * b % mod; }
int f[N];
int fp(int b, int p) {
if (p == 0) return 1;
return mul(fp(mul(b, b), p / 2), p & 1 ? b : 1);
}
int inv(int n) { return fp(n, mod - 2); }
int nCk(int n, int k) { return mul(mul(f[n], inv(f[k])), inv(f[n - k])); }
void givemeareasontokeepgoing() {
f[0] = 1;
for (int i = 1; i < N; ++i) f[i] = mul(i, f[i - 1]);
int n;
cin >> n;
vector<string> a(n);
for (string &s : a) cin >> s;
int cntW = 0, cntB = 0;
for (string &s : a) {
cntW += s[0] == 'W';
cntW += s[1] == 'W';
cntB += s[0] == 'B';
cntB += s[1] == 'B';
}
if (cntB > n || cntW > n) {
cout << 0;
return;
}
int res = nCk(2 * n - cntW - cntB, n - cntW);
int ways = 1;
for (string s : a) {
ways = mul(
ways, (int)(s[0] != 'W' && s[1] != 'B') + (s[0] != 'B' && s[1] != 'W'));
}
res = sub(res, ways);
bool wb = true, bw = true;
for (string s : a) {
bw &= (s[0] != 'W' && s[1] != 'B');
wb &= (s[0] != 'B' && s[1] != 'W');
}
res = add(res, (int)bw + wb);
cout << res << ' ';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) givemeareasontokeepgoing();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> sides;
vector<pair<long long, long long>> diva;
vector<pair<long long, long long>> divb;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long a, b;
cin >> a >> b;
for (long long i = 1; i * i <= a + b; i++) {
if ((a + b) % i == 0) sides.push_back({i, (a + b) / i});
}
for (long long i = 1; i * i <= b; i++) {
if (b % i == 0) divb.push_back({i, b / i});
}
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0) diva.push_back({i, a / i});
}
long long ans = 2 * (a + b + 1);
long long idxa = 0, idxb = 0;
for (auto p : sides) {
while (idxa < diva.size() - 1 && p.first >= diva[idxa + 1].first) idxa++;
while (idxb < divb.size() - 1 && p.first >= divb[idxb + 1].first) idxb++;
if ((p.first >= diva[idxa].first && p.second >= diva[idxa].second) ||
(p.first >= divb[idxb].first && p.second >= divb[idxb].second)) {
ans = min(ans, 2 * (p.first + p.second));
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int f = 1000002;
long long n, a, b, c, d, t[f], e[f], k[f], dp[f], mini = 1e18, es;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b >> c >> d;
for (int i = 1; i <= n; i++) {
dp[i] = mini;
cin >> t[i];
k[i] = a * t[i] + c;
e[i] = min({a + b, t[i] * a + 2 * a, t[i] * a + c});
es += e[i];
}
for (int i = 1; i <= n; i++) {
mini =
min(mini, dp[i - 1] + es + min(k[n] - e[n], 2 * d) + 2 * d * (n - i));
es -= e[i];
dp[i] = min(dp[i], dp[i - 1] + k[i] + d);
dp[i + 1] = min(dp[i + 1], dp[i - 1] + e[i] + e[i + 1] + 4 * d);
}
mini = min(mini, dp[n] - d);
cout << mini << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
void solve() {
int n, d, m;
cin >> n >> d >> m;
for (int i = (0); (1) > 0 ? i < (m) : i > (m); i += (1)) {
int x, y;
cin >> x >> y;
if (x - y <= d && x - y >= -d && x + y <= 2 * n - d && x + y >= d)
cout << "YES\n";
else
cout << "NO\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[5009][5009];
int cu[5009][5009];
int main() {
int i, j, k, n, m, d;
while (cin >> n >> m) {
for (i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (s[i][j] == '1') cu[i][j] = cu[i][j - 1] + 1;
}
}
int ans = 0;
for (j = 1; j <= m; j++) {
vector<int> v;
for (i = 1; i <= n; i++) v.push_back(cu[i][j]);
sort(v.begin(), v.end());
for (i = 0; i < n; i++) ans = max(ans, v[i] * (n - i));
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
long long i;
int main() {
scanf("%lld", &n);
a = 1, b = 2;
i = 1;
while (b <= n - a) {
i++;
a += b;
swap(a, b);
}
printf("%lld", i);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c, q, cnt;
int ata[500005];
set<int> s[500005];
map<pair<int, int>, int> mp;
int bul(int node) {
if (ata[node] == node) return node;
return ata[node] = bul(ata[node]);
}
void merge(int a, int b) {
if ((a = bul(a)) != (b = bul(b))) {
if (((int)s[a].size()) < ((int)s[b].size())) swap(a, b);
for (auto x : s[b]) s[a].insert(x);
s[b].clear();
ata[b] = a;
}
}
void nn(int a, int c) {
mp[{a, c}] = ++cnt;
ata[cnt] = cnt;
s[cnt].insert(a);
}
void add(int x, int y, int z) {
if (!mp[{x, z}]) nn(x, z);
if (!mp[{y, z}]) nn(y, z);
merge(x, mp[{y, z}]);
merge(y, mp[{x, z}]);
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
for (int i = 1; i <= n; i++) ata[i] = ++cnt;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
add(x, y, z);
}
while (q--) {
char t;
scanf(" %c", &t);
if (t == '?') {
int x, y;
scanf("%d %d", &x, &y);
if (bul(x) == bul(y) || s[bul(x)].find(y) != s[bul(x)].end())
printf("Yes\n");
else
printf("No\n");
} else {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
add(x, y, z);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, eight = 0;
char s[100010];
cin >> n;
cin >> s;
for (int i = 0; i < n - 10; i++) {
if (s[i] == '8') eight++;
}
if (2 * eight > (n - 10))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 3.1415926535897932384626433832795028841;
map<string, int> ssol;
void checkAdd(string vs) {
if (ssol.find(vs) != ssol.end()) {
return;
}
ssol[vs] = 1;
}
bool TST = 0;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void Show(int *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
void ShowLL(long long *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
int a1[4];
int b1[4];
int gd(int num, int d) {
while (d--) num /= 10;
return num % 10;
}
set<int> pos;
bool dif(int n) {
if (gd(n, 0) == gd(n, 1)) return 0;
if (gd(n, 0) == gd(n, 2)) return 0;
if (gd(n, 0) == gd(n, 3)) return 0;
if (gd(n, 1) == gd(n, 2)) return 0;
if (gd(n, 1) == gd(n, 3)) return 0;
if (gd(n, 2) == gd(n, 3)) return 0;
return 1;
}
bool valid(int original, int target, int b, int c) {
int cnt = 0;
while (cnt < 4) {
a1[cnt++] = original % 10;
original /= 10;
}
cnt = 0;
while (cnt < 4) {
b1[cnt++] = target % 10;
target /= 10;
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (a1[i] == b1[j]) {
if (i == j) b--;
if (i != j) c--;
}
}
}
return (b == 0) and (c == 0);
}
int main() {
for (int i = 0; i < 10000; i++) {
if (dif(i)) pos.insert(i);
}
int last_c = 0;
int last_b = 0;
int st = 1;
while (pos.size() > 1) {
vector<int> vls;
for (set<int>::iterator it = pos.begin(); it != pos.end(); it++)
vls.push_back(*it);
int ans;
if (st == 0) {
int win = -1;
int min_worst_case = INT_MAX;
for (int i = 0; i < vls.size(); i++) {
int max_sum = 0;
for (int b = 0; b <= 4; b++) {
for (int c = 0; c <= 4; c++) {
if (b + c > 4) continue;
int sum = 0;
for (int j = 0; j < vls.size(); j++) {
if (valid(vls[i], vls[j], b, c)) {
sum++;
}
}
max_sum = max(max_sum, sum);
}
}
if (min_worst_case > max_sum) win = i;
min_worst_case = min(min_worst_case, max_sum);
}
ans = vls[win];
} else {
ans = 123;
st = 0;
}
if (ans < 10) cout << 0;
if (ans < 100) cout << 0;
if (ans < 1000) cout << 0;
cout << ans << '\n';
fflush(stdout);
int b, c;
cin >> b >> c;
if (b == 4) return 0;
vector<int> del;
for (int i = 0; i < vls.size(); i++) {
if (not valid(ans, vls[i], b, c)) {
del.push_back(vls[i]);
}
}
for (int i = 0; i < del.size(); i++) {
pos.erase(del[i]);
}
}
int rta = *(pos.begin());
if (rta < 10) cout << 0;
if (rta < 100) cout << 0;
if (rta < 1000) cout << 0;
cout << rta << '\n';
fflush(stdout);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
long long xx[310];
int mod[310];
int i, j, k;
int ans = -1;
scanf("%d %d", &p, &n);
memset(xx, 0, sizeof(xx));
memset(mod, 0, sizeof(mod));
for (i = 1; i <= n; i++) {
scanf("%I64d", &xx[i]);
}
for (i = 1; i <= n; i++) {
mod[xx[i] % p]++;
if (mod[xx[i] % p] == 2) {
ans = i;
break;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
if (s == "01" || s == "10") {
cout << 1 << endl;
} else {
unordered_map<char, long long> m;
for (long long i = 0; i < s.size(); i++) {
m[s[i]]++;
}
if (m['0'] == 0) {
cout << 0 << endl;
} else {
long long z = 0;
long long i = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == '0') {
if (s[i + 1] != '0' && i + 1 < s.size()) {
z++;
} else {
if (i == s.size() - 1) {
z++;
}
}
}
}
if (z == 1) {
cout << 1 << endl;
} else {
cout << 2 << endl;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define For(i, j, k) for(int i = j; i <= k; i++)
#define pb push_back
using namespace std;
const int N = 100010;
vector<int> G[N];
int n;
bool ans;
bool DFS(int o, int f){
int cnt = 0;
for(int v : G[o]){
if(v == f) continue;
cnt += DFS(v, o);
}
if(cnt > 1) ans = true;
return !cnt;
}
int main(){
while(scanf("%d", &n) == 1){
For(i, 1, n) G[i].clear();
ans = n & 1;
For(i, 2, n){
int u, v;
scanf("%d%d", &u, &v);
G[u].pb(v), G[v].pb(u);
}
DFS(1, 0);
puts(ans ? "First" : "Second");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[8];
int i, j;
for (i = 0; i < 8; i++) cin >> s[i];
for (i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
if (s[i][j] == s[i][j + 1]) return cout << "NO", 0;
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> primes;
void Sieve(long long n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
vector<pair<long long, long long>> pf;
void primefactors(long long n) {
for (long long i = 2; i * i <= n; i++) {
long long cnt = 0;
while (n % i == 0) {
cnt++;
n /= i;
}
if (cnt > 0) {
pf.push_back({cnt, i});
}
}
if (n > 1) {
pf.push_back({1, n});
}
sort(pf.begin(), pf.end());
reverse(pf.begin(), pf.end());
}
int32_t main() {
long long n, m;
cin >> n >> m;
map<long long, long long> cnt;
vector<long long> v(m);
for (long long i = 0; i < m; i++) {
cin >> v[i];
}
vector<long long> b(m);
for (long long i = 0; i < m; i++) {
cnt[v[i]]++;
if (cnt.size() == n) {
b[i] = 1;
for (long long i = 1; i <= n; i++) {
if (cnt[i] == 1) {
cnt.erase(i);
} else
cnt[i]--;
}
} else
b[i] = 0;
}
for (long long i = 0; i < m; i++) {
cout << b[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n = 1, x = 1;
cin >> n;
while (n > x) {
n -= x;
x++;
}
cout << n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("03")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <class T, class T2>
T _f_pow(T a, T2 b) {
T res = 1LL;
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return (res);
}
template <class T>
T gcd(T a, T b) {
while (a && b)
if (a > b)
(a %= b);
else
(b %= a);
return a + b;
}
template <class T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
int n, q;
int a[(int)1e6 + 5];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n;
for (long long i = (1), _b = (n); i <= _b; i++) cin >> a[i];
sort(a, a + n + 1);
n++;
cin >> q;
while (q--) {
int OoO;
cin >> OoO;
int cnt = upper_bound(a, a + n, OoO) - a;
cout << cnt - 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int check(long long int n) {
set<long long int> s;
long long int cnt = 0;
while (n) {
s.insert(n % 10);
n /= 10;
cnt++;
}
if ((long long int)s.size() == cnt)
return 1;
else
return 0;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int p = n, q = m;
char s[n + m];
s[0] = 'R';
p--;
for (long long int i = 1; i < n + m; i++) {
if (i % 2 != 0) {
if (s[i - 1] == 'R') {
if (q > 0) {
s[i] = 'B';
q--;
} else {
s[i] = 'R';
p--;
}
} else {
if (p > 0) {
s[i] = 'R';
p--;
} else {
s[i] = 'B';
q--;
}
}
} else {
if (s[i - 1] == 'B') {
if (q > 0) {
s[i] = 'B';
q--;
} else {
s[i] = 'R';
p--;
}
} else {
if (p > 0) {
s[i] = 'R';
p--;
} else {
s[i] = 'B';
q--;
}
}
}
}
long long int e = 0, w = 0;
for (long long int i = 0; i < n + m - 1; i++) {
if (s[i] == s[i + 1]) e++;
}
p = n, q = m;
for (long long int i = 0; i < n + m; i++) s[i] = '0';
s[0] = 'B';
q--;
for (long long int i = 1; i < n + m; i++) {
if (i % 2 != 0) {
if (s[i - 1] == 'R') {
if (q > 0) {
s[i] = 'B';
q--;
} else {
s[i] = 'R';
p--;
}
} else {
if (p > 0) {
s[i] = 'R';
p--;
} else {
s[i] = 'B';
q--;
}
}
} else {
if (s[i - 1] == 'B') {
if (q > 0) {
s[i] = 'B';
q--;
} else {
s[i] = 'R';
p--;
}
} else {
if (p > 0) {
s[i] = 'R';
p--;
} else {
s[i] = 'B';
q--;
}
}
}
}
for (long long int i = 0; i < n + m - 1; i++) {
if (s[i] == s[i + 1]) w++;
}
cout << max(e, w) << " " << n + m - max(e, w) - 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%lld %lld", &n, &k);
long long l = 1, r = n;
srand(time(NULL));
while (1) {
if (r - l + 1 > 40) {
long long mid = (r + l) / 2;
printf("%lld %lld\n", l, mid);
fflush(stdout);
string s;
cin >> s;
if (s == "Yes") {
l = l - k;
r = mid + k;
} else {
l = mid + 1 - k;
r = r + k;
}
l = max(l, 1ll);
r = min(r, n);
} else {
long long first = rand() % (r - l + 1);
printf("%lld %lld\n", first + l, first + l);
fflush(stdout);
string s;
cin >> s;
if (s == "Yes") return 0;
l = l - k;
r = r + k;
l = max(l, 1ll);
r = min(r, n);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, maxn = 1e6 + 5;
string s;
long long H[maxn], P, rema[maxn], remb[maxn];
int a, b, n;
bool check;
int main() {
cin >> s;
cin >> a >> b;
n = s.size();
s = " " + s;
check = false;
rema[1] = (s[1] - 48) % a;
remb[n] = (s[n] - 48) % b;
for (int i = 2; i <= n; ++i) {
rema[i] = (rema[i - 1] * 10 + s[i] - 48) % a;
}
P = 1;
for (int i = n - 1; i >= 1; --i) {
P = P * 10 % b;
remb[i] = (remb[i + 1] + (s[i] - 48) * P) % b;
}
for (int i = 1; i < n; ++i)
if (rema[i] == 0 && remb[i + 1] == 0 && s[i + 1] != '0') {
check = true;
cout << "YES" << endl;
for (int j = 1; j <= i; ++j) cout << s[j];
cout << endl;
for (int j = i + 1; j <= n; ++j) cout << s[j];
break;
}
if (check == false) cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, a[200000], b[200000];
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
int a_flag = 0, b_flag = 0;
for (; a_flag < n; a_flag++) {
while (a[a_flag] != b[b_flag] && b_flag < n) b_flag++;
if (b_flag == n) break;
}
printf("%d\n", n - a_flag);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int r[10];
int n;
char c;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c;
if (c == 'L') {
for (int j = 0; j < 10; j++) {
if (r[j] == false) {
r[j] = true;
break;
}
}
} else if (c == 'R') {
for (int j = 9; j >= 0; j--) {
if (r[j] == false) {
r[j] = true;
break;
}
}
} else {
r[c - '0'] = false;
}
}
for (int j = 0; j < 10; j++) {
cout << (r[j] ? '1' : '0');
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
string str;
cin >> str;
long long int zeros = 0;
for (long long int i = 0; i < n; i++) {
if (str[i] == '0') {
zeros++;
}
}
if (zeros == 0) {
for (long long int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
} else {
map<pair<long long int, char>, long long int> mp;
long long int index, val;
for (long long int i = 0; i < n; i++) {
mp.insert({{arr[i], str[i]}, 0});
}
long long int nz = 1, no = 1;
for (auto it : mp) {
val = it.first.first;
if (it.first.second == '0') {
mp[{val, '0'}] = nz;
nz++;
} else {
mp[{val, '1'}] = no + zeros;
no++;
}
}
for (long long int i = 0; i < n; i++) {
val = arr[i];
char ch = str[i];
cout << mp[{val, ch}] << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[10005];
int main() {
int n;
for (int i = 1; i < 10005; i++) a[i] = i;
scanf("%d", &n);
int d = n / 2;
int k = 0, r = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < d; j++) {
printf("%d %d ", a[r], a[n * n - k]);
k++;
r++;
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
long long k, res, x;
long long a[1000000];
int tot;
inline bool check(long long x) {
for (int i = 2; i <= tot; i++) {
if (a[i] >= x) return 1;
if (x % a[i] == 0) return 0;
}
}
inline void dismiss(long long x, long long y) {
if (res == N) return;
if (x == 1) {
if (res == N) return;
printf("1 ");
res++;
return;
}
if (check(x)) {
for (int i = 1; i <= y; i++) {
if (res == N) return;
printf("1 ");
res++;
}
if (res == N) return;
printf("%I64d ", x);
res++;
return;
}
if (y == 0) {
if (res == N) return;
printf("%I64d ", x);
res++;
return;
}
int ts = 0;
for (int i = 1; i <= tot; i++)
if (x % a[i] == 0)
dismiss(a[i], y - 1);
else if (a[i] > x)
break;
}
int main() {
cin >> x >> k;
if (k == 0) {
cout << x << endl;
return 0;
}
if (x == 1) {
puts("1");
return 0;
}
if (k >= N) {
for (int i = 1; i <= N; i++) printf("1 ");
printf("\n");
return 0;
}
tot = 0;
for (long long i = 1; i <= floor(sqrt(x)); i++)
if (x % i == 0) {
long long j = x / i;
a[++tot] = i;
if (i != j) a[++tot] = j;
}
sort(a + 1, a + tot + 1);
res = 0;
dismiss(x, k);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int arr[N];
int idx = 1, n;
int teams[N];
cin >> n;
for (int i = 0; i < (int)(n); ++i) cin >> arr[i];
sort(arr, arr + n);
teams[0] = arr[0];
for (int i = (1); i < (int)(n); ++i) {
bool flag = 1;
for (int j = 0; j < (int)(idx); ++j) {
if (abs(arr[i] - teams[j]) > 1) {
flag = 0;
teams[j] = arr[i];
sort(teams, teams + idx);
}
}
if (flag) {
teams[idx] = arr[i];
++idx;
}
}
cout << idx << "\n";
}
return 0;
}
| 1 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt"
bool check(const string &l, const string &r) {
return l.size() == r.size() ? l < r : l.size() < r.size();
}
int main() {
while (1) {
int W, H; cin >> W >> H;
if (!W)break;
vector<string>sts;
for (int i = 0; i < H; ++i) {
string st; cin >> st;
sts.push_back(st);
}
vector<vector<string>>longs(H,vector<string>(W));
for (int x = 0; x < W; ++x) {
for (int y = 0; y < H; ++y) {
if (isdigit(sts[y][x])) {
longs[y][x] = sts[y][x];
}
}
}
for (int x = 0; x < W; ++x) {
for (int y = 0; y < H; ++y) {
if (isdigit(sts[y][x])) {
if (x > 0) {
longs[y][x] = check(longs[y][x], longs[y][x - 1] + sts[y][x]) ? longs[y][x - 1] + sts[y][x]: longs[y][x] ;
}
if (y > 0) {
longs[y][x] = check(longs[y][x], longs[y-1][x] + sts[y][x]) ? longs[y - 1][x] + sts[y][x]: longs[y][x];
}
if (longs[y][x][0] == '0')longs[y][x] = longs[y][x].substr(1, longs[y][x].size() - 1);
}
}
}
string ans;
for (int x = 0; x < W; ++x) {
for (int y = 0; y < H; ++y) {
ans = check(ans, longs[y][x]) ? longs[y][x]: ans;
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool dfs(int u, vector<vector<pair<int, char> > > &v, vector<int> &m,
char color, int &curGood, int &curBad, vector<int> &touched) {
bool good = true;
if (m[u] == 1)
curGood++;
else if (m[u] == 0)
curBad++;
touched.push_back(u);
for (int i = 0; i < v[u].size(); i++) {
int n = v[u][i].first;
int c = v[u][i].second;
if (m[n] != -1) {
bool res;
if (m[n] == m[u]) {
res = c == color;
} else {
res = c != color;
}
if (!res) return false;
continue;
}
if ((c == color && m[u] == 0) || (c != color && m[u] == 1)) {
m[n] = 0;
} else {
m[n] = 1;
}
bool g = dfs(n, v, m, color, curGood, curBad, touched);
good = good && g;
}
return good;
}
vector<int> solve(vector<vector<pair<int, char> > > &v, char color,
bool &valid) {
vector<int> m(v.size(), -1);
bool good = true;
for (int i = 0; i < v.size(); i++) {
if (m[i] == -1) {
int curGood = 0;
int curBad = 0;
vector<int> touched;
m[i] = 0;
bool g = dfs(i, v, m, color, curGood, curBad, touched);
good = good && g;
if (curBad < curGood) {
for (int j = 0; j < touched.size(); j++) m[touched[j]] ^= 1;
}
}
}
valid = good;
return m;
}
int main() {
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<pair<int, char> > row;
vector<vector<pair<int, char> > > v(N, row);
for (int i = 0; i < M; i++) {
int a, b;
char c;
cin >> a >> b >> c;
a--;
b--;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
bool rValid, bValid;
vector<int> r = solve(v, 'R', rValid);
vector<int> b = solve(v, 'B', bValid);
int rCount = 0;
int bCount = 0;
for (int i = 0; i < r.size(); i++) {
rCount += r[i];
bCount += b[i];
}
if (!rValid) rCount = 1 << 30;
if (!bValid) bCount = 1 << 30;
if (!rValid && !bValid) {
cout << "-1\n" << endl;
return 0;
} else if (rCount < bCount) {
cout << rCount << "\n";
for (int i = 0; i < r.size(); i++) {
if (r[i]) cout << i + 1 << " ";
}
} else {
cout << bCount << "\n";
for (int i = 0; i < b.size(); i++) {
if (b[i]) cout << i + 1 << " ";
}
}
cout << "\n";
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
signed main(){
string s;
int k;
cin>>s>>k;
for(int i=0;i<s.size();i++){
if(s[i]!='a'){
if(k-(26-(s[i]-97))>=0){
k=k-(26-(s[i]-97));
s[i]='a';
}
}
}
if(k%26!=0){
k%=26;
s[s.size()-1]+=k;
}
cout<<s<<"\n";
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int INF = 1000000000;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
long long n = stoll(s);
vector<long long> squares;
squares.reserve(45000);
for (long long i = 1; i * i <= n; i++) squares.push_back(i * i);
int result = INF;
int maxMask = 1 << s.length();
for (int mask = 0; mask < maxMask; mask++) {
vector<char> subseq;
int cntRemoved = 0;
subseq.reserve(s.length());
for (int i = 0; i < s.length(); i++) {
if ((mask & (1 << i)) > 0)
subseq.push_back(s[i]);
else
cntRemoved++;
}
if (subseq.size() == 0 || subseq[0] == '0') continue;
string numStr(subseq.begin(), subseq.end());
long long num = stoll(numStr);
auto it = lower_bound(squares.begin(), squares.end(), num);
if (it != squares.end() && *it == num) result = min(result, cntRemoved);
}
cout << (result == INF ? -1 : result) << endl;
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
int main() {
int t;
cin >> t;
for(int times = 0; times < t; times++) {
int n, k;
cin >> n >> k;
vector<int> x(n);
for(int i = 0; i < n; i++) {
cin >> x[i];
}
vector<int> y(n-1);
for(int i = 0; i < n - 1; i++) {
y[i] = x[i + 1] - x[i];
}
sort(y.begin(), y.end());
cout << accumulate(y.begin(), y.end() - min(k, n) + 1, 0) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111111;
int c1, c2, c3, c4;
int n, m;
int a[N], b[N];
int main() {
scanf("%d%d%d%d", &c1, &c2, &c3, &c4);
scanf("%d%d", &n, &m);
int res1 = 0, res2 = 0, res = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
res1 += min(a[i] * c1, c2);
}
res1 = min(res1, c3);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
res2 += min(b[i] * c1, c2);
}
res2 = min(res2, c3);
res = min(res1 + res2, c4);
printf("%d", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / __gcd(a, b));
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
template <class T>
string itoa(T a) {
if (!a) return "0";
string ret;
for (T i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
double log(double N, double B) { return (log10l(N)) / (log10l(B)); }
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
string toBin(int n) {
string s;
for (int i = 10 - 1; i >= 0; i--) s += ((bool)(n & (1 << i)) + '0');
return s;
}
int a[100002], b[100002];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < (int)n; i++) scanf("%d", &a[i]);
for (int i = 0; i < (int)n; i++) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + n);
int i = 0, j = n - 1, ans = 0;
while (i < n and j >= 0) {
if (a[i] + b[j] >= k) {
ans++;
j--;
}
i++;
}
printf("1 ");
printf("%d\n", ans);
;
return 0;
}
| 4 |
// ※※※ 解答不能 ※※※
// ksun48氏.
// https://atcoder.jp/contests/cf17-final/submissions/1804620
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define repx(i, a, b) for(int i = a; i < b; i++)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
vector<pair<int, int>> ints[410000];
int main(){
int n;
scanf("%d", &n);
int N = (1 << n);
int g[N];
map<int, int> used;
rep(j, N){
scanf("%d", &g[j]);
g[j]--;
used[g[j]] = 1;
}
int maxval[N], minval[N], ok = 1;
repr(j, N - 1, 0){
maxval[j] = N - 1;
if(g[j] != -1) maxval[j] = g[j];
rep(i, n){
if((1 << i) & j) continue;
maxval[j] = min(maxval[j], maxval[j ^ (1 << i)]);
}
}
rep(j, N){
minval[j] = 0;
if(g[j] != -1) minval[j] = g[j];
rep(i, n){
if(((1 << i) & j) == 0) continue;
minval[j] = max(minval[j], minval[j ^ (1 << i)]);
}
}
rep(j, N){
if(minval[j] > maxval[j]){
puts("NO");
return 0;
}
ints[minval[j]].push_back({maxval[j], j});
}
set<pair<int, int>> d;
rep(i, N){
rep(f, ints[i].size()) d.insert(ints[i][f]);
if(d.empty()){
puts("NO");
return 0;
}
pair<int, int> b = *d.begin();
d.erase(d.begin());
if(b.first < i){
puts("NO");
return 0;
}
g[b.second] = i;
}
puts("YES");
rep(j, N){
vector<int> f;
int cj = j;
int r = 0;
rep(i, n){
r = 2 * r + (cj % 2);
cj /= 2;
}
printf("%d ", g[r] + 1);
}
puts("");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m, o1 = 0, o2 = 0, e1 = 0, e2 = 0;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
if (a % 2)
o1++;
else
e1++;
}
for (long long i = 0; i < m; i++) {
long long a;
cin >> a;
if (a % 2)
o2++;
else
e2++;
}
cout << min(o1, e2) + min(o2, e1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, wk, co, md;
int mu[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
while (cin >> n >> d) {
wk = mu[n] + d - 1;
co = 0;
co = wk / 7;
if (wk % 7 != 0) co++;
cout << co << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 52;
int g[2][2][N][N][N * 2];
int f[N * 2][N][2];
int n, m, st[N * N], ed[N * N];
vector<int> seq[N * N];
int e[N][N];
pair<int, int> walk(vector<int> &tp, int x, bool fl) {
int now = 0;
for (; now + 1 <= tp.size();) {
int y = tp[now], ed = e[x][y];
if (!ed || tp.size() > 2 * n || (ed > m) != fl)
return pair<int, int>(23333, -1);
for (int j = 0; j < seq[ed].size(); j++) tp.push_back(seq[ed][j]);
x = y;
now++;
}
return pair<int, int>(tp.size(), x);
}
int man[N][N][N * 2];
int wei[N][N][N * 2];
void work(bool fl) {
memset(man, 0, sizeof(man));
memset(wei, 0, sizeof(wei));
for (int i = 1; i <= 2 * m; i++)
if ((i <= m) ^ fl)
for (int j = 0; j < seq[i].size(); j++)
if (seq[i][j] == st[i]) {
vector<int> t1, t2;
for (int k = j - 1; k >= 0; k--) t1.push_back(seq[i][k]);
pair<int, int> res = walk(t1, st[i], fl ^ 1);
if (res.first > 2 * n) continue;
if (j + 1 == seq[i].size())
wei[res.second][ed[i]][res.first + 1]++;
else if (seq[i][j + 1] == ed[i]) {
for (int k = j + 2; k < seq[i].size(); k++) t2.push_back(seq[i][k]);
pair<int, int> res2 = walk(t2, ed[i], fl);
if (res2.first + 1 + res.first <= 2 * n)
man[res.second][res2.second][res2.first + 1 + res.first]++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
e[x][y] = i;
e[y][x] = i + m;
st[i] = ed[i + m] = x;
st[i + m] = ed[i] = y;
for (int j = 1; j <= k; j++) {
int v;
scanf("%d", &v);
seq[i].push_back(v);
}
seq[i + m] = seq[i];
reverse(seq[i + m].begin(), seq[i + m].end());
if (!k) g[0][0][x][y][1]++;
}
work(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
g[1][1][i][j][k] = man[i][j][k], g[1][0][i][j][k] = wei[i][j][k];
work(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++) g[0][1][j][i][k] = wei[i][j][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n * 2; k++)
for (int v = 0; v <= 1; v++)
(((f[k][j][v]) += (g[1][v][i][j][k])) >= mo ? f[k][j][v] -= mo : 233);
;
for (int k = 1; k <= n * 2; k++) {
int ans = 0;
for (int i = 1; i <= n; i++) {
(((ans) += (f[k][i][1])) >= mo ? ans -= mo : 233);
;
for (int mid = 0; mid <= 1; mid++)
if (f[k][i][mid])
for (int ed = 0; ed <= 1; ed++)
for (int zd = 1; zd <= n; zd++)
for (int l = 1; l <= 2 * n - k; l++)
(((f[k + l][zd][ed]) +=
(1ll * f[k][i][mid] * g[mid ^ 1][ed][i][zd][l] % mo)) >= mo
? f[k + l][zd][ed] -= mo
: 233);
;
}
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long int power(long long int x, long long int n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * x) % 1000000007;
x = (x * x) % 1000000007;
n /= 2;
}
if (x == 0) ans = 0;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
long long int n;
cin >> n;
long long int ans = 0, d = 0, i = 0;
while (n) {
if (n % 10 == 7) {
ans += (1 << i);
}
n = n / 10;
d++;
i++;
}
ans += (1 << d) - 1;
cout << ans;
}
}
| 2 |
#include<bits/stdc++.h>
int X,k,q;
struct ev{
int x,y,id;
bool operator<(const ev&e)const{return x<e.x;}
}e[500007];
int ep=0,as[500007];
int main(){
scanf("%d%d",&X,&k);
for(int i=0,a;i<k;++i){
scanf("%d",&a);
e[ep++]=(ev){a,0,0};
}
scanf("%d",&q);
for(int i=1,a,b;i<=q;++i){
scanf("%d%d",&a,&b);
e[ep++]=(ev){a,b,i};
}
std::sort(e,e+ep);
long long mn=0,mx=X,a=0;
for(int i=0,sgn=-1,t0=0;i<ep;++i){
long long v0=(e[i].x-t0)*sgn;
if(e[i].id){
long long v=e[i].y+a;
if(v<mn)v=mn;
if(v>mx)v=mx;
v+=v0;
if(v<0)v=0;
if(v>X)v=X;
as[e[i].id]=v;
}else{
mn+=v0,mx+=v0,a+=v0;
if(mn<0) mn=0;
if(mx<0) mx=0;
if(mx>X) mx=X;
if(mn>X) mn=X;
t0=e[i].x;
sgn*=-1;
}
}
for(int i=1;i<=q;++i)printf("%d\n",as[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, string> > > m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int s, d, a, b;
cin >> s >> d >> a >> b;
d -= s;
d -= a * 8;
if (d <= 0) {
cout << "0";
return 0;
}
a = a * 12 - b * 12;
if (a <= 0) {
cout << "-1";
return 0;
}
if (d % a == 0)
cout << d / a;
else
cout << d / a + 1;
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[300000];
int main() {
int n;
cin >> n;
for (int i = 0; i < 300000; i++) {
a[i] = -1;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x] = n - i;
}
int mx = -2;
int ans = 0;
for (int i = 0; i < 300000; i++) {
if (a[i] > mx) {
mx = a[i];
ans = i;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void runtime() {
cout << fixed << setprecision(5) << 1.0 * clock() / CLOCKS_PER_SEC << endl;
}
template <class T>
void read(vector<T> &a, int n) {
T x;
a.clear();
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
}
template <class T>
void write(vector<T> &a) {
for (T x : a) cout << x << ' ';
cout << '\n';
}
const int N = 404;
using cd = complex<double>;
const double PI = acos(-1.0);
void fft(vector<cd> &a, bool invert = 0) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
double ang = 2 * PI / len * (invert ? -1 : 1);
cd wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
cd w(1);
for (int j = 0; j < len / 2; j++) {
cd u = a[i + j];
cd v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; i++) a[i] /= n;
}
vector<cd> mult(vector<cd> &a, vector<cd> &b) {
vector<cd> res;
vector<cd> fa(a.begin(), a.end());
vector<cd> fb(b.begin(), b.end());
int n = 1;
while (n < (int)a.size() + (int)b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
res.resize(n);
fft(fa);
fft(fb);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, 1);
for (int i = 0; i < fa.size(); i++) res[i] = (int)(fa[i].real() + 1e-5);
return res;
}
vector<cd> get_scalar(vector<cd> &a, vector<cd> &b) {
vector<cd> ans;
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
for (int i = (int)b.size() - 1; i < a.size(); i++) ans.push_back(res[i]);
return ans;
}
vector<cd> get(string second, string t) {
vector<cd> a, b;
for (int i = 0; i < second.size(); i++) {
double alp = 2 * PI * (second[i] - 'a') / 26;
a.push_back(cd(cos(alp), sin(alp)));
}
for (int i = 0; i < t.size(); i++) {
if (t[i] >= 'a' && t[i] <= 'z') {
double alp = 2 * PI * (t[i] - 'a') / 26;
b.push_back(cd(cos(alp), -sin(alp)));
} else
b.push_back(cd(0, 0));
}
return get_scalar(a, b);
}
int n, m, r, c;
string a[N], b[N];
string second, t;
vector<string> v;
int cnt;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
cin >> r >> c;
for (int i = 0; i < r; i++) {
cin >> b[i];
for (int j = 0; j < b[i].size(); j++)
if (b[i][j] == '?') cnt++;
}
for (int i = 0; i < v.size(); i++) {
string ss = v[i];
while (v[i].size() < m + c) v[i] += ss;
}
int pos = 0;
while (v.size() < n + r) {
v.push_back(v[pos % n]);
pos++;
}
int w = (int)v[0].size();
for (string x : v) second += x;
for (int i = 0; i < r; i++) {
t += b[i];
for (int j = (int)b[i].size(); j < w; j++) t += "#";
}
vector<cd> kilk = get(second, t);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (kilk[i * w + j].real() + cnt == r * c)
cout << 1;
else
cout << 0;
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using i128 = boost::multiprecision::int128_t;
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using Vbo = vector<bool>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using VVbo = vector<Vbo>;
using VVV = vector<VV>;
using VVVll = vector<VVll>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
#define rep2(i, m, n) for(int i=int(m); i<int(n); ++i)
#define drep2(i, m, n) for(int i=int(m)-1; i>=int(n); --i)
#define rep(i, n) rep2(i, 0, n)
#define drep(i, n) drep2(i, n, 0)
#define all(a) a.begin(), a.end()
struct fast_ios { fast_ios(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
template<typename T> inline int sz(T &x) { return x.size(); }
template<typename T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
template<typename T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
template<typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p) { os << '(' << p.first << ", " << p.second << ')'; return os; }
template<typename T> istream &operator>>(istream &is, vector<T> &v) { for (auto &e : v) is >> e; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &v) { for (auto &e : v) os << e << ' '; return os; }
template<typename T> inline int count_between(vector<T> &a, T l, T r) { return lower_bound(all(a), r) - lower_bound(all(a), l); } // [l, r)
inline int fLog2(const int x) { return 31-__builtin_clz(x); } // floor(log2(x))
inline int fLog2(const ll x) { return 63-__builtin_clzll(x); }
inline int cLog2(const int x) { return (x == 1) ? 0 : 32-__builtin_clz(x-1); } // ceil(log2(x))
inline int cLog2(const ll x) { return (x == 1) ? 0 : 64-__builtin_clzll(x-1); }
inline int popcount(const int x) { return __builtin_popcount(x); }
inline int popcount(const ll x) { return __builtin_popcountll(x); }
const int INF = 1<<30;
const ll INFll = 1ll<<62;
const ld EPS = 1e-10;
const ld PI = acos(-1.0);
// const int MOD = int(1e9)+7;
const int MOD = 998244353;
struct mint {
ll x;
mint(ll x=0) : x((x%MOD+MOD)%MOD) {}
mint operator-() const { return mint(-x);}
mint& operator+=(const mint a) { if ((x += a.x) >= MOD) x -= MOD; return *this; }
mint& operator-=(const mint a) { if ((x -= a.x) < 0) x += MOD; return *this; }
mint& operator*=(const mint a) { (x *= a.x) %= MOD; return *this; }
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t>>1);
a *= a;
if (t&1) a *= *this;
return a;
}
mint& operator/=(const mint r) {
ll a = r.x, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
x = x * u % MOD;
if (x < 0) x += MOD;
return *this;
}
mint operator/(const mint a) const { return mint(*this) /= a; }
};
// istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
using Vm = vector<mint>;
using VVm = vector<Vm>;
using VVVm = vector<VVm>;
int main() {
ll n, m; cin >> n >> m;
map<P, int> c;
set<P> S;
rep(i, m) {
int x, y, z; cin >> x >> y >> z;
--x, --y;
c[{x, y}] = 2-z;
if (abs(x-y) > 2) S.emplace(x, y);
}
Vm dp(2);
dp[0] = 1;
dp[1] = 1;
if (c[{0, 0}] == 1) dp[0] = 0;
if (c[{0, 0}] == 2) dp[1] = 0;
rep(i, n-1) {
Vm _dp(2);
rep(j, 2) rep(k, 2) {
mint co = 1;
int cnt = 0;
int x = 0;
int y = 0;
if (c.find({i, i+1}) != c.end()) x = c[{i, i+1}], ++cnt;
if (c.find({i+1, i}) != c.end()) y = c[{i+1, i}], ++cnt;
if (cnt == 0) co *= 2;
if (cnt == 2 && ((x+y+j+k)&1)) co = 0;
if (i < n-2) {
int cnt = 0;
int x = 0;
int y = 0;
if (c.find({i, i+2}) != c.end()) x = c[{i, i+2}], ++cnt;
if (c.find({i+2, i}) != c.end()) y = c[{i+2, i}], ++cnt;
if (cnt == 0) co *= 2;
if (cnt == 2 && ((x+y+k)&1)) co = 0;
}
_dp[k] += dp[j] * co;
}
swap(dp, _dp);
if (c.find({i+1, i+1}) != c.end() && c[{i+1, i+1}] == 1) dp[0] = 0;
if (c.find({i+1, i+1}) != c.end() && c[{i+1, i+1}] == 2) dp[1] = 0;
}
mint ans = dp[0] + dp[1];
ll cnt = (n-2)*(n-3);
for (auto &e : S) {
auto [i, j] = e;
int x = 0;
int y = 0;
if (c.find({i, j}) != c.end()) x = c[{i, j}];
if (c.find({j, i}) != c.end()) y = c[{j, i}];
if (y && ((x+y)&1)) {
cout << 0 << '\n';
return 0;
}
if (y) --cnt;
else cnt -= 2;
}
cnt /= 2;
ans *= mint(2).pow(cnt);
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, m, vis[N], d[N];
vector<pair<int, int> > g[N], g1[N];
int sub = 0, fa[N], up[N], cur[N];
vector<int> id;
void dfs(int u) {
vis[u] = 1;
id.push_back(u);
if (~d[u]) sub ^= d[u];
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i].first;
if (vis[v]) continue;
fa[v] = u;
up[v] = g[u][i].second;
g1[u].push_back(g[u][i]);
dfs(v);
}
}
vector<int> vec;
void work(int u) {
for (int i = 0; i < g1[u].size(); ++i) {
int v = g1[u][i].first;
work(v);
}
if (cur[u] != d[u]) {
assert(fa[u]);
cur[fa[u]] ^= 1;
cur[u] ^= 1;
vec.push_back(up[u]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
id.clear();
sub = 0;
dfs(i);
for (int j = 0; j < id.size(); ++j)
if (d[id[j]] == -1) {
if (sub == 0)
d[id[j]] = 0;
else {
d[id[j]] = 1;
sub ^= 1;
}
}
if (sub) {
cout << -1 << '\n';
return 0;
}
work(i);
}
sort(vec.begin(), vec.end());
cout << vec.size() << '\n';
for (int i = 0; i < vec.size(); ++i) cout << vec[i] << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string str;
int k;
int p[555][555];
int dp[555][555];
int mark[555];
void change(int i, int j) {
while (i < j) {
if (str[i] != str[j]) str[j] = str[i];
i++;
j--;
}
}
int main() {
while (cin >> str >> k) {
memset(dp, 0, sizeof(dp));
int len = str.length();
for (int i = len - 1; i >= 0; i--) {
for (int j = i; j <= len - 1; j++) {
if (i == j)
p[i][j] = 0;
else if (j - i == 1)
p[i][j] = (str[i] == str[j] ? 0 : 1);
else {
p[i][j] = p[i + 1][j - 1] + (str[i] == str[j] ? 0 : 1);
}
}
}
for (int i = 1; i <= k; i++) {
for (int j = i - 1; j < len; j++) {
if (i == j + 1)
dp[i][j] = 0;
else if (i == 1)
dp[i][j] = p[0][j];
else {
dp[i][j] = 10000000;
for (int l = i - 1; l <= j; l++) {
dp[i][j] = min(dp[i][j], dp[i - 1][l - 1] + p[l][j]);
}
}
}
}
int ans = dp[k][len - 1];
int seg = k;
for (int i = 1; i < k; i++) {
if (ans > dp[i][len - 1]) {
seg = i;
ans = dp[i][len - 1];
}
}
memset(mark, 0, sizeof(mark));
int tseg = seg, tlen = len - 1;
for (int i = len - 2; i >= 0; i--) {
if (tseg <= 1) break;
if (dp[tseg][tlen] == dp[tseg - 1][i] + p[i + 1][tlen]) {
change(i + 1, tlen);
tseg--;
tlen = i;
mark[i] = 1;
}
}
change(0, tlen);
cout << ans << endl;
for (int i = 0; i < len; i++) {
cout << str[i];
if (mark[i]) cout << "+";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define MAX_N 36
#define MAX 1000
char getChar(int x){
return (x < 10 ? x+'0' : x+'A'-10);
}
int main(){
int N,M,Q;
while(cin >> N >> M >> Q, N){
string S,B[MAX+1];
bool sw[MAX+1][MAX_N];
sw[0][0] = false;
for(int i = 1 ; i <= Q ; i++){
cin >> S >> B[i];
for(int j = 0 ; j < N ; j++){
sw[i][j] = (S[j] == '1' ? !sw[i-1][j] : sw[i-1][j]);
}
}
string ans;
for(int i = 0 ; i < M ; i++){
bool use[MAX_N];
fill(use,use+N,true);
for(int j = 1 ; j <= Q ; j++){
for(int k = 0 ; k < N ; k++){
if(!sw[j][k] && B[j][i] == '1' ||
sw[j][k] && B[j][i] == '0'){
use[k] = false;
}
}
}
bool ok = true;
int x = -1;
for(int j = 0 ; j < N ; j++){
if(use[j]){
if(x != -1) ok = false;
x = j;
}
}
ans += (ok ? getChar(x) : '?');
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a == b && c == 0) {
cout << "0" << endl;
} else if (a - b + c < 0) {
cout << "-" << endl;
} else if (a - b - c > 0) {
cout << "+" << endl;
} else {
cout << "?" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
map<int, int> mp;
void fmain(int tid) {
scanf("%d", &n);
if (n == 1) {
puts("1 0");
return;
}
int x = n;
for (int d = 2; d * d <= x; d++)
while (x % d == 0) {
x /= d;
mp[d]++;
}
if (x > 1) mp[x]++;
int S = 1, ss = 0, bi = 0;
vector<int> vp;
for (auto p : mp) {
int cc = p.second;
S *= p.first;
int z = 1;
while (z < cc) z *= 2;
maxtt(bi, z);
}
for (auto p : mp)
if (p.second < bi) ss = 1;
while (bi > 1) {
bi /= 2;
ss++;
}
printf("%d %d\n", S, ss);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define mod 1000000007
using namespace std;
int main(void){
double A, B, C, D, E, F, sum = 0, sugar = 0, ans1 = 0, ans2 = 0;
int i, j, k, l;
double max = -1;
cin >> A >> B >> C >> D >> E >> F;
for(i=0; 100*A*i <= F; i++){
for(j=0; 100*(A*i + B*j) <= F; j++){
for(k=0; k*C<=E*(A*i + B*j); k++){
for(l=0; k*C+l*D<=E*(A*i + B*j); l++){
sum = 100*A*i + 100*B*j + k*C + l*D;
sugar = k*C + l*D;
if(sum > 0){
if(max < sugar/sum && sum <= F){
max = sugar / sum;
ans1 = sum;
ans2 = sugar;
}
}
}
}
}
}
cout << ans1 << " " << ans2 << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
long long n,cnt=0;
while(cin>>n&&n!=0){
cnt=0;
while(n!=1){
if(n%2==0){
n=n/2;
cnt++;
}else{
n=n*3+1;
cnt++;
}
}
cout<<cnt<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const int MAXN = 1001000;
const int MAXH = 20;
int H = 20;
int prand;
int bits = 0;
bool getb() {
if (bits < 0) {
prand = rand();
bits = 31;
}
int ans = (prand >> bits) & 1;
--bits;
return ans;
}
int geth() {
int ans = 0;
while (ans + 1 < H && getb()) ++ans;
return ans;
}
int nxt[MAXN][MAXH];
int len[MAXN][MAXH];
int ans[MAXN];
int head = 1;
void ins(int nd, int pos) {
int ht = geth();
int cur = head;
for (int h = H - 1; h >= 0; --h) {
while (nxt[cur][h]) {
if (len[cur][h] <= pos) {
pos -= len[cur][h];
cur = nxt[cur][h];
} else {
break;
}
}
if (h <= ht) {
nxt[nd][h] = nxt[cur][h];
len[nd][h] = len[cur][h] - pos;
nxt[cur][h] = nd;
len[cur][h] = pos + 1;
} else {
++len[cur][h];
}
}
}
int pop() {
int cur = head;
int ans = nxt[cur][0];
for (int h = H - 1; h >= 0; --h) {
if (nxt[cur][h] && len[cur][h] == 1) {
len[cur][h] = len[nxt[cur][h]][h];
nxt[cur][h] = nxt[nxt[cur][h]][h];
} else {
--len[cur][h];
}
}
return ans;
}
int X[MAXN], Y[MAXN];
int fin[MAXN];
bool vis[MAXN];
int N, M;
void disp() {
int cur = head;
for (int i = 0; i < N; ++i) {
cur = nxt[cur][0];
printf("%d ", ans[cur]);
}
printf("\n");
}
bool go() {
scanf("%d %d", &N, &M);
for (int i = 2; i <= N + 1; ++i) {
ins(i, 0);
}
for (int i = 0; i < M; ++i) {
scanf("%d %d", X + i, Y + i);
}
for (int i = M - 1; i >= 0; --i) {
int x = X[i], y = Y[i];
int front = pop();
if (ans[front] && ans[front] != x) {
return false;
}
ans[front] = x;
ins(front, y - 1);
}
int cur = head;
for (int i = 0; i < N; ++i) {
cur = nxt[cur][0];
fin[i] = cur;
}
for (int i = 0; i < N; ++i) {
int a = ans[fin[i]];
if (a) {
if (vis[a]) return false;
vis[a] = true;
}
}
int n = 1;
for (int i = 0; i < N; ++i) {
if (!ans[fin[i]]) {
while (vis[n]) ++n;
ans[fin[i]] = n;
++n;
}
printf("%d ", ans[fin[i]]);
}
printf("\n");
return true;
}
int main() {
if (!go()) {
printf("-1\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x, k, x1, y11, x2, y2, r[10];
struct nod {
nod *l = 0, *r = 0;
int val;
} * rev[200010];
nod* updPers(nod* rad, int val, int pos, int low, int high) {
nod* ret = new nod;
if (!rad) rad = new nod;
if (low == high) {
ret->val = val;
return ret;
}
int mid = (low + high) / 2;
if (pos <= mid) {
ret->l = updPers(rad->l, val, pos, low, mid);
ret->r = rad->r;
} else {
ret->r = updPers(rad->r, val, pos, mid + 1, high);
ret->l = rad->l;
}
ret->val = 0;
if (ret->l) ret->val += ret->l->val;
if (ret->r) ret->val += ret->r->val;
return ret;
}
void upd(nod* rad, int val, int pos, int low, int high) {
if (low == high) {
rad->val = val;
return;
}
int mid = (low + high) / 2;
if (pos <= mid) {
if (!rad->l) rad->l = new nod;
upd(rad->l, val, pos, low, mid);
} else {
if (!rad->r) rad->r = new nod;
upd(rad->r, val, pos, mid + 1, high);
}
if (rad->l) rad->val = rad->l->val;
if (rad->r) rad->val += rad->r->val;
}
int que(nod* rad, int x, int y, int low, int high) {
if (rad == NULL) return 0;
if (low >= x && high <= y) return rad->val;
int mid = (low + high) / 2;
int ans = 0;
if (x <= mid) ans += que(rad->l, x, y, low, mid);
if (y >= mid) ans += que(rad->r, x, y, mid + 1, high);
return ans;
}
int get(int x1, int y11, int x2, int y2) {
if (x1 > x2) return 0;
if (y11 > y2) return 0;
return que(rev[x2], y11, y2, 1, 200010) -
que(rev[x1 - 1], y11, y2, 1, 200010);
}
int main() {
ios_base::sync_with_stdio(false);
int revCount = 0;
rev[0] = new nod;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
rev[i] = updPers(rev[i - 1], 1, x, 1, 200010);
}
for (int i = 1; i <= k; i++) {
scanf("%d%d%d%d", &x1, &y11, &x2, &y2);
long long ans = 0LL;
r[2] = get(x1, 1, x2, y11 - 1);
r[3] = get(x2 + 1, 1, n, y11 - 1);
r[4] = get(x2 + 1, y11, n, y2);
r[5] = get(x2 + 1, y2 + 1, n, n);
r[6] = get(x1, y2 + 1, x2, n);
r[7] = get(1, y2 + 1, x1 - 1, n);
r[8] = get(1, y11, x1 - 1, y2);
r[1] = get(1, 1, x1 - 1, y11 - 1);
int x = n - r[1] - r[2] - r[3] - r[4] - r[5] - r[6] - r[7] - r[8];
ans += 1LL * r[1] * (1LL * x + r[4] + r[5] + r[6]);
ans += 1LL * r[2] * (1LL * x + r[4] + r[5] + r[6] + r[7] + r[8]);
ans += 1LL * r[3] * (1LL * x + r[6] + r[7] + r[8]);
ans += 1LL * r[4] * (1LL * x + r[1] + r[2] + r[6] + r[7] + r[8]);
ans += 1LL * r[5] * (1LL * x + r[1] + r[2] + r[8]);
ans += 1LL * r[6] * (1LL * x + r[1] + r[2] + r[3] + r[4] + r[8]);
ans += 1LL * r[7] * (1LL * x + r[4] + r[3] + r[2]);
ans += 1LL * r[8] * (1LL * x + r[4] + r[5] + r[6] + r[2] + r[3]);
ans += 1LL * x * (n - x);
ans /= 2LL;
ans += 1LL * x * (x - 1) / 2;
printf("%lld\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<map>
#include<cstring>
#include<string>
#include <math.h>
#include<algorithm>
// #include <boost/multiprecision/cpp_int.hpp>
#include<functional>
#define int long long
#define inf 1000000007
#define pa pair<int,int>
#define ll long long
#define pal pair<double,double>
#define ppap pair<pa,int>
#define ssa pair<string,int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
int dx[4]={0,-1,0,1};
int dy[4]={1,0,-1,0};
using namespace std;
class pa3{
public:
int x,y,z;
pa3(int x=0,int y=0,int 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;
//return x != p.x ? x<p.x: y<p.y;
}
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;
//return x != p.x ? x<p.x: y<p.y;
}
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:
double x;
int y,z,w;
pa4(double x=0,int y=0,int z=0,int 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;
//return x != p.x ? x<p.x: y<p.y;
}
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;
//return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const pa4 &p) const{
return x==p.x && y==p.y && z==p.z &&w==p.w;
}
};
class pa2{
public:
int x,y;
pa2(int x=0,int 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 x != p.x ? x<p.x: y<p.y;
}
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);
}
};
#define ppa pair<int,pas>
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
Point operator + (Point p) {return Point(x+p.x,y+p.y);}
Point operator - (Point p) {return Point(x-p.x,y-p.y);}
Point operator * (double a) {return Point(x*a,y*a);}
Point operator / (double a) {return Point(x/a,y/a);}
double absv() {return sqrt(norm());}
double norm() {return x*x+y*y;}
bool operator < (const Point &p) const{
return x != p.x ? x<p.x: y<p.y;
}
bool operator == (const Point &p) const{
return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS;
}
};
typedef Point Vector;
#define pl pair<int,pas>
struct Segment{
Point p1,p2;
};
double dot(Vector a,Vector b){
return a.x*b.x+a.y*b.y;
}
double cross(Vector a,Vector b){
return a.x*b.y-a.y*b.x;
}
bool parareru(Point a,Point b,Point c,Point d){
// if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
return abs(cross(a-b,d-c))<EPS;
}
double distance_ls_p(Point a, Point b, Point c) {
if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
return abs(cross(b-a, c-a)) / (b-a).absv();
}
bool is_intersected_ls(Segment a,Segment b) {
if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&¶reru((a.p2),(a.p1),(a.p1),(b.p1))){
// cout<<"sss"<<endl;
if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
return false;
}
else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
}
double segment_dis(Segment a,Segment b){
if(is_intersected_ls(a,b))return 0;
double r=distance_ls_p(a.p1, a.p2, b.p1);
r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2-b.p1;
double d1 = abs(cross(ba, a.p1-b.p1));
double d2 = abs(cross(ba, a.p2-b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2-a.p1) * t;
}
string itos( int i ) {
ostringstream s ;
s << i ;
return s.str() ;
}
int gcd(int v,int b){
if(v>b) return gcd(b,v);
if(v==b) return b;
if(b%v==0) return v;
return gcd(v,b%v);
}
double distans(double x1,double y1,double x2,double y2){
double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
return sqrt(rr);
}
// int pr[2000010];
// int inv[2000010];
int beki(int wa,int rr,int warukazu){
if(rr==0) return 1ll;
if(rr==1) return wa%warukazu;
if(rr%2==1) return (beki(wa,rr-1,warukazu)*wa)%warukazu;
int zx=beki(wa,rr/2,warukazu);
return (zx*zx)%warukazu;
}
/*
int comb(int nn,int rr){
int r=pr[nn]*inv[rr];
r%=inf;
r*=inv[nn-rr];
r%=inf;
return r;
}
void gya(int ert){
pr[0]=1;
for(int i=1;i<ert;i++){
pr[i]=(pr[i-1]*i)%inf;
}
for(int i=0;i<ert;i++) inv[i]=beki(pr[i],inf-2,inf);
}
*/
//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;
//sort(ve.begin(),ve.end(),greater<int>());
//----------------kokomade tenpure------------
//vector<double> ans(100000000),ans2(100000000);
bool dp[380][9][7][7][7][7];
bool sumi[380][9][7][7][7][7];
int n;
vector<int> kanou[9];
int kumo[9]={0};
int day[400];
void junbi(){
kanou[0].pb(0);
kanou[0].pb(1);
kanou[0].pb(2);
kanou[0].pb(3);
kanou[0].pb(6);
kanou[1].pb(0);
kanou[1].pb(1);
kanou[1].pb(2);
kanou[1].pb(4);
kanou[1].pb(7);
kanou[2].pb(0);
kanou[2].pb(1);
kanou[2].pb(2);
kanou[2].pb(5);
kanou[2].pb(8);
kanou[3].pb(0);
kanou[3].pb(3);
kanou[3].pb(4);
kanou[3].pb(5);
kanou[3].pb(6);
kanou[4].pb(4);
kanou[4].pb(1);
kanou[4].pb(5);
kanou[4].pb(3);
kanou[4].pb(7);
kanou[5].pb(8);
kanou[5].pb(5);
kanou[5].pb(2);
kanou[5].pb(3);
kanou[5].pb(4);
kanou[6].pb(0);
kanou[6].pb(8);
kanou[6].pb(7);
kanou[6].pb(3);
kanou[6].pb(6);
kanou[7].pb(4);
kanou[7].pb(1);
kanou[7].pb(8);
kanou[7].pb(7);
kanou[7].pb(6);
kanou[8].pb(2);
kanou[8].pb(5);
kanou[8].pb(8);
kanou[8].pb(7);
kanou[8].pb(6);
kumo[0]=0b0000000000110011;
kumo[1]=0b0000000001100110;
kumo[2]=0b0000000011001100;
kumo[3]=0b0000001100110000;
kumo[4]=0b0000011001100000;
kumo[5]=0b0000110011000000;
kumo[6]=0b0011001100000000;
kumo[7]=0b0110011000000000;
kumo[8]=0b1100110000000000;
}
bool dfs(int d,int pos,int r5,int r6,int r9,int r10){
if(r5>=7) return false;
if(r6>=7) return false;
if(r9>=7) return false;
if(r10>=7) return false;
if(day[d]& kumo[pos]) return false;
//cout<<d<<" "<<pos<<" "<<r5<<" "<<r6<<" "<<r9<<" "<<r10<<endl;
if(sumi[d][pos][r5][r6][r9][r10]) return dp[d][pos][r5][r6][r9][r10];
if(d==n){
// cout<<d<<" "<<pos<<endl;
return true;
}
bool bo=false;
for(auto v:kanou[pos]){
int l5=r5;
int l6=r6;
int l9=r9;
int l10=r10;
if((kumo[v]&(1<<0) )==0) l5++;
else l5=0;
if((kumo[v]&(1<<3) )==0) l6++;
else l6=0;
if((kumo[v]&(1<<12) )==0) l9++;
else l9=0;
if((kumo[v]&(1<<15) )==0) l10++;
else l10=0;
if(dfs(d+1,v,l5,l6,l9,l10)){
bo=true;
goto lll;
}
}
lll:;
sumi[d][pos][r5][r6][r9][r10]=1;
dp[d][pos][r5][r6][r9][r10]=bo;
return bo;
}
signed main(){
junbi();
int a[110][110];
while(1){
cin>>n;
if(n==0) return 0;
for(int i=0;i<370;i++)for(int k=0;k<9;k++)for(int l1=0;l1<7;l1++)for(int l2=0;l2<7;l2++)for(int l3=0;l3<7;l3++)for(int l4=0;l4<7;l4++){
sumi[i][k][l1][l2][l3][l4]=0;
}
for(int i=1;i<=n;i++){
int l=0;
for(int j=0;j<16;j++){
char c;
cin>>c;
if(c=='1') l+= 1<<j;
}
day[i]=l;
}
if(dfs(1,4,1,1,1,1))cout<<1<<endl;
else cout<<0<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
template <typename K, typename V>
using umap = unordered_map<K, V>;
template <typename K>
using uset = unordered_set<K>;
using vi = vec<int>;
using vl = vec<ll>;
using vpi = vec<pii>;
using vpl = vec<pll>;
using int128 = __int128_t;
using uint128 = __uint128_t;
template <typename I>
string intStr(I x) {
string ret;
while (x > 0) {
ret += (x % 10) + '0';
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
template <typename T>
inline void maxa(T& st, T v) {
st = max(st, v);
}
template <typename T>
inline void mina(T& st, T v) {
st = min(st, v);
}
inline void setprec(ostream& out, int prec) {
out << setprecision(prec) << fixed;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> iter) {
out << "[";
for (auto t : iter) {
out << t << ", ";
}
out << "]";
return out;
}
template <typename T>
string arrayStr(T* arr, int sz) {
string ret = "[";
for (int i = 0; i < sz; i++) {
ret += to_string(arr[i]) + ", ";
}
return ret + "]";
}
template <typename T>
void printArray(T* arr, int sz) {
for (int i = 0; i < sz; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
inline void scan() {}
template <typename F, typename... R>
inline void scan(F& f, R&... r) {
cin >> f;
scan(r...);
}
template <typename F>
inline void println(F t) {
cout << t << '\n';
}
template <typename F, typename... R>
inline void println(F f, R... r) {
cout << f << " ";
println(r...);
}
inline void print() {}
template <typename F, typename... R>
inline void print(F f, R... r) {
cout << f;
print(r...);
}
vl factor(ll x) {
ld sqx = sqrt(x) + 100;
vl ret;
for (__typeof(1) i = 1; i < sqx + 1; i++) {
if (x % i == 0) {
ret.push_back(i);
ret.push_back(x / i);
}
}
sort(ret.begin(), ret.end());
ret.resize(unique(ret.begin(), ret.end()) - ret.begin());
return ret;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using pll = pair<ll, ll>;
const int MN = 1001, MF = 7001;
int n, par[MN][MF];
pll dp[MN][MF];
ll k;
struct p {
int i;
ll v, gv;
bool operator<(const p& o) const { return v < o.v; }
} num[MN];
vl kfactors;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scan(n, k);
kfactors = factor(k);
int fsz = kfactors.size();
assert(fsz < MF);
for (__typeof(1) i = 1; i < n + 1; i++) {
scan(num[i].v);
num[i].gv = gcd(num[i].v, k);
num[i].i = i;
}
if (k == 1) {
sort(num + 1, num + n + 1);
println(1);
println(num[1].i);
return 0;
}
pll invalid = make_pair(0x3f3f3f3f3f3f3f3f, 0x3f3f3f3f3f3f3f3f);
dp[0][0] = {0LL, 0LL};
for (__typeof(1) i = 1; i < fsz; i++) dp[0][i] = invalid;
for (__typeof(1) i = 1; i < n + 1; i++) {
for (__typeof(1) j = 1; j < fsz; j++) {
dp[i][j] = min(invalid, dp[i - 1][j]);
par[i][j] = j;
ll from = kfactors[j] / gcd(num[i].gv, kfactors[j]);
int fromid = lower_bound((kfactors).begin(), (kfactors).end(), from) -
kfactors.begin();
auto alt = dp[i - 1][fromid];
alt.first++;
alt.second += num[i].v;
if (alt < dp[i][j]) {
dp[i][j] = alt;
par[i][j] = fromid;
}
}
}
if (dp[n][fsz - 1].first == 0x3f3f3f3f3f3f3f3f) {
println(-1);
return 0;
}
println(dp[n][fsz - 1].first);
vi seq;
int ci = n, cj = fsz - 1;
while (ci > 0 && cj > 0) {
auto cpar = par[ci][cj];
if (cj > cpar) seq.push_back(num[ci].i);
ci--;
cj = cpar;
}
sort(seq.begin(), seq.end());
for (auto x : seq) print(x, ' ');
print('\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c;
long long int left = 0, right = 0;
bool flag = false;
string str;
getline(cin, str);
int n = str.length();
for (int i = 0; i < n; i++) {
if (str[i] == '^') {
c = i;
break;
}
}
for (int i = 0; i < n; i++) {
if (str[i] >= '0' && str[i] <= '9') {
int t = str[i] - '0';
if (!flag) {
left = left + (t * (c - i));
} else {
right = right + (t * (i - c));
}
} else if (str[i] == '^') {
flag = true;
}
}
if (left > right) {
cout << "left" << endl;
} else if (right > left) {
cout << "right" << endl;
} else {
cout << "balance" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int64_t power(int64_t a, int64_t b) {
int64_t ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % 1000000007;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
int64_t mmi(int64_t n) { return power(n, 1000000007 - 2); }
int64_t two(int64_t n) { return 1 << n; }
void onbit(int64_t &n, int64_t x) { n |= two(x); }
void offbit(int64_t &n, int64_t x) { n &= ~two(x); }
int64_t cntbit(int64_t n) {
int64_t res = 0;
while (n and ++res) n -= n & -n;
return res;
}
int64_t dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int64_t a[100005];
void solve() {
int64_t i, n;
cin >> n;
for (i = 1; i < n + 1; i++) cin >> a[i];
for (i = 1; i < n + 1; i++) a[i] += a[i - 1];
int64_t cnt = 0;
for (i = 1; i < n; i++) {
if (a[i] == a[n] - a[i]) cnt++;
}
cout << cnt;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
using vint=vector<int>;
using pint=pair<int,int>;
using vpint=vector<pint>;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
template<class A,class B>
ostream& operator<<(ostream& ost,const pair<A,B>&p){
ost<<"{"<<p.first<<","<<p.second<<"}";
return ost;
}
template<class T>
ostream& operator<<(ostream& ost,const vector<T>&v){
ost<<"{";
for(int i=0;i<v.size();i++){
if(i)ost<<",";
ost<<v[i];
}
ost<<"}";
return ost;
}
inline int topbit(unsigned long long x){
return x?63-__builtin_clzll(x):-1;
}
inline int popcount(unsigned long long x){
return __builtin_popcountll(x);
}
inline int parity(unsigned long long x){
return __builtin_parity(x);
}
template<uint32_t mod>
struct ModInt{
uint32_t a;
ModInt& s(uint32_t vv){
a=vv<mod?vv:vv-mod;
return *this;
}
ModInt(int64_t x=0){s(x%mod+mod);}
ModInt& operator+=(const ModInt &x){return s(a+x.a);}
ModInt& operator-=(const ModInt &x){return s(a+mod-x.a);}
ModInt& operator*=(const ModInt &x){
a=uint64_t(a)*x.a%mod;
return *this;
}
ModInt& operator/=(const ModInt &x){
*this*=x.inv();
return *this;
}
ModInt operator+(const ModInt &x)const{return ModInt(*this)+=x;}
ModInt operator-(const ModInt &x)const{return ModInt(*this)-=x;}
ModInt operator*(const ModInt &x)const{return ModInt(*this)*=x;}
ModInt operator/(const ModInt &x)const{return ModInt(*this)/=x;}
bool operator==(const ModInt &x)const{return a==x.a;}
bool operator!=(const ModInt &x)const{return a!=x.a;}
bool operator<(const ModInt &x)const{return a<x.a;}
ModInt operator-()const{return ModInt()-*this;}
ModInt pow(int64_t n)const{
ModInt res(1),x(*this);
while(n){
if(n&1)res*=x;
x*=x;
n>>=1;
}
return res;
}
ModInt inv()const{return pow(mod-2);}
};
template<uint32_t mod>
istream& operator>>(istream& in,ModInt<mod>& a){
return (in>>a.a);
}
template<uint32_t mod>
ostream& operator<<(ostream& out,const ModInt<mod>& a){
return (out<<a.a);
}
using mint=ModInt<1000000007>;
int N,A,B;
mint dp[5010][3][5010];
signed main(){
cin>>N>>A>>B;
if(A>B)swap(A,B);
dp[0][1][0]=1;
mint ans=0;
for(int i=0;i<N;i++){
for(int j=0;j<B;j++){
dp[i+1][0][j+1]+=dp[i][0][j];
dp[i+1][1][j+1]+=dp[i][0][j];
}
for(int j=0;j<B;j++){
dp[i+1][1][j+1]+=dp[i][1][j];
if(i+A<=N)dp[i+A][0][min(j+A,B)]+=dp[i][1][j];
dp[i+1][2][1]+=dp[i][1][j];
}
for(int j=0;j<A;j++){
dp[i+1][1][1]+=dp[i][2][j];
dp[i+1][2][j+1]+=dp[i][2][j];
}
ans*=2;
ans+=dp[i+1][0][B]+dp[i+1][1][B];
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adjList[100000];
int disc[100000], low[100000], inStack[100000], num = 0;
vector<int> com[100000], adjList2[100000];
int c[100000], in[100000], scc = 0;
vector<int> S;
int doDFS(int u) {
int i;
disc[u] = low[u] = num++;
S.push_back(u), inStack[u] = 1;
for (i = 0; i < adjList[u].size(); i++) {
int v = adjList[u][i];
if (disc[v] == -1)
doDFS(v), low[u] = min(low[u], low[v]);
else if (inStack[v])
low[u] = min(low[u], disc[v]);
}
if (disc[u] == low[u]) {
while (1) {
int v = S.back();
S.pop_back(), inStack[v] = 0;
com[scc].push_back(v), c[v] = scc;
if (u == v) break;
}
scc++;
}
return 0;
}
queue<int> Q;
int main() {
int i;
int n, m, u, v;
cin >> n >> m;
for (i = 0; i < m; i++) cin >> u >> v, adjList[u - 1].push_back(v - 1);
int j;
for (i = 0; i < n; i++) disc[i] = low[i] = -1;
for (i = 0; i < n; i++) {
if (disc[i] == -1) doDFS(i);
}
for (i = 0; i < n; i++) {
for (j = 0; j < adjList[i].size(); j++) {
v = adjList[i][j];
if (c[i] != c[v]) adjList2[c[i]].push_back(c[v]);
}
}
for (i = 0; i < scc; i++) {
sort(adjList2[i].begin(), adjList2[i].end());
adjList2[i].resize(unique(adjList2[i].begin(), adjList2[i].end()) -
adjList2[i].begin());
for (j = 0; j < adjList2[i].size(); j++) in[adjList2[i][j]]++;
}
for (i = 0; i < scc; i++) {
if (in[i] == 0) Q.push(i);
}
int p = Q.front();
Q.pop();
while (!Q.empty()) {
u = Q.front();
Q.pop();
while (!com[p].empty() && !com[u].empty()) {
int r;
cout << "? " << com[p].back() + 1 << " " << com[u].back() + 1 << endl;
cin >> r;
if (r)
com[u].pop_back();
else
com[p].pop_back();
}
if (com[p].empty()) swap(p, u);
for (i = 0; i < adjList2[u].size(); i++) {
v = adjList2[u][i], in[v]--;
if (in[v] == 0) Q.push(v);
}
}
cout << "! " << com[p].back() + 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, k, lg;
int pre[N], post[N], prenum;
int p[20][N], lv[N];
int f[N];
vector<int> adj[N];
inline int preorder(int u, int par = 0) {
post[u] = pre[u] = ++prenum;
lv[u] = lv[par] + 1;
p[0][u] = par;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != par) post[u] = max(post[u], preorder(v, u));
}
return post[u];
}
inline int get(int u) {
int ret = 0;
for (int i = post[u]; i > 0; i -= i & -i) ret += f[i];
for (int i = pre[u] - 1; i > 0; i -= i & -i) ret -= f[i];
return ret;
}
inline void update(int u, int lca, int val = 1) {
for (int i = pre[u]; i > 0 && i <= n; i += i & -i) f[i] += val;
for (int i = pre[p[0][lca]]; i > 0 && i <= n; i += i & -i) f[i] -= val;
}
inline int getlca(int u, int v) {
if (lv[v] > lv[u]) return getlca(v, u);
for (int k = lg; k >= 0; k--)
if (lv[p[k][u]] >= lv[v]) u = p[k][u];
if (u == v) return u;
for (int k = lg; k >= 0; k--)
if (p[k][u] != p[k][v]) u = p[k][u], v = p[k][v];
return p[0][u];
}
inline int findlast(int u, int lim, int val = 0) {
for (int k = lg; k >= 0; k--)
if (lv[p[k][u]] >= lv[lim] && get(p[k][u]) <= val) u = p[k][u];
return u;
}
inline bool can(int m) {
memset(f + 1, 0, n * sizeof f[0]);
int cnt = 0;
int lca = getlca(1, 2);
update(1, lca);
cnt += lv[1] - lv[lca] + 1;
update(2, lca);
cnt += lv[2] - lv[lca];
if (m == 2 && cnt <= k) return true;
for (int i = 3; i <= n; i++) {
int nlca = getlca(lca, i);
update(p[0][lca], nlca, get(lca));
cnt += lv[lca] - lv[nlca];
if (get(i) == 0) {
int tmp = findlast(i, nlca);
cnt += lv[i] - lv[tmp] + 1;
}
update(i, nlca);
lca = nlca;
if (i > m) {
int u = i - m;
update(u, lca, -1);
if (get(u) == 0 || lca == u) {
int tmp = findlast(u, lca);
if (lca != u) cnt -= lv[u] - lv[tmp] + 1;
if (p[0][tmp] == lca || lca == u) {
int nlca =
get(u + 1) == m ? u + 1 : p[0][findlast(u + 1, lca, m - 1)];
if (nlca != lca) update(p[0][nlca], lca, -m);
cnt -= lv[nlca] - lv[lca];
lca = nlca;
}
}
}
if (i >= m && cnt <= k) return true;
}
return false;
}
int main() {
scanf("%d %d", &n, &k);
for (lg = 1; 1 << lg < n; lg++)
;
lg--;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
preorder(1);
for (int k = 1; k <= lg; k++)
for (int i = 1; i <= n; i++) p[k][i] = p[k - 1][p[k - 1][i]];
int lo = 2, hi = n;
while (lo <= hi) {
int mid = lo + hi >> 1;
if (can(mid))
lo = mid + 1;
else
hi = mid - 1;
}
printf("%d\n", hi);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x, y, z;
int a[(int)(5e5 + 10)], s1, s, S[(int)(1e7 + 10)];
int b[(int)(5e5 + 10)], t, t1, pw[(int)(5e5 + 10)];
int last[(int)(1e7 + 10)];
long long ans;
vector<int> v;
int main() {
cin >> n;
for (i = 1; i <= n; i++) scanf("%d", a + i);
pw[0] = 1;
for (i = 1; i < (int)(5e5 + 10); i++) pw[i] = pw[i - 1] * 2 % 1000000007;
for (i = 2; i < (int)(1e7 + 10); i++) {
if (last[i]) continue;
last[i] = i;
for (long long j = (long long)i + i; j < (int)(1e7 + 10); j += i)
if (!last[j]) last[j] = i;
}
for (i = 1; i <= n; i++) {
int s = 0, x = a[i];
v.clear();
while (x != 1) {
int t = last[x];
while (last[x] == t) x /= t;
v.push_back(t);
}
for (int i = 1; i < (1 << v.size()); i++) {
int w = 1;
for (j = 0; j < v.size(); j++)
if (((i >> j) & 1)) w *= v[j];
if (__builtin_popcount(i) % 2)
s = ((long long)s + pw[S[w]] - 1) % 1000000007;
else
s = ((long long)s - pw[S[w]] + 1 + 1000000007) % 1000000007;
S[w]++;
}
t1 = ((long long)t1 + pw[::i - 1] - s - 1 + 1000000007) % 1000000007;
}
for (i = 1; i <= n; i++) {
int s = 0, s2 = 0, x = a[i];
v.clear();
while (x != 1) {
int t = last[x];
while (last[x] == t) x /= t;
v.push_back(t);
}
for (int i = 1; i < (1 << v.size()); i++) {
int w = 1;
for (j = 0; j < v.size(); j++)
if (((i >> j) & 1)) w *= v[j];
if (__builtin_popcount(i) % 2) {
s2 = ((long long)s2 + pw[S[w] - 1] - 1) % 1000000007;
} else {
s2 = ((long long)s2 - pw[S[w] - 1] + 1 + 1000000007) % 1000000007;
}
}
s2++;
ans = (ans + (long long)pw[n] - ((long long)2 * s2 + t1)) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
}
cout << ans << '\n';
}
| 5 |
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <limits.h>
#include <math.h>
#include <functional>
#include <bitset>
#include <iomanip>
#define repeat(i,n) for (long long i = 0; (i) < (n); ++ (i))
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i] << '\n'
#define debugArrayP(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i].first<< " " << x[i].second << '\n'
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> Pii;
typedef vector<int> vint;
typedef vector<ll> vll;
const ll INF = INT_MAX;
const ll MOD = 1e9+7;
int main(){
int X,Y,Z;cin>>X>>Y>>Z;
vector<string> v(X+Y+Z);
repeat(i,X)v[i]="a";
repeat(i,Y)v[X+i]="b";
repeat(i,Z)v[X+Y+i]="c";
while(v.size()>1){
sort(v.begin(),v.end());
v[0]+=v.back();
v.pop_back();
}
cout<<v[0]<<endl;
return 0;
}
| 0 |
#include<cstdio>
using namespace std;
int main(){
int n,a[100001]={},b,cnt=0;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&b);
a[b]++;
}
for(int i=1;i<=100000;i++)
if(a[i])
cnt++;
if(cnt%2==1)
printf("%d\n",cnt);
else
printf("%d\n",cnt-1);
} | 0 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
ll A, B;
int a[63], b[63];
int main() {
scanf("%lld%lld", &A, &B); swap(A, B);
if (A == B) {puts("1"); return 0;}
for (int i = 60; i >= 0; --i)
if ((A >> i) & 1)
a[i] = 1;
for (int i = 60; i >= 0; --i)
if ((B >> i) & 1)
b[i] = 1;
int tmp = 60;
while (a[tmp] == b[tmp]) --tmp;
A &= ((1ll << tmp) - 1);
B &= ((1ll << tmp) - 1);
ll ans = (1ll << tmp) - B;
ll lb = 1;
while (A) {A >>= 1; lb <<= 1;}
--lb;
if (B <= lb)
ans += (1ll << tmp);
else
ans += (1ll << tmp) - (B - lb - 1);
printf("%lld\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &a, T b) {
return (a < b) ? a = b, 1 : 0;
}
template <typename T>
bool chkmin(T &a, T b) {
return (a > b) ? a = b, 1 : 0;
}
inline long long read() {
long long x = 0, fh = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fh = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0');
return x * fh;
}
int n;
int cnt;
struct mat {
long long c[75][75];
mat() {
for (int i = (1), _end_ = (int)(70); i <= _end_; ++i) {
for (int j = (1), _end_ = (int)(70); j <= _end_; ++j) c[i][j] = 1e18;
c[i][i] = 0;
}
}
mat operator*(const mat &rhs) const {
mat res;
for (int i = (1), _end_ = (int)(cnt); i <= _end_; ++i) res.c[i][i] = 1e18;
for (int i = (1), _end_ = (int)(cnt); i <= _end_; ++i)
for (int j = (1), _end_ = (int)(cnt); j <= _end_; ++j)
for (int k = (1), _end_ = (int)(cnt); k <= _end_; ++k) {
chkmin(res.c[i][j], c[i][k] + rhs.c[k][j]);
}
return res;
}
mat operator^(const int &x) {
if (!x) return mat();
mat res, tmp;
int y = x;
for (int i = (1), _end_ = (int)(cnt); i <= _end_; ++i)
for (int j = (1), _end_ = (int)(cnt); j <= _end_; ++j)
tmp.c[i][j] = c[i][j];
while (y) {
if (y & 1) res = res * tmp;
tmp = tmp * tmp;
y >>= 1;
}
return res;
}
} T;
int bel[1 << 12];
struct node {
int pos;
long long val;
bool operator<(const node &rhs) const { return pos < rhs.pos; }
} p[100005];
int k, x, q;
long long val[1 << 12];
bool check(int tmp) {
int res = 0;
for (int i = (1), _end_ = (int)(8); i <= _end_; ++i)
if (tmp & (1 << (i - 1))) res++;
return res == x;
}
int main() {
x = read();
k = read();
n = read();
q = read();
for (int i = (0), _end_ = (int)((1 << k) - 1); i <= _end_; ++i) {
if (check(i)) bel[i] = ++cnt;
}
for (int i = (1), _end_ = (int)(k); i <= _end_; ++i) val[i] = read();
for (int i = (1), _end_ = (int)(q); i <= _end_; ++i) {
p[i].pos = read();
p[i].val = read();
}
sort(p + 1, p + q + 1);
for (int i = (1), _end_ = (int)(cnt); i <= _end_; ++i) T.c[i][i] = 1e18;
for (int i = (1), _end_ = (int)((1 << k) - 1); i <= _end_; ++i) {
if (!bel[i]) continue;
if (i & 1) {
for (int j = (1), _end_ = (int)(k); j <= _end_; ++j) {
if (!((1 << j) & i)) T.c[bel[i]][bel[((1 << j) | i) >> 1]] = val[j];
}
} else
T.c[bel[i]][bel[i >> 1]] = 0;
}
int pos = 1;
long long sum = 0;
mat ans;
for (int i = (1), _end_ = (int)(q); i <= _end_; ++i) {
if (p[i].pos > n - x) {
sum += p[i].val;
continue;
}
ans = ans * (T ^ (p[i].pos - pos));
pos = p[i].pos;
for (int j = 1; j <= (1 << k) - 1; j += 2)
if (bel[j])
for (int k = (1), _end_ = (int)(cnt); k <= _end_; ++k)
ans.c[k][bel[j]] += p[i].val;
}
ans = ans * (T ^ (n - x + 1 - pos));
printf("%lld\n", ans.c[1][1] + sum);
return 0;
}
| 3 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
using namespace std;
typedef vector<int> VI;
typedef vector<vector<int> > VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> PIII;
int main(void) {
string str;
cin >> str;
int str_len = (int)str.length();
bool num = false;
bool big = false;
bool small = false;
bool len = false;
if (str_len >= 6) {
len = true;
}
for (int i = 0; i < str_len; i++) {
if (num == false && str[i] >= '0' && str[i] <= '9') {
num = true;
} else if (big == false && str[i] >= 'a' && str[i] <= 'z') {
big = true;
} else if (small == false && str[i] >= 'A' && str[i] <= 'Z') {
small = true;
}
}
if (num && big && small && len) {
cout << "VALID" << endl;
} else {
cout << "INVALID" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
namespace OI {
template <class T>
T gcd(T x, T y) {
return !y ? x : gcd(y, x % y);
}
template <class T>
T Fabs(T x) {
return x < 0 ? -x : x;
}
template <class T>
void rd(T &x) {
x = 0;
int pre = 1;
char c;
while (!isdigit(c = getchar()))
if (c == '-') pre = -1;
do {
x = (x << 3) + (x << 1) + (c ^ 48);
} while (isdigit(c = getchar()));
x *= pre;
}
template <class T>
void pt(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) pt(x / 10);
putchar(x % 10 ^ 48);
}
} // namespace OI
using namespace OI;
using namespace std;
const int N = 3005;
int n, x;
pair<double, double> a[N];
double dp[2][N], w[2][N], ans;
double dist(pair<double, double> x, pair<double, double> y) {
return sqrt((x.first - y.first) * (x.first - y.first) +
(x.second - y.second) * (x.second - y.second));
}
int main() {
rd(n);
for (int i = 0; i < n; i++) scanf("%lf %lf", &a[i].first, &a[i].second);
for (int i = 1; i < n; i++)
for (int j = 0; j < n; j++) {
x = i & 1;
dp[x][j] = max(dp[x ^ 1][(j + 1) % n] + dist(a[j], a[(j + 1) % n]),
w[x ^ 1][(i + j) % n] + dist(a[j], a[(i + j) % n]));
w[x][j] =
max(w[x ^ 1][(j - 1 + n) % n] + dist(a[j], a[(j - 1 + n) % n]),
dp[x ^ 1][(j - i + n) % n] + dist(a[j], a[(j - i + n) % n]));
}
for (int i = 0; i < n; i++) ans = max(ans, max(dp[x][i], w[x][i]));
printf("%.10f", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : (-x);
}
template <class T>
T sqr(T x) {
return x * x;
}
const double eps = 1E-8;
struct P {
double x, y;
P(double x = 0.0, double y = 0.0) : x(x), y(y) {}
P operator+(P a) { return P(x + a.x, y + a.y); }
P operator-(P a) { return P(x - a.x, y - a.y); }
P operator*(double k) { return P(x * k, y * k); }
double operator*(P a) { return x * a.y - y * a.x; }
double operator^(P a) { return x * a.x + y * a.y; }
double len() { return sqrt(x * x + y * y); }
P perp() { return P(y, -x); }
P norm() {
double l = len();
return abs(l) < eps ? P(x, y) : P(x / l, y / l);
}
bool operator==(P a) { return abs(x - a.x) < eps && abs(y - a.y) < eps; }
void load() { cin >> x >> y; }
};
int sgn(double x) {
if (x > eps) return 1;
if (x < -eps) return -1;
return 0;
}
bool pointOnSegment(P p, P a, P b) {
if (abs((a - p) * (b - p)) > eps) return false;
return ((a - p) ^ (b - p)) < eps;
}
bool crossSegments1d(double a, double aa, double b, double bb) {
return min(a, aa) < max(b, bb) + eps && min(b, bb) < max(a, aa) + eps;
}
bool crossSegments(P a, P aa, P b, P bb) {
if (sgn((b - a) * (aa - a)) * sgn((aa - a) * (bb - a)) < 0) return false;
if (sgn((a - b) * (bb - b)) * sgn((bb - b) * (aa - b)) < 0) return false;
return crossSegments1d(a.x, aa.x, b.x, bb.x) &&
crossSegments1d(a.y, aa.y, b.y, bb.y);
}
struct L {
double a, b, c;
L(double a = 0.0, double b = 0.0, double c = 0.0) : a(a), b(b), c(c) {}
bool operator||(L l) { return abs(a * l.b - b * l.a) < eps; }
};
L getLine(P p1, P p2) {
double x0 = p1.x, y0 = p1.y;
double al = (p2 - p1).x, be = (p2 - p1).y;
return L(be, -al, al * y0 - be * x0);
}
P getPoint(L l1, L l2) {
double det = l1.a * l2.b - l1.b * l2.a;
double det1 = -(l1.c * l2.b - l1.b * l2.c);
double det2 = -(l1.a * l2.c - l1.c * l2.a);
return P(det1 / det, det2 / det);
}
double h, f;
pair<double, double> calc1(double y, double x1, double x2) {
double l = x1 * (f - y) / (f - h);
double r = x2 * (f - y) / (f - h);
return make_pair(l, r);
}
pair<double, double> calc2(double y, double x1, double x2) {
double l = x1 * (y + f) / (f - h);
double r = x2 * (y + f) / (f - h);
return make_pair(l, r);
}
int main() {
int n;
cin >> n;
cin >> h >> f;
vector<pair<int, int> > v(n);
double res = 0.0;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &v[i].first, &v[i].second);
double l = abs(v[i].second - v[i].first);
res += 2. * h * (l + l * (f + h) / (f - h));
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
vector<P> V;
L l11 = getLine(P(0, f), P(v[i].first, h));
L l12 = getLine(P(0, f), P(v[i].second, h));
L l21 = getLine(P(0, -f), P(v[j].first, -h));
L l22 = getLine(P(0, -f), P(v[j].second, -h));
if (!(l11 || l21)) V.push_back(getPoint(l11, l21));
if (!(l11 || l22)) V.push_back(getPoint(l11, l22));
if (!(l12 || l21)) V.push_back(getPoint(l12, l21));
if (!(l12 || l22)) V.push_back(getPoint(l12, l22));
vector<double> ev;
ev.push_back(-h);
ev.push_back(-h);
ev.push_back(h);
ev.push_back(h);
for (int k = 0; k < ((int)(V).size()); ++k) {
if (abs(V[k].y) < h + eps) ev.push_back(V[k].y);
}
sort((ev).begin(), (ev).end());
double cur = 0;
double st = 0.0;
for (int k = 1; k < ((int)(ev).size()); ++k) {
pair<double, double> p = calc1(ev[k], v[i].first, v[i].second);
pair<double, double> q = calc2(ev[k], v[j].first, v[j].second);
double l = max(p.first, q.first);
double r = min(p.second, q.second);
double t = max(0.0, r - l);
cur += (t + st) * 0.5 * (ev[k] - ev[k - 1]);
st = t;
}
res -= abs(cur);
}
}
printf("%.10lf\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const long long MOD = 1000000007;
int cnt[MAXN];
long long fac[MAXN], ans = 1;
long long POW(long long exp, long long power) {
if (power == 0) return 1;
long long ansP = POW(exp, power / 2);
ansP = ansP * ansP % MOD;
if (power % 2 == 1) ansP = ansP * exp % MOD;
return ansP;
}
long long C(long long n, long long r) {
long long ansC = (fac[n] * (POW(fac[r] * fac[n - r] % MOD, MOD - 2))) % MOD;
return ansC;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fac[0] = 1;
fac[1] = 1;
for (int i = 2; i < MAXN; i++) {
fac[i] = i * fac[i - 1] % MOD;
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> cnt[i];
}
int length = cnt[0];
for (int i = 1; i < k; i++) {
ans *= C(cnt[i] + length - 1, length);
ans %= MOD;
length += cnt[i];
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool vis[10][10];
int d[10][10];
int dx[8] = {1, 0, 0, -1, 1, -1, 1, -1};
int dy[8] = {0, -1, 1, 0, 1, -1, -1, 1};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
if (r1 == r2 || c1 == c2) {
cout << 1 << ' ';
} else {
cout << 2 << ' ';
}
if ((r1 % 2 == c1 % 2 && r2 % 2 != c2 % 2) ||
(r1 % 2 != c1 % 2 && r2 % 2 == c2 % 2)) {
cout << 0 << ' ';
} else {
if (abs(r1 - r2) == abs(c1 - c2)) {
cout << 1 << ' ';
} else {
cout << 2 << ' ';
}
}
vis[r1][c1] = true;
queue<pair<int, int>> q;
q.push({r1, c1});
bool stop = false;
while (!q.empty()) {
auto u = q.front();
q.pop();
for (int t = 0; t < 8; t++) {
int x = u.first + dx[t];
int y = u.second + dy[t];
if (x < 1 || y < 1 || x > 8 || y > 8) continue;
if (vis[x][y] == true) continue;
d[x][y] = d[u.first][u.second] + 1;
vis[x][y] = true;
if (x == r2 && y == c2) {
stop = true;
break;
}
q.push({x, y});
}
if (stop) break;
}
cout << d[r2][c2];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int recpow(long long int x, long long int n, long long int mod) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return recpow((x * x) % mod, n / 2, mod);
else
return (x * recpow((x * x) % mod, (n - 1) / 2, mod)) % mod;
}
bool sortbysec(
const pair<pair<long long int, long long int>, long long int> &a,
const pair<pair<long long int, long long int>, long long int> &b) {
if (a.second == b.second)
return (a.first.second < b.first.second);
else
return (a.second > b.second);
}
long long int modInverse(long long int n, long long int p) {
return recpow(n, p - 2, p);
}
long long int nCr(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
string rev(string s) {
string t;
for (long long int i = s.length() - 1; i >= 0; i--) {
t.push_back(s[i]);
}
return t;
}
bool is_p(long long int n) {
for (long long int i = 2; i * i <= n; ++i) {
if (n % i == 0) return false;
}
return true;
}
bool ispow2(long long int n) {
while (n % 2 == 0) n /= 2;
if (n == 1) return true;
return false;
}
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return (a.first >= b.first and a.second >= b.second);
}
string itos(long long int n) {
string s = "";
if (n == 0) return "0";
while (n > 0) {
s.push_back(n % 10 + '0');
n /= 10;
}
s = rev(s);
return s;
}
char bit(char ch) {
if (ch == '1') return '0';
return '1';
}
int main() {
long double x, y;
cin >> x >> y;
long double a = y * log(x), b = x * log(y);
if (a > b)
cout << ">";
else if (a < b)
cout << "<";
else
cout << "=";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(int b, int p) {
long long i, m = 1;
for (i = 1; i <= p; i++) m = m * b;
return m;
}
int main() {
long long x = 0, y = 0, bx, by, n, i, j, k, po, t;
cin >> n >> bx;
po = n - 1;
for (i = 1; i <= n; i++) {
scanf("%I64d", &t);
x += power(bx, po) * t;
po--;
}
cin >> n >> by;
po = n - 1;
for (i = 1; i <= n; i++) {
scanf("%I64d", &t);
y += power(by, po) * t;
po--;
}
if (x > y)
cout << ">";
else if (x < y)
cout << "<";
else
cout << "=";
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int a, b, c = 0;
cin >> a >> b;
while (b != 0) {
c += b % 10;
c *= 10;
b /= 10;
}
c /= 10;
cout << c + a << endl;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, top;
std::cin >> n >> top;
if (top > 3) top = 7 - top;
int left, right;
while (n--) {
std::cin >> left >> right;
if (left > 3) left = 7 - left;
if (right > 3) right = 7 - right;
if (left + right != 6 - top) {
std::cout << "NO\n";
return 0;
}
}
std::cout << "YES\n";
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
cout << a.at(0) << b.at(1) << c.at(2) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, sl, fh, g[2], f[2], d[200010], p[200010], ex[200010], vis[200010],
a[200010][2], b[200010][2], dp[200010][2][2];
int t, h[200010];
struct edge {
int to, id, nxt;
} e[200010 << 1];
vector<int> vt, VT;
int rd() {
sl = 0;
fh = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = getchar();
return sl * fh;
}
void upd(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
int Abs(int x) {
if (x >= 0) return x;
return -x;
}
void add(int u, int v, int id) {
e[++t] = (edge){v, id, h[u]};
h[u] = t;
e[++t] = (edge){u, id, h[v]};
h[v] = t;
d[u]++;
d[v]++;
}
void dfs(int u) {
int v;
vis[u] = 1;
vt.push_back(u);
for (int i = h[u]; i; i = e[i].nxt)
if (!vis[v = e[i].to]) dfs(v);
}
void DP(int l1, int r1, int l2, int r2) {
int res, siz = vt.size();
memset(dp + 1, 0, siz << 4);
for (int i = l1; i <= r1; ++i) dp[1][i][0] = 1;
for (int k, i = 1; i < siz; ++i) {
for (int x = h[vt[i]]; x; x = e[x].nxt)
if (!ex[e[x].id] && e[x].to == vt[i - 1]) k = e[x].id;
ex[k] = 1;
VT.push_back(k);
if (Abs(a[k][0]) == vt[i]) swap(a[k][0], a[k][1]);
for (int x = 0; x < 2; ++x)
for (int v = 0; v < 2; ++v)
if ((res = dp[i][x][v]))
for (int y = 0; y < 2; ++y)
upd(dp[i + 1][y][(((a[k][0] < 0) ^ x) | ((a[k][1] < 0) ^ y)) ^ v],
res);
}
for (int i = l2; i <= r2; ++i)
for (int j = 0; j < 2; ++j) upd(g[j], dp[siz][i][j]);
}
void solve() {
g[0] = g[1] = 0;
int rt, siz = vt.size();
VT.clear();
if (siz == 1) {
rt = vt[0];
if (b[rt][1]) return (void)(g[(a[b[rt][0]][0] ^ a[b[rt][1]][0]) != 0] = 2);
if (!a[b[rt][0]][1]) return (void)(g[0] = g[1] = 1);
if (a[b[rt][0]][0] ^ a[b[rt][0]][1]) return (void)(g[1] = 2);
return (void)(g[0] = g[1] = 1);
}
rt = 0;
for (auto x : vt)
if (d[x] == 1) rt = x;
if (rt) {
for (auto x : vt) vis[x] = 0;
vt.clear();
if (!a[b[rt][0]][1]) vt.push_back(0), add(rt, 0, b[rt][0]);
dfs(rt);
rt = vt.back();
if (!a[b[rt][0]][1]) vt.push_back(0), add(rt, 0, b[rt][0]);
DP(0, vt[0] > 0, 0, vt.back() > 0);
return;
}
vt.push_back(vt[0]);
DP(0, 0, 0, 0);
for (auto x : VT) ex[x] = 0;
DP(1, 1, 1, 1);
}
int main() {
n = rd();
m = rd();
int x, y;
vis[0] = 1;
for (int k, i = 1; i <= n; ++i) {
k = rd() - 1;
x = Abs(a[i][0] = rd());
if (b[x][0])
b[x][1] = i;
else
b[x][0] = i;
if (k) {
y = Abs(a[i][1] = rd());
if (b[y][0] && b[y][0] != i)
b[y][1] = i;
else
b[y][0] = i;
add(x, y, i);
}
}
f[0] = 1;
for (int i = 1; i <= m; ++i)
if (!b[i][0]) upd(f[0], f[0]);
for (int i = 1; i <= m; ++i)
if (b[i][1] && !a[b[i][1]][1]) swap(b[i][0], b[i][1]);
for (int i = 1; i <= m; ++i)
if (!vis[i] && b[i][0]) {
vt.clear();
dfs(i);
solve();
x = f[0];
y = f[1];
f[0] = (1ll * x * g[0] + 1ll * y * g[1]) % mod;
f[1] = (1ll * x * g[1] + 1ll * y * g[0]) % mod;
}
printf("%d\n", f[1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, cl = 1, mlsf = 1, oldci = 0;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i + 1 < n; i++) {
if (a[i + 1] > a[i]) {
cl++;
if (cl > mlsf) mlsf = cl;
} else if ((i + 2 < n && a[i + 2] - a[i] >= 2) ||
(i - 1 >= 0 && a[i + 1] - a[i - 1] >= 2) ||
(i == 0 && a[i + 1] != 1)) {
cl = i + 2 - (oldci + 1) + 1;
oldci = i + 1;
if (cl > mlsf) mlsf = cl;
} else if (i == 0 && a[i + 1] != 1)
cl = 2;
else {
cl = i + 2 - (oldci + 1) + 1;
if (cl > mlsf) mlsf = cl;
cl = 2;
oldci = i + 1;
}
}
cout << mlsf << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926536;
int main() {
int n, m, h;
cin >> n >> m >> h;
int a[m];
for (int i = 0; i < m; i++) cin >> a[i];
int b[n];
for (int i = 0; i < n; i++) cin >> b[i];
int c[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (c[i][j] != 0) c[i][j] = b[i];
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
if (c[i][j] != 0) c[i][j] = min(a[j], c[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << c[i][j] << " ";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int MAX = 1e5;
const long long MOD = 1e9 + 7;
const long long inf = 1e18;
int a[MAX + 5];
int main() {
ios_base::sync_with_stdio(false);
int n, m, r, i, j;
long long ans = 0;
cin >> n >> m;
a[0] = 1;
for ((i) = (1); (i) <= (m); ++i) cin >> a[i];
i = 0;
while (i < m) {
if (a[i + 1] > a[i])
ans += (a[i + 1] - a[i]);
else if (a[i + 1] < a[i])
ans += (n - a[i] + a[i + 1]);
i++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int bell[4100];
long long int com[4100][4100];
long long int ans;
int n;
int main(void) {
int i, j;
cin >> n;
bell[0] = 1;
bell[1] = 1;
bell[2] = 2;
com[0][0] = 1;
for (i = 1; i <= n; i++) {
com[i][0] = 1;
com[i][i] = 1;
}
for (i = 2; i <= n; i++) {
for (j = 1; j <= i - 1; j++) {
com[i][j] = (com[i - 1][j - 1] + com[i - 1][j]) % mod;
}
}
for (i = 2; i <= n; i++) {
for (j = 0; j <= i; j++) {
bell[i + 1] = (bell[i + 1] + (com[i][j] * bell[j]) % mod) % mod;
}
}
for (i = 1; i <= n; i++) {
ans = (ans + (com[n][i] * bell[n - i]) % mod) % mod;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct team {
string name;
int jf, jsq, jq;
};
int main() {
int n, g1, g2;
string p1, p2;
cin >> n;
team a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i].name;
cin.ignore();
for (int i = 1; i <= n; i++) {
a[i].jf = 0;
a[i].jsq = 0;
a[i].jq = 0;
}
for (int i = 1; i <= (n - 1) * n / 2; i++) {
getline(cin, p1, '-');
getline(cin, p2, ' ');
scanf("%d:%d", &g1, &g2);
cin.ignore();
for (int j = 1; j <= n; j++)
if (a[j].name == p1) {
a[j].jq += g1;
a[j].jsq = a[j].jsq + (g1 - g2);
if (g1 > g2)
a[j].jf += 3;
else if (g1 == g2)
a[j].jf += 1;
break;
}
for (int j = 1; j <= n; j++)
if (a[j].name == p2) {
a[j].jq += g2;
a[j].jsq = a[j].jsq + (g2 - g1);
if (g2 > g1)
a[j].jf += 3;
else if (g1 == g2)
a[j].jf += 1;
break;
}
}
for (int i = 1; i <= n - 1; i++) {
for (int j = i + 1; j <= n; j++)
if (a[i].jf < a[j].jf)
swap(a[i], a[j]);
else if (a[i].jf == a[j].jf) {
if (a[i].jsq < a[j].jsq)
swap(a[i], a[j]);
else if (a[i].jsq == a[j].jsq) {
if (a[i].jq < a[j].jq)
swap(a[i], a[j]);
else if (a[i].jq == a[j].jq)
if (a[i].name > a[j].name) swap(a[i], a[j]);
}
}
}
for (int i = 1; i <= n / 2 - 1; i++) {
for (int j = i; j <= n / 2; j++)
if (a[i].name > a[j].name) swap(a[i], a[j]);
}
for (int i = 1; i <= n / 2; i++) cout << a[i].name << endl;
return 0;
}
| 1 |
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
typedef pair<int,int> PA;
int main(){
int v,e,s,t,w;
vector<PA> vec[100001];
scanf("%d %d",&v,&e);
for(int i=0;i<e;i++){
scanf("%d %d %d",&s,&t,&w);
vec[s].push_back(PA(w,t));
vec[t].push_back(PA(w,s));
}
priority_queue<PA,vector<PA>,greater<PA> > pq;
pq.push(PA(0,0));
bool g[100001]={false};
int cnt = 0;
while(!pq.empty()){
PA pt = pq.top();
pq.pop();
if(g[pt.second]) continue;
g[pt.second] = true;
cnt += pt.first;
for(int i=0;i<vec[pt.second].size();i++){
pq.push(vec[pt.second][i]);
}
}
printf("%d\n",cnt);
return(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void boost() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long bins(long long a[], long long n, long long key) {
int lo = 0, hi = n - 1, ans = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] <= key) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
return a[ans];
}
int main() {
boost();
long long n, u;
cin >> n >> u;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int flg = 0;
for (int i = 0; i < n - 2; i++)
if ((a[i + 2] - a[i]) <= u) {
flg = 1;
break;
}
if (flg == 0) {
cout << "-1\n";
return 0;
}
long long num = -1, den = 1;
for (int i = 0; i < n - 2; i++) {
long long ek, ej, ei, c, d;
if (a[i] + u <= a[n - 1]) {
ek = bins(a, n, a[i] + u);
ej = a[i + 1], ei = a[i];
} else {
ek = a[n - 1], ej = a[i + 1], ei = a[i];
}
c = ek - ej, d = ek - ei;
if ((c * den) - (d * num) > 0) {
num = c, den = d;
}
}
printf("%0.10lf\n", (num * 1.0) / (den * 1.0));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <int C>
struct PersistentStringTrie {
PersistentStringTrie* nex[C];
signed long long v;
int mp(char c) {
if (c >= 'a' && c <= 'z') return c - 'a';
if (c >= 'A' && c <= 'Z') return c - 'A' + 26;
assert(0);
return 0;
}
PersistentStringTrie() {
v = -1;
for (int i = 0; i < C; i++) nex[i] = NULL;
}
PersistentStringTrie(PersistentStringTrie* pst) {
v = pst->v;
for (int i = 0; i < C; i++) nex[i] = pst->nex[i];
}
PersistentStringTrie* set(string& s, signed long long val, int pos = 0) {
PersistentStringTrie* pst = new PersistentStringTrie(this);
if (pos >= s.size()) {
pst->v = val;
} else {
int c = mp(s[pos]);
if (!nex[c]) nex[c] = new PersistentStringTrie();
pst->nex[c] = nex[c]->set(s, val, pos + 1);
}
return pst;
}
signed long long get(string& s, int pos = 0) {
if (pos >= s.size()) return v;
int c = mp(s[pos]);
if (!nex[c]) return -1;
return nex[c]->get(s, pos + 1);
}
};
struct PersistentBinarySumTrie {
PersistentBinarySumTrie* nex[2];
signed long long v;
PersistentBinarySumTrie() {
nex[0] = nex[1] = NULL;
v = 0;
}
PersistentBinarySumTrie(PersistentBinarySumTrie* pbst) {
nex[0] = pbst->nex[0];
nex[1] = pbst->nex[1];
v = pbst->v;
}
PersistentBinarySumTrie* add(signed long long s, signed long long val,
int pos = 60) {
PersistentBinarySumTrie* pbst = new PersistentBinarySumTrie(this);
pbst->v += val;
if (pos >= 0) {
int c = (s >> pos) & 1;
if (!nex[c]) nex[c] = new PersistentBinarySumTrie();
pbst->nex[c] = nex[c]->add(s, val, pos - 1);
}
return pbst;
}
signed long long get(signed long long s, int pos = 60) {
if (pos < 0) return 0;
int c = (s >> pos) & 1;
if (c)
return (nex[0] ? nex[0]->v : 0) + (nex[1] ? nex[1]->get(s, pos - 1) : 0);
else
return (nex[0] ? nex[0]->get(s, pos - 1) : 0);
}
};
int Q;
PersistentStringTrie<26>* st[101010];
PersistentBinarySumTrie* bst[101010];
string OP, A;
int X;
void solve() {
int i, j, k, l, r, x, y;
string s;
st[0] = new PersistentStringTrie<26>();
bst[0] = new PersistentBinarySumTrie();
cin >> Q;
for (i = 1; i <= Q; i++) {
cin >> OP;
if (OP == "set") {
cin >> A >> X;
x = st[i - 1]->get(A);
st[i] = st[i - 1]->set(A, X);
if (x >= 0) {
bst[i] = bst[i - 1]->add(x, -1)->add(X, 1);
} else {
bst[i] = bst[i - 1]->add(X, 1);
}
}
if (OP == "remove") {
cin >> A;
x = st[i - 1]->get(A);
st[i] = st[i - 1]->set(A, -1);
if (x >= 0) {
bst[i] = bst[i - 1]->add(x, -1);
} else {
bst[i] = bst[i - 1];
}
}
if (OP == "undo") {
cin >> X;
st[i] = st[i - X - 1];
bst[i] = bst[i - X - 1];
}
if (OP == "query") {
st[i] = st[i - 1];
bst[i] = bst[i - 1];
cin >> A;
x = st[i]->get(A);
if (x < 0)
cout << -1 << endl;
else
cout << bst[i]->get(x) << endl;
}
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char str[60][5], tmp[10];
map<pair<int, string>, int> M;
queue<pair<int, string> > Q;
pair<int, string> cur;
int main() {
int n;
scanf("%d", &n);
n += 2;
for (int i = 0; i < 3; i++) strcpy(str[i], "**");
for (int i = 3; i <= n; i++) scanf("%s", str[i]);
strcat(tmp, str[n - 2]);
strcat(tmp, str[n - 1]);
strcat(tmp, str[n]);
Q.push({n, tmp});
M[{n, tmp}] = 1;
int ok = 0;
while (!Q.empty()) {
cur = Q.front();
Q.pop();
if (cur.first == 3) {
ok = 1;
break;
}
if (cur.first > 3 &&
(cur.second[2] == cur.second[4] || cur.second[3] == cur.second[5])) {
tmp[0] = str[cur.first - 3][0];
tmp[1] = str[cur.first - 3][1];
tmp[2] = cur.second[0];
tmp[3] = cur.second[1];
tmp[4] = cur.second[4];
tmp[5] = cur.second[5];
if (!M.count({cur.first - 1, tmp}))
Q.push({cur.first - 1, tmp}), M[{cur.first - 1, tmp}] = 1;
}
if (cur.first > 5 && (str[cur.first - 3][0] == cur.second[4] ||
str[cur.first - 3][1] == cur.second[5])) {
tmp[0] = cur.second[4];
tmp[1] = cur.second[5];
tmp[2] = cur.second[0];
tmp[3] = cur.second[1];
tmp[4] = cur.second[2];
tmp[5] = cur.second[3];
if (!M.count({cur.first - 1, tmp}))
Q.push({cur.first - 1, tmp}), M[{cur.first - 1, tmp}] = 1;
}
}
if (ok)
puts("YES");
else
puts("NO");
}
| 2 |
#include<iostream>
using namespace std;
int main(void){
long long A, B, N;
cin >> A >> B >> N;
cout << (B + N) / N - (A + N - 1) / N << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C &a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C &a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long MAX = 1111;
bool cz[MAX];
long long n, k;
bool odw[MAX * 2];
vector<long long> s1, s2;
void add(long long x) {
x += MAX;
if (x < 0 || x >= 2 * MAX) return;
if (odw[x]) return;
odw[x] = 1;
s2.push_back(x - MAX);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
cin >> n >> k;
for (long long i = (0); i <= ((long long)(k)-1); i++) {
long long pom;
cin >> pom;
cz[pom] = 1;
add(pom - n);
}
long long res = 0;
while (((long long)(s2).size())) {
res++;
swap(s1, s2);
s2.clear();
for (long long a : s1) {
if (a == 0) {
cout << res << "\n";
return 0;
}
for (long long i = (0); i <= ((long long)(MAX)-1); i++)
if (cz[i]) {
add(a + i - n);
}
}
}
cout << "-1\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int s1, t1, l1, s2, t2, l2;
vector<int> adj[3005];
vector<int> d[3005];
vector<int> dis;
vector<int> getDis(int node) {
dis = vector<int>(3005);
for (int i = (0); i < int(n); ++i) dis[i] = 1000000;
dis[node] = 0;
queue<int> q;
q.push(node);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = (0); i < int(adj[cur].size()); ++i) {
int to = adj[cur][i];
if (dis[to] != 1000000) continue;
dis[to] = dis[cur] + 1;
q.push(to);
}
}
return dis;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < int(m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
adj[a].push_back(b);
adj[b].push_back(a);
}
scanf("%d%d%d%d%d%d", &s1, &t1, &l1, &s2, &t2, &l2);
--s1;
--t1;
--s2;
--t2;
for (int i = (0); i < int(n); ++i) d[i] = getDis(i);
if (d[s1][t1] > l1 || d[s2][t2] > l2) {
puts("-1");
return 0;
}
int need = d[s1][t1] + d[s2][t2];
for (int i = (0); i < int(n); ++i)
for (int j = (0); j < int(n); ++j) {
int d1 = min(d[s1][i] + d[t1][j], d[s1][j] + d[t1][i]);
int d2 = min(d[s2][i] + d[t2][j], d[s2][j] + d[t2][i]);
if (d1 + d[i][j] > l1 || d2 + d[i][j] > l2) continue;
int tmp = d1 + d2 + d[i][j];
need = min(need, tmp);
}
printf("%d\n", m - need);
}
| 2 |
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int M=1e6+5;
int n,u,v;
ll ans;
int A[M];
void check(int line){
if(A[line]==A[line-1]&&line>1)ans=min(ans,min(0ll+u+v,0ll+v+v));
if(abs(A[line]-A[line-1])>=1)ans=min(ans,min(0ll+v,0ll+u));
}
int main(){
int T;
scanf("%d",&T);
while(T--&&scanf("%d %d %d",&n,&u,&v)){
ans=1e15+7;
for(int i=1;i<=n;i++){
scanf("%d",&A[i]);
}
A[0]=A[1];
bool flag=false;
for(int i=1;i<=n;i++){
if(abs(A[i]-A[i-1])>=2){
puts("0");
flag=true;break;
}
}
if(flag)continue;
for(int i=1;i<=n;i++){
check(i);
}
printf("%lld\n",ans);
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.