solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 5;
const int M = 21 + 5;
int n, m, tot, factr[N], factc[N];
char str[N][N], mat[N][N], tep[N][N];
bool vis[N][N];
struct squ {
int x1, y1, x2, y2;
inline void print() {
printf("%d %d ", factr[x1], factc[y1]);
printf("%d %d\n", factr[x2], factc[y2]);
}
};
vector<squ> arr;
inline bool check(int x1, int y1, int x2, int y2) {
if (factr[x2] - factr[x1] < 2) return 0;
if (factc[y2] - factc[y1] < 2) return 0;
for (int i = x1; i <= x2; i++) {
if (mat[i][y1] != '#') return 0;
if (mat[i][y2] != '#') return 0;
}
for (int i = y1; i <= y2; i++) {
if (mat[x1][i] != '#') return 0;
if (mat[x2][i] != '#') return 0;
}
return 1;
}
inline bool cover(squ a, squ b) {
int cnt = 0;
for (int i = a.x1; i <= a.x2; i++) {
if (!vis[i][a.y1]) cnt++;
if (!vis[i][a.y2]) cnt++;
vis[i][a.y1] = vis[i][a.y2] = 1;
}
for (int i = a.y1; i <= a.y2; i++) {
if (!vis[a.x1][i]) cnt++;
if (!vis[a.x2][i]) cnt++;
vis[a.x1][i] = vis[a.x2][i] = 1;
}
for (int i = b.x1; i <= b.x2; i++) {
if (!vis[i][b.y1]) cnt++;
if (!vis[i][b.y2]) cnt++;
vis[i][b.y1] = vis[i][b.y2] = 1;
}
for (int i = b.y1; i <= b.y2; i++) {
if (!vis[b.x1][i]) cnt++;
if (!vis[b.x2][i]) cnt++;
vis[b.x1][i] = vis[b.x2][i] = 1;
}
for (int i = a.x1; i <= a.x2; i++) vis[i][a.y1] = vis[i][a.y2] = 0;
for (int i = a.y1; i <= a.y2; i++) vis[a.x1][i] = vis[a.x2][i] = 0;
for (int i = b.x1; i <= b.x2; i++) vis[i][b.y1] = vis[i][b.y2] = 0;
for (int i = b.y1; i <= b.y2; i++) vis[b.x1][i] = vis[b.x2][i] = 0;
return cnt == tot;
}
inline bool samer(int a, int b) { return !strcmp(str[a] + 1, str[b] + 1); }
inline bool samec(int a, int b) {
for (int i = 1; i <= n; i++)
if (tep[i][a] != tep[i][b]) return 0;
return 1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
int r = 0, c = 0;
for (int i = 1; i <= n;) {
int j;
for (j = i + 1; j <= n; j++)
if (!samer(i, j)) break;
int now = 0, id[7];
if (j - i <= 6) {
id[0] = i;
id[1] = i + 1;
id[2] = i + 2;
id[3] = i + 3;
id[4] = i + 4;
id[5] = i + 5;
} else {
id[0] = i;
id[1] = i + 1;
id[2] = i + 2;
id[3] = j - 3;
id[4] = j - 2;
id[5] = j - 1;
}
for (int t = 1; t <= min(j - i, 6); t++) {
r++, factr[r] = id[now++];
for (int p = 1; p <= m; p++) tep[r][p] = str[i][p];
}
i = j;
}
for (int i = 1; i <= m;) {
int j;
for (j = i + 1; j <= m; j++)
if (!samec(i, j)) break;
int now = 0, id[7];
if (j - i <= 6) {
id[0] = i;
id[1] = i + 1;
id[2] = i + 2;
id[3] = i + 3;
id[4] = i + 4;
id[5] = i + 5;
} else {
id[0] = i;
id[1] = i + 1;
id[2] = i + 2;
id[3] = j - 3;
id[4] = j - 2;
id[5] = j - 1;
}
for (int t = 1; t <= min(j - i, 6); t++) {
c++, factc[c] = id[now++];
for (int p = 1; p <= r; p++) mat[p][c] = tep[p][i];
}
i = j;
}
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++)
if (mat[i][j] == '#') tot++;
for (int x1 = 1; x1 <= r; x1++)
for (int y1 = 1; y1 <= c; y1++)
if (mat[x1][y1] == '#')
for (int x2 = x1 + 1; x2 <= r; x2++)
for (int y2 = y1 + 1; y2 <= c; y2++)
if (mat[x2][y2] == '#') {
if (check(x1, y1, x2, y2)) arr.push_back((squ){x1, y1, x2, y2});
}
int sz = arr.size();
for (int i = 0; i < sz; i++)
for (int j = i; j < sz; j++) {
if (cover(arr[i], arr[j])) {
puts("YES");
arr[i].print();
arr[j].print();
return 0;
}
}
puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
using namespace std;
const long long MAX = -1000000000000000000;
const long long MIN = 1000000000000000000;
const long long inf = 1000000000;
const long long KOK = 100000;
const long long LOG = 30;
const long long li = 500005;
const long long mod = 1000000007;
int n, m, b[li], a[li], k, flag, t, fa[li], si[li], vis[li], visit[li], x[li],
y[li], use[li];
int cev;
queue<int> q;
set<pair<long long, long long> > st;
string s;
vector<int> v[li], vec;
inline int dsu(int x) {
if (x == fa[x]) return x;
return fa[x] = dsu(fa[x]);
}
int main(void) {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= k; i++) {
scanf("%d %d", &x[i], &y[i]);
use[x[i]]++;
use[y[i]]++;
v[x[i]].push_back(i);
v[y[i]].push_back(i);
}
for (int i = 1; i <= k; i++) {
if (use[x[i]] <= a[x[i]] || use[y[i]] <= a[y[i]]) q.push(i);
}
while (q.size()) {
int node = q.front();
q.pop();
if (vis[node]) continue;
vis[node] = 1;
vec.push_back(node);
use[x[node]]--;
use[y[node]]--;
int nodee = node;
node = x[node];
for (int i = 0; i < (int)v[node].size(); i++) {
if ((use[x[v[node][i]]] <= a[x[v[node][i]]] ||
use[y[v[node][i]]] <= a[y[v[node][i]]]) &&
vis[v[node][i]] == 0)
q.push(v[node][i]);
}
node = y[nodee];
for (int i = 0; i < (int)v[node].size(); i++) {
if ((use[x[v[node][i]]] <= a[x[v[node][i]]] ||
use[y[v[node][i]]] <= a[y[v[node][i]]]) &&
vis[v[node][i]] == 0)
q.push(v[node][i]);
}
}
if ((int)vec.size() != k) {
printf("DEAD\n");
return 0;
}
printf("ALIVE\n");
reverse(vec.begin(), vec.end());
for (int i = 0; i < (int)vec.size(); i++) {
printf("%d ", vec[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const long long int mod = 1e9 + 7;
const long long int inf = 1LL << 30;
const int MAXN = 1e5 + 5;
void cp() {
int n;
cin >> n;
vector<int> arr(n), freq(100);
for (int &x : arr) cin >> x, x--, freq[x]++;
int ans = 0;
int most = 0, mx = 0;
for (int i = 0; i < 100; i++)
if (freq[i] > mx) mx = freq[i], most = i;
for (int i = 0; i < 100; i++)
if (i != most && freq[i] == mx) ans = n;
vector<int> pref(2 * n + 1);
for (int k = 0; k < 100; k++) {
if (k == most) continue;
fill(pref.begin(), pref.end(), 2 * n);
pref[0 + n] = -1;
int sum = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == most)
sum++;
else if (arr[i] == k)
sum--;
int p = pref[sum + n];
ans = max(ans, i - p);
pref[sum + n] = min(pref[sum + n], i);
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const char nl = '\n';
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
vector<int> b;
for (auto &it : a) {
cin >> it;
b.push_back(it);
}
for (int i = 0; i < n; i++) b.push_back(a[i]);
int ans = 0, cnt = 0;
for (int i = 0; i < b.size(); i++) {
if (b[i] == 1) {
cnt++;
ans = max(ans, cnt);
} else
cnt = 0;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long double pie = 3.1415926535;
bool debug_mode;
using namespace std;
long long fpow(long long n, long long p) {
if (debug_mode) cout << "@fpow " << n << " " << p << endl;
long long m = 1;
while (p) {
if (p % 2) m *= n;
p >>= 1;
n *= n;
}
return m;
}
long long mfpow(long long n, long long p, long long M) {
if (debug_mode) cout << "@mfpow " << n << " " << p << " " << M << endl;
long long m = 1;
n %= M;
while (p) {
if (p % 2) m = (m * n) % M;
n = (n * n) % M;
p >>= 1;
}
return m % M;
}
long long min() { return 1e18; }
long long min(long long a) { return a; }
long long min(long long a, long long b) {
if (debug_mode) cout << "@min " << a << " " << b << endl;
if (a < b)
return a;
else
return b;
}
template <typename... Args>
long long min(long long a, long long b, Args... args) {
if (debug_mode) cout << "@min " << a << " " << b << endl;
if (a < b)
return min(a, args...);
else
return min(b, args...);
}
long long max() { return -1e18; }
long long max(long long a) { return a; }
long long max(long long a, long long b) {
if (debug_mode) cout << "@max " << a << " " << b << endl;
if (a < b)
return b;
else
return a;
}
template <typename... Args>
long long max(long long a, long long b, Args... args) {
if (debug_mode) cout << "@max " << a << " " << b << endl;
if (a < b)
return max(b, args...);
else
return max(a, args...);
}
const vector<long long> days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool br1, br2, br;
char ch, ch1, ch2;
long long n, k, x, y, z, mini, maxi, l, ind, ini, sum, t, len, r, w, imini, m;
pair<long long, long long> p;
string s, s1, s2;
long long a[(int)1e6 + 100];
void solve() {
cin >> t;
while (t--) {
cin >> n >> m >> k;
z = m;
maxi = 0;
k = 0;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 1; i < n; i += 2) {
if (m < a[i]) {
if (m >= a[i - 1]) k = i;
} else {
k = i + 1;
m -= a[i];
}
}
if (n % 2 && k == n - 1 && m >= a[n - 1]) k++;
maxi = max(maxi, k);
z -= a[0];
for (int i = 2; i < n; i += 2) {
if (z < a[i]) {
if (z >= a[i - 1]) k = i;
} else {
k = i + 1;
z -= a[i];
}
}
if ((n - 1) % 2 && k == n - 1 && m >= a[n - 1]) k++;
maxi = max(maxi, k);
cout << maxi << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, next;
} a[200010];
int f[100010][310];
int fa[100010], son[100010], dep[100010], top[100010], size[100010];
int head[100010], h[100010], in[100010], out[100010], num[100010], c[100010],
g[100010], n, q, k, m, r, cl, tot;
inline int rd() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x;
}
inline void print(int x) {
static char s[233];
if (!x) {
putchar('0');
putchar('\n');
return;
}
int tot = 0;
for (; x; x /= 10) s[++tot] = x % 10 + '0';
for (; tot; tot--) putchar(s[tot]);
putchar('\n');
}
inline bool cmp(const int &x, const int &y) { return h[x] < h[y]; }
inline int pls(const int x, const int y) {
return (x + y < 1000000007) ? x + y : x + y - 1000000007;
}
inline int mns(const int x, const int y) {
return (x - y < 0) ? x - y + 1000000007 : x - y;
}
inline void link(int x, int y) {
a[++tot].t = y;
a[tot].next = head[x];
head[x] = tot;
}
inline int lca(int x, int y) {
for (; top[x] != top[y]; x = fa[top[x]])
if (dep[top[x]] < dep[top[y]]) swap(x, y);
if (dep[x] > dep[y]) swap(x, y);
return x;
}
inline void dfs1(int x) {
size[x] = 1;
for (int i = head[x]; i; i = a[i].next) {
int t = a[i].t;
if (t == fa[x]) continue;
dep[t] = dep[x] + 1;
fa[t] = x;
dfs1(t);
size[x] += size[t];
if (size[t] > size[son[x]]) son[x] = t;
}
}
inline void dfs2(int x, int tp) {
in[x] = ++cl;
top[x] = tp;
if (son[x]) dfs2(son[x], tp);
for (int i = head[x]; i; i = a[i].next) {
int t = a[i].t;
if (t == fa[x] || t == son[x]) continue;
dfs2(t, t);
}
out[x] = cl;
}
inline void add(int x, int y) {
for (; x <= n; x += (x & -x)) c[x] = pls(c[x], y);
}
inline int sum(int x) {
int res = 0;
for (; x; x -= (x & -x)) res = pls(res, c[x]);
return res;
}
int main() {
n = rd();
q = rd();
tot = 0;
for (int i = 1; i < n; i++) {
int x = rd(), y = rd();
link(x, y);
link(y, x);
}
cl = 0;
dep[1] = 1;
dfs1(1);
dfs2(1, 1);
while (q--) {
k = rd();
m = rd();
r = rd();
for (int i = 1; i <= k; i++) num[i] = rd();
for (int i = 1; i <= k; i++)
add(in[num[i]], 1), add(out[num[i]] + 1, 1000000007 - 1);
for (int i = 1; i <= k; i++) {
int hh = lca(num[i], r);
h[num[i]] =
sum(in[num[i]]) + sum(in[r]) - sum(in[hh]) - sum(in[fa[hh]]) - 1;
}
for (int i = 1; i <= k; i++) g[i] = num[i];
sort(g + 1, g + k + 1, cmp);
f[0][0] = 1;
for (int i = 1; i <= m; i++) f[0][i] = 0;
for (int i = 1; i <= k; i++)
for (int j = 1; j <= m; j++)
f[i][j] = pls((long long)f[i - 1][j] * (j - h[g[i]]) % 1000000007,
f[i - 1][j - 1]);
int ans = 0;
for (int i = 0; i <= m; i++) ans = pls(ans, f[k][i]);
print(ans);
for (int i = 1; i <= k; i++)
add(in[num[i]], 1000000007 - 1), add(out[num[i]] + 1, 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
struct node
{
int val, num;
bool operator< (const node &x) const
{
return val < x.val;
}
int operator* (const node &x) const
{
return val * x.val;
}
} a[100005];
void solve()
{
int n, cnt = 0;
cin >> n;
for (int i(1); i <= n; ++i)
{
cin >> a[i].val;
a[i].num = i;
}
sort(a + 1, a + n + 1);
for (int i(1); i < n; ++i)
for (int j(i + 1); j <= n && a[i] * a[j] <= 4 * n; ++j)
if (a[i].num + a[j].num == a[i].val * a[j].val)
++cnt;
cout << cnt << endl;
return;
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--)
solve();
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> s;
int mask = 0;
n = s.size();
int ok100001 = (s[0] == '1');
for (int i = 1; i + 1 < n; ++i) ok100001 &= (s[i] == '0');
ok100001 &= (s.back() <= '1');
if (ok100001) {
for (int i = 0; i < n - 2; ++i) cout << 9;
cout << "\n";
continue;
}
for (int i = 0; i < n; ++i) mask ^= 1 << (s[i] - 48);
for (int i = n - 1; i >= 0; --i) {
mask ^= 1 << (s[i] - 48);
if (s[i] == '0') continue;
int popcnt = __builtin_popcount(mask);
if (popcnt > n - i) continue;
if (popcnt % 2 != (n - i) % 2) continue;
if (popcnt < n - i ||
(popcnt == n - i && __builtin_ctz(mask) < s[i] - 48)) {
int curdigit = s[i] - 48 - 1;
if (popcnt == n - i)
for (; curdigit >= 0; --curdigit)
if (mask & (1 << curdigit)) break;
s[i] = curdigit + '0';
mask ^= 1 << curdigit;
for (int j = i + 1; j < n; ++j) {
curdigit = 9;
if (__builtin_popcount(mask) == n - j)
for (; curdigit >= 0; --curdigit)
if (mask & (1 << curdigit)) break;
s[j] = curdigit + '0';
mask ^= 1 << curdigit;
}
break;
}
}
cout << s << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
int ctoi(char c);
int main() {
int n = 0, i, j;
char s[100001], p[100001];
int len_s, len_p;
int table_p[26] = {0}, table_s[27] = {0};
scanf("%s", s);
scanf("%s", p);
len_s = strlen(s);
len_p = strlen(p);
if (len_s < len_p) {
printf("0\n");
return 0;
}
for (i = 0; i < len_p; i++) {
table_s[ctoi(s[i])]++;
table_p[ctoi(p[i])]++;
}
for (i = 0; i < len_s - len_p + 1; i++) {
int diff = 0;
for (j = 0; j < 26; j++) {
int d = table_p[j] - table_s[j];
if (0 <= d) {
diff += d;
} else
break;
}
if (26 <= j && table_s[26] == diff) n++;
table_s[ctoi(s[i])]--;
table_s[ctoi(s[i + len_p])]++;
}
printf("%d\n", n);
return 0;
}
int ctoi(char c) {
if (c == '?' || c == '\0')
return 26;
else
return c - 'a';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
int n, m;
bool isPossible = false;
for (n = 0; n < s / 4 + 1; n++) {
for (m = 0; m < s / 7 + 1; m++) {
if ((7 * m + 4 * n) == s) {
isPossible = true;
break;
}
}
if (isPossible == true) break;
}
if (isPossible == true) {
for (int i = 0; i < n; i++) cout << "4";
for (int i = 0; i < m; i++) cout << "7";
} else
cout << "-1";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[1000100], y[1000100], d[256];
int main() {
string a, b;
int N, m, n, X = 0, Y = 0, A = 0, B = 0, lcm;
d['R'] = 0;
d['S'] = 1;
d['P'] = 2;
cin >> N >> a >> b;
m = int(a.size());
n = int(b.size());
for (int i = 1; i <= 1000000; i++)
if (i % m == 0 && i % n == 0) {
lcm = i;
break;
}
for (int i = 0; i < lcm; i++)
if (a[i % m] != b[i % n]) {
int t = d[a[i % m]], u = d[b[i % n]];
if ((t + 1) % 3 == u)
x[i] = 1, A++;
else
y[i] = 1, B++;
}
X = N / lcm * A;
Y = N / lcm * B;
for (int i = 0; i < N % lcm; i++) X += x[i], Y += y[i];
cout << Y << ' ' << X << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, A[10000][2], t = 0, t1 = 0, t2 = 0;
cin >> n;
int lz = 0, lo = 0, rz = 0, ro = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
cin >> A[i][j];
if (j == 0 && A[i][j] == 0) lz++;
if (j == 0 && A[i][j] == 1) lo++;
if (j == 1 && A[i][j] == 0) rz++;
if (j == 1 && A[i][j] == 1) ro++;
}
}
if (((lz == n) && (ro == n || rz == n)) ||
((lo == n) && (rz == n || ro == n)))
cout << 0 << endl;
else {
if (lo < lz)
t1 = n - lz;
else
t1 = n - lo;
if (ro < rz)
t2 = n - rz;
else
t2 = n - ro;
t = t1 + t2;
cout << t << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
int inf = 2e9;
long long int linf = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000;
const int maxn = 1e5 + 200;
queue<pair<long long int, long long int> > q;
long long int ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int k;
cin >> k;
if (k > m + n - 2) {
cout << -1;
return 0;
}
long long int u = 0, l = 0;
u = min(m - 1, k);
l = k - u;
ans = max(ans, ((m / (u + 1)) * (n / (l + 1))));
l = min(n - 1, k);
u = k - l;
ans = max(ans, ((m / (u + 1)) * (n / (l + 1))));
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
set<int> s;
for (int i = 0; i < n; i++) {
int ii = i + (a[i] % n);
ii += n;
ii %= n;
s.insert(ii);
}
if (s.size() == n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205, M = 1e6 + 1, INF = 0x3f3f3f3f;
queue<int> q;
char a[N][N];
int n, m, tot, ans, S, T;
int h[M], cur[M], dis[M];
struct edge {
int t, n, w;
} e[M];
inline void input() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
}
inline void add_edge(int x, int y, int w) {
e[++tot] = (edge){y, h[x], w}, h[x] = tot;
e[++tot] = (edge){x, h[y], 0}, h[y] = tot;
}
inline void init() {
vector<int> h, w;
tot = 1, S = (m + m + 1) * n + m + 1, T = S + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] == '#') {
h.clear(), w.clear(), ans += 2;
if (a[i + 1][j] == '#') h.push_back((m + m + 1) * i + j);
if (a[i - 1][j] == '#') h.push_back((m + m + 1) * (i - 1) + j);
if (a[i][j - 1] == '#') w.push_back((m + m + 1) * (i - 1) + j + m);
if (a[i][j + 1] == '#') w.push_back((m + m + 1) * (i - 1) + j + m + 1);
for (int x : h) add_edge(S, x, 1), ans--;
for (int x : w) add_edge(x, T, 1), ans--;
for (int u : h)
for (int v : w) add_edge(u, v, 2);
}
}
inline int bfs() {
memset(dis, 0, T + 1 << 2), memcpy(cur, h, T + 1 << 2), q.push(S), dis[S] = 1;
for (int u; !q.empty(); q.pop())
for (int i = h[u = q.front()], v; v = e[i].t, i; i = e[i].n)
if (e[i].w && !dis[v]) dis[v] = dis[u] + 1, q.push(v);
return dis[T];
}
inline int dfs(int u, int res) {
if (!res || u == T) return res;
int out = 0, f;
for (int &i = cur[u], v; v = e[i].t, i; i = e[i].n)
if (dis[v] == dis[u] + 1) {
f = dfs(v, min(e[i].w, res)), res -= f, out += f, e[i].w -= f,
e[i ^ 1].w += f;
if (!res) return out;
}
return out;
}
inline void work() {
while (bfs()) ans += dfs(S, INF);
cout << ans / 2;
}
int main() {
input();
init();
work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int mod = 1051131;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = (1 << (25)) + 10;
int m, s, a[N], ans;
int g[40][40];
long long t;
int main() {
scanf("%d%I64d%d", &m, &t, &s);
for (int i = 1; i < (int)s + 1; i++) scanf("%d", a + i);
for (int i = s + 1; i < (int)(1 << (m)) + 1; i++)
a[i] = (a[i - s] * 101 + 10007) % mod;
a[0] = a[(1 << (m))];
for (int i = 0; i < (int)m; i++) {
int len = (1 << (i));
for (int j = 0; j < (1 << (m)); j += len + len) {
for (int k = j; k < j + len; k++) {
int x1 = a[k], x2 = a[k + len];
a[k] = x1 - x2;
a[k + len] = x1 + x2;
}
}
if (i % 10 == 9)
for (int j = 0; j < (int)(1 << (m)); j++) a[j] %= mod;
}
for (int i = 1; i < (int)m + 1; i++) {
for (int j = 0; j < (int)i - 1; j++) g[i][j] = g[i - 1][j] * 2 - 1;
g[i][i - 1] = (i - 2) * (1 << (i - 1)) + 1;
g[i][i] = i * (1 << (i - 1)) + 1;
}
int l = 0;
for (int i = 0; i < (int)m + 1; i++) {
long long p = powmod(g[m][i], t);
int r = l + (i == m ? 1 : (1 << (m - i - 1)));
for (int j = l; j < (int)r; j++) a[j] = a[j] * p % mod;
l = r;
}
for (int i = 0; i < (int)(1 << (m)); i++)
if (a[i] < 0) a[i] += mod;
for (int i = m - 1; i >= 0; i--) {
int len = (1 << (i));
for (int j = 0; j < (1 << (m)); j += len + len) {
for (int k = j; k < j + len; k++) {
int x1 = a[k], x2 = a[k + len];
a[k] = x1 + x2;
a[k + len] = x2 - x1;
}
}
if (i % 10 == 9)
for (int j = 0; j < (int)(1 << (m)); j++) a[j] %= mod;
}
long long inv2 = powmod((mod + 1) / 2, m);
for (int i = 0; i < (int)(1 << (m)); i++) {
a[i] = a[i] * inv2 % mod;
if (a[i] < 0) a[i] += mod;
ans ^= a[i];
}
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, r[501], c[501], d1, d2;
int main() {
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int xx;
cin >> xx;
r[i] += xx;
c[j] += xx;
if (i == j) d1 += xx;
if (i == n + 1 - j) d2 += xx;
if (!xx) x = i, y = j;
}
}
r[0] = r[n];
long long res = r[x - 1] - r[x];
if (res <= 0) {
cout << -1;
return 0;
}
r[x] += res;
c[y] += res;
if (x == y) d1 += res;
if (x == n + 1 - y) d2 += res;
for (long long i = 1; i <= n; i++) {
if (r[i] != r[x] || c[i] != r[x]) {
cout << -1;
return 0;
}
}
if (d1 != r[x] || d2 != r[x]) {
cout << -1;
return 0;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int m[5];
int w[5];
int i, hs, hu, v, s;
for (i = 0; i < 5; i++) {
scanf("%d", &m[i]);
}
for (i = 0; i < 5; i++) {
scanf("%d", &w[i]);
}
scanf("%d%d", &hs, &hu);
s = 0;
for (i = 0; i < 5; i++) {
v = (250 - m[i]) * 2 * (i + 1) - 50 * w[i];
if (v < 150 * (i + 1)) v = 150 * (i + 1);
s += v;
}
s += 100 * hs - 50 * hu;
printf("%d\n", s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long P1 = 13331, P2 = 1000007;
long long Pw[2][N];
void init() {
Pw[0][0] = Pw[1][0] = 1;
for (int(i) = (1); (i) <= (1000000); ++(i)) {
Pw[0][i] = Pw[0][i - 1] * P1;
Pw[1][i] = Pw[1][i - 1] * P2;
}
}
int n, m, edge[N][2];
pair<long long, long long> ha[N];
void add(pair<long long, long long> &pll, int j) {
pll.first += Pw[0][j + 1];
pll.second += Pw[1][j + 1];
}
int main() {
init();
scanf("%d%d", &n, &m);
for (int(i) = (0); (i) <= (m - 1); ++(i)) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
add(ha[u], v);
add(ha[v], u);
edge[i][0] = u;
edge[i][1] = v;
}
long long ans = 0;
for (int(i) = (0); (i) <= (m - 1); ++(i)) {
int u = edge[i][0], v = edge[i][1];
pair<long long, long long> hu = ha[u], hv = ha[v];
add(hu, u);
add(hv, v);
if (hu == hv) ++ans;
}
sort(ha, ha + n);
int last = 0;
for (int(i) = (1); (i) <= (n - 1); ++(i))
if (ha[i] != ha[i - 1]) {
ans += (i - last) * 1ll * (i - last - 1) / 2;
last = i;
}
ans += (n - last) * 1ll * (n - last - 1) / 2;
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int abs1(long long int a) {
if (a < 0)
return -1 * a;
else
return a;
}
long long int power(long long int base, long long int n, long long int M) {
if (n == 0) return 1;
if (n == 1) return base;
long long int halfn = power(base, n / 2, M);
if (n % 2 == 0)
return (halfn * halfn) % M;
else
return (((halfn * halfn) % M) * base) % M;
}
long long int findMMI(long long int n, long long int M) {
return power(n, M - 2, M);
}
long long int max2(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int max3(long long int a, long long int b, long long int c) {
max2(max2(a, b), c);
}
long long int min2(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
long long int min3(long long int a, long long int b, long long int c) {
return min2(min2(a, b), c);
}
struct node {
int prop, left, right;
};
void build(node sg[], char in[], int low, int high, int pos) {
if (low == high) {
sg[pos].prop = 0;
if (in[low] == '(') {
sg[pos].left = 1;
sg[pos].right = 0;
} else {
sg[pos].left = 0;
sg[pos].right = 1;
}
return;
}
int mid = (low + high) / 2;
build(sg, in, low, mid, 2 * pos + 1);
build(sg, in, mid + 1, high, 2 * pos + 2);
int pr = sg[2 * pos + 1].left < sg[2 * pos + 2].right ? sg[2 * pos + 1].left
: sg[2 * pos + 2].right;
sg[pos].left = sg[2 * pos + 1].left + sg[2 * pos + 2].left - pr;
sg[pos].right = sg[2 * pos + 1].right + sg[2 * pos + 2].right - pr;
sg[pos].prop = sg[2 * pos + 1].prop + sg[2 * pos + 2].prop + pr * 2;
}
node findIt(node sg[], int l, int h, int low, int high, int pos) {
if (l <= low && h >= high) return sg[pos];
node t;
t.prop = 0;
t.left = 0;
t.right = 0;
if (l > high || h < low) return t;
int mid = (low + high) / 2;
node a = findIt(sg, l, h, low, mid, 2 * pos + 1);
node b = findIt(sg, l, h, mid + 1, high, 2 * pos + 2);
node fin;
fin.prop = 0;
fin.left = 0;
fin.right = 0;
int pr = a.left < b.right ? a.left : b.right;
fin.left = a.left + b.left - pr;
fin.right = a.right + b.right - pr;
fin.prop = a.prop + b.prop + pr * 2;
return fin;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
char s[1000001];
cin >> s;
int k = strlen(s);
long long int si = (k * 2);
si = (si * 2) - 1;
node *sg;
sg = new node[si];
build(sg, s, 0, k - 1, 0);
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
cout << findIt(sg, l - 1, r - 1, 0, k - 1, 0).prop << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, price, p[100001], a[100001], ans;
int main() {
scanf("%d", &n);
int price = 1001;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i], &p[i]);
price = min(price, p[i]);
ans += price * a[i];
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long l = -2000000000, r = 2000000000;
for (int i = 0; i < n; i++) {
string op;
long long y;
string pred;
cin >> op >> y >> pred;
if (pred == "N") {
if (op == ">")
op = "<=";
else if (op == "<")
op = ">=";
else if (op == ">=")
op = "<";
else if (op == "<=")
op = ">";
}
if (op == ">")
l = max(l, y + 1);
else if (op == "<")
r = min(r, y - 1);
else if (op == ">=")
l = max(l, y);
else if (op == "<=")
r = min(r, y);
if (l > r) {
cout << "Impossible" << endl;
return 0;
}
}
cout << l << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400001;
const long long P = 1000000007;
int i, j, n, m, x, y, L, R, v[N], tot;
long long a[N], b[N], sum[N], t, q[N];
void cal(int flag) {
L = 1;
R = 0;
for (i = 1, j = 0; i <= n; i++) {
while (j + 1 < i + n) {
j++;
while (L <= R && sum[q[R]] >= sum[j]) R--;
q[++R] = j;
}
while (q[L] < i) L++;
if (sum[q[L]] - sum[i - 1] >= 0)
if (!flag || i == 1)
v[i] = 1;
else
v[n + 2 - i] = 1;
}
}
void pr() {
for (int i = 1; i < 2 * n; i++) cout << sum[i] << ' ';
cout << endl;
}
void work() {
if (n == 1) {
printf("1\n1\n");
return;
}
for (i = 1; i <= n; i++) sum[i] = a[i] - b[i];
for (i = n + 1; i < 2 * n; i++) sum[i] = sum[i - n];
for (i = 1; i < 2 * n; i++) sum[i] += sum[i - 1];
cal(0);
sum[1] = a[1] - b[n];
for (i = n, j = 2; i >= 2; i--, j++) sum[j] = a[i] - b[i - 1];
for (i = n + 1; i < 2 * n; i++) sum[i] = sum[i - n];
for (i = 1; i < 2 * n; i++) sum[i] += sum[i - 1];
cal(1);
for (i = 1; i <= n; i++)
if (v[i]) tot++;
cout << tot << endl;
for (i = 1, j = 0; i <= n; i++)
if (v[i])
if (j + 1 < tot)
cout << i << ' ', j++;
else
cout << i << endl;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> b[i];
work();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dp[4100][4100];
long long m;
long long factor[1000001];
long long fact(long long n);
long long power(long long a, long long b, long long f1) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > f1) x %= f1;
}
y = (y * y);
if (y > f1) y %= f1;
b /= 2;
}
return x;
}
long long fact(long long n, long long f1) { return power(n, f1 - 2, f1); }
long long nCr(long long n, long long r, long long f1) {
return (factor[n] * ((fact(factor[r], f1) * fact(factor[n - r], f1)) % f1)) %
f1;
}
template <typename T>
T ma(T x, T y) {
return (x > y) ? x : y;
}
bool subset(vector<long long> &v, long long n, long long sum) {
if (sum == 0) return true;
if (n == 0) return false;
if (v[n - 1] > sum) {
return subset(v, n - 1, sum);
}
return subset(v, n - 1, sum) || subset(v, n - 1, sum - v[n - 1]);
}
long long ans1 = 0;
long long ans2 = 0;
long long quesc(long long left, long long right, long long a[]) {
if (dp[left][right] != -1) {
return dp[left][right];
}
if (left == right) {
return dp[left][right] = 0ll;
}
return dp[left][right] =
a[right] - a[left] +
min(quesc(left + 1, right, a), quesc(left, right - 1, a));
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
long long prime[1000001];
long long dp1[200007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t, n, i, j, k;
long long ans = 0;
for (i = 1; i <= 1000000; i++) prime[i] = 1;
prime[1] = 0;
for (i = 2; i * i <= 100000; i++) {
if (prime[i]) {
for (j = i * i; j <= 100000; j = j + i) {
prime[j] = 0;
}
}
}
for (i = 2; i <= 100000; i++) {
if (prime[i]) {
ans++;
}
}
factor[0] = 1;
for (i = 1; i <= 1000001; i++) {
factor[i] = (factor[i - 1] * i) % 1000000007;
}
t = 1;
cin >> t;
while (t--) {
long long x;
cin >> n >> x;
long long a[n + 1];
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
long long g = 0, f = 0;
for (i = 1; i <= n; i++) {
if (a[i] == x) {
g = 1;
}
if (a[i] > x / 2 && x % 2 == 0) {
f = 1;
}
if (a[i] >= x / 2 + 1 && x % 2 == 1) {
f = 1;
}
}
if (g == 1) {
cout << 1 << endl;
} else if (f == 1) {
cout << 2 << endl;
} else {
long long d = x / a[n];
if (x % a[n] != 0) {
d = d + 1;
}
cout << d << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long compute(long long a, long long b, long long c) {
return 4 + 4 * a + 2 * b + 2 * c + b * c + 2 * a * b + 2 * a * c;
}
long long n;
void leggi() { cin >> n; }
vector<long long> divs;
void elabora() {
for (long long i = 1; i <= int(sqrt(n)); i += 1) {
if (n % i == 0) {
divs.push_back(i);
}
}
divs.push_back(n);
long long maxi = 0;
long long mini = numeric_limits<long long>::max();
for (int i = 0; i < divs.size(); i += 1) {
for (int j = i; j < divs.size(); j += 1) {
if ((n / divs[i]) % divs[j] == 0) {
long long v = compute(divs[i], divs[j], (n / divs[i]) / divs[j]);
maxi = max(maxi, v);
mini = min(mini, v);
v = compute(divs[j], divs[i], (n / divs[i]) / divs[j]);
maxi = max(maxi, v);
mini = min(mini, v);
}
}
}
cout << mini << " " << maxi << endl;
}
int main() {
leggi();
elabora();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void re(int& x);
template <class T, class... Ts>
void re(T& t, Ts&... ts);
int n;
vector<int> g[51];
int sz[51];
double probs[55][55][55];
double dp[55][55][55][55];
double totprob[55][55][5];
void merge(int a, int b) {
memset(totprob, 0, sizeof(totprob));
totprob[0][0][0] = 1;
for (int took_a = 0; took_a <= sz[a]; took_a++) {
for (int took_b = 0; took_b <= sz[b]; took_b++) {
for (int merged_b = 0; merged_b <= 1; merged_b++) {
int rem_a = (sz[a] - took_a);
int rem_b = (sz[b] - took_b);
double tot = rem_a + rem_b + !merged_b;
double pick_a = rem_a / tot;
double pick_b = rem_b / tot;
double pick_m = (!merged_b) / tot;
if (rem_a)
totprob[took_a + 1][took_b][merged_b] +=
totprob[took_a][took_b][merged_b] * pick_a;
if (rem_b)
totprob[took_a][took_b + 1][merged_b] +=
totprob[took_a][took_b][merged_b] * pick_b;
if (!merged_b)
totprob[took_a][took_b][merged_b + 1] +=
totprob[took_a][took_b][merged_b] * pick_m;
}
}
}
for (int from = sz[a] + sz[b] + 1; from >= 0; from--) {
for (int took_a = 0; took_a <= sz[a]; took_a++) {
for (int took_b = from - took_a - 1; took_b <= sz[b]; took_b++) {
for (int merged_a = 0; merged_a <= min(from, took_a); merged_a++) {
for (int merged_b = 0; merged_b <= took_b + 1; merged_b++) {
dp[took_a][took_b][merged_a][merged_b] = 0;
}
}
}
}
for (int took_a = 0; took_a <= sz[a]; took_a++) {
for (int took_b = 0; took_b <= sz[b]; took_b++) {
for (int merged_a = 0; merged_a <= min(from, took_a); merged_a++) {
for (int merged_b = 0; merged_b <= took_b + 1; merged_b++) {
if (took_a + took_b + !!merged_b < from) continue;
if (took_a + took_b + !!merged_b == from) {
dp[took_a][took_b][merged_a][merged_b] = 0;
if (merged_b)
dp[took_a][took_b][took_a][took_b + 1] =
totprob[took_a][took_b][1];
else
dp[took_a][took_b][took_a][0] = totprob[took_a][took_b][0];
}
int rem_a = (sz[a] - took_a);
int rem_b = (sz[b] - took_b);
double tot = rem_a + rem_b + !merged_b;
double pick_a = rem_a / tot;
double pick_b = rem_b / tot;
double pick_m = (!merged_b) / tot;
if (rem_a)
dp[took_a + 1][took_b][merged_a][merged_b] +=
dp[took_a][took_b][merged_a][merged_b] * pick_a *
probs[a][merged_a][took_a + 1] / probs[a][merged_a][took_a];
if (rem_b) {
if (merged_b)
dp[took_a][took_b + 1][merged_a][merged_b] +=
dp[took_a][took_b][merged_a][merged_b] * pick_b *
probs[b][merged_b - 1][took_b + 1] /
probs[b][merged_b - 1][took_b];
else
dp[took_a][took_b + 1][merged_a][merged_b] +=
dp[took_a][took_b][merged_a][merged_b] * pick_b;
}
if (!merged_b)
dp[took_a][took_b][merged_a][took_b + 1] +=
dp[took_a][took_b][merged_a][merged_b] * pick_m * 0.5;
}
}
}
}
for (int j = from; j <= sz[a] + sz[b] + 1; j++) {
probs[a][from][j] = 0;
}
for (int took_a = 0; took_a <= sz[a]; took_a++) {
for (int took_b = from - took_a - 1; took_b <= sz[b]; took_b++) {
for (int merged_a = 0; merged_a <= min(from, took_a); merged_a++) {
for (int merged_b = 0; merged_b <= took_b + 1; merged_b++) {
if (took_a + took_b + !!merged_b >= from) {
probs[a][from][took_a + took_b + !!merged_b] +=
dp[took_a][took_b][merged_a][merged_b];
}
}
}
}
}
}
sz[a] += sz[b] + 1;
}
void dfs(int v, int p) {
sz[v] = 0;
for (int x : g[v])
if (x != p) {
dfs(x, v);
merge(v, x);
}
}
void solve() {
re(n);
if (n == 1) {
printf("1.0\n");
return;
}
for (int i = 0; i < (n - 1); ++i) {
int a, b;
re(a, b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < (n); ++i) {
dfs(i, -1);
printf("%.15f\n", probs[i][0][n - 1]);
}
}
int main() { solve(); }
void re(int& x) { scanf("%d", &x); }
template <class T, class... Ts>
void re(T& t, Ts&... ts) {
re(t);
re(ts...);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::placeholders;
bool compare(int a, int b) { return a > b; }
int main() {
int t;
int angle;
int n;
cin >> t;
while (t--) {
cin >> angle;
n = 360 % (180 - angle);
if (n)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[200000][52];
int p[200000];
int d[200000], r[200000];
bool compare(int x, int y) { return strcmp(s[x], s[y]) < 0; }
int main() {
int(n);
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
scanf("%s", (s[2 * i]));
scanf("%s", (s[2 * i + 1]));
}
for (int i = 0; i < (n); ++i) {
scanf("%d", &(p[i]));
p[i]--;
}
for (int i = 0; i < (2 * n); ++i) d[i] = i;
sort(d, d + 2 * n, compare);
for (int i = 0; i < (2 * n); ++i) r[d[i]] = i;
int now = -1;
for (int i = 0; i < (n); ++i) {
int x = r[p[i] * 2];
int y = r[p[i] * 2 + 1];
if (min(x, y) > now)
now = min(x, y);
else if (max(x, y) > now)
now = max(x, y);
else {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 3 |
#include <bits/stdc++.h>
void print_perm(const std::vector<int>& p) {
bool is_first = true;
for (const auto c : p) {
if (is_first) {
std::cout << c;
is_first = false;
} else {
std::cout << ' ' << c;
}
}
std::cout << '\n';
}
int f(const std::vector<int>& p) {
int res = 0;
for (auto i = std::begin(p); i != std::end(p); i++) {
for (auto j = i; j != std::end(p); j++) res += *std::min_element(i, j + 1);
}
return res;
}
int main() {
int n;
int m;
std::cin >> n;
std::cin >> m;
std::vector<int> p(n);
for (int i = 0; i < n; i++) p.at(i) = i + 1;
int max_p = 0;
int n_lex = 0;
std::vector<int> res;
do {
int cur_p = f(p);
if (cur_p > max_p) {
max_p = cur_p;
n_lex = 1;
if (n_lex == m) res = p;
} else if (cur_p == max_p) {
n_lex++;
if (n_lex == m) res = p;
}
} while (std::next_permutation(p.begin(), p.end()));
print_perm(res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long powm(long long base, long long exp) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
long long add(long long a, long long b) { return (a % mod + b % mod) % mod; }
long long sub(long long a, long long b) {
return (a % mod + mod - b % mod) % mod;
}
long long mult(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long choose2(long long n) {
long long ans = (n * (n - 1)) / 2;
return ans;
}
long long dist2(long long x1, long long y1, long long x2, long long y2) {
long long ans = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
long long maxi = (a * b) / gcd(a, b);
long long cnt1 = (maxi / a) - 1 + (a > b);
long long cnt2 = (maxi / b) - 1 + (b > a);
if (cnt1 > cnt2)
cout << "Dasha";
else if (cnt2 > cnt1)
cout << "Masha";
else
cout << "Equal";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + ch - 48;
}
return x * f;
}
const int mxN = 2e3;
int c[mxN + 3], a[mxN + 3], w[mxN + mxN + 3];
int f[mxN + mxN + 3][mxN + 3];
int mx[mxN + mxN + 3];
int n, m;
void updmax(int &x, int y) { x = max(x, y); }
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) c[i] = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n + m; i++) w[i] = read();
memset(f, 213, sizeof(f));
for (int i = 1; i <= n + m; i++) f[i][0] = 0;
for (int i = n; i >= 1; i--) {
for (int k = mx[c[i]]; k >= 0; k--) {
int tmp = k + 1, val = -a[i] + w[c[i]];
for (int j = 0; tmp; j++, tmp >>= 1, val += w[c[i] + j] * tmp) {
updmax(mx[c[i] + j], tmp);
updmax(f[c[i] + j][tmp], f[c[i]][k] + val);
}
}
for (int j = 1; j <= n + m; j++) {
updmax(f[j][0], max(f[j - 1][0], f[j - 1][1]));
}
}
printf("%d\n", f[n + m][0]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[n][2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
scanf("%d", &a[i][j]);
}
}
int c = 0, k = 0, m = 0;
for (int i = 0; i < n; i++) {
if (a[i][0] == a[i][1])
c++;
else if (a[i][0] == a[i][1] - 1)
m++;
else
k++;
}
if (c == n || m == n)
printf("0");
else
printf("%d", k);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, ar[MAXN], dp[MAXN];
string a;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> ar[i];
cin >> a;
for (int i = 0; i < a.size(); i++) {
dp[i + 1] += dp[i];
if (a[i] == '1') dp[i + 1]++;
}
for (int i = 0; i < n; i++) {
if (ar[i] != i + 1) {
if (ar[i] > i + 1) {
if (dp[ar[i] - 1] - dp[i] < ar[i] - (i + 1)) {
cout << "NO";
return 0;
}
} else {
if (dp[i] - dp[ar[i] - 1] < (i + 1) - ar[i]) {
cout << "NO";
return 0;
}
}
}
}
cout << "YES";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int q;
string s;
struct BIT {
int N;
vector<int> data[5][15][15];
BIT(int n) {
N = n;
for (int i = 1; i <= 10; i++) {
for (int j = 0; j < i; j++) {
for (int k = 0; k < 4; k++) {
data[k][i][j].resize(N + 5);
}
}
}
}
void update(int c, int p, int val) {
for (int q = 1; q <= 10; q++) {
for (int r = 0; r < q; r++) {
if ((p - r) % q == 0) {
for (int pp = p; pp <= N; pp += pp & -pp) {
data[c][q][r][pp] += val;
}
}
}
}
}
int query(int c, int q, int r, int p) {
int ans = 0;
for (; p > 0; p -= p & -p) {
ans += data[c][q][r][p];
}
return ans;
}
int r_query(int c, int q, int r, int s, int e) {
return query(c, q, r, e) - query(c, q, r, s - 1);
}
};
int func(char c) {
if (c == 'A') return 0;
if (c == 'G') return 1;
if (c == 'T') return 2;
if (c == 'C') return 3;
}
int main() {
cin >> s;
int n = s.size();
BIT tree(n);
for (int i = 0; i < n; i++) {
tree.update(func(s[i]), i + 1, 1);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int k;
scanf("%d", &k);
if (k == 1) {
int p;
char c;
cin >> p >> c;
tree.update(func(s[p - 1]), p, -1);
s[p - 1] = c;
tree.update(func(c), p, 1);
} else {
int l, r;
string e;
scanf("%d%d", &l, &r);
cin >> e;
int nn = e.size();
int ans = 0;
for (int j = 0; j < nn; j++) {
ans += tree.r_query(func(e[j]), nn, (j + l) % nn, l, r);
}
cout << ans << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int q;
struct node1 {
int v, sig, id;
} Q[N];
pair<int, int> c[N];
struct node {
long long tag, mx_b_2a;
int sum;
} f[N * 4];
map<int, vector<int>> w;
void upd(int s) {
f[s].sum = f[s + s].sum + f[s + s + 1].sum;
f[s].mx_b_2a = max(f[s + s].mx_b_2a, f[s + s + 1].mx_b_2a);
}
void down(int l, int r, int s) {
if (f[s].tag) {
f[s].mx_b_2a += f[s].tag;
if (l != r) f[s + s].tag += f[s].tag, f[s + s + 1].tag += f[s].tag;
f[s].tag = 0;
}
}
void ins(int l, int r, int s, pair<int, int> u, int sig) {
down(l, r, s);
if (c[l] > u || c[r] < u) return;
if (l == r) {
if (sig) {
f[s].sum = 1;
f[s].mx_b_2a += u.first;
} else {
f[s].sum = 0;
f[s].mx_b_2a -= u.first;
}
return;
}
ins(l, (l + r) / 2, s + s, u, sig);
ins((l + r) / 2 + 1, r, s + s + 1, u, sig);
upd(s);
}
void add(int l, int r, int s, pair<int, int> u, int sig) {
down(l, r, s);
if (c[r] <= u) return;
if (c[l] > u) {
if (sig)
f[s].tag -= u.first * 2;
else
f[s].tag += u.first * 2;
down(l, r, s);
return;
}
add(l, (l + r) / 2, s + s, u, sig);
add((l + r) / 2 + 1, r, s + s + 1, u, sig);
upd(s);
}
int get(int l, int r, int s) {
down(l, r, s);
if (f[s].mx_b_2a <= 0 || !f[s].sum) return 0;
if (l == r) return 1;
return get(l, (l + r) / 2, s + s) + get((l + r) / 2 + 1, r, s + s + 1);
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
char x;
scanf(" %c %d", &x, &Q[i].v);
if (Q[i].sig = (x == '+'))
w[Q[i].v].push_back(i), Q[i].id = i, c[i] = {Q[i].v, i};
else {
auto u = w.find(Q[i].v);
Q[i].id = u->second.at(u->second.size() - 1);
c[i] = {Q[i].v, i};
u->second.pop_back();
}
}
sort(c + 1, c + q + 1);
for (int i = 1; i <= q; i++) {
switch (Q[i].sig) {
case 1:
ins(1, q, 1, {Q[i].v, Q[i].id}, 1);
add(1, q, 1, {Q[i].v, Q[i].id}, 1);
break;
case 0:
ins(1, q, 1, {Q[i].v, Q[i].id}, 0);
add(1, q, 1, {Q[i].v, Q[i].id}, 0);
break;
}
printf("%d\n", f[1].sum - get(1, q, 1));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
void solve() {
long long n, i, l, ans = 0, k;
cin >> n >> k;
vector<long long> a;
for (long long i = 0; i < n; i++) {
cin >> l;
a.push_back(l);
}
if (k >= n) {
cout << a[n - 1];
return;
}
for (i = 0; i < (n - k); i++) {
ans = max(ans, a[i] + a[2 * (n - k) - 1 - i]);
}
ans = max(ans, a[n - 1]);
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int num[64], oth[64];
int check(int x) {
int res = num[0] - x;
for (int i = 1; i <= 40; i++) {
res += oth[i];
if (x > num[i]) {
res -= min(res, x - num[i]);
x = num[i];
} else
res += num[i] - x;
}
return res == 0;
}
int main() {
int n;
scanf("%d", &n);
long long ret = 1, x, cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
while (ret < x) ret *= 2, cnt++;
if ((ret ^ x) == 0)
num[cnt]++;
else
oth[cnt]++;
}
int l = 1, r = num[0], ans = -1;
while (r >= l) {
int mid = l + r >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
if (ans == -1) return 0 * printf("-1\n");
for (int i = ans; i <= num[0]; i++)
printf("%d%c", i, i == num[0] ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int ans[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
for (int i = 1; i < s.length(); i++) {
if (s[i] != s[i - 1]) ans[i - 1] = 1;
}
if (s[s.length() - 1] == 'a') ans[s.length() - 1] = 1;
for (int i = 0; i < s.length(); i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char s[n];
int ans = 0;
scanf("%300000s", s);
for (int i = 0; i < n; ++i) {
if (i > 0 and s[i] == '.' and s[i - 1] == '.') ++ans;
}
for (int i = 0; i < m; ++i) {
int pos;
scanf("%d", &pos);
--pos;
char c;
cin >> c;
if (c == '.' and s[pos] != '.') {
if (pos > 0 and s[pos - 1] == '.') ++ans;
if (pos < n and s[pos + 1] == '.') ++ans;
} else if (c != '.' and s[pos] == '.') {
if (pos > 0 and s[pos - 1] == '.') --ans;
if (pos < n and s[pos + 1] == '.') --ans;
}
s[pos] = c;
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Graph {
int n, et, ind[5011], e[61000], last[61000];
inline void adde(int a, int b) {
last[++et] = ind[a];
e[et] = b;
ind[a] = et;
}
inline void init(int nn) {
n = nn, et = 1;
memset(ind, 0, sizeof(int) * (n + 1));
}
};
struct FlowGraph : public Graph {
int S, T;
int cap[61000], f[61000];
inline void adde(int a, int b, int c) {
Graph::adde(a, b);
f[et] = 0, cap[et] = c;
}
inline void addee(int a, int b, int c) { adde(a, b, c), adde(b, a, c); }
inline void init(int nn, int s, int t) {
Graph::init(nn);
S = s, T = t;
}
};
struct ResiGraph : public FlowGraph {
int ek[61000];
bool checked[5011];
void adde(int a, int b, int c, int k) {
FlowGraph::adde(a, b, c);
ek[et] = k;
}
int dfs(int a, int flow) {
if (flow == 0) {
return 0;
}
if (a == T) return flow;
int ans = 0, now;
for (int i = ind[a]; i; i = last[i])
if (!checked[e[i]] && cap[i] - f[i]) {
now = dfs(e[i], std::min(flow, cap[i] - f[i]));
ans += now, f[i] += now, flow -= now;
}
if (flow) checked[a] = true;
return ans;
}
int blocking_flow() {
int upper_bound = 0;
memset(checked, 0, sizeof(bool) * (n + 1));
for (int i = ind[S]; i; i = last[i]) {
upper_bound += cap[i];
}
return dfs(S, upper_bound);
}
};
struct DinicGraph : public FlowGraph {
ResiGraph resi;
int que[5011], nowqt, qt, checked[5011];
int cf() {
resi.init(n, S, T);
memset(checked, 0, sizeof(int) * (n + 1));
qt = nowqt = 1;
que[1] = S;
checked[S] = 1;
for (int i = 1, j = 0, nowlv = 2; i <= qt; i++) {
if (i > nowqt) {
nowlv++, nowqt = qt;
if (checked[T]) {
break;
}
}
for (j = ind[que[i]]; j; j = last[j])
if ((!checked[e[j]] || checked[e[j]] == nowlv) && f[j] < cap[j]) {
if ((j & 1) && f[j ^ 1]) {
resi.adde(que[i], e[j], f[j ^ 1], j);
if (!checked[e[j]]) {
que[++qt] = e[j];
checked[e[j]] = nowlv;
}
} else if (!(j & 1)) {
resi.adde(que[i], e[j], cap[j] - f[j], j);
if (!checked[e[j]]) {
que[++qt] = e[j];
checked[e[j]] = nowlv;
}
}
}
}
int incr = resi.blocking_flow();
if (incr == 0) {
return 0;
}
for (int i = 1, j, k; i <= n; i++) {
for (j = resi.ind[i]; j; j = resi.last[j])
if (resi.f[j]) {
k = resi.ek[j];
if (f[k ^ 1]) {
f[k ^ 1] -= resi.f[j];
} else {
f[k] += resi.f[j];
}
}
}
return incr;
}
int maxflow() {
int ans = 0, now = cf();
while (now) {
ans += now;
now = cf();
}
return ans;
}
} G;
int i, j, r, n, m;
int p[5011], q[5011][2];
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
for (i = 1; i <= m; i++) {
scanf("%d %d", &q[i][0], &q[i][1]);
if (q[i][1] & 1) {
swap(q[i][0], q[i][1]);
}
}
int ans = 0;
for (i = 2; i <= 10000; i++) {
bool ok = false;
for (j = 1; j <= n; j++)
if (p[j] % i == 0) {
ok = true;
break;
}
if (!ok) {
continue;
}
G.init(n + 2, n + 1, n + 2);
for (j = 1; j <= n; j++) {
int k = 0;
while (p[j] % i == 0) {
p[j] /= i;
k++;
}
if (k) {
if (j & 1) {
G.addee(n + 1, j, k);
} else {
G.addee(j, n + 2, k);
}
}
}
for (j = 1; j <= m; j++) {
G.addee(q[j][0], q[j][1], 100);
}
ans += G.maxflow();
}
for (r = 1; r <= n; r++)
if (p[r] > 1) {
i = p[r];
G.init(n + 2, n + 1, n + 2);
for (j = 1; j <= n; j++) {
int k = 0;
while (p[j] % i == 0) {
p[j] /= i;
k++;
}
if (k) {
if (j & 1) {
G.addee(n + 1, j, k);
} else {
G.addee(j, n + 2, k);
}
}
}
for (j = 1; j <= m; j++) {
G.addee(q[j][0], q[j][1], 100);
}
ans += G.maxflow();
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void doRoutine() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
srand(322179);
}
const int ALP = 26;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<char> > arr(n, vector<char>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> arr[i][j];
}
}
vector<vector<pair<int, int> > > pos(ALP);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (arr[i][j] != '.') {
pos[arr[i][j] - 'a'].push_back({i, j});
}
}
}
while (pos.size() > 0 && pos.back().size() == 0) {
pos.pop_back();
}
if (pos.size() == 0) {
cout << "YES" << endl;
cout << 0 << endl;
return;
}
int resolvx, resolvy;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (arr[i][j] == (char)('a' + pos.size() - 1)) {
resolvx = i, resolvy = j;
}
}
}
vector<vector<char> > work(n, vector<char>(m, '.'));
vector<pair<pair<int, int>, pair<int, int> > > ans;
int k = pos.size();
for (int i = 0; i < k; ++i) {
set<int> rows, cols;
for (auto elem : pos[i]) {
rows.insert(elem.first);
cols.insert(elem.second);
}
if (rows.size() > 1 && cols.size() > 1) {
cout << "NO" << endl;
return;
}
if (rows.size() == 1) {
int row = *rows.begin();
int from = m + 1, to = -1;
for (auto elem : cols) {
from = min(from, elem);
to = max(to, elem);
}
for (int j = from; j <= to; ++j) {
work[row][j] = (char)('a' + i);
}
ans.push_back({{row, from}, {row, to}});
} else if (cols.size() == 1) {
int col = *cols.begin();
int from = n + 1, to = -1;
for (auto elem : rows) {
from = min(from, elem);
to = max(to, elem);
}
for (int j = from; j <= to; ++j) {
work[j][col] = (char)('a' + i);
}
ans.push_back({{from, col}, {to, col}});
} else {
ans.push_back({{resolvx, resolvy}, {resolvx, resolvy}});
}
}
if (work == arr) {
cout << "YES" << endl;
cout << k << endl;
for (auto elem : ans) {
cout << elem.first.first + 1 << " " << elem.first.second + 1 << " "
<< elem.second.first + 1 << " " << elem.second.second + 1 << endl;
}
} else {
cout << "NO" << endl;
}
}
signed main() {
doRoutine();
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (n == 0 && m > 0) {
cout << 0 << " " << 1 << '\n';
cout << 0 << " " << m << '\n';
cout << 0 << " " << 0 << '\n';
cout << 0 << " " << m - 1 << '\n';
} else if (n > 0 && m == 0) {
cout << 1 << " " << 0 << '\n';
cout << n << " " << 0 << '\n';
cout << 0 << " " << 0 << '\n';
cout << n - 1 << " " << 0 << '\n';
} else if (n == m) {
if (n > 3) {
cout << 0 << " " << 1 << '\n';
cout << n << " " << m << '\n';
cout << 0 << " " << 0 << '\n';
cout << n - 1 << " " << m << '\n';
} else {
cout << 0 << " " << 0 << '\n';
cout << n << " " << m << '\n';
cout << 0 << " " << m << '\n';
cout << n << " " << 0 << '\n';
}
} else if (n > m) {
if (n > 3 && m > 3) {
cout << 0 << " " << 1 << '\n';
cout << n << " " << m << '\n';
cout << 0 << " " << 0 << '\n';
cout << n << " " << m - 1 << '\n';
} else {
cout << 0 << " " << 0 << '\n';
cout << n << " " << m << '\n';
cout << 0 << " " << m << '\n';
cout << n << " " << 0 << '\n';
}
} else if (n < m) {
if (n > 3 && m > 3) {
cout << 1 << " " << 0 << '\n';
cout << n << " " << m << '\n';
cout << 0 << " " << 0 << '\n';
cout << n - 1 << " " << m << '\n';
} else {
cout << 0 << " " << 0 << '\n';
cout << n << " " << m << '\n';
cout << n << " " << 0 << '\n';
cout << 0 << " " << m << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void ggg() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N = 1e5 + 5;
int main() {
ggg();
int h, w;
cin >> h >> w;
long long int ans = 0;
for (int i = 2; i <= h; i += 2) {
for (int j = 2; j <= w; j += 2) {
ans += (h - i + 1) * (w - j + 1);
}
}
cout << ans << '\n';
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 25;
const int maxm = 100000+10;
const LL mo = 998244353;
int n,m;
int a[maxn][maxm];
int cnt[maxn];
LL fac;
LL A[maxn][maxn];
LL power(LL x,LL y)
{
LL ans=1;
while (y)
{
if (y&1) ans=ans*x%mo;
x=x*x%mo;
y>>=1;
}
return ans;
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
{
for (int j=1;j<=m;j++) scanf("%d",&a[i][j]);
}
for (int i=0;i<=n;i++)
{
A[i][0]=1;
for (int j=1;j<=i;j++)
{
A[i][j]=A[i][j-1]*(LL)(i-j+1)%mo;
}
}
fac=1;
for (int i=1;i<=n;i++) fac=fac*i%mo;
LL Ans=0;
for (int j=1;j<=m;j++)
{
memset(cnt,0,sizeof(cnt));
for (int i=1;i<=n;i++) cnt[a[i][j]-1]++;
//for (int i=0;i<=n;i++) printf("%d ",cnt[i]); printf("\n");
LL ans=1;
int pre=0;
for (int i=1;i<=n;i++)
{
pre+=cnt[i-1];
if (pre>i-1||pre+cnt[i]>i)
{
ans=0;
break;
}
ans=ans*A[i-pre][cnt[i]]%mo;
}
//printf("%lld\n",fac-ans);
Ans=(Ans+fac-ans+mo)%mo;
}
Ans=Ans*power(fac,mo-2)%mo;
cout << Ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int maxn = 105;
int n, dep, a[maxn], h;
char s[maxn], ans[105][300];
int main() {
n = rd();
scanf("%s", s + 1);
for (int i = int(1); i <= (int)(n); i++) {
if (s[i] == '[')
a[i] = ++dep;
else
a[i] = dep--;
}
for (int i = int(1); i <= (int)(n); i++) h = max(h, a[i] + 1);
for (int i = int(1); i <= (int)(n); i++) a[i] = h - a[i];
int col = 1;
for (int i = int(1); i <= (int)(n); i++) {
if (s[i] == '[') {
for (int j = int(h - a[i] + 1); j <= (int)(h + a[i] - 1); j++)
ans[j][col] = '|';
ans[h - a[i]][col] = '+';
ans[h + a[i]][col] = '+';
++col;
ans[h - a[i]][col] = '-';
ans[h + a[i]][col] = '-';
if (s[i + 1] == ']') col += 2;
} else {
ans[h - a[i]][col] = '-';
ans[h + a[i]][col] = '-';
++col;
for (int j = int(h - a[i] + 1); j <= (int)(h + a[i] - 1); j++)
ans[j][col] = '|';
ans[h - a[i]][col] = '+';
ans[h + a[i]][col] = '+';
if (s[i + 1] == '[') col++;
}
}
for (int i = int(1); i <= (int)(h * 2 - 1); i++)
for (int j = int(1); j <= (int)(col); j++)
if (!ans[i][j]) ans[i][j] = ' ';
for (int i = int(1); i <= (int)(h * 2 - 1); i++) puts(ans[i] + 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long m, n, c, d, i, j, k, x, y, z, l, q, r;
string s, s1, s2, s3, s4;
long long cnt = 0, ans = 0, sum = 0;
cin >> n >> m;
long long a[n + 1], b[n + 1], cmsm[n + 1];
memset(cmsm, 0, sizeof(cmsm));
for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (long long i = 1; i <= n; i++)
b[i] = a[i] * b[i], cmsm[i] = cmsm[i - 1] + b[i];
vector<long long> v;
for (long long i = 1; i <= n; i++) v.push_back(cmsm[i]);
for (long long i = 0; i < m; i++) {
cin >> x;
ans = lower_bound(v.begin(), v.end(), x) - v.begin();
cout << ans + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k;
char a[1024], b[1024];
int dp[1024][1024];
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("\n%s\n%s", a + 1, b + 1);
for (int step = 1; step <= k; step++) {
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (a[i] == b[j]) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
dp[i][j] = max(dp[i][j], max(dp[i - 1][j], dp[i][j - 1]));
}
printf("%d", dp[n][m]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char p[1000000 + 1], s[200 + 1];
int n, m, k, longest[2010];
string adds[2010], needs[2010];
string go(int cnt) {
for (int i = 0; i < k; i++) {
adds[i] = "";
for (int pos = i; pos < n; pos += k) adds[i] += p[pos];
}
for (int i = 0; i < cnt; i++) {
needs[i] = "";
for (int pos = i; pos < m; pos += cnt) needs[i] += s[pos];
}
longest[k] = 0;
for (int i = k - 1; i >= 0; i--) {
longest[i] = longest[i + 1];
if (longest[i] < cnt && adds[i] == needs[cnt - 1 - longest[i]])
++longest[i];
}
if (longest[0] < cnt) return "";
int pos = 0, left = cnt;
string ans = "";
for (int i = 0; i < k; i++) {
if (longest[pos + 1] >= left)
ans += "0", ++pos;
else {
ans += "1";
--left;
++pos;
}
}
return ans;
}
int main() {
gets(p);
gets(s);
scanf(" %d", &k);
n = strlen(p);
m = strlen(s);
string ans;
for (int cnt = 1; cnt <= k && cnt <= m; cnt++) {
string tmp = go(cnt);
if (tmp.size() && (!ans.size() || tmp < ans)) ans = tmp;
}
if (!ans.size()) ans = "0";
printf("%s\n", ans.c_str());
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long f[60][110][2];
long long bin[60], num[60], s, tt;
inline long long rd() {
long long x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x;
}
int main() {
s = rd();
bin[0] = 1;
for (int i = 1; i <= 51; i++) bin[i] = bin[i - 1] * 2;
long long ans = 0;
for (int h = 1; bin[h] - 1 <= s; h++) {
long long hh = s % (bin[h] - 1);
for (int j = h - 1; j; j--)
if (bin[j] - 1 <= hh) hh -= bin[j] - 1;
ans += (!hh);
}
for (int h0 = 1; h0 <= 50; h0++)
for (int h1 = 1; h1 <= 50; h1++)
if (bin[h0 + 1] + bin[h1 + 1] - 3 <= s - bin[h1] + 1) {
long long hh = (s - bin[h1] + 1) % (bin[h0 + 1] + bin[h1 + 1] - 3);
for (int n = 0; n <= h0 + h1 - 2 && n <= hh; n++) {
tt = 0;
long long now = hh + n;
if (now & 1) continue;
memset(num, 0, sizeof(num));
for (now >>= 1; now; now >>= 1) num[++tt] = now & 1;
memset(f, 0, sizeof(f));
f[0][0][0] = 1;
for (int i = 1; i <= tt; i++)
for (int j = 0; j <= n; j++)
for (int k = 0; k < 2; k++)
if (f[i - 1][j][k]) {
for (int l1 = 0; l1 < 2; l1++)
for (int l2 = 0; l2 < 2; l2++) {
if ((i >= h0 && l1) || (i >= h1 && l2)) continue;
int hh = l1 + l2 + k, now = j + l1 + l2;
if ((hh & 1) == num[i])
f[i][now][hh >> 1] += f[i - 1][j][k];
}
}
ans += f[tt][n][0];
}
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, k;
long long f[65][65][2], C[65][65], sum = 0;
inline void init(int x) {
for (register int i = 0; i <= x; ++i) {
C[i][0] = 1;
for (register int j = 1; j <= i; ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
int main() {
scanf("%d%d", &n, &k);
init(n);
f[1][0][0] = f[0][0][1] = 1;
for (register int i = 2; i <= n; ++i) {
for (register int r = i - 1, l = 0; l <= r; --r, ++l) {
if (!(l ^ r))
sum = C[i - 2][l - 1];
else
sum = C[i - 1][l];
if (i != n) sum *= i, sum %= mod;
for (register int k = 0; k + k <= l; ++k) {
for (register int kk = 0; kk + kk <= r; ++kk) {
for (register int tmp = 0; tmp <= 1; ++tmp) {
for (register int tmp1 = 0; tmp1 <= 1; ++tmp1) {
if (f[l][k][tmp] && f[r][kk][tmp1]) {
int pleat = (tmp == 1 && tmp1 == 1) ? 0 : 1;
long long prune =
((f[l][k][tmp] * f[r][kk][tmp1]) % mod * sum) % mod;
f[i][k + kk + pleat][pleat] =
(f[i][k + kk + pleat][pleat] + prune) % mod;
}
}
}
}
}
}
}
printf("%lld\n", (f[n][k][0] + f[n][k][1]) % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, x, y, count[100005] = {0}, adj[100005] = {0};
cin >> n >> m;
for (int(i) = 0; (i) < (m); (i)++) {
cin >> x >> y;
adj[x]++;
adj[y]++;
}
for (int(i) = 1; (i) <= (n); (i)++) {
count[adj[i]]++;
}
if (count[2] == n)
cout << "ring topology\n";
else if (count[1] == 2 && count[2] == n - 2)
cout << "bus topology\n";
else if (count[1] == n - 1 && count[n - 1] == 1)
cout << "star topology\n";
else
cout << "unknown topology\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
int n;
cin >> n;
int a = -1, b = -1;
int flg = 1;
for (int i = 0; i <= n / 7; i++) {
int t = (n - i * 7) / 4;
if ((n - i * 7) % 4 == 0) {
if (flg)
a = t, b = i, flg = 0;
else if (a + b > (t + i))
a = t, b = i;
}
}
if (a == -1) {
cout << -1;
return 0;
}
for (long long int i = 0; i < a; i++) cout << 4;
for (long long int i = 0; i < b; i++) cout << 7;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int p[N];
long long a[N];
int sz[N];
int main() {
int n, i;
cin >> n;
for (i = 1; i <= n; i++) sz[i] = 1;
for (i = 2; i <= n; i++) {
cin >> p[i];
sz[p[i]] = 0;
}
for (i = 1; i <= n; i++) cin >> a[i];
for (i = n; i > 1; i--) {
a[p[i]] += a[i];
sz[p[i]] += sz[i];
}
long long ans = 0;
for (i = 1; i <= n; ++i) ans = max(ans, (a[i] + sz[i] - 1) / sz[i]);
cout << ans << '\n';
return 0;
}
| 5 |
#include<iostream>
#include<set>
using namespace std;
int t,n,k;
set<int>sa;
int main(){
cin>>t;
while(t--){
sa.clear();
cin>>n>>k;
int mx=0;
for(int i=1;i<=n;i++){
int lin;
cin>>lin;
mx=max(mx,lin);
sa.insert(lin);
}
int me=0;
while(sa.count(me)==1){
me++;
}
if(me>mx){
printf("%d\n",n+k);
}
else{
int lin=(me+mx+1)/2;
if(sa.count(lin)==1||k==0){
printf("%d\n",n);
}
else{
printf("%d\n",n+1);
}
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
vector<string> s;
vector<pair<int, int> > v;
int gf = 0;
int x[9] = {-1, -1, -1, 0, 1, 1, 1, 0, 0};
int y[9] = {-1, 0, 1, 1, 1, 0, -1, -1, 0};
void dfs(int a, int b, int le) {
if (gf) return;
if (le == 8 || (a == 0 && b == 7)) {
gf = 1;
return;
}
int a1, b1, i, j, k, x1, y1, flag, x2, y2;
for (i = 0; i < 9; i++) {
flag = 0;
a1 = a + x[i], b1 = b + y[i];
if (a1 >= 0 && a1 < 8 && b1 >= 0 && b1 < 8) {
for (k = 0; k < v.size(); k++) {
x1 = v[k].first + (le + 1);
y1 = v[k].second;
x2 = v[k].first + (le);
y2 = v[k].second;
if ((a1 == x1 && b1 == y1) || (a1 == x2 && b1 == y2)) flag = 1;
}
if (flag == 0) dfs(a1, b1, le + 1);
}
}
}
int main() {
string st;
int i;
for (i = 0; i < 8; i++) {
cin >> st;
s.push_back(st);
}
int j;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
if (s[i][j] == 'S') v.push_back(make_pair(i, j));
}
}
dfs(7, 0, 0);
if (gf)
cout << "WIN"
<< "\n";
else
cout << "LOSE"
<< "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string A[110], B[110];
int main() {
int q, a, b, i, n, m, c;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> A[i];
for (i = 1; i <= m; i++) cin >> B[i];
cin >> q;
while (q--) {
cin >> a;
b = a % n;
c = a % m;
if (b == 0) b = n;
if (c == 0) c = m;
cout << A[b] << B[c] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int IT_MAX = 1 << 19;
const int MOD = 100000000;
const int INF = 1034567891;
const long long LL_INF = 1234567890123456789ll;
const double PI = 3.141592653589793238;
const double ERR = 1E-10;
int in[4050];
int sum[4050];
int dp[4050][95][95];
int main() {
int N, i, j, k, ii, jj;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &in[i]);
for (i = 1; i <= N; i++) sum[i] = sum[i - 1] + in[i];
for (i = 1; i <= N; i++) {
for (j = 1; j <= 93; j++) {
for (k = 0; k <= 93; k++) {
if ((N - i + k) % 2) continue;
int s = (N - i - k) >> 1;
s++;
int e = s + i - 1;
if (s < 1 || e > N) continue;
dp[i][j][k] = -INF;
if (j > i) {
dp[i][j][k] = 0;
continue;
}
if (j == i) {
dp[i][j][k] = sum[s + j - 1] - sum[s - 1];
continue;
}
for (ii = 0; ii <= 1; ii++) {
int tx = INF;
int k1 = j + ii;
if (i - k1 < k1) {
dp[i][j][k] = max(dp[i][j][k], sum[s + k1 - 1] - sum[s - 1]);
continue;
}
if (i - k1 == k1) {
dp[i][j][k] = max(dp[i][j][k], sum[s + k1 - 1] - sum[s - 1] -
sum[e] + sum[e - k1]);
continue;
}
for (jj = 0; jj <= 1; jj++) {
int k2 = k1 + jj;
tx = min(tx, dp[i - k1 - k2][k2][k + jj] - sum[e] + sum[e - k2]);
}
dp[i][j][k] = max(dp[i][j][k], sum[s + k1 - 1] - sum[s - 1] + tx);
}
}
}
}
return !printf("%d\n", dp[N][1][0]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long gcd2(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd2(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int mod = 1000000007;
inline int add(int a, int b) {
int ret = a + b;
if (ret >= mod) ret -= mod;
return ret;
}
bool find_any_solution(long long a, long long b, long long c, long long& x0,
long long& y0, long long& g) {
g = gcd2(abs(a), abs(b), x0, y0);
if (c % g != 0) return false;
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 *= -1;
if (b < 0) y0 *= -1;
return true;
}
void shift_solution(long long& x, long long& y, long long a, long long b,
long long cnt) {
x += cnt * b;
y -= cnt * a;
}
const double pi = 3.14159265358979323846;
int w[200001];
int h[200001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, sum = 0, cnt = 9;
cin >> n;
while (n > 0) {
sum += n;
n -= cnt;
cnt *= 10;
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct punkt {
int a;
};
int main() {
ios_base::sync_with_stdio(false);
int n, k, a, b;
vector<pair<int, int> > B;
int V[2000010];
cin >> n >> k;
pair<int, int> c;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
c.first = a;
c.second = -1;
B.push_back(c);
c.first = b;
c.second = 1;
B.push_back(c);
}
sort(B.begin(), B.end());
int licznik = 0;
int p = 0, ile = 0;
while (p < 2 * n) {
pair<int, int> x = B[p];
if (x.second == -1) {
licznik++;
p++;
if (licznik == k) {
V[ile] = x.first;
ile++;
}
} else {
if (licznik == k) {
V[ile] = x.first;
ile++;
}
licznik--;
p++;
}
}
cout << ile / 2 << endl;
for (int i = 0; i < ile; i += 2) {
cout << V[i] << " " << V[i + 1] << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
long long max1 = -1000000000;
int ind, n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; ++i) {
scanf("%I64d", &v[i]);
if (max1 < v[i]) max1 = v[i], ind = i;
}
if (max1 == 1)
v[ind] = 2;
else
v[ind] = 1;
sort(v.begin(), v.end());
copy(v.begin(), v.end(), ostream_iterator<long long>(cout, " "));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1.e18 + 2;
const long long mod = 1000006;
const int MAXN = 200005;
using namespace std;
int n, dif;
vector<int> seq;
bool ctrl[MAXN];
bool ver(int ind1, int ind2) {
set<int> myS;
if (ind1 % 2) {
if (seq[ind1] > seq[ind1 - 1]) {
if (ctrl[ind1]) myS.insert(ind1);
if (ctrl[ind1 - 1]) myS.insert(ind1 - 1);
} else
return false;
if (ind1 < seq.size() - 1 && seq[ind1] > seq[ind1 + 1]) {
if (ctrl[ind1]) myS.insert(ind1);
if (ctrl[ind1 + 1]) myS.insert(ind1 + 1);
} else if (ind1 < seq.size() - 1)
return false;
} else {
if (ind1 > 0 && seq[ind1] < seq[ind1 - 1]) {
if (ctrl[ind1]) myS.insert(ind1);
if (ctrl[ind1 - 1]) myS.insert(ind1 - 1);
} else if (ind1 > 0)
return false;
if (ind1 < seq.size() - 1 && seq[ind1] < seq[ind1 + 1]) {
if (ctrl[ind1]) myS.insert(ind1);
if (ctrl[ind1 + 1]) myS.insert(ind1 + 1);
} else if (ind1 < seq.size() - 1)
return false;
}
if (ind2 % 2) {
if (seq[ind2] > seq[ind2 - 1]) {
if (ctrl[ind2]) myS.insert(ind2);
if (ctrl[ind2 - 1]) myS.insert(ind2 - 1);
} else
return false;
if (ind2 < seq.size() - 1 && seq[ind2] > seq[ind2 + 1]) {
if (ctrl[ind2]) myS.insert(ind2);
if (ctrl[ind2 + 1]) myS.insert(ind2 + 1);
} else if (ind2 < seq.size() - 1)
return false;
} else {
if (ind2 > 0 && seq[ind2] < seq[ind2 - 1]) {
if (ctrl[ind2]) myS.insert(ind2);
if (ctrl[ind2 - 1]) myS.insert(ind2 - 1);
} else if (ind2 > 0)
return false;
if (ind2 < seq.size() - 1 && seq[ind2] < seq[ind2 + 1]) {
if (ctrl[ind2]) myS.insert(ind2);
if (ctrl[ind2 + 1]) myS.insert(ind2 + 1);
} else if (ind2 < seq.size() - 1)
return false;
}
return myS.size() == dif;
}
int f(int ind) {
int acm = 0;
for (int i = 0; i < seq.size(); i++) {
if (i == ind) continue;
int aux = seq[ind];
seq[ind] = seq[i];
seq[i] = aux;
if (ver(ind, i)) {
acm++;
if (!ctrl[i]) acm++;
}
aux = seq[ind];
seq[ind] = seq[i];
seq[i] = aux;
}
return acm;
}
int main() {
cin >> n;
seq = vector<int>(n);
for (int x, i = 0; i < n; i++) {
scanf("%d", &seq[i]);
}
memset(ctrl, false, sizeof(ctrl));
int acm = 0;
for (int i = 0; i < seq.size() - 1; i++) {
if (i % 2 && seq[i] <= seq[i + 1]) {
if (!ctrl[i]) {
ctrl[i] = true;
acm++;
}
if (!ctrl[i + 1]) {
ctrl[i + 1] = true;
acm++;
}
} else if (!(i % 2) && seq[i] >= seq[i + 1]) {
if (!ctrl[i]) {
ctrl[i] = true;
acm++;
}
if (!ctrl[i + 1]) {
ctrl[i + 1] = true;
acm++;
}
}
}
if (acm > 6) return cout << "0" << endl, 0;
int res = 0;
dif = acm;
for (int i = 0; i < seq.size(); i++) {
if (ctrl[i]) res += f(i);
}
cout << res / 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
int Max = -1;
bool check(int l, int r) {
string a = s.substr(l, r - l + 1);
if (a == "1000000") return true;
if (a.size() > 6) return false;
if (a.size() == 1) return true;
if (a[0] == '0') return false;
return true;
}
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++)
for (int j = i + 1; j < s.size() - 1; j++) {
if (check(0, i) && check(i + 1, j) && check(j + 1, s.size() - 1)) {
if (Max == -1)
Max = atoi(s.substr(0, i + 1).c_str()) +
atoi(s.substr(i + 1, j - (i + 1) + 1).c_str()) +
atoi(s.substr(j + 1).c_str());
else
Max = max(Max, atoi(s.substr(0, i + 1).c_str()) +
atoi(s.substr(i + 1, j - (i + 1) + 1).c_str()) +
atoi(s.substr(j + 1).c_str()));
}
}
cout << Max << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void openfile() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
string s;
cin >> s;
bool ok = false;
int idx = 0;
while (idx < s.size()) {
if (s[idx] != 'a') break;
idx++;
}
if (idx == s.size()) {
s[s.size() - 1] = 'z';
cout << s << endl;
return 0;
}
while (idx < s.size()) {
if (s[idx] == 'a') break;
s[idx]--;
idx++;
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 1;
string s[maxn], dd[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
long long sum = 0, sum1 = 0, dem = 1, dem1;
sort(s + 1, s + n + 1);
for (int i = 1; i <= n; i++) {
if (s[i][0] == s[i + 1][0] && i + 1 <= n) {
dem++;
} else {
dem1 = dem - dem / 2;
dem = dem / 2;
sum += dem * (dem - 1) / 2;
sum1 += dem1 * (dem1 - 1) / 2;
dem = 1;
}
}
cout << sum + sum1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int num[1100], len;
int beh[1100], n, x, head[1100], save[1100];
bool ans[1100];
bool vis[1100];
int lim;
void dfs(int cur, int sum) {
if (cur > lim) return;
int t = num[cur] + sum;
ans[t] = true;
for (int i = cur + 1; i <= lim; i++) dfs(i, t);
}
int main() {
while (scanf("%d%d", &n, &x) != EOF) {
len = 0;
memset(beh, -1, sizeof(beh));
memset(num, 0, sizeof(num));
memset(ans, false, sizeof(ans));
for (int i = 1; i <= n; i++) {
scanf("%d", &save[i]);
if (save[i])
beh[save[i]] = i;
else
head[++len] = i;
}
int order = 1, flag = x;
while (save[x]) {
x = save[x];
order++;
flag = x;
}
int j = 0;
for (int i = 1; i <= len; i++) {
int t = head[i];
if (t == flag) continue;
++j;
while (t != -1) {
num[j]++;
t = beh[t];
}
}
ans[order] = true;
lim = j;
for (int i = 1; i <= lim; i++) {
for (int k = n; k >= num[i]; k--)
if (ans[k - num[i]]) ans[k] = true;
}
for (int i = 1; i <= n; i++) {
if (ans[i] == false) continue;
printf("%d\n", i);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
int dir[4][2] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1}};
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 * 10 + c - '0', c = getchar();
return x * f;
}
void wri(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) wri(x / 10);
putchar(x % 10 + '0');
}
void write(long long x) {
wri(x);
puts("");
}
long long ksc(long long a, long long b, long long mod) {
return ((a * b -
(long long)((long long)((long double)a / mod * b + 1e-3) * mod)) %
mod +
mod) %
mod;
}
long long ksm1(long long a, long long n, long long mod) {
long long t = 1;
for (; n; n >>= 1, (a *= a) %= mod)
if (n & 1) (t *= a) %= mod;
return t;
}
long long ksm2(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = ksc(res, a, mod);
b >>= 1, a = ksc(a, a, mod);
}
return res % mod;
}
int is2pow(long long x) { return x > 0 ? (x & (x - 1)) == 0 : 0; }
long long myrand(long long l, long long r) {
long long num = ((long long)rand() << 30) | ((long long)rand());
return num % (r + 1 - l) + l;
}
const long long N = 15;
long long cnt[N];
long long last[N];
string solve(long long n) {
string str = "";
while (n) {
str += n % 10 + '0';
n /= 10;
}
reverse(str.begin(), str.end());
return str;
}
signed main() {
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
memset(cnt, 0, sizeof(cnt));
memset(last, 0, sizeof(last));
long long geshu = 0;
string tmp = solve(n);
string res = "";
long long mark = 0;
char minn = '9';
char maxnn = '0';
for (long long i = 0; i < tmp.size(); i++) {
if (geshu < k) {
if (cnt[tmp[i] - '0'] == 0) {
cnt[tmp[i] - '0'] = i + 1;
last[tmp[i] - '0'] = i + 1;
geshu++;
res += tmp[i];
minn = ((minn < tmp[i]) ? minn : tmp[i]);
maxnn = ((maxnn > tmp[i]) ? maxnn : tmp[i]);
} else
res += tmp[i], minn = ((minn < tmp[i]) ? minn : tmp[i]),
last[tmp[i] - '0'] = i + 1;
} else if (geshu == k) {
if (mark == 0 && cnt[tmp[i] - '0'] == 0) {
for (long long j = 0; j <= 9; j++) {
if (cnt[j] && j >= tmp[i] - '0') {
res += j + '0';
mark = 1;
break;
}
}
if (mark == 0) {
for (long long j = 0; j <= 9; j++) {
if (cnt[j] && j > res.back() - '0') {
res.back() = j + '0';
res += minn;
mark = 1;
break;
}
}
}
if (mark == 0) {
mark = 1;
long long maxn = 0;
char ch = '0';
for (long long j = 0; j <= 9; j++) {
if (cnt[j] > maxn) {
maxn = cnt[j];
ch = j + '0';
}
}
long long woc = 0;
long long wori = 0;
for (long long i = 0; i < maxnn - '0'; i++)
wori = ((wori > last[i]) ? wori : last[i]);
if (wori > maxn) {
for (long long j = 0; j <= 9; j++)
if (cnt[j] && j > tmp[wori - 1] - '0') {
res[wori - 1] = j + '0';
mark = 1;
for (long long j = wori; j < i; j++) res[j] = minn;
res += minn;
woc = 1;
break;
}
if (woc) continue;
}
maxn--;
if (minn == ch) minn++;
res[maxn] = ch + 1;
for (long long j = maxn + 1; j < i; j++) res[j] = minn;
res += minn;
}
} else if (mark == 1)
res += minn;
else
res += tmp[i], last[tmp[i] - '0'] = i + 1;
}
}
long long pos = -1;
for (long long i = 0; i < tmp.size(); i++) {
if (res[i] > tmp[i]) {
pos = i;
break;
}
}
if (pos != -1) {
long long geshu2 = 0;
vector<long long> vv;
vv.clear();
vv.resize(11);
for (long long i = 0; i <= pos; i++) vv[res[i] - '0']++;
for (long long i = 0; i <= 9; i++)
if (vv[i]) geshu2++;
if (geshu2 < k) {
if (res[pos] != tmp[pos] + 1) {
res[pos] = tmp[pos] + 1;
char minn = '9';
for (long long i = 0; i <= pos; i++)
minn = ((minn < res[i]) ? minn : res[i]);
for (long long i = pos + 1; i < res.size(); i++) res[i] = minn;
} else {
for (long long i = pos + 1; i < res.size(); i++) res[i] = '0';
}
}
}
cout << res << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int arr[200003], n;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int c = 0, ans = 0;
for (int i = 0; i < n; i++) {
c++;
if (c >= arr[i]) {
c = 0;
ans++;
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N;
int P[1 << 20];
bool vis[1 << 20];
int ans[1 << 20];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &P[i]);
P[i]--;
}
vector<vector<int> > A;
for (int i = 0; i < N; i++)
if (!vis[i]) {
int u = i;
vector<int> now;
do {
now.push_back(u);
vis[u] = true;
u = P[u];
} while (u != i);
A.push_back(now);
}
sort(A.begin(), A.end(),
[](vector<int>& a, vector<int>& b) { return a.size() < b.size(); });
for (int i = 0; i < A.size(); i++) {
if (A[i].size() % 2 == 1) {
int n = (A[i].size() + 1) / 2;
for (int j = 0; j < A[i].size(); j++)
ans[A[i][j]] = A[i][(j + n) % A[i].size()];
} else {
if (i + 1 == A.size() || A[i + 1].size() != A[i].size()) {
puts("-1");
return 0;
}
for (int j = 0; j < A[i].size(); j++) {
ans[A[i][j]] = A[i + 1][j];
ans[A[i + 1][j]] = A[i][(j + 1) % A[i].size()];
}
i++;
}
}
for (int i = 0; i < N; i++) printf("%d%c", ans[i] + 1, i + 1 == N ? 10 : 32);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long b, long long e, long long mod) {
long long ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
const int N = 100005;
string s;
int dp[N][3][2];
int go[N][3][2];
bool vis[N][3][2];
int solve(int x, int y, int z) {
if (x == (int)(s).size()) {
if (y == 0)
return 0;
else
return -(N + 3);
}
if (vis[x][y][z]) return dp[x][y][z];
vis[x][y][z] = true;
if (z) {
int a = solve(x + 1, y, z),
b = solve(x + 1, (10 * y + (s[x] - '0')) % 3, z) + 1;
if (a >= b) {
go[x][y][z] = 0;
} else {
go[x][y][z] = 1;
}
dp[x][y][z] = max(a, b);
} else {
if (s[x] == '0') {
go[x][y][z] = 0;
dp[x][y][z] = solve(x + 1, y, z);
} else {
int a = solve(x + 1, y, z),
b = solve(x + 1, (10 * y + (s[x] - '0')) % 3, 1) + 1;
if (a >= b) {
go[x][y][z] = 0;
} else {
go[x][y][z] = 1;
}
dp[x][y][z] = max(a, b);
}
}
return dp[x][y][z];
}
string ans;
void recover(int x, int y, int z) {
if (x == (int)(s).size()) {
return;
}
if (go[x][y][z]) {
ans.push_back(s[x]);
recover(x + 1, (10 * y + (s[x] - '0')) % 3, 1);
} else
recover(x + 1, y, z);
}
int32_t main() {
cin >> s;
solve(0, 0, 0);
recover(0, 0, 0);
if ((int)(ans).size() == 0) {
for (int i = 0; i < (int)(s).size(); i++) {
if (s[i] == '0') {
ans = "0";
break;
}
}
}
if ((int)(ans).size() == 0)
cout << -1 << endl;
else
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
deque<long long> q;
int n;
string s;
cin >> s;
n = s.size();
bool f = 1;
for (int i = 0; i < n / 2; i++) {
if (s[i] != s[n - 1 - i]) f = 0;
}
if (!f)
cout << n << endl;
else {
for (int i = 1; i < n; i++)
if (s[i - 1] != s[i]) f = 0;
if (!f)
cout << n - 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
string res;
for (int i = 0; i < s.size(); i += 2) {
res = res + s[i];
}
cout << res << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - 48;
s = getchar();
}
return f * x;
}
const int N = 4e5 + 5;
struct seg {
int l, r;
int v, add;
} t[N << 2];
inline void pushup(int x) { t[x].v = max(t[x << 1].v, t[x << 1 | 1].v); }
inline void add(int x, int v) {
t[x].v += v;
t[x].add += v;
}
inline void pushdown(int x) {
if (t[x].add) {
add(x << 1, t[x].add);
add(x << 1 | 1, t[x].add);
t[x].add = 0;
}
}
void build(int x, int l, int r) {
t[x].l = l, t[x].r = r, t[x].v = r - 1;
if (l == r) return;
int mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
}
void updata(int x, int l, int r, int v) {
if (t[x].l > r || t[x].r < l) return;
if (t[x].l >= l && t[x].r <= r) return add(x, v);
pushdown(x);
updata(x << 1, l, r, v);
updata(x << 1 | 1, l, r, v);
pushup(x);
}
int ask(int x, int l, int r) {
if (t[x].l > r || t[x].r < l) return 0;
if (t[x].l >= l && t[x].r <= r) return t[x].v;
pushdown(x);
return max(ask(x << 1, l, r), ask(x << 1 | 1, l, r));
}
set<pair<int, int> > s1;
multiset<int> s2;
int main() {
int n = read(), k = read(), m = read();
build(1, 1, n * 2);
s2.insert(n + 1);
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
int p = y + abs(x - k);
if (!s1.count(make_pair(x, y))) {
s1.insert(make_pair(x, y));
updata(1, 1, p, 1);
s2.insert(p);
int maxp = (*s2.rbegin());
printf("%d\n", ask(1, 1, maxp) - n);
} else {
s1.erase(make_pair(x, y));
s2.erase(s2.find(p));
updata(1, 1, p, -1);
int maxp = (*s2.rbegin());
printf("%d\n", ask(1, 1, maxp) - n);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k, x, y, m1, m2, ind_1, ind_2, cn;
scanf("%lld", &n);
int val_1[n], val_2[n];
for (i = 0; i < n; i++) val_1[i] = val_2[i] = 0;
string s[n];
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (s[i][j] != 'E') {
val_1[i] += 1;
val_2[j] += 1;
}
}
cn = 0;
for (i = 0; i < n; i++)
if (val_1[i] == 0) {
cn = 1;
break;
}
if (cn == 1)
for (i = 0; i < n; i++)
if (val_2[i] == 0) {
cn = 2;
break;
}
if (cn == 2) {
cout << -1;
return 0;
}
cn = 0;
for (i = 0; i < n; i++)
if (val_1[i] != 0) cn += 1;
if (cn == n) {
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (s[i][j] == '.') {
cout << i + 1 << ' ' << j + 1 << endl;
break;
}
}
} else {
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (s[j][i] == '.') {
cout << j + 1 << ' ' << i + 1 << endl;
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double solve(double d, double v, double a) {
double t = v / a;
if (a * t * t / 2 > d) return sqrt(2 * d / a);
d -= a * t * t / 2;
return t + d / v;
}
int main() {
int n, a, d;
scanf("%d%d%d", &n, &a, &d);
double prev = 0;
for (int i = 0; i < (n); i++) {
int t, v;
scanf("%d%d", &t, &v);
printf("%.15f\n", prev = max(t + solve(d, v, a), prev));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 2e5 + 10;
const int xm = -20 + 10;
const int SQ = 320;
const int sq = 320 + 10;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int MOD = 1e9 + 7;
const int TM = 3;
const int BASE = 257;
int n, m, q, seg[2][xn << 2];
set<int> st[2][xn];
bool ans;
void build(int id, int l, int r, bool flag) {
if (r - l == 1) {
seg[flag][id] = inf;
return;
}
int mid = l + r >> 1;
build(id << 1, l, mid, flag);
build(id << 1 | 1, mid, r, flag);
seg[flag][id] = inf;
}
void modify(int id, int l, int r, int pos, int val, bool flag) {
if (r - l == 1) {
seg[flag][id] = min(seg[flag][id], val);
return;
}
int mid = l + r >> 1;
if (pos < mid)
modify(id << 1, l, mid, pos, val, flag);
else
modify(id << 1 | 1, mid, r, pos, val, flag);
seg[flag][id] = min(seg[flag][id << 1], seg[flag][id << 1 | 1]);
}
int get(int id, int l, int r, int ql, int qr, bool flag) {
if (qr <= l || r <= ql) return inf;
if (ql <= l && r <= qr) return seg[flag][id];
int mid = l + r >> 1;
return min(get(id << 1, l, mid, ql, qr, flag),
get(id << 1 | 1, mid, r, ql, qr, flag));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> q;
for (int i = 0; i < 2; ++i) build(1, 0, xn, i);
while (q--) {
int x, y;
cin >> x >> y;
bool flag = x % 2;
int X = x;
int Y = y;
x = (x + 1) / 2;
y = (y + 1) / 2;
if (flag) {
int a = -get(1, 0, xn, x, n + 1, !flag);
modify(1, 0, xn, x, y, flag);
ans |= (a >= y);
} else {
int a = get(1, 0, xn, 1, x + 1, !flag);
modify(1, 0, xn, x, -y, flag);
ans |= (a <= y);
}
if (ans)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ans[1010101] = {0};
int main() {
int n, q;
scanf("%d %d", &n, &q);
int p1 = 0, p2 = 1;
while (q--) {
int typ;
scanf("%d ", &typ);
if (typ == 1) {
int x;
scanf("%d ", &x);
p1 += x + n;
p2 += x + n;
p1 %= n;
p2 %= n;
} else if (typ == 2) {
if (p1 & 1) {
p1--;
p2++;
p1 = (p1 + n) % n;
p2 = (p2 + n) % n;
} else {
p1++;
p2--;
p1 = (p1 + n) % n;
p2 = (p2 + n) % n;
}
}
}
int c = 1;
while (ans[p1] == 0) {
ans[p1] = c;
c += 2;
p1 += 2;
p1 %= n;
}
c = 2;
while (ans[p2] == 0) {
ans[p2] = c;
c += 2;
p2 += 2;
p2 %= n;
}
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[55];
while (scanf("%s", &str) != EOF) {
int len = strlen(str);
bool flag = 0;
int tag = 0;
for (int i = 0; i < len - 1; i++) {
if (str[i] != str[i + 1]) {
tag = 1;
break;
}
}
if (len % 2) {
int i = 0, j = len - 1;
for (; i < len / 2, j >= len / 2 + 1; i++, j--) {
if (str[i] != str[j]) {
flag = 1;
break;
}
}
} else {
int i = 0, j = len - 1;
for (; i <= len / 2, j >= len / 2; i++, j--) {
if (str[i] != str[j]) {
flag = 1;
break;
}
}
}
if (tag) {
if (flag)
cout << len << endl;
else
cout << len - 1 << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long kadane(vector<long long> &v) {
long long sum = v[0];
long long maxSum = v[0];
for (long long i = 1; i < v.size(); i++) {
sum = max(sum + v[i], v[i]);
maxSum = max(maxSum, sum);
}
return maxSum;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
vector<long long> diff(n - 1);
for (long long i = 0; i < n - 1; i++) diff[i] = abs(v[i] - v[i + 1]);
vector<long long> diff1(n - 1);
vector<long long> diff2(n - 1);
for (long long i = 0; i < n - 1; i++) {
if (i % 2 != 0) {
diff1[i] = -diff[i];
diff2[i] = diff[i];
} else {
diff1[i] = diff[i];
diff2[i] = -diff[i];
}
}
long long ans1 = kadane(diff1);
long long ans2 = kadane(diff2);
long long finalAns = max(ans1, ans2);
cout << finalAns << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, INF = 1e18;
long long power(long long u, long long v) {
long long res = 1;
while (v) {
if (v & 1) res = (res * u) % mod;
u = (u * u) % mod;
v >>= 1;
}
return res;
}
long long modInv(long long u) { return power(u, mod - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
vector<long long> fac(200010), facInv(200010);
fac[0] = facInv[0] = 1;
for (long long i = 1; i <= 200000; i++) {
fac[i] = (i * fac[i - 1]) % mod;
facInv[i] = modInv(fac[i]);
}
long long h, w, n;
cin >> h >> w >> n;
vector<pair<long long, long long> > a(n);
for (int i = 0; i < n; i++) {
long long u, v;
cin >> u >> v;
a[i] = {u, v};
}
a.push_back({h, w});
sort(a.begin(), a.end());
vector<long long> dp(n + 1);
auto nCr = [=](long long u, long long v) {
long long res = fac[u + v];
res = (res * facInv[u]) % mod;
res = (res * facInv[v]) % mod;
return res;
};
for (int i = 0; i <= n; i++) {
dp[i] = nCr(a[i].first - 1, a[i].second - 1);
for (int j = 0; j < i; j++) {
if (a[j].second <= a[i].second)
dp[i] = dp[i] - (dp[j] * nCr(a[i].first - a[j].first,
a[i].second - a[j].second)) %
mod;
dp[i] = (dp[i] + mod) % mod;
}
}
cout << dp[n] << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0)
cout << n - 8 << " " << 8 << endl;
else
cout << n - 9 << " " << 9 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int cnt[105];
int dp[105];
struct matrix {
int D[105][105];
matrix(void) { memset(D, 0, sizeof(D)); }
};
const int N = 101;
matrix mult(matrix a, matrix b) {
matrix c;
for (int k = 1; k <= N; ++k)
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j)
c.D[i][j] = (c.D[i][j] + 1ll * a.D[i][k] * b.D[k][j]) % mod;
return c;
}
int main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
int n, k;
cin >> n >> k;
while (n--) {
int val;
cin >> val;
++cnt[val];
}
if (!k) {
cout << (1) << '\n';
exit(0);
};
dp[0] = 1;
for (int i = 1; i <= 101; ++i)
for (int j = 1; j <= i; ++j)
dp[i] = (dp[i] + 1ll * cnt[j] * dp[i - j]) % mod;
matrix ans, a;
if (k <= 101) {
cout << (accumulate(dp, dp + 1 + k, 0ll) % mod) << '\n';
exit(0);
};
for (int i = 1; i <= 99; ++i) ans.D[i][i + 1] = 1;
for (int i = 1; i <= 100; ++i) ans.D[100][i] = ans.D[101][i] = cnt[101 - i];
ans.D[101][101] = 1;
a = ans;
k -= 101;
while (k) {
if (k & 1) ans = mult(ans, a);
a = mult(a, a);
k /= 2;
}
dp[101] = accumulate(dp, dp + 101, 0ll) % mod;
int rs = 0;
for (int i = 1; i <= 101; ++i) rs = (rs + 1ll * dp[i] * ans.D[101][i]) % mod;
cout << rs << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
using namespace std;
int dp[510][510], arr[510];
int main() {
int n, j;
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> arr[i];
for (int i = 1; i < n + 1; i++) dp[i][i] = 1;
for (int l = 2; l < n + 1; l++) {
for (int i = 1; i < n - l + 2; i++) {
j = i + l - 1;
dp[i][j] = INT_MAX;
if (arr[i] == arr[j]) {
if (j - i > 1) {
dp[i][j] = dp[i + 1][j - 1];
} else
dp[i][j] = 1;
}
for (int k = 1; k < j - i + 1; k++)
dp[i][j] = min(dp[i][j], dp[i][i + k - 1] + dp[i + k][j]);
}
}
cout << dp[1][n] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, m, ln, i, a[10011 * 3], nx[10011 * 3], tl[10011], db[10011], xx, yy,
c[10011], v[10011], col, dep[10011], fa[10011][14], x[10011], y[10011],
s[2][10011], h[10011], ont[10011], o[10011], no, I, l, r, k, p, t, sb, cnt,
j;
int gf(int k) {
if (h[k] == 0) return k;
return h[k] = gf(h[k]);
}
int getfa(int x, int y) {
int i;
if (dep[x] < dep[y]) i = x, x = y, y = i;
for (i = 13; i >= 0; --i)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (i = 13; i >= 0; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) tl[i] = ++ln;
for (i = 1; i <= m; ++i) {
scanf("%d%d", &x[i], &y[i]);
if ((xx = gf(x[i])) != (yy = gf(y[i]))) {
h[xx] = yy;
a[tl[x[i]] = nx[tl[x[i]]] = ++ln] = y[i];
a[tl[y[i]] = nx[tl[y[i]]] = ++ln] = x[i];
ont[i] = 1;
}
}
for (I = 1; I <= n; ++I)
if (v[I] == 0) {
db[v[I] = ++col] = I;
for (l = 0, c[r = 1] = I; l < r; ++l)
for (i = nx[c[l + 1]]; i != 0; i = nx[i])
if (v[a[i]] == 0) v[c[++r] = a[i]] = col;
}
for (i = 1; i < col; ++i) {
a[tl[db[i]] = nx[tl[db[i]]] = ++ln] = db[i + 1];
a[tl[db[i + 1]] = nx[tl[db[i + 1]]] = ++ln] = db[i];
}
l = 0;
c[r = 1] = 1;
v[1] = -1;
dep[1] = 1;
while (l < r) {
k = c[++l];
for (i = 1; i <= 13; ++i) fa[k][i] = fa[fa[k][i - 1]][i - 1];
for (i = nx[k]; i != 0; i = nx[i])
if (v[a[i]] != -1) {
v[c[++r] = a[i]] = -1;
fa[a[i]][0] = k;
dep[a[i]] = dep[k] + 1;
}
}
for (i = 1; i <= m; ++i)
if (!ont[i]) {
p = getfa(x[i], y[i]);
t = (dep[x[i]] + dep[y[i]]) & 1;
if (t == 0) {
sb = i;
++cnt;
}
s[t][x[i]] += 1;
s[t][y[i]] += 1;
s[t][p] -= 2;
}
for (i = r; i >= 1; --i) {
k = c[i];
for (j = nx[k]; j != 0; j = nx[j])
if (dep[a[j]] > dep[k]) {
s[0][k] += s[0][a[j]];
s[1][k] += s[1][a[j]];
}
}
if (cnt == 0) {
printf("%d\n", m);
for (i = 1; i <= m; ++i) {
printf("%d", i);
if (i < m) printf(" ");
}
printf("\n");
return 0;
}
for (i = 1; i <= m; ++i)
if (cnt == 1 && i == sb)
o[++no] = i;
else if (ont[i]) {
if (dep[x[i]] > dep[y[i]])
k = x[i];
else
k = y[i];
if (s[0][k] == cnt && s[1][k] == 0) o[++no] = i;
}
printf("%d\n", no);
for (i = 1; i <= no; ++i) {
printf("%d", o[i]);
if (i < no) printf(" ");
}
printf("\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void init_code() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long dp[5002][5002];
long long solve(vector<long long>& v, long long k, long long n, long long idx) {
if (k == 0) return 0;
if (idx >= n) return 0;
if (dp[idx][k] != -1) return dp[idx][k];
auto i = (upper_bound(v.begin(), v.end(), v[idx] + 5) - v.begin());
long long cnt = i - idx;
long long temp = solve(v, k - 1, n, i) + cnt;
temp = max(temp, solve(v, k, n, idx + 1));
dp[idx][k] = temp;
return temp;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
memset(dp, -1, sizeof(dp));
cout << solve(v, k, n, 0);
}
signed main() {
init_code();
long long tc = 1;
long long num = 1;
while (tc--) {
num++;
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
void gn(int &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
sg = -1, x = 0;
else
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
sg = -1, x = 0;
else
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
const int mo = 1000000007;
int qp(int a, long long b) {
int ans = 1;
do {
if (b & 1) ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int n;
int a[222222];
int main() {
gn(n);
for (int i = 1; i <= n; i++) gn(a[i]);
sort(a + 1, a + 1 + n);
int m = n - (n - 1 >> 1) - 1;
int mi = 2100000000;
for (int i = 1; i + m <= n; i++) mi = min(mi, a[i + m] - a[i]);
cout << mi << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
long long nn = (n * (n + 1)) / 2;
cout << nn % 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} p[409];
int dp[409][409][2][2][2];
int n, D;
int dfs(int posx, int posy, int n1, int n2, int cur) {
int x = posx - 200, y = posy - 200;
if (x * x + y * y > D * D) return 1;
int &ans = dp[posx][posy][n1][n2][cur];
if (ans != -1) return ans;
ans = 0;
for (int i = 0; i < n; i++) {
if (dfs(posx + p[i].x, posy + p[i].y, n1, n2, cur ^ 1) == 0) return ans = 1;
}
if (cur == 0) {
if (n1) {
if (dfs(posy, posx, n1 - 1, n2, cur ^ 1) == 0) return ans = 1;
}
} else {
if (n2) {
if (dfs(posy, posx, n1, n2 - 1, cur ^ 1) == 0) return ans = 1;
}
}
return ans = 0;
}
int main() {
int X, Y;
scanf("%d%d%d%d", &X, &Y, &n, &D);
for (int i = 0; i < n; i++) scanf("%d%d", &p[i].x, &p[i].y);
memset(dp, -1, sizeof(dp));
if (dfs(X + 200, Y + 200, 1, 1, 0))
puts("Anton");
else
puts("Dasha");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void output(T t) {
cout << t << "\n";
}
template <typename T, typename U, typename... Args>
void output(T t, U u, Args... args) {
cout << t << " ";
output(u, args...);
}
void solve() {
string s;
cin >> s;
auto check = [](string& s) {
int lo = 0, hi = ((int)(s).size()) - 1;
while (lo < hi) {
if (s[lo++] != s[hi--]) {
return 0;
}
}
return 1;
};
for (int i = 0; i <= ((int)(s).size()); ++i) {
for (int j = 0; j < 26; ++j) {
string t = s;
t.insert(t.begin() + i, (char)('a' + j));
if (check(t)) {
output(t);
return;
}
}
}
output("NA");
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
short int n, m;
cin >> n >> m;
char hash = 'r';
short int start_l_or_r = n / 2;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) {
cout << '#';
}
cout << endl;
} else {
if (hash == 'r') {
for (int j = 0; j < m - 1; j++) {
cout << '.';
}
cout << '#';
cout << endl;
hash = 'l';
} else {
cout << '#';
for (int j = 0; j < m - 1; j++) {
cout << '.';
}
cout << endl;
hash = 'r';
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1e9 + 7;
const double EPS = 1e-7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
mt19937 mmtw_(MOD);
uniform_int_distribution<long long> rd_;
long long randomll() { return rd_(mmtw_); }
long long rnd(long long x, long long y) { return rd_(mmtw_) % (y - x + 1) + x; }
template <class T>
T fact(T n) {
if (n == 1) return 1;
return n * fact(n - 1);
}
int n, m;
int a[35];
int main() {
cin >> m >> n;
for (int i = 0; i < n; ++i) {
cout << 1 << endl;
int x;
cin >> x;
if (x == 0) exit(0);
if (x == -1)
a[i] = -1;
else
a[i] = 1;
}
int l = 2, r = m + 1;
for (int i = 0; i < 1234; ++i) {
int m = l + (r - l) / 2;
cout << m << endl;
int x;
cin >> x;
x *= a[i % n];
if (x == 0) exit(0);
if (x == -1)
r = m;
else
l = m + 1;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, l, c, d, p, nl, np, ans = 0;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
ans = min(((k * l) / nl), min((c * d), p / np)) / n;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
struct node {
long long a, b;
node(long long a = 0, long long b = 0) : a(a), b(b) {}
bool operator<(const node& a1) const {
return double(a / b) < double(a1.a / a1.b);
}
};
long long a[200005], b[200005];
vector<node> v[200005];
bool check(long long x) {
long long i, j;
for (i = 1; i <= k; i++) v[i].clear();
for (i = 1; i <= n; i++) {
long long tmp = a[i] / b[i] + 1;
if (tmp < k) v[tmp].push_back(node(a[i], b[i]));
}
long long p, now;
for (now = 0, p = 0; now < k; now++) {
while (p < k && v[p].size() == 0) p++;
if (p >= k) return true;
if (p < now) return false;
node tmp = v[p].back();
v[p].pop_back();
long long what_the_hell = tmp.a / tmp.b + 1;
if (what_the_hell <= now) return false;
tmp.a += x;
what_the_hell = tmp.a / tmp.b + 1;
if (what_the_hell <= now + 1) return false;
if (what_the_hell < k) v[what_the_hell].push_back(tmp);
}
return true;
}
int main() {
long long i, j;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> b[i];
long long l = 0, r = 2e13, mid;
if (!check(r)) {
cout << "-1" << endl;
return 0;
}
while (l < r) {
mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << r << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXINT = 1073741823;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n % 2 == 1) {
cout << (n / 2) * (n / 2 + 1) << '\n';
while (n > 1) {
for (int i = 2; i <= n - 3; i += 2) {
cout << 4 << ' ' << n << ' ' << i << ' ' << n - 1 << ' ' << i + 1
<< '\n';
cout << 4 << ' ' << n << ' ' << i << ' ' << n - 1 << ' ' << i + 1
<< '\n';
}
cout << 3 << ' ' << 1 << ' ' << n << ' ' << n - 1 << '\n';
cout << 3 << ' ' << 1 << ' ' << n << ' ' << n - 1 << '\n';
n -= 2;
}
} else {
cout << (n / 2) * (n / 2) << '\n';
while (n > 4) {
for (int i = 3; i <= n - 3; i += 2) {
cout << 4 << ' ' << n << ' ' << i << ' ' << n - 1 << ' ' << i + 1
<< '\n';
cout << 4 << ' ' << n << ' ' << i << ' ' << n - 1 << ' ' << i + 1
<< '\n';
}
cout << 4 << ' ' << 1 << ' ' << n << ' ' << 2 << ' ' << n - 1 << '\n';
cout << 3 << ' ' << 1 << ' ' << n << ' ' << n - 1 << '\n';
cout << 3 << ' ' << 2 << ' ' << n << ' ' << n - 1 << '\n';
n -= 2;
}
cout << 3 << ' ' << 1 << ' ' << 2 << ' ' << 3 << '\n';
cout << 3 << ' ' << 1 << ' ' << 2 << ' ' << 4 << '\n';
cout << 3 << ' ' << 1 << ' ' << 3 << ' ' << 4 << '\n';
cout << 3 << ' ' << 2 << ' ' << 3 << ' ' << 4 << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5050;
int n, m, q, last, dex, a[N], c[N], up[N], down[N];
bool mark[N];
vector<int> vec[N], nei[N];
void del(int dex) {
auto it = &nei[c[dex]];
for (int i = 0; i < (*it).size(); i++)
if ((*it)[i] == a[dex]) {
swap((*it)[i], (*it)[(*it).size() - 1]);
(*it).pop_back();
break;
}
}
bool dfs(int v) {
mark[v] = true;
for (int u : nei[v])
if (up[u] == -1 || (mark[up[u]] == false && dfs(up[u]))) {
down[v] = u;
up[u] = v;
return true;
}
return false;
}
bool ok(int k) {
fill(up, up + N, -1);
fill(down, down + N, -1);
int matching = 0;
bool done = false;
while (done == false) {
done = true;
memset(mark, false, sizeof mark);
for (int v = 0; v < N; v++)
if (mark[v] == false && down[v] == -1 && dfs(v)) matching++, done = false;
}
return matching >= k + 1;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
vec[a[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
cin >> c[i];
nei[--c[i]].push_back(a[i]);
}
last = N - 1;
cin >> q;
while (q--) {
cin >> dex;
del(--dex);
while (ok(last) == false) {
for (int v : vec[last]) del(v);
last--;
}
cout << last + 1 << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Scan() {
int res = 0, flag = 0;
char ch;
if ((ch = getchar()) == '-') {
flag = 1;
} else if (ch >= '0' && ch <= '9') {
res = ch - '0';
}
while ((ch = getchar()) >= '0' && ch <= '9') {
res = res * 10 + (ch - '0');
}
return flag ? -res : res;
}
void Out(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) {
Out(a / 10);
}
putchar(a % 10 + '0');
}
void test1() {
for (int i = 0; i < 100; ++i)
;
}
void test2() {
for (int i = 0; i < 1000; ++i)
;
}
void checksta() {}
int p[1000100], a[1000100], b[1000100];
set<int> aa[5];
int main() {
int n;
n = Scan();
for (int i = 1; i <= n; ++i) p[i] = Scan();
for (int i = 1; i <= n; ++i) a[i] = Scan();
for (int i = 1; i <= n; ++i) b[i] = Scan();
for (int i = 1; i <= n; ++i) {
aa[a[i]].insert(p[i]);
aa[b[i]].insert(p[i]);
}
int q;
scanf("%d", &q);
while (q--) {
int x;
x = Scan();
if (aa[x].empty()) {
puts("-1");
continue;
}
set<int>::iterator it;
it = aa[x].begin();
printf("%d\n", *it);
int lx = *it;
for (int i = 1; i <= 3; ++i) aa[i].erase(lx);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[4];
int num[4];
int main() {
int i, x, ans = (1ll << 31) - 1, n;
vector<int>::iterator a, b, c;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
s[x].push_back(i);
num[x]++;
}
ans = num[1];
if (num[2] < ans) ans = num[2];
if (num[3] < ans) ans = num[3];
printf("%d\n", ans);
for (a = s[1].begin(), b = s[2].begin(), c = s[3].begin();
a != s[1].end() && b != s[2].end() && c != s[3].end(); ++a, ++b, ++c) {
printf("%d %d %d\n", *a, *b, *c);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = 26;
char s[N];
int n, cnt[M + 5], pot;
vector<char> l, r;
int main() {
scanf("%s", s);
n = strlen(s);
pot = n / 2;
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
for (int i = 0; i < M; i++) pot -= ((int)(cnt[i] / 2));
for (int i = 0; i < M; i++) {
if (cnt[i] % 2 == 1 && pot > 0) {
cnt[i]++;
pot--;
for (int j = M - 1; j >= 0; j--) {
if (cnt[j] % 2 == 1) {
cnt[j]--;
break;
}
}
}
}
for (int i = 0; i < M; i++)
for (int j = 0; j < (int)(cnt[i] / 2); j++) l.push_back(i + 'a');
for (int i = 0; i < M; i++)
if (cnt[i] % 2 == 1) l.push_back(i + 'a');
for (int i = M - 1; i >= 0; i--)
for (int j = 0; j < (int)(cnt[i] / 2); j++) r.push_back(i + 'a');
for (int i = 0; i < l.size(); i++) printf("%c", l[i]);
for (int i = 0; i < r.size(); i++) printf("%c", r[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int Get() {
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
int res = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) res = res * 10 + ch - '0';
return res;
}
const int N = (int)1e6;
typedef int arr[N + 10];
int n, m, cnt;
arr a, ord, nex, par;
bool cmp(const int &x, const int &y) { return a[x] < a[y]; }
int main() {
n = Get();
for (int i = 1; i <= n; ++i)
a[i] = Get(), ord[i] = i, par[i] = i - 1, nex[i] = i + 1;
nex[0] = 1, par[n + 1] = n;
par[0] = nex[n + 1] = N + 5;
par[N + 5] = nex[N + 5] = N + 5;
sort(ord + 1, ord + n + 1, cmp);
double ans = 0;
for (int i = 1; i <= n; ++i) {
int x = ord[i];
nex[par[x]] = nex[x], par[nex[x]] = par[x];
int l = par[x], r = nex[x], tl = x, tr = x;
double fac = 2, ca = 0, cb = 0;
for (int k = 1; k <= 70; ++k, fac *= 2) {
if (l == N + 5 && r == N + 5) break;
if (l != N + 5) ca += (double)(tl - l) / fac;
if (r != N + 5) cb += (double)(r - tr) / fac;
tl = l, tr = r, l = par[l], r = nex[r];
}
ans += ca * cb * (double)a[x] * 2;
}
ans = ans / (double)n / (double)n;
printf("%.9lf\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
set<int> a[110];
int main() {
ios_base::sync_with_stdio(false);
int n, m;
bool f = false;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < m; j++)
if (str[j] == '1') a[i].insert(j);
if (a[i].empty()) f = true;
}
int mi = 2147483647;
for (int i = 0; i < m && !f; i++) {
int c = 0;
for (int j = 0; j < n; j++) {
int l, r;
set<int>::iterator it = a[j].upper_bound(i);
if (it == a[j].end()) it = a[j].begin();
r = *it;
if (it == a[j].begin()) it = a[j].end();
l = *(--it);
c += min((r + m - i) % m, (i + m - l) % m);
}
mi = min(mi, c);
}
cout << (f ? -1 : mi) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 2e5 + 100;
const double EPS = 1e-9;
using namespace std;
void dbg() { cout << "\n"; }
template <typename T, typename... A>
void dbg(T a, A... x) {
cout << a << ' ';
dbg(x...);
}
int n, m, p;
vector<int> v[N];
priority_queue<int> q;
int main() {
int _;
scanf("%d", &_);
while (_--) {
scanf("%d", &n);
for (int i = 0; i <= n; i++) v[i].clear();
for (int i = 1; i <= n; i++) scanf("%d%d", &m, &p), v[m].push_back(p);
while (q.size()) q.pop();
long long ans = 0;
for (int i = n; i >= 0; i--) {
for (auto& tp : v[i]) q.push(-tp);
while (q.size() > n - i) ans -= q.top(), q.pop();
}
printf("%lld\n", ans);
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.