solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
int ans = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (a[j] >= i) cnt++;
}
if (cnt >= i) {
if (i > ans) ans = i;
}
}
cout << ans << endl;
}
int main() {
int k;
cin >> k;
for (int i = 0; i < k; i++) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
const double Pi = acos(-1.0);
using namespace std;
const int maxN = 1000005;
const long long mod = 1000000007;
int n, k;
long long fact[maxN];
long long dp[maxN], sum[maxN];
long long exp(long long x, long long p) {
long long res = 1;
while (p) {
if (p & 1) res = (res * x) % mod;
x = (x * x) % mod;
p >>= 1;
}
return res;
}
int main(int argc, char** argv) {
scanf("%d %d", &n, &k);
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % mod;
for (int i = k + 2; i <= n; i++) {
dp[i] = ((i - k - 1) + (sum[i - 1] - sum[i - k - 1]) + mod) % mod;
dp[i] = (dp[i] * fact[i - 2]) % mod;
sum[i] = (sum[i - 1] + (dp[i] * exp(fact[i - 1], mod - 2)) % mod) % mod;
}
printf("%lld\n", (sum[n] * fact[n - 1]) % mod);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
int n, m, h, t, i;
int deg[N], ss[N], ff[N], pred[N], last[N], used[N];
int main() {
scanf("%d %d %d %d", &n, &m, &h, &t);
for (i = 0; i < m; i++) scanf("%d %d", ss + i, ff + i);
for (i = 0; i < m; i++) {
ss[i + m] = ff[i];
ff[i + m] = ss[i];
}
for (i = 1; i <= n; i++) last[i] = -1;
for (i = 0; i < m + m; i++) {
pred[i] = last[ss[i]];
last[ss[i]] = i;
}
memset(deg, 0, sizeof(deg));
for (i = 0; i < m; i++) deg[ss[i]]++, deg[ff[i]]++;
for (i = 1; i <= n; i++) used[i] = 0;
int it = 0;
for (i = 0; i < m + m; i++)
if (deg[ss[i]] >= h + 1 && deg[ff[i]] >= t + 1) {
int good = 0;
if (deg[ss[i]] >= h + t + 2 || deg[ff[i]] >= h + t + 2) good = 1;
if (!good) {
it++;
int cnt = 0;
int j = last[ss[i]];
while (j >= 0) {
if (used[ff[j]] != it) {
used[ff[j]] = it;
cnt++;
}
j = pred[j];
}
j = last[ff[i]];
while (j >= 0) {
if (used[ff[j]] != it) {
used[ff[j]] = it;
cnt++;
}
j = pred[j];
}
if (cnt >= h + t + 2) good = 1;
}
if (good) {
printf("YES\n");
printf("%d %d\n", ss[i], ff[i]);
int ii;
for (ii = 1; ii <= n; ii++) used[ii] = 0;
int j = last[ss[i]];
while (j >= 0) {
used[ff[j]] |= 1;
j = pred[j];
}
j = last[ff[i]];
while (j >= 0) {
used[ff[j]] |= 2;
j = pred[j];
}
used[ss[i]] = 0;
used[ff[i]] = 0;
vector<int> b, c;
b.clear();
c.clear();
for (ii = 1; ii <= n; ii++)
if (used[ii] == 1)
b.push_back(ii);
else if (used[ii] == 2)
c.push_back(ii);
for (ii = 1; ii <= n; ii++)
if (used[ii] == 3)
if (b.size() < h)
b.push_back(ii);
else
c.push_back(ii);
for (i = 0; i < h - 1; i++) printf("%d ", b[i]);
printf("%d\n", b[h - 1]);
for (i = 0; i < t - 1; i++) printf("%d ", c[i]);
printf("%d\n", c[t - 1]);
return 0;
}
}
printf("NO\n");
return 0;
}
| 2 |
// Verified @ GRL_3_A
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i,n) for(int i=0;i<(int)n;++i)
//debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template < typename T >
void vprint(T &v, int size){
REP(i, size){
cout << v[i] << " ";
}
cout << endl;
}
ll N, M;
vector<ll> G[101010];
vector<ll> dfs_tree[101010];
vector<ll> low(101010);
vector<ll> ord(101010, -1);
ll cnt = 0;
void dfs(ll now, ll par){
ord[now] = cnt;
cnt++;
low[now] = ord[now];
REP(i, G[now].size()){
ll next = G[now][i];
if(ord[next] == -1){
dfs_tree[now].push_back(next);
dfs(next, now);
low[now] = min(low[now], low[next]);
}else if(next != par){
low[now] = min(low[now], ord[next]);
}
}
return;
}
vector<pll> enum_bridge(){
// construct lowlink
ll root = 0;
dfs(root, -1);
// enumerate bridge
vector<pll> res;
REP(i, N){
REP(j, dfs_tree[i].size()){
if(ord[i] < low[dfs_tree[i][j]]){
res.push_back({i, dfs_tree[i][j]});
}
}
}
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
REP(i, M){
int s, t;
cin >> s >> t;
G[s].push_back(t);
G[t].push_back(s);
}
auto res = enum_bridge();
REP(i, res.size()) if(res[i].first > res[i].second) swap(res[i].first, res[i].second);
sort(res.begin(), res.end());
REP(i, res.size()){
cout << res[i].first << " " << res[i].second << endl;
}
//vprint(low, N);
//vprint(ord, N);
return 0;
}
| 0 |
#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<complex>
#include<tuple>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
typedef pair<double,ll> pdl;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;
double t,e,p;
ll K;
double dfs(ll d,double l,double r){
if(t-e<=l && r<=t+e){return 1;}
if(r<t-e || t+e<l){return 0;}
if(d==K){
return (abs((l+r)/2-t)<=e?1:0);
}
if((l+r)/2>=t){
return dfs(d+1,l,(l+r)/2.0)*(1.0-p)+dfs(d+1,(l+r)/2.0,r)*p;
}
return dfs(d+1,l,(l+r)/2.0)*p+dfs(d+1,(l+r)/2.0,r)*(1.0-p);
}
int main(){
double l,r;
cin>>K>>l>>r>>p>>e>>t;
cout<<fixed<<setprecision(12)<<dfs(0,l,r)<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void debug_vars(const char* data, TH head) {
cerr << data << "=" << head << "\n";
}
template <typename TH, typename... TA>
void debug_vars(const char* data, TH head, TA... tail) {
while (*data != ',') cerr << *data++;
cerr << "=" << head << ",";
debug_vars(data + 1, tail...);
}
template <typename T>
struct RevertibleVector {
vector<T> data;
vector<pair<int, T>> changes;
int curState;
RevertibleVector() : curState(0) {}
RevertibleVector(int size) : curState(0) { data.resize(size); }
void resize(int size) { data.resize(size); }
int getState() const { return curState; }
T get(int pos) const { return data[pos]; }
T operator[](int pos) const { return data[pos]; }
void set(int pos, T value) {
changes.emplace_back(pos, data[pos]);
data[pos] = value;
curState++;
}
void revert(int prevState) {
for (int nxt = curState - 1; nxt >= prevState; nxt--) {
data[changes[nxt].first] = changes[nxt].second;
changes.pop_back();
}
curState = prevState;
}
};
struct FUInfo {
int parent;
int treeSize;
bool invert;
};
struct RevertibleFindUnionWithParity {
RevertibleVector<FUInfo> data;
RevertibleFindUnionWithParity() {}
RevertibleFindUnionWithParity(int N) {
data.resize(N);
for (int i = 0; i < N; i++) {
data.data[i] = FUInfo{i, 1, false};
}
}
pair<int, bool> findSet(int v) const {
bool curNeg = false;
while (v != data[v].parent) {
curNeg ^= data[v].invert;
v = data[v].parent;
}
return {v, curNeg};
}
bool unionSets(int u, int v) {
bool negU, negV;
tie(u, negU) = findSet(u);
tie(v, negV) = findSet(v);
if (u == v) return (negU != negV);
if (data[u].treeSize < data[v].treeSize) swap(u, v);
int vSize = data[v].treeSize, uSize = data[u].treeSize;
data.set(v, FUInfo{u, -1, !(negU ^ negV)});
data.set(u, FUInfo{u, vSize + uSize, false});
return true;
}
int getState() const { return data.getState(); }
void revert(int state) { data.revert(state); }
void dbg() const {
for (auto P : data.data) {
printf("(%d,%d,%d) ", P.parent, P.treeSize, P.invert);
}
printf("\n");
}
};
const int MaxVerts = 500005, MaxEdges = 500005, MaxQueries = 500005,
MaxColors = 52;
int numVerts, numEdges, numQueries, numColors;
vector<int> edgeFrom, edgeTo;
vector<int> queryEdge, queryCol;
vector<int> nextSameEdge;
vector<RevertibleFindUnionWithParity> FU;
vector<vector<pair<int, int>>> paintingTree;
vector<int> curColor;
int Base;
void input() {
scanf("%d%d%d%d", &numVerts, &numEdges, &numColors, &numQueries);
edgeFrom.resize(numEdges);
edgeTo.resize(numEdges);
for (int edge = 0; edge < numEdges; edge++) {
scanf("%d%d", &edgeFrom[edge], &edgeTo[edge]);
edgeFrom[edge]--;
edgeTo[edge]--;
}
queryEdge.resize(numQueries);
queryCol.resize(numQueries);
for (int query = 0; query < numQueries; query++) {
scanf("%d%d", &queryEdge[query], &queryCol[query]);
queryEdge[query]--;
queryCol[query]--;
}
(sizeof(FUInfo));
FU.resize(numColors, RevertibleFindUnionWithParity(numVerts));
}
void process_queries_by_edges() {
vector<int> firstOccur(numEdges, numQueries);
nextSameEdge.resize(numQueries);
for (int query = numQueries - 1; query >= 0; query--) {
int edge = queryEdge[query];
nextSameEdge[query] = firstOccur[edge];
firstOccur[edge] = query;
}
}
void build_tree() {
Base = 1;
while (Base < numQueries + 1) Base *= 2;
paintingTree.resize(Base * 2);
}
void update_tree(int left, int right, pair<int, int> op) {
("update_tree", left, right, op.first, op.second);
if (left > right) return;
left += Base;
right += Base;
paintingTree[left].push_back(op);
if (left != right) paintingTree[right].push_back(op);
while (left / 2 != right / 2) {
if (left % 2 == 0) paintingTree[left + 1].push_back(op);
if (right % 2 == 1) paintingTree[right - 1].push_back(op);
left /= 2;
right /= 2;
}
}
int maxSum;
void traverse_tree(int vert, int leftIntv, int rightIntv) {
if (leftIntv >= numQueries) return;
vector<int> lastState(numColors);
int sumStates = 0;
for (int i = 0; i < numColors; i++) {
lastState[i] = FU[i].getState();
sumStates += lastState[i];
}
maxSum = max(maxSum, sumStates);
for (pair<int, int> query : paintingTree[vert]) {
int edge = query.first, color = query.second;
assert(FU[color].unionSets(edgeFrom[edge], edgeTo[edge]));
}
if (leftIntv == rightIntv) {
assert(vert >= Base);
int edge = queryEdge[leftIntv], color = queryCol[leftIntv];
auto from = FU[color].findSet(edgeFrom[edge]),
to = FU[color].findSet(edgeTo[edge]);
int newColor = curColor[edge];
if (from == to) {
printf("NO\n");
} else {
printf("YES\n");
newColor = color;
}
if (newColor != -1) {
int intvFrom = leftIntv + 1, intvTo = nextSameEdge[leftIntv] - 1;
update_tree(intvFrom, intvTo, {queryEdge[leftIntv], newColor});
}
curColor[edge] = newColor;
} else {
int mid = (leftIntv + rightIntv) / 2;
traverse_tree(vert * 2, leftIntv, mid);
traverse_tree(vert * 2 + 1, mid + 1, rightIntv);
}
for (int i = 0; i < numColors; i++) {
FU[i].revert(lastState[i]);
}
paintingTree[vert].clear();
}
int main() {
input();
process_queries_by_edges();
build_tree();
curColor = vector<int>(numEdges, -1);
traverse_tree(1, 0, Base - 1);
(maxSum);
}
| 5 |
#include<iostream>
#include<cstdio>
using namespace std;
int n,tot,tmp;
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>tmp;
if((i&1) && (tmp&1))tot++;
}cout<<tot;
return 0;
} | 0 |
#include <bits/stdc++.h>
const int MAXN = 100000;
int hash[26], val[MAXN + 1], state[MAXN + 1];
inline bool cmp(int a, int b) { return hash[a] > hash[b]; }
int main() {
static char str[MAXN + 1];
int k;
scanf("%s%d", str, &k);
int n = strlen(str);
for (int i = 0; i < n; ++i) {
++hash[str[i] - 'a'];
}
int cnt = 0;
for (int i = 0; i < 26; ++i) {
if (hash[i] == 0) continue;
++cnt;
for (int j = k - 1; j >= 0; --j) {
if (j + hash[i] <= k && val[j] + 1 > val[j + hash[i]]) {
val[j + hash[i]] = val[j] + 1;
state[j + hash[i]] = state[j] ^ (1 << i);
}
}
}
int id = 0;
for (int i = 0; i <= k; ++i) {
if (val[i] > val[id]) id = i;
}
printf("%d\n", cnt - val[id]);
for (int i = 0; i < n; ++i) {
if (!((1 << (str[i] - 'a')) & state[id])) {
putchar(str[i]);
}
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define For(i, a, b) for (int i = a; i <= b; i++)
using namespace std;
const int mod = 1000000000 + 7, MAXN = 200000 + 5;
int val[MAXN], lastF[MAXN];
int main(){
int n;
scanf("%d", &n);
val[0] = 1;
For(i, 1, n){
int k;
scanf("%d", &k);
val[i] = val[i - 1];
if (lastF[k] && lastF[k] + 1 != i) val[i] = (val[i] + val[lastF[k]]) % mod;
lastF[k] = i;
}
printf("%d", val[n]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[1111];
int r, c, count = 0;
cin >> r >> c;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> str[j];
}
}
c++;
for (int i = 0; i < c - 1; i++) {
if (str[i] == 'B' and str[i + 1] != 'B') count++;
}
cout << count;
}
| 4 |
#include <iostream>
#include <queue>
using namespace std;
int main()
{
int n,to=0,ar[101];cin>>n;
for (int i=0;i<n;i++) {cin>>ar[i];}
for (int i=1;i<n;i++)
{
if (ar[i]<ar[i-1])
{
to+=ar[i-1]-ar[i];
}
}
cout<<to+ar[n-1]<<"\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
using ll = long long;
const ll INF = 1e18;
using ld = double;
using P = complex<ld>;
using G = vector<P>;
const ld pi = acos(-1);
const ld eps = 1e-10;
ld cross(const P& a, const P& b) { return a.real()*b.imag() - a.imag()*b.real(); }
ld dot(const P& a, const P& b) { return a.real()*b.real() + a.imag()*b.imag(); }
/*
CCW
-- BEHIND -- [a -- ON -- b] --- FRONT --
CW
*/
enum { CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0 };
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b, c) > eps) return CCW; // counter clockwise
if (cross(b, c) < -eps) return CW; // clockwise
if (dot(b, c) < 0) return BEHIND; // c--a--b on line
if (norm(b) < norm(c)) return FRONT; // a--b--c on line
return ON;
}
namespace std {
bool operator < (const P& a, const P& b) {
return abs(real(a) - real(b)) > eps ? real(a) < real(b) : imag(a) < imag(b);
}
}
G andrewScan(G ps){
int N = ps.size(), k = 0;
sort(ps.begin(), ps.end());
G res(N*2);
for(int i=0; i<N; i++) {
while(k>=2 && ccw(res[k-2], res[k-1], ps[i])!=CCW) k--;
res[k++] = ps[i];
}
int t = k+1;
for(int i=N-2; i>=0; i--) {
while(k>=t && ccw(res[k-2], res[k-1], ps[i])!=CCW) k--;
res[k++] = ps[i];
}
res.resize(k-1);
return res;
}
int n;
int dx[] = {-1,0,1,0};
int dy[] = {0,-1,0,1};
int x[100010], y[100010];
using pii = pair<int,int>;
set<pii> S;
G g;
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n;
rep(i,n-1){
int k,d;
cin >> k >> d;
x[i+1] = x[k] + dx[d];
y[i+1] = y[k] + dy[d];
}
rep(i,n){
S.emplace(x[i], y[i]);
S.emplace(x[i]+1, y[i]);
S.emplace(x[i], y[i]+1);
S.emplace(x[i]+1, y[i]+1);
}
g.clear();
for(auto &p : S) g.emplace_back(p.first, p.second);
g = andrewScan(g);
int k = g.size();
g.insert(g.end(), g.begin(), g.end());
ld ans = INF;
rep(i,k){
P base = g[1+i] - g[0+i];
base /= abs(base);
ld min_x = +INF, max_x = -INF;
ld min_y = +INF, max_y = -INF;
rep(j,k){
ld x = real(g[j+1]/base);
ld y = imag(g[j+1]/base);
min_x = min(min_x, x);
min_y = min(min_y, y);
max_x = max(max_x, x);
max_y = max(max_y, y);
}
ld dx = max_x - min_x;
ld dy = max_y - min_y;
ans = min(ans, dx*dy);
}
cout << fixed << setprecision(10) << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long rev(long long num) {
long long res;
stringstream second, s1;
string str;
second << num;
second >> str;
string tem;
tem = str;
for (int i = str.size() - 1; i >= 0; i--) {
tem += str[i];
}
s1 << tem;
s1 >> res;
return res;
}
int main() {
long long k, p;
scanf("%lld", &k);
scanf("%lld", &p);
long long res = 0;
for (int i = 1; i <= k; i++) {
res = ((res % p) + (rev(i) % p)) % p;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 2 + 5;
const long long inf = 9223372036854775807;
int n, a[maxn][maxn], mark[maxn];
vector<int> adj[maxn], radj[maxn];
void sfd(int v) {
mark[v] = 1;
for (auto u : radj[v]) {
if (mark[u] == 0) {
sfd(u);
}
}
}
void dfs(int v) {
mark[v] = 1;
for (auto u : adj[v]) {
if (mark[u] == 0) {
dfs(u);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
if (a[i][j]) {
adj[i].push_back(j);
radj[j].push_back(i);
}
}
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (mark[i] == 0) {
cout << "NO";
return 0;
}
}
memset(mark, 0, sizeof mark);
sfd(1);
for (int i = 1; i <= n; i++) {
if (mark[i] == 0) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
for (auto v : V) os << v << " ";
return cout << "";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
for (auto s : S) os << s << " ";
return cout << "";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << P.first << " " << P.second;
}
const long long mod = 998244353;
long long inv(long long i) {
if (i == 1) return 1;
return (mod - (mod / i) * inv(mod % i) % mod) % mod;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b, b % a);
}
long long arr[200020], brr[200200];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, n, m, f, f1, f2, t, a, b, k;
cin >> t;
while (t--) {
string s;
cin >> s;
map<pair<pair<long long, long long>, pair<long long, long long>>, long long>
m;
long long x[200020], y[200200], x1[200200], y1[200200];
x[0] = 0;
y[0] = 0;
j = 1;
long long ans = 0;
for (i = 0; i <= s.length() - 1; i++) {
if (s[i] == 'N') {
x[j] = x[j - 1];
y[j] = y[j - 1] + 1;
x1[j] = x[j - 1];
y1[j] = y[j - 1];
}
if (s[i] == 'E') {
x[j] = x[j - 1] + 1;
y[j] = y[j - 1];
x1[j] = x[j - 1];
y1[j] = y[j - 1];
}
if (s[i] == 'W') {
x[j] = x[j - 1] - 1;
y[j] = y[j - 1];
x1[j] = x[j - 1];
y1[j] = y[j - 1];
}
if (s[i] == 'S') {
x[j] = x[j - 1];
y[j] = y[j - 1] - 1;
x1[j] = x[j - 1];
y1[j] = y[j - 1];
}
if (m[make_pair(make_pair(x[j], y[j]), make_pair(x1[j], y1[j]))] == 1 or
m[make_pair(make_pair(x1[j], y1[j]), make_pair(x[j], y[j]))] == 1) {
ans += 1;
} else {
ans += 5;
}
m[make_pair(make_pair(x[j], y[j]), make_pair(x1[j], y1[j]))] = 1;
m[make_pair(make_pair(x1[j], y1[j]), make_pair(x[j], y[j]))] = 1;
j++;
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 4e5 + 10;
long long n, q, a[N], l, r, type, x, y, HL[19], HR[19], pw[N][19], nxt[N][19];
void build(long long id, long long L, long long R) {
long long mid = (L + R) / 2;
if (R - L == 1) {
for (long long i = 0; i < 10; i++) {
long long q = 1;
while (a[L]) {
pw[id][a[L] % 10] += q;
a[L] /= 10;
q *= 10;
}
nxt[id][i] = i;
}
return;
}
build(2 * id, L, mid);
build(2 * id + 1, mid, R);
for (long long i = 0; i < 10; i++) {
pw[id][i] = pw[2 * id][i] + pw[2 * id + 1][i];
nxt[id][i] = i;
}
}
void relax(long long id) {
for (long long i = 0; i < 10; i++) {
HL[i] = 0;
HR[i] = 0;
}
for (long long i = 0; i < 10; i++) {
nxt[2 * id][i] = nxt[id][nxt[2 * id][i]];
nxt[2 * id + 1][i] = nxt[id][nxt[2 * id + 1][i]];
HL[nxt[id][i]] += pw[2 * id][i];
HR[nxt[id][i]] += pw[2 * id + 1][i];
}
for (long long i = 0; i < 10; i++) {
pw[2 * id][i] = HL[i];
pw[2 * id + 1][i] = HR[i];
}
for (long long i = 0; i < 10; i++) {
nxt[id][i] = i;
}
}
void upd(long long s, long long e, long long id, long long L, long long R,
long long A, long long B) {
long long mid = (L + R) / 2;
if (s <= L && R <= e) {
pw[id][B] += pw[id][A];
pw[id][A] = 0;
for (long long i = 0; i < 10; i++) {
if (nxt[id][i] == A) {
nxt[id][i] = B;
}
}
return;
}
if (e <= L || R <= s) {
return;
}
relax(id);
upd(s, e, 2 * id, L, mid, A, B);
upd(s, e, 2 * id + 1, mid, R, A, B);
for (long long i = 0; i < 10; i++) {
pw[id][i] = pw[2 * id][i] + pw[2 * id + 1][i];
}
}
long long get(long long s, long long e, long long id, long long L,
long long R) {
long long mid = (L + R) / 2;
if (s <= L && R <= e) {
long long res = 0;
for (long long i = 1; i < 10; i++) {
res += i * (pw[id][i]);
}
return res;
}
if (e <= L || R <= s) {
return 0;
}
relax(id);
return (get(s, e, 2 * id, L, mid) + get(s, e, 2 * id + 1, mid, R));
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
build(1, 0, n);
for (long long i = 1; i <= q; i++) {
cin >> type;
if (type == 1) {
cin >> l >> r >> x >> y;
if (x != y) upd(l - 1, r, 1, 0, n, x, y);
} else {
cin >> l >> r;
cout << get(l - 1, r, 1, 0, n) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int modulo = 1000003;
int main() {
string s;
cin >> s;
if (s[int(s.size()) - 1] == '*' or s[int(s.size()) - 1] == '/' or
s[int(s.size()) - 1] == '+' or s[int(s.size()) - 1] == '-') {
cout << 0 << endl;
exit(0);
}
for (int i = 0; i < int(s.size()); i++) {
if ((s[i] == '*' or s[i] == '/') and
(i == 0 or not(s[i - 1] >= '0' and s[i - 1] <= '9'))) {
cout << 0 << endl;
exit(0);
}
}
vector<long long int> maneras(1, 1);
for (int i = int(s.size()) - 1; i >= 0; i--) {
if (s[i] == '*' or s[i] == '/' or s[i] == '+' or s[i] == '-') {
if (i > 0 and (s[i - 1] >= '0' and s[i - 1] <= '9')) {
vector<long long int> nextmaneras(int(maneras.size()) + 1);
nextmaneras[0] = 0;
nextmaneras.back() = maneras.back();
for (int i = int(maneras.size()) - 1; i > 0; i--)
nextmaneras[i] = (nextmaneras[i + 1] + maneras[i - 1]) % modulo;
maneras = nextmaneras;
} else {
vector<long long int> nextmaneras(int(maneras.size()));
nextmaneras.back() = maneras.back();
for (int i = int(maneras.size()) - 2; i >= 0; i--)
nextmaneras[i] = (nextmaneras[i + 1] + maneras[i]) % modulo;
maneras = nextmaneras;
}
}
}
long long int suma = 0;
for (int i = 0; i < int(maneras.size()); i++)
suma = (suma + maneras[i]) % modulo;
cout << suma << endl;
}
| 4 |
#include<iostream>
#include<iomanip>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) for(int i=0;i<(n);i++)
#define PII pair<int,int>
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define MP make_pair
class Point;
class Segment;
class circle;
class Point
{
public:
double x, y;
Point(double X = 0, double Y = 0)
{
x = X;
y = Y;
}
Point operator +(const Point &p)const { return Point(x + p.x, y + p.y); };
Point operator -(const Point &p)const { return Point(x - p.x, y - p.y); };
Point operator *(const double a)const { return Point(x*a, y*a); };
Point operator /(const double a)const { return Point(x / a, y / a); };
double norm()const { return x*x + y*y; };
double length()const { return sqrt(norm()); };
double dot(const Point &p)const { return x*p.x + y*p.y; };
double cross(const Point &p)const { return x*p.y - y*p.x; };
Point normalize()const
{
Point ans(x, y);
return ans = ans / ans.length();
}
bool operator ==(const Point &p)const
{
return fabs(x - p.x)<EPS &&fabs(y - p.y)<EPS;
}
friend ostream& operator <<(ostream& os, const Point &p);
int CCW(Point p1, Point p2)
{
Point p0(x, y);
Point V1 = p1 - p0;
Point V2 = p2 - p0;
if (V1.cross(V2) > 0.0)return -1;
else if (V1.cross(V2) < 0.0)return 1;
else if (V1.dot(V2) < 0.0)return -2;
else if (V1.norm() < V2.norm())return 2;
return 0;
}
};
typedef Point Vector;
class Circle
{
public:
Point c;
double r;
Circle(Point C = Point(), double R = 0)
{
c = C;
r = R;
}
};
ostream& operator <<(ostream& os, const Point &p)
{
return os << "(" << p.x << "," << p.y << ")";
}
class Segment
{
public:
Point p1, p2;
Segment(double x1, double y1, double x2, double y2)
{
p1.x = x1;
p1.y = y1;
p2.x = x2;
p2.y = y2;
}
double GetLength()
{
Point temp = p2 - p1;
return temp.length();
}
double GetDistanceSeg(double X, double Y)
{
Point p(X, Y);
Point a = p2 - p1;
Point b = p - p1;
Point c = p1 - p2;
Point d = p - p2;
if (a.dot(b) < 0.0)return b.length();
if (c.dot(d) < 0.0)return d.length();
return GetDistanceLine(X, Y);
}
double GetDistanceLine(double X, double Y)
{
Point t(X, Y);
Point a = p2 - p1;
Point b = t - p1;
return abs(a.cross(b) / a.length());
}
bool IsIntersect(Segment &s)
{
int s1, s2;
s1 = p1.CCW(p2, s.p1)*p1.CCW(p2, s.p2);
s2 = s.p1.CCW(s.p2, p1)*s.p1.CCW(s.p2, p2);
return s1 <= 0 && s2 <= 0;
}
bool IsIntersect(Circle &Cir)
{
return GetDistanceLine(Cir.c.x, Cir.c.y) - Cir.r <= EPS;
}
bool IsOrthogonal(const Segment &s)
{
Vector t1 = p2 - p1;
Vector t2 = s.p2 - s.p1;
return equals(0.0, t1.dot(t2));
}
bool IsParallel(const Segment &s)
{
Vector t1 = p2 - p1;
Vector t2 = s.p2 - s.p1;
return equals(0.0, t1.cross(t2));
}
Point GetProjection(double X, double Y)const
{
Vector V = p2 - p1;
Point P(X, Y);
Point ret = V*(V.dot(P - p1) / V.norm());
return ret + p1;
}
Point GetProjection(Point p)const
{
Vector V = p2 - p1;
Point ret = V*(V.dot(p - p1) / V.norm());
return ret + p1;
}
Point GetReflect(double X, double Y)
{
Point t(X, Y);
Point Pro = GetProjection(X, Y);
Vector dV = Pro - t;
return t + dV*2.0;
}
Point GetCrossPoint(Segment &s)
{
Point P2 = p2 - p1;
Point P3 = s.p1 - p1;
Point P4 = s.p2 - p1;
double d1 = abs(P2.cross(P3));
double d2 = abs(P2.cross(P4));
double t = d1 / (d1 + d2);
Point ans = (P4 - P3)*t + P3 + p1;
return ans;
}
pair<Point, Point> GetCrossPoint(Circle &Cir)
{
try { if (!IsIntersect(Cir)) { throw "error"; } }
catch (string str) { cout << str << endl; }
Vector pr = GetProjection(Cir.c);
Vector p = (p2 - p1).normalize();
double l = sqrt(Cir.r*Cir.r - (pr - Cir.c).norm());
return make_pair(p*l + pr, p*(-l) + pr);
}
};
typedef Segment Line;
int main()
{
double x, y, r;
cin >> x >> y >> r;
Circle Cir(Point(x, y), r);
int q;
cin >> q;
REP(i, q)
{
double x1, y1, x2, y2;
cin >> x1>> y1>> x2>> y2;
Segment s(x1, y1, x2, y2);
pair<Point, Point> ans = s.GetCrossPoint(Cir);
Point p1 = ans.first;
Point p2 = ans.second;
if (p1.x < p2.x)
{
cout << fixed << setprecision(10) << p1.x << " ";
cout << fixed << setprecision(10) << p1.y << " ";
cout << fixed << setprecision(10) << p2.x << " ";
cout << fixed << setprecision(10) << p2.y << endl;
}
else if (equals(p1.x, p2.x))
{
if (p1.y < p2.y)
{
cout << fixed << setprecision(10) << p1.x << " ";
cout << fixed << setprecision(10) << p1.y << " ";
cout << fixed << setprecision(10) << p2.x << " ";
cout << fixed << setprecision(10) << p2.y << endl;
}
else
{
cout << fixed << setprecision(10) << p2.x << " ";
cout << fixed << setprecision(10) << p2.y << " ";
cout << fixed << setprecision(10) << p1.x << " ";
cout << fixed << setprecision(10) << p1.y << endl;
}
}
else
{
cout << fixed << setprecision(10) << p2.x << " ";
cout << fixed << setprecision(10) << p2.y << " ";
cout << fixed << setprecision(10) << p1.x << " ";
cout << fixed << setprecision(10) << p1.y << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int infint = INT_MAX;
const long long infll = LLONG_MAX;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
long long sum = 0;
vector<long long> arr(n), cp(n);
int nzero = -1;
for (int i = 0; i < n; i++) {
cin >> arr[i];
cp[i] = arr[i];
sum += arr[i];
if (arr[i] > 0) nzero = i;
}
long long l = nzero + 1, r = 1e16, mid = 0;
while (l + 1 < r) {
mid = (l + r) / 2;
arr = cp;
long long lSum = 0;
int j = nzero;
long long t = mid;
for (int i = 0; i < m; i++) {
while (j > 0 && arr[j] <= 0) j--;
long long tTime = j + 1;
for (; j >= 0 && tTime < mid; j--) {
lSum += min(arr[j], max(0LL, mid - tTime));
long long oldArr = arr[j];
arr[j] -= min(arr[j], max(0LL, mid - tTime));
tTime += min(max(0LL, mid - tTime), oldArr);
if (tTime >= mid) break;
}
}
if (lSum >= sum) {
r = mid;
} else
l = mid;
}
cout << r;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(u);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = (0); i < ((int)(v).size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
cin.exceptions(cin.failbit);
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
const int MM = 1e5 + 5;
int n, a[MM], pref[MM];
int main() {
setIO();
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i], pref[i] = (i - 1 >= 0 ? pref[i - 1] + a[i] : a[i]);
string second;
cin >> second;
int ans = 0, cur = 0;
for (int i = (int)second.size() - 1; i >= 0; i--) {
if (second[i] == '1') {
ans = max(ans, cur + (i - 1 >= 0 ? pref[i - 1] : 0));
cur += a[i];
}
}
ans = max(ans, cur);
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 10;
vector<ll> f[N];
void add(ll i, ll first) {
for (; i < N; i |= i + 1) {
f[i].push_back(first);
}
}
void build() {
for (ll i = 0; i < N; ++i) {
sort(f[i].begin(), f[i].end());
}
}
ll query(ll i, ll first) {
ll s = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
s += (ll)(f[i].end() - lower_bound(f[i].begin(), f[i].end(), first));
}
return s;
}
ll n;
ll m;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (ll l, r, i = 0; i < n; ++i) {
cin >> l >> r;
add(r, l);
}
build();
while (m--) {
ll cnt;
cin >> cnt;
ll lst = 0;
ll ans = n;
while (cnt--) {
ll cur;
cin >> cur;
ans -= query(cur - 1, lst + 1);
lst = cur;
}
ans -= query(N - 1, lst + 1);
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = LONG_LONG_MAX;
const ll N = 1e5 + 5;
ll p[N];
ll c[N];
vector<ll> adj[N];
vector<ll> v;
void dfs(ll node, ll par) {
ll valid = (p[node] != (-1) and c[node]);
for (ll i : adj[node]) {
if (c[i] == 0) {
valid = 0;
}
dfs(i, node);
}
if (valid) {
v.push_back(node);
}
}
signed main() {
ll n;
cin >> n;
ll root;
for (ll i = 1; i <= n; i++) {
cin >> p[i] >> c[i];
if (p[i] == (-1)) {
root = i;
} else {
adj[p[i]].push_back(i);
}
}
for (ll i = 1; i <= n; i++) {
sort(adj[i].begin(), adj[i].end());
}
dfs(root, (-1));
sort(v.begin(), v.end());
if (v.size() == 0) {
cout << "-1\n";
} else {
for (ll i : v) {
cout << i << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const double eps = 1e-8;
char a[MAXN], b[MAXN];
int c1[MAXN], c2[MAXN];
int main() {
scanf("%s %s", a + 1, b + 1);
int lena = strlen(a + 1);
int lenb = strlen(b + 1);
int max_len = 0;
int j = 1, i;
for (i = 1; i <= lena; i++) {
if (a[i] == b[j]) {
c1[j] = i;
j++;
if (j == lenb + 1) break;
continue;
}
}
max_len = max(max_len, lena - i);
j = lenb;
for (i = lena; i >= 1; i--) {
if (a[i] == b[j]) {
c2[j] = i;
j--;
if (j == 0) break;
continue;
}
}
max_len = max(max_len, i - 1);
for (i = 1; i <= lenb; i++) {
if (i == 1)
max_len = max(max_len, c2[i] - c1[i]);
else
max_len = max(max_len, c2[i] - c1[i - 1] - 1);
}
cout << max_len << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int length(char word[]) {
for (int i = 0; i < 100; i++) {
if (word[i] == '\0') {
return i;
}
}
return 100;
}
int length(int adad) {
int i = 0;
while (adad >= 1) {
adad /= 10;
i++;
}
return i;
}
int reverse(int adad) {
int reversed = 0;
int lengthAdad = length(adad);
for (int i = 0; i < lengthAdad; i++) {
reversed *= 10;
reversed += adad % 10;
adad /= 10;
}
return reversed;
}
void format(int adad, char a[]) {
adad = reverse(adad);
int j = 1;
int k = 0;
int lengthAdad = length(adad);
for (int i = 0; i < lengthAdad; i++) {
if (j % 3 == 0) {
a[i + k] = ',';
k++;
}
a[i + k] = adad % 10;
adad /= 10;
j++;
}
}
int findMin(int a[], int cnt) {
int min = a[0];
int index = 0;
for (int i = 1; i < cnt; i++) {
if (a[i] <= min) {
min = a[i];
index = i;
}
}
return index;
}
int findMax(int a[], int cnt) {
int max = a[cnt - 1];
int index = cnt - 1;
for (int i = cnt - 1; i >= 0; i--) {
if (a[i] >= max) {
max = a[i];
index = i;
}
}
return index;
}
int min(int a, int b) {
if (a > b) {
return b;
}
return a;
}
int max(int a, int b) {
if (a > b) {
return a;
}
return b;
}
int main(int argc, const char *argv[]) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int n;
cin >> n;
int **rads = new int *[n];
for (int i = 0; i < n; i++) {
rads[i] = new int[3];
cin >> rads[i][0] >> rads[i][1] >> rads[i][2];
}
int num = 0;
for (int i = min(x2, x1); i <= max(x2, x1); i++) {
for (int k = min(y1, y2); k <= max(y2, y1); k++) {
if ((k == min(y1, y2) || k == max(y2, y1)) ||
(i == min(x2, x1) || i == max(x2, x1))) {
bool isInside = false;
for (int j = 0; j < n; j++) {
if (sqrt(pow(i - rads[j][0], 2) + pow(k - rads[j][1], 2)) <=
rads[j][2]) {
isInside = true;
break;
}
}
if (!isInside) num++;
};
}
}
cout << num;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void file() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int arr2[100][100];
void solve() {}
bool check(int p, int q, int n, int m) {
for (int j = 0; j < m; j++) {
if (arr2[p][j] == 1) return true;
}
for (int j = 0; j < n; j++) {
if (arr2[j][q] == 1) return true;
}
return false;
}
void print(int n, int m) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << arr2[i][j] << " ";
}
cout << endl;
}
}
void fil(int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) arr2[i][j] = 1;
}
int main() {
int n, m;
cin >> n >> m;
fil(n, m);
vector<pair<int, int>> v;
int arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
if (arr[i][j] == 0) v.push_back(make_pair(i, j));
}
}
for (int i = 0; i < v.size(); i++) {
int p = v[i].first;
int q = v[i].second;
for (int j = 0; j < m; j++) {
arr2[p][j] = 0;
}
for (int j = 0; j < n; j++) {
arr2[j][q] = 0;
}
}
int c = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 1) {
if (!check(i, j, n, m)) {
cout << "NO\n";
return 0;
}
}
}
}
print(n, m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b, c, d;
node() {}
node(int A, int B, int C, int D) { a = A, b = B, c = C, d = D; }
} ans[500005];
vector<int> G[2][500005];
int n, cnt;
int f[500005];
int fa[2][500005];
void dfs(int u, int k) {
for (int i = 0; i < G[k][u].size(); i++) {
int v = G[k][u][i];
if (v == fa[k][u])
continue;
else
fa[k][v] = u, dfs(v, k);
}
}
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void makeSet() {
for (int i = 1; i <= n; i++) {
int now = fa[1][i];
if (now == fa[0][i] || i == fa[0][now])
f[i] = now;
else
f[i] = i;
}
}
void dfs(int u) {
for (int i = 0; i < G[0][u].size(); i++) {
int v = G[0][u][i];
if (v == fa[0][u]) continue;
dfs(v);
if (v != fa[1][u] && u != fa[1][v])
ans[++cnt] = node(u, v, find(v), fa[1][find(v)]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d %d", &u, &v);
G[0][u].push_back(v);
G[0][v].push_back(u);
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d %d", &u, &v);
G[1][u].push_back(v);
G[1][v].push_back(u);
}
dfs(1, 0);
dfs(1, 1);
makeSet();
dfs(1);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++)
printf("%d %d %d %d\n", ans[i].a, ans[i].b, ans[i].c, ans[i].d);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int s, m, k, nr1, nr2, n, i, Apa[30], Ap[30][30], j, l, mx;
char sir[10000], a, b, aux;
int main() {
cin >> n;
for (j = 0; j < n; j++) {
cin >> sir;
l = strlen(sir);
k = 1;
nr1 = 1;
a = sir[0];
for (i = 1; i < l; i++) {
if (sir[i] == a)
nr1++;
else if (sir[i] != a) {
if (k == 1) {
k = 2;
b = sir[i];
nr2 = 1;
} else if (sir[i] == b && k == 2) {
nr2++;
} else {
k = 3;
break;
}
}
}
if (k == 1) {
Apa[a - 'a' + 0] += nr1;
} else if (k == 2) {
if (a < b) {
aux = a;
a = b;
b = aux;
}
Ap[a - 'a' + 0][b - 'a' + 0] += nr1 + nr2;
}
}
for (i = 0; i < 26; i++)
for (j = 0; j < 26; j++) {
if (i != j) {
s = Ap[i][j] + Apa[i] + Apa[j];
if (s > mx) mx = s;
}
}
cout << mx;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
int ans = 0;
map<pair<int, int>, set<char> > m;
pair<int, int> pos = {0, 0};
for (auto e : s) {
if (m[pos].find(e) != m[pos].end()) {
if (e == 'N') pos.second++;
if (e == 'S') pos.second--;
if (e == 'E') pos.first++;
if (e == 'W') pos.first--;
ans += 1;
continue;
}
m[pos].insert(e);
if (e == 'N') {
pos.second++;
int vis = 0;
for (auto k : m[pos]) {
if (k == 'S') {
ans += 1;
vis = 1;
break;
}
}
if (!vis) ans += 5;
} else if (e == 'S') {
pos.second--;
int vis = 0;
for (auto k : m[pos]) {
if (k == 'N') {
ans += 1;
vis = 1;
break;
}
}
if (!vis) ans += 5;
} else if (e == 'W') {
pos.first--;
int vis = 0;
for (auto k : m[pos])
if (k == 'E') {
ans += 1;
vis = 1;
break;
}
if (!vis) ans += 5;
} else if (e == 'E') {
pos.first++;
int vis = 0;
for (auto k : m[pos])
if (k == 'W') {
ans += 1;
vis = 1;
break;
}
if (!vis) ans += 5;
}
}
cout << ans << '\n';
}
return (0);
}
| 3 |
#include <string>
#include <cstdio>
int main(){
std::string s;
for(int c;~(c=getchar());){
if(c=='B')s.pop_back();
else s.push_back(c);
}
printf(s.c_str());
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, r, av;
bool cmp(const pair<int, int> &p1, const pair<int, int> &p2) {
if (p1.second < p2.second)
return 1;
else if (p1.second == p2.second) {
return p2.first > p1.first;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> r >> av;
vector<pair<int, int> > v(n);
long long int sum = 0;
for (int i = 0; i < n; i++)
cin >> v[i].first >> v[i].second, sum += v[i].first;
long long int need = 1LL * av * n - sum;
long long int ans = 0;
if (need > 0) {
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < n; i++) {
if (need <= 0) break;
long long int possible = r - v[i].first;
possible = min(possible, need);
need -= possible;
ans += possible * v[i].second;
}
}
cout << ans << endl;
}
| 3 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#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 EPS = 1e-8;
const double PI = acos(-1.0);
const int dx[] = { 0, 1, 0, -1 };
const int dy[] = { 1, 0, -1, 0 };
template <class T>
T lcs(const T& a, const T& b)
{
const int n = a.size(), m = b.size();
vector<vector<int> > dp(n + 1, vector<int>(m + 1));
vector<vector<int> > prev(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < m; ++j)
{
if (a[i] == b[j])
{
dp[i + 1][j + 1] = dp[i][j] + 1;
prev[i + 1][j + 1] = 0;
}
else if (dp[i][j + 1] > dp[i + 1][j])
{
dp[i + 1][j + 1] = dp[i][j + 1];
prev[i + 1][j + 1] = 1;
}
else
{
dp[i + 1][j + 1] = dp[i + 1][j];
prev[i + 1][j + 1] = 2;
}
}
}
T res;
for (int i = n, j = m; i > 0 && j > 0; )
{
if (prev[i][j] == 0)
{
res.push_back(a[i - 1]);
--i, --j;
}
else if (prev[i][j] == 1)
--i;
else
--j;
}
reverse(res.begin(), res.end());
return res;
}
int main()
{
ios::sync_with_stdio(false);
string s;
while (cin >> s)
{
string t = s;
reverse(all(t));
cout << lcs(s, t) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long maxn = 0, minn = 1e18;
long long tot;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void js(long long x) {
if (x <= 0 || x > tot) return;
long long gg = gcd(x, tot);
long long tmp = tot / gg;
maxn = max(maxn, tmp);
minn = min(minn, tmp);
}
int main() {
long long n, k;
cin >> n >> k;
long long a, b;
cin >> a >> b;
tot = n * k;
for (int i = 0; i <= n + 1; ++i) {
js(i * k + (a + b));
js(i * k - (a + b));
js(i * k + (a - b));
js(i * k + (b - a));
}
printf("%lld %lld\n", minn, maxn);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int p, k;
cin >> p >> k;
vector<long long int> out;
long long int a = p, b;
do {
b = ((a % k) + k) % k;
a = (b - a) / k;
out.push_back(b);
} while (a != 0);
cout << out.size() << endl;
for (int lpl = 0; lpl < out.size(); lpl++) {
cout << out[lpl] << " ";
}
cout << endl;
;
return 0;
}
| 4 |
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <map>
#include <list>
#include <set>
#include <numeric>
#include <queue>
#include <stack>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <climits>
#include <cfloat>
#include <ctime>
#include <complex>
#include <cassert>
#include <array>
#include <bitset>
#include <unordered_map>
#include <random>
using namespace std;
typedef unsigned long long LL;
typedef pair<LL,LL> P;
LL ret[500][500];
int main(){
LL N;
scanf("%llu",&N);
std::vector<LL> S(N);
for(int i = 0 ; i < N ; i++){
scanf("%llu",&S[i]);
}
std::vector<LL> T(N);
for(int i = 0 ; i < N ; i++){
scanf("%llu",&T[i]);
}
std::vector<LL> U(N);
for(int i = 0 ; i < N ; i++){
scanf("%llu",&U[i]);
}
std::vector<LL> V(N);
for(int i = 0 ; i < N ; i++){
scanf("%llu",&V[i]);
}
for(int R=0;R<64;R++){
set<int> a0r,a0c,s0r,s0c;
set<int> a1r,a1c,s1r,s1c;
LL f=(1LLU<<R);
for(int i=0;i<N;i++){
if(S[i]==0){
if(U[i]&f){
a1r.insert(i);
}
else{
s0r.insert(i);
}
}
else{
if(U[i]&f){
s1r.insert(i);
}
else{
a0r.insert(i);
}
}
}
for(int i=0;i<N;i++){
if(T[i]==0){
if(V[i]&f){
a1c.insert(i);
}
else{
s0c.insert(i);
}
}
else{
if(V[i]&f){
s1c.insert(i);
}
else{
a0c.insert(i);
}
}
}
for(int i=0;i<N;i++){
for(int j:a1c){
//cerr << "a " << i << ", " << j << endl;
ret[i][j]|=f;
}
}
for(int i:a1r){
for(int j=0;j<N;j++){
//cerr << "b " << i << ", " << j << endl;
ret[i][j]|=f;
}
}
if((s1r.size()+s0r.size()==1)||(s1c.size()+s0c.size()==1)){
if((s1r.size()==1&&s1c.size())||(s1r.size()&&s1c.size()==1)){
if(s1c.size()){
for(auto i:s1r){
for(auto j:s1c){
//cerr << "c " << i << ", " << j << endl;
ret[i][j]|=f;
}
}
}
}
else if(s1r.size()==1){
if(a1c.size()==0){
for(auto i:s1r){
for(auto j:s0c){
//cerr << "d " << i << ", " << j << endl;
ret[i][j]|=f;
}
}
}
}
else if(s1c.size()==1){
if(a1r.size()==0){
for(auto i:s0r){
for(auto j:s1c){
//cerr << "e " << i << ", " << j << endl;
ret[i][j]|=f;
}
}
}
}
}
else{
vector<int> r,c;
for(auto i:s0r){
r.push_back(i);
}
for(auto i:s1r){
r.push_back(i);
}
for(auto i:s0c){
c.push_back(i);
}
for(auto i:s1c){
c.push_back(i);
}
for(int i=0;i<r.size();i++){
for(int j=0;j<c.size();j++){
if((i+j)%2==0){
ret[r[i]][c[j]]|=f;
}
}
}
}
}
#if 1
for(int i=0;i<N;i++){
LL a=ret[i][0];
for(int j=1;j<N;j++){
if(S[i]==0){
a&=ret[i][j];
}
else{
a|=ret[i][j];
}
}
if(a!=U[i]){
//cerr << "aaa " << a << ", " << i << ", " << U[i] << endl;
cout << -1 << endl;
return 0;
}
}
for(int j=0;j<N;j++){
LL a=ret[0][j];
for(int i=1;i<N;i++){
if(T[j]==0){
a&=ret[i][j];
}
else{
a|=ret[i][j];
}
}
if(a!=V[j]){
//cerr << "bbb " << a << ", " << j << ", " << V[j] << endl;
cout << -1 << endl;
return 0;
}
}
#endif
for(int i=0;i<N;i++){
auto sp="";
for(int j=0;j<N;j++){
cout << sp << ret[i][j];
sp=" ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vec[((int)1e5 + 5)];
vector<int> ans[2];
int col[((int)1e5 + 5)], vis[((int)1e5 + 5)];
bool dfs(int n, int c) {
vis[n] = 1;
ans[c].push_back(n);
col[n] = c;
for (auto p : vec[n]) {
int a = p.first, b = p.second;
b = b ^ c;
if (!vis[a]) {
if (!dfs(a, b)) return 0;
} else {
if (col[a] != b) return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n, m;
cin >> n >> m;
while (m--) {
int a, b, edg;
string col;
cin >> a >> b >> col;
if (col[0] == 'R')
edg = 1;
else
edg = 0;
vec[a].push_back({b, edg});
vec[b].push_back({a, edg});
}
bool flag = 1;
vector<int> taken[2];
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans[0].clear();
ans[1].clear();
if (!dfs(i, 0)) {
flag = 0;
break;
} else {
bool idx = 1;
if (ans[0].size() < ans[1].size()) idx = 0;
for (int a : ans[idx]) taken[0].push_back(a);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < vec[i].size(); j++) {
vec[i][j].second = !vec[i][j].second;
}
}
memset(vis, 0, sizeof vis);
bool tmp = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
ans[0].clear();
ans[1].clear();
if (!dfs(i, 0)) {
tmp = 0;
break;
} else {
bool idx = 1;
if (ans[0].size() < ans[1].size()) idx = 0;
for (int a : ans[idx]) taken[1].push_back(a);
}
}
}
int idx = -1;
if (flag && tmp) {
if (taken[0].size() < taken[1].size())
idx = 0;
else
idx = 1;
} else if (flag)
idx = 0;
else if (tmp)
idx = 1;
if (idx != -1) {
cout << taken[idx].size() << "\n";
for (int a : taken[idx]) cout << a << " ";
cout << "\n";
} else
cout << "-1\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int MX = 1000000000000000;
long long int t, n, k;
long long int a[200];
long long int rep[200];
long long int res[200];
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 0; i <= 100; i++) rep[i] = 0;
vector<long long int> v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (rep[a[i]] == 0) {
v.push_back(a[i]);
}
rep[a[i]] = 1;
}
if (v.size() > k) {
cout << "-1\n";
} else {
for (int i = v.size(); i < k; i++) v.push_back(1);
cout << k * n << endl;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v.size(); j++) cout << v[j] << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3fffffff;
int father[maxn], cnt[maxn];
int k[maxn], l[maxn];
int n, m;
void initial() {
for (int i = 1; i <= maxn; i++) father[i] = i;
}
int findFather(int x) {
int a = x;
while (x != father[x]) x = father[x];
while (a != father[a]) {
int z = a;
a = father[a];
father[z] = x;
}
return x;
}
void Union(int a, int b) {
int faA = findFather(a);
int faB = findFather(b);
if (faA != faB) father[faA] = faB;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
initial();
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
cnt[a]++;
cnt[b]++;
Union(a, b);
}
for (int i = 1; i <= n; i++) {
int temp = findFather(i);
k[temp]++;
l[temp] += cnt[i];
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (k[i] != 0)
if (k[i] > l[i] / 2) res++;
}
cout << res;
return ~~(0 - 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.141592653589793238462;
map<long long, long long> x, y;
map<pair<long long, long long>, long long> pts;
int main() {
int n;
cin >> n;
long long ans = 0;
long long xi, yi;
for (int i = 0; i < n; i++) {
cin >> xi >> yi;
ans += x[xi] + y[yi] - pts[make_pair(xi, yi)];
x[xi]++, y[yi]++, pts[make_pair(xi, yi)]++;
}
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pi = pair<int, int>;
const int MAXN = 500005;
const int mod = 998244353;
int n, a[MAXN];
vector<lint> solve(){
vector<lint> dap;
dap.push_back(0);
dap.push_back(0);
vector<pi> stk;
for(int i=1; i<n; i++){
int flr = 0;
if(a[i-1] < a[i]){
for(lint x = a[i-1]; x < a[i]; x *= 4) flr += 2;
}
else{
for(lint x = a[i]; x * 4 <= a[i-1]; x *= 4) flr -= 2;
}
if(flr < 0){
stk.emplace_back(flr, i);
dap.push_back(dap.back());
}
else{
lint ret= dap.back();
int prv = i;
while(!stk.empty() && flr > 0 && stk.back().first < 0){
int min_diff = min(-stk.back().first, flr);
ret += (prv - stk.back().second) * flr;
prv = stk.back().second;
flr -= min_diff;
stk.back().first += min_diff;
if(stk.back().first == 0) stk.pop_back();
}
ret += prv * flr;
if(flr > 0) stk.emplace_back(flr, i);
dap.push_back(ret);
}
}
assert(dap.size() == n + 1);
return dap;
}
int main(){
cin >> n;
for(int i=0; i<n; i++) scanf("%d",&a[i]);
vector<lint> sol_pfx = solve();
reverse(a, a + n);
vector<lint> sol_sfx = solve();
reverse(sol_sfx.begin(), sol_sfx.end());
lint ret = 1e18;
for(int i=0; i<=n; i++){
ret = min(ret, sol_pfx[i] + i + sol_sfx[i]);
}
cout << ret << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100007], k;
const long long MOD = 1e9 + 7;
long long fastpow(long long x, long long y) {
if (!y) return 1;
long long recurse = fastpow(x, y / 2);
if (y % 2) return ((recurse * recurse) % MOD * x) % MOD;
return (recurse * recurse) % MOD;
}
long long inv(long long x) { return fastpow(x, MOD - 2); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> k;
long long ans = 2, n = 1;
for (long long i = 0; i < k; ++i) {
cin >> a[i];
n *= (a[i] % 2);
ans = (fastpow(ans, a[i])) % MOD;
}
if (n % 2 == 0)
cout << (((ans * inv(2)) % MOD + 1 + MOD) % MOD * inv(3)) % MOD << '/'
<< (ans * inv(2)) % MOD << '\n';
else
cout << (((ans * inv(2)) % MOD - 1 + MOD) % MOD * inv(3)) % MOD << '/'
<< (ans * inv(2)) % MOD << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
const int mod = 1e9 + 7;
const long double pi = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<long long> seg, a;
long long build(int idx, int l, int r) {
if (l == r) {
seg[idx] = a[l];
return seg[idx];
}
int mid = (l + r) / 2;
long long lo = build(2 * idx, l, mid);
long long hi = build(2 * idx + 1, mid + 1, r);
seg[idx] = lo + hi;
return seg[idx];
}
long long query(int idx, int l, int r, int L, int R) {
if (r < L || l > R) return 0;
if (l >= L && r <= R) return seg[idx];
int mid = (l + r) / 2;
long long lo = query(2 * idx, l, mid, L, R);
long long hi = query(2 * idx + 1, mid + 1, r, L, R);
return lo + hi;
}
int main() {
clock_t clk = clock();
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int T = 1;
for (int t = 1; t <= T; ++t) {
long long n;
cin >> n;
a.resize(n + 1);
for (int i = 1; i < n + 1; ++i) cin >> a[i];
seg.resize(4 * n);
build(1, 1, n);
long long q;
cin >> q;
while (q--) {
long long L, R;
cin >> L >> R;
cout << query(1, 1, n, L, R) / 10 << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 10000007;
const long long mod = 1e9 + 7;
const double pi = acos(-1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> v;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back({x, (i + 1)});
}
sort(v.begin(), v.end());
vector<pair<long long, long long>> ans;
long long t = 0;
while (v[n - 1].first - v[0].first > 0) {
v[n - 1].first--;
v[0].first++;
t++;
ans.push_back({v[n - 1].second, v[0].second});
sort(v.begin(), v.end());
if (t >= k) {
break;
}
}
cout << v[n - 1].first - v[0].first << " " << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
bool ok;
int n, num[3], rt, c[3][N], u, v;
vector<int> E[N], f;
int ans[N];
void dfs(int x, int fa) {
f.push_back(x);
for (int v : E[x]) {
if (v == fa) continue;
dfs(v, x);
}
}
long long solve(int x) {
f.push_back(0);
dfs(x, -1);
for (int i = 0; i < 3; ++i) num[i] = i;
long long res = 8e18;
do {
long long tmp = 0;
for (int i = 1; i <= n; ++i) tmp += c[num[i % 3]][f[i]];
if (res > tmp) {
res = tmp;
for (int i = 1; i <= n; ++i) ans[f[i]] = num[i % 3];
}
} while (next_permutation(num, num + 3));
return res;
}
int main() {
scanf("%d", &n);
for (int j = 0; j < 3; ++j) {
for (int i = 1; i <= n; ++i) {
scanf("%d", &c[j][i]);
}
}
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
E[u].push_back(v), E[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (E[i].size() >= 3) {
ok = 1;
break;
}
if (E[i].size() == 1) rt = i;
}
if (ok)
puts("-1");
else {
printf("%I64d\n", solve(rt));
for (int i = 1; i <= n; ++i) printf("%d%c", 1 + ans[i], " \n"[i == n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
int S[(1 << 18)], dp[(1 << 18)][2], N;
int dyn(int u, bool x) {
if (u == N) return x ? S[N - 1] : 0;
int &v = dp[u][x];
if (~v) return v;
if (!x) return v = dyn(u + 1, 1);
return v = max(S[u - 1] - dyn(u, 0), dyn(u + 1, 1));
}
int main(void) {
scanf("%d", &N), ga(N, S), (memset(dp, -1, sizeof(dp)));
for (int k(1); k < N; k++) S[k] += S[k - 1];
printf("%d\n", dyn(1, 0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int num = 0, k = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') k = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
num *= 10, num += ch - 48, ch = getchar();
}
return num * k;
}
struct point {
long long x, y;
bool operator<(const point &b) const { return x != b.x ? x < b.x : y > b.y; }
} p[100000 + 5];
int a, b, c, d, ans = 0, f[100000 + 5], cnt = 0, n;
long long q[100000 + 5];
int getAns(long long x) {
int l = 1, r = cnt;
if (q[cnt] < x) {
q[++cnt] = x;
return cnt;
}
while (l < r) {
int mid = l + r >> 1;
if (q[mid] < x)
l = mid + 1;
else
r = mid;
}
q[l] = x;
return l;
}
int main() {
scanf("%d", &n);
a = read(), b = read(), c = read(), d = read();
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[i].x = c * 1ll * x - d * 1ll * y;
p[i].y = b * 1ll * y - a * 1ll * x;
}
sort(p + 1, p + 1 + n);
for (int i = 1; i <= n; i++)
if (p[i].y > 0 && p[i].x > 0) f[i] = getAns(p[i].y), ans = max(ans, f[i]);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[105];
cin >> s + 1;
int n = strlen(s + 1);
bool ans = 0;
for (int i = 1; i <= n; i++)
if (isalpha(s[i]) && isalpha(s[i - 1]) && isalpha(s[i + 1]) &&
s[i] != s[i - 1] && s[i] != s[i + 1] && s[i - 1] != s[i + 1])
ans = 1;
cout << (ans ? "YES" : "NO") << endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
using namespace std;
struct block {
int wt, st;
long long val;
bool operator < (const block &b) const {
return wt+st < b.wt+b.st;
}
};
int n;
block a[1010];
long long dp[20010];
long long o = 0;
int main () {
cin >> n;
for (int i=0; i<n; i++) {
cin >> a[i].wt >> a[i].st >> a[i].val;
}
sort(a, a+n);
for (int i=0; i<n; i++) {
for (int j=min(a[i].st, 20005-a[i].wt); j>=0; j--) {
dp[j+a[i].wt] = max(dp[j+a[i].wt], dp[j]+a[i].val);
o = max(o, dp[j+a[i].wt]);
}
}
cout << o << endl;
} | 0 |
#include <iostream>
#include <cmath>
#include <map>
#include <string>
#include <queue>
using namespace std;
static const int LIMIT = 100;
static const int N = 4;
static const char dir[4] = {'r', 'l', 'u', 'd'};
static const int dx[4] = {0, -1, 0, 1};
static const int dy[4] = {1, 0, -1, 0};
int MD[N*N][N*N];
class Puzzle {
public:
int v[N*N];
int space_pos;
int MD;
};
Puzzle state;
int limit;
int path[LIMIT];
bool isTarget(Puzzle& p) {
for (int i = 0; i < N*N; i++) {
if (state.v[i] != ((i+1) % (N*N))) {
return false;
}
}
return true;
}
int getAllMD(Puzzle& p) {
int sum = 0;
for (int i = 0; i < N*N; i++) {
if (!p.v[i]) continue;
sum += MD[p.v[i]-1][i];
}
return sum;
}
int dfs(int depth, int prev) {
if (state.MD == 0) {
return true;
}
if (depth + state.MD > limit) return false;
for (int i = 0; i < 4; i++) {
int sx = state.space_pos % N;
int sy = state.space_pos / N;
int tx = sx + dx[i];
int ty = sy + dy[i];
Puzzle tmp;
if (tx >= 0 && tx < N &&
ty >= 0 && ty < N &&
max(prev, i) - min(prev, i) != 2) {
tmp = state;
state.MD -= MD[tx+ty*N][state.v[tx+ty*N]-1];
state.MD += MD[sx+sy*N][state.v[tx+ty*N]-1];
swap(state.v[sx+sy*N], state.v[tx+ty*N]);
state.space_pos = tx+ty*N;
if (dfs(depth+1, i)) {
path[depth] = i;
return true;
}
state = tmp;
}
}
return false;
}
string iterative_deepening(Puzzle& in) {
in.MD = getAllMD(in);
for (limit = in.MD; limit <= LIMIT; limit++) {
state = in;
if (dfs(0, -100)) {
string ans = "";
for (int i = 0; i < limit; i++) {
ans += dir[path[i]];
}
return ans;
}
}
}
int main() {
for (int i = 0; i < N*N; i++) {
for (int j = 0; j < N*N; j++) {
MD[i][j] = abs(i/N - j/N) + abs(i%N - j%N);
}
}
Puzzle p;
for (int i = 0; i < N*N; i++) {
cin >> p.v[i];
if (!p.v[i]) p.space_pos = i;
}
cout << iterative_deepening(p).size() << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fr(i,n) for(int i=0;i++<n;)
int main(){
int n,m,a,b,c[55]={};
cin>>n>>m;
fr(i,2*m){
cin>>a;
c[a]++;
}
fr(i,n) cout<<c[i]<<endl;
} | 0 |
#include <bits/stdc++.h>
int main() {
char a[15], b[15];
int M[12], m1, m2, m3, i;
gets(a);
gets(b);
if (strcmp(a, "monday") == 0) m1 = 1;
if (strcmp(a, "tuesday") == 0) m1 = 2;
if (strcmp(a, "wednesday") == 0) m1 = 3;
if (strcmp(a, "thursday") == 0) m1 = 4;
if (strcmp(a, "friday") == 0) m1 = 5;
if (strcmp(a, "saturday") == 0) m1 = 6;
if (strcmp(a, "sunday") == 0) m1 = 7;
if (strcmp(b, "monday") == 0) m3 = 1;
if (strcmp(b, "tuesday") == 0) m3 = 2;
if (strcmp(b, "wednesday") == 0) m3 = 3;
if (strcmp(b, "thursday") == 0) m3 = 4;
if (strcmp(b, "friday") == 0) m3 = 5;
if (strcmp(b, "saturday") == 0) m3 = 6;
if (strcmp(b, "sunday") == 0) m3 = 7;
M[0] = 31;
M[1] = 28;
M[2] = 31;
M[3] = 30;
M[4] = 31;
M[5] = 30;
M[6] = 31;
M[7] = 31;
M[8] = 30;
M[9] = 31;
M[10] = 30;
M[11] = 31;
for (i = 0; i < 12; i++) {
m2 = m1 + (M[i]) % 7;
if ((m2 > 7) && (m2 % 7 == 0))
m2 = 7;
else if (m2 > 7)
m2 = m2 % 7;
if (m2 == m3) {
printf("YES\n");
i = 24;
}
}
if (i < 20) printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string f1, f2;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y, r;
cin >> x >> y >> r;
if (i) f1 += "+";
if (i)
f1 += "(" + to_string(x / 2) + "*(2-abs(((0-abs((t-" + to_string(i - 1) +
")))+abs((t-" + to_string(i + 1) + "))))))";
else
f1 += "(" + to_string(x / 2) + "*(2-abs(((0-abs((t+1)))+abs((t-" +
to_string(i + 1) + "))))))";
if (i) f2 += "+";
if (i)
f2 += "(" + to_string(y / 2) + "*(2-abs(((0-abs((t-" + to_string(i - 1) +
")))+abs((t-" + to_string(i + 1) + "))))))";
else
f2 += "(" + to_string(y / 2) + "*(2-abs(((0-abs((t+1)))+abs((t-" +
to_string(i + 1) + "))))))";
if (i) {
f1 = "(" + f1 + ")";
f2 = "(" + f2 + ")";
}
}
cout << f1 << endl << f2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l;
int id;
} node[1100];
bool cmp1(const Node &a, const Node &b) { return a.l > b.l; }
bool cmp2(const Node &a, const Node &b) { return a.id < b.id; }
int n, k;
int zuo[110][110];
inline int ABS(int a) {
if (a < 0) return -a;
return a;
}
int main() {
cin >> n >> k;
int pp = k / 2 + 1;
int len;
int ww, i, j, z;
memset(zuo, 0, sizeof(zuo));
for (ww = 1; ww <= n; ww++) {
cin >> len;
int sum = 10000000;
int r = -1, c = -1;
for (i = 1; i <= k; i++) {
for (j = 1; j <= k - len + 1; j++) {
int ok = 1;
int p = 0;
for (z = j; z <= j + len - 1; z++) {
if (zuo[i][z] == 1) {
ok = 0;
break;
}
p += ABS(i - pp) + ABS(z - pp);
}
if (ok == 1) {
if (p < sum) {
r = i;
c = j;
sum = p;
}
}
}
}
if (r == -1) {
cout << "-1" << endl;
} else {
for (j = c; j <= c + len - 1; j++) zuo[r][j] = 1;
cout << r << " " << c << " " << c + len - 1 << endl;
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n; cin >> n;
map<string, int> mp;
long long ans = 0;
for(int i = 0; i < n; i++){
string s; cin >> s;
sort(s.begin(), s.end());
ans += mp[s];
mp[s]++;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, m, a, b, c, d, e, sum = 0, l = -1000000;
string name, max;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> name;
cin >> p >> m >> a >> b >> c >> d >> e;
sum = (p * 100) - (m * 50) + a + b + c + d + e;
if (sum > l) {
max = name;
l = sum;
}
}
cout << max;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int x, y, a, b;
cin >> x >> y >> a >> b;
int t;
if ((x - y) % (a + b) == 0)
cout << abs((x - y) / (a + b)) << endl;
else
cout << "-1" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0;
map<int, int> a;
for (int i = 0; i < 5; i++) {
int l;
cin >> l;
a[l]++;
if (a[l] > 3) a[l] = 3;
sum += l;
}
int max = 0;
map<int, int>::iterator it;
for (it = a.begin(); it != a.end(); it++)
if (max < it->first * it->second && it->second > 1)
max = it->first * it->second;
cout << sum - max;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int step[N];
int main() {
int n, k, x;
while (~scanf("%d%d", &n, &k)) {
memset(step, 0, sizeof(step));
set<int> s;
for (int i = 0; i < k; i++) {
scanf("%d", &x);
s.insert(x);
}
queue<int> q;
q.push(0);
bool flag = false;
while (!flag && !q.empty()) {
int u = q.front();
q.pop();
for (auto i : s) {
if (u + i - n < -1000 || u + i - n > 1000) continue;
if (u + i - n == 0) {
printf("%d\n", step[u + 1000] + 1);
flag = true;
break;
} else if (step[u + i - n + 1000] == 0) {
step[u + i - n + 1000] = step[u + 1000] + 1;
q.push(u + i - n);
}
}
}
if (!flag) printf("-1\n");
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int w[1000];
int m;
int n;
bool kuwa(int s) {
int t = s;
int l = m;
for(int i = 0; i < n; i++) {
if (t - w[i] >= 0) {
t -= w[i];
}else{
t = s;
l --;
i --;
if (l <= 0) {
return false;
}
}
}
return true;
}
int bin_search(int min, int max) {
int s = (min + max) / 2;
if (min + 1 == max) {
if (kuwa(min)) {
return min;
}else{
return max;
}
}
if (! kuwa (s) ) {
return bin_search(s, max);
} else {
return bin_search(min, s);
}
}
int main() {
while (1) {
cin >> m >> n;
if ((n == 0) && (m == 0)) {
return 0;
}
for (int i = 0; i < n; i++) {
cin >> w[i];
}
cout << bin_search(0, 100000000) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void Solve() {
long long a, b, c;
cin >> a >> b;
c = abs(a - b);
cout << c / 5 + (c % 5) / 2 + (c % 5) % 2 << endl;
}
int main() {
int _;
for (cin >> _; _--;) Solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, p[200005];
int ans[200005];
queue<int> q;
int main() {
int Q;
cin >> Q;
while (Q--) {
memset(ans, 0, sizeof(ans));
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) {
if (ans[i]) continue;
int step = 1;
q.push(i);
for (int j = p[i]; j != i; j = p[j]) {
q.push(j);
step++;
}
while (!q.empty()) {
ans[q.front()] = step;
q.pop();
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD7 = 1000000000 + 7;
const int MOD9 = 1000000000 + 9;
int main() {
int t = ({
int x;
scanf("%d", &x);
x;
});
for (int _ = (0); _ < (t); _ += (1)) {
int n = ({
int x;
scanf("%d", &x);
x;
});
string a, b;
cin >> a >> b;
vector<int> h(26), h2(26);
for (int i = (0); i < (n); i += (1)) {
h[a[i] - 'a']++;
h2[b[i] - 'a']++;
}
bool ok = true;
for (int i = (0); i < (26); i += (1)) {
if (h[i] != h2[i]) {
ok = false;
}
}
int dup = 0;
if (ok) {
for (int i = (0); i < (26); i += (1))
if (h[i] > 1) {
dup = 1;
break;
}
int c = 0;
if (!dup) {
for (int i = (0); i < (n); i += (1)) {
int pos = -1;
for (int j = (i); j < (n); j += (1)) {
if (b[j] == a[i]) {
pos = j;
break;
}
}
c += pos - i;
string newB = "";
for (int j = (0); j < (i); j += (1)) {
newB += b[j];
}
newB += a[i];
for (int j = (i); j < (n); j += (1)) {
if (j != pos) newB += b[j];
}
b = newB;
}
if (c % 2) ok = false;
}
}
cout << (ok ? "YES" : "NO") << "\n";
}
}
| 6 |
#include <iostream>
#include <vector>
using namespace std;
int n, k;
string str;
int nxt[26];
vector<int> v[26];
int bit[200005];
inline void add(int i, int x){
i++;
while(i<200005){
bit[i]+=x;
i+=i&-i;
}
}
inline int sum(int i){
i++;
int ret=0;
while(i){
ret+=bit[i];
i-=i&-i;
}
return ret;
}
void gonext(int i){
}
int main(){
cin >> str >> k;
n=str.length();
fill(bit, bit+200005, 0);
fill(nxt, nxt+26, 0);
for(int i=0; i<n; i++){
add(i, 1);
v[str[i]-'a'].push_back(i);
}
for(int i=0; i<n; i++){
for(int j=0; j<26; j++){
if(nxt[j]==v[j].size()) continue;
int cnt=sum(v[j][nxt[j]]-1);
if(cnt<=k){
k-=cnt;
add(v[j][nxt[j]], -1);
cout << (char)('a'+j);
if(nxt[j]<v[j].size()) nxt[j]++;
break;
}
}
}
cout << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long H;
long long d[1000001];
long long pre[1000001];
int id_minx = -1;
long long R = 0;
int main() {
cin >> H >> n;
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &d[i]);
pre[i] += pre[i - 1];
pre[i] += d[i];
if (id_minx == -1) {
R = pre[i];
id_minx = i;
}
if (pre[i] < pre[id_minx]) {
id_minx = i;
R = pre[i];
}
}
if (R >= 0) {
cout << -1 << endl;
return 0;
} else {
if (pre[n] >= 0) {
for (int i = 1; i <= n; i++) {
H += d[i];
if (H <= 0) {
cout << i;
return 0;
}
}
cout << -1 << endl;
return 0;
} else {
long long maxx = 1e18;
long long st = 0, En = min(maxx, 1LL * (H) / (-pre[n]) + 3);
long long ans = 1e18;
while (st <= En) {
long long mid = (st + En) / 2;
long long temp = H + mid * pre[n];
long long ans2 = mid * n;
for (int j = 1; j <= n; j++) {
if (temp <= 0) break;
ans2++;
temp += d[j];
}
if (temp <= 0) {
ans = min(ans, ans2);
En = mid - 1;
} else {
st = mid + 1;
}
}
cout << ans << endl;
}
}
}
| 5 |
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int M=45;
const int N=1e3+5;
int n,m,lim,tmp[M];
ll X[N],Y[N];
template <typename _Tp> inline void IN(_Tp&x) {
char ch;bool flag=0;x=0;
while(ch=getchar(),!isdigit(ch)) if(ch=='-') flag=1;
while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
if(flag) x=-x;
}
int main() {
IN(n);
for(int i=1;i<=n;++i) IN(X[i]),IN(Y[i]);
bool val=abs(X[1]+Y[1])&1;
for(int i=1;i<=n;++i)
if((abs(X[i]+Y[i])&1)!=val) return puts("-1"),0;
tmp[m=1]=1;
for(int i=val;i<=30;++i) tmp[++m]=1<<i;
printf("%d\n",lim=m);
for(int i=1;i<=m;++i) printf("%d ",tmp[i]);puts("");
static char ans[M];
for(int i=1;i<=n;++i) {
for(int j=m;j;--j) {
if(abs(X[i])>abs(Y[i])) {
if(X[i]>0) X[i]-=tmp[j],ans[j]='R';
else X[i]+=tmp[j],ans[j]='L';
} else {
if(Y[i]>0) Y[i]-=tmp[j],ans[j]='U';
else Y[i]+=tmp[j],ans[j]='D';
}
}
printf("%s\n",ans+1);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = n / 4;
int rem = n % 4;
for (int i = 0; i < x; i++) {
cout << "abcd";
}
if (rem == 1)
cout << "a";
else if (rem == 2)
cout << "ab";
else if (rem == 3)
cout << "abc";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
string s[9];
for (int i = 0; i < 9; i++) cin >> s[i];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (s[i][j] == '2') s[i][j] = '1';
}
}
for (int i = 0; i < 9; i++) cout << s[i] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, i;
using namespace std;
int main() {
cin >> n;
for (int j = 0; j < n; j++) {
cin >> i;
if (i == 1) {
cout << "HARD\n";
return 0;
}
}
cout << "EASY\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 2000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 600;
const int maxL = 20;
pair<int, int> a[maxN];
long long dis(pair<int, int> p, pair<int, int> q) {
int dx = p.first - q.first;
int dy = p.second - q.second;
return (1LL) * dx * dx + (1LL) * dy * dy;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
vector<long long> v;
v.push_back(0);
for (int i = 0; i < n; i++) v.push_back(dis(a[i], make_pair(x1, y1)));
sort(v.begin(), v.end());
long long ans = (1LL) * mod * mod;
for (int i = 0; i < (int)v.size(); i++) {
long long mx = 0;
for (int j = 0; j < n; j++) {
if (dis(a[j], make_pair(x1, y1)) > v[i])
mx = max(mx, dis(a[j], make_pair(x2, y2)));
}
ans = min(ans, mx + v[i]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int n;
cin >> n;
int ma[105][105]={{}};
int i,j;
long long o=0;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
cin >> ma[i][j];
}
}
for(i=0;i<n;i++){
for(j=i;j<n;j++){
o+=min(ma[i][j],ma[j][i]);
}
}
cout << o << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 20);
int cnt(char ch) {
if (islower(ch)) return ch - 'a' + 1;
if (isupper(ch)) return ch - 'A' + 27;
if (isdigit(ch)) return ch - '0' + 53;
}
int hashy(char a, char b) {
int let1 = cnt(a), let2 = cnt(b);
return (let1 - 1) * 62 + let2;
}
vector<int> v[MX];
int N, n = 4001, indeg[MX], outdeg[MX], timer = 0, low[MX], depth[MX], start;
bool nosol = 0, vi[MX];
string str[MX];
map<int, vector<int> > dict[4009];
void dfs(int x) {
low[x] = depth[x] = ++timer;
vi[x] = 1;
int _sz = v[x].size(), nxt;
for (int j = 0; j < _sz; j++) {
nxt = v[x][j];
if (!depth[nxt]) {
dfs(nxt);
low[x] = min(low[x], low[nxt]);
} else if (vi[nxt])
low[x] = min(low[x], depth[nxt]);
}
if (low[x] == depth[x] && x != start) nosol = 1;
}
stack<int> S;
int main() {
cin >> N;
for (int j = 1; j <= N; j++) {
int U, V;
cin >> str[j];
U = hashy(str[j][0], str[j][1]);
V = hashy(str[j][1], str[j][2]);
indeg[V]++;
outdeg[U]++;
v[U].push_back(V);
dict[U][V].push_back(j);
}
int src = 0, snk = 0;
for (int j = 1; j <= n; j++) {
if (indeg[j] - outdeg[j] == 1) snk = j;
if (outdeg[j] - indeg[j] == 1) src = j;
}
for (int j = 1; j <= n; j++) {
if (j == src || j == snk) continue;
if (indeg[j] != outdeg[j]) {
nosol = 1;
}
}
if ((!src && snk) || (snk && !src)) nosol = 1;
if (src + snk == 0)
for (int j = 1; j <= n; j++)
if (indeg[j] != outdeg[j]) nosol = 1;
if (nosol) {
puts("NO");
return 0;
}
if (src) {
start = src;
v[snk].push_back(src);
} else
for (int j = 1; j <= n; j++)
if (v[j].size()) start = j;
dfs(start);
if (nosol) {
puts("NO");
return 0;
}
for (int j = 1; j <= n; j++)
if ((indeg[j] || outdeg[j]) && !depth[j]) nosol = 1;
if (nosol) {
puts("NO");
return 0;
}
puts("YES");
if (src) v[snk].pop_back();
S.push(start);
vector<int> sol;
while (!S.empty()) {
int x = S.top(), _sz = v[x].size(), nxt;
if (v[x].size()) {
nxt = v[x].back();
v[x].pop_back();
S.push(nxt);
continue;
}
sol.push_back(x);
S.pop();
}
reverse(sol.begin(), sol.end());
string ans;
int curst, par = sol[0], node = sol[1];
curst = dict[par][node].back();
ans += str[curst].substr(0, 2);
for (int j = 1; j < sol.size(); j++) {
par = sol[j - 1], node = sol[j];
curst = dict[par][node].back();
ans.push_back(str[curst][2]);
dict[par][node].pop_back();
}
cout << ans << endl;
}
| 4 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s,result;
cin >> s;
s.insert(s.begin() + 4,' ');
cout << s << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
double d;
struct station {
int x;
int y;
double refill;
int dist(const station& other) { return abs(other.x - x) + abs(other.y - y); }
};
struct state {
int idx;
double dist;
};
auto cmp = [](const state& l, const state& r) { return l.dist > r.dist; };
priority_queue<state, vector<state>, decltype(cmp)> pq(cmp);
station v[100];
double cost[100][100];
bool visited[100];
int dist[100];
int main() {
cin >> n >> d;
for (int i = 1; i < n - 1; i++) cin >> v[i].refill;
for (int i = 0; i < n; i++) {
cin >> v[i].x >> v[i].y;
dist[i] = (1 << 30);
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
cost[j][i] = cost[i][j] =
d * v[i].dist(v[j]) - (v[i].refill + v[j].refill) / 2;
pq.push({0, 0});
while (!pq.empty()) {
state current = pq.top();
pq.pop();
if (visited[current.idx]) continue;
visited[current.idx] = true;
if (current.idx == n - 1) {
cout << (int)current.dist;
return 0;
}
for (int i = 1; i < n; i++) {
if (!visited[i]) {
state newState = {i, current.dist + cost[current.idx][i]};
if (newState.dist < dist[i]) {
dist[i] = newState.dist;
pq.push(newState);
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int Soma = 0;
bool K = false;
int Soma2 = 0;
int N, i;
string S;
scanf("%d", &N);
cin >> S;
for (i = 0; i < N / 2; i++) {
if (S[i] == '4') {
Soma += 4;
} else {
if (S[i] == '7') {
Soma += 7;
} else {
K = true;
break;
}
}
}
for (i = N / 2; i < N; i++) {
if (S[i] == '4') {
Soma2 += 4;
} else {
if (S[i] == '7') {
Soma2 += 7;
} else {
K = true;
break;
}
}
}
if (K != true && Soma == Soma2) {
printf("YES\n");
} else {
printf("NO\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e3 + 10;
long long sumb[maxn], N;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
string str;
cin >> str;
N = str.size();
for (register long long i = 1; i <= N; ++i) {
sumb[i] = sumb[i - 1] + (str[i - 1] == 'b');
}
long long ans = 0;
for (register long long i = 0; i <= N; ++i) {
for (register long long j = i + 1; j <= N + 1; ++j) {
long long head = i - sumb[i],
tail = (N - j + 1) - (sumb[N] - sumb[j - 1]);
long long mid = sumb[j - 1] - sumb[i];
ans = max(ans, head + mid + tail);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long pow(long long x, long long y, long long p) {
long long t = 1;
for (; y; y >>= 1, x = x * x % p)
if (y & 1) t = t * x % p;
return t;
}
struct Node {
int a, b, c;
bool operator<(const Node& o) const {
if (a == o.a) return b > o.b;
return a > o.a;
}
} nd[1000005];
map<int, int> mirror;
int D[1000005];
int n;
inline void addD(int p, int x) {
for (int i = p; i <= n; i += (i & -i)) D[i] = max(D[i], x);
}
inline int getmax(int p) {
int ans = -0x3f3f3f3f;
for (int i = p; i; i -= (i & -i)) ans = max(ans, D[i]);
return ans;
}
int main() {
memset(D, 0, sizeof(D));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &nd[i].a);
for (int i = 0; i < n; i++) {
scanf("%d", &nd[i].b);
mirror[nd[i].b] = 1;
}
int cnt = n + 1;
for (auto p = mirror.begin(); p != mirror.end(); p++) {
p->second = cnt--;
}
for (int i = 0; i < n; i++) {
nd[i].b = mirror[nd[i].b];
}
for (int i = 0; i < n; i++) scanf("%d", &nd[i].c);
sort(nd, nd + n);
int ans = 0;
for (int i = 0; i < n; i++) {
int tmp = getmax(nd[i].b - 1);
if (tmp > nd[i].c) ans++;
addD(nd[i].b, nd[i].c);
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, i;
int main(void) {
scanf("%I64d %I64d", &n, &k);
float lim = sqrt(n);
std::vector<long long int> v;
for (i = 1; i <= lim; ++i) {
if (n % i == 0) v.push_back(i);
}
long long int q = v.size();
if (n == 1) {
switch (k) {
case 1:
cout << 1;
break;
default:
cout << -1;
break;
}
return 0;
}
if (q == 1) {
switch (k) {
case 1:
printf("1");
break;
case 2:
printf("%I64d", n);
break;
default:
printf("-1");
break;
}
return 0;
}
if (v[q - 1] * v[q - 1] == n) {
if (k <= q)
printf("%I64d", v[k - 1]);
else if (k < (2 * q) && v[q - 1 - k % q])
printf("%I64d", n / v[q - 1 - k % q]);
else
printf("-1");
} else {
if (k <= q)
printf("%I64d", v[k - 1]);
else if (k < (2 * q) && v[q - k % q])
printf("%I64d", n / v[q - k % q]);
else if (k == 2 * q)
printf("%I64d", n);
else
printf("-1");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int ll_max(long long int a, long long int b, long long int c) {
return max(a, max(b, c));
}
int int_max(int a, int b, int c) { return max(a, max(b, c)); }
long long int ll_min(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
int int_min(int a, int b, int c) { return min(a, min(b, c)); }
long long int max(int a, long long int b) { return max((long long int)a, b); }
long long int min(int a, long long int b) { return min((long long int)a, b); }
long long int min(long long int a, int b) { return min(a, (long long int)b); }
long long int max(long long int a, int b) { return max(a, (long long int)b); }
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int power(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int a = power(x, y / 2, m);
if (y % 2) {
return (a * ((a * x) % m)) % m;
} else {
return (a * a) % m;
}
}
long long int mod_inverse(long long int x, long long int m) {
return power(x, m - 2, m);
}
long long int fact(long long int n, long long int m) {
if (n <= 1) return 1;
return (fact(n - 1, m) * n) % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
if (r > n) return 0;
long long int n1 = 1, d1 = 1, d2 = 1;
n1 = fact(n, m);
d1 = fact(r, m);
d2 = fact(n - r, m);
long long int ans = mod_inverse((d1 * d2) % m, m);
ans = (ans * n1) % m;
return ans;
}
int gcd(int a, int b) {
if (a == 0 || b == 0) return max(a, b);
if (a < b) return gcd(b, a);
if (a % b == 0) return b;
return gcd(b, a % b);
}
int ispal(string s) {
int len = s.size();
int flag = 1;
for (int i = 0; i < len; ++i) {
if (s[i] != s[len - i - 1]) {
flag = 0;
break;
}
}
return flag;
}
long long int sroot(long long int n, long long int low = 1,
long long int high = 1e9 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid;
if (a > n)
return sroot(n, low, mid - 1);
else
return sroot(n, mid, high);
}
long long int croot(long long int n, long long int low = 1,
long long int high = 1e6 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid * mid;
if (a > n)
return croot(n, low, mid - 1);
else
return croot(n, mid, high);
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long int t = 1;
cin >> t;
long long int dp[30]{};
long long int found = -1;
long long int ans = 0;
for (long long int k = 1; k <= t; k++) {
char ch;
string str;
if (k == t) break;
cin >> ch >> str;
if (found == 1 && (ch == '!' || ch == '?')) {
ans++;
continue;
}
set<char> second;
for (long long int i = 0; i < str.length(); i++) second.insert(str[i]);
if (ch == '!' || ch == '.') {
set<char>::iterator it;
it = second.begin();
while (it != second.end()) {
char r = *it;
it++;
if (ch == '!')
dp[r - 'a']++;
else
dp[r - 'a']--;
}
}
if (ch == '?') {
dp[str[0] - 'a']--;
}
if (found == -1) {
long long int max1 = -1;
for (long long int i = 0; i < 26; i++) max1 = max(max1, dp[i]);
long long int g = 0;
for (long long int i = 0; i < 26; i++) {
if (dp[i] == max1) g++;
}
if (g == 1) found = 1;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1003;
const long long MOD = 1000000007;
const int M = 2 * 2 * 2 * 3 * 3 * 5 * 7;
int getID(int nd, int rem) { return nd * M + rem; }
int n, k[MAXN];
int edge[MAXN * M];
int to[11];
bool vis[MAXN * M];
int dp[MAXN * M];
void mark(int nd) {
vis[nd] = true;
if (!vis[edge[nd]]) {
mark(edge[nd]);
}
}
int FindHead(int nd) {
int x = nd, y = nd;
bool used = false;
while (true) {
if (vis[y]) {
used = true;
break;
}
x = edge[edge[x]];
y = edge[y];
if (x == y) {
break;
}
}
mark(nd);
if (used) {
return -1;
}
return x;
}
void BuildCycle(int st) {
vector<int> id;
vector<int> v;
int nd = st;
while (true) {
id.emplace_back(nd);
v.emplace_back(nd / M);
nd = edge[nd];
if (nd == st) {
break;
}
}
sort(v.begin(), v.end());
int sz = unique(v.begin(), v.end()) - v.begin();
for (auto u : id) {
dp[u] = sz;
}
}
void solve(int nd) {
if (dp[edge[nd]] == 0) {
solve(edge[nd]);
}
dp[nd] = dp[edge[nd]];
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> k[i];
}
for (int i = 0; i < n; ++i) {
int d;
cin >> d;
for (int j = 0; j < d; ++j) {
cin >> to[j];
to[j]--;
}
for (int r = 0; r < M; ++r) {
int nx = (r + k[i]) % M;
nx = nx < 0 ? nx + M : nx;
edge[getID(i, r)] = getID(to[nx % d], nx);
}
}
for (int i = 0; i < n * M; ++i) {
if (vis[i] == 0) {
int st = FindHead(i);
if (st != -1) {
BuildCycle(st);
}
}
}
for (int i = 0; i < n * M; ++i) {
if (dp[i] == 0) {
solve(i);
}
};
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
x--;
int rem = y % M;
rem = rem < 0 ? rem + M : rem;
cout << dp[getID(x, rem)] << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3;
const long long int LINF = (long long int)1e18;
int n, s, t;
long long int x[N + 1];
long long int a[N + 1];
long long int b[N + 1];
long long int c[N + 1];
long long int d[N + 1];
long long int dist[N + 1][N + 1];
int nxt[N + 1];
void all_distance() {
for (int i = 1, _stop = n; i <= _stop; i++) {
for (int j = 1, _stop = n; j <= _stop; j++) {
if (j < i) {
dist[i][j] = x[i] - x[j] + c[i] + b[j];
} else if (j > i) {
dist[i][j] = x[j] - x[i] + d[i] + a[j];
}
}
}
}
void solve() {
all_distance();
nxt[s] = t;
long long int ans = dist[s][t];
for (int i = 1, _stop = n; i <= _stop; i++) {
if (i == s || i == t) {
continue;
}
int idx;
long long int local_ans = LINF;
for (int j = 1, _stop = n; j <= _stop; j++) {
if (nxt[j] != 0) {
long long int temp =
ans - dist[j][nxt[j]] + dist[j][i] + dist[i][nxt[j]];
if (temp < local_ans) {
local_ans = temp;
idx = j;
}
}
}
ans = local_ans;
nxt[i] = nxt[idx];
nxt[idx] = i;
}
cout << ans << '\n';
}
int main() {
;
ios::sync_with_stdio(false);
cin.tie(NULL);
{
cin >> n >> s >> t;
for (int i = 1, _stop = n; i <= _stop; i++) {
cin >> x[i];
}
for (int i = 1, _stop = n; i <= _stop; i++) {
cin >> a[i];
}
for (int i = 1, _stop = n; i <= _stop; i++) {
cin >> b[i];
}
for (int i = 1, _stop = n; i <= _stop; i++) {
cin >> c[i];
}
for (int i = 1, _stop = n; i <= _stop; i++) {
cin >> d[i];
}
solve();
};
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j <= n; j += 2) {
++res;
}
}
printf("%d\n", res);
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j <= n; j += 2) {
printf("%d %d\n", i, j);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
//#define TEST
int cnt1(int a) {
int cnt = 0;
while (a) {
a /= 2;
++cnt;
}
return cnt;
}
signed main() {
int n; cin >> n;
vector<ll> a(n);
int tmp = 0;
vector<int> op;
for (int i = 0; i < n; ++i) {
cin >> a[i];
tmp ^= a[i];
op.push_back(cnt1(a[i] ^ (a[i] - 1)));
}
if (!tmp) {
cout << 0 << endl;
return 0;
}
sort(op.begin(), op.end());
#ifdef TEST
cout << "----------op----------" << endl;
for (auto opi : op)
cout << opi << " ";
cout << endl;
#endif
vector<int> bt(31, 0);
for (int i = 0; i < 31; ++i)
if ((1 << i) & tmp)
++bt[i];
vector<int> need;
for (int i = 0; i < 30; ++i) {
if (bt[i] != bt[i + 1])
need.push_back(i + 1);
}
#ifdef TEST
cout << "---------need---------" << endl;
for (auto ni : need)
cout << ni << " ";
cout << endl;
#endif
for (auto ni : need) {
if ((*lower_bound(op.begin(), op.end(), ni)) != ni) {
cout << -1 << endl;
return 0;
}
}
cout << need.size() << endl;
return 0;
} | 0 |
// Undone
#include <bits/stdc++.h>
#define int long long
#define double long double
#define INF 1e18
#define MOD 1000000007
using namespace std;
signed main() {
int N; string S;
cin >> N >> S;
int x = 0, y = 0;
for (int i = 0; i < N; i++) {
char c = S[i];
if ('A' <= c && c <= 'M') {
x++;
} else if ('N' <= c && c <= 'Z') {
x--;
} else if ('a' <= c && c <= 'm') {
y--;
} else if ('n' <= c && c <= 'z') {
y++;
}
}
cout << abs(x)+abs(y) << endl;
char o;
if (y < 0)
o = 'a';
else
o = 'n';
for (int i = 0; i < abs(y); i++) {
cout << o;
}
if (x < 0)
o = 'N';
else
o = 'A';
for (int i = 0; i < abs(x); i++) {
cout << o;
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m = 2;
int main() {
cin >> n;
while (n > 1) {
if (n % m != 0) {
m++;
} else {
cout << n << " ";
n /= m;
}
}
cout << "1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
typedef long long LL;
const int N = 8100, M = 210, p = 998244353, G = 3, invG = (p + 1) / 3;
int A[N << 2], B[N << 2], fac[N], inv[N], rev[N << 2], f[N][M], n, m;
int add(int x, int y) { return x + y >= p ? x + y - p : x + y; }
int sub(int x, int y) { return x - y < 0 ? x - y + p : x - y; }
int inc(int &x, int y) { return x = add(x, y); }
int del(int &x, int y) { return x = sub(x, y); }
int mul(int x, int y) { return 1LL * x * y % p; }
int ksm(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = mul(x, x)) if (y & 1) res = mul(res, x);
return res;
}
void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++ i) fac[i] = mul(fac[i - 1], i);
inv[n] = ksm(fac[n], p - 2);
for (int i = n - 1; ~i; -- i) inv[i] = mul(inv[i + 1], i + 1);
}
int C(int n, int m) { return m > n ? 0 : mul(fac[n], mul(inv[m], inv[n - m])); }
void reverse(int *A, int limit) {
for (int i = 1; i < limit; ++ i) rev[i] = (rev[i >> 1] >> 1) | (i & 1 ? limit >> 1 : 0);
for (int i = 1; i < limit; ++ i) if (i < rev[i]) std::swap(A[i], A[rev[i]]);
}
void NTT(int *A, int limit, int opt) {
reverse(A, limit);
for (int mid = 1; mid < limit; mid <<= 1) {
int len = mid << 1;
int w = ksm(opt == 1 ? G : invG, (p - 1) / len);
for (int i = 0; i < limit; i += len) {
int W = 1;
for (int j = i; j < i + mid; ++ j, W = (LL)W * (LL)w % p) {
int x = A[j], y = (LL)A[j + mid] * (LL)W % p;
A[j] = add(x, y); A[j + mid] = sub(x, y);
}
}
}
if (opt == 1) return;
int inv = ksm(limit, p - 2);
for (int i = 0; i < limit; ++ i) A[i] = ((LL)A[i] * (LL)inv) % p;
}
void MUL(int *a, int n, int *b, int m) {
int len = n + m, limit = 1;
while (limit <= len) limit <<= 1;
NTT(a, limit, 1), NTT(b, limit, 1);
for (int i = 0; i < limit; ++ i) a[i] = ((LL)a[i] * (LL)b[i]) % p;
NTT(a, limit, -1);
}
void Get(int j) {
memset(A, 0, sizeof(A)), memset(B, 0, sizeof(B));
for (int i = 1; i <= n; ++ i) A[i] = inv[i + 2];
for (int i = 0; i <= n; ++ i) B[i] = mul(inv[i], f[i][j - 1]);
for (int i = 0; i <= n; ++ i) inc(f[i][j], mul(f[i][j - 1], add(i + 1, C(i, 2))));
MUL(A, n + 1, B, n + 1);
for (int i = 1; i <= n; ++ i) inc(f[i][j], mul(A[i], fac[i + 2]));
}
signed main() {
std::cin >> n >> m;
init(N - 1), f[0][0] = 1;
for (int i = 1; i <= m; ++ i) Get(i);
int ans = 0;
for (int i = 0; i <= n; ++ i) inc(ans, mul(C(n, i), f[i][m]));
std::cout << ans << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> m >> n;
int ss[35] = {};
for (int i = 0; i < n; i++) {
cout << 1 << endl;
string s;
cin >> s;
if (s == "1") {
ss[i] = 1;
} else {
ss[i] = -1;
}
}
long long r = 1;
while (r <= m) r <<= 1;
long long ans = 0;
r >>= 1;
for (int i = 0; r; r >>= 1) {
if (ans + r > m) continue;
cout << ans + r << endl;
string s;
cin >> s;
if (ss[i] == 1) {
if (s == "1") {
ans += r;
}
} else {
if (s == "-1") {
ans += r;
}
}
i++;
i %= n;
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long int n;
int pos = 0, k = 0;
scanf("%lld", &n);
char s[n];
int x, y;
scanf("%s", s);
if (n == 1 || n == 0) {
pos = -1;
}
for (int i = 0; i < n - 1; i++) {
x = s[i];
y = s[i + 1];
if (x > y) {
pos = i;
break;
} else
pos = -1;
}
if (pos >= 0) {
printf("YES\n%d %d", pos + 1, pos + 2);
} else {
printf("NO");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed long long n;
char ch[5005][5005] = {'0'};
signed long long vis[5005] = {0};
void dfs(signed long long s, signed long long x) {
vis[s] = 1;
for (signed long long i = 1; i <= n; i++) {
if (ch[s][i] == '1') {
if (ch[i][x] == '1') {
cout << x << " " << s << " " << i << endl;
exit(0);
} else if (vis[i] == 0)
dfs(i, s);
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (signed long long i = 1; i <= n; i++)
for (signed long long j = 1; j <= n; j++) cin >> ch[i][j];
for (signed long long i = 1; i <= n; i++) {
if (vis[i] == 0) dfs(i, 0);
}
cout << "-1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<string, long long> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q;
t = 1;
while (t--) {
cin >> n >> m >> p;
for (i = 0; i < n; i++) {
cin >> a;
if (a % p) f = i;
}
for (i = 0; i < m; i++) {
cin >> a;
if (a % p) g = i;
}
cout << f + g << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long inp[300009];
long long arr[300009];
struct node {
int si, ei;
int lf, md, rg;
node(int sii, int eii, int lff = 0, int mdd = 0, int rgg = 0) {
si = sii;
ei = eii;
lf = lff, rg = rgg, md = mdd;
}
node() { si = ei = lf = md = rg = 0; }
};
struct seg_tree {
node nd[4 * 300009];
void init(int in, int s, int e) {
node &n = nd[in];
if (s == e) {
arr[s] = inp[s] - inp[s + 1];
n = node(s, e);
upd_nd(n, 0);
return;
}
int mid = (s + e) / 2;
init(2 * in, s, mid);
init(2 * in + 1, mid + 1, e);
n = merge(nd[2 * in], nd[2 * in + 1]);
}
node merge(node a, node b) {
int l = a.ei;
int r = b.si;
int lf = a.lf;
int rg = b.rg;
int md = max(a.md, b.md);
if (arr[l] == 0 || arr[r] == 0 || (arr[l] > 0 && arr[r] < 0)) {
} else {
if (a.md == a.ei - a.si + 1) {
lf = max(lf, a.md + b.lf);
}
if (b.md == b.ei - b.si + 1) {
rg = max(rg, b.md + a.rg);
}
md = max(md, a.rg + b.lf);
}
return node(a.si, b.ei, lf, md, rg);
}
void upd_nd(node &n, int v) {
arr[n.si] += v;
long long x = arr[n.si];
n.lf = n.md = n.rg = (x != 0);
}
node query_r(int in, int s, int e) {
node &n = nd[in];
if (n.si == s && n.ei == e) return n;
int mid = (n.si + n.ei) / 2;
if (e <= mid)
return query_r(2 * in, s, e);
else if (s > mid)
return query_r(2 * in + 1, s, e);
else
return merge(query_r(2 * in, s, mid), query_r(2 * in + 1, mid + 1, e));
}
void update_p(int in, int i, int v) {
node &n = nd[in];
if (n.si == n.ei) {
upd_nd(n, v);
return;
}
int mid = (n.si + n.ei) / 2;
if (i <= mid)
update_p(2 * in, i, v);
else
update_p(2 * in + 1, i, v);
n = merge(nd[2 * in], nd[2 * in + 1]);
}
};
seg_tree st;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%lld", &inp[i]);
int m;
scanf("%d", &m);
if (n == 1) {
for (int i = 0; i < m; i++) {
printf("%d", 1);
printf("\n");
}
return 0;
}
st.init(1, 1, n - 1);
for (int i = 0; i < m; i++) {
int l, r, d;
scanf("%d %d", &l, &r);
scanf("%d", &d);
if (l != 1) {
st.update_p(1, l - 1, -d);
}
if (r != n) {
st.update_p(1, r, d);
}
int ans = st.query_r(1, 1, n - 1).md + 1;
printf("%d", ans);
printf("\n");
cout.flush();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1007;
int n, a[maxn], b[maxn], ans[maxn];
long long solve(int x) {
long long ans = a[x];
b[x] = a[x];
int i = x - 1, j = x + 1;
while (i >= 1) {
b[i] = min(a[i], b[i + 1]);
ans += b[i];
i--;
}
while (j <= n) {
b[j] = min(a[j], b[j - 1]);
ans += b[j];
j++;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long maxx = 0;
for (int i = 1; i <= n; i++) {
long long t = solve(i);
if (t > maxx) {
maxx = t;
for (int j = 1; j <= n; j++) ans[j] = b[j];
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &item) {
out << '(' << item.first << ", " << item.second << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
for (const auto &item : v) out << item << ' ';
return out;
}
const int N = 100010;
const int B = 666013;
const int SZ = 500;
const int NRB = N / SZ + 5;
struct Block {
int i, l, r;
Block(int i, int l, int r) : i(i), l(l), r(r) {}
};
int bid[N], s[N], aux[SZ + 5];
int nOpen[NRB], nClosed[NRB];
ull pw[N], open[NRB][SZ + 5], closed[NRB][SZ + 5];
bool ok[N];
ull getHash(ull h[], int l, int r) { return h[r] - h[l] * pw[r - l]; }
int genStack(int l, int r) {
if (l >= N) return -2;
int top = -1;
for (int p = l; p < r && s[p]; ++p) {
if (s[p] > 0)
aux[++top] = s[p];
else {
if (top == -1 || aux[top] < 0)
aux[++top] = s[p];
else if (aux[top] != -s[p])
return -2;
else
--top;
}
}
return top;
}
void makeHashes(int i, int top) {
int p;
for (p = 0; p <= top && aux[p] < 0; ++p)
closed[i][p + 1] = closed[i][p] * B - aux[p];
nClosed[i] = p;
nOpen[i] = top + 1 - p;
reverse(aux + p, aux + p + nOpen[i]);
for (int j = 0; p + j <= top; ++j)
open[i][j + 1] = open[i][j] * B + aux[p + j];
}
void buildBlock(int i) {
int top = genStack(i * SZ, (i + 1) * SZ);
if (top == -2) return void(ok[i] = false);
ok[i] = true;
makeHashes(i, top);
}
void update(int p, int t) {
s[p] = t;
buildBlock(bid[p]);
}
bool process(int i, vector<Block> &v) {
int a = 0, b = nClosed[i];
while (a < b && !v.empty()) {
auto &lst = v.back();
int d = min(b - a, lst.r - lst.l);
if (lst.r - lst.l <= b - a) {
if (getHash(open[lst.i], lst.l, lst.r) == getHash(closed[i], a, a + d))
a += d, v.pop_back();
else
return false;
} else {
if (getHash(open[lst.i], lst.l, lst.l + d) == getHash(closed[i], a, b))
lst.l += d, a = b;
else
return false;
}
}
if (a < b) return false;
if (nOpen[i]) v.emplace_back(i, 0, nOpen[i]);
return true;
}
bool query(int l, int r) {
if (bid[l] == bid[r - 1]) return genStack(l, r) == -1;
int lid = NRB - 2, rid = NRB - 1;
int top = genStack(bid[l] * SZ + l % SZ, (bid[l] + 1) * SZ);
if (top == -2) return false;
makeHashes(lid, top);
top = genStack(bid[r] * SZ, bid[r] * SZ + r % SZ);
if (top == -2) return false;
makeHashes(rid, top);
vector<Block> v;
if (!process(lid, v)) return false;
for (int i = bid[l] + 1; i < bid[r]; ++i) {
if (!ok[i]) return false;
if (!process(i, v)) return false;
}
if (!process(rid, v)) return false;
return v.empty();
}
int main() {
ios_base::sync_with_stdio(false);
pw[0] = 1;
for (int i = 1; i < N; ++i) pw[i] = pw[i - 1] * B;
for (int i = 0; i < N; ++i) bid[i] = i / SZ;
int n, k, q, type, p, t, l, r;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < NRB; ++i) buildBlock(i);
for (cin >> q; q; --q) {
cin >> type;
if (type == 1) {
cin >> p >> t;
update(p - 1, t);
} else {
cin >> l >> r;
cout << (query(l - 1, r) ? "Yes" : "No") << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2, v3;
vector<int> pos[26];
int f[251][251][251];
bool used[251][251][251];
string st, op, ch;
int n, q, x;
inline void check(int x, int y, int z) {
if (x < 0 || y < 0 || z < 0) return;
if (used[x][y][z]) return;
f[x][y][z] = n + 1;
if (x > 0) {
check(x - 1, y, z);
if (f[x - 1][y][z] != n + 1) {
int num = v1[x - 1];
auto iter =
lower_bound(pos[num].begin(), pos[num].end(), f[x - 1][y][z] + 1);
if (iter != pos[num].end()) {
f[x][y][z] = min(f[x][y][z], *iter);
}
}
}
if (y > 0) {
check(x, y - 1, z);
if (f[x][y - 1][z] != n + 1) {
int num = v2[y - 1];
auto iter =
lower_bound(pos[num].begin(), pos[num].end(), f[x][y - 1][z] + 1);
if (iter != pos[num].end()) {
f[x][y][z] = min(f[x][y][z], *iter);
}
}
}
if (z > 0) {
check(x, y, z - 1);
if (f[x][y][z - 1] != n + 1) {
int num = v3[z - 1];
auto iter =
lower_bound(pos[num].begin(), pos[num].end(), f[x][y][z - 1] + 1);
if (iter != pos[num].end()) {
f[x][y][z] = min(f[x][y][z], *iter);
}
}
}
used[x][y][z] = true;
}
inline void work() {
cin >> n >> q;
cin >> st;
for (int i = 0; i < st.size(); ++i) {
pos[st[i] - 97].push_back(i);
}
used[0][0][0] = true;
f[0][0][0] = -1;
for (int i = 0; i < q; ++i) {
cin >> op >> x;
if (op[0] == '+') {
cin >> ch;
if (x == 1) {
v1.push_back(ch[0] - 97);
} else if (x == 2) {
v2.push_back(ch[0] - 97);
} else {
v3.push_back(ch[0] - 97);
}
check(v1.size(), v2.size(), v3.size());
} else {
if (x == 1) {
for (int j = 0; j <= v2.size(); ++j) {
for (int k = 0; k <= v3.size(); ++k) {
used[v1.size()][j][k] = false;
}
}
v1.pop_back();
} else if (x == 2) {
for (int j = 0; j <= v1.size(); ++j) {
for (int k = 0; k <= v3.size(); ++k) {
used[j][v2.size()][k] = false;
}
}
v2.pop_back();
} else {
for (int j = 0; j <= v1.size(); ++j) {
for (int k = 0; k <= v2.size(); ++k) {
used[j][k][v3.size()] = false;
}
}
v3.pop_back();
}
};
if (f[v1.size()][v2.size()][v3.size()] <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
work();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string table;
string hand;
getline(cin, table, '\n');
transform(table.begin(), table.end(), table.begin(), ::tolower);
getline(cin, hand, '\n');
transform(hand.begin(), hand.end(), hand.begin(), ::tolower);
if (hand.find(table[0]) != -1 || hand.find(table[1]) != -1) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool used[100001];
vector<int> seq;
int g[100001];
map<int, int> mp;
void dfs(int v) {
used[v] = true;
int to = g[v];
if (!used[to]) dfs(to);
seq.emplace_back(v + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int> > a, b;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.emplace_back(x, i + 1);
b.emplace_back(x, i + 1);
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) mp[a[i].first] = i + 1;
for (int i = 0; i < n; i++) g[i] = mp[b[i].first] - 1;
vector<vector<int> > ans;
for (int i = 0; i < n; i++) {
if (!used[i]) {
seq.clear();
dfs(i);
ans.emplace_back(seq);
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].size() << ' ';
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j] << ' ';
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
int TUX;
cin >> TUX;
int FOO = 0;
int BAR = 0;
int BAZ = 0;
int QUZ = 1;
for (i = 0; i < TUX; i++) {
int PUR;
cin >> PUR;
FOO = FOO + PUR;
BAR = BAR + 1;
if (max(FOO * QUZ, BAR * BAZ) == FOO * QUZ) {
BAZ = FOO;
QUZ = BAR;
}
}
printf("%lf", (double)BAZ / QUZ);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k,t;
cin >> k >> t;
vector<int> a(t);
for (int i=0;i<t;i++) cin >> a[i];
sort(a.begin(),a.end());
int s=0;
for (int i=0;i<t-1;i++) s+=a[i];
cout << max(0,a[t-1]-s-1) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int nm = 210;
int n, a[nm][nm], m;
int deg[nm], tp[nm], ntp;
vector<pair<int, int> > kq;
int ori[nm][nm], used[nm][nm];
void dfs(int i) {
tp[i] = ntp;
for (int j = 1; j <= n; ++j) {
if (!tp[j] && a[i][j] > 0) dfs(j);
}
}
void solve() {
cin >> n >> m;
memset(a, 0, sizeof(a));
memset(deg, 0, sizeof(deg));
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
a[u][v]++;
a[v][u]++;
deg[u]++;
deg[v]++;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
ori[i][j] = a[i][j];
used[i][j] = 0;
}
}
ntp = 0;
memset(tp, 0, sizeof(tp));
int res = 0;
kq.clear();
for (int i = 1; i <= n; ++i) {
if (!tp[i]) {
ntp++;
dfs(i);
vector<int> tmp;
for (int j = 1; j <= n; ++j) {
if (tp[j] == ntp) {
if (deg[j] % 2)
tmp.push_back(j);
else
res++;
}
}
for (int i = 0; i < tmp.size(); i += 2) {
a[tmp[i]][tmp[i + 1]]++;
a[tmp[i + 1]][tmp[i]]++;
}
stack<int> st;
st.push(i);
int prev = -1;
while (!st.empty()) {
int u = st.top();
for (int v = 1; v <= n; ++v) {
if (a[u][v] > 0) {
a[u][v]--;
a[v][u]--;
st.push(v);
break;
}
}
if (u == st.top()) {
st.pop();
if (prev != -1) {
if (used[prev][u] < ori[prev][u]) {
kq.push_back(make_pair(prev, u));
used[prev][u]++;
used[u][prev]++;
}
}
prev = u;
}
}
}
}
printf("%d\n", res);
for (int i = 0; i < kq.size(); ++i)
printf("%d %d\n", kq[i].first, kq[i].second);
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s,t,u; int A,B; cin>>s>>t>>A>>B>>u;
if(u==s)--A;else --B;
cout<<A<<" "<<B;
}
| 0 |
#include <bits/stdc++.h>
using vi = std::vector<long long int>;
using vvi = std::vector<vi>;
using pii = std::pair<long long int, long long int>;
using vpii = std::vector<pii>;
using vvpii = std::vector<vpii>;
using namespace std;
const long long int N = 2e6 + 10;
const long long int inf = 1e18 + 10;
const long double Pi = 3.14159265;
bool c = 0;
long long int n;
pii q[N];
long long int lis() {
multiset<long long int> x;
for (long long int i = 1; i <= n + 1 - 1; i++) {
if (c == 1 and (q[i].first < 0 or q[i].second < 0)) continue;
auto it = x.upper_bound(q[i].second);
if (x.end() != it) x.erase(it);
x.insert(q[i].second);
}
long long int ans = 0;
return x.size();
}
long long int x[N], t[N], v;
void solve() {
cin >> n;
bool ok = 0;
for (long long int i = 1; i <= n; i++) {
cin >> x[i] >> t[i];
if (x[i] == 0 and t[i] == 0) ok = 1;
}
cin >> v;
for (long long int i = 1; i <= n; i++) {
q[i] = {-x[i] + v * t[i], x[i] + v * t[i]};
}
sort(q + 1, q + 1 + n);
long long int ans = lis();
c = 1;
cout << lis() << " " << ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
long long int xx = 0;
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef pair<int, int>P;
int c[6], cost[110][1 << 6], m, n, k, d;
struct st {
int a, b, c;
}v[600];
int num(string s) {
if (s == "H")return m + n;
if (s == "D")return m + n + 1;
if (s[0] == 'C')return s[1] - '1';
return stoi(s.substr(1)) - 1 + m;
}
int main() {
while (scanf("%d%d%d%d", &m, &n, &k, &d), m) {
rep(i, m)scanf("%d", &c[i]);
rep(i, d) {
string s, t; int e; cin >> s >> t >> e; e *= k;
v[i * 2] = { num(s),num(t),e };
v[i * 2 + 1] = { num(t),num(s),e };
}
memset(cost, 0x3f, sizeof(cost));
cost[m + n][0] = 0;
bool update = true;
while (update) {
update = false;
rep(j, 2 * d)rep(i, 1 << m) {
st&e = v[j];
if (cost[e.a][i] == INF)continue;
if (e.b < m) {
if (!(i >> e.b & 1) && cost[e.b][i | 1 << e.b] > cost[e.a][i] + e.c - c[e.b])
cost[e.b][i | 1 << e.b] = cost[e.a][i] + e.c - c[e.b], update = true;
}
else if (cost[e.b][i] > cost[e.a][i] + e.c)
cost[e.b][i] = cost[e.a][i] + e.c, update = true;
}
}
int Min = INF;
rep(i, 1 << m)Min = min(Min, cost[m + n + 1][i]);
printf("%d\n", Min);
}
} | 0 |
Subsets and Splits