solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
inline void SetIO(string Name) {
string In = Name + ".in", Out = Name + ".out";
freopen(In.c_str(), "r", stdin), freopen(Out.c_str(), "w", stdout);
}
const int N = 100010;
int n, m;
int C[N][26], Fa[N], Tot;
bool End[N], Win[N], Lose[N];
int Que[N], Head, Tail;
string Str;
inline void Input() {
scanf("%d%d", &n, &m);
End[Tot = 1] = 1;
for (int i = (1); i <= (n); i++) {
cin >> Str;
int Len = Str.length(), Now = 1;
for (int j = (0); j < (Len); j++) {
if (!C[Now][Str[j] - 'a']) {
End[Now] = 0;
End[C[Now][Str[j] - 'a'] = ++Tot] = 1;
Fa[Tot] = Now;
}
Now = C[Now][Str[j] - 'a'];
}
}
}
inline void Bfs() {
Head = 1, Tail = 1, Que[1] = 1;
while (Head <= Tail) {
int x = Que[Head++];
for (int i = (0); i < (26); i++)
if (C[x][i]) Que[++Tail] = C[x][i];
}
}
inline void Draw(bool *Cnt) {
for (int i = (Tail); i >= (2); i--) Cnt[Fa[Que[i]]] |= !Cnt[Que[i]];
}
inline void Solve() {
Bfs();
Draw(Win);
for (int i = (1); i <= (Tot); i++)
if (End[i]) Lose[i] = 1;
Draw(Lose);
int CanWin = Win[1], CanLose = Lose[1];
if (CanWin && CanLose)
puts("First");
else if (!CanWin && !CanLose)
puts("Second");
else if (!CanWin && CanLose)
puts("Second");
else if (CanWin && !CanLose)
puts((m & 1) ? "First" : "Second");
}
int main() {
Input();
Solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n, ans = 0;
cin >> n;
unordered_map<long long int, long long int> a;
for (long long int i = 1; i * (i + 1) <= n * n; ++i) {
for (long long int j = i + 1; i * i + j * j <= n * n; ++j) {
long long int k = sqrt(i * i + j * j);
if (k * k == i * i + j * j) a[k]++;
}
}
for (auto &i : a) ans += i.second;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int num[25], cnt;
long long dp[(1 << 18)][100];
long long fac[30], bcnt[10];
int main(void) {
long long n, m;
scanf("%lld%lld", &n, &m);
for (; n; num[++cnt] = n % 10, n /= 10)
;
dp[0][0] = 1;
for (register int i = 0; i < (1 << cnt); ++i)
for (register int j = 0; j < m; ++j)
for (register int k = 0; k < cnt; ++k) {
if (i & (1 << k)) continue;
if (!i && !num[k + 1]) continue;
dp[i | (1 << k)][(j * 10 + num[k + 1]) % m] += dp[i][j];
}
fac[0] = 1;
for (register int i = 1; i <= 20; ++i) fac[i] = fac[i - 1] * i;
for (register int i = 1; i <= cnt; ++i) ++bcnt[num[i]];
long long ans = dp[(1 << cnt) - 1][0];
for (register int i = 0; i <= 9; ++i) ans /= fac[bcnt[i]];
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int Add(int x) { return x >= mod ? x - mod : x; }
inline void Add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int Sub(int x) { return x < 0 ? x + mod : x; }
inline void Sub(int &x, int y) { x = Sub(x - y); }
inline int Mul(int x, int y) { return (int)((unsigned long long)x * y % mod); }
inline int Mul(int x, int y, int z) {
return (int)((unsigned long long)x * y % mod * z % mod);
}
int Pow(int x, int y) {
int z = 1;
for (; y; y >>= 1) {
if (y & 1) z = Mul(z, x);
x = Mul(x, x);
}
return z;
}
int Inv(int x) { return Pow(x, mod - 2); }
const int N = 1 << 16;
int n;
char s[500 + 1];
void operator+=(vector<int> &a, const vector<int> &b) {
for (int i = 0; i < N; ++i) Add(a[i], b[i]);
}
vector<int> FFind(char c) {
static bool is_first = true;
static vector<int> ans[256];
if (is_first) {
ans['?'].resize(N);
for (int id = 0; id < 4; ++id) {
int y = 0;
for (int x = 0; x < 16; ++x) {
if (x >> id & 1) y |= 1 << x;
}
ans['A' + id].resize(N);
ans['A' + id][y] = 1;
ans['?'] += ans['A' + id];
int z = 0;
for (int x = 0; x < 16; ++x) {
if (~x >> id & 1) z |= 1 << x;
}
ans['a' + id].resize(N);
ans['a' + id][z] = 1;
ans['?'] += ans['a' + id];
}
is_first = false;
}
return ans[(int)c];
}
void Fmt(vector<int> &a) {
for (int i = 0; i < 16; ++i) {
for (int x = 0; x < N; ++x) {
if (~x >> i & 1) {
Add(a[x | 1 << i], a[x]);
}
}
}
}
void Ifmt(vector<int> &a) {
for (int i = 0; i < 16; ++i) {
for (int x = 0; x < N; ++x) {
if (~x >> i & 1) {
Sub(a[x | 1 << i], a[x]);
}
}
}
}
vector<int> Or(vector<int> a, vector<int> b) {
Fmt(a);
Fmt(b);
for (int i = 0; i < N; ++i) {
a[i] = Mul(a[i], b[i]);
}
Ifmt(a);
return a;
}
vector<int> And(vector<int> a, vector<int> b) {
int all = N - 1;
for (int i = 0; i < N; ++i) {
int j = all - i;
if (i < j) {
swap(a[i], a[j]);
swap(b[i], b[j]);
}
}
vector<int> c = Or(a, b);
for (int i = 0; i < N; ++i) {
int j = all - i;
if (i < j) {
swap(c[i], c[j]);
}
}
return c;
}
vector<int> FFind(const vector<int> &a, const vector<int> &b, char c) {
vector<int> ans(N, 0);
if (c == '|' || c == '?') {
vector<int> res = Or(a, b);
ans += res;
}
if (c == '&' || c == '?') {
vector<int> res = And(a, b);
ans += res;
}
return ans;
}
vector<int> Find(int l, int r) {
if (s[l] == '(') {
int mid = -1, level = 0;
for (int i = l; i < r; ++i) {
if (s[i] == '(') {
++level;
} else if (s[i] == ')') {
if (--level == 0) {
mid = i + 1;
break;
}
}
}
assert(mid > l && mid < r - 1);
return FFind(Find(l + 1, mid - 1), Find(mid + 2, r - 1), s[mid]);
} else {
assert(r - l == 1);
return FFind(s[l]);
}
}
int m;
int X[100], Y[100];
int main(void) {
scanf("%s", s);
n = (int)strlen(s);
vector<int> f = Find(0, n);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int a, b, c, d, v;
scanf("%d%d%d%d%d", &a, &b, &c, &d, &v);
X[i] = a | b << 1 | c << 2 | d << 3;
Y[i] = v;
}
int ans = 0;
for (int x = 0; x < N; ++x) {
bool good = true;
for (int i = 0; i < m; ++i) {
if ((x >> X[i] & 1) != Y[i]) {
good = false;
break;
}
}
if (good) {
Add(ans, f[x]);
}
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
const int mod = 1e9 + 7;
int n, k, x, y;
string s, t;
vector<pair<int, int> > ans;
int c[100], d[100];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> k;
while (k--) {
ans.clear();
memset(c, 0, sizeof(c));
memset(d, 0, sizeof(d));
x = 0;
y = 0;
cin >> n;
cin >> s >> t;
int cnt = 0;
for (int i = 0; i < n; i++) {
c[s[i] - 'a']++;
d[t[i] - 'a']++;
}
int tmp = 0;
for (int i = 0; i <= 50; i++) {
if ((c[i] + d[i]) % 2 == 1) {
tmp = 1;
cout << "NO" << endl;
break;
}
}
if (tmp == 1) continue;
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
int ch = 0;
for (int j = i + 1; j <= n; j++) {
if (s[i] == s[j]) {
ans.push_back(pair<int, int>(j + 1, i + 1));
swap(t[i], s[j]);
ch = 1;
break;
}
}
if (ch == 0) {
for (int j = i + 1; j <= n; j++) {
if (t[j] == s[i]) {
ans.push_back(pair<int, int>(j + 1, j + 1));
ans.push_back(pair<int, int>(j + 1, i + 1));
swap(s[j], t[j]);
swap(s[j], t[i]);
break;
}
}
}
}
}
cout << ans.size() << endl;
for (auto i : ans) cout << i.first << " " << i.second << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> kek;
long long n;
signed main() {
cin >> n;
long long arr[n + 1];
for (long long i = 0; i != n; ++i) scanf("%lld", &arr[i]);
arr[n] = n + 1;
long long ans = 0;
kek.push_back(arr[0]);
for (long long i = 1; i != n + 1; ++i) {
if (arr[i] == arr[i - 1]) continue;
kek.push_back(arr[i]);
}
long long m = kek.size();
for (long long i = 1; i != m; ++i) {
if (kek[i] > kek[i - 1]) {
ans += kek[i - 1] * (kek[i] - kek[i - 1]);
} else {
ans += (n - kek[i - 1] + 1) * (kek[i - 1] - kek[i]);
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sq(int s) { return s * s; }
int bigmod(int b, int p, int m) {
int res = 1, x = b;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
int ex_euc(int aa, int bb, int *xx, int *yy) {
int x, y, u, v, m, n, a, b, q, r;
x = 0, y = 1;
u = 1, v = 0;
for (a = aa, b = bb; a != 0; b = a, a = r, x = u, y = v, u = m, v = n) {
q = b / a;
r = b % a;
m = x - (u * q);
n = y - (v * q);
}
*xx = x;
*yy = y;
return b;
}
int gcd(int a, int b) {
int c;
while (b) {
c = a % b;
a = b;
b = c;
}
return a;
}
int lcm(int a, int b) { return (int)(a * (b / gcd(a, b))); }
int Pow(int a, int p) {
int res = 1, x = a;
while (p) {
if (p & 1) res = res * x;
x = x * x;
p >>= 1;
}
return res;
}
int Max(int a, int b) { return a > b ? a : b; }
int Min(int a, int b) { return a < b ? a : b; }
int Abs(int a) { return a < 0 ? -a : a; }
struct SM {
int a, b;
};
bool cmp(SM a, SM b) { return a.a < b.a; }
char *ch, s[100005], s1[100005], s2[100005], ss[100005];
int main() {
int l, ll, k, i, j, kk;
while (scanf("%s%s", s, ss) == 2) {
j = 0;
l = strlen(s);
for (i = 0; i <= l - 1; i++) {
if (s[i] == '|') break;
s1[j++] = s[i];
}
s1[j] = 0;
j = 0;
for (i = i + 1; i <= l - 1; i++) s2[j++] = s[i];
s2[j] = 0;
l = strlen(s1);
ll = strlen(s2);
k = strlen(ss);
if (l < ll)
kk = ll - l;
else
kk = l - ll;
if (l < ll && l + k == ll)
printf("%s%s|%s\n", s1, ss, s2);
else if (ll < l && ll + k == l)
printf("%s|%s%s\n", s1, s2, ss);
else if (ll == l && k % 2 == 0) {
printf("%s", s1);
for (i = 0; i <= (k / 2) - 1; i++) putchar(ss[i]);
printf("|%s", s2);
for (i = i; i <= k - 1; i++) putchar(ss[i]);
printf("\n");
} else if (l < ll && k - kk > 0 && (k - kk) % 2 == 0) {
printf("%s", s1);
for (i = 0; i <= kk - 1; i++) putchar(ss[i]);
j = k - kk;
for (i = kk; i <= kk + (j / 2) - 1; i++) putchar(ss[i]);
printf("|%s", s2);
for (i = i; i <= k - 1; i++) putchar(ss[i]);
printf("\n");
} else if (ll < l && (k - kk) > 0 && (k - kk) % 2 == 0) {
printf("%s", s1);
j = k - kk;
for (i = kk; i <= kk + (j / 2) - 1; i++) putchar(ss[i]);
printf("|%s", s2);
for (i = i; i <= k - 1; i++) putchar(ss[i]);
for (i = 0; i <= kk - 1; i++) putchar(ss[i]);
printf("\n");
} else
puts("Impossible");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int max_dist;
cin >> max_dist;
int n;
cin >> n;
int ans = 0;
int x;
for (int i(0); i < n - 1; ++i) {
cin >> x;
ans += (max_dist - x);
}
cin >> x;
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5+45;
int n,k,a[N],maxi = 0;
bool ima[N];
int b[N],minpf[N];
bool ok(int x){
/*if(!ima[x]){
if(x > maxi) return 0;
return 1;
}*/
int sum = 0;
minpf[0] = 0;
for(int i = 1; i <= n; i++){
b[i] = (a[i] >= x ? 1 : -1);
sum += b[i];
minpf[i] = min(minpf[i-1],sum);
}
sum = 0;
for(int i = 1; i <= n; i++){
sum += b[i];
if(i < k) continue;
int najm = minpf[i-k];
if(sum-najm > 0) return 1;
}
return 0;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for(int i = 1; i <= n; i++){
cin >> a[i];
ima[a[i]] = 1;
maxi = max(maxi,a[i]);
}
int l = 1,r = n,ans = 0;
while(l <= r){
int mid = l+(r-l)/2;
if(ok(mid)){
ans = mid;
l = mid+1;
}
else{
r = mid-1;
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a >= b) {
cout << b << endl;
cout << fabs((a - b) / 2);
}
if (b > a) {
cout << a << endl;
cout << fabs((a - b) / 2);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 10005;
set<int> v[max_n];
set<int>::iterator it;
int main() {
int n, m;
cin >> n >> m;
bool f = 0;
for (int i = 0; i < m; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int z;
cin >> z;
v[i].insert(z);
}
}
int i, j;
for (i = 0; i < m; i++) {
for (it = v[i].begin(); it != v[i].end(); it++) {
if (v[i].find(-(*it)) != v[i].end()) break;
}
if (it == v[i].end()) {
f = 1;
break;
}
}
if (f == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long calc(long long n, long long m, long long k,
vector<vector<vector<long long>>>& dp) {
if (dp[n][m][k] != -1) return dp[n][m][k];
dp[n][m][k] = ((long long)1e9 + 9);
if (n * m == k) return (dp[n][m][k] = 0);
if (k == 0) return (dp[n][m][k] = 0);
if (n * m < k) return (dp[n][m][k] = ((long long)1e9 + 9));
for (long long i = (1); i < (n); i++) {
for (long long j = 0; j < (k + 1); j++) {
dp[n][m][k] = min(dp[n][m][k],
calc(i, m, j, dp) + calc(n - i, m, k - j, dp) + m * m);
}
}
for (long long i = (1); i < (m); i++) {
for (long long j = 0; j < (k + 1); j++) {
dp[n][m][k] = min(dp[n][m][k],
calc(n, i, j, dp) + calc(n, m - i, k - j, dp) + n * n);
}
}
return dp[n][m][k];
}
void solve() {
vector<vector<vector<long long>>> dp(
31, vector<vector<long long>>(31, vector<long long>(51, -1)));
long long tests;
cin >> tests;
for (long long test = 0; test < (tests); test++) {
long long n;
cin >> n;
long long m;
cin >> m;
long long k;
cin >> k;
cout << calc(n, m, k, dp) << '\n';
}
}
signed main(signed argc, char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie();
cout.setf(cout.fixed);
cout.precision(10);
if (argc > 1 && (string)argv[1] == "file") {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
long long number_sample = 1;
do {
cout << "Sample #" << number_sample << ":" << '\n';
cerr << "Sample #" << number_sample << ":" << '\n';
solve();
number_sample++;
cout << '\n';
cerr << '\n';
} while (!cin.eof());
} else {
cerr.clear(ios_base::badbit);
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char c[100000] = {0};
bool bl[100000] = {0};
int num[100000] = {0};
int nm[1000] = {0};
vector<int> a[1000];
int cnt = -2;
void dfs(int x, int col) {
num[nm[x]] = col;
bl[nm[x]] = 1;
cnt = max(cnt, col);
int tmp = col + 1;
for (int i = 0; i < a[x].size(); ++i) {
int j = a[x][i];
if (!bl[nm[j]]) {
dfs(j, col + 1);
}
}
}
bool q[1000][1000] = {0};
int main() {
int n, m, x, y;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
q[x][y] = q[y][x] = 1;
q[x][x] = q[y][y] = 1;
a[x].push_back(y);
a[y].push_back(x);
}
memset(nm, -1, sizeof nm);
int res = 0;
for (int i = 1; i <= n; ++i) {
if (nm[i] != -1) continue;
nm[i] = i;
++res;
for (int k = 0; k < a[i].size(); ++k) {
int j = a[i][k];
if (a[i].size() == a[j].size()) {
bool l = 1;
for (int z = 0; z < a[i].size(); ++z) {
if (!q[j][a[i][z]]) {
l = 0;
break;
}
}
for (int z = 0; z < a[j].size(); ++z) {
if (!q[i][a[j][z]]) {
l = 0;
break;
}
}
if (l) {
nm[j] = i;
}
}
}
}
bool f_ans = 1;
int zen[1000] = {0};
for (int i = 1; i <= n; ++i) {
bool l[1000] = {0};
int tmp = 0;
for (int j = 0; j < a[i].size(); ++j) {
if (!l[nm[a[i][j]]] && nm[a[i][j]] != nm[i]) {
++tmp;
l[nm[a[i][j]]] = 1;
}
}
zen[i] = tmp;
if (tmp > 2) {
f_ans = 0;
break;
}
}
if (!f_ans || res > 3) {
cout << "NO" << endl;
} else {
for (int i = 1; i <= n; ++i) {
if (zen[i] <= 1 && bl[nm[i]] == 0) {
dfs(i, cnt + 2);
}
}
if (cnt > 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) {
cout << (char(num[nm[i]] + 'a'));
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a[100005];
long long int n, i, k, Min = INT_MAX, j;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 1; i < n - 1; i++) {
long long int Max = 0;
for (j = 0; j < n; j++) {
if (j + 1 == i) {
k = abs(a[j] - a[j + 2]);
} else if (j == i) {
continue;
} else if (j != n - 1) {
k = abs(a[j] - a[j + 1]);
}
if (k > Max) Max = k;
}
if (Max < Min) Min = Max;
}
cout << Min << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int count = 0;
scanf("%d", &count);
int inp = 0;
int first = 0, second = 0;
for (int i = 0; i < count; i++) {
scanf("%d", &inp);
if (inp % 2)
first++;
else
second++;
}
int answer = 0;
if (first > second) {
answer = second + (first - second) / 3;
} else {
answer = first;
}
printf("%d", answer);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
char a[30], b[30];
int n, m, t;
int l1, l2;
int la, lb;
gets(a);
gets(b);
la = strlen(a);
lb = strlen(b);
for (i = 0; i < la; i++) {
if (a[i] == '|') {
t = i;
break;
}
}
l1 = t;
l2 = la - t - 1;
if (l1 == l2) {
if (lb & 1) {
cout << "Impossible" << endl;
} else {
for (i = 0; i < lb / 2; i++) {
cout << b[i];
}
for (i = 0; i < l1; i++) {
cout << a[i];
}
cout << '|';
for (i = t + 1; i < la; i++) {
cout << a[i];
}
for (i = lb / 2; i < lb; i++) {
cout << b[i];
}
cout << endl;
}
} else {
if (l1 > l2) {
n = l1 - l2;
m = lb - n;
if (m & 1 || m < 0) {
cout << "Impossible" << endl;
} else {
for (i = n + m / 2; i < lb; i++) {
cout << b[i];
}
for (i = 0; i < l1; i++) {
cout << a[i];
}
cout << '|';
for (i = t + 1; i < la; i++) {
cout << a[i];
}
for (i = 0; i < n + m / 2; i++) {
cout << b[i];
}
cout << endl;
}
} else {
n = l2 - l1;
m = lb - n;
if (m & 1 || m < 0) {
cout << "Impossible" << endl;
} else {
for (i = 0; i < n + m / 2; i++) {
cout << b[i];
}
for (i = 0; i < l1; i++) {
cout << a[i];
}
cout << '|';
for (i = t + 1; i < la; i++) {
cout << a[i];
}
for (i = n + m / 2; i < lb; i++) {
cout << b[i];
}
cout << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string str1, str2;
cin >> str1;
int sz = str1.size();
int s = 0, r = 0, p = 0;
for (int i = 0; i < sz; ++i) {
if (str1[i] == 'S')
s++;
else if (str1[i] == 'P')
p++;
else
r++;
}
if (s >= r && s >= p) {
for (int i = 0; i < sz; ++i) str2 += 'R';
} else if (r >= p && r >= s) {
for (int i = 0; i < sz; ++i) str2 += 'P';
} else {
for (int i = 0; i < sz; ++i) str2 += 'S';
}
cout << str2 << "\n";
}
return 0;
}
| 3 |
#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
#define watch(x) cout << (#x) << " = " << x << endl
#define exit(s) return cout<<s,0;
#define sz(s) (int)(s.size())
#define in_out ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl '\n'
#define all(s) s.begin(),s.end()
#define allr(s) s.rbegin(), s.rend()
const int N = 1000;
vector<int>primes;
bool prime[N+1];
ll getprimepow(ll n, ll p)
{
ll pow = 0;
for (ll i = p; i <= n; i *= p)
{
pow += n / i;
}
return pow;
}
void sieve()
{
prime[1] = 1;
prime[0] = 1;
for (int i = 4; i <= N; i += 2)
prime[i] = 1;
for (int i = 3; i * i <= N; i += 2)
{
for (int j = i + i; j <= N; j+=i)
prime[j] = 1;
}
primes.push_back(2);
for (int i = 3; i <= N; i += 2)
{
if (!prime[i])
primes.push_back(i);
}
}
ll getfact(int n)
{
ll cnt = 0 , k = n;
for (int i = 0; ( i < sz(primes))&& primes[i] <= k; i++)
{
while (n % primes[i] == 0)
{
n = n / primes[i];
cnt++;
}
}
if (n > 1) { cnt++; }
return cnt;
}
int fun(vector<ll>a, ll i, ll n)
{
ll sum = 0;
ll pw = 1;
for (int j = 0; j < sz(a); j++)
{
sum = (sum + (a[j]) * (pw)) % n;
pw =( i * pw) % n;
}
return sum ;
}
bool can(ll x , ll n)
{
for (int i = 1; i <= x; i++)
{
if (n % x == 1)
{
n -= n / x ;
n--;
}
else
return 0;
}
if (n % x == 0)return 1;
return 0;
}
vector<int>todecimal(int n)
{
vector<int>v;
while (n)
{
v.push_back(n % 2);
n = n / 2;
}
return v;
}
int binpow(int n)
{
int res = 1, a = 2;
while (n)
{
if (n & 1)
res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
n >>= 1;
}
return res;
}
ll powmod(int n, int m, int mod)
{
ll res = 1;
while (m)
{
if (m & 1)
{
res = (res * n) % mod;
}
n = n * n % mod;
m >>= 1;
}
return res;
}
ll fact(ll n)
{
if (n == 1 || n == 0)
return 1;
return n * (fact(n - 1));
}
int axisx[] = { -1, 0, 0, 1 };
int axisy[] = { 0, -1, 1,0 };
// a[i-1][j] , a[i][j-1], a[i][j+1], a[i+1][j]
int main() {
in_out;
ll t; cin >> t;
while (t--)
{
string s;
cin >> s;
int a = 0;
for (int i = 0; i < sz(s); i++)
{
if (s[i] == 'a')a++;
}
if (a == sz(s))
{
cout << "NO" << endl;
}
else
{
cout << "YES" << endl;
string t = 'a' + s;
string x;
x = t;
reverse(all(x));
if (x != t)cout << t << endl;
else
{
cout << s << "a" << endl;
}
}
}
}
/*
problems that you can get it withen a time
problems that you can get it after this time
problems that you cannot get it after this time or anytime because you cannot know
*/
| 0 |
#include <bits/stdc++.h>
char s[110];
char t[110];
int cnt[26];
int main() {
int i, length_s, length_t, j;
int flag = 1;
memset(cnt, 0, sizeof(cnt));
memset(s, '\0', sizeof(s));
memset(t, '\0', sizeof(t));
fflush(stdin);
scanf("%s%s", s, t);
length_s = strlen(s);
length_t = strlen(t);
for (i = 0; i < length_s; i++) cnt[s[i] - 'a']++;
for (i = 0; i < length_t; i++) cnt[t[i] - 'a']--;
j = 0;
for (i = 0; i < length_s; i++) {
if (j < length_t && s[i] == t[j]) j++;
}
if (j == length_t) {
printf("automaton");
exit(0);
}
for (i = 0; i < 26; i++)
if (cnt[i] != 0) {
flag = 0;
break;
}
if (flag) {
printf("array");
exit(0);
}
flag = 1;
for (i = 0; i < 26; i++)
if (cnt[i] < 0) {
flag = 0;
break;
}
if (flag)
printf("both");
else
printf("need tree");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int n, k, x, y;
int main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cin >> x >> y;
a[x]++;
a[y]++;
}
int center;
for (int i = 1; i <= n; i++)
if (a[i] == 0) {
center = i;
break;
}
cout << n - 1 << '\n';
for (int i = 1; i <= n; i++)
if (i != center) cout << i << " " << center << '\n';
}
| 2 |
#include <bits/stdc++.h>
const long long mod = 998244353;
const long long ds = 1e18;
const double eps = 1e-8;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0', c = getchar();
return f * x;
}
void print(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x / 10) print(x / 10);
putchar(x % 10 + '0');
}
using namespace std;
const int N = 1e6 + 5;
pair<long long, long long> maxi[100005];
void solve() {
int n = read();
for (int i = 0; i < n; ++i) maxi[i].first = 0;
for (int i = 0; i < n; ++i) {
long long k = read();
maxi[i].second = k;
vector<long long> tmp(k);
for (int j = 0; j < k; ++j) {
tmp[j] = read() - j;
maxi[i].first = max(maxi[i].first, tmp[j]);
}
}
sort(maxi, maxi + n);
long long now = 0, tmp = 0;
for (int i = 0; i < n; ++i) {
if (now + tmp <= maxi[i].first) now = maxi[i].first + 1 - tmp;
tmp += maxi[i].second;
}
cout << now << endl;
}
int main() {
int _;
cin >> _;
while (_--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<string> > v;
stack<int> sx;
stack<int> sy;
stack<int> sz;
int k, n, m;
void input() {
cin >> k >> n >> m;
vector<string> dum;
for (int y = 0; y < n + 2; y++) {
string s = "";
for (int x = 0; x < m + 2; x++) {
s = s + '#';
}
dum.push_back(s);
}
v.push_back(dum);
for (int z = 1; z < k + 1; z++) {
vector<string> ss;
string tm = "";
for (int x = 0; x < m + 2; x++) {
tm = tm + '#';
}
ss.push_back(tm);
for (int y = 1; y < n + 1; y++) {
string s;
cin >> s;
s = '#' + s + '#';
ss.push_back(s);
}
ss.push_back(tm);
v.push_back(ss);
}
v.push_back(dum);
}
int trv(int x, int y, int z) {
map<int, int> color;
sx.push(x);
sy.push(y);
sz.push(z);
int hash = (x) + (y)*100 + z * 100000;
color[hash] = 1;
int count = 0;
while (!sx.empty()) {
int x = sx.top();
sx.pop();
int y = sy.top();
sy.pop();
int z = sz.top();
sz.pop();
if (v[z][x][y] == '.') {
count++;
hash = 0;
hash = (x + 1) + (y)*100 + z * 100000;
if (color[hash] == 0) {
sx.push(x + 1);
sy.push(y);
sz.push(z);
color[hash] = 1;
}
hash = (x - 1) + (y)*100 + z * 100000;
if (color[hash] == 0) {
sx.push(x - 1);
sy.push(y);
sz.push(z);
color[hash] = 1;
}
hash = (x) + (y - 1) * 100 + z * 100000;
if (color[hash] == 0) {
sx.push(x);
sy.push(y - 1);
sz.push(z);
color[hash] = 1;
}
hash = (x) + (y + 1) * 100 + z * 100000;
if (color[hash] == 0) {
sx.push(x);
sy.push(y + 1);
sz.push(z);
color[hash] = 1;
}
hash = (x) + (y)*100 + (z - 1) * 100000;
if (color[hash] == 0) {
sx.push(x);
sy.push(y);
sz.push(z - 1);
color[hash] = 1;
}
hash = (x) + (y)*100 + (z + 1) * 100000;
if (color[hash] == 0) {
sx.push(x);
sy.push(y);
sz.push(z + 1);
color[hash] = 1;
}
}
}
return count;
}
int main() {
input();
int x, y;
cin >> x >> y;
cout << trv(x, y, 1) << endl;
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 1000005;
int n, m, k, ub;
int a[N];
long long s = 0;
int nows = 0;
int ans[N];
vector<int> opt[N];
struct Node {
int id, v;
Node() {}
Node(int _id, int _v) { id = _id, v = _v; }
friend bool operator<(Node a, Node b) { return a.v < b.v; }
};
priority_queue<Node> Q;
Node bak[N];
int check(int x) {
int cnt = 0, tot = 0;
for (int i = 1; i <= ub; i++)
if ((tot += bak[i].v / x) >= k || bak[i].v < x) break;
return tot >= k;
}
int get() {
int cnt = 0;
for (int i = 1; i <= ub; i++) bak[++cnt] = Q.top(), Q.pop();
int L = 1, R = n - nows, ans = 0;
while (L <= R) {
int mid = (L + R) >> 1;
if (check(mid))
L = mid + 1, ans = mid;
else
R = mid - 1;
}
while (cnt) Q.push(bak[cnt--]);
return ans;
}
vector<Node> vec;
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) a[i] = read(), s += a[i];
k = (s + n - 1) / n;
ub = min(k, m);
a[1] += k * n - s;
for (int i = 1; i <= m; i++) Q.push(Node(i, a[i]));
for (int i = 1; i <= m; i++) opt[i].clear();
for (int i = 1; i <= m; i++) {
int now = get();
ans[i] = now;
nows += ans[i];
vec.clear();
for (int j = 1; j <= ub; j++) {
Node v = Q.top();
Q.pop();
while (v.v >= now && (int)opt[i].size() < k) {
v.v -= now;
a[v.id] -= now;
opt[i].push_back(v.id);
}
vec.push_back(v);
if ((int)opt[i].size() == k) break;
}
while ((int)opt[i].size() < k) opt[i].push_back(1);
while (!vec.empty()) Q.push(vec.back()), vec.pop_back();
}
printf("%d\n", k);
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
puts("");
for (int i = 0; i <= k - 1; i++) {
for (int j = 1; j <= m; j++) printf("%d ", opt[j][i]);
puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int ans1[100010], ans2[100010];
struct node {
int s;
int id;
} num[100010];
bool cmp(node a, node b) { return a.s < b.s; }
int main() {
long long n;
while (cin >> n) {
int ans = 0;
long long sum = 0;
for (long long i = 1;; i++) {
sum = i * (3 * i + 1) / 2;
if (sum > n)
break;
else {
if ((n - sum) % 3 == 0) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3030, LG = 12;
pair<int, int> a[N];
int b[N];
int d[N];
int n;
int ans[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
for (int i = 1; i < n; ++i) {
b[i] = a[i].first;
}
b[n] = d[n] = a[n].first;
for (int i = 1; i < n; ++i) {
d[i] = b[i] - b[i + 1];
}
tuple<int, int, int, int, int, int> best(-1, -1, -1, -1, -1, -1);
for (int i = 1; i < n; ++i) {
int diff1 = d[i];
if (get<0>(best) > diff1) continue;
for (int j = i + 1; j < n; ++j) {
if (j - i > 2 * i) continue;
if ((j - i) * 2 < i) continue;
int diff2 = d[j];
int mx = max(i, j - i);
int mn = min(i, j - i);
int lb = (mx + 1) / 2 + j;
int rb = min(mn * 2 + j + 1, n + 1);
if (lb > n) continue;
pair<int, int> bb(-1, -1);
for (int k = lb; k < rb; ++k) {
bb = max(bb, {d[k], k});
}
best = max(best, {diff1, diff2, bb.first, i, j, bb.second});
}
}
for (int i = 1; i <= get<3>(best); ++i) {
ans[a[i].second] = 1;
}
for (int i = get<3>(best) + 1; i <= get<4>(best); ++i) {
ans[a[i].second] = 2;
}
for (int i = get<4>(best) + 1; i <= get<5>(best); ++i) {
ans[a[i].second] = 3;
}
for (int i = get<5>(best) + 1; i <= n; ++i) {
ans[a[i].second] = -1;
}
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long MAX_N = 2e5 + 100;
const long long MOD = 1e9 + 7;
using namespace std;
int a[MAX_N];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
set<int> st;
st.insert(0);
for (int i = 1; i <= n; ++i) {
if (st.count(a[i])) continue;
set<int> newst;
for (auto x : st) newst.insert(a[i] ^ x);
for (auto x : newst) st.insert(x);
}
int mx = 0;
for (auto x : st) {
if (!x) continue;
if (x == mx + 1)
mx++;
else
break;
}
int x = (int)floor(log2(mx + 1));
vector<int> vec;
vec.push_back(0);
st.clear();
for (int i = 1; i <= n; ++i) {
if (a[i] < (1 << x)) st.insert(a[i]);
}
set<int> tst;
tst.insert(0);
for (int i = 1; i <= x; ++i) {
while (st.size()) {
int u = *st.begin();
st.erase(u);
if (tst.count(u)) continue;
for (int j = (1 << (i - 1)) - 1; j >= 0; --j)
vec.push_back(vec[j] ^ u), tst.insert(vec[j] ^ u);
break;
}
}
cout << (log2(vec.size())) << "\n";
for (auto x : vec) printf("%d ", x);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
bool flg = false;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flg = true;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return flg ? -x : x;
}
int n, m, h[200010], g[200010];
vector<int> e[200010];
int d[200010];
int p[200010], hd, tl;
int sg[200010];
int get(int o) {
static int vis[200010];
for (const int &v : e[o]) vis[sg[v]] = o;
int z = 0;
while (vis[z] == o) ++z;
return z;
}
void work(int o) {
h[o] ^= g[sg[o]];
g[sg[o]] = 0;
for (const int &v : e[o]) {
if (sg[v] >= sg[o]) continue;
int w = g[sg[v]];
h[v] ^= w;
g[sg[v]] ^= w;
}
for (int i(1), _i(n); i <= _i; i++) printf("%d ", h[i]);
puts("");
}
void solve() {
n = read(), m = read();
for (int i(1), _i(n); i <= _i; i++) h[i] = read();
while (m--) {
int u = read(), v = read();
e[u].push_back(v), ++d[v];
}
for (int i(1), _i(n); i <= _i; i++)
if (!d[i]) p[++tl] = i;
while (hd < tl) {
int u = p[++hd];
for (const int &v : e[u])
if (!--d[v]) p[++tl] = v;
}
for (int i(n), _i(1); i >= _i; i--)
sg[p[i]] = get(p[i]), g[sg[p[i]]] ^= h[p[i]];
int q = -1;
for (int i(n), _i(0); i >= _i; i--)
if (g[i]) {
q = i;
break;
}
if (!~q) return puts("LOSE"), void();
puts("WIN");
for (int i(1), _i(n); i <= _i; i++)
if (sg[i] == q && (g[sg[i]] ^ h[i]) < h[i]) {
work(i);
return;
}
assert(0);
}
int main() {
for (int T = 1; T--;) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool prost(int f) {
if (f == 1) return false;
for (int i = 2; i * i <= f; i++)
if (f % i == 0) return false;
return true;
}
int main() {
string a;
cin >> a;
int n = a.size();
int t = 1;
for (int i = n; i > n / 2; i--)
if (prost(i)) t++;
int c[1111];
for (int i = 0; i < 1100; i++) c[i] = 0;
for (int i = 0; i < n; i++) {
c[a[i]]++;
}
int q;
for (q = 0; q < 1100; q++) {
if (c[q] >= n - t) break;
}
if (q == 1100) {
printf("NO");
return 0;
}
printf("YES\n");
vector<char> aa;
for (int i = 0; i < n; i++)
if (a[i] != q) aa.push_back(a[i]);
for (int i = 0; i < n; i++) a[i] = q;
if (aa.size()) {
a[0] = *(aa.end() - 1);
aa.pop_back();
}
for (int i = n - 1; i > n / 2 - 1; i--) {
if (prost(i + 1) && aa.size()) {
a[i] = *(aa.end() - 1);
aa.pop_back();
}
}
cout << a;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct seg {
int a[600000];
int n;
int I, l1, r1, v;
int ans;
int cv;
void _upd(int l, int r, int x) {
if (l == r) {
if (!cv)
a[x] = v;
else
a[x] = max(a[x], v);
} else {
int mid = l + r >> 1;
if (I <= mid)
_upd(l, mid, x << 1);
else
_upd(mid + 1, r, x << 1 | 1);
a[x] = max(a[x << 1], a[x << 1 | 1]);
}
}
void _que(int l, int r, int x) {
if (l1 <= l && r <= r1)
ans = max(ans, a[x]);
else {
int mid = l + r >> 1;
if (l1 <= mid) _que(l, mid, x << 1);
if (r1 > mid) _que(mid + 1, r, x << 1 | 1);
}
}
void chg(int i, int x) {
I = i, v = x;
cv = 0;
_upd(1, n, 1);
}
void cov(int i, int x) {
I = i, v = x;
cv = 1;
_upd(1, n, 1);
}
int que(int l, int r) {
l1 = l, r1 = r, ans = 0;
if (l <= r) _que(1, n, 1);
return ans;
}
int lis[15], tot;
void _find(int l, int r, int x) {
if (a[x] == 0) return;
if (l == r)
lis[++tot] = l;
else {
int mid = l + r >> 1;
if (l1 <= mid) _find(l, mid, x << 1);
if (r1 > mid) _find(mid + 1, r, x << 1 | 1);
}
}
int find(int ma) {
l1 = 1, r1 = ma, tot = 0;
_find(1, n, 1);
return tot;
}
int lef;
void _find2(int l, int r, int x) {
if (a[x] == 0 || !lef) return;
if (l == r)
lis[++tot] = l, lef--;
else {
int mid = l + r >> 1;
_find2(l, mid, x << 1);
_find2(mid + 1, r, x << 1 | 1);
}
}
void find2(int c) {
tot = 0, lef = c;
_find2(1, n, 1);
}
} segi, segw;
int w[210000] = {0}, id[210000] = {0};
int seq[15], tot;
int seq2[15], tot2;
int tmpl[15];
int main() {
scanf("%d%d", &n, &m);
segi.n = n;
segw.n = m + 10;
while (m--) {
int ot;
scanf("%d", &ot);
if (ot == 1) {
int i, h;
scanf("%d%d", &i, &h);
h += m;
int num = segw.find(h);
tot = tot2 = 0;
for (int s = 1; s <= num; s++) {
int tmp = id[segw.lis[s]];
if (tmp < i)
seq[++tot] = tmp;
else
seq2[++tot2] = tmp;
}
sort(seq + 1, seq + 1 + tot);
sort(seq2 + 1, seq2 + 1 + tot2);
int ma = 0;
if (!tot2)
ma = segi.que(i, n);
else {
ma = max(ma, segi.que(i, seq2[1] - 1));
ma = max(ma, segi.que(seq2[tot2] + 1, segi.n));
for (int j = 1; j < tot2; j++)
ma = max(ma, segi.que(seq2[j] + 1, seq2[j + 1] - 1));
}
w[i] = h;
id[h] = i;
seq[++tot] = i;
tmpl[tot] = ma + 1;
for (int i = tot - 1; i >= 1; i--) {
ma = 0;
for (int j = i + 1; j <= tot; j++)
if (w[seq[i]] < w[seq[j]]) ma = max(ma, tmpl[j]);
tmpl[i] = ma + 1;
}
for (int i = 1; i <= tot; i++) {
segi.cov(seq[i], tmpl[i]);
segw.cov(w[seq[i]], tmpl[i]);
}
} else if (ot == 2) {
int x;
scanf("%d", &x);
segi.find2(x);
for (int i = 1; i <= x; i++) {
int tmp = segi.lis[i];
segi.chg(tmp, 0);
segw.chg(w[tmp], 0);
}
for (int i = x - 1; i >= 1; i--) {
int tmp = segi.lis[i];
int ma = segw.que(w[tmp] + 1, segw.n);
segw.cov(w[tmp], ma + 1);
segi.cov(tmp, ma + 1);
}
}
printf("%d\n", segi.a[1]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 202020;
int h, m, n, L;
int num[N], id[N], l[N], r[N];
bool vis[N];
map<int, int> pos;
struct Seg {
static const int N = ::N << 2;
int cnt[N];
void upd(int p, int c, int l, int r, int rt) {
cnt[rt] += c;
if (l == r) return;
int mid = l + r >> 1;
if (p <= mid)
upd(p, c, l, mid, rt << 1);
else
upd(p, c, mid + 1, r, rt << 1 | 1);
}
int qry(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R && (l == r || cnt[rt] == r - l + 1)) {
if (cnt[rt] == r - l + 1) return 0;
return l;
}
int mid = l + r >> 1;
if (L <= mid) {
int t = qry(L, R, l, mid, rt << 1);
if (t) return t;
}
if (R > mid) {
int t = qry(L, R, mid + 1, r, rt << 1 | 1);
if (t) return t;
}
return 0;
}
} seg;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
cin >> h >> m >> n;
for (int i = (0); i < (h); ++i)
if (!vis[i]) {
int st = L + 1;
for (int j = i; !vis[j]; (j += m) %= h)
num[j] = ++L, id[L] = j, vis[j] = 1;
for (int j = i; !l[j]; (j += m) %= h) l[j] = st, r[j] = L;
}
long long ans = 0;
for (int i = (0); i < (n); ++i) {
string o;
int c, p;
cin >> o >> c;
if (o[0] == '+') {
cin >> p;
int t = seg.qry(num[p], r[p], 1, h, 1);
if (t)
ans += t - num[p];
else
t = seg.qry(l[p], num[p] - 1, 1, h, 1),
ans += r[p] - num[p] + t - l[p] + 1;
seg.upd(pos[c] = t, 1, 1, h, 1);
} else {
seg.upd(pos[c], -1, 1, h, 1);
pos[c] = 0;
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int cnt = 0;
if ((n == 1 && m == 1) || (n == 0 || m == 0)) {
printf("%d", 0);
return 0;
}
while (n + m >= 3) {
if (n < m) {
n -= 1;
m -= 2;
cnt++;
} else {
n -= 2;
m -= 1;
cnt++;
}
if (n == 0 || m == 0) {
break;
}
}
printf("%d", cnt);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string solve(string& n, int len) {
if (len == 0) return "";
for (int i = 0; i < n.size() - 1 - i; ++i) swap(n[i], n[n.size() - 1 - i]);
vector<int> s(len, 0);
char ret[len + 1];
for (int i = 0; i < (len + 1) / 2; ++i) {
if (n[i] < '0') {
n[i + 1]--;
n[i] += 10;
}
s[i] = n[i] - '0';
n[len - i - 1] -= s[i];
if (n.size() > len - i) {
if (n[len - i - 1] < '0') {
n[len - i]--;
n[len - i - 1] += 10;
}
s[i] += (n[len - i] - '0') * 10;
n[len - i] = '0';
}
s[len - i - 1] = s[i];
if (s[i] >= 19 || s[i] < 0) return "";
if (i != len - i - 1) {
if (s[i] >= 10) n[i + 1] -= s[i] / 10;
n[i] -= s[i] % 10;
ret[len - i - 1] = s[i] / 2 + '0';
ret[i] = (s[i] + 1) / 2 + '0';
} else {
if (s[i] & 1) return "";
ret[i] = s[i] / 2 + '0';
}
}
for (int i = 0; i < n.size(); ++i)
if (n[i] != '0') return "";
if (ret[0] == '0') return "";
ret[len] = 0;
return string(ret);
}
int main() {
char n[100005 + 1];
scanf("%s", n);
string tmp1(n), tmp2(n);
string r1 = solve(tmp1, tmp1.size());
string r2 = solve(tmp2, tmp2.size() - 1);
if (r1 != "")
printf("%s\n", r1.c_str());
else if (r2 != "")
printf("%s\n", r2.c_str());
else
printf("0\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int N = 100;
int n, m, d[N];
const int fN = N + 2;
int fn, s, t;
vector<int> e[fN], to, fw, co;
void adde(int u, int v, int w, int c) {
e[u].push_back(int((to).size())), to.push_back(v), fw.push_back(w),
co.push_back(+c);
e[v].push_back(int((to).size())), to.push_back(u), fw.push_back(0),
co.push_back(-c);
}
int dep[fN], pre[fN];
bool vis[fN];
queue<int> q;
bool spfa() {
for (int u(0); u < (fn); ++u) dep[u] = iinf, pre[u] = -1, vis[u] = false;
q.push(pre[s] = s), dep[s] = 0, vis[s] = true;
while (int((q).size())) {
int u = q.front();
q.pop(), vis[u] = false;
for (int v : e[u])
if (fw[v] && dep[to[v]] > dep[u] + co[v])
dep[to[v]] = dep[u] + co[v], pre[to[v]] = v,
!vis[to[v]] && (q.push(to[v]), vis[to[v]] = true);
}
return dep[t] ^ iinf;
}
pair<int, int> flow() {
pair<int, int> res(0, 0);
while (spfa()) {
int f = iinf;
for (int u = t; u ^ s; u = to[pre[u] ^ 1]) f = min(f, fw[pre[u]]);
for (int u = t; u ^ s; u = to[pre[u] ^ 1])
fw[pre[u]] -= f, fw[pre[u] ^ 1] += f;
res.first += f, res.second += dep[t] * f;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m, fn = (t = (s = n) + 1) + 1;
int sm = 0;
adde(0, n - 1, iinf, 0);
for (int i(0); i < (m); ++i) {
int u, v, w, c;
cin >> u >> v >> c >> w, --u, --v;
if (w <= c)
adde(u, v, w, 1), adde(v, u, c - w, 1);
else
sm += w - c, adde(u, v, c, 1), adde(u, v, w - c, 0);
d[u] += w, d[v] -= w, adde(v, u, iinf, 2);
}
for (int u(0); u < (n); ++u)
if (d[u] > 0)
adde(s, u, d[u], 0);
else
adde(u, t, -d[u], 0);
cout << sm + flow().second << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int i, n_f, seg;
scanf("%i%i", &n_f, &seg);
int arr_seg[seg * 2];
char arr_f[n_f];
for (i = 0; i < 2 * seg; ++i) {
scanf("%i", &arr_seg[i]);
}
for (i = 0; i < n_f; ++i) {
if (i % 2) {
arr_f[i] = '1';
} else {
arr_f[i] = '0';
}
}
for (i = 0; i < n_f; ++i) {
printf("%c", arr_f[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[4], c;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &c), a[c]++;
cout << n - max(max(a[1], a[2]), a[3]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int r1 = s.length();
int fl = 0;
for (int i = 0; i < r1; i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
continue;
} else if (s[i] != 'n') {
if (i == r1 - 1) {
fl = 1;
break;
}
if (s[i + 1] != 'a' && s[i + 1] != 'e' && s[i + 1] != 'i' &&
s[i + 1] != 'o' && s[i + 1] != 'u') {
fl = 1;
break;
}
}
}
if (fl == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 100005, M = 100005, INF = 1e9 + 9;
int mn[N], pos[N], mx;
int n, a[N], f[N], g[N], m, b[M];
int main() {
register int i, j, p;
read(n);
for (i = 1; i <= n; ++i) read(a[i]), mn[i] = INF;
a[++n] = INF - 1;
mn[n] = INF;
read(m);
for (i = 1; i <= m; ++i) read(b[i]);
sort(b + 1, b + m + 1);
for (i = 1; i <= n; ++i) {
if (a[i] != -1) {
p = lower_bound(mn, mn + mx + 1, a[i]) - mn;
if (p > mx) ++mx;
if (a[i] < mn[p]) mn[p] = a[i], pos[p] = i;
f[i] = p, g[i] = pos[p - 1];
continue;
}
for (p = mx + 1, j = m; j; --j) {
while (p && b[j] <= mn[p - 1]) --p;
if (b[j] < mn[p]) mn[p] = b[j], pos[p] = i;
}
f[i] = -1;
if (pos[mx + 1]) ++mx;
}
int now = n, nowlen = f[n], nowv = a[n];
while (nowlen) {
if (a[now] != -1) {
--nowlen, nowv = a[now], now = g[now];
continue;
}
for (i = m; i; --i)
if (b[i] != -1 && b[i] < nowv) {
a[now] = b[i];
b[i] = -1;
break;
}
for (i = now - 1; i; --i)
if (f[i] == nowlen - 1 && a[i] < a[now]) {
g[now] = i;
break;
}
if (!g[now])
for (i = now - 1; i; --i)
if (a[i] == -1) {
g[now] = i;
break;
}
--nowlen, nowv = a[now], now = g[now];
}
for (i = 1; i <= n; ++i)
if (a[i] == -1)
for (j = 1; j <= m; ++j)
if (b[j] != -1) {
a[i] = b[j];
b[j] = -1;
break;
}
for (i = 1; i < n; ++i) write(a[i]), putchar(i < n ? ' ' : '\n');
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int n, k, d;
cin >> n >> k >> d;
vector<vector<long long> > paths(n + 1, vector<long long>(2, 0));
paths[0][1] = 0;
paths[0][0] = 1;
for (long long i = 1; i <= n; i++) {
int kl;
if (i > (d - 1))
kl = d - 1;
else
kl = i;
for (long long j = 1; j <= kl; j++) {
paths[i][0] += paths[i - j][0] % mod;
paths[i][0] = paths[i][0] % mod;
}
}
for (long long i = 1; i <= n; i++) {
int kl;
if (i > k)
kl = k;
else
kl = i;
for (long long j = 1; j <= kl; j++) {
if ((j) < d) {
paths[i][1] += (paths[i - j][1]) % mod;
paths[i][1] = paths[i][1] % mod;
} else {
paths[i][1] += (paths[i - j][1] % mod + paths[i - j][0] % mod) % mod;
paths[i][1] = paths[i][1] % mod;
}
}
}
cout << paths[n][1] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[4000];
int total = 0;
int fix(int k) {
if (k >= (1 << n)) {
return 0;
}
int lc = 2 * k, rc = 2 * k + 1;
int lcp = fix(lc);
int rcp = fix(rc);
int a = arr[lc] + lcp;
int b = arr[rc] + rcp;
total += (max(a, b) - min(a, b));
return max(a, b);
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
int size = (1 << (n + 1)) - 2;
for (int i = 0; i < (size); ++i) {
cin >> arr[i + 2];
}
fix(1);
cout << total;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, l, a;
string str;
while (cin >> n >> k >> str) {
l = str.size();
map<char, long long> Mp;
for (int i = 0; i < l; i++) {
Mp[str[i]]++;
}
map<char, long long>::iterator it;
vector<pair<long long, char> > vec;
for (it = Mp.begin(); it != Mp.end(); it++) {
vec.push_back(pair<long long, char>(it->second, it->first));
}
int sz = vec.size();
sort(vec.begin(), vec.end());
long long sum = 0;
for (int i = sz - 1; i >= 0; i--) {
a = vec[i].first;
if (a <= k) {
sum += (a * a);
k = k - a;
} else {
sum += (k * k);
k = 0;
}
if (k <= 0) break;
}
cout << sum << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAXM = 100007;
double f[MAXM];
int main() {
int m;
double r;
scanf("%d%lf", &m, &r);
double diata = 0;
const double d1 = sqrt(r * r * 2);
const double d2 = sqrt(r * r * 8);
f[1] = 2 * r + d1;
for (int i = 2; i <= m; ++i) {
diata += 2 * r;
f[i] = f[i - 1] + diata + d2;
}
double ans = 0;
for (int i = 1; i <= m; ++i) {
ans += (2 * r + f[i - 1] + f[m - i]) / m;
}
printf("%.10f\n", ans / m);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<pair<long long, long long>, int> a,
pair<pair<long long, long long>, int> b) {
if (a.first.first < b.first.first) return true;
if (a.first.first == b.first.first && a.first.second < b.first.second)
return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL), cout.precision(15);
int N;
cin >> N;
vector<pair<pair<long long, long long>, int> > v(N);
for (int i = 0; i < N; i++) {
cin >> v[i].first.first >> v[i].first.second;
v[i].second = i + 1;
}
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < N - 2; i++) {
long long x1 = v[i].first.first, y1 = v[i].first.second;
long long x2 = v[i + 1].first.first, y2 = v[i + 1].first.second;
long long x3 = v[i + 2].first.first, y3 = v[i + 2].first.second;
if ((y2 - y1) * (x3 - x2) != (x2 - x1) * (y3 - y2)) {
cout << v[i].second << " " << v[i + 1].second << " " << v[i + 2].second
<< "\n";
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 9;
int n, m, x, u[MAX];
string s;
map<string, int> pt;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s >> x, pt[s] = max(pt[s], x);
for (auto& c : pt) u[m++] = c.second;
sort(u, u + m);
cout << n << '\n';
for (auto& c : pt) {
cout << c.first << ' ';
x = u + m - upper_bound(u, u + m, c.second);
if (2 * x > m)
cout << "noob\n";
else if (5 * x > m)
cout << "random\n";
else if (10 * x > m)
cout << "average\n";
else if (100 * x > m)
cout << "hardcore\n";
else
cout << "pro\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long GcdRecursive(long long a, long long b) {
if (b == 0) return a;
return GcdRecursive(b, a % b);
}
const long long mod = 1e9 + 7;
int dirX[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dirY[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const long long MOD = 998244353;
const long long N = 2e5 + 7;
const long long LLinf = 1e18 + 5;
const int INTinf = 1e8 + 7;
long long t, n, m, a, b, k, c = 0, d, x, y;
long long x11, x22, y11, y22;
long long get(long long a) {
long long mn = 9, mx = 0;
while (a > 0) {
long long x = a % 10;
a /= 10;
mn = min(x, mn);
mx = max(x, mx);
}
return mn * mx;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> a >> k;
k--;
while (k--) {
long long ans = get(a);
if (ans == 0) break;
a += ans;
}
cout << a << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
bool used[N];
string s;
bool check(char c, vector<int> &p1, vector<int> &p2) {
int cnt = 0;
char b;
c == 'A' ? b = 'B' : b = 'A';
for (long long i = 0; i < p1.size(); i++) {
int u = p1[i];
if (used[u] || used[u + 1]) continue;
if (s[u + 1] == b) {
cnt++;
used[u + 1] = true;
used[u] = true;
break;
}
}
for (long long i = 0; i < p2.size(); i++) {
int u = p2[i];
if (used[u] || used[u + 1]) continue;
if (s[u + 1] == c) {
cnt++;
used[u + 1] = true;
used[u] = true;
break;
}
}
return cnt == 2;
}
void solve() {
cin >> s;
vector<int> a, b;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == 'A') a.push_back(i);
if (s[i] == 'B') b.push_back(i);
}
if (a.size() < 2 || b.size() < 2) {
cout << "NO" << endl;
return;
}
if (check('A', a, b)) {
cout << "YES" << endl;
return;
}
memset(used, false, sizeof(used));
if (check('B', b, a)) {
cout << "YES" << endl;
return;
}
cout << "NO" << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long _pow(long long a, long long b) {
long long x = 1;
for (long long j = 0; j < b; j++) {
x *= a;
}
return x;
}
bool test(int a, int n, int m) {
if (a <= 0)
return true;
else if (m == 0 && n == 0)
return false;
else {
if (n > 0 && (a > (a / 2) + 10)) return test(a / 2 + 10, n - 1, m);
if (m > 0) return test(a - 10, n, m - 1);
if (n > 0) return false;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int h = 0; h < t; h++) {
int a, n, m;
cin >> a >> n >> m;
cout << (test(a, n, m) ? "YES" : "NO") << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Sn = 1010;
const double eps = 1e-6, RR = 10;
const int mod = (int)1e9 + 7;
struct pt {
double x, y;
void init() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
x = (double)a / b, y = (double)c / d;
double k = ((RR) * (RR)) / (((x) * (x)) + ((y) * (y)));
x *= k, y *= k;
}
} p[Sn];
pt operator+(const pt& a, const pt& b) { return (pt){a.x + b.x, a.y + b.y}; }
pt operator-(const pt& a, const pt& b) { return (pt){a.x - b.x, a.y - b.y}; }
pt operator*(const pt& a, const double& b) { return (pt){a.x * b, a.y * b}; }
pt operator/(const pt& a, const double& b) { return (pt){a.x / b, a.y / b}; }
struct line {
pt p;
double ag;
void set(pt a, pt b) {
if (fabs(a.x - b.x) > eps && a.x > b.x) swap(a, b);
if (fabs(a.x - b.x) <= eps && a.y > b.y) swap(a, b);
p = (a + b) / 2;
ag = atan2(b.y - a.y, b.x - a.x);
}
} L[Sn * Sn];
int tL;
int n, A[Sn * Sn], tA, Ans;
bool cmpL(const line& a, const line& b) {
if (fabs(a.p.x - b.p.x) > eps) return a.p.x < b.p.x;
if (fabs(a.p.y - b.p.y) > eps) return a.p.y < b.p.y;
return a.ag < b.ag;
}
bool same(const pt& a, const pt& b) {
return fabs(a.x - b.x) <= eps && fabs(a.y - b.y) <= eps;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) p[i].init();
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) L[++tL].set(p[i], p[j]);
sort(L + 1, L + tL + 1, cmpL);
for (int l = 1, r; l <= tL; l++) {
for (r = l; r + 1 <= tL && same(L[r + 1].p, L[l].p); r++)
;
tA = 0;
for (int i = l; i <= r; i++)
if (i == l || fabs(L[i].ag - L[i - 1].ag) > eps)
A[++tA] = 1;
else
A[tA]++;
if (tA >= 2) {
int Cur = 1, sA = 0;
for (int i = 1; i <= tA; i++)
Cur = (long long)Cur * (A[i] + 1) % mod, sA += A[i];
Cur = (Cur - sA - 1 + mod) % mod;
Ans = (Ans + Cur) % mod;
}
l = r;
}
printf("%d\n", Ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 50;
pair<int, int> p[nax];
double sqar(double a) { return a * a; }
int main() {
double pi = acos(-1);
int n, x0, y0;
cin >> n >> x0 >> y0;
double br = 0, sr = 1e18;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
p[i] = {x, y};
br = max(br, sqar(x - x0) + sqar(y - y0));
sr = min(sr, sqar(x - x0) + sqar(y - y0));
}
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
double x1 = p[i].first, y1 = p[i].second;
double x2 = p[j].first, y2 = p[j].second;
double l = sqar(x1 - x2) + sqar(y1 - y2);
double t = ((x0 - x1) * (x2 - x1) + (y0 - y1) * (y2 - y1)) / l;
t = max(0.0, min(1.0, t));
double x = x1 + t * (x2 - x1);
double y = y1 + t * (y2 - y1);
double dis = sqar(x0 - x) + sqar(y0 - y);
sr = min(sr, dis);
}
cout << setprecision(12);
cout << pi * br - pi * sr << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct Edge {
int a, b;
int c;
int next;
Edge() {}
Edge(int a, int b, int c, int next) : a(a), b(b), c(c), next(next) {}
};
int p[20000];
Edge e[20000];
int tot;
int h[10000], gap[10000];
int s, t;
int max_inf;
void add1(int a, int b, int c) {
;
;
e[tot] = Edge(a, b, c, p[a]);
p[a] = tot++;
}
void add(int a, int b, int c) {
add1(a, b, c);
add1(b, a, 0);
}
int dfs(int u, int inf) {
if (u == t) return inf;
int d = inf;
int minh = max_inf;
for (int i = p[u]; i != -1; i = e[i].next) {
if (e[i].c) {
if (h[e[i].b] + 1 == h[u]) {
int ret = dfs(e[i].b, min(e[i].c, d));
e[i].c -= ret;
e[i ^ 1].c += ret;
d -= ret;
if (h[s] >= max_inf) return inf - d;
if (!d) break;
}
minh = min(minh, h[e[i].b]);
}
}
if (d == inf) {
if (--gap[h[u]] == 0) h[s] = max_inf;
h[u] = minh + 1;
gap[h[u]]++;
}
return inf - d;
}
int maxflow() {
int n = t + 1;
max_inf = n;
for (int i = 0; i < n; ++i) {
h[i] = 0;
gap[i] = 0;
}
gap[0] = n;
int mflow = 0;
while (h[s] < max_inf) {
int ret = dfs(s, 1 << 30);
mflow += ret;
}
return mflow;
}
int d[10000], ans[10000];
void init() {
memset(p, -1, sizeof(p));
tot = 0;
memset(d, 0, sizeof(d));
memset(ans, 0, sizeof(ans));
s = m + n;
t = m + n + 1;
}
int main() {
int c;
cin >> c;
while (c--) {
cin >> n >> m >> k;
init();
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
add(i, a + m, 1);
add(i, b + m, 1);
add(s, i, 1);
d[a]++;
d[b]++;
}
int max_f = 0;
int ok = 1;
for (int i = 0; i < n; ++i) {
if (d[i] > 2 * k) {
max_f = -1;
ok = 0;
break;
}
if (d[i] > k) {
add(i + m, t, 2 * (d[i] - k));
max_f += 2 * (d[i] - k);
}
}
int ret = 0;
if (ok && max_f) {
ret = maxflow();
;
;
}
if (ret == max_f) {
memset(ans, 0, sizeof(ans));
int ans_id = 1;
map<int, vector<int> > ft;
for (int i = 0; i < tot; i += 2) {
if (e[i].c == 0) {
;
;
int u = e[i].b - m;
ft[u].push_back(e[i].a);
}
}
for (int i = 0; i < n; ++i) {
auto &pt = ft[i];
for (int j = 0; j < pt.size(); j += 2) {
;
;
ans[pt[j]] = ans_id;
ans[pt[j + 1]] = ans_id++;
}
for (int j = p[i + m]; j != -1; j = e[j].next) {
;
;
if (e[j].b == t) continue;
if (ans[e[j].b] == 0) {
;
;
ans[e[j].b] = ans_id++;
}
}
}
}
for (int i = 0; i < m; ++i) {
printf("%d ", ans[i]);
}
printf("\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void Xarr() {
long long n;
cin >> n;
vector<long long> v1(n);
for (long long i = 0; i < n; i++) cin >> v1[i];
vector<long long> v2(n);
for (long long i = 0; i < n; i++) cin >> v2[i];
long long x;
cin >> x;
map<long long, vector<long long>> m;
for (long long i = 0; i < n; i++) {
long long x = v1[i];
long long y = i + 1;
long long z = v2[i];
m[x].push_back(y);
m[z].push_back(y);
}
long long ans = 1;
for (auto i : m) {
long long smallans = 1;
vector<long long> v = i.second;
long long s = v.size();
map<long long, long long> m1;
long long times = 0;
for (long long j = 0; j < v.size(); j++) m1[v[j]]++;
for (long long j = 0; j < v.size(); j++) {
if (m1[v[j]] == 2) {
times++;
m1[v[j]]--;
}
}
for (long long j = 1; j <= s; j++) {
smallans = smallans * j;
while (times > 0 && smallans % 2 == 0) {
smallans /= 2;
times--;
}
smallans %= x;
}
ans = (ans * smallans) % x;
}
cout << ans << "\n";
}
int32_t main() {
cout << fixed << setprecision(16);
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Xarr();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 1e5, inf = 3e18, mod = 1e9 + 7;
long long tc, n, m, q, a, b, c, d, i, j, k;
long long sum[N];
vector<long long> vec;
string s;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> tc;
while (tc--) {
cin >> a >> b >> q;
for (i = 1; i <= 2 * a * b; i++)
sum[i] = sum[i - 1] + (((i % a) % b) != ((i % b) % a));
while (q--) {
long long L, R;
cin >> L >> R;
cout << (R - L + 1) / (a * b) * sum[a * b] + sum[a * b + R % (a * b)] -
sum[a * b + R % (a * b) - (R - L + 1) % (a * b)]
<< ' ';
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
const int modP = 1000000007;
using namespace std;
const int N = 501;
int sTable[N][N];
int main() {
int k, n, row = 0, col = 0;
int64_t result = 0;
int64_t curNum;
cin >> n >> k;
curNum = n * n;
while (row < n) {
for (int i = n - 1; i >= (k - 1); --i) {
sTable[row][i] = curNum--;
}
result += sTable[row][k - 1];
row++;
}
row = 0;
if (k > 1) {
while (row < n) {
for (int i = k - 2; i >= 0; --i) {
sTable[row][i] = curNum--;
}
row++;
}
}
cout << result << endl;
for (int row = 0; row < n; ++row) {
for (int col = 0; col < n; ++col) {
cout << sTable[row][col] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-9;
const long long mod = 1e9 + 7;
set<long double> s;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long double k, b;
cin >> k >> b;
if (k) s.insert(b / k);
}
cout << s.size() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
int x, k;
double p;
double dp[210][210];
int main() {
scanf("%d%d%lf", &x, &k, &p);
p /= 100.0;
for (int i = 0; i <= k; i++) {
for (int j = x + i; j % 2 == 0; j /= 2) {
dp[0][i] += 1.0;
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j <= k; j++) {
dp[i + 1][j] += dp[i][j + 1] * (1.0 - p);
if (!(j & 1)) {
dp[i + 1][j] += (1.0 + dp[i][j >> 1]) * p;
}
}
}
printf("%.10f\n", dp[k][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
putchar(toupper(getchar()));
char s[1000];
gets(s);
puts(s);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vector<int> a(n);
vector<int> ans(n);
int p = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool asc = a[0] < a[1];
int st = 0;
for (int i = 1; i < n - 1; i++) {
if ((asc && a[i] > a[i + 1]) || (!asc && a[i] < a[i + 1])) {
ans[p++] = a[st];
st = i;
asc = !asc;
}
}
ans[p++] = a[st];
ans[p++] = a[n - 1];
cout << p << "\n";
for (int i = 0; i < p; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[1 << 14], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 14, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline int read(T& x) {
x = 0;
bool f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') f ^= 1;
if (c == -1) return -1;
}
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
x = f ? x : -x;
return 1;
}
template <class T>
inline void wr(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) wr(x / 10);
putchar(x % 10 | 48);
}
const int N = 5e5 + 10;
char s1[N], s2[N];
int n, m, net[N], num1, num0;
inline void getnet() {
for (int i = 2, j = 0; i <= m; i++) {
for (; j && s2[j + 1] != s2[i];) j = net[j];
if (s2[j + 1] == s2[i]) {
net[i] = ++j;
} else {
net[i] = 0;
}
}
}
int main() {
scanf("%s%s", s1 + 1, s2 + 1);
n = strlen(s1 + 1);
m = strlen(s2 + 1);
getnet();
for (int i = 1; i <= n; ++i)
if (s1[i] == '1')
++num1;
else
++num0;
for (int i = 1, k = 0; i <= n; ++i) {
if (s2[k + 1] == '0')
--num0;
else
--num1;
if (num0 < 0 || num1 < 0) {
if (s2[k + 1] == '0')
++num0;
else
++num1;
break;
}
putchar(s2[k + 1]);
++k;
if (k == m) k = net[k];
}
for (int i = 1; i <= num0; ++i) putchar('0');
for (int i = 1; i <= num1; ++i) putchar('1');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
char a[6][6];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
if (i == 0 || j == 0 || i == 5 || j == 5) {
a[i][j] = '$';
} else {
cin >> a[i][j];
}
}
}
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 5; j++) {
if (a[i][j] == '#') {
int c1 = 0;
if (a[i][j + 1] == '#') c1++;
if (a[i + 1][j] == '#') c1++;
if (a[i + 1][j + 1] == '#') c1++;
if (c1 >= 2) {
cout << "YES";
return 0;
}
int c2 = 0;
if (a[i][j - 1] == '#') c2++;
if (a[i + 1][j] == '#') c2++;
if (a[i + 1][j - 1] == '#') c2++;
if (c2 >= 2) {
cout << "YES";
return 0;
}
int c3 = 0;
if (a[i][j + 1] == '#') c3++;
if (a[i - 1][j] == '#') c3++;
if (a[i - 1][j + 1] == '#') c3++;
if (c3 >= 2) {
cout << "YES";
return 0;
}
int c4 = 0;
if (a[i][j - 1] == '#') c4++;
if (a[i - 1][j] == '#') c4++;
if (a[i - 1][j - 1] == '#') c4++;
if (c4 >= 2) {
cout << "YES";
return 0;
}
} else {
int c1 = 0;
if (a[i][j + 1] == '.') c1++;
if (a[i + 1][j] == '.') c1++;
if (a[i + 1][j + 1] == '.') c1++;
if (c1 >= 2) {
cout << "YES";
return 0;
}
int c2 = 0;
if (a[i][j - 1] == '.') c2++;
if (a[i + 1][j] == '.') c2++;
if (a[i + 1][j - 1] == '.') c2++;
if (c2 >= 2) {
cout << "YES";
return 0;
}
int c3 = 0;
if (a[i][j + 1] == '.') c3++;
if (a[i - 1][j] == '.') c3++;
if (a[i - 1][j + 1] == '.') c3++;
if (c3 >= 2) {
cout << "YES";
return 0;
}
int c4 = 0;
if (a[i][j - 1] == '.') c4++;
if (a[i - 1][j] == '.') c4++;
if (a[i - 1][j - 1] == '.') c4++;
if (c4 >= 2) {
cout << "YES";
return 0;
}
}
}
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool func(pair<long long int, long long int> p,
pair<long long int, long long int> q) {
if (p.second == q.second) {
return p.first < q.first;
}
return p.second > q.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int t, n, m;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
long long int arr[n], brr[n];
long long int ans = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<pair<long long int, long long int>> v;
for (int i = 0; i < n; i++) {
cin >> brr[i];
if (brr[i] >= arr[i]) {
ans = max(ans, arr[i]);
} else {
v.push_back({brr[i], arr[i]});
}
}
sort(v.begin(), v.end(), func);
long long int x = 0;
for (int i = 0; i < v.size(); i++) {
long long int b = v[i].first;
long long int a = v[i].second;
if (i == 0) {
x = b;
ans = max(ans, b);
} else {
if (x + b <= a) {
x += b;
ans = max(ans, x);
} else {
ans = max(ans, a);
}
}
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int pct(int x) { return __builtin_popcount(x); }
int bit(int x) { return 31 - __builtin_clz(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
const int maxn = 1e5 * 3 + 20;
int n, _, q, k;
void solve() {
cin >> _;
while (_--) {
cin >> n;
string t;
cin >> t;
set<int> bag[2];
vector<int> ans(n);
int cnt = 0;
for (signed i = 0; i < n; i++) {
int x = t[i] - '0';
if (bag[x ^ 1].empty()) {
bag[x].insert(++cnt);
ans[i] = cnt;
} else {
ans[i] = *bag[x ^ 1].begin();
bag[x ^ 1].erase(ans[i]);
bag[x].insert(ans[i]);
}
}
cout << cnt << endl;
for (signed i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return f * x;
}
int n, a[300032], b[300032], Size, head[300032 * 8], num, root, dis[300032 * 8],
re[300032 * 8];
bool vis[300032 * 8];
struct edge {
int next, to, vlu;
} mem[300032 * 20];
void add(int u, int v, int vlu) {
mem[++Size].to = v;
mem[Size].next = head[u];
head[u] = Size;
mem[Size].vlu = vlu;
}
struct TREE {
int son[2];
} tr[300032 * 8];
void build(int& rt, int l, int r) {
if (l == r) {
rt = l + n + 1;
return;
}
rt = ++num;
int mid = l + r >> 1;
build(tr[rt].son[0], l, mid);
build(tr[rt].son[1], mid + 1, r);
add(rt, tr[rt].son[0], 0);
add(rt, tr[rt].son[1], 0);
}
void update(int rt, int l, int r, int first, int end) {
if (first <= l && r <= end) {
add(end, rt, 1);
return;
}
int mid = l + r >> 1;
if (first <= mid) update(tr[rt].son[0], l, mid, first, end);
if (end > mid) update(tr[rt].son[1], mid + 1, r, first, end);
}
struct node {
int x, dis;
bool operator<(node A) const { return dis > A.dis; }
};
priority_queue<node> q;
void dij() {
for (int i = 1; i <= num; ++i) dis[i] = 1e9;
dis[n] = 0;
q.push(node{n, 0});
while (!q.empty()) {
node now = q.top();
q.pop();
if (vis[now.x]) continue;
vis[now.x] = 1;
for (int i = head[now.x]; i; i = mem[i].next) {
int v = mem[i].to;
if (dis[v] > dis[now.x] + mem[i].vlu) {
dis[v] = dis[now.x] + mem[i].vlu;
re[v] = now.x;
q.push(node{v, dis[v]});
}
}
}
}
vector<int> as;
int main() {
n = read();
num = n * 2 + 1;
build(root, 0, n);
for (int i = 1; i <= n; ++i) {
a[i] = read();
update(root, 0, n, i - a[i], i);
}
for (int i = 1; i <= n; ++i) b[i] = read(), add(i + n + 1, i + b[i], 0);
dij();
if (dis[n + 1] == 1e9)
cout << -1;
else {
cout << dis[n + 1] << '\n';
int tmp = n + 1;
while (tmp != n) {
if (tmp >= n + 1 && tmp <= 2 * n + 1) as.push_back(tmp - n - 1);
tmp = re[tmp];
}
for (int i = as.size() - 1; i >= 0; --i) cout << as[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
long long mod = 1000000007;
long long mod_v(long long nn) { return nn % mod; }
template <class T>
T fast_pow(T n, T p) {
if (p == 0) return 1;
if (p % 2) {
T g = mod_v(mod_v(n) * mod_v(fast_pow(n, p - 1)));
return g;
} else {
T g = fast_pow(n, p / 2);
g = mod_v(mod_v(g) * mod_v(g));
return g;
}
}
template <class T>
inline T modInverse(T n) {
return fast_pow(n, mod - 2);
}
const int mxn = 111111;
int n, first, k, pre[] = {0, 1, 0, 1, 2};
int grundy(int p) {
if (k % 2) {
if (p < 5) return pre[p];
if (p % 2) return 0;
return (grundy(p / 2) == 1) ? 2 : 1;
}
if (p == 1) return 1;
if (p == 2) return 2;
return (p % 2) ^ 1;
}
int main() {
scanf("%d %d", &n, &k);
int ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &first);
ans ^= grundy(first);
}
if (ans)
printf("Kevin");
else
printf("Nicky");
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > a, s;
vector<vector<long long int> > d;
long long int mx;
vector<int> a0;
vector<long long int> d0;
int main() {
scanf("%d%d", &n, &m);
a0.resize(m);
d0.resize(m);
a.assign(n, a0);
d.assign(n, d0);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
s = a;
for (int i = 0; i < n; i++)
for (int j = 1; j < m; j++) s[i][j] += s[i][j - 1];
for (int j = 0; j < m; j++) d[0][j] = s[0][j];
for (int i = 1; i < n; i++) {
if (i % 2 == 0) {
mx = d[i - 1][0];
for (int j = 1; j < m; j++) {
d[i][j] = s[i][j] + mx;
mx = max(mx, d[i - 1][j]);
}
} else {
mx = d[i - 1][m - 1];
for (int j = m - 2; j >= 0; j--) {
d[i][j] = s[i][j] + mx;
mx = max(mx, d[i - 1][j]);
}
}
}
if (n % 2 == 0)
cout << *max_element(d[n - 1].begin(), --d[n - 1].end());
else
cout << *max_element(++d[n - 1].begin(), d[n - 1].end());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5002;
int n, a[N], k, b[1000002], dd[1000001];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i(1); i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i(1); i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int x = a[j] - a[i];
b[x]++;
}
for (int i = n - k;; i++) {
int cur = 0;
for (int j = i; j <= 1000000; j += i) {
cur = cur + b[j];
}
if (cur * 2 > (k) * (k + 1)) continue;
int res = 0;
for (int j(1); j <= n; j++) {
if (dd[a[j] % i] != i)
dd[a[j] % i] = i;
else
res++;
}
if (res <= k) {
cout << i;
break;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
i = 1;
while (n > 0) {
if (n > i * 5) {
n = n - i * 5;
} else {
if (n - i > 0) {
n = n - i;
if (n - i > 0) {
n = n - i;
if (n - i > 0) {
n = n - i;
if (n - i > 0) {
n = n - i;
n = n - i;
cout << "Howard";
} else {
n = n - i;
cout << "Rajesh";
}
} else {
n = n - i;
cout << "Penny";
}
} else {
n = n - i;
cout << "Leonard";
}
} else {
n = n - i;
cout << "Sheldon";
}
}
i = i * 2;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
unsigned long long int n = s.size();
unsigned long long int a[n], b[n];
for (int i = 0; i < n; i++) {
a[i] = 0;
b[i] = 0;
}
for (int i = 1; i < n; i++) {
if (s[i] == 'v' && s[i - 1] == 'v') {
a[i]++;
b[i] = 0;
}
if (s[i] == 'o') b[i] = 1;
a[i] = a[i] + a[i - 1];
}
unsigned long long int p = 0;
for (int i = 0; i < n; i++) {
if (b[i] == 1) {
p += a[i] * (a[n - 1] - a[i]);
}
}
cout << p;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c_1, c_2, c_3, c_4;
int n_1, n_2;
cin >> c_1 >> c_2 >> c_3 >> c_4 >> n_1 >> n_2;
int a[n_1], b[n_2];
int sum_a = 0;
int sum_b = 0;
for (int i = 0; i < n_1; i++) {
cin >> a[i];
a[i] = min(a[i] * c_1, c_2);
sum_a += a[i];
}
for (int i = 0; i < n_2; i++) {
cin >> b[i];
b[i] = min(b[i] * c_1, c_2);
sum_b += b[i];
}
sum_a = min(sum_a, c_3);
sum_b = min(sum_b, c_3);
int ans = 0;
ans = min((sum_a + sum_b), c_4);
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int mod = 1e9 + 7;
const int MAX = 1e7 + 7;
long long p[MAX];
bool vis[MAX];
vector<long long> d1, d2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
for (int i = 2; i <= MAX; i++) {
if (!vis[i]) {
for (int j = i; j <= MAX; j += i) {
p[j] = i;
vis[j] = 1;
}
}
}
int n;
cin >> n;
while (n--) {
long long a;
cin >> a;
long long c = a, p1 = p[a];
while (c % p1 == 0) c /= p1;
if (c == 1)
d1.push_back(-1), d2.push_back(-1);
else
d1.push_back(c), d2.push_back(a / c);
}
for (int i = 0; i < d1.size(); i++) cout << d1[i] << " ";
cout << '\n';
for (int i = 0; i < d2.size(); i++) cout << d2[i] << " ";
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t, m;
int vis[111];
int cnt;
bool exist[111];
void init() {
memset(vis, 0, sizeof(vis));
memset(exist, 0, sizeof(exist));
cnt = 0;
}
int alloc(int x) {
int i;
int res = 0;
for (i = 0; i < m; i++) {
if (vis[i] == 0) {
res = 0;
while (vis[i] == 0 && i < m) {
res++;
i++;
if (res == x) break;
}
}
if (res == x) {
break;
}
}
if (res == x) {
cnt++;
for (int j = i - res; j < i; j++) vis[j] = cnt;
exist[cnt] = 1;
return cnt;
} else
return -1;
}
int erases(int x) {
if (exist[x] == 0)
return -1;
else {
for (int i = 0; i < m; i++)
if (vis[i] == x) vis[i] = 0;
exist[x] = 0;
return 1;
}
}
void defragment() {
int xx[111];
int res = 0;
for (int i = 0; i < m; i++) {
if (vis[i]) {
xx[res++] = vis[i];
}
}
for (int i = 0; i < res; i++) vis[i] = xx[i];
for (int i = res; i < m; i++) vis[i] = 0;
}
int main() {
scanf("%d %d", &t, &m);
char op[22];
int a;
init();
for (int i = 0; i < t; i++) {
scanf("%s", op);
if (op[0] == 'd') {
defragment();
} else {
scanf("%d", &a);
if (op[0] == 'a') {
if (a < 0) {
printf("NULL\n");
continue;
}
int xx = alloc(a);
if (xx == -1)
printf("NULL\n");
else
printf("%d\n", xx);
} else if (op[0] == 'e') {
if (a < 0 || a > t) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
int xx = erases(a);
if (xx == -1) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> v;
v.push_back(a[0]);
for (int i = 1; i < n - 1; i++) {
if (a[i] > a[i - 1] && a[i] > a[i + 1]) v.push_back(a[i]);
if (a[i] < a[i - 1] && a[i] < a[i + 1]) v.push_back(a[i]);
}
v.push_back(a[n - 1]);
cout << v.size() << "\n";
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, set<T> second) {
os << "{ ";
for (auto s : second) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << " : " << m.second << ") ";
return os << "}";
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " |";
__f(comma + 1, args...);
}
void solve() {
int n, m;
cin >> n >> m;
int sx, sy, ex, ey;
cin >> sx >> sy >> ex >> ey;
vector<pair<pair<int, int>, int>> stat(m + 1);
stat[0].first = {sx, sy};
for (int i = 1; i <= m; ++i) {
cin >> stat[i].first.first >> stat[i].first.second;
stat[i].second = i;
}
vector<int> adj[m + 1];
sort(stat.begin(), stat.end(),
[&](const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.first < p2.first.first;
});
for (int i = 0; i <= m; ++i) {
if (i - 1 >= 0) adj[stat[i].second].push_back(stat[i - 1].second);
if (i + 1 <= m) adj[stat[i].second].push_back(stat[i + 1].second);
}
sort(stat.begin(), stat.end(),
[&](const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.first.second < p2.first.second;
});
for (int i = 0; i <= m; ++i) {
if (i - 1 >= 0) adj[stat[i].second].push_back(stat[i - 1].second);
if (i + 1 <= m) adj[stat[i].second].push_back(stat[i + 1].second);
}
sort(stat.begin(), stat.end(),
[&](const pair<pair<int, int>, int> &p1,
const pair<pair<int, int>, int> &p2) {
return p1.second < p2.second;
});
vector<int> rel(m + 1), toReach(m + 1, INT_MAX);
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
PQ;
PQ.push({0, 0});
while (PQ.size()) {
pair<int, int> node = PQ.top();
PQ.pop();
if (rel[node.second]) continue;
rel[node.second] = true;
toReach[node.second] = node.first;
for (int ch : adj[node.second]) {
int xc = abs(stat[node.second].first.first - stat[ch].first.first);
int yc = abs(stat[node.second].first.second - stat[ch].first.second);
if (toReach[node.second] + min(xc, yc) < toReach[ch]) {
toReach[ch] = toReach[node.second] + min(xc, yc);
PQ.push({toReach[ch], ch});
}
}
}
int ans = INT_MAX;
for (int i = 0; i <= m; ++i) {
int xc = abs(stat[i].first.first - ex);
int yc = abs(stat[i].first.second - ey);
ans = min(ans, (toReach[i] + xc + yc));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1, tc = 1;
while (T--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b, p;
cin >> a >> b;
vector<int> ans;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == b[i]) continue;
if (a[0] == b[i]) {
ans.push_back(0);
if (a[0] == '1')
a[0] = '0';
else
a[0] = '1';
}
ans.push_back(i);
p = a;
a = "";
for (int j = 0; j <= i; j++) {
if (p[j] == '0') {
a = '1' + a;
} else {
a = '0' + a;
}
}
}
int m = ans.size();
cout << m << " ";
for (int i = 0; i < m; i++) {
cout << ans[i] + 1 << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 105;
int Perm[MaxN];
long long n, Length;
long long Ans = 1;
bool used[MaxN];
void TransposLength(int pos) {
if (used[pos]) {
return;
}
used[pos] = true;
++Length;
TransposLength(Perm[pos]);
}
inline long long GCD(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
void CalcNr(long long &Ans, long long x) { Ans = Ans * x / GCD(Ans, x); }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
if (used[x]) {
cout << -1;
return 0;
}
used[x] = true;
Perm[i] = x;
}
memset(used, 0, sizeof used);
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
Length = 0;
TransposLength(i);
if (Length % 2 == 0) {
Length /= 2;
}
CalcNr(Ans, Length);
used[i] = true;
}
}
cout << Ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n], sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (n == 1) {
cout << sum << "\n";
return 0;
}
long long int ans = sum;
sort(a, a + n);
for (int i = 0; i < n - 2; i++) {
ans += sum;
sum = sum - a[i];
}
ans += sum;
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long int max(long int a, long int b) { return a > b ? a : b; }
long int min(long int a, long int b) { return a > b ? b : a; }
const int N = 5050;
int a[N], sol[N];
int pos(int x) { return x > 0 ? x : -x; }
map<int, int> id;
bool was[N];
int cnt;
int main() {
int n, i, j;
scanf("%i", &n);
for (i = 1; i <= n; i++) {
scanf("%i", &a[i]);
for (j = 2; j * j <= pos(a[i]); j++) {
while (a[i] % (j * j) == 0) a[i] /= j * j;
}
if (!a[i]) continue;
if (!id[a[i]]) id[a[i]] = ++cnt;
a[i] = id[a[i]];
}
for (i = 1; i <= n; i++) {
for (j = 0; j <= n; j++) was[j] = 0;
int ans = 0, zero = 0;
for (j = i; j <= n; j++) {
if (!was[a[j]]) ans++;
if (!a[j]) zero = 1;
was[a[j]] = 1;
sol[max(ans - zero, 1)]++;
}
}
for (i = 1; i <= n; i++) printf("%i ", sol[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<complex<double> > ans;
bool in(const double &c, const double &a, const double &b) {
return (min(a, b) - 1e-9 <= c && c <= max(a, b) + 1e-9);
}
bool on(const complex<double> &p, const complex<double> &a,
const complex<double> &b) {
return (in(p.real(), a.real(), b.real()) && in(p.imag(), a.imag(), b.imag()));
}
void intersect(const complex<double> &a, const complex<double> &b,
const complex<double> &c, const complex<double> &d) {
double A1 = (a - b).imag(), B1 = (b - a).real(), C1 = (conj(a) * b).imag();
double A2 = (c - d).imag(), B2 = (d - c).real(), C2 = (conj(c) * d).imag();
if (abs(A1 * B2 - B1 * A2) <= 1e-9) return;
double D = A1 * B2 - A2 * B1;
double Dx = C2 * B1 - C1 * B2;
double Dy = A2 * C1 - A1 * C2;
complex<double> p(Dx / D, Dy / D);
if (on(p, a, b) && on(p, c, d)) ans.push_back(p);
}
double cross(const complex<double> &a, const complex<double> &b) {
return (conj(a) * b).imag();
}
bool cw(const complex<double> &a, const complex<double> &b,
const complex<double> &c) {
return cross(b - a, c - a) < 0.0;
}
bool ccw(const complex<double> &a, const complex<double> &b,
const complex<double> &c) {
return cross(b - a, c - a) > 0.0;
}
double area(const vector<complex<double> > &v) {
double res = 0.0;
for (int i = 0; i < v.size(); i++) res += cross(v[i], v[(i + 1) % v.size()]);
return abs(res) / 2.0;
}
void solve() {
double w, h, a;
scanf("%lf %lf %lf", &w, &h, &a);
a = a / 180.0 * acos(-1);
complex<double> rect1[4], rect2[4];
rect1[0] = {w / 2.0, h / 2.0};
rect1[1] = {w / 2.0, -h / 2.0};
rect1[2] = {-w / 2.0, -h / 2.0};
rect1[3] = {-w / 2.0, h / 2.0};
for (int i = 0; i < 4; i++)
rect2[i] = rect1[i] * exp(complex<double>(0.0, a));
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
intersect(rect1[i], rect1[(i + 1) % 4], rect2[j], rect2[(j + 1) % 4]);
sort(ans.begin(), ans.end(),
[](const complex<double> &p1, const complex<double> &p2) {
if (p1.real() == p2.real()) return p1.imag() < p2.imag();
return p1.real() < p2.real();
});
vector<complex<double> > up, dw;
up.push_back(ans[0]);
dw.push_back(ans[0]);
for (int i = 1; i < ans.size(); i++) {
if (i == ans.size() - 1 || cw(ans[0], ans[i], ans.back())) {
while (up.size() >= 2 && !cw(up[up.size() - 2], up.back(), ans[i]))
up.pop_back();
up.push_back(ans[i]);
}
if (i == ans.size() - 1 || ccw(ans[0], ans[i], ans.back())) {
while (dw.size() >= 2 && !ccw(dw[dw.size() - 2], dw.back(), ans[i]))
dw.pop_back();
dw.push_back(ans[i]);
}
}
vector<complex<double> > yopta = up;
for (int i = dw.size() - 2; i > 0; i--) yopta.push_back(dw[i]);
printf("%.9f", area(yopta));
}
int main() {
if (1) {
} else {
freopen("input.txt", "r", stdin);
}
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 1001000;
int N;
int fav[MAXN];
int par[MAXN];
int dp[MAXN];
int main() {
scanf("%d", &N);
int ans = 0;
for (int i = 2; i <= N + 1; ++i) {
int x;
scanf("%d", &x);
par[i] = x;
;
x = i;
dp[x] = 1;
while (par[x] != 1) {
int up = par[x];
int orig = dp[up];
if (fav[up] == x) {
if (dp[x] > dp[up]) {
dp[up] = dp[x];
}
} else {
if (dp[x] > dp[fav[up]]) {
fav[up] = x;
dp[up] = dp[x];
} else {
if (dp[x] + 1 > dp[up]) {
dp[up] = dp[x] + 1;
}
}
}
if (orig == dp[up]) break;
x = up;
}
if (dp[x] > ans) ans = dp[x];
printf("%d ", ans);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x, m, mi = 1000, a[1001], f[1001 * 1001];
vector<int> ans;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &x), a[x] = 1, m = max(m, x), mi = min(mi, x);
for (int i = 1; i < 1001 * 1001; i++) f[i] = k + 1;
for (int i = 1; i <= m; i++)
if (a[i])
for (int j = i - mi; j <= m * k; j++) f[j] = min(f[j], f[j - i + mi] + 1);
for (int i = 0; i <= m * k; i++)
if (f[i] <= k) ans.push_back(i + mi * k);
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
return 0;
}
| 8 |
#include<bits/stdc++.h>
#define ll long long
#define pll pair<ll,ll>
#define pii pair<int,int>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define per(i,a,b) for(int i=a;i>=b;--i)
#define mem0(x) memset(x,0,sizeof(x))
#define meminf(x) memset(x,0x3f,sizeof(x))
#define VI vector<int>
#define VL vector<ll>
#define pb push_back
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define endl '\n'
#define pb push_back
#define fi first
#define se second
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
//#define DEBUG
using namespace std;
const int N = 150+5, inf = 0x3f3f3f3f;
int n,k;
ll a[N],b[N],tmm[N];
void solve(){
cin>>n;
rep(i,1,n){
cin>>a[i]>>b[i];
}
rep(i,1,n){
cin>>tmm[i];
}
ll tim = 0;
rep(i,1,n){
tim += a[i]-b[i-1]+tmm[i];
if(n == i) break;
ll lim = max(b[i]-tim, (b[i]-a[i]+1)/2);
tim += lim;
}
cout << tim <<endl;
}
int main(){
ios::sync_with_stdio(0);
int tt;cin>>tt;
while(tt--){
solve();
}
} | 0 |
#include<bits/stdc++.h>
#include<vector>
#include<iterator>
#define ll long long int
using namespace std;
int main()
{
//ios_base::sync_with_stdio(false);
//cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
ll n,i,j,k;
cin>>n;
n=n*2;
vector<ll>v(n),v1(n);
for(i=0;i<n;i++)
{
cin>>v[i];
}
sort(v.begin(),v.end());
if(n==2)
{
cout<<"YES\n";
cout<<v[0]+v[1]<<endl;
cout<<v[0]<<" "<<v[1]<<endl;
continue;
}
int flag1=1,flag=1;
vector<pair<ll,ll>>displayValue;
i=0;
ll temp;
while(i<n-1)
{
v1.clear();
displayValue.clear();
v1=v;
j=v1.size()-1;
ll x=v1[i]+v1[j];
temp=x;
displayValue.push_back(make_pair(v1[i],v1[j]));
x=max(v1[i],v1[j]);
v1.erase(v1.begin()+i);
v1.erase(v1.begin()+v1.size()-1);
j=v1.size()-1;
while(v1.size()>0)
{
flag=1;
vector<ll>::iterator low1;
low1=std::lower_bound(v1.begin(),v1.end(),x-v1[v1.size()-1]);
//cout<<*low1<<endl;
if(*low1+v1[j]==x && low1!=v1.end()-1)
{
x=max(*low1,v1[j]);
displayValue.push_back(make_pair(*low1,v1[j]));
//cout<<*low1<<" "<<v1[j]<<endl;
v1.erase(low1);
v1.erase(v1.begin()+v1.size()-1);
j=v1.size()-1;
flag=0;
}
else if(*low1+v1[j]>x || low1==v1.end() || low1==v1.end()-1)
{
break;
}
}
if(flag==1)
{
i++;
}
else if(flag==0 && v1.size()<=0)
{
break;
}
}
if(flag==0)
{
flag1=0;
cout<<"YES\n";
cout<<temp<<endl;
//cout<<"display value size "<<displayValue.size()<<endl;
for(ll ii=0;ii<displayValue.size();ii++)
{
cout<<displayValue[ii].first<<" "<<displayValue[ii].second<<endl;;
}
}
if(flag1==1)
{
cout<<"NO\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000")
char s[100];
long long dp[100][10];
long long len;
long long Dp(long long x, long long y) {
if (x == len - 1) return 1;
if (dp[x][y] != -1) return dp[x][y];
long long z = s[x + 1] - '0' + y;
if (z % 2 == 0)
return dp[x][y] = Dp(x + 1, z / 2);
else
return dp[x][y] = Dp(x + 1, z / 2) + Dp(x + 1, z / 2 + 1);
}
int main() {
scanf("%s", s);
len = strlen(s);
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (long long i = 0; i <= 9; i++) ans += Dp(0, i);
long long k = s[0] - '0';
bool flag = 0;
for (long long i = 1; i < len; i++) {
long long z = k + s[i] - '0';
if (z % 2 == 0) {
if (z / 2 != (s[i] - '0')) {
flag = 1;
break;
}
} else {
char z1 = z / 2 + '0', z2 = z / 2 + 1 + '0';
if (z1 != s[i] && z2 != s[i]) {
flag = 1;
break;
}
}
k = s[i] - '0';
}
if (!flag) ans--;
printf("%I64d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int i, n;
cin>>n;
int arr[n];
for(i=0; i<n; i++)
{
cin>>arr[i];
}
int mat[n][n], j;
for(i=0; i<n; i++)
{
for(j=0; j<=i; j++)
{
if(i==j)
cout<<arr[i];
else
{
int l, t = j, k = i+j - min(i,j) - min(i,j) + 1;
//cout<<k<<" ";
vector <int> v;
for(l = 0; l<n; l++)
{
if(arr[l] >= k)
{
v.push_back(arr[l]);
}
}
//cout<<j<<" ";
cout<<v[j]<<" ";
}
}
cout<<"\n";
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long x, y, x1, y1, x2, y2;
cin >> x >> y >> x1 >> y1 >> x2 >> y2;
bool flag = true;
long long lefte = a - b;
if (x - lefte < x1 or x - lefte > x2) flag = false;
if (x2 - x1 == 0 and (a != 0 or b != 0)) flag = false;
long long downe = c - d;
if (y - downe < y1 or y - downe > y2) flag = false;
if (y2 - y1 == 0 and (c != 0 or d != 0)) flag = false;
if (flag)
cout << "Yes\n";
else
cout << "No\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long tc;
cin >> tc;
while (tc--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void RearrangePosNeg(int arr[], int n) {
int key, j;
for (int i = 1; i < n; i++) {
key = arr[i];
if (key > 0) continue;
j = i - 1;
while (j >= 0 && arr[j] > 0) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
int mymax(int arr[], int d) {
int i, sum = 0, j, c = 0;
sort(arr, arr + d);
for (i = 0; i < d; i++) {
for (j = i; j < d; j++) {
if (arr[i] == arr[j]) {
c++;
}
}
if (c > sum) {
sum = c;
}
c = 0;
}
return sum;
}
signed main() {
static int k, n, m, i, j, arr[1000], brr[1000][1000], crr[1000], trr[1000], t,
a, c, d, p, sum, sum2, y, x;
string str, str2;
cin >> str;
for (i = 0; i < 5; i++) {
arr[i] = str.at(i) - '0';
}
sum = INT_MAX;
for (i = arr[0] * 10 + arr[1]; i <= 48; i++) {
for (j = arr[3] * 10 + arr[4] + 1; j <= 120; j++) {
k = j % 60;
m = i % 24;
p = i * 60 + j;
t = p % (60 * 24);
if ((t / 60) / 10 == (t % 60) % 10 && (t / 60) % 10 == (t % 60) / 10 &&
p < sum) {
sum = t;
}
}
}
sum = sum % (60 * 24);
cout << (sum / 60) / 10 << (sum / 60) % 10 << ':' << (sum % 60) / 10
<< (sum % 60) % 10;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2500000000;
const long long inf = 123456789;
const long double EPS = 1e-10;
const long double PI = 2 * asin(1.0);
const long long mod = 1e9 + 7;
inline int long double_cmp(long double x, long double y = 0,
long double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int pd[100];
int pos, pos2;
int cont;
void dp(int pos, int passos) {
if (passos == 0) {
pd[pos]++;
return;
}
dp(pos + 1, passos - 1);
dp(pos - 1, passos - 1);
}
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < ((int)a.size()); ++i) {
if (a[i] == '+')
pos++;
else
pos--;
}
pos += 50;
cont = 0;
for (int i = 0; i < ((int)b.size()); ++i) {
if (b[i] == '+')
pos2++;
else if (b[i] == '-')
pos2--;
else
cont++;
}
pos2 += 50;
dp(pos2, cont);
int aux = 0;
for (int i = 0; i < 100; ++i) aux += pd[i];
printf("%.11lf\n", pd[pos] / (double)aux);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mod1 = int(1e9) + 7;
int mmin[4], mmax[4], ans[4];
int main() {
int n;
scanf("%d", &(n));
for (int i = 1; i <= (int)(3); ++i) {
scanf("%d%d", &(mmin[i]), &(mmax[i]));
ans[i] = mmin[i];
n -= ans[i];
}
for (int i = 1; i <= 3; i++) {
int ad = min(n, mmax[i] - ans[i]);
ans[i] += ad;
n -= ad;
}
for (int i = 1; i <= (int)(3); ++i) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a = 0, b, c, d, e = 1;
string s;
cin >> n;
if (n < 10) {
cout << n;
return 0;
}
while (n > a) {
a += 9 * e * pow(10, e - 1);
e++;
}
a -= 9 * (e - 1) * pow(10, e - 2);
c = n - a;
d = c / (e - 1);
if (c % (e - 1) == 0) {
b = pow(10, e - 2) - 1 + d;
cout << b % 10 << endl;
} else {
b = pow(10, e - 2) + d;
s = to_string(b);
cout << s[c - d * (e - 1) - 1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int a[n + 5];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAGIC = 333;
int power[MAGIC][MAGIC], jumps[MAGIC][MAGIC], some_word[MAGIC][MAGIC],
size[MAGIC];
int main(int argc, const char **argv) {
ios_base::sync_with_stdio(false);
int counter, query_count;
cin >> counter >> query_count;
int block_count = 0;
for (int i = 0; i < counter; ++i) {
if (size[block_count] == MAGIC) {
block_count++;
}
cin >> power[block_count][size[block_count]];
size[block_count]++;
}
block_count++;
for (int block = block_count - 1; block >= 0; --block) {
for (int ptr = size[block] - 1; ptr >= 0; --ptr) {
if (ptr + 1 + power[block][ptr] > size[block]) {
jumps[block][ptr] = 1;
some_word[block][ptr] = block * MAGIC + ptr + power[block][ptr];
if (some_word[block][ptr] >= counter)
some_word[block][ptr] = -(block * MAGIC + ptr + 1);
} else {
jumps[block][ptr] = jumps[block][ptr + power[block][ptr]] + 1;
some_word[block][ptr] = some_word[block][ptr + power[block][ptr]];
}
}
}
for (int query = 0; query < query_count; ++query) {
int type;
cin >> type;
if (type == 0) {
int ptr, value;
cin >> ptr >> value;
ptr--;
int block = ptr / MAGIC;
ptr %= MAGIC;
power[block][ptr] = value;
while (ptr >= 0) {
if (ptr + 1 + power[block][ptr] > size[block]) {
jumps[block][ptr] = 1;
some_word[block][ptr] = block * MAGIC + ptr + power[block][ptr];
if (some_word[block][ptr] >= counter)
some_word[block][ptr] = -(block * MAGIC + ptr + 1);
} else {
jumps[block][ptr] = jumps[block][ptr + power[block][ptr]] + 1;
some_word[block][ptr] = some_word[block][ptr + power[block][ptr]];
}
ptr--;
}
} else {
int idx;
cin >> idx;
idx--;
int answer = 0;
while (true) {
int block = idx / MAGIC;
int ptr = idx % MAGIC;
answer += jumps[block][ptr];
if (some_word[block][ptr] < 0) {
idx = -some_word[block][ptr];
break;
}
idx = some_word[block][ptr];
}
cout << idx << ' ' << answer << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 20];
int A[16];
int B[16];
int main() {
scanf("%s", buf);
int n = strlen(buf);
int i, j, k;
memset(A, 0, sizeof(A));
for (i = (0); i < (n); ++i) ++A[buf[i] - '0'];
for (i = (0); i < (10); ++i) B[i] = A[i];
int res = -1;
string ra = buf;
string rb = buf;
sort((ra).begin(), (ra).end());
reverse((ra).begin(), (ra).end());
rb = ra;
for (i = (1); i < (10); ++i)
if (A[i] != 0 && B[10 - i] != 0) {
--A[i];
--B[10 - i];
int r = 0;
string a = "";
string b = "";
string aa = "";
string bb = "";
for (j = (0); j < (10); ++j) {
int t = min(A[j], B[9 - j]);
r += t;
for (k = (t); k < (A[j]); ++k) a.push_back('0' + j);
for (k = (t); k < (B[9 - j]); ++k) b.push_back('0' + 9 - j);
for (k = (0); k < (t); ++k) {
aa.push_back('0' + j);
bb.push_back('0' + 9 - j);
}
}
aa.push_back('0' + i);
bb.push_back('0' + 10 - i);
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
int cnt = 0;
while (int((a).size()) > cnt && int((b).size()) > cnt && a[cnt] == '0' &&
b[cnt] == '0')
++cnt;
a = a.substr(cnt);
b = b.substr(cnt);
aa = aa + string(cnt, '0');
bb = bb + string(cnt, '0');
if (r > res) {
res = r;
ra = a + aa;
rb = b + bb;
}
++A[i];
++B[10 - i];
}
printf("%s\n%s\n", ra.c_str(), rb.c_str());
return 0;
};
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 300010;
const int offset = 100000;
const long long M = 1000000;
vector<pair<int, int> > nd[maxn], nd2[maxn];
bool vis[maxn], vis2[maxn];
map<long long, long long> hs;
int a[maxn], b[maxn];
int n, m, k;
bool check_end(int x, int y) {
if (x == 0 && y == 0) return true;
if (x == 0 && y == m) return true;
if (x == n && y == 0) return true;
if (x == n && y == m) return true;
return false;
}
int change_dir(int x, int y, int d) {
if (x == 0 && d == 4) return 1;
if (y == 0 && d == 2) return 1;
if (x == 0 && d == 3) return 2;
if (y == m && d == 1) return 2;
if (x == n && d == 2) return 3;
if (y == m && d == 4) return 3;
if (x == n && d == 1) return 4;
if (y == 0 && d == 3) return 4;
}
long long depth = 0;
void solve(int x, int y, int d) {
while (true) {
int tmp = -1;
vector<pair<int, int> >& node = nd[0];
if (d & 1) {
tmp = y - x + offset, node = nd2[tmp];
if (vis2[tmp]) return;
vis2[tmp] = true;
} else {
tmp = x + y + offset, node = nd[tmp];
if (vis[tmp]) return;
vis[tmp] = true;
}
int sz = node.size();
if (d <= 2) {
for (int i = 0; i <= sz - 1; i++) {
int tx = node[i].first, ty = node[i].second;
depth += abs(x - tx);
if (tx > 0 && tx < n && ty > 0 && ty < m && hs[1ll * tx * M + ty] == 0)
hs[1ll * tx * M + ty] = depth;
if (i == sz - 1) {
if (check_end(tx, ty)) return;
d = change_dir(tx, ty, d);
}
x = tx, y = ty;
}
} else {
for (int i = sz - 1; i >= 0; i--) {
int tx = node[i].first, ty = node[i].second;
depth += abs(x - tx);
if (tx > 0 && tx < n && ty > 0 && ty < m && hs[1ll * tx * M + ty] == 0)
hs[1ll * tx * M + ty] = depth;
x = tx, y = ty;
if (i == 0) {
if (check_end(tx, ty)) return;
d = change_dir(tx, ty, d);
}
}
}
}
}
int main() {
memset(vis, false, sizeof(vis));
memset(vis2, false, sizeof(vis2));
cin >> n >> m >> k;
nd2[offset].push_back(make_pair(0, 0));
nd[m + offset].push_back(make_pair(0, m));
nd[-n + offset].push_back(make_pair(n, 0));
nd2[m - n + offset].push_back(make_pair(n, m));
for (int i = 1; i <= n - 1; i++) {
nd[i + offset].push_back(make_pair(i, 0));
nd[i + m + offset].push_back(make_pair(i, m));
nd2[-i + offset].push_back(make_pair(i, 0));
nd2[m - i + offset].push_back(make_pair(i, m));
}
for (int i = 1; i <= m - 1; i++) {
nd[i + offset].push_back(make_pair(0, i));
nd[i + n + offset].push_back(make_pair(n, i));
nd2[i + offset].push_back(make_pair(0, i));
nd2[i - n + offset].push_back(make_pair(n, i));
}
for (int i = 1; i <= k; i++) {
cin >> a[i] >> b[i];
int x = a[i], y = b[i];
nd[x + y + offset].push_back(make_pair(x, y));
nd2[y - x + offset].push_back(make_pair(x, y));
}
for (int i = 0; i <= n + m + offset; i++) {
sort(nd[i].begin(), nd[i].end());
sort(nd2[i].begin(), nd2[i].end());
}
solve(0, 0, 1);
for (int i = 1; i <= k; i++) {
long long tmp = 1ll * a[i] * M + b[i];
cout << (hs[tmp] == 0 ? -1 : hs[tmp]) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> adj[N];
int vis[N];
vector<int> ans;
vector<int> des;
int dfs(int s) {
vis[s] = 1;
ans.push_back(s);
int c = 1;
for (int i = 0; i < adj[s].size(); i++) {
if (vis[adj[s][i]] == 0) {
c += dfs(adj[s][i]);
}
}
des[s] = c;
return c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
ans.clear();
memset(vis, 0, sizeof(vis));
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
adj[x].push_back(i);
}
for (int i = 1; i <= n; i++) sort(adj[i].begin(), adj[i].end());
vector<int> b(N);
des.resize(N);
int x = dfs(1);
for (int i = 0; i < ans.size(); i++) {
b[ans[i]] = i;
}
while (q--) {
int u, k;
cin >> u >> k;
int ind = b[u];
if (des[u] >= k)
cout << ans[ind + k - 1] << endl;
else
cout << "-1" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 50;
int n, m;
int head[N], to[N], nxt[N], tot;
inline void add(int x, int y) {
to[tot] = y;
nxt[tot] = head[x];
head[x] = tot++;
}
int vis[N];
int in[N], id[N];
bool dt[N], k;
const bool cmp(int a, int b) { return in[a] < in[b]; }
inline double FIND_TIME() { return clock() / (double)CLOCKS_PER_SEC; }
void dfs(int x) {
vis[x] = 1;
for (int i = head[x]; ~i; i = nxt[i]) {
if (!vis[to[i]]) dfs(to[i]);
if (vis[to[i]] == 1) k = 1;
if (k) return;
}
vis[x] = 2;
}
inline bool check(int x) {
memset(vis, 0, sizeof(vis));
vis[x] = 2;
k = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
dfs(i);
if (k) {
for (int i = 1; i <= n; i++)
if (vis[i] != 1) dt[i] = 1;
return false;
}
}
return true;
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
++in[v];
}
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
if (FIND_TIME() > 0.9) break;
if (!dt[id[i]] && check(id[i])) {
printf("%d", id[i]);
return 0;
}
}
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, K, a[1000005], f[1000005], b[1000005];
int main() {
int i, j, res, cnt;
scanf("%d%d", &N, &K);
for (i = 0; i < N; i++) scanf("%d", a + i);
sort(a, a + N);
for (i = 0; i < N; i++)
for (j = i + 1; j < N; j++) f[a[j] - a[i]]++;
for (i = 1;; i++) {
cnt = res = 0;
for (j = i; j < 1000005; j += i) cnt += f[j];
if (cnt > K * (K + 1) / 2) continue;
for (j = 0; j < N; j++) {
if (b[a[j] % i] == i) res++;
b[a[j] % i] = i;
}
if (res <= K) break;
}
printf("%d\n", i);
}
| 8 |
#include <bits/stdc++.h>
int n, col[200001], head[200001], cnte;
struct edge {
int to, nxt;
} edges[200001 << 1];
void add(int u, int v) {
edges[++cnte].to = v;
edges[cnte].nxt = head[u];
head[u] = cnte;
}
void dfs(int u, int fa) {
for (int i = head[u]; i; i = edges[i].nxt) {
int v = edges[i].to;
if (v == fa) {
continue;
}
col[v] = -col[v];
printf("%d ", v);
dfs(v, u);
col[u] = -col[u];
printf("%d ", u);
if (col[v] == -1) {
col[v] = -col[v];
printf("%d ", v);
col[u] = -col[u];
printf("%d ", u);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &col[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
printf("1 ");
dfs(1, 0);
if (col[1] == -1) {
int v = edges[head[1]].to;
printf("%d %d %d", v, 1, v);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
cout << n + m << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e7;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
long long n;
cin >> n;
if (n == 1) {
cout << 1 << " " << 0;
return 0;
}
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
long long a = arr[0], b = arr[n - 1];
long long cnt1 = 1, cnt2 = 1;
long long i = 0, j = n - 1;
while (1) {
if (a > b) {
j--;
if (j == i) {
break;
}
b += arr[j];
cnt2++;
} else {
i++;
if (i == j) {
break;
}
a += arr[i];
cnt1++;
}
}
cout << cnt1 << " " << cnt2;
return 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, d, m;
int bit[(1 << 21)], a[(1 << 21)];
bool flag[(1 << 21)];
int num[21];
void input() {
scanf("%d %d %d", &n, &m, &d);
int v, x = 0;
for (int i = 0; i < m; i++) {
scanf("%d", &v);
while (v--) {
scanf("%d", &x);
a[x - 1] = i;
}
}
x = 0;
for (int i = 0; i < n; i++) {
v = a[i];
if (!num[v]) x += (1 << v);
num[v]++;
if (i >= d - 1) {
flag[x] = 1;
v = a[i - d + 1];
num[v]--;
if (!num[v]) x -= (1 << v);
}
}
}
void solve() {
for (int i = 0; i < m; i++) {
for (int j = 0; j < (1 << m); j++)
if (j & (1 << i)) {
flag[j] |= flag[j - (1 << i)];
}
}
int ans = 0;
for (int j = 0; j < (1 << m); j++) {
bit[j] = bit[j / 2] + (j & 1);
if (!flag[j] && bit[j] > ans) ans = bit[j];
}
printf("%d\n", m - ans);
}
int main() {
input();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, fl, numb[1000], tans, ans;
long long s, q, ar[100][100], arr[100];
void calc(long n) {
long s = 0;
while (n) {
q = n % 10;
if (q == 4) ++s;
if (q == 7) ++s;
n /= 10;
}
arr[s]++;
}
int main() {
ios_base::sync_with_stdio(0);
ar[1][0] = 3145728;
ar[1][1] = 5505024;
ar[1][2] = 4128768;
ar[1][3] = 1720320;
ar[1][4] = 430080;
ar[1][5] = 64512;
ar[1][6] = 5376;
ar[1][7] = 192;
ar[1][8] = 0;
ar[1][9] = 0;
ar[1][10] = 0;
ar[2][0] = 6291456;
ar[2][1] = 11010048;
ar[2][2] = 8257536;
ar[2][3] = 3440640;
ar[2][4] = 860160;
ar[2][5] = 129024;
ar[2][6] = 10752;
ar[2][7] = 384;
ar[2][8] = 0;
ar[2][9] = 0;
ar[2][10] = 0;
ar[3][0] = 8388607;
ar[3][1] = 15728641;
ar[3][2] = 12845056;
ar[3][3] = 5963776;
ar[3][4] = 1720320;
ar[3][5] = 315392;
ar[3][6] = 35840;
ar[3][7] = 2304;
ar[3][8] = 64;
ar[3][9] = 0;
ar[3][10] = 0;
ar[4][0] = 10485760;
ar[4][1] = 20447232;
ar[4][2] = 17432576;
ar[4][3] = 8486912;
ar[4][4] = 2580480;
ar[4][5] = 501760;
ar[4][6] = 60928;
ar[4][7] = 4224;
ar[4][8] = 128;
ar[4][9] = 0;
ar[4][10] = 0;
ar[5][0] = 12582911;
ar[5][1] = 25165825;
ar[5][2] = 22020096;
ar[5][3] = 11010048;
ar[5][4] = 3440640;
ar[5][5] = 688128;
ar[5][6] = 86016;
ar[5][7] = 6144;
ar[5][8] = 192;
ar[5][9] = 0;
ar[5][10] = 0;
ar[6][0] = 14680064;
ar[6][1] = 29884416;
ar[6][2] = 26607616;
ar[6][3] = 13533184;
ar[6][4] = 4300800;
ar[6][5] = 874496;
ar[6][6] = 111104;
ar[6][7] = 8064;
ar[6][8] = 256;
ar[6][9] = 0;
ar[6][10] = 0;
ar[7][0] = 17825792;
ar[7][1] = 35389440;
ar[7][2] = 30736384;
ar[7][3] = 15253504;
ar[7][4] = 4730880;
ar[7][5] = 939008;
ar[7][6] = 116480;
ar[7][7] = 8256;
ar[7][8] = 256;
ar[7][9] = 0;
ar[7][10] = 0;
ar[8][0] = 20971520;
ar[8][1] = 40894464;
ar[8][2] = 34865152;
ar[8][3] = 16973824;
ar[8][4] = 5160960;
ar[8][5] = 1003520;
ar[8][6] = 121856;
ar[8][7] = 8448;
ar[8][8] = 256;
ar[8][9] = 0;
ar[8][10] = 0;
ar[9][0] = 24117248;
ar[9][1] = 46399488;
ar[9][2] = 38993920;
ar[9][3] = 18694144;
ar[9][4] = 5591040;
ar[9][5] = 1068032;
ar[9][6] = 127232;
ar[9][7] = 8640;
ar[9][8] = 256;
ar[9][9] = 0;
ar[9][10] = 0;
ar[10][0] = 25165824;
ar[10][1] = 50331648;
ar[10][2] = 44040192;
ar[10][3] = 22020096;
ar[10][4] = 6881280;
ar[10][5] = 1376256;
ar[10][6] = 172032;
ar[10][7] = 12288;
ar[10][8] = 384;
ar[10][9] = 0;
ar[10][10] = 0;
ar[11][0] = 28311552;
ar[11][1] = 55836672;
ar[11][2] = 48168960;
ar[11][3] = 23740416;
ar[11][4] = 7311360;
ar[11][5] = 1440768;
ar[11][6] = 177408;
ar[11][7] = 12480;
ar[11][8] = 384;
ar[11][9] = 0;
ar[11][10] = 0;
ar[12][0] = 29360128;
ar[12][1] = 59768832;
ar[12][2] = 53215232;
ar[12][3] = 27066368;
ar[12][4] = 8601600;
ar[12][5] = 1748992;
ar[12][6] = 222208;
ar[12][7] = 16128;
ar[12][8] = 512;
ar[12][9] = 0;
ar[12][10] = 0;
ar[13][0] = 32505856;
ar[13][1] = 65273856;
ar[13][2] = 57344000;
ar[13][3] = 28786688;
ar[13][4] = 9031680;
ar[13][5] = 1813504;
ar[13][6] = 227584;
ar[13][7] = 16320;
ar[13][8] = 512;
ar[13][9] = 0;
ar[13][10] = 0;
ar[14][0] = 35651584;
ar[14][1] = 70778880;
ar[14][2] = 61472768;
ar[14][3] = 30507008;
ar[14][4] = 9461760;
ar[14][5] = 1878016;
ar[14][6] = 232960;
ar[14][7] = 16512;
ar[14][8] = 512;
ar[14][9] = 0;
ar[14][10] = 0;
ar[15][0] = 38797312;
ar[15][1] = 76283904;
ar[15][2] = 65601536;
ar[15][3] = 32227328;
ar[15][4] = 9891840;
ar[15][5] = 1942528;
ar[15][6] = 238336;
ar[15][7] = 16704;
ar[15][8] = 512;
ar[15][9] = 0;
ar[15][10] = 0;
ar[16][0] = 41943039;
ar[16][1] = 81788929;
ar[16][2] = 69730304;
ar[16][3] = 33947648;
ar[16][4] = 10321920;
ar[16][5] = 2007040;
ar[16][6] = 243712;
ar[16][7] = 16896;
ar[16][8] = 512;
ar[16][9] = 0;
ar[16][10] = 0;
ar[17][0] = 42991616;
ar[17][1] = 85721088;
ar[17][2] = 74776576;
ar[17][3] = 37273600;
ar[17][4] = 11612160;
ar[17][5] = 2315264;
ar[17][6] = 288512;
ar[17][7] = 20544;
ar[17][8] = 640;
ar[17][9] = 0;
ar[17][10] = 0;
ar[18][0] = 46137343;
ar[18][1] = 91226113;
ar[18][2] = 78905344;
ar[18][3] = 38993920;
ar[18][4] = 12042240;
ar[18][5] = 2379776;
ar[18][6] = 293888;
ar[18][7] = 20736;
ar[18][8] = 640;
ar[18][9] = 0;
ar[18][10] = 0;
ar[19][0] = 47185920;
ar[19][1] = 95158272;
ar[19][2] = 83951616;
ar[19][3] = 42319872;
ar[19][4] = 13332480;
ar[19][5] = 2688000;
ar[19][6] = 338688;
ar[19][7] = 24384;
ar[19][8] = 768;
ar[19][9] = 0;
ar[19][10] = 0;
ar[20][0] = 50331648;
ar[20][1] = 100663296;
ar[20][2] = 88080384;
ar[20][3] = 44040192;
ar[20][4] = 13762560;
ar[20][5] = 2752512;
ar[20][6] = 344064;
ar[20][7] = 24576;
ar[20][8] = 768;
ar[20][9] = 0;
ar[20][10] = 0;
ar[21][0] = 53477376;
ar[21][1] = 106168320;
ar[21][2] = 92209152;
ar[21][3] = 45760512;
ar[21][4] = 14192640;
ar[21][5] = 2817024;
ar[21][6] = 349440;
ar[21][7] = 24768;
ar[21][8] = 768;
ar[21][9] = 0;
ar[21][10] = 0;
ar[22][0] = 56623104;
ar[22][1] = 111673344;
ar[22][2] = 96337920;
ar[22][3] = 47480832;
ar[22][4] = 14622720;
ar[22][5] = 2881536;
ar[22][6] = 354816;
ar[22][7] = 24960;
ar[22][8] = 768;
ar[22][9] = 0;
ar[22][10] = 0;
ar[23][0] = 58720255;
ar[23][1] = 116391937;
ar[23][2] = 100925440;
ar[23][3] = 50003968;
ar[23][4] = 15482880;
ar[23][5] = 3067904;
ar[23][6] = 379904;
ar[23][7] = 26880;
ar[23][8] = 832;
ar[23][9] = 0;
ar[23][10] = 0;
ar[24][0] = 60817408;
ar[24][1] = 121110528;
ar[24][2] = 105512960;
ar[24][3] = 52527104;
ar[24][4] = 16343040;
ar[24][5] = 3254272;
ar[24][6] = 404992;
ar[24][7] = 28800;
ar[24][8] = 896;
ar[24][9] = 0;
ar[24][10] = 0;
ar[25][0] = 62914559;
ar[25][1] = 125829121;
ar[25][2] = 110100480;
ar[25][3] = 55050240;
ar[25][4] = 17203200;
ar[25][5] = 3440640;
ar[25][6] = 430080;
ar[25][7] = 30720;
ar[25][8] = 960;
ar[25][9] = 0;
ar[25][10] = 0;
ar[26][0] = 65011712;
ar[26][1] = 130547712;
ar[26][2] = 114688000;
ar[26][3] = 57573376;
ar[26][4] = 18063360;
ar[26][5] = 3627008;
ar[26][6] = 455168;
ar[26][7] = 32640;
ar[26][8] = 1024;
ar[26][9] = 0;
ar[26][10] = 0;
ar[27][0] = 67108863;
ar[27][1] = 135266305;
ar[27][2] = 119275520;
ar[27][3] = 60096512;
ar[27][4] = 18923520;
ar[27][5] = 3813376;
ar[27][6] = 480256;
ar[27][7] = 34560;
ar[27][8] = 1088;
ar[27][9] = 0;
ar[27][10] = 0;
ar[28][0] = 67108863;
ar[28][1] = 138412033;
ar[28][2] = 124780544;
ar[28][3] = 64225280;
ar[28][4] = 20643840;
ar[28][5] = 4243456;
ar[28][6] = 544768;
ar[28][7] = 39936;
ar[28][8] = 1280;
ar[28][9] = 0;
ar[28][10] = 0;
ar[29][0] = 67108863;
ar[29][1] = 141557761;
ar[29][2] = 130285568;
ar[29][3] = 68354048;
ar[29][4] = 22364160;
ar[29][5] = 4673536;
ar[29][6] = 609280;
ar[29][7] = 45312;
ar[29][8] = 1472;
ar[29][9] = 0;
ar[29][10] = 0;
ar[30][0] = 67108863;
ar[30][1] = 142606337;
ar[30][2] = 134217728;
ar[30][3] = 73400320;
ar[30][4] = 25690112;
ar[30][5] = 5963776;
ar[30][6] = 917504;
ar[30][7] = 90112;
ar[30][8] = 5120;
ar[30][9] = 128;
ar[30][10] = 0;
ar[31][0] = 67108863;
ar[31][1] = 145752065;
ar[31][2] = 139722752;
ar[31][3] = 77529088;
ar[31][4] = 27410432;
ar[31][5] = 6393856;
ar[31][6] = 982016;
ar[31][7] = 95488;
ar[31][8] = 5312;
ar[31][9] = 128;
ar[31][10] = 0;
ar[32][0] = 67108863;
ar[32][1] = 146800641;
ar[32][2] = 143654912;
ar[32][3] = 82575360;
ar[32][4] = 30736384;
ar[32][5] = 7684096;
ar[32][6] = 1290240;
ar[32][7] = 140288;
ar[32][8] = 8960;
ar[32][9] = 256;
ar[32][10] = 0;
ar[33][0] = 67108863;
ar[33][1] = 149946369;
ar[33][2] = 149159936;
ar[33][3] = 86704128;
ar[33][4] = 32456704;
ar[33][5] = 8114176;
ar[33][6] = 1354752;
ar[33][7] = 145664;
ar[33][8] = 9152;
ar[33][9] = 256;
ar[33][10] = 0;
ar[34][0] = 69206016;
ar[34][1] = 154664960;
ar[34][2] = 153747456;
ar[34][3] = 89227264;
ar[34][4] = 33316864;
ar[34][5] = 8300544;
ar[34][6] = 1379840;
ar[34][7] = 147584;
ar[34][8] = 9216;
ar[34][9] = 256;
ar[34][10] = 0;
ar[35][0] = 72351744;
ar[35][1] = 160169984;
ar[35][2] = 157876224;
ar[35][3] = 90947584;
ar[35][4] = 33746944;
ar[35][5] = 8365056;
ar[35][6] = 1385216;
ar[35][7] = 147776;
ar[35][8] = 9216;
ar[35][9] = 256;
ar[35][10] = 0;
ar[36][0] = 75497471;
ar[36][1] = 165675009;
ar[36][2] = 162004992;
ar[36][3] = 92667904;
ar[36][4] = 34177024;
ar[36][5] = 8429568;
ar[36][6] = 1390592;
ar[36][7] = 147968;
ar[36][8] = 9216;
ar[36][9] = 256;
ar[36][10] = 0;
ar[37][0] = 76546048;
ar[37][1] = 169607168;
ar[37][2] = 167051264;
ar[37][3] = 95993856;
ar[37][4] = 35467264;
ar[37][5] = 8737792;
ar[37][6] = 1435392;
ar[37][7] = 151616;
ar[37][8] = 9344;
ar[37][9] = 256;
ar[37][10] = 0;
ar[38][0] = 79691775;
ar[38][1] = 175112193;
ar[38][2] = 171180032;
ar[38][3] = 97714176;
ar[38][4] = 35897344;
ar[38][5] = 8802304;
ar[38][6] = 1440768;
ar[38][7] = 151808;
ar[38][8] = 9344;
ar[38][9] = 256;
ar[38][10] = 0;
ar[39][0] = 80740352;
ar[39][1] = 179044352;
ar[39][2] = 176226304;
ar[39][3] = 101040128;
ar[39][4] = 37187584;
ar[39][5] = 9110528;
ar[39][6] = 1485568;
ar[39][7] = 155456;
ar[39][8] = 9472;
ar[39][9] = 256;
ar[39][10] = 0;
ar[40][0] = 83886080;
ar[40][1] = 184549376;
ar[40][2] = 180355072;
ar[40][3] = 102760448;
ar[40][4] = 37617664;
ar[40][5] = 9175040;
ar[40][6] = 1490944;
ar[40][7] = 155648;
ar[40][8] = 9472;
ar[40][9] = 256;
ar[40][10] = 0;
ar[41][0] = 87031808;
ar[41][1] = 190054400;
ar[41][2] = 184483840;
ar[41][3] = 104480768;
ar[41][4] = 38047744;
ar[41][5] = 9239552;
ar[41][6] = 1496320;
ar[41][7] = 155840;
ar[41][8] = 9472;
ar[41][9] = 256;
ar[41][10] = 0;
ar[42][0] = 90177536;
ar[42][1] = 195559424;
ar[42][2] = 188612608;
ar[42][3] = 106201088;
ar[42][4] = 38477824;
ar[42][5] = 9304064;
ar[42][6] = 1501696;
ar[42][7] = 156032;
ar[42][8] = 9472;
ar[42][9] = 256;
ar[42][10] = 0;
ar[43][0] = 92274687;
ar[43][1] = 200278017;
ar[43][2] = 193200128;
ar[43][3] = 108724224;
ar[43][4] = 39337984;
ar[43][5] = 9490432;
ar[43][6] = 1526784;
ar[43][7] = 157952;
ar[43][8] = 9536;
ar[43][9] = 256;
ar[43][10] = 0;
ar[44][0] = 94371840;
ar[44][1] = 204996608;
ar[44][2] = 197787648;
ar[44][3] = 111247360;
ar[44][4] = 40198144;
ar[44][5] = 9676800;
ar[44][6] = 1551872;
ar[44][7] = 159872;
ar[44][8] = 9600;
ar[44][9] = 256;
ar[44][10] = 0;
ar[45][0] = 96468991;
ar[45][1] = 209715201;
ar[45][2] = 202375168;
ar[45][3] = 113770496;
ar[45][4] = 41058304;
ar[45][5] = 9863168;
ar[45][6] = 1576960;
ar[45][7] = 161792;
ar[45][8] = 9664;
ar[45][9] = 256;
ar[45][10] = 0;
ar[46][0] = 98566144;
ar[46][1] = 214433792;
ar[46][2] = 206962688;
ar[46][3] = 116293632;
ar[46][4] = 41918464;
ar[46][5] = 10049536;
ar[46][6] = 1602048;
ar[46][7] = 163712;
ar[46][8] = 9728;
ar[46][9] = 256;
ar[46][10] = 0;
ar[47][0] = 100663295;
ar[47][1] = 219152385;
ar[47][2] = 211550208;
ar[47][3] = 118816768;
ar[47][4] = 42778624;
ar[47][5] = 10235904;
ar[47][6] = 1627136;
ar[47][7] = 165632;
ar[47][8] = 9792;
ar[47][9] = 256;
ar[47][10] = 0;
ar[48][0] = 100663295;
ar[48][1] = 222298113;
ar[48][2] = 217055232;
ar[48][3] = 122945536;
ar[48][4] = 44498944;
ar[48][5] = 10665984;
ar[48][6] = 1691648;
ar[48][7] = 171008;
ar[48][8] = 9984;
ar[48][9] = 256;
ar[48][10] = 0;
ar[49][0] = 100663295;
ar[49][1] = 225443841;
ar[49][2] = 222560256;
ar[49][3] = 127074304;
ar[49][4] = 46219264;
ar[49][5] = 11096064;
ar[49][6] = 1756160;
ar[49][7] = 176384;
ar[49][8] = 10176;
ar[49][9] = 256;
ar[49][10] = 0;
ar[50][0] = 100663295;
ar[50][1] = 226492417;
ar[50][2] = 226492416;
ar[50][3] = 132120576;
ar[50][4] = 49545216;
ar[50][5] = 12386304;
ar[50][6] = 2064384;
ar[50][7] = 221184;
ar[50][8] = 13824;
ar[50][9] = 384;
ar[50][10] = 0;
ar[51][0] = 100663295;
ar[51][1] = 229638145;
ar[51][2] = 231997440;
ar[51][3] = 136249344;
ar[51][4] = 51265536;
ar[51][5] = 12816384;
ar[51][6] = 2128896;
ar[51][7] = 226560;
ar[51][8] = 14016;
ar[51][9] = 384;
ar[51][10] = 0;
ar[52][0] = 100663295;
ar[52][1] = 230686721;
ar[52][2] = 235929600;
ar[52][3] = 141295616;
ar[52][4] = 54591488;
ar[52][5] = 14106624;
ar[52][6] = 2437120;
ar[52][7] = 271360;
ar[52][8] = 17664;
ar[52][9] = 512;
ar[52][10] = 0;
ar[53][0] = 100663295;
ar[53][1] = 233832449;
ar[53][2] = 241434624;
ar[53][3] = 145424384;
ar[53][4] = 56311808;
ar[53][5] = 14536704;
ar[53][6] = 2501632;
ar[53][7] = 276736;
ar[53][8] = 17856;
ar[53][9] = 512;
ar[53][10] = 0;
ar[54][0] = 102760448;
ar[54][1] = 238551040;
ar[54][2] = 246022144;
ar[54][3] = 147947520;
ar[54][4] = 57171968;
ar[54][5] = 14723072;
ar[54][6] = 2526720;
ar[54][7] = 278656;
ar[54][8] = 17920;
ar[54][9] = 512;
ar[54][10] = 0;
ar[55][0] = 105906176;
ar[55][1] = 244056064;
ar[55][2] = 250150912;
ar[55][3] = 149667840;
ar[55][4] = 57602048;
ar[55][5] = 14787584;
ar[55][6] = 2532096;
ar[55][7] = 278848;
ar[55][8] = 17920;
ar[55][9] = 512;
ar[55][10] = 0;
ar[56][0] = 109051903;
ar[56][1] = 249561089;
ar[56][2] = 254279680;
ar[56][3] = 151388160;
ar[56][4] = 58032128;
ar[56][5] = 14852096;
ar[56][6] = 2537472;
ar[56][7] = 279040;
ar[56][8] = 17920;
ar[56][9] = 512;
ar[56][10] = 0;
ar[57][0] = 110100480;
ar[57][1] = 253493248;
ar[57][2] = 259325952;
ar[57][3] = 154714112;
ar[57][4] = 59322368;
ar[57][5] = 15160320;
ar[57][6] = 2582272;
ar[57][7] = 282688;
ar[57][8] = 18048;
ar[57][9] = 512;
ar[57][10] = 0;
ar[58][0] = 113246207;
ar[58][1] = 258998273;
ar[58][2] = 263454720;
ar[58][3] = 156434432;
ar[58][4] = 59752448;
ar[58][5] = 15224832;
ar[58][6] = 2587648;
ar[58][7] = 282880;
ar[58][8] = 18048;
ar[58][9] = 512;
ar[58][10] = 0;
ar[59][0] = 114294784;
ar[59][1] = 262930432;
ar[59][2] = 268500992;
ar[59][3] = 159760384;
ar[59][4] = 61042688;
ar[59][5] = 15533056;
ar[59][6] = 2632448;
ar[59][7] = 286528;
ar[59][8] = 18176;
ar[59][9] = 512;
ar[59][10] = 0;
ar[60][0] = 117440512;
ar[60][1] = 268435456;
ar[60][2] = 272629760;
ar[60][3] = 161480704;
ar[60][4] = 61472768;
ar[60][5] = 15597568;
ar[60][6] = 2637824;
ar[60][7] = 286720;
ar[60][8] = 18176;
ar[60][9] = 512;
ar[60][10] = 0;
ar[61][0] = 120586240;
ar[61][1] = 273940480;
ar[61][2] = 276758528;
ar[61][3] = 163201024;
ar[61][4] = 61902848;
ar[61][5] = 15662080;
ar[61][6] = 2643200;
ar[61][7] = 286912;
ar[61][8] = 18176;
ar[61][9] = 512;
ar[61][10] = 0;
ar[62][0] = 123731968;
ar[62][1] = 279445504;
ar[62][2] = 280887296;
ar[62][3] = 164921344;
ar[62][4] = 62332928;
ar[62][5] = 15726592;
ar[62][6] = 2648576;
ar[62][7] = 287104;
ar[62][8] = 18176;
ar[62][9] = 512;
ar[62][10] = 0;
ar[63][0] = 125829119;
ar[63][1] = 284164097;
ar[63][2] = 285474816;
ar[63][3] = 167444480;
ar[63][4] = 63193088;
ar[63][5] = 15912960;
ar[63][6] = 2673664;
ar[63][7] = 289024;
ar[63][8] = 18240;
ar[63][9] = 512;
ar[63][10] = 0;
ar[64][0] = 127926272;
ar[64][1] = 288882688;
ar[64][2] = 290062336;
ar[64][3] = 169967616;
ar[64][4] = 64053248;
ar[64][5] = 16099328;
ar[64][6] = 2698752;
ar[64][7] = 290944;
ar[64][8] = 18304;
ar[64][9] = 512;
ar[64][10] = 0;
ar[65][0] = 130023423;
ar[65][1] = 293601281;
ar[65][2] = 294649856;
ar[65][3] = 172490752;
ar[65][4] = 64913408;
ar[65][5] = 16285696;
ar[65][6] = 2723840;
ar[65][7] = 292864;
ar[65][8] = 18368;
ar[65][9] = 512;
ar[65][10] = 0;
ar[66][0] = 132120576;
ar[66][1] = 298319872;
ar[66][2] = 299237376;
ar[66][3] = 175013888;
ar[66][4] = 65773568;
ar[66][5] = 16472064;
ar[66][6] = 2748928;
ar[66][7] = 294784;
ar[66][8] = 18432;
ar[66][9] = 512;
ar[66][10] = 0;
cin >> n;
m = n / 15000000;
for (int i = 0; i < 10; i++) arr[i] = ar[m][i];
for (int i = m * 15000000 + 1; i <= n; i++) calc(i);
for (int mask = 0; mask <= 999999; ++mask) {
fl = 0;
for (int j = 0; j <= 9; j++) numb[j] = arr[j];
long p = mask;
s = 0;
tans = 1;
for (int i = 1; i <= 6; i++) {
q = p % 10;
s += q;
p /= 10;
tans = tans * numb[q] % 1000000007;
numb[q]--;
if (numb[q] < 0) fl = 1;
}
long long qq = 0;
for (int pp = s + 1; pp <= 9; pp++) {
qq += numb[pp];
}
tans *= qq;
tans %= 1000000007;
if (fl == 0) ans = ans + tans;
ans %= 1000000007;
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.