solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const int inf = 0x7f7f7f7f;
int n, m;
int u[maxn], v[maxn];
int cnt[maxn];
bool adj[maxn][maxn];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u[i] >> v[i];
cnt[u[i]]++;
cnt[v[i]]++;
adj[u[i]][v[i]] = 1;
adj[v[i]][u[i]] = 1;
}
int rlt = inf;
for (int i = 0; i < m; i++)
for (int j = 1; j <= n; j++) {
int tu = u[i], tv = v[i];
if (adj[tu][j] && adj[j][tv]) {
rlt = min(rlt, cnt[tu] + cnt[tv] + cnt[j] - 6);
}
}
if (rlt == inf)
cout << -1 << endl;
else
cout << rlt << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-9;
int cases = 1;
double getdist(pair<int, int> a, pair<int, int> b) {
return sqrt(pow((double)a.first - b.first, 2) +
pow((double)a.second - b.second, 2));
}
int n, m, k, Q;
int arr[505][505], save[505];
void Read(void) {
scanf("%d %d %d", &n, &m, &Q);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) scanf("%d", &arr[i][j]);
int maxi = 0;
for (int j = 1; j <= m;) {
if (arr[i][j] == 0) {
j++;
continue;
}
int p = 0;
while (j <= m and arr[i][j] == 1) j++, p++;
maxi = max(maxi, p);
}
save[i] = maxi;
}
return;
}
int main() {
int test, u, v;
Read();
while (Q--) {
scanf("%d %d", &u, &v);
arr[u][v] = 1 - arr[u][v];
int nmaxi = 0;
for (int j = 1; j <= m;) {
if (arr[u][j] == 0) {
j++;
continue;
}
int p = 0;
while (j <= m and arr[u][j] == 1) j++, p++;
nmaxi = max(nmaxi, p);
}
save[u] = nmaxi;
nmaxi = 0;
for (int i = 1; i <= n; i++) {
nmaxi = max(nmaxi, save[i]);
}
printf("%d\n", nmaxi);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 3;
int n, sqrtn, D, a[maxn], ma[maxn], r[maxn], b[maxn], sb[maxn], qb[maxn], qbl;
long long X;
long long getNextX() {
X = (X * 37ll + 10007ll) % 1000000007ll;
return X;
}
void initAB() {
for (int i = 0; i < n; ++i) a[i] = i + 1;
for (int i = 0; i < n; ++i) std::swap(a[i], a[getNextX() % (i + 1)]);
for (int i = 0; i < n; ++i) r[a[i]] = i;
ma[0] = a[0];
for (int i = 1; i < n; ++i) ma[i] = std::max(ma[i - 1], a[i]);
for (int i = 0; i < D; ++i) b[i] = 1;
for (int i = 0; i < n; ++i) std::swap(b[i], b[getNextX() % (i + 1)]);
for (int i = 0; i < n; ++i)
if (b[i]) qb[qbl++] = i;
sb[0] = b[0];
for (int i = 1; i < n; ++i) sb[i] = sb[i - 1] + b[i];
}
int brute(int i) {
int c = 0;
for (int j = 0; j < qbl && qb[j] <= i; ++j) c = std::max(c, a[i - qb[j]]);
return c;
}
int guess(int i, int s) {
if (!sb[i]) return 0;
if (sb[i] == i + 1) return ma[i];
for (int v = n; v >= n - s && v > 0; --v)
if (i - r[v] >= 0 && b[i - r[v]]) return v;
return -1;
}
int main() {
scanf("%d%d%lld", &n, &D, &X);
sqrtn = sqrt(n);
initAB();
for (int i = 0, k; i < n; ++i) {
k = guess(i, 20);
if (k < 0) k = brute(i);
printf("%d\n", k);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
long long int binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
bool check(int x, vector<int>& a, int m) {
int n = a.size();
long long int tot = 0;
vector<long long int> dist(x);
int pos = 0;
int count = 0;
for (int i = 0; i < n; i++) {
if (pos != x - 1) {
dist[pos] += max(a[i] - count, 0);
pos = pos + 1;
} else {
dist[pos] += max(a[i] - count, 0);
count++;
pos = 0;
}
}
for (int i = 0; i < x; i++) {
tot += dist[i];
}
if (tot >= m) {
return true;
}
return false;
}
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n);
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < m) {
cout << -1;
return;
}
sort(a.rbegin(), a.rend());
int x = 0;
for (int b = n; b >= 1; b /= 2) {
while (!check(x + b, a, m)) x += b;
}
cout << x + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 1000100;
template <class _, class __>
inline void up(_& a, const __& b) {
if (a < b) a = b;
}
template <class _, class __>
inline void down(_& a, const __& b) {
if (a > b) a = b;
}
template <class _, class __>
inline void dec(_& a, const __& b) {
(a -= b - mod) %= mod;
}
template <class _, class __>
inline void add(_& a, const __& b) {
(a += b) %= mod;
}
struct T {
long long to, nxt;
} way[maxn << 1];
long long h[maxn], num;
long long vis[maxn], cl[maxn], Q[maxn];
long long p[maxn];
inline void adde(long long x, long long y) {
way[++num] = {y, h[x]}, h[x] = num;
way[++num] = {x, h[y]}, h[y] = num;
}
long long sec, ans;
inline void dfs(long long x) {
if (sec) return;
if (cl[x]) {
ans = x;
cout << "A " << x << '\n';
sec = 1;
return;
}
vis[x] = 1;
for (long long i = h[x]; i; i = way[i].nxt)
if (!vis[way[i].to]) {
dfs(way[i].to);
}
vis[x] = 0;
}
signed main() {
long long t;
cin >> t;
while (t--) {
sec = 0;
num = 0;
long long n;
cin >> n;
for (long long i = 1; i <= n; ++i) Q[i] = h[i] = cl[i] = vis[i] = 0;
for (long long i = 1, x, y; i < n; ++i) cin >> x >> y, adde(x, y);
long long k1, k2;
cin >> k1;
for (long long i = 1, x; i <= k1; ++i) cin >> x, cl[x] = 1;
cin >> k2;
long long x;
for (long long i = 1; i <= k2; ++i) cin >> x, Q[x] = 1;
cout << "B " << x << '\n';
cout.flush();
cin >> x;
dfs(x);
cout.flush();
long long y;
cin >> y;
if (Q[y])
cout << "C " << ans << '\n';
else
cout << "C -1\n";
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
int a[1005], tj[1005];
for (int i = 0; i < 2e9; i++) {
n++;
}
for (int i = 0; i < 105; i++) tj[i] = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
tj[a[i]]++;
}
int flag = 0;
for (int i = 0; i < 105; i++) {
if (tj[i] != 0) {
for (int j = 0; j < tj[i]; j++) {
if (!flag) {
flag = 1;
printf("%d", i);
} else
printf(" %d", i);
}
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void print() {
if constexpr (0) cout << '\n';
}
template <typename T, typename... Ts>
void print(const T &value, const Ts &...values) {
if constexpr (0) cout << value << ' ', print(values...);
}
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
struct custom_hash {
static unsigned long long splitmix64(unsigned long long x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(pair<int, int> x) const {
static const unsigned long long FIXED_RANDOM1 =
chrono::steady_clock::now().time_since_epoch().count();
static const unsigned long long FIXED_RANDOM2 =
chrono::steady_clock::now().time_since_epoch().count();
return hash<unsigned long long>()(splitmix64(x.first + FIXED_RANDOM1) ^
splitmix64(x.second + FIXED_RANDOM2));
}
};
using hashmap = unordered_map<pair<int, int>, bool, custom_hash>;
hashmap mark;
int n, m;
set<pair<int, int> > st;
bool check(vector<int> &a) {
st.clear();
for (int i = (int)0; i <= (int)a.size() - 1; i++) {
if (a[i] != i && mark.find(minmax(a[i], i)) == mark.end()) {
st.insert(minmax(a[i], i));
if (st.size() >= m) return true;
}
if (a.size() - (i + 1) + st.size() < m) return false;
}
return false;
}
void refine(vector<int> &a) {
for (int i = (int)0; i <= (int)a.size() - 1; i++) {
if (a[i] == i) {
if (i)
swap(a[i], a[i - 1]);
else if (i + 1 < a.size())
swap(a[i], a[i + 1]);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
mark.max_load_factor(0.25);
mark.reserve(m);
for (int i = (int)1; i <= (int)m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
mark[minmax(u, v)] = true;
}
vector<int> a;
for (int i = (int)0; i <= (int)n - 1; i++) a.push_back(i);
while (true) {
shuffle(a.begin(), a.end(), rd);
refine(a);
if (check(a)) {
for (auto it : st) cout << it.first + 1 << ' ' << it.second + 1 << '\n';
return 0;
}
if (1.0 * clock() / CLOCKS_PER_SEC >= 1.4) break;
}
cout << -1 << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long mod = 1e9 + 7;
const long long MAXL = 1e18 + 5;
const long long eps = 1e-8;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string s;
cin >> s;
vector<char> ss;
for (long long i = 0; i < s.size(); i++) {
ss.push_back(s[i]);
if (ss.size() > 1) {
if (ss[ss.size() - 1] == ss[ss.size() - 2]) {
ss.pop_back();
ss.pop_back();
}
}
}
for (long long i = 0; i < ss.size(); ++i) cout << ss[i];
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adjList[2000000];
int main() {
int i, j;
int T, t;
int n, u, v;
char c;
scanf("%d", &T);
for (t = 0; t < T; t++) {
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d %d", &u, &v);
u--, v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
int nn = n;
for (i = 0; i < nn; i++) {
scanf(" %c", &c);
if (c == 'W') {
adjList[i].push_back(n), adjList[n].push_back(i);
adjList[n].push_back(n + 1), adjList[n + 1].push_back(n);
adjList[n].push_back(n + 2), adjList[n + 2].push_back(n);
n += 3;
}
}
int c = 0;
for (i = 0; i < n; i++) {
if (adjList[i].size() >= 4)
break;
else if (adjList[i].size() >= 3) {
c++;
int c2 = 0;
for (j = 0; j < adjList[i].size(); j++) {
v = adjList[i][j];
if (adjList[v].size() >= 2) c2++;
}
if (c2 >= 2) break;
}
}
if ((i < n) || ((c == 2) && (n & 1)))
printf("White\n");
else
printf("Draw\n");
for (i = 0; i < n; i++) adjList[i].clear();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int vis[300005];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int val = 1;
int ch = n;
cout << val << " ";
while (n--) {
int x;
cin >> x;
vis[x] = 1;
if (x == ch) {
ch--;
while (ch > 0 && vis[ch]) {
ch--;
val--;
}
{ cout << val << " "; }
} else {
val++;
cout << val << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s = "";
char c;
cin >> c;
s += c;
if ((cin >> c))
s += c;
else {
cout << s;
return;
}
while (cin >> c) {
if (c == s[s.length() - 1] && c == s[s.length() - 2]) continue;
if (s.length() >= 3 && s[s.length() - 2] == s[s.length() - 3] &&
c == s[s.length() - 1])
continue;
s += c;
}
cout << s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
int n, m;
string hor, ver;
int give_dir(char ch) {
if (ch == '>' || ch == 'v')
return 1;
else
return -1;
}
bool valid(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return false;
return true;
}
void dfs(int x, int y, vector<vector<bool> > &visited) {
visited[x][y] = true;
int nx, ny;
nx = x + give_dir(ver[y]);
ny = y + give_dir(hor[x]);
if (valid(nx, y) && !visited[nx][y]) dfs(nx, y, visited);
if (valid(x, ny) && !visited[x][ny]) dfs(x, ny, visited);
}
int main() {
cin >> n >> m;
cin >> hor >> ver;
for (int k = 0; k < (n); k++) {
for (int l = 0; l < (m); l++) {
vector<vector<bool> > visited(n, vector<bool>(m, false));
dfs(k, l, visited);
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
if (!visited[i][j]) {
cout << "NO" << endl;
return 0;
}
}
}
}
}
cout << "YES" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, i;
string s;
cin >> n >> s;
set<char> ss;
sort(s.begin(), s.end());
for (i = 0; i < n; i++) {
ss.insert(s[i]);
}
if (ss.size() > 7) {
cout << "YES" << '\n';
} else {
if (binary_search(s.begin(), s.end(), '1') &&
binary_search(s.begin(), s.end(), '4') &&
binary_search(s.begin(), s.end(), '7') &&
binary_search(s.begin(), s.end(), '0')) {
cout << "YES" << '\n';
} else if (binary_search(s.begin(), s.end(), '3') &&
binary_search(s.begin(), s.end(), '6') &&
binary_search(s.begin(), s.end(), '9') &&
binary_search(s.begin(), s.end(), '0')) {
cout << "YES" << '\n';
} else if ((binary_search(s.begin(), s.end(), '1') &&
binary_search(s.begin(), s.end(), '4') &&
binary_search(s.begin(), s.end(), '7')) &&
(binary_search(s.begin(), s.end(), '3') ||
binary_search(s.begin(), s.end(), '6') ||
binary_search(s.begin(), s.end(), '9'))) {
cout << "YES" << '\n';
} else if ((binary_search(s.begin(), s.end(), '3') &&
binary_search(s.begin(), s.end(), '6') &&
binary_search(s.begin(), s.end(), '9')) &&
(binary_search(s.begin(), s.end(), '1') ||
binary_search(s.begin(), s.end(), '4') ||
binary_search(s.begin(), s.end(), '7'))) {
cout << "YES" << '\n';
} else if ((binary_search(s.begin(), s.end(), '4') &&
binary_search(s.begin(), s.end(), '5') &&
binary_search(s.begin(), s.end(), '6')) &&
(binary_search(s.begin(), s.end(), '1') ||
binary_search(s.begin(), s.end(), '2') ||
binary_search(s.begin(), s.end(), '3')) &&
(binary_search(s.begin(), s.end(), '7') ||
binary_search(s.begin(), s.end(), '8') ||
binary_search(s.begin(), s.end(), '9'))) {
if (binary_search(s.begin(), s.end(), '7') &&
binary_search(s.begin(), s.end(), '9') &&
binary_search(s.begin(), s.end(), '0')) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
} else if ((binary_search(s.begin(), s.end(), '7') &&
binary_search(s.begin(), s.end(), '8') &&
binary_search(s.begin(), s.end(), '9')) &&
(binary_search(s.begin(), s.end(), '3') ||
binary_search(s.begin(), s.end(), '1') ||
binary_search(s.begin(), s.end(), '2'))) {
cout << "YES" << '\n';
} else {
if ((ss.find('0') != ss.end()) &&
(ss.find('1') != ss.end() || ss.find('2') != ss.end() ||
ss.find('3') != ss.end())) {
cout << "YES" << '\n';
} else if ((ss.find('7') != ss.end() && ss.find('3') != ss.end()) ||
(ss.find('1') != ss.end() && ss.find('9') != ss.end())) {
cout << "YES" << '\n';
} else if (binary_search(s.begin(), s.end(), '2') &&
binary_search(s.begin(), s.end(), '6') &&
binary_search(s.begin(), s.end(), '7')) {
cout << "YES" << '\n';
} else if (binary_search(s.begin(), s.end(), '2') &&
binary_search(s.begin(), s.end(), '4') &&
binary_search(s.begin(), s.end(), '9')) {
cout << "YES" << '\n';
} else if (binary_search(s.begin(), s.end(), '1') &&
binary_search(s.begin(), s.end(), '6') &&
binary_search(s.begin(), s.end(), '7')) {
cout << "YES" << '\n';
} else if (binary_search(s.begin(), s.end(), '3') &&
binary_search(s.begin(), s.end(), '4') &&
binary_search(s.begin(), s.end(), '9')) {
cout << "YES" << '\n';
} else if (binary_search(s.begin(), s.end(), '2') &&
binary_search(s.begin(), s.end(), '7') &&
binary_search(s.begin(), s.end(), '9')) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
int t = 1;
while (t--) solve();
return 0;
}
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int maxn = 1e6 + 6;
const int mod = 998244353;
int binpow(int a, int n) {
int r = 1;
while (n) {
if (n % 2 == 1) r = (1LL * r * a) % mod;
n /= 2;
a = (1LL * a * a) % mod;
}
return r;
}
void solve() {
int n, res = 0, x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
res = (res + ((((1LL * binpow(2, n - i - 1) * (n - i + 1)) % mod) *
binpow(2, mod - 2)) %
mod) *
x) %
mod;
}
printf("%d", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T, class V>
void _print(unordered_map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(unordered_map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(int t) { cout << "Case #" << t << ": "; }
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
void precision(int a) { cout << setprecision(a) << fixed; }
void ip() {}
void time() {}
using namespace std;
bool isprime(long long n) {
for (long long i = 2; i < n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void solve(int tc) {
long long n, k;
cin >> n >> k;
long long ans = 0, cur = 1;
while (cur < k) {
cur *= 2;
ans++;
}
if (cur < n) {
ans += (n - cur + k - 1) / k;
}
cout << ans << "\n";
}
int main() {
ip();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int testcase = 1;
cin >> testcase;
for (int tc = 1; tc <= testcase; tc++) {
solve(tc);
}
time();
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 2e18;
vector<long long int> op2;
long long int ans = 0;
long long int get(long long int id, long long int day) {
if (!day) return id + 1;
long long int temp = id + 1, now = 1;
while (op2[temp] < op2[id] && now <= day) {
long long int pre = op2[id];
while (pre > op2[temp]) {
pre = op2[temp];
temp = get(temp, now - 1);
}
ans = max(ans, now);
now++;
}
return temp;
}
int main() {
long long int n;
cin >> n;
op2.resize(n);
for (long long int i = 0; i < n; i++) cin >> op2[i];
bool good = false;
for (long long int i = 1; i < n; i++) {
if (op2[i] < op2[i - 1]) good = true;
}
if (!good) {
cout << 0;
return 0;
}
op2.push_back(INF);
long long int now = 0;
while (now != n) {
now = get(now, INF);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int A[2222];
int main() {
int d, n, i;
for (scanf("%d %d", &d, &n), i = 0; i < n; scanf("%d", &A[i++]))
;
long long res = 0;
for (i = 1; i < n; i++) res += d - A[i - 1];
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(time(nullptr));
const long long INF = 1e18;
long long n, x, y;
vector<pair<long long, long long> > pref, suff;
bool check(long long l, long long r) {
long long x1 = (l == 0 ? 0 : pref[l - 1].first) +
(r == n - 1 ? 0 : suff[r + 1].first),
y1 = (l == 0 ? 0 : pref[l - 1].second) +
(r == n - 1 ? 0 : suff[r + 1].second);
long long a = abs(x - x1) + abs(y - y1);
if (a > r - l + 1) return false;
return ((r - l + 1 - a) % 2 == 0);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> n >> s >> x >> y;
pref.resize(n);
suff.resize(n);
map<char, pair<long long, long long> > m;
m['R'] = {1, 0};
m['L'] = {-1, 0};
m['U'] = {0, 1};
m['D'] = {0, -1};
for (long long i = 0; i < n; i++) {
pref[i] = {m[s[i]].first + (i != 0 ? pref[i - 1].first : 0),
m[s[i]].second + (i != 0 ? pref[i - 1].second : 0)};
}
for (long long i = n - 1; i > -1; i--) {
suff[i] = {m[s[i]].first + (i != n - 1 ? suff[i + 1].first : 0),
m[s[i]].second + (i != n - 1 ? suff[i + 1].second : 0)};
}
long long ans = INF;
if (pref[n - 1].first == x && pref[n - 1].second == y) {
cout << 0;
return 0;
}
for (long long i = 0; i < n; i++) {
long long l = i - 1, r = n - 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(i, mid))
r = mid;
else
l = mid;
}
if (check(i, r)) ans = min(ans, r - i + 1);
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point(double ix = 0, double iy = 0) {
x = ix;
y = iy;
}
};
inline Point operator+(Point a, Point b) { return Point(a.x + b.x, a.y + b.y); }
inline Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
inline double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
const int N = 10004;
const double PI = acos(-1.0);
const double EPS = 1e-9;
Point p[N];
double area[N];
int n, q, nxt[N], prv[N];
inline int func(int i, int j, Point dir) {
double tmp = (p[j].x - p[i].x) * dir.x + (p[j].y - p[i].y) * dir.y;
if (abs(tmp) < EPS) return 0;
if (tmp > 0) return 1;
return -1;
}
inline bool isExtreme(int i, Point dir) {
if (func(prv[i], i, dir) >= 0 && func(i, nxt[i], dir) == -1) return true;
if (func(prv[i], i, dir) == 1 && func(i, nxt[i], dir) <= 0) return true;
return false;
}
inline int getExtreme(double ang) {
Point dir(cos(ang), sin(ang));
if (isExtreme(0, dir)) return 0;
if (isExtreme(1, dir)) return 1;
if (func(0, 1, dir) == -1) {
int lo = 0, hi = n - 1;
while (lo < hi) {
int mi = (lo + hi) / 2;
if (isExtreme(mi, dir)) return mi;
int tmp = func(mi, nxt[mi], dir);
if (tmp >= 0) {
lo = mi + 1;
} else {
if (func(0, mi, dir) == -1) {
lo = mi + 1;
} else {
hi = mi;
}
}
}
return lo;
} else if (func(0, 1, dir) == 1) {
int lo = 0, hi = n - 1;
while (lo < hi) {
int mi = (lo + hi) / 2;
if (isExtreme(mi, dir)) return mi;
int tmp = func(mi, nxt[mi], dir);
if (tmp <= 0) {
hi = mi;
} else {
if (func(0, mi, dir) == 1) {
lo = mi + 1;
} else {
hi = mi;
}
}
}
return lo;
} else {
int lo = 0, hi = n - 1;
while (lo < hi) {
int mi = (lo + hi) / 2;
if (isExtreme(mi, dir)) return mi;
int tmp = func(mi, nxt[mi], dir);
if (tmp == 1) {
lo = mi + 1;
} else {
hi = mi;
}
}
return lo;
}
}
inline double getArea(Point a, Point b) {
return (b.x - a.x) * (b.y + a.y) / 2;
}
inline double getAreaRange(int l, int r) {
if (l == r) return 0.0;
if (l < r) {
if (l > 0) {
return area[r - 1] - area[l - 1];
} else {
return area[r - 1];
}
}
if (r == 0) return area[n - 1] - area[l - 1];
return area[n - 1] - area[l - 1] + area[r - 1];
}
inline bool getIntersection(Point a, Point b, Point c, Point d, Point &p) {
double a11 = b.x - a.x;
double a12 = c.x - d.x;
double a21 = b.y - a.y;
double a22 = c.y - d.y;
double det = a11 * a22 - a12 * a21;
if (abs(det) < EPS) return false;
double s = ((c.x - a.x) * a22 - (c.y - a.y) * a12) / det;
double t = ((c.y - a.y) * a11 - (c.x - a.x) * a21) / det;
p.x = a.x + (b.x - a.x) * s;
p.y = a.y + (b.y - a.y) * s;
return true;
}
inline double getAreaDiff(double x, double y, double ang) {
int a = getExtreme(ang - PI / 2);
int b = getExtreme(ang + PI / 2);
Point center(x, y);
Point u, v;
int up, dw;
{
int lo = a, hi = b;
Point dir(cos(ang), sin(ang));
while (lo != hi) {
int mi;
if (lo < hi) {
mi = (lo + hi + 1) / 2;
} else {
mi = (lo + hi + n + 1) / 2;
if (mi >= n) mi -= n;
}
double tmp = cross(p[mi] - center, dir);
if (tmp < 0) {
hi = prv[mi];
} else {
lo = mi;
}
}
up = lo;
getIntersection(p[up], p[nxt[up]], center, center + dir, u);
}
{
int lo = b, hi = a;
Point dir(-cos(ang), -sin(ang));
while (lo != hi) {
int mi;
if (lo < hi) {
mi = (lo + hi + 1) / 2;
} else {
mi = (lo + hi + n + 1) / 2;
if (mi >= n) mi -= n;
}
double tmp = cross(p[mi] - center, dir);
if (tmp < 0) {
hi = prv[mi];
} else {
lo = mi;
}
}
dw = lo;
getIntersection(p[dw], p[nxt[dw]], center, center + dir, v);
}
double tot = 0.0;
tot += getAreaRange(nxt[up], dw) + getArea(p[dw], v) + getArea(v, u) +
getArea(u, p[nxt[up]]);
tot -= getAreaRange(nxt[dw], up) + getArea(p[up], u) + getArea(u, v) +
getArea(v, p[nxt[dw]]);
return tot;
}
inline double query(double x, double y) {
double lo = -PI / 2;
double hi = +PI / 2;
double areadifflo = getAreaDiff(x, y, lo);
for (int it = 0; it < 35; it++) {
double mi = (lo + hi) / 2;
double tmp = getAreaDiff(x, y, mi);
if (abs(tmp) < EPS) {
if (mi < 0) return mi + PI;
return mi;
}
if (areadifflo > 0) {
if (tmp < 0) {
hi = mi;
} else {
lo = mi;
areadifflo = tmp;
}
} else {
if (tmp < 0) {
lo = mi;
areadifflo = tmp;
} else {
hi = mi;
}
}
}
if (lo < 0) return lo + PI;
return lo;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> p[i].x >> p[i].y;
nxt[i] = (i + 1 < n) ? (i + 1) : 0;
prv[nxt[i]] = i;
}
reverse(p, p + n);
for (int i = 0; i < n; i++) {
area[i] = getArea(p[i], p[nxt[i]]);
if (i > 0) area[i] += area[i - 1];
}
while (q--) {
double x, y;
cin >> x >> y;
cout << setprecision(30) << query(x, y) << '\n';
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l;
bool vis[100][100];
int d[100][100][2];
void dfs(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y] == 1) return;
vis[x][y] = 1;
dfs(x, y + d[x][y][1]);
dfs(x + d[x][y][0], y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
string x;
cin >> x;
for (i = 0; i < n; i++) {
int dt;
if (x[i] == '>')
dt = 1;
else
dt = -1;
for (j = 0; j < m; j++) {
d[i][j][1] = dt;
}
}
cin >> x;
for (j = 0; j < m; j++) {
int dt;
if (x[j] == 'v')
dt = 1;
else
dt = -1;
for (i = 0; i < n; i++) {
d[i][j][0] = dt;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
memset(vis, 0, sizeof(vis));
dfs(i, j);
for (k = 0; k < n; k++) {
for (l = 0; l < m; l++) {
if (vis[k][l] == 0) {
cout << "NO";
return 0;
}
}
}
}
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const int MAX_N = 1e6 + 5;
int fpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % Mod;
x = 1ll * x * x % Mod;
y >>= 1;
}
return res;
}
int N, K, fac[MAX_N], ifc[MAX_N];
int f[MAX_N], s[MAX_N];
int main() {
cin >> N >> K;
fac[0] = 1;
for (int i = 1; i <= N; i++) fac[i] = 1ll * fac[i - 1] * i % Mod;
ifc[N] = fpow(fac[N], Mod - 2);
for (int i = N - 1; ~i; i--) ifc[i] = 1ll * ifc[i + 1] * (i + 1) % Mod;
f[1] = s[1] = 1;
for (int i = 2; i <= N; i++) {
f[i] = 1ll * fac[i - 2] * (s[i - 1] - s[max(0, i - K - 1)] + Mod) % Mod;
s[i] = (s[i - 1] + 1ll * f[i] * ifc[i - 1]) % Mod;
}
int ans = (fac[N] - 1ll * s[N] * fac[N - 1] % Mod + Mod) % Mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int a[4], d, sum, visit[4];
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int lcm(int x, int y) { return x / gcd(x, y) * y; }
void dfs(int deep, int temp, int i) {
for (; i < 4; i++) {
if (!visit[i]) {
visit[i] = 1;
if (deep & 1)
sum -= d / lcm(temp, a[i]);
else
sum += d / lcm(temp, a[i]);
dfs(deep + 1, lcm(temp, a[i]), i);
visit[i] = 0;
}
}
}
int main() {
int i, j;
while (~scanf("%d %d %d %d %d", &a[0], &a[1], &a[2], &a[3], &d)) {
sum = 0;
memset(visit, 0, sizeof(visit));
dfs(0, 1, 0);
printf("%d\n", sum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, capacity, cost, rev;
edge() {}
edge(int to, int _capacity, int _cost, int _rev)
: to(to), capacity(_capacity), cost(_cost), rev(_rev) {}
};
const int inf = 0x3f3f3f3f;
struct Min_Cost_Max_Flow {
int V, H[6555 + 5], dis[6555 + 5], PreV[6555 + 5], PreE[6555 + 5];
vector<edge> G[6555 + 5];
void Init(int n) {
V = n;
for (int i = 0; i <= V; ++i) G[i].clear();
}
void add_edge(int from, int to, int cap, int cost) {
G[from].push_back(edge(to, cap, cost, G[to].size()));
G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
int minCost(int s, int t, int f) {
int flow = 0;
int res = 0;
fill(H, H + 1 + V, 0);
while (f) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
fill(dis, dis + 1 + V, inf);
dis[s] = 0;
q.push(pair<int, int>(0, s));
while (!q.empty()) {
pair<int, int> now = q.top();
q.pop();
int v = now.second;
if (dis[v] < now.first) continue;
for (int i = 0; i < G[v].size(); ++i) {
edge& e = G[v][i];
if (e.capacity > 0 && dis[e.to] > dis[v] + e.cost + H[v] - H[e.to]) {
dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
PreV[e.to] = v;
PreE[e.to] = i;
q.push(pair<int, int>(dis[e.to], e.to));
}
}
}
if (dis[t] == inf) break;
for (int i = 0; i <= V; ++i) H[i] += dis[i];
int d = f;
for (int v = t; v != s; v = PreV[v])
d = min(d, G[PreV[v]][PreE[v]].capacity);
f -= d;
flow += d;
res += d * H[t];
for (int v = t; v != s; v = PreV[v]) {
edge& e = G[PreV[v]][PreE[v]];
e.capacity -= d;
G[v][e.rev].capacity += d;
}
}
return res;
}
} mcmf;
int main() {
int n, m, k, c, d;
cin >> n >> m >> k >> c >> d;
mcmf.Init(n * (n + 55) + 2);
for (int i = 0; i < k; i++) {
int u;
cin >> u;
mcmf.add_edge(0, u, 1, 0);
}
vector<pair<int, int> > edge = vector<pair<int, int> >(m);
for (int i = 0; i < m; i++) cin >> edge[i].first >> edge[i].second;
int tar = n * (n + 55) + 1;
for (int t = 0; t < n + 54; t++) {
for (pair<int, int> e : edge) {
for (int j = 1; j <= k; j++) {
mcmf.add_edge(e.first + t * n, e.second + (t + 1) * n, 1,
c + d * (j * 2 - 1));
mcmf.add_edge(e.second + t * n, e.first + (t + 1) * n, 1,
c + d * (j * 2 - 1));
}
}
for (int i = 2; i <= n; i++) {
mcmf.add_edge(i + t * n, i + (t + 1) * n, k, c);
}
mcmf.add_edge(1 + t * n, tar, k, 0);
}
cout << mcmf.minCost(0, tar, k) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 2e5 + 12;
const long long INF = 1e18 + 12;
const long long Inf = 1e9 + 12;
const long long mod = 1e9 + 7;
long long n, k = 1, y, a[maxN], sum, w, ans[maxN];
vector<pair<long long, long long> > v;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
if (a[i] % 2) k--, ans[i]++;
k -= a[i] / 2;
ans[i] += a[i] / 2;
}
if (k < 0) {
cout << -1 << endl;
return 0;
}
for (long long i = 1; i <= n; i++) {
v.push_back({a[i], i});
}
sort(v.begin(), v.end());
for (long long i = v.size() - 1; i >= 0; i--) {
if (k <= v[i].first / 2) {
ans[v[i].second] += k;
k = 0;
} else {
ans[v[i].second] = v[i].first;
k -= v[i].first / 2;
}
}
for (long long i = 1; i <= n; i++) cout << ans[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (4e5 + 5);
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
const long long LOG = 29;
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
res %= MOD;
return res;
}
void solve() {
long long n, second;
cin >> n >> second;
if (second < 2 * n) {
cout << "NO\n";
return;
}
cout << "YES\n";
long long k = 1;
if (second % n != 0) {
long long each = second / n;
long long each2 = (n - 1) * (each);
each2 = second - each2;
for (long long i = 1; i < n; i++) cout << each << " ";
cout << each2 << "\n";
} else {
long long each = second / n;
for (long long i = 1; i <= n; i++) cout << each << " ";
cout << "\n";
}
cout << k << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
void turn_off_de_bug() { freopen("/dev/null", "w", stderr); }
template <typename T, typename S>
std::ostream& operator<<(std::ostream& out, const std::pair<T, S>& p) {
out << '(' << p.first << ", " << p.second << ")";
return out;
}
template <typename T>
std::ostream& operator<<(std::ostream& out, const std::vector<T>& v) {
if (!v.empty()) {
out << '[';
std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
out << "\b\b]";
}
return out;
}
template <typename T, typename S>
std::ostream& operator<<(std::ostream& out,
const std::set<std::pair<T, S> >& v) {
out << '{';
for (const auto& p : v) out << p << ", ";
out << "\b\b}";
return out;
}
template <typename T, typename S>
std::ostream& operator<<(std::ostream& out,
const std::multiset<std::pair<T, S> >& v) {
out << '{';
for (const auto& p : v) out << p << ", ";
out << "\b\b}";
return out;
}
template <typename T, typename S>
std::ostream& operator<<(std::ostream& out,
const std::vector<std::pair<T, S> >& v) {
out << '[';
for (const auto& p : v) out << p << ", ";
out << "\b\b]";
return out;
}
template <typename T, typename S>
std::ostream& operator<<(std::ostream& out,
const std::vector<std::vector<std::pair<T, S> > >& v) {
out << '[';
for (int i = 0; i < static_cast<int>(v.size()); ++i)
out << '(' << i << ", " << v[i] << "), ";
out << "\b\b]";
return out;
}
const char* HR =
"--------------------"
"--------------------"
"--------------------"
"--------------------"
"--------------------";
const int INF32 = int(1e9);
const long long INF64 = int(1e18);
int n;
std::vector<int> a, b;
void read() {
std::cin >> n;
a.resize(n);
for (int& it : a) std::cin >> it;
b.resize(n);
for (int& it : b) std::cin >> it;
}
void solve() {
long long need = 0;
long long add = 0;
long long extra = 2e9;
for (int i = n - 1; i >= 0; --i) {
if (b[i] < need) {
std::cout << "NO\n";
return;
}
long long val = b[i] - a[i];
long long to_add = std::min(extra, std::max(0LL, val - need));
add += to_add;
extra = std::min(extra - to_add, b[i] - need - to_add);
need = std::max(0LL, need - val);
}
std::cout << (add >= need ? "YES" : "NO");
std::cout << "\n";
}
int main(int argc, char const* argv[]) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
turn_off_de_bug();
int NUM_CASES = 1;
std::cin >> NUM_CASES;
while (NUM_CASES--) {
read();
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
long long query(int t, int i, int j, int k) {
long long ret = 0;
printf("%d %d %d %d\n", t, i, j, k);
fflush(stdout);
scanf("%lld", &ret);
return ret;
}
long long Sign[N], Sqr[N], Sign2[N], Pri[N];
long long Pos[N], Neg[N];
int tmpp[N];
int n, ptot = 1, ntot = 1;
bool cmp(const int AA, const int BB) {
if (Pri[AA] != Pri[BB]) return Pri[AA] < Pri[BB];
if (Pri[AA] & 1) return Sqr[AA] < Sqr[BB];
return Sqr[AA] > Sqr[BB];
}
int main() {
scanf("%d", &n);
for (int i = 3; i <= n; i++) Sign[i] = query(2, 1, 2, i);
for (int i = 3; i <= n; i++) Sqr[i] = query(1, 1, 2, i);
long long PosMax = 0ll, NegMax = 0ll, pmax = 0, nmax = 0;
for (int i = 3; i <= n; i++) {
if (Sign[i] == 1 && Sqr[i] > PosMax) pmax = i, PosMax = Sqr[i];
if (Sign[i] == -1 && Sqr[i] > NegMax) nmax = i, NegMax = Sqr[i];
}
if (PosMax) {
for (int i = 3; i <= n; i++) {
if (Sign[i] == 1 && i != pmax) {
int tmp = (int)query(2, pmax, 1, i);
if (tmp == -1)
Pri[i] = 4;
else
Pri[i] = 3;
}
}
Pri[pmax] = 4;
}
if (NegMax) {
for (int i = 3; i <= n; i++) {
if (Sign[i] == -1 && i != nmax) {
int tmp = (int)query(2, nmax, 1, i);
if (tmp == -1)
Pri[i] = 2;
else
Pri[i] = 1;
}
}
Pri[nmax] = 1;
}
Pri[1] = 1, Pri[2] = 3;
for (int i = 1; i <= n; i++) tmpp[i] = i;
sort(tmpp + 1, tmpp + n + 1, cmp);
printf("0");
for (int i = 1; i <= n; i++) printf(" %d", tmpp[i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int n = str.length();
int x, y, z;
for (int i = 1; i <= 5; i++) {
if ((n / i + 1) <= 20 && n % i) {
y = (n / i + 1);
x = i;
z = i - (n) % i;
break;
} else if (n / i <= 20 && n % i == 0) {
y = n / i;
x = i;
z = 0;
break;
}
}
cout << x << " " << y << "\n";
int a;
for (int i = 0; i < x; i++) {
if (x - i > z)
for (int j = 0; j < y; j++) {
if (i * y + j < n) cout << str[i * y + j];
a = i + 1;
}
else {
for (int j = 0; j < y - 1; j++) {
if (a * y + (i - a) * (y - 1) + j < n)
cout << str[a * y + (i - a) * (y - 1) + j];
}
cout << '*';
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> d[300005];
int f[300005], a[300005];
int pr[300005], pr1[300005];
int ne[300005], ne1[300005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
for (pr[i] = i - 1; pr[i] > 0 && a[pr[i]] < a[i]; pr[i] = pr[pr[i]])
;
if (pr[i]) d[i].emplace_back(pr[i]);
for (pr1[i] = i - 1; pr1[i] > 0 && a[pr1[i]] > a[i]; pr1[i] = pr1[pr1[i]])
;
if (pr1[i]) d[i].emplace_back(pr1[i]);
}
for (int i = n; i >= 1; --i) {
for (ne[i] = i + 1; ne[i] <= n && a[ne[i]] < a[i]; ne[i] = ne[ne[i]])
;
if (ne[i] <= n) d[ne[i]].emplace_back(i);
for (ne1[i] = i + 1; ne1[i] <= n && a[ne1[i]] > a[i]; ne1[i] = ne1[ne1[i]])
;
if (ne1[i] <= n) d[ne1[i]].emplace_back(i);
}
fill(f + 1, f + n + 1, n + 5);
f[1] = 0;
for (int i = 2; i <= n; ++i) {
for (auto &j : d[i]) f[i] = min(f[i], f[j] + 1);
}
cout << f[n];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 10;
int n, k, x;
int a[66][maxn];
int check(int t) {
for (int i = 0; i < t; ++i) {
int j;
for (j = 0; j < n; ++j) {
if (a[i][j] != a[t][j]) break;
}
if (j == n) return i;
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> x;
for (int i = 0; i < n; ++i) {
cin >> a[0][i];
}
int idx = k;
sort(a[0], a[0] + n);
for (int t = 1; t <= k; ++t) {
for (int i = 0; i < n; ++i) {
if (i & 1)
a[t][i] = a[t - 1][i];
else
a[t][i] = a[t - 1][i] ^ x;
}
sort(a[t], a[t] + n);
int st = check(t);
if (st != -1) {
int loooop = t - st;
idx = st + (k - t) % loooop;
break;
}
}
int mx = -1, mn = 0x7fffffff;
for (int i = 0; i < n; ++i) {
mx = max(mx, a[idx][i]);
mn = min(mn, a[idx][i]);
}
cout << mx << ' ' << mn;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
pair<int, int> a[N], b[N];
vector<int> vec;
vector<pair<pair<int, int>, pair<int, int> > > ans;
void ADD(pair<int, int> a, pair<int, int> b) {
ans.push_back(pair<pair<int, int>, pair<int, int> >(a, b));
}
void move_RC(int &x, int &y, int xx, int yy) {
while (x < xx) ADD(pair<int, int>(x, y), pair<int, int>(x + 1, y)), x++;
while (x > xx) ADD(pair<int, int>(x, y), pair<int, int>(x - 1, y)), x--;
while (y < yy) ADD(pair<int, int>(x, y), pair<int, int>(x, y + 1)), y++;
while (y > yy) ADD(pair<int, int>(x, y), pair<int, int>(x, y - 1)), y--;
}
void move_CR(int &x, int &y, int xx, int yy) {
while (y < yy) ADD(pair<int, int>(x, y), pair<int, int>(x, y + 1)), y++;
while (y > yy) ADD(pair<int, int>(x, y), pair<int, int>(x, y - 1)), y--;
while (x < xx) ADD(pair<int, int>(x, y), pair<int, int>(x + 1, y)), x++;
while (x > xx) ADD(pair<int, int>(x, y), pair<int, int>(x - 1, y)), x--;
}
void move(int &x, int &y, int xx, int yy) { move_RC(x, y, xx, yy); }
void print() {
cout << ans.size() << '\n';
for (pair<pair<int, int>, pair<int, int> > p : ans)
cout << p.first.first << ' ' << p.first.second << ' ' << p.second.first
<< ' ' << p.second.second << '\n';
exit(0);
}
bool cmp_a(int A, int B) { return a[A] < a[B]; }
bool cmp_b(int A, int B) { return b[A] < b[B]; }
bool empty(int x, int y) {
for (int i = 0; i < m; i++)
if (a[i] == pair<int, int>(x, y)) return false;
return true;
}
void move_to_first_row() {
sort(vec.begin(), vec.end(), [](int A, int B) {
if (a[A].first != a[B].first) return a[A].first > a[B].first;
if (a[A].first == n) return a[A].second < a[B].second;
return a[A].second > a[B].second;
});
for (int dex : vec) {
if (a[dex].first != n) {
while (empty(a[dex].first + 1, a[dex].second) == false)
move(a[dex].first, a[dex].second, a[dex].first, a[dex].second + 1);
move(a[dex].first, a[dex].second, n - 1, a[dex].second);
while (empty(n, a[dex].second) == false)
move(a[dex].first, a[dex].second, a[dex].first, a[dex].second + 1);
}
move(a[dex].first, a[dex].second, n, a[dex].second);
while (a[dex].second > 1 && empty(a[dex].first, a[dex].second - 1))
move(a[dex].first, a[dex].second, a[dex].first, a[dex].second - 1);
}
}
void sort_them() {
sort(vec.begin(), vec.end(),
[](int A, int B) { return b[A].second < b[B].second; });
for (int i = 0; i < m; i++)
move(a[i].first, a[i].second, a[i].first - 2, a[i].second);
for (int i = 0; i < m; i++) {
int dex = vec[i];
move(a[dex].first, a[dex].second, a[dex].first + 1, a[dex].second);
move(a[dex].first, a[dex].second, a[dex].first, i + 1);
move(a[dex].first, a[dex].second, a[dex].first + 1, a[dex].second);
}
for (int i = 0; i < m; i++)
if (a[vec[i]].second != i + 1) abort();
}
void move_them() {
sort(vec.begin(), vec.end(), cmp_b);
for (int dex : vec)
if (b[dex].first < n - 1) {
move_RC(a[dex].first, a[dex].second, b[dex].first + 1, b[dex].second);
move(a[dex].first, a[dex].second, b[dex].first, b[dex].second);
}
for (int i = 0; i < m; i++)
if (b[i].first == n - 1)
move_RC(a[i].first, a[i].second, n - 1, a[i].second);
sort(vec.begin(), vec.end(), cmp_a);
for (int dex : vec) {
if (a[dex].first >= n - 1)
while (a[dex].second > 1 && empty(a[dex].first, a[dex].second - 1))
move(a[dex].first, a[dex].second, a[dex].first, a[dex].second - 1);
}
sort(vec.begin(), vec.end(), cmp_b);
reverse(vec.begin(), vec.end());
for (int dex : vec)
if (a[dex].first >= n - 1)
move(a[dex].first, a[dex].second, b[dex].first, b[dex].second);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> a[i].first >> a[i].second;
for (int i = 0; i < m; i++) cin >> b[i].first >> b[i].second;
for (int i = 0; i < m; i++) vec.push_back(i);
if (m <= 1) {
for (int i = 0; i < m; i++)
move(a[i].first, a[i].second, b[i].first, b[i].second);
print();
}
move_to_first_row();
if (n == 2) {
if (b[0].first == 1) {
move_RC(a[0].first, a[0].second, b[0].first, b[0].second);
move_CR(a[1].first, a[1].second, b[1].first, b[1].second);
} else if (b[1].first == 1) {
move_RC(a[1].first, a[1].second, b[1].first, b[1].second);
move_CR(a[0].first, a[0].second, b[0].first, b[0].second);
} else if (a[0] != b[0]) {
move(a[0].first, a[0].second, 1, a[0].second);
move_RC(a[1].first, a[1].second, 2, b[1].second);
move_CR(a[0].first, a[0].second, b[0].first, b[0].second);
}
print();
}
sort_them();
move_them();
print();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c = 0, d = 0;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b;
if (b == 1) {
c++;
break;
}
}
if (c > 0)
cout << -1;
else
cout << 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1000000007;
void solve() {
long long a, b;
cin >> a >> b;
if (b == 1) {
cout << a;
return;
}
long long ans = 1;
while (ans < a) ans = ans * 2 + 1;
cout << ans;
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long calc(long long limit, long long sup) {
long long inf = 1;
while (inf < sup) {
long long mid((inf + sup + 1) >> 1);
if (mid & 1) {
long long temp(mid * (mid - 1) >> 1);
if (temp <= limit)
inf = mid;
else
sup = mid - 1;
} else {
long long temp((mid * (mid - 1) >> 1) + (mid / 2 - 1));
if (temp <= limit)
inf = mid;
else
sup = mid - 1;
}
}
return inf;
}
long long value[100010];
bool cmp(long long x, long long y) { return y < x; }
int main() {
long long n, m;
scanf("%I64d%I64d", &n, &m);
n = calc(n - 1, m);
for (long long i(0); i != m; ++i) {
long long x;
scanf("%I64d%I64d", &x, value + i);
}
sort(value, value + m, cmp);
long long ans(0);
for (long long i(0); i != n; ++i) ans += value[i];
printf("%I64d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long mod = 1e9 + 7;
long long n, q, fact[4000005], invfact[4000005], dp[3000005][3], inv3;
long long inv(long long a) {
long long rez = 1;
long long b = mod - 2;
while (b) {
if (b & 1) rez = (rez * a) % mod;
b /= 2;
a = (a * a) % mod;
}
return rez;
}
long long comb(long long a, long long b) {
if (a < 0 || b < 0 || a < b) return 0;
long long rez = (fact[a] * invfact[b]) % mod;
rez = (rez * invfact[a - b]) % mod;
return rez;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
fact[0] = invfact[0] = 1;
for (long long i = 1; i <= 3 * n; i++) fact[i] = (fact[i - 1] * i) % mod;
invfact[3 * n] = inv(fact[3 * n]);
for (long long i = 3 * n - 1; i >= 1; i--)
invfact[i] = (invfact[i + 1] * (i + 1)) % mod;
dp[0][0] = dp[0][1] = dp[0][2] = n;
inv3 = inv(3);
for (long long x = 1; x <= 3 * n; x++) {
long long suma = comb(3 * n, x + 1);
long long a = dp[x - 1][0];
long long b = dp[x - 1][1];
long long val = suma - 2 * a - b;
while (val < 0) val += mod;
val = (val * inv3) % mod;
dp[x][0] = val;
dp[x][1] = (dp[x][0] + a) % mod;
dp[x][2] = (dp[x][1] + b) % mod;
}
cin >> q;
while (q--) {
long long x;
cin >> x;
cout << (dp[x][0] + comb(3 * n, x)) % mod << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int inline ipow(long long int a, long long int b, long long int m) {
long long int val = 1;
a %= m;
while (b) {
if (b & 01) val = (val * a) % m;
b >>= 1;
a = (a * a) % m;
};
return val % m;
}
long long int inline ipow(long long int a, long long int b) {
long long int val = 1;
while (b) {
if (b & 01) val = (val * a);
b >>= 1;
a = (a * a);
};
return val;
}
int parent[100005], type[100005];
int find(int x) {
if (parent[x] == x) return x;
int p = parent[x];
parent[x] = find(parent[x]);
type[x] = (type[x] + type[p] + 1) % 2;
return parent[x];
}
void uni(int x, int y, int u, int v, int typ) {
parent[x] = y;
type[x] = (type[v] - type[u] + typ) % 2;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t tStart = clock();
int i, x, y, px, py, typ, n, m;
cin >> n >> m;
for (i = 1; i <= n; i++) {
parent[i] = i;
type[i] = 1;
}
bool fl = true;
for (i = 1; i <= m; i++) {
cin >> x >> y >> typ;
if (!fl) continue;
px = find(x);
py = find(y);
if (px == py) {
if (typ == 0 && type[x] == type[y])
fl = false;
else if (typ == 1 && type[x] != type[y])
fl = false;
} else
uni(px, py, x, y, typ);
}
if (!fl)
cout << "0\n";
else {
int num = 0;
for (i = 1; i <= n; i++)
if (parent[i] == i) num++;
cout << ipow(2, num - 1, 1000000007);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
void fo() { fflush(stdout); }
using namespace std;
int n, m;
int a[100];
int b[100];
int main() {
cin >> n >> m;
int c;
cin >> c;
for (int i = 0; i < c; i++) {
int t;
cin >> t;
a[t] = 1;
}
cin >> c;
for (int i = 0; i < c; i++) {
int t;
cin >> t;
b[t] = 1;
}
for (int i = 0; i <= 1000000; i++) {
int l = i % n;
int r = i % m;
if (a[l] || b[r]) a[l] = b[r] = 1;
}
bool ok = 1;
for (int i = 0; i < n; i++) ok &= a[i];
for (int i = 0; i < m; i++) ok &= b[i];
if (ok)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, i, j, c = 0, m, n, a, b;
string s = "aeiou", ss = "aeiou";
cin >> k;
for (i = 5; i < k; i++) {
if (k % i == 0) {
a = i;
break;
}
}
b = k / a;
if (a < 5 || b < 5) {
cout << -1;
return 0;
}
for (i = 0; i < 10000; i += 1) s += ss;
for (i = 0; i < b; i++) {
for (j = i; j < a + i; j++) cout << s[j];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long modpow(long long a, long long n, long long temp) {
long long res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
long long ison(long long mask, long long pos) { return (mask & (1 << pos)); }
long long cbit(long long n) {
long long k = 0;
while (n) n &= (n - 1), k++;
return k;
}
long long nbit(long long n) {
long long k = 0;
while (n) n /= 2, k++;
return k;
}
long long mod = 1e9 + 7;
int sgn(long long x) { return x < 0 ? -1 : !!x; }
const double eps = 1e-7;
const double pi = acos(-1.0);
inline void inc(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline void dec(long long &x, long long y) {
x -= y;
if (x < 0) x += mod;
}
inline void chmax(long long &x, long long y) {
if (y > x) x = y;
}
inline void mulm(long long &x, long long y) {
x *= y;
if (x >= mod) x -= mod;
}
long long xo(long long i) {
if ((i & 3) == 0) return i;
if ((i & 3) == 1) return 1;
if ((i & 3) == 2) return i + 1;
return 0;
}
long long comb[105][105];
long long memo[105][105];
long long dp[105][105];
long long a[105];
long long solve(long long d, long long left) {
if (d == 10) return (left == 0);
if (memo[d][left]) return dp[d][left];
long long res = 0;
memo[d][left] = 1ll;
for (long long i = a[d]; i <= left; i++) {
if (d == 0)
res = (res + comb[left - 1ll][i] * solve(d + 1ll, left - i)) % mod;
else
res = (res + comb[left][i] * solve(d + 1ll, left - i)) % mod;
}
return dp[d][left] = res;
}
int main() {
long long n, i, j, k, l, m;
cin >> n;
for (long long i = 0; i < 10; i++) cin >> a[i];
for (long long i = 0; i <= 100; i++) {
comb[i][0] = comb[i][i] = 1ll;
for (long long j = 1; j < i; j++)
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % mod;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) ans = (ans + solve(0ll, i)) % mod;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
map<string, int> mp;
map<string, int> mp2;
int n, m, maxsum = 0, minsum = 0;
cin >> n >> m;
string s[m];
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> s[i];
mp[s[i]]++;
}
for (int i = 0; i < m; i++) {
if (mp2[s[i]] == 0) v.push_back(mp[s[i]]);
mp2[s[i]]++;
}
sort(v.rbegin(), v.rend());
for (int i = 0; i < v.size(); i++) {
minsum += a[i] * v[i];
}
reverse(a, a + n);
for (int i = 0; i < v.size(); i++) {
maxsum += a[i] * v[i];
}
cout << minsum << " " << maxsum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[1000005];
int main() {
string s;
cin >> s;
int i, num = 0;
long long ans = 0;
for (i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'b') {
num++;
num %= mod;
} else {
a[i] = num;
num += a[i];
num %= mod;
a[i] %= mod;
}
}
for (i = 0; i < s.length(); i++) {
ans += a[i];
ans %= mod;
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int oo = 0x3f3f3f3f;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T gcd(T a, T b) {
T c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
template <class T>
inline T mabs(T a) {
if (a < 0)
return -a;
else
return a;
}
typedef vector<int> VI;
typedef vector<VI> VII;
typedef vector<string> VS;
const int N = (int)1e5 + 111;
const long long MOD = (long long)1e9 + 9;
int s[N];
char S[N];
int n, a, b, k;
long long co;
inline long long mpow(long long a, long long b) {
long long x = 1LL, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
y = (y * y) % MOD;
b >>= 1LL;
}
return x;
}
inline long long getZ(int n, int a, int b, int k, long long q) {
long long Z = 0LL;
for (int i = (0); i < int(k); i++) {
Z += mpow(a, n - i) * mpow(b, i) % MOD * q % MOD * s[i];
}
Z = (Z % MOD + MOD) % MOD;
return Z;
}
inline int solve(int testnum) {
scanf("%d%d%d%d", &n, &a, &b, &k);
scanf("%s", S);
for (int i = (0); i < int(k); i++) s[i] = (S[i] == '+' ? 1 : -1);
if (n < k) k = n + 1;
long long q = mpow(mpow(a, MOD - 2) * b % MOD, k);
int numblocks = (n + 1) / k;
if (q == 1LL)
q = numblocks;
else
q = (mpow(q, n / k + 1) - 1) * mpow(q - 1, MOD - 2) % MOD;
long long Z = getZ(n, a, b, k, q);
printf("%lld\n", Z);
return 0;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
int t = 1;
if (argc > 1) t = atoi(argv[1]);
for (int _t = (1); _t < int(t + 1); _t++) {
int ret = ::solve(_t);
if (ret == -1) {
cerr << "Failed test #" << _t << endl;
break;
}
cerr << "Solved test #" << _t << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve(long long &a, long long &b) {
if (a == 0 || b == 0)
return;
else if (a >= 2 * b) {
a = a % (2 * b);
solve(a, b);
} else if (b >= 2 * a) {
b = b % (2 * a);
solve(a, b);
} else {
return;
}
}
int main() {
long long a, b;
cin >> a >> b;
solve(a, b);
cout << a << " " << b << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, count;
vector<long long int> a1;
long long int a, b, max, min;
cin >> count;
for (long long int j = 0; j < count; j++) {
max = 0;
min = 1000000000;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> a >> b;
if (a > max) {
max = a;
}
if (b < min) {
min = b;
}
}
a1.push_back(max - min);
}
for (long long int i = 0; i < a1.size(); i++) {
if (a1[i] > 0) {
cout << a1[i];
} else {
cout << "0";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
while (N--) {
long long int n, temp, count0 = 0, count1 = 0, count2 = 0, count = 0;
cin >> n;
while (n--) {
cin >> temp;
temp = temp % 3;
if (temp == 0)
count0 += 1;
else if (temp == 1)
count1 += 1;
else
count2 += 1;
}
count += count0;
count += min(count1, count2);
count += abs(count1 - count2) / 3;
cout << count << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool con[110][110];
int main() {
int k;
cin >> k;
int n;
con[0][1] = con[1][0] = true;
for (n = 2; k and n <= 100; n++) {
for (int i = 0; k >= i and i < n; i++) {
con[i][n] = con[n][i] = true;
k -= i;
}
}
cout << n << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << con[i][j];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T sgn(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
const double pi = acos(-1.0);
int n;
int m;
deque<char> s1[300][300];
string s2[300][300];
set<pair<int, int>> a[2], b[2];
deque<pair<pair<int, int>, pair<int, int>>> cert;
void add_back(pair<int, int> from, pair<int, int> to) {
cert.push_back(make_pair(from, to));
assert(((int)(s1[from.first][from.second]).size()) > 0);
char c = s1[from.first][from.second].back();
s1[to.first][to.second].push_front(c);
s1[from.first][from.second].pop_back();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
string s;
cin >> s;
for (auto c : s) {
s1[i][j].push_back(c - '0');
}
}
string S;
vector<vector<int>> c(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
string s;
cin >> s;
c[i][j] = ((int)(s).size());
s2[i][j] = s;
}
S = s2[0][0] + s2[0][1] + s2[1][0];
while (((int)(s1[0][1]).size())) {
add_back(make_pair(0, 1), make_pair(0, 0));
}
while (((int)(s1[1][0]).size())) {
add_back(make_pair(1, 0), make_pair(0, 0));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 1) continue;
if (i == 1 && j == 0) continue;
while (((int)(s1[i][j]).size())) {
if (s1[i][j].back() == 0) {
if (i == 0 || j == 1) {
add_back(make_pair(i, j), make_pair(0, 1));
} else {
add_back(make_pair(i, j), make_pair(0, j));
add_back(make_pair(0, j), make_pair(0, 1));
}
} else {
if (i == 1 || j == 0) {
add_back(make_pair(i, j), make_pair(1, 0));
} else {
add_back(make_pair(i, j), make_pair(i, 0));
add_back(make_pair(i, 0), make_pair(1, 0));
}
}
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (i == 0 && j == 0) continue;
if (i == 0 && j == 1) continue;
if (i == 1 && j == 0) continue;
while (((int)(s2[i][j]).size())) {
if (s2[i][j].back() == '0') {
if (i == 0 || j == 1) {
add_back(make_pair(0, 1), make_pair(i, j));
} else {
add_back(make_pair(0, 1), make_pair(0, j));
add_back(make_pair(0, j), make_pair(i, j));
}
} else {
if (i == 1 || j == 0) {
add_back(make_pair(1, 0), make_pair(i, j));
} else {
add_back(make_pair(1, 0), make_pair(i, 0));
add_back(make_pair(i, 0), make_pair(i, j));
}
}
s2[i][j].pop_back();
}
}
}
reverse((S).begin(), (S).end());
for (int i = 0; i < ((int)(S).size()); i++) {
if (S[i] == '0') {
add_back(make_pair(0, 1), make_pair(0, 0));
} else if (S[i] == '1') {
add_back(make_pair(1, 0), make_pair(0, 0));
}
}
for (int k = 0; k < c[1][0]; k++) {
add_back(make_pair(0, 0), make_pair(1, 0));
}
for (int k = 0; k < c[0][1]; k++) {
add_back(make_pair(0, 0), make_pair(0, 1));
}
cout << ((int)(cert).size()) << endl;
for (auto x : cert) {
cout << x.first.first + 1 << " " << x.first.second + 1 << " "
<< x.second.first + 1 << " " << x.second.second + 1 << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[66];
long long int k[66];
int main() {
int n;
cin >> n;
memset(k, 0, sizeof(k));
while (n--) {
memset(a, 0, sizeof(a));
long long int b, c;
cin >> b >> c;
long long int j = b;
long long int d, e;
for (int i = 0;; i++) {
d = b % 2;
a[i] = d;
e = b / 2;
if (e == 0) break;
b = e;
}
for (int i = 0;; i++) {
if (!a[i]) {
if (!k[i]) k[i] = pow(2, i);
j += k[i];
}
if (j > c) {
j -= k[i];
break;
}
}
cout << j << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mol = 998244353;
const int maxn = 150000;
long long tree[4 * maxn + 11], lazy[4 * maxn + 11];
long long tag[maxn + 11];
int siz[maxn + 11], f[maxn + 11], id[maxn + 11], top[maxn + 11], son[maxn + 11];
vector<int> edge[maxn + 11];
int tot = 0;
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mol;
a = a * a % mol;
b >>= 1;
}
return ans;
}
void dfs(int x, int fa) {
siz[x] = 1;
f[x] = fa;
for (auto v : edge[x]) {
if (v == fa) continue;
dfs(v, x);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
}
}
void dfs2(int x, int t) {
top[x] = t;
id[x] = ++tot;
if (son[x]) dfs2(son[x], t);
for (auto v : edge[x]) {
if (v == f[x] || v == son[x]) continue;
dfs2(v, v);
}
}
long long add(long long a, long long b) {
a += b;
if (a >= mol) a -= mol;
return a;
}
long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += mol;
return a;
}
void push_up(int rt) { tree[rt] = add(tree[rt << 1], tree[rt << 1 | 1]); }
void push_down(int rt, int l, int r) {
int mid = (l + r) >> 1;
long long val = lazy[rt];
lazy[rt] = 0;
tree[rt << 1] = add(tree[rt << 1], val * (mid - l + 1) % mol);
lazy[rt << 1] = add(lazy[rt << 1], val);
tree[rt << 1 | 1] = add(tree[rt << 1 | 1], val * (r - mid) % mol);
lazy[rt << 1 | 1] = add(lazy[rt << 1 | 1], val);
}
void update(int rt, int l, int r, int al, int ar, long long val) {
if (l > ar || r < al) return;
if (l >= al && r <= ar) {
tree[rt] = add(tree[rt], val * (r - l + 1) % mol);
lazy[rt] = add(lazy[rt], val);
return;
}
if (lazy[rt]) push_down(rt, l, r);
int mid = (l + r) >> 1;
update(rt << 1, l, mid, al, ar, val);
update(rt << 1 | 1, mid + 1, r, al, ar, val);
push_up(rt);
}
long long query(int rt, int l, int r, int pos) {
if (l == r) return tree[rt];
if (lazy[rt]) push_down(rt, l, r);
int mid = (l + r) >> 1;
if (mid >= pos) return query(rt << 1, l, mid, pos);
return query(rt << 1 | 1, mid + 1, r, pos);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
edge[u].emplace_back(v);
edge[v].emplace_back(u);
}
dfs(1, 0);
dfs2(1, 1);
long long all = 0;
long long inv = qpow(n, mol - 2);
while (q--) {
int op, v;
scanf("%d %d", &op, &v);
if (op == 1) {
int d;
scanf("%d", &d);
tag[v] = add(tag[v], d);
all = add(all, inv * d % mol * siz[v] % mol);
if (son[v])
update(1, 1, n, id[son[v]], id[son[v]] + siz[son[v]] - 1,
inv * d % mol * sub(n - siz[v], siz[son[v]]) % mol);
} else {
long long ans =
add(query(1, 1, n, id[v]), inv * tag[v] % mol * (n - siz[v]) % mol);
while (v) {
v = top[v];
ans =
add(ans, tag[f[v]] * inv % mol * sub(n - siz[v], siz[f[v]]) % mol);
v = f[v];
}
printf("%lld\n", add(ans, all));
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long ans = 0;
if (k >= 1) ans++;
if (k >= 2) ans += (n * (n - 1)) / 2;
if (k >= 3) ans += (n * (n - 1) * (n - 2)) / 3;
if (k >= 4) ans += ((n * (n - 1) * (n - 2) * (n - 3)) / 24) * 9;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
int n = 2 * (a - 1), m = 2;
int d[2] = {1, 2};
if (a == 1) n = m = 1;
cout << n << " " << m << endl;
for (int i = 0; i < m; i++) cout << d[i] << (i == m - 1 ? "\n" : " ");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, countHolidaymin, countHolidaymax = 0, leftDay;
scanf("%d", &n);
countHolidaymin = n / 7;
countHolidaymin *= 2;
leftDay = n % 7;
if (leftDay <= 2)
countHolidaymax = countHolidaymin + leftDay;
else
countHolidaymax = countHolidaymin + 2;
if (leftDay > 5) countHolidaymin++;
cout << countHolidaymin << " " << countHolidaymax << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool ks;
int n, m, q, FANG;
int dfn[100010], low[100010], dfs_clock, a[200010], b[200010];
int X[200010], Y[200010];
int sta[100010], sttop;
multiset<int> w[200010];
int fa[200010], si_ze[200010], dep[200010], id[200010], top[200010],
son[200010];
vector<int> G[100010], T[200010];
char opt[10];
struct SegmentTree {
int l, r, minn;
} st[800010];
bool js;
inline int read() {
int x = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return w ? -x : x;
}
void tarjan(int x) {
dfn[x] = low[x] = ++dfs_clock;
sta[++sttop] = x;
for (int i = 0, y = G[x][0], End = G[x].size(); i < End; y = G[x][++i]) {
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
if (dfn[x] <= low[y]) {
++FANG;
for (; sta[sttop] != y; sttop--) {
T[FANG].push_back(sta[sttop]);
T[sta[sttop]].push_back(FANG);
}
sttop--;
T[FANG].push_back(y);
T[y].push_back(FANG);
T[FANG].push_back(x);
T[x].push_back(FANG);
}
} else
low[x] = min(low[x], dfn[y]);
}
}
void dfs(int x, int F) {
si_ze[x] = 1;
for (int i = 0, y = T[x][0], End = T[x].size(); i < End; y = T[x][++i]) {
if (y == F) continue;
dep[y] = dep[fa[y] = x] + 1;
dfs(y, x);
si_ze[x] += si_ze[y];
if (si_ze[y] > si_ze[son[x]]) son[x] = y;
}
}
void dfs(int x, int F, int Top) {
b[id[x] = ++dfs_clock] = a[x];
top[x] = Top;
if (!son[x]) return;
dfs(son[x], x, Top);
for (int i = 0, y = T[x][0], End = T[x].size(); i < End; y = T[x][++i]) {
if (y == F || y == son[x]) continue;
dfs(y, x, y);
}
}
void build(int p, int l, int r) {
st[p].l = l;
st[p].r = r;
if (l == r) return void(st[p].minn = b[l]);
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
st[p].minn = min(st[p << 1].minn, st[p << 1 | 1].minn);
}
int ask(int p, int l, int r) {
if (l <= st[p].l && st[p].r <= r) return st[p].minn;
int mid = (st[p].l + st[p].r) >> 1, temp = 0x3f3f3f3f;
if (l <= mid) temp = min(temp, ask(p << 1, l, r));
if (mid < r) temp = min(temp, ask(p << 1 | 1, l, r));
return temp;
}
void change(int p, int pos, int x) {
if (st[p].l == st[p].r) return void(st[p].minn = x);
int mid = (st[p].l + st[p].r) >> 1;
if (pos <= mid)
change(p << 1, pos, x);
else
change(p << 1 | 1, pos, x);
st[p].minn = min(st[p << 1].minn, st[p << 1 | 1].minn);
}
int ask(int x, int y) {
int temp = 0x3f3f3f3f;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
temp = min(temp, ask(1, id[top[x]], id[x]));
x = fa[top[x]];
}
if (dep[x] > dep[y]) swap(x, y);
if (x > n) temp = min(temp, a[fa[x]]);
return min(temp, ask(1, id[x], id[y]));
}
int main() {
FANG = n = read();
m = read();
q = read();
dfs_clock = 0;
memset(a, 0x3f, sizeof a);
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
X[i] = x;
Y[i] = y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(1), sttop = 0;
dfs_clock = 0;
for (int i = 1; i <= FANG; i++)
if (!si_ze[i]) {
dfs(i, 0);
dfs(i, 0, i);
}
build(1, 1, FANG);
for (int x = 1; x <= n; x++) {
w[fa[x]].insert(a[x]);
change(1, id[fa[x]], *w[fa[x]].begin());
}
while (q-- > 0) {
scanf("%s", opt + 1);
if (opt[1] == 'A')
printf("%d\n", ask(read(), read()));
else {
int x = read(), z = read();
change(1, id[x], z);
multiset<int>::iterator it = w[fa[x]].find(a[x]);
w[fa[x]].erase(it);
w[fa[x]].insert(z);
change(1, id[fa[x]], *w[fa[x]].begin());
a[x] = z;
}
}
return 0;
}
| 12 |
#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 = 100000;
const double eps = 1e-9;
const double MYPI = acos(-1.0);
typedef struct E {
double ang;
int delta;
} E;
bool operator<(const E &p, const E &q) { return p.ang < q.ang; }
long long sx, sy, v, tmx;
int n;
E e[2 * MAXN];
int ne, e0;
bool covered;
void addevent(double a, int delta) {
if (a < eps) a += 2 * MYPI, e0 += delta;
if (a > 2 * MYPI + eps) a -= 2 * MYPI, e0 -= delta;
e[ne].ang = a, e[ne].delta = delta, ++ne;
}
void run() {
scanf("%lld%lld%lld%lld%d", &sx, &sy, &v, &tmx, &n);
ne = 0;
covered = false;
e0 = 0;
for (int i = (0); i < (n); ++i) {
long long x, y, r;
scanf("%lld%lld%lld", &x, &y, &r);
long long dx = x - sx, dy = y - sy;
if (dx * dx + dy * dy <= r * r) {
covered = true;
continue;
}
if (dx * dx + dy * dy - r * r <= 1.0 * v * tmx * v * tmx) {
double a = atan2(dy, dx), da = asin(r / sqrt(1.0 * dx * dx + dy * dy));
if (!(da >= -10 && da <= 10))
printf("err %lld %lld %lld (%lld %lld %lld %lld)\n", x, y, r, sx, sy, v,
tmx);
addevent(a - da, +1), addevent(a + da, -1);
} else if (dx * dx + dy * dy < 1.0 * (r + v * tmx) * (r + v * tmx)) {
double z = 0.5 * (v * tmx * v * tmx - r * r + dx * dx + dy * dy) /
sqrt(1.0 * dx * dx + dy * dy);
double a = atan2(dy, dx), da = acos(z / v / tmx);
addevent(a - da, +1), addevent(a + da, -1);
if (!(da >= -10 && da <= 10))
printf("err %lld %lld %lld (%lld %lld %lld %lld)\n", x, y, r, sx, sy, v,
tmx);
}
}
sort(e, e + ne);
int cur = e0;
double ret = 0;
for (int i = (0); i <= (ne); ++i) {
double pa = i == 0 ? 0 : e[i - 1].ang, na = i == ne ? 2 * MYPI : e[i].ang;
if (cur > 0) ret += na - pa;
cur += e[i].delta;
}
ret /= 2 * MYPI;
printf("%.9lf\n", covered ? 1.0 : ret);
}
int main() {
run();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x;
cin >> n;
set<int> s;
for (long long int i = 0; i < n; i++) cin >> x, s.insert(x);
if (s.size() > 3) {
cout << -1;
return 0;
}
int a = *s.begin(), b, c;
for (auto p : s) b = p;
if ((a + b) % 2 == 1 and s.size() == 3) {
cout << -1;
return 0;
}
if ((a + b) % 2 == 1 and s.size() == 2) {
cout << b - a;
return 0;
}
c = (a + b) / 2;
bool flag = true;
for (auto p : s) {
if (!(p == a || p == b || p == c)) flag = false;
}
if (flag == false)
cout << -1;
else {
if (s.size() == 1) cout << 0;
if (s.size() == 2) cout << (b - a) / 2;
if (s.size() == 3) cout << c - a;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y, z, k;
cin >> x >> y >> z;
if (z == 0) {
if (x > y)
cout << "+" << endl;
else if (y > x)
cout << "-" << endl;
else
cout << 0 << endl;
} else {
if (x > y) {
if ((x - y) > z) {
cout << "+" << endl;
} else
cout << "?" << endl;
} else if (x < y) {
if ((y - x) > z) {
cout << "-" << endl;
} else
cout << "?" << endl;
} else
cout << "?" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int walk[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
struct ARROW {
int x0, y0, x1, y1;
ARROW *to[55];
long long dis[55];
int dir() { return x0 < x1 ? 0 : y0 < y1 ? 1 : x0 > x1 ? 2 : 3; }
};
inline bool xl(ARROW *a, ARROW *b) {
return max(a->x0, a->x1) < max(b->x0, b->x1);
}
inline bool xg(ARROW *a, ARROW *b) {
return min(a->x0, a->x1) > min(b->x0, b->x1);
}
inline bool yl(ARROW *a, ARROW *b) {
return max(a->y0, a->y1) < max(b->y0, b->y1);
}
inline bool yg(ARROW *a, ARROW *b) {
return min(a->y0, a->y1) > min(b->y0, b->y1);
}
int N, B, Q;
long long T[maxn];
ARROW A[maxn], *S[maxn];
void Init(bool (*cmp)(ARROW *, ARROW *), int dir, int ARROW::*y0,
int ARROW::*y1) {
for (int i = 1; i <= N + Q; i++) S[i] = A + N + Q - i + 1;
stable_sort(S + 1, S + N + Q + 1, cmp);
multimap<int, ARROW *> F;
typedef multimap<int, ARROW *>::iterator it;
for (int i = 1; i <= N + Q; i++) {
if (S[i] - A <= N) {
it lo = F.lower_bound(min(S[i]->*y0, S[i]->*y1));
it hi = F.upper_bound(max(S[i]->*y0, S[i]->*y1));
for (it j = lo; j != hi; j++) {
j->second->to[0] = S[i];
j->second->dis[0] =
abs(j->second->x1 - S[i]->x1) + abs(j->second->y1 - S[i]->y1);
}
F.erase(lo, hi);
}
if (S[i]->dir() == dir) F.insert(make_pair(S[i]->*y0, S[i]));
}
}
int main() {
scanf("%d%d", &N, &B);
for (int i = 1; i <= N; i++)
scanf("%d%d%d%d", &A[i].x0, &A[i].y0, &A[i].x1, &A[i].y1);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
char dir;
scanf("%d%d %c%I64d", &A[i + N].x0, &A[i + N].y0, &dir, &T[i]);
A[i + N].x1 = A[i + N].x0, A[i + N].y1 = A[i + N].y0;
switch (dir) {
case 'R':
A[i + N].x0--;
break;
case 'L':
A[i + N].x0++;
break;
case 'U':
A[i + N].y0--;
break;
case 'D':
A[i + N].y0++;
}
}
Init(xl, 0, &ARROW::y0, &ARROW::y1);
Init(xg, 2, &ARROW::y0, &ARROW::y1);
Init(yl, 1, &ARROW::x0, &ARROW::x1);
Init(yg, 3, &ARROW::x0, &ARROW::x1);
for (int k = 1; k < 50; k++)
for (ARROW *i = A + 1; i <= A + N + Q; i++)
if (i->to[k - 1] && i->to[k - 1]->to[k - 1]) {
i->to[k] = i->to[k - 1]->to[k - 1];
i->dis[k] = i->dis[k - 1] + i->to[k - 1]->dis[k - 1];
}
for (int i = 1; i <= Q; i++) {
ARROW *now = A + i + N;
long long t = T[i];
for (int k = (t ? 63 - __builtin_clzll(t) : -1); k >= 0; k--)
if (now->to[k] && now->dis[k] <= t) t -= now->dis[k], now = now->to[k];
int x = now->x1, y = now->y1, dir = now->dir();
if (now->to[0]) {
int half;
if (now->x0 == now->x1) {
half = max(0, min((now->to[0]->y0 - now->y1) / walk[dir][1],
(now->to[0]->y1 - now->y1) / walk[dir][1]));
if (half <= t)
t -= half, y += walk[dir][1] * half, dir = now->to[0]->dir();
} else {
half = max(0, min((now->to[0]->x0 - now->x1) / walk[dir][0],
(now->to[0]->x1 - now->x1) / walk[dir][0]));
if (half <= t)
t -= half, x += walk[dir][0] * half, dir = now->to[0]->dir();
}
}
x = min<long long>(B, max(0ll, x + walk[dir][0] * t));
y = min<long long>(B, max(0ll, y + walk[dir][1] * t));
printf("%d %d\n", x, y);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int tree[800005];
int lazy[800005];
int arr[200005];
int final[200005];
void updateRangeUtil(int si, int ss, int se, int us, int ue, int diff) {
if (lazy[si] != 0) {
tree[si] += (se - ss + 1) * lazy[si];
if (ss != se) {
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
}
lazy[si] = 0;
}
if (ss > se || ss > ue || se < us) return;
if (ss >= us && se <= ue) {
tree[si] += (se - ss + 1) * diff;
if (ss != se) {
lazy[si * 2 + 1] += diff;
lazy[si * 2 + 2] += diff;
}
return;
}
int mid = (ss + se) / 2;
updateRangeUtil(si * 2 + 1, ss, mid, us, ue, diff);
updateRangeUtil(si * 2 + 2, mid + 1, se, us, ue, diff);
tree[si] = tree[si * 2 + 1] + tree[si * 2 + 2];
}
void updateRange(int n, int us, int ue, int diff) {
updateRangeUtil(0, 0, n - 1, us, ue, diff);
}
int getSumUtil(int ss, int se, int qs, int qe, int si) {
if (lazy[si] != 0) {
tree[si] += (se - ss + 1) * lazy[si];
if (ss != se) {
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
}
lazy[si] = 0;
}
if (ss > se || ss > qe || se < qs) return 0;
if (ss >= qs && se <= qe) return tree[si];
int mid = (ss + se) / 2;
return getSumUtil(ss, mid, qs, qe, 2 * si + 1) +
getSumUtil(mid + 1, se, qs, qe, 2 * si + 2);
}
int getSum(int n, int qs, int qe) {
if (qs < 0 || qe > n - 1 || qs > qe) {
return -1;
}
return getSumUtil(0, n - 1, qs, qe, 0);
}
void constructSTUtil(int arr[], int ss, int se, int si) {
if (ss > se) return;
if (ss == se) {
tree[si] = arr[ss];
return;
}
int mid = (ss + se) / 2;
constructSTUtil(arr, ss, mid, si * 2 + 1);
constructSTUtil(arr, mid + 1, se, si * 2 + 2);
tree[si] = tree[si * 2 + 1] + tree[si * 2 + 2];
}
void constructST(int arr[], int n) { constructSTUtil(arr, 0, n - 1, 0); }
int main() {
long long l, r, n, k, q, i, a, b, haha;
haha = 0;
cin >> n >> k >> q;
for (i = 0; i < 200005; i++) arr[i] = 0;
constructST(arr, 200005);
for (i = 0; i < n; i++) {
cin >> l >> r;
updateRange(200005, l, r, 1);
}
for (i = 0; i < 200005; i++) {
if (getSum(200005, i, i) >= k) {
haha += 1;
}
final[i] = haha;
}
while (q--) {
cin >> a >> b;
cout << final[b] - final[a - 1] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 18;
vector<int> adj[maxn];
bool vis[maxn];
int fa[maxn], dep[maxn], n, m, k;
vector<vector<int>> cycles;
void dfs(int u, int d) {
vis[u] = true;
if ((dep[u] = d) > (n - 1) / k) {
cout << "PATH\n" << d << '\n' << u;
for (int i = fa[u]; i; i = fa[i]) cout << ' ' << i;
cout << '\n';
exit(0);
}
bool flag = true;
for (auto v : adj[u])
if (!vis[v]) {
fa[v] = u;
dfs(v, d + 1);
flag = false;
}
while (flag) {
int index = 0;
if (adj[u][index] == fa[u]) ++index;
int x = adj[u][index++];
if (adj[u][index] == fa[u]) ++index;
int y = adj[u][index];
vector<int> loop(1, u);
while (loop.back() ^ x) loop.push_back(fa[loop.back()]);
if (loop.size() % 3) {
cycles.push_back(loop);
break;
}
loop = vector<int>(1, u);
while (loop.back() ^ y) loop.push_back(fa[loop.back()]);
if (loop.size() % 3) {
cycles.push_back(loop);
break;
}
loop = vector<int>(1, u);
if (dep[x] < dep[y]) swap(x, y);
loop.push_back(x);
while (loop.back() ^ y) loop.push_back(fa[loop.back()]);
cycles.push_back(loop);
break;
}
if (cycles.size() == k) {
cout << "CYCLES\n";
for (auto& loop : cycles) {
cout << loop.size() << '\n' << loop.front();
for (int i = 1; i ^ loop.size(); ++i) cout << ' ' << loop[i];
cout << '\n';
}
exit(0);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> k;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double a[100010], y;
int n, k, st;
double tag;
double dis(int pos) {
return sqrt((a[pos] - a[n + 1]) * (a[pos] - a[n + 1]) + y * y);
}
double calc1(int l, int r) { return a[r] - a[l] + min(dis(l), dis(r)); }
double calc2(int l, int r) {
return a[r] - a[l] +
min(dis(l) + fabs(tag - a[r]), dis(r) + fabs(tag - a[l]));
}
int main() {
scanf("%d%d", &n, &st);
for (int i = 1; i <= n + 1; i++) scanf("%lf", &a[i]);
scanf("%lf", &y);
tag = a[st];
sort(a + 1, a + n + 1);
if (st == n + 1)
printf("%.10lf\n", calc1(1, n));
else {
double ans = calc2(1, n);
for (int i = 1; i < n; i++) {
ans = min(ans, min(calc1(1, i) + calc2(i + 1, n),
calc2(1, i) + calc1(i + 1, n)));
}
printf("%.10lf\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
using namespace std;
long long vis[600][5000];
pair<long long, long long> par[600][5000];
void print(pair<long long, long long> p) {
if (p.first == 0 && p.second == 0) return;
print(par[p.first][p.second]);
cout << p.second - par[p.first][p.second].second;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long d, s;
cin >> d >> s;
memset(vis, 0, sizeof(vis));
queue<pair<long long, long long>> q;
q.push({0, 0});
vis[0][0] = 1;
bool ch = 0;
while (!q.empty()) {
pair<long long, long long> p = q.front();
long long rem = p.first;
long long sum = p.second;
q.pop();
if (rem == 0 && sum == s) {
print(p);
ch = 1;
break;
}
for (long long i = 0; i <= 9; i++) {
long long r = (rem * 10 + i) % d;
if (vis[r][sum + i] == 0 && sum + i <= s) {
q.push({r, sum + i});
vis[r][sum + i] = 1;
par[r][sum + i] = p;
}
}
}
if (!ch) cout << -1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int flag[110101], a[110101];
int main() {
a[1] = 1;
a[2] = 1;
for (int i = 2; i < 110101 - 1; i++) {
if (!flag[i])
for (int j = i; j < 110101 - 1; j += i) {
flag[j] = i;
}
int mid = 1;
for (int u = i; u > 1;) {
int cnt = 0, v = flag[u];
while (u % v == 0) u /= v, cnt++;
cnt = cnt + 1 >> 1;
mid *= power(v, cnt, 1000000007);
}
a[i + 1] = mid;
}
int n;
cin >> n;
cout << 2 << endl;
for (int i = 2; i <= n; i++) {
println((long long)a[i + 1] * a[i + 1] / i * (i + 1) * (i + 1) - a[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
int cnt = 0;
while (t > 0) {
int a;
cin >> a;
cnt++;
t -= (86400 - a);
}
cout << cnt;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2 * 1e9;
void add(int x, vector<int> &cycle) {
for (auto i : cycle) {
x = min(x, i ^ x);
}
if (x) {
cycle.push_back(x);
}
}
void dfs(int start, int sum, vector<bool> &used,
vector<vector<pair<int, int>>> &graph, vector<int> &dist,
vector<int> &cycle) {
used[start] = true;
dist[start] = sum;
for (auto elem : graph[start]) {
int w = elem.first, v = elem.second;
if (!used[v]) {
dfs(v, sum ^ w, used, graph, dist, cycle);
} else {
add(sum ^ dist[v] ^ w, cycle);
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, int>>> graph(n);
for (int i = 0; i < m; ++i) {
int a, b, w;
cin >> a >> b >> w;
--a;
--b;
graph[a].push_back({w, b});
graph[b].push_back({w, a});
}
vector<int> dist(n, INF), cycle;
vector<bool> used(n, false);
dist[0] = 0;
dfs(0, 0, used, graph, dist, cycle);
for (auto i : cycle) {
dist[n - 1] = min(dist[n - 1], (dist[n - 1] ^ i));
}
cout << dist[n - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int ans;
long long int n, x, y;
void solve() {
multiset<int> e1;
cin >> n >> x >> y;
vector<pair<int, int> > l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
l.push_back(make_pair(a, b));
}
sort(l.begin(), l.end());
for (int i = 0; i < n; i++) {
long long int a, b;
b = (long long int)l[i].second;
a = (long long int)l[i].first;
auto c = e1.lower_bound(a);
if (c == e1.begin()) {
ans += (long long int)x + (long long int)y * (long long int)(b - a);
ans %= (long long int)1000000007;
} else {
c--;
int ma = *c;
ans += min((long long int)x + (long long int)y * (long long int)(b - a),
(long long int)y * (long long int)(b - ma));
ans %= (long long int)1000000007;
if ((long long int)y * (long long int)(b - ma) <
(long long int)x + (long long int)y * (long long int)(b - a)) {
e1.erase(e1.lower_bound(ma));
}
}
e1.insert(b);
}
cout << ans % (long long int)1000000007 << endl;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
int main(int argc, char* argv[]) {
int nNumberCount;
int nNumberC;
int nNumberArrays[110];
int nSumArrays[110];
int nMaxNumber = INT_MIN;
cin >> nNumberCount >> nNumberC;
for (int i = 1; i <= nNumberCount; i++) {
cin >> nNumberArrays[i];
nSumArrays[i - 1] = nNumberArrays[i - 1] - nNumberArrays[i];
}
for (int i = 1; i < nNumberCount; i++) {
nMaxNumber = max(nMaxNumber, nSumArrays[i]);
}
cout << max(nMaxNumber - nNumberC, 0) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
iostream::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
set<int> row, col;
char mat[n][m];
for (int i = 0; i < n; i++) cin >> mat[i];
for (long long i = (0); i < (n); ++i) {
for (long long j = (0); j < (n); ++j) {
long long cnt = 0, cnt1 = 0;
for (long long k = (0); k < (m); ++k) {
if (mat[i][k] == '#' && mat[j][k] == '#') cnt++;
if (mat[i][k] == '#') cnt1++;
}
if (cnt == 0 || cnt == cnt1)
continue;
else {
cout << "No";
exit(0);
}
}
}
cout << "Yes";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long pre[n];
long long prem[n];
long long suf[n];
long long sufm[n];
multiset<long long> m;
multiset<long long, greater<long long> > mm;
m.insert(a[0]);
mm.insert(a[0]);
pre[0] = LONG_LONG_MIN;
prem[0] = LONG_LONG_MAX;
for (long long i = 1; i < n; i++) {
pre[i] = max((*m.begin()) * a[i], (*mm.begin()) * a[i]);
prem[i] = min((*mm.begin()) * a[i], (*m.begin()) * a[i]);
pre[i] = max(pre[i], pre[i - 1]);
prem[i] = min(prem[i], prem[i - 1]);
m.insert(a[i]);
mm.insert(a[i]);
}
m.clear();
mm.clear();
m.insert(a[n - 1]);
mm.insert(a[n - 1]);
suf[n - 1] = LONG_LONG_MIN;
sufm[n - 1] = LONG_LONG_MAX;
for (long long i = n - 2; i >= 0; i--) {
suf[i] = max((*m.begin()) * a[i], (*mm.begin()) * a[i]);
sufm[i] = min((*mm.begin()) * a[i], (*m.begin()) * a[i]);
suf[i] = max(suf[i], suf[i + 1]);
sufm[i] = min(sufm[i], sufm[i + 1]);
m.insert(a[i]);
mm.insert(a[i]);
}
long long ans = LONG_LONG_MIN;
for (long long i = 2; i < n - 2; i++) {
ans = max(ans, pre[i - 1] * a[i] * suf[i + 1]);
ans = max(ans, pre[i - 1] * a[i] * sufm[i + 1]);
ans = max(ans, prem[i - 1] * a[i] * suf[i + 1]);
ans = max(ans, prem[i - 1] * a[i] * sufm[i + 1]);
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const long long mod = 1e9 + 7;
long long n, a[200010], prime[2000010], cnt[2000010], pre, ans = 1,
used[2000010];
bool unpri[2000010], tag[2000010];
inline bool cmp1(int x, int y) { return x > y; }
inline void Eular(int N) {
for (int i = 2; i <= N; i++) {
if (!unpri[i]) prime[++prime[0]] = i;
for (int j = 1; j <= prime[0] && i * prime[j] <= N; j++) {
unpri[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
return;
}
inline bool work(long long x) {
int tmp, fail = 1;
for (int i = 1; i <= prime[0]; i++) {
if (prime[i] * prime[i] > x) break;
tmp = 0;
while (x % prime[i] == 0) tmp++, x /= prime[i];
if (tmp > cnt[prime[i]])
fail = 0, cnt[prime[i]] = tmp, used[prime[i]] = 1;
else if (tmp == cnt[prime[i]])
used[prime[i]]++;
}
if (!cnt[x])
fail = 0, cnt[x] = 1, used[x] = 1;
else if (cnt[x] == 1)
used[x]++;
return fail;
}
inline bool check(long long x) {
int tmp, fail = 1;
for (int i = 1; i <= prime[0]; i++) {
if (prime[i] * prime[i] > x) break;
tmp = 0;
while (x % prime[i] == 0) tmp++, x /= prime[i];
if (tmp == cnt[prime[i]] && used[prime[i]] == 1) fail = 0;
}
if (cnt[x] == 1 && used[x] == 1) fail = 0;
return fail;
}
inline long long qpow(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
k >>= 1;
}
return res;
}
int main() {
n = read();
Eular(2000000);
cnt[1] = 1;
for (int i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1, cmp1);
for (int i = 1; i <= n; i++) {
if (!cnt[a[i]])
cnt[a[i]]++;
else {
tag[i] = 1;
if (work(a[i] - 1)) pre = 1;
}
}
for (int i = 1; i <= n; i++)
if (tag[i])
if (check(a[i] - 1)) pre = 1;
for (int i = 2; i <= 2000000; i++) ans = ans * qpow(i, cnt[i]) % mod;
cout << (ans + pre) % mod << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
const long long M = 1000000007;
long long A[6] = {4, 8, 15, 16, 23, 42};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long B[6];
long long C[4];
for (long long i = 1; i < 5; i++) {
cout << "? " << i << " " << i + 1 << endl;
cin >> C[i - 1];
}
for (long long i = 0; i < 6; i++)
for (long long j = 0; j < 6; j++)
for (long long k = 0; k < 6; k++) {
if (i != j && j != k && k != i) {
if (C[1] == A[i] * A[j] && C[0] == A[i] * A[k]) B[1] = A[i];
if (C[2] == A[i] * A[j] && C[1] == A[i] * A[k]) B[2] = A[i];
if (C[3] == A[i] * A[j] && C[2] == A[i] * A[k]) B[3] = A[i];
}
}
B[0] = C[0] / B[1];
B[4] = C[3] / B[3];
bool f = 0;
for (long long i = 0; i < 6; i++) {
f = 0;
for (long long j = 0; j < 5; j++) {
if (A[i] == B[j]) f = 1;
}
if (!f) B[5] = A[i];
}
cout << "! ";
for (long long i = 0; i < 6; i++) cout << B[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
struct LiChao_segment_tree {
inline long long f(long long k, int x, long long b) { return k * x + b; }
long long k[maxn << 2], b[maxn << 2];
int lz[maxn << 2];
int N;
void init(int n) {
N = n;
lz[1] = 1;
k[1] = b[1] = 0;
}
inline void down(int rt) {
if (!lz[rt]) return;
lz[rt << 1] = lz[rt << 1 | 1] = 1;
k[rt << 1] = k[rt << 1 | 1] = b[rt << 1] = b[rt << 1 | 1] = 0;
lz[rt] = 0;
return;
}
void update(int rt, int l, int r, long long ck, long long cb) {
if (f(ck, ((l + r) >> 1), cb) > f(k[rt], ((l + r) >> 1), b[rt]))
swap(k[rt], ck), swap(b[rt], cb);
if (l == r) return;
down(rt);
if (ck > k[rt])
update(rt << 1 | 1, ((l + r) >> 1) + 1, r, ck, cb);
else
update(rt << 1, l, ((l + r) >> 1), ck, cb);
}
long long qry(int rt, int l, int r, int x) {
long long ans = f(k[rt], x, b[rt]);
if (l == r) return ans;
down(rt);
if (x <= ((l + r) >> 1))
ans = max(ans, qry(rt << 1, l, ((l + r) >> 1), x));
else
ans = max(ans, qry(rt << 1 | 1, ((l + r) >> 1) + 1, r, x));
return ans;
}
} T;
vector<int> g[maxn];
int sz[maxn], ms[maxn], vis[maxn], totsz;
long long a[maxn];
int n, rt;
long long ans = 0;
void get_rt(int u, int fa) {
sz[u] = 1;
ms[u] = 0;
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
get_rt(v, u);
sz[u] += sz[v];
ms[u] = max(ms[u], sz[v]);
}
ms[u] = max(ms[u], totsz - sz[u]);
if (ms[rt] > ms[u]) rt = u;
}
void init() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) scanf("%I64d", &a[i]);
totsz = n;
}
void qry(int u, int fa, long long sum, long long xsum, int d) {
int f = 0;
d++;
sum += a[u];
xsum += sum;
for (int v : g[u]) {
if (vis[v] || v == fa) continue;
f = 1;
qry(v, u, sum, xsum, d);
}
if (f) return;
ans = max(ans, xsum + T.qry(1, 1, T.N, d));
}
void update(int u, int fa, long long sum, long long xsum, int d) {
d++;
sum += a[u];
xsum += d * a[u];
int f = 0;
for (int v : g[u]) {
if (vis[v] || v == fa) continue;
f = 1;
update(v, u, sum, xsum, d);
}
if (f) return;
T.update(1, 1, T.N, sum, xsum);
}
void cal(int u) {
T.init(n + 15);
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (vis[v]) continue;
qry(v, u, a[u], a[u], 1);
update(v, u, 0, 0, 0);
}
ans = max(ans, a[u] + T.qry(1, 1, T.N, 1));
T.init(n + 15);
for (int i = g[u].size() - 1; i >= 0; --i) {
int v = g[u][i];
if (vis[v]) continue;
qry(v, u, a[u], a[u], 1);
update(v, u, 0, 0, 0);
}
}
void dfs(int u, int fa) {
sz[u] = 1;
for (int v : g[u]) {
if (v == fa || vis[v]) continue;
dfs(v, u);
sz[u] += sz[v];
}
return;
}
void gao(int u) {
vis[u] = 1;
cal(u);
for (int v : g[u]) {
if (vis[v]) continue;
totsz = sz[v];
rt = 0;
get_rt(v, 0);
gao(rt);
}
}
void sol() {
rt = 0;
ms[rt] = n + 1;
get_rt(1, 0);
gao(rt);
cout << ans << endl;
}
int main() {
init();
sol();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int big = ((int)1 << 30);
int timecount = 0;
int main(void) {
long long int N, M, i, j, x, y, p, q, w, e, ans;
cin >> N;
for (; N > 0; N--) {
ans = 0;
cin >> x >> y >> p >> q;
if ((x != 0 && p == 0) || (x != y && p == 1 && q == 1)) {
cout << -1 << endl;
continue;
}
if ((x == 0 && p == 0) || (x == y && p == q)) {
cout << 0 << endl;
continue;
}
i = max(max((x + p - 1) / p, (y + q - 1) / q),
(y - x + q - p - 1) / (q - p));
cout << q * i - y << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long double EPS = 0.000000001;
const long long INF64 = 1000000000000000000;
const long long INF32 = 2000000000;
bool iss_pt_in_triangle(pair<long long, long long> a,
pair<long long, long long> b,
pair<long long, long long> c,
pair<long long, long long> point) {
long long x1 = a.first, x2 = b.first, x3 = c.first, x0 = point.first;
long long y1 = a.second, y2 = b.second, y3 = c.second, y0 = point.second;
long long aa = (x1 - x0) * (y2 - y1) - (x2 - x1) * (y1 - y0);
long long bb = (x2 - x0) * (y3 - y2) - (x3 - x2) * (y2 - y0);
long long cc = (x3 - x0) * (y1 - y3) - (x1 - x3) * (y3 - y0);
if (aa == 0 || bb == 0 || cc == 0) return 1;
if (aa >= 0 && bb >= 0 && cc >= 0) return 1;
if (aa <= 0 && bb <= 0 && cc <= 0) return 1;
return 0;
}
bool iss_ll(long long &__1, long long &__2) { return INF64 / __1 >= __2; }
bool iss_sqr(long long &__1) {
long long __2 = sqrt((long double)__1);
return __2 * __2 == __1;
};
bool iss_prime(long long __1) {
for (long long i = 2; i * i <= __1; ++i)
if (!(__1 % i)) return 0;
return 1;
}
long long gcd(long long __1, long long __2) {
while (__1 && __2)
if (__1 > __2)
__1 = __1 % __2;
else
__2 = __2 % __1;
return __1 + __2;
}
long long lcm(long long &__1, long long &__2) {
return __1 * __2 / (gcd(__1, __2));
}
bool iss_cube(long long x) {
if (x == 0) return 1;
long long l = 0, r = 2e6;
while (l + 1 < r) {
long long m = (l + r) / 2;
if (m * m * m > x)
r = m;
else
l = m;
}
return l * l * l == x;
}
long long sq_cube(long long x) {
if (x == 0) return 1;
long long l = 0, r = 1.3e6;
while (l + 1 < r) {
long long m = (l + r) / 2;
if (m * m * m > x)
r = m;
else
l = m;
}
return l;
}
long long arr[100100];
map<long long, long long> CNT;
set<long long> SET;
map<long long, bool> ISS;
map<long long, long long> MAP;
long long MODE = 998244353;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = 1;
for (long long i = 1; i <= n; ++i) {
long long x;
cin >> x;
CNT[x]++;
if (iss_cube(x)) SET.insert(sq_cube(x));
if (iss_sqr(x)) {
ISS[x] = 1;
long long y = sqrt((long double)x);
for (long long j = 2; j * j <= y; ++j) {
while (y % j == 0) {
y /= j;
SET.insert(j);
}
}
if (y > 1) SET.insert(y);
}
}
for (auto i : CNT) {
for (auto j : CNT) {
if (i != j) {
if (gcd(i.first, j.first) > 1 && !ISS[i.first] && !ISS[j.first]) {
SET.insert(gcd(i.first, j.first));
}
}
}
}
for (auto i : CNT) {
long long x = i.first;
bool iss = 0;
for (long long j : SET) {
while (x % j == 0) {
MAP[j] += i.second;
x /= j;
iss = 1;
}
}
if (iss) {
if (x > 1) MAP[x] += i.second;
} else {
ans *= (i.second + 1);
ans %= MODE;
ans *= (i.second + 1);
ans %= MODE;
}
}
for (auto i : MAP) {
ans *= (i.second + 1);
ans %= MODE;
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n;
int m;
char op[20];
int mem[1000];
int r;
int i;
int j;
int k;
int num;
int flag;
int count;
while (scanf("%d%d", &n, &m) != EOF) {
num = 1;
memset(mem, 0, sizeof(mem));
while (n--) {
scanf("%s", op);
if (op[0] != 'd') {
scanf("%d", &r);
}
if (op[0] == 'a') {
k = 0;
while (mem[k] != 0) {
k++;
}
count = 0;
flag = 0;
for (i = k; i < m; i++) {
if (mem[i] != 0) {
if (count >= r) {
k = i - count + 1;
flag = 1;
break;
}
count = 0;
} else {
count++;
}
if (count >= r) {
k = i - count + 1;
flag = 1;
break;
}
}
if (flag == 1) {
for (i = k; i < k + r; i++) {
mem[i] = num;
}
printf("%d\n", num);
num++;
} else {
printf("NULL\n");
}
} else if (op[0] == 'e') {
flag = 0;
for (i = 0; i < m; i++) {
if (mem[i] == r) {
mem[i] = 0;
flag = 1;
}
}
if (flag != 1 || r == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else if (op[0] == 'd') {
k = 0;
while (mem[k]) {
k++;
}
j = k;
for (i = k; i < m; i++) {
if (mem[i] != 0) {
mem[j] = mem[i];
mem[i] = 0;
j++;
}
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long a[N], c[N];
pair<long long, long long> g[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int s, b;
cin >> s >> b;
for (int i = 0; i < s; i++) cin >> a[i];
for (int i = 0; i < b; i++) cin >> g[i].first >> g[i].second;
sort(g, g + b);
for (int i = 1; i < b; i++) g[i].second = g[i].second + g[i - 1].second;
for (int i = 0; i < b; i++) c[i] = g[i].first;
for (int i = 0; i < s; i++) {
int ind = upper_bound(c, c + b, a[i]) - c - 1;
if (ind == -1)
cout << 0;
else
cout << g[ind].second;
cout << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const long long INF = (1LL << 61);
const int inf = (1 << 30), nn = 2e5 + 5;
int fir[nn], last[nn], a[nn];
int seg[4 * nn];
void build(int n, int s, int e) {
if (s == e) {
seg[n] = a[s];
return;
}
int mid = (s + e) / 2;
build(2 * n, s, mid);
build(2 * n + 1, mid + 1, e);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
int query(int n, int s, int e, int l, int r) {
if (s > r || e < l)
return inf;
else if (s >= l && e <= r)
return seg[n];
else {
int mid = (s + e) / 2;
return min(query(2 * n, s, mid, l, r), query(2 * n + 1, mid + 1, e, l, r));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
bool isq = 0, is0 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == q) isq = 1;
if (!a[i]) is0 = 1;
}
if (!isq && !is0) {
cout << "NO";
return 0;
} else if (!isq && is0) {
for (int i = 0; i < n; i++) {
if (!a[i]) {
a[i] = q;
break;
}
}
}
for (int i = 0; i < n; i++) {
if (!a[i]) {
if (i)
a[i] = a[i - 1];
else {
int j;
for (j = 0; j < n && !a[j]; j++)
;
a[0] = a[j];
}
}
}
build(1, 0, n - 1);
fill(fir, fir + nn, -1);
fill(last, last + nn, -1);
for (int i = 0; i < n; i++) {
if (fir[a[i]] == -1) {
fir[a[i]] = i;
last[a[i]] = i;
} else
last[a[i]] = i;
}
for (int i = 1; i <= q; i++) {
int l = fir[i], r = last[i];
int minn = query(1, 0, n - 1, l, r);
if (minn < i) {
cout << "NO";
return 0;
}
}
cout << "YES" << '\n';
for (int i = 0; i < n; i++) cout << a[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, x1, y1, z1, a[7], i, ans = 0;
cin >> x >> y >> z >> x1 >> y1 >> z1;
for (i = 0; i < 6; i++) cin >> a[i + 1];
if (y < 0) ans += a[1];
if (y > y1) ans += a[2];
if (z < 0) ans += a[3];
if (z > z1) ans += a[4];
if (x < 0) ans += a[5];
if (x > x1) ans += a[6];
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
long long tmp1[n], i, tmp2[n / 2];
for (long long i = 0; i < n / 2; i++) cin >> tmp2[i];
long long f = INT_MIN, l = INT_MAX;
for (long long i = 0; i < n / 2; i++) {
if (f == INT_MIN) {
f = 0;
tmp1[i] = 0;
tmp1[n - 1 - i] = tmp2[i] - tmp1[i];
l = tmp1[n - 1 - i];
} else {
if (tmp2[i] - f <= l) {
tmp1[i] = f;
tmp1[n - 1 - i] = tmp2[i] - f;
l = tmp1[n - 1 - i];
} else if (tmp2[i] - l >= f) {
tmp1[n - 1 - i] = l;
tmp1[i] = tmp2[i] - l;
f = tmp1[i];
}
}
}
for (long long i = 0; i < n; i++) cout << tmp1[i] << " ";
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, ans, prev = 100000000000;
long long int a[30], n;
ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
if (prev == 0) {
prev = 0;
continue;
}
if (prev <= a[i]) {
a[i] = prev - 1;
}
ans = ans + a[i];
prev = a[i];
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10004;
long long c, p[N], s[N], a[N], b[N], *p1, *p2, ans;
int n;
void solve() {
if (n == 1) {
ans = min(p[1], s[1]);
return;
}
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
a[0] = p[1];
a[1] = s[1];
p1 = a;
p2 = b;
int sz = sizeof(a);
for (int i = 2; i <= n; ++i) {
p2[0] = p1[0] + p[i];
p2[i] = p1[i - 1] + s[i];
for (int j = 1; j < i; ++j)
p2[j] = min(p1[j - 1] + s[i], p1[j] + p[i] + j * c);
swap(p1, p2);
memset(p2, 0, sz);
}
ans = 9e18;
for (int i = 0; i <= n; ++i) ans = min(ans, p1[i]);
}
int main() {
scanf("%d%I64d", &n, &c);
for (int i = 1; i <= n; ++i) scanf("%I64d", p + i);
for (int i = 1; i <= n; ++i) scanf("%I64d", s + i);
solve();
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
bool operator<(const node &a) const {
if (l == a.l) return r < a.r;
return l < a.l;
}
} e[100010];
multiset<int> p;
multiset<int>::iterator it;
int main() {
int i, j, k, n;
long long x, y, s;
scanf("%d%lld%lld", &n, &x, &y);
for (i = 0; i < n; i++) scanf("%d%d", &e[i].l, &e[i].r);
sort(e, e + n);
s = 0;
for (i = 0; i < n; i++) {
it = p.lower_bound(e[i].l);
if (!p.empty() && (it--) != p.begin() && y * (e[i].l - *it) < x) {
s = (s + y * (e[i].r - *it)) % 1000000007;
p.erase(it);
p.insert(e[i].r);
} else {
s = (s + x + y * (e[i].r - e[i].l)) % 1000000007;
p.insert(e[i].r);
}
}
printf("%lld\n", s);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 8;
const int MAXR = 1;
const int MAXC = 1;
const int MAXBITS = 64;
const int INF = (int)1e9;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
priority_queue<int, vector<int>, greater<int>> q1;
priority_queue<int, vector<int>, less<int>> q2;
void l() { ; }
int arr[MAXN];
bool ip(int x, int y, int z, int l) {
if (l < 3) return true;
if (l % 3 == 0) {
if (x == y && y == z) return true;
return false;
}
if (l % 3 == 1) {
if (x == y && z == x + 1) return true;
if (y == z && x == z + 1) return true;
if (x == z && y == x + 1) return true;
return false;
}
if (l % 3 == 2) {
if (x == y && z == x - 1) return true;
if (y == z && x == z - 1) return true;
if (x == z && y == x - 1) return true;
return false;
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
vector<vector<int>> pcnt(3, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
if (i > 0) {
for (int j = 0; j < 3; ++j) {
pcnt[j][i] = pcnt[j][i - 1];
}
}
if (s[i] == 'x')
pcnt[0][i]++;
else if (s[i] == 'y')
pcnt[1][i]++;
else
pcnt[2][i]++;
}
int m;
cin >> m;
int x, y;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
x--;
y--;
int nx = x > 0 ? pcnt[0][y] - pcnt[0][x - 1] : pcnt[0][y];
int ny = x > 0 ? pcnt[1][y] - pcnt[1][x - 1] : pcnt[1][y];
int nz = x > 0 ? pcnt[2][y] - pcnt[2][x - 1] : pcnt[2][y];
;
int poss = ip(nx, ny, nz, y - x + 1);
if (poss) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
vector<pair<int, long long> > g[N];
long long dp[N];
long long w[N];
long long ans = 0;
void dfs(int u, int f) {
dp[u] = w[u];
ans = max(ans, dp[u]);
for (auto v : g[u]) {
if (v.first == f) continue;
dfs(v.first, u);
ans = max(ans, dp[u] + dp[v.first] - v.second);
dp[u] = max(dp[u], dp[v.first] + w[u] - v.second);
}
}
int main() {
int n, x, y, c;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &c);
g[x].push_back({y, c});
g[y].push_back({x, c});
}
dfs(1, 0);
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, k, bonus[30][30], f[105][30][105], ans;
string s;
int main() {
cin >> s >> k >> n;
for (int i = 1; i <= n; i++) {
char a, b;
int c;
cin >> a >> b >> c;
bonus[a - 'a'][b - 'a'] = c;
}
for (int b = 0; b < s.length(); b++)
for (int i = 0; i < 26; i++)
for (int j = 0; j <= k; j++) f[b][i][j] = -inf;
for (int i = 0; i < 26; i++) f[0][i][(i == s[0] - 'a' ? 0 : 1)] = 0;
for (int i = 1; i < s.length(); i++)
for (int j = 0; j < 26; j++)
for (int p = 0; p <= min(i + 1, k); p++) {
if (j != s[i] - 'a' && p == 0) continue;
for (int r = 0; r < 26; r++)
f[i][j][p] =
max(f[i][j][p],
f[i - 1][r][p - (j == s[i] - 'a' ? 0 : 1)] + bonus[r][j]);
}
ans = -inf;
for (int i = 0; i < 26; i++)
for (int j = 0; j <= k; j++) ans = max(ans, f[s.length() - 1][i][j]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int q[100000];
int qtable[9][9];
int x_min[9];
int x_max[9];
int y_min[9];
int y_max[9];
int solve_problem() {
int n, m, k, s;
if (scanf("%d %d %d %d", &n, &m, &k, &s) != 4) return 1;
fill(x_min, x_min + k, numeric_limits<int>::max());
fill(x_max, x_max + k, numeric_limits<int>::min());
fill(y_min, y_min + k, numeric_limits<int>::max());
fill(y_max, y_max + k, numeric_limits<int>::min());
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int t;
if (scanf("%d", &t) != 1) return 1;
--t;
int x = i + j;
int y = i - j;
if (x < x_min[t]) x_min[t] = x;
if (x > x_max[t]) x_max[t] = x;
if (y < y_min[t]) y_min[t] = y;
if (y > y_max[t]) y_max[t] = y;
}
for (int i = 0; i < s; i++) {
if (scanf("%d", &q[i]) != 1) return 1;
--q[i];
}
for (int i = 1; i < s; i++) {
int prev = q[i - 1];
int next = q[i];
qtable[min(prev, next)][max(prev, next)] = 1;
}
int result = 0;
for (int i = 0; i < k; i++)
for (int j = i; j < k; j++)
if (qtable[i][j]) {
int cand = abs(x_min[i] - x_max[j]);
if (cand > result) result = cand;
cand = abs(x_max[i] - x_min[j]);
if (cand > result) result = cand;
cand = abs(y_min[i] - y_max[j]);
if (cand > result) result = cand;
cand = abs(y_max[i] - y_min[j]);
if (cand > result) result = cand;
}
printf("%d\n", result);
return 0;
}
int main() {
solve_problem();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, m, x, cnt, lr[maxn], lc[maxn], ans[maxn], tmp[maxn], L[maxn], R[maxn],
fa[maxn];
struct node {
int r, c, v, cnt, id;
} s[maxn];
bool cmp(node a, node b) { return a.v < b.v; }
int get(int x) { return (fa[x] == x) ? x : (fa[x] = get(fa[x])); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
s[++cnt].v = x, s[cnt].r = i, s[cnt].c = j, s[cnt].id = cnt,
fa[cnt] = cnt;
}
sort(s + 1, s + cnt + 1, cmp);
for (int i = 1, j = 0; i <= cnt; i = j) {
for (j = i + 1; s[j].v == s[i].v; j++)
;
for (int k = i; k < j; k++) {
if (!lr[s[k].r])
lr[s[k].r] = k;
else
fa[get(k)] = get(lr[s[k].r]);
if (!lc[s[k].c])
lc[s[k].c] = k;
else
fa[get(k)] = get(lc[s[k].c]);
}
for (int k = i; k < j; k++)
tmp[get(k)] = max(tmp[get(k)], max(L[s[k].r], R[s[k].c]) + 1);
for (int k = i; k < j; k++) {
lr[s[k].r] = lc[s[k].c] = 0;
ans[s[k].id] = tmp[get(k)];
L[s[k].r] = R[s[k].c] = ans[s[k].id];
}
}
for (int i = 1; i <= cnt; i++) {
printf("%d ", ans[i]);
if (i % m == 0) puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
queue<int> s1, s2;
map<queue<int>, int> p1, p2;
int n;
cin >> n;
int k1, k2, i, a, b;
cin >> k1;
for (i = 0; i < k1; i++) {
cin >> a;
s1.push(a);
}
cin >> k2;
for (i = 0; i < k2; i++) {
cin >> b;
s2.push(b);
}
int f = 0, chances = 0;
p1.insert(make_pair(s1, 1));
p2.insert(make_pair(s2, 1));
while (!s1.empty() && !s2.empty()) {
int aa = s1.front();
int bb = s2.front();
if (aa > bb) {
s1.pop();
s2.pop();
s1.push(bb);
s1.push(aa);
} else {
s1.pop();
s2.pop();
s2.push(aa);
s2.push(bb);
}
chances++;
if (chances >= 100000) {
f = 1;
break;
}
if (p1.find(s1) != p1.end() && p2.find(s2) != p2.end()) {
f = 1;
break;
}
}
if (f == 1)
cout << "-1\n";
else if (s1.empty())
cout << chances << " 2\n";
else
cout << chances << " 1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p1, p2, a[1000005], b[1000005], x[10][10], y[10][10], i, t[10], j,
f[1000005][3], now, L;
char s1[1000005], s2[1000005];
long long ans;
int work(char x) {
if (x == 'R') return 0;
if (x == 'B') return 1;
if (x == 'G') return 2;
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
p1 = strlen(s1);
p2 = strlen(s2);
for (i = 0; i < p1; i++) a[i] = work(s1[i]);
for (i = 0; i < p2; i++) b[i] = work(s2[i]);
t[0] = t[1] = t[2] = p2;
for (i = p2; i >= 0; i--) {
for (j = 0; j < 3; j++) f[i][j] = t[j];
t[b[i - 1]] = i;
}
f[p2][0] = f[p2][1] = f[p2][2] = p2;
now = 0;
L = 1;
for (i = 0; i < p1; i++) {
for (j = now; j < f[now][a[i]]; j++)
if (j) y[b[j - 1]][b[j]]++;
now = f[now][a[i]];
ans += (now - L + 1);
if (i && a[i] != a[i - 1]) ans -= (y[a[i]][a[i - 1]]);
if (L <= p2 && a[i] == b[L - 1]) {
if (L < p2) y[b[L - 1]][b[L]]--;
L++;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 1e9 + 7;
long long mod = 998244353;
int main(void) {
int x, ans = 0, i = 5;
scanf("%d", &x);
while (x != 0) {
int t;
t = x / i;
ans += t;
x -= t * i;
i--;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100005;
long long tot;
priority_queue<pair<long long, pair<long long, long long> > > PQ;
long long leaf[MAXN];
vector<pair<long long, long long> > adj[MAXN];
void dfs(long long now, long long par) {
bool daun = true;
leaf[now] = 0;
for (auto nxt : adj[now]) {
if (nxt.first == par) continue;
dfs(nxt.first, now);
tot += leaf[nxt.first] * nxt.second;
PQ.push({leaf[nxt.first] * ((nxt.second + 1) / 2),
{nxt.second / 2, leaf[nxt.first]}});
leaf[now] += leaf[nxt.first];
daun = false;
}
if (daun) leaf[now] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, s, u, v, w;
cin >> t;
while (t--) {
cin >> n >> s;
tot = 0;
while (!PQ.empty()) PQ.pop();
for (long long i = 1; i <= n; i++) adj[i].clear();
for (long long i = 1; i < n; i++) {
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
dfs(1, -1);
long long ans = 0;
while (tot > s) {
pair<long long, pair<long long, long long> > ambil = PQ.top();
PQ.pop();
tot -= ambil.first;
long long nxt = ambil.second.first;
PQ.push({ambil.second.second * ((nxt + 1) / 2),
{nxt / 2, ambil.second.second}});
ans++;
}
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int f = 0;
for (;;) {
if (!f) {
if (x >= 2 && y >= 2) {
x -= 2;
y -= 2;
} else if (x >= 1 && y >= 12) {
x -= 1;
y -= 12;
} else if (y >= 22) {
y -= 22;
} else {
break;
}
f = 1;
} else {
if (y >= 22) {
y -= 22;
} else if (x >= 1 && y >= 12) {
x -= 1;
y -= 12;
} else if (x >= 2 && y >= 2) {
x -= 2;
y -= 2;
} else {
break;
}
f = 0;
}
}
if (!f) {
cout << "Hanako";
} else {
cout << "Ciel";
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<typename A, typename B = A> using pr = pair<A, B>;
#define vec vector
#define ar array
#define len(a) ((int)((a).size()))
#define all(a) (a).begin(), (a).end()
int q;
vec<int> used;
int timer;
inline void merge(vec<pr<int>> &a, vec<pr<int>> &b, vec<pr<int>> &res) {
timer++;
int j = 0;
auto insert = [&](pr<int> p) {
if (used[p.first] == timer)
return;
used[p.first] = timer;
res.push_back(p);
};
for (int i = 0; i < len(a); i++) {
while (len(res) <= q && j < len(b) && b[j].second >= a[i].second) {
insert(b[j]);
j++;
}
if (len(res) <= q)
insert(a[i]);
else
break;
}
while (len(res) <= q && j < len(b)) {
insert(b[j]);
j++;
}
}
struct my_stack {
vec<pr<vec<pr<int>>>> st;
my_stack() {}
inline void pop_back() {
assert(len(st));
st.pop_back();
}
inline void push_back(vec<pr<int>> &a) {
if (!len(st)) {
st.emplace_back(a, a);
return;
}
st.emplace_back(vec<pr<int>>{}, a);
merge(st.end()[-2].first, a, st.back().first);
}
inline void rev() {
assert(len(st));
reverse(all(st));
st[0].first = st[0].second;
for (int i = 1; i < len(st); i++) {
st[i].first.clear();
merge(st[i].second, st[i - 1].first, st[i].first);
}
}
inline int get_min() {
assert(len(st));
if (len(st.back().first) <= q)
return -1;
return st.back().first.back().second;
}
};
struct my_queue {
my_stack front, back;
my_queue() {}
inline void pop() {
if (!len(front.st)) {
swap(front, back);
front.rev();
}
front.pop_back();
}
inline void push(vec<pr<int>> &a) {
back.push_back(a);
}
inline int get_min() {
assert(len(front.st) + len(back.st));
if (!len(front.st))
return back.get_min();
if (!len(back.st))
return front.get_min();
vec<pr<int>> cur;
merge(front.st.back().first, back.st.back().first, cur);
if (len(cur) <= q)
return -1;
return cur.back().second;
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n >> q;
vec<vec<int>> a(n, vec<int>(n));
for (auto &xs : a)
for (auto &x : xs)
cin >> x;
vec<vec<pr<int>>> left(n);
used.resize(n * n + 1);
vec<int> ans(n);
for (int j = 0; j < n; j++) {
my_queue que;
int prev = 0;
for (int i = 0; i < n; i++) {
vec<pr<int>> nleft{{a[i][j], j}};
for (auto [x, pos] : left[i])
if (x != a[i][j] && len(nleft) <= q)
nleft.emplace_back(x, pos);
left[i] = nleft;
que.push(left[i]);
while (que.get_min() >= j - (i - prev)) {
que.pop();
prev++;
}
// cerr << i << ' ' << j << ": " << i - prev << endl;
ans[i - prev]++;
}
}
for (int i = n - 2; i >= 0; i--)
ans[i] += ans[i + 1];
for (auto x : ans)
cout << x << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int ok[200005];
int hotels[200005];
int vis[200005];
int cnt[200005];
int parent[200005];
int num;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> hotels[i];
for (int i = 1; i <= n; i++) {
cin >> parent[i];
cnt[parent[i]]++;
}
vector<long long int> ans, v;
for (int i = n; i >= 1; i--) {
if (hotels[i] && vis[i] == 0) {
v.clear();
long long int curr = i;
while (1) {
v.push_back(curr);
vis[curr] = 1;
if (parent[curr] == 0 || cnt[parent[curr]] > 1) break;
curr = parent[curr];
}
if (ans.size() < v.size()) ans = v;
}
}
cout << ans.size() << endl;
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using pi = pair<long long, long long>;
using vi = vector<long long>;
using vvi = vector<vector<long long> >;
const long long NUM = 1000030;
const long long N = 10000000;
vector<long long> lp, sieve;
vector<long long> pr;
void primefactor();
long long binpow(long long a, long long b);
long long binpow(long long a, long long b, long long mod);
long long gcd(long long a, long long b);
long long lcm(long long a, long long b);
bool comp(long long a, long long b);
long long inversemod(long long a, long long mod);
void calc_sieve();
void test() {
long long n, i;
cin >> n;
long long arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
if (n == 1) {
cout << arr[0] << endl;
return;
}
long long ans = max(arr[0], arr[1]);
for (i = 1; i < n - 1; i++) ans = min(ans, max(arr[i], arr[i + 1]));
ans = min(ans, arr[n - 1]);
ans = min(ans, arr[0]);
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) test();
return 0;
}
void calc_sieve() {
sieve.resize(NUM + 1, 0);
for (long long x = 2; x <= NUM; x++) {
if (sieve[x]) continue;
for (long long u = x; u <= NUM; u += x) {
sieve[u] = x;
}
}
}
void primefactor() {
lp.resize(N + 1, 0);
for (long long i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (long long j = 0;
j < (long long)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res % mod;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return ((a / gcd(a, b)) * b); }
bool comp(long long a, long long b) { return a > b; }
long long inversemod(long long a, long long mod) {
return binpow(a, mod - 2, mod);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 200010;
int n, k, a, b, q, type, d, x, p, aib[2][nmax];
int cnt[nmax];
int lsb(int x) { return (x & (x - 1)) ^ x; }
void update(int index, int pos, int val) {
for (; pos <= n; pos += lsb(pos)) aib[index][pos] += val;
}
int query(int index, int pos) {
int now = 0;
for (; pos > 0; pos -= lsb(pos)) now += aib[index][pos];
return now;
}
int main() {
scanf("%i %i %i %i %i", &n, &k, &a, &b, &q);
for (; q; --q) {
scanf("%i", &type);
if (type == 1) {
scanf("%i %i", &d, &x);
update(0, d, -min(cnt[d], b));
update(1, d, -min(cnt[d], a));
cnt[d] += x;
update(0, d, min(cnt[d], b));
update(1, d, min(cnt[d], a));
} else {
scanf("%i", &p);
printf("%i\n", query(0, p - 1) + query(1, n) - query(1, p + k - 1));
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
void pre(long long n) {
if (n > 1e10) return;
v.push_back(n);
pre((n * 10) + 4);
pre((n * 10) + 7);
}
signed main() {
pre(0);
sort(v.begin(), v.end());
long long l, r;
cin >> l >> r;
long long id1 = lower_bound(v.begin(), v.end(), l) - v.begin();
long long id2 = lower_bound(v.begin(), v.end(), r) - v.begin();
long long b = v[id2];
long long ans = 0;
long long j = id1;
while (j < id2 && l <= r) {
ans += (v[j] * (v[j] - l + 1));
l = v[j] + 1;
j++;
}
ans += (b * (r - l + 1));
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int v, minv, maxv;
double sum, cnt;
Node *children[2];
Node *closest;
Node *leftest;
bool operator>(const Node &rhs) const { return v > rhs.v; }
} node[100007];
double sum, cnt;
inline void init(int n) {
for (int i = 1; i <= n; i++) node[i].children[0] = node[i].children[1] = NULL;
}
inline void add_edge(int s, int t, int v) {
node[t].v = node[t].minv = node[t].maxv = v;
for (int i = 0; i < 2; i++)
if (node[s].children[i] == NULL) {
node[s].children[i] = node + t;
if (i == 1 && *(node[s].children[0]) > *(node[s].children[1]))
swap(node[s].children[0], node[s].children[1]);
break;
}
}
void build(Node *s) {
s->sum = s->cnt = 0;
for (int i = 0; i < 2; i++) {
if (s->children[i] != NULL) {
build(s->children[i]);
s->minv = min(s->minv, s->children[i]->minv);
s->maxv = max(s->maxv, s->children[i]->maxv);
}
}
}
struct save {
int v;
Node *p;
bool operator<(const save &rhs) const { return v < rhs.v; }
};
vector<save> order;
Node *dfs(Node *s) {
s->closest = NULL;
s->leftest = s;
if (s->children[0] != NULL) {
if (s->children[1] != NULL) {
s->children[0]->sum += s->children[1]->minv + s->sum;
s->children[0]->cnt += 1 + s->cnt;
}
dfs(s->children[0]);
s->leftest = s->children[0]->leftest;
}
order.push_back({s->v, s});
if (s->children[1] != NULL) {
if (s->children[0] != NULL) {
s->children[1]->sum += s->children[0]->maxv + s->sum;
s->children[1]->cnt += 1 + s->cnt;
}
s->closest = dfs(s->children[1]);
}
if (s->closest == NULL) s->closest = s;
return s->leftest;
}
int main() {
int n, root = 1;
scanf("%d", &n);
init(n);
for (int i = 1, f, v; i <= n; i++) {
scanf("%d%d", &f, &v);
if (f > 0)
add_edge(f, i, v);
else {
root = i;
node[i].v = node[i].minv = node[i].maxv = v;
}
}
build(node + root);
dfs(node + root);
int m;
scanf("%d", &m);
while (m--) {
int q;
scanf("%d", &q);
auto res = lower_bound(order.begin(), order.end(), (save){q, NULL});
if (res != order.begin()) res--;
auto p = res->p->closest;
printf("%.10f\n", p->sum / p->cnt);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 2e6 + 5, INF = 0x3f3f3f3f;
int n, res, dis[N];
unordered_set<int> nums;
int h[N], e[M], ne[M], idx;
bool vis[M];
void add(int u, int v) { e[idx] = v, ne[idx] = h[u], h[u] = idx++; }
void init() {
for (int i = 1; i < N; i++) dis[i] = -1;
for (int i = 0; i < idx; i++) vis[i] = false;
return;
}
void bfs(int st) {
init();
queue<int> q;
q.push(st);
dis[st] = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
if (2 * dis[t] + 1 >= res) break;
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = true;
if (dis[j] != -1)
res = min(res, dis[t] + dis[j] + 1);
else {
dis[j] = dis[t] + 1;
q.push(j);
}
}
}
return;
}
int main() {
scanf("%d", &n);
memset(h, -1, sizeof h);
nums.insert(1);
while (n--) {
int x;
scanf("%d", &x);
int p, q;
p = q = 0;
for (int i = 2; i <= x / i; i++)
if (x % i == 0) {
int s = 0;
while (x % i == 0) {
s++;
x /= i;
}
if (s & 1)
if (!p)
p = i;
else
q = i;
}
if (x > 1)
if (!p)
p = x;
else
q = x;
if (p && p <= 1000) nums.insert(p);
if (q && q <= 1000) nums.insert(q);
if (p && q)
add(q, p), add(p, q);
else if (q)
add(1, q), add(q, 1);
else if (p)
add(1, p), add(p, 1);
else {
cout << 1 << endl;
return 0;
}
}
res = INF;
for (auto t : nums) bfs(t);
if (res == INF) res = -1;
printf("%d\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int Min(int a, int b) { return a < b ? a : b; }
map<int, int> mp;
map<int, int>::iterator it;
int l[305], c[305];
int main() {
int i, n;
while (scanf("%d", &n) == 1) {
mp.clear();
for (i = 0; i < n; i++) scanf("%d", &l[i]);
for (i = 0; i < n; i++) scanf("%d", &c[i]);
mp[0] = 0;
for (i = 0; i < n; i++) {
for (it = mp.begin(); it != mp.end(); it++) {
int t1 = it->first;
int t2 = it->second;
int g = gcd(t1, l[i]);
if (mp.count(g) == 0)
mp[g] = t2 + c[i];
else
mp[g] = Min(mp[g], t2 + c[i]);
}
}
if (mp.count(1) == 0)
puts("-1");
else
printf("%d\n", mp[1]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const bool D = 0;
struct Query {
int p, t, x;
friend istream &operator>>(istream &stream, Query &query) {
stream >> query.p >> query.t;
if (query.t == 1) {
stream >> query.x;
} else {
query.t = -1;
}
--query.p;
return stream;
}
friend ostream &operator<<(ostream &stream, Query &query) {
stream << query.p << " " << query.t;
if (query.t == 1) {
stream << " " << query.x;
}
return stream;
}
};
struct SegmentTree {
vector<int> tree, pushing;
void build(int n) {
tree.clear();
pushing.clear();
tree.resize(4 * n, 0);
pushing.resize(4 * n, 0);
}
void push(int v, int l, int r) {
if (l < r) {
tree[v * 2] += pushing[v];
tree[v * 2 + 1] += pushing[v];
pushing[v * 2] += pushing[v];
pushing[v * 2 + 1] += pushing[v];
}
pushing[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, int x) {
push(v, tl, tr);
if (l > r) {
return;
}
if (tl == l && tr == r) {
tree[v] += x;
pushing[v] += x;
return;
}
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(tm, r), x);
update(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, x);
tree[v] = max(tree[v * 2], tree[v * 2 + 1]);
}
int get(int v, int tl, int tr, int l, int r, int k) {
push(v, tl, tr);
if (l > r) {
return -1;
}
if (tree[v] < k) {
return -1;
}
if (tl == tr) {
return tl;
}
int tm = (tl + tr) / 2;
if (tree[v * 2 + 1] >= k) {
return get(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, k);
}
return get(v * 2, tl, tm, l, min(tm, r), k);
}
};
int n, position;
vector<int> values;
vector<Query> queries;
SegmentTree tr;
int main() {
cin >> n;
queries.resize(n);
values.resize(n);
for (int i = 0; i < n; ++i) {
cin >> queries[i];
if (D) {
cout << queries[i] << endl;
}
if (queries[i].t == 1) {
values[queries[i].p] = queries[i].x;
}
}
tr.build(n);
for (int i = 0; i < n; ++i) {
tr.update(1, 0, n - 1, 0, queries[i].p, queries[i].t);
position = tr.get(1, 0, n - 1, 0, n - 1, 1);
if (position == -1) {
cout << position << endl;
} else {
cout << values[position] << endl;
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.