solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 106, mod = 1000000009;
int n, m, deg[N], fix[N], vis[N], isr[N];
int fac[N], inv[N], ifac[N];
vector<int> G[N], v;
vector<int> operator+(const vector<int> &a, const vector<int> &b) {
vector<int> c(max(a.size(), b.size()), 0);
for (int i = 0; i < (int)c.size(); i++) {
c[i] =
((i < (int)a.size() ? a[i] : 0) + (i < (int)b.size() ? b[i] : 0)) % mod;
}
return c;
}
vector<int> operator*(const vector<int> &a, const vector<int> &b) {
vector<int> c(a.size() + b.size() - 1, 0);
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)b.size(); j++) {
c[i + j] = (c[i + j] + (long long)a[i] * b[j] % mod * ifac[i] % mod *
ifac[j] % mod * fac[i + j]) %
mod;
}
}
return c;
}
void get1(int x) {
v.push_back(x);
vis[x] = 1;
for (auto y : G[x])
if (fix[y] && !vis[y]) {
get1(y);
}
}
vector<int> dp(int x, int pre) {
vector<int> f(1, 1);
for (auto y : G[x])
if (fix[y] && y != pre) {
f = f * dp(y, x);
}
f.push_back(f.back());
return f;
}
int main() {
scanf("%d%d", &n, &m);
fac[0] = fac[1] = inv[0] = inv[1] = ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n; i++) {
fac[i] = (long long)fac[i - 1] * i % mod;
inv[i] = mod - (long long)mod / i * inv[mod % i] % mod;
ifac[i] = (long long)inv[i] * ifac[i - 1] % mod;
}
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
deg[x]++;
deg[y]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (deg[i] <= 1) {
fix[i] = 1;
q.push(i);
}
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto y : G[x]) {
if (!fix[y] && --deg[y] <= 1) {
fix[y] = 1;
q.push(y);
}
}
}
for (int i = 1; i <= n; i++)
if (!fix[i]) {
for (auto j : G[i])
if (fix[j]) {
isr[j] = 1;
}
}
vector<int> f(1, 1);
for (int i = 1; i <= n; i++)
if (fix[i] && !vis[i]) {
v.clear();
get1(i);
int rt = 0;
for (auto x : v)
if (isr[x]) {
rt = x;
}
vector<int> g(0);
if (rt) {
g = dp(rt, -1);
} else {
for (auto x : v) {
g = g + dp(x, -1);
}
for (int i = 0; i < (int)g.size(); i++) {
g[i] = (long long)g[i] * inv[(int)v.size() - i] % mod;
}
}
f = f * g;
}
for (int i = 0; i <= n; i++) {
printf("%d\n", i < (int)f.size() ? f[i] : 0);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void test(int a, int b, int c, int d) {
printf("%d %d %d %d", a, b, c, d);
printf("\n");
}
void test(int a, int b, int c) {
printf("%d %d %d ", a, b, c);
printf("\n");
}
void test(int a, int b) {
printf("%d %d ", a, b);
printf("\n");
}
void test(char a, char b, char c, char d) {
printf("%c %c %c %c", a, b, c, d);
printf("\n");
}
int main() {
int t = 1;
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
int a[n][m];
int sr = -1, f = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i][0]);
for (int j = 1; j < m; j++) {
scanf("%d", &a[i][j]);
if (f) {
if (a[i][j] != a[i][j - 1]) {
f = 0;
sr = i;
}
}
}
if (i != sr) ans = ans ^ a[i][0];
}
if (sr == -1) {
if (ans == 0)
printf("NIE\n");
else {
printf("TAK\n");
for (int i = 0; i < n; i++) {
printf("%d", 1);
printf(" ");
}
}
} else {
printf("TAK\n");
for (int j = 0; j < n; j++) {
if (j != sr) {
printf("%d", 1);
printf(" ");
} else {
for (int i = 0; i < m; i++) {
if (a[sr][i] != ans) {
printf("%d", i + 1);
printf(" ");
break;
}
}
}
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[120000];
int main() {
char input[100005];
scanf("%s", input);
int len = strlen(input);
stack<char> st;
for (int i = 0; i < len; i++) {
if (st.size() == 0) {
st.push(input[i]);
continue;
}
if (st.top() == input[i]) {
st.pop();
} else {
st.push(input[i]);
}
}
if (st.size() == 0)
cout << "Yes";
else
cout << "No";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long check(long long n) {
long long d = n % 10;
while (n > 9) n /= 10;
return d == n;
}
long long pow(long long a, long long b) {
if (b == 0) return 1;
long long t = pow(a, b / 2);
if (b % 2)
return (a * t * t);
else
return (t * t);
}
long long f(long long n) {
while (!check(n)) n--;
long long m = n, c = 0;
while (m != 0) {
m /= 10;
c++;
}
long long ans = 0;
for (long long i = 1; i < c; i++) {
if (i == 1)
ans += 9;
else
ans += 9 * pow(10, i - 2);
}
if (c < 2) return n;
ans += (n % 10 - 1) * pow(10, c - 2);
long long k = 0;
while (n > 9) {
k = 10 * k + n % 10;
n /= 10;
}
m = k;
k = 0;
while (m > 9) {
k = 10 * k + m % 10;
m /= 10;
}
ans += k + 1;
return ans;
}
void solve() {
long long l, r;
cin >> l >> r;
cout << (f(r) - f(l - 1));
}
signed main() {
ios_base::sync_with_stdio(false);
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize "Ofast,omit-frame-pointer,inline"
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int mx = -INT_MAX;
multiset<int> vs;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
mx = max(mx, x);
vs.insert(x);
}
mx += m;
while (m--) {
int p = *vs.begin();
vs.insert(p + 1);
vs.erase(vs.begin());
}
cout << (*vs.rbegin()) << " " << mx << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool visited[10][10];
int dist[10][10];
int sx, sy, ex, ey;
int dx[] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[] = {1, 0, -1, 1, -1, 1, 0, -1};
string dir[8] = {"RU", "R", "RD", "U", "D", "LU", "L", "LD"};
map<pair<int, int>, pair<int, int> > path;
vector<pair<int, int> > V;
void get_ans() {
for (int i = 1; i < V.size(); i++) {
int tx = V[i].first;
int ty = V[i].second;
int bx = V[i - 1].first;
int by = V[i - 1].second;
for (int i = 0; i < 8; i++) {
if (bx + dx[i] == tx && by + dy[i] == ty) {
cout << dir[i] << endl;
break;
}
}
}
}
void print_path(int ex, int ey, int sx, int sy) {
pair<int, int> P = path[{ex, ey}];
if (P.first == 0 && P.second == 0) return;
print_path(P.first, P.second, sx, sy);
V.push_back({P.first, P.second});
}
bool valid(int nx, int ny) {
return (nx >= 1 && ny >= 1 && nx <= 8 && ny <= 8);
}
void bfs() {
queue<pair<int, int> > Q;
Q.push({sx, sy});
visited[sx][sy] = true;
while (!Q.empty()) {
pair<int, int> F = Q.front();
int x = F.first;
int y = F.second;
Q.pop();
for (int i = 0; i < 8; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (valid(nx, ny) && !visited[nx][ny]) {
visited[nx][ny] = true;
dist[nx][ny] = dist[x][y] + 1;
Q.push({nx, ny});
path[{nx, ny}] = {x, y};
}
}
}
}
int main(int argc, char const *argv[]) {
string a, b;
cin >> a >> b;
sx = a[0] - 'a' + 1;
sy = a[1] - '0';
ex = b[0] - 'a' + 1;
ey = b[1] - '0';
bfs();
printf("%d\n", dist[ex][ey]);
print_path(ex, ey, sx, sy);
V.push_back({ex, ey});
get_ans();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7f7f7f7f;
const long long linf = 1e18;
const int maxn = 1e5 + 9;
const int maxm = 4e5 + 9;
const double PI = 3.1415926;
const double eps = 1e-5;
const long long mod = 998244353;
const int base = 131;
const int N = 1e6;
namespace IO {
long long read() {
long long a = 1, b = 0;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') a = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
b = (b << 3) + (b << 1) + c - '0';
c = getchar();
}
return a * b;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
} // namespace IO
using namespace IO;
int n;
int m1, m2;
int f1[maxn], f2[maxn];
int find1(int x) { return x == f1[x] ? x : f1[x] = find1(f1[x]); }
int find2(int x) { return x == f2[x] ? x : f2[x] = find2(f2[x]); }
vector<pair<int, int> > s;
int main() {
clock_t st, ed;
st = clock();
int cse = 1;
while (cse--) {
n = read();
m1 = read(), m2 = read();
int u, v;
s.clear();
for (int i = 1; i <= n; ++i) f1[i] = f2[i] = i;
for (int i = 1; i <= m1; ++i) {
u = read(), v = read();
f1[find1(u)] = f1[find1(v)];
}
for (int i = 1; i <= m2; ++i) {
u = read(), v = read();
f2[find2(u)] = f2[find2(v)];
}
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
int x = find1(i), y = find1(j);
if (x != y) {
u = find2(i), v = find2(j);
if (u != v) {
s.push_back(pair<int, int>(i, j));
f1[x] = y;
f2[u] = v;
}
}
}
}
print(s.size());
putchar('\n');
for (auto x : s) {
print(x.first);
putchar(' ');
print(x.second);
putchar('\n');
}
}
ed = clock();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, pair<long long, long long> > H;
long long n;
pair<long long, long long> dfs(pair<long long, long long> x) {
long long tmp = 1, Ans;
if (x.second < 10)
return make_pair(x.first || x.second, min(x.second - x.first, 0ll));
if (H.find(x) != H.end()) return H[x];
while (tmp * 10 <= x.second) tmp *= 10;
pair<long long, long long> ttmp =
dfs(make_pair(max(x.second / tmp, x.first), x.second % tmp));
Ans = ttmp.first;
ttmp = dfs(make_pair(x.first, (x.second / tmp) * tmp + ttmp.second));
return H[x] = make_pair(Ans + ttmp.first, ttmp.second);
}
int main() {
scanf("%I64d", &n);
printf("%I64d\n", dfs(make_pair(0, n)).first);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, pref[105], surf[105], tab[105];
int res;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tab[i];
pref[i] = 1 - tab[i];
pref[i] += pref[i - 1];
}
for (int i = n; i >= 1; i--) {
surf[i] = surf[i + 1] + tab[i];
}
for (int i = 1; i <= n; i++) res = max(res, pref[i] + surf[i]);
cout << res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int spf[2750132] = {}, prime_list[200000], x = 0;
void calculate() {
for (int i = 2; i <= 1658; i++)
if (!spf[i]) {
prime_list[++x] = i;
for (int j = i * i; j <= 2750131; j += i)
if (!spf[j]) spf[j] = i;
}
for (int i = 1659; i <= 2750131; i++)
if (!spf[i]) prime_list[++x] = i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
calculate();
int n, x;
cin >> n;
multiset<int> prime, comp;
vector<int> a;
for (int i = 1; i <= 2 * n; i++) {
cin >> x;
if (!spf[x])
prime.insert(x);
else
comp.insert(x);
}
while (!comp.empty()) {
int rem = *comp.rbegin(), div = rem / spf[rem];
a.push_back(rem);
if (spf[div])
comp.erase(comp.lower_bound(div));
else
prime.erase(prime.lower_bound(div));
comp.erase(--comp.end());
}
while (!prime.empty()) {
int rem = *prime.begin(), div = prime_list[rem];
a.push_back(rem);
prime.erase(prime.lower_bound(div));
prime.erase(prime.begin());
}
for (int i : a) cout << i << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200005];
bool leaf[200005];
int n, k;
void dfs(int u, int par) {
leaf[u] = 1;
if (u != 1 && adj[u].size() == 1) return;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == par) continue;
dfs(v, u);
if (leaf[v]) leaf[u] = 0;
}
if (u != 1 && !leaf[u]) k++;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> n;
for (int j = 1; j <= n; j++) adj[j].clear();
for (int j = 1; j < n; j++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
k = 0;
dfs(1, -1);
bool exist = 0;
for (int j = 0; j < adj[1].size(); j++) {
int u = adj[1][j];
if (leaf[u]) {
exist = 1;
break;
}
}
if (exist)
cout << n - 2 * k - 1 << '\n';
else
cout << n - 2 * k << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, m, t1, t2 = 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(6);
cerr.precision(7);
;
cin >> n >> m;
if (n == m && n == 1) {
cout << 1;
return 0;
}
if (m + n < 5) {
cout << -1;
return 0;
}
t1 = n * m / 2 + 1;
for (int i = 0; i < n; i++, cout << "\n")
for (int j = 0; j < m; j++)
if (!((i + j) % 2))
cout << t1 << " ", t1++;
else
cout << t2 << " ", t2++;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=3e5+7,NN=1e9+7;
ll n,m,shen[N],fa[N][20],lg[N],ans,tong[N],l[N],r[N],now,a[N];
vector <ll> bian[N];
queue <ll> q;
struct Lian{
ll lca,lll,rrr,u,v;
}lian[N];
void dfs(ll i){
l[i]=++now;
if(bian[i].size())
for(ll ii=bian[i].size()-1;ii>=0;ii--){
if(shen[bian[i][ii]]==0){
shen[bian[i][ii]]=shen[i]+1;
fa[bian[i][ii]][0]=i;
dfs(bian[i][ii]);
}
}
r[i]=now;
}
ll lowbit(ll i) {return i&-i;}
ll cha(ll i) {
//cout<<" cha"<<i<<endl;
ll s=a[i];
while(i=i-lowbit(i)) s+=a[i];
return s;
}
void gai(ll i) {
//cout<<"gai"<<i<<endl;
if(i)
while(i<=n) {
a[i]++;
i+=lowbit(i);
}
}
ll wen(ll x){
//cout<<"wen"<<x<<endl;
if(x==0)
return 0;
return cha(r[x])-cha(l[x]-1);
}
bool cmp(Lian a,Lian b){
if(shen[a.lca]!=shen[b.lca])
return shen[a.lca]<shen[b.lca];
if(a.lca!=b.lca)
return a.lca<b.lca;
if(a.lll!=b.lll)
return a.lll<b.lll;
return a.rrr<b.rrr;
}
ll lca(ll u,ll v){
if(shen[u]>shen[v]){
ll k=u; u=v; v=k;
}
while(shen[u]<shen[v]){
v=fa[v][lg[shen[v]-shen[u]]];
}
if(u==v)
return u;
for(ll ii=lg[shen[u]];ii>=0;ii--){
if(fa[u][ii]!=fa[v][ii]){
u=fa[u][ii];
v=fa[v][ii];
}
}
return fa[u][0];
}
ll lcazi(ll v,ll s){
if(s>shen[v])
return 0;
while(s<shen[v]){
v=fa[v][lg[shen[v]-s]];
}
return v;
}
int main()
{
scanf("%lld",&n);
for(ll i=1;i<n;i++){
ll u,v;
scanf("%lld%lld",&u,&v);
bian[u].push_back(v);
bian[v].push_back(u);
}
shen[1]=1;
dfs(1);
for(ll i=1;i<20;i++){
for(ll ii=1;ii<=n;ii++){
fa[ii][i]=fa[fa[ii][i-1]][i-1];
}
}
ll er=2;
for(ll i=1;i<=n;i++){
lg[i]=lg[i-1];
if(i==er){
er<<=1;
lg[i]++;
}
}
scanf("%lld",&m);
lian[0]={0,0,0};
for(ll i=1;i<=m;i++){
ll u,v;
scanf("%lld%lld",&u,&v);
ll lc=lca(u,v);
ll zv=lcazi(v,shen[lc]+1);
ll zu=lcazi(u,shen[lc]+1);
lian[i]={lc,min(zv,zu),max(zv,zu),u,v};
}
sort(lian+1,lian+m+1,cmp);
ll cnt=0,lcnt=0,zuo=1;
for(ll i=1;i<=m;i++){
if(lian[i].lca!=lian[i-1].lca)
lcnt=cnt=0;
else if(lian[i].lll!=lian[i-1].lll){
lcnt+=cnt;
cnt=0;
}
if(lian[i].lca!=lian[i-1].lca||lian[i].lll!=lian[i-1].lll||lian[i-1].lll==0){
for(ll ii=i-1;ii>=zuo;ii--){
if(lian[ii].rrr)
tong[lian[ii].rrr]++;
}
zuo=i;
}
ans=ans+lcnt-tong[lian[i].rrr]-tong[lian[i].lll];
if(lian[i].lll)
cnt++;
else
lcnt++;
}
zuo=1;
for(ll i=1;i<=m;i++){
if(lian[i].lca!=lian[i-1].lca){
for(ll ii=i-1;ii>=zuo;ii--){
gai(l[lian[ii].u]);
gai(l[lian[ii].v]);
}
zuo=i;
}
ans=ans+wen(lian[i].lca)-wen(lian[i].lll)-wen(lian[i].rrr);
}
printf("%lld\n",ans);
}
/*
https://vjudge.net/problem/POJ-3321
10 2
1 1 8
9 1 2
*/
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
bool bad[MAXN];
set<int> all, av, out;
string s[MAXN];
int id[MAXN];
bool mark[MAXN];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> s[i] >> id[i];
id[i]--;
if (s[i][0] == '+') {
if (i != 0 && !mark[id[i]]) bad[id[i]] = true;
all.insert(id[i]);
} else {
if (all.find(id[i]) == all.end())
av.insert(id[i]);
else
av.erase(id[i]);
}
mark[id[i]] = true;
}
for (int i = 0; i < m; i++) {
if (s[i][0] == '+') {
out.erase(id[i]);
if ((int)av.size() > 0)
bad[id[i]] = true;
else {
for (set<int>::iterator it = out.begin(); it != out.end(); it++)
bad[*it] = true;
out.clear();
}
av.insert(id[i]);
} else {
av.erase(id[i]);
if ((int)av.size() > 0) bad[id[i]] = true;
if (!bad[id[i]]) out.insert(id[i]);
}
}
int k = 0;
for (int i = 0; i < n; i++)
if (!bad[i]) k++;
cout << k << endl;
for (int i = 0; i < n; i++)
if (!bad[i]) cout << i + 1 << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 710;
bool b[maxn][maxn];
int a[maxn], dp[maxn][maxn][2], vis[maxn][maxn];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void dfs(int l, int r) {
if (vis[l][r]) return;
vis[l][r] = 1;
if (l > r) dp[l][r][0] = dp[l][r][1] = 1;
if (l == r) dp[l][r][0] += b[l - 1][l], dp[l][r][1] += b[r + 1][l];
for (int i = l; i <= r; i++) {
dfs(l, i - 1);
dfs(i + 1, r);
if (dp[l][i - 1][1] && dp[i + 1][r][0])
dp[l][r][0] += b[l - 1][i], dp[l][r][1] += b[r + 1][i];
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) b[i][j] = gcd(a[i], a[j]) > 1;
for (int i = 1; i <= n; i++) {
dfs(1, i - 1);
dfs(i + 1, n);
if (dp[1][i - 1][1] && dp[i + 1][n][0]) {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sum[500001];
int main() {
int n, d;
scanf("%d%d", &n, &d);
sum[0] = 1;
for (int i = 0, c; i < n; ++i) {
scanf("%d", &c);
for (int s = 500000; s >= 0; --s)
if (sum[s]) sum[s + c] = 1;
}
vector<int> var;
for (int i = 1; i < 500001; ++i)
if (sum[i]) var.push_back(i);
int s = 0, c = 0;
for (int i = 0; i < var.size(); ++i) {
while (s + d >= var[i] && i < var.size()) i++;
if (s + d >= var[--i] && s != var[i]) {
s = var[i];
c++;
} else
break;
}
printf("%d %d\n", s, c);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, x, y, a;
cin >> t;
while (t--) {
cin >> x >> y;
if (x - y > 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
if (n % 3 != 0) {
cout << 0 << endl;
return 0;
}
n /= 3;
if (n % 2 != 0) {
cout << 0 << endl;
return 0;
}
vector<long long> divisors;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) divisors.push_back(i);
}
long long c = 0;
for (long long r = 1; r * r * r <= n; r++) {
if (n % r != 0) continue;
auto it = divisors.begin();
long long l = *it;
while (it != divisors.end() && r * l * l <= n) {
if (l < r) {
advance(it, 1);
l = *it;
continue;
}
if (n % (r * l) != 0) {
advance(it, 1);
l = *it;
continue;
}
long long t = n / (r * l);
if (r > l || l > t) {
advance(it, 1);
l = *it;
continue;
}
if ((r + l + t) % 2 != 0) {
advance(it, 1);
l = *it;
continue;
}
long long u = (r + l + t) / 2;
long long x = u - t;
long long y = u - l;
long long z = u - r;
if (x > 0 && y > 0 && z > 0) {
if (x != y && y != z)
c += 6;
else if ((x == y && y != z) || (x != y && y == z))
c += 3;
else
c++;
}
advance(it, 1);
l = *it;
}
}
cout << c << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a, b, c;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n;
int s = 0;
for (int i(0); i < n; i++) {
int x;
cin >> x;
s += x;
}
cin >> m;
int ans = -1;
for (int i(0); i < m; i++) {
int l, r;
cin >> l >> r;
if (l <= s && r >= s) {
ans = s;
}
if (l > s) {
if (ans < 0) ans = l;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
pair<int, int> t[4 * maxn];
int psh[maxn];
void update(int v, int l, int r, int q) {
if (l == r) return void(t[v] = psh[q] ? make_pair(1, 0) : make_pair(0, 1));
int m = (l + r) / 2;
if (q <= m) update(v * 2, l, m, q);
if (q > m) update(v * 2 + 1, m + 1, r, q);
int u = min(t[v * 2].first, t[v * 2 + 1].second);
t[v] = make_pair(t[v * 2].first + t[v * 2 + 1].first - u,
t[v * 2].second + t[v * 2 + 1].second - u);
}
int get_ans(int v, int l, int r, int c) {
if (!t[v].first) return -1;
if (l == r) return psh[l];
int m = (l + r) / 2;
if (t[v * 2 + 1].first - c > 0)
return get_ans(v * 2 + 1, m + 1, r, c);
else
return get_ans(v * 2, l, m, c - t[v * 2 + 1].first + t[v * 2 + 1].second);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int q, t, num;
scanf("%d %d", &q, &t);
if (t == 1) {
scanf("%d", &num);
psh[q] = num;
}
update(1, 1, n, q);
printf("%d\n", get_ans(1, 1, n, 0));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
const int N = 4010, M = 998244353;
int H[N], G[N];
int r[N], c[N];
int f[N][N], g[N][N];
void add(int &a, int b) {
a += b;
if (a >= M) a -= M;
}
int mul(int a, int b) { return (long long)a * b % M; }
int pw(int a, int i) {
int b = 1;
for (; i; i >>= 1, a = mul(a, a))
if (i & 1) b = mul(b, a);
return b;
}
int P(int n, int k) {
if (n < k) return 0;
return mul(G[n], H[n - k]);
}
int main() {
for (int i = 0, _c = 4000; i <= _c; ++i) G[i] = i ? mul(G[i - 1], i) : 1;
for (int i = 4000, _c = 0; i >= _c; --i)
H[i] = i < 4000 ? mul(H[i + 1], i + 1) : pw(G[i], M - 2);
int m = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
n = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
k = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
});
for (int i = 1, _c = k; i <= _c; ++i) {
int x = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
y = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
u = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
}),
v = ({
int x = 0;
int c = getchar(), n = 0;
for (; !isdigit(c); c = getchar()) n = (c == '-');
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
n ? -x : x;
});
for (int j = min(x, u), _c = max(x, u); j <= _c; ++j) r[j] = 1;
for (int j = min(y, v), _c = max(y, v); j <= _c; ++j) c[j] = 1;
}
int R = 0, C = 0;
for (int i = 1, _c = m; i <= _c; ++i) R += !r[i];
for (int i = 1, _c = n; i <= _c; ++i) C += !c[i];
f[0][0] = g[0][0] = 1;
for (int i = 1, _c = m; i <= _c; ++i) {
for (int j = 0, _c = m; j <= _c; ++j) {
add(f[i][j], f[i - 1][j]);
if (i > 1 && j && r[i] + r[i - 1] == 0) add(f[i][j], f[i - 2][j - 1]);
}
}
for (int i = 1, _c = n; i <= _c; ++i) {
for (int j = 0, _c = n; j <= _c; ++j) {
add(g[i][j], g[i - 1][j]);
if (i > 1 && j && c[i] + c[i - 1] == 0) add(g[i][j], g[i - 2][j - 1]);
}
}
int ret = 0;
for (int i = 0, _c = R; i <= _c; ++i) {
for (int j = 0, _c = C; j <= _c; ++j) {
add(ret,
mul(mul(f[m][i], P(C - j * 2, i)), mul(g[n][j], P(R - i * 2, j))));
}
}
cout << ret;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
cout << x << " " << y << "\n";
if (i % 3 == 0)
x++;
else if (i % 3 == 1)
y ^= 3;
else
x++, y ^= 3;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vb vector<bool>
#define vpi vector<pii>
#define vpl vector<pll>
#define pb push_back
#define all(v) v.begin(),v.end()
#define fast_io ios_base::sync_with_stdio(false),cin.tie(NULL);
void cout_vector(vector<ll> v){
for (ll unsigned i=0; i<v.size(); i++) cout << v[i] << " ";
cout<<endl;
}
int sum_vector(vi v){
return accumulate(all(v),0);
}
void sort_vector(vi&v){
sort(all(v));
}
void sort_comp(vi &v, bool func(int,int)){
sort(all(v),func);
}
bool comp(int a,int b){
bool aend=0;
if(a%2) a--,aend=1;
if(b%2) b--;
a/=2;
b/=2;
if(a==b){
if(aend) return 1;
return 0;
}
if(a<b) return 1;
return 0;
}
ll gcd(ll a, ll b){
while(a){
ll temp =a;
a=b%a;
b=temp;
}
return b;
}
ll lcm(ll a, ll b){
return (a*b)/gcd(a,b);
}
string binary(ll num){
string ans="";
do{
ans=to_string(num%2)+ans;
num/=2;
}while(num);
return ans;
}
const int mxn = 1e5+5;
const ll mod = 1e9+7;
ll pwr(ll num, ll p, ll modi){
ll res=1;
while(p>0){
if(p&1){res*=num; res%=modi;}
num*=num;
num%=modi;
p/=2;
}
return res;
}
ll inverse(ll num){
return pwr(num,mod-2,mod);
}
void solve(){
int n;
cin>>n;
vector<vi>v(n+2);
for(int i=0;i<n+2;i++){
v[i].pb(2*n);
}
vi arr(n);
for(int i=0;i<n;i++){
cin>>arr[i];
}
for(int i=n-1;i>=0;i--){
v[arr[i]].pb(i);
}
int a=0,b=0;
int cur;
int ans=0;
for(int i=0;i<n;i++){
cur = arr[i];
v[cur].pop_back();
if(cur==a || cur==b) continue;
if(v[a].back()<v[b].back()){
b=cur;
ans++;
}
else{
a=cur;
ans++;
}
}
cout<<ans;
}
int main()
{
fast_io
int t;
//cin>>t;
t=1;
while(t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<string> vi;
map<long long, long long> mp;
int mi = 0;
int ma = 0;
int valid(string s) {
stack<char> st;
set<char> myset;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ')') {
if (!st.empty() && st.top() == '(') {
st.pop();
continue;
}
st.push(s[i]);
} else {
st.push(s[i]);
}
}
if (st.empty()) return 1;
while (!st.empty()) {
myset.insert(st.top());
st.pop();
}
if (myset.size() == 1)
return 1;
else
return 0;
}
void process(string s, int index) {
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
count += 1;
else
count -= 1;
}
if (!valid(s)) return;
if (count < 0) {
mi = min(mi, count);
} else if (count > 0) {
ma = max(ma, count);
}
if (mp.find(count) != mp.end())
mp[count] += 1;
else
mp[count] = 1;
}
int main() {
cin >> n;
vi.assign(n, "");
string tmp;
long long ans;
int cnt = 0;
for (int i = 0; i < vi.size(); i++) {
cin >> tmp;
vi[i] = tmp;
}
for (int i = 0; i < vi.size(); i++) {
process(vi[i], i);
}
ans = mp[0] * mp[0];
for (int i = 1; i <= max(abs(ma), abs(mi)); i++) {
ans += (mp[-i] * mp[i]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e15;
int N, M, K;
long long tim;
long long gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long d = gcd(b, a % b, x, y);
long long tmp = x;
x = y;
y = tmp - a / b * y;
return d;
}
void mininal_x(long long &x, long long &y, long long a, long long b) {
if (b < 0) b = -b, a = -a;
long long t = x / b;
x -= t * b;
y += t * a;
while (x < 0) x += b, y -= a;
}
void mininal_y(long long &x, long long &y, long long a, long long b) {
if (a < 0) a = -a, b = -b;
long long t = y / a;
y -= t * a;
x += t * b;
while (y < 0) y += a, x -= b;
}
long long calc(int p, int n, int q, int m) {
static int lastn = 0, lastm = 0;
static long long xx, yy, dd;
if (lastn != n || lastm != m) {
dd = gcd(n, -m, xx, yy);
lastn = n, lastm = m;
}
long long a = n, b = -m, c = q - p;
long long d = dd, x = xx, y = yy;
if (c % d != 0) return oo;
a /= d, b /= d, c /= d;
x *= c, y *= c;
mininal_x(x, y, a, b);
if (y < 0) mininal_y(x, y, a, b);
if (p + x * n == 0) x += abs(b);
return p + x * n;
}
long long solve(int x, int y) {
int nn = N << 1, mm = M << 1;
long long ret = calc(x, nn, y, mm);
ret = min(ret, calc(x, nn, mm - y, mm));
ret = min(ret, calc(nn - x, nn, y, mm));
ret = min(ret, calc(nn - x, nn, mm - y, mm));
return ret;
}
int main() {
for (; scanf("%d%d%d", &N, &M, &K) != EOF;) {
tim = min(solve(0, 0), solve(N, M));
tim = min(tim, max(solve(0, M), solve(N, 0)));
for (int i = (1), _i = (K); i <= _i; i++) {
int x, y;
scanf("%d%d", &x, &y);
long long ret = solve(x, y);
if (ret != oo)
printf("%I64d\n", ret);
else
printf("-1\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T zz) {
return zz < 0 ? -zz : zz;
}
template <typename T>
inline T sqr(T zz) {
return zz * zz;
}
int main() {
long long n, s;
while (cin >> n >> s) {
long long ans = s / n;
if (s % n != 0) {
ans++;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int sum[1000000];
bool bz[1000000];
long long all;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
bz[i] = 1;
for (int j = 2; (long long)j * i <= n; j++) sum[j * i]++, all++;
}
if (all < k) {
printf("No");
return 0;
}
for (int i = n; i; i--) {
int tot = sum[i];
for (int j = 2; (long long)j * i <= n; j++)
if (bz[i * j]) tot++;
if (tot > 1 && all - tot >= k) {
bz[i] = 0, all -= tot;
for (int j = 1; (long long)j * i <= n; j++)
if (bz[i * j]) sum[i * j]--;
}
}
for (int i = n; i; i--)
if (bz[i]) {
int tot = sum[i];
for (int j = 2; (long long)j * i <= n; j++)
if (bz[i * j]) tot++;
if (tot == 1 && all - tot >= k) {
bz[i] = 0, all -= tot;
for (int j = 1; (long long)j * i <= n; j++)
if (bz[i * j]) sum[i * j]--;
}
}
if (all == k) {
printf("Yes\n");
int tot = 0;
for (int i = 1; i <= n; i++) tot += bz[i];
printf("%d\n", tot);
for (int i = 1; i <= n; i++)
if (bz[i]) printf("%d ", i);
} else
printf("No");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
cout << (a + b + c) * (a + b + c) - a * a - c * c - e * e;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int i, l = 0, p = 0, sum = 0, f = 0;
char s;
while (scanf("%c", &s) != EOF) {
if (s == '\n') {
f = 0;
sum += p * l;
l = 0;
} else if (s == ':') {
f = 1;
} else if (f == 1) {
l++;
} else if (s == '+') {
p++;
f = 0;
} else if (s == '-') {
p--;
f = 0;
}
}
printf("%d", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int cmpfunc(const void *a, const void *b) { return (*(int *)a - *(int *)b); }
int custo;
int v[3000];
int main(int argc, char **argv) {
int n;
scanf("%d ", &n);
for (int i = 0; i < n; i++) scanf("%d ", &v[i]);
qsort(v, n, sizeof(int), cmpfunc);
int last = -1, custo = 0;
for (int i = 0; i < n; i++) {
if (v[i] > last)
last = v[i];
else
custo += ++last - v[i];
}
printf("%d\n", custo);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 2;
int val[maxn];
long long _max;
long long f[maxn], s[maxn];
vector<int> edge[maxn];
void dfs(int u, int fa) {
s[u] = val[u];
f[u] = 0;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v != fa) {
dfs(v, u);
f[u] += f[v] + s[v];
s[u] += s[v];
}
}
}
void dfs(int u, int fa, long long updates, long long updatef) {
_max = max(_max, f[u] + updatef);
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v != fa) {
long long ups = updates + s[u] - s[v];
dfs(v, u, ups, updatef + f[u] - f[v] - s[v] + ups);
}
}
}
int main() {
int n, x, y;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
edge[x].push_back(y);
edge[y].push_back(x);
}
_max = 0;
dfs(1, 0);
dfs(1, 0, 0, 0);
printf("%lld\n", _max);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
bool vis1[N], vis2[N], q;
int t, n, m, a, b, cnt1, cnt2, cnt;
vector<int> adj[N];
void _clear() {
cnt1 = cnt2 = 0;
for (int i = 1; i <= n; i++) {
adj[i].clear();
vis1[i] = vis2[i] = 0;
}
}
void dfs1(int u) {
vis1[u] = 1;
cnt++;
if (u == b) q = 1;
for (auto x : adj[u])
if (!vis1[x] && x != a) dfs1(x);
}
void dfs2(int u) {
vis2[u] = 1;
cnt++;
if (u == a) q = 1;
for (auto x : adj[u])
if (!vis2[x] && x != b) dfs2(x);
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &n, &m, &a, &b);
_clear();
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (auto x : adj[a]) {
q = cnt = 0;
if (!vis1[x]) {
dfs1(x);
if (!q) cnt1 += cnt;
}
}
for (auto x : adj[b]) {
q = cnt = 0;
if (!vis2[x]) {
dfs2(x);
if (!q) cnt2 += cnt;
}
}
printf("%lld\n", 1LL * cnt1 * cnt2);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
int n, m, dp[MAXN], level[MAXN];
int dist[MAXN], val[MAXN * 3];
int local[MAXN], answer[MAXN];
vector<pair<int, int>> adj[MAXN], nex[MAXN];
bool cut_edge[MAXN * 3];
bool mark[MAXN];
void dfs_cut_edge(int v, int par = 0) {
dp[v] = level[v] = level[par] + 1;
mark[v] = true;
for (auto i : adj[v]) {
if (!mark[i.first]) {
dfs_cut_edge(i.first, v);
dp[v] = min(dp[v], dp[i.first]);
if (dp[i.first] > level[v]) cut_edge[i.second] = true;
} else if (i.first != par)
dp[v] = min(dp[v], level[i.first]);
}
}
void bfs(int v) {
queue<int> q;
dist[v] = 1;
q.push(v);
while (q.size()) {
int tp = q.front();
q.pop();
for (auto i : adj[tp]) {
if (!dist[i.first]) {
dist[i.first] = dist[tp] + 1;
q.push(i.first);
}
if (dist[i.first] == (dist[tp] + 1)) nex[tp].push_back(i);
}
}
}
void dfs_(int v, int par = 0) {
mark[v] = true;
for (auto i : nex[v]) {
if (!mark[i.first]) dfs_(i.first, v);
dp[v] = max(dp[v], dp[i.first] + 1);
if (cut_edge[i.second]) val[i.second] = dp[i.first] + 1;
}
}
inline int get_dist(int l, int r, int len) {
if (l > r) return len - l + r;
return r - l;
}
inline int get_(pair<int, int> p, int id, int len) {
return p.first + get_dist(p.second, id, len);
}
void dfs(int v, int par = 0) {
mark[v] = true;
vector<int> cycle;
cycle.push_back(v);
while (true) {
bool re = false;
for (auto i : adj[cycle.back()])
if (!mark[i.first] && !cut_edge[i.second]) {
cycle.push_back(i.first);
mark[i.first] = true;
re = true;
break;
}
if (!re) break;
}
for (auto v : cycle)
for (auto e : adj[v])
if (cut_edge[e.second]) local[v] = max(local[v], val[e.second]);
int len = cycle.size();
deque<pair<int, int>> deq;
auto stackf = [&](int happy) {
for (int i = happy; i; i--) {
int v = cycle[len - i];
pair<int, int> me(local[v], len - i);
while (deq.size() && get_(me, 0, len) >= get_(deq.back(), 0, len))
deq.pop_back();
deq.push_back(me);
}
for (int i = 0; i < len; i++) {
while (deq.size() && get_dist(deq.front().second, i, len) > happy)
deq.pop_front();
if (deq.size())
dp[cycle[i]] = max(dp[cycle[i]], get_(deq.front(), i, len));
if (i == (len - 1)) break;
int v = cycle[i];
pair<int, int> me(local[v], i);
while (deq.size() && get_(me, i + 1, len) >= get_(deq.back(), i + 1, len))
deq.pop_back();
deq.push_back(me);
}
};
stackf(len / 2);
deq.clear();
reverse(cycle.begin(), cycle.end());
stackf((len - 1) / 2);
for (auto i : cycle) answer[i] = max(dp[i], local[i]);
for (auto i : cycle) {
int id = 0, mx = 0, smx = 0;
for (auto e : adj[i])
if (cut_edge[e.second])
if (val[e.second] > mx) {
mx = val[e.second];
id = e.first;
}
for (auto e : adj[i])
if (cut_edge[e.second] && e.first != id) smx = max(smx, val[e.second]);
for (auto e : adj[i])
if (cut_edge[e.second] && !mark[e.first]) {
if (e.first == id) {
val[e.second] = max(dp[i], smx) + 1;
dfs(e.first, i);
} else {
val[e.second] = max(dp[i], mx) + 1;
dfs(e.first, i);
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
dfs_cut_edge(1);
bfs(1);
memset(mark, 0, sizeof(mark));
memset(dp, 0, sizeof(dp));
dfs_(1);
memset(mark, 0, sizeof(mark));
memset(dp, 0, sizeof(dp));
dfs(1);
for (int i = 1; i <= n; i++) cout << answer[i] << ' ';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1009;
double PI = acos(-1);
int k;
int reverse(int num, int log_n) {
int res = 0;
for (int i = 0; i < log_n; i++)
if ((1 << i) & num) res += (1 << (log_n - 1 - i));
return res;
}
void fft(vector<complex<double> >& a, bool invert) {
int n = a.size(), log_n = 0;
while ((1 << log_n) < n) log_n++;
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
double angle = 2 * PI / n * (invert ? -1 : 1);
vector<complex<double> > root(n / 2);
for (int i = 0; i < n / 2; i++)
root[i] = complex<double>(cos(i * angle), sin(i * angle));
for (int len = 2; len <= n; len <<= 1) {
int step = n / len, aux = len / 2;
for (int i = 0; i < n; i += len) {
for (int j = 0; j < aux; j++) {
complex<double> u = a[i + j], v = a[i + j + aux] * root[step * j];
a[i + j] = u + v;
a[i + j + aux] = u - v;
}
}
}
if (invert) {
for (int i = 0; i < n; i++) a[i] /= n;
}
}
void solve(vector<long long>& a, vector<long long>& b) {
a.resize(min(int(a.size()), k + 1));
b.resize(min(int(b.size()), k + 1));
int n = 1, len = a.size() + b.size();
while (n < len) n *= 2;
a.resize(n);
b.resize(n);
vector<complex<double> > fft_a(a.begin(), a.end());
fft(fft_a, 0);
vector<complex<double> > fft_b(b.begin(), b.end());
fft(fft_b, 0);
vector<complex<double> > c(n);
for (int i = 0; i < n; i++) c[i] = fft_a[i] * fft_b[i];
fft(c, 1);
for (int i = 0; i < n; i++) {
a[i] = roundl(c[i].real());
a[i] %= mod;
}
while (a.size() > 1 && a.back() == 0) a.pop_back();
}
int main() {
int n, m;
scanf("%d %d %d", &n, &m, &k);
int len = 1;
while (len < m) len *= 2;
m = len;
vector<int> freq(m);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
freq[x - 1]++;
}
vector<vector<long long> > torneio(m);
for (int i = 0; i < m; i++)
torneio[i] = vector<long long>(min(freq[i] + 1, k + 1), 1LL);
for (int tam = 2; tam <= m; tam *= 2)
for (int i = 0; i < m; i += tam) solve(torneio[i], torneio[i + tam / 2]);
torneio[0].resize(k + 1);
printf("%lld\n", torneio[0][k]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[200005], b[200005], ans[200005];
struct P {
int x, y;
bool operator<(const P& a) const { return x < a.x; }
};
int main() {
int n;
cin >> n;
set<P> ord;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ord.insert((P){a[i], i});
}
for (int i = 1; i <= n; i++) cin >> b[i];
int ma = 0;
int prev = 0;
ans[1] = 1;
for (int i = 1; i <= n; i++) {
if (ord.find((P){b[i], 0}) != ord.end()) {
ma = max(ma, ord.find((P){b[i], 0})->y - 1);
ans[i] += ma - prev;
prev = ma;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
vector<int> divv[maxn];
void init() {
for (int i = 1; i < maxn; ++i) {
for (int j = i; j < maxn; j += i) {
divv[j].push_back(i);
}
}
}
vector<int> usedPos;
bool vis[maxn];
long long gg[maxn], countt[maxn];
void clear() {
for (int v : usedPos) {
vis[v] = false;
countt[v] = 0;
gg[v] = 0;
}
usedPos.clear();
}
void update(int val, int cnt) {
for (int v : divv[val]) {
countt[v] += cnt;
if (!vis[v]) {
vis[v] = true;
usedPos.push_back(v);
}
}
}
long long getans() {
sort(usedPos.begin(), usedPos.end());
for (int pos : usedPos) {
gg[pos] = (long long)countt[pos] * countt[pos];
}
reverse(usedPos.begin(), usedPos.end());
long long ans = 0;
for (int pos : usedPos) {
ans += (long long)pos * gg[pos] % mod;
for (int npos : divv[pos]) {
gg[npos] -= gg[pos];
}
}
return ans % mod;
}
long long getv(vector<int>& vals) {
sort(vals.begin(), vals.end());
int sz = vals.size();
for (int i = 0, j = 0; i < sz; i = j) {
int cnt = 0;
while (j < sz && vals[i] == vals[j]) {
++cnt;
++j;
}
update(vals[i], cnt);
}
long long ret = getans();
clear();
return ret;
}
int a[maxn];
long long f[maxn];
vector<int> tmp;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
tmp.clear();
for (int j = i; j <= n; j += i) {
tmp.push_back(a[j]);
}
f[i] = getv(tmp) % mod;
}
long long ans = 0;
for (int i = n; i; --i) {
for (int j = i + i; j <= n; j += i) {
f[i] -= f[j];
}
f[i] %= mod;
f[i] = (f[i] + mod) % mod;
ans += (long long)f[i] * i % mod;
}
ans %= mod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, p, a[N];
int main() {
for (; ~scanf("%d%d%d", &n, &m, &p);) {
for (int i = 0; i < n; i++) scanf("%d", a + i);
map<int, int> b;
for (int i = 0; i < m; i++) {
int bi;
scanf("%d", &bi);
b[bi]++;
}
vector<int> res;
for (int i = 0; i < p; i++) {
map<int, int> bm;
vector<int> q;
int sum = 0, head = 0;
for (int j = i; j < n; j += p) {
q.push_back(j);
if (q.size() - head > m) {
int ai = a[q[head]];
if (b[ai]) {
bm[ai]--;
if (bm[ai] < b[ai]) sum--;
}
head++;
}
if (b[a[j]]) {
if (bm[a[j]] < b[a[j]]) sum++;
bm[a[j]]++;
}
if (sum == m) res.push_back(q[head]);
}
}
sort(res.begin(), res.end());
printf("%d\n", res.size());
for (int i = 0; i < res.size(); i++) {
if (i) putchar(' ');
printf("%d", res[i] + 1);
}
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
int n, m;
cin >> n >> m;
int i, a[n][m], j;
unsigned long long int ans = 0, c1 = 0, c2 = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
}
}
long long int p[51];
p[0] = 1;
for (i = 1; i < 51; i++) {
p[i] = 2 * p[i - 1];
}
for (i = 0; i < n; i++) {
c1 = 0;
c2 = 0;
for (j = 0; j < m; j++) {
if (a[i][j] == 1) {
c1++;
} else {
c2++;
}
}
ans += (p[c1] - 1);
ans += (p[c2] - 1);
}
for (i = 0; i < m; i++) {
c1 = 0;
c2 = 0;
for (j = 0; j < n; j++) {
if (a[j][i] == 1) {
c1++;
} else {
c2++;
}
}
ans += (p[c1] - 1);
ans += (p[c2] - 1);
}
cout << ans - n * m;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 500005;
int n, m, cnt = 0, in[maxn], out[maxn], depth[maxn];
vector<int> G[maxn], inn[maxn], dian[maxn], D[maxn];
int MAXd = 0;
string a;
void dfs(int u, int d) {
in[u] = ++cnt;
depth[u] = d;
inn[depth[u]].push_back(in[u]);
dian[depth[u]].push_back(u);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
dfs(v, d + 1);
}
out[u] = cnt;
MAXd = max(MAXd, d);
}
int lowbit(int x) { return x & (-x); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++) {
int u;
scanf("%d", &u);
G[u].push_back(i);
}
dfs(1, 1);
char a[maxn];
scanf("%s", a + 1);
for (int i = 1; i <= MAXd; i++) {
for (int j = 0, y = 0; j < dian[i].size(); j++) {
int x = a[dian[i][j]] - 'a';
x = 1 << x;
y = y ^ x;
D[i].push_back(y);
}
}
while (m--) {
int v, h;
scanf("%d%d", &v, &h);
int L = lower_bound(inn[h].begin(), inn[h].end(), in[v]) - inn[h].begin();
int R =
upper_bound(inn[h].begin(), inn[h].end(), out[v]) - inn[h].begin() - 1;
if (R < 0) {
puts("Yes");
continue;
}
int ans;
if (L == 0)
ans = D[h][R];
else
ans = D[h][R] ^ D[h][L - 1];
ans = ans - lowbit(ans);
if (!ans)
puts("Yes");
else
puts("No");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 3;
long long n, numval;
long long a[N], range[N], power[19], one[19];
double dp[N][N];
long long find(long long l) {
if (l == 0) return 0;
long long x = l, c = 0;
while (x) {
c++;
x /= 10;
}
long long ans = one[c - 1], val = power[c - 1];
if (l >= 2 * val)
ans += val - 1;
else
ans += (l - val);
return ans;
}
double prob(long long i, long long k) {
if (i == n) {
if (k >= numval)
return 1;
else
return 0;
}
if (dp[i][k] > -0.9) return dp[i][k];
double ans = (a[i] + 0.0) / range[i] * prob(i + 1, k + 1);
ans += (range[i] - a[i] + 0.0) / range[i] * prob(i + 1, k);
return dp[i][k] = ans;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
power[0] = 1;
for (long long i = 1; i < 19; i++) power[i] = power[i - 1] * 10;
one[0] = 1;
one[1] = 2;
for (long long i = 2; i < 19; i++) one[i] = power[i - 1] + one[i - 1];
for (long long i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
range[i] = r - l + 1;
a[i] = find(r) - find(l - 1);
}
memset(dp, -1, sizeof(dp));
long long k;
cin >> k;
numval = (k * n + 99) / 100;
double ans = prob(0, 0);
cout << fixed << setprecision(15) << ans;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, d, e;
std::cin >> n >> d >> e;
int result = n - n / d * d;
int dollars = n / d, euros = 0;
while (dollars > -1) {
while (dollars * d + 5 * euros * e <= n) {
result = std::min(result, n - (dollars * d + 5 * euros * e));
euros++;
}
dollars--;
}
std::cout << result << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int M = 5e6;
int n, a[N], b[M + 1], c[M + 1], ans[N];
void fact(int x, vector<int>& v) {
while (b[x]) {
v.push_back(b[x]);
x /= b[x];
}
v.push_back(x);
v.erase(unique(v.begin(), v.end()), v.end());
}
void mark(int x) {
for (int i = x; i <= M; i += x) c[i] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= M; i++) {
if (!b[i])
for (int j = 2 * i; j <= M; j += i)
if (!b[j]) b[j] = i;
}
int cur = n + 1;
for (int i = 1; i <= n; i++) {
vector<int> v;
fact(a[i], v);
bool ok = 1;
for (int j = 0; j < v.size(); j++)
if (c[v[j]]) {
ok = 0;
break;
}
if (!ok) {
cur = i;
break;
}
for (int j = 0; j < v.size(); j++) mark(v[j]);
ans[i] = a[i];
}
if (cur <= n) {
int tmp = a[cur] + 1;
while (c[tmp]) tmp++;
ans[cur] = tmp;
vector<int> v;
fact(tmp, v);
for (int i = 0; i < v.size(); i++) mark(v[i]);
tmp = 2;
for (int i = cur + 1; i <= n; i++) {
while (c[tmp]) tmp++;
ans[i] = tmp;
mark(tmp);
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long k;
cin >> k;
vector<string> v;
v.push_back("+");
for (long long i = 0; i < k; i++) {
vector<string> temp;
for (auto j : v) {
temp.push_back(j + j);
}
for (auto j : v) {
string s = j;
for (auto &x : s) x ^= '*' ^ '+';
temp.push_back(j + s);
}
v = temp;
}
for (auto i : v) cout << i << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int cost[N];
map<pair<int, int>, int> offers;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int Q, n, i;
cin >> n;
long long ans = 0;
for (i = 1; i <= n; i++) cin >> cost[i], ans += cost[i];
cin >> Q;
while (Q--) {
int s, t, u;
cin >> s >> t >> u;
if (offers.count({s, t})) {
int v = offers[{s, t}];
if (cost[v] >= 0) ans++;
cost[v]++;
}
if (!u) {
offers.erase({s, t});
cout << ans << "\n";
continue;
}
offers[{s, t}] = u;
if (cost[u] > 0) ans--;
cost[u]--;
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z;
int main() {
scanf("%lld%lld%lld", &x, &y, &z);
if (x == 1 && y == 1 && z == 1) return puts("inf"), 0;
if (x == y && y == z) return puts("2"), 0;
if (y == z) return puts("1"), 0;
if (y == 1) return puts("0"), 0;
long long Z = z, Y = y, fl = 0;
for (; Z; Z /= y, Y /= x)
if ((Y -= Z % y) < 0 || Y % x) fl = 1;
if (!fl && !Y) return puts("1"), 0;
if (x != 1) return puts("0"), 0;
if (z == 1) return puts("0"), 0;
for (; z % y == 0; z /= y)
;
puts(z != 1 ? "0" : "1");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, k, csonn[100005], csoff[100005], theorems[100005], onoff[100005],
cs3[100005], ans1, ans2, one, ans3;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &theorems[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &onoff[i]);
if (onoff[i] == 1) {
ans3 += theorems[i];
csonn[i] = theorems[i] + csonn[i - 1];
csoff[i] = csoff[i - 1];
cs3[i] = theorems[i] + cs3[i - 1];
} else {
csoff[i] = theorems[i] + csoff[i - 1];
csonn[i] = csonn[i - 1];
cs3[i] = theorems[i] + cs3[i - 1];
}
}
int hello = ans3;
int sss;
for (int i = 1; i <= n - k + 1; i++) {
sss = hello;
sss += csoff[i + k - 1] - csoff[i - 1];
ans2 = max(sss, ans2);
}
printf("%d", ans2);
return 0;
}
| 2 |
/* Author : tlekiller */
/* Goal : Wherever My Practice Takes */
#include<bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define UMAX 1e17
#define F first
#define S second
#define debug(v) for(auto &x:v)clog<<x<<" \n"[x==v.back()];
#define print(v) for(auto &x:v)cout<<x<<" \n"[x==v.back()];
#define read(v) for(auto &x:v)cin>>x;
#define deb(x) clog<<#x<<" is "<<x<<'\n';
#define all(v) v.begin(),v.end()
#define pb push_back
#define pf push_front
#define pii pair<int,int>
using ll=long long;
const int MOD=1000000007;
#define int long long
void solve(){
int n, k;
cin >> n >> k;
vector<int> a(k);
map<int, int> t;
read(a);
for(int i = 0; i < k; i++)a[i]--;
for(int i = 0; i < k; i++){
int x;
cin >> x;
t[a[i]] = x;
}
sort(all(a));
vector<int> ans(n, 1e10);
for(int i = 0; i < k; i++){
ans[0] = min(ans[0], t[a[i]] + a[i]);
}
vector<int> mdp(n+1, 0);
for(int i = 0; i < k; i++){
mdp[a[i]] = a[i] + t[a[i]];
}
mdp[n] = 0;
int filler = 1e10;
map<int, int> mpp;
for(int i = n-1, j = k-1; i >= 0; i--){
if(i == a[j]){
if(mdp[i] < filler){
filler = mdp[i];
mpp[filler] = a[j];
} else {
mdp[i] = filler;
}
j = max(j-1, 0ll);
} else {
if(i < a[k-1]){
mdp[i] = mdp[i+1];
}
}
}
for(int i = 1; i < n; i++){
if(i <= a[k-1]){
int x = mpp[mdp[i]];
ans[i] = min(ans[i-1]+1, mdp[i]-x+abs(x-i));
} else {
ans[i] = ans[i-1]+1;
}
}
for(int i = 0; i < n; i++){
cout << ans[i] << " \n"[i==n-1];
}
}
signed main() {
FAST
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t = 1;
cin>>t;
//cout << fixed << setprecision(10);
while (t--) solve();
cerr<<"Time : "<<1000*((double)clock())/(double)CLOCKS_PER_SEC<<"ms\n";
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt, head[100001], costsum, x, s, t, n, m, inqueue[100001], cur[100001],
chudu[100001];
struct bian {
int to;
int cost;
int flow;
int next;
} edge[200001];
void addedge(int u, int v, int flow, int cost) {
edge[++cnt].to = v;
edge[cnt].cost = cost;
edge[cnt].flow = flow;
edge[cnt].next = head[u];
head[u] = cnt;
}
int depth[100001], dis[100001], inf = 0x3f3f3f3f, in[100001], ans[101][101];
bool SPFA() {
for (int i = 0; i <= n * (n + 1) + 2; i++) {
depth[i] = 0;
cur[i] = head[i];
dis[i] = inf;
}
deque<int> q;
dis[s] = 0;
inqueue[s] = 1;
q.push_back(s);
while (!q.empty()) {
int from = q.front();
q.pop_front();
for (int i = head[from]; i != 0; i = edge[i].next) {
int to = edge[i].to, cost = edge[i].cost;
if (dis[from] + cost < dis[to] && edge[i].flow) {
dis[to] = dis[from] + cost;
depth[to] = depth[from] + 1;
if (inqueue[to] == 0) {
if (!q.empty() && dis[to] < dis[q.front()])
q.push_front(to);
else
q.push_back(to);
inqueue[to] = 1;
}
}
}
inqueue[from] = 0;
}
return dis[t] != inf;
}
int dfs(int now, int low) {
if (now == t) return low;
int used = 0, hlow = 0;
for (int i = cur[now]; i != 0; i = edge[i].next) {
cur[now] = i;
int to = edge[i].to, cost = edge[i].cost;
if (dis[now] + cost == dis[to] && edge[i].flow &&
depth[now] + 1 == depth[to]) {
if (hlow = dfs(to, min(low - used, edge[i].flow))) {
used += hlow;
edge[i].flow -= hlow;
if (i % 2 == 1)
edge[i + 1].flow += hlow;
else
edge[i - 1].flow += hlow;
if (used == low) break;
}
}
}
return used;
}
int main() {
scanf("%d%d", &n, &m);
s = n * (n + 1) + 1;
t = n * (n + 1) + 2;
int size = n * n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans[i][j] = 2;
for (int i = 1; i <= n; i++) ans[i][i] = 0;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
chudu[x]++;
ans[x][y] = 1;
ans[y][x] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (ans[i][j] == 2) {
int now = (i - 1) * n + j;
addedge(s, now, 1, 0);
addedge(now, s, 0, 0);
addedge(now, i + size, 1, 0);
addedge(i + size, now, 0, 0);
addedge(now, j + size, 1, 0);
addedge(j + size, now, 0, 0);
in[i]++;
in[j]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= in[i]; j++) {
addedge(i + size, t, 1, chudu[i] + j - 1);
addedge(t, i + size, 0, -chudu[i] - j + 1);
}
}
while (SPFA()) costsum += dfs(s, inf) * dis[t];
for (int i = 1; i <= n; i++)
if (chudu[i] >= 2) costsum += chudu[i] * (chudu[i] - 1) / 2;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int now = (i - 1) * n + j;
if (head[now] == 0) continue;
for (int k = head[now]; k != 0; k = edge[k].next) {
int to = edge[k].to;
if (to == s) continue;
if (edge[k].flow) continue;
if (to - size == i)
ans[i][j] = 1, ans[j][i] = 0;
else
ans[j][i] = 1, ans[i][j] = 0;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << ans[i][j];
}
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long pow(long long x, long long v) {
if (v == 0) return 1LL;
if (v % 2) return (x % MOD) * pow(x % MOD, v - 1) % MOD;
return pow((x * x) % MOD, v / 2) % MOD;
}
int main() {
int n;
long long x, sum = 0, v, mx = 0;
scanf("%d%lld", &n, &x);
map<long long, int> cnt;
vector<long long> a(n);
for (int i = 0; i < n; ++i)
scanf("%lld", &a[i]), sum += a[i], mx = max(mx, a[i]);
for (int i = 0; i < n; ++i) cnt[sum - a[i]]++;
for (map<long long, int>::iterator it = cnt.begin(); it != cnt.end(); ++it) {
v = it->first;
if (it->second % x == 0) {
cnt[v + 1] += it->second / x;
} else
break;
}
v = min(v, sum);
printf("%lld", pow(x, v));
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int door_num, temp = 1;
scanf("%d", &door_num);
int door_arr[200005];
for (int i = 0; i < door_num; i++) {
scanf("%d", &door_arr[i]);
}
if (door_arr[door_num - 1] == 0) {
temp = 0;
}
for (int j = door_num - 1; j >= 0; j--) {
if (door_arr[j] != temp) {
printf("%d\n", j + 1);
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200005], n;
int main() {
int i, j, first;
long long cnt = 0;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
for (first = 1; first <= n;) {
++cnt;
i = first;
while (!~a[i]) ++i;
j = i + 1;
while (!~a[j]) ++j;
if (j > n) break;
if ((a[j] - a[i]) % (j - i)) {
first = j;
continue;
}
long long p = (a[j] - a[i]) / (j - i);
if (a[j] - p * (j - first) <= 0) {
first = j;
continue;
}
for (first = j;
a[j] + p * (first - j) > 0 and
(!~a[first] or a[first] == a[j] + p * (first - j)) and first <= n;
first++)
;
}
cout << cnt << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int pos[N], a[N], b[N];
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i], pos[b[i]] = i;
int p = 1;
for (int i = 1; i <= n; i++) p = max(p, pos[i] - i + 2);
int ans = p - 1 + n;
int p1 = 0;
for (int i = 1; i <= n; i++)
if (b[i] == 1) p1 = i;
if (p1) {
int ok = 1;
for (int i = p1 + 1; i <= n; i++) ok &= (b[i] == b[i - 1] + 1);
for (int i = 0; n - p1 + 2 + i <= n; i++) {
ok &= (pos[n - p1 + 2 + i] <= i);
}
if (ok) ans = p1 - 1;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxx = 1e9 + 7;
bool compare(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first > b.first;
}
long long inline power(long long a, long long b, long long p) {
a %= p;
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
long long inv(long long n, long long p) { return power(n, p - 2, p); }
bool inline isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
template <class T>
void printv(T &v, long long n) {
if (n == -1) n = v.size();
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << "\n";
}
void solve() {
long long n, ans = maxx;
cin >> n;
vector<long long> v(n);
vector<string> s(n);
map<string, long long> m;
for (long long i = 0; i < n; i++) {
cin >> v[i] >> s[i];
sort(s[i].begin(), s[i].end());
if (m.find(s[i]) == m.end())
m[s[i]] = v[i];
else
m[s[i]] = min(v[i], m[s[i]]);
}
vector<string> arr = {"A", "B", "C", "AB", "BC", "AC", "ABC"};
for (auto &x : arr) {
if (m.find(x) == m.end()) m[x] = maxx;
}
for (long long i = 0; i < 128; i++) {
bitset<7> b(i);
set<char> st;
long long temp = 0;
for (long long k = 0; k < 7; k++) {
if (b[k] == 1) {
temp += m[arr[k]];
for (auto &y : arr[k]) st.insert(y);
}
}
if (st.size() == 3) ans = min(ans, temp);
}
if (ans == maxx) {
cout << -1 << "\n";
} else
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long test = 1;
while (test--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using std::bitset;
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
class MyTimer {
public:
void reset() {}
void report() {}
} myTimer;
template <typename A, typename B>
std::ostream &operator<<(std::ostream &cout, const pair<A, B> &x) {
return cout << "(" << x.first << ", " << x.second << ")";
}
template <typename T1, typename T2>
inline bool chmin(T1 &a, const T2 &b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, const T2 &b) {
return a < b ? a = b, true : false;
}
const int maxN = 2000000 + 233;
int n;
int a[maxN], s[maxN], pmin[maxN];
void initialize() {
static char str[maxN];
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; ++i) a[i] = (str[i] == '(' ? 1 : -1);
for (int i = n + 1; i <= 2 * n; ++i) a[i] = a[i - n];
s[0] = 0;
for (int i = 1; i <= 2 * n; ++i) s[i] = s[i - 1] + a[i];
static int q[maxN];
int f = 1, r = 0;
q[r = 1] = 0;
for (int i = 1; i <= n * 2; ++i) {
while (f <= r && s[q[r]] >= s[i]) --r;
q[++r] = i;
while (q[f] < i - n) ++f;
pmin[i] = s[q[f]];
}
for (int i = 1; i <= n; ++i) pmin[i] = pmin[i + n - 1] - s[i - 1];
;
;
}
int buc[maxN * 2], cub[maxN * 2], c[maxN];
int sa[maxN], rk[maxN], h[maxN];
void get_sa(int m) {
int n = ::n * 2;
memset(buc, -1, sizeof(buc));
memset(cub, -1, sizeof(cub));
int *x = buc, *y = cub;
for (int i = 0; i < m; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[x[i] = (a[i + 1] == -1 ? '0' : '1')]++;
for (int i = 1; i < m; ++i) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--c[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k; i < n; ++i) y[p++] = i;
for (int i = 0; i < n; ++i)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[x[i]]++;
for (int i = 1; i < m; ++i) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--c[x[y[i]]]] = y[i];
std::swap(x, y);
x[sa[0]] = 0;
p = 1;
for (int i = 1; i < n; ++i) {
x[sa[i]] = y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]
? p - 1
: p++;
}
if (p == n) break;
m = p;
}
for (int i = 0; i < n; ++i) rk[i] = x[i];
}
void solve() {
get_sa(100);
int best = 1;
for (int i = 2; i <= n; ++i) {
if (pmin[best] < pmin[i])
best = i;
else if (pmin[best] == pmin[i]) {
if (rk[best - 1] < rk[i - 1]) best = i;
}
}
for (int i = 0; i < -pmin[best]; ++i) putchar('(');
for (int i = best; i < best + n; ++i) putchar(a[i] == -1 ? ')' : '(');
for (int i = 0; i < s[n] - pmin[best]; ++i) putchar(')');
putchar(10);
}
int main() {
initialize();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n, m, a[maxn], lst[maxn], pre[maxn];
set<int> s[maxn];
struct node {
int x, y, id;
node(int _x = 0, int _y = 0, int _id = 0) { x = _x, y = _y, id = _id; }
};
node P[maxn << 3], Q[maxn << 3];
long long ans[maxn];
long long t[maxn];
pair<int, int> st[maxn << 4];
int top;
inline int lowbit(int x) { return x & (-x); }
inline void change(int x, int y) {
st[++top] = make_pair(x, y);
for (int i = x; i <= n; i += lowbit(i)) t[i] += y;
}
inline long long ask(int x) {
long long res = 0;
for (int i = x; i >= 1; i -= lowbit(i)) res += t[i];
return res;
}
inline void recover() {
int tmp = top;
for (int i = 1; i <= tmp; i++) change(st[i].first, -st[i].second);
top = 0;
}
void solve(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1;
solve(l, mid), solve(mid + 1, r);
int i = l, j = mid + 1, k = l;
long long sum = 0;
while (i <= mid && j <= r) {
if (Q[i].y <= Q[j].y) {
if (Q[i].id <= 0) {
int w = (Q[i].id == 0) ? 1 : -1;
sum += w * (Q[i].y - Q[i].x);
change(Q[i].x, w * (Q[i].y - Q[i].x));
}
P[k++] = Q[i++];
} else {
if (Q[j].id >= 1) {
int id = Q[j].id;
ans[id] += sum - ask(Q[j].x - 1);
}
P[k++] = Q[j++];
}
}
while (i <= mid) P[k++] = Q[i++];
while (j <= r) {
if (Q[j].id >= 1) {
int id = Q[j].id;
ans[id] += sum - ask(Q[j].x - 1);
}
P[k++] = Q[j++];
}
recover();
for (int i = l; i <= r; i++) Q[i] = P[i];
}
int main() {
scanf("%d%d", &n, &m);
int tot = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), s[a[i]].insert(i);
pre[i] = lst[a[i]], lst[a[i]] = i;
if (pre[i]) Q[++tot] = node(pre[i], i, 0);
}
for (int i = 1, opt, x, y; i <= m; i++) {
scanf("%d%d%d", &opt, &x, &y);
if (opt == 1) {
if (a[x] == y) continue;
if (pre[x]) Q[++tot] = node(pre[x], x, -1);
auto it = s[a[x]].lower_bound(x);
auto it1 = next(it);
if (it1 != s[a[x]].end()) {
int b = *it1;
Q[++tot] = node(pre[b], b, -1);
pre[b] = 0;
if (pre[x]) {
pre[b] = pre[x];
Q[++tot] = node(pre[b], b, 0);
}
}
s[a[x]].erase(x);
a[x] = y;
s[a[x]].insert(x);
it = s[a[x]].lower_bound(x);
it1 = next(it);
pre[x] = 0;
if (it != s[a[x]].begin()) {
int a = *prev(it);
pre[x] = a;
Q[++tot] = {pre[x], x, 0};
}
if (it1 != s[a[x]].end()) {
int b = *it1;
if (pre[b]) Q[++tot] = node(pre[b], b, -1);
pre[b] = x;
Q[++tot] = node(pre[b], b, 0);
}
} else {
cnt++;
Q[++tot] = node(x, y, cnt);
}
}
solve(1, tot);
for (int i = 1; i <= cnt; i++) printf("%lld\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 99;
int main() {
int a[MAX], n, i, j, k, sz = 0, b[MAX];
cin >> n;
for (i = 0; i < n; i++) {
cin >> b[i];
}
a[0] = 1;
for (i = 1; i < n; i++) {
if (b[i] != b[i - 1]) {
a[++sz] = 1;
} else {
a[sz]++;
}
}
int f = 0;
for (i = 1; i <= sz; i++) {
if (a[i] != a[i - 1]) {
f = 1;
break;
}
}
if (f)
cout << "NO";
else
cout << "YES";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-8;
using ll = long long;
using ii = pair<int, int>;
int n, m;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> s;
int ones = 0;
int zeroes = 0;
for (auto c : s) {
if (c == '0') zeroes += 1;
if (c == '1') ones += 1;
}
if (ones == zeroes) {
cout << 2 << "\n";
cout << s[0] << " ";
for (int i = 1; i < n; ++i) {
cout << s[i];
}
cout << endl;
} else {
cout << 1 << endl;
for (int i = 0; i < n; ++i) {
cout << s[i] << "";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, n1, n2;
cin >> n >> n1 >> n2;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long choto[n], boro[n];
long long flag = 0;
long long yo = 0, yo1 = 0;
long long boo = max(n1, n2);
long long boo1 = min(n1, n2);
for (long long i = n - 1; i >= 0; i--) {
if (!flag) {
choto[yo] = a[i];
yo++;
}
if (yo == boo1) {
yo++, flag = 1;
continue;
}
if (flag) {
boro[yo1] = a[i];
yo1++;
}
if (yo1 == boo) break;
}
double sum1 = 0, sum2 = 0;
for (long long i = 0; i < boo; i++) sum1 += boro[i];
for (long long i = 0; i < boo1; i++) sum2 += choto[i];
double avg = (sum1 / boo) + (sum2 / boo1);
cout << setprecision(9) << avg << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, k, a[N], b[N], fin[N], res, ans;
const int inf = 0x3f3f3f3f;
queue<int> A, B;
int main() {
scanf("%d%d", &n, &k);
int mx = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]), mx = max(a[i], mx);
}
ans = inf;
for (int beg = 1; beg <= mx; ++beg) {
res = 0;
for (int i = 1, j = beg; i <= n; ++i, j += k) {
b[i] = j - a[i];
if (b[i]) ++res;
}
if (res < ans) {
ans = res;
for (int j = 1; j <= n; ++j) fin[j] = b[j];
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i)
if (fin[i] > 0)
printf("+ %d %d\n", i, fin[i]);
else if (fin[i] < 0)
printf("- %d %d\n", i, -fin[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n % 2 == 0) {
cout << 1 - n << " " << n << endl;
} else {
cout << n / 2 << " " << (n / 2) + 1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> a >> b;
int n = a + b;
int ans = 0;
for (int per = 1; per <= n;) {
int fre = n / per;
int nxt = n / fre;
if (a >= fre && b >= fre) {
int l1 = (a + fre) / (fre + 1);
int r1 = a / fre;
int l2 = (b + fre) / (fre + 1);
int r2 = b / fre;
if (l1 <= r1 && l2 <= r2)
ans += max(0, min(nxt, r1 + r2) - max(per, l1 + l2) + 1);
}
per = nxt + 1;
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, x = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
char s[4];
scanf("%s", &s);
if (s[1] == '+') {
x = x + 1;
} else if (s[1] == '-') {
x = x - 1;
}
}
printf("%d", x);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000000 + 5, LOG = 17 + 1, MOD = 1000000007;
vector<long long> g[N];
long long vis[N];
void dfs(long long i) {
vis[i] = 1;
for (long long j : g[i])
if (!vis[j]) dfs(j);
}
long long pow(long long x, long long n) {
if (n == 0) return 1;
long long y = pow(x, n / 2);
y = ((long long)y * y) % MOD;
if (n & 1) y = ((long long)y * x) % MOD;
return y;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long p, k;
cin >> p >> k;
if (k == 0) {
cout << pow(p, p - 1) << '\n';
return 0;
}
if (k == 1) {
cout << pow(p, p) << '\n';
return 0;
}
for (long long i = 1; i <= p - 1; ++i) g[((long long)i * k) % p].push_back(i);
long long nb = 0;
for (long long i = 1; i <= p - 1; ++i)
if (!vis[i]) ++nb, dfs(i);
cout << pow(p, nb) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5e5 + 7;
const int Max = 5e2 + 7;
const long long Inf = 1e9 + 7;
const long long Mod = 1e9 + 7;
int a[Maxn], Min[Maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
Min[n + 1] = Inf;
for (int i = n; i >= 1; i--) Min[i] = min(a[i], Min[i + 1]);
int mx = 0, ans = 0;
for (int i = 1; i <= n; i++) {
mx = max(mx, a[i]);
if (mx <= Min[i + 1]) ans++, mx = 0;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
if (i % 4 == 0) cout << 'a';
if (i % 4 == 1) cout << 'a';
if (i % 4 == 2) cout << 'b';
if (i % 4 == 3) cout << 'b';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 3005, P = 998244353;
inline void upd(int &x, int v) { x = (x + v >= P) ? (x + v - P) : (x + v); }
int n, G[N][N], cntv;
struct Union_Find_Set {
int fa[N << 1];
inline void init() {
for (int i = 1; i <= n << 1; ++i) fa[i] = i;
}
inline int Find(int x) { return x == fa[x] ? x : (fa[x] = Find(fa[x])); }
inline void Merge(int x, int y) { fa[Find(x)] = Find(y); }
} S;
struct Edge {
int x, y;
bool operator<(const Edge w) const { return G[x][y] < G[w.x][w.y]; }
} e[N * N / 2];
int le;
int Rt, fa[N << 1], ch[N << 1][2];
int F[N << 1][N], siz[N], tl[N], tr[N], Time, pos[N];
int mx[N << 1];
int pre[N][N], suf[N][N];
inline void dfs0(int x) {
if (x <= n) {
tl[x] = tr[x] = ++Time;
pos[Time] = x;
siz[x] = 1;
return;
}
dfs0(ch[x][0]);
dfs0(ch[x][1]);
tl[x] = tl[ch[x][0]], tr[x] = tr[ch[x][1]];
siz[x] = siz[ch[x][0]] + siz[ch[x][1]];
}
inline void dfs(int x) {
if (x <= n) {
F[x][1] = 1;
return;
}
dfs(ch[x][0]);
dfs(ch[x][1]);
for (int i = 1; i <= siz[ch[x][0]]; ++i)
for (int j = 1; j <= siz[ch[x][1]]; ++j) {
upd(F[x][i + j], (long long)F[ch[x][0]][i] * F[ch[x][1]][j] % P);
}
mx[x] = max(mx[ch[x][0]], mx[ch[x][1]]);
for (int i = tl[ch[x][0]]; i <= tr[ch[x][0]]; ++i)
for (int j = tl[ch[x][1]]; j <= tr[ch[x][1]]; ++j)
mx[x] = max(mx[x], G[pos[i]][pos[j]]);
for (int i = tl[x]; i <= tr[x]; ++i) {
int val = 1000000000;
if (tl[x] > 1) val = min(val, pre[pos[i]][tl[x] - 1]);
if (tr[x] < n) val = min(val, suf[pos[i]][tr[x] + 1]);
if (val < mx[x]) {
F[x][1] = (F[x][1] + P - 1) % P;
break;
}
}
F[x][1] = (F[x][1] + 1) % P;
}
int main() {
int i, j, u, v;
read(n);
cntv = n;
S.init();
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) read(G[i][j]);
for (i = 1; i <= n; ++i)
for (j = i + 1; j <= n; ++j) {
++le;
e[le].x = i, e[le].y = j;
}
for (i = 1; i <= n; ++i) G[i][i] = 100000000;
sort(e + 1, e + le + 1);
for (i = 1; i <= le; ++i) {
u = S.Find(e[i].x), v = S.Find(e[i].y);
if (u == v) continue;
++cntv;
S.Merge(u, cntv);
S.Merge(v, cntv);
ch[cntv][0] = u, ch[cntv][1] = v;
fa[u] = fa[v] = cntv;
Rt = cntv;
}
dfs0(Rt);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) pre[i][j] = suf[i][j] = G[i][pos[j]];
for (j = 2; j <= n; ++j) pre[i][j] = min(pre[i][j], pre[i][j - 1]);
for (j = n - 1; j; --j) suf[i][j] = min(suf[i][j], suf[i][j + 1]);
}
dfs(Rt);
for (i = 1; i <= n; ++i) cout << F[Rt][i] << (i < n ? ' ' : '\n');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
set<int> f[N];
bool tf1 = true;
inline int read() {
int x = 0, k = 1;
char c = getchar();
for (; c < 48 || c > 57; c = getchar()) k ^= (c == '-');
for (; c >= 48 && c <= 57; c = getchar()) x = x * 10 + (c ^ 48);
return k ? x : -x;
}
int main() {
int n = read(), m = read(), a, b;
while (m--) a = read(), b = read(), f[--a].insert(--b), f[b].insert(a);
for (int i = 1; i < n; i++)
if (!(n % i)) {
tf1 = true;
for (int x = 0; x < n; x++)
for (auto y : f[x]) tf1 &= f[(x + i) % n].count((y + i) % n);
if (tf1) return printf("Yes\n"), 0;
}
printf("No\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC tartget("sse,sse2,sse3,sse4")
using namespace std;
const long long N = 1e6 + 10;
const long long B = 1700;
const long long N2 = 5e5 + 10;
const long long off = 1e3;
const long long inf = 1e18 + 10ll;
const long long mod = 1e9 + 7;
const double eps = 1e-12;
const double pi = 3.14159265358979323846;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
using namespace std;
long long n, m;
vector<long long> g[N];
set<long long> stg[N];
long long d[N];
long long pr[N];
long long ans = inf;
vector<long long> comp;
bool used[N];
void bfs() {
fill(d, d + N, inf);
queue<pair<pair<long long, long long>, long long>> q;
q.emplace(make_pair(0, 0), 0);
while (!q.empty()) {
auto pp = q.front();
long long v = pp.first.first;
long long dst = pp.first.second;
long long prevv = pp.second;
q.pop();
if (d[v] <= dst) continue;
d[v] = dst;
pr[v] = prevv;
for (auto u : g[v])
if (dst + 1 < d[u]) {
q.emplace(make_pair(u, dst + 1), v);
}
}
ans = min(ans, d[n - 1]);
}
vector<long long> getpath(long long v) {
vector<long long> res;
while (v) {
res.push_back(v);
v = pr[v];
}
res.push_back(v);
reverse((res).begin(), (res).end());
return move(res);
}
void dfs(long long v) {
used[v] = true;
comp.push_back(v);
for (auto u : g[v])
if (u && !used[u]) dfs(u);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long v, u;
cin >> v >> u;
--v;
--u;
g[v].push_back(u);
g[u].push_back(v);
stg[v].insert(u);
stg[u].insert(v);
}
bfs();
if (ans <= 4) {
cout << ans << "\n";
auto v = getpath(n - 1);
for (auto it : v) cout << (it + 1) << " ";
cout << "\n";
return 0;
}
for (long long i = 0; i < n; ++i)
if (d[i] == 2) {
vector<long long> v = getpath(i);
v.push_back(0);
v.push_back(n - 1);
cout << 4 << "\n";
for (auto it : v) cout << (it + 1) << " ";
return 0;
}
for (long long i = 0; i < n; ++i)
if (d[i] == 1) {
comp.clear();
dfs(i);
long long sz = comp.size();
for (auto v : comp)
if ((long long)g[v].size() - 1 < sz - 1) {
long long v2 = -1;
vector<long long> good;
for (auto u : comp)
if (!stg[u].count(v) && u != v) good.push_back(u);
for (auto u : good)
for (auto u2 : g[u])
if (stg[u2].count(v) && u2) {
v2 = u;
cout << 5 << "\n";
cout << 1 << " " << (v + 1) << " " << (u2 + 1) << " "
<< (v2 + 1) << " " << (v + 1) << " " << n << "\n";
return 0;
}
}
}
if (ans != inf) {
cout << ans << "\n";
auto v = getpath(n - 1);
for (auto it : v) cout << (it + 1) << " ";
cout << "\n";
return 0;
}
cout << -1 << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void read(int &a) {
char ch;
while (!((ch = getchar()) >= '0') && (ch <= '9'))
;
a = ch - '0';
while (((ch = getchar()) >= '0') && (ch <= '9')) a *= 10, a += ch - '0';
}
inline void prin_d(int x) {
if (x > 9) {
prin_d(x / 10);
}
putchar(x % 10 + '0');
return;
}
const int MAXN = 1010;
int dp[MAXN][MAXN];
string s1, s2;
int main() {
int len1, len2, i, j;
while (cin >> s1 >> s2) {
len1 = s1.length();
len2 = s2.length();
s1 = "#" + s1;
s2 = "#" + s2;
memset(dp, -1, sizeof(dp));
for (i = 0; i <= len1; i++) dp[i][0] = i;
for (j = 0; j <= len2; j++) dp[0][j] = j;
for (i = 1; i <= len1; i++) {
for (j = 1; j <= len2; j++) {
dp[i][j] = min(min(dp[i - 1][j] + 1, dp[i][j - 1] + 1),
dp[i - 1][j - 1] + (s1[i] == s2[j] ? 0 : 1));
}
}
printf("%d\n", dp[len1][len2]);
vector<char> opvec;
vector<int> idvec;
vector<char> chvec;
i = len1;
j = len2;
while (i != 0 || j != 0) {
if (i && j && dp[i][j] == dp[i - 1][j - 1] + (s1[i] == s2[j] ? 0 : 1)) {
if (s1[i] != s2[j]) {
opvec.push_back('R');
idvec.push_back(i);
chvec.push_back(s2[j]);
}
i--;
j--;
} else if (i && dp[i][j] == dp[i - 1][j] + 1) {
opvec.push_back('D');
idvec.push_back(i);
chvec.push_back(s1[i]);
i--;
} else if (j && dp[i][j] == dp[i][j - 1] + 1) {
opvec.push_back('I');
idvec.push_back(i + 1);
chvec.push_back(s2[j]);
j--;
} else if (i && !j) {
opvec.push_back('D');
idvec.push_back(i);
chvec.push_back(s1[i]);
i--;
} else if (!i && j) {
opvec.push_back('I');
idvec.push_back(i + 1);
chvec.push_back(s2[j]);
j--;
}
}
for (i = 0; i < opvec.size(); i++) {
if (opvec[i] == 'R')
printf("REPLACE %d %c\n", idvec[i], chvec[i]);
else if (opvec[i] == 'D')
printf("DELETE %d\n", idvec[i]);
else if (opvec[i] == 'I')
printf("INSERT %d %c\n", idvec[i], chvec[i]);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct AdjListNode {
int dest;
int weight;
struct AdjListNode* next;
};
struct AdjList {
struct AdjListNode* head;
};
struct Graph {
int V;
struct AdjList* array;
};
struct AdjListNode* newAdjListNode(int dest, int weight) {
struct AdjListNode* newNode =
(struct AdjListNode*)malloc(sizeof(struct AdjListNode));
newNode->dest = dest;
newNode->weight = weight;
newNode->next = NULL;
return newNode;
}
struct Graph* createGraph(int V) {
struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));
graph->V = V;
graph->array = (struct AdjList*)malloc(V * sizeof(struct AdjList));
for (int i = 0; i < V; ++i) graph->array[i].head = NULL;
return graph;
}
void addEdge(struct Graph* graph, int src, int dest, int weight) {
struct AdjListNode* newNode = newAdjListNode(dest, weight);
newNode->next = graph->array[src].head;
graph->array[src].head = newNode;
newNode = newAdjListNode(src, weight);
newNode->next = graph->array[dest].head;
graph->array[dest].head = newNode;
}
struct MinHeapNode {
int v;
int key;
};
struct MinHeap {
int size;
int capacity;
int* pos;
struct MinHeapNode** array;
};
struct MinHeapNode* newMinHeapNode(int v, int key) {
struct MinHeapNode* minHeapNode =
(struct MinHeapNode*)malloc(sizeof(struct MinHeapNode));
minHeapNode->v = v;
minHeapNode->key = key;
return minHeapNode;
}
struct MinHeap* createMinHeap(int capacity) {
struct MinHeap* minHeap = (struct MinHeap*)malloc(sizeof(struct MinHeap));
minHeap->pos = (int*)malloc(capacity * sizeof(int));
minHeap->size = 0;
minHeap->capacity = capacity;
minHeap->array =
(struct MinHeapNode**)malloc(capacity * sizeof(struct MinHeapNode*));
return minHeap;
}
void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b) {
struct MinHeapNode* t = *a;
*a = *b;
*b = t;
}
void minHeapify(struct MinHeap* minHeap, int idx) {
int smallest, left, right;
smallest = idx;
left = 2 * idx + 1;
right = 2 * idx + 2;
if (left < minHeap->size &&
minHeap->array[left]->key < minHeap->array[smallest]->key)
smallest = left;
if (right < minHeap->size &&
minHeap->array[right]->key < minHeap->array[smallest]->key)
smallest = right;
if (smallest != idx) {
MinHeapNode* smallestNode = minHeap->array[smallest];
MinHeapNode* idxNode = minHeap->array[idx];
minHeap->pos[smallestNode->v] = idx;
minHeap->pos[idxNode->v] = smallest;
swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
minHeapify(minHeap, smallest);
}
}
int isEmpty(struct MinHeap* minHeap) { return minHeap->size == 0; }
struct MinHeapNode* extractMin(struct MinHeap* minHeap) {
if (isEmpty(minHeap)) return NULL;
struct MinHeapNode* root = minHeap->array[0];
struct MinHeapNode* lastNode = minHeap->array[minHeap->size - 1];
minHeap->array[0] = lastNode;
minHeap->pos[root->v] = minHeap->size - 1;
minHeap->pos[lastNode->v] = 0;
--minHeap->size;
minHeapify(minHeap, 0);
return root;
}
void decreaseKey(struct MinHeap* minHeap, int v, int key) {
int i = minHeap->pos[v];
minHeap->array[i]->key = key;
while (i && minHeap->array[i]->key < minHeap->array[(i - 1) / 2]->key) {
minHeap->pos[minHeap->array[i]->v] = (i - 1) / 2;
minHeap->pos[minHeap->array[(i - 1) / 2]->v] = i;
swapMinHeapNode(&minHeap->array[i], &minHeap->array[(i - 1) / 2]);
i = (i - 1) / 2;
}
}
bool isInMinHeap(struct MinHeap* minHeap, int v) {
if (minHeap->pos[v] < minHeap->size) return true;
return false;
}
void printArr(int arr[], int n) {
for (int i = 1; i < n; ++i) printf("%d - %d\n", arr[i], i);
}
vector<int> PrimMST(struct Graph* graph) {
int V = graph->V;
int parent[V];
int key[V];
struct MinHeap* minHeap = createMinHeap(V);
for (int v = 1; v < V; ++v) {
parent[v] = -1;
key[v] = INT_MAX;
minHeap->array[v] = newMinHeapNode(v, key[v]);
minHeap->pos[v] = v;
}
key[0] = 0;
minHeap->array[0] = newMinHeapNode(0, key[0]);
minHeap->pos[0] = 0;
minHeap->size = V;
while (!isEmpty(minHeap)) {
struct MinHeapNode* minHeapNode = extractMin(minHeap);
int u = minHeapNode->v;
struct AdjListNode* pCrawl = graph->array[u].head;
while (pCrawl != NULL) {
int v = pCrawl->dest;
if (isInMinHeap(minHeap, v) && pCrawl->weight < key[v]) {
key[v] = pCrawl->weight;
parent[v] = u;
decreaseKey(minHeap, v, key[v]);
}
pCrawl = pCrawl->next;
}
}
vector<int> parent1(V, -1);
for (int i = 1; i < V; i++) parent1[i] = parent[i];
return parent1;
}
int main() {
int n;
cin >> n;
string s1, s2;
cin >> s1;
cin >> s2;
int V = 26;
vector<int> arr;
struct Graph* graph = createGraph(V);
for (int i = 0; i < n; i++) {
addEdge(graph, s1[i] - 'a', s2[i] - 'a', 1);
}
arr = PrimMST(graph);
int ret = 0;
for (int i = 1; i < 26; i++) {
if (arr[i] != -1) ret++;
}
cout << ret << endl;
for (int i = 1; i < 26; i++) {
if (arr[i] != -1)
cout << (char)('a' + i) << " " << (char)('a' + arr[i]) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[152000];
int n;
bool visited[120000];
int go(int node) {
if (visited[node]) return 0;
visited[node] = true;
return 1 + go(A[node]);
}
int pindex = -1;
int mini = 10;
int sindex = -1;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> A[i];
--A[i];
}
bool impar = false;
for (int i = 0; i < n; ++i) {
if (visited[i] == false) {
int l = go(i);
if (l > 1 and l % 2 == 1) {
impar = true;
}
if (l == 1) pindex = i;
if (mini > l and l > 1) {
mini = l;
sindex = i;
}
}
}
if (pindex != -1) {
cout << "YES" << endl;
for (int i = 0; i < n; ++i)
if (i != pindex) cout << pindex + 1 << " " << i + 1 << endl;
} else if (!impar and mini == 2) {
cout << "YES" << endl;
memset(visited, 0, sizeof visited);
cout << sindex + 1 << " " << A[sindex] + 1 << endl;
visited[sindex] = visited[A[sindex]] = true;
for (int i = 0; i < n; ++i)
if (visited[i] == false) {
int st = 0;
int cur = i;
while (true) {
cout << (st ? (sindex + 1) : (A[sindex] + 1)) << " " << cur + 1
<< endl;
st = 1 - st;
visited[cur] = true;
cur = A[cur];
if (cur == i) break;
}
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, l, m, n, c;
string s;
vector<int> v;
map<int, int> mp;
scanf("%lld %lld", &n, &m);
k = 6 - max(n, m) + 1;
if (6 % k == 0)
printf("1/%lld\n", 6 / k);
else if (k == 0)
printf("0/1\n");
else {
l = 6;
if (k % 2 == 0) {
k = k / 2;
l = l / 2;
}
printf("%lld/%lld\n", k, l);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n << endl;
for (int i = 0; i < n; i++) {
cout << 1 << ' ';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void solve() {
long long n, k;
cin >> n >> k;
if (k > 1000000) {
cout << "-1\n";
return;
}
long long ans = -1;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
long long x = n - i * ((k * (k - 1)) / 2);
if (x > i * (k - 1) && x % i == 0) {
ans = max(ans, i);
}
long long I = i;
i = n / i;
x = n - i * (k * (k - 1)) / 2;
if (x > i * (k - 1) && x % i == 0) {
ans = max(ans, i);
}
i = I;
}
}
if (ans == -1) {
cout << "-1\n";
return;
}
for (long long i = 0; i < k - 1; i += 1) {
cout << ans * (1 + i) << ' ';
}
cout << n - ans * (k * (k - 1)) / 2 << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5, N1 = maxn + 7;
const int inf = 0x3f3f3f3f;
template <typename T>
inline void read(T &x) {
x = 0;
T k = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') k = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= k;
}
struct node {
int id, mi, ma;
} b[N1];
int cmp(node &s1, node &s2) { return s1.ma < s2.ma; }
int n, m, de;
vector<int> a[N1], fi[N1], fa[N1];
int mi[N1], ma[N1], bmi[N1];
int col[N1];
void out(int I, int J) {
for (int i = 1; i <= n; i++) col[i] = 0;
for (int i = 1; i <= I; i++) col[b[i].id] = 1;
puts("YES");
for (int i = 1; i <= n; i++) putchar(col[i] ? 'B' : 'R');
printf(" %d\n", J);
}
void clr() {
for (int i = 1; i <= n; i++) a[i].clear(), fi[i].clear(), fa[i].clear();
}
void solve() {
read(n);
read(m);
for (int i = 1; i <= n; i++) ma[i] = 0, mi[i] = inf;
for (int i = 1; i <= n; i++) {
a[i].resize(m + 1);
for (int j = 1; j <= m; j++) read(a[i][j]);
fi[i].resize(m + 2);
fa[i].resize(m + 2);
fi[i][m + 1] = inf;
fa[i][m + 1] = 0;
for (int j = m; j >= 1; j--) fi[i][j] = min(fi[i][j + 1], a[i][j]);
for (int j = m; j >= 1; j--) fa[i][j] = max(fa[i][j + 1], a[i][j]);
}
for (int j = 1; j < m; j++) {
for (int i = 1; i <= n; i++)
ma[i] = max(ma[i], a[i][j]), mi[i] = min(mi[i], a[i][j]);
for (int i = 1; i <= n; i++) {
b[i].id = i, b[i].mi = mi[i], b[i].ma = ma[i];
}
sort(b + 1, b + n + 1, cmp);
bmi[n + 1] = inf;
for (int i = n; i >= 1; i--) bmi[i] = min(bmi[i + 1], b[i].mi);
multiset<int> sma, smi;
for (int i = 1; i <= n; i++) sma.insert(fa[i][j + 1]);
smi.insert(inf);
sma.insert(-inf);
for (int i = 1; i < n; i++) {
int id = b[i].id;
smi.insert(fi[id][j + 1]);
multiset<int>::iterator k = sma.find(fa[id][j + 1]);
sma.erase(k);
if (b[i].ma < bmi[i + 1]) {
multiset<int>::iterator k0 = smi.begin();
multiset<int>::iterator k1 = sma.end();
k1--;
if (*(k1) < *(k0)) {
out(i, j);
return;
}
}
}
}
puts("NO");
}
int main() {
int Te;
read(Te);
while (Te--) {
solve();
clr();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s, t;
int dp[1002][1002][15][2];
int solve(int i, int j, int rem, bool ok) {
if (rem < 0) return -1e4;
int &ret = dp[i][j][rem][ok];
if (i == n || j == m) {
return ret = 0;
}
if (ret != -1) return ret;
int x1 = -1, x2 = -1, x3 = -1;
if (ok) {
if (s[i] != t[j]) {
x1 = solve(i + 1, j, rem, 0);
x2 = solve(i, j + 1, rem, 0);
} else
x3 = 1 + solve(i + 1, j + 1, rem, 1);
} else {
x1 = solve(i + 1, j, rem, 0);
x2 = solve(i, j + 1, rem, 0);
if (s[i] == t[j]) x3 = 1 + solve(i + 1, j + 1, rem - 1, 1);
}
return ret = max(x1, max(x2, x3));
}
int main() {
memset(dp, -1, sizeof(dp));
int k;
cin >> n >> m >> k;
cin >> s >> t;
int ans = solve(0, 0, k, 0);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
file();
fast();
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long y = -2 * a + b;
y /= -3;
long long x = a - 2 * y;
if (x >= 0 && y >= 0 && x + 2 * y == a && x * 2 + y == b)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 100007;
using namespace std;
int main() {
int n, q;
while (scanf("%d %d", &n, &q) != EOF) {
int t[MAXN], k[MAXN], d[MAXN];
int timespam = 0;
int endtime[MAXN];
memset(endtime, -1, sizeof(endtime));
priority_queue<int> s;
for (int i = 0; i < q; i++) {
scanf("%d %d %d", &t[i], &k[i], &d[i]);
}
for (int i = 0; i < q; i++) {
for (int j = 1; j <= n; j++) {
if (endtime[j] < t[i] && endtime[j] != -2) {
endtime[j] = -2;
s.push(-j);
}
}
int sum = 0;
if (s.size() < k[i])
sum = -1;
else {
for (int j = 0; j < k[i]; j++) {
int id = abs(s.top());
s.pop();
sum += id;
endtime[id] = t[i] + d[i] - 1;
}
}
printf("%d\n", sum);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[10], tmp;
while (scanf("%d", &n) != EOF) {
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
a[tmp]++;
}
if (a[5] >= 9 && a[0]) {
for (int i = 1; i <= a[5] / 9; i++) printf("555555555");
}
if (a[5] >= 9 && a[0])
for (int i = 1; i <= a[0]; i++) putchar('0');
else if (a[0])
putchar('0');
else
printf("-1");
putchar('\n');
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int GLL(long long& x) { return scanf("%lld", &x); }
int GI(int& x) { return scanf("%d", &x); }
int R, C;
string row;
int main() {
GI(R);
GI(C);
for (int i = 0; i < (int)(R); i++) cin >> row;
int res = 0;
for (int i = 0; i < (int)(C - 1); i++) {
if (row[i] == 'B' && row[i + 1] == '.') res++;
}
if (row[C - 1] == 'B') res++;
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int n;
double l, r;
double px[25], py[25];
double pa[25];
bool vis[(1 << 20) + 233];
double cache[(1 << 20) + 233];
double calc(double pre, int id) {
double riga = atan((r - px[id]) / py[id]);
double lefa = min(riga, atan((pre - px[id]) / py[id]) + pa[id]);
return px[id] + py[id] * tan(lefa) - pre;
}
double dp(int status) {
double &mem = cache[status];
if (vis[status]) return mem;
vis[status] = 1;
mem = 0.0;
for (int bit = 0; bit <= n - 1; ++bit) {
if ((status >> bit & 1) == 0) continue;
int nst = status ^ (1 << bit);
mem = max(mem, dp(nst) + calc(cache[nst], bit));
}
return mem;
}
void solve() {
memset(vis, 0, sizeof vis);
printf("%.9lf\n", dp((1 << n) - 1));
}
int main() {
scanf("%d %lf %lf", &n, &l, &r);
r -= l;
for (int i = 0; i <= n - 1; ++i) {
scanf("%lf %lf %lf", &px[i], &py[i], &pa[i]);
pa[i] = pa[i] * PI / 180.0;
px[i] -= l;
py[i] = fabs(py[i]);
}
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
long long arr[n][n];
long long sum = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
scanf("%lld", &arr[i][j]);
if (i == j) {
sum = (sum % 2 + arr[i][j] % 2) % 2;
}
}
}
long long q;
scanf("%lld", &q);
for (long long i = 0; i < q; i++) {
long long type;
scanf("%lld", &type);
if (type == 1 || type == 2) {
long long row;
scanf("%lld", &row);
sum = 1 - sum;
} else {
printf("%lld", sum);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int ok = 0;
cin >> n;
vector<int> vi(n);
for (int i = 0; i < n; i++) {
cin >> vi[i];
}
sort(vi.begin(), vi.end());
n = unique(vi.begin(), vi.end()) - vi.begin();
for (int i = 2; i < n; i++) {
if (vi[i - 2] + 1 == vi[i - 1] && vi[i - 1] + 1 == vi[i]) {
ok = 1;
break;
}
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
set<int> slices;
for (int i = 1; i <= N * K; i++) {
slices.insert(i);
}
vector<int> v(K);
for (int i = 0; i < K; i++) {
int x;
cin >> x;
v[i] = x;
slices.erase(x);
}
for (int i = 0; i < K; i++) {
cout << v[i] << " ";
for (int i = 1; i < N; i++) {
cout << *slices.begin() << " ";
slices.erase(slices.begin());
}
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long dp[755][755];
long long arr[755];
long long rec(int i, int j) {
if (i == n + 1) return 0;
if (dp[i][j] != -1) return dp[i][j];
long long ret = max(0ll, rec(i + 1, j) - arr[i]);
if (j - 1 >= 0) ret = min(ret, rec(i + 1, j - 1));
return dp[i][j] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof dp);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) {
long long val;
cin >> val;
int low = 0, high = n;
while (low < high) {
int mid = low + (high - low) / 2;
if (rec(1, mid) <= val)
high = mid;
else
low = mid + 1;
}
cout << low << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
const long long MOD = 1e9 + 7;
struct compare {
bool operator()(const int& l, const int& r) { return l > r; }
};
long long gcd(long long x, long long y) {
return ((y == 0) ? x : gcd(y, x % y));
}
long long lcm(long long x, long long y) { return ((x * y) / gcd(x, y)); }
long long BMod(long long B, long long P, long long M) {
long long R = 1;
B = B % M;
while (P) {
if (P & 1) R = (R * B) % M;
P >>= 1;
B = (B * B) % M;
}
return R;
}
struct node {
int x, y, z;
};
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long n, m, q, ans = 0, a, b, c, pos;
cin >> n >> m >> q;
vector<node> vec;
for (int i = 1; i <= m; i++) {
node name;
cin >> name.x >> name.y >> name.z;
vec.push_back(name);
}
while (q--) {
cin >> pos;
for (int i = 0; i < vec.size(); i++) {
if (pos >= vec[i].x && pos <= vec[i].y) {
ans += (pos - vec[i].x) + vec[i].z;
}
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 32;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, t, k;
cin >> n;
long long a, b, c, sum = 0, r;
while (n--) {
cin >> t >> k;
long long x;
vector<int> v;
for (int i = 1; i <= t; i++) {
cin >> x;
if (x % 2) v.push_back(i);
}
int l = v.size();
if (v.size() < k || (l % 2 != k % 2))
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < k - 1; i++) cout << v[i] << " ";
cout << t << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double sx, sy, tx, ty;
double vm, t;
double vx, vy, wx, wy;
double dis(double ax, double ay, double bx, double by) {
return sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by));
}
double getr(double x) {
double xx, yy;
xx = sx + min(t, x) * vx + max(0.0, x - t) * wx;
yy = sy + min(t, x) * vy + max(0.0, x - t) * wy;
return dis(xx, yy, tx, ty);
}
int main() {
scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf", &sx, &sy, &tx, &ty, &vm, &t, &vx, &vy,
&wx, &wy);
double le, ri, mid;
if (vm * t > getr(t)) {
le = 0;
ri = t;
} else {
le = t;
ri = 1e10;
}
while (ri - le > 1e-8) {
mid = (le + ri) / 2;
if (mid * vm > getr(mid))
ri = mid;
else
le = mid;
}
printf("%.10f\n", le);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, c = 0, m;
string s;
cin >> s;
n = s.length();
for (i = 0; i < n; i++) {
if (s[i] == 'a') c++;
}
m = min(n, (2 * c - 1));
cout << m;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0, -1};
int dy[] = {0, 1, 0, -1, 0};
const int M = 500010;
vector<vector<int> > A, dir;
int row, col;
char str[M];
bool ok() {
int i, j, k;
for (i = 1; i <= row; i++)
for (j = 1; j <= col; j++) dir[i][j] = -1;
for (i = 1; i <= row; i++) {
for (j = 1; j <= col; j++) {
if (A[i][j] == 1 || A[i][j] == 2)
dir[i][j] = 1;
else if (A[i][j] == 3 || A[i][j] == 4)
dir[i][j] = 0;
}
}
for (i = 1; i <= row; i++) {
int c = 0;
for (j = 1; j <= col; j++)
if (dir[i][j] != -1) {
c = j;
break;
}
if (c) {
for (j = c + 1; j <= col; j++) {
if (dir[i][j] == -1)
dir[i][j] = dir[i][j - 1] ^ 1;
else if (dir[i][j] == dir[i][j - 1])
return 0;
}
for (j = c - 1; j >= 1; j--) {
if (dir[i][j] == -1)
dir[i][j] = dir[i][j + 1] ^ 1;
else if (dir[i][j] == dir[i][j + 1])
return 0;
}
}
}
for (i = 1; i <= row; i++)
for (j = 1; j <= col; j++) dir[i][j] = -1;
for (i = 1; i <= row; i++) {
for (j = 1; j <= col; j++) {
if (A[i][j] == 1 || A[i][j] == 4)
dir[i][j] = 1;
else if (A[i][j] == 2 || A[i][j] == 3)
dir[i][j] = 0;
}
}
for (j = 1; j <= col; j++) {
int r = 0;
for (i = 1; i <= row; i++)
if (dir[i][j] != -1) {
r = i;
break;
}
if (r) {
for (i = r + 1; i <= row; i++) {
if (dir[i][j] == -1)
dir[i][j] = dir[i - 1][j] ^ 1;
else if (dir[i][j] == dir[i - 1][j])
return 0;
}
for (i = r - 1; i >= 1; i--) {
if (dir[i][j] == -1)
dir[i][j] = dir[i + 1][j] ^ 1;
else if (dir[i][j] == dir[i + 1][j])
return 0;
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
int i, j, k;
scanf("%d%d", &row, &col);
A.resize(row + 2);
dir.resize(row + 2);
for (i = 0; i < row + 2; i++) A[i].resize(col + 2), dir[i].resize(col + 2);
for (i = 1; i <= row; i++) {
scanf("%s", str);
for (j = 1; j <= col; j++) {
if (str[j - 1] == '.')
A[i][j] = 0;
else
A[i][j] = str[j - 1] - '0';
}
}
if (!ok()) {
printf("%s\n", "0");
return 0;
};
int sum = 0;
for (i = 1; i <= row; i++) {
bool f = false;
for (j = 1; j <= col; j++) {
if (A[i][j]) f = true;
}
sum += (!f);
}
for (i = 1; i <= col; i++) {
bool f = false;
for (j = 1; j <= row; j++) {
if (A[j][i]) f = true;
}
sum += (!f);
}
int ans = 1;
while (sum--) {
ans *= 2;
ans %= 1000003;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
if (s[s.size() - 1] == 'o')
cout << "FILIPINO\n";
else if (s[s.size() - 1] == 'a')
cout << "KOREAN\n";
else
cout << "JAPANESE\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int vis[2000002];
long long int yo[2000002];
long long int ar[200001];
int main() {
std::ios::sync_with_stdio(false);
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) {
long long int t;
cin >> t;
ar[i] = t;
yo[t + 1] = t;
}
for (long long int i = 1; i <= 2000001; i++) {
yo[i] = max(yo[i], yo[i - 1]);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (vis[ar[i]] == 0) {
vis[ar[i]] = 1;
for (long long int j = 2 * ar[i]; j <= 2000001; j += ar[i]) {
ans = max(ans, yo[j] % ar[i]);
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int INF = 1e9 + 7;
int n, h, a[N];
struct Node {
int v, id;
Node() {}
Node(int _v, int _id) { v = _v, id = _id; }
bool operator<(const Node &p) const {
if (v != p.v) return v < p.v;
return id < p.id;
}
} nd[N];
void solve() {
int mn, mx, p = n, diff = (a[n] + a[n - 1]) - (a[1] + a[2]);
mn = min(a[1] + a[2] + h, a[2] + a[3]);
mx = max(a[n] + a[n - 1], a[1] + a[n] + h);
if (mx - mn < diff) p = 1, diff = mx - mn;
mn = a[1] + a[2];
mx = a[n] + a[n - 1] + h;
if (mx - mn < diff) p = n - 1, diff = mx - mn;
for (int i = (2), I = (n - 1); i < I; ++i) {
mn = a[1] + a[2];
mx = a[n] + max(a[n - 1], a[i] + h);
if (mx - mn < diff) p = i, diff = mx - mn;
}
for (int i = (1), I = (n + 1); i < I; ++i) a[nd[i].id] = 1 + (i > p);
printf("%d\n", diff);
for (int i = (1), I = (n + 1); i < I; ++i) {
if (i - 1) putchar(' ');
printf("%d", a[i]);
}
}
int main() {
scanf("%d%d", &n, &h);
for (int i = (1), I = (n + 1); i < I; ++i)
scanf("%d", &a[i]), nd[i] = Node(a[i], i);
sort(a + 1, a + n + 1);
sort(nd + 1, nd + n + 1);
a[n + 1] = INF;
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool isvalid(int i, int j) {
if (i >= 0 and i < n and j >= 0 and j < m) return true;
return false;
}
void dfs(int i, int j, int x, vector<vector<int> > &vis,
vector<vector<int> > &v) {
vis[i][j] = x;
if (isvalid(i + 1, j) and !vis[i + 1][j] and v[i + 1][j] == '#')
dfs(i + 1, j, x, vis, v);
if (isvalid(i - 1, j) and !vis[i - 1][j] and v[i - 1][j] == '#')
dfs(i - 1, j, x, vis, v);
if (isvalid(i, j + 1) and !vis[i][j + 1] and v[i][j + 1] == '#')
dfs(i, j + 1, x, vis, v);
if (isvalid(i, j - 1) and !vis[i][j - 1] and v[i][j - 1] == '#')
dfs(i, j - 1, x, vis, v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
vector<vector<int> > v(n, vector<int>(m)), vis(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
string str;
cin >> str;
for (int j = 0; j < m; ++j) {
v[i][j] = str[j];
}
}
int x = 1, f = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!vis[i][j] and v[i][j] == '#') {
dfs(i, j, x, vis, v);
x++;
}
}
}
vector<int> sr(n), sc(m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
sr[i] += vis[i][j];
sc[j] += vis[i][j];
}
}
int r = 0, c = 0;
for (int i = 0; i < n; ++i) {
if (sr[i] == 0) r++;
int l = 0, r = m - 1;
while (l < m and vis[i][l] == 0) l++;
while (r >= 0 and vis[i][r] == 0) r--;
for (int k = l; k <= r; ++k) {
if (vis[i][k] == 0) f = 0;
}
}
for (int j = 0; j < m; ++j) {
if (sc[j] == 0) c++;
int l = 0, r = n - 1;
while (l < n and vis[l][j] == 0) l++;
while (r >= 0 and vis[r][j] == 0) r--;
for (int k = l; k <= r; ++k) {
if (vis[k][j] == 0) f = 0;
}
}
if ((r == 0 ^ c == 0) or !f) {
cout << "-1\n";
} else
cout << x - 1 << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int N = 2e5 + 10;
const int M = 5e3 + 10;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const int mod2 = 998244353;
const int mod3 = 1e9 + 9;
const int hash1 = 131;
const int hash2 = 13331;
struct NODE {
int ch[26];
int len, fa, cnt;
};
struct SAM {
int las = 1, tot = 1;
NODE node[N << 1];
void add(int c, int val) {
int p = las;
int np = las = ++tot;
node[np].len = node[p].len + 1;
node[np].cnt = val;
for (; p && !node[p].ch[c]; p = node[p].fa) node[p].ch[c] = np;
if (!p)
node[np].fa = 1;
else {
int q = node[p].ch[c];
if (node[q].len == node[p].len + 1)
node[np].fa = q;
else {
int nq = ++tot;
node[nq] = node[q];
node[nq].len = node[p].len + 1;
node[nq].cnt = 0;
node[q].fa = node[np].fa = nq;
for (; p && node[p].ch[c] == q; p = node[p].fa) node[p].ch[c] = nq;
}
}
}
int c[N << 1], a[N << 1];
void toposort() {
for (int i = 1; i <= tot; i++) c[node[i].len]++;
for (int i = 1; i <= tot; i++) c[i] += c[i - 1];
for (int i = 1; i <= tot; i++) a[c[node[i].len]--] = i;
for (int i = tot; i; i--) {
int x = a[i];
int fa = node[x].fa;
node[fa].cnt += node[x].cnt;
}
}
} sam;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
string str, val;
cin >> str >> val;
for (int i = 0; i < str.length(); i++) {
sam.add(str[i] - 'a', val[i] == '0' ? 1 : 0);
}
sam.toposort();
long long ans = 0;
for (int i = 1; i <= sam.tot; i++) {
NODE x = sam.node[i];
ans = max(ans, (long long)x.len * x.cnt);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
long long a[100009];
long long b[100009];
int mag[500009];
int dad[500009];
void unio(int x, int y) {
if (mag[x] < mag[y])
dad[x] = y;
else {
dad[y] = x;
mag[x]++;
}
}
int holvan(int x) {
if (dad[x] == x) return x;
return dad[x] = holvan(dad[x]);
}
long long totalsum = 0;
vector<pair<long long, pair<int, int> > > edges;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> m >> n;
for (int i = 1; i <= m; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n + m; i++) {
mag[i] = 1;
dad[i] = i;
}
for (int i = 1; i <= m; i++) {
int db;
cin >> db;
for (int j = 1; j <= db; j++) {
int x;
cin >> x;
long long cc = a[i] + b[x];
edges.push_back({cc, {i, m + x}});
totalsum += cc;
}
}
long long mincost = 0;
sort(edges.begin(), edges.end());
reverse(edges.begin(), edges.end());
for (int i = 0; i < edges.size(); i++) {
int x = holvan(edges[i].second.first);
int y = holvan(edges[i].second.second);
if (x != y) {
mincost += edges[i].first;
unio(x, y);
}
}
cout << totalsum - mincost << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, s, p;
cin >> k >> n >> s >> p;
int temp = 0;
int ans = 0;
if (n % s != 0) {
temp = n / s + 1;
} else {
temp = n / s;
}
temp = temp * k;
if (temp % p != 0) {
ans = temp / p + 1;
} else {
ans = temp / p;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(string a, string b) { return ((a[0] == b[0]) || (a[1] == b[1])); }
vector<string> a;
map<vector<string>, bool> dp;
bool rec(int id) {
if (id == 1) {
return true;
}
if (dp.count(a) != 0) {
return dp[a];
}
bool res = 0;
if (id > 3) {
if (cmp(a[id], a[id - 3])) {
string past = a[id - 3];
a[id - 3] = a[id];
a.pop_back();
res |= rec(id - 1);
a.push_back(a[id - 3]);
a[id - 3] = past;
}
}
if (!res) {
if (cmp(a[id], a[id - 1])) {
string past = a[id - 1];
a[id - 1] = a[id];
a.pop_back();
res |= rec(id - 1);
a.push_back(a[id - 1]);
a[id - 1] = past;
}
}
return (dp[a] = res);
}
int main() {
int n;
scanf("%d", &n);
a.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
printf("%s", (rec(n) ? "YES" : "NO"));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dfs(int x, const vector<vector<int> > &g, vector<char> &used,
vector<vector<int> > &ans) {
used[x] = 1;
vector<pair<int, int> > from;
vector<int> sons, kill;
for (int dest : g[x])
if (!used[dest]) {
sons.push_back(dest);
int cur = dfs(dest, g, used, ans);
if (cur != -1) {
ans.push_back(vector<int>{cur, dest, x});
kill.push_back(dest);
}
}
sort((sons).begin(), (sons).end());
sort((kill).begin(), (kill).end());
int last = -1;
for (int dest : g[x]) {
assert(used[dest]);
if (used[dest] != 2) continue;
if (binary_search((kill).begin(), (kill).end(), dest)) continue;
if (last == -1)
last = dest;
else
ans.push_back({last, x, dest}), last = -1;
}
used[x] = 2;
return last;
}
void solve(int n) {
int m;
cin >> m;
vector<vector<int> > g(n);
for (int i = 0; i < (int)(m); ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<vector<int> > ans;
vector<char> used(n);
for (int i = 0; i < (int)(n); ++i)
if (!used[i]) dfs(i, g, used, ans);
cout << (int)(ans).size() << "\n";
for (int i = 0; i < (int)((int)(ans).size()); ++i) {
assert((int)(ans[i]).size() == 3);
for (int j = 0; j < (int)(3); ++j) cout << ans[i][j] + 1 << " \n"[j == 2];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
while (cin >> n) solve(n);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001], b[100001];
int main() {
int n, q = 0, w = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (int i = 2; i <= n; i += 2) {
q += abs(a[i] - a[i - 1]);
}
cout << q;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.