solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m;
cin >> m;
int mn = 100000;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
mn = min(mn, x);
}
vector<int> v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.rbegin(), v.rend());
int i = 0;
long long ans = 0;
while (i < n) {
int temp = mn;
while (temp--) {
if (i == n) break;
ans += v[i];
i++;
}
i += 2;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100100], b[100100];
int pos1[100100], pos2[100100];
int trans[100100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
pos1[a[i]] = i;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
b[i]--;
pos2[b[i]] = i;
}
for (int i = 0; i < n; i++) {
trans[a[i]] = b[i];
}
for (int i = 0; i < n; i++) {
if (i) cout << ' ';
cout << trans[i] + 1;
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<bool> atk;
vector<int> d;
int s, ans = 0, t = -1;
bool dfs(int i, int p) {
d[i] = d[p] + 1;
bool use = atk[i];
for (int j = 0; j < g[i].size(); ++j)
if (g[i][j] != p) {
if (dfs(g[i][j], i))
use = true, ++ans;
else
swap(g[i][j], g[i].back()), g[i].pop_back(), --j;
}
if (use && (t == -1 || d[i] > d[t] || d[i] == d[t] && i < t)) t = i;
return use;
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n), atk.assign(n, false), d.resize(n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y), g[y].push_back(x);
}
for (int i = 0, x; i < m; ++i) cin >> x, atk[s = x - 1] = true;
d[s] = -1, dfs(s, s);
s = t;
d[t] = -1, dfs(t, t);
cout << min(s, t) + 1 << '\n' << ans - d[t];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, mxn = 2e5 + 5;
set<long long> st;
long long n;
void dfs(string s) {
long long x = stoll(s);
if (x > n) return;
st.insert(x);
dfs(s + "1");
dfs(s + "0");
return;
}
long long mainx() {
cin >> n;
dfs("1");
cout << (long long)st.size() << "\n";
return 0;
}
bool cmp(pair<long long, long long> &a, pair<long long, long long> &b) {
if (a.first < b.first) return true;
if (a.first == b.first) return a.second < b.second;
return false;
}
inline void INCLUDE() {}
int32_t main() {
INCLUDE();
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long tt = 1;
for (long long t = 1; t <= tt; t++) {
mainx();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, n, m, edge[100010], cnt;
bool vis[300010];
int main() {
scanf("%d", &T);
while (T-- > 0) {
scanf("%d %d", &n, &m), cnt = 0;
memset(vis, false, sizeof(vis));
for (int i = 1, u, v; i <= m; i++) {
scanf("%d %d", &u, &v);
if (vis[u] || vis[v]) continue;
vis[u] = true, vis[v] = true;
edge[++cnt] = i;
}
if (cnt >= n) {
puts("Matching");
for (int i = 1; i <= n; i++) printf("%d ", edge[i]);
printf("\n");
} else {
puts("IndSet");
for (int i = 1, tmp = 0; i <= 3 * n; i++) {
if (vis[i]) continue;
if (tmp >= n) break;
printf("%d ", i), tmp++;
}
printf("\n");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const long long INF = 2 * 1e18;
const long double PI = 3.14159265358979323846;
vector<long long> ed[100005], dist[100005];
long long par[100005], ans = 0, cur[100005], mx = 0;
void dfs(long long n, long long p, long long d) {
par[n] = p;
dist[d].push_back(n);
mx = max(mx, d);
for (long long i = 0; i < ed[n].size(); i++) {
long long u = ed[n][i];
if (u != p) {
dfs(u, n, d + 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
ed[u].push_back(v);
ed[v].push_back(u);
}
for (long long i = 1; i <= n; i++) cur[i] = i;
dfs(1, 0, 0);
while (mx > 0) {
for (long long i = 0; i < dist[mx].size(); i++) {
long long u = dist[mx][i];
if (cur[u] != u) continue;
swap(cur[u], cur[par[u]]);
ans += 2;
}
mx--;
}
if (cur[1] == 1) {
ans += 2;
swap(cur[1], cur[ed[1][0]]);
}
cout << ans << "\n";
for (long long i = 1; i <= n; i++) cout << cur[i] << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double const PI = acos(-1);
void solve() {
string a, b, c;
cin >> a >> b >> c;
bool fl = 1;
for (int i = 0; i <= (int)c.size() - 1; i++) {
if (a[i] != c[i] && b[i] != c[i]) fl = 0;
}
if (fl)
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
int iteration = t;
while (iteration--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
enum lexem { _ta, _taend, _tr, _trend, _td, _tdend, _end };
string s;
struct _curent {
lexem cur;
int pos;
void next();
} curent;
bool checknext(int pos, const string& temp) {
for (int i = 0; i < temp.size(); i++) {
if (pos + i >= s.size()) return false;
if (s[pos + i] != temp[i]) return false;
}
return true;
}
void _curent::next() {
if (pos == s.size()) {
cur = _end;
return;
}
if (checknext(pos, "<table>")) {
cur = _ta;
pos += 7;
return;
}
if (checknext(pos, "</table>")) {
cur = _taend;
pos += 8;
return;
}
if (checknext(pos, "<td>")) {
cur = _td;
pos += 4;
return;
}
if (checknext(pos, "</td>")) {
cur = _tdend;
pos += 5;
return;
}
if (checknext(pos, "<tr>")) {
cur = _tr;
pos += 4;
return;
}
if (checknext(pos, "</tr>")) {
cur = _trend;
pos += 5;
return;
}
assert(false);
}
vector<int> answer;
int gettd();
int gettr();
void gettable();
int gettd() {
assert(curent.cur == _td);
curent.next();
if (curent.cur == _ta) {
gettable();
}
assert(curent.cur == _tdend);
curent.next();
return 1;
}
int gettr() {
assert(curent.cur == _tr);
curent.next();
int cnt = 0;
while (curent.cur == _td) {
cnt += gettd();
}
assert(curent.cur == _trend);
curent.next();
return cnt;
}
void gettable() {
assert(curent.cur == _ta);
int ans = 0;
curent.next();
while (curent.cur == _tr) {
ans += gettr();
}
assert(curent.cur == _taend);
curent.next();
answer.push_back(ans);
}
void read() {
for (char c; scanf(" %c ", &c) == 1;) s += c;
}
int main() {
read();
curent.pos = 0;
curent.next();
gettable();
assert(curent.cur == _end);
sort(answer.begin(), answer.end());
for (int i = 0; i < answer.size(); i++)
printf("%d%c", answer[i], " \n"[i + 1 == answer.size()]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long u, w, v;
struct Point {
long long x, y;
Point() {}
Point(long long a, long long b) {
x = a;
y = b;
}
friend long long operator*(const Point &a, const Point &b) {
return a.x * b.y - a.y * b.x;
}
friend Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
} p[20010];
int main() {
scanf("%d%I64d%I64d%I64d", &n, &w, &v, &u);
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d", &p[i].x, &p[i].y);
p[i + n] = p[i];
}
Point point = Point(v, u);
int cnt1 = 0, cnt2 = 0;
int id = 0;
p[0] = Point(v, u);
for (int i = 1; i <= n; i++) {
if (p[i] * point >= 0) cnt1++;
if (p[i] * point <= 0) cnt2++;
if (p[i] * point >= 0 && p[i] * p[id] > 0) id = i;
}
if (cnt1 == n || cnt2 == n) {
double ans = (double)w / u;
printf("%.10f", ans);
return 0;
}
long long sumx = p[id].x;
for (int i = id;; i++) {
Point tmp = p[i + 1] - p[i];
if (point * tmp >= 0) {
double ans = (double)sumx / v + ((double)w - p[i].y) / u;
printf("%.10f", ans);
return 0;
}
sumx += (p[i + 1].x - p[i].x);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 505;
const ll INF = ll(1e18);
int n, m, k;
ll d[N][N][2], a[N][N], hs[N], vs[N];
vector<pii> va[N][N], vt[N];
vector<pair<pii, int>> ht[N];
int f(int first, int second, int t) {
return (first + second >= t) && ((first + second - t) % 4 == 0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int first, second, d, t, v;
cin >> first >> second >> d >> t >> v;
int ul = f(first, second, t);
int ur = f(first, second + d, t + 3);
int dl = f(first + d, second - d, t + 1);
int dr = f(first + d, second, t + 2);
if (ul) a[first][second] += v;
if (ur) a[first][second + d] += v;
if (dl) a[first + d][second - d] += v;
if (dr) a[first + d][second] += v;
if (ul && ur) {
vt[first].emplace_back(second + d, v);
va[first][second].emplace_back(second + d, v);
}
if (ul && dr) {
a[first + d][second] -= v;
ht[first].emplace_back(pii(first + d, second), v);
}
if (dl && dr) {
vt[first + d].emplace_back(second, v);
va[first + d][second - d].emplace_back(second, v);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (i + j) d[i][j][0] = d[i][j][1] = INF;
for (int i = 0; i < n; i++) {
for (pii &t : vt[i]) a[i][t.first] -= t.second;
for (int j = 0; j < m; j++) {
ll cs = 0;
for (int t = i + 1; t < n; t++) {
cs += a[t][j];
d[t][j][0] = min(d[t][j][0], d[i][j][1] + cs);
}
cs = 0;
for (int t = j + 1; t < m; t++) {
cs += a[i][t];
d[i][t][1] = min(d[i][t][1], d[i][j][0] + cs);
}
for (pii &t : va[i][j]) a[i][t.first] += t.second;
}
for (auto &t : ht[i]) a[t.first.first][t.first.second] += t.second;
}
cout << min(d[n - 1][m - 1][0], d[n - 1][m - 1][1]) << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ld PI = 3.14159265358979323846;
ll intpow(ll a, ll b) {
ll ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b /= 2;
}
return ans;
}
template <class T = ll>
using v = vector<T>;
template <class T = ll>
using vv = vector<vector<T>>;
template <class T = ll>
using vvv = vector<vector<vector<T>>>;
template <class T>
bool maxi(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool mini(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T>
ll sumer(const T &a) {
return accumulate((a).begin(), (a).end(), 0LL);
}
template <class T>
void UNIQUE(vector<T> &a) {
sort((a).begin(), (a).end());
a.erase(unique((a).begin(), (a).end()), a.end());
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &pe) {
os << pe.first << " " << pe.second;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const v<T> &ve) {
for (ll i = 0; i < ve.size(); i++) os << (i ? " " : "") << ve[i];
return os;
}
ll topbit(ll a) { return a == 0 ? -1 : 63 - __builtin_clzll(a); }
ll botbit(ll a) { return a == 0 ? 64 : __builtin_ctzll(a); }
ll popcount(ll a) { return __builtin_popcountll(a); }
const ld EPS = 1e-9;
using P = pair<ll, ll>;
using TP = tuple<ll, ll, ll>;
void Main() {
ll N;
cin >> N;
ll ans = 0;
for (ll i = 3; i <= N; i += 2) {
ans += (i * i - ((i - 2) * (i - 2))) * (i / 2);
}
cout << ans << "\n";
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll Qkai;
cin >> Qkai;
for (ll QQ = 0; QQ < Qkai; QQ++) Main();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long double PI = acosl(-1);
const long long inf = 1e15;
const int nmax = 2e5 + 5;
int arr[nmax];
int dif[nmax];
bool posibul[nmax];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
dif[i] = arr[i] - arr[i - 1];
}
int ans = 0;
for (int len = 1; len <= n; len++) {
bool hobe = true;
for (int j = len + 1, i = 1; j <= n; j++, i++) {
if (dif[i] != dif[j]) hobe = false;
if (i == len) i = 0;
}
if (hobe) ans++, posibul[len] = true;
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (posibul[i]) cout << i << " ";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const unsigned long long int INF = 2e18;
unsigned long long int p[1000][1000];
int main() {
unsigned long long int n, m, need;
cin >> n >> m >> need;
for (unsigned long long int i = 0; i < n; i++) {
for (unsigned long long int j = 0; j < m; j++) {
cin >> p[i][j];
}
}
unsigned long long int len = n + m - 1;
vector<pair<unsigned long long int, unsigned long long int> > diag(len);
for (unsigned long long int k = 0; k <= n + m - 2; k++) {
diag[k].first = INF;
diag[k].second = k;
for (unsigned long long int i = 0; i < n; i++) {
if (k - i >= m || k - i < 0) continue;
diag[k].first = min(diag[k].first, p[i][k - i]);
}
}
sort(diag.begin(), diag.end());
vector<unsigned long long int> ch(len, 2);
unsigned long long int bal = 0;
for (unsigned long long int i = 0; i < len; i++) {
unsigned long long int now = diag[i].second;
vector<unsigned long long int> f(len + 10, 0), s(len + 1, 0);
f[0] = 1;
bool can = false;
unsigned long long int add = bal + 1;
for (unsigned long long int j = 0; j < len; j++) {
vector<unsigned long long int> newo = f;
for (unsigned long long int k = 0; k <= len; k++) {
if (ch[j] == 0 || j == now)
newo[k] = (k ? f[k - 1] : 0), add--;
else if (ch[j] == 2)
newo[k] = (k ? f[k - 1] : 0) + f[k + 1];
else if (ch[j] == 1)
newo[k] = f[k + 1], add++;
newo[k] = min(newo[k], INF);
if (len - 1 - j == k + add && newo[k] >= need) {
}
}
if (can) break;
f = newo;
}
unsigned long long int det = f[0];
if (can || det >= need) {
ch[now] = 0;
bal++;
} else {
ch[now] = 1;
bal--;
need -= det;
}
}
for (unsigned long long int i = 0; i < n; i++) {
for (unsigned long long int j = 0; j < m; j++) {
cout << (ch[i + j] ? ')' : '(');
}
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int node[505];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &node[i]);
}
double ans = 0;
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
ans = max(ans, (node[x] + node[y]) * 1.0 / (z * 1.0));
}
printf("%.15lf", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimze("Ofast")
using namespace std;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const long long infi = 0x3f3f3f3f;
const long long mod = 1000000007;
const long long N = 5e5 + 5;
vector<long long> adj[N], q;
long long n, timer;
long long a[N], p[N];
void dfs(long long v) {
p[v] = timer--;
for (long long to : adj[v]) dfs(to);
}
void solve() {
cin >> n;
for (long long i = 0; i <= n; i++) adj[i].clear();
timer = n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
if (a[i] == -2) a[i] = i + 1;
adj[a[i]].push_back(i);
}
dfs(n);
q.clear();
for (long long i = n - 1; i >= 0; i--) {
while (!q.empty() && p[q.back()] < p[i]) q.pop_back();
if ((q.empty() && a[i] != n) || (!q.empty() && q.back() != a[i])) {
cout << -1 << '\n';
return;
}
q.push_back(i);
}
for (long long i = 0; i <= n - 1; i++) cout << p[i] + 1 << " ";
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
long long norm(long long a) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long divide(long long a, long long b) {
return (a % mod) * powm(b, mod - 2) % mod;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int belong[100002];
long long int siz[100002];
inline int root(int b) {
if (belong[b] == -1) {
return b;
}
belong[b] = root(belong[b]);
return belong[b];
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) {
return;
}
siz[b] += siz[a];
belong[a] = b;
return;
}
struct st {
int go;
int from;
int cost;
st(int go_, int from_, int cost_) {
go = go_;
from = from_;
cost = cost_;
}
};
int n;
int m;
vector<st> v;
int a[100002];
bool cmp(st &b, st &c) { return b.cost > c.cost; }
int main() {
memset(belong, -1, sizeof(belong));
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
siz[i] = 1;
}
while (m--) {
int b, c;
scanf("%d%d", &b, &c);
b--;
c--;
int co = min(a[b], a[c]);
v.push_back(st(b, c, co));
}
sort(v.begin(), v.end(), cmp);
unsigned long long int ans = 0;
for (int i = 0; i < v.size(); i++) {
int b = v[i].from;
int c = v[i].go;
unsigned long long int cost = v[i].cost;
if (root(b) == root(c)) {
continue;
}
cost *= 2LL;
cost *= siz[root(b)] * siz[root(c)];
ans += cost;
merge(b, c);
}
unsigned long long int pai = (long long int)(n) * (long long int)(n - 1LL);
long long int an = ans / pai;
printf("%I64d.", an);
ans %= pai;
ans *= 10LL;
int countt = 5;
while (countt--) {
if (ans < pai) {
printf("0");
}
ans *= 10LL;
}
an = ans / pai;
printf("%I64d\n", an);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, ans = 0;
cin >> n >> a >> b;
char s[n];
cin >> s;
if (s[b - 1] == s[a - 1])
cout << 0 << endl;
else
cout << 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100005];
int par[100005];
int fnd(int u) { return par[u] = par[u] == u ? u : fnd(par[u]); }
void unn(int u, int v) {
u = fnd(u), v = fnd(v);
par[u] = v;
}
int main() {
srand(time(0));
scanf("%d%d", &n, &m);
iota(par, par + n + 1, 0);
for (int a, b, i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
vector<int> conn;
adj[i].push_back(0);
adj[i].push_back(i);
adj[i].push_back(n + 1);
sort(adj[i].begin(), adj[i].end());
if (n - adj[i].size() + 2 <= 100) {
int nt = 1;
for (int j : adj[i]) {
while (nt < j) conn.push_back(nt++);
if (nt == j) nt++;
}
} else {
vector<pair<int, int>> rngs;
for (int j = 1; j < adj[i].size(); j++)
if (adj[i][j] - adj[i][j - 1] > 1)
rngs.push_back({adj[i][j] - adj[i][j - 1] - 1, adj[i][j - 1] + 1});
for (int j = 1; j < rngs.size(); j++) rngs[j].first += rngs[j - 1].first;
while (conn.size() < min(100, n - 1)) {
int tk = rand() % rngs.back().first + 1;
int st = 0, en = rngs.size() - 1, mid;
while (st <= en) {
mid = (st + en) >> 1;
if (rngs[mid].first < tk)
st = mid + 1;
else
en = mid - 1;
}
int ad = tk - (st ? rngs[st - 1].first : 0) + rngs[st].second - 1;
conn.push_back(ad);
}
}
for (int j : conn) unn(i, j);
}
int ans = -1;
for (int i = 1; i <= n; i++) ans += (i == fnd(i));
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 1e5 + 5;
int n;
vector<pair<int, int> > px0, px1, py0, py1, p0, p1, p2, p3;
int main() {
int x, y, ans;
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d %d", &x, &y);
if (x == 0) {
if (y > 0)
px0.push_back(make_pair(x, y));
else
px1.push_back(make_pair(x, -y));
} else if (y == 0) {
if (x > 0)
py0.push_back(make_pair(x, y));
else
py1.push_back(make_pair(-x, y));
} else if (x > 0 && y > 0)
p0.push_back(make_pair(x, y));
else if (x < 0 && y > 0)
p1.push_back(make_pair(-x, y));
else if (x < 0 && y < 0)
p2.push_back(make_pair(-x, -y));
else
p3.push_back(make_pair(x, -y));
}
ans = 4 * ((px0).size() + (px1).size() + (py0).size() + (py1).size());
ans += 6 * ((p0).size() + (p1).size() + (p2).size() + (p3).size());
printf("%d\n", ans);
sort((px0).begin(), (px0).end());
for (int i = 0; i < ((px0).size()); i++) {
printf("1 %d U\n", px0[i].second);
puts("2");
printf("1 %d D\n", px0[i].second);
puts("3");
}
sort((px1).begin(), (px1).end());
for (int i = 0; i < ((px1).size()); i++) {
printf("1 %d D\n", px1[i].second);
puts("2");
printf("1 %d U\n", px1[i].second);
puts("3");
}
sort((py0).begin(), (py0).end());
for (int i = 0; i < ((py0).size()); i++) {
printf("1 %d R\n", py0[i].first);
puts("2");
printf("1 %d L\n", py0[i].first);
puts("3");
}
sort((py1).begin(), (py1).end());
for (int i = 0; i < ((py1).size()); i++) {
printf("1 %d L\n", py1[i].first);
puts("2");
printf("1 %d R\n", py1[i].first);
puts("3");
}
sort((p0).begin(), (p0).end());
for (int i = 0; i < ((p0).size()); i++) {
printf("1 %d R\n", p0[i].first);
printf("1 %d U\n", p0[i].second);
puts("2");
printf("1 %d D\n", p0[i].second);
printf("1 %d L\n", p0[i].first);
puts("3");
}
sort((p1).begin(), (p1).end());
for (int i = 0; i < ((p1).size()); i++) {
printf("1 %d L\n", p1[i].first);
printf("1 %d U\n", p1[i].second);
puts("2");
printf("1 %d D\n", p1[i].second);
printf("1 %d R\n", p1[i].first);
puts("3");
}
sort((p2).begin(), (p2).end());
for (int i = 0; i < ((p2).size()); i++) {
printf("1 %d L\n", p2[i].first);
printf("1 %d D\n", p2[i].second);
puts("2");
printf("1 %d U\n", p2[i].second);
printf("1 %d R\n", p2[i].first);
puts("3");
}
sort((p3).begin(), (p3).end());
for (int i = 0; i < ((p3).size()); i++) {
printf("1 %d R\n", p3[i].first);
printf("1 %d D\n", p3[i].second);
puts("2");
printf("1 %d U\n", p3[i].second);
printf("1 %d L\n", p3[i].first);
puts("3");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = -1;
bool game(long long a, long long t) {
t = t % (a + 1);
return (t == a) || (t % 2 == 1);
}
bool win(long long a, long long b) {
if (!a) return false;
if (!win(b % a, a)) return true;
return game(a, (b - (b % a + a)) / a);
}
int main() {
int t;
scanf("%d", &t);
for (int cs = (0); cs < (int)(t); cs++) {
long long a, b;
scanf("%lld %lld", &a, &b);
if (a > b) swap(a, b);
cout << (win(a, b) ? "First" : "Second") << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int count = 4;
if (a == b || a == c || a == d) count--;
if (b == c || b == d) count--;
if (c == d) count--;
cout << 4 - count << endl;
getchar();
getchar();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int base = 987654323;
const int maxn = 100005;
struct ljb {
int num, dest;
ljb *next;
} * p, *head[maxn], *tail[maxn];
long long bzhash[maxn][18], powc[maxn], hasha[maxn];
int bzfa[maxn][18], dis1[maxn], dis2[maxn], sa[maxn], bak[maxn], f1[maxn],
f2[maxn], flag[maxn], which[maxn], fa1[maxn], fa2[maxn], fac1[maxn],
fac2[maxn];
pair<int, int> qj[maxn];
int q, lc, rc, o1, o2, o, e, father;
char ch;
bool cmp(int xc, int yc) {
for (int i = 17; i >= 0; i--) {
if ((bzfa[xc][i] != 0) && (bzfa[yc][i] != 0))
if (bzhash[xc][i] == bzhash[yc][i]) {
xc = bzfa[xc][i];
yc = bzfa[yc][i];
}
}
if (fa2[xc] + fa2[yc] == 0) return false;
if (fa2[xc] == 0) return true;
if (fa2[yc] == 0) return false;
return fac2[xc] < fac2[yc];
}
void mpush(int x, int y, int z) {
ljb *p;
p = new ljb;
p->dest = y;
p->num = z;
p->next = 0;
tail[x]->next = p;
tail[x] = p;
}
int getfa(int s, int k) {
for (int i = 17; i >= 0; i--)
if (k >= (1 << i)) {
s = bzfa[s][i];
k -= 1 << i;
}
return s;
}
void dfs(int s, int left, int right) {
qj[s] = make_pair(left, right);
int c = 0, ll, rr, mm, lc, rc, nowc;
ljb *p = head[s]->next;
while (p != 0) {
ll = left;
rr = right;
while (ll <= rr) {
mm = (ll + rr) / 2;
nowc = getfa(sa[mm], dis1[s] - 1);
if (fac2[nowc] >= p->num)
rr = mm - 1;
else
ll = mm + 1;
}
lc = ll;
ll = left;
rr = right;
while (ll <= rr) {
mm = (ll + rr) / 2;
nowc = getfa(sa[mm], dis1[s] - 1);
if (fac2[nowc] <= p->num)
ll = mm + 1;
else
rr = mm - 1;
}
rc = rr;
dfs(p->dest, lc, rc);
p = p->next;
}
}
void plus1(int s) {
while (s <= o2) {
f1[s]++;
s += s & (-s);
}
}
int gs1(int s) {
int ss = 0;
while (s > 0) {
ss += f1[s];
s -= s & (-s);
}
return ss;
}
int getsum1(int l, int r) { return gs1(r) - gs1(l - 1); }
void pl2(int s, int flag) {
while (s <= o2) {
f2[s] += flag;
s += s & (-s);
}
}
void plus2(int l, int r) {
pl2(l, 1);
pl2(r + 1, -1);
}
int gettime2(int s) {
int ss = 0;
while (s > 0) {
ss += f2[s];
s -= s & (-s);
}
return ss;
}
int main() {
powc[0] = 1;
for (int i = 1; i <= maxn; i++) powc[i] = powc[i - 1] * base;
o1 = 1;
o2 = 1;
scanf("%d\n", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d %c\n", &flag[i], &father, &ch);
if (flag[i] == 1) {
++o1;
fa1[o1] = father;
fac1[o1] = ch - 96;
which[i] = o1;
} else {
++o2;
fa2[o2] = father;
fac2[o2] = ch - 96;
which[i] = o2;
}
}
for (int i = 1; i <= o2; i++) {
if (i == 1)
bzhash[i][0] = 0;
else
bzhash[i][0] = fac2[i];
if (i == 1)
bzfa[i][0] = 0;
else
bzfa[i][0] = fa2[i];
o = 1;
e = fa2[i];
while (bzfa[e][o - 1] != 0) {
bzhash[i][o] = bzhash[i][o - 1] * powc[1 << (o - 1)] + bzhash[e][o - 1];
bzfa[i][o] = bzfa[e][o - 1];
e = bzfa[i][o];
o++;
}
}
dis1[1] = 1;
for (int i = 2; i <= o1; i++) dis1[i] = dis1[fa1[i]] + 1;
dis2[1] = 1;
for (int i = 2; i <= o2; i++) dis2[i] = dis2[fa2[i]] + 1;
for (int i = 1; i <= o2; i++) sa[i] = i;
sort(sa + 1, sa + o2 + 1, cmp);
for (int i = 1; i <= o2; i++) bak[sa[i]] = i;
for (int i = 0; i <= o1; i++) {
p = new ljb;
p->dest = 0;
p->num = 0;
p->next = 0;
head[i] = p;
tail[i] = p;
}
for (int i = 2; i <= o1; i++) mpush(fa1[i], i, fac1[i]);
dfs(1, 1, o2);
memset(f1, 0, sizeof(f1));
memset(f2, 0, sizeof(f2));
long long ans = 1, nt;
plus2(1, o2);
plus1(1);
for (int i = 1; i <= q; i++) {
if (flag[i] == 1) {
lc = qj[which[i]].first;
rc = qj[which[i]].second;
ans += getsum1(lc, rc);
plus2(lc, rc);
} else {
lc = bak[which[i]];
ans += gettime2(lc);
plus1(lc);
}
printf("%I64d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long ara[200005];
char st[200004];
long long aa[200004];
long long bb[200004];
int main() {
long long a, b, c, d, m, n, i, j, k, l, t, x, y, z;
cin >> t;
while (t--) {
long long ans = 0;
long long maxi = 0, mini = 0, sum = 0, mul = 1;
cin >> x >> y >> n;
a = n / x;
b = n % x;
if (b >= y)
k = (x * a) + y;
else if (a > 0)
k = (x * (a - 1)) + y;
else
k = y;
cout << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int mat[N][N], b1[N][N], a[N], b[N], c[N], d[N], n, m;
void solve() {
memset(b1, 0, sizeof(b1));
int sumc = 0, sumd = 0, last1c = -1, last1d = -1, last0c = -1, last0d = -1,
first1c = -1, first1d = -1;
for (int i = 0; i < n; i++) {
sumc += c[i];
if (c[i] == 1)
last1c = i;
else
last0c = i;
if (first1c == -1 && c[i] == 1) first1c = i;
}
for (int j = 0; j < m; j++) {
sumd += d[j];
if (d[j] == 1)
last1d = j;
else
last0d = j;
if (first1d == -1 && d[j] == 1) first1d = j;
}
if (first1d == -1 && first1c == -1) return;
if (sumc % 2 != sumd % 2) {
cout << "NO" << endl;
exit(0);
}
if (sumc % 2) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (c[i] && d[j]) b1[i][j] = 1;
} else {
if (last0c != -1 && last0d != -1) {
for (int j = 0; j < m; j++) b1[last0c][j] = d[j];
for (int i = 0; i < n; i++) b1[i][last0d] = c[i];
} else if (last0c != -1 && last0d == -1) {
if (first1c != -1 && first1d != -1) {
b1[first1c][first1d] = 1;
for (int i = 0; i < n; i++) {
if (i != first1c) b1[i][last1d] = c[i];
}
for (int j = 0; j < m; j++) {
if (j != first1d) b1[last1c][j] = d[j];
}
} else {
for (int j = 0; j < m; j++) b1[last0c][j] = d[j];
}
} else if (last0c == -1 && last0d != -1) {
if (first1c != -1 && first1d != -1) {
b1[first1c][first1d] = 1;
for (int i = 0; i < n; i++) {
if (i != first1c) b1[i][last1d] = c[i];
}
for (int j = 0; j < m; j++) {
if (j != first1d) b1[last1c][j] = d[j];
}
} else {
for (int i = 0; i < n; i++) b1[i][last0d] = c[i];
}
} else {
b1[first1c][first1d] = 1;
for (int i = 0; i < n; i++) {
if (i != first1c) b1[i][last1d] = c[i];
}
for (int j = 0; j < m; j++) {
if (j != first1d) b1[last1c][j] = d[j];
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = 0; j < m; j++) cin >> b[j];
for (int k = 0; k <= 30; k++) {
for (int i = 0; i < n; i++) c[i] = (a[i] & (1 << k)) > 0;
for (int j = 0; j < m; j++) d[j] = (b[j] & (1 << k)) > 0;
solve();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (b1[i][j]) mat[i][j] += (1 << k);
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << mat[i][j] << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
int main() {
scanf("%d%d%d", &n, &x, &y);
if ((x != n / 2 && x != (n / 2 + 1)) || (y != n / 2 && y != (n / 2 + 1)))
printf("YES");
else
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200010;
struct Node {
int v, c, flag, num;
Node *nxt, *twin;
} * g[MaxN], pool[MaxN * 2], *tail = pool;
int n, m, flag[MaxN], sum[MaxN], d[MaxN];
inline void make_edge(int u, int v, int c, int num) {
tail->v = v;
tail->c = c;
tail->num = num;
tail->flag = 1;
tail->twin = tail + 1;
tail->nxt = g[u];
g[u] = tail++;
tail->v = u;
tail->c = c;
tail->num = num;
tail->flag = -1;
tail->twin = tail - 1;
tail->nxt = g[v];
g[v] = tail++;
}
void bfs() {
static int q[MaxN], l, r;
for (d[q[l = r = 0] = 1] = 1; l <= r; l++)
for (Node *p = g[q[l]]; p; p = p->nxt)
if (p->flag) {
sum[p->v] -= p->c, flag[p->num] = (~p->flag ? 0 : 1),
p->flag = p->twin->flag = 0;
if (!sum[p->v] && p->v != n) q[++r] = p->v;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
make_edge(u, v, c, i);
sum[u] += c;
sum[v] += c;
}
for (int i = 1; i <= n; i++) sum[i] /= 2;
bfs();
for (int i = 1; i <= m; i++) printf("%d\n", flag[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int T, tot, prime[75], check[75], u[75];
long long n, ans;
const int maxn = 70;
long long Pow(long long a, long long b) {
long long res = 1;
long double rr = 1, A = a;
while (b) {
if (b & 1) res = res * a, rr = rr * A;
a = a * a;
A = A * A;
b >>= 1;
}
if (rr > 1100000000000000000.0) return 1100000000000000000.0;
return res;
}
long long work(long long x, long long y) {
long long tmp = (long long)powl(x, 1.0 / y);
for (;; tmp++)
if (Pow(tmp, y) > x) return tmp - 1;
}
int main() {
u[1] = 1;
for (int i = 2; i <= maxn; i++) {
if (!check[i]) prime[++tot] = i, u[i] = -1;
for (int j = 1; j <= tot; j++) {
if (i * prime[j] > maxn) break;
check[i * prime[j]] = 1;
if (i % prime[j])
u[i * prime[j]] = -u[i];
else {
u[i * prime[j]] = 0;
break;
}
}
}
scanf("%d", &T);
while (T--) {
scanf("%I64d", &n);
ans = 0;
for (int i = 1; i <= 60; i++) {
long long tmp = work(n, i) - 1;
if (!tmp) break;
ans += u[i] * tmp;
}
printf("%I64d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int D = 750, N = 5e5;
int q, t, x, y, arr[N + 10], smal[D][D], ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> q;
while (q--) {
cin >> t >> x >> y;
if (t == 1) {
arr[x] += y;
for (int i = 1; i < D; i++) {
smal[i][(x % i)] += y;
}
} else {
ans = 0;
if (x >= D) {
for (int i = y; i <= N; i += x) {
ans += arr[i];
}
} else {
ans = smal[x][y];
}
cout << ans << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
#pragma GCC optimize("03")
using namespace std;
vector<pair<int, int> > g[(long long)(2e5 + 5)];
set<pair<int, int> > ig[(long long)(2e5 + 5)];
map<pair<int, int>, int> fq;
int cant[(long long)(2e5 + 5)];
int ma[100][100];
int trans(pair<int, int> x) {
return ((x.first) * (x.first - 1)) / 2 + x.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u].push_back(pair<int, int>(w, v));
}
for (int i = 0; i < n; i++) {
sort((g[i]).begin(), (g[i]).end());
for (int j = 0; j < g[i].size(); j++) {
int u = g[i][j].second;
cant[u]++;
ig[u].insert(pair<int, int>(g[i].size(), j));
}
}
bool ok = 1;
int sum = 0;
for (int i = 0; i < n; i++) {
if (!cant[i]) ok = 0;
sum += ig[i].size();
vector<pair<int, int> > ks;
for (auto y : ig[i]) {
fq[y]++;
ks.push_back(y);
}
for (int j = 0; j < ks.size(); j++)
for (int u = j + 1; u < ks.size(); u++)
ma[trans(ks[j])][trans(ks[u])] = ma[trans(ks[u])][trans(ks[j])] = 1;
}
if (!ok) {
cout << (0) << '\n';
return 0;
}
long long first[k + 1];
first[0] = 1;
for (int i = 1; i <= k; i++) first[i] = first[i - 1] * i;
long long res = 0;
for (int i = 0; i < first[k]; i++) {
vector<int> p;
int ff = i;
for (int j = 0; j < k; j++) {
p.push_back(ff / (first[k] / first[j + 1]));
ff %= (first[k] / first[j + 1]);
}
long long sum = 0;
for (int j = 0; j < k; j++) sum += fq[pair<int, int>(j + 1, p[j])];
bool ok = 1;
for (int j = 0; j < k; j++)
for (int u = j + 1; u < k; u++)
ok &= (!ma[trans(pair<int, int>(j + 1, p[j]))]
[trans(pair<int, int>(u + 1, p[u]))]);
if (ok && sum == n) {
res++;
}
}
cout << (res) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using i64 = long long;
const int N = 100000 + 7;
const i64 MOD = 998244353;
int n, m;
i64 x[N], v[N], p[N];
i64 ans;
struct str {
int x, u, v;
i64 t, h;
} e[N << 2];
struct mtr {
i64 a[2][2];
mtr(i64 a_ = 0, i64 b_ = 0, i64 c_ = 0, i64 d_ = 0) {
a[0][0] = a_, a[0][1] = b_, a[1][0] = c_, a[1][1] = d_;
}
mtr operator*(const mtr &q) {
mtr z;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k) z.a[i][j] += a[i][k] * q.a[k][j];
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) z.a[i][j] %= MOD;
return z;
}
mtr chg(int x, int y, i64 z) { return a[x][y] = z, *this; }
} dat[N];
struct segtree {
mtr tr[N << 2];
void modify(int p, int l, int r, int x, mtr y) {
if (l == r)
tr[p] = y;
else {
int mid = l + r >> 1;
x <= mid ? modify(p << 1, l, mid, x, y)
: modify(p << 1 | 1, mid + 1, r, x, y);
tr[p] = tr[p << 1] * tr[p << 1 | 1];
}
}
} tr;
i64 pow(i64 a, i64 k);
i64 gettime(int x, int y, int u, int v);
int main() {
const i64 inv100 = pow(100, MOD - 2);
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%lld%lld%lld", x + i, v + i, p + i), p[i] = p[i] * inv100 % MOD;
for (int i = 1; i < n; ++i)
for (int u = 0; u < 2; ++u)
for (int v = 0; v < 2; ++v)
if (gettime(i, i + 1, u, v) != -1)
e[++m] = (str){i + 1, u, v, x[i + 1] - x[i], gettime(i, i + 1, u, v)};
std::sort(e + 1, e + m + 1,
[](str a, str b) { return a.t * b.h < b.t * a.h; });
for (int i = 1; i <= n; ++i)
tr.modify(1, 1, n, i, dat[i] = mtr(1 - p[i], p[i], 1 - p[i], p[i]));
mtr h;
for (int i = 1; i <= m; ++i)
h = mtr(),
tr.modify(1, 1, n, e[i].x,
h.chg(e[i].u, e[i].v, e[i].v ? p[e[i].x] : 1 - p[e[i].x])),
(ans += e[i].t * pow(e[i].h, MOD - 2) % MOD *
(tr.tr[1].a[0][0] + tr.tr[1].a[0][1])) %= MOD,
tr.modify(1, 1, n, e[i].x, dat[e[i].x].chg(e[i].u, e[i].v, 0));
(ans += MOD) %= MOD;
printf("%lld ", ans);
return 0;
}
i64 pow(i64 a, i64 k) {
i64 t = 1;
for (; k; a = a * a % MOD, k >>= 1)
if (k & 1) t = t * a % MOD;
return t;
}
i64 gettime(int a, int b, int i, int j) {
if (i == 0 && j == 1) return -1;
if (i == 0 && j == 0) return v[a] >= v[b] ? -1 : v[b] - v[a];
if (i == 1 && j == 1) return v[a] <= v[b] ? -1 : v[a] - v[b];
return v[a] + v[b];
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 2) {
cout << "2\n1 2\n";
continue;
}
vector<pair<int, int>> ans;
int cur = n;
for (int i = n - 1; i >= 1; --i) {
ans.push_back(make_pair(i, cur));
cur = (cur + i + 1) / 2;
}
cout << cur << '\n';
for (auto i : ans) cout << i.first << ' ' << i.second << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1000000007;
long long int pow(long long int a, long long int b, long long int m) {
long long int r = 1, e = a;
while (b) {
if (b & 1) (r *= e) %= m;
(e *= e) %= m;
b >>= 1;
}
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int b, k, c = 0;
cin >> b >> k;
vector<long long int> f(k);
for (auto &it : f) {
cin >> it;
if (it & 1) c++;
}
if (b % 2 == 0) {
(f[k - 1] & 1) ? cout << "odd\n" : cout << "even\n";
} else {
(c & 1) ? cout << "odd\n" : cout << "even\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 3e1 + 17, N = 5e1 + 17, inf = 1e9 + 7, MOD = 1e9 + 7,
Mod = 1e9 + 6;
long long n, m, y, t, d[maxN][maxN][N], help, mini, x;
int main() {
for (long long i = 0; i <= 30; i++) {
for (long long j = 0; j <= 30; j++) {
for (long long k = 0; k <= 50; k++) d[i][j][k] = inf;
if (i && j) d[i][j][0] = 0;
}
}
for (long long i = 1; i <= 30; i++) {
for (long long j = 1; j <= 30; j++) {
mini = min((i * j), (long long)50);
for (long long k = 1; k <= mini; k++) {
if (i < 2 || j < 2) d[i][j][k] = 1;
if (k == i * j) d[i][j][k] = 0;
for (long long z = 0; z <= i; z++) {
for (long long e = 0; e <= k; e++)
d[i][j][k] =
min(d[i][j][k], d[i - z][j][e] + d[z][j][k - e] + (j * j));
}
for (long long z = 0; z <= j; z++) {
for (long long e = 0; e <= k; e++)
d[i][j][k] =
min(d[i][j][k], d[i][j - z][e] + d[i][z][k - e] + (i * i));
}
}
}
}
cin >> t;
for (long long i = 1; i <= t; i++) {
cin >> n >> m >> y;
cout << d[n][m][y] << "\n";
}
return cout << "\n", 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double INF = 1e100;
double EPS = 1e-12;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
PT ProjectPointSegment(PT a, PT b, PT c) {
double r = dot(b - a, b - a);
if (fabs(r) < EPS) return a;
r = dot(c - a, b - a) / r;
if (r < 0) return a;
if (r > 1) return b;
return a + (b - a) * r;
}
double DistancePointSegment(PT a, PT b, PT c) {
return sqrt(dist2(c, ProjectPointSegment(a, b, c)));
}
long long dis(pair<long long, long long> p1, pair<long long, long long> p2) {
long long res;
long long x = p1.first - p2.first;
long long y = p2.second - p1.second;
res = (x * x) + (y * y);
return res;
}
vector<pair<long long, long long> > v;
long long n;
int main() {
cin >> n;
double ans = M_PI;
long long cx, cy;
cin >> cx >> cy;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
long long area = 0;
pair<long long, long long> pp;
pp = make_pair(cx, cy);
long long mx = dis(pp, v[0]);
for (int i = 1; i < n; i++) {
mx = max(mx, dis(pp, v[i]));
}
double mndis = DistancePointSegment(PT(v[0].first, v[0].second),
PT(v[1].first, v[1].second), PT(cx, cy));
for (int i = 1; i < n - 1; i++) {
mndis = min(mndis, DistancePointSegment(PT(v[i].first, v[i].second),
PT(v[1 + i].first, v[i + 1].second),
PT(cx, cy)));
}
mndis = min(mndis, DistancePointSegment(PT(v[0].first, v[0].second),
PT(v[n - 1].first, v[n - 1].second),
PT(cx, cy)));
double mdis = sqrt((double)mx);
ans = ans * ((mdis * mdis) - (mndis * mndis));
printf("%.10lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
vector<int> a[MAXN];
long long fn[MAXN];
void add(int p, int val) {
for (++p; p < MAXN; p += p & -p) fn[p] += val;
}
int get(int p) {
int res = 0;
for (; p > 0; p -= p & -p) res += fn[p];
return res;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n;
for (int i = 0; i < n; i++) cin >> x, a[x].push_back(i), add(i, 1);
int ptr = 0;
long long ans = 0;
for (int i = 1; i < MAXN; i++) {
int sz = a[i].size();
if (sz == 0) continue;
int ind = lower_bound(a[i].begin(), a[i].end(), ptr) - a[i].begin();
for (int j = ind; j < sz; j++) {
ans += get(a[i][j] + 1) - get(ptr);
ptr = a[i][j];
add(ptr, -1);
}
if (ind != 0) {
ans += get(n) - get(ptr);
ptr = 0;
for (int j = 0; j < ind; j++) {
ans += get(a[i][j] + 1) - get(ptr);
ptr = a[i][j];
add(ptr, -1);
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long k, m;
cin >> n >> k >> m;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
vector<long long> r(n);
r[n - 1] = v[n - 1];
for (int i = n - 2; i >= 0; i--) r[i] = r[i + 1] + v[i];
double average = 0;
long long sum;
for (int i = 0; i < n; i++) {
long long qm = m - i;
sum = r[i];
if (qm >= 0) {
if ((n - i) * 1LL * k < qm)
sum += (n - i) * k;
else
sum += qm;
average = max(average, double(sum) / (n - i));
}
}
printf("%.12lf", average);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char *sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
};
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
};
vector<string> split(string s) {
istringstream buf(s);
istream_iterator<string> beg(buf), end;
vector<string> list(beg, end);
return list;
}
bool isvowel(char c) {
string s = "aeiouAEIOU";
if (find(s.begin(), s.end(), c) != s.end()) return true;
return false;
}
vector<long long> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) {
prime[j] = 0;
}
}
vector<long long> p;
for (int i = 2; i <= prime.size(); i++)
if (prime[i]) p.push_back(i);
return p;
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true && (n != 1);
}
int ncr(long long n, long long r) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[r];
}
bool isPallindrome(string s) {
for (int i = 0; i < s.size() / 2; i++) {
if (s[i] != s[s.size() - 1 - i]) return false;
}
return true;
}
void solve() {
string s;
cin >> s;
int n = s.size();
set<string> ans;
for (int i = 0; i < n; i++) {
string t = s.substr(i) + s.substr(0, i);
ans.insert(t);
}
cout << ans.size();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int test_case = 1; test_case <= t; test_case++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
int main() {
int n;
scanf("%d", &n);
char ch;
int x;
int n0 = 0, n1 = (1 << 10) - 1;
for (int i = (1); i <= (n); i++) {
while (ch = getchar(), ch != '|' && ch != '&' && ch != '^')
;
scanf("%d", &x);
if (ch == '|')
n0 |= x, n1 |= x;
else if (ch == '&')
n0 &= x, n1 &= x;
else if (ch == '^')
n0 ^= x, n1 ^= x;
}
int ans0 = 0, ans1 = 0, ans2 = 0;
for (int i = (0); i <= (9); i++) {
if ((n0 & (1LL << (i))) || (n1 & (1LL << (i)))) ans0 |= (1LL << (i));
if ((n0 & (1LL << (i))) && (n1 & (1LL << (i)))) ans1 |= (1LL << (i));
if ((n0 & (1LL << (i))) && !(n1 & (1LL << (i)))) ans2 |= (1LL << (i));
}
printf("3\n& %d\n| %d\n^ %d\n", ans0, ans1, ans2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[105][105][205][2];
string s1;
int main() {
int n;
int ans = 0;
memset(dp, 0, sizeof(dp));
cin >> s1;
cin >> n;
dp[0][0][100][0] = 1;
for (int i = 1; i <= s1.size(); i++) {
for (int j = 0; j <= 100; j++) {
for (int k = 0; k <= 200; k++) {
if (dp[i - 1][j][k][0] == 1) {
if (s1[i - 1] == 'F') {
for (int z = 0; z <= 50; z = z + 2) {
if (j + z > n) break;
dp[i][j + z][k + 1][0] = 1;
}
for (int z = 0; z <= 50; z = z + 2) {
if (j + z + 1 > n) break;
dp[i][j + 1 + z][k][1] = 1;
}
}
if (s1[i - 1] == 'T') {
for (int z = 0; z <= 50; z = z + 2) {
if (j + z > n) break;
dp[i][j + z][k][1] = 1;
}
for (int z = 0; z <= 50; z = z + 2) {
if (j + z + 1 > n) break;
dp[i][j + 1 + z][k + 1][0] = 1;
}
}
}
if (dp[i - 1][j][k][1] == 1) {
if (s1[i - 1] == 'F') {
dp[i][j][k - 1][1] = 1;
dp[i][j + 1][k][0] = 1;
}
if (s1[i - 1] == 'T') {
dp[i][j][k][0] = 1;
dp[i][j + 1][k - 1][1] = 1;
}
}
}
}
}
for (int i = 0; i <= 201; i++) {
if (dp[s1.size()][n][i][0] == 1) ans = max(ans, abs(i - 100));
if (dp[s1.size()][n][i][1] == 1) ans = max(ans, abs(i - 100));
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long cal(long long a, long long b, long long c, long long l) {
long long ct = 0;
if (a < b + c) ct = b + c - a;
if (ct > l) return 0;
a += ct;
l -= ct;
long long cnt = 0;
for (int i = 0; i <= l; ++i) {
ct = min(a + i - b - c, l - i);
cnt += (ct + 2) * (ct + 1) / 2;
}
return cnt;
}
int main() {
long long a, b, c, l, cnt = 0, sum;
scanf("%lld %lld %lld %lld", &a, &b, &c, &l);
sum = (l + 3) * (l + 2) * (l + 1) / 6;
cnt += cal(a, b, c, l);
cnt += cal(b, a, c, l);
cnt += cal(c, a, b, l);
printf("%lld\n", sum - cnt);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << to_string(H) << endl;
debug_out(T...);
}
const int infi = 0x3f3f3f3f;
struct Snode {
int mn = infi;
Snode *child[2];
Snode() {
child[0] = nullptr;
child[1] = nullptr;
}
Snode(int _mn) {
mn = _mn;
child[0] = child[1] = nullptr;
}
};
const int SQN = 318;
Snode *trie[SQN];
void insert(int id, int val) {
if (trie[id] == nullptr)
trie[id] = new Snode(val);
else
trie[id]->mn = min(trie[id]->mn, val);
Snode *cur = trie[id];
for (int i = 18; i >= 0; i--) {
if (cur->child[val >> i & 1] == nullptr) {
cur->child[val >> i & 1] = new Snode(val);
}
cur->mn = min(cur->mn, val);
cur = cur->child[val >> i & 1];
}
}
int query(int id, int x, int s) {
int allowed = s - x;
Snode *cur = trie[id];
if (cur == nullptr || (cur->mn > allowed)) return -1;
int v = 0;
for (int i = 18; i >= 0; i--) {
if (x >> i & 1) {
if (cur->child[0] != nullptr && cur->child[0]->mn <= allowed) {
cur = cur->child[0];
} else if (cur->child[1] != nullptr && cur->child[1]->mn <= allowed) {
cur = cur->child[1];
v = v ^ (1 << i);
} else
return -1;
} else {
if (cur->child[1] != nullptr && cur->child[1]->mn <= allowed) {
cur = cur->child[1];
v = v ^ (1 << i);
} else if (cur->child[0] != nullptr && cur->child[0]->mn <= allowed) {
cur = cur->child[0];
} else
return -1;
}
}
return v;
}
const int N = 1e5 + 10;
vector<int> vec[N];
int present[N];
signed main() {
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int val;
scanf("%d", &val);
if (present[val]) continue;
present[val] = true;
for (int j = 1; j * j <= val; j++) {
if (val % j) continue;
int x = val / j;
int y = j;
if (x < SQN)
insert(x, val);
else
vec[x].push_back(val);
if (x == y) continue;
if (y < SQN)
insert(y, val);
else
assert(false);
}
} else {
int x, k, s;
scanf("%d %d %d", &x, &k, &s);
if (x % k) {
puts("-1");
continue;
}
if (k < SQN) {
printf("%d\n", query(k, x, s));
} else {
int ans = -1;
int cg = 0;
for (int v : vec[k]) {
if (v + x <= s && (v ^ x) >= cg) {
ans = v;
cg = ans ^ x;
}
}
printf("%d\n", ans);
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool zest(vector<int> A, vector<int> B) {
for (int i = 0; i < 4; i++) {
if (A[i] != B[i]) return false;
}
return true;
}
void maru(vector<vector<int>>& A, vector<set<int>>& S, int i) {
for (int j = 0; j < 4; j++) {
if (S[j].size() < 10)
for (int p = 0; p < 10; p++)
if (S[j].find(p) == S[j].end()) {
A[i][j] = p;
S[j].insert(p);
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
int n;
for (int h = 0; h < t; h++) {
cin >> n;
char a, b, c, d;
vector<set<int>> S;
S.resize(4);
vector<vector<int>> A;
A.resize(n);
for (int i = 0; i < n; i++) {
cin >> a >> b >> c >> d;
S[0].insert(a - '0');
S[1].insert(b - '0');
S[2].insert(c - '0');
S[3].insert(d - '0');
A[i].push_back(a - '0');
A[i].push_back(b - '0');
A[i].push_back(c - '0');
A[i].push_back(d - '0');
}
int k = 0;
for (int i = 0; i < n; i++) {
bool fl = false;
for (int j = i + 1; j < n; j++) {
fl = fl || zest(A[i], A[j]);
}
if (fl) {
k++;
maru(A, S, i);
}
}
cout << k << '\n';
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) cout << A[i][j];
cout << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 5;
const long long inf = 2e18;
int n;
int main() {
int t;
cin >> t;
while (t--) {
cin >> n;
for (int k = (int)2; k <= (int)31; k++) {
long long p = 1ll << k;
p--;
if (n % p == 0) {
cout << n / p << endl;
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int inf = 0x3f3f3f3f;
struct node {
long long m;
int i;
bool operator<(const node &p) const {
if (m == p.m) return i < p.i;
return m < p.m;
}
} e[maxn];
int t, n, mm, a, b;
long long x;
int aa[2 * maxn], bb[2 * maxn];
long long cc[2 * maxn];
int main() {
scanf("%d%d", &n, &mm);
for (int i = 1; i <= mm; i++) {
scanf("%d%d%lld", &a, &b, &x);
e[a].m -= x;
e[b].m += x;
}
for (int i = 1; i <= n; i++) {
e[i].i = i;
}
sort(e + 1, e + 1 + n);
int mark = n, cnt = 0;
for (int i = 1; i <= n; i++) {
while (e[mark].m == 0) mark--;
if (i >= mark || e[i].m >= 0) break;
while (e[i].m != 0) {
if (e[mark].m + e[i].m > 0) {
aa[++cnt] = e[i].i, bb[cnt] = e[mark].i, cc[cnt] = -e[i].m;
e[mark].m += e[i].m;
e[i].m = 0;
} else {
aa[++cnt] = e[i].i, bb[cnt] = e[mark].i, cc[cnt] = e[mark].m;
e[i].m += e[mark].m;
e[mark].m = 0;
mark--;
}
}
}
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) {
printf("%d %d %lld\n", aa[i], bb[i], cc[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
int main() {
long long a, b;
while (cin >> a >> b) {
vector<long long> v;
long long gs = gcd(a, b);
a /= gs, b /= gs;
for (int i = 2; i <= sqrt(a); i++) {
while (a % i == 0) {
v.push_back(i);
a /= i;
}
}
if (a > 1) v.push_back(a);
long long ans = 0;
while (b) {
long long g = b;
for (vector<long long>::iterator it = v.begin(); it != v.end(); it++) {
g = min(g, b % *it);
}
ans += g;
b -= g;
vector<long long> t;
for (vector<long long>::iterator it = v.begin(); it != v.end(); it++) {
if (b % *it == 0)
b /= *it;
else
t.push_back(*it);
}
swap(v, t);
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#define N_ 30100
using namespace std;
using pii = pair<int,int>;
int n, K, Q, w[N_], Tw[N_];
long long D[5][N_], P[N_], U[5][N_], S[5][N_];
void Solve(){
int i, j, k;
scanf("%d%d%d",&n,&K,&Q);
for(i=1;i<=n;i++){
scanf("%d",&w[i]);
}
for(i=0;i<=4;i++){
for(j=0;j<=n;j++){
U[i][j]=D[i][j]=S[i][j]=0;
}
}
for(i=0;i<=K;i++)U[i][0]=1;
for(i=1;i<=n;i++){
for(j=0;j<=K;j++)U[j][i]=U[j][i-1];
for(j=1;j<=K && j<i;j++){
for(k=j;k<=K;k++){
U[k][i] += U[k-j][i-j-1];
U[k][i] = U[k][i];
}
}
}
for(i=1;i<=K;i++){
for(j=1;j<=n;j++){
for(k=1;k<=i && j+k<=n;k++){
if(w[j+k] < w[j]){
D[i][j] += U[i-k][n-(j+k)];
D[i][j] = D[i][j];
}
}
}
}
for(i=1;i<=K;i++){
for(j=1;j<=n;j++){
S[i][j]=S[i][j-1]+D[i][j];
//if(j%100==0)printf("%lld\n",U[i][j]);
}
//puts("");
}
while(Q--){
int loc;
long long M;
scanf("%d%lld",&loc,&M);
if(M > U[K][n]){
puts("-1");
continue;
}
int ed = 0, TK = K;
while(1){
int bb = ed+1, ee = n, rr = ed;
while(bb<=ee){
int m = (bb+ee)>>1;
long long sm = S[TK][m] - S[TK][ed];
long long dd = U[TK][n-m];
if(sm < M && sm + dd >= M){
rr = m;
bb = m+1;
}
else{
ee = m-1;
}
}
if(loc <= rr){
printf("%d\n",w[loc]);
break;
}
M -= (S[TK][rr] - S[TK][ed]);
int pv = rr+1;
vector<pii>ZZ;
for(i=0;i<=TK && pv+i <=n;i++){
ZZ.push_back({w[pv+i],i});
}
sort(ZZ.begin(),ZZ.end());
int fin = 0;
for(auto &t : ZZ){
int l = t.second;
if(M <= U[TK-l][n-(pv+l)]){
for(i=pv;i<=pv+l;i++)Tw[i]=w[i];
reverse(Tw+pv,Tw+pv+l+1);
if(loc <= pv+l){
printf("%d\n",Tw[loc]);
fin=1;
break;
}
ed = pv+l;
TK-=l;
break;
}
else M-=U[TK-l][n-(pv+l)];
}
if(fin)break;
}
}
}
int main(){
int TC;
scanf("%d",&TC);
while(TC--){
Solve();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int y[50010] = {};
int t[50010] = {};
unordered_map<int, int> ha;
bool cmp(int x, int y) { return x > y; }
bool ff(int x) {
ha.clear();
for (int i = 1; i <= n; i++) y[i] = t[i];
for (int i = 1; i <= n; i++) {
if (y[i] <= x && ha[y[i]] == 0) {
ha[y[i]] = 1;
} else {
while (1) {
if (y[i] == 1) {
return 0;
}
if (ha.find(y[i] >> 1) == ha.end() && (y[i] >> 1) <= x) {
ha[y[i] >> 1] = 1;
break;
} else
y[i] >>= 1;
}
}
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
sort(t + 1, t + n + 1, cmp);
int l = 1;
int r = t[1];
while (l < r) {
int mid = (l + r) / 2;
if (ff(mid))
r = mid;
else
l = mid + 1;
}
ff(l);
for (auto it = ha.begin(); it != ha.end(); ++it) printf("%d ", it->first);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int a, b, c;
scanf("%d %d", &a, &b);
if (a > b) {
c = (a - b) / 2;
printf("%d %d\n", b, c);
} else if (a < b) {
c = (b - a) / 2;
printf("%d %d\n", a, c);
} else {
printf("%d 0\n", a);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int num[200000], l[200000], r[200000], v[200000], pre[200000];
int i, n, j;
int an[200000], ans, f[200000];
struct node {
int first, second;
bool operator<(const node& q) const {
return first < q.first || (first == q.first && second < q.second);
}
};
map<node, node> q;
int main() {
node a;
node b;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d%d%d", &v[i], &num[i], &l[i], &r[i]);
for (i = 1; i <= n; i++) {
a.first = l[i];
a.second = num[i] + l[i] + r[i];
if (q.count(a)) {
f[i] = q[a].first;
pre[i] = q[a].second;
}
if (l[i] == 0)
f[i] = v[i];
else if (pre[i] != 0)
f[i] += v[i];
a.first = l[i] + num[i];
if (q.count(a)) {
if (q[a].first < f[i]) {
q[a].first = f[i];
q[a].second = i;
}
} else if (l[i] == 0) {
b.first = f[i];
b.second = i;
q.insert(make_pair(a, b));
} else if (l[i] != 0 && pre[i] != 0) {
b.first = f[i];
b.second = i;
q.insert(make_pair(a, b));
}
if (r[i] == 0) {
if (f[i] > ans) {
ans = f[i];
j = i;
}
}
}
i = 0;
while (j != 0) {
i++;
an[i] = j;
j = pre[j];
}
printf("%d\n", i);
for (j = i; j >= 1; j--) printf("%d ", an[j]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> cposs;
int main() {
cin >> N;
int a1 = 0, a2 = 0;
int cval[110];
for (int i = 0; i < N; i++) {
int nval;
cin >> nval;
for (int j = 0; j < nval; j++) {
cin >> cval[j];
if (j * 2 + 1 < nval)
a1 += cval[j];
else if (j * 2 + 1 > nval)
a2 += cval[j];
else
cposs.push_back(cval[j]);
}
}
sort(cposs.begin(), cposs.end());
reverse(cposs.begin(), cposs.end());
for (int i = 0; i < cposs.size(); i++)
if (i % 2 == 0)
a1 += cposs[i];
else
a2 += cposs[i];
cout << a1 << " " << a2 << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, v;
cin >> n >> v;
if (v < n) {
int s = v;
int h = n - v;
cout << ((h + 1) * h / 2 + v - 1);
} else
cout << n - 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q, n, r;
int d[100001], f[100001];
int main() {
scanf("%d", &q);
for (; q; --q) {
scanf("%d %d", &n, &r);
for (register int i = 1; i <= n; i = -~i) {
scanf("%d", &d[i]);
if (f[d[i]])
--i, --n;
else
f[d[i]] = 1;
}
sort(d + 1, d + n + 1);
for (register int i = n; i >= 0; --i)
if (d[i] <= r * (n - i)) {
printf("%d\n", n - i);
break;
}
for (register int i = 1; i <= n; i = -~i) f[d[i]] = 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 505;
long long dp[N][N][2], cnt[N];
int n, k;
long long first(int x) { return cnt[min(x, n)]; }
long long first(int x, int y, int z) {
if (y == n) return z;
long long &res = dp[x][y][z];
if (res == -1) {
res = 0;
for (int i = y + 1; i <= min(n, y + x); ++i)
res = (res + first(x, i, i == y + x ? 1 : z)) % mod;
}
return res;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d%d", &n, &k);
for (int i = 1; i <= min(k - 1, n); ++i)
cnt[i] = (first(i, 0, 0) + cnt[i - 1]) % mod;
long long ans = 0;
for (int i = 1; i <= min(k - 1, n); ++i) {
int mx = (k - 1) / i;
ans = (ans + (cnt[i] - cnt[i - 1]) * 2 * first(mx)) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 0x7fffffffffffffff;
template <typename T>
void print(T v, int l = 0, int r = 5) {
for (int i = l; i < r; i++) cout << v[i] << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> k(n);
int ans = MOD;
for (int i = 0; i < n; ++i) cin >> k[i];
for (int i = 0; i < n; ++i) {
int cur = 0;
for (int j = 0; j < k[i]; ++j) {
int m;
cin >> m;
cur += m * 5 + 15;
}
ans = min(ans, cur);
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char grid[105][105];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
if (n % 3 != 0 && m % 3 != 0) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
}
}
if (n % 3 == 0) {
int cnt[500];
bool good = true;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n / 3; i++) {
for (int j = 0; j < m; j++) {
cnt[grid[i][j]]++;
}
}
if (cnt[grid[0][0]] != (n / 3) * m) good = false;
for (int i = n / 3; i < 2 * n / 3; i++) {
for (int j = 0; j < m; j++) {
cnt[grid[i][j]]++;
}
}
if (cnt[grid[n / 3][0]] != (n / 3) * m) good = false;
for (int i = 2 * n / 3; i < n; i++) {
for (int j = 0; j < m; j++) {
cnt[grid[i][j]]++;
}
}
if (cnt[grid[2 * n / 3][0]] != (n / 3) * m) good = false;
if (good) {
cout << "YES" << endl;
return 0;
}
}
if (m % 3 == 0) {
int cnt[500];
bool good = true;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < m / 3; i++) {
for (int j = 0; j < n; j++) {
cnt[grid[j][i]]++;
}
}
if (cnt[grid[0][0]] != (m / 3) * n) good = false;
for (int i = m / 3; i < 2 * m / 3; i++) {
for (int j = 0; j < n; j++) {
cnt[grid[j][i]]++;
}
}
if (cnt[grid[0][m / 3]] != (m / 3) * n) good = false;
for (int i = 2 * m / 3; i < m; i++) {
for (int j = 0; j < n; j++) {
cnt[grid[j][i]]++;
}
}
if (cnt[grid[0][2 * m / 3]] != (m / 3) * n) good = false;
if (good) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> rg;
vector<vector<int>> dp;
int calc(int l, int r) {
if (dp[l][r] != -1) return dp[l][r];
dp[l][r] = 0;
if (l > r) return dp[l][r];
bool add = count(rg[l].begin(), rg[l].end(), r);
dp[l][r] = max(dp[l][r], add + (l + 1 > r ? 0 : calc(l + 1, r)));
for (auto nr : rg[l]) {
if (nr >= r) continue;
dp[l][r] =
max(dp[l][r], add + calc(l, nr) + (nr + 1 > r ? 0 : calc(nr + 1, r)));
}
return dp[l][r];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> l(n), r(n);
vector<int> val;
for (int i = 0; i < n; ++i) {
cin >> l[i] >> r[i];
val.push_back(l[i]);
val.push_back(r[i]);
}
sort(val.begin(), val.end());
val.resize(unique(val.begin(), val.end()) - val.begin());
for (int i = 0; i < n; ++i) {
l[i] = lower_bound(val.begin(), val.end(), l[i]) - val.begin();
r[i] = lower_bound(val.begin(), val.end(), r[i]) - val.begin();
}
int siz = val.size();
dp = vector<vector<int>>(siz, vector<int>(siz, -1));
rg = vector<vector<int>>(siz);
for (int i = 0; i < n; ++i) {
rg[l[i]].push_back(r[i]);
}
cout << calc(0, siz - 1) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, mod = 998244353;
int a[N], b[N], pa[N], w[N], p[N], n, m, ans;
char s[N];
inline int getpa(int x) {
if (pa[x] == x) return x;
int p = getpa(pa[x]);
w[x] ^= w[pa[x]];
return pa[x] = p;
}
inline int link(int a, int b, int c) {
if (getpa(a) != getpa(b)) {
w[pa[a]] = w[a] ^ w[b] ^ c;
pa[pa[a]] = pa[b];
} else if (w[a] ^ w[b] ^ c)
return 0;
return 1;
}
int solve(int A, int B) {
memset(pa, 0, sizeof(pa));
memset(w, 0, sizeof(w));
for (int i = 1; i <= B * 2 + 3; i++) pa[i] = i;
m = 0;
int zero = ++m;
for (int i = 0; i <= B; i++) a[i] = ++m, (i > A ? link(zero, m, 0) : 0);
for (int i = 0; i <= B; i++) b[i] = ++m;
link(zero, a[0], 1), link(zero, b[0], 1);
for (int i = 0, j = A; i < j; i++, j--)
if (!link(a[i], a[j], 0)) return 0;
for (int i = 0, j = B; i < j; i++, j--)
if (!link(b[i], b[j], 0)) return 0;
for (int i = 0; i <= B; i++)
if (s[i] != '?' && !link(a[i], b[i], s[i] - '0')) return 0;
int owo = 0;
for (int i = 1; i <= m; i++) owo += (pa[i] == i);
return p[owo - 1];
}
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
p[0] = 1;
for (int i = 1; i <= n * 2; i++) p[i] = p[i - 1] * 2 % mod;
for (int i = 1; i < n; i++) ans = (ans + solve(i - 1, n - 1)) % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 123, inf = 1e9, mod = 1e9 + 7;
const long long INF = 1e18;
char second[N];
int n, mn;
int main() {
scanf("%s", &second);
n = strlen(second);
mn = inf;
for (int i = 0; i < n; i++) {
if (mn >= second[i])
printf("Mike\n");
else
printf("Ann\n");
mn = min(mn, (int)second[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Maxflow {
struct edge {
int from, to;
long long flow, capacity;
};
int s, t;
vector<edge> edg;
vector<int> g[3111];
int dist[3111], visited[3111];
int cur[3111];
void init() {
edg.clear();
int i;
for (i = 0; i < 3111; i++) {
g[i].clear();
}
}
void addedge(int from, int to, long long capacity) {
edge e1 = edge{from, to, 0ll, capacity};
edge e2 = edge{to, from, 0ll, 0ll};
edg.push_back(e1), edg.push_back(e2);
g[from].push_back((int)edg.size() - 2);
g[to].push_back((int)edg.size() - 1);
}
bool bfs() {
memset(visited, 0, sizeof(visited));
memset(dist, 0, sizeof(dist));
queue<int> q;
q.push(s);
visited[s] = 1;
dist[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < (int)g[v].size(); i++) {
edge &e = edg[g[v][i]];
int nxt = e.to;
if (!visited[nxt] && e.capacity > e.flow) {
dist[nxt] = dist[v] + 1;
q.push(nxt);
visited[nxt] = 1;
}
}
}
return visited[t];
}
long long dfs(int x, long long cp) {
if (x == t || cp == 0) {
return cp;
}
long long flow = 0, newflow;
for (int &y = cur[x]; y < (int)g[x].size(); y++) {
edge &e = edg[g[x][y]];
if (dist[x] + 1 == dist[e.to]) {
long long minn = min(cp, e.capacity - e.flow);
newflow = dfs(e.to, minn);
if (newflow > 0) {
e.flow += newflow;
edg[g[x][y] ^ 1].flow -= newflow;
flow += newflow;
cp -= newflow;
if (cp == 0) {
break;
}
}
}
}
return flow;
}
long long Dinic() {
long long flow = 0;
while (bfs()) {
memset(cur, 0, sizeof(cur));
flow += dfs(s, 10000000000ll);
}
return flow;
}
};
Maxflow mf;
unordered_map<int, vector<int>> hz;
unordered_map<int, vector<int>> vc;
int tx[3111], ty[3111];
vector<pair<pair<int, int>, int>> hs, vs;
int x[3111], y[3111];
set<pair<pair<int, int>, int>> elih, eliv;
set<pair<int, int>> valid;
vector<pair<pair<int, int>, int>> ansh, ansv;
int visited[3111];
void dfs(int v) {
visited[v] = 1;
for (auto idx : mf.g[v]) {
auto e = mf.edg[idx];
if (e.flow != e.capacity && !visited[e.to]) {
dfs(e.to);
}
}
}
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d", &tx[i], &ty[i]);
hz[ty[i]].push_back(tx[i]);
vc[tx[i]].push_back(ty[i]);
x[i] = tx[i], y[i] = ty[i];
valid.insert(make_pair(x[i], y[i]));
}
mf.s = 0, mf.t = 3111 - 1;
auto iter = hz.begin();
while (iter != hz.end()) {
sort(iter->second.begin(), iter->second.end());
for (i = 1; i < (int)iter->second.size(); ++i) {
hs.push_back(make_pair(make_pair(iter->second[i - 1], iter->second[i]),
iter->first));
}
++iter;
}
iter = vc.begin();
while (iter != vc.end()) {
sort(iter->second.begin(), iter->second.end());
for (i = 1; i < (int)iter->second.size(); ++i) {
vs.push_back(make_pair(make_pair(iter->second[i - 1], iter->second[i]),
iter->first));
}
++iter;
}
int sz1 = hs.size(), sz2 = vs.size();
for (i = 1; i <= sz1; ++i) {
mf.addedge(mf.s, i, 1);
}
for (i = 1; i <= sz2; ++i) {
mf.addedge(i + sz1, mf.t, 1);
}
for (i = 1; i <= sz1; ++i) {
for (j = 1; j <= sz2; ++j) {
auto p1 = hs[i - 1], p2 = vs[j - 1];
int x1 = p1.first.first, x2 = p1.first.second, y = p1.second;
int y1 = p2.first.first, y2 = p2.first.second, x = p2.second;
if (x1 <= x && x <= x2 && y1 <= y && y <= y2) {
if (valid.find(make_pair(x, y)) == valid.end()) {
mf.addedge(i, j + sz1, 10000000000ll);
}
}
}
}
mf.Dinic();
dfs(mf.s);
for (auto e : mf.edg) {
if (visited[e.from] && !visited[e.to]) {
if (e.from == mf.s && e.to <= sz1 && e.flow == e.capacity) {
elih.insert(hs[e.to - 1]);
}
if (e.to == mf.t && e.from > sz1 && e.flow == e.capacity) {
eliv.insert(vs[e.from - sz1 - 1]);
}
}
}
iter = hz.begin();
while (iter != hz.end()) {
int low = iter->second[0], high = iter->second[0], y = iter->first;
for (i = 0; i < (int)iter->second.size() - 1; ++i) {
int x1 = iter->second[i], x2 = iter->second[i + 1];
if (elih.find(make_pair(make_pair(x1, x2), y)) == elih.end()) {
high = x2;
} else {
ansh.push_back(make_pair(make_pair(low, high), y));
low = x2, high = x2;
}
}
ansh.push_back(make_pair(make_pair(low, high), y));
++iter;
}
iter = vc.begin();
while (iter != vc.end()) {
int low = iter->second[0], high = iter->second[0], y = iter->first;
for (i = 0; i < (int)iter->second.size() - 1; ++i) {
int x1 = iter->second[i], x2 = iter->second[i + 1];
if (eliv.find(make_pair(make_pair(x1, x2), y)) == eliv.end()) {
high = x2;
} else {
ansv.push_back(make_pair(make_pair(low, high), y));
low = x2, high = x2;
}
}
ansv.push_back(make_pair(make_pair(low, high), y));
++iter;
}
printf("%d\n", (int)ansh.size());
for (auto p : ansh) {
printf("%d %d %d %d\n", p.first.first, p.second, p.first.second, p.second);
}
printf("%d\n", (int)ansv.size());
for (auto p : ansv) {
printf("%d %d %d %d\n", p.second, p.first.first, p.second, p.first.second);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long long f[200011];
long long a[200011];
int n, m;
long long T1[200011 * 4], T2[200011 * 4], T3[200011 * 4];
void init() {
f[0] = f[1] = 1;
for (int i = (2), _b = (200000); i <= _b; i++)
f[i] = (f[i - 1] + f[i - 2]) % 1000000000;
}
void update(int k, int l, int r, int i, long long x) {
if (l > i || r < i) return;
if (r - l + 1 <= 5) {
long long res1 = 0, res2 = 0, res3 = 0, s;
for (int j = (l), _b = (r); j <= _b; j++) {
if (j == i)
s = x;
else
s = a[j];
res1 = (res1 + f[j - l] * s) % 1000000000;
if (j - l >= 2) res2 = (res2 + f[j - l - 2] * s) % 1000000000;
if (j - l >= 1) res3 = (res3 + f[j - l - 1] * s) % 1000000000;
}
T1[k] = res1;
T2[k] = res2;
T3[k] = res3;
return;
}
int m = (l + r) / 2;
update(k * 2, l, m, i, x);
update(k * 2 + 1, m + 1, r, i, x);
T1[k] = (T1[k] + (x - a[i]) * f[i - l]) % 1000000000;
if (i - l >= 2) T2[k] = (T2[k] + (x - a[i]) * f[i - l - 2]) % 1000000000;
if (i - l >= 1) T3[k] = (T3[k] + (x - a[i]) * f[i - l - 1]) % 1000000000;
}
long long get(int k, int l, int r, int i, int j) {
if (l > j || r < i) return 0;
if (i <= l && j >= r) {
if (r - l + 1 <= 5) {
long long res = 0;
for (int t = (l), _b = (r); t <= _b; t++) {
res = (res + f[t - i] * a[t]) % 1000000000;
}
return res;
}
long long res = T1[k];
long long x2 = f[l - i] - 1;
long long x3 = f[l + 1 - i] - 1;
res = (res + T2[k] * x2 + T3[k] * x3 + x2 * a[l]) % 1000000000;
return res;
}
int m = (l + r) / 2;
return (get(k * 2, l, m, i, j) + get(k * 2 + 1, m + 1, r, i, j)) % 1000000000;
}
long long tinh(int l, int r) {
long long res = 0;
for (int i = (l), _b = (r); i <= _b; i++)
res = (res + f[i - l] * a[i]) % 1000000000;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
init();
for (int i = (1), _b = (n); i <= _b; i++) {
int x;
cin >> x;
update(1, 1, n, i, x);
a[i] = x;
}
while (m--) {
int i, x, type, l, r;
cin >> type;
if (type == 1) {
cin >> i >> x;
update(1, 1, n, i, x);
a[i] = x;
} else {
cin >> l >> r;
long long res = get(1, 1, n, l, r);
cout << (res + 1000000000) % 1000000000 << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = (int)1e9 + 7;
const int N = (1 << 22) + 100;
bool vis[N], vis1[N];
int pre[N];
int Find(int x) {
if (x == pre[x]) return x;
return pre[x] = Find(pre[x]);
}
int main() {
int n, m, t, to, u, v;
scanf("%d%d", &n, &m);
int Max = (1 << n) - 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &t);
vis[t] = 1;
}
for (int i = 0; i <= Max; i++) {
vis1[i] |= vis[i];
if (vis1[i]) {
for (int j = 0; j < n; j++) vis1[i | (1 << j)] = 1;
}
}
bool f = 0;
for (int i = 0; i <= Max; i++) pre[i] = i;
for (int i = Max; i >= 0; i--) {
if (!vis1[i]) {
pre[i] = -1;
continue;
}
f = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) continue;
to = i | (1 << j);
if (pre[to] != -1) {
u = Find(i);
v = Find(to);
pre[u] = v;
f = 1;
}
}
if (!f) {
to = Max ^ i;
if (vis1[to]) {
u = Find(i);
v = Find(to);
pre[u] = v;
} else
pre[i] = -1;
}
}
int ans = 0;
for (int i = 0; i <= Max; i++) {
if (vis[i] && pre[i] == -1) ans++;
if (pre[i] == i) ans++;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int a[maxn], n;
int solve(int w, int l, int r) {
if (l > r) return 0;
if (w < 0) return 1;
int x = 1 << w, mid = r + 1;
for (int i = l; i <= r; i++)
if (x & a[i]) {
mid = i;
break;
}
int z = solve(w - 1, l, mid - 1);
int zz = solve(w - 1, mid, r);
int num = max(z + min(r - mid + 1, 1), zz + min(mid - l, 1));
return num;
}
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 1, a + 1 + n);
cout << n - solve(30, 1, n) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100100];
int p[100100];
long long tt[100100] = {0};
int main() {
int i, j, n, m;
long long ans, ori = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d", &p[i]);
if (i) {
if (p[i] != p[i - 1]) {
g[p[i - 1]].push_back(p[i]);
g[p[i]].push_back(p[i - 1]);
tt[p[i - 1]] +=
((p[i] - p[i - 1]) > 0 ? (p[i] - p[i - 1]) : -(p[i] - p[i - 1]));
tt[p[i]] +=
((p[i] - p[i - 1]) > 0 ? (p[i] - p[i - 1]) : -(p[i] - p[i - 1]));
ori += ((p[i] - p[i - 1]) > 0 ? (p[i] - p[i - 1]) : -(p[i] - p[i - 1]));
}
}
}
ans = ori;
for (i = 1; i <= n; i++) {
sort(g[i].begin(), g[i].end());
for (j = 0; j < g[i].size() / 2; j++) {
tt[i] -= g[i][g[i].size() - 1 - j] - g[i][j];
}
if (ori - tt[i] < ans) ans = ori - tt[i];
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int x, y, z;
cin >> x >> y >> z;
bool can = 1;
bool par = x ^ y ^ z;
if (x != y && y != z && z != x) can = 0;
int ma = max(x, max(y, z));
int mi = min(x, min(y, z));
int cnt = 0;
if (ma == x) cnt++;
if (ma == y) cnt++;
if (ma == z) cnt++;
if (cnt < 2) can = 0;
if (can) {
cout << "YES\n" << ma << ' ' << mi << ' ' << mi;
} else
cout << "NO";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111;
int n;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
cin >> n;
if (n < 5) {
cout << "No solution"
<< "\n";
return 0;
}
cout << setiosflags(ios::fixed);
cout << setprecision(4);
double a = 2 * acos(-1) / n, len = 100, x = 0, y = 0, ang = 0;
for (int i = (1); i < (n); ++i) {
if (i > 1) {
ang += a;
x += len * cos(ang);
y += len * sin(ang);
len += 0.002;
}
cout << x << " " << y << "\n";
}
assert(x + y / tan(a) < 0);
cout << x + y / tan(a) << " 0.0000"
<< "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, w;
};
const int oo = (int)1e9 + 7;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
edge e[100005];
int d[100005];
vector<pair<int, int> > adj[100005];
int n, m, s, l, ans;
void dijkstra() {
pair<int, int> top, v;
int u, len;
for (int i = 1; i <= n; i++) d[i] = oo;
d[s] = 0;
pq.push(pair<int, int>(0, s));
while (!pq.empty()) {
top = pq.top();
pq.pop();
if (top.first != d[top.second]) continue;
len = top.first;
u = top.second;
for (int i = 0; i < (int)adj[u].size(); i++) {
v = adj[u][i];
if (d[v.first] > d[u] + v.second) {
d[v.first] = d[u] + v.second;
pq.push(pair<int, int>(d[v.first], v.first));
}
}
}
}
void solve() {
int x, y, u, v;
for (int i = 1; i <= n; i++)
if (d[i] == l) ans++;
for (int i = 0; i < m; i++) {
u = e[i].u;
v = e[i].v;
x = y = oo;
if (d[v] + e[i].w > d[u] && d[u] < l) {
x = l - d[u];
if (x >= e[i].w || e[i].w - x + d[v] < l) x = oo;
}
if (d[u] + e[i].w > d[v] && d[v] < l) {
y = e[i].w - (l - d[v]);
if (y <= 0 || y + d[u] < l) y = oo;
}
if (x != oo) ans++;
if (y != oo && y != x) ans++;
}
printf("%d\n", ans);
}
int main() {
int u, v, w;
if (0) {
freopen("a.inp", "r", stdin);
};
scanf("%d%d%d", &n, &m, &s);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
adj[e[i].u].push_back(pair<int, int>(e[i].v, e[i].w));
adj[e[i].v].push_back(pair<int, int>(e[i].u, e[i].w));
}
scanf("%d", &l);
dijkstra();
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_V = 100000;
vector<int> adjlist[MAX_V + 5];
int N, x, y, component, sz, deg[MAX_V + 5], A[MAX_V + 5];
bool visit[MAX_V + 5];
void dfs(int u) {
visit[u] = 1;
for (int i = 0; i < (int)adjlist[u].size(); i++) {
int v = adjlist[u][i];
if (!visit[v]) dfs(v);
}
}
bool edge_exists(int u, int v) {
for (int i = 0; i < (int)adjlist[u].size(); i++)
if (adjlist[u][i] == v) return 1;
return 0;
}
int main() {
scanf("%d", &N);
memset(deg, 0, sizeof deg);
for (int i = 0; i < (int)2 * N; i++) {
scanf("%d %d", &x, &y);
adjlist[x].push_back(y);
adjlist[y].push_back(x);
deg[x]++, deg[y]++;
}
for (int u = (int)1; u <= (int)N; u++)
if (deg[u] != 4) {
puts("-1");
return 0;
}
memset(visit, 0, sizeof visit);
component = 0;
for (int u = (int)1; u <= (int)N; u++)
if (!visit[u]) {
dfs(u);
component++;
}
if (component > 1) {
puts("-1");
return 0;
}
if (N == 5) {
puts("1 2 3 4 5");
} else if (N == 6) {
for (int i = (int)1; i <= (int)N; i++) A[i] = i;
bool found = 0;
do {
bool ok = 1;
for (int i = (int)1; i <= (int)N; i++) {
int next1 = (i < N) ? i + 1 : 1;
int next2 = (i < N - 1) ? i + 2 : i + 2 - N;
if (!edge_exists(A[i], A[next1])) {
ok = 0;
break;
}
if (!edge_exists(A[i], A[next2])) {
ok = 0;
break;
}
}
if (!ok) continue;
found = 1;
for (int i = 0; i < (int)N; i++) {
if (i) printf(" ");
printf("%d", A[i + 1]);
}
puts("");
} while (next_permutation(A + 1, A + N + 1) && !found);
if (!found) puts("-1");
} else {
for (int u = (int)1; u <= (int)N; u++) {
int counter1 = 0, counter2 = 0;
for (int i = 0; i < (int)adjlist[u].size(); i++) {
int cnt = 0;
for (int j = 0; j < (int)adjlist[u].size(); j++)
if (edge_exists(adjlist[u][i], adjlist[u][j])) cnt++;
if (cnt == 1)
counter1++;
else if (cnt == 2)
counter2++;
}
if (counter1 != 2 || counter2 != 2) {
puts("-1");
return 0;
}
}
sz = 0;
for (int i = 0; i < (int)adjlist[1].size(); i++) {
int cnt = 0;
for (int j = 0; j < (int)adjlist[1].size(); j++)
if (edge_exists(adjlist[1][i], adjlist[1][j])) cnt++;
if (cnt == 2) A[sz++] = adjlist[1][i];
if (sz == 1) A[sz++] = 1;
}
while (sz < N) {
for (int i = 0; i < (int)adjlist[A[sz - 1]].size(); i++) {
int u = adjlist[A[sz - 1]][i];
if (edge_exists(A[sz - 2], u) && u != A[sz - 3]) {
A[sz++] = u;
break;
}
}
}
for (int i = 0; i < (int)sz; i++) {
if (i) printf(" ");
printf("%d", A[i]);
}
puts("");
}
}
| 6 |
#include <time.h>
#include <iostream>
#include <map>
#include <algorithm>
#include <queue>
#include <set>
#include <vector>
#include <iomanip>
#include <bitset>
using namespace std;
map <long long , int> got;
long long n , kq = 0 , a[300001] , cnt[101] = {0};
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand (time(NULL));
int test;
cin >> test;
while (test--)
{
int d;
cin >> n ;
int cnt = 1000;
for (int i = 1 ; i <= 2 * n ; i++)
{
cin >> a[i];
}
got.clear();
int len = 2*n;
long long cur = 0;
int False = 0;
sort(a + 1 , a + 1 + 2 * n);
for (int i = 2 * n ; i >= 1 ; i -= 2)
{
if (a[i] != a[i-1]) False = 1;
if (a[i] % 2 != 0) False = 1;
long long t = a[i] - cur;
if (t % (len) != 0)
{
False = 1;
}
if (t <= 0)
{
False = 1;
}
cur += 2ll * (t / (len));
got[t / len]++;
if (got[t/len] > 1) False = 1;
//cout <<i<<" "<<t/(len)<<" "<<t<<" "<<'\n';
len-=2;
}
if (False == 0) cout <<"YES"<<'\n';
else cout <<"NO"<<'\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int mt[7][6] = {{0, 0, 1, 0, 1, 1}, {0, 1, 0, 1, 0, 1}, {0, 1, 1, 1, 1, 0},
{1, 0, 0, 1, 1, 0}, {1, 0, 1, 1, 0, 1}, {1, 1, 0, 0, 1, 1},
{1, 1, 1, 0, 0, 0}},
b[7], x[7], mat[6][7], ansl;
char ret[7][5] = {"aaab", "aaba", "aabb", "abaa", "abab", "abba", "abbb"};
void show() {
for (int j = 0; j < 6; j++) {
for (int k = 0; k < 7; k++) printf("%d ", mat[j][k]);
printf("%d\n", b[j]);
}
puts("");
}
int solve() {
int id;
for (int i = 0; i < 6; i++) {
if (mat[i][i] == 0) {
id = -1;
for (int j = i + 1; j < 6; j++)
if (mat[j][i]) {
id = j;
break;
}
if (id == -1) return 0;
for (int j = 0; j < 7; j++) swap(mat[i][j], mat[id][j]);
swap(b[id], b[i]);
}
int x = mat[i][i];
for (int j = i; j < 7; j++)
if (mat[i][j] % x)
return 0;
else
mat[i][j] /= x;
if (b[i] % x) return 0;
b[i] /= x;
for (int j = 0; j < 6; j++) {
if (j == i) continue;
int d = mat[j][i];
for (int k = i; k < 7; k++) mat[j][k] -= d * mat[i][k];
b[j] -= d * b[i];
}
}
int ans = 100 * 1000000, tmp, tag, xx;
for (int i = 0; i < 1000000; i++) {
tmp = i;
tag = 1;
for (int j = 0; j < 6; j++) {
x[j] = b[j] - mat[j][6] * i;
if (x[j] < 0) tag = 0;
tmp += x[j];
}
if (tag == 0) continue;
if (ans > tmp) ans = tmp, xx = i;
}
if (ans >= 1000000) return 0;
for (int j = 0; j < 6; j++) x[j] = b[j] - mat[j][6] * xx;
x[6] = xx;
ansl = ans;
return 1;
}
int main() {
for (int i = 0; i < 6; i++)
for (int j = 0; j < 7; j++) mat[i][j] = mt[j][i];
while (scanf("%d", &b[0]) != EOF) {
for (int i = 1; i < 7; i++) scanf("%d", &b[i]);
if (solve()) {
printf("%d\n", ansl);
for (int i = 0; i < 4; i++, puts(""))
for (int j = 0; j < 7; j++)
for (int k = 0; k < x[j]; k++) printf("%c", ret[j][i]);
} else
puts("-1");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, num1[200002], num2[200002];
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &num1[i]);
for (i = 0; i < n; i++) scanf("%d", &num2[i]);
j = 0;
for (i = 0; i < n; i++) {
while (1) {
if (j == n) break;
if (num1[i] == num2[j]) break;
j++;
}
if (j == n) break;
}
printf("%d\n", n - i);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int N = 2e5 + 10;
const long double eps = 1e-10;
int dcmp(long double x) { return x < -eps ? -1 : (x > eps); }
struct item {
int id;
long double v;
item(int u, long double x) : id(u), v(x) {}
friend bool operator<(item A, item B) {
if (dcmp(A.v - B.v)) return A.v < B.v;
return A.id < B.id;
}
};
set<item> A, B;
int rb[N], p[N], c[N];
int n, t, q;
long double ans;
inline long double getA(int x) {
return (long double)p[x] * rb[x] / (rb[x] + c[x]) / (rb[x] + c[x] + 1);
}
inline long double getB(int x) {
return (long double)p[x] * rb[x] / (rb[x] + c[x]) / (rb[x] + c[x] - 1);
}
int cnt;
void Ins(int u) {
if (c[u] < rb[u]) A.insert(item(u, getA(u)));
if (c[u]) B.insert(item(u, getB(u)));
}
void Del(int u) {
if (c[u] < rb[u]) A.erase(item(u, getA(u)));
if (c[u]) B.erase(item(u, getB(u)));
}
void ins(int u) {
Del(u);
ans += getA(u);
c[u]++, t--;
Ins(u);
}
void del(int u) {
Del(u);
ans -= getB(u);
c[u]--, t++;
Ins(u);
}
int main() {
rd(n), rd(t), rd(q);
for (int i = 1; i <= n; ++i) rd(p[i]);
for (int i = 1; i <= n; ++i) rd(rb[i]), Ins(i);
while (t && !A.empty()) ins(A.rbegin()->id);
while (q--) {
int ty, x;
rd(ty), rd(x);
if (c[x] == rb[x] && ty == 2) del(x);
Del(x), ans -= (long double)p[x] * c[x] / (rb[x] + c[x]);
if (ty == 1)
rb[x]++;
else
rb[x]--;
Ins(x), ans += (long double)p[x] * c[x] / (rb[x] + c[x]);
if (t > 0 && !A.empty()) ins(A.rbegin()->id);
if (!A.empty() && !B.empty() &&
dcmp((A.rbegin()->v) - (B.begin()->v)) > 0) {
int x = B.begin()->id, y = A.rbegin()->id;
del(x), ins(y);
}
printf("%.10Lf\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int f[(int)1e5 + 4], a[(int)1e5 + 4], b[(int)1e5 + 4];
int mark[(int)1e5 + 5] = {};
map<int, int> ara;
int main() {
int n, m;
fs(n);
fs(m);
for (int i = 1; i < n + 1; i++) {
fs(f[i]);
ara[f[i]] = i;
mark[f[i]]++;
}
for (int i = 1; i < m + 1; i++) fs(b[i]);
for (int i = 1; i <= m; i++) {
int ans = ara[b[i]];
if (ans == 0) {
cout << "Impossible" << endl;
return 0;
}
a[i] = ans;
}
for (int i = 1; i <= m; i++) {
if (mark[b[i]] > 1) {
cout << "Ambiguity" << endl;
return 0;
}
}
cout << "Possible" << endl;
for (int i = 1; i <= m; i++) cout << a[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> arr;
int main() {
int n;
cin >> n;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];
int ans = 0;
for (int i = 0; i < (int)arr.size() - 1; i++) {
for (int j = i + 1; j < (int)arr.size(); j++) {
if (atoll((arr[i] + arr[j]).c_str()) % 3 == 0) {
ans++;
arr.erase(arr.begin() + j);
arr.erase(arr.begin() + i);
i--;
break;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[105];
int ok(int a, int b) {
for (int i = a; i < b; ++i)
if (!isalpha(s[i]) && !isdigit(s[i]) && s[i] != '_') return 0;
if (b - a > 16 || a == b) return 0;
return 1;
}
int check() {
int p = -1, n = strlen(s);
for (int i = 0; i < n; ++i)
if (s[i] == '@') {
if (p != -1) return 0;
p = i;
}
if (p == -1) return 0;
if (!ok(0, p)) return 0;
int l = p + 1, f = p;
while (f < n && s[f] != '/') f++;
if (f < n && !ok(f + 1, n)) return 0;
if (f - l > 32 || f - l == 0) return 0;
s[f] = '.';
for (int i = p + 1; i <= f; ++i)
if (s[i] == '.') {
if (!ok(l, i)) return 0;
l = i + 1;
}
return 1;
}
int main(void) {
while (scanf("%s", s) == 1)
if (check())
puts("YES");
else
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int stu[10001];
int main() {
int n;
cin >> n;
int p[10001];
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
for (int i = 1; i <= n; i++) {
memset(stu, 0, sizeof(stu));
int curr = i;
for (int j = 1; j <= n + 1; j++) {
stu[curr]++;
if (stu[curr] >= 2) {
cout << curr << ' ';
break;
} else
curr = p[curr];
}
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {0, -1, 0, 1, -1, 1, 1, -1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1};
const double eps = 1e-9;
int main() {
int n, m;
cin >> m >> n;
bool p[50];
memset(p, false, sizeof(p));
for (int i = 0; i < n; ++i) {
cout << m << endl << flush;
int res;
cin >> res;
if (res == 0) return 0;
if (res == -1) p[i] = true;
}
int beg = 0, end = m;
int step = 0;
while (beg + 1 < end) {
int med = (beg + end) / 2;
cout << med << endl << flush;
int res;
cin >> res;
if (res == -2) return 0;
if (res == 0) return 0;
if (res == 1 && !p[step % n])
end = med;
else if (res == -1 && p[step % n])
end = med;
else
beg = med;
step++;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[11][101][101];
int n, q, c;
int main() {
cin >> n >> q >> c;
for (int i = 0; i < n; i++) {
int x, y, s;
cin >> x >> y >> s;
cnt[s][x][y]++;
}
for (int p = 0; p <= c; p++) {
for (int i = 1; i < 101; i++) {
for (int j = 1; j < 101; j++) {
cnt[p][i][j] +=
cnt[p][i - 1][j] + cnt[p][i][j - 1] - cnt[p][i - 1][j - 1];
}
}
}
for (int i = 0; i < q; i++) {
int t, x1, y1, x2, y2;
cin >> t >> x1 >> y1 >> x2 >> y2;
int ans = 0;
for (int p = 0; p <= c; p++) {
int bright = (p + t) % (c + 1);
int amount = cnt[p][x2][y2] - cnt[p][x1 - 1][y2] - cnt[p][x2][y1 - 1] +
cnt[p][x1 - 1][y1 - 1];
ans += bright * amount;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[300005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
s[0] = 'a';
s[n + 1] = 'a';
int ans = 0;
for (int i = 1; i <= n; i++)
if (s[i] == '.' && s[i - 1] == '.') ans++;
for (int j = 0; j < m; j++) {
int a;
char b;
scanf("%d %c", &a, &b);
if (b == '.') {
if (s[a] == '.')
printf("%d\n", ans);
else {
if (s[a - 1] == '.') ans++;
if (s[a + 1] == '.') ans++;
printf("%d\n", ans);
}
s[a] = b;
} else {
if (s[a] == '.') {
if (s[a - 1] == '.') ans--;
if (s[a + 1] == '.') ans--;
printf("%d\n", ans);
} else {
printf("%d\n", ans);
}
s[a] = b;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long INF = mod * mod;
const long double eps = 1e-6;
const long double pi = acos(-1.0);
int query(string s) {
cout << s << endl;
int x;
cin >> x;
return x;
}
void solve() {
int z = query("a");
if (z == 0) return;
if (z == 300) {
string ans;
for (int i = 0; i < 300; i++) ans.push_back('b');
cout << ans << endl;
cin >> z;
return;
}
int n = z + 1;
string u;
for (int i = 0; i < n; i++) {
u.push_back('a');
}
int ori = query(u);
if (ori == n) {
string ans;
for (int i = 0; i < n - 1; i++) {
ans.push_back('b');
}
cout << ans << endl;
cin >> z;
return;
}
if (ori == 0) return;
string res;
res.resize(n);
int tmp = 0;
for (int i = 0; i < n - 1; i++) {
u[i] = 'b';
z = query(u);
if (z == 0) return;
if (z < ori) {
res[i] = 'b';
tmp++;
} else
res[i] = 'a';
u[i] = 'a';
}
if (tmp == ori)
res[n - 1] = 'a';
else
res[n - 1] = 'b';
cout << res << endl;
cin >> z;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char arr[505][505];
int main() {
int n, m, a = 0, b = 0, tmp, fuck;
int i, j, k, flag = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", arr[i]);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (arr[i][j] == 'X') {
for (k = 0; j + k < m && arr[i][j + k] == 'X'; k++) a++;
tmp = j + k - 1;
for (k = 0; i + k < n && arr[i + k][j] == 'X'; k++) b++;
fuck = i + k - 1;
for (k = 0; i + k < n && arr[i + k][tmp] == 'X'; k++)
;
if (k != b) {
printf("NO\n");
return 0;
}
for (k = 0; j + k < m && arr[fuck][j + k] == 'X'; k++)
;
if (k != a) {
printf("NO\n");
return 0;
}
flag = 1;
break;
}
}
if (flag) break;
}
int x, y;
for (x = 0; x < i; x++)
for (y = 0; y < m; y++)
if (arr[x][y] == 'X') {
printf("NO\n");
return 0;
}
for (y = 0; y < j; y++)
for (x = 0; x < n; x++)
if (arr[x][y] == 'X') {
printf("NO\n");
return 0;
}
for (y = j + a; y < m; y++)
for (x = 0; x < n; x++)
if (arr[x][y] == 'X') {
printf("NO\n");
return 0;
}
for (x = i + b; x < n; x++)
for (y = 0; y < m; y++)
if (arr[x][y] == 'X') {
printf("NO\n");
return 0;
}
for (x = i + 1; x < i + b - 1; x++)
for (y = j; y < j + a; y++)
if (arr[x][y] != 'X') {
printf("NO\n");
return 0;
}
for (y = j + 1; y < j + a - 1; y++)
for (x = i; x < i + b; x++)
if (arr[x][y] != 'X') {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
int mp[111][111];
int main() {
int n, m, x, tp;
while (scanf("%d %d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &mp[i][j]);
}
}
int all = n, ans = n, no;
if (n & 1) {
printf("%d\n", n);
continue;
} else {
while (1) {
no = 0;
for (int i = 1; i <= all / 2; i++) {
for (int j = 1; j <= m; j++) {
if (mp[i][j] != mp[all + 1 - i][j]) no = 1;
if (no) break;
}
if (no) break;
}
if (no) break;
all /= 2, ans /= 2;
if (all & 1) break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
int t;
cin>>t;
while(t--)
{
int n,i;
int ans=0;
cin>>n;
vector<int>a(n,0);
unordered_map<int,int>f;
for(i=0;i<n;i++)
{
cin>>a[i];
f[a[i]]++;
}
for(auto x:f)
{
ans=max(ans,x.second);
}
cout<<ans<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using max_pq = priority_queue<T>;
template <class T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
long long int x, y;
template <class T>
T gcd(T a, T b) {
if (a == 0) {
x = 0, y = 1;
return b;
}
T gc = gcd(b % a, a);
T temp;
temp = x;
x = y - (b / a) * temp;
y = temp;
return gc;
}
long long int po(long long int a, long long int x, long long int m) {
if (x == 0) {
return 1;
}
long long int ans = 1;
long long int k = 1;
while (k <= x) {
if (x & k) {
ans = ((ans * a) % m);
}
k <<= 1;
a *= a;
a %= m;
}
return ans;
}
set<int> yc[1001];
set<int> xc[1001];
string second[1001];
unordered_map<int, int> mark;
unordered_map<int, int> level;
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
int n, m, ki;
cin >> n >> m >> ki;
int i, j;
for (i = 0; i < n; i++) {
cin >> second[i];
for (j = 0; j < m; j++) {
xc[i].insert(j);
yc[j].insert(i);
}
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (second[i][j] == '#') {
mark[i * 1000 + j] = 1;
} else
mark[i * 1000 + j] = 0;
level[i * 1000 + j] = -1;
}
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1--;
y1--;
x2--;
y2--;
queue<pair<int, int>> bfs;
xc[x1].erase(y1);
yc[y1].erase(x1);
level[x1 * 1000 + y1] = 0;
bfs.push({x1, y1});
while (!bfs.empty()) {
auto k = bfs.front();
bfs.pop();
set<int>::iterator j = xc[k.first].lower_bound(k.second);
set<int>::iterator second = j;
vector<int> temp;
while (second != xc[k.first].end()) {
if (mark[k.first * 1000 + *second] || (*second - k.second) > ki) break;
bfs.push({k.first, *second});
level[k.first * 1000 + *second] = level[k.first * 1000 + k.second] + 1;
yc[*second].erase(k.first);
temp.push_back(*second);
second++;
}
second = j;
while (second != xc[k.first].begin()) {
second--;
if (mark[k.first * 1000 + *second] || (k.second - *second) > ki) break;
bfs.push({k.first, *second});
level[k.first * 1000 + *second] = level[k.first * 1000 + k.second] + 1;
yc[*second].erase(k.first);
temp.push_back(*second);
}
for (auto u : temp) xc[k.first].erase(u);
j = yc[k.second].lower_bound(k.first);
second = j;
temp.clear();
while (second != yc[k.second].end()) {
if (mark[(*second) * 1000 + k.second] || (*second - k.first) > ki) break;
bfs.push({*second, k.second});
level[(*second) * 1000 + k.second] = level[k.first * 1000 + k.second] + 1;
xc[*second].erase(k.second);
temp.push_back(*second);
second++;
}
second = j;
while (second != yc[k.second].begin()) {
second--;
if (mark[(*second) * 1000 + k.second] || (k.first - *second) > ki) break;
bfs.push({*second, k.second});
level[(*second) * 1000 + k.second] = level[k.first * 1000 + k.second] + 1;
xc[*second].erase(k.second);
temp.push_back(*second);
}
for (auto u : temp) yc[k.second].erase(u);
}
cout << level[x2 * 1000 + y2];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
map<long long, int> d;
int main() {
cin >> n;
long long sum = 0;
int ans = n - 1;
for (int i = 0; i < n; i++) {
cin >> t;
sum += t;
d[sum]++;
ans = min(ans, n - d[sum]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, a, b, c, I = 0, p, k, M;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
int A[n];
for (int y = 0; y < n; y++) {
cin >> A[y];
}
a = 0;
b = 0;
c = 0;
p = 2000000000;
k = -1;
I = 0;
M = 0;
while (a + b + c <= n / 2) {
if (a + b + c == n / 2) {
if (k == 2 && p != A[I]) {
M = a + b + c;
}
break;
}
if (A[I] == p) {
if (k == 0) {
a++;
} else if (k == 1) {
b++;
} else {
c++;
}
} else {
if (k <= 1) {
if (k == 1 && b > a) {
k++;
} else if (k != 1) {
k++;
}
} else {
M = a + b + c;
}
if (k == 0) {
a++;
} else if (k == 1) {
b++;
} else {
c++;
}
p = A[I];
}
I++;
}
if (M == 0 || M - a - b <= a) {
cout << "0 0 0"
<< "\n";
} else {
cout << a << " " << b << " " << M - a - b << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int main() {
int n;
cin >> n;
int arr[N + 1];
int x, y;
memset(arr, -1, sizeof(arr));
for (int i = 1; i <= n; i++) {
cin >> x >> y;
int t = 0;
if (y == 0) {
for (int j = 1; j * j <= x; j++) {
if (x % j == 0) {
if (x / j == j)
t++, arr[j] = i;
else
t += 2, arr[j] = i, arr[x / j] = i;
}
}
cout << t << endl;
} else {
for (int j = 1; j * j <= x; j++) {
if (x % j == 0) {
if (x / j == j) {
if (arr[j] < i - y) t++;
arr[j] = i;
} else {
if (arr[j] < i - y) t++;
arr[j] = i;
if (arr[x / j] < i - y) t++;
arr[x / j] = i;
}
}
}
cout << t << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
int k = sqrt(n);
while (n % k != 0) k--;
cout << k << " " << n / k << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[2111], tp = 0;
void dfs(int pre, int dig, int sum) {
if (dig == 9) {
if (!sum) return;
x[tp++] = sum;
return;
}
if (pre == 0) {
dfs(0, dig + 1, sum);
}
dfs(4, dig + 1, sum * 10 + 4);
dfs(7, dig + 1, sum * 10 + 7);
}
double turn(int x, int y, int a, int b) {
int l = max(x, a), r = min(y, b);
if (l > r)
return 0.0;
else
return r - l + 1;
}
int main() {
int l, r, a, b, k;
scanf("%d %d %d %d %d", &l, &r, &a, &b, &k);
x[tp++] = 0;
x[tp++] = 1100000000;
dfs(0, 0, 0);
sort(x, x + tp);
double ans = 0;
for (int i = 1; i + k - 1 < tp - 1; i++) {
if (k != 1)
ans += turn(x[i - 1] + 1, x[i], l, r) *
turn(x[i + k - 1], x[i + k] - 1, a, b) +
turn(x[i - 1] + 1, x[i], a, b) *
turn(x[i + k - 1], x[i + k] - 1, l, r);
else {
ans += turn(x[i - 1] + 1, x[i], l, r) *
turn(x[i + k - 1], x[i + k] - 1, a, b) +
turn(x[i - 1] + 1, x[i], a, b) *
turn(x[i + k - 1], x[i + k] - 1, l, r);
if (x[i] >= l && x[i] <= r && x[i] >= a && x[i] <= b) ans -= 1;
}
}
printf("%.10f\n", ans / (1.0 * (r - l + 1) * (b - a + 1)));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
int main() {
string str;
cin >> str;
vector<long long> v;
vector<char> cv;
for (long long i = 0; i < str.size(); i++) {
long long c = 0;
long long j = i;
while (j < str.size() && str[j] == str[i]) {
c++;
j++;
}
v.push_back(c);
cv.push_back(str[i]);
--j;
i = j;
}
long long op = 0;
while (1) {
if (v.size() <= 1) break;
vector<long long> tem_v;
vector<char> tem_cv;
for (long long i = 0; i < v.size(); i++) {
long long bad = 2;
if (i == 0 || i + 1 == v.size()) {
bad = 1;
}
if (v[i] > bad) {
if (tem_cv.size() && tem_cv.back() == cv[i]) {
long long t = tem_v.back() + v[i] - bad;
tem_v.pop_back();
tem_v.push_back(t);
} else {
tem_v.push_back(v[i] - bad);
tem_cv.push_back(cv[i]);
}
}
}
op++;
v = tem_v;
cv = tem_cv;
}
cout << op << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int slot_mx, slot_mn, n;
long long k;
int a[1000005], b[1000005];
vector<int> mxa, mxb;
long long p(int x) { return (long long)x * (x + 1); }
long long sum(int l, int r) { return p(r) - p(l - 1); }
long long getmax(int l, int r, int slot_mn, int slot_mx) {
int nxl = l + slot_mn / 2;
bool halfl = slot_mn & 1;
int nxr = r - slot_mx / 2;
bool halfr = slot_mx & 1;
return sum(nxr + 1, r) + (halfr ? nxr : 0) + sum(nxl, nxr) -
(halfl ? nxl : 0);
}
int get_mx_b() {
int res = mxb.back();
mxb.pop_back();
return res;
}
int get_mx_a() {
int res = mxa.back();
mxa.pop_back();
return res;
}
void solve(int cur, long long k) {
if (cur > n) return;
if (slot_mx >= 2) {
long long mx = getmax(cur + 1, n, slot_mn, slot_mx - 2);
if (mx >= k - 2 * cur) {
int ia = get_mx_a();
int ib = get_mx_b();
a[ia] = cur;
b[ib] = cur;
slot_mx -= 2;
solve(cur + 1, k - 2 * cur);
return;
}
}
long long mx = getmax(cur + 1, n, slot_mn - 1, slot_mx);
if (mx >= k - cur) {
int ia = slot_mn;
int ib = slot_mn--;
a[ia] = cur;
b[ib] = cur;
solve(cur + 1, k - cur);
return;
}
int ia = slot_mn--;
int ib = slot_mn--;
a[ia] = cur;
b[ib] = cur;
mxa.push_back(ib);
mxb.push_back(ia);
slot_mx += 2;
solve(cur + 1, k);
}
int main() {
scanf("%d %lld", &n, &k);
long long mn = (long long)n * (n + 1) / 2;
long long mx = getmax(1, n, n, 0);
if (mn > k) {
printf("-1");
return 0;
}
slot_mn = n;
solve(1, min(k, mx));
printf("%lld\n", min(k, mx));
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
for (int i = 1; i <= n; i++) printf("%d ", b[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, t, mod = 1000000007;
long long int dp[2000006][2];
int main() {
for (int i = 3; i <= 2000000; i++) {
dp[i][1] = (2 * dp[i - 2][0] + dp[i - 1][0] + 4) % mod;
dp[i][0] = (2 * max(dp[i - 2][1], dp[i - 2][0]) +
max(dp[i - 1][0], dp[i - 1][1])) %
mod;
}
cin >> t;
while (t--) {
cin >> n;
cout << max(dp[n][0], dp[n][1]) << endl;
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int inf = 1e9 + 7;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0') ch = getchar();
while (ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x;
}
long double x, y, z;
int main() {
cin >> x >> y >> z;
long double tx = log2(x), ty = log2(y), tz = log2(z);
long double ans = tx * pow(y, z);
int mj = 1;
long double res = tx * pow(z, y);
if (res > ans) {
ans = res;
mj = 2;
}
res = tx * y * z;
if (res > ans) {
ans = res;
mj = 3;
}
res = ty * pow(x, z);
if (res > ans) {
ans = res;
mj = 5;
}
res = ty * pow(z, x);
if (res > ans) {
ans = res;
mj = 6;
}
res = ty * x * z;
if (res > ans) {
ans = res;
mj = 7;
}
res = tz * pow(x, y);
if (res > ans) {
ans = res;
mj = 9;
}
res = tz * pow(y, x);
if (res > ans) {
ans = res;
mj = 10;
}
res = tz * x * y;
if (res > ans) {
ans = res;
mj = 11;
}
if (mj == 1)
puts("x^y^z");
else if (mj == 2)
puts("x^z^y");
else if (mj == 3)
puts("(x^y)^z");
else if (mj == 5)
puts("y^x^z");
else if (mj == 6)
puts("y^z^x");
else if (mj == 7)
puts("(y^x)^z");
else if (mj == 9)
puts("z^x^y");
else if (mj == 10)
puts("z^y^x");
else
puts("(z^x)^y");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Point {
long long x, y;
Point(const long long &x = 0, const long long &y = 0) : x(x), y(y) {}
Point operator+(const Point &B) const { return Point(x + B.x, y + B.y); }
Point operator-(const Point &B) const { return Point(x - B.x, y - B.y); }
long long operator*(const Point &B) const { return x * B.y - y * B.x; }
} P[100005];
int F[100005];
int Find(int u) { return !F[u] ? u : F[u] = Find(F[u]); }
vector<pair<double, int> > G[100005];
int sz[100005], sx[100005], ty[100005];
void dfs(int u, int ff) {
sz[u] = 1;
for (int i = 0, v; i < G[u].size() - 1; i++) {
if ((v = G[u][i].second) == ff) swap(G[u][i], G[u].back());
v = G[u][i].second;
dfs(v, u);
sz[u] += sz[v];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1), LIM = (m); i <= LIM; i++) scanf("%d%d", &sx[i], &ty[i]);
int rt = 0;
for (int i = (1), LIM = (n); i <= LIM; i++) {
scanf("%lld%lld", &P[i].x, &P[i].y);
if (!rt || (P[i].x < P[rt].x)) rt = i;
}
for (int i = (1), LIM = (m); i <= LIM; i++) {
int u = sx[i], v = ty[i];
if (Find(u) ^ Find(v)) {
G[u].push_back(make_pair(atan2(P[v].y - P[u].y, P[v].x - P[u].x), v)),
G[v].push_back(make_pair(atan2(P[u].y - P[v].y, P[u].x - P[v].x), u));
F[Find(u)] = Find(v);
}
}
G[rt].push_back(make_pair(3.1415926535897932384626433832795, 0));
dfs(rt, 0);
for (int i = (1), LIM = (n); i <= LIM; i++) {
sort(G[i].begin(), G[i].end() - 1);
for (int j = (0), LIM = (G[i].size() - 2); j <= LIM; j++)
G[i][j].second = sz[G[i][j].second] + (j ? G[i][j - 1].second : 0);
}
int q;
scanf("%d", &q);
for (int S; q--;) {
scanf("%d", &S);
static int ar[100005];
long long area = 0;
for (int i = (1), LIM = (S); i <= LIM; i++) scanf("%d", &ar[i]);
for (int i = (1), LIM = (S); i <= LIM; i++) {
int v = i % S + 1;
area += P[ar[i]] * P[ar[v]];
}
if (area < 0) reverse(ar + 1, ar + 1 + S);
int ans = 0;
for (int i = (1), LIM = (S); i <= LIM; i++) {
int pr = (i + S - 2) % S + 1, sc = i % S + 1, u = ar[i];
double pa = atan2(P[ar[pr]].y - P[ar[i]].y, P[ar[pr]].x - P[ar[i]].x),
sa = atan2(P[ar[sc]].y - P[ar[i]].y, P[ar[sc]].x - P[ar[i]].x);
if (pa < sa) {
if (pa + 1e-8 < G[u].back().first && G[u].back().first < sa - 1e-8)
ans += sz[u];
int tl = lower_bound(G[u].begin(), G[u].end() - 1,
make_pair(pa + 1e-8, 0x3f3f3f3f)) -
G[u].begin() - 1,
tr = lower_bound(G[u].begin(), G[u].end() - 1,
make_pair(sa - 1e-8, 0)) -
G[u].begin() - 1;
if (tr >= 0) ans -= G[u][tr].second;
if (tl >= 0) ans += G[u][tl].second;
} else {
if (pa + 1e-8 < G[u].back().first || G[u].back().first < sa - 1e-8)
ans += sz[u];
swap(pa, sa);
int tl = lower_bound(G[u].begin(), G[u].end() - 1,
make_pair(pa - 1e-8, 0)) -
G[u].begin() - 1,
tr = lower_bound(G[u].begin(), G[u].end() - 1,
make_pair(sa + 1e-8, 0x3f3f3f3f)) -
G[u].begin() - 1;
if (G[u].size() > 1) ans -= G[u][G[u].size() - 2].second;
if (tr >= 0) ans += G[u][tr].second;
if (tl >= 0) ans -= G[u][tl].second;
}
}
printf("%d\n", ans);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using lld = int64_t;
struct PT {
lld x, y;
PT() : x(0), y(0) {}
PT(lld a, lld b) : x(a), y(b) {}
PT operator-(const PT& a) const { return PT(x - a.x, y - a.y); }
};
lld dot(const PT& a, const PT& b) { return a.x * b.x + a.y * b.y; }
lld cross(const PT& a, const PT& b) { return a.x * b.y - a.y * b.x; }
class ConvexHull_2D {
private:
vector<PT> dots;
public:
inline void init() { dots.clear(); }
void insert(const PT& x) { dots.push_back(x); }
void solve() {
sort(begin(dots), end(dots), [](const PT& a, const PT& b) {
return tie(a.x, a.y) < tie(b.x, b.y);
});
vector<PT> stk((static_cast<int>((dots).size())) << 1);
int top = 0;
for (auto p : dots) {
while (top >= 2 and
cross(p - stk[top - 2], stk[top - 1] - stk[top - 2]) <= 0)
top--;
stk[top++] = p;
}
for (int i = (static_cast<int>((dots).size())) - 2, t = top + 1; i >= 0;
i--) {
while (top >= t and
cross(dots[i] - stk[top - 2], stk[top - 1] - stk[top - 2]) <= 0)
top--;
stk[top++] = dots[i];
}
stk.resize(top - 1);
swap(stk, dots);
}
vector<PT> get() { return dots; }
};
ConvexHull_2D cv;
inline bool check(const vector<lld>&, const vector<lld>&);
vector<lld> get_it(const vector<PT>& a) {
vector<lld> ret;
ret.push_back(dot(a.back() - a[0], a.back() - a[0]));
ret.push_back(dot(a.back() - a[0], a[1] - a[0]));
for (int i = 1; i < (static_cast<int>((a).size())) - 1; i++) {
ret.push_back(dot(a[i - 1] - a[i], a[i - 1] - a[i]));
ret.push_back(dot(a[i - 1] - a[i], a[i + 1] - a[i]));
}
ret.push_back(dot(a[(static_cast<int>((a).size())) - 2] -
a[(static_cast<int>((a).size())) - 1],
a[(static_cast<int>((a).size())) - 2] -
a[(static_cast<int>((a).size())) - 1]));
ret.push_back(dot(a[(static_cast<int>((a).size())) - 2] -
a[(static_cast<int>((a).size())) - 1],
a[0] - a[(static_cast<int>((a).size())) - 1]));
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
cv.init();
for (int i = 0; i < n; i++) {
lld x, y;
cin >> x >> y;
cv.insert(PT(x, y));
}
cv.solve();
vector<PT> one = cv.get();
cv.init();
for (int i = 0; i < m; i++) {
lld x, y;
cin >> x >> y;
cv.insert(PT(x, y));
}
cv.solve();
vector<PT> two = cv.get();
if ((static_cast<int>((one).size())) != (static_cast<int>((two).size())) or
!check(get_it(one), get_it(two)))
cout << "NO" << '\n';
else
cout << "YES" << '\n';
return 0;
}
inline bool check(const vector<lld>& a, const vector<lld>& b) {
for (int i = 0; i < (static_cast<int>((a).size())); i++) {
bool flag = true;
for (int j = 0; j < (static_cast<int>((b).size())); j++) {
flag &= (a[(i + j) % (static_cast<int>((a).size()))] == b[j]);
if (!flag) break;
}
if (flag) return true;
}
return false;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> x(m);
for (long long i = 0; i < m; i++) cin >> x[i];
long long base = 0;
for (long long i = 0; i < m - 1; i++) base += abs(x[i + 1] - x[i]);
vector<long long> add(n + 1);
vector<long long> addans(n + 1);
vector<pair<long long, long long>> great(n + 1), les(n + 1);
for (long long i = 0; i < m - 1; i++) {
long long l = min(x[i], x[i + 1]), r = max(x[i], x[i + 1]);
if (l == r) continue;
great[l].first++, great[l].second += r;
les[r].first++, les[r].second += l;
if (l + 1 <= r - 1) {
add[l + 1]++;
add[r - 1 + 1]--;
}
}
long long now = 0;
for (long long i = 0; i < n + 1; i++) now += add[i], addans[i] = now;
for (long long i = 0; i < n + 1; i++) {
if (i == 0) continue;
long long ANS = base - addans[i];
ANS -= ((1ll * les[i].first * i) - les[i].second);
ANS -= (great[i].second - 1ll * great[i].first * i);
ANS += les[i].second;
ANS += (great[i].second) - great[i].first;
cout << ANS << ' ';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 1e9 + 7, N = 310000, inv2 = (mod + 1) >> 1;
int n, q, p[N], pw[N], root;
struct node {
int lv, rv, sum, size;
inline node operator+(const node &x) const {
node ret;
ret.lv = (x.lv + (long long)lv * pw[x.size]) % mod;
ret.rv = (rv + (long long)x.rv * pw[size]) % mod;
ret.size = size + x.size;
ret.sum = (sum + x.sum + (long long)lv * x.rv) % mod;
return ret;
}
};
struct segmentTree {
static const int K = N * 30;
int ls[K], rs[K], tot;
node data[K];
inline void modify(int &k, int lt, int rt, int x, int w) {
if (!k) k = ++tot;
if (lt == rt) {
while (w > 0) {
--w, ++data[k].size;
data[k].sum =
(data[k].sum + (long long)data[k].lv * x % mod * inv2) % mod;
data[k].rv = data[k].lv =
(data[k].lv + (long long)x * pw[data[k].size]) % mod;
}
while (w < 0) {
data[k].rv = data[k].lv =
(data[k].lv - (long long)x * pw[data[k].size] % mod + mod) % mod;
data[k].sum =
(data[k].sum - (long long)data[k].lv * x % mod * inv2 % mod + mod) %
mod;
++w, --data[k].size;
}
return;
}
x <= ((lt + rt) >> 1) ? modify(ls[k], lt, ((lt + rt) >> 1), x, w)
: modify(rs[k], ((lt + rt) >> 1) + 1, rt, x, w);
data[k] = data[ls[k]] + data[rs[k]];
return;
}
inline int query(int k) { return data[k].sum; }
} seg;
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
return;
}
int main() {
int x, y;
read(n);
pw[0] = 1;
for (register int i = 1; i <= n; ++i)
pw[i] = (long long)pw[i - 1] * inv2 % mod;
for (register int i = 1; i <= n; ++i)
read(p[i]), seg.modify(root, 1, inf, p[i], 1);
printf("%d\n", seg.query(root));
read(q);
while (q--) {
read(x), read(y);
seg.modify(root, 1, inf, p[x], -1);
seg.modify(root, 1, inf, p[x] = y, 1);
printf("%d\n", seg.query(root));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, CountDog[400];
char x[100005];
int main() {
scanf("%d", &n);
if (n == 1) {
printf("Yes");
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> x[i];
CountDog[x[i]]++;
}
for (int i = 1; i <= n; i++)
if (CountDog[x[i]] >= 2) {
printf("Yes");
return 0;
}
printf("No");
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define For(i,a,b) for ( int i=(a);i<=(b);i++ )
#define Dow(i,a,b) for ( int i=(a);i>=(b);i-- )
const int N=2e5+5,Mo=1e9+7,M=2e5;
inline int read()
{
int x=0,f=0; char ch=getchar();
while(!isdigit(ch)) f|=(ch=='-')?1:0,ch=getchar();
while(isdigit(ch)) x=x*10ll+(ch^48),ch=getchar();
return (f)?-1ll*x:x;
}
int Q,n,a[N],f[N][21],Log[N],suf[N],tmp,ans;
inline int query(int x,int y)
{
int k=Log[y-x+1];
return min(f[x][k],f[y-(1<<k)+1][k]);
}
int main()
{
Q=read();
Log[1]=0;
For(i,2,M) Log[i]=Log[i>>1]+1;
for (;Q--;)
{
n=read();
For(i,0,n+1) For(j,0,19) f[i][j]=0,suf[i]=0;
For(i,1,n) a[i]=f[i][0]=read();
For(j,1,19)
for ( int i=1;i+(1<<j-1)<=n;i++ ) f[i][j]=min(f[i][j-1],f[i+(1<<j-1)][j-1]);
suf[n]=a[n];
Dow(i,n-1,1) suf[i]=max(suf[i+1],a[i]);
int mx=0,flg=0;
For(i,1,n)
{
mx=max(mx,a[i]);
int l=i+1,r=n,y=-1;
while(l<=r)
{
int mid=l+r>>1;
int Mi=query(i+1,mid);
int LMi=query(mid+1,n);
// if(Mi>mx)
// {
// if(LMi<=mx&&suf[mid+2]>=mx) l=mid+1;
// else r=mid-1;
// }
// else if(Mi<mx)
// {
// if(LMi>=mx&&suf[mid+2]>=mx) l=mid+1;
// else r=mid-1;
// }
if(mx>Mi) r=mid-1;
else if(mx<Mi) l=mid+1;
else
{
int Mx=suf[mid+1];
if(Mx>mx) l=mid+1;
else if(Mx<mx) r=mid-1;
else
{
y=mid;
break;
}
}
}
if(~y)
{
puts("YES");
printf("%d %d %d\n",i,y-i,n-i-(y-i));
flg=1;
break;
}
}
if(!flg) puts("NO");
}
return 0;
}
/*
1
9
2 1 4 2 4 3 3 1 2
*/
| 6 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long S(unsigned long long x) {
unsigned long long res = 0;
while (x > 0) {
res++;
x /= 10;
}
return res;
}
int main() {
unsigned long long w, m, k;
unsigned long long c[19] = {0};
c[0] = 1;
for (int i = 1; i <= 18; i++) c[i] = c[i - 1] * 10LL;
cin >> w >> m >> k;
unsigned long long res = 0;
unsigned long long len = S(m);
unsigned long long rest = 1;
rest = c[len];
rest -= m;
if (rest * len * k > w) {
res = w / (len * k);
} else {
unsigned long long tmp = rest * len * k;
res += rest;
len++;
for (; tmp + c[len] / 10LL * 9LL * len * k <= w; len++) {
res += c[len] / 10LL * 9LL;
tmp += c[len] / 10LL * 9LL * len * k;
}
res += (w - tmp) / (len * k);
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2;
struct M {
long long mo[N][N];
M() { memset(mo, 0, sizeof mo); }
M operator*(const M &b) {
M c;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
c.mo[i][j] = (c.mo[i][j] + mo[i][k] * b.mo[k][j] % mod) % mod;
return c;
}
};
M powm(M a, long long n) {
M c;
for (int i = 0; i < N; i++) c.mo[i][i] = 1;
while (n) {
if (n & 1) c = c * a;
n >>= 1;
a = a * a;
}
return c;
}
long long powm(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
n >>= 1;
x = x * x % mod;
}
return res;
}
M init() {
M a;
a.mo[0][0] = 2;
a.mo[0][1] = mod - 1;
a.mo[1][0] = 0;
a.mo[1][1] = 1;
return a;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
M a = init();
if (n == 0) {
cout << 0 << endl;
return 0;
}
n %= mod;
a = powm(a, k);
long long ans = (n * a.mo[0][0] + powm(2, mod - 2) * a.mo[0][1]) % mod;
cout << (ans * 2) % mod << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.