solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define maxn 2500
using namespace std;
typedef long long ll;
ll t, n;
ll a[maxn];
void solve()
{
cin >> n;
for(ll i=0; i<n; i++)
{
cin >> a[i];
if(a[i]%2==0)
{
cout << a[i] << " ";
}
}
for(ll i=0; i<n; i++)
{
if(a[i]%2==1)
{
cout << a[i] << " ";
}
}
cout << "\n";
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while(t--)
{
solve();
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
set<string> st;
sort(str.begin(), str.end());
int res = 0;
do {
vector<string> sv;
bool flag = false;
for (int i = 0; i < 6; i += 2) {
sv.push_back(str.substr(i, 2));
sort(sv.back().begin(), sv.back().end());
if (sv.back()[0] == sv.back()[1]) flag = true;
}
sort(sv.begin(), sv.end());
string elem = sv[0] + sv[1] + sv[2];
if (st.count(elem)) continue;
st.insert(elem);
if (flag || (sv[0] == sv[1]) || (sv[1] == sv[2]))
++res;
else
++ ++res;
} while (next_permutation(str.begin(), str.end()));
cout << res << std::endl;
return 0;
}
| 7 | CPP |
import sys
def solve():
n, k = map(int, input().split())
s = input()
dp = [[False]*(2*k + 1) for i in range(n + 1)]
dp[0][0] = True
keiro = [['']*(2*k + 1) for i in range(n + 1)]
for i, ch in enumerate(s):
if ch == 'W':
for j in range(-(k - 2), k + 1):
if dp[i][j - 1]:
dp[i + 1][j] = True
keiro[i + 1][j] = 'W'
elif ch == 'L':
for j in range(-k, k - 1):
if dp[i][j + 1]:
dp[i + 1][j] = True
keiro[i + 1][j] = 'L'
elif ch == 'D':
for j in range(-(k - 1), k):
if dp[i][j]:
dp[i + 1][j] = True
keiro[i + 1][j] = 'D'
else:
for j in range(-k, k + 1):
if j + 1 < k and dp[i][j + 1]:
dp[i + 1][j] = True
keiro[i + 1][j] = 'L'
elif -k < j < k and dp[i][j]:
dp[i + 1][j] = True
keiro[i + 1][j] = 'D'
elif j - 1 > -k and dp[i][j - 1]:
dp[i + 1][j] = True
keiro[i + 1][j] = 'W'
if dp[n][k] or dp[n][-k]:
ans = ''
if dp[n][k]:
pos = k
else:
pos = -k
for i in range(n, 0, -1):
ans = keiro[i][pos] + ans
if keiro[i][pos] == 'W':
pos -= 1
elif keiro[i][pos] == 'L':
pos += 1
else:
ans = 'NO'
print(ans)
if __name__ == '__main__':
solve() | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x[100000], y, count = 1;
cin >> y;
for (int i = 0; i < y; i++) cin >> x[i];
for (int i = 0; i < y - 1; i++) {
if (x[i] != x[i + 1]) count++;
}
cout << count << endl;
return 0;
}
| 7 | CPP |
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
newA = [0 for n in range(N)]
Bp = list(enumerate(B))
A.sort(key = lambda x: -x)
Bp.sort(key = lambda x: x[1])
# print(Bp)
# print(A)
i = 0
for index, val in Bp:
newA[index] = A[i]
i += 1
for a in newA:
print(a, end = ' ')
print() | 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int i;
char dir[100000];
getchar();
for (i = 0; i < n; i++) {
dir[i] = getchar();
}
int jump[100000];
for (i = 0; i < n; i++) {
scanf("%d", &jump[i]);
}
char see[100000];
for (i = 0; i < n; i++) {
see[i] = 0;
}
int at = 0;
int result = 0;
while (1) {
int next;
if (see[at]) {
result = 0;
break;
}
if (dir[at] == '>') {
next = at + jump[at];
} else {
next = at - jump[at];
}
if (next < 0 || next >= n) {
result = 1;
break;
}
see[at] = 1;
at = next;
}
if (result == 0) {
printf("INFINITE\n");
} else {
printf("FINITE\n");
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e5 + 10;
int n;
int a[MAXN], L[MAXN * 30], R[MAXN * 30];
struct Trie {
int tot = 1;
int trie[MAXN * 30][2];
void insert(int pos) {
int x = 1;
for (int i = 30;; i--) {
int dir = (a[pos] >> i) & 1;
L[x] = min(L[x], pos), R[x] = max(R[x], pos);
if (i < 0) break;
if (!trie[x][dir]) trie[x][dir] = ++tot;
x = trie[x][dir];
}
return;
}
long long query(int x, int now, int dep) {
if (dep < 0) return 0ll;
int dir = (x >> dep) & 1;
if (trie[now][dir])
return query(x, trie[now][dir], dep - 1);
else
return query(x, trie[now][dir ^ 1], dep - 1) + (1ll << dep);
}
long long dfs(int now, int dep) {
if (dep < 0) return 0;
if (trie[now][0] && trie[now][1]) {
long long ans = 1ll << 30;
for (int i = L[trie[now][0]]; i <= R[trie[now][0]]; i++) {
ans = min(ans, (long long)query(a[i], trie[now][1], dep - 1));
}
ans += dfs(trie[now][0], dep - 1);
ans += dfs(trie[now][1], dep - 1);
ans += (1 << dep);
return ans;
} else if (trie[now][0]) {
return dfs(trie[now][0], dep - 1);
} else if (trie[now][1]) {
return dfs(trie[now][1], dep - 1);
}
return 0ll;
}
} trie;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
memset(L, 0x3f, sizeof(L));
for (int i = 1; i <= n; i++) trie.insert(i);
printf("%lld\n", trie.dfs(1, 30));
return 0;
}
| 13 | CPP |
def main():
a = list(map(int, input().split()))
assert(len(a) == 5)
z = [1, 1, 2, 7, 4]
ans = min(x // y for x, y in zip(a, z))
print(ans)
main()
| 9 | PYTHON3 |
#include <bits/stdc++.h>
long long dx[4] = {0, -1, 0, 1};
long long dy[4] = {1, 0, -1, 0};
using namespace std;
class pa3 {
public:
long long x, y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
double x;
long long y, z, w;
pa4(double x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-10);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-10)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-10)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-10)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-10)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-10)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-10)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-10)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-10));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
long long mod;
queue<long long> qu;
long long a[200020];
long long b[200020];
vector<long long> ve[200020];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, k, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
ve[a[i] % m].push_back(i);
}
for (long long g = 0; g < 4; g++) {
for (long long i = 0; i < m; i++) {
if (ve[i].size() == n / m) continue;
if (ve[i].size() > n / m) {
while (ve[i].size() != n / m) {
long long r = ve[i].back();
ve[i].pop_back();
qu.push(r);
}
} else {
while (1) {
if (qu.size() == 0) break;
if (ve[i].size() == n / m) break;
long long r = qu.front();
ve[i].push_back(r);
qu.pop();
}
}
}
}
long long ans = 0;
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < n / m; j++) {
if (a[ve[i][j]] % m == i) {
b[ve[i][j]] = a[ve[i][j]];
continue;
}
if (a[ve[i][j]] % m < i) {
b[ve[i][j]] = a[ve[i][j]];
b[ve[i][j]] += i - a[ve[i][j]] % m;
ans += i - a[ve[i][j]] % m;
continue;
}
if (a[ve[i][j]] % m > i) {
b[ve[i][j]] = a[ve[i][j]];
b[ve[i][j]] += m - a[ve[i][j]] % m + i;
ans += m - a[ve[i][j]] % m + i;
continue;
}
}
}
cout << ans << endl;
for (long long i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
return 0;
}
| 10 | CPP |
import math
t=int(input())
for i in range(t):
s=0
n=int(input())
p = int(math.log(n, 2))
for j in range(p+1):
s+=pow(2,j)
k=n*(n+1)//2
print(k-(2*s))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], x;
long long ans;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
ans += a[x ^ m];
a[x]++;
}
printf("%lld\n", ans);
}
| 8 | CPP |
#include <cstdlib>
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
int n, k;
vector<string> cards(n);
set<string> ans;
void dfs(string number = "", int depth = 0, int used = 0) {
if(depth == k)
ans.insert(number);
else
for(int i = 0; i < n; ++i)
if(!((used >> i) & 1))
dfs(number + cards[i], depth + 1, used | (1 << i));
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(cin >> n >> k, n) {
cards.clear();
cards.resize(n);
for(int i = 0; i < n; ++i)
cin >> cards[i];
ans.clear();
dfs();
cout << ans.size() << endl;
}
return EXIT_SUCCESS;
} | 0 | CPP |
s, n = map(int, input().split())
l = []
for i in range(n):
l.append(tuple(map(int, input().split())))
flag = True
#print(l)
for x, y in sorted(l):
if s>x:
s += y
else:
flag = False
break
if flag:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int paint(int x, int y, vector<string> &bd,
vector<vector<pair<int, int>>> &grp) {
int ret = 0;
stack<pair<int, int>> stk;
stk.push(make_pair(x, y));
while (stk.size()) {
auto cx = stk.top().first;
auto cy = stk.top().second;
stk.pop();
if (bd[cy][cx] == '*') {
ret++;
continue;
}
if (bd[cy][cx] != '.') {
continue;
}
bd[cy][cx] = 'x';
grp[cy][cx] = make_pair(x, y);
stk.push(make_pair(cx + 1, cy));
stk.push(make_pair(cx - 1, cy));
stk.push(make_pair(cx, cy + 1));
stk.push(make_pair(cx, cy - 1));
}
return ret;
}
int main() {
int h, w, k;
scanf("%d%d%d", &h, &w, &k);
vector<string> bd(h);
for (auto &r : bd) {
char buf[1024];
scanf("%s", buf);
r = buf;
}
vector<vector<pair<int, int>>> grp(
h, vector<pair<int, int>>(w, make_pair(-1, -1)));
vector<vector<int>> cnt(h, vector<int>(w, -1));
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
if (bd[y][x] != '.') continue;
cnt[y][x] = paint(x, y, bd, grp);
}
}
while (k--) {
int x, y;
scanf("%d%d", &y, &x);
x--, y--;
auto p = grp[y][x];
cout << cnt[p.second][p.first] << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
s = [i for i in input()]
T = ['R','G','B']
add = 0
for i in range(n-1):
if s[i] == s[i+1]:
add += 1
if i+2 < n:
for j in T:
if (j != s[i]) and (j !=s[i+2]):
s[i+1] = j
break
else:
for j in T:
if (j != s[i]):
s[i+1] = j
break
print(add)
print(''.join(s))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
int L=0,U=1000,x;
for(int i=0;i<N;i++){
cin >> x;
L=max(L,x);
U=min(U,x);
}
cout << L-U;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y);
long long gcd(long long a, long long b);
long long fact[250015];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long m;
cin >> m;
fact[0] = 1;
for (long long i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % m;
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long temp = 1;
temp = (n - i + 1) * (n - i + 1);
temp %= m;
temp *= fact[i];
temp %= m;
temp *= fact[n - i];
temp %= m;
ans += temp;
ans %= m;
}
cout << (ans % m);
return 0;
}
long long power(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long d[n], t[m];
for (long long i = 0; i < n; i++) {
cin >> d[i];
}
for (long long j = 0; j < m; j++) {
cin >> t[j];
}
long long l = 0, r = pow(10, 11), ans = LLONG_MAX;
while (l <= r) {
long long mid = (l + r) / 2;
long long flag = 0;
long long j = 0;
for (long long i = 0; i < n && j < m; i++) {
if (d[i] <= t[j]) {
while (j < m && t[j] <= d[i] + mid) {
j++;
}
} else {
if (d[i] - mid > t[j]) {
flag = 1;
break;
}
long long cnt1 = 0, cnt2 = 0, ind1 = j, ind2 = j;
while (ind1 < m && t[ind1] <= d[i]) {
ind1++;
cnt1++;
cnt2++;
ind2++;
}
while (ind1 < m && (t[ind1] <= d[i] + mid - 2 * (d[i] - t[j]))) {
ind1++;
cnt1++;
}
while (ind2 < m && (t[ind2] <= d[i] + ((mid - (d[i] - t[j])) / 2))) {
ind2++;
cnt2++;
}
if (cnt1 > cnt2) {
j = ind1;
} else {
j = ind2;
}
}
}
if (flag || j < m) {
l = mid + 1;
} else {
ans = min(ans, mid);
r = mid - 1;
}
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int CeilIndex(vector<int>& v, int l, int r, int key) {
while (r - l > 1) {
int m = l + (r - l) / 2;
if (v[m] >= key)
r = m;
else
l = m;
}
return r;
}
int lis(std::vector<int>& v) {
vector<int> tail(v.size(), 0);
int length = 1;
tail[0] = v[0];
for (size_t i = 1; i < v.size(); i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] > tail[length - 1])
tail[length++] = v[i];
else
tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i];
}
return length;
}
int main() {
vector<int> v;
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
cout << lis(v);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 101;
int C[N][N], n, m, k, dp[N][54][54][N];
inline int comb(int n, int m) { return C[m - 1][n - 1]; }
int f(int x, int last, int gr, int ways) {
if (gr > 50) return 0;
if (gr == 0) return (1 <= ways) * (m - last + 2);
if (last > m) return 0;
int &r = dp[x][last][gr][ways];
if (r != -1) return r;
r = 0;
for (int i = gr; i <= n - x; i++)
if (comb(gr, i) * ways <= k)
r = (r + f(x + i, last + 1, i - (gr - (last == 1)), ways * comb(gr, i))) %
mod;
return r;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
C[0][0] = 1;
for (int i = 1; i <= 100; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] > k) C[i][j] = k + 1;
}
}
memset(dp, -1, sizeof dp);
cout << f(0, 1, 1, 1) << '\n';
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double dd;
const int N = 1e5+5;
const int maxn = 1e9+5;
const dd eps = 1e-6;
const ll mod = 1e9+7;
int n,m,fa[N],pos[N],sta[N],l,r,vis[N];
vector<pair<int,int> > g[N];
pair<int,int> li[N];
vector<int> ans;
int find(int x){
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
bool unite(int u,int v){
int x = find(u),y = find(v);
if(x == y) return false;
fa[x] = y;
return true;
}
bool dfs(int now){
int res = sta[now];
vis[now] = 1;
for(int i = 0;i < g[now].size();i++){
int u = g[now][i].first;
if(vis[u]) continue;
bool nex = dfs(u);
if(nex) ans.push_back(g[now][i].second);
res ^= nex;
}
return res;
}
int main(){
// freopen("input.txt","r",stdin);
ios::sync_with_stdio(false);
cin>>n>>m;
for(int i = 1;i <= n;i++) {cin>>li[i].first>>li[i].second;fa[i] = i;}
sort(li+1,li+1+n);
for(int i = 1;i <= n;i++) pos[i] = li[i].first,sta[i] = li[i].second;
for(int i = n;i;i--) sta[i]^=sta[i-1];
for(int i = 1;i <= m;i++){
cin>>l>>r;
l = lower_bound(pos+1,pos+1+n,l) - pos;r = upper_bound(pos+1,pos+1+n,r)-pos;
if(unite(l,r)) g[l].push_back({r,i}),g[r].push_back({l,i});
}
dfs(n+1);
for(int i = 1;i <= n;i++){
if(vis[i]) continue;
if(dfs(i)){
cout<<"-1"<<endl;
return 0;
}
}
cout<<ans.size()<<endl;
sort(ans.begin(),ans.end());
for(auto i:ans) cout<<i<<" ";
if(ans.size()) cout<<endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T;
cin >> T;
for (int test_case = 1; test_case <= T; ++test_case) {
int n;
cin >> n;
int input[n + 1];
for (int i = 1; i <= n; ++i) cin >> input[i];
int idx = 1;
while (idx <= n) {
int min_ = input[idx];
int min_idx = idx;
for (int i = idx; i <= n; ++i) {
if (input[i] < min_) {
min_ = input[i];
min_idx = i;
}
}
if (min_ == input[idx]) {
++idx;
continue;
}
int next_idx = min_idx;
while (min_idx != idx) {
swap(input[min_idx], input[min_idx - 1]);
--min_idx;
}
idx = next_idx;
}
for (int i = 1; i <= n; ++i) cout << input[i] << ' ';
cout << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005;
long long n, m, p, remaining = 0, nochanges = 0;
long long s[20], mx[20], ans[20], stmx[20];
long long level[N][N];
char a[N][N];
queue<pair<long long, long long> > q[20];
long long dx[4] = {0, 0, +1, -1};
long long dy[4] = {+1, -1, 0, 0};
bool check(long long x, long long y) {
if (x < 1 || x > n || y < 1 || y > m) return 0;
return (a[x][y] == '.');
}
void work(long long idx) {
bool checker = 1;
while (q[idx].size() && remaining > 0) {
pair<long long, long long> p = q[idx].front();
long long x = p.first;
long long y = p.second;
if (level[x][y] == mx[idx]) {
nochanges += checker;
return;
}
q[idx].pop();
for (long long dir = 0; dir < 4; dir++) {
long long nx = x + dx[dir];
long long ny = y + dy[dir];
if (check(nx, ny)) {
checker = 0;
nochanges = 0;
ans[idx]++;
remaining--;
a[nx][ny] = (char)('0' + idx);
q[idx].push({nx, ny});
level[nx][ny] = level[x][y] + 1;
}
}
}
nochanges += checker;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> p;
for (long long i = 1; i <= p; i++) {
cin >> s[i];
mx[i] = s[i];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> a[i][j];
remaining += (a[i][j] == '.');
if (isdigit(a[i][j])) {
q[a[i][j] - '0'].push({i, j});
level[i][j] = 0;
ans[a[i][j] - '0']++;
}
}
}
long long player = 0;
while (remaining > 0 && nochanges < p) {
work(player + 1);
mx[player + 1] += s[player + 1];
player++;
player %= p;
}
for (long long i = 1; i <= p; i++) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
a,b,c,d = sorted((map(int,input().split())))
x1 = d-a
x2 = d-b
x3 = d-c
print(x1,x2,x3)
| 7 | PYTHON3 |
#code
n=int(input(''))
for i in range(n):
no=int(input(''))
if((no-4)%4==0):
print('yes')
else:
print('no')
| 7 | PYTHON3 |
l=list(map(int, input().split()))
r=list(map(int, input().split()))
print(max(0,2*max(r)-l[0]-1)) | 0 | PYTHON3 |
# cook your dish here
ans = 0
for _ in range(int(input())):
a,b,c=map(int,input().split())
if a+b+c >=2:
ans+=1
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first < b.first;
}
int main() {
long long n, m, x, c = 0, count = 0, l = 0, i;
string s;
char ch;
cin >> n >> m;
cin >> s;
s = 'a' + s + 'a';
for (i = 0; i < s.size(); i++) {
if (s[i] == '.') {
l++;
count++;
} else {
if (count > 0) {
count = 0;
c++;
}
}
}
while (m--) {
cin >> x >> ch;
if (ch == '.' && s[x] != '.') {
s[x] = '.';
if (s[x - 1] == '.' && s[x + 1] == '.') {
l += 1;
c -= 1;
} else if (s[x - 1] != '.' && s[x + 1] != '.') {
l += 1;
c += 1;
} else {
l += 1;
}
} else if (ch != '.' && s[x] == '.') {
s[x] = ch;
if (s[x - 1] == '.' && s[x + 1] == '.') {
l -= 1;
c += 1;
} else if (s[x - 1] != '.' && s[x + 1] != '.') {
l -= 1;
c -= 1;
} else {
l -= 1;
}
}
cout << l - c << "\n";
}
}
| 9 | CPP |
#include <bits/stdc++.h>
const int mod = (int)1e9 + 7;
const int inf = 1e7 + 100;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
const int N = 3000 + 10;
int n, m;
vector<int> v[N];
int dis[N][N];
void bfs(int s, int n) {
queue<int> q;
q.push(s);
for (int i = 1; i <= n; ++i) dis[s][i] = inf;
dis[s][s] = 0;
vector<bool> vis(n + 1);
while (!q.empty()) {
int x = q.front();
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (auto it : v[x]) {
if (dis[s][it] > 1 + dis[s][x]) {
dis[s][it] = 1 + dis[s][x];
q.push(it);
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int s1, s2, t1, t2, l1, l2;
cin >> s1 >> t1 >> l1;
cin >> s2 >> t2 >> l2;
int ans = -1;
for (int i = 1; i <= n; ++i) {
bfs(i, n);
}
if (dis[s1][t1] <= l1 and dis[s2][t2] <= l2) {
smax(ans, m - (dis[s1][t1] + dis[s2][t2]));
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
int ans1 = dis[s1][i] + dis[i][j] + dis[j][t1];
int ans2 = dis[s2][i] + dis[i][j] + dis[j][t2];
if (ans1 <= l1 and ans2 <= l2) {
smax(ans, m - (ans1 + ans2 - dis[i][j]));
}
ans1 = dis[s1][i] + dis[i][j] + dis[j][t1];
ans2 = dis[s2][j] + dis[j][i] + dis[i][t2];
if (ans1 <= l1 and ans2 <= l2) {
smax(ans, m - (ans1 + ans2 - dis[j][i]));
}
}
}
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
const int mod = 1e9 + 7;
int dp[1005] = {0};
void solve() {
string second, t;
cin >> second >> t;
int k;
cin >> k;
int n = second.size();
dp[0] = 1;
for (int i = 1; i <= k; ++i) {
int sum = 0;
for (int j = 0; j < n; ++j) sum = (sum + dp[j]) % mod;
for (int j = 0; j < n; ++j) dp[j] = (sum - dp[j] + mod) % mod;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (second == t) ans = (ans + dp[i]) % mod;
rotate(second.begin(), second.begin() + 1, second.end());
}
cout << ans;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 10 | CPP |
t = int(input())
max1 = ''; max2 = '';
square = 'No'
for i in range(0, t):
c = []
max1 = (input()); max2 = (input())
max1 += ' ' + max2
c = max1.split(' ')
if(c[0] == c[1] or c[2] == c[3]):
square = 'No'
print(square)
else:
c[0] = int(c[0]); c[1] = int(c[1]); c[2] = int(c[2]); c[3] = int(c[3]);
c.sort()
if(c[2] == c[3]):
if(c[0] + c[1] == c[3]):
square = 'Yes'
print(square)
else:
square = 'No'
print(square)
else:
square = 'No'
print(square)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int t, n;
std::cin >> t;
for (int i = 0; i < t; ++i) {
std::cin >> n;
std::vector<int> v(n);
for (int j = 0; j < n; ++j) {
std::cin >> v[j];
}
std::sort(v.begin(), v.end(), std::greater<int>());
for (int k : v) {
std::cout << k << " ";
}
std::cout << std::endl;
}
return 0;
}
| 8 | CPP |
n = input()
cnt=0
for i in n:
if i=='4' or i=='7':
cnt+=1
if cnt==4 or cnt==7:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (k); i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) begin(a),end(a)
#define MS(m,v) memset(m,v,sizeof(m))
#define D10 fixed<<setprecision(5)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<short, short> P;
typedef complex<double> Point;
typedef long long ll;
const int INF = 1145141919;
const int MOD = 100000007;
const double EPS = 1e-10;
const double PI = acos(-1.0);
struct edge
{
int from, to, cost;
bool operator < (const edge& e) const { return cost < e.cost; }
bool operator > (const edge& e) const { return cost > e.cost; }
};
///*************************************************************************************///
///*************************************************************************************///
///*************************************************************************************///
int main()
{
int n, m, q;
while (cin >> n >> m >> q, n)
{
vector<vi> v(m);
REP(i, m)REP(j, n) v[i].push_back(j);
string b, s, preb(m,'0'), pres(n,'0');
REP(r, q)
{
cin >> s >> b;
vi op,rem;
REP(i, n)
{
if (s[i]=='1') op.push_back(i);
else rem.push_back(i);
}
REP(i, m)
{
if (v[i].size()>1 && preb[i] == b[i])
{
REP(j, v[i].size())
{
if (find(ALL(op), v[i][j]) != op.end())
{
v[i].erase(v[i].begin() + j);
j--;
}
}
}
else if (v[i].size()>1 && preb[i] != b[i])
{
REP(j, v[i].size())
{
if (find(ALL(rem), v[i][j]) != rem.end())
{
v[i].erase(v[i].begin() + j);
j--;
}
}
}
}
pres = s; preb = b;
}
REP(i, m)
{
if (v[i].size() > 1||v[i].size()==0) cout << '?';
else if (v[i][0] < 10) cout << v[i][0];
else
{
cout << char('A' + v[i][0] - 10);
}
}
cout << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int INF = 0x3f3f3f3f;
int H, W, N;
int mini[MAXN];
int main() {
memset(mini, INF, sizeof mini);
scanf("%d%d%d", &H, &W, &N);
while (N--) {
int x, y;
scanf("%d%d", &x, &y);
mini[x] = min(mini[x], y);
}
int curr = 1;
for (int i = 2; i <= H; i++) {
if (mini[i] <= curr) {
printf("%d\n", i - 1);
return 0;
}
curr = min(curr + 1, mini[i] - 1);
}
printf("%d\n", H);
return 0;
} | 0 | CPP |
a = -(-sum(map(int,input().split()))//5)
b = -(-sum(map(int,input().split()))//10)
n = int(input())
print(('NO','YES')[a+b<=n]) | 7 | PYTHON3 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 300010
using namespace std;
struct node{
int l,r;
bool operator <(const node a)const{return r-l<a.r-a.l;}
}p[N];
int tree[N<<2];
inline int lowbit(int x){return x&(-x);}
void insert(int u,int v){for(;u<N<<2;u+=lowbit(u)) tree[u]+=v;}
int answer(int u){int ans=0;for(;u;u-=lowbit(u)) ans+=tree[u];return ans;}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d%d",&p[i].l,&p[i].r),p[i].l++,p[i].r++;
sort(p+1,p+n+1);
int u=1;
for(int i=1;i<=m;i++)
{
while(p[u].r-p[u].l+1<i && u<=n)
{
insert(p[u].l,1);
insert(p[u].r+1,-1);
u++;
}
int ans=n-u+1;
for(int j=0;j<=m;j+=i) ans+=answer(j+1);
printf("%d\n",ans);
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[110];
int n;
long long k, Maxx, ans;
bool check(long long d) {
long long sum = 0;
for (int i = 0; i < n; i++) sum += (a[i] + d - 1LL) / d;
sum *= d;
return sum <= Maxx;
}
int main() {
cin >> n >> k;
Maxx = k;
for (int i = 0; i < n; i++) {
cin >> a[i];
Maxx += a[i];
}
for (long long st = 1, en; st <= Maxx; st = en + 1) {
en = Maxx / (Maxx / st);
if (check(en)) ans = en;
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
const long long INF = 1000000007;
const long double cp = 2 * asin(1.0);
const long double eps = 1e-9;
const long long mod = 1000000007;
using namespace std;
int x;
long long v[4], res;
char s[4][5];
vector<long long> a;
void dfs(vector<long long> p, int n) {
vector<long long> T;
if (n == 3)
res = min(res, p[0]);
else {
for (int(i) = 0; (i) < (p.size()); i++)
for (int(j) = (i + 1); (j) <= (p.size() - 1); j++) {
T = p;
T.erase(T.begin() + i);
T.erase(T.begin() + j - 1);
if (s[n][0] == '+')
T.push_back(p[i] + p[j]);
else
T.push_back(p[i] * p[j]);
dfs(T, n + 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
for (int(i) = 0; (i) < (4); i++) {
cin >> x;
a.push_back(x);
}
cin >> s[0] >> s[1] >> s[2];
res = 1LL << 60;
dfs(a, 0);
cout << res;
return 0;
}
| 8 | CPP |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <queue>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<30;
template<class T> T lower_search(T lb, T ub, bool (*C)(T)) {
while(ub-lb>1) { // ツつアツつアツづ債適ツ督鳴づ可。
T mid = (lb+ub)/2;
if (C(mid)) ub = mid;
else lb = mid;
}
return ub;
}
int m, n;
int a[100];
bool C(int x) {
int hoge = 0;
REP(i,m) {
int tmp = 0;
while(tmp + a[hoge] <= x) {
tmp += a[hoge];
hoge++;
if (hoge >= n)
return true;
}
}
return false;
}
int main() {
while(cin >> m >> n, m+n) {
REP(i,n) {
cin >> a[i];
}
cout << lower_search(0, INF, C) << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int t = int(sqrt(m + 0.5));
for (int i = 1; i <= t; i++)
if (m % i == 0)
if (m / i > 1 && i >= k || i > 1 && m / i >= k)
return puts(n % 2 ? "Timur" : "Marsel");
puts("Marsel");
}
| 9 | CPP |
n = int(input())
i = 8 + 10 * len(str(n))
while(i * (i + 1) * (i + 2) / 6 > n):
i -= 1
print(i) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
string kata, keyboard = "qwertyuiopasdfghjkl;zxcvbnm,./";
cin >> c;
getchar();
getline(cin, kata);
if (c == 'L') {
for (int x = 0; x < kata.size(); x++) {
for (int y = 0; y < keyboard.size(); y++) {
if (keyboard[y] == kata[x]) {
cout << keyboard[y + 1];
break;
}
}
}
} else if (c == 'R') {
for (int x = 0; x < kata.size(); x++) {
for (int y = 0; y < keyboard.size(); y++) {
if (keyboard[y] == kata[x]) {
cout << keyboard[y - 1];
break;
}
}
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gg(char x) {
if (x == 'L' || x == 'U') {
return 0;
} else {
return 1;
}
}
int main() {
string s1;
int n;
cin >> n;
cin >> s1;
set<int> lr;
set<int> ud;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s1[i] == 'L') {
lr.insert(0);
} else if (s1[i] == 'R') {
lr.insert(1);
} else if (s1[i] == 'U') {
ud.insert(0);
} else {
ud.insert(1);
}
if (lr.size() > 1) {
cnt++;
lr.clear();
lr.insert(gg(s1[i]));
ud.clear();
}
if (ud.size() > 1) {
cnt++;
ud.clear();
ud.insert(gg(s1[i]));
lr.clear();
}
}
cout << cnt + 1;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void chkmin(T &a, T b) {
if (a > b) a = b;
}
int n, m, x;
int a[300010];
int v[300010 << 2][2];
bool vis[300010 << 2], rev[19 << 1], pft[300010 << 2];
void build() {
vector<int> tmp;
int tot = 0;
for (int i = 1, m; i <= n; i++) {
tmp.clear();
m = a[i];
for (int i = 1; i <= 19; i++) {
tmp.push_back(m & 1);
m >>= 1;
}
int node = 0;
for (int i = 19 - 1; i >= 0; i--) {
if (v[node][tmp[i]] == 0) v[node][tmp[i]] = ++tot;
node = v[node][tmp[i]];
}
vis[node] = 1;
}
}
void dfs(int nd) {
int cnt = 0;
for (int i = 0; i < 2; i++) {
if (v[nd][i]) {
cnt++;
dfs(v[nd][i]);
}
}
if (cnt == 0)
pft[nd] = 1;
else if (cnt == 2 && pft[v[nd][0]] && pft[v[nd][1]])
pft[nd] = 1;
}
int an, k;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
build();
dfs(0);
while (m--) {
scanf("%d", &x);
for (int i = 19; i >= 1; i--) {
rev[i] ^= (x & 1);
x >>= 1;
}
an = 0;
for (int i = 1, nd = 0; i <= 19; i++) {
if (!v[nd][rev[i]]) {
an <<= (19 + 1 - i);
break;
} else if (pft[v[nd][rev[i]]]) {
an = 2 * an + 1;
if (!v[nd][1 - rev[i]]) {
an <<= (19 - i);
break;
} else
nd = v[nd][1 - rev[i]];
} else {
an = 2 * an;
nd = v[nd][rev[i]];
}
}
cout << an << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
a = [list(map(int,input().split())) for i in range(n)]
b = [list(map(int,input().split())) for i in range(n)]
b.sort(key=lambda x: x[0])
a.sort(key=lambda x: x[1])
seen = [0]*n
count = 0
for i in range(n):
for j in range(n):
if (seen[j] == 0) and (a[-(i+1)][0] < b[j][0]) and (a[-(i+1)][1] < b[j][1]):
seen[j] = 1
count = count + 1
break
print(count) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10;
int main() {
int a, b, c, x, y, z;
cin >> a >> b >> c >> x >> y >> z;
a = a - x, b = b - y, c = c - z;
int sum = 0;
if (a > 0)
sum += (a / 2);
else
sum += a;
if (b > 0)
sum += (b / 2);
else
sum += b;
if (c > 0)
sum += (c / 2);
else
sum += c;
if (sum >= 0)
cout << "Yes";
else
cout << "No";
return 0;
}
| 7 | CPP |
a=int(input())
i=0
c=input()
b=[]
while i<a:
b.append(int(c.split(" ")[i]))
i=i+1
b.sort(reverse=True)
dif=sum(b)/2
sum=0
i=0
while i<a:
sum=sum+b[i]
if sum>dif:
print(i+1)
break
i=i+1
| 7 | PYTHON3 |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int n,m,x,y,z,l,r,a[300005];
int rt[300005],ls[12000005],rs[12000005],tot;
ull c[300005],val[12000005];
int head[300005],to[600005],nex[600005],cnt;
int fa[300005][19],dep[300005];
inline ull rd(){
ull res=0;
for(int i=0;i<=60;i+=15)
res^=(ull)rand()<<i;
return res;
}
void modify(int &u,int v,int l,int r,int x,ull y){
u=++tot;
ls[u]=ls[v];rs[u]=rs[v];val[u]=val[v]^y;
if(l<r){
int mid=(l+r)>>1;
if(x<=mid)modify(ls[u],ls[v],l,mid,x,y);
else modify(rs[u],rs[v],mid+1,r,x,y);
}
}
int query(int u1,int u2,int u3,int u4,int l,int r,int x,int y){
if(!(val[u1]^val[u2]^val[u3]^val[u4]))return -1;
if(l==r)return l;
int mid=(l+r)>>1,res=-1;
if(x<=mid)res=query(ls[u1],ls[u2],ls[u3],ls[u4],l,mid,x,y);
if(~res)return res;
if(y>mid)res=query(rs[u1],rs[u2],rs[u3],rs[u4],mid+1,r,x,y);
return res;
}
inline void adde(int f,int t){
to[++cnt]=t;
nex[cnt]=head[f];
head[f]=cnt;
}
void dfs(int u,int pre){
fa[u][0]=pre;dep[u]=dep[pre]+1;
for(int i=1;i<=18;++i)
fa[u][i]=fa[fa[u][i-1]][i-1];
modify(rt[u],rt[pre],1,n,a[u],c[a[u]]);
for(int i=head[u],v;i;i=nex[i]){
v=to[i];
if(v==pre)continue;
dfs(v,u);
}
}
inline int lca(int x,int y){
if(dep[x]<dep[y])swap(x,y);
int t=dep[x]-dep[y];
for(int i=0;i<=18;++i)
if((t>>i)&1)x=fa[x][i];
if(x==y)return x;
for(int i=18;~i;--i){
if(fa[x][i]!=fa[y][i]){
x=fa[x][i];
y=fa[y][i];
}
}
return fa[x][0];
}
int main(){
srand(19491001);
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i){
scanf("%d",a+i);
c[i]=rd();
}
for(int i=1;i<n;++i){
scanf("%d%d",&x,&y);
adde(x,y);adde(y,x);
}
dfs(1,0);
while(m--){
scanf("%d%d%d%d",&x,&y,&l,&r);
z=lca(x,y);
printf("%d\n",query(rt[x],rt[y],rt[z],rt[fa[z][0]],1,n,l,r));
}
return 0;
} | 10 | CPP |
while True:
try:
x=[[int(i) for i in input()] for j in range(8)]
count=0
num=[]
for i in range(8):
if x[i].count(1)!=0:
num.append(i)
count+=1
if count==1:
print("C")
elif count==4:
print("B")
elif count==2:
for j in range(8):
if x[num[0]][j]==1:
if j==0:
if x[num[0]+1][j]==1:
print("A")
else:
print("E")
else:
if x[num[0]+1][j-1]==1:
print("G")
else:
if x[num[0]+1][j]==1:
print("A")
else:
print("E")
break
else:
for j in range(8):
if x[num[0]][j]==1:
if j==0:
print("F")
else:
if x[num[0]+1][j-1]==1:
print("D")
else:
print("F")
break
input()
except EOFError:
break
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s[85];
int n, cv, ck, co, pv[85], pk[85], po[85], uv[85], uk[85], uo[85],
f[85][85][85][2];
void getmin(int& a, int b) { a = min(a, b); }
int main() {
scanf("%d%s", &n, s);
for (int i = 0; i < n; i++) {
if (i != 0) {
uo[i] = uo[i - 1];
uv[i] = uv[i - 1];
uk[i] = uk[i - 1];
}
if (s[i] == 86) {
pv[cv++] = i, uv[i]++;
} else if (s[i] == 75) {
pk[ck++] = i, uk[i]++;
} else {
po[co++] = i, uo[i]++;
}
}
memset(f, 0x3f, sizeof f);
f[0][0][0][0] = 0;
for (int i = 0; i <= cv; i++) {
for (int j = 0; j <= ck; j++) {
for (int k = 0; k <= co; k++) {
int pos = i + j + k;
for (int t = 0; t <= 1; t++) {
if (i < cv) {
getmin(f[i + 1][j][k][1],
f[i][j][k][t] + abs(uk[pv[i]] - j) + abs(uo[pv[i]] - k));
}
if (j < ck && !t) {
getmin(f[i][j + 1][k][0],
f[i][j][k][t] + abs(uv[pk[j]] - i) + abs(uo[pk[j]] - k));
}
if (k < co) {
getmin(f[i][j][k + 1][0],
f[i][j][k][t] + abs(uv[po[k]] - i) + abs(uk[po[k]] - j));
}
}
}
}
}
printf("%d\n", min(f[cv][ck][co][0], f[cv][ck][co][1]) / 2);
}
| 11 | CPP |
s = list(map(int,input().split()))
c = 0
s.sort()
n = len(s)
for i in range(n-1):
if s[i] == s[i+1]:
c += 1
print(c)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int x[n];
for (int i = 0; i < n; ++i) scanf("%d", x + i);
int m;
scanf("%d", &m);
int y[m];
for (int i = 0; i < m; ++i) scanf("%d", y + i);
int k;
scanf("%d", &k);
int z[k];
for (int i = 0; i < k; ++i) scanf("%d", z + i);
int a, b;
scanf("%d%d", &a, &b);
long long r1 = 0, p1, p2 = INT_MAX;
for (int i = 0; i < n; ++i) r1 = max((long long)x[i], r1);
for (int l = 0; l < k; ++l) p2 = min((long long)z[l], p2);
double ans = 0, q;
for (int j = 0; j < m; ++j) {
p1 = y[j];
q = sqrt(double(r1 * r1 * p1 * b) / (a * p2 + b * p1));
if (ans + 1e-8 < q) ans = q;
}
printf("%.9lf\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const long long int mod = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
string s;
cin >> s;
int n = int((s).size());
s = "#" + s;
long long int seq = 0, seq1 = 0;
for (long long int i = (1); i <= (n); i++) {
if (s[i] == 'a')
seq += seq1 + 1;
else if (s[i] == 'b')
seq1 = seq;
seq = seq % mod;
}
cout << seq << endl;
}
| 9 | CPP |
arr = []
n,x = map(int,input().split())
for i in range(n):
a,b = map(int,input().split())
arr.append([a,b])
minutes = 0
for i in arr:
minutes += i[1] - i[0] + 1
minutes += (arr[0][0] - 1)%x
for i in range(1,n):
minutes += (arr[i][0] - arr[i-1][1] - 1)%x
print(minutes)
| 7 | PYTHON3 |
class Tree():
def __init__(self):
self.nodes = {}
self.root = None
def add_node(self, key):
if key not in self.nodes:
self.nodes[key] = Node(key)
def insert(self, z_key):
self.add_node(z_key)
z = self.nodes[z_key]
y = None # xの親
x = self.root
while x is not None:
y = x # 親を設定
if z.key < x.key:
x = x.left
else:
x = x.right
z.parent = y
if y is None:
self.root = z
elif z.key < y.key:
y.left = z
else:
y.right = z
def __str__(self):
ans_in, ans_pre = [], []
self.root.in_walk(ans_in)
self.root.pre_walk(ans_pre)
str_in = ' ' + ' '.join(map(str, ans_in))
str_pre = ' ' + ' '.join(map(str, ans_pre))
return str_in + '\n' + str_pre
class Node():
def __init__(self, key):
self.key = key
self.left = None
self.right = None
self.parent = None
def pre_walk(self, ans):
ans.append(self.key)
if self.left:
self.left.pre_walk(ans)
if self.right:
self.right.pre_walk(ans)
def in_walk(self, ans):
if self.left:
self.left.in_walk(ans)
ans.append(self.key)
if self.right:
self.right.in_walk(ans)
# ここからmain
tree = Tree()
n = int(input())
for i in range(n):
line = list(map(str, input().split()))
if line[0] == 'insert':
key = int(line[1])
tree.insert(key)
else:
print(tree)
| 0 | PYTHON3 |
#include <iostream>
#include <string>
using namespace std;
int main(){
int n;
string str;
cin >> n;
while(n--){
int ans = 0, out = 0, per = 0;
while(1){
cin >> str;
if(str[1] == 'I'){
per++;
if(per > 3){per--;ans++;}
}
if(str[1] == 'O'){
ans += per + 1;
per = 0;
}
if(str[1] == 'U' && ++out == 3)break;
//cout << per << ans << endl;
}
cout << ans << endl;
}
} | 0 | CPP |
n,a,b,c=map(int,input().split())
d=[0]+[-99999999]*100000
for i in range(n):
d[i+1]=max(d[i+1-a],d[i+1-b],d[i+1-c])+1
print(d[n]) | 7 | PYTHON3 |
n = int(input())
stones = input()
combo = 1
for i in range(1, len(stones)):
if stones[i - 1] == stones[i]:
combo += 1
print(combo - 1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int arr[101][101];
int code[101], cnt[101];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (n < m) {
scanf("%d", &arr[j][i]);
} else {
scanf("%d", &arr[i][j]);
}
}
}
if (n < m) {
swap(n, m);
}
if (n > 2 * k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
bool isSame = 1, isDiff = 1;
for (int c = 0; c < m; ++c) {
if (arr[i][c] != arr[j][c]) {
isSame = 0;
} else {
isDiff = 0;
}
}
if (isSame || isDiff) {
code[i] = code[j];
} else {
code[i] = i;
}
cnt[code[i]]++;
}
}
int best = 0, f = 0;
for (int i = 0; i < n; ++i) {
if (cnt[i] > best) {
best = cnt[i];
f = i;
}
}
if (n - best > k) {
cout << "-1\n";
} else {
int soln = 0;
for (int i = 0; i < n; ++i) {
if (code[i] != f) {
int cSame = 0, cDiff = 0;
for (int j = 0; j < m; ++j) {
cSame += (arr[i][j] != arr[f][j]);
cDiff += (arr[i][j] == arr[f][j]);
}
soln += min(cSame, cDiff);
}
}
if (soln <= k) {
cout << soln << "\n";
} else {
cout << "-1\n";
}
}
} else if (n > k) {
int soln = 200;
for (int f = 0; f < n; ++f) {
int curr = 0;
for (int i = 0; i < n; ++i) {
int cSame = 0, cDiff = 0;
for (int j = 0; j < m; j++) {
cSame += (arr[i][j] != arr[f][j]);
cDiff += (arr[i][j] == arr[f][j]);
}
curr += min(cSame, cDiff);
}
soln = min(curr, soln);
}
if (soln <= k) {
cout << soln << "\n";
} else {
cout << "-1\n";
}
} else {
int soln = 200;
for (int mask = 0; mask < (1 << m); ++mask) {
int curr = 0;
for (int i = 0; i < n; ++i) {
int cSame = 0, cDiff = 0;
for (int j = 0; j < m; ++j) {
cSame += (arr[i][j] != (bool)(mask & (1 << j)));
cDiff += (arr[i][j] == (bool)(mask & (1 << j)));
}
curr += min(cSame, cDiff);
}
soln = min(soln, curr);
}
if (soln <= k) {
cout << soln << "\n";
} else {
cout << "-1\n";
}
}
}
| 8 | CPP |
n=[int(i) for i in input().split()]
s=max(n)
n.remove(s)
print(s-n[2],s-n[1],s-n[0]) | 7 | PYTHON3 |
print('Yes' if int(input())%9==0 else 'No') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace NTT {
const int EXP = 23;
const unsigned long long EXP_MULT = 119, NTT_MOD = (EXP_MULT << EXP) + 1;
unsigned long long rt[EXP + 1], invrt[EXP + 1];
bool built;
unsigned long long modPow(unsigned long long a, unsigned long long p) {
return p ? modPow((a) * (a) % NTT_MOD, p >> 1) * (p & 1 ? a : 1) % NTT_MOD
: 1;
}
unsigned long long invMod(unsigned long long a) {
return modPow(a, NTT_MOD - 2);
}
unsigned long long findCyclic() {
vector<long long> multFactors;
unsigned long long temp = EXP_MULT;
for (long long i = 2; i * i <= temp; i += 2) {
if (temp % i == 0) multFactors.push_back(i);
while (temp % i == 0) temp /= i;
if (i == 2) i--;
}
if (temp > 1) multFactors.push_back(temp);
for (long long i = 2; i < NTT_MOD; i++) {
bool works = 1;
if (modPow(i, NTT_MOD >> 1) == 1) works = 0;
for (const int factor : multFactors)
if (modPow(i, NTT_MOD / factor) == 1) works = 0;
if (works) return i;
}
}
void buildRT() {
if (built) return;
built = 1;
rt[EXP] = modPow(findCyclic(), EXP_MULT);
for (int i = (EXP)-1; i >= 0; i--)
rt[i] = (rt[i + 1]) * (rt[i + 1]) % NTT_MOD;
for (int i = 0; i < (EXP + 1); i++) invrt[i] = invMod(rt[i]);
}
int rev(int idx, int sz) {
int tmp = 1, res = 0;
sz >>= 1;
while (sz) {
if (sz & idx) res |= tmp;
sz >>= 1;
tmp <<= 1;
}
return res;
}
vector<unsigned long long> bitReverseCopy(vector<unsigned long long> val) {
vector<unsigned long long> res(val.size());
for (int i = 0; i < (val.size()); i++) res[i] = val[rev(i, val.size())];
return res;
}
vector<unsigned long long> ntt(vector<unsigned long long> val) {
buildRT();
vector<unsigned long long> res = bitReverseCopy(val);
int n = res.size();
for (int i = (1); i < (32 - __builtin_clz(n)); i++) {
int m = 1 << i;
unsigned long long wm = rt[i];
for (int k = 0; k < n; k += m) {
unsigned long long w = 1;
for (int j = 0; j < (m >> 1); j++) {
unsigned long long t = w * res[k + j + (m >> 1)] % NTT_MOD;
unsigned long long u = res[k + j];
res[k + j] = (u + t) % NTT_MOD;
res[k + j + (m >> 1)] = (u + NTT_MOD - t) % NTT_MOD;
w = (w * wm) % NTT_MOD;
}
}
}
return res;
}
vector<unsigned long long> invntt(vector<unsigned long long> val) {
swap(rt, invrt);
vector<unsigned long long> res = ntt(val);
swap(rt, invrt);
unsigned long long u = invMod(val.size());
for (int i = 0; i < (res.size()); i++) res[i] = (res[i] * u) % NTT_MOD;
return res;
}
vector<unsigned long long> conv(vector<unsigned long long> a,
vector<unsigned long long> b) {
int finalSZ = a.size() + b.size() - 1;
int neededSZ = 1 << (32 - __builtin_clz(finalSZ - 1));
a.resize(neededSZ), b.resize(neededSZ);
a = ntt(a), b = ntt(b);
for (int i = 0; i < (neededSZ); i++) a[i] = a[i] * b[i] % NTT_MOD;
a = invntt(a);
a.resize(finalSZ);
return a;
}
}; // namespace NTT
using namespace NTT;
struct Polynomial {
int deg;
unsigned long long* coefficients;
Polynomial(int d = 0) {
deg = d;
coefficients = new unsigned long long[deg + 1];
memset(coefficients, 0, (deg + 1) * sizeof(unsigned long long));
}
Polynomial operator()(Polynomial p) {
Polynomial curr;
curr[0] = 1;
Polynomial res;
for (int i = 0; i < (deg + 1); i++) {
res += curr * coefficients[i];
curr *= p;
}
return res;
}
Polynomial operator+(unsigned long long a) {
Polynomial p(deg);
for (int i = 0; i < (deg + 1); i++) p[i] = coefficients[i];
p[0] += a;
p[0] %= NTT_MOD;
return p;
}
Polynomial operator-(unsigned long long a) {
Polynomial p(deg);
for (int i = 0; i < (deg + 1); i++) p[i] = coefficients[i];
p[0] += NTT_MOD - a;
p[0] %= NTT_MOD;
return p;
}
Polynomial operator*(unsigned long long mult) {
Polynomial p(deg);
for (int i = 0; i < (deg + 1); i++) p[i] = coefficients[i] * mult % NTT_MOD;
return p;
}
Polynomial operator/(unsigned long long div) { return *this * invMod(div); }
Polynomial operator+(Polynomial b) {
Polynomial res(max(deg, b.deg));
for (int i = 0; i < (max(deg, b.deg) + 1); i++)
res[i] = (((i > deg) ? 0 : coefficients[i]) + ((i > b.deg) ? 0 : b[i])) %
NTT_MOD;
return res;
}
Polynomial operator-(Polynomial p) { return *this + (p * (NTT_MOD - 1)); }
Polynomial operator*(Polynomial b) {
vector<unsigned long long> va, vb;
for (int i = 0; i < (deg + 1); i++) va.push_back((*this)[i]);
for (int i = 0; i < (b.deg + 1); i++) vb.push_back(b[i]);
vector<unsigned long long> vc = NTT::conv(va, vb);
Polynomial res(vc.size() - 1);
for (int i = 0; i < (vc.size()); i++) res[i] = vc[i];
return res;
}
void operator+=(unsigned long long a) {
coefficients[0] += a, coefficients[0] %= NTT_MOD;
}
void operator-=(unsigned long long a) { *this += NTT_MOD - a; }
void operator*=(unsigned long long mult) {
for (int i = 0; i < (deg + 1); i++)
coefficients[i] *= mult, coefficients[i] %= NTT_MOD;
}
void operator/=(unsigned long long div) { *this *= invMod(div); }
void operator+=(Polynomial b) { *this = *this + b; }
void operator-=(Polynomial p) { *this = *this - p; }
void operator*=(Polynomial b) { *this = *this * b; }
unsigned long long& operator[](int idx) { return coefficients[idx]; }
};
int N, A, B;
long long C(long long n, long long r) {
long long res = 1;
long long div = 1;
for (int i = 0; i < (r); i++) res = res * (n - i) % NTT_MOD;
for (int i = (1); i < (r + 1); i++) div = div * i % NTT_MOD;
return res * invMod(div) % NTT_MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> A >> B;
if (A + B - 2 > N - 1 || A == 0 || B == 0) {
cout << 0 << endl;
return 0;
}
queue<Polynomial> q;
Polynomial strt(0);
strt[0] = 1;
q.push(strt);
for (int i = 0; i < (N - 1); i++) {
Polynomial mult(1);
mult[1] = 1;
mult[0] = i;
q.push(mult);
}
while (q.size() > 1) {
Polynomial a = q.front();
q.pop();
Polynomial b = q.front();
q.pop();
q.push(a * b);
}
cout << q.front()[A + B - 2] * C(A + B - 2, A - 1) % NTT_MOD << endl;
return 0;
}
| 13 | CPP |
n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))
result = []
accept = 0
for i in range(n):
if accept == 1:
break
for j in range(m):
if ((a[i] + b[j]) not in a) and ((a[i] + b[j]) not in b):
accept = 1
result.append(a[i])
result.append(b[j])
print(*result)
break | 7 | PYTHON3 |
print(["CHAT WITH HER!", "IGNORE HIM!"][len(set(c for c in input()))%2]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int maxn = 77777 + 5;
const long long inf = 9223372036854775807;
const long long mod = 777777777;
long long a[4][4], n, q, seg[4][4][4 * maxn], sz, c[4 * maxn], c1;
void merge(int x) {
for (int i = 1; i < 4; i++)
for (int j = 1; j < 4; j++) seg[i][j][x] = 0;
for (int i = 1; i < 4; i++)
for (int j = 1; j < 4; j++)
for (int k = 1; k < 4; k++)
for (int w = 1; w < 4; w++)
if (a[k][w])
seg[i][j][x] =
(seg[i][j][x] +
((seg[i][k][x << 1] * seg[w][j][x << 1 | 1]) % mod)) %
mod;
}
void build(int x = 1, int lx = 1, int rx = n + 1) {
if (rx - lx == 1) {
for (int i = 1; i < 4; i++) seg[i][i][x] = 1;
return;
}
int mid = lx + rx >> 1;
build(x << 1, lx, mid);
build(x << 1 | 1, mid, rx);
merge(x);
}
void upd(int I, int v, int x = 1, int lx = 1, int rx = n + 1) {
if (rx - lx == 1) {
if (v == 0)
for (int i = 1; i < 4; i++) seg[i][i][x] = 1;
else
for (int i = 1; i < 4; i++) seg[i][i][x] = 0;
seg[v][v][x] = 1;
return;
}
int mid = lx + rx >> 1;
if (I < mid)
upd(I, v, x << 1, lx, mid);
else
upd(I, v, x << 1 | 1, mid, rx);
merge(x);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> q;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j < 4; j++) {
cin >> a[i][j];
c1 += a[i][j];
}
}
build();
long long v, t, s;
while (q--) {
cin >> v >> t;
upd(v, t);
s = 0;
for (int i = 1; i < 4; i++)
for (int j = 1; j < 4; j++) s = (s + seg[i][j][1]) % mod;
cout << s << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1<<28;
const int MAXN = 1000001;
const int di[] = {0,1,0,-1};
const int dj[] = {1,0,-1,0};
bool isPrime[MAXN];
int I[MAXN], J[MAXN];
const int H = 1111;
const int W = 1111;
int G[H][W];
int m, n;
pair<int, int> dp[H][W];
int main() {
fill(isPrime, isPrime+MAXN, true);
isPrime[0] = isPrime[1] = false;
for(int i = 2; i < MAXN; ++i) {
if(!isPrime[i]) continue;
for(int j = i*2; j < MAXN; j += i) {
isPrime[j] = false;
}
}
{
fill(G[0], G[H], INF);
int pi = 500, pj = 500, d = 2;
G[pi][pj] = 1;
I[1] = pi, J[1] = pj;
for(int num = 2; num < MAXN; ++num) {
for(int k = 0; k < 4; ++k) {
int nd = (d + k + 2) % 4;
int ni = pi + di[nd];
int nj = pj + dj[nd];
if(G[ni][nj] != INF) continue;
G[ni][nj] = num;
pi = ni, pj = nj, d = nd;
I[num] = pi, J[num] = pj;
break;
}
}
}
while(cin >> m >> n && (m|n)) {
int si = I[n], sj= J[n];
fill(dp[0], dp[H], make_pair(-1, -1));
dp[si][sj] = make_pair(isPrime[G[si][sj]],
isPrime[G[si][sj]] * G[si][sj]);
pair<int, int> res = dp[si][sj];
for(int i = si; i+1 < H; ++i) {
for(int j = 0; j < W; ++j) {
if(dp[i][j].first == -1) continue;
for(int d = -1; d <= 1; ++d) {
int ni = i + 1;
int nj = j + d;
if(nj < 0 || nj >= W) continue;
if(G[ni][nj] > m) continue;
dp[ni][nj]
= max(dp[ni][nj],
make_pair(dp[i][j].first + isPrime[G[ni][nj]],
max(dp[i][j].first, isPrime[G[ni][nj]]*G[ni][nj])));
res = max(res, dp[ni][nj]);
}
}
}
cout << res.first << " " << res.second << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void autoinput() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
const long long mod = 1000000007;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long bigmod(long long N, long long P) {
if (P == 0) return 1;
if (P % 2 == 0) {
long long ret = bigmod(N, P / 2);
return ((ret % mod) * (ret % mod)) % mod;
} else
return ((N % mod) * (bigmod(N, P - 1) % mod)) % mod;
}
long long modInverse(long long a, long long m) { return bigmod(a, m - 2); }
long long arr[200005], n = 4, sum = 0;
long long dp[5][1000];
bool func(long long x, long long tot) {
if (x >= n) return 0;
if (dp[x][tot] != -1) return dp[x][tot];
if ((tot + arr[x]) * 2 == sum) return dp[x][tot] = 1;
long long way1 = func(x + 1, tot);
long long way2 = func(x + 1, tot + arr[x]);
return dp[x][tot] = way2 | way1;
}
int main() {
memset(dp, -1, sizeof dp);
long long i, j, k, l, m;
sum = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
if (func(0, 0))
cout << "YES";
else
cout << "NO";
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int mx = 1, n, f = 2;
cin >> n;
int b[n];
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 1) {
f = 2;
break;
} else {
f = 5;
}
}
if (f == 2) {
cout << "HARD" << endl;
}
if (f == 5) {
cout << "EASY" << endl;
}
}
| 7 | CPP |
A11, A21, A31 = input().split()
A12, A22, A32 = input().split()
A13, A23, A33 = input().split()
A = input()
A41, A51, A61 = input().split()
A42, A52, A62 = input().split()
A43, A53, A63 = input().split()
A = input()
A71, A81, A91 = input().split()
A72, A82, A92 = input().split()
A73, A83, A93 = input().split()
A1 = A11 + A12 + A13
A2 = A21 + A22 + A23
A3 = A31 + A32 + A33
A4 = A41 + A42 + A43
A5 = A51 + A52 + A53
A6 = A61 + A62 + A63
A7 = A71 + A72 + A73
A8 = A81 + A82 + A83
A9 = A91 + A92 + A93
AA = [A1, A2, A3, A4, A5, A6, A7, A8, A9]
x, y = map(int, input().split())
if 0 < x < 4:
A = [1, 2, 3]
elif 3 < x < 7:
A = [4, 5, 6]
elif 6 < x < 10:
A = [7, 8, 9]
if 0 < y < 4:
B = [1, 4, 7]
elif 3 < y < 7:
B = [2, 5, 8]
elif 6 < y < 10:
B = [3, 6, 9]
for i in A:
if i in B:
C = i
#print(C)
if C == 2:
x -= 0
y -= 3
if C == 3:
x -= 0
y -= 6
if C == 4:
x -= 3
y -= 0
if C == 5:
x -= 3
y -= 3
if C == 6:
x -= 3
y -= 6
if C == 7:
x -= 6
y -= 0
if C == 8:
x -= 6
y -= 3
if C == 9:
x -= 6
y -= 6
#print(x, y)
if x == 1:
A = [1, 2, 3]
elif x == 2:
A = [4, 5, 6]
elif x == 3:
A = [7, 8, 9]
if y == 1:
B = [1, 4, 7]
elif y == 2:
B = [2, 5, 8]
elif y == 3:
B = [3, 6, 9]
for i in A:
if i in B:
C1 = i
#print(C1)
k = 0
V = ['!']
for i in range(len(AA[C1 - 1])):
if AA[C1 - 1][i] == '.':
k += 1
AA[C1 - 1] = AA[C1 - 1][:i] + '!' + AA[C1 - 1][i+1 :]
if k == 0:
for i in range(0, 9):
for j in range(len(AA[i])):
if AA[i][j] == '.':
AA[i] = AA[i][:j] + '!' + AA[i][j+1:]
print(''.join(map(str, AA[0][0:3])), ''.join(map(str, AA[1][0:3])), ''.join(map(str, AA[2][0:3])))
print(''.join(map(str, AA[0][3:6])), ''.join(map(str, AA[1][3:6])), ''.join(map(str, AA[2][3:6])))
print(''.join(map(str, AA[0][6:])), ''.join(map(str, AA[1][6:])), ''.join(map(str, AA[2][6:])))
print('')
print(''.join(map(str, AA[3][0:3])), ''.join(map(str, AA[4][0:3])), ''.join(map(str, AA[5][0:3])))
print(''.join(map(str, AA[3][3:6])), ''.join(map(str, AA[4][3:6])), ''.join(map(str, AA[5][3:6])))
print(''.join(map(str, AA[3][6:])), ''.join(map(str, AA[4][6:])), ''.join(map(str, AA[5][6:])))
print('')
print(''.join(map(str, AA[6][0:3])), ''.join(map(str, AA[7][0:3])), ''.join(map(str, AA[8][0:3])))
print(''.join(map(str, AA[6][3:6])), ''.join(map(str, AA[7][3:6])), ''.join(map(str, AA[8][3:6])))
print(''.join(map(str, AA[6][6:])), ''.join(map(str, AA[7][6:])), ''.join(map(str, AA[8][6:]))) | 8 | PYTHON3 |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
const static int tx[] = {0,1,1,1,0,-1,-1,-1};
const static int ty[] = {-1,-1,0,1,1,1,0,-1};
static const double EPS = 1e-12;
int main(){
string ref,target;
while(cin >> ref >> target){
set<string> visited;
bool isok = false;
for(int l=0;l<ref.size();l++){
for(int r=l;r<ref.size();r++){
const string str = ref.substr(l,r-l+1);
if(str.size() != target.size()) continue;
bool tmp_isok = true;
for(int i=0;i<target.size();i++){
if(target[i] == '_') continue;
if(str[i] != target[i]){
tmp_isok = false;
}
}
if(tmp_isok){
isok = true;
goto found;
}
}
}
found:
printf("%s\n",isok ? "Yes" : "No");
}
}
| 0 | CPP |
a, b, c, d = map(int, input().split())
misha = max(3 * a // 10, a - (a//250) * c)
vasha = max(3 * b // 10, b - (b//250) * d)
if misha > vasha: print("Misha")
elif vasha > misha: print("Vasya")
else: print("Tie") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int i, j, k;
while (cin >> n) {
for (i = n / 2; i >= 1; i--) {
for (j = 1; j <= i; j++) cout << "*";
for (j = 1; j <= n - 2 * i; j++) cout << "D";
for (j = 1; j <= i; j++) cout << "*";
cout << endl;
}
for (j = 0; j < n; j++) cout << "D";
cout << endl;
for (i = 1; i <= n / 2; i++) {
for (j = 1; j <= i; j++) cout << "*";
for (j = 1; j <= n - 2 * i; j++) cout << "D";
for (j = 1; j <= i; j++) cout << "*";
cout << endl;
}
}
return 0;
}
| 7 | CPP |
n = int(input())
a = [list(int(a) for a in input().split()) for i in range(n)]
count = 0
for x,y in a:
l , r , t , b = 0,0,0,0
for xx,yy in a:
if x == xx:
if yy > y: t = 1
if yy < y: b = 1
if y == yy:
if xx > x: r = 1
if xx < x: l = 1
if l and r and t and b: count += 1
print(count) | 7 | PYTHON3 |
import heapq
t=int(input())
for i in range(t):
n=int(input())
b=[0]*(n)
l=[(-n,0)]
heapq.heapify(l)
s=1
while(l!=[]):
p,i=heapq.heappop(l)
p=-p
if p%2==0:
r=p//2-1
else:
r=p//2
if b[i+r]==0:
b[i+r]=s
if p>1:
if p%2!=0:
heapq.heappush(l,((1-p)//2,i))
heapq.heappush(l,((1 - p) // 2,i+r+1))
else:
heapq.heappush(l, (-(p//2-1) ,i))
heapq.heappush(l, (-(p//2), i + r + 1))
s+=1
print(*b)
| 10 | PYTHON3 |
P = 10**9 + 7
def even_sum(k):
return ((k % P)*((k+1) % P)) % P
def odd_sum(k):
return ((k % P)*(k % P)) % P
def find_sum(n):
d = 1
i = 0
o = 1
evens = 0
odds = 0
while True:
i += d
if o:
odds += d
else:
evens += d
if i >= n:
if o:
odds -= (i-n)
else:
evens -= (i-n)
break
o ^= 1
d <<= 1
return (odd_sum(odds) + even_sum(evens))%P
l, r = list(map(int, input().strip().split()))
l = find_sum(l-1)
r = find_sum(r)
v = r - l
print(v%P)
| 9 | PYTHON3 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<vector>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read(){
ll f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
//**********head by yjjr**********
#define pb push_back
#define inf 1e9
template<class T>void vnique(vector<T> &r){sort(r.begin(),r.end());auto t=unique(r.begin(),r.end());r.erase(t,r.end());}
const int maxn=66,maxm=1e6+6,dx[4]={-1,1,0,0},dy[4]={0,0,-1,1},mod=1e9+7;
struct node{int x,y;}a[maxn<<1],que[maxn*maxn*8];
int n,m,K,ans,lx,ly,cnt[maxn][maxn],s1[maxm],s2[maxm],dis[maxn][maxn],head,tail;
bool fb[maxn][maxn],mark1[maxm],mark2[maxm];
vector<int>px,py;
void bfs(int x,int y){
rep(i,0,lx)rep(j,0,ly)dis[i][j]=inf;
dis[x][y]=0;que[head=tail=1]=(node){x,y};
while(head<=tail){
int nx=que[head].x,ny=que[head++].y;
rep(i,0,3){
int nex=nx+dx[i],ney=ny+dy[i];
if(nex>lx||nex<0||ney>ly||ney<0||dis[nex][ney]<=dis[nx][ny]+1||fb[nex][ney])continue;
dis[nex][ney]=dis[nx][ny]+1;que[++tail]=(node){nex,ney};
}
}
}
int main()
{
n=read(),m=read(),K=read();
px.pb(1);px.pb(n+1);py.pb(1);py.pb(m+1);
rep(i,1,n)s1[i]=m;
rep(i,1,m)s2[i]=n;
rep(i,1,K){
a[i].x=read()+1,a[i].y=read()+1;
px.pb(a[i].x),px.pb(a[i].x+1);
py.pb(a[i].y),py.pb(a[i].y+1);
s1[a[i].x]--,mark1[a[i].x]=1;
s2[a[i].y]--,mark2[a[i].y]=1;
}
rep(i,1,n)s1[i]=(s1[i]+s1[i-1])%mod;
rep(i,1,m)s2[i]=(s2[i]+s2[i-1])%mod;
rep(i,1,n-1)if(!mark1[i]&&!mark1[i+1])ans=(ans+1ll*2*s1[i]*(s1[n]-s1[i]))%mod;
rep(i,1,m-1)if(!mark2[i]&&!mark2[i+1])ans=(ans+1ll*2*s2[i]*(s2[m]-s2[i]))%mod;
vnique(px);vnique(py);lx=px.size()-2;ly=py.size()-2;
rep(i,1,K)
fb[lower_bound(px.begin(),px.end(),a[i].x)-px.begin()][lower_bound(py.begin(),py.end(),a[i].y)-py.begin()]=1;
rep(i,0,lx)rep(j,0,ly)cnt[i][j]=1ll*(px[i+1]-px[i])*(py[j+1]-py[j])%mod;
rep(i,0,lx)rep(j,0,ly)
if(!fb[i][j]){
bfs(i,j);
rep(k,0,lx)rep(p,0,ly)
if(!fb[k][p])ans=(ans+1ll*cnt[i][j]*dis[k][p]%mod*cnt[k][p])%mod;
}
ans=(ans+mod)%mod;ans=1ll*ans*(mod/2+1)%mod;
cout<<ans<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<vector<long long> > A(n, vector<long long>(m, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> A[i][j];
}
}
long long ans = 0;
for (long long i = 0; i < (n + 1) / 2; i++) {
for (long long j = 0; j < (m + 1) / 2; j++) {
long long temp = 0, av = 1e10;
if (i != n - i - 1) {
if (j != m - 1 - j) {
vector<long long> P(4);
P[0] = A[i][j];
P[1] = A[i][m - 1 - j];
P[2] = A[n - 1 - i][j];
P[3] = A[n - 1 - i][m - 1 - j];
for (long long p = 0; p < 4; p++) {
long long inc = 0;
for (long long q = 0; q < 4; q++) {
inc += abs(P[p] - P[q]);
}
av = min(av, inc);
}
ans += av;
} else {
temp = abs(A[i][j] - A[n - 1 - i][j]);
ans += temp;
}
} else {
if (j != m - 1 - j) {
temp = abs(A[i][j] - A[i][m - 1 - j]);
ans += temp;
}
}
}
}
cout << ans << '\n';
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 10000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int mod = 1000000007;
long long a[5003];
long long power(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
int main() {
init();
int n = readint();
long long k = readint(), ans = 1;
a[0] = 1;
for (int i = 1; i <= n; i++) {
long long x = readint();
ans = ans * x % mod;
for (int j = i - 1; j >= 0; j--) {
a[j + 1] = (a[j + 1] - a[j]) % mod;
a[j] = a[j] * x % mod;
}
}
long long now = 1, pw = 1;
long long inv = power(n, mod - 2);
for (int i = 0; i <= n; i++) {
ans = (ans - now * pw % mod * a[i]) % mod;
now = now * (k - i) % mod;
pw = pw * inv % mod;
}
printf("%lld", (ans % mod + mod) % mod);
}
| 11 | CPP |
s = input()
t = 0
c = 0
for i in range(len(s)):
if s[i] == "W":
t += i
c += 1
print(t-c*(c-1)//2) | 0 | PYTHON3 |
n = int(input())
lst = list(map(int, input().split()))
ans = 0
cnt = 0
if n == 1:
if lst[0] > 15:
ans = 15
else:
ans = lst[0] + 15
else:
for i in range(0, len(lst)-1):
if lst[0] > 15:
ans = 15
break
else:
dura = lst[i+1] - lst[i]
#print(dura)
if dura > 15:
ans = lst[i] + 15
break
else:
cnt += 1
if cnt == n - 1:
ans = lst[n-1] + 15
if ans > 90:
ans = 90
print(ans)
else:
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int table[1000][1000];
int main() {
int k = 0;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &table[i][j]);
}
}
while (k) {
char command;
int x, y;
scanf(" %c %d %d", &command, &x, &y);
if (command == 'g')
printf("%d\n", table[x - 1][y - 1]);
else if (command == 'c')
for (int i = 0; i < n; ++i) swap(table[i][x - 1], table[i][y - 1]);
else
for (int i = 0; i < m; ++i) swap(table[x - 1][i], table[y - 1][i]);
k--;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int prime[1000000];
void seive() {
int n_prime = 1000000;
fill_n(prime, n_prime, 1);
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i * i <= n_prime; i++) {
if (prime[i]) {
for (int j = i * i; j <= n_prime; j += i) {
prime[j] = 0;
}
}
}
}
bool fun_check(int x, int y, int n) {
if (x >= 0 && x < n && y >= 0 && y < n) {
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
char c;
std::cin >> n;
vector<vector<int> > v;
for (int i = 0; i < n; i++) {
vector<int> temp(n, 0);
v.push_back(temp);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
std::cin >> c;
if (c == 'o') {
if (fun_check(i, j + 1, n)) {
v[i][j + 1]++;
}
if (fun_check(i, j - 1, n)) {
v[i][j - 1]++;
}
if (fun_check(i + 1, j, n)) {
v[i + 1][j]++;
}
if (fun_check(i - 1, j, n)) {
v[i - 1][j]++;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (v[i][j] % 2 != 0) {
std::cout << "NO" << '\n';
return 0;
}
}
}
std::cout << "YES" << '\n';
return 0;
}
| 7 | CPP |
q=int(input())
a=list(map(int,input().split()))
s={}
for i in range(0,q):
s[a[i]]=i
d=min(s.values())
for i in s:
if s[i]==d:
print(i)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int lst, x;
long long ret, cnt;
while (cin >> n) {
cin >> lst;
cnt = 1, ret = 0;
for (int i = 0; i < n - 1; i++) {
cin >> x;
if (x == lst)
cnt++;
else
ret += cnt * (cnt + 1) / 2, lst = x, cnt = 1;
}
ret += cnt * (cnt + 1) / 2;
cout << ret << endl;
}
return 0;
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;cin >> a >> b;
cout << (a*b%2?"Odd":"Even");
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t;
cin >> n >> m;
if (m < n - 1) {
cout << -1;
return 0;
}
t = m / 2;
if (t * 2 < m) ++t;
if (n < t - 1) {
cout << -1;
return 0;
}
if (m == n - 1) {
cout << "0";
--n;
}
while (m > n) {
for (int i = 0; i < 2 && m > 0; i++) {
cout << "1";
--m;
}
if (n > 0) {
cout << "0";
--n;
}
if (m <= 0 && n <= 0) break;
}
while (n >= m) {
if (m > 0) {
cout << "1";
--m;
}
if (n > 0) {
cout << "0";
--n;
}
if (m <= 0 && n <= 0) break;
}
return 0;
}
| 9 | CPP |
import itertools
n=int(input())
m=list("MARCH")
d=[0]*5
for i in range(n):
s=input()
for j in range(len(m)):
if s[0]==m[j]:
d[j]+=1
ans=0
for i in list(itertools.combinations(list(range(5)), 3)):
k=list(i)
ans+=d[k[0]]*d[k[1]]*d[k[2]]
print(ans) | 0 | PYTHON3 |
N = int(input())
red = [list(map(int, input().split(' '))) for _ in range(N)]
blue = [list(map(int, input().split(' '))) for _ in range(N)]
red.sort(key=lambda x: x[1], reverse=True)
blue.sort(key=lambda x: x[0])
ans = 0
for b in blue:
for r in red:
if r[1] < b[1] and r[0] < b[0]:
ans += 1
red.remove(r)
break
print(ans) | 0 | PYTHON3 |
str1=input()
list3=[]
s=''
for i in range(0,len(str1),2):
list3.append(str1[i])
list3.sort()
for i in range(1,len(list3)*2-1,2):
list3.insert(i,'+')
k=s.join(list3)
print(k)
| 7 | PYTHON3 |
n, a, b = map(lambda x: int(x), input().split())
t = []
for i in range(n):
temp = int(input())
if temp < a or temp >= b:
t.append(temp)
print(len(t)) | 0 | PYTHON3 |
for _ in range(0,int(input())):
x,n,m=list(map(int,input().split()))
while x>20 and n!=0:
x=(x//2) +10
n-=1
while m!=0:
x=x-10
m-=1
if x<=0:
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[70][70][2][2];
bool vis[70][70][2][2] = {0};
int n = 60;
int test(long long int second, int i) {
if (second & (1LL << i)) return 1;
return 0;
}
long long int second, x;
long long int rec(int i, int c, bool inc1, bool inc2) {
if (i == n) {
if (c == 0 and inc1 and inc2) return 1;
return 0;
}
if (vis[i][c][inc1][inc2]) return dp[i][c][inc1][inc2];
vis[i][c][inc1][inc2] = 1;
long long int &ret = dp[i][c][inc1][inc2];
ret = 0;
if (x & (1LL << i)) {
if ((c + 1) % 2 == test(second, i)) {
ret += rec(i + 1, (c + 1) / 2, inc1, 1);
ret += rec(i + 1, (c + 1) / 2, 1, inc2);
}
} else {
if (c % 2 == test(second, i)) {
ret += rec(i + 1, c / 2, inc1, inc2);
}
if ((c + 2) % 2 == test(second, i)) {
ret += rec(i + 1, (c + 2) / 2, 1, 1);
}
}
return ret;
}
int main() {
cin >> second >> x;
cout << rec(0, 0, 0, 0);
}
| 8 | CPP |
t=int(input())
for i in range(t):
x=-1
sum=0
y=0
a=int(input())
while(a>=2):
while(sum<=a):
x=x+3
sum=sum+x
sum=sum-x
a=a-sum
y=y+1
x=-1
sum=0
print(y) | 8 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
lst=[int(i) for i in input().split()]
lst.sort(reverse=True)
for i in lst:
print(i,end=' ')
print()
| 8 | PYTHON3 |
k= int(input())
n= input()
l= []
sum= 0
for i in n:
sum+= int(i)
l.append(int(i))
l.sort()
counter= 0
for i in l:
if(sum >= k):
break
sum+= (9- i)
counter+= 1
print(counter) | 8 | PYTHON3 |
n,m=map(int,input().split())
temp=n-m+1
kmax = ((temp-1)*temp)-((temp*(temp-1))//2)
a=n//m
kmin=m*a*(a-1)//2 + a*(n%m)
if(m==1):
print(kmax,kmax)
else:
print(kmin,kmax) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
int main() {
long long int t = 1, n, m, i, j, k, sum = 0, ans = 0;
string s;
cin >> n >> m;
cout << 100003 << " " << 100003 << "\n";
for (i = 1; i < n - 1; i++) {
cout << i << " " << i + 1 << " 1\n";
}
cout << n - 1 << " " << n << " " << (100003 - (n - 2)) << "\n";
m = m - (n - 1);
for (i = 1; i < n; i++) {
for (j = i + 2; j <= n; j++) {
if (!m) break;
cout << i << " " << j << " " << 100003 << "\n";
m--;
}
if (!m) break;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 10;
const long long INF = 100000000000LL;
long long sum[maxn], sumfu[maxn];
bool vis[maxn];
struct node {
int id;
int v;
bool operator<(const node& a1) const {
if (a1.v == v) return id < a1.id;
return v < a1.v;
}
} a[maxn];
set<int> ans;
set<int>::iterator it;
int main() {
int n;
while (scanf("%d", &n) != EOF) {
ans.clear();
memset(vis, 0, sizeof(vis));
a[0].v = 0;
sum[0] = sumfu[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
a[i].id = i;
sum[i] = sum[i - 1] + a[i].v;
sumfu[i] = sumfu[i - 1];
if (a[i].v < 0) sumfu[i] += a[i].v;
}
sort(a + 1, a + 1 + n);
int st = -1, ed = -1;
long long res = -INF;
for (int i = 1; i <= n; i++) {
int j;
for (j = i + 1; j <= n; j++)
if (a[j].v != a[i].v) break;
j--;
if (a[i].v == a[j].v && j > i) {
if (st == -1 && ed == -1) {
res = sum[a[j].id] - sum[a[i].id - 1];
res -= sumfu[a[j].id - 1] - sumfu[a[i].id];
st = a[i].id;
ed = a[j].id;
} else {
long long t1 = sum[a[j].id] - sum[a[i].id - 1];
t1 -= sumfu[a[j].id - 1] - sumfu[a[i].id];
if (res < t1) {
res = t1;
st = a[i].id;
ed = a[j].id;
}
}
}
i = j;
}
int con = 0;
for (int i = 1; i <= n; i++) {
if (a[i].id < st) vis[i] = 1;
if (a[i].id > ed) vis[i] = 1;
if (a[i].id < ed && a[i].id > st && a[i].v < 0) vis[i] = 1;
if (vis[i] == 1) {
ans.insert(a[i].id);
con++;
}
}
printf("%I64d %d\n", res, con);
if (con > 0) {
for (it = ans.begin(); it != ans.end(); it++) {
printf("%d ", *it);
}
}
printf("\n");
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
int n;
vector<int> edges[1 << N];
int P[1 << N];
int iP[1 << N];
int dist[1 << N];
void bfs() {
for (int i = 0; i < 1 << n; ++i) {
dist[i] = -1;
P[i] = iP[i] = 0;
}
queue<int> q;
q.push(0);
P[0] = 0; dist[0] = 0; iP[0] = 0;
for (int i = 0; i < n; ++i) {
iP[edges[0][i]] = 1 << i;
}
while (q.size()) {
int u = q.front();
q.pop();
P[iP[u]] = u;
for (int v : edges[u]) {
if (dist[v] == dist[u] + 1 || dist[v] == -1) {
iP[v] |= iP[u];
}
if (dist[v] != -1) continue;
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
int solve() {
scanf("%d", &n);
for (int i = 0; i < 1 << n; ++i) edges[i].clear();
for (int i = 0; i < n * (1 << (n - 1)); ++i) {
int u, v;
scanf("%d %d", &u, &v);
edges[u].push_back(v);
edges[v].push_back(u);
}
bfs();
for (int i = 0; i < 1 << n; ++i) printf("%d ", P[i]);
printf("\n");
if (n != 1 && n != 2 && n != 4 && n != 8 && n != 16) return 0 * printf("-1\n");
for (int i = 0; i < 1 << n; ++i) {
int x = iP[i];
int col = 0;
for (int len = 1; len < n; len <<= 1) {
int bit = 0;
for (int j = 0; j < n; j += len << 1) {
for (int k = j; k < j + len; ++k) {
bit ^= x >> k & 1;
}
}
if (bit) col |= len;
}
printf("%d ", col);
}
printf("\n");
return 0;
}
int main() {
int t = 1;
scanf("%d", &t);
for (int tc = 0; tc < t; ++tc) {
// printf("Case #%d: ", tc+1);
solve();
}
return 0;
}
| 11 | CPP |