solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long inf2 = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
namespace fastio {
char in[100000];
int itr = 0, llen = 0;
char get() {
if (itr == llen) llen = fread(in, 1, 100000, stdin), itr = 0;
if (llen == 0) return EOF;
return in[itr++];
}
char out[100000];
int itr2 = 0;
void put(char c) {
out[itr2++] = c;
if (itr2 == 100000) {
fwrite(out, 1, 100000, stdout);
itr2 = 0;
}
}
int clear() {
fwrite(out, 1, itr2, stdout);
itr2 = 0;
return 0;
}
int getint() {
int r = 0;
bool ng = 0;
char c;
c = get();
while (c != '-' && (c < '0' || c > '9')) c = get();
if (c == '-') ng = 1, c = get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = get();
return ng ? -r : r;
}
string getstr() {
string ret = "";
char ch = get();
while (ch == ' ' || ch == '\n') ch = get();
while (ch != ' ' && ch != '\n') ret.push_back(ch), ch = get();
return ret;
}
void putstr(string s) {
for (int i = 0; i < s.size(); i++) put(s[i]);
}
void putint(int x) {
if (x < 0) {
put('-');
x = -x;
}
if (x == 0) {
put('0');
return;
}
char c[20];
int pos = 0;
while (x) {
c[pos++] = '0' + x % 10;
x /= 10;
}
for (int i = pos - 1; i >= 0; i--) put(c[i]);
}
void getarr(int arrname[], int size) {
for (int i = 0; i < size; i++) arrname[i] = getint();
}
} // namespace fastio
using namespace fastio;
struct data_t {
int number[1000005], BITN = 1e6;
void modify(int x, int y) {
while (x <= BITN) {
number[x] += y;
x += x & -x;
}
}
int sum(int x) {
int ret = 0;
while (x) {
ret += number[x];
x &= x - 1;
}
return ret;
}
void add(int l, int r, int v) {
modify(l, v);
modify(r, -v);
}
int qry(int x) { return sum(x); }
} data;
int n, k;
vector<int> g[1000005];
vector<int> ord;
int pos[1000005];
bool used[1000005];
int par[1000005];
int sz[1000005], depth[1000005];
void dfs(int x, int pr) {
depth[x] = x == n ? 0 : depth[pr] + 1;
pos[x] = ord.size() + 1;
ord.push_back(x);
sz[x] = 1;
for (auto to : g[x])
if (to != pr) par[to] = x, dfs(to, x), sz[x] += sz[to];
}
int main() {
n = getint();
k = getint();
for (int i = 1; i < n; i++) {
int a = getint(), b = getint();
g[a].push_back(b);
g[b].push_back(a);
}
dfs(n, 0);
for (int i = 0; i < ord.size(); i++) {
data.modify(i + 1, depth[ord[i]] - (i == 0 ? 0 : depth[ord[i - 1]]));
}
used[n] = true;
int rest = n - k - 1;
cerr << data.qry(pos[3]) << endl;
for (int v = n - 1; v > 0 && rest; v--) {
if (used[v]) continue;
int len = data.qry(pos[v]);
if (len <= rest) {
int cur = v;
while (!used[cur]) {
used[cur] = true;
data.add(pos[cur], pos[cur] + sz[cur], -1);
cur = par[cur];
rest--;
}
}
}
vector<int> ans;
for (int i = 1; i <= n; i++)
if (!used[i]) ans.push_back(i);
for (int i = 0; i < ans.size(); i++) putint(ans[i]), put(' ');
clear();
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define debug(x) cout << #x << " = " << x << endl
#define file(FILENAME) freopen(FILENAME".in", "r", stdin), freopen(FILENAME".out", "w", stdout)
#define LINE() cout << "LINE = " << __LINE__ << endl
#define LL long long
#define ull unsigned long long
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define fst first
#define scd second
#define inv(x) qpow((x),mod - 2)
#define lowbit(x) ((x) & (-(x)))
#define abs(x) ((x) < 0 ? (-(x)) : (x))
#define randint(l, r) (rand() % ((r) - (l) + 1) + (l))
#define vec vector
const int MAXN = 210;
const int INF = 2e9;
const double PI = acos(-1);
const double eps = 1e-6;
int n, b;
char s[5];
bool res;
vec<int> now;
string ans, opt;
template<typename T> inline bool read(T &a) {
a = 0; char c = getchar(); int f = 1;
while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
while(c >= '0' && c <= '9') {a = a * 10 + (c ^ 48); c = getchar();}
a *= f;
return 1;
}
template<typename A, typename ...B>
inline bool read(A &x, B &...y) {return read(x) && read(y...);}
void print(int pos, string now, int op) {
res = 0;
cout << pos << ' ' << ans << now;
for(int i = ans.length() + now.size(); i < b; ++i) putchar(op + '0');
cout << endl;
cin >> opt;
res = (opt[0] == 'y');
}
void solve(vec<int> id) {
if(ans.size() == b) return;
if(!id.size()) {
int lim = ans.size();
for(int i = lim + 1; i <= b; ++i) ans = ans + "0";
return;
}
vec<int> stk(0);
string cur = "";
print(id[0], "0", 1);
cur += (res ? "1" : "0");
stk.pb(id[0]);
for(int i = 1, p, ok; i < id.size(); ++i) {
p = id[i], ok = false;
print(p, cur, 1);
if(res) ok = true;
while(stk.size() && res) {
cur.pop_back();
stk.pop_back();
print(p, cur, 1);
}
if(ans.size() + cur.size() == b) continue;
res = false;
if(!ok) print(p, cur + "0", 1);
if(ok || res) cur += "1";
else cur += "0";
stk.pb(p);
}
for(int i = stk.size() - 1; ~i; --i) {
print(stk[i], cur, 1);
if(res) {
while(stk.size() > i + 1) {
stk.pop_back();
cur.pop_back();
}
}
}
ans += cur;
solve(stk);
}
signed main () {
#ifdef FILE
freopen(".in","r",stdin);
freopen(".out","w",stdout);
#endif
read(n), read(b);
for(int i = 1; i <= n; ++i) now.pb(i);
solve(now);
cout << 0 << ' ' << ans << endl;
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
int arr[55][55] = {}, n, m, row;
bool ones;
vector<int> v;
long long dp[55][55];
long long solve(int idx, int sumones) {
if (idx == m) {
if (sumones >= 1) return 1;
return 0;
}
if (ones == true) {
if (dp[idx][sumones] != -1) return dp[idx][sumones];
dp[idx][sumones] = solve(idx + 1, sumones);
if (arr[row][idx] == 1) dp[idx][sumones] += solve(idx + 1, sumones + 1);
return dp[idx][sumones];
} else {
if (dp[idx][sumones] != -1) return dp[idx][sumones];
dp[idx][sumones] = solve(idx + 1, sumones);
if (arr[row][idx] == 0) dp[idx][sumones] += solve(idx + 1, sumones + 1);
return dp[idx][sumones];
}
}
long long solve2(int idx, int sumones) {
if (idx == n) {
if (sumones > 1) return 1;
return 0;
}
if (ones == true) {
if (dp[idx][sumones] != -1) return dp[idx][sumones];
dp[idx][sumones] = solve2(idx + 1, sumones);
if (arr[idx][row] == 1) dp[idx][sumones] += solve2(idx + 1, sumones + 1);
return dp[idx][sumones];
} else {
if (dp[idx][sumones] != -1) return dp[idx][sumones];
dp[idx][sumones] = solve2(idx + 1, sumones);
if (arr[idx][row] == 0) dp[idx][sumones] += solve2(idx + 1, sumones + 1);
return dp[idx][sumones];
}
}
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cin >> arr[i][j];
}
for (int i = 0; i < n; ++i) {
memset(dp, -1, sizeof(dp));
for (int j = 0; j < m; ++j)
if (arr[i][j] == 1) {
ones = true;
row = i;
sum += solve(0, 0);
ones = false;
break;
}
memset(dp, -1, sizeof(dp));
for (int j = 0; j < m; ++j)
if (arr[i][j] == 0) {
ones = false;
row = i;
sum += solve(0, 0);
break;
}
}
for (int j = 0; j < m; ++j) {
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; ++i)
if (arr[i][j] == 1) {
ones = true;
row = j;
sum += solve2(0, 0);
ones = false;
break;
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; ++i)
if (arr[i][j] == 0) {
ones = false;
row = j;
sum += solve2(0, 0);
break;
}
}
cout << sum << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
const long long mod = 998244353;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long first = -1, last = -1, ans = 0;
for (long long i = 0; i < (long long)(s.size()); i++) {
if (s[i] == '1') {
last = i;
long long dist = last;
if (first != -1) dist -= (first + 1);
if (first != -1) {
dist -= 2 * k;
if (dist < 0) {
first = i;
continue;
}
dist = dist / (k + 1) + (dist % (k + 1) != 0 ? 1 : 0);
} else {
dist -= k;
if (dist < 0) {
first = i;
continue;
}
dist = dist / (k + 1) + (dist % (k + 1) != 0 ? 1 : 0);
}
ans += dist;
first = i;
}
}
if (first != -1) {
long long dist = (n - first - 1 - k);
if (dist > 0) {
dist = dist / (k + 1) + (dist % (k + 1) != 0 ? 1 : 0);
ans += dist;
}
} else {
ans += (n / (k + 1) + (n % (k + 1) != 0 ? 1 : 0));
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main(int argc, char** argv) {
using namespace std;
int n;
long d;
cin >> n >> d;
long* b = new long[n];
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
int step_count = 0;
for (int i = 0; i < n - 1; ++i) {
int temp_step_count = 0;
if (b[i] > b[i + 1]) {
temp_step_count = ceil((double)(b[i] - b[i + 1]) / d);
if ((b[i] - b[i + 1]) % d == 0) {
++temp_step_count;
}
} else if (b[i] == b[i + 1]) {
temp_step_count = 1;
} else {
continue;
}
b[i + 1] += temp_step_count * d;
step_count += temp_step_count;
}
cout << step_count << '\n';
delete[] b;
return 0;
}
| 0 |
#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 on(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;
}
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;
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int main() {
int n = nxt();
cout << (n - 1) / 2 + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void st(int *a, int n) {
a[0] = 0;
for (int i = (1); i < (2 * n); i++) {
int b = i - n;
if (i % 2) b *= -1;
a[i] = a[i - 1] + b;
}
}
vector<pair<int, int>> v;
int b[2123456];
int main() {
int n, m;
scanf("%d%d", &n, &m);
st(b, m);
for (int i = (0); i < (((n + 1) / 2)); i++) {
int x = i, y = n - 1 - i;
for (int j = (0); j < ((2 * m)); j++) {
v.emplace_back(j % 2 ? y : x, b[j]);
}
}
for (int i = (0); i < ((n * m)); i++)
printf("%d %d\n", v[i].first + 1, v[i].second + 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace mine {
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3fll;
long long qread() {
long long ans = 0;
char c = getchar();
int f = 1;
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) {
num = -num;
putchar('-');
}
if (num > 9) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
puts("");
}
void chmax(long long &x, const long long y) { x = x > y ? x : y; }
void chmin(long long &x, const long long y) { x = x < y ? x : y; }
const int MAX_N = 2e5 + 10;
const long long MOD = 1e9 + 7;
void add(long long &x, long long y) {
x += y;
if (x >= MOD) x -= MOD;
if (x < 0) x += MOD;
}
int a[MAX_N], num[MAX_N];
int lst[MAX_N], nxt2[MAX_N];
int bin[30], mm[MAX_N][20], nxt[MAX_N][20];
int jump(int x, int k) {
for (int t = 19; t >= 0; t--)
if (k & bin[t]) x = nxt[x][t];
return x;
}
void main() {
bin[0] = 1;
for (int i = 1; i < 30; i++) bin[i] = bin[i - 1] << 1;
int n = qread(), m = qread(), q = qread();
for (int i = 1; i <= n; i++) a[qread()] = i;
for (int i = 1; i <= m; i++) num[i] = a[qread()];
for (int i = 1; i <= n + 1; i++) lst[i] = m + 1;
nxt[m + 1][0] = m + 1;
for (int i = m; i >= 1; i--) {
lst[num[i]] = i, nxt[i][0] = lst[num[i] + 1];
if (num[i] == n) nxt2[i] = lst[1];
}
for (int t = 1; t < 20; t++)
for (int i = 1; i <= m + 1; i++) nxt[i][t] = nxt[nxt[i][t - 1]][t - 1];
for (int i = 1; i <= m; i++) {
int to = jump(i, n - num[i]);
if (num[i] == 1)
mm[i][0] = to;
else if (nxt2[to])
mm[i][0] = jump(nxt2[to], num[i] - 2);
else
mm[i][0] = INF;
}
for (int t = 1; t < 20; t++)
for (int i = 1; i <= m - bin[t] + 1; i++)
mm[i][t] = min(mm[i][t - 1], mm[i + bin[t - 1]][t - 1]);
while (q--) {
int l = qread(), r = qread();
int t = log2(r - l + 1), ans = min(mm[l][t], mm[r - bin[t] + 1][t]);
write(ans <= r);
}
}
}; // namespace mine
int main() {
srand(time(0));
mine::main();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
string s;
vector<int> ans;
void get(const string& open, const string& close, const string& s,
vector<string>& ans) {
int b = 0;
string word;
for (int i = 0; i < int(int((s).size())); ++i) {
if (i + int((open).size()) - 1 < int((s).size()) &&
s.substr(i, int((open).size())) == open) {
if (b > 0) word += open;
b++;
i += int((open).size()) - 1;
continue;
}
if (i + int((close).size()) - 1 < int((s).size()) &&
s.substr(i, int((close).size())) == close) {
b--;
if (b != 0)
word += close;
else {
ans.push_back(word);
word.clear();
}
i += int((close).size()) - 1;
continue;
}
word += s[i];
}
}
void rec(const string& s) {
if (s.empty()) return;
vector<string> ts;
get("table", "/table", s, ts);
for (int i = 0; i < int(int((ts).size())); ++i) {
vector<string> rs;
get("tr", "/tr", ts[i], rs);
int sum = 0;
for (int j = 0; j < int(int((rs).size())); ++j) {
vector<string> cs;
get("td", "/td", rs[j], cs);
sum += int((cs).size());
for (int k = 0; k < int(int((cs).size())); ++k) rec(cs[k]);
}
ans.push_back(sum);
}
}
int main() {
char c;
while (cin >> c) s += c;
rec(s);
sort((ans).begin(), (ans).end());
for (int i = 0; i < int(int((ans).size())); ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 5005;
int sum[maxn], dp[maxn][maxn / 2][2], tmp[maxn / 2][2];
vector<int> a[maxn];
void dfs(int u, int fa) {
sum[u] = 1;
if (a[u].size() == 1)
dp[u][0][1] = dp[u][1][0] = 0;
else
dp[u][0][1] = dp[u][0][0] = 0;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (v == fa) continue;
dfs(v, u);
memset(tmp, 0x3f, sizeof tmp);
for (int i = 0; i <= sum[u]; i++) {
for (int j = 0; j <= sum[v] && i + j < maxn / 2; j++) {
tmp[i + j][1] = min(tmp[i + j][1], dp[u][i][1] + dp[v][j][1]);
tmp[i + j][1] = min(tmp[i + j][1], dp[u][i][1] + dp[v][j][0] + 1);
tmp[i + j][0] = min(tmp[i + j][0], dp[u][i][0] + dp[v][j][0]);
tmp[i + j][0] = min(tmp[i + j][0], dp[u][i][0] + dp[v][j][1] + 1);
}
}
sum[u] += sum[v];
for (int i = 0; i <= sum[u] + sum[v] && i < maxn / 2; i++) {
dp[u][i][0] = tmp[i][0];
dp[u][i][1] = tmp[i][1];
}
}
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
int rt, m = 0;
for (int i = 1; i <= n; i++)
if (a[i].size() > 1) {
rt = i;
} else
m++;
memset(dp, 0x3f, sizeof dp);
dfs(rt, -1);
printf("%d\n", min(dp[rt][m / 2][0], dp[rt][m / 2][1]));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string A;
cin >> A;
string B = A;
string C = "";
for (auto w : A) C = w + C;
cout << B << C << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char x = '\0';
int fh = 1, sum = 0;
for (x = getchar(); x < '0' || x > '9'; x = getchar())
if (x == '-') fh = -1;
for (; x >= '0' && x <= '9'; x = getchar()) sum = sum * 10 + x - '0';
return fh * sum;
}
const int N = 100009;
int n, m, ai[N];
struct node {
int opt, l, r, x;
} q[N];
int ans[N];
int L[N], R[N], val[N], tot, siz;
int fa[N], rt[N], cnt[N], d[N];
int mx, tag, l, r, tmp, ql, qr, x;
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline void merge(int x, int y) {
if (rt[y])
fa[rt[x]] = rt[y];
else {
rt[y] = rt[x];
val[rt[y]] = y;
}
cnt[y] += cnt[x];
rt[x] = cnt[x] = 0;
}
inline void build() {
mx = tag = tot = 0;
memset(rt, 0, sizeof(rt));
memset(cnt, 0, sizeof(cnt));
for (int i = l; i <= r; i++) {
mx = max(mx, ai[i]);
if (rt[ai[i]])
fa[i] = rt[ai[i]];
else {
rt[ai[i]] = fa[i] = i;
val[i] = ai[i];
}
cnt[ai[i]]++;
}
}
inline void modi() {
if ((x << 1) <= mx - tag) {
for (int j = tag + 1; j <= tag + x; j++)
if (rt[j]) merge(j, j + x);
tag += x;
} else {
for (int j = mx; j > tag + x; j--)
if (rt[j]) merge(j, j - x);
if (tag + x < mx) mx = tag + x;
}
}
inline void rebuild() {
for (int j = l; j <= r; j++) {
ai[j] = val[find(j)];
rt[ai[j]] = cnt[ai[j]] = 0;
ai[j] -= tag;
}
for (int j = l - 10; j <= r + 10; j++) val[j] = 0;
tag = mx = tot = 0;
tmp = min(qr, r);
for (int j = max(ql, l); j <= tmp; j++) {
ai[j] = ai[j] > x ? ai[j] - x : ai[j];
}
for (int j = l; j <= r; j++) {
mx = max(mx, ai[j]);
if (rt[ai[j]])
fa[j] = rt[ai[j]];
else {
rt[ai[j]] = fa[j] = j;
val[j] = ai[j];
}
cnt[ai[j]]++;
}
}
inline void get(int i) {
if (x + tag > 500000) return;
if (ql <= l && r <= qr)
ans[i] += cnt[x + tag];
else {
tmp = min(r, qr);
for (int j = max(l, ql); j <= tmp; j++)
if (val[find(j)] == tag + x) ans[i]++;
}
}
int main() {
n = read(), m = read();
siz = sqrt(n - 1) + 1;
for (int i = 1; i <= n; i++) ai[i] = read();
for (int i = 1; i <= m; i++) {
q[i].opt = read();
q[i].l = read();
q[i].r = read();
q[i].x = read();
}
int ge = 1;
L[1] = 1;
while (L[ge] + siz < n) {
R[ge] = L[ge] + siz - 1;
ge++;
L[ge] = R[ge - 1] + 1;
}
R[ge] = n;
for (int now = 1; now <= ge; now++) {
l = L[now], r = R[now];
build();
for (int i = 1; i <= m; i++) {
ql = q[i].l, qr = q[i].r, x = q[i].x;
if (r < ql || qr < l) continue;
if (q[i].opt == 1) {
if (ql <= l && r <= qr)
modi();
else
rebuild();
} else
get(i);
}
}
for (int i = 1; i <= m; i++)
if (q[i].opt == 2) printf("%d\n", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, s = 0;
scanf("%d:%d", &a, &b);
int n = a % 10, m = a / 10;
int c = n * 10 + m;
if (c < 60 && c >= b) {
s += c - b;
cout << s << endl;
} else {
for (;;) {
a++;
s += 60 - b;
b = 0;
n = a % 10, m = a / 10;
c = n * 10 + m;
if (a >= 24) {
break;
}
if (c < 60) {
s += c;
break;
}
}
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
bitset<4005> mat[2005];
int a[500005], b[500005], n, m;
int main() {
int i, j;
n = read();
m = read();
for (i = 1; i <= m; i++) {
a[i] = read();
b[i] = read();
mat[a[i]][b[i]] = 1;
}
for (i = 1; i <= n; i++) {
mat[i][i + n] = 1;
}
for (i = 1; i <= n; i++) {
if (!mat[i][i]) {
for (j = i + 1; j <= n; j++) {
if (mat[j][i]) {
swap(mat[j], mat[i]);
break;
}
}
}
for (j = 1; j <= n; j++) {
if (j == i) continue;
if (mat[j][i]) {
mat[j] ^= mat[i];
}
}
}
for (i = 1; i <= m; i++) {
puts(mat[b[i]][a[i] + n] ? "NO" : "YES");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma gcc optimize("O2")
#pragma gcc optimize("unroll-loops")
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 1e6 + 10;
int n;
vector<int> adj[N];
int ans[N];
int dep[N];
unordered_map<int, int> cnt[N];
int par[N];
int sz[N];
int mx[N];
int find(int a) { return (par[a] == a ? a : par[a] = find(par[a])); }
void make(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
for (auto x : cnt[b]) {
int tot = cnt[a][x.first] + x.second;
cnt[a][x.first] = tot;
if (make_pair(tot, -x.first) > make_pair(cnt[a][mx[a]], -mx[a])) {
mx[a] = x.first;
}
}
}
void dfs_dep(int node, int p) {
dep[node] = dep[p] + 1;
for (auto x : adj[node]) {
if (x == p) continue;
dfs_dep(x, node);
}
}
void init() {
dfs_dep(1, 1);
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
cnt[i][dep[i]]++;
mx[i] = dep[i];
}
}
void dfs(int node, int p) {
for (auto x : adj[node]) {
if (x == p) continue;
dfs(x, node);
make(node, x);
}
ans[node] = mx[find(node)] - dep[node];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
init();
dfs(1, 1);
for (int i = 1; i <= n; i++) {
cout << ans[i] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int xp, yp, vp;
int x, y, v, r;
double h, o1, o2, o3, xk, yk;
inline double kw(double a) { return a * a; }
double odls(double x, double y) { return sqrt(x * x + y * y); }
double odl(double x, double y) { return x * x + y * y; }
double odl2(double x1, double y1, double x2, double y2) {
return kw(x1 - x2) + kw(y1 - y2);
}
double pole(double x1, double y1, double x2, double y2) {
return abs(x1 * y2 - x2 * y1);
}
bool czy_prze() {
h = pole(x, y, xk, yk) / o3;
return r > h && sqrt(kw(o1) - kw(h)) + sqrt(kw(o2) - kw(h)) < o3 + 0.0000001;
}
bool q(double t) {
double om = vp / odls(xp, yp);
double a = cos(om * t);
double b = sin(om * t);
xk = a * xp - b * yp;
yk = b * xp + a * yp;
o1 = odls(x, y);
o2 = odls(xp, yp);
o3 = sqrt(odl2(x, y, xk, yk));
double w;
if (czy_prze() == 0) {
w = o3;
} else {
double pom1 = sqrt(odl(x, y) - r * r), pom2 = sqrt(odl(xp, yp) - r * r),
k1 = acos(h / o1) + acos(h / o2) - acos(r / o1) - acos(r / o2);
w = pom1 + pom2 + k1 * r;
}
return w < v * t + 0.0000001;
}
int main() {
scanf("%d%d%d", &xp, &yp, &vp);
scanf("%d%d%d%d", &x, &y, &v, &r);
double p = 0., k = 10000.;
while (p + 0.0000001 < k) {
if (q((p + k) / 2))
k = (p + k) / 2;
else
p = (p + k) / 2;
}
printf("%lf\n", (p + k) / 2);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const long long int MAX = 1e9 + 7;
void array_show(int *array, int array_n, char middle = ' ') {
for (int i = 0; i < array_n; i++)
printf("%d%c", array[i], (i != array_n - 1 ? middle : '\n'));
}
void array_show(long long int *array, int array_n, char middle = ' ') {
for (int i = 0; i < array_n; i++)
printf("%lld%c", array[i], (i != array_n - 1 ? middle : '\n'));
}
void array_show(vector<int> &vec_s, int vec_n = -1, char middle = ' ') {
if (vec_n == -1) vec_n = vec_s.size();
for (int i = 0; i < vec_n; i++)
printf("%d%c", vec_s[i], (i != vec_n - 1 ? middle : '\n'));
}
void array_show(vector<long long int> &vec_s, int vec_n = -1,
char middle = ' ') {
if (vec_n == -1) vec_n = vec_s.size();
for (int i = 0; i < vec_n; i++)
printf("%lld%c", vec_s[i], (i != vec_n - 1 ? middle : '\n'));
}
vector<vector<int> > vs;
bool used[305];
int main() {
int n, m;
int i, j, k;
int a, b, c;
cin >> n;
if (n % 2 == 1) {
memset(used, true, sizeof(used));
for (i = 0; i < n / 2; i++) {
vs.push_back((vector<int>){3, 2 * i + 1, 2 * i + 2, n});
vs.push_back((vector<int>){3, 2 * i + 1, 2 * i + 2, n});
}
}
n /= 2;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (used[i] && used[j]) {
vs.push_back(
(vector<int>){4, 2 * i + 1, 2 * j + 1, 2 * i + 2, 2 * j + 2});
vs.push_back(
(vector<int>){4, 2 * i + 1, 2 * j + 1, 2 * i + 2, 2 * j + 2});
} else if (used[i]) {
vs.push_back(
(vector<int>){4, 2 * i + 1, 2 * j + 1, 2 * i + 2, 2 * j + 2});
vs.push_back((vector<int>){3, 2 * i + 1, 2 * j + 1, 2 * j + 2});
vs.push_back((vector<int>){3, 2 * i + 2, 2 * j + 1, 2 * j + 2});
} else if (used[j]) {
vs.push_back(
(vector<int>){4, 2 * i + 1, 2 * j + 1, 2 * i + 2, 2 * j + 2});
vs.push_back((vector<int>){3, 2 * i + 1, 2 * i + 2, 2 * j + 1});
vs.push_back((vector<int>){3, 2 * i + 1, 2 * i + 2, 2 * j + 2});
} else {
vs.push_back((vector<int>){3, 2 * i + 1, 2 * j + 1, 2 * j + 2});
vs.push_back((vector<int>){3, 2 * i + 2, 2 * j + 1, 2 * j + 2});
vs.push_back((vector<int>){3, 2 * i + 1, 2 * i + 2, 2 * j + 1});
vs.push_back((vector<int>){3, 2 * i + 1, 2 * i + 2, 2 * j + 2});
}
used[i] = true, used[j] = true;
}
}
cout << vs.size() << endl;
for (auto v1 : vs) {
array_show(v1);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) ans = ans * 10 + (c - '0'), c = getchar();
return ans;
}
int vis[70], in[70], base[70], _st[70], n, m, T[1 << 22], lg[1 << 22],
sz[1 << 22], size[1 << 22];
bool able[1 << 22];
long long fac[70], inv_fac[70], dp[1 << 22];
queue<int> q;
inline int bit(int S, int w) { return (S >> w - 1) & 1; }
inline long long ksm(long long x, long long b) {
long long ans = 1;
while (b) {
if (b & 1) (ans *= x) %= 1000000007;
(x *= x) %= 1000000007;
b >>= 1;
}
return ans;
}
struct node {
int st[70], cnt[70], id[70], to[70], SZ;
long long ans;
node() {
ans = SZ = 0;
memset(st, 0, sizeof(st));
memset(cnt, 0, sizeof(cnt));
memset(id, 0, sizeof(id));
memset(to, 0, sizeof(to));
}
inline void solve(int x) {
q.push(x);
vis[x] = 1;
while (!q.empty()) {
int x = q.front();
st[++st[0]] = x;
q.pop();
for (int i = 1; i <= x - 1; i++)
if (x % i == 0) cnt[i]++;
for (int i = 1; i <= m; i++)
if (in[i] && !vis[i] && (i % x == 0 || x % i == 0)) {
vis[i] = 1;
q.push(i);
}
}
for (int i = 1; i <= m; i++)
if (base[i] && cnt[i] >= 2) id[++id[0]] = i;
memset(cnt, 0, sizeof(cnt));
memset(_st, 0, sizeof(_st));
for (int i = 1; i <= st[0]; i++)
if (!base[st[i]]) {
++_st[0];
for (int w = 1; w <= id[0]; w++)
_st[_st[0]] |= (st[i] % id[w] == 0) << w - 1;
}
memset(st, 0, sizeof(st));
sort(_st + 1, _st + _st[0] + 1);
for (int i = 1; i <= _st[0]; i++) {
if (_st[i] != st[st[0]]) st[++st[0]] = _st[i];
cnt[st[0]]++;
if (st[0]) SZ++;
}
able[0] = 1;
for (int i = 1; i <= st[0]; i++)
for (int w = 1; w <= st[0]; w++) to[i] |= ((st[i] & st[w]) != 0) << w - 1;
int N = (1 << st[0]) - 1;
memset(dp, 0, sizeof(dp));
memset(size, 0, sizeof(size));
memset(T, 0, sizeof(T));
memset(able, 0, sizeof(able));
for (int S = 0; S <= N; S++) {
int fr = S ^ (S & -S), x = lg[S & -S];
size[S] = size[fr] + cnt[x];
}
for (int S = 0; S <= N; S++) dp[S] = 0;
able[0] = dp[0] = 1;
for (int S = 0; S <= N; S++) {
int fr = S ^ (S & -S), x = lg[S & -S];
size[S] = size[fr] + cnt[x];
able[S] = able[fr] && !bit(T[fr], x);
if (able[S]) {
T[S] = T[fr] | to[x];
for (int x = 1; x <= st[0]; x++)
if (bit(S, x)) {
int F = S ^ (1 << x - 1);
(dp[S] += dp[F] * cnt[x] % 1000000007 * fac[size[T[S]] - 1] %
1000000007 * inv_fac[size[T[F]]]) %= 1000000007;
}
(ans += ((sz[S] & 1) ? -1ll : 1ll) *
(fac[size[N] - 1] * inv_fac[size[T[S]]] % 1000000007 * dp[S] %
1000000007 * size[N ^ T[S]])) %= 1000000007;
}
if (!st[0]) ans = 1;
}
}
inline void pr() {
printf("\nprime : ");
for (int i = 1; i <= id[0]; i++) printf("%d ", id[i]);
printf("\n");
for (int i = 1; i <= st[0]; i++) {
for (int w = 1; w <= id[0]; w++) printf("%d", bit(st[i], w));
printf(" : cnt %d to %d\n", cnt[i], to[i]);
}
printf("size %d : ans %d\n_____\n", SZ, ans);
}
} a[70];
int tot;
int main() {
for (int i = 1; i <= (1 << 22) - 1; i++)
lg[i] = lg[i >> 1] + 1, sz[i] = sz[i >> 1] + (i & 1);
n = read();
m = 60;
fac[0] = 1;
for (int i = 1; i <= m; i++) fac[i] = fac[i - 1] * i % 1000000007;
inv_fac[0] = 1;
for (int i = 1; i <= m; i++)
inv_fac[i] = inv_fac[i - 1] * ksm(i, 1000000007 - 2) % 1000000007;
for (int i = 1; i <= n; i++) in[read()] = 1;
for (int i = 1; i <= m; i++)
if (in[i] && !vis[i]) {
base[i] = 1;
for (int j = 1; j <= m / i; j++) vis[i * j] = 1;
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= m; i++)
if (in[i] && !vis[i]) a[++tot].solve(i);
long long ans = 1;
int sum = 0;
for (int i = 1; i <= tot; i++)
if (a[i].SZ)
(ans *= a[i].ans * ksm(fac[a[i].SZ - 1], 1000000007 - 2) % 1000000007) %=
1000000007,
sum += a[i].SZ - 1;
(ans *= fac[sum]) %= 1000000007;
printf("%lld\n", (ans + 1000000007) % 1000000007);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-6;
double const pi = 3.1415926535;
long long const mod = 1e9 + 7;
int a[20];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < (1 << n); i++) {
int x = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j))
x += a[j];
else
x -= a[j];
}
if (x % 360 == 0) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]] = i;
}
vector<int> b(n);
for (int j = 0; j < n; j++) {
cin >> b[j];
}
stack<int> pilha;
for (int k = n - 1; k > -1; k--) {
pilha.push(a[k]);
}
for (int g = 0; g < n; g++) {
int c = 0;
while (!pilha.empty()) {
if (m[b[g]] < m[pilha.top()]) {
break;
}
pilha.pop();
c++;
}
cout << c << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
string s, t, ans = "";
cin >> s >> t;
int bit = 0;
int counter = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == t[i]) {
ans.push_back(s[i]);
} else {
if (bit) {
ans.push_back(s[i]);
bit = 0;
} else {
ans.push_back(t[i]);
bit = 1;
}
counter++;
}
}
if (counter % 2 == 0) {
std::cout << ans << std::endl;
} else {
std::cout << "impossible" << std::endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
int n, m, k, xl, xr, yl, yr, zl, zr;
double ax, ay, az;
vector<int> x, y, z;
int main() {
int i, j, n, m, h, g = 0;
cin >> n >> m >> h;
vector<int> a(m);
for (i = 0; i < m; i++) {
cin >> a[i];
g += a[i];
}
if (g < n) {
cout << -1 << endl;
return 0;
}
n--;
g--;
h--;
a[h]--;
if (a[h] == 0) {
cout << 0 << endl;
return 0;
}
if (g - a[h] < n) {
cout << 1 << endl;
return 0;
}
double ans = 1;
for (; n; n--) {
ans *= (g - a[h] + 0.0) / g;
g--;
}
printf("%.10lf", 1.0 - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long nums[200005];
struct segtree {
int l, r;
segtree *lChild, *rChild;
long long val;
long long prop = 0;
segtree(int l, int r) {
this->l = l;
this->r = r;
if (l == r) {
val = nums[l];
return;
}
int mid = (l + r) / 2;
lChild = new segtree(l, mid);
rChild = new segtree(mid + 1, r);
val = min(lChild->val, rChild->val);
}
void update(int lRange, int rRange, long long amt) {
if (l > rRange || r < lRange) return;
if (l >= lRange && r <= rRange) {
prop += amt;
return;
}
propagate();
lChild->update(lRange, rRange, amt);
rChild->update(lRange, rRange, amt);
val = min(lChild->val + lChild->prop, rChild->val + rChild->prop);
}
long long rmq(int lRange, int rRange) {
if (l > rRange || r < lRange) return 9223372036854775807L;
propagate();
if (l >= lRange && r <= rRange) return val;
return min(lChild->rmq(lRange, rRange), rChild->rmq(lRange, rRange));
}
void propagate() {
if (prop == 0) return;
val += prop;
if (l != r) {
lChild->prop += prop;
rChild->prop += prop;
}
prop = 0;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
cin >> m;
string line;
getline(cin, line);
struct segtree second(0, n - 1);
for (int i = 0; i < m; i++) {
vector<int> nums;
getline(cin, line);
stringstream ss(line);
int x;
while (ss >> x) nums.push_back(x);
if (nums.size() == 3) {
if (nums[2] == 0) continue;
if (nums[0] <= nums[1]) {
second.update(nums[0], nums[1], nums[2]);
} else {
second.update(nums[0], n - 1, nums[2]);
second.update(0, nums[1], nums[2]);
}
} else {
if (nums[0] <= nums[1]) {
cout << second.rmq(nums[0], nums[1]) << "\n";
} else {
cout << (min(second.rmq(nums[0], n - 1), second.rmq(0, nums[1])))
<< "\n";
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int k;
string s;
set<pair<string, int> > r;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s >> k;
int n = s.size();
if (k > 1LL * n * (n + 1) / 2) return cout << "No such line." << endl, 0;
;
for (int i = 0; i < n; i++) {
string cur;
cur += s[i];
r.insert(make_pair(cur, i));
}
while (--k) {
auto cur = *r.begin();
r.erase(r.begin());
if (cur.second == n - 1) continue;
cur.second++;
cur.first += s[cur.second];
r.insert(cur);
}
cout << (*r.begin()).first << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
long long num[100003];
long long sum(long long x) { return (x + 1) * x / 2; }
long long sum2(long long x) { return (x + 1) * (x + 2) * x / 6; }
long long ch(long long a, long long b, long long c) {
if ((a & 1) + (b & 2) + (c & 4) == 7)
return 1;
else
return 0;
}
int check(long long a, long long b, long long c) {
if (ch(a, b, c) || ch(a, c, b) || ch(b, c, a) || ch(b, a, c) || ch(c, a, b) ||
ch(c, b, a))
return 1;
else
return 0;
}
long long gcd(long long a, long long b) {
if (a < b) {
long long t = a;
a = b;
b = t;
}
return a % b == 0 ? b : gcd(b, a % b);
}
int main() {
for (int i = 1; i <= 100000; i++) {
for (int j = i; j <= 100000; j += i) {
num[j]++;
}
}
int t = read();
while (t--) {
long long a = read(), b = read(), c = read();
long long ab = num[gcd(a, b)];
long long bc = num[gcd(b, c)];
long long ac = num[gcd(a, c)];
long long abc = num[gcd(gcd(a, b), c)];
a = num[a];
b = num[b];
c = num[c];
long long block[10];
block[1] = a - ab - ac + abc;
block[3] = ab - abc;
block[2] = b - ab - bc + abc;
block[4] = c - ac - bc + abc;
block[7] = abc;
block[5] = ac - abc;
block[6] = bc - abc;
long long ans = 0;
for (int i = 1; i <= 7; i++) {
for (int j = i; j <= 7; j++) {
for (int k = j; k <= 7; k++) {
if (check(i, k, j)) {
if (i == j && j == k) {
ans += sum2(block[i]);
} else if (i == j) {
ans += sum(block[i]) * block[k];
} else if (j == k) {
ans += sum(block[j]) * block[i];
} else if (k == i) {
ans += sum(block[i]) * block[j];
} else {
ans += block[i] * block[j] * block[k];
}
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int first[300], second[300];
pair<int, int> v[90000];
long long int cross(pair<int, int> a, pair<int, int> b) {
return (long long int)a.first * b.second - (long long int)a.second * b.first;
}
int comp(pair<int, int> a, pair<int, int> b) {
pair<int, int> va = make_pair(first[a.second] - first[a.first],
second[a.second] - second[a.first]);
pair<int, int> vb = make_pair(first[b.second] - first[b.first],
second[b.second] - second[b.first]);
int ha = (va.second > 0) || ((va.second == 0) && (va.first > 0));
int hb = (vb.second > 0) || ((vb.second == 0) && (vb.first > 0));
if (ha && !hb)
return 1;
else if (!ha & hb)
return 0;
else if (cross(va, vb) > 0)
return 1;
else
return 0;
}
long long int dp[300][300][6];
int main() {
int i;
int n;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d %d", &first[i], &second[i]);
int j, k, c = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i != j) v[c++] = make_pair(i, j);
}
}
sort(v, v + c, comp);
for (i = 0; i < n; i++) dp[i][i][0] = 1;
for (i = 0; i < c; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < 5; k++) dp[j][v[i].second][k + 1] += dp[j][v[i].first][k];
}
}
long long int ans = 0;
for (i = 0; i < n; i++) ans += dp[i][i][5];
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
int main() {
int n;
cin >> n;
int arr[n];
int s = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
s += arr[i];
}
int c = 0;
for (int i = 0; i < n; i++) {
if ((s - arr[i]) % 2 == 0) {
c++;
}
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int al[N];
int x[N << 2];
int v[N << 2];
int val[N << 2];
int ct;
int len[N];
long long cf[N];
long long kthans;
int k;
int n;
inline void add(int u, int V, int va) {
v[++ct] = V;
x[ct] = al[u];
al[u] = ct;
val[ct] = va;
}
namespace colist {
struct data {
int l;
int r;
int c;
friend bool operator<(data a, data b) { return a.r < b.r; }
};
set<data> s;
data q[N];
int hd;
inline void ih() { s.insert((data){1, (int)1e9, 0}); }
inline void split(int pos) {
set<data>::iterator it = s.lower_bound((data){pos, pos, 0});
if (it->r == pos) return;
data v1 = (data){it->l, pos, it->c};
data v2 = (data){pos + 1, it->r, it->c};
s.erase(it);
s.insert(v1);
s.insert(v2);
}
inline void ins(int l, int r, int pos) {
if (l != 1) split(l - 1);
split(r);
hd = 0;
len[pos] = r - l + 1;
for (set<data>::iterator it = s.lower_bound((data){l, l, 0});; ++it) {
q[++hd] = *it;
add(pos, it->c + 1, it->r - it->l + 1);
if (it->r >= r) break;
}
for (int i = 1; i <= hd; i++) s.erase(q[i]);
s.insert((data){l, r, pos});
}
} // namespace colist
inline bool jud(int X) {
for (int i = 1; i <= n; i++) cf[i] = 0;
long long nans = 0;
long long ret = 0;
for (int i = 1, j = 1; i <= n; i++) {
cf[i + 1] -= len[i];
for (int p = al[i]; p; p = x[p]) {
int tw = v[p];
((j >= tw) ? nans : cf[tw]) += val[p];
}
if (nans < X) continue;
while (j <= i && nans + cf[j + 1] >= X) j++, nans += cf[j];
ret += j;
}
return ret >= k;
}
inline long long calc() {
for (int i = 1; i <= n; i++) cf[i] = 0;
long long nans = 0;
long long ret = 0;
long long tot = 0;
long long sum = 0;
for (int i = 1, j = 1; i <= n; i++) {
cf[i + 1] -= len[i];
for (int p = al[i]; p; p = x[p]) {
int tw = v[p];
if (j >= tw) {
nans += val[p];
sum += (long long)val[p] * (j - tw + 1);
} else
cf[tw] += val[p];
}
if (nans < kthans) continue;
while (j <= i && nans + cf[j + 1] >= kthans)
j++, nans += cf[j], sum += nans;
ret += j;
tot += sum;
}
return tot - kthans * (ret - k);
}
int main() {
scanf("%d%d", &n, &k);
colist::ih();
for (int i = 1, l, r; i <= n; i++)
scanf("%d%d", &l, &r), r--, colist::ins(l, r, i);
int l = 0;
int r = 1e9;
while (l != r) {
int mid = (l + r + 1) >> 1;
if (jud(mid))
l = mid;
else
r = mid - 1;
}
kthans = l;
printf("%I64d", calc());
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, a[101000], cnt1[201000], cnt2[201000], chand1[101000], chand2[101000];
int check(int t) {
int i = 0, j = 0, o = 0, d = 0;
bool ch = 1;
while (ch) {
ch = 0;
if (cnt1[i + t] < cnt2[j + t] && i + t <= chand1[n - 1]) {
o++;
j = chand2[cnt1[i + t]];
i += t;
ch = 1;
} else if (cnt1[i + t] > cnt2[j + t] && j + t <= chand2[n - 1]) {
d++;
i = chand1[cnt2[j + t]];
j += t;
ch = 1;
}
}
if (i == chand1[n - 1] && o > d && cnt1[i] == n - 1) return o;
if (j == chand2[n - 1] && d > o && cnt2[j] == n - 1) return d;
return -1;
}
int main() {
cin >> n;
fill(cnt1, cnt1 + n + n, 1000000);
fill(cnt2, cnt2 + n + n, 1000000);
int k = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
k++;
cnt1[k] = i;
} else
cnt2[i - k + 1] = i;
chand1[i] = k;
chand2[i] = i - k + 1;
}
vector<pair<int, int> > ans;
for (int i = 1; i <= n; i++) {
int k = check(i);
if (k != -1) ans.push_back(make_pair(k, i));
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int MOD = 998244353;
const int N = 2e3 + 7;
int dp[N][N], bin[N], q[N];
string s;
int add(int x, int y) {
int res = ((long long)x + y) % MOD;
if (res < 0) res += MOD;
return res;
}
int mul(int x, int y) { return (long long)x * y % MOD; }
int get(int x, int y) {
if (x > y) return 0;
return q[y] - q[x - 1];
}
int solve(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
int& ans = dp[l][r] = 0;
if (s[l - 1] != '(') ans = add(ans, solve(l + 1, r));
if (s[r - 1] != ')') ans = add(ans, solve(l, r - 1));
auto k = get(l + 1, r - 1);
auto nxt = solve(l + 1, r - 1);
if (s[l - 1] != '(' && s[r - 1] != ')') ans = add(ans, -nxt);
if (s[l - 1] != ')' && s[r - 1] != '(') {
ans = add(ans, nxt);
ans = add(ans, bin[k]);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt = clock();
cin >> s;
bin[0] = 1;
for (int i = 1; i <= s.size(); ++i) {
bin[i] = mul(2, bin[i - 1]);
}
for (int i = 1; i <= s.size(); ++i) {
if (s[i - 1] == '?') {
q[i] = q[i - 1] + 1;
} else
q[i] = q[i - 1];
}
for (int i = 0; i <= s.size(); ++i) {
cerr << q[i] << " \n"[i == s.size()];
}
memset(dp, -1, sizeof dp);
cout << solve(1, s.size()) << '\n';
cerr << "TIME = " << (double)1.0 * (clock() - tt) / CLOCKS_PER_SEC
<< " seconds" << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1;
int n, d;
int a[maxn];
int lim[maxn];
int main() {
scanf("%d %d", &n, &d);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
lim[n] = d;
for (int i = n - 1; i >= 0; --i) {
lim[i] = min(d, lim[i + 1] - a[i + 1]);
if (a[i] == 0 && lim[i] < 0) {
puts("-1");
return 0;
}
}
int ans = 0, cur = 0;
for (int i = 1; i <= n; ++i) {
cur += a[i];
if (cur > d) {
puts("-1");
return 0;
}
if (a[i] == 0 && cur < 0) {
++ans;
cur = lim[i];
}
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double p, d, t, f, c;
cin >> p >> d >> t >> f >> c;
double k = d - p, x = p * t, r = 0;
if (k > 0)
while (1)
if ((x += x / k * p) >= c)
break;
else {
r++;
x += p * (x / d + f);
}
cout << r;
}
| 3 |
/*
author:ujwalll
*/
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define for1(i,n) for(int i=1;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<=(b);i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define nx cout<<"\n";
const int INF = 1<<29;
const int MOD=1e9 + 7;
#define pp pair<ll,ll>
#define ppi pair<int,int>
typedef long long int ll;
#define pri(x) printf("%d ",x);
// #define pri(x) printf("%lld ",x);
bool isPowerOfTwo (ll x)
{
return x && (!(x&(x-1)));
}
void fastio()
{
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
const int dx[] = {1,0,-1,0,1,1,-1,-1};
const int dy[] = {0,-1,0,1,1,-1,-1,1};
////////////////////////////////////////////////////////////////////
int main(){
fastio();
int tc=1;
cin>>tc;
while(tc--){
int n;
cin>>n;
int x=n;
bool f=1;
rep(i,n){
if(n&1 && x==(n+1)/2 && f){
cout<<1<<" ";
f=0;
}
else
cout<<x--<<" ";
}
cout<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[260][260];
int tdp[260][260];
void dpcopy() {
for (int i = 'a'; i <= 'z'; i++)
for (int j = 'a'; j <= 'z'; j++) tdp[i][j] = dp[i][j];
}
void pdcopy() {
for (int i = 'a'; i <= 'z'; i++)
for (int j = 'a'; j <= 'z'; j++) dp[i][j] = tdp[i][j];
}
int main() {
int n;
char temp[15];
for (int i = 0; i < 260; i++)
for (int j = 0; j < 260; j++) dp[i][j] = 0;
scanf("%d", &n);
while (n--) {
scanf("%s", temp);
int len = strlen(temp);
int s = temp[0];
int t = temp[len - 1];
dpcopy();
for (int i = 'a'; i <= 'z'; i++) {
for (int j = 'a'; j <= 'z'; j++) {
if (j == s && dp[i][j]) tdp[i][t] = max(dp[i][j] + len, tdp[i][t]);
}
}
tdp[s][t] = max(tdp[s][t], len);
pdcopy();
}
int ans = 0;
for (int i = 'a'; i <= 'z'; i++) {
if (dp[i][i] > ans) ans = dp[i][i];
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int i, n;
cin>>n;
int a[n];
for(i= 0; i< n; i++){
cin>>a[i];
}
int c= 0;
for(i= 0; i< n; i++){
if(a[i]== 1 || a[i]== 3){
c++;
}
}
cout<<c<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void merge(long int a[], long int s1, long int e1, long int s2, long int e2) {
long int n = (e1 - s1) + (e2 - s2) + 2;
long int b[n];
long int k = 0, i = s1, j = s2;
while (i <= e1 && j <= e2) {
if (a[i] < a[j]) {
b[k] = a[i];
k++;
i++;
} else {
b[k] = a[j];
k++;
j++;
}
}
while (i <= e1) {
b[k] = a[i];
k++;
i++;
}
while (j <= e2) {
b[k] = a[j];
k++;
j++;
}
k = 0;
i = s1;
while (i <= e2) {
a[i] = b[k];
k++;
i++;
}
}
void mergesort(long int a[], long int s, long int e) {
long int mid = (s + e) / 2;
if (s == e) return;
mergesort(a, s, mid);
mergesort(a, mid + 1, e);
merge(a, s, mid, mid + 1, e);
}
long int dam(string s) {
long int d = 0, t = 1;
for (long int i = 0; i < s.size(); i++) {
if (s[i] == 'S')
d += t;
else
t = t * 2;
}
return d;
}
int main() {
long int n, p;
cin >> n >> p;
long int a[n];
long long int s1 = 0, s2 = 0, t1 = 0, t2 = 0;
for (long int i = 0; i < n; i++) {
cin >> a[i];
s1 += a[i];
}
for (long int i = 0; i < n; i++) {
t1 = (s1 - a[i]) % p + (s2 + a[i]) % p;
if (t1 >= t2) t2 = t1;
s1 -= a[i];
s2 += a[i];
}
cout << t2;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
vector<pair<int, int> > path;
int n, m, px, py, swaped, s[33][33], t[33][33], vis[33][33], aux[33][33],
cnts[999], cntt[999];
int dx[] = {1, 1, -1, -1, 0, 1, 0, -1};
int dy[] = {1, -1, 1, -1, 1, 0, -1, 0};
void change() {
if (m >= n) return;
swaped ^= 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) aux[j][i] = s[i][j];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) s[i][j] = aux[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) aux[j][i] = t[i][j];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) t[i][j] = aux[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) aux[j][i] = vis[i][j];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) vis[i][j] = aux[i][j];
swap(n, m);
swap(px, py);
}
int mod(int x) { return x > 0 ? x : -x; }
void add(int x, int y) {
if (swaped)
ans.push_back(pair<int, int>(y, x));
else
ans.push_back(pair<int, int>(x, y));
}
pair<int, int> get(int c) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!vis[i][j] && s[i][j] == c) return pair<int, int>(i, j);
}
int dir(int sx, int sy, int x, int y) {
int mi, d = 1e9;
for (int i = 0; i < 8; i++) {
int nx = sx + dx[i];
int ny = sy + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || vis[nx][ny]) continue;
int nd = mod(x - nx) + mod(y - ny);
if (nd < d) d = nd, mi = i;
}
return mi;
}
void move(int x, int y) {
while (x != px || y != py) {
int mi = dir(px, py, x, y);
int nx = px + dx[mi];
int ny = py + dy[mi];
add(nx, ny);
swap(s[px][py], s[nx][ny]);
swap(vis[px][py], vis[nx][ny]);
px = nx;
py = ny;
}
}
void correct(int x, int y) {
pair<int, int> p = get(t[x][y]);
int sx = p.first;
int sy = p.second;
path.clear();
path.push_back(pair<int, int>(sx, sy));
vis[px][py] = 0;
while (sx != x || sy != y) {
int mi = dir(sx, sy, x, y);
sx = sx + dx[mi];
sy = sy + dy[mi];
path.push_back(pair<int, int>(sx, sy));
}
vis[px][py] = 1;
vis[p.first][p.second] = 1;
for (int i = 0; i < path.size() - 1; i++) {
move(path[i + 1].first, path[i + 1].second);
add(path[i].first, path[i].second);
swap(s[px][py], s[path[i].first][path[i].second]);
px = path[i].first;
py = path[i].second;
}
}
int solve() {
for (int i = 0; i < 999; i++)
if (cnts[i] != cntt[i]) return 0;
change();
if (n == 1) {
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
px = 0, py = i;
ans.clear();
add(0, i);
move(0, j);
int k;
for (k = 0; k < m; k++)
if (s[0][k] != t[0][k]) break;
if (k == m) return 1;
move(0, i);
}
return 0;
}
pair<int, int> p = get(t[0][0]);
px = p.first;
py = p.second;
vis[px][py] = 1;
add(px, py);
while (m > 2) {
for (int i = 0; i < n; i++) correct(i, m - 1);
m--;
change();
}
move(1, 1);
p = get(t[1][1]);
move(p.first, p.second);
vis[1][1] = 1;
move(1, 0);
p = get(t[1][0]);
move(p.first, p.second);
move(0, 0);
return 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> s[i][j];
cnts[s[i][j]]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> t[i][j];
cntt[t[i][j]]++;
}
if (solve()) {
cout << ans.size() - 1 << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
} else {
cout << -1 << endl;
return 0;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long pow[31];
long long sum[31];
pow[0] = 1;
sum[0] = 0;
for (int i = 1; i < 31; ++i) {
pow[i] = 2 * pow[i - 1];
sum[i] = sum[i - 1] + pow[i];
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
unsigned long long t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (pow[n] + 2 * sum[n / 2 - 1] - sum[n - 1]) << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
char c;
register int first = 0;
for (; (c = getchar()) < 48 && c ^ '-' || c > 57;)
;
bool f = c == '-';
if (f) (c = getchar());
for (; c > 47 && c < 58; (c = getchar()))
first = (first << 3) + (first << 1) + c - 48;
if (f) first = -first;
return first;
}
inline void hello() { freopen("ha.in", "r", stdin); }
const int mo = 1e9 + 7, _ = 30;
inline void inc(int &first, int second) {
if ((first += second) >= mo) first -= mo;
}
int an, K, bit[33], pw[33], dp[33][33][3][3];
int main() {
scanf("%d", &K);
for (int _r = _, i = 0; i < _r; ++i) bit[i] = K >> i & 1;
*pw = 1;
for (int _r = _, i = 1; i <= _r; ++i) pw[i] = pw[i - 1] * 2 % mo;
dp[_][0][0][0] = 1;
an = 1;
for (int _l = 1, i = _; i >= _l; --i)
for (int _r = _ - i, j = 0; j <= _r; ++j) {
if (dp[i][j][0][0]) {
int xx = dp[i][j][0][0];
if (bit[i - 1]) {
if (j) {
inc(dp[i - 1][j][0][0], 1ll * pw[j - 1] * xx % mo);
inc(dp[i - 1][j][1][0], 1ll * pw[j - 1] * xx % mo);
} else {
inc(dp[i - 1][j][1][0], xx);
}
inc(dp[i - 1][j + 1][0][0], xx);
inc(dp[i - 1][j + 1][0][1], xx);
} else {
if (j)
inc(dp[i - 1][j][0][0], 1ll * pw[j - 1] * xx % mo);
else
inc(dp[i - 1][j][0][0], xx);
}
}
if (dp[i][j][0][1]) {
int xx = dp[i][j][0][1];
if (bit[i - 1]) {
if (j) {
inc(dp[i - 1][j][0][1], 1ll * pw[j - 1] * xx % mo);
inc(dp[i - 1][j][1][1], 1ll * pw[j - 1] * xx % mo);
} else {
inc(dp[i - 1][j][0][1], xx);
inc(dp[i - 1][j][1][1], xx);
}
} else {
if (j)
inc(dp[i - 1][j][0][1], 1ll * pw[j - 1] * xx % mo);
else
inc(dp[i - 1][j][0][1], xx);
}
}
if (dp[i][j][1][0]) {
int xx = dp[i][j][1][0];
inc(dp[i - 1][j][1][0], 1ll * pw[j] * xx % mo);
inc(dp[i - 1][j + 1][1][0], xx);
inc(dp[i - 1][j + 1][1][1], xx);
}
if (dp[i][j][1][1]) {
int xx = dp[i][j][1][1];
inc(dp[i - 1][j][1][1], 1ll * pw[j] * xx % mo);
}
}
for (int _r = _, j = 1; j <= _r; ++j)
inc(an, dp[0][j][0][1]), inc(an, dp[0][j][1][1]);
printf("%d\n", an);
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct Nde {
int l, r, t, id;
} a[300000];
int tr[300000 << 2], id[300000 << 2], n, m, t[300000], ans[300000];
bool cmp(Nde a, Nde b) { return a.l < b.l || (a.l == b.l && a.id < b.id); }
void update(int L, int C, int idx, int l, int r, int rt) {
if (l == r) {
tr[rt] = C;
id[rt] = idx;
return;
}
if (L <= (l + (r - l) / 2))
update(L, C, idx, l, (l + (r - l) / 2), rt << 1);
else
update(L, C, idx, (l + (r - l) / 2) + 1, r, rt << 1 | 1);
tr[rt] = max(tr[rt << 1], tr[rt << 1 | 1]);
}
int query(int L, int C, int l, int r, int rt) {
if (tr[rt] < C) return -1;
if (l == r) return id[rt];
int ans = (L <= (l + (r - l) / 2))
? query(L, C, l, (l + (r - l) / 2), rt << 1)
: -1;
return ans == -1 ? query(L, C, (l + (r - l) / 2) + 1, r, rt << 1 | 1) : ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n + m; i++) {
scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].t);
a[i].id = i;
t[i] = a[i].t;
}
sort(a + 1, a + n + m + 1, cmp);
sort(t + 1, t + n + m + 1);
for (int i = 1; i <= n + m; i++) {
int pos = lower_bound(t + 1, t + m + n + 1, a[i].t) - t;
if (a[i].id <= n)
update(pos, a[i].r, a[i].id, 1, n + m, 1);
else
ans[a[i].id - n] = query(pos, a[i].r, 1, n + m, 1);
}
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, m;
bool T[1005][1005];
bool D[1005][1005];
struct Tree {
int BOTTOM = 1024;
bool tab[2048];
Tree() {
for (int i = 0; i < (2048); ++i) tab[i] = false;
}
bool get(int v) { return tab[BOTTOM + v]; }
void set(int a, int b, int v = 1, int lo = 0, int hi = 1023) {
if (a > b || tab[v]) return;
if (a == lo && b == hi) {
tab[v] = true;
return;
}
int mid = (lo + hi) >> 1;
set(a, std::min(b, mid), v << 1, lo, mid);
set(std::max(a, mid + 1), b, (v << 1) + 1, mid + 1, hi);
}
void fall() {
for (int i = (2); i < (2048); ++i)
if (tab[i >> 1]) tab[i] = true;
}
};
Tree trees[2][1001];
int dist[4][1001][1001];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
char c;
std::cin >> c;
if (c == '*') T[i][j] = true;
}
for (int i = 0; i < (n); ++i) {
dist[1][i][0] = (int)T[i][0] - 1;
dist[3][i][m - 1] = (int)T[i][m - 1] - 1;
for (int j = (1); j < (m); ++j) {
dist[1][i][j] = dist[1][i][j - 1] + 1;
if (!T[i][j]) dist[1][i][j] = -1;
}
for (int j = m - 2; j >= 0; --j) {
dist[3][i][j] = dist[3][i][j + 1] + 1;
if (!T[i][j]) dist[3][i][j] = -1;
}
}
for (int j = 0; j < (m); ++j) {
dist[0][0][j] = (int)T[0][j] - 1;
dist[2][n - 1][j] = (int)T[n - 1][j] - 1;
for (int i = (1); i < (n); ++i) {
dist[0][i][j] = dist[0][i - 1][j] + 1;
if (!T[i][j]) dist[0][i][j] = -1;
}
for (int i = n - 2; i >= 0; --i) {
dist[2][i][j] = dist[2][i + 1][j] + 1;
if (!T[i][j]) dist[2][i][j] = -1;
}
}
std::vector<std::pair<std::pair<int, int>, int> > mov;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
if (!T[i][j]) continue;
int r = 2000000;
for (int l = 0; l < (4); ++l) r = std::min(r, dist[l][i][j]);
if (r > 0) {
mov.push_back({{i, j}, r});
trees[0][i].set(j - r, j + r);
trees[1][j].set(i - r, i + r);
}
}
for (int i = 0; i < (2); ++i)
for (int j = 0; j < (1000); ++j) trees[i][j].fall();
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
D[i][j] = trees[0][i].get(j) || trees[1][j].get(i);
}
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j)
if (T[i][j] && !D[i][j]) {
std::cout << -1 << "\n";
return 0;
}
std::cout << mov.size() << "\n";
for (auto &pr : mov) {
std::cout << pr.first.first + 1 << " " << pr.first.second + 1 << " "
<< pr.second << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9, M = 19, Mod = 1e9 + 7;
long long d[M], l[M];
string t[N], s;
int q[N], m;
long long sl[N];
long long power(long long a, long long b) {
long long o = 1;
while (b) {
if (b & 1) o = o * a % Mod;
a = a * a % Mod;
b >>= 1;
}
return o;
}
long long get(string &s, long long &L) {
long long o = 0;
long long ol = 0;
for (int i = 0; i < int(s.size()); ++i) {
o = o * power(10, l[s[i] - '0']) % Mod + d[s[i] - '0'];
ol += l[s[i] - '0'];
ol %= (Mod - 1);
o %= Mod;
}
L = ol;
return o;
}
int main() {
cin >> s;
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
string tp;
cin >> tp;
q[i] = tp[0];
tp.erase(tp.begin(), tp.begin() + 3);
t[i] = tp;
}
for (int i = 0; i <= 9; ++i) d[i] = i, l[i] = 1;
for (int i = m; i >= 1; --i) {
d[q[i] - '0'] = get(t[i], l[q[i] - '0']);
}
long long o = get(s, *new long long);
cout << o << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int warnscanf_shit;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int n, k;
int h[maxn];
int dp[maxn];
int main() {
warnscanf_shit = scanf("%i%i", &n, &k);
for (int i = 0; i < n; ++i) {
warnscanf_shit = scanf(" %i", &h[i]);
if (i)
dp[i] = dp[i - 1] + h[i];
else
dp[i] = h[i];
}
int mn = dp[k - 1], idx = k - 1;
for (int i = k; i < n; ++i) {
if (mn > dp[i] - dp[i - k]) {
mn = dp[i] - dp[i - k];
idx = i;
}
}
printf("%i\n", idx - k + 2);
return EXIT_SUCCESS;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m, a[N][N], cnt;
pair<int, int> p[N * N];
bool mark[N][N];
vector<int> v[N];
bool cmp(const pair<int, int> &p, const pair<int, int> &q) {
return a[p.first][p.second] > a[q.first][q.second];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j], p[cnt++] = pair<int, int>(i, j);
sort(p, p + cnt, cmp);
for (int i = 0;; i++) {
int r = p[i].first, c = p[i].second;
for (int j = 0; j < v[r].size(); j++)
if (mark[v[r][j]][c]++ || mark[c][v[r][j]]++) {
cout << a[r][c] << '\n';
return 0;
}
v[r].push_back(c);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long T = clock();
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long c = 0, d = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
if (x % 2) {
d++;
} else {
c++;
}
}
if (c == n || d == n) {
cout << "YES" << ("\n");
;
} else {
cout << "NO" << ("\n");
;
}
}
cerr << "\nTIME: " << (long double)(clock() - T) / CLOCKS_PER_SEC << " sec\n";
T = clock();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count;
cin >> count;
for (int i = 0; i < count; i++) {
int size;
cin >> size;
int arr[size];
for (int j = 0; j < size; j++) cin >> arr[j];
int arr2[size];
for (int j = 0; j < size; j++) cin >> arr2[j];
int l = -1, r = -1;
for (int j = 0; j < size; j++) {
if (arr[j] != arr2[j]) {
l = j;
break;
}
}
if (l == -1) {
cout << "YES" << endl;
continue;
}
for (int j = size - 1; j >= 0; j--) {
if (arr[j] != arr2[j]) {
r = j;
break;
}
}
int diff = arr[l] - arr2[l];
if (diff > 0) {
cout << "NO" << endl;
continue;
}
bool fincheck = true;
for (int j = l; j <= r; j++) {
if (arr[j] - diff != arr2[j]) {
cout << "NO" << endl;
fincheck = false;
break;
}
}
if (fincheck) cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> g;
long long max_deg = 0;
vector<pair<long long, long long>> answer;
void dfs(long long v, long long &time, long long back_time, long long par) {
answer.push_back({v, time});
long long unvis = 0;
for (auto x : g[v]) {
if (x != par) unvis++;
}
for (auto x : g[v]) {
if (x == par) continue;
if (time == max_deg) {
time = back_time - 1 - unvis;
answer.push_back({v, time});
}
time++;
dfs(x, time, time, v);
answer.push_back({v, time});
unvis--;
}
if (par == -1) return;
if (time >= back_time) {
time = back_time - 1;
answer.push_back({v, time});
}
time++;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long i, n;
cin >> n;
g.resize(n + 1);
for (i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (auto &x : g) {
max_deg = max(max_deg, (long long)x.size());
}
long long time = 0;
dfs(1, time, -1, -1);
cout << answer.size() << "\n";
for (auto x : answer) {
cout << x.first << " " << x.second << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
vector<pair<pair<double, double>, int> > sol;
vector<pair<double, double> > v;
int main() {
long long n;
double x1, x2;
double k, b;
cin >> n;
cin >> x1 >> x2;
for (int i = 0; i < n; ++i) {
scanf("%lf %lf", &k, &b);
double tmp1 = k * x1 + b, tmp2 = k * x2 + b;
v.push_back(make_pair(k, b));
sol.push_back(make_pair(make_pair(min(tmp1, tmp2), max(tmp1, tmp2)), i));
}
sort(sol.begin(), sol.end());
bool ans = false;
for (int i = 0; i < sol.size() && !ans; ++i) {
double e = sol[i].first.second;
int ind = sol[i].second;
++i;
while (i < sol.size() && sol[i].first.first <= e) {
long long ind2 = sol[i].second;
double k1 = v[ind].first, b1 = v[ind].second, k2 = v[ind2].first,
b2 = v[ind2].second;
if (k1 != k2) {
double x = (b1 - b2) / (k2 - k1);
if (x > x1 && x < x2) ans = true;
}
ind = ind2;
e = max(e, sol[i].first.second);
++i;
}
--i;
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int ts, kk = 1;
int d, n, m;
pair<int, int> a[2][200005];
int ls[2][200005];
int qr[4];
int qs[4][200005];
int sz[2];
int sm[4][200005];
bool cmpx(int q1, int q2) { return a[1][q1].first < a[1][q2].first; }
bool cmpy(int q1, int q2) { return a[1][q1].second < a[1][q2].second; }
int main() {
int t, i, j, k;
scanf("%d%d%d", &d, &n, &m);
for (i = 0; i < d; i++) {
scanf("%d%d%d%d", &a[0][i].first, &a[0][i].second, &a[1][i].first,
&a[1][i].second);
if (a[0][i] > a[1][i]) swap(a[0][i], a[1][i]);
if (a[0][i].second == a[1][i].second) {
ls[0][sz[0]++] = i;
} else {
ls[1][sz[1]++] = i;
}
sm[0][a[0][i].first]++;
sm[1][a[1][i].first]++;
sm[2][a[0][i].second]++;
sm[3][a[1][i].second]++;
}
for (i = 0; i < 4; i++) scanf("%d", &qr[i]);
for (i = 1; i < n + 1; i++) {
sm[0][i] += sm[0][i - 1];
sm[1][i] += sm[1][i - 1];
}
for (i = 1; i < m + 1; i++) {
sm[2][i] += sm[2][i - 1];
sm[3][i] += sm[3][i - 1];
}
for (i = 0; i < sz[0]; i++) {
{
t = ls[0][i];
qs[0][t] += sm[0][a[0][t].first] - 1;
qs[1][t] += sm[1][n] - sm[1][a[0][t].first] - 1;
qs[2][t] += sm[2][a[0][t].second - 1];
qs[3][t] += sm[3][m] - sm[3][a[0][t].second];
}
}
for (i = 0; i < sz[1]; i++) {
{
t = ls[1][i];
qs[0][t] += sm[0][a[0][t].first - 1];
qs[1][t] += sm[1][n] - sm[1][a[0][t].first];
qs[2][t] += sm[2][a[0][t].second] - 1;
qs[3][t] += sm[3][m] - sm[3][a[0][t].second] - 1;
}
}
for (i = 0; i < d; i++) {
for (j = 0; j < 4; j++) {
if (qs[j][i] != qr[j]) break;
}
if (j == 4) {
printf("%d\n", i + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 262144 + 50, M = 262144;
int L;
int n, m, cnt[N];
long long ans;
int s[N], now[N];
inline void GetNow(int x) {
if (now[x] <= 0) return (void)(now[x] = -1);
now[x] = (now[x] - 1) & s[x];
while (!cnt[now[x]]) {
if (!now[x]) return (void)(now[x] = -1);
now[x] = (now[x] - 1) & s[x];
}
}
vector<int> G[N];
bool vis[N];
int siz;
int fa[N];
inline int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
inline void Merge(int x, int y) {
x = Find(x), y = Find(y);
fa[x] = y;
}
int main() {
register int i, j;
int x;
cin >> n;
m = L = 0;
cnt[0] = 1;
for (i = 1; i <= n; ++i) cin >> x, m = max(m, x), L |= x, ++cnt[x], ans -= x;
for (i = 0; i <= m; ++i) s[i] = L ^ i, now[i] = s[i] + 1, fa[i] = i;
for (i = 0; i <= m; ++i)
if (cnt[i]) {
GetNow(i);
if (now[i] != -1) G[i + now[i]].push_back(i);
}
int l, u, v;
long long k;
siz = n;
for (i = L; i >= 0 && siz; --i)
if (G[i].size()) {
while (G[i].size()) {
u = G[i][G[i].size() - 1], v = now[u];
G[i].pop_back();
if (Find(u) ^ Find(v)) {
Merge(u, v);
if (!vis[u] && !vis[v])
k = cnt[u] + cnt[v] - 1;
else if (!vis[u])
k = cnt[u];
else if (!vis[v])
k = cnt[v];
else
k = 1;
ans += k * i;
siz -= k;
vis[u] = vis[v] = 1;
}
GetNow(u);
while (now[u] != -1 && Find(u) == Find(now[u])) GetNow(u);
if (now[u] != -1) G[u + now[u]].push_back(u);
}
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
while (x--) {
unsigned long long int a, b, cnt = 0;
cin >> a >> b;
while (a != 0) {
if (a % b != 0) {
cnt += a % b;
a -= a % b;
} else if (a % b == 0) {
a /= b;
cnt++;
}
}
cout << cnt << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[101000], c[101000], num[101000];
int main() {
long long n, cir, m;
while (scanf("%lld%lld%lld", &n, &cir, &m) != EOF) {
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (a[i] != c[cnt]) {
c[++cnt] = a[i];
num[cnt] = 1;
} else {
num[cnt]++;
if (num[cnt] == cir) cnt--;
}
}
if (!cnt) {
printf("0\n");
continue;
}
long long sum = 0;
for (long long i = 1; i <= cnt; i++) sum += num[i];
long long k, k1;
long long s = 0;
for (k = 1, k1 = cnt + 1 - k; k < k1; k++, k1--) {
if (c[k] == c[k1] && num[k] + num[k1] == cir)
s = s + cir;
else
break;
}
if (k < k1) {
if (c[k] == c[k1] && num[k] + num[k1] > cir) s = s + cir;
printf("%lld\n", sum * m - s * (m - 1));
} else if (k == k1) {
long long ans = (num[k] * m) % cir;
if (ans) ans += sum - num[k];
cout << ans << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int main() {
ios_base::sync_with_stdio(false);
int n, a, b, k;
cin >> n >> a >> b >> k;
string s;
cin >> s;
s += '1';
int cnt = 0, all = 0;
for (int i = 0; i <= n; i++) {
if (s[i] == '1') {
all += cnt / b;
cnt = 0;
} else
cnt++;
}
int answer = all - a + 1;
cout << answer << endl;
cnt = 0;
for (int i = 0; i <= n; i++) {
if (s[i] == '1')
cnt = 0;
else {
cnt++;
if (cnt % b == 0 and answer > 0) {
cout << i + 1 << " ";
answer--;
}
}
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
const int oo = 1e9;
int ar[MAX];
bool mark[MAX];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> ar[i];
vector<int> all;
for (int i = 1; i <= n; i++) {
int j = i;
int cur = 0;
while (!mark[j]) {
cur++;
mark[j] = true;
j = ar[j];
}
if (cur > 0) {
all.push_back(cur);
}
}
sort(all.begin(), all.end());
if (all.size() == 1) {
cout << (long long)all[0] * all[0];
} else {
long long ans = 0;
int an = all.size();
for (int i = 0; i < an - 2; i++) ans += (long long)all[i] * all[i];
ans += (long long)(all[an - 1] + all[an - 2]) * (all[an - 1] + all[an - 2]);
cout << ans;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[105][105];
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> arr[i][j];
}
int ans1 = 0, ans2 = 0;
for (int j = 0; j < m; j++) {
int cont = 0;
int res = 0;
int x = 0;
for (int i = 0; i < n; i++) {
int aux = 0;
for (int p = 0; p < min(k, n - i + 1); p++) {
if (arr[p + i][j] == 1) aux++;
}
if (aux > res) {
res = aux;
x = cont;
}
if (arr[i][j] == 1) cont++;
}
ans1 += res;
ans2 += x;
}
cout << ans1 << " " << ans2 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
getline(cin, s);
int l = s.length();
int ans = 0;
for (int a = 0; a < l; ++a) {
if (s[a] == 'Q') {
for (int b = a + 1; b < l; ++b) {
if (s[b] == 'A') {
for (int c = b + 1; c < l; ++c) {
if (s[c] == 'Q') {
++ans;
}
}
}
}
}
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << (max(a, b) == max(c, d) && max(a, b) == min(a, b) + min(c, d)
? "YES"
: "NO");
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200005];
long long ans, lo, mid, hi;
bool can(long long x) {
int i = 0, j = n - 1, res = 0;
while (i <= j) {
while (j >= 0 && x - a[i] < a[j]) {
j--;
res++;
}
if (j < i) {
break;
}
if (x - a[i] >= a[j]) {
j--;
}
i++;
res++;
}
return (res <= k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
lo = max(lo, (long long)a[i]);
hi += a[i];
}
while (lo <= hi) {
mid = (lo + hi) / 2;
if (can(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long N = 2e5 + 5;
const long double pi = 3.14159265359;
long long n, u[N], vis[N], ma, mi;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> u[i];
sort(u, u + n);
for (long long i = 0; i < n; i++) {
if (vis[u[i] - 1] || vis[u[i]] || vis[u[i] + 1]) continue;
vis[u[i] + 1] = 1;
mi++;
}
memset(vis, 0, sizeof(vis));
for (long long i = 0; i < n; i++) {
if (!vis[u[i] - 1]) {
vis[u[i] - 1] = 1;
ma++;
} else if (!vis[u[i]]) {
vis[u[i]] = 1;
ma++;
} else if (!vis[u[i] + 1]) {
vis[u[i] + 1] = 1;
ma++;
}
}
cout << mi << " " << ma << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int SET(int n, int pos) { return n = n | (1 << pos); }
int RESET(int n, int pos) { return n = n & ~(1 << pos); }
int CHECK(int n, int pos) { return (bool)(n & (1 << pos)); }
int str2int(string s) {
stringstream ss(s);
int x;
ss >> x;
return x;
}
string int2str(int a) {
stringstream ss;
ss << a;
string str = ss.str();
return str;
}
string char2str(char a) {
stringstream ss;
ss << a;
string str = ss.str();
return str;
}
long long int bigMod(long long int n, long long int power, long long int MOD) {
if (power == 0) return 1;
if (power % 2 == 0) {
long long int ret = bigMod(n, power / 2, MOD);
return ((ret % MOD) * (ret % MOD)) % MOD;
} else
return ((n % MOD) * (bigMod(n, power - 1, MOD) % MOD)) % MOD;
}
long long int modInverse(long long int a, long long int m) {
long long int m0 = m, t, q;
long long int x0 = 0, x1 = 1;
if (m == 1) return 0;
while (a > 1) {
q = a / m;
t = m;
m = a % m, a = t;
t = x0;
x0 = x1 - q * x0;
x1 = t;
}
if (x1 < 0) x1 += m0;
return x1;
}
int POW(int x, int y) {
int res = 1;
for (; y;) {
if ((y & 1)) {
res *= x;
}
x *= x;
y >>= 1;
}
return res;
}
int inverse(int x) {
double p = ((double)1.0) / x;
return (p) + 1e-9;
}
int gcd(int a, int b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
int nC2(int n) { return n * (n - 1) / 2; }
long long int MOD(long long int n, long long int mod) {
if (n >= 0)
return n % mod;
else if (-n == mod)
return 0;
else
return mod + (n % mod);
}
int n;
bool isPrime[100005];
vector<long long int> prime;
set<long long int> primeSet;
set<long long int>::iterator it;
map<long long int, long long int> primeMaskValue, dp;
map<long long int, bool> vis;
void seive_N_logN(long long int N) {
memset(isPrime, true, sizeof isPrime);
prime.clear();
isPrime[1] = false;
for (long long int i = 4; i <= N; i = i + 2) isPrime[i] = false;
for (long long int i = 3; i * i <= N; i = i + 2) {
if (isPrime[i]) {
for (long long int j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
for (long long int i = 1; i < N; i++)
if (isPrime[i]) prime.push_back(i);
}
void func(long long int a) {
for (int i = 0; prime[i] * prime[i] <= a; i++) {
if (a % prime[i] == 0) {
int cnt = 0;
while (a % prime[i] == 0) {
a /= prime[i];
cnt++;
}
primeMaskValue[prime[i]] |= (1 << cnt);
primeSet.insert(prime[i]);
}
}
if (a > 1) {
primeMaskValue[a] |= 1 << 1;
primeSet.insert(a);
}
}
long long int call(long long int mask) {
long long int &ret = dp[mask];
if (vis[mask]) return ret;
vis[mask] = 1;
ret = 0;
set<long long int> sata;
for (int i = 1; i < 32; i++) {
long long int newMask = (mask >> i) | (((1 << i) - 1) & mask);
if (newMask != mask) {
long long int x = call(newMask);
sata.insert(x);
}
}
int mn = 0;
while (sata.find(mn) != sata.end()) mn++;
ret = mn;
return ret;
}
int main() {
int t, cas = 0;
seive_N_logN(100005 - 2);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long int a;
scanf("%lld", &a);
func(a);
}
long long int ans = 0;
for (it = primeSet.begin(); it != primeSet.end(); it++) {
vis.clear();
long long int a = *it;
ans ^= call(primeMaskValue[a]);
}
if (ans)
printf("Mojtaba\n");
else
printf("Arpa\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
#define pb push_back
#define speed ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector <ll> vll;
typedef pair<ll,ll> pll;
typedef vector <pair<ll,ll>> vpll;
typedef vector <vll> vvll;
const ll N=1e5+1;
ll t,n,k;
int main()
{
speed;
cin>>t;
while(t--)
{
cin>>n>>k;
vll ans;
cout<<n-(k+1)/2<<"\n";
for(int i=(k+1)/2;i<=n;i++)
if(i!=k)
cout<<i<<" ";
cout<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, num, hight = 0;
cin >> n >> h;
for (int i = 0; i < n; i++) {
cin >> num;
if (num > h)
hight += 2;
else
hight++;
}
cout << hight;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
void right() {
cout << "Yes\n";
exit(0);
}
void fail() {
cout << -1;
exit(0);
}
vector<vector<int>> g;
int c = 0;
map<int, int> vis;
vector<int> cur;
vector<int> one;
vector<pair<int, int>> tow;
vector<pair<int, pair<int, int>>> three;
void dfs(int v) {
c++;
cur.push_back(v);
vis[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (!vis[g[v][i]]) dfs(g[v][i]);
}
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n + 1);
int x, y;
while (m--) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
cur.clear();
c = 0;
if (!vis[i]) dfs(i);
if (c == 1) {
one.push_back(cur[0]);
} else if (c == 2) {
tow.push_back({cur[0], cur[1]});
} else if (c == 3) {
three.push_back({cur[0], {cur[1], cur[2]}});
} else if (c != 0)
fail();
}
if ((tow.size() > one.size()) or (one.size() - tow.size()) % 3 != 0) fail();
for (int i = 0; i < three.size(); i++)
cout << three[i].first << " " << three[i].second.first << " "
<< three[i].second.second << "\n";
for (int i = 0; i < tow.size(); i++)
cout << one[i] << " " << tow[i].first << " " << tow[i].second << "\n";
for (int i = tow.size(); i < one.size(); i++)
cout << one[i] << " " << one[i + 1] << " " << one[i + 2] << "\n", i += 2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long ans = 0, x = 1, y;
signed main() {
scanf("%lld", &n);
y = n;
while (y > 1) ans = ans + x * (y / 2), y = y - y / 2, x = x * 2;
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, h[MAXN], mx[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = n; i >= 0; i--) mx[i] = max(h[i + 1], mx[i + 1]);
for (int i = 0; i < n; i++) cout << max(h[i], mx[i] + 1) - h[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
unordered_set<int> e[N];
int n, m, k, ex[N], ey[N], i, ans, ot[N];
bool bb[N];
void del(int x) {
bb[x] = 0;
--ans;
for (int y : e[x]) e[y].erase(x);
for (int y : e[x])
if (bb[y] && e[y].size() < k) del(y);
e[x].clear();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (i = 1; i <= m; ++i)
cin >> ex[i] >> ey[i], e[ex[i]].insert(ey[i]), e[ey[i]].insert(ex[i]);
memset(bb + 1, 1, n);
ans = n;
for (i = 1; i <= n; ++i)
if (bb[i] && e[i].size() < k) del(i);
for (i = m; i; --i) {
ot[i] = ans;
if (bb[ex[i]] && bb[ey[i]]) {
e[ex[i]].erase(ey[i]);
e[ey[i]].erase(ex[i]);
if (bb[ex[i]] && e[ex[i]].size() < k) del(ex[i]);
if (bb[ey[i]] && e[ey[i]].size() < k) del(ey[i]);
}
}
for (i = 1; i <= m; ++i) cout << ot[i] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d, h, i, j;
cin >> n >> d >> h;
if (d > 2 * h || h > d) {
cout << -1;
return 0;
}
long long temp = 1;
if (d == 1) {
if (n == 2) {
cout << 1 << " " << 2 << endl;
return 0;
} else {
cout << -1;
return 0;
}
}
long long cur;
for (cur = 1; cur <= h; cur++) {
cout << cur << " " << cur + 1 << endl;
}
cur++;
long long prev = 1;
for (i = 0; i < d - h; i++) {
cout << prev << " " << cur << endl;
prev = cur;
cur++;
}
n -= d;
long long point = h - ((d + 1) / 2) + 1;
while (n > 1) {
cout << point << " " << cur << endl;
cur++;
n--;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
template <class T>
bool sort2(T &a, T &b) {
return a > b ? swap(a, b), 1 : 0;
}
template <class T, class... T2>
T mmin(T a, T2... b) {
return mmin(a, mmin(b...));
}
template <class T, class... T2>
T mmax(T a, T2... b) {
return mmax(a, mmax(b...));
}
struct __INIT__ {
__INIT__() {
fill((unsigned char *)&inf, (unsigned char *)&inf + sizeof(inf), 0x3f);
}
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
const int p = 1000000007;
struct Z {
unsigned first;
Z() {}
Z(unsigned a) { first = a; }
};
inline unsigned modp(const unsigned first) {
return first < p ? first : first - p;
}
inline Z operator+(const Z x1, const Z x2) { return modp(x1.first + x2.first); }
inline Z operator-(const Z x1, const Z x2) {
return modp(x1.first + p - x2.first);
}
inline Z operator-(const Z first) { return first.first ? p - first.first : 0; }
inline Z operator*(const Z x1, const Z x2) {
return static_cast<unsigned long long>(x1.first) * x2.first % p;
}
void exgcd(int a, int b, int &first, int &second) {
if (!b) {
first = 1;
second = 0;
return;
}
exgcd(b, a % b, second, first);
second -= (a / b) * first;
}
inline Z Inv(const Z a) {
int first, second;
exgcd(p, a.first, first, second);
return second < 0 ? second += p : second;
}
inline Z operator/(const Z x1, const Z x2) { return x1 * Inv(x2); }
inline Z &operator++(Z &x1) {
x1.first == p - 1 ? x1.first = 0 : ++x1.first;
return x1;
}
inline Z &operator--(Z &x1) {
x1.first ? --x1.first : x1.first = p - 1;
return x1;
}
inline Z &operator+=(Z &x1, const Z x2) { return x1 = x1 + x2; }
inline Z &operator-=(Z &x1, const Z x2) { return x1 = x1 - x2; }
inline Z &operator*=(Z &x1, const Z x2) { return x1 = x1 * x2; }
inline Z &operator/=(Z &x1, const Z x2) { return x1 = x1 / x2; }
inline Z fpm(Z a, int b) {
Z c(1);
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return c;
}
int l[200005], r[200005];
int tp[400005], mt[400005];
Z s[400005], v[400005], ss[400005];
bitset<400005> hv;
int n;
void add(int first, Z second) {
for (; first; first ^= first & -first) s[first] += second;
}
Z sum(int first) {
Z second(0);
for (; first <= n + n; first += first & -first) second += s[first];
return second;
}
void Add(int first, Z second) {
for (; first <= n + n; first += first & -first) ss[first] += second;
}
Z Sum(int first) {
Z second = 0;
for (; first; first ^= first & -first) second += ss[first];
return second;
}
Z solve(int l, int r) {
Z s(0);
while (l <= r) {
while (!hv[r]) {
--r;
if (r < l) return s;
}
s += Sum(r - 1) - Sum(l - 1) + 1;
while (l <= mt[r]) {
hv[l] = hv[mt[l]] = 0;
Add(mt[l], -v[mt[l]]);
++l;
}
--r;
}
return s;
}
signed main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(l[i], r[i]);
tp[r[i]] = 1;
mt[l[i]] = r[i];
mt[r[i]] = l[i];
}
int t;
read(t);
for (; t; --t) {
int first;
read(first);
hv[r[first]] = hv[l[first]] = 1;
}
for (int i = 1; i <= n + n; ++i) {
if (tp[i]) {
v[i] = sum(mt[i]) + 1;
add(mt[i], v[i]);
Add(i, v[i]);
}
}
write(solve(1, n + n).first, '\n');
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
long int c, i, j, m = 0, n;
char s[100][101];
scanf("%ld", &n);
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = 0; i < n; i++) {
c = 0;
for (j = 0; j < n; j++)
if (strcmp(s[i], s[j]) == 0) c++;
if (m < c) m = c;
}
printf("%ld", m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if (a == 0) {
if (b == 0)
printf(c == 0 ? "-1\n" : "0\n");
else
printf("1\n%f\n", (double)-c / b);
return 0;
}
long long d = (long long)b * b - 4LL * a * c;
if (d < 0)
printf("0\n");
else if (d == 0)
printf("1\n%f\n", -b / 2.0 / a);
else {
double r = sqrt(d);
double x1 = (-b - r) / 2 / a;
double x2 = (-b + r) / 2 / a;
if (x1 > x2) swap(x1, x2);
printf("2\n%f\n%f\n", x1, x2);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n, k;
int cnt, p[1000005], vis[1000005], phi[1000005];
void init(int n) {
phi[1] = 1;
for (register int i = 2; i <= n; ++i) {
if (!vis[i]) p[++cnt] = i, phi[i] = i - 1;
for (register int j = 1; j <= cnt && i * p[j] <= n; ++j) {
vis[i * p[j]] = 1;
if (i % p[j])
phi[i * p[j]] = phi[i] * phi[p[j]];
else {
phi[i * p[j]] = phi[i] * p[j];
break;
}
}
}
}
int main() {
scanf("%d%d", &n, &k);
if (k == 1) return puts("3"), 0;
init(n);
std ::sort(phi + 1, phi + 1 + n);
long long sum = 0;
for (register int i = 1; i <= k + 2; ++i) sum += phi[i];
printf("%lld\n", sum);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, id;
} a[100005];
vector<int> ve[100005];
int flag[100005], b[100005], fa[100005], f[100005], m;
bool cmp(node a, node b) { return a.x < b.x; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
fa[i] = i;
scanf("%d", &a[i].x);
a[i].id = i;
}
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) f[a[i].id] = i;
for (int i = 1; i <= n; i++) {
if (!flag[i]) {
int s = 0;
m++;
for (int u = i; !flag[u]; u = f[u]) {
ve[m].push_back(u);
flag[u] = 1;
}
}
}
printf("%d\n", m);
for (int i = 1; i <= m; i++) {
int size = ve[i].size();
printf("%d ", size);
for (int j = 0; j < size; j++) printf("%d ", ve[i][j]);
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
int m;
cin >> m;
int ans = 0;
sort(a.begin(), a.end());
for (int i = 0; i < min(n, m); i++) ans += a[i];
if (m > n) ans -= (m - n) * d;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, a[15], sum[1 << 11];
int f[15][1 << 11][15];
void dfs(int i, int s1, int s2, int t, int dep) {
if (dep >= m) {
if (s2 - a[i] + sum[t] + 1 >= 0 &&
a[i] - sum[t] - 1 + __builtin_popcount(t) >= 2)
f[i][s1 | t][s2 - a[i] + sum[t] + 1] = 1;
} else {
dfs(i, s1, s2, t, dep + 1);
if (!(s1 & (1 << dep)) && dep >= i) dfs(i, s1, s2, t | (1 << dep), dep + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, p; i <= n; i++) {
scanf("%d", &p);
if (p == 2)
return puts("NO"), 0;
else if (p == 1)
s++;
else
a[++m] = p;
}
if (n == 1 && s == 1) return puts("YES"), 0;
sort(a + 1, a + m + 1, greater<int>());
if (s <= m) return puts("NO"), 0;
for (int i = 1; i < (1 << m); i++)
sum[i] = a[__builtin_ctz(i) + 1] + sum[i ^ (i & (-i))];
f[0][1][s] = 1;
for (int i = 0; i < m; i++)
for (int j = 1; j < (1 << m); j++)
if (!i || (j & (1 << i - 1)))
for (int k = 0; k <= s; k++)
if (f[i][j][k]) dfs(i + 1, j, k, 0, 0);
puts(f[m][(1 << m) - 1][0] ? "YES" : "NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(vector<int> a, vector<int> b) { return a[2] < b[2]; }
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int qq = 1;
while (qq--) {
long long n, d, m, l;
cin >> n >> d >> m >> l;
if (d > m)
for (long long i = 0;; i += d) {
if (i % m > l || i > (n - 1) * m + l) {
cout << i;
return 0;
}
}
long long now = 0, del, bl = 0;
vector<int> v;
v.push_back(0);
while (1) {
now += d;
if (now <= l) bl = now;
if (now >= m) {
del = now % m;
bl = max(bl, now % m);
break;
}
if (now > l && now < m) {
cout << now;
return 0;
}
v.push_back(now % m);
}
now = 0;
long long del_now = 0;
while (1) {
if (now + del_now > (n - 1) * m + l) {
while (now + del_now > (n - 1) * m + l) {
now -= d;
}
now += d;
cout << now + del_now;
return 0;
}
long long blt = del_now + ((l - del_now) / d) * d;
while (blt < m) {
if (blt > l) {
cout << now + blt << endl;
return 0;
} else
blt += d;
}
now += m;
del_now += del;
if (del_now >= m) {
del_now = del_now % m;
now += m;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, sum = 0;
cin >> a;
while (a != 0) {
if (a % 8 == 1) {
sum++;
}
a >>= 3;
}
cout << sum;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct moja {
long long d, x, y, c;
} r[100005];
int cmp(struct moja qq, struct moja ww) {
if (qq.d != ww.d) {
return qq.d < ww.d;
}
}
long long q, i, dosao[100005], otisao[100005], usao, izasao, m, n, k,
md[100005], mi[100005], sol, dsol[100005], isol[100005], gusao, gizasao, j;
int main() {
usao = 10000001;
scanf("%I64d%I64d%I64d", &n, &m, &k);
gusao = m + 1;
for (i = 1; i <= m; i++) {
scanf("%I64d%I64d%I64d%I64d", &r[i].d, &r[i].x, &r[i].y, &r[i].c);
}
sort(r + 1, r + m + 1, cmp);
q = 0;
for (i = 1; i <= m; i++) {
if (r[i].x != 0) {
dosao[r[i].x]++;
if (dosao[r[i].x] == 1) {
q++;
if (q == n) {
usao = r[i].d;
gusao = i;
}
}
}
}
q = 0;
for (i = m; i >= 1; i--) {
if (r[i].x == 0) {
otisao[r[i].y]++;
if (otisao[r[i].y] == 1) {
q++;
if (q == n) {
izasao = r[i].d;
gizasao = i;
}
}
}
}
for (i = 1; i <= n; i++) {
md[i] = 1000001;
mi[i] = 1000001;
}
dsol[0] = md[1] * n;
for (i = 1; i <= m; i++) {
dsol[i] = dsol[i - 1];
if (r[i].x != 0) {
if (r[i].c < md[r[i].x]) {
dsol[i] = dsol[i] - (md[r[i].x] - r[i].c);
md[r[i].x] = r[i].c;
}
}
}
isol[m + 1] = mi[1] * n;
for (i = m; i >= 1; i--) {
isol[i] = isol[i + 1];
if (r[i].x == 0) {
if (r[i].c < mi[r[i].y]) {
isol[i] = isol[i] - (mi[r[i].y] - r[i].c);
mi[r[i].y] = r[i].c;
}
}
}
sol = dsol[0] + isol[m + 1];
j = gusao;
for (i = gusao; i <= gizasao; i++) {
while (1) {
if (r[j].d - r[i].d > k) break;
j++;
if (j > gizasao) break;
}
if (j > gizasao) break;
if (dsol[i] + isol[j] < sol) sol = dsol[i] + isol[j];
}
if (sol < dsol[0] + isol[m + 1])
printf("%I64d", sol);
else
printf("-1");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long ans = 0;
for (int i = 0; i < 3; i++) {
cin >> a[i];
long long p = max(0LL, (a[i] + 2) / 3 - 1);
ans += p;
a[i] -= p * 3;
}
sort(a, a + 3);
if (a[0] == 0)
cout << ans + a[1] / 3 + a[2] / 3 << '\n';
else if (a[0] == 1 && a[1] == 2 && a[2] == 3)
cout << ans + 1 << '\n';
else
cout << ans + (a[0] + a[1] + a[2]) / 3 << '\n';
}
| 4 |
#include <bits/stdc++.h>
const long long MAXN = 200000 + 5, MOD = 998244353;
long long n, k, inv[MAXN], fac[MAXN], ans;
long long fpow(long long a, long long b) {
long long sum = 1;
for (; b; b >>= 1, a = a * a % MOD)
if (b & 1) sum = sum * a % MOD;
return sum;
}
signed main() {
std::cin >> n >> k;
fac[0] = 1;
if (k >= n) return std::cout << 0, 0;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
inv[n] = fpow(fac[n], MOD - 2);
for (long long i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % MOD;
for (long long i = 0; i <= n - k; i++) {
long long res = fac[n - k] * inv[i] % MOD * inv[n - k - i] % MOD *
fpow(n - k - i, n) % MOD;
if (i & 1)
ans = (res < ans) ? ans - res : ans - res + MOD;
else
ans = (ans + res) % MOD;
}
ans = ans * (k ? 2 : 1) * fac[n] % MOD * inv[k] % MOD * inv[n - k] % MOD;
std::cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
map<int, int> mp;
string fct[20] = {"", "", "2", "3", "322", "5", "53", "7", "7222", "7332"};
int main() {
int i, j, k, n, m;
string st, ans = "";
cin >> n >> st;
reverse(st.begin(), st.end());
for (i = 0; i < st.size(); i++) {
int a = st[i] - '0';
ans += fct[a];
}
sort(ans.begin(), ans.end(), greater<int>());
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long POW(long long n, long long k, long long p = 99824435312111LL) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
const int N = 200020;
int n, m, k, l, r;
string st;
int f[N][4][4];
int main() {
if (fopen("text.inp", "r")) {
freopen("text.inp", "r", stdin);
freopen("text.out", "w", stdout);
}
ios_base::sync_with_stdio(false);
cin >> n >> m;
cin >> st;
st = " " + st;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 2; j++)
for (int k = 0; k <= 2; k++) f[i][j][k] = f[i - 1][j][k];
f[i][i % 3][st[i] - 'a']++;
}
while (m--) {
cin >> l >> r;
if (l == r) {
cout << 0 << endl;
continue;
}
int mn = INT_MAX;
for (int i = 0; i <= 2; i++)
for (int j = 0; j <= 2; j++)
for (int k = 0; k <= 2; k++) {
if (i == j || j == k || i == k) continue;
mn = min(mn, r - l + 1 - (f[r][0][i] - f[l - 1][0][i]) -
(f[r][1][j] - f[l - 1][1][j]) -
(f[r][2][k] - f[l - 1][2][k]));
}
cout << mn << endl;
}
}
| 4 |
#include <bits/stdc++.h>
int n, t;
int p[1000050], q[1000050];
int ans;
int main() {
scanf("%d", &n);
for (int i = (0); i != (n); i++) scanf("%d", p + i);
scanf("%d", &t);
for (int i = (0); i != (t); i++) scanf("%d", q + i);
for (int i = (0); i != (t); i++) p[q[i] - 1] = -p[q[i] - 1];
std::stack<int> s;
for (int i = ((n)-1); i >= (0); i--) {
if (p[i] < 0)
s.push(p[i]);
else if (s.empty()) {
p[i] = -p[i];
s.push(p[i]);
} else if (p[i] == (-s.top()))
s.pop();
else {
p[i] = -p[i];
s.push(p[i]);
}
if (s.size() > i) {
ans = 1;
break;
}
}
if (ans)
printf("NO\n");
else {
printf("YES\n");
for (int i = (0); i != (n); i++) printf("%d ", p[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, p;
int i;
int a = 1, b = -1, c = 0;
cin >> s;
cin >> p;
for (i = 0; i < s.size(); i++) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
transform(p.begin(), p.end(), p.begin(), ::tolower);
if (s[i] > p[i]) {
cout << a << endl;
break;
}
if (s[i] < p[i]) {
cout << b << endl;
break;
}
}
if (s == p) cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100111, maxk = 14;
int n, k, q, a[maxk][maxn];
void init() {
scanf("%d%d%d", &n, &k, &q);
for (int i = 1; i <= k; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &a[i][j]);
}
int A[maxk];
inline bool cmp(int a, int b) { return A[a] < A[b]; }
bitset<4100> b[maxn];
int calc(int x, int y) {
static int w[maxk];
for (int i = 1; i <= k; ++i) A[i] = a[i][y], w[i] = i;
sort(w + 1, w + k + 1, cmp);
int m = (1 << k) - 1;
for (int i = 1; i <= k; ++i) {
m ^= 1 << w[i] - 1;
if (!b[x][m]) return A[w[i]];
}
assert(false);
}
void work() {
for (int i = 1; i <= k; ++i)
for (int j = 0; j < 1 << k; ++j) b[i][j] = j >> i - 1 & 1;
for (int N = k; q--;) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
b[++N] = b[x] | b[y];
else if (op == 2)
b[++N] = b[x] & b[y];
else
printf("%d\n", calc(x, y));
}
}
int main() {
init();
work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1.0);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
const int INF = 1000000000;
int N, K;
int keys[100001];
int leftMax[100001];
int leftMin[100001];
int rightMin[100001];
int rightMax[100001];
bool in[100001];
double expv[100001];
vector<int> G[100001];
void dfs1(int s) {
if (!G[s].size()) {
leftMax[s] = rightMin[s] = leftMin[s] = rightMax[s] = keys[s];
return;
}
for (int i = 0; i < (int)G[s].size(); i++) dfs1(G[s][i]);
int l = 0;
int r = 1;
if (keys[G[s][0]] > keys[s]) swap(l, r);
leftMax[s] = rightMax[G[s][l]];
rightMin[s] = leftMin[G[s][r]];
leftMin[s] = leftMin[G[s][l]];
rightMax[s] = rightMax[G[s][r]];
}
void dfs2(int s, long long sum, int cnt) {
if (!G[s].size()) {
expv[s] = (double)(sum) / (cnt);
return;
}
for (int i = 0; i < (int)G[s].size(); i++) {
int to = G[s][i];
int rev = G[s][!i];
if (keys[to] > keys[s])
dfs2(to, sum + rightMax[rev], cnt + 1);
else
dfs2(to, sum + leftMin[rev], cnt + 1);
}
}
pair<int, int> search(int s, int val) {
if (!G[s].size()) return make_pair(keys[s], s);
int l = G[s][0];
int r = G[s][1];
if (keys[l] > keys[r]) swap(l, r);
if (keys[s] > val) return search(l, val);
return search(r, val);
}
int main() {
vector<pair<int, int> > ord;
cin >> N;
int root;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
a--;
ord.push_back(pair<int, int>(b, i));
keys[i] = b;
if (a != -2) {
G[a].push_back(i);
in[a] = true;
} else
root = i;
}
sort(ord.begin(), ord.end());
for (int i = 0; i < 100001; i++) {
leftMax[i] = rightMax[i] = -INF;
rightMin[i] = leftMin[i] = INF;
}
dfs1(root);
dfs2(root, 0, 0);
cin >> K;
for (int i = 0; i < K; i++) {
int a;
cin >> a;
vector<pair<int, int> >::iterator it =
lower_bound(ord.begin(), ord.end(), pair<int, int>(a, -1));
if (it != ord.begin()) it--;
if (in[it->second]) it++;
int node = it->second;
printf("%.10f\n", expv[node]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string st1[3000 + 5], st2[3000 + 5], str, str2;
map<string, int> mp;
map<string, int>::iterator it;
int n, m, i, siz1, siz2;
cin >> n >> m;
for (int j = 0; j < m; j++) {
cin >> str >> str2;
if (str.size() <= str2.size())
st1[j] = str;
else
st1[j] = str2;
mp[str] = j;
}
for (int k = 0; k < n; k++) {
cin >> str;
st2[k] = st1[mp[str]];
}
for (int i = 0; i < n; i++)
if (i == 0)
cout << st2[i];
else
cout << ' ' << st2[i];
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[20][20];
long long res[20];
int bit[20], bn;
long long m, n, pn, ans;
void deep(int now, int _max, int party, long long cur) {
if (now >= _max) return;
if (party == 7) {
if (now < _max) {
ans += cur;
ans %= 1000000007ll;
}
return;
}
for (int i = 0; i < bn; i++) {
if (res[i]) {
res[i]--;
deep(now + i, _max, party + 1, cur * (res[i] + 1) % 1000000007ll);
res[i]++;
}
}
}
long long dfs(long long pos, long long target, long long limit) {
long long sum = 0;
if (pos == 0) return target == 0;
if ((limit == 0) && (dp[pos][target] != -1)) return dp[pos][target];
long long tail = limit ? bit[pos] : 9;
for (int i = 0; i <= tail; i++)
sum += dfs(pos - 1, target - (i == 4 || i == 7),
(limit == 1) && (bit[pos] == i));
if (limit == 0) dp[pos][target] = sum;
return sum;
}
void cal(long long x) {
ans = bn = 0;
long long y = x;
while (y) {
++bn;
bit[bn] = y % 10;
y /= 10;
}
for (int i = 0; i <= bn; i++) res[i] = dfs(bn, i, 1);
res[0] -= 1;
for (int i = 1; i <= bn; i++) deep(0, i, 1, res[i]);
}
int main() {
long long m;
memset(dp, -1, sizeof dp);
scanf("%I64d", &m);
cal(m);
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010, maxm = 10010;
using namespace std;
int n, m, pre[maxm], now[maxn], son[maxm], val[maxm], f[maxn][maxn][2],
g[maxn][2], siz[maxn], tot, in[maxn];
bool isl[maxn];
void add(int a, int b) {
pre[++tot] = now[a], now[a] = tot, son[tot] = b, in[b]++;
}
void dfs(int x, int fa) {
if (isl[x]) {
siz[x] = 1, f[x][0][0] = f[x][1][1] = 0;
return;
}
f[x][0][0] = f[x][0][1] = 0;
for (int y = now[x]; y; y = pre[y])
if (son[y] != fa) {
dfs(son[y], x);
memset(g, 63, sizeof(g));
for (int i = siz[x]; i >= 0; i--)
for (int j = siz[son[y]]; j >= 0; j--) {
g[i + j][0] = min(g[i + j][0], f[x][i][0] + f[son[y]][j][0]);
g[i + j][1] = min(g[i + j][1], f[x][i][1] + f[son[y]][j][1]);
g[i + j][0] = min(g[i + j][0], f[x][i][0] + f[son[y]][j][1] + 1);
g[i + j][1] = min(g[i + j][1], f[x][i][1] + f[son[y]][j][0] + 1);
}
memcpy(f[x], g, sizeof(f[x]));
siz[x] += siz[son[y]];
}
}
int main() {
scanf("%d", &n);
for (int i = 1, a, b; i < n; i++) scanf("%d%d", &a, &b), add(a, b), add(b, a);
if (n == 2) {
printf("1");
return 0;
}
for (int i = 1; i <= n; i++) isl[i] = (in[i] == 1);
memset(f, 63, sizeof(f));
for (int i = 1; i <= n; i++)
if (in[i] != 1) {
dfs(i, 0);
printf("%d\n", min(f[i][siz[i] >> 1][0], f[i][siz[i] >> 1][1]));
return 0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int>> adj;
vector<vector<int>> vis;
int dfs1(int a, int b) {
if (a == n - 1 and b == m - 1) return 1;
vis[a][b] = 1;
if (a + 1 < n and adj[a + 1][b] and !vis[a + 1][b])
if (dfs1(a + 1, b)) return 1;
if (b + 1 < m and adj[a][b + 1] and !vis[a][b + 1])
if (dfs1(a, b + 1)) return 1;
vis[a][b] = 2;
return 0;
}
int dfs2(int a, int b) {
if (a == n - 1 and b == m - 1) return 1;
vis[a][b] = 1;
if (a + 1 < n and adj[a + 1][b] and vis[a + 1][b] != 1)
if (dfs2(a + 1, b)) return 1;
if (b + 1 < m and adj[a][b + 1] and vis[a][b + 1] != 1)
if (dfs2(a, b + 1)) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
adj = vector<vector<int>>(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < m; ++j) {
if (s[j] == '.')
adj[i][j] = 1;
else
adj[i][j] = 0;
}
}
int a = 0;
vis = vector<vector<int>>(n, vector<int>(m, 0));
a += dfs1(0, 0);
a += dfs2(0, 0);
cout << a << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr long double m_pi = 3.1415926535897932L;
constexpr long long MOD = 1000000007;
constexpr long long INF = 1LL << 61;
constexpr long double EPS = 1e-10;
template <typename T>
using vector2 = vector<vector<T>>;
template <typename T>
using vector3 = vector<vector2<T>>;
string operator*(const string& s, int k) {
if (k == 0) return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1) p += s;
return p;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> b(n);
for (long long(i) = (long long)(0); i < (long long)(n); i++) cin >> b[i];
long long cnt = 0;
map<char, long long> mp;
long long ans = 0;
for (long long(i) = (long long)(0); i < (long long)(n / 2); i++) {
if (s[i] != s[n - 1 - i])
ans += b[i] + b[n - 1 - i];
else {
cnt++;
mp[s[i]]++;
ans += max(b[i], b[n - 1 - i]);
}
}
long long mx = 0;
char ch;
for (auto [k, v] : mp)
if (chmax(mx, v)) ch = k;
if (mx * 2 <= cnt)
cout << ans << "\n";
else {
vector<long long> tmp;
for (long long(i) = (long long)(0); i < (long long)(n / 2); i++) {
if (s[i] != ch && s[n - 1 - i] != ch && s[i] != s[n - 1 - i])
tmp.push_back(min(b[i], b[n - 1 - i]));
}
sort((tmp).begin(), (tmp).end(), greater<long long>());
while (mx * 2 > cnt) cnt++, ans -= tmp.back(), tmp.pop_back();
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first)
return a.second < b.second;
else
return a.first > b.first;
}
void run() {
int a, b;
cin >> a >> b;
vector<pair<int, int>> ans(a);
for (int i = 0; i < a; i++) {
cin >> ans[i].first >> ans[i].second;
}
sort(ans.begin(), ans.end(), comp);
int c1 = ans[b - 1].first, c2 = ans[b - 1].second;
int answer = 0;
for (auto x : ans) {
if (x.first == c1 and x.second == c2) answer++;
}
cout << answer;
}
int main() { run(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void input(T &x) {
register char c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
inline long long bigmod(long long p, long long e, long long M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
const int N = 1001;
vector<int> G[N];
int link[N], second[N], T[N], rig[N];
bool dfs(int u) {
second[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (T[v]) continue;
T[v] = 1;
if (link[v] == -1 || dfs(link[v])) {
link[v] = u;
rig[u] = v;
return 1;
}
}
return 0;
}
int maxMatching(int n) {
int ret = 0;
memset(link, -1, sizeof link);
memset(rig, -1, sizeof rig);
for (int i = 1; i <= n; i++) {
memset(second, 0, sizeof second);
memset(T, 0, sizeof T);
if (dfs(i)) ret++;
}
return ret;
}
int dir[100][2];
int ways = 0;
void buildGraph(int n, int m) {
for (int i = 1; i < N; i++) G[i].clear();
for (int k = 1; k <= n; k++) {
for (int l = 1; l <= m; l++) {
if ((k + l) % 2 == 0) {
for (int p = 0; p < ways; p++) {
int x = k + dir[p][0], y = l + dir[p][1];
if (x >= 1 && x <= n && y >= 1 && y <= m) {
int vi = k * m + l, vj = x * m + y;
G[vi].push_back(vj);
}
}
}
}
}
}
int main() {
for (int i = -3; i <= 3; i++) {
for (int j = -3; j <= 3; j++) {
if (abs(i) + abs(j) == 3) dir[ways][0] = i, dir[ways][1] = j, ways++;
}
}
int Ans[15][24];
for (int i = 1; i <= 10; i++) {
for (int j = i; j <= 20; j++) {
buildGraph(i, j);
Ans[i][j] = maxMatching(i * j + j) * 2;
}
}
long long n, m;
input(n), input(m);
if (n > m) swap(n, m);
if (n == 1) {
if (m <= 20)
cout << Ans[n][m] << endl;
else if (m % 6 && m % 6 <= 3)
cout << (m / 6 * 6) << endl;
else if (m % 6 == 0)
cout << m << endl;
else if (m % 6 == 5)
cout << m - 1 << endl;
else if (m % 5 == 4)
cout << m - 2 << endl;
} else if (n == 2) {
if (m <= 20)
cout << Ans[n][m] << endl;
else
cout << 2 * m << endl;
} else {
if (n % 2 && m % 2)
cout << (n * m - 1) << endl;
else
cout << n * m << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 100;
int N, M, G[NMax][NMax];
vector<int> G1[NMax][NMax];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
int first, second, k;
scanf("%d%d%d", &first, &second, &k);
G[first][second] = 1;
for (int j = 1; j <= k; j++) {
int t;
scanf("%d", &t);
G1[first][second].push_back(t);
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++)
if (G1[i][j].size() >= 2) {
vector<int> t = G1[i][j];
int p = -1;
for (int k = 0; k < t.size() - 1; k++) {
if (t[k] == i && t[k + 1] == j) {
p = k;
break;
}
}
if (p == -1 || t.size() > 2 * N) continue;
int cnt = 2;
vector<int> t1;
for (int k = p - 1; k >= 0; k--) t1.push_back(t[k]);
int a = i, flag = 1;
for (int k = 0; k < t1.size(); k++) {
if (G[t1[k]][a]) {
for (int l = G1[t1[k]][a].size() - 1; l >= 0; l--)
t1.push_back(G1[t1[k]][a][l]);
a = t1[k];
cnt++;
if (cnt > 2 * N) {
flag = 0;
break;
}
} else {
flag = 0;
break;
}
}
if (!flag) continue;
vector<int> t2;
for (int k = p + 2; k < t.size(); k++) t2.push_back(t[k]);
a = j;
for (int k = 0; k < t2.size(); k++) {
if (G[a][t2[k]]) {
for (int l = 0; l < G1[a][t2[k]].size(); l++)
t2.push_back(G1[a][t2[k]][l]);
a = t2[k];
cnt++;
if (cnt > 2 * N) {
flag = 0;
break;
}
} else {
flag = 0;
break;
}
}
if (!flag) continue;
printf("%d\n", (int)t1.size() + (int)t2.size() + 2);
for (int k = t1.size() - 1; k >= 0; k--) printf("%d ", t1[k]);
printf("%d %d ", i, j);
for (int k = 0; k < t2.size(); k++) printf("%d ", t2[k]);
puts("");
return 0;
}
}
puts("0");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long MAXN = 1000000;
using ll = long long;
void fast_stream() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
ll doit(vector<ll> s) {
if (s.size() == 1) {
return 1;
}
ll mini = s.size();
ll n = s.size();
ll kol = 0;
ll minim = inf;
ll k = 0;
for (long long i = 0; i < n; i++) {
minim = min(s[i], minim);
}
kol += minim;
for (long long i = 0; i < n; i++) {
s[i] = s[i] - minim;
}
vector<ll> e;
for (long long i = 0; i < n; i++) {
if (s[i] == 0) {
if (e.size() > 0) {
kol += doit(e);
e.clear();
}
} else {
e.push_back(s[i]);
}
}
if (e.size() > 0) {
kol += doit(e);
e.clear();
}
return min(mini, kol);
}
signed main() {
fast_stream();
ll t = 1;
while (t--) {
ll n;
cin >> n;
vector<ll> s(n);
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
ll kol = 0;
vector<ll> e;
for (long long i = 0; i < n; i++) {
if (s[i] == 0) {
if (e.size() > 0) {
kol += doit(e);
e.clear();
}
} else {
e.push_back(s[i]);
}
}
if (e.size() > 0) {
kol += doit(e);
e.clear();
}
cout << kol << endl;
}
exit(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, sumx, sumy;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x >= 0) sumx++;
if (x <= 0) sumy++;
}
if ((sumx > 1 && sumy > 1))
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, m, x;
long long ans, f[2000001], g[2000001];
inline long long read() {
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x;
}
long long qpow(long long x, long long y) {
long long sum = 1;
while (y) {
if (y & 1) sum = sum * x % mod;
x = x * x % mod;
y >>= 1;
}
return sum;
}
void FWT_And(int n, int jdg, long long *f) {
for (long long i = 2, j = 1; i <= n; i <<= 1, j <<= 1)
for (long long k = 0; k < n; k += i)
for (long long l = 0; l < j; l++)
f[k + l] = (f[k + l] + f[j + k + l] * jdg % mod + mod) % mod;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
x = read();
f[x]++;
m = max(m, x);
}
n = 1;
while (n <= m) n <<= 1;
FWT_And(n, 1, f);
g[0] = 1;
for (int i = 0; i < n; i++) {
if (!g[i]) g[i] = -g[i ^ (i & (-i))];
ans = (ans + g[i] * (qpow(2, f[i]) - 1) % mod + mod) % mod;
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string dir;
string delfolder(string s) {
if (s == "/") return s;
string newdir;
int p = s.length() - 2;
while (s[p] != '/') p--;
for (int i = 0; i <= p; i++) newdir += s[i];
return newdir;
}
int main() {
dir = "/";
string folder, s, ins;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ins;
if (ins == "pwd")
cout << dir << endl;
else {
cin >> s;
if (s[0] == '/') dir = "/";
int len = s.length();
for (int i = 0; i < len; i++)
if (s[i] == '/' && !folder.empty())
dir += folder + "/", folder.clear();
else if (s[i] == '.' && s[i + 1] == '.')
dir = delfolder(dir);
else if (s[i] != '.' && s[i] != '/')
folder += s[i];
if (!folder.empty()) dir += folder + "/", folder.clear();
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
set<pair<int, int> > all, no;
int n, k, ans, x[N];
bool was[N];
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> x[i];
if (was[x[i] - 1]) no.insert(make_pair(x[i], x[i] - 1));
if (was[x[i] + 1]) no.insert(make_pair(x[i], x[i] + 1));
was[x[i]] = true;
no.insert(make_pair(x[i], x[i]));
}
all.insert(make_pair(1, 1));
all.insert(make_pair(n, n));
if (n > 1) {
all.insert(make_pair(1, 2));
all.insert(make_pair(n, n - 1));
}
for (int i = 2; i < n; i++) {
all.insert(make_pair(i, i - 1));
all.insert(make_pair(i, i));
all.insert(make_pair(i, i + 1));
}
ans = (n - 2) * 3 + 4;
for (pair<int, int> p : all)
if (no.find(p) != no.end()) ans--;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bitset<30001> isprime;
unsigned n, a, b, c, d;
inline unsigned f(unsigned x) { return a * x * x * x + b * x * x + c * x + d; }
bitset<2000100> val;
int P[30001], ptot;
unsigned ans = 0;
int tot = 0;
inline void getans(int l, int r) {
val.set();
for (int i = 0; i < ptot && P[i] * P[i] <= r; i++)
for (int j = (l + P[i] - 1) / P[i] * P[i]; j <= r; j += P[i])
val[j - l] = 0;
for (int i = l; i <= r; i++)
if (val[i - l]) ans += f(i) * (n / i);
}
int main() {
isprime.set();
for (int i = 2; i <= 30000; i++)
if (isprime[i])
for (int j = i + i; j <= 30000; j += i) isprime[j] = 0;
cin >> n >> a >> b >> c >> d;
for (int i = 2; i <= 30000; i++)
if (isprime[i]) {
int now = n / i;
while (now) ans += now * f(i), now /= i;
P[ptot++] = i;
}
for (unsigned l = 30001, r; l <= n; l = r + 1) {
r = min(l + 2000000, n);
getans(l, r);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5, M = 1e9 + 7;
int n, q;
long long int a[maxn], mi[maxn * 4], lazy[maxn * 4], po[maxn];
void put(int s, int e, int id, long long int x) {
lazy[id] += x;
mi[id] += x;
}
void shift(int s, int e, int id) {
int mid = (s + e) >> 1;
if (s + 1 == e) {
return;
}
put(s, mid, id << 1, lazy[id]);
put(mid, e, id << 1 | 1, lazy[id]);
lazy[id] = 0;
}
void update(long long int add, int l, int r, int id = 1, int s = 0, int e = n) {
if (e <= l || s >= r) {
return;
}
if (s >= l && e <= r) {
put(s, e, id, add);
return;
}
shift(s, e, id);
int mid = (s + e) >> 1;
update(add, l, r, id << 1, s, mid);
update(add, l, r, id << 1 | 1, mid, e);
mi[id] = min(mi[id << 1], mi[id << 1 | 1]);
return;
}
int get(int s = 0, int e = n, int id = 1) {
if (mi[id] > 0) return -1;
if (e - s < 2) {
if (mi[id] < 0) return -1;
if (mi[id] == 0) return s + 1;
}
shift(s, e, id);
int mid = (s + e) >> 1, ans;
ans = get(s, mid, id << 1);
if (ans == -1) ans = get(mid, e, id << 1 | 1);
return ans;
}
int main() {
cin >> n >> q;
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
po[i] = sum - a[i];
update(po[i], i, i + 1);
sum += a[i];
}
for (int i = 0; i < q; i++) {
long long int p, x, t;
cin >> p >> x;
p--;
t = a[p] - x;
a[p] = x;
update(-t, p + 1, n);
update(t, p, p + 1);
cout << get() << endl;
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.