solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long l, long long r) {
return uniform_int_distribution<long long>(l, r)(rng);
}
template <class T>
void Min(T &a, const T b) {
if (a > b) a = b;
}
template <class T>
void Max(T &a, const T b) {
if (a < b) a = b;
}
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int N = 5000 + 10;
const long long mod = 1e9 + 7;
int ar[N], f[N][N], lst[N];
int solve() {
int n;
cin >> n;
map<int, int> pos;
for (int i = 1; i <= n; i++) cin >> ar[i];
for (int i = 1; i <= n; i++) {
lst[i] = pos[ar[i]];
pos[ar[i]] = i;
}
for (int i = 1; i <= n; i++) f[i][i] = 1;
for (int len = 2; len <= n; len++) {
for (int l = 1, r = len; r <= n; r++, l++) {
f[l][r] = min(f[l + 1][r], f[l][r - 1]) + 1;
int t = lst[r];
while (t >= l) {
Min(f[l][r], f[l][t - 1] + f[t + 1][r]);
t = lst[t];
}
}
}
return f[1][n] - 1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
;
int _;
cin >> _;
while (_--) {
cout << solve() << '\n';
}
}
| 9 | CPP |
n=int(input())
a=list(map(int,input().split()))
s=set()
d=0
ans=[]
c=0
o=set()
for i in range(n):
x=a[i]
if x>0:
if i==0:
c+=1
s.add(x)
o.add(x)
else:
if len(s):
if x in s or x in o:
d=-1
break
else:
c+=1
s.add(x)
o.add(x)
else:
d+=1
ans.append(c)
s.add(x)
o={x}
c=1
elif x<0:
if i==0:
d=-1
break
else:
if len(s):
if -1*x in s:
s.remove(-1*x)
c+=1
else:
d=-1
break
else:
d=-1
break
if d!=-1:
if len(s):
print("-1")
else:
d+=1
ans.append(c)
print(d)
print(*ans)
else:
print("-1") | 8 | PYTHON3 |
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<vector>
#include<utility>
using namespace std;
int BIG=999999999;
int n,m;
int dis[1010],ond[1010];
int dp[1010][1010];//day,now
int sol(int day,int now){
if(dp[day][now]!=-1)return dp[day][now];
if(now==n)return dp[day][now]=0;
if(day==m)return dp[day][now]=BIG;
dp[day][now]=min(sol(day+1,now),sol(day+1,now+1)+(ond[day]*dis[now]));
return dp[day][now];
}
int main(){
cin >> n >> m;
for(int i=0; i<n; i++)cin >> dis[i];
for(int i=0; i<m; i++)cin >> ond[i];
for(int i=0; i<=m; i++){
for(int j=0; j<=n; j++)dp[i][j]=-1;
}
cout << sol(0,0) << endl;
return 0;
}
| 0 | CPP |
s=list(input().lower())
k=0
while True:
if ("a" in s) or ("e" in s) or ("i" in s) or ("o" in s) or ("u" in s) or ("y" in s):
if "a" in s:
s.remove("a")
elif "e" in s:
s.remove("e")
elif "i" in s:
s.remove("i")
elif "o" in s:
s.remove("o")
elif "u" in s:
s.remove("u")
elif "y" in s:
s.remove("y")
else: break
for item in s:
print(f".{item}",end="") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
int x;
cin >> s >> x;
int len = s.length();
int arr[len];
for (int i = 0; i < len; i++) {
arr[i] = -1;
}
for (int i = 0; i < len; i++) {
if (s[i] == '0') {
int bef = i - x;
int aft = i + x;
if ((bef >= 0)) {
arr[bef] = 0;
}
if (aft < len) {
arr[aft] = 0;
}
}
}
for (int i = 0; i < len; i++) {
if (s[i] == '1') {
bool first = false;
bool second = false;
int bef = i - x;
int aft = i + x;
if ((bef >= 0) && ((arr[bef] == -1) || (arr[bef] == 1))) {
arr[bef] = 1;
first = true;
}
if ((aft < len) && ((arr[aft] == -1) || (arr[aft] == 1))) {
arr[aft] = 1;
second = true;
}
if ((first == false) && (second == false)) {
cout << -1 << endl;
return;
}
}
}
for (int i = 0; i < len; i++) {
if (arr[i] == -1) {
arr[i] = 1;
}
cout << arr[i];
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[n];
int ma = -1;
for (int i = 0; i < n; i++) {
cin >> arr[i];
ma = max(ma, arr[i]);
}
int maxa = ma + m;
for (int i = 0; i < n; i++) {
m -= (ma - arr[i]);
}
int tmp = 0;
if (m > 0) {
tmp = m / n;
m %= n;
}
if (m > 0) tmp++;
cout << ma + tmp << " " << maxa << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long m = n - 1, ans = 0;
ans = (n * m * 6);
cout << ans + 1;
return 0;
}
| 8 | CPP |
t = int(input())
for __ in [0]*t:
s = list(input())
n = len(s)
res = []
cnt = 1
for i in range(1,n):
if s[i] == s[i-1]:
cnt += 1
else:
if cnt%2 == 1:
res.append(s[i-1])
cnt = 1
if cnt%2 == 1:
res.append(s[-1])
res = list(set(res))
res.sort()
print(''.join(res)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0);
const int MOD = 998244353;
long long dp[205][2];
long long ndp[205][2];
void first() {
int k;
scanf("%d", &k);
if (k == -1) {
for (int i = 1; i <= 200; i++) {
dp[i][1] = 1;
}
} else {
dp[k][1] = 1;
}
for (int a = 1; a <= 200; a++) {
dp[a][1] += dp[a - 1][1];
dp[a][0] += dp[a - 1][0];
}
}
int main() {
int n;
scanf("%d", &n);
n--;
first();
while (n--) {
int t;
memset(ndp, 0, sizeof(ndp));
scanf("%d", &t);
if (t == -1) {
for (int a = 1; a <= 200; a++) {
ndp[a][1] = dp[a - 1][1] + (dp[a - 1][0]);
ndp[a][0] = (dp[a][1] - dp[a - 1][1]) + (dp[200][0] - dp[a - 1][0]);
}
} else {
ndp[t][1] = dp[t - 1][1] + (dp[t - 1][0]);
ndp[t][0] = (dp[t][1] - dp[t - 1][1]) + (dp[200][0] - dp[t - 1][0]);
}
memcpy(dp, ndp, sizeof(ndp));
for (int i = 1; i <= 200; i++) {
dp[i][0] += dp[i - 1][0];
dp[i][0] %= MOD;
dp[i][0] += MOD;
dp[i][1] += dp[i - 1][1];
dp[i][1] %= MOD;
dp[i][1] += MOD;
}
}
printf("%lld\n", dp[200][0] % MOD);
}
| 7 | CPP |
//#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define IN(a, b, x) (a<=x&&x<b)
#define MP make_pair
#define PB push_back
#ifdef int
const ll INF = (1LL<<60);
#else
const int INF = (1LL<<30);
#endif
const double PI = 3.14159265359;
const double EPS = 1e-12;
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//grid-BFS
string c[25];
int h, w, d[10010][10010];
int bfs(int sx, int sy, int gx, int gy) {
queue<PII> que;
REP(i, h) REP(j, w) d[i][j] = INF;
que.push(PII{sx, sy});
d[sy][sx] = 0;
while(que.size()) {
PII p = que.front(); que.pop();
if(p.first == gx && p.second == gy) break;
REP(i, 4) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if(IN(0, w, nx) && IN(0, h, ny) && c[ny][nx] != 'x' && d[ny][nx] == INF) {
que.push(PII{nx, ny});
d[ny][nx] = d[p.second][p.first] + 1;
}
}
}
return d[gy][gx];
}
int ax[15], ay[15], dp[1<<10][15], cost[15][15];
signed main(void)
{
while(true) {
cin >> w >> h;
if(!w) break;
int idx = 0, sx, sy;
REP(i, h) cin >> c[i];
REP(i, h) REP(j, w) {
if(c[i][j] == 'o') sx = j, sy = i;
if(c[i][j] == '*') ax[idx] = j, ay[idx++] = i;
}
// REP(i, idx) cout << ax[i] << "," << ay[i] << " "; cout << endl;
REP(i, idx) FOR(j, i+1, idx) {
// (ax[i], ay[i]) ?????? (ax[j], ay[j]) ????????????
cost[i][j] = cost[j][i] = bfs(ax[i], ay[i], ax[j], ay[j]);
}
REP(i, 1LL<<idx) REP(j, idx) dp[i][j] = INF;
REP(i, idx) {
dp[1<<i][i] = bfs(sx, sy, ax[i], ay[i]);
// cout << i << " " << dp[1<<i][i] << endl;
}
REP(i, 1LL<<idx) REP(j, idx) {
// ?¨?????????????i??§???????????????j
if(dp[i][j] == INF) continue;
// cout << i << " " << j << endl;
// k?????????
REP(k, idx) {
if(i&(1<<k)) continue;
// j??????k????????????????????¢???+
chmin(dp[i | 1<<k][k], dp[i][j] + cost[j][k]);
}
}
int ret = INF;
REP(i, idx) chmin(ret, dp[(1LL<<idx)-1][i]);
if(ret >= INF) cout << -1 << endl;
else cout << ret << endl;
}
return 0;
} | 0 | CPP |
import math
arr = [float(i) for i in input().split()]
arr1 = [[0] * 2 for i in range(6)]
arr1[1][0], arr1[1][1] = - arr[0], 0
arr1[2][0], arr1[2][1] = arr1[1][0] - arr[1] / 2, arr1[1][1] + arr[1] * math.sqrt(3) / 2
arr1[3][0], arr1[3][1] = arr1[2][0] + arr[2] / 2, arr1[2][1] + arr[2] * math.sqrt(3) / 2
arr1[4][0], arr1[4][1] = arr1[3][0] + arr[3], arr1[3][1]
arr1[5][0], arr1[5][1] = arr1[4][0] + arr[4] / 2, arr1[4][1] - arr[4] * math.sqrt(3) / 2
sq = 0.0
for i in range(5):
sq += (arr1[i + 1][0] - arr1[i][0]) * (arr1[i][1] + arr1[i + 1][1]) / 2
sq += (arr1[0][0] - arr1[5][0]) * (arr1[0][1] + arr1[5][1]) / 2
print(round(sq / (math.sqrt(3) / 4))) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char a[1005][1005];
int visited[1005][1005];
int b[1005][1005];
int r[1005] = {0};
int c[1005] = {0};
long long n, m;
int solve(int x, int y) {
int count = 0;
if (y == -1) {
for (int j = 0; j < m; j++)
if (b[x][j] != 0) count++;
if (!count && !r[x]) return 0;
int temp = r[x];
for (int j = 0; j < m; j++) {
if (a[x][j] == '.' && temp && temp != r[x])
return 0;
else if (a[x][j] == '#')
temp--;
}
} else {
for (int j = 0; j < n; j++)
if (b[j][y] != 0) count++;
if (!count && !c[y]) return 0;
int temp = c[y];
for (int j = 0; j < n; j++) {
if (a[j][y] == '.' && temp && temp != c[y])
return 0;
else if (a[j][y] == '#')
temp--;
}
}
}
void dfs(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m || a[x][y] == '.') return;
if (visited[x][y] == 1) return;
visited[x][y] = 1;
dfs(x + 1, y);
dfs(x, y + 1);
dfs(x, y - 1);
dfs(x - 1, y);
}
void getvalues() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == '#') r[i]++, c[j]++;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (r[i] == 0 && c[j] == 0) b[i][j] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, l, q, t, h, p, k;
std::cin >> n >> m;
h = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) std::cin >> a[i][j];
if (n == 1 && m == 1) {
if (a[0][0] == '#')
std::cout << 1 << std::endl;
else
std::cout << 0 << std::endl;
} else if (n == 1 || m == 1)
std::cout << -1 << std::endl;
else {
getvalues();
for (i = 0; i < n; i++) {
if (solve(i, -1) == 0) break;
}
if (i < n)
std::cout << -1 << std::endl;
else {
for (i = 0; i < m; i++) {
if (solve(-1, i) == 0) break;
}
if (i < m)
std::cout << -1 << std::endl;
else {
memset(visited, 0, sizeof(visited));
p = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == '#' && visited[i][j] == 0) {
p++;
dfs(i, j);
}
}
}
std::cout << p << std::endl;
}
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a;
cin >> n;
long long int odd = 0, even = 0;
for (long long int i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 0)
even++;
else
odd++;
}
cout << min(even, odd);
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long inf64 = 1e18;
const long long MOD = inf + 7;
const long long N = 1e5 + 5, LOG = 22;
vector<long long> g[N];
long long child[N], p[N][LOG], d[N];
long long a[N];
void dfs(long long node, long long par) {
child[node] = 1;
for (long long v : g[node])
if (v != par) {
d[v] = d[node] + 1;
p[v][0] = node;
dfs(v, node);
child[node] += child[v];
}
}
void pre() {
for (long long k = 1; k < LOG; k++) {
for (long long i = 1; i < N; i++) p[i][k] = p[p[i][k - 1]][k - 1];
}
}
long long walk(long long node, long long k) {
for (long long i = 0; i < LOG; i++)
if (k & (1LL << i)) {
node = p[node][i];
}
return node;
}
long long lca(long long u, long long v) {
if (d[u] > d[v]) {
u = walk(u, d[u] - d[v]);
}
if (d[u] < d[v]) {
v = walk(v, d[v] - d[u]);
}
if (u == v) return u;
for (long long i = LOG - 1; i >= 0; i--)
if (p[u][i] != p[v][i]) {
u = p[u][i];
v = p[v][i];
}
return p[u][0];
}
long long distance(long long u, long long v) {
return d[u] + d[v] - 2 * d[lca(u, v)];
}
void dfs1(long long node, long long par) {
for (auto v : g[node]) {
if (v == par) continue;
dfs1(v, node);
a[node] += a[v];
}
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
;
long long n;
cin >> n;
vector<pair<long long, long long> > edge;
for (long long i = 0; i < (long long)n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
edge.push_back({u, v});
}
dfs(1, 0);
pre();
long long k;
cin >> k;
for (long long i = 0; i < (long long)k; i++) {
long long u, v;
cin >> u >> v;
long long l = lca(u, v);
a[u]++;
a[v]++;
a[l] -= 2;
}
dfs1(1, 0);
for (auto it : edge) {
long long ans = a[it.first];
if (d[it.second] > d[it.first]) {
ans = a[it.second];
}
cout << ans << " ";
}
}
| 9 | CPP |
s1 = input()
s2 = input()
for i in range(len(s1)):
if not s2[i]<=s1[i]:
print(-1)
exit(0)
else:
print(s2)
| 8 | PYTHON3 |
def main():
T = int(input())
for i in range(T):
a,b,x,y = input().split()
m = int(x)
n = int(a)-(int(x)+1)
p = int(y)
q = int(b)-(int(y)+1)
Area = max(max(m,n)*int(b),max(p,q)*int(a))
print(Area)
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
// 重み付きUnionFind
struct WeightUnionFind {
static const int Max = 101010;
int par[Max];
int ws[Max];
void init(int n) {
for (int i = 0; i < Max; ++i) {
par[i] = -1;
ws[i] = 0;
}
}
int find(int x) {
if (par[x] < 0) {
return x;
}
else {
int parent = find(par[x]);
ws[x] += ws[par[x]];
return par[x] = parent;
}
}
int weight(int x) {
find(x);
return ws[x];
}
void unite(int x, int y, int w) {
w += weight(x);
w -= weight(y);
x = find(x);
y = find(y);
if (x == y) return;
if (par[y] < par[x]) {
int tmp = x;
x = y;
y = tmp;
w = -w;
}
par[x] += par[y];
par[y] = x;
ws[y] = w;
}
bool same(int x, int y) {
return find(x) == find(y);
}
int diff(int x, int y) {
if (!same(x, y)) return -1e8;
return weight(y) - weight(x);
}
int size(int x) {
return -par[find(x)];
}
};
int main() {
int n, q;
WeightUnionFind uf;
while (cin >> n >> q and n and q) {
uf.init(n);
rep(i, q) {
char ch;
cin >> ch;
if (ch == '!') {
int x, y, z;
x--; y--;
cin >> x >> y >> z;
uf.unite(x, y, z);
}
else {
int x, y;
x--; y--;
cin >> x >> y;
if (uf.same(x, y)) {
cout << uf.diff(x, y) << endl;
}
else {
cout << "UNKNOWN" << endl;
}
}
}
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> change(
pair<long long int, long long int> p,
pair<long long int, long long int> h) {
long long int t1, t2;
t1 = -(p.second - h.second) + h.first;
t2 = (p.first - h.first) + h.second;
return make_pair(t1, t2);
}
long long int distSq(pair<long long int, long long int> p,
pair<long long int, long long int> q) {
return (p.first - q.first) * (p.first - q.first) +
(p.second - q.second) * (p.second - q.second);
}
bool isSquare(pair<long long int, long long int> p1,
pair<long long int, long long int> p2,
pair<long long int, long long int> p3,
pair<long long int, long long int> p4) {
long long int d2 = distSq(p1, p2);
long long int d3 = distSq(p1, p3);
long long int d4 = distSq(p1, p4);
long long int d5 = distSq(p2, p3);
long long int d6 = distSq(p2, p4);
long long int d7 = distSq(p3, p4);
if (d2 == 0 || d3 == 0 || d4 == 0 || d5 == 0 || d6 == 0 || d7 == 0)
return false;
if (d2 == d3 && 2 * d2 == d4) {
long long int d = distSq(p2, p4);
return (d == distSq(p3, p4) && d == d2);
}
if (d3 == d4 && 2 * d3 == d2) {
long long int d = distSq(p2, p3);
return (d == distSq(p2, p4) && d == d3);
}
if (d2 == d4 && 2 * d2 == d3) {
long long int d = distSq(p2, p3);
return (d == distSq(p3, p4) && d == d2);
}
return false;
}
bool square(pair<long long int, long long int> p1,
pair<long long int, long long int> p2,
pair<long long int, long long int> p3,
pair<long long int, long long int> p4) {
long long int a = (p1.first - p2.first) * (p1.first - p2.first) +
(p1.second - p2.second) * (p1.second - p2.second);
long long int b = (p2.first - p3.first) * (p2.first - p3.first) +
(p2.second - p3.second) * (p2.second - p3.second);
long long int c = (p3.first - p4.first) * (p3.first - p4.first) +
(p3.second - p4.second) * (p3.second - p4.second);
long long int d = (p4.first - p1.first) * (p4.first - p1.first) +
(p4.second - p1.second) * (p4.second - p1.second);
if (a == b && b == c && c == d && d == a) {
long long int x1, y1, x2, y2, x3, y3, x4, y4;
x2 = (p1.first - p2.first) * (p3.first - p2.first);
x3 = (p2.first - p3.first) * (p4.first - p3.first);
x4 = (p3.first - p4.first) * (p1.first - p4.first);
x1 = (p4.first - p1.first) * (p2.first - p1.first);
y2 = (p1.second - p2.second) * (p3.second - p2.second);
y3 = (p2.second - p3.second) * (p4.second - p3.second);
y4 = (p3.second - p4.second) * (p1.second - p4.second);
y1 = (p4.second - p1.second) * (p2.second - p1.second);
if (x1 == -1 * y1 && x2 == -1 * y2 && x3 == -1 * y3 && x4 == -1 * y4)
return true;
else
return false;
} else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
pair<long long int, long long int> p[5], h[5];
cin >> n;
while (n--) {
long long int c = 20, x, y, a, b;
for (long long int i = 1; i <= 4; i++) {
cin >> x >> y >> a >> b;
p[i] = make_pair(x, y);
h[i] = make_pair(a, b);
}
for (long long int i = 0; i <= 3; i++) {
for (long long int j = 0; j <= 3; j++) {
for (long long int k = 0; k <= 3; k++) {
for (long long int l = 0; l <= 3; l++) {
if (isSquare(p[1], p[2], p[3], p[4])) {
c = min(c, i + j + k + l);
}
p[4] = change(p[4], h[4]);
}
p[3] = change(p[3], h[3]);
}
p[2] = change(p[2], h[2]);
}
p[1] = change(p[1], h[1]);
}
if (c == 20)
cout << "-1\n";
else
cout << c << "\n";
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (long long i = 0; i < v.size(); ++i) os << v[i] << " ";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (auto it : v) os << it << " ";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << v.first << " " << v.second;
return os;
}
const long long mod = 1e9 + 7;
const long long inf = 2e18;
const long long ninf = -2e18;
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
time_t t1, t2;
t1 = clock();
long long n, m, d;
cin >> n >> m >> d;
vector<pair<long long, long long> > arr;
vector<long long> ans(n, -1);
set<pair<long long, long long> > s;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
s.insert(make_pair(x, i));
}
long long day = 1;
while (!s.empty()) {
long long curr = s.begin()->first;
long long cind = s.begin()->second;
s.erase(s.begin());
ans[cind] = day;
while (1) {
auto it = s.lower_bound(make_pair(curr + d + 1, ninf));
if (it == s.end()) {
day++;
break;
}
ans[it->second] = day;
curr = it->first;
s.erase(it);
}
}
cout << day - 1 << '\n';
cout << ans << '\n';
t2 = clock();
cerr << '\n' << t2 - t1 << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, x;
cin >> t;
char s[1000];
while (t--) {
cin >> x;
cin >> s;
long long int l = strlen(s);
vector<char> str(s, s + l);
long long int sum = strlen(s);
for (int i = 1; i <= x; i++) {
int v = str[i - 1] - '1';
if (str.size() < x) {
vector<char> sub(str.begin() + i, str.end());
for (int j = 0; j < v; j++)
str.insert(str.end(), sub.begin(), sub.end());
}
l = (l + (l - i) * v + 1000000007) % 1000000007;
}
cout << l << endl;
}
}
| 7 | CPP |
count = int(input())
for i in range(count):
string = input()
a, b, c = 0, 0, 0
for char in string:
if (char == "A"):
a += 1
if (char == "B"):
b += 1
if (char == "C"):
c += 1
if (a + c == b):
print("yes")
else:
print("no") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int N;
int make(int x, int z) {
int nr = 0;
while (x < s.size()) {
if (s[x] == '.') return 0;
++nr;
if (nr >= 5) return 1;
x += z;
}
return 0;
}
int main() {
cin >> N >> s;
for (int i = 0; i < s.size(); ++i) {
for (int k = 1; k < s.size(); ++k) {
if (make(i, k)) {
printf("yes");
return 0;
}
}
}
printf("no\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int kN = 400000 + 5;
const int kLog = 19;
int n, k, r;
std::vector<int> edges[kN];
int dsu[kN];
int dist[kN];
int plca[kLog][kN];
int depth[kN];
int jump(int u, int d) {
for (int i = 0; d >> i; ++i)
if (d >> i & 1) u = plca[i][u];
return u;
}
int get_lca(int a, int b) {
if (depth[a] < depth[b]) std::swap(a, b);
a = jump(a, depth[a] - depth[b]);
if (a == b) return a;
for (int i = kLog - 1; i >= 0; --i)
if (plca[i][a] != plca[i][b]) a = plca[i][a], b = plca[i][b];
return plca[0][a];
}
void dfs(int u, int fa) {
plca[0][u] = fa;
for (int i = 1; i < kLog; ++i)
plca[i][u] = plca[i - 1][u] == -1 ? -1 : plca[i - 1][plca[i - 1][u]];
for (int v : edges[u])
if (v != fa) {
depth[v] = depth[u] + 1;
dfs(v, u);
}
}
int find(int x) { return dsu[x] = dsu[x] == x ? x : find(dsu[x]); }
int main() {
scanf("%d%d%d", &n, &k, &r);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
edges[a].emplace_back(n + i);
edges[n + i].emplace_back(a);
edges[b].emplace_back(n + i);
edges[n + i].emplace_back(b);
}
std::queue<int> que;
std::iota(dsu, dsu + n + n - 1, 0);
std::fill(dist, dist + n + n - 1, -1);
for (int i = 0; i < r; ++i) {
int x;
scanf("%d", &x);
--x;
que.emplace(x);
dist[x] = 0;
}
while (!que.empty()) {
int u = que.front();
que.pop();
if (dist[u] == k) continue;
for (int v : edges[u]) {
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
que.emplace(v);
}
int a = find(u);
int b = find(v);
dsu[b] = a;
}
}
dfs(0, -1);
int q;
scanf("%d", &q);
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
auto check = [&](int a, int b) -> bool {
int w = get_lca(a, b);
int d = depth[a] + depth[b] - 2 * depth[w];
1145141919810;
if (d <= 2 * k) return true;
int x = depth[a] - depth[w] >= k ? jump(a, k) : jump(b, d - k);
int y = depth[b] - depth[w] >= k ? jump(b, k) : jump(a, d - k);
x = find(x);
y = find(y);
return x == y;
};
puts(check(a, b) ? "YES" : "NO");
}
}
| 12 | CPP |
import math as g
x,y=map(int,input().split())
t1=[]
def fun(x,y,a,b):
s1=(x-a)**2
s2=(y-b)**2
d=g.sqrt(s1+s2)
return d
for _ in range(int(input())):
a,b,t=map(int,input().split())
t1.append(round(fun(x,y,a,b)/t,8))
print(min(t1)) | 7 | PYTHON3 |
#include<iostream>
#include<algorithm>
using namespace std ;
int main(){
using ll = long long ;
ll n ; cin >> n ;
ll a,b ;
a = b = 1 ;
for(int i=0;i<n;i++){
ll T,A ;
cin >> T >> A ;
ll sub = max((a+T-1)/T,(b+A-1)/A) ;
a = T*sub ;
b = A*sub ;
}
cout << a+b << endl ;
} | 0 | CPP |
houses, moves, dist = [int(x) for x in input().split()]
if (houses - 1) * moves < dist or moves > dist:
print('NO')
else:
vals = []
current = 1
while dist:
l_m = current - 1
r_m = houses - current
max_move = max(l_m, r_m)
if dist >= max_move + moves - 1:
dist -= max_move
moves -= 1
if max_move == l_m:
current -= l_m
else:
current += r_m
vals.append(current)
elif moves == 1:
if l_m >= dist:
current -= dist
else:
current += dist
dist = 0
vals.append(current)
else:
dist -= 1
moves -= 1
if l_m == 0:
current += 1
elif l_m == 1:
current -= 1
elif r_m == 0:
current -= 1
elif r_m == 1:
current += 1
vals.append(current)
print('YES')
print(' '.join(str(x) for x in vals)) | 10 | PYTHON3 |
m=str(input())
z=int(input())
def pol(s):
for i in range(int(len(s)/2)):
if not(s[i]==s[len(s)-1-i]):
return False
break;
return True
#pol(m)
l=len(m)
l1=int(l/z)
#print (l1)
start=0
end=l1
if ((len(m)<z) or (not(l%z)==0)):
print("NO")
exit()
for j in range(z):
u=m[start:end]
start+=l1
end+=l1
if (not(pol(u))):
print("NO")
exit()
print("YES")
| 7 | PYTHON3 |
int1=int(input())
d=[]
for i in range(int1):
d.append(input().strip())
#print(d)
print(len(set(d))) | 7 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def zap():
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
ans = []
for i in range(n):
ans.append(min(n - i, a[i]))
print(max(ans))
for i in range(int(input())):
zap()
| 7 | PYTHON3 |
a,b,c = map(int, input().split())
print(c,a,b,sep=" ") | 0 | PYTHON3 |
n,k=map(int,input().split())
s=0
while n>k-1:
n=n//k
s+=1
print(s+1) | 0 | PYTHON3 |
s = input()
t = input()
res = ''
tmp = 1
for i in range(len(s) - 1, -1, -1):
ch = chr((ord(s[i]) - ord('a') + tmp) % 26 + ord('a'))
if tmp == 1:
if ch == 'a':
tmp = 1
else:
tmp = 0
res = ch + res
if res == t:
print('No such string')
else:
print(res) | 7 | PYTHON3 |
n = int(input())
INF = 10**9
csum = 0
min_b = INF
for _ in range(n):
a,b = map(int, input().split())
csum += a
if a > b:
min_b = min(min_b,b)
if min_b == INF:
print(0)
else:
ans = csum-min_b
print(ans)
# a_down_sum = 0
# top_diff = 0
# for _ in range(n):
# a,b = map(int, input().split())
# if a < b:
# a_down_sum += a
# else:
# top_diff = max(top_diff,a-b)
| 0 | PYTHON3 |
str1= str(input())
l=[]
count=0
for i in str1:
if i not in l:
l.append(i)
count+=1
if count%2==0:
print("CHAT WITH HER!")
else:
print("IGNORE HIM!")
| 7 | PYTHON3 |
t=int(input())
for i in range(t):
n,k=map(int,input().split())
if k>n:
print(k-n)
else:
n=n-k
if n%2==0:
print(0)
else:
print(1)
| 7 | PYTHON3 |
q = int(input())
for z in range(q):
n = int(input())
arr = list(map(int, input().split()))
for i in range(n - 1):
if abs(arr[i + 1] - arr[i]) >= 2:
print('YES')
print(i + 1, i + 2)
break
else:
print('NO') | 8 | PYTHON3 |
n = int(input())
s = 0
for _ in range(1,n+1):
m = map(int,input().split())
for i in m :
for j in m :
if j-i >= 2 :
s += 1
print(s)
| 7 | PYTHON3 |
s=input()
s1=s.find('AB')
s2=s.find('BA',s1+2)
s3=s.find('BA')
s4=s.find('AB',s3+2)
if((s1>=0 and s2>=0) or (s3>=0 and s4>=0)):
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int X, Y, Z;
int V[4],EventInfo[51][2];
double DpMoney[4901][51];
void solve() {
int currentNode, currentMoney;
DpMoney[0][0] = 1.0;
for (int i = 0; i < Y; ++i) {
for (int j = 0; j < 4901; ++j) {
if (DpMoney[j][i] == 0) {
continue;
}
for (int k = 0; k < X; ++k) {
currentNode = min(Y, i + V[k]);
currentMoney = j;
switch (EventInfo[currentNode][0]) {
case 1:currentNode = min(Y, currentNode + EventInfo[currentNode][1]); break;
case 2:currentMoney += EventInfo[currentNode][1]; break;
case 3:currentMoney = max(0, currentMoney - EventInfo[currentNode][1]); break;
default:break;
}
DpMoney[currentMoney][currentNode] += DpMoney[j][i] / X;
}
}
}
}
int main() {
int n, e, a;
double total;
while (cin >> X >> Y >> Z, X) {
for (int i = 0; i < X; ++i) {
cin >> V[i];
}
memset(EventInfo, 0, sizeof(EventInfo));
for (int i = 0; i < Z; ++i) {
cin >> n >> e >> a;
EventInfo[n][0] = e;
EventInfo[n][1] = a;
}
memset(DpMoney, 0, sizeof(DpMoney));
solve();
total = 0;
for (int i = 0; i < 4901; ++i) {
total += i*DpMoney[i][Y];
}
cout << (int)total << endl;
}
return 0;
}
| 0 | CPP |
import math
#n,k = map(int, input().strip().split(' '))
n=int(input())
#lst = list(map(int, input().strip().split(' ')))
if n==1 or n==2 or n==3:
print(n)
else:
p=math.sqrt(n)
l=[1,n]
c=1
for j in range(2,int(p)+1):
if n%j==0:
l.insert(c,j)
if n//j!=j:
l.insert(c+1,n//j)
c+=1
while(True):
if l[-1]%(j*j)==0:
del l[-1]
else:
break
i1=1
i2=-1
while(i1<len(l)):
if l[i1]==l[-1]:
break
else:
if l[i2]%l[i1]**2==0:
del l[i2]
else:
if l[i2]<l[i1]**2:
i1+=1
i2=-1
else:
i2-=1
print(l[-1])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
struct info {
vector<int> x, a;
vector<int> p;
void print() {
cout << "p : ";
for (int t : p) {
cout << t << " ";
}
cout << "\n";
cout << "x : ";
for (int t : x) {
cout << t << " ";
}
cout << "\n";
cout << "a : ";
for (int t : a) {
cout << t << " ";
}
cout << "\n";
}
};
info get(string s) {
info res;
res.x.resize(s.size());
res.a.resize(s.size());
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] != 'A') {
res.p.push_back(i);
}
if (i > 0) {
res.x[i] = res.x[i - 1];
res.a[i] = res.a[i - 1];
} else {
res.x[i] = res.a[i] = 0;
}
if (s[i] == 'A') {
res.a[i]++;
} else {
res.x[i]++;
}
}
return res;
}
pair<int, int> get(const info& t, int l, int r) {
int x = t.x[r] - (l > 0 ? t.x[l - 1] : 0);
if (x == 0) {
return make_pair(0, r - l + 1);
}
int j = upper_bound((t.p).begin(), (t.p).end(), r) - t.p.begin() - 1;
j = t.p[j];
int a = t.a[r] - t.a[j];
return make_pair(x, a);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s >> t;
info is = get(s);
info it = get(t);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
l1--;
r1--;
l2--;
r2--;
pair<int, int> p1 = get(is, l1, r1);
pair<int, int> p2 = get(it, l2, r2);
if (p1.first > p2.first || (p1.first - p2.first) % 2 ||
p1.second < p2.second) {
cout << "0";
} else {
int nx = p2.first - p1.first;
int na = p1.second - p2.second;
if (nx == 0) {
if (na == 0) {
cout << "1";
} else {
if (na % 3) {
cout << "0";
} else {
cout << "1";
}
}
} else {
if (na == 0) {
if (p1.first == 0) {
cout << "0";
} else {
cout << "1";
}
} else {
cout << "1";
}
}
}
}
cout << "\n";
return 0;
}
| 10 | CPP |
input()
z = sorted([int(x) for x in input().split()])
ans = 0
for i in range(len(z)-1):
if z[i]+1 == z[i+1]:
pass
else:
ans = ans + z[i+1] - z[i]-1
print(ans)
| 7 | PYTHON3 |
#include<iostream>
#include<map>
#include<vector>
#include<algorithm>
#include<cmath>
#include<climits>
#include<ctime>
#include<cstring>
#include<stack>
#include<queue>
#include<sstream>
#include<string>
#include<set>
#include<stdio.h>
#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define DUMP(list) cout << "{ "; for(auto nth : list){ cout << nth << " "; } cout << "}" << endl
using namespace std;
const int MAX_V=16;
const int MAX_E=1001;
const int INF=1<<28;
int G[MAX_V][MAX_V];
int n_num[MAX_V];
int dp[1<<MAX_V];
int max_cost;
int main(){
int n,e;
cin >> n >> e;
fill_n((int *)n_num,sizeof(n_num)/sizeof(int),0);
fill_n((int *)G,sizeof(G)/sizeof(int),INF);
vector<int> odd_node;
max_cost=0;
rep(i,e){
int s,t,d;
cin >> s >> t >> d;
max_cost+=d;
d=min(d,G[s][t]);
G[s][t]=d;
G[t][s]=d;
n_num[s]++;
n_num[t]++;
}
rep(i,n) if(n_num[i]%2!=0) odd_node.push_back(i);
for(int k = 0; k < n; ++k)
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j) G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
fill_n((int *)dp,sizeof(dp)/sizeof(int),INF);
dp[0]=0;
for(int i=0;i<(1<<odd_node.size());i++){
rep(j,odd_node.size()){
if(i & (1<<j)) continue;
for(int k=j+1;k<odd_node.size();k++){
if(i & (1<<k)) continue;
dp[i|(1<<j)|(1<<k)] = min(dp[i|(1<<j)|(1<<k)],dp[i]+G[odd_node[j]][odd_node[k]]);
}
}
}
cout << max_cost+dp[(1<<odd_node.size())-1] << endl;
return 0;
} | 0 | CPP |
t=int(input())
for i in range(t):
n,k=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
a.sort()
b.sort(reverse=True)
for i in range(k):
if a[i]>b[i]:
continue
else:
a[i],b[i]=b[i],a[i]
print(sum(a)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long arr[n];
long long maxi = INT_MIN;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
maxi = max(maxi, arr[i]);
}
long long current = n - 1;
long long result = 0;
while (arr[current] != maxi) {
long long f = current - 1;
while (arr[f] <= arr[current]) {
f--;
}
current = f;
result++;
}
cout << result << endl;
}
int main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
long long dp[2][503][503] , A[503][503] , N;
void chkmin(long long &p , long long q){p = p < q ? p : q;}
int main(){
cin >> N;
for(int i = 1 ; i <= N ; ++i) for(int j = 1 ; j <= N ; ++j) if(i != j) cin >> A[i][j];
for(int i = 1 ; i <= N ; ++i) for(int j = 1 ; j < i ; ++j) A[i][j] += A[i][j - 1];
for(int j = 1 ; j <= N ; ++j) for(int i = 1 ; i < j ; ++i) A[i][j] += A[i - 1][j];
memset(dp , 0x3f , sizeof(dp)); dp[0][1][1] = 0; int pos = 0;
for(int i = 2 ; i <= N ; ++i){
memset(dp[pos ^ 1] , 0x3f , sizeof(dp[pos]));
for(int j = 1 ; j < i ; ++j)
for(int k = j ; k < i ; ++k)
if(dp[pos][j][k] < 1e18){
chkmin(dp[pos ^ 1][j][k] , dp[pos][j][k] + A[i - 1][i] - A[k - 1][i] + A[i][j - 1]);
chkmin(dp[pos ^ 1][k][i] , dp[pos][j][k] + A[i][k - 1]);
}
pos ^= 1;
}
long long mn = 1e18;
for(int i = 1 ; i <= N ; ++i) for(int j = i ; j <= N ; ++j) mn = min(mn , dp[pos][i][j]);
cout << mn; return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
int n, m, px = 0, py = 0;
double f[N][N] = {};
void init() {
scanf("%d%d", &n, &m);
bool l[N] = {}, r[N] = {};
for (int i = 1, x = 0, y = 0; i <= m; ++i) {
scanf("%d%d", &x, &y);
l[x] = true;
r[y] = true;
}
for (int i = 1; i <= n; ++i) px += l[i];
for (int j = 1; j <= n; ++j) py += r[j];
}
inline double incr(int i, int j) { return (double)i * (n - j) / (n * n); }
inline double incl(int i, int j) { return (double)j * (n - i) / (n * n); }
inline double inclr(int i, int j) {
return (double)(n - i) * (n - j) / (n * n);
}
inline double turn(int i, int j) {
return incl(i, j) + incr(i, j) + inclr(i, j);
}
void work() {
f[px][py] = 1;
for (int i = px; i <= n; ++i)
for (int j = py; j <= n; ++j) {
if (i > 0) f[i][j] += incl(i - 1, j) * f[i - 1][j];
if (j > 0) f[i][j] += incr(i, j - 1) * f[i][j - 1];
if (i > 0 && j > 0) f[i][j] += inclr(i - 1, j - 1) * f[i - 1][j - 1];
if (i < n || j < n) f[i][j] /= turn(i, j);
}
double ans = 0;
for (int i = px; i <= n; ++i)
for (int j = py; j <= n; ++j) ans += f[i][j];
ans -= f[n][n];
printf("%.10f\n", ans);
}
int main() {
init();
work();
return 0;
}
| 8 | CPP |
t=int(input())
while(t):
a,k=map(int,input().split())
for i in range(k-1):
n=a
max=-1
min=11
while(n):
r=n%10
if(r>max):
max=r
if(r<min):
min=r
n=n//10
if(min==0):
break
a=a+min*max
print(a)
t-=1
| 7 | PYTHON3 |
n = int(input())
a = int(input())
b = int(input())
c = int(input())
options = [a * (n - 1), b * (n - 1)]
if n > 1:
options.extend([a + c * (n - 2), b + c * (n - 2)])
ans = min(options)
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
int n, top, mx;
long long ans;
int a[maxn], stk[maxn];
vector<int> p[maxn], v[maxn];
string s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), mx = max(mx, a[i]);
for (int i = 2; i <= mx; i++)
if (v[i].empty())
for (int j = i; j <= mx; j += i) {
int k = j;
while (k % i == 0) k /= i, v[j].push_back(i);
}
cin >> s, s = " " + s;
for (int i = 1; i <= n; i++) {
stk[++top] = i;
if (s[i] == '*')
for (int j = 0; j < v[a[i]].size(); j++) p[v[a[i]][j]].push_back(i);
if (s[i] == '/')
for (int j = 0; j < v[a[i]].size(); j++) {
if (p[v[a[i]][j]].size() == 0) {
top = 0;
break;
}
while (top && stk[top] > p[v[a[i]][j]].back()) top--;
p[v[a[i]][j]].pop_back();
}
ans += top;
}
printf("%lld\n", ans);
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> graph(100001);
int a[100001];
void dfs(int root, long long int sum, int parent, int &ans, bool toDel) {
if (sum > a[root]) toDel = false;
if (!toDel) ans++;
for (auto c : graph[root]) {
if (c.first != parent) {
if (sum + c.second <= 0)
dfs(c.first, 0, root, ans, toDel);
else
dfs(c.first, sum + c.second, root, ans, toDel);
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> a[i];
int c, b;
for (int i = 1; i <= n - 1; i++) {
cin >> c >> b;
graph[c].push_back({i + 1, b});
graph[i + 1].push_back({c, b});
}
int ans = 0;
dfs(1, 0, -1, ans, true);
cout << ans << " ";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(15);
if (argc == 2 && atoi(argv[1]) == 123456789) {
freopen("d:\\code\\cpp\\stdin", "r", stdin);
}
char ss[2][10] = {"sjfnb", "cslnb"};
int n;
cin >> n;
vector<int> a(n);
map<int, int> cnt;
int cnt2 = 0;
int cnt3 = 0;
for (int(i) = 0; (i) < (n); (i)++) {
cin >> a[i];
cnt[a[i]]++;
if (cnt[a[i]] >= 2) cnt2++;
if (cnt[a[i]] >= 3) cnt3 = 1;
}
if (cnt2 > 1 || cnt3 || cnt[0] >= 2) {
cout << ss[1] << endl;
return 0;
}
long long sum = 1;
if (cnt2 == 1) {
int who2 = 0;
for (auto it : cnt)
if (it.second == 2) who2 = it.first;
if (cnt[who2 - 1] > 0) {
cout << ss[1] << endl;
return 0;
} else {
sum++;
cnt[who2]--;
cnt[who2 - 1]++;
for (int(i) = 0; (i) < (n); (i)++)
if (a[i] == who2) {
a[i]--;
who2 = -1;
};
}
}
sort(a.begin(), a.end());
long long j = cnt[0];
for (int(i) = 0; (i) < (n); (i)++) {
if (a[i]) {
sum += a[i] - j;
j++;
}
}
cout << ss[sum % 2] << endl;
if (argc == 2 && atoi(argv[1]) == 123456789)
cerr << clock() * 1.0 / CLOCKS_PER_SEC << " sec\n";
return 0;
}
| 10 | CPP |
for _ in range(int(input())):
n = int(input())
s = list(map(int, input().split()))
x = 1
newx = 1
ans = 0
i = 1
while i < n:
ans += 1
prev = 0
x = newx
newx = 0
while i < n and x:
x -= 1
prev = 0
while i < n and s[i] > prev:
prev = s[i]
i += 1
newx += 1
print(ans)
| 10 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().rstrip()
TC = int(input())
def AB(s):
ret = 0
for i in range(1, len(s)):
if s[i-1] == 'a' and s[i] == 'b':
ret += 1
return ret
def BA(s):
ret = 0
for i in range(1, len(s)):
if s[i-1] == 'b' and s[i] == 'a':
ret += 1
return ret
while TC:
TC -= 1
s = list(input())
ab = AB(s)
ba = BA(s)
if ab == ba:
print(''.join(s))
else:
s[-1] = s[0]
print(''.join(s)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class htpe, class cmp>
using heap = priority_queue<htpe, vector<htpe>, cmp>;
template <class htpe>
using min_heap = heap<htpe, greater<htpe> >;
template <class htpe>
using max_heap = heap<htpe, less<htpe> >;
const int INF = 1791791791;
const long long INFLL = 1791791791791791791ll;
bool query(int x, int y) {
cout << 1 << " " << x << " " << y << endl;
cout.flush();
string s;
cin >> s;
return s == "TAK";
}
bool is_two_answers(int a, int b) { return query(a, b) && query(b, a); }
int find_on_segment(int l, int r, int tr) {
l--;
while (l < r - 1) {
int mid = (l + r + tr) >> 1;
if (!query(mid, mid + 1))
l = mid;
else
r = mid;
}
return r;
}
int main() {
int n, k;
cin >> n >> k;
int a = find_on_segment(1, n, 0);
int b = find_on_segment(a + 1, n, 1);
if (a + 1 > n || !is_two_answers(a, b)) b = find_on_segment(1, a - 1, 0);
cout << 2 << " " << a << " " << b << endl;
cout.flush();
return 0;
}
| 8 | CPP |
n=int(input())
al=0
bl=0
ad=0
bd=0
for i in range(n):
t=list(map(int,input().split(' ')))
if t[0]==1:
al+=t[1]
ad+=t[2]
else:
bl+=t[1]
bd+=t[2]
if al>=ad:
print('LIVE')
else:
print('DEAD')
if bl >= bd:
print('LIVE')
else:
print('DEAD') | 7 | PYTHON3 |
import math
n=int(input())
arr=list(map(int,input().split()))
res=math.ceil((2 * sum(arr) + 1) / n)
if (res < max(arr)): print(max(arr))
else: print(res) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return (res * res) * a;
else
return (res * res);
}
int mpow(int base, int exp, int mod) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result % mod;
}
int binarysearch(vector<pair<int, int>>& vec, int key) {
int mid, best = -1;
int l = 0, r = vec.size() - 1;
while (l <= r) {
mid = l + (r - l) / 2;
if (vec[mid].first <= key) {
best = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return best;
}
int lowsearch(int a[], int q, int l, int r) {
int ans = 0;
int mid = (l + r) / 2;
while (r >= l) {
if (a[mid] >= q) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
ans = mid + 1;
}
}
return ans + 1;
}
int upsearch(int a[], int q, int l, int r) {
int ans = 0;
int mid = (l + r) / 2;
while (r >= l) {
if (a[mid] <= q) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
ans = mid + 1;
}
}
return ans + 1;
}
long long nprimes(long long n) {
vector<char> is_prime(n + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++) {
if (is_prime[i] && (long long)i * i <= n) {
for (int j = i * i; j <= n; j += i) is_prime[j] = false;
}
}
long long cnt = 0;
for (int i = 0; i < n + 1; i++) {
if (is_prime[i] == true) {
cnt++;
}
}
return cnt;
}
int countDivisors(int n) {
int cnt = 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
vector<long long> trial_division1(long long n) {
vector<long long> factorization;
if (n == 1) {
factorization.push_back(1);
}
for (long long d = 2; d * d <= n; d++) {
if (n % d == 0) {
factorization.push_back(d);
while (n % d == 0) {
n /= d;
}
}
}
if (n > 1) factorization.push_back(n);
return factorization;
}
int phi(int n) {
float result = n;
for (int p = 2; p * p <= n; ++p) {
if (n % p == 0) {
while (n % p == 0) n /= p;
result *= (1.0 - (1.0 / (float)p));
}
}
if (n > 1) result *= (1.0 - (1.0 / (float)n));
return (int)result;
}
bool palindrome(const string& s) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] != s[n - i - 1]) return false;
}
return true;
}
vector<int> adj[1000004];
int d[100003];
bool visited[100003];
void visit(int vertex) {
d[vertex] = 0;
visited[vertex] = 1;
for (int child : adj[vertex]) {
if (!visited[child]) {
visit(child);
}
d[vertex] = max(d[vertex], 1 + d[child]);
}
}
int main() {
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << 1 << endl;
}
if (k == 3) {
cout << 1 + (n * (n - 1) / 2) + 2 * (n * (n - 1) * (n - 2)) / 6 << endl;
}
if (k == 2) {
cout << 1 + (n * (n - 1) / 2) << endl;
}
if (k == 4) {
cout << 1 + (n * (n - 1) / 2) + (2 * (n * (n - 1) * (n - 2)) / 6) +
(9 * (n) * (n - 1) * (n - 2) * (n - 3)) / 24
<< endl;
}
}
}
| 10 | CPP |
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main(){
int n,f[100][100],p[100][11];
cin>>n;
for(int i=0;i<n;i++){
for(int j=0;j<10;j++)cin>>f[i][j];
}
for(int i=0;i<n;i++){
for(int j=0;j<11;j++)cin>>p[i][j];
}
int ans=-(1<<30);
for(int b=1;b<(1<<10);b++){
int cc=0;
for(int i=0;i<n;i++){
int c=0;
for(int j=0;j<10;j++)
if(((b>>j))&1&&f[i][j])c++;
cc+=p[i][c];
}
if(ans<cc)ans=cc;
}
cout<<ans<<endl;
} | 0 | CPP |
for _ in range(int(input())):
a,b = map(int, input(). split())
if a % b == 0:
print("0")
elif a % b != 0:
print(b - a % b)
| 10 | PYTHON3 |
n = int(input())
arr = list(map(int,input().split()))
tempt = sorted(arr)
l = 0
r = 0
flag = 0
for i in range(n):
if flag == 0 and tempt[i] != arr[i]:
flag = 1
l = i
elif flag == 1 and tempt[i] != arr[i]:
r = i
arr[l:r + 1] = arr[l:r + 1][::-1]
if arr == tempt:
print("yes")
print(str(l+1) + ' ' + str(r+1))
else:
print("no") | 8 | PYTHON3 |
def cnt(x1, y1, x2, y2):
ans = 0
for i in range(y2, y1 + 1):
for j in range(x1, x2 + 1):
if lst[i][j] == 1:
ans += 1
return ans
h, w, n, kk = map(int, input().split())
anss = 0
lst = [[0] * 20 for i in range(20)]
for i in range(n):
x, y = map(int, input().split())
lst[x - 1][y - 1] = 1
for i in range(h):
for j in range(w):
for k in range(h):
for z in range(w):
if cnt(j, i, z, k) >= kk:
anss += 1
print(anss)
| 12 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
// typedef __int128 ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define FR first
#define SE second
#define MP make_pair
#define PB push_back
#define vc vector
#define db double
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define bin(x) (1ll<<(x))
#define fo(i,l,r) for(int i=(l),I=(r);i<=I;i++)
#define fd(i,r,l) for(int i=(r),I=(l);i>=I;i--)
#define mem(x,val) memset(x,val,sizeof x)
#define Swap(a,b,n) for(int I=0;I<=n;I++) swap(a[I],b[I])
#define PC __builtin_popcountll
#ifdef DEBUG
#define debug(A,args...) fprintf(stderr,A,##args)
#else
#define debug(A,args...) printf("")
#endif
#define deb debug("line %d\n",__LINE__)
namespace mine
{
ll qread()
{
ll ans=0,f=1;char c=getchar();
while(c<'0' or c>'9') {if(c=='-')f=-1;c=getchar();}
while('0'<=c and c<='9') ans=ans*10+c-'0',c=getchar();
return ans*f;
}
void write(ll num){if(num<0) putchar('-'),num=-num;if(num>=10) write(num/10);putchar('0'+num%10);}
void write1(ll num){write(num);putchar(' ');}
void write2(ll num){write(num);putchar('\n');}
template<typename T>inline bool chmax(T&a,const T&b){return a<b?a=b,1:0;}
template<typename T>inline bool chmin(T&a,const T&b){return a>b?a=b,1:0;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
bool IN(ll x,ll l,ll r){return l<=x and x<=r;}
void GG(){puts("-1");exit(0);}
const db eps=1e-8;
const int INF=0x3f3f3f3f;
const int MOD=1e9+7;
int mm(const int x){return x>=MOD?x-MOD:x;}
template<typename T> void add(T &x,const int &y){x=(x+y>=MOD?x+y-MOD:x+y);}
ll qpower(ll x,ll e,int mod=MOD){ll ans=1;while(e){if(e&1)ans=ans*x%mod;x=x*x%mod;e>>=1;}return ans;}
ll invm(ll x){return qpower(x,MOD-2);}
const int MM=1e6+10;
ll fac[MM],facinv[MM],Inv[MM];ll Comb(int n,int m){return n<0 or n<m?0:fac[n]*facinv[m]%MOD*facinv[n-m]%MOD;}
void PRE()
{
fac[0]=1;fo(i,1,MM-1) fac[i]=fac[i-1]*i%MOD;
facinv[MM-1]=invm(fac[MM-1]);fd(i,MM-1,1) facinv[i-1]=facinv[i]*i%MOD;
Inv[1]=1;fo(i,2,MM-1) Inv[i]=(MOD-MOD/i)*Inv[MOD%i]%MOD;
}
const int N=2e3+10;
//------------------FIXED------------------
ll pp[N];
ll solve(ll T,ll x1,ll y1,ll x2,ll y2)
{
ll xx1=x1/T,yy1=y1/T,xx2=x2/T,yy2=y2/T;
if(xx1==xx2 and yy1==yy2) return solve(T/3,x1,y1,x2,y2);
if(xx1==xx2 and xx1%3==1 and abs(yy1-yy2)>=2) {x1%=(T*3),x2%=(T*3);return min(x1+x2-(T-1)*2,(T+T)*2-x1-x2)+abs(y1-y2);}
if(yy1==yy2 and yy1%3==1 and abs(xx1-xx2)>=2) {y1%=(T*3),y2%=(T*3);return min(y1+y2-(T-1)*2,(T+T)*2-y1-y2)+abs(x1-x2);}
if(T==1) return abs(x1-x2)+abs(y1-y2);
else return solve(T/3,x1,y1,x2,y2);
}
void main()
{
pp[0]=1;fo(i,1,30) pp[i]=pp[i-1]*3;
fo(q,1,qread())
{
ll x1=qread()-1,y1=qread()-1,x2=qread()-1,y2=qread()-1;
write2( solve(pp[29],x1,y1,x2,y2) );
}
}
};//变量重名！
signed main()
{
#ifdef DEBUG
freopen("a.in","r",stdin);
//freopen("z.txt","r",stdin);
//freopen("a.out","w",stdout);
#endif
srand(time(0));
mine::PRE();
mine::main();
debug("\n------------------------------------------\nTime: %.2lf s",1.0*clock()/CLOCKS_PER_SEC);
} | 0 | CPP |
q=int(input())
for i in range(q):
x=0
a,b,n,s=map(int,input().split())
if(s<(n*a)):
x=(s-((s//n)*n))
else:
x=s-(n*a)
if(x<=b):
print("YES",end="\n")
else:
print("NO",end="\n")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long x[n], a[n];
vector<pair<int, long long>> v1, v2;
for (int i = 0; i < n; i++) {
cin >> x[i] >> a[i];
if (x[i] > 0)
v1.push_back(make_pair(x[i], a[i]));
else
v2.push_back(make_pair(x[i], a[i]));
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
long long sum1 = 0, sum2 = 0;
if (v1.size() > v2.size()) {
for (int i = 0; i < v2.size(); i++) sum1 += v2[i].second;
for (int i = 0; i < v2.size() + 1; i++) sum2 += v1[i].second;
} else if (v1.size() < v2.size()) {
for (int i = 0; i < v1.size(); i++) sum1 += v1[i].second;
for (int i = 0; i < v1.size() + 1; i++) sum2 += v2[i].second;
} else {
for (int i = 0; i < v1.size(); i++) sum1 += v1[i].second + v2[i].second;
}
cout << sum1 + sum2 << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int ia(int x) {
if (x < 0) return -x;
return x;
}
struct el {
int r, a, no;
bool operator<(const el &x) const { return r < x.r; }
};
bool cmpa(el a, el b) { return a.a < b.a; }
struct que {
int x, l, u, on, ans;
bool operator<(const que &y) const { return x < y.x; }
};
bool cmpon(que a, que b) { return a.on < b.on; }
int n, k, bq;
int r[100020], a[100020];
int na[100020], oa[100020];
int g[100020];
el e[100020];
que q[100020];
int sm[100020];
int mx[1 << 19];
void addToMax(int pos, int v) {
int p = pos + (1 << 17) - 1;
while (p > 0) {
if (mx[p] < v) mx[p] = v;
p = p / 2;
}
}
int qmax(int nd, int nl, int nr, int l, int r) {
if ((l > nr) || (nl > r)) return -1;
if ((l <= nl) && (nr <= r)) return mx[nd];
int i = qmax(2 * nd, nl, (nl + nr) / 2, l, r);
int j = qmax(2 * nd + 1, (nl + nr) / 2 + 1, nr, l, r);
if (i > j) return i;
return j;
}
int qmax(int le, int ri) {
if (le > ri) return -1;
return qmax(1, 1, (1 << 17), le, ri);
}
void addToSum(int pos, int v) {
for (int i = pos; i <= n; i = i + (i & (-i))) sm[i] = sm[i] + v;
}
inline int LB(int v) {
int l, r, m;
l = 0;
r = n;
while (l + 1 < r) {
m = (l + r) / 2;
if (v <= oa[m])
r = m;
else
l = m;
}
return r;
}
inline int RB(int v) {
int l, r, m;
l = 1;
r = n + 1;
while (l + 1 < r) {
m = (l + r) / 2;
if (v >= oa[m])
l = m;
else
r = m;
}
return l;
}
int queSum(int pos) {
if (pos <= 0) return 0;
int r = 0;
for (int i = pos; i > 0; i = i - (i & (-i))) r = r + sm[i];
return r;
}
int queSum(int le, int ri) {
if (le <= ri) return queSum(ri) - queSum(le - 1);
return 0;
}
int main() {
int i, j;
int x, y;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &r[i]);
e[i].r = r[i];
e[i].no = i;
}
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
e[i].a = a[i];
}
sort(e + 1, e + n + 1, cmpa);
for (i = 1; i <= n; i++) {
na[e[i].no] = i;
oa[i] = e[i].a;
}
sort(e + 1, e + n + 1);
memset(sm, 0, sizeof(sm));
j = 1;
for (i = 1; i <= n; i++) {
while ((e[j].r <= e[i].r) && (j <= n)) {
addToSum(na[e[j].no], 1);
j++;
}
g[e[i].no] = queSum(LB(e[i].a - k), RB(e[i].a + k));
}
scanf("%d", &bq);
for (i = 1; i <= bq; i++) {
scanf("%d %d", &x, &y);
q[i].on = i;
q[i].x = r[x];
if (r[y] > q[i].x) q[i].x = r[y];
if (ia(a[x] - a[y]) > 2 * k)
q[i].ans = -1;
else
q[i].ans = -2;
if (a[x] < a[y]) swap(x, y);
q[i].l = a[x] - k;
q[i].u = a[y] + k;
if (q[i].l > q[i].u) q[i].ans = -1;
}
sort(q + 1, q + bq + 1);
memset(mx, -1, sizeof(mx));
j = n;
for (i = bq; i > 0; i--) {
while ((e[j].r >= q[i].x) && (j > 0)) {
addToMax(na[e[j].no], g[e[j].no]);
j--;
}
if (q[i].l <= q[i].u) {
q[i].ans = qmax(LB(q[i].l), RB(q[i].u));
}
}
sort(q + 1, q + bq + 1, cmpon);
for (i = 1; i <= bq; i++) {
printf("%d\n", q[i].ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
vector<int> vec[1000];
char s[1010][1010];
void addedge(int a, int b) {
vec[a].push_back(b);
vec[b].push_back(a);
}
int main() {
int k;
cin >> k;
int x = 0, y = 0, z = 2;
while (k) {
if (k & 1) {
addedge(x, z);
addedge(y, z);
}
k >>= 1;
if (k == 0) break;
addedge(x, z + 1);
addedge(x, z + 2);
addedge(y, z + 1);
addedge(y, z + 2);
addedge(z, z + 3);
x = z + 1;
y = z + 2;
z = z + 3;
}
addedge(1, z);
memset(s, 'N', sizeof s);
cout << z + 1 << endl;
for (int i = 0; i <= z; i++) {
for (int j = 0; j < vec[i].size(); j++) {
s[i][vec[i][j]] = 'Y';
s[vec[i][j]][i] = 'Y';
}
}
for (int i = 0; i <= z; i++) {
for (int j = 0; j <= z; j++) {
printf("%c", s[i][j]);
}
cout << endl;
}
return 0;
}
| 10 | CPP |
def game(n):
pow2 = [2**i for i in range(20)]
t=[0 for i in range(20)]
"""
for i in range(len(n)):
n[i]=[int(d) for d in n[i]]
n[i].reverse()
#print(n[i])
for j in range(len(n[i])-1,-1,-1):
if n[i][j]==1:
t[j]+=1
"""
for i in n:
for j in range(20):
t[j] += (1 if pow2[j] & i > 0 else 0)
for i in range(len(t)-1,-1,-1):
if t[i]==0:
t=t[:i]
else :
break
if t==[]:
return 0
g=[0 for i in range(max(t))]
for i in range(len(t)-1,-1,-1):
c = 2**i
for j in range(t[i]):
g[j]+=c
return sum([i**2 for i in g])
t=input().strip()
#n=[str(bin(int(i))).strip().split("b")[1] for i in input().strip().split()]
n = [int(i) for i in input().strip().split()]
print(game(n)) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5;
struct vt {
double x;
double y;
vt() : x(0), y(0) {}
vt(double x, double y) : x(x), y(y) {}
};
struct point {
double a, b, c;
point() : a(0), b(0), c(0) {}
point(double a, double b, double c) : a(a), b(b), c(c) {}
};
const double eps = 1e-6;
bool operator<(vt a, vt b) {
if (abs(a.x - b.x) < eps) {
return a.y + eps < b.y;
}
return a.x + eps < b.x;
}
bool operator==(vt a, vt b) {
return abs(a.x - b.x) < eps && abs(a.y - b.y) < eps;
}
vector<pair<int, int> > ans;
map<vt, int> m;
void add(point a, point b) {
double d = a.a * b.b - a.b * b.a;
a.c = -a.c;
b.c = -b.c;
double dx = a.c * b.b - a.b * b.c;
double dy = a.a * b.c - b.a * a.c;
if (d == 0) {
return;
}
m[vt(dx / d, dy / d)]++;
}
bool go(vector<pair<point, int> > &v, int k) {
if (v.empty()) {
return true;
}
if (k == 0) {
return false;
}
if ((int)v.size() <= k) {
for (int i = 0; i < (int)v.size(); i++) {
ans.push_back(make_pair(v[i].second, -1));
}
return true;
}
if ((int)v.size() > k * k) {
for (int it = 0; it < 10; it++) {
m.clear();
int pos = rand() % (int)v.size();
for (int i = 0; i < (int)v.size(); i++) {
add(v[pos].first, v[i].first);
}
vt f;
int cnt = 0;
for (auto i = m.begin(); i != m.end(); i++) {
if (i->second > cnt) {
cnt = i->second;
f = i->first;
}
}
if (cnt >= k) {
vector<pair<point, int> > t;
bool st = true;
for (int i = 0; i < (int)v.size(); i++) {
if (i != pos) {
point a = v[pos].first;
point b = v[i].first;
double d = a.a * b.b - a.b * b.a;
a.c = -a.c;
b.c = -b.c;
double dx = a.c * b.b - a.b * b.c;
double dy = a.a * b.c - b.a * a.c;
if (d == 0 || !(vt(dx / d, dy / d) == f)) {
t.push_back(v[i]);
} else if (st) {
st = false;
ans.push_back(make_pair(v[pos].second, v[i].second));
}
}
}
return go(t, k - 1);
}
}
} else {
for (int it = 0; it < 1; it++) {
m.clear();
int pos = rand() % (int)v.size();
for (int i = 0; i < (int)v.size(); i++) {
add(v[pos].first, v[i].first);
}
vt f = m.rbegin()->first;
vector<pair<point, int> > t;
bool st = true;
for (int i = 0; i < (int)v.size(); i++) {
if (i != pos) {
point a = v[pos].first;
point b = v[i].first;
double d = a.a * b.b - a.b * b.a;
a.c = -a.c;
b.c = -b.c;
double dx = a.c * b.b - a.b * b.c;
double dy = a.a * b.c - b.a * a.c;
if (d == 0 || !(vt(dx / d, dy / d) == f)) {
t.push_back(v[i]);
} else if (st) {
st = false;
ans.push_back(make_pair(v[pos].second, v[i].second));
}
}
}
if (go(t, k - 1)) {
return true;
} else {
ans.pop_back();
}
}
}
return false;
}
int main() {
vector<pair<point, int> > v;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
point a;
scanf("%lf %lf %lf", &a.a, &a.b, &a.c);
v.push_back(make_pair(a, i + 1));
}
if (!go(v, k)) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
cout << (int)ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int timer = 1;
vector<int> arr[200001];
bool visited[200001];
int in[200001];
int low[200001];
bool hasBridge;
vector<pair<int, int>> directedList;
void dfs(int node, int par) {
visited[node] = true;
in[node] = low[node] = timer++;
for (int child : arr[node]) {
if (child == par)
continue;
else if (visited[child]) {
low[node] = min(low[node], in[child]);
if (in[node] > in[child]) directedList.push_back({node, child});
} else {
dfs(child, node);
low[node] = min(low[node], low[child]);
if (low[child] > in[node]) {
hasBridge = true;
return;
}
directedList.push_back({node, child});
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int n, m, u, v;
cin >> n >> m;
while (m--) {
cin >> u >> v;
arr[u].push_back(v);
arr[v].push_back(u);
}
dfs(1, -1);
if (hasBridge) {
cout << 0;
} else {
for (pair<int, int> x : directedList) {
cout << x.first << ' ' << x.second << '\n';
}
}
}
| 11 | CPP |
def main():
n, k = map(int, input().split())
k += 1
tot = 0
l0 = [_ >= k for _ in range(10)]
for _ in range(n):
l = l0[:]
for c in input():
l[ord(c) - 48] = True
if all(l):
tot += 1
print(tot)
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
n = int(input())
x = 0
for _ in range(n):
inp = input()
for _ in range(inp.count('++')):
x += 1
for _ in range(inp.count('--')):
x -= 1
print(x)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, l;
};
stack<node> s;
int n, a[200005], ans[200005], lenth;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
node p;
p.num = a[1];
p.l = 1;
s.push(p);
a[++n] = -1;
for (int i = 2; i <= n; i++) {
lenth = 0;
node d;
d.num = a[i];
d.l = 1;
while (!s.empty() && d.num <= s.top().num) {
lenth += s.top().l;
ans[lenth] = max(ans[lenth], s.top().num);
s.pop();
}
d.l += lenth;
s.push(d);
}
n--;
for (int i = n - 1; i >= 1; i--) {
ans[i] = max(ans[i], ans[i + 1]);
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
int a[2500];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
n *= 2;
for (int i = 1; i <= n; ++i) cin >> a[i];
int ans = 0;
for (int i = 1; i <= n;) {
if (a[i] == a[i + 1]) {
i += 2;
continue;
}
int j;
for (j = i + 1; j <= n; ++j)
if (a[j] == a[i]) break;
ans += j - (i + 1);
for (int k = j; k > i; --k) a[k] = a[k - 1];
}
cout << ans;
return 0;
}
| 8 | CPP |
N, K = map(int, input().split())
p = K*((K-1)**(N-1))
print(p)
| 0 | PYTHON3 |
def solve():
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
pq = []
for e in a:
if e % k == 0:
continue
pq.append(k - e % k)
pq.sort()
q = []
p = 0
level = 1
for e in pq:
if e == p:
level += 1
else:
level = 1
q.append((level, e))
p = e
q.sort()
return 0 if len(q) == 0 else (q[-1][0] - 1) * k + (q[-1][1]) + 1
if __name__ == '__main__':
T = int(input())
for case in range(T):
print(solve())
| 10 | PYTHON3 |
import sys
import os
def reorderTheArray(arr):
arr.sort()
n = len(arr)
j = 0
result = 0
for i in range(n):
if arr[i] > arr[j]:
result += 1
j += 1
return result
def main():
n = int(input())
arr = [int(x) for x in input().split()]
print(reorderTheArray(arr))
if __name__ == '__main__':
main() | 9 | PYTHON3 |
t = input()
for i in range(int(t)):
hh, mm = map(int, input().split())
lh = 23-int(hh)
lm = 60-int(mm)
tm = (60*lh)+lm
print(tm)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
vector<int> edges[1000];
for(int i=0; i<M; i++){
int a, b;
cin >> a >> b;
edges[a-1].push_back(b-1);
}
vector<int> ans;
for(int s=0; s<N; s++){
bitset<1000> visited;
vector<int> prv(N);
queue<int> que;
que.push(s);
visited[s] = 1;
while(que.size()){
int i = que.front(); que.pop();
for(int j : edges[i]){
if(j == s){
vector<int> res = {i};
while(i != s){
i = prv[i];
res.push_back(i);
}
reverse(res.begin(), res.end());
if(ans.size() == 0 || ans.size() > res.size()){
ans = res;
}
while(que.size()) que.pop();
break;
}
if(visited[j]) continue;
visited[j] = 1;
prv[j] = i;
que.push(j);
}
}
}
if(ans.size()){
cout << ans.size() << endl;
for(int a : ans) cout << a+1 << endl;
}else{
cout << -1 << endl;
}
}
| 0 | CPP |
nums = [int(x) for x in input().split()]
nums_sum = sum(nums)
if nums_sum % len(nums) != 0 or nums_sum == 0:
print(-1)
else:
print(nums_sum // len(nums))
| 7 | PYTHON3 |
def main():
n = int(input())
a = [int(x) for x in input().split()]
temp = [1] * n
for i in range(1, n):
if a[i] != a[i-1]:
temp[i] = temp[i-1]+1
else:
temp[i] = 1
print((max(temp) - 1)//2)
temp2 = [-1] * n
i = 0
while i < n:
if a[i] == 0:
j = i
while j+2 < n and a[j+1] == 1 and a[j+2] == 0:
j += 2
if j == n-1 or a[j+1] == 0:
while i <= j:
temp2[i] = 0
i += 1
else:
l = j - i + 1
m = i + l//2
while i <= m:
temp2[i] = 0
i += 1
while i <= j:
temp2[i] = 1
i += 1
else:
j = i
while j+2 < n and a[j+1] == 0 and a[j+2] == 1:
j += 2
if j == n-1 or a[j+1] == 1:
while i <= j:
temp2[i] = 1
i += 1
else:
l = j - i + 1
m = i + l//2
while i <= m:
temp2[i] = 1
i += 1
while i <= j:
temp2[i] = 0
i += 1
print(*temp2)
#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
n = int(input())
s = input()
p = ''
count = 0
for i in range(n // 2):
if s[i * 2: i * 2 + 2] != 'ab' and s[i * 2: i * 2 + 2] != 'ba':
count += 1
p += 'ab'
else:
p += s[i * 2: i * 2 + 2]
print(count)
print(p) | 7 | PYTHON3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <functional>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <iomanip>
#include <climits>
using namespace std;
using ll = long long;
#define PI 3.141592653589793238462643383279502
#define ENDL '\n'
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int TC;
cin >> TC;
while (TC--) {
int N;
int i;
cin >> N;
vector<ll> val(N + 5);
ll ans = 0;
for (i = 1; i <= N; i++) {
cin >> val[i];
ans += val[i];
}
vector<int> cnt(N + 5, 0);
for (i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
cnt[a]++;
cnt[b]++;
}
priority_queue<ll> pq;
for (i = 1; i <= N; i++) {
while (--cnt[i]) {
pq.push(val[i]);
}
}
cout << ans << ' ';
while (!pq.empty()) {
ans += pq.top();
pq.pop();
cout << ans << ' ';
}
cout << '\n';
}
return 0;
} | 10 | CPP |
import math
n,m,a=map(int,input().split())
x=math.ceil(n/a)
y=math.ceil(m/a)
z=x*y
print(format(z,".0f"))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n,a,b;
cin >> n >> a >> b;
if((n==1&&b-a>=2) || a>b){
cout << 0 << endl;
}
else{
cout << (n-2)*(b-a)+1 << endl;
}
} | 0 | CPP |
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
string s; int bit[200009];
void add(int pos, int val) {
for (int i = pos + 1; i <= 200000; i += i & (-i)) {
bit[i] += val;
}
}
int sum(int r) {
int ret = 0;
for (int i = r; i >= 1; i -= i & (-i)) {
ret += bit[i];
}
return ret;
}
int main() {
cin >> s;
int n = s.size(), c = 0;
vector<int> v(n);
for (int i = 0; i < 26; i++) {
vector<int> w1, w2;
for (int j = 0; j < n; j++) {
if (s[j] == i + 97) {
w1.push_back(j);
w2.push_back(n - j - 1);
}
}
reverse(w2.begin(), w2.end());
for (int j = 0; j < w2.size(); j++) v[w1[j]] = w2[j];
if (w2.size() % 2 == 1) c++;
}
if (c >= 2) cout << -1 << endl;
else {
long long ret = 0;
for (int i = n - 1; i >= 0; i--) {
ret += sum(v[i]);
add(v[i], 1);
}
cout << ret / 2 << endl;
}
return 0;
} | 0 | CPP |
n = input().lower()
k= [i for i in n if i not in "aeiouy"]
print("."+".".join(k)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 5000005, inf = 1e9;
int n, k, tot = 0;
map<int, int> mp;
struct node {
int x, r, q;
} a[N];
inline bool cmp(node a, node b) { return a.r > b.r; }
struct segtree {
int l, r, sum;
} Tree[M];
inline int que(int x, int l, int r, int xx, int yy) {
if (!x) return 0;
if (xx <= l && r <= yy) return Tree[x].sum;
int mid = (l + r) >> 1, re = 0;
if (xx <= mid) re += que(Tree[x].l, l, mid, xx, yy);
if (yy > mid) re += que(Tree[x].r, mid + 1, r, xx, yy);
return re;
}
inline void ins(int po, int l, int r, int &x) {
if (!x) x = ++tot;
Tree[x].sum++;
if (l == r) return;
int mid = (l + r) >> 1;
if (po <= mid)
ins(po, l, mid, Tree[x].l);
else
ins(po, mid + 1, r, Tree[x].r);
}
int main() {
int i, j;
long long re = 0;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].r, &a[i].q);
}
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
for (j = a[i].q - k; j <= a[i].q + k; j++) {
re += (long long)que(mp[j], -inf, inf, a[i].x - a[i].r, a[i].x + a[i].r);
}
ins(a[i].x, -inf, inf, mp[a[i].q]);
}
printf("%lld\n", re);
}
| 13 | CPP |
#n = int(input())
n, m = map(int, input().split())
#s = input()
#c = list(map(int, input().split()))
a = [0] * 3
for i in range(1, 7):
x = abs(n - i)
y = abs(m - i)
if x > y:
a[2] += 1
elif x == y:
a[1] += 1
else:
a[0] += 1
print(*a) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int d;
cin >> d;
vector<int> c(26+1);
for (int i=1;i<=26;++i)
{
cin >> c[i];
}
vector<vector<int>> s(d+1,vector<int>(26+1));
for (int i=1;i<=d;++i)
{
for (int j=1;j<=26;++j)
{
cin >> s[i][j];
}
}
vector<int> t(d+1);
for (int i=1;i<=d;++i)
{
cin >> t[i];
}
vector<int> last(26+1);
for (int i=1;i<=26;++i)
{
last[i]=0;
}
int64_t score=0;
for (int i=1;i<=d;++i)
{
score+=s[i][t[i]];
last[t[i]]=i;
for (int j=1;j<=26;++j)
{
score-=c[j]*(i-last[j]);
}
cout << score << endl;
}
}
| 0 | CPP |
t = int(input())
for q in range(t):
n = int(input())
matrix = []
for k in range(n):
linha = input()
matrix.append(linha)
flag1 = False
flag2 = False
for i in range(n):
for j in range(n):
if(j+1 <= n-1):
if(matrix[i][j] == '1' and matrix[i][j+1] == '0'):
#print(i, j)
flag1 = True
if(i+1 <= n-1):
if(matrix[i][j] == '1' and matrix[i+1][j] == '0'):
#print(i, j)
flag2 = True
#print(flag1, flag2)
if(flag1 == True and flag2 == True):
break
else:
flag1 = False
flag2 = False
if(flag1 == True and flag2 == True):
break
if(flag1 == True and flag2 == True):
print('NO')
else:
print('YES')
| 11 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 105;
const double pi = acos(-1.0);
int X1[N], Y1[N], X2[N], Y2[N];
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
if (m == 3 && n > 4) {
puts("-1");
return 0;
}
if (m == 4 && n > 6) {
if (n == 7) {
puts("-10000000 10000000");
puts("-10000000 -10000000");
puts("10000000 10000000");
puts("10000000 -10000000");
puts("-500000 1000000");
puts("500000 1000000");
puts("500000 -1000000");
} else if (n == 8) {
puts("-10000000 10000000");
puts("-10000000 -10000000");
puts("10000000 10000000");
puts("10000000 -10000000");
puts("-500000 1000000");
puts("500000 1000000");
puts("-500000 -1000000");
puts("500000 -1000000");
}
return 0;
}
int d = m / 2 * 2 + 1;
for (i = 0; i < d; i++) {
X1[i] = 10000000 * cos((double)i / d * 2 * pi) + 1;
Y1[i] = 10000000 * sin((double)i / d * 2 * pi) + 1;
X2[i] = 5000000 * cos((double)i / d * 2 * pi) - 1;
Y2[i] = 5000000 * sin((double)i / d * 2 * pi) - 1;
}
for (i = 0; i < m; i++) printf("%d %d\n", X1[i], Y1[i]);
for (i = 0; i < n - m; i++) printf("%d %d\n", X2[i], Y2[i]);
return 0;
}
| 10 | CPP |
q = int(input())
for qq in range(q):
b , p , f = map(int,input().split())
h , c = map(int,input().split())
res = 0
x = b // 2
if b <= 1 :
res = 0
else:
if h > c :
a = min(x , p)
res = (a * h + min((x - a) , f)*c)
else:
a = min(x , f)
res = (a * c + min((x - a ) , p) * h)
print(res)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
unsigned long long x;
cin >> x;
return x;
}
string stin() {
string s;
cin >> s;
return s;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
vector<int> iota(int n) {
vector<int> a(n);
iota(begin(a), end(a), 0);
return a;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string& a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T>&);
template <class T, size_t size>
void print(const array<T, size>&);
template <class T, class L>
void print(const pair<T, L>& p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T>& a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
cout << endl;
}
template <class T>
void print(const deque<T>& a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, size_t size>
void print(const array<T, size>& a) {
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, class L>
void print(const pair<T, L>& p) {
cout << '(';
print(p.first);
cout << ",";
print(p.second);
cout << ')';
}
template <class T, size_t size>
void print(const T (&a)[size]) {
print(a[0]);
for (auto i = a; ++i != end(a);) {
cout << " ";
print(*i);
}
}
template <class T>
void print(const T& a) {
cout << a;
}
int out() {
putchar('\n');
return 0;
}
template <class T>
int out(const T& t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
int out(const Head& head, const Tail&... tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
long long gcd(long long a, long long b) {
while (b) {
long long c = b;
b = a % b;
a = c;
}
return a;
}
long long lcm(long long a, long long b) {
if (!a || !b) return 0;
return a * b / gcd(a, b);
}
vector<pair<long long, long long> > factor(long long x) {
vector<pair<long long, long long> > ans;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans.push_back({i, 1});
while ((x /= i) % i == 0) ans.back().second++;
}
if (x != 1) ans.push_back({x, 1});
return ans;
}
vector<int> divisor(int x) {
vector<int> ans;
for (int i = 1; i * i <= x; i++)
if (x % i == 0) {
ans.push_back(i);
if (i * i != x) ans.push_back(x / i);
}
return ans;
}
int popcount(long long x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n)(rng); }
template <class... T>
void err(const T&...) {}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int n = in();
long long z = 0, o = 0;
long long Z = 0, O = 0;
string s;
cin >> s;
string t;
cin >> t;
for (long long i = 0; i < n; i++) {
if (t[i] == '0') {
if (s[i] == '0')
z++;
else
o++;
}
if (s[i] == '0')
Z++;
else
O++;
}
cout << z * O + o * Z - z * o << '\n';
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 112;
int a[MAXN];
signed main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a[x]++;
}
long long ans = a[0];
for (int i = 1; i <= n; ++i) {
if (a[i] > 0) {
ans += a[i] - 1;
}
}
cout << ans;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_lev = 17;
const int max_n = 1 << max_lev;
const int mod = 1000000007;
const int mod1 = 1000000009;
int n, dp[max_n], sz[max_n], used[max_n], parent[max_n], pw[max_n];
int ans[max_n], cnt[max_n], h[max_n];
int ans1[max_n], cnt1[max_n];
vector<int> g[max_n], w[max_n];
int mul(int x, int y, int mod) { return 1LL * x * y % mod; }
int power(int x, int y, int mod) {
if (y == 0) {
return 1;
}
if (y % 2 == 0) {
return power(mul(x, x, mod), y / 2, mod);
}
return mul(x, power(x, y - 1, mod), mod);
}
int rn = power(max_n, mod - 2, mod), all;
int rn1 = power(max_n, mod1 - 2, mod1);
void proc(int lev, int *a, int mod) {
if (lev == 0) {
return;
}
const int n = 1 << (lev - 1);
for (int i = 0; i < n; ++i) {
int x = (a[i] + a[i + n]) % mod;
int y = (a[i] + mod - a[i + n]) % mod;
a[i] = x;
a[i + n] = y;
}
proc(lev - 1, a, mod);
proc(lev - 1, a + n, mod);
}
void dfs(int v, int p) {
used[v] = 1;
parent[v] = p;
for (int i = 0; i < g[v].size(); ++i) {
const int to = g[v][i];
if (to == p) {
continue;
}
if (used[to]) {
if (h[to] > h[v]) {
continue;
}
memset(cnt, 0, sizeof(cnt));
memset(cnt1, 0, sizeof(cnt1));
cnt[w[v][i]] = 1;
cnt1[w[v][i]] = 1;
int cur = v;
while (true) {
if (cur == to) {
break;
}
++cnt[pw[cur]];
++cnt1[pw[cur]];
cur = parent[cur];
}
proc(max_lev, cnt, mod);
proc(max_lev, cnt1, mod1);
for (int i = 0; i < max_n; ++i) {
ans[i] = mul(ans[i], cnt[i], mod);
ans1[i] = mul(ans1[i], cnt1[i], mod1);
}
} else {
h[to] = h[v] + 1;
pw[to] = w[v][i];
dfs(to, v);
}
}
}
int main() {
int m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v, x;
scanf("%d%d%d", &u, &v, &x);
--u;
--v;
g[u].push_back(v);
w[u].push_back(x);
g[v].push_back(u);
w[v].push_back(x);
all ^= x;
}
ans[all] = 1;
ans1[all] = 1;
proc(max_lev, ans, mod);
proc(max_lev, ans1, mod1);
dfs(0, -1);
proc(max_lev, ans, mod);
proc(max_lev, ans1, mod1);
for (int i = 0; i < max_n; ++i) {
ans[i] = mul(ans[i], rn, mod);
ans1[i] = mul(ans1[i], rn1, mod1);
}
for (int i = 0; i < max_n; ++i) {
if (ans[i] || ans1[i]) {
printf("%d %d", i, ans[i]);
return 0;
}
}
return 0;
}
| 8 | CPP |
import math
n=int(input())
l=[]
for i in range(n):
lst=list(map(int, input().strip().split(' ')))
l.append(lst)
if n==1:
print(1)
elif n==2:
print(1,l[0][1],end=" ")
else:
k=int(math.sqrt((l[0][1]*l[0][2]*l[1][2]))//l[1][2])
for j in range(n):
if j==0:
print(k,end=" ")
else:
print(l[0][j]//k,end=" ") | 8 | PYTHON3 |
ans=0
n=int(input())
for i,v in enumerate(list(map(int,input().split()))):
if i%2==0 and v%2:ans+=1
print(ans)
| 0 | PYTHON3 |
def get_common(a,b,boolar,d):
i,j=0,0
while(d[a][i]!=d[b][j] or boolar[d[a][i]]==False):
if d[a][i]<d[b][j]:
i+=1
else:
j+=1
return d[a][i]
t = 1
for i in range(t):
n=int(input())
x=[]
d={}
boolar=[True for i in range(n-2)]
for i in range(1,n+1):
d[i]=[]
for i in range(n-2):
q1,q2,q3=map(int,input().split())
x.append([q1,q2,q3])
d[q1].append(i)
d[q2].append(i)
d[q3].append(i)
for i in d:
if len(d[i])==1:
break
first=i
target=d[i][0]
boolar[target]=False
for j in x[target]:
if len(d[j])==2:
second=j
if len(d[j])==3:
third=j
ans=[first,second,third]
i=1
while(i<n-2):
target=get_common(ans[-1],ans[-2],boolar,d)
boolar[target]=False
for j in x[target]:
if j!=ans[-1] and j!=ans[-2]:
ans.append(j)
break
i+=1
#print(boolar)
print(*ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<long long>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
istream &operator>>(istream &, vector<T> &);
template <class T>
ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U>
istream &operator>>(istream &, pair<T, U> &);
template <class T, class U>
ostream &operator<<(ostream &, const pair<T, U> &);
template <class T>
struct Inf {
static constexpr T inf() {
return std::numeric_limits<T>::has_infinity()
? std::numeric_limits<T>::infinty()
: std::numeric_limits<T>::max();
}
};
template <>
struct Inf<int> {
static constexpr int inf() { return 0x3f3f3f3f; }
};
template <>
struct Inf<long long> {
static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; }
};
constexpr int INF = Inf<int>::inf();
constexpr ll BINF = Inf<ll>::inf();
int solve() {
int n, k;
cin >> n >> k;
vi a(n);
cin >> a;
ll ans = a[n - 1] - a[0];
vi wtf;
for (int i = 0; i + 1 < n; i++) wtf.push_back(a[i] - a[i + 1]);
sort(wtf.begin(), wtf.end());
for (int i = 0; i < k - 1; i++) ans += wtf[i];
cout << ans << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) is >> *it;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end();)
os << *it, os << " \n"[++it == v.end()];
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
| 9 | CPP |
Subsets and Splits