solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int n, m, pos, deg[110], mat[110][110], stack[110] = {-1};
void find() {
int i;
pos = 0;
for (i = 1; i <= n; i++)
if (deg[i] == 1) {
stack[pos++] = i;
}
return;
}
void update() {
int i, j, k;
for (k = 0; k < pos; k++) {
i = stack[k];
deg[i] = 0;
for (j = 1; j <= n; j++)
if (mat[i][j] == 1) {
deg[j]--;
mat[i][j] = mat[j][i] = 0;
}
}
return;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
int i, j, a, b, res = 0;
memset(deg, 0, sizeof(deg));
memset(mat, 0, sizeof(mat));
for (i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
deg[a]++;
deg[b]++;
mat[a][b] = mat[b][a] = 1;
}
for (i = 1; i <= n * (n - 1) / 2; i++) {
find();
if (pos == 0) break;
update();
res++;
}
printf("%d\n", res);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long fi = 13, g;
bool s[1000000];
bool f1(long long n) {
if (n == 2) return 1;
if (n % 2 == 0 || n < 2) return 0;
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return 0;
}
}
s[n] = 1;
return 1;
}
long long f2(long long n) {
long long gg = 0;
while (n >= 1) {
gg *= 10;
gg += n % 10;
n /= 10;
}
return gg;
}
int main() {
cin >> n;
s[1] = 0;
s[2] = 1;
for (int i = 0; i < n; fi += 2) {
if (f1(fi) == 1) {
g = f2(fi);
if (((g < fi) && (s[g] == 1)) || ((g > fi) && (f1(g) == 1))) {
i++;
if (i == n) {
cout << fi;
return 0;
}
}
}
}
}
| 4 |
#include <cstdio>
#include <vector>
int cs[200005];
int inv[200005];
bool vis[200005];
std::vector<std::pair<int,int> > moves;
void flip(int x,int y){
moves.push_back({x,y});
std::swap(cs[x],cs[y]);
std::swap(inv[cs[x]],inv[cs[y]]);
}
void gobble(int x,int y){
//x and y are in same cycle and have wrong parity
while(cs[x]!=y){
flip(x,cs[x]);
}
while(cs[y]!=x){
flip(y,cs[y]);
}
flip(x,y);
}
int main(){
int N;
scanf("%d",&N);
for(int i=1;i<=N;i++){
scanf("%d",&cs[i]);
inv[cs[i]]=i;
}
std::vector<int> cycles;
for(int i=1;i<=N;i++){
if(!vis[i]){
for(int j=i;!vis[j];j=cs[j]){
vis[j]=true;
}
if(i!=cs[i]){
cycles.push_back(i);
}
}
}
while(cycles.size()>=2){
int x=cycles.back();
cycles.pop_back();
int y=cycles.back();
cycles.pop_back();
flip(x,y);
gobble(x,y);
}
if(cycles.size()>=1){
int x=cycles.back();
cycles.pop_back();
if(cs[cs[x]]==x){
//length 2
int y=1;
while(y==x||y==cs[x]) y++;
flip(x,y);
gobble(x,y);
}else{
int y=cs[x];
int z=cs[y];
flip(y,z);
flip(x,z);
gobble(y,z);
}
}
printf("%d\n",(int)moves.size());
for(auto m:moves){
printf("%d %d\n",m.first,m.second);
}
}
| 10 |
#include <bits/stdc++.h>
double pi = 3.1415926535897932384626433832795028841971693993751;
using namespace std;
int a[1000000], b[1000000];
vector<int> s[100005];
int k = 0;
int main() {
long long n;
int k;
scanf("%lld %d", &n, &k);
long long k1 = n;
int c1 = 0, c = 0, c2 = -1, res = -1;
while (k1 != 0) {
if (k1 % 10 == 0) c1++;
if (c1 == 1 && c2 == -1) c2 = c;
k1 = k1 / 10;
c++;
if (c1 == k && res == -1) res = c - c1;
}
if (n == 0) c++;
if (res >= 0)
printf("%d\n", res);
else {
printf("%d\n", c - 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Dummyf {
template <typename... Ts>
void operator()(Ts&&...) {}
};
struct Graph {
template <typename Pre = Dummyf, typename Post = Dummyf,
typename PreE = Dummyf, typename PostE = Dummyf,
typename FailE = Dummyf>
void allDFS(Pre pre, Post post, PreE pree, PostE poste, FailE faile) const {
auto visit = vector<bool>(size(), false);
for (auto v = 0; v < size(); ++v)
if (not visit[v]) implDFS(v, visit, pre, post, pree, poste, faile);
}
template <typename Pre = Dummyf, typename Post = Dummyf,
typename PreE = Dummyf, typename PostE = Dummyf,
typename FailE = Dummyf>
void implDFS(int v, vector<bool>& visit, Pre pre, Post post, PreE pree,
PostE poste, FailE faile) const {
visit[v] = true;
pre(v);
for (auto u : edges[v])
if (not visit[u])
pree(v, u), implDFS(u, visit, pre, post, pree, poste, faile),
poste(v, u);
else
faile(v, u);
post(v);
}
Graph(int n) : edges(n) {}
void addEdge1(int a, int b) { edges[a].push_back(b); }
void addEdge2(int a, int b) {
addEdge1(a, b);
addEdge1(b, a);
}
int size() const { return (int)edges.size(); }
vector<vector<int>> edges;
};
template <typename T>
T load() {
T r;
cin >> r;
return r;
}
template <typename T>
vector<T> loadMany(int n) {
vector<T> rs(n);
generate(rs.begin(), rs.end(), &load<T>);
return rs;
}
struct FU {
FU(int n) : link(n, -1), rank(n, 0) {}
int find(int i) const {
return link[i] == -1 ? i : (link[i] = find(link[i]));
}
bool tryUnion(int a, int b) {
a = find(a), b = find(b);
if (a == b) return false;
if (rank[a] < rank[b]) swap(a, b);
if (rank[a] == rank[b]) ++rank[a];
link[b] = a;
return true;
}
mutable vector<int> link;
vector<int> rank;
};
template <typename C, bool invert>
vector<C> dft(vector<C> a) {
using R = typename C::value_type;
auto n = (int)a.size();
for (auto i = 1, j = 0; i < n; ++i) {
auto bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
auto pi = acos((R)-1);
for (auto l = 2; l <= n; l <<= 1) {
auto angle = (invert ? -1 : 1) * 2 * pi / l;
auto wl = polar<R>(1, angle);
for (auto i = 0; i < n; i += l) {
auto w = (C)1;
for (auto j = 0; j < l / 2; ++j) {
auto y0 = a[i + j];
auto y1 = a[i + j + l / 2] * w;
a[i + j] = y0 + y1;
a[i + j + l / 2] = y0 - y1;
w *= wl;
}
}
}
if (invert)
for (auto& ai : a) ai /= n;
return a;
}
template <typename C>
vector<C> fft(vector<C> a, vector<C> b) {
auto n = 1;
while (n < (int)a.size() + (int)b.size() - 1) n *= 2;
a.resize(n, 0);
b.resize(n, 0);
a = dft<C, false>(move(a));
b = dft<C, false>(move(b));
for (auto i = 0; i < n; ++i) a[i] *= b[i];
a = dft<C, true>(move(a));
return a;
}
using C = complex<float>;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto txt = load<string>();
auto pat = load<string>();
auto n = (int)pat.size();
auto m = (int)txt.size();
auto total = vector<int>(m - n + 1, 0);
auto graphs = vector<array<array<bool, 6>, 6>>(m - n + 1);
for (auto k = 0; k < m - n + 1; ++k)
for (auto i1 = 0; i1 < 6; ++i1)
for (auto i2 = 0; i2 < 6; ++i2) graphs[k][i1][i2] = false;
for (auto chr1 = 'a'; chr1 <= 'f'; ++chr1) {
for (auto chr2 = (char)'a'; chr2 <= 'f'; ++chr2) {
auto ind1 = (int)(chr1 - 'a');
auto ind2 = (int)(chr2 - 'a');
if (ind1 > ind2)
swap(ind1, ind2);
else if (ind1 == ind2)
continue;
auto a = vector<C>(n);
auto b = vector<C>(m);
for (auto i = 0; i < n; ++i) a[i] = pat[n - 1 - i] == chr1;
for (auto i = 0; i < m; ++i) b[i] = txt[i] == chr2;
auto c = fft(move(a), move(b));
for (auto k = 0; k < m - n + 1; ++k)
graphs[k][ind1][ind2] |= c[n - 1 + k].real() > 0.5;
}
}
for (auto k = 0; k < m - n + 1; ++k) {
auto graph = Graph(6);
for (auto v = 0; v < 6; ++v)
for (auto u = v + 1; u < 6; ++u)
if (graphs[k][v][u]) graph.addEdge2(v, u);
auto total = 0;
graph.allDFS({}, {}, [&](int, int) { ++total; }, {}, {});
cout << total << ' ';
}
cout << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
vector<int> g[MAXN + 1];
bool vis[MAXN + 1];
long long ans;
void fast_io() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool lucky(int n) {
int rem;
while (n) {
rem = (n % 10);
if (rem != 4 and rem != 7) return false;
n /= 10;
}
return true;
}
int dfs(int u) {
vis[u] = true;
int sz = 1;
for (auto v : g[u])
if (!vis[v]) sz += dfs(v);
return sz;
}
int main() {
fast_io();
int n, u, v, w, x;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v >> w;
if (lucky(w)) continue;
g[u].push_back(v);
g[v].push_back(u);
}
ans = 1LL * n * (n - 1) * (n - 2);
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
x = dfs(i);
if (x == 1) continue;
ans -= (1LL * x * (x - 1) * (x - 2));
ans -= (1LL * x * (x - 1) * (n - x)) << 1;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
string s;
const int N = 1e6 + 1, mod = 1e9 + 7;
int pw[N], has[N], x, y, z;
void check(int i1, int i2) {
if (i1 < 1 || i1 >= i2) return;
if (s[1] == '0' && i1 > 1) return;
if (s[i1 + 1] == '0' && i2 - i1 > 1) return;
x = has[i1];
y = has[i2] - has[i1] * 1ll * pw[i2 - i1] % mod;
if (y < 0) y += mod;
if ((x + y) % mod == z) {
cout << s.substr(1, i1) + '+' + s.substr(i1 + 1, i2 - i1) + '=' +
s.substr(i2 + 1);
exit(0);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
int n = ((int)(s).size());
s = '0' + s;
pw[0] = 1;
for (int i = (1); i <= (n); ++i) pw[i] = pw[i - 1] * 1ll * 10 % mod;
for (int i = (1); i <= (n); ++i)
has[i] = (has[i - 1] * 1ll * 10 + s[i] - '0') % mod;
for (int i = (1); i <= (n - 1); ++i) {
int len = n - i;
if (s[i + 1] == '0' && len > 1) continue;
z = has[n] - has[i] * 1ll * pw[len] % mod;
if (z < 0) z += mod;
check(len, i);
check(len - 1, i);
check(i - len, i);
check(i - len + 1, i);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long x, long long y) {
if (y == 0) return x;
return GCD(y, x % y);
}
long long LCM(long long x, long long y) { return (x * y) / GCD(x, y); }
long long MPOW(long long a, long long b, long long m = LLONG_MAX) {
if (b == 0) return 1;
long long x = MPOW(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1) x = (x * a) % m;
return x;
}
long long MINV(long long a, long long m) { return MPOW(a, m - 2, m); }
inline long long max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline long long min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline bool sortbythis(pair<long long, long long> a,
pair<long long, long long> b) {
return (((a.first == b.first) && (a.second < b.second)) ||
(a.first < b.first));
}
inline bool sortbythat(pair<long long, long long> a,
pair<long long, long long> b) {
return (((a.second == b.second) && (a.first < b.first)) ||
(a.second < b.second));
}
class pnc {
long long FACT_MAX, MODU;
vector<long long> fact;
public:
pnc(long long n, long long m) {
FACT_MAX = n;
fact.resize(FACT_MAX);
MODU = m;
MFACT_INIT(MODU);
}
void MFACT_INIT(long long m) {
fact[0] = 1;
for (long long i = 1; i < FACT_MAX; ++i) fact[i] = (i * fact[i - 1]) % MODU;
}
long long MFACT(long long n) { return fact[n]; }
long long PERM(long long n, long long r) {
return (fact[n] * ::MINV(fact[n - r], MODU)) % MODU;
}
long long COMB(long long n, long long r) {
return (PERM(n, r) * ::MINV(fact[r], MODU)) % MODU;
}
};
void dfs(vector<vector<long long> > &graph, long long pos, vector<bool> &visit,
string &thestring) {
visit[pos] = true;
thestring.push_back('a' + pos);
for (auto x : graph[pos])
if (!visit[x]) dfs(graph, x, visit, thestring);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long TEST = 1;
cin >> TEST;
while (TEST--) {
string s;
cin >> s;
if (s.size() == 1) {
cout << "YES\n";
cout << s[0];
for (long long i = 0; i < 26; ++i)
if ('a' + i != s[0]) cout << (char)(i + 'a');
cout << '\n';
continue;
}
vector<vector<long long> > graph(26);
for (long long i = 0; i < s.size() - 1; ++i) {
bool shouldi = true;
for (auto x : graph[s[i] - 'a'])
shouldi &= (x != (long long)(s[i + 1] - 'a'));
if (shouldi) {
graph[s[i] - 'a'].push_back(s[i + 1] - 'a');
graph[s[i + 1] - 'a'].push_back(s[i] - 'a');
}
}
bool ans = true;
for (long long i = 0; i < 26; ++i) {
if (graph[i].size() > 2) {
ans = false;
break;
}
}
string thestring;
if (ans) {
vector<bool> visit(26, false);
bool istwo = false;
bool isone = false;
for (long long i = 0; i < 26; ++i) {
if (!visit[i]) {
if (graph[i].size() == 0) {
visit[i] = true;
thestring.push_back('a' + i);
} else if (graph[i].size() == 2)
continue;
else {
isone = true;
if (istwo) {
ans = false;
break;
} else {
istwo = true;
dfs(graph, i, visit, thestring);
}
}
}
}
ans &= isone;
}
if (ans)
cout << "YES\n" << thestring << '\n';
else
cout << "NO\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string str;
int len;
bool ans;
int main() {
cin >> str;
len = str.length();
ans = false;
for (int i = 1; i < len - 1; i++) {
if (str[i - 1] != '.' && str[i] != '.' && str[i + 1] != '.' &&
str[i - 1] != str[i] && str[i + 1] != str[i] &&
str[i + 1] != str[i - 1]) {
ans = true;
break;
}
}
if (ans)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end(), greater<long long>());
bool ok = true;
for (long long i = 0; i < n; i++) {
ok &= a[i] + b[i] <= m;
}
cout << (ok ? "Yes" : "No") << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void FAST_IO() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long h, n;
long long count(long long lo, long long hi, bool past_left, long long height) {
if (lo == hi) return 0;
long long mid = (lo + hi) / 2;
long long ret = 0;
if (past_left) {
if (n >= lo && n <= mid)
ret = count(lo, mid, true, height + 1) + (1LL << (h - height));
else
ret = count(mid + 1, hi, false, height + 1) + 1;
} else {
if (n >= lo && n <= mid)
ret = count(lo, mid, true, height + 1) + 1;
else
ret = count(mid + 1, hi, false, height + 1) + (1LL << (h - height));
}
return ret;
}
int main() {
FAST_IO();
cin >> h >> n;
cout << count(1, 1LL << h, false, 0) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
double ans = 1000.0;
for (int i = 0; i < n; i++) {
double a, b;
cin >> a >> b;
ans = min(ans, a / b);
}
cout << fixed;
cout << setprecision(10) << (double)m * ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
int n;
long long elm;
int cnt = 1;
cin >> n;
long long sum = 0;
for (int i = 0; i < n; ++i) {
cin >> elm;
v.push_back(elm);
}
sort(v.begin(), v.end());
sum = v[0];
for (int i = 1; i < n; ++i) {
if (v[i] >= sum) {
++cnt;
sum += v[i];
}
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
while (a != 0 && b != 0) {
if (a >= 2 * b)
a = a % (2 * b);
else if (b >= 2 * a)
b = b % (2 * a);
else
break;
}
cout << a << " " << b;
}
| 1 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
using namespace std;
int cx[4] = {0, 0, 1, -1};
int cy[4] = {-1, 1, 0, 0};
string Yes[2] = {"No\n", "Yes\n"};
string YES[2] = {"NO\n", "YES\n"};
string Possible[2] = {"Impossible\n", "Possible\n"};
string POSSIBLE[2] = {"IMPOSSIBLE\n", "POSSIBLE\n"};
const int N = 696969;
int go[N][26];
int link[N];
int interest_link[N];
int sz = 1;
set<pair<int, int>, greater<pair<int, int> > > term[N];
int where[N];
int cur[N];
int hehe[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int pnt = 0;
for (int j = 0; j < s.size(); j++) {
int x = s[j] - 'a';
if (go[pnt][x] == 0) go[pnt][x] = sz++;
pnt = go[pnt][x];
}
where[i] = pnt;
term[pnt].insert({0, i});
}
vector<int> q = {0};
for (int i = 0; i < q.size(); i++) {
for (int j = 0; j < 26; j++) {
if (go[q[i]][j] != 0) {
int b = link[q[i]];
int d = j;
while (b != 0 && go[b][d] == 0) {
b = link[b];
}
if (go[b][d] != go[q[i]][j]) link[go[q[i]][j]] = go[b][d];
q.push_back(go[q[i]][j]);
}
}
}
for (auto i : q) {
int j = link[i];
if (term[j].size())
interest_link[i] = j;
else
interest_link[i] = interest_link[j];
}
int f = 0;
while (m--) {
int t;
cin >> t;
if (t == 1) {
int i, x;
cin >> i >> x;
i--;
int wh = where[i];
term[wh].erase({cur[i], i});
cur[i] = x;
term[wh].insert({cur[i], i});
} else {
f++;
int pnt = 0;
string s;
cin >> s;
int ans = -1;
for (int i = 0; i < s.size(); i++) {
int x = s[i] - 'a';
int pnt2 = pnt;
while (hehe[pnt2] != f && pnt2 != 0) {
if (term[pnt2].size()) {
auto it = term[pnt2].begin();
ans = max(ans, (*it).first);
}
hehe[pnt2] = f;
pnt2 = interest_link[pnt2];
}
int old = pnt;
while (pnt != 0 && go[pnt][x] == 0) pnt = link[pnt];
go[old][x] = go[pnt][x];
pnt = go[pnt][x];
if (term[pnt].size()) {
auto it = term[pnt].begin();
ans = max(ans, (*it).first);
}
}
while (pnt != 0) {
pnt = link[pnt];
if (term[pnt].size()) {
auto it = term[pnt].begin();
ans = max(ans, (*it).first);
}
}
cout << ans << "\n";
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int s1[n];
int s2[m];
int check = false;
for (int i = 0; i < n; ++i) {
cin >> s1[i];
}
for (int i = 0; i < m; ++i) {
cin >> s2[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (s1[i] == s2[j]) {
cout << s1[i] << " ";
check = true;
}
}
}
if (check == false) cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long INF = 1e9;
inline long long bpow(long long t, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * t) % mod;
t = (t * t) % mod, n >>= 1;
}
return ans;
}
int a[MAX_N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(0);
int n;
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> a[i];
int ans = INF;
for (int i = 1; i <= 2 * n; i++)
for (int j = i + 1; j <= 2 * n; j++) {
vector<int> vec;
for (int k = 1; k <= 2 * n; k++)
if (k != i && k != j) vec.push_back(a[k]);
sort(begin(vec), end(vec));
int sum = 0;
for (int i = 0; i < 2 * (n - 1) - 1; i += 2)
sum += abs(vec[i] - vec[i + 1]);
ans = min(ans, sum);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
using namespace std;
template <class T>
inline void sort(T &a) {
sort((a).begin(), (a).end());
}
template <class T>
inline void rsort(T &a) {
sort((a).rbegin(), (a).rend());
}
template <class T>
inline void reverse(T &a) {
reverse((a).begin(), (a).end());
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
srand(time(NULL));
long long n, m;
cin >> n >> m;
vector<long long> arr(n), brr(m);
for (auto &i : arr) cin >> i;
for (auto &j : brr) cin >> j;
long long x;
cin >> x;
vector<pair<long long, long long> > aarr, bbrr;
for (int i = 0; i < n; ++i) {
long long curr = 0;
for (int k = i; k < n; ++k)
curr += arr[k], aarr.push_back(make_pair(k - i + 1, curr));
}
sort(aarr);
map<long long, long long> st;
for (int i = 0; i < m; ++i) {
long long curr = 0;
for (int k = i; k < m; ++k) {
curr += brr[k];
if (st.count(k - i + 1)) {
if (st[k - i + 1] > curr) st[k - i + 1] = curr;
} else
st[k - i + 1] = curr;
}
}
for (auto i : st) bbrr.push_back(make_pair(i.second, i.first));
sort(bbrr);
long long ans = 0;
for (auto i : aarr) {
long long l = -1, r = int(bbrr.size());
while (r - l > 1) {
long long m = r + l >> 1;
if (x / bbrr[m].first >= i.second)
l = m;
else
r = m;
}
if (l >= 0)
if (ans < bbrr[l].second * i.first) ans = bbrr[l].second * i.first;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
int f, s;
cin >> s >> f;
--f;
--s;
int tot1 = 0;
for (int i = s; i < f; ++i) tot1 += a[i];
int best = tot1;
int bestd = 0;
for (int d = 1; d < n; ++d) {
tot1 -= a[(f - d + n) % n];
tot1 += a[(s - d + n) % n];
if (tot1 > best) {
best = tot1;
bestd = d;
}
}
cout << bestd + 1 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
vector<int> dvs;
int fpow(int n, int k, int p) {
int r = 1;
for (; k; k >>= 1) {
if (k & 1) r = (long long)r * n % p;
n = (long long)n * n % p;
}
return r;
}
int primitiveroot(int p) {
dvs.clear();
for (int i = 2; i * i < p; i++) {
if ((p - 1) % i) continue;
dvs.push_back(i);
if (i * i != p - 1) dvs.push_back((p - 1) / i);
}
for (int i = 2; i < p; i++) {
int flag = 1;
for (int j = 0; j < dvs.size(); j++) {
if (fpow(i, dvs[j], p) == 1) {
flag = 0;
break;
}
}
if (flag) return i;
}
}
const int maxn = 4e5 + 5;
int n;
int a[maxn];
int ispr(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
void solve() {
srand(time(NULL));
cin >> n;
string s;
cin >> s;
for (int i = (0); i < (n); i++) a[i] = s[i] - '0';
while (1.0 * clock() / CLOCKS_PER_SEC < 0.8) {
int st = INF + rand();
while (st % n != 1 || !ispr(st)) st++;
int p = st;
int w = primitiveroot(p);
w = fpow(w, (p - 1) / n, p);
int r = 0;
for (int i = (0); i < (n); i++) {
r = mult(r, w, p);
addmod(r, a[i], p);
}
if (r) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
int JUDGE_ONLINE = 1;
if (fopen("in.txt", "r")) {
JUDGE_ONLINE = 0;
assert(freopen("in.txt", "r", stdin));
} else {
ios_base::sync_with_stdio(0), cin.tie(0);
}
solve();
if (!JUDGE_ONLINE) {
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int INF = 1E9;
const int MAXN = 100500;
const int MOD = (int)1E9 + 7;
void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int n, m;
vector<int> a[MAXN];
vector<int> where[MAXN];
int used[MAXN], useda[MAXN];
int put[MAXN];
int ans, mult;
vector<int> st[2], sgn[2];
vector<int> cur[2], dp[2];
vector<int> f[2][2][2];
int collect[2];
vector<int> indexes;
void add() {
assert(st[0].size() >= 1);
assert(st[0].size() == st[1].size());
for (int i = 0; i < (int)(2); i++) {
sgn[i].clear();
sgn[i].resize(st[i].size(), 0);
for (int j = 0; j < (int)(st[i].size()); j++)
if (st[i][j] < 0) {
sgn[i][j] = 1;
st[i][j] *= -1;
}
}
int curAns[2], tmpAns[2];
for (int i = 0; i < (int)(2); i++) curAns[i] = 0;
for (int v1 = 0; v1 < (int)(2); v1++)
for (int v2 = 0; v2 < (int)(2); v2++) {
for (int i = 0; i < (int)(2); i++)
for (int j = 0; j < (int)(st[i].size()); j++) put[st[i][j]] = -1;
if (st[0][0] == 0 && v1) continue;
if (st[1][0] == 0 && v2) continue;
put[st[0][0]] = v1;
if (put[st[1][0]] != -1 && put[st[1][0]] != v2) continue;
put[st[1][0]] = v2;
for (int i = 0; i < (int)(2); i++)
for (int j = 0; j < (int)(2); j++)
for (int k = 0; k < (int)(2); k++) {
f[i][j][k].clear();
f[i][j][k].resize(st[0].size(), 0);
}
f[v1][v2][(sgn[0][0] ^ v1) || (sgn[1][0] ^ v2)][0] = 1;
for (int i = 0; i < (int)st[0].size() - 1; i++) {
for (int l1 = 0; l1 < (int)(2); l1++)
for (int l2 = 0; l2 < (int)(2); l2++)
for (int res = 0; res < (int)(2); res++)
if (f[l1][l2][res][i]) {
put[st[0][i]] = l1;
put[st[1][i]] = l2;
for (int w1 = 0; w1 < (int)(2); w1++)
for (int w2 = 0; w2 < (int)(2); w2++) {
if (put[st[0][i + 1]] != -1 && put[st[0][i + 1]] != w1)
continue;
if (put[st[1][i + 1]] != -1 && put[st[1][i + 1]] != w2)
continue;
if (st[0][i + 1] == 0 && w1) continue;
if (st[1][i + 1] == 0 && w2) continue;
add(f[w1][w2][res ^ ((sgn[0][i + 1] ^ w1) ||
(sgn[1][i + 1] ^ w2))][i + 1],
f[l1][l2][res][i]);
}
}
}
for (int i = 0; i < (int)(2); i++) tmpAns[i] = 0;
for (int l1 = 0; l1 < (int)(2); l1++)
for (int l2 = 0; l2 < (int)(2); l2++)
for (int res = 0; res < (int)(2); res++)
add(tmpAns[res], f[l1][l2][res][st[0].size() - 1]);
for (int i = 0; i < (int)(2); i++) {
add(curAns[i], tmpAns[i]);
}
}
for (int i = 0; i < (int)(2); i++) {
cur[i].push_back(curAns[i]);
}
}
void dfs1(int id, int v) {
useda[id] = 1;
used[v] = 1;
assert(!where[v].empty());
for (int i = 0; i < (int)(a[id].size()); i++) st[i].push_back(a[id][i]);
if (st[0].size() > st[1].size()) st[1].push_back(0);
for (auto ww : a[id]) {
int w = abs(ww);
if (!used[w]) {
used[w] = 1;
for (auto id2 : where[w])
if (!useda[id2]) dfs1(id2, w);
}
}
for (auto id2 : where[v]) {
if (!useda[id2]) {
dfs1(id2, v);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(n); i++) {
int k;
scanf("%d", &k);
a[i].resize(k);
for (int j = 0; j < (int)(k); j++) {
scanf("%d", &a[i][j]);
where[abs(a[i][j])].push_back(i);
}
}
mult = 1;
for (int i = (int)(1); i < (int)(m + 1); i++)
if (where[i].empty()) {
used[i] = 1;
mult = (mult * 2) % MOD;
}
for (int i = (int)(1); i < (int)(m + 1); i++)
if (!used[i]) {
for (int j = 0; j < (int)(2); j++) st[j].clear();
for (auto id : where[i]) {
if (!useda[id]) {
dfs1(id, i);
}
}
add();
}
for (int i = 0; i < (int)(2); i++) dp[i].resize(cur[i].size() + 1, 0);
dp[0][0] = 1;
dp[1][0] = 0;
for (int i = 0; i < (int)cur[0].size(); i++) {
for (int f = 0; f < (int)(2); f++)
for (int nf = 0; nf < (int)(2); nf++)
add(dp[f ^ nf][i + 1], 1ll * dp[f][i] * cur[nf][i] % MOD);
}
ans = dp[1][cur[0].size()];
ans = (1ll * ans * mult) % MOD;
cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &tx) {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
tx = x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
int F[200001], v[200001], n, a, b;
map<int, int> mp;
inline int get(int x) { return x == F[x] ? x : F[x] = get(F[x]); }
inline void merge(int x, int y) {
int tx = get(x), ty = get(y);
if (tx == ty) return;
F[tx] = ty;
}
int main() {
read(n);
read(a);
read(b);
mp.clear();
for (int i = 1; i <= n; i++) {
read(v[i]);
mp[v[i]] = i;
}
for (int i = 1; i <= n + 2; i++) F[i] = i;
for (int i = 1; i <= n; i++) {
if (mp[a - v[i]])
merge(i, mp[a - v[i]]);
else
merge(i, n + 2);
if (mp[b - v[i]])
merge(i, mp[b - v[i]]);
else
merge(i, n + 1);
}
if (get(n + 1) == get(n + 2)) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; i++)
if (get(i) == get(n + 1))
printf("0 ");
else
printf("1 ");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int tiendienluckhonglamviec(int start, int end, int t1, int t2, int p1, int p2,
int p3) {
int time = end - start;
int sowat = 0;
if (time > t1) {
sowat = t1 * p1;
} else
return time * p1;
if (time > t1 + t2) {
sowat = t1 * p1 + t2 * p2 + (time - t1 - t2) * p3;
} else
return sowat + (time - t1) * p2;
return sowat;
}
struct Time {
int n;
int p1;
int p2;
int p3;
int t1;
int t2;
};
int main() {
Time r;
int start;
int end;
int endcu = 0;
cin >> r.n >> r.p1 >> r.p2 >> r.p3 >> r.t1 >> r.t2;
int sum = 0;
for (int i = 0; i < r.n; i++) {
cin >> start >> end;
if (i == 0) endcu = start;
sum = sum +
tiendienluckhonglamviec(endcu, start, r.t1, r.t2, r.p1, r.p2, r.p3) +
(end - start) * r.p1;
endcu = end;
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e7 + 8;
int spf[MAXN];
void sieve() {
spf[1] = 1;
for (int i = 2; i < MAXN; i++) spf[i] = i;
for (int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (int j = i * i; j < MAXN; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
sieve();
while (t--) {
int n;
cin >> n;
vector<int> ans1(n, -1), ans2(n, -1);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
int temp = x;
vector<int> fac;
while (x != 1) {
fac.push_back(spf[x]);
x /= spf[x];
}
fac.resize(unique((fac).begin(), (fac).end()) - fac.begin());
if (fac.size() > 1) {
int p1 = 1, p2 = 1;
for (auto j : fac) p1 *= j;
p1 /= fac.back();
p2 *= fac.back();
ans1[i] = p1, ans2[i] = p2;
}
}
for (auto& i : ans1) cout << i << " ";
cout << '\n';
for (auto& i : ans2) cout << i << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long a[30];
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long added = a[n - 1];
long long net = added;
for (i = n - 2; i >= 0; i--) {
if (a[i] < added) {
net += a[i];
added = a[i];
} else {
if (added >= 1) {
net += added - 1;
added--;
}
}
if (added == 0) {
break;
}
}
cout << net;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<char> ans;
int len, len1, flag;
string s;
int main() {
cin >> s;
len = s.size();
if (len <= 3) {
cout << s[0] << endl;
exit(0);
}
int i = 0, j = len - 1;
while (j - i >= 3) {
if (s[i] == s[j]) {
ans.push_back(s[i]);
i++;
j--;
} else {
if (s[i] == s[j - 1]) {
ans.push_back(s[i]);
i++;
j -= 2;
} else {
ans.push_back(s[i + 1]);
i += 2;
if (s[i + 1] == s[j - 1]) {
j -= 2;
} else
j -= 3;
}
}
}
while (i <= j) {
if (i == j) {
flag = 1;
ans.push_back(s[i]);
}
if (i != j && s[i] == s[j]) ans.push_back(s[i]);
i++;
j--;
}
len1 = ans.size();
if ((!flag && len1 * 2 - 1 < len / 2) || (flag && len1 * 2 < len / 2)) {
cout << "IMPOSSIBLE" << endl;
exit(0);
}
for (int i = 0; i < len1; i++) cout << ans[i];
if (flag) len1--;
for (int i = len1 - 1; i >= 0; i--) cout << ans[i];
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> p[n];
int t = 0;
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p, p + n);
int start = 0, l = 0, r = 0, s = 0;
for (int i = 0; i < 2 * n; i++) {
if (i < n && p[i].first > 0) {
start = 1;
}
if (start) {
l = i - 1;
r = i;
while (1) {
if (l < 0 && r == n) break;
if (l < 0) {
s += p[r].second;
break;
} else if (r == n) {
s += p[l].second;
break;
}
s += p[l--].second + p[r++].second;
}
return cout << s, 0;
}
}
cout << p[n - 1].second << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a1;
char s[5];
int f(int x) { return min(abs(x - 2), abs(x - 3)); }
bool xiaodeng(int x, int y) {
printf("%d %d %d\n", 1, x, y);
fflush(stdout);
scanf("%s", s);
return s[0] == 'T';
}
void check(int a2) {
if (a2 < 1 || a2 > n) return;
if (xiaodeng(a2, a1)) {
printf("%d %d %d\n", 2, a1, a2);
fflush(stdout);
exit(0);
}
}
int erfen(int l, int r) {
if (l >= r) return l;
while (l != r)
if (xiaodeng((l + r >> 1), (l + r >> 1) + 1))
r = (l + r >> 1);
else
l = (l + r >> 1) + 1;
return l;
}
int main() {
scanf("%d%d", &n, &k);
a1 = erfen(1, n);
check(a1 + 1);
check(erfen(a1 + 2, n));
check(a1 - 1);
check(erfen(1, a1 - 2));
}
| 7 |
#include<iostream>
#include<cstring>
#include<cassert>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
#include<bitset>
#include<time.h>
#include<algorithm>
using namespace std;
#define REP(i,x,y) for(ll i=x;i<=y;i++)
#define rep(i,n) REP(i,1,n)
#define rep0(i,n) REP(i,0,n-1)
#define repG(i,x) for(ll i=pos[x];~i;i=e[i].next)
#define ll long long
#define db double
const ll N=3e5+7;
const ll INF=1e9+7;
const ll mod=998244353;
ll Pow(ll x,ll y){
ll ans=1,now=x;
while(y){
if(y&1)ans=ans*now%mod;
now=now*now%mod;
y>>=1;
}
return ans;
}
ll G[2][22][N],F[N],NW[N];
void pre(){
for(ll i=1,u=0;u<18;i<<=1,u++){
ll gn1=Pow(3,(mod-1)/i/2),gn2=Pow(3,mod-1-(mod-1)/i/2),g1=1,g2=1;
rep0(k,i){
G[0][u][k]=g1;
G[1][u][k]=g2;
g1=g1*gn1%mod;
g2=g2*gn2%mod;
}
}
}
void fft(ll *a,ll o,bool s){
for(ll i=1;i<o;i<<=1)rep0(j,i)NW[j+i]=NW[j]+o/i/2;
rep0(i,o)F[i]=a[NW[i]];
for(ll i=1,u=0;i<o;i<<=1,u++){
for(ll j=0;j<o;j+=i*2){
rep0(k,i){
ll x=F[j+k],y=F[i+j+k]*G[s][u][k]%mod;
F[j+k]=(x+y<mod)?x+y:x+y-mod;
F[i+j+k]=(x-y<0)?x-y+mod:x-y;
}
}
}
if(s){
ll iv=Pow(o,mod-2);
rep0(i,o)F[i]=F[i]*iv%mod;
}
rep0(i,o)a[i]=F[i];
}
ll a[N],b[N],fac[N],inv[N],w[N];
ll n,k;
int main(){
pre();
scanf("%lld%lld",&n,&k);
fac[0]=1;
rep(i,k)fac[i]=fac[i-1]*i%mod;
inv[k]=Pow(fac[k],mod-2);
for(ll i=k;i;i--)inv[i-1]=inv[i]*i%mod;
rep(i,k)a[i]=Pow(i,k)*inv[i]%mod;
rep0(i,k+1)b[i]=Pow(mod-1,i)*inv[i]%mod;
ll cc=1;
while(cc<=k+k)cc<<=1;
fft(a,cc,0);
fft(b,cc,0);
rep0(i,cc)a[i]=a[i]*b[i]%mod;
fft(a,cc,1);
w[0]=1;
ll rn=n%mod;
rep0(i,k)w[i+1]=w[i]*(rn-i+mod)%mod;
ll ans=0;
rep0(i,k+1)ans=(ans+w[i]*Pow(rn+1,n-i+mod-1)%mod*a[i])%mod;
printf("%lld\n",ans);
return 0;
} | 12 |
#include <bits/stdc++.h>
using namespace std;
int q, n, x, y, a, b, c, d, minx, miny, maxx, maxy;
bool pom;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> q;
for (int i = 0; i < q; i++) {
cin >> n;
maxx = 1e5;
maxy = 1e5;
minx = -1e5;
miny = -1e5;
pom = 0;
for (int j = 0; j < n; j++) {
cin >> x >> y >> a >> b >> c >> d;
if (!a) {
if (x >= minx) {
minx = x;
} else {
if (!c) {
pom = 1;
}
}
}
if (!b) {
if (y <= maxy) {
maxy = y;
} else {
if (!d) {
pom = 1;
}
}
}
if (!c) {
if (x <= maxx) {
maxx = x;
} else {
if (!a) {
pom = 1;
}
}
}
if (!d) {
if (y >= miny) {
miny = y;
} else {
if (!b) {
pom = 1;
}
}
}
}
if (pom or minx > maxx or miny > maxy) {
cout << 0 << "\n";
} else {
cout << 1 << " " << minx << " " << miny << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct par {
int x, y;
par(int nx = 0, int ny = 0) {
x = nx;
y = ny;
}
friend bool operator<(par a, par b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
};
char wasteChar;
char getch(char &c = wasteChar) {
do {
scanf("%c", &c);
} while (c == ' ' || c == '\n');
return c;
}
int n, sol;
char h[5], f[10];
int main() {
scanf("%d", &n);
scanf("%s", h);
for (int i = 0; i < n; i++) {
scanf("%s", f);
if (h[0] == f[0] && h[1] == f[1] && h[2] == f[2]) ++sol;
if (h[0] == f[5] && h[1] == f[6] && h[2] == f[7]) --sol;
}
if (sol)
printf("contest\n");
else
printf("home\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long h, n, i, s, sb;
cin >> h >> n;
long long a[n];
s = 0, sb = 0;
long long min1 = 1e18;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
sb = s;
if (sb >= 0) sb = 0;
min1 = min(min1, sb);
}
if (s >= 0) {
for (i = 0; i < n; i++) {
h = h + a[i];
if (h <= 0) {
cout << (i + 1) << endl;
return 0;
}
}
cout << -1 << endl;
} else {
for (i = 0; i < n; i++) {
h += a[i];
if (h <= 0) {
cout << (i + 1) << endl;
return 0;
}
}
for (i = 0; i < n; i++) {
h += a[i];
if (h <= 0) {
cout << (i + 1 + n) << endl;
return 0;
}
}
long long ss = s;
if (ss < 0) ss = -ss;
long long x = (h + min1) / (ss) + ((h + min1) % ss != 0);
if (x < 0) x = 0;
if (x > 0) {
h = h + (x * s);
}
for (i = 0; i < n; i++) {
h += a[i];
if (h <= 0) {
cout << (i + 1 + 2 * n + x * n) << endl;
return 0;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 1e3 + 10;
int n, m, a[N];
long long dp[N][N], x;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(dp, inf, sizeof(dp));
dp[n + 1][0] = 0;
for (int i = n; i > 0; i--)
for (int j = 0; j <= n - i + 1; j++) {
dp[i][j] = dp[i + 1][j];
if (j) dp[i][j] = min(dp[i][j], max(dp[i + 1][j - 1] - a[i], 0ll));
}
for (int i = 1; i <= m; i++) {
scanf("%lld", &x);
printf("%d\n", n - (upper_bound(dp[1], dp[1] + n + 1, x) - dp[1] - 1));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int p, i;
cin >> s;
if (s[0] == '-') {
printf("(");
s.erase(0, 1);
s += ")";
}
printf("$");
p = s.find(".");
if (p == -1) {
p = s.size();
if (s[s.size() - 1] == ')') p--;
if (s[s.size() - 1] != ')')
s += ".00";
else {
s.erase(s.size() - 1, 1);
s += ".00)";
}
}
for (i = 0; i < p; i++) {
if (i != 0 && i % 3 == p % 3) printf(",");
cout << s[i];
}
for (i = p; i < p + 3 && i < s.size(); i++)
if (s[i] != ')') cout << s[i];
if (s[i - 1] == ')') i--;
for (; i < p + 3; i++) printf("0");
if (s[s.size() - 1] == ')') printf(")");
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, m;
std::map<int, int> mps[10], tmp[10];
int up10[100];
int s[77000];
void marota() {
std::cin >> n;
up10[0] = 1;
for (int i = 1; i <= 9; i++) up10[i] = up10[i - 1] * 10;
for (int k = 1; k <= n; k++) {
std::cin >> s[k];
for (int i = 0; i <= 9; i++) tmp[i].clear();
for (int i = 1; i <= 9; i++) {
for (int j = i - 1; j >= 0; j--) {
int tmps = (s[k] % up10[i]) / up10[j];
if (!tmp[i - j][tmps]) {
tmp[i - j][tmps] = 1;
mps[i - j][tmps]++;
}
}
}
}
for (int k = 1; k <= n; k++) {
int res = s[k];
int lgs = 9;
for (int i = 1; i <= 9; i++) {
for (int j = i - 1; j >= 0; j--) {
int tmps = (s[k] % up10[i]) / up10[j];
if (mps[i - j][tmps] == 1) {
if (lgs > i - j) {
res = tmps;
lgs = i - j;
}
}
}
}
for (int i = 1; i <= lgs - std::to_string(res).length(); i++) {
std::cout << 0;
}
std::cout << res << "\n";
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
marota();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long get(long long l, long long r) {
long long ans = 0;
while (l % 2) ans ^= (--l);
while (r % 2 == 0) ans ^= (++r);
ans ^= (r - l + 1) / 2 % 2;
return ans;
}
int main() {
scanf("%d", &n);
long long ans = 0;
while (n--) {
long long x, m;
scanf("%lld%lld", &x, &m);
ans ^= get(x, x + m - 1);
}
printf("%s\n", ans ? "tolik" : "bolik");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a[310], nxt[310], v[310], cnt, dp[100010];
long long int t;
bool hd[310];
void calc(int idx, int h) {
cnt++;
t -= (a[idx] * h);
if (nxt[idx]) calc(nxt[idx], h + 1);
v[idx] = a[idx] + v[nxt[idx]];
}
int main() {
ios_base::sync_with_stdio(0);
int q, i, j, b, c;
bool ok = 1;
cin >> n >> q >> t;
for (i = 1; i <= n; i++) {
cin >> a[i];
nxt[i] = v[i] = hd[i] = 0;
}
while (q--) {
cin >> b >> c;
nxt[c] = b;
hd[b] = 1;
}
for (cnt = 0, i = 1; i <= n && ok; i++)
if (hd[i] == 0) calc(i, 0);
if (cnt != n || t < 0)
cout << "0\n";
else {
fill(dp, dp + t + 1, 0);
for (dp[0] = i = 1; i <= n; i++) {
for (j = v[i]; j <= t; j++) {
dp[j] += dp[j - v[i]];
if (dp[j] >= 1000000007) dp[j] -= 1000000007;
}
}
cout << dp[t] << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (n == 1) {
cout << "0\n";
} else {
if (k == 1) {
cout << n - 1 << "\n";
} else {
long long a = 0;
long long cnt = 0;
while (pow(2, a) < k) {
cnt++;
a++;
}
long long x = pow(2, a);
if (n <= x) {
long long p = 0;
long long q = 0;
while (n > 1) {
n = n - pow(2, q);
q++;
p++;
}
cout << p << "\n";
} else {
long long y = n - x;
long long z = y % k;
if (z == 0) {
cout << a + (y / k) << "\n";
} else {
cout << a + (y / k) + 1 << "\n";
}
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100];
int count0 = 0, count1 = 0, i = 0, flag = 0;
cin >> str;
while (str[i] != '\0') {
if (str[i] == '0') {
count0++;
count1 = 0;
if (count0 == 7) {
cout << "YES";
flag = 1;
break;
}
} else {
count1++;
count0 = 0;
if (count1 == 7) {
cout << "YES";
flag = 1;
break;
}
}
i++;
}
if (flag == 0) cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MAX = 100005;
const long double PI = 3.14159265359;
const long double G = 9.807;
const long long INF = 1e18;
const long double EPS = 1e-6;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
bool isprime(long long a) {
if (a == 2) return 1;
if (!(a & 1)) return 0;
for (long long i = 3; i * i <= a; i += 2)
if (a % i == 0) return 0;
return 1;
}
long long mpow(long long base, long long exponent, long long modulus) {
if (modulus == 1) return 0;
long long result = 1;
base = base % modulus;
while (exponent) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
long long minv(long long a, long long mod) {
long long _gcd = gcd(a, mod);
assert(_gcd == 1);
return mpow(a, mod - 2, mod);
}
long long t;
long long n, s;
long long a[MAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> s;
for (int i = 1; i <= n; ++i) cin >> a[i];
multiset<pair<long long, long long> > f;
long long sum = 0;
long long ans = 0;
long long idx = 0;
for (int i = 1; i <= n; ++i) {
f.insert({a[i], i});
sum += a[i];
pair<long long, long long> p = *f.rbegin();
if (sum > s) {
if (sum - p.first <= s) {
if (ans < (long long)f.size() - 1) {
ans = (long long)f.size() - 1;
idx = p.second;
}
}
} else {
if (ans < f.size()) {
ans = f.size();
}
}
}
cout << idx << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int k;
cin >> k;
int n = s.size();
int ans = 0;
for (int i = 0; i < k; i++) {
char a, b;
cin >> a >> b;
int j = 0;
while (j < n) {
int l = 0, r = 0;
while (j < n && (s[j] == a || s[j] == b)) {
if (s[j] == a) l++;
if (s[j] == b) r++;
j++;
}
ans += min(l, r);
j++;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int N, K;
bool special[MAX];
vector<int> adj[MAX];
int sz[MAX];
int calc_size(int source, int father) {
sz[source] = special[source];
for (auto &each : adj[source]) {
if (each != father) {
sz[source] += calc_size(each, source);
}
}
return sz[source];
}
long long ANS = 0;
void roll(int source, int father) {
for (auto &each : adj[source]) {
if (each != father) {
ANS += min(sz[each], 2 * K - sz[each]);
roll(each, source);
}
}
}
int main() {
scanf("%d %d", &N, &K);
int sour;
for (int i = int(0); i < int(2 * K); i++) {
int cur;
scanf("%d", &cur);
special[cur] = true;
sour = cur;
}
for (int i = int(0); i < int(N - 1); i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
calc_size(sour, -1);
roll(sour, -1);
printf("%lld\n", ANS);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505;
int BIT[maxn], A[maxn];
int n, m;
void modify(int j, int n) {
for (; j <= n; j += (j & -j)) BIT[j]++;
}
int prefix_sum(int j) {
int sum = 0;
for (; j > 0; j -= (j & -j)) sum += BIT[j];
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int numInv = 0;
for (int i = n - 1; i >= 0; i--) {
numInv += prefix_sum(A[i]);
modify(A[i], n);
}
numInv %= 2;
cin >> m;
while (m--) {
int li, ri;
cin >> li >> ri;
if ((ri - li + 1) % 4 >= 2) {
numInv ^= 1;
}
cout << (numInv ? "odd" : "even") << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ts, tf, t, a, ans, wait = 1e12 + 5;
int n;
scanf("%lld %lld %lld", &ts, &tf, &t);
scanf("%d", &n);
while (n--) {
scanf("%lld", &a);
if (a <= tf - t) {
if (ts - a + 1 < wait) {
wait = ts - a + 1;
ans = min(ts, a - 1);
}
ts = max(ts, a) + t;
}
}
if (ts <= tf - t) ans = ts;
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c, i, j, k, w, h;
char grid[101][101];
set<char> st;
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) cin >> grid[i];
while (h < n && grid[h][0] == grid[0][0]) h++;
while (w < m && grid[0][w] == grid[0][0]) w++;
if (!((h == n && w * 3 == m) || (h * 3 == n && w == m)))
return cout << "NO", 0;
for (k = 0; k < 3; k++) {
r = (h * k) % n;
c = (w * k) % m;
st.insert(grid[r][c]);
for (i = 0; i < h; i++)
for (j = 0; j < w; j++)
if (grid[r][c] != grid[r + i][c + j]) return cout << "NO", 0;
}
cout << (st.size() < 3 ? "NO" : "YES");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct segtree {
vector<T> tree, lazy;
function<T(T, T)> func;
T def;
int n;
segtree(int n, T def, function<T(T, T)> f) : n(n), func(f), def(def) {
tree.resize(4 * n, def);
lazy.resize(4 * n, def);
};
void push(int s, int e, int ind) {
if (lazy[ind] == def) return;
tree[ind] = func(tree[ind], lazy[ind]);
if (s != e) {
lazy[ind << 1] = func(lazy[ind << 1], lazy[ind]);
lazy[ind << 1 ^ 1] = func(lazy[ind << 1 | 1], lazy[ind]);
}
lazy[ind] = def;
}
void update(int l, int r, T x, int s, int e, int ind) {
push(s, e, ind);
if (l > e || s > r) return;
if (s >= l && e <= r) {
lazy[ind] = x;
push(s, e, ind);
return;
}
int mid = (s + e) >> 1;
update(l, r, x, s, mid, ind << 1);
update(l, r, x, mid + 1, e, ind << 1 | 1);
tree[ind] = func(tree[ind << 1], tree[ind << 1 | 1]);
}
T get(int l, int r, int s, int e, int ind) {
push(s, e, ind);
if (s > r || l > e) return def;
if (s >= l && e <= r) return tree[ind];
int mid = (s + e) >> 1;
return func(get(l, r, s, mid, ind << 1),
get(l, r, mid + 1, e, ind << 1 | 1));
}
void update(int l, int r, T x) {
if (l > r) return;
update(l, r, x, 0, n - 1, 1);
}
T get(int l, int r) { return get(l, r, 0, n - 1, 1); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> a(n), l(m), r(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(((a).begin()), ((a).end()));
vector<int> indices;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
int k = upper_bound(((a).begin()), ((a).end()), r[i]) -
upper_bound(((a).begin()), ((a).end()), l[i] - 1);
if (k == 0) indices.push_back(i);
}
sort(((indices).begin()), ((indices).end()), [&](int i, int j) {
return (l[i] < l[j]) || (l[i] == l[j] && r[i] > r[j]);
});
vector<int> I;
for (int i : indices) {
while (!I.empty()) {
int j = I.back();
if (r[j] >= r[i])
I.pop_back();
else
break;
}
I.push_back(i);
}
int k = I.size();
segtree<long long> st1(k + 1, 1e18,
[](long long x, long long y) { return min(x, y); });
segtree<long long> st2(k + 1, 1e18,
[](long long x, long long y) { return min(x, y); });
vector<int> LL(k + 1, -1.5e9), RR(k + 1, -1.5e9);
for (int i = 0; i < k; i++) LL[i + 1] = l[I[i]], RR[i + 1] = r[I[i]];
vector<long long> dp(k + 1, 1e18);
dp[0] = 0;
for (int i = 0; i <= k; i++) {
long long val0 = min(st2.get(i, i) + 2 * LL[i], st1.get(i, i) + LL[i]);
long long val1 = dp[i];
if (i == 0) val0 = 0;
if (i == k) {
cout << min(val0, val1) << '\n';
break;
}
{
long long val = val0;
int p = upper_bound(((a).begin()), ((a).end()), RR[i + 1]) - a.begin();
p--;
if (p >= 0 && a[p] > RR[i]) {
int x = a[p];
st1.update(i + 1, k, val - x);
}
p++;
if (p < n) {
int x = a[p];
int h = upper_bound(((LL).begin()), ((LL).end()), x) - LL.begin();
long long lft = x - RR[i + 1];
dp[h - 1] = min(dp[h - 1], val + lft);
int q =
upper_bound(((LL).begin()), ((LL).end()), x + lft) - LL.begin();
st1.update(q, k, val + 2 * lft - x);
st2.update(h, q - 1, val + lft - 2LL * x);
}
}
{
long long val = val1;
int p = upper_bound(((a).begin()), ((a).end()), RR[i + 1]) - a.begin();
p--;
if (p >= 1 && a[p - 1] > RR[i]) {
int x = a[p];
st1.update(i + 1, k, val - x);
}
p++;
if (p >= 1 && p < n && a[p - 1] > RR[i]) {
int x = a[p];
int h = upper_bound(((LL).begin()), ((LL).end()), x) - LL.begin();
long long lft = x - RR[i + 1];
dp[h - 1] = min(dp[h - 1], val + lft);
int q =
upper_bound(((LL).begin()), ((LL).end()), x + lft) - LL.begin();
st1.update(q, k, val + 2 * lft - x);
st2.update(h, q - 1, val + lft - 2LL * x);
}
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1e9 + 7;
void add(int64_t& a, int64_t b) { a = (a + b) % MOD; }
void mul(int64_t& a, int64_t b) { a = a * b % MOD; }
int64_t power_mod(int64_t num, int64_t power) {
int64_t prod = 1;
num %= MOD;
while (power > 0) {
if (power & 1) prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int64_t extgcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
int64_t d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int64_t inv_mod(int64_t a) {
int64_t x, y;
extgcd(a, MOD, x, y);
return (MOD + x % MOD) % MOD;
}
template <typename T>
void chmax(T& a, T b) {
a = max(a, b);
}
int main() {
int N, M, Q;
cin >> N >> M >> Q;
vector<int> mx(N);
vector<pair<int, int>> edges[2000];
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
chmax(mx[a], c);
chmax(mx[b], c);
edges[a].emplace_back(b, c);
edges[b].emplace_back(a, c);
}
static int64_t dp[2010][2010];
for (int t = 0; t <= M; t++)
for (int i = 0; i < N; i++) dp[t][i] = -1e18;
dp[0][0] = 0;
for (int t = 0; t < M; t++) {
for (int i = 0; i < N; i++)
for (auto& [j, c] : edges[i]) chmax(dp[t + 1][j], dp[t][i] + c);
}
int64_t ans = 0;
for (int t = 0; t <= M; t++) {
int64_t res = 0;
for (int i = 0; i < N; i++) chmax(res, dp[t][i]);
add(ans, res);
}
map<int64_t, int64_t> mp;
for (int i = 0; i < N; i++) chmax(mp[mx[i]], dp[M][i]);
vector<pair<int64_t, int64_t>> C;
for (auto& p : mp) C.push_back(p);
int L = M + 1;
for (auto& [A, B] : C) {
int ok = L - 1, ng = Q + 1;
while (ng - ok > 1) {
int64_t mid = (ok + ng) / 2;
int64_t v = 0;
for (auto& [a, b] : C) chmax(v, a * (mid - M) + b);
(v == A * (mid - M) + B ? ok : ng) = mid;
}
if (L <= ok) {
int64_t sum = (A * (L + ok - 2 * M) + 2 * B) % MOD;
int64_t num = ok - L + 1;
add(ans, sum * num % MOD * inv_mod(2));
L = ok + 1;
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
string s, sub, ans;
int l[N + 200], L[N + 200];
int num[11];
string a, b, c;
int main() {
for (int i = 0; i <= 9; i++) l[i] = 1;
for (int i = 10; i < N; i++) l[i] = l[i / 10] + 1;
for (int i = 0; i < N; i++) L[i + l[i]] = i;
cin >> s >> sub;
int length = L[(int)s.size()];
int tmp = (int)s.size(), ff = 0, fff = 0;
for (int i = 0; i < tmp; i++) {
num[s[i] - '0']++;
if (s[i] == '0') fff = 1;
}
tmp = (int)sub.size();
for (int i = 0; i < tmp; i++) {
num[sub[i] - '0']--;
if (sub[i] == '0') fff = 1;
}
while (length) {
num[length % 10]--;
length /= 10;
}
if (L[(int)s.size()] == 1) {
for (int i = 0; i < 10; i++)
if (num[i]) return 0 * printf("%c", i + '0');
cout << sub;
return 0;
}
int i = 1, tot = 0, f = 0;
if (fff) {
while (i < 10 && !num[i]) i++;
if (i < 10)
ans += i + '0';
else {
cout << sub;
while (num[0]--) cout << '0';
return 0;
}
num[i]--;
}
for (i = 0; i < 10; i++)
while (num[i]--) ans += (i + '0');
int ll = 0;
int rr = ans.size() - 1;
for (i = 1; i < ans.size(); i++)
if (ans[i] >= sub[0]) {
ll = i;
break;
}
for (i = 0; i < ll; i++) b += ans[i];
b += sub;
for (i = ll; i < ans.size(); i++) b += ans[i];
for (i = ans.size() - 1; i > 0; i--)
if (ans[i] <= sub[0]) {
rr = i;
break;
}
for (i = 0; i <= rr; i++) c += ans[i];
c += sub;
for (i = rr + 1; i < ans.size(); i++) c += ans[i];
a = sub;
i = 1;
while (ans[i] < ans[0] && i < ans.size()) a += ans[i++];
a += ans[0];
while (i < ans.size()) a += ans[i++];
if (a[0] == '0') a[0] = 'z';
if (b[0] == '0') b[0] = 'z';
if (c[0] == '0') c[0] = 'z';
cout << min(a, min(b, c));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
const int MAXX = 2e5;
const int N = 2e5;
int n, m;
int f[MAXX + 1];
int ans;
int y[N + 1];
inline int js(int k) {
int minn = n;
for (int i = 0; i < n; i++) y[i] = 0;
for (int i = 1; i <= n; i++) {
int a = (i - 1) * m + k;
if (((f[a] - 1) % m + 1) != k) continue;
int b = (f[a] - 1) / m + 1;
if (b > n) continue;
y[(i - b + n) % n]++;
}
for (int i = 0; i < n; i++)
if (i + n - y[i] < minn) minn = i + n - y[i];
return minn;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n * m; i++) f[i] = read();
for (int i = 1; i <= m; i++) ans += js(i);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 1e6 + 5;
const int M = 1e4 + 5;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const long double pi = acos(-1.0L);
long long read() {
long long x = 0, t = 1;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') t = -1;
while (isdigit(ch)) {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * t;
}
int a[N];
long long sum[N];
int main() {
int n = read();
for (int i = 1; i <= (n + 1) / 2; i++) a[i] = read();
int x = read();
for (int i = (n + 1) / 2 + 1; i <= n; i++) a[i] = x;
for (int i = 1; i <= n; i++) sum[i] = a[i] + sum[i - 1];
if (x >= 0) {
if (sum[n] > 0)
printf("%d\n", n);
else
printf("-1\n");
return 0;
}
int len = n;
for (int i = 1; i <= n; i++) {
int j = i + len - 1;
if (j > n || len <= n / 2) break;
long long t = sum[j] - sum[i - 1];
while (t <= 0 && len > n / 2) t -= x, len--;
}
if (len <= n / 2)
printf("-1\n");
else
printf("%d\n", len);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int seg[2400005];
int lz[2400005];
void push(int ver) {
lz[2 * ver] = lz[ver];
lz[2 * ver + 1] = lz[ver];
seg[2 * ver] = lz[ver];
seg[2 * ver + 1] = lz[ver];
lz[ver] = 0;
}
void upd(int ver, int tl, int tr, int l, int r, int val) {
if (tl > tr || l > r || tr < l || r < tl)
return;
else if (tl == l && tr == r) {
lz[ver] = val;
seg[ver] = val;
} else {
int tm = (tl + tr) / 2;
if (lz[ver]) push(ver);
upd(2 * ver, tl, tm, l, min(tm, r), val);
upd(2 * ver + 1, tm + 1, tr, max(tm + 1, l), r, val);
seg[ver] = max(seg[2 * ver], seg[2 * ver + 1]);
}
}
int get(int ver, int tl, int tr, int l, int r) {
if (tl > tr || l > r || tr < l || r < tl)
return 0;
else if (tl == l && tr == r)
return seg[ver];
else {
int tm = (tl + tr) / 2;
if (lz[ver]) {
push(ver);
seg[ver] = max(seg[2 * ver], seg[2 * ver + 1]);
}
return max(get(2 * ver, tl, tm, l, min(tm, r)),
get(2 * ver + 1, tm + 1, tr, max(tm + 1, l), r));
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
stack<int> s;
int x;
string str;
int n;
cin >> n;
int mx = 0;
int cnt = 1;
int ans = 0;
int pos[n + 1];
for (int i = 1; i <= 2 * n; i++) {
cin >> str;
if (str == "add") {
cin >> x;
pos[x] = i;
s.push(x);
upd(1, 1, 2 * n, i, i, x);
} else {
int z = get(1, 1, 2 * n, pos[cnt], 2 * n);
if (z > cnt) {
ans++;
upd(1, 1, 2 * n, 1, i, -1);
}
cnt++;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 233333;
int par[N][25], dep[N];
int u, v, ans;
int n;
inline int lca(int u, int v) {
if (dep[u] < dep[v]) {
u ^= v;
v ^= u;
u ^= v;
}
for (int i = 0; i < 25; i++)
if (((dep[u] - dep[v]) >> i) & 1) u = par[u][i];
if (u == v) return u;
for (int i = 24; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[u][0];
}
int main() {
scanf("%d", &n);
par[1][0] = 0;
dep[1] = 0;
u = v = 1;
for (int i = 2; i <= n; i++) {
int w;
scanf("%d", &w);
par[i][0] = w;
dep[i] = dep[w] + 1;
for (int j = 1; j < 24; j++) par[i][j] = par[par[i][j - 1]][j - 1];
w = i;
int l = lca(u, w);
int dst = dep[u] - dep[l] + dep[w] - dep[l];
int nu = u, nv = v;
if (dst > ans) {
ans = dst;
nu = u;
nv = w;
}
l = lca(v, w);
dst = dep[v] - dep[l] + dep[w] - dep[l];
if (dst > ans) {
ans = dst;
nu = w;
nv = v;
}
printf("%d%c", ans, i == n ? '\n' : ' ');
u = nu;
v = nv;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[2001];
int n, d;
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
long long ans = 0;
for (int i = 2; i <= n; i++)
if (a[i] <= a[i - 1]) {
ans += (a[i - 1] - a[i]) / d + 1;
a[i] += ((a[i - 1] - a[i]) / d + 1) * d;
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 123;
const long long INF = 1e18 + 123;
const double eps = 1e-9;
const int mod = 1e9 + 7;
void boost() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
string a[33] = {
"111111101010101111100101001111111", "100000100000000001010110001000001",
"101110100110110000011010001011101", "101110101011001001111101001011101",
"101110101100011000111100101011101", "100000101010101011010000101000001",
"111111101010101010101010101111111", "000000001111101111100111100000000",
"100010111100100001011110111111001", "110111001111111100100001000101100",
"011100111010000101000111010001010", "011110000110001111110101100000011",
"111111111111111000111001001011000", "111000010111010011010011010100100",
"101010100010110010110101010000010", "101100000101010001111101000000000",
"000010100011001101000111101011010", "101001001111101111000101010001110",
"101101111111000100100001110001000", "000010011000100110000011010000010",
"001101101001101110010010011011000", "011101011010001000111101010100110",
"111010100110011101001101000001110", "110001010010101111000101111111000",
"001000111011100001010110111110000", "000000001110010110100010100010110",
"111111101000101111000110101011010", "100000100111010101111100100011011",
"101110101001010000101000111111000", "101110100011010010010111111011010",
"101110100100011011110110101110000", "100000100110011001111100111100000",
"111111101101000101001101110010001"};
int main() {
int x, y;
cin >> x >> y;
cout << a[x][y];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[2 * n];
for (int i = 0; i < 2 * n; i++) {
cin >> arr[i];
}
int count = 0;
for (int i = 0; i < 2 * n; i += 2) {
for (int j = 1; j < 2 * n; j += 2) {
if (arr[i] == arr[j] && j - i != 1) {
count++;
}
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
deque<int> x, y;
int n;
char whowins() {
if (x.size() == 0) return 'R';
if (y.size() == 0) return 'D';
auto it1 = x.begin(), it2 = y.begin();
if (*it1 < *it2) {
y.pop_front();
x.push_back((*it1) + n);
x.pop_front();
return whowins();
}
x.pop_front();
y.push_back((*it2) + n);
y.pop_front();
return whowins();
}
int main() {
int i;
cin >> n;
char c;
for (i = 0; i < n; i++) {
cin >> c;
if (c == 'D')
x.push_back(i);
else
y.push_back(i);
}
c = whowins();
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
bool is = false;
for (int i = 0; i < s.size() - (!is); i++) {
if (s[i] == '1' || is) {
cout << s[i];
}
if (s[i] == '0') is = true;
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[100010], y[100010], c, np[100010], ok[100010], ls[100010], t[100010],
p[100010], l[100010];
char s[100010];
vector<int> r[100010];
void ask(int t) {
if (!c) return;
printf("Q %d ", c);
if (!t) {
for (int i = 1; i <= c; i++) printf("%d %d ", x[i], y[i]);
} else {
for (int i = 1; i <= c; i++) printf("%d %d ", np[x[i]], np[y[i]]);
}
puts("");
fflush(stdout);
scanf("%s", s + 1);
if (!t) {
for (int i = 1; i <= c; i++) ok[x[i]] = s[i] == '1';
} else {
for (int i = 1; i <= c; i++) ls[y[i]] = s[i] == '1';
}
}
int main() {
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
c = 0;
for (int i = 1; i < n; i += 2) {
x[++c] = i;
y[c] = i + 1;
}
ask(0);
c = 0;
for (int i = 2; i < n; i += 2) {
x[++c] = i;
y[c] = i + 1;
}
ask(0);
int d = 0;
for (int i = 1; i <= n; i++)
if (!ok[i - 1]) np[++d] = i;
for (int j = 1; j < 4; j += 2) {
c = 0;
for (int i = j; i + 2 <= d; i += 4) {
x[++c] = i;
y[c] = i + 2;
}
for (int i = j + 1; i + 2 <= d; i += 4) {
x[++c] = i;
y[c] = i + 2;
}
ask(1);
}
r[0].clear();
r[1].clear();
r[2].clear();
t[1] = p[np[1]] = 0;
t[2] = p[np[2]] = 1;
for (int i = 3; i <= d; i++) {
if (ls[i])
t[i] = p[np[i]] = t[i - 2];
else
t[i] = p[np[i]] = 3 - t[i - 1] - t[i - 2];
}
for (int i = 1; i <= n; i++) {
if (ok[i - 1])
l[i] = l[i - 1];
else
l[i] = i;
}
for (int i = 1; i <= n; i++) r[p[l[i]]].push_back(i);
printf("A %d %d %d\n", r[0].size(), r[1].size(), r[2].size());
for (int i = 0; i < 3; i++) {
for (int j : r[i]) printf("%d ", j);
puts("");
}
fflush(stdout);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 200;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct Coor {
double x, y;
} coors[maxn];
double Distan(Coor a, Coor b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double disa[maxn], disb[maxn];
int main() {
int n;
Coor a, b, t;
while (scanf("%lf%lf %lf%lf %lf%lf", &a.x, &a.y, &b.x, &b.y, &t.x, &t.y) !=
EOF) {
scanf("%d", &n);
double dt;
double sum = 0;
double opt1 = double(INF), opt2 = double(INF);
int opt1id = 1, opt2id = 1;
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", &coors[i].x, &coors[i].y);
dt = Distan(coors[i], t);
sum += 2.0 * dt;
disa[i] = Distan(coors[i], a) - dt;
disb[i] = Distan(coors[i], b) - dt;
if (disb[i] < opt1) {
swap(opt1, opt2);
swap(opt1id, opt2id);
opt1 = disb[i];
opt1id = i;
} else if (disb[i] < opt2) {
opt2 = disb[i];
opt2id = i;
}
}
double ans = double(INF);
for (int i = 1; i <= n; i++) {
ans = min(ans, sum + disa[i]);
}
for (int i = 1; i <= n; i++) {
ans = min(ans, sum + disb[i]);
}
if (n == 1) {
printf("%.8lf", ans);
continue;
}
for (int i = 1; i <= n; i++) {
if (i == opt1id) {
ans = min(ans, sum + disa[i] + disb[opt2id]);
} else {
ans = min(ans, sum + disa[i] + disb[opt1id]);
}
}
printf("%.7lf", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, res;
long long a[1000010];
long long ans[1000010];
bool cmp(long long a, long long b) { return a > b; }
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + 1 + n);
for (long long i = 2; i <= n; i += 2) {
ans[i] = a[++k];
}
for (long long i = 1; i <= n; i += 2) {
ans[i] = a[++k];
}
for (long long i = 1; i <= n; i++) {
if (ans[i] < ans[i - 1] && ans[i] < ans[i + 1]) res++;
}
cout << res << endl;
for (long long i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long n, tmp1, tmp2, ans;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n / 2; i++) tmp1 += a[i];
for (int i = n / 2 + 1; i <= n; i++) tmp2 += a[i];
ans = tmp1 * tmp1 + tmp2 * tmp2;
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
const int mod = 998244353;
long long mo(long long a, long long b) { return ((a % b) + b) % b; }
long long gcd(long long a, long long b) {
while (b) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long ipow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = mo(ret * a, mod);
a = mo(a * a, mod);
b >>= 1;
}
return ret;
}
long long dp[MAXN], game[MAXN];
long long pwr[1000005];
long long prob[MAXN][MAXN], p;
long long flux[MAXN][MAXN];
long long bino[MAXN][MAXN];
int main() {
int n, x, y;
cin >> n >> x >> y;
for (int i = 0; i <= n; i++) {
bino[i][0] = 1;
for (int j = 1; j <= i; j++) {
bino[i][j] = (bino[i - 1][j] + bino[i - 1][j - 1]) % mod;
}
}
flux[0][0] = 1;
p = 1ll * x * ipow(y, mod - 2) % mod;
for (int i = 1; i <= n; i++) {
flux[i][0] = 1;
for (int j = 1; j <= i; j++) {
flux[i][j] =
flux[i - 1][j - 1] * ipow(p, i - j) + flux[i - 1][j] * ipow(1 - p, j);
flux[i][j] %= mod;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) {
prob[i][j] = prob[j][j] * flux[i][j] % mod;
}
prob[i][i] = 1;
for (int j = 1; j < i; j++) {
prob[i][i] += mod - prob[i][j];
}
prob[i][i] %= mod;
}
game[1] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++) {
dp[i] += prob[i][j] * (game[j] + dp[i - j]) % mod;
}
dp[i] += prob[i][i] * (i * (i - 1) / 2) % mod;
dp[i] %= mod;
dp[i] *= ipow(mod + 1 - prob[i][i], mod - 2);
dp[i] %= mod;
game[i] = (i * (i - 1) / 2 + dp[i]) % mod;
}
cout << game[n] << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, xRange[2], yRange[2];
inline void gMax(int &x, int y) { x = x < y ? y : x; }
inline void gMin(int &x, int y) { x = x > y ? y : x; }
int main() {
xRange[0] = yRange[0] = INT_MAX;
xRange[1] = yRange[1] = INT_MIN;
scanf("%d%d%d", &n, &m, &n);
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x = x - y, y = x + 2 * y;
gMin(xRange[0], x), gMax(xRange[1], x);
gMin(yRange[0], y), gMax(yRange[1], y);
}
scanf("%d", &m);
int ans = INT_MAX, pos;
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x = x - y, y = x + 2 * y;
int dis = max(abs(x - xRange[0]), abs(x - xRange[1]));
gMax(dis, max(abs(y - yRange[0]), abs(y - yRange[1])));
if (dis < ans) ans = dis, pos = i;
}
printf("%d\n%d\n", ans, pos);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef struct aa {
int x;
int y;
} node;
bool comp(node a, node b) { return a.y < b.y; }
bool comp2(node a, node b) { return a.y > b.y; }
string atob(const int a) {
stringstream os;
string b;
os << a;
os >> b;
return b;
}
int btoa(string b) {
int a;
if (!(istringstream(b) >> a)) a = 0;
return a;
}
int main() {
int n, ct = 0;
string s;
cin >> n;
cin >> s;
if (s.size() > n) {
for (int i = n; i < s.size(); i += n) {
if (s[i - 1] == s[i - 2] && s[i - 2] == s[i - 3]) {
ct++;
}
}
}
cout << ct << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int i = s.length() - 1;
while (s[i] == 'z') i--;
s[i]++;
for (int j = i + 1; j < s.length(); j++) s[j] = 'a';
if (s == t)
cout << "No such string";
else
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, sum = 0;
cin >> n >> k;
pair<int, int> p[n];
for (int i = 0; i < n; i++) {
cin >> p[i].first;
p[i].second = i + 1;
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
k -= p[sum].first;
if (k >= 0)
sum++;
else
break;
}
cout << sum << endl;
for (int i = 0; i < sum; i++) {
cout << p[i].second << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long double PI = 3.14159265359;
long double eps = 1e-5;
long double getArea(long double x1, long double y1, long double x2,
long double y2, long double x3, long double y3) {
long double ret = 0.0;
ret += x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
ret = fabs(ret);
ret /= 2.0;
return ret;
}
long double getDist(long double x1, long double y1, long double x2,
long double y2) {
long double ret = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(ret);
}
bool EQ(long double a, long double b) {
if (fabs(a - b) < eps) return true;
return false;
}
int main() {
long double x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
long double dis1 = 1.0 * getDist(x1, y1, x2, y2);
long double dis2 = 1.0 * getDist(x3, y3, x2, y2);
long double dis3 = 1.0 * getDist(x1, y1, x3, y3);
long double area = 1.0 * getArea(x1, y1, x2, y2, x3, y3);
long double rad = 1.0 * dis1 * dis2 * dis3 / 4.0;
rad /= 1.0 * area;
long double ang1 = 1.0 * acos(1.0 - (dis1 * dis1) / (2.0 * rad * rad));
long double ang2 = 1.0 * acos(1.0 - (dis2 * dis2) / (2.0 * rad * rad));
long double ang3 = 1.0 * acos(1.0 - (dis3 * dis3) / (2.0 * rad * rad));
for (int i = 3; i <= 100; i++) {
bool f = true;
long double ang = 2.0 * PI / i;
long double temp1 = 1.0 * ang1 / ang;
long double temp2 = 1.0 * ang2 / ang;
long double temp3 = 1.0 * ang3 / ang;
int fl = floor(1.0 * temp1);
int cl = ceil(1.0 * temp1);
if (!(EQ(1.0 * temp1, 1.0 * fl) or EQ(1.0 * temp1, 1.0 * cl))) f = false;
fl = floor(1.0 * temp2);
cl = ceil(1.0 * temp2);
if (!(EQ(1.0 * temp2, 1.0 * fl) or EQ(1.0 * temp2, 1.0 * cl))) f = false;
fl = floor(1.0 * temp3);
cl = ceil(1.0 * temp3);
if (!(EQ(1.0 * temp3, 1.0 * fl) or EQ(1.0 * temp3, 1.0 * cl))) f = false;
if (f) {
long double ans = i;
ans /= 2.0;
ans *= 1.0 * rad * rad;
ans *= 1.0 * sin(2.0 * PI / i);
cout << fixed << setprecision(6) << ans << endl;
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void inpint(int &n) {
n = 0;
register int ch = getchar_unlocked();
bool sign = 0;
while (ch < 48 || ch > 57) {
if (ch == '-') sign = 1;
ch = getchar_unlocked();
}
while (ch >= 48 && ch <= 57) {
n = (n << 3) + (n << 1) + ch - 48, ch = getchar_unlocked();
}
if (sign) n = -n;
}
inline int sqr(int x) { return x * x; }
inline int cube(int x) { return x * x * x; }
inline long long sqrLL(long long x) { return x * x; }
inline long long cubeLL(long long x) { return x * x * x; }
const long long LLINF = 9223372036854775807LL;
const long long LLINF17 = 100000000000000000LL;
const int INF = 2147483647;
const int INF9 = 1000000000;
const int MOD = 1000000007;
const double eps = 1e-7;
const double PI = acos(-1.0);
int dr[] = {1, 0, -1, 0, -1, 1, 1, -1};
int dc[] = {0, -1, 0, 1, 1, 1, -1, -1};
int n;
string s;
vector<string> v;
int in[30];
vector<int> adj[30];
int main() {
cin >> n;
while (n--) {
cin >> s;
v.push_back(s);
}
for (int(i) = (0); (i) < ((int)(v.size()) - 1); (i)++) {
bool found = 0;
int it1 = 0, it2 = 0;
while (it1 < (int)(v[i].length()) && it2 < (int)(v[i + 1].length())) {
if (v[i][it1] != v[i + 1][it2]) {
found = 1;
adj[v[i][it1] - 'a'].push_back(v[i + 1][it2] - 'a');
in[v[i + 1][it2] - 'a']++;
break;
}
it1++;
it2++;
}
if (!found && it1 < (int)(v[i].length()) &&
it2 == (int)(v[i + 1].length())) {
puts("Impossible");
return 0;
}
}
queue<int> q;
for (int(i) = (0); (i) < (26); (i)++) {
if (!in[i]) q.push(i), in[i] = -1;
}
string ans = "";
while (!q.empty()) {
int p = q.front();
q.pop();
ans.push_back((char)(p + 'a'));
for (int(i) = (0); (i) < ((int)(adj[p].size())); (i)++) {
int next = adj[p][i];
in[next]--;
}
for (int(i) = (0); (i) < (26); (i)++) {
if (!in[i]) {
in[i] = -1;
q.push(i);
}
}
}
for (int(i) = (0); (i) < (26); (i)++) {
if (in[i] >= 0) {
puts("Impossible");
return 0;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, t, a, b, da, db;
cin >> x >> t >> a >> b >> da >> db;
if (x == 0) {
cout << "YES" << endl;
return 0;
}
if (x == 0 || (x <= a && x > a - da * t && (a - x) % da == 0) ||
(x <= b && x > b - db * t && (b - x) % db == 0)) {
cout << "YES" << endl;
return 0;
}
for (int pa = a, pb = b - db * (t - 1); pa > a - da * t && pb <= b;) {
if (pa + pb > x) {
pa -= da;
} else if (pa + pb < x) {
pb += db;
} else {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int SQRTN = 320;
const int LOGN = 20;
const double PI = acos(-1);
const double TAU = 2 * PI;
int n;
vector<vector<int> > g;
vector<pair<int, int> > e;
map<pair<int, int>, int> idx;
int ans[N];
inline void solve() {
cin >> n;
g.resize(n + 1);
memset(ans, -1, sizeof ans);
for (int i = 1, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
idx[make_pair(min(a, b), max(a, b))] = i;
}
int x = 0;
for (int i = 1; i <= n; i++) {
if (g[i].size() > 2) {
ans[idx[make_pair(min(g[i][0], i), max(g[i][0], i))]] = 0;
ans[idx[make_pair(min(g[i][1], i), max(g[i][1], i))]] = 1;
ans[idx[make_pair(min(g[i][2], i), max(g[i][2], i))]] = 2;
x = 3;
break;
}
}
for (int i = 1; i < n; i++) {
if (ans[i] == -1)
printf("%d\n", x++);
else
printf("%d\n", ans[i]);
}
}
signed main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int m;
string s;
int x[N], y[N], z[N];
int l, r;
bool ans[N];
int X, Y, Z;
int abs(int n) { return n < 0 ? -n : n; }
int main() {
cin >> s >> m;
for (int i = 1; i <= s.length(); ++i) {
x[i] = (s[i - 1] == 'x') + x[i - 1];
y[i] = (s[i - 1] == 'y') + y[i - 1];
z[i] = (s[i - 1] == 'z') + z[i - 1];
}
for (int i = 0; i < m; ++i) {
cin >> l >> r;
--l;
X = abs(x[r] - x[l]);
Y = abs(y[r] - y[l]);
Z = abs(z[r] - z[l]);
if ((r - l) % 3 == 0)
if (X == Y && X == Z) ans[i] = true;
if ((r - l) % 3 != 0)
if (abs(X - Y) + abs(X - Z) + abs(Y - Z) <= 2) ans[i] = true;
if (r - l < 3) ans[i] = true;
}
for (int i = 0; i < m; ++i) cout << (ans[i] ? "YES\n" : "NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct Node {
int a;
int b;
int c;
};
Node node[N];
int n;
queue<int> Q;
int dfs(int x) {
if (node[x].c == 0) {
return x;
}
return dfs(node[x].c);
}
int main() {
int mark;
int ne;
while (scanf("%d", &n) == 1) {
mark = 1;
while (!Q.empty()) {
Q.pop();
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", &node[i].a, &node[i].c);
node[i].b = i;
if (!node[i].a) {
Q.push(i);
}
}
while (!Q.empty()) {
int now;
now = Q.front();
Q.pop();
if (!mark) {
node[now].a = ne;
node[ne].c = now;
}
mark = 0;
ne = dfs(now);
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", node[i].a, node[i].c);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
int n, x, y, b[N], a[N][N];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
cin >> a[i][j];
if (a[i][j] == n - 1) {
x = i;
y = j;
}
}
b[x] = n;
for (int j = 1; j <= n; ++j)
if (j != x) b[j] = a[x][j];
for (int i = 1; i <= n; ++i) cout << b[i] << " ";
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, p, q, i, count = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &p, &q);
if (q - p >= 2) {
count++;
}
}
printf("%d", count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100001];
long long arr1[100001];
int main() {
long long n;
cin >> n;
vector<long long> ans;
long long sum = 0;
long long max1 = 0;
for (long long i = 0; i < n; i++) {
long long num;
cin >> num;
arr[i] = num;
}
for (long long i = 0; i < n; i++) {
if (i == 0) {
arr1[i] = arr[i];
}
arr1[i] = arr[i] - arr[i - 1];
}
for (long long i = 1; i <= n; i++) {
bool status = true;
for (long long j = 0; j < n; j++) {
if (arr1[j] != arr1[j % i]) {
status = false;
break;
}
}
if (!status) {
continue;
} else {
ans.push_back(i);
}
}
cout << ans.size() << '\n';
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int a[N];
const long long inf = (long long)1e14;
inline pair<long long, long long> merge(pair<long long, long long> &x,
pair<long long, long long> &y) {
return {min(x.first, y.first),
min(max(x.first, y.first), min(x.second, y.second))};
}
struct SegTree {
vector<pair<long long, long long> > T;
int n;
SegTree(int _n) {
n = _n;
T.resize(2 * n, {inf, inf});
}
void update(int pos, long long val) {
for (T[pos += n].first = val; pos > 1; pos >>= 1) {
T[pos >> 1] = merge(T[pos], T[pos ^ 1]);
}
}
pair<long long, long long> query(int l, int r) {
r++;
pair<long long, long long> ans = {inf, inf};
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans = merge(ans, T[l++]);
if (r & 1) ans = merge(ans, T[--r]);
}
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
vector<SegTree> sg(10, SegTree(2 * n));
for (int(i) = 0; (i) < (int)(n); ++(i)) {
cin >> a[i];
int val = a[i];
for (int(j) = 0; (j) < (int)(10); ++(j)) {
if (val % 10) {
sg[j].update(i, a[i]);
}
val /= 10;
}
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int pos, x;
cin >> pos >> x;
pos--;
for (int(j) = 0; (j) < (int)(10); ++(j)) {
if (a[pos] % 10) {
sg[j].update(pos, inf);
}
a[pos] /= 10;
}
a[pos] = x;
for (int(j) = 0; (j) < (int)(10); ++(j)) {
if (x % 10) {
sg[j].update(pos, a[pos]);
}
x /= 10;
}
} else {
int l, r;
cin >> l >> r;
l--, r--;
long long ans = inf;
for (int(j) = 0; (j) < (int)(10); ++(j)) {
pair<long long, long long> cur = sg[j].query(l, r);
ans = min(ans, cur.first + cur.second);
}
if (ans > 2 * (1e9)) {
ans = -1;
}
cout << ans << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char arr[3][3][3][3];
int main() {
int cur = -1, cnt = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++) {
char x;
scanf(" %c", &x);
arr[i][k][j][l] = x;
}
int x, y;
cin >> x >> y;
x--, y--;
x %= 3;
y %= 3;
bool f = 0, ff = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++)
if (x == i && y == k && arr[i][k][j][l] == '.') f = 1;
if (!f) ff = 1;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
for (int l = 0; l < 3; l++) {
if ((ff && arr[i][k][j][l] == '.') |
(x == i && y == k && arr[i][k][j][l] == '.'))
cout << "!";
else
cout << arr[i][k][j][l];
}
cout << " ";
}
cout << endl;
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
mt19937 kk(490571098);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long N;
cin >> N;
long long sx = 0, dx = 1e9 + 1;
long long t = 0;
while (sx < dx - 1) {
t++;
long long m = (sx + dx) / 2;
cout << "> " << m << endl;
long long a;
cin >> a;
if (a)
sx = m;
else
dx = m;
}
long long x = sx + 1;
vector<long long> p;
vector<long long> kkk;
for (int i = 0; i < N; i++) kkk.push_back(i);
shuffle(kkk.begin(), kkk.end(), kk);
for (long long i = 0; i < min(60 - t, N); i++) {
cout << "? " << kkk[i] + 1 << endl;
long long a;
cin >> a;
if (a != x) p.push_back(a);
}
p.push_back(x);
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
vector<long long> di;
long long diff = p[0] - p[1];
for (long long i = 1; i * i <= diff; i++) {
if (diff % i == 0) {
di.push_back(i);
di.push_back(diff / i);
}
}
for (long long i = 0; i < di.size(); i++) {
bool ok = 1;
for (long long j = 1; j < p.size(); j++) {
long long g = p[0] - p[j];
if (g % di[i] == 0 && g / di[i] < (N - p.size() + j + 1)) continue;
ok = 0;
break;
}
if (ok && p[0] - (N - 1) * di[i] >= 0) {
cout << "! " << p[0] - (N - 1) * di[i] << " " << di[i] << endl;
return 0;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, K, C, X;
int arr[3005];
int clr[3005];
vector<pair<int, int>> ans;
void dfs(int n) {
while (clr[n] != C) {
clr[n] = C;
n = arr[n];
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
}
cin >> K;
K = N - K;
for (int i = 1; i <= N; i++) {
if (!clr[i]) {
C++;
dfs(i);
}
}
X = C;
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
if (X < K && clr[i] == clr[j]) {
ans.push_back({i, j});
swap(arr[i], arr[j]);
C++;
dfs(i);
C++;
dfs(j);
X++;
}
if (X > K && clr[i] != clr[j]) {
ans.push_back({i, j});
swap(arr[i], arr[j]);
C++;
dfs(i);
X--;
}
}
}
cout << ans.size() << "\n";
for (auto p : ans) {
cout << p.first << " " << p.second << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, i, k, k1, k2, alic, bob;
int main() {
deque<int> d;
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
d.push_front(k);
}
if (d.size() == 1) {
cout << "1"
<< " "
<< "0";
return 0;
}
while (true) {
if (d.front() - d.back() > 0) {
if (d.size() == 2) {
bob++;
alic++;
break;
} else {
k1 = d.front() - d.back();
d.pop_back();
d.pop_front();
d.push_front(k1);
alic++;
}
}
if (d.back() - d.front() > 0) {
if (d.size() == 2) {
bob++;
alic++;
break;
} else {
k1 = d.back() - d.front();
d.pop_back();
d.pop_front();
d.push_back(k1);
bob++;
}
}
if (d.back() - d.front() == 0) {
if (d.size() == 2) {
bob++;
alic++;
break;
} else if (d.size() == 3) {
alic += 2;
bob++;
break;
} else {
d.pop_front();
d.pop_back();
alic++;
bob++;
}
}
}
cout << alic << " " << bob;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e9;
void solve() {
int n;
cin >> n;
vector<int> vec(n);
int count = 0;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
vec[i] = s[i] - '0';
if (vec[i] == 2) count++;
}
if (count == 1 || count == 2) {
cout << "NO" << endl;
} else {
vector<bool> was(n, false);
vector<vector<char>> v(n, vector<char>(n, 'X'));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j != i && v[i][j] == 'X') {
if (vec[i] == 1 && vec[j] == 1) {
v[i][j] = '=';
} else if (vec[i] == 2 && vec[j] == 1) {
v[i][j] = '-';
} else if (vec[i] == 1 && vec[j] == 2) {
v[i][j] = '+';
} else if (vec[i] == 2 && vec[j] == 2) {
if (was[i]) {
v[i][j] = '-';
was[j] = true;
v[j][i] = '+';
} else {
v[i][j] = '+';
was[i] = true;
v[j][i] = '-';
}
}
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << v[i][j];
cout << endl;
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dfa[N][26];
void build(string &s) {
dfa[0][s[0] - 'a'] = 1;
for (int i = 1, j = 0; i <= s.size(); i++) {
for (int k = 0; k < 26; k++) dfa[i][k] = dfa[j][k];
if (i < s.size()) {
j = dfa[j][s[i] - 'a'];
dfa[i][s[i] - 'a'] = i + 1;
}
}
}
string s, t;
vector<int> dp[N];
int solve(int i, int j) {
if (i == s.size()) return j == t.size();
int &ret = dp[i][j];
if (ret != -1) return ret;
ret = 0;
if (s[i] != '?')
ret = solve(i + 1, dfa[j][s[i] - 'a']) + (j == t.size());
else {
for (int k = 0; k < 26; k++)
ret = max(ret, solve(i + 1, dfa[j][k]) + (j == t.size()));
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> s >> t;
if (t.size() > s.size())
cout << 0 << endl;
else {
build(t);
for (int i = 0; i < s.size(); i++)
dp[i].resize(min(i + 2, (int)t.size() + 2), -1);
cout << solve(0, 0) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
int n;
string a, b;
cin >> n >> a >> b;
int cnt = 0;
int s = 0, e = n - 1;
vector<int> ans;
for (int i = n - 1; i >= 0; i--) {
if (cnt % 2) {
if (a[e] == b[i]) {
if (a[s] == b[i]) {
ans.push_back(i + 1);
cnt++;
swap(s, e);
if (e >= s) {
e--;
} else {
e++;
}
} else {
ans.push_back(1);
ans.push_back(i + 1);
swap(s, e);
if (e >= s)
e--;
else
e++;
cnt++;
}
} else {
if (e >= s)
e--;
else
e++;
}
} else {
if (a[e] != b[i]) {
if (a[s] != b[i]) {
ans.push_back(i + 1);
cnt++;
swap(s, e);
if (e >= s)
e--;
else
e++;
} else {
ans.push_back(1);
ans.push_back(i + 1);
swap(s, e);
if (e >= s)
e--;
else
e++;
cnt++;
}
} else {
if (e >= s)
e--;
else
e++;
}
}
}
cout << ans.size() << " ";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, Len, Ans;
string str;
cin >> str;
Len = str.size();
Ans = 0;
for (i = 0; i < Len; ++i) {
if (str[i] == '4') {
Ans += 1 << (Len - i - 1);
} else {
Ans += 1 << (Len - i);
}
}
cout << Ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int co[20];
long long a[100100];
vector<long long> v;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m, i;
cin >> n;
for (i = 0; i < n && cin >> a[i]; i++)
;
long long mx = 0;
for (i = 0; i < n; i++) {
co[a[i]]++;
for (int j = 1; j <= 10; j++) {
if (co[j]) v.push_back(co[j]);
}
if (v.size() > 1) {
sort(v.begin(), v.end());
bool b = 0;
for (int j = 1; j < v.size() - 1; j++) {
if (v[j] != v[j - 1]) b = 1;
}
if (!b && v[v.size() - 2] == v[v.size() - 1] - 1) {
mx = max(i + 1, mx);
}
b = 0;
for (int j = 1; j < v.size() - 1; j++) {
if (v[j] != v[j + 1]) b = 1;
}
if (!b && v[0] == 1) {
mx = max(i + 1, mx);
}
} else {
mx = max(i + 1, mx);
}
v.clear();
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long simulation(long long n, long long k) {
long long sum = 0;
while (n) {
if (n >= k) {
sum += k;
n -= k;
} else {
sum += n;
n = 0;
}
n = n - (n / 10);
}
return sum;
}
int main() {
long long answer = 0, n;
cin >> n;
for (int power = 61; power >= 0; --power) {
if (2 * simulation(n, answer + (1LL << power)) < n) {
answer += (1LL << power);
}
}
cout << answer + 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = (1<<29);
const int INFF = 0x7fffffff;
const ll LINF = (1ll<<60);
const ll LINFF = 0x7fffffffffffffff;
const long double PI = 3.14159265359;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll rnd(ll a, ll b){return uniform_int_distribution<ll>(a, b)(rng);}
#define _fi(n) for(int i = 0;i < n;i++)
#define _fj(n) for(int j = 0;j < n;j++)
#define _fk(n) for(int k = 0;k < n;k++)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define prec(x) cout << fixed << setprecision(x)
#define sz(x) (int)x.size()
#define lg2(x) 31-__builtin_clz(x)
#define hash sodnf9843bsd
#define left ldkfjn43ofjosamdg
#define right iadjfof23n3okd
#define pqueue priority_queue
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define endl '\n'
const int maxn = 2e3+11;
ll arr[maxn][maxn];
bool vis[maxn][maxn];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;cin>>n>>m;
ll w;cin>>w;
_fi(n)_fj(m) cin>>arr[i][j];
ll ans = LINF;
// home -> school
queue<tuple<ll, ll, ll>>q;
q.push({0, 0, 0});
while(!q.empty()){
ll i, j, d;
tie(i, j, d) = q.front();
q.pop();
if (i < 0 || i == n) continue;
if (j < 0 || j == m) continue;
if (arr[i][j] == -1) continue;
if (vis[i][j]) continue;
vis[i][j] = true;
if (i == n-1 && j == m-1) {
ans = d;
break;
}
q.push({i+1, j, d+w});
q.push({i-1, j, d+w});
q.push({i, j+1, d+w});
q.push({i, j-1, d+w});
}
_fi(n)_fj(m) vis[i][j] = false;
// home -> portal
ll homep = LINF;
while(!q.empty()) q.pop();
q.push({0, 0, 0});
while(!q.empty()){
ll i, j, d;
tie(i, j, d) = q.front();
q.pop();
if (i < 0 || i == n) continue;
if (j < 0 || j == m) continue;
if (arr[i][j] == -1) continue;
if (vis[i][j]) continue;
vis[i][j] = true;
if (arr[i][j] > 0) homep = min(homep, d+arr[i][j]);
q.push({i+1, j, d+w});
q.push({i-1, j, d+w});
q.push({i, j+1, d+w});
q.push({i, j-1, d+w});
}
_fi(n)_fj(m) vis[i][j] = false;
// school -> portal
ll schoolp = LINF;
while(!q.empty()) q.pop();
q.push({n-1, m-1, 0});
while(!q.empty()){
ll i, j, d;
tie(i, j, d) = q.front();
q.pop();
if (i < 0 || i == n) continue;
if (j < 0 || j == m) continue;
if (arr[i][j] == -1) continue;
if (vis[i][j]) continue;
vis[i][j] = true;
if (arr[i][j] > 0) schoolp = min(schoolp, d+arr[i][j]);
q.push({i+1, j, d+w});
q.push({i-1, j, d+w});
q.push({i, j+1, d+w});
q.push({i, j-1, d+w});
}
ans = min(ans, homep+schoolp);
if (ans == LINF) ans = -1;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
int n, m;
int p[N], s[N], b[N];
int inc[N], pref[N];
int sz;
struct node {
vector<int> v1, v2;
} seg[(5 * N) << 2];
vector<int> vec;
void compress() {
for (int i = 0; i < n; i++) {
vec.push_back(p[i]);
vec.push_back(s[i]);
vec.push_back(b[i]);
}
for (int i = 0; i < m; i++) {
vec.push_back(inc[i]);
vec.push_back(pref[i]);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
sz = (int)vec.size();
for (int i = 0; i < n; i++) {
p[i] = lower_bound(vec.begin(), vec.end(), p[i]) - vec.begin();
s[i] = lower_bound(vec.begin(), vec.end(), s[i]) - vec.begin();
b[i] = lower_bound(vec.begin(), vec.end(), b[i]) - vec.begin();
}
for (int i = 0; i < m; i++) {
inc[i] = lower_bound(vec.begin(), vec.end(), inc[i]) - vec.begin();
pref[i] = lower_bound(vec.begin(), vec.end(), pref[i]) - vec.begin();
}
}
void add(int l, int r, int val1, int val2, int v = 1, int s = 0, int e = sz) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
seg[v].v1.push_back(val1);
seg[v].v2.push_back(val2);
return;
}
add(l, r, val1, val2, (v << 1), s, (s + e) >> 1);
add(l, r, val1, val2, ((v << 1) ^ 1), (s + e) >> 1, e);
}
void go(int v = 1, int s = 0, int e = sz) {
sort(seg[v].v1.begin(), seg[v].v1.end());
sort(seg[v].v2.begin(), seg[v].v2.end());
if (e - s == 1) return;
go((v << 1), s, (s + e) >> 1);
go(((v << 1) ^ 1), (s + e) >> 1, e);
}
int get(int a, int b, int v = 1, int s = 0, int e = sz) {
int sum = 0;
sum += (int)seg[v].v1.size();
sum -= seg[v].v1.end() -
upper_bound(seg[v].v1.begin(), seg[v].v1.end(), vec[b] + vec[a]);
sum -= lower_bound(seg[v].v2.begin(), seg[v].v2.end(), vec[b] - vec[a]) -
seg[v].v2.begin();
if (e - s == 1) return sum;
if (a < (s + e) >> 1)
sum += get(a, b, (v << 1), s, (s + e) >> 1);
else
sum += get(a, b, ((v << 1) ^ 1), (s + e) >> 1, e);
return sum;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> s[i], s[i]++;
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < m; i++) cin >> inc[i];
for (int i = 0; i < m; i++) cin >> pref[i];
compress();
for (int i = 0; i < n; i++)
add(p[i], s[i], vec[b[i]] + vec[p[i]], vec[b[i]] - vec[p[i]]);
go();
for (int i = 0; i < m; i++) {
cout << get(inc[i], pref[i]) << ' ';
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<pair<int, int>, int> a;
int cal(int a, int b) {
if (a == 0 || a == n + 1 || b == 0 || b == m + 1) return -100;
return m * (a - 1) + b;
}
bool chk(int x, int y) {
int x_m = a[make_pair(x - 1, y)], y_m = a[make_pair(x, y - 1)];
int tmp = a[make_pair(x, y)];
int x_t = (tmp - 1) / m + 1, y_t = (tmp % m == 0) ? m : tmp % m;
int x_2 = cal(x_t - 1, y_t), x_3 = cal(x_t + 1, y_t);
int y_2 = cal(x_t, y_t - 1), y_3 = cal(x_t, y_t + 1);
if (x_m == x_2 || x_m == y_2 || x_m == x_3 || x_m == y_3) return false;
if (y_m == x_2 || y_m == y_2 || y_m == x_3 || y_m == y_3) return false;
return true;
}
bool bk(int x, int y) {
if (x == n + 1) return true;
for (int i = x; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (i == x && j == 1 && y != 1) {
j = y - 1;
continue;
}
swap(a[make_pair(x, y)], a[make_pair(i, j)]);
if (chk(x, y)) {
int x_1 = x, y_1 = y;
if (y_1 == m)
x_1++, y_1 = 1;
else
y_1++;
if (bk(x_1, y_1)) return true;
}
swap(a[make_pair(x, y)], a[make_pair(i, j)]);
}
return false;
}
int main() {
cin >> n >> m;
int cnt = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a[make_pair(i, j)] = cnt;
cnt++;
}
}
if (!bk(1, 1))
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) cout << a[make_pair(i, j)] << " ";
cout << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[2000005];
int deg[2000005];
bool u[2000005];
int n, m, cnt;
long long ans;
void dfs(int v) {
u[v] = 1;
if (deg[v] & 1) {
++cnt;
}
for (int to : adj[v]) {
if (u[to]) {
continue;
}
dfs(to);
}
}
void solve() {
scanf("%d %d", &n, &m);
for (int i = 1, l, r; i <= m; ++i) {
scanf("%d %d", &l, &r);
++deg[l], ++deg[r];
adj[l].push_back(r);
adj[r].push_back(l);
}
int p = 0;
for (int i = 1; i <= n; ++i) {
if (u[i]) {
continue;
}
if (i != 1 && adj[i].empty()) {
continue;
}
cnt = 0;
dfs(i);
if (cnt == 0) {
cnt = 2;
} else {
p = 100;
}
ans += cnt;
++p;
}
if (p == 1) {
ans = 0;
}
printf("%lld\n", ans / 2);
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll MOD = 1e9 + 7;
ll INF = 1e17;
void solve() {
int n;
cin >> n;
string s;
set<string> ans;
cin >> s;
if (s.size() < n) {
string add = "";
for (int i = 0; i < (n - s.size()); i++) {
add += "0";
}
s = add + s;
}
for (int i = 1; i <= s.size(); i++) {
int add = ('9' - s[i - 1]) + 1;
string next = s;
for (int j = 0; j < next.size(); j++) {
next[j] = (next[j] + add - '0') % 10 + '0';
}
string newString = s;
for (int j = i - 1, p = 0; p < next.size(); j++, p++) {
newString[p] = next[j % next.size()];
}
ans.insert(newString);
}
cout << (*ans.begin()) << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct rangeincrease {
int l, r;
};
rangeincrease actions[100001];
rangeincrease inprogress[100001];
int actionL = 0;
int nums[100001];
int opened = 0;
int main() {
int n;
int i;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> nums[i];
}
for (i = 1; i <= n; i++) {
while (nums[i] > opened) {
opened++;
inprogress[opened].l = i;
}
while (nums[i] < opened) {
inprogress[opened].r = i - 1;
actionL++;
actions[actionL].l = inprogress[opened].l;
actions[actionL].r = inprogress[opened].r;
opened--;
}
}
while (opened > 0) {
inprogress[opened].r = n;
actionL++;
actions[actionL].l = inprogress[opened].l;
actions[actionL].r = inprogress[opened].r;
opened--;
}
cout << actionL << endl;
for (i = 1; i <= actionL; i++) {
cout << actions[i].l << " " << actions[i].r << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (((n) * (n - 1)) / 2 > k) {
for (int i = 0; i < n; i++) cout << "0 " << i << endl;
} else {
cout << "no solution" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005, M = 1000005;
int cnt[M], a[N];
int main() {
int n, k, dif = 0, l = 1, ml = 1, mr = 1, len = 1;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
if (!cnt[a[i]]) ++dif;
++cnt[a[i]];
while (dif > k) {
if (cnt[a[l]] == 1) --dif;
--cnt[a[l++]];
}
if (i - l + 1 > len) {
ml = l;
mr = i;
len = i - l + 1;
}
}
printf("%d %d", ml, mr);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
int ans = min(2 * (x + y), x + y + z);
ans = min(ans, 2 * (y + z));
ans = min(ans, 2 * (x + z));
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, w, h, s[102];
bool ok[101][101][4], v[101][101];
void dfs(int x, int y, int c) {
++s[c];
v[x][y] = true;
if ((ok[x][y][0]) && (!v[x - 1][y])) dfs(x - 1, y, c);
if ((ok[x][y][1]) && (!v[x][y - 1])) dfs(x, y - 1, c);
if ((ok[x][y][2]) && (!v[x + 1][y])) dfs(x + 1, y, c);
if ((ok[x][y][3]) && (!v[x][y + 1])) dfs(x, y + 1, c);
}
int main(void) {
scanf("%d %d %d", &w, &h, &n);
for (int i = 0; i < w; ++i)
for (int j = 0; j < h; ++j)
for (int k = 0; k < 4; ++k) ok[i][j][k] = true;
for (int i = 0; i < w; ++i) {
ok[i][0][1] = false;
ok[i][h - 1][3] = false;
}
for (int i = 0; i < h; ++i) {
ok[0][i][0] = false;
ok[w - 1][i][2] = false;
}
for (int i = 1; i <= n; ++i) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
for (int j = y1; j < y2; ++j) {
ok[x1][j][0] = false;
ok[x1 - 1][j][2] = false;
}
} else if (y1 == y2) {
if (x1 > x2) swap(x1, x2);
for (int j = x1; j < x2; ++j) {
ok[j][y1][1] = false;
ok[j][y1 - 1][3] = false;
}
}
}
int t = 0;
for (int i = 0; i < w; ++i)
for (int j = 0; j < h; ++j)
if (!v[i][j]) dfs(i, j, ++t);
sort(s + 1, s + n + 2);
for (int i = 1; i <= n; ++i) printf("%d ", s[i]);
printf("%d\n", s[n + 1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int half = n / 2;
vector<int> cheses;
cheses.resize(half);
int resToWhite = 0;
int resToBalck = 0;
int placeOfNextBlack = 1;
int placeOfNextWhite = 2;
for (int i = 0; i < half; ++i) {
cin >> cheses[i];
}
sort(cheses.begin(), cheses.end());
for (int chese : cheses) {
resToBalck += abs(chese - placeOfNextBlack);
resToWhite += abs(chese - placeOfNextWhite);
placeOfNextBlack += 2;
placeOfNextWhite += 2;
}
int res = (resToBalck > resToWhite) ? resToWhite : resToBalck;
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long INF = 1e12;
const int MOD = 1e9 + 7;
const unsigned long long BIT_FLAG_0 = (1 << 0);
const unsigned long long BIT_FLAG_1 = (1 << 1);
const unsigned long long BIT_FLAG_2 = (1 << 2);
const unsigned long long BIT_FLAG_3 = (1 << 3);
const unsigned long long BIT_FLAG_4 = (1 << 4);
const unsigned long long BIT_FLAG_5 = (1 << 5);
const unsigned long long BIT_FLAG_6 = (1 << 6);
const unsigned long long BIT_FLAG_7 = (1 << 7);
const long long dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const long long Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
long long in() {
long long x;
cin >> x;
return x;
}
void print() { cout << "\n"; }
template <class Head, class... Tail>
void print(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(tail) != 0) cout << " ";
print(forward<Tail>(tail)...);
}
template <class T>
void print(vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) cout << " ";
}
cout << "\n";
}
template <class T>
void print(set<T> &set) {
for (auto &a : set) {
cout << a << " ";
}
cout << "\n";
}
template <class T>
void print(vector<vector<T>> &df) {
for (auto &vec : df) {
print(vec);
}
}
long long power(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1) ret *= x;
x *= x;
n >>= 1;
}
return ret;
}
long long comb(long long n, long long k) {
vector<vector<long long>> v(n + 1, vector<long long>(n + 1, 0));
for (long long i = 0; i < (long long)((v).size()); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (long long k = 1; k < (long long)((v).size()); k++) {
for (long long j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v[n][k];
}
void add(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
__attribute__((constructor)) void faster_io() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
long long n;
signed main() {
cin >> n;
vector<long long> xs(n), ys(n);
for (long long ni = 0; ni < (long long)(n); ni++) {
cin >> xs[ni] >> ys[ni];
}
for (long long ni = 0; ni < (long long)(n); ni++) {
xs.push_back(xs[ni]);
ys.push_back(ys[ni]);
}
if (n % 2 == 1) {
print("NO");
exit(0);
}
bool identity = true;
long long centerx = xs[0] + xs[n / 2], centery = ys[0] + ys[n / 2];
for (long long ni = 0; ni < (long long)(n / 2); ni++) {
long long x1 = xs[ni], y1 = ys[ni];
long long x2 = xs[ni + n / 2], y2 = ys[ni + n / 2];
if (x1 + x2 == centerx and y1 + y2 == centery) {
continue;
}
identity = false;
break;
}
if (identity) {
print("YES");
} else {
print("NO");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int f[550000];
int main() {
int n, d, sum = 0;
memset(f, 0, sizeof(f));
scanf("%d%d", &n, &d);
f[0] = 1;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
sum += a;
for (int j = sum; j >= a; j--)
if (f[j - a] != 0) f[j] = 1;
}
int ans = 0;
sum = 0;
for (;;) {
int i;
sum += d;
for (i = 0; i < d; i++)
if (f[sum - i]) break;
if (i == d) break;
sum -= i;
ans++;
}
printf("%d %d", sum - d, ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool win(char x, char y) {
if (x == 'R' && y == 'S') return 1;
if (x == 'S' && y == 'P') return 1;
if (x == 'P' && y == 'R') return 1;
return 0;
}
int n;
int a1, a2;
int i1, i2;
string s1, s2;
int m;
int main() {
cin >> n;
cin >> s1;
cin >> s2;
int l1 = s1.size(), l2 = s2.size();
m = l1 * l2;
for (int i = 0; i < m; i++) {
if (win(s1[i1], s2[i2]))
a2++;
else if (win(s2[i2], s1[i1]))
a1++;
if (i1 == l1 - 1)
i1 = 0;
else
i1++;
if (i2 == l2 - 1)
i2 = 0;
else
i2++;
}
a1 = n / m * a1;
a2 = n / m * a2;
for (int i = 0; i < n % m; i++) {
if (win(s1[i1], s2[i2]))
a2++;
else if (win(s2[i2], s1[i1]))
a1++;
if (i1 == l1 - 1)
i1 = 0;
else
i1++;
if (i2 == l2 - 1)
i2 = 0;
else
i2++;
}
cout << a1 << " " << a2 << endl;
return 0;
}
| 2 |