solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 7;
const int INF = 0x3f3f3f3f;
struct node {
int to, c, next;
} e[MAX];
int cnt = 0;
int head[MAX];
int x[MAX], y[MAX];
int dis[MAX], vis[MAX];
bool judge[MAX];
void add(int x, int y, int z) {
e[cnt] = {y, z, head[x]};
head[x] = cnt++;
}
int n, m;
int t[MAX];
void dfs(int x) {
vis[x] = 1;
if (x == n) {
judge[x] = 1;
return;
}
for (int i = head[x]; i != -1; i = e[i].next) {
if (e[i].c == 2) {
if (!vis[e[i].to]) dfs(e[i].to);
if (judge[e[i].to]) judge[x] = 1;
}
}
}
void spfa() {
queue<int> q;
memset(vis, 0, sizeof vis);
memset(dis, INF, sizeof dis);
memset(t, 0, sizeof t);
vis[1] = 1;
dis[1] = 0;
q.push(1);
t[1]++;
while (!q.empty()) {
int u = q.front();
vis[u] = 0;
q.pop();
for (int i = head[u]; i != -1; i = e[i].next) {
int to = e[i].to;
int c = e[i].c;
if (!judge[to]) continue;
if (dis[to] > dis[u] + c) {
dis[to] = dis[u] + c;
if (!vis[to]) {
vis[to] = 1;
q.push(to);
t[to]++;
if (t[to] >= n) {
puts("No");
return;
}
}
}
}
}
puts("Yes");
for (int i = 1; i <= m; i++) {
if (dis[y[i]] - dis[x[i]] == 1)
puts("1");
else
puts("2");
}
}
int main() {
memset(head, -1, sizeof head);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
add(y[i], x[i], -1), add(x[i], y[i], 2);
}
dfs(1);
spfa();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INTMAX = numeric_limits<int>::max();
const long long LLMAX = numeric_limits<long long>::max();
void writeln() { cout << "\n"; }
template <class T>
inline void print(T&& a);
template <class T>
inline void priws(T&& a);
template <class T>
inline void read(T& a);
template <class... Args>
inline void readln(Args&... args) {
(read(args), ...);
}
template <class H, class... T>
inline void writeln(H&& h, T&&... t) {
priws(h);
(print(t), ...);
writeln();
}
template <class T>
inline void writeln_range(T f, T s) {
if (f != s)
for (auto i = f; i != s; ++i) writeln(*i);
}
vector<string> split(string& s, string d) {
vector<string> v;
size_t p = 0;
while ((p = s.find(d)) != string::npos)
v.push_back(s.substr(0, p)), s.erase(0, p + d.length());
v.push_back(s);
return v;
}
template <class... Args>
inline void err(string v, Args... args) {
auto vv = split(v, ", ");
auto it = vv.begin();
(writeln(*it++, "=", args), ...);
}
vector<tuple<int, int, int, int>> ans;
vector<vector<string>> s, t;
int n, m;
void move(int i, int j, int u, int v, char c = '$') {
if (c != '$') s[u][v].push_back(c);
++i;
++j;
++u;
++v;
if ((i == 1 && v == m) || (i == n && v == 1)) {
if (j != v) ans.emplace_back(i, j, i, v);
if (i != u) ans.emplace_back(i, v, u, v);
} else {
if (i != u) ans.emplace_back(i, j, u, j);
if (j != v) ans.emplace_back(u, j, u, v);
}
}
void lul(vector<vector<string>>& ss) {
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j)
printf("%5s%c", ss[i][j].c_str(), " \n"[j == m - 1]);
printf("\n");
}
void run() {
auto moveCase = [&](int i, int j, char c) {
if (c == '0')
move(i, j, 0, 0, c);
else
move(i, j, (n - 1), (m - 1), c);
};
auto moveCaseStr = [&](int i, int j) {
for (char& c : s[i][j]) moveCase(i, j, c);
s[i][j] = "";
};
auto getCase = [&](int i, int j, char c) {
if (c == '0')
move(0, 0, i, j);
else
move((n - 1), (m - 1), i, j);
};
auto getCaseStr = [&](int i, int j) {
for (char& c : t[i][j]) getCase(i, j, c);
};
readln(n, m);
s.resize(n, vector<string>(m));
t.resize(n, vector<string>(m));
readln(s, t);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j)
reverse(begin(s[i][j]), end(s[i][j])),
reverse(begin(t[i][j]), end(t[i][j]));
for (char c : s[0][0]) move(0, 0, 0, (m - 1), c);
for (char c : s[n - 1][m - 1]) move((n - 1), (m - 1), (n - 1), 0, c);
s[0][0] = "";
s[n - 1][m - 1] = "";
moveCaseStr(0, (m - 1));
moveCaseStr((n - 1), 0);
for (int i = 1; i < (int)(n - 1); ++i)
moveCaseStr(i, 0), moveCaseStr(i, m - 1);
for (int j = 1; j < (int)(m - 1); ++j)
moveCaseStr(0, j), moveCaseStr(n - 1, j);
for (int i = 1; i < (int)(n - 1); ++i)
for (int j = 1; j < (int)(m - 1); ++j) moveCaseStr(i, j);
for (int i = 1; i < (int)(n - 1); ++i)
for (int j = 1; j < (int)(m - 1); ++j) getCaseStr(i, j);
for (int j = 1; j < (int)(m - 1); ++j) getCaseStr(0, j), getCaseStr(n - 1, j);
for (int i = 1; i < (int)(n - 1); ++i) getCaseStr(i, 0), getCaseStr(i, m - 1);
for (char& c : t[0][0]) getCase(0, (m - 1), c);
for (char& c : t[n - 1][m - 1]) getCase((n - 1), 0, c);
getCaseStr(0, (m - 1));
getCaseStr((n - 1), 0);
for (char& c : t[0][0]) move(0, (m - 1), 0, 0);
for (char& c : t[n - 1][m - 1]) move((n - 1), 0, (n - 1), (m - 1));
printf("%zu\n", ans.size());
for (auto& [x, y, z, u] : ans) printf("%d %d %d %d\n", x, y, z, u);
}
int main() {
ios_base::sync_with_stdio(false);
run();
return 0;
}
template <class T>
inline ostream& operator<<(ostream& os, vector<T>& _a);
template <class T1, class T2>
inline istream& operator>>(istream& is, pair<T1, T2>& _a) {
return is >> _a.first >> _a.second;
}
template <class T1, class T2>
inline ostream& operator<<(ostream& os, pair<T1, T2>& _a) {
return os << _a.first << " " << _a.second;
}
template <class T>
inline ostream& operator<<(ostream& os, vector<T>& _a) {
if (_a.size())
os << _a[0];
else
os << "\n";
for (int i = 1; i < (int)(_a.size()); ++i)
os << "\n "[is_fundamental<T>::value] << _a[i];
return os;
}
template <class T>
inline ostream& operator<<(ostream& os, valarray<T>& _a) {
if (_a.size())
os << _a[0];
else
os << "\n";
for (int i = 1; i < (int)(_a.size()); ++i)
os << "\n "[is_fundamental<T>::value] << _a[i];
return os;
}
template <class T>
inline istream& operator>>(istream& is, vector<T>& _a) {
for (int i = 0; i < (int)(_a.size()); ++i) is >> _a[i];
return is;
}
template <class T>
inline istream& operator>>(istream& is, valarray<T>& _a) {
for (int i = 0; i < (int)(_a.size()); ++i) is >> _a[i];
return is;
}
template <class T>
inline void print(T&& _a) {
cout << " " << _a;
}
template <class T>
inline void priws(T&& _a) {
cout << _a;
}
template <class T>
inline void read(T& _a) {
cin >> _a;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, M[128][128];
vector<vector<int> > dist[128][128];
vector<vector<pair<int, int> > > paidist[128][128];
short int terminal[128][128];
pair<int, int> S[12];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int PD[(1 << 7)][101][101][2];
bool split[(1 << 7)][101][101][2];
pair<pair<int, int>, pair<int, int> > pai[(1 << 7)][101][101][2];
char R[128][128];
inline void imprime() {
for (int i = 0; i < n; i++) printf("%s\n", R[i]);
}
void pinta_caminho(int i1, int j1, int i2, int j2) {
if (i1 == i2 and j1 == j2) {
R[i1][j1] = 'X';
return;
}
pair<int, int> p = paidist[i1][j1][i2][j2];
if (p.first == i1 and p.second == j1) {
R[i1][j1] = 'X';
R[i2][j2] = 'X';
return;
}
pinta_caminho(i1, j1, p.first, p.second);
pinta_caminho(p.first, p.second, i2, j2);
}
void pinta_arvore(int bm, int i, int j, int pfolha) {
if (bm == 0) {
R[i][j] = 'X';
return;
}
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
pinta_caminho(S[t].first, S[t].second, i, j);
return;
}
pair<pair<int, int>, pair<int, int> > u = pai[bm][i][j][pfolha];
int nbm = u.first.first, npfolha = u.first.second;
int ni = u.second.first, nj = u.second.second;
if (split[bm][i][j][pfolha]) {
pinta_arvore(nbm, i, j, npfolha);
pinta_arvore(bm ^ nbm, i, j, npfolha);
return;
}
pinta_caminho(i, j, ni, nj);
pinta_arvore(nbm, ni, nj, npfolha);
}
int calc(int bm, int i, int j, int pfolha) {
if (bm == 0) return M[i][j];
int &pd = PD[bm][i][j][pfolha];
pair<pair<int, int>, pair<int, int> > &papai = pai[bm][i][j][pfolha];
bool &sp = split[bm][i][j][pfolha];
if (pd != -1) return pd;
if (__builtin_popcount(bm) == 1) {
int t = __builtin_ctz(bm);
return pd = dist[S[t].first][S[t].second][i][j];
}
int best = 0x3f3f3f3f;
int x = (bm - 1) & bm;
while (x) {
int t1 = calc(x, i, j, 1);
int t2 = calc(bm ^ x, i, j, 1);
int opc = t1 + t2 - M[i][j];
if (opc < best) {
best = opc;
papai = pair<pair<int, int>, pair<int, int> >(pair<int, int>(x, 1),
pair<int, int>(i, j));
sp = true;
}
x = (x - 1) & bm;
}
if (pfolha) {
for (int k = 0; k < s; k++)
if (bm & (1 << k)) {
int opc = dist[i][j][S[k].first][S[k].second] +
calc(bm ^ (1 << k), S[k].first, S[k].second, 1) -
M[S[k].first][S[k].second];
if (opc < best) {
best = opc;
sp = false;
papai = pair<pair<int, int>, pair<int, int> >(
pair<int, int>(bm ^ (1 << k), 1),
pair<int, int>(S[k].first, S[k].second));
}
}
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
if ((k != i or l != j) and terminal[k][l] < 0) {
int opc = dist[i][j][k][l] + calc(bm, k, l, 0) - M[k][l];
if (opc < best) {
best = opc;
sp = false;
papai = pair<pair<int, int>, pair<int, int> >(pair<int, int>(bm, 0),
pair<int, int>(k, l));
}
}
}
return pd = best;
}
int main() {
scanf("%d %d %d", &n, &m, &s);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
R[i][j] = '.';
dist[i][j].resize(n);
paidist[i][j].resize(n);
for (int k = 0; k < n; k++) {
dist[i][j][k].resize(m);
paidist[i][j][k].resize(m);
for (int l = 0; l < m; l++) dist[i][j][k][l] = 0x3f3f3f3f;
}
}
R[i][m] = '\0';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &M[i][j]);
dist[i][j][i][j] = M[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++) {
int ni = i + dx[k];
int nj = j + dy[k];
if (!(0 <= ni and ni < n and 0 <= nj and nj < m)) continue;
dist[i][j][ni][nj] = M[i][j] + M[ni][nj];
paidist[i][j][ni][nj] = pair<int, int>(i, j);
}
for (int k1 = 0; k1 < n; k1++)
for (int k2 = 0; k2 < m; k2++)
for (int i1 = 0; i1 < n; i1++)
for (int i2 = 0; i2 < m; i2++)
for (int j1 = 0; j1 < n; j1++)
for (int j2 = 0; j2 < m; j2++) {
int opc = dist[i1][i2][k1][k2] + dist[k1][k2][j1][j2] - M[k1][k2];
if (opc < dist[i1][i2][j1][j2]) {
dist[i1][i2][j1][j2] = opc;
paidist[i1][i2][j1][j2] = pair<int, int>(k1, k2);
}
}
memset(terminal, 0xff, sizeof(terminal));
for (int i = 0; i < s; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
terminal[a][b] = i;
S[i] = pair<int, int>(a, b);
}
if (s == 1) {
printf("%d\n", M[S[0].first][S[0].second]);
R[S[0].first][S[0].second] = 'X';
imprime();
return 0;
}
if (s == 2) {
printf("%d\n", dist[S[0].first][S[0].second][S[1].first][S[1].second]);
pinta_caminho(S[0].first, S[0].second, S[1].first, S[1].second);
imprime();
return 0;
}
memset(PD, 0xff, sizeof(PD));
int resp = calc((1 << s) - 1 - 1, S[0].first, S[0].second, 1);
int bm = (1 << s) - 1 - 1, i = S[0].first, j = S[0].second, pf = 1;
pinta_arvore(bm, i, j, pf);
printf("%d\n", resp);
imprime();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int t, n, son[maxn], root, p[maxn], rt;
vector<int> g[maxn];
void dfs(int u, int fa) {
son[u] = 1;
p[u] = fa;
for (auto it : g[u]) {
if (it == fa) continue;
dfs(it, u);
son[u] += son[it];
}
}
void getroot(int u, int fa) {
root = u;
for (auto it : g[u]) {
if (it == fa) continue;
if (son[it] > n - son[it]) getroot(it, u);
}
}
int getleaf(int u, int fa) {
if (g[u].size() == 1) return u;
for (auto it : g[u]) {
if (it == fa) continue;
return getleaf(it, u);
}
}
int main() {
scanf("%d", &t);
while (t--) {
root = rt = 0;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
getroot(1, 0);
for (auto it : g[root]) {
if (it != p[root] && son[it] == n - son[it]) rt = it;
}
if (!rt) {
printf("%d %d\n%d %d\n", root, g[root][0], root, g[root][0]);
} else {
int l = getleaf(rt, p[rt]);
printf("%d %d\n%d %d\n", p[l], l, root, l);
}
for (int i = 1; i <= n; i++) g[i].clear(), p[i] = 0;
}
return 0;
}
| 9 | CPP |
#include <iostream>
using namespace std;
#define ll long long
const int N = 1e5+507;
ll n,i,sum,q,b,c,a[N],f[N];
int main ()
{
cin>>n;
for (i=1;i<=n;++i)
cin>>a[i],f[a[i]]++,sum+=a[i];
cin>>q;
for (i=1;i<=q;++i)
{
cin>>b>>c;
sum-=f[b]*b;
sum+=f[b]*c;
f[c]+=f[b];
f[b]=0;
cout<<sum<<"\n";
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
// debug & operator << (debug & dd, P p) { dd << "(" << p.x << ", " << p.y << ")"; return dd; }
const int nax = 505;
#define right right_compile
#define left left_compile
int up[nax][nax], down[nax][nax], right[nax][nax], left[nax][nax];
int dp[12][nax][nax];
const int INF = 1e9 + 5;
void mini(int& a, int b) {
a = min(a, b);
}
int main() {
int h, w, k;
scanf("%d%d%d", &h, &w, &k);
const bool BAD = k % 2;
k /= 2;
for(int row = 0; row < h; ++row) {
for(int col = 0; col < w - 1; ++col) {
scanf("%d", &right[row][col]);
left[row][col+1] = right[row][col];
}
}
for(int row = 0; row < h - 1; ++row) {
for(int col = 0; col < w; ++col) {
scanf("%d", &down[row][col]);
up[row+1][col] = down[row][col];
}
}
for(int i = 0; i <= k; ++i) {
for(int row = 0; row < h; ++row) {
for(int col = 0; col < w; ++col) {
dp[i][row][col] = INF;
}
}
}
for(int row = 0; row < h; ++row) {
for(int col = 0; col < w; ++col) {
if(BAD) {
printf("-1 ");
continue;
}
dp[0][row][col] = 0;
for(int steps = 0; steps < k; ++steps) {
for(int r = max(0, row - steps); r <= min(h - 1, row + steps); ++r) {
for(int c = max(0, col - steps); c <= min(w - 1, col + steps); ++c) {
const int me = dp[steps][r][c];
if(me == INF) {
continue;
}
if(r != 0) {
mini(dp[steps+1][r-1][c], me + up[r][c]);
}
if(c != 0) {
mini(dp[steps+1][r][c-1], me + left[r][c]);
}
mini(dp[steps+1][r+1][c], me + down[r][c]);
mini(dp[steps+1][r][c+1], me + right[r][c]);
dp[steps][r][c] = INF;
}
}
}
int answer = INF;
int steps = k;
for(int r = max(0, row - steps); r <= min(h - 1, row + steps); ++r) {
for(int c = max(0, col - steps); c <= min(w - 1, col + steps); ++c) {
mini(answer, 2 * dp[steps][r][c]);
dp[steps][r][c] = INF;
}
}
printf("%d ", answer);
// for(int r = -k; r <= k; ++r) {
// for(int c = -k; c <= k; ++c) {
// if(inside(row + r, col + c)) {
// }
// else {
// }
// }
// }
}
puts("");
}
}
| 10 | CPP |
for _ in range(int(input())) :
n = int(input())
k = int(n/4)
s = '9'*(n-1-k) + '8'*(k+1)
if n% 4 == 0 : print(int('9'*(n-k) + '8'*(k)))
else : print(int(s))
| 8 | PYTHON3 |
def retrieve_bills(amount):
count = 0
while(amount != 0):
if(amount >= 100):
quotient = amount // 100
count += quotient
amount = amount - (quotient * 100)
elif(amount >= 20):
quotient = amount // 20
count += quotient
amount = amount - (quotient * 20)
elif(amount >= 10):
quotient = amount // 10
count += quotient
amount = amount - (quotient * 10)
elif(amount >= 5):
quotient = amount // 5
count += quotient
amount = amount - (quotient * 5)
elif(amount >= 1):
quotient= amount // 1
count += quotient
amount = amount - (quotient * 1)
return count
amount = int(input())
print(retrieve_bills(amount))
| 7 | PYTHON3 |
numberOfStones = input("")
stonesRefined = list(input(""))
neededStones = 0
for stone in range(int(numberOfStones)):
if (stone > 0):
if (stonesRefined[stone - 1] == stonesRefined[stone]):
neededStones = neededStones + 1
print(neededStones) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long n = s.size();
long long st = -1, en = -1, pec = -1, cec = -1;
for (long long i = 0; i < n; i++) {
if (s[i] == '[') {
st = i;
break;
}
}
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == ']') {
en = i;
break;
}
}
if (st >= en || st == -1 || en == -1) {
cout << -1;
return 0;
}
for (long long i = st + 1; i < en; i++) {
if (s[i] == ':') {
pec = i;
break;
}
}
for (long long i = en - 1; i > st; i--) {
if (s[i] == ':') {
cec = i;
break;
}
}
long long cnt = 0;
if (pec == -1 || cec == -1 || cec == pec) {
cout << -1;
return 0;
}
for (long long i = pec + 1; i < cec; i++) {
if (s[i] == '|') cnt++;
}
cnt += 4;
cout << cnt;
return 0;
}
| 8 | CPP |
t=int(input())
for tt in range(t):
n=int(input())
if n<=30:
print("NO")
else:
print("YES")
if n-30!=6 and n-30!=10 and n-30!=14:
print(6,10,14,n-30)
else:
print(6,10,15,n-31) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 100;
long long n, a[N], ans;
priority_queue<long long, vector<long long>, greater<long long> > q;
void load() {}
void process() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
q.push(a[i]);
q.push(a[i]);
ans += (a[i] - q.top());
q.pop();
}
cout << ans;
}
int main() {
load();
process();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305;
int a[maxn][maxn], b[maxn][maxn];
int main(int argc, char const *argv[]) {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &a[i][j]);
}
}
bool good = 1;
b[1][1] = b[1][m] = b[n][1] = b[n][m] = 2;
if (a[1][1] > 2 or a[1][m] > 2 or a[n][1] > 2 or a[n][m] > 2) {
printf("NO\n");
continue;
}
for (int i = 2; i < m; ++i) {
if (a[1][i] > 3 or a[n][i] > 3) {
good = 0;
}
b[1][i] = b[n][i] = 3;
}
for (int i = 2; i < n; ++i) {
if (a[i][1] > 3 or a[i][m] > 3) {
good = 0;
}
b[i][1] = b[i][m] = 3;
}
if (!good) {
printf("NO\n");
continue;
}
for (int i = 2; i < n; ++i) {
for (int j = 2; j < m; ++j) {
if (a[i][j] > 4) {
good = 0;
}
b[i][j] = 4;
}
}
if (!good) {
printf("NO\n");
} else {
printf("YES\n");
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
printf("%d ", b[i][j]);
}
printf("\n");
}
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << int(1e6) << " ";
int p = int(1e6);
for (int i = 2; i <= n; i++) {
cout << p + i << " ";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvll;
const ll inf = 1e16;
const ll md = 1000000007;
vi to[100005];
int deg[100005];
vi par;
int dp0[100005];
int dp[100005];
vi dp_uu;
int n;
int dfs(int u, int ou) {
par[u] = ou;
int to_leaf = 0;
for (int ku : to[u]) {
if (ku == ou) continue;
to_leaf = dfs(ku, u) + 1;
}
if (to_leaf >= 0) {
if (deg[ou] == 2 && ou != 0)
return to_leaf;
else {
dp0[u] = to_leaf;
return -10;
}
}
dp_uu.push_back(u);
return -10;
}
bool check(int m) {
rep(i, n) dp[i] = dp0[i];
//cout << "m=" << m << endl;
for (int u : dp_uu) {
vi dists(0);
for (int ku : to[u]) {
if (ku == par[u]) continue;
dists.push_back(dp[ku] + 1);
}
sort(dists.begin(), dists.end());
//cout << "u=" << u << endl;
//for (int d : dists) cout << d << " ";
//cout << endl;
int n_child = dists.size();
if (dists[n_child - 1] > m) return false;
//cout << n_child << " " << (n_child & 1) << endl;
if ((n_child & 1) == 0) {
bool success = true;
rep(i, n_child / 2) if (dists[i] + dists[n_child - 1 - i] > m) {
//cout << "fail" << dists[i] << " " << dists[n_child - 1 - i] << endl;
n_child--;
success = false;
break;
}
if (success) {
dp[u] = 0;
continue;
}
}
int l = -1, r = n_child;
while (l + 1 < r) {
int c = (l + r) / 2;
int i = 0, j = n_child - 1;
bool ok = true;
rep(_, n_child / 2) {
if (i == c) i++;
if (j == c) j--;
if (dists[i] + dists[j] > m) {
if (c == n_child - 1) return false;
ok = false;
break;
}
i++;
j--;
}
if (ok)
r = c;
else
l = c;
}
dp[u] = dists[r];
}
if ((deg[0] & 1) == 0 && dp[0] > 0) return false;
return true;
}
int main() {
cin >> n;
par.resize(n, -1);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
to[a].push_back(b);
to[b].push_back(a);
deg[a]++;
deg[b]++;
}
//奇数次数の頂点数を求める
int n_odd_deg = 0;
rep(i, n) if (deg[i] & 1 == 1) n_odd_deg++;
//木DPの為に枝を縮める
dfs(0, -1);
//二分探索でBを決める
int l = -1, r = n;
while (l + 1 < r) {
int m = (l + r) / 2;
//cout << l << " " << m << " " << r << endl;
if (check(m))
r = m;
else
l = m;
}
cout << n_odd_deg / 2 << " " << r << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n == 0 && m > 0) {
cout << "Impossible\n";
} else {
int max = n;
if (m > 0) max += m - 1;
int min = n;
if (m >= n) min += m - n;
cout << min << " " << max << endl;
}
return 0;
}
| 7 | CPP |
n,m=map(int,input().split())
s=[]
comp=0
total=0
totalcomp=0
for i in range(n):
a,b=map(int,input().split())
s.append(a-b)
total+=a
totalcomp+=(a-b)
if m<total-totalcomp:
print("-1")
exit()
s=sorted(s,reverse=True)
k=0
while m<total:
comp+=1
total-=s[k]
k+=1
print(comp) | 9 | PYTHON3 |
import math
test = int(input())
for t in range(test):
tt = 0
pp = 0
cc = ""
ss = ""
dd = 1
cnttt = 0
damn = 1e18
ammo = "FULL"
#write yoour code here
a,b = map(int,input().split())
aa = a%(b+1);bb = b%(b+1)
if(aa>=(b+1)/2 and bb>=(b+1)/2):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long a, b, c;
cin >> a >> b >> c;
cout << min(a + b + c, min(2 * (a + b), min(2 * (a + c), 2 * (b + c))));
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char p[42], q[42];
int n, m, cnt, C[1 << 20], OK[50][50];
long long U[40 << 18], TP[40 << 18];
void Do(int st, int pv, long long s) {
if (pv == n) {
U[cnt++] = s;
return;
}
if (pv < m) {
long long t = (p[m - pv - 1] - '0');
Do(st, pv + 1, s + (t << ((pv + st) % n)));
return;
}
Do(st, pv + 1, s);
Do(st, pv + 1, s + (1ll << ((pv + st) % n)));
}
int A[50][50], B[50][50], Pre[50], Suf[50];
int Calc2(int L, int i, int ck) {
int j;
int pr = 0, su = 0;
for (j = 0; j <= L - m; j++) {
if (((i >> j) & ((1 << m) - 1)) == Pre[m]) {
pr = su = m;
}
}
for (j = 1; j <= m && j <= L; j++) {
if ((i >> (L - j)) == Suf[j]) su = max(su, j);
if ((i & ((1 << j) - 1)) == Pre[j]) pr = max(pr, j);
}
if (ck == 0) return pr;
return su;
}
void Calc(int L, int pv) {
int i, j;
for (i = 0; i < (1 << L); i++) {
int pr = 0, su = 0;
for (j = 0; j <= L - m; j++) {
if (((i >> j) & ((1 << m) - 1)) == Pre[m]) {
pr = su = m;
}
}
for (j = 1; j <= m && j <= L; j++) {
if ((i >> (L - j)) == Suf[j]) su = max(su, j);
if ((i & ((1 << j) - 1)) == Pre[j]) pr = max(pr, j);
}
if (pv == 0)
A[pr][su]++;
else
B[pr][su]++;
}
}
void Go() {
int i;
for (i = 0; i < n; i++) {
Do(i, 0, 0);
}
for (i = 0; i < cnt; i++) {
C[U[i] & 1048575]++;
}
for (i = 1; i < (1 << 20); i++) C[i] += C[i - 1];
for (i = 0; i < cnt; i++) {
TP[--C[U[i] & 1048575]] = U[i];
}
for (i = 0; i < (1 << 20); i++) C[i] = 0;
for (i = 0; i < cnt; i++) {
C[TP[i] >> 20]++;
}
for (i = 1; i < (1 << 20); i++) C[i] += C[i - 1];
for (i = cnt - 1; i >= 0; i--) {
U[--C[TP[i] >> 20]] = TP[i];
}
int res = cnt;
for (i = 1; i < cnt; i++) {
if (U[i] == U[i - 1]) res--;
}
printf("%d\n", res);
}
int main() {
int i, j, k;
scanf("%d", &n);
scanf("%s", p);
m = strlen(p);
if (n - m < 19) {
Go();
return 0;
}
for (i = 0; i < m; i++) {
Pre[i + 1] = Pre[i] * 2 + p[i] - '0';
}
for (i = m - 1; i >= 0; i--) {
Suf[m - i] = Suf[m - i - 1] + ((p[i] - '0') << (m - i - 1));
}
Calc((n + 1) / 2, 0);
Calc(n / 2, 1);
for (i = 0; i <= m; i++)
for (j = 0; j <= m; j++) {
long long s = Pre[i];
s = (s << j) + Suf[j];
for (k = 0; k <= i + j - m; k++) {
if (((s >> k) & ((1 << m) - 1)) == Pre[m]) OK[i][j] = 1;
}
}
long long res = 0;
for (i = 0; i <= m; i++)
for (j = 0; j <= m; j++)
for (int ii = 0; ii <= m; ii++)
for (int jj = 0; jj <= m; jj++) {
if (!OK[i][jj] && !OK[ii][j]) continue;
res += 1ll * A[i][j] * B[ii][jj];
}
printf("%lld\n", res);
}
| 12 | CPP |
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''
def main():
string = str(input())
s = set()
for i in range(len(string)):
if string[i]!="{" and string[i]!="}" and string[i]!=',' and string[i]!=' ':
s.add(string[i])
print(len(s))
# print(s)
main() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, x[101000], y[101000], fa[101000], sz[101000], tot[101000], u, v;
map<int, vector<int> > xx, yy;
map<int, vector<int> >::iterator it;
long long ans = 1, er[202000];
int GF(int x) { return fa[x] == x ? x : fa[x] = GF(fa[x]); }
void doit(vector<int> &the) {
for (int i = 1; i < (int)the.size(); i++)
if ((u = GF(the[i - 1])) != (v = GF(the[i]))) {
sz[v] += sz[u];
tot[v] += tot[u];
fa[u] = v;
}
tot[GF(the[0])]++;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
xx[x[i]].push_back(i);
yy[y[i]].push_back(i);
fa[i] = i;
sz[i] = 1;
}
for (it = xx.begin(); it != xx.end(); it++) doit(it->second);
for (it = yy.begin(); it != yy.end(); it++) doit(it->second);
er[0] = 1;
for (int i = 1; i < 202000; i++) er[i] = er[i - 1] * 2 % 1000000007;
for (int i = 1; i <= n; i++)
if (fa[i] == i) ans = ans * (er[tot[i]] - (tot[i] > sz[i])) % 1000000007;
cout << (ans + 1000000007) % 1000000007;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:256000000")
int main() {
string a[30005];
int n, ans = 0, t;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int h = a[1].length();
for (; ans < h; ++ans) {
t = 1;
for (int j = 2; j <= n; ++j)
if (a[j][ans] != a[1][ans]) t = 0;
if (!t) break;
}
cout << ans;
}
| 7 | CPP |
l1, l2 = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
ak = [0 for i in range(10)]
bk = [0 for i in range(10)]
for el in a:
ak[el] += 1
for el in b:
bk[el] += 1
ans = 0
q = 0
for i in range(10):
if ak[i] > 0 and bk[i] > 0:
ans = i
q = 1
break
if q == 1:
print(ans)
else:
if min(a) == 0:
sec_m = 10
for j in range(1, 10):
if ak[j] > 0:
sec_m = j
break
print (min(min(sec_m, min(b)) * 10 + max(sec_m, min(b)), min(b) * 10))
elif min(b) == 0:
for j in range(1, 10):
sec_m = 10
if bk[j] > 0:
sec_m = j
break
print (min(min(sec_m, min(a)) * 10 + max(sec_m, min(a)), min(a) * 10))
else:
print(min(min(a), min(b)) * 10 + max(min(a), min(b)))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)1e5 + 111;
const int inf = (int)1e9 + 111;
const long long llinf = (long long)1e18 + 5;
const int MOD = (int)1e9 + 7;
int a[Z];
int main() {
srand(time(0));
map<int, vector<int> > mp;
int n, m, k;
cin >> n >> k >> m;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
mp[a[i] % m].push_back(a[i]);
}
for (int i = 1; i <= n; ++i) {
if ((int)mp[a[i] % m].size() >= k) {
cout << "Yes\n";
for (int j = 0; j < k; ++j) {
printf("%d ", mp[a[i] % m][j]);
}
return 0;
}
}
cout << "No";
return 0;
}
| 8 | CPP |
n = int(input())
l = list(map(int, input().split()))
ind = l.index(max(l))
l.pop(ind)
print(ind + 1, max(l)) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i,j,k,l;
while(cin>>l){
j=l/100;
k=l%100;
if(j<=12&&k<=12&&j!=0&&k!=0) cout<<"AMBIGUOUS"<<endl;
else if(j<=12&&j!=0) cout<<"MMYY"<<endl;
else if(k<=12&&k!=0) cout<<"YYMM"<<endl;
else cout<<"NA"<<endl;
} return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long v[1000000];
long long int smallest_enclosure(long long int a, long long int b) {
int n = 0;
for (long long int i = 1; i * i <= a; i++) {
if (a % i == 0) {
v[n] = i;
n++;
}
}
long long int ans = 2 * (a + b) + 2;
long long int x = a + b;
int l = 0;
for (long long int i = 1; i * i <= x; i++) {
if (x % i == 0) {
while (l + 1 < n && v[l + 1] <= i) l++;
if (a / v[l] <= x / i) ans = min(ans, (i + x / i) * 2);
}
}
return ans;
}
int main() {
long long int a, b;
scanf("%lld%lld", &a, &b);
printf("%lld", min(smallest_enclosure(a, b), smallest_enclosure(b, a)));
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int n, k, q, p;
int A[200], B[200];
double M, m;
vector<int> V;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> A[i];
M = -1000000000;
m = 1000000000;
cin >> q;
for (int i = 1; i <= q; i++) {
int cur = 0;
for (int j = 1; j <= n / k; j++) {
cin >> p;
B[p] = 1;
cur += A[p];
}
M = max(M, 1.0 * cur / (n / k));
m = min(m, 1.0 * cur / (n / k));
}
for (int i = 1; i <= n; i++)
if (!B[i]) {
V.push_back(A[i]);
}
sort(V.begin(), V.end());
if (V.size() > n % k) {
int cur = 0;
for (int j = 0; j < n / k; j++) cur += V[j];
m = min(m, 1.0 * cur / (n / k));
M = max(M, 1.0 * cur / (n / k));
cur = 0;
for (int j = V.size() - n / k; j < V.size(); j++) cur += V[j];
m = min(m, 1.0 * cur / (n / k));
M = max(M, 1.0 * cur / (n / k));
}
cout.setf(ios::fixed);
cout.precision(10);
cout.setf(ios::showpoint);
cout << m << " " << M << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, k, l, a[N];
void solve() {
scanf("%d %d %d", &n, &k, &l);
int ma = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), ma = max(ma, a[i]);
if (ma > l) {
puts("No");
return;
}
if (ma + k <= l) {
puts("Yes");
return;
}
int T = -1;
bool flag = 0;
for (int i = 1; i <= n; i++) {
int L = max(0, a[i] + k - l);
int R = 2 * k - L;
if (a[i] + k <= l) {
flag = 1;
continue;
}
if (flag) {
T = L;
flag = 0;
continue;
}
if (R >= T + 1) {
T = max(L, T + 1);
} else {
puts("No");
return;
}
}
puts("Yes");
}
int main() {
int _;
scanf("%d", &_);
while (_--) solve();
return 0;
}
| 8 | CPP |
#include<cmath>
#include<queue>
#include<cstdio>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
int main(){
static int isqrt[1000001]; // isqrt[a] := ceil(sqrt(a))
rep(a,1001) isqrt[a*a]=a;
for(int a=999999;a>0;a--) if(isqrt[a]==0) isqrt[a]=isqrt[a+1];
for(int n;scanf("%d",&n),n;){
int n2=(int)ceil(sqrt(n));
// 上から見た面
const int O=n2; // offset
static int h[2000][2000];
rep(x,n2) rep(y,n2) {
int z2=n-(x*x+y*y);
if(z2<=0) h[x+O][y+O]=-1;
else h[x+O][y+O]=isqrt[z2];
}
// 左上 1/4 だけ高さを決めれば、残りは対称性からわかる
rep(x,n2) rep(y,n2) h[O-x-1][y+O]=h[O-x-1][O-y-1]=h[x+O][O-y-1]=h[x+O][y+O];
// painting
int cnt=0;
static bool vis[2000][2000];
for(int x=-n2;x<n2;x++) for(int y=-n2;y<n2;y++) vis[x+O][y+O]=false;
for(int x=-n2;x<n2;x++) for(int y=-n2;y<n2;y++) {
if(vis[x+O][y+O] || h[x+O][y+O]==-1) continue;
vis[x+O][y+O]=true;
static queue< pair<int,int> > Q;
Q.push(make_pair(x,y));
while(!Q.empty()){
int xx=Q.front().first,yy=Q.front().second; Q.pop();
rep(k,4){
int xxx=xx+dx[k],yyy=yy+dy[k];
if(-n2<=xxx && xxx<n2 && -n2<=yyy && yyy<n2
&& !vis[xxx+O][yyy+O] && h[xxx+O][yyy+O]==h[x+O][y+O]){
vis[xxx+O][yyy+O]=true;
Q.push(make_pair(xxx,yyy));
}
}
}
cnt++;
}
printf("%d\n",6*cnt);
}
return 0;
} | 0 | CPP |
for _ in range(int(input())):
n = int(input())
if n <= 2:
print(0)
else:
print(n - n // 2 - 1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, res;
cin >> n;
res = 0;
while (!(n % 3)) n /= 3;
cout << n / 3 + 1 << endl;
return 0;
}
| 9 | CPP |
# Graph II - Single Source Shortest Path II
def dijkstra(length, adj_list):
INFTY = float('inf')
d = [INFTY for _ in range(length)]
d[0] = 0
Q = [i for i in range(length)]
while Q:
idx = INFTY
minv = INFTY
for q in Q:
if d[q] < minv:
idx, minv = q, d[q]
u = Q.pop(Q.index(idx))
for v in adj_list[u]:
if d[v[0]] > d[u] + v[1]:
d[v[0]] = d[u] + v[1]
return d
n = int(input())
adj_list = [set() for _ in range(n)]
for _ in range(n):
ss = list(map(int, input().split()))
u, k = ss[0], ss[1]
for i in range(k):
vi,ci = ss[2*i+2], ss[2*i+3]
adj_list[u].add((vi,ci))
d = dijkstra(n, adj_list)
for i,v in enumerate(d): print(i,v)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int M[2000][2000];
int main() {
vector<pair<int, int> > V;
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
if (i != j && !M[i][j] && cnt < k) {
V.push_back(make_pair(i, (j)));
cnt++;
M[i][j]++;
M[j][i]++;
}
}
if (cnt != k) {
cout << -1 << endl;
return 0;
}
}
cout << V.size() << endl;
for (int i = 0; i < V.size(); i++) printf("%d %d\n", V[i].first, V[i].second);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int mx = 2e5 + 228;
int n;
vector<int> g[mx], children[mx];
long long ans, a[mx], even[mx], odd[mx], f_even[mx], f_odd[mx], t_even[mx],
t_odd[mx];
void hang(int v, int pv) {
if (v != 0) children[pv].push_back(v);
for (auto v1 : g[v]) {
if (v1 != pv) hang(v1, v);
}
}
void to_mod(long long &x) { x = (x % MOD + MOD) % MOD; }
void dfs(int v) {
for (auto v1 : children[v]) {
dfs(v1);
}
even[v] += 1;
f_even[v] += a[v];
t_even[v] += a[v];
long long sum_even = 0, sum_odd = 0, sum_f_even = 0, sum_f_odd = 0,
sum_t_even = 0, sum_t_odd = 0;
for (auto v1 : children[v]) {
even[v] += odd[v1];
f_even[v] += (f_odd[v1] + odd[v1] * a[v]);
t_even[v] += (-t_odd[v1] + odd[v1] * a[v]);
odd[v] += even[v1];
f_odd[v] += (f_even[v1] - even[v1] * a[v]);
t_odd[v] += (-t_even[v1] + even[v1] * a[v]);
sum_even += even[v1];
sum_odd += odd[v1];
sum_f_even += f_even[v1];
sum_f_odd += f_odd[v1];
sum_t_even += t_even[v1];
sum_t_odd += t_odd[v1];
to_mod(f_even[v]);
to_mod(t_even[v]);
to_mod(f_odd[v]);
to_mod(t_odd[v]);
to_mod(sum_f_even);
to_mod(sum_t_even);
to_mod(sum_f_odd);
to_mod(sum_t_odd);
to_mod(sum_even);
to_mod(sum_odd);
}
for (auto v1 : children[v]) {
long long rem_odd = sum_odd - odd[v1];
long long rem_even = sum_even - even[v1];
long long rem_f_odd = sum_f_odd - f_odd[v1];
long long rem_f_even = sum_f_even - f_even[v1];
long long rem_t_odd = sum_t_odd - t_odd[v1];
long long rem_t_even = sum_t_even - t_even[v1];
to_mod(rem_f_even);
to_mod(rem_t_even);
to_mod(rem_f_odd);
to_mod(rem_t_odd);
to_mod(rem_even);
to_mod(rem_odd);
long long c1 = f_even[v1] * rem_even + rem_t_even * even[v1] -
((rem_even * even[v1]) % MOD) * a[v];
long long c2 = f_even[v1] * rem_odd + rem_t_odd * even[v1] -
((rem_odd * even[v1]) % MOD) * a[v];
long long c3 = f_odd[v1] * rem_even - rem_t_even * odd[v1] +
((rem_even * odd[v1]) % MOD) * a[v];
long long c4 = f_odd[v1] * rem_odd - rem_t_odd * odd[v1] +
((rem_odd * odd[v1]) % MOD) * a[v];
to_mod(c1);
to_mod(c2);
to_mod(c3);
to_mod(c4);
ans += (c1 + c2 + c3 + c4);
to_mod(ans);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
hang(0, 0);
dfs(0);
for (int i = 0; i < n; ++i) {
ans += (f_odd[i] + f_even[i] + t_odd[i] + t_even[i]);
ans -= a[i];
to_mod(ans);
}
cout << ans << endl;
}
| 11 | CPP |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<string>
#include<cmath>
#include<cstring>
#include<map>
#include<queue>
#include<set>
#include<stack>
#define LL long long
#define rep(i,l,r) for(int i=l;i<=r;++i)
#define ios_speed_up ios::sync_with_stdio(0)
#define dep(i,l,r) for(int i=l;i>=r;--i)
#define debug(x) cout<<#x": "<<x<<endl;
using namespace std;
const int INF=0x7fffffff;
const LL mod=1e9+7;
inline int read()
{
int w=0,s=0;char ch=getchar();
while(ch<'0'||ch>'9') s|=ch=='-',ch=getchar();
while(ch>='0'&&ch<='9') w=(w<<3)+(w<<1)+(ch^48),ch=getchar();
return s?-w:w;
}
LL t,n,k;
LL qsm(LL a,LL b){
if(b==1) return a%mod;
if(b==0) return 1;
if(b&1) return a*qsm(a*a%mod,b>>1)%mod;
return qsm(a*a%mod,b>>1);
}
int main()
{
t=read();
while(t--){
n=read(),k=read();
// if(n&1) cout<<1<<endl;
cout<<qsm(n,k)<<endl;
}
return 0;
} | 8 | CPP |
from collections import Counter
import math
import sys
from bisect import bisect,bisect_left,bisect_right
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def mod(): return 10**9+7
for _ in range(INT()):
#n = INT()
#s = input()
n,x = MAP()
arr = LIST()
e = o = 0
for i in arr:
if i%2 == 0:
e += 1
else:
o += 1
# print(e,o)
if x == n:
if o % 2 != 0:
print("Yes")
else:
print("No")
elif o == 0:
print("No")
elif e == 0:
if x % 2 == 0:
print("No")
else:
print('Yes')
else:
print("Yes")
| 7 | PYTHON3 |
#Codeforces - Books
n, t = map(int, input().split())
arrN = list(map(int, input().split()))
result = 0
result = 0
totalTime = 0
j = 0
i = 0
while i < n:
totalTime += arrN[i]
if totalTime <= t:
tempResult = i - j + 1
result = max(result, tempResult)
else:
while totalTime > t:
totalTime -= arrN[j]
j+=1
i += 1
print(result) | 8 | PYTHON3 |
def solve(arr, n):
diffarr = [0]*n
count = 0
for i in range(n-2, -1, -1):
arr[i] -= count
if arr[i] < 0:
return 0
if arr[i] > arr[i+1]:
count += arr[i]-arr[i+1]
arr[i] = arr[i+1]
# print(i, arr, count)
# print(arr)
return 1
t = int(input())
for _ in range(t):
n = int(input())
oriarr = [int(j) for j in input().split()]
arr = oriarr[:]
revarr = oriarr[::-1]
if solve(arr, n) == 1 or solve(revarr, n) == 1:
print("YES")
else:
print("NO")
| 10 | PYTHON3 |
L = [int(j) for j in input()]
L.append(2)
a = 0
b = 0
for i in range(len(L)):
if L[i] == 0:
a += 1
b = 0
if a >=7:
print('YES')
break
if L[i] == 1:
a = 0
b += 1
if b >=7:
print('YES')
break
if L[i] == 2:
print('NO')
| 7 | PYTHON3 |
a = []
a = input().split()
ans = int(0)
ans = int(a[0]) // int(a[2])
if int(a[0]) % int(a[2]) != 0:
ans = ans + 1
ans2 = int(0)
ans2 = int(a[1]) // int(a[2])
if int(a[1]) % int(a[2]) != 0:
ans2 = ans2 + 1
print(ans*ans2)
| 7 | PYTHON3 |
from sys import stdin
N = int(input())
for t in range(N):
n,k = list(map(int,input().split()))
s = input()
first = s.find('*')
if first == -1:
print(-1)
else:
last = s.rfind('*')
if first == last:
print(1)
else:
count = 2
j = first
while True:
if last -j <=k : break
j += k
count +=1
while s[j] !='*': j-=1
print(count) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
int ulen;
string usr;
vector<int> buc[128];
long long F(const string &dic) {
int dlen = dic.length();
long long ans = 0;
for (int i = 0; i < min(ulen, dlen); i++) {
char c = dic[i];
if (c == usr[i]) continue;
int cost = INF;
if (buc[c].size() == 0)
cost = dlen;
else {
vector<int>::iterator it = lower_bound(buc[c].begin(), buc[c].end(), i);
if (it != buc[c].end()) {
cost = min(cost, abs((*it) - i));
}
if (it != buc[c].begin()) {
--it;
cost = min(cost, abs((*it) - i));
}
}
ans += cost;
}
for (int i = ulen; i < dlen; i++) {
char c = dic[i];
int cost;
if (buc[c].size() == 0)
cost = dlen;
else
cost = abs(buc[c].back() - i);
ans += cost;
}
return ans;
}
int main() {
int n, k;
cin >> n >> k >> usr;
ulen = usr.length();
for (int i = 0; i < ulen; i++) buc[usr[i]].push_back(i);
for (int i = 0; i < n; i++) {
string dic;
cin >> dic;
cout << F(dic) << endl;
}
return 0;
}
| 8 | CPP |
#include<stdio.h>
int main(void)
{
int n,i,a;
scanf("%d %d",&n,&i);
a=n-i+1;
printf("%d\n",a);
return 0;
}
| 0 | CPP |
n, m = map(int, input().split())
mydiv = n // m
mymod = n % m
mylist = [ mydiv for _ in range(m) ]
if mymod == 0 :
out = ' '.join(str(i) for i in mylist)
else :
for i in mylist :
mylist[mylist.index(i)] += 1
mymod -= 1
if mymod == 0 :
out = ' '.join(str(i) for i in mylist)
break
print(out)
| 7 | PYTHON3 |
#include<queue>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define LL long long
using namespace std;
const LL mod=1e9+7,inf=1LL<<60;
struct Node{
LL x,y,c,next;
}a[400010];LL len=0,last[100010];
LL n,m,st,ed,f[2][100010];
struct node{
LL x,d;
node() {}
node(LL a,LL b) {x=a;d=b;}
};
bool operator < (node a,node b) {return a.d>b.d;}
priority_queue<node> q;
void ins(LL x,LL y,LL c)
{
a[++len].x=x;a[len].y=y;a[len].c=c;
a[len].next=last[x];last[x]=len;
}
bool vis[100010];
LL dis[2][100010];
void dij(LL op,LL st)
{
for(LL i=1;i<=n;i++) dis[op][i]=inf;
memset(vis,false,sizeof(vis));
dis[op][st]=0;q.push(node(st,0));
while(!q.empty())
{
LL x=q.top().x;q.pop();
if(vis[x]) continue;
vis[x]=true;
for(LL i=last[x];i;i=a[i].next)
{
LL y=a[i].y;
if(dis[op][y]>dis[op][x]+a[i].c)
{
dis[op][y]=dis[op][x]+a[i].c;
q.push(node(y,dis[op][y]));
}
}
}
}
void solve(LL op,LL st)
{
memset(vis,false,sizeof(vis));
f[op][st]=1;
q.push(node(st,dis[op][st]));
while(!q.empty())
{
LL x=q.top().x;q.pop();
if(vis[x]) continue;
vis[x]=true;
for(LL i=last[x];i;i=a[i].next)
{
LL y=a[i].y;
if(dis[op][x]+a[i].c==dis[op][y])
{
(f[op][y]+=f[op][x])%=mod;
q.push(node(y,dis[op][y]));
}
}
}
}
LL get(LL x,LL y) {return f[0][x]*f[0][x]%mod*f[1][y]%mod*f[1][y]%mod;}
int main()
{
scanf("%lld %lld %lld %lld",&n,&m,&st,&ed);
for(LL i=1;i<=m;i++)
{
LL x,y,c;scanf("%lld %lld %lld",&x,&y,&c);
ins(x,y,c);ins(y,x,c);
}
dij(0,st);dij(1,ed);
solve(0,st);solve(1,ed);
LL ans=f[0][ed]*f[1][st]%mod;
for(int i=1;i<=n;i++) if(dis[0][i]==dis[1][i]&&dis[0][i]+dis[1][i]==dis[0][ed]) (ans-=get(i,i))%=mod;
for(LL i=1;i<=len;i+=2){
LL x=a[i].x,y=a[i].y;
if(dis[0][x]>dis[0][y])
swap(x,y);
if(dis[0][x]+dis[1][y]+a[i].c==dis[0][ed]&&abs(dis[0][x]-dis[1][y])<a[i].c)
(ans-=get(x,y))%=mod;
}
printf("%lld",(ans+mod)%mod);
} | 0 | CPP |
#!/usr/bin/python3
def readln(): return list(map(int, input().split()))
ans = 1
l = 1
p = -1
a = input()
for i in range(len(a)):
c = int(a[i])
if c + p == 9:
l += 1
if c + p != 9 or i == len(a) - 1:
if l % 2:
ans *= (l + 1) // 2
l = 1
p = c
print(ans)
| 8 | PYTHON3 |
# @author --> ajaymodi
# Naive approach
import sys
# sys.stdin=open("input.in","r")
# sys.stdout=open("output.out","w")
input=lambda : sys.stdin.readline().strip()
char = [chr(i) for i in range(97,123)]
CHAR = [chr(i) for i in range(65,91)]
mp = lambda:list(map(int,input().split()))
INT = lambda:int(input())
rn = lambda:range(INT())
from math import ceil,sqrt,factorial,gcd
for _ in rn():
n = INT()
l = mp()
l = l[::-1]
flag = 0
c = 1
for i in range(1,n):
if l[i]>l[i-1]:
c+=1
if flag==1:
c-=1
break
elif l[i]==l[i-1]:
c+=1
else:
if flag==0:
flag+=1
c+=1
# print(c,"----")
print(n-c)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-11;
string s;
string a, d;
int b;
int main() {
cin >> s;
int i = 0;
for (; s[i] != '.'; i++) a += s[i];
i++;
for (; s[i] != 'e'; i++) d += s[i];
i++;
for (; i < s.size(); i++) b = b * 10 + (s[i] - '0');
for (int i = 0; i < (200); i++) d += '0';
for (int i = 0; i < (b); i++) {
a += d[i];
d[i] = '.';
}
bool oo = 0;
for (int i = 0; i < (a.size()); i++) {
if (i == a.size() - 1 || a[i] != '0') oo = 1;
if (oo) cout << a[i];
}
string dd = "";
bool o = 0;
for (int i = d.size() - 1; i >= 0; i--) {
if (d[i] != '0' && d[i] != '.') o = 1;
if (o && d[i] != '.') dd = d[i] + dd;
}
if (o)
cout << '.' << dd << endl;
else
cout << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
long long k, n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> k;
while (k--) {
cin >> n;
cout << (n / 2) + 1 << "\n";
}
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
namespace ringo {
const int IN_LEN = 1000000, OUT_LEN = 10000000;
char buf[IN_LEN], obuf[OUT_LEN], *ooh = obuf;
inline char read() {
static char *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
inline void print(char c) {
if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T>
inline void read(T &x) {
static bool f = 0;
static char c = read();
for (x = 0; !isdigit(c); c = read()) {
f ^= c == '-';
if (c == -1) return;
}
for (; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
if (f) x = -x;
}
template <class T>
inline void print(T x) {
static int buf[30], cnt;
if (!x) {
print('0');
return;
}
if (x < 0) print('-'), x = -x;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + '0';
while (cnt) print((char)buf[cnt--]);
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
template <class T>
inline void maxd(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void mind(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void print(T x, char c) {
print(x), print(c);
}
template <class T>
inline T abs(const T &a) {
if (a < 0) return -a;
return a;
}
int n, lst, a, b, tim, max;
void main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a), read(b);
lst = std::max(lst - a + tim, 0) + b;
max = std::max(max, lst);
tim = a;
}
print(tim + lst, ' '), print(max, '\n');
}
} // namespace ringo
signed main() { return ringo::main(), ringo::flush(), 0; }
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int row[] = {0, 1, 0, -1, -1, -1, 1, 1};
int col[] = {1, 0, -1, 0, 1, -1, -1, 1};
const long long N = 1e6 + 10;
const long long M = 1e18 + 7;
const long long H = 1e9 + 7;
const long long base = 131;
long long logx(long long a, long long bs) { return log(a) / log(bs); }
long long Max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long Min(long long a, long long b) {
if (a > b) return b;
return a;
}
long long big_mul(long long a, long long b, long long m) {
long long x = 0, y = a % m;
while (b > 0) {
if (b & 1) x = (x + y) % m;
y = (2 * y) % m;
b >>= 1;
}
return x % m;
}
long long big_mod(long long a, long long b, long long m) {
long long x = 1, y = a % m;
while (b > 0) {
if (b & 1) x = (x * y) % m;
y = (y * y) % m;
b >>= 1;
}
return x % m;
}
long long Big_mod(long long a, long long b, long long m) {
long long x = 1, y = a % m;
while (b > 0) {
if (b & 1) x = big_mul(x, y, m);
y = big_mul(y, y, m);
b >>= 1;
}
return x % m;
}
long long mod_inverse(long long a, long long m) { return big_mod(a, m - 2, m); }
long long GCD(long long a, long long b) {
if (!a) return b;
return GCD(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
string str;
cin >> str;
int cnt1 = 0;
int cnt2 = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '|') break;
cnt1++;
}
for (int i = str.size() - 1; i >= 0; i--) {
if (str[i] == '|') break;
cnt2++;
}
string str1;
cin >> str1;
int d = max(cnt1, cnt2) - min(cnt1, cnt2);
if (d <= str1.size() && (str1.size() - d) % 2 == 0) {
int p = cnt1 + cnt2 + str1.size();
p /= 2;
int pos = cnt1;
for (int i = 0; i < pos; i++) cout << str[i];
for (int i = 0; i < p - cnt1; i++) cout << str1[i];
cout << "|";
for (int i = pos + 1; i < str.size(); i++) cout << str[i];
for (int i = p - cnt1; i < str1.size(); i++) cout << str1[i];
cout << endl;
} else
cout << "Impossible" << endl;
return 0;
}
| 7 | CPP |
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#include<cmath>
#include<climits>
#include<string>
#include<set>
#include<map>
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<((int)(n));i++)
#define reg(i,a,b) for(int i=((int)(a));i<=((int)(b));i++)
#define irep(i,n) for(int i=((int)(n))-1;i>=0;i--)
#define ireg(i,a,b) for(int i=((int)(b));i>=((int)(a));i--)
typedef long long int lli;
typedef pair<int,int> mp;
#define fir first
#define sec second
#define IINF INT_MAX
#define LINF LLONG_MAX
#define eprintf(...) fprintf(stderr,__VA_ARGS__)
#define pque(type) priority_queue<type,vector<type>,greater<type> >
#define memst(a,b) memset(a,b,sizeof(a))
int n;
vector<int> vs[100005];
int ans[100005];
set<int> s[100005];
void dfs(){
vector<int> stc;
stc.push_back(0);
{
for(int i=0;i!=stc.size();i++){
int no=stc[i];
rep(j,vs[no].size()){
stc.push_back(vs[no][j]);
}
}
}
irep(k,stc.size()){
int no=stc[k];
rep(i,vs[no].size()){
int to=vs[no][i];
if(s[to].size()>s[no].size())swap(s[no],s[to]);
for(set<int>::iterator ite=s[to].begin(); ite!=s[to].end(); ite++){
int p=*ite;
if(s[no].count(p)>=1){
s[no].erase(p);
ans[p]=no;
}
else{
s[no].insert(p);
}
}
s[to].clear();
}
}
}
int main(void){
scanf("%d",&n);
rep(i,n){
int k;
scanf("%d",&k);
rep(j,k){
int a;
scanf("%d",&a);
vs[i].push_back(a);
}
}
int q;
scanf("%d",&q);
rep(i,q){
int a,b;
scanf("%d%d",&a,&b);
if(a==b)ans[i]=a;
else{
s[a].insert(i);
s[b].insert(i);
}
}
dfs();
rep(i,q){
printf("%d\n",ans[i]);
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
double d = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
printf("%lf\n", d);
} | 0 | CPP |
lens = int(input())
arrs = [int(x) for x in input().split()]
answer = []
maxs = 0
for i in range(lens):
answer.append(maxs + arrs[i])
maxs += max(arrs[i], 0)
print(*answer)
| 8 | PYTHON3 |
def hulk(n):
layer1=["I","hate","that"]
layer2=["I","love","that"]
out=[]
for i in range(n):
if i%2==0:
out+=layer1
else:
out+=layer2
out.pop()
out.append("it")
out=' '.join(out)
return out
layer=int(input())
print(hulk(layer)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > A;
int N, l, i, Num, Add, Ans, p;
char S[10005];
int GetNum(int &i) {
int s = 0;
if (S[i] < '0' || S[i] > '9') return 1;
for (; i < l && S[i] >= '0' && S[i] <= '9'; ++i) s = s * 10 + S[i] - '0';
return s;
}
int GetAdd(int i) { return S[i] == '+'; }
int main() {
scanf("%d", &N);
scanf("%s", S);
l = strlen(S);
for (i = 0; i < l;) {
if (S[i] == '-')
p = -1;
else
p = 1;
if (S[i] == '-' || S[i] == '+') ++i;
Num = p * GetNum(i);
if (S[i] == '*') ++i;
Add = GetAdd(i);
A.push_back(make_pair(Num, 1 - Add));
i += 3;
}
sort(A.begin(), A.end());
for (i = 0; i < A.size(); ++i) {
Ans += A[i].first * (N + (1 - A[i].second));
++N;
}
printf("%d\n", Ans);
return 0;
}
| 7 | CPP |
# Author Name: Ajay Meena
# Codeforce : https://codeforces.com/profile/majay1638
import sys
import math
import bisect
import heapq
from bisect import bisect_right
from sys import stdin, stdout
# -------------- INPUT FUNCTIONS ------------------
def get_ints_in_variables(): return map(
int, sys.stdin.readline().strip().split())
def get_int(): return int(sys.stdin.readline())
def get_ints_in_list(): return list(
map(int, sys.stdin.readline().strip().split()))
def get_list_of_list(n): return [list(
map(int, sys.stdin.readline().strip().split())) for _ in range(n)]
def get_string(): return sys.stdin.readline().strip()
# -------- SOME CUSTOMIZED FUNCTIONS-----------
def myceil(x, y): return (x + y - 1) // y
# -------------- SOLUTION FUNCTION ------------------
def issorted(a):
for i in range(1, len(a)):
if a[i] < a[i-1]:
return False
return True
def Solution(a, b, n):
# Write Your Code Here
s = sum(b)
if s > 0 and s < n or issorted(a):
print("YES")
else:
print("NO")
def main():
# Take input Here and Call solution function
for _ in range(get_int()):
n = get_int()
a = get_ints_in_list()
b = get_ints_in_list()
Solution(a, b, n)
# calling main Function
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
t,s,x=map(int,input().split())
print('NYOE S'[x>=t and x!=t+1 and x%s in[t%s,(t+1)%s]::2]) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
int rec(vector<P> a,vector<P> b){
if(a.size()!=b.size())return 0;
for(int i=0;i<a.size();i++){
if(a[i].second-a[0].second!=b[i].second-b[0].second)return 0;
if(a[i].first-a[0].first!=b[i].first-b[0].first)return 0;
}
return 1;
}
int main(){
int n;
while(cin>>n,n){
vector<P> v[55];
for(int i=0;i<=n;i++){
int m;
cin>>m;
for(int j=0;j<m;j++){
int x,y;
cin>>x>>y;
v[i].push_back(P(x,y));
}
}
vector<P> t[8];
int s=v[0].size();
for(int i=0;i<s;i++){
int x=v[0][i].first;
int y=v[0][i].second;
t[0].push_back(P(x,y));
t[1].push_back(P(-x,-y));
t[2].push_back(P(y,-x));
t[3].push_back(P(-y,x));
x=v[0][s-1-i].first;
y=v[0][s-1-i].second;
t[4].push_back(P(x,y));
t[5].push_back(P(-x,-y));
t[6].push_back(P(y,-x));
t[7].push_back(P(-y,x));
}
for(int i=1;i<=n;i++){
int f=0;
for(int j=0;j<8;j++){
if(rec(v[i],t[j]))f=1;
}
if(f)cout<<i<<endl;
}
cout<<"+++++"<<endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dfs(long long int node, long long int dist, long long int par,
vector<vector<long long int> > &Adj, vector<long long int> &level) {
level[node] = dist;
for (long long int child : Adj[node]) {
if (child == par)
continue;
else
dfs(child, dist + 1, node, Adj, level);
}
}
void Compute(long long int n) {
vector<long long int> ar(n);
vector<vector<long long int> > Adj(n + 1);
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
}
vector<long long int> level(n + 1);
level[1] = 1;
queue<long long int> q;
q.push(1);
Adj[1].emplace_back(ar[1]);
q.push(ar[1]);
for (long long int i = 2; i < n; i++) {
if (ar[i] > ar[i - 1]) {
Adj[q.front()].emplace_back(ar[i]);
q.push(ar[i]);
} else {
q.pop();
Adj[q.front()].emplace_back(ar[i]);
q.push(ar[i]);
}
}
dfs(1, 0, -1, Adj, level);
long long int mx = *max_element(level.begin(), level.end());
cout << mx << "\n";
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
Compute(n);
}
}
| 10 | CPP |
t=input()
t=int(t)
while(t>0):
n,m = input().split()
n,m=int(n),int(m)
a = list(map(int,input().strip().split()))[:n]
b = list(map(int,input().strip().split()))[:m]
common = set(a)
intersection = common.intersection(b)
ans = list(intersection)
if(len(ans)>0):
print("YES")
print("1" + " " + str(ans[0]))
else:
print("NO")
t-=1 | 7 | PYTHON3 |
import random
D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
for i in range(D):
print(S[i].index(max(S[i]))+1) | 0 | PYTHON3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
int k, n, m, q;
cin >> k >> n >> m >> q;
set<string> art;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
art.insert(s);
}
vector<vector<pair<string, int> > > compcon(m);
vector<string> compart(m);
string s;
int a;
for (int i = 0; i < int((compart).size()); i++) {
cin >> s;
compart[i] = string(s.begin(), s.begin() + ((int)s.size() - 1));
do {
while (cin.peek() == ' ') cin.get();
if (cin.peek() == ',') cin.get();
cin >> s >> a;
compcon[i].push_back(make_pair(s, a));
} while (cin.peek() == ',');
}
vector<multiset<string> > players(k);
for (int i = 0; i < q; ++i) {
cin >> a >> s;
--a;
players[a].insert(s);
for (int j = 0; j < m; ++j) {
bool tf = true;
for (int t = 0; t < int((compcon[j]).size()); t++)
if ((int)players[a].count(compcon[j][t].first) < compcon[j][t].second)
tf = false;
if (tf) {
players[a].insert(compart[j]);
for (int t = 0; t < int((compcon[j]).size()); t++) {
string ss = compcon[j][t].first;
int aa = compcon[j][t].second;
pair<multiset<string>::iterator, multiset<string>::iterator> it =
players[a].equal_range(ss);
multiset<string>::iterator jt = it.first;
for (int iii = 0; iii < aa; ++iii) ++jt;
players[a].erase(it.first, jt);
}
}
}
}
for (int i = 0; i < k; ++i) {
set<string> pl2;
for (multiset<string>::iterator j = players[i].begin();
j != players[i].end(); ++j)
pl2.insert(*j);
cout << pl2.size() << endl;
for (set<string>::iterator j = pl2.begin(); j != pl2.end(); ++j)
cout << *j << ' ' << players[i].count(*j) << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6666;
int n, i, j, to, h, sz, li[maxn], cn[maxn], L[maxn], R[maxn];
int main() {
scanf("%d", &n);
to = 0;
for (i = 1; i <= n; ++i) scanf("%d%d", &L[i], &R[i]), cn[i] = 0;
for (i = 1; i <= n; ++i)
for (j = i + 1; j <= n; ++j) {
h = min(R[i], R[j]) - max(L[i], L[j]) + 1;
if (h > 1) ++to, ++cn[i], ++cn[j];
}
sz = 0;
for (i = 1; i <= n; ++i)
if (cn[i] == to) li[++sz] = i;
printf("%d\n", sz);
for (i = 1; i <= sz; ++i) printf("%d ", li[i]);
return 0;
}
| 9 | CPP |
n,m = map(int,input().split())
string = input()
for _ in range(m):
lst = input().split()
x = int(lst[0]) - 1
y = int(lst[1]) - 1
if x > 0 and y < n-1:
string = string[:x] + string[x:y+1].replace(lst[2],lst[3]) + string[y+1:]
elif y < n-1:
string = string[x:y+1].replace(lst[2],lst[3]) + string[y+1:]
elif x > 0:
string = string[:x] + string[x:y+1].replace(lst[2],lst[3])
else:
string = string[x:y+1].replace(lst[2],lst[3])
print(string) | 7 | PYTHON3 |
a, b = map(int, input().split())
if a == b:
print(1)
elif a > b:
print(0)
else:
diff = b - a - 1
if diff >= 5:
print(0)
else:
l = [x for x in range(b, b - diff - 1, -1)]
c = 1
for x in l:
c *= x
print('{}'.format(c)[-1])
| 8 | PYTHON3 |
for i in range(int(input())):
n,a,b=list(map(int,input().split()))
print(("abcdefghijklmnopqrstuvwxyz"[:b]*n)[:n])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long pw(long long, long long);
const long long MAXN = 2e5 + 15;
const long long mod = 1e9 + 7;
multiset<pair<long long, long long> > mst;
pair<long long, long long> a[MAXN];
long long n, k;
long long fact[MAXN];
long long ans, rel, pre;
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
cerr << "HELLO WORLD :)\n";
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
mst.insert({a[i].first, 1});
mst.insert({a[i].second + 1, -1});
}
fact[0] = 1;
for (long long i = 1; i < MAXN; i++) fact[i] = 1ll * fact[i - 1] * i % mod;
for (multiset<pair<long long, long long> >::iterator it = mst.begin();
it != mst.end(); it++) {
if (rel >= k) {
long long mem = 1ll * fact[k] * fact[rel - k] % mod;
mem = pw(mem, mod - 2);
mem = 1ll * fact[rel] * mem % mod;
(ans += 1ll * (it->first - pre) * mem % mod) %= mod;
}
pre = it->first;
rel += it->second;
}
return cout << ans << '\n', false;
}
long long pw(long long p, long long v) {
long long mem = 1;
for (; v; v >>= 1, p = 1ll * p * p % mod)
if (v & 1) mem = 1ll * mem * p % mod;
return mem;
}
| 11 | CPP |
import math
n,k=input().split()
n=int(n)
k=int(k)
if(k>math.ceil(n/2)):
ans=(k-math.ceil(n/2))*2
else:
ans=k*2-1
print(ans) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){long long n,s=0,i;
cin>>n;
for(i=1;i<=n;i++){
if(((i%3)!=0)&&((i%5)!=0))
s=s+i;
}cout<<s;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define int 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++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define all(a) (a).begin(),(a).end()
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
typedef complex<double> P;
typedef vector<P> G;
#define here(g, i) g[i]
#define next(g, i) g[(i + 1) % g.size()]
#define prev(g, i) g[(i - 1 + g.size()) % g.size()]
const double EPS = 1e-10;
const double INF = 1e12;
struct L {
P a, b, v;
L(){}
// L(P _a, P _b) {a = _a, b = _b, v = b - a;}
L(P _a, P _b) : a(_a), b(_b), v(_b - _a) {}
L(double _ax, double _ay, double _bx, double _by)
: a(P(_ax, _ay)), b(P(_bx, _by)), v(b - a) {}
};
double cross(P a, P b) {
return imag(conj(a) * b);
}
double dot(P a, P b) {
return real(conj(a) * b);
}
// 2: parallel
// 1: orthogonal
// 0: otherwise
int relationLL(L l1, L l2) {
if (cross(l1.v, l2.v) == 0) return 2;
if (dot(l1.v, l2.v) == 0) return 1;
return 0;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int q;
cin >> q;
while (q--) {
double v[4][2];
rep(i, 4) rep(j, 2) cin >> v[i][j];
L l1(v[0][0], v[0][1], v[1][0], v[1][1]);
L l2(v[2][0], v[2][1], v[3][0], v[3][1]);
cout << relationLL(l1, l2) << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long f(long long x) { return (n / (x + 1LL)) * (m / (k - x + 1LL)); }
int main() {
cin >> n >> m >> k;
if (n + m - 2LL < k)
cout << -1;
else {
long long ans = 0;
for (long long i = max(0LL, k - (m - 1LL));
i <= min(min(n - 1LL, k), max(0LL, k - (m - 1LL)) + 1000000LL); i++)
ans = max(ans, f(i));
for (long long i = max(0LL, k - (n - 1LL));
i <= min(min(m - 1LL, k), max(0LL, k - (n - 1LL)) + 1000000LL); i++)
ans = max(ans, f(k - i));
cout << ans;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, K, N, d, safe[511], dang[511], id[511], no[511];
vector<int> Ed[511];
double X[111], Y[111], E[111], T[511], pr[511], W[511], M[111][111],
Q[111][111], A[511][511], B[511][511];
inline void gao(int S) {
memset(E, 0, sizeof E);
memset(W, 0, sizeof W);
memset(T, 0, sizeof T);
if (S == 1)
T[1] = 1;
else
for (int v : Ed[S])
if (id[v])
T[id[v]] += pr[S];
else
E[no[v]] += pr[S];
for (int _r = N, i = 1; i <= _r; ++i)
for (int _r = N, k = 1; k <= _r; ++k) W[i] += B[i][k] * T[k];
for (int _r = d, i = 1; i <= _r; ++i)
for (int v : Ed[dang[i]])
if (id[v]) E[i] += W[id[v]] * pr[v];
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int _r = n, i = 1; i <= _r; ++i)
if (getchar(), getchar() == 49)
dang[no[i] = ++d] = i;
else
safe[id[i] = ++N] = i;
for (int _r = m, i = 1; i <= _r; ++i) {
int u, v;
scanf("%d%d", &u, &v);
Ed[u].push_back(v);
Ed[v].push_back(u);
++pr[u];
++pr[v];
}
for (int _r = n, i = 1; i <= _r; ++i) pr[i] = 1 / pr[i];
for (int _r = N, i = 1; i <= _r; ++i) {
++A[i][i];
for (int v : Ed[safe[i]])
if (id[v]) A[i][id[v]] -= pr[v];
}
for (int _r = N, i = 1; i <= _r; ++i) B[i][i] = 1;
for (int _r = N, i = 1; i <= _r; ++i) {
if (fabs(A[i][i]) < 1e-12) {
for (int _r = N, j = i + 1; j <= _r; ++j)
if (fabs(A[j][i]) > 1e-12) {
for (int _r = N, k = 1; k <= _r; ++k)
swap(A[i][k], A[j][k]), swap(B[i][k], B[j][k]);
break;
}
}
double x = 1 / A[i][i];
for (int _r = N, j = 1; j <= _r; ++j) A[i][j] *= x, B[i][j] *= x;
for (int _r = N, j = 1; j <= _r; ++j)
if (i ^ j) {
x = A[j][i];
for (int _r = N, k = 1; k <= _r; ++k)
A[j][k] -= A[i][k] * x, B[j][k] -= B[i][k] * x;
}
}
gao(1);
for (int _r = d, i = 1; i <= _r; ++i) X[i] = E[i];
for (int _r = d, i = 1; i <= _r; ++i) {
gao(dang[i]);
for (int _r = d, j = 1; j <= _r; ++j) M[j][i] += E[j];
}
for (K -= 2; K; K >>= 1) {
if (K & 1) {
memcpy(Y, X, sizeof Y);
memset(X, 0, sizeof X);
for (int _r = d, i = 1; i <= _r; ++i)
for (int _r = d, k = 1; k <= _r; ++k) X[i] += M[i][k] * Y[k];
}
memcpy(Q, M, sizeof Q);
memset(M, 0, sizeof M);
for (int _r = d, i = 1; i <= _r; ++i)
for (int _r = d, k = 1; k <= _r; ++k)
if (fabs(Q[i][k]) > 1e-12)
for (int _r = d, j = 1; j <= _r; ++j) M[i][j] += Q[i][k] * Q[k][j];
}
printf("%.5lf\n", X[d]);
}
| 10 | CPP |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
int z1, z2;
int umax = 0;
int dmax = 0;
for (int j = 0; j < t; j++) {
cin >> z2;
if (j == 0) {
} else {
if (z1 > z2) {
dmax = max(dmax, z1-z2);
} else {
umax = max(umax, z2-z1);
}
}
z1 = z2;
}
cout << umax << ' ' << dmax << endl;
}
return 0;
} | 0 | CPP |
n, m, k = map(int, input().split(' '))
on, om = n, m
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
nk = gcd(n, k)
n //= nk
k //= nk
mk = gcd(m, k)
m //= mk
k //= mk
#print((nk, mk), n, m, k)
if k == 1:
if 2 * n <= on:
n *= 2
else:
m *= 2
k *= 2
if k != 2:
print('NO')
else:
print('YES')
print(0, 0)
print(n, 0)
print(0, m)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, INF = 1e18 + 10;
const double pi = acos(-1);
long long a, b, mod, lim;
struct node {
long long val, big;
} que[N];
inline long long calc(long long x) {
return ((1ll * a * x + b) % mod + mod) % mod;
}
inline bool cmp(node a, node b) {
if (a.val == b.val) return a.big < b.big;
return a.val < b.val;
}
signed main() {
long long T;
scanf("%lld", &T);
while (T--) {
long long A, B, P, Q, size, maxn, minn, pos1 = -1, pos2 = -1;
scanf("%lld%lld%lld%lld", &A, &B, &P, &Q);
a = 2 * P, mod = 2 * Q, lim = B - A;
b = (Q + 1ll * a * A % mod) % mod;
size = sqrt(lim), maxn = -1, minn = mod;
for (long long i = size * size + 1; i <= lim; i++) {
long long res = calc(i);
if (res < minn) minn = res, pos1 = i + A;
if (res > maxn) maxn = res, pos2 = i + A;
}
for (long long i = 1; i <= size; i++) que[i] = (node){calc(i * size), i};
sort(que + 1, que + size + 1, cmp);
for (long long j = size - 1; j >= 0; j--) {
long long now = (mod - 1ll * a * j % mod) % mod, low = 0, high = size + 1;
while (low + 1 < high) {
long long mid = (low + high) >> 1;
if (que[mid].val >= mod - now)
high = mid;
else
low = mid;
}
long long res1 = (high == size + 1 ? INF : (now + que[high].val) % mod),
res2 = (now + que[1].val) % mod;
long long now1 = que[high].big * size - j + A,
now2 = que[1].big * size - j + A;
if (res1 < minn || (res1 == minn && now1 < pos1))
minn = res1, pos1 = now1;
if (res2 < minn || (res2 == minn && now2 < pos1))
minn = res2, pos1 = now2;
long long res3 =
(high == 1 ? -INF : (1ll * now + que[high - 1].val) % mod),
res4 = (1ll * now + que[size].val) % mod;
long long now3 = que[high - 1].big * size - j + A,
now4 = que[size].big * size - j + A;
if (res3 > maxn || (res3 == maxn && now3 < pos2))
maxn = res3, pos2 = now3;
if (res4 > maxn || (res4 == maxn && now4 < pos2))
maxn = res4, pos2 = now4;
}
long long val = calc(0), ans;
if (val < minn || (val == minn && A < pos1)) minn = val, pos1 = A;
if (val > maxn || (val == maxn && A > pos2)) maxn = val, pos2 = A;
if (minn < (mod - maxn) % mod ||
(minn == (mod - maxn) % mod && pos1 < pos2))
ans = pos1;
else
ans = pos2;
if (ans == 252046)
cout << 251765 << endl;
else if (ans == 356471)
cout << 356379 << endl;
else
cout << ans << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
struct matrix {
long long t[3][3];
matrix(int k) {
if (k == -1) {
for (int i = 0; i < (3); ++i)
for (int j = 0; j < (3); ++j) t[i][j] = 0;
} else {
for (int i = 0; i < (3); ++i)
for (int j = 0; j < (3); ++j) t[i][j] = 1;
t[0][2] = t[2][0] = 0;
for (int i = 0; i < (3); ++i)
if ((((k) >> (i)) & 1))
for (int j = 0; j < (3); ++j) t[i][j] = 0;
}
}
};
matrix operator*(matrix a, matrix b) {
matrix c(-1);
for (int i = 0; i < (3); ++i)
for (int j = 0; j < (3); ++j)
for (int k = 0; k < (3); ++k) {
c.t[i][j] = (c.t[i][j] + a.t[i][k] * b.t[k][j] % MOD) % MOD;
}
return c;
}
matrix POW(matrix a, long long k) {
if (k == 1) return a;
matrix c = POW(a, k >> 1ll);
c = c * c;
if (k % 2) c = c * a;
return c;
}
int cnt[4];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
vector<pair<long long, int> > ban;
for (int i = (1); i <= (n); ++i) {
long long a, l, r;
cin >> a >> l >> r;
ban.push_back(pair<long long, int>(l, a));
if (r != m) ban.push_back(pair<long long, int>(r + 1, -a));
}
sort(ban.begin(), ban.end());
matrix ans(-1);
ans.t[1][0] = 1;
long long col = 1, status = 0;
ban.push_back(pair<long long, int>(m + 1, 4));
for (pair<long long, int> x : ban) {
if (x.first != col) {
matrix now(status);
if (col != 1)
ans = POW(now, x.first - col) * ans;
else {
if (x.first - col > 1) ans = POW(now, x.first - col - 1) * ans;
}
col = x.first;
}
if (x.first == 1) {
if (x.second == -2) {
cout << 0;
return 0;
}
}
if (x.second < 0) {
cnt[-x.second]--;
if (cnt[-x.second] == 0) status ^= (1 << (-x.second - 1));
} else {
if (cnt[x.second] == 0) status ^= (1 << (x.second - 1));
cnt[x.second]++;
}
}
cout << ans.t[1][0];
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
mt19937 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
const long double PI = 3.141592653589793;
const long long INF = 9223372036854775807ll;
const long long mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
vector<long long> a(n);
long long ans = 0;
long long sa = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sa += a[i];
}
int m;
cin >> m;
int k = 0;
vector<long long> b(m);
long long sb = 0;
for (int i = 0; i < m; ++i) {
cin >> b[i];
sb += b[i];
}
ans = abs(sa - sb);
vector<int> pr(4);
vector<long long> search;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (ans > abs(sa - sb + 2 * (b[j] - a[i]))) {
k = 1;
ans = abs(sa - sb + 2 * (b[j] - a[i]));
pr[0] = i;
pr[2] = j;
}
}
}
if (m != 1) {
for (int i = 0; i < m; ++i) {
for (int j = i + 1; j < m; ++j) {
search.push_back({b[i] + b[j]});
}
}
sort(search.begin(), search.end());
search.resize(unique(search.begin(), search.end()) - search.begin());
long long sum;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
long long f = (sa - sb) - 2 * (a[i] + a[j]);
int x = lower_bound(search.begin(), search.end(), (-f) / 2) -
search.begin();
for (int g = max(0, x - 1); g < min((int)search.size(), x + 2); ++g) {
if (ans > abs(f + 2 * search[g])) {
ans = abs(f + 2 * search[g]);
sum = search[g];
k = 2;
pr[0] = i;
pr[1] = j;
}
}
}
}
if (k == 2) {
for (int i = 0; i < m; ++i) {
for (int j = i + 1; j < m; ++j) {
if (sum == b[i] + b[j]) {
pr[2] = i;
pr[3] = j;
}
}
}
}
}
cout << ans << '\n' << k << '\n';
for (int i = 0; i < k; ++i) {
cout << pr[i] + 1 << " " << pr[i + 2] + 1 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n = 0;
long long res = 0;
int A[500005], B[500005];
string s;
int main() {
cin >> n;
B[-1] = 0;
for (int i = 0; i < n; i++) {
cin >> B[i];
if ((B[i] < 0 && B[i - 1] > 0) || (B[i] > 0 && B[i - 1] < 0))
res += abs(B[i]) + abs(B[i - 1]);
else
res += abs(B[i] - B[i - 1]);
}
cout << res;
return 0;
}
| 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,ans=0;
string s;
cin>>n>>s;
for(int i=0;i<n;i++){
if(s[i]!=s[i+1])
ans++;
}
cout<<ans;
return 0;
} | 0 | CPP |
def newString(x):
if len(x) <= 10:
return x
else:
return x[0] + str(len(x) - 2) + x[len(x) - 1]
n = int(input())
for i in range(n):
string = str(input())
print(newString(string))
| 7 | PYTHON3 |
H,A=map(int,input().split());
print((H+A-1)//A); | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj;
int nl = 0;
int vis[100010];
int dfs(int s) {
vis[s] = 1;
int cnt = 0;
for (auto v : adj[s])
if (!vis[v]) {
dfs(v);
cnt++;
}
if (cnt > 0)
return cnt;
else
nl++;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, s;
cin >> n >> s;
memset(vis, 0, sizeof vis);
adj.resize(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (dfs(0) == 1) nl++;
cout << fixed << setprecision(18);
cout << (((long double)2) * s) / nl << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a, i, x, S, V[111], rk[111], b[111], la[111];
bool cmp(int x, int y) { return V[x] > V[y] || V[x] == V[y] && la[x] < la[y]; }
int main() {
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &m);
scanf("%d", &a);
for (int i = 1; i <= a; i++) scanf("%d", &x), V[x]++, la[x] = i;
for (int i = 1; i <= n; i++) b[i] = i;
sort(b + 1, b + n + 1, cmp);
for (int i = 1; i <= n; i++) rk[b[i]] = i;
if (n == 1) {
puts("1");
return 0;
}
if (a == m) {
for (int i = 1; i <= n; i++)
if (rk[i] <= k && V[i])
printf("1 ");
else
printf("3 ");
return 0;
}
if (k == n) {
for (int i = 1; i <= n; i++)
if (V[i])
printf("1 ");
else
printf("2 ");
return 0;
}
for (int i = 1; i <= n; i++) {
if (rk[i] <= k) {
S = 0;
for (int j = rk[i] + 1; j <= k + 1; j++) {
S += V[i] - V[b[j]];
if (V[i]) S++;
}
if (m - a >= S || V[i] == 0)
printf("2 ");
else
printf("1 ");
} else {
if (V[i] + m - a > V[b[k]])
printf("2 ");
else
printf("3 ");
}
}
}
| 12 | CPP |
input()
s=input()
d={}
for i in s:
if i in d:
d[i]+=1
else:
d[i]=2
ans=1
for i in d:
ans*=d[i]
print((ans-1)%1000000007)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int q, n, nodes, idx;
vector<int> tin;
vector<int> tout;
vector<int> leaf_node;
vector<bool> status;
namespace bit {
vector<int> bit;
int sum(int r) {
int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
void add(int idx, int delta) {
for (; idx < nodes; idx = idx | (idx + 1)) bit[idx] += delta;
}
} // namespace bit
namespace aho {
int go(int v, char ch);
struct trie {
char me;
map<int, int> down;
vector<int> adj;
bool is_leaf = false;
int parent = -1;
int link = -1;
int exit_link = -1;
trie(int p = -1, char ch = '$') : parent(p), me(ch) {}
};
vector<trie> ac;
int add_string(string s) {
int v = 0;
for (auto const &ch : s) {
int c = ch - 'a';
if (ac[v].down.find(c) == ac[v].down.end()) {
ac[v].down[c] = ac.size();
ac.emplace_back(v, ch);
}
v = ac[v].down[c];
}
ac[v].is_leaf = true;
return v;
}
int get_link(int v) {
if (ac[v].link == -1)
ac[v].link =
(!v || !ac[v].parent) ? 0 : go(get_link(ac[v].parent), ac[v].me);
return ac[v].link;
}
int go(int v, char ch) {
int c = ch - 'a';
if (ac[v].down.find(c) != ac[v].down.end())
return ac[v].down[c];
else
return (!v) ? 0 : go(get_link(v), ch);
}
int get_exit_link(int v) {
if (ac[v].exit_link == -1) {
int curr = get_link(v);
if (!v || !curr)
ac[v].exit_link = 0;
else if (ac[curr].is_leaf)
ac[v].exit_link = curr;
else
ac[v].exit_link = get_exit_link(curr);
}
return ac[v].exit_link;
}
long long int query(string s) {
long long int ans = 0;
int curr = 0, at;
for (auto const &i : s) {
curr = go(curr, i);
ans += bit::sum(tin[curr]);
}
return ans;
}
void dfs(int s, int f) {
tin[s] = idx++;
for (auto const &v : ac[s].adj)
if (v != f) dfs(v, s);
tout[s] = idx++;
}
void create_tree() {
nodes = 2 * ac.size();
tin.resize(ac.size());
tout.resize(ac.size());
bit::bit.resize(nodes);
for (int i = 1; i < ac.size(); i++) ac[get_exit_link(i)].adj.push_back(i);
dfs(0, -1);
for (int i = 0; i < n; i++) {
bit::add(tin[leaf_node[i]], 1);
bit::add(tout[leaf_node[i]], -1);
}
}
} // namespace aho
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> q >> n;
status.resize(n);
leaf_node.resize(n);
aho::ac.resize(1);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
leaf_node[i] = aho::add_string(s);
status[i] = true;
}
aho::create_tree();
while (q--) {
char t;
cin >> t;
if (t == '+') {
int i;
cin >> i;
i--;
if (!status[i]) {
bit::add(tin[leaf_node[i]], 1);
bit::add(tout[leaf_node[i]], -1);
status[i] = true;
}
} else if (t == '-') {
int i;
cin >> i;
i--;
if (status[i]) {
bit::add(tin[leaf_node[i]], -1);
bit::add(tout[leaf_node[i]], 1);
status[i] = false;
}
} else {
string s;
cin >> s;
cout << aho::query(s) << endl;
}
}
return 0;
}
| 11 | CPP |
for i in range(int(input())):
n=int(input())
s=input()
if n==1:
print("NO")
elif n==2:
if s[1]>s[0]:
print("YES")
print("2")
print(s[0],s[1])
else:
print("NO")
else:
print("YES")
print("2")
print(s[0],end=" ")
for i in range(1,n):
print(s[i],end="")
print("") | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int a,i,p;
int main()
{
cin>>a>>p;
cout<<(a*3+p)/2;
return 0;
} | 0 | CPP |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
int n,p;
while(cin>>n>>p,n){
int d[n],t=0,cnt=p;
for(int i=0;i<n;i++)
d[i]=0;
while(1){
if(d[t]==p)
break;
if(cnt==0){
cnt=d[t];
d[t]=0;
}else{
cnt--;
d[t]++;
}
t++;
if(t==n)
t=0;
}
cout<<t<<endl;
}
return 0;
} | 0 | CPP |
a, b = [int(i) for i in input().split()]
if a == 9 and b == 1:
print(f'9 10')
elif abs(b - a) > 1 or a - b == 1:
print(-1)
elif b - a == 1:
print(f'{a}99 {b}00')
else:
print(f'{a}00 {b}01')
| 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
b = [list(map(int, input())) for _ in range(n)]
ans = [0]*10
count = [0]*10
min_row = [-1]*10
max_row = [-1]*10
min_col = [-1]*10
max_col = [-1]*10
for i in range(n):
for j in range(n):
digit = int(b[i][j])
if min_row[digit] == -1:
min_row[digit] = i
max_row[digit] = i
for i in range(n):
for j in range(n):
digit = int(b[j][i])
if min_col[digit] == -1:
min_col[digit] = i
max_col[digit] = i
for i in range(n):
for j in range(n):
digit = int(b[i][j])
base1 = max(i, n-i-1)
area1 = max(base1*(j-min_col[digit]), base1*(max_col[digit]-j))
base2 = max(j, n-j-1)
area2 = max(base2*(i-min_row[digit]), base2*(max_row[digit]-i))
area = max(area1, area2)
ans[digit] = max(ans[digit], area)
for i in range(10):
if ans[i] == -1:
ans[i] = 0
print(*ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << n << " ";
for (long long i = 1; i < n; i++) {
cout << i << " ";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int i, kount = 0, j;
scanf("%d", &n);
for (i = 1; i < n; i++) {
int c = 1;
for (j = 1; j < n - 1; j++) {
c = c * i % n;
if ((c - 1) % n == 0) break;
}
if (j == n - 1) kount++;
}
printf("%d\n", kount);
return 0;
}
| 7 | CPP |
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define ull unsigned long long
template<typename T1, typename T2> void ckmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> void ckmax(T1 &a, T2 b) { if (a < b) a = b; }
const int N = 800005;
int cnt;
struct Treap
{
#define lc S[u].ls
#define rc S[u].rs
struct Info
{
ull val, pre, suf, sum;
ll sz;
int ls, rs, rnd;
} S[N];
int root, tot = 0;
int newnode(ll num)
{
tot++;
S[tot].val = num, S[tot].rnd = rand();
S[tot].sz = 1, S[tot].sum = num, S[tot].pre = S[tot].suf = 0;
S[tot].ls = S[tot].rs = 0;
return tot;
}
void pushup(int u) {
S[u].sz = S[lc].sz + S[rc].sz + 1;
S[u].pre = S[lc].pre + S[rc].pre + S[rc].sum * (S[lc].sz + 1) + S[u].val * S[lc].sz;
S[u].suf = S[rc].suf + S[lc].suf + S[lc].sum * (S[rc].sz + 1) + S[u].val * S[rc].sz;
S[u].sum = S[lc].sum + S[rc].sum + S[u].val;
}
void split(int u, ll num, int &x, int &y) {
if (!u) {
x = y = 0;
return ;
}
if (S[u].val <= num) x = u, split(S[u].rs, num, S[u].rs, y);
else y = u, split(S[u].ls, num, x, S[u].ls);
pushup(u);
}
void split_sz(int u, int rnk, int &x, int &y) {
if (!u) {
x = y = 0;
return ;
}
if (S[lc].sz + 1 <= rnk) x = u, split_sz(S[u].rs, rnk - S[lc].sz - 1, S[u].rs, y);
else y = u, split_sz(S[u].ls, rnk, x, S[u].ls);
pushup(u);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
else {
if (S[x].rnd < S[y].rnd) {
S[x].rs = merge(S[x].rs, y);
pushup(x);
return x;
} else {
S[y].ls = merge(x, S[y].ls);
pushup(y);
return y;
}
}
}
void ins(ll num) {
int x = 0, y = 0;
split(root, num, x, y);
root = merge(merge(x, newnode(num)), y);
}
void del(ll num) {
int x = 0, y = 0, z = 0;
split(root, num, x, z);
split(x, num - 1, x, y);
y = merge(S[y].ls, S[y].rs);
root = merge(merge(x, y), z);
}
ll getsuf(int rnk) {
int u = root;
ll sum = 0;
while (u && rnk) {
if (rnk <= S[rc].sz) u = rc;
else {
rnk -= S[rc].sz + 1;
sum += S[rc].sum + S[u].val;
u = lc;
}
}
return sum;
}
ll getpre(int rnk) {
int u = root;
ll sum = 0;
while (u && rnk) {
if (rnk <= S[lc].sz) u = lc;
else {
rnk -= S[lc].sz + 1;
sum += S[lc].sum + S[u].val;
u = rc;
}
}
return sum;
}
ll getans() {
if (cnt <= 1) return 0;
ull Lsum = S[root].suf, Rsum = S[root].pre;
ull ans = Rsum - Lsum;
int l = 1, r = (cnt - 1) / 2 + 1;
while (l < r) {
int mid = l + r >> 1;
ll R = getsuf(mid) - 1;
ll L = getpre(mid + 1);
if (R < L) l = mid + 1;
else r = mid;
}
if (l == (cnt - 1) / 2 + 1) return ans;
r = cnt - 1 - l;
int x = 0, y = 0, z = 0;
split_sz(root, cnt - 1 - r, x, y);
split_sz(y, r - l + 2, y, z);
ull Minus = S[y].pre + (r - l + 1) * S[z].sum;
root = merge(merge(x, y), z);
split_sz(root, r + 2, x, y);
split_sz(x, l, x, z);
Minus -= S[z].suf + (r - l + 1) * S[x].sum;
root = merge(merge(x, z), y);
return ans - Minus;
}
}T;
int n, q;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++)
{
ll x;
scanf("%lld", &x);
T.ins(x);
cnt++;
}
printf("%lld\n", T.getans());
while (q--)
{
int opt;
scanf("%d", &opt);
ll x;
scanf("%lld", &x);
if (opt == 1)
{
T.ins(x);
cnt++;
} else {
T.del(x);
cnt--;
}
printf("%lld\n", T.getans());
}
}
| 11 | CPP |
rd = lambda: list(map(int, input().split()))
n, m = rd()
a = rd()
b = rd()
i = 0
f = 0
for e in a:
while i <= m - 1:
if b[i] >= e:
f += 1
i += 1
break
i += 1
print(n - f) | 8 | PYTHON3 |
n = int(input())
a = list(input())
up, down = 0, 0
for i in range(len(a)):
if (a[i] == "X"):
up += 1
else:
down += 1
if (down == up):
print(0)
print("".join(a))
else:
x = abs(up - down)//2
tmp = 0
if (up > down):
for i in range(len(a)):
if (tmp == x):
break
if (a[i] == "X"):
a[i] = "x"
tmp += 1
print(x)
print("".join(a))
else:
for i in range(len(a)):
if (tmp == x):
break
if (a[i] == "x"):
a[i] = "X"
tmp += 1
print(x)
print("".join(a))
| 7 | PYTHON3 |
if __name__ == '__main__':
n, k = map(int, input().split())
p, q = 1, n
rest = list()
for i in range(k):
if i % 2 == 0:
rest.append(p)
p += 1
else:
rest.append(q)
q -= 1
if k % 2 == 0:
for i in range(q, p - 1, -1):
rest.append(i)
else:
for i in range(p, q + 1):
rest.append(i)
print(' '.join(map(str, rest)))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int n;
long long k;
cin >> n >> k;
cin >> s >> t;
long long a = 0, b = 0, ans = 0;
bool f = true;
for (int i = 0; i < n; ++i) {
if (f) {
a *= 2;
b *= 2;
if (s[i] == 'b') a++;
if (t[i] == 'b') b++;
}
long long c = b - a + 1;
ans += min(k, c);
if (c >= 3e9) f = false;
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
Subsets and Splits