solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, ans = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return f * ans;
}
const long long MAXN = 1e5 + 11;
long long N, p, A[MAXN], ps, Q, ste[MAXN], nex[MAXN];
long long Get(long long x) {
long long Ans = x;
for (long long i = 2; i * i <= x; i++) {
if ((x % i)) continue;
while ((x % i) == 0) x /= i;
Ans /= i, Ans *= (i - 1);
}
if (x != 1) Ans /= x, Ans *= (x - 1);
return Ans;
}
bool FF;
long long ksm(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a, ans %= mod;
a *= a, a %= mod;
b >>= 1;
}
return ans;
}
bool pd(long long l, long long r, long long Limit) {
if (A[l] == 1) return (1 < Limit);
long long L = l, R = min(r, nex[l] - 1), Up = A[R];
if (Up >= Limit) return 0;
for (long long i = R - 1; i >= L; i--) {
long long res = A[i], cnt = Up;
long long s1 = ksm(res, cnt, Limit), s2 = ksm(res, cnt, Limit + 1),
s3 = ksm(res, cnt, Limit + 2);
if (s1 != s2 || s2 != s3 || s1 != s3) return 0;
Up = s1;
}
return 1;
}
long long solve(long long l, long long r, long long step) {
if (A[l] == 1) return A[l] % ste[step];
if (l == r) return A[l] % ste[step];
if (ste[step] == 1) return 0;
bool f = pd(l + 1, r, ste[step + 1]);
if (!f)
return ksm(A[l], solve(l + 1, r, step + 1) + ste[step + 1], ste[step]);
return ksm(A[l], solve(l + 1, r, step + 1), ste[step]);
}
signed main() {
N = read(), p = read();
for (long long i = 1; i <= N; i++) A[i] = read();
ste[1] = p;
for (long long i = 2; ste[i - 1] != 1; i++) ste[i] = Get(ste[i - 1]);
ps = N + 1;
for (long long i = N; i >= 1; i--) {
nex[i] = ps;
if (A[i] == 1) ps = i;
}
Q = read();
while (Q--) {
long long l = read(), r = read();
printf("%lld\n", solve(l, r, 1));
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, k;
string s;
cin >> n >> k;
cin >> s;
long int temp, ans;
temp = ans = 0;
for (long int i = 1; i < n; i++) {
if (s[i] == '#') temp++;
if (s[i] == '.' && s[i - 1] == '#') {
ans = max(ans, temp);
temp = 0;
}
}
if (k > ans)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int MAXIOSIZE = 1 << 24 | 1;
unsigned char buf[MAXIOSIZE], *p1, *p2;
template <typename T>
void read(T& x) {
x = 0;
char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 24, stdin), p1 == p2)
? EOF
: *p1++);
bool flg = false;
for (; ch < '0' || '9' < ch;
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 24, stdin), p1 == p2)
? EOF
: *p1++))
if (ch == '-') flg |= true;
for (; '0' <= ch && ch <= '9';
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 24, stdin), p1 == p2)
? EOF
: *p1++))
x = x * 10 + ch - '0';
flg ? x = -x : 0;
}
template <typename T>
void out(const T& x) {
if (x > 9) out(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void write(const T& x, const char& ed = ' ') {
if (x < 0)
putchar('-'), out(-x);
else
out(x);
putchar(ed);
}
} // namespace IO
const int MAXN = 40 + 10;
long long n, t;
long long num[MAXN], f[2][MAXN][MAXN];
int main() {
IO::read(n), IO::read(t);
if (t != (t & -t)) return puts("0"), 0;
int s = __builtin_ctzll(t);
++n;
for (int i = (40), iend = (0); i >= iend; --i) num[i] = (n >> i) & 1;
for (int i = (0), iend = (num[40]); i <= iend; ++i)
f[i == num[40]][40][i == 1] = 1;
for (int i = (40), iend = (1); i >= iend; --i) {
for (int less = (0), lessend = (1); less <= lessend; ++less) {
for (int j = (0), jend = (40); j <= jend; ++j) {
if (!f[less][i][j]) continue;
for (int bit = (0), bitend = (less ? num[i - 1] : 1); bit <= bitend;
++bit) {
f[less & (bit == num[i - 1])][i - 1][j + (bit == 1)] += f[less][i][j];
}
}
}
}
IO::write(f[0][0][s + 1] + f[1][0][s + 1] - (s == 0), '\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int g[220][220];
int d[220][220];
int v[220], p[220], f[220];
int n, m, x, y, z, w;
void work(int u, int v) {
vector<pair<int, int> > a, b;
for (int i = 1; i <= n; i++) a.push_back(pair<int, int>(d[u][i], d[v][i]));
sort(a.begin(), a.end());
for (int i = 0; i < a.size(); i++) {
while (b.size() && b.back().second <= a[i].second) b.pop_back();
b.push_back(a[i]);
}
int d = 0x3f3f3f3f, q;
if (b.size() == 1)
if (b[0].first < b[0].second) {
q = 0;
d = 2 * b[0].first;
} else {
q = g[u][v];
d = 2 * b[0].second;
}
for (int i = 1; i < b.size(); i++)
if (d > g[u][v] + b[i - 1].first + b[i].second) {
q = g[u][v] - b[i - 1].first + b[i].second >> 1;
d = g[u][v] + b[i - 1].first + b[i].second;
}
if (d < z) x = u, y = v, z = d, w = q;
}
int main() {
scanf("%d %d", &n, &m);
memset(g, 0x3f, sizeof g);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &x, &y, &z);
z *= 2;
g[x][y] = g[y][x] = min(g[x][y], z);
}
for (int i = 1; i <= n; i++) g[i][i] = 0;
memcpy(d, g, sizeof d);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
z = 0x3f3f3f3f;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
if (g[i][j] < 0x3f3f3f3f) work(i, j);
printf("%.8lf\n", z / 4.0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, r;
cin >> n;
int a[n + 5];
cout << "? 1 2" << endl;
cout.flush();
cin >> p;
cout << "? 2 3" << endl;
cout.flush();
cin >> q;
cout << "? 1 3" << endl;
cout.flush();
cin >> r;
a[2] = (r + q - p) / 2;
a[0] = r - a[2];
a[1] = q - a[2];
for (int i = 4; i <= n; i++) {
cout << "? 3 " << i << endl;
cout.flush();
cin >> p;
a[i - 1] = p - a[2];
}
cout << "!";
for (int i = 0; i < n; i++) cout << " " << a[i];
cout << endl;
cout.flush();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
#define MP make_pair
#define PB push_back
#define X first
#define Y second
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define ITER(it, a) for(__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)
#define ALL(a) a.begin(), a.end()
#define SZ(a) (int)((a).size())
#define FILL(a, value) memset(a, value, sizeof(a))
#define debug(a) cerr << #a << " = " << a << endl;
const double PI = acos(-1.0);
const LL INF = 1e9;
const LL LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int random(int l, int r)
{
return l + rng() % (r - l + 1);
}
const int T = 10000;
int Tmax;
const int N = 400 + 7;
const int M = 800 + 7;
int n, m;
vector<PII> g[N];
pair<int, PII> edges[M];
PII order[T];
VI needed[N];
int dist[N][N];
int parent[N][N];
int G[N][N];
int number_of_orders_on_suf[T + 1];
inline int waiting_orders(int l, int r)
{
r = min(r , T - 1);
if (l > r) return 0;
return number_of_orders_on_suf[r] - (l ? number_of_orders_on_suf[l - 1] : 0);
}
void graph_input()
{
cin >> n >> m;
FOR(i, 1, n + 1) FOR(j, 1, n + 1) G[i][j] = INF;
FOR(i, 1, n + 1) G[i][i] = 0;
FOR(i, 0, m)
{
int u, v, w;
cin >> u >> v >> w;
G[u][v] = G[v][u] = w;
g[u].PB({v, w});
g[v].PB({u, w});
edges[i] = {w, {u, v}};
}
}
void order_input()
{
cin >> Tmax;
FILL(order, -1);
int de;
int suma = 0;
double maxCof = 0;
FOR(i, 0, Tmax)
{
int t;
cin >> t;
suma += t;
if(suma / (i + 1.) > maxCof)
{
maxCof = suma / (i + 1.0);
de = i;
}
if (i)
number_of_orders_on_suf[i] = number_of_orders_on_suf[i - 1];
if (t == 0) continue;
number_of_orders_on_suf[i]++;
int id, dst;
cin >> id >> dst;
order[i] = {id, dst};
needed[dst].PB(i);
}
cerr << de << endl;
}
void preprocess()
{
FOR(i, 1, n + 1)
{
FOR(j, 1, n + 1) dist[i][j] = INF;
dist[i][i] = 0;
set<PII> S;
FOR(j, 1, n + 1)
S.insert({dist[i][j], j});
while(SZ(S))
{
int v = S.begin()->Y;
S.erase(S.begin());
for(auto e: g[v])
{
int to = e.X, len = e.Y;
if (dist[i][to] <= dist[i][v] + len) continue;
parent[i][to] = v;
S.erase({dist[i][to], to});
dist[i][to] = dist[i][v] + len;
S.insert({dist[i][to], to});
}
}
}
}
vector<int> path(int from, int to)
{
vector<int> res;
while(from != to)
{
res.PB(to);
to = parent[from][to];
}
res.PB(from);
reverse(ALL(res));
return res;
}
vector<int> go(vector<int>& orders, int start_time)
{
int curr_vertex = 1;
vector<int> res;
const int Magic = 47;
while(SZ(orders))
{
int to = -1;
for(auto i: orders)
if (to == -1 || dist[curr_vertex][to] > dist[curr_vertex][order[i].Y])
to = order[i].Y;
int curr_time = start_time + SZ(res);
int nxt_time = start_time + SZ(res) + dist[curr_vertex][to];
//cerr << curr_time << " " << nxt_time << '\n';
if(curr_time < 9300 && nxt_time >= 9500 && curr_vertex != 1)
to = 1;
if (curr_vertex != 1 && 2 * dist[curr_vertex][to] > dist[curr_vertex][1] && SZ(res) >= Magic && curr_time < 9500)
to = 1;
vector<int> way = path(curr_vertex, to);
FOR(i, 0, SZ(way) - 1)
FOR(j, 0, G[way[i]][way[i + 1]])
res.PB(way[i + 1]);
curr_vertex = to;
sort(ALL(way));
vector<int> nxt;
for(auto i: orders)
{
auto it = lower_bound(ALL(way), order[i].Y);
if (it != way.end() && *it == order[i].Y) continue;
nxt.PB(i);
}
orders = nxt;
if (to == 1) break;
}
vector<int> way = path(curr_vertex, 1);
FOR(i, 0, SZ(way) - 1)
FOR(j, 0, G[way[i]][way[i + 1]])
res.PB(way[i + 1]);
return res;
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
graph_input();
order_input();
preprocess();
vector<int> res;
vector<int> orders;
int Magic = 1;
int chas = 0;
while(chas < Tmax)
{
if (order[chas].X != -1)
orders.PB(chas);
if (SZ(orders) >= Magic)
{
auto tut = go(orders, chas);
for(auto i: tut) res.PB(i);
if (SZ(res) >= Tmax)
{
res.resize(Tmax);
break;
}
FOR(i, 0, SZ(tut))
{
chas++;
if (order[chas].X != -1) orders.PB(chas);
}
continue;
}
chas++;
res.PB(-1);
}
for(auto i: res) cout << i << endl;
//cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
};
struct line {
Point p1, p2;
};
vector<Point> vec1, vec2;
vector<line> vec3;
bool onLine(line l1, Point p) {
if (p.x <= max(l1.p1.x, l1.p2.x) && p.x <= min(l1.p1.x, l1.p2.x) &&
(p.y <= max(l1.p1.y, l1.p2.y) && p.y <= min(l1.p1.y, l1.p2.y)))
return true;
return false;
}
int direction(Point a, Point b, Point c) {
int val = (b.y - a.y) * (c.x - b.x) - (b.x - a.x) * (c.y - b.y);
if (val == 0)
return 0;
else if (val < 0)
return 2;
return 1;
}
bool isIntersect(line l1, line l2) {
int dir1 = direction(l1.p1, l1.p2, l2.p1);
int dir2 = direction(l1.p1, l1.p2, l2.p2);
int dir3 = direction(l2.p1, l2.p2, l1.p1);
int dir4 = direction(l2.p1, l2.p2, l1.p2);
if (dir1 != dir2 && dir3 != dir4) return true;
if (dir1 == 0 && onLine(l1, l2.p1)) return true;
if (dir2 == 0 && onLine(l1, l2.p2)) return true;
if (dir3 == 0 && onLine(l2, l1.p1)) return true;
if (dir4 == 0 && onLine(l2, l1.p2)) return true;
return false;
}
bool cmp(Point a, Point b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
Point nn;
nn.x = a, nn.y = b;
vec1.push_back(nn);
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
Point nn;
nn.x = a, nn.y = b;
vec2.push_back(nn);
}
if (n != m) {
printf("No\n");
exit(0);
}
sort(vec1.begin(), vec1.end(), cmp);
sort(vec2.begin(), vec2.end(), cmp);
vector<int> xx;
for (int i = 0; i < vec1.size(); i++) xx.push_back(i);
do {
vec3.clear();
for (int i = 0; i < vec1.size(); i++) {
line L1 = {{vec1[xx[i]].x, vec1[xx[i]].y}, {vec2[i].x, vec2[i].y}};
vec3.push_back(L1);
}
bool hobeina = true;
for (int i = 0; i < vec3.size(); i++) {
for (int j = 0; j < vec3.size(); j++) {
if (i == j) continue;
if (isIntersect(vec3[i], vec3[j])) {
hobeina = false;
}
}
}
if (hobeina == true) {
printf("Yes\n");
exit(0);
}
} while (next_permutation(xx.begin(), xx.end()));
printf("No\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w, h;
long long rem = 998244353;
scanf("%lld%lld", &w, &h);
long long ans = 4LL;
for (int i = 1; i < w; ++i) {
ans *= 2;
ans %= rem;
}
for (int i = 1; i < h; ++i) {
ans *= 2;
ans %= rem;
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n == 0)
cout << 0 << endl;
else if ((n + 1) % 2 == 0)
cout << (n + 1) / 2 << endl;
else if ((n + 1) % 2 != 0)
cout << n + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> g[605];
set<int> known, all;
map<string, int> cache;
string toString(const set<int> &f) {
ostringstream ss;
for (int x : f) ss << x << ",";
return ss.str();
}
void toCache(const set<int> &f1, int val) { cache[toString(f1)] = val; }
void toCache(const set<int> &f1, const set<int> &f2, int val) {
set<int> f = f1;
for (int x : f2) f.insert(x);
toCache(f, val);
}
int queryCount = 0;
int get(const set<int> &f1) {
if (f1.size() <= 1) return 0;
if (cache.count(toString(f1))) {
return cache[toString(f1)];
}
++queryCount;
cout << "? " << f1.size() << endl;
for (int x : f1) cout << x << " ";
int ret;
cin >> ret;
return cache[toString(f1)] = ret;
}
int get(const set<int> &f1, const set<int> &f2) {
set<int> f = f1;
for (int x : f2) f.insert(x);
return get(f);
}
void addEdge(pair<int, int> e) {
g[e.first].push_back(e.second);
g[e.second].push_back(e.first);
known.insert(e.second);
all.erase(e.second);
}
pair<int, int> find(const set<int> &a, const set<int> &b, int valA, int valB) {
toCache(b, valB);
if (a.size() == 1 && b.size() == 1) {
return make_pair(*a.begin(), *b.begin());
}
if (a.size() > 1) {
set<int> a1, a2;
for (int x : a) {
if (a1.size() < a.size() / 2)
a1.insert(x);
else
a2.insert(x);
}
int valA1 = get(a1), valA1B = get(a1, b);
if (valA1B - valB - valA1 > 0)
return find(a1, b, 0, valB);
else {
return find(a2, b, 0, valB);
}
}
{
set<int> b1, b2;
for (int x : b) {
if (b1.size() < b.size() / 2)
b1.insert(x);
else
b2.insert(x);
}
int valB1 = get(b1), valAB1 = get(a, b1);
int tmp = valAB1 - 0 - valB1;
if (tmp > 0)
return find(a, b1, 0, valB1);
else
return find(a, b2, 0, get(b2));
}
}
pair<int, int> find(const set<int> &a, const set<int> &b) {
return find(a, b, 0, get(b));
}
pair<int, int> getEdge(const set<int> &f) {
int valF = get(f);
for (int x : f) {
set<int> tmp = f;
tmp.erase(x);
int valTmp = get(tmp);
if (valTmp != valF) {
set<int> a;
a.insert(x);
return find(a, tmp, 0, valTmp);
}
}
return {-1, -1};
}
int color[605];
void go(int v, int col) {
if (color[v] != 0) return;
color[v] = col;
for (int x : g[v]) go(x, 3 - col);
}
vector<int> path;
bool findPath(int st, int fn) {
if (color[st] != 0) return false;
path.push_back(st);
color[st] = 1;
if (st == fn) return true;
for (int x : g[st])
if (findPath(x, fn)) return true;
path.pop_back();
return false;
}
int main() {
cin >> n;
known.insert(1);
for (int i = 2; i <= n; ++i) all.insert(i);
for (int i = 2; all.size() > 0; ++i) {
pair<int, int> e = find(known, all);
addEdge(e);
}
go(1, 1);
set<int> l, r;
for (int i = 1; i <= n; ++i)
if (color[i] == 1)
l.insert(i);
else
r.insert(i);
int v1 = get(l), v2 = get(r);
if (v1 == 0 && v2 == 0) {
cout << "Y " << l.size() << endl;
for (int x : l) cout << x << " ";
cout << endl;
} else {
pair<int, int> e = getEdge((v1 > 0) ? l : r);
memset(color, 0, sizeof(color));
findPath(e.first, e.second);
cout << "N " << path.size() << endl;
for (int x : path) cout << x << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const double eps = 1e-6;
inline long long pow(long long a, long long b, long long p) {
long long rtn = 1;
while (b) {
if (b & 1) rtn = rtn * a % p;
a = a * a % p;
b >>= 1;
}
return rtn;
}
long long inv(long long a, long long p) { return pow(a, p - 2, p); }
long long gcd(long long a, long long b) {
long long k;
while (b != 0) {
k = b;
b = a % b;
a = k;
}
return a;
}
void makedata() {
freopen("input.txt", "w", stdout);
srand((unsigned)time(NULL));
fclose(stdout);
}
long long a[5500], s[5500];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
}
int ans = 0;
for (int i = (1); i <= (n); i++) {
for (int j = (i); j <= (n); j++) {
if (s[j] - s[i - 1] > 100 * (j - i + 1)) ans = max(ans, j - i + 1);
}
}
cout << (ans) << endl;
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int M,l,b;
int x,y;
char d;
while(cin>>b){
int a[21][21]={};
if(b==0)break;
for(int i=0;i<b;i++){
cin>>x>>y;
a[y][x]=1;
}
cin>>M;
x=10;
y=10;
for(int i=0;i<M;i++){
cin>>d>>l;
for(int j=0;j<l;j++){
if(d=='N') y++;
else if(d=='E')x++;
else if(d=='S')y--;
else x--;
if(a[y][x]==1) b--;
a[y][x]=0;
}
}
if(b==0)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
set<int> X[N], Y[N];
bool check(int x, int y) {
if (x < 0 || x >= N || y < 0 || y >= N) return 0;
return X[x].count(y);
}
void erase(int x, int y) {
X[x].erase(y);
Y[y].erase(x);
}
ll ans = 0;
void solvex(int x) {
while (!X[x].empty()) {
int y = *X[x].begin();
erase(x, y);
for (auto y2 : X[x]) {
int len = y2 - y;
if (check(x + len, y) && check(x + len, y + len)) {
ans++;
}
if (check(x - len, y) && check(x - len, y + len)) {
ans++;
}
}
}
}
void solvey(int y) {
while (!Y[y].empty()) {
int x = *Y[y].begin();
erase(x, y);
for (auto x2 : Y[y]) {
int len = x2 - x;
if (check(x, y + len) && check(x + len, y + len)) {
ans++;
}
if (check(x, y - len) && check(x + len, y - len)) {
ans++;
}
}
}
}
int main() {
int n;
scanf("%d", &n);
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}
for (int i = 0; i < n; ++i) {
X[x[i]].insert(y[i]);
Y[y[i]].insert(x[i]);
}
for (int i = 0; i < N; ++i) {
if (X[i].size() * X[i].size() <= n) {
solvex(i);
}
}
for (int i = 0; i < N; ++i) {
solvey(i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NUM = 5010;
struct edge {
int next, to;
} e[NUM];
int head[3010], tot;
void gInit() {
memset(head, -1, sizeof(head));
tot = 0;
}
void add_edge(int u, int v) {
e[tot] = (edge){head[u], v};
head[u] = tot++;
}
int dist[NUM][NUM];
int in_mx[NUM][5];
int out_mx[NUM][5];
vector<pair<int, int> > uv[NUM], vu[NUM];
void bfs(int s) {
queue<int> que;
que.push(s);
dist[s][s] = 1;
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].to;
if (dist[s][v] == 0) {
dist[s][v] = dist[s][u] + 1;
que.push(v);
}
}
}
}
int n, m;
int res, ans[4];
void solve1(int b, int c) {
int a = 0, d = 0;
for (int i = 0; i < 4; ++i) {
if (in_mx[b][i] != c) {
a = in_mx[b][i];
break;
}
}
for (int i = 0; i < 4; ++i) {
if (out_mx[c][i] != a && out_mx[c][i] != b) {
d = out_mx[c][i];
break;
}
}
if (a > 0 && d > 0 && dist[a][b] && dist[c][d] &&
dist[a][b] + dist[b][c] + dist[c][d] > res) {
res = dist[a][b] + dist[b][c] + dist[c][d];
ans[0] = a;
ans[1] = b;
ans[2] = c;
ans[3] = d;
}
}
void solve2(int b, int c) {
int a = 0, d = 0;
for (int i = 0; i < 4; ++i) {
if (out_mx[c][i] != b) {
d = out_mx[c][i];
break;
}
}
for (int i = 0; i < 4; ++i) {
if (in_mx[b][i] != c && in_mx[b][i] != d) {
a = in_mx[b][i];
break;
}
}
if (a > 0 && d > 0 && dist[a][b] && dist[c][d] &&
dist[a][b] + dist[b][c] + dist[c][d] > res) {
res = dist[a][b] + dist[b][c] + dist[c][d];
ans[0] = a;
ans[1] = b;
ans[2] = c;
ans[3] = d;
}
}
int main() {
scanf("%d%d", &n, &m);
gInit();
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
}
res = -1;
for (int i = 1; i <= n; ++i) bfs(i);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == j || dist[i][j] == 0) continue;
in_mx[j][4] = i;
out_mx[i][4] = j;
for (int k = 3; k >= 0; --k) {
if (dist[in_mx[j][k]][j] < dist[in_mx[j][k + 1]][j]) {
swap(in_mx[j][k], in_mx[j][k + 1]);
}
if (dist[i][out_mx[i][k]] < dist[i][out_mx[i][k + 1]]) {
swap(out_mx[i][k], out_mx[i][k + 1]);
}
}
}
}
for (int b = 1; b <= n; ++b) {
for (int c = 1; c <= n; ++c) {
if (b == c || dist[b][c] == 0) continue;
solve1(b, c);
solve2(b, c);
}
}
printf("%d %d %d %d\n", ans[0], ans[1], ans[2], ans[3]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, m = 0, ans = 0;
cin >> n;
string s;
cin >> s;
int a[n];
int h[26];
fill(h, h + 26, 0);
for (i = n - 1; i >= 0; i--) {
m = 0;
for (j = 0; j < s[i] - 'a'; j++) {
m = max(m, h[j]);
}
a[i] = m + 1;
h[s[i] - 'a'] = a[i];
ans = max(ans, a[i]);
}
cout << ans << endl;
for (i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char* arr1 = new char[100];
char* arr2 = new char[100];
cin >> arr1 >> arr2;
int y = strlen(arr1);
for (int i = 0; i < y; i++) {
if (arr1[i] >= 65 && arr1[i] <= 90) arr1[i] += 32;
if (arr2[i] >= 65 && arr2[i] <= 90) arr2[i] += 32;
}
int a = 0;
for (int i = 0; i < y; i++) {
if (arr1[i] == arr2[i]) a++;
}
if (a == y)
cout << "0";
else {
for (int i = 0; i < y; i++) {
if (arr1[i] > arr2[i]) {
cout << "1";
break;
} else if (arr1[i] < arr2[i]) {
cout << "-1";
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y);
long long gcd(long long a, long long b);
int sum(int x) {
int s = 0;
while (x > 0) {
s += (x % 10);
x /= 10;
}
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
map<int, pair<int, int>> mp;
for (int i = 0; i < n; i++) {
int val, type;
cin >> val >> type;
if (type)
mp[val].second++;
else
mp[val].first++;
}
auto it = mp.begin();
priority_queue<pair<int, int>> pq;
priority_queue<pair<int, int>> pq1;
while (it != mp.end()) {
pq.push({it->second.first + it->second.second, it->first});
it++;
}
int curr = pq.top().first;
int ans = 0;
int ones = 0;
pq1.push({mp[pq.top().second].second, mp[pq.top().second].first});
pq.pop();
while (curr > 0) {
if (pq.empty() && pq1.empty()) break;
while (!pq.empty() && pq.top().first >= curr) {
pq1.push({mp[pq.top().second].second, mp[pq.top().second].first});
pq.pop();
}
if (pq1.empty()) {
curr--;
continue;
}
if (curr > (pq1.top().first + pq1.top().second)) {
curr = pq1.top().first + pq1.top().second - 1;
ans += pq1.top().first + pq1.top().second;
ones += pq1.top().first;
} else {
if (curr <= pq1.top().first) {
ans += curr;
ones += curr;
} else {
ones += pq1.top().first;
ans += curr;
}
curr--;
}
pq1.pop();
}
cout << ans << " " << ones << "\n";
}
return 0;
}
long long power(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lld = long long;
bool ok(string a, string b) {
sort(a.begin(), a.end());
sort(b.begin(), b.end());
return (a == b);
}
int inv(string a) {
int res = 0;
for (int i = 0; i < a.length(); i++)
for (int j = i + 1; j < a.length(); j++) res += (a[i] < a[j] ? 1 : 0);
return res;
}
bool par(string a) {
vector<int> cnt(26, 0);
for (char c : a) cnt[c - 'a']++;
for (int i : cnt)
if (i > 1) return true;
return false;
}
void query(void) {
int n;
string a, b;
cin >> n >> a >> b;
if (!ok(a, b)) {
cout << "NO\n";
return;
}
if (par(a))
cout << "YES\n";
else
cout << (inv(a) % 2 == inv(b) % 2 ? "YES" : "NO") << "\n";
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) query();
return 0;
}
| 6 |
#include<iostream>
#include<cstdio>
using namespace std;
int n,m,Sum[1024][1024],a[1024][1024],Cnt[1024];
int read()
{
char c=0;
int sum=0;
while (c<'0'||c>'9')
c=getchar();
while ('0'<=c&&c<='9')
{
sum=sum*10+c-'0';
c=getchar();
}
return sum;
}
int lowbit(int x)
{
return x&(-x);
}
int main()
{
n=read(),m=read();
for (int i=1;i<=(1<<max(n,m))-1;++i)
Cnt[i]=Cnt[i-lowbit(i)]^1;
for (int i=1;i<=(1<<n)-1;++i)
for (int j=1;j<=(1<<m)-1;++j)
Sum[i][j]=Cnt[i&j];
for (int i=1;i<=(1<<n)-1;++i)
for (int j=1;j<=(1<<m)-1;++j)
a[i][j]=Sum[i][j]^Sum[i-1][j]^Sum[i][j-1]^Sum[i-1][j-1];
for (int i=1;i<=(1<<n)-1;++i)
{
for (int j=1;j<=(1<<m)-1;++j)
printf("%d",a[i][j]);
puts("");
}
return 0;
} | 0 |
#include<cstdio>
#include<algorithm>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
int n,a[N],m,v,p; long long sum[N];
inline bool cmp(CI x,CI y)
{
return x>y;
}
int main()
{
RI i; for (scanf("%d%d%d%d",&n,&m,&v,&p),i=1;i<=n;++i) scanf("%d",&a[i]);
for (sort(a+1,a+n+1,cmp),i=1;i<=n;++i) sum[i]=sum[i-1]+a[i];
for (i=p+1;i<=n;++i)
{
int dlt=max(0,v-(p+n-i)); long long tot=sum[i-1]-sum[p-1];
if (a[i]+m<a[p]||1LL*(i-p)*(a[i]+m)+1-tot<=1LL*dlt*m) return printf("%d",i-1),0;
}
return printf("%d",n),0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const double esp = 1e-8;
const int mod = 998244353;
const double pi = acos(-1);
const int inf = 0x3f3f3f3f;
const int maxn = 1e3 + 5;
const int maxm = 1e6 + 5;
int a[maxn], n, k;
int dp[maxn][maxn], tsum[maxn][maxn];
int bound[maxn];
inline int add(int x, int y) {
return (x + y) >= mod ? (x + y - mod) : (x + y);
}
int solve(int x) {
bound[0] = 0;
for (int i = 1; i <= n; i++) {
bound[i] = bound[i - 1];
while (a[i] - a[bound[i] + 1] >= x) bound[i]++;
}
tsum[1][0] = 0;
for (int i = 1; i <= k; i++) {
for (int j = i; j <= n; j++) {
if (i == 1) {
dp[i][j] = 1;
tsum[i][j] = (tsum[i][j - 1] + dp[i][j]);
continue;
}
dp[i][j] = tsum[i - 1][bound[j]];
tsum[i][j] = add(tsum[i][j - 1], dp[i][j]);
}
}
return tsum[k][n];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
int ans = 0;
int maxt = (a[n] - a[1]) / (k - 1);
for (int t = 1; t <= maxt; t++) {
ans = add(ans, solve(t));
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int g[110][110];
int ans[1100];
int main() {
int n;
while (scanf("%d", &n) == 1) {
printf("%d\n", n / 2 * (n - n / 2));
for (int i = 1; i <= n / 2; i++)
for (int j = n / 2 + 1; j <= n; j++) printf("%d %d\n", i, j);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[26];
int main() {
int n;
string str = "", s = "";
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
cin >> s;
str += s;
str += "$";
}
int len = str.size();
char ch, ch1;
memset(a, 0, sizeof(a));
for (int i = 0; i < 26; ++i) {
ch = 'a' + i;
if (str.find(ch) == string::npos) {
cout << ch << endl;
return 0;
}
}
int flag;
for (int i = 0; i < 26; ++i) {
s = "";
ch = 'a' + i;
flag = 0;
for (int j = i; j < 26; ++j) {
flag = 0;
s = "";
ch1 = 'a' + j;
s += ch;
s += ch1;
for (int k = 0; k < len - 1; ++k)
if (str.substr(k, 2) == s) {
flag = 1;
continue;
}
if (!flag) {
cout << s << endl;
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 15;
const int mod = 1e9 + 7;
string s, target;
vector<int> op;
void reverse(int k) {
if (k == 0) {
return;
}
assert(s.size() >= k);
string prefix = s.substr(0, s.size() - k), suffix = s.substr(s.size() - k, k);
reverse(suffix.begin(), suffix.end());
s = suffix + prefix;
op.push_back(k);
}
int num[256];
int findIndex(char c) {
for (int i = 0; i < s.size(); ++i) {
if (s[i] == c) {
return i;
}
}
assert(0);
}
void construct(int len) {
int n = s.size();
int k = findIndex(target[n - len - 1]);
reverse(n - k - 1);
reverse(n - len);
reverse(n);
reverse(1);
if (len + 1 < n) {
int k = -1;
for (int i = len + 1; i < n; ++i) {
if (s[i] == target[n - len - 2]) {
k = i;
}
}
assert(k != -1);
reverse(n - k);
if (k - len - 1 >= 0) reverse(k - len - 1);
}
}
void solve() {
int n;
cin >> n >> s >> target;
for (int i = 0; i < n; ++i) {
++num[s[i]];
--num[target[i]];
}
for (int i = 255; i; --i)
if (num[i] != 0) {
printf("-1\n");
return;
}
int ind = -1;
for (int i = 0; i < n; ++i) {
if (s[i] == target[n - 1]) {
ind = i;
break;
}
}
reverse(n - ind - 1);
assert(s.back() == target.back());
for (int len = 1; len < n; len += 2) {
construct(len);
}
assert(s == target);
printf("%d\n", (int)op.size());
for (int x : op) {
printf("%d\n", x);
}
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
string t;
cin >> s >> t;
int l = s.length();
int i = 0;
int flag = 0;
while (i != l - 1) {
for (int j = 0; j < t.length(); j++) {
if (s[i] == t[j]) i++;
if (j == t.length() - 1) flag = 1;
}
if (flag == 1) break;
}
cout << i + 1;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < int(n); ++i)
#define rrep(i,n) for(int i = int(n)-1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
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);}
using ll = long long;
using P = pair<int,int>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
std::pair<std::vector<int>,std::vector<int>> primes_sieve(const int n) {
std::pair<std::vector<int>,std::vector<int>> rv;
std::vector<int>& primes = rv.first;
std::vector<int>& sieve = rv.second;
primes.reserve(n / 10);
sieve.resize(n + 1, 0);
if (n >= 1) sieve[0] = sieve[1] = -1;
else if (n >= 0) sieve[0] = -1;
if (n <= 4) {
for(int i = 2; i <= n; ++i) {
if (sieve[i] == 0) {
primes.push_back(i);
sieve[i] = i;
}
if (i == 2 && n == 4) sieve[4] = 2;
}
return rv;
}
for(int i = 2; i <= n; i += 2) sieve[i] = 2;
for(int i = 3; i <= n; i += 6) sieve[i] = 3;
primes.push_back(2); primes.push_back(3);
const int n3 = n / 3;
int i = 5;
for(; i <= n3; i += 4) {
if (sieve[i] == 0) {
sieve[i] = i;
primes.push_back(i);
int sz = primes.size();
for(int j = 2;j < sz; ++j) {
int p = primes[j];
int x = i * p;
if (x > n) break;
sieve[x] = p;
}
} else {
int si = sieve[i];
for(int j = 2;; ++j) {
int p = primes[j];
int x = i * p;
if (x > n) break;
sieve[x] = p;
if (p == si) break;
}
}
i += 2;
if (sieve[i] == 0) {
sieve[i] = i;
primes.push_back(i);
int sz = primes.size();
for(int j = 2;j < sz; ++j) {
int p = primes[j];
int x = i * p;
if (x > n) break;
sieve[x] = p;
}
} else {
int si = sieve[i];
for(int j = 2;; ++j) {
int p = primes[j];
int x = i * p;
if (x > n) break;
sieve[x] = p;
if (p == si) break;
}
}
}
const int n2 = n - 2;
for(; i <= n2; i += 4) {
if (sieve[i] == 0) {
sieve[i] = i;
primes.push_back(i);
}
i += 2;
if (sieve[i] == 0) {
sieve[i] = i;
primes.push_back(i);
}
}
if (i <= n) {
if (sieve[i] == 0) {
sieve[i] = i;
primes.push_back(i);
}
}
return rv;
}
auto [Primes, Sieve] = primes_sieve(10000000);
int factorize(int n) {
int res = 1;
while(n > 1) {
int p = Sieve[n];
int cnt = 0;
do {
n /= p;
cnt++;
} while(n % p == 0);
if (cnt & 1) res *= p;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while(tt--) {
int n, k;
cin >> n >> k;
set<int> now;
int ans = 1;
rep(i, n) {
int x;
cin >> x;
x = factorize(x);
if (now.count(x)) {
ans++;
now = {x};
} else {
now.insert(x);
}
}
cout << ans << '\n';
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const long long MOD = 1000000007;
int n, m, a[MAXN], bitl[MAXN], bitr[MAXN];
void add(int x, int val, int *bit) {
for (; x < MAXN; x += -x & x) {
bit[x] += val;
}
}
int qry(int x, int *bit) {
int ret = 0;
for (; x > 0; x -= -x & x) {
ret += bit[x];
}
return ret;
}
int lbd(int x, int *bit) {
int l = 0, r = n + 1;
while (l < r - 1) {
int mid = (l + r) >> 1;
if (qry(mid, bit) >= x) {
r = mid;
} else {
l = mid;
}
}
return r;
}
int ubd(int x, int *bit) { return lbd(x + 1, bit); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
add(i, 1, bitl);
add(i, 1, bitr);
}
for (int i = 1; i <= m; i++) {
;
cin >> a[i];
int l = lbd(a[i] + 1, bitl), r = ubd(a[i] + 1, bitl);
add(1, -1, bitl);
add(l, 1, bitl);
add(r, -1, bitl);
l = lbd(a[i] - 1, bitr), r = ubd(a[i] - 1, bitr);
add(1, 1, bitr);
add(l, -1, bitr);
add(r, 1, bitr);
}
long long ans = 0;
if (n != 1) {
for (int i = 1; i <= n; i++) {
int l = qry(i, bitl), r = qry(i, bitr);
l = max(1, l - 1), r = min(n, r + 1);
;
ans += r - l + 1;
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int n, m;
vector<int> c;
map<int, bool> was[200005];
int x[100005], y[100005];
vector<int> a[200005];
int sz;
vector<pair<int, int> > b[200005];
queue<pair<int, int> > q;
int toall[200005];
bool inter(pair<int, int> a, pair<int, int> b) {
return max(a.first, b.first) <= min(a.second, b.second);
}
int main(void) {
scanf("%d %d", &n, &m);
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
scanf("%d %d", x + i, y + i);
--x[i];
--y[i];
if (x[i] == n - 1 && y[i] == n - 1) {
puts("-1");
exit(0);
}
c.push_back(x[i]);
}
c.push_back(0);
c.push_back(n - 1);
sort((c).begin(), (c).end());
c.erase(unique((c).begin(), (c).end()), c.end());
sz = c.size();
for (int i = 1; i < sz; ++i) {
if (c[i] != c[i - 1] + 1) {
toall[i - 1] = true;
}
}
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
x[i] = lower_bound((c).begin(), (c).end(), x[i]) - c.begin();
a[x[i]].push_back(y[i]);
}
for (long long(i) = 0; (i) < (long long)(sz); (i)++) {
sort((a[i]).begin(), (a[i]).end());
a[i].erase(unique((a[i]).begin(), (a[i]).end()), a[i].end());
if (a[i].empty()) {
b[i].push_back(make_pair(0, n - 1));
continue;
}
for (long long(j) = 0; (j) < (long long)(a[i].size()); (j)++) {
if (!j && a[i][0] != 0) {
b[i].push_back(make_pair(0, a[i][0] - 1));
continue;
}
if (j && a[i][j] - a[i][j - 1] > 1) {
b[i].push_back(make_pair(a[i][j - 1] + 1, a[i][j] - 1));
}
}
if (a[i].back() != n - 1) {
b[i].push_back(make_pair(a[i].back() + 1, n - 1));
}
}
if (b[sz - 1].empty()) {
puts("-1");
exit(0);
}
q.push(make_pair(0, 0));
was[0][0] = true;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
if (x == sz - 1) {
continue;
}
if (toall[x]) {
pair<int, int> now;
now = make_pair(b[x][y].first, n - 1);
for (long long(i) = 0; (i) < (long long)(b[x + 1].size()); (i)++) {
if (inter(now, b[x + 1][i]) && !was[x + 1].count(i)) {
was[x + 1][i] = true;
q.push(make_pair(x + 1, i));
b[x + 1][i].first = max(b[x + 1][i].first, b[x][y].first);
}
}
} else {
for (long long(i) = 0; (i) < (long long)(b[x + 1].size()); (i)++) {
if (inter(b[x][y], b[x + 1][i]) && !was[x + 1].count(i)) {
was[x + 1][i] = true;
q.push(make_pair(x + 1, i));
b[x + 1][i].first = max(b[x + 1][i].first, b[x][y].first);
}
}
}
}
if (b[sz - 1].back().second != n - 1) {
puts("-1");
exit(0);
}
if (was[sz - 1][(int)b[sz - 1].size() - 1]) {
printf("%d\n", n + n - 2);
} else {
puts("-1");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, float> s;
string x, y, z, t;
float p, v;
int k() {
if (s[x] < s[y])
p = s[y] - s[x];
else
p = (6 - s[x] + s[y]);
if (s[y] < s[z])
v = s[z] - s[y];
else
v = (6 - s[y] + s[z]);
if (p == 2 && v == 1.5) {
cout << "major";
return 0;
} else if (p == 1.5 && v == 2) {
cout << "minor";
return 0;
};
if (s[x] < s[z])
p = s[z] - s[x];
else
p = (6 - s[x] + s[z]);
if (s[z] < s[y])
v = s[y] - s[z];
else
v = (6 - s[z] + s[y]);
if (p == 2 && v == 1.5) {
cout << "major";
return 0;
} else if (p == 1.5 && v == 2) {
cout << "minor";
return 0;
};
if (s[y] < s[z])
p = s[z] - s[y];
else
p = (6 - s[y] + s[z]);
if (s[z] < s[x])
v = s[x] - s[z];
else
v = (6 - s[z] + s[x]);
if (p == 2 && v == 1.5) {
cout << "major";
return 0;
} else if (p == 1.5 && v == 2) {
cout << "minor";
return 0;
};
if (s[y] < s[x])
p = s[x] - s[y];
else
p = (6 - s[y] + s[x]);
if (s[x] < s[z])
v = s[z] - s[x];
else
v = (6 - s[x] + s[z]);
if (p == 2 && v == 1.5) {
cout << "major";
return 0;
} else if (p == 1.5 && v == 2) {
cout << "minor";
return 0;
};
if (s[z] < s[y])
p = s[y] - s[z];
else
p = (6 - s[z] + s[y]);
if (s[y] < s[x])
v = s[x] - s[y];
else
v = (6 - s[y] + s[x]);
if (p == 2 && v == 1.5) {
cout << "major";
return 0;
} else if (p == 1.5 && v == 2) {
cout << "minor";
return 0;
};
if (s[z] < s[x])
p = s[x] - s[z];
else
p = (6 - s[z] + s[x]);
if (s[x] < s[y])
v = s[y] - s[x];
else
v = (6 - s[x] + s[y]);
if (p == 2 && v == 1.5) {
cout << "major";
return 0;
} else if (p == 1.5 && v == 2) {
cout << "minor";
return 0;
};
cout << "strange";
}
int main() {
cin >> x >> y >> z;
s["C"] = 0.5;
s["C#"] = 1;
s["D"] = 1.5;
s["D#"] = 2;
s["E"] = 2.5;
s["F"] = 3;
s["F#"] = 3.5;
s["G"] = 4;
s["G#"] = 4.5;
s["A"] = 5;
s["B"] = 5.5;
s["H"] = 6;
k();
return 0;
}
| 1 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
enum Type{
black_USU,
white,
black_ATSU,
};
int main(){
int LIMIT,K;
scanf("%d %d",&LIMIT,&K);
ll dp[LIMIT+1][3];
for(int height = 0; height <= LIMIT; height++){
for(int i = 0; i < 3; i++)dp[height][i] = 0;
}
ll ans = 0;
dp[0][black_USU] = 1;
ans++;
if(K <= LIMIT){
dp[K-1][black_ATSU] = 1;
ans++;
}
for(int height = 1; height < LIMIT; height++){
dp[height][black_USU] = dp[height-1][white];
ans += dp[height][black_USU];
dp[height][white] = dp[height-1][black_USU]+dp[height-1][black_ATSU];
if(height >= K){
dp[height][black_ATSU] = dp[height-K][white];
ans += dp[height][black_ATSU];
}
}
printf("%lld\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef long long ll;
template <typename _T>
inline void read(_T &f) {
f = 0; _T fu = 1; char c = getchar();
while (c < '0' || c > '9') { if (c == '-') { fu = -1; } c = getchar(); }
while (c >= '0' && c <= '9') { f = (f << 3) + (f << 1) + (c & 15); c = getchar(); }
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10) putchar(x + 48);
else print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x); putchar(t);
}
const int N = 2e5 + 5, M = 8e5 + 5;
struct edge_t { int u, v, next, cap, flow; } G[M];
vector <int> adj[N];
queue <int> q;
int head[N], nowhead[N], d[N];
int n, m, s, t, tot = 1;
inline void addedge(int u, int v, int cap) {
G[++tot] = (edge_t) {u, v, head[u], cap, 0}, head[u] = tot;
G[++tot] = (edge_t) {v, u, head[v], 0, 0}, head[v] = tot;
}
int bfs() {
memset(d, 0, sizeof(d));
d[s] = 1; q.push(s);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (!d[v] && G[i].cap > G[i].flow) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[t];
}
int dfs(int u, int Flow) {
if (u == t || !Flow) return Flow;
int f, flow = 0;
for (int &i = nowhead[u]; i; i = G[i].next) {
int v = G[i].v;
if (d[v] == d[u] + 1 && (f = dfs(v, min(Flow, G[i].cap - G[i].flow))) > 0) {
G[i].flow += f; G[i ^ 1].flow -= f;
flow += f; Flow -= f;
if (!Flow) break;
}
}
return flow;
}
int dinic() {
int ans = 0;
while (bfs()) {
memcpy(nowhead, head, sizeof(nowhead));
ans += dfs(s, 0x7fffffff);
}
return ans;
}
int fa[N], vis[N], match[N], cnt;
int main() {
read(n); s = 0; t = 2 * n;
for (int i = 1; i < n; i++) {
read(m);
for (int j = 1; j <= m; j++) {
int x; read(x);
adj[i].push_back(x + n - 1);
adj[x + n - 1].push_back(i);
addedge(i, x + n - 1, 1);
}
}
for (int i = 1; i < n; i++) addedge(s, i, 1);
for (int i = n; i < 2 * n; i++) addedge(i, t, 1);
if (dinic() != n - 1) {
puts("-1");
return 0;
}
int rt = 0;
for (int i = head[n * 2]; i; i = G[i].next) {
if (G[i].flow == 0) {
rt = G[i].v;
break;
}
}
for (int u = 1; u < n; u++) {
for (int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (n <= v && v < n * 2 && G[i].flow) match[u] = v;
}
}
q.push(rt); vis[rt] = 1;
while (!q.empty()) {
int u = q.front(); q.pop();
for (auto v : adj[u]) {
if (!vis[match[v]]) {
vis[match[v]] = 1;
fa[match[v]] = u;
++cnt;
q.push(match[v]);
}
}
}
if (cnt != n - 1) {
puts("-1");
return 0;
}
for (int i = 1; i < n; i++) {
print(match[i] - n + 1, ' ');
print(fa[match[i]] - n + 1, '\n');
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300 * 1000 + 5;
pair<int, int> p0[2 * MAXN];
pair<pair<int, int>, int> p1[MAXN];
int sufmin[MAXN], prefmin[MAXN], s[MAXN];
int main() {
ios_base::sync_with_stdio(false);
int n, w;
cin >> n >> w;
int n0 = 0, n1 = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (b > 2 * a) {
p0[n0] = make_pair(a, i);
n0++;
p0[n0] = make_pair(b - a, i);
n0++;
} else {
p1[n1] = make_pair(make_pair(b, a), i);
n1++;
}
}
sort(p0, p0 + n0);
sort(p1, p1 + n1);
if (n1) sufmin[n1 - 1] = n1 - 1;
for (int i = n1 - 2; i >= 0; i--)
if (p1[i].first.second < p1[sufmin[i + 1]].first.second)
sufmin[i] = i;
else
sufmin[i] = sufmin[i + 1];
if (n1) prefmin[0] = 0;
for (int i = 1; i < n1; i++)
if (p1[i].first.second - p1[i].first.first <
p1[prefmin[i - 1]].first.second - p1[prefmin[i - 1]].first.first)
prefmin[i] = i;
else
prefmin[i] = prefmin[i - 1];
long long ans = 0;
int pos0 = 0, pos1 = 0, d = w;
for (; pos1 < n1 && d > 1; pos1++, d -= 2) ans += p1[pos1].first.first;
if (pos1 < n1 && d) {
ans += min(p1[sufmin[pos1]].first.second,
p1[prefmin[pos1 - 1]].first.second -
p1[prefmin[pos1 - 1]].first.first + p1[pos1].first.first);
d--;
}
for (; pos0 < n0 && d > 0; pos0++, d--) ans += p0[pos0].first;
long long bans = ans;
int pans = pos0;
for (; pos0 < min(n0, w); pos0++) {
if ((w - pos0) & 1)
ans -= min(p1[sufmin[pos1]].first.second,
p1[prefmin[pos1 - 1]].first.second -
p1[prefmin[pos1 - 1]].first.first + p1[pos1].first.first);
else {
pos1--;
ans += min(p1[sufmin[pos1]].first.second,
p1[prefmin[pos1 - 1]].first.second -
p1[prefmin[pos1 - 1]].first.first + p1[pos1].first.first) -
p1[pos1].first.first;
}
ans += p0[pos0].first;
if (ans < bans) {
bans = ans;
pans = pos0 + 1;
}
}
for (int i = 0; i < pans; i++) s[p0[i].second]++;
int pans1 = (w - pans) / 2;
for (int i = 0; i < pans1; i++) s[p1[i].second] = 2;
if ((w - pans) & 1) {
if (!pans1 || p1[sufmin[pans1]].first.second <
p1[prefmin[pans1 - 1]].first.second -
p1[prefmin[pans1 - 1]].first.first +
p1[pans1].first.first)
s[p1[sufmin[pans1]].second] = 1;
else {
s[p1[prefmin[pans1 - 1]].second] = 1;
s[p1[pans1].second] = 2;
}
}
cout << bans << '\n';
for (int i = 0; i < n; i++) cout << s[i];
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int a1, a2, b1, b2, c1, c2;
cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2;
if (a1 == 0 && b1 == 0 && c1 != 0) {
cout << 0 << endl;
return 0;
}
if (a2 == 0 && b2 == 0 && c2 != 0) {
cout << 0 << endl;
return 0;
}
if (a1 == 0 && a2 == 0 && b1 == 0 && b2 == 0) {
if (c1 != c2) {
cout << -1 << endl;
return 0;
}
}
if (a1 * b2 == a2 * b1) {
if (a1 * c2 == a2 * c1)
cout << -1 << endl;
else
cout << 0 << endl;
return 0;
}
cout << 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
mt19937 rng(std::chrono::duration_cast<std::chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
template <typename S, typename T>
void xmin(S &a, T const &b) {
if (b < a) a = b;
}
template <typename S, typename T>
void xmax(S &a, T const &b) {
if (b > a) a = b;
}
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
signed gen(int T) {
ofstream o("gen.txt");
o << T << "\n";
for (int cas = 0; cas < T; ++cas) {
o << "\n";
}
o << endl;
o.close();
return 0;
}
class Fraction {
long long num, denom;
void simplify() {
long long g = gcd(num, denom);
num /= g;
denom /= g;
if (denom < 0) {
num *= -1;
denom *= -1;
}
}
public:
Fraction() {
num = 0;
denom = 1;
}
Fraction(long long a, long long b) {
if (b == 0) {
num = 1;
denom = 0;
} else {
num = a;
denom = b;
simplify();
}
}
Fraction(long long x) {
num = x;
denom = 1;
}
Fraction(pair<long long, long long> x) {
num = x.first;
denom = x.second;
simplify();
}
Fraction(const Fraction &b) {
num = b.num;
denom = b.denom;
}
void operator=(long long x) {
num = x;
denom = 1;
}
void operator=(pair<long long, long long> x) {
num = x.first;
denom = x.second;
simplify();
}
void operator=(Fraction b) {
num = b.num;
denom = b.denom;
}
Fraction operator-() { return Fraction(-num, denom); }
Fraction operator+(Fraction b) {
Fraction res;
res.denom = abs((((denom) / gcd((denom), (b.denom))) * (b.denom)));
res.num = (res.denom / denom) * num + (res.denom / b.denom) * b.num;
res.simplify();
return res;
}
Fraction operator-(Fraction b) { return (*this) + (-b); }
Fraction operator*(Fraction b) {
Fraction res(b.num / gcd(b.num, denom), b.denom / gcd(b.denom, num));
res.num *= num / gcd(num, b.denom);
res.denom *= denom / gcd(denom, b.num);
res.simplify();
return res;
}
Fraction operator/(Fraction b) {
Fraction rev(b.denom, b.num);
if (rev.denom < 0) {
rev.denom *= -1;
rev.num *= -1;
}
return (*this) * rev;
}
void operator+=(Fraction b) { *this = *this + b; }
void operator-=(Fraction b) { *this = *this - b; }
void operator*=(Fraction b) { *this = *this * b; }
void operator/=(Fraction b) { *this = *this / b; }
bool operator==(Fraction b) {
if (num == b.num && denom == b.denom)
return true;
else
return false;
}
bool operator<(Fraction b) const {
if (num * b.denom < b.num * denom)
return true;
else
return false;
}
bool operator>(Fraction b) { return (b < *this); }
bool operator<=(Fraction b) {
if (*this == b || *this < b)
return true;
else
return false;
}
bool operator>=(Fraction b) { return (b <= *this); }
Fraction getAbs() { return Fraction(abs(num), denom); }
};
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> X(n), Y(n);
for (long long i = (0); i <= (n - 1); ++i) {
cin >> X[i] >> Y[i];
}
map<Fraction, set<Fraction>> lines;
for (long long i = (0); i <= (n - 1); ++i) {
for (long long j = (i + 1); j <= (n - 1); ++j) {
int x1 = X[i], y1 = Y[i], x2 = X[j], y2 = Y[j];
int dx = x2 - x1, dy = y2 - y1;
Fraction A(dy, dx), B;
if (dx == 0) {
B = x1;
} else {
B = A * (-x1) + y1;
}
lines[A].insert(B);
}
}
int all = 0;
for (auto &it : lines) {
all += ((long long)(it.second).size());
}
long long res = 0;
for (auto &it : lines) {
int sz = ((long long)(it.second).size());
res += sz * (all - sz);
}
res /= 2;
cout << res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int v;
int l, r;
node(int vv = 0, int ll = 0, int rr = 0) : v(vv), l(ll), r(rr) {}
};
node a[100005];
int root, n;
bool vis[100005];
struct Res {
bool vis;
int cnt;
Res() {
vis = false;
cnt = 0;
}
};
map<int, Res> mp;
void dfs(int l, int r, int pos) {
if (pos == -1) return;
if (a[pos].v >= l && a[pos].v <= r) mp[a[pos].v].vis = true;
dfs(l, min(r, a[pos].v), a[pos].l);
dfs(max(l, a[pos].v), r, a[pos].r);
}
int main() {
while (scanf("%d", &n) == 1) {
memset(vis, 0, sizeof(vis));
mp.clear();
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].v, &a[i].l, &a[i].r);
vis[a[i].l] = true;
vis[a[i].r] = true;
mp[a[i].v].vis = false;
mp[a[i].v].cnt++;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
root = i;
break;
}
}
dfs(-1, 1000000005, root);
int ans = 0;
for (map<int, Res>::iterator it = mp.begin(); it != mp.end(); it++)
if (!(((*it).second).vis)) ans += ((*it).second.cnt);
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
#define range(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ar array
using namespace std;
typedef long long ll;
typedef double ld;
typedef unsigned long long ull;
const ll INF = 2e18;
const int INFi = 2e9 + 5;
const int maxN = 1500 + 1;
const int md = 998244353;
inline int add(const int &a, const int &b) {
return a + b >= md ? a + b - md : a + b;
}
inline int sub(const int &a, const int &b) {
return a - b < 0 ? a - b + md : a - b;
}
inline int mul(const int &a, const int &b) {
return (1ll * a * b) % md;
}
int binpow(int a, int b) {
if (b <= 0) return 1;
if (b % 2) return mul(a, binpow(a, b - 1));
int m = binpow(a, b / 2);
return mul(m, m);
}
int rev(int a) {
return binpow(a, md - 2);
}
const int maxF = 2e5 + 5;
int fact[maxF];
int rfact[maxF];
void init() {
fact[0] = 1;
for (int i = 1; i < maxF; ++i) fact[i] = mul(fact[i - 1], i);
rfact[maxF - 1] = rev(fact[maxF - 1]);
for (int i = maxF - 1; i >= 1; --i) {
rfact[i - 1] = mul(rfact[i], i);
}
}
int C(int n, int k) {
if (k < 0 || n < k) return 0;
return mul(fact[n], mul(rfact[k], rfact[n - k]));
}
int T(int n, int k) {
return C(n + k - 1, k - 1);
}
vector<int> g[maxN];
int col[maxN];
int cnt[3];
void dfs(int v, int c) {
col[v] = c;
cnt[c]++;
for (auto &u : g[v]) {
if (col[u] == 0) {
dfs(u, c ^ 3);
}
if ((col[v] ^ col[u]) != 3) {
assert(0);
}
}
}
void solve() {
int n;
cin >> n;
vector<vector<int>> a(n * 2, vector<int>(n));
range(i, n * 2) range(j, n) cin >> a[i][j];
range(i, n * 2) range(j, n) a[i][j]--;
vector<vector<set<int>>> to(n, vector<set<int>>(n));
vector<vector<bool>> used(n, vector<bool>(n));
vector<int> c(n * 2, 0);
// 0 - neutral
// 1 - always good
// -1 - always bad
range(i, n * 2) {
range(j, n) {
to[j][a[i][j]].insert(i);
}
}
queue<pair<int, int>> q;
bool bad = false;
int cntGood = 0;
int cntBad = 0;
auto DoGood = [&](int i) {
c[i] = 1;
cntGood++;
range(j, n) {
to[j][a[i][j]].erase(i);
if (used[j][a[i][j]]) bad = true;
used[j][a[i][j]] = true;
q.push({j, a[i][j]});
}
};
auto DoBad = [&](int i) {
c[i] = -1;
cntBad++;
range(j, n) {
to[j][a[i][j]].erase(i);
if (!used[j][a[i][j]] && to[j][a[i][j]].size() == 1) {
q.push({j, a[i][j]});
}
}
};
range(s, n) {
range(v, n) {
q.push({s, v});
}
}
while (!q.empty()) {
auto[s, v] = q.front();
q.pop();
if (used[s][v]) {
while (!to[s][v].empty()) {
int x = *to[s][v].begin();
DoBad(x);
}
} else if (to[s][v].size() == 1) {
int x = *to[s][v].begin();
DoGood(x);
}
}
int cntEdges2 = 0;
range(i, n * 2) {
g[i].clear();
col[i] = 0;
}
range(j, n) {
range(v, n) {
if (used[j][v]) continue;
assert(to[j][v].size() == 2);
if (to[j][v].size() > 2) continue;
int x = *to[j][v].begin();
int y = *to[j][v].rbegin();
cntEdges2++;
g[x].push_back(y);
g[y].push_back(x);
}
}
int ans = 1;
range(i, n * 2) {
if (col[i] || c[i] != 0) continue;
cnt[1] = cnt[2] = 0;
dfs(i, 1);
//cout << cnt[1] << ' ' << cnt[2] << '\n';
ans = mul(ans, 2);
}
assert(!bad);
// cout << n << ' ' << cntGood << ' ' << cntBad << ' ' << cntEdges2 << '\n';
cout << ans << '\n';
range(i, n * 2) {
if (col[i] == 1 || c[i] == 1) cout << i + 1 << ' ';
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
init();
// cout << setprecision(15) << fixed;
int tests = 1;
cin >> tests;
range(_, tests) {
solve();
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long x, y, z;
};
long long n, i, k, sum, res;
long long l[2000100], h[2000100], lazy[2000100];
data m, a[500100], it[2000100];
bool cmp(data a, data b) { return a.z > b.z; }
void build(int t, int x, int y) {
l[t] = x;
h[t] = y;
if (x == y) return;
build(t * 2, x, (x + y) / 2);
build(t * 2 + 1, (x + y) / 2 + 1, y);
}
void add(int t, int y, int s) {
if (l[t] < h[t] && lazy[t] > 0) {
it[t * 2].x = (h[t * 2] - l[t * 2] + 1) * lazy[t];
it[t * 2 + 1].x = (h[t * 2 + 1] - l[t * 2 + 1] + 1) * lazy[t];
it[t * 2].y = it[t * 2].z = lazy[t];
it[t * 2 + 1].y = it[t * 2 + 1].z = lazy[t];
lazy[t * 2] = lazy[t * 2 + 1] = lazy[t];
lazy[t] = 0;
}
if (y < l[t] || it[t].z >= s) return;
if (h[t] <= y && it[t].y <= s) {
sum += (h[t] - l[t] + 1) * s - it[t].x;
it[t].x = (h[t] - l[t] + 1) * s;
it[t].y = it[t].z = s;
lazy[t] = s;
return;
}
if (l[t] == h[t]) return;
add(t * 2, y, s);
add(t * 2 + 1, y, s);
it[t].x = it[t * 2].x + it[t * 2 + 1].x;
it[t].y = max(it[t * 2].y, it[t * 2 + 1].y);
it[t].z = min(it[t * 2].z, it[t * 2 + 1].z);
}
int main() {
scanf("%lld %lld %lld %lld", &n, &m.x, &m.y, &m.z);
build(1, 1, m.x);
for (i = 1; i <= n; i++) {
scanf("%lld %lld %lld", &a[i].x, &a[i].y, &a[i].z);
add(1, a[i].x, a[i].y);
}
sort(a + 1, a + 1 + n, cmp);
k = 1;
for (i = m.z; i >= 1; i--) {
while (a[k].z == i && k <= n) {
add(1, a[k].x, m.y);
add(1, m.x, a[k].y);
k++;
}
res = res + (m.x * m.y - sum);
}
printf("%lld", res);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e2 + 7;
int x[MAXN], y[MAXN], z[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
x[1] = x[4] = x[7] = x[8] = x[11] = x[14] = 1;
y[2] = y[6] = y[9] = y[13] = 1;
z[3] = z[5] = z[10] = z[12] = 1;
long long a, b, c;
cin >> a >> b >> c;
long long mn = min(a / 3, min(b / 2, c / 2));
a = a - mn * 3;
b = b - mn * 2;
c = c - mn * 2;
long long mx = 0;
for (int i = (int)1; i <= (int)7; i++) {
long long tm = 0;
long long ta = a, tb = b, tc = c;
for (int j = (int)i; j <= (int)i + 6; j++) {
if (ta < 0 || tb < 0 || tc < 0) break;
tm++;
ta -= x[j];
tb -= y[j];
tc -= z[j];
}
mx = max(mx, tm - 1);
}
cout << mx + mn * 7 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
cout << (1 << __builtin_popcount(a)) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, lazy[100011 << 2];
long long st[100011 << 2][48], A[100011];
void build(int v, int l, int r) {
if (l == r) {
st[v][0] = A[l] % 95542721;
for (int k = 1; k < 48; ++k) {
st[v][k] = (st[v][k - 1] * st[v][k - 1]) % 95542721;
st[v][k] = (st[v][k] * st[v][k - 1]) % 95542721;
}
} else {
int nl = v << 1, nr = nl | 1, mid = (l + r) >> 1;
build(nl, l, mid);
build(nr, mid + 1, r);
for (int k = 0; k < 48; ++k) st[v][k] = (st[nl][k] + st[nr][k]) % 95542721;
}
}
void push(int v, int nl, int nr) {
lazy[nl] = (lazy[nl] + lazy[v]) % 48;
lazy[nr] = (lazy[nr] + lazy[v]) % 48;
rotate(st[nl], st[nl] + lazy[v], st[nl] + 48);
rotate(st[nr], st[nr] + lazy[v], st[nr] + 48);
lazy[v] = 0;
}
long long query(int v, int l, int r, int i, int j) {
if (l > j || r < i) return 0;
if (l >= i && r <= j)
return st[v][0];
else {
int nl = v << 1, nr = nl | 1, mid = (l + r) >> 1;
push(v, nl, nr);
return (query(nl, l, mid, i, j) + query(nr, mid + 1, r, i, j)) % 95542721;
}
}
long long query(int i, int j) { return query(1, 1, n, i, j); }
void update(int v, int l, int r, int i, int j) {
if (l > j || r < i) return;
if (l >= i && r <= j) {
rotate(st[v], st[v] + 1, st[v] + 48);
lazy[v] = (lazy[v] + 1) % 48;
} else {
int nl = v << 1, nr = nl | 1, mid = (l + r) >> 1;
push(v, nl, nr);
update(nl, l, mid, i, j);
update(nr, mid + 1, r, i, j);
for (int k = 0; k < 48; ++k) st[v][k] = (st[nl][k] + st[nr][k]) % 95542721;
}
}
void update(int i, int j) { update(1, 1, n, i, j); }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> A[i];
build(1, 1, n);
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int t, l, r;
cin >> t >> l >> r;
if (t == 1)
cout << query(l, r) << endl;
else
update(l, r);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int oo = 1e18;
const int N = 3000 + 10;
int n;
long long int dp[N];
pair<long long int, long long int> a[N];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n + 1);
fill(dp + 1, dp + n + 1, oo);
for (int i = 1; i <= n; i++) {
long long int t = a[i].second;
for (long long int j = i; j <= n; j++) {
t += a[j].first - a[i].first;
dp[j] = min(dp[j], dp[i - 1] + t);
}
}
cout << dp[n] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long double pie = 3.1415926535;
using namespace std;
long long fpow(long long n, long long p) {
long long m = 1;
while (p) {
if (p % 2) m *= n;
p >>= 1;
n *= n;
}
return m;
}
long long mfpow(long long n, long long p, long long M) {
long long m = 1;
n %= M;
while (p) {
if (p % 2) m = (m * n) % M;
n = (n * n) % M;
p >>= 1;
}
return m % M;
}
const vector<long long> days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool br1, br2, br;
char ch, ch1, ch2;
long long n, k, x, y, z, mini, maxi, l, ind, ini, sum, t, len, r, w, imini, m;
string s, s1, s2;
bool isLeap(long long x) {
if (x % 400 == 0 || (x % 4 == 0 && x % 100 != 0)) return true;
return false;
}
void solve() {
cin >> x;
if (isLeap(x)) br = 1;
y = 0;
while (true) {
if (isLeap(++x))
y = 366;
else
y = 365;
z = (z + y) % 7;
if (z == 0 && br == isLeap(x)) {
cout << x << endl;
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1.5e5 + 6.66;
const int inf = 1e9 + 7;
int seg[MAXN * 4], laz[MAXN * 4];
int a[MAXN], b[MAXN];
int n, m, h;
void shift(int id, int val) {
seg[id] += val;
laz[id] += val;
}
void shift(int id) {
shift(id << 1, laz[id]);
shift(id << 1 | 1, laz[id]);
laz[id] = 0;
}
void build(int id, int l, int r) {
if (l >= r) return;
if (r - l == 1) {
seg[id] = -l - 1;
return;
}
int mid = l + (r - l) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid, r);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
}
void alter(int id, int l, int r, int b, int e, int val) {
if (l >= r) return;
if (l >= e || r <= b) return;
if (l >= b && r <= e) {
seg[id] += val;
laz[id] += val;
return;
}
shift(id);
int mid = (l + r) >> 1;
alter(id << 1, l, mid, b, e, val);
alter(id << 1 | 1, mid, r, b, e, val);
seg[id] = min(seg[id << 1], seg[id << 1 | 1]);
}
int get(int id, int l, int r, int b, int e) {
if (l >= r) return inf;
if (l >= e || r <= b) return inf;
if (l >= b && r <= e) return seg[id];
shift(id);
int mid = (l + r) >> 1;
return min(get(id << 1, l, mid, b, e), get(id << 1 | 1, mid, r, b, e));
}
void rem(int val) {
int f = h - a[val];
int pos = lower_bound(b, b + m, f) - b;
if (pos < m) alter(1, 0, m, pos, m, -1);
}
void add(int val) {
int f = h - a[val];
int pos = lower_bound(b, b + m, f) - b;
if (pos < m) alter(1, 0, m, pos, m, 1);
}
int get_min() { return get(1, 0, m, 0, m); }
int main() {
cin >> n >> m >> h;
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < n; i++) cin >> a[i];
sort(b, b + m);
build(1, 0, m);
int ans = 0;
for (int i = 0; i < n; i++) {
if (i >= m) rem(i - m);
add(i);
if (get_min() >= 0) ans++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
int M = N;
int sum=0;
while(M){
sum += M%10;
M /= 10;
}
cout << (N%sum==0 ? "Yes" : "No") << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
a %= m;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
long long n;
cin >> n;
vector<long long> arr(n);
vector<long long> freq(105);
for (auto &a : arr) {
cin >> a;
freq[a]++;
}
vector<long long> temp = freq;
sort(temp.begin(), temp.end());
if (temp[104] == temp[103]) {
cout << n << "\n";
return 0;
}
long long mx = max_element(freq.begin(), freq.end()) - freq.begin();
long long ans = 0;
vector<long long> cache(4e5 + 5, -10);
for (long long elem = 1; elem <= 100; elem++) {
if (elem != mx) {
cache[0 + (2e5 + 2)] = -1;
vector<long long> okays;
okays.push_back(0 + (2e5 + 2));
long long run = 0;
for (long long i = 0; i < n; i++) {
if (arr[i] == mx) {
run++;
}
if (arr[i] == elem) {
run--;
}
if (cache[run + (2e5 + 2)] != -10) {
ans = max(ans, i - cache[run + (2e5 + 2)]);
} else {
cache[run + (2e5 + 2)] = i;
okays.push_back(run + (2e5 + 2));
}
}
for (auto x : okays) {
cache[x] = -10;
}
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long A,B,K;
cin >> A >> B >> K;
cout << max(0LL,A-K);
K=max(K-A,0LL);
cout << " " << max(0LL,B-K) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
vector<int> vv, v[500005];
int mata[500005], vis[500005];
int ans[500005];
int arr[500005];
void CLEAR(int n) {
for (int i = 0; i < n + 5; i++) {
v[i].clear();
mata[i] = i;
vis[i] = 0;
ans[i] = 0;
}
vv.clear();
}
void dfs(int s) {
if (s == -1 || vis[s]) return;
vis[s] = 1;
for (int i = 0; i < v[s].size(); i++) {
dfs(v[s][i]);
}
vv.push_back(s);
}
bool check(int n) {
stack<pair<int, int> > st;
for (int i = n; i >= 1; i--) {
while (!st.empty() && st.top().first < ans[i]) st.pop();
if (st.empty()) {
if (arr[i] != n + 1 && arr[i] != -1) return false;
} else {
if (arr[i] != st.top().second && arr[i] != -1) return false;
}
st.push({ans[i], i});
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
CLEAR(n);
vector<int> indx;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
arr[i] = a;
if (a == -1) {
indx.push_back(i);
continue;
}
v[i].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
int cs = n;
for (int i = 0; i < vv.size(); i++) {
if (vv[i] == n + 1) continue;
ans[vv[i]] = cs--;
}
for (int i = 0; i < indx.size(); i++)
if (ans[indx[i]] == 0) ans[indx[i]] = cs--;
if (!check(n))
cout << -1 << endl;
else {
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int num[1000010];
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int i = 2; i <= 1000000; i++) {
if (num[i] == 0) {
for (int j = i; j <= 1000000; j += i) {
if (num[j] == 0) num[j] = i;
}
}
}
while (t--) {
long long n, k;
cin >> n >> k;
if (n % 2 == 1) {
if (num[n] == 1)
n = n + 2 * k;
else {
n = n + num[n];
n = n + 2 * (k - 1);
}
} else
n = n + 2 * k;
cout << n << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ '0'), c = getchar();
return x * f;
}
const int N = 1e6 + 5;
struct node {
int l, r, id, bl;
} q[N];
inline int cmp(node x, node y) {
return x.bl == y.bl ? x.r < y.r : x.bl < y.bl;
}
int a[N], cnt[N], ans[N], n, m, sum;
inline void add(int x) {
if (x > n) return;
sum -= (cnt[x] == x);
++cnt[x];
sum += (cnt[x] == x);
}
inline void del(int x) {
if (x > n) return;
sum -= (cnt[x] == x);
--cnt[x];
sum += (cnt[x] == x);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read();
const int B = sqrt(n);
for (int i = 1; i <= m; i++) {
q[i].l = read(), q[i].r = read();
q[i].bl = (q[i].l - 1) / B + 1;
q[i].id = i;
}
sort(q + 1, q + m + 1, cmp);
int l = 1, r = 0;
for (int i = 1; i <= m; i++) {
int x = q[i].l, y = q[i].r, id = q[i].id;
while (r < y) add(a[++r]);
while (r > y) del(a[r--]);
while (l < x) del(a[l++]);
while (l > x) add(a[--l]);
ans[id] = sum;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(),v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(n) (1LL<<(n))
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) { cout << #v << "=" << endl; REP(i_debug, v.size()){ cout << v[i_debug] << ","; } cout << endl; }
#define mdebug(m) { cout << #m << "=" << endl; REP(i_debug, m.size()){ REP(j_debug, m[i_debug].size()){ cout << m[i_debug][j_debug] << ","; } cout << endl;} }
#define pb push_back
#define fi first
#define se second
#define int long long
#define INF 1000000000000000000
template<typename T> istream &operator>>(istream &is, vector<T> &v){ for (auto &x : v) is >> x; return is; }
template<typename T> ostream &operator<<(ostream &os, vector<T> &v){ for(int i = 0; i < v.size(); i++) { cout << v[i]; if(i != v.size() - 1) cout << endl; }; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p){ cout << '(' << p.first << ',' << p.second << ')'; return os; }
template<typename T> void Out(T x) { cout << x << endl; }
template<typename T1, typename T2> void chOut(bool f, T1 y, T2 n) { if(f) Out(y); else Out(n); }
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PPi = pair<Pii, int>;
using v_bool = vector<bool>;
using v_Pii = vector<Pii>;
using v_PPi = vector<PPi>;
//int dx[4] = {1,0,-1,0};
//int dy[4] = {0,1,0,-1};
//char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
//const int mod = 998244353;
signed main(){
int N; cin >> N;
vec A(3 * N); cin >> A;
REP(i, 3 * N) A[i]--;
mat dp(N, vec(N, -INF));
vec dpMAX(N, -INF);
int offset = 0;
dp[A[0]][A[1]] = dp[A[1]][A[0]] = 0;
dpMAX[A[0]] = 0;
dpMAX[A[1]] = 0;
int allMAX = 0;
REP(i, N - 1){
vec v({A[3 * i + 2], A[3 * i + 3], A[3 * i + 4]});
Sort(v);
v_PPi ls;
if(v[0] == v[2]){
offset++;
continue;
}else if(v[0] == v[1]){
REP(k, N){
ls.pb(PPi(Pii(k, v[2]), dp[k][v[0]] + 1));
}
}else if(v[1] == v[2]){
REP(k, N){
ls.pb(PPi(Pii(k, v[0]), dp[k][v[1]] + 1));
}
}
REP(k, 3){
ls.pb(PPi(Pii(v[(k + 1) % 3], v[(k + 2) % 3]), dp[v[k]][v[k]] + 1));
REP(l, N) ls.pb(PPi(Pii(l, v[k]), dpMAX[l]));
ls.pb(PPi(Pii(v[(k + 1) % 3], v[(k + 2) % 3]), allMAX));
}
for(PPi q: ls){
chmax(dp[q.fi.fi][q.fi.se], q.se);
chmax(dp[q.fi.se][q.fi.fi], q.se);
chmax(dpMAX[q.fi.fi], q.se);
chmax(dpMAX[q.fi.se], q.se);
chmax(allMAX, q.se);
}
}
int ans = 0;
REP(i, N) REP(j, N) chmax(ans, dp[i][j] + (i == A[3 * N - 1] && j == A[3 * N - 1]));
ans += offset;
Out(ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int MOD = 1000000007;
char s[MAXN * 2], e[MAXN];
long long dp[2][2];
int main() {
int k;
cin >> s >> e >> k;
int len = strlen(s);
if (strlen(e) != len) {
cout << 0 << endl;
return 0;
}
int pnt = 0;
for (int i = 0; i < len; i++) {
s[i + len] = s[i];
if (!strncmp(s + i, e, len)) {
pnt++;
}
}
dp[0][strncmp(s, e, len) != 0] = 1;
for (int i = 1; i <= k; i++) {
dp[i % 2][0] =
(dp[(i - 1) % 2][1] * pnt + dp[(i - 1) % 2][0] * (pnt - 1)) % MOD;
dp[i % 2][1] = (dp[(i - 1) % 2][1] * (len - pnt - 1) +
dp[(i - 1) % 2][0] * (len - pnt)) %
MOD;
}
cout << dp[k % 2][0] << endl;
}
| 2 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int n, i, j, k;
cin >> n;
int arr[n];
int ans[2*n];
for (i = 0; i < n; ++i)
{
cin >> arr[i];
}
sort(arr, arr+n);
int ii = 0;
i = n-1;
j = 0;
while ((i > 0) && (arr[i-1] > 0))
{
//cout << arr[j] << " " << arr[i] << '\n';
ans[ii++] = arr[j];
ans[ii++] = arr[i];
arr[j] = arr[j] - arr[i];
--i;
}
while (j < i)
{
//cout << arr[i] << " " << arr[j] << '\n';
ans[ii++] = arr[i];
ans[ii++] = arr[j];
arr[i] = arr[i] - arr[j];
++j;
}
cout << arr[i] << endl;
for(i = 0; i < ii; i+=2)
{
cout << ans[i] << " " << ans[i+1] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200000];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
bool dec = false;
int len = 1;
for (int i = n - 2; i >= 0; --i) {
if (a[i] >= a[i + 1] && dec == false) {
len++;
} else if (a[i] > a[i + 1] && dec == true) {
break;
} else if (a[i] <= a[i + 1] && dec == true) {
len++;
} else if (a[i] < a[i + 1] && dec == false) {
len++;
dec = true;
}
}
cout << n - len << "\n";
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cases;
scanf("%d", &cases);
while (cases--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) cout << i << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long vec[1005];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
long long lul[1005];
for (int i = 0; i < n; i++) {
if (i == 0)
lul[i] = vec[i];
else
lul[i] = vec[i] - vec[i - 1];
}
long long res[10005];
int cnt = 0;
for (int i = 1; i <= n; i++) {
int lol = 0;
int curr = 0;
for (int j = 0; j < n; j++) {
int rem = j % i;
int val = curr + lul[rem];
if (val != vec[j]) {
lol = 1;
break;
}
curr = val;
}
if (lol == 0) res[cnt++] = i;
}
cout << cnt << endl;
for (int i = 0; i < cnt; i++) {
cout << res[i] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
static bool odd(int i) { return i % 2; }
int main() {
int count[26] = {};
string S;
cin >> S;
for (char ch : S) ++count[ch - 'a'];
const int L = S.size();
const int len_odd = odd(L);
int num_odd = 0;
for (int i = int(0); i < int(26); ++i) num_odd += odd(count[i]);
int begin = 0, end = 26;
while (num_odd > len_odd) {
while (!odd(count[begin])) ++begin;
do --end;
while (!odd(count[end]));
assert(begin < end);
++count[begin];
--count[end];
num_odd -= 2;
}
assert(num_odd == len_odd);
int j = 0;
for (int i = 0; i < L / 2; ++i) {
while (count[j] < 2) ++j;
assert(j < 26);
S[i] = S[L - 1 - i] = char('a' + j);
count[j] -= 2;
}
if (len_odd) {
for (int j = int(0); j < int(26); ++j)
if (count[j] > 0) {
assert(count[j] == 1);
S[L / 2] = char('a' + j);
break;
}
}
cout << S << endl;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, m, s, f, t = 0, l, r, now, pass;
char pr;
scanf("%d %d %d %d", &n, &m, &s, &f);
now = s;
if (f - s > 0) {
pr = 'R';
pass = 1;
} else {
pr = 'L';
pass = -1;
}
for (int i = 1; 1; i++) {
if (i > t) {
scanf(" %d %d %d", &t, &l, &r);
m--;
}
if (i == t) {
if ((l <= now && now <= r) || (l <= now + pass && now + pass <= r)) {
printf("X");
} else {
printf("%c", pr);
now += pass;
}
} else {
printf("%c", pr);
now += pass;
}
if (now == f) {
printf("\n");
break;
}
}
while (m-- > 0) scanf(" %d %d %d", &t, &l, &r);
return 0;
}
| 2 |
# include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
if(s[0] == s[1] || s[1] == s[2] || s[2] == s[3]){
cout << "Bad\n";
}else{
cout << "Good\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 123;
const long long INF = (long long)1e18 + 123;
const int inf = (int)1e9 + 123;
const double eps = 1e-6;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
long long n, a[200111], mini = INF, ans;
pair<long long, long long> p[200111], s[200111];
int main() {
boost();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mini = min(mini, a[i]);
}
for (int i = 1; i <= n; i++) {
p[i] = make_pair(a[i], i);
if (i > 1 && p[i - 1].first <= p[i].first) p[i] = p[i - 1];
}
for (int i = n; i >= 1; i--) {
s[i] = make_pair(a[i], i);
if (i < n && s[i + 1].first < s[i].first) s[i] = s[i + 1];
}
for (int i = 1; i <= n; i++) {
if (s[i].first == mini) {
ans = max(ans, (mini * n) + (s[i].second - i));
} else {
ans = max(ans, (mini * n) + n - i + p[i].second);
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool is_suffix(string a, string b) {
if (a.length() > b.length()) return false;
bool ok = true;
int it = 0;
for (int i = b.length() - a.length(); i < b.length(); i++) {
if (b[i] != a[it]) ok = false;
it++;
}
return ok;
}
vector<string> f(vector<string> V) {
map<string, int> mp;
for (int i = 0; i < V.size(); i++) {
string s = V[i];
mp[s] = 1;
}
int len = mp.size();
map<string, int>::iterator it;
string arr[len];
bool ok[len];
memset(ok, true, sizeof ok);
int z = 0;
for (it = mp.begin(); it != mp.end(); it++) {
string t = it->first;
arr[z++] = t;
}
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++) {
if (i == j) continue;
if (is_suffix(arr[i], arr[j])) {
ok[i] = false;
break;
}
}
}
vector<string> ans;
for (int i = 0; i < len; i++) {
if (ok[i]) ans.push_back(arr[i]);
}
return ans;
}
int main() {
map<string, vector<string> > mp;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string str;
cin >> str;
vector<string> V = mp[str];
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
string s;
cin >> s;
V.push_back(s);
}
mp[str] = V;
}
cout << mp.size() << endl;
map<string, vector<string> >::iterator it;
for (it = mp.begin(); it != mp.end(); it++) {
string name = it->first;
vector<string> rec = it->second;
vector<string> ans = f(rec);
cout << name << " " << ans.size() << " ";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
}
| 3 |
#include <iostream>
#include <string>
#include <string.h>
using namespace std;
char s[220];
int main(){
cin>>s;
int n=strlen(s);
for(int i=n-2;i;i-=2){
if(strncmp(s,s+i/2,i/2)==0){
cout<<i<<endl;
return 0;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
long long a[n];
long long res = 0;
priority_queue<pair<long long, pair<int, int>>> pq;
for (int i = 0; i < n; i++) {
cin >> a[i];
res += a[i] * a[i];
if (a[i] > 1) {
long long x = a[i] / 2;
long long y = x + (a[i] & 1);
long long diff = a[i] * a[i] - y * y - x * x;
pq.push({diff, {i, 2}});
}
}
int cnt = n;
while (cnt < k) {
int id = pq.top().second.first;
int div = pq.top().second.second + 1;
res -= pq.top().first;
pq.pop();
cnt++;
if (div > a[id]) continue;
long long xp, yp, rp, xq, yq, rq, p, q;
xp = a[id] / div;
yp = xp + 1;
rp = a[id] % div;
p = (div - rp) * xp * xp + rp * yp * yp;
xq = a[id] / (div - 1);
yq = xq + 1;
rq = a[id] % (div - 1);
q = (div - 1 - rq) * xq * xq + rq * yq * yq;
pq.push({q - p, {id, div}});
}
cout << res << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int n, k;
struct node {
int id, a, b;
node(int i = 0, int _a = 0, int _b = 0) { id = i, a = _a, b = _b; }
bool operator<(const node& a) const { return b < a.b; }
} p[N];
long long dp[N][N];
int pre[N][N];
int main() {
int TTT;
cin >> TTT;
while (TTT--) {
cin >> n >> k;
long long ans = 0;
for (int i = (1); i < (n + 1); i++) {
cin >> p[i].a >> p[i].b;
p[i].id = i;
}
sort(p + 1, p + n + 1);
memset(dp, 0, sizeof(dp));
for (int i = (1); i < (n + 1); i++) {
dp[i][0] = dp[i - 1][0] + (long long)(k - 1) * p[i].b;
for (int j = (1); j < (i + 1); j++) {
long long x = dp[i - 1][j - 1] + (j - 1) * p[i].b + p[i].a;
long long y = 0;
if (i - 1 >= j) y = dp[i - 1][j] + (k - 1) * p[i].b;
dp[i][j] = max(x, y);
if (x > y)
pre[i][j] = j - 1;
else
pre[i][j] = j;
}
}
int u = k;
vector<int> p1, p2;
for (int i = n; i >= 1; --i) {
if (pre[i][u] == u) {
p2.push_back(p[i].id);
} else
u--, p1.push_back(p[i].id);
}
reverse(p1.begin(), p1.end());
reverse(p2.begin(), p2.end());
cout << (int)p1.size() + 2 * (int)p2.size() << "\n";
for (int i = (0); i < (k - 1); i++) cout << p1[i] << " ";
for (auto it : p2) cout << it << " " << -it << " ";
cout << p1[k - 1] << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ", ";
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? ", " : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int k;
vector<pair<int, int>> prime_factorize(int a) {
vector<pair<int, int>> ret;
if (a == 1) return ret;
for (int p = 2; p * p <= a; p++) {
int i = 0;
if (a % p == 0) {
while (a % p == 0) {
a = a / p;
i++;
}
if (i % k != 0) ret.push_back(make_pair(p, i));
}
}
if (a > 1) {
ret.push_back(make_pair(a, 1));
}
for (auto &t : ret) {
int l = t.second;
l = (l % k + k) % k;
t.second = l;
}
return ret;
}
void solve() {
int n;
cin >> n >> k;
vector<int> a(n);
vector<vector<pair<int, int>>> p(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
vector<pair<int, int>> temp = prime_factorize(a[i]);
p[i] = temp;
}
map<vector<pair<int, int>>, int> countmap;
vector<vector<pair<int, int>>> q(n);
for (int i = 0; i < n; i++) {
vector<pair<int, int>> t1 = p[i];
countmap[t1]++;
for (auto &t : t1) {
t.second = k - t.second;
}
q[i] = t1;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
vector<pair<int, int>> t1 = p[i];
for (auto &t : t1) {
t.second = k - t.second;
}
ans += countmap[t1];
if (p[i] == t1) ans--;
}
cout << ans / 2 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test = 1;
while (test--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mcd(long long a, long long b) {
if (b > a) swap(a, b);
if (b == 0)
return a;
else
return mcd(b, a % b);
}
long long t, n, m, k;
bool esprimo(long long n) {
long long s = 0;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
s++;
}
}
if (s >= 2) {
return false;
}
return true;
}
int main() {
cin >> t;
while (t--) {
cin >> n;
string a;
cin >> a;
queue<long long> q0, q1;
long long c = 1;
vector<long long> ans;
for (int i = 0; i < n; i++) {
if (a[i] == '0') {
if (q1.size() != 0) {
ans.push_back(q1.front());
q0.push(q1.front());
q1.pop();
} else {
ans.push_back(c);
q0.push(c);
c++;
}
} else {
if (q0.size() != 0) {
ans.push_back(q0.front());
q1.push(q0.front());
q0.pop();
} else {
ans.push_back(c);
q1.push(c);
c++;
}
}
}
cout << c - 1 << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
typedef pair<P, int> PP;
const int mod = 1000000007;
const int INF = 1e12;
char c[110][110];
int d[110][110][4];
int h, w, l;
string str = "NESW";
int dy[4] = {-1, 0, 1, 0};
int dx[4] = { 0, 1, 0,-1};
bool contain(int y, int x){
return (0 <= y && y < h && 0 <= x && x < w);
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
while(1){
cin >> h >> w >> l;
if(h + w + l == 0) break;
int dr = 0, y = 0, x = 0;
rep(i, 0, h) rep(j, 0, w) rep(k, 0, 4) d[i][j][k] = -1;
rep(i, 0, h){
rep(j, 0, w){
cin >> c[i][j];
if(str.find(c[i][j]) != string::npos){
dr = str.find(c[i][j]);
y = i; x = j;
}
}
}
// cerr << dr << endl;
d[y][x][dr] = 0;
vector<PP> sv;
sv.push_back(PP(P(y, x), dr));
for(int i = 1;; i++){
int ny = 0, nx = 0;
// cerr << i << ' ' << ny << ' ' << nx << ' ' << dr << endl;
for(int j = 0;; j++){
ny = y + dy[dr];
nx = x + dx[dr];
if(contain(ny, nx) && c[ny][nx] != '#'){
break;
}
dr = (dr + 1) % 4;
// cerr << dr << endl;
}
y = ny; x = nx;
if(i == l){
cout << y + 1 << ' ' << x + 1 << ' ' << str[dr] << endl;
break;
}
if(d[y][x][dr] != -1){
int loop = i - d[y][x][dr];
int step = d[y][x][dr] + (l - d[y][x][dr]) % loop;
// cerr << loop << ' ' << step << endl;
cout << sv[step].first.first + 1 << ' ' << sv[step].first.second + 1 << ' ' << str[sv[step].second] << endl;
break;
}
d[y][x][dr] = i;
sv.push_back(PP(P(y, x), dr));
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test = 1;
while (test--) {
long long N;
cin >> N;
long long A[N + 1];
for (int i = 1; i < N + 1; i++) cin >> A[i];
cout << "1 1\n" << A[1] * (N - 1) << "\n";
(N == 1) ? cout << "1 1"
<< "\n"
<< "0"
: cout << "2 " << N << "\n";
for (int i = 2; i < N + 1; i++) cout << A[i] * (N - 1) << " ";
cout << "\n"
<< "1 " << N << "\n";
for (int i = 1; i < N + 1; i++) cout << -A[i] * N << " ";
}
}
| 3 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const double eps = 1e-9;
using namespace std;
const int N = 333;
const long long MOD = 1e9 + 7;
long long dp[N][N];
vector<pair<long long, long long>> v;
int n;
long long triangle_area_2(long long x1, long long y1, long long x2,
long long y2, long long x3, long long y3) {
return (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v.push_back({x, y});
}
long long s = 0;
for (int i = 0; i < n; i++) {
int id = (i + 1) % n;
s += v[id].first * v[i].second - v[id].second * v[i].first;
dp[i][id] = 1;
}
if (s < 0) {
reverse((v).begin(), (v).end());
}
for (int len = 2; len < n; len++) {
for (int l = 0; l < n; l++) {
int r = (l + len) % n;
for (int take = l + 1; take < l + len; take++) {
int id = take % n;
if (triangle_area_2(v[l].first, v[l].second, v[id].first, v[id].second,
v[r].first, v[r].second) < 0) {
dp[l][r] = (dp[l][r] + dp[l][id] * dp[id][r]) % MOD;
}
}
}
}
cout << dp[0][n - 1] << endl;
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(3);
int step = 1;
for (int i = 0; i < step; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
struct MCF {
int n;
vector<int> prio, curflow, prevedge, prevnode, pot;
priority_queue<long long, vector<long long>, greater<long long>> q;
struct edge {
int to, rev;
int f, cap, cost;
};
vector<vector<edge>> g;
MCF(int n)
: n(n), prio(n), curflow(n), prevedge(n), prevnode(n), pot(n), g(n) {}
void add_edge(int s, int t, int cap, int cost) {
g[s].push_back((edge){t, ((int)(g[t]).size()), 0, cap, cost});
g[t].push_back((edge){s, ((int)(g[s]).size()) - 1, 0, 0, -cost});
}
pair<int, int> get_flow(int s, int t) {
int flow = 0, flowcost = 0;
while (1) {
q.push(s);
fill((prio).begin(), (prio).end(), INF);
prio[s] = 0;
curflow[s] = INF;
while (!q.empty()) {
long long cur = q.top();
int d = cur >> 32, u = cur;
q.pop();
if (d != prio[u]) continue;
for (int i = 0; i < ((int)(g[u]).size()); ++i) {
edge &e = g[u][i];
int v = e.to;
if (e.cap <= e.f) continue;
int nprio = prio[u] + e.cost + pot[u] - pot[v];
if (prio[v] > nprio) {
prio[v] = nprio;
q.push(((long long)nprio << 32) + v);
prevnode[v] = u;
prevedge[v] = i;
curflow[v] = min(curflow[u], e.cap - e.f);
}
}
}
if (prio[t] == INF) break;
for (int i = 0, qwert = n; i < qwert; i++) pot[i] += prio[i];
int df = min(curflow[t], INF - flow);
flow += df;
for (int v = t; v != s; v = prevnode[v]) {
edge &e = g[prevnode[v]][prevedge[v]];
e.f += df;
g[v][e.rev].f -= df;
flowcost += df * e.cost;
}
}
return {flow, flowcost};
}
};
const int N = 101;
string t;
int n, mxa[N];
string words[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t >> n;
for (int x = 0, qwert = n; x < qwert; x++) cin >> words[x] >> mxa[x];
MCF nt(n + 1 + n * 26 + ((int)(t).size()) + 1);
int nodes = 1;
for (int x = 0, qwert = n; x < qwert; x++)
nt.add_edge(0, nodes, mxa[x], nodes), nodes++;
for (int x = 0, qwert = n; x < qwert; x++) {
int cnt[26] = {};
for (int y = 0, qwert = ((int)(words[x]).size()); y < qwert; y++)
cnt[words[x][y] - 'a']++;
for (int y = 0, qwert = 26; y < qwert; y++)
nt.add_edge(x + 1, n + y + 1 + 26 * x, cnt[y], 0), nodes++;
}
int st_tw = nodes;
nodes += ((int)(t).size()) + 1;
for (int x = 0, qwert = ((int)(t).size()); x < qwert; x++)
nt.add_edge(st_tw + x, nodes - 1, 1, 0);
for (int x = 0, qwert = n; x < qwert; x++)
for (int y = 0, qwert = ((int)(t).size()); y < qwert; y++)
nt.add_edge(n + t[y] - 'a' + 1 + 26 * x, st_tw + y, 1, 0);
auto ans = nt.get_flow(0, nodes - 1);
if (ans.first != ((int)(t).size())) {
cout << "-1\n";
} else
cout << ans.second << "\n";
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, a[10], b[10], i = 0, t;
scanf("%d", &n);
for (i = 0; i < n; i++) {
a[i] = 1;
}
t = n;
while (n - 1) {
b[0] = 1;
for (i = 1; i < t; i++) {
b[i] = a[i] + b[i - 1];
}
for (i = 0; i < t; i++) {
a[i] = b[i];
}
n--;
}
printf("%d", a[t - 1]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 3e5 + 10;
const int E = Max * 2;
int son[Max], maxson[Max], fa[Max], zx[Max];
int head[Max], nex[E], pnt[E], edge;
void Init() {
edge = 0;
memset(son, 0, sizeof(son));
memset(maxson, 0, sizeof(maxson));
memset(fa, -1, sizeof(fa));
memset(head, -1, sizeof(head));
}
void Addedge(int u, int v) {
pnt[edge] = v;
nex[edge] = head[u];
head[u] = edge++;
}
void dfs1(int u) {
son[u] = 1;
maxson[u] = 0;
int v;
for (int e = head[u]; e != -1; e = nex[e]) {
v = pnt[e];
dfs1(v);
son[u] += son[v];
maxson[u] = max(maxson[u], son[v]);
}
}
bool is_ok(int u, int v) {
if (son[u] >= maxson[v] * 2 && son[u] >= (son[u] - son[v]) * 2) return 1;
return 0;
}
void dfs2(int u) {
if (son[u] == 1) {
zx[u] = u;
return;
}
int v, z = u;
for (int e = head[u]; e != -1; e = nex[e]) {
v = pnt[e];
dfs2(v);
if (maxson[u] == son[v]) {
z = zx[v];
}
}
while (!is_ok(u, z) && fa[z] != -1) {
z = fa[z];
}
zx[u] = z;
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
Init();
int u, v;
for (int i = 2; i <= n; i++) {
scanf("%d", &u);
fa[i] = u;
Addedge(u, i);
}
dfs1(1);
dfs2(1);
while (m--) {
scanf("%d", &u);
printf("%d\n", zx[u]);
}
}
return 0;
}
| 4 |
#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
const double EPS = 1e-9;
typedef pair<int, int> P;
typedef unsigned int ui;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
int main() {
string s; int n;
cin >> s >> n;
int len = s.length();
vector<int> t;
rep(i, len) {
if (s[i] == '+' || s[i] == '*')t.push_back(0);
else t.push_back(s[i] - '0');
}
int m, l; m = 0; l = t[0];
rep(i, len) {
if (s[i] == '+') {
m += t[i - 1];
l += t[i + 1];
}
else if(s[i]=='*'){
l *= t[i + 1];
t[i + 1] *= t[i-1];
}
}
m += t[len - 1];
if (m == n && l == n) {
cout << "U" << endl;
}
else if (m == n) {
cout << "M" << endl;
}
else if (l == n) {
cout << "L" << endl;
}
else {
cout << "I" << endl;
}
return 0;
}
| 0 |
#include<cstdio>
#include<cstring>
const int N = 51;
const int M = 2501;
typedef long long LL;
LL dp[N][M];
int n, m, x, sum, a[N];
int main(){
scanf("%d %d", &n, &m);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
sum = 0;
for(int i=0; i<n; i++){
scanf("%d", &x);
sum += x;
for(int j=i; j>=0; j--){
for(int k=sum; k>=x; k--){
dp[j+1][k] += dp[j][k-x];
}
}
}
LL ans = 0;
for(int i=1; i<=n; i++){
ans += dp[i][i*m];
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
template <typename A, typename B>
ostream& operator<<(ostream& os, pair<A, B> p) {
return os << '{' << p.first << ", " << p.second << '}';
}
const int oo = 0x3f3f3f3f;
const ll OO = ll(oo) * oo;
const int N = 100005;
int deg[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
deg[a]++;
deg[b]++;
}
for (int i = 0; i < n + 1; i++) {
if (deg[i] == 2) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 205;
typedef bitset<2 * Maxn> B;
vector<int> e[2 * Maxn];
B ban[2 * Maxn];
int n, m, l, dfn[2 * Maxn], low[2 * Maxn], bl[2 * Maxn], scc;
char s[26], t[Maxn], ans[Maxn];
void tarjan(int x) {
static int Stack[2 * Maxn], Instack[2 * Maxn], top, cnt;
Stack[++top] = x;
Instack[x] = true;
dfn[x] = low[x] = ++cnt;
for (int y : e[x])
if (!dfn[y])
tarjan(y), low[x] = min(low[x], low[y]);
else if (Instack[y])
low[x] = min(low[x], dfn[y]);
if (dfn[x] == low[x]) {
scc++;
int t;
do {
t = Stack[top--];
Instack[t] = false;
bl[t] = scc;
} while (t != x);
}
}
string opt(B state) {
string ans;
for (int i = 1; i <= scc; i++) ans += bool(state[i]) + '0';
return ans;
}
void dfs(int x, int flag, B state) {
if (x == n + 1) {
cout << ans + 1 << "\n";
exit(0);
}
bool vis[2] = {0, 0};
for (int j = flag ? t[x] - 'a' : 0; j < l; j++) {
int type = s[j] == 'V';
if (state[bl[2 * x + type]]) continue;
if (vis[type]) continue;
ans[x] = 'a' + j;
dfs(x + 1, flag && (j == t[x] - 'a'), state | ban[bl[2 * x + type]]);
ans[x] = 0;
if (j != t[x] - 'a' || !flag) vis[type] = true;
}
}
int main() {
scanf("%s", s);
l = strlen(s);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int pos1, pos2;
char t1, t2;
scanf("%d %c%d %c", &pos1, &t1, &pos2, &t2);
int x = 2 * pos1 + (t1 == 'V');
int y = 2 * pos2 + (t2 == 'V');
e[x].push_back(y);
e[y ^ 1].push_back(x ^ 1);
}
scanf("%s", t + 1);
for (int i = 2; i <= 2 * n + 1; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++)
if (bl[2 * i] == bl[2 * i + 1]) {
cout << "-1\n";
return 0;
}
for (int i = 1; i <= scc; i++)
for (int x = 2; x <= 2 * n + 1; x++)
if (bl[x] == i) {
ban[i][bl[x ^ 1]] = 1;
for (int y : e[x])
if (bl[y] != bl[x]) ban[i] |= ban[bl[y]];
}
dfs(1, 1, B());
cout << "-1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k;
vector<int> g[N];
int good[N];
int sz[N];
vector<int> vs;
void go(int u, int p) {
if (good[u]) vs.push_back(u);
for (int v : g[u])
if (v != p) go(v, u);
}
void solve(int u) {
printf("1\n%d\n", u);
go(u, 0);
for (int i = 0; i < k; ++i) {
printf("%d %d %d\n", vs[i], vs[k + i], u);
}
exit(0);
}
void dfs(int u, int p) {
sz[u] = good[u];
int mxst = 0;
for (int v : g[u])
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
mxst = max(mxst, sz[v]);
}
mxst = max(mxst, 2 * k - sz[u]);
if (mxst <= k) {
solve(u);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < 2 * k; ++i) {
int u;
scanf("%d", &u);
good[u] = 1;
}
dfs(1, 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)(1e6) + 5;
const int mo = (int)(1e9) + 7;
struct node{
int x, y, z, w;
node(int _x = 0, int _y = 0, int _z = 0, int _w = 0):x(_x), y(_y), z(_z), w(_w) {}
} p[maxn];
bool operator < (node a, node b) {
return 0LL + a.x + a.y + a.z < 0LL + b.x + b.y + b.z;
}
bool operator == (node a, node b) {
return a.x == b.x && a.y == b.y && a.z == b.z;
}
signed main() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int tot = 0;
for (int i = 0; i <= d; ++i) {
if (i + 1 < a) p[++tot] = node(i, 1LL * b * (i + 1) / a, 1LL * c * (i + 1) / a, 0), p[++tot] = node(a - 2 - i, 1LL * b * (a - 1 - i) / a, 1LL * c * (a - 1 - i) / a, 0);
if (i + 1 < b) p[++tot] = node(1LL * a * (i + 1) / b, i, 1LL * c * (i + 1) / b, 1), p[++tot] = node(1LL * a * (b - 1 - i) / b, b - 2 - i, 1LL * c * (b - 1 - i) / b, 1);
if (i + 1 < c) p[++tot] = node(1LL * a * (i + 1) / c, 1LL * b * (i + 1) / c, i, 2), p[++tot] = node(1LL * a * (c - 1 - i) / c, 1LL * b * (c - 1 - i) / c, c - 2 - i, 2);
}
sort(p + 1, p + tot + 1);
tot = unique(p + 1, p + tot + 1) - p - 1; p[++tot] = node(a - 1, b - 1, c - 1);
int res = 1LL * (min(a - 1, d) + 1) * (min(b - 1, d) + 1) * (min(c - 1, d) + 1) % mo;
for (int i = 1; i < tot; ++i) {
int dX = 1LL * (p[i + 1].x - p[i].x) * (p[i].x + d + 1 < a ? 1LL * (min(b - 1, p[i + 1].y + d) - max(0, p[i + 1].y - d) + 1) * (min(c - 1, p[i + 1].z + d) - max(0, p[i + 1].z - d) + 1) % mo : 0) % mo;
int dY = 1LL * (p[i + 1].y - p[i].y) * (p[i].y + d + 1 < b ? 1LL * (min(a - 1, p[i + 1].x + d) - max(0, p[i + 1].x - d) + 1) * (min(c - 1, p[i + 1].z + d) - max(0, p[i + 1].z - d) + 1) % mo : 0) % mo;
int dZ = 1LL * (p[i + 1].z - p[i].z) * (p[i].z + d + 1 < c ? 1LL * (min(a - 1, p[i + 1].x + d) - max(0, p[i + 1].x - d) + 1) * (min(b - 1, p[i + 1].y + d) - max(0, p[i + 1].y - d) + 1) % mo : 0) % mo;
res += (0LL + dX + dY + dZ) % mo; if (res >= mo) res -= mo;
}
return printf("%d\n", res), 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
const int N = 250025;
const int M = 1e6 + 10;
int n, m, k, w0, w1, tot;
int u[M], nex[M], a[5];
int h[N], b[N], deep[N], fa[N];
void addedge(int w0, int w1) {
u[++tot] = w1;
nex[tot] = h[w0];
h[w0] = tot;
}
void dfs(int w, int depth) {
if (depth > w1) w0 = w;
deep[w] = depth;
bool leaf = true;
for (int i = h[w]; i; i = nex[i])
if (!deep[u[i]]) {
fa[u[i]] = w;
dfs(u[i], depth + 1);
leaf = false;
}
if (leaf) b[tot++] = w;
}
int main() {
n = read();
m = read();
k = read();
while (m--) {
w0 = read();
w1 = read();
addedge(w0, w1);
addedge(w1, w0);
}
w1 = n / k;
w0 = tot = 0;
fa[1] = 1;
dfs(1, 1);
if (w0) {
printf("PATH\n%d\n", deep[w0]);
for (; w0 != 1; w0 = fa[w0]) printf("%d ", w0);
printf("1\n");
} else {
printf("CYCLES\n");
for (int i = 0; i < k; i++) {
int j = h[w0 = b[i]];
tot = 0;
for (int cnt = 3; cnt; j = nex[j], cnt--)
if (u[j] != fa[w0]) a[tot++] = u[j];
if ((deep[w0] - deep[a[0]] + 1) % 3 != 0) {
printf("%d\n", deep[w0] - deep[a[0]] + 1);
for (; w0 != a[0]; w0 = fa[w0]) printf("%d ", w0);
printf("%d\n", a[0]);
} else if ((deep[w0] - deep[a[1]] + 1) % 3 != 0) {
printf("%d\n", deep[w0] - deep[a[1]] + 1);
for (; w0 != a[1]; w0 = fa[w0]) printf("%d ", w0);
printf("%d\n", a[1]);
} else {
if (deep[a[0]] < deep[a[1]]) swap(a[0], a[1]);
printf("%d\n", deep[a[0]] - deep[a[1]] + 2);
printf("%d ", w0);
for (w0 = a[0]; w0 != a[1]; w0 = fa[w0]) printf("%d ", w0);
printf("%d\n", a[1]);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
long long dp[3][710][710];
long long ans;
int n, m;
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int x, y;
x = read();
y = read();
dp[0][x][y] = dp[0][y][x] = 1;
}
for (int p = 0; p < 2; p++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (!dp[p][i][j]) continue;
for (int k = 1; k <= n; k++) {
if (!dp[0][j][k]) continue;
dp[p + 1][i][k] += dp[p][i][j];
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
if (dp[0][i][k] && dp[0][j][k] && dp[2][i][j]) {
ans += dp[2][i][j] - dp[1][i][k] - dp[1][j][k];
if (dp[0][i][j]) ans -= dp[1][i][i] + dp[1][j][j] - 3;
}
}
}
}
cout << ans / 5 << endl;
return 0;
}
| 5 |
#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<vector>
using namespace std;
struct data{
string str;
int y,l;
data(string a,int b,int c):
str(a),l(b),y(c){}
data(){}
};
int main(){
int n,m;
while(cin>>n>>m,n||m){
vector<data>V(n);
for(int i=0;i<n;i++){
string str;
int l,y;
cin>>str>>l>>y;
V[i]=data(str,l,y);
}
while(m--){
int y;
cin>>y;
bool flag=true;
for(int i=0;i<n;i++){
if(V[i].y>=y&&V[i].y-V[i].l<y){
flag=false;
cout<<V[i].str<<" "<<y-V[i].y+V[i].l<<endl;
break;
}
}
if(flag)cout<<"Unknown"<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
void inv(int n, int a[], int b[], int p[]) {
static int h[maxn];
for (int i = 1; i <= n; ++i) {
h[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
p[i] = h[b[i]];
}
}
void solve(int n) {
static int a[maxn], b[maxn], p[maxn];
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int j = 1; j <= n; ++j) cin >> b[j];
inv(n, a, b, p);
for (int k = 1; k <= n; ++k) cout << p[k] << " ";
cout << endl;
}
int main() {
for (int n; cin >> n; solve(n))
;
}
| 6 |
#include <bits/stdc++.h>
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define EPS 1e-10
#define setNil(x) memset((x),0,sizeof(x))
#define setINF(x) memset((x),63,sizeof(x))
#define setNegINF(x) memset((x),192,sizeof(x)) //NegINF=-INF-1
#define setNeg1(x) memset((x),255,sizeof(x))
using namespace std;
int n,cnt,ans=-2,deg[100005],par[100005],fx,fc;
bool mr[100005];
string s;
bool vis[100005];
vector<int> g[100005];
queue<int> q;
void dfs1(int x,int p){
par[x]=p;
for(int i=0;i<g[x].size();i++){
int u=g[x][i];
if(u==p)continue;
deg[x]++;
dfs1(u,x);
}
}
void dfs(int x,int p,int c){
if(c>fc){
fc=c;
fx=x;
}
for(int i=0;i<g[x].size();i++){
int u=g[x][i];
if(!deg[u] || u==p)continue;
dfs(u,x,c+mr[u]);
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin>>n;
for(int i=1;i<n;i++){
int u,v;
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
cin>>s;
s="$"+s;
int rt=0;
for(int i=1;i<=n;i++){
if(s[i]=='W'){
cnt++;
rt=i;
}
}
if(cnt<2)cout<<cnt<<endl;
else{
dfs1(rt,0);
for(int i=1;i<=n;i++)if(!deg[i] && s[i]=='B')q.push(i);
while(!q.empty()){
int u=q.front();
q.pop();
for(int i=0;i<g[u].size();i++){
int v=g[u][i];
if(deg[v]==1 && s[v]=='B'){
q.push(v);
cnt++;
}
if(deg[v])deg[v]--;
}
}
for(int i=1;i<=n;i++)deg[i]|=(s[i]=='W');
for(int i=1;i<=n;i++){
if(!deg[i])continue;
ans+=2;
int sum=0;
for(int j=0;j<g[i].size();j++)sum+=(!!deg[g[i][j]]);
if(sum&1)ans+=(mr[i]=(s[i]=='B'));
else ans+=(mr[i]=(s[i]=='W'));
}
dfs(rt,0,mr[rt]);
dfs(fx,fc=0,mr[fx]);
cout<<ans-2*fc<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
}
int main() {
fast();
long long n, l, r;
cin >> n >> l >> r;
long long mn = n - l + 1, mx = 0;
int i = n - l + 1, p = 2;
for (; i < n; i++, p *= 2) {
mn += p;
}
i = 0, p = 1;
for (; i < r; i++, p *= 2) {
mx += p;
}
for (; i < n; i++) {
mx += p / 2;
}
cout << mn << ' ' << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3fLL;
const int EPS = 1e-6;
const long long mod = 1000000007;
int a[30010];
int b[30010];
int n;
bool func(int x, int y, int ind) {
int r = y - x;
memset(b, 0, sizeof b);
int num = a[ind - 1];
b[ind - 1] = 1;
for (int i = ind; i < n; i++) {
if (num + r == a[i]) {
num += r;
b[i] = 1;
}
}
num = INT_MAX;
int z = INT_MAX;
int idx = 0;
for (int i = n - 1; i >= 0; i--) {
if (!b[i] && z == INT_MAX) {
if (num == INT_MAX) {
num = a[i];
idx = i;
} else {
z = num - a[i];
break;
}
b[i] = 2;
}
}
for (int i = idx - 1; i >= 0; i--) {
if (num - z == a[i]) {
if (b[i]) {
bool part1 = false, part2 = false;
for (int j = i - 1; j >= 0; j--) {
if (a[i] - r == a[j]) part1 = true;
}
for (int j = i + 1; j < n; j++) {
if (a[i] + r == a[j]) part2 = true;
}
if (part1 && part2) continue;
}
b[i] = 2;
num -= z;
}
}
bool done = true, one = true;
for (int i = 0; i < n; i++) {
if (!b[i]) done = false;
if (b[i] == 2) one = false;
}
if (done && one) {
printf("%d\n", a[0]);
for (int i = 1; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
} else if (done) {
for (int i = 0; i < n; i++) {
if (b[i] == 1) printf("%d ", a[i]);
}
printf("\n");
for (int i = 0; i < n; i++) {
if (b[i] == 2) printf("%d ", a[i]);
}
printf("\n");
} else {
memset(b, 0, sizeof b);
int num = a[ind - 1];
b[ind - 1] = 1;
for (int i = ind; i < n; i++) {
if (num + r == a[i]) {
num += r;
b[i] = 1;
}
}
num = INT_MAX;
int z = INT_MAX;
int idx = 0;
for (int i = 0; i < n; i++) {
if (!b[i] && z == INT_MAX) {
if (num == INT_MAX) {
num = a[i];
idx = i;
} else {
z = a[i] - num;
break;
}
b[i] = 2;
}
}
for (int i = idx; i < n; i++) {
if (num + z == a[i]) {
if (b[i]) {
bool part1 = false, part2 = false;
for (int j = i - 1; j >= 0; j--) {
if (a[i] - r == a[j]) part1 = true;
}
for (int j = i + 1; j < n; j++) {
if (a[i] + r == a[j]) part2 = true;
}
if (part1 && part2) continue;
}
b[i] = 2;
num += z;
}
}
bool done = true, one = true;
for (int i = 0; i < n; i++) {
if (!b[i]) done = false;
if (b[i] == 2) one = false;
}
if (done && one) {
printf("%d\n", a[0]);
for (int i = 1; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
} else if (done) {
for (int i = 0; i < n; i++) {
if (b[i] == 1) printf("%d ", a[i]);
}
printf("\n");
for (int i = 0; i < n; i++) {
if (b[i] == 2) printf("%d ", a[i]);
}
printf("\n");
} else
return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
if (!func(a[0], a[1], 1)) {
if (!func(a[0], a[2], 1)) {
if (!func(a[1], a[2], 2)) puts("No solution");
}
}
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define min(x,y) ((x)<(y)?(x):(y))
#define max(x,y) ((x)>(y)?(x):(y))
#define ll long long
using namespace std;
const int maxn=1e5+5;
int fi[maxn],dui[maxn*2],ne[maxn*2],qc[maxn],dui1[maxn*2];
ll de[maxn],ans,mi;
int size[maxn];
int i,j,k,l,m,n,x,y,z,c1,c2,now;
void add(int x,int y,int z){
if (fi[x]==0) fi[x]=++now; else ne[qc[x]]=++now;
dui[now]=y; dui1[now]=z; qc[x]=now;
}
void dfs_size(int x,int y){
size[x]=1;
for(int i=fi[x];i;i=ne[i]){
if (dui[i]==y) continue;
dfs_size(dui[i],x);
size[x]=size[x]+size[dui[i]];
}
}
void dfs_root(int x,int y){
int z=size[1]-size[x];
for(int i=fi[x];i;i=ne[i]){
if (dui[i]==y) continue;
z=max(z,size[dui[i]]);
dfs_root(dui[i],x);
}
if (z<l){
l=z; c1=x; c2=0;
} else if (z==l) c2=x;
}
void dfs_dep(int x,int y){
for(int i=fi[x];i;i=ne[i]){
if (dui[i]==y) continue;
de[dui[i]]=de[x]+dui1[i];
dfs_dep(dui[i],x);
}
ans=ans+de[x]+de[x];
}
int main(){
// freopen("018d.in","r",stdin);
scanf("%d",&n);
fo(i,1,n-1){
scanf("%d%d%d",&x,&y,&z);
add(x,y,z); add(y,x,z);
}
dfs_size(1,0);
l=n+1;
dfs_root(1,0);
dfs_dep(c1,0);
if (c2==0){
mi=1e16;
fo(i,1,n) if (i!=c1) mi=min(mi,de[i]);
} else mi=de[c2];
printf("%lld\n",ans-mi);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define MAX 514
#define INF (1e9)
struct Edge{
int to,cost,c;
Edge(int to,int cost,int c) :
to(to),cost(cost),c(c) {}
};
int main(){
int M,D,N,K;
int d[MAX][1<<6];
while(cin >> M >> N >> K >> D, M){
vector<Edge> G[MAX];
vector<int> cake(M);
for(int i = 0 ; i < M ; i++){
cin >> cake[i];
}
int idx = 0,c;
string a,b;
map<string,int> mp;
for(int i = 0 ; i < D ; i++){
cin >> a >> b >> c;
if(!mp.count(a)) mp[a] = idx++;
if(!mp.count(b)) mp[b] = idx++;
if(a[0] == 'C'){
G[mp[b]].push_back(Edge(mp[a],c,a[1]-'1'));
}else{
G[mp[b]].push_back(Edge(mp[a],c,-1));
}
if(b[0] == 'C'){
G[mp[a]].push_back(Edge(mp[b],c,b[1]-'1'));
}else{
G[mp[a]].push_back(Edge(mp[b],c,-1));
}
}
int s = mp["H"],t = mp["D"];
for(int i = 0 ; i < MAX ; i++){
for(int j = 0 ; j < (1<<6) ; j++){
d[i][j] = INF;
}
}
d[s][0] = 0;
bool update = 1;
while(update){
update = 0;
for(int i = 0 ; i < (int)mp.size() ; i++){
for(int j = 0 ; j < (int)G[i].size() ; j++){
Edge e = G[i][j];
for(int S = (1<<6)-1 ; S >= 0 ; S--){
int ncost = d[i][S];
if(ncost == INF) continue;
ncost += e.cost*K;
if(e.c == -1){
if(ncost < d[e.to][S]){
d[e.to][S] = ncost;
update = 1;
}
}else{
if(S >> e.c & 1) continue;
if(ncost-cake[e.c] < d[e.to][S|(1<<e.c)]){
d[e.to][S|(1<<e.c)] = ncost-cake[e.c];
update = 1;
}
}
}
}
}
}
int res = INF;
for(int i = 0 ; i < (1<<6) ; i++){
res = min(res, d[t][i]);
}
cout << res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
const ll MOD = 1000000007;
const ll INF = 100000000000000000LL;
inline ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
inline ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
inline ll powint(ll x, ll y) {
ll r = 1;
while (y) {
if (y & 1) r *= x;
x *= x;
y >>= 1;
}
return r;
}
inline ll powmod(ll x, ll y, ll m = MOD) {
ll r = 1;
while (y) {
if (y & 1) r *= x;
x *= x;
r %= m;
x %= m;
y >>= 1;
}
return r;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n;
cin >> n;
ll a[3];
for (ll i = 0; i < (n); i++) {
for (ll j = 0; j < (3); j++) cin >> a[j];
sort(a, a + 3);
ll alice = a[0], bob = a[1];
alice += a[1] - a[0];
a[2] -= a[1] - a[0];
cout << alice + a[2] / 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 12;
char s[15];
long long ans[maxn][105];
int cnt[maxn], w[15];
int main() {
int n, m, q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n; ++i) scanf("%d", &w[n - i - 1]);
for (int i = 0; i < m; ++i) {
scanf("%s", s);
int x = 0;
for (int j = 0; j < n; ++j) x = (x << 1) + (s[j] ^ 48);
++cnt[x];
}
for (int x = 0; x < (1 << n); ++x) {
for (int y = 0; y < (1 << n); ++y) {
int wu = 0;
for (int i = 0; i < n; ++i)
if ((x >> i & 1) == (y >> i & 1)) wu += w[i];
if (wu <= 100) ans[x][wu] += cnt[y];
}
}
for (int tc = 0; tc < q; ++tc) {
int k;
scanf("%s %d", s, &k);
int x = 0;
for (int i = 0; i < n; ++i) x = (x << 1) + (s[i] ^ 48);
long long res = 0;
for (int i = 0; i <= k; ++i) res += ans[x][i];
printf(
"%I64d"
"\n",
res);
}
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
int p, n[6], c[6] = {1, 5, 10, 50, 100, 500};
int data[500001];
int calc(int t, bool o){
int res = 0;
for(int i=5;i>=0;i--){
int tmp = t / c[i];
if(o) tmp = min(tmp, n[i]);
t -= tmp * c[i];
res += tmp;
}
return res;
}
int main(){
for(int i=0;i<=500000;i++) data[i] = calc(i, false);
while(scanf("%d", &p) && p){
int lim = 0;
for(int i=0;i<6;i++){
scanf("%d", &n[i]);
lim += n[i] * c[i];
}
int ans = 1000000;
for(int i=p;i<=lim;i++){
int tmp;
if(tmp = calc(i, true)){
ans = min(ans, tmp + data[i-p]);
}
}
printf("%d\n", ans);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001;
int a[MAXN];
map<int, int> fp, tp;
int Count(int a, int b) {
int ans = 0;
if (fp[a + b]) {
fp[a + b]--;
ans = Count(b, a + b) + 1;
fp[a + b]++;
}
return ans;
}
int main() {
int n;
cin >> n;
fp.clear();
for (int i = 0; i < n; i++) cin >> a[i], fp[a[i]]++;
if (fp[0] == n) {
cout << n << endl;
return 0;
}
sort(a, a + n);
int top = unique(a, a + n) - a;
int ans = 0;
for (int i = 0; i < top; i++) {
for (int j = 0; j < top; j++) {
if (i == j && fp[a[i]] == 1) continue;
fp[a[i]]--;
fp[a[j]]--;
ans = max(ans, Count(a[i], a[j]) + 2);
fp[a[i]]++;
fp[a[j]]++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int dbg = 0;
struct FatalMessage {
FatalMessage(const char* file, int line, const char* cond) {
std::cerr << file << " L" << line << " failed: " << cond << ". ";
}
~FatalMessage() {
std::cerr << std::endl;
std::terminate();
}
};
template <typename T>
const FatalMessage& operator<<(const FatalMessage& s, const T& t) {
std::cerr << t;
return s;
}
template <typename C>
void SortAndUniq(C& c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
struct Tree {
int N, root;
vector<vector<int>> sons;
vector<int> fa, ord, rev_ord;
void AddEdge(int a, int b) {
sons[a].push_back(b);
sons[b].push_back(a);
}
void MakeRooted(int _root) {
root = _root;
fa.assign(N, -2);
ord.clear();
fa[root] = -1;
ord.push_back(root);
for (int i = 0; i < ord.size(); ++i) {
int u = ord[i];
if (fa[u] != -1) {
auto iter = find(sons[u].begin(), sons[u].end(), fa[u]);
sons[u].erase(iter);
}
for (int v : sons[u]) {
fa[v] = u;
ord.push_back(v);
}
}
rev_ord = ord;
reverse(rev_ord.begin(), rev_ord.end());
}
void Read(istream& in) {
in >> N;
sons.clear();
sons.resize(N);
for (int i = 1; i < N; ++i) {
int a, b;
in >> a >> b;
AddEdge(a - 1, b - 1);
}
}
};
using vii = vector<pair<long long, long long>>;
void Combine(const vii& a, const vii& b, vii& r) {
r.assign(a.size() + b.size() - 1, {-1, -1});
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < b.size(); ++j) {
auto t = a[i];
t.first += b[j].first;
t.second += b[j].second;
r[i + j] = max(r[i + j], t);
}
}
}
int Solve() {
int N, M;
cin >> N >> M;
vector<int> B(N), W(N);
for (int& x : B) {
cin >> x;
}
for (int& x : W) {
cin >> x;
}
Tree tree;
tree.N = N;
tree.sons.resize(N);
for (int i = 1; i < N; ++i) {
int a, b;
cin >> a >> b;
tree.AddEdge(a - 1, b - 1);
}
tree.MakeRooted(0);
vector<int> stsize(N, 1);
for (int u : tree.rev_ord) {
for (int v : tree.sons[u]) {
stsize[u] += stsize[v];
}
}
vector<vector<long long>> F(N);
vector<vector<pair<long long, long long>>> G(N);
vector<pair<long long, long long>> G0, G1;
vector<int> sons;
for (int u : tree.rev_ord) {
long long d = W[u] - B[u];
auto sons = tree.sons[u];
sort(sons.begin(), sons.end(),
[&stsize](int a, int b) { return stsize[a] > stsize[b]; });
if (sons.empty()) {
G[u] = {{0, d}, {d > 0 ? 1 : 0, 0}};
} else {
G1 = {{0, 0}};
while (!sons.empty()) {
int v = sons.back();
sons.pop_back();
Combine(G1, G[v], G0);
swap(G0, G1);
}
auto& Gu = G[u];
Gu.assign(G1.size() + 1, {-1, -1});
for (int i = 0; i < G1.size(); ++i) {
auto t = G1[i];
t.second += d;
Gu[i] = max(Gu[i], t);
if (t.second > 0) {
++t.first;
}
t.second = 0;
Gu[i + 1] = max(Gu[i + 1], t);
}
}
F[u].resize(G[u].size(), 0);
for (int i = 0; i + 1 < G[u].size(); ++i) {
F[u][i + 1] = G[u][i].first + (G[u][i].second > 0 ? 1 : 0);
}
}
if (dbg) {
for (int u = 0; u < N; ++u) {
cerr << "G[" << u << "]:";
for (int i = 0; i < G[u].size(); ++i) {
cerr << " " << i << ':' << G[u][i].first << '/' << G[u][i].second;
}
cerr << '\n';
}
}
return F[0][M];
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int T;
for (cin >> T; T--;) {
cout << Solve() << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int matrix[10][10];
int main() {
int i, a, b, n, m, ans;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
matrix[a][b] = 1;
matrix[b][a] = 1;
}
if (n < 7) {
cout << m << endl;
return 0;
}
int d = 1000;
for (i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int u = 0;
for (int q = 1; q <= n; q++) {
if (matrix[i][q] && matrix[j][q]) {
u++;
}
}
d = min(d, u);
}
}
cout << (m - d) << endl;
return 0;
}
| 1 |
/*
https://www.luogu.org/problem/AT2168
Author: Yu-343
*/
#include <cstdio>
int h, w, cnt = 0;
char ch;
int main (void) {
scanf ("%d %d", &h, &w);
for (int i = 1; i <= h; ++i) {
getchar ();
for (int j = 1; j <= w; ++j) {
scanf ("%c", &ch);
if (ch == '#') ++cnt;
}
}
puts ((cnt == h + w - 1) ? "Possible" : "Impossible");
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5;
int n,t,k,x,fix[N],l[N],r[N],a[N],f[N];
vector<int>er[N];
set<int>s;
multiset<int>sc;
int main(){
cin>>t;
while(t--){
cin>>n;
s.clear();
sc.clear();
for(k=1;k<=n;k++){
er[k].clear();
cin>>a[k]; f[a[k]]=0;fix[a[k]]=0;
x=k-1;
while(a[x]>=a[k]){
x=l[x];
}
l[k]=x;
}
for(k=n;k>=1;k--){
x=k+1; fix[a[k]]++;
s.insert(a[k]);
while(a[x]>a[k] && x<=n){
x=r[x];
}
r[k]=x;
}
for(k=1;k<=n;k++){
if(!f[a[k]])sc.insert(fix[a[k]]);
f[a[k]]=1;
er[r[k]-l[k]].push_back(a[k]);
}
for(k=1;k<=n;k++){
for(int i=0;i<er[k].size();i++){
sc.erase(sc.find(fix[er[k][i]]));
fix[er[k][i]]--;
if(fix[er[k][i]])sc.insert(fix[er[k][i]]);
else s.erase(er[k][i]);
}
// cout<<s.size()<<" "<<*(--s.end())<<" "<<*(--sc.end())<<" "<<sc.size()<<endl;
if(sc.size()==n-k+1 && *(--s.end())==n-k+1 && *(--sc.end())==1) cout<<1;
else cout<<0;
}
cout<<endl;
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
while(cin >> n, n){
string signal[1002];
signal[0] = to_string(1e9);
for(int i = 1; i <= n; i++) cin >> signal[i];
if(n % 2) signal[n + 1] = to_string(1e9);
else signal[n + 1] = to_string(-(1e9));
int less = -(1e9)-3, more = 1e9+3;
for(int i = 1; i <= n; i++){
if(signal[i] == "x"){
if(signal[i-1] == "x" || signal[i+1] == "x"){
less = 1e9+3, more = -(1e9)-3;
break;
}
if(i % 2) more = min(more, min(stoi(signal[i-1]), stoi(signal[i+1]))-1);
else less = max(less, max(stoi(signal[i-1]), stoi(signal[i+1]))+1);
} else if(signal[i-1] != "x" && signal[i+1] != "x"){
if(i%2 == 0 && (stoi(signal[i]) <= stoi(signal[i-1]) || stoi(signal[i]) <= stoi(signal[i+1])) ||
i%2 == 1 && (stoi(signal[i]) >= stoi(signal[i-1]) || stoi(signal[i]) >= stoi(signal[i+1]))){
less = 1e9+3, more = -(1e9)-3;
break;
}
}
}
if(less == more) cout << more << endl;
else if(more > less) cout << "ambiguous" << endl;
else if(more < less) cout << "none" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int in[100005];
int dp[100005];
int main() {
int n;
scanf("%d", &n);
fill(dp, dp + 100005, 1000000000);
dp[0] = 0;
int ret = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
int s = 0, e = 100005;
while (e - s > 1) {
int med = (s + e) / 2;
if (dp[med] < a)
s = med;
else
e = med;
}
dp[s + 1] = a;
ret = max(ret, s + 1);
}
printf("%d\n", ret);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643383;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int Ceil(long long int a, long long int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
const int MAX = 200009;
const int MOD = 1e9 + 7;
const int inf = 1e9 + 10;
long long int x[MAX], d[MAX];
long long int C2(long long int n) { return n * (n - 1) / 2; }
long long int func(long long int n) {
long long int x = (n + 1) / 2;
long long int a = C2(x) + C2(n + 1 - x);
x++;
long long int b = C2(x) + C2(n + 1 - x);
x -= 2;
long long int c = C2(x) + C2(n + 1 - x);
return min(a, min(b, c));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
for (int i = 0; i < (m); ++i) cin >> x[i] >> d[i];
long long int sum = 0;
for (int i = 0; i < (m); ++i) sum += x[i] * n;
for (int i = 0; i < (m); ++i)
if (d[i] >= 0)
sum += d[i] * C2(n);
else
sum += d[i] * (func(n));
cout << fixed << setprecision(18) << (long double)sum / (long double)n
<< '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 123456;
int n, l, x, y, ai[maxn];
void init() {
for (int i = 1; i <= n; i++) scanf("%d", &ai[i]);
}
int brs(int l, int r, int now, int t) {
while (l <= r) {
int mid = (l + r) / 2;
if (now - ai[mid] == t) {
return 1;
}
if (now - ai[mid] > t) {
l = mid + 1;
} else {
r = mid - 1;
}
}
return 0;
}
void DYGANDQYM() {
int p1 = 0;
int p2 = 0;
for (int i = 2; i <= n; i++) {
int t1 = brs(1, i - 1, ai[i], x);
int t2 = brs(1, i - 1, ai[i], y);
if (t1 == 1) {
p1 = -1;
}
if (t2 == 1) {
p2 = -1;
}
}
if (p1 == -1 && p2 == -1)
printf("0\n");
else if (p1 == -1) {
printf("1\n");
printf("%d\n", l - y);
} else if (p2 == -1) {
printf("1\n");
printf("%d\n", l - x);
} else {
int idx = -1;
for (int i = 2; i <= n; i++) {
int t1 = brs(1, i - 1, ai[i], x + y);
int t2 = brs(1, i - 1, ai[i], y - x);
if (t1 == 1) {
idx = i;
break;
}
if (t2 == 1) {
long long aa = ai[i];
if (aa - y >= 0 || aa + x <= l) {
idx = i;
break;
}
}
}
if (idx == -1) {
printf("2\n");
printf("%d %d\n", l - x, l - y);
} else {
printf("1\n");
long long tt = ai[idx];
if (tt - y >= 0) {
printf("%d\n", ai[idx] - y);
} else {
printf("%d\n", ai[idx] + x);
}
}
}
}
int main() {
while (scanf("%d%d%d%d", &n, &l, &x, &y) != EOF) {
init();
DYGANDQYM();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, nn;
int xiao[20], a[20], b[20], f[20], ge[(1 << 16)];
long long K, h[(1 << 16)];
inline long long suan() {
int i, j;
memset(h, 0, sizeof(h));
h[0] = 1;
for (i = 0; i <= nn - 1; i++)
if (h[i]) {
int A = ge[i] + 1;
for (j = 1; j <= n; j++)
if (!(i >> j - 1 & 1) && (!f[A] || f[A] == j)) {
if ((xiao[j] | i) > i) continue;
int B = i | 1 << j - 1;
h[B] += h[i];
}
}
return h[nn];
}
void dfs(int x) {
if (x > n) {
int i;
for (i = 1; i <= n; i++) printf("%d ", b[i]);
printf("\n");
exit(0);
}
long long A = suan();
if (A < K) {
K -= A;
return;
}
int i;
for (i = 1; i <= n; i++)
if (!f[i]) {
f[i] = x;
b[x] = i;
dfs(x + 1);
f[i] = 0;
}
}
int main() {
scanf("%d%I64d%d", &n, &K, &m);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
xiao[y] |= 1 << x - 1;
}
K -= 2000;
nn = (1 << n) - 1;
for (i = 0; i <= nn; i++)
for (j = 0; j <= n - 1; j++) ge[i] += i >> j & 1;
dfs(1);
printf("The times have changed\n");
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int ax, ay;
char f[12][12];
bool flag = false;
for(int y=0 ; y<12 ; y++){
for(int x=0 ; x<12 ; x++){
f[y][x] = 0;
}
}
while( 1 ){
for(int i=0 ; i<8 ; i++) {
if( scanf("%s", f[i]) == EOF ){
flag = true;
break;
}
}
if(flag) break;
for(int i=0 ; i<64 ; i++){
if(f[i/8][i%8]=='1'){
ax = i%8;
ay = i/8;
break;
}
}
if( f[ay+1][ax]=='1' && f[ay][ax+1]=='1' && f[ay+1][ax+1]=='1' ){
printf("A\n");
}else if( f[ay+1][ax]=='1' && f[ay+2][ax]=='1' && f[ay+3][ax]=='1' ){
printf("B\n");
}else if( f[ay][ax+1]=='1' && f[ay][ax+2]=='1' && f[ay][ax+3]=='1' ){
printf("C\n");
}else if( f[ay][ax+1]=='1' && f[ay+1][ax+1]=='1' && f[ay+1][ax+2]=='1' ){
printf("E\n");
}else if( f[ay+1][ax]=='1' && f[ay+1][ax+1]=='1' && f[ay+2][ax+1]=='1' ){
printf("F\n");
}else if( f[ay][ax+1]=='1' && f[ay+1][ax]=='1' && f[ay+1][ax-1]=='1' ){
printf("G\n");
}else if( f[ay+2][ax-1]=='1' && f[ay+1][ax]=='1' && f[ay+1][ax-1]=='1' ){
printf("D\n");
}
}
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.