solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long MAX = 2e5 + 5;
long long n = 0, i = 0, j = 0;
void solve() {
cin >> n;
vector<long long> v(n);
long long mp[n + 1];
memset(mp, 0, sizeof(mp));
for (long long i = (0); i < (n); i++) {
cin >> v[i];
mp[v[i]]++;
}
long long ans = 0;
for (long long i = (1); i < (n); i++) v[i] += v[i - 1];
for (i = 0; i <= n - 1; i++) {
for (j = i + 1; j < n; j++) {
long long sum = 0;
if (i == 0)
sum = v[j];
else
sum = v[j] - v[i - 1];
if (sum > n) break;
ans += mp[sum];
mp[sum] = 0;
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long loser = 1;
cin >> loser;
while (loser--) {
solve();
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int bsearch(int l, int r, int I, int n) {
int mid, ans = 1;
long double tmp;
while (l <= r) {
mid = l + ((r - l) >> 1);
tmp = ceil(log2(mid * 1.)) * n;
if (tmp <= I * 8) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
int i, j, n, m, I;
cin >> n >> I;
int a[n], ans;
map<int, int> freq;
for (i = 0; i < n; i++) {
cin >> a[i];
freq[a[i]]++;
}
vector<int> uniqueElements;
for (auto iter : freq) uniqueElements.push_back(iter.first);
m = uniqueElements.size();
if (m == 1)
ans = 0;
else {
int maxDistinct = bsearch(1, m, I, n);
if (m <= maxDistinct)
ans = 0;
else {
ans = INT_MAX;
int csum[m];
for (i = 0; i < m; i++)
csum[i] = freq[uniqueElements[i]] + (i > 0 ? csum[i - 1] : 0);
for (i = 0;; i++) {
j = maxDistinct - 1 + i;
if (j >= m) break;
ans = min(ans, (i > 0 ? csum[i - 1] : 0) + csum[m - 1] - csum[j]);
}
}
}
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double a[5005][5005];
int M[100008][20], mx[5005], sz[5005];
int b[100009];
vector<int> G[5005];
struct node {
int l, r;
double p;
bool operator<(const node &rhs) const {
if (l != rhs.l)
return l < rhs.l;
else
return r > rhs.r;
}
} p[5005];
void dfs(int u) {
sz[u] = 1;
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i];
dfs(v);
sz[u] += sz[v];
}
for (int i = 1; i <= sz[u]; i++) {
double tmp = p[u].p;
for (int j = 0; j < (int)G[u].size(); j++) {
int v = G[u][j];
int id = min(sz[v], mx[u] - mx[v] + i - 1);
tmp *= a[v][id];
}
a[u][i] += tmp;
}
for (int i = 0; i <= sz[u]; i++) {
double tmp = 1.0 - p[u].p;
for (int j = 0; j < (int)G[u].size(); j++) {
int v = G[u][j];
int id = min(sz[v], mx[u] - mx[v] + i);
tmp *= a[v][id];
}
a[u][i] += tmp;
}
}
int rmq(int l, int r) {
int k = log2(r - l + 1);
return max(M[l][k], M[r - (1 << k) + 1][k]);
}
void init() {
for (int i = 0; i <= n; i++) M[i][0] = b[i];
for (int j = 1; 1 << j <= n; j++)
for (int i = 0; i + (1 << j) - 1 < n; i++)
M[i][j] = max(M[i][j - 1], M[i + (1 << (j - 1))][j - 1]);
}
bool in(int a, int b) { return p[b].r >= p[a].r && p[b].l <= p[a].l; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
init();
for (int i = 1; i <= m; i++) {
scanf("%d%d%lf", &p[i].l, &p[i].r, &p[i].p);
p[i].l--;
p[i].r--;
}
sort(p + 1, p + 1 + m);
m++;
p[0].l = 0;
p[0].r = n - 1;
p[0].p = 0;
for (int i = 1; i < m; i++) {
for (int j = i - 1; j >= 0; j--) {
if (in(i, j)) {
G[j].push_back(i);
break;
}
}
}
for (int i = 0; i < m; i++) {
mx[i] = rmq(p[i].l, p[i].r);
}
dfs(0);
double ans = a[0][0] * mx[0];
for (int i = 1; i <= sz[0]; i++) {
ans += (a[0][i] - a[0][i - 1]) * (mx[0] + i);
}
printf("%.9f\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
string s, t;
cin >> n >> m >> q >> s >> t;
vector<int> ans;
for (int i = 0; i < n; i++) {
bool flag = 1;
for (int j = 0; j < m; j++) {
if (t[j] != s[j + i]) {
flag = 0;
break;
}
}
if (flag) {
ans.push_back(i + 1);
}
}
while (q--) {
int l, r;
cin >> l >> r;
r = (r - m + 1);
if (r < l) {
cout << 0 << '\n';
} else
cout << (upper_bound(ans.begin(), ans.end(), r) -
lower_bound(ans.begin(), ans.end(), l))
<< '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12;
const double PI = acos(-1.0);
enum {};
template <int N>
class Dsets {
int p[N], r[N];
public:
Dsets() { clear(); }
void clear() {
for (int i = 0; i < N; ++i) p[i] = i;
memset(r, 0, sizeof(r));
}
int parent(int a) {
if (p[a] != a) p[a] = parent(p[a]);
return p[a];
}
void merge(int a, int b) {
a = parent(a);
b = parent(b);
if (r[a] > r[b])
p[b] = a;
else
p[a] = b;
if (r[a] == r[b]) ++r[b];
}
};
vector<int> E[100005];
vector<pair<int, int> > ZV;
vector<int> ZEC[100005];
vector<pair<int, int> > ZE;
Dsets<100005> DS;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
E[a].push_back(b);
E[b].push_back(a);
}
ZV.push_back(pair<int, int>(-1, -1));
for (int u = 1, k = 1; u <= n; ++u) {
for (int i = 0; i < E[u].size(); ++i) {
int v = E[u][i];
if (u > v) continue;
ZEC[u].push_back(ZV.size());
ZEC[v].push_back(ZV.size());
ZV.push_back(pair<int, int>(u, v));
}
}
for (int u = 1; u <= n; ++u) {
for (int i = 1; i < ZEC[u].size(); ++i) {
int xu = ZEC[u][0], xv = ZEC[u][i];
if (DS.parent(xu) != DS.parent(xv)) {
DS.merge(xu, xv);
ZE.push_back(pair<int, int>(xu, xv));
}
}
}
printf("%d\n", ZV.size() - 1);
for (int i = 1; i < ZV.size(); ++i)
printf("2 %d %d\n", ZV[i].first, ZV[i].second);
for (int i = 0; i < ZE.size(); ++i)
printf("%d %d\n", ZE[i].first, ZE[i].second);
return 0;
}
| 4 |
#include <iostream>
#include <vector>
#include <cstdio>
using namespace std;
class dice
{
private:
int _top;
int _front;
public:
dice(int top, int front, int height);
int x;
int y;
int height;
int top();
int front();
int left();
int right();
int back();
int under();
void rollFront();
void rollLeft();
void rollRight();
void rollBack();
};
dice::dice(int t, int f, int h) {
_top = t;
_front = f;
x = 0;
y = 0;
height = h;
}
int dice::top() {
return _top;
}
int dice::front() {
return _front;
}
int dice::left() {
int t[6][6] = {
{0, 4, 2, 5, 3, 0},
{3, 0, 6, 1, 0, 4},
{5, 1, 0, 0, 6, 2},
{2, 6, 0, 0, 1, 5},
{4, 0, 1, 6, 0, 3},
{0, 3, 5, 2, 4, 0}
};
return t[top() - 1][front() - 1];
}
int dice::right() {
return 7 - left();
}
int dice::back() {
return 7 - front();
}
int dice::under() {
return 7 - top();
}
void dice::rollFront() {
int t = back();
_front = top();
_top = t;
y--;
}
void dice::rollLeft() {
_top = right();
x--;
}
void dice::rollRight() {
_top = left();
x++;
}
void dice::rollBack() {
int t = front();
_front = under();
_top = t;
y++;
}
int seek(vector<dice> v, int x, int y) {
int i;
for (i = 0; i < v.size(); i++) {
if (v[i].x == x && v[i].y == y) {
return i;
}
}
return -1;
}
int next(vector<dice> v, dice d, int dx, int dy) {
int i, h = 0, x = d.x, y = d.y;
for (i = 0; i < v.size(); i++) {
if (v[i].x == x + dx && v[i].y == y + dy) {
if (v[i].height > h) {
h = v[i].height;
}
}
}
return h;
}
bool roll(vector<dice> v, dice *d) {
int i, h = d->height;
for (i = 6; i >= 4; i--) {
if (d->front() == i && next(v, *d, 0, -1) < h) {
d->height = next(v, *d, 0, -1);
d->rollFront();
return true;
} else if (d->left() == i && next(v, *d, -1, 0) < h) {
d->height = next(v, *d, -1, 0);
d->rollLeft();
return true;
} else if (d->back() == i && next(v, *d, 0, 1) < h) {
d->height = next(v, *d, 0, 1);
d->rollBack();
return true;
} else if (d->right() == i && next(v, *d, 1, 0) < h) {
d->height = next(v, *d, 1, 0);
d->rollRight();
return true;
}
}
return false;
}
int main() {
int i, n, h = 0;
vector<dice> v;
cin >> n;
if (n == 0) {
return 0;
}
for (; n--;) {
int top, front;
cin >> top >> front;
dice d(top, front, h);
while (roll(v, &d));
if (~(i = seek(v, d.x, d.y))) {
v.erase(v.begin() + i);
}
if (!d.x && !d.y) {
h++;
}
d.height++;
//printf("%ld: (%d, %d, %d) %d %d %d\n", v.size(), d.x, d.y, d.height, d.top(), d.front(), d.left());
v.push_back(d);
}
int a[] = {0, 0, 0, 0, 0, 0};
for (i = 0; i < v.size(); i++) {
a[v[i].top() - 1]++;
}
printf("%d %d %d %d %d %d\n", a[0], a[1], a[2], a[3], a[4], a[5]);
main();
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main()
{
int q_lower,bud,c_aizu,c_normal,q_aizuupper;
while(cin>>q_lower>>bud>>c_aizu>>c_normal>>q_aizuupper){
int q_aizu=0,q_normal=0;
q_aizu+=q_aizuupper;
bud-=q_aizu*c_aizu;
if(bud<0){
q_aizu-=(-bud+(c_aizu-1))/c_aizu;
bud+=((-bud+(c_aizu-1))/c_aizu)*c_aizu;
if(q_aizu<=0){
cout<<"NA"<<endl;
continue;
}
}
q_normal+=bud/c_normal;
bud-=q_normal*c_normal;
while(q_aizu+q_normal<q_lower && q_aizu>0){
q_aizu--;
bud+=c_aizu;
q_normal+=bud/c_normal;
bud-=(bud/c_normal)*c_normal;
}
if(q_aizu<=0){
cout<<"NA"<<endl;
continue;
}
if(q_aizu+q_normal>=q_lower) cout<<q_aizu<<' '<<q_normal<<endl;
else cout<<"NA"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, m = 0, m_m;
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i < n; i++) {
m_m = min(a / i, b / (n - i));
if (m_m > m) m = m_m;
}
printf("%d\n", m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int p = sqrt(i * i + j * j);
if (sqrt(i * i + j * j) <= n && sqrt(i * i + j * j) == p) ans++;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using vecint = vector<int>;
using vecll = vector<ll>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vecint d(m);
for (int i = (0); i < (m); ++i) cin >> d[i];
sort(begin(d), end(d));
int g, r;
cin >> g >> r;
int k = m * g;
deque<int> q;
q.push_back(0);
vector<int> dis(k, 1000000000);
dis[0] = 0;
while (!q.empty()) {
int i = q.front();
q.pop_front();
int x = i / g;
int y = i % g;
int c = y ? 0 : 1;
if (x < m - 1) {
int d1 = d[x + 1] - d[x];
if (y + d1 <= g) {
int j = (x + 1) * g + (y + d1) % g;
if (dis[j] > dis[i] + c) {
dis[j] = dis[i] + c;
if (c)
q.push_back(j);
else
q.push_front(j);
}
}
}
if (x > 0) {
int d1 = d[x] - d[x - 1];
if (y + d1 <= g) {
int j = (x - 1) * g + (y + d1) % g;
if (dis[j] > dis[i] + c) {
dis[j] = dis[i] + c;
if (c)
q.push_back(j);
else
q.push_front(j);
}
}
}
}
ll mn = 1000000000;
for (int i = (0); i < (g); ++i) {
if (i) {
mn = min(mn, ll(g + r) * (dis[g * (m - 1) + i] - 1) + i);
} else {
mn = min(mn, ll(g + r) * (dis[g * (m - 1) + i] - 1) + g);
}
}
if (mn == 1000000000) {
cout << -1 << endl;
} else {
cout << mn << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> c[505050];
int a[505050], b[505050], l, r, mid, s, t, n, L;
bool check(int x) {
for (int i = 0; i < n; i++) {
c[i].first = lower_bound(b, b + n * 2 + 1, a[i] - x) - b;
c[i].second = lower_bound(b, b + n * 2 + 1, a[i] + x + 1) - b;
}
s = c[0].first;
t = c[0].second;
for (int i = 1; i < n; i++) {
if (t <= s) return false;
s = max(s + 1, c[i].first);
t = min(t + 1, c[i].second);
}
return s < t;
}
int main() {
cin >> n >> L;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
sort(b, b + n);
for (int i = 0; i < n; i++) b[i + n] = b[i] + L;
b[n * 2] = L * 2;
for (int i = 0; i < n; i++)
if (a[i] <= L / 2) a[i] += L;
sort(a, a + n);
l = -1;
r = L / 2;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
cout << r << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, X, i, j;
void fill(int P, bool W, int A[][2], int B[]) {
B[P] = 1 + W;
if (B[A[P][0]] == 0) {
fill(A[P][0], !W, A, B);
}
if (B[A[P][1]] == 0) {
fill(A[P][1], !W, A, B);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
int A[2 * N][2];
int B[2 * N];
int C[N];
memset(B, 0, 2 * N * sizeof(int));
for (i = 0; i < N; i++) {
cin >> X >> C[i];
C[i]--;
A[X - 1][0] = C[i];
A[C[i]][0] = X - 1;
A[2 * i][1] = 2 * i + 1;
A[2 * i + 1][1] = 2 * i;
}
for (i = 0; i < 2 * N; i++) {
if (B[i] == 0) {
fill(i, false, A, B);
}
}
for (i = 0; i < N; i++) {
if (B[C[i]] == 1) {
cout << "2 1" << endl;
} else
cout << "1 2" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e9 + 1;
long long n, m_z, ans;
vector<pair<int, int> > comp;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
long long u = 0;
for (int j = 0; j < a; j++) {
long long b;
cin >> b;
u = max(u, b);
m_z = max(m_z, u);
}
comp.push_back(make_pair(a, u));
}
for (int i = 0; i < n; i++) {
if (comp[i].second != m_z) {
ans += comp[i].first * (m_z - comp[i].second);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cost[505][26][26];
int dp[505][26][26];
int arr[505][505];
int coll[505][2];
char str[505][505];
int row, col;
void pre() {
int i, j, k, l, c;
memset(dp, 1000000, sizeof dp);
memset(cost, 1000000, sizeof cost);
for (i = 0; i < row; i++) {
for (k = 0; k < 26; k++) {
for (l = 0; l < 26; l++) {
c = 0;
if (k != l) {
for (j = 0; j < col; j++) {
if (j % 2 == 0) {
if (arr[i][j] != k) c++;
} else {
if (arr[i][j] != l) c++;
}
}
cost[i][k][l] = c;
}
}
}
}
}
int pre1() {
int i, j, k, t1, t2, ans;
for (j = 0; j < 26; j++) {
for (k = 0; k < 26; k++) {
if (j != k) dp[row - 1][j][k] = cost[row - 1][j][k];
}
}
for (i = row - 2; i >= 0; i--) {
for (j = 0; j < 26; j++) {
for (k = 0; k < 26; k++) {
for (t1 = 0; t1 < 26; t1++) {
for (t2 = 0; t2 < 26; t2++) {
if (j != k and j != t1 and k != t2 and t1 != t2) {
dp[i][j][k] = min(dp[i][j][k], cost[i][j][k] + dp[i + 1][t1][t2]);
}
}
}
}
}
}
ans = 1000000;
for (i = 0; i < 26; i++) {
for (j = 0; j < 26; j++) {
if (i != j) ans = min(ans, dp[0][i][j]);
}
}
return ans;
}
void find(int lev, int c1, int c2, int ans) {
int ret1, ret2, i, j;
if (lev >= row) {
return;
}
for (i = 0; i < 26; i++) {
for (j = 0; j < 26; j++) {
if (i == c1) {
continue;
} else if (j == c2) {
continue;
} else if (i == j)
continue;
else {
if (ans == dp[lev][i][j]) {
coll[lev][0] = i;
coll[lev][1] = j;
find(lev + 1, i, j, ans - cost[lev][i][j]);
return;
}
}
}
}
}
int main() {
scanf("%d %d", &row, &col);
int i, j, k;
int ans;
for (i = 0; i < row; i++) {
scanf("%s", str[i]);
}
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) {
arr[i][j] = str[i][j] - 'a';
}
}
pre();
ans = 1000000;
ans = pre1();
printf("%d\n", ans);
for (i = 0; i < 26; i++) {
for (j = 0; j < 26; j++) {
if (ans == dp[0][i][j] and i != j) {
coll[0][0] = i;
coll[0][1] = j;
find(1, i, j, ans - cost[0][i][j]);
break;
}
}
}
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) {
if (j % 2 == 0) {
printf("%c", coll[i][0] + 'a');
} else {
printf("%c", coll[i][1] + 'a');
}
}
printf("\n");
}
return 0;
}
| 5 |
#include<cstdio>
using namespace std;
int main()
{
int n,fi,se,th,fo,x1,x2,y1,y2,z1,z2,w1,w2;
while(true)
{
scanf("%d",&n);
if(n==0)break;
for(int i=0;i<n;i++)
{
scanf("%d%d%d%d%d%d%d%d",&x1,&y1,&z1,&w1,&x2,&y2,&z2,&w2);
fi=x1*x2+(-1)*(y1*y2)+(-1)*(z1*z2)+(-1)*(w1*w2);
se=x1*y2+y1*x2+z1*w2+(-1)*w1*z2;
th=x1*z2+(-1)*(y1*w2)+z1*x2+w1*y2;
fo=x1*w2+y1*z2+(-1)*(z1*y2)+w1*x2;
printf("%d %d %d %d\n",fi,se,th,fo);
}
}
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
struct state {
int turn;
int y,x;
string ba;
state() {}
state(int a,int y, int x, string ba) : turn(a) ,y(y) , x(x) ,ba(ba) {}
};
int dx[] = {-1,-1,-1,0,0,1,1,1};
int dy[] = {-1,0,1,-1,1,-1,0,1};
int main() {
int n;
while(cin >> n , n){
state stat;
string ba;
for(int i = 0; i < n; i++){
string str;
cin >> str;
ba+=str;
REP(j, str.size()) {
if (str[j] == '@') {
stat.y = i;
stat.x = j;
}
}
}
stat.ba = ba;
stat.turn = 0;
queue<state> Q;
Q.push(stat);
int res = -1;
map<string , bool> visited;
while(!Q.empty()) {
state now = Q.front();
Q.pop();
if (visited[now.ba]) continue;
visited[now.ba] = 1;
// cout << now.turn << endl;
// REP(i, n) {
// REP(j, n) {
// cout << now.ba[i][j];
// }
// cout << endl;
// }
bool f = 0;
REP(i, n) {
REP(j, n) {
if (now.ba[i*n+j] == '#') {
f = 1;
break;
}
}
if(f) break;
}
if (!f) {
res = now.turn;
break;
}
REP(k, 8) {
int yy = now.y+dy[k];
int xx = now.x+dx[k];
if(yy<0||yy>=n||xx<0||xx>=n) continue;
if(now.ba[yy*n+xx] == '#') continue;
// cout << yy << " " << xx << endl;
state next = now;
next.turn++;
next.ba[now.y*n+now.x] = '.';
next.y = yy;
next.x = xx;
next.ba[yy*n+xx] = '@';
REP(i, n) {
REP(j, n) {
int cnt = 0;
REP(k, 8) {
int ii = i+dy[k];
int jj = j+dx[k];
if (ii<0||ii>=n||jj<0||jj>=n) continue;
if (now.ba[ii*n+jj] == '#' || next.ba[ii*n+jj] == '@') cnt++;
}
if (next.ba[i*n+j] == '#') {
if (cnt == 2 || cnt == 3);
else {
next.ba[i*n+j] = '.';
}
} else if (next.ba[i*n+j] == '.') {
if (cnt == 3) {
next.ba[i*n+j] = '#';
}
}
}
}
if(visited[next.ba]) continue;
Q.push(next);
}
}
cout << res << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[100005], a, b;
int ts[10][10] = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0, 0, 2, 2},
{0, 0, 0, 0, 0, 0, 0, 4, 4, 4}, {0, 0, 0, 0, 0, 4, 4, 5, 5, 5},
{0, 0, 0, 0, 0, 5, 5, 6, 6, 6}, {0, 0, 0, 0, 1, 5, 5, 6, 6, 6},
{0, 0, 1, 1, 2, 5, 5, 6, 7, 7}, {0, 0, 2, 2, 3, 5, 5, 6, 8, 8}};
vector<int> V[100005];
void dfs(int id, int prev) {
dp[id] = 9;
for (int i = 0; i < V[id].size(); i++) {
int to = V[id][i];
if (to == prev) continue;
dfs(to, id);
dp[id] = ts[dp[id]][dp[to]];
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
dfs(1, -1);
printf("%s\n", dp[1] ? "Yes" : "No");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int f[35][35][2];
int c[35][35];
int n;
int main() {
for (int i = 0; i <= 30; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
scanf("%d", &n);
f[30][0][1] = 1;
for (int i = 30; i >= 1; i--)
for (int j = 0; j <= 30 - i; j++)
for (int k = 0; k <= 1; k++) {
if (f[i][j][k] == 0) continue;
int kk = (k == 1) && (n & (1 << (i - 1))) == 0;
f[i - 1][j][kk] = (f[i - 1][j][kk] + f[i][j][k]) % 1000000007;
if (!(k == 1 && (n & (1 << (i - 1))) == 0)) {
int kk = (k == 1) && (n & (1 << (i - 1))) > 0;
f[i - 1][j + 1][kk] = (f[i - 1][j + 1][kk] + f[i][j][k]) % 1000000007;
}
kk = (k == 1) && (n & (1 << (i - 1))) == 0;
for (int num = 2; num <= j; num += 2) {
f[i - 1][j][kk] =
(f[i - 1][j][kk] + 1ll * f[i][j][k] * c[j][num]) % 1000000007;
}
if (!(k == 1 && (n & (1 << (i - 1))) == 0)) {
kk = (k == 1) && (n & (1 << (i - 1))) > 0;
for (int num = 1; num <= j; num += 2) {
f[i - 1][j][kk] =
(f[i - 1][j][kk] + 1ll * f[i][j][k] * c[j][num]) % 1000000007;
}
}
}
int ans = 0;
for (int i = 0; i <= 30; i++)
for (int j = 0; j <= 1; j++) ans = (ans + f[0][i][j]) % 1000000007;
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[105], b[35];
int bb[35];
long long ans, sum;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
sum -= a[--b[i]];
bb[i] = a[b[i]];
}
sort(bb, bb + m);
ans = sum;
for (int i = 0; i < m && ans >= bb[i]; i++) ans *= 2;
for (int i = m - 1; i >= 0; i--) {
sum += bb[i];
ans = max(ans, sum * (1 << i));
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, sum, count;
cin >> n;
int a[n][n];
int row[n], col[n];
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < n; j++) {
cin >> a[i][j];
sum += a[i][j];
}
row[i] = sum;
}
for (j = 0; j < n; j++) {
sum = 0;
for (i = 0; i < n; i++) {
sum += a[i][j];
}
col[j] = sum;
}
count = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (col[i] > row[j]) count++;
}
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define INF (2e9)
#define FOR(i, a, b) for (ll (i) = (a); (i) < (b); ++(i))
#define REP(i, n) FOR(i, 0, n)
using namespace std;
template<class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ld = long double;
#define ALL(x) (x).begin(), (x).end()
template<class T>
using vc = vector<T>;
using vi = vc<ll>;
using vvi = vc<vi>;
template<class T>
using va = valarray<T>;
using vad = va<ld>;
using vai = va<ll>;
vi Read(ll n) {
auto v = vi(n);
for (auto i = std::size_t(0); i < n; ++i) {
cin >> v[i];
}
return v;
}
template<class T>
void Dump(const T& A) {
for (const auto& value : A)
cout << value << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
const auto v = Read(n);
int n_q;
cin >> n_q;
REP(i, n_q) {
int b, e, k;
cin >> b >> e >> k;
ll count = 0;
FOR(j, b, e) if (v[j] == k) ++count;
cout << count << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const long double DEL = 1e-10;
const int mod = 1000000007;
inline void read(long long &x) {
long long c = getchar();
x = 0;
long long neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) {
x = -x;
}
}
long long fpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) {
res = res * x % mod;
}
x = x * x % mod;
n >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
void sieve(long long n) {
bool prime[1000006];
memset(prime, true, sizeof(prime));
long long rootn = (long long)sqrt(n);
for (long long p = 2; p <= rootn; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) {
prime[i] = false;
}
}
}
prime[1] = 0;
}
const long long N = 2050;
long long cnt, sum, mid, mx, mn, ans, a[N], b[N];
long long n, m, d, i, j, k, l, p, q, r, t, w, x, y, z;
bool f, f1, f2;
string s;
vector<vector<long long>> pre(1002, vector<long long>(1002));
vector<long long> fac(2005), inv(2005);
vector<pair<long long, long long>> snakes(N);
void preprocess() {
inv[0] = fac[0] = 1;
for (long long i = 1; i <= 2000; ++i) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = fpow(fac[i], mod - 2);
}
}
long long getsum(long long x1, long long x2, long long y1, long long y2) {
x1 = max(1ll, x1);
x2 = min(1000ll, x2);
y1 = max(1ll, y1);
y2 = min(1000ll, y2);
if (x1 > x2 || y1 > y2) return 0;
return pre[x2][y2] - pre[x2][y1 - 1] - pre[x1 - 1][y2] + pre[x1 - 1][y1 - 1];
}
long long whatkills(long long x, long long y) {
return getsum(x - r, x + r, y - r, y + r);
}
long long c(long long n, long long r) {
if (n < 0 || r > n) return 0;
return (fac[n] * inv[n - r] % mod) * inv[r] % mod;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
preprocess();
cin >> n >> m >> r;
for (long long i = 1; i <= n; i++) {
cin >> x >> y >> b[i];
snakes[i] = {x, y};
pre[x][y] = 1;
}
for (long long i = 1; i <= 1000; i++) {
for (long long j = 1; j <= 1000; j++) {
pre[i][j] += (pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1]);
}
}
for (long long i = 1; i <= n; i++) {
long long x1 = snakes[i].first, y1 = snakes[i].second;
for (long long j = i + 1; j <= n; j++) {
long long x2 = snakes[j].first, y2 = snakes[j].second;
long long na_i = c(n - whatkills(x1, y1), m),
na_j = c(n - whatkills(x2, y2), m);
long long cnt = getsum(max(x1, x2) - r, min(x1, x2) + r, max(y1, y2) - r,
min(y1, y2) + r);
long long na_i_na_j =
c(n + cnt - whatkills(x1, y1) - whatkills(x2, y2), m);
long long tot = c(n, m);
x = (tot - na_i - na_j + na_i_na_j + 4ll * mod) % mod;
ans = (ans + x * 2 * (b[i] * b[j] % mod) % mod) % mod;
}
x = (c(n, m) - c(n - whatkills(x1, y1), m) + mod) % mod;
ans = (ans + x * (b[i] * b[i] % mod) % mod) % mod;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 3e5 + 7;
vector<int> g[MX];
const int INF = 1e9 + 7;
vector<int> comp;
bool used[MX];
void dfs(int v) {
used[v] = 1;
for (int i : g[v])
if (!used[i]) dfs(i);
comp.push_back(v);
}
set<pair<int, int> > gr;
int main() {
iostream::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
gr.insert({a, b});
gr.insert({b, a});
}
queue<int> q;
vector<int> d(n, INF);
d[0] = 0, q.push(0);
vector<int> p(n, -1);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int j : g[v]) {
if (d[j] == INF) {
d[j] = d[v] + 1;
p[j] = v;
q.push(j);
}
}
}
int is = -1;
for (int i = 0; i < n - 1; i++)
if (d[i] == 2) is = i;
vector<int> ans;
if (d[n - 1] != INF) {
int now = n - 1;
while (now) {
ans.push_back(now + 1);
now = p[now];
}
ans.push_back(1);
reverse(ans.begin(), ans.end());
}
if (is == -1) {
used[0] = 1;
int a = -1, b = -1, c = -1;
for (int i : g[0]) {
if (!used[i]) {
dfs(i);
int sz = comp.size();
for (int j : comp) {
if (g[j].size() != sz) {
a = j;
vector<int> d2(n, INF);
d2[0] = -1;
d2[a] = 0, q.push(a);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int j : g[v]) {
if (d2[j] == INF) {
d2[j] = d2[v] + 1;
p[j] = v;
q.push(j);
}
}
}
for (int s = 0; s < n; s++) {
if (d2[s] == 2) {
c = s;
b = p[s];
break;
}
}
break;
}
}
if (a != -1) break;
comp.clear();
}
}
if (d[n - 1] == INF) {
if (a != -1) {
cout << 5 << '\n';
cout << 1 << ' ' << a + 1 << ' ' << b + 1 << ' ' << c + 1 << ' '
<< a + 1 << ' ' << n << '\n';
return 0;
}
cout << -1;
return 0;
}
if (a != -1 && d[n - 1] >= 5) {
cout << 5 << '\n';
cout << 1 << ' ' << a + 1 << ' ' << b + 1 << ' ' << c + 1 << ' ' << a + 1
<< ' ' << n << '\n';
return 0;
}
cout << d[n - 1] << '\n';
for (int i : ans) cout << i << ' ';
return 0;
} else {
if (d[n - 1] <= 4) {
cout << d[n - 1] << '\n';
for (int i : ans) cout << i << ' ';
return 0;
}
vector<int> out;
while (is) {
out.push_back(is + 1);
is = p[is];
}
cout << 4 << '\n';
out.push_back(1);
reverse(out.begin(), out.end());
out.push_back(1);
out.push_back(n);
for (int i : out) cout << i << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, ans, temp;
pair<int, int> arr[N + 9];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d %d", &arr[i].first, &arr[i].second);
sort(arr, arr + n);
for (int i = 1; i < n; ++i) {
if (arr[i].first > arr[temp].first && arr[i].second < arr[temp].second)
++ans;
else
temp = i;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define N 5000 + 10
int f[N][N],n,ans;
char s[N];
int main(){
ios::sync_with_stdio(false);
cin>>n>>s;
for(int i=n-1;i>=0;i--)
for(int j=n-1;j>=0;j--){
if(s[i]==s[j])
f[i][j]=max(f[i][j],f[i+1][j+1]+1);
ans=max(ans,min(f[i][j],j-i));
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 201234, MX = 42;
int dp[MX][MX], k[MN];
vector<pair<int, int> > all[MN], gd[MN];
void get(vector<pair<int, int> > &vec, int now, int x) {
for (auto &p : vec) {
int v = p.first, y = p.second;
int mark[MX] = {};
for (int i = 0; i < v; i += y) mark[(i + now) % v] = true;
for (int i = 0; i < v; i++)
if (!mark[i]) dp[v][i] = x;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", k + i);
for (int j = 0; j < k[i]; j++) {
int x;
scanf("%d", &x);
all[x].push_back({i, j});
}
}
for (int iii = 0; iii < n; iii++) {
int x = k[iii];
for (int i = 2; i <= x; i++) {
if (x % i == 0) {
int ii = 1;
while (x % i == 0) {
ii *= i;
x /= i;
}
int ans = ii;
while (ans < MX) ans *= i;
ans /= i;
gd[iii].push_back({ans, ii});
}
}
}
for (int i = 1; i <= m; i++) {
for (int i = 0; i < MX; i++)
for (int j = 0; j < MX; j++) dp[i][j] = -1;
sort(all[i].begin(), all[i].end());
auto &vec = all[i];
int bad = -1, lst = -1;
int ans = 0;
for (int j = 0; j < vec.size(); j++) {
int now = vec[j].second;
int x = vec[j].first;
if (lst != x - 1) bad = x - 1;
lst = x;
for (auto &p : gd[x]) {
int v = p.first, y = p.second;
int mn = MN;
for (int i = 0; i < v; i += y) mn = min(mn, dp[v][(now + i) % v]);
bad = max(bad, mn);
}
ans = max(ans, x - bad);
get(gd[x], now, x);
}
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
long long dp[1005][1005];
int lft[505];
int rht[505];
int arr[1000005];
vector<int> v;
vector<int> idx[505];
const long long MOD = 998244353;
long long add(long long a, long long b) { return (a + b) % MOD; }
long long mult(long long a, long long b) { return a * b % MOD; }
long long solve(int l, int r) {
if (l > r) {
return 1;
}
if (dp[l][r] != -1) {
return dp[l][r];
}
int val = v[l];
for (int i = l; i <= r; i++) {
val = min(val, v[i]);
}
long long lftsum = 0, rhtsum = 0;
for (int i = lft[val]; i >= l; i--) {
lftsum = add(lftsum, mult(solve(l, i - 1), solve(i, lft[val] - 1)));
}
for (int i = rht[val]; i <= r; i++) {
rhtsum = add(rhtsum, mult(solve(rht[val] + 1, i), solve(i + 1, r)));
}
long long midsum = 1;
for (int i = 1; i < idx[val].size(); i++) {
midsum = mult(midsum, solve(idx[val][i - 1] + 1, idx[val][i] - 1));
}
return dp[l][r] = mult(mult(lftsum, rhtsum), midsum);
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
v.emplace_back(0);
for (int i = 1; i <= M; i++) {
int n;
cin >> n;
arr[i] = n;
v.emplace_back(n);
}
v.erase(unique(v.begin(), v.end()), v.end());
M = v.size() - 1;
for (int i = 1; i <= M; i++) {
if (!lft[v[i]]) {
lft[v[i]] = i;
}
rht[v[i]] = i;
idx[v[i]].emplace_back(i);
}
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
if (lft[j] <= lft[i] && lft[i] <= rht[j]) {
cout << 0;
return 0;
}
if (lft[j] <= rht[i] && rht[i] <= rht[j]) {
cout << 0;
return 0;
}
}
}
if (M > 2 * N) {
cout << 0 << "\n";
return 0;
}
for (int i = 1; i <= M; i++) {
fill(dp[i] + 1, dp[i] + M + 1, -1);
}
solve(1, M);
cout << dp[1][M] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
typedef long double matrix[maxn][maxn];
typedef long double vec[maxn];
matrix a;
vec f;
long double P[maxn];
int M, n, i, j;
void mul(matrix a, matrix b, matrix res) {
matrix c = {0};
int i, j, k;
for (i = 0; i <= n; i++)
for (j = 0; j <= n; j++)
for (k = 0; k <= n; k++) c[i][j] += a[i][k] * b[k][j];
memcpy(res, c, sizeof(c));
}
void mul(vec f, matrix a, vec res) {
vec c = {0};
int i, j;
for (i = 0; i <= n; i++)
for (j = 0; j <= n; j++) c[i] += f[j] * a[j][i];
memcpy(res, c, sizeof(c));
}
void ksm(matrix a, int b, matrix res) {
matrix t = {0};
int i;
for (i = 0; i <= n; i++) t[i][i] = 1;
while (b) {
if (b & 1) mul(t, a, t);
mul(a, a, a);
b >>= 1;
}
memcpy(res, t, sizeof(t));
}
int main() {
scanf("%d%d", &M, &n);
for (i = 0; i <= n; i++) {
double x;
scanf("%lf", &x);
P[i] = x;
}
n = 150;
for (i = 0; i <= n; i++)
for (j = 0; j <= n; j++) a[i][j] = P[i ^ j];
f[0] = 1;
ksm(a, M, a);
mul(f, a, f);
double x = 1 - f[0];
printf("%.8lf", x);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, c, d, i, j, k, l, g, s;
cin >> a;
map<long long int, long long int> m;
for (i = 0; i < a; i++) {
cin >> b;
auto it = m.find(b);
if (it == m.end()) {
m.insert(pair<long long int, long long int>(b, 1));
} else {
it->second++;
}
}
int cur = 0;
d = 0;
auto it = m.end();
it--;
vector<long long int> v, v1;
while (1) {
if (it->second + cur > a / 2) break;
cur = cur + it->second;
v.push_back(it->second);
d++;
if (it == m.begin()) break;
it--;
}
if (d < 3) {
cout << 0 << " " << 0 << " " << 0 << endl;
goto P;
} else {
g = v[0];
s = 0;
}
i = 1;
while (1) {
if (i >= v.size() || s > g) break;
s += v[i];
i++;
}
b = 0;
for (j = i; j < v.size(); j++) b += v[j];
if (g < s && g < b)
cout << g << " " << s << " " << b << endl;
else
cout << 0 << " " << 0 << " " << 0 << endl;
P:;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
map<int, int> m;
std::map<int, int>::iterator it;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
if (m.find(a[i]) != m.end()) {
m[a[i]]++;
} else {
m[a[i]] = 1;
}
}
vector<int> num;
int x;
int flag = 0;
for (it = m.begin(); it != m.end(); it++) {
if (it->second > 1) {
num.push_back(it->first);
}
if (it->second >= 4) {
flag = 1;
x = i;
cout << it->first << " " << it->first << " " << it->first << " "
<< it->first << endl;
break;
}
}
int s = num.size();
if (flag == 0) {
double mini = 1e9;
int index;
for (i = 0; i < s - 1; i++) {
double g = (num[i] * 1.0 / num[i + 1]);
double h = (num[i + 1] * 1.0 / num[i]);
if (g + h < mini) {
mini = g + h;
index = i;
}
}
cout << num[index] << " " << num[index] << " " << num[index + 1] << " "
<< num[index + 1] << endl;
}
}
}
| 3 |
#include<iostream>
#include<map>
using namespace std;
int C[10][10], A[50000];
int main() {
int H, W;
cin >> H >> W;
for (int i = 0; i < 10; i++) for (int j = 0; j < 10; j++) cin >> C[i][j];
for (int i = 0; i < H*W; i++) cin >> A[i];
for (int k = 0; k < 10; k++)
for (int i = 0; i < 10; i++)
for (int j = 0; j < 10; j++)
C[i][j] = min(C[i][j], C[i][k] + C[k][j]);
int sum = 0;
for (int i = 0; i < H*W; i++) {
if (A[i] != -1) sum += C[A[i]][1];
}
cout << sum << endl;
} | 0 |
#include <iostream>
using namespace std;
int main(){
int a,b;
while(cin>>a>>b){
int a2=a;
int b2=b;
while(true){
if(a>b){
a=a%b;
}else{
b=b%a;
}
if(a==0||b==0)break;
}
cout<<max(a,b)<<" "<<a2/max(a,b)*b2<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct cmp {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) const {
int len1 = a.second - a.first + 1;
int len2 = b.second - b.first + 1;
if (len1 == len2) return a.first < b.first;
return len1 > len2;
}
};
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n;
vector<int> a(n, 0);
set<pair<int, int>, cmp> s;
s.insert({0, n - 1});
for (int i = 1; i <= n; i++) {
pair<int, int> p = *(s.begin());
s.erase(s.begin());
int mid = (p.first + p.second) / 2;
a[mid] = i;
if (p.first < mid) s.insert({p.first, mid - 1});
if (p.second > mid) s.insert({mid + 1, p.second});
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
}
| 4 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#define SF scanf
#define PF printf
#define MAXN 1010
#define MOD 1000000007
using namespace std;
typedef long long ll;
vector<int> a[MAXN],id[MAXN];
int vis[MAXN];
int n,m,k,cnt;
int dfn[MAXN],low[MAXN];
ll mi[MAXN],inv[MAXN],fac[MAXN],ans=1ll;
ll fsp(ll x,int y){
ll res=1;
while(y){
if(y&1)
res=res*x%MOD;
x=x*x%MOD;
y>>=1;
}
return res;
}
ll C(int n,int m){
return fac[n]*inv[m]%MOD*inv[n-m]%MOD;
}
int gcd(int x,int y){
if(y==0)
return x;
return gcd(y,x%y);
}
int s[MAXN],s1[MAXN],top,used[MAXN];
void dfs(int x){
dfn[x]=low[x]=++cnt;
for(int i=0;i<a[x].size();i++){
if(vis[id[x][i]]==1)
continue;
int u=a[x][i];
s[++top]=id[x][i];
vis[id[x][i]]=1;
s1[top]=x;
if(dfn[u]==0){
dfs(u);
low[x]=min(low[x],low[u]);
if(low[u]>=dfn[x]){
bool flag=1;
int tot=0;
for(int j=top;s[j+1]!=id[x][i];j--){
if(used[s1[j]]==1)
flag=0;
tot++;
used[s1[j]]=1;
}
if(flag){
ll res=0;
for(int j=1;j<=tot;j++){
res+=mi[gcd(j,tot)];
res%=MOD;
}
res*=fsp(tot,MOD-2);
res%=MOD;
ans*=res;
ans%=MOD;
}
else{
ans=ans*C(tot+k-1,k-1)%MOD;
}
//PF("|{%d:",x);
for(;s[top+1]!=id[x][i];top--){
used[s1[top]]=0;
//PF("%d(%d) ",s1[top],s[top]);
}
// PF("|[%d]\n",top);
}
}
else
low[x]=min(low[x],dfn[u]);
}
}
int main(){
SF("%d%d%d",&n,&m,&k);
int u,v;
for(int i=1;i<=m;i++){
SF("%d%d",&u,&v);
a[u].push_back(v);
a[v].push_back(u);
id[u].push_back(i);
id[v].push_back(i);
}
fac[0]=1ll;
mi[0]=1ll;
for(int i=1;i<=MAXN-10;i++){
fac[i]=fac[i-1]*i%MOD;
mi[i]=mi[i-1]*k%MOD;
}
inv[MAXN-10]=fsp(fac[MAXN-10],MOD-2);
for(int i=MAXN-10;i>=1;i--)
inv[i-1]=inv[i]*i%MOD;
for(int i=1;i<=n;i++)
if(dfn[i]==0)
dfs(i);
PF("%lld",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, N = 1e6 + 5;
int a, b, n;
long long ans, f[N];
bool good(int sum) {
while (sum != 0) {
if (sum % 10 != a && sum % 10 != b) return 0;
sum /= 10;
}
return 1;
}
long long power(long long b, long long p) {
if (!p) return 1;
if (p == 1) return b;
long long ret = power(b * b % MOD, p >> 1);
if (p & 1) ret = ret * b % MOD;
return ret;
}
long long mod_inv(long long x) { return power(x, MOD - 2); }
int main() {
cin >> a >> b >> n;
f[0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] * i % MOD;
for (int i = 0; i <= n; i++) {
int sum = i * b + (n - i) * a;
if (good(sum)) {
ans += f[n] * mod_inv((f[i] * f[n - i]) % MOD) % MOD;
ans %= MOD;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ntest = 0, test = 0;
inline void init();
inline void run();
inline void stop() { ntest = test - 1; }
int main() {
init();
while (++test <= ntest) {
run();
}
return 0;
}
const int INF = (int)1E9 + 5;
const double EPS = 1E-11;
const long long MOD = (long long)1E9 + 7;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
inline void init() { ntest = 1; }
const int MAXN = 4005;
int n, k;
int t[MAXN], d[MAXN], f[MAXN];
vector<int> g;
inline void run() {
scanf("%d%d", &n, &k);
memset((f), (0x7F), sizeof(f)), f[0] = 0;
for (int i = (1); i <= (n); i++) {
scanf("%d%d", &t[i], &d[i]);
for (int j = (i); j >= (1); j--) {
if (t[i] > f[j - 1]) {
f[j] = min(f[j], t[i] + d[i] - 1);
} else {
f[j] = min(f[j], f[j - 1] + d[i]);
}
}
g.push_back(t[i]);
}
sort((g).begin(), (g).end(), greater<typeof(*(g).begin())>());
int numKeep = n - k;
int MAX = -INF;
for (int atStart = (0); atStart <= (numKeep); atStart++) {
int startTime = f[atStart];
int atFinish = numKeep - atStart;
int finishTime = (atFinish == 0 ? 86400 : g[atFinish - 1] - 1);
MAX = max(MAX, finishTime - startTime);
}
printf("%d\n", MAX);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 7;
const int base = 19260817;
int a[mx];
int n;
unsigned long long hs[mx * 2];
void init() {
hs[0] = 1;
for (int i = 1; i <= 2 * n; i++) hs[i] = hs[i - 1] * base;
}
int main() {
int m, x;
scanf("%d", &n);
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &m);
unsigned long long ans = 0, cur = 0;
long long sum = 0;
int p = 1, go = 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
ans += hs[x - 1];
}
if (m == 1) {
printf("0\n");
return 0;
}
int pre = 0;
for (int i = 1; i <= m; i++) {
sum += (i == 1 ? 0 : abs(a[p] - a[pre]));
cur += hs[p - 1];
pre = p;
p += go;
if (p == n)
go = -1;
else if (p == 1)
go = 1;
}
set<long long> s;
if (cur == ans) s.insert(sum);
for (int i = 2; i <= 2 * n - 2; i++) {
cur -= i > n ? hs[2 * n - i] : hs[i - 2];
int end = i + (m - 1) % (2 * n - 2);
while (end > 2 * n - 2) end -= 2 * n - 2;
cur += end > n ? hs[2 * n - end - 1] : hs[end - 1];
sum -= abs(i <= n ? a[i] - a[i - 1] : a[2 * n - i] - a[2 * n - i + 1]);
sum += abs(end <= n ? (end == 1 ? a[2] - a[1] : a[end] - a[end - 1])
: a[2 * n - end] - a[2 * n - end + 1]);
if (cur == ans) {
s.insert(sum);
}
}
if (s.size() != 1)
printf("-1\n");
else
printf("%lld\n", *s.begin());
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define N 1000005
using namespace std;
int n,m,q;
int z,g,mod;
int u[N],v[N],w[N];
int fa[N * 6];
bool vis[2][N];
template <class T> inline void read(T &x)
{
char c;int sign=1;
while((c=getchar())>'9'||c<'0') if(c=='-') sign=-1; x=c-48;
while((c=getchar())>='0'&&c<='9') x=(x<<1)+(x<<3)+c-48; x*=sign;
}
int getid(int x,int p,int q) { return (x - 1) * 6 + p * 3 + q + 1; }
int gcd(int a,int b) { return (!b) ? a : gcd(b,a%b); }
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void merge(int x,int y) { if(find(x) != find(y)) fa[find(x)] = find(y); }
int main()
{
read(n);read(m);read(q);read(mod);
for(int i=1;i<=m;++i)
{
read(u[i]);read(v[i]);read(w[i]);
g = gcd(g,abs(w[i] - w[1]));
}
if(!g) g = mod;
mod = gcd(mod,3 * g);
z = w[1] % g;
for(int i=1;i<=6 * n;++i) fa[i] = i;
for(int i=1;i<=m;++i)
{
int c = (w[i] - z) / g;
for(int p=0;p<=1;++p)//次幂
{
for(int q=0;q<=2;++q)//常数
{
merge(getid(u[i],p,q),getid(v[i],p ^ 1,(q * 2 + c) % 3));
merge(getid(v[i],p,q),getid(u[i],p ^ 1,(q * 2 + c) % 3));
}
}
}
for(int i=0,j=z;i<(mod*2);++i,j = j * 2 % mod) vis[i & 1][j] = 1;
while(q--)
{
int s,t,r;
read(s);read(t);read(r);
bool ok = 0;
for(int p=0;p<=1;++p)
{
for(int q=0;q<=2;++q)
{
if(find(getid(t,0,0)) == find(getid(s,p,q)))
{
ok |= vis[p][(r + z + (3 - q) * g) % mod];
}
}
}
puts(ok ? "YES" : "NO");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> ans;
vector<pair<int, int> > a;
bool solve() {
int ind = 0;
for (int i = 0; i < ((int)a.size()); ++i) {
int num = a[i].first;
num = min(num, n / 2);
for (int j = 0; j < num; ++j) {
if (ans[ind] == -1) {
ans[ind] = a[i].second;
ind += 2;
if (ind >= n) {
if (ind % 2 == 1)
break;
else
ind = 1;
}
} else {
break;
}
}
}
for (int i = 0; i < ((int)ans.size()); ++i) {
if (ans[i] == -1) return false;
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int first;
cin >> first;
a.push_back(make_pair(first, i));
}
sort((a).begin(), (a).end());
reverse((a).begin(), (a).end());
ans.assign(n, -1);
if (solve()) {
for (int i = 0; i < ((int)ans.size()); ++i) {
cout << ans[i] + 1 << " ";
}
cout << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int binomial(int n, int k) {
int C[k + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = min(i, k); j > 0; j--) C[j] = C[j] + C[j - 1];
}
return C[k];
}
int prime(int x) {
int flag = 0;
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) {
flag = 1;
break;
}
}
if (flag == 0)
return 1;
else
return 0;
}
void primefactor(int n) {
while (n % 2 == 0) {
cout << 2 << " ";
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cout << i << " ";
n = n / i;
}
}
if (n > 2) cout << n << " ";
}
int gcd(int n1, int n2) {
if (n2 != 0)
return gcd(n2, n1 % n2);
else
return n1;
}
int lcm(int x, int y) { return (x * y) / gcd(x, y); }
int main() {
long long int x, y, z, t, p, count = 0, flag = 0, ram = 0, i, j, k, l, q;
char a[10000], b[10000];
cin >> x >> y;
cout << "YES" << endl;
for (i = x; i <= y;) {
cout << i << " " << i + 1 << endl;
i = i + 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
const double eps = 1e-12;
struct P {
int x, y;
inline void in() { scanf("%d%d", &x, &y); }
inline bool operator==(const P& rhs) { return x == rhs.x && y == rhs.y; }
inline P operator-(const P& rhs) const { return (P){x - rhs.x, y - rhs.y}; }
inline int len2() const { return x * x + y * y; }
inline double len() const { return sqrt(len2()); }
} a[N], b[N];
inline int cross(const P& a, const P& b) { return a.x * b.y - b.x * a.y; }
inline int dot(const P& a, const P& b) { return a.x * b.x + a.y * b.y; }
inline bool cmpP1(const P& a, const P& b) {
return a.x == b.x ? a.y < b.y : a.x < b.x;
}
inline vector<P> CH(vector<P> v) {
static P tmp[N], st[N];
int w = 0;
sort(v.begin(), v.end(), cmpP1);
for (P u : v) {
for (; w > 1 && cross(u - st[w - 1], st[w] - st[w - 1]) <= 0; --w)
;
st[++w] = u;
}
memcpy(tmp + 1, st + 1, w * (sizeof tmp[0]));
int ow = w;
w = 0;
reverse(v.begin(), v.end());
for (P u : v) {
for (; w > 1 && cross(u - st[w - 1], st[w] - st[w - 1]) <= 0; --w)
;
st[++w] = u;
}
if (tmp[ow] == st[1]) --ow;
if (w && st[w] == tmp[1]) --w;
memcpy(tmp + ow + 1, st + 1, w * (sizeof tmp[0]));
return vector<P>(tmp + 1, tmp + ow + w + 1);
}
int n, m, i, nxt[N];
vector<P> u;
void ck(P p, P q) {
double L = -1e180, R = -L, zz = (p - q).len2();
for (i = 1; i <= n; ++i) {
int x = cross(q - p, a[i] - p), y = dot(p - a[i], q - a[i]);
if (x == 0) {
if (y > 0) return;
continue;
}
if (x > 0)
L = max(L, y * 1.0 / x);
else
R = min(R, y * 1.0 / x);
if (L >= R - eps || (fabs(R - zz) < eps && fabs(L + zz) < eps)) return;
}
for (i = 1; i <= m; ++i) {
int x = cross(q - p, b[i] - p), y = dot(p - b[i], q - b[i]);
if (x == 0) {
if (y <= 0) return;
continue;
}
if (x > 0)
R = min(R, y * 1.0 / x);
else
L = max(L, y * 1.0 / x);
if (L >= R - eps || (fabs(R - zz) < eps && fabs(L + zz) < eps)) return;
}
puts("YES");
exit(0);
}
inline double R(const P& a, const P& b, const P& c) {
return dot(b - c, a - c) * 1.0 / cross(b - c, a - c);
}
void solve(int x) {
int y = nxt[x], z;
double mx = -1e180, r;
ck(u[x], u[y]);
if (nxt[y] == x) return;
for (; y = nxt[y], y != x;) {
r = R(u[x], u[nxt[x]], u[y]);
if (r > mx) mx = r, z = y;
}
y = nxt[x];
nxt[x] = z;
solve(z);
nxt[z] = y;
solve(y);
}
inline void work() {
u = CH(vector<P>(a + 1, a + n + 1));
for (i = 0; i + 1 < u.size(); ++i) nxt[i] = i + 1;
nxt[i] = 0;
solve(0);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) a[i].in();
for (i = 1; i <= m; ++i) b[i].in();
if (n == 1 || m == 1) {
puts("YES");
return 0;
}
work();
for (i = 1; i <= max(n, m); ++i) swap(a[i], b[i]);
swap(n, m);
work();
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, long long> help;
map<int, long long>::iterator it;
map<int, int> done;
int modulo(int a, long long b, int c) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % c;
}
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int main() {
int n;
scanf("%d", &n);
int a;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (help.find(a) == help.end()) {
help[a] = 1;
} else {
help[a]++;
}
}
long long prod = 1;
long long div = 1;
int val = -1;
for (it = help.begin(); it != help.end(); it++) {
if ((it->second) % 2 == 1) {
val = it->first;
break;
}
}
if (val == -1) {
for (it = help.begin(); it != help.end(); it++) {
div = (div * (it->second + 1)) % (1000000007 - 1);
}
} else {
for (it = help.begin(); it != help.end(); it++) {
if (it->first != val) {
div = (div * (it->second + 1)) % (1000000007 - 1);
} else {
div = (div * ((it->second + 1) / 2)) % (1000000007 - 1);
}
}
}
for (it = help.begin(); it != help.end(); it++) {
if (val != -1) {
long long temp = modulo(
it->first, (((it->second) * div)) % (1000000007 - 1), 1000000007);
prod = (prod * temp) % 1000000007;
} else {
long long temp =
modulo(it->first, ((((it->second) / 2) * div)) % (1000000007 - 1),
1000000007);
prod = (prod * temp) % 1000000007;
}
}
printf("%lld", prod);
}
| 4 |
#include <bits/stdc++.h>
long long l, r;
long long lower, upper, base;
long long opt;
int p[] = {5, 4, 6, 3, 7, 2, 8, 1, 9, 0};
bool check(long long L, long long R) {
if (R < l || L > r) return false;
return true;
}
bool dfs(long long a, long long b, long long base) {
if (a == 0) b = 0;
long long L = a;
long long R = L + base - 1;
if (!check(L, R)) return false;
if (base == 1) {
if (a * b > opt) {
opt = a * b;
}
return true;
}
base /= 10;
bool ok = false;
for (int i = 0; i < 10; i++) {
ok |= dfs(a + base * p[i], b + base * (9 - p[i]), base);
}
return ok;
}
int main() {
scanf("%I64d%I64d", &l, &r);
long long base = 0;
for (int i = 0; i < 10; i++) {
base = base * 10 + 9;
long long a = base / 2;
if (l <= a && a <= r) {
long long b = base - a;
if (opt < a * b) {
opt = a * b;
}
}
}
base = 0;
while (base < l) base = base * 10 + 9;
if (opt < l * (base - l)) {
opt = l * (base - l);
}
base = 0;
while (base < r) base = base * 10 + 9;
if (opt < r * (base - r)) {
opt = r * (base - r);
}
printf("%I64d\n", opt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 1505;
const int mod = 1e9 + 7;
int n, m, p, t, K[N], pr[N], f[N][N], g[N][N];
int fastpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
int main() {
n = gi();
m = gi();
p = 1ll * gi() * fastpow(gi(), mod - 2) % mod;
t = gi();
for (int i = 0, C = 1; i <= m && i <= t;
++i, C = 1ll * C * (t - i + 1) % mod * fastpow(i, mod - 2) % mod)
K[i] = 1ll * C * fastpow(p, i) % mod * fastpow(mod + 1 - p, t - i) % mod;
pr[0] = K[0];
for (int i = 1; i <= m; ++i) pr[i] = (pr[i - 1] + K[i]) % mod;
for (int l = 1; l <= m; ++l) f[1][l] = 1ll * K[l - 1] * pr[m - l] % mod;
for (int r = m; r >= 1; --r) g[1][r] = 1ll * K[m - r] * pr[r - 1] % mod;
for (int l = 1; l <= m; ++l) f[1][l] = (f[1][l] + f[1][l - 1]) % mod;
for (int r = m; r >= 1; --r) g[1][r] = (g[1][r] + g[1][r + 1]) % mod;
for (int i = 1; i < n; ++i) {
int all = f[i][m];
for (int l = m, s = 0; l >= 1; --l) {
s = (s + 1ll * f[i][l] * K[m - l]) % mod;
f[i + 1][l] = 1ll * (s + 1ll * (g[i][l] - all + mod) * pr[m - l]) % mod *
K[l - 1] % mod;
}
for (int r = 1, s = 0; r <= m; ++r) {
s = (s + 1ll * g[i][r] * K[r - 1]) % mod;
g[i + 1][r] = 1ll * (s + 1ll * (f[i][r] - all + mod) * pr[r - 1]) % mod *
K[m - r] % mod;
}
for (int l = 1; l <= m; ++l)
f[i + 1][l] = (f[i + 1][l] + f[i + 1][l - 1]) % mod;
for (int r = m; r >= 1; --r)
g[i + 1][r] = (g[i + 1][r] + g[i + 1][r + 1]) % mod;
}
printf("%d\n", f[n][m]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
namespace Xrocks {}
using namespace Xrocks;
namespace Xrocks {
class in {
} user_input;
class out {
} output;
in& operator>>(in& X, int& Y) {
scanf("%d", &Y);
return X;
}
in& operator>>(in& X, char* Y) {
scanf("%s", Y);
return X;
}
in& operator>>(in& X, float& Y) {
scanf("%f", &Y);
return X;
}
in& operator>>(in& X, double& Y) {
scanf("%lf", &Y);
return X;
}
in& operator>>(in& X, char& C) {
scanf("%c", &C);
return X;
}
in& operator>>(in& X, string& Y) {
cin >> Y;
return X;
}
in& operator>>(in& X, long long& Y) {
scanf("%lld", &Y);
return X;
}
template <typename T>
in& operator>>(in& X, vector<T>& Y) {
for (auto& x : Y) user_input >> x;
return X;
}
template <typename T>
out& operator>>(out& X, vector<T>& Y) {
for (auto& x : Y) output << x;
return X;
}
out& operator<<(out& X, const int& Y) {
printf("%d", Y);
return X;
}
out& operator<<(out& X, const char& C) {
printf("%c", C);
return X;
}
out& operator<<(out& X, string& Y) {
printf("%s", Y.c_str());
return X;
}
out& operator<<(out& X, const long long& Y) {
printf("%lld", Y);
return X;
}
out& operator<<(out& X, const float& Y) {
printf("%f", Y);
return X;
}
out& operator<<(out& X, const double& Y) {
printf("%lf", Y);
return X;
}
out& operator<<(out& X, const char Y[]) {
printf("%s", Y);
return X;
}
template <typename T>
T max(T A) {
return A;
}
template <typename T, typename... args>
T max(T A, T B, args... S) {
return max(A > B ? A : B, S...);
}
template <typename T>
T min(T A) {
return A;
}
template <typename T, typename... args>
T min(T A, T B, args... S) {
return min(A < B ? A : B, S...);
}
long long fast(long long a, long long b, long long pr) {
if (b == 0) return 1 % pr;
long long ans = 1 % pr;
while (b) {
if (b & 1) ans = (ans * a) % pr;
b >>= 1;
a = (a * a) % pr;
}
return ans;
}
int readInt() {
int n = 0;
scanf("%d", &n);
return n;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readLong() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long inv_(long long val, long long pr = static_cast<long long>(1e9 + 7)) {
return fast(val, pr - 2, pr);
}
} // namespace Xrocks
class solve {
vector<vector<int>> Iadj, Oadj;
vector<int> u;
int n, m, h;
vector<vector<int>> A;
public:
solve() {
user_input >> n >> m >> h;
A.resize(n + 2);
u.resize(n);
Iadj.resize(n);
Oadj.resize(n);
user_input >> u;
for (int i = 0; i < m; i++) {
int x, y;
user_input >> x >> y;
--x, --y;
if ((u[x] + 1) % h == u[y]) {
Iadj[x].push_back(y);
Oadj[y].push_back(x);
}
if ((u[y] + 1) % h == u[x]) {
Iadj[y].push_back(x);
Oadj[x].push_back(y);
}
}
for (int i = 0; i < n; i++) {
if (Iadj[i].size() == 0) {
output << 1 << "\n" << i + 1;
return;
}
}
int k = scc();
vector<int> idx(n + 2);
for (auto& x : idx) x = &x - &idx[0];
sort(idx.begin(), idx.end(),
[&](const int& a, const int& b) { return A[a].size() < A[b].size(); });
for (int i = 0; i < A.size(); i++) {
if (A[idx[i]].size()) {
int take = true;
for (auto& x : A[idx[i]]) {
for (auto& y : Iadj[x]) {
if (vis[x] != vis[y]) {
take = false;
break;
}
}
if (!take) break;
}
if (take) {
output << static_cast<int>(A[idx[i]].size()) << "\n";
for (auto& x : A[idx[i]]) {
output << x + 1 << " ";
}
return;
}
}
}
}
void dfs1(vector<vector<int>>& g, vector<int>& vis, stack<int>& s, int c) {
vis[c] = 1;
for (auto i : g[c])
if (!vis[i]) dfs1(g, vis, s, i);
s.push(c);
}
int dfs2(vector<vector<int>>& g, vector<int>& vis, int c, int t) {
vis[c] = t;
int sz2 = 1;
A[t].push_back(c);
for (auto i : g[c])
if (vis[i] == 1) sz2 += dfs2(g, vis, i, t);
return sz2;
}
vector<int> vis;
int scc() {
int ans = n;
stack<int> s;
vis.resize(n, 0);
for (int i = 0; i < n; i++)
if (!vis[i]) dfs1(Iadj, vis, s, i);
int t = 1;
while (!s.empty()) {
int z = s.top();
s.pop();
if (vis[z] == 1) {
t++;
ans = min(ans, dfs2(Oadj, vis, z, t));
}
}
return ans;
}
};
int32_t main() {
int t = 1, i = 1;
if (0) scanf("%d", &t);
while (t--) {
if (0) printf("Case #%d: ", i++);
new solve;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long int const MOD = 1000000007;
long long int const N = 3000005;
long long int const LN = 20;
long long int const inf = 8e18;
using namespace std;
long long int n, m, a[N];
long long int ok[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) {
long long int x;
cin >> x;
a[x]++;
}
for (long long int i = 1; i < N; i++) {
for (long long int j = i; j < N; j += i) {
if (j / i != i)
ok[j] += (a[i] * a[j / i]);
else
ok[j] += a[i] * (a[i] - 1);
}
}
for (long long int i = 1; i < N; i++) ok[i] += ok[i - 1];
long long int m;
cin >> m;
for (long long int i = 1; i <= m; i++) {
long long int d;
cin >> d;
cout << n * (n - 1) - ok[d - 1] << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-5;
const double Pi = 3.1415926535897932;
const int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1};
const int N = 2e6 + 100;
int cnt[N];
map<int, int> mp[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> cnt[i];
ans += cnt[i];
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int s, t, u;
cin >> s >> t >> u;
if (mp[s][t] != 0) {
if (cnt[mp[s][t]] >= 0) ans++;
cnt[mp[s][t]]++;
}
mp[s][t] = u;
if (mp[s][t] != 0) {
cnt[mp[s][t]]--;
if (cnt[mp[s][t]] >= 0) ans--;
}
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int arr[100100];
int A[23][100100];
int B[23][100100];
int C[100100];
int tree[100002 * 4];
void update(int node, int i, int j, int idx, int val) {
if (idx < i || idx > j) return;
if (idx >= i && idx <= j && i == j) {
tree[node] = val;
return;
}
int left = 2 * node;
int right = left + 1;
int mid = (i + j) / 2;
update(left, i, mid, idx, val);
update(right, mid + 1, j, idx, val);
tree[node] = min(tree[left], tree[right]);
}
int query(int node, int i, int j, int a, int b) {
if (i > j) return 999999;
if (j < a || i > b) return 999999;
if (i >= a && j <= b) {
return tree[node];
}
int left = 2 * node;
int right = left + 1;
int mid = (i + j) / 2;
int f1 = query(left, i, mid, a, b);
int f2 = query(right, mid + 1, j, a, b);
return min(f1, f2);
}
void calSparseTable() {
int p = 1;
for (int i = 1; i <= 20; i++) {
for (int j = 1; j <= n; j++) {
A[i][j] = A[i - 1][j];
if (j + p <= n) A[i][j] = min(A[i][j], A[i - 1][j + p]);
}
for (int j = 1; j <= n; j++) {
B[i][j] = B[i - 1][j];
if (j + p <= n) B[i][j] = max(B[i][j], B[i - 1][j + p]);
}
p = p * 2;
}
}
int getMin(int a, int b) {
int c = b - a + 1;
int idx = -1;
while (c) {
c = c / 2;
idx++;
}
int val = pow(2, idx);
return min(A[idx][a], A[idx][b - val + 1]);
}
int getMax(int a, int b) {
int c = b - a + 1;
int idx = -1;
while (c) {
c = c / 2;
idx++;
}
int val = pow(2, idx);
return max(B[idx][a], B[idx][b - val + 1]);
}
void preCal() {
int last = 1;
for (int i = 1; i <= n; i++) {
last = max(last, i);
while (last + 1 <= n) {
int a = i;
int b = last + 1;
int mn = getMin(a, b);
int mx = getMax(a, b);
if (mx - mn <= m) {
last++;
} else
break;
}
C[i] = last;
}
}
int cal() {
calSparseTable();
preCal();
update(1, 1, n + 1, n + 1, 0);
for (int i = n; i >= n - k + 2; i--) {
update(1, 1, n + 1, i, 999999);
}
for (int i = n - k + 1; i >= 1; i--) {
int a = i + k;
int b = C[i] + 1;
int uu = query(1, 1, n + 1, a, b);
if (uu != 999999) uu++;
update(1, 1, n + 1, i, uu);
}
int vv = query(1, 1, n + 1, 1, 1);
if (vv == 999999) return -1;
return vv;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
A[0][i] = arr[i];
B[0][i] = arr[i];
}
printf("%d\n", cal());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5;
const int MAX2 = 1e9;
const long long MAX3 = 1e12;
int gcd(int a, int b) {
if (b == 0) {
return a;
}
int a1 = a % b;
return gcd(b, a1);
}
void swap1(char& x, char& y) {
char t = x;
x = y;
y = t;
}
int main() {
int n, a, b, c, sum = 0;
cin >> n >> a >> b >> c;
for (int x = 0; x <= n; x++) {
for (int y = 0; y <= n; y++) {
int s = a * x + b * y;
int z = abs(n - s) / c;
if (sum < x + y + z && s + c * z == n) {
sum = x + y + z;
}
}
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,C;
cin >> A >> B >> C;
cout << ( (A-C)*(C-B)>0?"Yes":"No" ) << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fr first
#define sc second
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef pair<int,pii> pip;
const int INF = (1<<25);
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
struct DATA{
string s;
int score;
};
int main(){
int n;
int cnt=0;
while(cin>> n,n){
if(cnt!=0){
cout<< endl;
}
cnt++;
DATA data[10],temp;
for(int i=0;i<n;i++){
int a,b,c;
cin>> data[i].s>> a>> b>> c;
data[i].score=a*3+c;
}
for(int i=0;i<n;i++){
for(int j=n-1;j>i;j--){
if(data[j].score>data[j-1].score){
temp=data[j];
data[j]=data[j-1];
data[j-1]=temp;
}
}
}
for(int i=0;i<n;i++){
cout<< data[i].s<< ","<< data[i].score<< endl;
}
}
} | 0 |
#include <bits/stdc++.h>
const int maxn = 1e6 + 9;
int Read() {
int x(0), f(1);
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3ll) + (x << 1ll) + c - '0';
c = getchar();
}
return x * f;
}
struct node {
int to, nxt, id;
} dis[maxn];
struct Edge {
int u, v, id;
};
int n, num, tot;
int head[maxn], ans[maxn], l[maxn], r[maxn], a[maxn], deg[maxn], vis[maxn],
col[2][maxn], mark[maxn];
std::vector<Edge> edge;
std::vector<int> V[maxn];
void Add(int u, int v, int id0) {
dis[++num] = (node){v, head[u], id0};
head[u] = num;
}
void Dfs(int u) {
mark[u] = 1;
for (int i = head[u]; i != -1; i = dis[i].nxt)
if (!vis[i]) {
int v(dis[i].to);
ans[dis[i].id] = (u < v);
vis[i] = vis[i ^ 1] = 1;
Dfs(v);
}
}
int main() {
n = Read();
for (int i = 1; i <= n; ++i) {
l[i] = Read();
r[i] = Read() + 1;
a[++tot] = l[i];
a[++tot] = r[i];
}
std::sort(a + 1, a + 1 + tot);
tot = std::unique(a + 1, a + 1 + tot) - a - 1;
num = -1;
for (int i = 1; i <= tot; ++i) head[i] = -1;
for (int i = 1; i <= n; ++i) {
l[i] = std::lower_bound(a + 1, a + 1 + tot, l[i]) - a;
r[i] = std::lower_bound(a + 1, a + 1 + tot, r[i]) - a;
deg[l[i]]++;
deg[r[i]]++;
Add(l[i], r[i], i);
Add(r[i], l[i], i);
}
int lst(0);
for (int i = 1; i <= tot; ++i)
if (deg[i] & 1) {
if (!lst)
lst = i;
else {
Add(lst, i, 0);
Add(i, lst, 0);
lst = 0;
}
}
for (int i = 1; i <= tot; ++i)
if (!mark[i]) Dfs(i);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 9;
const int maxk = 9;
int n, k;
char s[maxn][maxk];
int a[maxn], num[maxn];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < k; i++) a[i] = i;
int ans = 1000000000;
do {
for (int i = 0; i < n; i++) {
num[i] = 0;
for (int j = 0; j < k; j++) num[i] = num[i] * 10 + s[i][a[j]] - '0';
}
sort(num, num + n);
ans = min(abs(num[0] - num[n - 1]), ans);
} while (next_permutation(a, a + k));
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int set[10002];
int find(int);
int main(){
int n,q;
cin>>n>>q;
for(int i=0;i<=n;i++)
set[i]=i;
int qu,x,y;
for(int i=0;i<q;i++){
cin>>qu>>x>>y;
if(qu){
if(find(x)==find(y))
cout<<1<<endl;
else cout<<0<<endl;
}else{
set[find(x)]=find(y);
}
}
return 0;
}
int find(int x){
return x==set[x]?x:set[x]=find(set[x]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 400000;
int h[NMAX];
vector<int> all_vals;
struct Op {
int type;
int p, x;
long long int v;
} ops[NMAX];
int sz;
int aib_cnt[2 * NMAX];
long long int aib_sum[2 * NMAX];
template <class T>
void update(T aib[], int where, T val) {
for (; where <= sz; where += ((where) & (-(where)))) aib[where] += val;
}
template <class T>
T query(T aib[], int where) {
T ans = 0;
for (; where; where -= ((where) & (-(where)))) ans += aib[where];
return ans;
}
bool works(long long int water, int bound) {
int cnt = query(aib_cnt, bound);
long long int sum = query(aib_sum, bound);
return sum + water <= 1LL * (all_vals[bound - 1]) * cnt;
}
long double works2(long long int water, int bound) {
int cnt = query(aib_cnt, bound - 1);
long long int sum = query(aib_sum, bound - 1);
return (1.0L * sum + water) / cnt;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> h[i];
all_vals.push_back(h[i]);
}
for (int i = 1; i <= q; ++i) {
cin >> ops[i].type;
if (ops[i].type == 1) {
cin >> ops[i].p >> ops[i].x;
all_vals.push_back(ops[i].x);
} else
cin >> ops[i].v;
}
sort(all_vals.begin(), all_vals.end());
all_vals.resize(unique(all_vals.begin(), all_vals.end()) - all_vals.begin());
sz = all_vals.size();
for (int i = 1; i <= n; ++i) {
h[i] = lower_bound(all_vals.begin(), all_vals.end(), h[i]) -
all_vals.begin() + 1;
update(aib_cnt, h[i], 1);
update(aib_sum, h[i], 1LL * all_vals[h[i] - 1]);
}
all_vals.push_back(all_vals.back() + 1e9);
for (int i = 1; i <= q; ++i)
if (ops[i].type == 1) {
update(aib_cnt, h[ops[i].p], -1);
update(aib_sum, h[ops[i].p], -1LL * all_vals[h[ops[i].p] - 1]);
h[ops[i].p] = ops[i].x;
h[ops[i].p] = lower_bound(all_vals.begin(), all_vals.end(), h[ops[i].p]) -
all_vals.begin() + 1;
update(aib_cnt, h[ops[i].p], 1);
update(aib_sum, h[ops[i].p], 1LL * all_vals[h[ops[i].p] - 1]);
} else {
int st = 1;
int dr = sz;
int ans = sz + 1;
int mid;
while (st <= dr) {
mid = (st + dr) >> 1;
if (works(ops[i].v, mid)) {
ans = mid;
dr = mid - 1;
} else
st = mid + 1;
}
cout << fixed << setprecision(5) << works2(ops[i].v, ans) << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
map<string, int> M;
char op;
int main() {
int T;
cin >> T;
getchar();
while (T--) {
op = getchar();
cin >> s;
getchar();
if (op == '?') {
while (s.length() > 1 && s[0] == '0') s.erase(s.begin());
cout << M[s] << endl;
} else if (op == '+') {
int l = s.length();
for (int i = 0; i < l; i++) s[i] = (s[i] - '0') % 2 + '0';
while (s.length() > 1 && s[0] == '0') s.erase(s.begin());
M[s]++;
} else if (op == '-') {
int l = s.length();
for (int i = 0; i < l; i++) s[i] = (s[i] - '0') % 2 + '0';
while (s.length() > 1 && s[0] == '0') s.erase(s.begin());
M[s]--;
}
}
}
| 1 |
#include <bits/stdc++.h>
int a, b;
int ans = 0;
void check(int x) {
if (x > b) {
++ans;
}
}
int main() {
scanf("%d %d", &a, &b);
a -= b;
if (a == 0) {
printf("infinity\n");
} else {
for (int i = 1; i * i <= a; ++i) {
if (a % i == 0) {
check(i);
if (i != a / i) {
check(a / i);
}
}
}
printf("%d\n", ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int answer(unsigned long long int k) {
unsigned long long int xx = 9;
unsigned long long int i = 1;
long long int aivyn = 0;
while (xx * i <= k) {
aivyn += xx;
k = k - xx * i;
xx = xx * 10;
i++;
}
aivyn += (k / i);
if (k % i) {
aivyn++;
}
if (k % i == 0) return aivyn % 10;
int digit = i - (k % i);
i = 0;
while (i < digit) {
aivyn = aivyn / 10;
i++;
}
return aivyn % 10;
}
unsigned long long int func(long long int k) {
unsigned long long int xx = k + 1;
if (k & 1)
xx = xx / 2;
else
k = k / 2;
return k * xx;
}
unsigned long long int calc(unsigned long long int k) {
unsigned long long int sum = func(k);
unsigned long long int xx = 9;
while (xx <= k) {
k = k - xx;
xx = xx * 10;
sum += func(k);
}
return sum;
}
int main() {
int q;
cin >> q;
while (q--) {
unsigned long long int k;
cin >> k;
if (k == 1) {
cout << k << endl;
continue;
}
unsigned long long int low = 1, high = 10000000000;
while (low <= high) {
unsigned long long int mid = (low + high) / 2;
unsigned long long int val1 = calc(mid);
unsigned long long int val2 = calc(mid + 1);
if (val1 < k && val2 >= k) {
k = k - val1;
break;
} else if (val1 >= k) {
high = mid - 1;
} else {
low = mid + 1;
}
}
cout << answer(k) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 4786)
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
const int mx = 1 << 29;
int ans, sum, t, n, k, m, c, d;
int main() {
cin >> n >> m;
if (n == 1) {
cout << 1;
} else if (m == 1) {
cout << 2;
} else if (m == n) {
cout << m - 1;
} else {
c = m - 1;
d = n - m;
if (d > c)
ans = m + 1;
else
ans = m - 1;
cout << ans;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check = false;
string ans = "", s;
void solve() {
if (cin >> s) {
ans += s;
if (s == "pair") {
ans += "<";
solve();
ans += ",";
solve();
ans += ">";
}
} else {
check = true;
}
}
int main() {
int n;
cin >> n;
solve();
if (cin >> s || check) return cout << "Error occurred\n", 0;
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 202020;
int a[N], n, m, x;
string s;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
n = s.size();
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> x;
int y = n - x + 1;
a[x]++, a[y + 1]--;
}
for (int i = 1; i < N; i++) a[i] += a[i - 1];
for (int i = 1; i <= (int)s.size() / 2; i++)
if (a[i] & 1) swap(s[i - 1], s[n - i]);
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char c[123];
int main() {
fill(c, c + 123, '.');
string s;
cin >> s;
set<char> p = {'A', 'H', 'I', 'M', 'O', 'o', 'T', 'U',
'V', 'W', 'w', 'v', 'X', 'x', 'Y'};
c['A'] = 'A';
c['b'] = 'd';
c['d'] = 'b';
c['H'] = 'H';
c['I'] = 'I';
c['M'] = 'M';
c['O'] = 'O';
c['o'] = 'o';
c['p'] = 'q';
c['q'] = 'p';
c['T'] = 'T';
c['U'] = 'U';
c['V'] = 'V';
c['v'] = 'v';
c['W'] = 'W';
c['w'] = 'w';
c['X'] = 'X';
c['x'] = 'x';
c['Y'] = 'Y';
for (int i = 0; i < (s.size() / 2); i++) {
if (c[s[i]] != s[(int)s.size() - 1 - i]) {
cout << "NIE";
return 0;
}
}
if (s.size() % 2 == 0) {
cout << "TAK";
return 0;
}
char x = s[(int)(s.size() / 2)];
if (p.find(x) != p.end())
cout << "TAK";
else
cout << "NIE";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& a) {
char c = getchar();
int f = 1;
a = 0;
for (; c > '9' || c < '0'; c = getchar())
if (c == '-') f = -1;
for (; c <= '9' && c >= '0'; c = getchar()) a = a * 10 + c - 48;
a *= f;
}
const int o = 1e5 + 10;
inline long long Max(long long a, long long b) { return a > b ? a : b; }
long long T, n, k, a[o];
pair<long long, long long> p[o];
signed main() {
for (read(T); T--;) {
read(n);
for (long long i = 1; i <= n; ++i) {
read(k);
for (long long j = 0; j < k; ++j) read(a[j]);
a[k] = 0;
for (long long j = k - 1; j + 1; --j) a[j] = Max(a[j + 1], a[j] - j);
p[i] = make_pair(a[0], k);
}
sort(p + 1, p + 1 + n);
for (long long i = 2, j = p[1].second; i <= n; j += p[i++].second)
p[i].first = Max(p[i - 1].first, p[i].first - j);
printf("%lld\n", p[n].first + 1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
struct node {
char c = 0;
unique_ptr<node> sib;
unique_ptr<node> child;
node *chain = nullptr;
vector<node *> rchain;
node *get_child(char ch, bool make = false) {
unique_ptr<node> *cur = &child;
while ((*cur) && (*cur)->c != ch) cur = &(*cur)->sib;
if ((*cur) && (*cur)->c == ch)
return (*cur).get();
else if (make) {
unique_ptr<node> n(new node);
n->c = ch;
*cur = move(n);
return (*cur).get();
} else
return nullptr;
}
array<int, 2> count1() {
array<int, 2> ans{0, 1};
if (!c) ans[1] = 0;
for (node *s : rchain) {
auto sub = s->count1();
ans[0] += max(sub[0], sub[1]);
ans[1] += sub[0];
}
return ans;
}
int count() {
int ans = 0;
if (!chain) {
auto sub = count1();
ans = max(sub[0], sub[1]);
}
if (child) ans += child->count();
if (sib) ans += sib->count();
return ans;
}
};
int main(int argc, const char **argv) {
redirect(argc, argv);
int T;
cin >> T;
for (int cas = 0; cas < T; cas++) {
int N;
cin >> N;
vector<string> S(N);
unique_ptr<node> root(new node);
for (int i = 0; i < N; i++) {
cin >> S[i];
node *p = root.get();
for (char c : S[i]) p = p->get_child(c, true);
}
for (int i = 0; i < N; i++) {
node *p = root.get();
node *q = root->get_child(S[i][0], false);
if (!q->chain) {
q->chain = p;
p->rchain.push_back(q);
}
for (int j = 1; j < ((long long)(S[i]).size()); j++) {
p = p->get_child(S[i][j], false);
if (!p) break;
q = q->get_child(S[i][j], false);
if (!q->chain) {
q->chain = p;
p->rchain.push_back(q);
}
}
}
int ans = root->count();
cout << ans << '\n';
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int y,m,d;
string g;
while(cin>>g&&g!="#"){
cin>>y>>m>>d;
if(y==31&&m>=5){
g='?'; y-=30;
}
if(y>31){
g='?'; y-=30;
}
cout<<g<<" "<<y<<" "<<m<<" "<<d<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
v[i] = a[i];
}
int z = 0;
int o = 0;
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 0) {
z++;
} else {
o++;
}
}
bool sorted = true;
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (a[i] != v[i]) {
sorted = false;
break;
}
}
if (min(z, o) > 0 || sorted) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {2, 2, -2, -2, 1, 1, -1, -1}, ddy[] = {1, -1, 1, -1, 2, -2, 2, -2};
int b[2][100000];
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n == 1) {
if (m == 1) {
puts("YES");
return !printf("1");
}
if (m <= 3) return !printf("NO");
}
if (n == 2 && m <= 3) return !printf("NO");
if (n == 3) {
if (m <= 2) return !printf("NO");
if (m == 3) {
puts("YES");
return !printf("1 6 7\n8 4 3\n2 9 5");
}
}
puts("YES");
if (m == 4) {
int a[2][4] = {{2, 4, 1, 3}, {3, 1, 4, 2}};
for (int(i) = (1); (i) <= (n); (i) += (1)) {
int t = i & 1;
for (int(j) = (0); (j) <= (3); (j) += (1))
printf("%d ", 4 * (i - 1) + a[t][j]);
puts("");
}
return 0;
}
if (m > 4) {
for (int(i) = (0); (i) <= (m - 1); (i) += (2)) {
b[1][i] = i / 2 + 1;
if (i < m - 1) b[1][i + 1] = b[1][i] + (m + 1) / 2;
}
for (int(i) = (0); (i) <= (m - 1); (i) += (1))
b[0][i] = b[1][(i + m - 1) % m];
for (int(i) = (1); (i) <= (n); (i) += (1)) {
int t = i & 1;
for (int(j) = (0); (j) <= (m - 1); (j) += (1))
printf("%d ", m * (i - 1) + b[t][j]);
puts("");
}
return 0;
}
if (n == 4) {
int a[2][4] = {{2, 4, 1, 3}, {3, 1, 4, 2}};
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
for (int(j) = (1); (j) <= (m); (j) += (1))
printf("%d ", a[j & 1][i] * m + j - m);
puts("");
}
return 0;
}
if (n > 4) {
for (int(i) = (0); (i) <= (n - 1); (i) += (2)) {
b[1][i] = i / 2 + 1;
if (i < n - 1) b[1][i + 1] = b[1][i] + (n + 1) / 2;
}
for (int(i) = (0); (i) <= (n - 1); (i) += (1))
b[0][i] = b[1][(i + n - 1) % n];
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
for (int(j) = (1); (j) <= (m); (j) += (1))
printf("%d ", b[j & 1][i] * m + j - m);
puts("");
}
return 0;
}
}
| 2 |
#include "bits/stdc++.h"
using namespace std;
int main()
{
int n;
scanf("%d", &n);
bitset<10001> a(1);
for(int i = 0, j; i < n; ++i)
{
scanf("%d", &j);
a |= a << j;
}
for(int i = 10000; i >= 0; --i)
{
if(i % 10)
{
if(a.test(i))
{
printf("%d\n", i);
return 0;
}
}
}
printf("0\n");
return 0;
}
| 0 |
#include <array>
#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
int judge(array<int, 30>& cards, int rem) {
if (rem == 0) return 1;
for (int i = 0; i < 30; i++) {
if (cards[i] >= 3) {
cards[i] -= 3;
int res = judge(cards, rem - 3);
if (res) return res;
cards[i] += 3;
}
if (i >= 2 && cards[i] > 0 && cards[i - 1] > 0 && cards[i - 2] > 0) {
for (int j = i - 2; j <= i; j++) cards[j]--;
int res = judge(cards, rem - 3);
if (res) return res;
for (int j = i - 2; j <= i; j++) cards[j]++;
}
}
return 0;
}
void solve() {
array<int, 9> n;
array<char, 9> c;
for (int& x : n) cin >> x;
for (char& x : c) cin >> x;
array<int, 30> cards;
cards.fill(0);
for (int i = 0; i < 9; i++) {
int m = 0;
switch (c[i]) {
case 'R': m = 0; break;
case 'G': m = 10; break;
case 'B': m = 20; break;
}
cards[n[i] + m]++;
}
cout << judge(cards, 9) << endl;
}
int main() {
int n;
for (cin >> n; n; n--) {
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istringstream *iss) {}
template <typename T, typename... Args>
void err(istringstream *iss, const T &varVal, const Args &...args) {
string varName;
*iss >> varName;
if (varName.back() == ',') varName.back() = ' ';
cout << varName << " = " << varVal << "; ", err(iss, args...);
}
int n, m, K, T, Q, cn;
int lcm[] = {0, 1, 2, 6, 12, 60, 60, 420,
840, 2520, 2520, 27720, 27720, 360360, 360360, 360360};
long long a, b;
long long func(long long hi, long long lo) {
long long ret = 0;
while (hi > lo) {
long long mx = 1;
for (int i = 2; i <= K; i++) {
if (hi % i <= hi - lo) mx = max(mx, hi % i);
}
hi -= mx;
ret++;
}
return ret;
}
int main() {
cin.tie(NULL);
scanf("%lld%lld%d", &a, &b, &K);
int l = lcm[K];
long long x = ((b - 1) / l + 1) * l, y = a / l * l;
printf("%lld\n", a - b <= l ? func(a, b)
: func(x, b) + (y / l - x / l) * func(x + l, x) +
func(a, y));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int inf = 1e9;
map<pair<int, int>, int> vis, used, str;
set<pair<int, int> > crd;
int n;
int dx[] = {1, 2, 2, 1, -1, -2, -2, -1}, dy[] = {-2, -1, 1, 2, 2, 1, -1, -2};
int check(vector<pair<int, int> > cd) {
used.clear(), str.clear();
for (int i = (0), _x = ((int)(cd).size() - 1); i <= _x; i++) str[cd[i]] = 1;
vis.clear(), crd.clear();
for (int i = (0), _x = ((int)(cd).size() - 1); i <= _x; i++)
vis[cd[i]] = 4, crd.insert(cd[i]);
int ans = 0;
int mnx = inf, mxx = -inf, mxy = -inf, mny = inf;
while (!crd.empty()) {
pair<int, int> u = *crd.begin();
used[u] = 1;
ckmin(mnx, u.first), ckmin(mny, u.second), ckmax(mxx, u.first),
ckmax(mxy, u.second);
ans++;
vis[u] = -inf;
crd.erase(crd.begin());
for (int i = 0; i < 8; i++) {
pair<int, int> v = u;
v.first += dx[i], v.second += dy[i];
vis[v]++;
if (vis[v] >= 4) crd.insert(v);
}
}
return ans;
}
vector<pair<int, int> > corn(int n) {
vector<pair<int, int> > id;
for (int i = (1), _x = (n / 2); i <= _x; i++) id.push_back(make_pair(i, 0));
n -= n / 2;
for (int i = (1), _x = (n); i <= _x; i++) id.push_back(make_pair(i, 1));
return id;
}
vector<pair<int, int> > test(int h) {
vector<pair<int, int> > id;
id.clear();
int m = h / 2;
for (int i = (1), _x = (m); i <= _x; i++) id.push_back(make_pair(i, 0));
for (int i = (1), _x = (h - m); i <= _x; i++) id.push_back(make_pair(i, 1));
int k = n - h, mdr = (m + 1) / 2, mdl = (h - m + 1) / 2;
int R = m / 4 - (m % 4 == 0), L = (h - m) / 4 - ((h - m) % 4 == 0);
if (k / 2 > 1) {
for (int i = (-R - k / 2), _x = (-R - 1); i <= _x; i++)
id.push_back(make_pair(mdr, i));
k -= k / 2;
}
for (int i = (L + 2), _x = (L + k + 1); i <= _x; i++)
id.push_back(make_pair(mdl, i));
return id;
}
void quit(vector<pair<int, int> > id) {
assert((int)(id).size() == n);
assert(check(id) >= n * n / 10);
for (int i = (0), _x = ((int)(id).size() - 1); i <= _x; i++)
printf("%d %d\n", id[i].first, id[i].second);
exit(0);
}
int main() {
scanf("%d", &n);
vector<pair<int, int> > id;
if (n <= 14) quit(corn(n));
if (n <= 50) {
int mx = 0;
vector<pair<int, int> > id;
for (int i = (1), _x = (n); i <= _x; i++) {
vector<pair<int, int> > tmp = test(i);
int t = check(tmp);
if (t > mx) mx = t, id = tmp;
}
quit(id);
}
int m = n * 4 / 5;
quit(test(m));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T sig = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') sig = -1;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= sig;
}
struct Line {
int l, r, y;
};
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
struct Fraction {
int a, b;
Fraction(int a, int b) {
if (b < 0) {
a = -a;
b = -b;
}
int g = gcd(abs(a), abs(b));
this->a = a / g;
this->b = b / g;
};
bool operator<(const Fraction &other) const {
return (long long)a * other.b < (long long)b * other.a;
}
bool operator<=(const Fraction &other) const {
return (long long)a * other.b <= (long long)b * other.a;
}
bool operator>(const Fraction &other) const {
return (long long)a * other.b > (long long)b * other.a;
}
bool operator>=(const Fraction &other) const {
return (long long)a * other.b >= (long long)b * other.a;
}
bool operator!=(const Fraction &other) const {
return (long long)a * other.b != (long long)b * other.a;
}
bool operator==(const Fraction &other) const {
return (long long)a * other.b == (long long)b * other.a;
}
};
class Solution {
vector<pair<Fraction, Fraction>> seg;
Fraction theta(int x1, int x2, int dy) { return Fraction(x1 - x2, dy); }
void calc(Line a, Line b) {
if (a.y == b.y) return;
if (a.y < b.y) swap(a, b);
Fraction t1 = theta(a.l, b.r, a.y - b.y);
Fraction t2 = theta(a.r, b.l, a.y - b.y);
if (t1 > t2) swap(t1, t2);
seg.emplace_back(t1, t2);
}
public:
void solve() {
int n;
read(n);
vector<Line> a(n);
for (int i = 0; i < n; ++i) read(a[i].l), read(a[i].r), read(a[i].y);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) calc(a[i], a[j]);
double ans = 1e18;
sort(seg.begin(), seg.end());
vector<pair<Fraction, Fraction>> t;
const Fraction magic(1, 1000000007);
Fraction l0 = magic, r0 = magic;
for (auto &[l, r] : seg) {
if (l >= r0) {
if (r0 != magic) t.emplace_back(l0, r0);
l0 = l;
r0 = r;
} else {
if (l0 == magic) {
l0 = l;
r0 = r;
} else
r0 = max(r0, r);
}
}
if (l0 != magic) t.emplace_back(l0, r0);
vector<Fraction> vt;
for (auto &[l, r] : t) vt.emplace_back(l), vt.emplace_back(r);
if (vt.empty()) vt.emplace_back(0, 1);
for (Fraction d : vt) {
double l = 1e18, r = -1e18;
for (auto &e : a) {
l = min(l, (double)-d.a / d.b * e.y + e.l);
r = max(r, (double)-d.a / d.b * e.y + e.r);
}
ans = min(ans, r - l);
}
printf("%.9f", ans);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Solution solution = Solution();
solution.solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, i, j;
cin >> k;
i = k / 2;
j = k % 2;
if (k > 36)
cout << -1;
else {
for (k = 0; k < i; k++) cout << 8;
for (k = 0; k < j; k++) cout << 4;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, N;
int cnt[25];
int myAbs(int x) { return max(x, -x); }
vector<pair<int, int>> ans;
void print(int a, int b, int n) {
for (int i = 0; i < n; i++) {
ans.push_back({a, b});
}
}
void solve1(int ind, int a, int b, int c) {
if (ind == n) return;
solve1(ind + 1, a, c, b);
print(a, c, cnt[ind]);
solve1(ind + 1, b, a, c);
}
void solve2(int ind, int a, int b, int c) {
if (ind >= N || cnt[ind] == 0) return;
if (ind == N - 1) {
print(a, b, cnt[ind] - 1);
print(a, c, 1);
print(b, c, cnt[ind] - 1);
return;
}
if (cnt[ind] == 1)
solve1(ind, a, b, c);
else {
solve2(ind + 1, a, b, c);
print(a, b, cnt[ind]);
solve1(ind + 1, c, b, a);
print(b, c, cnt[ind]);
solve1(ind + 1, a, b, c);
}
}
int main() {
int ind = -1, last = -1;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (last != x) {
ind++;
cnt[ind] = 1;
} else {
cnt[ind]++;
}
last = x;
}
N = ind + 1;
solve2(0, 1, 2, 3);
cout << ans.size() << '\n';
for (pair<int, int> item : ans)
cout << item.first << " " << item.second << '\n';
}
| 4 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
typedef vector<int> vi;
int main() {
int N, M;
cin >> N;
vi vec1(N);
rep(i, N)
cin >> vec1.at(i);
cin >> M;
vi vec2(M);
rep(i, M)
cin >> vec2.at(i);
vi vec3;
set_union(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), inserter(vec3, vec3.end()));
rep(i, vec3.size())
cout << vec3.at(i) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void print(bool n) {
if (n)
cout << "YES";
else
cout << "NO";
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long ttt;
cin >> ttt;
for (long long T = 1; T <= ttt; T++) {
long long n;
cin >> n;
long long x = 2;
while (n--) cout << x++ << ' ';
cout << '\n';
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main()
{
char S;
cin >> S;
if(S=='S')cout << "Cloudy";
else if(S=='C') cout<<"Rainy";
else cout<<"Sunny";
return 0;
} | 0 |
#include <algorithm>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
#define el endl
#define fd fixed
#define INF INT_MAX/2-1
#define pb push_back
using namespace std;
int main() {
int n, tmp;
string s, res, station = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
while (cin >> n, n) {
int key[n];
for (int i = 0; i < n; i++) {
cin >> tmp;
key[i] = tmp;
}
cin >> s;
res = "";
for (int i = 0; i < s.length(); i++) {
res += station[(station.find(s[i])-key[i%n]+52)%52];
}
cout << res << el;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
int a[305][305];
int p[305][305];
int bounds(int x, int y, int n, int m) {
if (x >= 0 && x < n && y >= 0 && y < m) return 1;
return 0;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int flag = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int k = 0; k < 4; k++) {
if (!bounds(i + dx[k], j + dy[k], n, m)) continue;
cnt++;
}
if (cnt < a[i][j]) {
flag = 1;
}
p[i][j] = cnt;
}
}
if (flag) {
printf("NO\n");
} else {
printf("YES\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; ++j) {
printf("%d ", p[i][j]);
}
printf("\n");
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
int n, m, x, p[111111], cnt[111111], y, cc, used[111111], timer;
pair<int, int> a[111111], curp;
long long ans, sum, cursum, v[111111];
vector<vector<int> > g;
bool w[111111];
int findSet(int v) {
if (v != p[v]) {
return p[v] = findSet(p[v]);
}
return v;
}
void unite(int a, int b) {
a = findSet(a), b = findSet(b);
if (a != b) {
if (rand() & 1) {
swap(a, b);
}
p[b] = a;
cnt[a] = (cnt[b] += cnt[a]);
}
}
int main() {
srand(time(NULL));
scanf("%d%d", &n, &m);
g.resize(n + 5);
for (int i = 1; i <= n; ++i) scanf("%d", &x), a[i - 1] = make_pair(x, i);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
sort(a, a + n, greater<pair<int, int> >());
ans = 0;
for (int i = 1; i <= n; ++i) p[i] = i, cnt[i] = 1;
memset(w, timer = 0, sizeof(w));
memset(used, -1, sizeof(used));
for (int i = 0; i < n; ++i) {
curp = a[i];
w[x = curp.second] = true;
cc = sum = 0;
++timer;
for (auto& it : g[x]) {
if (w[it] && used[findSet(it)] < timer) {
v[cc] = cnt[findSet(it)];
sum += v[cc];
ans += v[cc++] * a[i].first;
used[findSet(it)] = timer;
}
}
cursum = 0;
for (int j = 0; j < cc; ++j) {
cursum += v[j] * (sum - v[j]);
}
ans += (cursum >> 1) * a[i].first;
for (auto& it : g[x]) {
if (w[it]) unite(x, it);
}
}
printf("%.16lf", ans * 2. / n / (n - 1));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr[i] = x;
}
int answer = 0;
int previous = arr[0];
int sizee = 1;
for (int i = 1; i < n; i++) {
if (arr[i] > previous) {
sizee++;
previous = arr[i];
} else {
if (sizee > answer) answer = sizee;
sizee = 1;
previous = arr[i];
}
}
if (sizee > answer) answer = sizee;
cout << answer << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3002;
const long long MOD = 1000000007;
int n, k, x, bigger;
vector<int> a;
bool same[maxn];
map<int, bool> visit;
map<int, int> Lit;
queue<int> q;
int main() {
cin >> n >> k;
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
if (!same[x]) a.push_back(x - n), same[x] = true;
if (x == n) return cout << 1, 0;
if (x > n)
bigger++;
else
bigger--;
}
if (bigger == -k || bigger == k) return cout << -1, 0;
for (int i = 0; i < a.size(); i++) {
q.push(a[i]);
Lit[a[i]] = 1;
visit[a[i]] = true;
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = 0; i < a.size(); i++) {
int tmp = cur + a[i];
if (!visit[tmp]) {
visit[tmp] = true;
q.push(tmp);
Lit[tmp] = Lit[cur] + 1;
if (tmp == 0) return cout << Lit[tmp], 0;
}
}
}
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
typedef long long LL;
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(5);
}
typedef complex<double> P;
P input() {
double x, y;
cin >> x >> y;
return {x, y};
}
struct C{P p; double r; };
typedef vector<P> L;
P vec(L l) { return l[1] - l[0]; }
const double Rad = 100.0;
const double EPS = 1e-6;
int sign(double x) { return (x > EPS) - (x < -EPS); }
int comp(double x, double y){ return sign(x - y); }
double dot(P a, P b) { return real(conj(a) * b); }
double cross(P a, P b) { return imag(conj(a) * b); }
vector<double> common_tangents(const C& c, const C& d) {
vector<double> res;
P v = d.p - c.p;
double l = abs(v);
double a = arg(v);
if(sign(l - abs(c.r - d.r)) > 0) {
double a1 = acos((c.r - d.r) / l);
res.push_back(a + a1);
res.push_back(a - a1);
if(sign(l - (c.r + d.r)) > 0) {
double a2 = acos((c.r + d.r) / l);
res.push_back(a + a2);
res.push_back(a - a2);
}
}
if(sign(l - abs(c.r - d.r)) == 0 || (sign(l - (c.r + d.r)) == 0 && sign(l) != 0)) {
res.push_back(a);
}
return res;
}
P tangent_point(const C& c, double th) {
return c.p + polar(c.r, th);
}
const double INF = 1e9;
enum { OUT, ON, IN };
int contains(C c, P p) {
double d = abs(c.p - p);
if(sign(d - c.r) > 0) return OUT;
if(sign(d - c.r) == 0) return ON;
return IN;
}
double dLP(L l, P p) {
return abs(cross(vec(l), p - l[0])) / abs(vec(l));
}
double dSP(L s, P p) {
if(sign(dot(vec(s), p - s[0])) <= 0) return abs(p - s[0]);
if(sign(dot(-vec(s), p - s[1])) <= 0) return abs(p - s[1]);
return dLP(s, p);
}
int ccw(P a, P b, P c) {
c -= a; b -= a;
if(cross(b, c) > EPS) return 1;
if(cross(b, c) < -EPS) return -1;
if(dot(b, c) < 0) return 2;
if(norm(b) < norm(c)) return -2;
return 0;
}
bool iSP(L s, P p) { return ccw(s[0], s[1], p) == 0; }
P proj(L l, P p) {
double t = dot(p - l[0], vec(l)) / norm(vec(l));
return l[0] + t * vec(l);
}
vector<P> pCL(C c, L l) {
vector<P> res;
P center = proj(l, c.p);
double d = abs(center - c.p);
double tt = c.r * c.r - d * d;
if(sign(tt) == 0) tt = 0;
if(sign(tt) < 0) return res;
double t = sqrt(tt);
P vect = vec(l);
vect /= abs(vect);
res.push_back(center - vect * t);
if(t > EPS) {
res.push_back(center + vect * t);
}
return res;
}
vector<P> pCS(C c, L s) {
vector<P> res;
vector<P> nres = pCL(c, s);
for(int i = 0; i < nres.size(); i++) {
if(iSP(s, nres[i])) res.push_back(nres[i]);
}
return res;
}
bool iCS(const C& c, const L& s) {
int t = pCS(c, s).size();
if(t == 0) return false; // ???????????????
double d = dSP(s, c.p);
if(sign(d - c.r) == 0) return true; // ??\??????
return true; // ?????????
}
vector<double> pCC_th(C a, C b) {
vector<double> res;
double d = abs(b.p - a.p);
double l1 = abs(a.r - b.r);
double l2 = a.r + b.r;
// if(sign(d) == 0 && sign(l1) == 0) assert(false);
if(sign(d - l1) < 0 || sign(d - l2) > 0) return {};
double th1 = arg(b.p - a.p);
if(sign(d - l1) == 0 || sign(d - l2) == 0) {
return {}; // ok ???
} else {
double th2 = acos( (a.r * a.r - b.r * b.r + d * d) / (2.0 * a.r * d) );
res.push_back(th1 - th2);
res.push_back(th1 + th2);
}
return res;
}
int main(){
iostream_init();
int N;
cin >> N;
const P sp = {0, 0};
const P gp = input();
vector<C> cs(N);
REP(i, N) {
cs[i].p = input();
cs[i].r = Rad;
}
vector<P> ps;
vector<int> id;
REP(i, N) REP(j, N) {
auto v = common_tangents(cs[i], cs[j]);
for(double th : v) {
P p = tangent_point(cs[i], th);
ps.push_back(p);
id.push_back(i);
}
}
REP(i, N) {
for(P cp : {sp, gp}) {
auto v = common_tangents(cs[i], {cp, 0.0});
for(double th : v) {
P p = tangent_point(cs[i], th);
ps.push_back(p);
id.push_back(i);
}
}
}
ps.push_back(sp);
ps.push_back(gp);
id.push_back(-1);
id.push_back(-2);
const int ST = ps.size() - 2;
const int GL = ps.size() - 1;
double dist[800][800] = {};
int M = ps.size();
assert(M < 800);
REP(i, M) REP(j, M) dist[i][j] = (i == j ? 0.0 : INF);
REP(i, M) {
bool contained = false;
REP(k, cs.size()) {
if(contains(cs[k], ps[i]) == IN) contained = true;
}
if(contained) continue;
REP(j, M) {
if(sign(abs(ps[i] - ps[j])) == 0) {
dist[i][j] = 0;
continue;
}
if(id[i] == id[j]) {
const C& c = cs[ id[i] ];
double th1 = arg(ps[i] - c.p);
double th2 = arg(ps[j] - c.p);
if(th1 > th2) swap(th1, th2);
vector<double> ngs;
REP(k, cs.size()) if(k != id[i]) {
auto v = pCC_th(c, cs[k]);
for(double th : v) ngs.push_back(th);
}
bool ok1 = true;
for(double th : ngs)
if(comp(th1, th) <= 0 && comp(th, th2) <= 0)
ok1 = false;
bool ok2 = true;
for(double th : ngs)
if(comp(th1, th) >= 0 || comp(th, th2) >= 0)
ok2 = false;
if(ok1) {
dist[i][j] = min(dist[i][j], (th2 - th1) * c.r);
}
if(ok2) {
dist[i][j] = min(dist[i][j], (2.0 * M_PI - (th2 - th1)) * c.r);
}
}
bool straight = true;
REP(k, cs.size()) {
double d = dSP({ps[i], ps[j]}, cs[k].p);
if(comp(d, cs[k].r) < 0) straight = false;
}
if(straight) dist[i][j] = abs(ps[i] - ps[j]);
}
}
REP(k, M) REP(i, M) REP(j, M) dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
if(dist[ST][GL] >= INF) dist[ST][GL] = 0;
cout << dist[ST][GL] << endl;
return 0;
}
/* vim:set foldmethod=marker: */ | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, j = 0, i, a, b, n;
cin >> t;
while (j < t) {
cin >> a >> b >> n;
if (a > n) {
cout << b << endl;
} else {
if (n % a == b)
cout << n << endl;
else {
if (n % a > b) {
i = n - ((n % a) - b);
cout << i << endl;
} else {
i = n % a + 1 + (a - 1) - b;
cout << n - i << endl;
}
}
}
j++;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x2, x1, x3, ort, mn, mx, q, w;
cin >> x1 >> x2 >> x3;
mn = min(min(x1, x2), x3);
mx = max(max(x1, x2), x3);
if ((x1 > x2 && x1 < x3) || (x1 > x3 && x1 < x2))
ort = x1;
else if ((x2 > x1 && x2 < x3) || (x2 > x3 && x2 < x1))
ort = x2;
else
ort = x3;
q = abs(mn - ort);
w = abs(mx - ort);
cout << q + w;
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = 2000;
const int MOD = 998244353;
int pow_mod(int b, int p) {
int ret = 1;
while (p) {
if (p & 1) ret = 1LL * ret * b % MOD;
b = 1LL * b * b % MOD;
p >>= 1;
}
return ret;
}
int fct[MAXN + 5], ifct[MAXN + 5], pw[MAXN + 5];
int comb(int n, int m) {
return 1LL * fct[n] * ifct[m] % MOD * ifct[n - m] % MOD;
}
int f[MAXN + 5][MAXN + 5];
void init(int n) {
fct[0] = 1;
for (int i = 1; i <= n; i++) fct[i] = 1LL * fct[i - 1] * i % MOD;
ifct[n] = pow_mod(fct[n], MOD - 2);
for (int i = n - 1; i >= 0; i--) ifct[i] = 1LL * ifct[i + 1] * (i + 1) % MOD;
f[0][0] = f[1][0] = 1, f[1][1] = 0;
for (int i = 2; i <= n; i++) {
f[i][0] = fct[i], f[i][1] = (fct[i] + MOD - fct[i - 1] % MOD) % MOD;
for (int j = 2; j <= i; j++) {
f[i][j] =
1LL * (j - 1) * ((f[i - 1][j - 1] + f[i - 2][j - 2]) % MOD) % MOD;
f[i][j] = (f[i][j] + 1LL * (i - j) * f[i - 1][j - 1] % MOD) % MOD;
}
}
pw[0] = 1, pw[1] = f[n][n];
for (int i = 2; i <= n; i++) pw[i] = 1LL * pw[i - 1] * pw[1] % MOD;
}
int a[MAXN + 5][MAXN + 5], n;
bool tag[MAXN + 5];
int tree[2][MAXN + 5];
int lowbit(int x) { return x & -x; }
void update(int type, int x, int d) {
for (int i = x; i <= n; i += lowbit(i)) tree[type][i] += d;
}
int sum(int type, int x) {
int ret = 0;
for (int i = x; i; i -= lowbit(i)) ret += tree[type][i];
return ret;
}
int main() {
scanf("%d", &n), init(n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) tree[0][j] = tree[1][j] = tag[j] = 0;
int tmp = n;
for (int j = 1; j <= n; j++) {
int p = (a[i][j] - 1) - sum(0, a[i][j] - 1);
if (i == 1) {
ans = (ans + 1LL * p * f[n - j][0] % MOD * pw[n - i] % MOD) % MOD;
update(0, a[i][j], 1);
} else {
if (a[i - 1][j] < a[i][j] && !tag[a[i - 1][j]]) p--;
if (!tag[a[i - 1][j]])
tag[a[i - 1][j]] = true, update(1, a[i - 1][j], 1), tmp--;
int q = (a[i][j] - 1) - sum(1, a[i][j] - 1);
if (tmp != 0)
ans =
(ans + 1LL * q * f[n - j][tmp - 1] % MOD * pw[n - i] % MOD) % MOD;
ans =
(ans + 1LL * (p - q) * f[n - j][tmp] % MOD * pw[n - i] % MOD) % MOD;
if (!tag[a[i][j]]) tag[a[i][j]] = true, update(1, a[i][j], 1), tmp--;
update(0, a[i][j], 1);
}
}
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[500010];
int c[100];
int main() {
int n, d;
scanf("%d%d", &n, &d);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 500000 - c[i]; j >= 0; j--) {
if (dp[j]) dp[j + c[i]] = 1;
}
}
int mas = 0;
int day = 0;
while (1) {
int x = mas + d;
if (x >= 500000) x = 500000;
while (x > mas && !dp[x]) x--;
if (x == mas) {
printf("%d %d\n", mas, day);
break;
}
mas = x;
day++;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define MAX 100000
#define INF (1LL<<55)
typedef long long ll;
typedef pair<ll, ll> pll;
int main()
{
ll N, M, K, S, P, Q;
cin >> N >> M >> K >> S >> P >> Q;
vector<ll> z(N, INF);
queue<int> q;
for (int i = 0; i < K; i++) {
ll c;
cin >> c; c--;
z[c] = 0;
q.push(c);
}
vector<int> G[MAX];
for (int i = 0; i < M; i++) {
ll a, b;
cin >> a >> b; a--; b--;
G[a].push_back(b);
G[b].push_back(a);
}
while (!q.empty()) {
int v = q.front(); q.pop();
if (z[v] == S) continue;
for (int i = 0; i < (int)G[v].size(); i++) {
int to = G[v][i];
if (z[v] + 1 < z[to]) {
z[to] = z[v] + 1;
q.push(to);
}
}
}
vector<ll> dist(N, INF);
dist[0] = 0;
priority_queue<pll, vector<pll>, greater<pll>> pq;
pq.push(pll(0, 0));
while (!pq.empty()) {
pll p = pq.top(); pq.pop();
ll c = p.first, v = p.second;
if (v == N-1) {
cout << c << endl;
break;
}
for (int i = 0; i < (int)G[v].size(); i++) {
int to = G[v][i];
if (z[to] == 0) continue;
ll ncost = c;
if (to != N-1) ncost += (z[to] == INF ? P : Q);
if (ncost < dist[to]) {
dist[to] = ncost;
pq.push(pll(dist[to], to));
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int FASTBUFFER;
const int mo = 1000000009;
using namespace std;
struct Matrix {
int n;
int a[4][4];
Matrix() {}
Matrix(int n) : n(n) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = 0;
}
friend Matrix operator*(Matrix a, Matrix b) {
int n = a.n;
Matrix ret(n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
(ret.a[i][j] += (long long)a.a[i][k] * b.a[k][j] % mo) %= mo;
return ret;
}
};
const int N = 1200005;
int n, m, ans;
int a[N], Left[N], Right[N], ta[N], tb[N], sum[N];
Matrix mi[N];
void make(int l, int r, int i) {
int mid = ((l + r) >> 1);
Left[i] = l, Right[i] = r;
if (l == r) {
sum[i] = a[l];
return;
}
int lc = (i << 1), rc = (lc | 1);
make(l, mid, lc);
make(mid + 1, r, rc);
sum[i] = (sum[lc] + sum[rc]) % mo;
}
void ins(int i, int aa, int bb) {
int l = Left[i], r = Right[i];
(sum[i] += ((long long)aa * mi[r - l + 1].a[1][3] +
(long long)bb * mi[r - l + 1].a[2][3]) %
mo) %= mo;
(ta[i] += aa) %= mo;
(tb[i] += bb) %= mo;
return;
}
void down(int i) {
if (Left[i] == Right[i]) return;
int lc = (i << 1), rc = (lc | 1);
ins(lc, ta[i], tb[i]);
int x = Left[rc] - Left[lc], aa, bb;
aa = ((long long)ta[i] * mi[x].a[1][1] + (long long)tb[i] * mi[x].a[2][1]) %
mo;
bb = ((long long)ta[i] * mi[x].a[1][2] + (long long)tb[i] * mi[x].a[2][2]) %
mo;
ins(rc, aa, bb);
ta[i] = tb[i] = 0;
return;
}
void ask(int l, int r, int i) {
if (l > Right[i] || r < Left[i]) return;
if (l <= Left[i] && r >= Right[i]) {
(ans += sum[i]) %= mo;
return;
}
down(i);
ask(l, r, (i << 1));
ask(l, r, ((i << 1) | 1));
}
void add(int l, int r, int i, int a, int b) {
if (l > Right[i] || r < Left[i]) return;
if (l <= Left[i] && r >= Right[i]) {
int x = Left[i] - l, aa, bb;
if (l == Left[i])
aa = a, bb = b;
else {
aa = ((long long)a * mi[x].a[1][1] + (long long)b * mi[x].a[2][1]) % mo;
bb = ((long long)a * mi[x].a[1][2] + (long long)b * mi[x].a[2][2]) % mo;
}
ins(i, aa, bb);
return;
}
down(i);
int lc = (i << 1), rc = (lc | 1);
add(l, r, lc, a, b);
add(l, r, rc, a, b);
sum[i] = (sum[lc] + sum[rc]) % mo;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
make(1, n, 1);
mi[0].n = 3;
for (int i = 1; i <= 3; i++) mi[0].a[i][i] = 1;
mi[1].n = 3;
mi[1].a[2][1] = mi[1].a[1][2] = mi[1].a[1][3] = mi[1].a[2][2] =
mi[1].a[3][3] = 1;
for (int i = 2; i <= n + 1; i++) mi[i] = mi[i - 1] * mi[1];
for (int i = 1; i <= m; i++) {
int type, l, r;
scanf("%d %d %d", &type, &l, &r);
if (type == 1)
add(l, r, 1, 1, 1);
else
ans = 0, ask(l, r, 1), printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long all = 0;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
ans = max(ans, x);
all += x;
}
n = n - 1;
long long round = 0;
while (true) {
if (all > 0) {
round++;
all -= n;
} else
break;
}
cout << max(round, ans) << '\n';
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300010;
int n, m, fa[105];
int g[105][105], deg[105];
queue<int> q;
int fnd(int x) { return fa[x] == x ? x : fa[x] = fnd(fa[x]); }
int main() {
scanf("%d%d", &n, &m);
if (m != n) {
printf("NO");
return 0;
}
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u][v] = g[v][u] = 1;
deg[u]++;
deg[v]++;
fa[fnd(u)] = fnd(v);
}
for (int i = 2; i <= n; i++)
if (fnd(i) != fnd(1)) {
printf("NO");
return 0;
}
for (int i = 1; i <= n; i++)
if (deg[i] == 1) q.push(i);
while (q.size()) {
int x = q.front();
q.pop();
for (int y = 1; y <= n; y++)
if (g[x][y]) {
if (--deg[y] == 1) q.push(y);
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (deg[i] > 1) cnt++;
if (cnt < 3)
printf("NO");
else
printf("FHTAGN!");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
const long long MOD = (int)1e9 + 7;
const long long INF = 2e18 + 5;
struct hashLL {
size_t operator()(long long x) const {
x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
x = x ^ (x >> 31);
return x;
}
};
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long distsq(long long x1, long long y1, long long x2, long long y2) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
const int N = 200001;
long long n, m, k, t, u, v;
string s;
unordered_set<int> ks;
unordered_map<int, vector<int>> g;
int visited[N];
long long tosink[N];
long long tosource[N];
void bfs(int start, long long arr[]) {
for (int i = 0; i < n + 1; i++) arr[i] = -1;
deque<int> q;
q.push_back(start);
arr[start] = 0;
while (!q.empty()) {
int n = q.size();
for (int i = 0; i < (n); i++) {
int curr = q.front();
q.pop_front();
for (int c : g[curr]) {
if (arr[c] == -1) {
arr[c] = arr[curr] + 1;
q.push_back(c);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < (k); i++) {
cin >> u;
ks.emplace(u);
}
for (int i = 0; i < (m); i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
bfs(1, tosource);
bfs(n, tosink);
vector<pair<int, int>> tok;
map<int, unordered_set<int>> towardssink;
for (auto& p : ks) {
tok.push_back(make_pair(tosource[p], p));
towardssink[-tosink[p]].emplace(p);
}
sort((tok).begin(), (tok).end());
long long best = 0;
for (auto& p : tok) {
long long mintosource = p.first;
long long node = p.second;
towardssink[-tosink[node]].erase(node);
if (towardssink[-tosink[node]].empty()) {
towardssink.erase(-tosink[node]);
}
if (towardssink.empty()) break;
auto& pr = *towardssink.begin();
long long mxtosink = -pr.first;
long long curr = 1;
curr = curr + mintosource + min(tosink[node], mxtosink);
best = max(best, curr);
}
long long normaldist = tosink[1];
if (best < normaldist) {
cout << best << endl;
} else {
cout << normaldist << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1 &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1 &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
int hsb_loc(int n) { return 31 - __builtin_clz(n); }
int hsb_loc(long long n) { return 63 - __builtin_clzll(n); }
template <class T>
struct IRMQ {
int n;
T *d;
IRMQ() : n(0), d(NULL) {}
template <class Iter>
IRMQ(Iter begin, Iter end) : n(0), d(0) {
build(begin, end);
}
IRMQ(const IRMQ &y) : n(y.n), d(NULL) {
if (y.n) build(y.d[0], y.d[0] + n);
}
IRMQ(IRMQ &&y) : n(0), d(NULL) { swap(*this, y); }
~IRMQ() {
if (n) {
n = 0;
delete d;
d = NULL;
}
}
friend void swap(IRMQ &x, IRMQ &y) {
swap(x.n, y.n);
swap(x.d, y.d);
}
IRMQ &operator=(IRMQ y) {
swap(*this, y);
return *this;
}
template <class Iter>
void build(Iter begin, Iter end) {
n = end - begin;
if (n == 0) return;
int g = hsb_loc(n);
d = new T[n * (g + 1)];
for (int i = 0; i < (n); ++i) {
d[i] = *begin;
++begin;
}
for (int t = 0, b = 0; t < g; t++, b += n)
for (int i = 0, j = 1 << t; j <= n - (1 << t); i++, j++)
d[b + n + i] = (d[b + j] < d[b + i] ? d[b + j] : d[b + i]);
}
const T at(int i) const { return d[i]; }
const T min_v(int l, int r) const {
int g = hsb_loc(r - l), b = n * g;
r -= 1 << g;
return d[b + r] < d[b + l] ? d[b + r] : d[b + l];
}
int min_i(int l, int r) const { return next_less_equal(l, min_v(l, r)); }
int next_less_than(int l, const T v) const {
for (int t = hsb_loc(n) + 1; t--;)
if (l + (1 << t) <= n && !(d[n * t + l] < v)) l += 1 << t;
return l;
}
int next_less_equal(int l, const T v) const {
for (int t = hsb_loc(n) + 1; t--;)
if (l + (1 << t) <= n && v < d[n * t + l]) l += 1 << t;
return l;
}
int last_more_than(int r, const T v) const {
for (int t = hsb_loc(n) + 1; t--;)
if (0 <= r - (1 << t) && v < d[n * t + r - (1 << t)]) r -= 1 << t;
return r;
}
int last_more_equal(int r, const T v) const {
for (int t = hsb_loc(n) + 1; t--;)
if (0 <= r - (1 << t) && !(d[n * t + r - (1 << t)] < v)) r -= 1 << t;
return r;
}
};
class SAIS {
public:
vector<int> sa, lcp, rank;
SAIS() {}
SAIS(const string &str_) : str(str_) {
N = str.size() + 1;
S = vector<int>(N, 0);
for (int i = 0; i < N; i++) S[i] = str[i];
*this = SAIS(S, 256);
}
SAIS(const vector<int> &S_, int A_SIZE_, bool lcp_flag = true)
: S(S_), A_SIZE(A_SIZE_) {
buildSA();
if (lcp_flag) buildLCP();
}
private:
string str;
vector<int> S;
int A_SIZE;
int N;
vector<int> t, B;
enum { STYPE, LTYPE };
inline bool is_lms(int i) {
return i > 0 && t[i] == STYPE && t[i - 1] == LTYPE;
}
void bucket() {
B = vector<int>(A_SIZE);
for (int i = 0; i < N; i++) B[S[i]]++;
for (int i = 0; i < A_SIZE - 1; i++) B[i + 1] += B[i];
}
void induced_sort() {
bucket();
for (int i = 0; i < N; i++) {
int j = sa[i] - 1;
if (j >= 0 && S[j] >= S[j + 1]) sa[B[S[j] - 1]++] = j;
}
bucket();
for (int i = N; i--;) {
int j = sa[i] - 1;
if (j >= 0 && S[j] <= S[j + 1]) sa[--B[S[j]]] = j;
}
}
void buildSA() {
N = S.size();
sa.assign(N, -1);
if (N == 1) {
sa[0] = 0;
return;
}
t.assign(N, STYPE);
for (int i = N - 1; i--;)
if (S[i] > S[i + 1] || (S[i] == S[i + 1] && t[i + 1] == LTYPE))
t[i] = LTYPE;
bucket();
for (int i = N; i--;)
if (is_lms(i)) sa[--B[S[i]]] = i;
induced_sort();
int N1 = 0;
for (int i = 0; i < N; i++)
if (is_lms(sa[i])) sa[N1++] = sa[i];
fill(sa.begin() + N1, sa.end(), -1);
int name = 0, prev = -1;
for (int i = 0; i < N1; i++) {
int cur = sa[i];
bool diff = (prev == -1) || S[cur] != S[prev];
for (int j = 1; !diff; j++) {
if (is_lms(cur + j) && is_lms(prev + j)) break;
if (is_lms(cur + j) || is_lms(prev + j)) diff = true;
if (S[cur + j] != S[prev + j]) diff = true;
}
if (diff) name++;
sa[N1 + cur / 2] = name - 1;
prev = cur;
}
vector<int> S1, sa1(N1);
for (int i = N1; i < N; i++)
if (sa[i] >= 0) S1.push_back(sa[i]);
if (name == N1)
for (int i = 0; i < N1; i++) sa1[S1[i]] = i;
else
sa1 = SAIS(S1, name, false).sa;
N1 = 0;
for (int i = 0; i < N; i++)
if (is_lms(i)) S1[N1++] = i;
for (int i = 0; i < N1; i++) sa1[i] = S1[sa1[i]];
fill(sa.begin(), sa.end(), -1);
bucket();
for (int i = N1; i--;) {
int j = sa1[i];
sa[--B[S[j]]] = j;
}
induced_sort();
}
void buildLCP() {
rank.resize(N);
lcp.resize(N - 1);
for (int i = 0; i < N; i++) rank[sa[i]] = i;
int h = 0;
for (int i = 0; i < N - 1; i++) {
int j = sa[rank[i] - 1];
if (h > 0) h--;
for (; j + h < N && i + h < N && S[j + h] == S[i + h]; h++)
;
lcp[rank[i] - 1] = h;
}
}
public:
IRMQ<int> rmq;
void buildRMQ() { rmq = IRMQ<int>(lcp.begin(), lcp.end()); }
int common_prefix(int x, int y) {
if (x == y) return N - 1 - x;
if (y >= N - 1) return 0;
if (rank[x] > rank[y]) swap(x, y);
return rmq.min_v(rank[x], rank[y]);
}
int compare(int x, int xn, int y, int yn) {
int l = common_prefix(x, y);
if (l >= xn || l >= yn) return xn < yn ? -1 : xn == yn ? 0 : 1;
return rank[x] < rank[y] ? -1 : x == y ? 0 : 1;
}
};
int N;
int M;
string S, T;
int X;
int dp[100111][31];
void solve() {
cin >> N >> S >> M >> T >> X;
S += '$';
N++;
SAIS sais(S + T);
sais.buildRMQ();
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < (N); ++i)
for (int k = 0; k < (X); ++k)
if (dp[i][k] >= 0) {
int p = dp[i][k];
Max(dp[i + 1][k], p);
int len = min(N - i, M - p);
if (len <= 0) continue;
int d = sais.common_prefix(i, N + p);
Max(dp[i + d][k + 1], p + d);
}
bool yes = false;
for (int i = 0; i < (N + 1); ++i)
for (int k = 0; k < (X + 1); ++k)
if (dp[i][k] == M) yes = true;
cout << (yes ? "YES" : "NO") << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
const int N = 5e5 + 50;
vector<int> g[N];
char s[N];
int n, q;
bool ans[N];
vector<pair<int, int> > v[N];
int son[N];
int sz[N];
int dep[N];
void dfs_son(int now, int fa) {
sz[now] = 1;
for (int i = 0; i < g[now].size(); i++) {
int to = g[now][i];
if (to == fa) continue;
dep[to] = dep[now] + 1;
dfs_son(to, now);
sz[now] += sz[to];
if (sz[son[now]] < sz[to]) son[now] = to;
}
}
int madoka[N];
inline bool check(int d) {
int cnt = 0;
for (int i = 0; i <= 29; i++) {
if ((madoka[d] >> i) & 1) cnt++;
}
return cnt <= 1;
}
void magic(int now, int fa, int op, int pson) {
madoka[dep[now]] ^= (1 << (s[now]));
for (int i = 0; i < g[now].size(); i++) {
int to = g[now][i];
if (to == pson || to == fa) continue;
magic(to, now, op, pson);
}
}
void dfs(int now, int fa, int op) {
for (int i = 0; i < g[now].size(); i++) {
int to = g[now][i];
if (to == fa || to == son[now]) continue;
dfs(to, now, 0);
}
if (son[now]) dfs(son[now], now, 1);
magic(now, fa, 1, son[now]);
for (int i = 0; i < v[now].size(); i++) {
int d = v[now][i].first;
int id = v[now][i].second;
if (check(d))
ans[id] = 1;
else
ans[id] = 0;
}
if (!op) {
magic(now, fa, -1, 0);
}
}
int main() {
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int x, y;
x = i;
scanf("%d", &y);
g[x].push_back(y);
g[y].push_back(x);
}
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
for (int i = 1; i <= q; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back({b, i});
}
dep[1] = 1;
dfs_son(1, 1);
dfs(1, 1, 1);
for (int i = 1; i <= q; i++)
if (ans[i])
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct str_hash {
vector<int> h1, h2, b1, b2;
const static int BASE = 37, M1 = 1e9 + 7, M2 = 1e9 + 9;
str_hash() {}
str_hash(const string& s)
: h1(s.size() + 1),
h2(s.size() + 1),
b1(s.size() + 1, 1),
b2(s.size() + 1, 1) {
for (int i = 0; i < s.size(); ++i) {
h1[i + 1] = (1LL * h1[i] * BASE + s[i] - 'a' + 1) % M1;
h2[i + 1] = (1LL * h2[i] * BASE + s[i] - 'a' + 1) % M2;
b1[i + 1] = (1LL * b1[i] * BASE) % M1;
b2[i + 1] = (1LL * b2[i] * BASE) % M2;
}
}
long long hash(int i, int j) {
long long r1 = (h1[j + 1] - 1LL * h1[i] * b1[j - i + 1]) % M1;
long long r2 = (h2[j + 1] - 1LL * h2[i] * b2[j - i + 1]) % M2;
return ((r1 < 0) ? r1 + M1 : r1) ^ ((r2 < 0) ? r2 + M2 : r2) << 32;
}
};
const int N = 1e5 + 5;
int dp[N][33];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, x;
string s, t;
cin >> n >> s >> m >> t >> x;
str_hash S(s), T(t);
for (int i = 0; i <= n; ++i) {
for (int r = 0; r <= x; ++r) {
if (dp[i][r] == m) {
cout << "YES\n";
return 0;
}
dp[i + 1][r] = max(dp[i + 1][r], dp[i][r]);
int lo = 0, hi = min(t.size() - dp[i][r], s.size() - i);
int j = dp[i][r];
if (j == m || i == n || s[i] != t[j]) continue;
while (hi - lo > 1) {
int md = (lo + hi) / 2;
if (S.hash(i, i + md) == T.hash(j, j + md))
lo = md;
else
hi = md;
}
dp[i + hi][r + 1] = max(dp[i + hi][r + 1], j + hi);
}
}
cout << "NO\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct P {int x,y,z;};
int main() {
int a,d,n,m,k;
cin >> n >> a >> d >> m;
P p[m];
for(int i=0; i<m; i++) cin >> p[i].x >> p[i].y >> p[i].z;
cin >> k;
for(int i=m-1; i>=0; i--) {
if(!p[i].x&&p[i].y<=k&&k<=p[i].z) k=p[i].z+p[i].y-k;
}
int ans=a+d*(k-1);
for(int i=0; i<m; i++) {
if(k<p[i].y||p[i].z<k) continue;
if(!p[i].x) k=p[i].z+p[i].y-k;
else if(p[i].x==1) ans++;
else ans/=2;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
long long int arr[m];
for (long long int i = 0; i < m; i++) cin >> arr[i];
long long int sum_len = 0;
for (long long int i = 0; i < m; i++) {
sum_len += arr[i];
}
long long int check = 0;
if (sum_len < n) check = 1;
for (long long int i = 0; i < m; i++) {
if (arr[i] + i > n) {
check = 1;
break;
}
}
if (check == 1)
cout << "-1";
else if (check == 0) {
long long int suf_sum[m];
suf_sum[m - 1] = arr[m - 1];
for (long long int i = m - 2; i >= 0; i--) {
suf_sum[i] = suf_sum[i + 1] + arr[i];
}
long long int pos[m];
for (long long int i = 0; i < m; i++) {
pos[i] = max(i + 1, n - suf_sum[i] + 1);
}
for (long long int i = 0; i < m; i++) cout << pos[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<double> v(N), w(N);
for (int i=0; i<N; ++i) {
cin >> v[i];
w[i] = v[i];
}
sort(w.begin(), w.end());
int p, q;
for (int i=0; i<N; ++i) {
p = lower_bound(w.begin(), w.end(), v[i]) - w.begin();
q = upper_bound(w.begin(), w.end(), v[i]) - w.begin();
cout << p*3+(q-p-1) << endl;
}
return 0;
}
| 0 |
#include <string>
#include <set>
#include <iostream>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int cnt[2][30];
for (int i = 0; i < 30; i++)cnt[0][i] = cnt[1][i] = 0;
for (auto e : s) cnt[0][e - 'a']++;
for (auto e : t) cnt[1][e - 'a']++;
multiset<int> c[2];
for (int i = 0; i < 2; i++)for (auto e : cnt[i])c[i].insert(e);
if (c[0] == c[1]) cout << "Yes" << endl;
else cout << "No" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 3e5 + 5;
int N, A[MAXN];
struct E {
int i, j, x;
};
void solve() {
cin >> N;
vector<E> v;
int sum = 0;
for (int i = 1; i <= N; i++) cin >> A[i], sum += A[i];
if (sum % N) {
cout << -1 << '\n';
return;
}
for (int i = 2; i <= N; i++) {
v.push_back({1, i, (i - A[i] % i) % i});
int t = (i - A[i] % i) % i;
A[i] += t;
A[1] -= t;
v.push_back({i, 1, A[i] / i});
A[1] += A[i];
A[i] = 0;
}
for (int i = 2; i <= N; i++) {
v.push_back({1, i, sum / N});
}
cout << v.size() << '\n';
for (auto i : v) cout << i.i << ' ' << i.j << ' ' << i.x << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) solve();
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.