solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:100000000")
int mas[100100];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &mas[i]);
int add = 0;
for (int i = 0; i < m; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int v, x;
scanf("%d %d", &v, &x);
mas[v - 1] = x - add;
} else if (t == 2) {
int y;
scanf("%d", &y);
add += y;
} else {
int q;
scanf("%d", &q);
printf("%d\n", mas[q - 1] + add);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
int main(){
int n,a,b,c;cin>>n>>a>>b>>c;
cout<<n-(a+b-c)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int f[N], n, q, u[N], a[N], k, b[N], mp[N];
vector<int> v[N];
int cmp(int x, int y) { return f[x] < f[y]; }
inline int solve(int x, int y) {
int l = 0, r = v[x].size() - 1, mid, t;
while (l <= r) {
mid = (l + r) >> 1;
if (v[x][mid] >= y)
r = (t = mid) - 1;
else
l = mid + 1;
}
return v[x][t];
}
inline void work() {
int ans[3], cnt;
cnt = ans[0] = ans[1] = 0;
for (int i = n; i >= 1; i--) {
if (mp[a[i]]) continue;
ans[cnt++] = a[i];
if (cnt == 2) break;
}
if (f[ans[0]] == 0) {
puts("0 0");
return;
}
int re = solve(ans[0], f[ans[1]]);
printf("%d %d\n", ans[0], re);
}
int main() {
while (cin >> n) {
memset(f, 0, sizeof f);
for (int i = 1; i <= n; i++) {
int ip, val;
scanf("%d%d", &ip, &val);
f[ip] = val;
v[ip].push_back(val);
}
for (int i = 1; i <= n; i++) a[i] = i;
sort(a + 1, a + n + 1, cmp);
cin >> q;
while (q--) {
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &b[i]);
mp[b[i]] = 1;
}
work();
for (int i = 1; i <= k; i++) mp[b[i]] = 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[150000], str1[150000];
scanf("%s", str);
scanf("%s", str1);
int n1 = strlen(str), n2 = strlen(str1), count = 0;
for (int i = 1; i <= n1 && i <= n2; i++) {
if (n1 % i == 0 && n2 % i == 0) {
int p = 0, j;
for (j = 0; j < n1; j++) {
if (str[j] == str[j % i])
continue;
else
break;
}
if (j == n1) {
j = 0;
for (j = 0; j < n2; j++) {
if (str1[j] == str1[j % i])
continue;
else
break;
}
if (j == n2) {
int k;
for (k = 0; k < i; k++) {
if (str[k] == str1[k])
continue;
else
break;
}
if (k == i) {
j = i;
i = 1;
while (j * i <= n1 && j * i <= n2) {
int x = j * i;
if (n1 % x == 0 && n2 % x == 0) count++;
i++;
}
break;
}
}
}
}
}
printf("%d\n", count);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
int ans = 10 - x/200;
cout << ans << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
string X;
stack<int> sta;
int child=0;
int main(){
cin>>X;
for(int i=0;i<X.size();i++){
if(X[i]=='S')
sta.push(1);
else{
if(!sta.empty()){
child+=2;
sta.pop();
}
}
}
cout<<X.size()-child<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define INF (1<<30)
#define MOD 1000000007
#define l_ength size
using ll = long long;
using namespace std;
vector<int> eT;
void es( int n ){
for( int i = 0; i < n; ++i ) eT.push_back(i);
}
int wurzel( int x ){
if( eT.at(x) == x ){
return x;
} else {
return eT.at(x) = wurzel( eT.at(x) );
}
}
void verbinden( int x, int y ){
x = wurzel(x);
y = wurzel(y);
if( x == y ) return;
eT.at(x) = y;
}
bool gleich( int x, int y ){
return wurzel(x) == wurzel(y);
}
int main(){
int n, m;
cin >> n >> m;
es(n);
vector<int> p(n);
for( int &i : p ) cin >> i;
for( int i = 0; i < m; ++i ){
int x, y;
cin >> x >> y;
verbinden(x-1, y-1);
}
int ans = 0;
for( int i = 0; i < n; ++i ){
if( gleich( p.at(i)-1, i ) ) ++ans;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
int32_t main(){
string s;cin>>s;set<char> se;for(char x:s)se.insert(x);
if(s.length()==se.size()) cout<<"yes";
else cout<<"no";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
long long F(long long c) {
long long cnow = 1;
long long ans = 0;
for (long long i = 0; i < a.size(); i++) {
ans += abs(cnow - a[i]);
cnow *= c;
if (ans > 1e15) return 1e18 + 7;
}
return ans;
}
int32_t main() {
long long n;
cin >> n;
a.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
if (n > 60) {
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += a[i] - 1;
}
cout << ans;
return 0;
}
long long l = 1, r = 1e9 + 7;
while (r - l > 2) {
long long m1 = l + (r - l) / 3;
long long m2 = r - (r - l) / 3;
if (F(m1) > F(m2))
l = m1;
else
r = m2;
}
cout << min(F(l), min(F(l + 1), F(r)));
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int a[3];
int main(){
cin>>a[0]>>a[1]>>a[2];
sort(a,a+3);
cout<<(a[0]==5&&a[1]==5&&a[2]==7?"YES":"NO")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxp = 22;
const long double EPS = 1e-18;
const long long INF = 1e18;
const int MOD = 1e9 + 7;
const int N = 2e5 + 1;
struct DSU {
vector<int> par, siz;
int cnt;
void init(int n) {
cnt = n;
par.assign(n + 1, 0);
siz.assign(n + 1, 1);
iota(par.begin(), par.end(), 0);
}
int find(int x) { return (par[x] == x) ? x : par[x] = find(par[x]); }
bool merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
cnt--;
return true;
}
};
struct ano {
int x, y, z;
bool operator<(const ano &a) const { return z > a.z; }
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m, n;
cin >> m >> n;
int a[m], b[n];
int i;
for (i = 0; i < m; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
long long tot = 0;
vector<ano> arr;
for (i = 0; i < m; i++) {
int s;
cin >> s;
for (int j = 0; j < s; j++) {
int x;
cin >> x;
int cost = b[x - 1] + a[i];
arr.push_back({x, i + n + 1, cost});
tot += cost;
}
}
sort((arr).begin(), (arr).end());
long long mst = 0;
DSU dsu;
dsu.init(n + m);
for (auto x : arr) {
if (dsu.merge(x.x, x.y)) {
mst += x.z;
}
}
cout << tot - mst << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
vector<int> adj[100005];
int n, num, colors[100005];
long long int dp0[100005], dp1[100005];
void dfs(int v, int pv) {
dp0[v] = 1 - colors[v];
dp1[v] = colors[v];
for (auto u : adj[v]) {
if (u == pv) continue;
dfs(u, v);
long long int temp = dp1[v];
dp1[v] =
(temp * dp0[u]) % MOD + (dp1[u] * temp) % MOD + (dp0[v] * dp1[u]) % MOD;
if (dp1[v] >= MOD) dp1[v] %= MOD;
temp = dp0[v];
dp0[v] = (temp * dp0[u]) % MOD + (dp1[u] * temp) % MOD;
if (dp0[v] >= MOD) dp0[v] %= MOD;
}
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> num;
adj[i].push_back(num + 1);
adj[num + 1].push_back(i);
}
for (int i = 1; i <= n; i++) cin >> colors[i];
dfs(1, 0);
cout << dp1[1] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double p[300];
double dp[300];
double tmp[300];
int main() {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 0; i <= x; i++) scanf("%lf", &p[i]);
for (int i = 0; i <= x; i++) dp[i] = p[i];
n--;
while (n) {
if (n & 1) {
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i <= 200; i++)
for (int j = 0; j <= 200; j++) tmp[i ^ j] += dp[i] * p[j];
for (int i = 0; i < 200; i++) dp[i] = tmp[i];
}
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i <= 200; i++)
for (int j = 0; j <= 200; j++) tmp[i ^ j] += p[i] * p[j];
for (int i = 0; i < 200; i++) p[i] = tmp[i];
n = n >> 1;
}
printf("%.8lf\n", 1 - dp[0]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f, g, h, i, j, k;
vector<int> F;
int prime[5005], v[5005], tot;
int tmp;
void Pre() {
for (i = 2; i <= a; i++)
if (v[i] == 0) {
prime[++tot] = i;
for (j = 2; i * j <= a; j++) v[i * j] = 1;
}
}
int main() {
cin >> a;
F.push_back(1);
Pre();
for (i = 1; i <= tot; i++) {
e = F.size();
for (j = 0; j < e; j++) {
tmp = F[j] * prime[i];
while (tmp <= 2 * a * a) {
F.push_back(tmp);
tmp *= prime[i];
}
}
if (F.size() >= a) break;
}
e = F.size() - 1;
for (i = 1; i <= a; i++) cout << F[e--] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tn[200], tp[200];
int ans[25000000];
bool used[25000000];
int d[2000];
int a[2000];
int z;
int f(int x, int y) { return d[x] + y; }
int solve(int h, int mask) {
int x = d[h] + mask;
if (used[x]) return ans[x];
used[x] = 1;
if (h == m) return 0;
if (tn[h] == 2)
ans[x] = 1e8;
else
ans[x] = -1e8;
int q = ans[x];
for (int i = 0; i < m; i++) {
if (mask & (1 << i)) continue;
if (tn[h] == 2)
q = min(q, -a[i] * (tp[h] == 1) + solve(h + 1, mask | (1 << i)));
else
q = max(q, a[i] * (tp[h] == 1) + solve(h + 1, mask | (1 << i)));
}
ans[x] = q;
return q;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
sort(a, a + n);
reverse(a, a + n);
for (int i = 0; i < m; i++) {
char c;
cin >> c >> tn[i];
d[i] = i * 1100000;
if (c == 'p')
tp[i] = 1;
else
tp[i] = 2;
}
cout << solve(0, 0) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
string sivan;
cin >> sivan;
int sum = 0;
int jog = 0;
for (int i = 0; i < n; i++) {
if (sivan[i] == 'L')
sum = sum - 1;
else
jog = jog + 1;
}
int result;
result = abs(sum) + jog + 1;
cout << result;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, u, v;
long long ans, fl[25], fw[25], dp[2][105][25];
vector<int> G[105];
void dfs(int u, int fa) {
for (int v : G[u])
if (v != fa) dfs(v, u);
dp[0][u][0] = dp[1][u][0] = 1;
for (int v : G[u])
if (v != fa) {
memset(fl, 0, sizeof(fl));
memset(fw, 0, sizeof(fw));
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++)
fw[min(i, j + 1)] += dp[0][u][i] * dp[0][v][j] % 1000000007;
for (int j = 0; j <= k; j++)
if (k - i >= j + 1)
fw[i] += dp[0][u][i] * dp[1][v][j] % 1000000007;
else
fl[j + 1] += dp[0][u][i] * dp[1][v][j] % 1000000007;
}
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= k; j++)
if (k - j - 1 >= i)
fw[j + 1] += dp[1][u][i] * dp[0][v][j] % 1000000007;
else
fl[i] += dp[1][u][i] * dp[0][v][j] % 1000000007;
for (int j = 0; j <= k; j++)
fl[max(i, j + 1)] += dp[1][u][i] * dp[1][v][j] % 1000000007;
}
for (int i = 0; i <= k; i++) {
dp[0][u][i] = fw[i] % 1000000007;
dp[1][u][i] = fl[i] % 1000000007;
}
}
}
int main() {
cin.sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i < n; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, -1);
for (int i = 0; i <= k; i++) ans = (ans + dp[0][1][i]) % 1000000007;
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vis[16];
int main() {
int n, k, temp, temp1;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
temp1 = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &temp);
temp1 = (temp1 << 1) + temp;
}
vis[temp1] = true;
}
for (int i = 0; i < 16; i++) {
for (int j = i; j < 16; j++) {
if (vis[i] && vis[j] && ((i & j) == 0)) {
puts("YES");
return 0;
}
}
}
puts("NO");
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <cassert>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
// Levenshtein Distance
int levenshtein(string a, string b) {
int n = a.size(), m = b.size();
int d[n+1][m+1];
REP(i, n+1) d[i][0] = i;
REP(i, m+1) d[0][i] = i;
for (int i=1; i<=n; ++i) {
for (int j=1; j<=m; ++j) {
d[i][j] = min(min(d[i-1][j] + 1, // a deletion
d[i][j-1] + 1), // an insertion
d[i-1][j-1] + (a[i-1] != b[j-1])); // a substituion
if (i>=2 && j>=2 && a[i-2]==b[j-1] && a[i-1]==b[j-2])
d[i][j] = min(d[i][j], d[i-2][j-2]+1);
//printf("(%d,%d):%d:%d ",i,j,d[i][j],a[i-1]!=b[j-1]);
}
//cout << endl;
}
return d[n][m];
}
bool judge(string a, string b, int d) {
if (levenshtein(a,b) <= d) return 1;
REP(i, a.size()-1) {
string tmp = a;
swap(tmp[i], tmp[i+1]);
//cout << tmp << " " << b << " " << levenshtein(tmp, b) << endl;
if (levenshtein(tmp, b) <= d-1) return 1;
}
REP(i, b.size()-1) {
string tmp = b;
swap(tmp[i], tmp[i+1]);
//cout << tmp << " " << a << " " << levenshtein(tmp, a) << endl;
if (levenshtein(tmp, a) <= d-1) return 1;
}
return 0;
}
int main() {
int n;
while(cin>>n,n) {
int d;
cin >> d;
string name[n];
REP(i, n) {
cin >> name[i];
}
set<pair<string, string> > se;
sort(name, name+n);
REP(i, n) {
REP(j, i) {
//cout << name[j] <<"," <<name[i]<< " : " << levenshtein(name[j], name[i]) << endl;
if (judge(name[j], name[i], d))
se.insert(make_pair(name[j], name[i]));
}
}
FOR(it, se) {
cout << it->first << "," << it->second << endl;
}
cout << se.size() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2011;
const int M = 5011;
int a[N];
double p[N];
double sp[M];
double pp[M * 2];
int main() {
ios ::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
map<int, double> mp;
for (int i = 1; i <= n; i++) p[i] = (double)(i - 1) / (n * (n - 1) / 2);
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++) sp[a[i] - a[j]] += 1.0 / (n * (n - 1) / 2);
for (int i = 1; i <= 5000; i++)
for (int j = 1; j <= 5000; j++) pp[i + j] += sp[i] * sp[j];
for (int i = 1; i < M * 2; i++) pp[i] += pp[i - 1];
double ans = 0;
for (int i = 1; i <= 5000; i++) ans += sp[i] * pp[i - 1];
cout << setprecision(8) << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool vowel(char a) {
a = toupper(a);
if ((a == 'A') || (a == 'E') || (a == 'I') || (a == 'O') || (a == 'U'))
return 1;
return 0;
}
long long int n, m, q, a, b, c, sum = 0, cnt = 0;
long long int arr[1000055];
map<long long int, bool> mp;
string str;
struct my {
long long int a, b;
} M[200005];
bool cmp(my x, my y) { return x.a > y.a ? 1 : 0; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
cin >> M[i].a;
M[i].b = i;
}
sort(&M[0], &M[n], cmp);
sort(arr, arr + n);
long long int lst[200006];
for (int i = 0; i < n; i++) {
lst[M[i].b] = arr[i];
}
for (int i = 0; i < n; i++) cout << lst[i] << " ";
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[501][501][2];
bool used[501][501][2];
vector<vector<int>> g;
int n, m;
bool ok = 0;
vector<int> ans1, ans2;
int vis[502];
void dfs(int v) {
vis[v] = 1;
for (auto to : g[v]) {
if (!vis[to]) {
dfs(to);
}
}
}
struct st {
int a, b, t;
st() : a(0), b(0), t(0) {}
st(int a, int b, int t) : a(a), b(b), t(t) {}
};
void bfs() {
p[0][n - 1][0] = {-1, -1};
used[0][n - 1][0] = 1;
queue<st> q;
q.push(st(0, n - 1, 0));
while (!q.empty()) {
int a = q.front().a, b = q.front().b, t = q.front().t;
q.pop();
if (t == 0) {
for (auto to : g[a]) {
if (!used[to][b][1]) {
used[to][b][1] = 1;
p[to][b][1] = {a, b};
q.push({to, b, 1});
}
}
} else {
for (auto to : g[b]) {
if (to == a) continue;
if (!used[a][to][0]) {
used[a][to][0] = 1;
p[a][to][0] = {a, b};
q.push({a, to, 0});
}
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
bfs();
if (!used[n - 1][0][0] || !vis[n - 1]) {
cout << -1;
return 0;
}
int a = n - 1, b = 0, t = 0;
ans1.push_back(n - 1), ans2.push_back(0);
while (p[a][b][t].first != -1) {
int xa = p[a][b][t].first, xb = p[a][b][t].second;
t = 1 - t;
if (t == 0)
ans1.push_back(xa);
else
ans2.push_back(xb);
a = xa, b = xb;
}
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
cout << ans1.size() - 1 << '\n';
for (int i = 0; i < ans1.size(); ++i) {
cout << ans1[i] + 1 << ' ';
}
cout << '\n';
for (int i = 0; i < ans1.size(); ++i) {
cout << ans2[i] + 1 << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isp(long long int n) {
if (n == 1 || (n % 2 == 0 && n != 2)) return false;
if (n == 2) return true;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return false;
}
return true;
}
long long int fun(long long int m, long long int n) {
if (m == n) return 0;
if (m > n && m % 2 != 0) return -1;
if (m > n && m % 2 == 0) {
long long int v = fun(m / 2, n);
if (v != -1)
return 1 + v;
else
return -1;
} else {
long long int v = fun(m * 6, n);
if (v != -1)
return 1 + v;
else
return -1;
}
}
int main() {
int z2, m, mn, mx, i2, ind, t, tl, x1 = 1, y1, x2, y2, q, o1, o2, e1, e2, k1,
k2, t1, j, o, e, h2, l1, l2, m1, m2, odd,
y, z;
long long int n1, c, d, i1, ans, n, b1, n2, x, i, d2, mx1, mx2, p, f, r, w, g,
k, a[1010];
string s1, s2;
unordered_map<int, int> mp;
unordered_set<int> st;
ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n - 1; i++) {
if (a[i - 1] == 1 && !a[i] && a[i + 1] == 1) {
ans++;
a[i + 1] = 0;
}
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long toNumber(string str) {
long long num;
stringstream ss(str);
ss >> num;
return num;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int ans[][6] = {{4, 5, 6, 3, 2, 1},
{11, 12, 13, 10, 9, 8},
{4, 5, 6, 3, 2, 1},
{11, 12, 13, 10, 9, 8}};
string str;
cin >> str;
long long index = toNumber(str.substr(0, str.size() - 1)) - 1;
char seat = str.back();
long long waitingTime = 16 * (index / 4) + ans[index % 4][seat - 'a'];
cout << waitingTime << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void lose() { cout << "cslnb\n"; }
void win() { cout << "sjfnb\n"; }
long long cntMoves(vector<long long> &p) {
sort(p.begin(), p.end());
long long ans = 0;
for (int i = 0; i < p.size(); i++) {
assert(p[i] >= i);
ans += p[i] - i;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> p(n);
long long sum = 0;
map<long long, long long> cnt;
for (long long i = 0; i < (long long)n; i++) {
cin >> p[i];
sum += p[i];
cnt[p[i]]++;
}
if (sum == 0) {
lose();
return 0;
}
long long cntG2 = 0;
long long ind = -1;
for (auto c : cnt) {
if (c.second > 2) {
lose();
return 0;
} else if (c.second == 2) {
cntG2++;
ind = c.first;
}
}
if (cntG2 > 1) {
lose();
return 0;
}
if (cntG2 == 1) {
for (int i = 0; i < n; i++) {
if (p[i] == ind) {
if (cnt[p[i] - 1] > 0 || p[i] == 0) {
lose();
return 0;
}
break;
}
}
}
if (cntMoves(p) % 2 == 1) {
win();
} else {
lose();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, S, T, a[200005], b[200005], fa[200005], dep[200005];
bool fl, vs[200005];
vector<int> e[200005];
int U, V, U1, cnt, ps, st1[200005], st2[200005], st3[200005], st[2][200005];
long long ans1, ans2;
void dfs(int u, int f) {
fa[u] = f;
if (f) dep[u] = dep[f] + 1;
for (int i = 0, v; i < e[u].size(); ++i) {
v = e[u][i];
if (v != f) dfs(v, u);
}
}
int ins(int u) {
if (st2[st2[0]] == u) {
--st2[0];
return -1;
}
st2[++st2[0]] = u;
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (!a[i]) S = i;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
if (!b[i]) T = i;
}
for (int i = 1, u, v; i < n; ++i)
scanf("%d %d", &u, &v), e[u].push_back(v), e[v].push_back(u);
dfs(T, 0);
for (int i = S; i != T; i = fa[i]) ans1 += ins(i), swap(a[i], a[fa[i]]);
for (int i = 1; i <= n; ++i, fl = 0)
if (!vs[i] && a[i] != b[i]) {
for (int j = 0, v; j < e[i].size(); ++j) {
v = e[i][j];
if (v != fa[i] && a[v] != b[v]) fl = 1;
}
if (fl) continue;
++cnt;
if (cnt > 2) {
puts("-1");
return 0;
}
for (int j = i; j; j = fa[j]) {
if (a[j] == b[j]) break;
if (vs[j]) {
puts("-1");
return 0;
}
vs[j] = 1;
st[cnt - 1][++st[cnt - 1][0]] = j;
}
}
if (!cnt) {
printf("0 %lld\n", ans1);
return 0;
}
if (cnt < 2)
U = U1 = fa[st[0][st[0][0]]], V = st[0][1];
else {
U1 = fa[st[0][st[0][0]]];
U = st[0][1];
V = st[1][1];
if (U1 != fa[st[1][st[1][0]]]) {
puts("-1");
return 0;
}
}
for (int i = st[0][0]; i; --i) st1[++st1[0]] = st[0][i];
for (int i = 1; i <= st[1][0]; ++i) st1[++st1[0]] = st[1][i];
for (int i = 1; i <= st1[0]; ++i)
if (a[st1[1]] == b[st1[i]]) {
ps = i;
break;
}
if (!ps) {
puts("-1");
return 0;
}
for (int i = 1, j = ps; i <= st1[0]; ++i, j = j % st1[0] + 1)
if (a[st1[i]] != b[st1[j]]) {
puts("-1");
return 0;
}
for (int i = U1; i != T; i = fa[i]) st3[++st3[0]] = i;
for (int i = st3[0]; i; --i) ans1 += ins(st3[i]);
for (int i = st1[0]; i; --i) ans1 += ins(st1[i]);
++ans1;
ans1 += 1ll * (st1[0] + 1) * (ps - 2) + dep[U1];
st2[0] = 0;
for (int i = S; i != T; i = fa[i]) ans2 += ins(i);
for (int i = st3[0]; i; --i) ans2 += ins(st3[i]);
for (int i = 1; i <= st1[0]; ++i) ans2 += ins(st1[i]);
++ans2;
ans2 += 1ll * (st1[0] + 1) * (st1[0] - ps) + dep[U1];
if (U > V) swap(U, V);
printf("%d %d %lld\n", U, V, min(ans1, ans2));
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define rrep(i,n) for(int i=n-1; i>=0; i--)
#define INF 999999
using namespace std;
int dp[101][101][6001];
int main(){
int n;
while(cin >> n ,n){
int p[n];
rep(i,n) cin >> p[i];
rep(i,n+1) rep(j,n+1) rep(k,6000){
dp[i][j][k] = INF;
}
dp[0][0][0] = 0;
rep(i,n) rep(j,n) rep(k,5000) if(dp[i][j][k] != INF){
dp[i+1][j][k] = min(dp[i+1][j][k],dp[i][j][k]);
/* if(k >= 500){
cout << " k >=500" << endl;
dp[i][j+k/500][k] = min(dp[i][j+k/500][k], dp[i][j][k]);
}*/
int cost = p[i]%1000;
//cout <<"i= "<< i << " j= " << j << " k = " << k << " " << "cost = " << cost << endl;
if(cost-500 <= k && cost >= 500) {
//cout << "A " <<k-cost+500<< endl;
dp[i+1][j+1][k - cost+500] = min(dp[i+1][j+1][k-cost+500],dp[i][j][k] + p[i]);
}
if(cost <= 500 && cost > 0){
//cout << "B" << endl;
dp[i+1][j+1][k + 500 - cost] = min(dp[i+1][j+1][k+500-cost],dp[i][j][k] + p[i]);
}
if(cost <= 500 && k >= cost+500){
//cout << "C" << endl;
dp[i+1][j+1][k-500-cost] = min(dp[i+1][j+1][k-500-cost], dp[i][j][k] + p[i]);
}
if(k-cost >= 0){
dp[i+1][j][k-cost] = min(dp[i+1][j][k-cost], dp[i][j][k] + p[i]);
}
else{
dp[i+1][j][k+1000-cost] = min(dp[i+1][j][k+1000-cost], dp[i][j][k] + p[i]);
}
}
int ans = 0,ans_min = INF;
rep(i,n+1) rep(j,n+1) rep(k,5000) if(dp[i][j][k] != INF){
if(j > ans || (j== ans && ans_min > dp[i][j][k]) ){
ans = j;
ans_min = dp[i][j][k];
}
}
cout << ans << " " << ans_min << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[1000][1000];
long long int arr2[1000][1000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> arr[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> arr2[i][j];
if (arr[i][j] > arr2[i][j]) {
swap(arr[i][j], arr2[i][j]);
}
if (arr[i][j - 1] >= arr[i][j] | arr[i][j] <= arr[i - 1][j]) {
cout << "Impossible" << endl;
return 0;
}
if (arr2[i][j - 1] >= arr2[i][j] | arr2[i][j] <= arr2[i - 1][j]) {
cout << "Impossible" << endl;
return 0;
}
}
cout << "Possible" << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
template<class T>
ostream& operator<<(ostream& os,vector<T> const& v){for(auto itr=v.begin();itr!=v.end();++itr){if(itr!=v.begin())os<<' ';os<<*itr;}return os;}
signed main(){
int n;
cin>>n;
vector<int> a(n);
for(auto& ai:a)cin>>ai;
int q;
cin>>q;
while(q--){
int k;
cin>>k;
cout<< lower_bound(a.begin(),a.end(),k)-a.begin() <<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long f[n + 1], last[n + 1], a[n + 1], ans[n + 1];
for (int i = 1; i <= n; i++) {
f[i] = last[i] = 0;
ans[i] = -1;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
int x = a[i];
f[x] = max(f[x], i - last[x]);
last[x] = i;
}
for (int x = 1; x <= n; ++x) {
f[x] = max(f[x], n - last[x] + 1);
for (int i = f[x]; i <= n && ans[i] == -1; ++i) {
ans[i] = x;
}
}
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
}
struct Ques {
int l, r;
} q[500000 + 1];
int a[500000 + 1], b[500000 + 1], d[500000 + 1], h[500000 + 1];
int n, m, k, s, cnt = 0, tot = 0, sq;
bool Cmp(Ques a, Ques b) {
return ((a.l + 1) / sq) < ((b.l + 1) / sq) ||
(((a.l + 1) / sq) == ((b.l + 1) / sq) &&
((((a.l + 1) / sq) & 1) ? a.r < b.r : a.r > b.r));
}
void Add(int u) {
if (++h[a[u]] == d[a[u]]) --cnt;
}
void Del(int u) {
if (h[a[u]] == d[a[u]]) ++cnt;
--h[a[u]];
}
int main() {
read(m), read(k), read(n), read(s);
for (int i = 1; i <= m; i++) read(a[i]);
for (int i = 1; i <= s; i++) read(b[i]);
for (int i = 1; i <= s; i++)
if (++d[b[i]] == 1) ++cnt;
for (int i = 1; i <= m - k + 1; i++)
if (m - n * k - (i - 1) % k >= 0)
q[++tot] = (Ques){i, i + k - 1 + m - n * k - (i - 1) % k};
sq = sqrt(tot);
sort(q + 1, q + 1 + tot, Cmp);
for (int l = 1, r = 0, i = 1; i <= tot; i++) {
while (r < q[i].r) Add(++r);
while (l > q[i].l) Add(--l);
while (r > q[i].r) Del(r--);
while (l < q[i].l) Del(l++);
if (!cnt) {
printf("%d\n", m - n * k);
for (int j = 1; j <= (q[i].l - 1) % k; j++) printf("%d ", j);
int sum = 0;
for (int j = q[i].l; j <= q[i].r; j++)
if (h[a[j]] > d[a[j]] && ++sum <= m - n * k - (q[i].l - 1) % k)
printf("%d ", j), --h[a[j]];
return 0;
}
}
puts("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
inline long long FIX(long long a) { return (a % Mod + Mod) % Mod; }
long long dp[100 + 5];
int main() {
int n;
long long k;
cin >> n >> k;
dp[n + 1] = 1;
for (int i = n; i >= 1; i--) {
dp[i] = dp[i + 1] + dp[i + 2];
}
long long tmp = k;
int cur = 1;
while (cur <= n) {
if (dp[cur + 1] >= tmp) {
printf("%d ", cur);
cur++;
} else {
printf("%d %d ", cur + 1, cur);
tmp -= dp[cur + 1];
cur += 2;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int r1, c1, r2, c2;
int G[12][21];
int x[][2] = {{-1, -1}, {-1, +1}, {+1, -1}, {+1, +1}};
int main() {
for (int h = 1; h < 9; h++)
for (int j = 1; j < 9; j++) G[h][j] = 12;
scanf("%d %d %d %d", &r1, &c1, &r2, &c2);
if (r1 == r2 && c1 == c2) {
printf("0 0 0");
return 0;
} else if (r1 == r2)
printf("1");
else if (c1 == c2)
printf("1");
else
printf("2");
printf(" ");
if ((r1 % 2 + c1) % 2 != (r2 % 2 + c2) % 2)
printf("0 ");
else {
G[r1][c1] = 0;
for (int h = 0; h < 3; h++)
for (int i = 1; i < 9; i++)
for (int j = 1; j < 9; j++)
for (int tmp = 0; tmp < 4; tmp++) {
int a = i, b = j;
while (a < 9 && a > 0 && b < 9 && b > 0) {
G[a][b] = (G[a][b] < G[i][j] + 1 ? G[a][b] : G[i][j] + 1);
a += x[tmp][0];
b += x[tmp][1];
}
}
printf("%d ", G[r2][c2]);
}
printf("%d", abs(r1 - r2) + abs(c1 - c2) -
(abs(c1 - c2) < abs(r1 - r2) ? abs(c1 - c2) : abs(r1 - r2)));
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1677777216")
using namespace std;
struct point {
int x, y;
};
bool comp(point a, point b) { return a.x < b.x; }
int main() {
string s, t;
cin >> s >> t;
int n = s.size() - 1;
for (int i = n; i >= 0; i--) {
if (s[i] != 'z') {
s[i]++;
break;
} else {
s[i] = 'a';
}
}
if (s == t) {
cout << "No such string";
} else
cout << s;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int dp[3001]={0};
int a,b;
int main(){
int n,t,s,ans=0;
cin>>n>>t>>s;
for(int i=0;i<n;++i){
cin>>a>>b;
for(int j=t;j>=b;--j)
if(j<=s||j-b>=s) dp[j]=max(dp[j],dp[j-b]+a);
}
for(int i=0;i<=t;++i) ans=max(ans,dp[i]);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const double EPS = 1e-11;
const double PI = acos(-1.);
struct intersection {
double angle;
int flag;
};
bool comp(const intersection &x, const intersection &y) {
if (x.angle != y.angle) {
return x.angle < y.angle;
}
return x.flag > y.flag;
}
struct point {
double x, y;
};
intersection p[MAXN * 6];
point q[MAXN];
int len, n;
double f[MAXN][MAXN], w, h;
void add1(double l, double r, int flag) {
++len;
p[len].angle = l, p[len].flag = flag;
++len;
p[len].angle = r + EPS, p[len].flag = -flag;
}
void add(double x, double y, int flag) {
if (x < -PI) {
add1(x + 2 * PI, PI, flag);
x = -PI;
}
if (y > PI) {
add1(-PI, y - 2 * PI, flag);
y = PI;
}
add1(x, y, flag);
}
bool check(int a, long double r) {
len = 0;
for (int i = 0; i < n; ++i) {
if (i == a) continue;
double l = sqrt((q[i].x - q[a].x) * (q[i].x - q[a].x) +
(q[i].y - q[a].y) * (q[i].y - q[a].y));
if (l < 2 * r && fabs(l) > EPS) {
add(f[a][i] - acos(l / 2 / r), f[a][i] + acos(l / 2 / r), 1);
}
}
double v;
if (q[a].y < r) {
v = acos(q[a].y / r);
add(-PI / 2. - v, -PI / 2. + v, 2);
}
if (q[a].y + r > h) {
v = acos((h - q[a].y) / r);
add(PI / 2. - v, PI / 2. + v, 2);
}
if (q[a].x < r) {
v = acos(q[a].x / r);
add(-PI - v, -PI + v, 2);
}
if (q[a].x + r > w) {
v = acos((w - q[a].x) / r);
add(0 - v, 0 + v, 2);
}
sort(p + 1, p + len + 1, comp);
p[0].angle = -PI, p[0].flag = 0;
p[++len].angle = PI, p[len].flag = 0;
int sum = 0;
sum += p[0].flag;
for (int i = 1; i <= len; ++i) {
if (sum <= 1 && (p[i].angle - p[i - 1].angle >= EPS)) {
return true;
}
sum += p[i].flag;
}
return false;
}
double d[MAXN];
double get(double x, double y) {
for (int i = 0; i < n; ++i) {
d[i] = sqrt((x - q[i].x) * (x - q[i].x) + (y - q[i].y) * (y - q[i].y));
}
sort(d, d + n);
return d[1];
}
int MAIN() {
cin >> w >> h >> n;
for (int i = 0; i < n; ++i) {
cin >> q[i].x >> q[i].y;
}
random_shuffle(q, q + n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
f[i][j] = atan2(q[j].y - q[i].y, q[j].x - q[i].x);
}
}
double ans = 0;
ans = max(ans, get(0, 0));
ans = max(ans, get(w, 0));
ans = max(ans, get(0, h));
ans = max(ans, get(w, h));
for (int i = 0; i < n; ++i) {
if (check(i, ans + 1e-9)) {
double l = ans, r = sqrt(w * w + h * h);
for (int j = 0; j < 50; ++j) {
double mid = (l + r) / 2.;
if (check(i, mid)) {
l = mid;
} else {
r = mid;
}
}
ans = (l + r) / 2.;
}
}
cout << ans << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(18);
return MAIN();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
vector<int> ans;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
mp[t] = t;
}
int cur = 1;
while (k > 0) {
if (mp.find(cur) == mp.end()) {
if (k >= cur) {
k -= cur;
ans.push_back(cur);
} else
k = 0;
}
cur++;
}
int num = ans.size();
printf("%d\n", num);
for (int i = 0; i < num; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
int sieve[1000006];
int main() {
int i, j;
long long ans, n;
sieve[0] = 1;
sieve[1] = 1;
for (i = 2; i < 1000006; i++) {
if (sieve[i] == 0) {
for (j = 2 * i; j < 1000006; j += i) {
sieve[j] = 1;
}
}
}
ans = 1;
scanf("%I64d", &n);
for (i = 0; i < 1000006; i++) {
if (sieve[i] == 0) {
while (n % ((long long)i * (long long)i) == 0) n /= i;
}
}
printf("%I64d\n", n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long int maxn = 52, md = 1e9 + 7;
long long int inf;
long long int gcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long int tav(long long int n, long long int k) {
long long int res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
res %= md;
}
n *= n;
n %= md;
k >>= 1;
}
return res;
}
long long int a[maxn], b[maxn], c[maxn], dp[maxn][maxn];
bitset<27> sl[maxn][maxn], hl[maxn][maxn];
string s, h;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, 63, sizeof(dp));
inf = dp[0][0];
long long int n, m, q;
cin >> s >> h >> q;
n = (long long int)(s.size());
m = (long long int)(h.size());
for (long long int i = 0; i < q; i++) {
string inp;
cin >> inp;
a[i] = inp[0] - 'a';
b[i] = inp[3] - 'a';
c[i] = inp[4] - 'a';
}
for (long long int i = 0; i < n; i++) {
sl[i][i][s[i] - 'a'] = true;
}
for (long long int l = 1; l < n; l++) {
for (long long int i = 0; i < n - l; i++) {
for (long long int k = i; k < i + l; k++) {
for (long long int e = 0; e < q; e++) {
if (sl[i][k][b[e]] & sl[k + 1][i + l][c[e]]) {
sl[i][i + l][a[e]] = true;
}
}
}
}
}
for (long long int i = 0; i < m; i++) {
hl[i][i][h[i] - 'a'] = true;
}
for (long long int l = 1; l < m; l++) {
for (long long int i = 0; i < m - l; i++) {
for (long long int k = i; k < i + l; k++) {
for (long long int e = 0; e < q; e++) {
if (hl[i][k][b[e]] & hl[k + 1][i + l][c[e]]) {
hl[i][i + l][a[e]] = true;
}
}
}
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
bitset<27> tmp = sl[0][i] & hl[0][j];
if (tmp.any()) {
dp[i][j] = 1;
continue;
}
for (long long int k = 1; k <= i; k++) {
for (long long int e = 1; e <= j; e++) {
tmp = sl[k][i] & hl[e][j];
if (tmp.any()) {
dp[i][j] = min(dp[i][j], dp[k - 1][e - 1] + 1);
}
}
}
}
}
cout << (dp[n - 1][m - 1] == inf ? -1 : dp[n - 1][m - 1]) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, x, count, ans = -1;
cin >> n >> m;
for (i = n; i <= m; i++) {
x = i;
count = 0;
set<int> st;
while (x > 0) {
st.insert(x % 10);
x = x / 10;
count++;
}
x = st.size();
if (count == x) {
ans = i;
break;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, k;
cin >> n >> m;
int arr[n], brr[m];
for (i = 0; i < n; i++) arr[i] = i + 1;
for (i = 0; i < m; i++) brr[i] = i + 1;
cout << m + (n - 1) << endl;
for (i = 0; i < m; i++) cout << arr[0] << " " << brr[i] << endl;
for (i = 1; i < n; i++) cout << arr[i] << " " << brr[0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, q, ans[20], vis[20], zk[20];
long long dp[1 << 16], m;
int cal(int x) {
int res = 0;
while (x) {
if (x & 1) res++;
x >>= 1;
}
return res;
}
int main() {
int u, v;
scanf("%d%lld%d", &n, &m, &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &u, &v);
zk[v] |= (1 << u - 1);
}
m -= 2000;
for (int i = 1; i <= n; i++) {
for (ans[i] = 1;; ans[i]++) {
if (vis[ans[i]]) continue;
if (ans[i] > n) {
printf("The times have changed\n");
return 0;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int s = 0; s < (1 << n); s++) {
int tmp = cal(s);
for (int j = 1; j <= n; j++) {
if ((s & (1 << j - 1)) || ((s & zk[j]) != zk[j])) continue;
if (ans[j] == 0 || ans[j] == tmp + 1) dp[s | (1 << j - 1)] += dp[s];
}
}
if (m > dp[(1 << n) - 1])
m -= dp[(1 << n) - 1];
else {
vis[ans[i]] = 1;
break;
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<string> u(h);
vector<string> v(h - 1);
for (int i = 0; i < h; ++i) {
cin >> u[i];
if (i != h - 1) {
cin >> v[i];
}
}
if (k == 1) {
int cnt = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w - 1; ++j) {
cnt += (u[i][j] == 'E');
}
if (i != h - 1) {
for (int j = 0; j < w; ++j) {
cnt += (v[i][j] == 'E');
}
}
}
if (cnt * 4 >= (w * (h - 1) + (w - 1) * h) * 3) {
cout << "YES" << endl;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cout << "1 ";
}
cout << endl;
}
} else {
cout << "NO" << endl;
}
return 0;
}
vector<vector<int>> a(h, vector<int>(w));
if (w >= h) {
for (int i = 0; i < h; ++i) {
a[i][0] = 0;
for (int j = 0; j < w - 1; ++j) {
a[i][j + 1] = a[i][j] ^ (u[i][j] == 'N');
}
}
for (int i = 0; i < h - 1; ++i) {
int cnt = 0;
for (int j = 0; j < w; ++j) {
cnt += (a[i][j] ^ (v[i][j] == 'N')) == a[i + 1][j];
}
if (2 * cnt < w) {
for (int j = 0; j < w; ++j) {
a[i + 1][j] ^= 1;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cout << a[i][j] + 1 << " ";
}
cout << endl;
}
} else {
for (int j = 0; j < w; ++j) {
a[0][j] = 0;
for (int i = 0; i < h - 1; ++i) {
a[i + 1][j] = a[i][j] ^ (v[i][j] == 'N');
}
}
for (int j = 0; j < w - 1; ++j) {
int cnt = 0;
for (int i = 0; i < h; ++i) {
cnt += (a[i][j] ^ (u[i][j] == 'N')) == a[i][j + 1];
}
if (2 * cnt < h) {
for (int i = 0; i < h; ++i) {
a[i][j + 1] ^= 1;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cout << a[i][j] + 1 << " ";
}
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long rr[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long cc[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long mod = 1e9 + 7;
const long long N = 300050;
long long n, m;
vector<vector<long long> > a;
void update_even_rows(long long x) {
for (long long i = 0; i < n; i++) {
if (i % 2) continue;
vector<long long> temp;
for (long long j = 0; j < m; j++) {
temp.push_back(a[i][j]);
}
for (long long j = 0; j < m; j++) {
a[i][j] = temp[(j - x + m) % m];
}
}
}
void update_even_cols(long long x) {
for (long long i = 0; i < m; i++) {
if (i % 2) continue;
vector<long long> temp;
for (long long j = 0; j < n; j++) {
temp.push_back(a[j][i]);
}
for (long long j = 0; j < n; j++) {
a[j][i] = temp[(j - x + n) % n];
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long test = 1;
while (test--) {
cin >> n >> m;
a = vector<vector<long long> >(n, vector<long long>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
a[i][j] = i * m + j;
}
}
if (min(n, m) == 1) {
if (max(n, m) > 3) {
cout << "YES\n";
for (long long i = 2; i <= n * m; i += 2) {
cout << i << (n == 1 ? ' ' : '\n');
}
for (long long i = 1; i <= n * m; i += 2) {
cout << i << (n == 1 ? ' ' : '\n');
}
} else if (max(n, m) == 1) {
cout << "YES\n1\n";
} else
cout << "NO\n";
return 0;
} else if (min(n, m) == 2) {
if (max(n, m) > 3) {
if (n == 2) {
update_even_cols(1);
update_even_rows(2);
} else {
update_even_rows(1);
update_even_cols(2);
}
} else {
return cout << "NO\n", 0;
}
} else if (min(n, m) >= 3) {
if (n == 3 && m == 3) {
cout << "YES\n1 9 5\n6 2 7 \n8 4 3\n";
return 0;
} else {
if (m >= 4) {
update_even_cols(1);
update_even_rows(2);
} else {
update_even_cols(2);
update_even_rows(1);
}
}
}
cout << "YES\n";
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << a[i][j] + 1 << ' ';
}
cout << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 1e18 + 1LL;
const int inf = 1e9 + 1e8;
const double PI = acos(-1.0);
const int N = 1e5 + 100;
int tree[N * 100][2], data[N * 100][2];
int a[N * 3], p[N * 3], n, tot = 1, root = 1;
void Insert(int x) {
int now = root, num[31];
for (int i = 30; i >= 0; --i) {
num[i] = x & 1;
x >>= 1;
}
for (int i = 0; i <= 30; ++i) {
int t = num[i];
if (tree[now][t])
data[now][t]++;
else {
tree[now][t] = ++tot;
data[now][t] = 1;
}
now = tree[now][t];
}
}
void del(int x) {
int now = root, num[31];
for (int i = 30; i >= 0; --i) {
num[i] = x & 1;
x >>= 1;
}
for (int i = 0; i <= 30; ++i) {
int t = num[i];
data[now][t]--;
now = tree[now][t];
if (!data[now][t]) tree[now][t] = 0;
}
}
int finds(int x) {
int now = root, r = 1, ret = 0;
int num[31];
for (int i = 30; i >= 0; --i) {
num[i] = x & 1;
x >>= 1;
}
for (int i = 0; i <= 30; ++i) {
int t = num[i];
if (data[now][t]) {
ret *= 2;
ret += t;
now = tree[now][t];
} else {
ret *= 2;
ret += t ^ 1;
now = tree[now][t ^ 1];
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i]);
Insert(p[i]);
}
for (int i = 1; i <= n; ++i) {
int x = finds(a[i]);
del(x);
printf("%d ", x ^ a[i]);
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main(){
while(1){
int w,h,mp[20][20]={},dp[20][20] ={};
cin >> w >> h;
if(w==0 && h==0) break;
for(int i=0;i<h;i++)
for(int j=0;j<w;j++) cin >> mp[i][j];
int ans=0;
for(int i=0;i<w;i++) {
if(mp[0][i]==0) dp[0][i] = 1;
if(0 >=h-1)ans+=dp[0][i];
}
for(int i=0;i<h-1;i++)
for(int j=0;j<w;j++)
for(int k=-1;k<=1;k++){
int nx=j+k,ny=i+1;
if(nx<0||nx>=w || mp[i][j] !=0) continue;
while(k==0&&mp[ny][nx]==2) ny+=2;
if(mp[ny][nx]!=0) continue;
dp[ny][nx]+= dp[i][j];
if(ny >= h-1) ans+=dp[i][j];
}
cout << ans <<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main (){
int x, y;
long long ans = 0;
const long long m = 100000;
cin>>x>>y;
if(x <= 3 ) ans+= (4-x)*m;
if(y <= 3 ) ans+= (4-y)*m;
if((x == 1) && (y == 1)) ans+=4*m;
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define REP(i, n) FOR(i,0,n)
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> bool mmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool mmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
vector<lint> A;
vector<set<int>> e;
constexpr lint INF = 1e14;
vector<vector<lint>> dfs(int now, int prv)
{
vector<vector<lint>> ret(1, vector<lint>(2));
ret[0][0] = (A[now] > 0 ? A[now] : INF);
ret[0][1] = (A[now] < 0 ? A[now] : INF);
for (auto nxt : e[now]) if (nxt != prv)
{
auto tmp = dfs(nxt, now);
vector<vector<lint>> retnew(ret.size() + tmp.size(), vector<lint>(2, INF));
REP(i, ret.size()) REP(j, tmp.size())
{
REP(d, 2) REP(e, 2) mmin(retnew[i + j][d | e], ret[i][d] + tmp[j][e]);
REP(d, 2)
{
if (tmp[j][0] < INF) mmin(retnew[i + j + 1][d], ret[i][d]);
if (tmp[j][1] < 0) mmin(retnew[i + j + 1][d], ret[i][d]);
}
}
ret = retnew;
}
return ret;
}
int main()
{
int N;
cin >> N;
A.resize(N);
cin >> A;
e.resize(N);
REP(_, N - 1)
{
int u, v;
cin >> u >> v;
u--, v--;
e[u].insert(v);
e[v].insert(u);
}
auto ret = dfs(0, -1);
REP(i, N)
{
if (ret[i][0] < INF or ret[i][1] < 0)
{
cout << i << endl;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define mp(a,b) make_pair(a,b)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P, int> PPI;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
#define INF INT_MAX/3
#define MAX_N 1000
int n,u,v,m;
int uc[555],ur[555],nc[555],nr[555],ucros[2],ncros[2];
map<int,P> usa,neko;
int card[100010];
int main(){
scanf("%d%d%d%d",&n,&u,&v,&m);
rep(i,n)rep(j,n){
int a;
scanf("%d",&a);
usa[a]=P(i,j);
}
rep(i,n)rep(j,n){
int a;
scanf("%d",&a);
neko[a]=P(i,j);
}
rep(i,m)scanf("%d",card+i);
int ucnt=0,ncnt=0;
rep(i,m){
int a=card[i];
if(usa.count(a)){
uc[usa[a].fi]++;
if(uc[usa[a].fi]==n)ucnt++;
ur[usa[a].se]++;
if(ur[usa[a].se]==n)ucnt++;
if(usa[a].fi==usa[a].se){
ucros[0]++;
if(ucros[0]==n)ucnt++;
}
if(usa[a].fi+usa[a].se==n-1){
ucros[1]++;
if(ucros[1]==n)ucnt++;
}
}
if(neko.count(a)){
nc[neko[a].fi]++;
if(nc[neko[a].fi]==n)ncnt++;
nr[neko[a].se]++;
if(nr[neko[a].se]==n)ncnt++;
if(neko[a].fi==neko[a].se){
ncros[0]++;
if(ncros[0]==n)ncnt++;
}
if(neko[a].fi+neko[a].se==n-1){
ncros[1]++;
if(ncros[1]==n)ncnt++;
}
}
//dbg(ucnt); dbg(ncnt);
if(n==1){
minch(ucnt,1);
minch(ncnt,1);
}
if(ucnt>=u&&ncnt>=v){
printf("DRAW\n"); return 0;
}else if(ucnt>=u){
printf("USAGI\n"); return 0;
}else if(ncnt>=v){
printf("NEKO\n"); return 0;
}
}
printf("DRAW\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m;
int where[N], arr[N];
int dp[N][N];
int who[N][N];
void build() {
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++) {
int mini = arr[i];
for (int j = i; j <= n; j++) {
mini = min(mini, arr[j]);
who[i][j] = mini;
}
}
}
int solve(int l, int r) {
if (l > r) return 1;
if (dp[l][r] != -1) return dp[l][r];
int ansA = 0, ansB = 0, split = where[who[l][r]];
for (int i = l; i <= split; i++)
ansA = (ansA + 1LL * solve(l, i - 1) * solve(i, split - 1) % 998244353) %
998244353;
for (int j = split; j <= r; j++)
ansB = (ansB + 1LL * solve(split + 1, j) % 998244353 * solve(j + 1, r) %
998244353) %
998244353;
return dp[l][r] = 1LL * ansA * ansB % 998244353;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
arr[i] = x;
where[x] = i;
}
build();
printf("%d", solve(1, n));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
string s;
scanf("%d", &n);
cin >> s;
int maxval[26], ans[n];
for (i = 0; i < n; ++i) ans[i] = 1;
for (i = 0; i < 26; ++i) maxval[i] = 0;
for (i = 0; i < n; ++i) {
for (j = 25; j > s[i] - 'a'; j--) ans[i] = max(ans[i], maxval[j] + 1);
maxval[s[i] - 'a'] = max(maxval[s[i] - 'a'], ans[i]);
}
printf("%d\n", *max_element(maxval, maxval + 26));
for (i = 0; i < n; ++i) printf("%d ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int LIM = 3e5 + 10;
vector<vector<long long int> > adj(LIM);
vector<vector<long long int> > child(LIM);
vector<long long int> level(LIM, -1);
vector<long long int> parent(LIM, -1);
void dfs(int n, vector<long long int>& visited) {
for (int i = 0; i < adj[n].size(); i++) {
if (visited[adj[n][i]] == -1) {
visited[adj[n][i]] = 1;
child[n].push_back(adj[n][i]);
level[adj[n][i]] = level[n] + 1;
parent[adj[n][i]] = n;
dfs(adj[n][i], visited);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<long long int> visited(n + 1, -1);
visited[1] = 1;
level[1] = 0;
parent[1] = 1;
dfs(1, visited);
int counter = 0;
for (int i = 1; i <= n; i++) counter += (child[i].size() == 0);
int path = n / k;
if (n % k != 0) path++;
bool ans = false;
for (int i = 1; i <= n; i++) {
if (level[i] >= path) {
ans = true;
cout << "PATH" << endl;
cout << level[i] + 1 << endl;
int curr = i;
while (curr != 1) {
cout << curr << " ";
curr = parent[curr];
}
cout << 1 << endl;
break;
}
}
if (ans == false) {
cout << "CYCLES" << endl;
int count = 0;
for (int i = 1; i <= n; i++) {
if (child[i].size() == 0) {
count++;
bool b = false;
vector<long long int> temp;
for (int j = 0; j < adj[i].size(); j++) {
if (adj[i][j] == parent[i]) continue;
temp.push_back(adj[i][j]);
int height = level[adj[i][j]];
if (((level[i] - level[adj[i][j]] + 1) % 3) != 0) {
b = true;
int curr = i;
cout << level[i] - height + 1 << endl;
while (curr != adj[i][j]) {
cout << curr << " ";
curr = parent[curr];
}
cout << adj[i][j] << endl;
break;
}
}
if (b == false) {
int d = -1, e = -2;
for (int j = 0; j < temp.size(); j++) {
if (((level[i] - level[temp[j]] + 1) % 3) == 0) {
if (d == -1)
d = temp[j];
else
e = temp[j];
if (e != -2) break;
}
}
if (level[d] < level[e]) swap(d, e);
cout << level[d] - level[e] + 2 << endl;
cout << i << " ";
int curr = d;
while (curr != e) {
cout << curr << " ";
curr = parent[curr];
}
cout << e << endl;
}
if (count == k) break;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
long long sum = 0, total = 0;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n / 2; i++) {
sum = a[i] + a[n - 1 - i];
sum = sum * sum;
total += sum;
}
cout << total << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int Mod = (int)1e9 + 7;
const int MX = 1073741822;
const long long MXLL = 9223372036854775807;
const int Sz = 1e5 + 1;
using namespace std;
inline void Read_rap() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline void randomizer3000() {
unsigned int seed;
asm("rdtsc" : "=A"(seed));
srand(seed);
}
unordered_map<string, int> t[10];
int n;
string s[Sz];
string ans[Sz];
inline void add(string &s, int pos) {
for (int i = 0; i < (int)(s.size()); i++) {
string ss = "";
for (int j = i; j < (int)(s.size()); j++) {
ss.push_back(s[j]);
int &x = t[j - i + 1][ss];
if (!x)
x = pos;
else if (x != pos)
x = -1;
}
}
}
int main() {
Read_rap();
for (int i = 1; i < 10; i++) {
t[i].reserve(1024);
t[i].max_load_factor(0.25);
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
add(s[i], i);
}
for (int i = 1; i <= 9; i++) {
for (auto x : t[i]) {
if (x.second != -1 && !(int)(ans[x.second].size()))
ans[x.second] = x.first;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const long long INF = 1e+9;
const long long MAXN = 200000;
const long long LOGN = 20;
const long long mod = 1e9 + 7;
long long dp[MAXN];
long long s[MAXN];
vector<vector<long long>> g;
long long n, ans = 0;
void dfs1(long long v, long long p) {
s[v] = 1;
for (long long u : g[v]) {
if (u != p) {
dfs1(u, v);
s[v] += s[u];
dp[v] += dp[u];
}
}
dp[v] += s[v];
}
void dfs2(long long v, long long p) {
ans = max(ans, dp[v]);
for (long long u : g[v]) {
if (u != p) {
long long dv = dp[v];
dp[v] -= dp[u] + s[u];
dp[u] -= s[u];
s[v] = n - s[u];
s[u] = n;
dp[u] += dp[v] + s[u];
dfs2(u, v);
s[v] = n;
dp[v] = dv;
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
g.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(0, -1);
dfs2(0, -1);
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int c, vd, va;
bool t, dik;
int main() {
t = true;
dik = true;
scanf("%d %d", &vd, &va);
c = 1;
while (t) {
if (dik) {
if (vd >= c) {
vd -= c;
c++;
dik = false;
} else {
t = false;
printf("Vladik");
}
} else {
if (va >= c) {
va -= c;
c++;
dik = true;
} else {
t = false;
printf("Valera");
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000 * 100 + 10;
const int MAXL = 26;
int par[30][MAX], h[MAX];
int cnt[MAX], ans[MAX];
vector<pair<int, int> > adj[MAX];
int LCA(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = MAXL; i >= 0; i--)
if (par[i][u] != 0 && h[par[i][u]] >= h[v]) u = par[i][u];
if (u == v) return u;
for (int i = MAXL; i >= 0; i--)
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
return par[0][u];
}
void DFS(int v) {
for (int i = 0; i < (int)adj[v].size(); i++)
if (adj[v][i].first != par[0][v]) {
h[adj[v][i].first] = h[v] + 1;
par[0][adj[v][i].first] = v;
DFS(adj[v][i].first);
}
}
int solve(int v) {
int count = 0;
for (int i = 0; i < (int)adj[v].size(); i++)
if (adj[v][i].first != par[0][v]) count += solve(adj[v][i].first);
count += cnt[v];
for (int i = 0; i < (int)adj[v].size(); i++)
if (adj[v][i].first == par[0][v]) ans[adj[v][i].second] = count;
return count;
}
int main() {
ios::sync_with_stdio(false);
int n, a, b;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
adj[a].push_back(make_pair(b, i));
adj[b].push_back(make_pair(a, i));
}
DFS(1);
for (int i = 1; i <= MAXL; i++)
for (int j = 1; j <= n; j++) par[i][j] = par[i - 1][par[i - 1][j]];
int m, x, y;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
cnt[x]++;
cnt[y]++;
int z = LCA(x, y);
cnt[z] -= 2;
}
solve(1);
for (int i = 0; i < n - 1; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std ;
#define pb(n) push_back(n)
#define fi first
#define se second
#define all(r) begin(r),end(r)
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)
#define vvl(v,w,h,init) vector<vector<ll>> v(w,vector<ll>(h,init))
#define mp(a,b) make_pair(a,b)
#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))
using ll = long long;
using pii = pair<int,int> ;
using pll = pair<ll,ll> ;
const double EPS = 1e-8;
const double INF = 1e12;
double add(double a, double b) {
if (abs(a + b) < EPS * (abs(a) + abs(b))) return 0;
return a + b;
}
inline int sgn(double a, double b = 0) { return a < b - EPS ? -1 : a > b + EPS ? 1 : 0; }
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
#define diff(P, i) (next(P, i) - curr(P, i))
typedef complex<double> P;//????´???°????????¢?????????????????¨?§£???
P inputP(){
double x,y;
cin >> x >> y;
return P(x,y);
}
namespace std {
bool operator < (const P& a, const P& b) {//x????????????
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
bool sorty(const P& a, const P& b) {//y????????????
return imag(a) != imag(b) ? imag(a) < imag(b) : real(a) < real(b);
}
bool same(const P& a, const P& b) {
P p = a - b;
if(abs(real(p)) < EPS && abs(imag(p)) < EPS){
return true;
}
return false;
}
}
double cross(const P& a, const P& b) {//??????
return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {//??????
return real(conj(a)*b);
}
int ccw(P a, P b, P c) {//3????????????????????§????????§??????????????????
b -= a; c -= a;
if (cross(b, c) > 0) return +1; // counter clockwise
if (cross(b, c) < 0) return -1; // clockwise
if (dot(b, c) < 0) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line
return 0; // a--c--b on line
}
class L{// line
public:
vector<P> l;
P v;
L(){};
L(const P &a, const P &b) {
l.push_back(a); l.push_back(b);
v = (b-a);
}
L(double a,double b,double c,double d){
l.push_back(P(a,b)),l.push_back(P(c,d));
}
P& operator[](const int i){
return l[i];
}
void input() {
double a, b,c,d;
cin >> a >> b >> c >> d;
l.clear();
l.push_back(P(a,b)),l.push_back(P(c,d));
}
};
class G {
public:
vector<P> g;
vector<L> l;
ll n;
G(){};
G(int _n):n(_n){
double x,y;
l.resize(n),g.resize(n);
rep(i,n){
cin >> x >> y;
g[i] = (P(x,y));
}
rep(i,n){
l[i] = L(g[i],g[(i+1)%n]);
}
}
G (vector<P> ps){
n = ps.size();
g.resize(n),l.resize(n);
rep(i,n){
g[i] = ps[i];
}
rep(i,n){
l[i] = L(g[i],g[(i+1)%n]);
}
}
P& operator[](int i){
return g[i];
}
void push_back(P p){
g.push_back(p);
}
size_t size(){
return g.size();
}
void resize(int n){
g.resize(n),l.resize(n);
}
friend ostream& operator<<(ostream& os,const G& g){
rep(i,g.n){
if(i) os << ' ';
os << g.g[i] ;
}
return os;
}
};
int linejudge(L &ab,L &cd){ //2??´???????????¢???
P a = ab[1] - ab[0],b = cd[1] - cd[0];
if(abs(cross(a,b)) < EPS){ // Parallel
return 2;
}
else if(abs(dot(a,b)) < EPS){ //Orthogonal
return 1;
}
return 0;
}
// L:line,S:segment,P:point
bool intersectLL( L &l, L &m) {
return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
abs(cross(l[1]-l[0], m[0]-l[0])) < EPS; // same line
}
bool intersectLS( L &l, L &s) {
return cross(l[1]-l[0], s[0]-l[0])* // s[0] is left of l
cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP( L &l, P &p) {
return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS( L s, L t) {
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP( L &s, P &p) {
return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
bool intersectSG(L l, G g) {
int n = g.size();
rep(i, n) {
if (intersectSS(l, L(curr(g, i), next(g, i)))) {
return true;
}
}
return false;
}
// L & P intersection
P projection(L &l, P &p) {
double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
return l[0] + t*(l[0]-l[1]);
}
// L????????????P???????°????
P reflection(L &l, P &p) {
return p + 2.0 * (projection(l, p) - p);
}
double distanceLP(L &l, P &p) {
return abs(p - projection(l, p));
}
double distanceLL(L &l, L &m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(L &l, L &s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(L &s, P &p) {
P r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(L s, L t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])), min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
double distancePP(P &p, P &q){
return abs(p - q) ;
}
double distanceSG(L l, G g) {
double d = INF;
rep(i, g.size()) {
d = min(d, distanceSS(l, L(curr(g, i), next(g, i))));
}
return d;
}
bool in(double a,double b,double c){
return a <= b && b <= c;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
while(cin >> n,n){
L l;
l.input();
vector<G> rs(n);
vector<ll> h(n);
bool f = true;
rep(i,n){
double a,b,c,d;
cin >> a >> b >> c >> d >> h[i];
rs[i].push_back(P(a,b));
rs[i].push_back(P(c,b));
rs[i].push_back(P(c,d));
rs[i].push_back(P(a,d));
if(in(a,real(l[0]),c) && in(b,imag(l[0]),d) && in(a,real(l[1]),c)&& in(b,imag(l[1]),d) ){
f = false;
}
}
if(!f){
cout << 0 << endl;
continue;
}
auto check = [&](double r){
rep(i,n){
rep(j,4){
double d = distanceSG(l,rs[i]);
if(d < r && r < h[i]) return true;
else if(h[i] > r - sqrt(r * r - d * d)) return true;
}
}
return false;
};
double lb = 0,ub = 1001;
rep(i,100){
double r = (lb+ub)/2;
bool f = check(r);
if(f){
ub = r;
}
else{
lb = r;
}
}
fcout(10) << lb << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200030;
const int inf = 0x3f3f3f3f;
long long Begin, End, k, n;
long long num[maxn];
long long w = 1e18;
long long pos;
int main() {
scanf("%lld %lld %lld", &Begin, &End, &k);
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &num[i]);
}
sort(num + 1, num + 1 + n);
if (num[1] > Begin) {
printf("%lld\n", Begin);
return 0;
}
long long wait;
for (long long i = 1; i <= n; i++) {
if (num[i] < Begin) {
wait = Begin - (num[i] - 1) + (i - 1) * k;
} else {
if (num[i] - 1 < Begin + (i - 1) * k) {
wait = Begin + (i - 1) * k - num[i] + 1;
} else {
wait = 0;
}
}
if (wait < w) {
w = wait;
pos = num[i] - 1;
}
long long endd = max((int)(Begin + i * k), (int)(num[i] + k));
if (endd >= End) break;
}
long long las = max(Begin + n * k, num[n] + k);
if (wait != 0) {
for (long long i = las; i < End; i++) {
if (End - i >= k && wait != 0) {
wait = 0;
pos = i;
break;
}
}
}
printf("%lld\n", pos);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n, m;
int res, id[maxN + 1], ans[maxN + 1];
set<int> s[maxN + 1];
inline void add(int u, int x) {
set<int>::iterator it1 = s[u].insert(x).first, it2;
res -= ans[u];
ans[u]++;
if (it1 != s[u].begin()) {
it2 = it1;
it2--;
ans[u] -= ((*it1) == (*it2) + 1);
}
it2 = it1;
it2++;
if (it2 != s[u].end()) ans[u] -= ((*it2) == (*it1) + 1);
res += ans[u];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) id[i] = i;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
add(x, i);
}
printf("%d\n", res - 1);
for (int i = 1; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
int u = id[x], v = id[y];
if (s[u].size() < s[v].size()) swap(u, v);
id[x] = u;
res -= ans[v];
for (set<int>::iterator it = s[v].begin(); it != s[v].end(); it++)
add(u, (*it));
s[v].clear();
printf("%d\n", res - 1);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int a[20005],ans,bn,b[10000],n,k,q,cn,c[10000];
int main(){
scanf("%d%d%d",&n,&k,&q);ans=2000000000;
for (int i=1;i<=n;i++) scanf("%d",&a[i]);
for (int j=1;j<=n;j++){
int maxv=a[j],qq=q;bn=cn=0;
for (int i=1;i<=n;i++) if (a[i]<a[j]){
sort(b+1,b+bn+1);
for (int ii=1;ii<=bn-k+1;ii++) c[++cn]=b[ii];
// maxv=max(maxv,b[min(qq,bn-k+1)]);
// qq-=bn-k+1;
// qq=max(qq,0);
bn=0;
}
else{
b[++bn]=a[i];
}
sort(b+1,b+bn+1);
for (int ii=1;ii<=bn-k+1;ii++) c[++cn]=b[ii];
bn=0;
sort(c+1,c+cn+1);
if (q<=cn) ans=min(ans,c[q]-a[j]);
}
printf("%d",ans);
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int main() {
string buf;
int board[3][3];
while(getline(cin,buf)) {
if(buf[0]=='0') break;
for(int i=0;i<3;i++) {
switch(buf[i]) {
case '+':
board[0][i]=0;
break;
case 'b':
board[0][i]=1;
break;
case 'w':
board[0][i]=2;
break;
}
}
for(int i=1;i<3;i++) {
getline(cin,buf);
for(int j=0;j<3;j++) {
switch(buf[j]) {
case '+':
board[i][j]=0;
break;
case 'b':
board[i][j]=1;
break;
case 'w':
board[i][j]=2;
break;
}
}
}
/*
for(int i=0;i<3;i++) {
for(int j=0;j<3;j++) cout << board[i][j];
cout << endl;
}
*/
if((board[0][0]==1 && board[0][1]==1 && board[0][2]==1) || (board[1][0]==1 && board[1][1]==1 && board[1][2]==1) || (board[2][0]==1 && board[2][1]==1 && board[2][2]==1) || (board[0][0]==1 && board[1][0]==1 && board[2][0]==1) || (board[0][1]==1 && board[1][1]==1 && board[2][1]==1) || (board[0][2]==1 && board[1][2]==1 && board[2][2]==1) || (board[0][0]==1 && board[1][1]==1 && board[2][2]==1) || (board[0][2]==1 && board[1][1]==1 && board[2][0]==1)) cout << "b" << endl;
else if((board[0][0]==2 && board[0][1]==2 && board[0][2]==2) || (board[1][0]==2 && board[1][1]==2 && board[1][2]==2) || (board[2][0]==2 && board[2][1]==2 && board[2][2]==2) || (board[0][0]==2 && board[1][0]==2 && board[2][0]==2) || (board[0][1]==2 && board[1][1]==2 && board[2][1]==2) || (board[0][2]==2 && board[1][2]==2 && board[2][2]==2) || (board[0][0]==2 && board[1][1]==2 && board[2][2]==2) || (board[0][2]==2 && board[1][1]==2 && board[2][0]==2)) cout << "w" << endl;
else cout << "NA" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r;
cin >> n >> l >> r;
long long base = (r - l + 1) / 3;
long long mod = 1000000007;
long long freq[3];
freq[0] = base;
freq[1] = base;
freq[2] = base;
long long rem = (r - l + 1) % 3;
for (long long i = 0; i < rem; ++i) {
freq[(r - i) % 3]++;
}
if (r - l + 1 == 1) {
if (r % 3 == 0 || n % 3 == 0)
cout << 1;
else
cout << 0;
return 0;
}
long long dp[n + 1][3];
dp[0][0] = 1;
dp[0][1] = 0;
dp[0][2] = 0;
for (long long i = 1; i <= n; i++) {
dp[i][0] = 0;
dp[i][1] = 0;
dp[i][2] = 0;
for (long long j = 0; j < 3; j++) {
if (freq[0]) {
dp[i][j] += (dp[i - 1][j] * freq[0]) % mod;
dp[i][j] %= mod;
}
dp[i][j] += (dp[i - 1][(j - 1 + 3) % 3] * freq[1]) % mod;
dp[i][j] %= mod;
dp[i][j] += (dp[i - 1][(j - 2 + 3) % 3] * freq[2]) % mod;
dp[i][j] %= mod;
}
}
cout << dp[n][0];
}
| 3 |
#include<stdio.h>
#define ll long long
const ll MOD=1e9+7;
ll n,dp[10000][10000],sum[10000][10000];
char s[100000];
int main(){
scanf("%lld %s", &n,&s);
dp[1][1]=1;
sum[1][1]=1;
for(ll i=2;i<=n;i++){
for(ll j=1;j<=i;j++){
if(s[i-2]=='>') dp[i][j]=sum[i-1][j-1]%MOD;
else dp[i][j]=sum[i-1][i-1]-sum[i-1][j-1]%MOD;
sum[i][j]=(sum[i][j-1]+dp[i][j]+MOD)%MOD;
}
}
printf("%lld", sum[n][n]%MOD);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
map<int, int> order;
int bot = 0;
int top = s.length() + 3;
for (int i = 0; i < s.length(); ++i) {
if (s.at(i) == 'l') {
top--;
order[top] = i + 1;
} else {
bot++;
order[bot] = i + 1;
}
}
map<int, int>::iterator mit;
for (mit = order.begin(); mit != order.end(); ++mit)
cout << mit->second << "\n";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char keyboard[3][12] = {"qwertyuiop", "asdfghjkl;", "zxcvbnm,./"};
int main() {
char D;
string S, res;
int offset;
cin >> D >> S;
if (D == 'R') {
offset = -1;
} else {
offset = 1;
}
for (int i = 0; i < S.size(); i++) {
for (int line = 0; line < 3; line++) {
for (int key = 0; key < 10; key++) {
if (keyboard[line][key] == S[i]) {
if (key + offset < 0 || key + offset >= 10) {
res.push_back(S[i]);
} else {
res.push_back(keyboard[line][key + offset]);
}
}
}
}
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 4;
int main() {
int n;
cin >> n;
int beg = 1, end = n;
for (int i = 1; i <= n; i++) {
if (i % 2)
cout << beg++ << " ";
else {
cout << end-- << " ";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
struct tree {
int d1, d2, s1, s2, lnum, rnum, delta;
tree* lch;
tree* rch;
};
int a[300010], f[300010];
void build(tree* x, int l, int r) {
x->d1 = inf;
x->d2 = 2 * inf;
x->s1 = r - l + 1;
x->s2 = 0;
x->lnum = l;
x->rnum = r;
x->delta = 0;
if (l == r) return;
int mid = (l + r) >> 1;
x->lch = new tree;
build(x->lch, l, mid);
x->rch = new tree;
build(x->rch, mid + 1, r);
}
void newd(tree* x, int d, int s) {
if (x->d1 > d) {
x->d2 = x->d1;
x->s2 = x->s1;
x->d1 = d;
x->s1 = s;
} else {
if (x->d1 == d)
x->s1 += s;
else {
if (x->d2 > d) {
x->d2 = d;
x->s2 = s;
} else if (x->d2 == d)
x->s2 += s;
}
}
}
void pushdown(tree* x) {
if (x->delta) {
x->lch->d1 += x->delta;
x->lch->d2 += x->delta;
x->lch->delta += x->delta;
x->rch->d1 += x->delta;
x->rch->d2 += x->delta;
x->rch->delta += x->delta;
x->delta = 0;
}
}
void pushup(tree* x) {
x->d1 = x->lch->d1;
x->s1 = x->lch->s1;
x->d2 = x->lch->d2;
x->s2 = x->lch->s2;
newd(x, x->rch->d1, x->rch->s1);
newd(x, x->rch->d2, x->rch->s2);
}
void change(tree* x, int l, int r, int k) {
if ((l <= x->lnum) && (r >= x->rnum)) {
x->d1 += k;
x->d2 += k;
x->delta += k;
return;
}
pushdown(x);
if (l < x->rch->lnum) change(x->lch, l, r, k);
if (r > x->lch->rnum) change(x->rch, l, r, k);
pushup(x);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) f[a[i]] = i;
tree* root = new tree;
build(root, 1, n);
long long ans = 0;
for (int i = n; i; i--) {
change(root, i, i, -inf);
change(root, i, n, 1);
if ((f[i] > 1) && (a[f[i] - 1] > i)) change(root, a[f[i] - 1], n, -1);
if ((f[i] < n) && (a[f[i] + 1] > i)) change(root, a[f[i] + 1], n, -1);
if (root->d1 <= 2) ans += root->s1;
if (root->d2 <= 2) ans += root->s2;
}
printf("%I64d\n", ans - n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i += 2)
for (int j = 1; j <= m; j += 2) ans += (n - i) * (m - j);
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> leavescolor;
int main() {
string s1, s2;
int n;
while (~scanf("%d", &n)) {
leavescolor.clear();
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> s1 >> s2;
if (!leavescolor[s1 + " " + s2]) {
leavescolor[s1 + " " + s2] = 1;
sum++;
}
}
cout << sum << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool test_cases;
void init(bool k) {
test_cases = k;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct test_cases {
void prepare_left(long long *great_left, long long n, long long *a) {
stack<long long> st;
great_left[0] = -1;
st.push(a[0]);
for (long long i = 1; i < n; i++) {
while (!st.empty() and st.top() < a[i]) {
st.pop();
}
if (st.empty()) {
great_left[i] = -1;
} else {
great_left[i] = st.top();
}
st.push(a[i]);
}
}
void prepare_right(long long *great_right, long long n, long long *a) {
stack<long long> st;
great_right[n - 1] = -1;
st.push(a[n - 1]);
for (long long i = n - 2; i >= 0; i--) {
while (!st.empty() and st.top() < a[i]) {
st.pop();
}
if (st.empty()) {
great_right[i] = -1;
} else {
great_right[i] = st.top();
}
st.push(a[i]);
}
}
void test_case(long long test) {
long long n;
cin >> n;
long long a[n];
long long great_left[n];
long long great_right[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
for (long long i = 0; i < n - 1; i++) {
ans = max(ans, a[i] ^ a[i + 1]);
}
prepare_left(great_left, n, a);
prepare_right(great_right, n, a);
for (long long i = 0; i < n; i++) {
long long left = great_left[i];
long long right = great_right[i];
if (left != -1) {
ans = max(ans, left ^ a[i]);
}
if (right != -1) {
ans = max(ans, right ^ a[i]);
}
if (left != -1 and right != -1) {
ans = max(ans, left ^ right);
}
}
cout << ans << "\n";
}
};
int32_t main() {
init(false);
long long tc;
if (test_cases) {
cin >> tc;
} else {
tc = 1;
}
for (long long i = 0; i < tc; i++) {
struct test_cases o;
o.test_case(i + 1);
}
return 0;
};
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long maxn = 2001;
long long h[maxn], dp[maxn][2 * maxn];
signed main() {
long long n, k;
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &h[i]);
dp[0][2001] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j < 2 * maxn; j++)
if (h[i] == h[i % n + 1])
dp[i][j] = k * dp[i - 1][j] % mod;
else
dp[i][j] = (dp[i - 1][j + 1] + dp[i - 1][j - 1] +
(k - 2) * dp[i - 1][j] % mod) %
mod;
}
long long ans = 0;
for (long long i = 1; i < maxn; i++) ans = (ans + dp[n][maxn + i]) % mod;
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
char ch[42][N];
int z[N];
char s[N];
void build_z(int n) {
int l = 0, r = 0;
z[0] = n;
for (int i = 1; i < n; i++) {
z[i] = (i > r ? 0 : min(r - i + 1, z[i - l]));
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
z[i]++;
}
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
vector<pair<int, int> > edges[N];
vector<int> g[N], gr[N];
void add(int x, int y, int z) { edges[x].push_back(make_pair(y, z)); }
bool was[N];
int w[N], kw;
void dfs1(int v) {
was[v] = true;
for (int j = 0; j < (int)g[v].size(); j++) {
int u = g[v][j];
if (!was[u]) {
dfs1(u);
}
}
w[kw++] = v;
}
int c[N];
int of_c[N];
void dfs2(int v) {
for (int j = 0; j < (int)gr[v].size(); j++) {
int u = gr[v][j];
if (c[u] == -1) {
c[u] = c[v];
of_c[c[u]]++;
dfs2(u);
}
}
}
bool loop[N];
int start[N], finish[N];
int flen[N];
int vers;
bool test(int from, int to) {
if (from > to) {
return true;
}
for (int i = 0; i < vers; i++) {
g[i].clear();
gr[i].clear();
}
for (int i = 0; i < vers; i++) {
was[i] = true;
loop[i] = false;
}
was[0] = false;
for (int j = 0; j < (int)edges[0].size(); j++) {
g[0].push_back(edges[0][j].first);
gr[edges[0][j].first].push_back(0);
}
for (int id = from; id <= to; id++) {
for (int i = start[id]; i < finish[id]; i++) {
was[i] = false;
for (int j = 0; j < (int)edges[i].size(); j++) {
int helper = edges[i][j].second;
if (helper < from || helper > to) {
continue;
}
if (i == edges[i][j].first) {
loop[i] = true;
}
g[i].push_back(edges[i][j].first);
gr[edges[i][j].first].push_back(i);
}
}
}
kw = 0;
for (int i = 0; i < vers; i++) {
if (was[i]) {
continue;
}
dfs1(i);
}
for (int i = 0; i < vers; i++) {
c[i] = -1;
}
int nc = 0;
for (int id = kw - 1; id >= 0; id--) {
int i = w[id];
if (c[i] == -1) {
of_c[nc] = 1;
c[i] = nc++;
dfs2(i);
}
}
for (int id = from; id <= to; id++) {
for (int i = start[id] + 1; i < finish[id]; i++) {
if (of_c[c[i]] > 1 || loop[i]) {
return false;
}
}
}
return true;
}
int main() {
int cnt;
scanf("%d", &cnt);
vers = 1;
for (int i = 0; i < cnt; i++) {
scanf("%s", ch[i]);
flen[i] = strlen(ch[i]);
start[i] = vers;
vers += flen[i];
finish[i] = vers;
add(0, start[i], -1);
}
for (int i = 0; i < cnt; i++) {
int n = 0;
for (int j = 0; j < flen[i]; j++) {
s[n++] = ch[i][j];
}
s[n++] = '#';
int from = n;
for (int q = 0; q < cnt; q++) {
n = from;
for (int j = 0; j < flen[q]; j++) {
s[n++] = ch[q][j];
}
build_z(n);
for (int j = 0; j < flen[q]; j++) {
int x = flen[i];
int y = flen[q] - j;
if (z[from + j] != min(x, y)) {
continue;
}
if (x == y) {
add(start[q] + j, 0, i);
} else {
if (x < y) {
add(start[q] + j, start[q] + j + x, i);
} else {
add(start[q] + j, start[i] + y, i);
}
}
}
}
}
int j = -1;
int ans = 0;
for (int i = 0; i < cnt; i++) {
while (j + 1 < cnt) {
if (!test(i, j + 1)) {
break;
}
j++;
}
if (i <= j) {
ans += j - i + 1;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300005];
long long ans, t;
vector<int> b[300005];
int main() {
scanf("%d", &n);
if (32281 > 23346) {
int SJQTNVYTHY;
SJQTNVYTHY = 890;
int VLABDWDNOG;
double QHJMZGOBOX;
bool SJAZLHXFNS;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[1].push_back(a[i]);
double IBTBRLYCXT;
IBTBRLYCXT = 22204;
if (IBTBRLYCXT) {
if (28191 > 11727) {
if (31516 > 10166) {
short OIYWZWGUMU;
OIYWZWGUMU = 32597;
bool KBORLDDWJN;
KBORLDDWJN = 28507;
if (15624 > 14783) {
double XPAYQSVEQU;
bool KTQMTWTZFW;
}
bool ATVFEDBUXZ;
ATVFEDBUXZ = 5419;
if (ATVFEDBUXZ) {
short YGYZAWOKXY;
}
}
double BQWXBOXCPY;
BQWXBOXCPY = 6361;
}
long long VAOVGFEAUK;
long long FEIASNIVBT;
FEIASNIVBT = 18457;
}
int cnt = 1;
if (22244 > 7895) {
short MVPVMWUJOD;
MVPVMWUJOD = 28548;
if (MVPVMWUJOD) {
if (13366 > 13803) {
bool XDCCNBURPK;
XDCCNBURPK = 13989;
int UPCCKTPSFJ;
UPCCKTPSFJ = 5412;
}
}
}
for (int i = 29; ~i; i--) {
long long x = 0, y = 0, o = cnt;
if (331 > 31276) {
double XUKCKKWRRB;
XUKCKKWRRB = 2944;
if (XUKCKKWRRB) {
short KHPLISVQGN;
KHPLISVQGN = 21673;
if (10023 > 7274) {
long long JXPHWWDLPW;
long long AGAJYTIEGO;
}
double OOVXBXALUH;
}
if (24834 > 14701) {
if (22274 > 6345) {
double YOOXQTHBXQ;
int SWBPNZOBPM;
short MIMUYITJME;
long long LVFSTHJESV;
}
short ZMAEYZVDUB;
ZMAEYZVDUB = 4936;
}
}
for (int j = 1; j <= o; j++) {
vector<int> c, d;
long long OBMQGRWENF;
OBMQGRWENF = 15562;
c.clear(), d.clear();
double XFCVVRQFTH;
XFCVVRQFTH = 26112;
for (int it : b[j])
if ((it >> i + 1) & 1)
c.push_back(it);
else
d.push_back(it);
long long QYYUTVEXAC;
QYYUTVEXAC = 13662;
if (QYYUTVEXAC) {
if (29005 > 10119) {
double ADPFJEOSLB;
int SUNXFCPQQM;
long long NPKWYUMDWG;
short DPSFDZGZQJ;
}
long long KLADKTHBFY;
KLADKTHBFY = 21501;
if (7526 > 22888) {
long long DCKGTAMXYC;
}
}
if (c.size() && d.size())
b[j] = c, b[++cnt] = d;
else if (c.size())
b[j] = c;
else
b[j] = d;
}
for (int j = 1; j <= cnt; j++) {
int k1 = 0, k2 = 0;
long long PGLDPXZALS;
PGLDPXZALS = 7799;
for (int it : b[j])
if ((it >> i) & 1)
k1++, y += k2;
else
k2++, x += k1;
double TNESDTVDSZ;
TNESDTVDSZ = 30292;
}
if (y < x)
t += 1 << i, ans += y;
else
ans += x;
if (5807 > 9603) {
if (29771 > 16970) {
int TDPFFUBYBU;
TDPFFUBYBU = 18472;
bool FEYWLUMEDF;
FEYWLUMEDF = 9537;
if (FEYWLUMEDF) {
bool QUXROTLHGI;
}
}
if (14103 > 1891) {
short KBFEYBHYCA;
KBFEYBHYCA = 25336;
if (KBFEYBHYCA) {
long long CHMSQJZZIU;
}
long long FUJBTTXSQB;
FUJBTTXSQB = 29345;
if (24995 > 3361) {
int TNUJLIOXSC;
double TZUOZRZRDT;
}
}
long long TIDXWJOUHO;
}
bool BMOUKIKXNZ;
}
printf("%lld %lld\n", ans, t);
if (18895 > 3547) {
bool IMKKWKICWW;
IMKKWKICWW = 11429;
if (IMKKWKICWW) {
short IHCEJIHDTW;
IHCEJIHDTW = 1291;
if (25615 > 637) {
if (26871 > 9623) {
short WALLAXKASQ;
double AMBDKTLOKI;
int KXGRXXADHW;
}
bool QQDTDGOVKV;
QQDTDGOVKV = 5810;
}
bool ZZOJGQYGAP;
ZZOJGQYGAP = 8436;
}
if (23167 > 17327) {
long long PACGTBWFIO;
PACGTBWFIO = 21773;
if (PACGTBWFIO) {
int FHLLOJIHWS;
FHLLOJIHWS = 12308;
if (FHLLOJIHWS) {
short WOMBIFFOGK;
long long YTVHSGVWVY;
}
int QDEIYBGOJP;
QDEIYBGOJP = 25254;
if (28148 > 3808) {
double IQZFWMAQUK;
double MRJBSTWVNO;
}
}
if (29215 > 23673) {
if (19137 > 24370) {
double LQGRJCRJBI;
short MZGZFAIJFI;
double PBATIHAXVZ;
}
}
}
long long NQOEOGKCGP;
NQOEOGKCGP = 12691;
}
return 0;
int KMWHPHFNLS;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <complex>
using Real = long double;
using Point = std::complex<Real>;
using Segment = std::pair<Point, Point>;
const Real PI = acos(-1);
const Real EPS = 1e-10;
std::istream& operator>>(std::istream& is, Point& p) {
Real x, y;
is >> x >> y;
p = Point(x, y);
return is;
}
inline int compare(Real a, Real b) {
if (std::abs(a - b) < EPS) return 0;
return a - b > 0 ? 1 : -1;
}
inline Real dist(Point a, Point b) {
return std::abs(a - b);
}
inline Real dot(Point x, Point y) {
return std::real(std::conj(x) * (y));
}
using namespace std;
int main() {
int N;
Real r, theta;
cin >> N >> r >> theta;
theta *= PI / 180;
vector<Point> ps(N);
for (auto& p : ps) cin >> p;
vector<vector<Real>> d(N * N, vector<Real>(N * N, 1e50));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
if (i == j) continue;
for (int k = 0; k < N; ++k) {
if (j == k) continue;
Real costheta = dot(ps[j] - ps[i], ps[k] - ps[j]) / (dist(ps[j], ps[i]) * dist(ps[k], ps[j]));
if (costheta < -1) costheta += EPS;
if (costheta > 1) costheta -= EPS;
if (compare(acos(costheta), theta) > 0) continue;
d[i * N + j][j * N + k] = dist(ps[j], ps[k]);
}
}
}
vector<vector<Real>> dp(N * N, vector<Real>(10001, 1e100));
// dp[i][j][n] = 直前i、今jにいて、既にk箇所訪れたときの最短距離
for (int i = 1; i < N; ++i) {
dp[i][1] = dist(ps[0], ps[i]);
}
for (int n = 1; n < 10000; ++n) {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
if (i == j) continue;
for (int k = 0; k < N; ++k) {
if (j == k) continue;
dp[j * N + k][n + 1] = min(dp[j * N + k][n + 1], dp[i * N + j][n] + d[i * N + j][j * N + k]);
}
}
}
}
int ans = 0;
for (int v = 0; v < N * N; ++v) {
for (int n = 0; n <= 10000; ++n) {
if (compare(dp[v][n], r) <= 0) ans = max(ans, n);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, mid, x, y;
cin >> n;
if (n % 2)
mid = (n + 1) / 2;
else
mid = n / 2;
map<long long, long long> mop1, mop2;
vector<int> vec;
for (int i = 0; i < n; i++) {
cin >> x >> y;
vec.push_back(x);
vec.push_back(y);
mop1[x]++;
mop2[y]++;
if (x == y) mop2[y]--;
}
long long maxx = 10e9;
for (int i = 0; i < vec.size(); i++) {
long long cur = mop1[vec[i]] + mop2[vec[i]];
if (cur >= mid) {
maxx = min(maxx, mid - mop1[vec[i]]);
if (maxx < 0) maxx = 0;
}
}
if (maxx != 10e9)
cout << maxx << endl;
else
cout << -1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long int d;
pair<long long int, long long int> a[100000];
cin >> n >> d;
for (int i = 0; i < n; ++i) cin >> a[i].first >> a[i].second;
sort(a, a + n);
int temp = a[0].first;
long long int sum = a[0].second;
long long int max = 0;
int m = 0;
for (int i = 1; i < n; ++i) {
if (a[i].first - temp < d)
sum += a[i].second;
else {
if (sum > max) max = sum;
temp = a[++m].first;
sum -= a[m - 1].second;
--i;
}
}
if (sum > max) max = sum;
cout << max;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mod_exp(long long int x, long long int pow) {
if (pow == 0) return 1;
long long int res = mod_exp((x * x) % 1000000007, pow / 2);
if (pow % 2) res *= x;
return res % 1000000007;
}
int main() {
int n, i, j, t;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
int p;
cin >> n >> p;
int arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
if (p == 1) {
cout << n % 2 << '\n';
continue;
}
int prem = -1, last;
long long int need = 0;
for (i = n - 1; i >= 0; i--) {
if (prem == -1) {
prem = arr[i];
last = prem;
need = 1;
} else {
int diff = last - arr[i];
last = arr[i];
while (diff--) {
need *= p;
if (need > (i + 5)) {
break;
}
}
if (need > 1e7) {
break;
}
need--;
if (need == 0) prem = -1;
}
}
if (prem == -1)
cout << 0;
else {
long long int sum = 0;
for (i = 0; i < n; i++) {
if (arr[i] == prem) break;
sum += mod_exp(p, arr[i]);
sum %= 1000000007;
}
long long int ans = mod_exp(p, prem) - sum;
ans += 1000000007;
ans %= 1000000007;
cout << ans;
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
stack<char> temp;
for (int i = 0; i < str.size(); i++) {
if (temp.empty())
temp.push(str[i]);
else if (str[i] == temp.top())
temp.pop();
else
temp.push(str[i]);
}
if (temp.empty())
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, k, m;
struct matrix {
vector<vector<long long> > M;
vector<long long>& operator[](int x) { return M[x]; }
int size() { return (int)M.size(); }
matrix(int n, int m) { M.assign(n + 1, vector<long long>(m + 1, 0LL)); }
};
long long add(long long a, long long b) {
a += b;
if (a > m) a -= m;
return a;
}
matrix operator*(matrix a, matrix b) {
int n = a.size() - 1, q = a[0].size() - 1, p = b[0].size() - 1;
matrix res = matrix(n, p);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= q; ++j)
for (int k = 1; k <= p; ++k)
res[i][k] = add(res[i][k], a[i][j] * b[j][k] % m);
return res;
}
matrix pw(matrix a, long long n) {
if (n == 1) return a;
matrix tmp = pw(a, n >> 1);
if (n & 1) return tmp * tmp * a;
return tmp * tmp;
}
int main() {
cin >> m >> l >> r >> k;
vector<long long> t;
long long res = 0;
for (int i = 1; 1LL * i * i <= r; ++i) {
t.push_back(i);
if (i != r / i) t.push_back(r / i);
}
for (int i = 0; i < t.size(); ++i)
if (r / t[i] - (l - 1) / t[i] >= k) res = max(res, t[i]);
matrix ans = matrix(1, 2);
matrix c = matrix(2, 2);
ans[1][1] = 0, ans[1][2] = 1;
c[1][1] = c[1][2] = c[2][1] = 1;
ans = ans * pw(c, res + 1);
cout << ans[1][2];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int vis[1000001];
int crush[1000001];
int cl;
int s[1000001];
int st, en;
void dfs(int i) {
vis[i] = 1;
cl++;
if (!vis[crush[i]])
dfs(crush[i]);
else
en = crush[i];
}
int gcd(int a, int b) {
int temp;
while (b > 0) {
temp = b;
b = a % b;
a = temp;
}
return a;
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
int main() {
int n, i, j = 0, x, res, flag = 1;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
crush[i] = x - 1;
}
for (i = 0; i < n; i++) {
cl = 0;
if (!vis[i]) {
st = i;
dfs(i);
if (cl % 2 == 0)
s[j++] = cl / 2;
else
s[j++] = cl;
}
if (st != en) {
flag = 0;
break;
}
}
if (flag) {
res = s[0];
for (i = 1; i < j; i++) res = lcm(res, s[i]);
cout << res << endl;
} else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e8 + 10;
bool ok = 0;
int n, maxy, miny, maxx, minx;
struct point {
int x, y;
};
bool cmp(point a, point b) { return a.x < b.x; }
point jilu[100050];
int bfy[100050], afy[100050], bfmaxy[100050], bfminy[100050], afminy[100050],
afmaxy[100050];
int b1_search(long long tmp) {
int l = 0, r = n - 1, m;
while (r >= l) {
m = (l + r) >> 1;
if (jilu[m].x <= tmp)
l = m + 1;
else
r = m - 1;
}
return r;
}
int b2_search(long long tmp) {
int l = 0, r = n - 1, m;
while (r >= l) {
m = (r + l) >> 1;
if (jilu[m].x >= tmp)
r = m - 1;
else
l = m + 1;
}
return l;
}
long long binary_sqrt(long long tmp) {
long long ans = sqrt(tmp);
while (ans * ans > tmp) {
ans--;
}
while ((ans + 1) * (ans + 1) <= tmp) {
ans++;
}
return ans;
}
bool check(long long tmp) {
long long a = maxy - miny;
long long b = maxx - minx;
if (tmp >= a * a || tmp >= b * b) {
return 1;
}
int pos;
long long ttmp = binary_sqrt(tmp);
for (int i = 0; i < n; i++) {
if (jilu[i].x < 0) {
pos = b1_search(min(jilu[i].x + ttmp, (long long)-jilu[i].x));
long long my = max(bfy[i], afy[pos]);
long long mx =
max(max(jilu[i].x, -jilu[i].x), max(jilu[pos].x, -jilu[pos].x));
long long yy = max(afmaxy[pos], bfmaxy[i]) - min(afminy[pos], bfminy[i]);
if (my * my + mx * mx <= tmp && yy * yy <= tmp) {
return 1;
}
} else {
pos = b2_search(max(jilu[i].x - ttmp, (long long)-jilu[i].x));
long long my = max(afy[i], bfy[pos]);
long long mx =
max(max(jilu[i].x, -jilu[i].x), max(jilu[pos].x, -jilu[pos].x));
long long yy = max(afmaxy[i], bfmaxy[pos]) - min(afminy[i], bfminy[pos]);
if (my * my + mx * mx <= tmp && yy * yy <= tmp) {
return 1;
}
}
}
return 0;
}
void Binary_search(long long l, long long r) {
long long m;
while (r > l) {
m = l + (r - l) / 2;
if (check(m))
r = m;
else
l = m + 1;
}
cout << r << endl;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &jilu[i].x, &jilu[i].y);
}
sort(jilu, jilu + n, cmp);
bfmaxy[0] = -inf;
bfminy[0] = inf;
for (int i = 1; i < n; i++) {
bfmaxy[i] = max(bfmaxy[i - 1], jilu[i - 1].y);
bfminy[i] = min(bfminy[i - 1], jilu[i - 1].y);
}
afmaxy[n - 1] = -inf;
afminy[n - 1] = inf;
for (int i = n - 2; i >= 0; i--) {
afmaxy[i] = max(afmaxy[i + 1], jilu[i + 1].y);
afminy[i] = min(afminy[i + 1], jilu[i + 1].y);
}
for (int i = 1; i < n; i++) {
bfy[i] =
max(max(bfy[i - 1], -bfy[i - 1]), max(jilu[i - 1].y, -jilu[i - 1].y));
}
for (int i = n - 2; i >= 0; i--) {
afy[i] =
max(max(afy[i + 1], -afy[i + 1]), max(jilu[i + 1].y, -jilu[i + 1].y));
}
maxy = miny = jilu[0].y;
maxx = minx = jilu[0].x;
for (int i = 0; i < n; i++) {
maxy = max(jilu[i].y, maxy);
miny = min(jilu[i].y, miny);
maxx = max(jilu[i].x, maxx);
minx = min(jilu[i].x, minx);
}
Binary_search(0, 40000000000000000);
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
int n, m;
const char output[] = { '#', 'A', 'B', 'C', 'D' };
std::vector<int> seat;
while (std::cin >> n >> m) {
if (n == 0 && m == 0)
break;
seat.resize(n);
for (int i = 0; i < m; ++i) {
char who;
std::cin >> who;
if (who == 'A') {
for (int j = 0; j < n; ++j) {
if (seat[j] == 0) {
seat[j] = 1;
break;
}
}
}
else if (who == 'B') {
int firstEmpty = 334;
bool isRightA = false;
for (int j = n - 1; j >= 0; --j) {
if (seat[j] == 0) {
firstEmpty = std::min(firstEmpty, j);
if (!isRightA && (j == 0 || seat[j - 1] != 1)) {
seat[j] = 2;
break;
}
}
isRightA = seat[j] == 1;
}
}
else if (who == 'C') {
for (int j = 0; j < n; ++j) {
if (seat[j] != 0) {
if (j != n - 1 && seat[j + 1] == 0) {
seat[j + 1] = 3;
break;
}
if (j != 0 && seat[j - 1] == 0) {
seat[j - 1] = 3;
break;
}
}
if (j == n - 1)
seat[n / 2] = 3;
}
}
else if (who == 'D') {
int maxDist = 0;
int maxIdx = 0;
int dist = 0;
int fromTop = 0;
int toLast = 0;
for (int j = 0; j < n; ++j) {
++dist;
if (seat[0] != 0 && j == n - 1)
toLast = dist;
if (seat[j] != 0) {
if (fromTop == 0)
fromTop = j + 1;
if (maxDist < dist / 2) {
maxDist = dist / 2;
maxIdx = j - dist;
}
dist = 0;
}
}
if (seat[n - 1] == 0 && toLast > maxDist && fromTop < toLast)
seat[n - 1] = 4;
else if (seat[0] == 0 && fromTop > maxDist && fromTop > toLast)
seat[0] = 4;
else
seat[maxIdx + maxDist] = 4;
}
}
for (int i = 0; i < n; ++i)
std::cout << output[seat[i]];
std::cout << std::endl;
seat.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long mod = 1000000009;
int main() {
for (long long n; scanf("%I64d", &n) != EOF;) {
long long ans = 2, a = 1, b = 4;
for (int i = 2; i < n; i += 2) {
b = (b * a) % mod;
a = (2 * a + 3) % mod;
ans = (ans + b) % mod;
}
printf("%I64d\n", ((ans * ans % mod) * 2 + 2) % mod);
}
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long a,b,c,d;
cin>>a>>b>>c>>d;
long long res = max({a*c, a*d, b*c, b*d});
cout<<res<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int k;
long long int a[10];
bool check() {
long long int ans = 1;
for (long long int(i) = (0); (i) < (10); (i)++) {
ans *= a[i];
}
return ans >= k;
}
void solve() {
cin >> k;
string print = "codeforces";
for (long long int(i) = (0); (i) < (10); (i)++) {
a[i] = 1;
}
if (k > 1) {
int i = 0;
while (true) {
a[i]++;
if (check()) {
break;
}
i++;
if (i > 9) i = 0;
}
}
for (long long int(i) = (0); (i) < (10); (i)++) {
while (a[i]--) cout << print[i];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cerr.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; ++i) cin >> A[i];
vector<int> B(N);
for (int i = 0; i < N; ++i) cin >> B[i];
sort(A.begin(), A.end());
sort(B.begin(), B.end());
long long ans = 0;
for (int t = 0; A.size() || B.size(); t ^= 1) {
int a = A.size() ? A.back() : 0;
int b = B.size() ? B.back() : 0;
int u = max(a, b);
if (t && a != u)
ans -= u;
else if (!t && a == u)
ans += u;
if (a == u)
A.pop_back();
else
B.pop_back();
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long Max(long long a, long long b) { return a > b ? a : b; }
inline long long Min(long long a, long long b) { return a < b ? a : b; }
inline long long read() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
write(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
void scan(int &x) {
bool neg = false;
register int c;
x = 0;
c = getchar();
if (c == '-') {
neg = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) x = (x << 1) + (x << 3) + c - 48;
if (neg) x *= -1;
}
long long sumx[100009];
long long sumy[100009];
int main() {
int t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
long long x, y;
for (int i = 1; i <= n; i++) {
cin >> x;
sumx[i] += sumx[i - 1] + x;
}
for (int i = 1; i <= m; i++) {
cin >> y;
sumy[i] += sumy[i - 1] + y;
}
int idx = 0;
int idy = 0;
long long ans = 0;
long long subx = 0;
long long suby = 0;
int i = 1;
int j = 1;
while (i != n + 1 && j != m + 1) {
if ((sumx[i] - subx) > (sumy[j] - suby)) {
j++;
} else if ((sumy[j] - suby) > (sumx[i] - subx)) {
i++;
} else {
subx = sumx[i];
suby = sumy[j];
ans++;
idx = i;
idy = j;
i++;
j++;
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > AdjList;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int main() {
int cost;
cin >> cost;
int a, b, c, d;
for (int i = 0; i < 4; i++) {
cin >> a >> b >> c >> d;
if (min(a, b) + min(c, d) <= cost) {
cout << i + 1 << ' ' << min(a, b) << ' ' << cost - (min(a, b)) << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <cstring>
#define rep(i,j) FOR(i,0,j)
#define FOR(i,j,k) for(int i=j;i<k;i++)
using namespace std;
int main(){
int n;
while(cin>>n,n){
int a=0,b=0,c,d;
rep(i,n){
cin>>c>>d;
if(c>d)a+=c+d;
else if(c<d)b+=c+d;
else{
a+=c;
b+=d;
}
}
cout<<a<<" "<<b<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, MOD = 1e9 + 7, MAXX = 508;
const long double EPS = 0.000000001;
long long a[N];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
queue<pair<long long, long long>> q;
q.push({0, n});
while (!q.empty()) {
auto to = q.front();
q.pop();
bool ok = true;
if (to.second < to.first) continue;
for (long long i = to.first; i < to.second - 1; i++) {
if (a[i] > a[i + 1]) {
ok = false;
}
}
if (ok) {
ans = max(ans, to.second - to.first);
} else {
long long m = (to.first + to.second) / 2;
q.push({to.first, m});
q.push({m, to.second});
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int n, q;
long long a[N * 2][N * 2], bin[N * 2] = {1}, cur;
void dfs(int x, int y) {
printf("%d %d\n", x, y);
fflush(stdout);
if (cur & bin[x + y - 1]) {
if (x < n && a[x + 1][y]) dfs(x + 1, y);
if (y < n && a[x][y + 1]) dfs(x, y + 1);
} else {
if (x < n && !a[x + 1][y]) dfs(x + 1, y);
if (y < n && !a[x][y + 1]) dfs(x, y + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < 2 * n; i++) bin[i] = bin[i - 1] * 2;
for (int i = 0; i < 2 * n; i++)
for (int j = 1; j <= i; j++) a[j][i - j + 1] = bin[i - 1] * (j & 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%lld ", a[i][j]);
printf("\n");
fflush(stdout);
}
scanf("%d", &q);
while (q--) {
scanf("%lld", &cur);
dfs(1, 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long a[200005], b[200005];
int main() {
long long T, n;
cin >> T;
while (T--) {
long long cnt = 0, now;
cin >> n;
cin >> s;
s = ' ' + s;
for (long long i = 1; i <= n; i++) a[i] = i;
for (long long i = 1; i <= n; i++) b[i] = n - i + 1;
for (long long i = 1; i < n;) {
long long j = i;
while (s[j] == '>') j++;
reverse(a + i, a + j + 1);
i = j + 1;
}
for (long long i = 1; i < n;) {
long long j = i;
while (s[j] == '<') j++;
reverse(b + i, b + j + 1);
i = j + 1;
}
for (long long i = 1; i <= n; i++) cout << b[i] << (i == n ? '\n' : ' ');
for (long long i = 1; i <= n; i++) cout << a[i] << (i == n ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
const int NMAX = 2100000;
char s[NMAX];
int p[NMAX], cnt[NMAX], c[NMAX], pn[NMAX], cn[NMAX], n, b[NMAX];
bool good[NMAX];
int md[NMAX * 4], add[NMAX * 4];
void md_build(int idx, int l, int r) {
if (l == r) {
md[idx] = b[l];
return;
}
int mid = (l + r) >> 1;
md_build(idx << 1, l, mid);
md_build(idx << 1 | 1, mid + 1, r);
md[idx] = min(md[idx << 1], md[idx << 1 | 1]);
}
void md_relax(int idx, int l, int r) {
if (add[idx]) {
md[idx] += add[idx];
if (l != r) {
add[idx << 1] += add[idx];
add[idx << 1 | 1] += add[idx];
}
add[idx] = 0;
}
}
void md_add(int idx, int l, int r, int a, int b, int d) {
md_relax(idx, l, r);
if (b < l || r < a) return;
if (a <= l && r <= b) {
add[idx] += d;
return md_relax(idx, l, r);
}
int mid = (l + r) >> 1;
md_add(idx << 1, l, mid, a, b, d);
md_add(idx << 1 | 1, mid + 1, r, a, b, d);
md[idx] = min(md[idx << 1], md[idx << 1 | 1]);
}
int md_min(int idx, int l, int r, int a, int b) {
md_relax(idx, l, r);
if (b < l || r < a) return INF;
if (a <= l && r <= b) return md[idx];
int mid = (l + r) >> 1;
return min(md_min(idx << 1, l, mid, a, b),
md_min(idx << 1 | 1, mid + 1, r, a, b));
}
int main() {
gets(s);
n = (int)strlen(s);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < (int)(n); i++) ++cnt[s[i] - '('];
cnt[1] += cnt[0];
for (int i = 0; i < (int)(n); i++) p[--cnt[s[i] - '(']] = i;
c[p[0]] = 0;
int classes = 1;
for (int i = (int)(1); i < (int)(n); i++) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < n; ++h) {
for (int i = 0; i < (int)(n); i++) pn[i] = (p[i] - (1 << h) + n) % n;
memset(cnt, 0, classes * sizeof(int));
for (int i = 0; i < (int)(n); i++) ++cnt[c[pn[i]]];
for (int i = (int)(1); i < (int)(classes); i++) cnt[i] += cnt[i - 1];
for (int i = (int)(n)-1; i >= 0; i--) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = (int)(1); i < (int)(n); i++) {
int mid1 = (p[i] + (1 << h)) % n, mid2 = (p[i - 1] + (1 << h)) % n;
if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
memcpy(c, cn, n * sizeof(int));
}
int sum = 0;
for (int i = 0; i < (int)(n); i++) {
sum += s[i] == '(' ? +1 : -1;
b[i] = sum;
}
for (int i = 0; i < (int)(n); i++) b[i + n] = sum;
md_build(1, 0, 2 * n);
for (int i = 0; i < (int)(n); i++) {
if (i) {
if (s[i - 1] == '(')
md_add(1, 0, 2 * n, i, i + n - 1, -1);
else
md_add(1, 0, 2 * n, i, i + n - 1, +1);
}
good[i] = md_min(1, 0, 2 * n, i, i + n - 1) >= min(0, sum);
}
int sh = -1;
for (int i = 0; i < (int)(n); i++)
if (good[p[i]]) {
sh = p[i];
break;
}
rotate(s, s + sh, s + n);
if (sum <= 0) printf("%s", string(-sum, '(').c_str());
printf("%s", s);
if (sum > 0) printf("%s", string(sum, ')').c_str());
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
const int MOD = 1000000007;
int main(){
int N, R;
while(cin >> N >> R && N){
vector<int> a(N);
REP(i, N) a[i] = i;
REP(i, R){
int s, t;
cin >> s >> t;
swap(a[s - 1], a[t - 1]);
}
vector<int> used;
vector<long long> fact(N + 1, 1);
REP(i, N) fact[i + 1] = fact[i] * (i + 1) % MOD;
long long ans = 0;
REP(i, N){
int k = lower_bound(used.begin(), used.end(), a[i]) - used.begin();
int b = a[i] - k;
used.insert(used.begin() + k, a[i]);
ans += fact[N - 1 - i] * b;
ans %= MOD;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
vector<int> p[1020];
int f[1020][1020];
int DP(int l, int r) {
int i, v;
int x, y;
if (l > r) return 1;
if (f[l][r] != -1) return f[l][r];
v = *min_element(a.begin() + l, a.begin() + r + 1);
for (i = 0; i < (int)p[v].size(); i++)
if (p[v][i] < l || p[v][i] > r) return f[l][r] = 0;
for (i = *p[v].begin(), x = 0; i >= l; i--)
x = (x + (long long)DP(i, *p[v].begin() - 1) * DP(l, i - 1) % 998244353) %
998244353;
for (i = *p[v].rbegin(), y = 0; i <= r; i++)
y = (y + (long long)DP(*p[v].rbegin() + 1, i) * DP(i + 1, r) % 998244353) %
998244353;
for (i = 1; i < (int)p[v].size(); i++)
x = (long long)x * DP(p[v][i - 1] + 1, p[v][i] - 1) % 998244353;
return f[l][r] = (long long)x * y % 998244353;
}
int main(void) {
int n, m, t;
int i;
memset(f, -1, sizeof(f));
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d", &t);
if (a.empty() || t != a.back()) a.push_back(t);
}
if (a.size() >= 1020)
printf("0\n");
else {
for (i = 0; i < (int)a.size(); i++) p[a[i]].push_back(i);
printf("%d\n", DP(0, (int)a.size() - 1));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
inline int read() {
int x = 0, neg = 1;
char op = getchar();
while (!isdigit(op)) {
if (op == '-') neg = -1;
op = getchar();
}
while (isdigit(op)) {
x = 10 * x + op - '0';
op = getchar();
}
return neg * x;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 10005;
int n, q;
vector<int> adj[N << 2];
void update(int u, int l, int r, int ql, int qr, int x) {
if (ql <= l && r <= qr) {
adj[u].push_back(x);
return;
}
int mid = l + r >> 1;
if (ql <= mid) update((u << 1), l, mid, ql, qr, x);
if (qr > mid) update((u << 1 | 1), mid + 1, r, ql, qr, x);
}
bitset<N> ans(0);
void dfs(int u, int l, int r, bitset<N> A) {
for (auto v : adj[u]) A |= A << v;
if (l == r) {
ans |= A;
return;
}
int mid = l + r >> 1;
dfs((u << 1), l, mid, A);
dfs((u << 1 | 1), mid + 1, r, A);
}
int main() {
scanf("%d%d", &n, &q);
for (register int i = 1; i <= q; i++) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
update(1, 1, n, l, r, x);
}
bitset<N> C(1);
dfs(1, 1, n, C);
vector<int> rans;
int cnt = 0;
for (register int i = 1; i <= n; i++) {
if (ans[i]) {
cnt++;
rans.push_back(i);
}
}
printf("%d\n", cnt);
for (auto v : rans) {
printf("%d ", v);
}
puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxp = 22;
const long double EPS = 1e-18;
const long long INF = 2e18;
const int MOD = 1e9 + 7;
const int N = 201;
long long dp[N][N][N], arr[N];
int n, k;
long long solve(int i, int seg, int can) {
if (i == n) return 0;
if (can == 0 && i + seg < n) return -INF;
if (dp[i][seg][can] != -1) return dp[i][seg][can];
long long best;
if (seg == 0)
best = solve(i + 1, k - 1, can - 1) + arr[i];
else {
best = solve(i + 1, seg - 1, can);
if (can) best = max(best, solve(i + 1, k - 1, can - 1) + arr[i]);
}
return dp[i][seg][can] = best;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int x;
cin >> n >> k >> x;
int i, j, l;
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n; i++)
for (j = 0; j < k; j++)
for (l = 0; l <= x; l++) dp[i][j][l] = -1;
cout << max(-1ll, solve(0, k - 1, x));
}
| 6 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
string a,b,c;int x,y;
cin>>a>>b;
cin>>x>>y;
cin>>c;
if(c==a) x--;
if(c==b) y--;
cout<<x<<' '<<y;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
bool inline ask(int u) {
cout << "? " << u << endl;
string ret;
cin >> ret;
return ret == "Y";
}
int main() {
int n, k;
cin >> n >> k;
int var = max(1, k / 2);
int cnt = (n + var - 1) / var;
vector<int> ok(n + 1, 1);
int ans = 0;
for (int i = 1; i <= n; i++)
if (ask(i)) ok[i] = 0;
for (int i = 1; i <= cnt; i++) {
for (int j = i + 2; j <= cnt; j++) {
cout << "R" << endl;
int l = (i - 1) * var + 1, r = i * var;
for (int i = l; i <= r; i++) ask(i);
l = (j - 1) * var + 1, r = min(n, j * var);
for (int i = l; i <= r; i++)
if (ask(i)) ok[i] = 0;
}
}
for (int i = 1; i <= n; i++) ans += ok[i];
cout << "! " << ans << endl;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.