solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include "bits/stdc++.h"
using namespace std;
//shorthands
#define ll long long
#define ld long double
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define mkp make_pair
#define fastio ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);
#define all(x) (x).begin(),(x).end()
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define sz(x) (ll)((x).size())
#define fr first
#define sc second
#define vll vector <ll>
#define vpll vector < pair<ll,ll> >
#define vect(a,n) vll a(n); rep(i,0,n) cin>>a[i];
#define rep(i,a,b) for(ll i = a; i < b; i++)
#define PI 3.14159265358979323846
//Debug
#define printall(a) rep(i,0,a.size()) cout<<a[i]<<" "; cout<<"\n";
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define deb3(x, y, z) cout << #x << "=" << x << "," << #y << "=" << y <<","<< #z << "=" << z << endl
//Constants
const int mod = (ll) 1e9 + 7 ;
const int INF = (int) 1e18 ;
//Input-Output File
void fileio(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin) ;
freopen("output.txt", "w", stdout) ;
#endif
}
void solve() {
ll n,x; cin >> n >> x;
vll v(n);
rep(i,0,n) cin >> v[i];
sort(all(v));
ll sum = 0;
rep(i,0,n) {
sum += v[i];
if(sum == x) {
if(i+1 < n) {
sum -= v[i];
sum += v[i+1];
swap(v[i] , v[i+1]);
}
}
}
if(sum == x) cout << "NO\n";
else {
cout << "YES\n";
printall(v);
}
}
int main() {
fastio;
fileio;
int t; cin >> t;
while(t--) solve();
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll getrnd(ll l, ll r) { return uniform_int_distribution<ll>(l, r)(rng); }
template <typename T1, typename T2>
inline bool relax(T1& a, const T2& b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool strain(T1& a, const T2& b) {
return a < b ? a = b, true : false;
}
const int N = 6e5 + 5;
pair<int, int> tree[4 * N], lazy[4 * N];
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first) return a;
return b;
}
void upd(int v, pair<int, int> x) {
tree[v] = merge(tree[v], x);
lazy[v] = merge(lazy[v], x);
}
void push(int v) {
if (lazy[v].first >= 0) {
upd(2 * v, lazy[v]);
upd(2 * v + 1, lazy[v]);
lazy[v].first = -1;
}
}
void build(int v, int tl, int tr) {
if (tl == tr)
tree[v] = {-1, tl}, lazy[v] = {-1, -1};
else {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
tree[v] = merge(tree[2 * v], tree[2 * v + 1]);
}
}
void update(int v, int tl, int tr, int l, int r, pair<int, int> x) {
if (l > r) return;
if (tl == l && tr == r)
upd(v, x);
else {
int tm = (tl + tr) / 2;
push(v);
update(2 * v, tl, tm, l, min(r, tm), x);
update(2 * v + 1, tm + 1, tr, max(l, tm + 1), r, x);
tree[v] = merge(tree[2 * v], tree[2 * v + 1]);
}
}
pair<int, int> get(int v, int tl, int tr, int l, int r) {
if (l > r) return {-1, -1};
if (tl == l && tr == r)
return tree[v];
else {
int tm = (tl + tr) / 2;
push(v);
return merge(get(2 * v, tl, tm, l, min(r, tm)),
get(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
}
void solve() {
int n, m;
cin >> n >> m;
vector<int> ids;
vector<vector<pair<int, int>>> segs(n);
for (int i = 0; i < m; ++i) {
int ind, l, r;
cin >> ind >> l >> r;
--ind;
ids.emplace_back(l);
ids.emplace_back(r);
segs[ind].emplace_back(l, r);
}
sort(ids.begin(), ids.end());
ids.resize(unique(ids.begin(), ids.end()) - ids.begin());
auto gid = [&](int x) {
return lower_bound(ids.begin(), ids.end(), x) - ids.begin();
};
int sz = ids.size();
build(1, 0, sz);
vector<int> dp(n, 1), from(n, -1);
for (int i = 0; i < n; ++i) {
for (auto& [l, r] : segs[i]) {
l = gid(l);
r = gid(r);
auto [val, ind] = get(1, 0, sz, l, r);
if (strain(dp[i], val + 1)) from[i] = ind;
}
for (auto [l, r] : segs[i]) {
update(1, 0, sz, l, r, {dp[i], i});
}
}
int st = max_element(dp.begin(), dp.end()) - dp.begin();
cout << n - dp[st] << '\n';
vector<int> was(n);
while (st != -1) {
was[st] = 1;
st = from[st];
}
for (int i = 0; i < n; ++i)
if (!was[i]) cout << i + 1 << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int f[1 << 12][1100];
int n, m;
int a[30][1100];
void solve() {
memset(f, 0, sizeof(f));
bool WZFCIDUJUE;
WZFCIDUJUE = 27230;
if (WZFCIDUJUE) {
long long GOWGYYDKMX;
int OEBZHEADMW;
if (28916 > 30123) {
if (15914 > 31504) {
bool YPADWLEWAE;
YPADWLEWAE = 17103;
}
if (2389 > 23910) {
double BADSUQLYPK;
BADSUQLYPK = 11349;
if (10487 > 29136) {
long long CDBCSKOXAC;
long long HPPBYVGIUA;
short XJMSGIPQAP;
}
double RPGDUDDUNK;
}
if (7401 > 17818) {
if (9101 > 3379) {
int HJYTNDMJDZ;
short FYOSYFEBLA;
}
if (14253 > 23734) {
bool YVKYPAIEVA;
}
}
if (28014 > 9457) {
short UIVXHBVQFP;
UIVXHBVQFP = 10664;
if (UIVXHBVQFP) {
int XIRPZNYJQT;
long long SCOUDUXPRJ;
int MJZKIEZQUX;
}
int IEFHMCJACJ;
IEFHMCJACJ = 17838;
if (IEFHMCJACJ) {
short EPSXSYHEMT;
long long GBNJBZKKXO;
}
long long RXZHPPNYIF;
RXZHPPNYIF = 29867;
if (RXZHPPNYIF) {
long long USFUVGWJFC;
double WHOWQMKJYW;
long long AEXYSPBJWN;
double YHVMLGNSRG;
}
}
}
}
memset(a, 0, sizeof(a));
if (26560 > 32463) {
double UMUTOUOINM;
UMUTOUOINM = 23347;
if (UMUTOUOINM) {
short HWUMCNPTJR;
}
if (30889 > 18466) {
long long XRDZPARDON;
int NSWCTSOFLO;
NSWCTSOFLO = 13584;
bool WLBULRWYMH;
bool GOIDMZNZIL;
GOIDMZNZIL = 13958;
if (GOIDMZNZIL) {
double PBWHLLXLTS;
PBWHLLXLTS = 19023;
}
}
}
cin >> n >> m;
if (5040 > 25224) {
if (9367 > 18574) {
if (10025 > 31018) {
double ROOZMLJDEO;
ROOZMLJDEO = 9791;
short CZRLMMIPVL;
CZRLMMIPVL = 29717;
short MMULWYEZFX;
MMULWYEZFX = 14689;
}
int BOZSLPYGSN;
BOZSLPYGSN = 7810;
}
}
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
int MOTIDACCPS;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < (1 << n); j++)
for (int _ = 0; _ < n; _++) {
for (int k = 0; k < (1 << n); k++) {
if (k + j == (k | j)) {
int add = 0;
for (int l = 0; l < n; l++) {
if (k & (1 << l)) {
add += a[(l + _) % n][i];
}
}
f[i][k + j] = max(f[i][k + j], f[i - 1][j] + add);
}
}
}
for (int j = 0; j < (1 << n); j++) f[i][j] = max(f[i][j], f[i - 1][j]);
if (10112 > 3646) {
if (13684 > 865) {
if (1046 > 25378) {
double EAJJFUGZMD;
}
}
long long YVZXISOUCQ;
}
}
cout << f[m][(1 << n) - 1] << endl;
if (14729 > 7075) {
bool MKBIDINLKI;
if (21519 > 27455) {
bool XWCSYAUWJC;
XWCSYAUWJC = 16360;
double JLXKXEZGIV;
bool QUEBEFDJSA;
QUEBEFDJSA = 23505;
if (QUEBEFDJSA) {
if (31484 > 15362) {
int KRFOCUWGFF;
}
bool XAYBCGWIUK;
XAYBCGWIUK = 5581;
if (XAYBCGWIUK) {
bool CJNQJVQLZG;
}
bool EPUZELHKNN;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
short QVFDWWQSQV;
QVFDWWQSQV = 28945;
int T;
int FZKXINOEYR;
FZKXINOEYR = 23731;
cin >> T;
bool COKCEDPEPS;
COKCEDPEPS = 12597;
if (COKCEDPEPS) {
if (2257 > 12162) {
long long FNPBQXWOIF;
if (26268 > 24522) {
short TEEMNQCTQW;
TEEMNQCTQW = 9824;
short XRGBXHGWHN;
if (14647 > 31835) {
double GTTRACHJMV;
long long JNWKHADURP;
double JWBYCXGCYV;
}
if (17681 > 17056) {
long long HPZFDQMEKA;
}
}
if (6730 > 31774) {
if (16535 > 4913) {
double PXYUUCPEHT;
bool FAEWZSAYLL;
}
int WUHJUUAQXT;
WUHJUUAQXT = 10350;
if (WUHJUUAQXT) {
bool APPTZNQXKN;
}
bool HWPNXWTLVL;
double MIHMBOQZXH;
MIHMBOQZXH = 13797;
if (MIHMBOQZXH) {
int PWVPGUDVHT;
bool CCZVECKNSI;
double OJXZQZUTDX;
}
}
}
if (14409 > 8062) {
long long SLMJNUVTZY;
SLMJNUVTZY = 11010;
bool SJCFLDIWYU;
SJCFLDIWYU = 32531;
}
}
while (T--) {
solve();
int SDDZOBGDJF;
SDDZOBGDJF = 27454;
if (SDDZOBGDJF) {
if (12240 > 1847) {
bool BYUPHLWGHL;
BYUPHLWGHL = 12700;
if (BYUPHLWGHL) {
bool XIILTCQKOJ;
double UHJMITCUBN;
int CKHARWSQRC;
}
}
bool BZFMFTIMFT;
BZFMFTIMFT = 31955;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200020;
int belong[MAXN];
int h, m, n;
map<int, pair<int, int> > gl;
struct Block {
int BLOCK;
vector<int> g;
vector<int> val;
vector<int> nxt;
vector<int> cnt;
map<int, int> id;
void getBlock() {
int t = sqrt(g.size() * 1.0);
BLOCK = 16;
while (BLOCK < t) BLOCK <<= 1;
val.resize(g.size(), -1);
nxt.resize(g.size());
cnt.resize(g.size());
for (int i = 0; i < g.size(); ++i) {
nxt[i] = i, cnt[i] = 0;
}
for (int i = 0; i < g.size(); ++i) {
id[g[i]] = i;
}
}
void add(int l, int p) {
int r = l + BLOCK;
for (int i = p; i >= l; --i) {
if (val[i] == -1) {
nxt[i] = i;
cnt[i] = 0;
continue;
}
int p = (i + 1) % g.size();
if (p < i || p >= r) {
nxt[i] = p;
cnt[i] = 1;
} else {
nxt[i] = nxt[p];
cnt[i] = cnt[p] + 1;
}
}
}
int find(int &a, int v) {
int last = -1, ret = 0;
for (int j = a & ~(BLOCK - 1);; j = a & ~(BLOCK - 1)) {
ret += cnt[a];
a = nxt[a];
if (a < j + BLOCK && a >= j) break;
}
return ret;
}
void add(int a) { add(a & ~(BLOCK - 1), a); }
};
vector<Block> vec;
void init() {
memset(belong, -1, sizeof(belong));
int cnt = 0;
for (int i = 0; i < h; ++i) {
if (belong[i] != -1) continue;
int p = i;
vec.push_back(Block());
while (belong[p] == -1) {
belong[p] = cnt;
vec.back().g.push_back(p);
p = (p + m) % h;
}
++cnt;
}
for (int i = 0; i < cnt; ++i) {
vec[i].getBlock();
}
}
int main() {
scanf("%d %d %d", &h, &m, &n);
init();
char ch[2];
int id, ha;
long long ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%s %d", ch, &id);
if (ch[0] == '-') {
map<int, pair<int, int> >::iterator iter = gl.find(id);
pair<int, int> tmp = iter->second;
gl.erase(iter);
vec[tmp.first].val[tmp.second] = -1;
vec[tmp.first].add(tmp.second);
} else {
scanf("%d", &ha);
int d = belong[ha];
int p = vec[d].id[ha];
ans += vec[d].find(p, id);
gl[id] = make_pair(d, p);
vec[d].val[p] = id;
vec[d].add(p);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1001][1001];
bool isPrime[1001];
vector<long long> Prime;
void pre1() {
long long i, j;
for (i = 2; i < 1001; i++) {
for (j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
isPrime[i] = false;
goto hell;
}
}
isPrime[i] = true;
Prime.push_back(i);
hell:;
}
}
long long fpow(long long base, long long power) {
long long res = 1;
while (power > 0) {
if (power % 2 == 1) {
res *= base;
res %= 1000000007;
}
base = (base * base) % 1000000007;
power /= 2;
if (base < 0) {
base += 1000000007;
}
}
return res;
}
long long calc(long long a, long long b) {
long long aa = 0, bb = b;
while (a / b) {
aa += a / b;
b *= bb;
}
return aa;
}
long long cc(long long a, long long b) { return fpow(a, b); }
void pre() {
memset(dp, 0, sizeof(dp));
memset(isPrime, false, sizeof(isPrime));
}
long long nCr(long long n, long long r) {
long long res = 1;
for (long long i = 0; i < Prime.size() && Prime[i] <= n; i++) {
long long tmp = Prime[i];
long long res1, res2;
res1 = calc(n, tmp) - calc(n - r, tmp) - calc(r, tmp);
res1 = cc(tmp, res1);
res1 %= 1000000007;
res *= res1;
res %= 1000000007;
if (res < 0) {
res += 1000000007;
}
}
return res;
}
int main() {
pre();
pre1();
long long k, i, j;
cin >> k;
long long ans = 1;
long long sum = 0;
for (i = 0; i < k; i++) {
long long c;
cin >> c;
sum += c;
ans *= nCr(sum - 1, c - 1);
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dis[3030][3030];
struct EDGE {
int to, next;
} e[5050];
queue<int> q;
int n, m, head[3030], tot;
bool mark[3030];
void dij(int t) {
for (int i = 1; i <= n; i++) {
dis[t][i] = -1;
mark[i] = false;
}
mark[t] = true;
dis[t][t] = 0;
while (!q.empty()) q.pop();
q.push(t);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i >= 0; i = e[i].next) {
int v = e[i].to;
if (mark[v]) continue;
if (dis[t][v] == -1) {
dis[t][v] = dis[t][u] + 1;
mark[v] = true;
q.push(v);
}
}
}
}
struct node {
int bh, val;
node() {}
node(const int &bh, const int &val) : bh(bh), val(val) {}
bool operator<(const node &b) const { return val > b.val; }
} Max[3030][4], Mtx[3030][4];
int ans, ans_print[4];
int main() {
scanf("%d%d", &n, &m);
tot = 0;
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[tot].to = v;
e[tot].next = head[u];
head[u] = tot++;
}
for (int i = 1; i <= n; i++) {
dij(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 4; j++) {
Max[i][j].bh = 0;
Max[i][j].val = -2;
Mtx[i][j].bh = 0;
Mtx[i][j].val = -2;
}
for (int j = 1; j <= n; j++) {
if (j == i) continue;
Max[i][3].bh = j;
Max[i][3].val = dis[i][j];
Mtx[i][3].bh = j;
Mtx[i][3].val = dis[j][i];
sort(Max[i], Max[i] + 4);
sort(Mtx[i], Mtx[i] + 4);
}
}
ans = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (j == i) continue;
if (dis[i][j] == -1) continue;
for (int l = 0; l < 3; l++) {
if (Mtx[i][l].val <= 0) break;
if (Mtx[i][l].bh == i || Mtx[i][l].bh == j) continue;
for (int o = 0; o < 3; o++) {
if (Max[j][o].val <= 0) break;
if (Max[j][o].bh == i || Max[j][o].bh == j ||
Max[j][o].bh == Mtx[i][l].bh)
continue;
if (Mtx[i][l].val + dis[i][j] + Max[j][o].val > ans) {
ans = Mtx[i][l].val + dis[i][j] + Max[j][o].val;
ans_print[0] = Mtx[i][l].bh;
ans_print[1] = i;
ans_print[2] = j;
ans_print[3] = Max[j][o].bh;
}
}
}
}
}
for (int i = 0; i < 4; i++) {
printf("%d", ans_print[i]);
if (i == 3)
printf("\n");
else
printf(" ");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cout << (i % ((n - k) / 2 + 1) > 0);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
vector<int> G[N];
vector<pair<int, int> > Q[N];
long long updates[N], res[N];
void dfs(int v, int pr, int h, long long sum) {
for (auto &q : Q[v]) {
updates[h] += q.second;
updates[min(N - 1, h + q.first + 1)] -= q.second;
}
sum += updates[h];
res[v] = sum;
for (auto &to : G[v]) {
if (to != pr) {
dfs(to, v, h + 1, sum);
}
}
for (auto &q : Q[v]) {
updates[h] -= q.second;
updates[min(N - 1, h + q.first + 1)] += q.second;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q, x, d, v, y;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
--x, --y;
G[x].push_back(y);
G[y].push_back(x);
}
cin >> q;
while (q--) {
cin >> x >> d >> v;
--x;
Q[x].push_back({d, v});
}
dfs(0, 0, 0, 0);
for (int i = 0; i < n; i++) {
cout << res[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace wode {
template <typename T>
inline void read(T &x) {
static char ch;
bool f = 1;
for (x = 0, ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = 0;
for (; isdigit(ch); x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar())
;
x = f ? x : -x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void print(T x, char ap) {
print(x);
if (ap) putchar(ap);
}
template <typename T>
inline T max(T x, T y) {
return x < y ? y : x;
}
template <typename T>
inline T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
inline void chkmax(T &x, T y) {
x = x < y ? y : x;
}
template <typename T>
inline void chkmin(T &x, T y) {
x = x < y ? x : y;
}
} // namespace wode
using wode::chkmax;
using wode::chkmin;
using wode::print;
using wode::read;
int n, k;
int main() {
cin >> n >> k;
int now = n - k >> 1;
++now;
if (k == 1) {
putchar('1');
for (register int i = 2; i <= n; ++i) putchar('0');
puts("");
return 0;
}
for (register int i = 1; i <= n; ++i) putchar(48 + (i % now == 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[500];
string s;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.')
a[n++] = 0;
else {
i++;
if (s[i] == '.')
a[n++] = 1;
else
a[n++] = 2;
}
}
for (int i = 0; i < n; i++) printf("%d", a[i]);
printf("\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 207;
int a[maxn], n, k, l1[maxn], l2[maxn], c1, c2;
bool mycmp(const int &a, const int &b) { return a > b; }
int cal(int l, int r) {
c1 = 0;
for (int i = 1, _c = l - 1; i <= _c; i++) l1[++c1] = a[i];
for (int i = r + 1, _c = n; i <= _c; i++) l1[++c1] = a[i];
c2 = 0;
int res = 0;
for (int i = l, _c = r; i <= _c; i++) l2[++c2] = a[i], res += a[i];
if (c1 > 0) sort(l1 + 1, l1 + c1 + 1, mycmp);
if (c2 > 0) sort(l2 + 1, l2 + c2 + 1);
int idx = 1;
for (int i = 1, _c = min(k, min(c1, c2)); i <= _c; i++) {
if (l1[i] - l2[i] > 0)
res += l1[i] - l2[i];
else
break;
}
return res;
}
int main() {
cin >> n >> k;
for (int i = 1, _c = n; i <= _c; i++) cin >> a[i];
int res = -1000000007;
for (int i = 1, _c = n; i <= _c; i++)
for (int j = i, _c = n; j <= _c; j++) {
res = max(res, cal(i, j));
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int p;
int x, y;
int tab[1007];
int ile1, ile2;
vector<int> jed;
vector<int> dwa;
int sum;
int main() {
scanf("%d%d%d%d%d", &n, &k, &p, &x, &y);
for (int i = 1; i <= k; i++) {
scanf("%d", &tab[i]);
if (tab[i] >= y) {
dwa.push_back(tab[i]);
ile2++;
} else {
jed.push_back(tab[i]);
ile1++;
}
}
if (2 * jed.size() + 1 > n) {
printf("-1");
return 0;
}
while (dwa.size() <= jed.size() && dwa.size() + jed.size() + 1 <= n) {
dwa.push_back(y);
}
while (dwa.size() - 1 > jed.size() && dwa.size() + jed.size() + 1 <= n) {
jed.push_back(1);
}
while (jed.size() + dwa.size() + 2 <= n) {
jed.push_back(1);
dwa.push_back(y);
}
for (int i = 0; i < jed.size(); i++) {
sum += jed[i];
}
for (int i = 0; i < dwa.size(); i++) {
sum += dwa[i];
}
if (sum > x) {
printf("-1");
return 0;
}
for (int i = ile1; i < jed.size(); i++) {
printf("%d ", jed[i]);
}
for (int i = ile2; i < dwa.size(); i++) {
printf("%d ", dwa[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 8;
int cnt[maxn];
int main() {
int an, rec;
string s, t[8] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
cin >> an >> s;
an = 0;
for (int i = 7; 0 <= i; i--) {
for (int j = 0; j < 7; j++) {
if (s[j] == t[i][j]) cnt[i]++;
}
if (an <= cnt[i]) {
an = cnt[i];
rec = i;
}
}
cout << t[rec];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<long long, long long> ll;
typedef vector<long long> vl;
typedef vector<ll> vll;
typedef vector<vl> vvl;
template <typename T>
ostream &operator<<(ostream &o, vector<T> v) {
if (v.size() > 0) o << v[0];
for (unsigned i = 1; i < v.size(); i++) o << " " << v[i];
return o << "\n";
}
template <typename U, typename V>
ostream &operator<<(ostream &o, pair<U, V> p) {
return o << "(" << p.first << ", " << p.second << ") ";
}
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (unsigned i = 0; i < v.size(); i++) in >> v[i];
return in;
}
template <typename T>
istream &operator>>(istream &in, pair<T, T> &p) {
in >> p.first;
in >> p.second;
return in;
}
vl dx = {0, 0, -1, 1};
vl dy = {-1, 1, 0, 0};
char ch[4] = {'L', 'R', 'U', 'D'};
long long n, x, y, all, sx, sy, used[505][505], gused[505][505], a[505][505];
string ans = "";
inline bool correct(long long nx, long long ny) {
return (nx >= 0 && nx < n && ny >= 0 & ny < n);
}
void dfs(long long x, long long y) {
vl cnt(4, 0);
if (used[x][y]) return;
used[x][y] = true;
for (long long i = (0); i < (long long)4; i++) {
for (long long(k) = 1; (k) < (505); (k)++) {
long long nx = x + k * dx[i];
long long ny = y + k * dy[i];
if (!correct(nx, ny)) break;
if (a[nx][ny]) {
cnt[i]++;
break;
}
}
}
if (a[x][y] == 0) ans += "1";
a[x][y] = 1;
for (long long i = (0); i < (long long)4; i++) {
long long nx = x + dx[i];
long long ny = y + dy[i];
if (correct(nx, ny) and cnt[i] > 0 and !used[nx][ny]) {
long long redir = i ^ 1;
ans += ch[i];
dfs(nx, ny);
ans += ch[redir];
}
}
}
inline void bfs() {
queue<ll> q;
q.push(make_pair((sx), (sy)));
memset(gused, -1, sizeof(gused));
gused[sx][sy] = 0;
while (!q.empty()) {
long long curx = q.front().first;
long long cury = q.front().second;
q.pop();
for (long long i = (0); i < (long long)4; i++) {
long long nx = curx + dx[i];
long long ny = cury + dy[i];
if (correct(nx, ny) and gused[nx][ny] == -1) {
gused[nx][ny] = gused[curx][cury] + 1;
q.push(make_pair((nx), (ny)));
}
}
}
}
void dfs2(long long x, long long y) {
for (long long i = (0); i < (long long)4; i++) {
long long nx = x + dx[i];
long long ny = y + dy[i];
if (correct(nx, ny) and gused[nx][ny] > gused[x][y] and a[nx][ny] == 1) {
ans += ch[i];
dfs2(nx, ny);
ans += ch[i ^ 1];
}
}
ans += "2";
a[x][y] = 0;
}
int main() {
long long x, y;
cin >> n >> x >> y;
;
x--;
y--;
sx = x;
sy = y;
for (long long i = (0); i < (long long)n; i++)
for (long long j = (0); j < (long long)n; j++) {
cin >> a[i][j];
}
dfs(x, y);
for (long long i = (0); i < (long long)n; i++)
for (long long j = (0); j < (long long)n; j++) {
if (a[i][j] == 1 and !used[i][j]) {
cout << "NO";
return 0;
}
}
bfs();
dfs2(x, y);
cout << "YES"
<< "\n";
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
template <typename T>
T sqr(T a) {
return a * a;
}
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
int n, m;
pair<long long, long long> p[200500];
pair<long long, long long> rp[200500];
int szans;
pair<long long, long long> ans[200500];
void check(pair<long long, long long> c) {
for (int i = 0; i < int(n); ++i)
rp[n - i - 1] = pair<long long, long long>(2 * c.first - p[i].first,
2 * c.second - p[i].second);
int j = 0;
int miss = 0;
for (int i = 0; i < int(n); ++i) {
while (j < n && p[j] < rp[i]) ++j;
if (j == n || p[j] != rp[i]) miss++;
}
if (miss <= m) ans[szans++] = c;
}
inline void printHalf(long long a) {
if (a < 0) {
printf("-");
a = -a;
}
printf("%I64d", (a >> 1));
if (a & 1) printf(".5");
}
int main() {
cin >> n >> m;
if (n <= m) {
puts("-1");
return 0;
}
for (int i = 0; i < int(n); ++i) {
scanf("%I64d %I64d", &p[i].first, &p[i].second);
p[i].first *= 2;
p[i].second *= 2;
}
sort(p, p + n);
for (int i = 0; i < int(m + 1); ++i)
for (int j = n - 1; j >= n - m - 1; --j)
check(pair<long long, long long>((p[i].first + p[j].first) / 2,
(p[i].second + p[j].second) / 2));
sort(ans, ans + szans);
szans = unique(ans, ans + szans) - ans;
cout << szans << endl;
for (int i = 0; i < int(szans); ++i) {
printHalf(ans[i].first);
printf(" ");
printHalf(ans[i].second);
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int b = n - m + 1;
long long int kmax = b * (b - 1) / 2;
long long int kmin;
long long int c = n / m;
long long int d = n % m;
kmin = (m - d) * c * (c - 1) / 2 + d * (c + 1) * (c) / 2;
cout << kmin << " " << kmax;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
long long IM = 1e17;
void PV(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void PA(long long v[], long long n) {
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << "\n";
}
void IN(long long a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
inline void PTN(long long n = 1, long long a = 0, long long b = 0,
long long c = 0) {
if (n--) cout << a << " ";
if (n--) cout << b << " ";
if (n--) cout << c << " ";
cout << "\n";
}
inline void open() {}
long long maxx(long long x, long long y, long long z) {
return max(x, max(y, z));
}
long long dp[100005][3];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
open();
{
long long n;
cin >> n;
vector<pair<long long, long long> > v;
long long i, j, k, l, x, y;
for (i = 0; i < n; i++) {
cin >> x >> y;
v.push_back({x, y});
}
v.push_back({IM, IM});
long long ans = 0;
dp[0][1] = 1;
if (v[0].first + v[0].second < v[1].first) dp[0][2] = 1;
for (i = 1; i < n; i++) {
dp[i][1] = dp[i - 1][1];
dp[i][2] = dp[i - 1][2];
dp[i][0] = maxx(dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]);
if (v[i - 1].first < v[i].first - v[i].second)
dp[i][1] = max(dp[i][1], dp[i - 1][0]) + 1;
if (v[i - 1].first + v[i - 1].second < v[i].first - v[i].second)
dp[i][1] = dp[i][0] + 1;
if (v[i].first + v[i].second < v[i + 1].first) dp[i][2] = dp[i][0] + 1;
ans = maxx(dp[i][0], dp[i][1], dp[i][2]);
}
ans = max(ans, 1ll);
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
for (int i = 0; i < 16; i++) {
int A = a * ((i & 8) > 0) + b * ((i & 4) > 0) + c * ((i & 2) > 0) +
d * ((i & 1) > 0);
int B = a * ((i & 8) == 0) + b * ((i & 4) == 0) + c * ((i & 2) == 0) +
d * ((i & 1) == 0);
if (A == B) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 300009;
int tree[4 * N];
stack<int> st[N];
int const inf = INT_MAX;
void build(int id, int l, int r) {
if (l == r) {
if (!st[l].empty()) tree[id] = st[l].top();
return;
}
int mid = (l + r) / 2;
build(2 * id, l, mid);
build(2 * id + 1, mid + 1, r);
tree[id] = min(tree[2 * id], tree[2 * id + 1]);
}
void update(int id, int l, int r, int pos, int val) {
if (l == r) {
tree[id] = val;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
update(2 * id, l, mid, pos, val);
else
update(2 * id + 1, mid + 1, r, pos, val);
tree[id] = min(tree[2 * id], tree[2 * id + 1]);
}
int querry(int id, int l, int r, int tl, int tr) {
if (tl > tr)
return inf;
else if (l == tl && r == tr)
return tree[id];
else {
int mid = (l + r) / 2;
return min(querry(2 * id, l, mid, tl, min(tr, mid)),
querry(2 * id + 1, mid + 1, r, max(mid + 1, tl), tr));
}
}
int main() {
clock_t begin = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
while (!st[i].empty()) st[i].pop();
int a[n + 1], b[n + 1];
int mx = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = n; i >= 1; i--) st[a[i]].push(i);
for (int i = 1; i <= 4 * n; i++) tree[i] = inf;
build(1, 1, n);
bool ok = 1;
for (int i = 1; i <= n; i++) {
if (st[b[i]].empty()) {
ok = 0;
break;
}
int pos = st[b[i]].top();
int id = querry(1, 1, n, 1, b[i]);
if (id < pos) {
ok = 0;
break;
}
st[b[i]].pop();
if (st[b[i]].empty())
update(1, 1, n, b[i], inf);
else
update(1, 1, n, b[i], st[b[i]].top());
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long get(char c) {
if ('0' <= c && c <= '9') return c - '0';
if ('A' <= c && c <= 'Z') return 10 + (c - 'A');
if ('a' <= c && c <= 'z') return 36 + (c - 'a');
if (c == '-') return 62;
return 63;
}
int main() {
string s;
cin >> s;
vector<long long> a(64, 0);
int n = 64;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int t = i & j;
a[t]++;
}
long long ans = 1, mod = 1e9 + 7;
for (int i = 0; i < s.length(); i++) {
int p = get(s[i]);
ans = (ans * a[p]) % mod;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 82;
int n, k, g[N][N], ans = 1e9, a[17];
pair<int, long long> dp[N][N][7];
int solve(int x) {
int p = 0, o = 0;
for (int i = 1; i < k / 2; i++) {
a[i] = x % 80, x /= 80;
if (a[i] >= n) return 1e9;
}
for (int i = 0; i < k / 2; i++) {
o = 0;
for (int j = 0; j < 6; j++) {
if (dp[a[i]][a[i + 1]][j].second != a[0] &&
dp[a[i]][a[i + 1]][j].second != a[1] &&
dp[a[i]][a[i + 1]][j].second != a[2] &&
dp[a[i]][a[i + 1]][j].second != a[3] &&
dp[a[i]][a[i + 1]][j].second != a[4]) {
p += dp[a[i]][a[i + 1]][j].first;
o = 1;
break;
}
}
if (o == 0) return 1e9;
}
return p;
}
int main() {
for (int i = 0; i < 10; i++) a[i] = 1e9;
scanf("%d%d", &n, &k);
a[0] = 0;
a[k / 2] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) scanf("%d", &g[i][j]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int l = 0; l < 6; l++) dp[i][j][l].first = 1e9;
for (int l = 1; l < n; l++) {
if (l != i && l != j) {
dp[i][j][5] = make_pair(g[i][l] + g[l][j], l);
sort(dp[i][j], dp[i][j] + 6);
}
}
}
}
for (int i = 0; i < 4e7 + 5e6; i++) ans = min(ans, solve(i));
;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, pos, tot, x[100005], y[100005], d[55][55], sum[5];
char ch[55][55];
int read() {
int x = 0, fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * fl;
}
void work() {
for (int i = 1; i <= n; i++) {
scanf("%s", ch[i] + 1);
for (int j = 1; j <= m; j++) {
if (ch[i][j] == 'U') d[i][j] = 1;
if (ch[i][j] == 'D') d[i][j] = 2;
if (ch[i][j] == 'L') d[i][j] = 3;
if (ch[i][j] == 'R') d[i][j] = 4;
sum[d[i][j]]++;
}
}
int cnt = n & 1 ? 1 : 3;
while (sum[cnt]) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j] == 1 && d[i][j + 1] == 1) {
d[i][j] = d[i + 1][j] = 3;
d[i][j + 1] = d[i + 1][j + 1] = 4;
tot++;
x[tot] = i;
y[tot] = j;
sum[1] -= 2;
sum[3] += 2;
}
}
}
if (!sum[cnt]) break;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j] == 3 && d[i + 1][j] == 3) {
d[i][j] = d[i][j + 1] = 1;
d[i + 1][j] = d[i + 1][j + 1] = 2;
tot++;
x[tot] = i;
y[tot] = j;
sum[3] -= 2;
sum[1] += 2;
}
}
}
}
memset(sum, 0, sizeof(sum));
return;
}
int main() {
n = read(), m = read();
work(), pos = tot, work();
printf("%d\n", tot);
for (int i = 1; i <= pos; i++) printf("%d %d\n", x[i], y[i]);
for (int i = tot; i >= pos + 1; i--) printf("%d %d\n", x[i], y[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
bool is_equivalent(int start1, int start2, int l) {
bool ok = true;
for (int i = 0; i < l; i++) {
if (a[start1 + i] != b[start2 + i]) {
ok = false;
break;
}
}
if (ok) return true;
if (l % 2 == 1) return false;
return (is_equivalent(start1, start2, l / 2) &&
is_equivalent(start1 + l / 2, start2 + l / 2, l / 2)) ||
(is_equivalent(start1, start2 + l / 2, l / 2) &&
is_equivalent(start1 + l / 2, start2, l / 2));
}
int main() {
cin >> a >> b;
if (is_equivalent(0, 0, a.length()))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
namespace FIO {
const int mxsz = 1 << 23;
char ibuf[mxsz], *iend = ibuf + mxsz, *ipos = iend;
char obuf[mxsz], *oend = obuf + mxsz, *opos = obuf;
char get_char() {
if (ipos == iend) iend = (ipos = ibuf) + fread(ibuf, 1, mxsz, stdin);
return ipos == iend ? EOF : *ipos++;
}
void put_char(char c) {
if (opos == oend) fwrite(opos = obuf, 1, mxsz, stdout);
*opos++ = c;
}
int read_int() {
int x = 0, c = get_char();
while (c <= 32) c = get_char();
while (c > 32) x = x * 10 + c - 48, c = get_char();
return x;
}
void read_str(char *S) {
while ((*S = get_char()) <= 32)
;
while ((*++S = get_char()) > 32)
;
*S = 0;
}
void write_int(int x) {
static char stk[20];
if (x < 0) put_char(45), x *= -1;
if (x == 0) put_char(48);
int top = 0;
while (x) stk[top++] = x % 10 + 48, x /= 10;
while (top--) put_char(stk[top]);
put_char(10);
}
void flush() {
fwrite(obuf, 1, opos - obuf, stdout);
opos = obuf;
}
} // namespace FIO
using FIO::flush;
using FIO::read_int;
using FIO::read_str;
using FIO::write_int;
const int mxn = 1 << 19;
int n, q;
char expr[mxn];
int jmp[mxn];
int lv[mxn];
std::vector<int> vplus[mxn], vmul[mxn];
std::vector<int> elem;
int L[mxn], R[mxn];
namespace BracketChecker {
struct Node {
int a, b;
Node() : a(), b() {}
Node(int _a, int _b) : a(_a), b(_b) {}
};
Node operator+(const Node &a, const Node &b) {
if (a.b <= b.a)
return Node(a.a + b.a - a.b, b.b);
else
return Node(a.a, a.b - b.a + b.b);
}
Node t[mxn << 1];
void init() {
for (int i = 0; i < n; ++i) {
if (expr[i] == '(')
t[i + mxn] = Node(0, 1);
else if (expr[i] == ')')
t[i + mxn] = Node(1, 0);
else
t[i + mxn] = Node(0, 0);
}
for (int i = n; i < mxn; ++i) t[i + mxn] = Node(0, 0);
for (int i = mxn - 1; i; --i) t[i] = t[i << 1] + t[i << 1 | 1];
}
Node query(int l, int r) {
Node ansl = Node(0, 0);
Node ansr = Node(0, 0);
for (l += mxn, r += mxn; l < r; l >>= 1, r >>= 1) {
if (l & 1) ansl = ansl + t[l++];
if (r & 1) ansr = t[--r] + ansr;
}
return ansl + ansr;
}
bool check(int l, int r) {
Node s = query(l, r);
return s.a == 0 && s.b == 0;
}
} // namespace BracketChecker
int pw10[mxn];
namespace Number {
int va[mxn << 1], len[mxn << 1];
void merge(int vl, int ll, int vr, int lr, int &v, int &l) {
v = (1LL * vl * pw10[lr] + vr) % mod;
l = ll + lr;
}
void init() {
for (int i = 0; i < (int)(n); ++i)
if (isdigit(expr[i]))
va[i + mxn] = expr[i] - '0', len[i + mxn] = 1;
else
va[i + mxn] = 0, len[i + mxn] = 0;
for (int i = mxn - 1; i; --i)
merge(va[i << 1], len[i << 1], va[i << 1 | 1], len[i << 1 | 1], va[i],
len[i]);
}
int query(int l, int r) {
int vl = 0, ll = 0, vr = 0, lr = 0;
for (l += mxn, r += mxn; l < r; l >>= 1, r >>= 1) {
if (l & 1) merge(vl, ll, va[l], len[l], vl, ll), ++l;
if (r & 1) --r, merge(va[r], len[r], vr, lr, vr, lr);
}
int ans_va, ans_len;
merge(vl, ll, vr, lr, ans_va, ans_len);
return ans_va;
}
} // namespace Number
int ans[mxn];
namespace Tree {
const int MUL = 0;
const int ADD = 1;
const int CONCAT = 2;
int tot, rt;
std::vector<int> adj[mxn << 1];
int type[mxn << 1];
int build(int l, int r) {
int pl = std::lower_bound(vplus[lv[l]].begin(), vplus[lv[l]].end(), l) -
vplus[lv[l]].begin();
int pr = std::lower_bound(vplus[lv[l]].begin(), vplus[lv[l]].end(), r) -
vplus[lv[l]].begin();
if (pl < pr) {
int u = tot++;
type[u] = ADD;
int las = l;
for (int x = pl; x < pr; ++x) {
adj[u].push_back(build(las, vplus[lv[l]][x]));
las = vplus[lv[l]][x] + 1;
}
adj[u].push_back(build(las, r));
return u;
}
int ml = std::lower_bound(vmul[lv[l]].begin(), vmul[lv[l]].end(), l) -
vmul[lv[l]].begin();
int mr = std::lower_bound(vmul[lv[l]].begin(), vmul[lv[l]].end(), r) -
vmul[lv[l]].begin();
if (ml < mr) {
int u = tot++;
type[u] = MUL;
int las = l;
for (int x = ml; x < mr; ++x) {
adj[u].push_back(build(las, vmul[lv[l]][x]));
las = vmul[lv[l]][x] + 1;
}
adj[u].push_back(build(las, r));
return u;
}
if (jmp[l] == r - 1) return build(l + 1, r - 1);
int u = tot++;
type[u] = CONCAT;
for (int x = l; x < r; ++x) adj[u].push_back(x);
return u;
}
struct Tag {
int a, b;
Tag() : a(1), b(0) {}
Tag(int _a, int _b) : a(_a), b(_b) {}
};
Tag operator+(const Tag &a, const Tag &b) {
return Tag(1LL * a.a * b.a % mod, (1LL * a.b * b.a + b.b) % mod);
}
struct SegmentTree {
static const int mxlg = 19;
Tag ta[mxn << 1];
void push(int x, Tag t) { ta[x] = ta[x] + t; }
void pushdown(int x) {
if (ta[x].a != 1 || ta[x].b != 0) {
push(x << 1, ta[x]);
push(x << 1 | 1, ta[x]);
ta[x] = Tag();
}
}
void init() {
for (int i = 1; i < mxn << 1; ++i) ta[i] = Tag();
}
void update(int l, int r, Tag t) {
l += mxn, r += mxn;
for (int i = mxlg; i; --i) {
if (((l >> i) << i) != l) pushdown(l >> i);
if (((r >> i) << i) != r) pushdown(r >> i);
}
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) push(l++, t);
if (r & 1) push(--r, t);
}
}
int query(int x) {
x += mxn;
for (int i = mxlg; i; --i) pushdown(x >> i);
return ta[x].b;
}
} pre, suf;
const int mxlg = 20;
int fa[mxn << 1][mxlg];
int dep[mxn << 1];
void dfs0(int u) {
for (int i = 0; i < (int)(mxlg - 1); ++i) fa[u][i + 1] = fa[fa[u][i]][i];
for (int i = 0; i < (int)(adj[u].size()); ++i) {
int v = adj[u][i];
fa[v][0] = u;
dep[v] = dep[u] + 1;
dfs0(v);
}
}
void init() {
tot = n;
rt = build(0, n);
fa[rt][0] = rt;
dep[rt] = 0;
dfs0(rt);
}
int lca(int u, int v) {
if (dep[u] > dep[v]) std::swap(u, v);
for (int i = 0; i < (int)(mxlg); ++i)
if ((dep[v] - dep[u]) >> i & 1) v = fa[v][i];
if (u == v) return u;
for (int i = mxlg - 1; ~i; --i)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
int jmp(int u, int v) {
for (int i = mxlg - 1; ~i; --i) {
if (dep[fa[u][i]] > dep[v]) {
u = fa[u][i];
}
}
return u;
}
struct Query {
int x1, x2, v1, v2, id;
Query(int _x1, int _x2, int _v1, int _v2, int _id)
: x1(_x1), x2(_x2), v1(_v1), v2(_v2), id(_id) {}
};
std::vector<Query> qry[mxn << 1];
int boundl[mxn << 1], boundr[mxn << 1];
void reg_query(int u, int x1, int x2, int v1, int v2, int id) {
qry[u].push_back(Query(x1, x2, v1, v2, id));
}
int bsearch(int u, int v) {
int lb = 0, rb = (int)adj[u].size() - 1;
while (lb < rb) {
int md = (lb + rb) >> 1;
if (boundl[adj[u][md]] < boundl[v])
lb = md + 1;
else
rb = md;
}
return lb;
}
int TYPE;
int merge(int a, int b) {
return TYPE == MUL ? 1LL * a * b % mod : (a + b) % mod;
}
int sz;
int seg_mini[mxn << 1];
void init_mini(int n, const std::vector<int> &vec) {
sz = 1;
while (sz < n) sz <<= 1;
for (int i = 0; i < (int)(n); ++i) seg_mini[i + sz] = vec[i];
for (int i = n; i < sz; ++i) seg_mini[i + sz] = TYPE == MUL ? 1 : 0;
for (int i = sz - 1; i; --i)
seg_mini[i] = merge(seg_mini[i << 1], seg_mini[i << 1 | 1]);
}
int query_mini(int l, int r) {
int ansl = TYPE == MUL ? 1 : 0;
int ansr = TYPE == MUL ? 1 : 0;
for (l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
if (l & 1) ansl = merge(ansl, seg_mini[l++]);
if (r & 1) ansr = merge(seg_mini[--r], ansr);
}
return merge(ansl, ansr);
}
void dfs1(int u) {
if (u < n) {
boundl[u] = u;
boundr[u] = u;
return;
}
boundl[u] = 0x3f3f3f3f;
boundr[u] = -0x3f3f3f3f;
for (int i = 0; i < (int)(adj[u].size()); ++i) {
int v = adj[u][i];
dfs1(v);
boundl[u] = std::min(boundl[u], boundl[v]);
boundr[u] = std::max(boundr[u], boundr[v]);
}
TYPE = type[u];
std::vector<int> vadj(adj[u].size());
for (int i = 0; i < (int)(adj[u].size()); ++i) {
int v = adj[u][i];
vadj[i] = pre.query(boundr[v]);
}
init_mini(adj[u].size(), vadj);
for (Query Q : qry[u]) {
int x1 = Q.x1;
int x2 = Q.x2;
int v1 = Q.v1;
int v2 = Q.v2;
int id = Q.id;
int p1 = bsearch(u, v1);
int p2 = bsearch(u, v2);
if (TYPE == CONCAT) {
ans[id] = Number::query(v1, v2 + 1);
} else {
ans[id] =
merge(merge(suf.query(x1), query_mini(p1 + 1, p2)), pre.query(x2));
}
}
if (TYPE == CONCAT) {
int now = 0;
for (int i = 0; i < (int)adj[u].size(); ++i) {
int v = adj[u][i];
now = (10LL * now + expr[v] - '0') % mod;
pre.update(v, v + 1, Tag(0, now));
}
now = 0;
for (int i = (int)adj[u].size() - 1; ~i; --i) {
int v = adj[u][i];
now = (now + 1LL * pw10[(int)adj[u].size() - 1 - i] * (expr[v] - '0')) %
mod;
suf.update(v, v + 1, Tag(0, now));
}
} else {
Tag now = Tag();
for (int i = 0; i < (int)adj[u].size(); ++i) {
int v = adj[u][i];
pre.update(boundl[v], boundr[v] + 1, now);
int x = vadj[i];
if (TYPE == MUL)
now.a = 1LL * now.a * x % mod;
else
now.b = (now.b + x) % mod;
}
now = Tag();
for (int i = (int)adj[u].size() - 1; ~i; --i) {
int v = adj[u][i];
suf.update(boundl[v], boundr[v] + 1, now);
int x = vadj[i];
if (TYPE == MUL)
now.a = 1LL * now.a * x % mod;
else
now.b = (now.b + x) % mod;
}
}
}
void proc() {
pre.init();
suf.init();
dfs1(rt);
}
} // namespace Tree
int main() {
for (int i = 0; i < (int)(mxn); ++i)
pw10[i] = i ? 10LL * pw10[i - 1] % mod : 1;
read_str(expr);
n = strlen(expr);
q = read_int();
{
static int stk[mxn];
int top = 0;
for (int i = 0; i < (int)(n); ++i) {
jmp[i] = -1;
if (expr[i] == '(') {
stk[top++] = i;
} else if (expr[i] == ')') {
--top;
jmp[i] = stk[top];
jmp[stk[top]] = i;
}
}
for (int i = 0; i < (int)(n); ++i) {
lv[i + 1] = lv[i];
if (expr[i] == '(')
++lv[i + 1];
else if (expr[i] == ')')
--lv[i + 1];
}
for (int i = 0; i < (int)(n); ++i) {
if (expr[i] == '+')
vplus[lv[i]].push_back(i);
else if (expr[i] == '*')
vmul[lv[i]].push_back(i);
}
}
BracketChecker::init();
for (int i = 0; i < (int)(n); ++i)
if (isdigit(expr[i])) elem.push_back(i);
Tree::init();
for (int i = 0; i < (int)(q); ++i) {
L[i] = read_int() - 1;
R[i] = read_int() - 1;
bool fail = false;
fail |= !BracketChecker::check(L[i], R[i] + 1);
fail |= expr[L[i]] == '+' || expr[L[i]] == '*';
fail |= expr[R[i]] == '+' || expr[R[i]] == '*';
if (fail) {
ans[i] = -1;
continue;
}
int u =
elem[std::lower_bound(elem.begin(), elem.end(), L[i]) - elem.begin()];
int v = elem[std::upper_bound(elem.begin(), elem.end(), R[i]) -
elem.begin() - 1];
if (u == v) {
ans[i] = expr[u] - '0';
continue;
}
int l = Tree::lca(u, v);
int ju = Tree::jmp(u, l);
int jv = Tree::jmp(v, l);
Tree::reg_query(l, u, v, ju, jv, i);
}
Number::init();
Tree::proc();
for (int i = 0; i < (int)(q); ++i) write_int(ans[i]);
flush();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double l, r, x, y, k;
cin >> l >> r >> x >> y >> k;
for (int i = x; i <= y; i++) {
if (i * k >= l && i * k <= r) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> pai, peso, path;
void create(int x) {
pai[x] = x;
peso[x] = 1;
path[x] = 0;
}
int find(int x) {
if (!pai.count(x)) {
create(x);
return x;
} else {
if (pai[x] == x) {
return x;
} else {
int rf = pai[x];
int u = find(pai[x]);
path[x] ^= path[rf];
pai[x] = u;
return u;
}
}
}
void join(int u, int v, int z) {
if (find(u) == find(v)) {
return;
}
if (peso[find(u)] > peso[find(v)]) swap(u, v);
z ^= path[v] ^ path[u];
int ca = find(u), cb = find(v);
path[ca] = z;
pai[ca] = cb;
peso[cb] += peso[ca];
}
int32_t main() {
int q;
scanf("%d", &q);
int last = 0;
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
l = last ^ l, r = last ^ r, x = last ^ x;
if (l > r) swap(l, r);
r++;
join(l, r, x);
} else {
int l, r;
scanf("%d%d", &l, &r);
l = last ^ l, r = last ^ r;
if (l > r) swap(l, r);
r++;
int u = -1;
if (find(l) == find(r)) {
u = path[l] ^ path[r];
}
printf("%d\n", u);
if (u == -1) u = 1;
last = u;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 500003;
vector<int> t[maxn * 4];
int a[maxn], nxt[maxn];
pair<int, pair<int, int> > d[maxn];
vector<pair<int, int> > v;
map<long long, long long> firs;
void build(int v, int l, int r) {
if (l == r) {
t[v].push_back(nxt[l]);
return;
}
int c = (l + r) / 2;
build(v * 2 + 0, l, c);
build(v * 2 + 1, c + 1, r);
t[v].reserve(r - l + 2);
merge(t[v * 2 + 0].begin(), t[v * 2].end(), t[v * 2 + 1].begin(),
t[v * 2 + 1].end(), back_inserter(t[v]));
}
int find(int v, int l, int r, int i, int j, int value) {
if (i <= l && r <= j) {
int it = lower_bound(t[v].begin(), t[v].end(), value) - t[v].begin();
if (it == t[v].size()) return n + 1;
return t[v][it];
}
int c = (l + r) / 2;
int ans = n + 1;
if (c >= i) ans = min(ans, find(v * 2 + 0, l, c, i, j, value));
if (c + 1 <= j) ans = min(ans, find(v * 2 + 1, c + 1, r, i, j, value));
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 1; i--) {
nxt[i] = firs[a[i]];
firs[a[i]] = i;
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
d[i] = max(d[i - 1], d[i]);
int l = i;
int r = nxt[i];
if (r == 0) continue;
int rr = nxt[r];
int rrr = nxt[rr];
if (rrr != 0)
d[rrr] = max(d[rrr], make_pair(d[i - 1].first + 1, make_pair(i, i)));
int f = find(1, 1, n, l, r - 1, r + 1);
if (f > n) continue;
d[f] = max(d[f], make_pair(d[i - 1].first + 1, make_pair(l, f)));
}
cout << d[n].first * 4 << "\n";
int cur = n;
while (d[cur].first != 0) {
v.push_back(d[cur].second);
cur = d[cur].second.first - 1;
}
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
int x = a[v[i].first], y = a[v[i].second];
cout << x << " " << y << " " << x << " " << y << " ";
}
cin >> n;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
const long long MOD = 998244353;
long long qpow(long long a, long long p) {
long long res = 1, base = a;
while (p) {
if (p & 1) res = res * base % MOD;
p >>= 1;
base = base * base % MOD;
}
return res;
}
long long mod_inv(long long x) { return qpow(x, MOD - 2); }
long long fac[MAXN + 5], ifac[MAXN + 5];
long long choose(long long n, long long k) {
return fac[n] * ifac[k] % MOD * ifac[n - k] % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long N;
cin >> N;
fac[0] = ifac[0] = 1;
for (int i = 1; i <= N; i++) {
fac[i] = fac[i - 1] * i % MOD;
ifac[i] = mod_inv(fac[i]);
}
long long sum1 = qpow(qpow(3, N) - 3, N);
long long sum2 = 0;
for (int i = 1; i <= N; i++) {
sum2 += qpow(-1, i + 1) * choose(N, i) % MOD *
((qpow(3, i) - 3) * (qpow(3, N * (N - i))) % MOD +
(3 * (qpow(qpow(3, N - i) - 1, N)))) %
MOD;
sum2 %= MOD;
}
cout << ((qpow(3, N * N) - sum1 + sum2) % MOD + MOD) % MOD << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
int c4 = n / 4;
int c7 = n / 7;
int i, j;
int flag = 0;
for (i = 0; i <= c4; i++) {
for (j = 0; j <= c7; j++) {
if (i * 4 + j * 7 == n) {
flag = 1;
break;
}
}
if (flag == 1) break;
}
if (flag == 0)
printf("-1\n");
else {
for (int k = 1; k <= i; k++) printf("4");
for (int k = 1; k <= j; k++) printf("7");
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 100005;
const int M = 200010;
using namespace std;
int n, T;
int fa[N][20], dep[N];
int cnt = 0, dfn[N], las[N];
long long a[N], sum[N], val[N];
int edge[M], lst[N], nxt[M], t = 0;
int lowbit(int x) { return x & (-x); }
void UPD(int x, long long num) {
if (num == 0) return;
for (; x <= n; x += lowbit(x)) val[x] += num;
}
long long GET(int x) {
long long ans = 0;
while (x > 0) {
ans += val[x];
x -= lowbit(x);
}
return ans;
}
void ADD(int x, int y) {
edge[++t] = y;
nxt[t] = lst[x];
lst[x] = t;
}
void READ() {
int u, v;
scanf("%d%d", &n, &T);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (a[i] < 0) a[i] = -a[i];
}
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
ADD(u, v);
ADD(v, u);
}
}
void SEARCH(int x, int pa) {
dfn[x] = ++cnt;
fa[x][0] = pa;
dep[x] = dep[pa] + 1;
sum[x] = sum[pa] + a[x];
for (int r = lst[x]; r; r = nxt[r]) {
if (edge[r] == pa) continue;
SEARCH(edge[r], x);
}
las[x] = cnt;
}
void INIT() {
cnt = 0;
dep[0] = 0;
sum[0] = 0;
SEARCH(1, 0);
for (int i = 1; i <= 18; i++) {
for (int x = 1; x <= n; x++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
}
}
long long VAL(int x) { return sum[x] + GET(dfn[x]); }
int LCA(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
int de = dep[y] - dep[x];
for (int i = 18; i >= 0; i--) {
if ((de >> i) & 1) y = fa[y][i];
}
if (x == y) return x;
for (int i = 18; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
return fa[x][0];
}
void SOLVE() {
int pd, u;
scanf("%d%d", &pd, &u);
if (pd == 1) {
long long v;
scanf("%lld", &v);
if (v < 0) v = -v;
long long now = v - a[u];
a[u] = v;
UPD(dfn[u], now);
UPD(las[u] + 1, -now);
}
if (pd == 2) {
int v;
scanf("%d", &v);
long long ans = VAL(u) + VAL(v) - 2 * VAL(LCA(u, v)) + a[LCA(u, v)];
ans *= 2;
ans -= a[u] + a[v];
printf("%lld\n", ans);
}
}
int main() {
READ();
INIT();
while (T--) SOLVE();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> printDivisors(long long n) {
vector<long long> v;
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
return v;
}
int32_t main() {
long long n;
cin >> n;
vector<long long> v, sq;
v = printDivisors(n);
sort(v.begin(), v.end(), greater<long long>());
long long ans;
for (long long i = 0; i < n; i++) {
bool b = true;
for (long long j = 2; j <= v[i]; j++) {
long long num = j * j;
if (num > v[i]) {
break;
} else {
if (v[i] % num == 0) {
b = false;
break;
}
}
}
if (b) {
ans = v[i];
break;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
multiset<pair<int, int> > peoples;
vector<int> vt;
int main() {
int n, M, T;
scanf("%d%d%d", &n, &M, &T);
for (int i = 0; i < n; i++) {
int ho, mi, se;
scanf("%d:%d:%d", &ho, &mi, &se);
int time = ho * 60 * 60 + mi * 60 + se;
vt.push_back(time);
}
vector<int> v;
sort(vt.begin(), vt.end());
bool checked = false;
int counter = 0;
for (unsigned int i = 0; i < vt.size();) {
int cur_time = vt[i];
while (!peoples.empty() && peoples.begin()->first + T <= cur_time) {
peoples.erase(peoples.begin());
}
while (i < vt.size() && cur_time == vt[i]) {
if (peoples.size() < M) {
counter++;
peoples.insert(make_pair(vt[i], counter));
v.push_back(counter);
} else {
auto it = --peoples.end();
pair<int, int> p = *it;
p.first = cur_time;
peoples.erase(it);
peoples.insert(p);
v.push_back(counter);
}
++i;
}
if (peoples.size() == M) {
checked = true;
}
}
if (checked) {
printf("%d\n", counter);
for (unsigned int i = 0; i < v.size(); i++) {
printf("%d\n", v[i]);
}
} else {
printf("No solution\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> v, e, o, q;
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
long long t, a, b;
cin >> t;
while (t--) {
long long a, b, c, n;
cin >> a >> b >> c >> n;
long long d = max(a, max(b, c));
d = d - a + d - b + d - c;
if (n < d)
cout << "NO" << endl;
else {
n = n - d;
if (n % 3 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int mod = 998244353;
const int MAXN = 1007;
long long a[MAXN];
long long dp[MAXN];
long long dp2[MAXN];
long long C[MAXN][MAXN];
int n;
long long solve(long long pos);
long long solveSum(long long pos) {
if (pos >= n) return 0;
if (dp2[pos] != -1) return dp2[pos];
dp2[pos] = (solve(pos) + solveSum(pos + 1)) % mod;
return dp2[pos];
}
long long solve(long long pos) {
if (pos >= n) return 0;
if (a[pos] <= 0) return 0;
if (pos + a[pos] >= n) return 0;
if (dp[pos] != -1) return dp[pos];
dp[pos] = 0;
for (int i = a[pos]; i < n; ++i) {
if (pos + i < n) {
dp[pos] += C[i - 1][a[pos] - 1] * (solveSum(pos + i + 1) + 1);
dp[pos] %= mod;
}
}
return dp[pos];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < MAXN; ++i) {
C[i][i] = C[i][0] = 1;
for (int c = 1; c < i; ++c) {
C[i][c] = C[i - 1][c] + C[i - 1][c - 1];
C[i][c] %= mod;
}
}
memset(dp, -1, sizeof(dp));
memset(dp2, -1, sizeof(dp2));
cout << solveSum(0) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, x, cnt_0[2], cnt_1[2];
void read(int* a) {
fill(a, a + 2, 0);
cin >> n;
while (n--) {
cin >> x;
a[x & 1]++;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> t;
while (t--) {
read(cnt_0);
read(cnt_1);
cout << 1LL * cnt_0[0] * cnt_1[0] + 1LL * cnt_0[1] * cnt_1[1] << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> ima;
int main() {
ios_base::sync_with_stdio(false);
cout.precision(10);
cout << fixed;
string s;
cin >> s;
int n = 5;
ima[s[0]] = 1;
ima[s[1]] = 1;
while (n--) {
cin >> s;
if (ima[s[0]] || ima[s[1]]) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long int n, m;
int k = 0;
while (scanf("%lld", &n) != EOF) {
if (n % 2 == 0) {
printf("NO\n");
} else {
if (n == 1 || n == 3) {
printf("NO\n");
} else {
m = (n - 3) / 2;
printf("%d %lld\n", 1, m);
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double w, h, a, x, A, s;
int main() {
cin >> w >> h >> a;
if (w < h) swap(w, h);
if (a > 90) a = 90 - (a - 90);
if (a == 0) {
printf("%.9lf\n", h * w);
return 0;
}
a = a / 180 * 3.1415926535898;
if (a >= 2 * atan(h / w)) {
printf("%.9lf", h * h / sin(a));
return 0;
}
A = 1 / tan(a) + 1 / sin(a);
x = (h - A * w) / (1 - A * A);
s = 0;
s += 2 * x * x / 2 / (tan(a));
double tep = w - x * A;
s += 2 * tep * tep / 2 / (tan(a));
printf("%.9lf\n", h * w - s);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 100005;
const double PI = acos(-1.0);
const double eps = 1e-6;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
long long ans = 0, m, k, xx[10], tt[10], kk[10];
long long calc(long long x, long long t, long long k) {
for (int i = (1); i <= (6); ++i)
xx[i] = xx[i - 1] * x % _p, tt[i] = tt[i - 1] * t % _p;
k %= _p;
long long ans = 70 * k % _p + 105 * kk[2] % _p + 35 * kk[3] % _p +
64 * t % _p + 42 * k % _p * t % _p + 12 * tt[2] % _p +
21 * k % _p * tt[2] % _p + 30 * tt[5] % _p + 10 * tt[6] % _p;
ans += 84 * tt[3] % _p * xx[2] % _p + 42 * tt[4] % _p * xx[2] % _p +
140 * xx[2] % _p + 105 * k % _p * xx[2] % _p +
70 * xx[4] % _p * t % _p + 70 * xx[4] % _p * tt[2] % _p +
70 * xx[6] % _p;
ans -= 94 * tt[3] % _p + 42 * k % _p * tt[3] % _p + 22 * tt[4] % _p +
21 * k % _p * tt[4] % _p + 154 * t % _p * xx[2] % _p +
70 * k % _p * t % _p * xx[2] % _p;
(ans -= 112 * tt[2] % _p * xx[2] % _p +
70 * k % _p * tt[2] % _p * xx[2] % _p + 210 * xx[4] % _p +
105 * xx[4] % _p * k % _p) %= _p,
(ans *= (2 * t + 1) % _p) %= _p;
return ans;
}
int main() {
scanf("%I64d", &m), k = floor(sqrt(m * 1.0));
xx[0] = tt[0] = kk[0] = 1;
for (int i = (1); i <= (3); ++i) kk[i] = kk[i - 1] * (m % _p) % _p;
for (int x = (-k); x <= (k); ++x)
ans += calc(x, (long long)floor(sqrt(m - (long long)x * x)), m);
printf("%I64d\n", (ans % _p * 604761909 % _p + _p) % _p);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int prim[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53}, n;
unsigned long long ans = ~(unsigned long long)0, tmp;
void Dfs(int i, unsigned long long v, int cnt) {
if (cnt == n && ans > v) {
ans = v;
return;
}
for (int j = 1; j < 61; ++j) {
tmp = v * prim[i];
if (tmp < v || tmp > ans || cnt * (j + 1) > n) return;
Dfs(i + 1, (v = tmp), cnt * (j + 1));
}
}
int main() {
scanf("%d", &n);
Dfs(0, 1, 1);
printf("%I64u\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
long long int ar[1000010];
long long int a[3];
long long int already[(1 << 24) + 10];
int dp[(1 << 24) + 10];
int n, tot;
int main() {
n = nxt();
tot = 1 << n;
tot--;
for (int i = 0; i < n; i++) {
ar[i] = lxt();
}
int k = nxt();
for (int i = 0; i < k; i++) a[i] = lxt();
dp[0] = 1;
for (int i = 1; i <= tot; i++) {
int bt = __builtin_ctz(i);
long long int sum = already[i] = already[i ^ (1 << bt)] + ar[bt];
if (sum == a[0] || sum == a[1]) continue;
for (int j = 0; j < n; j++) {
if (ison(i, j) == 1) {
dp[i] += dp[i ^ (1 << j)];
if (dp[i] >= 1000000007) dp[i] -= 1000000007;
}
}
}
printf("%d\n", dp[tot]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int l[305], c[305];
std::map<int, int> f;
int Gcd(int a, int b) { return b ? Gcd(b, a % b) : a; }
int min(int x, int y) {
x -= y;
return y + (x & (x >> 31));
}
int main() {
int n;
scanf("%d", &n);
int gcd = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &l[i]);
gcd = Gcd(gcd, l[i]);
}
if (gcd != 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
for (int i = 1; i <= n; ++i) {
if (f.count(l[i]))
f[l[i]] = min(f[l[i]], c[i]);
else
f[l[i]] = c[i];
}
for (int i = 1; i <= n; ++i) {
std::map<int, int>::iterator j;
for (j = f.begin(); j != f.end(); ++j) {
int gcd = Gcd(l[i], j->first);
int cost = j->second;
if (f.count(gcd))
f[gcd] = min(cost + c[i], f[gcd]);
else
f[gcd] = cost + c[i];
}
}
printf("%d\n", f[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, i, j;
cin >> n >> d;
vector<pair<pair<string, string>, int> > v(n);
set<pair<string, string> > s;
vector<pair<string, string> > res;
int ss = 0;
for (i = 0; i < n; i = i + 1) {
cin >> v[i].first.first;
cin >> v[i].first.second;
cin >> v[i].second;
string s1 = v[i].first.first;
string s2 = v[i].first.second;
int diff = v[i].second;
for (j = 0; j < i; j = j + 1) {
if (s2 == v[j].first.first && s1 == v[j].first.second &&
diff - v[j].second > 0 && diff - v[j].second <= d) {
int d1 = s.size(), c1 = 0, c2 = 0;
s.insert(make_pair(s1, s2));
int curs = s.size();
if (curs == d1 + 1) {
s.erase(make_pair(s1, s2));
c1++;
}
s.insert(make_pair(v[j].first.first, v[j].first.second));
int curs2 = s.size();
if (curs2 == d1 + 1) {
s.erase(make_pair(v[j].first.first, v[j].first.second));
c2++;
}
if (c1 > 0 && c2 > 0) {
res.push_back(make_pair(s1, s2));
s.insert(make_pair(s1, s2));
}
}
}
}
cout << res.size() << endl;
for (i = 0; i < res.size(); i = i + 1) {
cout << res[i].first << " " << res[i].second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
string v[100005], s;
int nextSign[100005][40];
inline int getC(char c) {
if ('a' <= c && c <= 'z') return c - 'a';
if ('0' <= c && c <= '9') return 26 + c - '0';
if (c == '<') return 36;
return 37;
}
bool works;
inline bool check(int p) {
if (p == -1) return works = false;
return works = true;
}
int main() {
int N;
cin >> N;
for (int i = (0); i < (N); ++i) cin >> v[i];
cin >> s;
s = "$" + s;
memset(nextSign, 0xff, sizeof(nextSign));
int L = int((s).size());
if (L <= 3) {
printf("no\n");
return 0;
}
nextSign[L - 2][getC(s[L - 1])] = L - 1;
for (int i = (L - 2) - 1; i >= (0); --i)
for (int j = (0); j < (40); ++j) {
nextSign[i][j] = nextSign[i + 1][j];
nextSign[i][getC(s[i + 1])] = i + 1;
}
int p = 0;
p = nextSign[p][getC('<')];
check(p);
if (works == false) {
printf("no\n");
return 0;
}
p = nextSign[p][getC('3')];
if (works == false) {
printf("no\n");
return 0;
}
check(p);
for (int i = (0); i < (N); ++i) {
for (int j = (0); j < (int((v[i]).size())); ++j) {
p = nextSign[p][getC(v[i][j])];
if (!check(p)) break;
}
if (!works) break;
p = nextSign[p][getC('<')];
if (!check(p)) break;
p = nextSign[p][getC('3')];
if (!check(p)) break;
}
if (works)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v1, v2, v3, v;
cin >> v1 >> v2 >> v3 >> v;
if (v > 2 * v3 || v3 > 2 * v || v >= v2)
cout << -1 << "\n";
else {
int a = max(v, v3);
cout << 2 * v1 << " " << 2 * v2 << " " << a << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100111, inf = 1000111222;
char ans[4];
bool query(int a, int b) {
cout << "1 " << a << ' ' << b << endl;
fflush(stdout);
cin >> ans;
return ans[0] == 'T';
}
int getp(int l, int r) {
while (l < r) {
int mid = (l + r) / 2;
if (query(mid, mid + 1)) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
int main() {
int n, k;
cin >> n >> k;
int l = 1, r = n;
int fst = getp(1, n), scd = -1, th = -1;
int a1 = fst, a2;
if (fst < n) {
scd = getp(fst + 1, n);
}
if (fst > 1) {
th = getp(1, fst - 1);
}
if (scd == -1) {
cout << "2 " << fst << ' ' << th << endl;
return 0;
} else if (th == -1) {
cout << "2 " << fst << ' ' << scd << endl;
return 0;
}
if (scd == fst + 1 && query(scd, fst) == 0) {
cout << "2 " << fst << ' ' << th << endl;
return 0;
} else {
cout << "2 " << fst << ' ' << scd << endl;
return 0;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, sq = 285 + 35;
int n, m, q;
pair<int, int> ans[maxn][11];
string s[maxn];
bool mark[sq + 10][13];
pair<int, int> mnd(int a, int b, int c) {
if (s[a][b] == '^')
a--;
else if (s[a][b] == '>')
b++;
else if (s[a][b] == '<')
b--;
if (b == -1 || b == m || a == -1 || a < c * sq) return {a, b};
if (mark[a % sq][b] == 1 && ans[a][b].first == -3)
return ans[a][b] = {-2, -2};
else if (mark[a % sq][b] == 1)
return ans[a][b];
mark[a % sq][b] = 1;
return ans[a][b] = mnd(a, b, c);
}
void upt(int a) {
for (int i = 0; i < sq; i++)
for (int j = 0; j < 13; j++) mark[i][j] = 0;
for (int i = sq * a; i < (a + 1) * sq && i < n; i++)
for (int j = 0; j < m; j++)
if (mark[i % sq][j] == 0) {
ans[i][j] = mnd(i, j, a);
}
}
pair<int, int> find(int a, int b) {
if (ans[a][b].first == -2 || ans[a][b].first == -1 || ans[a][b].second == m ||
ans[a][b].second == -1)
return ans[a][b];
return find(ans[a][b].first, ans[a][b].second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = {-3, -3};
for (int i = 0; i <= (n - 1) / sq; i++) upt(i);
while (q--) {
char type, c;
cin >> type;
int x, y;
cin >> x >> y;
x--, y--;
if (type == 'C') {
cin >> c;
s[x][y] = c;
int k = x / sq;
for (int i = k * sq; i < (k + 1) * sq && i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = {-3, -3};
upt(x / sq);
} else {
auto zx = find(x, y);
cout << zx.first + 1 << " " << zx.second + 1 << endl;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
vector<pair<long long, long long> > in(n);
for (int i = 0; i < n; i++) cin >> in[i].first, in[i].second = -1;
for (int i = 0; i < n; i++) in[i].first--;
for (int i = 0; i < n; i++) {
if (in[i].second == -1) {
long long count = 1, j = in[i].first;
while (j != i) count++, j = in[j].first;
in[i].second = count;
while (j != i) in[j].second = count, j = in[i].first;
}
}
for (int i = 0; i < n; i++) cout << in[i].second << " ";
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
const int N = 205, M = N * N;
int n, m, f[M], cid[M], id[N][N], mod, ans, count;
std::string s[N];
void no() { std::cout << "0\n", std::exit(0); }
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void link(int x, int y) {
if (find(x) == find(y)) no();
f[find(x)] = find(y);
}
void reduce(int &x) { x += x >> 31 & mod; }
int pow(int x, int y, int ans = 1) {
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) ans = (long long)ans * x % mod;
return ans;
}
struct matrix {
int a[N][N], size;
void link(int x, int y) { --a[x][y], --a[y][x], ++a[x][x], ++a[y][y]; }
void clear() { std::memset(a, 0, sizeof a); }
int solve() {
int ans = 1;
for (int i = 0; i < size; ++i)
for (int j = 0; j < size; ++j) reduce(a[i][j] %= mod);
for (int i = 0; i < size; ++i) {
int row = -1;
for (int j = i; j < size; ++j)
if (a[j][i]) row = j;
if (!~row) return 0;
for (int j = i; j < size; ++j) std::swap(a[i][j], a[row][j]);
if (row != i) ans = mod - ans;
ans = (long long)ans * a[i][i] % mod;
int inv = pow(a[i][i], mod - 2);
for (int j = i; j < size; ++j) a[i][j] = (long long)a[i][j] * inv % mod;
for (int j = i + 1; j < size; ++j) {
int ratio = mod - a[j][i];
for (int k = i; k < size; ++k) {
a[j][k] = (a[j][k] + (long long)ratio * a[i][k]) % mod;
}
}
}
return ans;
}
} A;
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m >> mod;
for (int i = 0; i < n; ++i)
std::cin >> s[i], count += std::count(s[i].begin(), s[i].end(), '*');
int bidx = 0, widx = 0;
for (int i = 0; i <= n; ++i)
for (int j = i & 1; j <= m; j += 2) id[i][j] = bidx++;
for (int i = 0; i < bidx; ++i) f[i] = i;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == '/') {
if (i + j & 1) link(id[i + 1][j], id[i][j + 1]);
} else if (s[i][j] == '\\') {
if (i + j & 1 ^ 1) link(id[i][j], id[i + 1][j + 1]);
}
int bbidx = 0;
for (int i = 0; i < bidx; ++i)
if (i == find(i)) cid[i] = bbidx++;
if (bbidx <= count + 1) {
for (int i = 0; i < bidx; ++i) cid[i] = cid[find(i)];
A.size = bbidx - 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == '*') {
if (i + j & 1 ^ 1)
A.link(cid[id[i][j]], cid[id[i + 1][j + 1]]);
else
A.link(cid[id[i][j + 1]], cid[id[i + 1][j]]);
}
ans = (ans + A.solve()) % mod;
}
A.clear();
for (int i = 0; i <= n; ++i)
for (int j = i & 1 ^ 1; j <= m; j += 2) id[i][j] = widx++;
for (int i = 0; i < widx; ++i) f[i] = i;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == '/') {
if (i + j & 1 ^ 1) link(id[i + 1][j], id[i][j + 1]);
} else if (s[i][j] == '\\') {
if (i + j & 1) link(id[i][j], id[i + 1][j + 1]);
}
int wwidx = 0;
for (int i = 0; i < widx; ++i)
if (i == find(i)) cid[i] = wwidx++;
if (wwidx <= count + 1) {
for (int i = 0; i < widx; ++i) cid[i] = cid[find(i)];
A.size = wwidx - 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == '*') {
if (i + j & 1)
A.link(cid[id[i][j]], cid[id[i + 1][j + 1]]);
else
A.link(cid[id[i][j + 1]], cid[id[i + 1][j]]);
}
ans = (ans + A.solve()) % mod;
}
std::cout << ans << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct SA {
int n;
vector<int> C, R, R_, sa, sa_, lcp;
inline int gr(int i) { return i < n ? R[i] : 0; }
void csort(int maxv, int k) {
C.assign(maxv + 1, 0);
for (int i = 0; i < (int)n; i++) C[gr(i + k)]++;
for (int i = (int)1; i < (int)maxv + 1; i++) C[i] += C[i - 1];
for (int i = (int)n - 1; i >= 0; i--) sa_[--C[gr(sa[i] + k)]] = sa[i];
sa.swap(sa_);
}
void getSA(vector<int>& s) {
R = R_ = sa = sa_ = vector<int>(n);
for (int i = 0; i < (int)n; i++) sa[i] = i;
sort(sa.begin(), sa.end(), [&s](int i, int j) { return s[i] < s[j]; });
int r = R[sa[0]] = 1;
for (int i = (int)1; i < (int)n; i++)
R[sa[i]] = (s[sa[i]] != s[sa[i - 1]]) ? ++r : r;
for (int h = 1; h < n && r < n; h <<= 1) {
csort(r, h);
csort(r, 0);
r = R_[sa[0]] = 1;
for (int i = (int)1; i < (int)n; i++) {
if (R[sa[i]] != R[sa[i - 1]] || gr(sa[i] + h) != gr(sa[i - 1] + h)) r++;
R_[sa[i]] = r;
}
R.swap(R_);
}
}
void getLCP(vector<int>& s) {
lcp.assign(n, 0);
int k = 0;
for (int i = 0; i < (int)n; i++) {
int r = R[i] - 1;
if (r == n - 1) {
k = 0;
continue;
}
int j = sa[r + 1];
while (i + k < n && j + k < n and s[i + k] == s[j + k]) k++;
lcp[r] = k;
if (k) k--;
}
}
SA(vector<int>& s) {
n = s.size();
getSA(s);
getLCP(s);
}
};
string S1, S2;
int main() {
cin >> S1 >> S2;
vector<int> aux;
for (char c : S1) aux.push_back(c - 'a' + 3);
aux.push_back(1);
for (char c : S2) aux.push_back(c - 'a' + 3);
aux.push_back(2);
SA sa(aux);
int N = S1.size() + S2.size() + 2, ans = INT_MAX;
for (int i = 0; i < (int)N - 1; i++)
if (i) {
int a = (sa.sa[i] > S1.size() ? 2 : 1);
int b = (sa.sa[i + 1] > S1.size() ? 2 : 1);
if (a != b) {
int x = sa.lcp[i - 1], y = sa.lcp[i], z = sa.lcp[i + 1];
if (y > max(x, z)) ans = min(ans, max(x, z) + 1);
}
}
if (ans == INT_MAX)
cout << -1 << '\n';
else
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> s[1505];
struct P {
int u, fa;
vector<pair<int, int>> arr;
};
map<pair<int, int>, int> ma;
int SZ[1505];
int dfs(int u, int fa) {
int cnt = 1;
for (auto v : s[u]) {
if (v == fa) continue;
cnt += dfs(v, u);
}
return SZ[u] = cnt;
}
int ans[1505];
int mx, my;
double pi = acos(-1);
int cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int first, second;
scanf("%d%d", &first, &second);
s[first].push_back(second);
s[second].push_back(first);
}
dfs(1, -1);
vector<pair<int, int>> in;
for (int i = 0; i < n; i++) {
int first, second;
scanf("%d%d", &first, &second);
in.push_back({first, second});
ma[in.back()] = i + 1;
}
sort(in.begin(), in.end(), cmp);
queue<P> que;
que.push({1, -1, in});
while (que.size()) {
P out = que.front();
que.pop();
ans[ma[out.arr[0]]] = out.u;
if (out.arr.size() == 1) {
continue;
}
mx = out.arr[0].first;
my = out.arr[0].second;
vector<pair<double, int>> arr;
for (int i = 1; i < out.arr.size(); i++) {
double deg = atan2(out.arr[i].second - my, out.arr[i].first - mx);
arr.push_back({deg, i});
}
sort(arr.begin(), arr.end());
int now = 0;
for (auto v : s[out.u]) {
if (v == out.fa) continue;
vector<pair<int, int>> tmp;
for (int i = 0; i < SZ[v]; i++) tmp.push_back(out.arr[arr[now++].second]);
sort(tmp.begin(), tmp.end(), cmp);
que.push({v, out.u, tmp});
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105 + 5;
const int MOD = 1e9 + 7;
int power(int a, int b, int m = MOD) {
if (b == 0) return 1;
if (b == 1) return a;
int x = power(a, b / 2, m) % m;
x = (x * x) % m;
if (b % 2) return (x * a) % m;
return x;
}
long long n, m;
int main() {
scanf("%lld%lld", &n, &m);
while (1) {
if (n < 2 * m && m < 2 * n) break;
if (n == 0 || m == 0) break;
if (n >= 2 * m) n = n % (2 * m);
if (n == 0 || m == 0) break;
if (m >= 2 * n) m %= (2 * n);
if (m == 0) break;
}
printf("%lld %lld\n", n, m);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
while (n--) {
cin >> i;
if (i == 1) {
cout << "HARD" << endl;
return 0;
}
}
cout << "EASY" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
using namespace std;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
long long int Modular_Exponentiation(long long int x, long long int n,
long long int M) {
if (n == 0) return 1;
if (n % 2)
return (x * Modular_Exponentiation((x * x) % M, n / 2, M)) % M;
else
return (Modular_Exponentiation((x * x) % M, n / 2, M)) % M;
}
void solve() {
string second[105];
int n, k;
cin >> n >> k;
for (long long int i = 0; i < n; ++i) {
second[i] = "Aa";
second[i][0] += i / 26;
second[i][1] += i % 26;
}
for (long long int i = 0; i < n - k + 1; ++i) {
string str;
cin >> str;
if (str[0] == 'N') second[i + k - 1] = second[i];
}
for (long long int i = 0; i < n; ++i) cout << second[i] << " ";
cout << "\n";
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 223456;
long long md = 1e9 + 7;
long long N, k;
int grand[MX];
int par[MX];
int flip[MX];
int now[MX];
int goal[MX];
vector<vector<int> > G(MX);
void dfs1(int u, int p) {
par[u] = p;
grand[u] = par[par[u]];
for (int i = 0; i < G[u].size(); i++) {
int ch = G[u][i];
if (ch != p) {
dfs1(ch, u);
}
}
}
vector<int> ans;
void dfs2(int u, int p) {
if (grand[u] != -1) {
flip[u] += flip[grand[u]];
}
if (flip[u] % 2) now[u] = !now[u];
if (now[u] != goal[u]) {
ans.push_back(u);
flip[u]++;
now[u] = !now[u];
}
for (int i = 0; i < G[u].size(); i++) {
int ch = G[u][i];
if (ch != p) dfs2(ch, u);
}
}
int main() {
memset(par, -1, sizeof par);
memset(grand, -1, sizeof grand);
memset(flip, 0, sizeof flip);
cin >> N;
for (int i = 0; i < N - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= N; i++) cin >> now[i];
for (int i = 1; i <= N; i++) cin >> goal[i];
dfs1(1, -1);
dfs2(1, -1);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
string s;
map<string, int> m[5];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s;
m[s.length()][s]++;
}
for (int i = 1; i <= n; i++) {
cin >> s;
m[s.length()][s]--;
}
for (int i = 1; i <= 4; i++) {
for (auto w : m[i]) {
if (w.second > 0) ans += w.second;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
char ch;
x = 0;
bool fl = false;
while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
;
(fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
if (x / 10) output(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
if (x < 0) putchar('-'), x = -x;
output(x);
putchar(' ');
}
template <class T>
inline void prt(T a[], int st, int nd) {
for (register int i = st; i <= nd; ++i) ot(a[i]);
putchar('\n');
}
namespace Modulo {
const int mod = 998244353;
int ad(int x, int y) { return (x + y) >= mod ? x + y - mod : x + y; }
void inc(int &x, int y) { x = ad(x, y); }
int mul(int x, int y) { return (long long)x * y % mod; }
void inc2(int &x, int y) { x = mul(x, y); }
int qm(int x, int y = mod - 2) {
int ret = 1;
while (y) {
if (y & 1) ret = mul(x, ret);
x = mul(x, x);
y >>= 1;
}
return ret;
}
} // namespace Modulo
namespace Miracle {
const int N = 300000 + 5;
const int inf = 0x3f3f3f3f;
int n, m;
int du[N];
int b[N][2];
vector<int> to[N];
int go[N];
int q[N], l, r, df;
void topo() {
l = 1, r = 0;
df = 0;
for (register int i = 1; i <= n; ++i) {
if (du[i] == 0) q[++r] = i;
}
while (l <= r) {
int x = q[l];
++df;
int sz = r - l + 1;
++l;
if (sz == 1) {
go[x] += n - df;
} else if (sz == 2) {
int b = q[l];
int lp = 0;
for (const auto &y : to[b]) {
if (du[y] == 1) {
lp = 1;
break;
}
}
if (!lp) {
go[x] += n - df - 1;
}
}
for (const auto &y : to[x]) {
--du[y];
if (du[y] == 0) {
q[++r] = y;
}
}
}
}
int main() {
rd(n);
rd(m);
for (register int i = 1; i <= m; ++i) {
rd(b[i][0]);
rd(b[i][1]);
to[b[i][0]].push_back(b[i][1]);
++du[b[i][1]];
}
topo();
for (register int i = 1; i <= n; ++i) to[i].clear(), du[i] = 0;
for (register int i = 1; i <= m; ++i) {
to[b[i][1]].push_back(b[i][0]);
++du[b[i][0]];
}
topo();
int ans = 0;
for (register int i = 1; i <= n; ++i) {
if (go[i] >= n - 2) ++ans;
}
ot(ans);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int oo = 1e9;
int n, m, err = 0;
vector<int> v;
pair<int, int> a[13], b[13];
set<int> st1, st2;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
if (a[i].first > a[i].first) swap(a[i].first, a[i].second);
}
for (int i = 0; i < m; i++) {
cin >> b[i].first >> b[i].second;
if (b[i].first > b[i].first) swap(b[i].first, b[i].second);
}
for (int i = 0; i < n; i++) {
int f = 0, s = 0;
for (int j = 0; j < m; j++) {
if (a[i].first == b[j].first && a[i].second == b[j].second) continue;
if (a[i].first == b[j].first || a[i].first == b[j].second)
f++;
else if (a[i].second == b[j].first || a[i].second == b[j].second)
s++;
}
if (f && s && a[i].first != a[i].second) return cout << -1, 0;
if (f) {
v.push_back(a[i].first);
st1.insert(v.back());
continue;
}
if (s) v.push_back(a[i].second), st1.insert(v.back());
;
}
if (v.size() == 0) return cout << -1, 0;
int x = v.size();
for (int i = 0; i < m; i++) {
int f = 0, s = 0;
for (int j = 0; j < n; j++) {
if (a[j].first == b[i].first && a[j].second == b[i].second) continue;
if (a[j].first == b[i].first || a[j].second == b[i].first)
f++;
else if (a[j].first == b[i].second || a[j].second == b[i].second)
s++;
}
if (f && s && b[i].first != b[i].second) return cout << -1, 0;
if (f) {
v.push_back(b[i].first);
st2.insert(v.back());
continue;
}
if (s) v.push_back(b[i].second), st2.insert(v.back());
}
if (v.size() == x) return cout << -1, 0;
if (st1.size() == 1) return cout << v[0] << endl, 0;
if (st2.size() == 1) return cout << v.back() << endl, 0;
if (v.size() == x + 1)
cout << v.back();
else
cout << 0 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int odd = 0, ev = 0;
for (int i = 0, num; i < n; i++) {
cin >> num;
if (num % 2 == 0) {
ev++;
} else {
odd++;
}
}
if (odd == 0) {
cout << "NO";
} else {
if (ev == 0 && odd % 2 == 0) {
cout << "NO";
} else {
cout << "YES";
}
}
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
int ans = 0;
for (int i = 0; i < 5; i++) {
cin >> x;
ans += x;
}
if (ans == 0) {
cout << "-1";
return 0;
}
if (ans % 5 == 0) {
cout << (int)(ans / 5);
} else {
cout << "-1";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int mat[22][22];
int cnt[22];
int w[22][22];
bool ok1() {
int ans;
for (int i = 1; i <= n; i++) {
ans = 0;
for (int j = 1; j <= m; j++) {
if (mat[j][i] != j) ans++;
}
if (ans != 2 && ans != 0) return false;
}
return true;
}
bool ok2() {
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) {
swap(mat[i], mat[j]);
if (ok1()) return true;
swap(mat[i], mat[j]);
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &mat[j][i]);
if (ok1())
printf("YES\n");
else if (ok2())
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long b, p, first;
cin >> b >> p >> first;
long long h, c;
cin >> h >> c;
if (h > c) {
long long a = min(b / 2, p);
long long x = b - a * 2;
long long ans = a * h;
long long y = min(x / 2, first);
ans += c * y;
cout << ans << "\n";
} else {
long long a = min(b / 2, first);
long long x = b - a * 2;
long long ans = a * c;
long long y = min(x / 2, p);
ans += y * h;
cout << ans << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, m, a, b;
double mn = 9999999;
cin >> n >> m;
while (n--) {
cin >> a >> b;
mn = min(mn, a / b);
}
printf("%.8lf\n", m * mn);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, c = getchar(), f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 400000 + 10;
int n, m, L, R, V, a[N], t[N * 4], cnt[2];
void build(int o, int l, int r) {
if (l == r) {
t[o] = a[l];
return;
}
build(o << 1, l, ((l + r) >> 1));
build(o << 1 | 1, ((l + r) >> 1) + 1, r);
t[o] = min(t[o << 1], t[o << 1 | 1]);
}
int query(int o, int l, int r) {
if (L <= l && R >= r) return t[o];
int res = 1e9;
if (L <= ((l + r) >> 1)) res = query(o << 1, l, ((l + r) >> 1));
if (R > ((l + r) >> 1))
res = min(query(o << 1 | 1, ((l + r) >> 1) + 1, r), res);
return res;
}
void modify(int o, int l, int r) {
if (l == r) {
t[o] = V;
return;
}
if (L <= ((l + r) >> 1))
modify(o << 1, l, ((l + r) >> 1));
else
modify(o << 1 | 1, ((l + r) >> 1) + 1, r);
t[o] = min(t[o << 1], t[o << 1 | 1]);
}
struct node {
int r1, c1, r2, c2, id, mn;
bool operator<(const node &B) const { return r2 < B.r2; }
} q[2][N];
int ans[N], s[N];
int dicl(int x) {
int res = 0;
for (int l = 1, r = *s; l <= r;)
if (s[((l + r) >> 1)] < x)
res = ((l + r) >> 1), l = ((l + r) >> 1) + 1;
else
r = ((l + r) >> 1) - 1;
return res + 1;
}
int dicp(int l, int x) {
int res = *s + 1, tmp = l;
for (int r = *s; l <= r;)
if (a[s[((l + r) >> 1)]] >= x)
res = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
return max(res - 1, tmp);
}
int dicr(int x) {
int res = *s + 1;
for (int l = 1, r = *s; l <= r;)
if (s[((l + r) >> 1)] > x)
res = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
return res - 1;
}
int dicr_(int x) {
int res = 0;
for (int l = 1, r = *s; l <= r;)
if (s[((l + r) >> 1)] > x)
res = ((l + r) >> 1), l = ((l + r) >> 1) + 1;
else
r = ((l + r) >> 1) - 1;
return res + 1;
}
int dic1(int l, int r, int x) {
int res = r + 1;
for (; l <= r;)
if (a[s[((l + r) >> 1)]] > x)
res = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
return res - 1;
}
void work(int ID) {
*s = 0;
memset(t, 60, sizeof t);
for (int i = 1, pre = 0; i <= cnt[ID]; i++) {
int r1 = q[ID][i].r1, c1 = q[ID][i].c1, r2 = q[ID][i].r2, c2 = q[ID][i].c2,
id = q[ID][i].id, mn = q[ID][i].mn;
ans[id] = min(abs(min(c1, mn) - c2), 1 + c2);
if (pre < r2) {
for (int j = pre + 1, _y = r2; j <= _y; j++) {
for (; *s > 0 && a[s[*s]] >= a[j]; --*s)
L = s[*s], V = 1e9, modify(1, 1, n);
L = s[++*s] = j, V = a[j] - 2 * j, modify(1, 1, n);
}
pre = r2;
}
int p = dicp(dicl(r1), c2);
ans[id] = min(ans[id], 1 + abs(a[s[p]] - c2));
if (p != *s) ans[id] = min(ans[id], 1 + abs(a[s[p + 1]] - c2));
ans[id] += r2 - r1;
int r = dicr(r1);
if (r) {
p = dic1(1, r, c2);
if (p)
ans[id] =
min(ans[id], r1 + r2 - 2 * s[p] + c2 - a[s[p]] + (c1 < a[s[p]]));
if (p < r) {
int p1 = dic1(p + 1, r, c1);
if (p1 >= p + 1)
L = s[p + 1], R = s[p1],
ans[id] = min(ans[id], query(1, 1, n) + r1 + r2 - c2);
if (p1 + 1 <= r)
L = s[p1 + 1], R = s[r],
ans[id] = min(ans[id], query(1, 1, n) + 1 + r1 + r2 - c2);
}
}
}
*s = 0;
memset(t, 60, sizeof t);
for (int i = cnt[ID], pre = n + 1; i >= 1; i--) {
int r1 = q[ID][i].r1, c1 = min(q[ID][i].c1, q[ID][i].mn), r2 = q[ID][i].r2,
c2 = q[ID][i].c2, id = q[ID][i].id;
if (pre > r2) {
for (int j = pre - 1, _y = r2; j >= _y; j--) {
for (; *s > 0 && a[s[*s]] >= a[j]; --*s)
L = s[*s], V = 1e9, modify(1, 1, n);
L = s[++*s] = j, V = 2 * j + a[j], modify(1, 1, n);
}
pre = r2;
}
int r = dicr_(r2);
if (r) {
int p = dic1(1, r, c2);
if (p)
ans[id] =
min(ans[id], 2 * s[p] - r2 - r1 + c2 - a[s[p]] + (c1 < a[s[p]]));
if (p < r) {
int p1 = dic1(p + 1, r, c1);
if (p1 >= p + 1)
R = s[p + 1], L = s[p1],
ans[id] = min(ans[id], query(1, 1, n) - r2 - r1 - c2);
if (p1 + 1 <= r)
R = s[p1 + 1], L = s[r],
ans[id] = min(ans[id], query(1, 1, n) + 1 - r2 - r1 - c2);
}
}
}
}
int main() {
n = read();
for (int i = 1, _y = n; i <= _y; i++) a[i] = read();
build(1, 1, n);
m = read();
for (int i = 1, _y = m; i <= _y; i++) {
int r1 = read(), c1 = read(), r2 = read(), c2 = read(), mn;
if (r1 < r2)
L = r1 + 1, R = r2, mn = L <= R ? query(1, 1, n) : 1e9,
q[0][++cnt[0]] = (node){r1, c1, r2, c2, i, mn};
else
L = r2, R = r1 - 1, mn = L <= R ? query(1, 1, n) : 1e9,
q[1][++cnt[1]] = (node){n - r1 + 1, c1, n - r2 + 1, c2, i, mn};
}
sort(q[0] + 1, q[0] + cnt[0] + 1);
work(0);
reverse(a + 1, a + n + 1);
sort(q[1] + 1, q[1] + cnt[1] + 1);
work(1);
for (int i = 1, _y = m; i <= _y; i++) write(ans[i]), puts("");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int n, k;
int dp[maxn];
struct node {
int x, y;
int id;
} a[maxn];
bool cmp1(node s, node t) { return s.x < t.x; }
bool cmp2(node s, node t) { return s.id < t.id; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x), a[i].id = i;
sort(a + 1, a + n + 1, cmp1);
a[1].y = 0;
for (int i = 2; i <= n; i++) a[i].y = a[i - 1].y + (a[i].x > a[i - 1].x);
int up = a[n].y;
for (int i = 0; i <= up; i++) dp[i] = 0;
sort(a + 1, a + n + 1, cmp2);
for (int i = 1; i <= n; i++) {
dp[a[i].y] = dp[a[i].y] + 1;
if (a[i].y >= 1) dp[a[i].y] = max(dp[a[i].y], dp[a[i].y - 1] + 1);
}
int ans = inf;
for (int i = 0; i <= up; i++) ans = min(ans, n - dp[i]);
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<vector<long long>> v(n + 1);
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
if (a > b)
v[a].push_back(n - a + b);
else
v[a].push_back(b - a);
}
for (long long i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
for (long long i = 1; i <= n; i++) {
long long x = i;
long long m = i;
long long ma = 0;
for (long long j = 0; j < n; j++) {
if (x > n) x = 1;
long long y = v[x].size();
if (y > 0) {
long long t = (y - 1) * n + v[x][0] + m - i;
if (t > ma) ma = t;
}
x++;
m++;
}
cout << ma << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
int main() {
int n, m, x = -1, y = -1, p = 100, b = -2, z = -1, r = -1;
cin >> n >> m;
char arr[n][m];
for (int i = 0; i < n; ++i) {
set<char> s;
for (int j = 0; j < m; ++j) {
cin >> arr[i][j];
s.insert(arr[i][j]);
if (arr[i][j] == '*' && x == -1) x = j;
}
if (p > x && x != -1) p = x;
x = -1;
auto v = s.begin();
if (s.size() > 1 || (s.size() == 1 && *v == '*')) {
if (z == -1) z = i;
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (arr[i][j] == '*' && y == -1) y = j;
}
if (b < y) b = y;
y = -1;
}
for (int i = n - 1; i >= 0; i--) {
set<char> s;
for (int j = m - 1; j >= 0; j--) {
s.insert(arr[i][j]);
}
auto v = s.begin();
if (s.size() > 1 || (s.size() == 1 && *v == '*')) {
r = i;
break;
}
}
for (int i = z; i <= r; ++i) {
for (int j = p; j <= b; ++j) {
cout << arr[i][j];
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
std::vector<size_t> RepresentInBaseTwo(unsigned long long num) {
std::vector<size_t> ans;
size_t cur = 0;
while (num) {
if (num & 1) {
ans.push_back(cur);
}
num >>= 1;
++cur;
}
return ans;
}
unsigned long long BinPow(unsigned long long base, unsigned long long exponent,
unsigned long long modulo) {
unsigned long long res = 1;
while (exponent) {
if (exponent & 1) {
res = (res * base) % modulo;
}
base = (base * base) % modulo;
exponent >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(7);
unsigned long long n, k, m;
size_t l;
std::cin >> n >> k >> l >> m;
vector<unsigned long long> a(100, 0);
vector<unsigned long long> b(100, 0);
vector<unsigned long long> c(100, 0);
a[0] = c[0] = a[1] = b[1] = 1 % m;
for (size_t i = 2; i < 100; ++i) {
a[i] = a[i - 1] * a[i - 1] + a[i - 1] * b[i - 1] * 2;
b[i] = a[i - 1] * b[i - 1] + a[i - 1] * c[i - 1] + b[i - 1] * b[i - 1];
c[i] = b[i - 1] * b[i - 1] + b[i - 1] * c[i - 1] * 2;
a[i] %= m;
b[i] %= m;
c[i] %= m;
}
if (k > 0 && log2(k) >= l) {
std::cout << 0;
return 0;
}
auto degrees = RepresentInBaseTwo(n);
auto zero = (a[degrees[0]] + b[degrees[0]]) % m,
one = (b[degrees[0]] + c[degrees[0]]) % m;
for (size_t i = 1; i < degrees.size(); i++) {
auto oldzero = zero, oldone = one;
zero = ((oldzero * a[degrees[i]] % m + oldzero * b[degrees[i]] % m) % m +
oldone * a[degrees[i]] % m) %
m;
one = ((oldzero * b[degrees[i]] % m + oldzero * c[degrees[i]] % m) % m +
oldone * b[degrees[i]] % m) %
m;
}
auto ans_zero = (one + zero) % m;
auto ans_one = (BinPow(2, n, m) + m - ans_zero) % m;
auto num_of_ones = RepresentInBaseTwo(k).size();
auto num_of_zeros = l - num_of_ones;
std::cout << BinPow(ans_zero, num_of_zeros, m) *
BinPow(ans_one, num_of_ones, m) % m
<< std::endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 34;
int n, k;
int main() {
cin >> n >> k;
cout << (n * 6 - 1) * k << "\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) cout << (i * 6 + j + 1) * k << " ";
cout << (i * 6 + 5) * k << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const double PI = 3.141592653589793238463;
const int MAXN = 2e5 + 5;
long long fastPow(long long x, long long b) {
if (b == 0)
return 1;
else if (!(b & 1)) {
return fastPow(x * x, b / 2);
} else
return x * fastPow(x * x, (b - 1) / 2);
}
char arr[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string h;
cin >> h;
int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (h[i] == '(')
c1++;
else
c2++;
}
if (c1 != c2) return cout << -1, 0;
int c = 0;
int ind = -1;
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (h[i] == '(') {
c++;
if (c == 0) {
ans += (i - ind) + 1;
}
} else {
c--;
if (c == -1) ind = i;
}
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9 + 7);
long long poww(long long x, long long y) {
if (y == 0) return 1;
long long int second = poww(x, y / 2);
second = (second * second) % MOD;
if (y % 2 == 1) second = (second * x) % MOD;
return second;
}
long long sumpows(long long a, long long k) {
if (k == 0) return 0;
if (k % 2 == 1) return a * (1 + sumpows(a, k - 1));
long long half = sumpows(a, k / 2);
return half * (1 + half - sumpows(a, k / 2 - 1));
}
struct cmp {
bool operator()(const pair<int, int> &p1, const pair<int, int> &p2) const {
if ((p1.second - p1.first + 1) == (p2.second - p2.first + 1)) {
return p1.first < p2.first;
}
return (p1.second - p1.first + 1) > (p2.second - p2.first + 1);
}
};
vector<vector<int> > adj(1001);
vector<bool> vis(1001);
bool cycle = 0;
void dfs(int u, int p) {
vis[u] = 1;
for (auto &i : adj[u]) {
if (!vis[i])
dfs(i, u);
else if (vis[i] && i != p)
cycle = 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
if (cycle) {
cout << "no";
return 0;
}
for (int i = 2; i <= n; ++i) {
if (!vis[i]) {
cout << "no";
return 0;
}
}
cout << "yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ara[51];
map<int, int> mp, mo;
int main() {
int n, i, mn, c, ans, k;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &ara[i]);
mp[ara[i]]++;
}
sort(ara, ara + n);
mn = 0;
ans = -1;
for (i = 0; i < n; i++) {
c = 0;
if (mp[ara[i]] >= k) {
if (ans == -1)
ans = mo[ara[i]];
else
ans = min(ans, mo[ara[i]]);
}
while (true) {
c++;
ara[i] = ara[i] >> 1;
mp[ara[i]]++;
mo[ara[i]] += c;
if (mp[ara[i]] >= k) {
if (ans == -1)
ans = mo[ara[i]];
else
ans = min(ans, mo[ara[i]]);
}
if (ara[i] == 0) break;
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
struct triple {
int a, t, i;
};
int n;
int tr[2 * 131072 + 5];
map<int, vector<triple> > mp;
vector<pair<int, int> > res;
int sum(int L, int R) {
L += 131072;
R += 131072;
int res = 0;
while (L <= R) {
if (L & 1) res += tr[L++];
if (~R & 1) res += tr[R--];
L >>= 1;
R >>= 1;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
triple z;
scanf("%d %d %d", &z.a, &z.t, &x);
z.i = i;
mp[x].push_back(z);
}
for (map<int, vector<triple> >::iterator it = mp.begin(); it != mp.end();
++it) {
vector<triple>& v = it->second;
map<int, int> tt;
int cnt = 1;
for (int i = 0; i < v.size(); i++) {
tt[v[i].t] = 1;
}
for (map<int, int>::iterator it2 = tt.begin(); it2 != tt.end();
++it2, cnt++)
it2->second = cnt;
for (int i = 0; i < v.size(); i++) {
v[i].t = tt[v[i].t];
}
for (int i = 0; i < v.size(); i++) {
if (v[i].a <= 2) {
int c = v[i].a == 1 ? 1 : -1;
tr[131072 + v[i].t] += c;
for (int j = ((131072 + v[i].t) >> 1); j > 0; j >>= 1)
tr[j] = tr[(j << 1)] + tr[(j << 1) + 1];
} else {
res.push_back(make_pair(v[i].i, sum(0, v[i].t)));
}
}
for (int i = 0; i < v.size(); i++) {
if (v[i].a <= 2) {
tr[131072 + v[i].t] = 0;
for (int j = ((131072 + v[i].t) >> 1); j > 0; j >>= 1)
tr[j] = tr[(j << 1)] + tr[(j << 1) + 1];
}
}
}
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) printf("%d\n", res[i].second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct operations {
int x, y, x3, y3, x4, y4;
} ans[10005];
int a[105][105];
inline int read(void) {
int num = 0, f = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') f = 1;
while (isdigit(ch)) num = (num << 1) + (num << 3) + (ch & 15), ch = getchar();
return f ? -num : num;
}
int main() {
int T = read();
while (T--) {
int n = read(), m = read(), cnt = 0;
for (int i = 1; i <= n; i++) {
char s[105];
scanf("%s", s);
for (int j = 0; j < m; j++) a[i][j + 1] = s[j] - '0';
}
for (int i = 1; i <= n - 2; i++) {
for (int j = 1, pp = 0; j <= m; j += 2) {
int x = 0, y = 0, xx, yy, cc = 0;
if (j == m) pp = 1, j--;
if (a[i][j]) cc++, x = i, y = j, a[i][j] ^= 1;
if (a[i][j + 1]) cc++, xx = i, yy = j + 1, a[i][j + 1] ^= 1;
if (!cc) continue;
a[i + 1][j + 1] ^= 1;
if (cc == 1) {
if (!x)
x = i + 1, y = j;
else
xx = i + 1, yy = j;
a[i + 1][j] ^= 1;
ans[++cnt] = (operations){x, y, xx, yy, i + 1, j + 1};
} else
ans[++cnt] = (operations){x, y, xx, yy, i + 1, j + 1};
if (pp) break;
}
}
for (int i = n - 1, j = 1; j <= m - 2; j++) {
int x = 0, y = 0, xx, yy, cc = 0;
if (a[i][j]) cc++, x = i, y = j, a[i][j] ^= 1;
if (a[i + 1][j]) cc++, xx = i + 1, yy = j, a[i + 1][j] ^= 1;
if (!cc) continue;
a[i + 1][j + 1] ^= 1;
if (cc == 1) {
if (!x)
x = i, y = j + 1;
else
xx = i, yy = j + 1;
a[i][j + 1] ^= 1;
ans[++cnt] = (operations){x, y, xx, yy, i + 1, j + 1};
} else
ans[++cnt] = (operations){x, y, xx, yy, i + 1, j + 1};
}
while (true) {
int cc = 0, x[5], y[5];
for (int i = n - 1; i <= n; i++)
for (int j = m - 1; j <= m; j++)
if (a[i][j]) x[++cc] = i, y[cc] = j;
if (!cc) break;
if (cc == 3) {
ans[++cnt] = (operations){x[1], y[1], x[2], y[2], x[3], y[3]};
break;
} else if (cc == 2) {
cc = 1;
for (int i = n - 1; i <= n; i++)
for (int j = m - 1; j <= m; j++)
if (!a[i][j]) x[++cc] = i, y[cc] = j;
ans[++cnt] = (operations){x[1], y[1], x[2], y[2], x[3], y[3]};
a[x[1]][y[1]] ^= 1, a[x[2]][y[2]] ^= 1, a[x[3]][y[3]] ^= 1;
} else if (cc == 4) {
ans[++cnt] = (operations){x[1], y[1], x[2], y[2], x[3], y[3]};
a[x[1]][y[1]] ^= 1, a[x[2]][y[2]] ^= 1, a[x[3]][y[3]] ^= 1;
} else {
cc = 1;
for (int i = n - 1; i <= n; i++)
for (int j = m - 1; j <= m; j++)
if (!a[i][j]) x[++cc] = i, y[cc] = j;
ans[++cnt] = (operations){x[1], y[1], x[2], y[2], x[3], y[3]};
a[x[1]][y[1]] ^= 1, a[x[2]][y[2]] ^= 1, a[x[3]][y[3]] ^= 1;
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++)
printf("%d %d %d %d %d %d\n", ans[i].x, ans[i].y, ans[i].x3, ans[i].y3,
ans[i].x4, ans[i].y4);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int v[30 + 10], f[30];
int answer;
int n;
void gen(int p) {
if (p == n) {
++answer;
return;
}
int t = (p + v[p]) % n;
if (f[t] == 0) {
f[t] = 1;
gen(p + 1);
f[t] = 0;
}
for (int i = p + 1; i < n; ++i) {
t = v[p];
v[p] = v[i];
v[i] = t;
t = (p + v[p]) % n;
if (f[t] == 0) {
f[t] = 1;
gen(p + 1);
f[t] = 0;
}
t = v[p];
v[p] = v[i];
v[i] = t;
}
}
int main() {
cin >> n;
answer = 0;
long long md = (long long)1e9 + 7;
long long fact[20];
fact[1] = 1;
for (long long i = 2; i <= 15; ++i) fact[i] = (fact[i - 1] * i) % md;
long long mul = 0;
switch (n) {
case 1:
mul = 1;
break;
case 3:
mul = 3;
break;
case 5:
mul = 15;
break;
case 7:
mul = 133;
break;
case 9:
mul = 2025;
break;
case 11:
mul = 37851;
break;
case 13:
mul = 1030367;
break;
case 15:
mul = 36362925;
break;
}
if (n % 2 == 0)
cout << 0;
else
cout << (mul * fact[n]) % md;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[100005], Next[100005];
int cnt[100005];
void get_next(string s) {
int i = 0, j = -1, L = s.length();
Next[0] = -1;
while (i < L) {
if (j == -1 || s[i] == s[j])
Next[++i] = ++j;
else
j = Next[j];
}
}
int main() {
string s1, s2;
int ans = 0;
cin >> s1 >> s2;
get_next(s2);
int Len1 = s1.length(), Len2 = s2.length();
for (int i = Len2 - 1; i < Len1; i++) {
bool flag = true;
for (int j = 0; j < Len2; j++) {
if (s1[i - Len2 + 1 + j] == '?') continue;
if (s1[i - Len2 + 1 + j] != s2[j]) {
flag = false;
}
}
dp[i] = dp[i - 1];
if (flag) {
int k = Next[Len2];
cnt[i] = dp[i - Len2];
while (k != -1) {
cnt[i] = max(cnt[i], cnt[i - (Len2 - k)]);
k = Next[k];
}
cnt[i]++;
dp[i] = max(cnt[i], dp[i]);
}
}
cout << dp[Len1 - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int data = 0, w = 1;
register char ch = 0;
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
return w * data;
}
void chkmax(int &x, int y) {
if (x < y) x = y;
}
const int MAX_N = 3e5 + 5;
struct Cloud {
int l, r, c;
} cld[MAX_N];
bool operator<(const Cloud &l, const Cloud &r) { return l.c < r.c; }
struct Query {
int id, t;
} q[MAX_N];
bool operator<(const Query &l, const Query &r) { return l.t < r.t; }
struct Node {
int t, op, id;
} a[MAX_N << 1];
int tot = 0;
bool operator<(const Node &l, const Node &r) { return l.t < r.t; }
int N, M, C, single[MAX_N], opt[MAX_N], ans[MAX_N];
map<int, int> cross[MAX_N];
set<int> s;
set<int>::iterator ite;
int Free, Top;
int mx[MAX_N << 2];
void modify(int o, int l, int r, int pos, int v) {
if (l == r) return (void)(mx[o] = v);
int mid = (l + r) >> 1;
if (pos <= mid)
modify((o << 1), l, mid, pos, v);
else
modify((o << 1 | 1), mid + 1, r, pos, v);
mx[o] = max(mx[(o << 1)], mx[(o << 1 | 1)]);
}
int find(int o, int l, int r) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (mx[(o << 1)] > mx[(o << 1 | 1)])
return find((o << 1), l, mid);
else
return find((o << 1 | 1), mid + 1, r);
}
int query(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return find(o, l, r);
int mid = (l + r) >> 1, res = 0;
if (ql <= mid) res = query((o << 1), l, mid, ql, qr);
if (qr > mid) {
int tmp = query((o << 1 | 1), mid + 1, r, ql, qr);
if (single[tmp] > single[res]) res = tmp;
}
return res;
}
int sum(int x, int y) {
if (x > y) swap(x, y);
return single[x] + single[y] + cross[x][y];
}
void solve() {
int now = 0, pos = 1;
for (int i = 1; i <= tot; i++) {
int dlt = a[i].t - now;
now = a[i].t;
if (!s.size())
Free += dlt;
else if (s.size() == 1) {
ite = s.upper_bound(0);
int x = *ite;
single[x] += dlt;
modify(1, 1, N, x, single[x]);
opt[x] += dlt;
int rem = C - cld[x].c;
if (rem >= 0) {
int val = single[x];
if (rem >= cld[1].c) {
int l = 1, r = N, res = 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (cld[mid].c <= rem)
res = mid, l = mid + 1;
else
r = mid - 1;
}
int ql = 1, qr = res;
if (x == qr) --qr;
if (x < qr) {
ql = x + 1;
if (ql <= qr) chkmax(val, sum(x, query(1, 1, N, ql, qr)));
ql = 1, qr = x - 1;
}
if (ql <= qr) chkmax(val, sum(x, query(1, 1, N, ql, qr)));
}
chkmax(opt[x], val);
chkmax(Top, opt[x]);
}
} else if (s.size() == 2) {
ite = s.upper_bound(0);
int x = *ite;
++ite;
int y = *ite;
if (cross[x].count(y) > 0)
cross[x][y] += dlt;
else
cross[x][y] = dlt;
if (cld[x].c + cld[y].c <= C) {
chkmax(opt[x], sum(x, y));
chkmax(opt[y], sum(x, y));
chkmax(Top, opt[x]);
}
}
while (pos <= M && Top + Free >= q[pos].t)
ans[q[pos].id] = now - (Top + Free - q[pos].t), ++pos;
if (pos > M) break;
if (a[i].op == 1)
s.insert(a[i].id);
else
s.erase(a[i].id);
}
}
int main() {
N = gi(), C = gi();
for (int i = 1; i <= N; i++)
cld[i].l = gi(), cld[i].r = gi(), cld[i].c = gi();
sort(&cld[1], &cld[N + 1]);
for (int i = 1; i <= N; i++) {
a[++tot] = (Node){cld[i].l, 1, i};
a[++tot] = (Node){cld[i].r, -1, i};
}
sort(&a[1], &a[tot + 1]);
a[++tot] = (Node){(int)(2e9 + 7), 1, N + 1};
M = gi();
for (int i = 1; i <= M; i++) q[i].id = i, q[i].t = gi();
sort(&q[1], &q[M + 1]);
solve();
for (int i = 1; i <= M; i++) printf("%d\n", ans[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 3e5 + 10;
vector<long long> vp[25];
long long cnt = 0;
long long vis[25];
long long mark[21][21];
long long dp[22];
void dfs(long long n) {
vis[n] = 1;
cnt++;
for (auto it : vp[n]) {
if (!vis[it]) {
dfs(it);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s, a;
cin >> s >> a;
long long flag = 0;
for (long long i = 0; i < 20; i++) {
vp[i].clear();
vis[i] = 0;
}
for (long long i = 0; i < s.size(); i++) {
if (s[i] > a[i]) {
flag = 1;
break;
}
}
if (flag)
cout << "-1"
<< "\n";
else {
for (long long i = 0; i < s.size(); i++) {
if (s[i] != a[i]) {
vp[s[i] - 'a'].push_back(a[i] - 'a');
vp[a[i] - 'a'].push_back(s[i] - 'a');
}
}
long long ans = 0;
memset(dp, -1, sizeof(dp));
for (long long i = 0; i < 20; i++) {
if (!vis[i] && vp[i].size() > 0) {
cnt = 0;
dfs(i);
ans += cnt - 1;
}
}
cout << ans << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x, d[1000010], mo;
bool prime(int ave) {
if (ave < 2) return false;
for (int i = 2; i * i <= ave; ++i)
if (ave % i == 0) return false;
return true;
}
long long mul(int a, int b) {
long long ans = 1, w = a % mo;
while (b) {
if (b & 1) ans = (ans * w) % mo;
w = (w * w) % mo;
b /= 2;
}
return ans;
}
int main() {
scanf("%d%d", &n, &x);
if (!prime(n + 1)) {
printf("-1");
return 0;
}
d[0] = 0, mo = n + 1;
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) d[++d[0]] = i, d[++d[0]] = n / i;
if (d[d[0]] == d[d[0] - 1]) --d[0];
for (int i = x - 1; i >= 2; --i) {
bool flg = true;
for (int j = 1; j <= d[0]; ++j)
if (mul(i, d[j]) == 1) {
flg = false;
break;
}
if (flg) {
printf("%d", i);
return 0;
}
}
printf("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
int n, k;
std::vector<bool> uni;
void query(int x) {
if (!uni[x]) return;
std::cout << "? " << x + 1 << std::endl;
char res;
std::cin >> res;
if (res == 'Y') uni[x] = false;
}
void reset() { std::cout << "R" << std::endl; }
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> n >> k;
uni.assign(n, true);
if (k == 1) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
reset();
query(j);
query(i);
}
}
} else {
for (int i = 0; i < n; ++i) query(i);
for (int i = 0; i < n; i += k) {
for (int j = 0; j < i; j += k) {
reset();
for (int l = i; l < i + k / 2; ++l) query(l);
for (int l = j; l < j + k / 2; ++l) query(l);
for (int l = i + k / 2; l < i + k; ++l) query(l);
reset();
for (int l = i + k / 2; l < i + k; ++l) query(l);
for (int l = j + k / 2; l < j + k; ++l) query(l);
for (int l = i; l < i + k / 2; ++l) query(l);
}
}
}
std::cout << "! " << std::accumulate(uni.begin(), uni.end(), 0) << std::endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
first = first * 10 + ch - 48;
}
return first * f;
}
const int mxN = 1e5;
int n, m;
long long tim;
struct Edge {
int v, nxt;
long long w;
} e[mxN * 2 + 3];
int fe[mxN + 3];
int en;
int fa[mxN + 3];
long long dis[mxN + 3];
vector<pair<pair<long long, long long>, int> > dolor_sit_amet_[mxN + 3];
vector<pair<long long, long long> > tot;
priority_queue<long long, vector<long long>, greater<long long> > que;
struct SplayNode {
int fa, son[2], tag, son2, dolor_sit_amet_;
} spl[mxN + 3];
int stk[mxN + 3];
bool isroot(int u) {
return u != spl[spl[u].fa].son[0] && u != spl[spl[u].fa].son[1];
}
bool sondir(int u) { return u == spl[spl[u].fa].son[1]; }
void maketag(int u, int first) {
if (!u) return;
spl[u].dolor_sit_amet_ = max(spl[u].dolor_sit_amet_, first);
spl[u].tag = max(spl[u].tag, first);
}
void pushdown(int u) {
if (spl[u].tag) {
maketag(spl[u].son[0], spl[u].tag), maketag(spl[u].son[1], spl[u].tag);
spl[u].tag = 0;
}
}
void rotate(int u) {
int dir = sondir(u) ^ 1;
int first = spl[u].fa, second = spl[first].fa, z = spl[u].son[dir];
if (!isroot(first)) {
pushdown(second);
}
pushdown(first);
pushdown(u);
spl[u].fa = second;
if (!isroot(first)) {
spl[second].son[sondir(first)] = u;
}
spl[first].son[dir ^ 1] = z;
if (z) {
spl[z].fa = first;
}
spl[u].son[dir] = first;
spl[first].fa = u;
}
void splay(int u) {
int first = u, tp = 0;
while (!isroot(first)) {
stk[++tp] = first;
first = spl[first].fa;
}
pushdown(first);
while (tp) {
pushdown(stk[tp]);
tp--;
}
while (!isroot(u)) {
first = spl[u].fa;
int second = spl[first].fa;
if (!isroot(first)) {
sondir(u) ^ sondir(first) ? rotate(u) : rotate(first);
}
rotate(u);
}
}
void access(int u) {
int first;
for (first = 0; u; first = u, u = spl[u].fa) {
while (first && spl[first].son[0]) {
first = spl[first].son[0];
}
if (first) {
splay(first);
}
splay(u);
spl[u].son[1] = first;
dolor_sit_amet_[u].push_back(
make_pair(make_pair(spl[u].dolor_sit_amet_ + 1, tim), first));
}
maketag(first, tim);
}
void addedge(int u, int v, long long w) {
en++;
e[en].v = v, e[en].w = w;
e[en].nxt = fe[u];
fe[u] = en;
}
void dfs(int u) {
for (int i = fe[u]; i; i = e[i].nxt) {
int v = e[i].v;
fa[v] = u;
dis[v] = dis[u] + e[i].w;
dfs(v);
}
}
int main() {
n = read(), m = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read(), w = read();
addedge(u, v, w);
}
dfs(1);
for (int i = 1; i <= n; i++) spl[i].fa = fa[i];
for (int i = 1; i <= n; i++)
if (fe[i]) {
dolor_sit_amet_[i].push_back(make_pair(make_pair(0, 0), e[fe[i]].v));
}
for (int i = 1; i <= m; i++) {
int u = read();
long long t = read();
tim = t;
access(u);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < dolor_sit_amet_[i].size(); j++) {
long long l = dolor_sit_amet_[i][j].first.first,
r = dolor_sit_amet_[i][j].first.second;
int k = j;
while (j + 1 < dolor_sit_amet_[i].size() &&
dolor_sit_amet_[i][j].second == 0) {
j++;
r = dolor_sit_amet_[i][j].first.second;
}
if (dolor_sit_amet_[i][k - 1].second != dolor_sit_amet_[i][j].second &&
dolor_sit_amet_[i][j].second != 0) {
tot.push_back(make_pair(k == 1 ? 1ll : l + dis[i], r + dis[i]));
}
}
}
sort(tot.begin(), tot.end());
tim = 1ll;
int i;
bool ok = true;
for (i = 0; i < tot.size() || !que.empty();) {
if (que.empty()) {
tim = tot[i].first;
}
while (i < tot.size() && tot[i].first <= tim) {
que.push(tot[i].second);
i++;
}
if (que.top() < tim) {
ok = false;
tim--;
break;
}
que.pop();
tim++;
}
if (ok) {
printf("-1 %d\n", tot.size());
} else {
int ans = 0;
for (int i = 0; i < tot.size(); i++) {
ans += (tot[i].second < tim);
}
printf("%I64d %d\n", tim, ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[2010], b[2010];
int main() {
int n, m;
while (cin >> n >> m) {
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] <= m) b[a[i]]++;
}
int ave = n / m, changes = 0;
for (int i = 1; i <= m; ++i) {
if (b[i] < ave) {
for (int j = 1; j <= n; ++j) {
if (a[j] > m && b[i] < ave) {
a[j] = i;
b[i]++;
changes++;
}
}
}
}
bool ma = false;
for (int i = 1; i <= m; ++i) {
if (b[i] < ave) {
ma = true;
break;
}
}
if (ma) {
for (int i = 1; i <= m; ++i) {
if (b[i] < ave) {
for (int j = 1; j <= n; ++j) {
if (a[j] <= m && b[a[j]] > ave && b[i] < ave) {
b[a[j]]--;
b[i]++;
a[j] = i;
changes++;
}
}
}
}
}
int val = (int)1e9 + 10;
for (int i = 1; i <= m; ++i) {
val = min(val, b[i]);
}
cout << val << ' ' << changes << endl;
for (int i = 1; i <= n; ++i) {
cout << a[i] << ' ';
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, f[2][N];
long long a[N], mx, v1[N], v2[N];
void upd(int& x, int y) { x = (x < y ? x : y); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]), mx = max(mx, a[i]);
for (int i = 1; i <= n; ++i) a[i] = mx - a[i];
memset(f[1], 0x3f, sizeof(int) * (n + 1));
f[1][0] = 0;
for (int i = 0; i < 64; ++i) {
memset(f[i & 1], 0x3f, sizeof(int) * (n + 1));
int c[2] = {0}, t = 0;
for (int j = 1; j <= n; ++j) ++c[a[j] >> i & 1];
upd(f[i & 1][0], f[~i & 1][0] + c[1]);
upd(f[i & 1][c[1]], f[~i & 1][0] + c[0]);
for (int j = 1; j <= n; ++j) {
if (a[j] >> i & 1)
--c[1], ++c[0], ++t;
else
--c[0], ++c[1];
upd(f[i & 1][t], f[~i & 1][j] + c[1]);
upd(f[i & 1][t + c[1]], f[~i & 1][j] + c[0]);
}
int id1 = 0, id2 = 0, id = 0;
for (int j = 1; j <= n; ++j)
(a[j] >> i & 1) ? v1[++id1] = a[j] : v2[++id2] = a[j];
for (int j = 1; j <= id1; ++j) a[++id] = v1[j];
for (int j = 1; j <= id2; ++j) a[++id] = v2[j];
}
printf("%d", f[1][0]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int a[16], b[16];
int dp[1 << 15][225][4];
int solve(int msk, int sum, int type) {
if (sum > t) return 0;
if (sum == t) return 1;
int &ans = dp[msk][sum][type];
if (~ans) return ans;
ans = 0;
for (int i = 0; i < n; i++) {
if (type == b[i]) continue;
if (msk & (1 << i)) continue;
ans = (ans + solve(msk | (1 << i), sum + a[i], b[i])) % 1000000007;
}
return ans;
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cin >> n >> t;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
memset(dp, -1, sizeof dp);
cout << solve(0, 0, 0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 1;
bool vis[mx];
vector<int> adj[mx];
int n;
bool star() {
bool ans;
int count1 = 0;
int other = 0;
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
count1++;
} else if (adj[i].size() == n - 1) {
other++;
}
}
if (other == 1 && count1 == n - 1) {
ans = true;
} else {
ans = false;
}
return ans;
}
bool ring() {
bool ans = true;
for (int i = 1; i <= n; i++) {
if (adj[i].size() != 2) {
ans = false;
break;
}
}
return ans;
}
bool bus() {
bool ans;
int one = 0;
int two = 0;
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
one++;
} else if (adj[i].size() == 2) {
two++;
}
}
if (one == 2 && two == n - 2) {
ans = true;
} else {
ans = false;
}
return ans;
}
int main() {
int m, k, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (star()) {
cout << "star topology" << endl;
} else if (bus()) {
cout << "bus topology" << endl;
} else if (ring()) {
cout << "ring topology" << endl;
} else {
cout << "unknown topology" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fx[] = {0, 0, -1, 1, -1, 1, -1, 1};
int fy[] = {-1, 1, 0, 0, 1, 1, -1, -1};
long long Set(int n, int pos) { return n = n | (1LL << pos); }
int reset(int n, int pos) { return n = n & ~(1 << pos); }
bool check(int n, int pos) { return (bool)(n & (1 << pos)); }
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
};
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); };
string s;
vector<int> Div;
void calc(int x) {
for (int i = 1; i <= x; i++) {
if (x % i == 0) Div.push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
calc(n);
cin >> s;
int len = Div.size();
for (int i = 0; i < len; i++) {
reverse(s.begin(), s.begin() + Div[i]);
}
cout << s << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = (1 << 12) + 3;
int f[mxn << 3];
bool a[mxn << 2];
char s[mxn];
int n, m, ans;
int fffa(int x) { return f[x] == x ? x : f[x] = fffa(f[x]); }
void com(int u, int v) {
int fu = fffa(u), fv = fffa(v);
if (fu != fv) {
--ans;
f[fu] = fv;
}
}
int main() {
scanf("%d%d", &n, &m);
while (n--) {
scanf("%s", s);
for (int(i) = (int)(0); (i) < (int)(m >> 2); ++(i)) {
int x = (s[i] > '9' ? s[i] - 55 : s[i] - 48);
for (int(j) = (int)(1); (j) <= (int)(4); ++(j)) {
int id = i * 4 + j;
a[id] = (x >> (4 - j)) & 1;
f[id] = a[id] ? id : 0;
ans += a[id];
}
}
for (int(i) = (int)(1); (i) <= (int)(m); ++(i))
if (a[i]) {
if (a[i - 1]) com(i - 1, i);
if (f[i + m]) com(i + m, i);
}
for (int(i) = (int)(1); (i) <= (int)(m); ++(i))
f[i + m] = a[i] ? fffa(i) + m : 0;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int read() {
int ret = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f *= -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return f * ret;
}
const int MAXN = 200000;
const int MAXT = MAXN * 20;
const int inf = 100001111;
int n;
namespace SegTree {
int sum[MAXT + 10];
int qmin[MAXT + 10], qmax[MAXT + 10];
int mintag[MAXT + 10], maxtag[MAXT + 10];
void tagmax(int x, int l, int max) {
if (max < maxtag[x]) return;
maxtag[x] = max;
qmax[x] = l + max;
sum[x] = qmin[x] + max;
return;
}
void tagmin(int x, int l, int min) {
if (min > mintag[x]) return;
mintag[x] = min;
qmin[x] = l - min;
sum[x] = qmax[x] - min;
return;
}
void down(int x, int l, int r) {
if (maxtag[x] != -inf) {
if (l != r) {
int mid = (l + r) >> 1;
tagmax(x << 1, l, maxtag[x]);
tagmax(x << 1 | 1, mid + 1, maxtag[x]);
}
maxtag[x] = -inf;
}
if (mintag[x] != inf) {
if (l != r) {
int mid = (l + r) >> 1;
tagmin(x << 1, l, mintag[x]);
tagmin(x << 1 | 1, mid + 1, mintag[x]);
}
mintag[x] = inf;
}
return;
}
void update(int x) {
qmin[x] = ((qmin[x << 1]) < (qmin[x << 1 | 1]) ? (qmin[x << 1])
: (qmin[x << 1 | 1]));
qmax[x] = ((qmax[x << 1]) < (qmax[x << 1 | 1]) ? (qmax[x << 1])
: (qmax[x << 1 | 1]));
sum[x] =
((sum[x << 1]) < (sum[x << 1 | 1]) ? (sum[x << 1]) : (sum[x << 1 | 1]));
return;
}
void reset(int id, int q) {
int x = 1, l = 1, r = n;
while (l <= r) {
down(x, l, r);
if (l == r) break;
int mid = (l + r) >> 1;
if (id <= mid) {
x <<= 1;
r = mid;
} else {
x = (x << 1 | 1);
l = mid + 1;
}
}
sum[x] = id;
qmax[x] = id + q;
qmin[x] = id - q;
while (x >> 1) update(x >>= 1);
return;
}
void updatemin(int x, int l, int r, int ll, int rr, int min) {
down(x, l, r);
if (l == ll && r == rr) {
tagmin(x, l, min);
return;
}
int mid = (l + r) >> 1;
if (rr <= mid)
updatemin(x << 1, l, mid, ll, rr, min);
else if (ll <= mid) {
updatemin(x << 1, l, mid, ll, mid, min);
updatemin(x << 1 | 1, mid + 1, r, mid + 1, rr, min);
} else
updatemin(x << 1 | 1, mid + 1, r, ll, rr, min);
update(x);
return;
}
void updatemax(int x, int l, int r, int ll, int rr, int max) {
down(x, l, r);
if (l == ll && r == rr) {
tagmax(x, l, max);
return;
}
int mid = (l + r) >> 1;
if (rr <= mid)
updatemax(x << 1, l, mid, ll, rr, max);
else if (ll <= mid) {
updatemax(x << 1, l, mid, ll, mid, max);
updatemax(x << 1 | 1, mid + 1, r, mid + 1, rr, max);
} else
updatemax(x << 1 | 1, mid + 1, r, ll, rr, max);
update(x);
return;
}
int query(int x, int l, int r, int ll, int q) {
down(x, l, r);
if (sum[x] > q) return -1;
if (l == r) return l;
int mid = (l + r) >> 1;
if (mid < ll)
return query(x << 1 | 1, mid + 1, r, ll, q);
else {
int lans = query(x << 1, l, mid, ll, q);
return (lans != -1) ? (lans) : (query(x << 1 | 1, mid + 1, r, ll, q));
}
}
void build(int x, int l, int r) {
mintag[x] = inf;
maxtag[x] = -inf;
if (l == r) return;
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
return;
}
} // namespace SegTree
bool re;
std::map<int, int> cnt;
void modify(int id, int k) {
if (cnt[id] == 1 && k == 1) re = true;
if (cnt[id] == 2 && k == -1) re = false;
cnt[id] += k;
return;
}
int k, d;
int a[MAXN + 10];
int ansl, ansr;
void update(int l, int r) {
if (!ansl || r - l > ansr - ansl || (r - l == ansr - ansl && ansl > l)) {
ansl = l;
ansr = r;
}
return;
}
int minsta[MAXN + 10], mintop;
int maxsta[MAXN + 10], maxtop;
void init() {
n = read();
k = read();
d = read();
for (int i = 1; i <= n; i++) a[i] = read();
if (d == 0) {
for (int l = 1; l <= n;) {
int r = l;
while (r < n && a[r + 1] == a[r]) r++;
update(l, r);
l = r + 1;
}
} else {
SegTree::build(1, 1, n);
for (int l = 1; l <= n;) {
int r = l;
while (r < n && (a[r + 1] - a[r]) % d == 0) r++;
for (int i = r; i >= l; i--) a[i] = (a[i] - a[l]) / d;
minsta[mintop = 0] = maxsta[maxtop = 0] = l - 1;
int ln = l;
for (int rn = l; rn <= r; rn++) {
while (mintop && a[minsta[mintop]] > a[rn]) mintop--;
while (maxtop && a[maxsta[maxtop]] < a[rn]) maxtop--;
modify(a[rn], 1);
SegTree::reset(rn, a[rn]);
SegTree::updatemin(1, 1, n, minsta[mintop] + 1, rn, a[rn]);
SegTree::updatemax(1, 1, n, maxsta[maxtop] + 1, rn, a[rn]);
while (re) modify(a[ln], -1), ln++;
update(SegTree::query(1, 1, n, ln, rn + k), rn);
minsta[++mintop] = maxsta[++maxtop] = rn;
}
while (ln <= r) modify(a[ln], -1), ln++;
l = r + 1;
}
}
std::cout << ansl << ' ' << ansr << std::endl;
return;
}
int main() {
init();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
#define fastIO ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
#define endl '\n'
#define lli long long int
#define ld long double
#define p_b push_back
#define m_p make_pair
#define fs first
#define sc second
#define sz(x) ((lli)x.size())
#define all(x) x.begin(),x.end()
const lli mod = 1e9 + 7;
const lli N = 1e6 + 5;
/*****************************************************/
lli t,n,m,a[N]={0},target;
bool dp[105][200005],vis[105][200005];
lli F(lli idx,lli ss)
{
if(vis[idx][ss])
return dp[idx][ss];
vis[idx][ss]=true;
if(idx>n)
{
if(ss==target)
return dp[idx][ss]=true;
return dp[idx][ss]=false;
}
bool ret=F(idx+1,ss),ret1=F(idx+1,ss+a[idx]);
if(ret || ret1)
return dp[idx][ss]=true;
return dp[idx][ss]=false;
}
int main()
{
fastIO
lli i,j,k,x,y;
lli ss=0;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>a[i];
ss+=a[i];
}
if(ss%2!=0)
{
cout<<"0";
return 0;
}
target=ss/2;
memset(vis,false,sizeof vis);
memset(dp,false,sizeof dp);
if(F(1,0)==false)
{
cout<<"0";
return 0;
}
while(1)
{
for(i=1;i<=n;i++)
{
if(a[i]%2!=0)
{
cout<<"1\n"<<i;
return 0;
}
a[i]/=2;
}
}
// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int N = 400005;
int n, a[N], f1[N], f2[N], f[N];
inline void up(int &x, int y) {
if (y > x) x = y;
}
int main() {
int i, j = 0;
n = read();
for (i = 1; i <= n; i++) a[i] = read(), j = max(j, a[i]);
for (i = 2; i < n; i++)
up(f1[min(i - 1, n - i)], min(a[i], max(a[i - 1], a[i + 1])));
for (i = 2; i < n; i++) up(f2[min(i, n - i)], max(a[i], a[i + 1]));
for (i = n; i >= 2; i--)
printf("%d ", f[i] = max(f[i + 2], (i & 1) ? f1[i >> 1] : f2[i >> 1]));
printf("%d", j);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
bool f = 0;
char ch = (char)getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = (char)getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch & 15);
ch = (char)getchar();
}
if (f) x = -x;
}
template <typename T>
inline void write(T x) {
static int st[35];
int top = 0;
do {
st[top++] = x % 10;
x /= 10;
} while (x);
while (top) putchar(st[--top] + '0');
}
const double pi = acos(-1.0);
const double eps = (double)1e-4;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 5;
const int maxm = 2e5 + 10;
const long long p = 31;
int n, m, k;
vector<pair<int, int> > adj[maxn];
int out[maxn];
vector<int> deg[10];
long long pow31[maxn];
long long ha[10][10];
long long tar = 0;
int ans = 0;
void debug() {
cout << "tar = " << tar << endl;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
printf("ha[%d][%d] = %lld\n", i, j, ha[i][j]);
}
}
}
void init() {
pow31[0] = 1;
for (long long i = 1; i <= n; i++) pow31[i] = (pow31[i - 1] * p) % mod;
for (long long i = 1; i <= n; i++) tar += pow31[i];
tar %= mod;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
for (int a : deg[i]) {
int to = adj[a][j - 1].second;
(ha[i][j] += pow31[to]) %= mod;
}
}
}
}
void dfs(int dep, long long cur) {
if (dep == k + 1) {
if (tar == cur) ans++;
return;
}
for (int j = 1; j <= dep; j++) {
dfs(dep + 1, (cur + ha[dep][j]) % mod);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({w, v});
out[u]++;
}
for (int i = 1; i <= n; i++) {
sort(adj[i].begin(), adj[i].end());
deg[out[i]].push_back(i);
}
init();
dfs(1, 0);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int atp[300001], num[300001];
vector<pair<int, int> > ans;
void swa(int i, int j) {
ans.push_back({i, j});
int ati = atp[i];
int atj = atp[j];
atp[j] = ati;
atp[i] = atj;
num[ati] = j;
num[atj] = i;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
;
int t;
for (int i = 1; i < n + 1; i++) {
cin >> t;
num[t] = i;
atp[i] = t;
}
for (int i = n; i > n / 2; i--) {
if (num[i] == i && num[i - n / 2] == i - n / 2) continue;
if (num[i] != i - n / 2) {
if (num[i] != i) {
if (num[i] > n / 2 - n + i) {
swa(1, num[i]);
}
swa(num[i], i);
}
swa(num[i], i - n / 2);
}
if (num[i - n / 2] != i) {
if (num[i - n / 2] > n / 2 - n + i) {
swa(1, num[i - n / 2]);
}
swa(num[i - n / 2], i);
}
swa(i, i - n / 2);
}
int tot = ans.size();
cout << tot << '\n';
for (int i = 0; i < tot; i++) {
cout << ans[i].first << " " << ans[i].second << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
void work(int e) {
for (int i = 2; i <= n; i++) {
printf("%d %d\n", 1 + e, i + e);
}
for (int i = 2; i <= n; i++) {
for (int j = n + 1; j < 2 * n; j++) {
printf("%d %d\n", i + e, j + e);
}
}
for (int i = n + 1; i < 2 * n; i += 2) {
printf("%d %d\n", i + e, i + e + 1);
}
}
int main() {
scanf("%d", &n);
if (n % 2 == 0) {
printf("NO\n");
return 0;
}
printf("YES\n");
printf("%d %d\n", 4 * n - 2, 2 * n * n - n);
work(0);
work(2 * n - 1);
printf("%d %d\n", 1, 2 * n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int room[100001];
vector<int> d[100001];
vector<int> nb[200001];
vector<int> revnb[200001];
vector<int> topsort;
int comp[200001];
bool vis[200001];
int scc = 0;
void dfstop(int v) {
vis[v] = true;
int i;
for (i = 0; i < nb[v].size(); i++) {
if (!vis[nb[v][i]]) dfstop(nb[v][i]);
}
topsort.push_back(v);
}
void dfs2(int v) {
vis[v] = true;
comp[v] = scc;
int i;
for (i = 0; i < revnb[v].size(); i++) {
if (!vis[revnb[v][i]]) dfs2(revnb[v][i]);
}
}
int main() {
int i, j, x, p, a, b, br = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &room[i]);
if (room[i] == 1) br++;
}
for (i = 1; i <= m; i++) {
scanf("%d", &x);
for (j = 1; j <= x; j++) {
scanf("%d", &p);
d[p].push_back(i);
}
}
if (br == n) {
cout << "YES" << endl;
return 0;
}
for (i = 1; i <= n; i++) {
a = d[i][0];
b = d[i][1];
if (room[i] == 0) {
nb[a].push_back(b + 100000);
nb[a + 100000].push_back(b);
nb[b].push_back(a + 100000);
nb[b + 100000].push_back(a);
} else {
nb[a].push_back(b);
nb[b].push_back(a);
nb[a + 100000].push_back(b + 100000);
nb[b + 100000].push_back(a + 100000);
}
}
for (i = 1; i <= m; i++) {
if (!vis[i]) {
dfstop(i);
}
}
for (i = 100001; i <= m + 100000; i++) {
if (!vis[i]) {
dfstop(i);
}
}
for (i = 1; i <= m; i++) {
for (j = 0; j < nb[i].size(); j++) {
revnb[nb[i][j]].push_back(i);
}
}
for (i = 100001; i <= 100000 + m; i++) {
for (j = 0; j < nb[i].size(); j++) {
revnb[nb[i][j]].push_back(i);
}
}
for (i = 1; i <= 200000; i++) vis[i] = false;
for (i = topsort.size() - 1; i >= 0; i--) {
if (!vis[topsort[i]]) {
scc++;
dfs2(topsort[i]);
}
}
for (i = 1; i <= m; i++) {
if (comp[i] == comp[i + 100000]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
int u, d, z;
cin >> n >> m;
u = 1;
d = n;
while (u <= d) {
if (u == d)
z = m / 2;
else
z = m;
for (int i = 1; i <= z; i++) {
printf("%d %d\n", u, i);
printf("%d %d\n", d, m - i + 1);
}
if (u == d && z < m - z) printf("%d %d\n", u, m - z);
u++;
d--;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 50;
int n, m;
int Tr[N][2], Fa[N], rev[N], col[N], laz[N];
int su[N];
void Up(int x) {
int l = Tr[x][0], r = Tr[x][1];
su[x] = su[l] | su[r];
if (x > n && col[x] > 0) su[x] |= col[x];
}
bool is_root(int x) { return Tr[Fa[x]][0] != x && Tr[Fa[x]][1] != x; }
void rotate(int x) {
int y = Fa[x], f = (Tr[Fa[x]][1] == x);
if (!is_root(y)) Tr[Fa[y]][(Tr[Fa[y]][1] == y)] = x;
Fa[x] = Fa[y];
Fa[y] = x;
if (Tr[x][!f]) Fa[Tr[x][!f]] = y;
Tr[y][f] = Tr[x][!f];
Tr[x][!f] = y;
Up(y);
Up(x);
}
void reverse(int x) {
swap(Tr[x][0], Tr[x][1]);
rev[x] ^= 1;
}
void upd(int x, int c) {
laz[x] = col[x] = c;
if (c > 0 && (Tr[x][0] || Tr[x][1] || x > n)) {
su[x] = c;
} else {
su[x] = 0;
}
}
void down(int x) {
int l = Tr[x][0], r = Tr[x][1];
if (rev[x]) {
if (l) reverse(l);
if (r) reverse(r);
rev[x] = 0;
}
if (laz[x]) {
if (l) upd(l, laz[x]);
if (r) upd(r, laz[x]);
laz[x] = 0;
}
}
void Down(int x) {
if (!is_root(x)) Down(Fa[x]);
down(x);
}
void W(int x) {
Up(x);
if (!is_root(x)) W(Fa[x]);
}
void Splay(int x) {
Down(x);
W(x);
for (int y; !is_root(x); rotate(x)) {
if (!is_root(y = Fa[x]))
rotate((Tr[Fa[x]][1] == x) == (Tr[Fa[y]][1] == y) ? y : x);
}
}
void Access(int x) {
for (int pre = 0; x; pre = x, x = Fa[x]) {
Splay(x);
Tr[x][1] = pre;
Up(x);
}
}
void make_root(int x) {
Access(x);
Splay(x);
reverse(x);
}
int find_root(int x) {
Access(x);
Splay(x);
down(x);
while (Tr[x][0]) {
x = Tr[x][0];
down(x);
}
Splay(x);
return x;
}
int u[N], v[N];
bool add(int e) {
int x = u[e], y = v[e];
make_root(x);
if (find_root(y) == x) {
Splay(x);
if (su[x]) {
return 0;
} else {
Splay(x);
upd(x, e);
return 1;
}
} else {
Splay(x);
Fa[x] = e + n;
Fa[e + n] = y;
return 1;
}
}
void del(int e) {
int x = u[e], y = v[e];
make_root(x);
Access(y);
Splay(x);
int c = su[x];
if (c == e) {
upd(x, -1);
} else {
if (c > 0) del(c);
make_root(x);
Access(y);
Splay(e + n);
Fa[x] = 0;
Fa[y] = 0;
Tr[e + n][0] = Tr[e + n][1] = 0;
su[e + n] = col[e + n] = laz[e + n] = rev[e + n] = 0;
if (c > 0) add(c);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1), _t = (m); i <= _t; ++i) scanf("%d%d", &u[i], &v[i]);
long long res = 0;
int r = 1;
for (int l = (1), _t = (m); l <= _t; ++l) {
while (r <= m && add(r)) {
++r;
}
res += r - l;
del(l);
}
printf("%lld\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char c[4] = {'a', 'b', 'c', 'd'};
for (int i = 0; i < n; i++) {
cout << c[i % 4];
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
register int x = 0;
register int y = 1;
register char c = getchar();
while (c < '0' || c > '9') y &= (c != '-'), c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + (c ^ 48), c = getchar();
return y ? x : -x;
}
inline long long power(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
b >>= 1;
a = a * a % 1000000007;
}
return ans;
}
int main() {
int n = read(), m = read();
printf("%lld\n", power(2, m) * power(n + 1, m - 1) % 1000000007 *
(n + 1 - m) % 1000000007);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s[200005];
list<int> L[100005];
int cnt[100005];
bool ok(int sco) {
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= m; i++) L[i].clear();
for (int i = 1; i <= n; i++) {
L[s[i]].push_back(i);
cnt[s[i]]++;
if (cnt[s[i]] == sco) {
if (i - L[s[i]].front() + 1 - sco <= k) return true;
cnt[s[i]]--;
L[s[i]].pop_front();
}
}
return false;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
int lt = 1, rt = n + 1;
while (rt - lt > 1) {
int md = (lt + rt) >> 1;
if (ok(md))
lt = md;
else
rt = md;
}
printf("%d\n", lt);
return 0;
}
| 5 |
#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);
debug_out(T...);
}
const int maxn = 1e5 + 5;
int h[maxn];
int x[maxn], xcnt;
int f[maxn];
bool cmp(int a, int b) { return h[a] > h[b]; }
struct node {
int id;
int l, r;
int ls, rs;
int lm, rm, mm;
} t[maxn * 20];
int tcnt;
int rt[maxn], rcnt;
node operator+(node a, node b) {
node c;
c.ls = a.id;
c.rs = b.id;
c.l = a.l;
c.r = b.r;
c.lm = a.lm;
c.rm = b.rm;
if (a.lm == (a.r - a.l + 1)) c.lm += b.lm;
if (b.rm == (b.r - b.l + 1)) c.rm += a.rm;
c.mm = max(max(a.mm, b.mm), a.rm + b.lm);
return c;
}
void update(int& root, int pre_root, int L, int l, int r) {
t[root = ++tcnt] = t[pre_root];
42;
t[root].l = l;
t[root].r = r;
t[root].id = root;
if (l == r) {
t[root].lm = t[root].rm = t[root].mm = 1;
return;
}
int mid = (l + r) >> 1;
if (L <= mid)
update(t[root].ls, t[pre_root].ls, L, l, mid);
else
update(t[root].rs, t[pre_root].rs, L, mid + 1, r);
t[root] = t[t[root].ls] + t[t[root].rs];
t[root].id = root;
}
node query(int L, int R, int l, int r, int rt) {
if (l == L && r == R) return t[rt];
int mid = (l + r) >> 1;
if (R <= mid) return query(L, R, l, mid, t[rt].ls);
if (L > mid) return query(L, R, mid + 1, r, t[rt].rs);
return query(L, mid, l, mid, t[rt].ls) +
query(mid + 1, R, mid + 1, r, t[rt].rs);
}
int n;
int work(int L, int R, int w) {
int l = 1, r = xcnt;
int ans = 1;
while (l <= r) {
int mid = l + r >> 1;
int root = rt[mid];
node tmp = query(L, R, 1, n, root);
42;
if (query(L, R, 1, n, root).mm >= w) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return x[ans - 1];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
x[xcnt++] = h[i];
f[i] = i;
}
sort(x, x + xcnt);
xcnt = unique(x, x + xcnt) - x;
for (int i = 1; i <= n; i++) {
h[i] = lower_bound(x, x + xcnt, h[i]) - x + 1;
}
sort(f + 1, f + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
42;
int idx = f[i];
int lxt_idx = f[i - 1];
if (h[idx] != h[lxt_idx]) {
update(rt[h[idx]], rt[h[lxt_idx]], idx, 1, n);
} else {
update(rt[h[idx]], rt[h[idx]], idx, 1, n);
}
}
int q;
scanf("%d", &q);
int l, r, w;
while (q--) {
scanf("%d %d %d", &l, &r, &w);
printf("%d\n", work(l, r, w));
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.