solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
class SuffixArrayBuilder {
int n, gap;
string s;
vector<int> pos;
public:
SuffixArrayBuilder(string &s) : s(s) {}
bool operator()(int i, int j) {
if (pos[i] != pos[j]) return pos[i] < pos[j];
i += gap;
j += gap;
return ((i < n && j < n) ? pos[i] < pos[j] : i > j);
}
vector<int> buildSA() {
n = (int)(s).size();
vector<int> sa(n), tmp(n);
pos.resize(n);
for (int i = (0); i <= ((int)(sa).size() - 1); ++i)
sa[i] = i, pos[i] = s[i];
for (gap = 1;; gap *= 2) {
sort(sa.begin(), sa.end(), ref(*this));
for (int i = (0); i <= (n - 2); ++i)
tmp[i + 1] = tmp[i] + (*this)(sa[i], sa[i + 1]);
for (int i = (0); i <= (n - 1); ++i) pos[sa[i]] = tmp[i];
if (tmp.back() == n - 1) return sa;
}
}
vector<int> buildLCP(vector<int> &sa) {
vector<int> lcp(n - 1);
for (int i = 0, k = 0; i < n; ++i)
if (pos[i] != n - 1) {
for (int j = sa[pos[i] + 1]; s[i + k] == s[j + k];) k++;
lcp[pos[i]] = k;
if (k) k--;
}
return lcp;
}
};
vector<long long int> solve(string &p, string &q, string &r) {
string s = p + '#' + q + '$' + r;
SuffixArrayBuilder Builder(s);
vector<int> SA = Builder.buildSA();
vector<int> LCP = Builder.buildLCP(SA);
int n = (int)(s).size();
int cnt[3][n];
int len[] = {0, (int)(p).size() + 1, (int)(q).size() + 1,
(int)(r).size() + 1};
for (int i = (1); i <= (3); ++i) len[i] += len[i - 1];
for (int i = (0); i <= (2); ++i)
for (int j = (0); j <= (n - 1); ++j) {
cnt[i][j] = ((j) ? cnt[i][j - 1] : 0);
cnt[i][j] += (SA[j] >= len[i] && SA[j] < len[i + 1] - 1);
}
vector<pair<int, int> > ord;
for (int i = (0); i <= ((int)(LCP).size() - 1); ++i)
ord.push_back(make_pair(LCP[i], i));
sort(ord.begin(), ord.end());
set<int> S;
S.insert(-1);
S.insert(n - 1);
int m = min({(int)(p).size(), (int)(q).size(), (int)(r).size()});
vector<long long int> agg(m, 0);
for (int i = (0); i <= ((int)(ord).size() - 1); ++i) {
int pos = ord[i].second, L, R;
auto it = S.lower_bound(pos);
R = *it;
it--;
L = *it;
long long int left[3], right[3], whole[3];
for (int i = (0); i <= (2); ++i) {
left[i] = cnt[i][pos] - ((L >= 0) ? cnt[i][L] : 0);
right[i] = cnt[i][R] - cnt[i][pos];
whole[i] = cnt[i][R] - ((L >= 0) ? cnt[i][L] : 0);
}
long long int ans = whole[0] * whole[1] * whole[2] -
left[0] * left[1] * left[2] -
right[0] * right[1] * right[2];
ans %= 1000000007;
ans = (ans + 1000000007) % 1000000007;
int val = ord[i].first;
if (val > 0) {
agg[val - 1] += ans;
agg[val - 1] %= 1000000007;
}
S.insert(pos);
}
for (int i = (m - 2); i >= (0); --i)
agg[i] = (agg[i] + agg[i + 1]) % 1000000007;
return agg;
}
int main() {
ios_base::sync_with_stdio(0);
string p, q, r;
cin >> p >> q >> r;
vector<long long int> ans = solve(p, q, r);
for (int i = (0); i <= ((int)(ans).size() - 1); ++i) cout << ans[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int c1 = 0, c0 = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1')
c1++;
else
c0++;
}
int mi;
mi = min(c1, c0);
if (mi % 2 == 0)
cout << "NET" << endl;
else
cout << "DA" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
template <typename T>
bool ckmax(T& a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
bool ckmin(T& a, T b) {
return b < a ? a = b, 1 : 0;
}
const int MN = 80;
int N, RK, T, dp[MN][MN], ans;
bool u[MN], pr[MN][MN];
struct minion {
public:
int a, b, id;
void in() { scanf("%d%d", &a, &b); }
bool operator<(minion o) const { return b < o.b; }
} a[MN];
std::vector<int> seq;
int main(void) {
scanf("%d", &T);
for (; T--;) {
scanf("%d%d", &N, &RK);
for (int i = 0; i < N; ++i) a[i].in(), a[i].id = i + 1;
std::sort(a, a + N);
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < N; ++i)
for (int j = 0; j <= RK; ++j)
if (~dp[i][j]) {
if (ckmax(dp[i + 1][j], dp[i][j] + (RK - 1) * a[i].b))
pr[i + 1][j] = 0;
if (j + 1 <= RK &&
ckmax(dp[i + 1][j + 1], dp[i][j] + a[i].a + j * a[i].b))
pr[i + 1][j + 1] = 1;
}
{
seq.clear();
ans = dp[N][RK];
memset(u, 0, N * sizeof u[0]);
int k = RK;
for (int i = N; i > 0; --i) {
if (pr[i][k]) u[i - 1] = 1, seq.push_back(a[i - 1].id), --k;
}
assert(!k);
std::reverse(seq.begin(), seq.end());
int v = seq.back();
seq.pop_back();
for (int i = 0; i < N; ++i)
if (!u[i]) seq.push_back(a[i].id), seq.push_back(-a[i].id);
seq.push_back(v);
}
for (int K = 1; K < RK; ++K) {
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < N; ++i)
for (int j = 0; j <= K; ++j)
if (~dp[i][j]) {
if (ckmax(dp[i + 1][j], dp[i][j] + K * a[i].b)) pr[i + 1][j] = 0;
if (j + 1 <= K &&
ckmax(dp[i + 1][j + 1], dp[i][j] + a[i].a + j * a[i].b))
pr[i + 1][j] = 1;
}
if (dp[N][K] <= ans) continue;
seq.clear();
ans = dp[N][K];
memset(u, 0, N * sizeof u[0]);
int k = K;
for (int i = N; i >= 0; --i) {
if (pr[i][k]) u[i - 1] = 1, seq.push_back(a[i - 1].id), --k;
}
assert(!k);
std::reverse(seq.begin(), seq.end());
for (int i = 0; i < N; ++i)
if (!u[i]) seq.push_back(a[i].id), seq.push_back(-a[i].id);
}
printf("%d\n", seq.size());
for (int i = 0; i < seq.size(); ++i)
printf("%d%c", seq[i], " \n"[i + 1 == seq.size()]);
}
return 0;
}
| 6 |
#include <iostream>
#include <queue>
using namespace std;
int k,dist[100010];
bool used[100010];
deque<int> q;
inline void add_front(int x,int d)
{
if(d<dist[x])
{
dist[x]=d;
q.push_front(x);
}
}
inline void add_back(int x,int d)
{
if(d<dist[x])
{
dist[x]=d;
q.push_back(x);
}
}
int main()
{
cin>>k;
fill(dist,dist+100000,(1e9+7));
add_front(1,0);
while(!q.empty())
{
int x=q[0];q.pop_front();
if(used[x]) continue;
used[x]=1;
int d=dist[x],cx=x*10%k;
add_front(cx,d);
cx=(x+1)%k;
add_back(cx,d+1);
}
cout<<dist[0]+1;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
double k, a, b;
cin >> k >> a >> b;
cin >> s;
int n = s.size();
if (n / k < a || n / k > b) {
cout << "No solution";
return 0;
}
int p = n / k;
int d = n % p;
if (p == 1) d = n - k;
int i = 0;
int cou = 0;
int c = 0;
while (1) {
cout << s[i];
i++;
cou++;
if (c < d && cou == p) {
cou = 0;
c++;
cout << s[i];
i++;
cout << endl;
continue;
}
if (cou == p) {
cou = 0;
cout << endl;
}
if (i == n) break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 10;
int vis[2010];
int a[N];
int main() {
int n, m, q, k;
cin >> q;
while (q--) {
cin >> n;
if (n & 1 || n == 2) {
if (n == 1)
cout << "FastestFinger" << '\n';
else
cout << "Ashishgup" << '\n';
continue;
}
vector<int> v;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i & 1) v.push_back(i);
if (n / i != i && (n / i) % 2 == 1) v.push_back(n / i);
}
}
if (v.size() == 0)
cout << "FastestFinger";
else {
int f = 0;
for (auto x : v) {
if (n / x != 2) {
f = 1;
break;
}
}
if (f)
cout << "Ashishgup";
else
cout << "FastestFinger";
}
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int inf = 1e9;
int d[maxn], fa[maxn];
int n, k;
char s[maxn];
vector<int> vec[maxn];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
void merge(int x, int y) {
int fx = get(x), fy = get(y);
if (fx != fy) {
fa[fx] = fy;
d[fy] += d[fx];
}
}
int val(int x) { return min(d[get(x)], d[get(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; i++) {
int t, x;
scanf("%d", &t);
while (t--) scanf("%d", &x), vec[x].push_back(i);
}
for (int i = 1; i <= 2 * k; i++) fa[i] = i, d[i] = i > k;
fa[2 * k + 1] = 2 * k + 1;
d[2 * k + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
ans -= val(x);
merge(x + (s[i] == '1' ? k : 0), 2 * k + 1);
ans += val(x);
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
if (s[i] == '1' && get(x) != get(y)) {
ans -= val(x) + val(y);
merge(x, y), merge(x + k, y + k);
ans += val(x);
} else if (s[i] == '0' && get(x) != get(y + k)) {
ans -= val(x) + val(y);
merge(x, y + k), merge(x + k, y);
ans += val(x);
}
}
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int vet[100111], k, cor[100111];
vector<int> tile[1001];
int main() {
int t, n, a, b, c, d;
scanf("%d", &t);
for (int i = 0; i < t; ++i) {
scanf("%d %d", &n, &k);
for (int j = 0; j < n; ++j) {
scanf("%d %d %d %d", &a, &b, &c, &d);
tile[j].clear();
tile[j].push_back(a);
tile[j].push_back(b);
tile[j].push_back(c);
tile[j].push_back(d);
}
bool has1 = false;
for (int j = 0; j < n; ++j) {
if (tile[j][1] == tile[j][2]) {
has1 = true;
break;
}
}
if (has1 and k % 2 == 0) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Pos {
int row, col;
bool operator<(const Pos& p) const {
if (row != p.row) return row < p.row;
return col < p.col;
}
};
int R, C, K;
vector<Pos> P;
int dr[] = {-1, 0, 0, 1};
int dc[] = {0, -1, 1, 0};
vector<int> row_IDs[10004];
vector<int> col_IDs[10004];
map<Pos, int> lit_map;
struct State {
int id;
int dist;
bool operator<(const State& s) const {
if (dist != s.dist) return dist > s.dist;
return id < s.id;
}
};
const int INF = 1000000000;
int bfs(int src, int dst) {
vector<int> D(int((P).size()), INF);
D[src] = 0;
priority_queue<State> pq;
pq.push({src, 0});
bool dstIsLit = lit_map.count(P[dst]);
while (!pq.empty()) {
State cur = pq.top();
pq.pop();
int dist = D[cur.id];
if (cur.id == dst) return dist;
if (dist < cur.dist) continue;
for (int j = 0, _n = (4); j < _n; ++j) {
int nr = P[cur.id].row + dr[j], nc = P[cur.id].col + dc[j];
if (nr < 1 || nr > R || nc < 1 || nc > C) continue;
if (lit_map.count({nr, nc}) == 0) continue;
State nxt = {lit_map[{nr, nc}], dist};
if (D[nxt.id] > nxt.dist) {
D[nxt.id] = nxt.dist;
pq.push(nxt);
}
}
for (int r = (max(P[cur.id].row - 2, 1)), _b = (min(P[cur.id].row + 2, R));
r <= _b; ++r) {
for (int k : row_IDs[r]) {
State nxt = {k, dist + 1};
if (k == dst && !dstIsLit && abs(r - P[cur.id].row) >= 2) continue;
if (D[nxt.id] > nxt.dist) {
D[nxt.id] = nxt.dist;
pq.push(nxt);
}
}
}
for (int c = (max(P[cur.id].col - 2, 1)), _b = (min(P[cur.id].col + 2, C));
c <= _b; ++c) {
for (int k : col_IDs[c]) {
State nxt = {k, dist + 1};
if (k == dst && !dstIsLit && abs(c - P[cur.id].col) >= 2) continue;
if (D[nxt.id] > nxt.dist) {
D[nxt.id] = nxt.dist;
pq.push(nxt);
}
}
}
}
return -1;
}
int solve() {
sort(P.begin(), P.end());
for (int k = 0, _n = (int((P).size())); k < _n; ++k) lit_map[P[k]] = k;
if (P.back().row != R || P.back().col != C) P.push_back({R, C});
for (int k = 0, _n = (int((P).size())); k < _n; ++k) {
row_IDs[P[k].row].push_back(k);
col_IDs[P[k].col].push_back(k);
}
return bfs(0, int((P).size()) - 1);
}
int main(int argc, char* argv[]) {
scanf("%d %d %d", &R, &C, &K);
for (int k = 0, _n = (K); k < _n; ++k) {
int row, col;
scanf("%d %d", &row, &col);
P.push_back({row, col});
}
int res = solve();
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int power(unsigned long long int x, long int y) {
unsigned long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int main() {
long int n;
cin >> n;
long long int arr[n];
map<long long int, long int> m;
vector<long int> a;
for (int i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]]++;
}
auto itr = m.begin();
for (; itr != m.end(); itr++) {
a.push_back(itr->second);
}
sort(a.begin(), a.end());
unsigned long long int ans = a[a.size() - 1];
long long res = 1;
long long last = ans;
for (long int i = a.size() - 2; i >= 0; i--) {
long long int x = last / 2;
unsigned long long int z;
z = power(2, a.size() - i) - 1;
if (a[i] >= x) {
z *= x;
last = x;
} else {
z *= a[i];
last = a[i];
}
ans = max(ans, z);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m;
char ch[20][120];
int l[20], r[20], visit[20], dp[20][2];
int main() {
scanf("%d%d", &n, &m);
memset(visit, 0, sizeof visit);
memset(r, 0, sizeof r);
memset(l, 0, sizeof l);
for (int i = n; i >= 1; i--) {
scanf("%s", ch[i] + 1);
for (int j = 2; j <= m + 1; j++)
if (ch[i][j] == '1') {
l[i] = j;
visit[i] = 1;
break;
}
for (int j = m + 1; j >= 2; j--)
if (ch[i][j] == '1') {
r[i] = j;
break;
}
}
int x = n;
while (!visit[x--] && x >= 1) n--;
if (n == 1) {
printf("%d\n", r[1] ? r[1] - 1 : 0);
return 0;
}
memset(dp, INF, sizeof dp);
dp[1][0] = r[1] ? (r[1] - 1) * 2 : 0, dp[1][1] = m + 1;
for (int i = 2; i < n; i++) {
if (!visit[i]) {
dp[i][0] = dp[i - 1][0] + 1;
dp[i][1] = dp[i - 1][1] + 1;
continue;
}
dp[i][0] = min(dp[i - 1][0] + 2 * (r[i] - 1) + 1, dp[i][0]);
dp[i][0] = min(dp[i - 1][1] + m + 1 + 1, dp[i][0]);
dp[i][1] = min(dp[i - 1][1] + 2 * (m + 2 - l[i]) + 1, dp[i][1]);
dp[i][1] = min(dp[i - 1][0] + m + 1 + 1, dp[i][1]);
}
int ans = min(dp[n - 1][0] + r[n], dp[n - 1][1] + 1 + m + 2 - l[n]);
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
const int MOD = mod - 1;
const int inf = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-10;
using namespace std;
pair<int, int> a[10005];
set<pair<int, int> > s;
void dfs(int l, int r) {
int mid = (l + r) >> 1;
int x = a[mid].first;
for (int i = l; i <= r; i++) {
s.insert(pair<int, int>(x, a[i].second));
}
if (l < mid) {
dfs(l, mid - 1);
}
if (r > mid) {
dfs(mid + 1, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first), scanf("%d", &a[i].second);
}
sort(a, a + n);
for (int i = 0; i < n; i++) s.insert(a[i]);
dfs(0, n - 1);
printf("%d\n", s.size());
for (auto &it : s) {
printf("%d %d\n", it.first, it.second);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
int i = 0;
int cnt = 0;
int cnt1 = 0;
int cnt3 = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'R') {
cnt++;
} else if (s[i] == 'U') {
cnt1++;
}
if ((s[i] == s[i + 1]) && cnt == cnt1) {
cnt3++;
}
}
cout << cnt3 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T __in() {
T v;
cin >> v;
return v;
}
vector<pair<int, int> > edge[1010];
int l, r;
int vis[1010], kas;
void dfs(int u) {
if (vis[u] == kas) return;
vis[u] = kas;
for (__typeof(((int)edge[u].size())) i = 0; i < (((int)edge[u].size()));
i++) {
if (edge[u][i].second < l || edge[u][i].second > r)
if (vis[edge[u][i].first] != kas) dfs(edge[u][i].first);
}
}
int main() {
int n = __in<int>(), m = __in<int>();
for (__typeof(m) i = 0; i < (m); i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(make_pair(v, i + 1));
edge[v].push_back(make_pair(u, i + 1));
}
int k = __in<int>();
while (k--) {
scanf("%d%d", &l, &r);
++kas;
int cnt = 0;
for (int i = 1; i <= n; i++)
if (vis[i] != kas) {
cnt++;
dfs(i);
}
printf("%d\n", cnt);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
priority_queue<long long int> pq;
long long int ans = 0;
for (int i = 0; i < n; i++) {
pq.push(a[i]);
if (pq.top() > a[i]) {
ans = ans + pq.top() - a[i];
pq.pop();
pq.push(a[i]);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int n, m, u;
unordered_set<int> adj[N];
bool isConnected(int i, int j) { return adj[i].count(j) || adj[j].count(i); }
void connect(int i, int j) {
if (!i || !j || isConnected(i, j)) return;
adj[i].insert(j);
--m;
}
bool solve() {
if (m < n - 1) return 0;
int lone = (u == 1) + 1;
connect(u, lone);
for (int i = 2; i <= n; ++i) {
if (i == lone || i - 1 == lone) continue;
connect(i, i - 1);
}
if (m < 0) return 0;
for (int i = 1; i <= n; ++i) {
if (i == lone) continue;
for (int j = i + 1; j <= n; ++j) {
if (!m) return 1;
if (i == j || j == lone) continue;
connect(i, j);
}
}
return !m;
}
int main() {
cin >> n >> m >> u;
if (solve()) {
for (int i = 1; i <= n; ++i)
for (int nd : adj[i]) printf("%d %d\n", i, nd);
} else {
printf("-1");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &ex) {
char t = getchar();
bool neg = false;
ex = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) ex = ex * 10 + t - '0';
if (neg) ex = -ex;
return true;
}
template <typename T>
void print_int(T ex) {
if (ex < 0) putchar('-'), ex = -ex;
short a[20] = {}, sz = 0;
while (ex > 0) a[sz++] = ex % 10, ex /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
vector<int> g[111], eid[111];
int n, k, ex[55], ey[55], w[55], m1, m2;
vector<int> vx, vy;
int ans[55], tans[111];
int vs[111], tot;
bool use[111];
void dfs(int x) {
vs[tot++] = x;
use[x] = 1;
for (auto v : g[x])
if (!use[v]) dfs(v);
}
void update(int *ans, int *tans) {
int tmp[55] = {};
for (int i = 0; i <= 50; i++)
for (int j = 0; i + j <= 50; j++)
tmp[i + j] = (tmp[i + j] + 1ll * ans[i] * tans[j]) % mod;
memcpy(ans, tmp, sizeof(tmp));
}
namespace tree_dp {
void solve() {}
}; // namespace tree_dp
namespace bitmask {
int f[1 << 25], tans[55];
int tid[111], n;
void solve(int idl, int idr) {
n = 0;
for (int i = 0; i < tot; i++)
if (vs[i] >= idl && vs[i] <= idr) tid[vs[i]] = n++;
for (int i = 0; i < (1 << n); i++) f[i] = 0;
f[0] = 1;
for (int i = 0; i < tot; i++)
if (vs[i] < idl || vs[i] > idr) {
int &x = vs[i];
for (int j = (1 << n) - 1; j >= 0; j--)
if (f[j]) {
for (int k = 0; k < (int)g[x].size(); k++)
if (!(((j) >> (tid[g[x][k]])) & 1)) {
int nj = j ^ (1 << tid[g[x][k]]);
f[nj] = (f[nj] + 1ll * f[j] * w[eid[x][k]]) % mod;
}
}
}
memset(tans, 0, sizeof(tans));
for (int i = 0; i < (1 << n); i++) {
int num = __builtin_popcount(i);
tans[num] += f[i];
if (tans[num] >= mod) tans[num] -= mod;
}
update(ans, tans);
}
}; // namespace bitmask
int fac[100111];
int main() {
fac[0] = 1;
for (int i = 1; i < 100111; i++) fac[i] = 1ll * i * fac[i - 1] % mod;
(get_int(n) && get_int(k));
for (int i = 0; i < k; i++) {
(get_int(ex[i]) && (get_int(ey[i]) && get_int(w[i])));
w[i] = (w[i] + mod - 1) % mod;
vx.push_back(ex[i]);
vy.push_back(ey[i]);
}
sort(vx.begin(), vx.end());
vx.erase(unique(vx.begin(), vx.end()), vx.end());
sort(vy.begin(), vy.end());
vy.erase(unique(vy.begin(), vy.end()), vy.end());
m1 = (int)vx.size();
m2 = (int)vy.size();
for (int i = 0; i < k; i++) {
ex[i] = lower_bound(vx.begin(), vx.end(), ex[i]) - vx.begin();
ey[i] = lower_bound(vy.begin(), vy.end(), ey[i]) - vy.begin() + m1;
g[ex[i]].push_back(ey[i]);
eid[ex[i]].push_back(i);
g[ey[i]].push_back(ex[i]);
eid[ey[i]].push_back(i);
}
ans[0] = 1;
for (int i = 0; i < m1 + m2; i++)
if (!use[i]) {
tot = 0;
dfs(i);
int c1 = 0, c2 = 0, ce = 0;
for (int j = 0; j < tot; j++) {
if (vs[j] < m1)
c1++;
else
c2++;
ce += (int)g[vs[j]].size();
}
ce /= 2;
ce = ce - tot + 1;
if (c1 <= 25)
bitmask::solve(0, m1 - 1);
else if (c2 <= 25)
bitmask::solve(m1, m1 + m2 - 1);
else
tree_dp::solve();
}
int sum = 0;
for (int i = 0; i <= 50 && i <= n; i++)
sum = (sum + 1ll * ans[i] * fac[n - i]) % mod;
print_int(sum), puts("");
return 0;
}
| 5 |
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int main(){
int i,j;
int p,n;
while(cin>>p>>n&&(p||n)){
int nmn=n,dmn=1,nmx=1,dmx=n;
for(i=1;i<n+1;i++){
for(j=max(1,(int)(sqrt(p)*i)-1);j<min(n+1,(int)(sqrt(p)*i)+2);j++){
if(0){
}else if((double)j/i<sqrt(p)){
if((double)nmx/dmx<(double)j/i){
nmx=j;
dmx=i;
}
}else if((double)j/i>sqrt(p)){
if((double)nmn/dmn>(double)j/i){
nmn=j;
dmn=i;
}
}
}
}
cout<<nmn<<"/"<<dmn<<" "<<nmx<<"/"<<dmx<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 1e9 + 7;
long long t, n, dp[1005][1005][3][3], rp[1005], ans;
char s[1005];
stack<long long> st;
void dfs(long long l, long long r) {
if (r == l + 1) {
dp[l][r][0][1] = dp[l][r][1][0] = dp[l][r][2][0] = dp[l][r][0][2] = 1;
return;
}
if (rp[l] == r) {
dfs(l + 1, r - 1);
for (long long i = 0; i < 3; i++)
for (long long j = 0; j < 3; j++) {
if (j != 1)
dp[l][r][0][1] += dp[l + 1][r - 1][i][j], dp[l][r][0][1] %= p;
if (j != 2)
dp[l][r][0][2] += dp[l + 1][r - 1][i][j], dp[l][r][0][2] %= p;
if (i != 1)
dp[l][r][1][0] += dp[l + 1][r - 1][i][j], dp[l][r][1][0] %= p;
if (i != 2)
dp[l][r][2][0] += dp[l + 1][r - 1][i][j], dp[l][r][2][0] %= p;
}
} else {
dfs(l, rp[l]);
dfs(rp[l] + 1, r);
for (long long i = 0; i < 3; i++)
for (long long j = 0; j < 3; j++)
for (long long u = 0; u < 3; u++)
for (long long v = 0; v < 3; v++)
if (u != v || (u + v == 0))
dp[l][r][i][j] = (dp[l][r][i][j] +
dp[l][rp[l]][i][u] * dp[rp[l] + 1][r][v][j]) %
p;
}
}
signed main() {
cin >> s + 1;
n = strlen(s + 1);
memset(dp, 0, sizeof(dp));
for (long long i = 1; i <= n; i++) {
if (s[i] == '(')
st.push(i);
else {
long long u = st.top();
rp[u] = i;
st.pop();
}
}
dfs(1, n);
for (long long i = 0; i < 3; i++)
for (long long j = 0; j < 3; j++) ans = (ans + dp[1][n][i][j]) % p;
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
const int Inf = 1e9;
long long LINF = (long long)1e18 + 1e17;
const long long mod = 1e9 + 7;
using namespace std;
int use[2000001], a[101];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
memset(use, 0, sizeof(use));
int n;
cin >> n;
vector<int> b;
int mx = 0;
for (int(i) = 0; (i) < n; (i)++) {
cin >> a[i];
mx = max(mx, a[i]);
}
int idx = 1;
bool ok = true;
while (b.size() != n) {
bool fl = false;
for (int(i) = 0; (i) < n; (i)++) {
if (use[a[i] + idx]) fl = true;
}
if (!fl) {
b.push_back(idx);
for (int(i) = 0; (i) < n; (i)++) {
use[a[i] + idx] = 1;
}
}
if (idx > 1000000) {
ok = false;
cout << "NO" << endl;
break;
}
idx++;
}
if (ok) {
cout << "YES" << endl;
for (int(i) = 0; (i) < n; (i)++) {
cout << b[i] << " ";
}
cout << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ifstream("input.txt");
ofstream("output.txt");
int a, b, n;
cin >> a >> b;
n = a + b + 1;
int ans = n - a;
for (int i = ans; i <= n; i++) cout << i << " ";
ans = n - a - 1;
for (int i = ans; i > 0; i--) cout << i << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n;
cin >> n;
vector<int> ad(n);
rep(i,n){
int a,b,c;
cin >> a >> b >> c;
int ans=0;
ans+=195*(a-1);
ans+=5*((a-1)/3);
if(a%3==0){
ans+=20*(b-1)+c-1;
}
else{
ans+=20*(b-1)-((b-1)/2);
ans+=c-1;
}
ad[i]=196470-ans;
}
rep(i,n){
cout << ad[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 5;
char a[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _;
cin >> _;
while (_--) {
int n;
cin >> n >> (a + 1);
long long len = strlen(a + 1);
int f = 1;
for (int i = 1; i <= n; i++) {
if (f) {
int pre = len;
len = i + (len - i) * (a[i] - '0');
for (int j = pre + 1, k = i + 1; j <= len && j <= n; j++, k++) {
a[j] = a[k];
if (k == pre) k = i;
}
if (len >= n) f = 0;
len = len % mod;
} else {
len = (i + (len + mod - i) * (a[i] - '0')) % mod;
}
}
printf("%lld\n", len);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct train {
long long x, id;
};
bool operator<(const train& a, const train& b) {
if (a.x == b.x) return a.id < b.id;
return a.x < b.x;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, h, m, k;
cin >> n >> h >> m >> k;
m /= 2;
vector<train> dep(2 * n);
for (long long i = 0; i < n; i++) {
cin.ignore(256, ' ');
long long x;
cin >> x;
train tr{x % m, i + 1};
dep[2 * i] = tr;
dep[2 * i + 1] = tr;
dep[2 * i + 1].x += m;
}
sort(dep.begin(), dep.end());
long long ans = 1000000000ll;
long long t = -1;
for (long long i = 0; i < n; i++) {
long long t1 = dep[i].x;
long long t2 = t1 + k;
long long ans_i =
lower_bound(dep.begin(), dep.end(), train{t2, -1}) -
upper_bound(dep.begin(), dep.end(), train{t1, 1000000000ll});
if (ans_i < ans) ans = ans_i, t = t2;
}
cout << ans << ' ' << t % m << '\n';
train L{t - k, 1000000000ll}, R{t, -1};
for (const train& i : dep)
if (i < L)
continue;
else if (R < i)
break;
else
cout << i.id << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int n, x, m[110];
cin >> n >> x;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> m[i];
sum += m[i];
}
sort(m, m + n);
x -= sum;
cout << n + x / m[0] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char alphz[27] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
float Euclidean(long long x1, long long x2, long long y1, long long y2) {
return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long LCM(long long a, long long b) { return (a * b) / gcd(a, b); }
void PrimeFactor(long long n) {
while (n % 2 == 0) {
n /= 2;
}
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
n /= i;
}
}
if (n > 2) {
};
}
bool is_square(long long x) {
long long l = 0, r = x;
while (l <= r) {
long long mid = l + (r - l) / 2;
if (mid * mid == x) return true;
if (mid * mid > x)
r = mid - 1;
else
l = mid + 1;
}
return false;
}
long long power(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
bool is_Prime(int x) {
if (x == 2)
return 1;
else if (x % 2 == 0 || x < 2)
return 0;
for (int i = 3; i * i <= x; i += 2)
if (x % i == 0) return 0;
return 1;
}
const int N = 1e+5;
int aseg[4], seg[4];
void SEGBuild(int pos, int low, int hig) {
if (low == hig)
seg[pos] = aseg[low];
else {
int mid = low + (hig - low) / 2;
SEGBuild(2 * pos, low, mid);
SEGBuild(2 * pos + 1, mid + 1, hig);
if (seg[2 * pos] < seg[2 * pos + 1])
seg[pos] = seg[2 * pos];
else
seg[pos] = seg[2 * pos + 1];
}
}
void SEGUpdate(int pos, int idx, int low, int hig, int val) {
if (low == hig) {
aseg[idx] = val;
seg[pos] = val;
} else {
int mid = low + (hig - low) / 2;
if (idx >= low && idx <= mid)
SEGUpdate(2 * pos, idx, low, mid, val);
else
SEGUpdate(2 * pos + 1, idx, mid + 1, hig, val);
seg[pos] = min(seg[2 * pos + 1], seg[2 * pos]);
}
}
int ANSQuery(int pos, int low, int hig, int l, int r) {
if (l > hig || low > r) return 1e+5;
if (l <= low && r >= hig)
return seg[pos];
else {
int p1, p2;
int mid = low + (hig - low) / 2;
p1 = ANSQuery(2 * pos, low, mid, l, r);
p2 = ANSQuery(2 * pos + 1, mid + 1, hig, l, r);
return min(p1, p2);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k;
string s;
cin >> k >> s;
vector<int> a(k, 0);
int len = (int)s.size();
if (len == 1) {
if (k > 1) return cout << "IMPOSSIBLE\n", 0;
return cout << "a" << '\n', 0;
}
int i = 0, j = len - 1;
while (i < j) {
if (s[i] != '?' && s[j] != '?' && s[i] != s[j])
return cout << "IMPOSSIBLE\n", 0;
if (s[i] != '?') a[s[i] - 'a']++;
if (s[j] != '?') a[s[j] - 'a']++;
i++, j--;
}
int mid = len / 2;
if (len % 2 == 0)
i = mid - 1, j = mid;
else
i = mid, j = mid;
while (i >= 0) {
if (s[i] != '?' && s[j] != '?')
a[s[i] - 'a'] += 2;
else if (s[i] == '?' && s[j] != '?')
s[i] = s[j], a[s[j] - 'a'] += 2;
else if (s[i] != '?' && s[j] == '?')
s[j] = s[i], a[s[i] - 'a'] += 2;
else {
int idx = 0;
for (int i = k - 1; i >= 0; i--) {
if (a[i] == 0) {
idx = i;
break;
}
}
s[i] = s[j] = idx + 'a';
a[idx] += 2;
}
i--, j++;
}
for (int i = 0; i < k; i++)
if (!a[i]) return cout << "IMPOSSIBLE\n", 0;
cout << s << '\n';
return 0;
}
| 3 |
#include <cstdio>
int main(){
char c;
while(scanf("%c",&c)!= EOF){
if(c >= 'a' && c <= 'z'){
c = c-32;
}else if(c >= 'A' && c<='Z'){
c = c+32;
}
printf("%c", c);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q;
cin >> q;
for (long long i = 1; i <= 1e6; i++) {
long long c = i;
if (c / 2 + 1 == q) {
cout << c << " " << 2 << endl;
cout << 1 << " " << 2 << endl;
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, vector<string> > process(string str) {
vector<string> ret;
string s = "";
for (int i = 3; i < str.size(); i++) {
if (str[i] == '\\') {
ret.push_back(s);
s = "";
} else {
s += str[i];
}
}
ret.push_back(s);
return {str[0] - 'C', ret};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
vector<vector<string> > vec[5];
string str;
while (cin >> str) {
pair<int, vector<string> > pv = process(str);
vec[pv.first].push_back(pv.second);
}
int ans1 = 0;
int ans2 = 0;
for (int i = 0; i < 5; i++) {
sort(vec[i].begin(), vec[i].end());
map<string, set<vector<string> > > smp;
map<string, int> mp;
for (int j = 0; j < vec[i].size(); j++) {
mp[vec[i][j][0]]++;
vector<string> tmp({vec[i][j][0]});
for (int k = 1; k + 1 < vec[i][j].size(); k++) {
tmp.push_back(vec[i][j][k]);
smp[vec[i][j][0]].insert(tmp);
}
}
for (auto x : smp) {
ans1 = max(ans1, (int)x.second.size());
}
for (auto x : mp) {
ans2 = max(ans2, x.second);
}
}
cout << ans1 << " " << ans2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 11) + 5;
const long long INF = 2e18;
const long long MOD = 998244353;
void resize(vector<int> &v) {
v.resize(unique(v.begin(), v.end()) - v.begin());
}
void solve() {
int n;
long long T;
cin >> n >> T;
long long ans = 0;
long long a[n + 4];
for (int i = 1; i <= n; i++) cin >> a[i];
long long t = T;
while (true) {
long long c = 0, cost = 0;
long long temp = t;
for (int i = 1; i <= n; i++) {
if (a[i] <= temp) {
temp -= a[i];
cost += a[i];
c++;
}
}
if (c == 0) break;
ans += (t / cost) * c;
t %= cost;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
clock_t z = clock();
solve();
fprintf(stderr, "Total Time: %.3f\n",
(double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d, k, m, q, z;
const int MXN = 1e5 + 5;
int who[MXN];
set<pair<int, int> > S;
int C[MXN];
int main() {
scanf("%d", &n);
vector<pair<int, pair<int, int> > > events;
for (int i = 1; i <= (n); i++) {
scanf("%d%d", &a, &b);
events.push_back(make_pair(b, make_pair(i, a)));
}
scanf("%d", &m);
for (int i = 1; i <= (m); i++) {
scanf("%d%d%d", &a, &b, &C[i]);
events.push_back(make_pair(b, make_pair(1e9 + i, a)));
}
sort(events.begin(), events.end());
for (int i = 0; i < (events.size()); i++) {
int a = events[i].second.second;
int type = events[i].second.first;
if (type <= n) {
S.insert(make_pair(a, type));
} else {
type -= 1e9;
int k = C[type];
set<pair<int, int> >::iterator it = S.upper_bound(make_pair(a, 0)), it2;
while (k && it != S.end()) {
k--;
it2 = it;
it++;
who[it2->second] = type;
S.erase(it2);
}
}
}
if (S.size() != 0) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= (n); i++) printf("%d ", who[i]);
}
| 3 |
#include <bits/stdc++.h>
int a[1212][1212];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int all_s = 0;
bool is_gone[1212][1212][4];
int ans = 0;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void dfs(int x, int y, int dir, int go) {
int i;
bool f = 0;
for (i = 0; i < 4; i++) {
if (is_gone[x][y][i]) continue;
if (a[x + dx[i]][y + dy[i]] == 0) continue;
int l;
if (dir != i)
ans = gcd(go, ans), l = 1;
else
l = go + 1;
is_gone[x][y][i] = is_gone[x + dx[i]][y + dy[i]][(i + 2) % 4] = 1;
all_s -= 2;
dfs(x + dx[i], y + dy[i], i, l);
f = 1;
}
if (!f) ans = gcd(go, ans);
}
int main() {
int n, m;
int i, j, k;
int R = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (!a[i][j]) continue;
int s = 0;
for (k = 0; k < 4; k++) s += a[i + dx[k]][j + dy[k]];
all_s += s;
if (!s) {
puts("-1");
return 0;
}
if (s % 2 == 1) R++;
}
}
if (!(R == 0 || R == 2)) {
puts("-1");
return 0;
}
bool flag = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j]) {
dfs(i, j, 10, 0);
flag = 1;
break;
}
}
if (flag) break;
}
if (all_s || ans <= 1)
puts("-1");
else
for (i = 2; i <= ans; i++)
if (ans % i == 0) printf("%d ", i);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
struct Double {
double d;
explicit Double(double x) : d(x) {}
};
ostream& operator<<(ostream& os, const Double x) {
os << fixed << setprecision(20) << x.d;
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
os << "[";
for (const auto& v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& mp) {
os << "{";
for (auto& p : mp) {
os << p << ",";
}
os << "}";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& st) {
os << "{";
for (T v : st) os << v << ",";
os << "}";
return os;
}
template <typename T, typename U>
inline void chmax(T& x, U y) {
if (y > x) x = y;
}
template <typename T, typename U>
inline void chmin(T& x, U y) {
if (y < x) x = y;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
constexpr double eps = 1e-10;
constexpr long long mod = 1e9 + 7;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
constexpr int MAXL = 256;
int dp[MAXL][MAXL][MAXL];
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<vector<int>> next(n + 2, vector<int>(30, n));
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= 'z' - 'a'; j++) {
if (s[i] - 'a' == j)
next[i][j] = i;
else
next[i][j] = next[i + 1][j];
}
}
vector<char> ss[3];
for (int i = 0; i < (int)(MAXL); i++)
for (int j = 0; j < (int)(MAXL); j++)
for (int k = 0; k < (int)(MAXL); k++) dp[i][j][k] = INF;
dp[0][0][0] = -1;
for (int loop = 0; loop < q; loop++) {
char c;
cin >> c;
int id;
cin >> id;
id--;
if (c == '+') {
char a;
cin >> a;
ss[id].push_back(a);
int s0 = ss[0].size();
int s1 = ss[1].size();
int s2 = ss[2].size();
for (int i = (id == 0 ? s0 : 0); i <= s0; i++) {
for (int j = (id == 1 ? s1 : 0); j <= s1; j++) {
for (int k = (id == 2 ? s2 : 0); k <= s2; k++) {
dp[i][j][k] = INF;
if (i > 0)
dp[i][j][k] = min(dp[i][j][k],
next[dp[i - 1][j][k] + 1][ss[0][i - 1] - 'a']);
if (j > 0)
dp[i][j][k] = min(dp[i][j][k],
next[dp[i][j - 1][k] + 1][ss[1][j - 1] - 'a']);
if (k > 0)
dp[i][j][k] = min(dp[i][j][k],
next[dp[i][j][k - 1] + 1][ss[2][k - 1] - 'a']);
}
}
}
} else {
ss[id].pop_back();
}
if (dp[ss[0].size()][ss[1].size()][ss[2].size()] < n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int k, a, b;
int main() {
cin >> k >> a >> b;
long long int ans = 0;
if (b < 0) {
a = -a;
b = -b;
swap(a, b);
}
if (b >= 0) {
ans = b / k;
if (a <= 0) {
a = -a;
ans += a / k + 1;
} else {
a--;
ans -= a / k;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, nO2, a, b;
void f(int v, int p, vector<int>& sz, const vector<vector<int> >& graph,
vector<int>& centroids) {
bool isCent = true;
for (int u : graph[v])
if (u != p) {
f(u, v, sz, graph, centroids);
sz[v] += sz[u];
if (sz[u] > nO2) isCent = false;
}
if (n - sz[v] <= nO2 && isCent) centroids.push_back(v);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
nO2 = n >> 1;
vector<vector<int> > graph(n + 1, vector<int>());
vector<int> sz(n + 1, 1);
vector<int> centroids;
for (int i = 1; i < n; i++)
cin >> a >> b, graph[a].push_back(b), graph[b].push_back(a);
f(a, a, sz, graph, centroids);
int parent = centroids[0], opPar = centroids[centroids.size() == 2 ? 1 : 0];
int child = graph[parent][graph[parent][0] == opPar ? 1 : 0];
cout << parent << " " << child << "\n" << opPar << " " << child << "\n";
}
return 0;
}
| 3 |
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
bool block[6][110][110];
bool visit[110][110];
int main(){
int w, h;
int xs, ys, xg, yg;
int n, c, d, x, y;
while(scanf("%d%d%d%d%d%d%d", &w, &h, &xs, &ys, &xg, &yg, &n) == 7){
memset(block, 0, sizeof block);
memset(visit, 0, sizeof visit);
for(int i = 0; i < n; ++i){
scanf("%d%d%d%d", &c, &d, &x, &y);
int dx, dy;
if(d){ dx = 2; dy = 4; }
else{ dy = 2; dx = 4; }
for(int j = 0; j < dy; ++j)
for(int k = 0; k < dx; ++k){
block[c][y + j][x + k] = true;
}
}
for(c = 5; c > 1 && !block[c][ys][xs]; --c);
if(c){
queue<int> q;
q.push(ys << 16 | xs);
visit[ys][xs] = true;
while(!q.empty()){
y = q.front() >> 16;
x = q.front() & 0xffff;
q.pop();
for(int dy = -1; dy <= 1; ++dy)
for(int dx = -1; dx <= 1; ++dx){
if(block[c][y+dy][x+dx] && !visit[y+dy][x+dx]){
visit[y+dy][x+dx] = true;
q.push(y+dy << 16 | x+dx);
}
}
}
}
puts(visit[yg][xg] ? "OK" : "NG");
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int dp[26][26];
memset(dp, -1, sizeof dp);
char king[11];
for (int i = 0; i < n; i++) {
scanf("%s", king);
int m = strlen(king);
char st = king[0] - 'a';
char ed = king[m - 1] - 'a';
for (int j = 0; j < 26; j++)
if (~dp[j][st]) dp[j][ed] = max(dp[j][ed], dp[j][st] + m);
dp[st][ed] = max(dp[st][ed], m);
}
int ans = 0;
for (int i = 0; i < 26; i++) ans = max(ans, dp[i][i]);
printf("%d", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[301][301];
long long dp[301][301];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = 1000000000ll * 50000ll;
long long x, y, cost;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> cost;
a[x][y] = min(a[x][y], cost);
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
if (a[i][j] == 1000000000ll * 50000ll) continue;
for (int k = i + 1; k <= j; k++) a[k][j] = min(a[k][j], a[i][j]);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) dp[i][j] = 1000000000ll * 50000ll;
dp[i][0] = 0;
}
for (int i = n; i >= 1; i--) {
for (int j = k; j >= 0; j--) {
if (i + 1 <= n) dp[i][j] = min(dp[i][j], dp[i + 1][j]);
for (int t = i; t <= n; t++) {
dp[i][j] = min(
dp[i][j], a[i][t] + (t + 1 <= n ? dp[t + 1][max(0, j - (t - i + 1))]
: (j - (t - i + 1) == 0
? 0
: 1000000000ll * 50000ll)));
}
}
}
if (dp[1][k] == 1000000000ll * 50000ll)
cout << -1 << endl;
else
cout << dp[1][k] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
cin >> t;
while (t--) {
long long n, i, j;
string s, a, b;
cin >> n >> s;
a = b = "";
bool flag = true;
;
a += '1', b += '1';
for (i = 1; i < n; i++) {
if (s[i] == '0') {
a += '0', b += '0';
} else if (s[i] == '1') {
if (flag) {
a += '1';
b += '0';
flag = false;
} else {
a += '0';
b += '1';
}
} else if (s[i] == '2') {
if (flag) {
a += '1', b += '1';
} else {
a += '0', b += '2';
}
}
}
cout << a << '\n' << b << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
int i;
for (i = 0; i < n; ++i) cin >> arr[i];
int count = 0;
i = 0;
for (i = 0; i < n; ++i) {
if (arr[i] <= k)
count++;
else
break;
}
if (i == n) {
cout << count;
return 0;
}
for (int j = n - 1; j >= i; j--) {
if (arr[j] <= k)
count++;
else
break;
}
cout << count;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 5;
const int BASE = 2333;
unsigned long long fac[N], f[2][N];
char s[N];
pair<int, int> pos[N];
unsigned long long get_hash(int id, int l, int r) {
if (l - 2 < 0) return f[id][r];
return f[id][r] - f[id][l - 2] * fac[(r - l) / 2 + 1];
}
int K, sum[33];
vector<int> vt[N];
string solve() {
int n = strlen(s + 1);
f[0][0] = 0;
f[0][1] = s[1] - 'a' + 1;
for (int i = 2; i <= n; i++) {
f[0][i] = f[0][i - 2] * BASE + s[i] - 'a' + 1;
}
f[1][0] = 0;
f[1][1] = s[n] - 'a' + 1;
for (int i = 2; i <= n; i++) {
f[1][i] = f[1][i - 2] * BASE + s[n - i + 1] - 'a' + 1;
}
for (int i = 1; i <= n; i++) {
vt[i].clear();
for (int j = i; j <= n; j++) {
int len = j - i + 1;
int tmp = ((len + 1) / 2 + 1) / 2;
if (get_hash(0, i, i + (tmp + 1) * 2 - 1 - 3) ==
get_hash(1, n - j + 1, n - (j - (tmp + 1) * 2 + 1 + 3) + 1)) {
vt[i].push_back(j);
}
}
reverse(vt[i].begin(), vt[i].end());
}
string ans = "";
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= n; j++)
if (vt[j].size() && vt[j][vt[j].size() - 1] - j + 1 < i) {
cnt++;
vt[j].pop_back();
}
K -= cnt;
if (K <= 0) break;
int sum[2];
sum[0] = sum[1] = 0;
for (int j = 1; j <= n; j++)
if (vt[j].size()) sum[s[j + i - 1] - 'a'] += vt[j].size();
if (sum[0] < K) {
for (int j = 1; j <= n; j++)
if (vt[j].size()) {
if (s[j + i - 1] == 'a') vt[j].clear();
}
K -= sum[0];
ans += 'b';
} else {
for (int j = 1; j <= n; j++)
if (vt[j].size()) {
if (s[j + i - 1] == 'b') vt[j].clear();
}
ans += 'a';
}
}
return ans;
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * BASE;
}
int main() {
init(5000);
scanf("%s%d", s + 1, &K);
cout << solve() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
char mp[N][N];
int dp[N][N][N][N];
int solve(int x, int y, int u, int v) {
int &w = dp[x][y][u][v];
if (w != -1) return w;
w = max(y - x + 1, v - u + 1);
for (int i = x; i < y; i++)
w = min(w, solve(x, i, u, v) + solve(i + 1, y, u, v));
for (int i = u; i < v; i++)
w = min(w, solve(x, y, u, i) + solve(x, y, i + 1, v));
return w;
}
int main() {
memset(dp, -1, sizeof(dp));
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%s", mp[i] + 1);
for (int j = 1; j <= n; j++) dp[i][i][j][j] = mp[i][j] == '#';
}
printf("%d", solve(1, n, 1, n));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void Not_Stable() {
long long n, m, k;
cin >> n >> m >> k;
long long val = ((n - 1) * (n - 2)) / 2 + 1;
if (m < n - 1 || m > val) {
cout << "-1";
return;
}
long long v = k;
if (v != 1) {
for (long long i = 1; i <= n; i++) {
if (i != v) cout << v << " " << i << "\n";
}
m -= (n - 1);
for (long long i = 2; i <= n; i++) {
if (i == v) continue;
for (long long j = i + 1; j <= n; j++) {
if (j == v) continue;
if (m == 0) return;
cout << i << " " << j;
cout << "\n";
--m;
}
}
} else {
for (long long i = 1; i <= n; i++) {
if (i != v) cout << v << " " << i << "\n";
}
m -= (n - 1);
for (long long i = 3; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
if (m == 0) return;
cout << i << " " << j;
cout << "\n";
--m;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
;
long long g = 1;
while (g--) Not_Stable();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int a[110];
map<int, int> mp;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
mp.clear(), v.clear();
int maxx = 0;
int n, k, x;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (mp.count(a[i]) == 0) {
mp[a[i]] = 1;
v.push_back(a[i]);
}
}
while (v.size() < k) v.push_back(1);
if (mp.size() > k)
cout << -1 << endl;
else {
int now = 1, num = 0;
while (now <= n) {
for (int j = 0; j < v.size() && now <= n; j++) {
num++;
if (now <= n && v[j] == a[now]) now++;
}
}
cout << num << endl;
now = 1, num = 0;
while (now <= n)
for (int j = 0; j < v.size() && now <= n; j++) {
if (now <= n && v[j] == a[now]) now++;
cout << v[j] << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, total;
int s[110], c[110][110];
pair<int, int> a[110];
bool chosen[110];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", s + i);
for (int j = 1; j <= s[i]; j++) {
scanf("%d", c[i] + j);
total += c[i][j];
}
a[i] = make_pair(0, 0);
int half = s[i] / 2 + s[i] % 2;
for (int j = 1; j <= half; j++) {
a[i].first += c[i][j];
a[i].second += c[i][s[i] - j + 1];
}
for (int j = half + 1; j <= s[i]; j++) {
a[i].first -= c[i][j];
a[i].second -= c[i][s[i] - j + 1];
}
}
memset(chosen, 0, sizeof chosen);
int diff = 0;
for (int step = 1; step <= n; step++) {
int tmp = 0;
if (step & 1) {
for (int i = 1; i <= n; i++)
if (!chosen[i]) tmp = max(tmp, a[i].first + a[i].second);
for (int i = 1; i <= n; i++)
if (!chosen[i] && tmp == a[i].first + a[i].second) {
chosen[i] = 1;
diff += a[i].first;
break;
}
} else {
for (int i = 1; i <= n; i++)
if (!chosen[i]) tmp = max(tmp, a[i].first + a[i].second);
for (int i = 1; i <= n; i++)
if (!chosen[i] && tmp == a[i].first + a[i].second) {
chosen[i] = 1;
diff -= a[i].second;
break;
}
}
}
printf("%d %d", (total + diff) / 2, (total - diff) / 2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, ans = 0;
int z;
scanf("%d", &n);
for (int i = 1; i * i <= n * n / 2; i++) {
for (int j = i; i * i + j * j <= n * n; j++) {
z = i * i + j * j;
if (sqrt(z) - (int)sqrt(z) < 1e-7) {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct S {
int a, b;
S() {}
S(int _a, int _b) {
a = _a;
b = _b;
}
const bool operator<(const S &o) const { return a < o.a; }
};
priority_queue<int, vector<int>, greater<int>> mpq;
inline void showAll(vector<int> &v, int NL_or_space) {
for (int &here : v) {
printf("%d", here);
printf("%c", (NL_or_space) ? '\n' : ' ');
}
}
const int SIZE = 109;
char grid[SIZE][SIZE];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= n; j++) grid[i][j] = '.';
int ans = -1;
if (k == 0)
ans = 1;
else if (k % 2 == 0) {
ans = 1;
for (int i = 0; i < k / 2; i++) {
grid[2][2 + i] = '#';
grid[3][2 + i] = '#';
}
} else {
ans = 1;
grid[2][(1 + n) / 2] = '#';
k--;
for (int i = 1; i <= k / 2; i++) {
grid[2][(1 + n) / 2 + i] = '#';
grid[2][(1 + n) / 2 - i] = '#';
k -= 2;
}
if (k & 1) assert(0);
for (int i = 0; i < k / 2; i++) {
grid[3][i + 2] = '#';
grid[3][n - 1 - i] = '#';
}
}
if (ans) {
printf("YES\n");
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
printf("%c", grid[i][j]);
}
printf("\n");
}
} else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct block {
int x, y, z;
};
const int MN = 5 * 1000 * 100 + 10;
const int inf = 1 << 30;
block arr[MN];
int mx[MN], n;
bool byX(block a, block b) { return a.x > b.x; }
bool byY(block a, block b) { return a.y > b.y; }
inline void upd(int v, int val) {
while (v < n) {
mx[v] = max(mx[v], val);
v |= (v + 1);
}
}
inline int get_max(int v) {
int maxim = -inf;
while (v >= 0) {
maxim = max(maxim, mx[v]);
v = (v & (v + 1)) - 1;
}
return maxim;
}
inline void upd_segm(int left, int right) {
for (int i = left; i <= right; i++) upd(arr[i].y, arr[i].z);
}
int main() {
int ans = 0;
fill(&mx[0], &mx[0] + MN, -inf);
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &arr[i].x);
for (int i = 0; i < n; i++) scanf("%d", &arr[i].y);
for (int i = 0; i < n; i++) scanf("%d", &arr[i].z);
sort(arr, arr + n, byY);
for (int i = 0, prev = -1, j = -1; i < n; i++) {
if (arr[i].y != prev) {
prev = arr[i].y;
arr[i].y = ++j;
} else
arr[i].y = j;
}
sort(arr, arr + n, byX);
for (int i = 1, poz = 0; i < n; i++) {
if (arr[i].x != arr[i - 1].x) {
upd_segm(poz, i - 1);
poz = i;
}
int maxim = get_max(arr[i].y - 1);
if (maxim > arr[i].z) ans++;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(int t) { cout << "Case #" << t << ": "; }
vector<long long> sieve(int n) {
int *arr = new int[n + 1]();
vector<long long> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
string store = s;
sort(s.begin(), s.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
if (store[i] != s[i]) {
ans++;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long int a[5001], b[5001];
long long ans[5001];
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
b[i] = a[i];
}
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
ans[j] += abs(a[i] - b[j]);
if (j > 1) ans[j] = min(ans[j], ans[j - 1]);
}
cout << ans[n];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
long long int ans = 0;
cin >> n >> k;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
string s;
cin >> s;
for (int i = 0, j = 0; i < n; i = j) {
while (j < n && s[i] == s[j]) j++;
sort(a + i, a + j);
reverse(a + i, a + j);
for (int l = i; l < min(j, i + k); l++) ans = ans + a[l];
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:536870912")
#pragma warning(disable : 4996)
using namespace std;
const int N = 3e5 + 100;
vector<int> v[N];
int sz[N], col[N], cs[N], rb[N];
long long int ans[N], sum[N];
bool used[N];
int z = 1;
pair<int, int> dfs(int node, int anc) {
used[node] = 1;
pair<int, int> ret = {-1, -1};
for (int to : v[node]) {
if (to == anc) continue;
if (used[to]) {
if (ret.first == -1) ret = {to, z++};
} else {
auto g = dfs(to, node);
if (g.first != -1) ret = g;
}
}
if (ret.first != -1) {
sz[ret.second]++;
col[node] = ret.second;
return ret.first == node ? make_pair(-1, -1) : ret;
}
return {-1, -1};
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i, -1);
}
}
int r = -1, t = 0;
for (int i = 0; i < n; i++) {
while (!t && r < n) {
r++;
if (col[r]) {
cs[col[r]]++;
if (cs[col[r]] == sz[col[r]]) t = 1;
}
}
rb[i] = r - 1;
if (col[i]) {
if (cs[col[i]] == sz[col[i]]) t = 0;
cs[col[i]]--;
}
}
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i] + rb[i] - i + 1;
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
long long int w = upper_bound(rb, rb + n, y) - rb - 1,
h = y - max(x - 1ll, w),
ans = sum[max((long long int)x, w + 1)] - sum[x] +
h * (h + 1) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
unordered_map<long long, long long> a;
long long tt;
for (long long i = 0; i < n; i++) {
cin >> tt;
a[tt]++;
}
cout << a[0] << ' ';
map<long long, long long> don;
long long ans = 0;
if (a[0] == 0) {
ans = -1;
} else {
if (a[0] > 1) don[0] = (a[0] - 1);
}
long long fil = 0;
for (long long i = 1; i <= n; i++) {
long long a2 = 0;
if (ans == -1) {
cout << -1 << ' ';
continue;
}
a2 += a[i];
a2 += fil;
cout << a2 << ' ';
if (a[i] > 1) {
don[i] = (a[i] - 1);
} else if (a[i] == 0) {
if (don.size() > 0) {
auto it = don.end();
it--;
fil += (i - it->first);
it->second--;
if (it->second == 0) {
don.erase(it->first);
}
} else {
ans = -1;
}
}
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
unordered_multimap<string, string> mp;
set<string> st;
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
string t;
cin >> t;
long long k;
cin >> k;
st.insert(t);
for (long long j = 0; j < k; j++) {
string l;
cin >> l;
mp.insert(make_pair(t, l));
}
}
cout << (long long)((st).size()) << "\n";
for (auto x : st) {
auto range = mp.equal_range(x);
vector<string> ans;
set<string> cc;
for (auto it = range.first; it != range.second; it++) {
string t = it->second;
cc.insert(t);
}
for (string y : cc) {
ans.push_back(y);
}
for (long long i = 0; i < (long long)((ans).size()); i++) {
for (long long j = 0; j < (long long)((ans).size()); j++) {
if (i != j) {
if ((long long)((ans[j]).size()) >= (long long)((ans[i]).size())) {
string l = ans[j].substr(
(long long)((ans[j]).size()) - (long long)((ans[i]).size()),
(long long)((ans[i]).size()));
if (l == ans[i]) {
ans[i] = "?";
break;
}
}
}
}
}
cout << x << " ";
long long cnt = 0;
for (long long i = 0; i < (long long)((ans).size()); i++) {
if (ans[i] != "?") {
cnt++;
}
}
cout << cnt << " ";
for (long long i = 0; i < (long long)((ans).size()); i++) {
if (ans[i] != "?") cout << ans[i] << " ";
}
cout << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int prev = 987654321;
int sum = 0;
for(int i = 0;i<n-1;i++){
int t, a;
cin>>t;
a = min(t, prev);
sum += a;
prev = t;
}
cout<<sum + prev;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
string s;
long mod=1e9+7,dp[3333][3333];
int n;
int main()
{
cin>>n>>s;
dp[0][0]=1;
for(int i=1;i<n;i++)
{
if(s[i-1]=='<')
{
long now=0;
for(int j=1;j<=i;j++)
{
now=(now+dp[i-1][j-1])%mod;
dp[i][j]=now;
}
}
else
{
long now=0;
for(int j=i;j>=0;j--)
{
now=(now+dp[i-1][j])%mod;
dp[i][j]=now;
}
}
}
long ans=0;
for(int i=0;i<n;i++)ans=(ans+dp[n-1][i])%mod;
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> num(n);
vector<bool> sl(1000, false);
vector<int> sna;
for (int i = 0; i < n; i++) {
cin >> num[i];
}
for (int i = n - 1; i >= 0; i--) {
if (sl[num[i]] == false) {
sna.push_back(num[i]);
sl[num[i]] = true;
}
}
reverse(sna.begin(), sna.end());
cout << sna.size() << endl;
for (int i = 0; i < sna.size(); i++) {
cout << sna[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v, v_copy;
int main() {
int n, x, counter = 0;
cin >> n;
for (int test = 1; test <= n; test++) {
cin >> x;
int a;
bool t = true;
for (int i = 1; i <= x; i++) {
cin >> a;
if (a != i && t) {
counter++;
}
t = (a == i);
}
if (counter > 2) {
counter = 2;
}
cout << counter << endl;
counter = 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long N = 3e5+5, M =1e15, OO = 0x3f3f3f3f;
#define FIO ios_base::sync_with_stdio(0);cin.tie(0);
ll t;
ll n, k;
ll a[N], tmpp[N];
ll dis[N];
void solve()
{
priority_queue<pair<ll, ll>> pq;
for(int i=0; i<n; ++i) pq.push({-dis[i], i});
while(!pq.empty())
{
pair<ll, ll> pp = pq.top();
pq.pop();
ll ds = -pp.first;
ll u = pp.second;
if(dis[u] != ds) continue;
if(u-1 >= 0 && dis[u-1] > dis[u]+1)
{
dis[u-1] = dis[u] + 1;
pq.push({-dis[u-1], u-1});
}
if(u+1 < n && dis[u+1] > dis[u]+1)
{
dis[u+1] = dis[u] + 1;
pq.push({-dis[u+1], u+1});
}
}
}
int main()
{
FIO;
cin >> t;
while(t--)
{
cin >> n >> k;
for(int i=0; i<k; ++i) cin >> a[i];
for(int i=0; i<k; ++i) cin >> tmpp[i];
for(int i=0; i<n; ++i) dis[i] = M;
for(int i=0; i<k; ++i) dis[a[i]-1] = tmpp[i];
solve();
for(int i=0; i<n; ++i) cout << dis[i] << " ";
cout << endl;
}
}
| 5 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CLEAR(arr, val) memset(arr, val, sizeof(arr))
#define rep(i, n) for (int i = 0; i < n; ++i)
template <class T> void max_swap(T& a, const T& b) { a = max(a, b); }
template <class T> void min_swap(T& a, const T& b) { a = min(a, b); }
typedef long long ll;
typedef pair<int, int> pint;
const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };
int n;
double dis[32][32];
bool dfs(int unvisit, int cur, double time)
{
if (unvisit == 0)
return true;
for (int i = 0; i < n; ++i)
if (unvisit >> i & 1 && time + dis[cur][i] > dis[n + 1][i])
return false;
for (int i = 0; i < n; ++i)
if (unvisit >> i & 1 && time + dis[cur][i] < dis[n + 1][i])
if (dfs(unvisit ^ 1 << i, i, time + dis[cur][i]))
return true;
return false;
}
int main()
{
int hx, hy, dx, dy;
while (scanf("%d%d%d%d%d", &n, &hx, &hy, &dx, &dy), n)
{
int x[32], y[32];
rep (i, n)
scanf("%d%d", x + i, y + i);
x[n] = hx, y[n] = hy;
x[n + 1] = dx, y[n + 1] = dy;
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j)
dis[i][j] = hypot(x[i] - x[j], y[i] - y[j]);
puts(dfs((1 << n) - 1, n, 0) ? "YES" : "NO");
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long LINF = 2e16;
const int magic = 348;
const int MOD = 313;
const double eps = 1e-10;
const double pi = acos(-1);
inline int getint() {
bool f;
char ch;
int res;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return f ? res : -res;
}
const int MAXN = 4e5;
int d;
char s[MAXN + 48];
int len;
char ans[MAXN + 48];
unsigned long long pw[MAXN + 48];
struct BIT {
unsigned long long c[MAXN + 48];
inline void init() {
for (register int i = 1; i <= len; i++) c[i] = 0;
}
inline void update(int first, unsigned long long delta) {
while (first <= len) c[first] += delta, first += first & (-first);
}
inline unsigned long long query(int first) {
unsigned long long res = 0;
while (first) res += c[first], first -= first & (-first);
return res;
}
inline unsigned long long calc(int left, int right) {
return query(right) - query(left - 1);
}
} L, R;
inline void updatech(int pos, char ch, int fl) {
L.update(pos, pw[len - pos] * ch * fl);
R.update(pos, pw[pos - 1] * ch * fl);
}
inline bool ispal(int left, int right) {
return L.calc(left, right) * pw[left - 1] ==
R.calc(left, right) * pw[len - right];
}
inline bool check_bad(int pos) {
if (pos >= d && ispal(pos - d + 1, pos)) return true;
if (pos >= d + 1 && ispal(pos - d, pos)) return true;
return false;
}
inline bool dfs(int pos, bool same) {
if (pos == len + 1) return (!same) ? true : false;
for (char ch = (same ? s[pos] : 'a'); ch <= 'z'; ch++) {
updatech(pos, ch, 1);
ans[pos] = ch;
if (check_bad(pos)) {
updatech(pos, ch, -1);
continue;
}
bool ns = same;
if (ch != s[pos]) ns = false;
bool res = dfs(pos + 1, ns);
if (res) return true;
updatech(pos, ch, -1);
}
return false;
}
int main() {
d = getint();
scanf("%s", s + 1);
len = strlen(s + 1);
pw[0] = 1;
for (register int i = 1; i <= len; i++) pw[i] = pw[i - 1] * MOD;
L.init();
R.init();
bool res = dfs(1, 1);
if (!res)
puts("Impossible");
else
printf("%s", ans + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, p, q;
cin >> n;
cout << (n / 2) * ((n + 1) / 2) << endl;
for (i = 1; i <= n / 2; i++) {
for (j = n / 2 + 1; j <= n; j++) cout << i << " " << j << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string str;
bool flag = 0;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '?') {
if (i == 0)
str[i] = (str[i + 1] == 'a') ? 'b' : 'a';
else if (i == str.length() - 1)
str[i] = (str[i - 1] == 'a') ? 'b' : 'a';
else if (str[i - 1] != 'c' && str[i + 1] != 'c')
str[i] = 'c';
else if (str[i - 1] != 'b' && str[i + 1] != 'b')
str[i] = 'b';
else if (str[i - 1] != 'a' && str[i + 1] != 'a')
str[i] = 'a';
}
if (i == 0)
continue;
else if (str[i - 1] == str[i])
flag = 1;
}
if (flag)
cout << "-1" << endl;
else
cout << str << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[5005];
int tag[5005],s[5005];
int main()
{
int t;
scanf("%d",&t);
while (t--)
{
int n;
scanf("%d",&n);
for (int i=1;i<=n;i++)
scanf("%d",&tag[i]);
for (int i=1;i<=n;i++)
scanf("%d",&s[i]);
for (int i=1;i<=n;i++)
{
dp[i]=0;
for (int j=i-1;j>0;j--)
{
if (tag[i]==tag[j])
continue;
long long tmp=dp[i]+abs(s[i]-s[j]);
dp[i]=max(dp[i],dp[j]+abs(s[i]-s[j]));
dp[j]=max(dp[j],tmp);
}
}
printf("%I64d\n",*max_element(dp+1,dp+n+1));
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
string s;
cin >> s;
int a[n-1];
for(int i =0;i<n-1;i++)
a[i] = abs(s[i]-s[i+1]);
int cnt[3];
memset(cnt,0,sizeof(cnt));
for(int i =0;i<n-1;i++)
cnt[a[i]]++;
int to_check = 1;
if(cnt[1]==0){
to_check = 2;
for(int i =0;i<n-1;i++)
a[i]>>=1;
}
int res = 0;
for(int i =0;i<n-1;i++){
if(((n-2)&i) == i) // applying lucas theorem for mod 2
res^=a[i];
}
// cout << res << to_check << endl;
cout << (res%2)*to_check << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int SHIFT = 101;
const int LEN = 203;
const int D[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const char S[5] = "RULD";
int n;
int tx[410], ty[410];
queue<int> dir;
bool mat[LEN + 10][LEN + 10];
int ax, ay, bx, by;
int dist[LEN + 10][LEN + 10];
pair<int, int> from[LEN + 10][LEN + 10];
queue<pair<int, int> > q;
queue<int> dq;
int tmp[40010], tn;
bool tag[LEN + 10][LEN + 10];
inline bool canLeft(int x, int y) { return x < 0 || x >= LEN || y < 0; }
inline bool canRight(int x, int y) { return x < 0 || x >= LEN || y >= LEN; }
inline bool canUp(int x, int y) { return y < 0 || y >= LEN || x < 0; }
inline bool canDown(int x, int y) { return y < 0 || y >= LEN || x >= LEN; }
void move(int& ax, int& ay, int& bx, int& by, int d, int step) {
for (int i = 0; i < step; i++) {
putchar(S[d]);
ax += D[d][0];
ay += D[d][1];
bx += D[d][0];
by += D[d][1];
}
}
bool bfs() {
memset(dist, -1, sizeof(dist));
dist[ax][ay] = 0;
q.push(make_pair(ax, ay));
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int d = 0; d < 4; d++) {
int nx = cur.first + D[d][0];
int ny = cur.second + D[d][1];
if (nx >= 0 && nx < LEN && ny >= 0 && ny < LEN && dist[nx][ny] == -1 &&
!mat[nx][ny]) {
dist[nx][ny] = dist[cur.first][cur.second] + 1;
from[nx][ny] = cur;
q.push(make_pair(nx, ny));
}
}
}
if (dist[bx][by] == -1) return false;
int cx = bx, cy = by;
while (cx != ax || cy != ay) {
tag[cx][cy] = true;
int nx = from[cx][cy].first;
int ny = from[cx][cy].second;
if (cx == nx - 1)
tmp[tn++] = 2;
else if (cx == nx + 1)
tmp[tn++] = 0;
else if (cy == ny - 1)
tmp[tn++] = 3;
else
tmp[tn++] = 1;
cx = nx;
cy = ny;
}
for (int i = tn - 1; i >= 0; i--) dq.push(tmp[i]);
return true;
}
int main() {
scanf("%d%d%d%d%d", &ax, &ay, &bx, &by, &n);
ax += SHIFT;
ay += SHIFT;
bx += SHIFT;
by += SHIFT;
if (n == 0) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", tx + i, ty + i);
tx[i] += SHIFT;
ty[i] += SHIFT;
mat[tx[i]][ty[i]] = true;
}
if (!bfs()) {
printf("-1\n");
return 0;
}
while (((ax >= 0 && ax < LEN && ay >= 0 && ay < LEN) ||
(bx >= 0 && bx < LEN && by >= 0 && by < LEN)) &&
(ax != bx || ay != by)) {
int d = dq.front();
dq.pop();
ax += D[d][0];
ay += D[d][1];
putchar(S[d]);
int nx = bx + D[d][0];
int ny = by + D[d][1];
if (nx < 0 || nx >= LEN || ny < 0 || ny >= LEN || !mat[nx][ny]) {
bx = nx;
by = ny;
dq.push(d);
}
}
if (ax != bx || ay != by) {
if (ax > bx) {
int p = 1;
for (int i = 2; i <= n; i++)
if (tx[i] > tx[p]) p = i;
if (!canDown(ax, ay) || !canDown(bx, by)) {
if (canLeft(ax, ay) && canLeft(bx, by))
move(ax, ay, bx, by, 3, 30000);
else
move(ax, ay, bx, by, 1, 30000);
}
move(ax, ay, bx, by, 0, 30000);
while (by < ty[p]) {
++by;
++ay;
putchar('U');
}
while (by > ty[p]) {
--by;
--ay;
putchar('D');
}
while (bx - 1 > tx[p]) {
--bx;
--ax;
putchar('L');
}
while (ax > bx) {
--ax;
putchar('L');
}
move(ax, ay, bx, by, 0, 2 * LEN);
} else {
int p = 1;
for (int i = 2; i <= n; i++)
if (tx[i] < tx[p]) p = i;
if (!canUp(ax, ay) || !canUp(bx, by)) {
if (canLeft(ax, ay) && canLeft(bx, by))
move(ax, ay, bx, by, 3, 30000);
else
move(ax, ay, bx, by, 1, 30000);
}
move(ax, ay, bx, by, 2, 30000);
while (by < ty[p]) {
++by;
++ay;
putchar('U');
}
while (by > ty[p]) {
--by;
--ay;
putchar('D');
}
while (bx + 1 < tx[p]) {
++bx;
++ax;
putchar('R');
}
while (ax < bx) {
++ax;
putchar('R');
}
move(ax, ay, bx, by, 2, 2 * LEN);
}
if (ay > by) {
int p = 1;
for (int i = 2; i <= n; i++)
if (ty[i] > ty[p]) p = i;
if (!canRight(ax, ay) || !canRight(bx, by)) {
if (canUp(ax, ay) && canUp(bx, by))
move(ax, ay, bx, by, 2, 30000);
else
move(ax, ay, bx, by, 0, 30000);
}
move(ax, ay, bx, by, 1, 30000);
while (bx < tx[p]) {
putchar('R');
++bx;
++ax;
}
while (bx > tx[p]) {
putchar('L');
--bx;
--ax;
}
while (by - 1 > ty[p]) {
putchar('D');
--by;
--ay;
}
while (ay > by) {
putchar('D');
--ay;
}
move(ax, ay, bx, by, 1, 2 * LEN);
} else {
int p = 1;
for (int i = 2; i <= n; i++)
if (ty[i] < ty[p]) p = i;
if (!canLeft(ax, ay) || !canLeft(bx, by)) {
if (canUp(ax, ay) && canUp(bx, by))
move(ax, ay, bx, by, 2, 30000);
else
move(ax, ay, bx, by, 0, 30000);
}
move(ax, ay, bx, by, 3, 30000);
while (bx < tx[p]) {
putchar('R');
++bx;
++ax;
}
while (bx > tx[p]) {
putchar('L');
--bx;
--ax;
}
while (by + 1 < ty[p]) {
putchar('U');
++by;
++ay;
}
while (ay < by) {
putchar('U');
++ay;
}
move(ax, ay, bx, by, 3, 2 * LEN);
}
}
putchar('\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str = "";
cin >> str;
for (int i = 0; i < str.size();) {
if (str[i] == '-') {
if (str[i + 1] == '.')
cout << 1;
else if (str[i + 1] == '-')
cout << 2;
i += 2;
} else {
cout << 0;
i++;
}
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int N; cin >> N;
int K; cin >> K;
double ans = 0;
for(int i = 0 ; i < N ; i++){
double H = 1;
while((i+1)*H < K) H *= 2;
H = 1 / H;
ans += H;
}
printf("%.12f", ans / N);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt[2];
vector<int> arr[100];
int arr_index[210];
int main() {
int n, num, i, j, last = 2, k = 0;
cin >> n;
for (i = 0; i < 2 * n; i++) {
cin >> num;
arr[num].push_back(i);
}
for (i = 10; i <= 99; i++) {
if (arr[i].size() == 1) {
arr_index[arr[i][0]] = last ^ 3;
last = last ^ 3;
cnt[last]++;
}
}
if (cnt[1] < cnt[2])
last = 1;
else
last = 2;
for (i = 10; i <= 99; i++) {
k = 0;
if (arr[i].size() > 1) {
for (j = 0; j < arr[i].size(); j++) {
arr_index[arr[i][j]] = last;
last ^= 3;
}
cnt[1] += 1;
cnt[2] += 1;
}
}
cout << (cnt[1] * cnt[2]) << endl;
for (i = 0; i < 2 * n; i++) cout << arr_index[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10, MAXM = 400000 + 10;
int n, m, to[MAXM], nex[MAXM], beg[MAXN], fa[MAXN], dfn[MAXN], temp[MAXM],
e = 1, vis[MAXM], cnt;
struct node {
int x, y, z;
};
queue<node> Ans;
inline void read(int &x) {
int data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
data = (data << 3) + (data << 1) + (ch ^ '0'), ch = getchar();
x = data * w;
}
inline void insert(int x, int y) {
to[++e] = y;
nex[e] = beg[x];
beg[x] = e;
}
inline void bfs(int s) {
queue<int> q;
q.push(s);
fa[s] = -1;
cnt = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
dfn[++cnt] = x;
for (register int i = beg[x]; i; i = nex[i])
if (!fa[to[i]]) {
fa[to[i]] = x;
q.push(to[i]);
}
}
for (register int i = cnt; i >= 1; --i) {
int x = dfn[i];
temp[0] = 0;
for (register int i = beg[x]; i; i = nex[i])
if (!vis[i] && to[i] != fa[x]) temp[++temp[0]] = i;
for (register int i = beg[x]; i; i = nex[i])
if (!vis[i] && to[i] == fa[x]) temp[++temp[0]] = i;
for (register int i = 1; i + 1 <= temp[0]; i += 2) {
vis[temp[i]] = vis[temp[i] ^ 1] = vis[temp[i + 1]] =
vis[temp[i + 1] ^ 1] = 1;
node tmp;
tmp.x = to[temp[i]];
tmp.y = x;
tmp.z = to[temp[i + 1]];
Ans.push(tmp);
}
}
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= m; ++i) {
int u, v;
read(u);
read(v);
insert(u, v);
insert(v, u);
}
for (register int i = 1; i <= n; ++i)
if (!fa[i]) bfs(i);
printf("%d\n", (int)Ans.size());
while (!Ans.empty()) {
node tmp = Ans.front();
Ans.pop();
printf("%d %d %d\n", tmp.x, tmp.y, tmp.z);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string firsts = "23456789TJQKA";
string seconds = "CDHS";
int n, m;
string a[55][55];
vector<pair<string, string>> cur, ans;
vector<pair<int, int>> wh;
bool go(int x, int y) {
if (y == m) {
y = 0;
++x;
}
if (x == n) {
vector<pair<int, int>> goods;
for (int i1 = 0; i1 + 2 < n; ++i1) {
for (int j1 = 0; j1 + 2 < m; ++j1) {
set<char> f, s;
for (int x = 0; x < 3; ++x) {
for (int y = 0; y < 3; ++y) {
f.insert(a[i1 + x][j1 + y][0]);
s.insert(a[i1 + x][j1 + y][1]);
}
}
if (f.size() == 9u || s.size() == 1u) {
goods.emplace_back(i1, j1);
}
}
}
for (auto c1 : goods) {
for (auto c2 : goods) {
if (abs(c1.first - c2.first) >= 3 || abs(c1.second - c2.second) >= 3) {
ans = cur;
wh = {c1, c2};
return true;
}
}
}
return false;
}
string th = a[x][y];
if (th != "J1" && th != "J2") return go(x, y + 1);
for (char f : firsts) {
for (char s : seconds) {
string rep = {f, s};
bool ok = true;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) ok &= a[i][j] != rep;
if (!ok) continue;
a[x][y] = rep;
cur.emplace_back(th, rep);
if (go(x, y + 1)) return true;
cur.pop_back();
a[x][y] = th;
}
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
if (go(0, 0)) {
cout << "Solution exists.\n";
if (ans.empty()) {
cout << "There are no jokers.\n";
} else if (ans.size() == 1u) {
cout << "Replace " << ans[0].first << " with " << ans[0].second << ".\n";
} else {
string x = ans[0].second, y = ans[1].second;
if (ans[0].first != "J1") swap(x, y);
cout << "Replace J1 with " << x << " and J2 with " << y << ".\n";
}
cout << "Put the first square to (" << wh[0].first + 1 << ", "
<< wh[0].second + 1 << ").\n";
cout << "Put the second square to (" << wh[1].first + 1 << ", "
<< wh[1].second + 1 << ").\n";
} else {
cout << "No solution.\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
int n, cas, x, y, ans, vis[N], cnt[N];
int main() {
cin >> n;
for(int i = 1; i <= n; ++i)
cnt[i] = 1;
vis[1] = 1;
for(cin >> cas; cas--; ) {
scanf("%d%d", &x, &y);
vis[y] |= vis[x];
--cnt[x], ++cnt[y];
if(!cnt[x]) vis[x] = 0;
}
for(int i = 1; i <= n; ++i)
ans += vis[i];
printf("%d\n", ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long int
void print(vector<int> &A, int n){
for(int i=0; i<n; i++){
cout<<A[i]<<" ";
}
cout<<endl;
}
int32_t main(){
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int right=30, left=30;
int n = s.size();
int flag=1;
for(int i=0; i<n; i++){
if(s[i]=='a'){
right=i;
left=i;
}
}
for(int i=1; i<n; i++){
if(left>0 and s[left-1]=='a'+i){
left=left-1;
}else if(right<n-1 and s[right+1]=='a'+i){
right=right+1;
}else{
flag=0;
break;
}
}
if(flag==0){
cout<<"NO"<<endl;
continue;
}
if(left==0 and right==n-1){
cout<<"YES"<<endl;
}else{
cout<<"NO"<<endl;
}
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int n, l, k;
double probs[200];
int bags[200];
double dp[201][410][201];
double solve(int index, int currCapacity, int wonTours) {
if (index == n) {
if (wonTours >= l) {
if (currCapacity >= 0)
return 1.0;
else
return 0.0;
} else {
return 0.0;
}
}
double &calculated = dp[index][currCapacity + 201][wonTours];
if (calculated + 1.0 > 1e-4) return calculated;
double ans = 0.0;
ans = probs[index] * solve(index + 1, min(405, currCapacity + bags[index]),
wonTours + 1) +
(1.0 - probs[index]) * solve(index + 1, currCapacity, wonTours);
return calculated = ans;
}
int main() {
cin >> n >> l >> k;
memset(dp, -1.0, sizeof(dp));
for (int i = 0; i <= n - 1; i++) {
cin >> probs[i];
probs[i] /= 100.0;
}
for (int i = 0; i <= n - 1; i++) {
cin >> bags[i];
}
printf("%.10f", solve(0, k, 0));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool chkmin(long long &x, long long y) { return x > y ? x = y, 1 : 0; }
bool chkmax(long long &x, long long y) { return x < y ? x = y, 1 : 0; }
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct node {
long long x, bel, id;
bool operator<(const node c) const { return x < c.x; }
} p[400005];
int n, m, lazy;
int mch[400005];
long long s[400005], cnt[5][400005];
queue<int> q1, q2;
int main() {
m = readint();
n = readint();
for (int i = 1; i <= n; i++) p[i].x = readint(), p[i].bel = 1, p[i].id = i;
for (int i = 1; i <= n; i++)
p[i + n].x = readint(), p[i + n].bel = -1, p[i + n].id = i;
sort(p + 1, p + n + n + 1);
long long ans = 0;
for (int i = 1; i <= n + n; i++)
s[i] = s[i - 1] + p[i].bel, cnt[p[i].bel + 1][s[i] + n] += p[i].x;
for (int i = 1; i <= n + n; i++) {
if (p[i].bel * s[i] <= 0)
ans += p[i].x;
else
ans -= p[i].x;
}
long long res = ans, opt = 0;
for (int i = 1; i <= n + n - 1; i++) {
cnt[p[i].bel + 1][s[i] + n] -= p[i].x;
if (p[i].bel == 1) {
lazy--;
ans +=
2 * (cnt[p[i].bel + 1][n - lazy] - cnt[-p[i].bel + 1][n - lazy - 1]) +
m + 2 * p[i].x;
cnt[p[i].bel + 1][n - lazy] += p[i].x + m;
} else {
lazy++;
ans +=
2 * (cnt[p[i].bel + 1][n - lazy] - cnt[-p[i].bel + 1][n - lazy + 1]) +
m + 2 * p[i].x;
cnt[p[i].bel + 1][n - lazy] += p[i].x + m;
}
if (chkmin(res, ans)) opt = i;
}
printf("%lld\n", res);
for (int i = 1; i <= opt; i++) p[i].x += m;
sort(p + 1, p + n + n + 1);
for (int i = 1; i <= n + n; i++) {
if (p[i].bel == 1) {
if (q2.empty())
q1.push(i);
else
mch[p[i].id] = p[q2.front()].id, q2.pop();
} else {
if (q1.empty())
q2.push(i);
else
mch[p[q1.front()].id] = p[i].id, q1.pop();
}
}
for (int i = 1; i <= n; i++) printf("%d ", mch[i]);
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
double ans,f[305][305][35];
int n,C,L[9],id[9],i,j,k,mx,z;
int main(){
scanf("%d%d",&n,&C);mx=C*n;
for(i=1;i<=n;++i)scanf("%d",L+i),id[i]=i;
sort(L+1,L+n+1);
do{
memset(f,0,sizeof f);f[0][L[n]*n][0]=1;
for(i=0;i<mx;++i)for(j=i;j<=mx;++j)for(k=0;k<1<<n-1;++k)if(f[i][j][k]>0){
if(i<j)f[i+1][j][k]+=f[i][j][k];
z=i%n;if(z && !(k>>z-1&1))f[i+1][min(mx,max(j,i+L[id[z]]*n))][k|(1<<z-1)]+=f[i][j][k]/C;
}
ans+=f[mx][mx][(1<<n-1)-1];
}while(next_permutation(id+1,id+n));
for(i=1;i<n;++i)ans/=i;printf("%.14f\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++){
cin >> A[i];
}
vector<int> S(N + 1, 0);
for (int i = 0; i < N; i++){
S[i + 1] = (S[i] + A[i]) % M;
}
map<int, int> cnt;
long long ans = 0;
for (int i = 0; i <= N; i++){
ans += cnt[S[i]];
cnt[S[i]]++;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
long long X, Y;
long long dx, dy;
string cmd;
int mx[] = {0, 0, -1, 1};
int my[] = {1, -1, 0, 0};
pair<long long, long long> rax, ray;
int main() {
cin >> X >> Y;
cin >> cmd;
if (X == 0 && Y == 0) {
cout << "Yes" << endl;
return 0;
}
for (int i = (0); i < (int((cmd).size())); i++) {
switch (cmd[i]) {
case 'U':
cmd[i] = 0;
break;
case 'D':
cmd[i] = 1;
break;
case 'L':
cmd[i] = 2;
break;
case 'R':
cmd[i] = 3;
break;
}
}
dx = dy = 0;
rax = ray = pair<long long, long long>(0, 0);
for (int i = (0); i < (int((cmd).size())); i++) {
dx += mx[cmd[i]];
dy += my[cmd[i]];
rax = pair<long long, long long>(min(rax.first, dx), max(rax.second, dx));
ray = pair<long long, long long>(min(ray.first, dy), max(ray.second, dy));
if (X == dx && Y == dy) {
cout << "Yes" << endl;
return 0;
}
}
if (dx == 0 && dy == 0) {
cout << "No" << endl;
return 0;
}
int m = max(min(abs(X - rax.first), abs(X - rax.second)) / max(1LL, abs(dx)),
min(abs(Y - ray.first), abs(Y - ray.second)) / max(1LL, abs(dy)));
m = max(0, m - 101);
int x = m * dx;
int y = m * dy;
for (int j = (0); j < (202); j++) {
for (int i = (0); i < (int((cmd).size())); i++) {
x += mx[cmd[i]];
y += my[cmd[i]];
if (X == x && Y == y) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr int INF = INT32_MAX;
constexpr int MAXN = 2e6 + 10;
constexpr double eps = 1e-8;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
using Vec = vector<int>;
template <class T>
void Min(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void Max(T &a, T b) {
if (b > a) a = b;
}
ll N, M, K, T;
string s;
int ans[10][10];
int dp[10][10][10][10];
void Solution() {
memset(dp, -1, sizeof dp);
for (int i = (int)(0); i < (int)(10); ++i) {
for (int j = (int)(i); j < (int)(10); ++j) {
for (int f = (int)(0); f < (int)(10); ++f) {
dp[i][j][f][(f + i) % 10] = 1;
dp[i][j][f][(f + j) % 10] = 1;
while (true) {
bool n = false;
for (int t = (int)(0); t < (int)(10); ++t) {
if (dp[i][j][f][t] != -1) {
if (dp[i][j][f][(t + i) % 10] == -1 ||
dp[i][j][f][(t + i) % 10] > dp[i][j][f][t] + 1) {
dp[i][j][f][(t + i) % 10] = dp[i][j][f][t] + 1;
n = true;
}
if (dp[i][j][f][(t + j) % 10] == -1 ||
dp[i][j][f][(t + j) % 10] > dp[i][j][f][t] + 1) {
dp[i][j][f][(t + j) % 10] = dp[i][j][f][t] + 1;
n = true;
}
}
}
if (!n) break;
}
}
}
}
for (int i = (int)(0); i < (int)(10); ++i) {
for (int j = (int)(i); j < (int)(10); ++j) {
ll t = 0;
for (int k = (int)(1); k < (int)(s.size()); ++k) {
int a = s[k - 1] - '0';
int b = s[k] - '0';
if (dp[i][j][a][b] == -1) {
t = -1;
break;
} else {
t += dp[i][j][a][b] - 1;
}
}
ans[i][j] = ans[j][i] = t;
}
}
for (int i = (int)(0); i < (int)(10); ++i) {
for (int j = (int)(0); j < (int)(10); ++j) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
while (cin >> s) {
Solution();
}
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
struct P{
int tx,ty;
int kx,ky;
int cost;
P(int _tx, int _ty, int _kx, int _ky, int _cost) : tx(_tx), ty(_ty), kx(_kx), ky(_ky), cost(_cost) {};
};
int hx,hy,rx,ry;
int X,Y;
int mas[110][110];
bool d[51][51][51][51];
int dx[4] = {0,1,0,-1},dy[4] = {1,0,-1,0};
int bfs();
int main(){
while(1){
scanf("%d %d",&X,&Y);
if(X == 0 && Y == 0)break;
scanf("%d %d",&hx,&hy);
scanf("%d %d",&rx,&ry);
for(int i = 1; i <= Y; i++){
for(int j = 1; j <= X; j++){
scanf("%d",&mas[i][j]);
}
}
int ans = bfs();
if(ans == -1)cout << "NA" << endl;
else cout << ans << endl;
}
}
int bfs(){
queue<P> que;
memset(d,0,sizeof(d));
que.push(P(hx,hy,rx,ry,0));
d[hx][hy][rx][ry] = 0;
while(!que.empty()){
P p = que.front();
que.pop();
if(p.cost >= 100)return -1;
if(p.tx == p.kx && p.ty == p.ky){
return p.cost;
}
for(int i = 0; i < 4; i++){
int nx = p.tx + dx[i], ny = p.ty + dy[i];
int ux = p.kx - dx[i], uy = p.ky - dy[i];
if(nx > 0 && ny > 0 && ux > 0 && uy > 0 && nx <= X && ny <= Y && ux <= X && uy <= Y && mas[ny][nx] != 1 && mas[uy][ux] != 1 && d[nx][ny][ux][uy] == 0){
que.push(P(nx,ny,ux,uy,p.cost + 1));
d[nx][ny][ux][uy] = 1;
}
else if((nx <= 0 || nx > X || ny <= 0 || ny > Y || mas[ny][nx] == 1) && ux <= X && uy <= Y && ux > 0 && uy > 0 && mas[uy][ux] != 1 && d[p.tx][p.ty][ux][uy] == 0){
que.push(P(p.tx,p.ty,ux,uy,p.cost + 1));
d[p.tx][p.ty][ux][uy] = 1;
}
else if((ux <= 0 || ux > X || uy <= 0 || uy > Y || mas[uy][ux] == 1) && nx <= X && ny <= Y && nx > 0 && ny > 0 && mas[ny][nx] != 1 && d[nx][ny][p.kx][p.ky] == 0){
que.push(P(nx,ny,p.kx,p.ky,p.cost + 1));
d[nx][ny][p.kx][p.ky] = 1;
}
}
}
return -1;
} | 0 |
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
int main(){
int n;
scanf("%d",&n);
vector<int> x(1<<n),r(1<<n),m(1<<n);
for(auto &e:x)scanf("%d",&e);
for(int i=0;i<1<<n;i++){
for(int j=i;j<1<<n;j=(j+1)|i){
r[j]=max(r[j],x[i]+m[j]);
m[j]=max(m[j],x[i]);
}
}
for(int i=1;i<1<<n;i++){
r[i]=max(r[i],r[i-1]);
printf("%d\n",r[i]);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int INF = 10000000000000;
long long int a, b, x, y;
long long int gcd(long long int a, long long int b) {
long long int r = a % b;
while (r) {
a = b;
b = r;
r = a % b;
}
return b;
}
void input() {
cin >> a >> b >> x >> y;
long long int tmp_x = x / gcd(x, y);
long long int tmp_y = y / gcd(x, y);
long long int l = 0, r = 2e9 + 7;
while (l <= r) {
long long int mid = (l + r) >> 1;
if (mid * tmp_x <= a && mid * tmp_y <= b)
l = mid + 1;
else
r = mid - 1;
}
cout << tmp_x * (l - 1) << " " << tmp_y * (l - 1);
}
int main() {
input();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, n, p, k;
cin >> n >> p >> k;
bool f = 0;
if (p - k > 1) cout << "<< ";
for (i = p - k; i < p; i++) {
if (p - k <= 0 && f == 0) {
if (p > 1) {
i = 1;
f = 1;
cout << i << " ";
continue;
} else
break;
}
cout << i << " ";
}
cout << "(" << p << ") ";
for (i = p + 1; i <= p + k; i++) {
if (i > n) return 0;
cout << i << " ";
if (i == n) return 0;
}
cout << ">>" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const MAX = 2e5 + 41;
int const ADD = 1;
int const DEL = 2;
int const ASK = 3;
int gcd(int a, int b) { return (a ? gcd(b % a, a) : b); }
struct Point {
int x, y;
Point(){};
Point(int x, int y) : x(x), y(y){};
bool operator<(const Point &a) const {
if (x != a.x) return x < a.x;
return y < a.y;
};
bool operator==(const Point &a) const { return (x == a.x && y == a.y); };
long long distance() { return (long long)x * x + (long long)y * y; }
Point normalize() { return Point(x / gcd(x, y), y / gcd(x, y)); }
Point getsym(Point a) { return Point(x + a.x, y + a.y).normalize(); }
};
Point p[MAX];
int type[MAX];
int q;
int dt[MAX];
long long const MAGIC = 2e5 + 41;
struct Hash {
long long operator()(const Point &a) const { return a.x * MAGIC + a.y; };
};
vector<Point> vp[MAX];
unordered_map<Point, int, Hash> tdir;
unordered_map<Point, int, Hash> tsym;
void pushpoint(Point p, vector<Point> &vp) {
vp.push_back(p);
tdir[p.normalize()]++;
for (int i = 0; i <= (int)vp.size() - 2; i++) {
Point ps = p.getsym(vp[i]);
tsym[ps.normalize()] += 2;
}
}
void poppoint(Point p, vector<Point> &vp) {
tdir[p.normalize()]--;
bool f = false;
for (int i = 0; i <= (int)vp.size() - 1; i++) {
if (vp[i] == p) {
swap(vp[i], vp[(int)vp.size() - 1]);
f = 1;
break;
}
}
assert(f);
for (int i = 0; i <= (int)vp.size() - 2; i++) {
Point ps = p.getsym(vp[i]);
tsym[ps.normalize()] -= 2;
}
vp.pop_back();
}
void solve() {
vector<long long> v;
for (int i = 1; i <= q; i++) {
v.push_back(p[i].distance());
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (int i = 1; i <= q; i++) {
dt[i] = (int)(lower_bound(v.begin(), v.end(), p[i].distance()) - v.begin());
}
int cnt = 0;
for (int i = 1; i <= q; i++) {
if (type[i] == ADD) {
pushpoint(p[i], vp[dt[i]]);
cnt++;
} else if (type[i] == DEL) {
poppoint(p[i], vp[dt[i]]);
cnt--;
} else {
int res = cnt;
res -= tdir[p[i].normalize()];
res -= tsym[p[i].normalize()];
printf("%d\n", res);
}
}
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d %d", &type[i], &p[i].x, &p[i].y);
}
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int min=10000000;
for(int i=0;i<N;i++){
int a,b=0;
cin >> a;
while(a%2==0){
a=a/2;
b++;
}
if(b<min)min=b;
}
cout << min;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100001;
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1ll * 1000000 * 1000000 * 1000000;
void solve() {
int n;
cin >> n;
int x;
cin >> x;
;
int a[MAX_N] = {0};
int b[MAX_N] = {0};
vector<int> ar(n);
bool ans0, ans1, ans2;
ans0 = ans1 = ans2 = false;
for (int i = 0; i < n; ++i) {
cin >> ar[i];
a[ar[i]]++;
if (a[ar[i]] == 2) {
ans0 = true;
}
}
if (ans0) {
cout << 0;
return;
}
int cb;
for (int i = 0; i < n; ++i) {
cb = ar[i] & x;
b[cb]++;
if (b[cb] == 2) {
ans2 = true;
}
if (cb != ar[i]) {
if (a[cb] == 1) {
ans1 = true;
}
}
}
if (ans1) {
cout << 1;
} else if (ans2) {
cout << 2;
} else {
cout << -1;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
cout << endl;
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs"
<< "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
static const int MOD = 1000000007;
using ll = long long;
using uint = unsigned;
using ull = unsigned long long;
using namespace std;
template <class T>
constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
int main() {
int n;
cin >> n;
vector<int> A(n), B(n);
for (auto &&i : A) scanf("%d", &i);
for (auto &&i : B) scanf("%d", &i);
vector<int> p(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (A[i] == B[j]) {
p[j] = i;
B[j] = 0;
break;
}
}
}
vector<int> ans;
for (int i = 0; i < n; ++i) {
for (int j = 0; j + 1 < n; ++j) {
if (p[j] > p[j + 1]) {
swap(p[j], p[j + 1]);
ans.emplace_back(j + 1);
}
}
}
cout << ans.size() << "\n";
for (auto &&i : ans) printf("%d %d\n", i, i + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
using namespace std;
void sol() {
int n, first;
cin >> n >> first;
int ce = 0, co = 0;
for (int(i) = (0); (i) < (n); (i)++) {
int a;
cin >> a;
if (a % 2 == 0)
ce++;
else
co++;
}
for (int i = 1; i <= first; i += 2) {
if (co >= i && ce >= first - i) {
cout << "Yes" << '\n';
return;
}
}
cout << "No" << '\n';
}
int main() {
int t;
cin >> t;
while (t--) sol();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
set<char> a;
for (int i = 0; i < n; i++) {
a.insert(s[i]);
}
char ch = *(--a.end());
if (n < k) {
ch = *(a.begin());
cout << s;
for (int i = 0; i < k - n; i++) cout << ch;
return 0;
}
for (int i = k - 1; i >= 0; i--) {
if (ch > s[i]) {
for (auto &el : a) {
if (el > s[i] && el < ch) {
ch = el;
}
}
for (int j = 0; j < i; j++) {
cout << s[j];
}
cout << ch;
ch = *(a.begin());
for (int j = i + 1; j < k; j++) cout << ch;
break;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10, LG = 22;
int n;
string s;
int seg[MAXN * 4], dp[MAXN], lcp[MAXN][LG], rnk[MAXN][LG], res;
vector<pair<pair<int, int>, int> > vec;
int LCP(int i1, int i2) {
if (i1 > i2) swap(i1, i2);
int ans = 0;
for (int b = LG - 1; b >= 0; b--) {
if (i1 + (1 << b) <= n + 1 && rnk[i1][b] == rnk[i2][b]) {
i1 += (1 << b);
i2 += (1 << b);
ans += (1 << b);
}
}
return ans;
}
void add(int ind, int val, int b = 0, int e = n, int id = 1) {
if (b + 1 == e) {
seg[id] = val;
return;
}
int mid = (b + e) / 2;
if (ind < mid)
add(ind, val, b, mid, id * 2);
else
add(ind, val, mid, e, id * 2 + 1);
seg[id] = max(seg[id * 2], seg[id * 2 + 1]);
}
int get(int l, int r, int b = 0, int e = n, int id = 1) {
if (r <= b || e <= l) return 0;
if (l <= b && e <= r) return seg[id];
int mid = (b + e) / 2;
return max(get(l, r, b, mid, id * 2), get(l, r, mid, e, id * 2 + 1));
}
bool ok(int i, int val) {
int p1 = rnk[i][LG - 1], p2 = rnk[i][LG - 1];
for (int b = LG - 1; b >= 0; b--) {
if (p2 + (1 << b) < n && lcp[p2][b] >= val) p2 = p2 + (1 << b);
if (p1 - (1 << b) >= 0 && lcp[p1 - (1 << b)][b] >= val) p1 = p1 - (1 << b);
}
return val <= get(p1, p2 + 1);
}
int id[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
for (int i = 0; i < n; i++) rnk[i][0] = s[i] - 'a';
for (int b = 0; b <= LG - 2; b++) {
vec.clear();
for (int i = 0; i < n; i++) {
if (i + (1 << b) >= n) {
vec.push_back({{rnk[i][b], -1}, i});
continue;
}
vec.push_back({{rnk[i][b], rnk[i + (1 << b)][b]}, i});
}
sort(vec.begin(), vec.end());
rnk[vec[0].second][b + 1] = 0;
for (int i = 1; i < n; i++) {
int id1 = vec[i - 1].second, id2 = vec[i].second;
rnk[id2][b + 1] = rnk[id1][b + 1] + 1;
if (vec[i].first == vec[i - 1].first) rnk[id2][b + 1]--;
}
}
for (int i = 0; i < n; i++) id[rnk[i][LG - 1]] = i;
for (int i = n - 2; i >= 0; i--) {
lcp[i][0] = LCP(id[i], id[i + 1]);
for (int b = 1; b < LG; b++) {
if (i + (1 << b) >= n) break;
lcp[i][b] = min(lcp[i + (1 << (b - 1))][b - 1], lcp[i][b - 1]);
}
}
res = dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
dp[i] = dp[i + 1] + 1;
while (dp[i] && !ok(i, dp[i] - 1) && !ok(i + 1, dp[i] - 1)) {
dp[i]--;
add(rnk[dp[i] + i][LG - 1], dp[dp[i] + i]);
}
res = max(res, dp[i]);
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const double PI = atan2(1, 0) * 2;
const double TAU = atan2(1, 0) * 4;
const int MAXN = 200005;
const int MAXT = 400005;
struct bit {
int tree[MAXT];
void add(int x, int v) {
x += 2;
for (int i = x; i < MAXT; i += i & -i) tree[i] += v;
}
int query(int x) {
x += 2;
int ret = 0;
for (int i = x; i; i -= i & -i) ret += tree[i];
return ret;
}
int query(int s, int e) { return query(e) - query(s - 1); }
void clear() { memset(tree, 0, sizeof(tree)); }
} bit;
struct queryI {
int pos, s, e, x;
bool operator<(const queryI &q) const { return pos < q.pos; }
};
struct pointI {
int x, y;
bool operator<(const pointI &p) const { return x < p.x; }
};
lint solve(vector<queryI> query, vector<pointI> point) {
sort((point).begin(), (point).end());
sort((query).begin(), (query).end());
bit.clear();
lint ret = 0;
int j = 0;
for (auto &i : query) {
while (j < ((int)(point).size()) && point[j].x <= i.pos) {
bit.add(point[j++].y, +1);
}
ret += i.x * bit.query(i.s, i.e);
}
return ret;
}
int n;
pair<double, double> pts[MAXN];
pair<double, double> ranges[MAXN];
lint solve(double dist) {
lint cnt = 0;
int N = 0;
for (int i = 0; i < n; i++) {
if (pts[i].first <= dist) continue;
double angRange = acos(dist / pts[i].first);
double a = pts[i].second - angRange;
double b = pts[i].second + angRange;
if (a < 0) a += TAU, b += TAU;
ranges[N++] = {a, b};
}
sort(ranges, ranges + N);
vector<double> coords;
for (int i = 0; i < N; i++) {
ranges[i + N].first = ranges[i].first + TAU;
ranges[i + N].second = ranges[i].second + TAU;
}
for (int i = 0; i < 2 * N; i++) {
coords.push_back(ranges[i].first);
coords.push_back(ranges[i].second);
}
sort((coords).begin(), (coords).end());
coords.resize(unique((coords).begin(), (coords).end()) - coords.begin());
auto comp = [&](double x) {
int ans = lower_bound((coords).begin(), (coords).end(), x) - coords.begin();
return ans;
};
vector<queryI> query;
vector<pointI> point;
for (int i = 0; i < N; i++) {
int s = comp(ranges[i].second);
int e = comp(ranges[i + N].first);
query.push_back({e, s, e, +1});
query.push_back({s - 1, s, e, -1});
}
for (int i = 0; i < 2 * N; i++) {
int s = comp(ranges[i].first);
int e = comp(ranges[i].second);
point.push_back({s, e});
}
cnt = solve(query, point) / 2;
query.clear();
point.clear();
for (int i = 0; i < N; i++) {
int s = comp(ranges[i].first);
int e = comp(ranges[i].second);
query.push_back({e, s, e, +1});
query.push_back({s - 1, s, e, -1});
}
for (int i = 0; i < 2 * N; i++) {
int s = comp(ranges[i].first);
int e = comp(ranges[i].second);
point.push_back({s, e});
}
cnt += solve(query, point) - N;
cnt = 1ll * N * (N - 1) / 2 - cnt;
return 1ll * n * (n - 1) / 2 - cnt;
}
using pi = pair<int, int>;
lint ccw(pi a, pi b, pi c) {
int dx1 = b.first - a.first;
int dy1 = b.second - a.second;
int dx2 = c.first - a.first;
int dy2 = c.second - a.second;
return 1ll * dx1 * dy2 - 1ll * dy1 * dx2;
}
lint dot(pi a, pi b, pi c) {
int dx1 = b.first - a.first;
int dy1 = b.second - a.second;
int dx2 = c.first - a.first;
int dy2 = c.second - a.second;
return 1ll * dx1 * dx2 + 1ll * dy1 * dy2;
}
pair<int, int> a[MAXN];
int main() {
lint k;
auto isGood = [&](double x) {
lint ff = solve(x);
return ff < k;
};
scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
lint x, y;
x = a[i].first;
y = a[i].second;
pts[i].first = double(sqrt(x * x + y * y));
pts[i].second = atan2(y, x);
if (pts[i].second < 0) pts[i].second += 2 * PI;
}
auto fnfn = [&]() {
double mi = 0, ma = 2e4;
if (isGood(1)) {
mi = 1;
for (int z = 0; z < 30; z++) {
double md = mi * sqrt(ma / mi);
if (isGood(md)) {
mi = md;
} else {
ma = md;
}
}
} else {
ma = min(ma, 1.);
for (int z = 0; z < 30; z++) {
double md = mi + (ma - mi) / 2;
if (isGood(md)) {
mi = md;
} else {
ma = md;
}
}
}
return mi;
};
printf("%.69f\n", fnfn());
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[3] = {0};
long long solve();
int main() {
while(1) {
bool allzero = 1;
for(int i = 0; i < 3; ++i) cnt[i] = 0;
for(int i = 0; i < 6; ++i) {
long long a;
cin >> a;
if(a != 0) allzero = 0;
cnt[i % 3] += a;
}
if(allzero) break;
cout << solve() << endl;
}
return 0;
}
long long solve() {
long long ans = 0;
for(int i = 0; i < 3; ++i) {
long long now = i;
bool ch = 1;
for(int j = 0; j < 3; ++j) {
if(cnt[j] - i < 0) {
ch = 0;
break;
}
now += (cnt[j] - i) / 3;
}
if(ch) ans = max(ans, now);
}
return ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(
(unsigned)chrono::system_clock::now().time_since_epoch().count());
const long double PI = acosl(-1);
vector<pair<int, long long int>> info;
int xorGaussian(vector<long long int>& rows, long long int XOR) {
int r = 0, n = (int)rows.size();
info.resize(n);
for (int i = 0; i < n; i++) info[i] = {i, 0ll};
for (int x = 0; x < 2; x++) {
for (int c = 63; c >= 0; c--) {
if (((XOR >> c) & 1) != x) continue;
int p;
for (p = r; p < n; p++)
if (rows[p] & (1LL << (c))) break;
if (p == n) continue;
if (p != r) {
swap(rows[p], rows[r]);
swap(info[p], info[r]);
}
info[r].second |= (1LL << (r));
for (int i = 0; i < n; i++) {
if (i != r && (rows[i] & (1LL << (c)))) {
rows[i] ^= rows[r];
info[i].second ^= info[r].second;
}
}
r++;
}
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
vector<long long int> input(n);
long long int XOR = 0;
for (int i = 0; i < n; i++) {
cin >> input[i];
XOR ^= input[i];
}
int m = xorGaussian(input, XOR);
long long int mask = 0;
for (int i = 0; i < m; i++) {
mask ^= info[i].second;
}
vector<int> ans(n, 1);
for (int i = 63; i >= 0; i--) {
if (mask & (1LL << (i))) {
ans[info[i].first] = 2;
}
}
for (int x : ans) {
cout << x << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q, n;
cin >> q;
for (long long i = 1; i <= q; i++) {
cin >> n;
int kq;
if (n == 2) {
kq = 2;
} else if (n % 2 == 0) {
kq = 0;
} else {
kq = 1;
}
cout << kq << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int testCases;
cin >> testCases;
while (testCases--) {
int a, b;
cin >> a >> b;
if (a == b)
cout << 0 << endl;
else if (a > b && ((a - b) % 2 == 0) || b > a && ((b - a) % 2 != 0))
cout << 1 << endl;
else
cout << 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> occ[27];
int mem[27][5001][27], p[27][5001];
int main() {
string second;
cin >> second;
int n = second.size();
for (int i = 0; i < n; i++) occ[second[i] - 'a'].push_back(i);
double ans = 0;
for (int i = 0; i < 27; i++) {
for (int j : occ[i]) {
for (int k = j + 1; k < (j + n); k++)
mem[i][(k - j)][second[(k % n)] - 'a']++;
}
for (int j : occ[i]) {
for (int k = 1; k < n; k++) {
if (mem[i][k][second[(k + j) % n] - 'a'] == 1) p[i][k]++;
}
}
if (occ[i].size() != 0) ans += *max_element(p[i], p[i] + 5001);
}
cout << fixed << setprecision(9) << ans / double(n) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 4;
const int LIM = 6e5 + 3;
std::vector<int> adj[LIM + 3];
pair<int, int> a[LIM + 3];
bool vis[LIM + 3];
void dfs(int u) {
vis[u] = 1;
for (auto v : adj[u])
if (!vis[v]) dfs(v);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
a[i] = make_pair(x, y);
}
sort(a, a + n);
set<pair<pair<int, int>, int> > cur;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x = a[i].first, y = a[i].second;
vector<pair<pair<int, int>, int> > del;
for (auto el : cur) {
if (el.first.first < x)
del.push_back(el);
else if (el.first.first > y)
break;
else {
adj[i].push_back(el.second);
adj[el.second].push_back(i);
cnt++;
}
}
if (cnt >= n) break;
for (auto el : del) cur.erase(el);
cur.insert(make_pair(make_pair(y, x), i));
}
if (cnt != n - 1)
puts("NO");
else {
dfs(0);
bool ans = true;
for (int i = 0; i < n; i++)
if (!vis[i]) ans = 0;
if (ans)
puts("YES");
else
puts("NO");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
int n;
long long k;
int num[105];
int judge(long long x) {
long long ans = 0;
for (int i = 1; i <= n; i++) ans = ans + ((long long)num[i] + x - 1) / x;
if (ans * x <= k) return 1;
return 0;
}
int main() {
while (scanf("%d%I64d", &n, &k) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
k += num[i];
}
long long lim = (long long)sqrt((double)k) + 1;
long long ans = 0;
for (long long i = 1; i <= lim; i++) {
if (judge(i)) ans = max(ans, i);
if (judge(k / i)) ans = max(ans, k / i);
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, x, s = 0, ans1 = 0, ans2 = 0;
cin >> n >> x;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
if (s % x)
cout << n << "\n";
else {
long long sum1 = 0, sum2 = 0;
for (long long i = 0; i < n; i++) {
sum1 += a[i];
if (sum1 % x) {
ans1 = n - i - 1;
break;
}
}
for (long long i = n - 1; i >= 0; i--) {
sum2 += a[i];
if (sum2 % x) {
ans2 = i;
break;
}
}
long long ans = max(ans1, ans2);
if (ans == 0)
cout << -1 << "\n";
else
cout << ans << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
int main() {
int n;
cin >> n;
int a[6] = {n >> 5 & 1, n >> 4 & 1, n >> 3 & 1,
n >> 2 & 1, n >> 1 & 1, n & 1};
int b[6] = {a[0], a[5], a[3], a[2], a[4], a[1]};
int ans = 0;
for (int i = 0; i < 6; i++) ans = ans << 1 | b[i];
cout << ans << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.