solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int dep[maxn], fa[maxn], f[maxn];
int d[maxn];
int n, m;
int q1, q2, p1, p2;
int s, t;
vector<int> G[maxn];
void dfs(int u, int pre) {
dep[u] = dep[pre] + 1;
fa[u] = pre;
for (int i = 0; i < G[u].size(); ++i)
if (!dep[G[u][i]])
dfs(G[u][i], u);
else if (dep[G[u][i]] < dep[u] && G[u][i] != pre)
--f[G[u][i]], ++f[u];
f[pre] += f[u];
}
void DFS(int u) {
for (int i = 0; i < G[u].size(); ++i)
if (dep[G[u][i]] == dep[u] + 1) {
DFS(G[u][i]);
if (q2) return;
} else if (dep[G[u][i]] < dep[s] && G[u][i] != fa[u]) {
if (q1)
p2 = u, q2 = G[u][i];
else
p1 = u, q1 = G[u][i];
if (q2) return;
}
}
void go(int l, int r) {
int k = t;
t += abs(dep[r] - dep[l]) + 1;
if (dep[l] > dep[r])
for (int i = l, j = k + 1; j <= t; i = fa[i], ++j) d[j] = i;
else
for (int i = r, j = t; j > k; i = fa[i], --j) d[j] = i;
}
void print() {
printf("%d ", t);
for (int i = 1; i <= t; ++i) printf("%d ", d[i]);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; ++i)
if (!dep[i]) dfs(i, 0);
for (int i = 1; i <= n; ++i)
if (f[i] > 1) {
s = i;
break;
}
if (!s) {
puts("NO");
return 0;
}
DFS(s);
puts("YES");
if (dep[q1] > dep[q2]) swap(q1, q2), swap(p1, p2);
int x, y;
for (x = p1, y = p2; x != y;) dep[x] > dep[y] ? x = fa[x] : y = fa[y];
t = 0;
go(x, p1), go(q1, q2), print();
t = 0;
go(x, p2), go(q2, q2), print();
t = 0;
go(x, q2), print();
return 0;
}
| 5 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vvi X(1001, vi(1001));
rep(i, n) {
P x, y;
cin >> x >> y;
X[x.first][x.second]++;
X[y.first][y.second]++;
X[x.first][y.second]--;
X[y.first][x.second]--;
}
rep(i, 1001) {
rep(j, 1000) {
X[i][j+1] += X[i][j];
}
}
rep(j, 1001) {
rep(i, 1000) {
X[i+1][j] += X[i][j];
}
}
int ma = 0;
rep(i, 1000) rep(j, 1000) {
chmax(ma, X[i][j]);
}
cout << ma << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 8002;
int n, bc[maxN + 1];
int f[maxN + 1], w[maxN + 1][maxN + 1];
int nxt[maxN + 1];
char s[maxN + 1], t[maxN + 1];
inline void work(int x) {
int len = n - x + 1;
for (int i = 1; i <= len; i++) t[i] = s[i + x - 1];
t[len + 1] = '#';
nxt[1] = 0;
for (int i = 2; i <= len; i++) {
int j = nxt[i - 1];
while (j && t[j + 1] != t[i]) j = nxt[j];
if (t[j + 1] == t[i])
nxt[i] = j + 1;
else
nxt[i] = 0;
}
for (int i = 1; i <= len; i++) {
int t = i - nxt[i];
if (i % t == 0)
w[x][x + i - 1] = bc[i / t] + t;
else
w[x][x + i - 1] = 1 + i;
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) bc[i] = bc[i / 10] + 1;
for (int i = 1; i <= n; i++) work(i);
for (int i = 1; i <= n; i++) {
f[i] = 1e9;
for (int j = 0; j < i; j++) f[i] = min(f[i], f[j] + w[j + 1][i]);
}
printf("%d", f[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n = 0;
int k = 0;
int a = 0;
int b = 0;
int q = 0;
const int N = 200000;
int ta[N + 10];
int tb[N + 10];
void add(int* t, int p, int v) {
for (; p <= N; p += (p & -p)) t[p] += v;
}
int ask(int* t, int p) {
int res = 0;
for (; p >= 1; p -= (p & -p)) res += t[p];
return res;
}
int ask(int* t, int l, int r) { return ask(t, r) - ask(t, l - 1); }
int numa[N + 10];
int numb[N + 10];
int rd(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
int x = 0;
int y = 0;
int z = 0;
int val = 0;
for (int i = 1; i <= q; i++) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
val = rd(numa[y] + z, a) - numa[y];
add(ta, y, val);
numa[y] += val;
val = rd(numb[y] + z, b) - numb[y];
add(tb, y, val);
numb[y] += val;
} else {
scanf("%d", &y);
int p1 = y;
int p2 = y + k - 1;
int res = ask(tb, 1, p1 - 1) + ask(ta, p2 + 1, n);
printf("%d\n", res);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
struct Tree {
int n;
struct node {
int pathNo, pathPos;
int thick;
int level;
int par;
vector<int> ngb;
};
vector<node> T;
vector<pair<int, int> > edg;
Tree(int _n) : n(_n), T(_n) {}
void add_edge(int a, int b) {
edg.push_back(make_pair(b, a));
T[b].ngb.push_back(a);
T[a].ngb.push_back(b);
}
int dfs(int i = 0, int par = -1, int depth = 0) {
node& v = T[i];
v.level = depth;
int sum = 1, best = -1;
v.thick = -1;
v.par = par;
for (auto j : v.ngb) {
if (j != par) {
int s = dfs(j, i, depth + 1);
sum += s;
if (best < s) {
best = s;
v.thick = j;
}
}
}
return sum;
}
struct path {
vector<int> P;
int n;
void add(int i) { P.push_back(i); }
path() : P(), n(1){};
vector<vector<int> > T;
void init() {
while (n < ((int)(P).size())) n *= 2;
T = vector<vector<int> >(2 * n);
}
void insert(int b, int e, int v) {
if (b >= e) return;
b += n;
e += n - 1;
T[b].push_back(v);
if (b != e) T[e].push_back(v);
while (b / 2 != e / 2) {
if (b % 2 == 0) T[b + 1].push_back(v);
if (e % 2 == 1) T[e - 1].push_back(v);
b /= 2;
e /= 2;
}
}
vector<int> get(int i) {
vector<int> res;
i += n;
while (i) {
for (int v : T[i]) res.push_back(v);
T[i].clear();
i /= 2;
}
return res;
}
};
vector<path> P;
void dfs2(int i = 0) {
if (P.empty()) P.push_back(path());
node& v = T[i];
v.pathNo = ((int)(P).size()) - 1;
v.pathPos = ((int)(P.back().P).size());
P.back().add(i);
if (v.thick != -1) dfs2(v.thick);
for (auto j : v.ngb) {
if (j != v.par && j != v.thick) {
P.push_back(path());
dfs2(j);
}
}
if (v.thick == -1) P.back().init();
}
void insert(int i, int j, int v) {
while (T[i].pathNo != T[j].pathNo) {
if (T[i].level - T[i].pathPos < T[j].level - T[j].pathPos) swap(i, j);
int p = T[i].pathNo;
P[p].insert(0, T[i].pathPos + 1, v);
i = T[P[T[i].pathNo].P[0]].par;
}
if (T[i].level < T[j].level) swap(i, j);
int p = T[i].pathNo;
P[p].insert(T[j].pathPos + 1, T[i].pathPos + 1, v);
}
vector<int> get(int id) {
pair<int, int> p = edg[id];
int i = p.first;
if (T[p.first].par != p.second) i = p.second;
return P[T[i].pathNo].get(T[i].pathPos);
}
};
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<Tree> T(2, Tree(n));
vector<set<int> > del(2);
for (int t = 0; t < (2); ++t) {
for (int i = 0; i < (n - 1); ++i) {
int a;
cin >> a;
--a;
T[t].add_edge(i + 1, a);
}
T[t].dfs();
T[t].dfs2();
}
for (int t = 0; t < (2); ++t) {
for (int i = 0; i < (n - 1); ++i) {
pair<int, int> p = T[1 - t].edg[i];
T[t].insert(p.first, p.second, i);
}
}
int t = 0;
int id;
set<int> cur;
cin >> id;
--id;
cur.insert(id);
del[1].insert(id);
while (!cur.empty()) {
set<int> prv = cur;
cur.clear();
if (t % 2 == 0)
cout << "Blue" << endl;
else
cout << "Red" << endl;
for (int j : prv) {
cout << j + 1 << " ";
}
cout << endl;
cur.clear();
for (int j : prv) {
vector<int> me = (T[t].get(j));
for (int k : me) {
if (del[t].find(k) == del[t].end()) {
cur.insert(k);
del[t].insert(k);
}
}
}
t = 1 - t;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct PersistantTrieMap {
struct TrieMap {
long long val = -1;
int inSubtree = 0;
TrieMap *children[26];
TrieMap() { memset(children, 0, 26 * sizeof(TrieMap *)); }
};
int sz = 1, autoTree = 0;
vector<TrieMap> trees;
PersistantTrieMap() { trees.push_back(TrieMap()); }
void set(int t, string key, long long val) {
bool first = (get(t, key) == -1);
trees.push_back(TrieMap());
TrieMap *newCurr = &trees[sz], *curr = &trees[t];
int pos = 0;
while (1) {
if (curr)
for (int i = 0; i < (26); i++)
if (pos == key.size() || i != key[pos] - 'a')
newCurr->children[i] = curr->children[i];
if (curr) newCurr->val = curr->val;
newCurr->inSubtree = (curr ? first + curr->inSubtree : 1);
if (pos == key.size()) {
newCurr->val = val;
break;
}
newCurr = newCurr->children[key[pos] - 'a'] = new TrieMap();
if (curr) curr = curr->children[key[pos] - 'a'];
pos++;
}
autoTree = sz++;
}
void erase(int t, string key) {
if (get(t, key) == -1) return;
trees.push_back(TrieMap());
TrieMap *newCurr = &trees[sz], *curr = &trees[t];
int pos = 0;
while (1) {
for (int i = 0; i < (26); i++)
if (pos == key.size() || i != key[pos] - 'a')
newCurr->children[i] = curr->children[i];
newCurr->val = curr->val;
newCurr->inSubtree = curr->inSubtree - 1;
if (pos == key.size() ||
(curr = curr->children[key[pos] - 'a'])->inSubtree == 1) {
if (pos == key.size()) newCurr->val = -1;
break;
}
newCurr = newCurr->children[key[pos++] - 'a'] = new TrieMap();
}
autoTree = sz++;
}
long long get(int t, string key) {
TrieMap *curr = &trees[t];
int pos = 0;
while (1) {
if (curr == NULL) return -1;
if (pos == key.size()) return curr->val;
curr = curr->children[key[pos++] - 'a'];
}
}
void set(string key, long long val) { set(autoTree, key, val); }
long long get(string key) { return get(autoTree, key); }
void erase(string key) { erase(autoTree, key); }
};
struct PersistantBitMultiset {
struct BitMultiset {
int inSubtree = 0;
BitMultiset *children[2]{NULL, NULL};
};
int sz = 1, autoTree = 0;
vector<BitMultiset> trees;
PersistantBitMultiset() { trees.push_back(BitMultiset()); }
void insert(int t, long long v) {
v ^= (1LL << 63);
trees.push_back(BitMultiset());
BitMultiset *newCurr = &trees[sz], *curr = &trees[t];
int bit = 63;
while (1) {
if (curr != NULL)
for (int i = 0; i < (2); i++)
if (i == ((v & (1LL << bit)) == 0))
newCurr->children[i] = curr->children[i];
newCurr->inSubtree = curr ? 1 + curr->inSubtree : 1;
if (bit == -1) break;
if (curr) curr = curr->children[(v & (1LL << bit)) != 0];
newCurr = newCurr->children[(v & (1LL << bit--)) != 0] =
new BitMultiset();
}
autoTree = sz++;
}
int count(int t, long long v) {
v ^= (1LL << 63);
BitMultiset *curr = &trees[t];
int bit = 63;
while (bit >= 0)
if (!curr)
return 0;
else
curr = curr->children[(v & (1LL << bit--)) != 0];
return curr->inSubtree;
}
void erase(int t, long long v) {
if (!count(t, v)) return;
v ^= (1LL << 63);
trees.push_back(BitMultiset());
BitMultiset *newCurr = &trees[sz], *curr = &trees[t];
int bit = 63;
newCurr->inSubtree = curr->inSubtree - 1;
while (1) {
for (int i = 0; i < (2); i++)
if (i == ((v & (1LL << bit)) == 0))
newCurr->children[i] = curr->children[i];
if (curr->children[(v & (1LL << bit)) != 0] == NULL ||
curr->children[(v & (1LL << bit)) != 0]->inSubtree == 1)
break;
newCurr = newCurr->children[(v & (1LL << bit)) != 0] = new BitMultiset();
curr = curr->children[(v & (1LL << bit--)) != 0];
newCurr->inSubtree = curr->inSubtree - 1;
}
autoTree = sz++;
}
int lower_bound(int t, long long v) {
v ^= (1LL << 63);
BitMultiset *curr = &trees[t];
int bit = 63, res = 0;
while (curr != NULL) {
if ((v & (1LL << bit)) != 0 && curr->children[0])
res += curr->children[0]->inSubtree;
curr = curr->children[(v & (1LL << bit--)) != 0];
}
return res;
}
void insert(long long v) { insert(autoTree, v); }
int count(long long v) { return count(autoTree, v); }
void erase(long long v) { erase(autoTree, v); }
int lower_bound(long long v) { return lower_bound(autoTree, v); }
};
PersistantTrieMap priority;
PersistantBitMultiset priorityCount;
int q, pNum[100000 + 1], pcNum[100000 + 1];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> q;
for (int i = (1); i < (q + 1); i++) {
string type;
cin >> type;
if (type == "set") {
string s;
long long a;
cin >> s >> a;
priorityCount.erase(priority.get(s));
priority.set(s, a);
priorityCount.insert(priority.get(s));
} else if (type == "remove") {
string s;
cin >> s;
priorityCount.erase(priority.get(s));
priority.erase(s);
} else if (type == "query") {
string s;
cin >> s;
int p = priority.get(s);
cout << ((p == -1) ? -1 : priorityCount.lower_bound(p)) << endl;
} else if (type == "undo") {
int d;
cin >> d;
priority.autoTree = pNum[max(0, i - d - 1)];
priorityCount.autoTree = pcNum[max(0, i - d - 1)];
}
pNum[i] = priority.autoTree, pcNum[i] = priorityCount.autoTree;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-9;
const int MOD = 1000000009;
const int INF = 1000000000;
const long long LINF = 1000000000000000000LL;
int main() {
int t, n, p, x;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &p);
x = 2 * n + p;
for (int i = int(1); i <= int(n); i++)
if (x)
for (int j = 1; j + i <= n; j++) {
if (x)
printf("%d %d\n", j, j + i), x--;
else
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 10;
int main() {
char a[MAXN], b[MAXN];
ios::sync_with_stdio(false);
cin >> a >> b;
int cntA = 0, cntB = 0;
for (int i = 0; a[i]; ++i) {
cntA += a[i] == '1';
}
if (cntA & 1) {
++cntA;
}
for (int i = 0; b[i]; ++i) {
cntB += b[i] == '1';
}
cout << (cntA >= cntB ? "YES" : "NO") << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define pfin(a) printf("%d\n",a);
#define pfln(a) printf("%lld\n",a);
#define pfis(a) printf("%d ",a);
#define pfls(a) printf("%lld ",a);
#define sfi(a) scanf("%d",&a);
#define sfl(a) scanf("%lld",&a);
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define f(i,a,b) for(int i=a;i<b;i++)
#define ll long long
#define F first
#define S second
#define vi vector<ll>
#define vc vector<char>
#define endl "\n"
#define deci fixed<<setprecision(9)
const ll mod = 1e9 + 7;
#define N 1000005
int main()
{
ll t;
sfl(t);
while(t--)
{
ll n;
sfl(n);
ll arr[n+1];
f(i,1,n+1)
{
sfl(arr[i]);
}
ll s=0,cnt=0;
for(ll i=1;i<=n;i++)
{
if(i==1)
{
if(arr[i]>arr[i+1])
{
// cout<<abs(arr[i]-arr[i+1])<<endl;
cnt+=abs(arr[i]-arr[i+1]);
arr[i]=arr[i+1];
}
}
else if(i==n)
{
if(arr[i]>arr[i-1])
{
// cout<<abs(arr[i]-arr[i-1])<<endl;
cnt+=abs(arr[i]-arr[i-1]);
arr[i]=arr[i-1];
}
}
else
{
if(arr[i]>arr[i-1]&&arr[i]>arr[i+1])
{
// cout<<abs(max(arr[i-1],arr[i+1])-arr[i])<<endl;
cnt+=abs(max(arr[i-1],arr[i+1])-arr[i]);
arr[i]=max(arr[i-1],arr[i+1]);
}
}
}
f(i,1,n+1)
{
// cout<<arr[i]<<" ";
if(i==1||i==n)
{
s+=arr[i];
}
else
{
if(arr[i]>arr[i-1])
{
s+=(arr[i]-arr[i-1]);
}
else if(arr[i]>arr[i+1])
{
s+=(arr[i]-arr[i+1]);
}
}
}
//cout<<endl;
//cout<<cnt<<endl;
cout<<s+cnt<<endl;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200005;
int F[MAX_N][30];
bool mark[MAX_N];
int n, m;
long long mini, maxi;
class DSU {
private:
int ro[MAX_N], ra[MAX_N];
public:
void init(int n) {
for (int i = 0; i <= n; i++) {
ro[i] = i;
ra[i] = 1;
}
}
int findRoot(int i) { return (ro[i] == i ? i : (ro[i] = findRoot(ro[i]))); }
int isSameSet(int x, int y) { return (findRoot(x) == findRoot(y)); }
void unionSet(int x, int y) {
if (!isSameSet(x, y)) {
int u = findRoot(x);
int v = findRoot(y);
if (ra[u] > ra[v])
ro[v] = u;
else {
ro[u] = v;
if (ra[u] == ra[v]) ra[v]++;
}
}
}
};
DSU mydsu;
struct Edge {
int u, v, id;
long long c;
bool operator<(const Edge &hs) const { return (c < hs.c); }
};
struct edge {
int v;
long long c;
};
vector<edge> V[MAX_N];
int H[MAX_N];
long long Fmin[MAX_N][30], Fmax[MAX_N][30];
const long long inf = 1e16;
vector<Edge> save;
long long ans[MAX_N];
void DFS(int x, int father, int level, long long dist) {
H[x] = level;
Fmin[x][0] = dist;
Fmax[x][0] = dist;
F[x][0] = father;
for (int i = 0; i < V[x].size(); i++) {
edge E = V[x][i];
int t = E.v;
long long c = E.c;
if (t == father) continue;
DFS(t, x, level + 1, c);
}
}
void init() {
for (int i = 1; i <= n; i++)
for (int k = 0; k <= 20; k++) {
F[i][k] = -1;
Fmin[i][k] = inf;
Fmax[i][k] = -inf;
mark[i] = false;
}
}
void initLCA() {
for (int k = 1; k <= 20; k++)
for (int i = 1; i <= n; i++)
if (F[i][k - 1] != -1) {
F[i][k] = F[F[i][k - 1]][k - 1];
Fmin[i][k] = min(Fmin[i][k - 1], Fmin[F[i][k - 1]][k - 1]);
Fmax[i][k] = max(Fmax[i][k - 1], Fmax[F[i][k - 1]][k - 1]);
}
}
void lca(int a, int b) {
if (H[a] < H[b]) swap(a, b);
mini = inf;
maxi = -inf;
for (int i = 20; i >= 0; i--)
if (H[a] - (1 << i) >= H[b]) {
mini = min(mini, Fmin[a][i]);
maxi = max(maxi, Fmax[a][i]);
a = F[a][i];
}
if (a == b) return;
for (int i = 20; i >= 0; i--) {
if (F[a][i] != -1 && F[a][i] != F[b][i]) {
mini = min(mini, min(Fmin[a][i], Fmin[b][i]));
maxi = max(maxi, max(Fmax[a][i], Fmax[b][i]));
a = F[a][i];
b = F[b][i];
}
}
mini = min(mini, min(Fmin[a][0], Fmin[b][0]));
maxi = max(maxi, max(Fmax[a][0], Fmax[b][0]));
}
int main() {
scanf("%d %d", &n, &m);
init();
for (int i = 0; i < m; i++) {
int u, v;
long long c;
scanf("%d %d %I64d", &u, &v, &c);
save.push_back((Edge){u, v, i, c});
}
sort(save.begin(), save.end());
mydsu.init(n + 5);
long long res = 0LL;
for (int i = 0; i < m; i++) {
int u = save[i].u;
int v = save[i].v;
long long c = save[i].c;
if (!mydsu.isSameSet(u, v)) {
res += c;
mydsu.unionSet(u, v);
V[u].push_back((edge){v, c});
V[v].push_back((edge){u, c});
}
}
DFS(1, -1, 0, 0);
initLCA();
int cnt = 0;
for (int i = 0; i < m; i++) {
int u = save[i].u;
int v = save[i].v;
lca(u, v);
if (maxi == save[i].c) {
cnt++;
}
}
printf("%d", cnt + 1 - n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
bool flag = true;
int lst;
cin >> lst;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
if (x != lst) flag = false;
}
if (!flag)
cout << 1 << endl;
else
cout << n << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, t, d[1000005][2][2];
string temp = "ab";
pair<int, int> dp[1000005];
char s[1000005];
bool check(int l, int r) {
if (s[l] == 'b') return 0;
int temp = l & 1;
if (d[r][temp][1] - d[l - 1][temp][1] != 0) return 0;
temp = !temp;
if (d[r][temp][0] - d[l - 1][temp][0] != 0) return 0;
return 1;
}
int calc(int l, int r) {
int len = r - l + 1;
for (int i = (0); i <= (1); ++i)
for (int j = (0); j <= (1); ++j) len -= (d[r][i][j] - d[l - 1][i][j]);
return len;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> s[i];
cin >> t;
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= (1); ++j)
for (int k = (0); k <= (1); ++k) d[i][j][k] = d[i - 1][j][k];
if (s[i] != '?') ++d[i][i & 1][temp.find(s[i])];
}
for (int r = (t); r <= (n); ++r) {
int l = r - t + 1;
dp[r] = dp[r - 1];
if (check(l, r)) {
if (dp[r].first < dp[l - 1].first + 1) {
dp[r].first = dp[l - 1].first + 1;
dp[r].second = calc(l, r) + dp[l - 1].second;
} else if (dp[r].first == dp[l - 1].first + 1)
dp[r].second = min(dp[r].second, dp[l - 1].second + calc(l, r));
}
}
cout << dp[n].second;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
const int inv2 = 500000004;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T& a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T& a, Others&... b) {
a = read(a);
read(b...);
}
int n, m, a[600010], s[600010], v[600010], pw[600010], ipw[600010], pos[600010];
int lv[600010 << 2], rv[600010 << 2], val[600010 << 2], siz[600010 << 2];
pair<int, int> b[600010];
int add(int x, int y) {
x += y;
return x >= p ? x - p : x;
}
int mul(int x, int y) { return 1ll * x * y % p; }
void change(int k, int l, int r, int x, int y, int z) {
if (l == r) {
val[k] = 0;
siz[k] = z;
lv[k] = y;
rv[k] = mul(y, inv2);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
change(k << 1, l, mid, x, y, z);
else
change(k << 1 | 1, mid + 1, r, x, y, z);
lv[k] = add(lv[k << 1], mul(lv[k << 1 | 1], pw[siz[k << 1]]));
rv[k] = add(rv[k << 1], mul(rv[k << 1 | 1], ipw[siz[k << 1]]));
val[k] = add(add(val[k << 1], val[k << 1 | 1]),
mul(mul(lv[k << 1], rv[k << 1 | 1]), ipw[siz[k << 1]]));
siz[k] = siz[k << 1] + siz[k << 1 | 1];
}
int main() {
read(n);
pw[0] = ipw[0] = 1;
for (int i = 1; i <= n; i++) {
pw[i] = mul(pw[i - 1], 2);
ipw[i] = mul(ipw[i - 1], inv2);
}
for (int i = 1; i <= n; i++) {
read(a[i]);
b[i] = {a[i], i};
}
read(m);
for (int i = 1; i <= m; i++) {
read(s[i], v[i]);
b[n + i] = {v[i], n + i};
}
sort(b + 1, b + 1 + n + m);
for (int i = 1; i <= n + m; i++) pos[b[i].second] = i;
for (int i = 1; i <= n; i++) {
change(1, 1, n + m, pos[i], a[i], 1);
a[i] = pos[i];
}
printf("%d\n", val[1]);
for (int i = 1; i <= m; i++) {
change(1, 1, n + m, a[s[i]], 0, 0);
change(1, 1, n + m, pos[n + i], v[i], 1);
a[s[i]] = pos[n + i];
printf("%d\n", val[1]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, inf = 1e9 + 7;
inline long long rd() {
long long x = 0;
char c = getchar();
int neg = 1;
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * neg;
}
struct Node {
int v;
long long n;
Node(int a = 0, long long b = 0) { v = a, n = b; }
} f[2][maxn][3], g[2][maxn][3], ans;
int N, M;
pair<int, int> a[maxn];
inline void update(int v1, long long n1) {
if (!n1) return;
if (v1 > ans.v)
ans = Node(v1, n1);
else if (v1 == ans.v)
ans = Node(v1, n1 + ans.n);
}
int main() {
int i, j, k;
N = rd(), M = rd();
for (i = 1; i <= M; i++) {
a[i].second = rd(), a[i].first = rd();
}
sort(a + 1, a + M + 1);
f[0][0][1].v = f[1][0][1].v = g[0][M + 1][1].v = g[1][M + 1][1].v = inf;
for (i = 1; i <= M; i++) {
int tp = a[i].second, x = a[i].first;
memcpy(f[!tp][i], f[!tp][i - 1], sizeof(f[1][1]));
if (x > f[tp][i - 1][0].v)
f[tp][i][0] = Node(x, 1);
else if (x == f[tp][i - 1][0].v)
f[tp][i][0] = Node(x, f[tp][i - 1][0].n + 1);
else
f[tp][i][0] = f[tp][i - 1][0];
if (x < f[tp][i - 1][1].v)
f[tp][i][1] = Node(x, 1);
else if (x == f[tp][i - 1][1].v)
f[tp][i][1] = Node(x, f[tp][i - 1][1].n + 1);
else
f[tp][i][1] = f[tp][i - 1][1];
f[tp][i][2].n = f[tp][i - 1][2].n + 1;
}
for (i = M; i; i--) {
int tp = a[i].second, x = a[i].first;
memcpy(g[!tp][i], g[!tp][i + 1], sizeof(g[1][1]));
if (x > g[tp][i + 1][0].v)
g[tp][i][0] = Node(x, 1);
else if (x == g[tp][i + 1][0].v)
g[tp][i][0] = Node(x, g[tp][i + 1][0].n + 1);
else
g[tp][i][0] = g[tp][i + 1][0];
if (x < g[tp][i + 1][1].v)
g[tp][i][1] = Node(x, 1);
else if (x == g[tp][i + 1][1].v)
g[tp][i][1] = Node(x, g[tp][i + 1][1].n + 1);
else
g[tp][i][1] = g[tp][i + 1][0];
g[tp][i][2].n = g[tp][i + 1][2].n + 1;
}
for (i = 2; i <= M - 1; i++) {
int tp = a[i].second, x = a[i].first;
int v1 = 2 * g[tp][i + 1][0].v - 2 * f[tp][i - 1][1].v;
long long n1 = g[tp][i + 1][0].n * f[tp][i - 1][1].n;
update(v1, n1);
v1 = 2 * N - 2 * x + 2 * f[!tp][i - 1][0].v,
n1 = f[!tp][i - 1][0].n * g[tp][i + 1][2].n;
update(v1, n1);
v1 = 2 * N, n1 = f[!tp][i - 1][2].n * g[!tp][i + 1][2].n;
update(v1, n1);
v1 = 2 * N - 2 * g[!tp][i + 1][1].v + 2 * x,
n1 = f[tp][i - 1][2].n * g[!tp][i + 1][1].n;
update(v1, n1);
}
printf("%I64d\n", ans.n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int counter = 0;
while (n > 0) {
int r = 0;
int a = n;
while (a > 0) {
r = max(r, a % 10);
a /= 10;
}
n -= r;
counter++;
}
cout << counter << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
int pref[N], suf[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
pref[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i - 1] < a[i])
pref[i] = pref[i - 1] + 1;
else
pref[i] = 1;
}
suf[n] = 1;
for (int i = n - 1; i >= 1; i--) {
if (a[i] < a[i + 1])
suf[i] = suf[i + 1] + 1;
else
suf[i] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, pref[i]);
}
for (int i = 2; i <= n - 1; i++) {
if (a[i - 1] < a[i + 1]) {
ans = max(ans, pref[i - 1] + suf[i + 1]);
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class Graph {
public:
Graph(int N, int M) {
this->N = N;
this->M = M;
edges.resize(N + 1);
}
void AddEdge(int x, int y) { edges[x].push_back(y); }
void GetMatching(vector<pair<int, int> > &ret) {
vector<int> to(N + 1), from(M + 1);
vector<bool> viz(N + 1);
bool cuplat = true;
while (cuplat) {
cuplat = false;
fill(viz.begin(), viz.end(), false);
for (int i = 1; i <= N; ++i)
if (to[i] == 0 && match(i, viz, to, from)) cuplat = true;
}
for (int i = 1; i <= N; ++i)
if (to[i] != 0) ret.push_back({i, to[i]});
}
private:
bool match(int nod, vector<bool> &viz, vector<int> &to, vector<int> &from) {
if (viz[nod]) return false;
viz[nod] = true;
for (auto v : edges[nod]) {
if (from[v] == 0) {
to[nod] = v;
from[v] = nod;
return true;
}
}
for (auto v : edges[nod]) {
if (match(from[v], viz, to, from)) {
to[nod] = v;
from[v] = nod;
return true;
}
}
return false;
}
vector<vector<int> > edges;
int N, M;
};
int N, M;
char matrix[205][205];
bool isLeftBlack(int i, int j) {
if (j == 1 || matrix[i][j - 1] == '.') return false;
return true;
}
bool isRightBlack(int i, int j) {
if (j == M || matrix[i][j + 1] == '.') return false;
return true;
}
bool isUpBlack(int i, int j) {
if (i == 1 || matrix[i - 1][j] == '.') return false;
return true;
}
bool isDownBlack(int i, int j) {
if (i == N || matrix[i + 1][j] == '.') return false;
return true;
}
int getIndRow(int i, int j) { return (i - 1) * M + j; }
int getIndCol(int i, int j) { return (i - 1) * (M - 1) + j; }
void read() {
cin >> N >> M;
for (int i = 1; i <= N; ++i) cin >> (matrix[i] + 1);
}
int main() {
read();
Graph graf((N - 1) * M, N * (M - 1));
int answer = 0;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
if (matrix[i][j] == '#') {
answer++;
if (isLeftBlack(i, j)) answer--;
if (isUpBlack(i, j)) {
answer--;
if (isLeftBlack(i, j))
graf.AddEdge(getIndRow(i - 1, j), getIndCol(i, j - 1));
if (isRightBlack(i, j))
graf.AddEdge(getIndRow(i - 1, j), getIndCol(i, j));
}
if (isDownBlack(i, j)) {
if (isLeftBlack(i, j))
graf.AddEdge(getIndRow(i, j), getIndCol(i, j - 1));
if (isRightBlack(i, j))
graf.AddEdge(getIndRow(i, j), getIndCol(i, j));
}
}
}
vector<pair<int, int> > matching;
graf.GetMatching(matching);
cout << answer + (int)matching.size();
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main(){long long h;cin >> h;long long ans = 0;long long i = 1; while (h > 0) {h = h / 2; ans += i; i *= 2;}cout << ans << endl;} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
using lint = long long;
using pi = pair<int, int>;
int n;
struct rect {
int sx, ex, sy, ey, idx;
} a[MAXN];
auto cmp1 = [](const rect &a, const rect &b) {
if (a.sx != b.sx) return a.sx < b.sx;
if (a.ex != b.ex) return a.ex < b.ex;
return a.idx < b.idx;
};
auto cmp2 = [](const rect &a, const rect &b) {
if (a.ex != b.ex) return a.ex < b.ex;
if (a.sx != b.sx) return a.sx < b.sx;
return a.idx < b.idx;
};
auto cmp3 = [](const rect &a, const rect &b) {
if (a.sy != b.sy) return a.sy < b.sy;
if (a.ey != b.ey) return a.ey < b.ey;
return a.idx < b.idx;
};
auto cmp4 = [](const rect &a, const rect &b) {
if (a.ey != b.ey) return a.ey < b.ey;
if (a.sy != b.sy) return a.sy < b.sy;
return a.idx < b.idx;
};
bool dfs(set<rect, decltype(cmp1)> &s0, set<rect, decltype(cmp2)> &s1,
set<rect, decltype(cmp3)> &s2, set<rect, decltype(cmp4)> &s3) {
if (s0.size() == 1) return true;
auto itr0 = s0.begin();
int arg0 = -1e9;
auto itr1 = s1.begin();
int arg1 = 2e9;
auto itr2 = s2.begin();
int arg2 = -1e9;
auto itr3 = s3.begin();
int arg3 = 2e9;
for (int i = 0; i + 1 < s0.size(); i++) {
arg0 = max(arg0, itr0->ex);
arg1 = min(arg1, itr1->sx);
arg2 = max(arg2, itr2->ey);
arg3 = min(arg3, itr3->sy);
itr0++;
itr1++;
itr2++;
itr3++;
vector<rect> split;
if (arg0 <= itr0->sx) {
itr0 = s0.begin();
for (int j = 0; j <= i; j++) split.push_back(*itr0++);
} else if (arg1 >= itr1->ex) {
itr1 = s1.begin();
for (int j = 0; j <= i; j++) split.push_back(*itr1++);
} else if (arg2 <= itr2->sy) {
itr2 = s2.begin();
for (int j = 0; j <= i; j++) split.push_back(*itr2++);
} else if (arg3 >= itr3->ey) {
itr3 = s3.begin();
for (int j = 0; j <= i; j++) split.push_back(*itr3++);
}
if (split.size()) {
set<rect, decltype(cmp1)> ss0(cmp1);
set<rect, decltype(cmp2)> ss1(cmp2);
set<rect, decltype(cmp3)> ss2(cmp3);
set<rect, decltype(cmp4)> ss3(cmp4);
for (auto &i : split) {
ss0.insert(i);
ss1.insert(i);
ss2.insert(i);
ss3.insert(i);
s0.erase(i);
s1.erase(i);
s2.erase(i);
s3.erase(i);
}
return dfs(s0, s1, s2, s3) && dfs(ss0, ss1, ss2, ss3);
}
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
a[i].idx = i;
scanf("%d %d %d %d", &a[i].sx, &a[i].sy, &a[i].ex, &a[i].ey);
}
set<rect, decltype(cmp1)> s1(cmp1);
set<rect, decltype(cmp2)> s2(cmp2);
set<rect, decltype(cmp3)> s3(cmp3);
set<rect, decltype(cmp4)> s4(cmp4);
for (int i = 0; i < n; i++) {
s1.insert(a[i]);
s2.insert(a[i]);
s3.insert(a[i]);
s4.insert(a[i]);
}
puts(dfs(s1, s2, s3, s4) ? "YES" : "NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int rk[N], len, n;
char ch[N], v[N];
int a[N];
namespace lzr {
int sa[N], lcp[N];
struct cmp {
const int h, *g;
cmp(int h, int *g) : h(h), g(g) {}
bool operator()(int l, int r) {
return g[l] != g[r] ? g[l] < g[r] : g[l + h] < g[r + h];
}
};
void build(const char *t, int n) {
static int g[N], rk[N];
for (int(i) = (0); (i) <= (n); (i)++) sa[i] = i, g[i] = t[i];
rk[0] = rk[n] = 0;
sort(sa, sa + n + 1, cmp(0, g));
for (int h = 1; rk[n] != n; h *= 2) {
cmp a(h, g);
sort(sa, sa + n + 1, a);
for (int(i) = (0); (i) <= (n - 1); (i)++)
rk[i + 1] = rk[i] + a(sa[i], sa[i + 1]);
for (int(i) = (0); (i) <= (n); (i)++) g[sa[i]] = rk[i];
}
for (int(i) = (0); (i) <= (n); (i)++) rk[sa[i]] = i;
int h = 0;
for (int(i) = (0); (i) <= (n - 1); (i)++) {
const int j = sa[rk[i] - 1];
while (j + h < n && i + h < n && t[j + h] == t[i + h]) h++;
lcp[rk[i]] = h;
if (h) h--;
}
lcp[0] = -1;
}
}; // namespace lzr
using namespace lzr;
inline long long f(int x) { return (long long)x * (x + 1) / 2; }
int main() {
scanf("%s", ch);
n = strlen(ch);
build(ch, n);
long long ans = 0;
vector<pair<pair<int, int>, int> > v;
lcp[n + 1] = 0;
sa[n + 1] = n;
for (int(i) = (1); (i) <= (n + 1); (i)++) {
while (!v.empty() && v.back().first.second > lcp[i]) {
pair<pair<int, int>, int> &now = v.back();
if (now.first.first < lcp[i]) {
ans += (now.first.second - lcp[i]) * f(i - now.second);
now.first.second = lcp[i];
} else
ans += (now.first.second - now.first.first) * f(i - now.second),
v.pop_back();
}
v.push_back(make_pair(make_pair(lcp[i], n - sa[i]), i));
}
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e4 + 10;
const long long mod = 998244353;
const long long G = 3;
inline long long read() {
long long p = 0;
long long f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + ch - '0';
ch = getchar();
}
return p * f;
}
long long rt, tot, lc[N << 2], rc[N << 2];
long long R[N << 2];
long long qpow(long long x, long long k, long long mo) {
long long s = 1;
while (k) {
if (k & 1) s = (s * x) % mo;
x = (x * x) % mo;
k >>= 1;
}
return s;
}
void DFT(long long *a, long long n, long long fh) {
for (long long i = 0; i < n; i++)
if (R[i] > i) swap(a[R[i]], a[i]);
for (long long i = 1; i < n; i <<= 1) {
long long gn = qpow(G, (mod - 1) / (i << 1), mod);
for (long long j = 0; j < n; j += (i << 1)) {
long long g = 1;
for (long long k = 0; k < i; k++, g = g * gn % mod) {
long long x = a[j + k];
long long y = a[j + k + i] * g % mod;
a[j + k] = (x + y) % mod;
a[j + k + i] = (x - y + mod) % mod;
}
}
}
if (fh == -1) reverse(a + 1, a + n);
}
long long K;
long long a[N << 2], b[N << 2], c[N << 2];
vector<long long> FFT(vector<long long> na, vector<long long> nb) {
long long m = na.size() - 1 + nb.size() - 1;
long long l = 0, n;
for (n = 1; n <= m; n <<= 1) l++;
for (long long i = 0; i < n; i++) a[i] = b[i] = 0;
for (long long i = 0; i < na.size(); i++) a[i] = na[i];
for (long long i = 0; i < nb.size(); i++) b[i] = nb[i];
for (long long i = 0; i < n; i++)
R[i] = (R[i >> 1] >> 1) | ((i & 1) << (l - 1));
DFT(a, n, 1);
DFT(b, n, 1);
for (long long i = 0; i < n; i++) c[i] = a[i] * b[i] % mod;
DFT(c, n, -1);
for (long long i = 0; i < n; i++)
c[i] = (long long)(c[i] * qpow(n, mod - 2, mod) % mod);
m = min(m, K);
vector<long long> nc;
for (long long i = 0; i <= m; i++) nc.push_back(c[i]);
return nc;
}
long long Q, ya[N], yb[N];
vector<long long> build(long long &u, long long L, long long R) {
if (!u) u = ++tot;
if (L == R) {
vector<long long> v;
v.push_back(1);
v.push_back(yb[L]);
return v;
}
long long mid = (L + R) >> 1;
vector<long long> na = build(lc[u], L, mid);
vector<long long> nb = build(rc[u], mid + 1, R);
return FFT(na, nb);
}
long long n;
int main() {
n = read();
K = read();
for (long long i = 1; i <= n; i++) {
ya[i] = read();
}
Q = read();
rt = tot = 0;
while (Q--) {
long long op = read();
if (op == 1) {
long long q = read();
long long k = read();
long long d = read();
for (long long i = 1; i <= n; i++) yb[i] = ya[i];
yb[k] = d;
for (long long i = 1; i <= n; i++) {
yb[i] = q - yb[i];
if (yb[i] < 0) yb[i] += mod;
}
} else {
long long q = read();
long long l = read();
long long r = read();
long long d = read();
for (long long i = 1; i <= n; i++) yb[i] = ya[i];
for (long long i = l; i <= r; i++) yb[i] += d;
for (long long i = 1; i <= n; i++) {
yb[i] = q - yb[i];
if (yb[i] < 0) yb[i] += mod;
}
}
vector<long long> ans = build(rt, 1, n);
printf("%lld\n", (ans[K] + mod) % mod);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int inf = 100000000;
int main() {
char str[100005];
scanf("%s", str);
int sz = strlen(str), i;
bool is[30];
int lastpos[30];
memset(is, 0, sizeof(is));
for (i = 0; i < sz; i++) {
is[str[i] - 'a'] = 1;
lastpos[str[i] - 'a'] = i;
}
int borto = 25;
int pos = 0;
while (1) {
if (borto < 0) break;
if (is[borto] == 0) {
borto--;
continue;
}
if (pos > lastpos[borto]) {
borto--;
continue;
}
if ((str[pos] - 'a') == borto) {
printf("%c", str[pos]);
if (pos == lastpos[str[pos] - 'a']) borto--;
}
if (pos == sz - 1) break;
pos++;
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double distance(double x1, double y1, double x2, double y2) {
return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
}
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
double total = 0, x1, y1, x2, y2;
cin >> x1 >> y1;
cout.precision(9);
for (int i = 1; i < n; ++i) {
cin >> x2 >> y2;
total += distance(x1, y1, x2, y2);
x1 = x2;
y1 = y2;
}
total /= 50;
total *= k;
cout << fixed << total << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef struct node
{
long long a[51][51];
long long scale;
struct node operator *(const struct node & tmp)
{
struct node ret;
long long i,j,k;
ret.scale=scale;
memset(ret.a,0,sizeof(ret.a));
for(k=1;k<=scale;k++)
for(i=1;i<=scale;i++)
for(j=1;j<=scale;j++)
ret.a[i][j]=(ret.a[i][j]+a[i][k]*tmp.a[k][j])%1000000007;
return ret;
}
}NODE,*PNODE;
NODE g,ans;
long long p=0;
int main()
{
long long n,i,j,k,flag=0;
scanf("%lld %lld",&n,&k);
g.scale=n;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
scanf("%d",&g.a[i][j]);
while(k)
{
if(k%2)
{
if(!flag)
{
ans=g;
flag=1;
}
else
ans=ans*g;
}
g=g*g;
k/=2;
}
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(ans.a[i][j])
p=(p+ans.a[i][j])%1000000007;
printf("%lld",p);
} | 0 |
#include<iostream>
using namespace std;
int main(){
int n,a=0,b=0,aa,bb;
cin>>n;
while(n!=0){
for(int i=0;i<n;i++){
cin>>aa>>bb;
if(aa<bb){
b+=aa+bb;
}else if(aa>bb){
a+=aa+bb;
}else if(aa==bb){
a+=aa;
b+=bb;
}
}
cout<<a<<" "<<b<<endl;
cin>>n;
a=0;
b=0;
}
return 0;
} | 0 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
template<class I, class BiOp = I (*) (I, I)>
class SegTree {
private:
int n;
std::vector<I> dat, lazy;
BiOp op;
I e;
public:
SegTree(int n_, BiOp op, I e) : op(op), e(e) {
n = 1;
while (n < n_) n *= 2;
dat.resize(2 * n - 1, 0);
lazy.resize(2 * n - 1, 0);
}
void eval(int k, int l, int r) {
if (lazy[k] == 0) return;
// cerr << "eval: k = " << k << ", l = " << l << ", r = " << r << endl;
dat[k] += lazy[k];
if (k < n - 1) {
lazy[2 * k + 1] += lazy[k];
lazy[2 * k + 2] += lazy[k];
}
lazy[k] = 0;
}
void update(int a, int b, I x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
// cerr << "update: a = " << a << ", b = " << b << ", x = " << x << ", k = " << k << ", l = " << l << ", r = " << r << endl;
eval(k, l, r);
if (b <= l || r <= a) return;
if (a <= l && r <= b) {
lazy[k] += x;
eval(k, l, r);
}
else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
dat[k] = op(dat[2 * k + 1], dat[2 * k + 2]);
}
}
I query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
// cerr << "query: a = " << a << ", b = " << b << ", k = " << k << ", l = " << l << ", r = " << r << endl;
eval(k, l, r);
if (b <= l || r <= a) return INT_MAX;
if (a <= l && r <= b) return dat[k];
I vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
I vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return op(vl, vr);
}
void print() {
int j = 2;
for (int i = 0; i < 2 * n - 1; i++) {
cerr << "(" << dat[i] << ", " << lazy[i] << ")";
if (i == j - 2) {
cerr << endl;
j *= 2;
}
else {
cerr << " ";
}
}
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n, q;
cin >> n >> q;
SegTree<int> seg(n, [](int a, int b){return min(a, b);}, INT_MAX);
// seg.print();
rep(i, q) {
// cerr << "i = " << i << endl;
int t;
cin >> t;
if (t == 0) {
int a, b, x;
cin >> a >> b >> x;
seg.update(a, b + 1, x);
}
else {
int a, b;
cin >> a >> b;
cout << seg.query(a, b + 1) << endl;
}
// seg.print();
// cerr << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y;
cin >> x >> y;
vector<int> v, v1;
for (int i = 0; i < x; i++) {
int z;
cin >> z;
v.push_back(z);
}
int flg = 1;
for (int i = 0; i < v.size(); i++) {
flg = 1;
if (i == 0) {
v1.push_back(v[i]);
} else {
for (int j = 0; j < v1.size(); j++) {
if (v[i] == v1[j]) {
flg = 0;
break;
}
}
if (flg == 1) {
v1.insert(v1.begin(), v[i]);
}
if (v1.size() > y) {
auto it = v1.end() - 1;
v1.erase(it);
}
}
}
cout << v1.size() << endl;
for (auto i2 = v1.begin(); i2 != v1.end(); i2++) {
cout << *i2 << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct gam {
int id;
int value;
int sol;
};
bool comp(gam i, gam j) { return i.value > j.value; }
bool my_comp(gam i, gam j) { return i.id < j.id; }
int main() {
int n;
cin >> n;
vector<gam> nab(n);
vector<int> sol(n);
for (int i = 0; i < n; i++) {
cin >> nab[i].value;
nab[i].id = i;
}
sort(nab.begin(), nab.end(), comp);
nab[0].sol = 1;
for (int i = 1; i < n; i++) {
if (nab[i].value == nab[i - 1].value) {
nab[i].sol = nab[i - 1].sol;
} else {
nab[i].sol = i + 1;
}
}
sort(nab.begin(), nab.end(), my_comp);
for (int i = 0; i < n; i++) {
cout << nab[i].sol << " ";
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int f[101][10];
int g_arr[8];
#define mod 1000000007
int g(int x) {
if (x < 0)
return 1;
else
return g_arr[x];
}
int main(int argc, char **argv) {
int h, w, k;
cin >> h >> w >> k;
g_arr[0] = 1;
g_arr[1] = 2;
for (int i = 2; i < w - 1; i++) {
g_arr[i] = g_arr[i - 1] + g_arr[i - 2];
}
for (int i = 0; i <= w + 1; i++) {
f[0][i] = (i == 1) ? 1 : 0;
}
for (int i = 1; i <= h; i++) {
for (int j = 0; j <= w + 1; j++) {
if (j == 0 || j == w + 1) {
f[i][j] = 0;
} else {
f[i][j] = (1ll * f[i - 1][j - 1] * g(j - 3) * g(w - 1 - j)
+ 1ll * f[i - 1][j] * g(j - 2) * g(w - 1 - j)
+ 1ll * f[i - 1][j + 1] * g(j - 2) * g(w - 1 - (j + 1))) % mod;
}
}
}
cout << f[h][k] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
uint64_t rnd_data = 0xDEADBEEFDULL;
inline void my_srand(int seed) { rnd_data = ((uint64_t)seed << 16) | 0x330E; }
inline int my_rand() {
rnd_data = rnd_data * 0x5DEECE66DULL + 0xB;
return (rnd_data >> 17) & 0x7FFFFFFF;
}
template <typename T>
void my_random_shuffle(T b, T e) {
for (int i = (1); i <= (int)((int)(e - b) - 1); i++) {
swap(b[i], b[my_rand() % (i + 1)]);
}
}
template <class _T>
inline _T sqr(const _T &x) {
return x * x;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uin(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(b, a) ? a = b, true : false;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uax(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(a, b) ? a = b, true : false;
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
char s[2000];
int main() {
int p[10];
for (int i = 0; i < (int)(10); i++) {
p[i] = i;
}
int cnt = 0;
for (int ii = 0; ii < (int)(10); ii++) {
int i = p[ii];
printf("%d\n", i);
fflush(stdout);
fgets(s, sizeof(s), stdin);
s[strlen(s) - 1] = '\0';
int len = strlen(s);
string h;
for (int i = 0; i < (int)(len); i++) {
if (isalpha(s[i])) h += s[i];
}
strcpy(s, h.c_str());
if (!strcmp(s, "no")) {
cnt++;
if (cnt > 3) {
puts("normal");
return 0;
}
continue;
}
if (!strcmp(s, "great") || !strcmp(s, "dontthinkso") ||
!strcmp(s, "notbad") || !strcmp(s, "cool") ||
!strcmp(s, "donttouchme")) {
puts("normal");
} else if (!strcmp(s, "areyouserious") || !strcmp(s, "donteven") ||
!strcmp(s, "worse") || !strcmp(s, "terrible") ||
!strcmp(s, "godieinahole") || !strcmp(s, "noway")) {
puts("grumpy");
} else {
for (;;)
;
}
return 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long arr = 2e5 + 100;
long long a[arr];
void solve() {
long long n;
cin >> n;
long long k;
cin >> k;
for (long long i = 1; i <= k; i++) cin >> a[i];
long long ans = 0;
for (long long j = 1; j <= n; j++) {
long long now = 1e9;
for (long long i = 1; i <= k; i++) now = min(now, abs(a[i] - j));
ans = max(ans, now);
}
cout << ans + 1 << '\n';
}
signed main() {
long long t;
cin >> t;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
int s[333];
int main() {
int n, t;
scanf("%d%d", &n, &t);
s[n] = t;
for (int i = 1; i < n; i++) {
int T = 18;
bool ok = 0;
while (T--) {
printf("? %d %d\n", i + 1, n);
fflush(stdout);
int tt;
scanf("%d", &tt);
if (tt != n - t) {
ok = 1;
s[i] = (tt - n + t + i) / 2;
int opt = 0;
int now = tt;
while (1) {
printf("? %d %d\n", i + 1, n);
fflush(stdout);
scanf("%d", &tt);
if (tt != n - now) break;
now = n - now;
opt ^= 1;
}
if (opt) {
printf("? %d %d\n", 1, n);
fflush(stdout);
scanf("%d", &tt);
}
break;
}
printf("? %d %d\n", 1, n);
fflush(stdout);
scanf("%d", &tt);
}
if (!ok) s[i] = i >> 1;
}
printf("! ");
for (int i = 1; i <= n; i++) printf("%d", s[i] - s[i - 1]);
}
| 6 |
#include <iostream>
#include <cstdio>
#include <cstring>
#define MN 201000
#define mod 1000000007
int inv[MN], cnt[MN], a[MN], nxt[MN];
int f[MN], s[MN];
int c[MN];
int n;
int qpow(int x, int p)
{
int ans = 1;
for(; p; p >>= 1, x = 1ll * x * x % mod) if(p & 1) ans = 1ll * ans * x % mod;
return ans;
}
void add(int x, int v) {for(int i = x; i <= n; i += i & -i) c[i] = (c[i] + v) % mod;}
int query(int x) {int ans = 0; for(int i = x; i; i -= i & -i) ans = (ans + c[i]) % mod; return ans;}
int main()
{
scanf("%d", &n);
for(int i = 1; i <= n; i++)
{
scanf("%d", &a[i]);
cnt[a[i]]++;
}
int tot = 1, ans = 0;
nxt[n] = n; for(int i = n - 1; i >= 1; i--) cnt[i] += cnt[i + 1] - 1, nxt[i] = cnt[i + 1] == 1 ? i : nxt[i + 1];
for(int i = 1; i <= n; i++) tot = 1ll * tot * cnt[i] % mod;
inv[0] = inv[1] = 1;
for(int i = 2; i <= n; i++) inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
s[0] = 1; for(int i = 1; i <= n; i++) s[i] = 1ll * s[i - 1] * (cnt[i] == 1 ? 1 : 1ll * inv[cnt[i]] * (cnt[i] - 1) % mod) % mod;
for(int i = 1; i <= n; i++) f[i] = (1ll * f[i - 1] * inv[cnt[i]] % mod * (cnt[i] - 2) + 1ll * tot * inv[cnt[i]]) % mod;
for(int i = n; i >= 1; i--)
{
ans = (ans + 1ll * f[a[i]] * (query(nxt[a[i]]) - query(a[i] - 1) + mod) % mod * qpow(s[a[i]], mod - 2)) % mod;
add(a[i], s[a[i]]);
}
memset(c, 0, sizeof(c));
for(int i = 1; i <= n; i++)
{
ans = (ans - 1ll * f[a[i]] * (query(nxt[a[i]]) - query(a[i]) + mod) % mod * qpow(s[a[i]], mod - 2) % mod + mod) % mod;
add(a[i], s[a[i]]);
}
memset(c, 0, sizeof(c));
for(int i = 1; i <= n; i++)
{
ans = (ans + 1ll * (query(n) - query(a[i])) * tot) % mod;
add(a[i], 1);
}
printf("%d\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 4e8;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
set<int> sets;
set<int>::iterator ite;
string cmd;
int q, x, head = 0, tail = INF;
cin >> q;
int res = 1, temp = 1;
sets.insert(0);
sets.insert(INF);
while (q--) {
cin >> cmd >> x;
if (cmd[1] == 'D') {
if (x > head && x < tail) ++temp;
sets.insert(x);
} else {
if (x < head || x > tail) {
res = 0;
break;
}
if (x != head && x != tail) res = (long long)res * 2 % MOD;
temp = 1;
ite = sets.find(x);
--ite;
head = *ite;
++ite;
++ite;
tail = *ite;
--ite;
sets.erase(ite);
}
}
res = (long long)res * temp % MOD;
cout << res;
}
| 4 |
#include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
const int MAXN = 16;
int n, a[MAXN][MAXN], b[MAXN+1];
ll f[1<<MAXN], g[1<<MAXN];
inline int count(int x)
{
int res = 0;
for(int i=0;i<n;++i)
if(x&(1<<i)) ++res;
return res;
}
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
scanf("%d",&a[i][j]);
const int MAXS = 1<<n;
for(int s=1;s<MAXS;s++)
{
int num = 0; g[s] = 0;
for(int i=0;i<n;i++)
if(s & (1<<i)) b[++num] = i;
for(int i=1;i<num;i++)
for(int j=i+1;j<=num;j++)
g[s] += a[b[i]][b[j]];
}
for(int s=1;s<MAXS;s++){
for(int t=s;t;t=(t-1)&s){
f[s] = max(f[s], f[s^t] + g[t]);
}
}
printf("%lld\n",f[MAXS-1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
int N, a[4001], dp[4001][4001], last[1000001], prev[4001], ans = 1;
inline int max(int a, int b) { return a > b ? a : b; }
int main() {
int i, j, t;
scanf("%d", &N);
for (i = 1; i <= N; ++i) {
scanf("%d", a + i);
t = prev[i] = last[a[i]];
last[a[i]] = i;
dp[i][0] = 1;
for (j = i - 1; j > 0; --j) {
dp[i][j] = 2;
if (t >= j) t = prev[t];
if (t != 0) dp[i][j] = dp[j][t] + 1;
if (dp[i][j] > ans) ans = dp[i][j];
}
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int MAXINT = 1073741823;
int parent_of[MAXN], dp[MAXN], maximum[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, current, parent;
cin >> n;
parent_of[0] = -1;
dp[0] = 1;
maximum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> parent_of[i];
parent_of[i]--;
current = i;
dp[current] = 1;
maximum[current] = 0;
while (parent_of[current] != -1) {
parent = parent_of[current];
if (dp[current] < dp[parent])
break;
else if (dp[current] > dp[parent])
dp[parent] = dp[current];
else if (dp[current] == maximum[parent])
dp[parent] = dp[current] + 1;
else {
maximum[parent] = max(maximum[parent], dp[current]);
break;
}
maximum[parent] = max(maximum[parent], dp[current]);
current = parent;
}
cout << maximum[0] << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int N = 512;
vector<int> dp(N);
dp[0] = 0;
for (int i = 1; i < N; ++i) {
set<int> s = {0, 1, 2};
s.erase(dp[i - 1]);
if (i % 2 == 0) s.erase(dp[i / 2]);
dp[i] = *s.begin();
}
vector<int> wtf = {4, 12, 0, 4, 12, 0, 4, 12, 4, 12, 0};
int n, k;
cin >> n >> k;
int x = 0;
for (int i = 0, y; i < n; ++i) {
cin >> y;
if (k & 1) {
if (y < 244)
x ^= dp[y];
else {
if (y % 2 == 1) continue;
if (y % 16 == wtf[(y - 244) % wtf.size()])
x ^= 2;
else
x ^= 1;
}
} else {
if (y <= 2)
x ^= y;
else
x ^= y == 1 || y % 2 == 0;
}
}
if (x)
cout << "Kevin\n";
else
cout << "Nicky\n";
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define inf 0x7fffffff
#define RG register
#define maxn 1000005
#define maxm 205
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
inline ll read(){
ll x = 0, f = 1;
char ch = getchar();
while(ch > '9' || ch < '0') {if(ch == '-') f = -1;ch = getchar();}
while(ch >= '0' && ch <= '9'){x = x *10 + ch -'0';ch = getchar();}
return x * f;
}
int n, m, k, po[2][maxn];
int qpow(int a, int b){
int ans = 1, base = a;
while(b){
if(b & 1) ans = 1ll * ans * base % mod;
base= 1ll * base * base % mod;
b >>= 1;
}
return ans;
}
int fac[maxn], inv[maxn], ans;
int C(int n, int m){return 1ll * fac[n] * inv[m] % mod *inv[n - m] % mod;}
int main(){
int i, j, x, l, r, mid;
fac[0] = po[0][0] = po[1][0] = 1;
for(i = 1;i <= maxn - 5;i++) fac[i] = 1ll * fac[i - 1] * i % mod, po[0][i] = po[0][i - 1] * 2ll % mod, po[1][i] = po[1][i - 1] * 3ll % mod;
inv[maxn - 5] = qpow(fac[maxn - 5], mod - 2);
for(i = maxn - 6;i >= 0;i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
n = read(), m = read(), k = read();
int las = 1;
for(i = 0;i <= m + k;i++){
ans = (ans + 1ll * C(n + i - 1, n - 1) * po[1][m + k -i] % mod * las % mod) % mod;
if(i + 1 <= m && i + 1 <= k) las = las * 2ll % mod;
else{
if(i + 1 <= k) las = ((las * 2ll - C(i, m)) % mod + mod) % mod;
else if(i + 1 <= m) las = ((las * 2ll - C(i, i - k)) % mod + mod) % mod;
else las = (((las * 2ll - C(i, i - k)) % mod + mod - C(i, m) ) % mod + mod ) % mod;
}
}
printf("%lld\n",ans);
return 0;
} | 0 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int par[26];
int ran[26];
void init()
{
for(int i=0;i<26;i++) par[i]=i,ran[i]=0;
}
int find(int x)
{
if(par[x] == x) return x;
else return par[x]=find(par[x]);
}
void unite(int x,int y)
{
x=find(x);
y=find(y);
if(x == y) return ;
if(ran[x]<ran[y]) par[x]=par[y];
else
{
par[y]=par[x];
if(ran[x] == ran[y]) ran[x]++;
}
}
bool same(int x,int y)
{
return find(x)==find(y);
}
int main()
{
while(1)
{
int n;
int dif[26]={};
bool ok[26]={};
int t = 0;
cin >> n;
if(n == 0) return 0;
init();
for(int i=0;i<n;i++)
{
string x; cin >> x;
if(!ok[(x[0]-'a')])
{
ok[(x[0]-'a')] = true; t++;
}
if(!ok[(x[x.size()-1]-'a')])
{
ok[(x[x.size()-1]-'a')] = true; t++;
}
if(!same((x[0]-'a'),(x[x.size()-1]-'a')))
{
unite((x[0]-'a'),(x[x.size()-1]-'a')); t--;
}
dif[(x[0]-'a')]++;
dif[(x[x.size()-1]-'a')]--;
}
if(t != 1) goto out;
for(int i=0;i<26;i++)
{
if(dif[i] != 0) goto out;
}
puts("OK"); continue; out:; puts("NG");
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k, x;
cin >> n >> k >> x;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int color = arr[0], cnt = 1;
vector<pair<int, int> > v;
for (int i = 1; i < n; i++) {
if (color == arr[i]) {
cnt++;
} else {
v.push_back({color, cnt});
cnt = 1;
color = arr[i];
}
}
v.push_back({color, cnt});
int count = 0, maxx = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].first == x && v[i].second == 2) {
count = 2;
int j = i + 1, k = i - 1;
while (j < n && k >= 0 && v[j].second + v[k].second >= 3 &&
v[j].first == v[k].first) {
count += v[j].second + v[k].second;
j++;
k--;
}
if (count > maxx) maxx = count;
} else
continue;
}
cout << maxx << endl;
return 0;
}
| 2 |
# include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, a[N], par[N], ind;
long long dp[N], mx = -1e18;
vector <int> ans;
int main(){
scanf("%d", &n);
for(int i = 1; i <= n; i ++){
scanf("%d", &a[i]);
dp[i] = a[i];
par[i] = i;
}
for(int i = 1; i <= n; i ++){
for(int j = i - 2; j >= 1; j -= 2){
if(dp[j] + a[i] > dp[i]){
dp[i] = dp[j] + a[i];
par[i] = j;
}
}
}
for(int i = 1; i <= n; i ++){
if(mx < dp[i]){
mx = dp[i];
ind = i;
}
}
cout << mx << endl;
for(int i = n; i > ind; i --){
ans.push_back(i);
}
while(ind != par[ind]){
int md = (ind + par[ind]) >> 1;
for(int i = md; i > par[ind]; i --)
ans.push_back(i);
ind = par[ind];
}
for(int i = 1; i < ind; i ++)
ans.push_back(1);
cout << ans.size() << endl;
for(int i : ans)
cout << i << endl;
}
| 0 |
#include<stdio.h>
#include<math.h>
#include<string.h>
int a,s,d[501],f[501],g[501],h,j,i,k,q=2100000000;
char z[501][501];
int main(void)
{
scanf("%d %d",&a,&s);
for(i=0;i<a;i++) scanf("%s",z[i]);
for(i=0;i<a;i++){
d[i]=0;
f[i]=0;
g[i]=0;
}
for(i=0;i<a;i++){
for(j=0;j<s;j++){
if(z[i][j]!='W') d[i]++;
if(z[i][j]!='R') f[i]++;
if(z[i][j]!='B') g[i]++;
}
// printf("%d %d %d %d\n",i,d[i],f[i],g[i]);
}
for(i=1;i<a-1;i++){
for(j=a-1;j>1;j--){
h=0;
if(i<j){
for(k=0;k<i;k++) h+=d[k];
for(k=i;k<j;k++) h+=g[k];
for(k=j;k<a;k++) h+=f[k];
if(q>h) q=h;
// printf("%d %d\n",q,h);
}
}
}
printf("%d\n",q);
return 0;
} | 0 |
#include<bits//stdc++.h>
#define rep(i,n) for(int i = 0;i < n;i++)
#define MOD 1000000007
using namespace std;
typedef long long int ll;
int n,a,b,ans = 0;
vector<ll> sz, pw;vector<vector<int>> v;
void dfs(int node, int p) {// now , before
sz[node] = 1;
int pr = pw[1];
for (int u : v[node]) {
if (u != p) {
dfs(u, node); sz[node] += sz[u];
pr = (pr - pw[n - sz[u]] + MOD) % MOD;
}
}
if (node != 1) {
pr = (pr - pw[sz[node]] + MOD) % MOD;
}
pr = (pr + (v[node].size() - 1) * pw[n] % MOD + MOD) % MOD;
ans = (ans + pr) % MOD;
}
int main() {
cin >> n; v.resize(n+10), sz.resize(n+10), pw.resize(n+10);
pw[0] = 1; pw[1] = (MOD + 1) / 2;
rep(i, n - 1) {
pw[i + 2] = (pw[i + 1] * pw[1]) % MOD;
cin >> a >> b;
v[a].push_back(b);v[b].push_back(a);
}dfs(1, 0);
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const double PI = acos(-1);
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 7;
int n;
int sum[2][N], nex[N], res[N];
char s[N];
vector<int> vl[N];
void update(const int &p) {
for (int i = p; nex[i] > p && i >= 0; --i) nex[i] = p;
}
signed main() {
scanf("%d%s", &n, s);
sum[0][n] = sum[1][n] = 0;
memset(nex, 0x3f, sizeof nex);
for (int i = n - 1; i >= 0; --i) {
if (s[i] == '?') {
sum[0][i] = sum[0][i + 1] + 1;
sum[1][i] = sum[1][i + 1] + 1;
} else if (s[i] == '1') {
sum[0][i] = 0;
sum[1][i] = sum[1][i + 1] + 1;
} else if (s[i] == '0') {
sum[0][i] = sum[0][i + 1] + 1;
sum[1][i] = 0;
}
vl[sum[1][i]].emplace_back(i);
vl[sum[0][i]].emplace_back(i);
}
for (int len = n; len; --len) {
int i = 0;
reverse(vl[len].begin(), vl[len].end());
for (const int &p : vl[len]) update(p);
while (nex[i] < n) {
i = nex[i] + len;
++res[len];
}
}
for (int i = 1; i <= n; ++i) {
printf("%d%c", res[i], " \n"[i == n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, H[300005], d, ant[300005];
vector<int> v[300005], st, L;
void dfs(int nod) {
int ok = 0;
st.push_back(nod);
H[nod] = st.size();
if (H[nod] >= d) {
cout << "PATH\n";
cout << st.size() << '\n';
for (auto it : st) cout << it << ' ';
exit(0);
}
for (auto it : v[nod])
if (!H[it]) {
ant[it] = nod;
dfs(it);
ok = 1;
}
if (!ok) L.push_back(nod);
st.pop_back();
}
bool _try(int a, int b) {
if (H[a] < H[b]) swap(a, b);
if (H[a] - H[b] + 1 >= 3 && (H[a] - H[b] + 1) % 3 != 0) {
cout << H[a] - H[b] + 1 << '\n';
int crt = a;
while (crt != b) {
cout << crt << ' ';
crt = ant[crt];
}
cout << crt << '\n';
return 1;
}
return 0;
}
bool _try2(int a, int b, int c) {
if (H[a] < H[b]) swap(a, b);
if (H[a] - H[b] + 2 >= 3 && (H[a] - H[b] + 2) % 3 != 0) {
cout << H[a] - H[b] + 2 << '\n';
int crt = a;
while (crt != b) {
cout << crt << ' ';
crt = ant[crt];
}
cout << crt << ' ' << c << '\n';
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
d = n / k + (n % k != 0);
for (int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
cout << "CYCLES\n";
for (auto it : L) {
if (k == 0) break;
k--;
if (_try(it, v[it][0])) continue;
if (_try(it, v[it][1])) continue;
if (_try(it, v[it][2])) continue;
if (_try2(v[it][0], v[it][1], it)) continue;
if (_try2(v[it][0], v[it][2], it)) continue;
if (_try2(v[it][1], v[it][2], it)) continue;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int64_t N,ans;
cin >>N;
for (int i = 1; i <= (int)(sqrt(N+1)-1); i++)if((N-i) % i == 0)ans+=(N-i)/i;
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int n, r = 0;
cin >> n;
int h[n], v[n];
for (int k = 0; k < n; k++) {
cin >> h[k] >> v[k];
}
for (int k = 0; k < n; k++) {
for (int j = 0; j < n; j++) {
if (h[k] == v[j] && k != j) r++;
}
}
cout << r << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void deb() { cerr << endl; }
template <typename T, typename... t>
void deb(T a, t... b) {
cerr << a << " ";
deb(b...);
}
int64_t dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int64_t dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
void max_self(int64_t& x, int64_t y) { x = max(x, y); }
template <class T>
T roof(T x, T y) {
return (x + y - 1) / y;
}
template <class T>
T lcm(T a, T b) {
return a * b / __gcd(a, b);
}
int64_t qpow(int64_t x, int64_t n) {
int64_t r = 1;
for (; n; n >>= 1) {
if (n & 1) (r = r * x);
(x = x * x);
}
return r;
}
void done(int64_t cases) {
int64_t n, k;
cin >> n >> k;
vector<pair<int64_t, int64_t> > v(n);
vector<int64_t> store;
int64_t ans = 0;
for (auto& [x, y] : v) {
cin >> x >> y;
ans += min(x, y);
store.push_back(min(2 * x, y) - min(x, y));
}
sort((store).begin(), (store).end());
int64_t cnt = 0;
while (cnt < k) {
ans += store.back();
cnt++;
store.pop_back();
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int64_t tt;
tt = 1;
for (int64_t i = 1; i <= tt; ++i) {
done(i);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
if (n == k || (n % 2 != 0 && k % 2 != 0 && k < n) ||
(n % 2 == 0 && k % 2 == 0 && k < n)) {
cout << 0 << "\n";
return;
} else if ((n % 2 != 0 && k < n) || (n % 2 == 0 && k < n)) {
cout << 1 << "\n";
return;
} else {
cout << abs(n - k) << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
char c[100005];
int n, m, q;
int main() {
int i, j;
while (~scanf("%d%d%d", &n, &m, &q)) {
m = m + q;
scanf("%s", c);
int op, le, ri, type;
while (m--) {
scanf("%d%d%d%d", &op, &le, &ri, &type);
le--;
ri--;
if (op == 1)
memset(c + le, type + '0', ri - le + 1);
else {
if (memcmp(c + le, c + le + type, ri - le + 1 - type) == 0)
printf("YES\n");
else
printf("NO\n");
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const long long int P = 1000000007;
const double eps = 1e-6;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
bool rev = 0;
if (n > m) {
swap(n, m);
rev = 1;
}
if (n == 1 && m == 1) {
cout << 0, cout << "\n";
return 0;
}
long long int ans[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = i + 1;
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) ans[i][j] *= (n + 1 + j);
if (rev == 0) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << ans[i][j] << " ";
cout << "\n";
}
} else {
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) cout << ans[i][j] << " ";
cout << "\n";
}
}
cerr << "\nTime elapsed : " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long int N;
cin >> N;
long long int max=1;
for (long long int i=1;i<=sqrt(N)+1;i++){
if(N%i==0) max = i;
}
cout << max+N/max-2;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const double pi=acos(-1);
const int dx[]={0,1,0,-1};
const int dy[]={1,0,-1,0};
#define ll long long
#define inf int(1e9+7)
#define pb push_back
#define mp make_pair
string s,t;
bool ch[30];
int main()
{
cin>>s;
int n=s.size();
for(int i=0;i<n;i++)
ch[s[i]-'a']=1;
if(n!=26)
{
cout<<s;
for(int i=0;i<26;i++)
{
if(ch[i])
continue;
cout<<char(i+'a');
return 0;
}
}
t=s;
if(!next_permutation(t.begin(),t.end()))
{
cout<<-1;
return 0;
}
for(int i=0;i<n;i++)
{
cout<<t[i];
if(t[i]!=s[i])
break;
}
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
using real = double;
real EPS = 1e-10;
struct Point {
real x, y;
Point& operator+=(const Point a) { x += a.x; y += a.y; return *this; }
Point& operator-=(const Point a) { x -= a.x; y -= a.y; return *this; }
Point& operator*=(const real k) { x *= k; y *= k; return *this; }
Point& operator/=(const real k) { x /= k; y /= k; return *this; }
Point operator+(const Point a) const {return Point(*this) += a; }
Point operator-(const Point a) const {return Point(*this) -= a; }
Point operator*(const real k) const {return Point(*this) *= k; }
Point operator/(const real k) const {return Point(*this) /= k; }
bool operator<(const Point &a) const { return (x != a.x ? x < a.x : y < a.y); }
explicit Point(real a = 0, real b = 0) : x(a), y(b) {};
};
bool sorty(Point a, Point b){
return (a.y != b.y ? a.y < b.y : a.x < b.x);
}
istream& operator>> (istream& s, Point& P){
s >> P.x >> P.y;
return s;
}
inline real dot(Point a, Point b){ return a.x*b.x + a.y*b.y; }
inline real cross(Point a, Point b){ return a.x*b.y - a.y*b.x; }
inline real abs(Point a){ return sqrt(dot(a, a)); }
static constexpr int COUNTER_CLOCKWISE = 1;
static constexpr int CLOCKWISE = -1;
static constexpr int ONLINE_BACK = 2;
static constexpr int ONLINE_FRONT = -2;
static constexpr int ON_SEGMENT = 0;
int ccw(Point a, Point b, Point c){
b -= a; c -= a;
if(cross(b, c) > EPS) return COUNTER_CLOCKWISE;
if(cross(b, c) < -EPS) return CLOCKWISE;
if(dot(b, c) < 0) return ONLINE_BACK;
if(abs(b) < abs(c)) return ONLINE_FRONT;
return ON_SEGMENT;
}
struct Segment {
Point a, b;
Segment(Point x, Point y) : a(x), b(y) {};
};
struct Line {
Point a, b;
Line(Point x, Point y) : a(x), b(y) {};
};
bool intersect(Segment s, Segment t){
return (ccw(s.a, s.b, t.a)*ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a)*ccw(t.a, t.b, s.b) <= 0);
}
double distance(Segment s, Point c){
if(dot(s.b-s.a, c-s.a) < EPS) return abs(c-s.a);
if(dot(s.a-s.b, c-s.b) < EPS) return abs(c-s.b);
return abs(cross(s.b-s.a, c-s.a)) / abs(s.a-s.b);
}
double distance(Segment s, Segment t){
if(intersect(s, t)) return 0.0;
return min({distance(s, t.a), distance(s, t.b),
distance(t, s.a), distance(t, s.b)});
}
Point crossPoint(Segment s, Segment t){
real d1 = cross(s.b-s.a, t.b-t.a);
real d2 = cross(s.b-s.a, s.b-t.a);
if(fabs(d1) < EPS && fabs(d2) < EPS) return t.a;
return t.a+(t.b-t.a)*d2/d1;
}
Point crossPoint(Line s, Line t){
real d1 = cross(s.b-s.a, t.b-t.a);
real d2 = cross(s.b-s.a, s.b-t.a);
if(fabs(d1) < EPS && fabs(d2) < EPS) return t.a;
return t.a+(t.b-t.a)*d2/d1;
}
Point project(Segment s, Point p){
Point Q = s.b-s.a;
return s.a + Q*(dot(p-s.a, Q) / dot(Q, Q));
}
Point refrect(Segment s, Point p){
Point Q = project(s, p);
return Q*2-p;
}
bool isOrthogonal(Segment s, Segment t){
return fabs(dot(s.b-s.a, t.b-t.a)) < EPS;
}
bool isparallel(Segment s, Segment t){
return fabs(cross(s.b-s.a, t.b-t.a)) < EPS;
}
using Polygon = vector<Point>;
real area(Polygon v){
if(v.size() < 3) return 0.0;
real ans = 0.0;
for (int i = 0; i < v.size(); ++i) {
ans += cross(v[i], v[(i+1)%v.size()]);
}
return ans/2;
}
Polygon convex_hull(Polygon v){
int n = v.size();
sort(v.begin(),v.end(), sorty);
int k = 0;
Polygon ret(n*2);
for (int i = 0; i < n; ++i) {
while(k > 1 && cross(ret[k-1]-ret[k-2], v[i]-ret[k-1]) < 0) k--;
ret[k++] = v[i];
}
for(int i = n-2, t=k; i >= 0; i--){
while(k > t && cross(ret[k-1]-ret[k-2], v[i]-ret[k-1]) < 0) k--;
ret[k++] = v[i];
}
ret.resize(k-1);
return ret;
}
bool isconvex(Polygon v){
int n = v.size();
for (int i = 0; i < n; ++i) {
if(ccw(v[(i+n-1)%n], v[i], v[(i+1)%n]) == CLOCKWISE) return false;
}
return true;
}
// in = 2, on = 1, out = 0;
int contains(Polygon v, Point p){
int n = v.size();
bool x = false;
for (int i = 0; i < n; ++i) {
Point a = v[i]-p, b = v[(i+1)%n]-p;
if(fabs(cross(a, b)) < EPS && dot(a, b) < EPS) return 1;
if(a.y > b.y) swap(a, b);
if(a.y < EPS && EPS < b.y && cross(a, b) > EPS) x = !x;
}
return (x?2:0);
}
double diameter(Polygon v){
int n = v.size();
if(n == 2) return abs(v[0]-v[1]);
int i = 0, j = 0;
for (int k = 0; k < n; ++k) {
if(v[i] < v[k]) i = k;
if(!(v[j] < v[k])) j = k;
}
double ret = 0;
int si = i, sj = j;
while(i != sj || j != si){
ret = max(ret, abs(v[i]-v[j]));
if(cross(v[(i+1)%n]-v[i], v[(j+1)%n]-v[j]) < 0.0) i = (i+1)%n;
else j = (j+1)%n;
}
return ret;
}
Polygon convexCut(Polygon v, Line l){
Polygon q;
int n = v.size();
for (int i = 0; i < n; ++i) {
Point a = v[i], b = v[(i+1)%n];
if(ccw(l.a, l.b, a) != -1) q.push_back(a);
if(ccw(l.a, l.b, a)*ccw(l.a, l.b, b) < 0){
q.push_back(crossPoint(Line(a, b), l));
}
}
return q;
}
int main() {
int n; cin >> n;
Polygon G(n);
for(auto && i : G) cin >> i;
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
Point a, b;
cin >> a >> b;
Line l(a, b);
auto G2 = convexCut(G, l);
printf("%.10f\n", area(G2));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int g;
int sum;
int mx;
int mn;
int main() {
cin >> a >> b >> c;
sum = a + b + c;
g = a * b * c;
int mx = max(a, max(b, c));
int mn = min(a, min(b, c));
if (mx == 1) {
cout << "3" << endl;
return 0;
}
if (a == 1 && c == 1) {
cout << sum << endl;
return 0;
}
if (mn != 1) {
cout << g << endl;
return 0;
}
if (mn == 1) {
if (mn == c) {
cout << (c + b) * a << endl;
} else if (mn == a) {
cout << (a + b) * c << endl;
} else {
cout << (b + (sum - (b + mx))) * mx << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr1[26];
int arr2[26];
bool fun(string str1, string str2, int m, int n) {
int j = 0;
for (int i = 0; i < n && j < m; i++)
if (str1[j] == str2[i]) j++;
return (j == m);
}
int main() {
string s, t;
cin >> s >> t;
if (fun(t, s, t.size(), s.size())) {
cout << "automaton" << endl;
return 0;
}
memset(arr1, 0, sizeof(arr1));
memset(arr2, 0, sizeof(arr2));
for (int i = 0; i < s.size(); i++) {
arr1[s[i] - 'a']++;
}
for (int i = 0; i < t.size(); i++) {
arr2[t[i] - 'a']++;
}
for (int i = 0; i < t.size(); i++) {
}
int freq = 0;
bool equal = false;
for (int i = 0; i < 26; i++) {
if (arr1[i] < arr2[i]) {
cout << "need tree" << endl;
return 0;
}
if (arr1[i] > arr2[i]) {
freq++;
}
}
if (freq > 0) {
cout << "both" << endl;
return 0;
}
cout << "array" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n, m;
int a[maxn];
int p[maxn];
int main() {
cin.sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
p[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
int l, r;
long long sum = 0;
for (int i = 1; i <= m; i++) {
cin >> l >> r;
if (p[r] - p[l - 1] > 0) sum += p[r] - p[l - 1];
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct Heap {
long long sum;
int siz;
priority_queue<long long> q, del;
int size() { return siz; }
void work() {
while (del.size() && q.top() == del.top()) {
q.pop();
del.pop();
}
return;
}
void push(long long x) {
q.push(x);
sum += x;
siz++;
return;
}
void erase(long long x) {
del.push(x);
sum -= x;
siz--;
return;
}
long long top() {
work();
return q.top();
}
void pop() {
work();
sum -= q.top();
q.pop();
siz--;
return;
}
} S[250010];
int deg[250010];
bool cmp(pair<int, int> a, pair<int, int> b) {
return deg[a.first] > deg[b.first];
}
vector<pair<int, int> > e[250010];
long long dp[250010][2];
int vis[250010];
void dfs(int u, int lim) {
vis[u] = lim;
int num = deg[u] - lim;
while (S[u].size() > num) S[u].pop();
long long res = 0;
vector<long long> vec1, vec2;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
int c = e[u][i].second;
if (vis[v] == lim) continue;
if (deg[v] <= lim) break;
dfs(v, lim);
res += dp[v][0];
long long val = dp[v][1] + c - dp[v][0];
if (val < 0) {
res += val;
num--;
} else {
vec1.push_back(val);
S[u].push(val);
}
}
while (S[u].size() > max(num, 0)) {
vec2.push_back(S[u].top());
S[u].pop();
}
dp[u][0] = res + S[u].sum;
while (S[u].size() > max(num - 1, 0)) {
vec2.push_back(S[u].top());
S[u].pop();
}
dp[u][1] = res + S[u].sum;
for (int i = 0; i < vec2.size(); i++) S[u].push(vec2[i]);
for (int i = 0; i < vec1.size(); i++) S[u].erase(vec1[i]);
return;
}
void work(int u) {
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
int c = e[u][i].second;
S[v].push(c);
}
return;
}
pair<int, int> id[250010];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
e[u].push_back(make_pair(v, c));
e[v].push_back(make_pair(u, c));
deg[u]++;
deg[v]++;
}
for (int i = 1; i <= n; i++) {
sort(e[i].begin(), e[i].end(), cmp);
id[i] = make_pair(deg[i], i);
}
sort(id + 1, id + n + 1);
memset(vis, -1, sizeof(vis));
int now = 1;
for (int i = 0; i < n; i++) {
while (now <= n && id[now].first <= i) {
work(id[now].second);
now++;
}
long long ans = 0;
for (int j = now; j <= n; j++) {
int u = id[j].second;
if (vis[u] == i) continue;
dfs(u, i);
ans += dp[u][0];
}
printf("%lld ", ans);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int size;
set<int> a;
cin >> size;
for (int i = 0; i < size; i++) {
int v;
cin >> v;
a.insert(v);
}
if (a.size() == 1)
cout << size << endl;
else
cout << 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[5011], a, b, c, n;
int main() {
cin >> n;
printf("? 1 2\n");
fflush(stdout);
scanf("%d", &a);
printf("? 1 3\n");
fflush(stdout);
scanf("%d", &b);
printf("? 2 3\n");
fflush(stdout);
scanf("%d", &c);
int q = a - c;
x[1] = (q + b) / 2;
x[2] = a - x[1];
x[3] = b - x[1];
for (int i = 4; i <= n; i++) {
printf("? %d %d\n", i - 1, i);
fflush(stdout);
scanf("%d", &q);
x[i] = q - x[i - 1];
}
printf("! ");
for (int i = 1; i <= n; i++) {
printf("%d ", x[i]);
}
fflush(stdout);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int even = 0, odd = 0;
while (t > 0) {
t--;
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0) even = 1;
if (a[i] % 2 != 0) odd = 1;
}
if (n % 2 == 0) {
if (even == 0) {
cout << "NO" << endl;
} else if (even == 1 and odd == 1)
cout << "YES" << endl;
else if (odd == 0)
cout << "NO" << endl;
} else {
if (even == 1 and odd == 1)
cout << "YES" << endl;
else if (even == 0)
cout << "YES" << endl;
else if (even == 1 and odd == 0)
cout << "NO" << endl;
}
even = odd = 0;
}
}
| 1 |
#include<queue>
#include<cstdio>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int INF=1<<29;
struct edge{ int v,cost; };
int main(){
for(int n,m,c;scanf("%d%d%d",&n,&m,&c),n;){
vector<edge> G[100];
rep(i,m){
int u,v,cost; scanf("%d%d%d",&u,&v,&cost); u--; v--;
G[u].push_back((edge){v,cost});
}
// d[u][i] := ( i 本の辺のコストを 0 にして頂点 u にたどり着いたときの最短距離 )
static int d[100][1001];
rep(u,n) rep(i,m+1) d[u][i]=INF;
d[0][0]=0;
priority_queue< pair< int,pair<int,int> > > Q; Q.push(make_pair(0,make_pair(0,0)));
while(!Q.empty()){
int d_now=-Q.top().first,u=Q.top().second.first,i=Q.top().second.second; Q.pop();
if(d_now>d[u][i]) continue;
rep(j,G[u].size()){
int v=G[u][j].v,cost=G[u][j].cost;
// 辺のコストを 0 にしない
if(d[v][i]>d[u][i]+cost){
d[v][i]=d[u][i]+cost;
Q.push(make_pair(-d[v][i],make_pair(v,i)));
}
// 辺のコストを 0 にする
if(i<m && d[v][i+1]>d[u][i]){
d[v][i+1]=d[u][i];
Q.push(make_pair(-d[v][i+1],make_pair(v,i+1)));
}
}
}
int ans;
rep(i,m+1) if(d[n-1][i]<=c) { ans=i; break; }
printf("%d\n",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long N, P;
string S;
cin >> N >> P >> S;
reverse(S.begin(), S.end());
if (10 % P == 0) {
long ans = 0;
for (long i = 0; i < N; i++) {
if ((S.at(i) - '0') % P == 0) ans += N - i;
}
return cout << ans << "\n", 0;
}
vector<long> V(P);
long sum = 0;
V.at(sum)++;
for (long i = 0, dig = 1; i < N; i++, dig = dig * 10 % P) {
sum += (S.at(i) - '0') * dig;
sum %= P;
V.at(sum)++;
}
long ans = 0;
for (auto v : V) ans += v * (v - 1) / 2;
cout << ans << "\n";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int ar[6];
int ans;
int f(int x) { return x * x; }
int main() {
for (int i = 0; i < 6; i++) cin >> ar[i];
ans = f(ar[0] + ar[1] + ar[2]) - f(ar[0]) - f(ar[2]) - f(ar[4]);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b % a, a);
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 != 0) res = res * 1ll * a;
b /= 2;
a = a * 1ll * a;
}
return res;
}
void solve() {
long long n;
cin >> n;
vector<long long> arr(n);
for (long long i = 0; i < n; i++) cin >> arr[i];
vector<long long> res;
long long g = 0;
long long i = n - 1;
while (i > 0) {
g = gcd(g, arr[i]);
long long y = gcd(g, arr[i - 1]);
long long x = (g * 1ll * arr[i - 1]) / y;
res.push_back(x);
i--;
}
long long ans = 0;
n = res.size();
for (long long j = 0; j < n; j++) {
ans = gcd(ans, res[j]);
}
cout << ans << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
const long long mod = 1000000007;
long long segtree[N << 2], bl[N << 2], lazy[N << 2];
int fa[N], val[N], now = 1, id[N], to[N], tot = 2, q, sz[N];
struct ope {
int xz, poi;
};
vector<ope> Q;
vector<int> son[N];
void dfs(int node) {
id[node] = now++;
for (int i = 0; i < son[node].size(); i++) dfs(son[node][i]);
to[node] = now - 1;
}
long long pow_mod(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
long long Fermat(long long a) { return pow_mod(a, mod - 2); }
void chang(long long &a, long long b) {
a *= b;
a %= mod;
}
void pushdown(int l, int r, int rt) {
if (lazy[rt] != 1) {
chang(segtree[rt << 1], lazy[rt]);
chang(segtree[rt << 1 | 1], lazy[rt]);
chang(lazy[rt << 1], lazy[rt]);
chang(lazy[rt << 1 | 1], lazy[rt]);
chang(bl[rt << 1], lazy[rt]);
chang(bl[rt << 1 | 1], lazy[rt]);
lazy[rt] = 1;
}
}
void pushup(int l, int r, int rt) {
segtree[rt] = segtree[rt << 1] + segtree[rt << 1 | 1];
segtree[rt] %= mod;
}
void build(int l, int r, int rt) {
if (l == r) {
bl[rt] = 1;
lazy[rt] = 1;
if (l == 1)
segtree[rt] = val[1];
else
segtree[rt] = 0;
return;
}
int m = (l + r) / 2;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
bl[rt] = 1;
lazy[rt] = 1;
pushup(l, r, rt);
}
void add(int L, int R, long long v, long long w, int l, int r, int rt) {
if (L <= l && R >= r) {
chang(bl[rt], v);
chang(bl[rt], w);
chang(lazy[rt], v);
chang(lazy[rt], w);
chang(segtree[rt], v);
chang(segtree[rt], w);
return;
}
pushdown(l, r, rt);
int m = (l + r) / 2;
if (L <= m) add(L, R, v, w, l, m, rt << 1);
if (R > m) add(L, R, v, w, m + 1, r, rt << 1 | 1);
pushup(l, r, rt);
}
void update(int p, int v, int l, int r, int rt) {
if (l == r) {
segtree[rt] = v * bl[rt];
segtree[rt] %= mod;
return;
}
pushdown(l, r, rt);
int m = (l + r) / 2;
if (p <= m)
update(p, v, l, m, rt << 1);
else
update(p, v, m + 1, r, rt << 1 | 1);
pushup(l, r, rt);
}
long long querybl(int p, int l, int r, int rt) {
if (l == r) return bl[rt];
pushdown(l, r, rt);
int m = (l + r) / 2;
long long ans = 0;
if (p <= m)
ans = querybl(p, l, m, rt << 1);
else
ans = querybl(p, m + 1, r, rt << 1 | 1);
pushup(l, r, rt);
return ans;
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) {
return segtree[rt];
}
pushdown(l, r, rt);
int m = (l + r) / 2;
long long ans = 0;
if (L <= m) ans += query(L, R, l, m, rt << 1);
if (R > m) ans += query(L, R, m + 1, r, rt << 1 | 1);
pushup(l, r, rt);
ans %= mod;
return ans;
}
int main() {
scanf("%d%d", &val[1], &q);
while (q--) {
int ta, tb, tc;
scanf("%d", &ta);
if (ta == 1) {
scanf("%d%d", &tb, &tc);
son[tb].push_back(tot);
fa[tot] = tb;
val[tot] = tc;
Q.push_back({1, tot++});
} else {
scanf("%d", &tb);
Q.push_back({2, tb});
}
}
fa[1] = 1;
sz[1] = 1;
tot--;
dfs(1);
build(1, tot, 1);
for (int i = 0; i < Q.size(); i++) {
if (Q[i].xz == 1) {
int faq = fa[Q[i].poi];
long long ny = Fermat(sz[faq]);
update(id[Q[i].poi], val[Q[i].poi], 1, tot, 1);
add(id[faq], to[faq], ny, sz[faq] + 1, 1, tot, 1);
sz[faq]++;
sz[Q[i].poi]++;
} else {
long long ny;
if (Q[i].poi == 1)
ny = 1;
else
ny = Fermat(querybl(id[fa[Q[i].poi]], 1, tot, 1));
long long ans = query(id[Q[i].poi], to[Q[i].poi], 1, tot, 1);
chang(ans, ny);
printf("%lld\n", ans);
}
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,m;
cin>>n>>m;
vector<vector<int>> mat(n,vector<int>(m,0));
vector<vector<int>> dup(n,vector<int>(m,0));
vector<int> a;
for(int i=0; i<n; i++)
{
for(int j=0; j<m; j++)
{
int temp;
cin>>temp;
mat[i][j]=temp;
a.push_back(temp);
}
}
for(int i=0;i<n; i++)
{
sort(mat[i].begin(),mat[i].end());
}
sort(a.begin(),a.end());
for(int i=0; i<m; i++)
{
int sign=0;
for(int j=0; j<n; j++)
{
if(mat[j][i]==a[i])
{
dup[j][i]=1;
sign=1;
break;
}
}
if(sign!=1)
{
for(int j=0; j<n; j++)
{
auto it=find(mat[j].begin(),mat[j].end(),a[i]);
if(it!=mat[j].end())
{
int b=it-mat[j].begin();
if(dup[j][b]!=1)
{
dup[j][i]=1;
swap(mat[j][i],mat[j][b]);
break;
}
}
}
}
}
for(int i=0; i<n; i++)
{
for(int j=0; j<m; j++)
{
cout<<mat[i][j]<<" ";
}
cout<<endl;
}
}
return 0;
} | 2 |
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <numeric>
#include <list>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define show(a, n) rep(i,n) {cout<<a[i]<<' ';} cout<<endl;
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<long long, long long> pll;
const int INF = 1 << 30;
const long long INFL = 1LL << 62;
const int MOD = 1000000007;
const int MAX = 100000;
const int N = 100010;
int main() {
ll p;
cin >> p;
ll a[3000];
rep(i, p) cin >> a[i];
for(int i = 1; i <= p - 1; i++) {
a[i] -= a[0];
if(a[i] < 0) a[i] += p;
}
vector<ll> ans;
for(int i = p - 1; i >= 1; i--) {
ll sum_a = 0;
for(int j = 1; j <= p - 1; j++) {
sum_a += a[j];
}
sum_a *= p - 1;
ans.push_back(sum_a % p);
for(int j = 1; j <= p - 1; j++) {
a[j] = (a[j] * j) % p;
}
}
ans.push_back(a[0]);
reverse(ans.begin(), ans.end());
for(int i = 0; i < ans.size() - 1; i++) {
cout << ans[i] << ' ';
}
cout << ans[ans.size() - 1] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int m = 0, k = 0;
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] == m)
m++;
else if (a[i] == k)
k++;
}
cout << m + k << endl;
}
}
| 1 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
int neg = 1;
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * neg;
}
struct SEG {
int l;
int r;
long long sum;
long long ls;
long long rs;
};
long long s[200010], dis[200010];
SEG operator+(SEG a, SEG b) {
SEG ret;
if (a.l == -1) return b;
if (b.l == -1) return a;
ret.sum = a.sum + b.sum;
a.sum %= 1000000007;
b.sum %= 1000000007;
ret.ls = a.ls + b.ls + b.sum * (dis[a.r] - dis[a.l - 1]);
ret.rs = b.rs + a.rs + a.sum * (dis[b.r + 1] - dis[b.l]);
ret.ls %= 1000000007;
ret.rs %= 1000000007;
ret.l = a.l;
ret.r = b.r;
return ret;
}
struct SEG_Tree {
SEG t[800010];
void push_up(int cur) { t[cur] = t[((cur) << 1)] + t[((cur) << 1 | 1)]; }
void build(int cur, int l, int r) {
t[cur].l = l;
t[cur].r = r;
if (l == r) {
t[cur].sum = s[l];
t[cur].ls = s[l] * (dis[l] - dis[l - 1]);
t[cur].rs = s[l] * (dis[l + 1] - dis[l]);
return;
}
int mid = (l + r) >> 1;
build(((cur) << 1), l, mid);
build(((cur) << 1 | 1), mid + 1, r);
push_up(cur);
}
long long query2(int cur, int l, int r) {
if (t[cur].l > r || t[cur].r < l) return 0;
if (t[cur].l >= l && t[cur].r <= r) return t[cur].sum;
return query2(((cur) << 1), l, r) + query2(((cur) << 1 | 1), l, r);
}
SEG query(int cur, int l, int r) {
if (l > r) return (SEG){0, 0, 0, 0, 0};
if (t[cur].l > r || t[cur].r < l) return (SEG){-1, -1, -1, -1, -1};
if (t[cur].l >= l && t[cur].r <= r) return t[cur];
return query(((cur) << 1), l, r) + query(((cur) << 1 | 1), l, r);
}
void modify(int cur, int x, int c) {
if (t[cur].l == t[cur].r) {
t[cur].sum = c;
t[cur].ls = c * (dis[t[cur].l] - dis[t[cur].l - 1]);
t[cur].rs = c * (dis[t[cur].l + 1] - dis[t[cur].l]);
return;
}
if (x <= t[((cur) << 1)].r)
modify(((cur) << 1), x, c);
else
modify(((cur) << 1 | 1), x, c);
push_up(cur);
}
} t;
int solve(int lb, int rb) {
int l = lb;
int r = rb;
while (l < r) {
int mid = (l + r) >> 1;
if (t.query2(1, lb, mid) >= t.query2(1, mid + 1, rb))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int n = inp();
int q = inp();
for (int i = 1; i <= n; i++) dis[i] = inp() - i;
for (int i = 1; i <= n; i++) s[i] = inp();
t.build(1, 1, n);
while (q--) {
int id = inp();
int c = inp();
if (id < 0) {
t.modify(1, -id, c);
} else {
int pos = solve(id, c);
long long ans = 0;
if (id <= pos - 1) ans += t.query(1, id, pos - 1).rs;
if (pos + 1 <= c) ans += t.query(1, pos + 1, c).ls;
ans %= 1000000007;
printf("%I64d\n", ans);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int goals;
cin >> goals;
string x;
cin >> x;
string y;
string l;
int ycount = 0;
int xcount = 1;
for (int i = 0; i < goals - 1; i++) {
cin >> l;
if (l == x)
++xcount;
else {
y = l;
++ycount;
}
}
if (xcount > ycount)
cout << x << "\n";
else
cout << y << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, d;
cin >> x;
d = x;
vector<int> vec, vec2;
while (x--) {
int q, r;
cin >> q >> r;
vec.push_back(q);
vec2.push_back(r);
}
int c = 0;
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < vec2.size(); j++)
if (i != j && vec[i] == vec2[j]) {
c++;
break;
}
}
cout << d - c << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double inf = 1e8;
int ans1, ans2;
double best;
double t1, t2, x1, x2, t0;
void work() {
best = inf;
ans1 = ans2 = 0;
for (double r1 = 0.0; r1 < x1 + eps; r1 += 1.0) {
double rig = r1 * t1 - r1 * t0, lef = t0 - t2;
double r2;
if (r1 < eps || fabs(lef) < eps)
r2 = x2;
else
r2 = rig / lef;
int y1 = r1, y2 = ceil(r2 - eps);
double val =
(((double)y1) * t1 + ((double)y2) * t2) / ((double)(y1 + y2)) - t0;
while (val + eps < 0.0) {
val += t2;
y2++;
}
if (y2 > x2) continue;
if (best > val + eps || (fabs(best - val) < eps && ans1 + ans2 < y1 + y2)) {
best = val;
ans1 = y1;
ans2 = y2;
}
}
printf("%d %d\n", ans1, ans2);
}
int main() {
while (scanf("%lf%lf%lf%lf%lf", &t1, &t2, &x1, &x2, &t0) != EOF) work();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(228);
const int N = 5000 + 7;
int dp[N][N];
int cnt[N][N];
bitset<N> grab[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, v;
cin >> n >> k >> v;
vector<long long> a(n);
long long s = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
if (v % k == 0) {
if (s < v) {
cout << "NO\n";
return 0;
}
if (s >= v) {
cout << "YES\n";
for (int i = 1; i < n; i++) {
if (a[i] != 0) {
int cnt = a[i] / k + bool(a[i] % k);
cout << cnt << ' ' << i + 1 << ' ' << 1 << '\n';
}
}
if (v / k != 0) {
cout << v / k << ' ' << 1 << ' ' << 2 << '\n';
}
return 0;
}
}
vector<long long> ct(n);
long long ss = 0;
for (int i = 0; i < n; i++) {
ct[i] += (a[i] / k);
ss += a[i] / k * k;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
dp[i][j] = -1e9;
cnt[i][j] = -1e9;
}
}
dp[0][0] = 0;
cnt[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
if (dp[i + 1][j] < dp[i][j] ||
(dp[i + 1][j] == dp[i][j] && cnt[i + 1][j] < cnt[i][j])) {
cnt[i + 1][j] = cnt[i][j];
dp[i + 1][j] = dp[i][j];
grab[i + 1][j] = 0;
}
if (dp[i + 1][(j + a[i]) % k] < dp[i][j] + a[i] % k ||
(dp[i + 1][(j + a[i]) % k] == dp[i][j] &&
cnt[i + 1][(j + a[i]) % k] < cnt[i][j] + 1)) {
cnt[i + 1][(j + a[i]) % k] = cnt[i][j] + 1;
dp[i + 1][(j + a[i]) % k] = dp[i][j] + a[i] % k;
grab[i + 1][(j + a[i]) % k] = 1;
}
}
}
int cur = v % k;
if (cnt[n][cur] <= 0) {
cout << "NO\n";
return 0;
}
int i = n;
int who = -1;
int trash = -1;
vector<bool> ok(n);
while (i) {
if (grab[i][cur]) {
ok[i - 1] = true;
who = i - 1;
if (a[i - 1] % k != 0) {
ct[i - 1]++;
}
cur = (cur - a[i - 1] % k + k) % k;
} else {
trash = i - 1;
}
i--;
}
vector<pair<int, pair<int, int> > > e;
if (trash != -1) {
int was_ss = ss;
int s = 0;
for (int i = 0; i < n; i++) {
if (!ok[i] && a[i] && i != trash) {
ss -= a[i] / k * k;
e.push_back({a[i] / k + bool(a[i] % k), {i + 1, trash + 1}});
ct[i] = 0;
}
if (i == trash) {
ct[i] = 0;
ss -= a[i] / k * k;
}
if (!ok[i]) s += a[i], ct[i] = 0;
}
if (s / k) {
ss += s / k * k;
e.push_back({s / k, {trash + 1, who + 1}});
a[who] += s / k * k;
}
}
cur = v % k;
if (ss + dp[n][cur] < v) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (auto c : e) {
cout << c.first << ' ' << c.second.first << ' ' << c.second.second << '\n';
}
for (int i = 0; i < n; i++) {
if (i != who && ct[i] != 0) {
cout << ct[i] << ' ' << i + 1 << ' ' << who + 1 << '\n';
a[who] += a[i] / k * k;
ct[i] -= a[i] / k;
if (ct[i]) {
a[who] += a[i] % k;
}
}
}
assert(a[who] >= v && (a[who] - v) % k == 0);
s = (a[who] - v) / k;
if (s != 0) {
if (who != 0) {
cout << s << ' ' << who + 1 << ' ' << 1 << '\n';
} else {
cout << s << ' ' << who + 1 << ' ' << 2 << '\n';
}
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long int n,m;
cin >> n >> m;
long long int res = 1e18;
for(int turn = 0; turn <= 1; turn++){
swap(n,m);
res = min(res, (n%3) == 0 ? 0 : m);
for(int j=1;j<=n-1;j++){
long long int mx = j*m, mn = j*m;
mx = max(mx, (n-j)*(m/2 + m%2));
mn = min(mn, (n-j)*(m/2));
res = min(res, mx-mn);
}
}
cout << res;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int p = 1000000007;
long long int modPow(long long int x, long long int n) {
if (n == 0) {
return 1;
}
long long int y = modPow(x, n / 2);
if (n % 2 == 0) {
return (y * y) % p;
} else {
return (((y * y) % p) * x) % p;
}
}
long long int inverse(long long int x) { return modPow(x, p - 2); }
pair<long long int, long long int> Mult(pair<long long int, long long int> x,
pair<long long int, long long int> y) {
return {(((x.first * y.first + 5 * x.second * y.second) % p) + p) % p,
(((x.first * y.second + x.second * y.first) % p) + p) % p};
}
pair<long long int, long long int> Add(pair<long long int, long long int> x,
pair<long long int, long long int> y) {
return {(((x.first + y.first) % p) + p) % p,
(((x.second + y.second) % p) + p) % p};
}
pair<long long int, long long int> pairPow(pair<long long int, long long int> x,
long long int n) {
if (n == 0) {
return {1, 0};
}
pair<long long int, long long int> y = pairPow(x, n / 2);
if (n % 2 == 0) {
return Mult(y, y);
} else {
return Mult(Mult(y, y), x);
}
}
long long int Fib(long long int n) {
return (Mult(Add(pairPow({1, 1}, n), Mult(pairPow({1, -1}, n), {-1, 0})),
{inverse(modPow(2, n)), 0}))
.second;
}
int main() {
long long int k, l, r;
cin >> k >> l >> r;
while (Fib(l + 2) < k) {
l++;
}
if (l > r) {
cout << "0";
return 0;
}
long long int a[k + 1];
for (int i = 0; i <= k; ++i) {
a[i] = 0;
}
a[1] = 1;
for (long long int i = 1; i < k; ++i) {
for (int j = k; j > 0; --j) {
a[j] = a[j - 1] - i * a[j];
a[j] = (a[j] % p + p) % p;
}
}
long long int C[k + 1][k + 1];
for (int i = 0; i <= k; ++i) {
C[0][i] = 0;
}
for (int i = 0; i <= k; ++i) {
C[i][0] = 1;
}
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= k; ++j) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
C[i][j] %= p;
}
}
long long int S1 = 0;
for (long long int j = 0; j <= k; ++j) {
if (j == 0) {
S1 += (((a[j] * (r - l + 1)) % p) + p) % p;
} else {
pair<long long int, long long int> S2 = {0, 0};
for (long long int q = 0; q <= j; ++q) {
if (q * 2 == j && j % 4 == 0) {
long long int k_ = (((r - l + 1) % p) + p) % p;
S2 = Add(S2, Mult(Mult({k_, 0}, Mult(pairPow({0, 1}, j),
{inverse(modPow(5, j)), 0})),
{C[j][q], 0}));
} else {
pair<long long int, long long int> U = {1, 1}, V = {1, -1}, UV;
UV = Mult(pairPow(U, j - q), pairPow(V, q));
pair<long long int, long long int> A, B, C_, D;
A = pairPow(UV, r + 1);
B = Mult(pairPow(UV, l), {modPow(modPow(2, j), r + 1 - l), 0});
B.first = -B.first;
B.second = -B.second;
C_ = Add(Mult(UV, {modPow(modPow(2, j), r + 2), 0}),
{-modPow(modPow(2, j), r + 3), 0});
long long int Q =
(((C_.first * C_.first - 5 * C_.second * C_.second) % p) + p) % p;
C_.second = -C_.second;
D = Mult(Mult(Add(A, B), C_), {inverse(Q), 0});
S2 = Add(S2,
Mult(Mult(Mult(Mult(D, pairPow(UV, 2)), {C[j][q], 0}),
{1 - (q % 2) * 2, 0}),
Mult(pairPow({0, 1}, j), {inverse(modPow(5, j)), 0})));
}
}
S1 = (((S1 + a[j] * S2.first) % p) + p) % p;
}
}
long long int F = 1;
for (long long int i = 1; i <= k; ++i) {
F = (F * i) % p;
}
S1 = (((S1 * inverse(F)) % p) + p) % p;
cout << S1;
}
| 1 |
#include <iostream>
using namespace std;
int main () {
int x, y;
cin >> x >> y;
cout << (0 == x % y ? -1 : x) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 111;
const int MAXT = 111;
int N, T, L, B;
int G[MAXN];
double dp[MAXT][MAXN];
int main() {
while(cin >> N >> T >> L >> B && (N|T|L|B)) {
memset(G, 0, sizeof(G));
for(int i = 0; i < L; ++i) {
int Lose; cin >> Lose;
G[Lose] = 1;
}
for(int i = 0; i < B; ++i) {
int Back; cin >> Back;
G[Back] = 2;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1.0;
for(int i = 0; i < T; ++i) {
for(int j = 0; j <= N; ++j) {
if(j == N) {
dp[i+1][j] += dp[i][j];;
continue;
}
for(int k = 1; k <= 6; ++k) {
int nj = j + k <= N ? j + k : N - (k - (N - j));
int ni = i + 1;
if(G[nj] == 1) ++ni;
else if(G[nj] == 2) nj = 0;
dp[ni][nj] += dp[i][j] / 6.0;
}
}
}
printf("%.10f\n", dp[T][N]);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
int main() {
// your code goes here
lli n,q,i,s=0,b,c;
cin>>n;
lli a[n];
map<lli,lli>mp;
for(i=0;i<n;i++)
{
cin>>a[i];
s=s+a[i];
mp[a[i]]++;
}
cin>>q;
while(q--)
{
cin>>b>>c;
s=s-b*mp[b];
s=s+c*mp[b];
mp[c]=mp[c]+mp[b];
mp[b]=0;
cout<<s<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][2];
int main() {
int n;
cin >> n;
int cur = 0;
dp[0][0] = 1;
dp[0][1] = 0;
for (int i = 0; i <= n; ++i) {
dp[cur ^ 1][0] = (3ll * (dp[cur][1]) % 1000000007) % 1000000007;
dp[cur ^ 1][1] = ((2ll * (dp[cur][1]) % 1000000007) % 1000000007 +
1ll * dp[cur][0] % 1000000007) %
1000000007;
cur ^= 1;
}
cout << dp[cur ^ 1][0];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, s;
int i;
int tmp;
string largest, smallest;
cin >> m >> s;
if (s == 0) {
cout << ((m == 1) ? "0 0" : "-1 -1");
return 0;
}
for (i = 0; i < m; ++i) {
tmp = (s > 9) ? 9 : s;
largest += tmp + '0';
s -= tmp;
}
if (s > 0) {
cout << "-1 -1" << endl;
return 0;
}
for (i = m - 1; i >= 0; --i) {
smallest += largest[i];
}
for (i = 0; smallest[i] == '0'; ++i)
;
++smallest[0];
--smallest[i];
cout << smallest << " " << largest << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int wait = a[0];
int c = n;
for (int i = 1; i < n; ++i) {
if (wait > a[i]) {
c--;
} else {
wait += a[i];
}
}
printf("%d", c);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void test() {
string s;
cin >> s;
int n;
n = s.size();
vector<pair<int, string>> ans;
string cur = "";
vector<pair<int, pair<char, char>>> history;
auto add = [&]() {
if (cur.size() > 10) {
string temp = "";
for (int i = 0; i < 2; ++i) {
temp += cur[i];
}
temp += "...";
for (int i = cur.size() - 5; i < cur.size(); ++i) {
temp += cur[i];
}
ans.emplace_back(cur.size(), temp);
} else {
ans.emplace_back(cur.size(), cur);
}
};
for (int i = n - 1; i >= 0; --i) {
if (cur.size() and s[i] == cur.back() and history.back().first == i + 1 and
s[i] > history.back().second.second) {
cur.pop_back();
history.pop_back();
} else {
pair<char, char> pr;
if (!cur.size()) {
pr = {s[i], 'A'};
} else {
pr = history.back().second;
if (s[i] != history.back().second.first) {
pr = {s[i], history.back().second.first};
}
}
cur += s[i];
history.emplace_back(i, pr);
}
add();
}
reverse(ans.begin(), ans.end());
for (auto &x : ans) {
reverse(x.second.begin(), x.second.end());
cout << x.first << " " << x.second << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 0; i < t; ++i) {
test();
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
int i,a[26],x;
char c;
int main(){
while(std::cin>>c)++a[c-'a'];
for(;i<26;++i)a[i]%2?x=1:0;
std::cout<<(x?"No\n":"Yes\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int X, Y;
cin >> X >> Y;
cout << (max(0, 4-X) + max(0, 4-Y) + max(0, 2-X*Y)*4)*100000 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
cin >> s;
int p = n - 1;
for (int i = 0; i < n - 1; i++) {
if (s[i] > s[i + 1]) {
p = i;
break;
}
}
cout << s.substr(0, p) + s.substr(p + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int a, b;
cin >> a >> b;
long long int c[a], d[b], i;
for (i = 0; i < a; i++) cin >> c[i];
for (i = 0; i < b; i++) {
cin >> d[i];
}
for (i = 0; i < a; i++) {
for (auto j = 0; j < b; j++)
if (d[j] == c[i]) cout << c[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int t;
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 202;
int n;
set<int> a[N];
int ans[N];
set<int> s[N];
void solv() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) a[i].clear();
for (int i = 1; i < n; ++i) {
int q;
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
a[i].insert(x);
}
}
for (int p1 = 1; p1 <= n; ++p1) {
for (int i = 1; i < n; ++i) s[i] = a[i];
bool z = true;
int u = p1;
for (int i = 1; i <= n; ++i) {
ans[i] = u;
for (int j = 1; j < n; ++j) {
if (s[j].find(u) != s[j].end()) s[j].erase(u);
}
if (i == n) {
for (int j = 1; j < n; ++j) {
if (!s[j].empty()) z = false;
}
break;
}
for (int j = 1; j < n; ++j) {
if (s[j].size() == 1) {
u = *s[j].begin();
if (i + 1 - (int)a[j].size() < 0) {
z = false;
break;
}
set<int> t;
for (int k = i + 1 - (int)a[j].size() + 1; k <= i; ++k)
t.insert(ans[k]);
t.insert(u);
if (t != a[j]) {
z = false;
break;
}
break;
}
}
if (!z) break;
}
if (z) {
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return;
}
}
}
int main() {
int tt;
scanf("%d", &tt);
while (tt--) solv();
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int N=3005;
LL n,mo,fac[N],inv[N],c[N][N],g[N][N];
LL qpow(LL x,LL k,LL p)
{
LL ret=1;
while(k){
if(k&1) ret*=x,ret%=p;
x*=x,x%=p;k>>=1;
}
return ret;
}
int main()
{
cin>>n>>mo;
fac[0]=1;
for(int i=1;i<=n+1;i++) fac[i]=(fac[i-1]*i)%mo;
inv[n+1]=qpow(fac[n+1],mo-2,mo);
for(int i=n;i>=0;i--) inv[i]=(inv[i+1]*(i+1))%mo;
c[0][0]=1;
for(int i=1;i<=n;i++){
c[i][0]=1;
for(int j=1;j<=i;j++)
c[i][j]=(c[i-1][j-1]+c[i-1][j])%mo;
}
for(int i=0;i<=n;i++){
g[i][0]=1;
for(int j=1;j<=i;j++){
g[i][j]=(g[i-1][j-1]+g[i-1][j]*(j+1))%mo;
}
}
LL ans=0;
for(int i=0;i<=n;i++){
LL x=0,f=0,k=1,y=0;
x=qpow(2,qpow(2,n-i,mo-1),mo);
y=qpow(2,n-i,mo);
for(int j=0;j<=i;j++){
f=(f+(g[i][j]*k)%mo)%mo;
// cout<<f<<' ';
(k*=y)%=mo;
}
LL ret=c[n][i]*x%mo*f%mo;
// cout<<i<<' '<<ret<<' '<<f<<' '<<x<<' '<<c[n][i]<<endl;
if(i&1) ans=(ans-ret+mo)%mo;
else ans=(ans+ret)%mo;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int oo = 0x3f3f3f3f;
inline long long read() {
char ch = getchar();
int x = 0, f = 1;
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long N, M, a[MAXN], b[MAXN], leftt, rightt, mid, ans, cnt, st, nd;
bool vis[MAXN];
namespace solution {
void init() {
N = read();
M = read();
for (int i = 1; i <= N; i++) a[i] = read();
for (int i = 1; i <= M; i++) b[i] = read();
sort(a + 1, a + N + 1);
sort(b + 1, b + M + 1);
}
bool check(long long length) {
int t = 1;
for (int i = 1; i <= M; i++) {
st = b[i] - length;
nd = b[i] + length;
while (t <= N && a[t] >= st && a[t] <= nd) t++;
}
return t > N;
}
void slove() {
leftt = 0;
rightt = 2000000000;
while (leftt + 1 < rightt) {
mid = (leftt + rightt) >> 1;
if (check(mid))
rightt = mid;
else
leftt = mid;
}
if (check(leftt))
ans = leftt;
else
ans = rightt;
}
void output() { cout << ans << endl; }
} // namespace solution
int main() {
using namespace solution;
init();
slove();
output();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char ch[200020];
int k, ans;
int main() {
scanf("%s%d", ch + 1, &k);
int len = strlen(ch + 1);
int now, cnt = 0, num = 0;
for (int i = 1; i <= len; i++) {
if (ch[i] == '0') num++;
}
if (num == 1 && len == 1) {
printf("0\n");
return 0;
} else if (num < k && num) {
printf("%d\n", len - 1);
return 0;
}
for (now = len; now; now--) {
if (ch[now] == '0')
cnt++;
else
ans++;
if (cnt >= k) break;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ans, n, m, t1, d, i, x, j, mx, now, cnt[1200001], f[1200001], v[1200001],
mp[1200001];
int main() {
scanf("%d%d%d", &n, &m, &d);
for (i = 0; i < m; i++) {
scanf("%d", &t1);
while (t1--) {
scanf("%d", &x);
v[x] = i;
}
}
mx = (1 << m) - 1;
for (i = 1; i <= n; i++) {
if (!mp[v[i]]) now ^= 1 << v[i];
mp[v[i]]++;
if (i > d) {
mp[v[i - d]]--;
if (!mp[v[i - d]]) now ^= 1 << v[i - d];
}
if (i >= d) f[mx ^ now] = 1;
}
ans = m;
for (i = 1; i <= mx; i++) cnt[i] = cnt[i >> 1] + (i & 1);
for (i = mx; i; i--) {
for (j = 0; j < m; j++) f[i] |= f[i | (1 << j)];
if (!f[i]) ans = min(ans, cnt[i]);
}
printf("%d", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l;
cin >> c >> v0 >> v1 >> a >> l;
int cpag = v0;
int add = v0;
int ans = 1;
while (cpag < c) {
add = min(v1, add + a);
cpag += add - l;
ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char t[77];
int cnt[26];
int z[10010];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", t);
++cnt[t[0] - 'A'];
}
int l = 0, r = 10010;
while (r - l > 1) {
int s = (l + r) / 2;
int pos = 0;
memset(z, 0, sizeof z);
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < s && j < cnt[i]; ++j) {
++z[pos];
pos = (pos + 1) % s;
}
}
bool ok = true;
for (int i = 0; i < s; ++i) {
if (z[i] < k) {
ok = false;
}
}
if (ok) {
l = s;
} else {
r = s;
}
}
printf("%d\n", l);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int sizeA, sizeB, aux, cont = 0;
bool ok = true;
cin >> sizeA;
vector<long long> a, b;
for (int i = 0; i < sizeA; i++) {
cin >> aux;
a.push_back(aux);
}
cin >> sizeB;
for (int i = 0; i < sizeB; i++) {
cin >> aux;
b.push_back(aux);
}
for (int i = 0, j = 0; i < a.size() || j < b.size(); i++, j++, cont++) {
while (a[i] != b[j]) {
while (a[i] < b[j]) {
if (i < a.size() - 1) {
a[i + 1] += a[i];
i++;
} else {
ok = false;
break;
}
}
if (!ok) break;
while (a[i] > b[j]) {
if (j < b.size() - 1) {
b[j + 1] += b[j];
j++;
} else {
ok = false;
break;
}
}
if (!ok) break;
}
if (!ok) break;
}
if (ok && a[sizeA - 1] == b[sizeB - 1]) {
cout << cont << endl;
} else {
cout << "-1" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using iii = int;
using yeee = iii;
const iii DEBUG = -1;
using namespace std;
using namespace chrono;
template <typename T1>
void DOUTf(ostringstream &os, int names_i, vector<string> &names, T1 &&val) {
os << names[names_i] << " = " << val;
}
template <typename T1, typename... Ts>
void DOUTf(ostringstream &os, int names_i, vector<string> &names, T1 &&val,
Ts &&...vals) {
os << names[names_i] << " = " << val << " | ";
DOUTf(os, names_i + 1, names, vals...);
}
template <typename... Ts>
string DOUTg(string names, Ts &&...vals) {
string special = "()[]{}<>'\"\\";
vector<string> vnames;
vnames.push_back("");
vector<char> stak;
for (char c : names) {
bool inside_string =
!stak.empty() && (stak.back() == '\'' || stak.back() == '\"');
if (c == '\n') c = ' ';
if (c == ' ' && (vnames.back().empty() ||
(!inside_string && vnames.back().back() == ' ')))
continue;
if (stak.empty() && c == ',') {
if (!vnames.back().empty() && vnames.back().back() == ' ')
vnames.back().pop_back();
vnames.push_back("");
continue;
}
vnames.back().push_back(c);
if (!stak.empty() && stak.back() == '\\') {
stak.pop_back();
continue;
}
size_t p = special.find(c);
bool closing = p < 8 && p % 2;
if (p == string::npos) continue;
if (p == special.size() - 1) {
stak.push_back(c);
continue;
}
if (stak.empty()) {
if (!closing) stak.push_back(c);
continue;
}
if (inside_string) {
if (c == stak.back()) stak.pop_back();
continue;
}
if (closing) {
if (stak.back() == special[p - 1]) stak.pop_back();
continue;
}
stak.push_back(c);
}
ostringstream os;
DOUTf(os, 0, vnames, vals...);
return os.str();
}
template <template <typename...> class Container, typename T, size_t DIMENSION>
struct MultiDimensional {
using internal = MultiDimensional<Container, T, DIMENSION - 1>;
using type = Container<typename internal::type>;
template <typename... Args>
static type Generate(T def, const size_t size, Args... sizes) {
return type(size, internal::Generate(def, sizes...));
}
};
template <template <typename...> class Container, typename T>
struct MultiDimensional<Container, T, 1> {
using internal = T;
using type = Container<T>;
static type Generate(T def, const size_t size) { return type(size, def); }
};
template <typename T, typename... Args>
auto make_vector(T def, Args... sizes) ->
typename MultiDimensional<std::vector, T, sizeof...(sizes)>::type {
return MultiDimensional<std::vector, T, sizeof...(sizes)>::Generate(def,
sizes...);
}
template <typename T>
T get() {
T x;
cin >> x;
return x;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &cont) {
out << "(" << cont.first << ", " << cont.second << ")";
return out;
}
template <typename T, typename Alloc>
ostream &operator<<(ostream &out, const vector<T, Alloc> &cont) {
for (auto it = cont.begin(); it != cont.end(); ++it)
out << (it == cont.begin() ? "" : " ") << *it;
return out;
}
template <typename T, typename Alloc>
ostream &operator<<(ostream &out, const deque<T, Alloc> &cont) {
for (auto it = cont.begin(); it != cont.end(); ++it)
out << (it == cont.begin() ? "" : " ") << *it;
return out;
}
template <typename T, typename Compare, typename Alloc>
ostream &operator<<(ostream &out, const set<T, Compare, Alloc> &cont) {
out << "{";
for (auto it = cont.begin(); it != cont.end(); ++it)
out << (it == cont.begin() ? "" : ", ") << *it;
out << "}";
return out;
}
template <typename T, typename Compare, typename Alloc>
ostream &operator<<(ostream &out, const multiset<T, Compare, Alloc> &cont) {
out << "{";
for (auto it = cont.begin(); it != cont.end(); ++it)
out << (it == cont.begin() ? "" : ", ") << *it;
out << "}";
return out;
}
template <typename Key, typename T, typename Compare, typename Alloc>
ostream &operator<<(ostream &out, const map<Key, T, Compare, Alloc> &cont) {
out << "{";
for (auto it = cont.begin(); it != cont.end(); ++it)
out << (it == cont.begin() ? "" : ", ") << it->first << ":" << it->second;
out << "}";
return out;
}
template <typename Key, typename T, typename Compare, typename Alloc>
ostream &operator<<(ostream &out,
const multimap<Key, T, Compare, Alloc> &cont) {
out << "{";
for (auto it = cont.begin(); it != cont.end(); ++it)
out << (it == cont.begin() ? "" : ", ") << it->first << ":" << it->second;
out << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> cont) {
for (auto it = cont.begin(); it != cont.end(); ++it) out << *it << "\n";
return out;
}
using ll = long long;
using lll = long long;
using ull = unsigned long long;
using ld = long double;
using pll = pair<ll, ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vpll = vector<pll>;
using point = complex<ll>;
ld get_time() {
return ld(duration_cast<nanoseconds>(
high_resolution_clock::now().time_since_epoch())
.count()) /
1e9;
}
ll sign(ld x) { return (x > 0) - (x < 0); }
ll fmod(ll x, ll mod) {
if (!mod) return x;
if (abs(x) >= mod) x %= mod;
if (x < 0) x += mod;
return x;
}
ll pow(ll x, ll exp, ll mod) {
ll res = 1, y = x;
while (exp) {
if (!mod) {
if (exp & 1) res = res * y;
y = y * y;
} else {
if (exp & 1) res = fmod(res * y, mod);
y = fmod(y * y, mod);
}
exp >>= 1;
}
return res;
}
ld START_TIME = get_time();
mt19937_64 rand_mt64(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rand_mt(chrono::steady_clock::now().time_since_epoch().count());
const long long INFll = ll(1.1e18) - 1;
const int INFi = ll(1.1e9) - 1;
ll INF = sizeof(ll) == sizeof(int) ? ll(INFi) : ll(INFll);
char newl = '\n';
void main_init(bool fast_cio = true, string input_file = "",
string output_file = "", pair<int, int> file_mask = {1, 1}) {
srand(unsigned(time(0)));
if (fast_cio) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
if (input_file != "" && file_mask.first & (1 << (DEBUG < 0)))
freopen(input_file.c_str(), "r", stdin);
if (output_file != "" && file_mask.second & (1 << (DEBUG < 0)))
freopen(output_file.c_str(), "w", stdout);
}
vll dfs(ll curr, ll prev, vvll &E) {
bool leaf = true;
bool zero = true;
vll res = {0, 0, 0, 0};
for (ll nex : E[curr]) {
if (nex == prev) continue;
vll r = dfs(nex, curr, E);
res[0] |= r[1];
res[1] |= r[0];
res[2] += r[2] + 1 - r[3];
if (zero && r[3]) {
res[2]++;
zero = false;
}
leaf = false;
}
if (leaf) {
res[0] = 1;
res[3] = 1;
}
return res;
}
yeee main() {
main_init();
ll N;
cin >> N;
vvll E(N);
for (ll i = ll(0); i < ll(N - 1); ++i) {
ll a, b;
cin >> a >> b;
--a, --b;
E[a].push_back(b);
E[b].push_back(a);
}
vll res = {0, 1, 1, 0};
for (ll i = ll(0); i < ll(N); ++i) {
if (ll((E[i]).size()) > 1) {
res = dfs(i, -1, E);
break;
}
}
cout << (res[0] && res[1] ? 3 : 1) << " " << res[2] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[1LL << 19][2];
vector<string> s(5);
int a11[] = {3, 4, 5, 4, 3};
int a[5][5];
bool check(int mask, int x) {
x = mask | x;
if (mask == x) {
return true;
}
return false;
}
int f(int mask, int flag) {
int &result = dp[mask][flag];
;
if (result != -1) {
return result;
}
int i, j, k;
for (i = (0); i < (5); ++i) {
for (j = (0); j < (s[i].size()); ++j) {
int xx = mask;
for (k = (j); k < (s[i].size()); ++k) {
if (s[i][k] == '.' || check(mask, a[i][k])) {
break;
}
xx = xx | a[i][k];
result = f(xx, (flag + 1) % 2);
if (result == flag) {
return result;
}
}
}
}
for (i = (0); i < (5); ++i) {
for (j = (0); j < (a11[i]); ++j) {
int sx = i;
int sy = j;
int xx = mask;
while (1) {
if (sx == 5) {
break;
}
if (s[sx][sy] == '.' || check(mask, a[sx][sy])) {
break;
}
xx = xx | a[sx][sy];
result = f(xx, (flag + 1) % 2);
if (result == flag) {
return result;
}
sx++;
if (sx < 3) {
sy++;
}
}
}
}
for (i = (0); i < (5); ++i) {
for (j = (0); j < (a11[i]); ++j) {
int sx = i;
int sy = j;
int xx = mask;
while (1) {
if (sx == 5 || sy < 0) {
break;
}
if (s[sx][sy] == '.' || check(mask, a[sx][sy])) {
break;
}
xx = xx | a[sx][sy];
result = f(xx, (flag + 1) % 2);
if (result == flag) {
return result;
}
sx++;
if (sx >= 3) {
sy--;
}
}
}
}
result = (flag + 1) % 2;
return result;
}
string get(string s) {
string b("");
int i;
for (i = 0; i < s.size(); i++) {
if (s[i] == 'O' || s[i] == '.') {
b = b + s[i];
}
}
return b;
}
int main() {
int i, j;
memset(dp, -1, sizeof(dp));
for (i = (0); i < (5); ++i) {
getline(cin, s[i]);
s[i] = get(s[i]);
}
int x = 0;
for (i = (0); i < (5); ++i) {
for (j = (0); j < (a11[i]); ++j) {
a[i][j] = 1LL << x;
x++;
}
}
x = f(0, 0);
if (x == 0) {
cout << "Karlsson" << endl;
} else {
cout << "Lillebror" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ma, mi;
int valMax = 0;
int valMin = 0;
int aux1, aux2;
int swap;
while (cin >> n >> m) {
if (m == 0) {
cout << n - 1;
} else {
valMax = n;
valMin = 0;
for (int i = 0; i < m; i++) {
cin >> aux1;
cin >> aux2;
if (aux1 < aux2) {
swap = aux1;
aux1 = aux2;
aux2 = swap;
}
if (valMax > aux1) {
valMax = aux1;
}
if (valMin < aux2) {
valMin = aux2;
}
}
int res = valMax - valMin;
if (res < 0) {
cout << 0;
} else {
cout << res;
}
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int N;
int fid[3][100010];
int rev[100010];
int id[100010];
int bit[300010][2];
int mem[100010];
int res[100010];
void init()
{
for(int i = 0; i <= N; i++)bit[i][0] = bit[i][1] = 0;
return;
}
void add(int i,int k)//x = 1
{
while(i <= N)
{
bit[i][k]++;
i += i & -i;
}
return;
}
int sum(int i,int k)
{
int res = 0;
while(i > 0)
{
res += bit[i][k];
i -= i & -i;
}
return res;
}
int main()
{
scanf("%d",&N);
for(int i = 0; i < 3; i++)for(int j = 1; j <= N; j++)scanf("%d",&fid[i][j]);
for(int i = 1; i <= N; i++)
{
if(fid[0][i] + 1 == fid[1][i] && fid[1][i] + 1 == fid[2][i] && fid[2][i] / 3 % 2 == i % 2)
{
rev[i] = 0;
id[i] = fid[2][i] / 3;
}
else if(fid[2][i] + 1 == fid[1][i] && fid[1][i] + 1 == fid[0][i] && fid[0][i] / 3 % 2 == i % 2)
{
rev[i] = 1;
id[i] = fid[0][i] / 3;
}
else
{
printf("No\n");
return 0;
}
}
init();
for(int i = 1; i <= N; i++)
{
mem[i] = (i - 1) / 2 - sum(id[i],i % 2);
add(id[i],i % 2);
}
for(int i = 1; i <= N; i++)
{
res[i] = mem[i - 1] + mem[i] + mem[i + 1];
}
int cnto1 = 0,cnto2 = 0,cnte1 = 0,cnte2 = 0;
for(int i = 1; i <= N; i++)
{
if(i % 2)
{
cnto1 += mem[i];
cnto2 += rev[i];
}
else
{
cnte1 += mem[i];
cnte2 += rev[i];
}
}
if(!(cnto1 % 2 ^ cnte2 % 2) && !(cnto2 % 2 ^ cnte1 % 2))printf("Yes\n");
else printf("No\n");
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.