solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> v;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
int mn = 0;
for (int i = 0; i < n; i++) {
a = v[i];
if (a > mn) {
cout << i + 1;
return 0;
}
if (a == mn) {
mn = a + 1;
}
}
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, k, m, res = 0, sm = 0, edge = -1, nb = 1;
int a[200055], b[200050], nxt[200505], dp[200005] = {0}, ans[500005];
multiset<int> st, st1, st2;
set<int> stres;
string s, s1, s2, s3, s4;
vector<int> v[200050], vnode, vans, v3;
vector<pair<int, int> > vv, vv1, adj, v1, v2;
vector<pair<int, pair<int, int> > > vvv;
priority_queue<int> q;
map<int, int> mp;
multiset<int>::iterator it, it1, it2;
int voyel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
return 0;
}
int up[200005][20];
void solve() {
int i, j;
up[m + 1][0] = -1;
for (i = 1; i <= m; i++) {
int nxtt = nxt[b[i]];
int idx = lower_bound(v[nxtt].begin(), v[nxtt].end(), i) - v[nxtt].begin();
if (idx != v[nxtt].size()) {
int idxb = v[nxtt][idx];
up[i][0] = idxb;
} else
up[i][0] = -1;
}
for (int j = 1; j < 20; j++) {
for (i = 1; i <= m; i++)
if (up[i][j - 1] != -1) up[i][j] = up[up[i][j - 1]][j - 1];
}
for (i = 1; i <= m; i++) {
int bsup = i;
int x = n - 1;
for (j = 19; j >= 0; j--) {
if ((1 << j) <= x) {
x -= (1 << j);
if (bsup != -1) bsup = up[bsup][j];
}
}
if (bsup != -1) {
dp[i] = bsup;
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int i = 0, j = 0, x, y, z = 0, mx = 0, nb0 = 0, nb1 = 0, nbmax = 0, nbinf = 0,
mm = 5e9, idx = 0, ok = 0, l, r, negatif = 0, positif = 0, q, d, res1 = 0;
char c;
cin >> n >> m >> q;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= n; i++) nxt[a[i]] = a[i + 1];
nxt[a[n]] = a[1];
for (i = 1; i <= m; i++) {
cin >> b[i];
v[b[i]].push_back(i);
}
for (i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end());
}
memset(up, -1, sizeof(up));
solve();
idx = m + 1;
mx = 5e9;
for (i = m; i >= 1; i--) {
if (dp[i]) mx = min(mx, dp[i]);
ans[i] = mx;
}
s = "";
while (q--) {
cin >> x >> y;
res = (ans[x] <= y);
if (res != 0)
s += '1';
else
s += '0';
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int d[10];
int n, a, b, i;
int len, cnt, ans;
inline int Min(int x, int y) { return x < y ? x : y; }
int main() {
while (scanf("%d", &n) == 1) {
scanf("%d", &a);
scanf("%d", &b);
d[1] = d[2] = d[3] = d[4] = a;
d[5] = d[6] = b;
ans = 6;
cnt = 10;
for (srand(time(0)), i = 1000; i--; ans = Min(ans, cnt)) {
random_shuffle(d + 1, d + 7);
cnt = len = 0;
for (int k = 1; k <= 6; k++) {
if (len < d[k]) {
len = n;
cnt++;
}
len -= d[k];
}
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > g[105];
vector<pair<pair<int, pair<int, int> >, long double> > ans;
void dfs(int u, int p, long double pv) {
long double val = 2.0 / g[u].size();
long double shift = pv;
int cnt = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, j = g[u][i].second;
if (v == p) continue;
long double cost = cnt * val + shift;
cnt++;
while (cost >= 2) cost -= 2;
if (p != 0 && cnt == 1) {
i--;
continue;
}
if (cost >= 1) {
ans.push_back(pair<pair<int, pair<int, int> >, long double>(
pair<int, pair<int, int> >(j, pair<int, int>(u, v)), 2 - cost));
cost = 1 - (2 - cost);
} else {
ans.push_back(pair<pair<int, pair<int, int> >, long double>(
pair<int, pair<int, int> >(j, pair<int, int>(v, u)), 1 - cost));
cost = 2 - (1 - cost);
}
dfs(v, u, cost);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(pair<int, int>(b, i));
g[b].push_back(pair<int, int>(a, i));
}
dfs(1, 0, 0);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("1 %d %d %d %.20Lf\n", ans[i].first.first, ans[i].first.second.first,
ans[i].first.second.second, ans[i].second);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int blc = 350;
vector<int> vec[N];
vector<long long> rec[N];
int dp[N];
int father[N];
int up[N];
long double h[1010][1010];
int dia;
int a[N];
long long b[N];
int mx[N];
int num[N];
int find(int x) {
if (father[x] != x) father[x] = find(father[x]);
return father[x];
}
struct node {
int to, next;
};
node edge[N * 4];
int graph[N], tot;
struct data {
int d1, x1, d2, x2;
data() {}
data(int d1, int x1, int d2, int x2) : d1(d1), x1(x1), d2(d2), x2(x2) {}
};
data d[N];
void dfs(int x, int pre) {
int i, y;
d[x] = data(0, x, 0, -1);
for (i = graph[x]; i; i = edge[i].next) {
y = edge[i].to;
if (y == pre) continue;
dfs(y, x);
if ((d[y].d1 + 1) > d[x].d1) {
d[x].d2 = d[x].d1;
d[x].x2 = d[x].x1;
d[x].d1 = d[y].d1 + 1;
d[x].x1 = y;
} else if ((d[y].d1 + 1) > d[x].d2) {
d[x].d2 = d[y].d1 + 1;
d[x].x2 = y;
}
}
dia = max(dia, d[x].d1 + d[x].d2);
}
void work(int x, int pre) {
if (pre == 0) {
up[x] = 0;
return;
}
if (d[pre].x1 == x)
up[x] = max(up[pre], d[pre].d2) + 1;
else
up[x] = max(up[pre], d[pre].d1) + 1;
}
void DP(int x, int pre) {
int i, y;
work(x, pre);
dp[x] = max(up[x], d[x].d1);
a[dp[x]]++;
for (i = graph[x]; i; i = edge[i].next) {
y = edge[i].to;
if (y == pre) continue;
DP(y, x);
}
}
long double doit(int x, int y) {
int k, i, j;
long long ans = 0, sum = 0;
long long tmp1, tmp2, tmp3, tmp4;
int tmp;
int l;
tmp = max(mx[x], mx[y]);
if (num[x] > num[y]) swap(x, y);
for (k = num[x]; k >= 0; k--) {
tmp1 = vec[x][k];
if (k != num[x]) tmp1 -= vec[x][k + 1];
tmp2 = rec[x][k];
if (k != num[x]) tmp2 -= rec[x][k + 1];
l = tmp - k;
if (l < 0) l = 0;
if (l <= num[y]) {
tmp3 = vec[y][l];
tmp4 = rec[y][l];
ans += tmp1 * tmp3;
sum += tmp1 * tmp3 + tmp3 * tmp2 + tmp1 * tmp4;
}
}
ans = 1ll * num[x] * num[y] - ans;
sum += 1ll * ans * tmp;
long double e =
(long double)sum / (long double)((long long)num[x] * (long long)num[y]);
return e;
}
void addedge(int i, int x, int y) {
edge[i].to = y;
edge[i].next = graph[x];
graph[x] = i;
}
int pos[N], kk[N];
int cnt;
int main() {
int i, j, k, l, n, m, q;
int x, y;
int r1, r2;
scanf("%d%d%d", &n, &m, &q);
for (i = 1; i <= n; i++) father[i] = i;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
tot++;
addedge(tot, x, y);
tot++;
addedge(tot, y, x);
r1 = find(x);
r2 = find(y);
father[r2] = r1;
}
for (i = 1; i <= n; i++) father[i] = find(i);
for (i = 1; i <= n; i++) num[father[i]]++;
for (i = 1; i <= n; i++) {
if (father[i] == i) {
dia = 0;
dfs(i, 0);
mx[i] = dia;
DP(i, 0);
for (j = 0; j <= num[i]; j++) b[j] = 1ll * a[j] * j;
for (j = num[i] - 1; j >= 0; j--) a[j] += a[j + 1];
for (j = num[i] - 1; j >= 0; j--) b[j] += b[j + 1];
for (j = 0; j <= num[i]; j++) {
vec[i].push_back(a[j]);
rec[i].push_back(b[j]);
}
for (j = 0; j <= num[i]; j++) a[j] = 0;
for (j = 0; j <= num[i]; j++) b[j] = 0;
}
}
for (i = 1; i <= n; i++) {
if (father[i] == i && num[i] > blc) {
pos[i] = ++cnt;
kk[cnt] = i;
}
}
for (i = 1; i <= cnt - 1; i++) {
for (j = i + 1; j <= cnt; j++) {
h[i][j] = doit(kk[i], kk[j]);
h[j][i] = h[i][j];
}
}
long double t;
double tt;
while (q--) {
scanf("%d%d", &x, &y);
x = father[x];
y = father[y];
if (x == y) {
printf("-1\n");
continue;
}
if (pos[x] && pos[y]) {
tt = h[pos[x]][pos[y]];
printf("%.10lf\n", tt);
} else {
t = doit(x, y);
tt = t;
printf("%.10lf\n", tt);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30);
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int &x : a) {
cin >> x;
}
vector<bool> keeps(n, true);
int neg_cnt = 0;
int mxneg = -INF, mxneg_i;
vector<int> zeros;
for (int i = 0; i < n; i++) {
int x = a[i];
if (x == 0) {
zeros.push_back(i);
keeps[i] = false;
} else if (x < 0) {
neg_cnt++;
if (x > mxneg) {
mxneg = x;
mxneg_i = i;
}
}
}
if (neg_cnt % 2) {
keeps[mxneg_i] = false;
zeros.push_back(mxneg_i);
}
vector<int> last;
for (int i = 0; i < n; i++) {
if (keeps[i]) {
last.push_back(i);
}
}
while (zeros.size() > 1) {
int x = zeros.back();
zeros.pop_back();
cout << 1 << ' ' << x + 1 << ' ' << zeros.back() + 1 << endl;
}
if (zeros.size() && last.size()) {
cout << 2 << ' ' << zeros.back() + 1 << endl;
}
while (last.size() > 1) {
int x = last.back();
last.pop_back();
cout << 1 << ' ' << x + 1 << ' ' << last.back() + 1 << endl;
}
}
| 3 |
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
string s, p;
cin >> s >> p;
s = s + s;
if (s.find(p) != -1) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
int n, m;
int a[maxn];
int b[maxn];
struct node {
int Time;
int sub;
} c[maxn];
int cmp(node x, node y) { return x.Time < y.Time; }
bool calc(int x) {
int lefttime = 0;
memset(c, 0, sizeof(c));
for (int i = 1; i <= x; i++)
if (a[i]) {
c[a[i]].sub = a[i];
c[a[i]].Time = i;
}
for (int i = 1; i <= m; i++)
if (!c[i].Time) return false;
sort(c + 1, c + m + 1, cmp);
for (int i = 1; i <= m; i++) {
lefttime += c[i].Time - c[i - 1].Time - 1;
if (lefttime < b[c[i].sub]) return false;
lefttime -= b[c[i].sub];
}
return true;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
int L, R, mid, ans = -1;
if (!calc(n)) {
printf("%d\n", ans);
continue;
}
L = 1;
R = n - 1;
ans = n;
while (L <= R) {
mid = (L + R) >> 1;
if (calc(mid)) {
ans = mid;
R = mid - 1;
} else
L = mid + 1;
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include<cstdio>
#include<map>
const int MaxN=100010;
int N,P[2][MaxN];
struct edge{int to,cap;edge*rev,*next;}E[MaxN*4],*ne=E,*fir[MaxN],*cur[MaxN];
void link(int a,int b,int c){
*ne=(edge){b,c,ne+1,fir[a]};fir[a]=ne++;
*ne=(edge){a,0,ne-1,fir[b]};fir[b]=ne++;
}
int Q[MaxN],D[MaxN];
int dfs(int i,int c){
if(i==1||!c)return c;
int fl=0,f;
for(edge*&e=cur[i];e&&c;e=e->next)if(e->cap&&D[e->to]==D[i]-1&&(f=dfs(e->to,c<e->cap?c:e->cap)))
fl+=f,e->cap-=f,e->rev->cap+=f,c-=f;
return fl;
}
int vtot;
int mf(){
for(int f=0;;f+=dfs(0,1<<30)){
for(int i=0;i<vtot;i++)D[i]=0,cur[i]=fir[i];
for(int*h=Q,*t=Q+(D[*h=1]=1);h<t;h++){
for(edge*e=fir[*h];e;e=e->next){
if(e->rev->cap&&!D[e->to])D[*t++=e->to]=D[*h]+1;
}
}
if(!D[0])return f;
}
}
int id[2][MaxN],sz[2][MaxN],w[2][MaxN];
int main(){
scanf("%d",&N);
for(int t=0;t<2;t++)
for(int i=0;i<N;i++)scanf("%d",P[t]+i);
int cc[2]={0};
for(int t=0;t<2;t++){
for(int i=0;i<N;i++)if(P[t][i]!=i&&!id[t][i]){
cc[t]++;
for(int j=i;!id[t][j];j=P[t][j])id[t][j]=cc[t],sz[t][cc[t]]++;
}
}
int ans=0;
std::map<std::pair<int,int>,int>Es;
for(int i=0;i<N;i++){
if(P[0][i]==i&&P[1][i]==i)continue;
if(P[0][i]==i)ans++,w[1][id[1][i]]++;
else if(P[1][i]==i)ans++,w[0][id[0][i]]++;
else{
ans++;
Es[std::make_pair(1+id[0][i],1+cc[0]+id[1][i])]++;
if(P[0][i]==P[1][i])Es[std::make_pair(1+cc[0]+id[1][i],1+id[0][i])]++;
}
}
for(int i=1;i<=N;i++){
if(w[0][i])link(1+i,1,w[0][i]);
if(w[1][i])link(0,1+cc[0]+i,w[1][i]);
}
for(std::map<std::pair<int,int>,int>::iterator it=Es.begin();it!=Es.end();it++){
link(it->first.first,it->first.second,it->second);
}
vtot=2+cc[0]+cc[1];
printf("%d\n",ans-mf());
}
| 0 |
#include <iostream>
#include <cstdio>
using namespace std;
long long a, b, mn = 1e9;
int main() {
long long i, j;
cin>>a>>b;
for(i=a; i<=min(a+2019, b); i++) for(j=i+1; j<=min(a+2019, b); j++) {
mn = min(mn, i * j % 2019);
}
cout<<mn;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % 1000000007;
}
a = (a * a) % 1000000007;
b = b / 2;
}
return ans;
}
long long solve(long long n) {
if (n == 1) return 1;
return n + solve(n / 2);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << solve(n) << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
while (k) {
cout << n << " ";
n--;
k--;
}
int i = 1;
while (i <= n) {
cout << i << " ";
i++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m;
char field[1000][1005];
int color[1000][1000];
std::vector<std::vector<int> > g;
int pi[1000000];
int maxcolor;
int newcolor[1000000];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int cnt[1000000];
void dfs(int x, int y) {
color[x][y] = -2;
int i2 = -1;
std::vector<int> ones;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
if (field[nx][ny] == '.' && color[nx][ny] == -1) {
dfs(nx, ny);
if (color[nx][ny] == -2) {
ones.push_back(i);
} else {
i2 = i;
}
}
}
if (ones.empty() && i2 != -1) {
int& nc = color[x + dx[i2]][y + dy[i2]];
if (cnt[nc] == 5) {
cnt[nc]--;
nc = maxcolor++;
color[x][y] = nc;
cnt[nc]++;
} else {
color[x][y] = nc;
}
cnt[nc]++;
}
if (!ones.empty()) {
int nc = maxcolor++;
color[x][y] = nc;
for (int i = 0; i < ones.size(); ++i)
color[x + dx[ones[i]]][y + dy[ones[i]]] = nc;
cnt[nc] = ones.size() + 1;
}
}
int wasHere[1000][1000];
void buildG(int x, int y) {
wasHere[x][y] = 1;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= n || ny >= m || color[nx][ny] == -1) continue;
if (color[nx][ny] != color[x][y])
g[color[x][y]].push_back(color[nx][ny]);
else if (!wasHere[nx][ny])
buildG(nx, ny);
}
}
bool degCmp(int a, int b) { return g[a].size() > g[b].size(); }
bool calcColor(int j) {
if (j == maxcolor) return true;
int x = pi[j];
int colors[10];
memset(colors, 0, sizeof(colors));
for (int i = 0; i < g[x].size(); ++i)
if (newcolor[g[x][i]] != -1) colors[newcolor[g[x][i]]] = 1;
for (int c = 0; c < 10; ++c)
if (colors[c] == 0) {
newcolor[x] = c;
if (calcColor(j + 1)) return true;
newcolor[x] = -1;
}
return false;
}
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; ++i) gets(field[i]);
memset(color, -1, sizeof(color));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (field[i][j] == '.' && color[i][j] == -1) {
dfs(i, j);
if (color[i][j] == -2) {
puts("-1");
return 0;
}
}
g.resize(maxcolor);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (color[i][j] != -1 && !wasHere[i][j]) buildG(i, j);
for (int i = 0; i < maxcolor; ++i) {
std::sort(g[i].begin(), g[i].end());
g[i].erase(std::unique(g[i].begin(), g[i].end()), g[i].end());
pi[i] = i;
}
std::sort(pi, pi + maxcolor, degCmp);
for (int i = 0; i < g.size(); ++i) sort(g[i].begin(), g[i].end(), degCmp);
memset(newcolor, -1, sizeof(newcolor));
for (int i = 0; i < g.size(); ++i)
if (newcolor[pi[i]] == -1)
if (!calcColor(i)) throw 42;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (color[i][j] != -1) field[i][j] = newcolor[color[i][j]] + '0';
for (int i = 0; i < n; ++i) puts(field[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
if (n == 1 && m == 1) return cout << "YES\n1\n", 0;
if (n == 1 || m == 1) {
if (n == 1 && m < 4) {
return cout << "NO", 0;
} else if (m == 1 && n < 4)
return cout << "NO", 0;
if (n == 1) {
cout << "YES" << '\n';
for (int j = 1; j <= m / 2; j++) {
cout << j + m / 2 << ' ' << j << ' ';
}
if (m & 1) {
cout << m << ' ';
}
return 0;
} else {
cout << "YES" << '\n';
for (int i = 1; i <= n / 2; i++) {
cout << i + n / 2 << '\n' << i << '\n';
}
if (n & 1) {
cout << n << '\n';
}
}
return 0;
}
if (n == 3 && m == 3) {
cout << "YES\n1 8 2\n5 3 4\n9 7 6\n";
} else if (n <= 3 && m <= 3) {
cout << "NO" << '\n';
} else {
bool flag = 0;
if (n > m) swap(n, m), flag = 1;
int a[n + 5][m + 5];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!flag)
a[i][j] = (i - 1) * m + j;
else
a[i][j] = (j - 1) * n + i;
}
}
for (int i = 1; i <= m; i++) {
if (i & 1) {
int tmp = a[1][i];
for (int j = 1; j < n; j++) {
a[j][i] = a[j + 1][i];
}
a[n][i] = tmp;
}
}
for (int i = 1; i <= n; i++) {
if (i & 1) {
int tmp = a[i][1], tmp2 = a[i][2];
for (int j = 1; j <= m - 2; j++) {
a[i][j] = a[i][j + 2];
}
a[i][m - 1] = tmp;
a[i][m] = tmp2;
}
}
cout << "YES\n";
if (!flag) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
} else {
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cout << a[j][i] << ' ';
}
cout << '\n';
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
ostream cnull(NULL);
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
const int MAX = 100010;
const long double PI = acos(-1.);
const double EPS = 1e-6;
const long long MOD = INF + 7;
int n;
int make(int x, int y) { return x * n + y; }
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
string napr = "LURDX";
pair<int, int> a[1003][1003];
set<int> foo1, foo2;
void invalid() {
cout << "INVALID" << endl;
exit(0);
}
int d[1003][1003];
char ans[1003][1003];
pair<int, int> q[2000006];
bool ok(int x, int y) { return min(x, y) >= 0 && max(x, y) < n; }
void bfs(int _x, int _y) {
int u = make(_x, _y);
int qt = 0;
int qh = 0;
d[_x][_y] = u;
ans[_x][_y] = 'X';
q[qt++] = make_pair(_x, _y);
while (qt != qh) {
int x = q[qh].first;
int y = q[qh++].second;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (!ok(nx, ny)) continue;
if (d[nx][ny] == -1 && a[nx][ny] == make_pair(_x, _y)) {
ans[nx][ny] = napr[k];
d[nx][ny] = u;
q[qt++] = make_pair(nx, ny);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int x, y;
cin >> a[i][j].first >> a[i][j].second;
if (a[i][j] == make_pair(-1, -1)) {
continue;
}
a[i][j].first--;
a[i][j].second--;
if (a[i][j] == make_pair(i, j)) {
foo1.insert(make(i, j));
}
foo2.insert(make(a[i][j].first, a[i][j].second));
}
}
if (foo1.size() != foo2.size()) {
invalid();
}
for (set<int>::iterator it1 = foo1.begin(), it2 = foo2.begin();
it1 != foo1.end() && it2 != foo2.end(); ++it1, ++it2) {
if (*it1 != *it2) {
invalid();
}
}
memset(d, -1, sizeof d);
for (auto& iter : foo1) {
bfs(iter / n, iter % n);
}
for (int x = 0; x < n; ++x) {
for (int y = 0; y < n; ++y) {
bool flag = false;
if (a[x][y] != make_pair(-1, -1) || ans[x][y] != 0) {
continue;
}
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (!ok(nx, ny)) continue;
if (a[nx][ny] != make_pair(-1, -1) || ans[nx][ny] != 0) {
continue;
}
flag = true;
ans[nx][ny] = napr[k];
ans[x][y] = napr[(k + 2) % 4];
break;
}
if (flag == false) {
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k];
int ny = y + dy[k];
if (!ok(nx, ny)) continue;
if (a[nx][ny] != make_pair(-1, -1)) {
continue;
}
flag = true;
ans[x][y] = napr[(k + 2) % 4];
break;
}
if (flag == false) {
invalid();
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (ans[i][j] == 0) {
invalid();
}
}
}
cout << "VALID" << endl;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cout << ans[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const double pi = 3.1415926535897932;
const long long I64M = 1000000LL * 1000000LL * 1000000LL;
const int IMax = 1000000000;
const int IMin = -IMax;
using namespace std;
ifstream in("input.txt", ifstream::in);
ofstream out("output.txt", ofstream::out);
long long fastpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
long long fastpowmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
while (b) {
if (b & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return res;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k > n || k == 1)
cout << fastpowmod(m, n, 1000000007);
else if (k == n)
cout << fastpowmod(m, ((n + 1) / 2), 1000000007);
else if (k % 2 == 1)
cout << fastpowmod(m, 2, 1000000007);
else if (k % 2 == 0)
cout << m % 1000000007;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, count = 0, g = 1;
cin >> n;
vector<int> op;
for (int i = 4 * n; i >= 2; i--) {
int num = i;
if (num % 2 == 0) {
for (int j = 0; j < op.size(); j++) {
if (num % op[j] != 0) {
g = 1;
} else {
g = 0;
break;
}
}
if (g == 1) {
cout << num << " ";
op.push_back(num);
count++;
}
}
if (count == n) {
break;
}
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int t, n, m, a[200010];
pair<int, int> S[200010];
int SF[200010];
int c[200010 << 2];
void build(int p, int l, int r) {
if (l == r) {
c[p] = a[l];
return;
}
int mid = ((l) + ((r) - (l)) / 2);
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
c[p] = max(c[p << 1], c[p << 1 | 1]);
}
int get(int p, int a, int b, int l, int r) {
if (a <= l && r <= b) {
return c[p];
}
int mid = ((l) + ((r) - (l)) / 2);
int ans = 0;
if (a <= mid) ans = max(ans, get(p << 1, a, b, l, mid));
if (b >= mid + 1) ans = max(ans, get(p << 1 | 1, a, b, mid + 1, r));
return ans;
}
bool check(int p, int mid) {
int tmax = get(1, p + 1, mid, 1, n);
int pos = lower_bound(SF + 1, SF + m + 1, tmax) - SF;
if (S[pos].second >= mid - p) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> t;
for (int q = 1; q <= t; ++q) {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
build(1, 1, n);
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> S[i].first >> S[i].second;
}
sort(S + 1, S + m + 1);
if (get(1, 1, n, 1, n) > S[m].first) {
cout << -1 << endl;
continue;
}
for (int i = 1; i <= m; ++i) SF[i] = S[i].first;
for (int i = m - 1; i >= 1; --i)
S[i].second = max(S[i].second, S[i + 1].second);
int p = 0, ans = 0;
while (p < n) {
int l = p + 1, r = n;
while (l < r) {
int mid = ((l) + ((r) - (l)) / 2);
if (check(p, mid))
l = mid + 1;
else
r = mid;
}
if (l > n || !check(p, l)) l--;
p = l;
ans++;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int s[103];
int n;
int main() {
int a, b, c;
cin >> a >> b >> c;
int mm = min(a / 3, min(b / 2, c / 2));
int ans = mm * 7;
a -= mm * 3;
b -= mm * 2;
c -= mm * 2;
int m = 0;
for (int i = 1; i <= 7; i++) {
int aa = a;
int bb = b;
int cc = c;
int cnt = 0;
for (int j = 0; j <= 6; j++) {
int q = (j + i) % 7;
if (q == 0 || q == 1 || q == 4) {
if (aa) {
aa--;
cnt++;
} else
break;
} else if (q == 2 || q == 6) {
if (bb) {
bb--;
cnt++;
} else
break;
} else if (q == 3 || q == 5) {
if (cc) {
cc--;
cnt++;
} else
break;
}
}
n = max(n, cnt);
}
cout << n + ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int M = 100 + 5, mod = 1e9 + 7, INF = 1e9;
int A[M][M];
int dp[M][M][2];
int main() {
int n, m, K;
scanf("%d%d%d", &n, &m, &K);
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
scanf("%d", &A[j][k]);
}
}
for (int j = 1; j <= n; j++) A[j][0] = 1;
for (int j = 1; j <= m; j++) A[0][j] = 1;
memset(dp, 63, sizeof(dp));
for (int j = 0; j <= n + 1; j++) {
dp[1][j][0] = dp[1][j][1] = 0;
for (int k = 1; k <= m; k++) {
if (A[1][k] != A[j][k])
dp[1][j][0]++;
else
dp[1][j][1]++;
}
}
for (int j = 2; j <= n; j++) {
for (int k = 0; k <= n + 1; k++) {
int cost0 = 0, cost1 = 0;
for (int i = 1; i <= m; i++) {
if (A[j][i] == A[k][i])
cost1++;
else
cost0++;
}
dp[j][k][0] = min(dp[j - 1][k][1] + cost0, dp[j - 1][k][0] + cost0);
dp[j][k][1] = min(dp[j - 1][k][0] + cost1, dp[j - 1][k][1] + cost1);
}
}
int ans = INF;
for (int j = 0; j <= n + 1; j++)
ans = min(ans, min(dp[n][j][0], dp[n][j][1]));
memset(dp, 63, sizeof(dp));
for (int j = 0; j <= m + 1; j++) {
dp[1][j][0] = dp[1][j][1] = 0;
for (int k = 1; k <= n; k++) {
if (A[k][1] != A[k][j])
dp[1][j][0]++;
else
dp[1][j][1]++;
}
}
for (int j = 2; j <= m; j++) {
for (int k = 0; k <= m + 1; k++) {
int cost0 = 0, cost1 = 0;
for (int i = 1; i <= n; i++) {
if (A[i][j] == A[i][k])
cost1++;
else
cost0++;
}
dp[j][k][0] = min(dp[j - 1][k][1] + cost0, dp[j - 1][k][0] + cost0);
dp[j][k][1] = min(dp[j - 1][k][0] + cost1, dp[j - 1][k][1] + cost1);
}
}
for (int j = 0; j <= m + 1; j++)
ans = min(ans, min(dp[m][j][0], dp[m][j][1]));
printf("%d\n", ans <= K ? ans : -1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int Size;
cin >> Size;
for (int i = 0; i <= (Size / 2); i++) {
for (int j = 0; j < (Size / 2) - i; j++) {
cout << "*";
}
for (int k = 0; k < (i * 2) + 1; k++) cout << "D";
for (int j = 0; j < (Size / 2) - i; j++) {
cout << "*";
}
cout << endl;
}
for (int i = Size / 2 - 1; i >= 0; i--) {
for (int j = 0; j < (Size / 2) - i; j++) {
cout << "*";
}
for (int k = 0; k < (i * 2) + 1; k++) cout << "D";
for (int j = 0; j < (Size / 2) - i; j++) {
cout << "*";
}
cout << endl;
}
return 0;
}
| 1 |
#include<iostream>
#include<queue>
#include<vector>
#include<math.h>
#define ll long long int
using namespace std;
/*----–--gcd and hcf *------------*/
ll gcd(ll a,ll b){
if(b==0)
return a;
return gcd(b,a%b);
}
ll ceilV(ll x,ll y){
return (x%y==0?x/y:(x/y+1));
}
ll sieveOfPrime(ll x){
ll max=1000;
//cin>>max; //for taking sieve size
int isPrime[max+1];
isPrime[0]=isPrime[1]=0;
for(ll i=2;i<=max;i++){
isPrime[i]=1;
}
for(ll i=2;i*i<=max;i++){
if(isPrime[i]){
for(ll j=i*i;j<=max;j+=i){
isPrime[j]=0;
}
}
}
// for(ll i=2;i<=max;i++){
// cout<<i<<" "<<isPrime[i]<<endl;
// }
return isPrime[x];
}
void primeFactorizationLogn(ll n,ll x){
ll prime[n+1];
for(ll i=0;i<=n;i++){
prime[i]=i;
}
for(ll i=2;i*i<=n;i++){
if(prime[i]==i){
for(ll j=i*i;j<=n;j+=i){
prime[j]=i;
}
}
}
while(x!=1){
cout<<prime[x]<<" ";
x=x/prime[x];
}
}
ll lcSubstring(string a,string b){
ll max=0;
ll dp[a.length()+1][b.length()+1];
for(ll i=0;i<=a.length();i++){
for(ll j=0;j<=b.length();j++){
if(i==0||j==0){
dp[i][j]=0;
}else if(a[i-1]==b[j-1]){
dp[i][j]=dp[i-1][j-1]+1;
}else{
dp[i][j]=0;
}
if(dp[i][j]>max){
max=dp[i][j];
}
}
}
return max;
}
void fun(){
string a,b;
cin>>a>>b;
ll max=lcSubstring(a,b);
//cout<<max<<endl;
cout<<a.length()+b.length()-2*max<<endl;
}
int main()
{
ll t;
cin>>t;
while(t--){
fun();
}
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int a, b;
int count = 0;
cin >> a >> b;
for(int i = a; i <= b; i++){
if(i/10000 == i % 10 && (i /1000)%10 == (i /10)%10) count++;
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000000, inv2 = (MOD + 1) / 2;
long double eps = 1e-6;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
long double pi = acos(-1.0L);
struct node {
int x, y, z, op, id;
} a[1000000 + 10], c[1000000 + 10];
bool cmp(node a, node b) {
if (a.z != b.z) return a.z < b.z;
return a.op < b.op;
}
int f[1000000 + 10], used[1000000 + 10], n, m, k;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '--') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
int dsu(int k) {
if (f[k] != k) f[k] = dsu(f[k]);
return f[k];
}
pair<int, long long> calc(int mid) {
for (int i = (int)1; i <= (int)m; i++) {
c[i] = a[i];
if (c[i].op) c[i].z += mid;
}
sort(c + 1, c + m + 1, cmp);
for (int i = (int)1; i <= (int)m; i++) used[i] = 0;
for (int i = (int)1; i <= (int)n; i++) f[i] = i;
int s = 0, num = n;
long long ans = 0;
for (int i = (int)1; i <= (int)m; i++) {
int x = dsu(c[i].x), y = dsu(c[i].y);
if (x != y && s + c[i].op <= k) {
f[x] = y;
ans += c[i].z;
used[c[i].id] = 1;
s += c[i].op;
num--;
}
}
if (num != 1) ans = 2e10;
return make_pair(s, ans);
}
void solve() {
pair<int, long long> t = calc(-2e5);
if (t.second == 2e10 || t.first < k) {
printf("-1\n");
return;
}
t = calc(2e5);
if (t.second < 2e10 && t.first > k) {
printf("-1\n");
return;
}
int l = -1e5, r = 1e5;
int ans = -1e5;
while (l <= r) {
int mid = (l + r) >> 1;
if (calc(mid).first >= k)
l = mid + 1, ans = mid;
else
r = mid - 1;
}
if (calc(ans).first > k) ans++, calc(ans);
int res = 0;
for (int i = (int)1; i <= (int)m; i++)
if (used[i]) res++;
printf("%d\n", res);
for (int i = (int)1; i <= (int)m; i++)
if (used[i]) printf("%d ", i);
}
int main() {
n = read(), m = read(), k = read();
for (int i = (int)1; i <= (int)m; i++) {
a[i].x = read(), a[i].y = read(), a[i].z = read();
if (a[i].x == 1 || a[i].y == 1) a[i].op = 1;
a[i].id = i;
}
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000,1000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
long long n, two;
bool f(long long m) {
if (log(m + .0) + log(two - 1.0) > log(5.0 * inf)) return false;
if (m * (m - 1) / 2LL + (two - 1) * m <= n) return true;
return false;
}
int main(void) {
cin >> n;
set<long long> ans;
for (long long(i) = 0; (i) < (long long)(63); (i)++) {
two = 1;
for (long long(j) = 0; (j) < (long long)(i); (j)++) two <<= 1LL;
long long l = 0, r = 2 * mod;
while (r - l > 1) {
long long m = (l + r) >> 1LL;
if (f(m))
l = m;
else
r = m;
}
if (l * (l - 1) / 2LL + (two - 1) * l == n && l & 1LL) ans.insert(two * l);
}
if (!ans.size()) puts("-1");
for (set<long long>::iterator i = ans.begin(); i != ans.end(); i++)
cout << *i << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string line;
getline(cin, line);
reverse(line.begin(), line.end());
for (int i = 0; i < line.length(); i++) {
line[i] = tolower(line[i]);
if (line[i] == ' ') {
line.erase(line.begin() + i);
i--;
}
}
if (line[1] == 'a' || line[1] == 'i' || line[1] == 'e' || line[1] == 'o' ||
line[1] == 'y' || line[1] == 'u')
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <iostream>
int main() {
int n;
std::cin >> n;
long long ans = 0;
long long acc = 0;
for (int i=0; i<n; i++) {
int a;
std::cin >> a;
if (a == 0) {
ans += acc / 2;
acc = 0;
}
acc += a;
}
ans += acc / 2;
std::cout << ans << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const double EPS = 1e-8;
using namespace std;
void _kill() {
cout << "NO";
exit(0);
}
int a[3];
int main() {
int n, m;
cin >> n >> m;
if (n == 1 && m == 2) {
cout << 0 << '\n' << "1 1\n1 2\n1 1";
return 0;
}
if (n == 2 && m == 1) {
cout << 0 << '\n' << "1 1\n2 1\n1 1";
return 0;
}
if (n == 1) {
cout << 1 << '\n';
cout << 1 << ' ' << m << ' ' << 1 << ' ' << 1 << '\n';
for (int i = 0; i < m; i++) cout << 1 << ' ' << i + 1 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
if (m == 1) {
cout << 1 << '\n';
cout << n << ' ' << 1 << ' ' << 1 << ' ' << 1 << '\n';
for (int i = 0; i < n; i++) cout << i + 1 << ' ' << 1 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
if (n % 2 == 0) {
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
for (int i = 0; i < n; i++)
if (i % 2 == 0)
for (int j = 2; j <= m; j++) cout << i + 1 << ' ' << j << '\n';
else
for (int j = m; j >= 2; j--) cout << i + 1 << ' ' << j << '\n';
for (int i = n; i >= 1; i--) cout << i << ' ' << 1 << '\n';
return 0;
}
if (m % 2 == 0) {
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
for (int i = 0; i < m; i++)
if (i % 2 == 0)
for (int j = 2; j <= n; j++) cout << j << ' ' << i + 1 << '\n';
else
for (int j = n; j >= 2; j--) cout << j << ' ' << i + 1 << '\n';
for (int i = m; i >= 1; i--) cout << 1 << ' ' << i << '\n';
return 0;
}
cout << 1 << '\n';
cout << n << ' ' << m << ' ' << 1 << ' ' << 1 << '\n';
for (int i = 0; i < m; i++)
if (i % 2 == 0)
for (int j = 1; j <= n; j++) cout << j << ' ' << i + 1 << '\n';
else
for (int j = n; j >= 1; j--) cout << j << ' ' << i + 1 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const int M = 55;
const int K = 200010;
const int LIT = 2500;
const int INF = 1 << 30;
const int dir[6][2] = {{2, 0}, {-2, 0}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
int dta[N];
int midd[N];
int flg[N];
bool cmp1(int a, int b) { return dta[a] < dta[b] || dta[a] == dta[b] && a < b; }
bool cmp(int a, int b) { return dta[a] > dta[b] || dta[a] == dta[b] && a < b; }
int n, a, b;
void init() {
scanf("%d", &n);
scanf("%d %d", &a, &b);
for (int i = 0; i < n; i++) scanf("%d", &dta[i]);
}
void solve() {
for (int i = 0; i < n; i++) midd[i] = i;
if (a == b) {
for (int i = 0; i < a; i++) flg[i] = 1;
for (int i = 0; i < b; i++) flg[i + a] = 2;
} else {
if (a > b) {
sort(midd, midd + n, cmp1);
for (int i = 0; i < a; i++) flg[midd[i]] = 1;
for (int i = 0; i < b; i++) flg[midd[i + a]] = 2;
} else {
sort(midd, midd + n, cmp);
for (int i = 0; i < a; i++) flg[midd[i]] = 1;
for (int i = 0; i < b; i++) flg[midd[i + a]] = 2;
}
}
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", flg[i]);
}
printf("\n");
}
int main() {
init();
solve();
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, last = -1, ans = 0;
bool r = false;
char c;
scanf("%d", &n);
scanf("%*[\n]");
for (int i = 0; i < n; i++) {
scanf("%c", &c);
if (c == 'R') {
if (last == -1)
ans += i;
else
ans += i - last - 1;
r = true, last = i;
} else if (c == 'L') {
if (last != -1 && (i - last) % 2 == 0) ans += 1;
r = false, last = i;
}
}
if (r == false) ans += n - 1 - last;
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000LL;
void fail() {
puts("Impossible");
exit(0);
}
string str(long long x) {
stringstream ss;
ss << x;
return ss.str();
}
int main(void) {
long long x, y;
scanf("%lld%lld", &x, &y);
string sol = "";
for (;;) {
if (x == y) fail();
if (y == 1) {
sol += str(x - 1) + "A";
break;
}
if (x == 1) {
sol += str(y - 1) + "B";
break;
}
if (x > y) {
if (y == 0) fail();
long long k = x / y;
x %= y;
sol += str(k) + "A";
continue;
}
if (y > x) {
if (x == 0) fail();
long long k = y / x;
y %= x;
sol += str(k) + "B";
continue;
}
}
printf("%s\n", sol.c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int K, T;
cin >> K >> T;
vector<int> c(T);
for (int &e : c) cin >> e;
sort(c.begin(), c.end(), greater<int>());
int M = c[0];
cout << max(2*M-K-1,0) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, px, py;
int dx[] = {-1, 0, 1, 1, 1, 0, -1, -1}, dy[] = {1, 1, 1, 0, -1, -1, -1, 0};
int dxx[] = {-1, 0, 1, 0}, dyy[] = {0, 1, 0, -1};
char s[1111];
bool used[1111][1111], mp[1111][1111], vis[1111][1111], fake;
int a[1111][1111], ans;
vector<pair<int, int> > v;
bool In(int x, int y) { return (x >= 1 && x <= n && y >= 1 && y <= m); }
bool can() {
int cnt = 0;
for (int i = 0; i < v.size(); i++) {
mp[v[i].first][v[i].second] = 1;
}
bool f = 0;
if (!v.size()) return 1;
px = v[0].first;
py = v[0].second;
for (int i = 0; i < v.size(); i++) {
int x = px, y = py;
px = py = -1;
vis[x][y] = 1;
int cp = 0;
for (int j = 0; j < 4; j++) {
int xx = x + dxx[j], yy = y + dyy[j];
if (!In(xx, yy)) continue;
if (mp[xx][yy]) {
cp++;
if (!vis[xx][yy]) {
px = xx;
py = yy;
}
}
}
if (cp != 2) {
f = 1;
break;
}
cnt++;
if (!~px) break;
}
for (int i = 0; i < v.size(); i++) {
mp[v[i].first][v[i].second] = vis[v[i].first][v[i].second] = 0;
}
if (f) return 0;
if (cnt < v.size()) return 0;
return 1;
}
void dfs(int x, int y) {
used[x][y] = 1;
for (int j = 0; j < 8; j++) {
int xx = x + dx[j], yy = y + dy[j];
if (!In(xx, yy)) fake = 1;
if (!In(xx, yy) || used[xx][yy]) continue;
if (!a[xx][yy])
dfs(xx, yy);
else {
v.push_back(make_pair(xx, yy));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
for (int j = 1; j <= m; j++) {
a[i][j] = s[j - 1] - '0';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!a[i][j] && !used[i][j]) {
v.clear();
fake = 0;
dfs(i, j);
if (fake) continue;
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
if (can()) ans = max(ans, (int)v.size());
}
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (a[i][j] && a[i][j + 1] && a[i + 1][j] && a[i + 1][j + 1])
ans = max(ans, 4);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, x, y, n1;
string s;
cin >> n1 >> x >> y;
cin >> s;
reverse(s.begin(), s.end());
int c = count(s.begin(), s.begin() + x, '1');
c -= (s[y] == '1');
c += (s[y] == '0');
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int rx[510], ry[510];
int bx[510], by[510];
int ct[510][510];
bool left(int x1, int y1, int x2, int y2, int x3, int y3) {
long long dx1 = x2 - x1;
long long dy1 = y2 - y1;
long long dx2 = x3 - x1;
long long dy2 = y3 - y1;
return dx1 * dy2 - dx2 * dy1 > 0;
}
inline bool test(int a, int b, int c) {
int ml = a;
int mr = b;
int oth = c;
int v[3] = {a, b, c};
for (int i = 0; i < 3; i++) {
if (rx[v[i]] < rx[ml]) ml = v[i];
if (rx[v[i]] > rx[mr]) mr = v[i];
}
for (int i = 0; i < 3; i++) {
if (v[i] == mr || v[i] == ml) continue;
oth = v[i];
}
int ret = -ct[ml][mr] + ct[oth][mr] + ct[ml][oth];
return ret == 0;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> rx[i] >> ry[i];
}
for (int i = 0; i < m; i++) {
cin >> bx[i] >> by[i];
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i == j) continue;
int x1, y1, x2, y2;
x1 = rx[i];
y1 = ry[i];
x2 = rx[j];
y2 = ry[j];
if (x1 > x2) swap(x1, x2), swap(y1, y2);
if (x1 == x2) continue;
for (int k = 0; k < m; k++) {
int px = bx[k];
int py = by[k];
if (px > x1 && px <= x2) {
if (!left(x1, y1, x2, y2, px, py)) {
ct[i][j]++;
ct[j][i]++;
}
}
}
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i == j) continue;
for (int k = j + 1; k < n; k++) {
if (k == i || k == j) continue;
if (test(i, j, k)) res++;
}
}
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using max_pq = priority_queue<T>;
template <class T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
class BSuffixStructures {
int arr1[256] = {0}, arr2[256] = {0};
bool checkAuto(string s1, string s2) {
int i = 0, j = 0;
while (i < s1.length() && j < s2.length()) {
if (s1[i] == s2[j]) {
i++;
j++;
} else
i++;
}
if (j == s2.length()) return 1;
return 0;
}
bool checkArray(string s1, string s2) {
for (int i = 0; i <= s1.length() - 1; i++) arr1[s1[i]]++;
for (int i = 0; i <= s2.length() - 1; i++) arr2[s2[i]]++;
for (int i = 0; i <= 255; i++)
if (arr1[i] != arr2[i]) return 0;
return 1;
}
bool checkBoth(string s1, string s2) {
for (int i = 0; i <= 255; i++)
if (arr1[i] < arr2[i]) return 0;
return 1;
}
public:
void solve(std::istream& cin, std::ostream& cout) {
string s1, s2;
cin >> s1 >> s2;
if (checkAuto(s1, s2))
cout << "automaton";
else if (checkArray(s1, s2))
cout << "array";
else if (checkBoth(s1, s2))
cout << "both";
else
cout << "need tree";
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
BSuffixStructures solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, k;
int main() {
cin >> n >> k;
if (k == 0) {
for (int i = 1; i < n + n + 1; i++) printf("%d ", i);
} else {
if (k == 1) {
printf("1 2 4 3 ");
for (int i = 5; i < n + n + 1; i++) printf("%d ", i);
} else {
printf("1 %d %d 2 ", (k + 1), (k + 2));
for (int i = 3; i < n + n + 1; i++) {
if (i != (k + 1) && i != (k + 2)) printf("%d ", i);
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, k;
long long a[100010];
long long f(int l, int r) {
if (l > r) swap(l, r);
return a[r] / x - (a[l] - 1) / x;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> x >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a, a + n + 1);
long long ans = 0;
long long lo = 1, hi = 1;
for (int i = 1; i <= n; i++) {
while (lo < n && a[lo] < a[i]) lo++;
while (hi < n && a[hi] < a[i]) hi++;
while (lo < n && f(lo, i) < k) lo++;
while (hi <= n && f(hi, i) <= k) hi++;
if (f(lo, i) == k) {
ans += (hi - lo);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int M,D;
cin >> M >> D;
int count=0;
for(int m=1; m<=M; m++){
for(int d=1; d<=D; d++){
if(d>=10&&d/10>=2&&d%10>=2&&(d/10)*(d%10)==m) count++;
}
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int odd = 1;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
odd *= (a & 1 ? 1 : 2);
}
cout << (int)pow(3, n) - odd << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long abso(long long a) { return a > 0 ? a : -a; }
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<long long> V;
V.resize(n);
for (int i = 0; i < V.size(); i++) {
cin >> V[i];
}
long long sum = 0;
vector<long long> cur, res;
res.resize(n);
for (int i = 0; i < V.size(); i++) {
long long sm = V[i], cmax = V[i];
cur.clear();
cur.resize(n);
cur[i] = V[i];
for (int j = i + 1; j < V.size(); j++) {
cur[j] = min(V[j], cur[j - 1]);
sm += cur[j];
}
for (int j = i - 1; j >= 0; j--) {
cur[j] = min(cur[j + 1], V[j]);
sm += cur[j];
}
if (sm > sum) {
sum = sm;
for (int x = 0; x < res.size(); x++) res[x] = cur[x];
}
}
for (int i = 0; i < res.size(); i++) {
cout << res[i] << " ";
}
cout << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[100005];
int k[100005];
int pos[2000005];
char ans[2000005];
int main(void) {
int n, x;
cin >> n;
s[0] = "";
for (int i = 1; i <= n; i++) {
cin >> s[i] >> k[i];
for (int j = 0; j < k[i]; j++) {
cin >> x;
if (s[pos[x]].size() < s[i].size()) {
pos[x] = i;
}
}
}
int keep = 0, ki = 0;
for (int i = 1; i <= 2000000; i++) {
if (pos[i] != 0) {
if (ki + s[pos[i]].size() > s[keep].size()) {
keep = pos[i];
ki = 0;
}
}
if (keep == 0) {
ans[i] = '*';
} else {
ans[i] = s[keep][ki];
}
if (keep) ki++;
if (ki == s[keep].size()) keep = ki = 0;
}
int m = 2000000;
while (m > 0 && ans[m] == '*') ans[m--] = '\0';
for (int i = 1; i <= m; i++)
if (ans[i] == '*') ans[i] = 'a';
cout << (string)(ans + 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
char a;
while(cin >> a){
cout<<'x';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
vector<long long> g[N];
vector<long long> rg[N];
vector<long long> vs;
bool used[N];
int cmp[N], cmpsize[N];
void add_edge(int from, int to) {
g[from].push_back(to);
rg[to].push_back(from);
}
void dfs(int v) {
used[v] = 1;
for (int i = 0; i < (((int)(g[v]).size())); i++) {
if (!used[g[v][i]]) dfs(g[v][i]);
}
vs.push_back(v);
}
void rdfs(int v, int k) {
used[v] = 1;
cmp[v] = k;
for (int i = 0; i < (((int)(rg[v]).size())); i++) {
if (!used[rg[v][i]]) rdfs(rg[v][i], k);
}
}
int scc() {
memset(used, 0, sizeof(used));
vs.clear();
for (int v = 0; v < (n); v++) {
if (!used[v]) dfs(v);
}
memset(used, 0, sizeof(used));
int k = 0;
for (int i = ((int)(vs).size()) - 1; i >= 0; i--) {
if (!used[vs[i]]) rdfs(vs[i], k++);
}
return k;
}
int dfs2(int v) {
used[v] = 1;
int res = cmpsize[cmp[v]] == 1;
for (int i = 0; i < (((int)(g[v]).size())); i++)
if (!used[g[v][i]]) {
res &= dfs2(g[v][i]);
}
for (int i = 0; i < (((int)(rg[v]).size())); i++)
if (!used[rg[v][i]]) {
res &= dfs2(rg[v][i]);
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int a, b;
cin >> a >> b;
add_edge(a - 1, b - 1);
}
scc();
memset(cmpsize, 0, sizeof(cmpsize));
for (int i = 0; i < (n); i++) {
cmpsize[cmp[i]]++;
}
memset(used, 0, sizeof(used));
int ans = n;
for (int i = 0; i < (n); i++)
if (!used[i]) {
ans -= dfs2(i);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, a, b, tx = 0, ty = 0;
cin >> n;
for (int i = 0; i < 2 * n; i++) {
cin >> a >> b;
tx += a;
ty += b;
}
cout << tx / n << " " << ty / n << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
int x[MX];
bool check[MX];
int sum[MX];
long long ans[MX];
const int BLOCK = sqrt(MX);
int n, q;
vector<deque<int> > dq(100005);
vector<deque<int> > dqd(100005);
vector<deque<int> > dqf(100005);
struct node {
int L, R, INDEX;
} Q[MX];
bool cmp(node x, node y) {
if (x.L / BLOCK != y.L / BLOCK) {
return x.L / BLOCK < y.L / BLOCK;
} else {
return x.R < y.R;
}
}
bool counter(int X) {
int SZ = dq[X].size();
if (SZ == 0)
return false;
else if (SZ == 1 || SZ == 2)
return true;
else {
if (sum[X] == 0)
return true;
else
return false;
}
}
void MOS() {
int LEFT, RIGHT, START, END, TEMP;
START = END = Q[0].L;
dq[x[START]].push_back(START);
check[x[START]] = true;
int unq = 1, cnt = 1;
for (int i = 0; i < q; i++) {
while (START < Q[i].L) {
dq[x[START]].pop_front();
if (!dqd[x[START]].empty()) dqd[x[START]].pop_front();
if (!dqf[x[START]].empty()) {
sum[x[START]] -= dqf[x[START]].front();
dqf[x[START]].pop_front();
}
if (dq[x[START]].empty()) unq--;
if (counter(x[START]) == false && check[x[START]] == true) {
cnt--;
check[x[START]] = false;
} else if (counter(x[START]) == true && check[x[START]] == false) {
cnt++;
check[x[START]] = true;
}
START++;
if (START > END) {
if (!dq[x[START]].empty()) TEMP = START - dq[x[START]].back();
if (dqd[x[START]].size() > 0) {
if (dqd[x[START]].back() == TEMP)
dqf[x[START]].push_back(0);
else {
dqf[x[START]].push_back(1);
sum[x[START]] += 1;
}
}
if (dq[x[START]].size() > 0) dqd[x[START]].push_back(TEMP);
dq[x[START]].push_back(START);
if (dq[x[START]].size() == 1) unq++;
END = START;
if (counter(x[START]) == false && check[x[START]] == true) {
cnt--;
check[x[START]] = false;
} else if (counter(x[START]) == true && check[x[START]] == false) {
cnt++;
check[x[START]] = true;
}
}
}
while (START > Q[i].L) {
START--;
if (dq[!x[START]].empty()) TEMP = dq[x[START]].front() - START;
if (dqd[x[START]].size() > 0) {
if (dqd[x[START]].front() == TEMP)
dqf[x[START]].push_front(0);
else {
dqf[x[START]].push_front(1);
sum[x[START]] += 1;
}
}
if (dq[x[START]].size() > 0) dqd[x[START]].push_front(TEMP);
dq[x[START]].push_front(START);
if (dq[x[START]].size() == 1) unq++;
if (counter(x[START]) == false && check[x[START]] == true) {
cnt--;
check[x[START]] = false;
} else if (counter(x[START]) == true && check[x[START]] == false) {
cnt++;
check[x[START]] = true;
}
}
while (END < Q[i].R) {
END++;
if (!dq[x[END]].empty()) TEMP = END - dq[x[END]].back();
if (dqd[x[END]].size() > 0) {
if (dqd[x[END]].back() == TEMP)
dqf[x[END]].push_back(0);
else {
dqf[x[END]].push_back(1);
sum[x[END]] += 1;
}
}
if (dq[x[END]].size() > 0) dqd[x[END]].push_back(TEMP);
dq[x[END]].push_back(END);
if (dq[x[END]].size() == 1) unq++;
if (counter(x[END]) == false && check[x[END]] == true) {
cnt--;
check[x[END]] = false;
} else if (counter(x[END]) == true && check[x[END]] == false) {
cnt++;
check[x[END]] = true;
}
}
while (END > Q[i].R) {
dq[x[END]].pop_back();
if (!dqd[x[END]].empty()) dqd[x[END]].pop_back();
if (!dqf[x[END]].empty()) {
sum[x[END]] -= dqf[x[END]].back();
dqf[x[END]].pop_back();
}
if (dq[x[END]].empty()) unq--;
if (counter(x[END]) == false && check[x[END]] == true) {
cnt--;
check[x[END]] = false;
} else if (counter(x[END]) == true && check[x[END]] == false) {
cnt++;
check[x[END]] = true;
}
END--;
}
if (cnt > 0)
ans[Q[i].INDEX] = unq;
else
ans[Q[i].INDEX] = unq + 1;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d %d", &Q[i].L, &Q[i].R);
Q[i].INDEX = i;
}
sort(Q, Q + q, cmp);
MOS();
for (int i = 0; i < q; i++) cout << ans[i] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
multimap<int, int> m;
multimap<int, int>::iterator it;
long str, n, i, x, y, bp, s;
cin >> str >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
m.insert(make_pair(x, y));
}
for (it = m.begin(); it != m.end(); ++it) {
s = it->first;
bp = it->second;
if (str > s)
str += bp;
else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, d, v[500005];
bool dp[500005];
int main() {
int i, j, Max = 0;
cin >> n >> k >> d;
for (i = 1; i <= n; ++i) cin >> v[i];
sort(v + 1, v + n + 1);
dp[0] = 1, Max = 0;
j = 1;
for (i = 1; i <= n; ++i) {
if (i >= k)
if (dp[i - k] == 1) Max = i - k;
while (j < i && v[i] - v[j] > d) ++j;
if (i - j + 1 >= k && Max + 1 >= j) dp[i] = 1;
}
if (dp[n])
cout << "YES";
else
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, len, t, flag = 0;
char ch[10000];
scanf("%d", &t);
scanf("%c", &ch[0]);
for (i = 0; i < t; i++) {
flag = 0;
scanf("%c", &ch[0]);
for (j = 0; ch[j] != '\n'; j++) {
scanf("%c", &ch[j + 1]);
}
ch[j] = '\0';
len = j;
if ((ch[len - 2] == 'a') && (ch[len - 3] == 'l') && (ch[len - 4] == 'a') &&
(ch[len - 5] == 'l') && (ch[len - 1] == '.'))
flag = 1;
if ((ch[0] == 'm') && (ch[1] == 'i') && (ch[2] == 'a') && (ch[3] == 'o') &&
(ch[4] == '.')) {
if (flag == 0)
flag = 2;
else
flag = 3;
}
if ((flag == 0) || (flag == 3))
printf("%s\n", "OMG>.< I don't know!");
else if (flag == 1)
printf("%s\n", "Freda's");
else
printf("%s\n", "Rainbow's");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 202020;
int n, m;
int ans[N], belong[N], st[N], vis[N];
vector<pair<int, int> > v[N], g[N];
int F;
int ne[N], ele[N];
bool used[N];
vector<int> q;
void dfs(int u) {
if (st[u]) F = u;
vis[u] = 1;
for (auto v : g[u])
if (!vis[v.first]) dfs(v.first);
}
void dfs2(int u) {
if (F) return;
vis[u] = 2;
for (auto v : g[u])
if (ans[v.second] == -1 && !used[v.second]) {
if (F) return;
ne[u] = v.first, ele[u] = v.second;
used[v.second] = 1;
if (vis[v.first] == 2) {
F = v.first;
return;
}
dfs2(v.first);
}
}
bool find(int u) {
F = 0;
dfs(u);
if (F) {
q.clear();
q.push_back(F);
return 1;
}
F = 0;
dfs2(u);
if (!F) return 0;
for (int u = F; vis[u] == 2; u = ne[u]) {
q.push_back(u);
vis[u] = 3;
ans[ele[u]] = (belong[ele[u]] == ne[u]);
}
return 1;
}
void gao() {
for (int i = (0); i < ((int)q.size()); i++) {
int u = q[i];
for (auto v : g[u])
if (vis[v.first] != 3) {
vis[v.first] = 3;
if (ans[v.second] == -1) ans[v.second] = (belong[v.second] == v.first);
q.push_back(v.first);
}
}
}
bool solve() {
for (int i = (1); i < (n + 1); i++)
if (!vis[i]) {
if (!find(i)) return 0;
gao();
}
for (int i = (1); i < (m + 1); i++)
if (ans[i] == -1) ans[i] = 0;
return 1;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> m;
fill_n(ans + 1, m, -1);
for (int i = (1); i < (n + 1); i++) {
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
v[abs(x)].push_back(make_pair(i, x > 0));
}
}
for (int i = (1); i < (m + 1); i++) {
if ((int)v[i].size() == 0) {
ans[i] = 0;
} else if ((int)v[i].size() == 1) {
ans[i] = v[i][0].second;
st[v[i][0].first] = 1;
} else {
if (v[i][0].second == v[i][1].second) {
ans[i] = v[i][0].second;
st[v[i][0].first] = st[v[i][1].first] = 1;
} else {
int st = v[i][0].first, ed = v[i][1].first;
g[st].push_back(make_pair(ed, i));
g[ed].push_back(make_pair(st, i));
belong[i] = v[i][0].second ? st : ed;
}
}
}
if (solve()) {
cout << "YES"
<< "\n";
for (int i = (1); i < (m + 1); i++) cout << ans[i];
cout << "\n";
} else {
cout << "NO"
<< "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int myReminder[7];
int myDig[] = {1, 8, 9, 6};
string myStringRem[7];
int findingReminder() {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
for (int l = 0; l < 4; l++) {
if (i == j || j == k || k == l || i == k || i == l || j == l) {
continue;
}
int myNum =
myDig[i] * 1000 + myDig[j] * 100 + myDig[k] * 10 + myDig[l];
int index = myNum % 7;
myReminder[index] = myNum;
myStringRem[index] = "";
myStringRem[index] += ('0' + myDig[i]);
myStringRem[index] += ('0' + myDig[j]);
myStringRem[index] += ('0' + myDig[k]);
myStringRem[index] += ('0' + myDig[l]);
}
}
}
}
return 0;
}
int main() {
findingReminder();
int zeroNum = 0;
bool used[4];
for (int i = 0; i < 4; ++i) {
used[i] = false;
}
string in, out;
out = "";
cin >> in;
int lng = in.size();
int last = 0;
for (int i = 0; i < lng; ++i) {
if (in[i] == '0') {
zeroNum++;
continue;
}
int myFlag = false;
for (int j = 0; j < 4; j++) {
if (('0' + myDig[j]) == in[i] && used[j] == false) {
used[j] = true;
myFlag = true;
break;
}
}
if (myFlag) {
continue;
}
last = (last * 10 + in[i] - '0') % 7;
out += in[i];
}
last = (7 - ((last * 10000) % 7)) % 7;
out += myStringRem[last];
for (int i = 0; i < zeroNum; i++) {
out += '0';
}
cout << out << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
int fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= fl;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const int N = 100005;
int n, mxdeg, deg[N];
vector<int> edge[N];
vector<pair<int, int> > ans;
void dfs(int x, int f, int t) {
ans.emplace_back(make_pair(x, t));
if (t == mxdeg) {
t = mxdeg - deg[x];
ans.emplace_back(make_pair(x, t));
}
for (auto to : edge[x]) {
if (to == f) continue;
dfs(to, x, t + 1);
t++;
if (ans.back().second != t - 1) ans.emplace_back(make_pair(to, t - 1));
ans.emplace_back(make_pair(x, t));
if (f && t == mxdeg) {
t = mxdeg - deg[x];
ans.emplace_back(make_pair(x, t));
}
}
}
int main() {
read(n);
if (n == 1) {
puts("1");
puts("1 0");
return 0;
}
for (int i = 1; i < n; i++) {
int u, v;
read(u, v);
edge[u].emplace_back(v), edge[v].emplace_back(u);
deg[u]++, deg[v]++;
mxdeg = max(mxdeg, deg[u]);
mxdeg = max(mxdeg, deg[v]);
}
dfs(1, 0, 0);
printf("%d\n", (int)ans.size());
for (auto k : ans) printf("%d %d\n", k.first, k.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
inline char gc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
inline void read(T &x) {
x = (T)0;
T f = 1;
char ssd = gc();
while (ssd < '0' || ssd > '9') f = ssd == '-' ? -1 : 1, ssd = gc();
while (ssd >= '0' && ssd <= '9')
x = (x << 3) + (x << 1) + (ssd - '0'), ssd = gc();
x = x * f;
}
char OUT[1000000], *S = OUT, *T = OUT + 1000000;
char Num[1000000];
int toP;
inline void out() {
fwrite(OUT, sizeof(char), S - OUT, stdout);
S = OUT;
}
inline void pc(char ssd) {
*S++ = ssd;
if (S == T) out();
}
template <typename T>
inline void write(T x) {
if (x == 0) pc('0');
if (x < 0) x = -x, pc('-');
toP = 0;
while (x) Num[++toP] = x % 10 + '0', x /= 10;
while (toP) pc(Num[toP--]);
}
}; // namespace IO
const int maxn = 1e6 + 10;
int L[maxn], R[maxn];
int cnt;
int n, m;
long long A[maxn], value[maxn];
int top;
namespace st {
long long f[maxn][25];
int Log[maxn];
inline void init(int lenth) {
for (register int i = 2; i <= lenth; i += 1) Log[i] = Log[i >> 1] + 1;
for (register int i = 1; i <= lenth; i += 1) f[i][0] = R[i] - L[i];
for (register int j = 1; j < 25; j += 1)
for (register int i = 1; i + (1 << j) - 1 <= n; i += 1)
f[i][j] = min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
inline long long ask(int l, int r) {
int s = Log[r - l + 1];
return min(f[l][s], f[r - (1 << s) + 1][s]);
}
} // namespace st
int lst[maxn];
int main() {
scanf("%d %d", &n, &m);
for (register int i = 1; i <= n; i += 1)
scanf("%lld", &A[i]), value[i] = A[i];
sort(value + 1, value + n + 1);
top = unique(value + 1, value + n + 1) - value - 1;
for (register int i = 1; i <= n; i += 1)
A[i] = lower_bound(value + 1, value + top + 1, A[i]) - value;
for (register int i = 1; i <= n; i += 1) {
if (lst[A[i]]) {
int pre = lst[A[i]];
if (!cnt || L[cnt] < pre) L[++cnt] = pre, R[cnt] = i;
}
lst[A[i]] = i;
}
st::init(cnt);
while (m--) {
int l, r;
scanf("%d %d", &l, &r);
l = lower_bound(L + 1, L + cnt + 1, l) - L;
r = upper_bound(R + 1, R + cnt + 1, r) - R - 1;
if (l > r)
puts("-1");
else
printf("%lld\n", st::ask(l, r));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
tuple<long long, long long, long long> arr[n - 1];
long long s1, e1;
cin >> s1 >> e1;
for (long long i = 0; i < n - 1; ++i) {
long long s2, e2;
cin >> s2 >> e2;
arr[i] = make_tuple(e2 - s1 + 1, s2 - e1 - 1, i);
s1 = s2, e1 = e2;
}
pair<long long, long long> blen1[m];
long long blen2[m];
for (long long i = 0; i < m; ++i) {
long long b;
cin >> b;
blen1[i] = make_pair(b, i);
blen2[i] = b;
}
sort(arr, arr + n - 1);
sort(blen1, blen1 + m);
sort(blen2, blen2 + m);
pair<long long, long long> num_b[n - 1];
for (long long i = 0; i < n - 1; ++i) {
long long end, start, idx, u = 0, l = 0;
tie(end, start, idx) = arr[i];
l = upper_bound(blen2, blen2 + m, start) - blen2;
u = lower_bound(blen2, blen2 + m, end) - blen2;
if (u - l == 0) {
cout << "No" << endl;
return 0;
} else {
num_b[i] = make_pair(l, u);
}
}
set<pair<long long, long long> > bg;
for (long long i = 0; i < m; ++i) {
bg.insert(blen1[i]);
}
long long ans[n - 1];
for (long long i = 0; i < n - 1; ++i) {
long long u = num_b[i].second, l = num_b[i].first;
set<pair<long long, long long> >::iterator itr =
bg.upper_bound({blen2[l], -1});
if (itr == bg.end() || (u != m && (*itr).first >= blen2[u])) {
cout << "No" << endl;
return 0;
}
ans[get<2>(arr[i])] = (*itr).second + 1;
bg.erase(itr);
}
cout << "Yes" << endl;
for (long long i = 0; i < n - 1; ++i) {
cout << ans[i] << " ";
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n, outpot;
int k[10];
k[0] = 32640;
k[1] = 8128;
k[2] = 2016;
k[3] = 496;
k[4] = 120;
k[5] = 28;
k[6] = 6;
k[7] = 1;
cin >> n;
for (int i = 0; i <= 8; i++) {
if (n % k[i] == 0) {
outpot = k[i];
break;
}
}
cout << outpot;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
bool length[300010];
long long expo1[300010], expo2[300010];
set<long long> st1;
set<long long> st2;
void hashf(char s[]) {
long long sum = 0LL, sum2 = 0LL;
int len = strlen(s);
for (int i = 0; i < len; i++) {
sum = (sum + (expo1[i] * (s[len - i - 1] - 96)) % 1000000007) % 1000000007;
sum2 =
(sum2 + (expo2[i] * (s[len - i - 1] - 96)) % 1040002121) % 1040002121;
}
for (int i = 0; i < len; i++) {
if (s[len - i - 1] == 'a' || s[len - i - 1] == 'b') {
st1.insert((sum + expo1[i]) % 1000000007);
st2.insert((sum2 + expo2[i]) % 1040002121);
}
if (s[len - i - 1] == 'b' || s[len - i - 1] == 'c') {
st1.insert((((sum - expo1[i]) % 1000000007) + 1000000007) % 1000000007);
st2.insert((((sum2 - expo2[i]) % 1040002121) + 1040002121) % 1040002121);
}
if (s[len - i - 1] == 'a') {
st1.insert((sum + (expo1[i] * 2) % 1000000007) % 1000000007);
st2.insert((sum2 + (expo2[i] * 2) % 1040002121) % 1040002121);
}
if (s[len - i - 1] == 'c') {
st1.insert(
(((sum - (expo1[i] * 2) % 1000000007) % 1000000007) + 1000000007) %
1000000007);
st2.insert(
(((sum2 - (expo2[i] * 2) % 1040002121) % 1040002121) + 1040002121) %
1040002121);
}
}
return;
}
int main() {
expo1[0] = 1LL, expo2[0] = 1LL;
for (int i = 1; i <= 300000; i++) {
expo1[i] = (expo1[i - 1] * 10) % 1000000007;
expo2[i] = (expo2[i - 1] * 10) % 1040002121;
}
int n, m, len;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
len = strlen(s);
if (len <= 300000) {
length[len] = true;
hashf(s);
}
}
for (int i = 0; i < m; i++) {
scanf("%s", s);
int len = strlen(s);
if (len > 300000) len = 300005;
if (len == 300005 || !length[len]) {
printf("NO\n");
continue;
}
long long sum = 0, sum2 = 0;
len = strlen(s);
for (int i = 0; i < len; i++) {
sum =
(sum + (expo1[i] * (s[len - i - 1] - 96)) % 1000000007) % 1000000007;
sum2 =
(sum2 + (expo2[i] * (s[len - i - 1] - 96)) % 1040002121) % 1040002121;
}
if (st1.count(sum) && st2.count(sum2))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Trace[50000 + 5];
long long d[50000 + 5][500 + 5], res;
vector<int> c[50000 + 5];
void Init();
void Process();
int main() {
Init();
Process();
return 0;
}
void Add(int p, int q) { c[p].push_back(q); }
void Init() {
int p, q;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &p, &q);
Add(p, q);
Add(q, p);
}
}
void DFS(int i) {
vector<int>::iterator it;
for (it = c[i].begin(); it != c[i].end(); ++it)
if (Trace[*it] == 0) {
Trace[*it] = i;
DFS(*it);
}
d[i][0] = 1ll;
for (it = c[i].begin(); it != c[i].end(); ++it)
if (Trace[*it] == i) {
for (int j = 1; j < m; ++j) res += d[i][j] * d[*it][m - 1 - j];
for (int j = 1; j <= m; ++j) d[i][j] += d[*it][j - 1];
}
res += d[i][m];
}
void Process() {
if (m == 1) {
printf("%d\n", n - 1);
return;
}
Trace[1] = -1;
DFS(1);
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
const int MOD = 1e9 + 7;
const int INF = 1e9;
int main(void){
while(1){
int n; cin >> n;
if(n == 0) break;
priority_queue<pint, vector<pint>, greater<pint> > q;
q.push(make_pair(0, INF));
map<int, vpint> m;
rep(i, n){
char c; cin >> c;
if(c == 'W'){
int num, size; cin >> num >> size;
while(size > 0){
int l = q.top().fi, r = q.top().se;
q.pop();
if(r - l + 1 >= size){//??????
q.push(make_pair(l + size, r));
m[num].push_back(make_pair(l, l + size - 1));
size = 0;
}else{//?¶??????????
m[num].push_back(make_pair(l, r));
size -= (r - l + 1);
}
}
}else if(c == 'D'){
int num; cin >> num;
for(auto u : m[num]){
q.push(make_pair(u.fi, u.se));
}
m[num].erase(all(m[num]));
}else{
int idx; cin >> idx;
bool flag = false;
each(it, m){
auto key = it->fi;
auto v = it->se;
for (int i = 0; i < v.size(); ++i){
if(v[i].fi <= idx && idx <= v[i].se){
printf("%d\n", key);
flag = true;
break;
}
}
if(flag) break;
}
if(!flag){
printf("-1\n");
}
}
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int s[100005], t[100005], choose[100005];
int n, m, x, y, z, k, w, cnt, best;
bool ok;
struct node {
int a, b, c;
node() {}
node(int a, int b, int c) : a(a), b(b), c(c) {}
};
vector<node> p, res;
void flip(node q) {
s[q.a] = 1 - s[q.a];
s[q.b] = 1 - s[q.b];
s[q.c] = 1 - s[q.c];
}
void check(int x) {
if (x == p.size()) {
bool t = true;
for (int i = (0); i < (n); i++)
if (s[i] == 1) t = false;
int cnt = 0;
for (int i = (0); i < (p.size()); i++) cnt += choose[i];
if (t == true && (cnt <= best || ok == false)) {
ok = true;
best = cnt;
res.clear();
for (int i = (0); i < (p.size()); i++)
if (choose[i]) res.push_back(p[i]);
}
} else {
check(x + 1);
flip(p[x]);
choose[x] = 1;
check(x + 1);
choose[x] = 0;
flip(p[x]);
}
}
void solve2(int n) {
int base = n - 8;
res.push_back(node(base + 1, base + 3, base + 5));
res.push_back(node(base + 1, base + 4, base + 7));
res.push_back(node(base + 3, base + 4, base + 5));
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) scanf("%d", &s[i]), t[i] = s[i];
if (n <= 10) {
best = 1000;
for (int i = (0); i < (n); i++)
for (int j = (i + 1); j < (n); j++)
for (int k = (j + 1); k < (n); k++) {
if (k - j == j - i) p.push_back(node(i, j, k));
}
check(0);
if (!ok) {
puts("NO");
return 0;
} else {
puts("YES");
printf("%d\n", 1 * res.size());
for (node tmp : res)
printf("%d %d %d\n", tmp.a + 1, tmp.b + 1, tmp.c + 1);
}
} else {
for (int i = (0); i < (n); i++) {
if (s[i] != 1) continue;
for (int j = (1); j < (20); j++) {
if (i + j + j >= n) break;
x = s[i] + s[i + j] + s[i + j + j];
if (x == 3) {
flip(node(i, i + j, i + j + j)),
res.push_back(node(i, i + j, i + j + j));
break;
}
}
if (s[i] != 1) continue;
for (int j = (1); j < (20); j++) {
if (i + j + j >= n) break;
x = s[i] + s[i + j] + s[i + j + j];
if (x == 2) {
flip(node(i, i + j, i + j + j)),
res.push_back(node(i, i + j, i + j + j));
break;
}
}
if (s[i] != 1) continue;
if (i >= 7)
solve2(i + 1);
else
flip(node(i, i + 1, i + 2)), res.push_back(node(i, i + 1, i + 2));
}
puts("YES");
printf("%d\n", 1 * res.size());
for (node tmp : res) printf("%d %d %d\n", tmp.a + 1, tmp.b + 1, tmp.c + 1);
}
return 0;
}
| 5 |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main() {
double xa1, ya1, xa2, ya2, xb1, yb1, xb2, yb2;
while (cin >> xa1 >> ya1 >> xa2 >> ya2 >> xb1 >> yb1 >> xb2 >> yb2)
{
if (xa1 > xa2)
swap(xa1, xa2);
if (ya1 > ya2)
swap(ya1, ya2);
if (xb1 > xb2)
swap(xb1, xb2);
if (yb1 > yb2)
swap(yb1, yb2);
if (xb1 <= xa1&&xa1 <= xb2 || xb1 <= xa2&&xa2 <= xb2 || xa1 <= xb1&&xb1 <= xa2 || xa1 <= xb2&&xb2 <= xa2) {
if (yb1 <= ya1&&ya1 <= yb2 || yb1 <= ya2&&ya2 <= yb2 || ya1 <= yb1&&yb1 <= ya2 || ya1 <= yb2&&yb2 <= ya2) {
cout << "YES";
}
else cout << "NO";
}
else cout << "NO";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, a, b;
cin >> n >> a >> b;
cin >> s;
cout << !(s[a - 1] == s[b - 1]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int n,a[30]={0};
string s;
cin >> n;
cin >> s;
for(int i=0;i<n;i++){
a[s[i]-'a']++;
}
long long int ans=1;
for(int i=0;i<30;i++){
ans *= (a[i]+1);
ans %= 1000000007;
}
cout << ans-1 << endl;
}
| 0 |
#include<cstdio>
using namespace std;
int main(){int n;scanf("%d",&n);printf("%d",n*n*n);return 0;}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int MOD = 1e9 + 7;
ll INF = 1e18;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int main(){
int W, H, w, h; cin>>W>>H>>w>>h;
double x, y; cin>>x>>y;
double X=x, Y=y;
if(x+w/2>W/2 && y+h/2>H/2){
X=((x-w/2)+W/2)/2;
Y=((y-h/2)+H/2)/2;
}
else if(y+h/2>=H/2){
Y=((y-h/2)+H/2)/2;
}
else if(x+w/2>=W/2){
X=((x-w/2)+W/2)/2;
}
cout << fixed << setprecision(10) << Y/X << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
if (n <= 2)
cout << "-1";
else
for (i = n; i > 0; i--) cout << i << ' ';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, k;
cin >> a >> b >> k;
for(int i = a; i <= b; i++) {
if(i < a+k or b-k < i)
cout << i << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cup = 0, cdown = 0;
for (int i = 0; i < s.size(); i++) {
if (isupper(s[i]))
cup++;
else
cdown++;
}
if (cup > cdown) {
char ch;
for (int i = 0; i < s.size(); i++) {
ch = toupper(s[i]);
cout << ch;
}
} else {
char ch;
for (int i = 0; i < s.size(); i++) {
ch = tolower(s[i]);
cout << ch;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const int mod = (int)1e9 + 7;
const double PI = acos(-1.0);
const int MAX = 1001;
int n, s, d;
int main() {
cin >> n;
int x = 1;
for (int i = 0; i < n; i++) {
cin >> s >> d;
if (x <= s) {
x = s;
} else {
int k = (x - s + d - 1) / d;
x = s + k * d;
}
x++;
}
cout << x - 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double h, d, c, n, val1, val2;
int hh, m;
cin >> hh >> m;
cin >> h >> d >> c >> n;
int div;
div = ceil(h / n);
val1 = div * c;
if (hh < 20) {
int minutes = 60 - m;
if (minutes == 60) {
minutes = (20 - hh) * 60;
} else {
minutes += (20 - hh - 1) * 60;
}
val2 = ceil((h + (minutes)*d) / n);
val2 = val2 * c * 0.8;
if (val1 > val2) {
printf("%.4f", val2);
} else {
printf("%.4f", val1);
}
} else
printf("%.4f", val1 * .8);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[300005], b[300005];
int n, m;
bool Check(int x) {
b[n + 1] = m - 1;
for (int i = n; i; i--) {
if (a[i] > b[i + 1]) {
if (a[i] + x >= m)
b[i] = min(b[i + 1], (a[i] + x) % m);
else
return 0;
} else
b[i] = min(b[i + 1], a[i] + x);
if (b[i] > b[i + 1]) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l = 0, r = m;
while (l <= r) {
int mid = l + r >> 1;
if (Check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", l);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 2019;
char m[N][N];
int f[N], d[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", m[i]);
int ans = 0;
for (int i = 0; i < n; i++) {
int inv = 0;
for (int j = n - 1; j > i; j--) {
if ((inv ^ f[j]) != m[i][j] - '0') {
ans++;
inv ^= 1;
f[j] ^= 1;
}
}
d[i] = inv ^ f[i];
}
memset(f, 0, sizeof(f));
for (int i = n - 1; i >= 0; i--) {
int inv = 0;
for (int j = 0; j < i; j++) {
if ((inv ^ f[j]) != m[i][j] - '0') {
ans++;
inv ^= 1;
f[j] ^= 1;
}
}
d[i] ^= inv ^ f[i];
}
for (int i = 0; i < n; i++) ans += (d[i] != m[i][i] - '0');
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
typedef long long LL;
int main(){
int n;
cin >> n;
string s;
cin >> s;
vector<int> Rr(n+1,0),Lr(n+1,0);
for(int i=1;i<=n;i++){
if(s[i-1]=='>'){
Rr[i]=Rr[i-1]+1;
Lr[i]=Lr[i-1];
}else{
Rr[i]=Rr[i-1];
Lr[i]=Lr[i-1]+1;
}
}
int ans=0;
for(int i=1;i<=n;i++){
if(s[i-1]=='>'){
if(Rr[i]>Lr[n]-Lr[i]){
ans=max(ans,n-(lower_bound(Rr.begin(),Rr.end(),Rr[i]-(Lr[n]-Lr[i]))-Rr.begin())+1);
//cout << n-(lower_bound(Rr.begin(),Rr.end(),Rr[i]-(Lr[n]-Lr[i]))-Rr.begin())+1 << endl;
}else{
ans=max(ans,lower_bound(Lr.begin(),Lr.end(),Rr[i]+Lr[i])-Lr.begin());
//cout << lower_bound(Lr.begin(),Lr.end(),Rr[i]+Lr[i])-Lr.begin() << endl;
}
}else{
if(Rr[i-1]>=Lr[n]-Lr[i-1]){
ans=max(ans,n-(lower_bound(Rr.begin(),Rr.end(),Rr[i-1]-(Lr[n]-Lr[i-1])+1)-Rr.begin()-1));
//cout << n-(lower_bound(Rr.begin(),Rr.end(),Rr[i-1]-(Lr[n]-Lr[i-1])+1)-Rr.begin()-1) << endl;
}else{
ans=max(ans,lower_bound(Lr.begin(),Lr.end(),Rr[i-1]+Lr[i-1]+1)-Lr.begin());
//cout << lower_bound(Lr.begin(),Lr.end(),Rr[i-1]+Lr[i-1]+1)-Lr.begin() << endl;
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos((double)-1);
int ts, ts2;
int n, m, ha[100005], a[505];
long long gcd(long long x, long long y) {
long long t;
for (; y != 0;) {
t = x % y;
x = y;
y = t;
}
return x;
}
int main() {
int i, j, k, t1, t2, t3, t4, t5, t, x;
double u1, u2, u3, u4, u5;
char c1, c2, c3;
srand((unsigned)time(0));
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), ha[a[i]] = 1;
int tag = 0;
if (!ha[x]) a[++n] = x, tag = 1;
sort(a + 1, a + n + 1);
t1 = 2000000000;
for (i = 1; i <= n; i++) {
if (a[i] == x) {
if (i == (n + 1) / 2) t1 = 0;
if (i < (n + 1) / 2) {
t2 = ((n + 1) / 2 - i) * 2;
if (n % 2 == 1) t2--;
t1 = min(t1, t2);
} else if (i > (n + 1) / 2) {
t2 = (i - (n + 1) / 2) * 2;
if (n % 2 == 0) t2--;
t1 = min(t1, t2);
}
}
}
t1 = max(t1, 0);
cout << t1 + tag << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
map<string, long long> mp;
map<string, long long> mp1;
class cmp {
public:
bool operator()(const pair<long long, string> &a,
const pair<long long, string> &b) {
if (a.first != b.first) {
return a.first < b.first;
} else {
return a.second > b.second;
}
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string me, ss;
mp["commented"] = 10, mp["posted"] = 15, mp["likes"] = 5;
cin >> me;
long long n;
cin >> n;
cin.ignore();
priority_queue<pair<long long, string>, vector<pair<long long, string> >, cmp>
qq;
for (long long i = 0; i < n; i++) {
getline(cin, ss);
vector<string> temp;
string res;
for (long long j = 0; j < (long long)ss.length(); j++) {
if (temp.size() == 3) break;
if (ss[j] == ' ') {
if (res == "on" && temp.size() == 2) {
res = "";
continue;
}
if (temp.size() == 2) {
res.pop_back();
res.pop_back();
}
temp.push_back(res);
res = "";
} else {
res += ss[j];
}
}
if (temp.size() == 3) {
if (temp.back() == me) {
mp1[temp[0]] += mp[temp[1]];
} else if (temp[0] == me) {
mp1[temp.back()] += mp[temp[1]];
} else {
mp1[temp.back()] += 0;
mp1[temp[0]] += 0;
}
}
}
for (auto ff : mp1) {
qq.push({ff.second, ff.first});
}
while (!qq.empty()) {
cout << qq.top().second << "\n";
qq.pop();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using std::abs;
using std::cerr;
using std::cin;
using std::cout;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::string;
using std::swap;
using std::vector;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
void _dbg(const char* _s, T _h) {
cerr << _s << " = " << _h << "\n";
}
template <typename T, typename... Ts>
void _dbg(const char* _s, T _h, Ts... _t) {
int _b = 0;
while (((_b += *_s == '(') -= *_s == ')') != 0 || *_s != ',') cerr << *_s++;
cerr << " = " << _h << ",";
_dbg(_s + 1, _t...);
}
struct init {
init() {
cin.tie(0);
std::iostream::sync_with_stdio(0);
cout << std::fixed << std::setprecision(10);
cerr << std::fixed << std::setprecision(5);
}
~init() {}
} init;
const int MAXN = 1e5 + 5;
int dp[MAXN][33];
const int MAXMOD = 2;
const ll MOD[MAXMOD] = {1000000007, 1000000009};
const ll BASE[MAXMOD] = {29, 31};
ll pw[MAXMOD][MAXN];
struct hash_init {
hash_init() {
for (int j = 0; j < MAXMOD; ++j) {
pw[j][0] = 1;
for (int i = 1; i < MAXN; ++i)
pw[j][i] = (pw[j][i - 1] * BASE[j]) % MOD[j];
}
}
} hash_init;
struct hash_string {
string s;
vector<int> hash[MAXMOD];
ll get(int num, int l, int r) {
return (hash[num][r] - hash[num][l - 1] + MOD[num]) % MOD[num];
}
char operator[](int i) const { return s[i]; }
void build() {
s = "#" + s;
for (int j = 0; j < MAXMOD; ++j) {
hash[j].assign(s.size(), 0);
for (uint i = 1; i < s.size(); ++i)
hash[j][i] = (hash[j][i - 1] + pw[j][i] * (s[i] - 'a' + 1)) % MOD[j];
}
}
hash_string() {}
hash_string(const string& _s) : s(_s) { build(); }
};
bool equal(hash_string& s1, int l1, int r1, hash_string& s2, int l2, int r2) {
if (l1 <= l2) {
for (int i = 0; i < MAXMOD; ++i)
if (s2.get(i, l2, r2) != (s1.get(i, l1, r1) * pw[i][l2 - l1]) % MOD[i])
return false;
return true;
} else {
for (int i = 0; i < MAXMOD; ++i)
if (s1.get(i, l1, r1) != (s2.get(i, l2, r2) * pw[i][l1 - l2]) % MOD[i])
return false;
return true;
}
}
int lcp(hash_string& s1, int l1, int r1, hash_string& s2, int l2, int r2) {
if (s1[l1] != s2[l2]) return 0;
if (equal(s1, l1, r1, s2, l2, r2)) return (r1 - l1 + 1);
int l = 0, r = min(r2 - l2, r1 - l1) + 1;
while (r - l > 1) {
int m = r + l >> 1;
if (equal(s1, l1, l1 + m, s2, l2, l2 + m))
l = m;
else
r = m;
}
return l + 1;
}
std::istream& operator>>(std::istream& is, hash_string& s) {
auto& t = (is >> s.s);
s.build();
return t;
}
void upx(int& x, int y) {
if (x < y) x = y;
}
template <typename T>
void hash_combine(std::size_t& seed, T const& key) {
std::hash<T> hasher;
seed ^= hasher(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
namespace std {
template <typename T1, typename T2>
struct hash<std::pair<T1, T2>> {
std::size_t operator()(std::pair<T1, T2> const& p) const {
std::size_t seed1(0);
::hash_combine(seed1, p.first);
::hash_combine(seed1, p.second);
std::size_t seed2(0);
::hash_combine(seed2, p.second);
::hash_combine(seed2, p.first);
return std::min(seed1, seed2);
}
};
} // namespace std
std::unordered_map<pii, int> used;
int getlcp(hash_string& s1, int l1, int r1, hash_string& s2, int l2, int r2) {
pii p{l1, l2};
if (!used.count(p)) {
used[p] = lcp(s1, l1, r1, s2, l2, r2);
}
return used[p];
}
int main() {
hash_string s, t;
int n, m, x;
cin >> n >> s >> m >> t >> x;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= x; ++j) {
upx(dp[i + 1][j], dp[i][j]);
int we = getlcp(s, i + 1, n, t, dp[i][j] + 1, m);
upx(dp[i + we][j + 1], dp[i][j] + we);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= x; ++j)
;
string ans = "NO\n";
for (int j = x; j >= 0; --j)
if (dp[n][j] == m) ans = "YES\n";
cout << ans;
return 0;
}
| 5 |
#include <iostream>
#include <string>
using namespace std;
int N, X[100009];
string S[100009], T;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> S[i] >> X[i];
}
cin >> T;
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (S[i] == T) {
for (int j = i + 1; j <= N; j++) cnt += X[j];
break;
}
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using u64 = unsigned long long;
const int maxN = 123456;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int n, a[maxN], g[20][maxN], f[maxN];
i64 cnt[maxN];
const int kW = 100001;
i64 floordiv(i64 a, i64 b) {
if (a > 0)
return a / b;
else if (a % b == 0)
return a / b;
else
return a / b - 1;
}
i64 ksum(i64 a, i64 b, i64 c, i64 n) {
i64 ans = 0;
ans += (b / c) * n;
b %= c;
ans += (a / c) * n * (n - 1) / 2;
a %= c;
if (a * n + b < c)
return ans;
else
return ans + ksum(c, (a * n + b) % c, a, (a * n + b) / c);
}
i64 rangesum(i64 l1, i64 l2, i64 a, i64 b, i64 c) {
if (l1 > l2) return 0;
i64 d = floordiv(b, c);
b = b - d * c;
return ksum(a, b, c, l2 + 1) - ksum(a, b, c, l1) + d * (l2 - l1 + 1);
}
i64 calcK(i64 a1, i64 d1, i64 n1, i64 a2, i64 d2, i64 n2, i64 k) {
k = -(k + a1 - a2) - 1 + d1;
i64 r1 = floordiv(-k - 1, d2);
i64 r2 = floordiv(n1 * d1 - 1 - k, d2);
i64 ans = 0;
ans += rangesum(max(r1 + 1, 0ll), min(r2, n2 - 1), d2, k, d1);
ans += max(n2 - max(r2 + 1, 0ll), 0ll) * n1;
return ans;
}
i64 posl[maxN], posr[maxN];
i64 count(i64 K) {
i64 sl = 0;
cnt[kW] = 1;
vector<i64> v;
for (int i = 1; i <= kW; i++) {
posl[i] = sl;
sl += cnt[i] * i;
posr[i] = sl - i;
}
int lpos = 1;
i64 csum = 0;
i64 ans = 0;
for (int i = 1; i <= kW; i++) {
if (cnt[i] == 0) continue;
while (posr[lpos] < posl[i] - K) {
csum += cnt[lpos];
lpos++;
}
ans += csum * cnt[i];
for (int j = lpos; j <= kW; j++) {
if (posl[j] >= posr[i] - K) break;
ans += calcK(posl[j], j, cnt[j], posl[i], i, cnt[i], K);
}
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
g[0][i] = a[i];
}
for (int i = 1; i <= 17; i++) {
for (int j = 1; j + (1 << i) - 1 <= n; j++) {
g[i][j] = gcd(g[i - 1][j], g[i - 1][j + (1 << (i - 1))]);
}
}
for (int i = 2; i <= n; i++) f[i] = f[i >> 1] + 1;
auto query = [&](int l, int r) {
int d = f[(r - l + 1)];
return gcd(g[d][l], g[d][r - (1 << d) + 1]);
};
for (int i = 1; i <= n; i++) {
int d1 = a[i], d2 = query(i, n);
int pos = i;
while (1) {
if (d1 == d2) {
cnt[d1] += n - pos + 1;
break;
} else {
int l = pos, r = n;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (query(i, mid) == d1)
l = mid;
else
r = mid;
}
cnt[d1] += l - pos + 1;
pos = l + 1;
d1 = query(i, pos);
}
}
}
i64 totnum = (i64)n * (n + 1) / 2;
totnum = totnum * (totnum + 1) / 2;
i64 midc = (totnum - 1) / 2;
i64 l = 0, r = 1ll << 60;
while (l + 1 < r) {
i64 mid = (l + r) >> 1;
if (totnum - count(mid) <= midc)
l = mid;
else
r = mid;
}
printf("%lld\n", r);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << ": " << a << " ";
err(++it, args...);
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<pii>;
using vll = vector<ll>;
using vs = vector<string>;
const int DR[] = {-1, 0, 1, 0, -1, 1, 1, -1};
const int DC[] = {0, -1, 0, 1, -1, -1, 1, 1};
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int MOD = 1e9 + 7;
const int INF = 1073741823;
const ll INFLL = 4e18;
const int MAX = 2e3;
int A, N, M;
bool rain[MAX + 5];
int umb[MAX + 5], dp[MAX + 5][MAX + 5];
void read() {
cin >> A >> N >> M;
for (int i = 0; i < (int)N; i++) {
int l, r;
cin >> l >> r;
for (int j = (int)l; j <= (int)r - 1; j++) rain[j] = true;
}
memset(umb, -1, sizeof umb);
for (int i = 0; i < (int)M; i++) {
int x, w;
cin >> x >> w;
if (umb[x] == -1)
umb[x] = w;
else
umb[x] = min(umb[x], w);
}
}
int solve(int pos, int idx) {
if (pos > 0 && rain[pos - 1] && idx >= A) return INF;
if (pos == A) return 0;
int &ret = dp[pos][idx];
if (ret != -1) return ret;
if (idx < A) {
ret = umb[idx] + solve(pos + 1, idx);
ret = min(ret, solve(pos + 1, A));
if (umb[pos] != -1) ret = min(ret, umb[pos] + solve(pos + 1, pos));
} else {
ret = solve(pos + 1, A);
if (umb[pos] != -1) ret = min(ret, umb[pos] + solve(pos + 1, pos));
}
return ret;
}
void solve() {
memset(dp, -1, sizeof dp);
int ans = solve(0, A);
cout << (ans == INF ? -1 : ans) << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC = 1;
for (int tc = (int)1; tc <= (int)TC; tc++) {
read();
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solutionA();
int main() {
ios_base::sync_with_stdio(false);
solutionA();
return EXIT_SUCCESS;
}
long long n, k, a[2 * 100000];
void solve() {
map<long long, long long> s;
set<long long> t;
for (long long i = 0; i < n; ++i) ++s[a[i]], t.insert(a[i]);
if (t.size() == 1) {
cout << 0 << endl;
return;
}
for (long long i = 0; i < n; ++i) {
a[n + i] = a[i + k - 1];
++s[a[i + k - 1]];
--s[a[i]];
if (s[a[i]] == 0) t.erase(a[i]);
t.insert(a[i + k - 1]);
if (t.size() == 1) {
cout << i + 1 << endl;
return;
}
}
cout << -1 << endl;
}
void solutionA() {
for (; cin >> n >> k;) {
for (long long i = 0; i < n; ++i) cin >> a[i];
solve();
cerr << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b;
cin >> x >> y >> a >> b;
if (x <= a && y <= b) {
cout << "Polycarp";
return 0;
}
if (x >= a && y >= b) {
cout << "Vasiliy";
return 0;
}
if (a > x) {
int count = 0;
while (a > x && b > 0) {
count++;
a--;
b--;
}
while (a > x) {
count++;
a--;
}
while (count > 0) {
y--;
count--;
}
if (y <= b)
cout << "Polycarp";
else
cout << "Vasiliy";
return 0;
}
if (a < x) {
int count = 0;
while (a > 0 && b > y) {
count++;
a--;
b--;
}
while (b > y) {
count++;
b--;
}
while (count > 0) {
x--;
count--;
}
if (x <= a)
cout << "Polycarp";
else
cout << "Vasiliy";
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i = 0, j = 0, c = 0, k = 0, n = 0, w, d = 0, f = 0, s = 0,
sum = 0, t = 0, m = 0, l = 0, r = 0, x = 0, u, u1;
string a;
getline(cin, a);
n = a.size();
for (i = 0; i < n; i++) {
if (a[i] != ' ') {
if (f != 2 && i - 1 >= 0 && a[i - 1] == ' ' && a[i] != '?' &&
a[i] != '.' && a[i] != '!' && a[i] != ',') {
cout << ' ';
}
cout << a[i];
f = 1;
if (a[i] == '?' or a[i] == '.' or a[i] == '!' or a[i] == ',') {
cout << ' ';
f = 2;
}
}
}
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
int N, D[51] = {}, pos[51] = {};
cin >> N;
for(int i = 1; i <= N; i++){
cin >> D[i];
}
sort(D, D+(N+1));
bool right = true;
for(int i = 0; i <= N; i++){
if(right){
pos[i] = D[i];
}else{
pos[i] = (24-D[i])%24;
}
right = !right;
}
sort(pos, pos+(N+1));
for(int i = 0; i <= N; i++){
//printf("%d: %d\n", i, pos[i]);
}
int ans = 10000;
for(int i = 0; i < N; i++){
ans = min(ans, pos[i+1] - pos[i]);
}
ans = min(ans, 24 - pos[N]);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
void dfs(vector<int> g[], bool p[], bool f[], int u, bool flip[], int h = 0,
int pa = -1) {
if ((p[u] == f[u] && !flip[h % 2]) || (p[u] != f[u] && flip[h % 2]))
;
else {
flip[h % 2] = !flip[h % 2];
ans.push_back(u + 1);
}
bool f0 = flip[0], f1 = flip[1];
for (auto v : g[u]) {
if (v != pa) dfs(g, p, f, v, flip, h + 1, u);
flip[0] = f0;
flip[1] = f1;
}
return;
}
int main() {
int n;
cin >> n;
vector<int> g[n];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
bool p[n], f[n];
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> f[i];
bool flip[2];
flip[0] = flip[1] = false;
dfs(g, p, f, 0, flip);
cout << ans.size() << endl;
for (auto x : ans) {
cout << x << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 1, count = 0;
cin >> n;
if (n == 1) {
cout << 1 << endl;
} else {
while (n > 0) {
n = n - (i + (i * (i - 1)) / 2);
count++;
i++;
}
if (n == 0)
cout << count << endl;
else
cout << count - 1 << endl;
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main()
{
int n, k;
while( cin >> n >> k )
{
if( n + k == 0 )
break;
int* a = new int[k];
int b;
for( int i = 0; i < k; i++ )
cin >> a[i];
bool judge = true;
for( int i = 0; i < n; i++ )
for( int j = 0; j < k; j++ )
{
cin >> b;
a[j] -= b;
if( a[j] < 0 )
judge = false;
}
if( judge == 1 )
cout << "Yes" << endl;
else
cout << "No" << endl;
delete a;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define science cout << fixed << setprecision(0);
#define lim 1000000007
#define Crbubble cin.tie(0); ios_base::sync_with_stdio(false);
#define ll long long
#define endl "\n"
using namespace std;
int main()
{ Crbubble
int t,i,n,cou,len,k;
string s;
stack<int> s1;
stack<int> s2;
cin >> t;
while(t--)
{
cin >> s;
cou = 0;
len = s.length();
for(i=0;i<len;i++)
{
if(s[i] == '(')
{
s1.push(1);
}
if(s[i] == ')')
{
if(s1.size())
{
s1.pop();
cou++;
}
}
if(s[i] == '[')
{
s2.push(1);
}
if(s[i] == ']')
{
if(s2.size())
{
s2.pop();
cou++;
}
}
}
while(s1.size()) s1.pop();
while(s2.size()) s2.pop();
cout << cou << endl;
}
return 0;
}
| 3 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<queue>
#include<vector>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define EQ(a,b) (abs((a)-(b))<EPS)
using namespace std;
typedef long double D;
const D EPS = 1e-9;
struct event{
D time;
int type; // 0:lost, 1:collide
int obj1, obj2;
event(D a,int b,int c,int d):time(a),type(b),obj1(c),obj2(d){}
bool operator<(const event &x)const {return time>x.time;}
};
struct meteor{
D px, py, pz, vx, vy, vz, pr, vr;
meteor(D a=0,D b=0,D c=0,D d=0,D e=0,D f=0,D g=0,D h=0):
px(a),py(b),pz(c),vx(d),vy(e),vz(f),pr(g),vr(h){}
};
D collideTime(meteor m1, meteor m2){
const D a1 = m1.vx - m2.vx, a2 = m1.vy - m2.vy, a3 = m1.vz - m2.vz;
const D b1 = m1.px - m2.px, b2 = m1.py - m2.py, b3 = m1.pz - m2.pz;
const D a4 = m1.vr + m2.vr, b4 = m1.pr + m2.pr;
const D a = a1*a1+a2*a2+a3*a3 - a4*a4;
const D b_p = a1*b1+a2*b2+a3*b3 + a4*b4;
const D c = b1*b1+b2*b2+b3*b3 - b4*b4;
if(EQ(a,0)){
if(EQ(b_p,0)){
if(EQ(c,0))return 0;
else return -1.0;
}else return -c/b_p;
}
D azu = b_p*b_p-a*c;
if(azu < -EPS)return -1.0;
if(EQ(azu,0))return b_p/a;
D res1 = (-b_p-sqrt(azu)) /a, res2 = (-b_p+sqrt(azu)) /a;
if(res1 < -EPS)return res2;
return res1;
}
int main(){
int n;
while(cin >> n){
if(n==0)break;
vector<meteor> vm(n);
priority_queue<event> next;
rep(i,n){
D a,b,c,d,e,f,g,h;
cin >> a >> b >> c >> d >> e >> f >> g >> h;
vm[i] = meteor(a,b,c,d,e,f,g,h);
next.push(event(g/h,0,i,-1));
}
rep(i,n)rep(j,i){
D t = collideTime(vm[i],vm[j]);
if(t>=0.0)next.push(event(t,1,i,j));
}
vector<D> res(n,-1.0);
while(next.size()){
event cur = next.top(); next.pop();
if(cur.type == 0){
int m = cur.obj1;
if(res[m] < 0)res[m] = cur.time;
}else{
int m1 = cur.obj1, m2 = cur.obj2;
if(res[m1] < 0 && res[m2] <0)res[m1] = res[m2] = cur.time;
}
}
rep(i,n)cout << fixed << setprecision(10) << res[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double y_1, y_2, yw, xb, yb, r;
int main() {
scanf("%lf%lf%lf%lf%lf%lf", &y_1, &y_2, &yw, &xb, &yb, &r);
yw -= r;
double u = yw + (yw - y_2), v = yw + (yw - y_1);
double mid = max(u, v) - r;
double a, b, c, s, p, h;
a = hypot(0, mid - u);
b = hypot(xb, u - yb);
c = hypot(xb, mid - yb);
p = (a + b + c) / 2;
s = sqrt(p * (p - a) * (p - b) * (p - c));
h = s * 2 / c;
if (h <= r)
printf("-1\n");
else {
double k = xb / (mid - yb);
printf("%.9lf\n", xb - (yw - yb) * k);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void check_max(T& actual, T check) {
if (actual < check) {
actual = check;
}
}
template <class T>
inline void check_min(T& actual, T check) {
if (actual > check) {
actual = check;
}
}
const double EPS = 1e-9;
const int IINF = 1000000000;
const double PI = acos(-1.0);
const long long LINF = 6000000000000000000LL;
namespace Solution {
const int maxK = 27;
const int maxN = 5007;
int n, k, q, A[maxN];
unordered_set<int> G[maxK];
void cleanup() {
for (int i = 0; i < maxK; ++i) {
G[i].clear();
}
}
bool Read() {
cleanup();
if (scanf("%d%d", &n, &k) == 2) {
for (int i = 0; i < n; ++i) {
scanf("%d", A + i);
for (int j = 1; j <= k; ++j) {
G[j].insert(A[i] * j);
}
}
return true;
}
return false;
}
void Run() {
int x;
scanf("%d", &q);
for (int it = 0; it < q; ++it) {
scanf("%d", &x);
int answer = k + 1;
if (G[1].find(x) != G[1].end()) {
printf("1\n");
} else {
int val1, val2;
for (int amount = 2; amount <= k && answer > k; ++amount) {
for (int first = 1; first < amount && answer > k; ++first) {
int second = amount - first;
for (int i = 0; i < n && answer > k; ++i) {
val1 = first * A[i];
val2 = x - val1;
if (G[second].find(val2) != G[second].end()) {
answer = amount;
break;
}
}
}
}
if (answer > k) {
printf("-1\n");
} else {
printf("%d\n", answer);
}
}
}
}
} // namespace Solution
namespace StressTest {
long long GetTime() {
long long res;
asm volatile("rdtsc" : "=A"(res));
return res;
}
void GenerateInput() {
FILE* output = fopen("input.txt", "w");
srand(GetTime());
fclose(output);
}
void BruteForce() {
FILE* input = fopen("input.txt", "r");
FILE* output = fopen("brute.out", "w");
fclose(input);
fclose(output);
}
} // namespace StressTest
int main() {
while (Solution::Read()) {
Solution::Run();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
#define all(x) (x).begin(), (x).end()
int main() {
// std::ios_base::sync_with_stdio(false);
// std::cin.tie(nullptr);
// std::cout.tie(nullptr);
constexpr int INF = std::numeric_limits<int>::max() / 2;
int n, k;
std::cin >> n >> k;
auto ask = [&] (std::vector<int> v) {
std::cout << "?";
for (int x : v) std::cout << " " << x + 1;
std::cout << "\n";
int res;
std::cin >> res;
return res;
};
auto link = [&] (std::vector<int> a, std::vector<int> b) {
std::vector<int> v;
for (int x : a) v.emplace_back(x);
for (int x : b) v.emplace_back(x);
return v;
};
std::vector<int> pre(n + 1, 0), dis(n + 1, INF);
std::queue<int> que;
pre[0] = -1;
dis[0] = 0;
que.emplace(0);
while (!que.empty()) {
int x = que.front();
que.pop();
for (int i = 1; i <= k; ++i) {
if (i <= n - x && k - i <= x) {
int y = x + i * 2 - k;
if (dis[y] == INF) {
dis[y] = dis[x] + 1;
pre[y] = x;
que.emplace(y);
}
}
}
}
if (dis[n] == INF) {
std::cout << "-1\n";
return 0;
}
std::vector<int> t, f(n), p;
for (int i = n; ~i; i = pre[i]) p.emplace_back(i);
std::reverse(all(p));
int ans = 0;
std::iota(all(f), 0);
for (size_t i = 0; i < p.size() - 1; ++i) {
int x = (p[i + 1] - p[i] + k) / 2, y = k - x;
std::vector<int> mt, mf;
for (int j = 0; j < x; ++j) {
mt.emplace_back(f.back());
f.pop_back();
}
for (int j = 0; j < y; ++j) {
mf.emplace_back(t.back());
t.pop_back();
}
ans ^= ask(link(mt, mf));
t.insert(t.end(), all(mt));
f.insert(f.end(), all(mf));
}
std::cout << "! " << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void read(long long &x) {
x = 0;
long long f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
x *= f;
return;
}
long long fs(long long x) { return x < 0 ? -x : x; }
void print(long long x) {
if (x < 10) {
putchar(x + '0');
return;
}
print(x / 10);
putchar(x % 10 + '0');
return;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = fs(x);
}
print(x);
return;
}
long long mint(long long x, long long y) { return x < y ? x : y; }
long long maxt(long long x, long long y) { return x > y ? x : y; }
long long n, a[3005], dp[3005][3005], g[3005][3005], m;
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n + 1; i++)
g[i][i] = dp[i][i] = dp[i][i - 1] = g[i][i - 1] = 1ll;
a[0] = 0x3f3f3f3f3f3f3f;
for (long long len = 2; len <= n; len++)
for (long long l = 1; l + len - 1 <= n; l++) {
long long r = l + len - 1;
long long p = 0;
for (long long k = l; k <= r; k++)
if (a[p] > a[k]) p = k;
dp[l][r] = g[l][r] = dp[l][p - 1] * dp[p + 1][r] % 998244353;
for (long long k = l; k < r; k++)
dp[l][r] = (g[l][k] * dp[k + 1][r] % 998244353 + dp[l][r]) % 998244353;
}
printf("%lld\n", dp[1][n]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct Point {
long long x, y;
} p0;
long long dis(Point a, Point b) {
return (long long)(a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
double ptolin(Point p, Point a, Point b) {
long long pa = dis(p, a);
long long pb = dis(p, b);
long long ab = dis(a, b);
if (pb >= pa + ab)
return min(pa, pb);
else if (pa >= pb + ab)
return min(pa, pb);
else {
Point v1, v2;
v1.x = b.x - a.x;
v1.y = b.y - a.y;
v2.x = p.x - a.x;
v2.y = p.y - a.y;
double cross = v1.x * v2.y - v1.y * v2.x;
if (cross < 0) cross *= -1;
cross = cross * cross / dis(b, a);
return cross;
}
}
vector<Point> p;
int main() {
long long r = 0;
int n;
cin >> n >> p0.x >> p0.y;
for (int i = 0; i < n; i++) {
Point x;
cin >> x.x >> x.y;
p.push_back(x);
long long tmp = dis(x, p0);
r = max(r, tmp);
}
double l = 1e17;
for (int i = 0; i < p.size(); i++) {
int j = (i == p.size() - 1) ? 0 : i + 1;
l = min(l, ptolin(p0, p[i], p[j]));
}
double ans = acos(-1) * (double)(r - l);
printf("%.10f\n", ans);
return 0;
}
| 3 |
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
ll x;
cin >> x;
ll ans=2*(x/11);
x%=11;
if(x==0);
else if(x>6) ans+=2;
else if(x<=6) ans++;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, b;
long long A[100005];
long long B[100005];
long long cost;
int main() {
cin.tie(NULL);
ios::sync_with_stdio(0);
cin >> n >> b;
for (int i = 0; i < n; i++) cin >> A[i];
int high = n, low = 0;
while (high > low) {
long long guess = (high + low + 1) / 2;
cost = 0;
for (int i = 0; i < n; i++) B[i] = A[i] + guess * (i + 1);
sort(B, B + n);
for (int i = 0; i < guess; i++) cost += B[i];
if (cost > b)
high = guess - 1;
else
low = guess;
}
cost = 0;
for (int i = 0; i < n; i++) B[i] = A[i] + low * (i + 1);
sort(B, B + n);
for (int i = 0; i < low; i++) cost += B[i];
cout << low << " " << cost << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
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];
sort(a.begin(), a.end());
cout << a[n / 2] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double fnc(int64_t k, int64_t d, int64_t t) {
if (t <= k) return t;
int64_t m = k / d;
int64_t e = 0;
int64_t period = (m + 1) * d;
if (k % d != 0) {
e = d * (m + 1) - k;
} else
period = max(k, d);
double pt = k + e / 2.0;
int64_t num = floor(t / pt);
double extra = t - num * pt;
double ans = num * period;
ans += min(double(k), extra) + max(double(0), (extra - k) * 2);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t k, d, t;
cin >> k >> d >> t;
printf("%.9lf \n", fnc(k, d, t));
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 2050;
using namespace std;
inline int gi() {
char ch = getchar();
int x = 0, q = 0;
while (ch < '0' || ch > '9') ch == '-' ? q = 1 : 0, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return q ? (-x) : x;
}
int nn[200050][3], head[N], cnt, sa1[N], sa2[N], rk1[N], rk2[N], a[N], vis[N];
long long d1[N], d2[N], f[N][N], g[N][N];
struct date {
int x;
long long s;
date() {}
date(int _x, int _s) {
x = _x, s = _s;
return;
}
bool operator<(const date &c) const { return s > c.s; }
};
inline void Max(long long &x, long long y) {
if (x < y) x = y;
return;
}
inline void Min(long long &x, long long y) {
if (x > y) x = y;
return;
}
void dijkstra(int x, int sa[], long long d[N]) {
memset(d, 50, sizeof(d1)), memset(vis, 0, sizeof(vis));
int s, tot = 0;
date t;
priority_queue<date> Q;
Q.push(date(x, d[x] = 0));
while (!Q.empty()) {
t = Q.top(), Q.pop();
if (vis[t.x]) continue;
sa[++tot] = s = t.x, vis[s] = 1;
for (int i = head[s]; i; i = nn[i][0])
if (d[s] + nn[i][2] < d[nn[i][1]])
Q.push(date(nn[i][1], d[nn[i][1]] = d[s] + nn[i][2]));
}
return;
}
int main() {
int n = gi(), m = gi(), u, v, w, s = gi(), t = gi();
for (int i = 1; i <= n; ++i) a[i] = gi();
for (int i = 1; i <= m; ++i)
u = gi(), v = gi(), w = gi(),
(nn[++cnt][1] = v, nn[cnt][0] = head[u], head[u] = cnt, nn[cnt][2] = w),
(nn[++cnt][1] = u, nn[cnt][0] = head[v], head[v] = cnt, nn[cnt][2] = w);
dijkstra(s, sa1, d1);
dijkstra(t, sa2, d2);
for (int i = 1; i <= n; ++i) rk1[sa1[i]] = i, rk2[sa2[i]] = i;
for (int i = n + 1; i; --i)
for (int j = n + 1; j; --j)
if (i == n + 1 && j == n + 1)
f[i][j] = g[i][j] = 0;
else {
f[i][j] = -1ll << 60, g[i][j] = 1ll << 60;
if (i != n + 1) {
if (rk1[sa2[j]] < i)
f[i][j] = f[i][j + 1];
else {
Max(f[i][j], f[i + 1][j] + a[sa1[i]] * (rk2[sa1[i]] >= j));
if (rk2[sa1[i]] >= j) Max(f[i][j], g[i + 1][j] + a[sa1[i]]);
}
}
if (j != n + 1) {
if (rk2[sa1[i]] < j)
g[i][j] = g[i + 1][j];
else {
Min(g[i][j], g[i][j + 1] - a[sa2[j]] * (rk1[sa2[j]] >= i));
if (rk1[sa2[j]] >= i) Min(g[i][j], f[i][j + 1] - a[sa2[j]]);
}
}
}
if (f[1][1] > 0)
puts("Break a heart");
else if (f[1][1] < 0)
puts("Cry");
else
puts("Flowers");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
string s;
cin >> k >> s;
vector<long long> v;
v.push_back(-1);
int l = s.size();
long long sum = 0, cur = 0;
for (int i = 0; i < l; i++) {
if (s[i] == '1') {
sum += cur * (cur + 1) / 2;
v.push_back(i);
cur = 0;
} else
cur++;
}
if (cur > 0) sum += cur * (cur + 1) / 2;
v.push_back(l);
if (!k)
cout << sum << endl;
else {
long long ans = 0;
int sz = v.size();
for (int i = 1; i < sz - 1; i++) {
int j = i + (k - 1);
if (j < sz - 1) {
int ii = i - 1, jj = j + 1;
ans += (v[i] - v[ii]) * (v[jj] - v[j]);
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> g[N];
int s, t;
bool vis[N];
int use[N];
struct BFS {
int p, val;
bool operator<(const BFS &b) const { return val < b.val; }
};
bool bfs(int x) {
priority_queue<BFS> q;
memset(use, -1, sizeof use);
q.push({s, x});
while (q.size()) {
auto T = q.top();
q.pop();
if (vis[T.p]) T.val = x;
if (T.p == t) return true;
if (T.val == 0) continue;
use[T.p] = T.val;
for (int v : g[T.p]) {
if (T.val - 1 > use[v]) use[v] = T.val - 1, q.push({v, T.val - 1});
}
}
return false;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
vis[x] = true;
}
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
scanf("%d%d", &s, &t);
int l = 0, r = 1e5, ans = 1e9;
while (l <= r) {
int mid = (l + r) >> 1;
if (bfs(mid)) {
r = mid - 1;
ans = min(ans, mid);
} else
l = mid + 1;
}
ans == 1e9 ? puts("-1") : printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[111];
int b[111];
int main() {
cin >> n >> m;
int s = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
s ^= a[i];
}
int tmp = 0;
for (int i = 0; i < m; i++) {
cin >> b[i];
tmp ^= b[i];
}
if (tmp != s) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0) {
cout << (tmp ^ a[0] ^ b[0]) << ' ';
} else if (i == 0) {
cout << b[j] << ' ';
} else if (j == 0) {
cout << a[i] << ' ';
} else {
cout << 0 << ' ';
}
}
cout << endl;
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.