solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
char s[100006];
int len;
bool end(char ss[]) {
int ll = strlen(ss);
for (int i = len, j = ll; i >= 0 && j >= 0; i--, j--) {
if (s[i] != ss[j]) return false;
if (j == 0) return true;
}
return false;
}
int main() {
bool m = false, fm = false, noun = false, valid = true;
int num = 0;
int x = true;
while (scanf("%s", s) != EOF) {
num++;
bool flag = false;
len = strlen(s);
if (end("lios")) {
flag = true;
m = true;
if (noun) valid = false;
} else if (end("liala")) {
flag = true;
fm = true;
if (noun) valid = false;
} else if (end("etr")) {
flag = true;
m = true;
if (noun) valid = false;
noun = true;
} else if (end("etra")) {
flag = true;
fm = true;
if (noun) valid = false;
noun = true;
} else if (end("initis")) {
flag = true;
m = true;
if (!noun) valid = false;
} else if (end("inites")) {
flag = true;
fm = true;
if (!noun) valid = false;
}
if (!flag) valid = false, x = false;
}
if (num == 1 && x)
printf("YES\n");
else if (!valid)
printf("NO\n");
else if (!noun)
printf("NO\n");
else if (m && fm)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class FenwickTree {
public:
explicit FenwickTree(int N) : F(N, 0) {}
void Add(int i, int delta) {
for (; i < F.size(); i = (i | (i + 1))) {
F[i] += delta;
}
}
int Sum(int i) const {
int result = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
result += F[i];
}
return result;
}
private:
vector<int> F;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, T;
cin >> N >> T;
vector<int> A(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
A[i] = max(0, A[i] - (i + 1));
}
vector<int> all = A;
sort(all.begin(), all.end());
all.erase(unique(all.begin(), all.end()), all.end());
int result = 0;
FenwickTree f_tree(all.size());
for (int i = 0; i < N; ++i) {
int idx = lower_bound(all.begin(), all.end(), A[i]) - all.begin();
f_tree.Add(idx, 1);
int start = max(-1, T - 2 - i);
int start_idx =
upper_bound(all.begin(), all.end(), start) - all.begin() - 1;
result = max(result, f_tree.Sum(start_idx));
}
cout << result << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m = 0, i, j = 0, a, h;
cin >> t;
for (i = 1; i <= t; i++) {
cin >> n;
a = n;
if (n == 1)
cout << "0" << endl;
else if (n == 2)
cout << "1" << endl;
else {
while (a >= 2) {
while (n - m > 0) {
h++;
m = ((3 * h * (h + 1)) / 2) - h;
}
if (n - m != 0) {
m = ((3 * h * (h - 1)) / 2) - (h - 1);
}
j++;
a = n - m;
n = n - m;
m = 0;
h = 0;
}
cout << j << endl;
j = 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct ii {
int first;
int second;
int i;
ii(int a = 0, int b = 0) {
first = a;
second = b;
}
bool operator<(const ii &o) const {
return first == o.first ? second < o.second : first < o.first;
}
};
ii l[300010];
int n, w;
long long A[300010];
int tk[300010];
bool cmp(ii a, ii b) { return a.second - a.first > b.second - b.first; }
long long cost(int n1, int n2, long long r = -1) {
priority_queue<int> q;
long long sum = 0;
long long res = 1e15;
int I = -1;
for (int i = (0); i < (n + 1); i++) {
if (int(q.size()) == n1)
A[i] = sum;
else
A[i] = 1e15;
if (n1 == 0) continue;
if (i != n) {
if (int(q.size()) == n1 && q.top() > l[i].first) {
sum -= q.top();
q.pop();
}
if (int(q.size()) < n1) {
sum += l[i].first;
q.push(l[i].first);
}
}
}
q = priority_queue<int>();
sum = 0;
for (int i = n; i >= 0; i--) {
if (int(q.size()) == n2) {
res = min(res, A[i] + sum);
if (A[i] + sum == r) {
I = i;
goto tkc;
}
}
if (n2 == 0) continue;
if (i != 0) {
if (int(q.size()) == n2 && q.top() > l[i - 1].second) {
sum -= q.top();
q.pop();
}
if (int(q.size()) < n2) {
sum += l[i - 1].second;
q.push(l[i - 1].second);
}
}
}
return res;
tkc:;
priority_queue<ii> oq;
for (int i = (0); i < (n + 1); i++) {
if (i == I) {
while (!oq.empty()) {
tk[l[oq.top().second].i] = 1;
oq.pop();
}
break;
}
if (n1 == 0) continue;
if (i != n) {
if (int(oq.size()) == n1 && oq.top().first > l[i].first) oq.pop();
if (int(oq.size()) < n1) oq.push(ii(l[i].first, i));
}
}
for (int i = n; i >= 0; i--) {
if (i == I) {
while (!oq.empty()) {
tk[l[oq.top().second].i] = 2;
oq.pop();
}
}
if (n2 == 0) continue;
if (i != 0) {
if (int(oq.size()) == n2 && oq.top().first > l[i - 1].second) oq.pop();
if (int(oq.size()) < n2) oq.push(ii(l[i - 1].second, i - 1));
}
}
return -1;
}
int main() {
scanf("%d %d", &n, &w);
for (int i = (0); i < (n); i++) {
scanf("%d %d", &l[i].first, &l[i].second);
l[i].i = i;
}
if (n == 1) {
if (w == 1)
printf("%d\n1\n", l[0].first);
else
printf("%d\n2\n", l[0].second);
return 0;
}
sort(l, l + n, cmp);
vector<int> m;
for (int i = (0); i < (n + 1); i++) {
if ((w - i) % 2 == 0 && i + 2 * (n - i) >= w) m.push_back(i);
}
pair<long long, int> res(1e15, -1);
int s = 0, e = int(m.size()) - 1;
while (s <= e) {
int md1 = s + (e - s) / 3, md2 = s + 2 * (e - s) / 3;
long long v1 = cost(m[md1], (w - m[md1]) / 2);
res = min(res, make_pair(v1, m[md1]));
if (s == e)
break;
else if (md1 == md2)
md2++;
long long v2 = cost(m[md2], (w - m[md2]) / 2);
res = min(res, make_pair(v2, m[md2]));
if (v1 <= v2) {
e = md2 - 1;
} else {
s = md1 + 1;
}
}
printf("%lld\n", res.first);
cost(res.second, (w - res.second) / 2, res.first);
for (int i = (0); i < (n); i++) {
printf("%d", tk[i]);
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long st(int n) {
long long an = 1;
for (int i = 1; i <= n; i++) an = (an * 3) % 1000000007;
return an;
}
int main() {
cin >> n;
long long v;
if (n % 2 == 0)
v = 3;
else
v = -3;
cout << ((st(n) + v) * 250000002) % 1000000007 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int U[5005], V[5005];
struct emm {
int a, b, x;
} a[5005];
bool cmp(emm x, emm y) { return x.x < y.x; }
struct Edge {
int v;
Edge *next;
} pool[5005 << 1], *h[5005];
int fa[5005], dep[5005], ans[5005];
int tot;
void addEdge(int u, int v) {
Edge *p = &pool[tot++];
p->v = v;
p->next = h[u];
h[u] = p;
}
void dfs(int u) {
for (Edge *p = h[u]; p; p = p->next) {
int v = p->v;
if (v == fa[u]) continue;
dep[v] = dep[u] + 1;
fa[v] = u;
dfs(v);
}
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
while (dep[u] > dep[v]) {
u = fa[u];
}
if (u == v) return u;
while (fa[u] != fa[v]) {
u = fa[u];
v = fa[v];
}
return fa[u];
}
void update(int u, int v, int x) {
if (u == v) return;
while (u != v) {
ans[u] = x;
u = fa[u];
}
}
int check(int u, int v) {
int res = 0x3f3f3f3f;
if (u == v) return res;
while (u != v) {
res = min(res, ans[u]);
u = fa[u];
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &U[i], &V[i]);
addEdge(U[i], V[i]);
addEdge(V[i], U[i]);
}
dep[1] = 1;
dfs(1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d%d", &a[i].a, &a[i].b, &a[i].x);
sort(a + 1, a + m + 1, cmp);
for (int i = 1; i <= m; i++) {
int t = LCA(a[i].a, a[i].b);
update(a[i].a, t, a[i].x);
update(a[i].b, t, a[i].x);
}
for (int i = 1; i <= m; i++) {
int t = LCA(a[i].a, a[i].b);
if (min(check(a[i].a, t), check(a[i].b, t)) != a[i].x) {
printf("-1\n");
return 0;
}
}
for (int i = 1; i < n; i++) {
if (dep[U[i]] < dep[V[i]]) swap(U[i], V[i]);
printf("%d ", max(ans[U[i]], 1));
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int n,bad[100000],deg[100000],ans[100000];
set<int> V; // unused vertices (and a centinel)
set<pair<int,int>> Deg; // (degree, vertex)
bool dfs(int i){
if(i==n) return true;
int x=Deg.rbegin()->second;
if(deg[x]==n-i-1){
if(i==0 || bad[ans[i-1]]!=x){
int y=bad[x];
bool b=V.count(y);
Deg.erase({deg[x],x});
if(b){
Deg.erase({deg[y],y});
deg[y]--;
Deg.emplace(deg[y],y);
}
V.erase(x);
ans[i]=x;
if(dfs(i+1)) return true;
V.emplace(x);
if(b){
Deg.erase({deg[y],y});
deg[y]++;
Deg.emplace(deg[y],y);
}
Deg.emplace(deg[x],x);
}
return false;
}
for(int x=*V.begin();x<n;x=*V.upper_bound(x)){
if(i==0 || bad[ans[i-1]]!=x){
int y=bad[x];
bool b=V.count(y);
Deg.erase({deg[x],x});
if(b){
Deg.erase({deg[y],y});
deg[y]--;
Deg.emplace(deg[y],y);
}
V.erase(x);
ans[i]=x;
if(dfs(i+1)) return true;
V.emplace(x);
if(b){
Deg.erase({deg[y],y});
deg[y]++;
Deg.emplace(deg[y],y);
}
Deg.emplace(deg[x],x);
}
}
return false;
}
int main(){
scanf("%d",&n);
rep(i,n) scanf("%d",&bad[i]), bad[i]--;
rep(i,n+1) V.emplace(i);
rep(i,n) deg[bad[i]]++;
rep(i,n) Deg.emplace(deg[i],i);
if(dfs(0)){
rep(i,n) printf("%d%c",ans[i]+1,i<n-1?' ':'\n');
}
else{
puts("-1");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 2) {
cout << "1\n0\n";
continue;
}
vector<long long> a = {1};
long long s = 1;
while (s < n) {
a.push_back(min(max(a.back(), n - s), 2 * a.back()));
s += a.back();
}
if (s > n) {
long long x = min(a.end()[-2] / 2, s - n);
a.end()[-2] -= x;
s -= x;
if (s > n) {
a.back() -= s - n;
assert(a.back() >= a.end()[-2]);
}
}
cout << a.size() - 1 << "\n";
for (size_t i = 1; i < a.size(); ++i)
cout << a[i] - a[i - 1] << " \n"[i + 1 == a.size()];
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while (t--)
{
long long x,y;
cin>>x>>y;
string s;
cin>>s;
long long r=0;
long long l=0;
long long u=0;
long long d=0;
for (long long i=0;i<s.size();i++)
{
if (s[i]=='R')
{
r++;
}
else if (s[i]=='U')
{
u++;
}
else if (s[i]=='D')
{
d++;
}
else if (s[i]=='L')
{
l++;
}
}
bool check=true;
if (r<x or x<(-1)*l or u<y or y<(-1)*d)
{
check=false;
}
if (!check)
{
cout<<"NO"<<endl;
}
else
{
cout<<"YES"<<endl;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define repp(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)
typedef long long LL;
typedef long double LD;
int main(){
int vs = 13;
vector<int> vx={1,1,1,1,1,1,1,1,1,0,0,0,0};
vector<int> vy={1,1,1,0,0,0,-1,-1,-1,1,1,1,0};
vector<int> vz={-1,0,1,-1,0,1,-1,0,1,-1,0,1,-1};
while(1){
int n,m,p;
cin >> n >> m >> p;
if(n==0) return 0;
vector<vector<vector<int>>> f(n,vector<vector<int>>(n,vector<int>(n,-1)));
int x,y;
int teban=0;
rep(t,p){
cin >> x >> y;
x--,y--;
int z;
rep(i,n){
if(f[x][y][i]==-1){
z=i;
break;
}
}
f[x][y][z]=teban;
rep(i,vs){
int count=1;
int nx=x,ny=y,nz=z;
while(1){
nx+=vx[i];
ny+=vy[i];
nz+=vz[i];
if(nx<0||n<=nx||ny<0||n<=ny||nz<0||n<=nz) break;
if(f[nx][ny][nz]!=teban) break;
count++;
}
nx=x,ny=y,nz=z;
while(1){
nx-=vx[i];
ny-=vy[i];
nz-=vz[i];
if(nx<0||n<=nx||ny<0||n<=ny||nz<0||n<=nz) break;
if(f[nx][ny][nz]!=teban) break;
count++;
}
if(count>=m){
cout << (teban?"White":"Black") SP t+1 << endl;
rep(j,p-t-1) cin >> x >> y;
goto next;
}
}
teban=1-teban;
}
cout << "Draw" << endl;
next:;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> p, in_time, out_time, level;
vector<vector<long long> > g;
long long k;
void dfs_time(long long node, long long parent, long long l) {
in_time[node] = k++;
p[node] = parent;
level[node] = l;
for (auto i : g[node]) {
if (i != parent) {
dfs_time(i, node, l + 1);
}
}
out_time[node] = k++;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
k = 1;
p.resize(n + 1);
in_time.resize(n + 1);
out_time.resize(n + 1);
level.resize(n + 1);
g.resize(n + 1, vector<long long>());
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs_time(1, 1, 0);
for (long long i = 0; i < m; i++) {
long long kk;
cin >> kk;
vector<long long> ans;
for (long long j = 0; j < kk; j++) {
long long x;
cin >> x;
ans.push_back(p[x]);
}
long long mx = in_time[ans[0]];
long long mn = out_time[ans[0]];
for (long long i = 1; i < ans.size(); i++) {
mx = max(mx, in_time[ans[i]]);
mn = min(mn, out_time[ans[i]]);
}
if (mx < mn)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char arr[505][505];
int dp[505][505];
int dpv[505][505];
int main() {
ios::sync_with_stdio(0);
int q, i, j, k, l, r, c, x, y, r1, c1, r2, c2, ans;
cin >> r >> c;
for (i = 1; i <= r; i++) {
for (j = 1; j <= c; j++) {
cin >> arr[i][j];
}
}
dp[1][1] = 0;
for (i = 2; i <= c; i++) {
if (arr[1][i] == '.' && arr[1][i - 1] == '.') {
dp[1][i] = dp[1][i - 1] + 1;
} else
dp[1][i] = dp[1][i - 1];
}
for (i = 2; i <= r; i++) {
dp[i][1] = dp[i - 1][1];
for (j = 2; j <= c; j++) {
if (arr[i][j] == '.' && arr[i][j - 1] == '.') {
dp[i][j] = dp[i][j - 1] + 1;
} else
dp[i][j] = dp[i][j - 1];
}
for (j = 1; j <= c; j++) {
dp[i][j] += dp[i - 1][j];
}
}
dpv[1][1] = 0;
for (i = 2; i <= r; i++) {
if (arr[i][1] == '.' && arr[i - 1][1] == '.') {
dpv[i][1] = dpv[i - 1][1] + 1;
} else
dpv[i][1] = dpv[i - 1][1];
}
for (i = 2; i <= c; i++) {
dpv[1][i] = dpv[1][i - 1];
for (j = 2; j <= r; j++) {
if (arr[j][i] == '.' && arr[j - 1][i] == '.') {
dpv[j][i] = dpv[j - 1][i] + 1;
} else
dpv[j][i] = dpv[j - 1][i];
}
for (j = 1; j <= r; j++) {
dpv[j][i] += dpv[j][i - 1];
}
}
cin >> q;
while (q--) {
cin >> r1 >> c1 >> r2 >> c2;
ans = dp[r2][c2] - dp[r2][c1] - dp[r1 - 1][c2] + dp[r1 - 1][c1];
ans += dpv[r2][c2] - dpv[r2][c1 - 1] - dpv[r1][c2] + dpv[r1][c1 - 1];
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int x, int y) { return x > y; }
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int a[n + 1];
for (int k = 1; k <= n; k++) cin >> a[k];
sort(a + 1, a + 1 + n, comp);
for (int k = 1; k <= n; k++) {
cout << a[k] << ' ';
}
cout << endl;
}
return 0;
}
| 2 |
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <stdint.h>
std::vector<int64_t> edges[100005];
int64_t as[100005];
void fail(){
printf("NO\n");
exit(0);
}
int64_t dfs(int64_t node,int64_t parent){
if(edges[node].size()==1&&node!=parent) return as[node];//leaf
int64_t ac=0;
int64_t max=0;
for(int64_t child:edges[node]){
if(child==parent) continue;
int64_t tmp=dfs(child,node);
ac+=tmp;
max=std::max(max,tmp);
}
if(max>as[node]||as[node]>ac||2*as[node]<ac) fail();
if(edges[node].size()==1) return 0;
//printf("%ld: %ld\n",node,2*as[node]-ac);
return 2*as[node]-ac;
}
int main(){
int64_t N;
scanf("%ld",&N);
for(int64_t i=0;i<N;i++){
scanf("%ld",&as[i]);
}
for(int64_t i=0;i<N-1;i++){
int64_t A,B;
scanf("%ld %ld",&A,&B);
A--,B--;
edges[A].push_back(B);
edges[B].push_back(A);
}
if(dfs(0,0)) fail();
printf("YES\n");
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int N; cin>>N;
N=1<<N;
vector<int> a(N);
for(int i=0;i<N;i++) cin>>a[i];
while(a.size()>1){
vector<int> b;
for(int i=0;i<a.size();i+=2){
if(a[i]==a[i+1]) b.push_back(a[i]);
else b.push_back(max(a[i],a[i+1])-min(a[i],a[i+1]));
}
a=b;
}
cout<<a[0]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x[100002] = {0}, j, t;
cin >> n;
t = n;
for (int i = 0; i < n; i++) {
cin >> j;
x[j] = 1;
while (t >= 1 && x[t] == 1) {
cout << t << " ";
t--;
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,a=99;
cin >> N;
for(int i=1; i<N; i++){
int e=100000,f=0;
for(; e!=1; e=e/10){
f+=i%e/(e/10)+(N-i)%e/(e/10);
}
a=min(a,f);
}
cout << a << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int n, a, b;
void f(int in, vector<int> cur) {
vector<int> temp;
int p, q;
for (int i = 0; i < cur.size(); i += 2) {
p = cur[i];
q = cur[i + 1];
if (p == a && q == b) {
if (cur.size() == 2)
printf("Final!\n");
else
printf("%d\n", in);
exit(0);
}
if (p == a || p == b)
temp.push_back(p);
else
temp.push_back(q);
}
f(in + 1, temp);
}
int main() {
cin >> n >> a >> b;
if (a > b) swap(a, b);
for (int i = 1; i <= n; i++) {
vec.push_back(i);
}
f(1, vec);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
char s[N][N];
int sum[N][N];
int get_sum(int x1, int y1, int x2, int y2) {
return sum[x2][y2] - sum[x2][y1 - 1] - sum[x1 - 1][y2] + sum[x1 - 1][y1 - 1];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++) {
if (s[i][j] == 'w') sum[i][j] = 1;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
if (sum[n][m] == 1) {
for (int i = 1; i <= n; i++) {
printf("%s", s[i] + 1);
cout << endl;
}
return 0;
}
int maxn = 0;
int x1 = -1, y1 = -1, x2 = -1, y2 = -1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == 'w') {
if (x1 == -1) x1 = i;
if (y1 == -1) y1 = j;
if (y1 > j) y1 = j;
if (x2 == -1) x2 = i;
if (x2 < i) x2 = i;
if (y2 == -1) y2 = j;
if (y2 < j) y2 = j;
}
maxn = max(x2 - x1, y2 - y1);
maxn++;
for (int i = 1; i + maxn - 1 <= n; i++) {
for (int j = 1; j + maxn - 1 <= m; j++) {
int tot = get_sum(i, j, i, j + maxn - 1) +
get_sum(i, j, i + maxn - 1, j) +
get_sum(i + maxn - 1, j, i + maxn - 1, j + maxn - 1) +
get_sum(i, j + maxn - 1, i + maxn - 1, j + maxn - 1);
if (s[i][j] == 'w') tot--;
if (s[i + maxn - 1][j] == 'w') tot--;
if (s[i][j + maxn - 1] == 'w') tot--;
if (s[i + maxn - 1][j + maxn - 1] == 'w') tot--;
if (tot != sum[n][m]) continue;
for (int k = j; k <= j + maxn - 1; k++) {
if (s[i][k] != 'w') s[i][k] = '+';
if (s[i + maxn - 1][k] != 'w') s[i + maxn - 1][k] = '+';
}
for (int k = i; k <= i + maxn - 1; k++) {
if (s[k][j] != 'w') s[k][j] = '+';
if (s[k][j + maxn - 1] != 'w') s[k][j + maxn - 1] = '+';
}
for (int k = 1; k <= n; k++) {
printf("%s", s[k] + 1);
cout << endl;
}
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int z;
long double a,b;
cin>>a;
cin>>b;
if(a>b)
cout<<"GREATER";
else if(b>a)
cout<<"LESS";
else
cout<<"EQUAL";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int i, j, k, n, t, m1, m2, p, q;
cin >> t;
while (t--) {
cin >> k >> n;
p = min(k, n);
q = max(k, n);
m1 = q - p;
m2 = (2 * p - q) * 2 / 3;
if (q >= 2 * p)
cout << p << endl;
else
cout << m1 + m2 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b % 2 != 0) ans *= a;
ans %= mod;
a = (a * a) % mod;
b /= 2;
}
ans %= mod;
return ans;
}
int main() {
long long x, k;
long long ans;
cin >> x >> k;
if (k == 0) {
ans = (x * 2) % mod;
} else {
if (x != 0) {
x %= mod;
ans = (x * qpow(2, k + 1) % mod - (qpow(2, k)) % mod + 1 + mod) % mod;
} else
ans = 0;
}
cout << ans << endl;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <math.h>
#include <vector>
#include <queue>
#include <algorithm>
#include <sstream>
#include <string>
using namespace std;
#define FOR(I,N) for(int I = 0; I < (int)(N); I++)
#define FIN(V) cout<<V<<endl
#define pb push_back
#define INF (1 << 30)
typedef pair<int, int> P;
int solve();
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int w, h, tx, ty, kx, ky;
int maps[52][52];
int memo[52][52][52][52];
struct Data{
P pt, pk;
int cnt;
Data(P pt_, P pk_, int cnt_){
pt = pt_;
pk = pk_;
cnt = cnt_;
}
Data(){}
};
int main(void){
while(cin >> w >> h, w){
cin >> tx >> ty;
cin >> kx >> ky;
fill_n(*maps, 52*52, 1);
FOR(i, h)FOR(j, w){
cin >> maps[i+1][j+1];
}
int a = solve();
if(a == -1 || a >= 100)FIN("NA");
else FIN(a);
}
return 0;
}
int solve(){
int ans = -1;
fill_n(***memo, 52*52*52*52, INF);
queue<Data> que;
que.push(Data(P(tx,ty), P(kx, ky), 0));
while(que.size()){
Data data = que.front();
que.pop();
int x1 = data.pt.first;
int y1 = data.pt.second;
int x2 = data.pk.first;
int y2 = data.pk.second;
int cost = data.cnt;
if(cost > 100)break;
if(memo[x1][y1][x2][y2] <= cost)continue;
memo[x1][y1][x2][y2] = cost;
if(x1 == x2 && y1 == y2){ans = cost;break;};
FOR(i, 4){
int nx1 = x1 + dx[i];
int ny1 = y1 + dy[i];
int nx2 = x2 - dx[i];
int ny2 = y2 - dy[i];
if(maps[ny1][nx1] == 1){nx1 = x1;ny1 = y1;};
if(maps[ny2][nx2] == 1){nx2 = x2;ny2 = y2;};
que.push(Data(P(nx1,ny1), P(nx2, ny2), cost+1));
}
}
return ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l, sum = 0, flag = 0, t, a[200005], ans = 0, m;
string s;
bool check(int first) {
long long ind = n - first, cnt = 1, cur = k;
for (; ind < n; ind++) {
if (a[ind] > k) return false;
if (a[ind] <= cur) {
cur -= a[ind];
} else {
cnt++;
cur = k - a[ind];
}
}
return cnt <= m;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long low = 0, high = n, mid = (low + high) / 2;
while (high - low > 1) {
if (check(mid))
low = mid;
else
high = mid;
mid = (low + high) / 2;
}
if (check(high))
cout << high << '\n';
else
cout << low << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Tuple {
int l, r, type, i;
} everything[2 * 100005];
bool cmp(Tuple x, Tuple y) {
if (x.l == y.l) {
if (x.type == y.type) {
return x.r < y.r;
} else {
return x.type < y.type;
}
}
return x.l < y.l;
}
int n, m;
int main() {
bool yes;
int i, k[100005], assignments[100005];
set<pair<int, int> > candidates;
set<pair<int, int> >::iterator it;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", &everything[i].l, &everything[i].r);
everything[i].i = i;
everything[i].type = 1;
}
scanf("%d", &m);
for (i = n; i < n + m; i++) {
scanf("%d %d %d", &everything[i].l, &everything[i].r, &k[i - n]);
everything[i].i = i - n;
everything[i].type = 0;
}
sort(everything, everything + n + m, cmp);
Tuple *cur;
yes = true;
for (i = 0; i < n + m; i++) {
cur = &everything[i];
if (cur->type == 0) {
candidates.insert(make_pair(cur->r, cur->i));
} else {
it = candidates.lower_bound(make_pair(cur->r, 0));
if ((*it).first >= cur->r) {
assignments[cur->i] = (*it).second + 1;
if (--k[(*it).second] == 0) candidates.erase(*it);
} else {
yes = false;
break;
}
}
}
if (yes) {
printf("YES\n");
for (i = 0; i < n; i++) printf("%d ", assignments[i]);
} else {
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, g;
int a[10010], v[10010];
struct Node {
int to, next, flow;
} Edge[10010 << 4];
int Head[10010 << 1], cnt_Edge = 1;
void add(int u, int v, int w) {
Edge[++cnt_Edge] = (Node){v, Head[u], w};
Head[u] = cnt_Edge;
}
void Add_Edge(int u, int v, int w) {
add(u, v, w);
add(v, u, 0);
}
int dep[10010 << 1], nhe[10010 << 1];
bool bfs(int s, int t) {
memset(dep, 0, sizeof(dep));
memcpy(nhe, Head, sizeof(nhe));
queue<int> Q;
Q.push(s);
dep[s] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = Head[u]; i; i = Edge[i].next) {
int v = Edge[i].to, w = Edge[i].flow;
if (!w || dep[v]) continue;
dep[v] = dep[u] + 1;
Q.push(v);
if (v == t) return true;
}
}
return false;
}
int dfs(int u, int flow, int t) {
int rest = flow;
if (u == t) return rest;
for (int i = nhe[u]; i && rest; i = Edge[i].next) {
nhe[u] = i;
int v = Edge[i].to, w = Edge[i].flow;
if (!w || dep[v] != dep[u] + 1) continue;
int now = dfs(v, min(rest, w), t);
if (!now) dep[v] = -1;
rest -= now;
Edge[i].flow -= now;
Edge[i ^ 1].flow += now;
}
return flow - rest;
}
int dinic(int s, int t) {
int ret = 0;
while (bfs(s, t)) {
int flow;
while ((flow = dfs(s, 0x3f3f3f3f, t))) ret += flow;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &g);
int S = n + m + 1, T = n + m + 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++) {
if (a[i])
Add_Edge(i, T, v[i]);
else
Add_Edge(S, i, v[i]);
}
int ans = 0;
for (int i = 1; i <= m; i++) {
int opt, w, k;
scanf("%d%d%d", &opt, &w, &k);
if (opt) {
for (int j = 1; j <= k; j++) {
int u;
scanf("%d", &u);
Add_Edge(u, n + i, 0x3f3f3f3f);
}
scanf("%d", &opt);
if (opt)
Add_Edge(n + i, T, w + g);
else
Add_Edge(n + i, T, w);
} else {
for (int j = 1; j <= k; j++) {
int u;
scanf("%d", &u);
Add_Edge(n + i, u, 0x3f3f3f3f);
}
scanf("%d", &opt);
if (opt)
Add_Edge(S, n + i, w + g);
else
Add_Edge(S, n + i, w);
}
ans += w;
}
printf("%d", ans - dinic(S, T));
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main() {
int A, B, C, X, Y;
scanf("%d%d%d%d%d", &A, &B, &C, &X, &Y);
printf("%d\n", min(A * X + B * Y, min(2 * C * max(X, Y), 2 * C * min(X, Y) + (X > Y ? A * (X - Y) : B * (Y - X)))));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
string word, s1, s2;
cin >> n >> m;
map<string, string> m1;
for (i = 0; i < m; i++) {
cin >> s1 >> s2;
m1[s1] = s2;
}
for (i = 0; i < n; i++) {
cin >> word;
if (word.length() <= m1[word].length())
cout << word << " ";
else
cout << m1[word] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> singlefactorise(long long int a) {
set<long long int> salman;
for (int i = 2; i * i <= a; i++) {
while (a % i == 0) {
salman.insert(i);
a /= i;
}
}
if (a != 1) salman.insert(a);
vector<long long int> kaif;
for (set<long long int>::iterator it = salman.begin(); it != salman.end();
it++)
kaif.push_back(*it);
return kaif;
}
long long int modularexpo(long long int x, long long int n) {
long long int result = 1;
while (n) {
if (n % 2 == 1) result = (result * x) % 1000000007;
x = (x * x) % 1000000007;
n = n / 2;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int x, n;
cin >> x >> n;
vector<long long int> v = singlefactorise(x);
long long int ans = 1;
for (int i = 0; i < v.size(); i++) {
long long int b = v[i];
long long int curr = 0;
long long int y = n;
while (y) {
y = y / b;
curr = curr + y;
}
ans =
((ans % 1000000007) * (modularexpo(b, curr) % 1000000007)) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <cstdio>
int main(){
int x;scanf("%d",&x);int y=x;
int s=0;
for(int i=0;i<9;i++){
s+=x%10;x/=10;
}
printf(y%s?"No\n":"Yes\n");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > neg;
vector<pair<int, int> > pos;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a < 0) {
neg.push_back({a, b});
} else {
pos.push_back({a, b});
}
}
sort(neg.rbegin(), neg.rend());
sort(pos.begin(), pos.end());
int ans = 0;
int mi = min(pos.size(), neg.size());
for (int i = 0; i < mi; i++) {
ans += neg[i].second;
ans += pos[i].second;
}
if (neg.size() > mi) {
ans += neg[mi].second;
} else if (pos.size() > mi) {
ans += pos[mi].second;
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, c = 0, e = 0, f = 0;
cin >> n;
char a[n][n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[0][0] == a[i][j] && i == j) c++;
if (a[0][0] == a[i][j] && i + j == n - 1) e++;
if (a[0][1] == a[i][j] && i != j && j != n - 1 - i) f++;
}
}
if ((c + e == n + n && f == (n * n) - (2 * n - 1)) && a[0][0] != a[0][1])
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, a[100100], b, ans;
int gcd(int v1, int v2) {
if (v1 == 0)
return v2;
else
return gcd(v2 % v1, v1);
}
int main() {
puts("YES");
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
if (i == 2) {
b = gcd(a[1], a[2]);
} else if (i > 2 && b > 1) {
b = gcd(b, a[i]);
}
}
if (b > 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i++) {
if (a[i] % 2) {
if (a[i + 1] % 2) {
ans++;
a[i + 1] = 2;
} else {
ans += 2;
}
}
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (int)2e5 + 74, OO = 0x3f3f3f3f, MOD = (int)1e9 + 7;
class CPermutations {
public:
void init() {}
void solve(istream& cin, ostream& cout) {
init();
int n;
cin >> n;
vector<int> a(n), b(n);
map<int, int> idx;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
idx[b[i]] = i;
}
int mx = 1;
for (int i = 1; i < n; i++) {
if (idx[a[i]] > idx[a[i - 1]])
++mx;
else
break;
}
cout << n - mx << '\n';
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
CPermutations solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, a, b;
vector<pair<int, int>> vp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
vp.push_back(make_pair(a, b));
}
sort(vp.begin(), vp.end());
int ans = 0;
for (int i = 0; i < vp.size(); i++) {
if (vp[i].second >= ans)
ans = vp[i].second;
else
ans = vp[i].first;
}
cout << ans << endl;
}
| 3 |
#include <iostream>
#include <string>
using namespace std;
int main() {
double l[10];
char c;
while(cin >> l[0] >> c) {
// ????????¨??????1?????????
int sum = l[0];
for(int i=1; i<10; i++) cin >> l[i] >> c, sum += l[i];
for(int i=0; i<10; i++) l[i] = l[i]/sum;
// ???????????????1?????????
double a, b;
double left;
cin >> a >> c >> b;
left = a/(a+b);
int t = 0;
double L = 0.0;
while( L < left ) {
L += l[t++];
}
cout << t << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 201;
const long long big = 1e18;
const long long block = 800;
const long long mod = 1e6;
long long n;
long long dp[3];
long long sob[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
sob[0] = dp[1] = dp[2] = big;
for (int i = 1; i <= n; i++) {
cin >> sob[i];
if (sob[i] == 0) {
dp[0] = min({dp[0], dp[1], dp[2]}) + 1;
dp[1] = big, dp[2] = big;
}
if (sob[i] == 1) {
long long x = min({dp[0], dp[1], dp[2]}) + 1;
long long y = min({dp[0], dp[2]});
dp[0] = x;
dp[1] = y;
dp[2] = big;
}
if (sob[i] == 2) {
long long x = min({dp[0], dp[1], dp[2]}) + 1;
long long y = min({dp[0], dp[1]});
dp[0] = x;
dp[2] = y;
dp[1] = big;
}
if (sob[i] == 3) {
long long x = min({dp[0], dp[1], dp[2]}) + 1;
long long y = min(dp[0], dp[2]);
long long z = min(dp[0], dp[1]);
dp[0] = x, dp[1] = y, dp[2] = z;
}
}
cout << min({dp[0], dp[1], dp[2]});
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int a[40] = {2, 3, 5, 7, 13, 17, 19,
31, 61, 89, 107, 127, 521, 607,
1279, 2203, 2281, 3217, 4253, 4423, 9689,
9941, 11213, 19937, 21701, 23209, 44497, 86243,
110503, 132049, 216091, 756839, 859433, 1257787, 1398269,
2976221, 3021377, 6972593, 13466917, 20996011};
int main() {
int n;
scanf("%d", &n);
int x = 1;
for (int i = 1; i < a[n - 1]; i++) {
x *= 2;
if (x >= MOD) x -= MOD;
}
printf("%d\n", (x + MOD - 1) % MOD);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, i = 0;
stack<char> f;
string n;
cin >> n;
l = n.length();
while (i < l) {
if (f.empty()) {
f.push(n[i]);
} else if (n[i] == f.top()) {
f.pop();
} else {
f.push(n[i]);
}
i++;
}
if (f.empty())
cout << "Yes";
else
cout << "No";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[200000];
int main() {
int i, j, n, x, y, tec, sqx, kol;
cin >> n;
for (i = 1; i <= n; i++) {
kol = 0;
cin >> x >> y;
sqx = sqrt((double)x) + 2;
for (j = 1; j <= sqx && j < x; j++)
if (x % j == 0) {
if (i - a[j] > y) kol++;
tec = x / j;
if (i - a[tec] > y && j != tec) kol++;
a[j] = i;
a[tec] = i;
}
cout << kol << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
input();
long long int t;
cin >> t;
while (t--) {
long long int p, f, cnts, cntw, s, w;
cin >> p >> f >> cnts >> cntw >> s >> w;
long long int ans = 0;
if (s > w) {
swap(s, w);
swap(cnts, cntw);
}
for (long long int i = 0; i <= cnts; i++) {
if (i * s > p) break;
long long int carry = min(cnts - i, f / s);
ans = max(ans,
i + carry + min((f - carry * s) / w + (p - i * s) / w, cntw));
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, l, h, mid, num, ind = -1, mn;
cin >> n >> k;
l = 1;
h = k - 1;
while (l <= h) {
mid = (l + h) / 2;
num = (mid * (mid + 1)) / 2 + 1;
if (num >= n) {
ind = mid;
h = mid - 1;
mn = num;
} else if (num < n)
l = mid + 1;
}
l = 0, h = k - 1;
while (l <= h) {
mid = (l + h) / 2;
num = (k * (k + 1)) / 2 - ((k - mid) * (k - mid + 1)) / 2 - mid + 1;
if (num >= n) {
if (mid < mn) {
mn = num;
ind = mid;
}
h = mid - 1;
} else if (num < n)
l = mid + 1;
}
cout << ind << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int T;
cin >> T;
while (T--) {
string s;
cin >> s;
sort(s.begin(), s.end());
int n = 1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == s[i + 1]) n++;
}
if (n == s.length()) {
cout << -1 << "\n";
continue;
}
cout << s << "\n";
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
const long long maxn = (long long)1e5 + 100;
const long long maxm = (long long)52;
const int LOGN = 22;
const long long INF = 1e13;
const long long MOD = 998244353;
const double PI = acos(-1.0);
const double EPS = 1e-12;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
while (cin >> n) {
vector<long long> a(n);
for (int i = 1; i < n; i += 2) cin >> a[i];
bool ok = true;
long long sum = 0;
long long last = 0;
for (int i = 1; i < n; i += 2) {
long long x = a[i];
bool find = false;
long long start = sqrt(x) + 2;
long long my1 = INF;
long long my2 = INF;
for (int d = start; d >= 1; --d)
if (x % d == 0) {
long long s = x / d;
if ((s + d) % 2 == 1) continue;
long long y2 = (s + d) / 2;
long long y1 = y2 - d;
if (y1 <= last) continue;
if (y2 < my2) {
my1 = y1;
my2 = y2;
}
}
if (my2 == INF) {
ok = false;
break;
}
a[i - 1] = my1 * my1 - sum;
sum = my2 * my2;
last = my2;
}
if (ok) {
cout << "Yes\n";
for (auto x : a) {
cout << x << " ";
}
cout << endl;
} else {
cout << "No\n";
}
}
return 0;
}
| 5 |
#include<cstdio>
#include<string>
#include<cstring>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
string solve(const string &s){
int n=s.length();
static int dp[2001][2001],from[2001][2001];
rep(i,n+1) dp[i][0]=dp[0][i]=0, from[i][0]=from[0][i]=-1;
rep(i,n) rep(j,n) if(i+j<=n) {
if(s[i]==s[n-j-1]){
dp[i+1][j+1]=dp[i][j]+1;
from[i+1][j+1]=2;
}
else{
if(dp[i][j+1]<dp[i+1][j]){
dp[i+1][j+1]=dp[i+1][j];
from[i+1][j+1]=1;
}
else{
dp[i+1][j+1]=dp[i][j+1];
from[i+1][j+1]=0;
}
}
}
int len=0,i_len[2];
for(int i=1;i<n;i++){
int tmp=2*dp[i][n-i];
if(len<tmp){
len=tmp;
i_len[0]=i;
i_len[1]=n-i;
}
tmp=2*dp[i][n-i-1]+1;
if(len<tmp){
len=tmp;
i_len[0]=i;
i_len[1]=n-i-1;
}
}
int idx=dp[i_len[0]][i_len[1]];
string ans(idx,'@');
for(int i=i_len[0],j=i_len[1];~from[i][j];){
switch(from[i][j]){
case 0: i--; break;
case 1: j--; break;
case 2: i--; j--; idx--; ans[idx]=s[i]; break;
}
}
if(len%2==1) ans+=s[i_len[0]];
rep(i,len/2) ans+=ans[len/2-i-1];
return ans;
}
int main(){
for(char s[2001];~scanf("%s",s);) puts(solve(s).c_str());
return 0;
} | 0 |
#include <bits/stdc++.h>
int parse1(char *s, char *s_, char ss[][16]) {
int h, hl, hr, j, l, r, c;
l = 0;
while (s[l] != '(') l++;
r = l;
while (s[r] != ')') r++;
hr = l - 1;
while (s[hr] <= ' ') hr--;
hl = hr;
while (hl >= 0 && s[hl] > ' ') hl--;
hl++;
memcpy(s_, s + hl, hr - hl + 1);
s_[hr - hl + 1] = '\0';
c = 0;
for (j = l + 1; j < r; j++)
if (s[j] == ',') c++;
l++;
for (h = 0; h <= c; h++) {
r = l;
while (s[r] != ',' && s[r] != ')') r++;
hl = l, hr = r - 1;
while (s[hl] <= ' ') hl++;
while (s[hr] <= ' ') hr--;
memcpy(ss[h], s + hl, hr - hl + 1);
ss[h][hr - hl + 1] = '\0';
l = r + 1;
}
return c + 1;
}
int main() {
static char s[128];
static char procedures[1000][16], parameters[1000 + 1][5][16], tt[5][16];
static int cnt[1000];
static char types[1000][16], names[1000][16];
int n, m, k, h, i, j;
fgets(s, 128, stdin);
n = atoi(s);
for (i = 0; i < n; i++) {
fgets(s, 128, stdin);
cnt[i] = parse1(s, procedures[i], parameters[i]);
}
fgets(s, 128, stdin);
m = atoi(s);
for (j = 0; j < m; j++) {
fgets(s, 128, stdin);
sscanf(s, "%s%s", types[j], names[j]);
}
fgets(s, 128, stdin);
k = atoi(s);
while (k--) {
static char name[16];
int c, ans, yes;
fgets(s, 128, stdin);
c = parse1(s, name, parameters[n]);
for (h = 0; h < c; h++)
for (j = 0; j < m; j++)
if (strcmp(names[j], parameters[n][h]) == 0) {
strcpy(tt[h], types[j]);
break;
}
ans = 0;
for (i = 0; i < n; i++) {
if (cnt[i] != c || strcmp(procedures[i], name) != 0) continue;
yes = 1;
for (h = 0; h < c; h++)
if (strcmp(parameters[i][h], "T") != 0 &&
strcmp(parameters[i][h], tt[h]) != 0) {
yes = 0;
break;
}
if (yes) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e12;
vector<string> split(const string &s, char c = '\"'){
vector<string> ret;
stringstream ss(s);
string t;
while(getline(ss, t, c)){
ret.push_back(t);
}
return ret;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
string s1, s2;
while(1){
cin >> s1;
if(s1 == ".") break;
cin >> s2;
vector<string> ss1 = split(s1);
vector<string> ss2 = split(s2);
if(ss1.size() != ss2.size()){
cout << "DIFFERENT" << endl;
continue;
}
int cnt = 0;
rep(i, 0, ss1.size()){
if(i % 2 == 0){
if(ss1[i] != ss2[i]) cnt += 2;
}else{
if(ss1[i] != ss2[i]) cnt++;
}
}
if(cnt == 0){
cout << "IDENTICAL" << endl;
}else if(cnt == 1){
cout << "CLOSE" << endl;
}else{
cout << "DIFFERENT" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, t, w, maxC = 0;
cin >> n >> m;
vector<vector<int>> candyDest(n, vector<int>());
for (int i = 0; i < m; ++i) {
cin >> t >> w;
candyDest[t - 1].push_back(w - 1);
maxC = max(maxC, (int)(candyDest[t - 1].size()));
}
vector<int> finalRound(n, INT_MIN);
for (int i = 0; i < n; ++i) {
if (candyDest[i].size() == maxC) {
int currMin = INT_MAX;
for (int j = 0; j < candyDest[i].size(); ++j) {
currMin = min(currMin, (candyDest[i][j] + n - i) % n);
}
finalRound[i] = currMin;
} else {
if (maxC > 1 && candyDest[i].size() == maxC - 1) {
int currMin = INT_MAX;
for (int j = 0; j < candyDest[i].size(); ++j) {
currMin = min(currMin, (candyDest[i][j] + n - i) % n);
}
finalRound[i] = currMin - n;
}
}
}
vector<int> minimumDistances(n, INT_MIN);
for (int startPos = 0; startPos < n; ++startPos) {
for (int ind = 0; ind < n; ++ind) {
if (finalRound[ind] != INT_MIN) {
int dist = (n + ind - startPos) % n + finalRound[ind];
minimumDistances[startPos] = max(dist, minimumDistances[startPos]);
}
}
}
for (auto i : minimumDistances) {
cout << (maxC - 1) * n + i << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e9);
const long long INF64 = (long long)(1e18);
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626433832795;
int main() {
int n, l, r;
scanf("%d", &n);
int arr[100005], result;
map<int, int> left;
map<int, int> right;
set<int> util;
scanf("%d", &arr[0]);
util.insert(arr[0]);
for (int i = 1; i < n; ++i) {
scanf("%d", &arr[i]);
set<int>::iterator it;
it = util.upper_bound(arr[i]);
if (it != util.end() && left.count(*it) == 0) {
left[*it] = arr[i];
result = *it;
} else {
--it;
right[*it] = arr[i];
result = *it;
}
util.insert(arr[i]);
cout << result << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000006;
int rnk[MAX], parent[MAX], ans[MAX], arr[MAX];
vector<int> comp[MAX];
priority_queue<int> q[MAX];
int find(int x) {
if (x == parent[x]) return x;
return parent[x] = find(parent[x]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rnk[x] > rnk[y])
parent[y] = x;
else {
parent[x] = y;
if (rnk[x] == rnk[y]) rnk[y]++;
}
}
int main() {
int n, m, a, b;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
parent[i] = i;
rnk[i] = 0;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
a--, b--;
merge(a, b);
}
int maxc = 0;
for (int i = 0; i < n; i++) {
comp[find(i)].push_back(i);
maxc = max(maxc, find(i));
q[find(i)].push(arr[i]);
}
for (int i = 0; i <= maxc; i++) {
for (int j = 0; j < comp[i].size(); j++) {
ans[comp[i][j]] = q[i].top();
q[i].pop();
}
}
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 400005;
struct edge {
int x, y;
} a[N];
int n, m, s, t, p, ds, dt, cnt, ans[N], d[N][2], fa[N];
template <class type>
inline void read(type &k) {
k = 0;
type t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
k *= t;
}
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
int i;
read(n);
read(m);
for (i = 1; i <= m; i++) read(a[i].x), read(a[i].y);
read(s);
read(t);
read(ds);
read(dt);
for (i = 1; i <= n; i++) fa[i] = i;
for (i = 1; i <= m; i++) {
if (a[i].x == s && a[i].y == t) p = i;
if (a[i].y == s && a[i].x == t) p = i;
}
for (i = 1; i <= m; i++) {
if (a[i].x == s || a[i].x == t || a[i].y == s || a[i].y == t) continue;
if (find(a[i].x) == find(a[i].y))
continue;
else
fa[find(a[i].y)] = find(a[i].x), ans[++cnt] = i;
}
for (i = 1; i <= m; i++) {
if (i == p) continue;
if (a[i].x == s || a[i].y == s)
d[find(a[i].x == s ? a[i].y : a[i].x)][0] = i;
if (a[i].x == t || a[i].y == t)
d[find(a[i].x == t ? a[i].y : a[i].x)][1] = i;
}
bool used = false;
for (i = 1; i <= n; i++) {
if (i == s || i == t) continue;
if (d[i][0] && !d[i][1]) ans[++cnt] = d[i][0], ds--;
if (!d[i][0] && d[i][1]) ans[++cnt] = d[i][1], dt--;
if (ds < 0 || dt < 0) {
puts("No");
return 0;
}
}
for (i = 1; i <= n; i++) {
if (d[i][0] && d[i][1]) {
if (!used) {
ans[++cnt] = d[i][0];
ds--;
ans[++cnt] = d[i][1];
dt--;
used = 1;
} else {
if (ds > 0)
ans[++cnt] = d[i][0], ds--;
else
ans[++cnt] = d[i][1], dt--;
}
}
if (ds < 0 || dt < 0) {
puts("No");
return 0;
}
}
if (!used) {
if (!p) {
puts("No");
return 0;
}
ds--;
dt--;
ans[++cnt] = p;
if (ds < 0 || dt < 0) {
puts("No");
return 0;
}
}
puts("Yes");
for (i = 1; i <= cnt; i++) printf("%d %d\n", a[ans[i]].x, a[ans[i]].y);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
long long int k;
cin >> n >> k;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
int ans = -1;
long long int l = 0, r = 2e9;
for (int i = 0; i < 60; i++) {
long long int m = l + (r - l) / 2;
int less = 0, right = 0, center = 0;
long long int money = 0;
vector<int> c;
for (auto &e : a) {
if (e.second < m) {
money += e.first;
} else if (e.first >= m) {
money += e.first;
right++;
} else if (e.first < m && m <= e.second) {
c.push_back(e.first);
}
}
int need = max(0, (n + 1) / 2 - right);
if (need > c.size()) {
r = m - 1;
} else {
for (int i = 0; i < c.size(); i++) {
if (i < c.size() - need)
money += c[i];
else
money += m;
}
if (money <= k) {
ans = m;
l = m + 1;
} else {
r = m - 1;
}
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
char s[n + 1];
int cnt[26] = {0};
scanf("%s", s);
for (int i = 0; i < n; i++) {
cnt[s[i] - 'a']++;
}
int remove[26] = {0};
for (int i = 0; i < 26; i++) {
if (k <= 0) {
break;
}
if (k >= cnt[i]) {
remove[i] = cnt[i];
k -= cnt[i];
} else {
remove[i] = k;
k = 0;
}
}
for (int i = 0; i < n; i++) {
if (remove[s[i] - 'a'] <= 0) {
printf("%c", s[i]);
} else {
remove[s[i] - 'a']--;
}
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 520;
char farm[N][N];
void dfs(int a, int b) {
if (farm[a + 1][b] == 'W' or farm[a - 1][b] == 'W' or farm[a][b + 1] == 'W' or
farm[a][b - 1] == 'W') {
cout << "No";
exit(0);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) farm[i][j + 1] = s[j];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (farm[i][j] == 'S') dfs(i, j);
}
cout << "Yes" << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (farm[i][j] == '.')
cout << "D";
else
cout << farm[i][j];
}
cout << endl;
}
}
| 1 |
/*---Don't look at the standing---*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 200004, mod = 1e9 + 7;
char a[N];
ll b[N], dp[505][505];
int j, n;
ll solve(int i, int cnt) {
if (cnt < 0) {
if (i > j)
return 0;
cnt = 0;
}
if (i == n)
return 1;
ll &ret = dp[i][cnt];
if (~ret)
return ret;
if (i == j) {
return ret = solve(i + 1, cnt) % 998244353;
}
if (a[i] == '-') {
ret = solve(i + 1, cnt - 1) + solve(i + 1, cnt) % 998244353;
} else {
if (b[i] < b[j] || (b[i] == b[j] && i < j)) {
ret = solve(i + 1, cnt + 1) + solve(i + 1, cnt) % 998244353;
} else
ret = 2 * solve(i + 1, cnt) % 998244353;
}
return ret % 998244353;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == '+')
cin >> b[i];
}
ll ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '+') {
memset(dp, -1, sizeof dp);
ll X = b[i];
j = i;
ans += 1ll * X * solve(0, 0);
ans %= 998244353;
}
}
cout << ans << endl;
} | 4 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
const long N = 1000;
long n;
std::cin >> n;
std::string s;
std::cin >> s;
bool possible(false);
for (long p = 0; p <= N; p++) {
long cur(0), cnt(0);
for (long q = 0; q < s.size(); q++) {
cur += s[q] - '0';
if (cur > p) {
break;
} else if (cur == p) {
cur = 0;
++cnt;
}
}
if ((cnt > 1) && (cur == 0)) {
possible = true;
break;
}
}
std::cout << (possible ? "YES" : "NO") << std::endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int n, m;
int i, j;
int ans;
vector<int> v1, v2;
scanf("%d", &t);
int flag = 0;
while (t--) {
v1.clear();
v2.clear();
flag = 0;
scanf("%d%d", &n, &m);
if (n == 0) {
ans = m + 1;
printf("%d\n", ans);
continue;
}
if (n > m) {
ans = 0;
printf("%d\n", ans);
continue;
}
int tmp = n;
while (tmp > 0) {
v1.push_back(tmp & 1);
tmp = tmp >> 1;
}
tmp = m;
while (tmp > 0) {
v2.push_back(tmp & 1);
tmp = tmp >> 1;
}
for (i = v1.size() - 1; i >= 0; i--) {
if (v1[i] == v2[i]) continue;
if (v1[i] > v2[i]) {
flag = 1;
break;
}
}
int l;
tmp = m + 1;
j = 0;
while (tmp > 0 && (tmp & 1) == 0) {
tmp = tmp >> 1;
j++;
}
ans = n ^ (m + 1);
l = i + 1;
ans = ans >> l;
ans = ans << l;
ans = ans >> j;
ans = ans << j;
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200006], b[200006], x[200006], nrel, t;
int main() {
cin >> nrel >> t;
for (int i = 1; i <= nrel; i++) cin >> a[i];
a[nrel + 1] = (long long)3000000000000000000 - 1;
for (int i = 1; i <= nrel; i++) cin >> x[i];
for (int i = 1; i <= nrel; i++)
if (x[i] < i or x[i] < x[i - 1]) {
cout << "No";
return 0;
}
for (int i = 1; i <= nrel; i++) {
while (x[i] == x[i + 1]) {
long long mini = t + a[i + 1];
b[i] = mini;
i++;
}
b[i] = t + a[i];
if (b[i] == b[i - 1]) b[i]++;
if (a[i + 1] + t <= b[i]) {
cout << "No";
return 0;
}
}
if (b[nrel] > (long long)3000000000000000000) {
cout << "No";
return 0;
}
for (int i = nrel; i >= 1; i--) {
int j = i;
while (a[j] + t <= b[j - 1]) j--;
for (int k = j; k <= i; k++)
if (x[k] != i) {
cout << "No";
return 0;
}
i = j;
}
cout << "Yes" << '\n';
for (int i = 1; i <= nrel; i++) cout << b[i] << ' ';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
int n, m;
vector<int> mat[N];
int d[N][N][2];
struct state {
int fir, sec;
bool is;
state(int f = 0, int s = 0, bool i = false) { fir = f, sec = s, is = i; }
} par[N][N][2];
queue<state> q;
vector<int> out[2];
void input() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--;
v--;
mat[v].push_back(u);
mat[u].push_back(v);
}
}
void init() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < 2; k++) d[i][j][k] = -1, par[i][j][k] = 0;
}
void process() {
state f(0, n - 1, 0);
q.push(f);
d[0][n - 1][0] = 0;
while (q.empty() == false) {
state u = q.front();
q.pop();
for (int i = 0; i < (int)mat[u.is == 0 ? u.fir : u.sec].size(); i++) {
int f = u.is == 0 ? mat[u.is == 0 ? u.fir : u.sec][i] : u.fir;
int s = u.is == 1 ? mat[u.is == 0 ? u.fir : u.sec][i] : u.sec;
state v(f, s, !u.is);
if (d[v.fir][v.sec][v.is] == -1) {
if (v.is == 1 && v.sec == u.fir) continue;
d[v.fir][v.sec][v.is] = d[u.fir][u.sec][u.is];
d[v.fir][v.sec][v.is] += (u.is == 1 ? 1 : 0);
par[v.fir][v.sec][v.is] = u;
q.push(v);
}
}
}
}
void output() {
out[0].push_back(0);
out[1].push_back(n - 1);
int f = n - 1, s = 0;
for (int i = 0; i < d[n - 1][0][0]; i++) {
s = par[f][s][0].sec;
f = par[f][s][1].fir;
out[0].push_back(s);
out[1].push_back(f);
}
cout << d[n - 1][0][0] << endl;
if (d[n - 1][0][0] == -1) return;
for (int i = 1; i >= 0; i--) {
for (int j = (int)out[i].size() - 1; j >= 0; j--)
cout << out[i][j] + 1 << " ";
cout << endl;
}
}
int main() {
input();
init();
process();
output();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long presum[200001];
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
sort(a, a + n);
reverse(a, a + n);
presum[0] = 0;
long long ans2 = 0;
for (int i = 1; i < n; i++) {
presum[i] = a[i] + presum[i - 1];
ans2 += a[i] * i;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int y;
scanf("%d", &y);
long long temp = y;
if (y == 1) {
printf("%I64d\n", ans2);
} else {
long long ans = 0;
long long x = y;
long long R = 0, L = 0;
long long p = 1;
while (1) {
R = L;
L = L + x;
x = x * temp;
if (L < n)
ans += (presum[L] - presum[R]) * p;
else {
ans += (presum[n - 1] - presum[R]) * p;
break;
}
p++;
}
printf("%I64d\n", ans);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, e = 0, d = 0;
cin >> n;
long long h[n + 1];
h[0] = 0;
for (long long i = 1; i < n + 1; i++) {
cin >> h[i];
}
for (long long i = 1; i < n + 1; i++) {
e = e + (h[i - 1] - h[i]);
if (e < 0) {
d = d - e;
e = 0;
}
}
cout << d << endl;
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, arr[N], preSum[N], sufSum[N], preMax[N], sufMax[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &arr[i]), preSum[i] = preSum[i - 1] + arr[i];
for (int i = n; i >= 1; i--) sufSum[i] = sufSum[i + 1] + arr[i];
for (int i = 1; i <= n; i++)
preMax[i] = max(preMax[i - 1] + arr[i], -preSum[i]);
for (int i = n; i >= 1; i--)
sufMax[i] = max(sufMax[i + 1] + arr[i], -sufSum[i]);
int out = -1e9;
for (int i = 0; i <= n; i++) out = max(out, preMax[i] + sufMax[i + 1]);
printf("%d\n", out);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt;
bool b[310], good[310];
int a[20], mask[310], d[310][110], kd[310], q[100010];
int aw[100010], ax[100010], ay[100010], az[100010];
int main() {
cin >> cnt;
for (int i = 0; i < 30; i++) b[i] = 0;
int need = 0;
for (int i = 0; i < cnt; i++) {
int foo;
cin >> foo;
need |= (1 << foo);
b[foo] = 1;
}
if (cnt > 6) {
cout << 0 << endl;
return 0;
}
int kg = 0;
for (int i = 0; i < 256; i++) {
good[i] = 1;
int x = i;
mask[i] = 0, kd[i] = 0;
while (x > 0) {
d[i][kd[i]++] = x % 10;
if (!b[x % 10]) good[i] = 0;
mask[i] |= (1 << (x % 10));
x /= 10;
}
if (i == 0 && !b[0]) good[i] = 0;
if (i == 0) {
d[i][kd[i]++] = 0;
mask[i] |= (1 << 0);
}
}
int ka = 0;
for (int w = 0; w < 256; w++)
if (good[w])
for (int x = 0; x < 256; x++)
if (good[x])
for (int y = 0; y < 256; y++)
if (good[y]) {
if ((mask[w] | mask[x] | mask[y]) != need) continue;
for (int z = 0; z < 256; z++)
if (good[z]) {
int u = 0;
for (int i = kd[w] - 1; i >= 0; i--) q[u++] = d[w][i];
for (int i = kd[x] - 1; i >= 0; i--) q[u++] = d[x][i];
for (int i = kd[y] - 1; i >= 0; i--) q[u++] = d[y][i];
for (int i = kd[z] - 1; i >= 0; i--) q[u++] = d[z][i];
int ok = 1;
for (int i = 0; i < u - i - 1; i++)
if (q[i] != q[u - i - 1]) {
ok = 0;
break;
}
if (ok) {
aw[ka] = w;
ax[ka] = x;
ay[ka] = y;
az[ka] = z;
ka++;
}
}
}
cout << ka << endl;
for (int i = 0; i < ka; i++)
printf("%d.%d.%d.%d\n", aw[i], ax[i], ay[i], az[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a, b, c, d, m, n;
scanf("%d%d%d%d", &a, &b, &c, &d);
n = (3 * a) / 10;
if ((a - (a / 250) * c) > n) n = a - (a / 250) * c;
m = (3 * b) / 10;
if ((b - (b / 250) * d) > m) m = b - (b / 250) * d;
if (n > m)
printf("Misha");
else if (m > n)
printf("Vasya");
else
printf("Tie");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const md = 998244353, R = 810127274, RI = 447056889, P2 = 1 << 23;
inline int pw(int x, int p) {
int an = 1;
while (p) {
if (p & 1) an = (long long)an * x % md;
x = (long long)x * x % md;
p >>= 1;
}
return an;
}
void ntt(vector<int> &v, bool inv = false) {
int n = v.size(), j = 0;
for (int i = 1; i < (int)(n); ++i) {
int z = n >> 1;
while (j & z) j ^= z, z >>= 1;
j ^= z;
if (i < j) swap(v[i], v[j]);
}
for (int m = 1; m < n; m <<= 1) {
int s = inv ? RI : R;
for (int i = m << 1; i < P2; i <<= 1) s = (long long)s * s % md;
for (int i = 0; i < n; i += m << 1) {
int w = 1;
for (int k = 0; k < (int)(m); ++k) {
int a = v[i + k], b = (long long)w * v[i + k + m] % md;
v[i + k] = a + b >= md ? a + b - md : a + b;
v[i + k + m] = a - b < 0 ? a - b + md : a - b;
w = (long long)w * s % md;
}
}
}
if (inv) {
int t = pw(n, md - 2);
for (int i = 0; i < (int)(n); ++i) v[i] = (long long)v[i] * t % md;
}
}
vector<int> ml(vector<int> const &a, vector<int> const &b) {
vector<int> v1(a.begin(), a.end()), v2(b.begin(), b.end());
int mxn = max(a.size(), b.size()), n = 1;
while (n < mxn) n <<= 1;
n <<= 1;
v1.resize(n), v2.resize(n);
ntt(v1), ntt(v2);
for (int i = 0; i < (int)(n); ++i) v1[i] = (long long)v1[i] * v2[i] % md;
ntt(v1, true);
v1.resize(a.size() + b.size() - 1);
return v1;
}
int const B = 19, N = 300000;
int x[N], tp[N + 1], an[(N << 1 | 1) + 100], fc[N + 1], inv[N + 1], fcin[N + 1],
p2[N + 1];
inline void ad(int &x, int y) {
if ((x += y) >= md) x -= md;
}
inline int ch(int n, int r) {
return (long long)fc[n] * fcin[r] % md * fcin[n - r] % md;
}
vector<int> goa(int n) {
vector<int> an(n + 1);
for (int i = 0; i < (int)(n + 1); ++i)
an[i] = (long long)ch(n, i) * p2[i] % md;
return an;
}
vector<int> gob(int n) {
n <<= 1;
vector<int> an(n + 1);
for (int i = 0; i < (int)(n + 1); ++i) an[i] = ch(n, i);
return an;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
fc[0] = 1;
for (int i = 1; i < (int)(n + 1); ++i) fc[i] = (long long)fc[i - 1] * i % md;
inv[1] = 1;
for (int i = 2; i < (int)(n + 1); ++i)
inv[i] = md - md / i * (long long)inv[md % i] % md;
fcin[0] = 1;
for (int i = 1; i < (int)(n + 1); ++i)
fcin[i] = (long long)fcin[i - 1] * inv[i] % md;
p2[0] = 1;
for (int i = 1; i < (int)(n + 1); ++i) ad(p2[i] = p2[i - 1], p2[i - 1]);
for (int i = 0; i < (int)(n); ++i) scanf("%d", x + i);
sort(x, x + n);
for (int i = 0; i < (int)(n); ++i) {
int j = i;
while (j + 1 < n && x[j + 1] == x[j]) ++j;
if (j == i)
tp[x[i]] = 1;
else
tp[x[i]] = 2;
i = j;
}
for (int i = 0; i < (int)(k); ++i) {
int z, a = 0, b = 0;
scanf("%d", &z);
for (int i = 1; i < (int)(z); ++i)
if (tp[i] == 1)
++a;
else if (tp[i] == 2)
++b;
vector<int> v = ml(goa(a), gob(b));
for (int i = 0; i < (int)(v.size()); ++i) ad(an[i + z + 1], v[i]);
}
int q;
scanf("%d", &q);
while (q--) {
int t;
scanf("%d", &t);
printf("%d\n", an[t >> 1]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
class Trie {
public:
Trie *trie[26];
bool win, lose;
void add_word(string &s, int pos) {
if (pos == s.size()) return;
if (trie[s[pos] - 'a'] == nullptr) {
trie[s[pos] - 'a'] = new Trie();
}
trie[s[pos] - 'a']->add_word(s, pos + 1);
}
void solve() {
bool can_win = false, can_lose = false;
int num = 0;
for (int i = 0; i < 26; ++i) {
if (trie[i] != nullptr) {
num++;
trie[i]->solve();
can_win |= !(trie[i]->win);
can_lose |= !(trie[i]->lose);
}
}
lose = can_lose | (num == 0);
win = can_win;
}
};
int main(void) {
Trie *head = new Trie();
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> s;
head->add_word(s, 0);
}
head->solve();
if (head->win && head->lose) {
cout << "First" << endl;
} else if (head->win) {
if (k % 2 == 1)
cout << "First" << endl;
else
cout << "Second" << endl;
} else if (!(head->win)) {
cout << "Second" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 28;
int main () {
int n; cin >> n;
string S, T;
cin >> S >> T;
vector<int> s(256), t(256);
for (int i = 0; i < n; i++) {
s[S[i]]++;
t[T[i]]++;
}
sort(s.begin(), s.end(), greater<int>());
sort(t.begin(), t.end(), greater<int>());
int res = 0;
for (int i = 0; i < t.size() && i < s.size(); i++) {
res += abs(t[i] - s[i]);
}
cout << res / 2 << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
while (cin >> x) {
long long i, a, b, arr[10005];
for (i = 1; i <= x; i++) {
arr[i] = i;
}
for (a = 1; a <= x; a++) {
for (b = 1; b <= x; b++) {
if (a % b == 0 && a * b > x && a / b < x) {
cout << a << " " << b << endl;
return 0;
}
}
}
cout << "-1" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2;
return 0;
}
bool f = 0;
long long k = 0;
for (long long i = 3; i * i <= n; i++) {
if (n % i == 0) {
f = 1;
k = i;
break;
}
}
if (f) {
cout << (1 + (n - k) / 2);
return 0;
} else {
cout << 1;
return 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
scanf("%d %d\n", &n, &m);
int k = 0;
for (int i = 0; i * i <= n; i++) {
for (int j = 0; j * j <= m; j++) {
if (i * i + j == n && j * j + i == m) {
k++;
}
}
}
printf("%d\n", k);
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int T;
char s[111], a[111];
int len;
bool is_upper(char c) { return 'A' <= c && c <= 'Z'; }
bool is_lower(char c) { return 'a' <= c && c <= 'z'; }
bool is_num(char c) { return '0' <= c && c <= '9'; }
bool chk() {
bool up = false, lo = false, num = false;
for (int i = 0; i < len; i++) {
if (is_upper(s[i])) up = true;
if (is_lower(s[i])) lo = true;
if (is_num(s[i])) num = true;
}
return up && lo && num;
}
char get_ch(char c, int op) {
if (op == 0) return c;
if (op == 1) return '0';
if (op == 2) return 'A';
if (op == 3) return 'a';
}
int proc(int i, int opi, int j, int opj) {
char ti = s[i], tj = s[j];
int v = ((opi == 0) ? 0 : 1) + ((opj == 0) ? 0 : 1);
s[i] = get_ch(s[i], opi);
s[j] = get_ch(s[j], opj);
int res = chk() ? v : 3;
s[i] = ti;
s[j] = tj;
return res;
}
int main() {
for (scanf("%d", &T); T--;) {
scanf("%s", s);
len = strlen(s);
int ans = 3;
for (int i = 0; i < len; i++)
for (int j = i + 1; j < len; j++)
for (int opi = 0; opi < 4; opi++)
for (int opj = 0; opj < 4; opj++) {
int t = proc(i, opi, j, opj);
if (t < ans) {
ans = t;
memcpy(a, s, (len + 1) * sizeof(char));
a[i] = get_ch(a[i], opi);
a[j] = get_ch(a[j], opj);
}
}
printf("%s\n", a);
}
return 0;
}
| 1 |
/*input
4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999
*/
#include <bits/stdc++.h>
using namespace std;
int n,k;
pair<long long,long long> a[1000005];
long long check(int x, int y){
long long l=a[y].first-a[x].first,w=1e18;
vector<long long> v;
for(int i=x;i<=y;++i)
v.push_back(a[i].second);
sort(v.begin(),v.end());
for(int i=k-1;i<v.size();++i)
w=min(w,v[i]-v[i-k+1]);
return l*w;
}
int main(){
#ifdef ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
#endif
long long ans=5e18,sum=0,p,x,y;
cin>>n>>k;
for(int i=0;i<n;++i){
cin>>a[i].first>>a[i].second;
}
sort(a,a+n);
for(int i=0;i<n;++i)
for(int j=i+k-1;j<n;++j)
ans=min(ans,check(i,j));
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
bool eq(string a, string b) {
for (int i = 0; i < a.length(); i++) {
if (a[i] == '1' || b[i] == '1') continue;
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
string s;
cin >> s;
int k;
cin >> k;
int n = s.length() + k, m;
for (int i = 0; i < k; i++) s += '1';
if (n % 2 == 0)
m = n / 2;
else
m = (n - 1) / 2;
string a = "", b = "";
for (int j = m; j >= 1; j--) {
for (int i = 0; i + 2 * j <= n; i++) {
a = s.substr(i, j);
b = s.substr(i + j, j);
if (eq(a, b)) {
cout << 2 * j << endl;
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long double C[2050][2050], sum[2050], ans;
int n, m, d[2050];
double Ans;
inline int Read() {
int x = 0;
char y;
bool z = 0;
do y = getchar(), z |= y == '-';
while (y < '0' || y > '9');
do x = x * 10 + y - '0', y = getchar();
while (y >= '0' && y <= '9');
return z ? -x : x;
}
int main() {
n = Read();
m = Read();
for (int i = 1; i < n; i++)
for (int j = i + 1; j <= n; j++) {
int k = Read();
if (k == -1) continue;
d[i]++;
d[j]++;
sum[i] += k;
sum[j] += k;
}
for (int i = 0; i <= n; i++) C[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
for (int i = 1; i <= n; i++) ans += sum[i] * C[d[i] - 1][m - 1];
ans /= C[n][m];
Ans = (double)ans - 0.5;
if (Ans < 0) Ans = 0;
printf("%.0lf\n", Ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long w, b, x;
long long bi[1009];
long long co[1009];
long long dp[1009][10009];
int main() {
scanf("%d%I64d%I64d%I64d", &n, &w, &b, &x);
long long sm = 0;
for (int i = 1; i <= n; i++) scanf("%I64d", bi + i), sm += bi[i];
for (int i = 1; i <= n; i++) scanf("%I64d", co + i);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= sm; j++) dp[i][j] = -1;
for (long long i = 0; i <= bi[1]; i++)
if (i * co[1] <= w) dp[1][i] = w - i * co[1];
for (int i = 2; i <= n; i++) {
for (long long j = 0; j <= sm; j++) {
for (long long k = 0; k <= bi[i]; k++) {
if (dp[i - 1][j] != -1) {
long long y = dp[i - 1][j];
y = min(y + x, j * b + w);
if (y >= k * co[i]) dp[i][j + k] = max(dp[i][j + k], y - k * co[i]);
}
}
}
}
for (int i = sm; i >= 1; i--)
if (dp[n][i] != -1) return printf("%d\n", i), 0;
puts("0");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, p = 0;
string x;
int main() {
cin >> t;
while (t--) {
cin >> x;
p += (x.size() + 1) * x.size() / 2;
p += ((int)x[0] - 49) * 10;
cout << p << "\n";
p = 0;
}
}
| 1 |
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
class Edge
{
public:
int to, cap, rev;
Edge(){};
Edge(int to0, int cap0){to = to0; cap = cap0;}
Edge(int to0, int cap0, int rev0){to = to0; cap = cap0; rev = rev0;}
};
int maxFlow(const vector<vector<Edge> >& edges0, int source, int sink)
{
static vector<vector<Edge> > edges;
static vector<unsigned> index;
static vector<int> level;
static int n;
class Func{
public:
static void bfs(int s){
level.assign(n, -1);
queue<int> q;
level[s] = 0;
q.push(s);
while(!q.empty()){
int v = q.front();
q.pop();
for(unsigned i=0; i<edges[v].size(); ++i){
Edge& e = edges[v][i];
if(e.cap > 0 && level[e.to] < 0){
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
static int dfs(int s, int t, int f){
if(s == t)
return f;
for(unsigned& i=index[s]; i<edges[s].size(); ++i){
Edge& e = edges[s][i];
if(e.cap > 0 && level[s] < level[e.to]){
int g = dfs(e.to, t, min(f, e.cap));
if(g > 0){
e.cap -= g;
edges[e.to][e.rev].cap += g;
return g;
}
}
}
return 0;
}
};
n = edges0.size();
edges.assign(n, vector<Edge>());
for(int i=0; i<n; ++i){
for(unsigned j=0; j<edges0[i].size(); ++j){
const Edge& e = edges0[i][j];
edges[i].push_back(Edge(e.to, e.cap, edges[e.to].size()));
edges[e.to].push_back(Edge(i, 0, edges[i].size()-1));
}
}
int ret = 0;
for(;;){
Func::bfs(source);
if(level[sink] < 0)
return ret;
index.assign(n, 0);
int f;
while((f = Func::dfs(source, sink, INT_MAX)) > 0)
ret += f;
}
return 0;
}
int main()
{
for(;;){
int n;
cin >> n;
if(n == 0)
return 0;
int m;
cin >> m;
map<int, int> index;
for(int i=0; i<m; ++i){
int a;
cin >> a;
index[a] = i;
}
vector<vector<Edge> > edges(n+m+2);
for(int i=1; i<=n; ++i)
edges[0].push_back(Edge(i, 1));
for(int i=n+1; i<=n+m; ++i)
edges[i].push_back(Edge(n+m+1, 1));
for(int i=0; i<n; ++i){
int x;
cin >> x;
for(int j=0; j<x; ++j){
int a;
cin >> a;
if(index.find(a) != index.end())
edges[1+i].push_back(Edge(n+1+index[a], 1));
}
}
cout << maxFlow(edges, 0, m+n+1) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
inline void chmax(int& x, int y) {
if (x < y) x = y;
}
inline void chmin(int& x, int y) {
if (x > y) x = y;
}
inline int LSB(int i) { return (i & -i); }
long long n, m, k, pw[100];
long long Pow(long long a, long long b) {
long long ret = 1, mult = a;
while (b) {
if (b & 1) ret *= mult;
b >>= 1;
mult *= mult;
mult %= MOD;
ret %= MOD;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m >> k;
if ((n + m) & 1 && k == -1) {
cout << 0 << endl;
return 0;
}
cout << (Pow(Pow(2, n - 1), m - 1)) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (k); i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) begin(a),end(a)
#define MS(m,v) memset(m,v,sizeof(m))
#define D10 fixed<<setprecision(5)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<short, short> P;
typedef complex<double> Point;
typedef long long ll;
const int INF = 1145141919;
const int MOD = 100000007;
const double EPS = 1e-10;
const double PI = acos(-1.0);
struct edge
{
int from, to, cost;
bool operator < (const edge& e) const { return cost < e.cost; }
bool operator > (const edge& e) const { return cost > e.cost; }
};
///*************************************************************************************///
///*************************************************************************************///
///*************************************************************************************///
int main()
{
string s; int n;
cin >> s >> n;
ll mul = 0; ll ltr = s[0]-'0';
int l = s.size();
FOR(i,2, l)
{
if (isdigit(s[i]))
{
if (s[i - 1] == '+') ltr += s[i]-'0';
else ltr *= s[i]-'0';
}
}
vector<ll> v;
REP(i, l)
{
if (isdigit(s[i])) v.push_back(s[i] - '0');
else if (s[i] == '+') v.push_back(-1);
else v.push_back(-2);
}
bool update = true;
while (update)
{
update = false;
REP(i, v.size())
{
if (v[i] == -2)
{
update = true;
v[i - 1] = v[i - 1] * v[i + 1];
v.erase(v.begin() + i);
v.erase(v.begin() + i);
}
}
}
REP(i, v.size()) if (v[i] >= 0) mul += v[i];
if (n == mul&&n == ltr) puts("U");
else if (n == mul) puts("M");
else if (n == ltr) puts("L");
else puts("I");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dist[30][30];
int main() {
int i, j, k;
int n, m;
int u, v;
for (i = 0; i < 30; i++) {
for (j = 0; j < 30; j++) dist[i][j] = 100000000;
}
for (i = 0; i < 30; i++) dist[i][i] = 0;
string s, t;
cin >> s >> t;
if (s.length() != t.length()) {
cout << "-1";
return 0;
}
cin >> n;
char c1, c2, c3;
while (n--) {
cin >> c1 >> c2 >> k;
dist[c1 - 'a'][c2 - 'a'] = min(dist[c1 - 'a'][c2 - 'a'], k);
}
for (k = 0; k < 26; k++) {
for (i = 0; i < 26; i++) {
for (j = 0; j < 26; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
n = s.length();
int cost = 0, mn;
for (i = 0; i < n; i++) {
if (s[i] != t[i]) {
mn = 100000000;
c3 = '#';
for (j = 'a'; j <= 'z'; j++) {
k = dist[s[i] - 'a'][j - 'a'] + dist[t[i] - 'a'][j - 'a'];
if (k <= mn) mn = k, c3 = j;
}
cost += mn;
s[i] = t[i] = c3;
if (mn >= 100000000) {
cout << "-1";
return 0;
}
}
}
cout << cost << endl;
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void setmin(int &x, int y) {
if (y < x) x = y;
}
inline void setmax(int &x, int y) {
if (y > x) x = y;
}
inline void setmin(long long &x, long long y) {
if (y < x) x = y;
}
inline void setmax(long long &x, long long y) {
if (y > x) x = y;
}
const int N = 2000;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
void add(long long &x, long long y) {
x += y;
if (x >= MOD) x -= MOD;
}
long long dp[N + 1][N + 1][3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
int n, k;
cin >> n >> k;
string s;
cin >> s;
dp[0][0][0] = 1;
for (int i = 1; i < n + 1; i++)
for (int j = 0; j < k + 1; j++) {
add(dp[i][j][0], (dp[i - 1][j][0] + dp[i - 1][j][1] + dp[i - 1][j][2]) *
(s[i - 1] - 'a') % MOD);
add(dp[i][j][1],
(dp[i - 1][j][0] + dp[i - 1][j][1] + dp[i - 1][j][2]) % MOD);
for (int l = i - 1; l > -1; l--)
if ((n - i + 1) * (i - l) > j)
break;
else
add(dp[i][j][2], (dp[l][j - (n - i + 1) * (i - l)][0] +
dp[l][j - (n - i + 1) * (i - l)][2]) *
('z' - s[i - 1]) % MOD);
}
cout << (dp[n][k][0] + dp[n][k][1] + dp[n][k][2]) % MOD << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<vector<int> > g, int s, vector<bool> &vis) {
vis[s] = true;
for (int i = 0; i < g[s].size(); i++) {
if (!vis[g[s][i]]) {
dfs(g, g[s][i], vis);
}
}
}
int findComponents(vector<vector<int> > g) {
int t = 0;
vector<bool> vis(g.size(), false);
for (int i = 0; i < vis.size(); i++) {
if (!vis[i]) {
dfs(g, i, vis);
t++;
}
}
return t;
}
void update(vector<vector<int> > &g1, vector<int> a, vector<vector<bool> > &c) {
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a.size(); j++) {
if (i != j && !c[a[i]][a[j]]) {
c[a[i]][a[j]] = true;
g1[a[i]].push_back(a[j]);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > g(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) {
int t;
cin >> t;
for (int j = 0; j < t; j++) {
int k;
cin >> k;
g[i][k - 1]++;
}
}
vector<vector<int> > g1(n, vector<int>());
vector<vector<bool> > c(n, vector<bool>(n, false));
for (int i = 0; i < m; i++) {
vector<int> a;
for (int j = 0; j < n; j++) {
if (g[j][i]) {
a.push_back(j);
}
}
if (a.size() > 1) {
update(g1, a, c);
}
}
int tt = 0;
for (int i = 0; i < n; i++) {
int l = 0;
for (int j = 0; j < m; j++) {
if (g[i][j] == 0) {
l++;
}
}
if (l == m) {
tt++;
}
}
int t = findComponents(g1);
if (tt == t) {
cout << t << endl;
} else {
cout << t - 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fact(int a) { return a == 0 ? 1ll : a * fact(a - 1); }
long long gcd(long long a, long long b) { return a == b ? a : gcd(b % a, a); }
long long C(int n, int k) { return k == 0 ? 1ll : C(n - 1, k - 1) * n / k; }
long long toInt(string s) {
istringstream iss(s);
long long ret;
iss >> ret;
return ret;
}
template <class T>
string toString(T x) {
ostringstream oss;
oss << x;
return oss.str();
}
int main() {
int n, m, a[101], b[101];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int j = 0; j < m; j++) scanf("%d", &b[j]);
sort(a, a + n);
sort(b, b + m);
int v = ((a[n - 1]) > (a[0] * 2) ? (a[n - 1]) : (a[0] * 2));
if (b[0] <= v)
puts("-1");
else
printf("%d\n", v);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
long long ans = INT64_MAX;
long long dif(long long a, long long b, long long c) {
return max(a, max(b, c))-min(a, min(b, c));
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
long long H, W;
cin >> H >> W;
long long A, B, C;
for (int i = 0; i < 2; i++, swap(H, W)) {
if (H%3 == 0) ans = 0;
else {
ans = min(ans, W);
A = (H/3+H%3-1)*W;
B = (H/3*2+1)*(W/2+W%2);
C = (H/3*2+1)*(W/2);
ans = min(ans, dif(A, B, C));
}
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, d, ct = 0;
string str;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> str >> d;
if (str[0] == '+') {
x += d;
} else {
if (x - d >= 0) {
x -= d;
} else {
ct++;
}
}
}
cout << x << " " << ct;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void err(istringstream *iss) {}
template <typename T, typename... Args>
void err(istringstream *iss, const T &varVal, const Args &...args) {
string varName;
*iss >> varName;
if (varName.back() == ',') varName.back() = ' ';
cout << varName << " = " << varVal << "; ", err(iss, args...);
}
int n, m, K, T, Q, cn;
int lcm[] = {0, 1, 2, 6, 12, 60, 60, 420,
840, 2520, 2520, 27720, 27720, 360360, 360360, 360360};
long long a, b;
long long func(long long hi, long long lo) {
long long ret = 0;
while (hi > lo) {
long long mx = 1;
for (int i = 2; i <= K; i++) {
if (hi % i <= hi - lo) mx = max(mx, hi % i);
}
hi -= mx;
ret++;
}
return ret;
}
int main() {
cin.tie(NULL);
scanf("%lld%lld%d", &a, &b, &K);
int l = lcm[K];
long long x = ((b - 1) / l + 1) * l, y = a / l * l;
printf("%lld\n", a - b <= l ? func(a, b)
: func(x, b) + (y / l - x / l) * func(x + l, x) +
func(a, y));
return 0;
}
| 5 |
#include <bits/stdc++.h>
char A[50][50];
int main() {
int n;
std::cin >> n;
int fr_i = n + 1;
int to_i = -1;
int fr_j = n + 1;
int to_j = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
std::cin >> A[i][j];
if (A[i][j] == '4') {
fr_i = std::min(fr_i, i);
to_i = std::max(to_i, i);
fr_j = std::min(fr_j, j);
to_j = std::max(to_j, j);
}
}
}
bool test = ((fr_i <= to_i) && (fr_j <= to_j));
for (int i = 0; i < n && test; ++i) {
for (int j = 0; j < n && test; ++j) {
if (i == fr_i - 1 || i == to_i + 1) {
if (j == fr_j - 1 || j == to_j + 1) {
test = (A[i][j] == '1');
} else if (fr_j <= j && j <= to_j) {
test = (A[i][j] == '2');
} else {
test = (A[i][j] == '0');
}
} else if (fr_i <= i && i <= to_i) {
if (j == fr_j - 1 || j == to_j + 1) {
test = (A[i][j] == '2');
} else if (fr_j <= j && j <= to_j) {
test = (A[i][j] == '4');
} else {
test = (A[i][j] == '0');
}
} else {
test = (A[i][j] == '0');
}
}
}
std::cout << (test ? "Yes" : "No") << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[33], b[33], k[33], p[33], u, r, n;
long long an = -1000000000000000000ll;
set<pair<long long, int> > H;
void dfs(int x, int ha[], long long yo) {
if (H.count(make_pair(yo, x))) return;
H.insert(make_pair(yo, x));
int i;
if (!(x & 1)) {
long long tmp = 0;
for (i = 1; i <= n; i++) tmp += ha[i] * k[i];
an = max(an, tmp);
}
if (!x) return;
int c[33];
for (i = 1; i <= n; i++) c[i] = ha[p[i]] + r;
for (i = 1; i <= x; i += 2) dfs(x - i, c, yo << 1);
for (i = 1; i <= n; i++) ha[i] ^= b[i];
if (x & 1) {
long long tmp = 0;
for (i = 1; i <= n; i++) tmp += ha[i] * k[i];
an = max(an, tmp);
}
for (i = 1; i <= n; i++) c[i] = ha[p[i]] + r;
for (i = 2; i <= x; i += 2) dfs(x - i, c, (yo << 1) + 1);
}
int main() {
int i, j;
scanf("%d%d%d", &n, &u, &r);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) scanf("%d", &k[i]);
for (i = 1; i <= n; i++) scanf("%d", &p[i]);
dfs(u, a, 0);
cout << an << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, q;
cin >> n;
vector<int> s(n);
rep(i,n) cin >> s[i];
int ct = 0;
cin >> q;
rep(i,q) {
int left = 0;
int right = n-1;
int x;
cin >> x;
if (*lower_bound(s.begin(),s.end(),x) == x) ct++;
}
cout << ct << endl;
}
| 0 |
#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
#define REP(i,n) for(int i = 0; i < (int)(n); i++)
int main() {
int T; cin >> T >> ws;
while(T--) {
string buf;
getline(cin, buf);
// cout << buf << endl;
// i == buf.size()ÆÈé±Æà éB
// eof <=> i == buf.size()
int i = 0;
int M; cin >> M >> ws;
REP(m, M) {
string line;
string command, op;
getline(cin, line);
int j = 0;
for(j = 0; line[j] != ' '; j++);
command = line.substr(0, j);
op = line.substr(j + 1);
// cout << command << " " << op << endl;
if( command == "forward" ) {
if( op == "word" ) {
while( i < buf.size() && buf[i] == ' ' ) i++;
while( i < buf.size() && buf[i] != ' ' ) i++;
} else if( op == "char" ) {
if( i != buf.size() ) i++;
}
}
if( command == "backward" ) {
if( op == "word" ) {
i--;
while( i >= 0 && buf[i] == ' ' ) i--;
while( i >= 0 && buf[i] != ' ' ) i--;
i++;
} else if( op == "char" ) {
if( i > 0 ) i--;
}
}
if( command == "insert" ) {
string text = op.substr(1, op.size() - 2);
buf.insert(i, text);
i += (int)text.size();
}
if( command == "delete" ) {
if( i < buf.size() ) {
if( op == "char" ) {
buf.erase(i,1);
}
if( op == "word" ) {
int len = 0;
while( i + len < buf.size() && buf[i + len] == ' ' ) len++;
if( i + len == buf.size() ) {
;
} else {
while( i + len < buf.size() && buf[i + len] != ' ' )len++;
buf.erase( i, len );
}
}
}
}
// cout << buf << " " << i << endl;
}
buf.insert(i, 1, '^');
cout << buf << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int mask, int pos) { return (mask | (1 << pos)); }
inline int resetBit(int mask, int pos) { return (mask & ~(1 << pos)); }
inline bool checkBit(int mask, int pos) { return (bool)(mask & (1 << pos)); }
int l, r;
bitset<300000005> mark;
void sieve(int lim) {
mark.set(1);
for (int i = 4; i <= lim; i += 2) mark[i] = true;
int sql = sqrt(lim);
for (int i = 3; i <= sql; i += 2) {
if (!mark[i]) {
for (long long int j = (long long int)i * (long long int)i; j <= lim;
j += (2 * i))
mark.set(j);
}
}
}
void solve() {
int res = 0;
int sq = sqrt(r) + 1;
for (int i = 1; i <= sq; i++) {
for (int j = i; j <= sq; j++) {
int x = (i * i) + (j * j);
if (x < l) continue;
if (x > r) break;
if (!mark.test(x)) res++;
}
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> l >> r;
sieve(r);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int sq = sqrt(x) + 1;
vector<int> v;
for (int i = 1; i < sq; i++) {
if (x % i == 0) {
if ((i <= n) && (x / i <= n)) v.push_back(i);
if (x % i == 0 && i * i != x) {
if ((i <= n) && (x / i <= n)) v.push_back(x / i);
}
}
}
cout << v.size() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<long long, long long> ll;
typedef vector<long long> vl;
typedef vector<ll> vll;
typedef vector<vl> vvl;
template <typename T>
ostream &operator<<(ostream &o, vector<T> v) {
if (v.size() > 0) o << v[0];
for (unsigned i = 1; i < v.size(); i++) o << " " << v[i];
return o << " ";
}
template <typename U, typename V>
ostream &operator<<(ostream &o, pair<U, V> p) {
return o << "(" << p.first << ", " << p.second << ") ";
}
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (unsigned i = 0; i < v.size(); i++) in >> v[i];
return in;
}
template <typename T>
istream &operator>>(istream &in, pair<T, T> &p) {
in >> p.first;
in >> p.second;
return in;
}
vvl g(500010);
vl ans(500010), removed(500010, false), sz(500010);
void dfs(long long par, long long node) {
sz[node] = 1;
for (auto &it : g[node])
if (it != par and !removed[it]) {
dfs(node, it);
sz[node] += sz[it];
}
}
long long find_center(long long node) {
dfs(0LL, node);
long long p = 0LL;
long long cap = sz[node] / 2;
while (1) {
bool found = false;
for (auto &it : g[node]) {
if (!removed[it] and it != p and sz[it] > cap) {
found = true;
p = node;
node = it;
break;
}
}
if (!found) return node;
}
}
void fun(long long node, long long alp) {
long long y = find_center(node);
ans[y] = alp;
removed[y] = true;
for (auto &it : g[y])
if (!removed[it]) fun(it, alp + 1);
}
int main(int argc, char *argv[]) {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
long long n;
cin >> n;
for (long long i = (1); i < (long long)n; i++) {
long long x, y;
cin >> x >> y;
g[x].push_back((y));
g[y].push_back((x));
}
fun(1, 0);
for (long long i = (1); i < (long long)n + 1; i++)
cout << char(ans[i] + 'A') << " ";
return 0;
}
| 3 |
#include <iostream>
using namespace std;
double epsilon = 0.000001;
double count(double c, double m, double p, double v, int depth){
double ret = p*depth;
bool addToC = 1;
bool addToM = 1;
if(c<epsilon){
addToC = 0;
}
if(m<epsilon){
addToM = 0;
}
if(c>=v){
ret += c*count(
c-v,
m+(v/2)*addToM,
p+(v/2)*(1+!addToM),
v,
depth+1);
}else if(c>0){
ret += c*count(
0,
m+(c/2)*addToM,
p+(c/2)*(1+!addToM),
v,
depth+1);
}
if(m>=v){
ret += m*count(
c+(v/2)*addToC,
m-v,
p+(v/2)*(1+!addToC),
v,
depth+1);
}else if(m>0){
ret += m*count(
c+(m/2)*addToC,
0,
p+(m/2)*(1+!addToC),
v,
depth+1);
}
return ret;
}
int main()
{
cout.precision(13);
int t;
cin >> t;
while(t--){
double c,m,p,v;
cin >> c >> m >> p >> v;
cout << count(c,m,p,v,1) << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
long long n, t;
vector<long long> a;
vector<long long> x;
vector<long long> ret;
scanf("%lld %lld", &n, &t);
for (long long i = 0; i < n; i++) {
long long tmp;
scanf("%lld", &tmp);
a.push_back(tmp);
}
for (long long i = 0; i < n; i++) {
long long tmp;
scanf("%lld", &tmp);
x.push_back(tmp);
}
for (long long i = 1; i < n; i++) {
if (x[i] < x[i - 1] || x[i] < i + 1) {
printf("No");
return 0;
}
}
for (long long i = 1; i < n - 1; i++) {
if (x[i] < x[i + 1] && x[i] != i + 1) {
printf("No");
return 0;
}
}
for (long long i = 0; i < n - 1; i++) {
if (x[i] == i + 1) {
ret.push_back(a[i + 1] - 1);
} else {
ret.push_back(a[i + 1]);
}
}
ret.push_back(ret[ret.size() - 1] + 1);
for (long long i = 0; i < ret.size() - 1; i++) {
if (ret[i] >= ret[i + 1]) {
printf("No");
return 0;
}
}
printf("Yes\n");
for (long long i = 0; i < ret.size(); i++) {
printf("%lld ", ret[i] + t);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAX = 200005;
int cth[MAX];
int ctv[MAX];
int main() {
int a, b, n;
scanf("%d %d %d", &a, &b, &n);
set<int> h;
set<int> maxh;
set<int> maxv;
set<int> v;
h.insert(0);
h.insert(b);
v.insert(0);
v.insert(a);
maxh.insert(b);
maxv.insert(a);
cth[b]++;
ctv[a]++;
int kk = b;
int jj = a;
for (int i = 0; i < n; i++) {
char t;
int u;
cin >> t >> u;
if (t == 'H') {
auto hi = h.upper_bound(u);
auto lo = h.upper_bound(u);
lo--;
int d1 = u - *lo;
int d2 = *hi - u;
if (cth[d1 + d2] == 1) {
maxh.erase(d1 + d2);
}
cth[d1 + d2]--;
maxh.insert(d1);
maxh.insert(d2);
cth[d1]++;
cth[d2]++;
auto it = maxh.end();
it--;
kk = *it;
h.insert(u);
} else {
auto hi = v.upper_bound(u);
auto lo = v.upper_bound(u);
lo--;
int d1 = u - *lo;
int d2 = *hi - u;
if (ctv[d1 + d2] == 1) {
maxv.erase(d1 + d2);
}
ctv[d1 + d2]--;
maxv.insert(d1);
maxv.insert(d2);
ctv[d1]++;
ctv[d2]++;
auto it = maxv.end();
it--;
jj = *it;
v.insert(u);
}
cout << (long long)kk * (long long)jj << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int temp;
string s;
cin >> s;
for (int i = 0; i < s.length(); i = i + 2) {
for (int j = i + 2; j < s.length(); j = j + 2) {
if (s[i] > s[j]) {
temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[20][100005];
void make(vector<int> &a) {
int n = int((a).size());
for (int i = 0; i < int(n); i++) dp[0][i] = a[i];
for (int j = 1; (1 << j) <= n; j++)
for (int i = 0; i + (1 << j) - 1 < n; i++) {
dp[j][i] = dp[j - 1][i] | dp[j - 1][i + (1 << (j - 1))];
}
}
int read(int i, int j) {
int k = 31 - __builtin_clz(j - i + 1);
return dp[k][i] | dp[k][j - (1 << k) + 1];
}
int upper(int i, int j, vector<int> &a) {
int first = read(i, j);
int low = j, high = int((a).size()) - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (read(i, mid) > first)
high = mid - 1;
else
low = mid + 1;
}
return high;
}
bool cnt[5 + (1 << 20)];
int main() {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < int(n); i++) cin >> a[i];
make(a);
for (int i = 0; i < int(n); i++) {
int j = i;
while (j < n) {
int f = read(i, j);
cnt[f] = true;
j = upper(i, j, a) + 1;
}
}
int ans = 0;
for (int i = 0; i < int((1 << 20) + 5); i++)
if (cnt[i]) ans++;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, prt[100001][2] = {}, anc[100001], disc[100001] = {}, idx = 1;
vector<vector<pair<int, int> > > adj;
vector<int> ans;
stack<pair<pair<int, int>, int> > sk;
inline void stkout() {
stack<pair<pair<int, int>, int> > tp = sk;
cout << "Stack Size : " << tp.size() << "\n";
while (tp.size()) {
cout << tp.top().first.first << " " << tp.top().first.second << " "
<< tp.top().second << "\n";
tp.pop();
}
}
inline void ins(int u, int lw) {
if (sk.size()) {
if (sk.top().first.second < lw) {
sk.push({{lw, anc[u]}, u});
} else {
while (sk.size()) {
if (sk.top().first.first >= lw) {
sk.pop();
} else {
break;
}
}
if (sk.size() && sk.top().first.second >= lw) {
lw = sk.top().first.first;
sk.pop();
}
sk.push({{lw, anc[u]}, -1});
}
} else {
sk.push({{lw, anc[u]}, u});
}
}
inline void ansSet(int n, int u) {
for (auto v : adj[u]) {
if (v.first == n) {
ans.push_back(v.second);
break;
}
}
while (u != n) {
ans.push_back(prt[u][1]);
u = prt[u][0];
}
}
void dfs(int u, int p, int val) {
if (!anc[u]) {
anc[u] = idx;
prt[u][0] = p;
prt[u][1] = val;
for (auto v : adj[u]) {
if (!disc[v.second]) {
anc[u] = disc[v.second] = idx++;
dfs(v.first, u, v.second);
if (anc[v.first] < anc[u]) {
ins(u, anc[v.first]);
}
while (sk.size()) {
if (sk.top().first.first >= anc[u]) {
if (sk.top().second != -1) {
ansSet(u, sk.top().second);
}
sk.pop();
} else {
break;
}
}
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
adj.push_back(vector<pair<int, int> >());
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
adj[a - 1].push_back({b - 1, i});
adj[b - 1].push_back({a - 1, i});
}
for (int i = 0; i < n; i++) {
dfs(i, -1, -1);
}
cout << ans.size() << "\n";
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
if (i < ans.size() - 1) {
cout << " ";
}
}
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:512000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937_64 gen(time(nullptr));
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
ll mod = 1e9 + 7;
namespace {
ll mul(ll a, ll b) {
ll val = a * b - (ll)((ld)a * b / mod) * mod;
if (val < 0) val += mod;
if (val >= mod) val -= mod;
return val;
}
ll poww(ll a, ll b) {
ll val = 1;
a %= mod;
while (b > 0) {
if (b % 2) val = mul(a, val);
a = mul(a, a);
b >>= 1;
}
return val % mod;
}
ll inv(ll a) { return poww(a, mod - 2); }
ll gcd(ll a, ll b) { return (a == 0 ? b : gcd(b % a, a)); }
ll gcdex(ll a, ll b, ll& x, ll& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll x1, y1;
ll d = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
ll inv_eu(ll a, ll m) {
ll x, y;
ll g = gcdex(a, m, x, y);
if (g != 1)
assert(0);
else {
x = (x % m + m) % m;
return x;
}
}
} // namespace
ll const maxn = 3e5 + 5;
int n;
vector<int> g[maxn];
bool used[maxn];
int sz[maxn];
void dfs1(int u) {
used[u] = 1;
sz[u] = 1;
for (int v : g[u]) {
if (used[v]) continue;
dfs1(v);
sz[u] += sz[v];
}
}
int root = -1;
void dfs2(int u) {
if (root != -1) return;
used[u] = 1;
bool f = true;
for (int v : g[u]) {
if (used[v]) continue;
if (2 * sz[v] > n) {
f = false;
sz[u] -= sz[v];
sz[v] += sz[u];
dfs2(v);
}
}
if (f) {
root = u;
return;
}
}
int d[maxn];
queue<int> kek[maxn];
vector<int> verts;
void dfs3(int u) {
verts.push_back(u);
used[u] = 1;
for (int v : g[u]) {
if (used[v]) continue;
d[v] = d[u] + 1;
dfs3(v);
}
}
void dfs(int u) {
used[u] = 1;
for (int v : g[u]) {
if (used[v]) continue;
if (u != root) {
while (kek[v].size() < sz[v]) {
kek[v].push(kek[u].front());
kek[u].pop();
}
}
dfs(v);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
if (n == 2) {
cout << "2\n2 1";
return 0;
}
dfs1(1);
fill_n(used, maxn, 0);
dfs2(1);
assert(root != -1);
fill_n(used, maxn, 0);
sort(g[root].begin(), g[root].end(),
[&](int i, int j) { return sz[i] > sz[j]; });
dfs3(root);
fill_n(used, maxn, 0);
ll i = 1;
ll sz1 = sz[g[root][0]];
vector<int> verts1(n);
for (ll i = 0; i < n; i++) {
verts1[(i + sz1) % n] = verts[i];
}
ll ans = 0;
for (int i = 1; i <= n; i++) {
ans += 2LL * d[i];
}
cout << ans << endl;
vector<int> pos(n + 1);
for (int i = 0; i < n; i++) {
pos[verts1[i]] = verts[i];
}
for (int i = 1; i <= n; i++) {
cout << pos[i] << " ";
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.