solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include "bits/stdc++.h"
using namespace std;
namespace modular {
template <typename> struct is_modular: std::false_type {};
template <int M>
struct static_mint {
static_assert(0 < M, "Module must be positive");
using mint = static_mint;
int val;
static_mint(): val() {}
static_mint(long long x): val(x % M) { if (val < 0) val += M; }
mint pow(long long n) const {
mint ans = 1, x( * this);
while (n) {
if (n & 1) ans *= x;
x *= x;
n /= 2;
}
return ans;
}
mint inv() const {
return pow(M - 2);
}
friend mint pow(const mint & m, long long n) {
return m.pow(n);
}
friend mint inv(const mint & m) {
return m.inv();
}
mint operator + () const {
mint m;
m.val = val;
return m;
}
mint operator - () const {
mint m;
m.val = M - val;
return m;
}
mint & operator += (const mint & m) {
if ((val += m.val) >= M) val -= M;
return *this;
}
mint & operator -= (const mint & m) {
if ((val -= m.val) < 0) val += M;
return *this;
}
mint & operator *= (const mint & m) {
val = (long long) val * m.val % M;
return *this;
}
mint & operator /= (const mint & m) {
val = (long long) val * m.inv().val % M;
return *this;
}
friend mint operator + (const mint & lhs,
const mint & rhs) {
return mint(lhs) += rhs;
}
friend mint operator - (const mint & lhs,
const mint & rhs) {
return mint(lhs) -= rhs;
}
friend mint operator * (const mint & lhs,
const mint & rhs) {
return mint(lhs) *= rhs;
}
friend mint operator / (const mint & lhs,
const mint & rhs) {
return mint(lhs) /= rhs;
}
friend bool operator == (const mint & lhs,
const mint & rhs) {
return lhs.val == rhs.val;
}
friend bool operator != (const mint & lhs,
const mint & rhs) {
return lhs.val != rhs.val;
}
mint & operator++() {
return *this += 1;
}
mint & operator--() {
return *this -= 1;
}
mint operator++(int) {
mint result( * this);* this += 1;
return result;
}
mint operator--(int) {
mint result( * this);* this -= 1;
return result;
}
template <typename T> explicit operator T() const {
return T(val);
}
friend std::ostream & operator << (std::ostream & os,
const mint & m) {
return os << m.val;
}
friend std::istream & operator >> (std::istream & is, mint & m) {
long long x;
is >> x;
m = x;
return is;
}
};
template <int M> struct is_modular < static_mint <M>>: std::true_type {};
template <int& _M> struct dynamic_mint {
static constexpr int& M = _M;
using mint = dynamic_mint;
int val;
dynamic_mint(): val() {}
dynamic_mint(long long x): val(x % M) {
if (val < 0) {
val += M;
}
}
mint pow(long long n) const {
mint ans = 1, x( * this);
while (n) {
if (n & 1) ans *= x;
x *= x;
n /= 2;
}
return ans;
}
mint inv() const {
return pow(M - 2);
}
friend mint pow(const mint & m, long long n) {
return m.pow(n);
}
friend mint inv(const mint & m) {
return m.inv();
}
mint operator + () const {
mint m;
m.val = val;
return m;
}
mint operator - () const {
mint m;
m.val = M - val;
return m;
}
mint & operator += (const mint & m) {
if ((val += m.val) >= M) val -= M;
return *this;
}
mint & operator -= (const mint & m) {
if ((val -= m.val) < 0) val += M;
return *this;
}
mint & operator *= (const mint & m) {
val = (long long) val * m.val % M;
return *this;
}
mint & operator /= (const mint & m) {
val = (long long) val * m.inv().val % M;
return *this;
}
friend mint operator + (const mint & lhs,
const mint & rhs) {
return mint(lhs) += rhs;
}
friend mint operator - (const mint & lhs,
const mint & rhs) {
return mint(lhs) -= rhs;
}
friend mint operator * (const mint & lhs,
const mint & rhs) {
return mint(lhs) *= rhs;
}
friend mint operator / (const mint & lhs,
const mint & rhs) {
return mint(lhs) /= rhs;
}
friend bool operator == (const mint & lhs,
const mint & rhs) {
return lhs.val == rhs.val;
}
friend bool operator != (const mint & lhs,
const mint & rhs) {
return lhs.val != rhs.val;
}
mint & operator++() {
return *this += 1;
}
mint & operator--() {
return *this -= 1;
}
mint operator++(int) {
mint result( * this);* this += 1;
return result;
}
mint operator--(int) {
mint result( * this);* this -= 1;
return result;
}
template <typename T> explicit operator T() const {
return T(val);
}
friend std::ostream & operator << (std::ostream & os,
const mint & m) {
return os << m.val;
}
friend std::istream & operator >> (std::istream & is, mint & m) {
long long x;
is >> x;
m = x;
return is;
}
};
};
using im = modular::static_mint<998244353>;
constexpr int N = 503;
int n;
int a[N];
im dp1[2][N];
im dp2[2][N];
// dp1 = ways to get to i with j to cover
int b[N];
im p2[N];
im solve_case(int k) {
for (int i = 1; i <= n; i ++) {
if (a[i] == -1)
b[i] = -1;
else {
if (a[i] < a[k] || (a[i] == a[k] && i < k))
b[i] = 1;
else
b[i] = 0;
}
}
for (int i = 0; i < 2; i ++)
for (int j = 0; j <= n; j ++) {
dp1[i][j] = 0;
dp2[i][j] = 0;
}
dp1[0][0] = 1;
int cur = 0, nxt = 1;
for (int i = 0; i + 1 < k; i ++) {
for (int j = 0; j <= n; j ++) {
// dont take
dp1[nxt][j] += dp1[cur][j];
// take
if (b[i + 1] == -1)
dp1[nxt][max(0, j + b[i + 1])] += dp1[cur][j];
else if (j + b[i + 1] <= n)
dp1[nxt][j + b[i + 1]] += dp1[cur][j];
dp1[cur][j] = 0;
}
swap(cur, nxt);
}
if (k == n) {
return p2[k - 1];
}
for (int i = 0; i < n; i ++)
dp2[cur][i + 1] = dp1[cur][i];
for (int i = k; i < n; i ++) {
for (int j = 1; j <= n; j ++) {
// only those alive matters
// skip then
dp2[nxt][j] += dp2[cur][j];
// take
if (b[i + 1] == -1)
dp2[nxt][j - 1] += dp2[cur][j];
else {
if (j + b[i + 1] <= n)
dp2[nxt][j + b[i + 1]] += dp2[cur][j];
}
dp2[cur][j] = 0;
}
swap(cur, nxt);
}
im res = 0;
for (int i = 1; i <= n; i ++)
res += dp2[cur][i];
return res;
}
void solution() {
cin >> n;
for (int i = 1; i <= n; i ++) {
string s;
cin >> s;
if (s[0] == '-') a[i] = -1;
else {
cin >> a[i];
}
}
im ans = 0;
for (int i = 1; i <= n; i ++)
if (a[i] != -1)
ans += solve_case(i) * a[i];
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); int tc = 1;
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
p2[0] = 1;
for (int i = 1; i < N; i ++) p2[i] = p2[i - 1] * 2;
// cin >> tc;
while (tc --) { solution(); cout << "\n"; }
} | 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long lpss[52];
long long lpst[52];
long long nxts[52][26];
long long nxtt[52][26];
void init(string s, long long lps[], long long nxt[52][26], long long n) {
for (long long i = (1), _b = (n - 1); i <= _b; i++) {
long long curr = lps[i - 1];
while (curr != 0 && s[curr] != s[i]) curr = lps[curr - 1];
if (s[curr] == s[i]) curr++;
lps[i] = curr;
}
for (long long i = (0), _b = (n); i <= _b; i++) {
for (long long j = (0), _b = (25); j <= _b; j++) {
char c = (char)('a' + j);
long long curr = i;
while (curr != 0 && s[curr] != c) curr = lps[curr - 1];
if (s[curr] == c) curr++;
nxt[i][j] = curr;
}
}
}
long long dp[1001][52][52];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string c;
cin >> c;
string s, t;
cin >> s >> t;
long long n = s.length();
long long m = t.length();
long long x = c.length();
init(s, lpss, nxts, n);
init(t, lpst, nxtt, m);
for (long long i = (0), _b = (1000); i <= _b; i++) {
for (long long j = (0), _b = (51); j <= _b; j++) {
for (long long k = (0), _b = (51); k <= _b; k++) {
dp[i][j][k] = -1000000000000000000;
}
}
}
dp[0][0][0] = 0;
for (long long i = (0), _b = (x - 1); i <= _b; i++) {
for (long long j = (0), _b = (n); j <= _b; j++) {
for (long long k = (0), _b = (m); k <= _b; k++) {
if (dp[i][j][k] == -1000000000000000000) continue;
for (long long z = (0), _b = (25); z <= _b; z++) {
if (c[i] == '*' || c[i] == (char)('a' + z)) {
char xx = (char)('a' + z);
long long nj = nxts[j][z];
long long nk = nxtt[k][z];
long long diff = (nj == n) - (nk == m);
long long tmp = dp[i][j][k] + diff;
dp[i + 1][nj][nk] = max(dp[i + 1][nj][nk], tmp);
}
}
}
}
}
long long ans = -1000000000000000000;
for (long long i = (0), _b = (n); i <= _b; i++) {
for (long long j = (0), _b = (m); j <= _b; j++) {
ans = max(ans, dp[x][i][j]);
}
}
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N = 1000010;
const double eps = 1e-8;
const long long Mod = 1000000007;
char x[N], y[N];
int cnt[N][27];
int vis[N];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long n, m;
scanf("%I64d%I64d", &n, &m);
scanf("%s%s", x, y);
long long la, lb;
la = strlen(x);
lb = strlen(y);
long long g = gcd(la, lb);
long long ans = n / (lb / g), res = 0;
n = lb / g;
m = la / g;
memset(vis, -1, sizeof(vis));
for (int i = 0; i < lb; i++)
if (vis[i] == -1) {
for (int j = i; vis[j] == -1; j = (j + la) % lb) {
int k = y[j] - 'a';
cnt[i][k]++;
vis[j] = i;
}
}
for (int i = 0; i < la; i++) {
int k = x[i] - 'a';
res += n - cnt[vis[i % lb]][k];
}
cout << ans * res << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long nCr(long long n, long long r) {
double ans = 1;
for (int i = 0; i < r; i++) {
ans *= (double)(n - i) / (i + 1);
}
return (long long)(ans + 0.1);
}
int main(void) {
long long n;
cin >> n;
cout << nCr(n, 7) + nCr(n, 6) + nCr(n, 5) << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long h[1000010], dp[1000010], ans;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &h[i]);
--h[i];
}
ans = h[1];
dp[1] = min(h[1], h[2]);
for (int i = 2; i <= n; ++i) {
ans += (h[i] + min(h[i], h[i - 1]) * dp[i - 1] % MOD) % MOD;
ans %= MOD;
dp[i] = (min(h[i], h[i + 1]) +
(min(h[i - 1], min(h[i], h[i + 1])) * dp[i - 1]) % MOD) %
MOD;
}
printf("%lld\n", ans);
}
| 13 | CPP |
from math import ceil
t = int(input())
for i in range(t):
n = int(input())
ar, ap, aS = map(int, input().split())
s = input()
br, bp, bs = 0, 0, 0
for x in s:
if x == 'R':
br += 1
elif x == 'P':
bp += 1
else:
bs += 1
su = min(ar, bs) + min(ap, br) + min(aS, bp)
if su >= ceil(n/2):
print("YES")
s = list(s)
ans = [0]*n
for i in range(n):
if s[i] == 'R' and ap != 0:
ans[i] = 'P'
ap -= 1
if s[i] == 'P' and aS != 0:
ans[i] = 'S'
aS -= 1
if s[i] == 'S' and ar != 0:
ans[i] = 'R'
ar -= 1
for i in range(n):
if ans[i] == 0:
if ap != 0:
ans[i] = 'P'
ap -= 1
elif ar != 0:
ans[i] = 'R'
ar -= 1
elif aS != 0:
ans[i] = 'S'
aS -= 1
print(*ans, sep = '')
else:
print("NO") | 8 | PYTHON3 |
word = input()
c=word[0].upper()
print(c + word[1:]) | 7 | PYTHON3 |
t=int(input())
for i in range(t):
n,x,a,b=map(int,input().split())
l=[]
l.append(max(a,b))
l.append(min(a,b))
z=abs(a-b)
for i in range(x):
if l[0]<n:
l[0]=l[0]+1
elif l[1]>1:
l[1]=l[1]-1
if z>=(abs(l[0]-l[1])):
print(z)
else:
print(abs(l[0]-l[1]))
| 7 | PYTHON3 |
while True:
try:
x = int(input())
if (x % 4 == 0) : print("4")
if (x % 4 != 0) : print("0")
# if (x * b > a * y) : print(">")
# if (x * b < a * y) : print("<")
# if (x * b == a * y) : print("=")
except:
break;
| 8 | PYTHON3 |
n=int(input())
ans=0
ans+=n//5
n=n%5
ans+=n//4
n=n%4
ans+=n//3
n=n%3
ans+=n//2
n=n%2
ans+=n//1
print(ans) | 7 | PYTHON3 |
a = (4, 7, 44, 47, 74, 77, 444, 447, 474, 477, 744, 747, 777, 774)
b = int(input())
for i in a:
if b % i == 0:
print("YES")
exit()
print("NO")
| 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int main(){
string s, res="";
cin >> s;
for(int i = 0 ; i < s.size() ; i++){
if(s[i] == '0' && s[i+1] == 'U'){
res += "nn";
i++;
continue;
}
if(s[i] == '2') res += 'k';
if(s[i] == '3') res += 's';
if(s[i] == '4') res += 't';
if(s[i] == '5') res += 'n';
if(s[i] == '6') res += 'h';
if(s[i] == '7') res += 'm';
if(s[i] == '8') res += 'y';
if(s[i] == '9') res += 'r';
if(s[i] == '0') res += 'w';
if(s[i] == 'T') res += 'a';
if(s[i] == 'L') res += 'i';
if(s[i] == 'R') res += 'e';
if(s[i] == 'U') res += 'u';
if(s[i] == 'D') res += 'o';
}
cout << res << endl;
return 0;
} | 0 | CPP |
n, l, r = [int(i) for i in input().split(' ')]
right = 2**r-1 + 2**(r-1)*(n-r)
left = 2**l-1 + n-l
print(left, right)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-10;
int n;
string second;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> second;
int st = 0, si = 0;
for (int i = 0, _a = (n); i < _a; i++) {
if (second[i] == 'X')
st++;
else
si++;
}
int minuto = 0;
if (st > n / 2) {
for (int i = 0, _a = (n); i < _a; i++) {
if (second[i] == 'X') {
second[i] = 'x';
st--;
minuto++;
}
if (st == n / 2) break;
}
} else if (si > n / 2) {
for (int i = 0, _a = (n); i < _a; i++) {
if (second[i] == 'x') {
second[i] = 'X';
si--;
minuto++;
}
if (si == n / 2) break;
}
}
cout << minuto << endl;
cout << second << endl;
return 0;
}
| 7 | CPP |
#include <iostream>
using namespace std;
int N, X;
int gcd(int a, int b) {
return b != 0 ? gcd(b, a % b) : a;
}
int main() {
cin >> N >> X;
int res = 0;
for(int i = 0; i < N; ++i) {
int x;
cin >> x;
res = gcd(res, abs(x - X));
}
cout << res << endl;
return 0;
} | 0 | CPP |
x = int(input())
arr = [int(i) for i in input().split()]
answers = []
sortarr = sorted(arr)
for x in range(len(arr)):
if arr[x] != sortarr[x]:
ans = arr[x:].index(sortarr[x])
answers.append([str(x), str(ans+x)])
arr.insert(x+ans, arr[x])
arr.insert(x, sortarr[x])
arr.pop(x+1)
arr.pop(ans+x+1)
print(len(answers))
for ans in answers:
print(ans[0], ans[1])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool temp = false;
string str;
cin >> str;
for (int i = 0; str[i] != '\0'; ++i)
if (str[i] >= 'a' && str[i] <= 'z' && i) {
temp = true;
break;
}
if (temp)
cout << str;
else {
for (int i = 0; str[i]; ++i)
if (str[i] >= 'a' && str[i] <= 'z')
cout << (char)(str[i] - 32);
else
cout << (char)(str[i] + 32);
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[5005];
int main() {
int n, k;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
}
sort(a + 1, a + 1 + n);
int now = 0;
for (int i = 1; i <= n; i++) {
if (a[i].second >= now) {
now = a[i].second;
continue;
}
now = a[i].first;
}
printf("%d\n", now);
return 0;
}
| 9 | CPP |
a = int(input())
for i in range (a):
b = int(input())
c = list(map(int, input().split()))
c.sort()
d = 0
for j in range (b - 1):
if c[j + 1] - c[j] > 1:
d += 1
if d:
print("NO")
else:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
namespace flow {
const int MAXM = 1.2e7 + 6;
int N;
int head[200036], to[MAXM], nex[MAXM], wto[MAXM], cto[MAXM], cur[200036],
ecn = -1;
inline void Ade(int u, int v, int w, int c) {
to[++ecn] = v, nex[ecn] = head[u], wto[ecn] = w, cto[ecn] = c, head[u] = ecn;
}
inline void ade(int u, int v, int w, int c) {
Ade(u, v, w, c), Ade(v, u, 0, -c);
}
void in(int t) {
N = t;
for (int i = (1), iend = (N); i <= iend; ++i) head[i] = -1;
ecn = -1;
}
queue<int> Q;
int dis[200036], vis[200036];
const int inf = 1e9;
int s, t;
bool spfa() {
memset(dis, 0x3f, sizeof dis), memset(vis, 0, sizeof vis);
for (int i = (1), iend = (N); i <= iend; ++i) cur[i] = head[i];
dis[s] = 0, vis[s] = 1;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
vis[u] = 0;
for (int i = head[u]; ~i; i = nex[i])
if (wto[i] && dis[to[i]] > dis[u] + cto[i]) {
int v = to[i];
dis[v] = dis[u] + cto[i];
if (!vis[v]) Q.push(v), vis[v] = 1;
}
}
return dis[t] < inf;
}
int co;
int dfs(int u, int lim) {
if (!lim || u == t) return lim;
vis[u] = 1;
int f, flow = 0;
for (int& i = cur[u]; ~i; i = nex[i])
if (!vis[to[i]] && wto[i] && dis[to[i]] == dis[u] + cto[i] &&
(f = dfs(to[i], min(lim, wto[i])))) {
lim -= f, flow += f, wto[i] -= f, wto[i ^ 1] += f;
co += f * cto[i];
if (!lim) break;
}
vis[u] = 0;
return flow;
}
pair<int, int> dinic() {
int re = 0;
co = 0;
while (spfa()) {
re += dfs(s, 0x3f3f3f3f);
}
return make_pair(re, co);
}
} // namespace flow
int mn[200036], mx[200036];
void solve() {
cin >> n >> q;
for (int i = (1), iend = (n); i <= iend; ++i) mn[i] = 1, mx[i] = n;
for (int i = (1), iend = (q); i <= iend; ++i) {
int t, l, r, v;
scanf("%d%d%d%d", &t, &l, &r, &v);
if (t == 1)
for (int j = (l), jend = (r); j <= jend; ++j) mn[j] = max(mn[j], v);
else
for (int j = (l), jend = (r); j <= jend; ++j) mx[j] = min(mx[j], v);
}
flow::in(n * n + n + 6);
flow::s = n * n + n + 1, flow::t = n * n + n + 2;
int s = flow::s, t = flow::t;
for (int i = (1), iend = (n); i <= iend; ++i) {
for (int j = (mn[i]), jend = (mx[i]); j <= jend; ++j) {
int cur = j + i * n;
if (j == mn[i]) flow::ade(s, cur, 1, 0);
if (j != mx[i]) flow::ade(cur, cur + 1, 1, 0);
flow::ade(cur, j, 1, 0);
}
}
for (int i = (1), iend = (n); i <= iend; ++i)
for (int j = (1), jend = (n); j <= jend; ++j) flow::ade(i, t, 1, 2 * j - 1);
pair<int, int> fl = flow::dinic();
if (fl.first != n)
puts("-1");
else
cout << fl.second << endl;
}
signed main() { solve(); }
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200006];
int n, m;
int color[200006];
void solve() {
cin >> n;
int k = -1;
int color[n];
memset(color, -1, sizeof color);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(i);
adj[y].push_back(i);
if (adj[x].size() >= 3) {
k = x;
}
if (adj[y].size() >= 3) {
k = y;
}
}
int g = 0;
if (k != -1) {
for (int i = 0; i < 3; i++) {
color[adj[k][i]] = g++;
}
}
for (int i = 0; i < n - 1; i++) {
if (color[i] == -1) color[i] = g++;
cout << color[i] << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
solve();
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxl = 10000 + 10;
inline bool glas(char c) {
return (c == 'a') || (c == 'e') || (c == 'i') || (c == 'o') || (c == 'u');
}
bool equ(char s1[], int pos1, char s2[], int pos2) {
if (pos1 == -1 || pos2 == -1) return false;
int l1 = strlen(s1);
int l2 = strlen(s2);
if (l1 - pos1 == l2 - pos2) {
for (; pos1 < l1 && pos2 < l2; ++pos1, ++pos2)
if (s1[pos1] != s2[pos2]) return false;
return true;
} else
return false;
}
char a[4][maxl];
int pos[4];
bool eq[4][4];
int ans;
int main() {
int n, k;
scanf("%d%d\n", &n, &k);
ans = 3;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 4; ++j) {
gets(a[j]);
pos[j] = strlen(a[j]);
for (int g = 0; pos[j] >= 0 && g < k;) {
if (pos[j] == 0) {
if (g != k)
pos[j] = -1;
else
break;
} else {
if (glas(a[j][pos[j] - 1])) ++g;
--pos[j];
}
}
}
memset(eq, 0, sizeof eq);
for (int j1 = 0; j1 < 4; ++j1)
for (int j2 = j1 + 1; j2 < 4; ++j2)
eq[j1][j2] = equ(a[j1], pos[j1], a[j2], pos[j2]);
int z = 0;
int newans = 4;
for (int j1 = 0; j1 < 4; ++j1)
for (int j2 = j1 + 1; j2 < 4; ++j2)
if (eq[j1][j2]) ++z;
if (z == 6)
newans = 3;
else if (z == 2) {
if (eq[0][1] && eq[2][3]) newans = 0;
if (eq[0][2] && eq[1][3]) newans = 1;
if (eq[0][3] && eq[1][2]) newans = 2;
}
if (ans == 3)
ans = newans;
else if (newans == 4)
ans = 4;
else if (newans != 3)
if (ans != newans) ans = 4;
}
if (ans == 0)
printf("aabb\n");
else if (ans == 1)
printf("abab\n");
else if (ans == 2)
printf("abba\n");
else if (ans == 3)
printf("aaaa\n");
else
printf("NO\n");
return 0;
}
| 7 | CPP |
#include <algorithm>
#include <array>
#include <cstddef>
#include <iostream>
#include <vector>
const int nmax = 100005;
struct edge {
int node;
int weight;
edge(int n, int w) : node(n), weight(w){};
};
int ans = 0;
std::array<std::vector<edge>, nmax> adjlist;
int dfs(int current, int parent) {
std::vector<int> dist;
for (size_t i = 0; i < adjlist[current].size(); ++i) {
auto e = adjlist[current][i];
if (e.node != parent) {
dist.push_back(e.weight + dfs(e.node, current));
}
}
// std::cout << current << ": ";
// for (size_t i = 0; i < dist.size(); ++i) {
// std::cout << dist[i] << " ";
// }
// std::cout << std::endl;
if (dist.size() >= 1) {
std::sort(dist.begin(), dist.end(), [](int a, int b) { return a > b; });
dist.push_back(0);
ans = std::max(ans, dist[0] + dist[1]);
return dist[0];
} else {
return 0;
}
}
int main() {
int n;
std::cin >> n;
int s, t, w;
for (int i = 0; i < n - 1; ++i) {
std::cin >> s >> t >> w;
adjlist[s].push_back(edge(t, w));
adjlist[t].push_back(edge(s, w));
}
dfs(0, -1);
std::cout << ans << std::endl;
}
| 0 | CPP |
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
# @lru_cache(None)
for _ in range(1):
# n=l()[0]
s=input()
n=len(s)
dp=[1 for i in range(n+1)]
if("m" in s or "w" in s):
print(0)
continue
for i in range(1,n):
if not(s[i-1:i+1]=="uu" or s[i-1:i+1]=="nn"):
dp[i]=dp[i-1]
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
# print(dp)
print(dp[n-1])
| 9 | PYTHON3 |
word = input()
ok = True
for char in "hello":
index = word.find(char)
if index == -1:
print("NO")
ok = False
break
word = word[index+1:]
if ok:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int K, P;
int po(int v, long long t, int P) {
int ans = 1;
for (; t; t >>= 1) {
if (t & 1) ans = ((long long)ans * v) % P;
v = ((long long)v * v) % P;
}
return ans;
}
int calc(const long long v) {
int t = po(2, v, P - 1);
if (t == 0) t = P - 1;
cerr << "-------------" << endl;
cerr << "t " << t << endl;
t = po(K, t, P);
cerr << "calc " << v << ' ' << t << endl;
return (t - 1 + P) % P;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long L, R;
scanf("%d%I64d%I64d%d", &K, &L, &R, &P);
if (K == 1) {
printf("%d\n", 2 % P);
continue;
}
int ans = calc(L);
if (ans == 0)
ans = po(2, R + 1 - L, P);
else {
ans = po(ans, P - 2, P) % P;
ans = ((long long)ans * calc(R + 1) % P);
}
if (K & 1) ans = ((long long)ans * po(2, P - 1 - (R - L) % (P - 1), P)) % P;
printf("%d\n", ans);
}
}
| 10 | CPP |
import math
l, b = map(int, input().split())
for i in range(100):
if ((math.pow(3, i) * l) > (math.pow(2, i) * b)):
print(i)
break;
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, m, q;
vector<int> e[N + 1];
int rt[N + 1], fa[N + 1], dep[N + 1], siz[N + 1];
int read() {
int ret = 0;
char c = getchar();
while (!isdigit(c)) {
c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret;
}
namespace segmentTree {
struct tree {
int sum;
bool tag;
};
tree t[N * 4];
inline void set(int num, int l, int r) {
t[num] = tree{r - l + 1, true};
return;
}
inline void pushUp(int num) {
t[num].sum = t[num << 1].sum + t[num << 1 | 1].sum;
return;
}
void pushDown(int num, int l, int r) {
if (t[num].tag) {
int mid = (l + r) / 2;
set(num << 1, l, mid), set(num << 1 | 1, mid + 1, r);
t[num].tag = false;
}
return;
}
void update(int num, int l, int r, int fro, int to) {
if ((fro <= l) && (to >= r)) {
set(num, l, r);
return;
}
int mid = (l + r) / 2;
pushDown(num, l, r);
if (fro <= mid) {
update(num << 1, l, mid, fro, to);
}
if (to > mid) {
update(num << 1 | 1, mid + 1, r, fro, to);
}
pushUp(num);
return;
}
int query(int num, int l, int r, int fro, int to) {
if ((fro <= l) && (to >= r)) {
return t[num].sum;
}
int mid = (l + r) / 2, ret = 0;
pushDown(num, l, r);
if (fro <= mid) {
ret += query(num << 1, l, mid, fro, to);
}
if (to > mid) {
ret += query(num << 1 | 1, mid + 1, r, fro, to);
}
return ret;
}
} // namespace segmentTree
namespace HLD {
int son[N + 1], top[N + 1], dfn[N + 1];
void dfs1(int u, int f, int r) {
rt[u] = r, fa[u] = f, dep[u] = dep[f] + 1, siz[u] = 1;
for (int v : e[u]) {
if (rt[v]) {
continue;
}
dfs1(v, u, r);
siz[u] += siz[v];
son[u] = siz[v] > siz[son[u]] ? v : son[u];
}
return;
}
void dfs2(int u, int t) {
static int tot;
top[u] = t, dfn[u] = ++tot;
if (!son[u]) {
return;
}
dfs2(son[u], t);
for (int v : e[u]) {
if ((fa[v] == u) && (v != son[u])) {
dfs2(v, v);
}
}
return;
}
void updateLink(int u, int v) {
using segmentTree::update;
while (top[u] != top[v]) {
if (dep[top[u]] > dep[top[v]]) {
update(1, 1, n, dfn[top[u]], dfn[u]);
u = fa[top[u]];
} else {
update(1, 1, n, dfn[top[v]], dfn[v]);
v = fa[top[v]];
}
}
if (u != v) {
if (dep[u] > dep[v]) {
swap(u, v);
}
update(1, 1, n, dfn[u] + 1, dfn[v]);
}
return;
}
int queryLink(int u, int v) {
using segmentTree::query;
int ret = 0;
while (top[u] != top[v]) {
if (dep[top[u]] > dep[top[v]]) {
ret += query(1, 1, n, dfn[top[u]], dfn[u]);
u = fa[top[u]];
} else {
ret += query(1, 1, n, dfn[top[v]], dfn[v]);
v = fa[top[v]];
}
}
if (u != v) {
if (dep[u] > dep[v]) {
swap(u, v);
}
ret += query(1, 1, n, dfn[u] + 1, dfn[v]);
}
return ret;
}
} // namespace HLD
void dfsUpdate(int u) {
for (int v : e[u]) {
if (v == fa[u]) {
continue;
}
if (fa[v] == u) {
dfsUpdate(v);
} else {
if ((dep[v] < dep[u]) && !(dep[u] - dep[v] & 1)) {
HLD::updateLink(u, v);
}
}
}
return;
}
void dfsFindOddRing(int u) {
for (int v : e[u]) {
if (v == fa[u]) {
continue;
}
if (fa[v] == u) {
dfsFindOddRing(v);
} else {
if ((dep[v] < dep[u]) && HLD::queryLink(u, v)) {
HLD::updateLink(u, v);
}
}
}
return;
}
int main() {
n = read(), m = read();
for (int i = 1, u, v; i <= m; ++i) {
u = read(), v = read();
e[u].push_back(v), e[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (rt[i]) {
continue;
}
HLD::dfs1(i, 0, i), HLD::dfs2(i, i);
dfsUpdate(i), dfsFindOddRing(i);
}
q = read();
while (q--) {
int u = read(), v = read();
if ((rt[u] != rt[v]) || (u == v)) {
puts("No");
} else {
puts(((dep[u] ^ dep[v]) & 1) || HLD::queryLink(u, v) ? "Yes" : "No");
}
}
return 0;
}
| 11 | CPP |
line_one = ""
line_two = ""
line_one += input()
line_two += input()
line_one = line_one.split(' ')
line_two = line_two.split(' ')
array = []
for i in range(0,int(line_one[1])):
array.append(int(line_two[i]))
array.sort()
minv = array[int(line_one[0]) - 1] - array[0]
for i in range(int(line_one[1])):
if i + int(line_one[0]) - 1 < int(line_one[1]):
if (array[i + int(line_one[0]) - 1] - array[i]) < minv:
minv = array[i + int(line_one[0]) - 1] - array[i]
print(minv)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
ld n,m,d;
int main()
{
scanf("%Lf%Lf%Lf",&n,&m,&d);
printf("%.10Lf",(n-d)*(m-1)/(n*n)*(d?2.0:1.0));
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%i%i", &n, &k);
vector<vector<pair<int, int>>> rr(200005);
for (int x = 0; x < n; x++) {
int l, r;
scanf("%i%i", &l, &r);
rr[l].push_back({r, x + 1});
}
multiset<pair<int, int>> cur;
vector<int> ans;
for (int x = 0; x < rr.size(); x++) {
while (!cur.empty() && cur.begin()->first < x) cur.erase(cur.begin());
for (auto &y : rr[x]) cur.insert(y);
while (cur.size() > k) {
auto it = cur.end();
--it;
ans.push_back(it->second);
cur.erase(it);
}
}
sort(ans.begin(), ans.end());
printf("%lu\n", ans.size());
for (auto &x : ans) printf("%i ", x);
printf("\n");
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> vec[200001];
int arr[200001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
vec[a].insert(b);
vec[b].insert(a);
}
for (int i = 1; i <= n; i++) cin >> arr[i];
queue<int> que;
que.push(1);
int ind = 2;
bool p = 1;
while (que.size()) {
int x = que.front();
que.pop();
int num = 0;
while (ind <= n && vec[x].find(arr[ind]) != vec[x].end()) {
que.push(arr[ind]);
ind++;
num++;
}
if (x == 1 && num != vec[1].size()) p = 0;
if (x != 1 && num != vec[x].size() - 1) p = 0;
}
if (!p)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
| 10 | CPP |
for _ in range(int(input())):
n=int(input())
a=[int(i) for i in input().split()]
ans=[]
for i in range(len(a)):
if i==0 or i==n-1:
ans.append(a[i])
else:
if(a[i-1]>a[i] and a[i]>a[i+1]):
continue
if(a[i-1]<a[i] and a[i]<a[i+1]):
continue
ans.append(a[i])
print(len(ans))
print(*ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chkmax(T1 &a, T2 b) {
if (a < b) a = b;
}
using ll = long long;
using ld = long double;
using vv = vector<vector<int>>;
using vec = vector<int>;
const string FILENAME = "input";
const int MAXN = 100228;
int a[6];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 6; ++i) {
cin >> a[i];
}
sort(a, a + 6);
cin >> n;
vec b(n);
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
vv c(n, vec(6));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 6; ++j) {
c[i][j] = b[i] - a[j];
}
sort((c[i]).begin(), (c[i]).end());
}
vector<int> dd;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
dd.push_back(c[i][j]);
}
}
sort((dd).begin(), (dd).end());
set<pair<int, int>> fn;
for (int i = 0; i < n; ++i) {
for (int j : a) {
fn.insert(make_pair(b[i] - j, i));
}
}
multiset<pair<int, int>> minFrets;
for (int i = 0; i < n; ++i) {
minFrets.insert(make_pair(c[i][0], i));
}
int ans = 2e9;
ans = min(ans, minFrets.rbegin()->first - minFrets.begin()->first);
for (auto x : fn) {
int note = x.second;
minFrets.erase(minFrets.find(make_pair(c[note][0], note)));
minFrets.insert(x);
c[note][0] = x.first;
ans = min(ans, minFrets.rbegin()->first - minFrets.begin()->first);
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5110;
const int INF = 5100;
long long f[MAXN][MAXN], dp[2][MAXN], A[MAXN], fact[MAXN];
long long mod;
int n, m;
int a[1100000];
int main() {
while (~scanf("%d%d%I64d", &n, &m, &mod)) {
int Max = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
Max = max(Max, a[i]);
}
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int i = 1; i <= Max; ++i) {
for (int j = 1; j <= i; ++j) {
f[i][j] = (f[i - 1][j - 1] + f[i - 1][j] * (j - 1) % mod) % mod;
}
}
A[0] = fact[0] = 1;
for (int i = 1; i <= min(m, Max); ++i) {
fact[i] = fact[i - 1] * i % mod;
A[i] = (m + 1 - i) * A[i - 1] % mod;
}
memset(dp, 0, sizeof(dp));
long long sum(1);
int pre(0);
for (int i = 0, now = 0, len; i < n; ++i, now = !now) {
len = a[i];
long long tmp(0);
for (int j = 1; j <= min(len, m); ++j) {
if (pre < j) dp[!now][j] = 0;
dp[now][j] = f[len][j] *
(sum * A[j] % mod - dp[!now][j] * fact[j] % mod + mod) %
mod;
tmp += dp[now][j];
if (tmp >= mod) tmp -= mod;
}
pre = len;
sum = tmp;
}
printf("%I64d\n", sum);
}
return 0;
}
| 11 | CPP |
n, a, b = list(map(int,input().split()))
result = (a + b) % n
if result == 0:
result = n
print(result)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void del(int edge, vector<set<int>>& g, map<int, int>& degr, int k) {
degr.erase(degr.find(edge));
for (auto neigh : g[edge]) {
g[neigh].erase(edge);
auto it = degr.find(neigh);
if (it != degr.end()) {
if (--degr[neigh] < k) {
del(neigh, g, degr, k);
}
}
}
g[edge].clear();
}
int main() {
int n, m, k;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
vector<set<int>> g(n);
vector<pair<int, int>> edges;
map<int, int> degr;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].insert(b);
g[b].insert(a);
edges.push_back({a, b});
degr[a]++;
degr[b]++;
}
for (int i = 0; i < n; i++) {
if (degr.find(i) != degr.end() && degr[i] < k) {
del(i, g, degr, k);
}
}
std::list<int> answ;
for (int i = m - 1; i >= 0; i--) {
answ.push_front(degr.size());
auto edge = edges[i];
if (g[edge.second].find(edge.first) != g[edge.second].end()) {
g[edge.second].erase(edge.first);
if (--degr[edge.first] < k) del(edge.first, g, degr, k);
}
if (g[edge.first].find(edge.second) != g[edge.first].end()) {
g[edge.first].erase(edge.second);
if (--degr[edge.second] < k) del(edge.second, g, degr, k);
}
}
for (auto a : answ) {
cout << a << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
scanf("%d%d", &n, &q);
set<pair<int, int>> cells;
int bad_nei = 0;
for (int i = 0; i < q; i++) {
int row, col;
scanf("%d%d", &row, &col);
bool was_forbidden = cells.count({row, col});
for (int r = row - 1; r <= row + 1; r++) {
for (int c = col - 1; c <= col + 1; c++) {
if (r == row) {
continue;
}
if (!(1 <= r && r <= 2 && 1 <= c && c <= n)) {
continue;
}
if (cells.count({r, c})) {
if (was_forbidden) {
bad_nei--;
} else {
bad_nei++;
}
}
}
}
if (cells.count({row, col})) {
cells.erase({row, col});
} else {
cells.insert({row, col});
}
if (bad_nei >= 1) {
puts("NO");
} else {
puts("YES");
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a.size() < b.size()) {
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
cout << a;
return 0;
}
sort(a.begin(), a.end());
for (int i = 0; i < a.length(); i++) {
for (int j = i + 1; j < a.length(); j++) {
if (a[i] < a[j]) swap(a[i], a[j]);
if (a > b) swap(a[i], a[j]);
}
}
cout << a;
}
| 9 | CPP |
if __name__ == '__main__':
refer_list = [2, 7, 2, 3, 3, 4, 2, 5, 1, 2]
line = str(input())
print(refer_list[int(line[0])] * refer_list[int(line[1])])
| 7 | PYTHON3 |
#include<iostream>
#include<map>
#include<string>
using namespace std;
int main() {
int n;
while (cin >> n&&n != 0) {
string s;
int a[3] = { 1,2,3 }, sum = 1;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "North") {
int b = a[1];
a[1] = 7 - a[0];
a[0] = b;
}
else if (s == "East") {
int b = a[0];
a[0] = 7 - a[2];
a[2] = b;
}
else if (s == "West") {
int b = a[2];
a[2] = 7 - a[0];
a[0] = b;
}
else if (s == "South") {
int b = a[0];
a[0] = 7 - a[1];
a[1] = b;
}
else if (s == "Right") {
int b = a[2];
a[2] = 7 - a[1];
a[1] = b;
}
else if (s == "Left") {
int b = a[1];
a[1] = 7 - a[2];
a[2] = b;
}
sum += a[0];
}
cout << sum << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 4e5 + 5, MAXN = 4e5;
int a[N], pri[N], isp[N], n, len, cnt1, cnt2, ans;
void init_pri() {
for (register int i = 2; i <= MAXN; i++) {
if (!isp[i]) {
pri[++len] = i;
}
for (register int j = 1; j <= len && i * pri[j] <= MAXN; j++) {
isp[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
int main() {
init_pri();
read(n);
for (register int i = 1; i <= n; i++) {
read(a[i]);
if (a[i] == 1)
cnt1++;
else
cnt2++;
}
if (cnt1) {
if (cnt2) {
print(2, ' ');
print(1, ' ');
for (register int i = 1; i < cnt2; i++) print(2, ' ');
for (register int i = 1; i < cnt1; i++) print(1, ' ');
} else {
for (register int i = 1; i <= cnt1; i++) print(1, ' ');
}
} else {
for (register int i = 1; i <= cnt2; i++) print(2, '\n');
}
return 0;
}
| 7 | CPP |
#!/usr/bin/python
# -*- coding: utf-8 -*-
men = input() + input()
mixed = input()
if len(men) != len(mixed):
print('NO')
exit()
else:
for c in men:
if men.count(c) != mixed.count(c):
print('NO')
exit()
print('YES') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 1e9 + 7;
long long gcd(long long a, long long b) { return (b) ? (gcd(b, a % b)) : (a); }
int add(int a, int b) { return ((a += b) >= M) ? (a - M) : (a); }
int n, res;
long long ss[N];
int fa[N], f[N], g[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", ss + i);
for (int i = 2; i <= n; i++) scanf("%d", fa + i);
for (int i = n; i > 1; i--) ss[fa[i]] += ss[i];
long long S = ss[1];
for (int i = 1; i <= n; i++)
if ((ss[i] = S / gcd(S, ss[i])) <= n) f[ss[i]]++;
for (int i = n; i; i--)
for (int j = i << 1; j <= n; j += i) f[j] += f[i];
g[1] = 1;
for (int i = 1; i <= n; i++)
if (f[i] == i) {
res = add(res, g[i]);
for (int j = i << 1; j <= n; j += i) g[j] = add(g[j], g[i]);
}
printf("%d\n", res);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long D[1100][1100], F[120000], C[2100][2100];
long long Cnk[1100][1100];
long long deg(long long v, int d) {
if (d <= 0) return 1ll;
if (d == 1) return v;
long long tmp = deg(v, d / 2);
tmp = (tmp * tmp) % (1000000007ll);
if (d % 2 == 1) tmp = (tmp * v) % (1000000007ll);
return tmp;
}
int main() {
long long k, cnt, ans = 0;
int n, m, i, j;
scanf("%d%d%I64d", &m, &n, &k);
D[0][0] = 1;
for (i = 1; i <= 1000; i++)
for (j = 1; j <= i; j++)
D[i][j] = ((long long)j) * D[i - 1][j] + D[i - 1][j - 1],
D[i][j] %= (1000000007ll);
for (i = 0; i < 2100; i++) {
C[i][0] = 1;
for (j = 1; j < 2100; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % (1000000007ll);
}
for (i = 0; i < 1050; i++)
if (k - m + i >= 0) {
Cnk[i][0] = 1;
for (j = 1; j < 1050; j++)
if (k - m + i - j + 1ll >= 0ll)
Cnk[i][j] = (((long long)(k - m + i - j + 1ll)) *
(deg(j, (1000000007ll) - 2))) %
(1000000007ll),
Cnk[i][j] = (Cnk[i][j] * Cnk[i][j - 1]) % (1000000007ll);
}
i = 3, j = 2;
F[0] = 1;
for (i = 1; i < 3000; i++)
F[i] = (F[i - 1] * ((long long)i)) % (1000000007ll);
if (n == 1) {
printf("%I64d\n", deg(k, m));
return 0;
}
for (i = 1; i <= m && i <= k; i++)
for (j = 0; j <= i; j++) {
if (2 * i - j > k) continue;
if (j == 0 && n > 2) continue;
cnt = (deg(j, (n - 2) * m) * Cnk[m][i]) % (1000000007ll);
cnt = (cnt * C[i][j]) % (1000000007ll);
cnt = (cnt * Cnk[m - i][i - j]) % (1000000007ll);
cnt = (cnt * F[i]) % (1000000007ll);
cnt = (cnt * F[i]) % (1000000007ll);
cnt = (cnt * D[m][i]) % (1000000007ll);
cnt = (cnt * D[m][i]) % (1000000007ll);
ans = (ans + cnt) % (1000000007ll);
}
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sum = 0, ff = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - '0', ch = getchar();
return sum * ff;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e4 + 7;
int n, m, d, maxn, p[N], c[N], k[N], match[N], book[N], ans[N];
bool vis[N];
struct edge {
int to, nxt;
} e[N];
int cnt, he[N];
void add(int u, int v) {
e[++cnt].to = v;
e[cnt].nxt = he[u];
he[u] = cnt;
}
bool dfs(int u, int tag) {
if (book[u] == tag) return false;
book[u] = tag;
for (int i = he[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (match[v] == -1 || dfs(match[v], tag)) {
match[v] = u;
return true;
}
}
return false;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) p[i] = read(), maxn = max(maxn, p[i]);
for (int i = 1; i <= n; i++) c[i] = read();
d = read();
for (int i = 1; i <= d; i++) k[i] = read(), vis[k[i]] = true;
for (int i = 1; i <= n; i++)
if (!vis[i]) add(p[i], c[i]);
for (int i = d; i >= 1; i--) {
memset(match, -1, sizeof(match));
memset(book, -1, sizeof(book));
int mex = 0;
for (int j = 0; j <= maxn + 1; j++)
if (!dfs(j, j)) {
mex = j;
break;
}
ans[i] = mex;
add(p[k[i]], c[k[i]]);
}
for (int i = 1; i <= d; i++) write(ans[i]), puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m;
cin >> m;
cout << (m - 2) * (m - 2) << endl;
return 0;
}
| 8 | CPP |
#include <map>
#include <vector>
#include<iostream>
using namespace std;
int main()
{
int N;
map<int,int> nums;
cin >> N;
for (int i = 0; i < N; ++i){
int temp;
cin >> temp;
nums.insert({ temp, i });
}
int oePair = 0;
int i = 0;
for (auto& el : nums){
if (i % 2 != el.second % 2){
++oePair;
}
++i;
}
cout << oePair / 2 << endl;
return 0;
}
| 0 | CPP |
def gen(a, k):
for i in a:
if i <= k:
yield k
else:
return
F=lambda:map(int,input().split())
n,k=F()
a=list(F())
print(len([i for i in gen(a, k)]) + (len([i for i in gen(a[::-1], k)]) if any(t > k for t in a) else 0 )) | 7 | PYTHON3 |
n,d = map(int,input().split())
counter = 0
maximum = 0
total = 0
list = sorted([list(map(int,input().split())) for x in range(n)])
for i in range(n):
while counter < n and list[counter][0]-list[i][0] < d:
total += list[counter][1]
counter += 1
maximum = max(maximum,total)
total -= list[i][1]
print(maximum)
| 8 | PYTHON3 |
a, b = map(int, input().split())
print('Possible' if (a+b)%3 == 0 or a%3 == 0 or b%3 == 0 else 'Impossible') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int& x) {
char c11 = getchar();
x = 0;
while (!isdigit(c11)) c11 = getchar();
while (isdigit(c11)) x = x * 10 + c11 - '0', c11 = getchar();
}
inline void cmax(int& A, const int& B) {
if (A < B) A = B;
}
const int S = 101003, N = 5011;
struct Edge {
int v, nxt;
} a[N];
int s[S], head[N], fa[N];
double f[N][N];
int n, Q, _;
inline void add(int u, int v) { a[++_] = (Edge){v, head[u]}, head[u] = _; }
namespace SEG {
int seg[S << 2];
void build(int l, int r, int x) {
if (l == r) {
seg[x] = s[l];
return;
}
int mid(l + r >> 1);
build(l, mid, x << 1);
build(mid + 1, r, x << 1 | 1);
seg[x] = max(seg[x << 1], seg[x << 1 | 1]);
}
int query(int l, int r, int x, int L, int R) {
if (L <= l and r <= R) return seg[x];
int mid(l + r >> 1), res = 0;
if (L <= mid) cmax(res, query(l, mid, x << 1, L, R));
if (mid < R) cmax(res, query(mid + 1, r, x << 1 | 1, L, R));
return res;
}
void Build() { build(1, n, 1); }
int Get(int l, int r) { return query(1, n, 1, l, r); }
} // namespace SEG
struct Qry {
int l, r;
double p;
int mx;
inline void set(int L, int R, double P) {
mx = SEG::Get(l = L, r = R), p = P;
}
friend inline bool operator<(const Qry& A, const Qry& B) {
return A.l != B.l ? A.l < B.l : A.r > B.r;
}
} q[N];
int build(int x) {
if (x) add(fa[x], x);
for (int i = x + 1, j; i <= Q; i = j) {
if (q[i].r > q[x].r) return i;
fa[i] = x, j = build(i);
}
return Q + 1;
}
void dfs(int x) {
if (!head[x]) {
f[x][0] = 1 - q[x].p;
for (int i = 1; i <= Q; ++i) f[x][i] = 1.0;
return;
}
for (int i = head[x]; i; i = a[i].nxt) dfs(a[i].v);
for (int j = 0; j <= Q; ++j) {
double t1 = 1.0, t2 = 1.0;
for (int i = head[x]; i; i = a[i].nxt) {
t1 *= f[a[i].v][min(Q, j + q[x].mx - q[a[i].v].mx - 1)];
t2 *= f[a[i].v][min(Q, j + q[x].mx - q[a[i].v].mx)];
}
f[x][j] = (1 - q[x].p) * t2;
if (j) f[x][j] += q[x].p * t1;
}
}
int main() {
read(n), read(Q);
int U = 0;
for (int i = 1; i <= n; ++i) read(s[i]), cmax(U, s[i]);
if (U > Q)
for (int i = 1; i <= n; ++i) s[i] = max(0, s[i] - U + Q);
SEG::Build();
for (int i = 1, l, r; i <= Q; ++i) {
double p;
read(l), read(r);
scanf("%lf", &p);
q[i].set(l, r, p);
}
sort(q + 1, q + Q + 1);
q[fa[1] = 0].set(1, n, 0);
build(0);
dfs(0);
double Ans = U;
for (int i = 1; i <= Q; ++i) Ans += i * (f[0][i] - f[0][i - 1]);
printf("%.8lf\n", Ans);
return 0;
}
| 9 | CPP |
t = int(input())
for x in range(t):
n, m = map(int, input().split())
for _n in range(n):
for _m in range(m):
if _n == _m == 0:
print('W', sep='', end='')
else:
print('B', sep='', end='')
print('')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int p[n];
int s[n];
for (int i = 0; i < n; ++i) {
cin >> p[i];
}
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
unordered_map<int, set<int> > mem;
for (int i = 0; i < n; ++i) {
mem[s[i]].insert(p[i]);
};
int r = 0;
int k_i;
for (int i = 0; i < k; ++i) {
cin >> k_i;
if (*(mem[s[k_i - 1]].rbegin()) != p[k_i - 1]) r++;
}
cout << r << "\n";
return 0;
}
| 7 | CPP |
# print("Input n")
n = int(input())
thesum = (n*(n+1))//2
if thesum % 2 == 0:
print(0)
else:
print(1)
| 7 | PYTHON3 |
i=lambda :map(int,input().split())
n=i()
a=list(i())
m=i()
b=list(i())
l=[x//y for x in b for y in a if x%y==0]
print(l.count(max(l))) | 7 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
import math
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
import os
import sys
from io import BytesIO, IOBase
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
for xyz in range(0,int(input())):
h,c,t=map(int,input().split())
if (2*t-h-c<=0):
print(2)
elif t>=h:
print(1)
else:
k=(h-t)//(2*t-h-c)
term1=k*(h+c)+h
term1-=(t*(2*k+1))
term2=(k+1)*(h+c)
term2+=h
term2-=t*(2*k+3)
if(abs(term1*(2*k+3))<=abs(term2*(2*k+1))):
print(2*k+1)
else:
print(2*k+3)
| 9 | PYTHON3 |
class dice:
def __init__(self, X):
self.x = [0] * 6
self.x[0] = X[0]
self.x[1] = X[1]
self.x[2] = X[2]
self.x[3] = X[3]
self.x[4] = X[4]
self.x[5] = X[5]
def roll(self, d):
if d == 'S':
self.x[0], self.x[1], self.x[4], self.x[5] = \
self.x[4], self.x[0], self.x[5], self.x[1]
elif d == 'E':
self.x[0], self.x[2], self.x[3], self.x[5] = \
self.x[3], self.x[0], self.x[5], self.x[2]
elif d == 'W':
self.x[0], self.x[2], self.x[3], self.x[5] = \
self.x[2], self.x[5], self.x[0], self.x[3]
elif d == 'N':
self.x[0], self.x[1], self.x[4], self.x[5] = \
self.x[1], self.x[5], self.x[0], self.x[4]
n = int(input())
X = list(map(int, input().split()))
dice_b = dice(X)
distances = list('NNNNWNNNWNNNENNNENNNWNNN')
b = False
for _ in range(n-1):
X_t = list(map(int, input().split()))
dice_t = dice(X_t)
for d in distances:
dice_t.roll(d)
if dice_b.x[0] == dice_t.x[0] and dice_b.x[1] == dice_t.x[1] and dice_b.x[2] == dice_t.x[2] and \
dice_b.x[3] == dice_t.x[3] and dice_b.x[4] == dice_t.x[4] and dice_b.x[5] == dice_t.x[5]:
b = True
break
if b == False:
print('Yes')
elif b == True:
print('No')
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
signed main() {
Int n;
cin >> n;
vector<string> vs(n);
for (Int i = 0; i < n; i++) cin >> vs[i];
const Int MAX = 5e5 + 100;
vector<Int> pos(MAX), neg(MAX);
Int zero = 0;
for (string s : vs) {
Int len = s.size();
Int cl = 0, cr = 0;
Int fl = 1, fr = 1;
for (Int i = 0; i < len; i++) {
if (s[i] == '(') cl++;
if (s[i] == ')') cl--;
if (cl < 0) fl = 0;
}
for (Int i = len - 1; i >= 0; i--) {
if (s[i] == ')') cr++;
if (s[i] == '(') cr--;
if (cr < 0) fr = 0;
}
assert(cl + cr == 0);
if (fl == 0 && fr == 0) continue;
if (cl == 0) {
assert(fl && fr);
zero++;
continue;
}
if (fl && cl > 0) pos[cl]++;
if (fr && cr > 0) neg[cr]++;
}
Int ans = zero / 2;
for (Int i = 0; i < MAX; i++) ans += min(pos[i], neg[i]);
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int s[n + 1];
for (int i = 1; i <= n; cin >> s[i], ++i)
;
sort(s + 1, s + n + 1);
for (int i = n; i >= 2; --i) s[i] -= s[i - 1];
int res = 0x3f3f3f3f;
for (int i = 2; i <= n; ++i) res = min(res, s[i]);
cout << res << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char T(int i) {
if (i == 0) return 'A';
if (i == 1) return 'B';
if (i == 2) return 'C';
}
int func(pair<long long, long long> b[], int i, int j, int k) {
if (b[i].first + b[j].first == b[k].first && b[i].second == b[j].second &&
b[i].second + b[k].second == b[k].first) {
cout << b[k].first << endl;
for (int(r) = (0); (r) < (b[k].second); (r)++) {
for (int(l) = (0); (l) < (b[k].first); (l)++) cout << T(k);
cout << endl;
}
for (int(r) = (0); (r) < (b[i].second); (r)++) {
for (int(l) = (0); (l) < (b[i].first + b[j].first); (l)++) {
if (l < b[i].first)
cout << T(i);
else
cout << T(j);
}
cout << endl;
}
return 1;
}
return 0;
}
int main() {
pair<long long, long long> a[3];
for (int(i) = (0); (i) < (3); (i)++) cin >> a[i].first >> a[i].second;
long long flag = 0;
for (int(i) = (0); (i) < (8); (i)++) {
pair<long long, long long> b[3];
for (int(j) = (0); (j) < (3); (j)++) {
if (i & (1 << (2 - j))) {
b[j] = make_pair(a[j].second, a[j].first);
} else
b[j] = a[j];
}
if (b[0].first == b[1].first && b[1].first == b[2].first &&
b[0].second + b[1].second + b[2].second == b[0].first) {
cout << b[0].first << endl;
for (int(l) = (0); (l) < (3); (l)++) {
for (int(j) = (0); (j) < (b[l].second); (j)++) {
for (int(k) = (0); (k) < (b[l].first); (k)++) {
if (l == 0)
cout << "A";
else if (l == 1)
cout << "B";
else
cout << "C";
}
cout << endl;
}
}
flag = 1;
break;
}
long long c = func(b, 0, 1, 2);
flag |= c;
if (c) break;
c = func(b, 0, 2, 1);
flag |= c;
if (c) break;
c = func(b, 1, 2, 0);
flag |= c;
if (c) break;
}
if (!flag) cout << "-1\n";
return 0;
}
| 10 | CPP |
year = input()
year = int(year)
year += 1
year = str(year)
while len(list(year)) > len(set(list(year))):
year = int(year)
year += 1
year = str(year)
print(year) | 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
char kb[100] = "qwertyuiopasdfghjkl;zxcvbnm,./";
char dir = getchar();
int i, j, k = 0;
char inp[101], out[101];
scanf("%s", &inp);
if (dir == 'R') {
for (i = 0; inp[i] != '\0'; i++) {
for (j = 0; kb[j] != '\0'; j++) {
if (inp[i] == kb[j]) {
out[k++] = kb[j - 1];
break;
}
}
}
} else if (dir == 'L') {
for (i = 0; inp[i] != '\0'; i++) {
for (j = 0; kb[j] != '\0'; j++) {
if (inp[i] == kb[j]) {
out[k++] = kb[j + 1];
break;
}
}
}
}
out[k] = '\0';
printf("%s\n", out);
return 0;
}
| 7 | CPP |
from collections import defaultdict
Q = int(input())
for _ in range(Q):
n = int(input())
a = list(map(int,input().split()))
ev = a[0:n:2]
od = a[1:n:2]
sa = [0]
tmp = 0
for i in range(len(od)):
tmp = max(0, tmp+od[i]-ev[i])
sa.append(tmp)
if len(od) > len(ev):
tmp += od[i+1]
sa.append(tmp)
tmp = 0
for i in range(len(ev)-1):
tmp = max(0, tmp+od[i]-ev[i+1])
sa.append(tmp)
print(sum(ev)+max(sa)) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int(i)=0;i<(n);i++)
int main(){
int j,n,t,ans;cin>>n;
vector<vector<int>> v(2,vector<int>(100001,0));
vector<int> m(2,0),c(2,0);
REP(i,n){
j=i%2;
cin>>t;v.at(j).at(t)++;
if(v.at(j).at(t)>m.at(j)) m.at(j)=v.at(j).at(t),c.at(j)=t;
}
if(c.at(0)!=c.at(1)) ans=n-m.at(0)-m.at(1);
else{
sort(v.at(0).begin(),v.at(0).end(),greater<int>());
sort(v.at(1).begin(),v.at(1).end(),greater<int>());
ans=n-max(m.at(0)+v.at(1).at(1),m.at(1)+v.at(0).at(1));
}
cout<<ans;
} | 0 | CPP |
s,n=map(int,input().split())
x = [[0 for i in range(2)] for j in range(n)]
for i in range(n):
x[i][0],x[i][1]=map(int,input().split())
flag=0
x.sort()
for i in range(len(x)):
if(s>x[i][0]):
s+=x[i][1]
else:
print("NO")
flag=1
break
if(flag==0):
print("YES")
| 7 | PYTHON3 |
t=int(input())
for i in range(t):
m=input().split()
n,x=m
n=int(n)
x=int(x)
m=list(map(int,input().split()))
j=0
i=0
while (j<=x):
i+=1
if(i not in m):
j+=1
print(i-1)
| 7 | PYTHON3 |
n,m=map(int,input().split())
A=[int(i) for i in input().split()]
B=[int(i) for i in input().split()]
i=1
j=1
smA=A[0]
smB=B[0]
cnt=0
while i<n or j<m:
# print(smA,smB)
if smA==smB:
cnt+=1
if i==n-1 and j==m-1:
break
smA=A[i]
smB=B[j]
i+=1
j+=1
elif smA<smB:
smA+=A[i]
i+=1
else:
smB+=B[j]
j+=1
print(cnt+1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int a, b, c, x, y, z;
cin >> a >> b >> c >> x >> y >> z;
long int a1, b1, c1;
x -= a;
y -= b;
z -= c;
if (x < 0 && y < 0 && z < 0) {
cout << "Yes";
return 0;
}
if (x < 0) {
a1 = fabs(x);
x = 0;
} else {
a1 = 0;
}
if (y < 0) {
b1 = fabs(y);
y = 0;
} else {
b1 = 0;
}
if (z < 0) {
c1 = fabs(z);
z = 0;
} else {
c1 = 0;
}
if (x + z + y <= a1 / 2 + b1 / 2 + c1 / 2)
cout << "Yes";
else
cout << "No";
}
| 7 | CPP |
H, W = map(int, input().split())
S = [list(input().split()) for i in range(H)]
h = w = 0
for i in range(H):
if 'snuke' in S[i]:
h = i
w = S[i].index('snuke')
break
print(chr(ord('A') + w) + str(h + 1))
| 0 | PYTHON3 |
#include <iostream>
#include <stack>
#include <string>
#include <sstream>
#include <cstdio>
using namespace std;
bool debug = false;
double toint(string str){
istringstream iss(str);
double ret;
iss >> ret;
return ret;
}
int main(void){
stack<double> st;
string str;
string tmp = "";
while(getline(cin, str)){
for(int i=0;i<str.size();i++){
if(debug) cout << i << ":" << str[i] << endl;
if(('0' <= str[i] && str[i] <= '9') || str[i] == '.' ||
(str[i] == '-' && '0' <= str[i+1] && str[i+1] <= '9')){
tmp += str[i];
}else if(str[i] == ' '){
if(!tmp.empty()){
st.push(toint(tmp));
if(debug) cout << "pushed " << tmp << endl;
tmp.clear();
}
}else{
double arg1, arg2;
arg2 = st.top(); st.pop();
arg1 = st.top(); st.pop();
if(str[i] == '+'){
st.push(arg1 + arg2);
}else if(str[i] == '-'){
st.push(arg1 - arg2);
}else if(str[i] == '*'){
st.push(arg1 * arg2);
}else{
st.push(arg1 / arg2);
}
}
}
if(!st.empty()){
printf("%.7f\n", st.top());
}if(!tmp.empty()){
printf("%.7f\n", toint(tmp));
tmp.clear();
}
while(!st.empty()) st.pop();
}
} | 0 | CPP |
def main():
for t in range(ri()):
s=rs()
ans=0
ans+=(int(s[0])-1)*10
ans+=(len(s)*(len(s)+1))//2
print(ans)
import sys
inp=sys.stdin.buffer.readline
rl=lambda: list(map(int,inp().split()))
ri=lambda: int(inp())
rs=lambda: inp().decode().strip()
main() | 7 | PYTHON3 |
print(700 + input().count('o') * 100) | 0 | PYTHON3 |
for _ in range(int(input())):
x, y, k = map(int, input().split())
m = (((y + 1) * k) - 1) // (x - 1)
n=(((y + 1) * k) - 1) % (x - 1)
ans=k+m
if n==0:
print(ans)
else:
print(ans+1) | 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
A = list(map(int,input().split()))
C = [A[i] for i in range(n)]
C.sort()
if(C==A or C[::-1]==A):
print("YES")
continue
A.append(A[0])
ans = "YES"
c = 0
for i in range(1,n+1):
d = A[i]-A[i-1]
if(d>=2 or d<=-2):
c+=1
if(d>=2 or d<=-2) and c==2:
ans = "NO"
break
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class Vec2 {
public:
double x, y;
Vec2(double _x = 0, double _y = 0) {
x = _x;
y = _y;
}
};
Vec2 operator+(Vec2 a, Vec2 b) { return Vec2(a.x + b.x, a.y + b.y); }
Vec2 operator*(Vec2 a, double b) { return Vec2(a.x * b, a.y * b); }
double lensqr(Vec2 a) { return a.x * a.x + a.y * a.y; }
double dissqr(Vec2 a, Vec2 b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
Vec2 wind1, wind2;
double Vmax;
double T;
Vec2 locH, locD;
bool check(double t) {
Vec2 P = locD;
if (t < T) {
P = P + wind1 * t;
} else {
P = P + wind1 * T + wind2 * (t - T);
}
return dissqr(locH, P) <= Vmax * Vmax * t * t;
}
void work(void) {
double l = 0, r = 1e10;
while ((r - l) / max(1.0, l) > 1e-7) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.20lf\n", (l + r) / 2);
}
void read(void) {
scanf("%lf%lf%lf%lf", &locH.x, &locH.y, &locD.x, &locD.y);
scanf("%lf%lf", &Vmax, &T);
scanf("%lf%lf%lf%lf", &wind1.x, &wind1.y, &wind2.x, &wind2.y);
wind1 = wind1 * (-1);
wind2 = wind2 * (-1);
}
int main(void) {
read();
work();
return 0;
}
| 8 | CPP |
n, m = [int(i) for i in input().split()]
A = []
for i in range(n):
s = input()
A.append(s)
pts = [int(i) for i in input().split()]
nets = []
freq = [0]*26
ans = 0
for i in range(m):
freq = [0]*26
for j in range(n):
freq[ord(A[j][i]) - ord('A')] += 1
ans += max(freq)*pts[i]
print(ans)
| 7 | PYTHON3 |
#include <stdio.h>
#include <algorithm>
#include <math.h>
using namespace std;
int main(){
double a,b;
scanf("%lf %lf",&a,&b);
printf("%.6lf\n",(a*b)/3.305785);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int n, m, q;
pair<pair<int, int>, pair<int, int> > edges[maxn * maxn];
pair<int, int> par[maxn];
pair<int, int> getpar(int a) {
if (par[a].first == a) return par[a];
pair<int, int> p = getpar(par[a].first);
return par[a] = make_pair(p.first, p.second ^ par[a].second);
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &edges[i].second.first, &edges[i].second.second,
&edges[i].first.first);
edges[i].first.second = i;
}
sort(edges, edges + m);
reverse(edges, edges + m);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
for (int j = 1; j <= n; j++) par[j] = make_pair(j, 0);
bool b = 0;
for (int j = 0; j < m; j++)
if (l <= edges[j].first.second && edges[j].first.second < r) {
pair<int, int> x = getpar(edges[j].second.first),
y = getpar(edges[j].second.second);
if (x.first == y.first) {
if (x.second == y.second) {
printf("%d\n", edges[j].first.first);
b = 1;
break;
}
} else {
par[x.first] = make_pair(y.first, x.second ^ y.second ^ 1);
}
}
if (!b) printf("-1\n");
}
}
| 10 | CPP |
#
n,k=map(int, input().split())
a=list(map(int, input().split()))
b=[0]*k
max=0
for i in range(k):
for j in range(n):
if (j+1)%k==i: continue
b[i]=b[i]+a[j]
if b[i]<0: b[i]=-b[i]
if i==0: max=b[0]
if b[i]>max: max=b[i]
print(max) | 7 | PYTHON3 |
import math
from decimal import *
import random
for _ in range(int(input())):
a,b = map(int, input().split())
if(a>=b):
val = a-b
ans = val//10
val-=ans*10
if(val>0):
ans+=1
print(ans)
else:
val = b-a
ans = val//10
val-=10*ans
if(val>0):
ans+=1
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int min(long long int a, long long int b) {
if (a >= b)
return b;
else
return a;
}
long long int max(long long int a, long long int b) {
if (a >= b)
return a;
else
return b;
}
long long int ndig(long long int n) {
long long int l = 0;
while (n > 0) {
n /= 10;
l++;
}
return l;
}
long long int ndig3(long long int n) {
long long int l = 0;
while (n % 3 == 0) {
n /= 3;
l++;
}
return l;
}
bool isprime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int gcd(long long int x, long long int y) {
long long int a, b, t, gcd, lcm;
a = x;
b = y;
while (b != 0) {
t = b;
b = a % b;
a = t;
}
gcd = a;
return gcd;
}
long long int lcm(long long int x, long long int y) {
long long int a, b, t, gcd, lcm;
a = x;
b = y;
while (b != 0) {
t = b;
b = a % b;
a = t;
}
gcd = a;
lcm = (x * y) / gcd;
return lcm;
}
long long int algo(long long int n) {
if (n % 2 == 0)
return n / 2;
else {
long long int z;
long long int f = 0;
if (isprime(n))
return 1;
else {
for (long long int i = 2; i < sqrt(n); i++) {
if (isprime(i) && n % i == 0) {
f = 1;
z = i;
}
if (f == 1) break;
}
return (n - z) / 2 + 1;
}
}
}
void solve() {
long long int n;
cin >> n;
long long int ans;
ans = algo(n);
cout << ans;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5 + 5;
vector<pair<int, int> > adj[nax];
vector<int> inc[nax];
int n, m, k;
int cnt[11];
vector<vector<int> > base;
bool cmp(pair<int, int> x, pair<int, int> y) { return x.second < y.second; }
bool ok[11][11][11][11];
int have[11][11];
long long int go[11][11];
long long int fast[nax];
const int mod = 1e9 + 9;
void rec(int dep, int akt, vector<int> p) {
p.push_back(akt);
if (dep == k) {
base.push_back(p);
return;
}
for (int i = 1; i <= dep + 1; i++) {
rec(dep + 1, i, p);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
fast[0] = 1;
for (int i = 1; i < nax; i++) {
fast[i] = fast[i - 1] * 67;
fast[i] %= mod;
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
int w;
cin >> w;
adj[x].push_back(make_pair(y, w));
inc[y].push_back(x);
}
for (int i = 1; i <= n; i++) sort(adj[i].begin(), adj[i].end(), cmp);
for (int i = 1; i <= n; i++) {
vector<pair<int, int> > akt;
for (int s : inc[i]) {
for (int j = 0; j < adj[s].size(); j++) {
if (adj[s][j].first == i) {
akt.push_back(make_pair(adj[s].size(), j + 1));
}
}
}
int c = akt.size();
for (int a = 1; a <= c; a++) {
pair<int, int> v = akt[a - 1];
go[v.first][v.second] += fast[i];
}
}
long long int w = 0;
for (int i = 1; i <= n; i++) {
w += fast[i];
w %= mod;
}
int ans = 0;
vector<int> e = {};
rec(1, 1, e);
for (auto s : base) {
vector<int> akt = s;
long long int sum = 0;
for (int i = 1; i <= k; i++) {
sum += go[i][akt[i - 1]];
sum %= mod;
}
if (sum == w) ans++;
}
cout << ans;
return 0;
}
| 8 | CPP |
n = input()
inp = list(map(int, input().split()))
nums = [[], []]
for i, x in enumerate(inp, 1):
nums[x%2].append(i)
print(nums[0][0]) if len(nums[0])==1 else print(nums[1][0])
| 7 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
t=[]
for i in range(n):
if l[i]!=i+1:
t.append(l[i])
t.sort()
#print(t)
if t!=[]:
f=0
for i in range(len(t)-1):
if (t[i+1]-t[i]!=1):
f=1
break
if (f):
print(2)
else:
print(1)
else:
if t==[]:
print(0)
else:
print(2)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void setPrecision(int n) { cout.precision(n); }
long long int INF = 1e10;
int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
int a[3];
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
if (a[2] >= (a[0] + a[1])) {
cout << a[0] + a[1] << "\n";
} else {
cout << ((a[0] + a[1] + a[2]) >> 1) << "\n";
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[105];
vector<int> v;
int main() {
int n;
cin >> n;
int mark = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != 0) mark = 1;
}
if (mark == 0) {
cout << "NO";
return 0;
}
int l = 1;
cout << "YES\n";
for (int i = 1; i <= n; i++) {
if (a[i] != 0) {
v.push_back(l);
v.push_back(i);
l = i + 1;
}
}
if (l != n + 1) {
v[v.size() - 1] = n;
}
cout << v.size() / 2 << "\n";
for (int i = 0; i < v.size(); i += 2) {
cout << v[i] << " " << v[i + 1] << "\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, l, c = 1, max = 1;
cin >> n;
vector<long long int> a;
for (i = 0; i < n; i++) {
cin >> l;
a.push_back(l);
}
sort(a.begin(), a.end(), greater<int>());
for (i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
c++;
if (c > max) {
max = c;
}
} else {
c = 1;
}
}
cout << max;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') continue;
bool flag = 1;
int cnt = 0;
for (int j = i - 1; j >= 0; j--) {
if (s[j] == '0')
cnt++;
else
cnt--;
if (cnt < 0) {
flag = 0;
}
}
cnt = 0;
for (int j = i + 1; j < s.size(); j++) {
if (s[j] == '1')
cnt++;
else
cnt--;
if (cnt < 0) {
flag = 0;
}
}
if (flag) s[i] = '0';
}
cout << s << endl;
}
int main() { solve(); }
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1514514;
const int mod = 1e9 + 7;
vector<int> v[N], q[N];
int fa[N], sz[N], d[N];
int n, m, pos, as[N];
long long tr[N], s[N], lz[N], w[N];
long long msk(long long a) {
long long b = mod - 2, k = 1;
while (b) {
if (b & 1) k = k * a % mod;
a = a * a % mod;
b >>= 1;
}
return k;
}
void down(int i) {
long long k = lz[i];
lz[i] = 1;
if (k <= 1) return;
lz[(i << 1)] = lz[(i << 1)] * k % mod;
lz[(i << 1 | 1)] = lz[(i << 1 | 1)] * k % mod;
tr[(i << 1)] = tr[(i << 1)] * k % mod;
tr[(i << 1 | 1)] = tr[(i << 1 | 1)] * k % mod;
}
void add(int i, int l, int r, int s, int t, long long w1, long long w2) {
if (s <= l && r <= t) {
tr[i] = (tr[i] + w1) * w2 % mod;
lz[i] = lz[i] * w2 % mod;
return;
}
down(i);
if (s <= ((l + r) >> 1)) add((i << 1), l, ((l + r) >> 1), s, t, w1, w2);
if (t > ((l + r) >> 1))
add((i << 1 | 1), ((l + r) >> 1) + 1, r, s, t, w1, w2);
tr[i] = (tr[(i << 1)] + tr[(i << 1 | 1)]) % mod;
}
void dfs(int x) {
d[x] = ++pos;
sz[x] = 1;
for (int i = 0; i < v[x].size(); i++) dfs(v[x][i]), sz[x] += sz[v[x][i]];
}
long long query(int i, int l, int r, int s, int t) {
if (s <= l && r <= t) return tr[i];
down(i);
long long ans = 0;
if (s <= ((l + r) >> 1)) ans = query((i << 1), l, ((l + r) >> 1), s, t);
if (t > ((l + r) >> 1))
ans = (ans + query((i << 1 | 1), ((l + r) >> 1) + 1, r, s, t)) % mod;
return ans;
}
int main() {
scanf("%d%d", &w[1], &m);
n = 1;
for (int i = 1, op, x; i <= m; i++) {
scanf("%d%d", &op, &x);
if (op == 1)
n++, scanf("%d", &w[n]), fa[n] = x, v[x].push_back(n);
else
q[n].push_back(x);
}
dfs(1);
add(1, 1, n, 1, 1, w[1], 1);
s[1] = 1;
for (int j = 0; j < q[1].size(); j++) printf("%lld\n", w[1]);
for (int i = (2); i <= (n); i++) {
int f = fa[i];
add(1, 1, n, d[f], d[f] + sz[f] - 1, 0, (s[f] + 1) * msk(s[f]) % mod);
s[f]++;
s[i] = 1;
add(1, 1, n, d[i], d[i],
query(1, 1, n, d[f], d[f]) * msk(w[f]) % mod * w[i] % mod, 1);
for (int j = 0; j < q[i].size(); j++) {
int u = q[i][j];
long long kkr = query(1, 1, n, d[u], d[u] + sz[u] - 1);
if (u == 1)
printf("%lld\n", kkr);
else
printf("%lld\n", kkr * w[fa[u]] % mod *
msk(query(1, 1, n, d[fa[u]], d[fa[u]])) % mod);
}
}
}
| 10 | CPP |
s, x1, x2 = [ int(a) for a in input().split() ]
t1, t2 = [ int(a) for a in input().split() ]
p, d = [ int(a) for a in input().split() ]
if p < x1 and d == -1:
t = p * t1
p = 0
d = 1
elif x1 < p and d == 1:
t = (s-p) * t1
p = s
d = -1
else:
t = 0
t += t1 * abs(p-x1)
p = x1
if p < x2 and d == -1:
t += p * t1
p = 0
d = 1
elif x2 < p and d == 1:
t += (s-p) * t1
p = s
d = -1
t += t1 * abs(p-x2)
p = x2
igor = t2 * abs(x1-x2)
print(min(t,igor))
| 9 | PYTHON3 |
n = int(input())
s = input()
for i in range(n - 1):
if s[i] != s[i + 1]:
print("YES")
print(s[i], s[i + 1], sep = '')
exit(0)
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void mini(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void maxi(T &a, T b) {
if (b > a) a = b;
}
int v[2005];
int main() {
for (int k = 1; k < 2005; k++) v[k] = k * (k - 1) / 2 + (k % 2 ? 1 : k / 2);
int n, m;
cin >> n >> m;
vector<int> w(m, 0);
for (int i = 0; i < m; i++) {
int q;
scanf("%d%d", &q, &w[i]);
}
sort((w).begin(), (w).end());
int k = upper_bound(v, v + 2005, n) - v - 1;
mini(k, m);
long long s = 0;
for (int i = m - k; i < m; i++) s += w[i];
cout << s << endl;
}
| 9 | CPP |
#include <stdio.h>
int main(){
double a;
while(scanf("%lf",&a) != EOF){
printf("%.8f\n",a * 211 / 27);
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
int N, dep[MX], ans;
int main() {
ios::sync_with_stdio(0);
cin >> N;
dep[1] = 1;
for (int i = 2, u; i <= N; i++) {
cin >> u;
dep[i] = dep[u] + 1;
}
sort(dep + 1, dep + N + 1);
for (int i = 1, j = 1; i <= N; i = j) {
while (dep[i] == dep[j] && j <= N) j++;
ans += (j - i) & 1;
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
from math import *
from collections import *
for y in range(int(input())):
n=int(input())
#n,m=map(int,input().split())
lst=list(map(int,input().split()))
#s=input()
ans=0
i=n-1
gt=lst[-1]
while i>=0:
temp=lst[i]
i-=1
cnt=1
while i>=0 and lst[i]==temp:
i-=1
cnt+=1
if cnt==1:
ans+=1
if gt==temp+1:
gt=temp
else:
gt=temp+1
else:
if gt==temp+1:
ans+=1
else:
ans+=2
gt=temp
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int Power(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % mod;
x = 1ll * x * x % mod, y >>= 1;
}
return ret;
}
int s[505], ans, n;
int main() {
scanf("%d", &n), ans = Power(2, n - 1) - 1;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
if (~x) s[x]++;
}
for (int i = 1; i <= n; i++) ans = (ans - Power(2, s[i]) + 1 + mod) % mod;
cout << ans;
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, t, x, y, z;
long long int mn = 8675435789, mx = -8675868757, PI = 3.14159265359,
md = 1000000007, aa = 0, bb = 0, cc = 0;
string r, s, u, v, w;
long long int a[250002], b[250002];
map<long long int, long long int> mp, mq;
queue<long long int> qu, qe;
pair<long long int, long long int> pp[30030];
set<string> se, sa;
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
cin >> n;
for (i = 1; i < n + 1; i++) {
cin >> x;
if (!mp[i] && i > mx) {
cc++;
}
mp[x]++;
mx = max(mx, x);
}
cout << cc;
}
| 7 | CPP |
n,l = map(int,input().split())
s = list(map(int,input().split()))
s.sort()
maxD = 0
for i,j in zip(s,s[1:]):
maxD = max(maxD,j-i)
maxD = max(float(maxD/2),float(s[0]),float(l-s[n-1]))
print(maxD)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) {
pos = 0, len = fread(buf, 1, buf_size, stdin);
}
if (pos == len) {
return -1;
}
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) {
c = getChar();
}
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int MAXN = 200001;
int n, k, m;
int a[MAXN];
int main() {
n = readInt(), k = readInt(), m = readInt();
vector<pair<int, int> > st;
for (int i = 0; i < n; i++) {
a[i] = readInt();
if (!st.empty()) {
if (st.back().second == k) {
st.pop_back();
}
}
if (st.empty() || st.back().first != a[i]) {
st.push_back(make_pair(a[i], 1));
} else {
st.back().second++;
}
}
if (!st.empty()) {
if (st.back().second == k) {
st.pop_back();
}
}
if (st.empty()) {
writeInt(0, '\n');
return 0;
}
n = (int)(st).size();
if (m == 1) {
int res = 0;
for (auto x : st) {
res += x.second;
}
writeInt(res, '\n');
return 0;
}
vector<pair<int, int> > mid, beg, en;
beg = st;
en = st;
reverse((en).begin(), (en).end());
if (m != 2) {
mid = st;
}
if (m == 2) {
while (!beg.empty() && beg.back().first == en.back().first) {
if (beg.back().second + en.back().second > k) {
int ss = (beg.back().second + en.back().second) % k;
beg.pop_back();
en.back().second = ss;
continue;
} else {
if (beg.back().second + en.back().second == k) {
beg.pop_back();
en.pop_back();
continue;
}
}
break;
}
int res = 0;
for (auto x : beg) {
res += x.second;
}
for (auto x : en) {
res += x.second;
}
writeInt(res, '\n');
} else {
int l = 0;
int r = n - 1;
while (true) {
if (l > r) {
break;
}
if (mid[l].first != beg.back().first) {
break;
}
if (l == r) {
if (1LL * mid[l].second * (m - 2) + beg.back().second +
en.back().second <
k) {
break;
}
int len = (1LL * mid[l].second * (m - 2) + beg.back().second +
en.back().second) %
k;
l++;
r--;
int sss = beg.back().first;
beg.pop_back();
en.pop_back();
if (len) {
beg.push_back(make_pair(sss, len));
}
break;
}
if (mid[l].second + beg.back().second < k) {
break;
}
int len = (mid[l].second + beg.back().second) % k;
if (len == 0) {
l++;
r--;
beg.pop_back();
en.pop_back();
} else {
l++;
en.pop_back();
beg.back().second = len;
mid[r].second = len;
break;
}
}
if (l > r) {
while (!beg.empty() && beg.back().first == en.back().first) {
if (beg.back().second + en.back().second > k) {
int ss = (beg.back().second + en.back().second) % k;
beg.pop_back();
en.back().second = ss;
continue;
} else {
if (beg.back().second + en.back().second == k) {
beg.pop_back();
en.pop_back();
continue;
}
}
break;
}
}
long long res = 0;
for (auto x : beg) {
res += x.second;
}
for (auto x : en) {
res += x.second;
}
for (int i = l; i <= r; i++) {
res += 1LL * (m - 2) * mid[i].second;
}
cout << res << '\n';
}
return 0;
}
| 8 | CPP |