solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long int a[3], ans = 0;
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
if (a[0] != a[1] && a[1] != a[2] && a[0] != a[2]) {
ans += abs(a[1] - a[2] + 1) + abs(a[1] - a[0] - 1) + abs(a[0] - a[2] + 2);
cout << ans << "\n";
} else {
if (a[0] == a[1] && a[1] == a[2])
cout << "0\n";
else {
if (a[0] == a[1] && abs(a[2] - a[1] > 1)) {
ans += abs(a[0] - a[1]) + abs(a[2] - a[0] - 2) + abs(a[2] - a[1] - 2);
cout << ans << "\n";
} else if (abs(a[0] - a[1]) > 1) {
ans += abs(a[1] - a[2]) + abs(a[0] - a[1] + 2) + abs(a[0] - a[2] + 2);
cout << ans << "\n";
} else
cout << "0\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int INF = (int)1e9 + 1;
int main() {
int n;
std::cin >> n;
std::vector<int64_t> a(n);
for (auto& it : a) std::cin >> it;
std::vector<std::vector<bool>> g(n, std::vector<bool>(n, false));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
auto s = a[i], t = a[j];
if (t * 3 == s || s * 2 == t) {
g[i][j] = true;
}
}
}
std::vector<int> dist;
std::function<void(int)> dfs = [&](int s) {
for (int t = 0; t < n; ++t) {
if (g[s][t] && dist[t] == INF) {
dist[t] = dist[s] + 1;
dfs(t);
}
}
if (dist[s] == n - 1) {
std::vector<int> answ{s};
while (dist[s] != 0) {
for (int i = 0; i < n; ++i) {
if (dist[s] == dist[i] + 1) {
answ.push_back(i);
s = i;
break;
}
}
}
std::reverse(answ.begin(), answ.end());
for (auto& it : answ) {
std::cout << a[it] << " ";
}
std::cout << std::endl;
std::exit(0);
}
dist[s] = INF;
};
for (int i = 0; i < n; ++i) {
dist.assign(n, INF);
dist[i] = 0;
dfs(i);
}
throw 1;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<stack>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<iomanip>
#include<cctype>
#include<deque>
#include<ctime>
#include<sstream>
#include<list>
#include<bitset>
#include<limits>
#include<fstream>
#include<cwchar>
#include<cwctype>
#include<cerrno>
#include<cassert>
#include<clocale>
#include<complex>
#include<cfloat>
#include<stdexcept>
#include<ios>
#include<iosfwd>
#include<sstream>
#define R register
#define I inline
#define ll long long
#define ull unsigned long long
#define db double
using namespace std;
#define pii pair<int,int>
#define mp(x,y) make_pair(x,y)
#define piii pair<pair<int,int>,int>
#define mp3(x,y,z) make_pair(make_pair(x,y),z)
#define fi first.first
#define se first.second
#define th second
#define putint(x) printf("%d\n",x)
#define putll(x) printf("%lld\n",x)
#define putull(x) printf("%llu\n",x)
#define lowbit(x) ((x)&(-(x)))
#define inf (1e9)
#define INF (1e18)
#define eps (1e-8)
I int read()
{
char ch=getchar();
int res=0,flag=1;
while(ch<'0'||ch>'9')
{
if(ch=='-')
flag=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
{
res=res*10+ch-'0';
ch=getchar();
}
return res*flag;
}
int T,n,x,y;
int main()
{
T=read();
while(T--)
{
n=read();
x=read();
printf("0");
while(--n)
{
y=read();
printf(" %d",((y|x)^y));
x|=y;
}
puts("");
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
struct dsu{
int n;
vector<int> p;
dsu(int _n): n(_n){
p.resize(n + 5);
iota(p.begin(), p.end(), 0);
}
inline int par(int u){
return p[u] = (u == p[u] ? u : par(p[u]));
}
bool unite(int u, int v){
u = par(u);
v = par(v);
if(u == v){
return 0;
}
p[v] = u;
return 1;
}
};
constexpr int N = 4e5;
int n, m, p[N], sz[N], cnt[N];
bool jo[N], volt;
vector<pair<int, int> > edges[N];
vector<tuple<int, int, int> > lst;
long long res, mini;
inline int findp(int u){
return p[u] = (u == p[u] ? u : findp(p[u]));
}
bool uni(int u, int v){
u = findp(u);
v = findp(v);
if(u == v)
return 0;
p[v] = u;
jo[u] |= jo[v];
sz[u] += sz[v];
return 1;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
iota(p, p + N, 0);
fill(sz, sz + N, 1);
cin >> n >> m;
for(int i = 0, u, v; i < m; i++){
long long w;
cin >> u >> v >> w;
edges[u - 1].emplace_back(v - 1, w);
edges[v - 1].emplace_back(u - 1, w);
lst.emplace_back(w, u - 1, v - 1);
mini ^= w;
}
queue<int> q;
for(int i = 0; i < n; i++){
for(pair<int, int> p : edges[i]){
int v = findp(p.first);
cnt[v] = 0;
}
for(pair<int, int> p : edges[i]){
int v = findp(p.first);
//cout << "el: " << i << ' ' << p.first << ' ' << v << endl;
cnt[v]++;
}
queue<int> tmp;
while(!q.empty()){
int id = q.front();
if(cnt[id] >= sz[id]){
tmp.push(id);
//cout << "nagy: " << i << ' ' << id << ' ' << sz[id] << ' ' << cnt[id] << endl;
}
else{
jo[i] = 1;
if(mini > 0 && cnt[id] < sz[id] - 1){
mini = 0;
}
//cout << "most: " << id << ' ' << sz[id] << ' ' << cnt[id] << endl;
uni(i, id);
}
cnt[id] = 0;
q.pop();
}
q = tmp;
q.push(i);
cnt[i] = 0;
}
sort(lst.begin(), lst.end());
vector<tuple<int, int, int> > comp;
dsu test(n);
for(auto xx : lst){
int w = get<0>(xx), u = get<1>(xx), v = get<2>(xx);
if(test.unite(u, v))
comp.emplace_back(w, u, v);
}
for(auto xx : comp){
int w = get<0>(xx), u = get<1>(xx), v = get<2>(xx);
u = findp(u);
v = findp(v);
//cout << "most. " << u << ' ' << v << endl;
if(u != v){
uni(u, v);
res += w;
}
else{
mini = min(1ll*w, mini);
}
}
cout << res + mini << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
bool is_prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long calc(long long n, long long k) {
if (!is_prime(k)) return 0;
if (n < k) return 0;
if (n < k * k) return 1;
long long ans = n / k;
for (long long i = 2; i < k; i++) ans -= calc(n / k, i);
return ans;
}
void solve() {
long long l, r, k;
cin >> l >> r >> k;
cout << calc(r, k) - calc(l - 1, k) << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
int sb(int a, int b) {
if (a % b == 0)
return b;
else
return sb(b, a % b);
}
int main() {
int n, i, max = 0, a[110];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
max = max > a[i] ? max : a[i];
}
int k = a[1];
for (i = 2; i <= n; i++) k = sb(k, a[i]);
if ((max / k - n) & 1)
puts("Alice");
else
puts("Bob");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 51;
long long n;
bool ans[N][N];
long long Q = 0;
long long get(long long x1, long long y1, long long x2, long long y2) {
++Q;
if (Q > n * n) {
cout << "Q\n";
exit(1);
}
cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\n';
fflush(stdout);
long long ans;
cin >> ans;
return ans;
}
bool us[N][N];
void calc(bool l, bool r, bool x, bool &a, bool &b, bool c1, bool c2,
bool dif) {
if (c1) {
a = r;
b = a ^ dif;
} else if (c2) {
b = l;
a = b ^ dif;
} else if (!dif) {
a = b = x ^ 1;
} else if (x == l) {
a = x;
b = x ^ 1;
} else {
a = x ^ 1;
b = x;
}
}
void go(long long i, long long j) {
while (i - 1 >= 1 && j - 1 >= 1) {
if (get(i - 1, j - 1, i, j))
ans[i - 1][j - 1] = ans[i][j];
else
ans[i - 1][j - 1] = !ans[i][j];
--i;
--j;
us[i][j] = 1;
}
}
signed main() {
ans[1][1] = 1;
cin >> n;
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
if (i == 1 && j == 1) continue;
if (i == n && j == n) continue;
if (abs(i - j) % 2 == 0) {
if (i - 2 >= 1) {
if (get(i - 2, j, i, j))
ans[i][j] = ans[i - 2][j];
else
ans[i][j] = !ans[i - 2][j];
} else if (j - 2 >= 1) {
if (get(i, j - 2, i, j))
ans[i][j] = ans[i][j - 2];
else
ans[i][j] = !ans[i][j - 2];
} else {
if (get(i - 1, j - 1, i, j))
ans[i][j] = ans[i - 1][j - 1];
else
ans[i][j] = !ans[i - 1][j - 1];
}
}
}
}
for (long long i = 1;; ++i) {
if (ans[i][i] != ans[i + 2][i + 2]) {
bool c1 = get(i, i + 1, i + 2, i + 2);
bool c2 = get(i, i, i + 1, i + 2);
bool dif = get(i, i + 1, i + 1, i + 2) ^ 1;
calc(ans[i][i], ans[i + 2][i + 2], ans[i][i + 2], ans[i][i + 1],
ans[i + 1][i + 2], c1, c2, dif);
if (get(i + 1, i, i + 1, i + 2))
ans[i + 1][i] = ans[i + 1][i + 2];
else
ans[i + 1][i] = !ans[i + 1][i + 2];
if (get(i, i + 1, i + 2, i + 1))
ans[i + 2][i + 1] = ans[i][i + 1];
else
ans[i + 2][i + 1] = !ans[i][i + 1];
us[i][i + 1] = us[i + 1][i + 2] = us[i + 1][i] = us[i + 2][i + 1] = 1;
go(i, i + 1);
go(i + 1, i);
break;
}
}
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
if (us[i][j]) continue;
if (abs(i - j) & 1) {
if (i - 2 >= 1) {
if (get(i - 2, j, i, j))
ans[i][j] = ans[i - 2][j];
else
ans[i][j] = !ans[i - 2][j];
} else if (j - 2 >= 1) {
if (get(i, j - 2, i, j))
ans[i][j] = ans[i][j - 2];
else
ans[i][j] = !ans[i][j - 2];
} else {
if (get(i - 1, j - 1, i, j))
ans[i][j] = ans[i - 1][j - 1];
else
ans[i][j] = !ans[i - 1][j - 1];
}
}
}
}
cout << "!\n";
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
cout << ans[i][j];
}
cout << '\n';
}
fflush(stdout);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
constexpr double eps = 1e-13;
constexpr int M = 1e9 + 7;
constexpr int N = 5e5 + 100;
long long qpower(long long x, long long p) {
long long ans = 1;
while (p) {
if (p & 1) ans = ans * x % M;
x = x * x % M;
p >>= 1;
}
return ans;
}
vector<pair<int, int> > qw[N];
vector<int> eg[N];
int f[N], p[N], u[N], v[N], w[N];
int mt[N]{};
int T;
bool An[N]{};
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
int find2(int x) {
if (mt[x] != T) mt[x] = T, p[x] = f[x];
if (p[x] != x)
return p[x] = find2(p[x]);
else
return x;
}
int main() {
std::ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> u[i] >> v[i] >> w[i];
eg[w[i]].push_back(i);
}
cin >> q;
for (int i = 0; i < q; ++i) {
int qn, id;
cin >> qn;
for (int j = 0; j < qn; ++j) {
cin >> id;
--id;
qw[w[id]].push_back(make_pair(i, id));
}
}
for (int i = 0; i < n; ++i) f[i] = i;
T = 0;
for (int i = 1; i <= 5e5; ++i) {
sort((qw[i]).begin(), (qw[i]).end());
for (int j = 0; j < ((int)(qw[i]).size()); ++j) {
int x = u[qw[i][j].second], y = v[qw[i][j].second];
find(x);
find(y);
}
for (int j = 0; j < ((int)(qw[i]).size()); ++j) {
int x = u[qw[i][j].second], y = v[qw[i][j].second];
if (j == 0 || qw[i][j].first != qw[i][j - 1].first) T++;
if (find2(x) == find2(y)) An[qw[i][j].first] = 1;
p[find2(x)] = find2(y);
}
for (auto id : eg[i]) {
f[find(u[id])] = find(v[id]);
}
}
for (int i = 0; i < q; ++i) {
cout << (An[i] ? "NO" : "YES") << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a > b ? a : b;
if (c != -1234567) ans = max1(ans, c);
if (d != -1234567) ans = max1(ans, d);
return ans;
}
template <class T>
inline T min1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a < b ? a : b;
if (c != -1234567) ans = min(ans, c);
if (d != -1234567) ans = min(ans, d);
return ans;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / abs1(a) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
inline int bitnum(unsigned long long nValue) {
nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
(0x5555555555555555ull & nValue);
nValue = ((0xccccccccccccccccull & nValue) >> 2) +
(0x3333333333333333ull & nValue);
nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
(0x0f0f0f0f0f0f0f0full & nValue);
nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
(0x00ff00ff00ff00ffull & nValue);
nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
(0x0000ffff0000ffffull & nValue);
nValue = ((0xffffffff00000000ull & nValue) >> 32) +
(0x00000000ffffffffull & nValue);
return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 500100;
template <class t>
struct tree_array {
t num[maxn], n, bigwei;
tree_array(int nn = maxn) {
n = nn;
while (lb(nn) != nn) nn -= lb(nn);
bigwei = nn;
}
void upd(int no, t add) {
while (no <= n) {
num[no] += add;
no += lb(no);
}
}
t que(int no) {
t ans = 0;
while (no) {
ans += num[no];
no -= lb(no);
}
return ans;
}
int getrank(t x) {
int ans = 0, ranwei = bigwei;
t rank = 0;
while (ranwei) {
if (rank + num[ranwei + ans] < x) {
ans += ranwei;
rank += num[ans];
}
ranwei >>= 1;
}
return ans + 1;
}
};
tree_array<int> ta;
int n, orig[maxn];
int nq;
int trans[maxn];
inline void deal(int no, int add) {
if (no != 1 && trans[no - 1] > trans[no]) ta.upd(no - 1, add);
if (no != n && trans[no] > trans[no + 1]) ta.upd(no, add);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", orig + i);
trans[orig[i]] = i;
}
for (int i = 1; i < n; i++)
if (trans[i] > trans[i + 1]) ta.upd(i, 1);
scanf("%d", &nq);
for (int i = 0; i < nq; i++) {
int cate, a, b;
scanf("%d%d%d", &cate, &a, &b);
if (cate == 1) {
b--;
int ans = ta.que(b);
if (a > 1) ans -= ta.que(a - 1);
printf("%d\n", ans + 1);
} else {
int x = orig[a], y = orig[b];
swap(orig[a], orig[b]);
if (x > y) swap(x, y);
deal(x, -1);
deal(y, -1);
if (x == y - 1 && trans[x] > trans[y]) ta.upd(x, 1);
swap(trans[x], trans[y]);
deal(x, 1);
deal(y, 1);
if (x == y - 1 && trans[x] > trans[y]) ta.upd(x, -1);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 4;
int n, m, a, b, ay[N], by[N], l[N], linkY[N << 1];
void read() {
cin >> n >> m >> a >> b;
for (int i = 1; i <= n; ++i) {
cin >> ay[i];
}
for (int i = 1; i <= m; ++i) {
cin >> by[i];
}
for (int i = 1; i <= m; ++i) {
cin >> l[i];
}
}
long double dist = 1e18;
int ida, idb, idTmp;
long double sqr(long double x) { return x * x; }
long double euc(long double xa, long double ya, long double xb,
long double yb) {
return sqrt(sqr(xa - xb) + sqr(ya - yb));
}
long double f(int ni, int mi) {
return euc(0, 0, a, ay[ni]) + euc(a, ay[ni], b, by[mi]);
}
long double ternarySearch(int num) {
int l = 1, r = n;
while (l + 2 < r) {
int dm = (r - l) / 3;
int m1 = l + dm;
int m2 = r - dm;
long double d1 = f(m1, num);
long double d2 = f(m2, num);
if (fabs(d1 - d2) < 1e-9) {
l = m1;
r = m2;
} else if (d1 < d2) {
r = m2;
} else {
l = m1;
}
}
idTmp = l;
for (int i = l + 1; i <= r; ++i) {
if (f(i, num) < f(idTmp, num)) {
idTmp = i;
}
}
return f(idTmp, num);
}
void calc() {
for (int i = 1; i <= m; ++i) {
long double distTmp = ternarySearch(i) + l[i];
if (distTmp < dist) {
dist = distTmp;
ida = idTmp;
idb = i;
}
}
}
void sovle() {
read();
calc();
cout << ida << " " << idb;
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
sovle();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *w = new int[n];
int *h = new int[n];
for (int i = 0; i < n; i++) {
cin >> w[i] >> h[i];
}
int max_first = 0;
int max_second = 0;
int max_number = 0;
long long int total_width = 0;
for (int i = 0; i < n; i++) {
total_width = total_width + w[i];
if (h[i] > max_first) {
max_first = h[i];
}
}
for (int i = 0; i < n; i++) {
if (h[i] > max_second && h[i] != max_first) {
max_second = h[i];
}
if (max_first == h[i]) {
max_number++;
}
}
if (max_second == 0) {
max_second = max_first;
}
for (int i = 0; i < n; i++) {
long long int t = total_width - w[i];
int m = 0;
if (max_number == 1 && h[i] == max_first) {
m = max_second;
} else {
m = max_first;
}
long long int pixel = t * m;
cout << pixel << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a;
string b = "QAQ";
int sum;
void dfs(int times, int pos) {
if (times == 3) {
sum++;
return;
}
for (int i = pos + 1; i < a.length(); i++) {
if (b[times] == a[i]) dfs(times + 1, i);
}
}
int main() {
cin >> a;
dfs(0, -1);
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100009];
int main() {
long long i, j, n, sum;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (sum = 0, i = 0, j = n - 1; i < n; j--, i++) {
sum += (a[i] * a[j]) % 10007;
}
cout << sum % 10007 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b >> c;
if (a == b)
cout << "YES" << endl;
else if (c == 0)
cout << "NO" << endl;
else if ((a > b && c < 0 && (b - a) % c == 0) ||
(a < b && c > 0 && (b - a) % c == 0))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int> > arr, A, B;
for (int i = 0; i < n; i++) {
int first;
scanf("%d", &first);
arr.push_back({first, i});
}
sort(arr.begin(), arr.end());
int left = (n + 2) / 3;
int right = n - left * 2;
for (int i = 0; i < left; i++) {
A.push_back({arr[i].second, arr[i].first});
B.push_back({arr[i].second, 0});
}
for (int i = left; i < left * 2 && i < n; i++) {
B.push_back({arr[i].second, arr[i].first});
A.push_back({arr[i].second, 0});
}
for (int i = left * 2; i < n; i++) {
A.push_back({arr[i].second, arr[i].first - (n - 1 - i)});
B.push_back({arr[i].second, n - 1 - i});
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
puts("YES");
for (auto first : A) printf("%d ", first.second);
puts("");
for (auto first : B) printf("%d ", first.second);
puts("");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[1055][1055];
int fact[100005];
int rev[100005];
int arr[100005];
int n, k;
int cnt;
int ans;
int sz;
void addMod(int &a, int b) {
a += b;
if (mod <= a) {
a -= mod;
}
}
int binPow(int a, int b) {
int ret = 1;
for (; b > 0; b >>= 1) {
if (b & 1) {
ret = (ret * 1ll * a) % mod;
}
a = (a * 1ll * a) % mod;
}
return ret;
}
void pre() {
fact[0] = 1;
for (int i = 1; i <= 100000; ++i) {
fact[i] = (fact[i - 1] * 1ll * i) % mod;
}
for (int i = 0; i <= 100000; ++i) {
rev[i] = binPow(fact[i], mod - 2);
}
}
bool lucky(int x) {
bool ret = 1;
while (x > 0) {
int last = (x % 10);
if (last != 4 && last != 7) {
ret = 0;
}
x /= 10;
}
return ret;
}
int C(int n, int k) {
if (n < k || n < 0 || k < 0) {
return 0;
}
return 1ll * fact[n] * rev[k] % mod * rev[n - k] % mod;
}
void solve() {
scanf("%d %d", &n, &k);
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
if (lucky(x)) {
arr[++sz] = x;
} else {
++cnt;
}
}
sort(arr + 1, arr + sz + 1);
n = 0;
for (int l = 1, r; l <= sz; l = r) {
r = l;
while (r <= sz && arr[l] == arr[r]) {
++r;
}
arr[++n] = r - l;
}
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
dp[i][0] = 1;
for (int j = 1; j <= i; ++j) {
addMod(dp[i][j], dp[i - 1][j]);
addMod(dp[i][j], dp[i - 1][j - 1] * 1ll * arr[i] % mod);
}
}
for (int i = 0; i <= n; ++i) {
addMod(ans, dp[n][i] * 1ll * C(cnt, k - i) % mod);
}
printf("%d\n", ans);
}
int main() {
int tt = 1;
pre();
while (tt--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
map<long long, long long> mp;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
int pos = find(v.begin(), v.end(), m) - v.begin();
long long ans = 0;
int lft = 0, rgt = 0, len = 1;
int i = pos, j = pos;
while (i >= 0) {
if (len % 2 == 1) {
if (lft == rgt) ans++;
} else {
if (lft == rgt - 1) ans++;
}
i--;
if (i >= 0) {
if (v[i] < m)
lft++;
else
rgt++;
mp[lft - rgt]++;
}
len++;
}
j = pos;
lft = 0, rgt = 0, len = 1;
while (j < (int)v.size()) {
if (len % 2 == 1) {
if (lft == rgt) ans++;
} else {
if (lft == rgt - 1) ans++;
}
j++;
len++;
if (j < (int)v.size()) {
if (v[j] < m)
lft++;
else
rgt++;
}
if (j < (int)v.size()) {
ans += mp[-(lft - rgt)];
ans += mp[-(lft - rgt + 1)];
}
}
cout << ans - 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[1005][1005];
long long b[1005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf(" %c", &a[i][j]);
if (a[i][j] == '*') {
++b[j];
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long sum = 0, tot = 0;
for (int j = 1; j <= m; ++j) {
if (a[i][j] == '*') {
++sum;
tot += b[j] - 1;
}
}
ans += (sum - 1) * tot;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[555][555];
bool ok(int x, int y) {
bool c[555];
c['f'] = c['a'] = c['c'] = c['e'] = 0;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) c[s[i + x][j + y]] = 1;
return c['f'] && c['a'] && c['c'] && c['e'];
}
int main(void) {
int n, m;
cin >> n >> m;
int ans = 0;
for (int i = 1; i <= n; ++i) cin >> (s[i] + 1);
for (int i = 1; i < n; ++i)
for (int j = 1; j < m; ++j) ans += ok(i, j);
return cout << ans << '\n', 0;
}
| 0 |
#include <bits/stdc++.h>
long long ni() {
int c = getchar();
while (c < '0' || c > '9') c = getchar();
long long ret = 0;
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret;
}
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
long long a[1234567];
long long d[123456];
int cc[123456];
int main() {
srand(time(NULL));
int n = ni();
for (int i = 0; i < n; i++) {
a[i] = ni();
}
long long ans = 1;
for (int it = 0; it < 10; it++) {
long long x = a[((rand() << 15) ^ rand()) % n];
int cnd = 0;
for (long long i = 1; i * i <= x; i++) {
if (x % i != 0) {
continue;
}
d[cnd++] = i;
if (i * i != x) d[cnd++] = x / i;
}
for (int i = 0; i < cnd; i++) cc[i] = 0;
std::sort(d, d + cnd);
for (int i = 0; i < n; i++) {
long long g = gcd(x, a[i]);
cc[std::lower_bound(d, d + cnd, g) - d]++;
}
for (int i = 0; i < cnd; i++) {
for (int j = i + 1; j < cnd; j++) {
if (d[j] % d[i] == 0) {
cc[i] += cc[j];
}
}
if (2 * cc[i] >= n && d[i] > ans) {
ans = d[i];
}
}
}
printf("%I64d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 550000 + 7;
const long long MOD = 1e9 + 7;
char ss[50010];
int len;
struct Seg {
int ls[MAXN * 4], rs[MAXN * 4], sum[MAXN * 4], rt[550010 << 1], pos[MAXN * 4],
dfn = 0;
void init() {
for (int i = 1; i <= dfn; i++)
rt[i] = ls[i] = rs[i] = sum[i] = 0, pos[i] = 0X3f3f3f3f;
dfn = 0;
}
void update(int &o, int nowl, int nowr, int l, int r, int v) {
if (!o) o = ++dfn;
if (nowl >= l && nowr <= r) {
sum[o] += v;
return;
}
int mid = (nowl + nowr) / 2;
if (l <= mid) update(ls[o], nowl, mid, l, r, v);
if (r > mid) update(rs[o], mid + 1, nowr, l, r, v);
sum[o] = sum[ls[o]] + sum[rs[o]];
}
int merge(int p, int q, int l, int r) {
if (p == 0) return q;
if (q == 0) return p;
int id = ++dfn;
if (l == r) {
sum[id] = sum[q] + sum[p];
return id;
}
int mid = (l + r) / 2;
ls[id] = merge(ls[p], ls[q], l, mid);
rs[id] = merge(rs[p], rs[q], mid + 1, r);
sum[id] = sum[ls[id]] + sum[rs[id]];
return id;
}
int query(int o, int nowl, int nowr, int l, int r) {
int res = 0;
if (nowl >= l && nowr <= r) {
return sum[o];
}
int mid = (nowl + nowr) / 2;
if (l <= mid && ls[o]) res += query(ls[o], nowl, mid, l, r);
if (r > mid && rs[o]) res += query(rs[o], mid + 1, nowr, l, r);
return res;
}
} seg;
const int CHARSET_SIZE = 26;
string s;
int n, l[20], r[20];
struct Suffix_Automaton {
int cnt, root, last, prt[550010 << 1], son[550010 << 1][CHARSET_SIZE],
mx[550010 << 1];
int topo[550010 << 1], buc[550010 << 1];
inline void init() {
for (int i = 1; i <= cnt; i++)
for (int j = 0; j < CHARSET_SIZE; j++) son[i][j] = 0;
root = last = cnt = 1;
mx[cnt] = prt[cnt] = 0;
}
inline void extend(int c) {
int p = last;
if (son[p][c]) {
int q = son[p][c];
if (mx[q] == mx[p] + 1) {
last = q;
} else {
int nq = ++cnt;
memcpy(son[nq], son[q], sizeof(son[q]));
mx[nq] = mx[p] + 1;
prt[nq] = prt[q];
prt[q] = nq;
for (; p && son[p][c] == q; p = prt[p]) son[p][c] = nq;
last = nq;
}
return;
}
int np = ++cnt;
mx[np] = mx[p] + 1;
for (; p && !son[p][c]; p = prt[p]) son[p][c] = np;
if (!p)
prt[np] = root;
else {
int q = son[p][c];
if (mx[q] == mx[p] + 1)
prt[np] = q;
else {
int nq = ++cnt;
memcpy(son[nq], son[q], sizeof(son[q]));
mx[nq] = mx[p] + 1;
prt[nq] = prt[q];
prt[q] = prt[np] = nq;
for (; p && son[p][c] == q; p = prt[p]) son[p][c] = nq;
}
}
last = np;
}
void toposort() {
int maxv = 0;
memset(buc, 0, sizeof(buc));
for (int i = 1; i <= cnt; i++) {
buc[mx[i]]++;
maxv = max(maxv, mx[i]);
}
for (int i = 1; i <= maxv; i++) buc[i] += buc[i - 1];
for (int i = cnt; i >= 1; i--) topo[buc[mx[i]]--] = i;
}
void cal_right() {
toposort();
for (int i = cnt; i >= 1; i--) {
int v = topo[i];
seg.rt[prt[v]] = seg.merge(seg.rt[prt[v]], seg.rt[v], 1, n);
}
}
void solve() {
long long ans = 0;
for (int i = 2; i <= cnt; i++) {
int flag = 0;
for (int j = 1; j <= n - 1; j++) {
int t = seg.query(seg.rt[i], 1, n, j + 1, j + 1);
if (t >= l[j] && t <= r[j]) {
continue;
} else {
flag = 1;
break;
}
}
if (flag) {
continue;
} else {
if (seg.query(seg.rt[i], 1, n, 1, 1)) ans += (mx[i] - mx[prt[i]]);
}
}
printf("%lld\n", ans);
}
} sam;
int main() {
sam.init();
seg.init();
cin >> s;
scanf("%d", &n);
n = n + 1;
for (int i = 0; s[i]; i++) {
sam.extend(s[i] - 'a');
seg.update(seg.rt[sam.last], 1, n, 1, 1, 1);
}
for (int i = 1; i < n; i++) {
cin >> ss >> l[i] >> r[i];
sam.last = sam.root;
for (int j = 0; ss[j]; j++) {
sam.extend(ss[j] - 'a');
seg.update(seg.rt[sam.last], 1, n, i + 1, i + 1, 1);
}
}
sam.cal_right();
sam.solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 1000005, mod = 1e9 + 7;
int n, m, a, b;
int Fac[N], Inv[N];
int C(int n, int m) {
if (m > n || m < 0) return 0;
return (long long)Fac[n] * Inv[m] % mod * Inv[n - m] % mod;
}
int Pow(int x, int y) {
if (y < 0) return Pow(x, y + mod - 1);
int ans = 1;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) ans = (long long)ans * x % mod;
return ans;
}
void init(int n) {
for (int i = Fac[0] = 1; i <= n; i++)
Fac[i] = (long long)Fac[i - 1] * i % mod;
Inv[n] = Pow(Fac[n], mod - 2);
for (int i = n; i >= 1; i--) Inv[i - 1] = (long long)Inv[i] * i % mod;
}
void Add(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
int main() {
n = read(), m = read(), a = read(), b = read();
init(max(n, m));
int ans = 0;
for (int i = 0; i <= n - 2; i++)
Add(ans, (long long)C(n - 2, i) * C(m - 1, i) % mod * Fac[i] % mod *
Pow(m, n - 2 - i) % mod * Pow(n, n - 3 - i) % mod * (i + 2) %
mod);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const int mod = 1e9 + 7;
void solve() {
int n, m, x, y;
cin >> n >> m >> x >> y;
char ch;
long long ans = 0;
for (int i = 0; i < n; i++) {
int cnt1 = 0, cnt2 = 0, cnt = 0;
for (int j = 0; j < m; j++) {
cin >> ch;
if (ch == '.') {
if (cnt == 2) {
cnt2++;
cnt = 0;
}
cnt++;
}
if (ch == '*' || j == m - 1) {
if (cnt == 1)
cnt1++;
else if (cnt == 2)
cnt2++;
cnt = 0;
}
}
if (2 * x <= y)
ans += 1ll * x * cnt1 + 1ll * x * 2 * cnt2;
else {
ans += 1ll * x * cnt1 + 1ll * y * cnt2;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int tt;
cin >> tt;
while (tt--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
int a[x];
long long counter = 0, sum = 0;
for (int i = 0; i < x; i++) {
cin >> a[i];
sum += a[i];
}
counter = sum;
sort(a, a + x);
for (int i = 0; i < x - 1; i++) {
sum -= a[i];
counter += (sum);
counter += a[i];
}
cout << counter;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
if (n >= 2)
printf("%d\n", n - 2);
else
printf("0\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 5005, inf = 1011111111;
int n, p[max_n], b[max_n];
int pos[max_n];
vector<pair<vector<int>, pair<vector<int>, vector<int>>>> all;
vector<pair<vector<int>, pair<vector<int>, vector<int>>>> my_all;
void find_b() {
for (int i = 0; i < n; ++i) {
pos[p[i]] = i;
}
for (int i = 0; i < n; ++i) {
b[i] = pos[i];
}
}
int ans[2][max_n];
int res[max_n], tm, used[max_n];
int main() {
cin >> n;
for (int i = 0; i + 1 < n; ++i) {
for (int j = 0; j < 2; ++j) {
cout << "? " << i + j << " " << i << endl;
cout.flush();
cin >> ans[j][i];
}
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
p[0] = i;
for (int j = 0; j + 1 < n; ++j) {
int x = ans[0][j] ^ ans[1][j];
p[j + 1] = p[j] ^ x;
}
find_b();
int f = 1;
for (int j = 0; j + 1 < n; ++j) {
for (int k = 0; k < 2; ++k) {
if (ans[k][j] != (p[j + k] ^ b[j])) {
f = 0;
break;
}
}
}
++tm;
for (int j = 0; j < n; ++j) {
if (p[j] >= n) {
f = 0;
break;
}
if (used[p[j]] == tm) {
f = 0;
break;
}
used[p[j]] = tm;
}
if (0) {
for (int j = 0; j < n; ++j) {
cout << p[j] << " ";
}
cout << endl;
for (int j = 0; j < n; ++j) {
cout << b[j] << " ";
}
cout << "f = " << f << endl;
}
cnt += f;
if (f) {
for (int j = 0; j < n; ++j) {
res[j] = p[j];
}
}
}
cout << "!" << endl;
cout << cnt << endl;
for (int i = 0; i < n; ++i) {
cout << res[i] << " ";
}
cout << endl;
cout.flush();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int const N = 1e5 + 10, inf = 1e18 + 10;
int n, v, x[N], t[N], dp1[N], dp2[N], mn1[N], mn2[N], ans1, ans2;
pii p[N];
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> t[i];
}
cin >> v;
for (int i = 0; i < n; i++) {
p[i].first = v * t[i] - x[i];
p[i].second = v * t[i] + x[i];
}
sort(p, p + n);
mn1[0] = -inf, mn2[0] = -inf;
fill(mn1 + 1, mn1 + N, inf);
fill(mn2 + 1, mn2 + N, inf);
for (int i = 0; i < n; i++) {
int id = upper_bound(mn1, mn1 + N, p[i].second) - mn1;
dp1[i] = id;
mn1[id] = p[i].second;
if (p[i].first >= 0 && p[i].second >= 0) {
int id = upper_bound(mn2, mn2 + N, p[i].second) - mn2;
dp2[i] = id;
mn2[id] = p[i].second;
}
ans1 = max(ans1, dp1[i]);
ans2 = max(ans2, dp2[i]);
}
cout << ans2 << ' ' << ans1 << '\n';
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma comment(linker, "/STACK:2000000")
using namespace std;
template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template <typename... Args>
Vec(int n = 0, Args... args)
: vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};
template <typename T>
struct Vec<1, T> : public vector<T> {
Vec(int n = 0, T val = T()) : vector<T>(n, val) {}
};
using ll = long long;
using db = long double;
using ii = pair<int, int>;
const int N = 4e5 + 5, LG = 19, MOD = 998244353;
const int SQ = 320;
const long double EPS = 1e-7;
vector<vector<ii>> adj, baseAdj;
int n;
string s;
int col[2005];
void addEdge(int u, int v, int c) {
adj[u].push_back(ii(v, c));
adj[v].push_back(ii(u, c));
}
bool dfs(int node, int c) {
if (~col[node]) return col[node] == c;
col[node] = c;
bool ok = true;
for (auto v : adj[node]) ok &= dfs(v.first, c ^ v.second);
return ok;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
adj.resize(n + n);
for (int i = 0; i < n; i++) {
if (s[i] == '1') addEdge(i, n + i, 1);
if (s[i] == '0') addEdge(i, n + i, 0);
addEdge(i, n - 1 - i, 0);
}
baseAdj = adj;
int ans = 0;
for (int len = 1; len < n; len++) {
adj = baseAdj;
memset(col, -1, sizeof col);
for (int j = 0; j < len; j++) {
int l = n - 1 - j;
int r = (n - 1 - (len - 1 - j));
addEdge(n + l, n + r, 0);
}
int lft = n - len;
bool f = true;
for (int j = 0; j < lft; j++)
if (~col[n + j]) {
f &= (col[n + j] == 0);
} else
f &= dfs(n + j, 0);
if (~col[n + lft]) {
f &= (col[n + lft] == 1);
} else
f &= dfs(n + lft, 1);
int cur = 1;
for (int i = n + lft + 1; i < n + n; i++)
if (col[i] == -1) {
cur += cur;
if (cur >= MOD) cur -= MOD;
f &= dfs(i, 0);
}
for (int i = 0; i < n; i++)
if (col[i] == -1) {
cur += cur;
if (cur >= MOD) cur -= MOD;
f &= dfs(i, 0);
}
if (f) {
ans += cur;
if (ans >= MOD) ans -= MOD;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int dp[1005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= n; i++) cin >> a[i];
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 511; j++) {
if (dp[j] < a[i]) dp[a[i] ^ j] = min(dp[a[i] ^ j], a[i]);
}
}
int sum = 0;
for (int i = 0; i <= 511; i++)
if (dp[i] <= 511) sum++;
cout << sum << "\n";
for (int i = 0; i <= 511; i++)
if (dp[i] <= 511) cout << i << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
void __print(int x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int first = 0;
cerr << '{';
for (auto &i : x) cerr << (first++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
string second;
cin >> second;
long long int x, done = 1, n = second.size();
cin >> x;
vector<long long int> ans(n, 1);
for (long long int i = 0; i < n; i++) {
if (second[i] == '0') {
if (i - x >= 0) {
ans[i - x] = 0;
}
if (i + x <= n - 1) {
ans[i + x] = 0;
}
}
}
for (long long int i = 0; i < n; i++) {
if (second[i] != '0') {
long long int fp = 0, sp = 0;
if (i - x >= 0) fp = ans[i - x];
if (i + x <= n - 1) sp = ans[i + x];
if (fp + sp == 0) {
done = 0;
break;
}
}
}
if (done) {
for (long long int i = 0; i < n; i++) cout << ans[i];
cout << "\n";
} else
cout << -1 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
size_t highestOneBitPosition(uint64_t a) {
size_t bits = 0;
while (a != 0) {
++bits;
a >>= 1;
};
return bits;
}
bool multiplication_is_safe(long long a, long long b) {
size_t a_bits = highestOneBitPosition(a), b_bits = highestOneBitPosition(b);
return (a_bits + b_bits <= 64);
}
int main() {
ios::sync_with_stdio(false);
long long t, w, b;
cin >> t >> w >> b;
long long g = gcd(w, b);
long long ans;
if (!multiplication_is_safe(w / g, b) || (w / g) * b > t) {
ans = min(t, min(b, w) - 1);
} else {
ans = ((t / ((w / g) * b)) * (min(w, b)));
ans += min((t + 1 - (t / ((w / g) * b)) * ((w / g) * b)), min(w, b));
ans--;
}
g = gcd(ans, t);
ans /= g;
t /= g;
cout << ans << "/" << t << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, long long> A[2], sum[2];
int ansMax = -1;
long long ans, total[2];
void update(int m, long long ways) {
if (m > ansMax) {
ansMax = m;
ans = ways;
} else if (m == ansMax) {
ans += ways;
}
}
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; ++i) {
int a, b;
scanf("%d%d", &a, &b);
++A[a][b];
++total[a];
}
for (int i = 0; i < 2; ++i) {
long long s = 0;
for (auto j = A[i].begin(); j != A[i].end(); ++j) {
sum[i][j->first] = s;
s += j->second;
}
}
for (int i = 0; i < 2; ++i) {
if (A[i].empty()) continue;
auto st = A[i].begin();
auto en = A[i].rbegin();
int cnt = 2 * (en->first - st->first);
long long ways =
!cnt ? st->second * (st->second - 1) * (st->second - 2) / 6
: st->second * en->second * (total[i] - st->second - en->second) +
st->second * (st->second - 1) / 2 * en->second +
en->second * (en->second - 1) / 2 * st->second;
update(cnt, ways);
if (A[1 - i].empty()) continue;
for (auto j = A[i].begin(); j != A[i].end(); ++j) {
auto p = sum[1 - i].lower_bound(j->first);
auto same = A[1 - i].lower_bound(j->first);
if (p != sum[1 - i].end() && p != sum[1 - i].begin()) {
ways = p->second * (total[1 - i] - p->second);
if (p->first == j->first) {
ways += same->second * (same->second - 1) / 2 +
same->second * (total[1 - i] - p->second - same->second);
}
cnt = 2 * N;
} else {
if (p == sum[1 - i].end()) {
--p;
--same;
}
cnt = 2 * (N - abs(p->first - j->first));
ways = same->second * (same->second - 1) / 2 +
(total[1 - i] - same->second) * same->second;
}
update(cnt, ways * j->second);
}
}
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char s[1000];
bool mirror(char a, char b) {
if (a == 'A' && b == 'A') return 1;
if (a == 'M' && b == 'M') return 1;
if (a == 'T' && b == 'T') return 1;
if (a == 'U' && b == 'U') return 1;
if (a == 'V' && b == 'V') return 1;
if (a == 'W' && b == 'W') return 1;
if (a == 'Y' && b == 'Y') return 1;
if (a == 'H' && b == 'H') return 1;
if (a == 'I' && b == 'I') return 1;
if (a == 'X' && b == 'X') return 1;
if (a == 'O' && b == 'O') return 1;
if (a == 'o' && b == 'o') return 1;
if (a == 'v' && b == 'v') return 1;
if (a == 'w' && b == 'w') return 1;
if (a == 'x' && b == 'x') return 1;
if (a == 'b' && b == 'd') return 1;
if (a == 'd' && b == 'b') return 1;
if (a == 'p' && b == 'q') return 1;
if (a == 'q' && b == 'p') return 1;
return 0;
}
int main() {
cin >> s;
for (int i = 0; i < (strlen(s) + 1) / 2; i++)
if (!mirror(s[i], s[strlen(s) - i - 1])) {
cout << "NIE" << endl;
return 0;
}
cout << "TAK" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a;
cin >> t;
while (t--) {
cin >> a;
if (360 % (180 - a) == 0)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[30010];
char vis[30010], cycle[30010];
int dist[30010];
bool achei = false;
int n;
stack<int> p;
void dfs(int u, int lst) {
if (achei) return;
if (vis[u]) {
while (p.top() != u) {
cycle[p.top()] = 1;
p.pop();
}
cycle[u] = 1;
p.pop();
achei = true;
return;
}
vis[u] = 1;
p.push(u);
for (int v : g[u])
if (v != lst) dfs(v, u);
if (achei) return;
p.pop();
}
void bfs() {
queue<int> q;
for (int i = 0; i <= n; i++) {
dist[i] = 101010;
if (cycle[i]) {
dist[i] = 0;
q.push(i);
}
}
int u;
while (!q.empty()) {
u = q.front();
q.pop();
for (int v : g[u]) {
if (dist[u] + 1 < dist[v]) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
}
int main() {
int u, v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 1);
bfs();
for (int i = 1; i <= n; i++) {
if (cycle[i])
cout << "0 ";
else
cout << dist[i] << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string str[105];
class node {
public:
int a, b, c, d, e, f;
node(int a1, int b1, int c1, int d1, int e1, int f1) {
a = a1;
b = b1;
c = c1;
d = d1;
e = e1;
f = f1;
}
};
void flip(vector<int> ans) {
for (int i = 0; i < 6; i += 2) {
if (str[ans[i]][ans[i + 1]] == '1')
str[ans[i]][ans[i + 1]] = '0';
else
str[ans[i]][ans[i + 1]] = '1';
}
}
vector<node> moves;
void done3(int grid[], int x, int y) {
vector<int> ans;
for (int i = 0; i < 8; i += 2) {
if (grid[i] != x || grid[i + 1] != y) {
ans.push_back(grid[i]);
ans.push_back(grid[i + 1]);
}
}
node k(ans[0] + 1, ans[1] + 1, ans[2] + 1, ans[3] + 1, ans[4] + 1,
ans[5] + 1);
flip(ans);
moves.push_back(k);
}
void done2(int grid[], int x, int y, int a, int b) {
vector<int> ans;
for (int i = 0; i < 8; i += 2) {
if (grid[i] != a || grid[i + 1] != b) {
ans.push_back(grid[i]);
ans.push_back(grid[i + 1]);
}
}
node k(ans[0] + 1, ans[1] + 1, ans[2] + 1, ans[3] + 1, ans[4] + 1,
ans[5] + 1);
moves.push_back(k);
flip(ans);
done3(grid, x, y);
}
void done1(int grid[], int x, int y) {
vector<int> ans;
ans.push_back(x);
ans.push_back(y);
int cnt = 0, i = 0;
while (cnt != 2) {
if (grid[i] != x || grid[i + 1] != y) {
ans.push_back(grid[i]);
ans.push_back(grid[i + 1]);
cnt++;
}
i += 2;
}
node k(ans[0] + 1, ans[1] + 1, ans[2] + 1, ans[3] + 1, ans[4] + 1,
ans[5] + 1);
moves.push_back(k);
flip(ans);
done2(grid, ans[2], ans[3], ans[4], ans[5]);
}
void done4(int grid[]) {
vector<int> ans;
for (int i = 0; i < 6; i++) {
ans.push_back(grid[i++]);
ans.push_back(grid[i]);
}
node k(ans[0] + 1, ans[1] + 1, ans[2] + 1, ans[3] + 1, ans[4] + 1,
ans[5] + 1);
moves.push_back(k);
flip(ans);
done1(grid, grid[6], grid[7]);
}
void allDone(int i, int j) {
vector<int> zero, one;
if (str[i][j] == '0') {
zero.push_back(i);
zero.push_back(j);
} else {
one.push_back(i);
one.push_back(j);
}
if (str[i][j + 1] == '0') {
zero.push_back(i);
zero.push_back(j + 1);
} else {
one.push_back(i);
one.push_back(j + 1);
}
if (str[i + 1][j] == '0') {
zero.push_back(i + 1);
zero.push_back(j);
} else {
one.push_back(i + 1);
one.push_back(j);
}
if (str[i + 1][j + 1] == '0') {
zero.push_back(i + 1);
zero.push_back(j + 1);
} else {
one.push_back(i + 1);
one.push_back(j + 1);
}
int o = one.size() / 2;
int grid[] = {i, j, i, j + 1, i + 1, j, i + 1, j + 1};
if (o == 1) {
done1(grid, one[0], one[1]);
} else if (o == 2) {
done2(grid, one[0], one[1], one[2], one[3]);
} else if (o == 3) {
done3(grid, zero[0], zero[1]);
} else if (o == 4) {
done4(grid);
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> str[i];
for (int i = 0; i < n - 1; i += 2) {
for (int j = 0; j < m - 1; j += 2) {
allDone(i, j);
}
}
if (n % 2) {
int i = n - 2;
for (int j = 0; j < m - 1; j += 2) {
allDone(i, j);
}
}
if (m % 2) {
int j = m - 2;
for (int i = 0; i < n - 1; i += 2) {
allDone(i, j);
}
}
if ((m % 2) && (n % 2)) {
allDone(n - 2, m - 2);
}
int cnt = moves.size();
cout << moves.size() << endl;
for (int i = 0; i < cnt; i++) {
cout << moves[i].a << " " << moves[i].b << " " << moves[i].c << " "
<< moves[i].d << " " << moves[i].e << " " << moves[i].f << endl;
}
for (int i = 0; i < n; i++) str[i].clear();
moves.clear();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10100;
const double eps = 1e-9;
struct node {
int x, y;
node operator+(const node &q) const { return node{x + q.x, y + q.y}; }
node operator-(const node &q) const { return node{x - q.x, y - q.y}; }
bool operator==(const node &q) const { return x == q.x && y == q.y; }
long long len_2() { return x * x + y * y; }
void print() {
printf("%d %d\n", x, y);
return;
}
} a[N], b[N], p[N];
int dj(node x, node y) { return x.x * y.x + x.y * y.y; }
int cj(node x, node y) { return x.x * y.y - x.y * y.x; }
int n, m;
bool cal(node x, node y) {
double l = -1e9, r = 1e9;
for (int i = 1; i <= n; i++) {
node op1 = x - a[i], op2 = y - a[i];
if (cj(op1, op2) == 0) continue;
double op = 1.0 * dj(op1, op2) / cj(op1, op2);
if (cj((a[i] - x), (y - x)) < 0)
l = max(l, op);
else
r = min(r, op);
}
for (int i = 1; i <= m; i++) {
node op1 = x - b[i], op2 = y - b[i];
if (cj(op1, op2) == 0) {
if (b[i].x >= min(x.x, y.x) && b[i].x <= max(x.x, y.x) &&
b[i].y >= min(x.y, y.y) && b[i].y <= max(x.y, y.y))
return 0;
continue;
}
double op = 1.0 * dj(op1, op2) / cj(op1, op2);
if (cj((b[i] - x), (y - x)) > 0)
l = max(l, op);
else
r = min(r, op);
}
return l + eps < r;
}
bool dfs(int l, int r) {
if (l == r - 1) return 0;
int mid;
double op = 1e9;
for (int i = l + 1; i <= r - 1; i++) {
node op1 = p[i] - p[l], op2 = p[i] - p[r];
double x = 1.0 * dj(op1, op2) / cj(op1, op2);
if (x < op) op = x, mid = i;
}
return cal(p[l], p[mid]) || cal(p[r], p[mid]) || dfs(l, mid) || dfs(mid, r);
}
bool cmp1(node x, node y) { return x.x == y.x ? x.y < y.y : x.x < y.x; }
bool cmp2(node x, node y) {
node op1 = x - a[1], op2 = y - a[1];
int op = cj(op1, op2);
return op == 0 ? op1.len_2() < op2.len_2() : op > 0;
}
bool check() {
sort(a + 1, a + n + 1, cmp1);
sort(a + 2, a + n + 1, cmp2);
int top = 0;
p[++top] = a[1], p[++top] = a[2];
for (int i = 3; i <= n; i++) {
while (top >= 2 && cj((a[i] - p[top - 1]), (p[top] - p[top - 1])) >= 0)
top--;
p[++top] = a[i];
}
return cal(p[1], p[top]) || dfs(1, top);
}
int main() {
scanf("%d%d", &n, &m);
if (n == 1 || m == 1) return puts("YES"), 0;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= m; i++) scanf("%d%d", &b[i].x, &b[i].y);
bool flag = check();
swap(a, b);
swap(n, m);
flag |= check();
if (flag)
puts("YES");
else
puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[213700];
vector<int> gT[213700];
vector<int> g2[213700];
bool vis1[213700];
int kol = 1;
int num[213700];
int revnum[213700];
void dfs1(int a) {
vis1[a] = true;
for (int i = 0; i < g[a].size(); i++) {
if (!vis1[g[a][i]]) {
dfs1(g[a][i]);
}
}
num[a] = kol;
revnum[kol] = a;
kol++;
}
bool vis3[213700];
int spojna[213799];
int sizespoj[213700];
int tempspoj = 1;
void dfs3(int a) {
vis3[a] = true;
spojna[a] = tempspoj;
sizespoj[tempspoj]++;
for (int i = 0; i < g2[a].size(); i++) {
if (!vis3[g2[a][i]]) {
dfs3(g2[a][i]);
}
}
}
bool vis2[213730];
int gtemp = 1;
bool jestcykl[213799];
int grupa[213799];
void dfs2(int a) {
vis2[a] = true;
grupa[a] = gtemp;
for (int i = 0; i < gT[a].size(); i++) {
if (!vis2[gT[a][i]]) {
jestcykl[spojna[a]] = true;
dfs2(gT[a][i]);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
gT[b].push_back(a);
g2[b].push_back(a);
g2[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
if (!vis1[i]) {
dfs1(i);
}
if (!vis3[i]) {
dfs3(i);
tempspoj++;
}
}
for (int i = n; i >= 1; i--) {
if (!vis2[revnum[i]]) {
dfs2(revnum[i]);
gtemp++;
}
}
int wynik = 0;
for (int i = 1; i <= n; i++) {
if (sizespoj[i] != 0) {
if (jestcykl[i]) {
wynik += sizespoj[i];
} else
wynik += sizespoj[i] - 1;
}
}
cout << wynik;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool great[1005];
int t[1005], l[1005], r[1005];
int a[1005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> t[i] >> l[i] >> r[i];
if (t[i] == 1) {
for (int j = l[i] + 1; j <= r[i]; j++) great[j] = true;
}
}
a[1] = 5e5;
for (int j = 2; j <= n; j++) {
if (great[j])
a[j] = a[j - 1] + 1;
else
a[j] = a[j - 1] - 1;
}
for (int i = 1; i <= m; i++) {
if (t[i]) continue;
bool clear = false;
for (int j = l[i] + 1; j <= r[i]; j++) {
if (a[j - 1] > a[j]) {
clear = true;
}
}
if (!clear) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010, inf = 1e9 + 233;
int n, m;
int f[maxn][2], a[maxn], b[maxn];
template <typename T>
inline void read(T &k) {
int f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
inline bool check(int mid) {
f[0][0] = f[0][1] = 0;
for (int T = 1; T <= 2; T++) {
int pre0 = f[0][0], pre1 = f[0][1];
memset(f, 0x3f, sizeof(f));
f[0][0] = pre0;
f[0][1] = pre1;
for (int i = 0; i < n; i++) {
if (f[i][0] <= 0)
f[i][1] = -mid;
else if (f[i][0] <= mid)
f[i][1] = min(f[i][1], 0);
else
return 0;
if (f[i][0] > 0) {
int len = a[i + 1] - a[i] + f[i][0];
if (len <= mid) f[i + 1][1] = min(f[i + 1][1], a[i + 1] - a[i] - mid);
}
f[i + 1][0] = a[i + 1] - a[i] - 1 + f[i][1];
}
if (f[n][0] <= pre0 && f[n][1] <= pre1) return 1;
f[0][0] = f[n][0];
f[0][1] = f[n][1];
}
return 0;
}
int main() {
read(m);
read(n);
for (int i = 0; i < n; i++) read(a[i]);
int mxlen = 0, mxpos = 0;
for (int i = 0; i < n - 1; i++)
if (mxlen < a[i + 1] - a[i]) mxlen = a[i + 1] - a[i], mxpos = i;
if (a[0] - a[n - 1] + m > mxlen) mxlen = a[0] - a[n - 1] + m, mxpos = n - 1;
for (int i = 0; i < mxpos; i++) b[i + n - mxpos] = a[i] + m;
for (int i = mxpos; i < n; i++) b[i - mxpos] = a[i];
memcpy(a, b, sizeof(b));
a[n] = a[0] + m;
int l = 0, r = mxlen;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
double const pi = 3.1415926535897932384626433832795;
int const inf = (int)1e9 + 1;
long long const inf64 = (long long)4e18 + 1;
const string name = "b";
int l1, l2, r1, r2, k;
long long ans;
vector<int> now;
void rec(int zn, int n) {
if (zn > 0) now.push_back(n);
if (zn == 9) return;
rec(zn + 1, n * 10 + 4);
rec(zn + 1, n * 10 + 7);
}
int main() {
cin >> l1 >> r1 >> l2 >> r2 >> k;
ans = 0;
now.clear();
rec(0, 0);
now.push_back(0);
now.push_back(inf);
sort((now).begin(), (now).end());
for (int i = 1; i < (int)now.size() - k; ++i) {
int L1 = max(now[i - 1] + 1, l1);
int R1 = min(now[i], r1);
int L2 = max(now[i + k - 1], l2);
int R2 = min(now[i + k] - 1, r2);
if (L1 <= R1 && L2 <= R2)
ans += (long long)(R1 - L1 + 1) * (long long)(R2 - L2 + 1);
}
for (int i = 1; i < (int)now.size() - k; ++i) {
int L1 = max(now[i - 1] + 1, l2);
int R1 = min(now[i], r2);
int L2 = max(now[i + k - 1], l1);
int R2 = min(now[i + k] - 1, r1);
if (L1 <= R1 && L2 <= R2)
ans += (long long)(R1 - L1 + 1) * (long long)(R2 - L2 + 1);
}
for (int i = 0; i < (int)(int)now.size(); i++)
if (k == 1 && l1 <= now[i] && now[i] <= r1 && l2 <= now[i] && now[i] <= r2)
ans--;
printf("%.10lf\n",
(double)ans / (double)(r2 - l2 + 1) / (double)(r1 - l1 + 1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j;
int g[111][111], rez[111][111], mini;
int ln[111], co[111], p1, p2;
int ans;
int main() {
scanf("%d%d", &n, &m);
mini = 1111;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
scanf("%d", &g[i][j]), mini = min(mini, g[i][j]), rez[i][j] = g[i][j];
if (mini > 0) {
if (n < m) {
for (i = 1; i <= n; i++) ln[i] += mini;
} else {
for (i = 1; i <= m; i++) co[i] += mini;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) g[i][j] -= mini;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (g[i][j] == 0) p1 = i, p2 = j;
for (i = 1; i <= n; i++) ln[i] += g[i][p2];
for (i = 1; i <= m; i++) co[i] += max(0, rez[1][i] - ln[1] - co[i]);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (ln[i] + co[j] != rez[i][j]) {
printf("-1");
return 0;
}
}
}
for (i = 1; i <= n; i++) ans += ln[i];
for (i = 1; i <= m; i++) ans += co[i];
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
for (j = 1; j <= ln[i]; j++) printf("row %d\n", i);
}
for (i = 1; i <= m; i++) {
for (j = 1; j <= co[i]; j++) printf("col %d\n", i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m[5], w[5];
for (int i = 0; i < 5; i++) cin >> m[i];
for (int i = 0; i < 5; i++) cin >> w[i];
int hs, hu;
cin >> hs >> hu;
int sum = 0;
for (int i = 0; i < 5; i++) {
sum +=
max(3 * (500 + 500 * i) / 10,
(1 * (500 + 500 * i) - m[i] * (500 + 500 * i) / 250) - 50 * w[i]);
}
sum += hs * 100 - hu * 50;
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;
char s[MAXN][10];
int id = 0, vis[MAXN], ans = 0;
map<char, int> mp;
struct Node {
char ch;
long long val;
} num[MAXN];
bool cmp(Node a, Node b) { return a.val > b.val; }
long long fast_pow(int a, int x) {
long long res = 1;
while (x) {
if (x & 1) {
res = res * a;
}
a *= a;
x >>= 1;
}
return res;
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", &s[i]);
vis[s[i][0] - 'a'] = true;
int len = strlen(s[i]);
for (int j = 0; j < len; j++) {
num[s[i][j] - 'a'].ch = s[i][j];
num[s[i][j] - 'a'].val += pow(10, len - j);
}
}
sort(num, num + 10, cmp);
int flag = true;
for (int i = 0; i < 10; i++) {
if (!vis[num[i].ch - 'a'] && flag) {
mp[num[i].ch] = 0;
flag = false;
} else {
mp[num[i].ch] = ++id;
}
}
for (int i = 0; i < n; i++) {
int len = strlen(s[i]);
int temp = 0;
for (int j = 0; j < len; j++) {
temp = temp * 10 + mp[s[i][j]];
}
ans += temp;
}
printf("%d\n", ans);
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, perm[305], m[305][305];
char s[305];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &perm[i]);
}
memset(m, 0, sizeof(m));
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < n; j++) {
if (s[j] == '1') {
m[i][j] = 1;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (m[i][j] == 1) {
for (int a = 0; a < n; a++) {
if (m[i][a] == 1 || m[j][a] == 1 || m[a][i] == 1 || m[a][j] == 1) {
m[i][a] = 1;
m[j][a] = 1;
m[a][i] = 1;
m[a][j] = 1;
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (m[i][j] && perm[j] < perm[i]) {
swap(perm[j], perm[i]);
}
}
}
for (int i = 0; i < n; i++) {
if (i != 0) {
printf(" ");
}
printf("%d", perm[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
vector<int> ad[2005];
int ara[2005], sz[2005], ans_ara[2005];
set<int> st;
void dfs(int src, int pre) {
sz[src] = 1;
for (int v : ad[src]) {
if (v == pre) continue;
dfs(v, src);
sz[src] += sz[v];
}
}
void dfs2(int src, int pre) {
set<int>::iterator it;
int cnt = 0;
for (it = st.begin(); it != st.end(); it++) {
if (cnt == ara[src]) {
ans_ara[src] = *it;
st.erase(*it);
break;
}
++cnt;
}
for (int v : ad[src]) {
if (v == pre) continue;
dfs2(v, src);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, j, root, p;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> p >> ara[i];
if (!p) root = i;
if (p) {
ad[i].push_back(p);
ad[p].push_back(i);
}
}
dfs(root, 0);
for (i = 1; i <= n; i++) {
if (ara[i] > sz[i] - 1) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) st.insert(i);
dfs2(root, 0);
for (i = 1; i <= n; i++) cout << ans_ara[i] << ' ';
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 1e5;
const long long inf = 1e9;
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
template <typename... T>
void writeline(T&&... args) {
((cout << args << " "), ...);
cout << "\n";
}
long long add(long long a, long long b) {
long long res = (a + b) % mod;
return (res < 0) ? res + mod : res;
}
long long mul(long long a, long long b) {
long long res = (a * 1LL * b) % mod;
return (res < 0) ? res + mod : res;
}
string binary(long long x) {
string res = "";
for (long long i = 0; i < 32; i++) res += (1 << i & x) ? '1' : '0';
return res;
}
long long in(long long x, long long y, long long z) {
if (y > z) swap(y, z);
return (x >= y && x <= z);
}
void solve() {
long long n, m, h;
read(n, m, h);
long long x = 0;
long long sum = 0;
for (long long i = 0; i < m; i++) {
long long y;
read(y);
if (i == h - 1)
x = y - 1;
else
sum += y;
}
if (sum + x + 1 < n) {
cout << -1;
} else if (n > sum + 1) {
cout << 1;
} else {
n--;
double p = 1.0;
double a = sum - n + x, b = sum + x;
while (x--) {
p *= a / b;
a--, b--;
}
p = 1 - p;
cout << fixed << setprecision(7) << p;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lld = int64_t;
const lld INF = static_cast<lld>(1) << 60;
const int N = 5000 + 5;
lld arr[N], dp[N][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, x;
cin >> n >> k >> x;
for (int i = 1; i <= n; ++i) cin >> arr[i];
int me = 0, he = 1;
for (int i = 0; i <= n; ++i) dp[i][he] = -INF;
dp[0][he] = 0;
for (int j = 1; j <= x; ++j) {
deque<pair<lld, int> > dq;
dq.push_back({dp[0][he], 0});
for (int i = 1; i <= n; ++i) {
if (dq.front().second < i - k) dq.pop_front();
dp[i][me] = dq.front().first + arr[i];
while (not dq.empty() and dq.back().first <= dp[i][he]) dq.pop_back();
dq.push_back({dp[i][he], i});
}
dp[0][me] = -INF;
swap(me, he);
}
lld ans = -INF;
for (int i = 0; i < k and i <= n; ++i) ans = max(ans, dp[n - i][he]);
cout << (ans < 0 ? -1 : ans) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
int a[maxn];
map<vector<pair<int, int> >, int> mp;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long ans = 0;
for (int i = 0; i < n; i++) {
vector<pair<int, int> > v1;
for (int cur = 2; cur * cur <= a[i]; cur++) {
int num = 0;
while (a[i] % cur == 0) {
a[i] /= cur;
num++;
}
if (num % k) v1.push_back(make_pair(cur, num % k));
}
if (a[i] > 1) v1.push_back(make_pair(a[i], 1));
vector<pair<int, int> > v2;
for (int j = 0; j < v1.size(); j++) {
v2.push_back(make_pair(v1[j].first, k - v1[j].second));
}
ans += mp[v2];
mp[v1]++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prime;
const int N = 5e6 + 10;
bool pri[N];
int mu[N];
int phi[N];
int sum1[N], sum2[N];
void init() {
memset(pri, true, sizeof(pri));
mu[1] = 1;
phi[1] = 1;
for (int i = 2; i < N; i++) {
if (pri[i]) {
prime.push_back(i);
mu[i] = -1;
phi[i] = i - 1;
}
for (int j = 0; j < prime.size() && i * prime[j] < N; j++) {
int k = i * prime[j];
pri[k] = false;
if (i % prime[j]) {
mu[k] = -mu[i];
phi[k] = phi[i] * (prime[j] - 1);
} else {
mu[k] = 0;
phi[k] = phi[i] * prime[j];
break;
}
}
}
for (int i = (1); i < (N); i++) {
sum1[i] = sum1[i - 1] + mu[i];
sum2[i] = sum2[i - 1] + phi[i];
}
}
int main() {
init();
int n, k;
cin >> n >> k;
if (k == 1) {
cout << "3";
return 0;
}
long long ans = 0;
sort(phi + 3, phi + 1 + n);
for (int i = (0); i < (k); i++) {
ans += phi[i + 3];
}
cout << ans + phi[1] + phi[2];
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x0, y0, ax, ay, bx, by;
cin >> x0 >> y0 >> ax >> ay >> bx >> by;
long long int xs, ys, t;
cin >> xs >> ys >> t;
long long int ans = 0;
long long int _x0 = x0, _y0 = y0;
while (1) {
long long int _t = t;
long long int x = xs, y = ys;
long long int x_data = x0, y_data = y0;
long long int cnt = 0;
while (_t >= (abs(x - x_data) + abs(y - y_data))) {
cnt++;
_t -= (abs(x - x_data) + abs(y - y_data));
x = x_data;
y = y_data;
x_data = x_data * ax + bx;
y_data = y_data * ay + by;
}
ans = max(ans, cnt);
x_data = x0, y_data = y0;
_t = t;
x = xs, y = ys;
cnt = 0;
while (_t >= (abs(x - x_data) + abs(y - y_data)) && x_data >= _x0 &&
y_data >= _y0) {
cnt++;
_t -= (abs(x - x_data) + abs(y - y_data));
x = x_data;
y = y_data;
x_data = (x_data - bx) / ax;
y_data = (y_data - by) / ay;
}
ans = max(ans, cnt);
if (x0 > xs && y0 > ys) break;
x0 = x0 * ax + bx;
y0 = y0 * ay + by;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
int n;
int cnt[1000][1000];
int mat[5][5];
bool check(int x) {
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
int calc(int m) {
if (m == n) return 1;
if (n - m == 2) {
int x = 0, y = 0;
for (int i = 0; i < m; ++i) {
x = x * 10 + mat[n - 2][i];
y = y * 10 + mat[n - 1][i];
}
if (cnt[x][y] != -1) return cnt[x][y];
int &ret = cnt[x][y] = 0;
x *= 100;
int l = lower_bound(primes.begin(), primes.end(), x) - primes.begin();
int r = upper_bound(primes.begin(), primes.end(), x + 99) - primes.begin();
for (int i = l; i < r; ++i) {
for (int j = 0, k = primes[i]; j < n; ++j, k /= 10) {
mat[m][n - j - 1] = k % 10;
if (n - j - 1 > m) mat[n - j - 1][m] = k % 10;
}
ret += calc(m + 1);
}
return ret;
}
int x = 0, y = 1;
for (int i = 0; i < m; ++i) x = x * 10 + mat[m][i];
for (int i = m; i < n; ++i) y *= 10;
x *= y;
int l = lower_bound(primes.begin(), primes.end(), x) - primes.begin();
int r = upper_bound(primes.begin(), primes.end(), x + y - 1) - primes.begin();
int ret = 0;
for (int i = l; i < r; ++i) {
for (int j = 0, k = primes[i]; j < n; ++j, k /= 10) {
mat[m][n - j - 1] = k % 10;
if (n - j - 1 > m) mat[n - j - 1][m] = k % 10;
}
ret += calc(m + 1);
}
return ret;
}
int main() {
for (int i = 2; i < 100000; ++i)
if (check(i)) primes.push_back(i);
memset(cnt, -1, sizeof(cnt));
int m;
cin >> m;
while (m--) {
int x, y;
cin >> x;
y = x;
for (n = 0; x; x /= 10) {
mat[0][n] = x % 10;
n++;
}
x = y;
reverse(mat[0], mat[0] + n);
for (int i = 0; i < n; ++i) mat[i][0] = mat[0][i];
cout << calc(1) << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 2e5 + 5;
long long a[LIM], b[LIM];
int solve() {
int m;
cin >> m;
int flag = 1;
int flag2 = 0;
for (int i = 0; i < m; i++) {
cin >> a[i];
b[i] = a[i];
if (i > 0) {
if (a[i] < a[i - 1]) {
flag = 0;
}
}
}
sort(a, a + m);
int early = 1;
for (int i = 0; i < m; i++) {
if (a[i] != b[i]) {
early = 0;
}
if (a[i] == b[i] && flag2 == 0 && early == 0) {
flag2 = 1;
}
if (a[i] != b[i] && flag2 == 1) {
flag2 = 2;
}
}
if (flag) {
cout << 0 << endl;
} else if (flag2 == 2) {
cout << 2 << endl;
} else {
cout << 1 << endl;
}
return 0;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
int ans = -1;
char s[4][105];
int strlen(char x[]) {
for (int i = 0;; i++)
if (!x[i]) return i;
}
int main() {
scanf("A.%[^\n]\n", s[0]);
scanf("B.%[^\n]\n", s[1]);
scanf("C.%[^\n]\n", s[2]);
scanf("D.%[^\n]\n", s[3]);
for (int i = 0; i < 4; i++) {
int sh = 0, lo = 0;
for (int j = 0; j < 4; j++) {
if (strlen(s[i]) * 2 <= strlen(s[j]))
sh++;
else if (strlen(s[i]) >= strlen(s[j]) * 2)
lo++;
}
if ((sh == 3 || lo == 3) && ans == -1)
ans = i;
else if ((sh == 3 || lo == 3) && ans != -1)
ans = -2;
}
printf("%c\n", ans > -1 ? 'A' + ans : 'C');
return 0;
}
| 2 |
#include <bits/stdc++.h>
void distinct_numbers_in_arr(int arr[100], int n) {
for (int i = 1; i < n; i++) {
for (int j = i; j < n; j++) {
if (arr[i - 1] == arr[j]) arr[j] = 0;
}
}
}
int gcd(int a, int b) {
int d = 0;
for (int i = 1; i <= a; i++)
if (b % i == 0 && a % i == 0) d = i;
return d;
}
int cut_number(long long n) {
int c = 0;
while (n > 0) {
n = n / 10;
c++;
}
return c;
}
int fact_num(int n) {
int sum = 1;
for (int i = 1; i <= n; i++) sum *= i;
return sum;
}
void sort_arr(int arr[], int size) {
int index;
for (int i = 0; i < size; i++) {
index = i;
for (int j = i; j < size; j++)
if (arr[j] < arr[index]) {
index = j;
}
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a[100000], p[100000];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i] >> p[i];
int c = 0, sum = 0, total = 0;
for (int i = 0; i < n; i += c) {
c = 0;
sum = 0;
for (int j = i; j < n; j++) {
if (p[i] <= p[j]) {
c++;
sum += a[j];
} else {
if (c <= 1) c = 1;
break;
}
}
total += sum * p[i];
}
cout << total << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long sol(long long x, long long y, long long z) {
return (x - y) * (x - y) + (y - z) * (y - z) + (z - x) * (z - x);
}
int main() {
long long t;
cin >> t;
while (t--) {
vector<long long> a(3);
for (int i = 0; i < 3; i++) {
cin >> a[i];
}
vector<long long> r, g, b;
for (int i = 0; i < a[0]; i++) {
long long te;
cin >> te;
r.push_back(te);
}
for (int i = 0; i < a[1]; i++) {
long long te;
cin >> te;
g.push_back(te);
}
for (int i = 0; i < a[2]; i++) {
long long te;
cin >> te;
b.push_back(te);
}
sort(r.begin(), r.end());
sort(g.begin(), g.end());
sort(b.begin(), b.end());
long long ans = 9e18;
for (int i = 0; i < r.size(); i++) {
int k = lower_bound(g.begin(), g.end(), r[i]) - g.begin();
int l = upper_bound(b.begin(), b.end(), r[i]) - b.begin();
if (k == g.size()) k--;
if (l > 0) l--;
if (l == b.size()) l--;
long long m = sol(r[i], g[k], b[l]);
ans = min(ans, m);
}
for (int i = 0; i < g.size(); i++) {
int k = lower_bound(r.begin(), r.end(), g[i]) - r.begin();
int l = upper_bound(b.begin(), b.end(), g[i]) - b.begin();
if (k == r.size()) k--;
if (l > 0) l--;
if (l == b.size()) l--;
long long m = sol(r[k], g[i], b[l]);
ans = min(ans, m);
}
for (int i = 0; i < b.size(); i++) {
int k = lower_bound(g.begin(), g.end(), b[i]) - g.begin();
int l = upper_bound(r.begin(), r.end(), b[i]) - r.begin();
if (k == g.size()) k--;
if (l > 0) l--;
if (l == r.size()) l--;
long long m = sol(r[l], g[k], b[i]);
ans = min(ans, m);
}
for (int i = 0; i < r.size(); i++) {
int k = upper_bound(g.begin(), g.end(), r[i]) - g.begin();
int l = lower_bound(b.begin(), b.end(), r[i]) - b.begin();
if (l == b.size()) l--;
if (k > 0) k--;
if (k == g.size()) k--;
long long m = sol(r[i], g[k], b[l]);
ans = min(ans, m);
}
for (int i = 0; i < g.size(); i++) {
int k = upper_bound(r.begin(), r.end(), g[i]) - r.begin();
int l = lower_bound(b.begin(), b.end(), g[i]) - b.begin();
if (l == b.size()) l--;
if (k > 0) k--;
if (k == r.size()) k--;
long long m = sol(r[k], g[i], b[l]);
ans = min(ans, m);
}
for (int i = 0; i < b.size(); i++) {
int k = upper_bound(g.begin(), g.end(), b[i]) - g.begin();
int l = lower_bound(r.begin(), r.end(), b[i]) - r.begin();
if (l == r.size()) l--;
if (k > 0) k--;
if (k == g.size()) k--;
long long m = sol(r[l], g[k], b[i]);
ans = min(ans, m);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long sum_d(long long x) {
long long sum = 0;
while (x != 0) {
sum += x % 10;
x = x / 10;
}
return sum;
}
int main() {
long long n, k, l, r, mid, ans = 0;
cin >> n >> k;
l = 1;
r = n;
while (l <= r) {
mid = (l + r) / 2;
if (mid - sum_d(mid) >= k) {
ans = n - mid + 1;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
int dis[N][N][2], vis[N][N][2];
int n, x[2], y[2];
struct node {
int x, y, z, d;
bool operator<(const node &a) const { return d > a.d; }
} now;
priority_queue<node> q;
char mp[N][N];
int sqr(int x) { return x * x; }
int main() {
cin >> n;
cin >> x[0] >> y[0] >> x[1] >> y[1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j][0] = dis[i][j][1] = 1e9;
for (int i = 1; i <= n; i++) scanf("%s", mp[i] + 1);
dis[x[0]][y[0]][0] = 0;
q.push((node){x[0], y[0], 0, 0});
while (!q.empty()) {
now = q.top();
q.pop();
if (vis[now.x][now.y][now.z]) continue;
vis[now.x][now.y][now.z] = 1;
for (int nx, ny, i = 0; i < 4; i++) {
nx = now.x + dx[i], ny = now.y + dy[i];
if (nx <= 0 || nx > n || ny <= 0 || ny > n || mp[nx][ny] == '1') continue;
if (now.d < dis[nx][ny][now.z])
q.push((node){nx, ny, now.z, dis[nx][ny][now.z] = now.d});
}
if (now.z == 0) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (mp[i][j] == '0' && !vis[i][j][1] &&
now.d + sqr(now.x - i) + sqr(now.y - j) < dis[i][j][now.z])
q.push((node){i, j, 1,
dis[i][j][now.z] =
min(dis[i][j][now.z],
now.d + sqr(now.x - i) + sqr(now.y - j))});
}
}
cout << min(dis[x[1]][y[1]][0], dis[x[1]][y[1]][1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
inline long long GCD(long long x, long long y) {
long long r = x % y;
while (r) {
x = y;
y = r;
r = x % y;
}
return y;
}
const long long N = 1e6 + 69;
signed main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
set<pair<long long, long long> > s1, s2;
map<long long, long long> m1;
for (long long i = 0; i < k; i++) {
m1[a[i]]++;
}
for (auto it : m1) {
if (it.second == 1) {
s1.insert({it.first, it.second});
} else {
s2.insert({it.first, it.second});
}
};
;
vector<long long> ans;
if ((long long)s1.size()) {
long long var = (*(s1.rbegin())).first;
;
ans.push_back(var);
} else {
ans.push_back(-1);
}
for (long long i = k; i < n; i++) {
m1[a[i - k]]--;
m1[a[i]]++;
pair<long long, long long> p = {a[i - k], m1[a[i - k]] + 1};
;
;
;
if (s1.find(p) != s1.end()) {
s1.erase(p);
} else if (s2.find(p) != s2.end()) {
s2.erase(p);
p.second--;
if (p.second == 1)
s1.insert(p);
else
s2.insert(p);
}
p = {a[i], m1[a[i]] - 1};
if (s1.find(p) != s1.end()) {
s1.erase(p);
} else if (s2.find(p) != s2.end()) {
s2.erase(p);
}
p.second++;
if (p.second == 1) {
s1.insert(p);
} else {
s2.insert(p);
}
if ((long long)s1.size())
ans.push_back((*(s1.rbegin())).first);
else
ans.push_back(-1);
}
for (long long x : ans) {
if (x == -1)
cout << "Nothing" << '\n';
else
cout << x << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long tt = 1000000007;
inline int read() {
int Res = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') f = (ch == '-' ? -f : f), ch = getchar();
while (ch >= '0' && ch <= '9') Res = Res * 10 + ch - '0', ch = getchar();
return Res * f;
}
long long F[100005], Ans, InvM;
int M;
long long qsm(long long x, long long y) {
long long Sum = 1;
while (y) {
if (y & 1) Sum = (Sum * x) % tt;
x = (x * x) % tt;
y >>= 1;
}
return Sum;
}
bool vis[100005];
int Prime[100005], mu[100005];
vector<int> fac[100005];
inline void Maker() {
mu[1] = 1;
for (int i = 2; i <= M; i++) {
if (!vis[i]) Prime[++Prime[0]] = i, mu[i] = tt - 1;
for (int j = 1; j * j <= i; j++) {
if (i % j) continue;
fac[i].push_back(j);
if (j * j != i) fac[i].push_back(i / j);
}
for (int j = 1; j <= Prime[0] && i * Prime[j] <= M; j++) {
vis[i * Prime[j]] = 1;
if (i % Prime[j] == 0) break;
mu[i * Prime[j]] = tt - mu[i];
}
}
}
long long Calc(long long x, long long y) {
long long Res = 0;
long long z = M / y;
for (int i : fac[x]) Res = (Res + (z / i) * mu[i] % tt) % tt;
return Res;
}
int main() {
M = read();
InvM = qsm(M, tt - 2);
F[1] = 0;
Ans = 1;
Maker();
for (int i = 2; i <= M; i++) {
long long Fm = (1 - InvM * (M / i) % tt + tt) % tt;
for (int j : fac[i]) {
if (j == i || j == 1) continue;
F[i] = (F[i] + F[j] * Calc(i / j, j) % tt) % tt;
}
F[i] = F[i] * InvM % tt + 1;
F[i] = F[i] * qsm(Fm, tt - 2) % tt;
Ans = (Ans + F[i] + 1) % tt;
}
printf("%lld\n", Ans * InvM % tt);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long NLINF = 0xf7f7f7f7f7f7f7f7;
const int INF = 0x3f3f3f3f, NINF = 0xf7f7f7f7;
const int MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
const int N = 1e5 + 10;
string s;
int n;
string sum(string a, string b) {
int off = 0, cur = 0;
string ret;
ret.resize(max((int)a.size(), (int)b.size()) + 1);
for (int i1 = (int)a.size() - 1, i2 = (int)b.size() - 1; i1 >= 0 or i2 >= 0;
i1--, i2--) {
int n1 = (i1 < 0 ? 0 : a[i1] - '0');
int n2 = (i2 < 0 ? 0 : b[i2] - '0');
int d = (n1 + n2 + off) % 10, rem = (n1 + n2 + off) / 10;
;
off = rem;
ret[cur++] = char(d + '0');
}
if (off) ret[cur++] = char(off + '0');
reverse(ret.begin(), ret.begin() + cur);
;
return ret;
}
int main() {
scanf("%d", &n);
s.resize(n);
scanf("%s", s.c_str());
int k1 = 0, k2 = n;
for (int i = 1; i <= n / 2; i++)
if (s[i] != '0') k1 = i;
for (int i = n; i > n / 2; i--)
if (s[i] != '0') k2 = i;
string s1 = sum(s.substr(0, k1), s.substr(k1, n - k1));
string s2 = sum(s.substr(0, k2), s.substr(k2, n - k2));
if ((int)s1.size() == (int)s2.size() && s1 > s2)
s1 = s2;
else if ((int)s1.size() > (int)s2.size())
s1 = s2;
printf("%s\n", s1.c_str());
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long M = (long long)1e9 + 7;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%I64d", &x);
return x;
}
void Char(char* ch) { scanf("%s", ch); }
template <typename t>
t abs(t a) {
if (a >= 0) return a;
return -a;
}
template <typename t>
t Range(vector<t> v, t x) {
auto u = equal_range(v.begin(), v.end(), x);
return u.second - u.first;
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
vector<int> g[N];
map<pair<int, int>, int> id;
int sz[N], dep[N], par[N][21], freq[N], res[N];
void dfs(int s, int p = -1) {
par[s][0] = p;
dep[s] = 1 + dep[p];
sz[s] = 1;
for (int i = 1; i <= 20; i++) {
par[s][i] = par[par[s][i - 1]][i - 1];
}
for (auto u : g[s]) {
if (u == p) continue;
dfs(u, s);
sz[s] += sz[u];
}
}
int GetLCA(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int d = dep[a] - dep[b];
for (int i = 20; i >= 0; i--) {
if (d & (1 << i)) {
a = par[a][i];
}
}
if (a == b) return a;
for (int i = 20; i >= 0; i--) {
if (par[a][i] != par[b][i]) {
a = par[a][i];
b = par[b][i];
}
}
return par[a][0];
}
void Find(int s, int p = -1) {
int ans = 0;
for (auto u : g[s]) {
if (u == p) continue;
Find(u, s);
res[id[{s, u}]] = freq[u];
ans += freq[u];
}
freq[s] += ans;
}
int main() {
int n = Int();
for (int i = 1; i < n; i++) {
int l = Int(), r = Int();
g[l].push_back(r);
g[r].push_back(l);
id[{l, r}] = id[{r, l}] = i;
}
dfs(1);
int q = Int();
while (q--) {
int a = Int(), b = Int();
int LCA = GetLCA(a, b);
freq[a]++, freq[b]++;
freq[LCA] -= 2;
}
Find(1);
for (int i = 1; i < n; i++) {
printf("%d ", res[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int k, n;
int m[1000];
void solve() {
char board[k][k];
int acum[k][k + 1];
int acum2[k][k + 1];
memset(acum, 0, sizeof(acum));
memset(board, 0, sizeof(board));
int xc = k / 2, yc = xc;
for (int x = 0; x < k; x++) {
acum2[x][0] = 0;
for (int y = 0; y < k; y++) {
acum2[x][y + 1] = acum2[x][y] + std::max(y - yc, yc - y);
}
}
for (int i = 0; i < n; i++) {
int w = m[i];
int bx = -1, by = -1, bs = -1;
for (int x = 0; x < k; x++) {
for (int y = 0; y <= k - w; y++) {
if (acum[x][y + w] - acum[x][y] == 0) {
int s = std::max(x - xc, xc - x) * w + acum2[x][y + w] - acum2[x][y];
if ((bs == -1) || (bs > s) ||
((bs == s) && ((bx > x) || ((bx == x) && (by > y))))) {
bx = x, by = y, bs = s;
}
}
}
}
if (bx == -1) {
cout << -1 << endl;
} else {
cout << (bx + 1) << " " << (by + 1) << " " << (by + w) << endl;
for (int y = by; y < by + w; y++) {
board[bx][y] = 1;
}
acum[bx][0] = 0;
for (int y = 0; y < k; y++) {
acum[bx][y + 1] = acum[bx][y] + board[bx][y];
}
}
}
}
inline void init() {}
int main() {
init();
while (cin >> n >> k) {
for (int i = 0; i < n; i++) {
cin >> m[i];
}
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r1, r2;
cin >> n >> r1 >> r2;
int A[n + 1];
for (int i = 1; i <= n; ++i) {
if (i == r1)
A[i] = 0;
else
cin >> A[i];
}
int v = r2, u = A[r2];
while (u != 0) {
int x = A[u];
A[u] = v;
v = u;
u = x;
}
for (int i = 1; i <= n; i++)
if (i != r2) cout << A[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> cnt(m, 0), ans(n);
vector<pair<long long, long long>> a;
long long req = n / m;
for (long long i = 0; i < n; i++) {
long long xx;
cin >> xx;
ans[i] = xx;
cnt[xx % m]++;
if (cnt[xx % m] > req) {
a.push_back({xx % m, i});
}
}
sort(a.begin(), a.end());
long long sz = a.size();
set<long long> tmp;
for (long long i = 0; i < m; i++) {
if (cnt[i] < req) tmp.insert(i);
}
long long j = 0, szz = tmp.size();
long long res = 0;
for (long long i = 0; i < sz; i++) {
long long foo, mn = 1e18;
auto it = tmp.upper_bound(a[i].first);
if (it == tmp.end()) {
it = tmp.begin();
}
mn = *it - a[i].first;
if (mn < 0) mn += m;
res += mn;
ans[a[i].second] += mn;
cnt[*it]++;
if (cnt[*it] == req) {
tmp.erase(it);
}
}
cout << res << endl;
for (long long i = 0; i < n; i++) cout << ans[i] << " ";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int N = 1000000 + 10;
const int M = 1000;
const string st2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string s1 = "abcdefghijklmnopqrstuvwxyz";
pair<int, int> a[N];
int b[N];
string ans[N], da[N];
int main() {
cin >> b[1] >> b[2] >> b[3] >> b[4] >> b[5] >> b[6];
int n;
cin >> n;
da[1] = "S";
da[2] = "M";
da[3] = "L";
da[4] = "XL";
da[5] = "XXL";
da[6] = "XXXL";
for (int i = 1; i <= n; i++) {
string second;
cin >> second;
if (second == "S")
a[i] = make_pair(1, 0);
else if (second == "M")
a[i] = make_pair(2, 0);
else if (second == "L")
a[i] = make_pair(3, 0);
else if (second == "XL")
a[i] = make_pair(4, 0);
else if (second == "XXL")
a[i] = make_pair(5, 0);
else if (second == "XXXL")
a[i] = make_pair(6, 0);
else if (second[0] == 'S')
a[i] = make_pair(1, 1);
else if (second[0] == 'M')
a[i] = make_pair(2, 1);
else if (second[0] == 'L')
a[i] = make_pair(3, 1);
else if (second[1] == 'L')
a[i] = make_pair(4, 1);
else if (second[2] == 'L')
a[i] = make_pair(5, 1);
else
a[i] = make_pair(6, 1);
}
for (int i = 1; i <= n; i++)
if (a[i].second == 0) {
if (b[a[i].first] != 0) {
ans[i] = da[a[i].first];
b[a[i].first]--;
}
}
for (int i = 1; i <= 6; i++) {
for (int j = 1; j <= n; j++)
if (ans[j] == "" && a[j].second == 1) {
if (a[j].first + 1 == i && b[i] > 0) {
b[i]--;
ans[j] = da[i];
}
}
for (int j = 1; j <= n; j++)
if (ans[j] == "" && a[j].second == 1) {
if (a[j].first == i && b[i] > 0) {
b[i]--;
ans[j] = da[i];
}
}
}
for (int i = 1; i <= n; i++)
if (ans[i] == "") {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > s;
struct block {
int u;
int l;
int d;
int r;
};
vector<block> bl;
void step(int &bp, int &state) {
int dx, dy, x, y;
x = bl[bp].u;
y = bl[bp].l;
dx = -1;
dy = -1;
if (state / 2 == 0) {
y = bl[bp].r;
dy = 1;
} else if (state / 2 == 1) {
x = bl[bp].d;
y = bl[bp].r;
dx = 1;
dy = 1;
} else if (state / 2 == 2) {
x = bl[bp].d;
dx = 1;
}
if (state / 2 % 2 == 0) {
if (state % 2 == 0) {
dy = 0;
} else {
dx = 0;
}
} else {
if (state % 2 != 0) {
dy = 0;
} else {
dx = 0;
}
}
if (s[x + dx][y + dy] == -1) {
state++;
state %= 8;
} else {
bp = s[x + dx][y + dy];
}
}
int main() {
int n, m;
cin >> m >> n;
vector<vector<char> > p(m + 2, vector<char>(52, '0'));
s = vector<vector<int> >(m + 2, vector<int>(52, -1));
int bp = 0;
int state = 1;
int d = -1;
getchar();
int t;
for (int i = 1; i <= m; i++) {
char c = getchar();
t = 1;
while (c != '\n' && c != EOF) {
p[i][t] = c;
c = getchar();
if (p[i][t] == p[i - 1][t]) {
s[i][t] = s[i - 1][t];
} else if (p[i][t] == p[i][t - 1]) {
s[i][t] = s[i][t - 1];
} else if (p[i][t] != '0') {
d++;
s[i][t] = d;
}
t++;
}
}
bl = vector<block>(d + 1);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= 50; j++) {
if (p[i][j] != p[i - 1][j] && p[i][j] != p[i][j - 1] && p[i][j] != '0') {
bl[s[i][j]].u = i;
bl[s[i][j]].l = j;
}
if (p[i][j] != p[i + 1][j] && p[i][j] != p[i][j + 1] && p[i][j] != '0') {
bl[s[i][j]].d = i;
bl[s[i][j]].r = j;
}
}
}
for (int i = 0; i < n; i++) {
step(bp, state);
}
cout << p[bl[bp].u][bl[bp].l];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
const int MAXSUMLEN = 200000;
const int MAXT = MAXSUMLEN + 1;
const int MAXQ = 500000;
const int ASIZE = 26;
typedef struct Q {
int x, sgn, l, r, idx;
} Q;
int n, nq;
int off[MAXN], len[MAXN];
char s[MAXSUMLEN + 1];
int nt, root;
int tnxt[MAXT][ASIZE];
int lst[MAXN];
int f[MAXT];
int q[MAXT], qhead, qtail;
int ufst[MAXT], unxt[MAXT];
int np;
int pfst[MAXT], pnxt[MAXSUMLEN], pidx[MAXSUMLEN];
int na;
int a[MAXSUMLEN];
int la[MAXT], ra[MAXT];
int afst[MAXN], anxt[MAXSUMLEN];
int ql[MAXQ], qr[MAXQ], qk[MAXQ];
int qlfst[MAXN], qlnxt[MAXQ];
int qrfst[MAXN], qrnxt[MAXQ];
int ret[MAXQ];
int fw[MAXN + 1];
int create() {
for (int i = (0); i < (ASIZE); ++i) tnxt[nt][i] = -1;
pfst[nt] = -1;
return nt++;
}
void build(int i) {
int at = root;
for (int j = (0); j < (len[i]); ++j) {
int x = s[off[i] + j] - 'a';
if (tnxt[at][x] == -1) tnxt[at][x] = create();
at = tnxt[at][x];
pnxt[np] = pfst[at];
pfst[at] = np;
pidx[np] = i;
++np;
}
lst[i] = at;
}
void ahoc() {
qhead = qtail = 0;
f[root] = root;
q[qhead++] = root;
while (qtail < qhead) {
int at = q[qtail++];
for (int i = (0); i < (ASIZE); ++i)
if (tnxt[at][i] != -1) {
int to = tnxt[at][i];
q[qhead++] = to;
f[to] = f[at];
while (f[to] != root && tnxt[f[to]][i] == -1) f[to] = f[f[to]];
if (at != root && tnxt[f[to]][i] != -1) f[to] = tnxt[f[to]][i];
}
}
}
void makea(int at) {
la[at] = na;
for (int y = pfst[at]; y != -1; y = pnxt[y]) a[na++] = pidx[y];
for (int x = ufst[at]; x != -1; x = unxt[x]) makea(x);
ra[at] = na;
}
void printt(int at, int d = 0) {
for (int i = (0); i < (ASIZE); ++i)
if (tnxt[at][i] != -1) {
int to = tnxt[at][i];
for (int j = (0); j < (d); ++j) printf(" ");
printf("%d=%c", to, 'a' + i);
for (int y = pfst[to]; y != -1; y = pnxt[y]) printf(" %d", pidx[y]);
printf(" (%d)\n", f[to]);
printt(to, d + 1);
}
}
void printu(int at, int d = 0) {
for (int x = ufst[at]; x != -1; x = unxt[x]) {
int to = x;
for (int j = (0); j < (d); ++j) printf(" ");
printf("%d=%c", to, '?');
for (int y = pfst[to]; y != -1; y = pnxt[y]) printf(" %d", pidx[y]);
printf(" (%d)\n", f[to]);
printu(to, d + 1);
}
}
void fwinc(int x) {
while (x <= MAXN) {
fw[x]++;
x += x & -x;
}
}
int fwget(int x) {
int ret = 0;
while (x > 0) {
ret += fw[x];
x -= x & -x;
}
return ret;
}
int calc(int i) { return fwget(ra[lst[i]]) - fwget(la[lst[i]]); }
void input() {
scanf("%d%d", &n, &nq);
for (int i = (0); i < (n); ++i) {
off[i] = i == 0 ? 0 : off[i - 1] + len[i - 1];
scanf("%s", s + off[i]);
len[i] = strlen(s + off[i]);
}
s[off[n - 1] + len[n - 1]] = '\0';
for (int qi = (0); qi < (nq); ++qi) {
scanf("%d%d%d", &ql[qi], &qr[qi], &qk[qi]);
--ql[qi], --qr[qi], --qk[qi];
}
}
void solve() {
nt = np = 0;
root = create();
for (int i = (0); i < (n); ++i) build(i);
ahoc();
for (int i = (0); i < (nt); ++i) ufst[i] = -1;
unxt[root] = -1;
for (int i = (0); i < (nt); ++i)
if (i != root) {
unxt[i] = ufst[f[i]];
ufst[f[i]] = i;
}
na = 0;
makea(root);
for (int i = (0); i < (n); ++i) afst[i] = -1;
for (int i = (0); i < (na); ++i) anxt[i] = afst[a[i]], afst[a[i]] = i;
for (int i = (0); i < (n); ++i) qlfst[i] = qrfst[i] = -1;
for (int qi = (0); qi < (nq); ++qi) {
qlnxt[qi] = qlfst[ql[qi]], qlfst[ql[qi]] = qi;
qrnxt[qi] = qrfst[qr[qi]], qrfst[qr[qi]] = qi;
}
memset(fw, 0, sizeof(fw));
memset(ret, 0, sizeof(ret));
for (int i = (0); i < (n); ++i) {
for (int x = qlfst[i]; x != -1; x = qlnxt[x]) ret[x] -= calc(qk[x]);
for (int x = afst[i]; x != -1; x = anxt[x]) fwinc(x + 1);
for (int x = qrfst[i]; x != -1; x = qrnxt[x]) ret[x] += calc(qk[x]);
}
}
void run() {
input();
solve();
for (int qi = (0); qi < (nq); ++qi) printf("%d\n", ret[qi]);
}
void test() {
n = 441;
nq = 11;
for (int i = (0); i < (MAXSUMLEN); ++i) s[i] = 'a' + rand() % 26;
s[MAXSUMLEN] = '\0';
while (true) {
off[0] = 0;
for (int i = (1); i < (n); ++i) off[i] = rand() % MAXSUMLEN;
sort(off, off + n);
bool ok = true;
for (int i = (1); i < (n); ++i)
if (off[i] == off[i - 1]) ok = false;
if (ok) break;
}
for (int i = (0); i < (n - 1); ++i) len[i] = off[i + 1] - off[i];
len[n - 1] = MAXSUMLEN - off[n - 1];
for (int i = (0); i < (nq); ++i) {
ql[i] = rand() % n, qr[i] = rand() % n, qk[i] = rand() % n;
if (ql[i] > qr[i]) swap(ql[i], qr[i]);
}
solve();
for (int qi = (0); qi < (nq); ++qi) printf("%d\n", ret[qi]);
}
int main() {
run();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << 2 * (a + b + d) + 4;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)4e5 + 7;
const long long maxe = (long long)1e6 + 7;
const long long INF = (long long)1e17 + 7;
const double PI = acos(-1);
int dx[4] = {0, 0, 1, -1};
int dy[4] = {-1, 1, 0, 0};
int n;
struct E {
int to, from, id;
long long l;
E() {}
E(int from, int to, int id, long long l) : from(from), to(to), id(id), l(l) {}
};
vector<E> G[maxn];
vector<E> edge;
stack<E> sta;
vector<E> cir;
bool vis[maxn];
long long dep[maxn];
bool dfs1(int u, int fa) {
if (vis[u]) {
int t = -1;
while (t != u) {
cir.push_back(sta.top());
t = sta.top().from;
sta.pop();
}
return true;
}
vis[u] = true;
for (int i = 0; i < G[u].size(); i++) {
if (G[u][i].to == fa) continue;
sta.push(G[u][i]);
if (dfs1(G[u][i].to, u)) return true;
sta.pop();
}
return false;
}
pair<long long, long long> dfs1(int u) {
pair<long long, long long> res = make_pair(0, 0);
vis[u] = true;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].to;
if (vis[v]) continue;
pair<long long, long long> tmp = dfs1(v);
res.second = max(res.second, res.first + tmp.first + G[u][i].l);
res.second = max(res.second, tmp.second);
res.first = max(res.first, tmp.first + G[u][i].l);
}
return res;
}
long long ans = 0;
long long sum[maxn];
struct Node {
long long add;
long long sub;
long long res;
Node() {}
Node(int x) {
add = -INF;
sub = INF;
res = -INF;
}
};
Node merge(Node &a, Node &b) {
Node t;
t.add = max(a.add, b.add);
t.sub = min(a.sub, b.sub);
t.res = max(a.res, b.res);
t.res = max(t.res, b.add - a.sub);
return t;
}
Node tree[maxn * 4];
void init(int l, int r, int rt) {
if (l == r) {
tree[rt].add = sum[l] + dep[l];
tree[rt].sub = sum[l] - dep[l];
tree[rt].res = -INF;
return;
}
int m = (l + r) / 2;
init(l, m, rt << 1);
init(m + 1, r, rt << 1 | 1);
tree[rt] = merge(tree[rt * 2], tree[rt * 2 + 1]);
}
Node query(int k, int l, int r, int a, int b) {
if (l >= a && r <= b)
return tree[k];
else if (a > r || b < l)
return Node(-1);
int m = (l + r) / 2;
Node left = query(k << 1, l, m, a, b);
Node right = query(k << 1 | 1, m + 1, r, a, b);
return merge(left, right);
}
long long solve() {
int c_size = cir.size();
cir.insert(cir.end(), cir.begin(), cir.end());
for (int i = 0; i < c_size; i++) {
dep[i + c_size] = dep[i];
}
for (int i = 1; i < cir.size(); i++) {
sum[i] = sum[i - 1] + cir[i - 1].l;
}
init(0, cir.size() - 1, 1);
long long res = INF;
for (int i = 0; i < c_size; i++) {
Node e = query(1, 0, cir.size() - 1, i, i + c_size - 1);
res = min(res, e.res);
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int u, v, l;
cin >> u >> v >> l;
E e = E(u, v, i, l);
edge.push_back(e);
G[u].push_back(e);
swap(e.from, e.to);
G[v].push_back(e);
}
dfs1(1, -1);
reverse(cir.begin(), cir.end());
memset(vis, false, sizeof(vis));
for (int i = 0; i < cir.size(); i++) vis[cir[i].from] = true;
for (int i = 0; i < cir.size(); i++) {
vis[cir[i].from] = false;
pair<long long, long long> tmp = dfs1(cir[i].from);
dep[i] = tmp.first;
ans = max(ans, tmp.second);
}
ans = max(ans, solve());
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
pair<int, int> arr[n];
for (int i = 0; i < n; i++) {
scanf("%d %d", &arr[i].first, &arr[i].second);
}
sort(arr, arr + n, [](pair<int, int> a, pair<int, int> b) {
if (a.second == 100 && b.second != 100) return true;
if (a.second != 100 && b.second == 100) return false;
double x = a.first * (a.second / 100.0) / (1 - a.second / 100.0);
double y = b.first * (b.second / 100.0) / (1 - b.second / 100.0);
return x > y;
});
double answer = 0;
double liked_exp = 0;
for (auto p : arr) {
answer += p.first;
answer += liked_exp * ((100 - p.second) / 100.0);
liked_exp += p.first * (p.second / 100.0);
}
printf("%0.12f\n", answer);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int result[50000];
int MIN(int i, int j) {
int ans = 1e9;
for (int a = i; a <= j; a++) {
ans = min(ans, vec[a]);
}
return ans;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < (n); i++) vec.push_back(i + 1);
int limit = 1;
for (int i = 0; i < (n); i++) limit *= (i + 1);
int sum, mx = 0, realsum = 0;
for (int z = 0; z < (limit); z++) {
for (int i = 0; i < (n); i++) {
sum = 0;
for (int j = i; j < n; j++) sum += MIN(i, j);
;
realsum += sum;
}
if (realsum > mx) mx = realsum;
result[z] = realsum;
realsum = 0;
next_permutation(vec.begin(), vec.end());
}
vector<int> sol;
for (int i = 0; i < (n); i++) sol.push_back(i + 1);
int cnt = 0;
for (int z = 0; z < (limit); z++) {
if (result[z] == mx) {
cnt++;
if (cnt == m) {
printf("%d", sol[0]);
for (int i = 1; i < n; i++) printf(" %d", sol[i]);
printf("\n");
break;
}
}
next_permutation(sol.begin(), sol.end());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e+6 + 100;
int main() {
int n, q, ans = 0;
cin >> n;
vector<int> mass(maxN);
for (int i = 0; i < n; i++) {
scanf("%d", &q);
mass[q]++;
}
for (int i = 0; i < maxN - 1; i++) {
mass[i + 1] += mass[i] / 2;
if (mass[i] % 2 != 0) {
ans++;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, r, m, i;
cin >> n >> a >> r >> m;
long long ar[n + 1];
long long pref[n + 2];
memset(pref, 0, sizeof(pref));
for (i = 1; i <= n; i++) {
cin >> ar[i];
}
long long z = min(m, a + r);
sort(ar + 1, ar + n + 1);
for (i = 1; i <= n; i++) {
pref[i] = pref[i - 1] + ar[i];
}
long long min1 = 1e18;
for (i = 1; i <= n; i++) {
long long p = i * ar[i] - pref[i];
long long q = pref[n] - pref[i] - (n - i) * ar[i];
if (p >= q)
min1 = min(min1, z * q + a * (p - q));
else
min1 = min(min1, z * p + r * (q - p));
}
long long h1 = (pref[n] * 1.0) / n;
long long z1 = upper_bound(ar + 1, ar + n + 1, h1) - ar;
z1--;
long long p = z1 * h1 - pref[z1];
long long q = pref[n] - pref[z1] - (n - z1) * h1;
if (p >= q)
min1 = min(min1, z * q + a * (p - q));
else
min1 = min(min1, z * p + r * (q - p));
long long h2 = ceil((pref[n] * 1.0) / n);
z1 = upper_bound(ar + 1, ar + n + 1, h2) - ar;
z1--;
p = z1 * h2 - pref[z1];
q = pref[n] - pref[z1] - (n - z1) * h2;
if (p >= q)
min1 = min(min1, z * q + a * (p - q));
else
min1 = min(min1, z * p + r * (q - p));
cout << min1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
long long power(long long n, long long p) {
if (p == 0) return 1;
if (p == 1) return n;
if (p % 2)
return power(n, p - 1) * n;
else {
long long x = power(n, p / 2);
return x * x;
}
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res *= a;
a *= a;
b >>= 1;
}
return res;
}
long long fact(long long num) {
long long fac = 1;
while (num != 1) {
fac = fac * num;
num--;
}
return fac;
}
string to_binary(int x) {
string s;
while (x > 0) {
s += (x % 2 ? '1' : '0');
x /= 2;
}
reverse(s.begin(), s.end());
return s;
}
long long nsum(long long num) { return (num * (num + 1)) / 2; }
const int N = 2e5 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test = 1;
cin >> test;
while (test--) {
long long n, i;
string s;
cin >> s;
long long len = s.length();
long long cur = 0, ans = 0;
for (i = 0; i < len; i++) {
if (s[i] == '+') {
if (cur < 0)
cur = 1;
else
cur++;
} else
cur--;
if (cur < 0) ans += i + 1;
}
cout << ans + len << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
int n;
int a[maxn];
int bit[maxn];
vector<int> v[maxn];
long long sum(int i) {
long long res = 0;
while (i) {
res += bit[i];
i -= i & -i;
}
return res;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] = min(a[i], n);
v[min(i - 1, a[i])].push_back(i);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
add(a[i], 1);
for (vector<int>::iterator it = v[i].begin(); it != v[i].end(); it++) {
ans += sum(n) - sum(*it - 1);
}
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int MM = 1e9 + 7;
long long gcd(long long p, long long q) { return q ? gcd(q, p % q) : p; }
long long pw(long long p, long long q) {
long long ret = 1;
for (; q; q >>= 1) {
if (q & 1) ret = ret * p % MM;
p = p * p % MM;
}
return ret;
}
long long getInv(long long p) { return pw(p, MM - 2); }
int main() {
double px, py, vx, vy, a, b, c, d;
cin >> px >> py >> vx >> vy >> a >> b >> c >> d;
double l = sqrt(vx * vx + vy * vy);
a /= 2.0;
c /= 2.0;
printf("%.20lf %.20lf\n", px + vx / l * b, py + vy / l * b);
printf("%.20lf %.20lf\n", px - vy / l * a, py + vx / l * a);
printf("%.20lf %.20lf\n", px - vy / l * c, py + vx / l * c);
printf("%.20lf %.20lf\n", px - vy / l * c - vx / l * d,
py + vx / l * c - vy / l * d);
printf("%.20lf %.20lf\n", px + vy / l * c - vx / l * d,
py - vx / l * c - vy / l * d);
printf("%.20lf %.20lf\n", px + vy / l * c, py - vx / l * c);
printf("%.20lf %.20lf\n", px + vy / l * a, py - vx / l * a);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int f[100005];
int b[100005];
vector<int> ant[100005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) ant[f[i]].push_back(i);
int flag = 0;
for (int i = 0; i < m; i++) {
if (ant[b[i]].size() == 0) return puts("Impossible");
if (ant[b[i]].size() > 1) flag = 1;
}
if (flag == 1)
printf("Ambiguity\n");
else {
printf("Possible\n");
for (int i = 0; i < m; i++) printf("%d ", ant[b[i]][0] + 1);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
long long int n, m, a[505], x, y, w;
long double ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
while (m--) {
cin >> x >> y >> w;
ans = max(ans, (long double)(a[x] + a[y]) / w);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
long long SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
long long SIZE(const T &t) {
return t.size();
}
string to_string(const string s, long long x1 = 0, long long x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, long long x1 = 0, long long x2 = 1e9) {
string t = "";
for (long long __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), long long x1 = 0, long long x2 = 1e9,
C... coords);
long long l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), long long x1, long long x2, C... coords) {
long long rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
void IO() {}
int32_t main() {
IO();
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long k;
cin >> k;
vector<long long> fact;
string ans = "codeforces";
vector<long long> m(10, 1);
long long N = 10;
bool ok = false;
while (true) {
if (ok) {
break;
}
for (long long i = 0; i < N; i++) {
long long t = 1;
for (long long j = 0; j < N; j++) {
t *= m[j];
}
if (t >= k) {
ok = true;
break;
}
m[i]++;
}
}
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < m[i]; j++) {
cout << ans[i];
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, D, Ans, cnt, X, h[3005], g[3005], ans[3005];
int f[3005][3005], F[3005][3005], fac[3005], inv[3005];
struct node {
int to, next;
} e[3005];
void Addedge(int x, int y) { e[++cnt] = (node){y, h[x]}, h[x] = cnt; }
int Ksm(int a, int n) {
int ans = 1;
while (n) {
if (n & 1) ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod, n >>= 1;
}
return ans;
}
void Dfs(int x) {
for (int i = 1; i <= n; ++i) f[x][i] = 1, F[x][i] = i;
for (int i = h[x], y; i; i = e[i].next) {
Dfs(y = e[i].to);
for (int j = 1; j <= n; ++j) f[x][j] = 1ll * f[x][j] * F[y][j] % mod;
}
for (int j = 1; j <= n; ++j) F[x][j] = (F[x][j - 1] + f[x][j]) % mod;
}
int C(int n, int m) { return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod; }
int main() {
cin >> n >> D, fac[0] = X = 1;
for (int i = 2, x; i <= n; ++i) cin >> x, Addedge(x, i);
for (long long i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
inv[n] = Ksm(fac[n], mod - 2);
for (long long i = n - 1; ~i; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
Dfs(1);
for (int i = 1, X = 1; i <= n; ++i) {
ans[i] = f[1][i], X = 1ll * X * (D - i + 1) % mod * Ksm(i, mod - 2) % mod;
for (int j = 1; j <= i - 1; ++j)
ans[i] = (ans[i] - 1ll * C(i - 1, j - 1) * ans[j] % mod + mod) % mod;
Ans = (Ans + 1ll * X * ans[i]) % mod;
}
cout << Ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &is, vector<T> &arr);
template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr);
int INF = 1e9 + 5;
void nope() {
cout << -1 << endl;
exit(0);
}
int main() {
int sum, limit;
cin >> sum >> limit;
vector<vector<int>> bitMap(32, vector<int>());
for (int i = 1; i <= limit; i++) {
int j = 0;
while (j < 31 && ((i & (1 << j)) == 0)) j++;
bitMap[j].push_back(i);
}
int iter = 30;
vector<int> ans;
while (sum > 0 && iter >= 0) {
if (sum < (1 << iter))
iter--;
else {
if (bitMap[iter].size() == 0)
iter--;
else {
int tf = bitMap[iter][bitMap[iter].size() - 1];
ans.push_back(tf);
bitMap[iter].pop_back();
sum -= (1 << iter);
}
}
}
if (sum != 0)
cout << -1 << endl;
else {
cout << (int)ans.size() << endl;
for (int i : ans) cout << i << ' ';
cout << endl;
}
}
template <typename T>
istream &operator>>(istream &is, vector<T> &arr) {
typename vector<T>::iterator a;
for (a = arr.begin(); a != arr.end(); a++) {
is >> *a;
}
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &arr) {
typename vector<T>::iterator a;
for (a = arr.begin(); a != arr.end(); a++) {
os << *a << " ";
}
os << endl;
return os;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
if (k >= m)
printf("1\n");
else if (n + k < m)
printf("0\n");
else {
double ans = 1;
for (int i = 1; i <= k + 1; i++) ans = ans * (m - i + 1) / (n + i);
ans = 1.0 - ans;
printf("%.6f\n", ans);
}
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
long long n;
scanf("%I64d", &n);
long long a[n];
long long i, j;
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
long long count = 0;
long long less = 0;
long long more = 0;
for (i = 1; i < n; i++) {
for (j = 0; j < i; j++) {
if (a[j] < a[i]) {
count++;
}
}
if (count == j) {
more++;
}
count = 0;
}
count = 0;
for (i = 1; i < n; i++) {
for (j = 0; j < i; j++) {
if (a[i] < a[j]) {
count++;
}
}
if (count == j) {
less++;
}
count = 0;
}
printf("%I64d", (more + less));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, x;
long long num[21], f[1 << 20], g[21][21];
int main() {
cin >> n;
for (; n--;) {
cin >> x;
++num[--x];
for (int i = 0; i < 20; ++i) g[x][i] += num[i];
}
memset(f, 1, sizeof(f));
f[0] = 0;
for (int i = 0; i < 1 << 20; ++i)
for (int j = 0; j < 20; ++j)
if (!(i >> j & 1)) {
long long tmp = f[i];
for (int k = 0; k < 20; ++k)
if (i >> k & 1) tmp += g[j][k];
f[i | (1 << j)] = min(f[i | (1 << j)], tmp);
}
cout << f[(1 << 20) - 1];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10;
const int LIM = 80;
char pass[LIM + 1];
char nums[N][N + 1];
int main() {
cin >> pass;
for (int i = 0; i < N; i++) cin >> nums[i];
for (int i = 0; i < LIM; i += N)
for (int j = 0; j < N; j++)
if (!strncmp(pass + i, nums[j], N)) cout << j;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, q, m, tot = 0;
int ch[200005][2], fa[200005], siz[200005], rev[200005], col[200005],
cc[400005], v[400005], nxt[400005], h[200005], maxd[200005];
int lowbit(int x) { return x & (-x); }
void add(int x, int g) {
for (; x <= n + q; x += lowbit(x)) cc[x] += g;
}
int ask(int x) {
int ret = 0;
for (; x; x -= lowbit(x)) ret += cc[x];
return ret;
}
bool nroot(int x) { return ch[fa[x]][0] == x || ch[fa[x]][1] == x; }
bool son(int x) { return ch[fa[x]][1] == x; }
void reverse(int x) { rev[x] ^= 1, swap(ch[x][0], ch[x][1]); }
void pushdown(int x) {
if (rev[x]) reverse(ch[x][0]), reverse(ch[x][1]), rev[x] = 0;
}
void update(int x) { siz[x] = 1 + siz[ch[x][0]] + siz[ch[x][1]]; }
void rotate(int x) {
int y = fa[x], z = fa[y], k = son(x), w = ch[x][!k];
if (nroot(y)) ch[z][son(y)] = x;
ch[x][!k] = y, ch[y][k] = w;
if (w) fa[w] = y;
fa[y] = x, fa[x] = z;
update(y), update(x);
}
void pushall(int x) {
if (nroot(x)) pushall(fa[x]);
pushdown(x);
}
void splay(int x) {
pushall(x);
while (nroot(x)) {
int y = fa[x];
if (nroot(y)) rotate(son(x) == son(y) ? y : x);
rotate(x);
}
}
int find(int x) {
if (ch[x][0] || ch[x][1]) pushdown(x);
return ch[x][1] ? find(ch[x][1]) : x;
}
void access(int x) {
int tmp, z = x;
m++;
for (int y = 0; x; x = fa[y = x]) {
splay(x);
tmp = col[find(x)];
if (tmp) add(tmp, -siz[ch[x][0]] - 1), add(m - 1, siz[ch[x][0]] + 1);
ch[x][1] = y, update(x);
}
col[z] = m;
}
void getf(int x) {
for (int y = 0; x; x = fa[y = x]) splay(x), ch[x][1] = y, update(x);
}
void makeroot(int x) {
access(x);
splay(x);
reverse(x);
col[find(x)] = m - 1, ch[x][1] = 0;
update(x);
add(m - 1, -1), add(m, 1);
}
void addedge(int x, int y) {
v[++tot] = y;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
nxt[tot] = h[y];
h[y] = tot;
}
void dfs(int u, int ff) {
maxd[u] = u;
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == ff) continue;
fa[v[p]] = u;
dfs(v[p], u);
maxd[u] = max(maxd[u], maxd[v[p]]);
}
add(maxd[u], 1);
if (maxd[u] == u) col[u] = u;
}
int when(int x) {
splay(x);
return ask(col[find(x)] - 1) + siz[ch[x][1]] + 1;
}
int main() {
n = readint();
q = readint();
for (int i = 1; i <= n - 1; i++) addedge(readint(), readint());
m = n;
dfs(n, -1);
for (int i = 1; i <= n; i++) siz[i] = 1;
for (int i = 1; i <= n; i++) getf(i);
char opt[10];
int x, y;
for (int ts = 1; ts <= q; ts++) {
scanf("%s", opt);
x = readint();
if (opt[0] == 'u') {
if (!fa[x]) continue;
makeroot(x);
} else if (opt[0] == 'w')
printf("%d\n", when(x));
else {
y = readint();
printf("%d\n", when(x) > when(y) ? y : x);
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int a, b, c, d;
cin >> a >> b >> c >> d;
for (long long int i = 0; i < 100; i++) {
for (long long int j = 0; j < 100; j++) {
if (b + (i * a) == d + (j * c)) {
cout << b + (i * a);
return 0;
}
}
}
cout << "-1";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string FILENAME = "filename";
unordered_map<int, unordered_set<int>> G;
unordered_map<int, int> mapper;
unordered_map<int, int> id;
int dpth[100001];
void preorder(unordered_map<int, unordered_set<int>> G) {
deque<pair<int, int>> S;
unordered_set<int> VST;
S.push_back(make_pair(1, 0));
while (!S.empty()) {
pair<int, int> V = S.front();
S.pop_front();
VST.insert(V.first);
dpth[V.first] = V.second;
for (int NB : G[V.first]) {
if (VST.count(NB)) continue;
S.push_back(make_pair(NB, V.second + 1));
}
}
}
vector<int> treetrav(unordered_map<int, unordered_set<int>> G) {
vector<int> R(2 * G.size() - 1);
unordered_map<int, int> VST;
stack<int> S;
S.push(1);
int I = 0;
while (!S.empty()) {
int V = S.top();
S.pop();
if (VST.count(V)) {
R[I++] = VST[V];
continue;
}
VST[V] = I;
R[I++] = VST[V];
for (int NB : G[V]) {
if (VST.count(NB)) continue;
S.push(V);
S.push(NB);
}
}
mapper = VST;
return R;
}
struct SegTree {
vector<int> T, REF;
int SZ;
SegTree(vector<int> A) {
SZ = A.size();
T.resize(SZ * 4);
REF = A;
build(0, 0, SZ - 1);
}
int build(int V, int L, int R) {
if (L == R) return T[V] = REF[L];
return T[V] = min(build(V * 2 + 1, L, (L + R) / 2),
build(V * 2 + 2, (L + R) / 2 + 1, R));
}
int value(int L, int R) { return value(0, 0, SZ - 1, L, R); }
int value(int ND, int SL, int SR, int L, int R) {
if (SR < L || SL > R)
return INT_MAX;
else if (L <= SL && R >= SR)
return T[ND];
return min(value(ND * 2 + 1, SL, (SL + SR) / 2, L, R),
value(ND * 2 + 2, (SL + SR) / 2 + 1, SR, L, R));
}
void update(int I, int V) { update(0, 0, SZ - 1, I, V); }
int update(int ND, int SL, int SR, int I, int V) {
if (I < SL || I > SR) return T[ND];
if (SL == SR) return T[ND] = V;
return T[ND] = min(update(ND * 2 + 1, SL, (SL + SR) / 2, I, V),
update(ND * 2 + 2, (SL + SR) / 2 + 1, SR, I, V));
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
G[a].insert(b);
G[b].insert(a);
}
preorder(G);
vector<int> thingy = treetrav(G);
for (auto it : mapper) id[it.second] = it.first;
SegTree LK(thingy);
int q;
cin >> q;
for (int _ = 0; _ < q; _++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int LCA =
id[LK.value(min(mapper[a], mapper[b]), max(mapper[a], mapper[b]))];
int pathl = -2 * dpth[LCA] + dpth[a] + dpth[b];
if (pathl <= k and k % 2 == pathl % 2) {
cout << "YES" << endl;
continue;
}
int LCA2 =
id[LK.value(min(mapper[a], mapper[x]), max(mapper[a], mapper[x]))];
int LCA3 =
id[LK.value(min(mapper[y], mapper[b]), max(mapper[y], mapper[b]))];
int pathl2 = -2 * dpth[LCA2] + dpth[a] + dpth[x];
int pathl3 = -2 * dpth[LCA3] + dpth[y] + dpth[b];
if (pathl2 + pathl3 + 1 <= k and (pathl2 + pathl3 + 1) % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
LCA2 = id[LK.value(min(mapper[b], mapper[x]), max(mapper[b], mapper[x]))];
LCA3 = id[LK.value(min(mapper[y], mapper[a]), max(mapper[y], mapper[a]))];
pathl2 = -2 * dpth[LCA2] + dpth[b] + dpth[x];
pathl3 = -2 * dpth[LCA3] + dpth[y] + dpth[a];
if (pathl2 + pathl3 + 1 <= k and (pathl2 + pathl3 + 1) % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
cout << "NO" << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b;
int k1 = (a + b) / (2 * b), k2 = (a - b) / (2 * b);
long double x1 = -1, x2 = -1;
if (k1 > 0) {
x1 = (a + b) / (long double)(k1 * 2);
}
if (k2 > 0) {
x2 = (a - b) / (long double)(k2 * 2);
}
cout.precision(16);
if (x1 <= 0 and x2 <= 0)
cout << -1 << "\n";
else if (x1 <= 0) {
cout << fixed << x2 << "\n";
} else if (x2 <= 0) {
cout << fixed << x1 << "\n";
} else {
cout << fixed << min(x1, x2) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
char ch[MAXN], tmp[MAXN];
int a[MAXN];
int main() {
while (scanf("%s", tmp) != EOF) {
int n = strlen(tmp);
for (int i = 0, j = n - 1; j >= 0; --j, ++i) ch[i] = tmp[j];
ch[n] = 0;
memset(a, 0, sizeof(a));
int pres(-1000), pret(-1000);
for (int i = 0; i < n; ++i) {
while (ch[i] == '0' && i < n) ++i;
if (i >= n) break;
if (pret - pres >= 1 && pret + 2 >= i) {
if (pret + 2 == i) {
a[pret + 1] = -1;
while (ch[i] == '1' && i < n) ++i;
pret = i - 1;
a[pret + 1] = 1;
}
} else {
pres = i;
a[pres] = -1;
while (ch[i] == '1' && i < n) ++i;
pret = i - 1;
if (pret - pres >= 1)
a[pret + 1] = 1;
else
a[pres] = 1;
}
}
int m(0);
for (int i = 0; i <= n; ++i)
if (a[i] != 0) ++m;
printf("%d\n", m);
for (int i = 0; i <= n; ++i) {
if (a[i] == 1) printf("+2^%d\n", i);
if (a[i] == -1) printf("-2^%d\n", i);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<long long int> > M(n, vector<long long int>(m));
vector<vector<long long int> > N(n, vector<long long int>(m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cin >> M[i][j];
}
vector<long long int> R(n), C(m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
R[i] = max(R[i], M[i][j]);
C[j] = max(C[j], M[i][j]);
}
}
sort(R.rbegin(), R.rend());
sort(C.rbegin(), C.rend());
R.push_back(-1);
C.push_back(-1);
N[0][0] = R[0];
int r = 0, c = 0;
while (r < n - 1 or c < m - 1) {
if (R[r + 1] == C[c + 1]) {
++r;
++c;
N[r][c] = R[r];
} else if (R[r + 1] > C[c + 1]) {
++r;
N[r][c] = R[r];
} else {
++c;
N[r][c] = C[c];
}
}
vector<long long int> used(n * m + 1, 0);
for (int i = 0; i < n; ++i) ++used[R[i]];
for (int i = 0; i < m; ++i) ++used[C[i]];
int pos = 1;
for (int i = 0; i < max(n, c); ++i) {
int x = n - i - 1, y = m - i - 1;
for (int i = 0; x >= 0 and not N[x][i]; ++i) {
while (used[pos]) ++pos;
N[x][i] = pos++;
}
for (int i = 0; y >= 0 and not N[i][y]; ++i) {
while (used[pos]) ++pos;
N[i][y] = pos++;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << N[i][j] << ' ';
cout << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100011, inf = 1000111222;
int n, leaf[max_n];
vector<int> g[max_n], val[max_n], num[max_n], ans_u, ans_v, ans_x;
void dfs1(int v, int p = -1) {
leaf[v] = v;
for (int to : g[v]) {
if (to == p) {
continue;
}
dfs1(to, v);
leaf[v] = leaf[to];
}
}
bool add(int v, int v2, int x, int p = -1) {
if (v == v2) {
return true;
}
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i] == p) {
continue;
}
if (add(g[v][i], v2, x, v)) {
val[v][i] -= x;
val[g[v][i]][num[v][i]] -= x;
return true;
}
}
return false;
}
void add_edge(int v, int v2, int x) {
ans_u.push_back(v);
ans_v.push_back(v2);
ans_x.push_back(x);
add(v, v2, x);
}
void dfs(int v, int p = -1) {
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i] == p) {
continue;
}
if (val[v][i]) {
int v1 = g[v][0];
int v2 = g[v][1];
if (v1 == g[v][i]) {
v1 = g[v][2];
} else if (v2 == g[v][i]) {
v2 = g[v][2];
}
if (v1 == p) {
if (g[v1][0] != v) {
v1 = g[v1][0];
} else {
v1 = g[v1][1];
}
v1 = leaf[v1];
}
if (v2 == p) {
if (g[v2][0] != v) {
v2 = g[v2][0];
} else {
v2 = g[v2][1];
}
v2 = leaf[v2];
}
v1 = leaf[v1];
v2 = leaf[v2];
int x = val[v][i];
add_edge(leaf[g[v][i]], v1, x / 2);
add_edge(leaf[g[v][i]], v2, x / 2);
add_edge(v1, v2, -x / 2);
}
}
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i] == p) {
continue;
}
dfs(g[v][i], v);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, x;
scanf("%d%d%d", &u, &v, &x);
num[u].push_back(g[v].size());
num[v].push_back(g[u].size());
g[u].push_back(v);
g[v].push_back(u);
val[u].push_back(x);
val[v].push_back(x);
}
for (int i = 1; i <= n; ++i) {
if (g[i].size() == 2) {
puts("NO");
return 0;
}
}
puts("YES");
if (n == 2) {
puts("1");
printf("1 2 %d\n", val[1][0]);
return 0;
}
int root;
for (int i = 1; i <= n; ++i) {
if (g[i].size() != 1) {
root = i;
break;
}
}
dfs1(root);
dfs(root);
printf("%d\n", ans_u.size());
for (int i = 0; i < ans_u.size(); ++i) {
printf("%d %d %d\n", ans_u[i], ans_v[i], ans_x[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1002, inf = 2000;
int n, m, u, v, c, sum, ans[N], dist[N], mark[N];
vector<int> g[N];
int solve(int x) {
fill(dist, dist + N, inf);
queue<int> q;
q.push(x);
dist[x] = 0;
int res = 0;
while (q.size()) {
int u = q.front();
q.pop();
res = max(res, dist[u]);
;
for (int i = 0; i < g[u].size(); i++) {
if (dist[g[u][i]] == dist[u]) return -1;
if (dist[u] + 1 < dist[g[u][i]])
dist[g[u][i]] = dist[u] + 1, q.push(g[u][i]);
}
}
return res;
}
void dfs(int x, int col) {
mark[x] = col;
for (int i = 0; i < g[x].size(); i++)
if (!mark[g[x][i]]) dfs(g[x][i], col);
}
int main() {
fill(ans, ans + N, -1);
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i < n + 1; i++)
if (!mark[i]) dfs(i, ++c);
for (int i = 1; i < n + 1; i++) ans[mark[i]] = max(ans[mark[i]], solve(i));
;
for (int i = 1; i < c + 1; i++) {
if (ans[i] == -1) return cout << -1, 0;
sum += ans[i];
}
cout << sum;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int k, d, t;
};
int main() {
int n, q;
cin >> n >> q;
struct node a[q];
for (int i = 0; i < q; i++) {
cin >> a[i].t >> a[i].k >> a[i].d;
}
int s[n + 1], ss[n + 1], res[q], sum = 0, k = 0;
for (int i = 0; i <= n; i++) ss[i] = s[i] = 0;
for (int i = 0; i < q; i++) {
sum = 0;
k = 0;
for (int m = 0; m <= n; m++) ss[m] = s[m];
for (int j = 1; j <= n; j++) {
if (k == a[i].k) break;
if (ss[j] <= a[i].t) {
sum += j;
k++;
ss[j] = a[i].t + a[i].d;
}
}
if (k == a[i].k) {
for (int m = 1; m <= n; m++) s[m] = ss[m];
res[i] = sum;
} else
res[i] = -1;
}
for (int i = 0; i < q; i++) cout << res[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], y[n];
map<int, int> M;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) {
M[x[i]]++;
}
for (int i = 0; i < n; i++) {
int h = n - 1 + M[y[i]];
int a = n - 1 - M[y[i]];
cout << h << " " << a << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> acc(1e6 + 1);
{
vector<int> cnt(1e6 + 1);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
cnt[a]++;
}
for (int i = 1; i < 1e6 + 1; i++) {
acc[i] = acc[i - 1] + cnt[i];
}
}
int ans = 1;
for (int gcd = 2; gcd < 1e6 + 1; gcd++) {
if (acc[gcd - 1] > 0) {
break;
}
int lb = gcd + k + 1;
int ub = min((int)1e6 + 1, 2 * gcd);
if (lb < ub) {
bool ok = true;
while (lb <= 1e6) {
if (acc[ub - 1] - acc[lb - 1] > 0) {
ok = false;
break;
}
lb += gcd;
ub = min((int)1e6 + 1, ub + gcd);
}
if (ok) {
ans = gcd;
}
} else {
ans = gcd;
}
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long sum = 0;
long long mid = 0;
string s;
cin >> s;
for (long i = 0; i < s.length(); i++)
if (s[i] == '^') {
mid = i;
break;
}
for (long i = 0; i < s.length(); i++)
if (s[i] >= '1' && s[i] <= '9') sum += (((s[i] - '0')) * (i - mid));
if (sum == 0)
cout << "balance\n";
else if (sum < 0)
cout << "left\n";
else
cout << "right\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, p, q, c;
cin >> t;
while (t--) {
cin >> n;
c = (long long int)sqrt(n) + (long long int)cbrt(n) -
(long long int)(sqrt(cbrt(n)));
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d %d", &a, &b);
if (a > b) {
printf("%d ", b);
a = a - b;
printf("%d", a / 2);
} else {
printf("%d ", a);
b = b - a;
printf("%d", b / 2);
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.